From e51c4764dac47ef9b4734c38724c4ff9d30bf911 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 6 Dec 2023 13:15:06 +0100 Subject: [PATCH 01/39] fix parallel builds for coveralls --- .github/workflows/ci.yml | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index d7cb7570..b2c570fd 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -44,4 +44,14 @@ jobs: - name: Publish to coveralls.io uses: coverallsapp/github-action@v2 with: + parallel: true github-token: ${{ secrets.GITHUB_TOKEN }} + + finish: + needs: test + runs-on: ubuntu-latest + steps: + - name: Close parallel build + uses: coverallsapp/github-action@v2 + with: + parallel-finished: true From f9841e45b009309e60795cbeb89126d345dd99d4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 6 Dec 2023 13:27:01 +0100 Subject: [PATCH 02/39] get rid of extra github icon --- docs/conf.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/docs/conf.py b/docs/conf.py index 24306d2f..e650f89a 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -49,14 +49,14 @@ "github_url": "https://github.com/mbakker7/timml", "use_edit_page_button": True, "header_links_before_dropdown": 6, - "icon_links": [ - { - "name": "GitHub", # Label for this link - "url": "https://github.com/mbakker7/timml", # required - "icon": "fab fa-github-square", - "type": "fontawesome", # Default is fontawesome - } - ], + # "icon_links": [ + # { + # "name": "GitHub", # Label for this link + # "url": "https://github.com/mbakker7/timml", # required + # "icon": "fab fa-github-square", + # "type": "fontawesome", # Default is fontawesome + # } + # ], } html_context = { From e042776962f37413b635c9e45cd7a61ecc9472c3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Fri, 29 Dec 2023 11:48:33 +0100 Subject: [PATCH 03/39] add Model.elements attribute - all user-added elements are added to this list - Model.elementlist is reserved for computation elements --- timml/model.py | 23 ++++++++++++++++------- 1 file changed, 16 insertions(+), 7 deletions(-) diff --git a/timml/model.py b/timml/model.py index 2dc2952c..5a533c8c 100644 --- a/timml/model.py +++ b/timml/model.py @@ -48,29 +48,38 @@ class Model(PlotTim): def __init__(self, kaq, c, z, npor, ltype): # All input variables are numpy arrays # That should be checked outside this function - self.elementlist = [] + self.elements = [] # elements added by user + self.elementlist = [] # computation elements self.elementdict = {} # only elements that have a label self.aq = Aquifer(self, kaq, c, z, npor, ltype) self.modelname = "ml" # Used for writing out input def initialize(self): + elementlist = [] + for e in self.elements: + # refine + if hasattr(e, "_refine") and e.refine: + refined_elements = e._refine() + elementlist += refined_elements + else: + elementlist.append(e) + # remove inhomogeneity elements (they are added again) - self.elementlist = [e for e in self.elementlist if not e.inhomelement] + self.elementlist = [e for e in elementlist if not e.inhomelement] self.aq.initialize() for e in self.elementlist: e.initialize() def add_element(self, e): - self.elementlist.append(e) + self.elements.append(e) if e.label is not None: self.elementdict[e.label] = e def remove_element(self, e): """Remove element `e` from model""" - if e.label is not None: self.elementdict.pop(e.label) - self.elementlist.remove(e) + self.elements.remove(e) def storeinput(self, frame): self.inputargs, _, _, self.inputvalues = inspect.getargvalues(frame) @@ -540,7 +549,7 @@ def solve_mp(self, nproc=4, printmat=0, sendback=0, silent=False): return def write(self): - rv = self.modelname + " = " + self.name + "(\n" + rv = "tml." + self.modelname + " = " + self.name + "(\n" for key in self.inputargs[1:]: # The first argument (self) is ignored if isinstance(self.inputvalues[key], np.ndarray): rv += ( @@ -559,7 +568,7 @@ def write(self): def writemodel(self, fname): self.initialize() # So that the model can be written without solving first f = open(fname, "w") - f.write("from timml import *\n") + f.write("import timml as tml\n") f.write(self.write()) for e in self.elementlist: f.write(e.write()) From a041dde65776d0f1411cdb7b0b554aa583ff1a52 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 3 Jan 2024 16:44:03 +0100 Subject: [PATCH 04/39] add general refine functions: - move compute_z1z2 to util.py - add refine_n_segments --- timml/util.py | 71 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 71 insertions(+) diff --git a/timml/util.py b/timml/util.py index 00a40d84..ee049518 100644 --- a/timml/util.py +++ b/timml/util.py @@ -370,3 +370,74 @@ def vcontoursf1D( return ax # if layout: # self.plot(win=[x1, x2, y1, y2], orientation='ver', newfig=False) + + +def compute_z1z2(xy): + # Returns z1 and z2 of polygon, in clockwise order + x, y = list(zip(*xy)) + if x[0] == x[-1] and y[0] == y[-1]: # In case last point is repeated + x = x[:-1] + y = y[:-1] + z1 = np.array(x) + np.array(y) * 1j + index = list(range(1, len(z1))) + [0] + z2 = z1[index] + Z = 1e-6j + z = Z * (z2[0] - z1[0]) / 2.0 + 0.5 * (z1[0] + z2[0]) + bigZ = (2.0 * z - (z1 + z2)) / (z2 - z1) + bigZmin1 = bigZ - 1.0 + bigZplus1 = bigZ + 1.0 + angle = np.sum(np.log(bigZmin1 / bigZplus1).imag) + if angle < np.pi: # reverse order + z1 = z1[::-1] + z2 = z1[index] + return z1, z2 + + +def refine_n_segments(xy, shape_type, n_segments): + """Refine line segments into n_segments each. + + Use controlpoints half-circle approach to determine new segment lengths. + + Parameters + ---------- + xy : list of tuple or np.array + list of coordinates or 2d-array containing x-coordinates in the first column + and y-coordinates in the second column + shape_type : str + shape type, either "line" or "polygon". + n_segments : int + number of segments to split each line segment into. + + Returns + ------- + xynew : np.array + array containing refined coordinates + reindexer : np.array + array containing index to original line segment, useful for obtaining element + parameters from original input. + """ + + if shape_type == "polygon": + z1, z2 = compute_z1z2(xy) + elif shape_type == "line": + z = xy[:, 0] + 1j * xy[:, 1] + z1 = z[:-1] + z2 = z[1:] + else: + raise ValueError("shptype must be one of 'polygon' or 'line'.") + xpts = [] + ypts = [] + reindexer = [] + for i in range(len(z1)): + xcpi, ycpi = controlpoints(n_segments - 1, z1[i], z2[i], include_ends=True) + if i < len(z1) - 1: + xpts.append(xcpi[:-1]) + ypts.append(ycpi[:-1]) + else: + xpts.append(xcpi) + ypts.append(ycpi) + reindexer.append(i * np.ones(len(xcpi[:-1]), dtype=int)) + return ( + np.vstack([np.concatenate(xpts), np.concatenate(ypts)]).T, + np.concatenate(reindexer), + ) From 0956e409eb54ecd1573624ea2ae6ebe70891f518 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 3 Jan 2024 16:44:27 +0100 Subject: [PATCH 05/39] add general refine functions: - move compute_z1z2 to util.py - add refine_n_segments --- timml/util.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/timml/util.py b/timml/util.py index ee049518..2186511c 100644 --- a/timml/util.py +++ b/timml/util.py @@ -2,7 +2,8 @@ import numpy as np from matplotlib.collections import LineCollection -from .trace import timtraceline, timtracelines +from .controlpoints import controlpoints +from .trace import timtraceline plt.rcParams["contour.negative_linestyle"] = "solid" From 8d4999df7684dee8fb6ee64f722f5f900d9c3bdb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 3 Jan 2024 16:45:30 +0100 Subject: [PATCH 06/39] add addtomodel kwarg to StripAreaSink classes --- timml/stripareasink.py | 24 ++++++++++++++---------- 1 file changed, 14 insertions(+), 10 deletions(-) diff --git a/timml/stripareasink.py b/timml/stripareasink.py index d54c7feb..1a28dfa0 100644 --- a/timml/stripareasink.py +++ b/timml/stripareasink.py @@ -1,5 +1,3 @@ -import inspect # Used for storing the input - import numpy as np from .element import Element @@ -32,6 +30,7 @@ def __init__( layer=0, name="StripAreaSink", label=None, + addtomodel=True, ): Element.__init__( self, model, nparam=1, nunknowns=0, layers=layer, name=name, label=label @@ -39,7 +38,9 @@ def __init__( self.xleft = xleft self.xright = xright self.N = N - self.model.add_element(self) + self.addtomodel = addtomodel + if self.addtomodel: + self.model.add_element(self) def __repr__(self): return self.name + " between " + str((self.xleft, self.xright)) @@ -118,9 +119,9 @@ def changetrace( u = u1 * (1.0 + eps) # Go just beyond circle else: u = u2 * (1.0 + eps) # Go just beyond circle - xn = x1 + u * (x2 - x1) - yn = y1 + u * (y2 - y1) - zn = xyzt1[2] + u * (xyzt2[2] - xyzt1[2]) + # xn = x1 + u * (x2 - x1) + # yn = y1 + u * (y2 - y1) + # zn = xyzt1[2] + u * (xyzt2[2] - xyzt1[2]) xyztnew = xyzt1 + u * (xyzt2 - xyzt1) return changed, terminate, xyztnew, message @@ -135,6 +136,7 @@ def __init__( layer=0, name="StripAreaSink", label=None, + addtomodel=True, ): Element.__init__( self, model, nparam=1, nunknowns=0, layers=layer, name=name, label=label @@ -142,7 +144,9 @@ def __init__( self.xleft = xleft self.xright = xright self.N = N - self.model.add_element(self) + self.addtomodel = addtomodel + if self.addtomodel: + self.model.add_element(self) def __repr__(self): return self.name + " at " + str((self.xc, self.yc)) @@ -248,8 +252,8 @@ def changetrace( u = u1 * (1.0 + eps) # Go just beyond circle else: u = u2 * (1.0 + eps) # Go just beyond circle - xn = x1 + u * (x2 - x1) - yn = y1 + u * (y2 - y1) - zn = xyzt1[2] + u * (xyzt2[2] - xyzt1[2]) + # xn = x1 + u * (x2 - x1) + # yn = y1 + u * (y2 - y1) + # zn = xyzt1[2] + u * (xyzt2[2] - xyzt1[2]) xyztnew = xyzt1 + u * (xyzt2 - xyzt1) return changed, terminate, xyztnew, message From f05360718d849c9a62a53c92998a040828773a73 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 3 Jan 2024 16:49:22 +0100 Subject: [PATCH 07/39] Add logic to refine elements in initialize in model class + some minor style fixes --- timml/model.py | 28 +++++++++++++++------------- 1 file changed, 15 insertions(+), 13 deletions(-) diff --git a/timml/model.py b/timml/model.py index 4fd0073d..927508af 100644 --- a/timml/model.py +++ b/timml/model.py @@ -5,7 +5,6 @@ import inspect # Used for storing the input import multiprocessing as mp -import sys import numpy as np from scipy.integrate import quad_vec @@ -54,19 +53,22 @@ def __init__(self, kaq, c, z, npor, ltype): self.aq = Aquifer(self, kaq, c, z, npor, ltype) self.modelname = "ml" # Used for writing out input - def initialize(self): + def initialize(self, refine_level=None): elementlist = [] for e in self.elements: # refine - if hasattr(e, "_refine") and e.refine: - refined_elements = e._refine() - elementlist += refined_elements + if hasattr(e, "_refine") and ( + e.refine_level > 1 or refine_level is not None + ): + refined_element = e._refine(n=refine_level) + elementlist += refined_element else: elementlist.append(e) # remove inhomogeneity elements (they are added again) self.elementlist = [e for e in elementlist if not e.inhomelement] - self.aq.initialize() + self.aq.initialize(refine_level=refine_level) + # now initialize all computation elements for e in self.elementlist: e.initialize() @@ -135,9 +137,9 @@ def normflux(self, x, y, theta): sinnorm = np.sin(theta) return cosnorm * qxqy[0] + sinnorm * qxqy[1] - def _normflux_integrand(self, l, theta_norm, x1, y1): - x = l * np.cos(theta_norm - np.pi / 2) + x1 - y = l * np.sin(theta_norm - np.pi / 2) + y1 + def _normflux_integrand(self, s, theta_norm, x1, y1): + x = s * np.cos(theta_norm - np.pi / 2) + x1 + y = s * np.sin(theta_norm - np.pi / 2) + y1 return self.normflux(x, y, theta_norm) def intnormflux_segment(self, x1, y1, x2, y2, method="legendre", ndeg=10): @@ -214,8 +216,8 @@ def intnormflux(self, xy, method="legendre", ndeg=10): Total flow across polyline can be obtained using: >>> np.sum(Qn) - - Total flow across segments summed over aquifers using + + Total flow across segments summed over aquifers using >>> np.sum(Qn, axis=0) """ @@ -426,10 +428,10 @@ def velocomp(self, x, y, z, aq=None, layer_ltype=None): vy = qy[layer] / (aq.Haq[layer] * aq.nporaq[layer]) return np.array([vx, vy, vz]) - def solve(self, printmat=0, sendback=0, silent=False): + def solve(self, printmat=0, sendback=0, silent=False, refine_level=None): """Compute solution""" # Initialize elements - self.initialize() + self.initialize(refine_level=refine_level) # Compute number of equations self.neq = np.sum([e.nunknowns for e in self.elementlist]) if self.neq == 0: From d6a073c75a60782eb42d94982020a6e00f9d5c87 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 3 Jan 2024 16:49:53 +0100 Subject: [PATCH 08/39] add addtomodel kwarg to constant classes --- timml/constant.py | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/timml/constant.py b/timml/constant.py index 561d072f..f1e68f59 100644 --- a/timml/constant.py +++ b/timml/constant.py @@ -104,7 +104,7 @@ def setparams(self, sol): class ConstantInside(Element): # Sets constant at points xc, yc equal to the average of the potential of all elements at points xc, yc # Used for the inside of an inhomogeneity - def __init__(self, model, xc=0, yc=0, label=None): + def __init__(self, model, xc=0, yc=0, label=None, addtomodel=True): Element.__init__( self, model, @@ -117,7 +117,9 @@ def __init__(self, model, xc=0, yc=0, label=None): self.xc = np.atleast_1d(xc) self.yc = np.atleast_1d(yc) self.parameters = np.zeros((1, 1)) - self.model.add_element(self) + self.addtomodel = addtomodel + if self.addtomodel: + self.model.add_element(self) def __repr__(self): return self.name @@ -170,7 +172,7 @@ def setparams(self, sol): # class ConstantStar(Element, PotentialEquation): # I don't think we need the equation class ConstantStar(Element): - def __init__(self, model, hstar=0.0, label=None, aq=None): + def __init__(self, model, hstar=0.0, label=None, aq=None, addtomodel=True): Element.__init__( self, model, @@ -183,7 +185,9 @@ def __init__(self, model, hstar=0.0, label=None, aq=None): assert hstar is not None, "a value for hstar needs to be specified" self.hstar = hstar self.aq = aq - self.model.add_element(self) + self.addtomodel = addtomodel + if self.addtomodel: + self.model.add_element(self) def __repr__(self): return self.name + " with head " + str(self.hstar) From 31848ed8b63fd600cd4dc0651239e205ca7e6e69 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 3 Jan 2024 17:05:05 +0100 Subject: [PATCH 09/39] Add refine functionality to inhoms - add refine_level kwarg - add _refine method (using refine_n_segments for now) that returns new refined inhom - modify create_elements to return elements (instead of automatically adding to the model elementlist) - store user input in self._input for creating refined elements - add addtomodel kwarg to all inhoms --- timml/inhomogeneity.py | 267 +++++++++++++++++++++++++++++++---------- 1 file changed, 204 insertions(+), 63 deletions(-) diff --git a/timml/inhomogeneity.py b/timml/inhomogeneity.py index 8e4afd39..3aabb1f7 100644 --- a/timml/inhomogeneity.py +++ b/timml/inhomogeneity.py @@ -1,24 +1,42 @@ import inspect # Used for storing the input +from copy import deepcopy from warnings import warn import numpy as np -from .aquifer import AquiferData -from .aquifer_parameters import param_3d, param_maq -from .constant import ConstantInside, ConstantStar -from .element import Element -from .intlinesink import ( +from timml.aquifer import AquiferData +from timml.aquifer_parameters import param_3d, param_maq +from timml.constant import ConstantInside, ConstantStar +from timml.element import Element +from timml.intlinesink import ( IntFluxDiffLineSink, IntFluxLineSink, IntHeadDiffLineSink, LeakyIntHeadDiffLineSink, ) +from timml.util import compute_z1z2, refine_n_segments class PolygonInhom(AquiferData): tiny = 1e-8 - def __init__(self, model, xy, kaq, c, z, npor, ltype, hstar, N, order, ndeg): + def __init__( + self, + model, + xy, + kaq, + c, + z, + npor, + ltype, + hstar, + N, + order, + ndeg, + refine_level=1, + addtomodel=True, + ): + self._input = {k: v for k, v in locals().items() if k not in ["self", "model"]} # All input variables except model should be numpy arrays # That should be checked outside this function): AquiferData.__init__(self, model, kaq, c, z, npor, ltype) @@ -26,8 +44,11 @@ def __init__(self, model, xy, kaq, c, z, npor, ltype, hstar, N, order, ndeg): self.ndeg = ndeg self.hstar = hstar self.N = N - self.inhom_number = self.model.aq.add_inhom(self) - self.z1, self.z2 = compute_z1z2(xy) + self.addtomodel = addtomodel + if self.addtomodel: + self.inhom_number = self.model.aq.add_inhom(self) + self.xy = xy + self.z1, self.z2 = compute_z1z2(self.xy) self.Nsides = len(self.z1) Zin = 1e-6j Zout = -1e-6j @@ -45,6 +66,7 @@ def __init__(self, model, xy, kaq, c, z, npor, ltype, hstar, N, order, ndeg): self.xmax = max(self.x) self.ymin = min(self.y) self.ymax = max(self.y) + self.refine_level = refine_level def __repr__(self): return "PolygonInhom: " + str(list(zip(self.x, self.y))) @@ -74,12 +96,13 @@ def isinside(self, x, y): def create_elements(self): aqin = self.model.aq.find_aquifer_data(self.zcin[0].real, self.zcin[0].imag) + inhom_elements = [] for i in range(self.Nsides): aqout = self.model.aq.find_aquifer_data( self.zcout[i].real, self.zcout[i].imag ) if (aqout == self.model.aq) or (aqout.inhom_number > self.inhom_number): - ls = IntHeadDiffLineSink( + ls_in = IntHeadDiffLineSink( self.model, x1=self.x[i], y1=self.y[i], @@ -93,7 +116,7 @@ def create_elements(self): aqin=aqin, aqout=aqout, ) - ls = IntFluxDiffLineSink( + ls_out = IntFluxDiffLineSink( self.model, x1=self.x[i], y1=self.y[i], @@ -107,6 +130,7 @@ def create_elements(self): aqin=aqin, aqout=aqout, ) + inhom_elements += [ls_in, ls_out] if aqin.ltype[0] == "a": # add constant on inside c = ConstantInside(self.model, self.zcin.real, self.zcin.imag) c.inhomelement = True @@ -117,6 +141,21 @@ def create_elements(self): assert self.hstar is not None, "Error: hstar needs to be set" c = ConstantStar(self.model, self.hstar, aq=aqin) c.inhomelement = True + inhom_elements += [c] + return inhom_elements + + def _refine(self, n=None): + if n is None: + n = self.refine_level + xyr, _ = refine_n_segments(self.xy, "polygon", n_segments=n) + input_args = deepcopy(self._input) + cls = input_args.pop("__class__", self.__class__) + input_args["model"] = self.model + # overwrite some input args for refined element + input_args["xy"] = xyr + input_args["refine_level"] = 1 # set to 1 to prevent further refinement + input_args["addtomodel"] = False + return cls(**input_args) class PolygonInhomMaq(PolygonInhom): @@ -179,7 +218,10 @@ def __init__( N=None, order=3, ndeg=3, + refine_level=1, + addtomodel=True, ): + _input = {k: v for k, v in locals().items() if k not in ["self", "model"]} if N is not None: assert ( topboundary[:4] == "conf" @@ -192,8 +234,22 @@ def __init__( ltype, ) = param_maq(kaq, z, c, npor, topboundary) PolygonInhom.__init__( - self, model, xy, kaq, c, z, npor, ltype, hstar, N, order, ndeg + self, + model, + xy, + kaq, + c, + z, + npor, + ltype, + hstar, + N, + order, + ndeg, + refine_level=refine_level, + addtomodel=addtomodel, ) + self._input = _input class PolygonInhom3D(PolygonInhom): @@ -261,7 +317,10 @@ def __init__( N=None, order=3, ndeg=3, + refine_level=1, + addtomodel=True, ): + _input = {k: v for k, v in locals().items() if k not in ["self", "model"]} if N is not None: assert ( topboundary[:4] == "conf" @@ -271,29 +330,22 @@ def __init__( if topboundary == "semi": z = np.hstack((z[0] + topthick, z)) PolygonInhom.__init__( - self, model, xy, kaq, c, z, npor, ltype, hstar, N, order, ndeg + self, + model, + xy, + kaq, + c, + z, + npor, + ltype, + hstar, + N, + order, + ndeg, + refine_level=refine_level, + addtomodel=addtomodel, ) - - -def compute_z1z2(xy): - # Returns z1 and z2 of polygon, in clockwise order - x, y = list(zip(*xy)) - if x[0] == x[-1] and y[0] == y[-1]: # In case last point is repeated - x = x[:-1] - y = y[:-1] - z1 = np.array(x) + np.array(y) * 1j - index = list(range(1, len(z1))) + [0] - z2 = z1[index] - Z = 1e-6j - z = Z * (z2[0] - z1[0]) / 2.0 + 0.5 * (z1[0] + z2[0]) - bigZ = (2.0 * z - (z1 + z2)) / (z2 - z1) - bigZmin1 = bigZ - 1.0 - bigZplus1 = bigZ + 1.0 - angle = np.sum(np.log(bigZmin1 / bigZplus1).imag) - if angle < np.pi: # reverse order - z1 = z1[::-1] - z2 = z1[index] - return z1, z2 + self._input = _input class BuildingPit(AquiferData): @@ -312,6 +364,8 @@ def __init__( order=3, ndeg=3, layers=[0], + refine_level=1, + addtomodel=True, ): """Element to simulate a building pit with an impermeable wall. @@ -352,22 +406,32 @@ def __init__( ndeg : int number of points used between two segments to numerically integrate normal discharge - layers: list or np.array + layers : list or np.array layers in which impermeable wall is present. + refine_level : int, optional + refine element by partitioning each side into refine_level segments, default + is 1, which means no refinement is applied. """ + self._input = {k: v for k, v in locals().items() if k not in ["self", "model"]} AquiferData.__init__(self, model, kaq, c, z, npor, ltype) self.order = order self.ndeg = ndeg - + self.xy = xy self.layers = np.atleast_1d(layers) # layers with impermeable wall self.nonimplayers = list( set(range(self.model.aq.naq)) - set(self.layers) ) # layers without wall - self.hstar = hstar + self.refine_level = refine_level + self.addtomodel = addtomodel + if self.addtomodel: + self.inhom_number = self.model.aq.add_inhom(self) + + # compute derived params + self.compute_derived_params() - self.inhom_number = self.model.aq.add_inhom(self) - self.z1, self.z2 = compute_z1z2(xy) + def compute_derived_params(self): + self.z1, self.z2 = compute_z1z2(self.xy) self.Nsides = len(self.z1) Zin = 1e-6j Zout = -1e-6j @@ -386,10 +450,10 @@ def __init__( def __repr__(self): return ( - "BuildingPit: layers " + f"{self.__class__.__name__}: layers " + str(list(self.layers)) + ", " - + str(list(self.x, self.y)) + + str(list(zip(self.x, self.y))) ) def isinside(self, x, y): @@ -417,13 +481,14 @@ def isinside(self, x, y): def create_elements(self): aqin = self.model.aq.find_aquifer_data(self.zcin[0].real, self.zcin[0].imag) + inhom_elements = [] for i in range(self.Nsides): aqout = self.model.aq.find_aquifer_data( self.zcout[i].real, self.zcout[i].imag ) if (aqout == self.model.aq) or (aqout.inhom_number > self.inhom_number): # Conditions for layers with impermeable walls - IntFluxLineSink( + ils_in = IntFluxLineSink( self.model, x1=self.x[i], y1=self.y[i], @@ -438,7 +503,7 @@ def create_elements(self): aqin=aqin, aqout=aqout, ) - IntFluxLineSink( + ils_out = IntFluxLineSink( self.model, x1=self.x[i], y1=self.y[i], @@ -453,9 +518,11 @@ def create_elements(self): aqin=aqin, aqout=aqout, ) + inhom_elements += [ils_in, ils_out] + if len(self.nonimplayers) > 0: # use these conditions for layers without impermeable or leaky walls - IntHeadDiffLineSink( + ihdls_in = IntHeadDiffLineSink( self.model, x1=self.x[i], y1=self.y[i], @@ -470,7 +537,7 @@ def create_elements(self): aqin=aqin, aqout=aqout, ) - IntFluxDiffLineSink( + ihdls_out = IntFluxDiffLineSink( self.model, x1=self.x[i], y1=self.y[i], @@ -485,6 +552,7 @@ def create_elements(self): aqin=aqin, aqout=aqout, ) + inhom_elements += [ihdls_in, ihdls_out] if aqin.ltype[0] == "a": # add constant on inside c = ConstantInside(self.model, self.zcin.real, self.zcin.imag) @@ -493,6 +561,22 @@ def create_elements(self): assert self.hstar is not None, "Error: hstar needs to be set" c = ConstantStar(self.model, self.hstar, aq=aqin) c.inhomelement = True + inhom_elements += [c] + + return inhom_elements + + def _refine(self, n=None): + if n is None: + n = self.refine_level + xyr, _ = refine_n_segments(self.xy, "polygon", n_segments=n) + input_args = deepcopy(self._input) + cls = input_args.pop("__class__") + input_args["model"] = self.model + # overwrite some input args for refined element + input_args["xy"] = xyr + input_args["refine_level"] = 1 # set to 1 to prevent further refinement + input_args["addtomodel"] = False + return cls(**input_args) class BuildingPitMaq(BuildingPit): @@ -509,6 +593,8 @@ def __init__( order=3, ndeg=3, layers=[0], + refine_level=1, + addtomodel=True, ): """Element to simulate a building pit with an impermeable wall in ModelMaq. @@ -553,7 +639,11 @@ def __init__( integrate normal discharge layers: list or np.array layers in which impermeable wall is present. + refine_level : int, optional + refine element by splitting up each side into refine_level segments, default + is 1, which means no refinement is applied. """ + _input = {k: v for k, v in locals().items() if k not in ["self", "model"]} (kaq, c, npor, ltype) = param_maq(kaq, z, c, npor, topboundary) super().__init__( model=model, @@ -567,7 +657,10 @@ def __init__( order=order, ndeg=ndeg, layers=layers, + refine_level=refine_level, + addtomodel=addtomodel, ) + self._input = _input class BuildingPit3D(BuildingPit): @@ -586,6 +679,8 @@ def __init__( order=3, ndeg=3, layers=[0], + refine_level=1, + addtomodel=True, ): """Element to simulate a building pit with an impermeable wall in Model3D. @@ -632,7 +727,11 @@ def __init__( integrate normal discharge layers: list or np.array layers in which impermeable wall is present. + refine_level : int, optional + refine element by partitioning each side into refine_level segments, default + is 1, which means no refinement is applied. """ + _input = {k: v for k, v in locals().items() if k not in ["self", "model"]} (kaq, c, npor, ltype) = param_3d(kaq, z, kzoverkh, npor, topboundary, topres) if topboundary == "semi": z = np.hstack((z[0] + topthick, z)) @@ -648,7 +747,10 @@ def __init__( order=order, ndeg=ndeg, layers=layers, + refine_level=refine_level, + addtomodel=addtomodel, ) + self._input = _input class LeakyBuildingPit(BuildingPit): @@ -666,6 +768,8 @@ def __init__( ndeg=3, layers=[0], res=np.inf, + refine_level=1, + addtomodel=True, ): """Element to simulate a building pit with a leaky wall. @@ -712,8 +816,10 @@ def __init__( resistance of leaky wall, if passed as an array must be either shape (n_segments,) or (n_layers, n_segments). Default is np.inf, which simulates an impermeable wall. + refine_level : int, optional + refine element by partitioning each side into refine_level segments, default + is 1, which means no refinement is applied. """ - super().__init__( model, xy, @@ -726,7 +832,10 @@ def __init__( order=order, ndeg=ndeg, layers=layers, + refine_level=refine_level, + addtomodel=addtomodel, ) + self._input = {k: v for k, v in locals().items() if k not in ["self", "model"]} if isinstance(res, (int, float, np.integer)): # make 2D so indexing resistance works for all cases self.res = res * np.ones((1, self.Nsides)) @@ -748,23 +857,16 @@ def __init__( ) self.res[self.res < self.tiny] = self.tiny - def __repr__(self): - return ( - "LeakyBuildingPit: layers " - + str(list(self.layers)) - + ", " - + str(list(self.x, self.y)) - ) - def create_elements(self): aqin = self.model.aq.find_aquifer_data(self.zcin[0].real, self.zcin[0].imag) + inhom_elements = [] for i in range(self.Nsides): aqout = self.model.aq.find_aquifer_data( self.zcout[i].real, self.zcout[i].imag ) if (aqout == self.model.aq) or (aqout.inhom_number > self.inhom_number): # Conditions for layers with leaky walls - LeakyIntHeadDiffLineSink( + ilhdls_in = LeakyIntHeadDiffLineSink( self.model, x1=self.x[i], y1=self.y[i], @@ -775,13 +877,13 @@ def create_elements(self): order=self.order, ndeg=self.ndeg, label=None, - addtomodel=True, + addtomodel=False, aq=aqin, aqin=aqin, aqout=aqout, ) - LeakyIntHeadDiffLineSink( + ilhdls_out = LeakyIntHeadDiffLineSink( self.model, x1=self.x[i], y1=self.y[i], @@ -792,15 +894,16 @@ def create_elements(self): order=self.order, ndeg=self.ndeg, label=None, - addtomodel=True, + addtomodel=False, aq=aqout, aqin=aqin, aqout=aqout, ) + inhom_elements += [ilhdls_in, ilhdls_out] if len(self.nonimplayers) > 0: # use these conditions for layers without leaky walls - IntHeadDiffLineSink( + ihdls_in = IntHeadDiffLineSink( self.model, x1=self.x[i], y1=self.y[i], @@ -810,12 +913,12 @@ def create_elements(self): order=self.order, ndeg=self.ndeg, label=None, - addtomodel=True, + addtomodel=False, aq=aqin, aqin=aqin, aqout=aqout, ) - IntFluxDiffLineSink( + ihdls_out = IntFluxDiffLineSink( self.model, x1=self.x[i], y1=self.y[i], @@ -825,19 +928,39 @@ def create_elements(self): order=self.order, ndeg=self.ndeg, label=None, - addtomodel=True, + addtomodel=False, aq=aqout, aqin=aqin, aqout=aqout, ) + inhom_elements += [ihdls_in, ihdls_out] if aqin.ltype[0] == "a": # add constant on inside - c = ConstantInside(self.model, self.zcin.real, self.zcin.imag) + c = ConstantInside( + self.model, self.zcin.real, self.zcin.imag, addtomodel=False + ) c.inhomelement = True if aqin.ltype[0] == "l": assert self.hstar is not None, "Error: hstar needs to be set" - c = ConstantStar(self.model, self.hstar, aq=aqin) + c = ConstantStar(self.model, self.hstar, aq=aqin, addtomodel=False) c.inhomelement = True + inhom_elements += [c] + + return inhom_elements + + def _refine(self, n=None): + if n is None: + n = self.refine_level + xyr, reindexer = refine_n_segments(self.xy, "polygon", n_segments=n) + input_args = deepcopy(self._input) + cls = input_args.pop("__class__") + input_args["model"] = self.model + # overwrite some input args for refined element + input_args["xy"] = xyr + input_args["res"] = self.res[:, reindexer] + input_args["refine_level"] = 1 # set to 1 to prevent further refinement + input_args["addtomodel"] = False + return cls(**input_args) class LeakyBuildingPitMaq(LeakyBuildingPit): @@ -888,6 +1011,9 @@ class LeakyBuildingPitMaq(LeakyBuildingPit): resistance of leaky wall, if passed as an array must be either shape (n_segments,) or (n_segments, n_layers). Default is np.inf, which simulates an impermeable wall. + refine_level : int, optional + refine element by partitioning each side into refine_level segments, default + is 1, which means no refinement is applied. """ def __init__( @@ -904,7 +1030,10 @@ def __init__( ndeg=3, layers=[0], res=np.inf, + refine_level=1, + addtomodel=True, ): + _input = {k: v for k, v in locals().items() if k not in ["self"]} (kaq, c, npor, ltype) = param_maq(kaq, z, c, npor, topboundary) super().__init__( model=model, @@ -919,7 +1048,10 @@ def __init__( ndeg=ndeg, layers=layers, res=res, + refine_level=refine_level, + addtomodel=addtomodel, ) + self._input = _input class LeakyBuildingPit3D(LeakyBuildingPit): @@ -939,6 +1071,8 @@ def __init__( ndeg=3, layers=[0], res=np.inf, + refine_level=1, + addtomodel=True, ): """Element to simulate a building pit with a leaky wall in Model3D. @@ -989,7 +1123,11 @@ def __init__( resistance of leaky wall, if passed as an array must be either shape (n_segments,) or (n_segments, n_layers). Default is np.inf, which simulates an impermeable wall. + refine_level : int, optional + refine element by partitioning each side into refine_level segments, default + is 1, which means no refinement is applied. """ + _input = {k: v for k, v in locals().items() if k not in ["self"]} (kaq, c, npor, ltype) = param_3d(kaq, z, kzoverkh, npor, topboundary, topres) if topboundary == "semi": z = np.hstack((z[0] + topthick, z)) @@ -1006,7 +1144,10 @@ def __init__( ndeg=ndeg, layers=layers, res=res, + refine_level=refine_level, + addtomodel=addtomodel, ) + self._input = _input class AreaSinkInhom(Element): From b3a3e13295b9713ca66dff6d3f4b43d998a6fb70 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 3 Jan 2024 17:05:37 +0100 Subject: [PATCH 10/39] style fixes --- timml/util.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/timml/util.py b/timml/util.py index 2186511c..6703bc87 100644 --- a/timml/util.py +++ b/timml/util.py @@ -151,9 +151,9 @@ def contour( # color if color is None: c = plt.rcParams["axes.prop_cycle"].by_key()["color"] - elif type(color) is str: + elif isinstance(color, str): c = len(layers) * [color] - elif type(color) is list: + elif isinstance(color, list): c = color if len(c) < len(layers): n = np.ceil(self.aq.naq / len(c)) @@ -169,7 +169,7 @@ def contour( if labels: fmt = "%1." + str(decimals) + "f" plt.clabel(cs, fmt=fmt) - if type(legend) is list: + if isinstance(legend, list): plt.legend(cshandlelist, legend) elif legend: legendlist = ["layer " + str(i) for i in layers] @@ -251,9 +251,9 @@ def tracelines( """Draw trace lines""" if color is None: c = plt.rcParams["axes.prop_cycle"].by_key()["color"] - elif type(color) is str: + elif isinstance(color, str): c = self.aq.naq * [color] - elif type(color) is list: + elif isinstance(color, list): c = color if len(c) < self.aq.naq: n = int(np.ceil(self.aq.naq / len(c))) From 72462fff7726d1224d2d600ff3468baf2079de29 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 3 Jan 2024 17:18:38 +0100 Subject: [PATCH 11/39] add refine logic for LineSinkBase - create new elements - distrbute Q according to new segment lengths --- timml/linesink.py | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/timml/linesink.py b/timml/linesink.py index 10e42799..f2faf0e4 100644 --- a/timml/linesink.py +++ b/timml/linesink.py @@ -172,7 +172,9 @@ def __init__( name="LineSinkBase", label=None, addtomodel=True, + refine_level=1, ): + _input = {k: v for k, v in locals().items() if k not in ["self", "model"]} Element.__init__( self, model, nparam=1, nunknowns=0, layers=layers, name=name, label=label ) @@ -185,8 +187,10 @@ def __init__( self.res = float(res) self.wh = wh self.addtomodel = addtomodel + self.refine_level = refine_level if self.addtomodel: self.model.add_element(self) + self._input = _input def __repr__(self): return ( @@ -258,6 +262,33 @@ def plot(self, layer=None): if (layer is None) or (layer in self.layers): plt.plot([self.x1, self.x2], [self.y1, self.y2], "k") + def _refine(self, n=None): + if n is None: + n = self.refine_level + + # refine xy + xy = np.array([(self.x1, self.y1), (self.x2, self.y2)]) + xyr, _ = refine_n_segments(xy, "line", n_segments=n) + + # get input arguments + input_args = deepcopy(self._input) + cls = input_args.pop("__class__", self.__class__) + input_args["model"] = self.model + input_args["refine_level"] = 1 # set to 1 to prevent further refinement + input_args["addtomodel"] = False # these are internally created elements + + # build new elements + refined_elements = [] + Qls = input_args.pop("Qls") + L = np.sqrt((xyr[1:, 0] - xyr[:-1, 0]) ** 2 + (xyr[1:, 1] - xyr[:-1, 1]) ** 2) + for ils in range(n): + (input_args["x1"], input_args["y1"]) = xyr[ils] + (input_args["x2"], input_args["y2"]) = xyr[ils + 1] + # distribute discharge evenly according to new segment lengths + input_args["Qls"] = Qls * L[ils] / np.sum(L) + refined_elements.append(cls(**input_args)) + return refined_elements + class HeadLineSinkZero(LineSinkBase, HeadEquation): def __init__( From d3ecfa3086976a370120d17f131998731e00c776 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 3 Jan 2024 17:19:38 +0100 Subject: [PATCH 12/39] support refining in LineSinkHoBase - add refine_level kwarg - add option to skip adding element to aquifer elementlist (needed for LineSinkString elements) --- timml/linesink.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/timml/linesink.py b/timml/linesink.py index f2faf0e4..3b5a5a21 100644 --- a/timml/linesink.py +++ b/timml/linesink.py @@ -348,6 +348,7 @@ def __init__( addtomodel=True, aq=None, zcinout=None, + refine_level=1, ): Element.__init__( self, model, nparam=1, nunknowns=0, layers=layers, name=name, label=label @@ -364,6 +365,7 @@ def __init__( self.model.add_element(self) self.aq = aq self.zcinout = zcinout + self.refine_level = refine_level def __repr__(self): return ( @@ -374,7 +376,7 @@ def __repr__(self): + str((self.x2, self.y2)) ) - def initialize(self): + def initialize(self, addtoaq=True): self.ncp = self.order + 1 self.z1 = self.x1 + 1j * self.y1 self.z2 = self.x2 + 1j * self.y2 @@ -403,7 +405,9 @@ def initialize(self): ) if self.aq is None: self.aq = self.model.aq.find_aquifer_data(self.xc[0], self.yc[0]) - if self.addtomodel: + # also respect addtomodel here to prevent sub-elements (e.g. parts of + # HeadLineSinkString) from being added to the aquifer elementlists + if (addtoaq is None and self.addtomodel) or addtoaq: self.aq.add_element(self) self.parameters = np.empty((self.nparam, 1)) # Not sure if that needs to be here From 426b1921cfde6238defbe6651ef07a40b57fd837 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 3 Jan 2024 17:20:56 +0100 Subject: [PATCH 13/39] add refine functionality to HeadLineSink - add _refine method for creating new elements with correct head-specification --- timml/linesink.py | 40 ++++++++++++++++++++++++++++++++++++++-- 1 file changed, 38 insertions(+), 2 deletions(-) diff --git a/timml/linesink.py b/timml/linesink.py index 3b5a5a21..2dd1bffb 100644 --- a/timml/linesink.py +++ b/timml/linesink.py @@ -568,7 +568,9 @@ def __init__( label=None, name="HeadLineSink", addtomodel=True, + refine_level=1, ): + _input = {k: v for k, v in locals().items() if k not in ["self", "model"]} self.storeinput(inspect.currentframe()) LineSinkHoBase.__init__( self, @@ -583,14 +585,16 @@ def __init__( name=name, label=label, addtomodel=addtomodel, + refine_level=refine_level, ) self.hls = np.atleast_1d(hls) self.res = res self.wh = wh self.nunknowns = self.nparam + self._input = _input - def initialize(self): - LineSinkHoBase.initialize(self) + def initialize(self, addtoaq=True): + LineSinkHoBase.initialize(self, addtoaq=addtoaq) if self.wh == "H": self.whfac = self.aq.Haq[self.layers] elif self.wh == "2H": @@ -611,6 +615,38 @@ def initialize(self): def setparams(self, sol): self.parameters[:, 0] = sol + def _refine(self, n=None): + if n is None: + n = self.refine_level + # refine xy + xy = np.array([(self.x1, self.y1), (self.x2, self.y2)]) + xyr, _ = refine_n_segments(xy, "line", n_segments=n) + # get input arguments + input_args = deepcopy(self._input) + cls = input_args.pop("__class__", self.__class__) + input_args["model"] = self.model + input_args["refine_level"] = 1 # set to 1 to prevent further refinement + input_args["addtomodel"] = False + # build new elements + refined_elements = [] + hls = np.atleast_1d(input_args.pop("hls")) + s = np.sqrt((xyr[:, 0] - xyr[0, 0]) ** 2 + (xyr[:, 1] - xyr[0, 1]) ** 2) + for ils in range(n): + (input_args["x1"], input_args["y1"]) = xyr[ils] + (input_args["x2"], input_args["y2"]) = xyr[ils + 1] + # refine head-specification if possible + if len(hls) == 1: + input_args["hls"] = hls + elif len(hls) == 2: + input_args["hls"] = np.interp(s, [0, s[-1]], self.hls)[ils : ils + 2] + elif len(hls) == self.order + 1: + # this is never well-defined, so raise error + raise NotImplementedError( + "Cannot refine HeadLineSink when hls is defined at control points." + ) + refined_elements.append(cls(**input_args)) + return refined_elements + class LineSinkDitch(HeadLineSink): """ From 6d68c1d96b15f7da21fd7fa729428ea3e710748c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 3 Jan 2024 17:21:59 +0100 Subject: [PATCH 14/39] delete LineSinkStringBase (unused) and replace with LineSinkStringBase2 --- timml/linesink.py | 176 ---------------------------------------------- 1 file changed, 176 deletions(-) diff --git a/timml/linesink.py b/timml/linesink.py index 2dd1bffb..3ae7d8ac 100644 --- a/timml/linesink.py +++ b/timml/linesink.py @@ -751,182 +751,6 @@ def setparams(self, sol): class LineSinkStringBase(Element): - """Original implementation - Used for boundaries of inhomogenieities""" - - def __init__( - self, - model, - xy, - closed=False, - layers=0, - order=0, - name="LineSinkStringBase", - label=None, - aq=None, - ): - Element.__init__( - self, model, nparam=1, nunknowns=0, layers=layers, name=name, label=label - ) - self.xy = np.atleast_2d(xy).astype("d") - if closed: - self.xy = np.vstack((self.xy, self.xy[0])) - self.order = order - self.aq = aq - self.lslist = [] - self.x, self.y = self.xy[:, 0], self.xy[:, 1] - self.nls = len(self.x) - 1 - for i in range(self.nls): - if label is not None: - lslabel = label + "_" + str(i) - else: - lslabel = label - self.lslist.append( - LineSinkHoBase( - model, - x1=self.x[i], - y1=self.y[i], - x2=self.x[i + 1], - y2=self.y[i + 1], - Qls=0.0, - layers=layers, - order=order, - label=lslabel, - addtomodel=False, - aq=aq, - ) - ) - - def __repr__(self): - return self.name + " with nodes " + str(self.xy) - - def initialize(self): - for ls in self.lslist: - ls.initialize() - # Same order for all elements in string - self.ncp = self.nls * self.lslist[0].ncp - self.nparam = self.nls * self.lslist[0].nparam - self.nunknowns = self.nparam - self.xls = np.empty((self.nls, 2)) - self.yls = np.empty((self.nls, 2)) - for i, ls in enumerate(self.lslist): - self.xls[i, :] = [ls.x1, ls.x2] - self.yls[i, :] = [ls.y1, ls.y2] - if self.aq is None: - self.aq = self.model.aq.find_aquifer_data( - self.lslist[0].xc, self.lslist[0].yc - ) - self.parameters = np.zeros((self.nparam, 1)) - # As parameters are only stored for the element not the list, - # we need to combine the following - self.xc = np.array([ls.xc for ls in self.lslist]).flatten() - self.yc = np.array([ls.yc for ls in self.lslist]).flatten() - self.xcin = np.array([ls.xcin for ls in self.lslist]).flatten() - self.ycin = np.array([ls.ycin for ls in self.lslist]).flatten() - self.xcout = np.array([ls.xcout for ls in self.lslist]).flatten() - self.ycout = np.array([ls.ycout for ls in self.lslist]).flatten() - self.cosnorm = np.array([ls.cosnorm for ls in self.lslist]).flatten() - self.sinnorm = np.array([ls.sinnorm for ls in self.lslist]).flatten() - self.aqin = self.model.aq.find_aquifer_data(self.xcin[0], self.ycin[0]) - self.aqout = self.model.aq.find_aquifer_data(self.xcout[0], self.ycout[0]) - - def potinf(self, x, y, aq=None): - """ - linesink 0, order 0, layer[0] - order 0, layer[1] - ... - order 1, layer[0] - order 1, layer[1] - ... - linesink 1, order 0, layer[0] - order 0, layer[1] - ... - order 1, layer[0] - order 1, layer[1] - ... - """ - if aq is None: - aq = self.model.aq.find_aquifer_data(x, y) - rv = np.zeros((self.nls, self.lslist[0].nparam, aq.naq)) - for i in range(self.nls): - rv[i] = self.lslist[i].potinf(x, y, aq) - rv.shape = (self.nparam, aq.naq) - return rv - - def disvecinf(self, x, y, aq=None): - if aq is None: - aq = self.model.aq.find_aquifer_data(x, y) - rv = np.zeros((2, self.nls, self.lslist[0].nparam, aq.naq)) - for i in range(self.nls): - rv[:, i] = self.lslist[i].disvecinf(x, y, aq) - rv.shape = (2, self.nparam, aq.naq) - return rv - - def changetrace( - self, xyzt1, xyzt2, aq, layer, ltype, modellayer, direction, hstepmax - ): - changed = False - terminate = False - xyztnew = 0 - message = None - for ls in self.lslist: - changed, terminate, xyztnew, message = ls.changetrace( - xyzt1, xyzt2, aq, layer, ltype, modellayer, direction - ) - if changed or terminate: - return changed, terminate, xyztnew, message - return changed, terminate, xyztnew, message - - def plot(self, layer=None): - if (layer is None) or (layer in self.layers): - plt.plot(self.x, self.y, "k") - - -class HeadLineSinkStringOLd(LineSinkStringBase, HeadEquation): - def __init__( - self, model, xy=[(-1, 0), (1, 0)], hls=0.0, layers=0, order=0, label=None - ): - self.storeinput(inspect.currentframe()) - LineSinkStringBase.__init__( - self, - model, - xy, - closed=False, - layers=layers, - order=order, - name="HeadLineSinkString", - label=label, - aq=None, - ) - self.hls = np.atleast_1d(hls) - self.model.add_element(self) - - def initialize(self): - LineSinkStringBase.initialize(self) - self.aq.add_element(self) - # self.pc = np.array([ls.pc for ls in self.lslist]).flatten() - if len(self.hls) == 1: - self.pc = self.hls * self.aq.T[self.layers] * np.ones(self.nparam) - elif len(self.hls) == self.nls: # head specified at centers - self.pc = (self.hls[:, np.newaxis] * self.aq.T[self.layers]).flatten() - elif len(self.hls) == 2: - L = np.array([ls.L for ls in self.lslist]) - Ltot = np.sum(L) - xp = np.zeros(self.nls) - xp[0] = 0.5 * L[0] - for i in range(1, self.nls): - xp[i] = xp[i - 1] + 0.5 * (L[i - 1] + L[i]) - self.hls = np.interp(xp, [0, Ltot], self.hls) - self.pc = (self.hls[:, np.newaxis] * self.aq.T[self.layers]).flatten() - else: - print("Error: hls entry not supported") - self.resfac = 0.0 - - def setparams(self, sol): - self.parameters[:, 0] = sol - - -class LineSinkStringBase2(Element): """ Alternative implementation that loops through line-sinks to build equation Has the advantage that it is easier to have different line-sinks in From bbd9cb17fb4102db3aa570a4464d3610dc52808c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 3 Jan 2024 17:23:16 +0100 Subject: [PATCH 15/39] add refine support to LineSinkStringBase --- timml/linesink.py | 21 +++++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-) diff --git a/timml/linesink.py b/timml/linesink.py index 3ae7d8ac..141f1fec 100644 --- a/timml/linesink.py +++ b/timml/linesink.py @@ -767,6 +767,7 @@ def __init__( name="LineSinkStringBase", label=None, aq=None, + refine_level=1, ): Element.__init__( self, model, nparam=1, nunknowns=0, layers=layers, name=name, label=label @@ -783,16 +784,24 @@ def __init__( self.layers = self.layers[:, np.newaxis] else: # entire string in these layers self.layers = self.layers * np.ones( - (self.nls, len(self.layers)), dtype="int" + (self.nls, len(self.layers)), dtype=int ) self.nlayers = len(self.layers[0]) + self.refine_level = refine_level + + # set _x, _y and _layers so that _refine can potentially overwrite + # these attributes without modifying original input + self._xy = self.xy.copy() + self._x = self.x.copy() + self._y = self.y.copy() + self._layers = self.layers.copy() def __repr__(self): - return self.name + " with nodes " + str(self.xy) + return self.name + " with nodes " + str(self._xy) def initialize(self): for ls in self.lslist: - ls.initialize() + ls.initialize(addtoaq=False) self.aq = [] for ls in self.lslist: if ls.aq not in self.aq: @@ -860,7 +869,7 @@ def discharge_per_linesink(self): Qls = Qls.sum(axis=2) rv = np.zeros((self.model.aq.naq, self.nls)) for i, q in enumerate(Qls): - rv[self.layers[i], i] += q + rv[self._layers[i], i] += q return rv def discharge(self): @@ -871,7 +880,7 @@ def discharge(self): Qls.shape = (self.nls, self.nlayers, self.order + 1) Qls = np.sum(Qls, 2) for i, q in enumerate(Qls): - rv[self.layers[i]] += q + rv[self._layers[i]] += q # rv[self.layers] = np.sum(Qls.reshape(self.nls * (self.order + 1), self.nlayers), 0) return rv @@ -891,7 +900,7 @@ def changetrace( return changed, terminate, xyztnew, message def plot(self, layer=None): - if (layer is None) or (layer in self.layers): + if (layer is None) or (layer in self._layers): plt.plot(self.x, self.y, "k") From ca78a8cc4e533a0be50cbda14e36b2f7d847c01c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 3 Jan 2024 17:24:30 +0100 Subject: [PATCH 16/39] Add refine logic to HeadLineSinkString and LineSinkDitchString --- timml/linesink.py | 97 ++++++++++++++++++++++++++++++++++++----------- 1 file changed, 75 insertions(+), 22 deletions(-) diff --git a/timml/linesink.py b/timml/linesink.py index 141f1fec..13d542c7 100644 --- a/timml/linesink.py +++ b/timml/linesink.py @@ -904,7 +904,7 @@ def plot(self, layer=None): plt.plot(self.x, self.y, "k") -class HeadLineSinkString(LineSinkStringBase2): +class HeadLineSinkString(LineSinkStringBase): """ Class to create a string of head-specified line-sinks which may optionally have a width and resistance @@ -940,6 +940,9 @@ class HeadLineSinkString(LineSinkStringBase2): if scalar: element is placed in this layer if list or array: element is placed in all these layers label: str or None + refine_level : int, optional + partition each linesink reach into refine_level segments, default is 1, which + means no refinement is applied. See Also -------- @@ -959,9 +962,10 @@ def __init__( layers=0, label=None, name="HeadLineSinkString", + refine_level=1, ): self.storeinput(inspect.currentframe()) - LineSinkStringBase2.__init__( + LineSinkStringBase.__init__( self, model, xy, @@ -971,33 +975,40 @@ def __init__( name=name, label=label, aq=None, + refine_level=refine_level, ) - self.hls = np.atleast_1d(hls) + # TODO: TEST FOR DIFFERENT AQUIFERS AND LAYERS self.res = res self.wh = wh self.model.add_element(self) - # TO DO: TEST FOR DIFFERENT AQUIFERS AND LAYERS + self.hls = np.atleast_1d(hls) + + # set hls for computation, copy so that _refine + # can potentially overwrite these attributes without modifying original input + self._hls = self.hls.copy() def initialize(self): - if len(self.hls) == 1: # one value - self.hls = self.hls * np.ones(self.nls + 1) # at all nodes - elif len(self.hls) == 2: # values at beginning and end + if len(self._hls) == 1: # one value + self._hls = self._hls * np.ones(self.nls + 1) # at all nodes + elif len(self._hls) == 2: # values at beginning and end L = np.sqrt( - (self.x[1:] - self.x[:-1]) ** 2 + (self.y[1:] - self.y[:-1]) ** 2 + (self._x[1:] - self._x[:-1]) ** 2 + (self._y[1:] - self._y[:-1]) ** 2 ) s = np.hstack((0, np.cumsum(L))) - self.hls = np.interp(s, [0, s[-1]], self.hls) - elif len(self.hls) == len(self.x): # nodes may contain nan values - if np.isnan(self.hls).any(): + self._hls = np.interp(s, [0, s[-1]], self._hls) + elif len(self._hls) == len(self.x): # nodes may contain nan values + if np.isnan(self._hls).any(): L = np.sqrt( - (self.x[1:] - self.x[:-1]) ** 2 + (self.y[1:] - self.y[:-1]) ** 2 + (self._x[1:] - self._x[:-1]) ** 2 + + (self._y[1:] - self._y[:-1]) ** 2 ) s = np.hstack((0, np.cumsum(L))) - self.hls = np.interp( - s, s[~np.isnan(self.hls)], self.hls[~np.isnan(self.hls)] + self._hls = np.interp( + s, s[~np.isnan(self._hls)], self._hls[~np.isnan(self._hls)] ) else: print("Error: hls entry not supported in HeadLineSinkString") + self.lslist = [] # start with empty list for i in range(self.nls): if self.label is not None: @@ -1007,20 +1018,20 @@ def initialize(self): self.lslist.append( HeadLineSink( self.model, - x1=self.x[i], - y1=self.y[i], - x2=self.x[i + 1], - y2=self.y[i + 1], - hls=self.hls[i : i + 2], + x1=self._x[i], + y1=self._y[i], + x2=self._x[i + 1], + y2=self._y[i + 1], + hls=self._hls[i : i + 2], res=self.res, wh=self.wh, - layers=self.layers[i], + layers=self._layers[i], order=self.order, label=lslabel, addtomodel=False, ) ) - LineSinkStringBase2.initialize(self) + LineSinkStringBase.initialize(self) def setparams(self, sol): self.parameters[:, 0] = sol @@ -1060,6 +1071,31 @@ def equation(self): jcol += ls.nunknowns return mat, rhs + def _refine(self, n=None): + if n is None: + n = self.refine_level + xyr, reindexer = refine_n_segments(self.xy, "line", n_segments=n) + + # update attributes + self._xy = xyr + self._x = xyr[:, 0] + self._y = xyr[:, 1] + + # refining logic for hls + if len(self.hls) == 1: + self._hls = self.hls.copy() # initialize will set hls for each segment + elif len(self.hls == 2): + self._hls = self.hls.copy() # initialize will set hls for each segment + elif len(self.hls) == len(self.x): + self._hls = self.hls[reindexer] # reindex user-specified hls + mask = ~(np.diff(reindexer, prepend=[-1]).astype(bool)) + self._hls[mask] = np.nan + + self._layers = self.layers[reindexer] + self.nlayers = len(self._layers[0]) + self.nls = len(self._x) - 1 + return [self] + class LineSinkDitchString(HeadLineSinkString): """ @@ -1110,6 +1146,7 @@ def __init__( order=0, layers=0, label=None, + refine_level=1, ): self.storeinput(inspect.currentframe()) HeadLineSinkString.__init__( @@ -1123,6 +1160,7 @@ def __init__( layers=layers, label=label, name="LineSinkDitchString", + refine_level=refine_level, ) self.Qls = Qls @@ -1149,6 +1187,15 @@ def equation(self): def setparams(self, sol): self.parameters[:, 0] = sol + def _refine(self, n=None): + if n is None: + n = self.refine_level + xyr, _ = refine_n_segments(self.xy, "line", n_segments=n) + # update attributes + self._x = xyr[:, 0] + self._y = xyr[:, 1] + return [self] + class LineSinkContainer(Element): """ @@ -1168,7 +1215,13 @@ def __init__( aq=None, ): Element.__init__( - self, model, nparam=1, nunknowns=0, layers=layers, name=name, label=label + self, + model, + nparam=1, + nunknowns=0, + layers=layers, + name=name, + label=label, ) self.order = order From 82a69e2281e4a3662b1444b97d6f448c85c47567 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 3 Jan 2024 17:25:22 +0100 Subject: [PATCH 17/39] add imports, use labels in HeadLineSinkContainer --- timml/linesink.py | 23 ++++++++++++----------- 1 file changed, 12 insertions(+), 11 deletions(-) diff --git a/timml/linesink.py b/timml/linesink.py index 13d542c7..4cb41ed7 100644 --- a/timml/linesink.py +++ b/timml/linesink.py @@ -1,12 +1,14 @@ import inspect # Used for storing the input +from copy import deepcopy import matplotlib.pyplot as plt import numpy as np -from . import bessel -from .controlpoints import controlpoints, strengthinf_controlpoints -from .element import Element -from .equation import HeadEquation, PotentialEquation +from timml import bessel +from timml.controlpoints import controlpoints, strengthinf_controlpoints +from timml.element import Element +from timml.equation import HeadEquation +from timml.util import refine_n_segments __all__ = [ "LineSinkBase", @@ -1393,7 +1395,7 @@ def __init__( self.res = res self.wh = wh self.model.add_element(self) - # TO DO: TEST FOR DIFFERENT AQUIFERS AND LAYERS + # TODO: TEST FOR DIFFERENT AQUIFERS AND LAYERS def initialize(self): self.lslist = [] @@ -1407,6 +1409,10 @@ def initialize(self): self.xls.append(xy[:, 0]) self.yls.append(xy[:, 1]) for i in range(len(xy) - 1): + if self.label is not None: + lslabel = self.label + "_" + str(i) + else: + lslabel = self.label x1, y1 = xy[i] x2, y2 = xy[i + 1] ls = HeadLineSink( @@ -1420,16 +1426,11 @@ def initialize(self): wh=self.wh, layers=layers[i], order=self.order, - label=None, + label=lslabel, addtomodel=False, ) self.lslist.append(ls) self.nls = len(self.lslist) - for i in range(self.nls): - if self.label is not None: - lslabel = self.label + "_" + str(i) - else: - lslabel = self.label LineSinkContainer.initialize(self) def setparams(self, sol): From da0ed41f20349ea31c2de7a9d7b193d5bb26aca5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 3 Jan 2024 17:32:36 +0100 Subject: [PATCH 18/39] Add refine logic to LineDoubletHoBase, ImpLineDoublet and LeakyLineDoublet - add _refine method - add refine_level kwarg - add addtoaq kwarg to initialize (for String elements) - store user inputs --- timml/linedoublet.py | 36 ++++++++++++++++++++++++++++++++++-- 1 file changed, 34 insertions(+), 2 deletions(-) diff --git a/timml/linedoublet.py b/timml/linedoublet.py index 8a444f11..19b14faf 100644 --- a/timml/linedoublet.py +++ b/timml/linedoublet.py @@ -33,6 +33,7 @@ def __init__( addtomodel=True, aq=None, zcinout=None, + refine_level=1, ): Element.__init__( self, model, nparam=1, nunknowns=0, layers=layers, name=name, label=label @@ -50,6 +51,7 @@ def __init__( self.model.add_element(self) self.aq = aq self.zcinout = zcinout + self.refine_level = refine_level def __repr__(self): return ( @@ -60,7 +62,7 @@ def __repr__(self): + str((self.x2, self.y2)) ) - def initialize(self): + def initialize(self, addtoaq=True): self.ncp = self.order + 1 self.z1 = self.x1 + 1j * self.y1 self.z2 = self.x2 + 1j * self.y2 @@ -87,7 +89,9 @@ def initialize(self): if self.aq is None: self.aq = self.model.aq.find_aquifer_data(self.xc[0], self.yc[0]) self.resfac = self.aq.Haq[self.layers] / self.res - if self.addtomodel: + # also respect addtomodel here to prevent sub-elements (e.g. parts of + # LineDoubletString) from being added to the aquifer elementlists + if (addtoaq is None and self.addtomodel) or addtoaq: self.aq.add_element(self) self.parameters = np.empty((self.nparam, 1)) # Not sure if this needs to be here @@ -164,6 +168,26 @@ def plot(self, layer=None): if (layer is None) or (layer in self.layers): plt.plot([self.x1, self.x2], [self.y1, self.y2], "k") + def _refine(self, n=None): + if n is None: + n = self.refine_level + # refine xy + xy = np.array([(self.x1, self.y1), (self.x2, self.y2)]) + xyr, _ = refine_n_segments(xy, "line", n_segments=n) + # get input args + input_args = deepcopy(self._input) + cls = input_args.pop("__class__", self.__class__) + input_args["model"] = self.model + input_args["refine_level"] = 1 # set to 1 to prevent further refinement + input_args["addtomodel"] = False + # build new elements + refined_elements = [] + for ils in range(n): + (input_args["x1"], input_args["y1"]) = xyr[ils] + (input_args["x2"], input_args["y2"]) = xyr[ils + 1] + refined_elements.append(cls(**input_args)) + return refined_elements + class ImpLineDoublet(LineDoubletHoBase, DisvecEquation): """ @@ -211,7 +235,9 @@ def __init__( layers=0, label=None, addtomodel=True, + refine_level=1, ): + _input = {k: v for k, v in locals().items() if k not in ["self", "model"]} self.storeinput(inspect.currentframe()) LineDoubletHoBase.__init__( self, @@ -227,7 +253,9 @@ def __init__( name="ImpLineDoublet", label=label, addtomodel=addtomodel, + refine_level=refine_level, ) + self._input = _input self.nunknowns = self.nparam def initialize(self): @@ -288,7 +316,9 @@ def __init__( layers=0, label=None, addtomodel=True, + refine_level=1, ): + _input = {k: v for k, v in locals().items() if k not in ["self", "model"]} self.storeinput(inspect.currentframe()) LineDoubletHoBase.__init__( self, @@ -304,7 +334,9 @@ def __init__( name="ImpLineDoublet", label=label, addtomodel=addtomodel, + refine_level=refine_level, ) + self._input = _input self.nunknowns = self.nparam def initialize(self): From 70e222198b98e067fdd4556ebbb404dc728f9656 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 3 Jan 2024 17:35:01 +0100 Subject: [PATCH 19/39] add refine logic to LineDoubletStringBase and its child classes - add refine_level kwarg - introduce internal _x, _y and _xy vars - add _refine method - move building linedoublets into initialize --- timml/linedoublet.py | 106 +++++++++++++++++++++++++++++++------------ 1 file changed, 77 insertions(+), 29 deletions(-) diff --git a/timml/linedoublet.py b/timml/linedoublet.py index 19b14faf..54ea7154 100644 --- a/timml/linedoublet.py +++ b/timml/linedoublet.py @@ -358,6 +358,7 @@ def __init__( name="LineDoubletStringBase", label=None, aq=None, + refine_level=1, ): Element.__init__( self, model, nparam=1, nunknowns=0, layers=layers, name=name, label=label @@ -366,41 +367,59 @@ def __init__( if closed: self.xy = np.vstack((self.xy, self.xy[0])) self.order = order + self.res = res self.aq = aq self.ldlist = [] self.x, self.y = self.xy[:, 0], self.xy[:, 1] - self.Nld = len(self.x) - 1 - for i in range(self.Nld): + self.nld = len(self.x) - 1 + self.layers = np.atleast_1d(layers) + self.refine_level = refine_level + + # set _x, _y for computation, copied so that new parameters + # can be overwritten if _refine is called + self._xy = self.xy.copy() + self._x = self.x.copy() + self._y = self.y.copy() + + def __repr__(self): + return self.name + " with nodes " + str(self._xy) + + def initialize(self): + self.ldlist = [] + for i in range(self.nld): + if self.label is not None: + ldlabel = self.label + "_" + str(i) + else: + ldlabel = self.label self.ldlist.append( LineDoubletHoBase( - model, - x1=self.x[i], - y1=self.y[i], - x2=self.x[i + 1], - y2=self.y[i + 1], + self.model, + x1=self._x[i], + y1=self._y[i], + x2=self._x[i + 1], + y2=self._y[i + 1], delp=0.0, - res=res, - layers=layers, - order=order, - label=label, + res=self.res, + layers=self.layers, + order=self.order, + label=ldlabel, addtomodel=False, - aq=aq, + aq=self.aq, ) ) - def __repr__(self): - return self.name + " with nodes " + str(self.xy) - - def initialize(self): + # to not add sub-elements to aquifer, the compound element takes care of this + # itself for ld in self.ldlist: - ld.initialize() + ld.initialize(addtoaq=False) + self.ncp = ( - self.Nld * self.ldlist[0].ncp + self.nld * self.ldlist[0].ncp ) # Same order for all elements in string - self.nparam = self.Nld * self.ldlist[0].nparam + self.nparam = self.nld * self.ldlist[0].nparam self.nunknowns = self.nparam - self.xld = np.empty((self.Nld, 2)) - self.yld = np.empty((self.Nld, 2)) + self.xld = np.empty((self.nld, 2)) + self.yld = np.empty((self.nld, 2)) for i, ld in enumerate(self.ldlist): self.xld[i, :] = [ld.x1, ld.x2] self.yld[i, :] = [ld.y1, ld.y2] @@ -409,7 +428,8 @@ def initialize(self): self.ldlist[0].xc[0], self.ldlist[0].yc[0] ) self.parameters = np.zeros((self.nparam, 1)) - ## As parameters are only stored for the element not the list, we need to combine the following + # As parameters are only stored for the element not the list, + # we need to combine the following: self.xc = np.array([ld.xc for ld in self.ldlist]).flatten() self.yc = np.array([ld.yc for ld in self.ldlist]).flatten() self.xcin = np.array([ld.xcin for ld in self.ldlist]).flatten() @@ -425,8 +445,8 @@ def initialize(self): def potinf(self, x, y, aq=None): if aq is None: aq = self.model.aq.find_aquifer_data(x, y) - rv = np.zeros((self.Nld, self.ldlist[0].nparam, aq.naq)) - for i in range(self.Nld): + rv = np.zeros((self.nld, self.ldlist[0].nparam, aq.naq)) + for i in range(self.nld): rv[i] = self.ldlist[i].potinf(x, y, aq) rv.shape = (self.nparam, aq.naq) return rv @@ -434,8 +454,8 @@ def potinf(self, x, y, aq=None): def disvecinf(self, x, y, aq=None): if aq is None: aq = self.model.aq.find_aquifer_data(x, y) - rv = np.zeros((2, self.Nld, self.ldlist[0].nparam, aq.naq)) - for i in range(self.Nld): + rv = np.zeros((2, self.nld, self.ldlist[0].nparam, aq.naq)) + for i in range(self.nld): rv[:, i] = self.ldlist[i].disvecinf(x, y, aq) rv.shape = (2, self.nparam, aq.naq) return rv @@ -444,6 +464,17 @@ def plot(self, layer=None): if (layer is None) or (layer in self.layers): plt.plot(self.x, self.y, "k") + def _refine(self, n=None): + if n is None: + n = self.refine_level + xyr, _ = refine_n_segments(self.xy, "line", n_segments=n) + # update attributes + self._xy = xyr + self._x = xyr[:, 0] + self._y = xyr[:, 1] + self.nld = len(self._x) - 1 + return [self] + class ImpLineDoubletString(LineDoubletStringBase, DisvecEquation): """ @@ -475,7 +506,15 @@ class ImpLineDoubletString(LineDoubletStringBase, DisvecEquation): """ - def __init__(self, model, xy=[(-1, 0), (1, 0)], layers=0, order=0, label=None): + def __init__( + self, + model, + xy=[(-1, 0), (1, 0)], + layers=0, + order=0, + label=None, + refine_level=1, + ): self.storeinput(inspect.currentframe()) LineDoubletStringBase.__init__( self, @@ -488,6 +527,7 @@ def __init__(self, model, xy=[(-1, 0), (1, 0)], layers=0, order=0, label=None): name="ImpLineDoubletString", label=label, aq=None, + refine_level=refine_level, ) self.model.add_element(self) @@ -532,7 +572,14 @@ class LeakyLineDoubletString(LineDoubletStringBase, LeakyWallEquation): """ def __init__( - self, model, xy=[(-1, 0), (1, 0)], res=np.inf, layers=0, order=0, label=None + self, + model, + xy=[(-1, 0), (1, 0)], + res=np.inf, + layers=0, + order=0, + label=None, + refine_level=1, ): self.storeinput(inspect.currentframe()) LineDoubletStringBase.__init__( @@ -543,9 +590,10 @@ def __init__( layers=layers, order=order, res=res, - name="ImpLineDoubletString", + name="LeakyLineDoubletString", label=label, aq=None, + refine_level=refine_level, ) self.model.add_element(self) From 22dceb74bcb16f2233a330564552710081ce338f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 3 Jan 2024 17:35:11 +0100 Subject: [PATCH 20/39] add imports --- timml/linedoublet.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/timml/linedoublet.py b/timml/linedoublet.py index 54ea7154..67b83c45 100644 --- a/timml/linedoublet.py +++ b/timml/linedoublet.py @@ -1,12 +1,14 @@ import inspect # Used for storing the input +from copy import deepcopy import matplotlib.pyplot as plt import numpy as np -from . import bessel -from .controlpoints import controlpoints -from .element import Element -from .equation import DisvecEquation, LeakyWallEquation +from timml import bessel +from timml.controlpoints import controlpoints +from timml.element import Element +from timml.equation import DisvecEquation, LeakyWallEquation +from timml.util import refine_n_segments __all__ = [ "ImpLineDoublet", From 0b7b50ef374c21f08248c1087e2c79bd8f4d6822 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 3 Jan 2024 17:37:04 +0100 Subject: [PATCH 21/39] add refinement notebook (move to docs later) --- notebooks/refinement.ipynb | 1041 ++++++++++++++++++++++++++++++++++++ 1 file changed, 1041 insertions(+) create mode 100644 notebooks/refinement.ipynb diff --git a/notebooks/refinement.ipynb b/notebooks/refinement.ipynb new file mode 100644 index 00000000..32fdf2c4 --- /dev/null +++ b/notebooks/refinement.ipynb @@ -0,0 +1,1041 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Automatic refinement of elements\n", + "\n", + "---\n", + "\n", + "_Developed by D.A. Brakenhoff, December 2023, Artesia + TU Delft_\n", + "\n", + "\n", + "This notebook shows how elements can be automatically refined in TimML. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Contents\n", + "\n", + "- [Single line-sink](#single-line-sink)\n", + "- [Compound line-sinks](#compound-line-sinks)\n", + "- [Compound line-sink with nearby well](#compound-line-sink-with-nearby-well)\n", + "- [Refining inhomogeneities: LeakyBuildingPit](#refining-inhomogeneities-leakybuildingpit)\n", + "- [Global refine option](#global-refine-option)\n", + "\n", + "Refinement means splitting line elements into smaller sub-elements. This can be\n", + "necessary for computational accuracy at locations where elements lie close together.\n", + "The sub-elements derive their properties from the original user-specified elements." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "import timml as tml\n", + "from timml.util import refine_n_segments" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Single line-sink" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Supported elements can be refined by passing the `refine_level` kwarg. A refinement\n", + "level of 0 or 1 means no refinement is applied. A refinement level of 3 means that\n", + "a line-sink is split into 3 segments. The segmentation is performed according to the\n", + "cosine rule (the same method that determines the location of the control points for an\n", + "element).\n", + "\n", + "In this example a single `HeadLineSink` is refined into 3 segments. The head along the\n", + "line-sink is compared to a case with no refinement.\n", + "\n", + "First we define some model parameters. We have a single semi-confined aquifer split\n", + "into two 10 m-thick layers, with 1 day resistance between the two layers. The confining\n", + "layer has resistance of 1000 days with head of 0 m+ref above the confining layer." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# model parameters\n", + "\n", + "kh = 10 # m/day\n", + "\n", + "ctop = 1000.0 # resistance top leaky layer in days\n", + "\n", + "ztop = 0.0 # surface elevation\n", + "zbot = -20.0 # bottom elevation of the model\n", + "z = np.array([ztop + 1, ztop, -10, -10, zbot])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Build and store the models. Note that the only change required to apply the automatic\n", + "refinement is to supply a `refine_level>1` to the `HeadLineSink` element." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "models = []\n", + "\n", + "for rlvl in [1, 3]:\n", + " ml = tml.ModelMaq(kaq=kh, z=z, c=[ctop, 1], topboundary=\"semi\", hstar=0.0)\n", + " ls = tml.HeadLineSink(ml, 0, 0, 10, 10, hls=1.0, refine_level=rlvl)\n", + " ml.solve(silent=True)\n", + " models.append(ml)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot a top-view of the model." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "models[0].plot([-10, 20, -10, 20])\n", + "plt.xlabel(\"x [m]\")\n", + "plt.ylabel(\"y [m]\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Compare the head along the element for the refined and non-refined models. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# compute distance along line-sink\n", + "xy = np.array([(0, 0), (10, 10)])\n", + "x, y = refine_n_segments(xy, \"line\", 101)[0].T\n", + "r = np.sqrt((x - x[0]) ** 2 + (y - y[0]) ** 2)\n", + "\n", + "# loop over models\n", + "for i, iml in enumerate(models):\n", + " h = iml.headalongline(x, y)\n", + " if i == 0:\n", + " lbl = \"No refinement\"\n", + " # plot head condition\n", + " plt.plot([0, r[-1]], [ls.hls, ls.hls], ls=\"dashed\", color=\"k\")\n", + " else:\n", + " lbl = f\"Refinement level = {ls.refine_level}\"\n", + " \n", + " # plot head\n", + " plt.plot(r, h[0], c=f\"C{i}\", label=lbl)\n", + "\n", + " # plot locations control points\n", + " for e in iml.elementlist:\n", + " if isinstance(e, tml.HeadLineSink):\n", + " rc = np.sqrt((e.xc - x[0]) ** 2 + (e.yc - y[0]) ** 2)\n", + " if i == 0:\n", + " plt.plot(rc, ls.hls, f\"C{i}o\", ms=5, zorder=5)\n", + " else:\n", + " plt.plot(rc, ls.hls, f\"C{i}o\", ms=10, mfc=\"none\", zorder=5)\n", + "leg = plt.legend(loc=(0, 1), frameon=False, ncol=2)\n", + "plt.grid(True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
Note: \n", + "Be careful when refining single line-sinks! The variable referring to the original\n", + "element is not the one used in the calculations! See below for more information. \n", + "
\n", + "\n", + "When refining a single line-sink, the TimML creates new refined elements internally. This means that the original user-specified line-sink was not used in the computation and cannot be used for calculations, e.g. getting the discharge of the line-sink.\n", + "\n", + "\n", + "This means the following will not work:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AttributeError 'NoneType' object has no attribute 'naq'\n" + ] + } + ], + "source": [ + "ls = models[1].elements[-1] # get user-specified element from 2nd model\n", + "\n", + "try:\n", + " ls.discharge()\n", + "except Exception as e:\n", + " print(e.__class__.__name__, e)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Instead do this:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-204.24637731, 0. ])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Q = np.zeros(2) # 2 layers\n", + "for e in models[1].elementlist[1:]: # loop through computation (refined) elements\n", + " Q += e.discharge()\n", + "Q" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Another method to avoid this issue is to use compound line-sink elements, such as\n", + "`HeadLineSinkString`, which is shown in the next section." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Compound line-sinks\n", + "\n", + "Compound line-sinks are elements that consist of multiple line-sinks, e.g.\n", + "`HeadLineSinkString`. Refining these elements works similar to the example for a single\n", + "line-sink. \n", + "\n", + "The advantage of compound elements is that they store their own list of\n", + "sub-elements internally, which means the original element can be used for further\n", + "computation, unlike the example with a single line-sink.\n", + "\n", + "In this example we have the same single line-sink as the previous example, but the\n", + "specified head is 1 m+ref at the starting point and 0 m+ref at the end of the line-sink.\n", + "Because the head is sloping we need more than 1 control point in the non-refined model,\n", + "so we increase the order of the element to 2. That model is compared to a refined model\n", + "with a refine_level of 3 and order 0." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Build the models" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "models = []\n", + "\n", + "for rlvl, order in zip([1, 3], [2, 0]):\n", + " ml = tml.ModelMaq(kaq=kh, z=z, c=[ctop, 1], topboundary=\"semi\", hstar=0.0)\n", + " ls = tml.HeadLineSinkString(\n", + " ml, xy=[(0, 0), (10, 10)], hls=[1.0, 0.0], refine_level=rlvl, order=order\n", + " )\n", + " ml.solve(silent=True)\n", + " models.append(ml)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Compare the head contours between the two models. As expected they look quite similar." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "models[-1].plot([-20, 30, -20, 30])\n", + "for i, iml in enumerate(models):\n", + " iml.contour([-20, 30, -20, 30], 101, newfig=False, decimals=2, color=f\"C{i}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As mentioned the advantage of compound line-sinks is that the original reference to the line-sink that was specified by the user can be used for computation." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-102.31796071, 0. ])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# non-refined model\n", + "models[0].elements[1].discharge()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-102.12318866, 0. ])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# refined model\n", + "models[1].elements[1].discharge()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Compound line-sink with nearby well\n", + "\n", + "In this example a well is pumping near a head-specified line-sink. We apply different\n", + "refinement levels and observe the effect on the total discharge of the line-sink. \n", + "\n", + "First specify the line-sink and well coordinates." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "xy = np.array([(0, 0), (10, 10), (20, 10)]) # line-sink coordinates\n", + "\n", + "xw, yw = 15, 0 # well coordinates\n", + "rw = 0.3 # well radius, in m\n", + "Qw = 100.0 # well discharge, in m3/d" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot a top-view of the model" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'y [m]')" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(xy[:, 0], xy[:, 1], \"k-o\", label=\"head-specified line-sink\")\n", + "plt.plot(xw, yw, \"C0o\", label=\"well\")\n", + "leg = plt.legend(loc=(0, 1), frameon=False, ncol=2)\n", + "plt.xlabel(\"x [m]\")\n", + "plt.ylabel(\"y [m]\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Build models and apply refinement levels 1-9. Print the total discharge of the line-sink for each model. After level 4, the discharge does not change by all that much any more. " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Refinement level 1: Qls = -418.22\n", + "Refinement level 2: Qls = -428.80\n", + "Refinement level 3: Qls = -434.54\n", + "Refinement level 4: Qls = -437.01\n", + "Refinement level 5: Qls = -438.26\n", + "Refinement level 6: Qls = -438.99\n", + "Refinement level 7: Qls = -439.43\n", + "Refinement level 8: Qls = -439.73\n", + "Refinement level 9: Qls = -439.94\n" + ] + } + ], + "source": [ + "models = []\n", + "for rlvl in range(1, 10):\n", + " ml = tml.ModelMaq(kaq=kh, z=z, c=[ctop, 1], topboundary=\"semi\", hstar=0.0)\n", + " hls = tml.HeadLineSinkString(ml, xy, hls=[2, 1], refine_level=rlvl)\n", + " w = tml.Well(ml, xw, yw, Qw, rw=0.1, layers=[0])\n", + " ml.solve(silent=True)\n", + " models.append(ml)\n", + " print(f\"Refinement level {rlvl}: Qls = {hls.discharge().sum():.2f}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Compare the head contours for the first (non-refined) and last model (`refine_level=9`)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAckAAAG2CAYAAAAUS31lAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd3hT5fuH74w23XvvySx77z1kCwiKA8QtuAeOnwP9OnAvVBRBRNkKIoIIyt6jQBktnbR073Rln98fL21BWkZpOiD3deVqk5ycvjlNznOe9XlkkiRJWLBgwYIFCxYuQ97YC7BgwYIFCxaaKhYjacGCBQsWLNSCxUhasGDBggULtWAxkhYsWLBgwUItWIykBQsWLFiwUAsWI2nBggULFizUgsVIWrBgwYIFC7VgMZIWLFiwYMFCLViMpAULFixYsFALFiNpwYIFCxYs1EKzMZLffPMN7du3x8nJCScnJ3r16sWmTZuqnpckiTfffBM/Pz9sbW0ZOHAgp06dasQVW7BgwYKF5k6zMZIBAQG8//77HD58mMOHDzN48GDGjx9fZQg/+OADPvnkE7766isOHTqEj48Pw4YNo6SkpJFXbsGCBQsWmiuy5ixw7ubmxocffsjMmTPx8/Pj6aefZs6cOQBotVq8vb2ZN28ejzzySCOv1IIFCxYsNEeUjb2AumA0Glm9ejVlZWX06tWL5ORksrKyGD58eNU2KpWKAQMGsHfv3isaSa1Wi1arrbpvMpkoKCjA3d0dmUxm1vdhwYIFCxbqF0mSKCkpwc/PD7n8xoOlzcpIxsTE0KtXLzQaDQ4ODqxdu5Y2bdqwd+9eALy9vS/Z3tvbm3Pnzl1xn++99x5z584125ovRiGDdXfaklMm8egGDRLwzmAVt0UombdHxy8xemRAs3XtLViwYKGJkJaWRkBAwA3vp1mFW3U6HampqRQVFfHrr7+ycOFCduzYQVFREX369CEjIwNfX9+q7R966CHS0tL466+/at3nfz3J4uJigoKCSEtLw8nJqW4LNeqwOvMbstIsDOEjMLmGgtIGWWkWdqunouvyEPr29wAgK8tBtXseipxTlN37F0gSbH8fvFpD67EgV9RtDRYs3AqYTHB2Exz8HtIPVz8eNgh6zoKgHmCJCN0wkiTx074UPvr7LJIEA1t68OHkjthaN6Hzk8kIax9FHbORwE9LKSoqwtnZ+YZ326yM5H8ZOnQo4eHhzJkzh/DwcI4ePUqnTp2qnh8/fjwuLi4sWbLkmvepVqtxdnamuLj4+o2kUQ/7voLdn4JrCKicoDAFOk+HAS9AxjH47SHo9zx0mFr9uri/YMU0eGyPMI6SZPliW7BwvZw/DHu/hDPrQTKJxwK6Qb/noMVIy3eqHtgUk8lTK4+hM5joFOTCD9O74WZv3djLqkZfgfqP13Ce9HHdzuE10GyqW2tCkiS0Wi2hoaH4+PiwZcuWqud0Oh07duygd+/eDbegzONwYhWM/Rwe2QmTfoCoiXB6nXjeryPoNVCYDAZd9eu8WoNPOzi+QtxvvtctFiw0HgFdYcoSmH0YutwPChWcPwTL74QF/eD078LztFBnbmvnyy8P9sDZ1oro1CImf7OX84Xljb2saqxsYejr9brLZmMkX3nlFXbt2kVKSgoxMTG8+uqrbN++nbvvvhuZTMbTTz/Nu+++y9q1azl58iQzZszAzs6OadOmNdwi8+KhOB1ajhL3Hb2hoghCB1QbxfBBELcRynKqX2fnBl5toCBR3K+HZLMFC7cs7uEw9jN4Ogb6PAXWDpAVA6vug697wslfLcbyBugW4savj/XCz9mGpLwyJn2zl7ism7fVrtkU7mRnZ3PvvfeSmZmJs7Mz7du356+//mLYsGEAvPjii1RUVPD4449TWFhIjx49+Pvvv3F0dKy/ReScAbcwUKpqft7WFRRWsGMetJ0IMasg4R/o+SiUZoFLEHR/CBaPguSd0PGCAVc5CgMZ2L3+1mqhXpEkCbXGQEGZjoIyLeoKA8UVeoor9JRo9JTpjJRpDZRpjWj0RrQGI1qDCa3ehMFkwiiB0WS65Nwsk4FCLkMpl6FUyLFSyFApFdhYybGxUmBrpcBBpcRBpcRepcTJ1goXWytc7MTNzV6Fi60VcrkljFgjjt4w7C3o8zTs/wYOLIC8OFgzE7w+hkEvQ6sxljBsHYjwcuTXx3szfdFBzmaXMvW7fSye0Y1OQa6NvbR6p1nnJM3BZTlJbSns/ACO/Ag2LuDkDwPnQNhA8YLKwyeTid9jNwgDePB7CO4NQb0g8V+oKIC714BHpLiiVWdCv2eh5W2QEwur7oW+z1QbTgsNhs5gIqOogoziCjKKNGQWVZCp1pCj1pBToiVbraGgTIfe2PS+Kgq5DDd7azwcVHg7qfBxssHbyQZfZxv8XW3xd7HFz8UWG6smVGDRWGiKhbHcNx+0avGYbwcY8jqED7luY2k0GtHr9WZYaPNBXaHjlbUnOZOpxsZKwVvjougSYn5DaW1tXWt7xw3VldSAxUj+h8sO8LHlsH8+DHoVHH1h54eQnwD9X4B2k0XY5r//rFXTRchn4MvCs9SVw6Lh4N9VhIFyz8KujyFhC3i3hfRoiBgM474EmxuvxrJwOVqDkXP55STllpKUV0ZybhmpBeWkFZSTqdZccxrY3lqBq701LnZWONuKm6PKCnuVEnuVAjtrJXbWClRKOSorOdYKBUqF8BYVchnyCydiCeGdmiQJvVHCYJTQG01oDUY0ehMavZHySu9UZ6BEI25F5TqKKvQUlulQawzX/P69nVQEu9kT5G5HiLsdYZ4OhHs6EOJhh0p5ixnQikJhKPd/A7pS8VhIPxjyBgR2u+rLJUkiKyuLoqIi866zmWCSJArKdGj0JmQycLO3xtbMF2VyuZzQ0FCsrS8vGrIYSTNzyQG2sxFeH8C0C0U1Bi2se0x4gjM2XN6ioc6AlfdA32eh9RhRlixXwK8PQfF5mHlBb1ZfIYoK0g5A2GAI6NJwb/ImxmiSSMkv40ymmrisEs5mlxCfXUpKfhmmK3zSbazk+LkIz8vX2QYfZ1u8nVR4O9rg5aTCw0GFm711k/LIdAYTheU6cku05JZqyVFryCzWkH3hZ3phBelFFZTrjLXuQy6DYHd7Wng70NLHiVY+jrT2dSLYze7mD+OW5YuL1UMLwXihDaz1WBg6V1zk1kJmZiZFRUV4eXlhZ2dnER1BGMrMogpKtQZkyPBxVuFka56qV5PJREZGBlZWVgQFBV12/OvbSDabnGSjYNSB+jy0v6hdQ6mCNuNh65sitNpmPBgNIJMLj7K8QIRdM4+LAh65QhQNZJ2AHheUfyRJVGGF9hc3C3XCaJJIyCnlxPkiYtKLiUkvJjazhAp9zUbBUaUkzNOeME8HQtztCfGwI9DNjiA3O9ztrZvdyc5aKcf7Qni1NiRJorBcT2pBOefyyziXX05KfhlJuWUk5pRSojWQnFdGcl4Zm09lV73OQaWkja8Tbf2d6BDgQsdAF4LdbzKDYO8OI9+Fno/Bjvfh2DI48wfEbYJuD8KAOaKo7iKMRmOVgXR3d2+khTdNwmxsOF9YQWG5DplShY1NLbUb9YCnpycZGRkYDAasrKzM9nfAYiSvjMoB5FaiatVoAMWFw+XbATxawJkLRlJx0WH0iRI9Wbs/FWFZg/aCtzgQWo0V29xMJ5oGJK9Uy9FzhUSnFRGdWsiJ88U1ekk2VnJa+jjR2seRFt6VNwc8HVU310n+GpDJRM7Szd6ajoEulzwnSRK5JVric0qJzSohLktNbFYJsVkllGoNHEwp4GBKQdX2LnZWdAhwoUuwK12CXekY6IK96iY4hbgEwvj50Gs2bHkd4v+GA9+KVMvAOdDtIVAKr6gyB2lnZ9eYK26SyGQyAlxtcba1wsn2csOlu5BK0BtNKBUynG/A06wMsxqNRouRbHTajBfhGE2xuPIEUbzjHgHZJ8XjNs6ikdnOTVS/9polDGnKLtHUPOgVYTwtXBfnC8vZn1TAoeQCDqUUkJRXdtk29tYKovydaR/gTJS/M239nAn1sEdxs4cK6wGZTIaXkw1eTjb0ifCoelxvNJGYW8qpdDUx6cUcSyvidIaaonI9O87msuNsLiBCtW39nOkZ5kbPMHe6hrjhXMPJsdng1RruXg2J2+Dv1yA7Bja/AocXw8j3IHJY1aa32sXWtSKTyWo0kGVaA+lFFRhNElYKOTqjieIKA0FudbvYaMjjb8lJ/ofL4tnF6fB5e7h9gWjrqCzS2fIGZByFe3+HrOOw7nFRyTrmk8Z9A82YvFItu+Pz2JuYx76kfNIKKi7bpoW3A52DXOkU5ELHQFcivBwsBrEB0BlMnMlUE51ayJHUIo6eKyS96NL/j1wG7fyd6RvpQd8ITzoHuzTfoiCTEaJ/hn/fhjJxUUDkcDSD3yG5yEhoaCg2NrWHuS1UU6EzkJhbhpONFR4O1thaK9AaTKTkl+HjZIOL3fV7lBqNhuTk5Br/D5acZEPj7A+tRouWDvcIoZoDIgSrsBZG06OF6LcK6NqoS21u6I0mDqcUsjM+l51nczmVob7keYVcRvsAZ7qHutE9xI0uwa51+kJZuHGslXI6BLrQIdCFGX3EY5nFFRxMLmB/Uj77kwpIzivj+Plijp8vZv62ROysFfQO92BQK08GtvTC38W2cd/E9SBXQJfp0HaCqGjf/60Iw2YnwqCvm6UYwcCBA+nYsSOfffZZg/1Nk0niXEE5Diolfi42KBXCybCxUmAll1OhN+LSYKupGxYjWRsVhbBvnlDsGPgKbH4ZfrkDBr4EGdGQcwomLhTbWtvD4Fcbd73NhPxSLf/G5rA9Lped8bmU/KeNoY2vE30i3Okd4UG3EDccboac102Kr7Mt4zv6M76jPwBZxRp2J+SxOz6X3Qn55JVq2Xomm61nREFQS29HhrbxYmhrbzoEuDSP6lkbZxj+P+g8Aza9ANnxIsVSkAjyIEvL1lU4X1SBDC4xkAAGo8hNWiuqQ7MxMTHMnj2bgwcP4ubmxiOPPMJrr73W6KFtyxmoNr7tD1IRaEtg3Bcw7is4vAhO/iaM4vj519RTZQFS8sr4+3QWW05nc+Rc4SWtGG721gxo4Un/FiJE5+lovoo4C+bFx9mGyV0CmNwlAEmSOJ2pZntcLv/G5hCdWkhcdglx2SXM35aIp6OK4W28GdXOlx6hbpecQJskHhFwz29waiOUKcGkh4IkITDiHCD6oS1cglYv1Kc8HVVYXfj/6vV6FEolReV6FHIZ1krxuFqtZtiwYQwaNIhDhw5x9uxZZsyYgb29Pc8991xjvg2LkawVTSEEtBEC5ZIkwq5DXrNM6LhGEnNL2Xgikz9jMon9j65jWz8nhrTyYlArL9oHuFhyijchMpmMtn6ikGrWoAiKynVsj8tly5lsdsTlklui5ZcDqfxyIBVXOytGtPVhbAc/eoa5N93Pg0wGEUMgKRFsHUBfAJoicSHt5At2HrWfG0wGkDet0+3PP//MZ599RlxcHPb29gwePJjPPvsMLy8vJEkiMjKSRx99lOeff77qNSdPnqR9+/bEx8cTHh5OcXExL7zwAuvWrUOj0dC1a1c+/fRTOnTogAR8Nu8ddv+ziaefeor//e9/pKSkUFiqoahCh42VAkcbcXHxyy+/oNFo+PHHH1GpVERFRXH27Fk++eQTnn322Ub1JpvWf60pMXQuDJx9+RWixUDWSlpBOX+cyGD9sYxLDKNCLqNXmDvD2ngztI1388pNWagXXOysmdDJnwmd/NEZTOxLyuevk5lsPpVNQZmOFYfSWHEoDU9HFWPb+zG+ox/tA5wbPdRWIzK50IWVe0JxGujLhVCIOgNcgi89Z+jKoSJfDDgwGcHRB2xuvJgEa/sb3oVOp+Ptt9+mZcuW5OTk8MwzzzBjxgw2btyITCZj5syZLF68+BIjuWjRIvr160d4eDiSJDF69Gjc3NzYuHEjzs7OLFiwgCFDhnD27FnsnZxRyGUkJSayatUqfv31V8r1JvJKtciQ4XfhPCBJEvv27WPAgAGoVCrKtAbySrUMHjqMl19+mZSUFEJDQ2/4/dYVi5GsjW4PWEIo10BhmY4NJzJYG53O0dSiqseVchl9IjwY3c6XYW28cW1KM+csNCrWSjkDWngyoIUnb483cTC5gD9OZLLpZCa5JVoW7Ulm0Z5kwj3tmdg5gNs7+VedUJsU1naiaK8sF0oyYUEDCoO8WXzDu5g5c2bV72FhYXzxxRd0796d0tJSHBwcuP/++3n99dc5ePAg3bt3R6/X8/PPP/Phhx8CsG3bNmJiYsjJyUGlEmmSjz76iHXr1rFmzRoefvhhrBRytDodH83/HkcXN+z0JuRyOX7ONijkMiRJQiaTkZWVRUhICAD2KiUFZTpKZeJCICsry2IkLTQdstUaTmeoaevvhJdjzSXueqOJbbE5/HY0nX9is6uEv2Uy6BnqzviOfoyM8rFUolq4KkqFnN4RHvSO8GDuuLbsis9l3bEMtpzOIjG3jA83x/HR33H0Cffgzu6BDGvj3bTaSmQycPBqlgU80dHRvPnmmxw7doyCggJMFyp2U1NTadOmDb6+vowePZpFixbRvXt3NmzYgEaj4Y477gDgyJEjlJaWXqY8VFFRQWKiGPvnZGtFYGAQji5uGE0S3k4q7KwVWCsVmCSpSssYLu19DHSzoyBHOCnqisYVkbcYSQsA5Kg1vPxbDLsT8gj1sKdEY+DV0a0Z2tq7KrmenFfGikOp/HoknbxSbdVr2/o5cXsnf8Z28LuiRJoFC1fCWilnSGtvhrT2pkSjZ1NMFr8ePc+B5AJRNZuQh5u9NRM7+TOtRxBhng6NveRqlCp4JaP6fmkulGYLDVilTXWapiRTTBbyiGycdV6grKyM4cOHM3z4cH7++Wc8PT1JTU1lxIgR6HTVA+EffPBB7r33Xj799FMWL17M1KlTq9SGTCYTvr6+bN++/bL9u7i4VP3u5OhAkJsdEiCXydAbTRhNJhQXDYbw8fEhKysLoMq7NFWIljCjjTNZxRp8nBvn3GIxkhYAWHkoDbVGz59P9sXVzpoP/orjy38TKNHomdotiP9tOMXC3SlV23s4qJjY2Z+Jnf1p5VMPORYLFi7C0caKKd0CmdItkLSCclYdTmPV4TSy1VoW7k5m4e5k+kV6cE/PYIa08moa1bEX5wl1SULuzr5ayUgU71gJr1Npc/lwhAYkNjaWvLw83n//fQIDAwE4fPjwZduNGjUKe3t7vvnmGzZt2sTOnTurnuvcuTNZWVkolcqqUGltyGQyZAi95cxiDUiXtoX06tWLV155BZ1OVyU59+emv/Dx9SUwKJjCch2udlaoGmHAQBP4ZFloSI6nFbH8YCopeWUYjCK8otEb2RmfS4SXIxFejrg7qHhldGs6Bbnw/a5kADoFuSGXwZBWXiy4twv7Xh7MK6NaWwykBbMT6GbHc8NbsmfOYH6Y3pXBrbyQyWBXfB6PLD1Cvw+28c32RIrKdVffWUNQUQTILg/B6srBUCGGG8gV1DifzWQSxtTMBAUFYW1tzZdffklSUhLr16/n7bffvmw7hULBjBkzePnll4mIiKBXr15Vzw0dOpRevXoxYcIENm/eTEpKCnv37uX//u//ajS4IFSZFHIZCoXskgubu+66C5VKxYwZMzgRE8PiX1Yy7/33uefBx/F3tSPMwx6VlQjRmhpYJM7iSd4i/HUyi/c2naFMayTA1ZbvdiYxtr0vzw5vSUGZDp3BRIh7tY6is60Vo9v5subIeQ6nFDC8rTe75wzCz8Ui7GyhcVAqqsOxaQXlLDuYyspDaWQWa5j3Vyyf/3OWiZ0DmNknhAgvx8ZdrEx2acuHUSdECCTTpd5lJSajGARdlie2UdqItjMztY14enry448/8sorr/DFF1/QuXNnPvroI8aNG3fZtg888ADvvvvuJYU+ILzDjRs38uqrrzJz5kxyc3Px8fGhf//+eHt71/h3ZTIZ/i62VKqhVuYlXVxc2LJlCw8/+hjdunXDydmFR2c9ydxXX8LuIkGR3BItRpOErbz28W/1jUW79T/Ut+5fUyCjqIKnVkTTL9KTh/uHoa7Qs3T/OdZGp7P12QHYWCkY9fkueoS58eKIVthai5BGtlrD7GVHCfd04P1J7TGZpOahkmLhlkFrMLLheCY/7E7mdGa1rOHQ1t48OiCMriFuV3j19XMlzdAqdGVQmCKGHVhdqMotyYSKC0MS7D0v77fWlop2EqUN2LpBeb7wOl2CQNW4Bn/Pnj0MHDiQ8+fP12r86kJl7hFArdFTUKqjTGfAUWWFp6Oq6jxUuS0IfWedQaKgpBRNQRbtWkWaXbvVEm69BUjJKyM6tYiJnf2xsVLg5WSDjZWCSC8HyrQitDOgpSc7zuZeUpDjZCNGIyXmiuntFgNpoamhUiqY1CWAP5/sy8qHezK8jTcyGWw9k83kb/cx6Zu9/HMmmwb1BZQ2wjgWJInh7HkJYsCzjZMwkBdTuS7JJMbquYaArTO4h4HSVnifjYRWqyUhIYHXXnuNKVOm1KuBhOpq1vTCclLzyzGYTIS42+PvaoutteKS/5lMJkMmk+HpaIOviw1+zjaUaAz8cya7tt3XGxYjeROQmFuKppZBw5X4utjw075zojjnRCZ/HM+gV7h71dXaXd2CyCiq4EBy9fxAW2sFao0ebyebq+7fgoXGRCaT0SPMne/u68rWZwdwZ7dArBVyjpwr5IElhxn9xW42xmRiMjWAsZQrhBdp7wm6UlH56hIETn4XL/jSn3KFmF+ruzAOTpLEDEtdqQjFNgLLly+nZcuWFBcX88EHH5jt73g52hDoZkewuz32KiXyqkNz6UX5xUbTXmWFSinn7H/UvMyBJdz6H5pLuFWjN/LD7mQW7U7GWiknyM2O+/uEMjLKB6j+QMlkMowmiY0xmeyOz2NtdDruDtZ0DXEjPrsEuUzG53d2JNLbkUeXHqGwXMcLI1rSNcSNCp2RKQv20T3UjdfGtGnMt2vBwnWTo9bww+5kft5/jrILw7kjvBx4ckgkY9r51ikyck3h1ou5OKxqMkBpjqiCVTmJxzVqKC8QxlBhLdR7bF2Eqo+2VBT/OPuL/Rj1oC8T+U1bt5te7KQyHHvxuawSjUbDwROxrE808NFdl05fqu9zuMVI/ofmYiS3ns7mo7/jeGxgOBFeDizclcyRc4U8MTiCO7oG1pg/nPdXLNlqDa+NboOrvTXZag2PLD1CkJsdX9zViZPpxXz1bwJ7E/O4o2sgh88VYjCamD+tMyEeNy6DZcFCY1BYpmPx3hQW70mumjrTyseRp4e2YERb7+uSvrtuI3kx2hIoSgVbV+FVmkxQlCKec/ABKxvQV0DhORGatXERqj4yuTCu5QXC0CqtQVcBzn6Xh29vAi7OVV6M0SQqW3UGE3lFJSQkJWOy92RY+8BLtrPMk7SA0SSx+VQW9ipl1ZiiT6d25LlVx1l2MJWRUT5VwsGVlGkNHDlXyNgOfrjaW19Qv7Chd7g7W06LuH6UvzPzJrVn08lMdsbnMrCFJ/f1CsbdwTKZw0LzxdXemmeHteDBfqEs3p3Cwl1JxGaV8OjPR2jn78yLI1vSL/L6jE2dfAuVowjDVnqAklF4hdaOwhjCBS/TUYRYVRfEEjRqYSRtXcDBW7y+LFeM87Nxuek8ykoDmaPWoDWYMEkSeqMJvVGqdsr1RlztrAkOdjX7eiw5yWaIDEjKK6N3+KVyUGPa+6Ku0LPppFCuMJqkqhxMTokWncFEbokozFHIZeSUaNiTkMfAlp6YTBKSJOFsZ8Wd3YP4+u4uPDOshcVAWrhpcLKx4qmhkeyeM5jZgyKwt1YQk17MvT8c5O6F+zlxvuiq+7CyEgapvLy8bouwsq1u61BYgUIljOXFKKxE2LWS4vPCeNp7VhtE6wv5S2MT6Q2tR6RKb7FUR2G5DgeVEk9HG/xdbAnzsCfC0wE/RytsrRU42Zn//GTxJJshcrkMB5WShJxSdAZTlWxca18nWvk4sfV0NlO6BiKXVV+VhXrY0y/Sg8W7k8kt0eBka8W22Bycba24q3uQpXLVwi2Ds50Vz49oyf19QvhqWwK/7E9lT0I+477aw9gOfswZ2ZIA15r7gRUKBS4uLuTk5ABgZ2d3Y5NKFA6iAlarF/lHQ4WohLV3B41GhFi1erD1BoMEBo14nbYMJJXYxtSEtGzrkSBnJWmFFeSrS/FzsUUpl2MyGDGYTOTm5mBnZ4dSaX4TZslJ/ofmkpNceSiVeX/FsempflV6qSaTxKdbz3IgqYBv7umMu4OKxNxSrBVyAt3sKC7Xs/VMNnsT8yks1zGmvS8TOwc08juxYKFxSSso59OtZ1kbnY4kCQ3ZB/uG8tjA8MvSFiA8naysLIqKiupnASaDUOkx6QG58Bbt3ESxTlmOkLKrLOYRCxD5TV2pCL82orxdQ5BXqkVvlHC3t65yCORyOaGhoVUSdhdjKdwxM83FSBaW6ej53j+8Nb4tk7sEVg2q/erfeLbH5bL0gR6kFpQz59cTtPZ14r2J7apeazRJTXewrQULjcSpjGL+t+EM+5LyAaFP/OLIlkzuHFBjpMVoNKLX1+OEipJs4U0qrIThK8uFjXMgYjB0uqd6u5xY2PiieLzv06IASH5zZ86++jeeQymFvHt7FP6udlhbWyOv5T1bCncsAKIYYUx7P5YdSKW1rxPtA1wAiM8Rjf+21gqC3e3oEuxKK59LFTssBtKChctp6+fMsod6sPVMDu9uPENyXhkvrjnBsgOpvDW+bdV3rBKFQoFCUY9enE2w+FnZNiJzhdzjENodKitp1RkQsxRKU2Dwize9cazk+VHtOJVRjLuzLTY2DTuCz+JJ/oem7knGZZWQmFvKqHa+pOSV8cb6U5zKUPPc8BbEZZXwb2wO709qR+/wGvQhLViwcE3oDCZ+3JvM51vjKdMZkcngzm6BzBnZqmHnpP7zNqTshtEfiYrXvV9A1kkY8CK0myweu8nDrf+lsEzHsoOpPD4wvMZ8sCXcamaaqpEsLtfzyZY4lu4/h521ku0vDMTDQUVWsYal+1M4lFyIQi7jwX6hDGldv/JRFizcqmSrNby/KZa10ekAuNlb8+qo1kzs7H9jBTvXiqYYfp8FSTvAyR8UShgwB1qPNf/fboLojSZGfLqTpLwy5oxsxWMDwy/bxmIkzUxTM5Imk8TqI2nM+yuOgjJR7j2yrQ9zx7fFy1FV9UU1GE1NY6Zec8dkFCcmTZEojtCWigIJfTnoNaK60KAVxRYmvfj536+QTCaKLRRWQkVFqQIrO6HpaW0n1FZUjuJm4yyea4gTroU6czC5gP9bF8PZbJHO6BXmzju3RzXc4Oe8BPF5c/IXQgNwuUj6LcKyA6m8sjYGuQyWP9STHmGXtsJZjKSZaUpG8nSGmlfXxRCdWgQISa2549rSJ8ISSr0uJEkUQRSfF9MY1BniZ2mOGE1UlgvleaI5uzEEpRUqUc1o6yp64Ry8RNWig5c4KTr5iZujn1BbsdAo6Awmvt+VxBf/xKO90Hr1zNAWPNQvtOEvUA8sEDJ1vWc37N9tAkiSxLOrjrM2Oh0vRxUbn+qHx0X93BYjaWaagpEs0xr4bOtZFu1JwWiSsLdW8MywFkzvHYKVxVusGaMeCpLF5IWCxAs/k8X4oaLU6v6ya8XqgvKJykE0blvbC49QaSt+KqxEU7hcWV2aD4AkvFGTQdyMugseaIWQHNOVg65EeKka9eWN5FdCJheG0jUYXILFpAj3CHALB/dwsUYLZic1v5xX18WwKz4PgHb+znwwuT2tfRvofJEVA9/2AyTo+TgMf+eWKeCppExrYPz8PSTklNIv0oMf7+9eVZBoMZJmprGN5L+x2fzf2pNkFIuT+qh2Prw+pi0+ztepE3mzYtBBfjxkn4ac05B3FnLjoDD5KhPdZcI7q/LKfMV9ew/hsdl5VHtzlWX45kaSRCi3olA0jZfnC8+2NFv0x5VkiUZzdbrwfo3aK+/POQg8W4qbVxvwbgterYVRt1CvSJLEmiPneXvDadQaA0q5jCeHRPL4wHDze5WSBHu/hC2vifvtpsCEr286ebqrcTa7hPFf7aFCb+T54S2YPTgSsBhJs9NYRjK/VMvcP06z/ngGAAGutrw9PopBrbwabA1NDl25uGrOPF59y4290HRdA9YO4BYqPCu3MPG7S9CFMUUBzTtUKUkiPFx0TghgF6YIbzk/HvIToaKg5tfJleDRAnw7gF8n8OsMPlHVw4At3BA5ag3/t+4kf1/QP+4Q4MzHUzoS4dUAucoTq2DdY+LisMVIuOPHW+7/uubIeZ5ffRyFXMbKh3vSNcTt1jWS7733Hr/99huxsbHY2trSu3dv5s2bR8uWLau2mTFjBkuWLLnkdT169GD//v3X/Hca2khKksTvxzKY+8cpCsv1yGXwYL8wnhna4pLJ3Dc9kiRO+mkH4PwhOH8Ysk/VHI60dgTvNsJb8motjIBHC+Eh3oKFDIDwRHPjxEVEbqw4dtknhZf6X+RK8GkHgT0gsDsE9hTjmCzUicrv8Ou/n0StMaBSypkzshUzeoeYX+7x7GZYdZ9IJwT3gbuWi0jILYIkSTyz8hjrjmXg72LLxqf6IdNX3JpGcuTIkdx5551069YNg8HAq6++SkxMDKdPn8beXuRiZsyYQXZ2NosXL656nbW1NW5ubtf8dxrSSOaUaHh17cmqKRytfBz5YHL7y5qWb0pMJsg5JXrAzu2F1P0ixPhfHLyFB+TTXnhDPu2EZ3irGsPrQZJEqDYrBjKOQUY0ZBwVhUr/xSUYQvqKE21oP3GMLVwXmcUVvLjmRFWusl+kBx/f0QEvJzOnSs7thWVTQasG345w71qROrhFKNHoGf3FblILyhnd3pd3R4fj4uJy6xnJ/5Kbm4uXlxc7duygf//+gDCSRUVFrFu3rs77bQgjKUkS649n8Mb6UxSV67FSyHhycCSPDgy/eQtzJAny4iFpGyTvFMZRU3TpNgprYRADu4N/VwjoKqo7LQax/pAkUcyUdvDCbb9oTv+vx+4WBqEDIGwghA0QuVoLV0WSJH7ef453Np5BozfhZm/Nh5Pbm793OfM4LJ0oqrS9o+DedeBw882arI1jaUVM/mYvBpPEW7eFMX1gG4uRTEhIIDIykpiYGKKiogBhJNetW4e1tTUuLi4MGDCAd955By+v2vN6Wq0Wrba6IEKtVhMYGGg2I1lUruPVdSf580QmAG39nPjojg4NVxnXkGiKIXEbxG8RxlGdfunz1g4Q1BOCe0NQb2EgrSwFSg2OtgRSD0DKLji3B9KPXmo0ZQpx4RIxFCKHC2/ecuFyRRJySnhi+THOZKoBmNE7hJdHtUKlNGMKJTcOlowVhV+ereC+38HRx3x/r4kxf1sCH26OwxYtsfMm3dpGUpIkxo8fT2FhIbt27ap6fOXKlTg4OBAcHExycjKvvfYaBoOBI0eOoFLVXOH35ptvMnfu3MseN4eR3B2fx/Orj5Ol1qCQy5g9KILZgyNuLu8xPxFi/xS5krT9l1acKlTCKIYNFF6KbwehIGKhaaFRC2OZtAMS/4W8uEufdw6ElqOg1WhxgXOLVVVeKxq9kQ/+imPRnmQA2gc4M39aZwLdah7DVS/kJQhDWZIh2oOm/yFy9bcABqOJqd/t59DZdNI+m3JrG8lZs2bx559/snv3bgICah/1lJmZSXBwMCtWrGDixIk1btMQnqTWIL4sP+wWX5YwD3s+ndqRDoEu9bL/RkWSIP0IxG6A2I2Xn1DdI4X3ETEEgnpVT2C30HwoShXRgPgtkLRd9HxWYusqjGWbCeLCpzlXEJuJf85k8+yq4xRX6HGyUfLRHR0Y3taMHl5BEiwZJ8LqbmEwYyM4+Zrv7zUhUvPLGf/pFo69M+HWNZJPPPEE69atY+fOnYSGhl51+8jISB588EHmzJlzTfuv75xkYm4pTyyL5vSFsMs9PYN4ZVRr7KybsQdlMsH5g3D6dzi9HtTnq5+TKyGkH7S8DSKHiS+phZsHXbkwlHF/Qtwm0dtZiY2z0BRtd4f4DNxiwttXIr2ogtnLjlapZz06IJwXRrQ030SewnPw4xgoThUXqvdvFP3AtwA5+YV4e7jdekZSkiSeeOIJ1q5dy/bt24mMjLzqa/Lz8/H39+e7777jvvvuu6a/U19GsrLZ+I31pyjXGRsugV8X1JmiiMarde3bSBJknYCY1XBy7aWG0dpBeIutRou8la2LuVdsoSlgNIiw7Jn1cOYPkQurxMEboiZBx2kih2kBvdHE+5tiqyJK/SI9+OLOTrjam8n7LkyBxaPFd9WzNczYIMQzbnJu2T7Jxx9/nGXLlvH7779f0hvp7OyMra0tpaWlvPnmm0yaNAlfX19SUlJ45ZVXSE1N5cyZMzg6Ol5h79XUxwEu1Rp4dW0Mvx8TwgC9wtz57M6OeJu7FPx6MOrh2C+wb74osLHzEFWMvWaBc0C1eHJxOpxYAcdXCHWbSlROIi/VZjyED7YU3NzqmIyijSdmNZxed2l/pk97MTS43R23VGtCbfxxPIMX15ygQm8kwNWWb+/pQpS/mXob8xPhx9FCq9i7HUxff9P/D25ZI1nbWJrFixczY8YMKioqmDBhAtHR0RQVFeHr68ugQYN4++23CQwMvOa/c6MHOC6rhMd+OUJSbhkKuYxnh7Xg0QHhTW/Q8en1sOtj6HAXtJ0AMWuEIWw7Hvq/IGTfNr8sije48BFR2kCLERA1WXiOFsNooSYMOkj8B44vF3nqSoUkhQrajIMuM0Q/5i1cIRubpebhn46QWlCOjZWcj+7owJj2ZiqwyYsXhrI0W7RW3fe70CS+SblljWRDcSMH+Ncj53l1XQwavQkfJxu+mtaJriGNfNVmMkLqPnANER4iCKHttY9ARZG4sqx8bPEoMci11ywhgfZJa1GdGtxHGNM246vH9FiwcC2UFwjvMnqpEDWoxD0Sut4PHe++ZcPzxeV6nloZzfY4Ie7w1JBInh4aaZ45ldmn4cdRwsMPGwTTVt60mr4WI2lm6nKAtQYjc/84zbIDqYDINXw2tSPuDo34IcxLgH/mihJ+Jz8xs7DlbTDwJTEj8a85kHtWXFVa28GZDXDoexg/v9qYxqwRDf2uIY33PizcHEiSUPw5ukR8rnRiLiNW9tDhTuj+MHi1atw1NgJGk8R7G8+w8EKecnR7Xz6a3ME8kpTnj4j2EH0ZtB4ntF5vwuIqi5E0M9d7gLOKNTz2yxGiU4uQyeDJwZE8OSSyccOreg38+ZyQqer/gshBHFggwqkPbxNG8Nw+2DFPhLxS94uTmHuE8BQ7T4cOU0UV6y02gsdCA6AtEd7lge8g90z14xFDodds0Ud7i4ViVx5K5dW1JzGYJNoHOPPD9G54OprhIjtxGyybIka4db4Pxn5x0x1ri5E0M9dzgA+lFPDYz0fJK9XiZKPk87s6MahlEyizLkiC+T1g6s8ihwgiN/Tv/2DigupqQ3UG/PawmCDQcZoIxUT/LMbwvHzeknO8DrQGI/mlOvJLdRRV6Ciu0KOuMKDW6CnXGijXGSnXG9HojOiMJgxGCb3RhPE/Xz+FTIZSIUOpkKNSyLGxVmBrJW72KiVOtkqcbKxwsrXCzc4aNwdr3O2tsbFqhh6BJAmVnwMLIG4jSCbxuHc7MUw4atItJVSwPymfx34+QmG5nkA3W368vzvhnmbIHZ5eD6uni+M94CUY9HL9/41GxGIkzcy1HuDlB1N5/feT6I0SrXwcWXBvF4LdG2jobVGqaOJW1VKxm3EM1j8hpMRGfyxmFG58QXiQw9+u3u7MH7DtXZi+AezdxWPqDFjQH8Z8Bq3HVFe53sLojSYyiipIK6ggrbCc9MIKMos1ZKnFz1y1lhLtlWZZmh8HlRIvJxU+Tjb4ONng62JDgKsdga52BLrZ4u9ia/45hzdCQTLs/0ZcpOnLxGPOQdDnSeh07y1zwZacV8b9iw+Skl+Oi50VC+/rap66hsOLYcPT4vdxXwqv8ibBYiTNzNUOsMFo4n9/nuHHvSkAjG7ny4d3tDe/OIDRIFo2dn4oxuJ4tREl9Z3vFc9fbMyMBlGGf2KlGJtUkiVmLCIJwfAR74r8z5/PiRaPsZ9VazweXwlb34DbvxVhr1uIMq2Bs9klnM0uIT67lKS8MpJyS0krrMBouvrXRCmX4WZvjZu9dZW352SjxF6lxE6lwM5KiY2VHGulHKVCjpVcVhWWl8lkSJKE0SRhMEkYjCZ0RhMVOhMVeiMVOgOlWiNqjZ4SjZ7iCgOFZTryy7Tojde2tiB3O8I8HAj3tCfS25FWPo5EeDk0LS+0ohAOLxIGs3JaiYM39H4Cuj5wSyg25ZdqeWDJYY6lFWGtlPP51I7c1s4Mijn/vA27PhLavNNWCvGPmwCLkTQzVzrAxRV6Zi87WjUK57lhLZg9OMI81Wj/Je0gbHhG5AuDe8GRJULxZuAc6PZgza85vlIY1mFvCZ3UjGjY/KrIO05bCXF/wZbXxVikAS8KD/T4cvDvLDzQm5hstYaT6cWcylBzMr2YM1lq0goqat1epZQT4GpLoJsdAa62+Drb4utsg4+zDV6ONng6qHCyVTbMZ+EiJEmiRGsgt0RLtlpDtlpDVrFWeL6F5ZwvrCCtoBytwVTj6+UyCPWwp62fM239nIjydybK3xln20YOc+or4OhS2PN5tXCFvRf0fUZUxd7kw4UrdEaeXBHNltPZyGTwzoR2TOtRz+PLJEkMbT6+XBRQ3b8R/DrW799oBCxG0szUdoBT88u5/8eDJOaWYWul4NOpHRgZ1UB6iJIk8omn1sKsg9Wi4BueEYZvylJwCaz2Jit/rrhbVKaOeEe0gsgVcORHEWJ9/qwozDn1mwhxFZ8X+Z/O00Xo5Sa6YtfojZw4X8zR1EKOpRYRnVZItlpb47aejqoqDyvM04FwD3tCPe3xdrQx/wBdM2EySWSpNSTllpGcV0pCTilx2SXEZZVQWK6v8TXhnvZ0DHSlU5AL3UPdiPB0aJz3b9AJMYudH4o0A4CDD/R/XvRb3sQ5S6NJ4rXfT1ZVzc8Z2YrHBobX7x8x6EQhT9I2cPSFh/5t9oLoFiNpZmo6wNGphTy45DD5ZTp8nW1YOL0rbf0aePr3L3eInOKoj6rLtpN3iYb/dndAn6eEIZTJhYEsyYY19wtR8SGvie0NOvGYtgTuXFbdUFxRJJL4N4kSR7nOwKGUQvYn5XMouYAT54vRGS/1pOQyiPByqPKg2vg50crHCTdzSYQ1QSRJIrdEy6lMNacz1JzKKOZkuprUgvLLtnW1s6JbiBvdQ93oG+lBS2/HhvWaDTo4vgx2fiSEuwFcQ2Hw/0HbiTdtFbYkSXz0dxzztyUC8MiAMF4a2ap+j72mGH4YLlIzvh3g/k1g3UD1FWbAYiTNzH8P8KaYTJ5eeQytwURbPycWzejWOPJyv8+C/CS4Z031B7i8AP7+P+EFTl9/eZHN1jfh2HJoP0WEUGM3iuGsoz64qfKNJpNETHoxO87msichj6OphZfl6TwdVXQNdqVjoAsdA11oF+DcvEXmzUhBmY7jaUVEpxZyJLWQo+eKqNBfOpTZw0FF3wh3+rfwZEALz4brCTboRK/ljnnVOUvfDjD8HQjt1zBraAS+25nIuxtjATEk4a1xUfXr2RemwPeDhWB967Fwx0/N9sLDYiTNzMUHeM2JfN7+8zSSBINbefHlXZ2wVzXSiTVuE6yZCY/tuXSyxq5PxPzGKUuEp1mWLwp7nP2FN3l8uSizL0gWucyej4N328Z5D/VIUbmObXE57IjLZWd8HgVlukue93O2oVe4Bz3C3Oge4kawu12D5wtvFvRGEyfTizmQXMC+xHwOJOej0Vd75jIZdAhwYXArL4a09qKNr5P5j7W2VBT37PkcdCXisZajRfW2ez2HJJsIKw6m8vLaGCQJpnQN4P2J7evXUKbuF2IDRh30ew6GvF5/+25ALEbSzFQe4NfXHGTJoRwA7u0ZzBtj2zRuCb2+Aj5uCQPmQPdHqvOSB78Xkl/3/CZUTP58TuQUxn1Z/dqKoptC+iutoJzNp7LYeiabQymFl1ScOqiU9Ilwp1+kJ30iPAixGEWzoTUYOXKukN3xeWyLy+XMhTFwlQS42jK8jQ8j2nrTLcTNvLnMsjzY/p5oaZCMYlRb90dEQZtNA6dEGoB10ek8u+oYJgkmdQ7gg8nt61e45PgKIVkJMHmR6FVtZliMpJmpPMCBT69CrrLjxZEteWxAeNM44W6aI/KQYz+HwG7isT+fF57irANg0MLG58EpQCjtyOXNvs8xNb+cP2My2RiTSUx68SXPtfJxZFArLwa28KRzsCtWTbkP8CYmq1jDjrM5bD2Tw6743Eu8TG8nFaPb+TGuox8dApzN9z3KiYUtr0H83+K+vRcM/59INTTjz39NbDiRwVMrjmE0SdzeyZ+P7uhQv4by79dg7xdCyvKBv5vdqDOLkTQzlQc45NnVfHBXD+7oeu0TRMzCuX0iBzN+vuh33PAMZByFIW+IXGTMKnEyaDW6cddZj+SWaNlwIoN1xzI4nlZU9bhcBt1D3RjexodhbbwJdLt5KnBvFip0RnbG5wqP/3Q2ak21yEKwux23d/JnYqcAgtzN9L9L2CouJvMTxP2gXqKd6SZIMVzMpphMnlgejcEkMbGTPx/Wp6E0GeHnSaLi1SUYHt7erIr6LEbSzFQe4PWH4hnbNaLxFlKUJnoYT/0m7o+fL2byqTPh4AI4t1fkDro/Au2nNtskeyUavZHNp7L49Wg6u+NzqYykymXQK9ydUe18GdHWB4/GFI23cF1oDUZ2nc1j/fEMtpzOvqT4p1uIK3d0CWRMB9/6L6AyaMWc1J0fgr5chGB7PwH9X7ypWpv+OpnJrGXRGE0Sd3UP5N3b29Wfp15eAN8NhKJzED4E7l7dbMTQLUbSzNT3Ab5udOWw5zNRkGDQADLoMh0GvQr2ntWhI4O22Y+6kSSJE+eLWXU4jfXHMyi5yOvoEOjChI5+jGnvZx6hZwsNSrnOIC6CjqSzJzGPyrOOo0rJuI5+3NU9qP4HDxefF15l7AZx3zUERn8CEUPq9+80In8cz+CpFdGYJLi/Twivj2lTf4YyKwYWDgNDRbPSeLUYSTPTaEZSkkQF619zqpumQ/rByPeaXU7gapRpDaw/nsEvB85xMr266MPfxZZJnf2Z2DmAEI/m26dl4cpkFlewNjqdlYfSOJdf3ZPZOciFGX1CuS3Kp37zy7F/Cu1idbq43/FuIc14ExSzAaw5cp7nVx8HYPagCJ4f0bL+dn5sOax7FJDBPb82iwsMi5E0M41iJAtTYOOLEL9Z3HcKECo5bcbfVEUHyXllLNmbwq9HzlcJglsr5IyM8mFqt0B6hbk3W1UbC9ePySSxPymfZQdT2Xwqq6q31ctRxT09g7mnZ3D9iTtoS4Rq1YEFgCTUZcZ+AS2G18/+G5ml+8/x2rqTALw6qjUP9Q+7yiuugz+eEkpddu7wyC7RXtaEsRhJM9OgRtKoh31fwfZ5IqQhtxIjgvq/0GwULyRJumJ4x2SS2Bmfy497U6omsIMo4ri7RxCTuwTeUio3Fmomp0TDsgOp/HIgldwSIRloYyVncpcAHugbRmh9RRZS98O6x6FAKNjQ8W4Y+b7QM27mzN+WwIeb4wD4ZEoHJnYOqJ8d6zXwwzDIOgHBfWD6H006P2kxkmamwYzk+SPwx5OQLa7+COkn8iWeLcz3N+sZk0mq1fPTGUz8fiyd73clcTZbTKGXyWBQSy+m9w6hX4SHxWu0cBk6g4lNJzNZuCu5quVHJoMRbXyYPTiifvKW+grhVe6bD0iignPidxDU88b33YhIksT//jzDD7uTUcplLJzelYH1Nd82P1GM0NOVwsCXYeBL9bNfM2AxkmbG7EZSVya+oPu/ASSwdROh1Q53NZvQamp+OV9vTyCtsJwof2eGtfama4gbkiQhSbBwdxI/7E6uEhF3UCm5o2sA03uFWHKNFq4JSZI4kFzA9zuT+Cc2p+rxIa28eGJIJB0DXW78j5zbB2sfFjUAMrlQmRkwp1mLpptMEs+sOsbvxzKwtVKw4uGedKiPYwVwYhX89pA4VtP/gJC+9bPfesZiJM2MWY1k8i5YP1vkIEEYxuHvVA88bgasOJjKR3+fpUeoG91CXFlxKA1bawUL7+tapd9513f72ZeUj5ejipl9Q5nWIwgnm+Z74rHQuJzNLmH+tgT+OJ5R1Ro0qKUnzw1veeOepaZYVMAeXy7u+3cRSjOuITe230ZEZzDxwJJD7IrPw8PBmrWP96m/nuJ1j4vxe45+QiKzCfZPWoykmTGLkdSWikHGhxaK+04BMO5ziBhaP/tvIEq1BqYu2Mftnfx5sJ8oDPjrZCafbY3ng8ntaR/gAsCRcwUk5pQxvpMfKmXTzV1YaF4k5ZYyf1si646lV0kSjmjrzbPDWtLSx/HGdn5qrShQ0RSDyhnGfykK55oppVoDU77dx+lMNZFeDvz6eO/6uVDVloqwa0GimL4yeVGTi4DV9zm8eXegNwdSD8C3fasNZJf74fF9Td5AFlfo2XE2l6JyXdUJKSWvDJ3BhK11teGr0Btp4e1YZSABugS7MaVboMVAWqhXwjwd+HhKB7Y+O4AJHf2QyWDzqWxGfr6TF1YfJ6tYU/edt70dHt0NAd1BWwyr7hM6yPob2Gcj4qBSXphYpCI+p5RZvxxF/59xcXVC5QATvweZQgidxKy+8X02cSye5H+ot6sQgw62vytEASST8B4nzG/yI6rSCsp5d+MZdifk4etsg0IuZ2wHXx4fGEFGUQUf/R3H9rhcnhvegr9PZbMzPpc2vk50CHTh9k7+dAtxu2JBjwUL9cXZ7BI+3XKWTSezAFEN+3C/MB4eEI5DXaf1GPWiZmDPZ+K+b0eYuhRcguplzQ3NyfRi7vh2HxV6I9N6BPHOhKj6ERvYPk+c31TOIuzq0sjynRdhCbeamXo5wLln4deZQrECoMM0uO39Jj+VoExr4P/WnaRMa+DFka0AiRUH09h0Mou/n+mPvUpJTomGIymFzN+egI+TLbMHC+P5x/EMDqUUcvj/mraHbOHm42hqIe/+eYbD5woBMTv0pZGtuL2Tf90v1uK3iCKVikJRXDf5BwgfXI+rbji2nM7m4aWHkSSYO64t03uH3PhOjQZYPBLOHxKV+fetbzLSmJZwa1NGkkTT7YL+wkDausHUn+H2b5q8gQRIyS9j3bF0HhsYToSXAxFejoR5OhDkZofOYMJokvBytMHZzorCMj3vToyiY6ALo9r5MmdkK7QGI7vj8xr7bVi4xegc5MrqR3vx7T2dCXG3I7dEy3OrjzPxm72XCORfF5HD4JGdwpOsKBCC37s/hWboUwxr483Lt7UC4K0Np9mXmH/jO1Uo4fYFoLQVU4gO/3Dj+2yiWIxkfVFeAKvuFcl/QwWEDRK5x9ZjG3tl14zOYCLMw579SQWAkA/bGJNJlL8TJkmqmjJwJKWQDoHOOKqqCwFis0qwtVI0tRy+hVsEmUzGyChfNj/Tn5dua4W9tYJjaUWMn7+Hl349QVG57uo7+S8uQTBzsxgsIJlg65vCu9RX1Pv6zc1D/cIY39EPo0li1rKjpBfVw3twD4dhc8XvW96AwnM3vs8miCXc+h/q5KqnHYQ1M6E4TajmDH0Des5qMuGHSk5nqHG2s8LLUXWJNmalak6p1sDP+8+x/lgGJkkiMbeUzkGuaA0mCst1PNgvjHt7BvPTvhR+3n+OcR38mNYjmIyiCr74Jx4rpZzPp3Zs3OHU9Ym+AkpzxK08X3gU5QUiBKctEY3VWrXofTVoxfYGLZj04qRqMoqfMrlQKJHJxedDqQKlDVjZiJl9KidQOYqbrYuIQNi5gZ0HOHiBg7fY1sI1k6PW8P5fsfx2VOi1uttb89qYNozv6Hf9OTlJgsOLYNOLYDKAX2e4cxk4+Zph5eajQmdk8rd7OZWhpq2fE78+1hsbqxssrjOZ4MfRkLoXQvuLsGsjXylbcpJm5roOsCQJWbmtb4ovj1uYKIn269Qga71WdsXn8sbvpygs1+HtZEMLb0deH9sGDwdVjbJyR84V8u7GMzw/vCW9wt0pLNOx7GAq3+5IJObNEWj0Rt7fFMuGExn4OtuSlFvK0DbevDiyFf4uto30Lq8TSRIGryAJCpPFVXBxmpgcUXxezO7UFl99Pw2FjQs4+YFzIDgHiEIJ11DxmXMLE1WHFi7jYHIBr66NIT5HqD71jfDgvYnt6tY3mLxTVL1WFIo+wbuWg1/H+l2wmTlfWM64r/ZQUKZjcpcAPrqjw43vND8RvukjImjjvoTO9934Pm8Ai5E0M9d8gCuKRGNt3J/iftvbhWByE9OAzC/VMmvZUToGunJ3jyBOZah5e8NpOga58Na4trhfZCgrf87flsDOs7msfKRX1X6OpRUxZcE+fnusN1H+zhiMJlLyy0jOK6dHmFvTFQuQJFBnCPm/nDOQdxZy4yAv/tqMoEIlPDl792oPz9b1gvfnILw/K3vh6SlthJcot7rgOV7wHiXThZtRVE8atGIMmkFzwRstEf1nWrU4AZcXCK+1LB9Ks8Govfo6HXzAsyV4tgKvVuDVBryjLMYTkUb4flcSX/wTj9Zgws5awcu3teLuHsHXX9hTkATL7oS8OPF/n7JE5C+bEXsT87hn4QFMEnwwqT1TutVDZerer+DvV0XtxaxD4Oh94/usIxYjaWau6QBnnYSV9wgPRGEtxll1faDRwww1sSchjweWHGLdrD608hHvZ8OJDL7flczgll48NTQSo0m6ZKr5y7+doLhCz7u3t8PFToiPv7fpDEfPFbLg3q642FqZp8VDksQxNBkh8V8xZd4tHDpMvbbCJ0kSJ7GMaHHLPC6MY0Vh7a9x9BOemGuI8M6c/IWn5uQnjKONc+P+XyUJNEVQkg3qC15uUZqQUitMFlfxFQW1vFgm8kY+7cG/M/h3FZ6PVTPx9uuZlLwyXvz1BAeTxfHqGebGvEntCXa/TqlETTGsvBeSd4gLoTGfipmvzYhKMXSVUs7ax/vQxu8GjYnRAAuHQOYx4TDc8WN9LLNOWIykmbnqAT6xGtY/IUILzkEw9acmF169mJ/3n2PloTS+vrtzVYhJrdHzxdZ4tp/NZeOT/bBWyjEYTSjkMmQyGeui0/luZxIqKzl3dQ/inzPZxJwv5skhkdzZ3cz9YtmnYcPToM4E3/bQYqQova9pPI9GDemHRU447SCkHxEG5b/IFODRArxaC0/LswV4tAS30JvDYFQUCmOZGytuObGQfQpKMi7fVq4E77YQ2FMIegf3Bkefhl9zI2EySSzdf473N8VSoTdiZ63g9TFtmNot8PpylQadGFBQKWfX/0UY9EqTvFCuCZNJYuaSQ2yPyyXUw54/nuhb997SSjKPw3eDRMRk2ipoMaJ+FnudWIykman1ABsNsOU12P+1uB8+BCYtbJLahRdz4nwRE7/ey+pHe9EpyLXq8S2ns/locxyPDwpnfEdhgAxGE0qFHK3ByN6EfH6LTiezqIJIbwdmDYogwLWe9B8BSnPFsZMrqj1IjVoUQDl4C+GFmojbBCm7Rdl5VowIY16MwloMqfbrLC5efKKEYVSq6m/tzYXSXMg6Lk5e6UdFT1tp9uXbuYZC2AAhdBHSv1lpCdeV1PxyXlhznAMXvMphbbx5f2K7Kv3ha0KSYNs7sPNDcb/LDDHJpwmPkbqYwjIdo7/YRUaxhomd/Plkascb3+nmV0WdhkswzDrQKBehFiNpZmo8wBWFsPp+SNom7vd7Xlw1NpMvQ/8PtjGirTevjm5T9VjlSaJHqBvPDm/Jrvhcfj1ynudHtKwyhjqDCaVcVn+h1exTsP19UQDhGgKB3cXsTIcL43wyT8DS2+HpGCjNgoR/xHORw6u/bPN7CG+pEpdgsZ+A7hDQVeThlJb5lDUiSSJce/6gkEtM3StSB/znFODbUXgBkSPEhUYTq9KuL0wmiYW7k/hwcxx6o4SHg4qPp3RgQAvP69vR4UWw4VlAEnqmty9oNp/Bg8kF3PndPkwSfDq1A7d3usEZlNpS+KqbiGIMeAkGvVw/C70OLEbSzFx2gHPjYPmdItdlZQe3f9vshI8X7kriq20JrHm0NxFe1YUcgz7aztRugTw6IJxVh9P44p94Xr6tNaPbm6G0XVcGvz4Edq5CgUgmF2FrnygY9bHwXvZ/C2f/goBucGY92HtCWa7IEQ7+P3HC3vEBqNOFykdwb5E7tFB3NMViZFTyDkjaDjmnL33e3lOEvFuPE97mTeiRn8oo5pmVx6rmnj42MJxnh7W4pE3q6jtZKz7fJj1EDIMpP4F1PUZezMjnW+P5dOtZHFRKNj7ZjyD3G1z3qbWweoYoepu1X+T8G5BbVnHnvffeo1u3bjg6OuLl5cWECROIi4u7ZBtJknjzzTfx8/PD1taWgQMHcurUqbr/0YStsHCoMJDOQfDA383OQAI82C8MG6WC73cmkZpfDkDChZJ4HyfRfze6nS+rH+1VdwNp1F9ZjST+b5Ez7DwdQvpAcC8Y+7nwaE79dmEjSXibZ9YLozhjA9w2T7TX/Ps/sUm/58Xr2k22GMj6wMYZWo4UxWeP74Pn4mD8fPE5VzmJi5TopbDsDvggTERUzvzRbIW/a6KtnzPrZ/fl3p7BAHyzPZFp3++/PsH0trfDXSuEAk3CFvhlsqhabgbMHhxBtxBXSrUGnll1rGqgQZ1pM0GIqRi1sKnpDme+VpqNkdyxYwezZs1i//79bNmyBYPBwPDhwykrK6va5oMPPuCTTz7hq6++4tChQ/j4+DBs2DBKSurwYT26FH6ZIsryg3rBQ/+KXFczQpIkVh1KQ63R88bYNsRll3DX9/t5b9MZZv54iABXW4a0FqFOe5USX+frzB/oymDPF/BlVxFi+Wdu9azMSkwXcoYFSaJgpjK0CqKIpCQTzm4W9wN7iJOynXu1UlHYQOh4jwjRwk0b+msyOPoIhZkpP8ELiXDf79DtIXD0Fe0qp34Tld0fRsBvjwiNU6OhsVd9w9hYKXh7QhTzp3XGUaXkUEoho77YxZ6E65BZjBwK960TFxfn9sDPzcNQKuQyPp3aEUeVkiPnCvluZ9KN7VAmg1Efiu93/GaI31o/C20kmm24NTc3Fy8vL3bs2EH//v2RJAk/Pz+efvpp5syZA4BWq8Xb25t58+bxyCOPXNN+q1z1lxxxUsnEYOSxnze7MFNhmY4X1hxn65kcJnT047M7O3Euv4wNJzI5lVFMrzB37u0VcmN/5OhSOLBAlL/buooiBtcQGPWRaD2oNJByOaTsgT+fFUbvtnnixLrrI4jdAPlJMCdZfKm+HyT6z+77vTqvk7wLfn0QZvwJHhE3tuYmjCRJSJLIEFb2rCqayjQVkwkyjsLpdXByrWhHqcTRF9pPhY7TRK9mMyclr4xZy45yKkONXAYv39aaB/uFXnv1a/pRWDpBhLIDe8Dda5pc/3RNrD6cxgtrTmCtkLP+ieqWsTpTWcTj0QIe2wuKhumltuQkL5CQkEBkZCQxMTFERUWRlJREeHg4R48epVOn6paM8ePH4+LiwpIlS65pv5cYyZH/JwpLmklZdyWHUwp4Ynk0mcUarBVyXrqtFTN6ByOvTy+soghW3C2kuSZdmJWZcwbWPipyhSPfEyfWyr9pNIgCh/1fg75cyLx5t4VeT8Dvsy546lFiBM/Rn8SFSeSFiSK/z4KCZLhjCThcZ1FFAyNJEsUVejKLNWSpNeSqteSX6Sgo05JfqqOoQk+JRk+JxkCJxoBGb0RnMKE1mNDVMO9PLgMrhRwrhRwbKzn2KiX21kocVEqc7axws7PGxV789HJS4e1og5eTDb7ONtjfaEl/bZhMolL25BqIWXNpn2ZgD+g6U4Rrm3F7jUZv5P/WnWTNEXExMLaDH/MmtcPO+hqPaUY0/DReGMqA7nDPr03eUEqSxEM/HWbrmRza+DqxblYfrJU3cM7QFMMXnaE8D0bOg56P1t9ir4DFSCL+mePHj6ewsJBdu3YBsHfvXvr06UN6ejp+ftW5qocffphz586xefPmGvel1WrRaqsVTdRqNYGBgRTvWYxT7xlmfR/1jckksWBnEh/9HYfRJBHmYc+X0zrR1s8ME0iKUoVm49C5EDVRPGY0wM4P4PR6eGRHzd53+lHRy1jZwJ92CNY+LLzPiCFCbeavl0U+uP1UYUxzz8CAOdBqdP2/jzogSRI5JVoSckpJyCklJb+MtIJyUgvKSSuooEJvbOwlAuBqZ0Wgmx2BrnaEeNgR7ulAuKcDYZ72ONaXQpJBJ0Jqx5aJsLl04b3bOIsoTPeHRVShGSJJEj/vP8fcP05jMEm08XVi4fSu+F2r9GJGNPw0QXzeA3vCvb+B9XUKFzQwOSUaRny6k8JyPc8MbcFTQyNvbIeHF8GGZ4Ss4lPHRMTJzNS3kTTTpaZ5mT17NidOnGD37t2XPfffkEhN2qQX89577zF37tzLn6g88TcTiiv0PLfqOFvPiD64CR39+N/t7W68Qbg2XIJEH57ponyUQinytsdXXJgz11cU9FwcZvHvfOl+Tv0mih1CBwgPxc4NRn0gFHeOLRc5spHzRKFPI6AzmIjLKuF0ZjGnM9SczlQTm1VCiebKeThXOyu8nWzwcbbB3V6Fu4M1bvbWuNpZ4WhjhaONssortFbKUSnlWCvlyGUyKj+tEqJ3VW+S0BlMaPRGyrQGSrUGyrRGiip0FJbpKCjTU1CmJadES7ZaQ45aS4nWQGG5nsLyYk6cv1x+z9/FljZ+TrT2daKtnxMdA13wdqqDiLrSWuSPW48VAhDRP8PRJUIH98C34hY5QngRYYOaVVRGJpNxb68QWvo48fgvRzidqWbC/D38ML0b7QKu4cLTr5NIG/w0DtL2i1zuXSuadOrGy9GGueOjeHJ5NF9ti2dUOx8ivR3rvsPO0+HAd+JCd/enMOyt+ltsA9HsPMknnniCdevWsXPnTkJDQ6ser2u4tVZPsp6uQhqC2Cw1jy49Qkp+OdZKOXPHteXO61UQqQsL+ouiptvmVT+WES0q2lqPhd6zL39NRSGU5Qnjd/p3OPgddH8EOt1t3rVeIzklGg4mF3D0XBHH0go5maFGZ6g5DBrsbl/lmQW52V3w2mzxc7G98ekKN4hao+d8QQVpheWkFZSTnFdGYm4pibll5JbUrAXr62xDx0AXugS70jPMnda+TnXLiVbKCh78XniZlXi2hr5PQ9SkBstP1RfnC8t54MfDxGWLkXCf3dmREW2vUako7aDwKPVl0GqMSBsomq5/cnHYtVOQC2se7X1jufGzm2HZFNES8sQRIf9oRm7ZcKskSTzxxBOsXbuW7du3ExkZednzfn5+PPPMM7z44osA6HQ6vLy86la400yM5PrjGcxZc4IKvRF/F1u+vafLtV3l1gdb50LcRrh/U7XyUGkOLJsqclJ9nxYSabmx0HaCeD77NPz1EmQcE1fU3R+Gfs82mjBDTomGvQn57EvM51BKAUl5ZZdt42xrRTt/Z9r4OdHG14lWvo6EetijUjYPMYn/UlSu40xmCWcyhWd8Mr2Ys9kl/Lfy39FGSbcQN3qHu9M30oOW3o7Xf+GVnyiKu479IqpjQUwy6TUbOt/b5MOPF1Oi0TN7WTQ7zuYik8Gro1rzYL9r7AFM3CYMhVEn+oTHz2/SldqZxRUM+2QnpVoDr49pw8y+oVd/UW1IEiwZK1SyOkwTQ+jNyC1rJB9//HGWLVvG77//TsuW1RV0zs7O2NqKHMG8efN47733WLx4MZGRkbz77rts376duLg4HB2vLWTQXIykySTx4d9xfLM9EYB+kR58cWcnXO3NrPRhNIgQqZWtqFpbMADGfyX6FkEounzWHqb/IfohN70kmotn/iW0UnXlIvTkHNQolapag5GDyQVsi81lT0IecdmXlujLZNDax4muIa50CnKhY6ArIe525vfKG5lSrYGY88VEpxVyKLmAwymFlGgvDSl7OKjoF+nBkNZe9G/heX2TXzTFIj+172soyxGP2XlAn6eg2wPNxlgajCbm/nGapfvFgOGH+4fx0shW16ZKFfunEEaXjND7SRj+tplXe2P8cuAcr649ib21gn+eG4iP8w3MNE0/At8PBmSiH9erdb2t87/cskaytpPU4sWLmTFjBiC8yblz57JgwQIKCwvp0aMH8+fPJyoq6pr/TnMwkqVaA0+vOFaVf3x0QDgvjGhp3nYBXZnIN+39CopThYF8/IAQeU7cBgNfElWtuz8RhnLCt6LyNeEf0QvZelyjVfcVlunYciabf85kszs+jzJddWGNTAZRfs70DnenR5gbXYLdcLZtXqFAc2A0SZzOUHMgOZ9d8XkcTC64pCBJKZfRI8yN4W18uC3KB69rzWfqK4Qo+O7PoOjCJPsqY/lgs1CpkSRRIPf+JiGPOLGzP/Mmtb82hZ5jy2DdY+L32z6EHg+bcaU3hskkMfnbvRxNLWJUOx++vrvLje1w5T1CiKL1OJi6tH4WWQO3rJFsKJq6kUwrKOfBJSI3Yq2U88Gk9kzoVMOEjPpCWyJyS/u+EpWmIKTKejwqroZ1pbDrYyE6nhsrjOfI94UX2Yjkl2rZfCqbTScz2ZuYf4mKiJejikEtvRjQ0pNeYe7m975vArQGI0fPFbH9bA5bT2eTmFsdlpbJoEeoG6Pb+zG6nS9u13I8jXo4sVKIg1cKUDj6ioutjvc06ZxdJasPp/HSbzEYTRKDWnoy/+7O19YisvMj+PdtQCaMRaVwRhPkTKaaMV/uxmiSWDKz+/Xr2l5Mzhn4uhcgwcM7zDaw2mIkzUxTNpLRqYU8uOQw+WU6PB1VfHdvl0sme9QrGjUcXAD75lfPY3QNgd5PQMe7L++BK0wBe69G9QRKtQb+PpXF78cy2J2Qd4lhbO3rxIi23gxp5U1bPyfzzMO8hUjOK2Pr6Ww2nswkOrWo6nGlXMbAll5M7OzP4FZeVy9gqjSW2+eJCAWAeyQMeV0YjyYe5v7nTDazlh1FozfRPcSNRfd3u3pFuSSJtogji8Wg7hl/CnH+Jspbf5xm0Z5kQtzt2PxM/xvLxf/6EMSsEkML7l5df4u8CIuRNDNN1Uj+fSqLJ1dEo9GbaOsn+rWuW0buWtCVw6HvRbl2pXF0jxCiClGTm9wVvskksT8pn9VHzrPpZCYafXUlapS/E6Pb+XFblA8hHs0j59UcOV9YzsaYTNYfz+BkurrqcUcbJRM7+XNXj6Crq7cYtCJnueODanGC4L5ClMK3vRlXf+McTing/h8PUaIx0DnIhR9ndr96vtZogBXTRPWvvacQ03Ax86zWOlKi0TP44x3klmh5ZVQrHu5/A32v+YnwVVcx4u6hbZe3hNUDFiNpZpqikfxxTzJzN5xGkmBQS0++mta5/tVUDDrR37bzIzGmCsQV/YA5ome0iY0Fy1FrWHEojVWH0zhfWFH1eJiHPeM6+jGugx9hng5X2IMFcxCfXcLa6HTWRaeTcZFAeOcgF+7uEcyYDr5X9kQ0atj7Bez9EgwaQAad74PBrzVptaUT54u494eDFFfo6RDgzE8ze+BsdxVDqS2BRbdBdgx4txPFbaqm+ZlddTiNF9ecwFGlZNsLA/G4nrmb/+W3R+DECmg5Cu5aXn+LvIDFSJqZpmQkTSaJeX/FsuCC4PC0HkG8Na4tyusZ4XM1JEn0K/4zV4iQg6g8HfQytJvSpDxHSZI4kFzA0n3n2HwqC8OFcKqjSsnYjn7c0SWAjoEuN30lanPAZJLYk5jHsgOpbDmdXfW/8nBQcW/PYKb1CMLT8Qon2qI02PqmkL4DoeAz5HXocn+Tu2Cr5FRGMfcsPEBhuZ62fk788mAPXOyukp8tShN6xWW5oodyytIm2RpiMkmMn7+HmPRi7uoeyHsTb8C7zz0L87sDEjy6u94HR1iMpJlpKkbSYDQx59cYfj0qtCNfHNmSxwaE168BSDsoRIjPHxT37b1gwIviyr0JqYJo9EZ+P5bOot0pl7RsdAtxZVqPIEa29cXWummeOC2IXtTVh8+zdN85stTCu7RWyJnQyY9HBoQTfiWPP/UAbHoBMo+L+/5dYPQnZiv6uFHiskq4e+F+8kp1dAhw5ucHe1xdAjD1ACwZI3ooB70qvoNNkMMpBUz+dh8yGWx8sh+tfW/g/LhmJpz8VYwYu+PHelsjWIyk2WkKRlKjN/LE8mi2nM5GIZcxb1J7Jne5wYnhF1OcDlter75Kt7ITzd19ngTVDUhQ1TP5pVp+2neOn/efI79MB4CdtYLxHf25t2cwbfyaRjjcwrWhN5rYdDKLRbuTOZZWBIi6nJFtfXh0QDgdAl1qfqHJCIcWwj9vg65EDOzu+biYOdoERdTPZpcwdcE+Csv1dA9xY8nM7le/iDu6FNbPBmQwbRW0GN4ga71eZv1ylD9jMhnQwpMlM7vXfUfZp+Cb3uJ/Oftwver7WoykmWlsI1mqNfDgkkPsTyrAWiln/rTODGvjXT8712tg35ew6xMxiQOZkIMb9H+ip7GJkFWs4budSSw/mFrVm+fnbMOMPiFM7RZk6WO8CThyrpBvtidW9fqCyLc/O6xl7YpRJVmw+RXhgQC4hQvlmkbS9b0SJ9OLueu7/ZRoDfSL9GDh9K5Xrwrd8IwoXrJxFi0SbjegcmMmzuWXMeTjHRhMEsse6kHvcI+67+yXO8Qw9i73w9jP6m2NFiNpZhrTSBaX65m++CDH0opwVCn5fnpXeoa518/O47fCxuehMFncD+whNFf9Ol35dQ3I+cJy5m9L5Ncj56vGRrXzd+bh/mHcFuVTv7lYC02Cs9klfLs9kd+PZ1S17Axr482zw1rUHs47uxn+eEqIVCCDHo/AkDeanBDBkXMF3LPwIBV6IyPaevP13V2uLPhh0MGPo8RwAJ/28MAWsLoBlRsz8cbvJ1my7xztA5z5fVafuqeAUvaI96tQwdMx4Fg/zoDFSJqZxjKShWU67l10gJPpalzsrFg6s0f9aLCqM4RW6unfxX1HXxj2tpCRayIFLpnFFczflsDKQ2nojeLj2D3EjVmDI+gf6WEpxLkFSMkr4/N/4ll3LB1JEh/N2zv589zwlvjXNJqqogj+flWoQIGoxJ70fZO66APYk5DH/T8eQmcwcU/PIN4eH3Xlz3NxOizoJ4Q7uj8Moz5suMVeI3mlWgZ8sI0ynZEF93a5dqH3/yJJ8MMwcVEwYA4MeqVe1mcxkmamMYxkfqmWe344yJlMNe721vzyUI8bnwpelcd5S6jiyBRCJWfQy00m75hfquWrbQn8sj+1ynPsE+HOU0Na0D3UrZFXZ6ExSMgp4dOt8fx5IhMAa6Wc+/uE8PjAiJrD7AlbYd0s0bYkV4oTbZ+nm1QF7KaYTB5fdhRJEgV4jw+8imZx/Bb45YIW8p3Lmswc1Yv5aHMcX21LoJWPIxuf7Fd3cY5Ta2H1DCFN+MypevGcLUbSzDS0kcwv1XL3wgPEZpXg4aBi+UM9bmx+G4jJG+ufqK5aDegOYz6p91LrulKhM7JoTzLfbk+sEtHuHurGs8Na1F942UKz5nhaEe9uPMOBZCEs4GZvzYsjWjKla+DlJ+TyAqEhfOYPcT+4D0xaCE5+NBUW7U7mrQ2nAfhkSgcmdr5KId7f/yd6RW1c4LE94FyPhXv1QFG5jn7ztlGiNfD13Z0Z1a6ONQ1GA3zeAdTnYdxXYjLMDWIxkmamIY1kUbmOO7/bT2xWCV6OKpY91JMIrxtoJjbqYc9nQrXEqANrRxj2JnSZ2SR6r0wmiXXH0vngr7iqVoC2fk68dFsr+kZYwqoWLkWSJLbF5fDuxlgScsSYrQ4BzswdH0XH/1bCSpIQD9/0ooic2HnAxO8gYkjDL7wW3vnzNN/vSkYpl/HTzO70jrhC0YtBB4tGQMZRCOoNMzY0Ke8Y4NMtZ/n8n3givRzY/HT/unuTez4X1fZebcUFwQ2eByxG0sw0lJFUa/Tcs/AAJ84X4+moYsXDPa/cL3Y1cmJh3aNi6DGIafBjPmkyV6DH0op4c/2pqtJ/fxdbXhjRknEd/Jq3jqokiTFQFQVQXih+aorFiVpbKqqIDVpx0WLUg0l/6etlClBag8JaFDBY24G1gwiJq5zEnE47N7B1E1WPt+CFhN5oYsneFD7fGl8VeZjWI4iXbmt1ufxbfiKsng5ZMYBMyCkOfKlJGBiTSeLJFdFsOJGJs60V62f3Idj9CnKJBUnwbT/xWRr2tmjRakIUV+jpO+9fSjQGvr2nMyOj6uhNVhTCx63BUAH3/3XD1coWI2lmGsJIlmkN3LfoIEfOFeJmb83Kh3vWPcRqMsH+r0Xu0agVJ9LbPoT2U5rECTW3RMv7m2KrRBHsrRXMHhzJ/X1Cri5+3RTQlYmTVVHqpbfSbNGSUJotDGBDoLAGRx9RfOXoKya8uwQL4fnKm+LmbY/JKdEwb1Nc1WfJ20nF3HFRjIz6T+GIXiOK1Y4sFvfDBsHkRdWDwRsRjd7I1O/2czytiEgvB357vPeVxQaO/iRSJwpr0Rbi3abhFnsNfPx3HF/+m0A7f2fWz76BStffZ0P0UqEPPfmHG1qTxUiaGXMbSY3eyANLDrEnIR8nGyXLH+5JW786VrEWpcHaR+HcbnE/YqiI6zeBnkeTSWL5oVTmbYpFrRFX/5O7BPDiiJbXPnuwIakoEqO+ck5D9mnIixNeiTr92l5vZX/B43MVFyrWDkKH09peeIiV3qJMcenFi8lQ7WUaNEJgXlcqdD21auGdlueDvqz2v12J3ArcwsCzBXi2FjlonyhwCWkS4fb6Yn9SPi//FkNynjgmI9v68NaEtng5/udzdWK1yFXqy8UFxJ3Lm4SRyVFrGPvVbrLVWoa08uK7+7rW3hoiSbD8Tjj7l/h/Pviv+Cw1EQrKdPR5/18q9EZ+mtmd/nUdpZVxDL4bID7Dz565IZ1ei5E0M+Y0kkaTxKxfjvLXqSzsrRX8/GCPuo+6OrVOnAA0xeIEPeId6DKjSXiPsVlqXvkthqMXRihF+Tvx9vgo8431ul7KC8Sk9MxjQu4s87jwDmvD1hVcQ8WUBpcgcA4UFyIOPsKzs/c0fz+bXgNlOaDOFP2B6owLXu05KDwn+l/15TW/1tpB9N35dxaybgFdxXtoAp+VuqLRG/ny33gW7EjCYJJwtbPindvbXV5AknVSTNsoOie+JxMXNIn5jcfTipiyYB9ag4nZgyJ4fkTL2jcuyYave4pQfj22StQXlaO0eoa5seLhGwiVfj9YfC+HvAH9nq3zbixG0syYy0hKksSr606y7EAq1go5P97f7cqJ+9rQlcGmOSI0AeKkN/H7epV1qis6g4mvtyfw1b8JGEwSDiolzw1vwX29Qq7cRG1OJEl4hCm7hFbt+YOQn1Dztk7+4NUavNqAZyvwiBRjwppAmO6qmEyiQjDvrBCQzjkl8nI5sSIM/1+c/EUVaHBvCOkr3mczNJpnMtU8u+o4ZzLFiK7xHf2YO67tpcLi5QUiT5m8U9wf+qZoE2nk97suOp2nVx4DYOF9XRl6JWWtk7/BmvtFm8sjO8G7bcMs8hrILK6g37xtGEwSG57oS5R/HSNj0T/D77NENOSJo3X+/1iMpJkxl5GsrASTyWD+tDqWTOecgVXTRSgQmbjaGvhyk8hDnUwv5vnVx4nNEgLkw9t4M3d8W/PMvLwaxech4R9I3iFUPSpHf12MewT4dQbfDuLm0w5sXRp8qWbHaBCGMyNaXKWnH4HskyLMezHOQRAxGMKHQNhAsGk+urg6g4kv/43n6+2JGE0SPk42fHZnx0vbiYwG2PwyHPxO3O86U+TuG3nKzZvrT/Hj3hScbJT8+WQ/At1qUQ2SJFh5D8RuEBfGD2xpEsVIlTy1Iprfj2Vweyd/Pp3asW470ZbCxy1FumHGn+LirQ5YjKSZMYeRXHYglVfWxgDwvwlR3NMz+Pp3cmw5/PmsCKk5+ory9tD+9bK+G0FvNPHlvwnM35aA0SThZm/NW+PbMrqdb8O1dBi0kLJbNGEn/iOMwsUoVBDQTVTNBXQX4cYG9g6NJomcEg0ZRRrySrXklmjJK9VSVK5HXaGnuEJPicaAxmBEqzehNRir1Ieq3oZchkopR2Ulx0apwMFGibOtFU42VjjbWuHpqKq6+TjZ4OtsU7OUn65ceNTn9oqLiPMHLy0+kltBaD8x76/lbU2mQvpqHEsr4tmVx0jKK0MugycGR/LkkMhLoxj7v4G/XgYkiBgmJlA04gxHncHElAX7OJZWRPsAZ1Y/2qt2jVd1phgxpVXDyHnQ89GGXewViDlfzNivdqOUy9g9ZzA+znVMP6x/Usy1bT9VnOPqgMVImpn6PsA7zuYy88dDGE0STw6J5NlhLa5vB3qN6P06ukTcDx8Mt3/XJAbQJuWW8szKYxw/XwzA6Pa+vDWuLe43MpD1WikvgLiNELcJErddWtgik4N/V3GsQvuJ3xtAA1OSJLLUGuKzS0nMFbfkvDLOF1aQUVRxmdEzNwq5DB8nGwLdbAn1cCDCy4FILwcivR3wcbKpvojRlYmLjMR/xYVGQeKlO/LvIkYatZkgKmqbMGVaA2+sP8WaI6ICtkeoG1/c1Qnvi4vFYv+ENQ+IlgPfjnDPb2DfeCIW6UUVjP5iF0Xleh7qF8qro69QXHToB3GxbO0ITxwWOfEmwpQF+ziYXMATgyN4bvgVcqxX4vxhWDgElDbwfHydIhoWI2lm6vMAx2apmfzNPkq1BiZ1DuCjO9pfn3dVfF6EWDKiAZkIrfZ/vtHDLJIksfxgGm9vOE2F3oiTjZJ3bm/H2A5mVjgpzYUz68UteRdIxurnHHzEeKGIoRA6wOyhU0mSSC+q4GhqESfTizmVUczpDDWF5fpaX6OUy/B2ssHLSYWngwoPRxVudtY4XvAIHW2ssLNWVHmLSrn8krSMwSSh0RvRGkxodEZKtAbUFcITLSzXV3moOSVastQadAZTrWtxs7cmyt+ZKD8n2ge40DXEtXrafO5ZiPsT4v6CtAPARaeIwB7Q4U6ImiSqeJsoa6PP8+rak5TrjHg6qvj67s50C7koenD+CCy7Q1QOe7SE+9Y1qkLP1tPZPPjTYQB+vL8bA1t61byhyQQ/DBVh8xvwtszBxphMHv/lKB4OKva+NBhrZR0qqiUJvuoG+fEw/msxpeg6sRhJM1NfBzhHrWHC/D1kFGvoGebGTzN7XN+HJmWPKDYoyxWN5JN/EJ5RI1NcoWfOmhP8dUrk+XqHu/PxlA7myz1qS8WVf8wq4TFebBi920HrMdBipKjeNGObgyRJnM0uZW9iHgeSCjiaWkhOyeUFMUq5jBAPe8I97Qn3dCDM04EgNzsCXG3xdrJpsAImk0kit1RLWkE5qQXlJOWWkZBTSnxOCSn55VUTNy4mzMOeriGu9Axzp2+kh2ipKMkWFyWn1sG5PVQZTKUNtBojZMRCBzR6EUxNJOWW8vgvR4nNKkEpl/HamDbc1yu4+kI19ywsnSDafFyC4N51jVoA9/rvJ/lp3zk8HFRsfrpf7RGZ9KOiEhQJ7t8kiq+aAHqjib7z/iVbreXzOzsyvqN/3Xa040PY9j/xuZq+/rpfbjGSZqY+DrBGb2TKgn2cOF9MmKc9ax/rg7PddRTXHPxeNEObDMIQ3PkLuNYhj1nPHEsrYvayo5wvrMBKIWPOyFbM7BNa/4o5JpPo/Yz+RZygL25t8Oskwn6tx5r9hJZVrGHn2Vx2xOeyPzG/avBzJUq5jDZ+TnQMdKGtnxNt/ZyJ8HJo8iIJGr2RuKwSYtKLOZleTHRqEXHZJZdt18rHkb4RHgxq5UX3UDesyrLFoO7oXyD3TPWG7hGiEKbDXU2uErhcZ+DFNSfYcEEwfVLnAN65Par6f1SUCj+NF4IRDt7CUDZSL6VGb2T8V3uIyy5heBtvFtzbpfbI0x9PC7EEr7ai2rWRC5Aq+WzrWT7bGk+3EFdWP1pH412YIvRckQnRc+frM7YWI2lmbvQAS5LE0yuP8fuxDFztrFg36yrSUxdjNAjjeOh7cT9qkhAHaOQ5eZIksXhPCu9tOoPeKBHkZsdX0zrRPsClfv9QcbpobTn2y6V9i25h0G6KUBEyo2GUJImY9GL+OpnFv7E5VZW6ldhYyekW4kavcHe6BrvRzt/56hPnmwlF5TqOphZyILmAPQl5nExXX/K8o42SAS08GdbGm6GtvLDPjxEl+ydWimpEEN5luzug12zwatUI76JmJEli4a5k3tt0BpMEXYNdWXBvl2pPrTQHlt4uqn7tPERlZSOt/3SGmvHzd6M3Slf2xsoL4MvOQtJtzGfQ9f4GXWdtZKs19H7/X4wmia3P9ifCq45KYj+MgLT9MOJd6DXrul5qMZJm5kYP8IIdiby3KRaFXMbPD/SgV/g1FgRoimH1/aI6ExkMfaNJ9HKV6wzM+TWGP45nADCqnQ/vT2p/uWZmXTGZIGmbmMget6k6nKpyEhcJHe8W1ahmOg6SJHE0tZANJzLZfDKLjGJN1XMyGbQPcGFAC0/6RXrQPsD56tPlbxLyS7XsTcxnV3wu/8bmkFda7UXbWMkZ0sqbsR18GRhii03sb3BoEWTHVO8gYhj0fkJUYDeRUOzu+Dwe++UIJRoDQW52LJrRrXqgQHmB8CizToC9lzCUntdZZFdPfPlPPB9vOYuLnRV/P9P/ciWhSvZ/Iy6q7T3hyegmMwLvwSWH2Homh4f7h/HKqNZ128nB78WQeP+u8NA/1/VSi5E0MzdygLfH5XD/j4eQJHhrfFvu6xVybS8sPAfLpghZNCs7IQ7Qesz1L76eOZdfxiNLj1TldF4Z1Zr7+4TUT2uHthSOLxdf9IurKYP7CuWg1mPAynw9lgk5pfx+LJ11x9JJK6ioetzOWsGgll4Ma+NN/xaeuNk3HQmwxsJkkjh2voitp7PZdDKrSg4OwMlGyYRO/kzpEkCUKVaMd4r9k6rcZUA3oRITMbRJGMuEnBLu//EQaQUVONko+faeLtWiHuUFsGScMPYOPsJQelxl9qMZ0BtNTJi/h1MZ6iuHXQ06+LqHCBX3ex6GvNbga62Jv09l8fDSI3g4WLPv5SFY1dSGdDVKc0TPpGSCp44LWcFrxGIkzUxdD/C5/DLGfLmbEo2BO7sF8t7EdtdmTDKi4Zc7RIGOoy/ctQL8Otb9DdQTu+Jzmb0smuIKPR4OojqwXgYhF5+HA9/CkZ9AK1pHUDmJfFbXmWYNc5VqDfxxPINVh9OIviCZB0J0fXhbH0a186VfpEeTzyk2JpIkcSpDzfrjGfxxPIPMizzvNr5OTOsRxMRgLXZHvxOhc8OF5307CmPZ8rZGN5b5pVoeXnqEI+cKsVLI+GRKx+rK7LJ8WDJWKBY5+sHMvxqlHuBMppqxX+7GYJL4alonxrSvpfL2zB+iAl5pA08eaxK6zXqjiV7v/UteqZbv7u3C8LZ1bFNZMlaoJA19E/o+c80vsxhJM1OXA6zRG7n9672cyVTTOciF5Q/3vLawXMJWWHmf6PHzbgd3r2oSg2KX7j/Hm+tPYTRJdAx04dt7utS9ObiS3DgxN+7Eymq1F7dw6PmYMJBmbOg+mV7MT/tS+ON4JhV6Ec5VyGUMaOHJhE7+DGvtfdPkFhsSo0liT0IeKw+nseVUNjqjaDlxVCmZ3DWA+9vbERS7UITSK4uvArqJk14d1VTqC43eyHOrj/PniUxkMnhrfBT3Vop8lObCkjEisuMWDg/8DfZ1kJC8QSpVurwcVfzz3ICap4VIEiwaKfJ33R6C0R81+DpronJ25qh2Pnx9d5e67aSyJ/Q6Q64WI2lm6nKAX1xznFWHz+Nub82fT/a7NoNyfIXQKTQZRKnz1J8bXQrMaJL435+nWbwnBYCJnf15b2K7G8vDZRyDnR8KOa1KQvqJfFXEMLO1beiNJv46mcWSvSkcPldY9XiYpz1TuwYysXMAno4NIHpwi1BYpuO36HR+3n+uKhwrkwl5wid6uBKVuhT2fysa+EGEX4fOFVNKGgmjSeKN9Sf5eb8oEnt2WAueGBwhIkDqDFE8UpwqKqqn/9HgOT+twcjIz3aRnFfGjN4hvDmuFr3W5F3CqMut4IkjTaIS/mR6MWO+3I21Us6R/xt65XFgtaHOhE8uRJaejb1mL9liJM3M9R7gVYfSePHXE8hlsPSBHvS5FtHyPV/Algv5g3Z3iKbZRh5/U6Y18MTyaP6NzQHghREteXxgeN3zjxnHYMc8oYpTSasxImwS0PXGF1wLZVoDKw6l8cOupKoiHKVcxqh2vtzbK5iuwa4NJ5d3C2IySexKyGPJ3pSqzxJAnwh3nu7uRNfUhciOLhEXhzK5yD8P+r9GU7yRJIlPt8bzxT/xAMzsE8prY1qLz0hePCwaIQQHwgbCtNUN/j3dHZ/HPT8cQC6D9bOvIB6+ZJzQKu50D4yf36BrrAlJkhj6yQ4Sc8v4cHJ77uhaR6WmhUPh/CEY/TF0e/CaXmIxkmbmeg5wXFYJ477ajdZg4vnhLZg9OPLKO5ck2PaO8KxAlMoPe7vRZ/3llWq5f/EhYtKLUSnlfDKlI6Pb1zG3kX0a/v2fUGwBcSKMmiyUgjzrKFV1DeSXalm8J4Wl+89RXCFUbzwcrJnWI5i7ewRdKktmoUGIzy7hmx2JrD+WgeGCeEH3UDde7mFNp7NfwOl1YkMbZ6Em1e2hRuv3+3FPMm/+cRqAGb1DeGNsG2Eo04/Aj2NFSqTDXTDhmwbPqT65PJr1xzPoEuzKmkd71XyRl3ZIKPHIFPDk0esqdDEXlVW6/SI9WPpAj7rtZPensPVNIbx/72/X9BKLkTQz13qAK3RGxn21m/icUvq38OTHGd2u3FRvMokpBAe+FfdvcGZafZGaX859iw6Qkl+Om701P0zvWre5j0WpsO09UbGKdJFxfMGspfQFZTq+25nET/tSKNeJfGOohz0P9QtjYmd/SxFOE+B8YTnf70xi+aG0Kqm8PhHuvNmukMjod8RILxCTWMZ+LrRiG4EVB1N56TexlksMZfxWUX0uGWHI69DvuQZdV7Zaw8APt1OhN/LlXZ1ql3/8aYJop+o6E8Z82qBrrImk3FIGf7wDhVzG4VeH4lqXSvGcM2KWpkIFc5LFEPOrUN9G8uYZV97AvLXhNPE5pXg6qvhkSoerGEijGJBcaSBHfdQkDOTJ9GImfrOXlPxyAlxtWfNor+s3kBVFsPlV+LILHF8GSNB6HDy+HyZ9bzYDWVyu54O/Yuk771++3ZFIuc5IlL8T397Tma3PDmBajyCLgWwiBLjaMXd8FDteGMi9PYOxUsjYk5DPsLUmnnT6jILBH4rB1lkxIry2aQ5oL1cAMjd3dg/i/YntAPhxbwpz/ziNJEkQObS6IOaft+D09Uul3QjeTjY8NlCIaLy/KRaN3ljzhv2fFz+jfxb5vEYmzNOBVj6OGE0SW85k120nnq3EGDejVuReGwGLkawDf53MZPnBVGQy+HRKx2ph6JowGWHdY6IcXiaHCd9C94cabrG1cCApnzu/209eqZZWPo789lhvwjyvo8LUaBANv190gn1fiVFLof3hwX9h6lKzhVY1eiPf7Uyk/4fb+Hp7tXFceF9X/pjdl5FRvo034NnCFfF1tuXtCVFse34gd3QJQCaD9Sey6fl3IJ+3Xo4+aoroizvwLczvKWaCNjD/NZTvb4oVT3SdCd0fEb+vfQQyTzTouh7qF4afsw3pRRX8sDu55o2C+0BgT/Fd3PdVg66vNirn5m6MqaPRlskgcpj4PX5zPa3q+rAYyeskR63h5QshmUf6h9M38gqFOiYjrHtctD3IlTB5EXS8q4FWWju74/OYvvggpVoDPULdWPVoL7yuJ2eXtAO+7SsUMSoKxBSFu9fAfeshwDyhMpNJ4rej5xn80Xbe3RhLcYWeFt4OfHdvF/6Y3ZehbbwtBTnNhABXOz68owMbnuhL73B3dAYTn+4toO/ZqezvsxDJNQTU5+HnibDhGSE80YDc2T2I9y4YygU7k1iw44LYxYh3xZABfTmsvFuIDzQQttYKXhwpKj2/3ZFIcU3TZmSyam/yyBLQqC/fpoEZ1U70SO5NyKdUa7jK1rUQOVz8TPy3nlZ1fViM5HUgSRJzfj1BYbmeNr5OV54NaTKKFo8TK0QyffIiMZOvkdkWm8PMJYfQ6E0MbOnJkpndr11iTp0Ja2bCT+OEwLWtmwgdP7ZHXO2ZyUidOF/E5G/38uyq42QUa/B1tuHDye3Z9FR/hrf1sRjHZkpbP2d+ebAHC+/rSrC7HdlqLXf+Y8eDtp9T3O6CFunhRfBNbzEgugG5q3sQr4wSRum9TbGsOpwmioomLxJFMUWp4rtgqiX0aQbGdfCjlY8jJRoD3+5MrHmjiKHiolVXIjSQG5lwTweC3e3QGU3sjs+t205C+ggnozAFCmrxos1Isyrc2blzJx9++CFHjhwhMzOTtWvXMmHChKrnZ8yYwZIlSy55TY8ePdi/f/81/40rJX1/OXCOV9eexFopZ8MTfWnhXUvflMkE65+AYz9fMJA/NAkDuflUFrOXHUVvlBjWxpuvpnW6th5IowEOfgfb3hVfPpkcuj4Ag18VuSQzkV+q5cPNcaw8nIYkCcm4WYMieKBvaNPMN+o1YuySOgNKs6EkS/ysKLxwKxIavfoy0FeArlyExiSjONlKRvF5kSvFTWElChWs7YVcoY0T2LmLm62bGLjr5C8EKJz8xQSOZnrBoNEb+XZHIl9vT0RnMGGtkPNhl0LGnXsHWfF58Zkb8FKDz1N9b+MZFuxMQiGX8e09XRjWxhuyT4ncqb5cVOUOfKnB1lM5d9LGSs7OFwfVrOt6eJHwwF1DRd9kI8+ffeuP0yzak8wdXQL48I4OddvJopGQuu+axNzru3CnacxXuUbKysro0KED999/P5MmTapxm5EjR7J48eKq+9bW9dPXlJpfzjt/ivFAL45oWbuBlCTY9EK1gZy0sEkYyL9PZTHrl6MYTBJj2vvy6dSO16apmHlCGPzMY+K+f1fRs2RG6TxJklh9+DzvbjpD0YWw0u2d/HnptlaN38qhK4e8OMhPFH10+QlQmAxFaVCWc/XXXw3JCEajKFTQA5qia3+ttaPwclyDxfgqz1bg1Ro8WjT6JJmrYWOl4OmhLbi9kz+v/36KHWdzeeqgM0t9P2Fhi1W4nF0D29+FlF1C27iB5Ndeuq0VBWU6Vh85z+xlR1nxcE86BbUV1aNrH4Ht70NQLwgb0CDrGdLai05BLkSnFvH1tsSaBQba3wlb54rP5dnN0GpUg6ytNoa29mLRnmS2xeVgMkl1G60XNkgYyaRtDT7xpFl5khcjk8lq9CSLiopYt25dnfdb01WIySRx98ID7EvKp0eoG8sf6ln7P/qft2HXR4BMTA1vP6XOa6kvtsXl8PBPh9EbJSZ09OOjOzqgvJqB1FeIE8DeL8WJ28ZZKKR0nm7Wvs6EnFJeWRvDwWSR72nl48j/JkTR9eKp8g1FaS5kHBXCCNkxoge0IIkq8e6asLIXJ3AHH+HpOXgLD8/WBWxd0SkdyNIoSS+VkVYCGWUmckv1ZJUaySnVUVqhQ6PVoZAZUaHHFi32aLGXVeBIOW6yElxkpbhRgresEB9ZAb6yfNwpQS6reV0SMkxuESgCugj1GP/OQku1kQUsakOSJNYdS+fN9acprtBjpZAxPyqeYckfINOVCk960g8QPqhB1mMwmnhk6RH+ic3Bw0HFulm9CXC1ExePR38SmsuP7mkwQYRKgQGVUs6elwbXXDj492uw9wuhanXPmgZZV23oDCY6vfU3ZTojfz7Zl7Z+tQgiXIlz+2DxSDHK7IWEK0ZMbmlP8lrYvn07Xl5euLi4MGDAAN555x28vLxq3V6r1aLVVk+YV6svT3YvP5TKvqR8bK0UfDC5fe0Gcs8XFwwkMOaTJmEg9ybk8ejSI+iNEqPb+V6bgUw7BOseFV4SQJvxcNsH4qRvJgxGEwt2JvH51nh0RhO2VgqeGRbJ/X1C6zZF4HoxGsQ8wdT94oo1/QgUp9W8rZ2H8M7cw4XH5hYmJtu7BInw84UvcFaxhmNpRZzJVBN7Tk1sVgmpBeVIUk0FDDJAdeEGSKBSysXNSoG1Qo5cLiL5RpOEwSSh0Rsp0xmQJFChI0CWS6Ash2BZDuGyDFrIz9NCloabrBRFQTwUxIscOWCUq9D7dUUV3hdZSD8I7NFkjKZMJuP2TgH0ifDgtXUn2Xwqm4ePRzAu4FM+4jOs806Jop6hc4W8oZlDzEqFnC/u6sTkb/dxJlPNg0sOs+ax3jiMfF98XvLOwvrZcOeyBgl394lwp0OgC8fTili0O7mqoOcSuswQRjJhq5gy1IhSddZKOT3C3Pk3Nofd8Xl1M5L+nYWIe3me0IFuwHmfN5UnuXLlShwcHAgODiY5OZnXXnsNg8HAkSNHUKlqbtN48803mTt37mWPV16FpBdVMOLTnZRqDbw+pg0z+4bWvKCjP4krS2gyQgGHUwq494eDVOiNDG3txTf3dLmywTHoYMf7QuVCMglvaPTHZh/blZBTynOrj3M8rQiAgS09eXt8FIFuZgwRmkzCKCbvENW6qfuqhwdXIQOPSOF9+bQH77bi5nD5RZfRJHEmU83+pHyOphYSnVp0yYSMi3FUKQnxsCfEwx5/F1t8nFR4O9ng5WSDq50VzrZWONpYYa28+sWBJElU6I2oKwzkl2nJK9WRV6IlS60hNb+ctIIySvIz8Cg5Q3tZEu3lSXSUJ+Auu7QPUaewRxfUF/u2tyGLHAbOAdd8KM1JpVf52rpTlGoNuNuYWBv0K0Gpa8UGUZNh3JcNEk7OKKpg/Pw95JZoGdzKi+/v64oiOwYWDhG55euQTrtRKsdROaqU7Hl5cM3Fdz+Nh6TtQvxgyOsNsq7aWLQ7mbc2nL4x9Z0fx4hw+1WOs0Vx5wI1Gcn/kpmZSXBwMCtWrGDixIk1blOTJxkYGEhxcTGOjo7M/PEQ2+Jy6RLsyqpHetXcg3d2Myy/UxiWPk/BsLdu9O3dMLFZaqZ8uw+1xkD/Fp58f1+XKxfpZJ+G3x6uHpzbfircNs+shTmSJLF4Twrz/opFazDhaKPkjbFtmdTZ3zwVq2V5ovcu/m9RTl7xnxJ+lZPwqIJ6QmB3EZK8guj8ufwytsXmsDshn4PJ+ag1l3qIchm09HGirZ8TrX2daO3jSAsfR9ztrRu8IrdMayA+p5SzWSWczigmN/kErnmH6SY7Qx/5STxkl0ZQilyisGk/DpuocSK32cgFQan55Ty1MvrCiDOJL8IOMTbrK2QmA/h2ECPmGmCCzrG0IqYu2IfWYOKRAWG8fFtr2DcfNr8iQu2P720QSTiTSWLk5zs5m13KS7e14tEB4ZdvdPp3WHWfuNh99nSjFvDEZ5cw7NOdqJRyTrw5vG5DE7a/D9vfExdGk3+odTNLuPU68PX1JTg4mPj4+Fq3UalUtXqZG2Oy2BaXi5VCxrxJ7Ws2kOlHYfUMYSA73i1CQI3M+cJypi86iFpjoGuwKwvuuYKBlCQ4/INQzTFoRL5nzGfQZpxZ15hXquX51cfZHifKwvu38GTepHb4OtfzoOW8BIj9A85sECHUi/OJ1g4Q3FtMYQntL7zEK5xITCaJI6mFbD6Zxb9xOSTlll3yvINKSfdQN7qGuNI5yJV2/s7Yq5rGV8xepaRjoAsdA12AQCAKjX4qJ9OLWZmUR1bsATwyd9BHdpzOsnhcik7CzpOw812KHCJQdZmGbec7wdm/UdYf5G7H6kd68cU/8Xy5LYEnk7qzx+t/vKv/EEXmcVFtevdq8T80Ix0DXfjojg48sTyaBTuS6BToysgej0HsRji3W0ST7ltv9osKuVzGg/3CeHHNCX7am8KDfUMvT6O0uE1UQZdmCY8yYohZ13QlIrwccLe3Jr9MR8z54rrVGARe8EDPH6zfxV2FpvENNhP5+fmkpaXh63v9lXBqjZ43/zgFwGMDI4jwqkGNpiBZaDrqy0WT8djPG/2Ku6BMx32LDpKt1hLp5cDC6V1rn5VYXiC+1JVjrCKGCgHnGsKJ9cmu+FyeWXmcvFItKqWc/xvdmnt6Btefd5WXACfXwKl1op/zYnzaiebkiGFiGoniyj2ikiRxNLWQDScy2RSTRZa6OoSqlMvoGuLKgBZe9A53p62f09XzvU0IGysFXUPcxAlrcAu0hmlEpxbxZcwZ9Kc30rl8D33kJ3EpTYAdb2Ha8TYFnj1x6fcQyjZjGzyHqVTIeXZ4S7qGuPHUimhW5gQRYzOX1U6fYK9OEm0CU5eKiR1mZGwHP46nFbFwdzIvrD5Oyyf6Ejr+S/i6txgSfOTHBqnAHNfBj3mbYsko1rD5VPblQwmU1hA1EQ4tFIImjWgkZTIZ3ULc+OtUFgeSC+pmJP27ADLRo1qSDY7e9b7OmmhW4dbS0lISEkQxSadOnfjkk08YNGgQbm5uuLm58eabbzJp0iR8fX1JSUnhlVdeITU1lTNnzuDoeG2z4Cpd9TnL9rHieD6hHvZseqrf5X155QXwwzBR3OLTDmZsbPR5kBU6I9MW7ic6tQhfZxt+faw3fi61eGapB2DN/aKvT24Fw+ZCj8fMWrlqMJr4ZMtZvt4uGqFbeDvw5V2daelTD3P61JkQs1oYx8zj1Y/LlcJLbDUGWo665taBtIJy1kan89vR86Tkl1c97qhSMqyNN0PbeNM30uPahRiaIUm5pWw7dpbSo2voWfYPPeSxVc+VWrlh7HAPzn0fEgVLDUx6UQWP/3KU42lFOFPKRu9v8S8+Kv7f4+dDhzvN+vf1RhPTvt/PoZRCWvk4sm5WH2wOLxBDDKwdYdb+BsnrfvJ3HF/8m0CXYFd+faz35RtUTgexsoPn48063PxqVOYlB7QQIiZ14uvekHNKzN9tPbbGTW7pnOT27dsZNOjysu/p06fzzTffMGHCBKKjoykqKsLX15dBgwbx9ttvExh47bPMKg9w8DOrwNqOXx6sYUakUS+q65J3glMAPLi1wfq2asNkkpi9/CgbY7JwtrVizaO9iKypl1OSYP83Yp6lySAmr09eZNa+RxDh1SeXR7M3MR+Ae3oG8X+j29yYKIBeI0ZyHVsmcoySmDCBTCE8+6hJ0HLkNedV9UYTW05n8/P+c1XrBCFiMLyNN2Pa+9GvhceNDaFuppzJVLPtwCFUJ5Yx1rgVL1kRACbk5AeNwGPYc8gCuzXomrQGI//bcIal+89hjZ4VnkvoXHJBumzUR2bXSM5Waxj9xW7ySrXc3SOId8a3gcW3QdoBcVF2p/kVb3LUGnq//y8Gk8Tmp/tffsEpSUJfuTBZfM+jau4vbwgqBzE7qpQcf2N43fol1z8JR5eIubRD36xxk1vaSDYElQc48OlVjO0WzvxpnS/dQJLgz2eFqoW1A8zc3KjT1Sv5cHMs87clYqWQ8fMDPegRVkPPlrYEfp9dPcev7e2iMtDME9ePphYy65ejZBZrsLNW8P6k9oyrbdzPtZAXL47/sWWXNtsH9hBtN20mgP01DL++QI5aw88HUllxMJWcElHEJZNBrzB3JnUOYGSUT5PJLTY2eqOJf06eJ37XKjrl/EZf+amq5/JcO+I8fA5WrW5r0LTDz/vP8cb6U5hMRj53XcO4inXiiWFviUI6M7I7Po97Fx1AkuCbuztzm3eR0DU2GWDaKmgxwqx/H+CRpYfZfCqbmX1CeX1sm8s32PIG7PlMfC+mLLn8+QbCYDQR9eZmNHoTW5/tT4RXHc47lWpC4YPh3rU1bmIp3GkgbKzkvDqq9eVPHPxe/KOQCTWdJmAgfz1ynvnbRAjzvYntazaQefGwYpro6ZIrhVhz94fNfjI7lFLAtO/3ozdKhHnas+CeLjV7uFfDZIS4jeL4J++oftwpQITWOk4TfYvXQXx2Cd/tTGLdsXT0RnGt6OGg4s5ugdzZPVA0jFu4BCuFnJEdghjZ4XnSCh7nmy1b8Dn9A6PZjUfhMVh5F/nOUTiPeh1li+ENYizv6RlMqIc9j/18hCcL76DAXskM4xrY8jroyoR0nJnW0TfSg0cHhPPN9kReXhtD56f7493zcdGjuGmOKAqzMq9K1NRugWw+lc3a6PPMua3l5ZGONuOEkYz/WyhGNZL6klIhp72/CwdTCohOLaqbkfS9IGuXeVw4LA3w+bIYyVp4qF/Y5fm8xG3w1xzx+7C50PK2hl/YfzicUsBLv4mxPY8PDGdylxryIPFbhRizthgc/cTVZGAdcwK1UFyux9nO6jLZqY6BLnQJdsXVzpoPJrfH8XpzeJpiMR/vwAIoOnfhQZm4Qu/6gChGuM7S9qOphcz/N4F/Yqtl5LoGuzKjTwjD2/hcU3+iBQh0s+OxqeMpLh/Fsl2Hke//hsmmv3AvPgnLp5Dv0h6Xce+gCOtv9rX0ifBg3aw+zPzxEG/mT0Rta82T0jLYMU/0MA55w2wn1GeGtmBXfC4n09W8uOYEP057AVnMahHi3PdV9WQOM9E/0hMfJxuy1Br+OZNTNZ6qCr/O4BwoxDES/zV73/OV6Bh0wUimFXFH12tPg1Xh1VZc5JfnQ/F5cKnDPq4Ty9mgFqb3Drn0gcJzotBFMkGHadD7yUZZ18VkFWt49GchWH5blA/PD//PDEdJgr1fwbI7hIEM7AmP7Kh3A/nUimieXhlNXqkWuVyGyVQdwbdSyPlheje+vrvz9RlIdYZoS/mkjehBKzoncot9n4WnT8C0ldBi+HUZyCPnCrj3hwNM/Hov/8TmIJPBiLbe/PpYb9Y81psx7f0sBrIOONtZMWNEL+54eTG/9d/IUtlYKiRr3ItOoPhpLPnfT4Cc2P9n76zDozq7r32fmcnE3T0QkhAsuLtbC0ULxaECpQJ1o071pUqhlFKkpbi7uwcnBEgIMeLuY+f745kYBIjS9/d+XdeVa2DknCeTmbOfvffaaz3yODVFfWcr1k/vSIi3HfMKBvO5YaJ44Nh3cOTbOjuvWqXg+9HNUasUHL6Zwvpr2aWz0se+F/O5dQiVUsGwlmI0Z9OF+PufIEnQcJD4981ddbqWR6GZl1DbuXa3mjZeJmZibheE0PxjwL9XhAegHKFEWwBrxgsnB48WQtz4Hx71KNLpmf5XaIlp8rcjQ8o3wvVa2Poy7HlPBPYW42Hi1lof77iTmseB68nkafQsNLJWFQqJsq1uS1NV5cc70iJFc/6HELEL1+SKL8UTP8CsMOj9YZXZlFfjs5iw5AzDF5zk6K1UlAqJUa292D+7G7+Ob00r37oTTPj/CeZqJeN6tWb4O0tZ02kbq+iLTlbgGH8Qwy8dyFrzYp17MDpamfL3s+3oFujMb5p+fKYbLx44+JkY+q8jNHCxZlZvYZ33ydZrJPsOFmIUmhw4/HWdnbcYTzYXPf5DN1LIKqjAa7LYk/HWXrF5/ofQyF30CMMTstHpDdU7iIuxDZb8b5D874Asw/bXRQ3cwhFGrajzHkNl8MnWMC7EZGJjpuLX8a3KE0sKs+CvkUIqT1JAvy8EQacO5tqUCglbCxOCXK0Jjclg6XHh9yZJ5QPlI5F+GzZOh59bC/aaXgM+HWHsWphxSmhRVrGXEpeRz6zVFxn80zGO3ExBpZAY3dqbg6915+sRIdR3/ufo8P/LsFCrmNi3Hf3e+IuFTf5ij6E1CgzYhv1J/rzmFJ1ZJmQB6/D8iye2ZlgLTxbrBjBPN0I8sPtdI5+gbvBsl3o09bQlu1DHe5vDkPsYhUXO/S42f3WIhm42BLpaodEb2H0t8f4n+HUWikC5ieVHpB4zfB0tsVArKdIZuJOW9+gXVAQXIzkpKaz2FvYQ/BskH4ULK4y2VwpBoX4MNfBHYcP5OP46HYMkwQ9jWuDraFn6YFY8LBkgLGVMLOHpv6HDjDrJfPUGGb1BpqmnLTN7NiDQxZqtlxO4aNRgzdNUwpA2I1qYU//UGi6tFFlvgz4weRdM2SlKqlVce26Rji93htPz28NsNJafngzx4MBr3flqRDN8HP9vE3JkWUarN1RtE/IPwN5SzcyRAwl4eQtfu39HuMEbC10WpjteJmN+zzq9yJkoFXw7MoQJHXz5UfcUC3TGmbpts4XIRB1ApVTwzchmmCgl9oYlsaegofgsG3Rw8PM6OWdZFDPGt11OqGBxpqUiCxF763wtD4JSIZWMqYQl5Dzi2Q9AsapS8vWHP6+W8C9x52FIugY73hD/7vFenSt5VAa3knJ4b+NVAF7uGUCPoDLl0+RwMb+ZHS8smsauqdP5R6VCwsXGlNiMfFQKiXHtfVl09DafbgvjfEwGnwxpwjNtfSqeh8pPhyPfCLaqwVgeatBHMBG9WlVrPbIss+XSXebuuE5Sthjl6FDfkXcHBtPUqxrOA48JOr2BmPR8olLzuJtZwN2sQhKzCknOKSSrQEt2gY6sAi0FWn3JxqQYaqUCtUqBmYkSewsT7C3VOFqqcbE2xdvBAm8HC3wcLKjnZPmPGVXXc7LkzeencDCsL/s3fM0k7Srs0y6gW9CFos5vYtnjNVDW/qVIoZD4+MnGmKoUfHX0aSwpZIJqr9AotnYHn2oKbT8EDd1seK5rfeYfjOSTrWF0e+YDzCL2wtUN0PXNOnWvGNDUnW/33ORkZCo5hdr7OQD+PcRccdRR6PpGna3jUQh0seZCTCYRyfcaClQSTqKsTVqEYL3XsSbtv0HyQdDkCU1WXaGQa+v8z7t6FGj0vLjyPAVaPZ0aOPJyr4DSB+POwV8jRN/UKRCeWVer9jiZ+RqKdAYcLdUl0msGg0xGvpYCjR4bcxMcrUyxNlNxOS6T+k6W9GvsWkLkKQmU2gI4vRCOfifIRCBo8j3frxGh6GZSDu9vulriQ+njYMEHgxvRO9jlsYuJPxCyTHZWGpG3I4mJiSY1MYa8zBS0eRlYynnYkI+FpKExWlqiRU15wXStpKRIaUKhUk2hbEo2FmTKVmTqrMjQWpGY50BUsgPnsMVwT5FIqZDwd7akkbsNjT1saeUntGUfiw2ZET0aedG+wXf8sXM4gaEf01sRiurYXDKvbcVuzOI6CSCSJPHuwGCUCgUfHZ6Iu5ROH0KFIcG0fVUeG6oMXuzRgI3n44nPLOCX62bMbjhYSD8e/VaMjdUR/J2tqOdkSVRqHkdvpd7PcvXrIm5jz4CuSGSX/wCKJT4jU6oZJO18QGkqjMmzYutcUP7fIPkg7JkjZgqt3eGpX+tUrq2y+GRbGDeTcnGyMuX70S1KBdcjD8KqZ0CbB56thdCzRe2ZFK8+G8OiI7fRG2T8nCzp2dCFCR38UCgkPO3M8Xe2IiWniHl7b7LzSgKDmroTn1nA8hPRvN4vSARIWRauBHs+gKwYcWDXpmKUpgaakkU6PfMPRLDgcCRavYyZiYKZPRowrUv9fyZz0usEEzctEtIiyE+8SU7ibciKwbowERsKaAG0KPuaWl6mQVKRrXYhXunFbYMrYYVOXNK4cz3Jh01JuWy6eBcQSkKtfO1pX9+RHkEuBLtb1/mGwlytZMaQblxrvYGv//qB5/MWYpdxBe2Czuh6foR55xdrvTUgSRJv9Q9CqYCXD77IKukzQgpui03l1H21bpZsoVbxweBGTP/rPAsP3+bpcS/hEb4Nrq6Hbm8J+7U6Qu9gF347GsW+sKT7g6RzEFg6Q16KEPv3rUDG7jHA30W0hyKrm0kqlGJzkxwm5r//DZL/EK6sBjOl2PlVQb2lrrD7WiJ/nxF9yO9HN8fZ2rgLDN8uMl69Bur3EJqGtajPuOZsLJ9tv84HgxthbqLk1O00vt19g8x8LS/3CiCrQMvF2Ex6zzuMh50566Z3JMjVmk+3h7HjSgI9GjrTyvQu7HpbeMEB2HgKf7umo2q0+QiNzuCt9ZdLyja9g135eEhjPB+kV1vbyE+HhIuQcFl8YZOuIafeRNJrSp5iYfwpi1wsyDNxQG/hjIm1MxY2jljYOCCZ2YKJuTCXVZkaxdfLBAyDVkjx6QpERl6YJSoHBRlizCAnAXISUMg67IruYsddGgNPABg5W7lqFyKV9ThSUI9jRQGcvVWfo7dS+Wb3DdxtzejR0IV+jd3o5O9Yp2LtjT3taDD7fX7f2ZPgM+/TQ3kRk/3vkXnzAHZP/1brgUuSJF7vG0SR1sDUY2+w0XQO3um3BWt9wuZHCt1XFf2buNElwImjt1L57LwJvwQOgJs74cRP8OSPtXqusugV7MpvR6M4fDMFWZbLb3okSRB4rm2E6BP/WJCs7ySuT1GpefevsbJwbCC+c2kRENCnlldYHv8GyYehy2viQ/UPIzmnkHc2CJ/H57rWp3OAMWhf2wjrpoKsh+AnRUCv5RLKxbhMhjb3ZJRx8LdnQxcautswZ/NVvB3MeaqFF5M71SMiOZe3+gfhYiOYv9O61KdfoC2trn8LpxcIQo7KTMiEdXq1RqofRTo93+29xa9HIpFloZLzyZDGDGjiVneZkEEvetQxJ4U2Z/x5MSx+DySgQFZzR3bjtuxGtOyG3sYHO09//OoH0ahhIxzt7akzXq1eB7lJkHEH0m4J1nBapFh7RhRWmmRCSCaE07xkKrLO2+pAdhQ0Zl92M/4+nc/K0zE4W5syJMSDp1p6Vs9JvhIwVSmZ8UQXLjTbyHd/fcGMoj+wi91P7g/tsHh6CYpaFiGQJIn3BgWTr9Uz+cwbbFR/iHX0cdjzvvBOreVzvT+oEQN+OMKOK4ncGDaZoJs7hRtHrw9rfRNQjJY+9piZKEjL03AzKfd+LVevNuK6EX++Ts5fGXjam6OQoEhnICWnqOSaUSUUZ48Z0Q99Wm3g3yD5ILiFiNLIPwxZlnlr3WXS8zQEu9swu4+xaX11Pax/VgTIZqNhyC91Qn6ISsnDwap0dMTSVMXTbbyJScvj/Y1X6RrgzPTu/hRq9SXlTVmW8Uw8iOeONyA7Trww+Eno93mNHSNuJuXwyqqLXE8Qw8jDWnoyZ3Aj7CxqebxFlsVONfKgkMGLOV3aQy2DVLUn5zQ+XNF6Ey57c0P2odDcna4NXeke5MLYAKfaX9vDoFQJz0dbT/DrVP6xwmzxO929CLGnIOYUipwEGhSF8bIijJdN15KrsmOfrgUb8tqy9FhjFh+LIsTbjskd/RjY1L1OxBZa+DrQYPZcvvu7LSOjPsBfk4Bh+RDyun2AZfdZtVp+lSSJT4c0YVahjtlXpvObep7okXu0hJDRtXYegCA3a0a08mLNuTjeD7VijXsIUsIlCF1SZ8QZtUpBGz8Hjt5K5URk6v1B0rO1uI0/99hk3e6FiVKBu6058ZkFxGbk1zBI3qnNpVWIfwXO70GJOO7t89jUa/HoF9QxVp6O4d2NV1CrFGx7qTOBrtZwZR1seLbU6PnJn2qd4VVcBvlx/y0O30zhkyGNy2UUSdmFPLf8HP4uVswb1bz0hTlJsOM1uL5V/N/OFwbNg4DeNV7PshN3mLszHI3OgIOlmrlPNaV/E7caHbcc8tMhYr/QuLx9CPKSyz+utqLIvTUXpYasT3Jjd4YHWcac0NnalEFN3RnUzJ1WPvbVczh43JBl4c13+5AYC4g8JIbfjchV2LBD15r12k6clhviZGXGM+18mNTRD3vL2g/8siyz4fRNFDve4CmF0OfN8H8S+9G/1rreqFZv4Lnl52gROZ+XVZswqMxQTNtf61rMCVkFdP/mEEU6Azu73yX41OuCef7q1Trz41xwKJKvdoXTp5Erv01oXf5BbQF84SXGUl69+o+NtI3+9SSno9L5fnRzhraohpF3xH7B5HcOFrZkZfCvwPnjQh2w3qqK+MwC5u4Qs0Bv9gsSAfLaJkFhL1bReeLHOiEVFZct2/g5sPXSXXZfS8LLzgJbC9G7cbUxo3OAE1fis0UWqVKI4L3zDdEjk5TQ8SWRjdfwApdVoOWtdZfZZRyS7hHkzFcjmuFiXQuiDum3IWwLMVeP45x4BHNKTZVRmYNfJ+R63Qg3b8FvN8zYejWlRAzd3ETJ8KbujGjlRdt6DqVEqv8rkCTBgG41UfzotaKcfG0ThG3CKj+NUYoDjDI9QCxu/F3Qjb/3d2Xx0duM7+DHs13q4WhVe+V9SZIY3j6IW35/8sOST5lR9Dv2kVvImB+B/eQ1tXpBN1EqmP9MS575dQrNkqPoziX0qyegfOFwrbriuNuaM769L4uPRfHR7UBWWbog5SaJ/mSjIbV2nrJoW0+Q9s5HZ9zf8zMxF4El6QokXvnHgqSnvTlEQUJW4aOfXBGKK1JZcbW3qAfg3yD5XwpZlnl7/WVyi3S09rVnSqd6cHMPrDf2IJuPq7MAWRYd/B0Z0MSNLRfjcbUxZUQrrxKXAQu1iow8DVJuMux+XdDcAdyawdBfhBl1DXElLosXV54nJj0fE6Wg80/q6Fez3mP6bbiyHsI2s+WuFd/oRmNOL1R0Z5bjGbo0qYdZw97Inq2JzNAye80lLsdlAaLE28LHjjFtfBjYzB2r/yULLaWJMKiu1xUGfA3Rx4WR9bWNeGsSedNkNa+ZrGWLvgOLjwxi2Ql/JnT0ZUb3Btia1x7xJcDNhsmz5zJvaUOmJXyIY1YYOT93w2LyepSetVfdsVCrWDSpPZN/mU1Q/izcMyLRb52NcsRvtXYOEDyC5aeiOR2Ty91Ww/C8tlCoYdVRkGzsYYNKIZGWpyEuowBvh3s2qa6NRJBMvgYNB9bJGh6F4g1uUnY1g6S1kbmryRFthDo0vP/n5xr+RYVYey6Oo7dSxSD0iGYooo8JJp5BB01GCIZcLQTIpOxC8jW6Ch8rFiqf3TeIlj72rDkby3d7b5GSU0RUah6HbiTT0joL1aLOIkAqTITowrMHaiVArjwdw/AFJ4hJz8fL3px1L3Rkcqd61QuQealwehEs7i1MaA9+xsWEfH7UDWOs022+7mZGvaAQ/qOaykLVWPDrjKw0xdnajKiUPNQqBcNberFlZic2zujEqDbe/1sB8l4oVVC/Gwz5GV67IXre3u1RYuAp5XG2m77Lb3xC2NFNdP/6AMtO3EFbXS3OCmBjZsIbz01hQ+u/uG7wwVqXhnZxfwrCaleg29nalO8n9+Yd6VX0soTy6hrky2tr9RwuNmaMNhLf5qUZBQwi9tdZFmRmoiTYqJFarH5VfkFG7dPHJOtWEVxtRAUixejfWmWYWoGpsf2TU4HCUC3i3yD5X4jknEI+3S4+wLP7BOKvvSWGn3WFEDQQnlpYKz3IH/bdYtCPRzkekVbOuaMYCoVUou7yydAmdA9yYeuluzzx0zHGLDqJWeYtPox6BmVBqph5fO4QdHuzxnR6rd7Aexuv8O7GK2j0Bvo0cmX7S10I8bar2oH0OrixS8yQ/idIlILjzgqJQf+ebPJ9D5VzANNf+5Tm/Sfx44RODGzqzh/H7xCXkY9CIWFjpmLBuFacfLsn/xkVQjOvKq7hfwGmVtDiGZi6W/yNm4xAlpR0Vl5jhfpLftO/z95tqxjw/RGOR9Se44VCIfHsE92IHbqB44ammMmFqNeMIfPEH7V2DhDD7dMnjGO+YRgAms2vCheaWsTz3eqjUkisv2NKrlt7QIZLf9fqOcqiufG7cjku8/4HXR6vrFtFcLWpYSYJYGM0bs+uwPmkFvFvkPwvxKfbrpNTqKOZly3TGsnw5wjhhlGvK4z4o1Zmun4+cIstl+KxNjPhm93h3EiqWEexuM1mZari5V4BbJ7ZifkD7PhO/SsrCl9GIcnCNuzZ2iE9pOdpGLf4dIk27Zv9g1g0vlVJL7RSyIqD/Z/Ad43g79EQvo0YnQOFrq2h/5cwOxzd2PXITkH4Opf2n5QKiSHNPfBxsOCb3TcAwW3pHOBUq723mkKWZQo0enIKtWQXaskq0JJTqK1wo1Pr8GgBI35HeuUitHsBWWVGa8VN/lR/wdysN5n3+3JeW3OJ9DzNIw9VWfRtGYD1lA1sk7qjxIDdnldJ2lm7zhrt6jviOuh9Lhr8MdXnkvr387XqluFlb8HgZqJEuF3RTdxZRxqyIEquAOGJFXyvnY0M+fTbdSo0/zA4GIlfGfk1+JwUOxrVtRVZnR79X1QZR2+lsPXSXRQSfNXPDeXK4ZCfKmx3nl5ZKw4k2YVa8jV6xrf3ZWRrb/p9f4Svd4XzxbBmuNmWP74kSSTnFGKhVmFlqsLp1lqctr8mslorN5HV+veo8ZpA6NJOXnqWuIwCrExV/PB0c3oFu1buxbIMUUfgzCK4sUMQm4BF0iiWy/1xcrBFqzXlPedg2lg4YKJUoDPI5BTqiE3PL+nbeNqZM6q1F9/uuUlKTlGpaMNjRGa+hvDEHG6n5BGXkU98ZgHxGQWk5WnILhCBsZg8VBaSJDYzNmYmOFqp8ba3wMvBHG97Cxq6WdPYwxZzdS2xoO18YMBXSJ1nwbHvkM/9QVtusN70YzZf2csz4RN47okuDG3uWSuzq838XHB4aSWrFr7E05r1uJ7+nNiifLyH1J6Z8uj29fnhzscEX5+MU8IRko/8jku3abVybIAJHf3YdPEu38YEMEqtQkq6Cik3S4NWLSLQOPpxo6IgaeMlWiP6IpGF/QPkHTvjpjczvwJbr8rC0lnc5qXUwooejH+D5H8RCrV6PtgkxMuntnUl+OA0MQdk7ye0WGuJdWdjZsLwVl44WKixNFWxdHIbBvxwlD+ORzGzZ4Nywsh3MwuYs/kaZkqZn62WCkcUEHq2Ty2qtaHoE5GpPL8ilJxCHb6OFiye0JoA10r8vjqNmBk9+TMkXS25O8ZjIJ9oxhKvs+GtHgE4W5sy/2AE/9lzkzf6BdG+viPDW3nx9KJThCVklwRJlVJBIw9bPOzMOXQjuXru6VVAVoGWS7GZnI/J4GJsJuEJOSRWswQly5BTqCOnUEd8ZoGRbFQKpUIi0NWa5t62dPB3onMDp5IdfbVh7SaCZadX4dAXyOeXM0R5gr76cyxY9yTTL07ls5GtcKqFTNzLwZIBs37l7/lWjMldhvfF77hdmE/90V/VWqCcPmIQq3+YwPic37E4+AG5wb2xcvGrlWO38LajiacNV+Mh1qUtPuknIGyTaFHUMgKM+qjJOUVk5GnKj+woVYLVnBYhssl/IEjaG2eHMwu01Vfd+TdI/v+H349FcSctHzcrFW/mfQN3LwgPy3EbwMq5Vs/lb/RS1OoNNHCx5psRIcxacxF/ZyueaulZInztZmOGr6UOy1ubochoGdbjXej8Wq0xa7dcustray6i1cu08bNn0fjWj57DK8wWPn2nfy1t3JtYQvOx0GYaYcm2WF5N5Jsu9WniKRr8ga7WDPjhCDpjFtbSx54mHjasORtLYw8bvOxFoPR1tCAtt6hWLuz3okCj58yddI7eTOFYRCo3knIqrOp52pkT6GqFl70FnvbmeNqZ42Jtiq2FCTZmJtiYm6BSSEgSSEgYZNkYILVkF+pIzi4kNqOA2PR8YtLzuRKfRUpOEdcTsrmekM3fZ2KRJGjiYUv3IGeGtvAs+UxUCzbu8OSPSG2mYtj5FuYxJ5ltso7IqOO88910xo4aU96xppqwNTfhqVe+Y/UCC0anL6B++K/c+FND0LjaMUJXqxT0n/YZV74/SlP5JheXzyTkta21kg1LksSE9n68uf4yq/Ja8SYnxDxxHQRJazMTPO3EwH5kSi6tLe/RcnaoL4JkRhTQrdbP/ygUs6H1BpncIt39jiWVQfEG/d8g+f8HkrILmX8wAoAVvjswidgllO7HrKrTmc3iYDi0hScXYzP5fMd1fB0taOJpy6qzsQRL0bwbORVlUSpYOAlPzfq196VaciyKT7YJktLApm7MG9X84cLkBRkiMJ5aAIWZ4j4rN2j3PLSejGxmhyRJNFMX4OtoWcLyk2UZS1Nx3JzC0hLPuwODmbnyAmvOxjKrTyCSJBGXUYCJUlG1PuhDkJmvYU9YEjuvJHA8Mg2NrnwfyNfRghbedrTwsaeJpw2BrtbiomEwCJWfwiwoTAFNPuQXQbZGaPWCIHBJClAoMVNb4WxqDVZW4GwPpq4lgUOWZRKzC7kUm0VodDpHb6USnpjDlfgsrsRn8dOBCJp72zG8pSdPhnhW/3d3D0ExeSdc24B2x9v45yfwm34OK1cc4suWbzHryTYlI0TVhZmJkuEvzmXjb6Y8lfg9QZF/cHmFCc0mfFOj4xbD2daC1KE/od0wkOa5RzmwdQU9n5xQK8ce1MydD7dcY21WMG+aAYmXITel1jfBIJxw4jMLiMsooLXfPQ8Wk15yKjBofgwwVSlQSGCQIV+jr16QNLMTt4X3K2HVJv4Nkv8l+GpXOPkaPa87nyEgcqm4c+gvNbKPqiyKraw+erIx4YnZfLjlGqYmSm4nprNKOQclqeAeInqitl61ck5Zlvlu3y1+3H8LgEkd/fhgcKMHD+QXZMLJ+UJCrEjMK+IYAF1mi5EYo3pJ8as97MzxMAqd6w0ySoXExZhMdHqZNsZha1mWae3nwPgOvqw5F8uxiFTa1Xdk4/l4Ovg70si9+rNXBRo9u64lsPHCXU5EpKIrQ6pxtzWjWwMH+nppaGWThW1RLGQeh8RYiEgS2qu5SUIBiBqQR0wsRTnU2h3JwQ9354a4OwXRv1NDGBhMck4RR2+lsv1KAodvpnAxNpOLsZl8sTOcsW19mNqlHu621RCLlyRoMhwT/17o9sxBdWEZY1UHSLx0gc/vvMZzk6eWZO3VhUqpYMhzH7HzDwUDYufR7PYiTv9pQbtxH9fouMUIDmnP5dBxNItZRkDoJ1wL6Utj35qrO1maqujb2JXNF/UkmgfgVnBLKB41G1nzRd8DL3vxt4vLyL//weI5w1pm8VYWkiRhqVaRU6QjvzLm7BWhJEhm19q6KkKlgqSDQ9VslyRJ4vz58/j61p6f4f8yLsZmsuF8PK2kG8zImy/u7P4ONB3xWM5fPOqhVEi82KMBE5acoZ1NBscUb2JLHjQeBkPm15o0mCzLfL79OouPCYHw1/oEMrNng4pLWpp8QcY59l1J5pjr1JyVLrNp0boTbeo/2qGlOPBeiM2kjZ8DTlamyLJcIl35Qjd/2tZzYF9YEmF3s5nVJ4DRbaquMSvLMhdiM1l7LpZtlxLIKdKhRE89KYGeDqn0dkwlWHUXq9xopPDbcK2SM2IqczCzFe+/ygyUavEDgqAk68W4iyZX/BTlCGKVNg/SI8VP9LHyx7R0wcWrNcM9WzG8e3uSh3Zhy5UU1pyL5WZSLouPRbHs5B2GNvfk5V4B9w+kVwbmdqiG/Agho8lfPwO3nDt8kv0+y384hd/or+gaXLMNl0Ih0X/KHA4vKaBb7ALaRXzPoZWWdB9bO+XLps98TvrXO/DWp7Bsxft4v74Am+pkPPdgaHNPNl+8y67CRkziFkTur6MgKf5mcRkF9z9obQz4/1AmCcI2LadIR15RxXPaj4SZcU7yvyGTzMzM5Pvvv8fW9tFuALIsM2PGDPT6au4O/j+DLMvM3XEdZzL4w/InFDotNBr62MXVlQqJHVcSeHHleZ5xuMFneR+LtKznB8INpZaIEbIs8/HWMJaeuAPAh080YnKnevc/0aCHCyvg4FyRVQF6x4Zs8H2Pn8KtiL1QwNOquzTytMOykkP9+68n0a+xuDhIkujjybLYHLTxc6CNX/U8OAu1erZeusuyE1EUJITTXIrkdUUkbSzuEChHo5I1kI/4KQulqSBQ2PmIH1tvUQazchH6npbO4kJQHWcXTZ64AOYkimwhLQJSwoVHauotoUt7Y4f4AVxMbZhWvztTu/XluLI1P53K5HRUOmtD49h88S6TO/kxo0c1lXX8OmHx0klyt76N1ZVlTGAbV/++yqoO8xjdv2eN+n2SJNF1yhec/b2ANnFL6XJjLjvW2DJw1PPVPmbJsU2tMR38NWyezNPaTXy2ehifTBhQ4/5k5wAn7CxM2F8YzCT1ZmFbVQdwtxNM9Qql3yyLxyeS73/sMaG4rVKkq2asKCYyFv0XZJIATz/9NC4ulWu8v/TSS9Ve0P9vOBCezIWoZFab/oCNLh1cGoky6z+gzm9LHt85b2do9l/iAj5sETQeWmvHl2WZOZuvseJUNJIEXzzVlKfbVpCx3T4Eu94VslkAtj7Q4x2yGzzFtQO3GdvODHMTJV/vCmdka29a+tg/8tyXYjO5djebxRPaoNUbWHAoksM3U3h7QMNqB8f0nAJ27dlJ8tUDNNaFsVxxAwfTMkayxa1HE0uhcuLaSPx9HQPAqYEIirUsTF8CtaXoZVfUz9YWQMIliDsn3CCijooxo+tbkK5vobNCRefA/kQOHson1z04HJnJr0dus+ac6Ns+08636jq1agushv+INrgvmvUzaMIdfE89w7K77zN24owauYtIkkSbqd9zbVEWjRM20uvae2zY7MywIcOqfcxiWDZ/ipzTv2KdeIo2ET+y4XwzhreqWQZsolTQLdCZAxcbICMhZUaLWb9a9q11KGaQVjSLaG4nbuu4VPkwqJTiM6SrYJypUiiubGlrIEhQCVQqSBqqOHCak1PxYPq/KA+9QearXeG8r1pBS+mmkFka/ae4wD0G5BXpeHvDFV7vG4gviXQ6MByy74C5vSAM+bSvtXPJsswn28JKAuTXw5vdP16RflsEx5s7xf/NbEVG3WYaqEyxk2WebO6Bn6MlDpZqFh25zfrQOBq6WWOhVt13vrI7/kM3Umjt58Dyk3f4/XgUVqYq3hsYXPUAmR5FzrXdxJ/fiXv6WcZKeeJ+Y6yTVeZIHi3As6UYvPdoAfb16lxjt0owMRd/2+K/r8EgmNS39ojMMvEyhG/DP3wbSy1duNNqFK9HtyM0FeZsvsb60Di+HN6shBRVpVM3GozKqyWJS8bhlhnKpNj32PDdFbq/8D0O1jUwy5YkGj/7O1Hz06mXdpiu519htbkTo/vW0JNSkrAe8g3yr115UnmSMVs2067+5Br3VLsHObP54l1iFV74GGKFElTQgJqt9R4UM8TTKwqSJf28zFo9Z1WgMm609NUVwTApDpIV9FxrEf8Sd/5BbLwQT2DKXiaq94o7hi16rO4jH225xtZLd9HEX2Kh/DlSXrKwthq3HpwCavVc3+y+wR/H7wDw1b0BUlsAx74XfUd9kXAQaTMNur8NFqVBTJKkclnjq70D+HDLNUa19r5Psk6SpBJCUm6RjsM3k7kQm0lSViFfDW9WUnZ9JPRauHMMbu1Ff3M3yvQIrIGGABLkSpbkurXDuXEPlH4dkdxDat3lvmQpBpmk7EJi0vOJTc8nM79UcSevSI9CEmVzhULCUq3E1cYMFxszXK1NCXC1fvBMpEIBXq3ET493hKbnxb/g8mqkvGTqXfuZdarF3GwwmNdjO3MpDp78+Riv9g7k+a71USmrtgGQbDxwe2k3sWtex/vGUoblreL09zdxn/oXPh4e1X+DFErqPbeSpB974ZoXTstjL/C32WrGdK2hjrB7M+SQMUiXVjLT8Bevr23Jymnta2SH1jXAGUmC05p6+KhiIT609oOkkaGckVfBwH7Zft4/5CupNG4ctdUOksZN1X9jkIyPj+f48eMkJyffl2W+/PLLtbKw/3Vo9QbW7j3KYpPF4o4ur0FQ/8d2/t3XElkbGkdzRQTzNf9B0mQJUfJxG0rlnmoJvx6O5JdDkQB8NrQJo8oGyFv7hP9ksXlq/e7CgcI56IHHK84SR7b25j97brL+fBwBrlZYqFUU26MeCE/mWEQqHz7RGCtTFT2DnHlvUDCtfCuROWoLhAD19a0iqzUSA5SATlYQKgcSad2WoI5P0LJ9D6zqICgWavViPCMui6vxWVy9m8Wd1Hw0NRAR93W0oLm3HS287ejb2K2E/XsfXBsJg+zeH4n34MRPSHfPExS3ji3Sek449eWN1EF8s1vmQHgyP41p8eBjPQhKE7zH/EDC0VbY73+NdvrzRC7qy40xawgKalTt3xFTK1ye30jOz10J0MQTu3cma82WMbKtX/WPCSh6vIt8ZR2duMZPd47xxwk3pnauoJdeSThamRLkak1YipHcmBJeo/VVhGIB/nyNrmLLLBCGCQZ9nRi2PwrF39Vq7zWKyWt6TZ0G+iq/M3/88QcvvPACarUaR0fHcm+8JEn/BslKYvO5O7yb/zXWigL0Xu1Rdn/3sZ07NbeIdzdcoZ10neVm/0GlyQevtvDM2tJeRS1hzdlYvtgpLgBvD2jIuPbGi0J+Oux6By6vEv+3dod+c6HxU4/8sEuShE5vQKVU8HKvAL7YcZ1Rrb1p4mlb8nm8djeb7ZcTGNDEnbaepszs9QjpL70Oog7B5bXC0URT2ltMw5b9uuYcNDQnzaUDLw5szZgAp1oZMC85vUHmUlwmJyJSOR6RRmhMxn3zlCBKVF725ng7WOBoqcbWXAgLWKhVyMgYDDJ6g5gFTc4pIim7kIQskX1Gp4mfzRfv8vG2MDrUd+SpFp4MaPoAyy+lCTQZJv4m0SfgxI9IN3fRKXc3Ry0Oslzfj++jn2DQj7nMG928WmIB7l0mkO4eTO5fo/CXY0lZOYBLA5cR0q57Nd5FAcnGA6uJa9H+3o+eXOTXLe+z3ewbBhm1U6sFO2+kVhPh7G/MUq1j/K7GdA1wqpwq1APQ1NOW28nGzDn1VvXX9gAUz6MaZNAZZEyUZT6vyjJVBb3mHwmSBmOQVFb3e6Qos2bZICpQdYAqvzNz5sxhzpw5vPPOOyj+m/os/4eg1RvQ7v2IEMVtClU2mI38/bF9SGVZ5v2NVwkuCOV30/9gatAI4fSn/xZuD7WI/deTeGfjFUCMWbzQzVhKDtsM218zKmVI0H66UPGpguxecYlvbDsfvt93k80X4ynSGdh+OYFewS5M7ODHGOUBnA9+K44b0BcaDhLs0bK7zsQrcHGl8E0so9xRZOXJTl0b/spqRqgciK+TNa/1DWRgE/caldnKokin50REGruvJbLvehKpueV7R87WpoR42dLE05amnrYEulrjbmtW5fImQFa+lktxmVyKzeRoRCpnotI5EZnGicg0Pt4axsSOvjzXxb9iEQFJAr9O4if2LOz7CGX0MSZLWxlufoi5RaOZ8kcRM3oEMLtPUJVJPQ4N2pA7/SAxi4bio4vCYscozmb/RJs+o6v8e5Ys2bMFqqcWwPopPK/ayotrGmBpOoPuNVH96TIb+fxy2hFOG91lXl9rw4YZnapttt3My5ZfzxuDZPptkdHVIpGrLBlKozOUCIcA5VsCeg1QO+NdVUHx7HC1zcrLBkmDrs5IcFW+Mufn5/P000//GyBrgBN71jJGtxkAaeiCWhvQrwy2X0kg6/p+/jD5FlO0ENgfRi6rFeH0srgan8XMlRfQG2SGt/Tirf5BQi1n+2tCaxXAKUjMX3q3qdY5inuOw1p68euRSBYfi6JdPQemhJhju/klMfbQcoIYgTj1i7gQ9f9C6L2eXwoX/hQklWJYOFIUNITfslrzbZgtIGFtquK9PoFM6OBb/iJTTciyzLnoDDacj2Pb5QRyCktnxKzNVHTyd6JTA0c6NnCivpNlrWWrthYmdA10pmugMy/1CiA2PZ/NF+PZcD6e26l5zD8YyYqT0bzQ3Z/JHes9WAjduw1M2gYR+2DvHGySw/jSZDEjlEd479AUrifk8NOYFpUeyymGlYsfqlcOcv2X4QQXhNLi2AucKsim/ZPPVvt3lpoOxxB/HsWpn/lCuZDhf/piOXVItdnM2HggtZ4CpxfwmskGhsU1YemJO9Uuuzb2tCVedqQIE0z1GuFeY197s+VlM0eNzoBl2UkiRZkgaajmnGINoa9xkCzzGTXogLoxI6hykJw6dSpr167l7bffrov1/M9Dn5dBozPvAHDNcySNmwx+bOfOyteycfN6fjf5FjPJGCBHrShRq6ktJGQVMHXZWQq0eroEOPHl8KZIUUdg03ThOiApofMsoVlZxRlAjc6AJAkafWaBljfXXWZ/eBIDm7rzUo/6NHS3g0urIOEyTNsnNEX1WkF1z0sVAVJpIoJmxh1xsQgaAC3GsasgmPe33iQ1Vwz5j2zlxVsDGtaKhmtqbhGrzsSw5lwcMemlRAMXa1P6NnalX2M32td3rJVAjEEv+qoGXemPiTmY2pRk0N4OFszsGcCM7g3YE5bEd3tvciMph6933WDl6Ri+HRlC+/oPEK+XJAjoA/V7CKGHg5/TWnOTber3WBDxBGMWTuK3yR1KPAMrCzNrewJn7+TC/HG0yNxDm9A3OKktoMPw6rdwFH0+xhB/DpvYU3wnfc/EpU6seK4bjTyqqabU6RU49zst9TdoK4Xz7W4VfRu5VktswdveAhkFabI1HlK6GMOpxSCpLyMKrFTeE4jkMrOJdTWG9AgUGJV2HipDWWnUHfGoykHyiy++YPDgwezatYumTZtiYlK+PDNv3rxaW9z/IhJXvYSnnMYd3PEd83jfqxXr1vG97nMspCIM9XugGLms1gNkXpGOKUvPkZRdRKCrFfNHN8Zk3wfCpQPAwR+G/SaYlFVETqGW6X+ex8POjK+GN0ORHUc/k4u8MbkzQYENxZNkGbJihfhxcQBWmohSaotnSn/f7u8K+nvTkSTrLZiz6Rq7ronSsL+zJV8Nb0br6mYcZXA1Pos/jt8RLGIj6cZSrWRgU3eGtfSiXT2HypVvDQbITRTZRmaM2GzkGOXr8pLFBqAwS2wGNA8YwZIUgvpv4QgezcG7HQqf9vRv1Ig+jVzZcimeb3ffJC6jgDG/nWJqp3q83i/owRcxpQo6zIBGQ2Dnm5iEb+Nl1Sa6pV3m5Z9m8eHkoVUORkoTU5q/vIrQ+ZNolbaFDlc+4IS2gI5PV1NcQ6lCMWIJ8sIuNCm4wyu6ZUz8w5z1L3TEx7EaJUYbd2gxDs4t4V2bHQzNCubdjVdYPqVtlbN+R0s1JkqJjJIgmVH19TwEZecPTe6t/JXNHhX/zJBDcZC0qK59m1ymZ1+H7Nwqvztz585l9+7dBAUJ9uG9xJ1/8WDI1zbhGbsVvSxxotnnjLWqvjZoVXE59DjjI2djLRWQ7dYBmzF/13qJ1WCQeW3NJa4nZONkpWbJpDbYbHtWEGEAWk0WrMlqzIGm5RYxYckZrt3Nprv6OoXpb2GXHsZIxwawaS70+hCaDBd9VZdGgoCzeaawGbuyRmRXsl4EkpYTIET0u3ZdTeSdDefIyNeiUkjM6O7Piz0b1EiEW5ZljkekMf9gBCdvp5XcH+Jly4QOfgxs6v7gcmZemlEZ5wakGq2M0m+LrFdfSRm7e9eDhIQsLioF6eIn7ZbowwKYO6BsOpKnmo+lz6td+Gz7dVadjWXxsSgO3Uxh4bhWNHB5SL/a1hOe/guubkC/dRYhRbdZqnmNrxZeou/4t+kYUDXxbkmhpOWLyzj36/O0TlpDx/C5nPizkI7jPqzW74+tJ9KwRfDXcCao9nIirzETlihZ+0LH6vmFdnoFQpfSvCiUpqo4jt6CtaFx5VnblYBCIeFibUZGnvG9LUiv+loegrJBUnVvJqkvMxaiqJuRpYdBlmXytcVBsppBulyQrLv2X5VXN2/ePJYsWcKkSZPqYDkPx5EjR/jmm28IDQ0lISGBjRs3MnTo0JLHZVnm448/ZtGiRWRkZNCuXTvmz59P48aNH/ta70N+OrqtszEBFslDGd3/icd2al16NB7bxmEr5XPHoil+U9aXUsBrA9kJoDJl4Zl0dl1LRK1U8Ov41mLgutOrQtnlie+rPQeWnFPIuMWnuZmUSw/LKH50P4K5R1MY/btg6R39Fs7+BjaeENAbAvoJhZurG+D8MjFv6dtJzP7t+xgkBfmNn+aTLddYdS4OEE7u34wIqX4ZDvH523c9mZ8PRnApNhMQbNRBzdyZ1NGPFmWVgQx6SLkheqKJV8RP0jVRcnsQJCXYeFJk5UGKwpm7elvuFFpxK8+cGzlmZMiW5GBOtmxJAWp0qNChQEaBmaThwuttMNfniCw09izEnhJ/m4J0OPMrnPkVK9cmfNlmKv0a9uGNjTeISM5l2C/HWTiuFR0bPEIRpskwlD7t0a5/AfPow3wkLWbrijAOjfqF7k2q1reTFApaPf8rZ5ZY0DZuKR0j5nHsLxM6P1NNFnhAb1HiP/YdX6sX0y/Nn4lLzrDq+fZV12O194PgJyFsE197n2BA1Cg+2SrYwlUtu9pbmpCfZ9ysFtWuCEuBMQgpFVLJ4H4JdGU2XHU01/swFOkMJT3JYneeKsNQpmRcR8xWqEaQNDU1pVOnTnWxlkciLy+PkJAQJk+ezPDhw+97/Ouvv2bevHksXbqUwMBAPvvsM/r06cONGzewtq4dw+JqY/e7mBSmccPgRULISzU3u60s8tPJ/X0oTnI6EXjjPG1D7Sr6bH0FYk5TmJ+NTXYwHRVtGfzkGFr52InHvdvAK5eqnbUmZhUy9rdT3E7Nw9XGlLm9PbDOaw+tp4K1q3hSrznwY4tShrBCKfzybu2BVpOEMAFA38+gIIPcs3/x5H4vbqfmIkkSL3TzZ1bvwBpJo52+ncYXO8O5aAyOZiYKnm7jw7Nd6+NpZy7Kode3QuwZiD8vFG60eRUfzM4HnBuCUyA41Cfb3ItjGXYcuKvkdHQ2sZEVCFYjKk72FmocLdVYqJXoZTEOotHpUSqsMHc0EsRcgpH9e4nKj14Htw8Khm/4dmFcvW0WPex8OdjndaaG1uNMTDYTlpxh7rCmj86WbDwwmbgJ3fEfkfZ/zBOKE9xcM5hDWb/RvVPHKr2nkkJB26nfc26JROvYP+h86yuOrlLT5enXq3ScEnR/F24fwubuBX4yX8iohHeYtuwcy6e0rXpfrP10CNtEw5Rd9PB+moOxumqVXWUZlMX6hbUcrDILBFvaztzk/jUV652qrf+RnmRmvshkVQqp4vGjyqDYLk5S1Ol0QJWP/Morr/DTTz/x448/1sV6HooBAwYwYEDF2Ygsy3z//fe89957DBsmNBuXLVuGq6srK1eu5Pnnay54XG1E7IdLf2OQJd7WPss3XR4xs1db0Bag/Ws0dnm3SZAduNpjCUMdakkoQK+FLS/B3QukdZrD4s376MBZfrBajpNrJ5B8Sint1QyQ8ZkFjP3tFNFp+XjambPy2Xa425uB4h5NzqIc45yUMchJEiSHi76La5OSp8lFOSTH3ORMiopYTRbutlbMG9WcDv4PIKhUAjcSc/hqVzgHwoVQtLmJkokd/Xi2hQWOyafhyEKIPinKm/dCbSUEHNyagVsTsVbnhqC2IDY9n51XE9gbmkRodAYGuTTDVEjQ2MO2xHsy0NUaf2crnKzUDxwPkcuQOI4cOUJKSum4i0EGpMGoArrjlHwct9gdqDOj4M6LfGzuxlJ9f5bF+fDy99fYHmTHE8H2lQgE3ph7vY7X1fnYEoPz6idYcHACLsGdK/3elsC2M7ciIuhYcBivk5+w4PotXJr1rfpxAFPzkTTKvoKz4QpPF/zOkrhOPBV5gSltXVBUpV0kywRrvbHMjGaMyUr23Q1hb5zMe7nhtPK6vzRtamrK4MH3k/RkGVQYM6JaLnsWK+3YVTTWUyxHV6y885hREsAtKgjglYXOqNmqrBtWazGqHCTPnDnDgQMH2LZtG40bN76PuLNhw4ZaW1xVEBUVRWJiIn37ln55TE1N6datGydOnHhgkCwqKqKoqLT0kJ1dy4K/mnzYNguApfp+WAd0pIHLY8hqDQbY+Dwm8WfIki34zO4TfuxavVGLClGQAQmX0PX4gGmH7LhQ0Jtol5b85HMYad0UePmiECCuihJG5EEhbt58LMmmviUB0tvBnL+fbV9eL1M29tgUStHzNLMF7/al53P0F0zWS6vAzJZCW392rvqZ4JQEVuom0KWhB/NGhWBnUb2MPitfy7y9N1hxKhqDDFaKIt4KSma47Q0sIo/D6Rv3v8g5WOilerUGz1YiUyyzi8/M17DtfAKbLsRzLro8iaOxhw3dg5xpW8+Rlj52VTaplSQJjUaDu7s7WRqQ1Bboc9OQNaVZqYmTDyo7Nwoi4su8MgL4ueR/y40/1cP3xp+aYpHxp6bYDGxmF7CrRsf50/gDX/z14GeV3agUwyDLpUGytjPJ/OJAVMFnvFjY3Ozx8SLKojiAV8tVphg6YyZZy+TDe1HlIGlnZ1eSqf03ITFR+KK5urqWu9/V1ZXo6OgHvu6LL77g449rx6i1Qhz7DjKjScCRb3Wj+LnjY/LYPPwlhG2mSFbxrOY13ho2qPrzSBVCgvw0dp2P4EJMANZmKt6ZNBylpgUkh8HG54RYe2UCZHoUHPxcuFHkJpFn7cf4E3dLAuTq5zrcL3smSaIPodfC9W3Qeor4ssiyUWbLBLq+Dse+Q7v5ZfLTk2muV/Ojfjidez/F9G7+KKoxbmEwyKwNjeWrXTewyo9lsuIcI2yu07DoKlJUWTEASWSJ9bqCX2fwbldOh7YYsixzPiaTFSfvsONKYgkDViFB+/qO9G/iRq9gV1GyrQE0Gg2urq5kZmbi0O9FzHybo02LRdbko8/NoCjxFtYtByEplBTeuYSsK0ICiithWj1U16xBpRA/AEW66ttImyhAWcvHKTOmWmUU/14GGarrG5yWp8FJMvoh1rLaVbFFlktF5KRi4QyL6ldRaoLiMStHyxpkgcXtCpO6NYSolizdfzPuTd3v0yy8B++88w6zZ88u+X92djbe3lVjqT0QaZFw/HsAPtKMx97Onm6BtauLWiGurofDXwHwnm4qTk16VE6z9GG4NyOU9WRbeBMXfg4rPPliWCdBWtA3hE4vw6EvRJm5Qa9HH7soWyj6j1mJ7tA3RO5fQlLOi7jaOLFyWvuH64ImhwlT4fpzxf8lqfTqGfwkYRZtWPjXSiIKLUgwD+Cn8S3pHFA9S6KIpBx+Wb0Zv+S9rFSE0tA0VjxQnIzZ+UCDPkJ/1q9zhUGxGBqdgc0X41l28g5X40urF8HuNgxr4cmTzT2qPGcI4vMemZLL5bgsridkE56YQ1RSFue/nUBBZiYAHp7emPv40aNPW/I0OtLzNMgyXLubhY25Cf0XHUFnkHnbYiuNb/wknEymHaD7fw5zJy2fZVPa0i2wcoxV+fZhDMuHosTARteXeGr6Z1X+nQAurfmckLCvMcgSx1t9R5cnJ1frOFxZB+unAjBV8xr7Da14b2Awz3atX7XjpN+Gn9uCQcv6Rj/y2nknzE2UbH2pU6UrRQUaPSk5hXiZGgOWnV/V1vAIFJstV0gmyr4rbm1qIChfAyRliwDualsDhn0x0akKSl3Vwf+MC4ibm3B1SExMxN29VKMxOTn5vuyyLExNTTE1rYOatizDzrdAr+GCuhW7C9vwRjufWs7mKkD8edg0A4BfdYPYJHdnX7+GNTtm6FKhLakrEuMTLsFkKBxYn1qfIcp9SA36MLiZ8cumVIFvR9Fvy68kpd0pCLq+TqGlJ59kDOJTzUu0Nk/gramDHs0WPPcHeLURotypt+DMb6KhP+BrdoWnM2v1FQq0jQhwsWLLpDbVGvrWJYZxYecSHO9sZ550t+RbI0tKJL9OEDRQBEdH/0dmzvkaHStPx7D4aBSJxguFWqXgyRAPJnTwpZmXXZXXF5OWz6GbyZy6ncaZqPRy8nYGg46E32eiyxDG1d169GTVvFd4fe0l6jlb8myX+tzNLCCnUMeoX0/Stp4DDhZqIuKTsbuxRhyk7+fkaPTcSRMiCE09K9nHyoxBu3oiagxsNHSlzeh3qvy7AYQf/Jum174BCQ75vkTP6gbI5HDkLS8jAT/rhrDf0Ir3BwUzrUsVAyTA/k/AoCXJuROvnRebrs+GNqlSKyU2Ix97crCUjO0eu1ranJc5PoC3fQWbzJwEcWtdAz3bGqAkSFZnBKcYRUZ95VqW07wXlQqSLVu2ZP/+/djbP9rcFqBz586sXr0aT0/PGi2uKqhXrx5ubm7s3buXFi1aAKLEdPjwYb766qvHto4S3NwFEXsxKNTMyhmLSqFgZOs6lp/LTYFVz4CukHPqNnxVOIbxHXzwc6pmOUJXBKvHQ/J1COwHt3YLVmbnWbx/wYPt+UPpbnGWaYY1kNQaXI2jNnY+oMkTw++VgYkZBhtv3lh9ka1xDkw3deHL4CicHB7QryjOatOjhP9h8JPwx0CIOSXKmn0+YcmpeD7dHoYsQ9dAZ34e26JqVP+cRLiyjqLzKzFNvUYbAAm0mKDz74N5s6FIAX0emi2WRYFGz7KTd1h05DbpeSKIuVibMrlTPUa38a4S21mWZS7GZrI3LIl915O4mVQqxm5OIe1UcTi4++Lo6sf3z/VBlyFIP1bNBzBt7gLcbM34ZVxLJi05Q1xGPp8NFVZShVo9r/UNwtPOnKL18zFNSBLB368T14zznu62ZpVbq64Iec0E1EUZXDbU42abj3nKoeqfw7vhp/E9/AoKSeao7ZN0n1jN1khhNvLqcUjaPI7pGzNPN5IPn2jE5E7VkJSLOQXXNiIjMS3hSQCe71a/ymbMkcm51JOM3xFr9yqrTz0KsUZlpwq9L7PjS8/7DyAxW2wMqlMtKUExQ/e/IZO8ePEily5dwsGhcheEixcvliPD1BZyc3OJiIgo+X9UVBQXL17EwcEBHx8fXn31VebOnUtAQAABAQHMnTsXCwsLxo4dW+treSj0WtjzPgCnXEZz5447/Rq54GJdu8P75WDQizJSzl3yrOsxKeV5TE1MmNmzmr6QhVmw+12RlU3bJ8YtDF/Bou7cuniE7Ze7oVRI6EatRLl9OBz+GlpNBN/OcOeICGKelVfV+W7fTXZcikWlUKFr8yxO1xdB1kv3+1qm3hJWXma2EHMScpPhxk5oNgqeXolsZst/9tzk54NhAIxv78uHTzSqnCi4Xis2N6FLkSMPIMkGTAGNrOSUFIJ5i1G07jcWkyowAnV6A2vOxfHD/pskGS8MPg4WvNDNn+GtPKskWhCdlseG8/FsuhhPdFo+9mTTSBFND1UMXazu0kiKwr4gGgkZfbKCVl/qyMsQAdS1VT/Mer+IvYUavUHGxsyEZVPaMmv1Rd5ad5mn23pjoVZibqKEzFhMrxndWXqI7C/USCQq6+f5UOz5AOnuBTJkK16T3mBNzyaPfs09yEu/i2r1WMwp4oJJS9rMWFytPjKyDJtfREq7xV3ZgVe0M5nzRBMmVSdA6nWwXYygbFX04orOm97BLrxVjWrNicg0WiiMrGf35lVfy0Og0RmITBF/+wDXCjKttNvi1qEaWXQtoDSA16DXXmAkt5lX8jNZTVS63NqrV68K2VkVoa6Ud86dO0ePHj1K/l/cS5w4cSJLly7lzTffpKCggBkzZpSICezZs+fxz0ieWwJpEciWzryTIti2I1rVbinlPhz6EqIOI5tY8obyTXKx4PkOvtVTFAHxAdQWQocXRYDUFYHKlALvrmSePQR0ZWb3ejRs2AhM5sPZ3+HP4cJyK+EidHxJlF0rgbXnYvnpQASg5OthTanXvDec/wqijoBjg9IS5p3jsOMNaPIUdH1DZI1T94B3W0AIJs/ZdJW/TscA8Ea/IGZ093/05zEjWpSUL/4lZN4QSpChhgA26juT6jOIj8d0qdKuV5Zl9oYl8eXOcG6nCoKBp505s/oEMrS5R6WdPDQ6AzuvJrDt+AX08RdoKkXxviKKpqZ3cJPKlLMLS/+pV9swY30Sl+IEg7BHj54kdn6VfI2eIDcrlAphSG1tZsKnQ5vw84EIXvgzFBcbM6zNVHBkvhifqdetZKNz9o44V2u/SlyQwncIcQJglnY6T/Rqi30V54JlbSFJi0ZQX04lGg88n12FWXXbIid+hOtb0MhKZmheZfqg9tULkADnfoekK+RKVnyYP4L6TpbMG928Ws4wR2+l8JbipviPT7vqrecBuJWcg1YvY2Omup/0ZTCIPj48VpP3sigOktWSBixGvlHNqo7JR5UKklFRUVU+sJdX7ZcWu3fv/tBALUkSH330ER999FGtn7vSKMgUpBXgRsOXiD6uxNFSTfegqklzVQm39sGRrwG42vITdhy2xUKt5LmqkhHKwt4P2kwtDXRG/7nzN6NI1NvR0M2GF3sY5z39e4rgGHdWlEDsfIU2aCVwMjKNd412Wi/28GdUSw8xFtHoSUFAajhIfBm0haKc6x4i9F9BfMHLfMkP3Ujmr9MxSJLoDz3T7iFMYlmGqMOih3ljR4nEldbMib+1XVmS34l4hQdv9mvIJ53rVekiGJGcy8dbr3H0lihzOliqmdmjAc+096lc5liUQ0bEaa6ePoA29ixtDREMkdKhojjj4G+ctWwC7s3RODbE1b8pmZlaJGD5U2YMntad5kf0qFUKfB0sStxTANxtzZncqR4anYHGHjaYFGYIlSIQCjWIzUdxJvlIB43su7BZ9MQX6QZx2bwdP1fVJUOWufn7NIIKr5ElW5I1bAW+Lg/mFTwUUUcw7P0IBfCJbgID+g+uXg8SIDcZ+cBnSMBczWg0ant+Hd+q6oo9iCBxJy2PVqbGTNK7doPk9QRBagl2t7l/k5gdL2YMFSbiu/qYkVukI83YcqgOR6AExZyH/4Yg6ev7+N/I/7M48aPIwpwb8kt2RyCZIc09a8fdoSLkJMFGMQMqt57K+7eDgUwmdPDDsbruFcU9v+IAadyYHLyRTEpaLpH48s2IENQmZT4+plbg36OCgz0YcRn5zPgrFK1eZnAzd17rE0QJNbXVJFj2JCzpJzK9Tq9A74/gqQX3LLWUvdwr2JWXewUQ6GpVSiS6F7oiuLwaTs4v5wYv1+/OEZsnmH7WhXy9kvpOlmwc04ImlSWpIPqOP+y/xe/HbqPVy6iVCqZ1qcf07v4PnmuUZciMFn2umJNoos+gSg3HHgNdip8jgQEFescATLxaitKce4gIjGX6MaVjHmKk4PWB/oxrlkL+lb+AlgS6WmFyT5DWG2QauFjx6dAm4s988j+gzRfHr98dECLtOYU6rE1VNHR7SFXGYBCksYIMwqX6fKMbzVv9/KusqBK19WuCEoXG8ZnW/6FPSOsqvb4EmbEUrpyAGQbW67vg1nMGz3erQea0802komwuG+qx2tCDhc+0qLbp8tbLdwmU4nCRMsUG1KNF9ddVAYplERt7VPD5TTHO8DrU+0fMlu8YKysOlupqbTBKUCzh+N8QJP9FJZGbDKfERbyo23vsXS3KAU82ryOatcEg7KfyU8G1CacDX+fSsQuYqhTV9rgD7mdoShKFWj0fbr7Gz4oYLOp3pKmX8ct37g9wb1al/iMIksj0P8+jzk/iJafbvDjyfZHdaArg0Fw4vwKs3aDJCDEDaStIYFq9gQsxmSgkcLczx9POvFygnN3nAWpGBZkQ+gecWlhKKDKxhOZjKGoxhXeP6Vh/Sui4DmjixjcjQ6p0cT91O423118uYYD2aujCnCca4et4D1lFlsX4QNQRuHMUok+UMg0pTRbjZCfumAXjENiBwBZdUXm2QPEAFp8sy+QVFOHt6U6mccyjZ8+efP3eUNjzPpFKkTl1DXBm++UEnK1N8XW0wNXGrIRt/em2MKZ39sbrzG/ioB1fLvkcFKsJdQ5weniZ+OxiuH0QncKMGQUzsLO2ZFz7qm2wMy/vwuf8lwBscXuJoYOfrtLrS6AtIP2PUThoM7hq8CO2w+e82qsGSlfhO+DaRnSygne003hvUBP6NKpedmswyKw6E8sQxVlxh3/P2tVS5hHl8cRL4tataa2es7K4lSyy3IeK5lcGOaI1glU1qwyVxL9BsjZxdJ7YhXu2Yq++FQXai3g7mBPiVflspEo4+xtE7geVGQz/nQXbxEV+ZGuvyvUi89LEQK6dzyOf+suhSPLTE6hnlkSD3oPEB3TlSEHwmbi1ykv/aMs1HBMOsdxsIXZ5eUgJ/Y19GRmQhDly8/KEq7wiHeN+P01ekY6sAi31nCz5ZkTIw0s2BRli43JqQSkbztpDaG+2mkiSxpTnlp/jUlwWCgne6t+Q57rWr3RfPadQy5c7w0v6oG42Znw69J4LaF6qUBKK2C9uc+6WO4ZOUnFZX4+zhkDOGwJR+7VlbK92dKrv8NB1FGr1bL10lyVHItj3+QR0ZQLk/v37YfU4APbn+QHQyteeacvPEWC8OJmqlLhYm+LtYMHKMzE0kW/RM1eDq42HsL8y4tANESR7BD1kxjf1Fuz9AICflOO5LXvwftf6VdJE1afeRrVxKkoM7Fb3ZsDUD6vHb5Bl4pc/i2dWGGmyNfubzeOVAc2qfpxiFGSi3TILE2CxfhAt23Vncie/ah/uWEQqMen5DDALFXc0rF1P2exCLTeSRCBq7VtRkBTtDdxq8J7UAMVs7IAaB8nHM8byb5CsLWTFi6Y+QM8P2H5SZCuDm3nUDZEp5SbsnSP+3fczwnQeHL4ZiUKC57pUoqR0abUo07acAH0+fihDLDotj4WHIvGU8jHY1cM67hgs/xwa9IRRVRcpW3smCu8L3/Cleou4wy2kdJRCbQl9P73vNYVaPcMXnMDf2Yp3BjbkSlwWP+y/RUx6fkmQLCcckZ8ujJVP/1oaHJ0birJtkxGgUhN2N5upy46TkFWIvYUJ88e2fLTTRRmciUpn1uqLxGeKoe2x7Xx4e0BDbNQK4bJxazfc2gsJlyinD6NUo/dozUm5Mb9Gu3FWW59CTOkR5MyrvQMJ8bZ76HmzCrSsOHmHpSfukJydL+Yg08UGqU3XXuzfv09krLEiUzlRWB8bMxWN3G1o5mWHk6WaroHOJGYXkpGn4drdLEyUChZfzOMX7Uf4GcxZYZRIS8kp4lKcKN8+sK9uMMDmF0FXSKJTB36M64aTlfrhPeF7UZRL5pLhOMq5XJIb4D95EWbVtFCK3PwF/rFb0ckK1tf/nJeH96zRdzBv8+tY5icSZXDlrN/z/PpEoxod789T0XhLSTQiSugNBw2s9rEqQmh0BrIMvo4WuFRENku4LG7/qUzSGCQDq1mqBsTnO6d4fObfTPL/Bo5/L8YlfDtR6N2FQ0v3ATCoaR3scgz6kosSDXpDm2ksXS8++AOauj+aMXZ1g1hvoyFC29S7LTQbfb92pMEACgVfbg9DozfQ11uHTUqYCM4DvxF9wyridtRtvLePY6TqmrijzbPCY/IRM2L7rydjZariqxHNsDJV4WVvwZpzsaTmFnEyMg0POzN8HS0xFOahOPsrHPseioxyXy6Noftb0PAJMJrPHr6Zwot/nSe3SEcDFyt+n9j6/tLoA6DVG/hh3y1+ORSBQQZvB3O+GRJAe8Ml2DlfuI8UM++K4doE/Hsg1+/J1gxvPtsTTXKOGAlp42fPm/0bPpIUk56n4fdjt1l+IpqcIh0Gg46k319Ely5m3qyaD+DLX42KWKk3ITcRraTmkuzPgIYuuNuZ88GgYObtvYmztSkTO/oBsPBwJHfTc3ijYBnxKmes25cO/W+/LLLeEC/bii+4IDaHsaeR1VbMzJ2CjIJnu9R/sGfmvZBl0ldOxTH/NkmyHbF9f2Owe/X6TDeOrifgwtcgwUaXF5k6fkKNAlpu6BqswteilyV+tJ7Nd+PaV5qZXBHCE7PZE5bEG6qD4o563YRBeC3iyE2h4NO+XgXHzUstZbbW8thJZRF2V3wvgx7W334U8tNK/VX/2zLJSZMmMWXKFLp27VoX6/m/iZwkCDUyAru9yZFbqRRo9XjamdO4Bv6ED8TpXyHujLC5eeIH0vO1bLooLmZTHlUGKhYGDxogLKZ2viWCnlNgyShFCRQKTkamcSQsGqXCgnEd/ZFuPgEDvhYO7VVEUcx5rJePpL6USoFkjumw+Sia3m95VhHyNTpuJuWQlluElamKfWFJHLqZQlJ2ERq9gbiMfP7slEbra58hZyeIdppLY+El2XBwSXAEWBcax1vrL6M3yLSv78Cv41tXWmg5Oi2Pl/++wKW4LMwp5L0G0TxteR7Vuv2i1F4MUxvRawroK6T5rN24Gp/FnM1XOR8jaP++jha8NzCYPo1cH3ohz8jTsPBwJMtPRpd4BDZwNOP03KfRZJYKBbR+5s1S2cPIAwCEykEUoWZYS8E2b+3nwKu9A3lv4xUSswqZ0rkeablFNDFJoL/mLDQcjNy5NMMo/lwNaf4AYZCseOHRCZxv8BLnzlviZKVmfIfKZ5EFB77BIXoXGlnJKr/PeaVTy0q/tixuXTmD574XUUgyh6wGMeS5j2ukcFWQGl1iTrBCNZy3nptUM6IJ8N3em6jRMsH0COgRDPJahCzL7L8uyuM9gysoj8ecFLfODWs9OFcGablF3DVqytbo2php1OOuAxGGe1HlIJmTk0Pfvn3x9vZm8uTJTJw48bEq6/xX4sSPYlfj1RbqdWP3WpHV9W388ItftZB+W0higShL2nqx6lAEGp2Bpp62jx72liQI7C8u4AADvhLzh/s/gaELyklj6XVarq/7hK9MrnOq1X/wbtEUWvSp3rqvbkCx4QWc5SLu4IH1xNWY+z26J1JcQq3vbElDdxsm/XGWboHOLDt5h/cGBjOilRdFkcf4dtN5Pjhsx9/qbOzsfaDH+9B0ZLngCLD46G0+234dgKHNPfhqRLNKD/TvuprAu2tDaak9zwKzk/RRXkAVV8bb0dYHggeL8plP+5LMPK9Ix7xtYfxxPAqDDBZqJTN7NmBq53ol595wPo4dVxKp52RB38ZuhHjZoVYpkGWZtLwifjt6G4MMTTxteL6zLxN6hpBr7EHat+iPTd8XmdalXmlQMAbJA9omuFib0slYRtbpDbSt58Avz7Rk2vJzOFiqOX8njU65p8VwaOspJZ/ZqNQ8LsYKktTgkAo2RbIMO14HTQ4Grza8GtkK0PBCN/9Ku83LEfsxPSp0d38ye4EXxlaPqBMTG4P5+nFYSQWEqZvSfubvqKvqEVkGOp2OO4snECznchV/Ok/7Brea6IwCl+My2X0tiaHK01jrM4VJeGD1jMgfhMiUXGLS81ErFXSuqHUQbQySlZxhrm1ciRdZZH1nyyo72ZRDpuAAVIZPUVNUOUiuX7+etLQ0/vzzT5YuXcqHH35I7969mTp1KkOGDLnPOut/HvnpguEJ0PUN9DLsDxesq36N3Wr3XLIMW18FXYFwl2g1Cb1B5s+TYlc1qaNf5YJyMUtSpxHOGWP+hp9awZlF0O3NkrGCzZeTyM3JpKUqg9famFXN9qrsmg99CYe/xAQ4pA9BGrmEbn4NKvXy4t+nla8DM7r7czMpB43OQN9GrkxrJMPmSXBjO410/bgo9UXZew50mHzf7lKWZb7fd4sf9ou5tGmd6/HuwOBKzT/qdHpWbliPdHk1B5QnsVMb3Qf0iHnSJsOFNJ57yH3vz7Fbqby94XKJ2PTgZu68P6hRyQW3SKfn/Y1XOXgjheGtPDkblc7esCQGNnXnzf4NkSSJBi7WvNY3iGB3azrVs8PNza2ExdqkYx9yuszE1caU4cZsEW0B3DkGwFFDM55q4VkSPFVKBQaDTICrNUsmteGjLdc4H5vFZJNIcKoH9UvHeDZeEGXczgHOFatFXd8iZkwVJmzzfYfYiEJcrE0rz2jNjEGzegqmyKw29KDfhLewrIYBb1J6Ful/jKY5SSQoXPF+YR1mZtVnixoMMnt+fZuBhRfJk02Rh/9GA/eaGQTIsszn268DMrOt9wvxh1aTa30EY/c1ce1p7+9Y8Xt556i49flnguRlY3+70vq/D0KGMZP8bwySAI6Ojrzyyiu88sorXLhwgSVLljB+/HisrKwYN24cM2bMICCgmnJo/9cQulQwRF2bQEAfLsZkkpmvxcZMVTGzrCa4ul4MwKvM4IkfQJI4ejOZu1mF2JqbMKhZFUugKrXob9p5i+NtniHmtRoNQXf7KMd2X2CLbhjq7m/Q3LMaf89iY+ZLfwPwm24g0S3f4rNmDw+QmfkaVp+NJSo1jxY+drTwsSfQ1ZruQS50D3Jh5clIkuKiKJr/BKaGfJCU6H0642QIQteyHbLShLKhSpZlvtwZzq9HhBRXpZV4clPIP7OcrBO/M0EXXypsbu2O1HgYNB0OHi0r3DgUaPR8viOMP0+JHa+nnTmfPdXkPoZoZHIeZ+6kM39sC9rVF+Wv+QcjWHEymhBvO/o1dsNgkHmxR4NydlcgxMrze71JTk4R07v5lzJJIw+CNp+7sgPh+DC/TXm1p+KNgb+zFa/1CaRLympaFdyC1rNKMm+9QWbtOeFyMqIiTdKiHFGqB3QdXmaucZrhxR4NKsdo1RZStHIcptpMLhvqkdnt8yrNpBYjM6+Iywsm0scQRi4WqMevwdqh+ptTWZZZvnIZ45MXgwRRbebQtFnVxpsqwvrz8ZyOSqePyWV8Cm8I15tq9PQfBlmWSzY2g5pW8B7kJEKikbRTv1utnruyOFdVecMHIc0oT/oYZPVqtI1JSEhgz5497NmzB6VSycCBA7l27RqNGjXi66+/ZtasWbW1zv9O6DQi+wLoMBMkicNGunyXQOcaNfjvQ7GWKkCX10o+HGuMF7KnWnhWiW5fgmLT3+ZjxHjCvo8gfBvKqxtQa6diZ9WECV2r4SJSlAtrJ0LEPvQoeU87maPWg9g96OEanik5RYxYeAIfBwv0Bpnjkal0buDMOwMbYqVWoYg5gfOxBWiyO7BW2YEgL2ciGkxl3pF05o0KuE/+TJZlvtgZziJjgJwzuBFTHjZDWqzEc+4P5PDtWBi0WAD5sinpvv3w6jYZqV63cmbJ9+JKXBavrL7A7RSRcY5r78PbA4KxMlWRmltEgUZfwsjNLNCQma/Fs4yG5cjWXkSl5PD55ov0y4pAEXMSffQpxi6PJzNTkBV69uzJiA8W8dWucLzszRlblkkavg2A3fo29Al2o77zg6n2zblB88LfxZxei3El9x++mVzC+u3XuAL24OGvBQXfvh5/m44iMTsSd1sznm5bOflF/c43MU2+RIZsxULXj/ipR6NKva4sCjR6dvzyGmO1B9GhIH/I77jUa17l45TFwq1HGXnrA5SSTLTPUzQZ9GKNjgeipzx3h8giP7fbBjmI2V+r2lXhuhyXRURyLqYqBQMrIgze2iNuPVoK/ePHDL1B5nxllZsehbRiWb26T8aqHCS1Wi1btmzhjz/+YM+ePTRr1oxZs2bxzDPPlGikrlq1iunTp//vB8lrG8SFwspNlNyAQ0ZmWfdK+u1VGgfnCl1RB38x6I1ogu8NE+WVUa1roA1rZLHS9XX4uQ2ybGCmycdsL2zAB90bVLq/VIK8VPhrJNw9j15pxrSClzhoaMGfw5s9dEA/u1DLcyvO0dbPgbnDmmKiVLDraiJvrrvEhJZOBF/+As4vow+wR12fJerJ5KSZ41BQyNcjmtG/SfndsyzLfLXrRkmA/GxokweXAoty4coaOL0IUkTPUgIuGvzZqe7P8AkzCfR5uCiEwSCz4HAk3+29ic4g42pjyrcjQ+gS4ExmvoZXVwnCz3Nd6zO0uSfmaiXZBVrcbMyITkzHK+MMxJzCJfoEo+5kcqBgOmt27GGE8hDTtxWxPkyDBPTq2Z11W3fR5WvRd5zdJxB1sauxXochfAcKYJe+LW88QppQ794S5chl5KTdJaPADA9TAyqlgr/PiM3XsJZe9/dsU2+ViGZo+nzBjxvF+MmLPRpUrr97aRXK88swyBJvSa/w4TP9qkyw0ekNLPvtO17IWyGW1OVz3FrUbJRi4YHrtDn3Gk6KbNKtg/Adv6Dq7YUK8MXO66TnaZjgeAOXnGsii+z0ao2Pey82nBd/h36N3Sru993cLW4D+9X6uSuD6wnZ5BYJ5aYaMVuhNJN8DNqzVQ6S7u7uGAwGxowZw5kzZ2jevPl9z+nXrx92dna1sLz/YshyyYWCds+BSk1GnqakMV1ZU9pKITlcaIyCGL0wEf2hLZfuotXLNPW0pVFNmGIKhRh0/3M4BPZjVb25bN8cjquNKc+0q2LNPzsBlj8JqTeRzR14VXqbg3lePN3G+5Fmxycj03C0VPNc1/olMn79m7ixYPcFolbOIlizE52sQNV6It/0nsXVdAWSBDZmJhUKCvx8IIKFh8WO89MHBciseDi9AEKXl4yM6JTmrNZ04k9dLyx8mvPr+FY4PULiLz1Pw6urL5bQ7wc2dWPuU02xsxDzmLPXXMTVxoxvRjTD39kKpayD6NN0STjKnNR6hK5cSivFFswkIUruL1vT3SSMnaYDmff7fk7f0ZRosY778Rs+2X+L7EIdQa7W5Zmn0cdQFGaQLluh82pLq0eU/CWlCTQeypnrSbz76wle6OZPz4Yu7L8uNl9jKsoMd70DBi0E9OX35EBScsLxtDOv3EYt5Qb6ra+iBL7XDWfQyGfuF+B+BGRZ5tc/VzIt+UuQILHRVNx6zajSMe7F70dvY3vgHVqrblKkssJh8qpaUcHZfz2JNefiUKHjHRPRdqDts7WeReZrdCWl1gotuzR5JWQuAvrW6rkri1NGu7VWfvY189UtyIA8UbHDsXLchpqgykHyu+++Y+TIkZiZPZjpZW9vXy1R9P9TiD8v3C6UptByEgCno9KRZaEk8cCZsupg7wcg6yFokBgnMKKYnj+sZTXZxcUZJAiyzuDv0LWYyMJ5hwF4rqt/1Uq4WfGw7Akxh2XjxaqgH9h6tAhHSzXvDAh+5MsdLdU097bDv7g8WJSLYc8HFKUGkKzUg7MfqiG/gF8nAJo85Nf+43gU/9krRi0+GNyI8fcGyKQwOPGTyB4NOnGfQ32OOzzFC1eDycGCJ0I8+GZEs0e+B6HRGcxceZ6ErELMTBR8MqQJI1t5FUvecvBGMm62Ziwd5gkRW0g6dhz72F3oCnOxlAw8xRhWarvT0z6GJg38wLsdjr6dsDyhZfXqzdyNESXW5U+ZMa61I5EKX5afFE3A9wYFl7vgFFxYhzmwS9+Gmb0bPrLvWtyfdLUxY2hzT0K87UqYtN0Cne83Eb65GyL2gsKEzG6f8MtvYkdfLpt9EDR56FdPQKkr4Ki+CfHNZjD7QaMlD8HiTXsZc/stTCUtSR69cBvxTZWPURZ/HI8ibtc8PjQ5iIyE6ag/aqXXlZRdyOtrhQTcLw3OYR53CyycoPPsGh/7Xqw/H092oQ4/Rwu6VMRqvbFTjCjZ+9W6TmxlUSz4XyHrtipINmou23iBWR2M2N2DKgfJ8ePH18U6/u/h7GJx23hoybxR8U6pff1anD+KPCh6CQoV9Pmk5O6o1DwuxWaiVEgPFvN+GFIjYM0EGPIzeLYUM5Lebdlx6a7wKrQwqTiLeBAyY2HZYMi4A3Y+JDy1jk8Wi43SuwODsbV4NOu5tZ8DrXztkSQJOf4CrJuKIiMSB+ldzOu1h/FLQW3J0VspWJuZ0PwByjSbL8bz8VbhJzm7T2B5HduEy3D4q5K+HQC+nZE7vsSXEd78evQOAM93rc9b/Rs+lP0qyzJLT9zh8+3X0Rlk6jtZ8su4ljR0E19cCRk5/gI7TkTyotkuUuft5hXtTHLlpphLAbRVRzO7cT5v1WvPlt2u/NngP8zqE4SrjRkajYbfV8xBpzQDg543jGLlckAfPtgeic4g0zvYla5lKxZ6LYYwoWJ0y6kPYypZzZBlmSaetjR0syYjX8vac6Js98K9YuA6jcgiAdpP54cLBnKKdDRyt+GpFpUIdjveRJkaTrJsx1cWr/H3kKrLoq08eJ4+F2bioMglzbYJrpP+fGh/+FFYfvIOh7ev5HeTP8UdfT6BwJpnWnqDzKzVF8nI19LZTUef5CXigd4fgbldjY9fFrIss/S4+K5N7OhX8Wf2ylpx23RkrZSQq4oinZ7TUeL6+KiK0iORLL7buFa9j10d/Ku4Ux3kpwumKQjFGCNORooPQQf/WgqSBkOJHiZtpoFTaWlh80UjPb+BU9U9I3UaWDcZkq/BgU9h/EZAfNl+OSgyg8md6lW+F5kZC0sHiQFfez+YuJWPtiZToNXTtp5DlTJdCeDUAqQ9HyDrtWDrialpCMrmTUBtyYpT0Xy+PYy/plVsLXQ8IrVk9z6pox8v9TS+ZwmXBNmkJDhKEPwEdHoVvUdL3t1whdXn7gDw7sCGPNf14b2OIp2e9zZeZV2oCCiDmrnz5bCmWJtIEHUUwrchX98OWbHYa9/hWL41++Sx1LPS0y9IyQFNGxaFNUVp789T9bx4rnsS60LjmP5nKM919mPizNcxadKP3P2L6NmzB1/3y4T0FM5bdOJEaBpqlYI5g8tfJJIv78VFn0WqbEPfQSNKskiDQSY+swBbCxPMVEpMlFK5DFOSJGLT83l34xUaudtQpDMQ4m1H+/r3kCtOLxBVAksX4prO5M+fQ43vVyVGaS6uhIt/opclXtG+yHsTulV5Tm7PpSgCDz6PnyKJbDMPHJ/dCOrqWy0tP3mHlVt2slb9E0pJRm4xHqnjS9U+XlksOBTBicg0LNRKFrisQ7qZK0wAmj9TK8cviyO3UolMycPKVFUxEzk/XbRTQEgy/gMIjc6gUGvAycqUoJrI0UFpkHR5dHWqNvBvkKwOrqwV4gGuTcFL2Phk5ZeKCretV0PmVjHCNgkxYlMb6PZWuYd2XBHivkOq4zBy+EtBBTd3gCHzS+4+dTud8MQczE2UTKisYkpuCiwfIgKkQ32YuJVTaebsvpaEUiHx2dAmlRdUKMiAjdPh5k4ApODByE/8SNof1zHIMmvOxfLRlmvMH9uCVr73v8e3knJ44c9S6605gxshpUWKjUDYJuOzJEGy6vYmOAehN8i8tuYimy7eRSHBl8ObPbK3lpZbxAt/hnL2TgZKhcR7/QOY7BmPtOc1uL4VCtKLz0ShiQ3eVmaE6npgYm7Noknt8bAzpwuQt+4SP+6PYM25OJysTXmqhScHricxbd4aVI16k3n0Tzp4mbN/5U+woAOy0pTZ50V2OKO7/33yg7f3L8EFuGjVld4BpYzUG8b3pZEDODk6E+BqhY+DcAGxszDB2syEK/FZnIlKL/GNvG9EJjcFDhvLmr0/4ouD8Wj1Ml0CnB6dGaTcRN42Gwn4QTec4A6Dq7yRPBWZgn7987RW3KRAYYX1lI01YmgWi0p0V6RhpjAg+3ZGGjSvVrKsA+FJJaX+39omYn1ug9BoHfjNfeIWNYUsy/ywT5xrVGvvijcel1eLHrJbU3CpBlO9FnDohujVdwlwqrnASuJVcevSuIarqhz+DZLVwQVjaabl+JIv1YVYcXHxc7R4JMmjUjDoS8yb6TCzVAAcUWq9mZSLSiHRq2EVxX1jz8Cx78S/n/gebEqD7LITdwDR47SzqISTfGEW/DlMZBe2PjBxGwZrD+auOA7A2LY+FYoY6w3y/Y37pDBYNRYyooS/Xr+50GYakiThYKlm+ck7XE/IYcEzLelbgUhDam4Rk5eeJadQRxs/e/4zwAXF9leF5ZasByRRaur6BjgHlqyjOECqFBI/PN3ikbOmt5JymLLsLLHp+TRXx9PXOYMnT76LVFCmB2/uAEEDkIMGYdagJ22vprFpw1Wa2JviYSSpZOZr2HU1EROVRJ9GLsRlFJKYmc/OtweTrZMw5KTRs2dP9u3bB0dEcAozb0V0qooGLlZM714+0z15PZqQnCMgQUDfZ8s9di46A/Ps2wwzPcum7E7856IT2UV6TBRKnC1V+LlYk54nZntTcjU087Kl7702UIe+AE0OuDcn1L4f2y+fRpJEFvlQ6IqQ109B0hVwTN+Y/c7jWd8/6OGvuQfXE7K5ueIVJihOo8UE9TN/I9XgYj//wC2+2SMCS6OuI1A16Y/k2EDMDdcQNxJzePnvi8gyPNfSmk5hgolOx5eqbCdXGRy6mcL5mExMVQpe6FZBH1WWS8VOankus7KQZbmEhV9de7ESGPSls57uITVcWeXwb5CsKhIuiz+SUi0uukacj8kEamFIthhX1gqRanN7YetUBruvCfX7Dv6Oler1lUCTJ5w/ZAM0e7qcHVJ8ZgF7wsRxJ3Twe/SxtAXw9xjxXlg6w4RNYOvJ1ovxXI7LwspUxSu9759hiknLZ8uleJ5q6VXKary2SZj1avPA1gd59Aokj+biNHoDBllcfJZNblth1lKk0/PCilDiMgoIcFCxrMERTH/5oVRLNXAA9PoAXEt3nnqDzOtrL5UEyJ/HtqB/k4cHyJORaXywYhcDNUfIV1mwStOdS/EeBJvY0sPKQZRvmwwD385CScWoUDSwqTu7ryZxKiqNS7GZhHjb8em26wS6WpOYXcjoNj4cDk/ko4WrkFoOx8nBC0+TfPb/JXwVuS6syJZmNEGS4Kvh5aX0tHoDR7csoYNURJqpN77Nyg+K5xRqWWT+C14+HejTfwiY2ZBXpONmfApXkzWE3c3iZEQ0kiSynNl9Asvv9lNuCNEMwNDnMz7ZLkx7R7f2Jtj9EcSJfR8hJV4hTbbmbXkmf4xpVSUyWHxmATt+m8NrbAdAHvoLSv/q6UbLmbF8d7aAH/ffAmRm9Q7i5V4Nak06MiWniClLz5JbpKOtnz1v6+cLr1eXxtDjvVo5R1nIssw8Y7Cf2NGvYrJgzElINYoXlLlePU5EpuQRlZqHWqko30OvDtIixPfaxBKcHo9gzb9BsqowqscQNLBcdnchRmSSLWpDZUevE1JuIOap7mFw7TEGyYoyqodi38dC+9XGU2i2lsHfp2MwyNChvuOjZ5gMelg/DaKPi1LwuPXg6I9GZ+Cb3eICOr27/30ZdWx6PsMXniA1t4jUXA0vdquPc+h/SjIl6nVDHr4Eyao0EJooFTzRzJ1ZvQNo8YANyMdbwzgXnc5ws3N8qVyHyTEx44dXW0HE8O1QfvkGmXc2XGbjhXiUComfxjwiQGoLubD3L3SnlrJHusJZVRALdU/wo9ki/lCNYonNWzSb1A1Hm/IuIpIkYTDImKqUTO7kR0puEa+tvcTsPgEkZhWQXaAlxNsOV0slH3y3GFPvxujys3E301Hk150PN19lTicLFAmXMUgK9ulbMrGj331jHctPRtMpdy8owbLNuPtKhn2K9mEr5RPf6TO8zWwwXFiJ5e0DtMhPo4V3exj2FjuvJpKZr6Wlj93940t755Swqzdl1uNS7CUs1Epm932EifGtvcKuDHhD+zxTBnYgoAr9qKx8Lb8v+p739UtBgoJuczBvPqrSry8L+dCXFBydT0zBOKAzb/VryPQetTc+kFukY+qys8RnFuDnaMEfzcJQ7NkGChN4amGdiHDvuJLIlfgsLNRKnn/QPGwxwbDJMDCrI1/bR6B4893e37FKRuYV4u5FcevWtEaErarg3yBZFRj0wmYKIKRUiFmW5RJNwhaP8AKsFMI2ibKjuYOYqSqDjDwNF2MzAejVsAo9mdgzpepAQ34ux7DT6Q2sDRWBpVK6m3vnCAKM0qj7aix7rAuNIy6jAGdrU6Z0Kq9qU6DRs/BwJJ0bONHR35G31l/GELGfl7J+xVlClJR7f4xk1LJcfvIOGXlaXukdwMiH9AjXhcZx/MwZ/lQvoTNXhZqJtYcIjk1HVNhj+mLnddaci0MhwU9jWjDgQXZmaZFwbglF51bQQpsFxnaSv7cnEzwC6dHrFRpkQt/vj3AiKovBzSzKZSUGg1xCaGlX35F5o0J4a/1l5h+MJCJZlMsHN3MluP8ELLpMImnlOzi6e3Fx6y7m7b3JgfAktNa7MJPghL4RVg6uvNGvfKkyPrOANXsOs1t5DRkJs9bljaoBGkgJ6IN7Y+NkC/s/RRF5AKxckZ2D4exvFF7agFXBC2Tiwuv9gspnVpEH4eYuUKjI6fw+ny8VQgsv9mhQsZ5rMXISkTe+gAT8oetHvl9vJhmtuSqDQq2ebxcv4/28/6CQZHKbTcSqe/VGJ3RFBdw5s4tcrTODlKfo0q03w3s0KD8CVQMUavU8u+wcl+OycLBU89cAEyw3GlnAvT4A99o3Ny7Q6I0qPjCtS30cK2rxpEfBNUHKo+1ztb6GymLrJcGf6F8bWtZxZ8StZ/WcYqqDf4NkVRBzEnITxY7Mv3ReMS6jgKwCLWqlomZGoiBKdMe+F/9uP12YEJfBsYhUDDIEulqV9LceCb0Wtr4CyBAyttQBxIjDRsspB0v1o3sG55fDyZ/Fv59aCH6dAdDoDMw3MmOnd/O/z0tQqZBo6mmLuVrJkCALnE5uY0r8QBSqYcwc1BanDqWsv6wCLeejM7iRlMvTbb1xfcDMaVhsKrGbPmGPegOmklZo2nZ6FTq9fN/7VoxfD0fy21HRP/x6RMj98l0Gg5gDPLMIIoQnqCkQLzsS7voE3Ue/ipNjPYplwANcoU+wK4uP3qaNn0M5p4jiAJmep8HBUo2voyXLp7Qjq0DLxdgMtl66yzfrj6Oz9aTw9nka13Pj+H5RVmzubcuB60ncObudhsBmQ2fmjWpeTrRalmU+2HSVJw37RQD373Wf4LMsy0iWDqhSrosNQ/g20e9t0AtJlpGbjyFuybMMUZzgVtBzdPQvU8426GHP++LfbabxVaietDwNDVyseLbLQ+YIDQbY+AJSfirXDL7MV01k6+jmlRKTB1EKn7t8C7PTPsRU0pLj1wfrod9Vi1RTpNPzypowxuTouS0HMNA1A1fNVtB1MWoX1yxQanQGZq68wMnbaViqlax4uh6eW4cIb9mGg0vUsWobCw5FEJ9ZgIetGdPvHdUpxokfRWvFv9dj69/di1tJOVxPyEalkBjQpBaCZKwxSN5r61eH+DdIVgXFYx/BT5Rr8hdnkUFu1o8eqH4UIvZD0hVRc28z7b6HixVdqqToc+InQZs2d4C+n9338KqzIosc3tLz4eu/cxy2GXfz3d8tkeIDWBsaS3xmAS7WpoytQKVHrVIwtIUnZnl3YUl/eqSFs8g8mucKXoQUP17KLcLRylRkXxJ8+ERjcot0DwyQuVGnMV8+lVlKsXa5fg+kQf95qEzVutA4vtgpBpHfHdiwPF1eWyBYgCfni14wICNxSN+M5fq+NOryFK/3L+9Ir9MLCbePnmxMp68OcDgslhHtGqBUSMiyTE6Rjh/33SIxu5Cfx7bkekI2NuYmeErpdM/czHdfzCH+Rj5q53p4jvqAVT/PLunXbbxwF0dVIQ0LzlMom+DVYeR9epfbryRwKDyRL0yFs4PUakK5x6/GZ/HOhit81b4pjZJ+hb0fiv5xsUmtJHEw04XofB9ClFGM6t+gvNPLxb8g6SqY2XE9cAZ/LRaswk+HNHn45+Tsb3D7IAWympe1M/nsmZa421ZuQyfLMt+sP8q06DewV+SS49Qc67HLq1VayyvSMX3FWc5G3GWqWkP9wa/jajgj+v1X1wu9Ym1+qStOFaHVG3h19QX2XU/CVKVg8fgQGh+bCtlxQglm6C91MpMYnZbHQqPU4geDG1Vsbp2TBBf+Ev/uUvviBZXFlktC8KRboPN9uspVRlGu+DyCaKU8JvwbJCsLgx6Mg9o0HlbuoWtGp+0mnrWg/lCcpbWaVK7nCeICUqxaUekGeFZ8ac+v39z7jFbTcos4EC4knka3eXBZk6w4IT5g0JaOUBih0xtYcEjIv03v/mCVHrPsO7DsSQxZ8UjWHvQZ9zULUp2Y/lcoSoXE813rs/TEHW4k5vDz2JYVf6l0RXD4K8yPfkc9DGRgg8mgr7Fq/fRDL0jHbqXy9nrBinuua/3SOcj8dJE1nlkk3M4BTG045/gEs6NaEyO78nrfQGb2vJ8koFIq0Bfm4HFlEadtlpKy15zcjMHY9pqFRmmBjZkJMqIcd/j0WeYdiOYls51YZ2zlje2Z7LyiRQK6NfHCLsiX347exs5CTaFWz4mIVN5RrwbgjGl7ZvQvX15KzS3iw83X6Ka4hKuUITZAZbwJdXoD7264zJX4bH6LcOG7kKeFLFnSNVERcW1EoVbPJ1vD6C070c0+C1+XMr1OTZ7QCwYMXd/g7V1xyDI8EeLx8PGN5HDkvXOQgLm6sbRp3f6RhKiy+G3/FQZdeQkfRQp5lj5YT15frVnItFxBorkcl4G52pIGns7Ye6vAeoToy4cuhUNzoeETYuNYxWyySKdn5soL7A1LQq1U8Ou4FnS4Mkf06dXW8PTKOukBGgwyb667jEZnoEuA0316xSU49l2px61vp1pfR2VgMMhsMs5zP1mdUbV7EX9OZMY2XmD7+DyM/w2SlUXMKcFUM7MVXo5lcNM4H1mstFJtpNyA2wfFTFW75+97ODotn8TsQtRKReVV9Pd/LHbLPh3K9VGLsfNqInqD0H+9T4KsGDoNrJkofn+3pvDkz+UC0s6ricRlFOBgqWZM2wdovabcFJJ1uYkonAJgwiYM1p70d5NY8EwrXv77AodvphCZksu6FzpUvDtOuAwbX4DkayiBrfoO+Iz/hZDAh0uIRSTnMP3PUHQGmSHNPXi7f0NhG3TyZ0GP1+SKJ9r5QLsXWJDVka8OiR3wo4QFpIt/wbWN2Hadzg+7ovgwdAGRd6P4Tj+SKQM68Lr1XswjfqfzplkMUJyhZ+FaXtheyOLLEiZ2bszrWsTMTbvYdS2JFafucCk2i2B3a/oE2tEnbDtI0KDvC+UyN1mWeWfDFdLyNDxvdRh0QMiYctWNpSfucDk+G2szFe8MagomAaLsnhwuDLZTbrAtvwXtM8/xislGVD0XlP/FTv0ixPvtfFih78Ol2AisTVW897CRD50GecM0JF0hh/XNOG4/lG1PVF4VZf3ZOwQcnklT5R0KTOyxnLIJLCupzqIrgqP/ASDFpjHP7Ze5lG6Cvbmapc8EY789TjDFrV3BzA7unhcbi+ZjRYCsQtk1X6Pj+RWhHL2VilqlYOG4lnSP+VlUIhQqGLkUnKs25lJZLDkexemodCzUSj4d8oAZ5IxoOPe7+HePd/4RhR0QCmSx6QVYm6ro26gWSq1RRi9Mv8cb9P8NkpVFsVJL4IASx/li3EwSF9ka9yOLiTVBA8H+fgLNSaPsXXMfu8rR6OPOiS8uEvT/osIvy7bLIhgMfth84N45YhdnZgej/yy3s5dlmd+OitLPhA6+Fa8r6ZoQHMhLAZdGMGEzWLmgML6+fxM32vs7ciE6gy0vdqap1z07cFmG0wthzwdg0JIuW/OudirBPcfxxCMCZEaehqnLzpFTJOYnvx7gjmLPu3D2d7HTBiEK0WU2BD/JwmPRfHWotCT7XFd/sUkI2yRK4d5toMV4wVYsykVx4ifkkKcx7TSDtNuhTA+3YXbsOsb4utDSZyCEJbIm1Q8HKY+3GqbS5j0DUQETcXumCY5ODpxyN2dAah79m7jRJcAJjc5AWEIWa//4DluTfPLM3fFoWd69fl1oHHvDkvBWptNOf07c2XpyyeNxsdFE7/2Fz1S3CQloiAtNwdwD+n4Kgf3hzCKKok7wVPIivJVBJDScTGDI0NIT5KbAsR8ASG//Dl/tED3ctwY0LNdzvQ8HP0dKvEK6bMU7hhdYNKZlpVWbDoUnodkymx7KS2gVpphPXFd5h4e4c2IcySmAPI2OooSlvG2w513bD1k0rRP+jhZC9ENbCKvHi79jYH+xUYrcD25NKh0gM/I0TFl2lgsxmViolSye0JqOyatE/w/EBjKgd+XWXUXcTMrhayN7/L1Bwfg5Vdx35+Bc0ROt1+0+/sHjxGqjjd+TzT0q3vRWFUYjcfy61PxYVcC/QbIykOXSIBk8uNxD+RodMeliHi/QtXq9DUAM5l80jpdUkEVCqexdpbRhZblUZ7P52ApFjZOyCzkdJdRhHjhEH75dyJGBIOrY+5V7+HRUOpfjsjBVKe4XEQehjrFssFDTcWsG4zeVK/kaZPhq53WO3kph68zO9xvv5qeLGUqjCs9Z0w68kDUBP18/fu7x8IuoTm/gxZXniU7Lp5GdlmW+uzD9ebGYxwTwbgddXoeAPiBJrDgVzZfGnuWbBHryNQABAABJREFU/YNEgIw+CTvfEOXH+t3Byg1DQTb7YvT0sY5GMrcn074Jzy08QWh0Bq92HkiQsgDVje3AV9ByEirdLSxibXF++QOUnZ5Hbe3Ik8rjDLfM5Dfz9xn84zH+nNaOVr725BYW8MqqS/yoOAiAZbtJ5fpxMWn5Jbq0/2lwGSnaIC4axpkxWZbJ+nM8g9DgYA4B2UlwM6A0iPp1QvbtyHu/beFIUQ4h/h4sGt2Dcjj8JWhykD1a8MZ1f/I1qbTxs2fsg6oEAHeOIx//AQl4R/ssk/t3qLSJ8qXYTC6snMMs5X4MSChHLilRsqoUrqyF+t04GfIFz604T1PtRT4zW8lOl59ROw8UGXTEPriyDrzawPOHRdVg55tCbMK3M3g9etA/Nj2fyUvPEpGci625CUsmtaFV6hbYY5yB7PWh6HPWAQq1el5ddRGNzkD3IOcH/y0Srxo3xgid2H8Imfkadl4Vox8PbeNUFpo8iBcyiMVkwceFf4NkZZASDpkxwvHjnp1ZsbGug6W6Yhp2ZXFlnbh4Owc/cKdULBnWrjKydzd2CLq0iQX0/KDCp+wNS0KWoYWPHV72FfR9cpJgi1HLssNMCBpw31OWn7wDCHue+37/tEhY8ZQIkJ6tYNyGCsWdG7hYVRwgY8/A2kmQHQ9KNScazGbspaZYqlV8N6r5I02tv959g9DIBF5S7+FVw1aUp0VZHI8W4j3x71mSXW+7fJc5mwUpYGaPBszo3kCs+9h3oq8zeB4gmJdvrrvM+vNxfNLFggl5yWDQ066eIz+PbSmIRjfT4MyvyOlRSC5BKD0sOL5tN7mSBQ6WdgzV7mah90VoMoKuQzvx/IpQ1pyNpamnLTNWXsAq7w4dTcOQkZCal450aHQGXvr7PLlFOjr4WtEmbbN4oIySSuiqT3EuSGCa4VNWPv8E0vkvRBn/6nrRi7PzY4O2A+tuq1ArHXlnaNv7hQOMCi2HfV5i/6FU1EoFXwxr+mB2alEOhk3TUSCzWtedfP8B5UXlH4Ko1Dw2LPmajxWrADD0+xLVPRvRh0JXBDd2Eu46iAl/nEWrl9H7dsalbzfUa0bCoa+g+1tiJCgvVYxCFBN1Wk0SrZNKBMjzMRk8t/wcqbka3GzMWD61LYHRq2DH6+IJHWZC57rxz5VlmXc3XiEsIRsHSzVfD29WcZnVYIDtrwEyNBr6WMck7sWac7FodAaC3W1oWsnN0kMRfULwIWx97tuo1zX+DZKVQbE4sF/n+0YLotNEFunnWHVyQTlUIHVXFsk5hcRnFiBJEPKoWUyDAQ58Lv7d7nmwqThLLPYMrHDsQ5ZFgMxPE33IXh/ev6bsQvZcE8e4L4vMvgsrhgrfN9emDwyQSoVUsVbq+eXiC6/XgGMDEvsuYOqf6YCedwcF36dbei92XI4n8dif7DddhZeUChrAtQl0fwcaDir3Hh+PSGXWaiElNq69D6/1MZJ0ksKEotDY1ZB4Ff2tvay5lsveO4EoFVbYegbCdQn77Bu83ntISRletvMmzdSL81v+pPvYt5jcpznqvq/j0Os5bN18mOYkgR50LSZgqlLS0seeCzEZfLjlKqHRGcwxE1ZlUoPe5UY6vt4VzqW4LGzNTZjfIg5pV5Iw/DYqJ92JT8A9fDmf68bw3KB21HOyBDtfUX6L2AtOQRhO/EJ8YV8kBvNq7wDqO99T/dgjbNkK/fvz0ikrQMesPoEP7lcbX6PIjCZOdmKh2VTWVnLcIyWniB9++41vDAtBAk37l1F3eOGRryuBLCMr1USaBHAj7CJafWcGNnVj3qjmouzf7S3Rk285Qfzc23f0aFEp26j1oXG8s/EKGp2BRu42/D6pNe5hS2D3u+IJ7V8U5J866v0tPxnNhvPxKCT4eUyLB9vwXVgBsacEM77f53WylspAb5BZdiIagEkdfWtH0cg4jkWDno+9x1q7arv/qyj5A93fa7iTJjJJP8cH9Acqg6QwQSRQqKDZ6AqfctEoexfoYv1o1YprG4TDh6ntA+e08jU6jhvLt72DKwiSoUvh1m4hGPDUogp1LVefjUVnkGnla19eniw/XWSQmTFC9Hx8+QAZGp3O7ZTciteu14rguOUlESCDn0R+9iBvHJMp0OppV8+BMW0ebgQdf/0UHuuH8qP6ZxEgrT1g6EJ4/qjw47yyVvRZ0yK5npDN8yuEKPqgpu58/GQTpOILaU6C8P87+TPyuqmEnd5Li7ur+Vs9l1U9C4TZsX9PuH1IPBcxFvDx3rvcyrXg6s1InFw9yEhPJzt0C/Yu7mjNHdlU2BzZrh6qeqJioNEZSMgq5O8zsZhKWsYZRzrK9hn3X09i8THRG/x2ZAgOV416nK2ngNIEvUFm/rpd7NW3wNyzKRM7+Bk3S59Bhxnw7EHkYYs4ZNKZboYzhHja8FzXexRnoo7Ard3IChUfFz5NTqGOEC9bnu3ykKwwYh+EirW8qX2eL8Z2qpR2cV6Rjg8Xr+eTwq8wkfQUNhyGut8nj3xdWehleH/TVXYkWOEupfFZSBo/j2lZ2hdv9KTY4BWrzlSRwarTG/hsWxivrb2ERmegTyNX1j7fHveLP5UGyM6zRUCqowv36dtpfLpNlNffHRhMxwd5Mealis80QI93wbYCN5DHhL1hScRnFmBvYVLeELwmKL4Gl5lPf1z4N5N8FDT5ItWHCoNktDFI+tYkSF40zjMF9n8gm+9SXCbAAz0US1BWGL3jS/eNkRTjeEQaGp0BL3tzAlzuySYyY2F3mT5LBb5tBoNcMl85rn2ZoKUtgL9GihK1tYfoQZZxayguV95Jy2fhuFbls9j8dEGsiDY26Hu8D11eY8vlhBIm4UPLfgUZ6Pd9ilvoH3hKBgokc9TdZqPsOFOQjWJOiaCRGQ2ZsWQ6tWTKLmtyi3S0q+fAvNEhQni9eFawIAP0GuQzv7HCYiJz4hrSWBnDEt99uEb+BL1HiJLduilwaw+FzSfz4l/nuXEjhrfVt5i75SY5maLn28Hbgg9eHsqiVRvYXNCJK4Wd6X8kitiMfDacj0OrNwDwQ7M41DcyxHsX0A8QvbDXjPZfkzv50cc2DuLOCskzYyBdcCiCLQl2XDcdyK9P9xfv0Z3jovrR6VVQmrDpQhy70vyZorrFtwPdy5erZRn2fQRApPdI/r6hRq1U8M3IkAeXtfPT0W18ERWwRNef1j2GVqpfXqTT8/ayPbyb+QE2Uj6F7m0xG76gSoEmX6Pj1b/Ps+d6Cm5SbybYXqKtVShkdy/Nvu18RItEW1D6O1byHCk5Rby6+gLHI8RG8qWeDZjVsz6KXW+VMke7vytGoeooQN5JzWPGX+fRGWSeDPF4cAlblmHHG1CYKao27aqQjdcBlhi9Lce09amaafuDkBEtNFsl5X2TBY8D/wbJRyHujGBBWntUKKh7N7MQAC/7Sqrf3AuDoYzU3YOb/mF3swFoci/z815c3yo+UGZ20P7BX5ajt4QoQY8gl/LlkOIvnDZPjI20n1Hh609FpRGfWYCNmYoBxXNwsgybXxRMWHN74VN5D0t319VEIlPysDU3Ke9XmBkDfw4Xg/xqaxi2CBoOJK9IVyK/9XLPBveXB4vPe2Ud7HoLpXHWcbfUkZbTfsHZs8yFxaAXxI2hCzD8OYwjezaQljUMf2c7Fo1vXSoaXnwxdW+OnJfCXdmJOYkNUSrgpTFP4WrVTJCR8tLApx0ED0Y++CUrj0VxJ9mX51R7ORWn42yk+Jv16NmT/fv3Q/J1GhnmssOkA+fcX2HFyTu09LVHIUnoDTCwqRv9Cn4Sa2g5AZQqCrV6pv8VSma+lmZetrw9oCFsNhK7mgwHKxdCo9P5bt8t9KiZ9GQfPB2NWb1fZ/E3VCiJS89jzqZrjJUS8bFV4e5/j+7qtQ0QH4rBxJIpUd0BeKV3wEMZ27ptr6HKSyTS4M4BzxdY2rPBA59b8icwyHyw6iTT497GS5FKoY0fZuNWgckDSojaAki9JcTpjQSmpOxCpi47y9X4bExVMGd0b+wMJsJM28JJiIkXZ40qU7AyzhRXMpgdvZXCrNWXSM0twtxEyTcjmzE40BL+HiVmTYvZ4vcYD9QmErMKeWbxadLyNDT2sOGrB/UhAS6vEX8/SQlP/iDE9f8hnLuTzpmodEyUEuMra7f3KNzcJW6929W6YXVl8G+QfBTuCNsn/DpX+CW7myV2qe52D6HGPwwxJyDnriiNBvR54NPCEwXpJPhh4uOyDMcFdZ+2z4Lpg597zChKcJ+rRvg2wSRVmMDg7x9Yotp8QYyODGzqXrpbPPKtIIgoVGJU5B47I1mWWXBYSNdN7OhX6n2XeBX+GiFKljae8My6kux1/sEIkrKL8HGwYFpFUmg5ibBtliAqAbcMnszRTWLyMxNw9rxnNsurNXi2RFaZsUduT6O8ffiaD2TxpDbl3VSKf2f3ZtxWB6HOiMBM0vLN6LZieDstT/R90m+DpSM5nd7hwJUUQjJ287Q6hojUIl49kEdSnkzP4gAJGM4txUXKYlJjFZOe7khKTiGjfz1FvkZPiJct87oqkX4/Kd6/1pORZZn3N13larwgbCwY1wrT/ORSPc72L5CVr+Xlvy+iN86ADi9rcC3LICnQG2Rmr72MiyaamWb/j72zjo7q/L7+547EXUmIEIIFD8Hdrbi0uBRaaKlB3b1QoaVKW9xdi1uLuwUnCXF3n4zd949nZpIQIfRb+/XtXitrYObOnZk7d+55zjn77P0LdgN/Ln9c9CVC/B7YYDWCuHxH2tZxY2ZVcmcAN7ajurkVvazgffXzzB/f4YFEKoBP996g/503aayMRWvjjs2U7RUELiyIPAQbJgmixqMrwaMet5LzeHz5eZJzNbjZW7FoUpjJW3QMZMeIRWL0UbHgjDst/Fh7vfPA9wWiVP7lwbv8eDQKWYaG3o58Pz6Ueqp0WDJcVEfUdjBiUQWW+x+JrEItE5acJTGnmCAPe5ZPbVv1CEV2jImsg+i3/wl2XA8DszTlyFZ+NVZZeiBMv20aDfxj9veQ+C9IPgix5iBZcYBVlmWSTZnk7z4hrm0StyGDq3QKyCnSkpwrXqdBdUEy5oTobapsoG3lYyQgRLHvZRSikCivnqLJgz0mJZ1Oz1dp0KrRGdhz3Wz6bLoo39wJv5ok7x6ZXylN+0RkBtcT87BVK5lqFruOPi58JEvyBLN3wmZLPyUmo5DFJp3Vtwc1Ll+6kWXhyLLvNdDkIivULJJG8rlmIKPaBlXukGI6vicjMvgiqSkHrFaxoI9TxVK50QiSxI8nE4jMaM6bqmusaJtAO/Ms4dV14FEPHL3JLdIxadUNrmaNJFjdjbs/zSYhTWSQZQMkOg1cNVHzw6aYND8vcS+jkNoutiya3BqbIyamZMgQcKzFmjOxbL6YYCFs1HaxhSPzwaiHgA7IPi15ZfVFEnOKCXS3q2hwbfr3omNRKGOP85bVPhTBPVCGPFL+855fDDmxFFp58EFmDxytVaWl58pQlIVmxxxsgIWGIcycNLpK+cCyWHoiGs/TH9FTdQWDwhqriZvArYoSYuwpURoPHS8ypXM/cS5oFtPW3yG/RE+wpz3LprQlwM1WVAgUSujyohjTOfY53NkrjtMTRyqdOb4f8VlFPL/+ssXybny7AHHOxR2FTVNFKdPRB8auB5ON25+BfI2OyUvPEZlWgI+zDaumtcXTsYoer0EPW2cIn0//9n+r/BwIGcRf76SjkKh+gfUw0OSWzkc2/C9I/vOgLxG9HxCzVPchr1hPsc4AgE91Q9ZVwaAvlbprNrLKze6YssjaLrY4VeY8bsbp78Vty/GlJabKNjMRdpr7uZTf37HPRVbrGgRdX6ry+UfvppOv0ePjbCPGUdLvCCUcEP2QKsxdfzbpTY5p6y8k5yIPiwCp10BARxi7VpRpTfh03220BiG/1TukjONJURb88pzFZxGflnxh+xzf37QhyMOetwdVr/LSuZ47T49+BO2+eTTRXgNDn/ICEQoFWy8lMG/vbazpwPh6WtrdmgeGy+LCm3oDOs8mz8aHiYvPEp6Qi7O1xLWjh8lVeYOUS88e3UsDJMDtXShKssl1CGZTchDnz1zmbHQ2DtYqlkxpjZeisHTB1PYJzkVn8f4vNwB4tX8jQdjQFsGFpZbjvORENPtvpKJWCruvylzpw+Oz+fLALXpQiEfDjtiPfK38BkVZcPQzAD4sGkExNnw5tEnlI0Em5G6djbM2kztGPxTdXikvil4Ftl1O4N7er/lILeZdlSN/qj7rUVkLDkDn2cJCbcME1p6yplDfjrZBHiya2Lo0+5eUoiyrtoWA9jBuoyCAVVXCLQNZlll3Lp6Pd9+kUGvA0UbFpyObM7Cxp5gXPfY5IEPt1jBmDTj+AcoxVSC7UMuU5ee5lijcRFZNa1ft98CRDwSb1dpJtCf+IuuoqvD14QhASBdWKXTwsLh7QPzmPBrUXFziD8Z/QbI6pFwXDEs790q/oIxCodjiaK36fQ3qhHNQnCX6h9WoSERnCHJQ8P0Em7LIji2t3VfRRzSj0nnLrGihagPCa1JddWZsNn0e0NQHhb5YaLrqCsVn6Fs59fxeegHHIzKQJISNVuRhoZJiKBEqRqOXlXvNy3HZ7L2egkISWaQlQ7p3VATk/CRRluz+Or95juP7FZeRJMH8fKDKi9HAiFZ+ED9QlPTaPiEITrIMskz4qb2c2HcS6MTkro0I7TcY4kfD1bWiX9plDoVuTZi2+CReSUcZZi2z7lQitu1Go27YFd/sq2xd/mX51zQxLI/7TeeLgxFodEZUCokfxrcScobH54vFgk8LYu2bM+OHU4Jx29yHJ81egVfXipEclwDO2XRk7l6htvPmwBCa+7mUfz1ZJq9EzzPrrqA1SCiaDqHpqJCKOqjHPgdNDlFSABv1XXmkuQ/DQ6tmJBaH78A5cjsGWWJtrVd4p9eDZefyNDqO7FjFAtVy8dZ6vo3UZHj1T/IJBfd6GFV2zIsOpqGhEy8q1uPVsAVzJrQVvzdz7/juAdEmGPi5CK4KZY0CRlJOMa9uCbfoIbep48qXj7bEX5Ehes5xp8WGrSbBgM9rFHR/LxKyi5i09Bz30gtxsVOz8vG21Kvu9x6+qbS1MvjrGmXLfyYuxWVz8GYqCgmerUTn+Hfj5nZxGzLkj9vnQ+JfNQLy3nvvIUlSub9atf6HlV+iSfKrdlil/cisQi0Abg6/U93eXGuv37eC1F1ZRJsYtEHVzQZeWALIULeHKAVWA4tBdFkT48PviwVB3R7i/VQBncHIoZtiNrJ/01qi3Jl+Gxy8YdSyKkkDq86IualejbzwzzpdGiAbDhT9pjIBUpZlPt0nlG9GtPIT5BGjUbAvVw4VAdK9Hkw/REG7F3hjuyD2TO0YVMGQ2IL0O6X/lkynfYuxkHxFiLcD6Eu4m1ZA0sFveVaxmZHNXITOq0Ipyu1Dv4cB89Aondj/7Sy+S5vEz+ovyDy0CKVfU7L2fYe7Lo2M4P58tPsmkWn5GI1yqai4QkWacyganWCyzn+0hRCqN+iETB5Q1OpJpq28SHaRjma1nfliVAuxQDAa4JQQv88PncGL684RKt9iVHM3Jlfi0ygDb2y9RljOft50+IV5wxsj3R8gs6KRzy0C4L2Scfi62jN3RLMqCSJyYSbaHc8DsEY1nOcnj626JFsGTrl3WaD6BqUkI4dOROry4gOfg0KBRunAc2vP8/Oxe7yoexoXG4nXHfdio80R25jfZ8YdsdgxB7UHQJZlNp6Pp99XxzgekYG1SsFbj4Sw4ckO+CfugYWdxb6sHGHEYhjy7Z8aIG+n5DFy4SnupRfi62zD5pkPUCtKuCgIciDaIk1HVL3tXwBZlvnUpFQ1Ksyv+uD+MNDkCeNugActqv5E/OsyySZNmnDo0CHL/5XK/6EEkWAOkpVLZGUWmILk77WAuWPK/B7QkI4xZZJVljB0GiGvBRVMmu9HvkbHHZMge6tAF3FnwkUTGUR64FD0mXuZ5Gn0eDhYEVZ4FC6tEM8b8XOVJd7CEj2bL4hA9FxQIqx7sjRAjl5RYQbz6N10ztzLwkqlYHYfEwtToRClQWRRzu33CVjZ89mO6yTlavB3s+WlfvcxNkEEwMMfQvh6oRlbt3spMadOZzEHevo7KMlHq9PxTNIU3HU9aVrrET55tG3puIlBDxH7MZxfilXUYUYgY0Rm2s4SNiRa4Wh7g951rdi29A2O3k1nzoYrXIzN5pX+DekStQx74JjrCD44KkZC3h7UuLSfe+sXyEtEtvdk1tVAItPyqOVkw+LJrUsJG7d3QXY0sq0rT91ozDslH9LNOhx8XkHKrQ3O/uW+tw3n4zkSHs1b6ruMsI3ExpAD3FcdOPIRklHHMUMzTtOCTWNDqy3nR66cRX1DNhFybVpMnFez874oC9aNRakvgqBuSINq5guZXahlxqqLnIvJwkZp5NPRrXB0WwVL+0NgRwibKqof+cmixN+gf6Xs8/sRl1nE2zuuc9RkOdfS34X5j7Yg2F4L22eUSrr5tREEnap6pn8QTkZmMHP1RfI1ehp4O7Di8bbV8xty4kWLwlyBqUTk46/G0bvpnI0Wv9fne1fyG/y9uLtPfE73+oLd/DfhXxckVSrV/5Y9lkXSJXFbRe8kp8gUJO1+R5DMiobMCFEyfMCAbHyWYNAGVpVJ3tkjyrZOfuJiUQ2uJ+Yhy2JkxeIs/6upRNpirBB7rgaHbwlbrWH1VCh3m2S4uswRwacK7LmWTH6Jnt4uKTQ78U7VAdKgR86MYNe+M4AXE9sHCrKKGQM/FwQnEws4PCHHkqHOG9G8XJk1PTOTmF9XEHftOC3k2wRKStQJF8T7NBrExfDyGqEJGX0co18b5uZ0426ORB33NvwwrRPWarWwGru4XKiZ5CdjXnIdNzRl5rLr3EzUIhHNe257eXbyaEB45519oxfPrrvMrDWXeFylZYTkz8xEMfc4o1vd0pk3Wbb0kg/ZPcKvkYLYtHhy61IyTBkj7iMOQ9DGXyLEKp6Sxo/iePJLuLtbMBsDO4GNE9cTc3ln5w202FDU7T1sGhsqqi4lXoLrmzHKEp/qx/Jiv4blKwv34dZvmwhJ3YtBlojo8BkD61QUoEjL14BMqSKMXivmXnNiBUN19PJqKyZmRKTmM23FBeKyinC0VvHTpDA6BrmBorYw1P7tU8iIFN9Lm2kQ1OWBAbJEb2DRsXt8eySSEr0RK5WCF/s0YHrnIJQ3t8LeV4XLjaSAri9D11f+1FEKo1Fm4dEo5h+4g1EWpd7Fk+5jWd+Pwgwh0lGQIowCRi762/uQOoORj3eLSk6F3+v/CnOPvsmwv83JBP6FQTIiIgJfX1+sra1p164dn3zyCXXrVu0UUVJSQklJieX/eXl5pgcKhPYogE/zSp9bUKIHwNHmdxzGaCE9Ru3WYFO9xVZK3gMYtObVb4vHHvijuZUsPl9js0JOwgXhhCAphcblA3AiMgOQeSL321LR8u6vV/ucrZcS8ZPS+dr4MZK2QAwEj15ePkDmJsCGiRRqSvgs6ya9rNrStsmn5XeksrYESKNR5p0dN5BlGNrSl05mJRJZpij8F57cFE+xwYZ78mT81AV8ODCYTu07IMsykmwUixT3ujDwM/Buwrvbr7MqKRYHaxWLJ7XCNeWEKIHe2SM87IBClQurNF3YaOjK+R/foCBHHMtlw2yZ3DgXWo5HlmUMRhmVUsHCCWFsX/czb1/tzCq6o0FYib3WvwxrOP4sJF5AL1nxenw7wWQdF1q+3BZ9FJIuoVfY8HJ8BwYpz6IObIvjyG9BNw82TxPZRatJ5Defxqz1qWj1Rt6tfZHJvgbwva+fI8sY9r+FEthm7IRH/TbM6Fr1byQ5NQ3X3wTh57j7owzo90iFbT7ff5vjERmk5mlo4uvMMz2CaXX1XSEMYeUoWKFVCFuUxZl7mTyx8gL5Gj1hLoXMnTpAlNtlWWzQ8Tk4+Y2Qcew/t5wqUVU4HZXJW9uvEWXSWe4Y7M6Hw5oSbJULG8aW9vI9G4nS6p/sep9bpGPOxiscNvm4jmzlx8fDm1bPayjKEjKPmRFiMTx+U7UjXn8VVp+JJSKtAFc7Nc/9kb3IgrRSOdAqVMj+KvyrgmS7du1YuXIlDRo0IDU1lY8++oiOHTty48YN3N0rn8WaO3cu77//fsUH0m8DstDGLKMYUxb5GhEkHX5PkLxnCpLVZGAgxi3Mvc9KGbSFGaWSTTU4mcxBspE5SB41BaIWYx8oHJyUU0xkWgHDlKfwTj4sZimHLaw2O0jILuLWvRi2WM3DXpsp9FMfW11+3CX9DqwaAQ0H8HFcayK0iSyz/w7He79AUGilSilbLiVwJT4HB2sVb5g9DrNjYe8rzLjekloU85rHCQIHzuHpiyG8fSKfnaF67K2U4v32fNOyr/Xn4lh1JhZbqYRNYRHU2/imuBiZUacLh+wG8vQlXzRGiexF0ynIEQzhJ3sHM7lFOrdtW9GodiskQKWUMBhllEYtA2I/w1pdh6d0L9CtgScf3z+mcUqIB2zSdSIDZz4a2pRe98sEmggaq7XdyMKJht3H4F2nQGQ6SmcxNnPrF+Rds9Fe2U1bzXBCnX2Zkv0Nksm4uSzkO3tQxp1EI6tZZTuRpdVorZboDVxe9gIDySBZUYv20+dX6FnO3nCFK/E5vNyvIQpJ4rP9t1m04zALs1Yio0AatRS8qvGhNGF3eDKzN1xBazDwift+xpZsRNJsAzqK7z/2lMik/NsKU+MHeE1mFpTw8Z5bbL0kjH89HKx5e1AIQ5p5I11YKnw1tfniPO76kmDSVjGG9UfhSnwOz667RHxWMVYqBR8MacJjbfyr1zctzhYBMuUa2HvCpO1/q+ycGRkFJXx58C4AL/ZtWH0W/LC4vgVkg0gialBG/zPxrwqSAwaUulQ0a9aMDh06EBwczIoVK5gzp/IZotdff73cY3l5efj7+wuyBVSZRUKZIGn9kCeHLJdmknW7VbtpqimLtFErcLat5HVubBMUaZ+WNTJ6NYsSNPZxhKTLEHFAZJE1mLE6EZmBEwW8b7VKMEO6vvzA8uwvl2JYZDWfYEWyaQW8ubxje0k+nFkI9ftwrclLrDt+AaUiBH3H2XBtibCyuo9pW1iit/jqPduzHt4OVnD6BzjyIXs1TUiTXfmwk4rAfrtBbcsrnoVMWXaOrAItDveVrK8n5vLDjqO8ptrPZJtj2F7KFQ9YOQrbo9bT2JHkyPPrr2A06sla/ASFOYINWadNT77qeA0AVbfyx0+pkLi9fynuxSW8qZtGoKstSya3KR+MMiKRb+9GAhYbBvJcz3pMuF8oPvkqRB1Bj4LFhoGMCvNjXO8y56RBJ4J+yGC+TmyI229v8LFqCWotSA36Ca3asjDoyPvlTZyB5cYBvD2+b7W9xeXr1jFDs1t8pqHfYGNXPntZfy6OhOwivh/Xisa+YuHlU3SbR7eqiLTypV7/WdCgaiIYlHqSzt17G4VsYKXXerrmidck5oToQYKY/+3zQZVWcmboDUbWnYtj/sG75BTpkCSY0C6Ql/o1xDn9IiwZL859EA4vQ76tcib4j4JGZ+C7I5EsPBqFwSjj72bLwvFhD7YTK8wQSlTJVwXLfvIvf3vQMGPuntvka/Q08XWq2mz99+LKWnFbiVH8X41/VZC8H/b29jRr1oyIiIgqt7G2tsbaupLVY4ZYIeFVNcXdPCNp+7DjH5mRgsqvsqmSFGR5GwWiFOzpaF35avPmDnHbbPQDX1aWZaJMwuL1vBzhhKnp33RkjWaQzkdnMVu1BWc5T5SmamANFHj2fdoo7qJVOWI1YUvF3phCLVaMdbuz9GwKIDG4uQ+uXsXi+KhtK2SRS05Ek55fQqC7HVNDZFg+EOJOY5AlUlxb08SjMW69O4BaLCr8XG1RKRVcS8y1uIfkFGlJirlF3Nb3Oaz6DbVkAD3CNaP9UxA6AawdOR+TxcubzmI06slYPIPibEH4cG/Vn+f6+GAnXUDj0ZR67corsBy+mUzgmW+RkWjlkMXClx6roEiTsncetZA5ZAilTev2pSSlMtAc+QwbYJehPd4BDfh4+H2ZqCmLP3AtngWHIoCptGkUREj8Bhj+U4X9xR/8Af/CaDJlR6x7vGhSq6kcG07dpXfER6CApLqj8G3Rr8I2WUVaQgNcCfYykcpyE3A9/Ape0lPYNOoDHWZVuX8QWr5v77jO2rNxWKNlu9cSQvKOi95g/0+h3ZOlG9du9UD7pzP3Mnlv5w3LYrBRLUfmjWxOS8d82PWkkG8DsQjq/S60nvbQwucPiwsxWby6JdxS7h3U3IePhzV7cOaVHQurR4jrhZ07TNpZo4z8r8Cxu+lsuZSAJMEHQ5vWiOVcYyRdEe47Sitxbfqb8a8OkiUlJdy6dYsuXX6Hk3WmkFeqLjvT6kWvylr9kD+y+LPi1je0UneNssgu1AFVkIMKM0sVgUIGP/Bl0wtKKNIaUEjgr84t1YytoQZlVvQVJipNlOwBnz7wvWecWMZA7T6MskTJsEVYlV2t56eCo7eg1vf5gDSdLbvWHUGBkamdgkCTKSTAJKnU4shoILNIz09Ho5Aw8n3wOax+Hgv6YrByQNn3Q/rUHYN3Yq6Fpak3GFEpFdRxtyM8IYdHmvtgSLnJtEXnGVWylbGq30ACfUBnVB1nQYN+lr5ufFYRM1ZdRKPTkr5kJppsMfriEtofzz7TmaoW4xA23eeUC+R7ryWzff0iflInUqyw57vnx6K+L0CG37hOSORWkOBy4ON8PLzi6EVx4nVsI4TZ9w6HsSyaVEZftgzupuYze9MNQOb5MBtCbi0TAeC+XndmZgb2Z74A4IDn40zp0aLK7+5SXDZZez8iWJlMgZUnvqPnl3vcYJRRKiSmdgxCbzRirVIia4uRNkzERpOKUWGNoee7yEBVl0+NzsDz6y+z/0YqzlIB+70XUivnshAlH7X0oaTf0vI1fLL7FtuvCLlEZ1s1L/ZtwLiW7qjOfCtK1nqNeDetJgo/0SraKH8UUvM0fLrvtqXc6+lozYdDm9C/qc8DngnEnRV95qIMwVyeuO0fk0EWluh5fauooEzuUKfqsavfi0srxG3I4Br1sf9s/KuC5EsvvcTgwYMJCAggLS2Njz76iLy8PCZPnvzwOzMHSY+qKc1ak3ODVQ00K8sh/py49WvzwE2zTAxal8qCpJlUUqt5jYaJzd6Xvi62WF9ZKUxM/drWyJw1p7CEx/N/QqU0oq3/CFYP6KWScg2XI4IItNV5IqOaljFsXjNalJzHrhd9NRsX1pyIQG8wEBrgJvwyL6cKqTp9iegTxZyExAv8mNEFK202yx0X0zTcNKIT1A3NgK+x8QrCD/BzE9miLMsoTIGnia8z8anpsO0p3rpgS4qhOWNtfuOQMQz/IW/SsHX5smRBiZ7pKy6QkV9E6pKn0WYJAQWn0P44932G592O4lKUL/q4IUMtz9txJZE5G6+yQSXUgKzbT0fhWP6HHp6Qw5WNn9BcMnDLujnPTRlfYSVuMMpcXfsO7YHDtOPdaSMrLYtmF2qZvuIChVoDHep68Ex3D3B5WjjAlIHeYOTosrcZQR7xki+Dpr5WZR8sPb+Ez1ZuY5VCBGj74V9ZhKXT80vwdLRGqRB9VzGiosRoMKLY+xIkXSLXOoQ82RWFlS2SJCHLMnuvp9CpnoelZZBbrOOJlRc4F52FnzKHve5f4ZgTITSMx66rVAayMugMRtaciWX+gbvkl+iRJOE+8VKfBrjF7IaFbwnTbhDs3/5zwafqxcEfAY3OwJIT0Xz/ayRFWlFterS1H28ObFyzvl34RjEHadCK9zp2PTj5/qnv+WHw2b7bJOYU4+dqy8v9HtzieShoC4VQAkCr33Hd/hPwrwqSCQkJjB07loyMDDw9PWnfvj1nzpwhMPB3qFEUpIK1JIbWq4DOlEmqVQ8ZJM1Sd/7tHripeczEtbIfl1mMoAZZJJQGybpuNhYPwOqcQsoi4ew2OilvoEWN1cBPqt9YWwibpqAylvCroQWaDmX6dcseEbNtE7dZKPZ6o8zac3HIKEQWCaAtECUmlTVcXQ/bZpLT81Nunv+VvdbfUkuXLcqxfT9ibkZn8k4UMPe+mWohKAEUpOMZ+wvh9zTsUkaxyTCLD9Qr6Fcyj1ED+tG7dXlmp9Eo8+LGK9xKziZlySx0WSI7cWjZH9e+z9C9ngtP5pmOfcdnLZ9j1ZlY3tlxndbcprXiLrLSCkWH8upH1xNzeWbxYfYiyFZ1h71VITuUZZkFG/bwQsERkMBn8NuVzshq9UY+XLaN+Cw7/N3s+X58K9T2VtDrvQrb/rDzGNPzt4AEqr7v4Whf+TiRVm9k1urzvKT9EbXCgL5+f1Sm8+vHo1Ecj0jnhd4NaFPHrVxgV1xZKRinkoKSXh/hclSBv5sdeRodj/54Gg8Ha4stWlJOMVOWneNuagGNrLPY7vgZNnlxgiQ3YcsD+9xmnIrK4N0dN4hIEy2EFn7OfDisKc31N2DdwFIxEJcA6POhMKf+E0cJNDoDa8/G8ePRKNLyRZskNMCFdwc3ebDFHYh554PvwDlTmbzRIDF/bFXxu/+7cCoyg5Wmsau5I5ph/yBv24fF9S2CTOVap1oVsr8S/6oguX79+j92h7Zu1VqzyAha+kOV43XFpeovNcjgCkrESrQCg9agEya5UK1CTlmYSUDdlOFiEWDnAY1qEGCNRmpdEuW231xH0fcBLFj2vQ6ZkSTLbszWPc3exrWE7uhPXYRI9IxjYO0gaN5GPSfitKTnl+Bmb0W/hqbSjdEgsvjTP8CBt2DEz1w8fY6VysUoJVk8NmoZZ4t8+HnbGVY9XsmCQ6dBf/pHVCfnU7fIj3eMb/CbsQUtHXN5I38a3Rt6Mr0SQ+Effotk77VEkpc8gz5LZCEOLQfg3m8Wo8P8mFvvBood8YJpaBr7+OpQBN+YtCvneu6FfJBaji+n9XkjKZfxi88yTb8Te1UJBu/mWDeq+N19vv8O9W7+gFIpk1arO43DKl4sZFnmg00neS/9eWZae6IcsaU007yvx7b9ciLeF7/CTlVCtltLfNo/WuVX994vNwhK2E5b9R2MKjtUj4jy7Pe/RvLj0Shc7azYeD4eZ1t1qY1WcjjseUWQkHu/Q55HS7wc73I7JY/pKy5Qx92e1dPF9xOdUciExcLhoq1jOmus5qIuSBEXxUk7HsiwBkjOLebj3bfYFS5E9l3t1LzYtyFj65agPDRTuNiAKNd3el78VSOz+L+isETPunNx/Hj0noVD4Otsw8v9GzK0Re2q/U/LIvkqbH3SxKpHiLX3eOtP75c+DLIKtczeeEUUgdr606V+1frQvwuyDGdNC4TWj/9jPvu/Kkj+4XCpGWPLPMJVI6TeFEQVOw8RMB6AYq1g0FbQI004X5pt1aqagVvupU1BsnPBfnFH88ce2FcE4PYveBTcJU+2JbbR9Oq3vXsALq1ARmKO7ik8vHzwcbIRwtyZUWJlbO0gtEojDkLaLfypzYuq+mS3fBUrG9PFrDBdZCZWDjBuI5rzy+mV/AtIkBo8Cu/HvqFEYcPMTw7zXM/6dK7vQVq+hjsp+VyNz8Et/zbdIj+jdn44AF5etZATFbTwd+FyvISrnZrPRlX06Dt2J5XTBzdgXPMd+izRgzQHyFf6N+SprkFIC01kkvZPYVDa8PZ2QTwBmNtWQ73w80IkogyxKTwhh4lLziEX5zDN9gDIoOxe0bB30bF77D16gkNWotfsNeS9Sg/zD79FUevGIpxUxSicbXGoW3nF41pCLku3/MJ2pWBTuw7/vMpsau3ZOA6cvcZha2ECruj1Frj4k5RTbFIPaoSdWsmyU9GsORPLzO7B+FjrkDdORjKUIDXsDx2fJ+dGKpfishn87QlGhPrx6Shxft5KzmPiknNkFJTQ2zWNn/gQZWGmIIFN3F6R1HUfDEaZ5adimH/gjqW3PqF9IC919sLp3Jfw4yLB9JaUEDYZur0m+t5/EmIzC1l5OpaN5+PJN81M13axZVaPeowK88OqJhUmowFOLoBf54r2h72XkD98ACP4r4YsC7P01LwS6no+2ETgdyH2FKReF4ubVpP++P3/TvwXJKtDDYPkQyHlqrj1aV6j0o+5p1GBQRt1RNzW7VHjFVdqngYX8qmXfVzc0XLcg59kNAqFE2CZYQCN/f2r3laTC78IMstJj0c5ndCEqfU9xOcMGSIC+9rHhLtD4iVo9ySFSmd+3badAYpzuOhXAvPEvtS24viPWgK75mCTEo5WVvKz07PMmvAeSBIzlp3Dw8Ga2X0aUKI38PTqSxRriknPzMLbkMIyJvCG4156DHyUes3H8O7pWD7YdROAj4c3K1UcAtAWkX92Jf6HvsLhQDSJSYIw5dByAH6DnmP+oy0Y2MwHbu8Rq31rJ4pbPM4Lay6y/0aqheU3NsrkntJijKVPfDE2mylLz5Ffomeu+1HsC4vAqwk0LD+Uv/FCPB/vucUX6h0iW27QX5C77sOu8CSW7j/HMWsxBO8w4N1Kz4H0/BKeXHWBedIaFJKMsfEwFFUMyl+Mzebdndf5TL0aZ6lILLxMdms+zjY80aUudTzs8HG2JbdYx5ZLCaw9E8cTWZ/jlH0P2ckfadhCUCgshLYPhzZljGk04GJsNlOXnSNPo2ewZxpfa99FUZIrem4TtlXtKWnCzaQ83tx+jcsmK6vWga68P7gBTRK3wOK5YpYQhFRb3w//NJKLVm/k1ztpbDwfz5E7aZYFcpCHPTO71WVEK78KJK0qkXhJGJyby8KNBgmx8gfMf/4dWHUmlkO3UrFSKvh2bOiDTQR+D8wGC80fK+cG9HfjvyBZHZyrCQhgIYUYHyaVNM9f1mpWo83NYtgV1DiiTYHuQQSaMsgo0NJPeQGlrBOvX5PeT+QhSLtBvmzLEn1/dlXjVM+vnwjxcbe6fFw8EtDT2ayE4+AJvd8TF7N7R4WouX8bfjkXxzc6GQdnW8ZknIe8JEFS6PaKkBtbNw4K08iUnZihfYGZAyYgSRK5xTqcbdWciMhgw/k4zt/LwLkojo8LPqOhKoqzyqYsc36KNW6vEdYoDGujzOqzcRhNCj0Dm5myluIcUeI5+yP2RZm8tEvDz5d0SMBzfQI43/Mlfp4URhNfZ1EyOC7Kj4XNJzNu5Q2uJuRipVSwYExLBromwb4DYnyhs+jDnozM4ImVFyjSGugRoGZMrskaretL5QLbL1eTeG1LOEFSMiOUJsZy11cqHOLTUZnM2XCV11Q7sJdKRBCtxGdPozMwY9UF6uefpZtVOLJCjaJ35TqfybnFzFh1kTbyNYYrTyIjIQ3+2tJrlSSpnO/o452DyCws4bfLN3EsKOJxtRWq0cvQqJ2xAYaF1ibY04FmfmIG8FRkBo+vOI9GZ2SUbyafFb0nAqR/O6EcU3Zu9j4UlOj5Yv8dVp6OwSgLx53XBzRijMstFNv6l4o+eDWGfh9DcM8q9/V7Icsy4Qm5bLucyI4riWQX6SyPdW/oyZSOdeha37NmZVUQRuGHPzDNAspiHGXAp2LR+jfKr1WFy3HZfGhaXL46oJH4LfzRyI4R+sQAbZ+sdtO/Gv8FyerwAO84cznFvHKuETJMP+pqWLNlIZsCsKrsD1CvFe4VIPzzaoh8jY6+CtOqtfHQ6jc248wPAKwz9KRQ4YivSxVuCKk3wOQokd/rU26tEheScvRwx1pCmDzjLniLcs3ea8nkYY9nncYQuVOUy0AE0vXjQFtAtkN9hmY+g5V7HXo2ErR9Z1s1HwxtSrPazry17RqOFLJB9QH1FYlQpwvtBn5BfLwDr28NJ7tQy5ZLiUSmFeDhYMX7Q5qI4HhmofgrycUoy0zcXsLacBEgVw63IaHbbHZM64SHg2mONvoYJF7EqLTm0auh3MjLxdVOzU8TW9M2yA3WPCe2az4G3IM5cCOFZ9ZdRqsXnpg/B+xHOpknLuiNh1kOy55rybyw4QpGGb7y3osi1yCySL/ymsG3U/J4ctUFPA2pTLQxSXb1erfChVWWZd7Yeo0rcVnstRF9eqntk+BWUXpOBNOL5BUU8KndCjCC1PaJKvvl5tGPl1voyDp+in2GNrg07Uc/95a8tTmc7g08GRnmZwmQxyPSmb7iAiV6I+Pr5PNR7jtImhzBqh6/uVpJxhMRGby6JZzEHKFd/EhzH97toMLr+PNw71exkZ0H9HhDMCH/QK1Vo1HmakIOe64ls+daiuU9gBjlGBFam0fb+BPs+RCOF4UZ4vd09ifRKgFxrvR+9x/FXi2LtHwNT6+5hM4g079JLR7vVOfPeaHT3wumfnBPy7Xhn4L/gmR1cKi+n2FtCpIlDxMkzaMl7jUrB5mz1HLXwdRrYubL1rVa9u390Bfl01lxXfynUQ1m0NJuwb1fkSUFKw19qW0ayq8AWYY9r4hea8gQLihbAuep62lfcXTFra4gZyiU5BbpOBkl1GtaeCpA7iF6rLd3Czd4QwlyUDcmpM8kQZZ5v2Odcqt1ZyuYot9MY/VOogzeeNopYOBijE1GolAqCCrOpomvM9EZhSz8TRz3jwYG4XLhazj5LZQIdR2Nc33CvozkZoLWEiD7dWyOy6xnUZdlnh4X5KV1+u7cKLShroc9S6e0EczTxIul6kVdX2L9uTje2HYNowz9mnjzzdAA1N+ZSAk93rBkkfuup/DcussYjDLPNCmhRdTh0m3KIDGnmMlLz5Gv0fO16y7UxTqhgRvco8LX8dOxe2y9nMijqhM0JFZkapWYaJuDaXhCLnNs9+NvTBQ9sR5vVtjWDKVCwlBShHLLdN5QxvKa/dtsyK7P19+IysY7ZXpVv91J48lVF9HqjUysW8gHOW8gFWcLw4AJVQfIghI9n+y5Zenz+rvZMm9IQzqlrIbVX4jRCKWVmO/t8mK1mejDoFhr4GRkBodvp3L4VpqFoQqi3dErxIuRYX50qedR+e+gKuQlC/nBi8tAJxjm+LWB/vPAr3oxkb8TJXoDM1ddJDlXQ7CnPZ+PrtjD/0NQmFnqYtTphT9+//8j/guS1eEBw8Zm6n6Ng6S2sHRmq4Y9E3Mht9zJabbw8mvzUOWZFiUXsFbo0DkHofasgQyXiWmW6N2ThBhPulTlQnJjmxCyVtlCzze5fNnkV+lfSV9BkkQgAQ7fTkU2GpjkdhuPyz8Lmbvbu4WpsmyARoM43uJTbqy4iqO1ipFhZfQqM6NgyzRUSZdph0TzxvVwGPIrOHhaTFJ/uZqEWinxw29RSAYtc33P0e/wC1AohKXxDKGk4xyce89BmyUC5pKh9kxoroRB70KZAGksyiY3JQYHWckPJQPpGOzOwvFhpXNvv4leqtz8Ub67YmT+QTFs/WhrPz4Z3gzVkfdF9lCruWWBcuBGCs+uu4TeKDM8tDYvGj9DQhZZfplZvuxCLVOWniM1r4Qe7jn0KCqTRd6H/TdS+HTfbWwo4V2HbaBBBJJKhrIXH49m6+VE/BSZzFJsJU9vi1PfD6tldAMoD7+HMe0Ojo5eDOvZlyc33aV7A0+WTmljOU+P3E5l5qpLaA1GxtY38EHWm0hFmUI+ccLWKgPbhZgsZm+8YnG+mdQhkDfqJ2JzaFipClb9vjDgs//ZxkqWZW6n5HMiIoNjEemci84q91u2t1LSK8Sbgc1q0a2BV6ltWU1gNELMcTEYf+sXEdhBlMe7vix6p/8Q9mZlkGWZ17dc41JcDk42KhZPboNjNTZq/xPO/SwEQXxaioXfPwz/BcnqYFc9mcD8ozEzUB+IHLEyxtq5xkoS5hBoNJbpeyabyD++Dx4hKYs2snieLrgP6gcFV12xmFkCznmOghjwrcyFxKCHIx+Jf7sFwd39RCYIsklzv+pX+EmX9vKa6giTSn6Dfh+AjQtsfQKQocU4GPIt69eL9zwyzA8H80zWtc2CIKQtABtnlAO/wKHZaMuCIS1fw+7wZDZeiGdO72Bu7VvMAutN+GYJUXJc60DPt9E2GEStWj5oc3IAmNknmKkt00WAalgqfpCn0TFnUxRHsj+mqRRNj/ZhvDOoSSl7MfYURBxAlpTM1wzmu7PiYv5092Be7tcQKT+llNre4w2QJH65msTsDVfQG2WGtPDliw5apKW7RT+ze2kWma/RMXnZOSLSCvB2suYHn91IkUbRh7wvC7kan8Pz6y8jy/Bt0Gnsk1NFX71tRa3TX++kMXevsDha7bedFxMex9XJgeeCh1MtZSLyMJz7CYUEp9p8x5Ob7jKylR9fjC4N6iciMiwBcnRDaz7JexmpME2I20/cVmkQ1hmMfHM4gu9/jcQoC5boV0MCaHvrU9i4UWxk7yl6d01G/O7eXVJOMSciMzgVmcGJyEzLyIYZtV1s6R3iRa8Qb9rVdatU4ahapN2GWzvh6jrIuld6f0AHkc0H9/pH9h3vxxcH7rD1ciJKhcT341sRVJWX7f8KTS6cXSj+3en5f+Sx+S9IVocHrKgdTRdts9D5A5FryiIfQsHf/CM1q/sAkCaa6A9TuzcYZdpL4nmGOtWLqgNwZ69QvHH2J1zZBIjHw7GScZFrGyErSmiwZkTAb5/iI01HTVjpHJ0ZZnk5RNA/m6ilAyru9VpMiItK9CCRhZ7mwC/ILtZz6KbI+h5t7S9mLfe9CpdWiv0FdhLGuM61LS+h0RnYeSWJAzdSeL+tkdBfRzLdSgw/4+gL3V6G0IloDTLe3t7kmAJkl66d+aHzLTAiCEamH+vtlDyeXn2JexmFWKlUTBg6nEfblCF0yTIceh+AI3b9+e6qmJt9f0gTJnaoI7Y5+qlYKfu3gwb92Xghnte2hGOUYVhLX74Y1RzlKpOdVYtxFrFtjc7A9BUXCE8Qvc/Nj6iw3WYKpL3eKXdo47OKmLbiAhqdkSH1VPROMwlE93pXSP+VQWRaAc+tvYxRhjcaJPFFZGOOGptTlGuP76VExrcPqMBeNBplFJps2G4SR2j7JEEtuzBHn8CzvUqrIueis3hi5QW0BiNDQpz4tOQdpOx74BwghAIqWRzGZBTy/PrLXE0Q2fyIVrX5KCQOuz0DxTyvpIB2Twkrt4csrRaW6DlzL5Pjpmzxnkk/1QxbtZL2dd3oXN+TLvU9qO/l8HAlRYPOVGo/KIKjOdsFQchpPlr0S31bPtT7/jux6kws3/8qbALnDm/2x89DlsXZn0Wg9GhYc57EX4z/gmR1eMAP0uwjWeMgmZcgbh+iSW91f9/TaBCrVRBjBDWELjuOuooUDLKEHNDhwU8IN63em40mPU18PguBxQyD3jIegos/PLoK3bklvHDxZ+4pnqGBZ5/y2ysUoMmDm9u57jWE48V1uG4dyJM+zrBmpCDtNH8MBn4BCgU7riSiNRhp4utEkFUOLBkn+rFIomTV7VVQqsQF3NSrtFErGeqvof3NJTS9sBmAfOyw6fkK6g4zQW2LVqstFyB79uzJ4afrwrVwwRYO7oksy2w4H8+7O29Qojfi62zDjxPDaO7nUv4z3d0H8WfQYMXrmQOxs1Ly9ZhQi7oMmVGlQb33eyw/FcN7v4jFyti2AXw0rCnKe4dFuVppBd2Fb6NWb+TpNZc4G52Fo7WKlVPb4n/INLLTYlw5oevcYh2PLz9PRkEJjWo5Mt9zC1JCgSjt3ScQnVus48mVF8gv0dM+wIGmmfs4TSgrW0VwvtYY5u27jZu9FYNb+Jab81MoJORdL7InN5CBXk5Ivd/Hx8q2XIC8Ep/D48vPU6wz0LO+Kwukz1EkXRKiHBO3VkqE++1OGs+tu0yeRo+TjYp5Q+oxMO5L2LJabODRAIb+AP4PlnA0Iz6riF/vpHHwZipn7mWiM5RWYRQStPB3oXM9DzrV8yA0wOXhskWdRlhWxZ8RRK7YU6UkHBCLxeAegpjVZNg/Si2nJthxJZF3dgjewuzeDcovCP9oaPLg9Hfi391e+dsNpKvCf0GySkhiJVgNzDX6PI2u2u0syBPyZmUznwfBQg4yOY6QEyuyEqX1Q/VkJNPIyDW5Lg3sHrAaL86GSJOQefPHyNwueowVtEOvb4GcGHER7PYa1GrKrVbvknL+KvOsluCe3Qsc2ongaPaEvLkdDrxNjl8cEMpQ/2JU658WRKQG/cUgtSnb3HpZZN7eihyWfL+OMcZYPBw8YeTicqMv5gC5/2IEITErCbjxA55GPVpZxXJDP+qPfJceoUJjstIAuWo+/GzKrnu/T55Gx5vbrvPL1URAontDT758tGXFz2/QU7TnbeyApfr+KJ192DS5dXmK/OEPQDYg1+/HNxGefHVIBMjpnYN485EQpDKZKG2eABd/dAYjL2y4zJHbadioFSyZ0oZmxWeFmL3SGnqUmlybyRXmcuyqIc6oV5lIEH0/Ltf30huMPLNWZMW+zjYsbnQR+ehJJtjraTxwOaEOrsRlFfHezhu4O1jRpb4nSoXQXpVu/cK+a/G8q5vKPX8/nrUq35++m5rP5KXnKCjR0z7IlZ/dVqO4ekQMho/fVKEHbzTKfHskkgWH7yLL0CrAhR/72uK1f5yYQ5UU0OEZUZ5+gFqOwShzOS6b/TdSOHgzlRiT/KIZ/m62dK3vSZf6nnQIdq/ccu5+yLIQtEi7KQRA0m6KNkfazVIGthm2bqKX1ugRIZD/BxGJ/mrsDk9mzsaryDJMbB/Ic71qTgr8XTj7E2hyxEKoyfA/97X+B/wXJKuCyvaBjXXzRTOzQFuzfRYKJif2NS9fmOXo8szZanaM6cWDHmrlpUwW/nnnjQ0JLtvfrAyRh8WFwDMEvBpRpD0BYHHWsODcz+K2/dPQQhg+x2UV8YzuRQ7YvI/3rtkwcpGYyTS7eTQZDjoNq282xY1YXkp/T7BMAzrA6OUW66e4zCLCE3JpIUXxa0IQvzGA23Z1eHbYMOrXqU+5b0aWifptJd8eLMIFexarJSIcOjIrazQBwU14oqUYt6k0QB46BMtNTN9mozmj8efFBcdJzCnGWmHk+b6Nmdk1uIL0oCzLHNv4Fd1yI8iWHTjhNY4dUzrh5VSmtBl3Bm5uR5YUfM1YFhwSpbjne9Xnhd71RVnv6nphC2TtBF3miAC5/gp7rqVgpVTw44Qw2gY4wY+m8mq7GZZyvdCYvcrpe5nYWylZMrkNnkdnCNJTw4EVRMI/3nOL4xEZ2KqVLB0VgMOmySAV02vgo+AgOpEfDWtGUo6GN7dd57txoYQGuApG6u4X6abIZWq9Qkb3LC8BmGRi3uYW62jp78KKJpdRHVojAt3oFRV6p3kaHc+vu8yvd4Tt2Ng2/nzgfx71+jfEYsnBG0YuEXOyVcA8u7jlUgJ7riWTUeY3qFJIhAa40DvEm96Nvase05BlsSDMugdZ0abbKMFAz4wUZcDKYOchPlNgJ7FY8276jybh1AS/XE3ihQ1XMBhlRrby4/0hTf4cJqsZRVlw6hvx726v/mOzSPgvSFYNdRXzgGVgLj/e3/yvEmZVkAcQgsrCvOrNKzZlq2byj8vDibYrU64AcM1Yl5GGBwTJu0LJhYb9AUGNh/sswZIuC6UQhVpIgJnvzhQ+fj8Efc+C9Cdg76sw7AcoSBfyW73fR277BJf27+cb9bc4lKSAW7Bwmi+TMey5nsxExX4S8OJV5XpCA9x4Ln0IT+1I4s1HnOlUz0MILGRFwy/PERx9jCeVHXB3cye500oGb5WRJFg4sBGSJFUeIA8fFgo6sSeQVTZ8yzi+WnSGSYr9dLWPIqy2DS52/UFRfkWdr9Hx1oazvHnvO5DgaK0pLJ3et7zggyzDfjFKccy+HwuuWVXsVWqL4MiH4t9d5qC3ceOF9VfYfS0ZtVJi4YRWdG/oBReXi+zK1lUwVU34ZI/QL1UpJH6a2Jqm2qtCt1RSCnPiMlh3Lo5lJ2MA+PLRFjS68ZEQkvZtBS3GAqUzkEuntGHA18d5d+cNFjzWEv2BuXyXPZpZnleZNXlSud9GbpGOyUvPkZyroZ6XA6t7arDe+LZ4sM+HFeTVknOLmbL0PHdS87FWKfh4SENGJX4Oe0w91OBewgfTofKFZHahlo0X4tl8McEibA6i9dGrkRd9m9SiawPPUpIXiBJpZoTQTE6/UxoMs+5VHQgBkMTIklcIeDcRf76txCLlH0gw+b3YdjmBFzdexSjDqDA/Ph3ZvObCCL8Xx+cLzoN3M0HE+gfjvyBZFVSVGDHfBzORJbNQW64vViWKs8Stbc090ixBUnN/kHwIyTyDDilFjCSEy0HVix8Y9IKEAKL8CWj0IkiWCwLnF4vbxkPLjcok5OlQocfXzRGGHICFncTMY0q4kGrzqEdcZiFTtWvorLqBrLZDGrOmAqHD/uwCXlFvYquhC/4hbWg39kVOo+DJVRd4as0lnu9Zj0eVv+F54h3ytTIH6Mng/n2w6jCDScsvAukMbeFLE1/nqgOkQSdcF4D1ikF8eb6Yl1QbmGB7GruWI7AqSoMra0TGYCJJ3U7O5ek1lxmSswIvVQ75dv4MfeIdpPv7Wje2QeIFirHhpYxB2KgVfDMmlL5NyvTlzvwgRoKc/dG3mcELG0oD5I8TwugV4i3Ghn41ua50fcVCJlt8/B6LT0QD8MXoFnQOdoNFb4ntWj9errx59l4mb28XfaY5fRowwC2ptOc34DNLFqRUSBb/zU0zO9D3y6PMXnmMyPR2dFDcpOGo8iQgjc7AEysvWEq9q0d647C+v8hkm4+pYLh8JyWfKctEQPV0tGbF2AY0Pj5L9PYkpRiq7/BspVlZVHoBq07HsuF8vMXs3FqloH/TWoxo5UfHYHchB1eUBYknIOW6KI8mXRLBUK7mnHf0FZUZ1yBhPu5eT/y5Bf2pwuj/BCw5EW1R03m0tR/zRvwFATIn3iI8Qu/KJRX/SfgvSFYF5YOFv93tRSA1GGWyirQViS33ozhH3D6ANVsW5iCZbbLMItdE/nkIhiwZd8FQQr5sS4xcC425v1kZki6JPoGtq8Xv0hxULb6Z2qJSw+Y25QXPU3I16FHh62wlgmfYFDj2ufgxmAS/Ey/tY5ZKyLNJQ76t4Laev+8jJhatBAkGd26FW38hz6YAFk9uw+JD4Xx84A7XFAk8p/Jgsc0Ubtu0YGSn3lyIyeLY3XRUConZfRpUHSCBktM/Y50ZQabsyMd5/Rlkf4sn1KexHrcaAtoJZ/h1YwAZuTiHVVdy+Gj3Lbz1ycy0ERJajo98WHFBpS1Cu+8trIAfdY+gt/Ni7ZQ2tAooM1yRnwInvgJA1+NtZm24yYGbqSKDHG8KkAAnvxEMT5dAaDMNgC0XE/hotxjfeH1AI4aF1hZl2+Sroo9uIv+AEOGeufoieqPMoOY+PNsjGJb2Ew82H1OBEKNSKtAbjDhYq5jczpd5ByKZqTzAq53doIzuqyzLvLw5nHMxJmLRpGbU2jVKVEt8Q2HwgnLZ1umoTJ5cdYF8jZ56Xg6sGuGNz65RkHFHiNiPXg717yN6ITRfFxy6y/GIDMt9TXydmNg+kIHNfXDS50D0Udh7EmJPQ/qtCvsARJ/QMwQ8G5gCYHCpsMV9/dX/H2Awyny0+6aluvB4pyDeeiTkzw+QIPr0hhII7Cx0nP/h+C9IVgXpwasbK5UCT0dr0vNLSM7RPDhI6kzSVuqa/yjNItzpZvWPQtHHeShXdZPKT7yiNiBVTzSKPytuAzpa+gRK08XOIlEbcUAoh7gEVJDFyzGVhV3sbYTk27HPYeh3EDpBbFCURbPz4iJ+xm0o7ZuNKn2yLMNvc3E88zkAK+2nMKl/KUnFYJRRxhxj+pUnaW9lw1O6F3jU+AlF+Qr2PC4u4F8fjgBk3q0fje+1m9Qa/hE5OaKkVjZAngi/Q/NDn2ANfKkfTa+W9fikdgbWkfVFgAQxY6grRrfjeZIzsmioUSPpX+Mrty3YFGlFhllGXs6MyG0fUa8gkUTZnQMuj7FlSkfq3t8XO/wBaAsw+Ibx+PkAjkelYqVSsHB8q9IAmZsIJ78W/+7zPqis2Xc9hZc3i9nRxzsF8WTXumLRcthUXu36okUg28x6zS7S0ay2M5+PaoF0fQsknBPnYO/3Krx3EIFy1ZlY5h2I4j3VSia734KeZ8pt8/XhCH65mmQq9YbR8Monolpg5w6PrS6XgR29my7GQvRG2tRxZUl/G5w2DRLnsqMvjNsgBP/L4FZyHvMP3OHQLTECpJCgZyMvJnesQ2fPYqTbu2HdLxB3umKW6BokdIm9mwl1n1rNxO/lX1Qi/V9QUKJn9oYrHLwpXG5e7d+Imd3q/rk9SDPiz4uxMSTo99H/ie/kvyD5P6K2iy3p+SUk5hRZ9CqrhCVI1ryE4+0kAm96fokIEuYgafcQTgGmoeYUlWDV5hRVFyTPidsyGYZSKU5kndF0MbqxTdw2HlbhJDf3Tp2sVaDyFbNx9XqVbrD3FRy1aUQZfbjd/FXKhdjT34uZQuBj3ThsW5Yp1xmNKI9+ivzbp8hAU68GLOzWgsFrk5k/ugWNajlxKS6bvMgzbLZaQ6uY2zz1nYasHPF+zAEyMaeYj3bdpN3teXRWFRApBdJnwst0D/GFa1GCGHVhmSC+rBlFrsqNuWndyC4y8Kx6Oyc95uJRcEeUBweWt50yGmVW7D3G2Js/gwRbPZ5i/bSeFd3oEy+JMi7wRvF4jidnYW+lZNHk1nQMLvO9Hv5AMJkDOkDjYZyIyOC5dWK+cXSYH289EiIubKe/N5VtA8Q8IWI4f9aaS0SlF+LjbMPiya2xpQQOmVR6Os8pZ02173oK7YLccLW3QpZlvIzpLLH+kp7SRRi4XtibmfDL1SQWHBIaxJ8Mb0ZH3Rm4sEQ8OGJRuSpH2QDZO8Sb73tZYb1mqGg91GoG4zaWG4nKKdLy0e5bbLmUgCyLEvDoMD9mda+Lf9YZODMDzNJ9ZtRqJgx6AzuKY/UPdNH4pyAqvYAZqy4SmVaAlUrB/NEtGNziL9KNNRphn6nK0XJ8pQ43/0T8FySrRM1WOLVdbbkSn0NijubBG+tNQVL1YFKQGe4O1igkMMqQWVCCV6FJNeZhLgSZYjA409oP8kWGUSlkuUyQLGUwqkw9A4NRFllLxAHxQCW0bfO+ne2swP++4eDIw3BtEwYUzNY9zYu+ZbLh27uFuTKwQBrPIsMjbGlg+ozaItgxC25sFap2oRPJ7f4Rzy2+QrcGnoxo5Qf5KWg2PM0O68MYZZknfilh6WUhVv7qwCDe2XaArw9FsPBoJP76OL61OgRA7VGfUi/EdJHwDRUCy79+jP7WbvIy0+mf/xZpuFLX0x635m54nDZlbO1mCCKH+XMX6Xhx01VGR36AjVJHtGMrnnpqDqr7e5WyLEypgcPq7mxIroWzrZrlU9sQWrYcm3gRwk0m4v0+5mJcDk+uEkP6/ZvUYu6IZqI0lp9qKdvSW/QMZVnm3Z03OBGZgZ2VksWTW+PtZANHP7f0QOn4jOWlTkVlMGvtJXxdbNj2dCc87K3od+ddkC4KO68y6kPXEnJ5aZPIZJ/oEsSjDVWw0LSvjs+VWxAdjygNkH0ae/NDH1vUqwaLAFk7TKjvmMYlZFlm3/UU3tl5w1I1GdTchxe71SYoZgOsnVqqe4xkWjgMEWMXf4al3b8Qu8OTeXVLOAUleqHeNL4VYYE150f8z7i2SZD9rByg19t/3ev+j/gvSFYFuZq+XRn4u4rSaVxm4QO2RBBFwDLmUBMoFRLeTjYk52qIzy7GS5MjHniIvqa5j1lk7wcZZUq396MwAwpSAEnoKJpgntUs0hpEeUtXBE61K10JhmivkUUgdvfrXBoNliC42tiPcDmYIHfToHXqTeHKjkx244ksuNQfeyslLfxcxGzp+nGCTatQwaAF0GoixkItg5v7Mrt3fbi8BsPe1+mozUVvhIHrDRyMKBUr792zPr3m/0ZSrgaQ+dJpLSqtEep2xzb+ODh7Ckq/ezD0/ZBTgU+xf9cmhmujyMSJKR3r8Er/htjtXCWMcW3dyvX9riXk8vTai9TPOUk/qwsYJSVBE74vp/1qwdV1EH+GYqx5I38UHg7WrJ7elka1yoh9G42CFQzQfAzhcjBTlp2lSGugS30Pvh7bslRg+8iHoCuE2q0twgFLTkSz9mwckgRfjwkVc5tleqD0fs9SzUjKKeaZtUJgvXWgG+72VnBzR6kW74B5lreVWVDCjFXC0aNHQ09e698I1j8m+pA+LaFn6YXvfExWuQD5fX8X1CsHQlGmOG/K6Lem5omRk0O3RPkv2NOez4c3olX6Dlj7aGmLwcoRWk0UVkr/o27r/0+4XzC+bZAb340LLe+n+mejOMfy+6fLnAc6LP2T8F+QrApmQeIHoK5J0/BeRg2C5O9EoLsdybka4jILCPsdfU3zfKbaSfS6knOLK9/O7M3n4l+OzOBqcvLIKdJChpiZJKhbxX5Cfgo/y+9TYG1LVskZoIwYw9V1kHYTo40L83NEBurtbC3YiOvGCNWSoK7s9X8BLt2hZYALqrTrsGa0CNy2bvDYKqjTWbwneyteaG0Nq0dC1GGUwBVDHQYtTiIxJQ+A5cNsmNDcipGJ/UiSNdR2seXr5nE0O3dFDOUnXxWDzKYfbEquhg93RbP7WjKtJGdG26rZMcCKpq3rQuI5i5YtAz8HG2dkWXhUfvjLTZSGIjbZrgAZFB1mVS4ZWJSFbu9bqIGvdCOw9/RnxdS2+Lvd911e2ygMqtX23GoyhwmLz5Kv0dO2jhs/TQwrVYhJvgqXTSzV/nNBkth3PYWP9wjyypsDQ0qVf458JIKpXxtLMNXoDDy1+iJZhVoa+zgxd0QzUb6t3we6vATWjpYsTQgRXCYpV0NdD3u+HhuKMnytqCoorcTYhkqcJxGp+UxbLvwjuzf05Puh/lgt7S0ISN5NRYA0LfIuxGTx1JpLpOeXoFZKPNW9Hs94hWO1s08pk9s1CDq/IEYFqrHW+g8VcexuOq9vvWax+nq6ezBz+jR4OBeTPwJHPhLGAu71hEjE/yH8FySrgr5ms491PU1BMr0GQfJ3NqnruNtz5l4WCRm5WHxBHqJka16J27qIYCAyqkpg9rq8z8bLxdRTyynSQYwpSJqCVTmEb0CFkSjZF5eyYy7aIjjysXiJ0GfI+9UBVzs11goJNj8uVIRcAmH0Ci7uigegn2sqrHhOMG09G8HY9VzMd6aJziBGUcI3Iu2aA9p8ZKU18zTDeO+nvWgzxYLgw4FeTGqhYauhM5E2TXmzRz0mtvbE5ieT56OTjyAnDfwcvcHI5gMn2HTiOhFaN5QKB7q2DiUkfTvKa/Pg8vumC7Ys2HhNR5JVqOXVLeEW8sOP3vuolZsu+oJlssyyiN74GkElmdw11uZq7XFsmdwe1/tVfEry4aDoG6a0fIYx62PJ0+hpHejKsqltSjVVLXOYsgh6/m25FJdtETgf3y6AaZ1N2VbKtdJg2u8TkISKztvbr3M1IRdnWzU/TQwrHfGxsq9QDvt8/x1O38vEzkrJTxPDcNKmW8rG9HjTojeblqdhyrLz5Gn0QkVnTBOs1g6H3DjBJp24zTLus/ZsHO/uvI7OINPQ25HvR9Wj3vn34OQGsV+HWkKvNXRipdWXnCItkWkFxGUVUVCiJ18j/iQJ7NRKbK2U2Fmp8HK0xsfFBj9Xu5qp7fwLkFuk4+M9N9l4QVSR/Fxt+WxkczrW+xv6tYmXSkfGHvmyRuN1/yT8FySrQo2DpCA0JOYUU6TVVxCGLg9TkLTQRGuGQFNZMik9q/TOmpJ/ZBmKROBw8fABkknMriqTNPV8PO4PkuJCnpeXJ0ZEoPIgeVVc3DYZuvFE2fsvLIH8JHD253bAWOCq6JGdXyTMc9V2MHYd2LlxOT6cZtI9xt7+DHR5wpx3wmbysWPM/IN4qoo5ErILm9umERT/9qz1ms07U55AnyUuCP27tOCtNtEUyjaktHmVY306iIvjofchN14wKm3dkFs/zq+3UzFseZIWJffoLuVjYyuT12c+AR0HQu4a0UeJPSXkyNR28Mh8frubziubw0kzZT/zOkr0u1Amy6xEr3PHrp0Mjt4IEuzye5EVUzuVnzs149jnUJBCiVMgg863IFejIyzQleWPt8W+7ID87V3CikllA73fIyaj0GJu3KuRV6liStlg2mSEZYxj9dk4Nl1MQCHBd+NCK2azZbD/Rgo/HRPkr89HtaC+tyOsnymGwWuHQcdnAZMg+8oLJOYUE+Rhz+LJbbA5+KJgTNs4C5KOgxd6g5EPdt1k5WkhPD+wWS3mt9dgu6W/WDBJCqHN2+kFS0XDYJS5Ep/Nb3fSOR2VSVR6AdnVEdCqgLOtmka1HAnxcSLEx5GmtZ1pVMsJ5V8x+vAXQGcwsvZsHAsO3SW7SIckweQOdXi5X8Py589fBYMedr0AyNDsUahbA3OFfxj+C5JVQVdUzrWiKrjZW+HhYEVGgZa7qQW09HepemPzCspQQ4UeE+p5iUAckVY2W63hj9qgtWhN+nh5AsncSy8QepyVlEsB0W8sg1omqTVD2m2xLzt3cL1P8ScvGdJuYERir6EtE0wqPRj0pTZRXV8mVyuOZx2rXDhsUpvp8wF4N0GjM+CUeZWVVvNQ64oEecjkXn/8WjLt5HAWKH7C5naWydz4ZbQdXmCmjz/6HEFoCmjdg809bgBg7P46T/cw+dMlXhSKPwBdX0J7/Gvm7EknKO5HuisTma98nLHt69BTfxKXg0+Al6sgoTQeBse+AEDT5TU++C2ftWfF/ut5OfDN6MY03jXcYjhtVinK1+hK/fcMOvrd+xiFJHPNfQAvTH+88nm0tFuCqQrMyRtDhgZCA1xYPrVNRQUZc3+nwzNkqWsxZdFJsgq1NKvtzLfjQkvLaREHxRyh0koQe4BLcdl88Iv4DK/0b1Sty0NCdhEvm4g60zsH8UhzH4g4JIK0pIQh34FCKQyct12zOJYsn9oGt8htJnF3ScxBetTHYJR5cdNVdlxJQpLgpb4Nedp6L9Lqd8Qoh3OAkDI0jRbdTMpj8fF7HLmTVikr20qlQK2U8HW2RaWUiEgtoJ6XA018ndAbZQpL9KTmlZCUU0xmoZbcYh1no7M4G1264HSwVhEa4ELrQDfa1XV7eNHzfwBkWebwrTQ+2XvLUtWq7+XAJyOa0abOX0jOuR+nvxNtARtn6PvR3/c+/gf8FySrhCxku2ogVhzi48TxiAxuJuVVHyTNfURtUdXbVLp/0duLyCgGc7XIqAceLHhQtrdax9sVhSR0YNPyS0Q2VxZFlTNn63iI963IMpVjPRpWfJ3oo+I9KoLJxaF0FvPuPpG92blD88covipKv9MKfhLH16+NsMYC4m9fYKV6Lk5SMXJAB6Txm0RfzGiEY1+wUr0EhSyLvsbwn9F6NcPb25sCk1CAd1g/jo3VYp+nAf/2OHYTGQ46DWx7CmQj+fWH8VZUK8bn2DIg+ytUSohrMIX5I2eYSnHDhX7oia8EGWb7LNAWkO3RmoHHG5GcL/pkUzrW4bUBjbA5+blwJrF1g0fmszs8maUno2ldx5XHOwWJY3zya2yybmOwdaPZ499TQQgWRMa3+0Uw6jkst2Z3SQtaB7qydGolZrdnfhCjKo4+FLZ9lseXnycmswg/V1uWTGldWs0w6OGgqWzabga41iGjoISnV19CZ5AZ0LQWM7rWrfheTNAZjBaHjhb+LrzSv5GosOwV4g60f8rSe914IZ6tl0z+g+NaEWhMhF1CPILur0FwTwxGmZdMAVKlkPhmTEsGpi+BA2IRQvMxMPAzsHHmSnwO3x2JsMxJgtBkVSgkpnasw9Bm7py6FU9cei4zmyvw9XABW1d2ROqYeyCGJ7sG07BWeYOCIq2e6IxCbifncys5j1speYTH55Jfoud4RIZFsMBGraBNHTc6BnvQuZ4HjX3/uZmmzmBkV3gSPx+L5lay6MW721sxu08DxrTx/+t7j2WREQm/zRX/7jcXHL3/vvfyP+C/IFkdNLk1CpKNTUHSfJJWCXOQ1D1ckKztYoujjQqNRlsaJGvIvkVfGiRtbGwJdLcnOqOQiNSCqoPkfdqyAaZSnGOeyUTWs0HF17knguQNm1ZQBHnFJkH2i8vEbehEUNtQrDXQU3GJNkXHRSYyaIHI1ouy8N37OPZSMbfUTQgZv1nM5hXnIO+YxcD0XSBBar0xeD/6FVpUFZV05o6EPS+J4zzsh1LR5KOfQsYd8pRu9Ljej0w5CYWiB886HaOOIRZF69lgqxZBRakS5ebMKLiyFuJOUiLZMCRxPMmynjrudswb2Zz2dd1Fr++YED7I7f05b+xI4HJcNiNa+dGnsTcqhSQuFEc/A0DZfx7YV6HbG74BYk9SJFvzTslEutT34KeJYRXL93nJlsxW3+Mdntp0lyvxObjYqVk+tW15xuLllSbNVzfo8pJldjIlTyMYpKNbVDtAPv/AXS7F5eBoo+K7saHCOuv4d0L31MFbCFOb0KdxLXaFJ9OtgScd6zjB4mGCKBTUFbq+jNEo88rmcLaZjHy/G9uS/vEL4JypytDrXegyh7R8DW9suGBhuoKomdR1VeOuLCIqx8CgKzNpfO4KAbINDpIGIkpNZhoa/cnWfoj7vpkQEAL+7UVrQG2DnZWKJr7O5VxaDEaZOyn5XIzN4lxMNqejhBGzOWh+iujJdwx2p3M9T7o28MDP9e9X6EnL07D1ciIrT8VYOAZ2VkomdajD0z2CK5oR/NUwGmD7U2LBWbcHtBz3976f/wH/BcnqUJxToxmsxr6CcXc9qTqxZEp7VWX952oASZIIqeXExZgyZVpDDfsxRvN2EiiUNPB2EKvplDw617+viW8WYL9PW9YcJD10CaCkArEHgLhTANxzDIMsk4xeQZqYjQSLCLpWp+VNlRikp8MsoYwiy7D9aeyLEogzerK14We8ae0g1Dk2TUbKS6REVvGJNI23xs5Da9BXDJBrv4VFPcV+e78P7sHIssyds3tpcGIBCuCl4slkys70DvHmiW7PUfeWDGdvwrHPwKdFqYWZXosRMB54BxXwoXYsSVItZnatywu964teoq4YtjwhMvpGgzih7khSbjQbZnQo7e8ZDbBhliivB/eC5o9W/h0VZlKy+zWsgW/1w2napCnfjA2tvOR36D3QFSLXbsOLtxty7G4Ktmoly6a0sZTlAUEAMmu+dn8NbF34eOcNzkZn4WCt4qeJYTgknoDo4yKQhgwRYuS2YlbzREQGPx4V87WfjmwuPlNBGhybL/bZ58NyTFM3eyuWT20rkuTjX4gFhJ07jFgMCiWf7hECAUqFxLdjWtI/4ZvSADnwC2j7BAdupPDqlnCyi3QoJAj2sGWsdzyD037GM+86pwyNmaGfQ8OSayCBg8oIDv6gtsVYnIdSk8VuXXtaSpHYRh+EGCEdiLWT+HzNRwvRgTKOE0qFRGNfJxr7OjGxQx1kWSYirYBTkRmciMzk7L1Mcop07LmWwp5roh1R18OeLvU96BDsQdsgt4oWan8SirR6jtxOY/PFBI7dTcds5uPhYM3UTnUY3y7Awh/423HiK6HsZO0EQ779P6GsUxX+C5LVwTyf9QC0MBnx3kjKo0RvqLqfYRbxNmdsD4GWAS6ci8lCK9lgJWtElluJy3sFWDRoZTDoae7nwv4bqVyOy6m4rdGUnSrLnxbuDtZ4OFjjWiIcPipI4umKhc4pYPRsArF5xGYWQeRJ8bq1mgtmI1A/7QDBimQKFU7YdzOV7c79DHf3opfUzNTNZpiXD8ScFOMfukJybf2ZlPMEXiGdkCsLkPv3wM89hFhDcC9KWk1l/9Ukth6/xKfps1BIRjYbumJsOIidverR3NdJZK9+H4pKwbXNQs80ZDCyJgfjta1kGB3wlrX8amjBTd+R7BjWnKa1RQai0RmwOfiO0Am194JBC9iyOYaOwe74u9nx5YE7RGUUElB0kz5xGbSycaigZWqGLMvcXvEsIdps7hj9yGg2ne9Ht6q8TBZ7GsLXIyOxyGEGO66moFIIt5ByQgQg5OwK04VGadhUtl1OYPmpGEC4gNQrvgbbnxaLg5J82D0HNO9AuxlkF2p5cdMVAMa1C2BgM5Myz9HPRHbo26rSgK9USKIMbMp06f8pOHqz40qihfjzxejmDCzcDmcXki074DrsU4qajOHDreGsOyeYzc1q2bK4+R28r3wHkSatYoWa6w7d8CxSkD9mD+5+DURANx1TJZBVUMKeH0/xeDMV9m6fQMIFIZ6elwhXVos/p9qCaBQ2pVLymyRJNPB2pIG3I1M6BaE3GLmakMuJiAyOR6RzOT6HexmF3MsoZIWJeFTfy4E2QW608BNZan1vhz+kp6kzGLmTks+JyAyO3U3nQkw2WkOpBF9YoCuPtvZjaMvalZPA/i4kXiotsw74VIyU/R/Gf0GyOhSkPXgbxByjm70VWYVabiblVbxgmWEuYxY+fJAMCxT7zMMODzQPsPgpg7KjIvpiQgNcAEHeqACzBmYlurVNfJ1wjjERh2xcyj+YFQ3IYO2Mh3dtII+YjEIoNLmJmIWrZZnmsSsAOOQyiqHWjpAcbiGhrHCYxs3iOrytvQKrZ4mgV7c7r+jmcDW7gA89C2no70lOjihrW7RYD7wFaTfQ27rzrcMcVs79ldyiElao5+GtzCHVug6hk5YwqnaZ4G40irm+Hm8I9ZaowxRGneZ0vhdW2np0VV4nDTfyBnzH5vZC3Wbf9RTWn4/DRZ9B69go+imd8By2kHyVC/bWKrIKdby6OZyo9AJ6+ktsv1bIfmbyXjs7uroEVCBL6QxGVqxaxvS03RhliXPN3uPTka0rJ/UY9KKUDFz3HsonV0W2Ov/RFsJOqyxyE+GUyfG9z/tcTy3mtS3CBebZnvWEE8k3A4U4fefZItCc+RGOfYHcZDhvbI8nNa+Eup72vPWISXw+6x5cXMYFYwMCO76DZ2WZgSzDnldEiS2oKzQbxa3kPF7dEg7ArB7BtFNF8cquGI4YFlLL2YZ2CY04d/IM1xJykSR4sktdXgq4i3qzaYzGoRbGTrNRhE0kZvc9vNILUAeEQSXlxGWnYrBWqxjfrwtGY2cUbaaL7znutJg9vbFNBMx9r8HxL6HT89B6aqVsZDNUSgVhga6EBbryfO/65Gl0nI7K5HhEOueis7ibWkBEmvhba5I9Vislgj0dCHCzI8DNjkB3OzwdrXGyVeNko7aUQg2yjMEoo9EZSC8oIT1f/EWlF3ArOZ/ItHx099na+bnaMqxlbUa0ql1RD/ifAG0hbDVVWBoPs9iw/V/Gf0GyOhSkPngbxOoz1N+Fw7fTuBSXU3WQNBNiijIqf7wamB0kMg12eCiyxPxgTVA2SOo0tPAT5J3kXA3JucX4OJdZTVuEoiteAMsFyfvVfiyjI/UIMv1w4zLyQHtE3F/f5CkYewq3grsUy1YccRjEUIMOtkwX5KKGA1ka05euirO0O71AlCjr9UE/eiUnPj5GB65w4q33iUkrr8Wadf0grqe+QwJm5k7h0FmxePjabhldjNeRlbZ4T9uAt9d9gUShsLCX79i3ZkGaEwdj2zBMeZIv1HswosB+3HKGNmjO6ahMPtp9k+xCLcOauFB08TcW6ocQ79OP1+v3xhGh23olPgcHayVfjGxCne1DGWUVzSc2L/JJREO63nc88zU6Xlxzijdj54EC7gY+xsTRo6v+Hi8shdTraFROTIoVDNr3BjdmaMvaFbf99WOL5mu2f19mfn+SEr0Y7H+hdwO4vEb0FFuOM33nCmF5duobjh0/wt7rjqgUEl8/FoqdynQuHPmYBdohnLfuyJtuYXjcF/BlWUa6swci9guP0YHzKdAamLn6IhqdkS71PZjT3pn3v1xGguzOZ/Vvkth4Ou/uvIFRBidbFT+OD6NDsDuSFAIZr4ssP2wKksoGJAkrpQKNzoiTjdrifWlGZFo+68/H8/WYlqavVyr9nut0En8DPhOiFsfni7nXA28KxnPfj0VmXIOSoJONmn5NatHPZHmWVajlfEwWF2OzuZGUy/XEPHKLddxOyed2Sv4D9/cgOFqraBvkRpf6HnRt4EmQh/1fI0T+e3HgLXE9cPSBQV/9ny6zmvFfkKwOeUk13jQ0QATJi7FZpUPc98PedKE2j1o8BDwdrQnysCc7z8TYK6xhoFUoQG0vymQledg7eNLE15lribmcjsoUuqeWbU0lG2PFfmdzP2dsJRMJ6P4ylfk4Oftb+mKGjHugzhYkmtomZ3qTYs1OQ0dSdHaiHJZ1D+w9kYd8h9/cVSxSz0dh0EODAfDoCkr0CnQGHfc2f8G5KKHF+tKAIOq/toinftjBR6mzkCSZdfoe/Epreod48YbdNureEL1QqdMzFeY+zbickMuqQ+fZeld83laKe8y1WiZUc3q8jn2DbpToDcRlFdK1gSdPdvLHddMokE6RY/8GCU49ydPocLJR062hJ3uuJ9OrkTd1rs6HpMt42Trz6MD+zNgSTXRGIUEmdaaYjEKmr7zAuKwfCFSlobGtRaPxX1T9HRakCcUS4KPikWTjxCv9GzKlUyXnWXK4IBwB+t4f8Mz6yyRkFxPgZsfXj4WiRBakLycfkUGZv3MnH4o9m/PbmYtAd+b0bUCztB2QoofATlwLv8iP+ndYOLA2jX2dKNEbyCnSWayvJFnGeOhDFCB0YT0b8MXOG8RmFlHbxZZvxoQSs+0l9pe04Vm3c3SbMI9pa0WAVCokxrUNoGM9DxH8JMoJMkiAVqsnKS2D2op8OP09Smc/YX3lVheUKjacj6d7A0+a1nbmREQGWy8noNUbeb5XfTHXCWIEK2yKENe+uk6UhXNiYduTwqz6kS9r1sIoAzd7q3JBU5ZlErKLiUwvID6riNjMIuKyisgyjZ/kFuvI1+iQkFAqJBQSWKuVeDpY4+ko/vxd7QjxEbOcfq62/+ygWBY3tonFHMCwhQ99LP+p+C9IVofc+Bpv2q6uKKWei86qfAYRSmvzD7Hfsuhcz4Pki6YTLy+x5k908ILsaJEZuwfTtYEH1xJz+e1Oevkgaesq9mv2vSyDdkHuFJlOl8y8AtzLSi+ahdvVdvi52uJmb4VPcbK4z3QRQ5YtZs77ja1JzdNAYA947jJkRVFikPlS+Q3Wkh5d/QGoR6+AE19hc/pH7FZncy4uDwn4eKAH25u9z449V9lk9T7uinzuqYIx9JrLmZZ18Uw9AWt+EK9t7yl8FgM7CcKGUoXBKPPr7TSWnYomMeo676tW4KQMRdvgET5IXYiqSCtEvbuI0qa1Sknn+p70bazE9cT7gqBk5Qi1O9ClobeldDa4uS9LT0STkp5O2r3leEnAkO/I0Dng7mBl8fA8ESHExBtqwplivR8AmxHfi1GXqrD/TSjJ5ZqxDmsNvXiuV32e7l6v4nayLLIjkwrPJ1cdOBkZjZ2Vkp8nhZW6kbQYKwKM+TVlGaMMv6VY08Z4hSsBw5hRLx8WPwfTDsLxL1lt6M1w93h6dBzB9cRcFh6N4lJsNiqlRAMvR75uEY9Dxi2R/XV6gctx2aw4HQMI4o9r6iku3LmGndSclv0mMe9AFBfvxNJQlUfbOi5ERd8DTW2UVg6Uq2QkXEQ+9B5WiRe5V/AujyjOQuqW0seVVoS79mVxwljUKiW7ryWjUki0DXJjfPvA0gBZFko1tJokjsOJr+C3eeICH3dWsKKDe1T9XTwAkiTh72ZXrTjDvxIZkbDDNHLVefb/dAz/afgvSFYHs3ZkDdDczxlrlYKMAi1R6QXU86rkx+lsCpI5vy9IdqnvQeQFU18z9yGCpKOPCJL5InB1b+jF979GcSwivXzZysRsrKyU62pvRbHSGoxwLSaN7mWnQMzqRGobJEmipb8L/hGmfq5rHXGbfgdy45CV1pwyNoE8jVhMuPiDsx/S6seoLWUSbfQmcPhP8OuHGE9+w9O7NFyNE5meY2h/fmr2DFZKBQtcN9G8IBqDjSt1Z26nrkuAcMTYNlOUEP3awNR9sGYkbJlObp8vWZtVn9XnUyw6lg0VMr5OKp5t5oN73FwoShXBY8RP5UQkarvYiovo6e9Yr+/Oj+onSIooJKYgnjyNjkHNffF1sWVcuwCWnbjHDy4v81JQLDYNB3Flz22a1HamUS1HlpyI5pM9t7A2FvON3SIURlmMxtSvxnj23m9wbSNGWeIN3XSe6FZPiLpXhrv7BFFFac0e7xks3R0NCKKORUDdoBdBoqzZsiyz7FQs17J9ma0+w1fDG6DcOhjaPoFs54Z0bRO2jMexbksAZq29RK9G3szu0wAHaxXfHYlgyJZ8Vig88W8/HZ2VE69vPYEsw4jQ2nQOcoIfX6a+lEusXIv4m2d55NYSXrWOQSmBnCDEFnWLGqBuMxV96GRUslaITZxfjIRMgWyDvaRF6+BLkf8grAqTUKbfRtIXIafdpLV0hwHOiXTp3p/6rftYynwGo8xb268xqUMdQnzu031VqqHbK0I0YuuToky4ahi0nwW93gH1XygA/n8Z2iLYOEnMPQd2hh5v/d3v6A/Ff0GyOmTHlg5gPQDWKiVhga6cisrkdFRm5UHSPE5SmCZOrId0RO8Q7M4pRJAsyoilxs82D/Hmix5rqL8LTjYqcop0XInPLrXLMfcai7Iq7gNQW9tCMdyIT6N72Qf0Ji1YpVAUaunvgn2kKUia3RoihTWVMbAzmpvWoDOSW6wTlPVzi7CO2k+JrOI1xfNsOPwuxgtLeWqXhp8viRLr8mG29PxsLncNPnQoOYntNpFNKEf8JI6rJtfkGJEmdGDHb0ZjlDjUciHe+2YQsn0Gt3VTyTC2xcXOnqkt7BndpgVnojtQeGUrI9JuYm/nKuTx7s/qUm/ADiHKfNZjBKNbNKJ3iDeHb6ey/0Yql2Jz+HFiGCNa+eFko+a1rSVctQolcd4RHGxUvD2oMU+vucTe66LMvthnO7WyU8Siqd8nVX9vOg25m5/DGVhp6EObjr14rX+jyqsUBh0cEMIBaY2n8sJ+8R0+16s+/Zv6CEEFtY3I6u9TkorMKOLTfbepJ/th7+KBx+m3BAFj4Oew8wVRnnXx52y6FYdupuLnasuzPetZdGfr551l1q5izlq1wr/9U6w8HcvtlHxc7NS8+UgIXFwOGXcJsPdksuIoPW8vY62xJ5HNnmdU97ZciM1m0/FwnvCKo/6h91ClhEPkEShIxihLXHDuw5fa4YSXuHA1ty4Lczvg6WhNv8aeDK2jp1XWbjadnQ+FhbB7CSSME0bfCiXLTkaz7lw8Wy4lsnxKm8q1S2uHwYxjop92YSmc+V5YOk3YUn2G/x9MZK2XIO2GaCeNWlKBHf9/Hf+uT/OHQiFWRgWpNbZ16RjszqmoTI5FZDCxQ52KG9i6CmaoJkesWu9zY38QHG3U2HgFQxZoUiNqHiRdTBJyWWLuTaVU0KORFzuuJLErPLk0SDqafBWryKBtnD2hOIq42JjyOrVmcpBJJKF9XXcifhX9S73KQZxkptdW+oXhkyisv+6mFtDWMQsOvgPAp/oxPGW1DeOFc8zcpWGRKUCuHG7DhDBn8PLAL/kC7DApw7adAQ36iRGGVSMg+QpGW3eOtv2ZX3bG8OvNRLJLAGbysUrNF1Y/M7m5J006DkS7eSb77zbi5cxBuFOP9ja1qP/odxUtmPJTYe1jGEsKUdTtyvxx41CoRdmyYS1HnI25LLmcT06RFhdbNcNCaxMa4MK1xFxs1Uq8nWx4es0l4rKKUCslfmydTMerO8W+h35XravFpdVv0KoollTZhay2r/D2oJCq+1MXlkJmBEZbd8be7mQxOX6hV30oKRDHuEF/MQtZJkAajDKvbL6KVm+kTnAD3DMTIPwGPHUKirKQwtcB8Hi/9rx0GnZcTaKwxICDjfjuZVmm/t2fqSu1Ia5WP4oU9vzwq/AkfbV/I9ztVCLoAIoerzJt7xe8o5vCDe+hbB/VCZQKnMnn8gk9d0KGUj+oLprdr7Pc0IdJLlY8nz8JfYaGFhwjmbZMU+2mkSKBLUVdWXOuG6vPKfB07MjPI8YQGrtczF5eXSv6j4O+YlhobY5FiBGKGasusvmpjhWUeADRnx30lSCZbZsp9GbXPArjN5UznP4P9+HCUmEgLilEgPw/ZIFVU/yNmkX/cLiasr70OzV+ipmKfzIygxJ9JYo4kgReIQ+937Ko2zgMAKfC2JoLCphfM+225a6hLUVA3BWeLMyUoZTgYjG3LQ8HH/G4tyGFAzfKMH/Nc5OmudKwQFcUViJwJmTkmB7LsGzbzDRvGB6fLcyU9cUU1O5CoJRKV+M5nvzlvgDZyiSOnXYLNk4W9PLmj0H/uWh0Bs7G5RNdbEu+5MiQvJeZujOTrZdFgPR3thKjB8+tRN3lBVrdmIvVqkEYNPlctO3AL1ZvoMGKI40/RB9wn2i7thDWPQa58Sg8gpFHLbcESFmW4ezPDDkxnMeUR1EpFWZ/FgLd7RnY1IeYzCJG/HCKuCwhGbd9Yl163TXp1XZ8Dup2r/Q4y7LM6h27aRazHICzjV5n9uDWVQfI4mzLXNqPiseIyldSz8uBrx5rIVie258yZUg/iNGQMsSx5SfvcSlOsHLfGtEOqeEA6PO+kJu7uExUCWo1x6dxJ7rU8+B0VAZXE3JYdPyeKJen30YXc4Y0XHGo04pVp2PJLNQS6G7H6DA/uLtfzE7auBAXMAxXYzY3jYEMaOZjmQXNKCghMr2AUC8lnFiAApkNxr60y3iTvoajLLP6nNet1nPUZg6TVIdpq7jDp+pFHHP9mG72saTnl/DYmih2+z4LIxYBknjvhz/Aw8GanyeG0baOG/kleqYsO1e1VRwIg+lJ28HaWfSfVwyuOUnu/zdEHyuVKOz9nhj7+Rfiv0yyKrjVh6JYyLhbY+X6xj5OeDhYk1FQwoWYbDpVVtrxbCTmttJv/a631SmsJQXHhRxXdsIdXAObPvhJnsLGqOxrdq7nibOtmvT8Es5FZ9Eh2F1ookKpZdZ9kEz9xQBFGlsuJTAs1DR+YGbtmkZmlAoJPw9XSANN7AVhqZRocg+xdaW5nzMHbqZSFHEM4s+AypbcoAFMTHidp3ZpWHK5TIBsaQ9j1mA06JHWj0cy6ojx7ssi+SluLDzDjaRcdAYZNU/gL6VxT/alrqc9vRt50btxLVoHuqJAFtlTr7fh2iYkOzeKgh9j1rEP8FNkMLqekY3xzgzKLxH9RxDCClumIydeRrJzg3EbkUyScrIso9Nqybi4ixKFOyNsL+OQcwe8m4DRSEKuhpc3hXP6npiH7dPYmy9GNMV5y2iTQXGLcgbFZWEwyny48yrDLr2FWmEgyr0HQ8bOrP77Pfo5FGeTqK7D/MwOuNlbsXSySfM15qRgED/yhfgOwjeIc7rZaCLtQ/ls/10A3hjQCF93Jxj+IwCZuQXEntiPwdgQ24bP0FSl5Nle9anv7cD8A3dZdTqW01GZNCi6zD3dHLLUtRjfrRldPvsVgGd71hdB8OxC8R7DJvPlbwmMlYOYbnOEL08FUcvRCn9XW378NYLxrbxx2f885CVQLNljNOpZYjWfNtIdDCjYYehInOxFiuyGBznMVO/Bv/gWK3id454DmZ7+KLPWXiJpYEueGPSVcJ448SXYumDT6Xl+nhTGqB9PE5lWwMQl59g0o0NFmzIzfENh0jZYPUq43izpIzww/zN6LkVmFGyYKBaszUaLRd+/FP/KTPKHH34gKCgIGxsbwsLCOH78+MPvxJxVpdU8mCkUEt0bCkeFw2WEmcvBnNWl3nz49wTUdrUjSSUIQDcun6rZkzwaAJJQ+jFlEVYqBf2aiF7l9suJZbZDkHx0lay2TReJYCmJk5EZxGWaNGjNJZbcRIsNWB0fEVDUBUloC3Mhz6ScorSmmUmhKCBxt7iv+aO43ljFi/s1bLhRJkA2t2KB4xy+X78Dw6qRSIYSDhjC6B07gTXnk7gSn4POIOPlaE3f5v5MGtSbX1/qzpGBBbyR9yFtAxxFJqVQCA3bLU+IcYpGg/E9/hp+Ugb0fIunHxvKvYxCzkRligzRaIRfnoM7e5BU1jB2PbgHU1iiZ/WZWD7Zc4seX50kKqMQnU8YHrbA2R+RdRo2XkpkwIKjnL6Xia1aycfDm/LzxDCcLywQK2+1HYxcYjEoLguNzsCz6y5hc34hLRX30KocCZ68sPrvNv2ORd7t9cLHUCrV/DwxjAB3UzFeZS0u+g0GCOZm2BRIvYHx+HwOr/wIW30uXep7MMb+Epz6FoDE7CKeWHSE5/PG8rbhCaaccOOVzVfJKtTSv6kPK6e1ZUybADzsVJxKhhaKKJYN9WTThXiyCrXUcbdjWEtfITIRfQwkJakNJ7LjahLv6SYzwPoaO6SXcDz4EldWvszYgpW8kvcJ9tF7kYEPtBOYY72Ttoo7FEq2nDA0obEUy0TlYT5WL+Ul9WYW6fqzxSAyly75e1gcKEZ+Pt5ziyvew0VmA8KbMzMKFzsrVjzellpONkSmFfDBrgf8/mqHwbQDot+ddU/0u0seTk7yX4vibHE8NDlivGvId/+Keciq8K8Lkhs2bOCFF17gzTff5PLly3Tp0oUBAwYQF1dzpipQ6iyfEv5QTzM7we+/kSIuuPfDp4W4Tbz40L6SZui8WwKQffd0zZ5gZSc0UkFksSaMChPBdsfVRHKLdeDkK5iwRr2YYbwfpnnHZopobOVifj4u+ox4hYBCBQUpYu4MqN1QsCcVsp4F9s+VirtnRdEuyA0XOzVOunTL5+n25XVySiDyOQcM7zgyvpkVCUZ3hmcvY5Z+BWrJwE5DR+Y5vEq3hj7M6hHMt2NDOfpyd86+0Yvvx7ViSsc6BEUshw0T4M6eUqNXy/sPg9AJcOQD8f+Oz2Ho9CKejtb0DvFmw/l4MgtKYP8bwqRYUpAxcBGb0nwp1hqwt1bhameFVqfnzX516RJoR4MhryA1HEBJ/BUWfT+PVzaHoyspplWAC3uf78L4doFIkYfFmAGIWbxK5jZzi3VMXnqOyOvnmaPaLL62R+aJecaqIMtCPcao56ChFceMLfhsVHNal7VG8mstxMPNurRtpsHgr4kqsKJD3j5ettnGN81jUOyebbFUe2rNJeppb7PZ6j2+7lDE4Ja+bLqYwOBvT3A8Ih0fZ1ue712fr1ql84v6dV5wPU1Qyx5sMBn8Tu0UJLJIE1mLgA7sS1Ajy2Af0BKr587h0u0puvkaeNInigE213HKFa2Avere/GZsySCFOE8vGYLpprxGI0U8xfnZHIvWkpBn5Hn1NvYY2vCNixBZ75K1lceaiHNsw/l4MYYQ1A2QLfO5tV1s+XGiaFdsv5LI3dQHDPt71IfHD4hefcZd4WryO3+z/xrotSKDzIwEJz8Ys/ZfzwL+1wXJL7/8kmnTpjF9+nRCQkJYsGAB/v7+LFz4gBX5/ajVTNymXBe0+RqiWwNP7KyUJOYUE55QiXScTwsRUArTIDfh4d6TCX7NRfnXt+AasZmFD9jahMBO4jbmpOWuNnVcaVTLEY3OyJaLCWI1aNnuRMV9uAaCSyAqDLRR3GHThQQRVKzshZ5nmf0r6nRCRiJIkcrOk1eQzZZdSZewUSsZ1coPNykfoyzTcsTzXIgrZPkVHQej9BRYeXO79nA8rbQEKtKQgbx2LzHw3V0cebkPS6a25eUG6QzOXEbg3eVIMSegOBf2vCwCHDKETYU2ZayfFSqRdZ1fBMBuzyeQe79vWQE/36s+52OzuLbru9IS4dDv+Y0wvt11jl+uJoHRQL8m3rw/pCkDQ+uA2g5tXgo/ZbVkU0otWmTtZa/162yuu4dNM9pTx8NekKC2Ti99Ty0rynTFZBQy/IeTXIxOY4HVj1hJekGyaTm++u/0zl6IOkKJrOIj/QSe7VmvtAReFg4mv0ijEWSZu1IgjyROZYehI/1dknDd+7QgkXWezdl7mRi0xbxW8g3eygIadnuMx9r40ybQjca+TsxcdZE918QokeHmTlSSEUIGc91kP2WlUlj63USZFJfq9eTgTVGK79vEW5DXOj2P9eQtMPM4zDA5wgAbC0OZYPUbSllHrNGLrsrrYvzllDWBCwroubKIwAUFLLtUwtfq79mV6kqOS2PQFfKszT4Adl5JJLdIVyqJdnG5pX/f0t+F/k1qIcvw5YG71R9fEIuUUUvF+7u20SLq8P8ljEbY+Yww+7ZygHEb/s/aXz0M/lVBUqvVcvHiRfr27Vvu/r59+3LqVOWlyZKSEvLy8sr9AeAaJE4EfbFYRdYQNmolPRqJHt2e68kVN1Dbit4VCJr574Bz/Y4ANJWi2X4humZPChTPIbb0OEiSxIT2gvm6+kwsRqMsbIWg8iAJlv7sUOcISvRGi7u85XmxpiBs52b5nO0NF0vF0xMugCwzvn0gznIeT+3ScDNJlLH69uzG2Hk7cWzci5CkbVjr80FSIHV9Bad+b6JSKUXp9JfnTXqtN+HWL6I0uqS3KQBKwtx10FcW8YBrMcncXfgoXFyKUZZ4U/c4s+J7cD0pH6VCQpZlmvo60dShgO3Xsog3erK9+UJOOfRlcOQ7/GL/If3qCBcVlQQoFMjaQgqSI5ix+R5zj2YQb3QnVHmPBrb5NB3wJEql0jQ/NlmUp3xDof+8CofzVFQGQ78/yb30Ql6z30VjKVqwoAd/XX0JS6ehZLfIohYbBhLWMozZvSuxMCsLhQK9UebVjZfQGoxE15+KW0hXwU4eLTR1rdVKUrILuCf7QKNHwLEW1iolsVmFPN09mC71PTlyOw0MOpR3TOXyxkNZc1acB/2a1BJjPQadKLUCebW7csbUn30s/VvY82Kpp6osi6wkNw69pOa8sSFTrERfs5YkxliS8g18eqjU9cIow4xdGnLyi1iins8XBUKmr/bdVbT2lCnUGlh9NhaaDBeCEnmJcGun5TDM6dsASYJ9N1K4VtlC9n4EdoBHTO4nx7+AMw+54P43wCxUEb5BLDhHLy+tTv3L8a8KkhkZGRgMBry9y69uvL29SUmpXApu7ty5ODs7W/78/U0D/wpF+dLoQ2BgU1Ei23U1WQSe++FnGuSOO/NQ+7XArS4aa3esJT23zx9BV8YZoEoEdgIkMc9URm5vWGhtHK1V3Mso5MDNlFKGWvyZyoXYTYzMftI5FBhZfPweKbma0ufd3gUasdCQgkRAnaw6gF5WYFCoxQXr0gqCPOy5mWZgxVXRg1w81IH9XS7DmlFCMgwE4cjZT0iUmccWLi4XjMkRi+Cx1UI5pTBdLGTUdmhHLueS3wRWnI5l1tpLDPtwJaqlfWmQfhCdrOR5/TNEBT7K+0Oa4OcqSDqywQC/PM/44rXsNHagr+Er3r3mQX5uFtbJ53F2sMf5pGmeUaHgenwWY5aFsz/Hl/icEhbYLuUV682o6/VA6REsFiKyLMpzSZdE0Ht0ZbmylCzLrD4Ty6Ql58gt1jG6VgrTjCYlmYFfPJBKn3XoC6zz40iRXblSZzqfjmpeuTD6fVh8IprLiQU42ij5tKsV0unvod/HFgkxH1uZusZYDhrCOOU7maScYqavOE/3Bl6EBrgypKUve64lk3LrpOhJ2Xmg8WnLL1fFgnB8OxMrPPWGsISzceFEgS96o0xDb0ecDdmiL2wR05csff9IqQ426HDVi36+taTHKEtEZBq5/2dkkCEyy4i/Ip2bhY4YbD2QdIU82Uj00k9HZYrjbc4mTX6nAA28HRnUXGS728z9+Aeh9VRRtgYxj/oQXIV/BY7PF+xogKE/lJoW/H+Af1WQNON+qnyVMnHA66+/Tm5uruUvPr6MGo45mCWce6jX7xXihaO1isScYs7FVDKYb8nWTlZ8rCaQJNT1hXdic8059t+ogRasvYfoT4FQZjHBwVrFlE51AFhwKAKja11hbWXUw42tFffTcCDYOGNXlMhU7ygKtQY+3nNL9H/c64uh/ovLxbbtZoLKhmaKGIqwZqlxkLh/3xuQdot2L6xg/WNOrBxuw7SW4lQsxpprDp04XPcVtDnJxITM4EZKAZFpBSTGR6O5vIksv17End5M8RdNxXhDST4x1g150uZzQtZZMeKHU7y78wYl13exxvgaIYo48pQuHG23iHdff5v1T3Zgcsc6gt2oLaJwwzRePmvNO/qpNHc1MG90K66+25d+wbYi2IUMhqQrpPz2M8+uu8zgH05zPjqDzorrHLR+lcEeSSinHUB6bJU4dpdXwa7nIXy9KNONXl7Ol7RIq+elTeG8tf06eqPMY82c+JSvkWQDNB0JzUZV+1Wmx9/F7uzXAKx2ms6CiZ1Q18CB/lZynqXE+PagJnjWrisWIGFTLNt4Jx1ktHSEI1JbXjkpMWrhKTwdrfl0lJjp9XS0pp6XA7p7pnO3Xm9ORGVTUKLHx9mGtuZ+qJkh7dWYm8miUhAa4AKProAxa8rPHpr+bafUk4kTxdaiPJxsdEUhydRzU3B//FdKUM9NwWFDKHm2ASiLxZhGnlNDAGytTJq0DqYF831EtN4hotpzMbZy4YxK0Xm2OP+NOtj5nCg//v+AC0vhiGl0qd8n0OKxv/f9/MX4VwVJDw8PlEplhawxLS2tQnZphrW1NU5OTuX+LPBvJ27jHy5I2qiVDGgmMoEdVypZqQaagmTq9SrVbR4EZQNRUu6uuMqykzE1e1LDgeL29p5yd0/vXBdHaxW3U/LZdyMFWowRD4RvrLgPta2lV/a8yykUEvxyNYmT97KE9RDA6e+FVJ1zbegglGpsJR2LND0JVzUTYuvLH8HD2YlHFkbSZPYm5gavpo1xGSGapUzNmIAm4jeulXjR/dcgHvnmOL2/PMozP+xAij+L+uZm/C5+im1hAkYZThia0iv3LQ6ku2AwyvjYSyz02sZiq/k4SUXIfm1xev40vQeOxMPBuvSzFKTBikHId/fjpiji554SO14dJpw1jEZxYfVvR6TPIE5q6pBz5BtOXL2NLMPQFr6o+3+I1PUllFN3Q+1WgknaaqLQib0oypcM/LzcPGRkWgHDvj/JlksJKCR4tV9D5lkvQ5ETKwLpI19W+xVm5GuIXP40Nmi5rGjClCdfwt7aNMllLmlXghK9gdnrL6M1GOkd4iVmGK0dywmJA3BlDY+qjrK4Yw4fDm3KTxNbs3hyqYTdlbgcCkv0+CSYFlr1elnaCv2a1CrNZs0tCo/63EwWlQWzObn5vV64l8rZe5kUKkSQdJILAIlYx5YAHDOKwOzvrGBqtwCLoqtCgp8G2eDo6sHLuhlM9jf93j1DyDQKEXlH8zExZ+/68kHSTG66niRcO2oESRJZvpWjWDib+tv/alxZB7vmiH93eUkYpf9/hn9VkLSysiIsLIyDBw+Wu//gwYN07Njx4XdoziTTbz90MDMTKHaFJ1vErS1w8DTNLsqlPbyHRXAvZCRCFHEkxkbWrLdiDpLRRy0lUQBnOzWPm5xLFhy6iz5kuFDQSDgnhIvvR6tJADjFH+bpVqJk+fb26xQ1GiGYgAUpIkhocqHzC6C0xgodL9jsZVLBLGKtG4hxlBVDUMf8SmjnR3h94mCOvzWYxZPa8GWzGNrZJnLSfRSB7nbUdTAw3PYy76pXYYUOR0mDQoJTVh3Y4zKWZjZpLOyQx5LJbbgwwZZTbh8wIG+TeK/tnkKaukcwd8si6Qos6gWJF3Gys+X16RPo3neo5WFZkjgbX0DS7bMMWnaXBelhJMgerHFbzC3/T/kqNAW3No9Bz7fKux0Y9KXl4vZPCzYpopqx7XICQ747wd3UAjwdrVn7RHuecj6FdH2LyDhHLqloQ1YG2YVaflj4NR0M59Ghota4H/BwLMMsPPuTcAGpJFh+dTCC26kFNLQrZIH/caTK/Ehz4pGjjiLLENhhBD0aedHMzxkHaxX5Gh2bLsSz4NBd3ujhgyotHJDQBna3kHIs5sxQJkg24GaSKUiatVNv7oTNj1OyeizfL/6JmEIh0OCoz2Kk4jeuy2Jet5kylvX67gAs7pZD3GwHfp1sR+wLDkxrZcUb8tNk4URvhWkGN7AD2UUmnV+TIpBZKhGdptxHre1iSwNvB4vgfY3hXBt6m8uub4nj/W/FlXWiUoMsvEd7/rs0WWuKf1WQBJgzZw6LFy9m6dKl3Lp1i9mzZxMXF8fMmQ8YyK4MDp6lA/axlRN/qkL7IHd8nW3I1+jZWxmBx9SvMztjPDTs3ZH82wIwUHmOhUcrV8kpB8+GYhbSoLXQ4s14vHMQzrZq7qYWsPaWFuqZRLfPVkJS8AoRPU6jnuekDXg5WnMvo5A3f4lA7vyC2ObgO7CoJyzsKF4PGMcePlYvZ3DuS8Qq/KAkVxi0Lu0PB97B5s4OejvE0DVjIx7+DXkuzJqjwes5opjFV/LntFRECi5LrebwxBE6vrGPQU9+jLN7LfraRdLr9nt4bB6OlH4L7DzgsTUwYJ4QsjZDlsVoyNJ+kBsHbsEw/ZAgZyBGMVafiaXvV8f4aNNJMrVKSiRrvJr1oG0DfxqXhGNrLBSklvtnHdNui/kxvQbq9xMEIiCnSMsz6y4ze8NVirQGOtR1Z/dznWlvmygYuQA93wTT91kZcot1PLX4CDMKRV+oMOxpfOq1LN3gwNuC2bttpugLl5SON1yMzeLnY2Jc54uwLBzOfysIGPfj6npkQArqUipMb0KRVhgDz+wWTC9rUz/OuylXs1Xka/S42qktxuCAZR5XdvYjNV8EqAA3O7i5w6SyVEK22puv1D8gRR4EJJQY+Fy9CE1aJEalDY2lGOpIKewwdiTLJgBvNye611Hh56TgR+NQ9hY14hWnA/hEi3NZ22AQO02Vm4ZmQXczn6CSHq9ZjjGmpgxxM1pPE3OnBq1QnPk3joVcXV8aIFtPgwGf/6tnIavDv05x57HHHiMzM5MPPviA5ORkmjZtyp49ewgMDPx9O6zbXbDvoo9CyKAaP02hkBjTNoAvD95l7dk4hof6ld+gQT8xBH53fwXB6Rqj6SiIP8sQ5UmGXx9AZFp+5cLqZkgStJosWGoXlwsyggnOtmpe6tuAt3fcYP6BuwwbPROniAPCoLf7G2BSm7Ggz4ewuCdW19ez5JGxDNumZdvlRFr592ZinS6CJg6iRFOcBde3Qko4jyjPUKx05FdtY0YpM7CVdCjjzwiiUFlkR5eOEIDIUGs1g6SLwqvOzKzLvie+n9QbQogbxKhFr3cq+tkVpAmh8ghhUUWD/jD8J/RWThy/k8bmiwkcvJmKVi96TYFWnijd6nBykD++p98VijVB3QT5KPGSKLEaDcKTMStaOEgUZ4l5zNHLQKHk6N10Xt50lbT8EpQKied61ueZnvVQluTCpsmmgNoXOs2u8mvL0+iYsuwco9J/xluVg9a5Li793yzdIDMKIg8LRm/0Udg0Bdo+CW2fpMghgDkbr2KUYWQrP5r16wN1a0OjQWQVaonOKMRGrUABhFxdh0KSMbYYh3RfH9/L0ZrHOwVho1bC/uXiTv+2giADdAz2KGeCTHE2ABqVE7IsSp0ONio4v0S8t26vcnLnbbZeaMyP4fMhuCdEHSbeqi6dS8L52fVFZuR9TXvtbc4aG9Et5x3yscMaLXYU00Zxl+OOb1Jba2JXd32FBfdqk5QbRS0nG0a0qi1m+m5uF483HVnhuDpYi75lsbbqMnWlUCiEgtG938Tc8fUtD+wj/5/C1fVisYUMrR8XJebfc336l+Bf+cmffvppYmJiKCkp4eLFi3Tt+j9oCpozvjLsuJrisTb+KBUS52OyKw4u1+ksRkwKUiD58u97b02Gg6SkpeIeAaTww29RD35Oi7GgtILkK5BU/nXHtQskxMeJ3GIdc295gk9L0cuprPfiFyb0U4Fm1+bxWj9BmPhg9x2utpsvCBPZ0YLB2+kFMQ835DtAYhQHGWBzg2/1w+he8gXf2T9DVOBjGH3FoDdqO/ANE5+v82xheTX7hmCIyrLIgqKPwdYZsLiPEFaXDRDQEaYdgsELKgbIO3vhhw4iQCqs0Ladxb7GnzF7ZwxhHx1i6rLz7A5PRqs30qiWI28PasyeCT40zj2G74Z+ovw866xQcnGsJZir5gCZlwwrhworMq/GMH4zOXo1r24OZ/LSc6Tll1DX055tT3fk+d71hfHx1ieFkouzPwz/qcqLUFahlnGLzqCOP814lVCVsRr+bfkB7uIckYX6txUkoZGLxeJm4yTWrVlCamY2Ps42vNdWL8hEjQYRn13MhMVneW7dZUYuPMVr688wO6UvccpAFI2HWAJkZFo+4Qk5SJIkAiT/r72zjo7i/vrwsxt3VxKSYMHdXYprKd5SaIEaUKNGvb+3Qt0ohbZQKKVIKbQUaXF39wiEGHF32Z33jxslCURJoPOcs2eTldnvzu7OnWufi4h/A3h24fA1KZjp1vCWk6i8cWsZBuLRaTVgZmQgOq71OoChMW09bTmub0q2Ygjd54LWEK+ca9ho0vgr3JJfG3+FYmJFF+1VzpnO4rT5XDaYf8Qas0/4wfhL6uUES+Xw4A+55PsMS/ZfB+C90S1krYE7xVhbupaqK2qWJ9Cfll3+PugCbDygV16ubsfbovN7P3B0MWx8EunrnQ7DPv9PG0i4T41kteLTC9BArF/FZjgCLtamDMjrmfz1aHDxOw1N5OwZ4OqWyq3N0qmgb3GM9hB/nb3JtZg7SGdZOECzUfL3sR+K3WWg1fC/0dLbuOZkKIGNJZ/G0e9LbwcZ8A4YmkHIEWaa72NYK1dydAoz/ggh/IGFYljO/Qa7/ifGrf1UmRRgZodLbjjzjdawxPgbAhL0TPXrQcfI1/i06xECH7uAMmuXHPAfeFdCoRnxEHwQPDpLKfqKkXLAR5EQ8rTN8Pi24nMSQTy81VNg9SRIjyXRxJ1MRUPosY18uvZfNp4RtSEHC2Omd/dm89yebHuuFzN6+mDRpI+cCPR/U0K3Vq7iwbZ9WIqUtAYSVlwxUpSG7HxQHtnAn34ZDPh8H2tPSqX09O7ebJnbi9Z5cnzs/j8x1oam0sZSxgT36ORMJi45QkB4LJ+YLJUb208rrI7Ox72dFEjl99+2fAjmXSUSe6YGv86zhhtZMtAYq7+fFDlEjYanfj1FU1crVs7ozJZnezHY7AoR2DNd9wZ/XSnMVy47dIOnVp4qyCuSmw0R5wDIcuvA6eBEoDQjKdvIL8oxNzYUw2vuACk3Qa+njactHppYtPocMtMSocVYAKwMstGj4a1T5nzi8il6aw+0KNjr42ih98NXCZITqV4vwXPnOOk2mceWn0KnVxjWypXBLVzlxCG/IrPlQ/JZ3YKJYV5FdXYlq1S7z5Viq+TwkupO9xqKAns+hH+k95bOT8LwL//zBhLuw3BrtWNmJwU8YceldSKvEKO8TOvuzfbLUfx+MowXBzaRRut8mo+WJucL60XwujIx/zZT4NpuppnuY2HaGD7edpUfHu14++d0fRourhePrM/LYN+g4K5O3vZM6OjBupNhzDjuxm6n5hjEXIadb8Po74pvx6ae5NK2v4nmn9f47JHN3Ii15nJEMmO3mrCp+7u4HHpbhKaTb8KwT+SA1egBmUZxdBHNs4P42ljybNE6W84dasiZgxb4G4GzpSGupjk4pQVgkn5Lm4uhqRjHDo9Bp8cLbk7OzOFmYgaRsXHYnFxIy+BfMFKyyVW0bNZ1oYE+klP6vowyOMxzFjvwb/USvVs3poOXXWG4UFEKvcTR3xUeYPNni7Z8SK4TQyXEGhcINp5cG/ob76wL4WCgeFeNnS35cGwrOhWViTu7WvYHwMhvwL1tqR9RaHw6jyw9RnBcOh+Zr8dbf1M8ooH/K/lgrRYcGxVb+/VkGBExm5E6X/5n+hsm/+6UPO3QBVyJSCZHp2dO/0Y0cLKE3GyeTPyKLoaOrPf+gCX7rqPTK4xt78GAps542pkXVqbG+kkuztSGyxn2ZOv02FsY08DRotT3YWIkB9msXJ20YvkOk5MuIwuaODXjY7OV7M9pTbtdX2LaqANotBjqs/nK9xIj/b343t+aHU7f8b+xrrQwT8ImKwIyk8hsMJATsUbs2RHOL0dukKtXaOJiyXujWopX99tEEZuwcJLveykE5EV36ttXbK5rAUZm0Ptl2DRX0hfdn70383Z6vcgb5mkA0+9N6P3SvfleagDVSJYH36FiJP22VdhIdm/oQDM3a65EJLPqWAiz+zUqst1hEnJNDJY2k/pdKr625qPgH0fs02MZaHCGfy4bcPR6HF0bOJT9HI+OYqgCd8L+z0T4ughvjWjO4WtxBCdk8J3LbJ5ltmiZtn2koMClgK6zpajJbyvmfzzCqin/MGmtgl9UCgMPNWVT1/fxPvqWeH3Bh8ToNOgjxrXLU+IVBmxHibqEM4kMNMgrtFCAlLxLHtcVNy5rfTlg3IMLJu0xzDUl97BCxr69pGfnkpqZi1F2IlMNdjDd8F8cNPLkg7oWvJs7DRdzeMTmAuYdniHbOICRW6ah8R4H9TtQrBFPo5Fq09ws8fjzDWb+QUOjkarfX0ZDchg6Kw8+c/mMJT8HoVfEQ3l2QGNm9WqAsWGRM/GQo6IOBNBrXpn9ZhfDk3hs+QliUrIYZXONyVmb5Y5R3962+jV/bVmKhmdXnSQ9W0dwg4cw6tIZNj4BE38BJP8clZzFwcBYMZKBOzDISqCDtQl2w7rx6fYA1hwPZUzbegxo5kL/vGgIIDKNAC4tOR8u3mVrD5uSfcgGxpCbiaWhFLXk6BQyc/SY9XwBEm/A5hfQ5mbi6NSDCaEzeTT9FK+H7kLj3ByiLtLsxkqONs9gQvAoAmPSmPKbpBJcra1wt3Xi0sZzZOUWeoAj27izYGwrLAx0sPoRyXGb2sDUjWDrWequOhOaCEDb+nfYp7ejxVjp+42/LimAck4MqjPkZEiBzqWN8v+wz6DzrNs/5z+G6kuXh6KtExWcBKDRaHiit7RXLD98o/icSWNzaVQH0YWsDIYmItoNzLOTYpkPt14pXemnKH3y+uPOrZEfeBGsTI34amJbtBr4ws+OG17j5Y7Nz4vhKIpWC2N/AOcWkBqF3V+PsnZ6czp42ZGcmcvgg4041udXqZZMCoVfRsGWl2SYsYWDjK966gCa+WGSexyygNz+7xDc4XX2+cxjuf1zPGv2Ee1yf6Z/1ufMyXiCtUktuBydxfmwJC5HJBMUm4pdSgAv6Zdx2ORZ5hmtx0GTQoyhG1uafkzGpA0sf2Uqv74xk6FPfMjEHs1x6zQaTbuHJRQcXWQiRH6lYuAu2PaqvN9bQ3UR56Q6NjmMOFMvHkicz/fndegVGNbKle0v9GZ2v0bFDWRsIKyeLF5Ys5Fytl4Ku65EMWHJEWJSsmjnbMCXJnkh8fbTZGByOfho61UuRqZhb2HMtyProf33NTm5c28HSBHOkBau7LkaLeH5/ErXVuNo4GzNK0OaculmEifyhDCKGcCoQiN5Ls/ItMkPIxclr6LYTKsr8NCTM3Nkav3o7+CVa/BaMA5PbMLCwpIfU7qxocvv8PQh6PcGoMExcD07TF7jtSZRBd5eZHImp0MSycrV42ptyvgOHiyZ2oFvJrXFIj1MZACv7ZZw7MPrCzWYbyE+LZvgvCk2bUtbf3kxsYTWE+TvPR/eW5WuKVGwfLgYSK0RPPiDaiBLQfUky4OTr2i5JgRJyLWClWwjWrvz8TY/IpMz2XA6nMmdC9VXaD1B+uou/C4tA0ZmFV9fx8fg0Nc0Tj1Be+NQTofBupOhTCr6Orfi2anQm9zxtuTGim7S255nBzTmq50BTLw+mEOWezCMuSol7yO/Lr4tEyuYskb6DqMuYLvuIX6d/Dtz/gxm19VoJv6rYXaPZbygrMTw9M9SCHRqObQYI5WOHp3khMGrG3h1wxDwyrv0AaYDer1CTGoWMSlZZOXqyMzWoUkIwjXsH1xD/sY8sYi+rmsr6PE8Ts3HMNzglq+4qbX0MuYfrL9sJXqcw78QVaJ8gxBzVSqPm40obIcBCNiJsu5RNDlpXFZ8eCTxVeKxpn19W94Y3qygraAYSeGw8kHJq7q3K7NQ55cjN3h30yX0CvRq7MhSm6UYXAwFWy+RjisHf50NZ/nhGwB8Pr4NThY6MbD5vX2AoYGWqd28mLniJM/9dpL/S/CntaLBIO9gb29uTD07s9Kb7PNPKFyac9FP8o6tPWxKPs5QCos0uRnYmhkRl5ZNTEoWLtamhffrcjDVp/N0V0e+3eXPZ5tO0NbDkoZ9XpFCm41PYZAQxFOpL/CUWxsyBjyFn0VnbmSY0bKeNQ2dLMWAh56A31+V1IWiFy920qrbttTky9E1cbHExtyozMeVi17z4Oxv4r2GHCnUSa7LxPjJvMykEEkpTfy1ZK5bBQCNUuo8p/8uycnJ2NjYkJSUVFx9Z+d7kkvyHQ6Tf6vwdpceDOL/Nl/Gw86MPS/1LZQR0+vgm7YyLWLM99B2SuUWvv5xuPgHQU796Rc6E2tTQ3bN64uTlUnZz4m6BIt7SWXow+tL6DHm6vTM/OUke/1iGG15ha9y30eDAiO+KtY+UkDEecnRpceBQ2Nyxy3n/ROagoO2j6MF33dLoumVhcWl/hwai6F0bycXazfxBIzMxSNJi5WBzqnRYrxCj0l4OrVIntLAWFopOj4uBVF3yqfkG8rQEzJUd9in8tyEG5I/rd9Vco358z8VhcRdX2B98H206Dmsa86TOS9Sz9WF5x9ozOAWrqVLH6bFwc9DJZfn0Ei85fypHHlk5er4v82X+fWojHOb0NGDDxv7Y7hxphQ/Td9aMsxdCn6B13h5xU7O53gwu19DXh6cN2y7jBajxPRsnl68lbPROmZYHafnpJexNDVix+UoVh0L4ej8/jLyqihftoSkUHIe3Uqzn5LI1Ssceq1/4bDqfJb0Fo97yjoe2mXFqeAEvp3cjpFt3MWrPr5ETtCSb6LosknFgkCdC/vN+vPY069ibesoucV/35CTlZR8vWENuLQEDTL5JTMRsgqFMWjQD/q8etv9lZKZQ59P9xKfls2Csa1ufzJZXv58Bs6uEqGNUd9WfXs1if92mUyTmST1CA+vB4eGtb2qaqPMY3glUY3kLZS5g6MuSWO8gTG8FHDn3NAtZGTr6PXJbmJTs/l0XGvGdyySJ9n/mVTieXSGmZUUF4i+Cou6Agqzrb9lS7QDY9q689Wkdrd/3r9vwJGF4ik/c7TEbLjkzBweWnSYgOhU3rP/l2npKyQ089jW0s/UY/zEa0oOl8rXYZ+yw2Qgb/x5kegUCdVO7erFS60ysLnwsxQt6bJKbqc8aA2hfjfxxpuNuvNnEn1VogL5xiw/17jzPdFbbTVBdCo7PiYalRoNer3CEb8wDDY/R9c0acFYk9uXVQ7PMntgcwY1dy1bWDwrBVaMEpFz63rw+D/FNFwBIpIyePrX05wNTUSjgZcG+fJMaw2aJX0gO0UO+P1ev+OuSEzPZu8XDzMqZwe/2z3OuGc/L963WBa/jGGFvxHfGTyMjY0dYQkZNHWz4uVBvnRv5Fj8sdnp8KGo6vg/eo5BP1zCysSQ8+8OKnmCsGo8BGyHkV/zSlA71p0M4/kHGvN8y2xYM0WiD60nysHZwJjkpAT+3raZcblbOWw9hD7PLEJrlvf7i/GXKumAnRB1oeR7MDCWz67bM4UVvrfhyx3+fL0rgAZOFmx/vnfJE4HKEHQAVowAE2t4yb9yEaGaRq+DfR/Dvk8ARWQ3J60u2QN9j6MayRrmtjv4uy7iyYxeBO3uMOuvFJbsu8ZH267i7WDOzhf7FP44U6Lgy+YiKv7UocqPoPl9OlzaSJL3ENr5PYpegRWPd6ZPE6eyn5OVAgs7SY9f71ekoOYWQuLSGbPoEPFpWayzW0znjANSaTlzR4mDPiCe34Yn4JoYFVo+RHK/D/lgT3RBW4SFsQFTu3nzREdb7OPPiiG5eUa8j/R4EZEuQCNVipYu8nqeneQH7t6ufAej8FNw6GtRe5nye2FuL79aNS0OPm0oczEfeBc6zyIoNo0/ToVx/NRJ3sz8lNbaIHIVLavsn8Fz0Fz6+rrcfupGZrKo74QcATN7MZBOvsUecuRaHHNXnyY2NRtrU0O+ntSOfg2tYOkgGfZdv5u0ttwaMr4FnV7h9R/W80HEExhq9KRO3oSlbzkKSJLC4csWgELSEycJzHHEyECDq7UpztamJR8fcR6W9AIzO9YNOMAr68/TxceetU+W4rX9NUdOPPq+zhLNOD7adpURrd1YaPStnJgM/1wKa4pwPiyR9xf/wqfabznU8j0mj59c0vgmR8jnaWQqcylNbWWmocltRDSKEByXxrCvD5CWreP7h9sztKiUXlXQ6+HrNhK+HLesVPGCWiUzCf6YKScuIDJzgz+Umob7jOo2kmrhTkXI/+Lna3NWkEe6emFvYcyNuPQCYwHIjzy/gOfIwsqvr8+roNFic+Mf3mwt+aJX1p8jMT277OeYWBXOOTzwOYQcK/GQ+g7mLJ3WETMjQx5LmE6YkbeEOpcNLZz2UBQLRwnhDHhbqkQv/oH1ko58bP83q6c2o4W7NWnZOhbvu0aPb87yrp8nF5vMRpmyTs7C346Ft2LhtRB4+Zr8/XIAPH1QQt09X5C8z+0MpF4vQu4/DxN5vMt/ARoxxvloNBB8BL5sgeLRiaApB1iU3o8x3x2i32d7iNy/lGVZL9JaG0SagQ1RY9Yw7bkP6N/sNt4jSI/eygfFQJrYwCN/FDOQOTo9X2z34+GfjhKbmk0zN2s2z+1FP18n2DJPDKS5g2i53sFAAnz8z1UGhy/EUKMnxWtg+QwkFPaZevXAxl3aYFp72JZuIAHi88QqHBpxNUIqh4uJlhfFJi9SkhhME1cxYJcjkiWc7damhIEEaO1hy+SxD6JHw56zAcz57YwMTy6KtVthntijo7S+lNNARiVn8sjSY6Rl62hX35YhLW8/jqxCaLXQ8kH5u6hSVF0g4rz8BgK2S3TnwSVyknIfGsiaQDWSFaHNJEAjkmsJNyr8dAsTQ57tLy0gX+4IIC2riNJH97zWgAu/S/9dZXBuBu2mAjA9aQkNHcyISs7i9Y0XuG3AoMUYCX0pOsltliLm3q6+Hcumd0JvZMm4lHncNPSA5DDRXc1rLi+GVisFDTN2iNZqdgrs/4Rum/qyufUhfh3nTmsPGzJydCw/fIMR3x5k4Jf7+W5PIH6RKeg1hnIgtXAsl6EAxDMMPyUh5K9awprJ0naiNYTWk6RyssjUi5iULA4Gp7LV5UkGJL5Bv8VX+OQfP66HhvGd0Td8ZrQES00m+vrdsZh7iHrtBt95DWlxIi4QflIKIqb9JfJ1edyITWPc4iN8szuwQCpuw9Pdqe9gLqHes6skDzlumfSh3oFfjtzgysE/6W9wFr3GEKuRJQc7l7mvzubl1subB8+vgrZvSEC0GElflzIMlGNjuY71L6gevR6TRpa9r7TC5H/H88dN6eS38KD2ALZWliRqbNhyIYIhX+8vGNhcFfb4RTPy24OExmfg5WDOkqkdyhyfV2nq53nUoSeqd7uVRVFEQeenAZJft64nghv5U35UyoUabr2FO7rqv4wWzcZy5opuJTtXz8Av9xEcly45mqLT5FeMlF6rLk+LMHdlSI2Gb9pDdgqhvT+n304ZePvJQ62Z0Kn0fjFAwq5L+oi30HgQTF5barHHsetxPLb8BKbZCay3/IwGuYGSh5mytuyqPr1eRLf3fAgxhcNqFfd2BDn2Z3Vic1ZeNyOzyDmDnbkRnX3s6eRtT1NXaxq7WOJsZVLywJYULoYw+BBc2yM9p/mY2EDHx9B1eoIIxY6AqFSuRCZzJSKFSzeTuB5TXErM2EDDHLcrzExZjHlWtBjXfq+LrF4pii0lSI6AX8cWNrFP/bMgdK7XK6w5Ecr7Wy6Tnq3D2tSQDx5sJYUsIIVIP+fNKnzgPZmecge2X4pk7q/H2Gw0n8ba8Ip9b0JPwNIHyNaacnjMYfq0anBno1EQQp1P18OdiEzO5I+nuxcXNs8n8iIs7iEnOq8G88CX+wmMTuWXB53offpFKbZpMUY8To1WinRunhH1qd4vcc77MZ5bd5EbceloNDC+gwcPtfegs499hYxbalYuH2y5wurjUhTV0MmC5Y91xrOyAgK3Iy1WwvYAr96Qk6TaIi1OhOT9t8n/vsOkmrsMdaf7CTUnWcPccQef/10qw6w94Llz5fdyirD5/E3m/HYGc2MD9rzUt7AsPnCXHGSNzGXbls6331BZHPwKdr4Dli4sa7uW/+28iZmRARtnd6ep622+NJEXpI1DlyVKImWMxjkeFM+M5ScgK5lfLb6kje6SjCQa9L70WZV1ENPrpCfr5LK8qSqFXz3FyIJYq6aczPbidLIV0bkWJGJFimKGiSYHU7JxMM6hiUUGDbWReOrDcckJxSY7qthLZGtNuWrdg2PmfTmkacv1BB03EzPILaNvtKmrFV187OnvnEaPgE8wvL5T7rBvCA/9KDqj5SHyoqi8JIeBlRs8ugmc5AToWkwq8zdc4HiQeOhdG9jzxYS2uOdXhCbcgJ8egLQYKUCa8Msdq3NPhyQw5cejTNf/yWtGa1DMHdHMPVn+A/Pfz8Opn9mg68nrzOHAK/1vXwkN8PNwCD5IxohFNFtvC8D5dwdhbVpKC0VOJnzgCigwz4+3dsWy8mgw07t7825/Zzi9Aq78Lb2zuhzJLbq0gM4zC1pu0rJyee/vS6w7GVaw2Rbu1jzRuwF9mjgVV68q+tI6PceD4tlxOYrN528Smyrphsd7+PDKEN9CDdqa4Jt24nFP3VgoO3m3Cdgh1bZp0VLUNOh9abX6jyjoqEayhrnjDs7JgC+aS8/bhJWieFNBFEXhoe8PczokkdFt3fk6vwJVUSR3cPN01bzJ3CypxI0LRGkzmUfjH+NAQCz17c3ZNKdHmQcXAE6vhE0yKJmR30CHaaU+7GpkMo//fIK4pGQWmX7HAPJCTI0GyhmrVelDrgtIjRav4crfEn7LqZxAdK6i5ZLizTF9M07ofTmob0kGJXNqRgYavBwsaOZmTTM3K5q5WtOuvi22pMLhb+DIIjk50BqJLmvvl8pfoRiwQ4qmslOlneWR9WDnTXaunh/2X+Ob3YFk5+oxMzJg3qAmPNbDp7DyND1eCnXiAqS/87F/pEH9NgRGpzJ+8WEsMsLZZfoqJkpWxdqHstNRPvdFk5XMlOzXad1rNK8NbXrn533RApLD8BvxB4PXZ+FqbcrR1weU/fiFnWSu5JR1bM9pwxMrT+FhZ8aBV/pVyBs8HhTP+lOh/H0ugowis1ndbUxp7m5NPVszMnP0pGXnkpqVy+ngBJKLhCW8HMz5aGwrujd0LG3z1Ut+pOnBH8pUVKoxstOl5zl/IIFTUxH6cGtzd9dRy1S3kVTFBCqKkZmo4x/8QobcVsJIajQa/je6JSMXHuSvszeZ0rk+XRo4yJnegLel1/DkUilpL6169E4YmkgF7rLBaM6t5vuxIxgaZ05IfDrPrjnLz9M7ld0e0H6qeDYHPpNJF+YOpY4Ia+pqzV9zevL0r6eYEfw80w2286bxagwDd8D33WRsU7NRZZ+9WjpLq0XHx8TDjA3Iq249K6LhGfGQniBhOUNT9IZmZGhMSNVaE2fiSaShBzc0boQZNSBDa45eD3YoTDIxxNrUCCtTQ+zMjfGwM8PT3hwXa9Pi7zkzGY5+KYVS+X12DfqKLFd+Pu1OKAoc/1FEoRU9ePeCiStRTG3592IkC7Zd4UaeqkufJk68P6Zl8TBfbhasnSoG0rqeVN7ewUAGxaYx5cejJKRn86PVr5jkZMnrtplcvjUDXP4LTVYyIXonLhq35vs+5eiRy82Sth7gapYjEE4j59uvlXodxEiGn6ZXjwcwMdQSlpCBX1RK8YhG0fN0jUY+mz+fhqYjoO1kOvvY09nHnvlDm/HLkWD+OB1GSHw6N5MyuZmUWfJ1AQcLYwY0c2Zgc1f6NHEqrn5Ukxjn7ZPslNs/rroJPgx/P1c47LrL0yIgURdbUe4xVCNZGTrNkJaC4IMSoixD+up2tKxnw5TO9Vl1LIR3Nl1i89ye0hLSsJ+ojQTth70fw5jv7ryx0qjfBbrNhiMLsdz+Ij+N287on6+w3z+GD7de4a0Rzct+bv83paH+3G+w/jGY9FsJoQEAJysTVs3qwrubLrH8+GAOZbbgB/Pv8UkPgnWPymDmB94rOZnjVrQG4NxULm1LP9hrAYu8iwtwm9XfnuQIOQE58VPBzENcWkru0XdY+UNS2emw5cXCSue2D8OIrzgfmc77m49yPE/SzdHShDeHN2N0W/fi3pNeLzmj4IOS0334d6ncvA0hcelM+fEo0SlZzLS/QMf0k+L5Dv+iQqE0/elf0ALrdH15sl/j8inOJAQDChhbcjlRIhF3NJLu7WX/3DyNmbEBvRo7svNKNDsuRRU3kreu/cBnksO+ullEJ4Z+AgZG2FkY89wDjXnugcYkZ+ZwNSKFyzeTiE7JwsLEEHNjA8yNDWjoZEm7+nbl6xOtbvIrbSsoX1lp0uOlUO1cXhGWpatoMTe6jYevUiHU6tbKYONR6EEeqaQRQxrHbc2NuBqZwtKDQYV39H9brs/9VnrlaHnp/xY4+kJqFL6H5/H5ODHmSw8G8dOB62U/T6MR1ZDmo0VrdPXkvBaKkpgYGvDR2NYserg90aY+DE57l+/1Y8jVmkgxzdIHZFRV2Kna07VUFCmM+WOmVL3u/1QMpENjGPczPHkAmg4vv6GJviph8XOrpehk4P+43Okjnlx9nlELD3H8RjymRlrm9m/E3pf7MqZdveIGUlFg6zypZNYaSg7yDk3wofHpTP7xKBFJmbR1gtc1y+SOXi8W5D7LRWwg2pDD6BQNu00f4LEe3uV7XkLe99POm8C8gqeGTqVP/iggP58bdhIUhYHNJQS/7WLkbZ4EDHgX+s4HNJK//m1iCaNjbSqFXdN7+PDKkKbM7teIx3r4MLFTfTp629eOgQSJKID8bmqaa7slrXLuN0AjEa5njqgGsppRjWRl6TZXrqvQsmFnYcwbw0T27Isd/lzPnwXp2UmmCyh6EQPPL5OvKEamMr/R0AwCdzI8bgWvDpHc0/tbrvDHqbCyn2tgCGN/EkOpz5Gc26nlZT58WCs3/n2+N92auPNx9gR6pX/GFsMBKGjBbwv81F8a0U/8VDBrsMaJuiQC5t+0Fem5C7+LYEP9bjB+hSgMtRxb/pl5igKnVsCP/aRK19KFoOGreep6T4Z9e5B/L0Wh0cCD7eqxe15f5g3yxdLEsOQ2/pkvB380kkts2O+2LxsUm8akH44SnphBAycLVnv+iTYtWox8zxcrtEuyj4tx3atvy+QHumJuXM5gUnyekbT3wT+v/aNxWe0f+bi2ku9eRjzE+jOouSuGWg2XI5ILxlSVilYrrTqT10gR27Vdss+D9pdvrbWFosCNg/J3kbafaic1WsQ6Vj4oIiAOjaTVauTX/4nq1buNaiQri0cHCYvqc6vkTY7r4EGvxo5k5ep59Y/zhdM7Bn8ARhYSbqqkeAEgB6p8QfL9n/CUmz8ze8pUklf+OM+uK1FlP9fQWDyt9o+Kwf77Odj2WkFPW4mXsjFl+WOd+Hx8G3RW7sxOncEDWR+z36w/egNjCU1vmQef+cKvD8lMyahL1edhJkfA+XXSqvBVaznLPvC55FiNzCVv98ReUb9pMaZilclJ4bLmv5+FnHRinboxy/wr+q3X8c+lSDQaGde0/fnefDmxSOVqURQFdr4Lx76X/0d9WzhBogwuhicx7vvDhCdm4ONowYa+cZhdXice7OjvSsgI3pbsNPSnZFzWLothFdMszfMkc2y8CUvIAGRe5m0xNJaGf4DgQ9hZGNPXV9Sf/jp78zZPzMN3iCgOWThLrm3FSFg/Q3LWdZFYf8nbGphIqqG60evl5Gphx7zJLRqpWn1y/51TGv8RMnN0vLK+CtG3UlBzklWh5wtydnt6hbRMVEIDUaPR8OGDrRj81X5O3EhgxZEbPNbDB6zdoe+rUq22421oOqzyfVdtJkLYCTjxI5oNT/L649uJT6/HhtPhPL3qND9M7UBf3zLaTbQGUuVqXQ/2fiQH+OhLogZTSouKRqPhoQ4eDGnpyuJ91/hhv5ZHE2ZiwyRedD7FOHZikXxNxK0D89otzOxk1JZrS8kP2npKn6G5o9yn0YiRVvTST5cSIVJ+KREiExh1UYxtWkzxxRgYS7Vtq4egyRCRnasoer30Bm5/E7KSydUYs9hgMl+EDkSPgoFWw7BWbszt34gmt/OsFAX2fACHvpL/h38uRVK34XBgLE+sPEVqVi4t61mzYoI3tivyBkz3eL7C80djDq/ESZdCiN6JPiMeLhTZLw95QgLRBm4oCthbGONgWQ7FFq/uIr4RfBg6Ps7otvXYeSWaP8+GM29QkztXuXp0gDnHYff7cGKpDAv3/1cqkLs+VW61nbvClU1yfSc1qMoQfkpOUiPztGvd2khxXHlblP4jLNh2la0XqvckSm0BuYUKlQ8rCvzQVyoyu8+VfqRKsvLIDd766xImhlo2zemJr6sV5GbD4p4yQaLNZHhwcaW3T262nImHHgXreuRM38bszTFsvxyFkYGGbye3v7NM1+W/YOPT0q5RzgKB8MQMvtrhz59nw8nRKYDCUOcEZrgF0Sb7LEahhyE3o/LvqxgacGstHr5PH5nkUZWDaPgpdFtexuCmDII+rW/EyzlPck2ph4OFMVO61OfhLl642tzBm9PrZcRYfmn+4A+lqOo2/H3uJvPWnSNbp6dbAwd+mNoOq/WTJfTo0hJm7a6QrJii1xH+YVs8ckP4zfZJJj/3ccUUZ77tAHGB7Ov6E9P2mpet2Xor1/dKW4SVO7x4mYwcPR3f30Fato4/nu5W+mixsrh5RiIR4XmDuc0dJNzcaUbtV3GeXwcbn5QTueGfizZqdZCTKSenh7+RbZtYy7zNzrPKJ3DxH2KvXzTTfz6BPiud0K8mqH2SNUWFe2wCdsCqcTIf79kz4gFWAkVReGz5Cfb6xeDrYsVfc3pI03PocemjQ5Ecje/QSm0fyBvbNETCQg6NyX50Ky9sDmPLhQgMtBo+G9+aB9t53H4b0Vfh92niwYHI2Q3+6I5edERSBj8dCGL18RDSs6XXzdhAy9Bmdkz2yaCdSRgmsVfEK0yJhPTYPHm8Ur6e5o5g5SqC5w4NxWi4tJTq2Mp4i7cQExlCyua3aBD2JwBpiglf5o5jmW4oXRo4Mb6jB8NauZWvKT03Ww6elzYAGqnU7PJEmQ/X6xW+2OHPwj2BgAxx/mJCW0xPfA/b35Dv2RP75L1WgCP//Ea3o0+TqpiR8ORZPN0roFuqyxFhAH0uX7X+i6+Op4kowKg7T9wgJwMW1JdClrmnwaEhL649y4Yz4TzStT7vj6lgZbheL/tyz4eFWrIWzhK2bjOpUpXmVSInUwzY3o/EiLV/FEZ8Xf489+24ta2j5Tj5/txnUzuqg7jULAZ/dYDY1Cwmt3VkweSuqpGsKSpsJBVF5gWGHIEOj8HIryr92jEpWQz9Wj7oad28eG903jSQ7W/C4W/Fe3vmSNWS80lhsHSwKMO4tyP3kb94dfMN/jgdhkYD745swbTu3rffRnaaFMQcWwIoMuViyEdiMO/gnSSkZbPhTDi/nwzlamRh8YaxoZauDRzo28SJbg0daOJihQF6KfLRaAsvhiYFU++rA0VRiErO4lRwAuf8A2jg/zOjsrZgrpHxXX/oerLa6nG6t2vFuPYeorFaXrJSYd1UqULUGkkk4DYDu1Myc3hh7Vl2XokG4IneDXh1SFPxZJcNkQKq4V+I51QBktJzuPppP7ooFzjr8TBtZy6q0POJDYSFHcDInIed/uDQ9YQ7yxwWJU+phxFfQsfHORAQw9Slx7E0MeTI/P5YlabYcyd0uVLVue8TUe3Jx7mFDAvw6i6TYiqSs60IiiID2P95rVDHucNj8vlU1UCmxcHOt+FM3iB0C+e8vuOS/coq8hue9ctJdl6JpomLJb8+2hoXR3vVSNYUlVJrCD4shlJjALOPy2SCSrLPP4Zpy2QgccEon5wMGWIb6w8tHpRimqpITMX4w7LBUnVYvxv6SWt4d0cYvxwR3dPp3b15c3izO8/ZCzsJm56VHCWAW1sY8BY0HHDH9SmKwqWbyaw/FcaOy1GEJxYPuVqaGNLW05Z29W1p4mJFAycLGjhaYmZc+RBTenYuQbFpBMWmcS06jQvhiZwLS4KUKGYYbuNRg+0FxtHPsAnnW86nbbeBNHK2rLgYdmKIzE2MvCBFQxN/vW1oOjA6lad+PUVgdCrGhlo+fqiVePWpMfBDHykIaTZSVJ4quJZvVq3n2YAZ6NCim3sWYwevir0Xv39g9UQU11a0j36bhPQc/p7Tk1YeJSd5lMreBeJptRgL439Gr1cY+OU+rsWk8faI5jyeV0hWKXKzIXAHnFsjRqto64WxpegQe/eUsWouLao2+SI9HoL2wfV9cuKTrxNs5QYD/09OgKoq/RZ5USJTKRHyf/tHpddYrVotk1+PBvPmnxcxNtDy15we1LNAlaWrSSotaZQ/ZNZ3GEyuQjUq8OHWK/yw/zoWxgb8NacHjZytpM9w2SCpps07I68S4afglzGiNuPSCuWR9Sw6mcqn//oB0KuxIwsnt79zo7kuR8JN+z8vlJbz6iF9bt49y3XQUBSFazGp7Lkaw/6AGM6EJJKaVXoFrYu1CY6WhRdLEwOMDbUYG2oxMtCSnasnK1dPVq6O1MxcYlOziU3NyrsU7V1TaK8J4FHD7QzTHsNYIyHgJLsWGPR7HctWFeibvJUbh0RMIT1WCpAmryms8izlva87Gcq7my6TkaPDxdqEH6Z2pI2nrRiAX0ZDyGFp95i1G0wr9qM/FBhLwoqHGWFwlFjvkThO/7Xi7ydPCzityRhanJ+AkYGGC+8OLr8G6o2DsHy4RELmXQWNpuDA1sDRgl3z+lTPRI6MBJE5DNovr5lvaPLRGkmY2tZLep1tPCSvaWQmrSqGJvJ9zkkTsYjMRPES44OkujfuGsXC/4Zm0OVJKdq7g1JSuQg5CqsmQFYSODaR6uf6Xau+3fuYq5HJjF54iKxcPW8Ob8bMXg1U7daaptI7OMYPFnWTcVNT/7xj79vtyNXpeWTpMY5ej6eBkwV/ze4hIanD30ro1cBEBh5XVZMx8gKsHCtCyHY+MHUj/9w05YW158jI0eHjaMGih9vTzK0c+yE1Bg5+KX2QOvHGcGoqxrz1RDCzLfeydHqFgOgUTgUncD40iWsxqQTGpJJ462zBSuBrnsJE81MMzN2HZ6Zf4R0enUWvtfGgyhtHRYFTP8PWl+Vkxq0NTFwl1bqlkJyZw+sbLrD5vBzMezZy5IuJbXC2ygsRbn5R1IFMrMVAllcuL4/E9GxmfbmWNdlzMdAolR/oveFJOL+Gq82fY8jpLrTxsOGvOT3L//yiecnZJ8CpCalZuXT9cBepWbmsmtmFHo2qWVdVUSD8tEzBCM8b6J1RcgRchXFuLkVhDfqCT69qyYEDUum95hEpYqvfXeam1uYUkXuAjGwdIxceJDA6lb6+Tiyb1gmtVqMayZqmSjt426twbLH8kJ48UKkJIfnEpmYx8tuDRCRlMrC5C0se6YBWg6jf+G+Ts+En91X9hxR/XZqSE25IIcyUdVymAbN+OUl4YgYmhlreGdmCyZ09y3e2nxQusmLn1kCO6JZiaCY9b81GihGqZMVpfFo2YQnpxKVmE5PnHWZk6wq8x1y9HiMDLaZGBpgYajE3NsDR0gQPJQLPuMM4hWzFMOwYBd6AgQm0Gi+TJ9zbVWpNBWQmS+XlhXXyf8uHYNRCMC49h3koMJZX1p8nPDEDQ62GeYN8ebJ3g8Jhzid/hs3PAxoZQ9akHLMsi6AoCnN+O8PAq28wxuAwuY2HYPjw2sq9t8W9IPI86xp+zCuXPHm0mxf/G11BY5sv/D1kAXR9GoC3/rzIyqPBDG3pyveP1HArg6JICDz6suTl8y+ZiWLEczIgN1Py3UYW8rmZWMnvzN5HTiKdmt5ZuL8yXP5L+j/1OdKyNOGXMr83KoXM33Ce1cdDcbIyYdtzvXDMa0lSjWQNU6UdnB4vo3IyE4sdDCrL2dBEJiw+QrZOz+x+DXl5cFMJKS3pI/mQBn3h4fVVL2RJiZRG+aiLUj05/Avim4xn3rqz7PGT3sMhLVz5aGwr7CxuM0GkKJlJUhZ/cpkcmPIxMBEv27sXeHWTgczVWIhTcDC8eVpyxQE7CiXV8vHsKko7LcdVT6Vg2En4Y4acaGgMJC/b4/lSPdKkjBw+3HKFtSel2MTT3oxvJrWjXf0iJzv+/8rJkKITacHeL1V4SetOhLJsw2a2Gs9Hq1Gk4bwykQddLnzoDrosZjssZUu4GZ+Nb8O4Dneogr6V/ChIo4EyJQXwi0xh8Ff7MdBqOPJaf5yta6jIpi6TGCLTUnIzJWf74BIRYVC5LX+fu8nc1WfQaODXGcUjEaqRrGGqvINPLpPpGcaWMPuY5D2qwPpTYbz0uyhILBjbSlRSIi9IhWpOmlTUjfiy6gUDmUmibRqwXf7vMB394I/58Ug4n233I0en4GhpwnujWjCslWv5c0iKIgbr8ibJF+WX7edjZC4Hb8fGkndzbCyFEOb2efki8+LvTVHEQ81MgoxEqWzMzxvFBcDNs5ILLIrWSHI7TYbkDfqt2mdSQG62hJj3fSwGzaa+zKAsJY+kKAr/XorknU2XiEqWcPS0bl68PKRpcem60OOwYpSE3dpMFtm6Cn62AVEpjFx4kEUsoL/BWWg+BiasqNx7zBuerBhb4pu2hGydhn0v98XLoYJhxojzIktobCkDifNOjB76/jCnghN4dUhTnu5bjmkk9xvrZ4hAgncvePQvtfexHNyITWPktwdJycotdB6KoBrJGqbKO1ivl0rX0KPQZKgU8VTRgH2x3Y9vdgdioNWwdFpHUcfx2ybeBoqIGHSfW6XXKFj7gc+kBw1FQpBjf+JCphPPrz3DtTxh6wFNnfnfmJbUK0167XYoiniVAdulSCHkqHjdt0NrlHfg0Mh+1OVIWOq2zzGUSsZ6HaWi1Kd39SuzhJ4Qibp8L7nlQ1L+X0ru9fLNZP5v82WOXI8DwMfRgo8fak1nn1sqFmP88qqOEyQsPem3CnvZaVm5PLjoEPYxx1lj/D6K1hDN7OPST1oZzvwKf80mybkLbUKew93GlEOv9a94oY1eD582kPc2Y2eBjNq6E6G88sd5fBwt2F1dBTz3CjF+8F0XoAqe/n+MzBwdYxcd5nJEMp287Vg9q2uJKnx1nmRdR6uVXsnFvSR3ePlPaduoAi8MbEJYQgYbzoQze9Vp1j7ZjZa+Q0W55d/5sP0tETFo+VDV197nFRFn/mOmFDss7kmrAW+zde5MFu27waK9gey6Gs2RL/Yxp38jHu/hU/4qR41GjFf+xAu9Pk9W7pJ4gbH+EBcoRUAZ8VLooS/DKGoMxCBZuYNdkbyRWxsRFqip/rjMJJFIO/4joIi3O+TjUsv/o1My+XJHAGtOhKAo0gv6RK8GzOnfqOQ+SwyVIqqMBDHu45dX2EDq9QovrjuLf1QKm83WggKaDtMrbyBBPHMgwFDamro2cKicIdNqper56ma4Uag1Ory1G+/9fYmg2DSOB8XLXNX/Cgc+BxSZm6kayHLx3t+XuRyRjIOFMd9Obn/nNrVqQDWSZZCQlk2lT0Kcm4mu6/5PpJijfvcqJfw1Gg0LHmpNZHImh6/F8eiy46x7siuNuj4t+bbjP8hUAENTGflUVRo9AE8dFKHw63vg3/mYXNrIC6O+ZWSbXszfcIETNxL45B8/Vh0N4ZUhvoxs7V5YdFJetFpwaS6XW1EUES3ITCzUbVUU8RLNbCVsdze9Dl2uVK7u/QjSxSOkzRQRor+lhy0uNYsl+6/zy5EbZObIBJfhrd14bUjT4kOX80kIhhUjRODBsYnMlqxE1eRn2/3491IUYw2P0FIJkAKU3q9UeDvFCD8JwN4UCVF3rYoR8+4lRjL4MPSaB4CFiSGj2rqz+ngoa06E/neMZG62pCCgwpNc/qv8cSqM1cdD0Gjgq0lt7ywHWU2oU0DK4JN/rlZtA71fEo8mPU7CclWMahsbalkytQOt6tkQn5bNlB+PERSXLgVCrSZIy8Hv0yFgZ9XWnY+NB0zdKPlOYyuZRvJ9dxqdeJe1Dzfm8/FtcLU2JTwxg+fWnGXMokPsuBxVOMWkqmg00ntm4wG29cHOW7xFW08Jnd4tA6koUkjzfXfY+pJ8ng6NJX/04PfFDGR0Siaf/nuV3p/s4Yf918nM0dOuvi2/P9WN76a0L91Axl+Hn4dJAYd9Q2kfqkTj+PpTYSzaew0LMnjf8ne5sdcLVavGzEqVXCKwIVaMZP4Uj0qRL8gedqLY+LcJHaVFZuuFCJIyqt7mc08QeV7yzmb2NTtW6z7BLzKFN/4UcffnBjSmV+MqfA8riGoky+Dv8xHsvnqbMVJ3wtAExv4gkyj8/4HTv1R5TVamRqx4vDNNXa2ITsliyo9HCUnIkuKO/AHJax8WRZDqQKORPsfZR8F3uBSnnPgJ7cL2PJSxnj3PdeGlQU2wMDbgfFgSs345ydCvD7DxTBi5ukrOwKwr6PVwdSv8NAB+myAi82b2MOwzkQZs0LfgoZduJjFv3Tl6LtjDd3uukZato2U9a36e3okNT3enk3cZRi82UCTb8j3I6VvApl6Fl3rsehzzN4gxW+GzC/PMKGld6DanMu+8kPCToOhIM3PjpuJAy3rWVatAdWkphViZSYV6pEBbT1uauFiSlatn07lyjNC6Hwg5KteeXe5uROQeJCUzh6d/PUVmjp5ejR2Z279i/cJVRTWSt+H1DRdJqkoDu0sL6P+m/P3P/DzFjqphb2HMrzO70MjZkoikTCb/eJTgxCwZXdVkqJSS/zZBpMSqCxsPaW6e9rcISGclw853MFvUjjkm29j7XCee6tMQSxND/KJSeGHtOXp/sofv9gQSk5JVfeu4G+Rmw4X1Uom5ZrIoExmaQvdnRcC+8ywwMCIzR8fGM2FMWHKE4d8c5I/TYWTr9LSvb8viRzrw95ye9GvqXHb+LuIcLB8GKTfBqZkYSGu3Ci/3YngSM385SY5O4YnGKXSIzOuFHP5F1SdjBB8B4LKBDAbvX9Y4tfJiYFQ42inseMHNGo2mwJv8/WTlBpjfc4Qek+sKjjv7r6EoCi/9fo7rsWm42Zjy1cS2GFQ0rVNFVCNZBl4O5kQmZ/LmXxertqFuc8Crp7Rr/D5NpgZUEUdLE36b2YUGjhaEJ2YwYckR/GMzpcy/yRAxlGumwNnfqvxaxfDpLRMoRi8Caw9R6tnxFk4/deA1sz85PLsZLw/2xcHCmJtJmXz6rx/dF+zi2dVnOBgQW7e9y+QI2PMRfNVSeh6jLkres8fz8PwFGPR/KKY2nAlJ4J2/LtL5g528sPYcx4PiMdBqGNnGnY3PdGfDMz0Y0vIOLTL+22HZUEiNEu9q+uZSZ3PeCb/IFKYuPUZKZi7dvKx4LetbNIpOCsUaP1D5fZHP9T0A/J3cAIAHmldDI31+aDGvICifB9vVQ6uB82FJhMSlV/116jqxAXLt2rp211HH+X7fNf69FIWxgZbvH+lQvhmm1cx91QLi7e1NcHBwsdteffVVFixYUO5t5JcPH7gUzLRfL6LTK3w1sS1j2lU8DFa40ZsyFzI9DjpMh5FfV35bRYhOyeSRn47hH5WKjZkRy6Z3ooOHpRTcnF8jDxr4PxlQW93kZst09INfFvY+agygyWCy20xlS3pzVhwL52xoYsFTHC2NGdbKjRGt3Wlf3/auVKbdluw0aaW5+Ie0pejz9GItXaDjDOg8i1wTW86EJrLtQiT/XIzgZlLhSU49WzMmdvJkfEcP3GzK6bWdXAZbXpLQdYO+oq5iWk6h8CJcj0llwpKjxKZm0cbDhnVN92Fy8BOptn3mGFhWMWeTkQifNABFR4/MrzFy8GLPS32r3qJxYb2chHh2gRnbi9015cejHL4Wx/yhTXmyz33cM6ko8GE9OXHOGx+mUpL9/jFM//k4egU+GtuKyZ3rl+t5ap/kbfD29mbGjBnMmjWr4DZLS0ssLcsvPlx0B/98PIovd/pjZWLI1ud6lV54UV6u7ZYSfxRR1WgzqfLbKkJiejaPLz/B6ZBETI3kbKtfY0cZtXP4W3lQp1lS4FMFmbwy0eukzeX4jzIuLB8LJ/Adyg3nASwNr8/mS7EkFAldW5sa0quxE72bONKrsRPuFe25rCxpcaKT6b9NCnJyingt9buhdJpFsHN/DgYlczAglkPXYknJLBRbtzA2YEAzF8Z18KBnI8fyV/TqcmHXeyIGD9D2YRjxVaXUVYLj0pj0w1EikjJp5mbN2tEWWP8yUIz8uGVVbwUCqbxcN5UII0+6pXzM3P6NmDfIt+rbjfGD7zpL5e38sGJjpfIHj7f1tOXP2T2q/lp1lbQ46RkFeCOq5tqV7mFC49MZufAgiek5TOrkyYKHyu9xq32Sd8DKygpX1woMlL0Ns/s15EBADCeDE5i7+gzrnuyGsWElvZ+G/aHva9JC8PfzogPp3rbKa7Q1lxzlM6tOs9cvhpkrTvL+mJZMHvS+eETb34ITP0o/4vjlYFHNQtJaAzkot3xIRnCdXgHnVkNaDJz+BW9+4f9MbHivSW8CLdqzMbEhv10zJSkzly0XIthyQcS969ma0dHbjo7e9rSqZ0MTF0vMjavh65mVKgUoIcfEOIadoOgkB52tDzc9h3HEvB87Y+w4/VcCsamHi23CxsyIfr5ODGvlRu8mTuXvC80nNRrWPw43Dsj/fV+XftRKeGWXbybz6LLjxKZm0cjZkpWPtsJ69TAxkE1HiLRZdRC4A4AdmdKeM6pN5YaJl8ChkWj55qRJ+1IRL2pwC1fe3nSJs6GJRCVn4nK/ytTlj9iydFENZClkZOt4cuUpEtNzaO1hU77h3jXIfedJZmVlkZ2djaenJ+PHj+fll1/G2Lj8Z+u3noWExqcz/JsDJGfmMqOnD2+NKKWnr7zodfDbRDkAWdeDWXuqTTA5R6fnlfXn2XgmHCgyE9J/q/RQ5qSBjafMNawG43xbdDkyqujK39IXl1q8SlixcCbZrgV+eLMn2ZVdsXaE6h3JoPCAodFAfXtzmrhY4WlnjoedGfXszHC1NsXO3BgbcyOsTAwLPTm9Xl4n5qpcoq+g3DwLURclT1eEm6aNOGnUkfXp7dif5gEUN1bGBlraetrSu4kjPRs70aqeTeWLBUKOSS46JUK8p9HfVtrTOx4Uz4wVJ0jJzKWpqxW/zOiM895X4dRyGcz79KFK5TZLoNfBZ00gPZaHs+eT5NaDzXN7VX27+XzfQ3K+U36HJoOK3TXy24NcCE+qeoqjLuO3DVZPEkWrJ/bW9mrqFIqi8Nyas2w6dxMHC2M2ze1ZYWUv1ZO8Dc899xzt27fHzs6O48ePM3/+fIKCgvjpp5/KfE5WVhZZWYUVmMnJycXu97Q357PxbXhi5SmWHgyik7c9Q1pW0lPVGsC4pfDjAFGYWTNFijaqWoUIGBlo+WJCG3wcLfhihz/LD98gIDqF76YMwnbWLljzsOQOlw6CQf8HnZ+oudJzAyMRMW/YT1omwk/JsNqg/RB6DE1aNDZp0XQGOgOv5p3DpBvZEYkTN3Mtick1IznJnJQkc3RoSUHDFcAfPZZkYEEmlpoMnLXJuGnicCYBI4rPoMx/d+GKA6f0TTiib84eXVsiM4s3rNe3N6epqxUdvOzo6G1Hy3o2mBhWUUNTr5Nw9+7/Ey/PsYmcoDhVLmS583IUs387TVauns7e9vw4rSM2gX+JgUQj7UbVYSBBmv3TY0nCimP6ZrzbqXy5oHJj7yNGMv56ibu6N3TgQngSR67F3b9GMv+k0bIGJorc4/x44Dqbzt3EUKth0cPtKy59WQPUeSP57rvv8t577932MSdOnKBjx4688MILBbe1bt0aOzs7xo0bx8cff4yDQ+lKHh999NEdtz+ohSsze/rw08EgXl5/jmZuVhUXeM7H1EZGH/00QMKAG5+CcT8Xy81UFo1Gw7MDGtPExYoX153lUGAco787xOJHOtBs1m55Lf9tsO0VyZGOWlj1Ao87odWKBJlnJxFYyMmU9ofI8yLUHnleWmOykjHPSaABCTQAqISN0isabiguBCge+Cse+Ok9OaVvQpqpC/bWxjhbmdLd3gwPO3M8bM1o5GJJExer4gLj1UF8EPz5dGGOtsWDMkC3EvqxiqKw9GAQH269gl6BB5o5s3BKe0yTb0jYHmS/VmF+aQku/wXA9tx2mJmY8mB1Gyv7vHxcKUayW0MHluy/zuHrsSXuu29IjZbr6jqpuU/Y7x/Dgm0i4vLOyOZ1Rn2pzhvJOXPmMGnS7YtcvL29S729a1eZxhAYGFimkZw/fz4vvlgoC5WcnIynZ8khua8ObcrpkAROhyQy65eTbHimR+UPrg4Nxav4ZYwUvfzrBkM+qjbPbkhLV7wduzNzxUmC49IZ/d0h3hnZnCmTfkNz/AfY8ZYIHHzfTYpHmo2oltctF0am0ht2a39Y/kSPxBAZOZaZJJJ0WSlFZOn0IktnbEmOoQUZGjOyTOzJMnMlw8yVTFMnjIyNaWygpYWhFjMjA2zMjO5eFa1eD6eXw79vSnjb2FIKpto9UqnPNjNHx+sbL7DhtITQJ3T04IMHW2Gky4C1UyE7RSQP+7xWfe9BlyPfSWCbvjMPdfbAorpPIuy85ToxuMRdnbzt0WogND6D6OTM+3N8Vr4naaEayaJk5eoxMzJgRGt3HunqVdvLKaDOG0lHR0ccHStXbHLmzBkA3NzKbtI2MTHBxOTOvTdGeX06I789iH9UKvPWneX7hztUXK80H++eopSzYSYc+148ujw9y+qgqas1m+b0LJgJ+cbGixy+FseCsTOw8u4JG2bJBIu1D0vBx9BPKqX2Um2Y2crFtVW5Hm6Ud6kzRF4Qnd78JnGvHjBmUaFBqOjmkjJ58tdTnAtNxECr4fVhzXi8hzcaRZEcc/QlqSAet7R6q5YDdkBaDDGKNYdow3s9fapv2/lY5qUr8j2qIliYGNLQyZKA6FQu3kyi//1sJK2qp8DwfmFgcxc2ze2Jh51ZnZoGc9+ICRw5coQvv/ySs2fPEhQUxLp163jyyScZNWoU9etXT07FxdqUxVM7YGyg5d9LUXy9K6BqG2w9HgZ/JH/v+p/00FUj9hbGLJ3WideHNcVQq2HL+QiGf3OQk5nuUjTU8wXxzK5ulrL8o4sll6ZSfjKTYNtrsKS3GEgjC/lMp22utIHcdSWKYd8c4FxoIrbmRvzyeGdm9PSRA8eud+XzMjCGCStl+kt1cnYVAH/qejKsTf2qtT2VRX4u7paCrnxaeUjf6PmwpOp/7bpAQbj1v5uTzNXpySlFXKShk2XV6wGqmfvGSJqYmLB27Vr69u1L8+bNefvtt5k1axarV6+u1tdpX9+O9x9sCcDXuwLYltfCUGm6PVM4BWDzi3C2eter1Wp4ondD1j3VjXq2ZoTEpzN+yRE+2H6dzD5vyRw7j86QnQr/vCqiB9Ulkn4/k5stvaHfdpBIgKKX4cZzTshnWokcc2aOjnc3XWLGipPEp2XT3M2aTbN7Fk5dP7UcDuUJUYz+Dry6VdvbASA1BsVf5AzX63rX3BBkqyJGUl/yQNm63v1uJP+7hTsZ2TpeXHeWJ1eeYtziI+zxiyYzp26fmN83RrJ9+/YcPXqUxMREMjIyuHr1Ku+++y7m5tV/JjyhoyeP9fAG4Pm1ZzkdklC1DQ54Wxr+UaTgo7rl5BDjvu35Xozr4IGiwI8Hghj29QFOZLjB4/+K1qeprYRgVz0k+dLIC9W+jnseRYGLG8Tz3vqS9IM6NIJHNogsYCVD1pduJjHmu0MsP3wDgMd7+LBxdnfqO+R9f/3+kZMokBxk6wnV8GZu4dRyNPpczuob4NWsE01cqnlQdT7mefUB+lzJ3d5CUzcp278ek1ozr1+bKIpIIEK1tX/dK0QkZTD4q/0io9jQATtzI97YcIHA6Lr9Od83RvJu88awZgxo6kxWrp6ZK05yI7bkj73caDSSE+w4AzGUz8CZVdW21nysTY34bHwblk7riLOVCddj0xi/+Ajz1l8gttkjIuDdbQ5ojUS3c3FPaR0JP13ta7nn0OXC+XXS47f+MWmEt3CWk4tnjkKjAZXabGaOjgXbrjJq4SGuRqbgaGnMz4914u2RzQvDTjcOyRg0RSdKPX2rsVAnn9xsco79AMAK3ZDqUdcpC8MiecZStIzzy/5vJmVW3+i1ukJ6POjyWs6sKi5of6+SkJbNW39epJO3PT8+2pGZvRqw/LHOWJsZsf5UWG0v77aoRrKSGBpo+XZKu4L5jq9vrKLXpdXC8M8LDeVfz0g4rwYY0MyFHS/0YWLe5IU/TofR/7O9/HIuGd3A9yVk2OJBefDVzfBjP1j5oIzgun+0J8pHVgoc+wG+bZdX7HRJqlb7zpeTik4zpC+0EhwKjGXwV/tZvO8aOr3C8FZubHuuN/2KTtsIPS5TXXIzoPFg0f2tgaIG5fKfGKVHE63YYth6LL6uNeRFgqzfMK//ragsYB6uNqZoNJCdqycuLbvm1lEbJEulMhZOMk7vP8LNpAyydQqTO8sxJytXQqxdfOzJLSXkXpeo89WtdRlzY0OWTu/Imxsv8n9jWlZ9gxqNGEoDIzi2OG/Ib3ylJcxuh425ER+Pa83Ezp689edFLt1M5u2/LvHr0WDmD21G33E/o+nzmgiYX/hd+iqv7RY5vc6zoPUkGYp8vxLjJycp59ZIqwWAuSN0fQo6zQQzu0pvOjQ+nQ+2XOGfS5EAuNmY8n+jW5acshF6An59SPLF+WLolTTIt0VRSNz1FXbAWmUg84aUr8K4ShiZiuHPLelJGhlocbEyJTI5k5uJGThZ3UfGJDlvXuZ/xIs8F5pIG09bWrjbML27Fx3zZqsaFsnZJ2eICIher1S+W6AGUY1kFXG2MuWHRzsWu02vV7gRl8bpkERSM3OY0Mmz/DqkGo301plYw/5PYO+HkBopyjXa6q/6al/fjk1zerLqWDBf7PDHPyqVx5afoFsDB14f1oxWY5dAv/miHnN2tUi+bZkHO98Tb7P1RKjfrVrEEGqdjARppD+/DoIPFd7u0Ai6PCX9jlVQR0rLymXR3kB+PBBEdq4erQYe7ebNvEFNsDK9xfiFHMszkCng3Qsmra4xnc+UC1uwS7pEumKCeY8ncbW5C20X+REJTenfG2szQyKTZZ/dVyTckGu7utMHWFN8uyuAL3b6s2x6J/r5OtO/qZwEKopSIPOYmqUr6MPVajWExqcTn5ZNG0/b2lp2CVQjWQN8tt2PXVeiSczIxsPOnC92+PPZ+DYMalHOviiNBvq/IYocW1+W1pCUSBj7Y414bwZaDY9282Z0m3os2hvIz4dvcOR6HCMXHuSBZs7M6d+YtsM/lwKjs6vh+A8icXd6hVxsPKHlWPAdDh4da8SY1xhpcaKle3lT3risvEklGq0Mse48E3z6VukkID07l5VHglmy/zrxeeHDHo0ceHtEi9LDmgE7YN2jEor07iUKTcY10IoBoCgkbPs/rIDNJsOYOqBDzbzOrejywqhleMb5IvKZuXW78rHC5Aso2N7fRvLpX0+x3z8GMyMDQuMlpK7Ti3HUaDTFvMZ6tnJStvtqFHN+O8NHY1upRvJ+5veTofx0IIhXhvgyorU7rjamfPzPVVYfD6GPr1PFeoA6z5LcxYYnwG8r/DwEJq8BG48aWbuNuRHzhzVjajcvPt/uz59nw9l5JZqdV6Lp1diR2f0a0aXLk2g6PyETLS6sE+OSFCqtCYe+lsrFxoOg0QNygK9rFXy6HBn4G7RXhh/fMhUEl5bQahy0Gl/l/Zyalcuqo8WNo7eDOa8Pa8bA5i6lN0yfWwN/zZbKz4YDYOJKMK6kBGI5uHxgPc0zrpKumOA79o3KT7mpKAVGsvThA6Z5v5PMnLqdr6owiSFyXcke2nuBCYuPEJuWxdl3BvHNrgCW7LvOg+3qlYyWAAnp2bQzt+WPU2G8tuE8Lw3yZXTbuqXZqxrJsogPAus2FXrKzcQM/vf3ZWb28mFKl/oFIdb+TZ35cf91IhIz8Xas4AGvxRiZGLJmsrRk/NBXmsiru0euCB525nw5sS1z+jfi+73X2HgmnAMBsRwIiKWFuzUzevowonUvjBv0kTCw/79wZZP0V6bHyaisc3n9no5NxFh6dJLpIw6Na2auZVmkxULEWTGMwYch5GjJtgPXVtBkiIyZcqnClJc8opIzWX74BquOBpOcN4vSy8Gcuf0bM6ate+kyeYoi+d9deTrCrSZIL2Ql5k2Wl5SMLAz3fAjAKeex9GrauMZeqxi6nMIB1wal5xsNDeQEorSG83uafE/SpqT05b1OZo6OcYsPY2SgZdOcnhgZaGlX35Yt5yM4HhTPgGYuKIqCRqMp8CIzsnUs2hNIVEoW30xqx/DWdS9XqxrJslg/A+buqZAo9UfbrlLPzoyZvRoUy0EGRKXi42iBpWkld7dnJ5i1G1ZPgagLsGIkDHofujxZc5M8EPWLz8a34bkBjVm87xp/nA7j0s1kXlx3jgXbrjKpkyfjO3ri2WKMGHNdjqjO+G2TiR+RFyDWXy4nl8pGDc3ApQU4Ngb7hjIRws5bGqstnSte8afXQ0a8NGgnR0gYOO6aXEdfKawmLIqZncjGNRogFaPVIMenKAqnghP47XgIf5+7SY5OvFMfRwue6duQB9vVK1tDNidT8rxnf5X/u82Bgf9Xo3leRVHYtOJzHlauk4o5bSe/U2OvVYL0OLnWaEWKsBTyG8wrPLuzLqPXy3cTJM99nxGZlMmYtvWY2atBwW3dG4oQxs4r0QxoVjx6kpGtIyUrh8xcPX8+06NAaamuoRrJsojzl6kZE1aW62AVEJXCfv8Y3hvVAjvzwrBCdEom58MScbc1w6gqBz3b+jDjX+mhvPynqOMEH4LRC2WySA3iaW/OBw+24qVBvvx2PIQVh28QnZLFN7sD+WZ3IN0bOjC+owcDm7ti6d1TdGlBKnODD8vl5hmZ+JGdNwQ5/GTpL2ZqK+/H2FLCjEZmxU8EdDmyjaxUuU6PK/RKysKhEbi1gXodwacXOLeoNgMUk5LFxjNhrD0RyrWYQg+1s7c9s3o3YEBT59tX7CWFw7qpMk5Mo4XBH0LXp6tlbbfjz2N+DIxYAhpI6PQCnvZ38Qw+LUauzR3LzF+nZYmRrPYJLbVJSoTkmbWG92XhjrejRTEDqdMrmBoZMKOXD9/uCiQgKoXGRQQqzIwNeG1IMxo5W96dYrFKch99A6sZrZH0CO77WKo770BMShYOFsY0crYsdrZ0wD+Wo9fjeKJ3Q2zMjQrCDUXJyNaRnavHxvwO5f3GFjB+ubSHbH9LQpyRF2DcMqjXvjLvskLYWRgzu18jZvVqwL+XIll3MpSDgbEcvhbH4WtxmBheoH9TZ0a2caefrzNm5vYyYSR/yoheL+ORoi7keXvX5TopLE+iLEcmf2QmVnxxZvYiGG3fQC4ODSXU69ISTKs+eLUoienZbLsYyd/nbnL0ehz5/e4ywcCNh7t60bY8hQfBh2HdNEiLFu923DJo2L9a11oagdGpxG77EGdNIolmnngOfr7GX7MY+dqlFmWPaUvLlhMfc+P7yJOMy9N6tvOumVaeOkZ+BWtjZzGMQbFpNHaxQqdX0GpktF/PxpUbXnE3UY1kWQxZALtegn0L5KDbZuJtH25hYkh8ejZGRUJq+/1j+PNsOA2cLJnSpaTIenJmDv9ejOTXYyEYaTU0dbPi/TF36FHTaMTT8OgsKiwJQbB0IPR5VQTL78KPz9hQy8g27oxs405YQjrrT4Xx19mbBMWmse1iJNsuRmJqpKVHQ0f6N3Omf1Nn3GzMxHtzbCSXW1EUacFIjZYG/uxUyE6DnIzij9MaSAjc2EIu5g6ifFODuTuAG7Fp7L4aze6r0RwLiisIpwK0q2/LhI6ejGjtVmpxQgl0uXDgczkBU3RiyCetuivFHKlZuXy0/A8WsxkA61ELanzflaCgV7D0oi5FUQoKnWzN7/LaapIYP7l2bFK767jLdPaxp4mrFUsPBjGohWuB8bxXUI1kWbSZCBkhcPgbqTa0coUGfcp8uKe9Ob4uVnyzK4CZvXzwi0zh50M3cLIy4fVhzYDCEuh8rtxMZtHea7TztGVQCxeWHbzBoC/3sXBK+zvrZnp0gKf2w9/PSW/fng+kAvbBJeBUg5Jity7DzpznH2jCcwMac+lmMpvPR7D5/E3CEjLYdTWaXVfFa2jkbEkXH3u6NnCgSwN7nK1uCa9oNGBuL5c6QERSBseux3MsKJ6j1+MIukV2sKmrFaPaujOytXvFJmUkBEu1cuhR+b/1RBjxZY1WsOaj0yu8sPoUT6cuxEirI6vhEEyaDq/x1y1BfF5ezr50AfW4tGzSs3VoNOBuW3fDcBUm6qJcu7So3XVUA8mZOSh6ikW/SouS5bd6TOzoyaf/XuVMSALt6ldeiKM2UI3k7XjgPWlvuLpVRiLdBnsLY76Z3I7n1pzhuTVn0ekVBjZ3YVJnTxo5S29j/tcn/8uUkJ5DbGoWX0xsKy/XzIWpS4+z43JU+cSlzexg/ApRxNn6kuT9FveCfq9Dt9l3NaSj0WhoWc+GlvVseHWIL35RKey6Ip7X6ZAEAqNTCYxOZdUxKYF3tzGllYcNrT1sae5uTRMXK9xtTO/6HDlFUYhMzsQvMoWL4UlcCE/iYngy4YnFPVhDrYbOPvb0b+pMv6bONHSqYL+qoohIwdaXICsZjK1EXekOEYrq5IMtV3AJWE1HI390hhaYjPq8Rgu/yiQuUK4dSjeS+X11rtamdW5sUpWIuiTX97iRfO2P8wRGpxIcn87Y9vXo09iJ7o0c0Wg0JQxlfj7e19WSkPh0Mur4xI/SUI3k7dBqYcxiUZlxb1t4u6JImDPspBzw2j4MRma4WJuy5oluBMWmYW1qiIOlVGpeiUimmZt1wRcmV68Ql5qFoij4ulhxMTyJlvVsyMrV42Rlwskb8WTm6DA20N5ZpkmjkYkQ3j1h01wI3Ak73xHDOeJL8OxcQzvndkvS0NTVmqau1szu14iEtGyO34jn2HXxyq5EJnMzKZObSZn8e6lwpqCliSGNnC3xcbTAw84s72KOo6UJDpbG2JkbVzhUo9MrJGXkEJ+WTVRyJuEJGYQnZhCWkMG1GDHcqaWoumg10LKeDV187OnsI96vdXlCqaWRGCITPAJ3yP8enWHsD1LZe5f4+VAQuw8fZouxTJgxGPhOjfXb3pG463JdhicZkmckPe1qSEChNtDrpNoapHDsHuWZVacIjE5lbv/GhCdm8O+lSA4HxvFknwaMaC2zTXN1+mKV3Dq9QiNnK3bP61vxFrg6gGok74SRaXEDCbDnQwltpsVIv9Pu98WY+g4BpOw/n03nbrJwdwCP9/BhUmfJS365w59D1+JQFAVTQwPGLjrMo928SMnM5VxYIqPb1sPUyACdXiEtK5fQhHTcrM1uX9hj7Q4Pr5ehudvflNDO0oHQYTr0fxssHKp5x5QfOwtjBrdwZXCe4lBqVi6X8ry2c2FJXI1IJig2jdSsXM6GJnI2NLHU7Wg0MsnEwtgAM2MDzI0NMTTQoIGCs9esXB2ZOXoysnWkZ+eSmJFzR012A60GbwdzWtazoVWeN9zC3bp8+cXbodfBiZ9Ewi8nTRrne7+Slzu+ez+9v8/d5KPN51lvtBALTZb0rXaadddevxg5GXLSCWX2pF6+mQxAI5f7SBs41l8qW40syvSg6zohcekExabz0dhWdPCStEiPho78djyYj/+5ir25Md0bOWJooCFXpyciKRNPe/OCCNq9aCBBNZIV5/w6OPQV9HtDpNhs68OOd+Rg2LBfiT6/xnmeUUdvicNfCEviyPU4+vk68XTfhhhoNGy/HMV7f1/i4S5evNTYl5Ft5Izs73M3WXowiBydnqSMHKZ19+apPrf5gWk0oi/aZCjseFv67k4tl/mHveaJ/mgN6X9WBEsTQ7o0cKBLg0LDnZ2r50ZcGgFRqYTEpxOWkE5oQgY3EzOIS80iIV2MXVJGDkkZORV+TWtTQ5ysTKhnZ049WzPq2ZrSwMmSxs6WeDlYVL/STNAB+Hd+4UzO+t1g5DfgdHeLNvb4RfPiurPMM1hHa20QipkdmgeX1J7WbsR5KVaydBGRjFI4F5YIQFsP27u3rpomf9ycW5t7S7axCAoKYQnpxKRkFdzWysOGqVpvUjJz+XyHP5725njam/PN7kB2XI5i8SPt8XK4N41jPqqRrAjJEZJT6vq0TILI11H1HQZHFkJiaInKzWZu1iyZWiiArqBwJSKZOf0aYWJogF6v0KORI642ZtS3Ny8wkHGpWWy5EIGzlQnPDmhMVHImH227Skh8Om+PaI6Jobbs/J2FA4z5DtpOkX7KyAsSgj3xk+ivtnyozv1QjQ21NHGxKjMXm6vTk5CeQ1KGFHWkZ+vIyNaRo9OjUKiXbWKkxdRQPE0LYwNszY2xNTcqVnVco8RflxOUK3/nLcgGBrwlI9DusmHa5x/DkytP0Vk5z1NGUs2qGbWwWsQTKk34Kbl2b19qPlSnV7gQJvn/1p51s7m8UtzMM5J3oVWrpjA1MsDH0YIrESn09XUuEHpo7m7Ng+3q8fl2f44HxeNpb46bjSm+Lpb3RXWyaiQrwo63wNoDuj9bXGg85qq0iZSjqd/V2pSW7jZEJsuIIK1Wg42ZETq9niuRyYxBDmC25sakZeUytJVbgdivVqPhw21XSM7Iwdm6HB6hdw94Yj+cXwu7/idFSBtmSftB39eg2eh7ZnqHoYEWJyuTujs2Kfmm7NdTK6TfU6OFjo/L3EmLu98LtutKFE//eho7XSyLLBaDDllPfs9qbRF6TK7rlS6k7h+VQlq2DjMjAxpVtDiqLhOWJ57h3q5211EFXKxNGdrSja92+tPZx54ejQq/1wOaubBk33V2+0XzUAcPJneuz8SOnnVy9FVFUY1keYnxkykRQz+R3rx8UqPlLNHGs1zembO1KWPa1eOjrVe5Fp1GAycLTtyI52pECt9OlrNM/6gUjl6Pw8nKhB2Xo5jcyRNDAy0pWTno9AqBManlM5IgRrDtZGg+Go4ukpaWmKvSY+ncAnq/BM1G3V091fuJ1Gg4+JV46fkT5xv2h0EfVIsObGX452IEc1efQavLYq3Nt9hkJchnPeiDWllPAXodBO2Tv316lfqQ/f6ixtO1gX3ZMn73GlkpojYFUL9r7a6lijzdtyEXw5OYt+4c3z/SntYetgXFdA2dLTE1KvzM7gcDCaqRLD+pUdK07tS0eJjo2h7JP3V9Wnr8FKVkGCk7XQ6geYN6H+nqRWcfez7ceoVzYYkYajV8M7kdPo4W7LoSxaf/+mFqZEBfXyeCrkbT+r3tDGvlxungBBo7W9HOsxJ9RsbmYhA7zYSj34vBjL4E6x+TvGqXp6H91App1f6nifGXEPu5NYXGsX43yVWXYQDuBquOBfPWnxfRKwq/O/2Kd4qfqBFNWlVz47bKS8RZEYwwsS7Tk9wfIEayd5Oy1XjuOUKPg6KX31ltVRRXI19ObMv0n48z57czPNG7Ae3q25KUkcO2ixG8NOju9WjfLVQjWV6MLaSatehon2t7JJRp7yNjrfLR68SrjL8u4beg/aLX6NkZBsvZfBMXK5Y/1pm41CzsLYwLZqxtOneTBk4WvD2iBa42pjzTtxHvbLpIapaOrye1w9naBDNjg1Ibd8uFma3I7HV5UuTtTvwkLQr/zoe9H0kes8Nj4Ny0avvrfkSvh+t7ZJ6m/z+Ft9frKL2pDfvXTt8h0rT9+Q4/vtsjjfrfe+2jU9RO+d5N+OWutpuUybXdcu3Tu9Qe3vTsXE4EJQDQ534ykiFH5Lp+99pdRzVhbKjlt1ldefn3c6w5EcrXuwIwMzLg0a5ePNL1/tOkVY1kebH1kibgA5/JlIboK+KNmdtLCBYKjaMmL+y69WWZm9egL3h1h93/B8tHyIzAPK8yv5cyX5lCr0BCWk6B4K+xoZaW9WxYczyUxi6WmORVYVa56d7cXg7sPV8Qb+jId6IteWyxXLx6iLFsOrz2PZDaJi0WzvwKp34unCyPRgq2us8RD7KWjCPIxIyX15/n73Mi97aoTRBD/X6QO4d+XKuebTGubpHrRgNKvXvXlWiydXrq25sXa6O65wnaL9de94eRzOeTca2JTskiJiULUyODAtGU+w3VSJYXC0cY+yP8MVNClHqdDBfuMB2cm+U9qMiBMviICHf3flmG+IKUf68aJwb2lh9Mfvy+s489f5wK41pMKg2dLMnKm8wekZRBVo6++kcHGZlBx8eg/TS4vhtO/iw9oMGH5GJkIcUerSaIsf+v5C6z02Tk14XfIXCXFOOAVKu2mSjtNHWg3y08MYNnfj3FubAkDLUalvZKps+Jd+XOrs9IeL0uEHdNFKE0BtB0ZKkP+fOMjDUb1cb9risv1RiZSYVFOw371e5aqoher7DqWDATO9XHOK+63sXaFJfy1kfco/xHjnjVhE09eHwbxAbISCfLvJBQ9FUJTxatFLVwklFR1u5FNqCRZur8UUGlMLGjJ6eDE3jwu0NM7lwfv6gUzoUmMrWbNzbmRuz3j6FHI8fqFwnWaqHRA3JJCofTv8jg5MRgCSmfXyveb+PB0HQYNBxQvML3fiA9HgJ2gP82GSSdk154n3t7qQ5tOfau6KyWh4MBsTy75gzxadnYmBnx6yCFVrtfEIPefIzMHK0rXNoo1w36FP5uihCXmsW+vKKdMe3q1mT6KnHjoPSFOjSSnOQ9zMf/XmXJvuvsvBLN8sc63T8nMndANZKVwbHIBPcL62WifNenpZE/HxMrMZCnVhR6jcEHZfZhbhYl0OtBq8XYUMuXE9uy52o0G86E425rRq/GTszo6cOhwFgeXXac9vVt+Whsa3xda6jIxqae5C37viZFBxd+h0sbZHbj+TVyMTCR99Wwn+TiqnFG411Dr5Nikuv7RM4v5IgUWORj5yNRgJbj6lSOVq9XWLQ3kC92+KNXoGU9a34aaITrxgli2Bs9IFGPutILqyhw8Q/5u8XYUh/y97mb5OoVWnvY3F9hu+v51by9a3cdVWT9qTCW7BM5wQfb1fvPGEhQjWTVcWws7R/18gQDcrNl9JCVC0z8FVaNh8+bSajy3Gqpbms9QR6bkSgeWsIN+btB3wLB6355QtpFiUvNwtLEkNMhiQz/5gAzevnw3IDGmBvX0Meo0UD9LnIZskB63Py2Sm4pIUiKWK7vkeZ5c0fw7CLFSZ5dJLRc13KZ2WkS8gs7KcY/+GBJ4XrnFiIv6DtcGr/r2MEgLCGdl34/x9Hr8QBM6OjB/3VRMPltDGQlSX50wsq7P/7qdoSfgujLYGhaap+mXq/wy5FgAMZ1uPerP4uRr9fb4N4NtZ68Ec/rG0Q5am7/RveXp18ONIpyJ2XL/xbJycnY2NiQlJSEtXUFh/Xq9RDrJ4UeXt0Lz+QvbpDexH2fwEM/iXcSuAvOrISwU9B8lDz27GrJb45fXjAy6tYq1puJGbz396UCYfB6tma8M7I5A5u73L2zO0URLcpre6Ri8cZB0SYtikYrISaXluDaUmbo2TcQ76ymjWdOhlTsxl2Tg3P0FbmOuVrcUwTJMXr3lBOUJoPr7MR4RVHYeCacd/66REpWLubGBrw7qgUTXCJh1UNi7D06wdSNda+N58/ZIpHYZjI8uLjE3XuuRvPY8hNYmRpydP4ALEzuk3P32EBY2EEGuL8aVPc+l3IQlpDO6IWHiEvLZmhLV76b0r7O9z9W6RheCvfJt7EOcW0PnF6RN9exqWilGhhLuKnxIDGQWSnSbmFsKdWRXZ6U53Z/Fv55Tby11pPAwLCE4XO3NWPJ1I7svBzFO5suEZ6YwRMrT9GrsSNvjWhevhFbVUWjkZmVTr7Q9Snxnm+egbDj4m2GHpe+0lh/uVzaUPz5lq4SirZykzmdFk7SmmJqI7leIzPRwDUwkUIhRS+hUb1OehKzUgov6XHS0J8aJdeJwfJ3WVi5g0dHuXj1FI+3jhcjRadk8s5fl9h2MRKA9vVt+WJCW7yTT8AvU+QExbMLPPx73TsQZyYVhlo7TC/1IUsPBgGSj79vDCQUtgl5da97n0s5SM3KZeaKk8SlZdPC3ZrPJ7Sp8wayJriPvpF1AK0Wuj0j4dOfh4FXN/k7N0sOxg8tlcft/1RCftbu4nEd+CJPgPwJGPh/YgjucOB+oLkL3Rs58O3uQJYeCOJAQCxDvz7A5M6evPBAk4LWkruCoXFhWJa54mmmRkHkRZlGEnVJBu3GXYPMREiNlEtNYmwlvYHOzfIuzcG11S2FVHUbvV5h9YkQFmy7SkpmLoZaDc8/0Jin+jTE8OomkRjUZUsob9KqOlNQVIwzqyA3A5yaiSG/hYvhSRwMjEWrgWndve/++mqSfCPZZHDtrqMS6PUKz685y9XIFBwtTfjx0Y41l9ap4/w333VNM+wTUa8J3CmSb+5tJfRoZAo3z0rlpEcnCT0ZW0LIYTj0tXg3FRBANjc25NUhTZnUyZMPt17h30tR/Ho0hI2nw5nRqwGzevlUfdxTZdBoxEO0coXGDxS/Lz1eThxSIiElQi7pcZKTzUwSI5qTIScWuhwxAvm9p1oD8cpNrWW/mViKRKCFM1g6i0dqWx/svKUSt47lEyuCX2QKb2y8wMlgaa5vVc+Gj8a2oqW7tSgm/fs6oECzkXLyZXgXT4rKS262qBKBREtK+Ty+2OEPSNuHp30dy2FXhdQYaaEC6TW+x/hsux87r0RhbKjlx0c74G5rVttLqjVUI1lTuLaSSz76vFxYWoyECQf+r7DPzqsHbH9LKi3rtS9d2u42eDlYsGRqR45ci+PDrVe4EJ7EN7sCWHnkBs/0bcQjXb0wM64jlY7m9gX5VpWSxKRk8cUOf9aeCEGvgIWxAfMG+TKtuzcGSi78/ZyE80HEHoZ/XneqWG/lwjpIDpfwetspJe4+E5LA7qvRGGg1PPfA3R0hVuNc3SxpAre2ctJ2D/HnmXAW7RXlpk8eak27+pWQwbyPUI3k3SK/PSIlQjymW0Mwls7iZUGlPaBuDR3YNKcH2y5G8tl2P67HpPHB1iss2X+Nmb0a8EhXLyzvp5zPfURGto5lh4JYtCeQtGwRkBjWypU3hzeXs/j0eFj3KNw4AGikB7Lb7LrrLev1IvwOkoIoxdPN9yLHtqt3fynsAFz+S65bjKnVZVSUMyEJvPKHiLE/07fhf66StTTUI+bdpl4HyZWFnQKPDuJVXtoohS/5OcsqoNFoGNbKjUHNXdhwOpxvdgcQlpDBgm1XWbzvGo9192FqNy/sLepQi8B/mMwcHb8dC2HR3mvEpkr/bBsPG94c0ZxO3nked/hpmdqSGCxh5oeWSptKXebiHyJzaGojHu8t7PWL5kBALIZaDXP7Ny5lA/cwKVGF006ajardtVSAyKRMnlx5iuxcPQ80c7kvxcorg2ok7zYOjcDRF36bAJ1mwPW9Msy57+tiPPNEBaqKoYGWCZ08ebB9vYLwSVBsGl/u9GfR3kAe6uDBjJ4+NLyfZvbdQ2Rk6/j9VCjf7QkkKlmMo6e9GfMG+jKqjbtUESqKiKn/+4ao6Nh6weTVoiFcl8nNhj15aj/d50oOuQjZuXr+t/kyANO7e1Pf4T7KRQJcXC+hVo9OdUK6sDxk5uh4YuVJolOy8HWx4qtJbf+TlayloRrJu42hCYxbCud/l7NNzy5yaTZC5O4OfCGhNAuHO2+rHBgZaBnf0ZOx7T3YfP4mPx64zsXwZH47FsJvx0Lo6+vEI1286NfUufql7lRKEJuaxcojwaw8Gkx8WjYA7jamzOnfmPEdPTDKn6GYmQSb5haG7ZqOgNELC4Tx6zT5QvCWLqIfews/HwriekwajpbGPPvAfeZFgoiGALSZVLvrKCeKovDy+vOcD0vCztyIn6Z1VNMyRVD3RG3Rerz0TObnlBQFNj0rla4B20Xhpuj9VcRAq2F023qMauPOsaB4fjogGox7/WLY6xdDPVszJnf2ZFwHz4IJJCrVx8XwJH49GszGM+Fk5UoRl4edGU/0bsDETp6YGBYpvgnaLw34SSHSiD7o/0RQva7mH4uSkSiiGSCyhre0pdxMzOCbXQEAvDKkKda1UX1dk0RfhcgL8rmVIcFX11i09xp/n7uJoVbD9490uL+qjKuBe8ZIfvDBB2zZsoWzZ89ibGxMYmJiiceEhIQwe/Zsdu/ejZmZGVOmTOGzzz7D2LiO5t+KHvQ0ecUYf82GmCuwYSac+QWGfSZN+9X2khq6NnCgawMHbsSmsepYML+fCiM8MYPPtvvzxQ5/ejV2YlwHDwY2d6n+qSP/ITKydWy7GMHKo8GcCUksuL2Nhw1P9G7I4BYuGBoUCa3nZMDO9+DY9/K/rReM+1ly1/cKez6A9FhRWGo3tdhdiqLw6h/nScvW0dHLjnHt7zMJOhBlIYDGA++JKu6dl6P4bLsfAO+OakHXBtUTwbqfuGeMZHZ2NuPHj6dbt24sXVqywEWn0zF8+HCcnJw4ePAgcXFxTJs2DUVR+Pbbb2thxZXAowM8uR8Ofw37PxOP4vseUsXY++Vqn7rh7WjBG8ObM2+QL1svRLDmeCjHb8Szzz+Gff4xWJkYMrCFCyNau9GzkRPGhveYgHktoNcrHA2KY+PpcLZdjCQ1KxcAIwMNQ1q6MbWrF5287UpKCAYfkfBqnHhZdHhMTprupUkrN8/KEG+AYZ+WGKy85kQoBwJiMTHU8sm41vdfzis3W2azQokThLqIf1QKz605g6LAI13r35cDk6uDe067dfny5Tz//PMlPMlt27YxYsQIQkNDcXcXVZU1a9Ywffp0oqOjy63hV926f5Um4QZse03GNoH0mg16X8K0NciN2DQ2nA7jj9PhhCdmFNxubWrIA81cmNDJUz3bLIWQuHSWHQri30uRRCRlFtyeH8ae0MkTZ6tSwtjZabDtVdHxBZHqG7WwpAhDXUevh6UPiJh5y4dg3LJid4cnZjD4y/2kZuXy5vBmzOzVoJYWWoNc3gTrpkou9oXLdVruMDE9m9HfHSI4Lp2uDexZOaNLYT78HkfVbi2DI0eO0LJlywIDCTB48GCysrI4deoU/fqVrsKflZVFVlbh6KqkJJkKkZycXLMLvhMG9jDiB5lvuPMdiAuBiGvgXbPrsjeGmV3deLyzK2dDE/j3UhTbL0USk5TO+qPJ+NhoaO54n+WRqoGY+BSW7ZGKTUtTA4a0cGVEa3fa17fLq1TNJjk5u+QT9ToIOgNZigiA950vYbra/v5VlOx0sGoMih90fa3E+uMS0vC0BCMbYx5q5VD7v6+aIEsBu9YiDpKWfufH1yIJqVnYGuSSZaZnwcjGZKSlknHnp90T5H+3qs3/U+4xfv75Z8XGxqbE7bNmzVIGDhxY4nZjY2Plt99+K3N777zzjgKoF/WiXtSLermPLteuXasWm1OrnuS7777Le++9d9vHnDhxgo4dO5Zre6WNilJuGTV1K/Pnz+fFF18s+D8xMREvLy9CQkKwsbEp1+vWBZKTk/H09CQ0NLR2w8QVRF333eVeXTfcu2tX1313SUpKon79+tjbV0/hVK0ayTlz5jBp0u17iby9vcu1LVdXV44dO1bstoSEBHJycnBxcezCF+EAAAvPSURBVCnzeSYmJpiYlJTMsrGxuae+GPlYW1ur676LqOu++9yra1fXfXfRVoMoC9SykXR0dMTR0bFattWtWzc++OADIiIicHNzA2D79u2YmJjQocM9VEKvoqKiolJnuGcKd0JCQoiPjyckJASdTsfZs2cBaNSoEZaWlgwaNIjmzZszdepUPv30U+Lj43nppZeYNWvWPXkWpKKioqJS+9wzRvLtt99mxYoVBf+3a9cOgD179tC3b18MDAzYsmULzzzzDD169CgmJlARTExMeOedd0oNwdZl1HXfXdR1333u1bWr6767VPe677k+SRUVFRUVlbvF/dE9qqKioqKiUgOoRlJFRUVFRaUMVCOpoqKioqJSBqqRVFFRUVFRKQPVSObxwQcf0L17d8zNzbG1tS31MSEhIYwcORILCwscHR159tlnyc4uRY+zlvH29kaj0RS7vPbaa7W9rBIsWrQIHx8fTE1N6dChAwcOHKjtJd2Rd999t8S+dXV1re1llWD//v2MHDkSd3d3NBoNf/75Z7H7FUXh3Xffxd3dHTMzM/r27culS5dqZ7FFuNO6p0+fXmL/d+3atXYWW4SPPvqITp06YWVlhbOzM2PGjMHPz6/YY+riPi/PuuviPv/+++9p3bp1gdBBt27d2LZtW8H91bmvVSOZR/4orqeffrrU+/NHcaWlpXHw4EHWrFnDH3/8wbx58+7ySsvH//73PyIiIgoub775Zm0vqRhr167l+eef54033uDMmTP06tWLoUOHEhISUttLuyMtWrQotm8vXLhQ20sqQVpaGm3atGHhwoWl3v/JJ5/wxRdfsHDhQk6cOIGrqysDBw4kJSXlLq+0OHdaN8CQIUOK7f+tW7fexRWWzr59+5g9ezZHjx5lx44d5ObmMmjQINLS0goeUxf3eXnWDXVvn3t4eLBgwQJOnjzJyZMn6d+/P6NHjy4whNW6r6tFAfY+oiwB9a1btyparVYJDw8vuG316tWKiYmJkpSUdBdXeGe8vLyUL7/8sraXcVs6d+6sPPXUU8Vua9q0qfLaa6/V0orKxzvvvKO0adOmtpdRIQBl48aNBf/r9XrF1dVVWbBgQcFtmZmZio2NjbJ48eJaWGHp3LpuRVGUadOmKaNHj66V9VSE6OhoBVD27dunKMq9s89vXbei3Dv73M7OTvnpp5+qfV+rnmQ5udMorrrGxx9/jIODA23btuWDDz6oU2Hh7OxsTp06xaBBg4rdPmjQIA4fPlxLqyo/AQEBuLu74+Pjw6RJk7h+/XptL6lCBAUFERkZWWz/m5iY0KdPn3ti/+/duxdnZ2eaNGnCrFmziI6Oru0llSB/5F6+yPa9ss9vXXc+dXmf63Q61qxZQ1paGt26dav2fX3PKO7UNpGRkSWE0u3s7DA2NiYyMrKWVlU6zz33HO3bt8fOzo7jx48zf/58goKC+Omnn2p7aQDExsai0+lK7E8XF5c6ty9vpUuXLvzyyy80adKEqKgo3n//fbp3786lS5dwcLg3hlHn7+PS9n9wcHBtLKncDB06lPHjx+Pl5UVQUBBvvfUW/fv359SpU3VGGUZRFF588UV69uxJy5YtgXtjn5e2bqi7+/zChQt069aNzMxMLC0t2bhxI82bNy8whNW1r+9rI1kXRnFVFxV5Ly+88ELBba1bt8bOzo5x48YVeJd1hVv3293al1Vh6NChBX+3atWKbt260bBhQ1asWFFs5Nq9wL24/ydOnFjwd8uWLenYsSNeXl5s2bKFsWPH1uLKCpkzZw7nz5/n4MGDJe6ry/u8rHXX1X3u6+vL2bNnSUxM5I8//mDatGns27ev4P7q2tf3tZGsC6O4qouqvJf8SrTAwMA6YSQdHR0xMDAo4TVGR0fflX1ZnVhYWNCqVSsCAgJqeynlJr8aNzIysmBiDtyb+9/NzQ0vL686s//nzp3Lpk2b2L9/Px4eHgW31/V9Xta6S6Ou7HNjY2MaNWoEQMeOHTlx4gRff/01r776KlB9+/q+NpL30yiuqryXM2fOABT7wtQmxsbGdOjQgR07dvDggw8W3L5jxw5Gjx5diyurOFlZWVy5coVevXrV9lLKjY+PD66uruzYsaNgUEB2djb79u3j448/ruXVVYy4uDhCQ0Nr/butKApz585l48aN7N27Fx8fn2L319V9fqd1l0Zd2ee3oigKWVlZ1b+vq15TdH8QHBysnDlzRnnvvfcUS0tL5cyZM8qZM2eUlJQURVEUJTc3V2nZsqUyYMAA5fTp08rOnTsVDw8PZc6cObW88uIcPnxY+eKLL5QzZ84o169fV9auXau4u7sro0aNqu2lFWPNmjWKkZGRsnTpUuXy5cvK888/r1hYWCg3btyo7aXdlnnz5il79+5Vrl+/rhw9elQZMWKEYmVlVefWnZKSUvAdBgq+E8HBwYqiKMqCBQsUGxsbZcOGDcqFCxeUyZMnK25ubkpycnKdXXdKSooyb9485fDhw0pQUJCyZ88epVu3bkq9evVqfd1PP/20YmNjo+zdu1eJiIgouKSnpxc8pi7u8zutu67u8/nz5yv79+9XgoKClPPnzyuvv/66otVqle3btyuKUr37WjWSeUybNk0BSlz27NlT8Jjg4GBl+PDhipmZmWJvb6/MmTNHyczMrL1Fl8KpU6eULl26KDY2Noqpqani6+urvPPOO0paWlptL60E3333neLl5aUYGxsr7du3L1Z2XleZOHGi4ubmphgZGSnu7u7K2LFjlUuXLtX2skqwZ8+eUr/P06ZNUxRFWhLeeecdxdXVVTExMVF69+6tXLhwoXYXrdx+3enp6cqgQYMUJycnxcjISKlfv74ybdo0JSQkpLaXXeqaAeXnn38ueExd3Od3Wndd3eePP/54wbHDyclJGTBgQIGBVJTq3dfqqCwVFRUVFZUyUPskVVRUVFRUykA1kioqKioqKmWgGkkVFRUVFZUyUI2kioqKiopKGahGUkVFRUVFpQxUI6mioqKiolIGqpFUUVFRUVEpA9VIqqioqKiolIFqJFVU7mNu3LiBRqNBo9HQtm3bKm8vf1u2trZV3paKyr2AaiRVVP4D7Ny5k127dlV5OxEREXz11VdVX5CKyj2CaiRVVP4DODg4VMuYNFdXV2xsbKphRSoq9waqkVRRuUeIiYnB1dWVDz/8sOC2Y8eOYWxszPbt2yu0renTpzNmzBg+/PBDXFxcsLW15b333iM3N5eXX34Ze3t7PDw8WLZsWXW/DRWVe4r7ep6kisr9hJOTE8uWLWPMmDEMGjSIpk2b8sgjj/DMM88waNCgCm9v9+7deHh4sH//fg4dOsSMGTM4cuQIvXv35tixY6xdu5annnqKgQMH4unpWQPvSEWl7qN6kioq9xDDhg1j1qxZPPzwwzz11FOYmpqyYMGCSm3L3t6eb775Bl9fXx5//HF8fX1JT0/n9ddfp3HjxsyfPx9jY2MOHTpUze9CReXeQTWSKir3GJ999hm5ubmsW7eOVatWYWpqWqnttGjRAq228BDg4uJCq1atCv43MDDAwcGB6OjoKq9ZReVeRTWSKir3GNevX+fmzZvo9XqCg4MrvR0jI6Ni/2s0mlJv0+v1lX4NFZV7HTUnqaJyD5Gdnc3DDz/MxIkTadq0KTNmzODChQu4uLjU9tJUVO5LVE9SReUe4o033iApKYlvvvmGV155hWbNmjFjxozaXpaKyn2LaiRVVO4R9u7dy1dffcXKlSuxtrZGq9WycuVKDh48yPfff1/by1NRuS9Rw60qKvcIffv2JScnp9ht9evXJzExscLbWr58eYnb9u7dW+K2GzduVHjbKir3E6qRVFH5D9C9e3fatm3L4cOHq7QdS0tLcnNzK11Rq6Jyr6EaSRWV+xgPDw8CAgIAMDExqfL2zp49C0h7iIrKfwGNoihKbS9CRUVFRUWlLqIW7qioqKioqJSBaiRVVFRUVFTKQDWSKioqKioqZaAaSRUVFRUVlTJQjaSKioqKikoZqEZSRUVFRUWlDFQjqaKioqKiUgaqkVRRUVFRUSmD/wd6DA58YA9L3wAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "models[0].plot([-10, 30, -10, 30])\n", + "models[0].contour([-10, 30, -10, 30], 101, newfig=False, decimals=2, color=\"C0\")\n", + "models[-1].contour([-10, 30, -10, 30], 101, newfig=False, decimals=2, color=\"C1\")\n", + "\n", + "plt.xlabel(\"x [m]\")\n", + "plt.ylabel(\"y [m]\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Compare the head along the line-sink to the specified head-conditions for each model." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for i, iml in enumerate(models):\n", + " x, y = refine_n_segments(xy, \"line\", 101)[0].T\n", + " r = np.sqrt((x - x[0]) ** 2 + (y - y[0]) ** 2)\n", + " h = iml.headalongline(x, y)\n", + " plt.plot(r, h[0], c=f\"C{i}\", label=f\"{i+1}\")\n", + "\n", + "plt.plot(r[[0, -1]], hls._hls[[0, -1]], ls=\"dashed\", color=\"k\")\n", + "plt.xlabel(\"distance along line-sink [m]\")\n", + "plt.ylabel(\"head [m+ref]\")\n", + "plt.legend(loc=(0, 1), frameon=False, ncol=9, fontsize=\"x-small\")\n", + "plt.grid(True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Refining inhomogeneities: LeakyBuildingPit\n", + "\n", + "In this example a model with an inhomogeneity is refined. In this case we're refining a\n", + "rectangular LeakyBuildingPit with a sheetpile wall that has an effective resistance of\n", + "100 days on three sides. On the northern side, the sheetpile wall has almost no\n", + "resistance. The bottom of the sheetpile wall reaches halfway into the aquifer.\n", + "\n", + "The model is confined, and a well is pumping inside the leaky building pit with 100\n", + "$m^3$/day. Define the coordinates of the leaky building pit and the resistance of the\n", + "walls." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "xy = [\n", + " (-10, -5),\n", + " (10, -5),\n", + " (10, 5),\n", + " (-10, 5),\n", + " (-10, -5),\n", + "]\n", + "\n", + "res = np.array([100.0, 100.0, 1e-3, 100.0]) # resistance of leaky wall, in days" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Build the model, without refinement." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of elements, Number of equations: 19 , 65\n", + "...................\n", + "solution complete\n" + ] + } + ], + "source": [ + "ml = tml.ModelMaq(kaq=kh, z=z, c=[ctop, 1], topboundary=\"semi\", hstar=0.0)\n", + "bpit = tml.LeakyBuildingPitMaq(\n", + " ml,\n", + " xy,\n", + " kaq=kh,\n", + " z=z[1:],\n", + " topboundary=\"conf\",\n", + " c=[1],\n", + " layers=[0],\n", + " res=res,\n", + ")\n", + "well = tml.Well(ml, 0.0, 0.0, Qw=Qw, rw=rw)\n", + "ml.solve()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot the head contours in both layers. Note the head contours in the corners of the\n", + "leaky building pit. Clearly, the solution isn't quite right at these locations." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "tiny = 1e-5\n", + "xgr = np.linspace(-10 + tiny, 10 - tiny, 101)\n", + "ygr = np.linspace(-5 + tiny, 5 - tiny, 51)\n", + "h = ml.headgrid(xgr, ygr)\n", + "plt.contour(xgr, ygr, h[0], levels=20, colors=\"C0\")\n", + "plt.contour(xgr, ygr, h[1], levels=20, colors=\"C1\")\n", + "plt.axis(\"scaled\")\n", + "plt.xlabel(\"x [m]\")\n", + "plt.xlabel(\"y [m]\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also see that the water balance isn't quite correct. In the first layer, along 3\n", + "sides, there is a discharge out of the building pit (negative numbers), which is not\n", + "what we would expect, and the total discharge flowing into the building pit should\n", + "equal the pumping discharge of the well (it's close but not quite right)." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
SideSENWtotal
Layer
0-0.7-0.456.0-0.454.4
119.210.45.510.445.6
total18.610.061.510.0100.1
\n", + "
" + ], + "text/plain": [ + "Side S E N W total\n", + "Layer \n", + "0 -0.7 -0.4 56.0 -0.4 54.4\n", + "1 19.2 10.4 5.5 10.4 45.6\n", + "total 18.6 10.0 61.5 10.0 100.1" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = pd.DataFrame(\n", + " index=np.arange(ml.aq.naq),\n", + " columns=[\"S\", \"E\", \"N\", \"W\"],\n", + " data=ml.intnormflux(xy, ndeg=99),\n", + ")\n", + "df.index.name = \"Layer\"\n", + "df.columns.name = \"Side\"\n", + "df[\"total\"] = df.sum(axis=1)\n", + "df.loc[\"total\", :] = df.sum(axis=0)\n", + "df.round(1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, let's refine the leaky building pit, and see how that affects the solution. Let's\n", + "try a `refine_level` of 3." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of elements, Number of equations: 51 , 193\n", + "...................................................\n", + "solution complete\n" + ] + } + ], + "source": [ + "mlr = tml.ModelMaq(kaq=kh, z=z, c=[ctop, 1], topboundary=\"semi\", hstar=0.0)\n", + "bpitr = tml.LeakyBuildingPitMaq(\n", + " mlr,\n", + " xy,\n", + " kaq=kh,\n", + " z=z[1:],\n", + " topboundary=\"conf\",\n", + " c=[1],\n", + " layers=[0],\n", + " res=res,\n", + " refine_level=3,\n", + ")\n", + "wellr = tml.Well(mlr, 0.0, 0.0, Qw=Qw, rw=rw)\n", + "mlr.solve()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot the contours. The results in the corners of the building pit seem a lot more\n", + "realistic, though there are still some visible minor irregularities in the top-left and\n", + "right corners." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "tiny = 1e-5\n", + "xgr = np.linspace(-10 + tiny, 10 - tiny, 101)\n", + "ygr = np.linspace(-5 + tiny, 5 - tiny, 51)\n", + "h = mlr.headgrid(xgr, ygr)\n", + "plt.contour(xgr, ygr, h[0], levels=20, colors=\"C0\")\n", + "plt.contour(xgr, ygr, h[1], levels=20, colors=\"C1\")\n", + "plt.axis(\"scaled\")\n", + "plt.xlabel(\"x [m]\")\n", + "plt.xlabel(\"y [m]\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The calculated discharge is now more realistic, with no discharge out of the building\n", + "pit in layer 0 and the total discharge is exactly equal to the discharge of the pumping\n", + "well." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
SideSENWtotal
Layer
00.60.154.90.155.9
120.28.47.28.444.1
total20.98.562.18.5100.0
\n", + "
" + ], + "text/plain": [ + "Side S E N W total\n", + "Layer \n", + "0 0.6 0.1 54.9 0.1 55.9\n", + "1 20.2 8.4 7.2 8.4 44.1\n", + "total 20.9 8.5 62.1 8.5 100.0" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = pd.DataFrame(\n", + " index=np.arange(mlr.aq.naq),\n", + " columns=[\"S\", \"E\", \"N\", \"W\"],\n", + " data=mlr.intnormflux(xy, ndeg=99),\n", + ")\n", + "df.index.name = \"Layer\"\n", + "df.columns.name = \"Side\"\n", + "df[\"total\"] = df.sum(axis=1)\n", + "df.loc[\"total\", :] = df.sum(axis=0)\n", + "df.round(1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Global refine option\n", + "\n", + "In the examples above the refine_level was defined in the elements that were meant to\n", + "be refined. This allows for fine-grained control over which elements should be refined and by how much. This is the preferred method for specifying this information. However, in certain situations it can be useful to globally set a refinement level. \n", + "\n", + "This is possible by setting the `refine_level` in `ml.solve()`. Setting this kwarg to None (the default), uses the element-level settings, setting it to a number will override the element settings." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of elements, Number of equations: 4 , 3\n", + "....\n", + "solution complete\n" + ] + } + ], + "source": [ + "ml = tml.ModelMaq(kaq=kh, z=z, c=[ctop, 1], topboundary=\"semi\", hstar=0.0)\n", + "ls = tml.HeadLineSink(ml, 0, 0, 10, 10, hls=1.0)\n", + "ml.solve(refine_level=3)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[ConstantStar with head 0.0,\n", + " HeadLineSink from (0.0, 0.0) to (2.499999999999999, 2.499999999999999),\n", + " HeadLineSink from (2.499999999999999, 2.499999999999999) to (7.5, 7.5),\n", + " HeadLineSink from (7.5, 7.5) to (10.0, 10.0)]" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ml.elementlist" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "artesia", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From f9afcec7daefe511f9f4495cb69a3dcaae4a503b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 3 Jan 2024 17:38:31 +0100 Subject: [PATCH 22/39] add addtomodel kwarg --- timml/linesink1d.py | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-) diff --git a/timml/linesink1d.py b/timml/linesink1d.py index 173182a4..5ea22e29 100644 --- a/timml/linesink1d.py +++ b/timml/linesink1d.py @@ -50,7 +50,6 @@ def initialize(self): self.ncp = 1 if self.aq is None: self.aq = self.model.aq.find_aquifer_data(self.xc[0], self.yc[0]) - if self.addtomodel: self.aq.add_element(self) self.parameters = np.empty((self.nparam, 1)) @@ -147,7 +146,7 @@ class LineSink1D(LineSink1DBase, MscreenWellEquation): """ - def __init__(self, model, xls=0, sigls=1, layers=0, label=None): + def __init__(self, model, xls=0, sigls=1, layers=0, label=None, addtomodel=True): self.storeinput(inspect.currentframe()) LineSink1DBase.__init__( self, @@ -157,7 +156,7 @@ def __init__(self, model, xls=0, sigls=1, layers=0, label=None): layers=layers, name="Linesink1D", label=label, - addtomodel=True, + addtomodel=addtomodel, res=0, wh=1, aq=None, @@ -204,7 +203,9 @@ class HeadLineSink1D(LineSink1DBase, HeadEquation): """ - def __init__(self, model, xls=0, hls=1, res=0, wh=1, layers=0, label=None): + def __init__( + self, model, xls=0, hls=1, res=0, wh=1, layers=0, label=None, addtomodel=True + ): self.storeinput(inspect.currentframe()) LineSink1DBase.__init__( self, @@ -214,7 +215,7 @@ def __init__(self, model, xls=0, hls=1, res=0, wh=1, layers=0, label=None): layers=layers, name="HeadLinesink1D", label=label, - addtomodel=True, + addtomodel=addtomodel, res=res, wh=wh, aq=None, @@ -233,7 +234,9 @@ def setparams(self, sol): class HeadDiffLineSink1D(LineSink1DBase, HeadDiffEquation): """HeadDiffLineSink1D for left side (xcout)""" - def __init__(self, model, xls, label=None, aq=None, aqin=None, aqout=None): + def __init__( + self, model, xls, label=None, aq=None, aqin=None, aqout=None, addtomodel=True + ): LineSink1DBase.__init__( self, model, @@ -242,7 +245,7 @@ def __init__(self, model, xls, label=None, aq=None, aqin=None, aqout=None): layers=np.arange(model.aq.naq), label=label, name="HeadDiffLineSink1D", - addtomodel=True, + addtomodel=addtomodel, aq=aq, ) self.inhomelement = True @@ -268,7 +271,9 @@ def setparams(self, sol): class FluxDiffLineSink1D(LineSink1DBase, DisvecDiffEquation): """HeadDiffLineSink1D for left side (xcout)""" - def __init__(self, model, xls, label=None, aq=None, aqin=None, aqout=None): + def __init__( + self, model, xls, label=None, aq=None, aqin=None, aqout=None, addtomodel=True + ): LineSink1DBase.__init__( self, model, @@ -277,7 +282,7 @@ def __init__(self, model, xls, label=None, aq=None, aqin=None, aqout=None): layers=np.arange(model.aq.naq), label=label, name="FluxDiffLineSink1D", - addtomodel=True, + addtomodel=addtomodel, aq=aq, ) self.inhomelement = True From 3c2a9b6837122b5b0b98366bb56ef18e08e53270 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 3 Jan 2024 17:40:13 +0100 Subject: [PATCH 23/39] add refine logic to AquiferData class (for inhoms) - add aq.inhoms for user-added inhoms - add aq.inhomlist for computation inhoms --- timml/aquifer.py | 40 +++++++++++++++++++++------------------- 1 file changed, 21 insertions(+), 19 deletions(-) diff --git a/timml/aquifer.py b/timml/aquifer.py index e4dd62dd..2d33bb7d 100644 --- a/timml/aquifer.py +++ b/timml/aquifer.py @@ -2,7 +2,6 @@ import numpy as np -from .aquifer_parameters import param_maq from .constant import ConstantStar @@ -55,7 +54,8 @@ def __init__(self, model, kaq, c, z, npor, ltype): self.nporll = self.npor[self.ltype == "l"] def initialize(self): - self.elementlist = [] # Elementlist of aquifer + self.elementlist = [] # computation element list of aquifer + d0 = 1.0 / (self.c * self.T) d0[:-1] += 1.0 / (self.c[1:] * self.T[:-1]) dp1 = -1.0 / (self.c[1:] * self.T[1:]) @@ -108,33 +108,35 @@ def findlayer(self, z): class Aquifer(AquiferData): def __init__(self, model, kaq, c, z, npor, ltype): AquiferData.__init__(self, model, kaq, c, z, npor, ltype) - self.inhomlist = [] + self.inhoms = [] # user added inhoms self.area = 1e300 # Needed to find smallest inhom - def initialize(self): - # cause we are going to call initialize for inhoms + def initialize(self, refine_level=None): + self.inhomlist = [] # compute list for inhoms + # because we are going to call initialize for inhoms AquiferData.initialize(self) + for inhom in self.inhoms: + inhom.initialize() # always initialize original element + if hasattr(inhom, "_refine") and ( + inhom.refine_level > 1 or refine_level is not None + ): + refined_inhom = inhom._refine(n=refine_level) # create refined element + refined_inhom.initialize() + self.inhomlist.append(refined_inhom) + else: + self.inhomlist.append(inhom) for inhom in self.inhomlist: - inhom.initialize() - for inhom in self.inhomlist: - inhom.create_elements() + inhom_elements = inhom.create_elements() # create elements + self.model.elementlist += inhom_elements # add elements to compute list def add_inhom(self, inhom): - self.inhomlist.append(inhom) - return len(self.inhomlist) - 1 # returns number in the list + self.inhoms.append(inhom) + return len(self.inhoms) - 1 # returns number in the list def find_aquifer_data(self, x, y): rv = self - for inhom in self.inhomlist: + for inhom in self.inhoms: if inhom.isinside(x, y): if inhom.area < rv.area: rv = inhom return rv - # Not used anymore I think 5 Nov 2015 - # def find_aquifer_number(self, x, y): - # rv = -1 - # for i,inhom in enumerate(self.inhomlist): - # if inhom.isinside(x, y): - # if inhom.area < rv.area: - # rv = i - # return rv From 3b62e365926a899f75f0fcced81ab70f5585d376 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 3 Jan 2024 17:41:52 +0100 Subject: [PATCH 24/39] use addtomodel=False to prevent inhom elements from being added to model when created --- timml/inhomogeneity1d.py | 84 +++++++++++++++++++++++++++++----------- 1 file changed, 61 insertions(+), 23 deletions(-) diff --git a/timml/inhomogeneity1d.py b/timml/inhomogeneity1d.py index 8daee2a4..b58e454f 100644 --- a/timml/inhomogeneity1d.py +++ b/timml/inhomogeneity1d.py @@ -21,7 +21,7 @@ def __init__(self, model, x1, x2, kaq, c, z, npor, ltype, hstar, N): self.hstar = hstar self.N = N self.inhom_number = self.model.aq.add_inhom(self) - self.addlinesinks = True # Set to False not to add line-sinks + self.addlinesinks = False def __repr__(self): return "Inhom1D: " + str(list([self.x1, self.x2])) @@ -30,30 +30,40 @@ def isinside(self, x, y): return (x >= self.x1) and (x < self.x2) def create_elements(self): + inhom_elements = [] # HeadDiff on right side, FluxDiff on left side if self.x1 == -np.inf: xin = self.x2 - self.tiny * abs(self.x2) - self.tiny xoutright = self.x2 + self.tiny * abs(self.x2) + self.tiny aqin = self.model.aq.find_aquifer_data(xin, 0) aqoutright = self.model.aq.find_aquifer_data(xoutright, 0) - if self.addlinesinks: - HeadDiffLineSink1D( - self.model, - self.x2, - label=None, - aq=aqin, - aqin=aqin, - aqout=aqoutright, - ) + # if self.addlinesinks: + hdls_right = HeadDiffLineSink1D( + self.model, + self.x2, + label=None, + aq=aqin, + aqin=aqin, + aqout=aqoutright, + addtomodel=False, + ) + inhom_elements.append(hdls_right) elif self.x2 == np.inf: xin = self.x1 + self.tiny * abs(self.x1) + self.tiny xoutleft = self.x1 - self.tiny * abs(self.x1) - self.tiny aqin = self.model.aq.find_aquifer_data(xin, 0) aqoutleft = self.model.aq.find_aquifer_data(xoutleft, 0) - if self.addlinesinks: - FluxDiffLineSink1D( - self.model, self.x1, label=None, aq=aqin, aqin=aqin, aqout=aqoutleft - ) + # if self.addlinesinks: + fdls_left = FluxDiffLineSink1D( + self.model, + self.x1, + label=None, + aq=aqin, + aqin=aqin, + aqout=aqoutleft, + addtomodel=False, + ) + inhom_elements.append(fdls_left) else: xin = 0.5 * (self.x1 + self.x2) xoutleft = self.x1 - self.tiny * abs(self.x1) - self.tiny @@ -61,22 +71,50 @@ def create_elements(self): aqin = self.model.aq.find_aquifer_data(xin, 0) aqleft = self.model.aq.find_aquifer_data(xoutleft, 0) aqright = self.model.aq.find_aquifer_data(xoutright, 0) - if self.addlinesinks: - HeadDiffLineSink1D( - self.model, self.x2, label=None, aq=aqin, aqin=aqin, aqout=aqright - ) - FluxDiffLineSink1D( - self.model, self.x1, label=None, aq=aqin, aqin=aqin, aqout=aqleft - ) + # if self.addlinesinks: + hdls_right = HeadDiffLineSink1D( + self.model, + self.x2, + label=None, + aq=aqin, + aqin=aqin, + aqout=aqright, + addtomodel=False, + ) + fdls_left = FluxDiffLineSink1D( + self.model, + self.x1, + label=None, + aq=aqin, + aqin=aqin, + aqout=aqleft, + addtomodel=False, + ) + inhom_elements += [hdls_right, fdls_left] if self.N is not None: assert ( aqin.ilap ), "Error: infiltration can only be added if topboundary='conf'" - StripAreaSinkInhom(self.model, self.x1, self.x2, self.N, layer=0) + areasink = StripAreaSinkInhom( + self.model, + self.x1, + self.x2, + self.N, + layer=0, + addtomodel=False, + ) + inhom_elements.append(areasink) if aqin.ltype[0] == "l": assert self.hstar is not None, "Error: hstar needs to be set" - c = ConstantStar(self.model, self.hstar, aq=aqin) + c = ConstantStar( + self.model, + self.hstar, + aq=aqin, + addtomodel=False, + ) c.inhomelement = True + inhom_elements.append(c) + return inhom_elements class StripInhomMaq(StripInhom): From 1605c1ba9a86cbd08bd6031a2f1460c1ebfde0a0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 3 Jan 2024 17:42:07 +0100 Subject: [PATCH 25/39] remove self.addlinesinks option --- timml/inhomogeneity1d.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/timml/inhomogeneity1d.py b/timml/inhomogeneity1d.py index b58e454f..77624f35 100644 --- a/timml/inhomogeneity1d.py +++ b/timml/inhomogeneity1d.py @@ -21,7 +21,6 @@ def __init__(self, model, x1, x2, kaq, c, z, npor, ltype, hstar, N): self.hstar = hstar self.N = N self.inhom_number = self.model.aq.add_inhom(self) - self.addlinesinks = False def __repr__(self): return "Inhom1D: " + str(list([self.x1, self.x2])) @@ -37,7 +36,6 @@ def create_elements(self): xoutright = self.x2 + self.tiny * abs(self.x2) + self.tiny aqin = self.model.aq.find_aquifer_data(xin, 0) aqoutright = self.model.aq.find_aquifer_data(xoutright, 0) - # if self.addlinesinks: hdls_right = HeadDiffLineSink1D( self.model, self.x2, @@ -53,7 +51,6 @@ def create_elements(self): xoutleft = self.x1 - self.tiny * abs(self.x1) - self.tiny aqin = self.model.aq.find_aquifer_data(xin, 0) aqoutleft = self.model.aq.find_aquifer_data(xoutleft, 0) - # if self.addlinesinks: fdls_left = FluxDiffLineSink1D( self.model, self.x1, @@ -71,7 +68,6 @@ def create_elements(self): aqin = self.model.aq.find_aquifer_data(xin, 0) aqleft = self.model.aq.find_aquifer_data(xoutleft, 0) aqright = self.model.aq.find_aquifer_data(xoutright, 0) - # if self.addlinesinks: hdls_right = HeadDiffLineSink1D( self.model, self.x2, From 72fa78cd10a2f15ca9ac543a35653bc8109edd15 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 3 Jan 2024 17:42:54 +0100 Subject: [PATCH 26/39] ruff check/format --- timml/__init__.py | 34 +++++++++++++++++----------------- timml/aquifer_parameters.py | 30 ++++++++++++++++++------------ timml/circareasink.py | 6 +++--- timml/circinhom.py | 2 +- timml/element.py | 2 +- timml/uflow.py | 7 ++++--- 6 files changed, 44 insertions(+), 37 deletions(-) diff --git a/timml/__init__.py b/timml/__init__.py index de758654..7b6a1c22 100644 --- a/timml/__init__.py +++ b/timml/__init__.py @@ -7,17 +7,17 @@ multiaquifer flow with analytic elements and consists of a library of Python scripts and FORTRAN extensions. """ -# from __future__ import division, print_function, absolute_import +# ruff : noqa -# --version number __name__ = "timml" __author__ = "Mark Bakker" -from . import bessel + # Import all classes and functions -from .circareasink import CircAreaSink -from .constant import Constant, ConstantStar -from .inhomogeneity import ( +from timml import bessel, util +from timml.circareasink import CircAreaSink +from timml.constant import Constant, ConstantStar +from timml.inhomogeneity import ( BuildingPit3D, BuildingPitMaq, LeakyBuildingPit3D, @@ -25,15 +25,15 @@ PolygonInhom3D, PolygonInhomMaq, ) -from .inhomogeneity1d import StripInhom3D, StripInhomMaq -from .linedoublet import ( +from timml.inhomogeneity1d import StripInhom3D, StripInhomMaq +from timml.linedoublet import ( ImpLineDoublet, ImpLineDoubletString, LeakyLineDoublet, LeakyLineDoubletString, ) -from .linedoublet1d import ImpLineDoublet1D, LeakyLineDoublet1D -from .linesink import ( +from timml.linedoublet1d import ImpLineDoublet1D, LeakyLineDoublet1D +from timml.linesink import ( HeadLineSink, HeadLineSinkContainer, HeadLineSinkString, @@ -42,13 +42,13 @@ LineSinkDitch, LineSinkDitchString, ) -from .linesink1d import HeadLineSink1D, LineSink1D -from .model import Model, Model3D, ModelMaq -from .stripareasink import StripAreaSink -from .trace import timtraceline, timtracelines -from .uflow import Uflow -from .version import __version__ -from .well import HeadWell, Well, WellBase +from timml.linesink1d import HeadLineSink1D, LineSink1D +from timml.model import Model, Model3D, ModelMaq +from timml.stripareasink import StripAreaSink +from timml.trace import timtraceline, timtracelines +from timml.uflow import Uflow +from timml.version import __version__ +from timml.well import HeadWell, Well, WellBase __all__ = [s for s in dir() if not s.startswith("_")] diff --git a/timml/aquifer_parameters.py b/timml/aquifer_parameters.py index cf020155..107aa7a1 100644 --- a/timml/aquifer_parameters.py +++ b/timml/aquifer_parameters.py @@ -15,17 +15,19 @@ def param_maq(kaq, z, c, npor, top): ltype = np.array(list(Naq * "la")) if len(kaq) == 1: kaq = kaq * np.ones(Naq) - assert len(kaq) == Naq, "Error: length of kaq needs to be 1 or" + str(Naq) + assert len(kaq) == Naq, "Error: length of kaq needs to be 1 or " + str(Naq) H = z[:-1] - z[1:] - assert np.all(H >= 0), "Error: Not all layers thicknesses are non-negative" + str(H) + assert np.all(H >= 0), "Error: Not all layers thicknesses are non-negative " + str( + H + ) if top == "conf": if len(c) == 1: c = c * np.ones(Naq - 1) if len(npor) == 1: npor = npor * np.ones(2 * Naq - 1) - assert len(c) == Naq - 1, "Error: Length of c needs to be 1 or" + str(Naq - 1) - assert len(npor) == 2 * Naq - 1, "Error: Length of npor needs to be 1 or" + str( - 2 * Naq - 1 + assert len(c) == Naq - 1, "Error: Length of c needs to be 1 or " + str(Naq - 1) + assert len(npor) == 2 * Naq - 1, ( + "Error: Length of npor needs to be 1 or " + str(2 * Naq - 1) ) c = np.hstack((1e100, c)) else: # leaky layer on top @@ -33,8 +35,8 @@ def param_maq(kaq, z, c, npor, top): c = c * np.ones(Naq) if len(npor) == 1: npor = npor * np.ones(2 * Naq) - assert len(c) == Naq, "Error: Length of c needs to be 1 or" + str(Naq) - assert len(npor) == 2 * Naq, "Error: Length of npor needs to be 1 or" + str( + assert len(c) == Naq, "Error: Length of c needs to be 1 or " + str(Naq) + assert len(npor) == 2 * Naq, "Error: Length of npor needs to be 1 or " + str( 2 * Naq ) return kaq, c, npor, ltype @@ -54,23 +56,27 @@ def param_3d(kaq, z, kzoverkh, npor, top="conf", topres=0): ltype = np.hstack(("l", Naq * ["a"])) if len(kaq) == 1: kaq = kaq * np.ones(Naq) - assert len(kaq) == Naq, "Error: length of kaq needs to be 1 or" + str(Naq) + assert len(kaq) == Naq, "Error: length of kaq needs to be 1 or " + str(Naq) if len(kzoverkh) == 1: kzoverkh = kzoverkh * np.ones(Naq) - assert len(kzoverkh) == Naq, "Error: length of kzoverkh needs to be 1 or" + str(Naq) + assert len(kzoverkh) == Naq, "Error: length of kzoverkh needs to be 1 or " + str( + Naq + ) if len(npor) == 1: if top == "conf": npor = npor * np.ones(Naq) elif top == "semi": npor = npor * np.ones(Naq + 1) if top == "conf": - assert len(npor) == Naq, "Error: length of npor needs to be 1 or" + str(Naq) + assert len(npor) == Naq, "Error: length of npor needs to be 1 or " + str(Naq) elif top == "semi": - assert len(npor) == Naq + 1, "Error: length of npor needs to be 1 or" + str( + assert len(npor) == Naq + 1, "Error: length of npor needs to be 1 or " + str( Naq + 1 ) H = z[:-1] - z[1:] - assert np.all(H >= 0), "Error: Not all layers thicknesses are non-negative" + str(H) + assert np.all(H >= 0), "Error: Not all layers thicknesses are non-negative " + str( + H + ) c = 0.5 * H[:-1] / (kzoverkh[:-1] * kaq[:-1]) + 0.5 * H[1:] / ( kzoverkh[1:] * kaq[1:] ) diff --git a/timml/circareasink.py b/timml/circareasink.py index 30ae910b..a594c285 100644 --- a/timml/circareasink.py +++ b/timml/circareasink.py @@ -248,8 +248,8 @@ def changetrace( u = u1 * (1.0 + eps) # Go just beyond circle else: u = u2 * (1.0 + eps) # Go just beyond circle - xn = x1 + u * (x2 - x1) - yn = y1 + u * (y2 - y1) - zn = xyzt1[2] + u * (xyzt2[2] - xyzt1[2]) + # xn = x1 + u * (x2 - x1) + # yn = y1 + u * (y2 - y1) + # zn = xyzt1[2] + u * (xyzt2[2] - xyzt1[2]) xyztnew = xyzt1 + u * (xyzt2 - xyzt1) return changed, terminate, xyztnew, message diff --git a/timml/circinhom.py b/timml/circinhom.py index f568d02f..4d655111 100644 --- a/timml/circinhom.py +++ b/timml/circinhom.py @@ -5,9 +5,9 @@ (c) Mark Bakker, 2002-2007 """ +import numpy as np import scipy.special from element import Element -import numpy as np class CircleInhom(Element): diff --git a/timml/element.py b/timml/element.py index c4a42c0a..4867f07c 100644 --- a/timml/element.py +++ b/timml/element.py @@ -144,7 +144,7 @@ def plot(self, layer): pass def write(self): - rv = self.name + "(" + self.model.modelname + ",\n" + rv = "timml." + self.name + "(" + self.model.modelname + ",\n" for key in self.inputargs[2:]: # The first two are ignored if isinstance(self.inputvalues[key], np.ndarray): rv += ( diff --git a/timml/uflow.py b/timml/uflow.py index 6d1fe296..7244ad65 100644 --- a/timml/uflow.py +++ b/timml/uflow.py @@ -29,9 +29,10 @@ class Uflow(Element): """ def __init__(self, model, slope, angle, label=None): - assert ( - model.aq.ilap - ), "TimML Error: Uflow can only be added to model with background confined aquifer" + assert model.aq.ilap, ( + "TimML Error: Uflow can only be added to model " + "with background confined aquifer" + ) self.storeinput(inspect.currentframe()) Element.__init__( self, model, nparam=2, nunknowns=0, layers=0, name="Uflow", label=label From 10b01db9125e3c19bf96e8a1daac5f299607ca78 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 3 Jan 2024 17:43:35 +0100 Subject: [PATCH 27/39] add refine tests --- tests/test_refine.py | 314 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 314 insertions(+) create mode 100644 tests/test_refine.py diff --git a/tests/test_refine.py b/tests/test_refine.py new file mode 100644 index 00000000..0296ebaf --- /dev/null +++ b/tests/test_refine.py @@ -0,0 +1,314 @@ +import numpy as np +import timml as tml + + +def modelmaq(): + # model parameters + kh = 10 # m/day + ctop = 1000.0 # resistance top leaky layer in days + ztop = 0.0 # surface elevation + zbot = -20.0 # bottom elevation of the model + z = np.array([ztop + 1, ztop, -10, -10, zbot]) + ml = tml.ModelMaq(kaq=kh, z=z, c=[ctop, 1], topboundary="semi", hstar=0.0) + return ml + + +def model3d(): + # model parameters + kh = 10 # m/day + kzoverkh = 0.25 + ctop = 1000.0 # resistance top leaky layer in days + ztop = 0.0 # surface elevation + zbot = -20.0 # bottom elevation of the model + z = np.array([ztop, -10, zbot]) + ml = tml.Model3D( + kaq=kh, + kzoverkh=kzoverkh, + z=z, + topres=ctop, + topthick=1.0, + topboundary="semi", + hstar=0.0, + ) + return ml + + +def test_refine_n_segments_line(): + x1, x2, y1, y2 = -5, 5, 0, 0 + xy = np.array([(x1, y1), (x2, y2)]) + xyr, reindexer = tml.util.refine_n_segments(xy, "line", 3) + assert np.allclose(xyr[:, 0], np.array([-5.0, -2.5, 2.5, 5.0])) + assert (reindexer == 0).all() and len(reindexer) == 3 + + +def test_refine_n_segments_polygon(): + xy = [ + (-10, -5), + (10, -5), + (10, 5), + (-10, 5), + (-10, -5), + ] + xyr, reindexer = tml.util.refine_n_segments(xy, "polygon", 2) + assert np.all(reindexer == np.array([0, 0, 1, 1, 2, 2, 3, 3])) + assert len(xyr) == 9 + + +def test_refine_linesink(): + ml = modelmaq() + tml.LineSinkBase(ml, refine_level=3) + ml.solve(silent=True) + assert np.allclose(ml.elementlist[-3].Qls, [25.0]) + assert np.allclose(ml.elementlist[-2].Qls, [50.0]) + assert np.allclose(ml.elementlist[-1].Qls, [25.0]) + assert len(ml.elementlist) == 4 + + +def test_refine_headlinesink(): + ml = modelmaq() + tml.HeadLineSink(ml, refine_level=2) + ml.solve(silent=True) + assert len(ml.elementlist) == 3 + + +def test_refine_headlinesinkstring(): + ml = modelmaq() + hls = tml.HeadLineSinkString(ml, refine_level=2) + ml.solve(silent=True) + assert len(hls.lslist) == 2 + assert ml.head(10, 10, layers=[0]) == 0.0 + assert np.sum(hls.discharge()) == 0.0 + + +def test_refine_leakylinedoublet(): + ml = modelmaq() + tml.LeakyLineDoublet(ml, res=100, refine_level=2) + ml.solve(silent=True) + assert len(ml.elementlist) == 3 + assert ml.head(10, 10, layers=[0]) == 0.0 + + +def test_refine_leakylinedoubletstring(): + ml = modelmaq() + llds = tml.LeakyLineDoubletString(ml, res=100, refine_level=2) + ml.solve(silent=True) + assert len(llds.ldlist) == 2 + assert ml.head(10, 10, layers=[0]) == 0.0 + + +def test_refine_implinedoublet(): + ml = modelmaq() + tml.ImpLineDoublet(ml, refine_level=2) + ml.solve(silent=True) + assert len(ml.elementlist) == 3 + assert ml.head(10, 10, layers=[0]) == 0.0 + + +def test_refine_implinedoubletstring(): + ml = modelmaq() + llds = tml.ImpLineDoubletString(ml, refine_level=2) + ml.solve(silent=True) + assert len(llds.ldlist) == 2 + assert ml.head(10, 10, layers=[0]) == 0.0 + + +def test_refine_polygonimhommaq(): + ml = modelmaq() + xy = [ + (-10, -5), + (10, -5), + (10, 5), + (-10, 5), + (-10, -5), + ] + inhom = tml.PolygonInhomMaq( + ml, + xy, + kaq=ml.aq.kaq, + z=ml.aq.z[1:], + c=ml.aq.c[1:], + topboundary="conf", + refine_level=2, + ) + tml.Well(ml, 0, 0) + ml.solve(silent=True) + xyin = np.vstack( + [ + np.hstack([inhom.zcin.real, inhom.zcin.real[:1]]), + np.hstack([inhom.zcin.imag, inhom.zcin.imag[:1]]), + ] + ).T + assert len(ml.elementlist) == 19 + assert np.allclose(np.sum(ml.intnormflux(xyin, ndeg=99)), [100.0]) + + +def test_refine_polygonimhom3d(): + ml = model3d() + xy = [ + (-10, -5), + (10, -5), + (10, 5), + (-10, 5), + (-10, -5), + ] + inhom = tml.PolygonInhom3D( + ml, + xy, + kaq=ml.aq.kaq, + kzoverkh=0.25, + z=ml.aq.z[1:], + topboundary="conf", + refine_level=2, + ) + tml.Well(ml, 0, 0) + ml.solve(silent=True) + xyin = np.vstack( + [ + np.hstack([inhom.zcin.real, inhom.zcin.real[:1]]), + np.hstack([inhom.zcin.imag, inhom.zcin.imag[:1]]), + ] + ).T + assert len(ml.elementlist) == 19 + assert np.allclose(np.sum(ml.intnormflux(xyin, ndeg=99)), [100.0]) + + +def test_refine_buildingpitmaq(): + ml = modelmaq() + xy = [ + (-10, -5), + (10, -5), + (10, 5), + (-10, 5), + (-10, -5), + ] + tml.BuildingPitMaq( + ml, + xy, + kaq=ml.aq.kaq, + z=ml.aq.z[1:], + c=ml.aq.c[1:], + topboundary="conf", + refine_level=3, + ) + tml.Well(ml, 0, 0) + ml.solve(silent=True) + assert len(ml.elementlist) == 51 + assert np.allclose( + np.sum(ml.intnormflux(xy, ndeg=99), axis=1), + [0.0, 100.0], + atol=0.15, + rtol=0.01, + ) + + +def test_refine_buildingpit3d(): + ml = model3d() + xy = [ + (-10, -5), + (10, -5), + (10, 5), + (-10, 5), + (-10, -5), + ] + tml.BuildingPit3D( + ml, + xy, + kaq=ml.aq.kaq, + kzoverkh=0.25, + z=ml.aq.z[1:], + topboundary="conf", + refine_level=3, + ) + tml.Well(ml, 0, 0) + ml.solve(silent=True) + assert len(ml.elementlist) == 51 + assert np.allclose( + np.sum(ml.intnormflux(xy, ndeg=99), axis=1), + [0.0, 100.0], + atol=1.0, + rtol=0.01, + ) + + +def test_refine_leakybuildingpitmaq(): + ml = modelmaq() + xy = [ + (-10, -5), + (10, -5), + (10, 5), + (-10, 5), + (-10, -5), + ] + tml.LeakyBuildingPitMaq( + ml, + xy, + kaq=ml.aq.kaq, + z=ml.aq.z[1:], + c=ml.aq.c[1:], + res=[100, 100, 1, 100], + topboundary="conf", + refine_level=2, + ) + tml.Well(ml, 0, 0) + ml.solve(silent=True) + eps = 1e-6 + xyin = [ + (-10 + eps, -5 + eps), + (10 - eps, -5 + eps), + (10 - eps, 5 - eps), + (-10 + eps, 5 - eps), + (-10 + eps, -5 + eps), + ] + assert len(ml.elementlist) == 35 + # accuracy of intnormflux around inner boundary is reasonable but not perfect + assert np.allclose(np.sum(ml.intnormflux(xyin, ndeg=99)), [100.0], rtol=1e-3) + + +def test_refine_leakybuildingpit3d(): + ml = model3d() + xy = [ + (-10, -5), + (10, -5), + (10, 5), + (-10, 5), + (-10, -5), + ] + tml.LeakyBuildingPit3D( + ml, + xy, + kaq=ml.aq.kaq, + kzoverkh=0.25, + z=ml.aq.z[1:], + res=[100, 100, 1, 100], + topboundary="conf", + refine_level=2, + ) + tml.Well(ml, 0, 0) + ml.solve(silent=True) + eps = 1e-6 + xyin = [ + (-10 + eps, -5 + eps), + (10 - eps, -5 + eps), + (10 - eps, 5 - eps), + (-10 + eps, 5 - eps), + (-10 + eps, -5 + eps), + ] + assert len(ml.elementlist) == 35 + # accuracy of intnormflux around inner boundary is reasonable but not perfect + assert np.allclose(np.sum(ml.intnormflux(xyin, ndeg=99)), [100.0], rtol=1e-3) + + +def test_global_refine_option(): + ml = modelmaq() + tml.HeadLineSink(ml, refine_level=1) + ml.solve(refine_level=3, silent=True) + assert len(ml.elementlist) == 4 + + +def test_multiple_solves(): + ml = modelmaq() + tml.HeadLineSink(ml, refine_level=3) + ml.solve(silent=True) + assert len(ml.elementlist) == 4 + ml.solve(silent=True) + assert len(ml.elementlist) == 4 From b7b7fba35cf695320c41c7d27f0ca6e6aa1383f8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Thu, 4 Jan 2024 11:27:59 +0100 Subject: [PATCH 28/39] improve notebook --- ...finement.ipynb => refining_elements.ipynb} | 297 ++++++++++++++---- 1 file changed, 242 insertions(+), 55 deletions(-) rename notebooks/{refinement.ipynb => refining_elements.ipynb} (99%) diff --git a/notebooks/refinement.ipynb b/notebooks/refining_elements.ipynb similarity index 99% rename from notebooks/refinement.ipynb rename to notebooks/refining_elements.ipynb index 32fdf2c4..49798d1d 100644 --- a/notebooks/refinement.ipynb +++ b/notebooks/refining_elements.ipynb @@ -45,6 +45,143 @@ "from timml.util import refine_n_segments" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Supported elements\n", + "\n", + "The following elements support automatic refinement:\n", + "\n", + "* Line-sinks and line-doublets:\n", + " * LineSinkBase\n", + " * HeadLineSink\n", + " * HeadLineSinkString\n", + " * LineSinkDitchString\n", + " * ImpLineDoublet\n", + " * ImpLineDoubletString\n", + " * LeakyLineDoublet\n", + " * LeakyLineDoubletString\n", + "* Inhomogeneities:\n", + " * PolygonInhomMaq\n", + " * PolygonInhom3D\n", + " * BuildingPitMaq\n", + " * BuildingPit3D\n", + " * LeakyBuildingPitMaq\n", + " * LeakyBuildingPit3D" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## User added elements vs. refined elements\n", + "\n", + "In order to support automatic refinement, TimML now distinguishes between elements\n", + "added to a model by the user, and elements used in the computation. When automatic\n", + "refinement is applied, in some cases, new elements are created and added to the\n", + "computation list. When an element is not refined, the original user specified element\n", + "is passed on to the computation list.\n", + "\n", + "User-specified elements are stored under `ml.elements`:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[HeadLineSink from (-1.0, 0.0) to (1.0, 0.0)]" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ml = tml.ModelMaq()\n", + "ls = tml.HeadLineSink(ml, refine_level=2)\n", + "\n", + "ml.elements # user-specified elements" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The computation element list (`ml.elementlist`) is empty until the model is initialized\n", + "(or solved)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ml.elementlist" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Initialize the model" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "ml.initialize()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that the computation list has been filled, in this case with 2 refined elements\n", + "based on the original HeadLineSink:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[HeadLineSink from (-1.0, 0.0) to (6.123233995736766e-17, 0.0),\n", + " HeadLineSink from (6.123233995736766e-17, 0.0) to (1.0, 0.0)]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ml.elementlist" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -57,10 +194,10 @@ "metadata": {}, "source": [ "Supported elements can be refined by passing the `refine_level` kwarg. A refinement\n", - "level of 0 or 1 means no refinement is applied. A refinement level of 3 means that\n", - "a line-sink is split into 3 segments. The segmentation is performed according to the\n", - "cosine rule (the same method that determines the location of the control points for an\n", - "element).\n", + "level of 0 or 1 means no refinement is applied. A refinement level of 3 means that a\n", + "line-sink is split into 3 segments. The segmentation is performed according to the\n", + "cosine rule (the same method that determines the location of the control points for a\n", + "line element).\n", "\n", "In this example a single `HeadLineSink` is refined into 3 segments. The head along the\n", "line-sink is compared to a case with no refinement.\n", @@ -72,7 +209,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -97,7 +234,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -119,7 +256,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -143,12 +280,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Compare the head along the element for the refined and non-refined models. " + "Compare the head along the element for the refined and non-refined models. The refined\n", + "element has three points at which the head condition is specified, whereas the initial\n", + "element of order 0 has just 1 control point." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -210,7 +349,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -222,10 +361,13 @@ } ], "source": [ - "ls = models[1].elements[-1] # get user-specified element from 2nd model\n", + "ls = models[1].elements[-1] # get user-specified element from refined model\n", + "\n", "\n", + "# NOTE: since the original element is never used in computation, it is never \n", + "# initialized and will throw an error when trying to do computations with it.\n", "try:\n", - " ls.discharge()\n", + " ls.discharge() \n", "except Exception as e:\n", " print(e.__class__.__name__, e)" ] @@ -239,7 +381,31 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[ConstantStar with head 0.0,\n", + " HeadLineSink from (0.0, 0.0) to (2.499999999999999, 2.499999999999999),\n", + " HeadLineSink from (2.499999999999999, 2.499999999999999) to (7.5, 7.5),\n", + " HeadLineSink from (7.5, 7.5) to (10.0, 10.0)]" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# the refined HeadLineSink elements are the last three in the elementlist\n", + "models[1].elementlist" + ] + }, + { + "cell_type": "code", + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -248,13 +414,13 @@ "array([-204.24637731, 0. ])" ] }, - "execution_count": 7, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "Q = np.zeros(2) # 2 layers\n", + "Q = np.zeros(models[1].aq.naq) # 2 layers\n", "for e in models[1].elementlist[1:]: # loop through computation (refined) elements\n", " Q += e.discharge()\n", "Q" @@ -264,7 +430,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Another method to avoid this issue is to use compound line-sink elements, such as\n", + "Another (better) method to avoid this issue is to use compound line-sink elements, such as\n", "`HeadLineSinkString`, which is shown in the next section." ] }, @@ -278,9 +444,12 @@ "`HeadLineSinkString`. Refining these elements works similar to the example for a single\n", "line-sink. \n", "\n", + "
Tip: \n", "The advantage of compound elements is that they store their own list of\n", "sub-elements internally, which means the original element can be used for further\n", "computation, unlike the example with a single line-sink.\n", + "
\n", + "\n", "\n", "In this example we have the same single line-sink as the previous example, but the\n", "specified head is 1 m+ref at the starting point and 0 m+ref at the end of the line-sink.\n", @@ -298,7 +467,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -322,7 +491,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -346,12 +515,36 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "As mentioned the advantage of compound line-sinks is that the original reference to the line-sink that was specified by the user can be used for computation." + "As mentioned previously, the advantage of compound line-sinks is that the original\n", + "reference to the line-sink that was specified by the user can be used for computation." ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[ConstantStar with head 0.0,\n", + " HeadLineSinkString with nodes [[ 0. 0.]\n", + " [10. 10.]]]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# the HeadLineSinkString is the second element in ml.elements\n", + "models[0].elements" + ] + }, + { + "cell_type": "code", + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -360,7 +553,7 @@ "array([-102.31796071, 0. ])" ] }, - "execution_count": 10, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -372,7 +565,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -381,7 +574,7 @@ "array([-102.12318866, 0. ])" ] }, - "execution_count": 11, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -405,7 +598,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -425,19 +618,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 19, "metadata": {}, "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'y [m]')" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - }, { "data": { "image/png": "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", @@ -454,7 +637,7 @@ "plt.plot(xw, yw, \"C0o\", label=\"well\")\n", "leg = plt.legend(loc=(0, 1), frameon=False, ncol=2)\n", "plt.xlabel(\"x [m]\")\n", - "plt.ylabel(\"y [m]\")" + "plt.ylabel(\"y [m]\");" ] }, { @@ -466,7 +649,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -505,7 +688,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -537,7 +720,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -583,7 +766,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -607,7 +790,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -646,7 +829,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -677,14 +860,14 @@ "metadata": {}, "source": [ "We can also see that the water balance isn't quite correct. In the first layer, along 3\n", - "sides, there is a discharge out of the building pit (negative numbers), which is not\n", + "sides, there is flow out of the building pit (negative numbers), which is not\n", "what we would expect, and the total discharge flowing into the building pit should\n", "equal the pumping discharge of the well (it's close but not quite right)." ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -760,7 +943,7 @@ "total 18.6 10.0 61.5 10.0 100.1" ] }, - "execution_count": 20, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -788,7 +971,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -829,7 +1012,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -866,7 +1049,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 29, "metadata": {}, "outputs": [ { @@ -942,7 +1125,7 @@ "total 20.9 8.5 62.1 8.5 100.0" ] }, - "execution_count": 23, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } @@ -967,14 +1150,18 @@ "## Global refine option\n", "\n", "In the examples above the refine_level was defined in the elements that were meant to\n", - "be refined. This allows for fine-grained control over which elements should be refined and by how much. This is the preferred method for specifying this information. However, in certain situations it can be useful to globally set a refinement level. \n", + "be refined. This allows for fine-grained control over which elements should be refined\n", + "and by how much. This is the preferred method for specifying this information. However,\n", + "in certain situations it can be useful to globally set a refinement level.\n", "\n", - "This is possible by setting the `refine_level` in `ml.solve()`. Setting this kwarg to None (the default), uses the element-level settings, setting it to a number will override the element settings." + "This is possible by setting the `refine_level` in `ml.solve()`. Setting this keyword\n", + "argument to None (the default), uses the element-level settings, setting it to a number\n", + "will override the element settings." ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 30, "metadata": {}, "outputs": [ { @@ -989,13 +1176,13 @@ ], "source": [ "ml = tml.ModelMaq(kaq=kh, z=z, c=[ctop, 1], topboundary=\"semi\", hstar=0.0)\n", - "ls = tml.HeadLineSink(ml, 0, 0, 10, 10, hls=1.0)\n", + "ls = tml.HeadLineSink(ml, 0, 0, 10, 10, hls=1.0) # no refine_level specified\n", "ml.solve(refine_level=3)" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -1007,7 +1194,7 @@ " HeadLineSink from (7.5, 7.5) to (10.0, 10.0)]" ] }, - "execution_count": 25, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } From c4c465a56a37454fc98e4dd07f2c0ac8d1cecc0a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Thu, 4 Jan 2024 11:31:30 +0100 Subject: [PATCH 29/39] avoid creating new inhom element when refining - use original element but update internal parameters - add inhom.extent as useful attribute --- timml/aquifer.py | 9 ++--- timml/inhomogeneity.py | 75 ++++++++++++++++++++---------------------- 2 files changed, 38 insertions(+), 46 deletions(-) diff --git a/timml/aquifer.py b/timml/aquifer.py index 2d33bb7d..5bec46d3 100644 --- a/timml/aquifer.py +++ b/timml/aquifer.py @@ -116,15 +116,12 @@ def initialize(self, refine_level=None): # because we are going to call initialize for inhoms AquiferData.initialize(self) for inhom in self.inhoms: - inhom.initialize() # always initialize original element if hasattr(inhom, "_refine") and ( inhom.refine_level > 1 or refine_level is not None ): - refined_inhom = inhom._refine(n=refine_level) # create refined element - refined_inhom.initialize() - self.inhomlist.append(refined_inhom) - else: - self.inhomlist.append(inhom) + inhom._refine(n=refine_level) # refine element + inhom.initialize() + self.inhomlist.append(inhom) for inhom in self.inhomlist: inhom_elements = inhom.create_elements() # create elements self.model.elementlist += inhom_elements # add elements to compute list diff --git a/timml/inhomogeneity.py b/timml/inhomogeneity.py index 3aabb1f7..2fb68f56 100644 --- a/timml/inhomogeneity.py +++ b/timml/inhomogeneity.py @@ -48,7 +48,15 @@ def __init__( if self.addtomodel: self.inhom_number = self.model.aq.add_inhom(self) self.xy = xy - self.z1, self.z2 = compute_z1z2(self.xy) + self.refine_level = refine_level + + # introduce internal vars that can be modified by _refine() + self._xy = self.xy.copy() + + self.compute_derived_params() + + def compute_derived_params(self): + self.z1, self.z2 = compute_z1z2(self._xy) self.Nsides = len(self.z1) Zin = 1e-6j Zout = -1e-6j @@ -66,7 +74,7 @@ def __init__( self.xmax = max(self.x) self.ymin = min(self.y) self.ymax = max(self.y) - self.refine_level = refine_level + self.extent = [self.xmin, self.xmax, self.ymin, self.ymax] def __repr__(self): return "PolygonInhom: " + str(list(zip(self.x, self.y))) @@ -147,15 +155,11 @@ def create_elements(self): def _refine(self, n=None): if n is None: n = self.refine_level + # refine xy xyr, _ = refine_n_segments(self.xy, "polygon", n_segments=n) - input_args = deepcopy(self._input) - cls = input_args.pop("__class__", self.__class__) - input_args["model"] = self.model - # overwrite some input args for refined element - input_args["xy"] = xyr - input_args["refine_level"] = 1 # set to 1 to prevent further refinement - input_args["addtomodel"] = False - return cls(**input_args) + self._xy = xyr + # update derived parameters + self.compute_derived_params() class PolygonInhomMaq(PolygonInhom): @@ -412,7 +416,6 @@ def __init__( refine element by partitioning each side into refine_level segments, default is 1, which means no refinement is applied. """ - self._input = {k: v for k, v in locals().items() if k not in ["self", "model"]} AquiferData.__init__(self, model, kaq, c, z, npor, ltype) self.order = order self.ndeg = ndeg @@ -427,11 +430,14 @@ def __init__( if self.addtomodel: self.inhom_number = self.model.aq.add_inhom(self) + # introduce internal var that can be updated by _refine() + self._xy = self.xy.copy() + # compute derived params self.compute_derived_params() def compute_derived_params(self): - self.z1, self.z2 = compute_z1z2(self.xy) + self.z1, self.z2 = compute_z1z2(self._xy) self.Nsides = len(self.z1) Zin = 1e-6j Zout = -1e-6j @@ -447,6 +453,7 @@ def compute_derived_params(self): self.xmax = max(self.x) self.ymin = min(self.y) self.ymax = max(self.y) + self.extent = [self.xmin, self.xmax, self.ymin, self.ymax] def __repr__(self): return ( @@ -568,15 +575,11 @@ def create_elements(self): def _refine(self, n=None): if n is None: n = self.refine_level + # refine xy xyr, _ = refine_n_segments(self.xy, "polygon", n_segments=n) - input_args = deepcopy(self._input) - cls = input_args.pop("__class__") - input_args["model"] = self.model - # overwrite some input args for refined element - input_args["xy"] = xyr - input_args["refine_level"] = 1 # set to 1 to prevent further refinement - input_args["addtomodel"] = False - return cls(**input_args) + self._xy = xyr + # update derived params + self.compute_derived_params() class BuildingPitMaq(BuildingPit): @@ -643,7 +646,6 @@ def __init__( refine element by splitting up each side into refine_level segments, default is 1, which means no refinement is applied. """ - _input = {k: v for k, v in locals().items() if k not in ["self", "model"]} (kaq, c, npor, ltype) = param_maq(kaq, z, c, npor, topboundary) super().__init__( model=model, @@ -660,7 +662,6 @@ def __init__( refine_level=refine_level, addtomodel=addtomodel, ) - self._input = _input class BuildingPit3D(BuildingPit): @@ -731,7 +732,6 @@ def __init__( refine element by partitioning each side into refine_level segments, default is 1, which means no refinement is applied. """ - _input = {k: v for k, v in locals().items() if k not in ["self", "model"]} (kaq, c, npor, ltype) = param_3d(kaq, z, kzoverkh, npor, topboundary, topres) if topboundary == "semi": z = np.hstack((z[0] + topthick, z)) @@ -750,7 +750,6 @@ def __init__( refine_level=refine_level, addtomodel=addtomodel, ) - self._input = _input class LeakyBuildingPit(BuildingPit): @@ -835,7 +834,6 @@ def __init__( refine_level=refine_level, addtomodel=addtomodel, ) - self._input = {k: v for k, v in locals().items() if k not in ["self", "model"]} if isinstance(res, (int, float, np.integer)): # make 2D so indexing resistance works for all cases self.res = res * np.ones((1, self.Nsides)) @@ -857,6 +855,10 @@ def __init__( ) self.res[self.res < self.tiny] = self.tiny + # introduce vars that can be modified by _refine() + self._xy = self.xy.copy() + self._res = self.res.copy() + def create_elements(self): aqin = self.model.aq.find_aquifer_data(self.zcin[0].real, self.zcin[0].imag) inhom_elements = [] @@ -872,7 +874,7 @@ def create_elements(self): y1=self.y[i], x2=self.x[i + 1], y2=self.y[i + 1], - res=self.res[:, i], + res=self._res[:, i], layers=self.layers, order=self.order, ndeg=self.ndeg, @@ -889,7 +891,7 @@ def create_elements(self): y1=self.y[i], x2=self.x[i + 1], y2=self.y[i + 1], - res=self.res[:, i], + res=self._res[:, i], layers=self.layers, order=self.order, ndeg=self.ndeg, @@ -951,16 +953,13 @@ def create_elements(self): def _refine(self, n=None): if n is None: n = self.refine_level + # refine xy xyr, reindexer = refine_n_segments(self.xy, "polygon", n_segments=n) - input_args = deepcopy(self._input) - cls = input_args.pop("__class__") - input_args["model"] = self.model - # overwrite some input args for refined element - input_args["xy"] = xyr - input_args["res"] = self.res[:, reindexer] - input_args["refine_level"] = 1 # set to 1 to prevent further refinement - input_args["addtomodel"] = False - return cls(**input_args) + self._xy = xyr + # update input args + self._res = self.res[:, reindexer] + # update derived parameters + self.compute_derived_params() class LeakyBuildingPitMaq(LeakyBuildingPit): @@ -1033,7 +1032,6 @@ def __init__( refine_level=1, addtomodel=True, ): - _input = {k: v for k, v in locals().items() if k not in ["self"]} (kaq, c, npor, ltype) = param_maq(kaq, z, c, npor, topboundary) super().__init__( model=model, @@ -1051,7 +1049,6 @@ def __init__( refine_level=refine_level, addtomodel=addtomodel, ) - self._input = _input class LeakyBuildingPit3D(LeakyBuildingPit): @@ -1127,7 +1124,6 @@ def __init__( refine element by partitioning each side into refine_level segments, default is 1, which means no refinement is applied. """ - _input = {k: v for k, v in locals().items() if k not in ["self"]} (kaq, c, npor, ltype) = param_3d(kaq, z, kzoverkh, npor, topboundary, topres) if topboundary == "semi": z = np.hstack((z[0] + topthick, z)) @@ -1147,7 +1143,6 @@ def __init__( refine_level=refine_level, addtomodel=addtomodel, ) - self._input = _input class AreaSinkInhom(Element): From f22cdd9d72fd1440fc25d3590702919d1aba362a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Thu, 4 Jan 2024 11:38:01 +0100 Subject: [PATCH 30/39] update notebook --- notebooks/refining_elements.ipynb | 2 ++ 1 file changed, 2 insertions(+) diff --git a/notebooks/refining_elements.ipynb b/notebooks/refining_elements.ipynb index 49798d1d..27b288d8 100644 --- a/notebooks/refining_elements.ipynb +++ b/notebooks/refining_elements.ipynb @@ -20,6 +20,8 @@ "source": [ "## Contents\n", "\n", + "- [Supported elements](#supported-elements)\n", + "- [User added elements vs. refined elements](#user-added-elements-vs-refined-elements)\n", "- [Single line-sink](#single-line-sink)\n", "- [Compound line-sinks](#compound-line-sinks)\n", "- [Compound line-sink with nearby well](#compound-line-sink-with-nearby-well)\n", From fca242a45e6c302c64b8eba72843fa13a9e7cf07 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Thu, 4 Jan 2024 11:44:22 +0100 Subject: [PATCH 31/39] update import --- timml/model.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/timml/model.py b/timml/model.py index 927508af..eb13ab18 100644 --- a/timml/model.py +++ b/timml/model.py @@ -575,7 +575,7 @@ def write(self): def writemodel(self, fname): self.initialize() # So that the model can be written without solving first f = open(fname, "w") - f.write("import timml as tml\n") + f.write("import timml\n") f.write(self.write()) for e in self.elementlist: f.write(e.write()) From 49e00cf44a42b7a70b1bb4d70c31bafe81d8d7d0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Thu, 4 Jan 2024 11:46:10 +0100 Subject: [PATCH 32/39] update docstring --- timml/util.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/timml/util.py b/timml/util.py index 6703bc87..4d7fb60d 100644 --- a/timml/util.py +++ b/timml/util.py @@ -83,6 +83,9 @@ def plot( plt.axhspan( ymin=self.aq.z[i], ymax=self.aq.z[i], color=[0.8, 0.8, 0.8] ) + # for e in self.elementlist: + # if hasattr(e, "xsec"): + # e.xsec() def contour( self, From 6648b780d7858033c5b4103d94ef3bd2ac7b2142 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Thu, 4 Jan 2024 12:31:10 +0100 Subject: [PATCH 33/39] forgot to commit updated tests --- tests/test_refine.py | 68 +++++++++++++++++++++++++++++--------------- 1 file changed, 45 insertions(+), 23 deletions(-) diff --git a/tests/test_refine.py b/tests/test_refine.py index 0296ebaf..21d2d977 100644 --- a/tests/test_refine.py +++ b/tests/test_refine.py @@ -132,14 +132,16 @@ def test_refine_polygonimhommaq(): ) tml.Well(ml, 0, 0) ml.solve(silent=True) - xyin = np.vstack( - [ - np.hstack([inhom.zcin.real, inhom.zcin.real[:1]]), - np.hstack([inhom.zcin.imag, inhom.zcin.imag[:1]]), - ] - ).T + eps = 1e-6 + xyin = [ + (-10 + eps, -5 + eps), + (10 - eps, -5 + eps), + (10 - eps, 5 - eps), + (-10 + eps, 5 - eps), + (-10 + eps, -5 + eps), + ] assert len(ml.elementlist) == 19 - assert np.allclose(np.sum(ml.intnormflux(xyin, ndeg=99)), [100.0]) + assert np.allclose(np.sum(ml.intnormflux(xyin, ndeg=99)), [100.0], rtol=1e-3) def test_refine_polygonimhom3d(): @@ -162,14 +164,16 @@ def test_refine_polygonimhom3d(): ) tml.Well(ml, 0, 0) ml.solve(silent=True) - xyin = np.vstack( - [ - np.hstack([inhom.zcin.real, inhom.zcin.real[:1]]), - np.hstack([inhom.zcin.imag, inhom.zcin.imag[:1]]), - ] - ).T + eps = 1e-6 + xyin = [ + (-10 + eps, -5 + eps), + (10 - eps, -5 + eps), + (10 - eps, 5 - eps), + (-10 + eps, 5 - eps), + (-10 + eps, -5 + eps), + ] assert len(ml.elementlist) == 19 - assert np.allclose(np.sum(ml.intnormflux(xyin, ndeg=99)), [100.0]) + assert np.allclose(np.sum(ml.intnormflux(xyin, ndeg=99)), [100.0], rtol=1e-3) def test_refine_buildingpitmaq(): @@ -188,16 +192,25 @@ def test_refine_buildingpitmaq(): z=ml.aq.z[1:], c=ml.aq.c[1:], topboundary="conf", - refine_level=3, + refine_level=2, ) tml.Well(ml, 0, 0) ml.solve(silent=True) - assert len(ml.elementlist) == 51 + eps = 1e-6 + xyin = [ + (-10 + eps, -5 + eps), + (10 - eps, -5 + eps), + (10 - eps, 5 - eps), + (-10 + eps, 5 - eps), + (-10 + eps, -5 + eps), + ] + assert len(ml.elementlist) == 35 + # accuracy of intnormflux around inner boundary is reasonable but not perfect assert np.allclose( - np.sum(ml.intnormflux(xy, ndeg=99), axis=1), + np.sum(ml.intnormflux(xyin, ndeg=99), axis=1), [0.0, 100.0], - atol=0.15, - rtol=0.01, + atol=1e-1, + rtol=1e-3, ) @@ -217,16 +230,25 @@ def test_refine_buildingpit3d(): kzoverkh=0.25, z=ml.aq.z[1:], topboundary="conf", - refine_level=3, + refine_level=2, ) tml.Well(ml, 0, 0) ml.solve(silent=True) - assert len(ml.elementlist) == 51 + eps = 1e-6 + xyin = [ + (-10 + eps, -5 + eps), + (10 - eps, -5 + eps), + (10 - eps, 5 - eps), + (-10 + eps, 5 - eps), + (-10 + eps, -5 + eps), + ] + assert len(ml.elementlist) == 35 + # NOTE: accuracy of intnormflux around inner boundary isn't great... assert np.allclose( - np.sum(ml.intnormflux(xy, ndeg=99), axis=1), + np.sum(ml.intnormflux(xyin, ndeg=99), axis=1), [0.0, 100.0], atol=1.0, - rtol=0.01, + rtol=1e-3, ) From b67338651b3332698dc2e3a82558eeb3bba5998f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Thu, 4 Jan 2024 12:54:12 +0100 Subject: [PATCH 34/39] update docs --- timml/util.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/timml/util.py b/timml/util.py index 4d7fb60d..28c2e934 100644 --- a/timml/util.py +++ b/timml/util.py @@ -400,7 +400,7 @@ def compute_z1z2(xy): def refine_n_segments(xy, shape_type, n_segments): """Refine line segments into n_segments each. - Use controlpoints half-circle approach to determine new segment lengths. + Use cosine-rule to determine new segment lengths. Parameters ---------- From dd326384efd848923daa5d0c8fb5b31f7af845a3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Thu, 4 Jan 2024 16:45:46 +0100 Subject: [PATCH 35/39] implement resert for elements - solution for cases with subsequent solves, first with refine, next without - implement _reset() methods to reset internal vars to original values - modify initialize calls to call _reset() - add tests --- tests/test_refine.py | 39 +++++++++++++++++++++++++++++++++++++-- timml/aquifer.py | 4 ++++ timml/inhomogeneity.py | 34 ++++++++++++++++++---------------- timml/linesink.py | 10 ++++++++++ timml/model.py | 2 ++ 5 files changed, 71 insertions(+), 18 deletions(-) diff --git a/tests/test_refine.py b/tests/test_refine.py index 21d2d977..0fabf92a 100644 --- a/tests/test_refine.py +++ b/tests/test_refine.py @@ -332,5 +332,40 @@ def test_multiple_solves(): tml.HeadLineSink(ml, refine_level=3) ml.solve(silent=True) assert len(ml.elementlist) == 4 - ml.solve(silent=True) - assert len(ml.elementlist) == 4 + ml.solve(silent=True, refine_level=1) + assert len(ml.elementlist) == 2 + + +def test_reset_headlinesinkstring(): + ml = modelmaq() + hls = tml.HeadLineSinkString(ml, refine_level=2) + ml.initialize() + assert len(hls.lslist) == 2 + ml.initialize(refine_level=1) + assert len(hls.lslist) == 1 + + +def test_reset_leakybuildingpitmaq(): + ml = modelmaq() + xy = [ + (-10, -5), + (10, -5), + (10, 5), + (-10, 5), + (-10, -5), + ] + tml.LeakyBuildingPitMaq( + ml, + xy, + kaq=ml.aq.kaq, + z=ml.aq.z[1:], + c=ml.aq.c[1:], + res=[100, 100, 1, 100], + topboundary="conf", + refine_level=2, + ) + tml.Well(ml, 0, 0) + ml.initialize() + assert len(ml.elementlist) == 35 + ml.initialize(refine_level=1) + assert len(ml.elementlist) == 19 diff --git a/timml/aquifer.py b/timml/aquifer.py index 5bec46d3..449194f0 100644 --- a/timml/aquifer.py +++ b/timml/aquifer.py @@ -120,6 +120,10 @@ def initialize(self, refine_level=None): inhom.refine_level > 1 or refine_level is not None ): inhom._refine(n=refine_level) # refine element + else: + # potentially reset refined parameters if initialize + # has already been called with refine_level > 1 + inhom._reset() inhom.initialize() self.inhomlist.append(inhom) for inhom in self.inhomlist: diff --git a/timml/inhomogeneity.py b/timml/inhomogeneity.py index 2fb68f56..270e6655 100644 --- a/timml/inhomogeneity.py +++ b/timml/inhomogeneity.py @@ -36,7 +36,6 @@ def __init__( refine_level=1, addtomodel=True, ): - self._input = {k: v for k, v in locals().items() if k not in ["self", "model"]} # All input variables except model should be numpy arrays # That should be checked outside this function): AquiferData.__init__(self, model, kaq, c, z, npor, ltype) @@ -53,8 +52,6 @@ def __init__( # introduce internal vars that can be modified by _refine() self._xy = self.xy.copy() - self.compute_derived_params() - def compute_derived_params(self): self.z1, self.z2 = compute_z1z2(self._xy) self.Nsides = len(self.z1) @@ -103,6 +100,8 @@ def isinside(self, x, y): return rv def create_elements(self): + # update derived parameters + self.compute_derived_params() aqin = self.model.aq.find_aquifer_data(self.zcin[0].real, self.zcin[0].imag) inhom_elements = [] for i in range(self.Nsides): @@ -158,8 +157,9 @@ def _refine(self, n=None): # refine xy xyr, _ = refine_n_segments(self.xy, "polygon", n_segments=n) self._xy = xyr - # update derived parameters - self.compute_derived_params() + + def _reset(self): + self._xy = self.xy.copy() class PolygonInhomMaq(PolygonInhom): @@ -225,7 +225,6 @@ def __init__( refine_level=1, addtomodel=True, ): - _input = {k: v for k, v in locals().items() if k not in ["self", "model"]} if N is not None: assert ( topboundary[:4] == "conf" @@ -253,7 +252,6 @@ def __init__( refine_level=refine_level, addtomodel=addtomodel, ) - self._input = _input class PolygonInhom3D(PolygonInhom): @@ -324,7 +322,6 @@ def __init__( refine_level=1, addtomodel=True, ): - _input = {k: v for k, v in locals().items() if k not in ["self", "model"]} if N is not None: assert ( topboundary[:4] == "conf" @@ -349,7 +346,6 @@ def __init__( refine_level=refine_level, addtomodel=addtomodel, ) - self._input = _input class BuildingPit(AquiferData): @@ -420,6 +416,7 @@ def __init__( self.order = order self.ndeg = ndeg self.xy = xy + self.Nsides = len(self.xy) self.layers = np.atleast_1d(layers) # layers with impermeable wall self.nonimplayers = list( set(range(self.model.aq.naq)) - set(self.layers) @@ -433,9 +430,6 @@ def __init__( # introduce internal var that can be updated by _refine() self._xy = self.xy.copy() - # compute derived params - self.compute_derived_params() - def compute_derived_params(self): self.z1, self.z2 = compute_z1z2(self._xy) self.Nsides = len(self.z1) @@ -487,6 +481,8 @@ def isinside(self, x, y): return rv def create_elements(self): + # update derived parameters + self.compute_derived_params() aqin = self.model.aq.find_aquifer_data(self.zcin[0].real, self.zcin[0].imag) inhom_elements = [] for i in range(self.Nsides): @@ -578,8 +574,9 @@ def _refine(self, n=None): # refine xy xyr, _ = refine_n_segments(self.xy, "polygon", n_segments=n) self._xy = xyr - # update derived params - self.compute_derived_params() + + def _reset(self): + self._xy = self.xy.copy() class BuildingPitMaq(BuildingPit): @@ -834,6 +831,7 @@ def __init__( refine_level=refine_level, addtomodel=addtomodel, ) + self.compute_derived_params() # calculate Nsides if isinstance(res, (int, float, np.integer)): # make 2D so indexing resistance works for all cases self.res = res * np.ones((1, self.Nsides)) @@ -860,6 +858,8 @@ def __init__( self._res = self.res.copy() def create_elements(self): + # update derived parameters + self.compute_derived_params() aqin = self.model.aq.find_aquifer_data(self.zcin[0].real, self.zcin[0].imag) inhom_elements = [] for i in range(self.Nsides): @@ -958,8 +958,10 @@ def _refine(self, n=None): self._xy = xyr # update input args self._res = self.res[:, reindexer] - # update derived parameters - self.compute_derived_params() + + def _reset(self): + self._xy = self.xy.copy() + self._res = self.res.copy() class LeakyBuildingPitMaq(LeakyBuildingPit): diff --git a/timml/linesink.py b/timml/linesink.py index 4cb41ed7..f3535b76 100644 --- a/timml/linesink.py +++ b/timml/linesink.py @@ -905,6 +905,12 @@ def plot(self, layer=None): if (layer is None) or (layer in self._layers): plt.plot(self.x, self.y, "k") + def _reset(self): + self._xy = self.xy.copy() + self._x = self.x.copy() + self._y = self.y.copy() + self._layers = self.layers.copy() + class HeadLineSinkString(LineSinkStringBase): """ @@ -1098,6 +1104,10 @@ def _refine(self, n=None): self.nls = len(self._x) - 1 return [self] + def _reset(self): + super()._reset() + self._hls = self.hls.copy() + class LineSinkDitchString(HeadLineSinkString): """ diff --git a/timml/model.py b/timml/model.py index eb13ab18..5adc309c 100644 --- a/timml/model.py +++ b/timml/model.py @@ -63,6 +63,8 @@ def initialize(self, refine_level=None): refined_element = e._refine(n=refine_level) elementlist += refined_element else: + if hasattr(e, "_reset"): + e._reset() # reset variables in case _refine was previously called elementlist.append(e) # remove inhomogeneity elements (they are added again) From d5df5de4604d159c949f49a60b8c1e9b4f9ac6b2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Thu, 4 Jan 2024 17:21:15 +0100 Subject: [PATCH 36/39] fix failing tests --- timml/aquifer.py | 2 +- timml/inhomogeneity.py | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/timml/aquifer.py b/timml/aquifer.py index 449194f0..ae1d1cac 100644 --- a/timml/aquifer.py +++ b/timml/aquifer.py @@ -120,7 +120,7 @@ def initialize(self, refine_level=None): inhom.refine_level > 1 or refine_level is not None ): inhom._refine(n=refine_level) # refine element - else: + elif hasattr(inhom, "_reset"): # potentially reset refined parameters if initialize # has already been called with refine_level > 1 inhom._reset() diff --git a/timml/inhomogeneity.py b/timml/inhomogeneity.py index 270e6655..1188ae0c 100644 --- a/timml/inhomogeneity.py +++ b/timml/inhomogeneity.py @@ -51,6 +51,7 @@ def __init__( # introduce internal vars that can be modified by _refine() self._xy = self.xy.copy() + self.compute_derived_params() # needed for isinside calls def compute_derived_params(self): self.z1, self.z2 = compute_z1z2(self._xy) @@ -429,6 +430,7 @@ def __init__( # introduce internal var that can be updated by _refine() self._xy = self.xy.copy() + self.compute_derived_params() # needed for isinside calls def compute_derived_params(self): self.z1, self.z2 = compute_z1z2(self._xy) @@ -831,7 +833,6 @@ def __init__( refine_level=refine_level, addtomodel=addtomodel, ) - self.compute_derived_params() # calculate Nsides if isinstance(res, (int, float, np.integer)): # make 2D so indexing resistance works for all cases self.res = res * np.ones((1, self.Nsides)) From 446a1f53904908cb91dcdb983472acf10570a8c9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Tue, 13 Feb 2024 13:05:00 +0100 Subject: [PATCH 37/39] tiny improvement to notebook --- notebooks/refining_elements.ipynb | 26 ++++++++++++++++++++------ 1 file changed, 20 insertions(+), 6 deletions(-) diff --git a/notebooks/refining_elements.ipynb b/notebooks/refining_elements.ipynb index 27b288d8..df1fc67f 100644 --- a/notebooks/refining_elements.ipynb +++ b/notebooks/refining_elements.ipynb @@ -197,9 +197,9 @@ "source": [ "Supported elements can be refined by passing the `refine_level` kwarg. A refinement\n", "level of 0 or 1 means no refinement is applied. A refinement level of 3 means that a\n", - "line-sink is split into 3 segments. The segmentation is performed according to the\n", - "cosine rule (the same method that determines the location of the control points for a\n", - "line element).\n", + "line-sink is split into 3 segments. The segmentation is performed according to an\n", + "adjusted version of the cosine rule (the same method that determines the location of\n", + "the control points for a line element in TimML).\n", "\n", "In this example a single `HeadLineSink` is refined into 3 segments. The head along the\n", "line-sink is compared to a case with no refinement.\n", @@ -695,7 +695,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -800,7 +800,14 @@ "output_type": "stream", "text": [ "Number of elements, Number of equations: 19 , 65\n", - "...................\n", + ".." + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + ".................\n", "solution complete\n" ] } @@ -981,7 +988,14 @@ "output_type": "stream", "text": [ "Number of elements, Number of equations: 51 , 193\n", - "...................................................\n", + ".." + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + ".................................................\n", "solution complete\n" ] } From ff9b161fc87d07dbd2188df9f14be16e764cab4e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 14 Feb 2024 13:13:24 +0100 Subject: [PATCH 38/39] remove LineSinkStringBase, HeadLineSinkStringOld rename LineSinkStringBase2 to LineSinkStringBase --- .gitignore | 5 +- timml/linesink.py | 185 +--------------------------------------------- 2 files changed, 6 insertions(+), 184 deletions(-) diff --git a/.gitignore b/.gitignore index e047aab3..99f82f6e 100644 --- a/.gitignore +++ b/.gitignore @@ -99,7 +99,10 @@ ENV/ # f2py .plist -.vscode/settings.json + +.vscode + +coverage/ # docs _build/ diff --git a/timml/linesink.py b/timml/linesink.py index f11c5745..943a1ad3 100644 --- a/timml/linesink.py +++ b/timml/linesink.py @@ -756,188 +756,6 @@ def setparams(self, sol): class LineSinkStringBase(Element): - """Original implementation. - - Used for boundaries of inhomogenieities. - """ - - def __init__( - self, - model, - xy, - closed=False, - layers=0, - order=0, - name="LineSinkStringBase", - label=None, - aq=None, - ): - Element.__init__( - self, model, nparam=1, nunknowns=0, layers=layers, name=name, label=label - ) - self.xy = np.atleast_2d(xy).astype("d") - if closed: - self.xy = np.vstack((self.xy, self.xy[0])) - self.order = order - self.aq = aq - self.lslist = [] - self.x, self.y = self.xy[:, 0], self.xy[:, 1] - self.nls = len(self.x) - 1 - for i in range(self.nls): - if label is not None: - lslabel = label + "_" + str(i) - else: - lslabel = label - self.lslist.append( - LineSinkHoBase( - model, - x1=self.x[i], - y1=self.y[i], - x2=self.x[i + 1], - y2=self.y[i + 1], - Qls=0.0, - layers=layers, - order=order, - label=lslabel, - addtomodel=False, - aq=aq, - ) - ) - - def __repr__(self): - return self.name + " with nodes " + str(self.xy) - - def initialize(self): - for ls in self.lslist: - ls.initialize() - # Same order for all elements in string - self.ncp = self.nls * self.lslist[0].ncp - self.nparam = self.nls * self.lslist[0].nparam - self.nunknowns = self.nparam - self.xls = np.empty((self.nls, 2)) - self.yls = np.empty((self.nls, 2)) - for i, ls in enumerate(self.lslist): - self.xls[i, :] = [ls.x1, ls.x2] - self.yls[i, :] = [ls.y1, ls.y2] - if self.aq is None: - self.aq = self.model.aq.find_aquifer_data( - self.lslist[0].xc, self.lslist[0].yc - ) - self.parameters = np.zeros((self.nparam, 1)) - # As parameters are only stored for the element not the list, - # we need to combine the following - self.xc = np.array([ls.xc for ls in self.lslist]).flatten() - self.yc = np.array([ls.yc for ls in self.lslist]).flatten() - self.xcin = np.array([ls.xcin for ls in self.lslist]).flatten() - self.ycin = np.array([ls.ycin for ls in self.lslist]).flatten() - self.xcout = np.array([ls.xcout for ls in self.lslist]).flatten() - self.ycout = np.array([ls.ycout for ls in self.lslist]).flatten() - self.cosnorm = np.array([ls.cosnorm for ls in self.lslist]).flatten() - self.sinnorm = np.array([ls.sinnorm for ls in self.lslist]).flatten() - self.aqin = self.model.aq.find_aquifer_data(self.xcin[0], self.ycin[0]) - self.aqout = self.model.aq.find_aquifer_data(self.xcout[0], self.ycout[0]) - - def potinf(self, x, y, aq=None): - """Compute the unit potential influence of the element. - - Returns - ------- - array - linesink 0, order 0, layer[0] - order 0, layer[1] - ... - order 1, layer[0] - order 1, layer[1] - ... - linesink 1, order 0, layer[0] - order 0, layer[1] - ... - order 1, layer[0] - order 1, layer[1] - ... - """ - if aq is None: - aq = self.model.aq.find_aquifer_data(x, y) - rv = np.zeros((self.nls, self.lslist[0].nparam, aq.naq)) - for i in range(self.nls): - rv[i] = self.lslist[i].potinf(x, y, aq) - rv.shape = (self.nparam, aq.naq) - return rv - - def disvecinf(self, x, y, aq=None): - if aq is None: - aq = self.model.aq.find_aquifer_data(x, y) - rv = np.zeros((2, self.nls, self.lslist[0].nparam, aq.naq)) - for i in range(self.nls): - rv[:, i] = self.lslist[i].disvecinf(x, y, aq) - rv.shape = (2, self.nparam, aq.naq) - return rv - - def changetrace( - self, xyzt1, xyzt2, aq, layer, ltype, modellayer, direction, hstepmax - ): - changed = False - terminate = False - xyztnew = 0 - message = None - for ls in self.lslist: - changed, terminate, xyztnew, message = ls.changetrace( - xyzt1, xyzt2, aq, layer, ltype, modellayer, direction - ) - if changed or terminate: - return changed, terminate, xyztnew, message - return changed, terminate, xyztnew, message - - def plot(self, layer=None): - if (layer is None) or (layer in self.layers): - plt.plot(self.x, self.y, "k") - - -class HeadLineSinkStringOLd(LineSinkStringBase, HeadEquation): - def __init__( - self, model, xy=[(-1, 0), (1, 0)], hls=0.0, layers=0, order=0, label=None - ): - self.storeinput(inspect.currentframe()) - LineSinkStringBase.__init__( - self, - model, - xy, - closed=False, - layers=layers, - order=order, - name="HeadLineSinkString", - label=label, - aq=None, - ) - self.hls = np.atleast_1d(hls) - self.model.add_element(self) - - def initialize(self): - LineSinkStringBase.initialize(self) - self.aq.add_element(self) - # self.pc = np.array([ls.pc for ls in self.lslist]).flatten() - if len(self.hls) == 1: - self.pc = self.hls * self.aq.T[self.layers] * np.ones(self.nparam) - elif len(self.hls) == self.nls: # head specified at centers - self.pc = (self.hls[:, np.newaxis] * self.aq.T[self.layers]).flatten() - elif len(self.hls) == 2: - L = np.array([ls.L for ls in self.lslist]) - Ltot = np.sum(L) - xp = np.zeros(self.nls) - xp[0] = 0.5 * L[0] - for i in range(1, self.nls): - xp[i] = xp[i - 1] + 0.5 * (L[i - 1] + L[i]) - self.hls = np.interp(xp, [0, Ltot], self.hls) - self.pc = (self.hls[:, np.newaxis] * self.aq.T[self.layers]).flatten() - else: - print("Error: hls entry not supported") - self.resfac = 0.0 - - def setparams(self, sol): - self.parameters[:, 0] = sol - - -class LineSinkStringBase2(Element): """Alternative implementation that loops through line-sinks to build equation. Has the advantage that it is easier to have different line-sinks in different layers @@ -1100,7 +918,8 @@ def _reset(self): self._y = self.y.copy() self._layers = self.layers.copy() -class HeadLineSinkString(LineSinkStringBase2): + +class HeadLineSinkString(LineSinkStringBase): """Class to create a string of head-specified line-sinks which may optionally have a width and resistance. From 4decd0add371b43515954740a4924485e9665f95 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Wed, 14 Feb 2024 13:35:55 +0100 Subject: [PATCH 39/39] mucked up a merge conflict --- timml/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/timml/__init__.py b/timml/__init__.py index 4bde8ec4..215baaad 100644 --- a/timml/__init__.py +++ b/timml/__init__.py @@ -46,7 +46,7 @@ from timml.trace import timtraceline, timtracelines from timml.uflow import Uflow from timml.version import __version__ -from timml.well import HeadWell, Well, WellBase +from timml.well import HeadWell, LargeDiameterWell, Well, WellBase __all__ = [s for s in dir() if not s.startswith("_")]