#
# turtle.py: a Tkinter based turtle graphics module for Python
# Version 1.1b - 4. 5. 2009
#
# Copyright (C) 2006 - 2010  Gregor Lingl
# email: glingl@aon.at
#
# This software is provided 'as-is', without any express or implied
# warranty.  In no event will the authors be held liable for any damages
# arising from the use of this software.
#
# Permission is granted to anyone to use this software for any purpose,
# including commercial applications, and to alter it and redistribute it
# freely, subject to the following restrictions:
#
# 1. The origin of this software must not be misrepresented; you must not
#    claim that you wrote the original software. If you use this software
#    in a product, an acknowledgment in the product documentation would be
#    appreciated but is not required.
# 2. Altered source versions must be plainly marked as such, and must not be
#    misrepresented as being the original software.
# 3. This notice may not be removed or altered from any source distribution.


"""
Turtle graphics is a popular way for introducing programming to
kids. It was part of the original Logo programming language developed
by Wally Feurzig and Seymour Papert in 1966.

Imagine a robotic turtle starting at (0, 0) in the x-y plane. After an ``import turtle``, give it
the command turtle.forward(15), and it moves (on-screen!) 15 pixels in
the direction it is facing, drawing a line as it moves. Give it the
command turtle.right(25), and it rotates in-place 25 degrees clockwise.

By combining together these and similar commands, intricate shapes and
pictures can easily be drawn.

----- turtle.py

This module is an extended reimplementation of turtle.py from the
Python standard distribution up to Python 2.5. (See: https://www.python.org)

It tries to keep the merits of turtle.py and to be (nearly) 100%
compatible with it. This means in the first place to enable the
learning programmer to use all the commands, classes and methods
interactively when using the module from within IDLE run with
the -n switch.

Roughly it has the following features added:

- Better animation of the turtle movements, especially of turning the
  turtle. So the turtles can more easily be used as a visual feedback
  instrument by the (beginning) programmer.

- Different turtle shapes, gif-images as turtle shapes, user defined
  and user controllable turtle shapes, among them compound
  (multicolored) shapes. Turtle shapes can be stretched and tilted, which
  makes turtles very versatile geometrical objects.

- Fine control over turtle movement and screen updates via delay(),
  and enhanced tracer() and speed() methods.

- Aliases for the most commonly used commands, like fd for forward etc.,
  following the early Logo traditions. This reduces the boring work of
  typing long sequences of commands, which often occur in a natural way
  when kids try to program fancy pictures on their first encounter with
  turtle graphics.

- Turtles now have an undo()-method with configurable undo-buffer.

- Some simple commands/methods for creating event driven programs
  (mouse-, key-, timer-events). Especially useful for programming games.

- A scrollable Canvas class. The default scrollable Canvas can be
  extended interactively as needed while playing around with the turtle(s).

- A TurtleScreen class with methods controlling background color or
  background image, window and canvas size and other properties of the
  TurtleScreen.

- There is a method, setworldcoordinates(), to install a user defined
  coordinate-system for the TurtleScreen.

- The implementation uses a 2-vector class named Vec2D, derived from tuple.
  This class is public, so it can be imported by the application programmer,
  which makes certain types of computations very natural and compact.

- Appearance of the TurtleScreen and the Turtles at startup/import can be
  configured by means of a turtle.cfg configuration file.
  The default configuration mimics the appearance of the old turtle module.

- If configured appropriately the module reads in docstrings from a docstring
  dictionary in some different language, supplied separately  and replaces
  the English ones by those read in. There is a utility function
  write_docstringdict() to write a dictionary with the original (English)
  docstrings to disc, so it can serve as a template for translations.

Behind the scenes there are some features included with possible
extensions in mind. These will be commented and documented elsewhere.

"""

_ver = "turtle 1.1b- - for Python 3.1   -  4. 5. 2009"

# print(_ver)

import tkinter as TK
import types
import math
import time
import inspect
import sys
import warnings

from os.path import isfile, split, join
from copy import deepcopy
from tkinter import simpledialog

_tg_classes = ['ScrolledCanvas', 'TurtleScreen', 'Screen',
               'RawTurtle', 'Turtle', 'RawPen', 'Pen', 'Shape', 'Vec2D']
_tg_screen_functions = ['addshape', 'bgcolor', 'bgpic', 'bye',
        'clearscreen', 'colormode', 'delay', 'exitonclick', 'getcanvas',
        'getshapes', 'listen', 'mainloop', 'mode', 'numinput',
        'onkey', 'onkeypress', 'onkeyrelease', 'onscreenclick', 'ontimer',
        'register_shape', 'resetscreen', 'screensize', 'setup',
        'setworldcoordinates', 'textinput', 'title', 'tracer', 'turtles', 'update',
        'window_height', 'window_width']
_tg_turtle_functions = ['back', 'backward', 'begin_fill', 'begin_poly', 'bk',
        'circle', 'clear', 'clearstamp', 'clearstamps', 'clone', 'color',
        'degrees', 'distance', 'dot', 'down', 'end_fill', 'end_poly', 'fd',
        'fillcolor', 'filling', 'forward', 'get_poly', 'getpen', 'getscreen', 'get_shapepoly',
        'getturtle', 'goto', 'heading', 'hideturtle', 'home', 'ht', 'isdown',
        'isvisible', 'left', 'lt', 'onclick', 'ondrag', 'onrelease', 'pd',
        'pen', 'pencolor', 'pendown', 'pensize', 'penup', 'pos', 'position',
        'pu', 'radians', 'right', 'reset', 'resizemode', 'rt',
        'seth', 'setheading', 'setpos', 'setposition', 'settiltangle',
        'setundobuffer', 'setx', 'sety', 'shape', 'shapesize', 'shapetransform', 'shearfactor', 'showturtle',
        'speed', 'st', 'stamp', 'tilt', 'tiltangle', 'towards',
        'turtlesize', 'undo', 'undobufferentries', 'up', 'width',
        'write', 'xcor', 'ycor']
_tg_utilities = ['write_docstringdict', 'done']

__all__ = (_tg_classes + _tg_screen_functions + _tg_turtle_functions +
           _tg_utilities + ['Terminator']) # + _math_functions)

_alias_list = ['addshape', 'backward', 'bk', 'fd', 'ht', 'lt', 'pd', 'pos',
               'pu', 'rt', 'seth', 'setpos', 'setposition', 'st',
               'turtlesize', 'up', 'width']

_CFG = {"width" : 0.5,               # Screen
        "height" : 0.75,
        "canvwidth" : 400,
        "canvheight": 300,
        "leftright": None,
        "topbottom": None,
        "mode": "standard",          # TurtleScreen
        "colormode": 1.0,
        "delay": 10,
        "undobuffersize": 1000,      # RawTurtle
        "shape": "classic",
        "pencolor" : "black",
        "fillcolor" : "black",
        "resizemode" : "noresize",
        "visible" : True,
        "language": "english",        # docstrings
        "exampleturtle": "turtle",
        "examplescreen": "screen",
        "title": "Python Turtle Graphics",
        "using_IDLE": False
       }

def config_dict(filename):
    """Convert content of config-file into dictionary."""
    with open(filename, "r") as f:
        cfglines = f.readlines()
    cfgdict = {}
    for line in cfglines:
        line = line.strip()
        if not line or line.startswith("#"):
            continue
        try:
            key, value = line.split("=")
        except ValueError:
            print("Bad line in config-file %s:\n%s" % (filename,line))
            continue
        key = key.strip()
        value = value.strip()
        if value in ["True", "False", "None", "''", '""']:
            value = eval(value)
        else:
            try:
                if "." in value:
                    value = float(value)
                else:
                    value = int(value)
            except ValueError:
                pass # value need not be converted
        cfgdict[key] = value
    return cfgdict

def readconfig(cfgdict):
    """Read config-files, change configuration-dict accordingly.

    If there is a turtle.cfg file in the current working directory,
    read it from there. If this contains an importconfig-value,
    say 'myway', construct filename turtle_mayway.cfg else use
    turtle.cfg and read it from the import-directory, where
    turtle.py is located.
    Update configuration dictionary first according to config-file,
    in the import directory, then according to config-file in the
    current working directory.
    If no config-file is found, the default configuration is used.
    """
    default_cfg = "turtle.cfg"
    cfgdict1 = {}
    cfgdict2 = {}
    if isfile(default_cfg):
        cfgdict1 = config_dict(default_cfg)
    if "importconfig" in cfgdict1:
        default_cfg = "turtle_%s.cfg" % cfgdict1["importconfig"]
    try:
        head, tail = split(__file__)
        cfg_file2 = join(head, default_cfg)
    except Exception:
        cfg_file2 = ""
    if isfile(cfg_file2):
        cfgdict2 = config_dict(cfg_file2)
    _CFG.update(cfgdict2)
    _CFG.update(cfgdict1)

try:
    readconfig(_CFG)
except Exception:
    print ("No configfile read, reason unknown")


class Vec2D(tuple):
    """A 2 dimensional vector class, used as a helper class
    for implementing turtle graphics.
    May be useful for turtle graphics programs also.
    Derived from tuple, so a vector is a tuple!

    Provides (for a, b vectors, k number):
       a+b vector addition
       a-b vector subtraction
       a*b inner product
       k*a and a*k multiplication with scalar
       |a| absolute value of a
       a.rotate(angle) rotation
    """
    def __new__(cls, x, y):
        return tuple.__new__(cls, (x, y))
    def __add__(self, other):
        return Vec2D(self[0]+other[0], self[1]+other[1])
    def __mul__(self, other):
        if isinstance(other, Vec2D):
            return self[0]*other[0]+self[1]*other[1]
        return Vec2D(self[0]*other, self[1]*other)
    def __rmul__(self, other):
        if isinstance(other, int) or isinstance(other, float):
            return Vec2D(self[0]*other, self[1]*other)
        return NotImplemented
    def __sub__(self, other):
        return Vec2D(self[0]-other[0], self[1]-other[1])
    def __neg__(self):
        return Vec2D(-self[0], -self[1])
    def __abs__(self):
        return math.hypot(*self)
    def rotate(self, angle):
        """rotate self counterclockwise by angle
        """
        perp = Vec2D(-self[1], self[0])
        angle = math.radians(angle)
        c, s = math.cos(angle), math.sin(angle)
        return Vec2D(self[0]*c+perp[0]*s, self[1]*c+perp[1]*s)
    def __getnewargs__(self):
        return (self[0], self[1])
    def __repr__(self):
        return "(%.2f,%.2f)" % self


##############################################################################
### From here up to line    : Tkinter - Interface for turtle.py            ###
### May be replaced by an interface to some different graphics toolkit     ###
##############################################################################

## helper functions for Scrolled Canvas, to forward Canvas-methods
## to ScrolledCanvas class

def __methodDict(cls, _dict):
    """helper function for Scrolled Canvas"""
    baseList = list(cls.__bases__)
    baseList.reverse()
    for _super in baseList:
        __methodDict(_super, _dict)
    for key, value in cls.__dict__.items():
        if type(value) == types.FunctionType:
            _dict[key] = value

def __methods(cls):
    """helper function for Scrolled Canvas"""
    _dict = {}
    __methodDict(cls, _dict)
    return _dict.keys()

__stringBody = (
    'def %(method)s(self, *args, **kw): return ' +
    'self.%(attribute)s.%(method)s(*args, **kw)')

def __forwardmethods(fromClass, toClass, toPart, exclude = ()):
    ### MANY CHANGES ###
    _dict_1 = {}
    __methodDict(toClass, _dict_1)
    _dict = {}
    mfc = __methods(fromClass)
    for ex in _dict_1.keys():
        if ex[:1] == '_' or ex[-1:] == '_' or ex in exclude or ex in mfc:
            pass
        else:
            _dict[ex] = _dict_1[ex]

    for method, func in _dict.items():
        d = {'method': method, 'func': func}
        if isinstance(toPart, str):
            execString = \
                __stringBody % {'method' : method, 'attribute' : toPart}
        exec(execString, d)
        setattr(fromClass, method, d[method])   ### NEWU!


class ScrolledCanvas(TK.Frame):
    """Modeled after the scrolled canvas class from Grayons's Tkinter book.

    Used as the default canvas, which pops up automatically when
    using turtle graphics functions or the Turtle class.
    """
    def __init__(self, master, width=500, height=350,
                                          canvwidth=600, canvheight=500):
        TK.Frame.__init__(self, master, width=width, height=height)
        self._rootwindow = self.winfo_toplevel()
        self.width, self.height = width, height
        self.canvwidth, self.canvheight = canvwidth, canvheight
        self.bg = "white"
        self._canvas = TK.Canvas(master, width=width, height=height,
                                 bg=self.bg, relief=TK.SUNKEN, borderwidth=2)
        self.hscroll = TK.Scrollbar(master, command=self._canvas.xview,
                                    orient=TK.HORIZONTAL)
        self.vscroll = TK.Scrollbar(master, command=self._canvas.yview)
        self._canvas.configure(xscrollcommand=self.hscroll.set,
                               yscrollcommand=self.vscroll.set)
        self.rowconfigure(0, weight=1, minsize=0)
        self.columnconfigure(0, weight=1, minsize=0)
        self._canvas.grid(padx=1, in_ = self, pady=1, row=0,
                column=0, rowspan=1, columnspan=1, sticky='news')
        self.vscroll.grid(padx=1, in_ = self, pady=1, row=0,
                column=1, rowspan=1, columnspan=1, sticky='news')
        self.hscroll.grid(padx=1, in_ = self, pady=1, row=1,
                column=0, rowspan=1, columnspan=1, sticky='news')
        self.reset()
        self._rootwindow.bind('<Configure>', self.onResize)

    def reset(self, canvwidth=None, canvheight=None, bg = None):
        """Adjust canvas and scrollbars according to given canvas size."""
        if canvwidth:
            self.canvwidth = canvwidth
        if canvheight:
            self.canvheight = canvheight
        if bg:
            self.bg = bg
        self._canvas.config(bg=bg,
                        scrollregion=(-self.canvwidth//2, -self.canvheight//2,
                                       self.canvwidth//2, self.canvheight//2))
        self._canvas.xview_moveto(0.5*(self.canvwidth - self.width + 30) /
                                                               self.canvwidth)
        self._canvas.yview_moveto(0.5*(self.canvheight- self.height + 30) /
                                                              self.canvheight)
        self.adjustScrolls()


    def adjustScrolls(self):
        """ Adjust scrollbars according to window- and canvas-size.
        """
        cwidth = self._canvas.winfo_width()
        cheight = self._canvas.winfo_height()
        self._canvas.xview_moveto(0.5*(self.canvwidth-cwidth)/self.canvwidth)
        self._canvas.yview_moveto(0.5*(self.canvheight-cheight)/self.canvheight)
        if cwidth < self.canvwidth or cheight < self.canvheight:
            self.hscroll.grid(padx=1, in_ = self, pady=1, row=1,
                              column=0, rowspan=1, columnspan=1, sticky='news')
            self.vscroll.grid(padx=1, in_ = self, pady=1, row=0,
                              column=1, rowspan=1, columnspan=1, sticky='news')
        else:
            self.hscroll.grid_forget()
            self.vscroll.grid_forget()

    def onResize(self, event):
        """self-explanatory"""
        self.adjustScrolls()

    def bbox(self, *args):
        """ 'forward' method, which canvas itself has inherited...
        """
        return self._canvas.bbox(*args)

    def cget(self, *args, **kwargs):
        """ 'forward' method, which canvas itself has inherited...
        """
        return self._canvas.cget(*args, **kwargs)

    def config(self, *args, **kwargs):
        """ 'forward' method, which canvas itself has inherited...
        """
        self._canvas.config(*args, **kwargs)

    def bind(self, *args, **kwargs):
        """ 'forward' method, which canvas itself has inherited...
        """
        self._canvas.bind(*args, **kwargs)

    def unbind(self, *args, **kwargs):
        """ 'forward' method, which canvas itself has inherited...
        """
        self._canvas.unbind(*args, **kwargs)

    def focus_force(self):
        """ 'forward' method, which canvas itself has inherited...
        """
        self._canvas.focus_force()

__forwardmethods(ScrolledCanvas, TK.Canvas, '_canvas')


class _Root(TK.Tk):
    """Root class for Screen based on Tkinter."""
    def __init__(self):
        TK.Tk.__init__(self)

    def setupcanvas(self, width, height, cwidth, cheight):
        self._canvas = ScrolledCanvas(self, width, height, cwidth, cheight)
        self._canvas.pack(expand=1, fill="both")

    def _getcanvas(self):
        return self._canvas

    def set_geometry(self, width, height, startx, starty):
        self.geometry("%dx%d%+d%+d"%(width, height, startx, starty))

    def ondestroy(self, destroy):
        self.wm_protocol("WM_DELETE_WINDOW", destroy)

    def win_width(self):
        return self.winfo_screenwidth()

    def win_height(self):
        return self.winfo_screenheight()

Canvas = TK.Canvas


class TurtleScreenBase(object):
    """Provide the basic graphics functionality.
       Interface between Tkinter and turtle.py.

       To port turtle.py to some different graphics toolkit
       a corresponding TurtleScreenBase class has to be implemented.
    """

    def _blankimage(self):
        """return a blank image object
        """
        img = TK.PhotoImage(width=1, height=1, master=self.cv)
        img.blank()
        return img

    def _image(self, filename):
        """return an image object containing the
        imagedata from a gif-file named filename.
        """
        return TK.PhotoImage(file=filename, master=self.cv)

    def __init__(self, cv):
        self.cv = cv
        if isinstance(cv, ScrolledCanvas):
            w = self.cv.canvwidth
            h = self.cv.canvheight
        else:  # expected: ordinary TK.Canvas
            w = int(self.cv.cget("width"))
            h = int(self.cv.cget("height"))
            self.cv.config(scrollregion = (-w//2, -h//2, w//2, h//2 ))
        self.canvwidth = w
        self.canvheight = h
        self.xscale = self.yscale = 1.0

    def _createpoly(self):
        """Create an invisible polygon item on canvas self.cv)
        """
        return self.cv.create_polygon((0, 0, 0, 0, 0, 0), fill="", outline="")

    def _drawpoly(self, polyitem, coordlist, fill=None,
                  outline=None, width=None, top=False):
        """Configure polygonitem polyitem according to provided
        arguments:
        coordlist is sequence of coordinates
        fill is filling color
        outline is outline color
        top is a boolean value, which specifies if polyitem
        will be put on top of the canvas' displaylist so it
        will not be covered by other items.
        """
        cl = []
        for x, y in coordlist:
            cl.append(x * self.xscale)
            cl.append(-y * self.yscale)
        self.cv.coords(polyitem, *cl)
        if fill is not None:
            self.cv.itemconfigure(polyitem, fill=fill)
        if outline is not None:
            self.cv.itemconfigure(polyitem, outline=outline)
        if width is not None:
            self.cv.itemconfigure(polyitem, width=width)
        if top:
            self.cv.tag_raise(polyitem)

    def _createline(self):
        """Create an invisible line item on canvas self.cv)
        """
        return self.cv.create_line(0, 0, 0, 0, fill="", width=2,
                                   capstyle = TK.ROUND)

    def _drawline(self, lineitem, coordlist=None,
                  fill=None, width=None, top=False):
        """Configure lineitem according to provided arguments:
        coordlist is sequence of coordinates
        fill is drawing color
        width is width of drawn line.
        top is a boolean value, which specifies if polyitem
        will be put on top of the canvas' displaylist so it
        will not be covered by other items.
        """
        if coordlist is not None:
            cl = []
            for x, y in coordlist:
                cl.append(x * self.xscale)
                cl.append(-y * self.yscale)
            self.cv.coords(lineitem, *cl)
        if fill is not None:
            self.cv.itemconfigure(lineitem, fill=fill)
        if width is not None:
            self.cv.itemconfigure(lineitem, width=width)
        if top:
            self.cv.tag_raise(lineitem)

    def _delete(self, item):
        """Delete graphics item from canvas.
        If item is"all" delete all graphics items.
        """
        self.cv.delete(item)

    def _update(self):
        """Redraw graphics items on canvas
        """
        self.cv.update()

    def _delay(self, delay):
        """Delay subsequent canvas actions for delay ms."""
        self.cv.after(delay)

    def _iscolorstring(self, color):
        """Check if the string color is a legal Tkinter color string.
        """
        try:
            rgb = self.cv.winfo_rgb(color)
            ok = True
        except TK.TclError:
            ok = False
        return ok

    def _bgcolor(self, color=None):
        """Set canvas' backgroundcolor if color is not None,
        else return backgroundcolor."""
        if color is not None:
            self.cv.config(bg = color)
            self._update()
        else:
            return self.cv.cget("bg")

    def _write(self, pos, txt, align, font, pencolor):
        """Write txt at pos in canvas with specified font
        and color.
        Return text item and x-coord of right bottom corner
        of text's bounding box."""
        x, y = pos
        x = x * self.xscale
        y = y * self.yscale
        anchor = {"left":"sw", "center":"s", "right":"se" }
        item = self.cv.create_text(x-1, -y, text = txt, anchor = anchor[align],
                                        fill = pencolor, font = font)
        x0, y0, x1, y1 = self.cv.bbox(item)
        return item, x1-1

##    def _dot(self, pos, size, color):
##        """may be implemented for some other graphics toolkit"""

    def _onclick(self, item, fun, num=1, add=None):
        """Bind fun to mouse-click event on turtle.
        fun must be a function with two arguments, the coordinates
        of the clicked point on the canvas.
        num, the number of the mouse-button defaults to 1
        """
        if fun is None:
            self.cv.tag_unbind(item, "<Button-%s>" % num)
        else:
            def eventfun(event):
                x, y = (self.cv.canvasx(event.x)/self.xscale,
                        -self.cv.canvasy(event.y)/self.yscale)
                fun(x, y)
            self.cv.tag_bind(item, "<Button-%s>" % num, eventfun, add)

    def _onrelease(self, item, fun, num=1, add=None):
        """Bind fun to mouse-button-release event on turtle.
        fun must be a function with two arguments, the coordinates
        of the point on the canvas where mouse button is released.
        num, the number of the mouse-button defaults to 1

        If a turtle is clicked, first _onclick-event will be performed,
        then _onscreensclick-event.
        """
        if fun is None:
            self.cv.tag_unbind(item, "<Button%s-ButtonRelease>" % num)
        else:
            def eventfun(event):
                x, y = (self.cv.canvasx(event.x)/self.xscale,
                        -self.cv.canvasy(event.y)/self.yscale)
                fun(x, y)
            self.cv.tag_bind(item, "<Button%s-ButtonRelease>" % num,
                             eventfun, add)

    def _ondrag(self, item, fun, num=1, add=None):
        """Bind fun to mouse-move-event (with pressed mouse button) on turtle.
        fun must be a function with two arguments, the coordinates of the
        actual mouse position on the canvas.
        num, the number of the mouse-button defaults to 1

        Every sequence of mouse-move-events on a turtle is preceded by a
        mouse-click event on that turtle.
        """
        if fun is None:
            self.cv.tag_unbind(item, "<Button%s-Motion>" % num)
        else:
            def eventfun(event):
                try:
                    x, y = (self.cv.canvasx(event.x)/self.xscale,
                           -self.cv.canvasy(event.y)/self.yscale)
                    fun(x, y)
                except Exception:
                    pass
            self.cv.tag_bind(item, "<Button%s-Motion>" % num, eventfun, add)

    def _onscreenclick(self, fun, num=1, add=None):
        """Bind fun to mouse-click event on canvas.
        fun must be a function with two arguments, the coordinates
        of the clicked point on the canvas.
        num, the number of the mouse-button defaults to 1

        If a turtle is clicked, first _onclick-event will be performed,
        then _onscreensclick-event.
        """
        if fun is None:
            self.cv.unbind("<Button-%s>" % num)
        else:
            def eventfun(event):
                x, y = (self.cv.canvasx(event.x)/self.xscale,
                        -self.cv.canvasy(event.y)/self.yscale)
                fun(x, y)
            self.cv.bind("<Button-%s>" % num, eventfun, add)

    def _onkeyrelease(self, fun, key):
        """Bind fun to key-release event of key.
        Canvas must have focus. See method listen
        """
        if fun is None:
            self.cv.unbind("<KeyRelease-%s>" % key, None)
        else:
            def eventfun(event):
                fun()
            self.cv.bind("<KeyRelease-%s>" % key, eventfun)

    def _onkeypress(self, fun, key=None):
        """If key is given, bind fun to key-press event of key.
        Otherwise bind fun to any key-press.
        Canvas must have focus. See method listen.
        """
        if fun is None:
            if key is None:
                self.cv.unbind("<KeyPress>", None)
            else:
                self.cv.unbind("<KeyPress-%s>" % key, None)
        else:
            def eventfun(event):
                fun()
            if key is None:
                self.cv.bind("<KeyPress>", eventfun)
            else:
                self.cv.bind("<KeyPress-%s>" % key, eventfun)

    def _listen(self):
        """Set focus on canvas (in order to collect key-events)
        """
        self.cv.focus_force()

    def _ontimer(self, fun, t):
        """Install a timer, which calls fun after t milliseconds.
        """
        if t == 0:
            self.cv.after_idle(fun)
        else:
            self.cv.after(t, fun)

    def _createimage(self, image):
        """Create and return image item on canvas.
        """
        return self.cv.create_image(0, 0, image=image)

    def _drawimage(self, item, pos, image):
        """Configure image item as to draw image object
        at position (x,y) on canvas)
        """
        x, y = pos
        self.cv.coords(item, (x * self.xscale, -y * self.yscale))
        self.cv.itemconfig(item, image=image)

    def _setbgpic(self, item, image):
        """Configure image item as to draw image object
        at center of canvas. Set item to the first item
        in the displaylist, so it will be drawn below
        any other item ."""
        self.cv.itemconfig(item, image=image)
        self.cv.tag_lower(item)

    def _type(self, item):
        """Return 'line' or 'polygon' or 'image' depending on
        type of item.
        """
        return self.cv.type(item)

    def _pointlist(self, item):
        """returns list of coordinate-pairs of points of item
        Example (for insiders):
        >>> from turtle import *
        >>> getscreen()._pointlist(getturtle().turtle._item)
        [(0.0, 9.9999999999999982), (0.0, -9.9999999999999982),
        (9.9999999999999982, 0.0)]
        >>> """
        cl = self.cv.coords(item)
        pl = [(cl[i], -cl[i+1]) for i in range(0, len(cl), 2)]
        return  pl

    def _setscrollregion(self, srx1, sry1, srx2, sry2):
        self.cv.config(scrollregion=(srx1, sry1, srx2, sry2))

    def _rescale(self, xscalefactor, yscalefactor):
        items = self.cv.find_all()
        for item in items:
            coordinates = list(self.cv.coords(item))
            newcoordlist = []
            while coordinates:
                x, y = coordinates[:2]
                newcoordlist.append(x * xscalefactor)
                newcoordlist.append(y * yscalefactor)
                coordinates = coordinates[2:]
            self.cv.coords(item, *newcoordlist)

    def _resize(self, canvwidth=None, canvheight=None, bg=None):
        """Resize the canvas the turtles are drawing on. Does
        not alter the drawing window.
        """
        # needs amendment
        if not isinstance(self.cv, ScrolledCanvas):
            return self.canvwidth, self.canvheight
        if canvwidth is canvheight is bg is None:
            return self.cv.canvwidth, self.cv.canvheight
        if canvwidth is not None:
            self.canvwidth = canvwidth
        if canvheight is not None:
            self.canvheight = canvheight
        self.cv.reset(canvwidth, canvheight, bg)

    def _window_size(self):
        """ Return the width and height of the turtle window.
        """
        width = self.cv.winfo_width()
        if width <= 1:  # the window isn't managed by a geometry manager
            width = self.cv['width']
        height = self.cv.winfo_height()
        if height <= 1: # the window isn't managed by a geometry manager
            height = self.cv['height']
        return width, height

    def mainloop(self):
        """Starts event loop - calling Tkinter's mainloop function.

        No argument.

        Must be last statement in a turtle graphics program.
        Must NOT be used if a script is run from within IDLE in -n mode
        (No subprocess) - for interactive use of turtle graphics.

        Example (for a TurtleScreen instance named screen):
        >>> screen.mainloop()

        """
        self.cv.tk.mainloop()

    def textinput(self, title, prompt):
        """Pop up a dialog window for input of a string.

        Arguments: title is the title of the dialog window,
        prompt is a text mostly describing what information to input.

        Return the string input
        If the dialog is canceled, return None.

        Example (for a TurtleScreen instance named screen):
        >>> screen.textinput("NIM", "Name of first player:")

        """
        return simpledialog.askstring(title, prompt, parent=self.cv)

    def numinput(self, title, prompt, default=None, minval=None, maxval=None):
        """Pop up a dialog window for input of a number.

        Arguments: title is the title of the dialog window,
        prompt is a text mostly describing what numerical information to input.
        default: default value
        minval: minimum value for input
        maxval: maximum value for input

        The number input must be in the range minval .. maxval if these are
        given. If not, a hint is issued and the dialog remains open for
        correction. Return the number input.
        If the dialog is canceled,  return None.

        Example (for a TurtleScreen instance named screen):
        >>> screen.numinput("Poker", "Your stakes:", 1000, minval=10, maxval=10000)

        """
        return simpledialog.askfloat(title, prompt, initialvalue=default,
                                     minvalue=minval, maxvalue=maxval,
                                     parent=self.cv)


##############################################################################
###                  End of Tkinter - interface                            ###
##############################################################################


class Terminator (Exception):
    """Will be raised in TurtleScreen.update, if _RUNNING becomes False.

    This stops execution of a turtle graphics script.
    Main purpose: use in the Demo-Viewer turtle.Demo.py.
    """
    pass


class TurtleGraphicsError(Exception):
    """Some TurtleGraphics Error
    """


class Shape(object):
    """Data structure modeling shapes.

    attribute _type is one of "polygon", "image", "compound"
    attribute _data is - depending on _type a poygon-tuple,
    an image or a list constructed using the addcomponent method.
    """
    def __init__(self, type_, data=None):
        self._type = type_
        if type_ == "polygon":
            if isinstance(data, list):
                data = tuple(data)
        elif type_ == "image":
            if isinstance(data, str):
                if data.lower().endswith(".gif") and isfile(data):
                    data = TurtleScreen._image(data)
                # else data assumed to be Photoimage
        elif type_ == "compound":
            data = []
        else:
            raise TurtleGraphicsError("There is no shape type %s" % type_)
        self._data = data

    def addcomponent(self, poly, fill, outline=None):
        """Add component to a shape of type compound.

        Arguments: poly is a polygon, i. e. a tuple of number pairs.
        fill is the fillcolor of the component,
        outline is the outline color of the component.

        call (for a Shapeobject namend s):
        --   s.addcomponent(((0,0), (10,10), (-10,10)), "red", "blue")

        Example:
        >>> poly = ((0,0),(10,-5),(0,10),(-10,-5))
        >>> s = Shape("compound")
        >>> s.addcomponent(poly, "red", "blue")
        >>> # .. add more components and then use register_shape()
        """
        if self._type != "compound":
            raise TurtleGraphicsError("Cannot add component to %s Shape"
                                                                % self._type)
        if outline is None:
            outline = fill
        self._data.append([poly, fill, outline])


class Tbuffer(object):
    """Ring buffer used as undobuffer for RawTurtle objects."""
    def __init__(self, bufsize=10):
        self.bufsize = bufsize
        self.buffer = [[None]] * bufsize
        self.ptr = -1
        self.cumulate = False
    def reset(self, bufsize=None):
        if bufsize is None:
            for i in range(self.bufsize):
                self.buffer[i] = [None]
        else:
            self.bufsize = bufsize
            self.buffer = [[None]] * bufsize
        self.ptr = -1
    def push(self, item):
        if self.bufsize > 0:
            if not self.cumulate:
                self.ptr = (self.ptr + 1) % self.bufsize
                self.buffer[self.ptr] = item
            else:
                self.buffer[self.ptr].append(item)
    def pop(self):
        if self.bufsize > 0:
            item = self.buffer[self.ptr]
            if item is None:
                return None
            else:
                self.buffer[self.ptr] = [None]
                self.ptr = (self.ptr - 1) % self.bufsize
                return (item)
    def nr_of_items(self):
        return self.bufsize - self.buffer.count([None])
    def __repr__(self):
        return str(self.buffer) + " " + str(self.ptr)



class TurtleScreen(TurtleScreenBase):
    """Provides screen oriented methods like setbg etc.

    Only relies upon the methods of TurtleScreenBase and NOT
    upon components of the underlying graphics toolkit -
    which is Tkinter in this case.
    """
    _RUNNING = True

    def __init__(self, cv, mode=_CFG["mode"],
                 colormode=_CFG["colormode"], delay=_CFG["delay"]):
        TurtleScreenBase.__init__(self, cv)

        self._shapes = {
                   "arrow" : Shape("polygon", ((-10,0), (10,0), (0,10))),
                  "turtle" : Shape("polygon", ((0,16), (-2,14), (-1,10), (-4,7),
                              (-7,9), (-9,8), (-6,5), (-7,1), (-5,-3), (-8,-6),
                              (-6,-8), (-4,-5), (0,-7), (4,-5), (6,-8), (8,-6),
                              (5,-3), (7,1), (6,5), (9,8), (7,9), (4,7), (1,10),
                              (2,14))),
                  "circle" : Shape("polygon", ((10,0), (9.51,3.09), (8.09,5.88),
                              (5.88,8.09), (3.09,9.51), (0,10), (-3.09,9.51),
                              (-5.88,8.09), (-8.09,5.88), (-9.51,3.09), (-10,0),
                              (-9.51,-3.09), (-8.09,-5.88), (-5.88,-8.09),
                              (-3.09,-9.51), (-0.00,-10.00), (3.09,-9.51),
                              (5.88,-8.09), (8.09,-5.88), (9.51,-3.09))),
                  "square" : Shape("polygon", ((10,-10), (10,10), (-10,10),
                              (-10,-10))),
                "triangle" : Shape("polygon", ((10,-5.77), (0,11.55),
                              (-10,-5.77))),
                  "classic": Shape("polygon", ((0,0),(-5,-9),(0,-7),(5,-9))),
                   "blank" : Shape("image", self._blankimage())
                  }

        self._bgpics = {"nopic" : ""}

        self._mode = mode
        self._delayvalue = delay
        self._colormode = _CFG["colormode"]
        self._keys = []
        self.clear()
        if sys.platform == 'darwin':
            # Force Turtle window to the front on OS X. This is needed because
            # the Turtle window will show behind the Terminal window when you
            # start the demo from the command line.
            rootwindow = cv.winfo_toplevel()
            rootwindow.call('wm', 'attributes', '.', '-topmost', '1')
            rootwindow.call('wm', 'attributes', '.', '-topmost', '0')

    def clear(self):
        """Delete all drawings and all turtles from the TurtleScreen.

        No argument.

        Reset empty TurtleScreen to its initial state: white background,
        no backgroundimage, no eventbindings and tracing on.

        Example (for a TurtleScreen instance named screen):
        >>> screen.clear()

        Note: this method is not available as function.
        """
        self._delayvalue = _CFG["delay"]
        self._colormode = _CFG["colormode"]
        self._delete("all")
        self._bgpic = self._createimage("")
        self._bgpicname = "nopic"
        self._tracing = 1
        self._updatecounter = 0
        self._turtles = []
        self.bgcolor("white")
        for btn in 1, 2, 3:
            self.onclick(None, btn)
        self.onkeypress(None)
        for key in self._keys[:]:
            self.onkey(None, key)
            self.onkeypress(None, key)
        Turtle._pen = None

    def mode(self, mode=None):
        """Set turtle-mode ('standard', 'logo' or 'world') and perform reset.

        Optional argument:
        mode -- one of the strings 'standard', 'logo' or 'world'

        Mode 'standard' is compatible with turtle.py.
        Mode 'logo' is compatible with most Logo-Turtle-Graphics.
        Mode 'world' uses userdefined 'worldcoordinates'. *Attention*: in
        this mode angles appear distorted if x/y unit-ratio doesn't equal 1.
        If mode is not given, return the current mode.

             Mode      Initial turtle heading     positive angles
         ------------|-------------------------|-------------------
          'standard'    to the right (east)       counterclockwise
            'logo'        upward    (north)         clockwise

        Examples:
        >>> mode('logo')   # resets turtle heading to north
        >>> mode()
        'logo'
        """
        if mode is None:
            return self._mode
        mode = mode.lower()
        if mode not in ["standard", "logo", "world"]:
            raise TurtleGraphicsError("No turtle-graphics-mode %s" % mode)
        self._mode = mode
        if mode in ["standard", "logo"]:
            self._setscrollregion(-self.canvwidth//2, -self.canvheight//2,
                                       self.canvwidth//2, self.canvheight//2)
            self.xscale = self.yscale = 1.0
        self.reset()

    def setworldcoordinates(self, llx, lly, urx, ury):
        """Set up a user defined coordinate-system.

        Arguments:
        llx -- a number, x-coordinate of lower left corner of canvas
        lly -- a number, y-coordinate of lower left corner of canvas
        urx -- a number, x-coordinate of upper right corner of canvas
        ury -- a number, y-coordinate of upper right corner of canvas

        Set up user coodinat-system and switch to mode 'world' if necessary.
        This performs a screen.reset. If mode 'world' is already active,
        all drawings are redrawn according to the new coordinates.

        But ATTENTION: in user-defined coordinatesystems angles may appear
        distorted. (see Screen.mode())

        Example (for a TurtleScreen instance named screen):
        >>> screen.setworldcoordinates(-10,-0.5,50,1.5)
        >>> for _ in range(36):
        ...     left(10)
        ...     forward(0.5)
        """
        if self.mode() != "world":
            self.mode("world")
        xspan = float(urx - llx)
        yspan = float(ury - lly)
        wx, wy = self._window_size()
        self.screensize(wx-20, wy-20)
        oldxscale, oldyscale = self.xscale, self.yscale
        self.xscale = self.canvwidth / xspan
        self.yscale = self.canvheight / yspan
        srx1 = llx * self.xscale
        sry1 = -ury * self.yscale
        srx2 = self.canvwidth + srx1
        sry2 = self.canvheight + sry1
        self._setscrollregion(srx1, sry1, srx2, sry2)
        self._rescale(self.xscale/oldxscale, self.yscale/oldyscale)
        self.update()

    def register_shape(self, name, shape=None):
        """Adds a turtle shape to TurtleScreen's shapelist.

        Arguments:
        (1) name is the name of a gif-file and shape is None.
            Installs the corresponding image shape.
            !! Image-shapes DO NOT rotate when turning the turtle,
            !! so they do not display the heading of the turtle!
        (2) name is an arbitrary string and shape is a tuple
            of pairs of coordinates. Installs the corresponding
            polygon shape
        (3) name is an arbitrary string and shape is a
            (compound) Shape object. Installs the corresponding
            compound shape.
        To use a shape, you have to issue the command shape(shapename).

        call: register_shape("turtle.gif")
        --or: register_shape("tri", ((0,0), (10,10), (-10,10)))

        Example (for a TurtleScreen instance named screen):
        >>> screen.register_shape("triangle", ((5,-3),(0,5),(-5,-3)))

        """
        if shape is None:
            # image
            if name.lower().endswith(".gif"):
                shape = Shape("image", self._image(name))
            else:
                raise TurtleGraphicsError("Bad arguments for register_shape.\n"
                                          + "Use  help(register_shape)" )
        elif isinstance(shape, tuple):
            shape = Shape("polygon", shape)
        ## else shape assumed to be Shape-instance
        self._shapes[name] = shape

    def _colorstr(self, color):
        """Return color string corresponding to args.

        Argument may be a string or a tuple of three
        numbers corresponding to actual colormode,
        i.e. in the range 0<=n<=colormode.

        If the argument doesn't represent a color,
        an error is raised.
        """
        if len(color) == 1:
            color = color[0]
        if isinstance(color, str):
            if self._iscolorstring(color) or color == "":
                return color
            else:
                raise TurtleGraphicsError("bad color string: %s" % str(color))
        try:
            r, g, b = color
        except (TypeError, ValueError):
            raise TurtleGraphicsError("bad color arguments: %s" % str(color))
        if self._colormode == 1.0:
            r, g, b = [round(255.0*x) for x in (r, g, b)]
        if not ((0 <= r <= 255) and (0 <= g <= 255) and (0 <= b <= 255)):
            raise TurtleGraphicsError("bad color sequence: %s" % str(color))
        return "#%02x%02x%02x" % (r, g, b)

    def _color(self, cstr):
        if not cstr.startswith("#"):
            return cstr
        if len(cstr) == 7:
            cl = [int(cstr[i:i+2], 16) for i in (1, 3, 5)]
        elif len(cstr) == 4:
            cl = [16*int(cstr[h], 16) for h in cstr[1:]]
        else:
            raise TurtleGraphicsError("bad colorstring: %s" % cstr)
        return tuple(c * self._colormode/255 for c in cl)

    def colormode(self, cmode=None):
        """Return the colormode or set it to 1.0 or 255.

        Optional argument:
        cmode -- one of the values 1.0 or 255

        r, g, b values of colortriples have to be in range 0..cmode.

        Example (for a TurtleScreen instance named screen):
        >>> screen.colormode()
        1.0
        >>> screen.colormode(255)
        >>> pencolor(240,160,80)
        """
        if cmode is None:
            return self._colormode
        if cmode == 1.0:
            self._colormode = float(cmode)
        elif cmode == 255:
            self._colormode = int(cmode)

    def reset(self):
        """Reset all Turtles on the Screen to their initial state.

        No argument.

        Example (for a TurtleScreen instance named screen):
        >>> screen.reset()
        """
        for turtle in self._turtles:
            turtle._setmode(self._mode)
            turtle.reset()

    def turtles(self):
        """Return the list of turtles on the screen.

        Example (for a TurtleScreen instance named screen):
        >>> screen.turtles()
        [<turtle.Turtle object at 0x00E11FB0>]
        """
        return self._turtles

    def bgcolor(self, *args):
        """Set or return backgroundcolor of the TurtleScreen.

        Arguments (if given): a color string or three numbers
        in the range 0..colormode or a 3-tuple of such numbers.

        Example (for a TurtleScreen instance named screen):
        >>> screen.bgcolor("orange")
        >>> screen.bgcolor()
        'orange'
        >>> screen.bgcolor(0.5,0,0.5)
        >>> screen.bgcolor()
        '#800080'
        """
        if args:
            color = self._colorstr(args)
        else:
            color = None
        color = self._bgcolor(color)
        if color is not None:
            color = self._color(color)
        return color

    def tracer(self, n=None, delay=None):
        """Turns turtle animation on/off and set delay for update drawings.

        Optional arguments:
        n -- nonnegative  integer
        delay -- nonnegative  integer

        If n is given, only each n-th regular screen update is really performed.
        (Can be used to accelerate the drawing of complex graphics.)
        Second arguments sets delay value (see RawTurtle.delay())

        Example (for a TurtleScreen instance named screen):
        >>> screen.tracer(8, 25)
        >>> dist = 2
        >>> for i in range(200):
        ...     fd(dist)
        ...     rt(90)
        ...     dist += 2
        """
        if n is None:
            return self._tracing
        self._tracing = int(n)
        self._updatecounter = 0
        if delay is not None:
            self._delayvalue = int(delay)
        if self._tracing:
            self.update()

    def delay(self, delay=None):
        """ Return or set the drawing delay in milliseconds.

        Optional argument:
        delay -- positive integer

        Example (for a TurtleScreen instance named screen):
        >>> screen.delay(15)
        >>> screen.delay()
        15
        """
        if delay is None:
            return self._delayvalue
        self._delayvalue = int(delay)

    def _incrementudc(self):
        """Increment update counter."""
        if not TurtleScreen._RUNNING:
            TurtleScreen._RUNNING = True
            raise Terminator
        if self._tracing > 0:
            self._updatecounter += 1
            self._updatecounter %= self._tracing

    def update(self):
        """Perform a TurtleScreen update.
        """
        tracing = self._tracing
        self._tracing = True
        for t in self.turtles():
            t._update_data()
            t._drawturtle()
        self._tracing = tracing
        self._update()

    def window_width(self):
        """ Return the width of the turtle window.

        Example (for a TurtleScreen instance named screen):
        >>> screen.window_width()
        640
        """
        return self._window_size()[0]

    def window_height(self):
        """ Return the height of the turtle window.

        Example (for a TurtleScreen instance named screen):
        >>> screen.window_height()
        480
        """
        return self._window_size()[1]

    def getcanvas(self):
        """Return the Canvas of this TurtleScreen.

        No argument.

        Example (for a Screen instance named screen):
        >>> cv = screen.getcanvas()
        >>> cv
        <turtle.ScrolledCanvas instance at 0x010742D8>
        """
        return self.cv

    def getshapes(self):
        """Return a list of names of all currently available turtle shapes.

        No argument.

        Example (for a TurtleScreen instance named screen):
        >>> screen.getshapes()
        ['arrow', 'blank', 'circle', ... , 'turtle']
        """
        return sorted(self._shapes.keys())

    def onclick(self, fun, btn=1, add=None):
        """Bind fun to mouse-click event on canvas.

        Arguments:
        fun -- a function with two arguments, the coordinates of the
               clicked point on the canvas.
        btn -- the number of the mouse-button, defaults to 1

        Example (for a TurtleScreen instance named screen)

        >>> screen.onclick(goto)
        >>> # Subsequently clicking into the TurtleScreen will
        >>> # make the turtle move to the clicked point.
        >>> screen.onclick(None)
        """
        self._onscreenclick(fun, btn, add)

    def onkey(self, fun, key):
        """Bind fun to key-release event of key.

        Arguments:
        fun -- a function with no arguments
        key -- a string: key (e.g. "a") or key-symbol (e.g. "space")

        In order to be able to register key-events, TurtleScreen
        must have focus. (See method listen.)

        Example (for a TurtleScreen instance named screen):

        >>> def f():
        ...     fd(50)
        ...     lt(60)
        ...
        >>> screen.onkey(f, "Up")
        >>> screen.listen()

        Subsequently the turtle can be moved by repeatedly pressing
        the up-arrow key, consequently drawing a hexagon

        """
        if fun is None:
            if key in self._keys:
                self._keys.remove(key)
        elif key not in self._keys:
            self._keys.append(key)
        self._onkeyrelease(fun, key)

    def onkeypress(self, fun, key=None):
        """Bind fun to key-press event of key if key is given,
        or to any key-press-event if no key is given.

        Arguments:
        fun -- a function with no arguments
        key -- a string: key (e.g. "a") or key-symbol (e.g. "space")

        In order to be able to register key-events, TurtleScreen
        must have focus. (See method listen.)

        Example (for a TurtleScreen instance named screen
        and a Turtle instance named turtle):

        >>> def f():
        ...     fd(50)
        ...     lt(60)
        ...
        >>> screen.onkeypress(f, "Up")
        >>> screen.listen()

        Subsequently the turtle can be moved by repeatedly pressing
        the up-arrow key, or by keeping pressed the up-arrow key.
        consequently drawing a hexagon.
        """
        if fun is None:
            if key in self._keys:
                self._keys.remove(key)
        elif key is not None and key not in self._keys:
            self._keys.append(key)
        self._onkeypress(fun, key)

    def listen(self, xdummy=None, ydummy=None):
        """Set focus on TurtleScreen (in order to collect key-events)

        No arguments.
        Dummy arguments are provided in order
        to be able to pass listen to the onclick method.

        Example (for a TurtleScreen instance named screen):
        >>> screen.listen()
        """
        self._listen()

    def ontimer(self, fun, t=0):
        """Install a timer, which calls fun after t milliseconds.

        Arguments:
        fun -- a function with no arguments.
        t -- a number >= 0

        Example (for a TurtleScreen instance named screen):

        >>> running = True
        >>> def f():
        ...     if running:
        ...             fd(50)
        ...             lt(60)
        ...             screen.ontimer(f, 250)
        ...
        >>> f()   # makes the turtle marching around
        >>> running = False
        """
        self._ontimer(fun, t)

    def bgpic(self, picname=None):
        """Set background image or return name of current backgroundimage.

        Optional argument:
        picname -- a string, name of a gif-file or "nopic".

        If picname is a filename, set the corresponding image as background.
        If picname is "nopic", delete backgroundimage, if present.
        If picname is None, return the filename of the current backgroundimage.

        Example (for a TurtleScreen instance named screen):
        >>> screen.bgpic()
        'nopic'
        >>> screen.bgpic("landscape.gif")
        >>> screen.bgpic()
        'landscape.gif'
        """
        if picname is None:
            return self._bgpicname
        if picname not in self._bgpics:
            self._bgpics[picname] = self._image(picname)
        self._setbgpic(self._bgpic, self._bgpics[picname])
        self._bgpicname = picname

    def screensize(self, canvwidth=None, canvheight=None, bg=None):
        """Resize the canvas the turtles are drawing on.

        Optional arguments:
        canvwidth -- positive integer, new width of canvas in pixels
        canvheight --  positive integer, new height of canvas in pixels
        bg -- colorstring or color-tuple, new backgroundcolor
        If no arguments are given, return current (canvaswidth, canvasheight)

        Do not alter the drawing window. To observe hidden parts of
        the canvas use the scrollbars. (Can make visible those parts
        of a drawing, which were outside the canvas before!)

        Example (for a Turtle instance named turtle):
        >>> turtle.screensize(2000,1500)
        >>> # e.g. to search for an erroneously escaped turtle ;-)
        """
        return self._resize(canvwidth, canvheight, bg)

    onscreenclick = onclick
    resetscreen = reset
    clearscreen = clear
    addshape = register_shape
    onkeyrelease = onkey

class TNavigator(object):
    """Navigation part of the RawTurtle.
    Implements methods for turtle movement.
    """
    START_ORIENTATION = {
        "standard": Vec2D(1.0, 0.0),
        "world"   : Vec2D(1.0, 0.0),
        "logo"    : Vec2D(0.0, 1.0)  }
    DEFAULT_MODE = "standard"
    DEFAULT_ANGLEOFFSET = 0
    DEFAULT_ANGLEORIENT = 1

    def __init__(self, mode=DEFAULT_MODE):
        self._angleOffset = self.DEFAULT_ANGLEOFFSET
        self._angleOrient = self.DEFAULT_ANGLEORIENT
        self._mode = mode
        self.undobuffer = None
        self.degrees()
        self._mode = None
        self._setmode(mode)
        TNavigator.reset(self)

    def reset(self):
        """reset turtle to its initial values

        Will be overwritten by parent class
        """
        self._position = Vec2D(0.0, 0.0)
        self._orient =  TNavigator.START_ORIENTATION[self._mode]

    def _setmode(self, mode=None):
        """Set turtle-mode to 'standard', 'world' or 'logo'.
        """
        if mode is None:
            return self._mode
        if mode not in ["standard", "logo", "world"]:
            return
        self._mode = mode
        if mode in ["standard", "world"]:
            self._angleOffset = 0
            self._angleOrient = 1
        else: # mode == "logo":
            self._angleOffset = self._fullcircle/4.
            self._angleOrient = -1

    def _setDegreesPerAU(self, fullcircle):
        """Helper function for degrees() and radians()"""
        self._fullcircle = fullcircle
        self._degreesPerAU = 360/fullcircle
        if self._mode == "standard":
            self._angleOffset = 0
        else:
            self._angleOffset = fullcircle/4.

    def degrees(self, fullcircle=360.0):
        """ Set angle measurement units to degrees.

        Optional argument:
        fullcircle -  a number

        Set angle measurement units, i. e. set number
        of 'degrees' for a full circle. Default value is
        360 degrees.

        Example (for a Turtle instance named turtle):
        >>> turtle.left(90)
        >>> turtle.heading()
        90

        Change angle measurement unit to grad (also known as gon,
        grade, or gradian and equals 1/100-th of the right angle.)
        >>> turtle.degrees(400.0)
        >>> turtle.heading()
        100

        """
        self._setDegreesPerAU(fullcircle)

    def radians(self):
        """ Set the angle measurement units to radians.

        No arguments.

        Example (for a Turtle instance named turtle):
        >>> turtle.heading()
        90
        >>> turtle.radians()
        >>> turtle.heading()
        1.5707963267948966
        """
        self._setDegreesPerAU(math.tau)

    def _go(self, distance):
        """move turtle forward by specified distance"""
        ende = self._position + self._orient * distance
        self._goto(ende)

    def _rotate(self, angle):
        """Turn turtle counterclockwise by specified angle if angle > 0."""
        angle *= self._degreesPerAU
        self._orient = self._orient.rotate(angle)

    def _goto(self, end):
        """move turtle to position end."""
        self._position = end

    def forward(self, distance):
        """Move the turtle forward by the specified distance.

        Aliases: forward | fd

        Argument:
        distance -- a number (integer or float)

        Move the turtle forward by the specified distance, in the direction
        the turtle is headed.

        Example (for a Turtle instance named turtle):
        >>> turtle.position()
        (0.00, 0.00)
        >>> turtle.forward(25)
        >>> turtle.position()
        (25.00,0.00)
        >>> turtle.forward(-75)
        >>> turtle.position()
        (-50.00,0.00)
        """
        self._go(distance)

    def back(self, distance):
        """Move the turtle backward by distance.

        Aliases: back | backward | bk

        Argument:
        distance -- a number

        Move the turtle backward by distance, opposite to the direction the
        turtle is headed. Do not change the turtle's heading.

        Example (for a Turtle instance named turtle):
        >>> turtle.position()
        (0.00, 0.00)
        >>> turtle.backward(30)
        >>> turtle.position()
        (-30.00, 0.00)
        """
        self._go(-distance)

    def right(self, angle):
        """Turn turtle right by angle units.

        Aliases: right | rt

        Argument:
        angle -- a number (integer or float)

        Turn turtle right by angle units. (Units are by default degrees,
        but can be set via the degrees() and radians() functions.)
        Angle orientation depends on mode. (See this.)

        Example (for a Turtle instance named turtle):
        >>> turtle.heading()
        22.0
        >>> turtle.right(45)
        >>> turtle.heading()
        337.0
        """
        self._rotate(-angle)

    def left(self, angle):
        """Turn turtle left by angle units.

        Aliases: left | lt

        Argument:
        angle -- a number (integer or float)

        Turn turtle left by angle units. (Units are by default degrees,
        but can be set via the degrees() and radians() functions.)
        Angle orientation depends on mode. (See this.)

        Example (for a Turtle instance named turtle):
        >>> turtle.heading()
        22.0
        >>> turtle.left(45)
        >>> turtle.heading()
        67.0
        """
        self._rotate(angle)

    def pos(self):
        """Return the turtle's current location (x,y), as a Vec2D-vector.

        Aliases: pos | position

        No arguments.

        Example (for a Turtle instance named turtle):
        >>> turtle.pos()
        (0.00, 240.00)
        """
        return self._position

    def xcor(self):
        """ Return the turtle's x coordinate.

        No arguments.

        Example (for a Turtle instance named turtle):
        >>> reset()
        >>> turtle.left(60)
        >>> turtle.forward(100)
        >>> print turtle.xcor()
        50.0
        """
        return self._position[0]

    def ycor(self):
        """ Return the turtle's y coordinate
        ---
        No arguments.

        Example (for a Turtle instance named turtle):
        >>> reset()
        >>> turtle.left(60)
        >>> turtle.forward(100)
        >>> print turtle.ycor()
        86.6025403784
        """
        return self._position[1]


    def goto(self, x, y=None):
        """Move turtle to an absolute position.

        Aliases: setpos | setposition | goto:

        Arguments:
        x -- a number      or     a pair/vector of numbers
        y -- a number             None

        call: goto(x, y)         # two coordinates
        --or: goto((x, y))       # a pair (tuple) of coordinates
        --or: goto(vec)          # e.g. as returned by pos()

        Move turtle to an absolute position. If the pen is down,
        a line will be drawn. The turtle's orientation does not change.

        Example (for a Turtle instance named turtle):
        >>> tp = turtle.pos()
        >>> tp
        (0.00, 0.00)
        >>> turtle.setpos(60,30)
        >>> turtle.pos()
        (60.00,30.00)
        >>> turtle.setpos((20,80))
        >>> turtle.pos()
        (20.00,80.00)
        >>> turtle.setpos(tp)
        >>> turtle.pos()
        (0.00,0.00)
        """
        if y is None:
            self._goto(Vec2D(*x))
        else:
            self._goto(Vec2D(x, y))

    def home(self):
        """Move turtle to the origin - coordinates (0,0).

        No arguments.

        Move turtle to the origin - coordinates (0,0) and set its
        heading to its start-orientation (which depends on mode).

        Example (for a Turtle instance named turtle):
        >>> turtle.home()
        """
        self.goto(0, 0)
        self.setheading(0)

    def setx(self, x):
        """Set the turtle's first coordinate to x

        Argument:
        x -- a number (integer or float)

        Set the turtle's first coordinate to x, leave second coordinate
        unchanged.

        Example (for a Turtle instance named turtle):
        >>> turtle.position()
        (0.00, 240.00)
        >>> turtle.setx(10)
        >>> turtle.position()
        (10.00, 240.00)
        """
        self._goto(Vec2D(x, self._position[1]))

    def sety(self, y):
        """Set the turtle's second coordinate to y

        Argument:
        y -- a number (integer or float)

        Set the turtle's first coordinate to x, second coordinate remains
        unchanged.

        Example (for a Turtle instance named turtle):
        >>> turtle.position()
        (0.00, 40.00)
        >>> turtle.sety(-10)
        >>> turtle.position()
        (0.00, -10.00)
        """
        self._goto(Vec2D(self._position[0], y))

    def distance(self, x, y=None):
        """Return the distance from the turtle to (x,y) in turtle step units.

        Arguments:
        x -- a number   or  a pair/vector of numbers   or   a turtle instance
        y -- a number       None                            None

        call: distance(x, y)         # two coordinates
        --or: distance((x, y))       # a pair (tuple) of coordinates
        --or: distance(vec)          # e.g. as returned by pos()
        --or: distance(mypen)        # where mypen is another turtle

        Example (for a Turtle instance named turtle):
        >>> turtle.pos()
        (0.00, 0.00)
        >>> turtle.distance(30,40)
        50.0
        >>> pen = Turtle()
        >>> pen.forward(77)
        >>> turtle.distance(pen)
        77.0
        """
        if y is not None:
            pos = Vec2D(x, y)
        if isinstance(x, Vec2D):
            pos = x
        elif isinstance(x, tuple):
            pos = Vec2D(*x)
        elif isinstance(x, TNavigator):
            pos = x._position
        return abs(pos - self._position)

    def towards(self, x, y=None):
        """Return the angle of the line from the turtle's position to (x, y).

        Arguments:
        x -- a number   or  a pair/vector of numbers   or   a turtle instance
        y -- a number       None                            None

        call: distance(x, y)         # two coordinates
        --or: distance((x, y))       # a pair (tuple) of coordinates
        --or: distance(vec)          # e.g. as returned by pos()
        --or: distance(mypen)        # where mypen is another turtle

        Return the angle, between the line from turtle-position to position
        specified by x, y and the turtle's start orientation. (Depends on
        modes - "standard" or "logo")

        Example (for a Turtle instance named turtle):
        >>> turtle.pos()
        (10.00, 10.00)
        >>> turtle.towards(0,0)
        225.0
        """
        if y is not None:
            pos = Vec2D(x, y)
        if isinstance(x, Vec2D):
            pos = x
        elif isinstance(x, tuple):
            pos = Vec2D(*x)
        elif isinstance(x, TNavigator):
            pos = x._position
        x, y = pos - self._position
        result = round(math.degrees(math.atan2(y, x)), 10) % 360.0
        result /= self._degreesPerAU
        return (self._angleOffset + self._angleOrient*result) % self._fullcircle

    def heading(self):
        """ Return the turtle's current heading.

        No arguments.

        Example (for a Turtle instance named turtle):
        >>> turtle.left(67)
        >>> turtle.heading()
        67.0
        """
        x, y = self._orient
        result = round(math.degrees(math.atan2(y, x)), 10) % 360.0
        result /= self._degreesPerAU
        return (self._angleOffset + self._angleOrient*result) % self._fullcircle

    def setheading(self, to_angle):
        """Set the orientation of the turtle to to_angle.

        Aliases:  setheading | seth

        Argument:
        to_angle -- a number (integer or float)

        Set the orientation of the turtle to to_angle.
        Here are some common directions in degrees:

         standard - mode:          logo-mode:
        -------------------|--------------------
           0 - east                0 - north
          90 - north              90 - east
         180 - west              180 - south
         270 - south             270 - west

        Example (for a Turtle instance named turtle):
        >>> turtle.setheading(90)
        >>> turtle.heading()
        90
        """
        angle = (to_angle - self.heading())*self._angleOrient
        full = self._fullcircle
        angle = (angle+full/2.)%full - full/2.
        self._rotate(angle)

    def circle(self, radius, extent = None, steps = None):
        """ Draw a circle with given radius.

        Arguments:
        radius -- a number
        extent (optional) -- a number
        steps (optional) -- an integer

        Draw a circle with given radius. The center is radius units left
        of the turtle; extent - an angle - determines which part of the
        circle is drawn. If extent is not given, draw the entire circle.
        If extent is not a full circle, one endpoint of the arc is the
        current pen position. Draw the arc in counterclockwise direction
        if radius is positive, otherwise in clockwise direction. Finally
        the direction of the turtle is changed by the amount of extent.

        As the circle is approximated by an inscribed regular polygon,
        steps determines the number of steps to use. If not given,
        it will be calculated automatically. Maybe used to draw regular
        polygons.

        call: circle(radius)                  # full circle
        --or: circle(radius, extent)          # arc
        --or: circle(radius, extent, steps)
        --or: circle(radius, steps=6)         # 6-sided polygon

        Example (for a Turtle instance named turtle):
        >>> turtle.circle(50)
        >>> turtle.circle(120, 180)  # semicircle
        """
        if self.undobuffer:
            self.undobuffer.push(["seq"])
            self.undobuffer.cumulate = True
        speed = self.speed()
        if extent is None:
            extent = self._fullcircle
        if steps is None:
            frac = abs(extent)/self._fullcircle
            steps = 1+int(min(11+abs(radius)/6.0, 59.0)*frac)
        w = 1.0 * extent / steps
        w2 = 0.5 * w
        l = 2.0 * radius * math.sin(math.radians(w2)*self._degreesPerAU)
        if radius < 0:
            l, w, w2 = -l, -w, -w2
        tr = self._tracer()
        dl = self._delay()
        if speed == 0:
            self._tracer(0, 0)
        else:
            self.speed(0)
        self._rotate(w2)
        for i in range(steps):
            self.speed(speed)
            self._go(l)
            self.speed(0)
            self._rotate(w)
        self._rotate(-w2)
        if speed == 0:
            self._tracer(tr, dl)
        self.speed(speed)
        if self.undobuffer:
            self.undobuffer.cumulate = False

## three dummy methods to be implemented by child class:

    def speed(self, s=0):
        """dummy method - to be overwritten by child class"""
    def _tracer(self, a=None, b=None):
        """dummy method - to be overwritten by child class"""
    def _delay(self, n=None):
        """dummy method - to be overwritten by child class"""

    fd = forward
    bk = back
    backward = back
    rt = right
    lt = left
    position = pos
    setpos = goto
    setposition = goto
    seth = setheading


class TPen(object):
    """Drawing part of the RawTurtle.
    Implements drawing properties.
    """
    def __init__(self, resizemode=_CFG["resizemode"]):
        self._resizemode = resizemode # or "user" or "noresize"
        self.undobuffer = None
        TPen._reset(self)

    def _reset(self, pencolor=_CFG["pencolor"],
                     fillcolor=_CFG["fillcolor"]):
        self._pensize = 1
        self._shown = True
        self._pencolor = pencolor
        self._fillcolor = fillcolor
        self._drawing = True
        self._speed = 3
        self._stretchfactor = (1., 1.)
        self._shearfactor = 0.
        self._tilt = 0.
        self._shapetrafo = (1., 0., 0., 1.)
        self._outlinewidth = 1

    def resizemode(self, rmode=None):
        """Set resizemode to one of the values: "auto", "user", "noresize".

        (Optional) Argument:
        rmode -- one of the strings "auto", "user", "noresize"

        Different resizemodes have the following effects:
          - "auto" adapts the appearance of the turtle
                   corresponding to the value of pensize.
          - "user" adapts the appearance of the turtle according to the
                   values of stretchfactor and outlinewidth (outline),
                   which are set by shapesize()
          - "noresize" no adaption of the turtle's appearance takes place.
        If no argument is given, return current resizemode.
        resizemode("user") is called by a call of shapesize with arguments.


        Examples (for a Turtle instance named turtle):
        >>> turtle.resizemode("noresize")
        >>> turtle.resizemode()
        'noresize'
        """
        if rmode is None:
            return self._resizemode
        rmode = rmode.lower()
        if rmode in ["auto", "user", "noresize"]:
            self.pen(resizemode=rmode)

    def pensize(self, width=None):
        """Set or return the line thickness.

        Aliases:  pensize | width

        Argument:
        width -- positive number

        Set the line thickness to width or return it. If resizemode is set
        to "auto" and turtleshape is a polygon, that polygon is drawn with
        the same line thickness. If no argument is given, current pensize
        is returned.

        Example (for a Turtle instance named turtle):
        >>> turtle.pensize()
        1
        >>> turtle.pensize(10)   # from here on lines of width 10 are drawn
        """
        if width is None:
            return self._pensize
        self.pen(pensize=width)


    def penup(self):
        """Pull the pen up -- no drawing when moving.

        Aliases: penup | pu | up

        No argument

        Example (for a Turtle instance named turtle):
        >>> turtle.penup()
        """
        if not self._drawing:
            return
        self.pen(pendown=False)

    def pendown(self):
        """Pull the pen down -- drawing when moving.

        Aliases: pendown | pd | down

        No argument.

        Example (for a Turtle instance named turtle):
        >>> turtle.pendown()
        """
        if self._drawing:
            return
        self.pen(pendown=True)

    def isdown(self):
        """Return True if pen is down, False if it's up.

        No argument.

        Example (for a Turtle instance named turtle):
        >>> turtle.penup()
        >>> turtle.isdown()
        False
        >>> turtle.pendown()
        >>> turtle.isdown()
        True
        """
        return self._drawing

    def speed(self, speed=None):
        """ Return or set the turtle's speed.

        Optional argument:
        speed -- an integer in the range 0..10 or a speedstring (see below)

        Set the turtle's speed to an integer value in the range 0 .. 10.
        If no argument is given: return current speed.

        If input is a number greater than 10 or smaller than 0.5,
        speed is set to 0.
        Speedstrings  are mapped to speedvalues in the following way:
            'fastest' :  0
            'fast'    :  10
            'normal'  :  6
            'slow'    :  3
            'slowest' :  1
        speeds from 1 to 10 enforce increasingly faster animation of
        line drawing and turtle turning.

        Attention:
        speed = 0 : *no* animation takes place. forward/back makes turtle jump
        and likewise left/right make the turtle turn instantly.

        Example (for a Turtle instance named turtle):
        >>> turtle.speed(3)
        """
        speeds = {'fastest':0, 'fast':10, 'normal':6, 'slow':3, 'slowest':1 }
        if speed is None:
            return self._speed
        if speed in speeds:
            speed = speeds[speed]
        elif 0.5 < speed < 10.5:
            speed = int(round(speed))
        else:
            speed = 0
        self.pen(speed=speed)

    def color(self, *args):
        """Return or set the pencolor and fillcolor.

        Arguments:
        Several input formats are allowed.
        They use 0, 1, 2, or 3 arguments as follows:

        color()
            Return the current pencolor and the current fillcolor
            as a pair of color specification strings as are returned
            by pencolor and fillcolor.
        color(colorstring), color((r,g,b)), color(r,g,b)
            inputs as in pencolor, set both, fillcolor and pencolor,
            to the given value.
        color(colorstring1, colorstring2),
        color((r1,g1,b1), (r2,g2,b2))
            equivalent to pencolor(colorstring1) and fillcolor(colorstring2)
            and analogously, if the other input format is used.

        If turtleshape is a polygon, outline and interior of that polygon
        is drawn with the newly set colors.
        For more info see: pencolor, fillcolor

        Example (for a Turtle instance named turtle):
        >>> turtle.color('red', 'green')
        >>> turtle.color()
        ('red', 'green')
        >>> colormode(255)
        >>> color((40, 80, 120), (160, 200, 240))
        >>> color()
        ('#285078', '#a0c8f0')
        """
        if args:
            l = len(args)
            if l == 1:
                pcolor = fcolor = args[0]
            elif l == 2:
                pcolor, fcolor = args
            elif l == 3:
                pcolor = fcolor = args
            pcolor = self._colorstr(pcolor)
            fcolor = self._colorstr(fcolor)
            self.pen(pencolor=pcolor, fillcolor=fcolor)
        else:
            return self._color(self._pencolor), self._color(self._fillcolor)

    def pencolor(self, *args):
        """ Return or set the pencolor.

        Arguments:
        Four input formats are allowed:
          - pencolor()
            Return the current pencolor as color specification string,
            possibly in hex-number format (see example).
            May be used as input to another color/pencolor/fillcolor call.
          - pencolor(colorstring)
            s is a Tk color specification string, such as "red" or "yellow"
          - pencolor((r, g, b))
            *a tuple* of r, g, and b, which represent, an RGB color,
            and each of r, g, and b are in the range 0..colormode,
            where colormode is either 1.0 or 255
          - pencolor(r, g, b)
            r, g, and b represent an RGB color, and each of r, g, and b
            are in the range 0..colormode

        If turtleshape is a polygon, the outline of that polygon is drawn
        with the newly set pencolor.

        Example (for a Turtle instance named turtle):
        >>> turtle.pencolor('brown')
        >>> tup = (0.2, 0.8, 0.55)
        >>> turtle.pencolor(tup)
        >>> turtle.pencolor()
        '#33cc8c'
        """
        if args:
            color = self._colorstr(args)
            if color == self._pencolor:
                return
            self.pen(pencolor=color)
        else:
            return self._color(self._pencolor)

    def fillcolor(self, *args):
        """ Return or set the fillcolor.

        Arguments:
        Four input formats are allowed:
          - fillcolor()
            Return the current fillcolor as color specification string,
            possibly in hex-number format (see example).
            May be used as input to another color/pencolor/fillcolor call.
          - fillcolor(colorstring)
            s is a Tk color specification string, such as "red" or "yellow"
          - fillcolor((r, g, b))
            *a tuple* of r, g, and b, which represent, an RGB color,
            and each of r, g, and b are in the range 0..colormode,
            where colormode is either 1.0 or 255
          - fillcolor(r, g, b)
            r, g, and b represent an RGB color, and each of r, g, and b
            are in the range 0..colormode

        If turtleshape is a polygon, the interior of that polygon is drawn
        with the newly set fillcolor.

        Example (for a Turtle instance named turtle):
        >>> turtle.fillcolor('violet')
        >>> col = turtle.pencolor()
        >>> turtle.fillcolor(col)
        >>> turtle.fillcolor(0, .5, 0)
        """
        if args:
            color = self._colorstr(args)
            if color == self._fillcolor:
                return
            self.pen(fillcolor=color)
        else:
            return self._color(self._fillcolor)

    def showturtle(self):
        """Makes the turtle visible.

        Aliases: showturtle | st

        No argument.

        Example (for a Turtle instance named turtle):
        >>> turtle.hideturtle()
        >>> turtle.showturtle()
        """
        self.pen(shown=True)

    def hideturtle(self):
        """Makes the turtle invisible.

        Aliases: hideturtle | ht

        No argument.

        It's a good idea to do this while you're in the
        middle of a complicated drawing, because hiding
        the turtle speeds up the drawing observably.

        Example (for a Turtle instance named turtle):
        >>> turtle.hideturtle()
        """
        self.pen(shown=False)

    def isvisible(self):
        """Return True if the Turtle is shown, False if it's hidden.

        No argument.

        Example (for a Turtle instance named turtle):
        >>> turtle.hideturtle()
        >>> print turtle.isvisible():
        False
        """
        return self._shown

    def pen(self, pen=None, **pendict):
        """Return or set the pen's attributes.

        Arguments:
            pen -- a dictionary with some or all of the below listed keys.
            **pendict -- one or more keyword-arguments with the below
                         listed keys as keywords.

        Return or set the pen's attributes in a 'pen-dictionary'
        with the following key/value pairs:
           "shown"      :   True/False
           "pendown"    :   True/False
           "pencolor"   :   color-string or color-tuple
           "fillcolor"  :   color-string or color-tuple
           "pensize"    :   positive number
           "speed"      :   number in range 0..10
           "resizemode" :   "auto" or "user" or "noresize"
           "stretchfactor": (positive number, positive number)
           "shearfactor":   number
           "outline"    :   positive number
           "tilt"       :   number

        This dictionary can be used as argument for a subsequent
        pen()-call to restore the former pen-state. Moreover one
        or more of these attributes can be provided as keyword-arguments.
        This can be used to set several pen attributes in one statement.


        Examples (for a Turtle instance named turtle):
        >>> turtle.pen(fillcolor="black", pencolor="red", pensize=10)
        >>> turtle.pen()
        {'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
        'pencolor': 'red', 'pendown': True, 'fillcolor': 'black',
        'stretchfactor': (1,1), 'speed': 3, 'shearfactor': 0.0}
        >>> penstate=turtle.pen()
        >>> turtle.color("yellow","")
        >>> turtle.penup()
        >>> turtle.pen()
        {'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
        'pencolor': 'yellow', 'pendown': False, 'fillcolor': '',
        'stretchfactor': (1,1), 'speed': 3, 'shearfactor': 0.0}
        >>> p.pen(penstate, fillcolor="green")
        >>> p.pen()
        {'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
        'pencolor': 'red', 'pendown': True, 'fillcolor': 'green',
        'stretchfactor': (1,1), 'speed': 3, 'shearfactor': 0.0}
        """
        _pd =  {"shown"         : self._shown,
                "pendown"       : self._drawing,
                "pencolor"      : self._pencolor,
                "fillcolor"     : self._fillcolor,
                "pensize"       : self._pensize,
                "speed"         : self._speed,
                "resizemode"    : self._resizemode,
                "stretchfactor" : self._stretchfactor,
                "shearfactor"   : self._shearfactor,
                "outline"       : self._outlinewidth,
                "tilt"          : self._tilt
               }

        if not (pen or pendict):
            return _pd

        if isinstance(pen, dict):
            p = pen
        else:
            p = {}
        p.update(pendict)

        _p_buf = {}
        for key in p:
            _p_buf[key] = _pd[key]

        if self.undobuffer:
            self.undobuffer.push(("pen", _p_buf))

        newLine = False
        if "pendown" in p:
            if self._drawing != p["pendown"]:
                newLine = True
        if "pencolor" in p:
            if isinstance(p["pencolor"], tuple):
                p["pencolor"] = self._colorstr((p["pencolor"],))
            if self._pencolor != p["pencolor"]:
                newLine = True
        if "pensize" in p:
            if self._pensize != p["pensize"]:
                newLine = True
        if newLine:
            self._newLine()
        if "pendown" in p:
            self._drawing = p["pendown"]
        if "pencolor" in p:
            self._pencolor = p["pencolor"]
        if "pensize" in p:
            self._pensize = p["pensize"]
        if "fillcolor" in p:
            if isinstance(p["fillcolor"], tuple):
                p["fillcolor"] = self._colorstr((p["fillcolor"],))
            self._fillcolor = p["fillcolor"]
        if "speed" in p:
            self._speed = p["speed"]
        if "resizemode" in p:
            self._resizemode = p["resizemode"]
        if "stretchfactor" in p:
            sf = p["stretchfactor"]
            if isinstance(sf, (int, float)):
                sf = (sf, sf)
            self._stretchfactor = sf
        if "shearfactor" in p:
            self._shearfactor = p["shearfactor"]
        if "outline" in p:
            self._outlinewidth = p["outline"]
        if "shown" in p:
            self._shown = p["shown"]
        if "tilt" in p:
            self._tilt = p["tilt"]
        if "stretchfactor" in p or "tilt" in p or "shearfactor" in p:
            scx, scy = self._stretchfactor
            shf = self._shearfactor
            sa, ca = math.sin(self._tilt), math.cos(self._tilt)
            self._shapetrafo = ( scx*ca, scy*(shf*ca + sa),
                                -scx*sa, scy*(ca - shf*sa))
        self._update()

## three dummy methods to be implemented by child class:

    def _newLine(self, usePos = True):
        """dummy method - to be overwritten by child class"""
    def _update(self, count=True, forced=False):
        """dummy method - to be overwritten by child class"""
    def _color(self, args):
        """dummy method - to be overwritten by child class"""
    def _colorstr(self, args):
        """dummy method - to be overwritten by child class"""

    width = pensize
    up = penup
    pu = penup
    pd = pendown
    down = pendown
    st = showturtle
    ht = hideturtle


class _TurtleImage(object):
    """Helper class: Datatype to store Turtle attributes
    """

    def __init__(self, screen, shapeIndex):
        self.screen = screen
        self._type = None
        self._setshape(shapeIndex)

    def _setshape(self, shapeIndex):
        screen = self.screen
        self.shapeIndex = shapeIndex
        if self._type == "polygon" == screen._shapes[shapeIndex]._type:
            return
        if self._type == "image" == screen._shapes[shapeIndex]._type:
            return
        if self._type in ["image", "polygon"]:
            screen._delete(self._item)
        elif self._type == "compound":
            for item in self._item:
                screen._delete(item)
        self._type = screen._shapes[shapeIndex]._type
        if self._type == "polygon":
            self._item = screen._createpoly()
        elif self._type == "image":
            self._item = screen._createimage(screen._shapes["blank"]._data)
        elif self._type == "compound":
            self._item = [screen._createpoly() for item in
                                          screen._shapes[shapeIndex]._data]


class RawTurtle(TPen, TNavigator):
    """Animation part of the RawTurtle.
    Puts RawTurtle upon a TurtleScreen and provides tools for
    its animation.
    """
    screens = []

    def __init__(self, canvas=None,
                 shape=_CFG["shape"],
                 undobuffersize=_CFG["undobuffersize"],
                 visible=_CFG["visible"]):
        if isinstance(canvas, _Screen):
            self.screen = canvas
        elif isinstance(canvas, TurtleScreen):
            if canvas not in RawTurtle.screens:
                RawTurtle.screens.append(canvas)
            self.screen = canvas
        elif isinstance(canvas, (ScrolledCanvas, Canvas)):
            for screen in RawTurtle.screens:
                if screen.cv == canvas:
                    self.screen = screen
                    break
            else:
                self.screen = TurtleScreen(canvas)
                RawTurtle.screens.append(self.screen)
        else:
            raise TurtleGraphicsError("bad canvas argument %s" % canvas)

        screen = self.screen
        TNavigator.__init__(self, screen.mode())
        TPen.__init__(self)
        screen._turtles.append(self)
        self.drawingLineItem = screen._createline()
        self.turtle = _TurtleImage(screen, shape)
        self._poly = None
        self._creatingPoly = False
        self._fillitem = self._fillpath = None
        self._shown = visible
        self._hidden_from_screen = False
        self.currentLineItem = screen._createline()
        self.currentLine = [self._position]
        self.items = [self.currentLineItem]
        self.stampItems = []
        self._undobuffersize = undobuffersize
        self.undobuffer = Tbuffer(undobuffersize)
        self._update()

    def reset(self):
        """Delete the turtle's drawings and restore its default values.

        No argument.

        Delete the turtle's drawings from the screen, re-center the turtle
        and set variables to the default values.

        Example (for a Turtle instance named turtle):
        >>> turtle.position()
        (0.00,-22.00)
        >>> turtle.heading()
        100.0
        >>> turtle.reset()
        >>> turtle.position()
        (0.00,0.00)
        >>> turtle.heading()
        0.0
        """
        TNavigator.reset(self)
        TPen._reset(self)
        self._clear()
        self._drawturtle()
        self._update()

    def setundobuffer(self, size):
        """Set or disable undobuffer.

        Argument:
        size -- an integer or None

        If size is an integer an empty undobuffer of given size is installed.
        Size gives the maximum number of turtle-actions that can be undone
        by the undo() function.
        If size is None, no undobuffer is present.

        Example (for a Turtle instance named turtle):
        >>> turtle.setundobuffer(42)
        """
        if size is None or size <= 0:
            self.undobuffer = None
        else:
            self.undobuffer = Tbuffer(size)

    def undobufferentries(self):
        """Return count of entries in the undobuffer.

        No argument.

        Example (for a Turtle instance named turtle):
        >>> while undobufferentries():
        ...     undo()
        """
        if self.undobuffer is None:
            return 0
        return self.undobuffer.nr_of_items()

    def _clear(self):
        """Delete all of pen's drawings"""
        self._fillitem = self._fillpath = None
        for item in self.items:
            self.screen._delete(item)
        self.currentLineItem = self.screen._createline()
        self.currentLine = []
        if self._drawing:
            self.currentLine.append(self._position)
        self.items = [self.currentLineItem]
        self.clearstamps()
        self.setundobuffer(self._undobuffersize)


    def clear(self):
        """Delete the turtle's drawings from the screen. Do not move turtle.

        No arguments.

        Delete the turtle's drawings from the screen. Do not move turtle.
        State and position of the turtle as well as drawings of other
        turtles are not affected.

        Examples (for a Turtle instance named turtle):
        >>> turtle.clear()
        """
        self._clear()
        self._update()

    def _update_data(self):
        self.screen._incrementudc()
        if self.screen._updatecounter != 0:
            return
        if len(self.currentLine)>1:
            self.screen._drawline(self.currentLineItem, self.currentLine,
                                  self._pencolor, self._pensize)

    def _update(self):
        """Perform a Turtle-data update.
        """
        screen = self.screen
        if screen._tracing == 0:
            return
        elif screen._tracing == 1:
            self._update_data()
            self._drawturtle()
            screen._update()                  # TurtleScreenBase
            screen._delay(screen._delayvalue) # TurtleScreenBase
        else:
            self._update_data()
            if screen._updatecounter == 0:
                for t in screen.turtles():
                    t._drawturtle()
                screen._update()

    def _tracer(self, flag=None, delay=None):
        """Turns turtle animation on/off and set delay for update drawings.

        Optional arguments:
        n -- nonnegative  integer
        delay -- nonnegative  integer

        If n is given, only each n-th regular screen update is really performed.
        (Can be used to accelerate the drawing of complex graphics.)
        Second arguments sets delay value (see RawTurtle.delay())

        Example (for a Turtle instance named turtle):
        >>> turtle.tracer(8, 25)
        >>> dist = 2
        >>> for i in range(200):
        ...     turtle.fd(dist)
        ...     turtle.rt(90)
        ...     dist += 2
        """
        return self.screen.tracer(flag, delay)

    def _color(self, args):
        return self.screen._color(args)

    def _colorstr(self, args):
        return self.screen._colorstr(args)

    def _cc(self, args):
        """Convert colortriples to hexstrings.
        """
        if isinstance(args, str):
            return args
        try:
            r, g, b = args
        except (TypeError, ValueError):
            raise TurtleGraphicsError("bad color arguments: %s" % str(args))
        if self.screen._colormode == 1.0:
            r, g, b = [round(255.0*x) for x in (r, g, b)]
        if not ((0 <= r <= 255) and (0 <= g <= 255) and (0 <= b <= 255)):
            raise TurtleGraphicsError("bad color sequence: %s" % str(args))
        return "#%02x%02x%02x" % (r, g, b)

    def clone(self):
        """Create and return a clone of the turtle.

        No argument.

        Create and return a clone of the turtle with same position, heading
        and turtle properties.

        Example (for a Turtle instance named mick):
        mick = Turtle()
        joe = mick.clone()
        """
        screen = self.screen
        self._newLine(self._drawing)

        turtle = self.turtle
        self.screen = None
        self.turtle = None  # too make self deepcopy-able

        q = deepcopy(self)

        self.screen = screen
        self.turtle = turtle

        q.screen = screen
        q.turtle = _TurtleImage(screen, self.turtle.shapeIndex)

        screen._turtles.append(q)
        ttype = screen._shapes[self.turtle.shapeIndex]._type
        if ttype == "polygon":
            q.turtle._item = screen._createpoly()
        elif ttype == "image":
            q.turtle._item = screen._createimage(screen._shapes["blank"]._data)
        elif ttype == "compound":
            q.turtle._item = [screen._createpoly() for item in
                              screen._shapes[self.turtle.shapeIndex]._data]
        q.currentLineItem = screen._createline()
        q._update()
        return q

    def shape(self, name=None):
        """Set turtle shape to shape with given name / return current shapename.

        Optional argument:
        name -- a string, which is a valid shapename

        Set turtle shape to shape with given name or, if name is not given,
        return name of current shape.
        Shape with name must exist in the TurtleScreen's shape dictionary.
        Initially there are the following polygon shapes:
        'arrow', 'turtle', 'circle', 'square', 'triangle', 'classic'.
        To learn about how to deal with shapes see Screen-method register_shape.

        Example (for a Turtle instance named turtle):
        >>> turtle.shape()
        'arrow'
        >>> turtle.shape("turtle")
        >>> turtle.shape()
        'turtle'
        """
        if name is None:
            return self.turtle.shapeIndex
        if not name in self.screen.getshapes():
            raise TurtleGraphicsError("There is no shape named %s" % name)
        self.turtle._setshape(name)
        self._update()

    def shapesize(self, stretch_wid=None, stretch_len=None, outline=None):
        """Set/return turtle's stretchfactors/outline. Set resizemode to "user".

        Optional arguments:
           stretch_wid : positive number
           stretch_len : positive number
           outline  : positive number

        Return or set the pen's attributes x/y-stretchfactors and/or outline.
        Set resizemode to "user".
        If and only if resizemode is set to "user", the turtle will be displayed
        stretched according to its stretchfactors:
        stretch_wid is stretchfactor perpendicular to orientation
        stretch_len is stretchfactor in direction of turtles orientation.
        outline determines the width of the shapes's outline.

        Examples (for a Turtle instance named turtle):
        >>> turtle.resizemode("user")
        >>> turtle.shapesize(5, 5, 12)
        >>> turtle.shapesize(outline=8)
        """
        if stretch_wid is stretch_len is outline is None:
            stretch_wid, stretch_len = self._stretchfactor
            return stretch_wid, stretch_len, self._outlinewidth
        if stretch_wid == 0 or stretch_len == 0:
            raise TurtleGraphicsError("stretch_wid/stretch_len must not be zero")
        if stretch_wid is not None:
            if stretch_len is None:
                stretchfactor = stretch_wid, stretch_wid
            else:
                stretchfactor = stretch_wid, stretch_len
        elif stretch_len is not None:
            stretchfactor = self._stretchfactor[0], stretch_len
        else:
            stretchfactor = self._stretchfactor
        if outline is None:
            outline = self._outlinewidth
        self.pen(resizemode="user",
                 stretchfactor=stretchfactor, outline=outline)

    def shearfactor(self, shear=None):
        """Set or return the current shearfactor.

        Optional argument: shear -- number, tangent of the shear angle

        Shear the turtleshape according to the given shearfactor shear,
        which is the tangent of the shear angle. DO NOT change the
        turtle's heading (direction of movement).
        If shear is not given: return the current shearfactor, i. e. the
        tangent of the shear angle, by which lines parallel to the
        heading of the turtle are sheared.

        Examples (for a Turtle instance named turtle):
        >>> turtle.shape("circle")
        >>> turtle.shapesize(5,2)
        >>> turtle.shearfactor(0.5)
        >>> turtle.shearfactor()
        >>> 0.5
        """
        if shear is None:
            return self._shearfactor
        self.pen(resizemode="user", shearfactor=shear)

    def settiltangle(self, angle):
        """Rotate the turtleshape to point in the specified direction

        Argument: angle -- number

        Rotate the turtleshape to point in the direction specified by angle,
        regardless of its current tilt-angle. DO NOT change the turtle's
        heading (direction of movement).

        Deprecated since Python 3.1

        Examples (for a Turtle instance named turtle):
        >>> turtle.shape("circle")
        >>> turtle.shapesize(5,2)
        >>> turtle.settiltangle(45)
        >>> turtle.stamp()
        >>> turtle.fd(50)
        >>> turtle.settiltangle(-45)
        >>> turtle.stamp()
        >>> turtle.fd(50)
        """
        warnings._deprecated("turtle.RawTurtle.settiltangle()",
                             "{name!r} is deprecated since Python 3.1 and scheduled "
                             "for removal in Python {remove}. Use tiltangle() instead.",
                             remove=(3, 13))
        self.tiltangle(angle)

    def tiltangle(self, angle=None):
        """Set or return the current tilt-angle.

        Optional argument: angle -- number

        Rotate the turtleshape to point in the direction specified by angle,
        regardless of its current tilt-angle. DO NOT change the turtle's
        heading (direction of movement).
        If angle is not given: return the current tilt-angle, i. e. the angle
        between the orientation of the turtleshape and the heading of the
        turtle (its direction of movement).

        (Incorrectly marked as deprecated since Python 3.1, it is really
        settiltangle that is deprecated.)

        Examples (for a Turtle instance named turtle):
        >>> turtle.shape("circle")
        >>> turtle.shapesize(5, 2)
        >>> turtle.tiltangle()
        0.0
        >>> turtle.tiltangle(45)
        >>> turtle.tiltangle()
        45.0
        >>> turtle.stamp()
        >>> turtle.fd(50)
        >>> turtle.tiltangle(-45)
        >>> turtle.tiltangle()
        315.0
        >>> turtle.stamp()
        >>> turtle.fd(50)
        """
        if angle is None:
            tilt = -math.degrees(self._tilt) * self._angleOrient
            return (tilt / self._degreesPerAU) % self._fullcircle
        else:
            tilt = -angle * self._degreesPerAU * self._angleOrient
            tilt = math.radians(tilt) % math.tau
            self.pen(resizemode="user", tilt=tilt)

    def tilt(self, angle):
        """Rotate the turtleshape by angle.

        Argument:
        angle - a number

        Rotate the turtleshape by angle from its current tilt-angle,
        but do NOT change the turtle's heading (direction of movement).

        Examples (for a Turtle instance named turtle):
        >>> turtle.shape("circle")
        >>> turtle.shapesize(5,2)
        >>> turtle.tilt(30)
        >>> turtle.fd(50)
        >>> turtle.tilt(30)
        >>> turtle.fd(50)
        """
        self.tiltangle(angle + self.tiltangle())

    def shapetransform(self, t11=None, t12=None, t21=None, t22=None):
        """Set or return the current transformation matrix of the turtle shape.

        Optional arguments: t11, t12, t21, t22 -- numbers.

        If none of the matrix elements are given, return the transformation
        matrix.
        Otherwise set the given elements and transform the turtleshape
        according to the matrix consisting of first row t11, t12 and
        second row t21, 22.
        Modify stretchfactor, shearfactor and tiltangle according to the
        given matrix.

        Examples (for a Turtle instance named turtle):
        >>> turtle.shape("square")
        >>> turtle.shapesize(4,2)
        >>> turtle.shearfactor(-0.5)
        >>> turtle.shapetransform()
        (4.0, -1.0, -0.0, 2.0)
        """
        if t11 is t12 is t21 is t22 is None:
            return self._shapetrafo
        m11, m12, m21, m22 = self._shapetrafo
        if t11 is not None: m11 = t11
        if t12 is not None: m12 = t12
        if t21 is not None: m21 = t21
        if t22 is not None: m22 = t22
        if t11 * t22 - t12 * t21 == 0:
            raise TurtleGraphicsError("Bad shape transform matrix: must not be singular")
        self._shapetrafo = (m11, m12, m21, m22)
        alfa = math.atan2(-m21, m11) % math.tau
        sa, ca = math.sin(alfa), math.cos(alfa)
        a11, a12, a21, a22 = (ca*m11 - sa*m21, ca*m12 - sa*m22,
                              sa*m11 + ca*m21, sa*m12 + ca*m22)
        self._stretchfactor = a11, a22
        self._shearfactor = a12/a22
        self._tilt = alfa
        self.pen(resizemode="user")


    def _polytrafo(self, poly):
        """Computes transformed polygon shapes from a shape
        according to current position and heading.
        """
        screen = self.screen
        p0, p1 = self._position
        e0, e1 = self._orient
        e = Vec2D(e0, e1 * screen.yscale / screen.xscale)
        e0, e1 = (1.0 / abs(e)) * e
        return [(p0+(e1*x+e0*y)/screen.xscale, p1+(-e0*x+e1*y)/screen.yscale)
                                                           for (x, y) in poly]

    def get_shapepoly(self):
        """Return the current shape polygon as tuple of coordinate pairs.

        No argument.

        Examples (for a Turtle instance named turtle):
        >>> turtle.shape("square")
        >>> turtle.shapetransform(4, -1, 0, 2)
        >>> turtle.get_shapepoly()
        ((50, -20), (30, 20), (-50, 20), (-30, -20))

        """
        shape = self.screen._shapes[self.turtle.shapeIndex]
        if shape._type == "polygon":
            return self._getshapepoly(shape._data, shape._type == "compound")
        # else return None

    def _getshapepoly(self, polygon, compound=False):
        """Calculate transformed shape polygon according to resizemode
        and shapetransform.
        """
        if self._resizemode == "user" or compound:
            t11, t12, t21, t22 = self._shapetrafo
        elif self._resizemode == "auto":
            l = max(1, self._pensize/5.0)
            t11, t12, t21, t22 = l, 0, 0, l
        elif self._resizemode == "noresize":
            return polygon
        return tuple((t11*x + t12*y, t21*x + t22*y) for (x, y) in polygon)

    def _drawturtle(self):
        """Manages the correct rendering of the turtle with respect to
        its shape, resizemode, stretch and tilt etc."""
        screen = self.screen
        shape = screen._shapes[self.turtle.shapeIndex]
        ttype = shape._type
        titem = self.turtle._item
        if self._shown and screen._updatecounter == 0 and screen._tracing > 0:
            self._hidden_from_screen = False
            tshape = shape._data
            if ttype == "polygon":
                if self._resizemode == "noresize": w = 1
                elif self._resizemode == "auto": w = self._pensize
                else: w =self._outlinewidth
                shape = self._polytrafo(self._getshapepoly(tshape))
                fc, oc = self._fillcolor, self._pencolor
                screen._drawpoly(titem, shape, fill=fc, outline=oc,
                                                      width=w, top=True)
            elif ttype == "image":
                screen._drawimage(titem, self._position, tshape)
            elif ttype == "compound":
                for item, (poly, fc, oc) in zip(titem, tshape):
                    poly = self._polytrafo(self._getshapepoly(poly, True))
                    screen._drawpoly(item, poly, fill=self._cc(fc),
                                     outline=self._cc(oc), width=self._outlinewidth, top=True)
        else:
            if self._hidden_from_screen:
                return
            if ttype == "polygon":
                screen._drawpoly(titem, ((0, 0), (0, 0), (0, 0)), "", "")
            elif ttype == "image":
                screen._drawimage(titem, self._position,
                                          screen._shapes["blank"]._data)
            elif ttype == "compound":
                for item in titem:
                    screen._drawpoly(item, ((0, 0), (0, 0), (0, 0)), "", "")
            self._hidden_from_screen = True

##############################  stamp stuff  ###############################

    def stamp(self):
        """Stamp a copy of the turtleshape onto the canvas and return its id.

        No argument.

        Stamp a copy of the turtle shape onto the canvas at the current
        turtle position. Return a stamp_id for that stamp, which can be
        used to delete it by calling clearstamp(stamp_id).

        Example (for a Turtle instance named turtle):
        >>> turtle.color("blue")
        >>> turtle.stamp()
        13
        >>> turtle.fd(50)
        """
        screen = self.screen
        shape = screen._shapes[self.turtle.shapeIndex]
        ttype = shape._type
        tshape = shape._data
        if ttype == "polygon":
            stitem = screen._createpoly()
            if self._resizemode == "noresize": w = 1
            elif self._resizemode == "auto": w = self._pensize
            else: w =self._outlinewidth
            shape = self._polytrafo(self._getshapepoly(tshape))
            fc, oc = self._fillcolor, self._pencolor
            screen._drawpoly(stitem, shape, fill=fc, outline=oc,
                                                  width=w, top=True)
        elif ttype == "image":
            stitem = screen._createimage("")
            screen._drawimage(stitem, self._position, tshape)
        elif ttype == "compound":
            stitem = []
            for element in tshape:
                item = screen._createpoly()
                stitem.append(item)
            stitem = tuple(stitem)
            for item, (poly, fc, oc) in zip(stitem, tshape):
                poly = self._polytrafo(self._getshapepoly(poly, True))
                screen._drawpoly(item, poly, fill=self._cc(fc),
                                 outline=self._cc(oc), width=self._outlinewidth, top=True)
        self.stampItems.append(stitem)
        self.undobuffer.push(("stamp", stitem))
        return stitem

    def _clearstamp(self, stampid):
        """does the work for clearstamp() and clearstamps()
        """
        if stampid in self.stampItems:
            if isinstance(stampid, tuple):
                for subitem in stampid:
                    self.screen._delete(subitem)
            else:
                self.screen._delete(stampid)
            self.stampItems.remove(stampid)
        # Delete stampitem from undobuffer if necessary
        # if clearstamp is called directly.
        item = ("stamp", stampid)
        buf = self.undobuffer
        if item not in buf.buffer:
            return
        index = buf.buffer.index(item)
        buf.buffer.remove(item)
        if index <= buf.ptr:
            buf.ptr = (buf.ptr - 1) % buf.bufsize
        buf.buffer.insert((buf.ptr+1)%buf.bufsize, [None])

    def clearstamp(self, stampid):
        """Delete stamp with given stampid

        Argument:
        stampid - an integer, must be return value of previous stamp() call.

        Example (for a Turtle instance named turtle):
        >>> turtle.color("blue")
        >>> astamp = turtle.stamp()
        >>> turtle.fd(50)
        >>> turtle.clearstamp(astamp)
        """
        self._clearstamp(stampid)
        self._update()

    def clearstamps(self, n=None):
        """Delete all or first/last n of turtle's stamps.

        Optional argument:
        n -- an integer

        If n is None, delete all of pen's stamps,
        else if n > 0 delete first n stamps
        else if n < 0 delete last n stamps.

        Example (for a Turtle instance named turtle):
        >>> for i in range(8):
        ...     turtle.stamp(); turtle.fd(30)
        ...
        >>> turtle.clearstamps(2)
        >>> turtle.clearstamps(-2)
        >>> turtle.clearstamps()
        """
        if n is None:
            toDelete = self.stampItems[:]
        elif n >= 0:
            toDelete = self.stampItems[:n]
        else:
            toDelete = self.stampItems[n:]
        for item in toDelete:
            self._clearstamp(item)
        self._update()

    def _goto(self, end):
        """Move the pen to the point end, thereby drawing a line
        if pen is down. All other methods for turtle movement depend
        on this one.
        """
        ## Version with undo-stuff
        go_modes = ( self._drawing,
                     self._pencolor,
                     self._pensize,
                     isinstance(self._fillpath, list))
        screen = self.screen
        undo_entry = ("go", self._position, end, go_modes,
                      (self.currentLineItem,
                      self.currentLine[:],
                      screen._pointlist(self.currentLineItem),
                      self.items[:])
                      )
        if self.undobuffer:
            self.undobuffer.push(undo_entry)
        start = self._position
        if self._speed and screen._tracing == 1:
            diff = (end-start)
            diffsq = (diff[0]*screen.xscale)**2 + (diff[1]*screen.yscale)**2
            nhops = 1+int((diffsq**0.5)/(3*(1.1**self._speed)*self._speed))
            delta = diff * (1.0/nhops)
            for n in range(1, nhops):
                if n == 1:
                    top = True
                else:
                    top = False
                self._position = start + delta * n
                if self._drawing:
                    screen._drawline(self.drawingLineItem,
                                     (start, self._position),
                                     self._pencolor, self._pensize, top)
                self._update()
            if self._drawing:
                screen._drawline(self.drawingLineItem, ((0, 0), (0, 0)),
                                               fill="", width=self._pensize)
        # Turtle now at end,
        if self._drawing: # now update currentLine
            self.currentLine.append(end)
        if isinstance(self._fillpath, list):
            self._fillpath.append(end)
        ######    vererbung!!!!!!!!!!!!!!!!!!!!!!
        self._position = end
        if self._creatingPoly:
            self._poly.append(end)
        if len(self.currentLine) > 42: # 42! answer to the ultimate question
                                       # of life, the universe and everything
            self._newLine()
        self._update() #count=True)

    def _undogoto(self, entry):
        """Reverse a _goto. Used for undo()
        """
        old, new, go_modes, coodata = entry
        drawing, pc, ps, filling = go_modes
        cLI, cL, pl, items = coodata
        screen = self.screen
        if abs(self._position - new) > 0.5:
            print ("undogoto: HALLO-DA-STIMMT-WAS-NICHT!")
        # restore former situation
        self.currentLineItem = cLI
        self.currentLine = cL

        if pl == [(0, 0), (0, 0)]:
            usepc = ""
        else:
            usepc = pc
        screen._drawline(cLI, pl, fill=usepc, width=ps)

        todelete = [i for i in self.items if (i not in items) and
                                       (screen._type(i) == "line")]
        for i in todelete:
            screen._delete(i)
            self.items.remove(i)

        start = old
        if self._speed and screen._tracing == 1:
            diff = old - new
            diffsq = (diff[0]*screen.xscale)**2 + (diff[1]*screen.yscale)**2
            nhops = 1+int((diffsq**0.5)/(3*(1.1**self._speed)*self._speed))
            delta = diff * (1.0/nhops)
            for n in range(1, nhops):
                if n == 1:
                    top = True
                else:
                    top = False
                self._position = new + delta * n
                if drawing:
                    screen._drawline(self.drawingLineItem,
                                     (start, self._position),
                                     pc, ps, top)
                self._update()
            if drawing:
                screen._drawline(self.drawingLineItem, ((0, 0), (0, 0)),
                                               fill="", width=ps)
        # Turtle now at position old,
        self._position = old
        ##  if undo is done during creating a polygon, the last vertex
        ##  will be deleted. if the polygon is entirely deleted,
        ##  creatingPoly will be set to False.
        ##  Polygons created before the last one will not be affected by undo()
        if self._creatingPoly:
            if len(self._poly) > 0:
                self._poly.pop()
            if self._poly == []:
                self._creatingPoly = False
                self._poly = None
        if filling:
            if self._fillpath == []:
                self._fillpath = None
                print("Unwahrscheinlich in _undogoto!")
            elif self._fillpath is not None:
                self._fillpath.pop()
        self._update() #count=True)

    def _rotate(self, angle):
        """Turns pen clockwise by angle.
        """
        if self.undobuffer:
            self.undobuffer.push(("rot", angle, self._degreesPerAU))
        angle *= self._degreesPerAU
        neworient = self._orient.rotate(angle)
        tracing = self.screen._tracing
        if tracing == 1 and self._speed > 0:
            anglevel = 3.0 * self._speed
            steps = 1 + int(abs(angle)/anglevel)
            delta = 1.0*angle/steps
            for _ in range(steps):
                self._orient = self._orient.rotate(delta)
                self._update()
        self._orient = neworient
        self._update()

    def _newLine(self, usePos=True):
        """Closes current line item and starts a new one.
           Remark: if current line became too long, animation
           performance (via _drawline) slowed down considerably.
        """
        if len(self.currentLine) > 1:
            self.screen._drawline(self.currentLineItem, self.currentLine,
                                      self._pencolor, self._pensize)
            self.currentLineItem = self.screen._createline()
            self.items.append(self.currentLineItem)
        else:
            self.screen._drawline(self.currentLineItem, top=True)
        self.currentLine = []
        if usePos:
            self.currentLine = [self._position]

    def filling(self):
        """Return fillstate (True if filling, False else).

        No argument.

        Example (for a Turtle instance named turtle):
        >>> turtle.begin_fill()
        >>> if turtle.filling():
        ...     turtle.pensize(5)
        ... else:
        ...     turtle.pensize(3)
        """
        return isinstance(self._fillpath, list)

    def begin_fill(self):
        """Called just before drawing a shape to be filled.

        No argument.

        Example (for a Turtle instance named turtle):
        >>> turtle.color("black", "red")
        >>> turtle.begin_fill()
        >>> turtle.circle(60)
        >>> turtle.end_fill()
        """
        if not self.filling():
            self._fillitem = self.screen._createpoly()
            self.items.append(self._fillitem)
        self._fillpath = [self._position]
        self._newLine()
        if self.undobuffer:
            self.undobuffer.push(("beginfill", self._fillitem))
        self._update()


    def end_fill(self):
        """Fill the shape drawn after the call begin_fill().

        No argument.

        Example (for a Turtle instance named turtle):
        >>> turtle.color("black", "red")
        >>> turtle.begin_fill()
        >>> turtle.circle(60)
        >>> turtle.end_fill()
        """
        if self.filling():
            if len(self._fillpath) > 2:
                self.screen._drawpoly(self._fillitem, self._fillpath,
                                      fill=self._fillcolor)
                if self.undobuffer:
                    self.undobuffer.push(("dofill", self._fillitem))
            self._fillitem = self._fillpath = None
            self._update()

    def dot(self, size=None, *color):
        """Draw a dot with diameter size, using color.

        Optional arguments:
        size -- an integer >= 1 (if given)
        color -- a colorstring or a numeric color tuple

        Draw a circular dot with diameter size, using color.
        If size is not given, the maximum of pensize+4 and 2*pensize is used.

        Example (for a Turtle instance named turtle):
        >>> turtle.dot()
        >>> turtle.fd(50); turtle.dot(20, "blue"); turtle.fd(50)
        """
        if not color:
            if isinstance(size, (str, tuple)):
                color = self._colorstr(size)
                size = self._pensize + max(self._pensize, 4)
            else:
                color = self._pencolor
                if not size:
                    size = self._pensize + max(self._pensize, 4)
        else:
            if size is None:
                size = self._pensize + max(self._pensize, 4)
            color = self._colorstr(color)
        if hasattr(self.screen, "_dot"):
            item = self.screen._dot(self._position, size, color)
            self.items.append(item)
            if self.undobuffer:
                self.undobuffer.push(("dot", item))
        else:
            pen = self.pen()
            if self.undobuffer:
                self.undobuffer.push(["seq"])
                self.undobuffer.cumulate = True
            try:
                if self.resizemode() == 'auto':
                    self.ht()
                self.pendown()
                self.pensize(size)
                self.pencolor(color)
                self.forward(0)
            finally:
                self.pen(pen)
            if self.undobuffer:
                self.undobuffer.cumulate = False

    def _write(self, txt, align, font):
        """Performs the writing for write()
        """
        item, end = self.screen._write(self._position, txt, align, font,
                                                          self._pencolor)
        self._update()
        self.items.append(item)
        if self.undobuffer:
            self.undobuffer.push(("wri", item))
        return end

    def write(self, arg, move=False, align="left", font=("Arial", 8, "normal")):
        """Write text at the current turtle position.

        Arguments:
        arg -- info, which is to be written to the TurtleScreen
        move (optional) -- True/False
        align (optional) -- one of the strings "left", "center" or right"
        font (optional) -- a triple (fontname, fontsize, fonttype)

        Write text - the string representation of arg - at the current
        turtle position according to align ("left", "center" or right")
        and with the given font.
        If move is True, the pen is moved to the bottom-right corner
        of the text. By default, move is False.

        Example (for a Turtle instance named turtle):
        >>> turtle.write('Home = ', True, align="center")
        >>> turtle.write((0,0), True)
        """
        if self.undobuffer:
            self.undobuffer.push(["seq"])
            self.undobuffer.cumulate = True
        end = self._write(str(arg), align.lower(), font)
        if move:
            x, y = self.pos()
            self.setpos(end, y)
        if self.undobuffer:
            self.undobuffer.cumulate = False

    def begin_poly(self):
        """Start recording the vertices of a polygon.

        No argument.

        Start recording the vertices of a polygon. Current turtle position
        is first point of polygon.

        Example (for a Turtle instance named turtle):
        >>> turtle.begin_poly()
        """
        self._poly = [self._position]
        self._creatingPoly = True

    def end_poly(self):
        """Stop recording the vertices of a polygon.

        No argument.

        Stop recording the vertices of a polygon. Current turtle position is
        last point of polygon. This will be connected with the first point.

        Example (for a Turtle instance named turtle):
        >>> turtle.end_poly()
        """
        self._creatingPoly = False

    def get_poly(self):
        """Return the lastly recorded polygon.

        No argument.

        Example (for a Turtle instance named turtle):
        >>> p = turtle.get_poly()
        >>> turtle.register_shape("myFavouriteShape", p)
        """
        ## check if there is any poly?
        if self._poly is not None:
            return tuple(self._poly)

    def getscreen(self):
        """Return the TurtleScreen object, the turtle is drawing  on.

        No argument.

        Return the TurtleScreen object, the turtle is drawing  on.
        So TurtleScreen-methods can be called for that object.

        Example (for a Turtle instance named turtle):
        >>> ts = turtle.getscreen()
        >>> ts
        <turtle.TurtleScreen object at 0x0106B770>
        >>> ts.bgcolor("pink")
        """
        return self.screen

    def getturtle(self):
        """Return the Turtleobject itself.

        No argument.

        Only reasonable use: as a function to return the 'anonymous turtle':

        Example:
        >>> pet = getturtle()
        >>> pet.fd(50)
        >>> pet
        <turtle.Turtle object at 0x0187D810>
        >>> turtles()
        [<turtle.Turtle object at 0x0187D810>]
        """
        return self

    getpen = getturtle


    ################################################################
    ### screen oriented methods recurring to methods of TurtleScreen
    ################################################################

    def _delay(self, delay=None):
        """Set delay value which determines speed of turtle animation.
        """
        return self.screen.delay(delay)

    def onclick(self, fun, btn=1, add=None):
        """Bind fun to mouse-click event on this turtle on canvas.

        Arguments:
        fun --  a function with two arguments, to which will be assigned
                the coordinates of the clicked point on the canvas.
        btn --  number of the mouse-button defaults to 1 (left mouse button).
        add --  True or False. If True, new binding will be added, otherwise
                it will replace a former binding.

        Example for the anonymous turtle, i. e. the procedural way:

        >>> def turn(x, y):
        ...     left(360)
        ...
        >>> onclick(turn)  # Now clicking into the turtle will turn it.
        >>> onclick(None)  # event-binding will be removed
        """
        self.screen._onclick(self.turtle._item, fun, btn, add)
        self._update()

    def onrelease(self, fun, btn=1, add=None):
        """Bind fun to mouse-button-release event on this turtle on canvas.

        Arguments:
        fun -- a function with two arguments, to which will be assigned
                the coordinates of the clicked point on the canvas.
        btn --  number of the mouse-button defaults to 1 (left mouse button).

        Example (for a MyTurtle instance named joe):
        >>> class MyTurtle(Turtle):
        ...     def glow(self,x,y):
        ...             self.fillcolor("red")
        ...     def unglow(self,x,y):
        ...             self.fillcolor("")
        ...
        >>> joe = MyTurtle()
        >>> joe.onclick(joe.glow)
        >>> joe.onrelease(joe.unglow)

        Clicking on joe turns fillcolor red, unclicking turns it to
        transparent.
        """
        self.screen._onrelease(self.turtle._item, fun, btn, add)
        self._update()

    def ondrag(self, fun, btn=1, add=None):
        """Bind fun to mouse-move event on this turtle on canvas.

        Arguments:
        fun -- a function with two arguments, to which will be assigned
               the coordinates of the clicked point on the canvas.
        btn -- number of the mouse-button defaults to 1 (left mouse button).

        Every sequence of mouse-move-events on a turtle is preceded by a
        mouse-click event on that turtle.

        Example (for a Turtle instance named turtle):
        >>> turtle.ondrag(turtle.goto)

        Subsequently clicking and dragging a Turtle will move it
        across the screen thereby producing handdrawings (if pen is
        down).
        """
        self.screen._ondrag(self.turtle._item, fun, btn, add)


    def _undo(self, action, data):
        """Does the main part of the work for undo()
        """
        if self.undobuffer is None:
            return
        if action == "rot":
            angle, degPAU = data
            self._rotate(-angle*degPAU/self._degreesPerAU)
            dummy = self.undobuffer.pop()
        elif action == "stamp":
            stitem = data[0]
            self.clearstamp(stitem)
        elif action == "go":
            self._undogoto(data)
        elif action in ["wri", "dot"]:
            item = data[0]
            self.screen._delete(item)
            self.items.remove(item)
        elif action == "dofill":
            item = data[0]
            self.screen._drawpoly(item, ((0, 0),(0, 0),(0, 0)),
                                  fill="", outline="")
        elif action == "beginfill":
            item = data[0]
            self._fillitem = self._fillpath = None
            if item in self.items:
                self.screen._delete(item)
                self.items.remove(item)
        elif action == "pen":
            TPen.pen(self, data[0])
            self.undobuffer.pop()

    def undo(self):
        """undo (repeatedly) the last turtle action.

        No argument.

        undo (repeatedly) the last turtle action.
        Number of available undo actions is determined by the size of
        the undobuffer.

        Example (for a Turtle instance named turtle):
        >>> for i in range(4):
        ...     turtle.fd(50); turtle.lt(80)
        ...
        >>> for i in range(8):
        ...     turtle.undo()
        ...
        """
        if self.undobuffer is None:
            return
        item = self.undobuffer.pop()
        action = item[0]
        data = item[1:]
        if action == "seq":
            while data:
                item = data.pop()
                self._undo(item[0], item[1:])
        else:
            self._undo(action, data)

    turtlesize = shapesize

RawPen = RawTurtle

###  Screen - Singleton  ########################

def Screen():
    """Return the singleton screen object.
    If none exists at the moment, create a new one and return it,
    else return the existing one."""
    if Turtle._screen is None:
        Turtle._screen = _Screen()
    return Turtle._screen

class _Screen(TurtleScreen):

    _root = None
    _canvas = None
    _title = _CFG["title"]

    def __init__(self):
        # XXX there is no need for this code to be conditional,
        # as there will be only a single _Screen instance, anyway
        # XXX actually, the turtle demo is injecting root window,
        # so perhaps the conditional creation of a root should be
        # preserved (perhaps by passing it as an optional parameter)
        if _Screen._root is None:
            _Screen._root = self._root = _Root()
            self._root.title(_Screen._title)
            self._root.ondestroy(self._destroy)
        if _Screen._canvas is None:
            width = _CFG["width"]
            height = _CFG["height"]
            canvwidth = _CFG["canvwidth"]
            canvheight = _CFG["canvheight"]
            leftright = _CFG["leftright"]
            topbottom = _CFG["topbottom"]
            self._root.setupcanvas(width, height, canvwidth, canvheight)
            _Screen._canvas = self._root._getcanvas()
            TurtleScreen.__init__(self, _Screen._canvas)
            self.setup(width, height, leftright, topbottom)

    def setup(self, width=_CFG["width"], height=_CFG["height"],
              startx=_CFG["leftright"], starty=_CFG["topbottom"]):
        """ Set the size and position of the main window.

        Arguments:
        width: as integer a size in pixels, as float a fraction of the screen.
          Default is 50% of screen.
        height: as integer the height in pixels, as float a fraction of the
          screen. Default is 75% of screen.
        startx: if positive, starting position in pixels from the left
          edge of the screen, if negative from the right edge
          Default, startx=None is to center window horizontally.
        starty: if positive, starting position in pixels from the top
          edge of the screen, if negative from the bottom edge
          Default, starty=None is to center window vertically.

        Examples (for a Screen instance named screen):
        >>> screen.setup (width=200, height=200, startx=0, starty=0)

        sets window to 200x200 pixels, in upper left of screen

        >>> screen.setup(width=.75, height=0.5, startx=None, starty=None)

        sets window to 75% of screen by 50% of screen and centers
        """
        if not hasattr(self._root, "set_geometry"):
            return
        sw = self._root.win_width()
        sh = self._root.win_height()
        if isinstance(width, float) and 0 <= width <= 1:
            width = sw*width
        if startx is None:
            startx = (sw - width) / 2
        if isinstance(height, float) and 0 <= height <= 1:
            height = sh*height
        if starty is None:
            starty = (sh - height) / 2
        self._root.set_geometry(width, height, startx, starty)
        self.update()

    def title(self, titlestring):
        """Set title of turtle-window

        Argument:
        titlestring -- a string, to appear in the titlebar of the
                       turtle graphics window.

        This is a method of Screen-class. Not available for TurtleScreen-
        objects.

        Example (for a Screen instance named screen):
        >>> screen.title("Welcome to the turtle-zoo!")
        """
        if _Screen._root is not None:
            _Screen._root.title(titlestring)
        _Screen._title = titlestring

    def _destroy(self):
        root = self._root
        if root is _Screen._root:
            Turtle._pen = None
            Turtle._screen = None
            _Screen._root = None
            _Screen._canvas = None
        TurtleScreen._RUNNING = False
        root.destroy()

    def bye(self):
        """Shut the turtlegraphics window.

        Example (for a TurtleScreen instance named screen):
        >>> screen.bye()
        """
        self._destroy()

    def exitonclick(self):
        """Go into mainloop until the mouse is clicked.

        No arguments.

        Bind bye() method to mouseclick on TurtleScreen.
        If "using_IDLE" - value in configuration dictionary is False
        (default value), enter mainloop.
        If IDLE with -n switch (no subprocess) is used, this value should be
        set to True in turtle.cfg. In this case IDLE's mainloop
        is active also for the client script.

        This is a method of the Screen-class and not available for
        TurtleScreen instances.

        Example (for a Screen instance named screen):
        >>> screen.exitonclick()

        """
        def exitGracefully(x, y):
            """Screen.bye() with two dummy-parameters"""
            self.bye()
        self.onclick(exitGracefully)
        if _CFG["using_IDLE"]:
            return
        try:
            mainloop()
        except AttributeError:
            exit(0)

class Turtle(RawTurtle):
    """RawTurtle auto-creating (scrolled) canvas.

    When a Turtle object is created or a function derived from some
    Turtle method is called a TurtleScreen object is automatically created.
    """
    _pen = None
    _screen = None

    def __init__(self,
                 shape=_CFG["shape"],
                 undobuffersize=_CFG["undobuffersize"],
                 visible=_CFG["visible"]):
        if Turtle._screen is None:
            Turtle._screen = Screen()
        RawTurtle.__init__(self, Turtle._screen,
                           shape=shape,
                           undobuffersize=undobuffersize,
                           visible=visible)

Pen = Turtle

def write_docstringdict(filename="turtle_docstringdict"):
    """Create and write docstring-dictionary to file.

    Optional argument:
    filename -- a string, used as filename
                default value is turtle_docstringdict

    Has to be called explicitly, (not used by the turtle-graphics classes)
    The docstring dictionary will be written to the Python script <filename>.py
    It is intended to serve as a template for translation of the docstrings
    into different languages.
    """
    docsdict = {}

    for methodname in _tg_screen_functions:
        key = "_Screen."+methodname
        docsdict[key] = eval(key).__doc__
    for methodname in _tg_turtle_functions:
        key = "Turtle."+methodname
        docsdict[key] = eval(key).__doc__

    with open("%s.py" % filename,"w") as f:
        keys = sorted(x for x in docsdict
                      if x.split('.')[1] not in _alias_list)
        f.write('docsdict = {\n\n')
        for key in keys[:-1]:
            f.write('%s :\n' % repr(key))
            f.write('        """%s\n""",\n\n' % docsdict[key])
        key = keys[-1]
        f.write('%s :\n' % repr(key))
        f.write('        """%s\n"""\n\n' % docsdict[key])
        f.write("}\n")
        f.close()

def read_docstrings(lang):
    """Read in docstrings from lang-specific docstring dictionary.

    Transfer docstrings, translated to lang, from a dictionary-file
    to the methods of classes Screen and Turtle and - in revised form -
    to the corresponding functions.
    """
    modname = "turtle_docstringdict_%(language)s" % {'language':lang.lower()}
    module = __import__(modname)
    docsdict = module.docsdict
    for key in docsdict:
        try:
#            eval(key).im_func.__doc__ = docsdict[key]
            eval(key).__doc__ = docsdict[key]
        except Exception:
            print("Bad docstring-entry: %s" % key)

_LANGUAGE = _CFG["language"]

try:
    if _LANGUAGE != "english":
        read_docstrings(_LANGUAGE)
except ImportError:
    print("Cannot find docsdict for", _LANGUAGE)
except Exception:
    print ("Unknown Error when trying to import %s-docstring-dictionary" %
                                                                  _LANGUAGE)


def getmethparlist(ob):
    """Get strings describing the arguments for the given object

    Returns a pair of strings representing function parameter lists
    including parenthesis.  The first string is suitable for use in
    function definition and the second is suitable for use in function
    call.  The "self" parameter is not included.
    """
    defText = callText = ""
    # bit of a hack for methods - turn it into a function
    # but we drop the "self" param.
    # Try and build one for Python defined functions
    args, varargs, varkw = inspect.getargs(ob.__code__)
    items2 = args[1:]
    realArgs = args[1:]
    defaults = ob.__defaults__ or []
    defaults = ["=%r" % (value,) for value in defaults]
    defaults = [""] * (len(realArgs)-len(defaults)) + defaults
    items1 = [arg + dflt for arg, dflt in zip(realArgs, defaults)]
    if varargs is not None:
        items1.append("*" + varargs)
        items2.append("*" + varargs)
    if varkw is not None:
        items1.append("**" + varkw)
        items2.append("**" + varkw)
    defText = ", ".join(items1)
    defText = "(%s)" % defText
    callText = ", ".join(items2)
    callText = "(%s)" % callText
    return defText, callText

def _turtle_docrevise(docstr):
    """To reduce docstrings from RawTurtle class for functions
    """
    import re
    if docstr is None:
        return None
    turtlename = _CFG["exampleturtle"]
    newdocstr = docstr.replace("%s." % turtlename,"")
    parexp = re.compile(r' \(.+ %s\):' % turtlename)
    newdocstr = parexp.sub(":", newdocstr)
    return newdocstr

def _screen_docrevise(docstr):
    """To reduce docstrings from TurtleScreen class for functions
    """
    import re
    if docstr is None:
        return None
    screenname = _CFG["examplescreen"]
    newdocstr = docstr.replace("%s." % screenname,"")
    parexp = re.compile(r' \(.+ %s\):' % screenname)
    newdocstr = parexp.sub(":", newdocstr)
    return newdocstr

## The following mechanism makes all methods of RawTurtle and Turtle available
## as functions. So we can enhance, change, add, delete methods to these
## classes and do not need to change anything here.

__func_body = """\
def {name}{paramslist}:
    if {obj} is None:
        if not TurtleScreen._RUNNING:
            TurtleScreen._RUNNING = True
            raise Terminator
        {obj} = {init}
    try:
        return {obj}.{name}{argslist}
    except TK.TclError:
        if not TurtleScreen._RUNNING:
            TurtleScreen._RUNNING = True
            raise Terminator
        raise
"""

def _make_global_funcs(functions, cls, obj, init, docrevise):
    for methodname in functions:
        method = getattr(cls, methodname)
        pl1, pl2 = getmethparlist(method)
        if pl1 == "":
            print(">>>>>>", pl1, pl2)
            continue
        defstr = __func_body.format(obj=obj, init=init, name=methodname,
                                    paramslist=pl1, argslist=pl2)
        exec(defstr, globals())
        globals()[methodname].__doc__ = docrevise(method.__doc__)

_make_global_funcs(_tg_screen_functions, _Screen,
                   'Turtle._screen', 'Screen()', _screen_docrevise)
_make_global_funcs(_tg_turtle_functions, Turtle,
                   'Turtle._pen', 'Turtle()', _turtle_docrevise)


done = mainloop

if __name__ == "__main__":
    def switchpen():
        if isdown():
            pu()
        else:
            pd()

    def demo1():
        """Demo of old turtle.py - module"""
        reset()
        tracer(True)
        up()
        backward(100)
        down()
        # draw 3 squares; the last filled
        width(3)
        for i in range(3):
            if i == 2:
                begin_fill()
            for _ in range(4):
                forward(20)
                left(90)
            if i == 2:
                color("maroon")
                end_fill()
            up()
            forward(30)
            down()
        width(1)
        color("black")
        # move out of the way
        tracer(False)
        up()
        right(90)
        forward(100)
        right(90)
        forward(100)
        right(180)
        down()
        # some text
        write("startstart", 1)
        write("start", 1)
        color("red")
        # staircase
        for i in range(5):
            forward(20)
            left(90)
            forward(20)
            right(90)
        # filled staircase
        tracer(True)
        begin_fill()
        for i in range(5):
            forward(20)
            left(90)
            forward(20)
            right(90)
        end_fill()
        # more text

    def demo2():
        """Demo of some new features."""
        speed(1)
        st()
        pensize(3)
        setheading(towards(0, 0))
        radius = distance(0, 0)/2.0
        rt(90)
        for _ in range(18):
            switchpen()
            circle(radius, 10)
        write("wait a moment...")
        while undobufferentries():
            undo()
        reset()
        lt(90)
        colormode(255)
        laenge = 10
        pencolor("green")
        pensize(3)
        lt(180)
        for i in range(-2, 16):
            if i > 0:
                begin_fill()
                fillcolor(255-15*i, 0, 15*i)
            for _ in range(3):
                fd(laenge)
                lt(120)
            end_fill()
            laenge += 10
            lt(15)
            speed((speed()+1)%12)
        #end_fill()

        lt(120)
        pu()
        fd(70)
        rt(30)
        pd()
        color("red","yellow")
        speed(0)
        begin_fill()
        for _ in range(4):
            circle(50, 90)
            rt(90)
            fd(30)
            rt(90)
        end_fill()
        lt(90)
        pu()
        fd(30)
        pd()
        shape("turtle")

        tri = getturtle()
        tri.resizemode("auto")
        turtle = Turtle()
        turtle.resizemode("auto")
        turtle.shape("turtle")
        turtle.reset()
        turtle.left(90)
        turtle.speed(0)
        turtle.up()
        turtle.goto(280, 40)
        turtle.lt(30)
        turtle.down()
        turtle.speed(6)
        turtle.color("blue","orange")
        turtle.pensize(2)
        tri.speed(6)
        setheading(towards(turtle))
        count = 1
        while tri.distance(turtle) > 4:
            turtle.fd(3.5)
            turtle.lt(0.6)
            tri.setheading(tri.towards(turtle))
            tri.fd(4)
            if count % 20 == 0:
                turtle.stamp()
                tri.stamp()
                switchpen()
            count += 1
        tri.write("CAUGHT! ", font=("Arial", 16, "bold"), align="right")
        tri.pencolor("black")
        tri.pencolor("red")

        def baba(xdummy, ydummy):
            clearscreen()
            bye()

        time.sleep(2)

        while undobufferentries():
            tri.undo()
            turtle.undo()
        tri.fd(50)
        tri.write("  Click me!", font = ("Courier", 12, "bold") )
        tri.onclick(baba, 1)

    demo1()
    demo2()
    exitonclick()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          """Simple implementation of the Level 1 DOM.

Namespaces and other minor Level 2 features are also supported.

parse("foo.xml")

parseString("<foo><bar/></foo>")

Todo:
=====
 * convenience methods for getting elements and text.
 * more testing
 * bring some of the writer and linearizer code into conformance with this
        interface
 * SAX 2 namespaces
"""

import io
import xml.dom

from xml.dom import EMPTY_NAMESPACE, EMPTY_PREFIX, XMLNS_NAMESPACE, domreg
from xml.dom.minicompat import *
from xml.dom.xmlbuilder import DOMImplementationLS, DocumentLS

# This is used by the ID-cache invalidation checks; the list isn't
# actually complete, since the nodes being checked will never be the
# DOCUMENT_NODE or DOCUMENT_FRAGMENT_NODE.  (The node being checked is
# the node being added or removed, not the node being modified.)
#
_nodeTypes_with_children = (xml.dom.Node.ELEMENT_NODE,
                            xml.dom.Node.ENTITY_REFERENCE_NODE)


class Node(xml.dom.Node):
    namespaceURI = None # this is non-null only for elements and attributes
    parentNode = None
    ownerDocument = None
    nextSibling = None
    previousSibling = None

    prefix = EMPTY_PREFIX # non-null only for NS elements and attributes

    def __bool__(self):
        return True

    def toxml(self, encoding=None, standalone=None):
        return self.toprettyxml("", "", encoding, standalone)

    def toprettyxml(self, indent="\t", newl="\n", encoding=None,
                    standalone=None):
        if encoding is None:
            writer = io.StringIO()
        else:
            writer = io.TextIOWrapper(io.BytesIO(),
                                      encoding=encoding,
                                      errors="xmlcharrefreplace",
                                      newline='\n')
        if self.nodeType == Node.DOCUMENT_NODE:
            # Can pass encoding only to document, to put it into XML header
            self.writexml(writer, "", indent, newl, encoding, standalone)
        else:
            self.writexml(writer, "", indent, newl)
        if encoding is None:
            return writer.getvalue()
        else:
            return writer.detach().getvalue()

    def hasChildNodes(self):
        return bool(self.childNodes)

    def _get_childNodes(self):
        return self.childNodes

    def _get_firstChild(self):
        if self.childNodes:
            return self.childNodes[0]

    def _get_lastChild(self):
        if self.childNodes:
            return self.childNodes[-1]

    def insertBefore(self, newChild, refChild):
        if newChild.nodeType == self.DOCUMENT_FRAGMENT_NODE:
            for c in tuple(newChild.childNodes):
                self.insertBefore(c, refChild)
            ### The DOM does not clearly specify what to return in this case
            return newChild
        if newChild.nodeType not in self._child_node_types:
            raise xml.dom.HierarchyRequestErr(
                "%s cannot be child of %s" % (repr(newChild), repr(self)))
        if newChild.parentNode is not None:
            newChild.parentNode.removeChild(newChild)
        if refChild is None:
            self.appendChild(newChild)
        else:
            try:
                index = self.childNodes.index(refChild)
            except ValueError:
                raise xml.dom.NotFoundErr()
            if newChild.nodeType in _nodeTypes_with_children:
                _clear_id_cache(self)
            self.childNodes.insert(index, newChild)
            newChild.nextSibling = refChild
            refChild.previousSibling = newChild
            if index:
                node = self.childNodes[index-1]
                node.nextSibling = newChild
                newChild.previousSibling = node
            else:
                newChild.previousSibling = None
            newChild.parentNode = self
        return newChild

    def appendChild(self, node):
        if node.nodeType == self.DOCUMENT_FRAGMENT_NODE:
            for c in tuple(node.childNodes):
                self.appendChild(c)
            ### The DOM does not clearly specify what to return in this case
            return node
        if node.nodeType not in self._child_node_types:
            raise xml.dom.HierarchyRequestErr(
                "%s cannot be child of %s" % (repr(node), repr(self)))
        elif node.nodeType in _nodeTypes_with_children:
            _clear_id_cache(self)
        if node.parentNode is not None:
            node.parentNode.removeChild(node)
        _append_child(self, node)
        node.nextSibling = None
        return node

    def replaceChild(self, newChild, oldChild):
        if newChild.nodeType == self.DOCUMENT_FRAGMENT_NODE:
            refChild = oldChild.nextSibling
            self.removeChild(oldChild)
            return self.insertBefore(newChild, refChild)
        if newChild.nodeType not in self._child_node_types:
            raise xml.dom.HierarchyRequestErr(
                "%s cannot be child of %s" % (repr(newChild), repr(self)))
        if newChild is oldChild:
            return
        if newChild.parentNode is not None:
            newChild.parentNode.removeChild(newChild)
        try:
            index = self.childNodes.index(oldChild)
        except ValueError:
            raise xml.dom.NotFoundErr()
        self.childNodes[index] = newChild
        newChild.parentNode = self
        oldChild.parentNode = None
        if (newChild.nodeType in _nodeTypes_with_children
            or oldChild.nodeType in _nodeTypes_with_children):
            _clear_id_cache(self)
        newChild.nextSibling = oldChild.nextSibling
        newChild.previousSibling = oldChild.previousSibling
        oldChild.nextSibling = None
        oldChild.previousSibling = None
        if newChild.previousSibling:
            newChild.previousSibling.nextSibling = newChild
        if newChild.nextSibling:
            newChild.nextSibling.previousSibling = newChild
        return oldChild

    def removeChild(self, oldChild):
        try:
            self.childNodes.remove(oldChild)
        except ValueError:
            raise xml.dom.NotFoundErr()
        if oldChild.nextSibling is not None:
            oldChild.nextSibling.previousSibling = oldChild.previousSibling
        if oldChild.previousSibling is not None:
            oldChild.previousSibling.nextSibling = oldChild.nextSibling
        oldChild.nextSibling = oldChild.previousSibling = None
        if oldChild.nodeType in _nodeTypes_with_children:
            _clear_id_cache(self)

        oldChild.parentNode = None
        return oldChild

    def normalize(self):
        L = []
        for child in self.childNodes:
            if child.nodeType == Node.TEXT_NODE:
                if not child.data:
                    # empty text node; discard
                    if L:
                        L[-1].nextSibling = child.nextSibling
                    if child.nextSibling:
                        child.nextSibling.previousSibling = child.previousSibling
                    child.unlink()
                elif L and L[-1].nodeType == child.nodeType:
                    # collapse text node
                    node = L[-1]
                    node.data = node.data + child.data
                    node.nextSibling = child.nextSibling
                    if child.nextSibling:
                        child.nextSibling.previousSibling = node
                    child.unlink()
                else:
                    L.append(child)
            else:
                L.append(child)
                if child.nodeType == Node.ELEMENT_NODE:
                    child.normalize()
        self.childNodes[:] = L

    def cloneNode(self, deep):
        return _clone_node(self, deep, self.ownerDocument or self)

    def isSupported(self, feature, version):
        return self.ownerDocument.implementation.hasFeature(feature, version)

    def _get_localName(self):
        # Overridden in Element and Attr where localName can be Non-Null
        return None

    # Node interfaces from Level 3 (WD 9 April 2002)

    def isSameNode(self, other):
        return self is other

    def getInterface(self, feature):
        if self.isSupported(feature, None):
            return self
        else:
            return None

    # The "user data" functions use a dictionary that is only present
    # if some user data has been set, so be careful not to assume it
    # exists.

    def getUserData(self, key):
        try:
            return self._user_data[key][0]
        except (AttributeError, KeyError):
            return None

    def setUserData(self, key, data, handler):
        old = None
        try:
            d = self._user_data
        except AttributeError:
            d = {}
            self._user_data = d
        if key in d:
            old = d[key][0]
        if data is None:
            # ignore handlers passed for None
            handler = None
            if old is not None:
                del d[key]
        else:
            d[key] = (data, handler)
        return old

    def _call_user_data_handler(self, operation, src, dst):
        if hasattr(self, "_user_data"):
            for key, (data, handler) in list(self._user_data.items()):
                if handler is not None:
                    handler.handle(operation, key, data, src, dst)

    # minidom-specific API:

    def unlink(self):
        self.parentNode = self.ownerDocument = None
        if self.childNodes:
            for child in self.childNodes:
                child.unlink()
            self.childNodes = NodeList()
        self.previousSibling = None
        self.nextSibling = None

    # A Node is its own context manager, to ensure that an unlink() call occurs.
    # This is similar to how a file object works.
    def __enter__(self):
        return self

    def __exit__(self, et, ev, tb):
        self.unlink()

defproperty(Node, "firstChild", doc="First child node, or None.")
defproperty(Node, "lastChild",  doc="Last child node, or None.")
defproperty(Node, "localName",  doc="Namespace-local name of this node.")


def _append_child(self, node):
    # fast path with less checks; usable by DOM builders if careful
    childNodes = self.childNodes
    if childNodes:
        last = childNodes[-1]
        node.previousSibling = last
        last.nextSibling = node
    childNodes.append(node)
    node.parentNode = self

def _in_document(node):
    # return True iff node is part of a document tree
    while node is not None:
        if node.nodeType == Node.DOCUMENT_NODE:
            return True
        node = node.parentNode
    return False

def _write_data(writer, data):
    "Writes datachars to writer."
    if data:
        data = data.replace("&", "&amp;").replace("<", "&lt;"). \
                    replace("\"", "&quot;").replace(">", "&gt;")
        writer.write(data)

def _get_elements_by_tagName_helper(parent, name, rc):
    for node in parent.childNodes:
        if node.nodeType == Node.ELEMENT_NODE and \
            (name == "*" or node.tagName == name):
            rc.append(node)
        _get_elements_by_tagName_helper(node, name, rc)
    return rc

def _get_elements_by_tagName_ns_helper(parent, nsURI, localName, rc):
    for node in parent.childNodes:
        if node.nodeType == Node.ELEMENT_NODE:
            if ((localName == "*" or node.localName == localName) and
                (nsURI == "*" or node.namespaceURI == nsURI)):
                rc.append(node)
            _get_elements_by_tagName_ns_helper(node, nsURI, localName, rc)
    return rc

class DocumentFragment(Node):
    nodeType = Node.DOCUMENT_FRAGMENT_NODE
    nodeName = "#document-fragment"
    nodeValue = None
    attributes = None
    parentNode = None
    _child_node_types = (Node.ELEMENT_NODE,
                         Node.TEXT_NODE,
                         Node.CDATA_SECTION_NODE,
                         Node.ENTITY_REFERENCE_NODE,
                         Node.PROCESSING_INSTRUCTION_NODE,
                         Node.COMMENT_NODE,
                         Node.NOTATION_NODE)

    def __init__(self):
        self.childNodes = NodeList()


class Attr(Node):
    __slots__=('_name', '_value', 'namespaceURI',
               '_prefix', 'childNodes', '_localName', 'ownerDocument', 'ownerElement')
    nodeType = Node.ATTRIBUTE_NODE
    attributes = None
    specified = False
    _is_id = False

    _child_node_types = (Node.TEXT_NODE, Node.ENTITY_REFERENCE_NODE)

    def __init__(self, qName, namespaceURI=EMPTY_NAMESPACE, localName=None,
                 prefix=None):
        self.ownerElement = None
        self._name = qName
        self.namespaceURI = namespaceURI
        self._prefix = prefix
        if localName is not None:
            self._localName = localName
        self.childNodes = NodeList()

        # Add the single child node that represents the value of the attr
        self.childNodes.append(Text())

        # nodeValue and value are set elsewhere

    def _get_localName(self):
        try:
            return self._localName
        except AttributeError:
            return self.nodeName.split(":", 1)[-1]

    def _get_specified(self):
        return self.specified

    def _get_name(self):
        return self._name

    def _set_name(self, value):
        self._name = value
        if self.ownerElement is not None:
            _clear_id_cache(self.ownerElement)

    nodeName = name = property(_get_name, _set_name)

    def _get_value(self):
        return self._value

    def _set_value(self, value):
        self._value = value
        self.childNodes[0].data = value
        if self.ownerElement is not None:
            _clear_id_cache(self.ownerElement)
        self.childNodes[0].data = value

    nodeValue = value = property(_get_value, _set_value)

    def _get_prefix(self):
        return self._prefix

    def _set_prefix(self, prefix):
        nsuri = self.namespaceURI
        if prefix == "xmlns":
            if nsuri and nsuri != XMLNS_NAMESPACE:
                raise xml.dom.NamespaceErr(
                    "illegal use of 'xmlns' prefix for the wrong namespace")
        self._prefix = prefix
        if prefix is None:
            newName = self.localName
        else:
            newName = "%s:%s" % (prefix, self.localName)
        if self.ownerElement:
            _clear_id_cache(self.ownerElement)
        self.name = newName

    prefix = property(_get_prefix, _set_prefix)

    def unlink(self):
        # This implementation does not call the base implementation
        # since most of that is not needed, and the expense of the
        # method call is not warranted.  We duplicate the removal of
        # children, but that's all we needed from the base class.
        elem = self.ownerElement
        if elem is not None:
            del elem._attrs[self.nodeName]
            del elem._attrsNS[(self.namespaceURI, self.localName)]
            if self._is_id:
                self._is_id = False
                elem._magic_id_nodes -= 1
                self.ownerDocument._magic_id_count -= 1
        for child in self.childNodes:
            child.unlink()
        del self.childNodes[:]

    def _get_isId(self):
        if self._is_id:
            return True
        doc = self.ownerDocument
        elem = self.ownerElement
        if doc is None or elem is None:
            return False

        info = doc._get_elem_info(elem)
        if info is None:
            return False
        if self.namespaceURI:
            return info.isIdNS(self.namespaceURI, self.localName)
        else:
            return info.isId(self.nodeName)

    def _get_schemaType(self):
        doc = self.ownerDocument
        elem = self.ownerElement
        if doc is None or elem is None:
            return _no_type

        info = doc._get_elem_info(elem)
        if info is None:
            return _no_type
        if self.namespaceURI:
            return info.getAttributeTypeNS(self.namespaceURI, self.localName)
        else:
            return info.getAttributeType(self.nodeName)

defproperty(Attr, "isId",       doc="True if this attribute is an ID.")
defproperty(Attr, "localName",  doc="Namespace-local name of this attribute.")
defproperty(Attr, "schemaType", doc="Schema type for this attribute.")


class NamedNodeMap(object):
    """The attribute list is a transient interface to the underlying
    dictionaries.  Mutations here will change the underlying element's
    dictionary.

    Ordering is imposed artificially and does not reflect the order of
    attributes as found in an input document.
    """

    __slots__ = ('_attrs', '_attrsNS', '_ownerElement')

    def __init__(self, attrs, attrsNS, ownerElement):
        self._attrs = attrs
        self._attrsNS = attrsNS
        self._ownerElement = ownerElement

    def _get_length(self):
        return len(self._attrs)

    def item(self, index):
        try:
            return self[list(self._attrs.keys())[index]]
        except IndexError:
            return None

    def items(self):
        L = []
        for node in self._attrs.values():
            L.append((node.nodeName, node.value))
        return L

    def itemsNS(self):
        L = []
        for node in self._attrs.values():
            L.append(((node.namespaceURI, node.localName), node.value))
        return L

    def __contains__(self, key):
        if isinstance(key, str):
            return key in self._attrs
        else:
            return key in self._attrsNS

    def keys(self):
        return self._attrs.keys()

    def keysNS(self):
        return self._attrsNS.keys()

    def values(self):
        return self._attrs.values()

    def get(self, name, value=None):
        return self._attrs.get(name, value)

    __len__ = _get_length

    def _cmp(self, other):
        if self._attrs is getattr(other, "_attrs", None):
            return 0
        else:
            return (id(self) > id(other)) - (id(self) < id(other))

    def __eq__(self, other):
        return self._cmp(other) == 0

    def __ge__(self, other):
        return self._cmp(other) >= 0

    def __gt__(self, other):
        return self._cmp(other) > 0

    def __le__(self, other):
        return self._cmp(other) <= 0

    def __lt__(self, other):
        return self._cmp(other) < 0

    def __getitem__(self, attname_or_tuple):
        if isinstance(attname_or_tuple, tuple):
            return self._attrsNS[attname_or_tuple]
        else:
            return self._attrs[attname_or_tuple]

    # same as set
    def __setitem__(self, attname, value):
        if isinstance(value, str):
            try:
                node = self._attrs[attname]
            except KeyError:
                node = Attr(attname)
                node.ownerDocument = self._ownerElement.ownerDocument
                self.setNamedItem(node)
            node.value = value
        else:
            if not isinstance(value, Attr):
                raise TypeError("value must be a string or Attr object")
            node = value
            self.setNamedItem(node)

    def getNamedItem(self, name):
        try:
            return self._attrs[name]
        except KeyError:
            return None

    def getNamedItemNS(self, namespaceURI, localName):
        try:
            return self._attrsNS[(namespaceURI, localName)]
        except KeyError:
            return None

    def removeNamedItem(self, name):
        n = self.getNamedItem(name)
        if n is not None:
            _clear_id_cache(self._ownerElement)
            del self._attrs[n.nodeName]
            del self._attrsNS[(n.namespaceURI, n.localName)]
            if hasattr(n, 'ownerElement'):
                n.ownerElement = None
            return n
        else:
            raise xml.dom.NotFoundErr()

    def removeNamedItemNS(self, namespaceURI, localName):
        n = self.getNamedItemNS(namespaceURI, localName)
        if n is not None:
            _clear_id_cache(self._ownerElement)
            del self._attrsNS[(n.namespaceURI, n.localName)]
            del self._attrs[n.nodeName]
            if hasattr(n, 'ownerElement'):
                n.ownerElement = None
            return n
        else:
            raise xml.dom.NotFoundErr()

    def setNamedItem(self, node):
        if not isinstance(node, Attr):
            raise xml.dom.HierarchyRequestErr(
                "%s cannot be child of %s" % (repr(node), repr(self)))
        old = self._attrs.get(node.name)
        if old:
            old.unlink()
        self._attrs[node.name] = node
        self._attrsNS[(node.namespaceURI, node.localName)] = node
        node.ownerElement = self._ownerElement
        _clear_id_cache(node.ownerElement)
        return old

    def setNamedItemNS(self, node):
        return self.setNamedItem(node)

    def __delitem__(self, attname_or_tuple):
        node = self[attname_or_tuple]
        _clear_id_cache(node.ownerElement)
        node.unlink()

    def __getstate__(self):
        return self._attrs, self._attrsNS, self._ownerElement

    def __setstate__(self, state):
        self._attrs, self._attrsNS, self._ownerElement = state

defproperty(NamedNodeMap, "length",
            doc="Number of nodes in the NamedNodeMap.")

AttributeList = NamedNodeMap


class TypeInfo(object):
    __slots__ = 'namespace', 'name'

    def __init__(self, namespace, name):
        self.namespace = namespace
        self.name = name

    def __repr__(self):
        if self.namespace:
            return "<%s %r (from %r)>" % (self.__class__.__name__, self.name,
                                          self.namespace)
        else:
            return "<%s %r>" % (self.__class__.__name__, self.name)

    def _get_name(self):
        return self.name

    def _get_namespace(self):
        return self.namespace

_no_type = TypeInfo(None, None)

class Element(Node):
    __slots__=('ownerDocument', 'parentNode', 'tagName', 'nodeName', 'prefix',
               'namespaceURI', '_localName', 'childNodes', '_attrs', '_attrsNS',
               'nextSibling', 'previousSibling')
    nodeType = Node.ELEMENT_NODE
    nodeValue = None
    schemaType = _no_type

    _magic_id_nodes = 0

    _child_node_types = (Node.ELEMENT_NODE,
                         Node.PROCESSING_INSTRUCTION_NODE,
                         Node.COMMENT_NODE,
                         Node.TEXT_NODE,
                         Node.CDATA_SECTION_NODE,
                         Node.ENTITY_REFERENCE_NODE)

    def __init__(self, tagName, namespaceURI=EMPTY_NAMESPACE, prefix=None,
                 localName=None):
        self.parentNode = None
        self.tagName = self.nodeName = tagName
        self.prefix = prefix
        self.namespaceURI = namespaceURI
        self.childNodes = NodeList()
        self.nextSibling = self.previousSibling = None

        # Attribute dictionaries are lazily created
        # attributes are double-indexed:
        #    tagName -> Attribute
        #    URI,localName -> Attribute
        # in the future: consider lazy generation
        # of attribute objects this is too tricky
        # for now because of headaches with
        # namespaces.
        self._attrs = None
        self._attrsNS = None

    def _ensure_attributes(self):
        if self._attrs is None:
            self._attrs = {}
            self._attrsNS = {}

    def _get_localName(self):
        try:
            return self._localName
        except AttributeError:
            return self.tagName.split(":", 1)[-1]

    def _get_tagName(self):
        return self.tagName

    def unlink(self):
        if self._attrs is not None:
            for attr in list(self._attrs.values()):
                attr.unlink()
        self._attrs = None
        self._attrsNS = None
        Node.unlink(self)

    def getAttribute(self, attname):
        """Returns the value of the specified attribute.

        Returns the value of the element's attribute named attname as
        a string. An empty string is returned if the element does not
        have such an attribute. Note that an empty string may also be
        returned as an explicitly given attribute value, use the
        hasAttribute method to distinguish these two cases.
        """
        if self._attrs is None:
            return ""
        try:
            return self._attrs[attname].value
        except KeyError:
            return ""

    def getAttributeNS(self, namespaceURI, localName):
        if self._attrsNS is None:
            return ""
        try:
            return self._attrsNS[(namespaceURI, localName)].value
        except KeyError:
            return ""

    def setAttribute(self, attname, value):
        attr = self.getAttributeNode(attname)
        if attr is None:
            attr = Attr(attname)
            attr.value = value # also sets nodeValue
            attr.ownerDocument = self.ownerDocument
            self.setAttributeNode(attr)
        elif value != attr.value:
            attr.value = value
            if attr.isId:
                _clear_id_cache(self)

    def setAttributeNS(self, namespaceURI, qualifiedName, value):
        prefix, localname = _nssplit(qualifiedName)
        attr = self.getAttributeNodeNS(namespaceURI, localname)
        if attr is None:
            attr = Attr(qualifiedName, namespaceURI, localname, prefix)
            attr.value = value
            attr.ownerDocument = self.ownerDocument
            self.setAttributeNode(attr)
        else:
            if value != attr.value:
                attr.value = value
                if attr.isId:
                    _clear_id_cache(self)
            if attr.prefix != prefix:
                attr.prefix = prefix
                attr.nodeName = qualifiedName

    def getAttributeNode(self, attrname):
        if self._attrs is None:
            return None
        return self._attrs.get(attrname)

    def getAttributeNodeNS(self, namespaceURI, localName):
        if self._attrsNS is None:
            return None
        return self._attrsNS.get((namespaceURI, localName))

    def setAttributeNode(self, attr):
        if attr.ownerElement not in (None, self):
            raise xml.dom.InuseAttributeErr("attribute node already owned")
        self._ensure_attributes()
        old1 = self._attrs.get(attr.name, None)
        if old1 is not None:
            self.removeAttributeNode(old1)
        old2 = self._attrsNS.get((attr.namespaceURI, attr.localName), None)
        if old2 is not None and old2 is not old1:
            self.removeAttributeNode(old2)
        _set_attribute_node(self, attr)

        if old1 is not attr:
            # It might have already been part of this node, in which case
            # it doesn't represent a change, and should not be returned.
            return old1
        if old2 is not attr:
            return old2

    setAttributeNodeNS = setAttributeNode

    def removeAttribute(self, name):
        if self._attrsNS is None:
            raise xml.dom.NotFoundErr()
        try:
            attr = self._attrs[name]
        except KeyError:
            raise xml.dom.NotFoundErr()
        self.removeAttributeNode(attr)

    def removeAttributeNS(self, namespaceURI, localName):
        if self._attrsNS is None:
            raise xml.dom.NotFoundErr()
        try:
            attr = self._attrsNS[(namespaceURI, localName)]
        except KeyError:
            raise xml.dom.NotFoundErr()
        self.removeAttributeNode(attr)

    def removeAttributeNode(self, node):
        if node is None:
            raise xml.dom.NotFoundErr()
        try:
            self._attrs[node.name]
        except KeyError:
            raise xml.dom.NotFoundErr()
        _clear_id_cache(self)
        node.unlink()
        # Restore this since the node is still useful and otherwise
        # unlinked
        node.ownerDocument = self.ownerDocument
        return node

    removeAttributeNodeNS = removeAttributeNode

    def hasAttribute(self, name):
        """Checks whether the element has an attribute with the specified name.

        Returns True if the element has an attribute with the specified name.
        Otherwise, returns False.
        """
        if self._attrs is None:
            return False
        return name in self._attrs

    def hasAttributeNS(self, namespaceURI, localName):
        if self._attrsNS is None:
            return False
        return (namespaceURI, localName) in self._attrsNS

    def getElementsByTagName(self, name):
        """Returns all descendant elements with the given tag name.

        Returns the list of all descendant elements (not direct children
        only) with the specified tag name.
        """
        return _get_elements_by_tagName_helper(self, name, NodeList())

    def getElementsByTagNameNS(self, namespaceURI, localName):
        return _get_elements_by_tagName_ns_helper(
            self, namespaceURI, localName, NodeList())

    def __repr__(self):
        return "<DOM Element: %s at %#x>" % (self.tagName, id(self))

    def writexml(self, writer, indent="", addindent="", newl=""):
        """Write an XML element to a file-like object

        Write the element to the writer object that must provide
        a write method (e.g. a file or StringIO object).
        """
        # indent = current indentation
        # addindent = indentation to add to higher levels
        # newl = newline string
        writer.write(indent+"<" + self.tagName)

        attrs = self._get_attributes()

        for a_name in attrs.keys():
            writer.write(" %s=\"" % a_name)
            _write_data(writer, attrs[a_name].value)
            writer.write("\"")
        if self.childNodes:
            writer.write(">")
            if (len(self.childNodes) == 1 and
                self.childNodes[0].nodeType in (
                        Node.TEXT_NODE, Node.CDATA_SECTION_NODE)):
                self.childNodes[0].writexml(writer, '', '', '')
            else:
                writer.write(newl)
                for node in self.childNodes:
                    node.writexml(writer, indent+addindent, addindent, newl)
                writer.write(indent)
            writer.write("</%s>%s" % (self.tagName, newl))
        else:
            writer.write("/>%s"%(newl))

    def _get_attributes(self):
        self._ensure_attributes()
        return NamedNodeMap(self._attrs, self._attrsNS, self)

    def hasAttributes(self):
        if self._attrs:
            return True
        else:
            return False

    # DOM Level 3 attributes, based on the 22 Oct 2002 draft

    def setIdAttribute(self, name):
        idAttr = self.getAttributeNode(name)
        self.setIdAttributeNode(idAttr)

    def setIdAttributeNS(self, namespaceURI, localName):
        idAttr = self.getAttributeNodeNS(namespaceURI, localName)
        self.setIdAttributeNode(idAttr)

    def setIdAttributeNode(self, idAttr):
        if idAttr is None or not self.isSameNode(idAttr.ownerElement):
            raise xml.dom.NotFoundErr()
        if _get_containing_entref(self) is not None:
            raise xml.dom.NoModificationAllowedErr()
        if not idAttr._is_id:
            idAttr._is_id = True
            self._magic_id_nodes += 1
            self.ownerDocument._magic_id_count += 1
            _clear_id_cache(self)

defproperty(Element, "attributes",
            doc="NamedNodeMap of attributes on the element.")
defproperty(Element, "localName",
            doc="Namespace-local name of this element.")


def _set_attribute_node(element, attr):
    _clear_id_cache(element)
    element._ensure_attributes()
    element._attrs[attr.name] = attr
    element._attrsNS[(attr.namespaceURI, attr.localName)] = attr

    # This creates a circular reference, but Element.unlink()
    # breaks the cycle since the references to the attribute
    # dictionaries are tossed.
    attr.ownerElement = element

class Childless:
    """Mixin that makes childless-ness easy to implement and avoids
    the complexity of the Node methods that deal with children.
    """
    __slots__ = ()

    attributes = None
    childNodes = EmptyNodeList()
    firstChild = None
    lastChild = None

    def _get_firstChild(self):
        return None

    def _get_lastChild(self):
        return None

    def appendChild(self, node):
        raise xml.dom.HierarchyRequestErr(
            self.nodeName + " nodes cannot have children")

    def hasChildNodes(self):
        return False

    def insertBefore(self, newChild, refChild):
        raise xml.dom.HierarchyRequestErr(
            self.nodeName + " nodes do not have children")

    def removeChild(self, oldChild):
        raise xml.dom.NotFoundErr(
            self.nodeName + " nodes do not have children")

    def normalize(self):
        # For childless nodes, normalize() has nothing to do.
        pass

    def replaceChild(self, newChild, oldChild):
        raise xml.dom.HierarchyRequestErr(
            self.nodeName + " nodes do not have children")


class ProcessingInstruction(Childless, Node):
    nodeType = Node.PROCESSING_INSTRUCTION_NODE
    __slots__ = ('target', 'data')

    def __init__(self, target, data):
        self.target = target
        self.data = data

    # nodeValue is an alias for data
    def _get_nodeValue(self):
        return self.data
    def _set_nodeValue(self, value):
        self.data = value
    nodeValue = property(_get_nodeValue, _set_nodeValue)

    # nodeName is an alias for target
    def _get_nodeName(self):
        return self.target
    def _set_nodeName(self, value):
        self.target = value
    nodeName = property(_get_nodeName, _set_nodeName)

    def writexml(self, writer, indent="", addindent="", newl=""):
        writer.write("%s<?%s %s?>%s" % (indent,self.target, self.data, newl))


class CharacterData(Childless, Node):
    __slots__=('_data', 'ownerDocument','parentNode', 'previousSibling', 'nextSibling')

    def __init__(self):
        self.ownerDocument = self.parentNode = None
        self.previousSibling = self.nextSibling = None
        self._data = ''
        Node.__init__(self)

    def _get_length(self):
        return len(self.data)
    __len__ = _get_length

    def _get_data(self):
        return self._data
    def _set_data(self, data):
        self._data = data

    data = nodeValue = property(_get_data, _set_data)

    def __repr__(self):
        data = self.data
        if len(data) > 10:
            dotdotdot = "..."
        else:
            dotdotdot = ""
        return '<DOM %s node "%r%s">' % (
            self.__class__.__name__, data[0:10], dotdotdot)

    def substringData(self, offset, count):
        if offset < 0:
            raise xml.dom.IndexSizeErr("offset cannot be negative")
        if offset >= len(self.data):
            raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")
        if count < 0:
            raise xml.dom.IndexSizeErr("count cannot be negative")
        return self.data[offset:offset+count]

    def appendData(self, arg):
        self.data = self.data + arg

    def insertData(self, offset, arg):
        if offset < 0:
            raise xml.dom.IndexSizeErr("offset cannot be negative")
        if offset >= len(self.data):
            raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")
        if arg:
            self.data = "%s%s%s" % (
                self.data[:offset], arg, self.data[offset:])

    def deleteData(self, offset, count):
        if offset < 0:
            raise xml.dom.IndexSizeErr("offset cannot be negative")
        if offset >= len(self.data):
            raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")
        if count < 0:
            raise xml.dom.IndexSizeErr("count cannot be negative")
        if count:
            self.data = self.data[:offset] + self.data[offset+count:]

    def replaceData(self, offset, count, arg):
        if offset < 0:
            raise xml.dom.IndexSizeErr("offset cannot be negative")
        if offset >= len(self.data):
            raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")
        if count < 0:
            raise xml.dom.IndexSizeErr("count cannot be negative")
        if count:
            self.data = "%s%s%s" % (
                self.data[:offset], arg, self.data[offset+count:])

defproperty(CharacterData, "length", doc="Length of the string data.")


class Text(CharacterData):
    __slots__ = ()

    nodeType = Node.TEXT_NODE
    nodeName = "#text"
    attributes = None

    def splitText(self, offset):
        if offset < 0 or offset > len(self.data):
            raise xml.dom.IndexSizeErr("illegal offset value")
        newText = self.__class__()
        newText.data = self.data[offset:]
        newText.ownerDocument = self.ownerDocument
        next = self.nextSibling
        if self.parentNode and self in self.parentNode.childNodes:
            if next is None:
                self.parentNode.appendChild(newText)
            else:
                self.parentNode.insertBefore(newText, next)
        self.data = self.data[:offset]
        return newText

    def writexml(self, writer, indent="", addindent="", newl=""):
        _write_data(writer, "%s%s%s" % (indent, self.data, newl))

    # DOM Level 3 (WD 9 April 2002)

    def _get_wholeText(self):
        L = [self.data]
        n = self.previousSibling
        while n is not None:
            if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):
                L.insert(0, n.data)
                n = n.previousSibling
            else:
                break
        n = self.nextSibling
        while n is not None:
            if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):
                L.append(n.data)
                n = n.nextSibling
            else:
                break
        return ''.join(L)

    def replaceWholeText(self, content):
        # XXX This needs to be seriously changed if minidom ever
        # supports EntityReference nodes.
        parent = self.parentNode
        n = self.previousSibling
        while n is not None:
            if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):
                next = n.previousSibling
                parent.removeChild(n)
                n = next
            else:
                break
        n = self.nextSibling
        if not content:
            parent.removeChild(self)
        while n is not None:
            if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):
                next = n.nextSibling
                parent.removeChild(n)
                n = next
            else:
                break
        if content:
            self.data = content
            return self
        else:
            return None

    def _get_isWhitespaceInElementContent(self):
        if self.data.strip():
            return False
        elem = _get_containing_element(self)
        if elem is None:
            return False
        info = self.ownerDocument._get_elem_info(elem)
        if info is None:
            return False
        else:
            return info.isElementContent()

defproperty(Text, "isWhitespaceInElementContent",
            doc="True iff this text node contains only whitespace"
                " and is in element content.")
defproperty(Text, "wholeText",
            doc="The text of all logically-adjacent text nodes.")


def _get_containing_element(node):
    c = node.parentNode
    while c is not None:
        if c.nodeType == Node.ELEMENT_NODE:
            return c
        c = c.parentNode
    return None

def _get_containing_entref(node):
    c = node.parentNode
    while c is not None:
        if c.nodeType == Node.ENTITY_REFERENCE_NODE:
            return c
        c = c.parentNode
    return None


class Comment(CharacterData):
    nodeType = Node.COMMENT_NODE
    nodeName = "#comment"

    def __init__(self, data):
        CharacterData.__init__(self)
        self._data = data

    def writexml(self, writer, indent="", addindent="", newl=""):
        if "--" in self.data:
            raise ValueError("'--' is not allowed in a comment node")
        writer.write("%s<!--%s-->%s" % (indent, self.data, newl))


class CDATASection(Text):
    __slots__ = ()

    nodeType = Node.CDATA_SECTION_NODE
    nodeName = "#cdata-section"

    def writexml(self, writer, indent="", addindent="", newl=""):
        if self.data.find("]]>") >= 0:
            raise ValueError("']]>' not allowed in a CDATA section")
        writer.write("<![CDATA[%s]]>" % self.data)


class ReadOnlySequentialNamedNodeMap(object):
    __slots__ = '_seq',

    def __init__(self, seq=()):
        # seq should be a list or tuple
        self._seq = seq

    def __len__(self):
        return len(self._seq)

    def _get_length(self):
        return len(self._seq)

    def getNamedItem(self, name):
        for n in self._seq:
            if n.nodeName == name:
                return n

    def getNamedItemNS(self, namespaceURI, localName):
        for n in self._seq:
            if n.namespaceURI == namespaceURI and n.localName == localName:
                return n

    def __getitem__(self, name_or_tuple):
        if isinstance(name_or_tuple, tuple):
            node = self.getNamedItemNS(*name_or_tuple)
        else:
            node = self.getNamedItem(name_or_tuple)
        if node is None:
            raise KeyError(name_or_tuple)
        return node

    def item(self, index):
        if index < 0:
            return None
        try:
            return self._seq[index]
        except IndexError:
            return None

    def removeNamedItem(self, name):
        raise xml.dom.NoModificationAllowedErr(
            "NamedNodeMap instance is read-only")

    def removeNamedItemNS(self, namespaceURI, localName):
        raise xml.dom.NoModificationAllowedErr(
            "NamedNodeMap instance is read-only")

    def setNamedItem(self, node):
        raise xml.dom.NoModificationAllowedErr(
            "NamedNodeMap instance is read-only")

    def setNamedItemNS(self, node):
        raise xml.dom.NoModificationAllowedErr(
            "NamedNodeMap instance is read-only")

    def __getstate__(self):
        return [self._seq]

    def __setstate__(self, state):
        self._seq = state[0]

defproperty(ReadOnlySequentialNamedNodeMap, "length",
            doc="Number of entries in the NamedNodeMap.")


class Identified:
    """Mix-in class that supports the publicId and systemId attributes."""

    __slots__ = 'publicId', 'systemId'

    def _identified_mixin_init(self, publicId, systemId):
        self.publicId = publicId
        self.systemId = systemId

    def _get_publicId(self):
        return self.publicId

    def _get_systemId(self):
        return self.systemId

class DocumentType(Identified, Childless, Node):
    nodeType = Node.DOCUMENT_TYPE_NODE
    nodeValue = None
    name = None
    publicId = None
    systemId = None
    internalSubset = None

    def __init__(self, qualifiedName):
        self.entities = ReadOnlySequentialNamedNodeMap()
        self.notations = ReadOnlySequentialNamedNodeMap()
        if qualifiedName:
            prefix, localname = _nssplit(qualifiedName)
            self.name = localname
        self.nodeName = self.name

    def _get_internalSubset(self):
        return self.internalSubset

    def cloneNode(self, deep):
        if self.ownerDocument is None:
            # it's ok
            clone = DocumentType(None)
            clone.name = self.name
            clone.nodeName = self.name
            operation = xml.dom.UserDataHandler.NODE_CLONED
            if deep:
                clone.entities._seq = []
                clone.notations._seq = []
                for n in self.notations._seq:
                    notation = Notation(n.nodeName, n.publicId, n.systemId)
                    clone.notations._seq.append(notation)
                    n._call_user_data_handler(operation, n, notation)
                for e in self.entities._seq:
                    entity = Entity(e.nodeName, e.publicId, e.systemId,
                                    e.notationName)
                    entity.actualEncoding = e.actualEncoding
                    entity.encoding = e.encoding
                    entity.version = e.version
                    clone.entities._seq.append(entity)
                    e._call_user_data_handler(operation, e, entity)
            self._call_user_data_handler(operation, self, clone)
            return clone
        else:
            return None

    def writexml(self, writer, indent="", addindent="", newl=""):
        writer.write("<!DOCTYPE ")
        writer.write(self.name)
        if self.publicId:
            writer.write("%s  PUBLIC '%s'%s  '%s'"
                         % (newl, self.publicId, newl, self.systemId))
        elif self.systemId:
            writer.write("%s  SYSTEM '%s'" % (newl, self.systemId))
        if self.internalSubset is not None:
            writer.write(" [")
            writer.write(self.internalSubset)
            writer.write("]")
        writer.write(">"+newl)

class Entity(Identified, Node):
    attributes = None
    nodeType = Node.ENTITY_NODE
    nodeValue = None

    actualEncoding = None
    encoding = None
    version = None

    def __init__(self, name, publicId, systemId, notation):
        self.nodeName = name
        self.notationName = notation
        self.childNodes = NodeList()
        self._identified_mixin_init(publicId, systemId)

    def _get_actualEncoding(self):
        return self.actualEncoding

    def _get_encoding(self):
        return self.encoding

    def _get_version(self):
        return self.version

    def appendChild(self, newChild):
        raise xml.dom.HierarchyRequestErr(
            "cannot append children to an entity node")

    def insertBefore(self, newChild, refChild):
        raise xml.dom.HierarchyRequestErr(
            "cannot insert children below an entity node")

    def removeChild(self, oldChild):
        raise xml.dom.HierarchyRequestErr(
            "cannot remove children from an entity node")

    def replaceChild(self, newChild, oldChild):
        raise xml.dom.HierarchyRequestErr(
            "cannot replace children of an entity node")

class Notation(Identified, Childless, Node):
    nodeType = Node.NOTATION_NODE
    nodeValue = None

    def __init__(self, name, publicId, systemId):
        self.nodeName = name
        self._identified_mixin_init(publicId, systemId)


class DOMImplementation(DOMImplementationLS):
    _features = [("core", "1.0"),
                 ("core", "2.0"),
                 ("core", None),
                 ("xml", "1.0"),
                 ("xml", "2.0"),
                 ("xml", None),
                 ("ls-load", "3.0"),
                 ("ls-load", None),
                 ]

    def hasFeature(self, feature, version):
        if version == "":
            version = None
        return (feature.lower(), version) in self._features

    def createDocument(self, namespaceURI, qualifiedName, doctype):
        if doctype and doctype.parentNode is not None:
            raise xml.dom.WrongDocumentErr(
                "doctype object owned by another DOM tree")
        doc = self._create_document()

        add_root_element = not (namespaceURI is None
                                and qualifiedName is None
                                and doctype is None)

        if not qualifiedName and add_root_element:
            # The spec is unclear what to raise here; SyntaxErr
            # would be the other obvious candidate. Since Xerces raises
            # InvalidCharacterErr, and since SyntaxErr is not listed
            # for createDocument, that seems to be the better choice.
            # XXX: need to check for illegal characters here and in
            # createElement.

            # DOM Level III clears this up when talking about the return value
            # of this function.  If namespaceURI, qName and DocType are
            # Null the document is returned without a document element
            # Otherwise if doctype or namespaceURI are not None
            # Then we go back to the above problem
            raise xml.dom.InvalidCharacterErr("Element with no name")

        if add_root_element:
            prefix, localname = _nssplit(qualifiedName)
            if prefix == "xml" \
               and namespaceURI != "http://www.w3.org/XML/1998/namespace":
                raise xml.dom.NamespaceErr("illegal use of 'xml' prefix")
            if prefix and not namespaceURI:
                raise xml.dom.NamespaceErr(
                    "illegal use of prefix without namespaces")
            element = doc.createElementNS(namespaceURI, qualifiedName)
            if doctype:
                doc.appendChild(doctype)
            doc.appendChild(element)

        if doctype:
            doctype.parentNode = doctype.ownerDocument = doc

        doc.doctype = doctype
        doc.implementation = self
        return doc

    def createDocumentType(self, qualifiedName, publicId, systemId):
        doctype = DocumentType(qualifiedName)
        doctype.publicId = publicId
        doctype.systemId = systemId
        return doctype

    # DOM Level 3 (WD 9 April 2002)

    def getInterface(self, feature):
        if self.hasFeature(feature, None):
            return self
        else:
            return None

    # internal
    def _create_document(self):
        return Document()

class ElementInfo(object):
    """Object that represents content-model information for an element.

    This implementation is not expected to be used in practice; DOM
    builders should provide implementations which do the right thing
    using information available to it.

    """

    __slots__ = 'tagName',

    def __init__(self, name):
        self.tagName = name

    def getAttributeType(self, aname):
        return _no_type

    def getAttributeTypeNS(self, namespaceURI, localName):
        return _no_type

    def isElementContent(self):
        return False

    def isEmpty(self):
        """Returns true iff this element is declared to have an EMPTY
        content model."""
        return False

    def isId(self, aname):
        """Returns true iff the named attribute is a DTD-style ID."""
        return False

    def isIdNS(self, namespaceURI, localName):
        """Returns true iff the identified attribute is a DTD-style ID."""
        return False

    def __getstate__(self):
        return self.tagName

    def __setstate__(self, state):
        self.tagName = state

def _clear_id_cache(node):
    if node.nodeType == Node.DOCUMENT_NODE:
        node._id_cache.clear()
        node._id_search_stack = None
    elif _in_document(node):
        node.ownerDocument._id_cache.clear()
        node.ownerDocument._id_search_stack= None

class Document(Node, DocumentLS):
    __slots__ = ('_elem_info', 'doctype',
                 '_id_search_stack', 'childNodes', '_id_cache')
    _child_node_types = (Node.ELEMENT_NODE, Node.PROCESSING_INSTRUCTION_NODE,
                         Node.COMMENT_NODE, Node.DOCUMENT_TYPE_NODE)

    implementation = DOMImplementation()
    nodeType = Node.DOCUMENT_NODE
    nodeName = "#document"
    nodeValue = None
    attributes = None
    parentNode = None
    previousSibling = nextSibling = None


    # Document attributes from Level 3 (WD 9 April 2002)

    actualEncoding = None
    encoding = None
    standalone = None
    version = None
    strictErrorChecking = False
    errorHandler = None
    documentURI = None

    _magic_id_count = 0

    def __init__(self):
        self.doctype = None
        self.childNodes = NodeList()
        # mapping of (namespaceURI, localName) -> ElementInfo
        #        and tagName -> ElementInfo
        self._elem_info = {}
        self._id_cache = {}
        self._id_search_stack = None

    def _get_elem_info(self, element):
        if element.namespaceURI:
            key = element.namespaceURI, element.localName
        else:
            key = element.tagName
        return self._elem_info.get(key)

    def _get_actualEncoding(self):
        return self.actualEncoding

    def _get_doctype(self):
        return self.doctype

    def _get_documentURI(self):
        return self.documentURI

    def _get_encoding(self):
        return self.encoding

    def _get_errorHandler(self):
        return self.errorHandler

    def _get_standalone(self):
        return self.standalone

    def _get_strictErrorChecking(self):
        return self.strictErrorChecking

    def _get_version(self):
        return self.version

    def appendChild(self, node):
        if node.nodeType not in self._child_node_types:
            raise xml.dom.HierarchyRequestErr(
                "%s cannot be child of %s" % (repr(node), repr(self)))
        if node.parentNode is not None:
            # This needs to be done before the next test since this
            # may *be* the document element, in which case it should
            # end up re-ordered to the end.
            node.parentNode.removeChild(node)

        if node.nodeType == Node.ELEMENT_NODE \
           and self._get_documentElement():
            raise xml.dom.HierarchyRequestErr(
                "two document elements disallowed")
        return Node.appendChild(self, node)

    def removeChild(self, oldChild):
        try:
            self.childNodes.remove(oldChild)
        except ValueError:
            raise xml.dom.NotFoundErr()
        oldChild.nextSibling = oldChild.previousSibling = None
        oldChild.parentNode = None
        if self.documentElement is oldChild:
            self.documentElement = None

        return oldChild

    def _get_documentElement(self):
        for node in self.childNodes:
            if node.nodeType == Node.ELEMENT_NODE:
                return node

    def unlink(self):
        if self.doctype is not None:
            self.doctype.unlink()
            self.doctype = None
        Node.unlink(self)

    def cloneNode(self, deep):
        if not deep:
            return None
        clone = self.implementation.createDocument(None, None, None)
        clone.encoding = self.encoding
        clone.standalone = self.standalone
        clone.version = self.version
        for n in self.childNodes:
            childclone = _clone_node(n, deep, clone)
            assert childclone.ownerDocument.isSameNode(clone)
            clone.childNodes.append(childclone)
            if childclone.nodeType == Node.DOCUMENT_NODE:
                assert clone.documentElement is None
            elif childclone.nodeType == Node.DOCUMENT_TYPE_NODE:
                assert clone.doctype is None
                clone.doctype = childclone
            childclone.parentNode = clone
        self._call_user_data_handler(xml.dom.UserDataHandler.NODE_CLONED,
                                     self, clone)
        return clone

    def createDocumentFragment(self):
        d = DocumentFragment()
        d.ownerDocument = self
        return d

    def createElement(self, tagName):
        e = Element(tagName)
        e.ownerDocument = self
        return e

    def createTextNode(self, data):
        if not isinstance(data, str):
            raise TypeError("node contents must be a string")
        t = Text()
        t.data = data
        t.ownerDocument = self
        return t

    def createCDATASection(self, data):
        if not isinstance(data, str):
            raise TypeError("node contents must be a string")
        c = CDATASection()
        c.data = data
        c.ownerDocument = self
        return c

    def createComment(self, data):
        c = Comment(data)
        c.ownerDocument = self
        return c

    def createProcessingInstruction(self, target, data):
        p = ProcessingInstruction(target, data)
        p.ownerDocument = self
        return p

    def createAttribute(self, qName):
        a = Attr(qName)
        a.ownerDocument = self
        a.value = ""
        return a

    def createElementNS(self, namespaceURI, qualifiedName):
        prefix, localName = _nssplit(qualifiedName)
        e = Element(qualifiedName, namespaceURI, prefix)
        e.ownerDocument = self
        return e

    def createAttributeNS(self, namespaceURI, qualifiedName):
        prefix, localName = _nssplit(qualifiedName)
        a = Attr(qualifiedName, namespaceURI, localName, prefix)
        a.ownerDocument = self
        a.value = ""
        return a

    # A couple of implementation-specific helpers to create node types
    # not supported by the W3C DOM specs:

    def _create_entity(self, name, publicId, systemId, notationName):
        e = Entity(name, publicId, systemId, notationName)
        e.ownerDocument = self
        return e

    def _create_notation(self, name, publicId, systemId):
        n = Notation(name, publicId, systemId)
        n.ownerDocument = self
        return n

    def getElementById(self, id):
        if id in self._id_cache:
            return self._id_cache[id]
        if not (self._elem_info or self._magic_id_count):
            return None

        stack = self._id_search_stack
        if stack is None:
            # we never searched before, or the cache has been cleared
            stack = [self.documentElement]
            self._id_search_stack = stack
        elif not stack:
            # Previous search was completed and cache is still valid;
            # no matching node.
            return None

        result = None
        while stack:
            node = stack.pop()
            # add child elements to stack for continued searching
            stack.extend([child for child in node.childNodes
                          if child.nodeType in _nodeTypes_with_children])
            # check this node
            info = self._get_elem_info(node)
            if info:
                # We have to process all ID attributes before
                # returning in order to get all the attributes set to
                # be IDs using Element.setIdAttribute*().
                for attr in node.attributes.values():
                    if attr.namespaceURI:
                        if info.isIdNS(attr.namespaceURI, attr.localName):
                            self._id_cache[attr.value] = node
                            if attr.value == id:
                                result = node
                            elif not node._magic_id_nodes:
                                break
                    elif info.isId(attr.name):
                        self._id_cache[attr.value] = node
                        if attr.value == id:
                            result = node
                        elif not node._magic_id_nodes:
                            break
                    elif attr._is_id:
                        self._id_cache[attr.value] = node
                        if attr.value == id:
                            result = node
                        elif node._magic_id_nodes == 1:
                            break
            elif node._magic_id_nodes:
                for attr in node.attributes.values():
                    if attr._is_id:
                        self._id_cache[attr.value] = node
                        if attr.value == id:
                            result = node
            if result is not None:
                break
        return result

    def getElementsByTagName(self, name):
        return _get_elements_by_tagName_helper(self, name, NodeList())

    def getElementsByTagNameNS(self, namespaceURI, localName):
        return _get_elements_by_tagName_ns_helper(
            self, namespaceURI, localName, NodeList())

    def isSupported(self, feature, version):
        return self.implementation.hasFeature(feature, version)

    def importNode(self, node, deep):
        if node.nodeType == Node.DOCUMENT_NODE:
            raise xml.dom.NotSupportedErr("cannot import document nodes")
        elif node.nodeType == Node.DOCUMENT_TYPE_NODE:
            raise xml.dom.NotSupportedErr("cannot import document type nodes")
        return _clone_node(node, deep, self)

    def writexml(self, writer, indent="", addindent="", newl="", encoding=None,
                 standalone=None):
        declarations = []

        if encoding:
            declarations.append(f'encoding="{encoding}"')
        if standalone is not None:
            declarations.append(f'standalone="{"yes" if standalone else "no"}"')

        writer.write(f'<?xml version="1.0" {" ".join(declarations)}?>{newl}')

        for node in self.childNodes:
            node.writexml(writer, indent, addindent, newl)

    # DOM Level 3 (WD 9 April 2002)

    def renameNode(self, n, namespaceURI, name):
        if n.ownerDocument is not self:
            raise xml.dom.WrongDocumentErr(
                "cannot rename nodes from other documents;\n"
                "expected %s,\nfound %s" % (self, n.ownerDocument))
        if n.nodeType not in (Node.ELEMENT_NODE, Node.ATTRIBUTE_NODE):
            raise xml.dom.NotSupportedErr(
                "renameNode() only applies to element and attribute nodes")
        if namespaceURI != EMPTY_NAMESPACE:
            if ':' in name:
                prefix, localName = name.split(':', 1)
                if (  prefix == "xmlns"
                      and namespaceURI != xml.dom.XMLNS_NAMESPACE):
                    raise xml.dom.NamespaceErr(
                        "illegal use of 'xmlns' prefix")
            else:
                if (  name == "xmlns"
                      and namespaceURI != xml.dom.XMLNS_NAMESPACE
                      and n.nodeType == Node.ATTRIBUTE_NODE):
                    raise xml.dom.NamespaceErr(
                        "illegal use of the 'xmlns' attribute")
                prefix = None
                localName = name
        else:
            prefix = None
            localName = None
        if n.nodeType == Node.ATTRIBUTE_NODE:
            element = n.ownerElement
            if element is not None:
                is_id = n._is_id
                element.removeAttributeNode(n)
        else:
            element = None
        n.prefix = prefix
        n._localName = localName
        n.namespaceURI = namespaceURI
        n.nodeName = name
        if n.nodeType == Node.ELEMENT_NODE:
            n.tagName = name
        else:
            # attribute node
            n.name = name
            if element is not None:
                element.setAttributeNode(n)
                if is_id:
                    element.setIdAttributeNode(n)
        # It's not clear from a semantic perspective whether we should
        # call the user data handlers for the NODE_RENAMED event since
        # we're re-using the existing node.  The draft spec has been
        # interpreted as meaning "no, don't call the handler unless a
        # new node is created."
        return n

defproperty(Document, "documentElement",
            doc="Top-level element of this document.")


def _clone_node(node, deep, newOwnerDocument):
    """
    Clone a node and give it the new owner document.
    Called by Node.cloneNode and Document.importNode
    """
    if node.ownerDocument.isSameNode(newOwnerDocument):
        operation = xml.dom.UserDataHandler.NODE_CLONED
    else:
        operation = xml.dom.UserDataHandler.NODE_IMPORTED
    if node.nodeType == Node.ELEMENT_NODE:
        clone = newOwnerDocument.createElementNS(node.namespaceURI,
                                                 node.nodeName)
        for attr in node.attributes.values():
            clone.setAttributeNS(attr.namespaceURI, attr.nodeName, attr.value)
            a = clone.getAttributeNodeNS(attr.namespaceURI, attr.localName)
            a.specified = attr.specified

        if deep:
            for child in node.childNodes:
                c = _clone_node(child, deep, newOwnerDocument)
                clone.appendChild(c)

    elif node.nodeType == Node.DOCUMENT_FRAGMENT_NODE:
        clone = newOwnerDocument.createDocumentFragment()
        if deep:
            for child in node.childNodes:
                c = _clone_node(child, deep, newOwnerDocument)
                clone.appendChild(c)

    elif node.nodeType == Node.TEXT_NODE:
        clone = newOwnerDocument.createTextNode(node.data)
    elif node.nodeType == Node.CDATA_SECTION_NODE:
        clone = newOwnerDocument.createCDATASection(node.data)
    elif node.nodeType == Node.PROCESSING_INSTRUCTION_NODE:
        clone = newOwnerDocument.createProcessingInstruction(node.target,
                                                             node.data)
    elif node.nodeType == Node.COMMENT_NODE:
        clone = newOwnerDocument.createComment(node.data)
    elif node.nodeType == Node.ATTRIBUTE_NODE:
        clone = newOwnerDocument.createAttributeNS(node.namespaceURI,
                                                   node.nodeName)
        clone.specified = True
        clone.value = node.value
    elif node.nodeType == Node.DOCUMENT_TYPE_NODE:
        assert node.ownerDocument is not newOwnerDocument
        operation = xml.dom.UserDataHandler.NODE_IMPORTED
        clone = newOwnerDocument.implementation.createDocumentType(
            node.name, node.publicId, node.systemId)
        clone.ownerDocument = newOwnerDocument
        if deep:
            clone.entities._seq = []
            clone.notations._seq = []
            for n in node.notations._seq:
                notation = Notation(n.nodeName, n.publicId, n.systemId)
                notation.ownerDocument = newOwnerDocument
                clone.notations._seq.append(notation)
                if hasattr(n, '_call_user_data_handler'):
                    n._call_user_data_handler(operation, n, notation)
            for e in node.entities._seq:
                entity = Entity(e.nodeName, e.publicId, e.systemId,
                                e.notationName)
                entity.actualEncoding = e.actualEncoding
                entity.encoding = e.encoding
                entity.version = e.version
                entity.ownerDocument = newOwnerDocument
                clone.entities._seq.append(entity)
                if hasattr(e, '_call_user_data_handler'):
                    e._call_user_data_handler(operation, e, entity)
    else:
        # Note the cloning of Document and DocumentType nodes is
        # implementation specific.  minidom handles those cases
        # directly in the cloneNode() methods.
        raise xml.dom.NotSupportedErr("Cannot clone node %s" % repr(node))

    # Check for _call_user_data_handler() since this could conceivably
    # used with other DOM implementations (one of the FourThought
    # DOMs, perhaps?).
    if hasattr(node, '_call_user_data_handler'):
        node._call_user_data_handler(operation, node, clone)
    return clone


def _nssplit(qualifiedName):
    fields = qualifiedName.split(':', 1)
    if len(fields) == 2:
        return fields
    else:
        return (None, fields[0])


def _do_pulldom_parse(func, args, kwargs):
    events = func(*args, **kwargs)
    toktype, rootNode = events.getEvent()
    events.expandNode(rootNode)
    events.clear()
    return rootNode

def parse(file, parser=None, bufsize=None):
    """Parse a file into a DOM by filename or file object."""
    if parser is None and not bufsize:
        from xml.dom import expatbuilder
        return expatbuilder.parse(file)
    else:
        from xml.dom import pulldom
        return _do_pulldom_parse(pulldom.parse, (file,),
            {'parser': parser, 'bufsize': bufsize})

def parseString(string, parser=None):
    """Parse a file into a DOM from a string."""
    if parser is None:
        from xml.dom import expatbuilder
        return expatbuilder.parseString(string)
    else:
        from xml.dom import pulldom
        return _do_pulldom_parse(pulldom.parseString, (string,),
                                 {'parser': parser})

def getDOMImplementation(features=None):
    if features:
        if isinstance(features, str):
            features = domreg._parse_feature_string(features)
        for f, v in features:
            if not Document.implementation.hasFeature(f, v):
                return None
    return Document.implementation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    """Lightweight XML support for Python.

 XML is an inherently hierarchical data format, and the most natural way to
 represent it is with a tree.  This module has two classes for this purpose:

    1. ElementTree represents the whole XML document as a tree and

    2. Element represents a single node in this tree.

 Interactions with the whole document (reading and writing to/from files) are
 usually done on the ElementTree level.  Interactions with a single XML element
 and its sub-elements are done on the Element level.

 Element is a flexible container object designed to store hierarchical data
 structures in memory. It can be described as a cross between a list and a
 dictionary.  Each Element has a number of properties associated with it:

    'tag' - a string containing the element's name.

    'attributes' - a Python dictionary storing the element's attributes.

    'text' - a string containing the element's text content.

    'tail' - an optional string containing text after the element's end tag.

    And a number of child elements stored in a Python sequence.

 To create an element instance, use the Element constructor,
 or the SubElement factory function.

 You can also use the ElementTree class to wrap an element structure
 and convert it to and from XML.

"""

#---------------------------------------------------------------------
# Licensed to PSF under a Contributor Agreement.
# See https://www.python.org/psf/license for licensing details.
#
# ElementTree
# Copyright (c) 1999-2008 by Fredrik Lundh.  All rights reserved.
#
# fredrik@pythonware.com
# http://www.pythonware.com
# --------------------------------------------------------------------
# The ElementTree toolkit is
#
# Copyright (c) 1999-2008 by Fredrik Lundh
#
# By obtaining, using, and/or copying this software and/or its
# associated documentation, you agree that you have read, understood,
# and will comply with the following terms and conditions:
#
# Permission to use, copy, modify, and distribute this software and
# its associated documentation for any purpose and without fee is
# hereby granted, provided that the above copyright notice appears in
# all copies, and that both that copyright notice and this permission
# notice appear in supporting documentation, and that the name of
# Secret Labs AB or the author not be used in advertising or publicity
# pertaining to distribution of the software without specific, written
# prior permission.
#
# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
# ABILITY AND FITNESS.  IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
# OF THIS SOFTWARE.
# --------------------------------------------------------------------

__all__ = [
    # public symbols
    "Comment",
    "dump",
    "Element", "ElementTree",
    "fromstring", "fromstringlist",
    "indent", "iselement", "iterparse",
    "parse", "ParseError",
    "PI", "ProcessingInstruction",
    "QName",
    "SubElement",
    "tostring", "tostringlist",
    "TreeBuilder",
    "VERSION",
    "XML", "XMLID",
    "XMLParser", "XMLPullParser",
    "register_namespace",
    "canonicalize", "C14NWriterTarget",
    ]

VERSION = "1.3.0"

import sys
import re
import warnings
import io
import collections
import collections.abc
import contextlib

from . import ElementPath


class ParseError(SyntaxError):
    """An error when parsing an XML document.

    In addition to its exception value, a ParseError contains
    two extra attributes:
        'code'     - the specific exception code
        'position' - the line and column of the error

    """
    pass

# --------------------------------------------------------------------


def iselement(element):
    """Return True if *element* appears to be an Element."""
    return hasattr(element, 'tag')


class Element:
    """An XML element.

    This class is the reference implementation of the Element interface.

    An element's length is its number of subelements.  That means if you
    want to check if an element is truly empty, you should check BOTH
    its length AND its text attribute.

    The element tag, attribute names, and attribute values can be either
    bytes or strings.

    *tag* is the element name.  *attrib* is an optional dictionary containing
    element attributes. *extra* are additional element attributes given as
    keyword arguments.

    Example form:
        <tag attrib>text<child/>...</tag>tail

    """

    tag = None
    """The element's name."""

    attrib = None
    """Dictionary of the element's attributes."""

    text = None
    """
    Text before first subelement. This is either a string or the value None.
    Note that if there is no text, this attribute may be either
    None or the empty string, depending on the parser.

    """

    tail = None
    """
    Text after this element's end tag, but before the next sibling element's
    start tag.  This is either a string or the value None.  Note that if there
    was no text, this attribute may be either None or an empty string,
    depending on the parser.

    """

    def __init__(self, tag, attrib={}, **extra):
        if not isinstance(attrib, dict):
            raise TypeError("attrib must be dict, not %s" % (
                attrib.__class__.__name__,))
        self.tag = tag
        self.attrib = {**attrib, **extra}
        self._children = []

    def __repr__(self):
        return "<%s %r at %#x>" % (self.__class__.__name__, self.tag, id(self))

    def makeelement(self, tag, attrib):
        """Create a new element with the same type.

        *tag* is a string containing the element name.
        *attrib* is a dictionary containing the element attributes.

        Do not call this method, use the SubElement factory function instead.

        """
        return self.__class__(tag, attrib)

    def copy(self):
        """Return copy of current element.

        This creates a shallow copy. Subelements will be shared with the
        original tree.

        """
        warnings.warn(
            "elem.copy() is deprecated. Use copy.copy(elem) instead.",
            DeprecationWarning
            )
        return self.__copy__()

    def __copy__(self):
        elem = self.makeelement(self.tag, self.attrib)
        elem.text = self.text
        elem.tail = self.tail
        elem[:] = self
        return elem

    def __len__(self):
        return len(self._children)

    def __bool__(self):
        warnings.warn(
            "The behavior of this method will change in future versions.  "
            "Use specific 'len(elem)' or 'elem is not None' test instead.",
            FutureWarning, stacklevel=2
            )
        return len(self._children) != 0 # emulate old behaviour, for now

    def __getitem__(self, index):
        return self._children[index]

    def __setitem__(self, index, element):
        if isinstance(index, slice):
            for elt in element:
                self._assert_is_element(elt)
        else:
            self._assert_is_element(element)
        self._children[index] = element

    def __delitem__(self, index):
        del self._children[index]

    def append(self, subelement):
        """Add *subelement* to the end of this element.

        The new element will appear in document order after the last existing
        subelement (or directly after the text, if it's the first subelement),
        but before the end tag for this element.

        """
        self._assert_is_element(subelement)
        self._children.append(subelement)

    def extend(self, elements):
        """Append subelements from a sequence.

        *elements* is a sequence with zero or more elements.

        """
        for element in elements:
            self._assert_is_element(element)
            self._children.append(element)

    def insert(self, index, subelement):
        """Insert *subelement* at position *index*."""
        self._assert_is_element(subelement)
        self._children.insert(index, subelement)

    def _assert_is_element(self, e):
        # Need to refer to the actual Python implementation, not the
        # shadowing C implementation.
        if not isinstance(e, _Element_Py):
            raise TypeError('expected an Element, not %s' % type(e).__name__)

    def remove(self, subelement):
        """Remove matching subelement.

        Unlike the find methods, this method compares elements based on
        identity, NOT ON tag value or contents.  To remove subelements by
        other means, the easiest way is to use a list comprehension to
        select what elements to keep, and then use slice assignment to update
        the parent element.

        ValueError is raised if a matching element could not be found.

        """
        # assert iselement(element)
        self._children.remove(subelement)

    def find(self, path, namespaces=None):
        """Find first matching element by tag name or path.

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return the first matching element, or None if no element was found.

        """
        return ElementPath.find(self, path, namespaces)

    def findtext(self, path, default=None, namespaces=None):
        """Find text for first matching element by tag name or path.

        *path* is a string having either an element tag or an XPath,
        *default* is the value to return if the element was not found,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return text content of first matching element, or default value if
        none was found.  Note that if an element is found having no text
        content, the empty string is returned.

        """
        return ElementPath.findtext(self, path, default, namespaces)

    def findall(self, path, namespaces=None):
        """Find all matching subelements by tag name or path.

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Returns list containing all matching elements in document order.

        """
        return ElementPath.findall(self, path, namespaces)

    def iterfind(self, path, namespaces=None):
        """Find all matching subelements by tag name or path.

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return an iterable yielding all matching elements in document order.

        """
        return ElementPath.iterfind(self, path, namespaces)

    def clear(self):
        """Reset element.

        This function removes all subelements, clears all attributes, and sets
        the text and tail attributes to None.

        """
        self.attrib.clear()
        self._children = []
        self.text = self.tail = None

    def get(self, key, default=None):
        """Get element attribute.

        Equivalent to attrib.get, but some implementations may handle this a
        bit more efficiently.  *key* is what attribute to look for, and
        *default* is what to return if the attribute was not found.

        Returns a string containing the attribute value, or the default if
        attribute was not found.

        """
        return self.attrib.get(key, default)

    def set(self, key, value):
        """Set element attribute.

        Equivalent to attrib[key] = value, but some implementations may handle
        this a bit more efficiently.  *key* is what attribute to set, and
        *value* is the attribute value to set it to.

        """
        self.attrib[key] = value

    def keys(self):
        """Get list of attribute names.

        Names are returned in an arbitrary order, just like an ordinary
        Python dict.  Equivalent to attrib.keys()

        """
        return self.attrib.keys()

    def items(self):
        """Get element attributes as a sequence.

        The attributes are returned in arbitrary order.  Equivalent to
        attrib.items().

        Return a list of (name, value) tuples.

        """
        return self.attrib.items()

    def iter(self, tag=None):
        """Create tree iterator.

        The iterator loops over the element and all subelements in document
        order, returning all elements with a matching tag.

        If the tree structure is modified during iteration, new or removed
        elements may or may not be included.  To get a stable set, use the
        list() function on the iterator, and loop over the resulting list.

        *tag* is what tags to look for (default is to return all elements)

        Return an iterator containing all the matching elements.

        """
        if tag == "*":
            tag = None
        if tag is None or self.tag == tag:
            yield self
        for e in self._children:
            yield from e.iter(tag)

    def itertext(self):
        """Create text iterator.

        The iterator loops over the element and all subelements in document
        order, returning all inner text.

        """
        tag = self.tag
        if not isinstance(tag, str) and tag is not None:
            return
        t = self.text
        if t:
            yield t
        for e in self:
            yield from e.itertext()
            t = e.tail
            if t:
                yield t


def SubElement(parent, tag, attrib={}, **extra):
    """Subelement factory which creates an element instance, and appends it
    to an existing parent.

    The element tag, attribute names, and attribute values can be either
    bytes or Unicode strings.

    *parent* is the parent element, *tag* is the subelements name, *attrib* is
    an optional directory containing element attributes, *extra* are
    additional attributes given as keyword arguments.

    """
    attrib = {**attrib, **extra}
    element = parent.makeelement(tag, attrib)
    parent.append(element)
    return element


def Comment(text=None):
    """Comment element factory.

    This function creates a special element which the standard serializer
    serializes as an XML comment.

    *text* is a string containing the comment string.

    """
    element = Element(Comment)
    element.text = text
    return element


def ProcessingInstruction(target, text=None):
    """Processing Instruction element factory.

    This function creates a special element which the standard serializer
    serializes as an XML comment.

    *target* is a string containing the processing instruction, *text* is a
    string containing the processing instruction contents, if any.

    """
    element = Element(ProcessingInstruction)
    element.text = target
    if text:
        element.text = element.text + " " + text
    return element

PI = ProcessingInstruction


class QName:
    """Qualified name wrapper.

    This class can be used to wrap a QName attribute value in order to get
    proper namespace handing on output.

    *text_or_uri* is a string containing the QName value either in the form
    {uri}local, or if the tag argument is given, the URI part of a QName.

    *tag* is an optional argument which if given, will make the first
    argument (text_or_uri) be interpreted as a URI, and this argument (tag)
    be interpreted as a local name.

    """
    def __init__(self, text_or_uri, tag=None):
        if tag:
            text_or_uri = "{%s}%s" % (text_or_uri, tag)
        self.text = text_or_uri
    def __str__(self):
        return self.text
    def __repr__(self):
        return '<%s %r>' % (self.__class__.__name__, self.text)
    def __hash__(self):
        return hash(self.text)
    def __le__(self, other):
        if isinstance(other, QName):
            return self.text <= other.text
        return self.text <= other
    def __lt__(self, other):
        if isinstance(other, QName):
            return self.text < other.text
        return self.text < other
    def __ge__(self, other):
        if isinstance(other, QName):
            return self.text >= other.text
        return self.text >= other
    def __gt__(self, other):
        if isinstance(other, QName):
            return self.text > other.text
        return self.text > other
    def __eq__(self, other):
        if isinstance(other, QName):
            return self.text == other.text
        return self.text == other

# --------------------------------------------------------------------


class ElementTree:
    """An XML element hierarchy.

    This class also provides support for serialization to and from
    standard XML.

    *element* is an optional root element node,
    *file* is an optional file handle or file name of an XML file whose
    contents will be used to initialize the tree with.

    """
    def __init__(self, element=None, file=None):
        # assert element is None or iselement(element)
        self._root = element # first node
        if file:
            self.parse(file)

    def getroot(self):
        """Return root element of this tree."""
        return self._root

    def _setroot(self, element):
        """Replace root element of this tree.

        This will discard the current contents of the tree and replace it
        with the given element.  Use with care!

        """
        # assert iselement(element)
        self._root = element

    def parse(self, source, parser=None):
        """Load external XML document into element tree.

        *source* is a file name or file object, *parser* is an optional parser
        instance that defaults to XMLParser.

        ParseError is raised if the parser fails to parse the document.

        Returns the root element of the given source document.

        """
        close_source = False
        if not hasattr(source, "read"):
            source = open(source, "rb")
            close_source = True
        try:
            if parser is None:
                # If no parser was specified, create a default XMLParser
                parser = XMLParser()
                if hasattr(parser, '_parse_whole'):
                    # The default XMLParser, when it comes from an accelerator,
                    # can define an internal _parse_whole API for efficiency.
                    # It can be used to parse the whole source without feeding
                    # it with chunks.
                    self._root = parser._parse_whole(source)
                    return self._root
            while True:
                data = source.read(65536)
                if not data:
                    break
                parser.feed(data)
            self._root = parser.close()
            return self._root
        finally:
            if close_source:
                source.close()

    def iter(self, tag=None):
        """Create and return tree iterator for the root element.

        The iterator loops over all elements in this tree, in document order.

        *tag* is a string with the tag name to iterate over
        (default is to return all elements).

        """
        # assert self._root is not None
        return self._root.iter(tag)

    def find(self, path, namespaces=None):
        """Find first matching element by tag name or path.

        Same as getroot().find(path), which is Element.find()

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return the first matching element, or None if no element was found.

        """
        # assert self._root is not None
        if path[:1] == "/":
            path = "." + path
            warnings.warn(
                "This search is broken in 1.3 and earlier, and will be "
                "fixed in a future version.  If you rely on the current "
                "behaviour, change it to %r" % path,
                FutureWarning, stacklevel=2
                )
        return self._root.find(path, namespaces)

    def findtext(self, path, default=None, namespaces=None):
        """Find first matching element by tag name or path.

        Same as getroot().findtext(path),  which is Element.findtext()

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return the first matching element, or None if no element was found.

        """
        # assert self._root is not None
        if path[:1] == "/":
            path = "." + path
            warnings.warn(
                "This search is broken in 1.3 and earlier, and will be "
                "fixed in a future version.  If you rely on the current "
                "behaviour, change it to %r" % path,
                FutureWarning, stacklevel=2
                )
        return self._root.findtext(path, default, namespaces)

    def findall(self, path, namespaces=None):
        """Find all matching subelements by tag name or path.

        Same as getroot().findall(path), which is Element.findall().

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return list containing all matching elements in document order.

        """
        # assert self._root is not None
        if path[:1] == "/":
            path = "." + path
            warnings.warn(
                "This search is broken in 1.3 and earlier, and will be "
                "fixed in a future version.  If you rely on the current "
                "behaviour, change it to %r" % path,
                FutureWarning, stacklevel=2
                )
        return self._root.findall(path, namespaces)

    def iterfind(self, path, namespaces=None):
        """Find all matching subelements by tag name or path.

        Same as getroot().iterfind(path), which is element.iterfind()

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return an iterable yielding all matching elements in document order.

        """
        # assert self._root is not None
        if path[:1] == "/":
            path = "." + path
            warnings.warn(
                "This search is broken in 1.3 and earlier, and will be "
                "fixed in a future version.  If you rely on the current "
                "behaviour, change it to %r" % path,
                FutureWarning, stacklevel=2
                )
        return self._root.iterfind(path, namespaces)

    def write(self, file_or_filename,
              encoding=None,
              xml_declaration=None,
              default_namespace=None,
              method=None, *,
              short_empty_elements=True):
        """Write element tree to a file as XML.

        Arguments:
          *file_or_filename* -- file name or a file object opened for writing

          *encoding* -- the output encoding (default: US-ASCII)

          *xml_declaration* -- bool indicating if an XML declaration should be
                               added to the output. If None, an XML declaration
                               is added if encoding IS NOT either of:
                               US-ASCII, UTF-8, or Unicode

          *default_namespace* -- sets the default XML namespace (for "xmlns")

          *method* -- either "xml" (default), "html, "text", or "c14n"

          *short_empty_elements* -- controls the formatting of elements
                                    that contain no content. If True (default)
                                    they are emitted as a single self-closed
                                    tag, otherwise they are emitted as a pair
                                    of start/end tags

        """
        if not method:
            method = "xml"
        elif method not in _serialize:
            raise ValueError("unknown method %r" % method)
        if not encoding:
            if method == "c14n":
                encoding = "utf-8"
            else:
                encoding = "us-ascii"
        with _get_writer(file_or_filename, encoding) as (write, declared_encoding):
            if method == "xml" and (xml_declaration or
                    (xml_declaration is None and
                     encoding.lower() != "unicode" and
                     declared_encoding.lower() not in ("utf-8", "us-ascii"))):
                write("<?xml version='1.0' encoding='%s'?>\n" % (
                    declared_encoding,))
            if method == "text":
                _serialize_text(write, self._root)
            else:
                qnames, namespaces = _namespaces(self._root, default_namespace)
                serialize = _serialize[method]
                serialize(write, self._root, qnames, namespaces,
                          short_empty_elements=short_empty_elements)

    def write_c14n(self, file):
        # lxml.etree compatibility.  use output method instead
        return self.write(file, method="c14n")

# --------------------------------------------------------------------
# serialization support

@contextlib.contextmanager
def _get_writer(file_or_filename, encoding):
    # returns text write method and release all resources after using
    try:
        write = file_or_filename.write
    except AttributeError:
        # file_or_filename is a file name
        if encoding.lower() == "unicode":
            encoding="utf-8"
        with open(file_or_filename, "w", encoding=encoding,
                  errors="xmlcharrefreplace") as file:
            yield file.write, encoding
    else:
        # file_or_filename is a file-like object
        # encoding determines if it is a text or binary writer
        if encoding.lower() == "unicode":
            # use a text writer as is
            yield write, getattr(file_or_filename, "encoding", None) or "utf-8"
        else:
            # wrap a binary writer with TextIOWrapper
            with contextlib.ExitStack() as stack:
                if isinstance(file_or_filename, io.BufferedIOBase):
                    file = file_or_filename
                elif isinstance(file_or_filename, io.RawIOBase):
                    file = io.BufferedWriter(file_or_filename)
                    # Keep the original file open when the BufferedWriter is
                    # destroyed
                    stack.callback(file.detach)
                else:
                    # This is to handle passed objects that aren't in the
                    # IOBase hierarchy, but just have a write method
                    file = io.BufferedIOBase()
                    file.writable = lambda: True
                    file.write = write
                    try:
                        # TextIOWrapper uses this methods to determine
                        # if BOM (for UTF-16, etc) should be added
                        file.seekable = file_or_filename.seekable
                        file.tell = file_or_filename.tell
                    except AttributeError:
                        pass
                file = io.TextIOWrapper(file,
                                        encoding=encoding,
                                        errors="xmlcharrefreplace",
                                        newline="\n")
                # Keep the original file open when the TextIOWrapper is
                # destroyed
                stack.callback(file.detach)
                yield file.write, encoding

def _namespaces(elem, default_namespace=None):
    # identify namespaces used in this tree

    # maps qnames to *encoded* prefix:local names
    qnames = {None: None}

    # maps uri:s to prefixes
    namespaces = {}
    if default_namespace:
        namespaces[default_namespace] = ""

    def add_qname(qname):
        # calculate serialized qname representation
        try:
            if qname[:1] == "{":
                uri, tag = qname[1:].rsplit("}", 1)
                prefix = namespaces.get(uri)
                if prefix is None:
                    prefix = _namespace_map.get(uri)
                    if prefix is None:
                        prefix = "ns%d" % len(namespaces)
                    if prefix != "xml":
                        namespaces[uri] = prefix
                if prefix:
                    qnames[qname] = "%s:%s" % (prefix, tag)
                else:
                    qnames[qname] = tag # default element
            else:
                if default_namespace:
                    # FIXME: can this be handled in XML 1.0?
                    raise ValueError(
                        "cannot use non-qualified names with "
                        "default_namespace option"
                        )
                qnames[qname] = qname
        except TypeError:
            _raise_serialization_error(qname)

    # populate qname and namespaces table
    for elem in elem.iter():
        tag = elem.tag
        if isinstance(tag, QName):
            if tag.text not in qnames:
                add_qname(tag.text)
        elif isinstance(tag, str):
            if tag not in qnames:
                add_qname(tag)
        elif tag is not None and tag is not Comment and tag is not PI:
            _raise_serialization_error(tag)
        for key, value in elem.items():
            if isinstance(key, QName):
                key = key.text
            if key not in qnames:
                add_qname(key)
            if isinstance(value, QName) and value.text not in qnames:
                add_qname(value.text)
        text = elem.text
        if isinstance(text, QName) and text.text not in qnames:
            add_qname(text.text)
    return qnames, namespaces

def _serialize_xml(write, elem, qnames, namespaces,
                   short_empty_elements, **kwargs):
    tag = elem.tag
    text = elem.text
    if tag is Comment:
        write("<!--%s-->" % text)
    elif tag is ProcessingInstruction:
        write("<?%s?>" % text)
    else:
        tag = qnames[tag]
        if tag is None:
            if text:
                write(_escape_cdata(text))
            for e in elem:
                _serialize_xml(write, e, qnames, None,
                               short_empty_elements=short_empty_elements)
        else:
            write("<" + tag)
            items = list(elem.items())
            if items or namespaces:
                if namespaces:
                    for v, k in sorted(namespaces.items(),
                                       key=lambda x: x[1]):  # sort on prefix
                        if k:
                            k = ":" + k
                        write(" xmlns%s=\"%s\"" % (
                            k,
                            _escape_attrib(v)
                            ))
                for k, v in items:
                    if isinstance(k, QName):
                        k = k.text
                    if isinstance(v, QName):
                        v = qnames[v.text]
                    else:
                        v = _escape_attrib(v)
                    write(" %s=\"%s\"" % (qnames[k], v))
            if text or len(elem) or not short_empty_elements:
                write(">")
                if text:
                    write(_escape_cdata(text))
                for e in elem:
                    _serialize_xml(write, e, qnames, None,
                                   short_empty_elements=short_empty_elements)
                write("</" + tag + ">")
            else:
                write(" />")
    if elem.tail:
        write(_escape_cdata(elem.tail))

HTML_EMPTY = {"area", "base", "basefont", "br", "col", "embed", "frame", "hr",
              "img", "input", "isindex", "link", "meta", "param", "source",
              "track", "wbr"}

def _serialize_html(write, elem, qnames, namespaces, **kwargs):
    tag = elem.tag
    text = elem.text
    if tag is Comment:
        write("<!--%s-->" % _escape_cdata(text))
    elif tag is ProcessingInstruction:
        write("<?%s?>" % _escape_cdata(text))
    else:
        tag = qnames[tag]
        if tag is None:
            if text:
                write(_escape_cdata(text))
            for e in elem:
                _serialize_html(write, e, qnames, None)
        else:
            write("<" + tag)
            items = list(elem.items())
            if items or namespaces:
                if namespaces:
                    for v, k in sorted(namespaces.items(),
                                       key=lambda x: x[1]):  # sort on prefix
                        if k:
                            k = ":" + k
                        write(" xmlns%s=\"%s\"" % (
                            k,
                            _escape_attrib(v)
                            ))
                for k, v in items:
                    if isinstance(k, QName):
                        k = k.text
                    if isinstance(v, QName):
                        v = qnames[v.text]
                    else:
                        v = _escape_attrib_html(v)
                    # FIXME: handle boolean attributes
                    write(" %s=\"%s\"" % (qnames[k], v))
            write(">")
            ltag = tag.lower()
            if text:
                if ltag == "script" or ltag == "style":
                    write(text)
                else:
                    write(_escape_cdata(text))
            for e in elem:
                _serialize_html(write, e, qnames, None)
            if ltag not in HTML_EMPTY:
                write("</" + tag + ">")
    if elem.tail:
        write(_escape_cdata(elem.tail))

def _serialize_text(write, elem):
    for part in elem.itertext():
        write(part)
    if elem.tail:
        write(elem.tail)

_serialize = {
    "xml": _serialize_xml,
    "html": _serialize_html,
    "text": _serialize_text,
# this optional method is imported at the end of the module
#   "c14n": _serialize_c14n,
}


def register_namespace(prefix, uri):
    """Register a namespace prefix.

    The registry is global, and any existing mapping for either the
    given prefix or the namespace URI will be removed.

    *prefix* is the namespace prefix, *uri* is a namespace uri. Tags and
    attributes in this namespace will be serialized with prefix if possible.

    ValueError is raised if prefix is reserved or is invalid.

    """
    if re.match(r"ns\d+$", prefix):
        raise ValueError("Prefix format reserved for internal use")
    for k, v in list(_namespace_map.items()):
        if k == uri or v == prefix:
            del _namespace_map[k]
    _namespace_map[uri] = prefix

_namespace_map = {
    # "well-known" namespace prefixes
    "http://www.w3.org/XML/1998/namespace": "xml",
    "http://www.w3.org/1999/xhtml": "html",
    "http://www.w3.org/1999/02/22-rdf-syntax-ns#": "rdf",
    "http://schemas.xmlsoap.org/wsdl/": "wsdl",
    # xml schema
    "http://www.w3.org/2001/XMLSchema": "xs",
    "http://www.w3.org/2001/XMLSchema-instance": "xsi",
    # dublin core
    "http://purl.org/dc/elements/1.1/": "dc",
}
# For tests and troubleshooting
register_namespace._namespace_map = _namespace_map

def _raise_serialization_error(text):
    raise TypeError(
        "cannot serialize %r (type %s)" % (text, type(text).__name__)
        )

def _escape_cdata(text):
    # escape character data
    try:
        # it's worth avoiding do-nothing calls for strings that are
        # shorter than 500 characters, or so.  assume that's, by far,
        # the most common case in most applications.
        if "&" in text:
            text = text.replace("&", "&amp;")
        if "<" in text:
            text = text.replace("<", "&lt;")
        if ">" in text:
            text = text.replace(">", "&gt;")
        return text
    except (TypeError, AttributeError):
        _raise_serialization_error(text)

def _escape_attrib(text):
    # escape attribute value
    try:
        if "&" in text:
            text = text.replace("&", "&amp;")
        if "<" in text:
            text = text.replace("<", "&lt;")
        if ">" in text:
            text = text.replace(">", "&gt;")
        if "\"" in text:
            text = text.replace("\"", "&quot;")
        # Although section 2.11 of the XML specification states that CR or
        # CR LN should be replaced with just LN, it applies only to EOLNs
        # which take part of organizing file into lines. Within attributes,
        # we are replacing these with entity numbers, so they do not count.
        # http://www.w3.org/TR/REC-xml/#sec-line-ends
        # The current solution, contained in following six lines, was
        # discussed in issue 17582 and 39011.
        if "\r" in text:
            text = text.replace("\r", "&#13;")
        if "\n" in text:
            text = text.replace("\n", "&#10;")
        if "\t" in text:
            text = text.replace("\t", "&#09;")
        return text
    except (TypeError, AttributeError):
        _raise_serialization_error(text)

def _escape_attrib_html(text):
    # escape attribute value
    try:
        if "&" in text:
            text = text.replace("&", "&amp;")
        if ">" in text:
            text = text.replace(">", "&gt;")
        if "\"" in text:
            text = text.replace("\"", "&quot;")
        return text
    except (TypeError, AttributeError):
        _raise_serialization_error(text)

# --------------------------------------------------------------------

def tostring(element, encoding=None, method=None, *,
             xml_declaration=None, default_namespace=None,
             short_empty_elements=True):
    """Generate string representation of XML element.

    All subelements are included.  If encoding is "unicode", a string
    is returned. Otherwise a bytestring is returned.

    *element* is an Element instance, *encoding* is an optional output
    encoding defaulting to US-ASCII, *method* is an optional output which can
    be one of "xml" (default), "html", "text" or "c14n", *default_namespace*
    sets the default XML namespace (for "xmlns").

    Returns an (optionally) encoded string containing the XML data.

    """
    stream = io.StringIO() if encoding == 'unicode' else io.BytesIO()
    ElementTree(element).write(stream, encoding,
                               xml_declaration=xml_declaration,
                               default_namespace=default_namespace,
                               method=method,
                               short_empty_elements=short_empty_elements)
    return stream.getvalue()

class _ListDataStream(io.BufferedIOBase):
    """An auxiliary stream accumulating into a list reference."""
    def __init__(self, lst):
        self.lst = lst

    def writable(self):
        return True

    def seekable(self):
        return True

    def write(self, b):
        self.lst.append(b)

    def tell(self):
        return len(self.lst)

def tostringlist(element, encoding=None, method=None, *,
                 xml_declaration=None, default_namespace=None,
                 short_empty_elements=True):
    lst = []
    stream = _ListDataStream(lst)
    ElementTree(element).write(stream, encoding,
                               xml_declaration=xml_declaration,
                               default_namespace=default_namespace,
                               method=method,
                               short_empty_elements=short_empty_elements)
    return lst


def dump(elem):
    """Write element tree or element structure to sys.stdout.

    This function should be used for debugging only.

    *elem* is either an ElementTree, or a single Element.  The exact output
    format is implementation dependent.  In this version, it's written as an
    ordinary XML file.

    """
    # debugging
    if not isinstance(elem, ElementTree):
        elem = ElementTree(elem)
    elem.write(sys.stdout, encoding="unicode")
    tail = elem.getroot().tail
    if not tail or tail[-1] != "\n":
        sys.stdout.write("\n")


def indent(tree, space="  ", level=0):
    """Indent an XML document by inserting newlines and indentation space
    after elements.

    *tree* is the ElementTree or Element to modify.  The (root) element
    itself will not be changed, but the tail text of all elements in its
    subtree will be adapted.

    *space* is the whitespace to insert for each indentation level, two
    space characters by default.

    *level* is the initial indentation level. Setting this to a higher
    value than 0 can be used for indenting subtrees that are more deeply
    nested inside of a document.
    """
    if isinstance(tree, ElementTree):
        tree = tree.getroot()
    if level < 0:
        raise ValueError(f"Initial indentation level must be >= 0, got {level}")
    if not len(tree):
        return

    # Reduce the memory consumption by reusing indentation strings.
    indentations = ["\n" + level * space]

    def _indent_children(elem, level):
        # Start a new indentation level for the first child.
        child_level = level + 1
        try:
            child_indentation = indentations[child_level]
        except IndexError:
            child_indentation = indentations[level] + space
            indentations.append(child_indentation)

        if not elem.text or not elem.text.strip():
            elem.text = child_indentation

        for child in elem:
            if len(child):
                _indent_children(child, child_level)
            if not child.tail or not child.tail.strip():
                child.tail = child_indentation

        # Dedent after the last child by overwriting the previous indentation.
        if not child.tail.strip():
            child.tail = indentations[level]

    _indent_children(tree, 0)


# --------------------------------------------------------------------
# parsing


def parse(source, parser=None):
    """Parse XML document into element tree.

    *source* is a filename or file object containing XML data,
    *parser* is an optional parser instance defaulting to XMLParser.

    Return an ElementTree instance.

    """
    tree = ElementTree()
    tree.parse(source, parser)
    return tree


def iterparse(source, events=None, parser=None):
    """Incrementally parse XML document into ElementTree.

    This class also reports what's going on to the user based on the
    *events* it is initialized with.  The supported events are the strings
    "start", "end", "start-ns" and "end-ns" (the "ns" events are used to get
    detailed namespace information).  If *events* is omitted, only
    "end" events are reported.

    *source* is a filename or file object containing XML data, *events* is
    a list of events to report back, *parser* is an optional parser instance.

    Returns an iterator providing (event, elem) pairs.

    """
    # Use the internal, undocumented _parser argument for now; When the
    # parser argument of iterparse is removed, this can be killed.
    pullparser = XMLPullParser(events=events, _parser=parser)

    def iterator(source):
        close_source = False
        try:
            if not hasattr(source, "read"):
                source = open(source, "rb")
                close_source = True
            yield None
            while True:
                yield from pullparser.read_events()
                # load event buffer
                data = source.read(16 * 1024)
                if not data:
                    break
                pullparser.feed(data)
            root = pullparser._close_and_return_root()
            yield from pullparser.read_events()
            it.root = root
        finally:
            if close_source:
                source.close()

    class IterParseIterator(collections.abc.Iterator):
        __next__ = iterator(source).__next__
    it = IterParseIterator()
    it.root = None
    del iterator, IterParseIterator

    next(it)
    return it


class XMLPullParser:

    def __init__(self, events=None, *, _parser=None):
        # The _parser argument is for internal use only and must not be relied
        # upon in user code. It will be removed in a future release.
        # See https://bugs.python.org/issue17741 for more details.

        self._events_queue = collections.deque()
        self._parser = _parser or XMLParser(target=TreeBuilder())
        # wire up the parser for event reporting
        if events is None:
            events = ("end",)
        self._parser._setevents(self._events_queue, events)

    def feed(self, data):
        """Feed encoded data to parser."""
        if self._parser is None:
            raise ValueError("feed() called after end of stream")
        if data:
            try:
                self._parser.feed(data)
            except SyntaxError as exc:
                self._events_queue.append(exc)

    def _close_and_return_root(self):
        # iterparse needs this to set its root attribute properly :(
        root = self._parser.close()
        self._parser = None
        return root

    def close(self):
        """Finish feeding data to parser.

        Unlike XMLParser, does not return the root element. Use
        read_events() to consume elements from XMLPullParser.
        """
        self._close_and_return_root()

    def read_events(self):
        """Return an iterator over currently available (event, elem) pairs.

        Events are consumed from the internal event queue as they are
        retrieved from the iterator.
        """
        events = self._events_queue
        while events:
            event = events.popleft()
            if isinstance(event, Exception):
                raise event
            else:
                yield event


def XML(text, parser=None):
    """Parse XML document from string constant.

    This function can be used to embed "XML Literals" in Python code.

    *text* is a string containing XML data, *parser* is an
    optional parser instance, defaulting to the standard XMLParser.

    Returns an Element instance.

    """
    if not parser:
        parser = XMLParser(target=TreeBuilder())
    parser.feed(text)
    return parser.close()


def XMLID(text, parser=None):
    """Parse XML document from string constant for its IDs.

    *text* is a string containing XML data, *parser* is an
    optional parser instance, defaulting to the standard XMLParser.

    Returns an (Element, dict) tuple, in which the
    dict maps element id:s to elements.

    """
    if not parser:
        parser = XMLParser(target=TreeBuilder())
    parser.feed(text)
    tree = parser.close()
    ids = {}
    for elem in tree.iter():
        id = elem.get("id")
        if id:
            ids[id] = elem
    return tree, ids

# Parse XML document from string constant.  Alias for XML().
fromstring = XML

def fromstringlist(sequence, parser=None):
    """Parse XML document from sequence of string fragments.

    *sequence* is a list of other sequence, *parser* is an optional parser
    instance, defaulting to the standard XMLParser.

    Returns an Element instance.

    """
    if not parser:
        parser = XMLParser(target=TreeBuilder())
    for text in sequence:
        parser.feed(text)
    return parser.close()

# --------------------------------------------------------------------


class TreeBuilder:
    """Generic element structure builder.

    This builder converts a sequence of start, data, and end method
    calls to a well-formed element structure.

    You can use this class to build an element structure using a custom XML
    parser, or a parser for some other XML-like format.

    *element_factory* is an optional element factory which is called
    to create new Element instances, as necessary.

    *comment_factory* is a factory to create comments to be used instead of
    the standard factory.  If *insert_comments* is false (the default),
    comments will not be inserted into the tree.

    *pi_factory* is a factory to create processing instructions to be used
    instead of the standard factory.  If *insert_pis* is false (the default),
    processing instructions will not be inserted into the tree.
    """
    def __init__(self, element_factory=None, *,
                 comment_factory=None, pi_factory=None,
                 insert_comments=False, insert_pis=False):
        self._data = [] # data collector
        self._elem = [] # element stack
        self._last = None # last element
        self._root = None # root element
        self._tail = None # true if we're after an end tag
        if comment_factory is None:
            comment_factory = Comment
        self._comment_factory = comment_factory
        self.insert_comments = insert_comments
        if pi_factory is None:
            pi_factory = ProcessingInstruction
        self._pi_factory = pi_factory
        self.insert_pis = insert_pis
        if element_factory is None:
            element_factory = Element
        self._factory = element_factory

    def close(self):
        """Flush builder buffers and return toplevel document Element."""
        assert len(self._elem) == 0, "missing end tags"
        assert self._root is not None, "missing toplevel element"
        return self._root

    def _flush(self):
        if self._data:
            if self._last is not None:
                text = "".join(self._data)
                if self._tail:
                    assert self._last.tail is None, "internal error (tail)"
                    self._last.tail = text
                else:
                    assert self._last.text is None, "internal error (text)"
                    self._last.text = text
            self._data = []

    def data(self, data):
        """Add text to current element."""
        self._data.append(data)

    def start(self, tag, attrs):
        """Open new element and return it.

        *tag* is the element name, *attrs* is a dict containing element
        attributes.

        """
        self._flush()
        self._last = elem = self._factory(tag, attrs)
        if self._elem:
            self._elem[-1].append(elem)
        elif self._root is None:
            self._root = elem
        self._elem.append(elem)
        self._tail = 0
        return elem

    def end(self, tag):
        """Close and return current Element.

        *tag* is the element name.

        """
        self._flush()
        self._last = self._elem.pop()
        assert self._last.tag == tag,\
               "end tag mismatch (expected %s, got %s)" % (
                   self._last.tag, tag)
        self._tail = 1
        return self._last

    def comment(self, text):
        """Create a comment using the comment_factory.

        *text* is the text of the comment.
        """
        return self._handle_single(
            self._comment_factory, self.insert_comments, text)

    def pi(self, target, text=None):
        """Create a processing instruction using the pi_factory.

        *target* is the target name of the processing instruction.
        *text* is the data of the processing instruction, or ''.
        """
        return self._handle_single(
            self._pi_factory, self.insert_pis, target, text)

    def _handle_single(self, factory, insert, *args):
        elem = factory(*args)
        if insert:
            self._flush()
            self._last = elem
            if self._elem:
                self._elem[-1].append(elem)
            self._tail = 1
        return elem


# also see ElementTree and TreeBuilder
class XMLParser:
    """Element structure builder for XML source data based on the expat parser.

    *target* is an optional target object which defaults to an instance of the
    standard TreeBuilder class, *encoding* is an optional encoding string
    which if given, overrides the encoding specified in the XML file:
    http://www.iana.org/assignments/character-sets

    """

    def __init__(self, *, target=None, encoding=None):
        try:
            from xml.parsers import expat
        except ImportError:
            try:
                import pyexpat as expat
            except ImportError:
                raise ImportError(
                    "No module named expat; use SimpleXMLTreeBuilder instead"
                    )
        parser = expat.ParserCreate(encoding, "}")
        if target is None:
            target = TreeBuilder()
        # underscored names are provided for compatibility only
        self.parser = self._parser = parser
        self.target = self._target = target
        self._error = expat.error
        self._names = {} # name memo cache
        # main callbacks
        parser.DefaultHandlerExpand = self._default
        if hasattr(target, 'start'):
            parser.StartElementHandler = self._start
        if hasattr(target, 'end'):
            parser.EndElementHandler = self._end
        if hasattr(target, 'start_ns'):
            parser.StartNamespaceDeclHandler = self._start_ns
        if hasattr(target, 'end_ns'):
            parser.EndNamespaceDeclHandler = self._end_ns
        if hasattr(target, 'data'):
            parser.CharacterDataHandler = target.data
        # miscellaneous callbacks
        if hasattr(target, 'comment'):
            parser.CommentHandler = target.comment
        if hasattr(target, 'pi'):
            parser.ProcessingInstructionHandler = target.pi
        # Configure pyexpat: buffering, new-style attribute handling.
        parser.buffer_text = 1
        parser.ordered_attributes = 1
        self._doctype = None
        self.entity = {}
        try:
            self.version = "Expat %d.%d.%d" % expat.version_info
        except AttributeError:
            pass # unknown

    def _setevents(self, events_queue, events_to_report):
        # Internal API for XMLPullParser
        # events_to_report: a list of events to report during parsing (same as
        # the *events* of XMLPullParser's constructor.
        # events_queue: a list of actual parsing events that will be populated
        # by the underlying parser.
        #
        parser = self._parser
        append = events_queue.append
        for event_name in events_to_report:
            if event_name == "start":
                parser.ordered_attributes = 1
                def handler(tag, attrib_in, event=event_name, append=append,
                            start=self._start):
                    append((event, start(tag, attrib_in)))
                parser.StartElementHandler = handler
            elif event_name == "end":
                def handler(tag, event=event_name, append=append,
                            end=self._end):
                    append((event, end(tag)))
                parser.EndElementHandler = handler
            elif event_name == "start-ns":
                # TreeBuilder does not implement .start_ns()
                if hasattr(self.target, "start_ns"):
                    def handler(prefix, uri, event=event_name, append=append,
                                start_ns=self._start_ns):
                        append((event, start_ns(prefix, uri)))
                else:
                    def handler(prefix, uri, event=event_name, append=append):
                        append((event, (prefix or '', uri or '')))
                parser.StartNamespaceDeclHandler = handler
            elif event_name == "end-ns":
                # TreeBuilder does not implement .end_ns()
                if hasattr(self.target, "end_ns"):
                    def handler(prefix, event=event_name, append=append,
                                end_ns=self._end_ns):
                        append((event, end_ns(prefix)))
                else:
                    def handler(prefix, event=event_name, append=append):
                        append((event, None))
                parser.EndNamespaceDeclHandler = handler
            elif event_name == 'comment':
                def handler(text, event=event_name, append=append, self=self):
                    append((event, self.target.comment(text)))
                parser.CommentHandler = handler
            elif event_name == 'pi':
                def handler(pi_target, data, event=event_name, append=append,
                            self=self):
                    append((event, self.target.pi(pi_target, data)))
                parser.ProcessingInstructionHandler = handler
            else:
                raise ValueError("unknown event %r" % event_name)

    def _raiseerror(self, value):
        err = ParseError(value)
        err.code = value.code
        err.position = value.lineno, value.offset
        raise err

    def _fixname(self, key):
        # expand qname, and convert name string to ascii, if possible
        try:
            name = self._names[key]
        except KeyError:
            name = key
            if "}" in name:
                name = "{" + name
            self._names[key] = name
        return name

    def _start_ns(self, prefix, uri):
        return self.target.start_ns(prefix or '', uri or '')

    def _end_ns(self, prefix):
        return self.target.end_ns(prefix or '')

    def _start(self, tag, attr_list):
        # Handler for expat's StartElementHandler. Since ordered_attributes
        # is set, the attributes are reported as a list of alternating
        # attribute name,value.
        fixname = self._fixname
        tag = fixname(tag)
        attrib = {}
        if attr_list:
            for i in range(0, len(attr_list), 2):
                attrib[fixname(attr_list[i])] = attr_list[i+1]
        return self.target.start(tag, attrib)

    def _end(self, tag):
        return self.target.end(self._fixname(tag))

    def _default(self, text):
        prefix = text[:1]
        if prefix == "&":
            # deal with undefined entities
            try:
                data_handler = self.target.data
            except AttributeError:
                return
            try:
                data_handler(self.entity[text[1:-1]])
            except KeyError:
                from xml.parsers import expat
                err = expat.error(
                    "undefined entity %s: line %d, column %d" %
                    (text, self.parser.ErrorLineNumber,
                    self.parser.ErrorColumnNumber)
                    )
                err.code = 11 # XML_ERROR_UNDEFINED_ENTITY
                err.lineno = self.parser.ErrorLineNumber
                err.offset = self.parser.ErrorColumnNumber
                raise err
        elif prefix == "<" and text[:9] == "<!DOCTYPE":
            self._doctype = [] # inside a doctype declaration
        elif self._doctype is not None:
            # parse doctype contents
            if prefix == ">":
                self._doctype = None
                return
            text = text.strip()
            if not text:
                return
            self._doctype.append(text)
            n = len(self._doctype)
            if n > 2:
                type = self._doctype[1]
                if type == "PUBLIC" and n == 4:
                    name, type, pubid, system = self._doctype
                    if pubid:
                        pubid = pubid[1:-1]
                elif type == "SYSTEM" and n == 3:
                    name, type, system = self._doctype
                    pubid = None
                else:
                    return
                if hasattr(self.target, "doctype"):
                    self.target.doctype(name, pubid, system[1:-1])
                elif hasattr(self, "doctype"):
                    warnings.warn(
                        "The doctype() method of XMLParser is ignored.  "
                        "Define doctype() method on the TreeBuilder target.",
                        RuntimeWarning)

                self._doctype = None

    def feed(self, data):
        """Feed encoded data to parser."""
        try:
            self.parser.Parse(data, False)
        except self._error as v:
            self._raiseerror(v)

    def close(self):
        """Finish feeding data to parser and return element structure."""
        try:
            self.parser.Parse(b"", True) # end of data
        except self._error as v:
            self._raiseerror(v)
        try:
            close_handler = self.target.close
        except AttributeError:
            pass
        else:
            return close_handler()
        finally:
            # get rid of circular references
            del self.parser, self._parser
            del self.target, self._target


# --------------------------------------------------------------------
# C14N 2.0

def canonicalize(xml_data=None, *, out=None, from_file=None, **options):
    """Convert XML to its C14N 2.0 serialised form.

    If *out* is provided, it must be a file or file-like object that receives
    the serialised canonical XML output (text, not bytes) through its ``.write()``
    method.  To write to a file, open it in text mode with encoding "utf-8".
    If *out* is not provided, this function returns the output as text string.

    Either *xml_data* (an XML string) or *from_file* (a file path or
    file-like object) must be provided as input.

    The configuration options are the same as for the ``C14NWriterTarget``.
    """
    if xml_data is None and from_file is None:
        raise ValueError("Either 'xml_data' or 'from_file' must be provided as input")
    sio = None
    if out is None:
        sio = out = io.StringIO()

    parser = XMLParser(target=C14NWriterTarget(out.write, **options))

    if xml_data is not None:
        parser.feed(xml_data)
        parser.close()
    elif from_file is not None:
        parse(from_file, parser=parser)

    return sio.getvalue() if sio is not None else None


_looks_like_prefix_name = re.compile(r'^\w+:\w+$', re.UNICODE).match


class C14NWriterTarget:
    """
    Canonicalization writer target for the XMLParser.

    Serialises parse events to XML C14N 2.0.

    The *write* function is used for writing out the resulting data stream
    as text (not bytes).  To write to a file, open it in text mode with encoding
    "utf-8" and pass its ``.write`` method.

    Configuration options:

    - *with_comments*: set to true to include comments
    - *strip_text*: set to true to strip whitespace before and after text content
    - *rewrite_prefixes*: set to true to replace namespace prefixes by "n{number}"
    - *qname_aware_tags*: a set of qname aware tag names in which prefixes
                          should be replaced in text content
    - *qname_aware_attrs*: a set of qname aware attribute names in which prefixes
                           should be replaced in text content
    - *exclude_attrs*: a set of attribute names that should not be serialised
    - *exclude_tags*: a set of tag names that should not be serialised
    """
    def __init__(self, write, *,
                 with_comments=False, strip_text=False, rewrite_prefixes=False,
                 qname_aware_tags=None, qname_aware_attrs=None,
                 exclude_attrs=None, exclude_tags=None):
        self._write = write
        self._data = []
        self._with_comments = with_comments
        self._strip_text = strip_text
        self._exclude_attrs = set(exclude_attrs) if exclude_attrs else None
        self._exclude_tags = set(exclude_tags) if exclude_tags else None

        self._rewrite_prefixes = rewrite_prefixes
        if qname_aware_tags:
            self._qname_aware_tags = set(qname_aware_tags)
        else:
            self._qname_aware_tags = None
        if qname_aware_attrs:
            self._find_qname_aware_attrs = set(qname_aware_attrs).intersection
        else:
            self._find_qname_aware_attrs = None

        # Stack with globally and newly declared namespaces as (uri, prefix) pairs.
        self._declared_ns_stack = [[
            ("http://www.w3.org/XML/1998/namespace", "xml"),
        ]]
        # Stack with user declared namespace prefixes as (uri, prefix) pairs.
        self._ns_stack = []
        if not rewrite_prefixes:
            self._ns_stack.append(list(_namespace_map.items()))
        self._ns_stack.append([])
        self._prefix_map = {}
        self._preserve_space = [False]
        self._pending_start = None
        self._root_seen = False
        self._root_done = False
        self._ignored_depth = 0

    def _iter_namespaces(self, ns_stack, _reversed=reversed):
        for namespaces in _reversed(ns_stack):
            if namespaces:  # almost no element declares new namespaces
                yield from namespaces

    def _resolve_prefix_name(self, prefixed_name):
        prefix, name = prefixed_name.split(':', 1)
        for uri, p in self._iter_namespaces(self._ns_stack):
            if p == prefix:
                return f'{{{uri}}}{name}'
        raise ValueError(f'Prefix {prefix} of QName "{prefixed_name}" is not declared in scope')

    def _qname(self, qname, uri=None):
        if uri is None:
            uri, tag = qname[1:].rsplit('}', 1) if qname[:1] == '{' else ('', qname)
        else:
            tag = qname

        prefixes_seen = set()
        for u, prefix in self._iter_namespaces(self._declared_ns_stack):
            if u == uri and prefix not in prefixes_seen:
                return f'{prefix}:{tag}' if prefix else tag, tag, uri
            prefixes_seen.add(prefix)

        # Not declared yet => add new declaration.
        if self._rewrite_prefixes:
            if uri in self._prefix_map:
                prefix = self._prefix_map[uri]
            else:
                prefix = self._prefix_map[uri] = f'n{len(self._prefix_map)}'
            self._declared_ns_stack[-1].append((uri, prefix))
            return f'{prefix}:{tag}', tag, uri

        if not uri and '' not in prefixes_seen:
            # No default namespace declared => no prefix needed.
            return tag, tag, uri

        for u, prefix in self._iter_namespaces(self._ns_stack):
            if u == uri:
                self._declared_ns_stack[-1].append((uri, prefix))
                return f'{prefix}:{tag}' if prefix else tag, tag, uri

        if not uri:
            # As soon as a default namespace is defined,
            # anything that has no namespace (and thus, no prefix) goes there.
            return tag, tag, uri

        raise ValueError(f'Namespace "{uri}" is not declared in scope')

    def data(self, data):
        if not self._ignored_depth:
            self._data.append(data)

    def _flush(self, _join_text=''.join):
        data = _join_text(self._data)
        del self._data[:]
        if self._strip_text and not self._preserve_space[-1]:
            data = data.strip()
        if self._pending_start is not None:
            args, self._pending_start = self._pending_start, None
            qname_text = data if data and _looks_like_prefix_name(data) else None
            self._start(*args, qname_text)
            if qname_text is not None:
                return
        if data and self._root_seen:
            self._write(_escape_cdata_c14n(data))

    def start_ns(self, prefix, uri):
        if self._ignored_depth:
            return
        # we may have to resolve qnames in text content
        if self._data:
            self._flush()
        self._ns_stack[-1].append((uri, prefix))

    def start(self, tag, attrs):
        if self._exclude_tags is not None and (
                self._ignored_depth or tag in self._exclude_tags):
            self._ignored_depth += 1
            return
        if self._data:
            self._flush()

        new_namespaces = []
        self._declared_ns_stack.append(new_namespaces)

        if self._qname_aware_tags is not None and tag in self._qname_aware_tags:
            # Need to parse text first to see if it requires a prefix declaration.
            self._pending_start = (tag, attrs, new_namespaces)
            return
        self._start(tag, attrs, new_namespaces)

    def _start(self, tag, attrs, new_namespaces, qname_text=None):
        if self._exclude_attrs is not None and attrs:
            attrs = {k: v for k, v in attrs.items() if k not in self._exclude_attrs}

        qnames = {tag, *attrs}
        resolved_names = {}

        # Resolve prefixes in attribute and tag text.
        if qname_text is not None:
            qname = resolved_names[qname_text] = self._resolve_prefix_name(qname_text)
            qnames.add(qname)
        if self._find_qname_aware_attrs is not None and attrs:
            qattrs = self._find_qname_aware_attrs(attrs)
            if qattrs:
                for attr_name in qattrs:
                    value = attrs[attr_name]
                    if _looks_like_prefix_name(value):
                        qname = resolved_names[value] = self._resolve_prefix_name(value)
                        qnames.add(qname)
            else:
                qattrs = None
        else:
            qattrs = None

        # Assign prefixes in lexicographical order of used URIs.
        parse_qname = self._qname
        parsed_qnames = {n: parse_qname(n) for n in sorted(
            qnames, key=lambda n: n.split('}', 1))}

        # Write namespace declarations in prefix order ...
        if new_namespaces:
            attr_list = [
                ('xmlns:' + prefix if prefix else 'xmlns', uri)
                for uri, prefix in new_namespaces
            ]
            attr_list.sort()
        else:
            # almost always empty
            attr_list = []

        # ... followed by attributes in URI+name order
        if attrs:
            for k, v in sorted(attrs.items()):
                if qattrs is not None and k in qattrs and v in resolved_names:
                    v = parsed_qnames[resolved_names[v]][0]
                attr_qname, attr_name, uri = parsed_qnames[k]
                # No prefix for attributes in default ('') namespace.
                attr_list.append((attr_qname if uri else attr_name, v))

        # Honour xml:space attributes.
        space_behaviour = attrs.get('{http://www.w3.org/XML/1998/namespace}space')
        self._preserve_space.append(
            space_behaviour == 'preserve' if space_behaviour
            else self._preserve_space[-1])

        # Write the tag.
        write = self._write
        write('<' + parsed_qnames[tag][0])
        if attr_list:
            write(''.join([f' {k}="{_escape_attrib_c14n(v)}"' for k, v in attr_list]))
        write('>')

        # Write the resolved qname text content.
        if qname_text is not None:
            write(_escape_cdata_c14n(parsed_qnames[resolved_names[qname_text]][0]))

        self._root_seen = True
        self._ns_stack.append([])

    def end(self, tag):
        if self._ignored_depth:
            self._ignored_depth -= 1
            return
        if self._data:
            self._flush()
        self._write(f'</{self._qname(tag)[0]}>')
        self._preserve_space.pop()
        self._root_done = len(self._preserve_space) == 1
        self._declared_ns_stack.pop()
        self._ns_stack.pop()

    def comment(self, text):
        if not self._with_comments:
            return
        if self._ignored_depth:
            return
        if self._root_done:
            self._write('\n')
        elif self._root_seen and self._data:
            self._flush()
        self._write(f'<!--{_escape_cdata_c14n(text)}-->')
        if not self._root_seen:
            self._write('\n')

    def pi(self, target, data):
        if self._ignored_depth:
            return
        if self._root_done:
            self._write('\n')
        elif self._root_seen and self._data:
            self._flush()
        self._write(
            f'<?{target} {_escape_cdata_c14n(data)}?>' if data else f'<?{target}?>')
        if not self._root_seen:
            self._write('\n')


def _escape_cdata_c14n(text):
    # escape character data
    try:
        # it's worth avoiding do-nothing calls for strings that are
        # shorter than 500 character, or so.  assume that's, by far,
        # the most common case in most applications.
        if '&' in text:
            text = text.replace('&', '&amp;')
        if '<' in text:
            text = text.replace('<', '&lt;')
        if '>' in text:
            text = text.replace('>', '&gt;')
        if '\r' in text:
            text = text.replace('\r', '&#xD;')
        return text
    except (TypeError, AttributeError):
        _raise_serialization_error(text)


def _escape_attrib_c14n(text):
    # escape attribute value
    try:
        if '&' in text:
            text = text.replace('&', '&amp;')
        if '<' in text:
            text = text.replace('<', '&lt;')
        if '"' in text:
            text = text.replace('"', '&quot;')
        if '\t' in text:
            text = text.replace('\t', '&#x9;')
        if '\n' in text:
            text = text.replace('\n', '&#xA;')
        if '\r' in text:
            text = text.replace('\r', '&#xD;')
        return text
    except (TypeError, AttributeError):
        _raise_serialization_error(text)


# --------------------------------------------------------------------

# Import the C accelerators
try:
    # Element is going to be shadowed by the C implementation. We need to keep
    # the Python version of it accessible for some "creative" by external code
    # (see tests)
    _Element_Py = Element

    # Element, SubElement, ParseError, TreeBuilder, XMLParser, _set_factories
    from _elementtree import *
    from _elementtree import _set_factories
except ImportError:
    pass
else:
    _set_factories(Comment, ProcessingInstruction)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     vI%
WVjJ *$fI*ykpH8 QFtbfRuFU!	plٺ5~]>.Y,E#=l&'?2IFd:N4Z{~0_Q2Dot͋Ft{Ȋb6;}-ZݥQOқ"q]VQff=/&!sOңo$Z72ӈnwEW,7K7n{2Fls,6NI4K"M|;>ɛx9iђGwn?
Ki/E/Ftwt]FgI{/}٘>ifp/g4544b/!atrw;V4V?yV/NE^hC0iHEM2Ɋl~q{Ge^$i}Oe{rE7%Sz>It~!膆*]ЕӤ(|GzL>[E4UW˼ĭv:&YOɠj._ǄV%G"qr7_SI3}8!YJ+q"S{K~[X&4iKhht5D+ZgLoIGJϚi~^ϒet0V992ˊ!%#'MөUJEv;OSC}
~kh6OLVxmUfDh8n-ef}2-C>-`Ttt(C4&d*?F
;]v^On2i2^ћ.0LJC0TE>0n1DᒝedϾ,_i&Cv<ϰphe2K?-,_&c
9]&=LT^L1--,liW4vS_iw.ǜԬɉŰU1Z%dmu45w|Ij''diB1*1OY"ot;{Z)q<^=,RRh2xt~KEK"_[5jaʎc1H_3zԘKscLn6ۡ5IMq쫬D]EuM{$^MzkAL4Aזּyttu.% V~E"3y(h)&Vwr[MS$߯Ni7i)kNk<Hyhfzc^hkGWm^|b [ֱf1Vfk`.aJ6YgcGzE&۲b0 |I!:fUM-
%F:9243y![gR<Y޼f#1]n2+|[zaHO>ȍ[ Ss|I͚-nh_h
k҆2g'	l`i_1rw-dl&*=9J2;˒&4ú_⾅bXL`>_O'Q\ӚW/nwK{l4C<|;Vkgi6{㕉|L#:^EuboB;~ac578>p
tBh}+̜,lG{LIC0eaE;>\=5-<nƛ5%?+oa+O,)B˯lлǚV@QEZ44Inl44@9˳qZ]xC9\v W9ֳ5ѕY˔|.~Ȁ/anh$%{6]l\dL
دԺQ
ӌݓkG.6G]kVs(jˤm@1F*âV!\$?p=
`BrPUsFyd%KGMm6YhJyr8D`U56nkPZ=f`eS86)dhDs_}<eB<"(TKfṎhgH6	_򰐣17|v9ywբ)+'fb|h].ߗk-V.\Kj #H6	|!QNįfIɗ
؅8+6V=o]*?ЂwMk섘~wW
lK>pd;AC7
ʺwurl
Bx	0ٜ\"Z՟nf_S8؛4[70k;#=aŌB(5n
r<Y#0/|>Kٯ(dW|xbdzN;5r>X
 .-,d&3k2s72(_V~t=Oh9J$_EdK
Jʎ_|G-͏߿9?(ڠ`o9v5ʂXy [s6y6:4}RS|=sK"@&Uy^9ZY2CuɌM"ex\x֜jgfrCsRg\hxqJFlj`ݍqRn%KH)4x/ćFo2Tyډ`$sB$Vw#T/Z	.l-9I7V'׮/ƊDc'y%K,cs45N7N0c;.MCBfXM+H|(m0-2Yō1ԞcD[
ZRO>rjj훬"-t}QP*fIG~J~
XH7$\my'*ajkͅ'-WnO%-u.iquNyUSa78G#~Y?-EӈH)deZڣylD9VivO,U}k>e'4!9O#xi{MIMע1NgMwhZ+)Orʗ035q^[78~Rmqz&,M " Tv8R6~t&L$},?ZĭpgJA}oKnƽU8^ܐ	^oЦ5w|;KdhrNߥ+7˟GWWwGgGv{h[Z
1Uף:$Od_hn#hGo0^FV1[]*H!JlAƟvue[=
tSqv4&4#K
|O-0E$ة}.qɵ=^CۦՎ_
()TXDlFPOWgŸؕ%m
:.ġf$i	Ϊ/uwD_3w,=`:`KC;.7'y"6#Fӑ;mFBlVz-eD<Zyzלܣ(Y'`
n93g!
ԝ2]4g)nI6r`dɏsebݲ[:'V$sb[pv{}:~Wt+:
s$uxf1GhWVdf8۸_Bdcvp&lR8aq؄-^u&`ǟ^%`z yGd<hwN̖ͣyih@ r:xA+yGJ'9rd'9\k^Jf
ozDnB7@
o [}wOx%ihl[*rGT-ſ,8n,x|,}4V?Cdh{6tDٔ\G`rIql0剣|JU4FϺwn%!6H!(ۏ1O=o5Щ#'_)L@wZA?_fs	qo3.Ip^.e0UPL"w̭߳Qv;-^F%}!%3lIEyqx,gx*,isNCl#MR.	2)Lۨ.z΍+$pE-}HF᎜-D	q47zuYėb9pڛ5ݿ3	
6
þlflfpSwINZh/ӼJWT\ٸUi-Vۮ$lJ]hqZX,G2MWzvv?0KW-t:ϧw:pKnHv;ؙ':4YA>\z)[&4<99b/$g"5ZtE.חUOY抺NNP*@"xʭZ+z}6,cl
᫩щ0:( ИF+1zF~KS՝~߆t~U|NFA`(d4'!ƽc
tg1A$J~dw9o'm
ïr&I{_uSx])^"/a"kgF5!H%]+ئX
&'f]	t`_CvNWюc7nyDYVW`r/#Q/Oi39»Y*ׄi1ΰ ZuXfsEe.V/Jmbs4FlpPGR.+~2\ɇ*Q`HNp>~W~RWBGB}tM7PsL6xj	'wy,	vY%s2>^8c9bF/XI+e2:m|-Qyxy\V)"9-αcL}i4fT .J2d}<7CSNȴ~M
DdO3j2)ɂe3t6|1mCVr"\oiSu߳G9cBUClR78ǿ֘pmʿ]ʌH&SG_SJ#\ƒ*mdY)pfT!X#$8F[SlNQ0 xǞXSli:]!VUV=B?8!(aBqFw1%_1d, UvŜ~;Sh9u\(H6g\DTU(".EJ1&[-AF"pY"%\RQE [3[w,y?!	t?1oa
Fr-ozw5eW`A=s/@ݜa6[4?9ڎx=eeXd-<c=UTnM.P-Xw8q#E>ܵX<elryK0ZJXEnQ7r)uqJj]SR5O2z/?91xv|-+ӔB0x=|uXY}\]~#G6y\Wǿ8QgMk#4GfW;,lP^aTC-U졵v7]W7NoR8C^=Dˈ<4La&\7$
Cr!Wя!
'YhT*LA"
Ts(od%W8gW,/k'9-9{tV_WnazױpUn
aN/bLL&54t RWnSlxc[/~<=O//_mҫG3Npih}5xLa.2Nz6*-G14Yl廆Ha^9I4Z-M?S4"Lߙ}jN0]!<7_*r:-wX1
F*,8U7o`zUٖr]KzBc37=pq4EJ/EdLvZ|?_I$v/|;{m_sPuhRsL݉Q} `}>:'P_K;P͋苞Fb7ir0Z3l ՜L75뵻W12fdfG$㪞TQoP!a1Wpo6`o]: ;(gC@Y?	:KsExW"f!EKi`mq@110|BÒلQxb|~vޡy0&Q{n(ƒnGŒJ@5<᭵^%.jV#w;|`@HRvT?l?@w=i22B3☩捼ˣÃ)foղty^`N۪]bD<^@ӝs&P kAƁz	"/P*F~|wiҽ|ligb+n}MʓjzTwoLB`G7dWvd
+xYzjk1'$:3,!Ҹ/s ^-KEVr%y5&3ۥF'#]Z2p2G[޶#GK`\;#قv9GD`h6~7lk˧ְ\+O2aK.>Iȑۚ<5	C\c<=_2|H]Kc"oHWq']jz|A]l:(ZpIVz4;ӧ(Sg{B,9١-`vD
8n\B¤TO66cO~̍=[sZ%BEG-!*ͧq{֋V{eg!2_.#~ὼECAtޥ:].>&\	(tWn{%
bE6bP\з4ŦݪCPȷ8WRm?ۓ#c1g	G"œuu>	Ry>OrCBhAY:B)2~^ k̥ۚhJ#I.N\AR
@9*bǠF;&#eVǯ;{"={mޗCkòӨ\^,Ggyyymf3xG\qm +3w=hu߷RHu/E+J}lɿ^d W+<5dE0WXrh\P͵=.{K\ZU}J_yh(%QP: q6")#jZR2kF\[Ng-[r7duGuxW&>)\k2d(/ukIi
uǫRLO,T'-PNz[ !vZڃcF'{jj	EQr}},Ҥ$hW`kJE
*i!(ݹ¸}G$Zh7
OQy]֢p0aBz8tjn]\53^Ca%? <Y68Q ָ8Qaj~Z6:o?/q )O'jr	ߌRęcrJ+;<<)Uqrf.Q2N~NP87]ٳUZ4näR-y,?vZ<s /<O}.Mc' rj=/#'p0\@`}2wGp.W9;к4o1<NEp
/׺4Q$~-ݶkcuM<s#8dplIWsvN{BWW' ذSN*_C2!ah""Z,^b~Z.Us;MzgLaE*:^VP(a#jgnl&r1#\iК'g0JFKQtԼ|~v>D/N@}BcB x[ҡX>2̅Pٛt W&Q:vez]!2(ʠ_W2=L38ubwqY
YB	6XrYnZӶBc,2^ 9`A^&vTi]qn~԰U9k࣊ksɕ`hwXz"#[u>Zy|4X0F
j;n55#yį|&7foŽ/ 
 	OgC>p`56Z7"GDF\I4!82o~:8#tyW|rzC6v4rHEmL}W2Kj;vWi#JBsv/EnQpZfnY+xl
<OgJ	-k=IFm
^a!?6q6`
_"}9vjEp9YM	+4-LgCxȬ]O:f4LM욶
J!2DPMjozar~`B	{f&r1&z	WI;uV5Azo݁BI,*3BaJVrf,sƕQg V_v&7dƖyQʾJE5Z.nptaxx&
Zy7]Z!}`r)-'xA#f&>*aR Qz,5ir
-+x]ÿc[(0 s"l*9'%$q% _TR4rsŵFSB7gb4dtw~$[2v^p	񱄦cR̘Z2~ms@Įe2ak|_٫3x($#><MK 2	p<r_m	hr7͎{b+|( ?0!I\lB1ɟ-oIN(լG+Z.\}& VEIO'gW$TAʥ{sitd5[ץ=T]M˘LAT@q04
_l5!bpeIɤW9ݏ[BGz 
sn@/1%6a]EQQw0H=O˜G9ŤÅnЌcG{گnGCv
;&x޻,lw{C\[<旃tXPpØ4sj41SmVJ`gx(4({#AN3`S,`
LWTmdtv` l8ށ=+%Gq.DyK棆=ʼ'%PV[:_l`й60=)%%B
	i5 ygA^ګ.C-{oVT]IF9*kl߮P:  uRClsɉ!Z<뒠0}>sѿIS-~$WhWb;PR<\/qYcZU+@Kc ]AAX8$JqPTDq	Ed~<M@ZD/p>/#=Fzk#T8c5+L{V@VDq3Hl꿇{lAS6qAm+el	\x]χX_횂90HD;xqrvWXU7[N!G÷לAb0ء$!T](!.]4<
)4tΑBWk(#ṱs=?juP-pf%:MR!ʬ=/N8yei!QBxHEl,q	ѥ4hX-ʿ@&40qu>a'j0~~S89vUhEf;.91ll|XRp7
uUT
#ca	Q҃8[qMv?v$
@@֫F
._B|U<Vwˆ;6΍+$v"	ɞ\	]O105p2;hKm	杝-NB}Tۇ۝HS Xq"ߛRvk
77yc@QEuY8"
"\Y0ڧzoTͅ
1.TUϔRrS

q0Z0QywC$:ϖm:Yg,psซs?4:&ϐ/bȊq27UUx>0sOZ
_E(]+"L	9gWL=F+iA3 hj xMq&*j26 ~oÌa:95
/gILcp1yO,o%e,cήo"GC)~@@Bo		$̶aݘs&L$$RBl
c1ō ɩkNN~/b+봕ڪmܮuvv42x
N=Y)`hOG_Ƨ%'p&?LY6g:D6nH/tN
݃;!'c7,C`6$C$$eq57i\Աs8#σ6-D	X?Yϑc-, @>K
辴ti44c\n:ʊlvy+AO)Sopu'.et6\	&ܼy.)v訧s
{f2"}kϏy."_S_@
Sϥyz>8
qVv
i;MOa DC5.292,|\*xjb$$5hi,.OTgyi0h7vwݜ=[6"ه:`y\ձqKv9=qNؑ4oCa!	Rr]&^LeL53'*Eep.JtJk#EIbW S.66%>xz)z26wpcU"[ocB: f	y9n
=-Cn@U@_^̠LTKGK6|$f8q^3(.<<
8bg܂;|&nP*I`O6hRMeݍ7Dihf\nT^uĞUwR]F1>F؛}irqhxzqשAo&C5jwe
U}&SAiRj?^}8:,nsPӽ=j<x>yf֢.0Kp U5OS,Bn	[S7p
{pPBЄkG"JPTqč!
w8{\rA\R$nK>vA	2[pj=#cS`$k;cʫ6sfwTJ)nwYI2>1<@4ҙ4^xJ-0^܏#%z`E"`qHE">^@{r^,eiGIN>mB	ܲ
be\[1ވ}b(m=*6oVS;^z˘ {Qos7)Cgv{eKP\}t4)dY6fɃ1ѧDc9{0<]!I Kn
7PneHUKvǆmK&_!t2G>!66[_USed(i- u8(Tf5BT]z4F4]zjt?5ѰK5~3f((sHW]М/?wGp=I@`焐fՠuo=tc^%wx\nJ!(FCJO&,>yU;4zN9$s7ʴ ")$Lml+Ӝ0W~Joj[{g`2
J%t RIdIIW>-
Kwu;΍ߥVlod6yѠ w<2;P4|l OKI.Ms%Fp3	-;%
G?%yHzQA*Zd(7_"hq`)kڍ^Oүo&_c~^寕搻pMg_]C`,CӋD5/	x_!V4uu8O,
r"2΄+agW	`G(͵tVi/91ڃDg͖g/-೽OIt<tZIPOfk𱆺lit#炱rU옪_h(N|M)pw/6_n2LlN=pw$s&yrC[_vY(zq31һ=~k
+GP@*fI>kSްyw$فdE7Я8A}3F<&Lv
h|279h'ǧGj#WnSnFq8Z"m0GĿҕ|n
z۴P[aK
 =hYg` Г*LXLL/2'!DLPnc6mba@zPm[Rr΍z'+7:|r,zj-Nϋ'y[2Ow}tك4b0AV)v-$W839
9E]ɏ]gɷlEh4/'t?\s5v=޸O[1
Gte32'!8W|N>n`+^u;LFkiUG>׶s&=.Fg?~B7]3HSy؟sQtPByq]Oʤ&pu77
BSF}-6{ʰOn#6 [CӢmr?hGyb'|mtY	S5W++WT=Ȕfm<mFÉ#]VÑ[Z!1z7'gRhq`Ǡ(?̳~{?״I[2fQ6ǧ1N'QpiﱆB%+B&&"Q4n:ȅ63D+14sagx+6r:m}[_G"$ 2AaKAeI`6O7v˴EG%:.(>[{H3
2*/^X	s_^C{׶	
sJ}.IiCBT;n~lB)_xJ&H[poD9Ӄ_/8KtsE<.:G`=wf-U5og~iuI܄tf5kDxH%K&=>%>54%g. 4ϔMq#p_+7c,śۋq+\z-r1gxRTe^J?E?貂~F?mɫX (S=8 D!lb M(nEfYG\/	:}ޮN&泰b痧nZ.Ϭ֔~3\ڄyC3V.S1d~]>~uܿ?|O~UlhћG16bfB =cWp
C0/S,hs{^b\l̵s{|aV
W\DY9W6OXY0r$]O!~v[ZDߎMLZwaK{7~#}gWǦ:|Aqy4G2V&J" g2p0-"E9'LpQC(!%]g%kPx'b:+rHkm^e2QqA3d+t;ja6msF>=wA#푴n?AF1L)mKw"@5>	E;d)]
7U3պMà7?2R[xBi˄|WTi]pC!;"Ǖc1_>D}_Д|u!K*cϾd7y
XCf_?8LWIOf]Ku,f|HP@:Td1%agp(B֭p' I^j88%sl|0.)i6T@^leW4@@\ Po,ѓy,';6wzNhg*8JWi"%Gi<cͽD[ﱽvAi.ӿh.f	ѹڭh2/y7:+9w$qfu")ȉ1Wp^V-G]󍆶dP^eI@aVS	zI%<6R$bG:8Atݶ;*xE:H+1@I.lAQjےEaM<cS#a_>4Oû%п4HS%
d7o(a&oean"L.
=}AB{|yFzf{z
~w@w9I
\9WV;,gI}Cff}Rk(ԅD=a"AY:1*Wf|d/{HKƤpNh|+zܵ \踑ԘԌ+heLJza( yk3\\Y'$!X΂DÒWԨȃV@
W2ށN2x"n߷sɹ컨1|nwP:a_oePц&5< BpO'7Cx i0]
jKJ95
4C7rE!%{Uo@{ceQ	51 \WےrxNa>id(*;, ǖ,-'o9	NJ',6S;J 9MV\p%p/oT~xEax>x)\OP#?1b0Qg"S.'W~0؆&RHk5T(u
fBC~OκUS-ۯ J
9TRpu^ K9QR]Q.GZf$n=L̶v:)F_<T[mV}
xGSW\oi_i\6xYQ\´MOZJ,~4dB?=67)
36($
.9e+fDDqK!Q@sd jn M+ҤhhA7"ҷ
O(`}2$Ƽѵl\%hXYC:^"`6:+.zj*L%B6]Q@ִIoِ!bDFsm(蕕˗;z'zǿJlܵKϚ9-嶼dFQJBPx7DADNRyItM1PYw>0{M<+dp !E.K՘ߢ|n\}:aYP.8r<Mo[t=WO1gy]1;Pa+Klڜ&/j+QW=_NP`pno&ŋ{~C'(خe^,W!x*2'ĝAkЊ-KQ%yD/@ʙǸWDz|7g?d`PpQ
O^ԮJdCk?^iq>NOE[2~8Dy.;JX9C䦜
S֎|a,Hŀ}B!-
BFjL+Hȯ*jW`LöԨTYy.w;-4=pYY[4Vq՟*}j(VL],A=wRNESMF	X/x^4TFΫƜuaLoۅdqGT;ѵۜҌUZeMcpmcE"*'9Sɤm/#0rT\bP>ӾDZ7U%EIRKAʖ೪ r& 5Ål~=ߝӄ:xtI*{ف^$lSE4	K]wd1v
Flf[ }g)	Ղ3B?/sr߮+-[HƧݤ;ޞUC1PndQmWUFihrfE&Z2ogᕼ|eM6YsБ"]Deۊ2Fk u]*Oȉ;[?	qVq{J̷@(rR3 "T0^(:7M
w@_LZ	:G!![DKv[rtzcFџ蠅v/l(U)^/CӑYvrSVY^	˵I=3X%>`eĦz@3|zɄjR&rr5UH{^'qu9E:7"pQ^N-_ds/~zuZ-Ϻ4rs@'bPʋi"z/F#fFҟo-ud.Dӻ7wB2yƚ&kF>l-՚xti"l$$d»>I@zEMT yLfJfPLQhPejl.B5>VUt_u<CX=E~@,+O"0J㉞NRy 1C|qh&f8OBҴLPádeNػR"=(Rdj^{n2JJ΅R<lxYLjRrmtj~Y<zuqOߘWUy<znxxr~!'ߜ=9?YﮎN.>_a3	BlNуV>]ABHd)i$ܜ
5`)'غǨ+#v[9
CD1]9"Gj^k{\bH_\-ꊈA|+
sXyIH*ay4m2_1hj/<ַt^wAT{X'xR+|?.[0NKX=`ܥ
nO#"ݥwfL&e:A0&Jzk9l4OHNԌv{qe>IN0EU2KMFxOq]nbS?zkC,'	aOMx+M0i 7 \FDL1~*e+:6]?Ab~}K"ϧfTԐ N1C+uxJs+~d@"7B&.󚩕(8Fk^=A`{{1)N{9!'B]NIEee77v9qo?gRs5©8J#zn{=<v@/q 
'v%`oT+E

MlsT}Ba:.%zD{#Bg9 ZV!. 0r<~._mGzGmC>&\
8LQkҗ/fәA!ʅ8s	!>=PTh3.VNsxq|R^N+3:5ӆ(d2)FyYXw.ׇyu?oGu>SomA
"}Ǚ%$
AB&9DCy@%t*4?pj]!YꓷRˢr=MiF)>'l5\4rv2qV-.︞
ɨ_s otԠ׶p˲cd
wpա&g"|9w/ƈ~6|S Cܡc}muӜ&O	<p7"MY4zM=Maj}MF%&?ꖰan8@XDiQD	AԎv8xX&K<h;6r,d-+Җ)E&)2M(ӚzCѪ
l^ߛ5@fW^㻏աIHu@:^ެ	E+vΑlbV.~ r4du28RlK̨,v.zW~Cv|+SN!ލ1w6=[{]8]-uc߆I)"a+JXl$mn۵%h0.׬(-vMS⃯4u-a˞P()km63(KD*t'@aRyzȉU{mg	ůyKv)SME~[	鐌(`\ypsyʷh?Բ3K[fJǴx)oй/WR\2,eOj9-exLqHƺUsP7)DbdN9nxLS9@m97jgd`l'x>s"Y隠Ud{5JWIZ#嫽F?TD|D<MqIP!"_8T<IV׳ƚ=
3`ٍBn;0&Kj`NA;/@S	(Bv[hb4>(y-vN<4;d:H%舌-~nuy,tY/t
{V_ށ?h VxDXXߔ~Wk5SJ~	HB-OJ$B2I搧]aɈ9'pAgL^ ?(fڽ~WFr,` KUZ{UOq1K4VI>Q@֔|N%cr_+lRY?ـlGAk߅_RQ}~]սgߪ77!o2>Obz
N3+dJDH+	 r^T`>8g F^Ƴ.|^zIx0F\̪{oL4/4U<c`iY1}h`&RA>ǭzr|wo/q:y\&dVLMUD-U@5U*0!R!
WoT!̪ͭ.DK J
tkQJ\Jm
,ɦ,W%"e%jmv{]G\IC~q6"Hz~%+ `Fo߀ũU=3RtU2zvyn3C1Q3:H)n{w/C QAT~Lc8%X(>!uUw:6iܔ^c\R4mf*PA@[HC ~An``O7F(Y=>6&K~nq(F59SjX'U mRmsUGwmF\fv3tAcE9^GD'Yd@CN<ٍ*-4@#JZԂ+z~@H;~z`]'SG*/!7T9
mi:m
%"y[.?-{=
v4s1Y#;FՊ4D
L	t]\A/&GmT{ʉj^47~EA*v#`P+9`ş2KIyHVֽ=q]*R~>/$ҔR$Îshy֠3{Oa$H!@HM:-Cw1E,eyg Rn/~@ϭYNٛƫYZa!b &^s~?r{,P`YBa~ױ8Ck`y+\n;O~\a[*Io6۬#ւGĔ@6;xeO@TD//eyx;&G ./S#`[mۮ
bM>l0V?UdoB:E;
[JkChR3w2n|k?B&z:m(B*Pq*O-3{]9/NSXc03S%k<G+M؅K.Ecfn?VNd}8Bf`Gd ,a$:5xZ{-tm|8+!vW
VˁsZ-ʛڌU\X<#+(zG
U\	Ht4}BXWh,c~w+%5[DX&-x;>;;ؖe\hHJ{zX9sYw6h.NfiFMkM+ΎH`vJN#l@~oc9-.-i-įiOR|d>B\-Y	!nWa6/*bDtqy"RJ\ zט1fK&sb0 .K2nLVyklݍy{zK
0BBMhDIz#zsg\=irÈ>%+,>/Fxz+*Y_KD}Ľ;Ǚ/\F$xZ[өg.45q;3Cn|E;۬P~?
r\]}:=*W<|W*JIc[蕪
eWB'	:ãAT0S?O ǉ(Qaik3FE{{a!T0
!T}Hǌ&E?䡛[<̝[HIy	쌡u&jʩ]C[C,e:K9PefCF(^$aiw݌1ČHpbR
RIa/| S[n,;ز_͖]f8Z3oG+ysMcN@4jS`6ɓz
f^>lë|<l5Y)/͑iwL\ MO}f<i.uAw%~Qf7olG9
HRqrם(=W{yI=Ae2Ef
IY\	֔b$V4ё!@6zFC4t.c
(p:4+rtF0%j?/@/g|ǣ-kطE`k7N],ڞƠ-!0LU*0pZ(2ĔgU#!&wY:r"NN3|+Z	
RYd)v Ӹ e%]K H'l/pȿbnEWEjFyOf=cN={ۜpI}PFg7b檰327pR"\?
xDvr]'z^;i_V4QfȶNj
k^-ɝwFN#[NuXX6SOLQSMHۘd	IvxC9K_5ˈ`ȧ_'#^~'I\Tv n=.ʵbH fq8Gi2Wa2p!M2LTѥXk=1Re?
߉{f^%rd̴S]L%*h
VRi^/!ޅP:	63|ձip|~2@ߝo52@Ӏ	\̯'KՕJ5䤲 eHF%Y
ɳa	axO6z.pK(Ƴ8KX_VMtC\CfucЄ˵aV6}]FB
IsNKVcfddVbwo6[ȯa6~$BMʎۋS^nҙB8V>
(o1s7/]F0<(i0@@J#kfm	~do8\~ܤ*r+$֪17BfI`zFz+*|Nro=Bɡ@L\ n,TkO/Ap|b;1N2<ebA|YY_KIa6S{ Cc%	X'3zaI圴!\WM"y5wżץљͦ3EX;bM}7eSd׻Y͂׷Ow")B홑Hb8<Sy!m.]✙l&}Oe]ɧ8潕t!ȗdF=ndR$Ms<%:I9|ު(_
xi|<R%ʱ'Q1QÐ!x0wܜz: Q-=|&w($
YŅ
2'RQ;)KԚ;ȵ
 \Vv^i]6w
7^53GX֑?g^Kät\P,( /xM_홣6 DͤU)\٨J/S_YgouBb2u+=\9P4~yrlq,ŕ̅N*6i<wh("<5NvosvRw50zbM;@oN`USӶW邩h!Bݑej/Y.'8_O!TL&S5^DeF.aI	0Wb6%?M&YtO?׳b͝~]8ZF5j
W>JW4| /H]1pK<Ďqu^7.!>ݡN vMhBzLDֵXUρ
͸1M^/
}!PS/es/O;<tJ`waGF/$%3AggאZ`dQJv6e 7[-OPgtئE|Ķ*ʵnY؜QP~׼4\,oeCzqatuFG	ySLUjr2Ti394$֐PRzJ,4b'	w>8xĩ-p5
M&, m:Ą	u ӕ+O
5u m&>0;DAӛ0|{OݽV,:EJKI%]>EX&$nQ9P8z	:9G4ԔP~YP±;+q^b4I`ً-
^stU\wƓv"ITFQeGGAOETu6ƮEmH8ҹgΊ۱\Д0s֐Z+AY1bdE1Wrӣ? [],,ՕP#WZ0-ʤ;\HVʒvΠsEFjP|{6nL*D;=N93_'2,-
Ռv`Yz.xo.{Nɚ.)]ԡu-OSAp
<SxO8qytC)iQR|X>r0k蒔ENbeʒ!oy'Fk7f?!ن9;~NQ;w$tc6h&Pa(V=Re/F20Uχ)4$orD\
gu/*W5RSb'n	bN^`y,6k2IyΒo;&/
$i`ĦFbK<V@AIHr
ӈ&Ĳ%UT^?B"6wk]suZjrx*(E4z_*ahb-Ӧ <ٯ`7F5zΉЩ$:j=W;!2n$F<\J2YX&%$׫2dpk#n`pصXw_	!-,8;z4Ϊ6s	)N>tʱOXBCJ,#qjo͒Maͽ3찛W95*JhWgg7&#X҈FވD--n\Cq	j$F-!`"aeg
#$\՘Fʝ,%-ѶT- H֏u6!
812EYcGAt^d|&J,ojf)_g4~RTd4J2'
RZG:࣯sW?~Z31q`1=]	^@JY{
}ݞ l$#YzC_7nYٵ԰T,
4n;vőU׏{+`D
^=̅H}9
_3S98.UfEn_7n4;\d`
E!A\3iYBJiʢ.ͳz]-7ԓʥQJUVQ&j`0"?Xߪ(u2J1
;.#<[`GN& .(Db-퉰+$*Yv<[|؊{t,
1*3YTLRQ}:;dxI@jVj!WM;+>ᨀA1bSo
ޔIJ2aj%MIۂ䙻Z]
}|wD8YX5XAI{ME&rFQ=ٔg-vC1JT4^FfndMJr^<f#E":_6M+#!jAoqL[P5yߪB@Ž`8x>?_]_~:;;4Ol=|qzn<V^*raw6'7~"]}Zp)H%KU9]L/pj\ک{
xk[u(4x|w`zbc j*8
J48&F&͍H.yTz,E%:Ҙ;ƏH_߻L`==xhey\䥩بz'sT|%Ba&J\ԸPʴ
4㍤

aa3=	ri
:CHie<<qzh2k0Ms:Fy0}3'<=:;!yq3VLzyIh0_McEp(Hmw&hEmP'TdRB+Ĕq8x|_,Y`τ}bUB>GсQdAg9NV]2axi<1glP&u^z$W㐒rAR¬^)Viae{FMDr4#1vUw>)aCȑ>V/Gq7؝aJ$8cg	lŇsNջ-Jm+[ƐZx#娥|,;k? ^{GL2a\\Ǎذfѷ4zCY+<޺5>\{ީpвsIٱ 59dqŻѷFmj\3Vqi['``yJRXXj"ȌCP
\	IB[g{=vϙ§еEMOQ.DsUS': ^?kDϮj@*ޙ ѐ[dJhO\RgK"@S-n(񏵬 !Bxwo#>lC9N@mp31{܌?~!j%
T5<p\
^y>8Z9ECi1\3l˷;9zjbljBݩ3i5Ҹ@
=S@l
*I<x\]g*	OM8^ܼU>9A*D38KH@=cQ֓<cLjk iARB*oA*IA2cע5nczy&dkmAWGr/IH]}RtW?owͥ_x}Y&RZzdP[\r;mt[<F;2<ܴ)A +C=!'[/G)9>z7/^!^R6J.
t)kF?6ҫZ5*.fmn+	k-$R0~p^/T9e1AE#~ۚE*&xpz][57)=`w"Du9S yy4N,!*6_v4w?^x-I_AxO/8J+Z4OEB'r7d,c9Vd#I-l6rV}2TԱr23;hAX/y89>;z=I*pBM堲;LjF*5h+DNXZDZ39DjȓkFIգo3w{ʵ.rBP~")w/)۵125zʸQ -AOsf`^YCEp>AIuW/rH[O鯭zI9ZNEHNF/VtpiI	/^yJy/A(okCȊ[D/@ӵ:u~9jvۑr;}7nVb㭅X5g<sݭI[Wkny
B겕E[=#;C~\ϵIa^L{4D74D.#Af;j
V>L[:;E=׷	2=Ju˱W44DBhjkB4yGq$z5z>V.u2I cNC .@.76PPrNg]^-DN\bUnQ̵vAVS}<F	|0b_9v
!g
ȍ[GD?qWDc6ZwjgN;4b_ڄFTȭZjwQpY*l ,(bb5h.`
4h;?tYydASxO0}Q@ >,{d;6+)ŎׇISX[z7	V]]mMJKE;DH8=7)e~}S\M
7EQk`JС)j.(_j'1J2E_>5fZfϺMQH,Cˀ7i=d7R]-2`("Y:ɒ}tB+,)f'+͖l,ZO*:8m6mXBt5oDaZioͿ_Rau|^_@|$W>aWĲ.~p5XF0M
Rrh(@V7IYMo+quoYm0m/#L&?KMOH4K^!kreЈU7ZR
XEa5<r.dJAW\JMJcB"\[`gmehjH2ͭp6*Wp|EmqSW؄'[V
4{Lq^=#]~(i;m2FqdSFtϵRL50
 *F[8Pz !X(*7W6aG=PLr8h^d9`-:B+1ciT
Mx/R|]G8:bz\L59ܺ5owיWHk,9q9|hL܌}x|B.>bhlީ:r^twnLo-@+1Lj V>JMaSt[ЪgLfoZcc׃R	zʰ@nj)EF.TT}^<nfk|-q`X*r<YrZ3x- ]ҥ$
Jdndz9h
<;U&f30\=p=ƅ?e6*x_Um^#L}JQKQ
wG)vS<0HN 1\DL"/0nkI*T+!'(%Ϩw2}N˩#nUG<VÌ;#_>}-[S O߃igc>uI݂1J򍛋C|}C<ǋƧ_JSt"=hJӗ^t'EL!okc5l̠UТ칥X[.V7HGw):r$"\
m . Y0oAĉ+T8~Ekӕp.^C>9mAfR|FVd4Zu_TwAX`_A3(~D8?wNBUY~+]aNW>DImID7ҁ$,(F64AT[Tp=I? \˼88LA x8e18^_G-QF̌JOghjf=~EU['-.⒪{Xe<i:xt F!Y	7'cDPC6xeQwKu$W0jjYnd_3KG0MHaHn.Fٕiz,E[qe854wR/Nw"q
Vjc|yVt\1b6Q˩CcЪ/fm
ec;X#_2 wYG8<ys {`TJV')jioҽ&[ci8v;H|\WNU&:vJ{;UZ4,p`[؍*o<Iώxj[]Y %ed-oTf;Bf2JC{)7~zv Y9>s=N9ٺjk-2/,Wq
hN5{VMv1Йfwr<79~y"?3Tc=SS,-@nmmnfz$ʉdzJu
}@);uBWS.*_Ax٬`dʳw
uqytxpr2<== ?>w"R`R[
y%7;bͅwDK-6<h,5(3㳃?@XdE~ɲ]ٕR%tUH"^&^\2mXg<m%>esܔUT~*{L˞ZAa3
M9b`4;`
0pbPAg;)Jj\-KPyP'S	ʳefGNp5>uEF܆{nwLˬvXԻ(	[OĐ8`0hќ٢8p2fNc&̊?^}yn+Hg1-N L'8NVгpŮ-Bf6Jk2z
mVo8bU*lW?`U+ziCXõF"kYӫ>6+([0ef6)ÂCF6c'"Y3ģp6r|E$gn.ߎ}E>i#-kK:O^{=C^qBlMx!㉇b(ȠǓ_CSqʻ{{T᢭,S5ruvk<Aa)ײl >埘%T0M8@7QBd"7NB%6ȷgG{$~?tzSukZjO%}edVjoHljx5(ܲ(mKM_:ɹ飹Zj$`tіV3uw#
1	kv4%"F(cAiX>jI)]pd,82ib9:E5LBb8k=D
cjfNN/N+ Q6FʽWꚖA'OЅc(/gp'޻d"Rs0@it p!Ӡ-yn??_w@gz쫹3dʔa>n{RV<0Ψ>G48
w$'9Z훒|"gT.{{g/\\&N.f%XvvN_ -ퟚ`M$~i2vPL B.d3B[1J}gEqdw30EY2BܦkE7̭RJ4ū# -d
޻y[fr}.
sJQbfaaJ%R69balH_;gBO.$/)VEejP~Sdj0q]mL}Aє~Э}̈́^-c)0qe~XM[5݀}k=WkGy>UOESێCu6_9YQIPL-%8'wJS
ߠOYcŵ%nܧCߝ(*|~?8V?׻.FA2^J]z/ߢf?KX
;-	u޳ŷ^3\0x2:Ûg\͙;	3pJ0oqؔU0dXu0?ٌ11٪Dl!>7}H䛾>;?v__!Zmaȁh	"{6V?PG#yē˥r4j[Nx-,w[80%՝gY\q#Q6nᢧ+J(5FU0Xu:;іLGػ%Db_Sq˾iR1[TQ	Sl.!J.wB<C (ˮlep7h/,_i8PQ 7sJea	/HuN%<6PszUqN/^PA\o8FJ1A+#BFN0~ 0Bág24ޡ++p8f}@X>
a]_~UrvI6J}a1[bi~-.gP=fxW[iò%6E~OD-6:NpnQXY[%BD:{|gJn7M}{ClC" sP["<s9q-J7P,bkՀ?imORg $*'oנ
 'y)m9:XGfPNuw$-؟Aw{"ZNZB-4_j:toA'Fz%3EG,9|!(l:Ip־ViaRWBˣ(-a_!"LN ]
򱴢	6Ü±:G쟬;)#8:ss,]z`TA{?(IljKKr
 tT#) *AV,wk|
n^L9L܄i$WmP<KCzE&0.&ͲO-/¯	PUcsP)9XqQI1YSNe9.ըn9e VP'"8"^ʿF	!*'5Pl/G^	[kEL^dկhf!vp+X&EnC

J֖EʼޑW"yWAo|gAyD@&,٤5^W넜ՁF[CKH,(C^b<ӄv9H6ekMLtF61T'j4+6'AYN\9aX~9@Hw@6Jd/)f@cՆl7<oVFb*>̪ڛ:*`Rvu2ӯU>$E&F7R0/@ C&g#Z9HN7U~ofrOΛ[BGMWfyUnK4R+Zc.Isa/P]4B$yƑQ/:+~xAvFVJ]HYKoxVnV~,mȹ<=%A(-3-M8qyWkc0/hxu}p-$ 9I;7x&Lxky([PЧIMC'"mFaUj:F6G'_BC/l\=U|0^9iFhKMXeft54w
-Ӝ
C+Xf?9UĐe?s#<:@r+):3.k0>Vb`wfTƱ9tn^}:<<QR3rߑ[.^Cw-#`z.IڈXʅ=놦c撵vT
LU6~nir$F&5trQ|84q#6έ*OM`K3 '<"g0Ax}}!ܒ/
v+UƆl?ଚm9	CXj
E>~JtN1"jFz
CK)kXw4K4}m	~gD4;fxXů$U (sO%O]> !ȺÂ^ 8%2
e}`U 5Fc_
\)'BϏ,b2/2dAyɏ*0:ָj)Gt}+'Jz^Qe}R[~_)8Y8欨p𣪻^*Q']ߋ]I2ztKs5v1Ě=E" z~xEY9r_	3WkIePrrJ%f,,TYad+
`k
&T-,<:Jez}T֗*[kFّBFt3ncooT:[s,Sĕep:|Po>dq~|jpZ@)BZ?h?w/uq6Ŗʦm[b٣ډс|J0k[6]5r7\+)x, 01:$9⿊ah\V:w޴Q*߂8jg6/gJp&_DJcA1jq;Rp[t,W 4D9H}:Y1|
q45!p2M|)o%#_ӧ?fPJD%F+K
g, F{lmEvT1{y|'.H(WQ6,x)-v#379'P#9	52Ϋ:WWPQ(jB{aNkY, /~ǴV[ίd=r-1r~ƭiDT	ܤ;W?d^=d4^aP#U^[W
hmn-lf4JNˌHŸ)Ux"zi1k{[
#
pumL(MeܿB? 8MrvG\e@N5SidoB-zPls5e'Cٓov<KR	oxi{ɗ):(_GHj n_ϐP8,b-R<;rT\!ʆa"LmJavUQ@'yO)p1D܀n*Dsv*t6b=Oֿ7=Mz<7ܧH.Mu%L/5u6@4OO`6,iZ7.{f=JW4C֠U>Ɛ<]s
"GѢ ׉]g<KĞ]M$H>w7>P?k
XЮ76 ^wgu{;*lXArFp7׆
1G%uVXB
~$cnIv2jP
{IJä
Ns)%uNLT玖'TXq
XLCq|T<Kœ9ټg,InE#aޓdw|1'8!S{;6zw:zn̈)%1{
M"mSjF<Dli$g:<T%&r)3zBWc9Vyzo,Yrhq_
8DI67p
D/8t5)u`gd:Fb"(%[:eTxhxz|QJyyRuR=3&y(LY9-C6kW2JsZP/Q&v 1|PQ{Up1|28Zu3Ϸ=tne&zo;)(#dmFka!jjdϓɚەT}Eܸ!P0
.u%x$}>-SXDYjTVfsa[+A)4;Osmƀ".6Ik@yf9[A mg` t_TEٓ
:BM-zKW_i5	|gyWUCjuc-7PF+'>}Ԭ6҂!I&ܮl#{6#Lz.櫼@'^i ^ls?"Zt`?gSxL²0fbhks)ǎ#qbZlֈZa9^i6B`nm.P rhcáH6NALo;_1B@}YCV+ƙGI7=7X^RMࢧykwË=BN<d1>a5Ec(~y0R@	e#W̓l1V/(ΏH"߫\xZE9_gnBu>D ߊ")=~Gm:уʅ@[ۤAfaVUo
qp2\28mWnӥ\e£q4X~
iS[IÀjN|[ZǋE[ŘƤɄT5Y4SF \г=iz=(~Vr"
-<MqI%nykSǁ%e)OejF|d)SKȶ 5COtQhѧܽKǉ_
VY @aS+H!((CdocL$Zf˦r3|afeڎG6-h NCK0@p	lZo
0LêU_k)nvGP3]2K-ߒoOC>æ+}@P| hTqHjj&0+rf+P1_
69%o9߷9ng|6~kD%E:"iׇKӚM_ӶrㅓtvNHyz4Dp<r86B8n^CopaӍw%33l[͖V)6H?#I#Bs	hȶf;P-҈\!\\3~yǽ=HJ8h(r)
KIPW!(xs'
oE邩[ϵMzmMmfM5w8	\
D2B*Rc<`"L|sSp3U]&q6te#Y{iꩃ7UjȵT<XLFyAZV<(-F<]~MHo6^\|ː(BvA{MfTDܽC~7ަvZ^kxR*eyb׎2}.FKL$%T.cDՂz:VΆP.MThI1yw]Tneg) 2?Yipj<^jI5$t@$تշE2W.|up*
%[/
Yo^ĥgݜPt"bt
Q8La^s\WS@n, VeddBϺLFCP6+n
S$\*rg30_zj4!\\شZD8gE%?旼LZU7܌l	|'DyOmX Q
J,*Eq uM&Fl26oiR'pxZYkKg"KS\i/EAwxVpC%nm &@pж!v&<6l
.O!U"0Li[
]ޮ^uVW,QN+0ˈeVwTis9#~$e+3Š"װWMN/2)'.!er/CNv0wYޜL.zm!f
Zbp^Fyr8\*[wi)F?p2?v¦]f9AZoN׆ZpeZ"sKE'KtOVyCͅi{ՑEme!d!t"\)y|q% x|
M ;"L}ڗCuRswra'4$ϯ VyCL\&!|vAqeK-嶟P?R
TVP,+Ӆm]I^;|<BrfFl
K"<D	Yk'`ĵjZyO-7Vπ6Z}%ߢ듫:+^@QLWW'5N
lݖ4Eb,IQuY-^)+aIx7	NFmqL
;?¹E\vbM	y]wgvkFt3|57*J*&ǯϝ9!=*~sP`Rŷb4uR%
%T	![}\x*u|<w8B#`<J+~FƮdt
A7ֿŧ0ê64Q!2PXnc}.լ
0} G˽0A:DUwhlNj@eU-b+QҾ-W˰]~v`d!ޕP^2
5V,d."1VGy/C9B/[n$"3LL`{R<!Mn^6๪
"_b(6WdyCۤtus~~Xj#!s][ZL^Jo԰F]@PwyR99/AS=~^v"H6BbplHW$#9AԋzOëXD>vMRD1"h>+*,6YXu+޼~}T\}=IA,F{Jf>?K*u{r<OK$[Є
skUP'KZoÓZkm0	)v[&' FlЗl
cyxi
<ʎ8
bR㍔Άaf豐NnIo+
gC7ӆ05K(h)j]V42w	]}>~:;><w4g1՚
1UWlRhu9K'oڝUQR<t ]g(QI_SV{/>Y5[x2~e&'V
ono_ȭΠ3fB2Xf7/
[?uʘf=X+¸Zf.=yN⑯2n<O8ZdĊt+٢)B
͏FETahd`n2wxƐۧ/4٤M\ۅ4eQՂq,	4_gE>{B!dn'ZnwNGCahJ N2YTI;<`H	}NրC,mB?&q$e.ҎߏӪM,s0k!`Y	\Xu]\n8p/OUI6oX9Ӫ*J"4f:ҳ 8.>fta7Kt(рKc'm=v	%Ȉ,ᔙe,CaElStkMƢ{;7\M212$OҾ {DRt{
V(|N\~ŌSxټ~\מ]إ^d?<U%*W;rK"{5w-~K4ڑ챳6'l~+3lI XtyXd߸W-4L/XA0FH -aUPZO"ww=31\@;"jY؆~h\"3<?:NAx_*ppPկJ{髣oyZb#JM~pB'ӭ)iAM du&S)GN☦R[LD.uP<q>G/7z±jw}Dw0p4F9ҁtBÔcV/VJ+mR@#\b~{}Η+|V8<kV~lAk6 &Wo#jxp5|wp}PudT?:7"!g&^/䈀Wrt&HĀo~Z>@dvXfJC`'hx|\.h"2v1Q3%ڇPĘPB:T"HmPGTqXvwqkk'B E4apǉpw~fؖtq,O<yEJ"WC`dD'@m᪕pybqWfX_&!'Hy%MN*XDir/<r@7­ґWdLV5*Z.E<f:-jA"t2]%޳$ӄ5ZlN6w<X^O	H԰csC
DgnD_dA^zN`v@[1shOie:zh
g?{ILd/>O?Jga~<:9w{QR+S 9*M6OB 4|LJg+Hgc%5+`2two<K1(B= %KPoTZhpvp2xpnFjd02RlDLTP.33u,Bw/]VY*BU 3>tqW;(?">1ԣVӴaT,%Z#o[wEMZ|&TBCţDz{r$J%ѽ}NGJӓLjr(2!c䜩:,)m&ȗخ-(LıHYȕX("+n-Bd7YBK!=de˃ӋsZGRR1QS
WGt>~N5l{ٷZ.;+Ղ3~75nDWΦ_YtުmDZcB.Sbe4+TX۫D)^(<(+ʣ-	oV nTGIt앵GTD
\FG'g*)VEԲT۫OGI~j;fV-O
|QOPS)>]eӒuRZoT-9TנNO^rݥX5nნ.͎Jn02$M8 @^f̫g
9fl<pU%Dw:!0khw~aH/4[M{*3Zw-"K>N/Osa.N޹;)X7Cb;EC0AIk@|j~?&6Xjbo.[֩F wYkJ*sw;(O ,8Iu1y:'FHJ=)nFlU
GGZ
3zA 7``ixr~n3tI3bMf;q*ϱWjFYEsN	P-D!"[<@Vnd!;F}-$eXySٹ5 m,_yvbujt6V(4ρ5#eXwK邵f`݋j̍9H9QIkLW[}dQ*{̔>ːS]%}Ha
|e<u1I&;=/Gj]XCOCü42FL\,B|/ါ	eJ\nl],O1E%^0L%1IG
}É7kɱۮuY^&aN[OJ.Yy '!SqɄWС$ǗQNk+h^Õt5#Sx[b\"Ŗ&s$<"bb;DʷHXa^ee#}Ʋe^vq{^#PtR?%g\=@ܮ_tDB~;I Wa6ņ \7
x;CQ)	iZz1, {rSqk
f$! 1`)uBWӃ_~x,Ht};ho0VFP"s<M?$q;Gpz~E2'G)N߳Gڹ2IUۃjV-*v
[~"҅;Y2d#w,R G9D 5/f'Oz2?Ϋ+_Q*ގF ʏ R
	FPp?U(yrG#F $[Qʾ
x7B^;\ *z􌭵Tr'ZP{(keʙ3%HDtK(Y@7c_;ۓOG}z#j:}k]`p
3S|ˣ.nU*>s
JI":\-;d(.wrX,XK|(8Lo]͊nx_?-`#ܶV:~^]DfXZG;Z0?|6umR
}JK'Q.g؜r*,ҤߣaxY7T(5u
eC[쟏]?tWt+sy4{5qr#&<_[JZnYוh׶&»9于;3(&~2Ftas^tQҷtzJ1qrpxcǴ9"akZ.K	)?SZuM	b0HCW[jr]Y+N8N
b*|bo 󚸊OBoG:"`OK+߯GPR_{5^i {\rEeeɛ,Q<gS˴L.,s<mZ(0?WC12r;H΁S+-R>5hJ'M߯P@_Pbw6
`;mÑQ2)X(
\-!+)'3q!NVB$Q-۪m&T̼b{^4/dy?މ`tb-*EVA2Fq(LV))fqo02Enm.E$xs	ț8ꨞ
ˈber8iif/I(M>9K4f.zr[zU 2>5~̹`D4Y
SƜU4AvVBzg<o|%gdrI9^Fo|NV.>6hKE[TO|}u-*7^ѣ蹘L;l&&<!	(᱕2kT++Uu-@%L:7!6HR'c.y&%d-qzd_Ǭr:r0&l:(%}V4?p2/A*ydilG㲿;R8y (fES)ndū8XE8~wfu8,=ȆwYpUyXf6TEք0?4ʶl;?};	NWvw>-	eTvw(Nɹ.u"8`ζ@=F[ʈ0ig!aYNto[Q,{,tgT
IF#yTs/<d[j9,T`#ݑV<G쎄};NȎwyj
;&gl쨄Zw۩N^'_r'Ƨa_C@{6-,)&3%15;[א12ַciOXe13cd^]TtqjLAi;܀$^6i2	d
#T׏ 4A%}=cŪ0
N%BڈBn
1
U:Kw92Y8'HwLߟLIӳHC<?SaS'`spUd$BCfJ綔=] LOK#!@O&3Q4WaKG͎1cmbc,LE0`N.@U0iC>AӴ&,mϧSOmasYL2oԹihBnou 29DP zɄINR]]~g:aje
T
^փ&):3UrSLݬEl9u?X
S]bLDU]zKfQ4]gN	o

/BS\l
Z`U4 AOTxD:C?[ValNXi锦#%ѯ/Nj+W߀xυ<m{J}\f\TJ- ʵq-"Vp/qÕ|,IogvVzW_^L!b״8N^{d~,42Yd,K;O5A֛1x{]Z@!4oAB^3|w!ς69M
*2+WџїK?L9
Gg_sǺ#-O;<pjޟ؎_)pD*).P[ds5ûW61¦7'MA%Y&tc̙UnVBiP7M9ւsK]J'!nojUư|7DW.[qh~u'PG
KlƋ䞓3`L9dyx-0O\)H瓕<}~^e
{φșZ1aJ *X*Hq*\ zHۢqFlǤ?PĊ=mL4
\̄Vɲ6H!8nd?^^;%z|S|{'iF_s&)~Epr
Wb.amg	׶_K%J[|>k*)C]B+0
hayeajVwTvJ5{wߊ	4e&jҘ!䜑rJz 炋=4c7i+LlˤKDV@V*tݽ_;dFswi}i?#XCѳJn٠PsJ;sWXʇ:w֖(*ۼ4rU S8E*FhQI8"y&D|`d24
.L--OT淌"3xm,bdɵ	-
S̓FB]aVܺ~u]Rݎgpo'쟠#J^$C]PKn04h'7*#	)"6nv:PsG~
?/11lp't㐣X`9[w)sUZخjLWo"/[ϑᕏv*GgP2ZhWáFHC48\+*wY~Pp583,Ϳp#*13w aǭ\r3%VVs{Ga^mAŌ&TڱdYPEo&Bi%\ʴfeʞd6ܣoيoe,~HZy:U¾.uH"*䇕Yzͯ6HMkR3S˫dhu;F3縌*J"0 
򵡂k $/jSб+dxxyJË˫룳 ~ux*_bWL+߯
9zʼD'␓RY\<":Lw*lٝyő,w@Sj@ќnʉͷ	S,Q&JMY.`,ruaVRk4a4p/}a|#:(@i
oݨyALŻA$Y7!׷^"Ej9L#ZhS@Mה>ĭ'<Co/8o\~I%kjllJxSJӸD"'<V{"'oE[s=IG^9m<fFQ<ʭkZXs0Z$A!]Nη5\xFg`gN/M
Ԇ5wbn옏@aA9@f"E<]6cJ$;~Li2]xf
ۓjcñCytAxdmv{Dab24/Q:ᘦ4.WIи{mJՂ~.Mk4&%	uv~	
W>zd#@*4#6<1a;=VFhJGULxI|k*#w?B|UKC4A=L`ݩ1k*>c3Nˮ(^`A4c&
.I>B+e/]-c3lmDԂܠhh^.;˱_rd=oJMbD$P	i+l\-K潎~&n6_K}Fp$KLm/
Q.p
1)9x&̄8>b݋Vrvqř.Ԙ>ri- ^3e
RjCx%Hz,؏pxՍ5z9a
yTՠEsYHҿTB0%J#L0fAѪfuKtr$?nuK^<%9 ٨[(:di	u,g.X{1Ex{ n :gp]퇩|0/dɞxLJM#iT+Wg`3aQqA:9b(JW]qAG}.] `
0j]Bk7?M0GZz}Dd'0C%e RRY`/,b,tvq,hyPT4.--q:ӑS]{[2eƖHņ5RPU,Vl3Ə
u0DWȟoFC
Zʿ&Cisx2eaI՜
O}:9ݑ-pn	VJ u4urcSh" ]90^Bђ4a:5{We
P#Ӄ>\1^BpO rH7~YsdY"}j|*Q1"&#nc2Qw>YPb
TXϹ*Eta;5:}d|gM_l
;z<}}	6 tmpZGF%)wj|~s}y(M%4NNYz-':tex`KW+=j =>::v{NTeMݽau0奩ޕRJ3+l^6hx:'n<aS)fgRk_`yNUGN=htvi֗(Xsjio`@xDG`l:<B;Ѥ}*7kwy&FvǙ8kb6
.
(7w ,rtTYXᐏ&sL=~DFFބ,/O@ǣյ`
tLPy>%dftAZ+#8;:fM[Jrj<y(&	lE8Z M.ӓHB׼:ht4wX\PpjIGfVs gD_ЮL~O~zrrP{l}pYJLx\d"H|Ğ%8.tJ2mCAtyXntv,|&ʧm
YۙO~z?"u{
ȼTq'og)hI/$]6ŉdr2_5[V
 %(_p\TI-`wmpKe3<ߛFi̕wz(j0<*|['=ۦ\mAIK/Q~}:kO{
LJXmM<Tyס߈#Pyݛ:hS$u3N|HZ
~W?z4ea/z~ڸjYVAnD}x]X=06q5%sBA
Rg;՟i
0H4
 [B.hYasl:ygzl:S2/EՃRgz(@FF:؏'Ucr !&YNy.Qz=$_n+ҸF v4WՎ_
6Lg^X>vgP%*nɋl/u@%yŵ0ڃ@2ܙe]}^Xbq{/`S@%5C-H󪎦@)Rh/ 5
<كV)RuBJD.#g0CD.%UFkUf0ܕxMUw{ N{ ;kAۓRjzh%'X]_veѦ0m`I,>=v UtԲ1)pN8`+31Kc;?8<&v/Ggށ4m1\OVA"0qQǟqT:rpR]
]%`~A_R"ܥ[)Rl\c0<3R2?#;K˗ҙ̎Fw}
ݳëttvxT~]^.xK3q*ܘ6F	?r
!A$*fDM߸
#sFJę˭h<Ion_lo38NQnƤCt~KdJRad{<,gsPaHeKp9t
b@к[)1#4`YG,'SrbKc>õ&*|\xQCad7ы?kNFR[}I!̞5^*܅Qp:à$/6|Aj o.<Ww{@\;:3+9qJJρxZ|@	A^!`hЊ5v	TVHiXP>#Nxnr HKǣ8A-;PwVoڤʠ=G#/xV~X!i_ ftI@EFsȼz&<Z%0Sop8E\Ǌo>EB 
Eg~SXaaRwyZ֜G)a;KRz-dGL~"w!eI柶N>a>8]Z׃6idS!,/Lɖ!6{!0Pn,fenN%FG-1W!'óӣ+OsU1ft Qܐ[sV)HdjͶR[頢pF\/sٿzʙB(Gyr,"Vɰi.ǡOFH_bI_y7AOEw$\_ŢwB\
UPX1[1tvx}|~vg|4Yo$zTR1ڹ/3+KoLCqQJb,/|C/NqN8$8ea;ؙj9/[):͒1Tߞl;˺X)<"`"L䇀&N-8Rz5Ěp1S4)c(m,Z\x	f8+Xrp2+qEbw*|K/U[:^u;ۿonh@K.sOK"\f
<V렔	몵A4Z$1K
v7rq1̖2V	;B#r0%zt|M9Xb*/z՘ ?#Ŏ(?X>a(ܪwieh<1좉W wJyU"xwؠ_]}:%WO1lң]abiuJߣk]%-(uѾpEuN^jXA{ʆ>'څG~^\?>9XW
ܤ%Bܯ5}l6ef8]~ǬɎSS,Ti
B{ k%կuhF@rA!~ bO`J'GOM[2,I2YhEM9əGW>T1c{Zfa
uͻZW<|R*8^Kid$cI[	)
cIy,T'dȄ0KAG飝@|E
̍\ϙMdT
>j-ŸT>}ie*fƏfҗXMvW6M@ͦ	=)Y;f3Alpݛh>
a7?o>q5.{_XOm6mmS\i~`4F 9#1q>>{{D^^؁',CzQJGekh P8AU\!b+\a/=Jwc~/t#֯fd\8Oб_&jť@>PA}4QM1
 :#^	uq#06#nԞ|zwZ>CCRsR螆;
2eANe7?nS[QkFQ `O:⧊
!tʐ_A0ӂY.1=31/ADw:E~e1^^q{Ӛm7n -|vO˱
"C
8"-s !/Ɩ}=83?Jm3*S(un-)to``w$C6lbT]b_dnF$UzPL6[Z{F hۍM,[NolPÅ~Zi| !zu
@yh  5/jXpyXf|̗o|`N<s=!=rJ@	:yK[QQ@/LW߄yD60w8_dL&mzܒps-z	D"[ 5
8k(8nTS+:83;	+`w˕z4s3ځù:AƄڮޢT
wȲ8i֋FN_0wg{Loep@a	%!g"^FCu4͎|K<fnqӟj2mO]d)F
b,NQ(tB* .AZ68&dTԅ]tLp]cD蔲)W_;#EHÀoIqvxTtFX_Oc۫&Jr16"SRq	BK~E/>8LrR(Ib`/8R7)z!-9hQ
,9#_kI
4`i!ZtqdH1җ酕 >0H1hiRsdQ
Jwk+U
)M=B~
MнF4cJ#.	zZ^ٝ$  wkQG|(QԝBNaoN3H*j93=
 %ȶB
؛ұ̙{NR1?9GFx` >o#L4J,/2Y&TIp'5lIgiH!ۜLk{G~?赦TH]μOpwI`Rhό
[/oAhjxv>8fuߕ-w
kFM`_g9m,<jVBT&T*mw@c[PDVЌgcY:eF"or ckfxY,$-D~ğ KhY#W2fS˺.rmʽ'>!b6$b'ZfwaQEnxAqJ7%=b~̦|xLoJo/H)Je4:*@<|x0{ʤWvOүM2 'SD<aB	Avl)w9I}*xhy{H)8rZYXkdr˼Ne){UqDn);9AA'~M-)Ŵ(<E4M&56 z^O2M
y1Xg;pq|\MVgRޅ٭`r}GQoГ5[:zh^zAA`e,53ҫ˴yIaѷVu9=ACC&'&Fͳ'bi cLDrJ0K`P/~JfQ7+kzP+Tcᚔp7^%TiF'_>0$ zPT9tj˗T<A.Q0FkQQP5zsCi()iF]cdd|,τF |Ewʅ%o{0L{Xo-=6E8]묷dwt,YY5j!-}:$:y}}r'/\hY
j+230
q{|0<Pñ9p1Y6Zj+\V*=9g)ey_$Z7#%NjRZی]) |t}	$.h34vCԑ{q%KV61zSpJ6 VlEk;l4p)ִ^~{Ƀ2yɕ;W~y
{vi(vm C^EW6<ֵN;xS+n^W@$"~,9T8GXXł6o&R~[94"Y[ۘݛĂ %U-d~E۫7DpE
Gc̽tqŊ ߘ=иP<Gb8~l۬)PV/W2A׬ґyfxYBf
ŁA#A=\) erc8Fq׺"_57x~DO.ˣǿt!d4u1<)	IjZ-UC:Su^|R;-iH]3aMKo}Eqގf0h!@VIO6dhT Ӑ-l7X
aAlhspU
f4zc/PaIvOL|&cnZrc,_5ƙ e
x@0Mm>e#K:*I|lq%J7߄b3Uq8Ip9noT}#G_1ZHKkH_Um"W_npe+`pCn7Î77PX)>`Q)/%aWͨn @M:)uqߚ}u(h$+P7.1m'}nr9G/R<X2'.8z32ALA	?B8!Mh
J (^ݙZ-Vhb4N^kvֶB	oC%(8ߪ2WBGͪ?J]s#mBǈ{U>D lQ͇f!RA%S L\ǂKGE[˙49
8sU-*ohk0=/%sfBB9?~wr$s(A	CHz
\bG	'`Dt&41&KJ*!m1 RxyGm)c̧і;U$7(gJ|%,ȊfLVzAkY-(hUλn1y4Y=HMS<.tDqN;x:yxf=;#T:Sq
;&@W',2Km1b8"Gk&oP)?@9z25
`qƗ}-yx#6ۛqXԝr\󮼱>zc 驍ceLx-^q=!43j,̏^Wosms	{N^]woh9iur+JC,5vW>ۇwMlzNN IѰ#KšLe[
`X@@Y@v@i>w.,i I"ǠUe?2<a
oàZU,W.Ս[7G!N2->=_۳=|޺Keu8$0!xӷH[	d\&ྡ3s`WG>dO8Տc.$J6[`]\CԳ%QKo>
Oꍥ,G0'Ri -*?Õh=	˶]w"+x&C#K=k$1
lzGE!.O@F=G)k3jaܷN=ݧ5&C?ןe<ёO.	fm
6?6xs(qlҶؤ,/\4
5bӛMY,,5/X.7J_"lWt0I"<^G/(J1GzP7HmOvJg֖%7iq04Hl!"
g/F\߬["B47iw[j3QWF趪E)ȋԽ-nYl!/yx vn:J,^#gdXunl.9s*ߏf{E[vvtezRohX
fzz=G
5FlsFi!N0jՉ7NLݻ -KQX\WR8Z-c	%7OWn,#6$L@ww˅舜qF וּ1b%l>z)4^𗨸N9d/dPD'Yl
2PĮHI%@s|ݥJW:;~8:~<Pz
'\&Ho|[2SgU$"՟x8;̦\԰矇M)ox(wI@d%h.%{Dy?]a./TX%0`3\}AR&S~ ?JN4J%ş"IXu9S	kǬa<
vу}BYx:KB1OT5y5',clig.1Aʓ٤[ަpsNbw*7F6(+YFDqB	KEjLƭHmEj:zWv._p}	l?Ĳ<w2:|Fv]t;3D-p լv_Wm
etK ã_0(W^Hc	Jg#W;b
"2v\>+fhSo{~R>E^c2(kx ,<tHy[
,)y)%M^ӂmG5*fϜZNh.K>ﶵ,R,]Z]9 wR(G
FUnir,xRx,CzQP
L:
OC~oըjT8>[3z.CE7KK8՛ =cҙi;`=5sдMgLϮ q[X&<viURHx1Y^xؙotg/zÛ>Do+9Mu|VQɧWrA91KvW֊d5	6
u|웒0Y2:r+m#~R߱TYEʫLY亝=0Ee&zduL6cw CkYQR)zSC_i/:.@>Ds_|z2[UWdZK&H$"9K,h\<Rd}{<]f<π{NrɩQ~\<P>@Fў.'
~;8 "pP8H?W`Q}n*-u)IUom qܠ):,mgNLQ@9/e9T>@v96\Mԇ,~t2hϑEh/o.X.RdJcCEh΅60Du:>JPAM1=^!G(^|ٜeZ+`y_4kma!f_ĥ*#UKkWrERcc5ۭft5nRPitx'd)70qpujƯ6
f\>ȡx&r}}MPXBܲ4$5@7엊]T:6ELVk˿ĿX)cdj_Ȳ.ApOa̿EH^{xER)AP~KÌD0@㫯&=y5IzԓYk}.Pgf!cǎ˾"9J
	כȇ'!萎,sJG}JaQ
+4ܣe^EvnЅcP
a^pa2)M@_Ü D |II'q:3Ly(7%9(|!rUO	@]K5`b>BjF\ZaM2(+fljElw;"caɾYnA̗d1CB\b/Q5?[#f,ҴT*`~<^IFgKC))kn8ը\30~fiӃ(#Ӕ;8󄃝k: ;n}hETjv"U*h,ߚdh:͖ڌ7'hKއ; }c[fKfZ(+g2q}LƷ({
qǌE{QA
Ѡ3!Sֻ|.CHS4N0vn'<VL9ȶ680 `ōJSeAnhUS}!VkV[q<TnUt!z≢?h}s_!?Ehc'r8-&Pvv
A.kLLg*F
QcBo!7-j=ZU{rxjy^$qQ:T
fte"a[},U#"E)*!⢢96L(iE6?';-HLܕ?-3=
o­?"Jd8\'ʾdcb^
ue9
uιMy[$b
Jc|kהXƅZ2]<1k1sH^%XUj	f,5<J^kFh{m!fzJٔ3;VSqw`1Lvr<{/Z*VGuP^°f٦2Tշ{q^o>A$Aő9aJ=}6샶▢!gA4倞ɒUW*_mCUAnH'{*{Th'c^δ&k,g\&7M<XA֚e{Gi5]4d(ńLԷͧ0Toj*EX!@ +ޒ{qKO+iFv7}@ب	ͣ
1Skc(ucR[Fj)sמO:QqU[rW>,Tv3Ϟ2\@7J>C;U|***x%d7c95*3žXh4LX]Kt~0uZW5Z^jq!VҪRT{c۝q=?©8VΖz7}؃I,jglŀQ

_}p!7٭frI7V\@k0J/7$ع8:PGѧ\ \0$Cbz9d;9lw7:+
<zp
.U~Bauy$sNcg<IwjjȪJ0tKy0*d܏Pr8*")w.4C^ Ӣ2!y7c0kU;U5.KD|v.Jhe[Z@DF}GnPAnUn-8a"|	l0U^'(a|}sAo,l#{;Ȗ?g<Kt*Y26d(L,3ŝTզ<Xn@a%Rpk% J䗠01X8߻ݓD݌Ac*ZH>q#"86	7nz|ΪwNi5	>#M @:|ZsVV^ʂk)n'$	C4eRG50E 8kq'`Cw]H
&*2rW٤57IrHü͟.i~@ٵ9c+&ዬ5ߜ} 9ek!F:Wîdn ;qه'ɇۓK6A+rfEϧ 4:v$jca%fwnH7(9\P#
}#>qI?^X=wgϐr}$N۸HW8;`a8Ո'w᫿}xyBbmok

d Q;ǫ"22=n>CvtU&V K_?|<Kt:[gF&~-΂"&&R! -(Ƥq9.ߥ:M;-ukgw2xA:3jRt
YQ1 b/P wbD4
L,r{AJ's7;az=j=U߼ՃW;Ut]ҽ-G9=@Tts+'ODU!
IF3RmHYj۬U$?+T_}|eBYN$[q-jBOwn*>B+~.d5jeR&=IAxWym?@)!=9s=哺([['|I99[VdrbT+M4_%tP4ˁKmT0+	[Ab}`݈zK%-M']Z%2nsX[^
&O!05Rb19)17GO99m9*71'*xp$j`bS
<t0e7|Uۚ1h؂X\ROlF@6-2=}_RLiyQS5n15\t
]hL  sp[SΞ:[+?p2($ƑE %ҥ-F,:fDmDr*8ήz6pL9p`=oy08JP=%ti3F.  RJVMg/dy'Z^Qqw5|!M`O^߼؊ӥ2<"1*f>ToCwO(9đJ|ᬊH4
s??ХrLG+Φ𹌌9YsTmƨ㒳r[5̎kzP(@ԋqjŬw~BCힹC9z
d~aPÚy|9+0҄y&7@<RhzrV7(z"CMRkIRJNeբCFrc6OIP+T1)?!%V[W\5mD?"3+}*F|Q]*ί:/(JZpydJqXEɱ
 Ǥ)]1t"	#< \evs/,CC>(ވw<?|~Yh)ƃx1mЈbFmyrLd"DHn49Nfs${y5bvǹsecaTAͿg/Vl
I)٭dm'+1-G.
g`I»
Xwq|qp=cQ邪y-⡰x)@%}v;w"LIRGM
*6'~Bs3	̰g`Pᖸ
-xSu;Q	I߈TQP|}0z~Y	 Cn2[EI>Agu~,.Ocʔc_&߶ZH_C6Ԋ)Z_"/Gl`V
=+溋RdzfHŝۻ0.ddy^r#O"Fu<yyL#k,VA1KEePBu6Hb;Fv!0`U	iCx!GDڨQtdZ#G>
J}+NX݇3~ȏR6|K)ϼZ1):_ߝ-o.ާM
[{vo<"t"%NG"LKʄhfxMeMæ$=:)lbSdwT7݂[8 ǽ_%)mfɸљ ).$$Uur"+))%ϊju".q򿕇g3NMҸ/1#qm蛺
$pRN;[/!帻hƄm1)[8~wSKG&M?~l
.>SgE@M )n S|`Fi=IɦPmW@ fepLÃR=Q=S]3qh(Q$jg)2Z-i'"{VM3r$Iπd
|QB=ZYVlEZLy˺+@62AC\c=N'/]THS,ջO6<}, YM61.|%6y_9e#MC.-,,GC3H:OhgRy]C)
L%aqk"wP.f7t4LIO
eG 0U#Kq{
EeU:+%"+>h*QoXv
w
Ι1o`-!PЃ*D	ɉpf|rA&L9?~НPD!zTV'#D˯/@{wKRZ\͜%\f [,^<B9!Đ*yhCVx%,g$lل@Q`R-Zm8|И I4KRmM%|YZ^kV2hې*c	PU
}- s-?Hi'=Fa's)>~,*^ .6*bgnr봞, AJi4MyWZjȺYt#UBB賥"jUj&tseC|-5FvPT#pVTڛJs%|bK4)8j<A)'xD}	#'*+Sx&nzlQWm2,~'(B{¹f6VY
SCxC`	TQ |pZyh4Ӏ\QLoUJj"0SsMaCN* }J׆ҍw>OJbw6{<h^6bt3q= j$@TҪ7|nA)HnTۺKPqL7?77/ALp-Wً@53EDyGvt#$ղDZbSzL^{HeR((HZCGMd[ؖօD
!700ow=õn{_E9~'y̾C	5R$׎"ekwRA=MJUɱsv_^ir=0Uu6X)a(Gs~[ik\+J'Ʀ!ʹ$'P 3
AJ|M	}OJ( X^q3ccZ.̈́"(){)ۡ񋨌DnUǒ/
Q8Ѥ)RwCKX](!'M_ƿ=z
&%o8VICjZDS4ɨ	`%24,$$Rfob+i5$xGQ<<e9%
<8fb62Dw
dщͷ;hI]>"ɫQB[1(0{
,r/\ߣem@]R#_7q#)
oچ`h1Ijїjkg:2T!JHb1Sō?O	<1Zz!($WQY0^	UM}1#(`jWQ7S2/"6&7r4X
moJ< \ZQ>*c4CK?D\;MЭ
=aΣаn;|l4=N,$jDEڕLvJ~S/=g
)&ɚ3+a"ko5+q0m(ƙ -$4סϭ}RݛbIӨ?jB*]ֱvSP
ad6#eO$	D}pPFq&8lA<VooՂH,4NiIu9VWR];?6/)HLO+bva{ޔ:2b
_ƣi:}qXd$.5Z$D#p<|p*#u1]c?a*"排z%C'Y:&R4<%Kpc֝?w<b㖂٫{;x~s釽ӳ_Ԗ,%#y{(YzWv.Fk&=v]Ù9/k<x;/ ;nvˮv,X6090
48Fd	H!sFY0΂'oF!柳hH"Ϗn>B<nQU@-UH^P-Jwӆ`	P5j^)4Fi$`oC ]U^-dvhw|^i=].kKn(<(;bc̒܎[e/%>(:{{Ma!֨nJ[V&`#EYI織	t8зmR_SX Tg6p{wQQtam7yDRTn8
GfM-El21\/$7\vDnyjgMڧ{R~.H8gI%ŭ@+P3@~ZȵjKwMsX X5C+W+b#TScǾlO%cid˳ѹԿ4(4~|1)(Pgr8SFׄgj"ہ<4j<LP_f\{E!6+((1<|c[KIf\Tm!
)ǔY'`;/4*s%N%%CO),4T ACnADJ
m)NtEmG|kksP~~3?;`$l7#%=w{TX?<DәQyJ<ux2>FOaI++~*}PcbJ" .8fPe:Ӽ6\MK6
dʎ750Dyjׁ
9,GO־;JFАDKLQ 0O[s3N27Yαm~yCy~<\\EL2H	jXzHRuT퀛2tM1ZmE¾/lZha _@LDO-PthPoF24](˽*aȕAv#EZЬbţun@YuVo%ĩMQV/j#Ea\MMq|)Ġ}T题Qs3SFѤ~+8R-Y-B\~@#(LG>ƮI[ݤhAdnkҺxȖGnSg4¡a?^\^j8ޱq77歆wUP	F$A
PNn`1ypdFS[琣Ӱ4Jw8nێhcQC3=Z *N7\qX8C_"|>oS9cwWM͏ܸMDRDTC2 :??"]@EHD^P]?N	-v-vP%\X(4_xn"GRiR]쒳h)cK6grBGJV۔RxMJ' 92R_joC|sn0Q.k8C\Av·aiŮ2E4L|Vp;b*UY,J7Y\S殚Hdr\;wZBE̤
zL٩Cˢd"JCC%R6dJK_۹MSylwBfegL,_r9.{?
{6ZY&Y lSr#a3
d/H25MM1/Oy0!ȰNUqIgػUG/׻r#V8֨{*wк
a%07/Ɠ/jŴɝްx=40xIRhWfe0!sF]M$ﶛ> nRڶwǇ?HqǱKLB6zlk šƪ랐*$ZȪk$OS6[獵OAkfq!TvO891zR7G0Fgt[CZز~?0IZSJv(y5{Zk4"@7[~u@IDhSᾘ
c1km2jcI0
V(;^sJTXޗZGM"$LDFꛅRsX:uv/+@4BvG/qgk5b̈́/cיC494pcÊ
KrHlqeJWJ׺Gq*yysc[-Qwad\.(
݃pI(UK
+nE	xIT)Y<E ڽjPKAdڵobX`mSL%vid$PDd7('jV^7晱+?7mjjER"o0ӡ`t5sh=3qс
|m^'VS_zO)^Hr6tzݸVkpODW9M)c+Gc]Ug*{On,<rk}h0*t]%0Bas|
]QI6HӒnp6=%A;5ﲊ;a77yd`L=fv pf<n#@HN{{I	1??8{M!/g#ژ"y:Mn$e@JOS挆o㛃-yޱh U*+l#`M얦3xR؏lzV,0)j7j$j%ޯ' txX)y=ɨV譞0]P+R+ʤY/R":ji5K4 DѴ̆cOSTǊp8>tpѵ~"l?{P4JF9-ag;ƃO $~RU'.~u?^H)UQNXj%4n+&sbq@rOi6=V&}Fb0jTSknEl6'W	N$	*;BF'<ڙU&sJoMZQS;YzV<g{Ѧ.^וM{$ʙ&`wVO^oi8'`r&X#g"NdC%Ȩ~LӰRnPkRRUFml=%"De4ج#D
nno	bF9sv18mfڤ52 Z^_݇J)r8(&Ϩvv<;YɷB
s5f,+Ec@T@[EJfwLkꎪU+j4\9D$4sh9yWWA&|ϾnmlCjZ~Y?W"؟_eu/Ϝtr
R3.»
'O{/RʪT=$nb>v ـu2@Uf@ sItQ(^YP44\&nKDbek)mgJք*e_=n&YbnaN5GBV#5ZYpzq\Y~mXUΝ8Ѿ#b\
 R6T4
0ݏ`Vrب.%04{ם~H:&Ȫ[

4
:oXֿXַQ Qs=#1(8C19RDmZ4$bIrK%VoԊ/>ٍEu@l	FIhc4Sdx;Qh[QMwC%*s]1q)1dU\ZQreXjtZ2E`)(Fo: ƺPUvʈUN(S%An;DY4SCmb |jQatbĴlIK;z|+ T	h'I(Ir[GY7ŨJ\f^nH\_f?:7رi.fs7vjp7Q%%tkC{RlDZQqEU\I;֝!XN)sP E{CR *X`_&PKnqNW$o,ūxIɗjk h<@P+xYL][֢MM5ү;9%bݵ.s	u9*MJ.t3#K\\ٳ:]R5Es;R,*( MYOeʌ'a[mT+	_HflKhV#/
m(^X֬[[͛|DUٸ$){RPhqeEN*}.G*1<^O)̊l2OEmZE)xe2[E[L`iJA,e|Yϧ'ǽӓ'o/ߙiϧ!;qn`zЎ,'LҐ@߀ڈ'SkInRrV$b
$%k&/f#,~!R*Cvwyn;Aǿ\8:>\]O`oHmcS-tAMe)^۟gd;	62hD6P5@ ;,W%RKw_j6GZ[8$n~7JۻMC++j$y$01MgB+{bi"C%4 #+z	qQV@WPPHjVI"pV9]t$Y8m NF 9hZ6v90cPKPBcY
UdI)MFK֜[=򧴋rC&Xo ;yȾݾJ	6&1縨e>ݿҙ혛}ʔ'Φu?GA7#GVO}0`G
0{qv_^һ>fnV_]\SuT0@#'7ePr%݋jF|ton79d'e	#d|yf釂x).uzrZ殉?Mmb2	%OZx*n|NP|Ӥзאoic!^}m%)鶋)u.1J]lc1nGEr7 _zTܨn. Zs+
Ŝ<w3MYA%ond5T-4&Pe0t[5Jb,h5#u\gHƕDnN4VL|aܡ]Ӻ
b}d#%M"a/)^#+F.x
˘c<ɆIUIʫ]CAO!ʘm6(PaS"G;\n[CݹGoͩܶ9hG:QEzRgt`
Oއ~^R	@g2rFJAQ|ҟr6rBC_ݾVM}'<S!]?#r-s]/ij^mD!`Z]G1,ޚ Q蹸ݛn` *k`u
d,nN?Lv^+tX`*f,{?)͞t8ΈcJQdn~o d<* !\[ DA\QMSmT;-ՠWDz$;G^b< #	 /M]FIF$6bJYMy.0Er6Ødyk2=KVHDHpDHfO9c7àwBM>\uQ{:Wl0KXbj !br9j3")/bpu
F6ޡoN7!TD%Ql&pps5txs6Kl/Q'G>zd>LAI˧TE(@?g!,~kO.Exڳ+S^3dWork&9qEp?:Ji	O݀mϛzdc e<U#8	v/ _i;qo[)VCCrSul!c.UnRCC ke	WaE/TK13HkoRf,vyy;!zZi\f#{q~ 1j%X:3W-I zRI
_ūlO1+K6aM_v-IG*&S+02X^ߞmQ
땣Jb+
 ,8ΑƊc|beQ߿Uz}Th0nsReWk_6}ub{3>^Ԇ</g..4?<m{ry:<VAy3;p?nSP~,iiF6?ED0;PU=klon=H9y;͎N/+]\)m@=}E
7Ő+^$\*cg`0jvstFH,Ĺ2zhdYTSV?YDYF6Ej~UEg1r6})?<ҋ	,&'㮐h3kgCϺоUZ1U2iz1&f3FZ$H>uEPF#	rޛSEyVrtk$d$*yDv^s'<L4;Rₖ<?<4ZeaR}nAYr 
zѽ*~@CPX:4/ǽgGOhzy.8#[~*gknVҍJ0mv廳7gB}TX%,c$(݂[DNcYTj#R  kZ,7_5Tnۇbޝ LС覙r4Xf/p~Oy*|stmW<=J:y
@>?+űYhw=_'_]X	pՁ1$L_*nvn4U@PJR@eRc#Re:p']a0#U-5"$@+F9dkIחYC =l1MX
Kn$7<Z2 S!2A:ČRRR+j^R1Vrؕop%*0OX}FS7SyhG)?nX"XW "UĖ6} =@
X`npnE3<f[!,^ѥA,E+=}s}VWwO(PVv0%h:Rpn"+t"ԕBY41pQh܊}U+xp<	H'cܥcww:O2W+~+VH;nWw_]qLθZ;_xid섑EDzJRn,C4Ma~!Vb+{,+fc>â7؇f:,npEIu ?:;>8:p`.O*+>p<̭D1"ϮԮ
,3[87P2mdi^(KJJGyk;lg?n
ѣb$IܨRE;3JHiZ;[2@ʲi8謺%'G9p,x 8$nD)Zld<l'pxF&ES`,"G|V߰og띖K]lX̌kլQ1U37\_)!IN@Ԙlr=w`<}G)ݒmTI7R<jʤZ3^TƟ'Rd^9V6$e?^SZ*C3L<64TVWe5U>ZŰl㪬$ēhA0$p1RDSdg¿RᵶH)d{݈7liaE]JBԌģj3ܬ-x&rbҮ10MzMgXXn'^l>7XyC?zyIT;DZdÓb:lF#Tf7(s[:m:ł^qtzj݇Kr nf
"(	X #g*jc27Tef;JcO'4lעd*/|)e8]G<m*4VP$䍘O;V8PrR@!>Ex{ihS;A5"G9#ݼ4)a_>&g꓾> ;<9G˪B֪G[adi *S'[Y,'3*[s+
+
;9^l,v=a6!bPJ3jP*jK2Q
/w4û܄lEfM"@0
c4c˃<'nkUIl+s"Mlb
+RJuO쳤;im7ĪBXc>[N&M7%HZ6_KA]U^d,QMuJh)]w']+VO_eM5b\Z;[-U!zŮ92rmHp$T|/S0dn8R3dka\+02+-m(5cӄBo+&n(pBZg`jdӡu 
 i2x;[)x7RQ)Xcueml
W4`	$[{hmmo+ZģYiBKiVPxCP8+0AKmo/a)nt 3bH-JЅ$XݜUdNmS4P	,|zwEoiPX^Q=E}B-bolqD7DST\.aeqǃz`	't{ȟpuՑ4/DeUdU~gxo@`X
]+d>?5P(ִ=6}|ݛӳ|4Vvkܸbl#aX\:|&ۃBT1J5۳ްjCYpI(>%4#ţ3ţXߠpZ8n׶`4Lre>`aT/`G	kw&	[Ukm1@h0W|d2w6d	hjעkQWri^U~^/rYlD@g|vjxAɭK5IC|	
g*AJz0{=zx4b92Ŋb_'rcPs{zK	v%~dy+.I)Za
N3WA˞@MryGZ[0&'T<%ˤHI/nt`6btשy7(W&1;ۮqbmL:#1&q4dg{˽WayDߊhʩ0
F-7[@.e&'Kʘq=q8x_&vg`Cl[usG8vpMl0_	'	,MY&WR,,
d
7ɰ-&S57%E\8;6VVf!rlP*8 k#EW<W]xNcoE6rv6>8dcӑ>y|px)a|9aZaڃ{?CL!Hy	5A2!>{#
`m KO'/5wvN19p
ITUgR]˰EN(JG!m~<] &o|mm+CZm2%`q%"QP:+b\YfBXd'9>]ڒ&Wy=5!2m&MTQ;_,Z>v8B;qLqIy*H=k}'06*Zjڀ/CRA tYE.LR290ZSA405y4e9)p.8Y#3	9F=LB-z^YXO	lVHs[tp[S>LCǙqY<ԓɨ~YɚBd|BYq'~R}/rʲ o*A@q ޖ
(UDN)
?`1tmR̔UqD7Ct`(+	;m@]  цF?Nh$jѰ/y,oUIWh7NQ2LwFj8lHz"QuPfQWR͙{ꃯ$af>5řI7橁hb-Ux=[1Ja\l(~<*#\nK[>WNox_;ƚ]7NVծl	lKwюp2vƝ|O}/=#W|Q^@EE/2nA)2=^8Ԋ<S^8{xD1Ӈ5%'FJR:Ɔwd8đf&}u	s<[ٔݕ~"NAtn\Sz-IZm'iڝt)9X}a-D	Cѫ_`1(~(-IQ!G3{&|FIF7s'B<טq陡A7/32ik?q{zK/wPĈ#yЛ\_WiUZ-CqF,0q/J3Syji%$n3 6J%*N&3~]vᘁFRb2翼ƣ
)zF2<Dq>spSCʽnk4jԐn>Js'ed<"CET@0gLsY}}yQ%xLΗp.!U8>Lo^patx|⪺'2)gD;ljiiI2bWp7FΛS<gsE h^:ވ;}ٚI4b<P:
ihilNp%"34z4dt<3_) hg
 bؽKEUctti;]ǋQ]@[	΅7$[47#6ֆ0-Túf)dbʳ_	OH<HҠn$Յ=mNB+菆elrڥCT!0XϮiF$WWJM%[7s~2eZZHi9ެ>7V4pIn5ڍ-C9.Rik8
|>Qo<?wk$A[&O9.{ΎOz٥js/sAjJ@Z7R82`yX3=Ӈ)ȉzqadnk)_vhRFGwc5`FjDe""nV,סmjw/F]}Lt%ꜛꂲ!`O־{󔌊:`PGn}o%?(II|wS9$A&,uF6҅3"M6jqx?>akA?ip+%b|̆L#?'28$K]d'M#qV5qaxgv^|2\`&֊3cb2qq# U}jU`$_M\$w9\t(u$V@xVg?5pF&9VRwl{I֖Gw8Z1[2BZ9VRIjٕ'"Y1;q/fyFT'*vFbCna$ݦ-f1N1jg^KNHHN[7Yn'N(*PtbtB^L(e|qo)34;V㱚~V('SBvM\~ڡ9Cawx`z̘+yY8-(@j䯐zqQ}*H˶ێ$hK7<y]^u ܕ8f,LB7}D
~^o`6h5
fmq:wZ{No/V"ӯr&hxS TR>63ΏϫgKEn1Vstq<)bROdZrR=擞pr*^k]hyTe/gF܅M;<xo+4h<a﯐"L?7p>P|"*BXBJTi_ tw'ǐ<Mv~-=B'4Ѩ
fKy];0peؽ9<Ӡ0eN2OsD^PI}w] UlQݽ:m/T7`ХZ_a,,QF ݮ `.^ˏadMC1UC${x<A%arV;={]`N˄:4SG|Kwy>?b>|/Y$;e67zPBynLj#T6։ռX2I"XtMmC3W~5s0׵
xC*0^3\H@pbu'#0[`Ɍt Q)l#c,0.hSRH*G P0\RoSYN-U	dA}<4S"EFSVE{wd:kε=@xeW܀,p$*yɘ:m禯\.|nU?j	*",s6%*2~,J;QQ'
9?eCb@_仔IR]#,4wo0n}O)!Z9UߒF+9?&Pٗ=+Zϼ3yM)t߬_SG
ᑸ3".sy%{ԁʻ;OR4 
(zK_Sdf$ܫ)T̜=4=6ߥn`"9Ui ᦿ
U_MKibCсQ3z#sVڂ)mF?->jMACϑk=*5͌;LC][dDDL_*0;OQTH]IJ҇ȍA
Z:?ߏYEGG/ȪT;,c4O'-ꝃچ]K&7idʻG2}U/#O
%H(V#\LU3H4"tcHc RaW+ʹ:Rx=
~GC&T~ÈHY~9?)';?ǽ_˃\᯿?흟]?\^glҾczRt#fTwV,!d':B äg>K \7|Z>WeW)
|+a5˥@Tjnñ_kTY<ex̿F!u19ՌxĘT'Uwp:s=թk3cbwsn7r0b,<yV0zayٛb8svWSNz%X̝~FاS4av-`U̬XYJ=֍n_"bU<.Re<߼U="I-5h
6ϿW{ON#Z>)LId tB.GVR*m_#|ܸ pMC%
NiVk>"v0%遳in1$p%u[
Hp3톷qgW:;aTpVQM\Be<)1`fي_q|ZrJ&Y
Uu`o<˒0Ef'sդfWF^:dP
[/4#bѨXfoM^{/N>Xseb٢r?,Ahf9Y6D\V>
TDe{&?F@S5`9\F7K#w?9:=.
mk[ӆ?9Ϲ%>=Gz\>(]MvoWt/eQ"">DN _2d:ԣUbt<\fH\Q2s;Ab%BKуaZy9f~/APs7!UʋB<FcUs,AYKgAN싐DCsY|׽Ǘ:>81*Ua}dq@4&/g0iE*kwm}PybpYd@jkimCǉtR1!2Ё%;qP)#ƻ;JJ7M|7=}dTxv
zʽ؀r:çH&/Qcz&`dJZoxtzR/Oy & .[6bx/'msmu M/MQ^4d3|$'n$J42>` YGdDZR/ڭ ":M'-Bɧ	7z|r!SB}l|(H.N{?_<ʢ	SQo7^*WTM,~O?>n/肏)VD)M`@Vw7o.{Gg_<3=CtAJ/N%;sOC)l]
J7mIYcS7U.=za(өyKӼjs_E,tYhջ7Xx0;N<*OV|2L?8D߼99=
ol'c:@w|CfK*qW޹]= ս9`/7|g-Vw[d.nvdcw|qqzvݙۆޜ||~=NV]swmk/zVԁ-|(ܺ55dy9*`8lscH
WLvgL;x3Bb#XY\OLgnJq%$[>ƅZlҳ1KEמk#gId]T 1ATsz<jzf-:֥ir1܌KZg@կOƭl
fW%Z[	'bz̈́Pi\,Jޅz|".RYh\w4	3eE*$Z9hU({˹sb^>VjS@`B9f
IJ5dIGe˴cx1ֆ05ЇqC8O/Rfɓ(
D~fPD>Z?!MM	UqɻI41ғrlZ<f{2rУci:},]lut@QN+Yj5n{)ER/Bwfl6;[k7dCae#8֊̲MABѡQr4io}1(PH ƪWRg@KȪS#BX7o3oDmLܭ/Y[T=pj=P%Q5,4UyJVp^8ʧV*c.KoM:0a1 LcҎLiJԁFdҕ{3@I'iE͹$%y;-Á8da VPZ^HrH| vV=&&	{GǇo-S2`K0yT'ɝAMo#BGQE=˓kJEL+Euiݧ oo5ww^83a'/Bq{/f8W
$Az$zh6Im{b⪑ A
|SQe	Rg+~(,""! >jxL9bJE@F()/NbUд 6i9XCU1}y{rGr%O"tKԚ]
Ω C`)Fۡ'rF*vCgs2b9G-9xRZrWBRjk%QH(,Uw[;,1SK
/}BU1IYe.y=7Q͏Dy7MR:Ī"Ey~adơ[aŌ
(ypů>bhni&D=NbOB角h.%֗˵s]<b᫋jhObІA:".$D݃N{hYz!h#bC`iGx47F͉/kOH
KqFּ TɔFw|ThR 2KS85	ю
+``pߊzpsKNOޖs^!$ jm6ubsxVo`(Wd>)x]Ru	ghA8LQw!y:-"	mC%L_ϗ_C7K/x|n	:1tҍ@:JwZ	-A$R S
+ F;Kb
.Dr>{R	QwbQY9VLD'*EMm°_ˁnwA콯u:HeiMGLR@SJM!-cȳS4WVMo]J<JfEUSABlqWnMd 
gD>s~1Mt2<
Ȗ1ܻWڒ#-
yʙoC핡y*f4h](n
P`Z,5&ѭ;uAY֜tR^BJ}xq|KK mmqɿHOpsCԢ 5)?QA0Sh
+X#%`\4 
9ҁShRB?
Ƀiż
F`T ъƨTq=~RٰC
anl
`ݕ_#W|+fh)D,{zg3b&gРRA;*]MN,F}%0L5k|$ pvht0v_i2I_=|m3Tùm-#yJ\<po!8흧	A\vw~~KT`k։;cg`tK%8HŽ3l}KݵIu{ !?G^b(ҳ1onai5HqD(b{DHJ/snH޼FeHYUa6@b|@&)ǡt16aFŖp2Ugƕ)r8o߽Vϗ]+<ziety~s"ɌH@|'rLT,嗵/)SJUw~xo΅Qp^*ۮ9Vܙģg+UT(I~]CHqc?4ЬOϩRG~cӃcGVB&tm@xm3B{SJ8}R)xǙ<¨Ŧl D~
]0s8b+o]',&OJM؃='kQ"	-N^M^jUȋT%%K Oqꯗ>}|~q8ʚY=[TahtNU 6j5}Yy]&oxU<|Aʜl.$/~޽DȊ/j?8<?o*3i鞨E1(gVX|p"Y"ZʷQQ" |$wV2wnTO3
XLzd֜2X`/=4`)[Y$GB(=H5En')v!ςy݂w(I=ѯ,vt=?<|')KfJwI>H嚂woǒ
ڙh d>1
enϞxL$|MbDX37۞Ӈm"7BA^qۓyrWi`Io%o-nF.
NUyKu5ߏYm&([[l'=:STM)dW 	>go[7@do'H%@mo'O.@g|	ug a,&H+Lj^y;Y%惐bJ\)EkvF;eJ 0Doút7Pvh_g\~<'z`؅gKP8E<U/F 
p{e_WWin)_vQJ5,{?󉅶^uN;LVԅ]%{axC,QyMHVmFMl؄[Gb
31$:cwHc`YR:()\3Xo%}1yE, 3yXmO̛2pUrnx{@3ǉ $0n_޿G;Ѯ+|8_DX6]%2
wn3ծ|u&'c]B|dIfLc1^ſO6y̝{)Z$o{;;mX뙺wożk 8	F2̎i|ox>IsRНDXw@qٲUn	M`^S
[:dX^U-AlVܢ&M{`i"f$Xv,]&+dZJA FŴFn-qӨ)o-ϰipΏ)u[@(83iܯ[n܈/פCWZ?<q#
/2_I!*ݑuYʙ+vGTɷ
a$Ꭓ,Q|l-vjYL/l
0B)~V4 6 !2ՆioYnɵK[m{8ۊ.??adm#,&'vDG1:ZW*XfrsA )cpshqW̍8y /A^md J[uƵ:?|WȂ.3$Nt&`p.cK`3(hDj._5n)Mfh0mk1/KT#CL0;8Mb
<Ȝ5RA^nH+T)ul(E w<nJECP+Ua<5"̤qTb6Ƃ{	z^9hwВ?43ut(p^,ƆF븧qX(-j艆
}=-SZE-/]6q_rIGǵtUZQmzIaR#V(KHLvw)2h
׏ګ@w,hokP\2sDzbjzR+XV`0y=*+!l;6!JaeZZYQ0xWݒ<z[ȌmU,Z﹝a0fGtB1s]`w_˟fv{W&ht;`$. H[W!fs?t80ȏ "10%vNl[b,OCtp6}0UpU%z7Q	U;Eeg;#!xJk$۱
YMgxM(`LJya
"-*Qhc
­2~qyד^a<l'lM+*^
॰#N޿xyc?J\ݍ5/%LtLĕGa:]^_x
baXrɧxfEB6hD,뛔a#vHҽ\,%dW8Kܯ6
!ur]	!Vb3E)Pܓpi@<$ɑ	aw8PdK>[{[7+?
Y!Qin v&U1`EmrcGy?
4bC |$kzדjf]Ϗa{`F ^VQjN!S;Eb;Pp+LCO?#,#'hAfH"UWy{e+{%&m3ҕogc˭DLu2W<UٷYy%;+[$XgD?r96;pza/_0*oF__S^k*Dl(qRￕf)\$q?yB7:tgƔ2NK}el|]uiDa-?)sbq\J^ndmףJ;wUww8ڵ([ծ{j!5EJf\1Q)9lp'MIX몵f:"e8eF^:"as_#Bp? DXٛ/i@g祝!6)BQ躥P"'?ɇ;{_MJiFYQ=SVZ,](K0X.#]hoL%j LC
٘ʄ&ʧFҩ(~a/1<
Ei) كjNc}`Fđ/)b
ЕC!7{|xMRB`۶Z[SqʹSN3U{t
@P'褎Tn?ŏl_Q¯v(M8I莩YQc\xoQz:oM1B$iU}ltm|ru,3^ba&BCVwK;[-N;k\i>McR[dLqӈ<	֥<S[_*Jj@u
Wda:[Ϻ&~y_mhi9GqfLt+9
pYlh[
1C/p.]Mp.k0)UZXZdQEqt{i)
l=dLF!xpZ52 	l	O&ǽJswb/*]~dkv+McM":;~(0D'ҪMF|GX03FQGs{|Xu1vSeˢXUi[OUjRV8B;l(2RIQ!
Kȣ9y,)WW o𶛂P`zs.ͭr5=nvBUnw
q^5VcYH	kZ$A= ۡہikvL;m,R7ctEPBNaXwk̉^r0v&Yf`
b`R
C9܄kTEVi̊fg~k*ϻ_jn|Q.6O62{ў/BVZ!s_<MhiCvb'mK<3Fz4Ҝk! 4kLDw8ޯ"V'*-/%be΀h- 3^$ӣ=yE6OXm$'3$gm4:q"HhH` qCc[8T%gaaEW37N}yKV=Јc5[ێޏ?3z}lNuS3SVsى۪,h!&܌XF,^jTVI"h~G4wk -/:ȇa*(?ZwLj$ns̿EoʺxQN&6$5".cG$a>"RX!)|B$ʘ	~lVϾ}Q.a!@bfaQ$DvYmt_M.N$JR)kMǽ/P{|䃛}
wyv.nVuN2.Ǒu+wl|Jn10j'[l4-%bQQU&VM~I)-)h}@2?/+N1Xc ^!{CrfsKݕ(r)I^borURJe57
_()c;֟p΢x;J
.#<lGCC`
cޠ''Do8z05o95ϋPnƅ/$O2ӻd,Y/иn*> tdI hxs;
z=_PyxzxqlgգEb(#vMCHTf:1IK{FRD<9WпW-{.KZt;LUF^NKpCÍETYi=g|;|[Y60j
&MWgE£}%$B
\ɮ"	5ïy.UDkäξ8Ju0i/JU&-t)(PO k&bN	ѡ72zX PAy(4;Ƶ.VZq<rhv"-{e5	CK;[D!Ҵ\m\PnL~`(] Pk|dLjt
QckF٘#a1z}`H(z.@ݨ#H>whFC jĦ\D'cw`Gٚ1{>]}89#8,.pu*P
sF/N/OUpdې@:Qr\48ǥgGp	O>LS
Sq
r(< ]i#JXM<ud8^ú><l>@l$N"n3-vIs)AoVQ `TsH+!w
OrnuBeЛaȝyF%땋:'
J,WXPy<O^Tb2`D*󮨤XEf|;\3/X/կ*,WZU7wL?^Oq(\j-)>IV'i+~^ɺ'1kk%-9qw~ ;â*7q%hO*j"zt
lepLFc) *cZh@|t(zrMLFelzj
Xz*ki*C#=tq4G[bL !Bp*j˽k7wYJ.ν'_وIk׈a+p>T
y~K
9oX4DW'L'p l̒<

NOk`~XŢߞGQH8t%HKaB5:OBP?;j~0$*"&~WLcze*ŔoTVӲ:Nݐy0'P$fҟIjdh(U+lDrJwV"kovûMq#amn|bĘU9xֹ	Ȏy{ngHCCpTߪk4䛟M?hho	,b)[<,'9%TѹIϲN弯V]+BG6Pvz[U9V7%AQGÉax锛t׋n$BN``թ`N֏sc]`ªҶwq7}8_U̩$kujjUsN5(BkgVѬcιl
/mAzZ3>߯LЭ}daltON}1V$vXL!,`!h
|
#}3"Mݹ(}VTsނ,?PR!527տbB)h6`/A8cyjEWRh4$e/Nv^E@Z-?'O#^螜%SyAGࢼΓ[Zb@ʚhb0*6{^F_3ofs2kɨ4~XV'P*|]\9cD 8hfLY]S'<lXğU!ymo<Z{hz!7>s#*<A -\pT[=6UaE1~sDMH!~v*7.?IBƊvsk(gZT+&rh՘2M
kudQќ_F1]FߣaPE0fzL'B_#vdn$Y+"71jas	BuڔJ%Cq;N`l
8B7,L^@zAɋ`[1ϻg]^Hǣ3N[V}hg4T(7b=Ģrx
hu/NvZ-ei5hke
z߈x1_T'\'sŕvl+PU#*@KpcQ5u{[|  

8˲4&](u4·7`^
<7&G|`op;z(Y ?RUs>|y0)
S	=~*5(5@jplTIBZQ'Ć;Ś{;ɲ
uRsP@$	c
$,B\Pk74JK=/	^]fLህ[kJL3&w. I&fN(weɤk둢Iׯm=_ ;!m`QHsu!6XbӞh_nׯڅz;)]>$*ee<
2bOYmvLNFa4j'gY@XC0bJwGq wZ ~ր)8߯?E,Gd ?u(`hE\"OA{ʰEo졺p%%@$I	#6*ܔ\A $!3:FA!h%nȌJ}x,?z[OM h{iZ}1^<[k*d7h#S<(C30@s||}-ܴ[,@n7`GN#gB-*QdPjΆ`f+b P3~
B(ES_W	T?tGz}g
O3{lvsZ<C9r'|Va1&nitY7r#7Z4Eӣui+/`?>b|3?f$Q\ax$y90hId=V2z7Pr=@F8ėaɅ^Xy iĬ";&I$B"-ՙ	Jmg4BGLbD
yl0myGS\F4
`奴kt<!de"Z?>5~&t7άlU8
Hv+*rc/}p*2yE8B
:µ:"A淡s)ŻOwG%dao;|-d,b)I;D|8;(Z> ub4fKb,Er%Xȩ0AUR:҄
Ty.ύx},q]+WkgZ9ŋO:XknSq\]͜{5V3p1Vb<Z&h1(բW	oe|8Q*3C84<S,fsߨ_?`lg!5cn')5ѯ&ﱄ:͎UOAEK_Յ[mqJ !`㊙mյ;#>dS)Inې0qA%&W+#ܸ-@ŀx>$b,{6QdFwmuGIf,lqDA	"f`?XG!lKmO/
*
_@z	55귭hKZ7%ouc\Q=$rt%EaCC4^O&PTϟW5-硖&S.h(JH"fN3rQwF4[EpTH1PvƖr5n7ޯׯ{:pT;*'{ߢ)k.
J#V5^ʱ2QUwȏ_{p2e&ub*.9ِ22 ?M{"! r@Oᄒ+)  n(&5%%mg4^I=;$
DK
wNzf(()4J}i_8eA>?$+[lI$=r̨_l:bڶ[v1b:}j4k1rG=
R]0Rgofe{tS~kY	ʆArx8~}p*i'uH\PA|)ES
w#՘OŨg³kIRWҧ/o	xp8*pVeŇ=q`Kr*""pF%;_l0BFZ@J#FH7ԏ6mHBjz7m{-$2Cc׮<3X15TU.-1NGƁf
+Ɍ⣜Q-q4=U޹7xgNR)!0x<GﺎBK
ggL2-ŐU 醼3bsՆ֝:Pya^OMnn-_i&biM?aȜ5dst㲊beemn8/8
B-cEuOXP|huz-	"x#XryfMvo{{Āc!:e|=VcYO=v_Y,8n?r_Duϧ'I
 0I"a7PHlTc țvZ$2;]N3O<>zg1iȻ
+Z2>7GrDx*(ArsׅQ /Xuze#;$H9gtm4^cdi{&uX)L!&D)ޱ04Ksv67J>)q6&ҿm,S6]׾tvy.CN	nA)J4
ǈԪ)*nAgATxqؑ${\XqjwvUL&<Lh4F"4PHpwb&8[_s=e_e^5	Ppƌ@W뾐^DktCHUFUPs:{X-	l~J޹𞂐w|8'c٥DhBN{hK+%Gwk}l*Tk1OF\r"Sf;׉NcFr(M

j?{9#sr[yu$Twf8{_?Fod.+Q2*MJKF܎O `0 񀕲y	Y<MjgK /kn#jrR?~PdNNvl`5~
DP:y(55oZBA'=#x
ZA+%U<C.[%]JNS$N6Hnj=IxCUPPdB듔hO ͽ+ԲD
{D g̯d]Ⱉ
=B}9W:㈪ 
Q_B{08eK}%Sp2؉.E&^5u_)D,ޗxc71UrDvmodq8Nstͽ$NgOS7t	q	DSDq$d	eL 31[Q"2 +0+To]OYP[PPLCt[ "`.iu_$M_߻!>q"oJ?\L
DUjks;k)L&E߆5x3a
a<aD7
`Hr5LLBޘeuc<PNQ a'P 7[EU}+!x7-5_Qw
9zimhݎ>tOз_%ť(MȴQ9S+b_+jہ2!)])j/HoojCO
ravB_ĳT$>Gq+s'N0xbA<\B8f2t[4Vݴ4cqVn&羳Nc|a7'yb<Bw>̭է%-!?jS,"ňHfO!J=ÍJ:GC6SrV'4lk,FGښL\N "a餚CaQ$pQʖ~a	{C4oHgu5qΥ0kP֔B=fMR0vhj pT(;)/igkį);&A7bzn>Dp|̿s批yFڹp,jKA_&&f,ZY:hGzsG;c>Di	U1%b4MB*Cm$\Z=W%oRU
V1o
w>3X̍wne!bH˵koG2K'<Q`ౘ!!CZ:]Alc^ȓ7BTPT\㸺؇xS-섶Լ0gY9*"[`#훹\Gott&
O
Z @44'ܽ_q;smvo	tE?zQJSxeQ%fH=&U]5dY\x {TDhFiEeLzl{N\OB˭uݠ(v])Vqc㴳,}o72eR 5Wn߮b$j[_q;Զ*N)y9T>2,m#d@♚V+aUzd2UN ^H[~߂m?ys|{M>_mA	*l;)?YOAF6
+
?MLn{w8hH>r'4m)y@nzn#K$~1TLO 5-ڥd;Ʃ/m8O|iߍ~+y}p	l
7̔)A\ J ?N8з`(G }T"ײMa!w.1_
29Ah<(z6Nŗ !}F68vBGmkl.C+-Qy]K7~0Gc*;~X6SjۢmcuFIa\YFQ|{+`I>\f5'񻃟{o NH?!#{Qdq1ڈanVBAPL$	L6}du0NVi=7է*͑BGe
{V\hf=+H3PGQUq=źÒxb;Ӳ9T^Vb鄎#{]Ո)ʵ5{zϭ^'O!`}9J"x4%Yehohͤ36D(r .cYD**Njo'~J݂'6pn`r)PH1ng
#TR8~v#|+>tOMmď] &Hh=7hb0ׁ
8ϓr[s]=lʜE8u; ua3uJ4i7H>..0_. nDn %pr
C֡Pn(򋵘
xlau71z.f%k=bgQ)6l;JAhey~'7v:ۻ![܂s&E!+ /â_y
sy\hnd`8^M:[,kOőǸgl^	Pk dJ pq+ݖR;g[0?Y{+"<~]&sYUbٱ/_۰bdf#A3)G9&3;ڨc0<?'ԖBlB]NF;D}j!EKK"<TK8.
BV}RtwFd
^rW13Wʐ}}sE2QN~2HO_N;5ɠ7[s۩gd"6,fۿb&9:Fw#))@KguI[6^/OIl,j3(j]Y*_WFH^0x;	2RSzɷ3>j~%'au
E`%؛ ԗn) bE`zIOd*\(ؿzfL6Ey_8䆉{qVHVTVJ@+bćH
0!' ٺCHXH;ؘMF
@6ƺQm9h.u<wtEat#<$MIBE*]*Oa
xchEGNѾ(TsKZ׶0)KBقmx,Z+c-l]X1Sg,10n$y:hk7IKYy"I'ՖĸLJHizYE-FP\WM8t4;ABu UZx(D+9L}c
&n  v''#gd?ٿjVlǜs	w=]7я  3w$4/Wjo)t@g *
t⠳O1Ԣd_>P	E|=vL_oWjD!Ek+)
B~{˫{@7	T{
7o;UioNONOc@lҪhXa[cQsdh<8޸N?o!8#҆ٵ[[V9ڍm"pjh@|l1uB6'	w4bVXiQeKZԩaPow>!km7cv&_ܗ8Ҫ!эLv 缾+qL̹Ղ!cyIVF5ST5U&=zZeO&*/+$4*p̤ɩ$EE>?nԝl$NCC
+Bi<dmmgm+EQ9<B؅̈́dP1~{pJ>lKyP.l$rq}
̅2?~Ii;|8Ӊ{ʾfA:F@\.'uwƧFѠQ!rGG/"wm]Gu>Png(9VuX4/4UD,Og$x
ɌB$n~-@$A&N;{Mq	*BɹhMQ
kQjٞ; QWFe.	ZEBѥQ=Jp*[|_1:HaH <RqX "-8O˵JhAP^)P[tW` URM^ʰ. 3 9 L &D#M@%96xhȖ$8KTˆה%(a7Tn*x.;@IOZ+ZOc8Y$-UQqw5(4"YWiP~%aZĽ0R*7bFHZT(r2/},sW;	0.bκ`?ؿDE*qNflPZf܄bCl @v4e#NpPųAD	[o4*+;RjRr1Jgm'gRRz8v&u{"u@=a#
#t~?FΧ#ͦ[FxfB@ἲ:LI&b2O=z^ew?hy&Wn:vw,HX̶n(2ĸe *hiv>6͚5āwyy~]5e}UIh_P3p^"p=ʡ hHs/[Sd=Ayʜ		$D;PB0E{0*ߒm@J]oKy,x. +1=a9Z':H)X	xRNwuh
|r8e W7.ic*ࢡr]M5Α+JK=bN9hy=em50Wowӝ-C?ߪ\akIz߳Fŕg+'_}Ƅ:3:Bԣ7h趲G`נ8zŬ	DDYk?o_!	Ps̢0xvsB|3oQ&4gR^P?"W rRkd,TMՐb^I fԈYt@	ӧpvE.,VHR/RKu贬:~]M&sFbb
)2f'?SD)KynR˩M/T"y=;N7WDF)wA_j%U+ji%m~ u,)IBAfG]t"֊N֢ 9>3.ZŨJ8) kzA`Ocm/Ac=uю#L xXAUCr|߽qL
/EcKޯN!ↃpbxYM]r1lz8	pQC%TS5P,y'9^mRYkdT-@?FSf!X#|yT
_:؆Yd~@]R/b SQ	`h1˔ܣAu/e,g~,cJռ~5=1b'HS}N|br %1J/\gᚔ<{(k*~,:~i:
K6Ny='eVkȧv謸swϪIY)k#bB\,1F"2a*DO^AjNr28
Ij%y=l	f`Vdo)PIG>oy0F~+$=࿩obx?a=QHCZf0WTS )^29)J?(kڏJ^v숀B#1/0;-,/npyƐ)=1@%C ITH7kiva{рYzۻr$M+1oPBUt'WeDOPL,;^&UP~[鎳f'QX^Q<Pq7a\/j_tC+T_1V/Ivɞa+ 
05Lξ^yJ<KӾJ:hXѷyw4ή̱zs/0J3fsb˿p{B*nzFll
`HcW1a wNט* ju3TKVs;# 0PGaW(EbAȧUfpGKZ p#W_(kw+w+Ț &)7e|4f=\@
O_|D<; Dx@\ݽew'gu[V]9=liR`1/d%b^\dȚ,:,
r.4*-Fm[>GMY	Lefg/bI3nz!tpF]u K$[ـ*2s-#8%,,(ι`3Vq /-;~ͦcePg21$a=

q("ojS̾
PsHTX0uO=/tޖS9u#; 6q@"kPNa" !"2%je	3(,zT
W-b95ͬ@2DHKRBG={:Q}'
"B)J^Ej%Cط/`$JuŇEن
wȯ1Bn"?ز )z3,^! T-3P3u]dߣdf+==(ꗻӇoWήO+-<bh?<
?OFvT(7 ^6rCQ*ސ肴rC|Z!'R^n'=[Kӄ#|P"03j=-62G15}ȸ`
_kQc%jٱ0 -Qh1sPMD ]+
;LRJz}˴g"<^ⲓ@ݍ>F <o:%=S]C64كqcKm>pW+z;"0~V%VjͦR{Q<MMy'lv	z:nso'`;- s=t`YN3S*ޱjW2Hp7{m!0멧-$DZ\YǦZ;{Mi`u^QsV可pTۗB PqJ(NJ"̥pٱ# 1n7a%8;<-+BzBo?LB|sgt7< b
XK$~~fZi^|ykLdvn2|
q\n;-FVh%ոDvr\p+٥9[DZߝ]Ɖ:,Cyv0UB*\+K@*^QUC>E&>{fJԩ}7m%$MO9
|H:Kў\^0sPΟ2
 "cvNvAUM<g;pnS:mJz=v7#= x϶ihI>t80ςk2+6
#U=:}!(7b5 > Hk0u\R$I@oY%ķr۳	N,#"
HhZ~h9E\tXq2TBo^JQ-^eΕKR~D6gw6<I0Nrg<8R'
քUܭœGk%ճMBʞab61d?%f+}ME]w!ݴd:WDjX)Ԍ_PorOwB
g[ǣǟ3tk#PKaƵnAW<KDt튱y!7
[2'(
F#nt	p
L].]9&FE,> 3,m1GyW{-^_ЙS6\NRD+Y5Ia9X~	[Tֲ@yRh&`IeD#nl2<-q4'[lڙsbPǰ;͝(%̨W dIxQ69U*w7/ΖDl9
dl:f1lB@*vP4p^βOE1NE%Fx5*`xEU=s<OE[6'l:{-@G%ݰ *w=PU,}Yp)pTRM&s2SRœe)YaV+DFT (0uv~9LHV
8*mA'LQIV:O?`$SF-QꑫÉy|R}o妡,a}k,KrȲpMI#?1tȸ+dΐRׁ2
u\4MSUjI69Db?W](?@G?Lc>zMqP-JZ5Rr%W-dTI	wzLOE,-+	v=\	0[ Ms	mMq&]>Men_,VdqP?E&:)[n[p.Ԫ_}uw`e7ʴ2W._6hڇ&Ym-sTTTWSSivP=DTtzQkވrTCrR;9{)'MD5O*v*^"m1
m}|*}_SkݪOUD @(ة#$}
Dt4vEo=?Vx>P0uY+<b5ȃQXĝ(o3(\L}O~5lī;vt"	r-p_s1}1:'w41ԅItmQidIF©vͧ=`rT#/
){Tb3=5rs7 p67߫yPT̵]	k( 3Sn:Im5N
2~eGB(M0ByvАۭ^efz_B,K	.WoK@OJQn7ݩW|'`QC~(ު>6zx]]e,I@3{
=u-qy6AXId025 wF<1qvxx
9 /_1uaA`@#=Z	xkIʱ䑜I-D*-8,eObGnmpEkle-j9UYπ'~XF]"R?$y1U*MGF0>H2zgOk&֬tH zu'\ϏMse̎a_DtS,G
61y +sWO<N<r-TӮ)Jהۗݑj2+Ap(ad-:ĵrc7ƛE>RWrO.ii+3fTP!$blFvflUb詀%2$Ov]:p3.Zj+;=hADh
=i1lP4s[k$͸&pf9ҵj>@n|S;KBod{W2nC|BJycVJ8B Pn'x!~=AW"Y9H5փ[pJ	dy0gX[m-O0vsOq9	oc;uSF6?pAU|^ɔ.jfKN۷	ukA1)M04$;Bwr5>Z)pqU~R[ָC썊9k:@:i5k#IwDk%A ¾
ȳ;-?j?R)=7==qG%a"c0
xSW4e"Z)=8;+7`Q~< .\k3~|V)VqG[8ի "da$23436]kt !U"Fѩ*gCB;p$T/M{i 6lZ](-WmSY2nXoVyb$ZF$UϕjR^^;pq{;'(|qCE0ç"A,!-q1~0"
SvsYSe^=t=nl>|NU1w+eSiwg˓g/sk.-"~/FF	nA8
CČXςޫI>NL,	Q,kr4CRP9qp~cCI4{W=CTZ߷3c%,$,-^We+1vh$UTlt#ҷ)GO?`ZFtoHnZcd|2ښbꟳ<&[[	q聄7U<˅jbʡSYu^9".$ڏ/t uS/Ր]7Z`O9.Oo#.G3	&&e[DXs5"a:Z~0*,חv{ß,axuߦoCT'&,.!LiЬ m(OaK5Tss#YZv-FhJ{wg(0s_ȟAGwu1wbP(,l.U^xsGh
w#p
x~w|WG"9.WnLۖZnяRPaߙPMpggxaNU_]'Grh͟Ng]ip4-?+ 3yAnZoI_Lq'"@8|-ٗk2iǽ }|6d&ϬшM$[/CDDjI+p8{O%xRGMxZ4yhД!$|RFwU-92`IS
~Z@v1; V/DcƿG6eTl.Fk
ros((q9wxnv~7	6ysB-鵛z=@Hm>8j^(mQ3SNd8-#|b}neV+Ͻ!lflg7womXR?d\IxomfQT^οLɬs]8@7b~^4T+̖r0ӻձt
el։XC51B:=ȵL
n}|ؕлM (W~lP;՝/'h7m̣.=;Ry3H7S<x ;1+a}U.Or( 7Πp/;oI."XwDfOÈ?ĖNpS6WYgF*=zKgH?*"lgWPwX|Tݶ
GiV%\徾MuψT }Қ"1>@pAsìj7wxYg!bQ@򺣀AT56ofVW5FFgь; bd +N"Npv\%܂)94u6ks	i`l|lr`,Ag_Yj
rX455'o=bwBC^ŻXYrS48ɈM,ބ8
uUq9wfBmVHjT}IUdX4J76	+mswB/H.la-n<%&ZN:e4'oRP/
TsImx3z\JWag?`$ mG]ci5o,0v'WY-Lr&l6@?zxu3$ư	-!;Ϝq<B-	~)ǟoBͤ{dtKFˢX=AlCD0- i }ILBfź$DŖe3o

4 EsYo4~}}m整W'
fE>J=\_~,;evIne<<x||~pzqbV=5ԻbDOC=6pxX>bip>mŎq{^6У}Qm#1m1b>}rB4
qBD^?e{FƎIT*zÁk>fuKY{4R½;#> 
} gLHxۘmᾈ9T]!Kg>dr]!t1ܨ2y
Ykmk(B%V{d#$fVPC^M5e?=d8<ZdqUk菓CO3A;",F;[#
#$չj?6a"c≸fYB!kYc1&Q\mFj¦<wÛ[Q4*Wg7~m\rA5ޭ*lڟ??1O̴-e߻Mͩ.&ΏC5niԄc᪌(ԭzӀaX _y/7U-gWn$`\
U1rnn&dCNB1߱ҷ\;n/ʻIݪݽc :֋Qs=f1.FXk3@G
%e2``tJ0KJgP2	L/ "N=vZ
g,ŀ´xGu1"Sʢi	PRo}-\㛑X$uAъOR2:wΘg'+֢@2GII̯DI/w@m>^>6XRZ-O{iuz`xa+{jwJ\׀Cw#͘^E[c{Rgg/0w9Zu? d-U+m?6WZ;c۷gfN>;pzZmS̟4STdcn6*!'u	?Ibte_}39ڀ`	r#l73T;x=(Cr킢6iWV^mA{WGǇo =[k%mn?Iζ=	iDyQPZ1tOs蟻ȟZBۀ̪^4)9<.ta=Ѓ'1*H)p)ؔL
R 1jq(Xni!_RW{rwy֠5L[氲GZ8x8Ef@
(ٰ2j|κ|%Mo<gjnQF|)S &pƻ}3goI18ͨ+n!!݁蠌ՑyBf{<:նH/ڗ^1";p2.ٹTjbN;`dDܼ6|@9y< KЍpOk$>&.-6Gr;ԈNRG{ ntK7E>1胈Zza1=)!+BӖ]9WZt%|N;ɼ!EI{nCAI'rm^MF!EjoF4WG
J< +(eBYpgwsJ
*RЕm0קcꁐ
#¸ۻ&υG&7t,oUlߑG㟎O<Z9m=S<]%rlWM|z
l*2J7uMPF[qN$M^miZ!~ԫ)yӓnQ>G[
V=qw<@>xJeQg%uF5uO'1VZR24Zg;i:<=H\
9B	ZC6)@IהK&<usԙ(HE-EO^żZ2bBk2iRɵøekĹX6Ӟ]/=*0K>(qf©n2ɲAs7\2.m콡g݇* FM17/|_

TK圪p+V2+#<uWݹvi/՛h$Qd2pb";'#ZP|)D_q{o7O"B.H:}o
u̢5>y7ӆzOrcH<bt breML5=o(('ڎF	i_/OI9y(80/ފoΣ?)JZZaI^q/>!r9n =tONm2 ý҆fOY[k·^Ⱥ%~Gi<moi9
[|-d!I
fV@Cy7u÷^\(ZW@x6ۛ΋3.b-TH/G| !l	R-~Z(r>ײ@N`4RY̕r#)f=
qjK?Ԩ)l<M)oȷHyQt)lb""*_7պA39wqALV帠pDcS[
CQ|.;eK><D
KH2 LVGԫ&A@ )e!!N+23 i7k5fE$W8{nvT;ߞa;F Zj='"HFɣ%If0%<bvxJ."jr͛\6LeSۙ_`H-f78ϼ7[~yq**!N&X\1&up~GW(+b$vȽ/*-/RݭNgGQ݁-^;v=߭ZK˖WQ$^VSQÎսr8t*ل6
nyk~=%yGWw]=PU-n*3SVGdg+ջd|Ͳ[5/~>CogϳvZB`܌< 
89D)&YPxMA{ķJPQ
bٕkJB
M\ea!`!Lbރ{v[Fvn_k֐A9"o1-8HǹъyGyB.uyͳ񃗶J*̞Q9J[>}<t׳ϋp.DʸqpsK1C7==/o/t	DdD~2D1I䌘6YmZMt\(^?QoUo+dRj/w
r =Xjc{qT%߹<T9RAi[5uF$WrPUO1K~U5iH5h}CZ7Iˋ`!J.ie2BUZz'L3&*dV@0IIӢe;w"r:tMMH%QL(,[B}[ѭL@Pn 1iGZ
>U	T?WģcyX#4=~I:X+M^B8h0*gmzt&[d)%_uBm "L;Kz1͜)E01/Xn6,|j/O*(wV E,Hbgݤ2R{t<YqjDyP*O[!ʩ+w&PL蹋
,ӵ5p&%(`+CRcn`#B=s
#adW(s2{<%3vgr]WbҰ1^}3MU =*{B7Z-SDR(f6ֺGEiuˠh_Z})b>6yLy.qdɜ:sw rU"?M3U`BsndҮud(QeP9AwI3KgC͋Y{ٷ1yfa<,V݃lP>O91.~$EXe? ?ER.+
D!ǨJ!}z%UƱ-ntOR-g+I@ol唔S$`nSS
:EsYpf/|*3VZ9(|HvC0D3ZZqv΁s~NθjEC^sz4	tVC>~.@"JX#ˈϔ-> Θ1
dq;RT7BM/9>W#Ɗ;D,ndo2L"A=K-J#BRdbuHRwsg`N~YP >R5B-0
o8N)&#)KsqۢvWQآ5ޯ^"R@Uk_~9s}_;?7ǿLԫq$7V>TM12/Ȫ.pBpQ`NN[!ys7m!*PE6ŘE
|Tjrc6o.RHJ;{PHeNXF᭑@#C $!nN6Qt	Ł1'-FXoqP3Hw
DF*j7B@>J~{6R҆GKeʸD f!
aU ˠN96o^@A`?,g6t)Jӈщd,jww2yTc	ZIqp]Jٸid:mѡޚ;̓3*OT:nʓ6&R."<xZ;vĒ:q(  -ũbŔRp\Qv
"htQ:}μګ_/?Cy9LIOވ$N/ʆO>p~/:VzK6אTb|:E2hp2_+8euz0%|R.|dѱbQa3IץT4T016sK޲u/..N
J(yw@[TT7zlG@gzTUij0`TҮËIg-v &"EO(H;+GB9@*X"Ӳ9M>f3hR[ m.AFA73E,<4!8şB6Wb6pN%/RgsًV'?9
/ yY(R)jZF-'偾u@8PW{JZo8@Od	ʓqG/"!mYnSه_I/TPLox)[{5NxǠ]rnjyjqg\≽xTY΍ͽTؘ9dF:LGbK[v?o˫3߽V<.<yz徜UOX/@CZ`w)=SE_ٿB$q1tZ,H156z<+C/h?-t
Z=#|kʗh8/G.H.ri2|*)<V4i^[9" Y=ŧ@MqC1`XΎ=O0ku#ai܍o!xEЇՌs6{UVd73]8 LvJ-Ai=(s3lk{t=w/C/ֺJJ.yLy}*Y+y~rq2f
&(C=(yfMnHǙ;fؾpIоP.}}ZArY#7ښ~((u
FfG6`Zb,f?Cb(PXm-_ VbDI"cd>,w2IK8k1.)?0ɍ'Vqc&VV	Xݘ,C\cQ@"BPVKѱP e	6h[k8^T;l'k!!R2n3;5E_=i;HO
2Qm5i`FUu5 ]
\لBE)G#חn&N3;]áa):e,!ڿ?MV)7/NdhP{R1fƑIP,&M(~BhTޤ,	Pk}%mՉ7)p
a_/SIh¸&BLFBUt$3c[OM+,xn">7_~Wk9P~Wv7" V\d@}3<?>'#kwe~7~^>al^đ6V^ŝ6J3
xwJjKB=~_7]/WIzU|rnخY̼ `zVFmiZa]i +RXSH9%ج-R#ִ6uZ
ք&h^H-8܃bj#|)16
%LL<32vu#YkS4?%fw8I8_#MP8INW8`I
owR)Cy⁋y0
/662`l|bϣ;R\\b )ZZka++"YVlA w3 4n^Epr90]^(J[sg>jڦ-{.GxߋYV49϶P<#Up`W;`5ܴRϘiۋj>M:YY;kXd
2{QIkH-W>1/yIۣ+. 52D=~Eҁ=i$e/xU(]71!VW/QqW֨?kf E
$ wQoюRN?8jW.h6(œx͞_Hz l<'Fe߆[_M4h~&[*25hzYهbiP94x+{ӇSXJ	"2f	*c5t8!}0VTk?9\}L3bk`U.5nEooZ_{4\pN)m-BŴtpc9uKh͊7ʷdHK7P'P/+K'dP VQ哹'L:UҲ콻
6	45ye:Fр=IE$
r|H7[E)#m3+&x`2mqeZ)^3<X1Wˉfܯb> Yc_
') 0`-C=1{%kDϺY0i
	CLq<dKyV$U
8{d;-X8*f^%rD$_d I
+VES7B:T	1æ:& ?⻻8;? wxҍ8#ƨ7bArMA8쐣czvR[,SNwJ^`HQH>l'm
828.esSCB9[5
Q]KvCE&:QxMqJ:Uk6n\TF]1|ѓzrU=u1Dn5jpgǽ9?><>9[.Ƹ>L`r)0b{'Oe$hП$jL!t[\=B/ńuG`+^$;sQ̩"I$"}6YPejkwoy蛢**	R9h!A}W`SK^O~
$Кa%l?D1ڴ"lNO	j2'XhdnLAQ.m>}Yiʨ)M=Dy3#<AOp;ln/ȉ(W2E	m'Ul="{?a(rg
9~lejuCXIW%l&֑ei^p7?8I8K1Ӱ69
wERg
Ae,}uʍ\fO͈y&#XnWid4Ykȓ
|7,d.dy﷎8<k~>yԍR9ۛ΄:Y'+m#aHl*^wVۜݨPƭ*a6s
K' Fc#u@r,ADX!U/AxJB˦kQkë'7
m|$[	c}5gut"`*4u{iL96ƣ68aGEZ1_SS$p3Wɕ'AkgT:ckA9-*"ko;O,޶hݹ[z"(#'7cI}w~%B\
-!E	,PeNG1`;n鏜3 s&LX)J@~nWkG1h$P=gA{gLES珫ȕ=(YY3@5U?sA3yF5Kl/"r[xٰ:*@T_k[oxweM{C)UshnwE#8xOCيi -`P`Q\=3a]{H\1L*6jeHEq\!|
=PLJr<szgm"H>}u(LYR}	vyuj_b\lRȖ?:}wo,断0W̨.$zRvnn;F$;S)x܀?!T掼f|"C0Cow<B̓rcC|v(=b)%&FԤ.ҔN"9v2[)@,cs`8Pļ>=<}8{>ґjwLO-t`+sO)Mͻ:p XQaY$"伯ZO-IO6gn=3<{
$K
<p/z16rԍb%;(Yn?5Y+O!Sƽ]r<jC0	#QjEC%uy(NY{yNfÕ+g7hk\CzSq>"zӬ)LCKLAuL :OƿfHO	~EIP܈6 _iy:֘h|[=$ހ| %_LA:pWZ8,*Y*_@_OYp$y*	F
e{KC!( kb8k}'dxX=R:}FN
3Z-@ߝϔb6~tw7fMnX[ЁdipdHܸV<n8_ypp~ug0 @gzW2E) ;.Tny-X'R(/谮4}瘿䄴n:x
q!AVXMQX{eA>˙ؘm<2^~#"O

8Q6<֏+F2	r8GqBAZEC]G3BE6R0_kU+s*B"NLd8LX/}\f5FF<zp|ܪe.	HQ7JK;,6QEr}eư[{i7{ǙXՋ5[}H/.
nGɚ p
}MDL&-	ջh4,1k~ߪԞWj\MkpPlm){e:qvsS˓珼;8YV+@܋G=.k8lef$kSeU:1:Oa2:Oߺ窜w	t^CQcOj4o-va}ϰ"d讥Z,7\9kaM(Ī5H0SM[R[#bp?5Snl@|tq7}*s!t&uK,o	Y !-ɾ3Gg#Cp9
< 18.XGUv?x3UDa&hx+mdЫ谠geՐ5j8YUXHX҉֩]Uso`\Te?O:杻AE羆E*oe0gV*Y$ZoR ڶJ(@,f!R={{S!zu&b e񕸑/da|ȺӇoGwYLйV)~<3#%%'ކ?<px)}%s(!
sGSvi=87/Z[N<AC(wN W{vZM9V#Y6
Sئ2dC?!`T2	طz5EIz}ߜsep'2{d㲵;(*cc,Ʃ@s&jsVZ>f+ssgC^Ie?\9! Μ
Di+	4^'Wsa 껵.<La;DmA/1
Ur04\򳬼jZAΔpjwoӖZgmOmN&%0ܔ=R;h] =lt,8l&<:{\r|
)!<}%
*kVf	lKk	X0c'즾Ww
u4-A,r27}4^+h'!a]^HdXm]$Vľ9n 
MvGLQ
R$*O`M/	[V/
Mszpon0PN]'&\ܭOMTf*&d5X{֟5,ESYTGPzxaqA]\.Gg4 ۟97O?pp3|˫wѽމJ̯jZ]<QB饠G>$XYlnnv[12Z;)	=
dߵc,Ȩ2TpnM&H ݫ1NFt<&vn'əG)q6	[|e軺M.3AmZU,oT!E._̅ps
#V!uTJj(VghgTxaY~Ab<-qla (ؼqfg"Gt1FMIi~elucOff5INb	܅02T< vSόWSFo}39Hk\?`L[Ig}C)'rWm;ͭf'ktN~s.t66752-FTȂZdrbzۧ
͕v[,ڋ(?bK sK><W snXaLۯ}c읐ީxهgתyU(ۍ qcBe^l>T
sE#nY"\~YѮ|0~;A?|[?R &lH@e)~ʁNz,)1-D	eW[nM85w˟ã_N>^Wz6UIN"P,=	v"~[

K#@t@6
\Ht:͓NwAckɊi|F?Fls7ӼJV#MF-,*ZщOAP|G)ʛ.aaK~vz|:;x!^r׹sܭ/N$qSub8/91my iebhCd h*~Z6  )Óբݖ*ҹя,#>r)+Фv:2u j|<?Ko13G֓<zi"U'rOrWgLn*Wg7
Q$N76~-Ǹ[uor\pƱ@?q%GsO/AU{W_ΊWQPsks~\^Fy@ Dd<OH-9{VpN.r*.tE&3
Ƀh`wb=|/ON~r9ǫ㳏QiKR)xqV"oפ5U7oe/87C޻./$F,jgӬbfH4ja{&b7(Y;t|1E_9j/B-[PR|SQ\g傿 T
|[T.
;><s)di9me
%U+W6ߢ̢LnԈIOe+Q$m%NP: ^g:o]bn%|r^) HAzĕ%s_h=wǕ՛d1fǆ_V>>=tɑS{_oau"*<d#Vեc,-W͹ʞR#xT,l-.yXM>)*PkԎ,2K2+Gu䤼cLT@˲'GoI3R\T:+o;"\ayjJH^)RˍAΌ 6;
{y=y^K~?;'=W>zlG.g}e̥U?
2'>$slCU|su -<G=Q t鿡!&1M՗ˠ_K*ٗg7/:vv<t7 Y!U?I^VNvkcͱnIEj$1<LbLUXqGXU"аz,T	/R㜟ޤsBrObΎ'Lie:d;y|a̠zDnX%n叉B_x.QLrRt#huG{AJ-ڎVn$:)Rb#.s.smaE(
XSre­28{*i9~H]1"1I@oXRV*CPGCb؋O"Ј8pc̣eo=j|K<l^'(_vMͽ,5k!t!.6	sS򖳄ĔZ_AWT 7MHPIB䣚]PTϼ3:fUc!h@oЕj;6*M$>Cz=jbq`MCmWG\|[%Ť8I
F9젣A=+ i7*`ef# eDOրV<"`fhSN?Q?gO_4EY}ᒛF |b:?&6L
meG!!CzCVt	|gN!aAՌ7Z1ZJs@sfVi1uԈMp3⒉'GD<Yxq&E!`/f0{+\1{8' IymUZ~(+!J]'l!گl9_oNy\s2OVWyj(4pj|-
is0".$<^nA7S'#/N"-_5KPƲѕڶפ+ƜsmLIMߊ3o|<cҺ:t@Ήi[](=2K܁Soe6A1A
_Yu.A%Q<GOÒK~ƩC./'́C	7)]Z*.8?}'bsڭ,rjbqN8"\x.nD^FI\PPu+|9FkNA~5/]R"p&<o7"	F/y-d"ZGc&=a%J5Wg?dZ)wow~~<}Sf|v{ )OQ尡3s3SčOvi|m<ck"@
 vfHzz'ڊq'^Vg)鿳iýzQCR[zu9:senˣ7#(@njv}F{T0}}x	̺~`LZ¡D4@Il*-)'5Ӣ3padw/):ӑԎs.~#~H.	ȹ-U3n42:4N[g]!@Ġܐ &8yAs .A1KG5׎
Hzy(ً6^a>
҆?QS*|M7; q}L4/<:QxxqtyG>/8b$HNIPx#Z7
%Sǅ[XY??_}&7L|J7]PR>$碦{6vKNZӺ]΀Ұad4ĳ1@S4}8>%
Ac(yĽsEV4 4RꜲ"uQvưv%Sl8%ӧvjVE<K_G0fvO92cVɸהOS'q˽#~?V~jxz0斉F&2ne)őUx}-·oaעՂvKDވ^'&ffH[T0}~͖=F;rwp)"hQM-܊S0k)ṡGPvB%㤻Ip֪7A5OVX	!V=j>mRHߗEd^>Ez%<]$b&`q%rba$9L\!m%
 =m:Q:hG	Q9jJ)C^
VS{˪T2-ځ{n{#=4e3g_<$&gWg)v\>
W!xxr|'t`6_
2wyoѼ&ߟ.zKX(ٹo5Eżx	<@zsw;\He4-'3ғTd~M{iO'WGA9T:}~"$X2fiA-^'>eM,Sc݈*MӍt%`
v[;j_gΆB8c4qK;L+;9-O6j#҄IX7<v֑sZs\*[4:4ɐ)2{R@QУ1&Wa4
 ol바rpMR+0eV鴏)yTޓ3#
e(y[0,܁68S8BgDWf!5GR>99p/%3eJG߰7*S>5sR
KSy!>=N%J#א-o8ǰŬ}P2UP.̇z{;$\AܩkbY%5P$J5W!EDei&&?kܐ7uXIeO_W]L
&BvvJ#XA7Pt;MڧrЯUP僨[	&8*ۚR*p.=oX% <%HĉEX9䠹<m&Kk<a3&R]mwMj;Eó70bYw@Vww<7x6ojQQ῞4Fr⸾npUZMR7#DZnGSf	$zHq"K%cJ8WxlYI9K%VE22nl4՜ f wh@31EFvL*URR@.@q
XJ]{*PYʥIy3ɅrmOkoIygZM枿̥V_}J\]*XaqsSJ`I<JZ\<_H:*0.s&5D,,jyY&B1SED/Pn?yq`2?\B9PN.
(;lU(#LmKM9}>m5z͑DWh
m/4_E΄G@|
Yv^lDĨ%kxpbVS[_"W^'(T!Q?wsc11Ą /4EՂ7oVis5Ky9Xs {^4bLEE~׬OX F$FK%s:ud,Oӱ9,.VgmvXZIx|c5HvlݚQA(pfnJ2+Y7\.?*].ziwLmyܰy=?KXt}82~!-&hEb=_7Eq79
>H=Mil2toǢtcf* T
eȶ ŴJG>6
C{NnKQ=%qpWj.>|)@D	bJ6
hen0eQ_#qP2WJOʦ,-~|@S!&
oa<	GNxun7Uۅof._!Xpz/ݣeر̳̌kFwZ7w/zw#Lnc5q_*vٓD=)]HF+R)*'F{xnk/Fɨb@"#~MjP[mu
'T/*K7˭D"<h x$I+PU3&0Qݖ9-)@΋~J@nC<q7VT@@MEiQ\!%Tozq*5ɷRoxkQ7>5笆̺l\q¼:8Ҝ< .d@Up;R˒dy92ا;{A9nD[rf!jՑMydqzm=9]*9+l0c&t?0&?9_ݵתIM++?=+AX<K86)bK[{e/F
*zAOJj)u4B60ډy+۟R>>1(/|v$>8t
RuQHh\:g?K۳?ؓPFE1.:֣j[e4RA<'<DT	`<(#vrH^{_%}9@<g(||LHqwӵ 3@nqT%*%q$4fۻ1MLa=OO&bpc<ҜvS-{
FL0uW0f'ַ<m>niy(jD?oD4彽D"Ov
hAĻj`B]7RzB9nizUۘ%+:f2tJK>{QZYnC3"4	@hYYvc|NNV"8pQ4eg1`RNצIu4\߳1I X&7sZg8"fi_[>41醆(/TЧ*-SS+DI[l%pM5$2~Rda^.ҎOC7}SU[
j=^&lD&v0ȟ؆RgL_E$ze&O/ϷpNhR_1p{
E[niK<G͋+J^eGv^`YR(z։ ;F4iS/S#+*fN=/+Ω#|g'c%Y,lRAFDD;b]i*\Fw/nmlm],Z. p4`&[3/[nIy/\⫋#7;)Agcc+9~&&{R&	?
zӏœBdO߻dǧJ.4mC
gR:8Y+%.m'1(	a
)ūToVN'm
AT`n 2Ϯ]D_^pl8N?W~G_&h5zp~%=զKl~~>Pw&ؾoK0pjK-wW[-.9w4t}\2Ӡ+jcPY&1)T093UjT̐bvCҲxzx|ZC`j8:m	K|m)e]ju[?^J1p{mkڐREyf{d;ff5j$𛟮mJ#%nbPL/]P.u)/|}, }
n}i!ȡE]wՅP@;ah_O:OI׆ӏ;7@-b&BӇz)IGm3nTӛ2)Tk.":Ur7).n7S-?=^E09/2l jUBvb%;m_RSqLFĠ$"\.FU}[oF- @2o໌Ӷv!Z3Q,vKtvry}QTj⬢YJyJ//HN?y?rXnl-XA|(YX`60aͬGl&1:]! ='?fe1FiBM6;J4{17s,CTxa*o{mr<W{]3^
%L.,vVR2urԼEl=2҅.5~ػ/뉥@^h{jy2$]1WvD*
h[m6k{XTLx];OU0'AwlCGU

7u֪(/,7\oݮɉ嘌w	#n鹆*J;yaףJ6GGzʛ?<O!~y{7U[WZ=&T+A\0xÅW1^:ɗcIFTZozE5v@@	X"zel~הoCt]5-ZV+\bYΙ;ҝ'u>g)BQtWO%;7np1̟3b{^3u.Ot/LMFףYayr/Sa<}i6dz'@UyM]XR5]J`/nf48!z
\)e=ex;$&nn쫿Ɔ܂pe-Jbԟp.(("b_%6*_Vn
b8t(s,F+{Wݿq[$"*A[$L-+@zʅ+fRp9֦jcA1Roo'3y~iB*f)~4'9VFIp>6:h"1#/t7d
DOQЮ8niꂽ]<DKV$pQW@x湴lG84I顲
C	FZ--.iܺf-,
*%C<I"Xh3kRV30٥*B'0}e('(/pwi9=k5S8).
hN<}K,xc!.	ľ|cKt[KѢ.Crk9;_S	sJEK$B]!aGΆ`51yqk1Kr[f_>cCP1^7^P/ʻ3BjfRYJ_KEܤQbVgCA	$̂ƾXk^ވw9QQRج!zdCXgnDDJmY3V+~@l:f՝/$RQT )e#m*zj
<}1r
m)U怃-JzxDWC;БX|R*!~q*@rԦiRVIwQm~=Oe/I aɟgDIs;ocŕj_bƬSV"NDL+]C$R5JLnz*T
/Nx]ܖϵ=_MK3̭+;7ouc="tl EսP(ZjjXsLbKElme()
_:$4Ux6ɜ#';?0<=޶0{);aZ:ED,MAKz.E
"KMT]HDͽ4dCrT5ң>x\_>.ӓ?x8d5(,jhѧ,iȢZa`dY*^T14`R.tA*K3"	YĕY][үlJ,k ,
bd}l&&{%B|ӎI֝]JJf]g=vy`/\*}>IÖ\K()*ܹ>CvZ
Y7ر<7Yx6|RRx3U|S4|R$q3ʓfllm]ʗK=";;;2HP&BnBMY7;q]#T ō=z׃e#ѶdYHc<c46Dޭޅ<cK4;E ?k^.6R'
/
.?n"~m&Ui6 ~zM񭭷oCym
vƂYL
p28mC ?)BdUo꾦/wn Aٕ;3}i-(C	c]k}v❚'DMCw("xoe!X#x:B":rPQ'x77޲V8+E8w:)kZql*em)jK_@>7
YMN&(/wy,馱n|{Y
6fGM!/o`{Ѕ(ȥ-{25e(nACɩ)?K8s"6&=FiC9N4-kL P*S1a
Aaת5ݙ= NE!7K:Ϊoz,A.Gx(jNlPR4wڧHɺo{L!g9f65gD͈iݳKi{RluTWj޹7{I㲡?͖^{fP.T%WBW_+h1roSe&:JLқT\+@夂yp-
Ywh&stU6>(S^cs
zwǪ/ooکǲRo
;tg݋ /"brUhx0Ckա˱<yVDpE拠wJbi!
S%!{Oq }VѵhX19G#+ @W :Y/BjU۳i08Ds647prV
EL!B&qXXu?Ӭ uLέPyMC}&K?"G!m7
Jb|';t`HP%Zڔe($ɷf~ 7EW@.ÉHZ^EX[ _EcHq6l``Ƅnävk;ZEbbkMK=򱰻`6^vH>)%`Y,PC
cRJ}܏޿;:;/cCi rOx'gՅ1`eSfQ4Sc0%6yiNl,hn5[
Im|THT06o]jPz4/Ά)Z;ŴH8Tb9ddԷI40ZZnhKJ´
j\w!&kU5GVDqãW.Vf5y5ޖ(Eni5Udk'9Q@ZmiٯgRu5;;mk\D/`ROyXz1]BiXh[cL
!C]e#`/ Rv L8w;ݝ4Gҗ6iB0ֽȄWl)#06"S2R,B>93t
9:y[LO&,syԢ}(tiГ֎}ѪIT|I}v[.㒾 vlKu "il͎5=qc~5"?`E_^Wux}!(w;TaQsr9rϰvoh |z3T?i~s<oW7cCAWmAkM[jj&+pF"'~ZXW !wB9LGx+ɡ%#W.&bmnVDyụx fNS;<_TҤ'3V/ȹX?A	ć*SQ
_f.M\
,|)\d}`3pf(@@.	9b9牨8-ܧq>kv3>:3G^ʼB_9ѕ+9\FD^k5x!R<a}?|"W+REZŁŘG2o§eusjpZܷzp?/n?)R{0	ՃjyCR@MM?{צysq"|{WOmmNB)Abfij s[nuo#
,4;	N]TCJZ1p66끱cU:$/-fm [QWk^ymܛBFUH_ NegdmSQ]I9}[AjrO\:=?ݘޫvԄ}oa%e5]=z_we5:__?Ok!W魞1lcg7[{ՅR+7dg:;aw/ʙ诒T1ÿ:=Bz9
9rH? 9]s"]s9\n7#W[[v}|惺8~U?5yQ%OYOUΎ|̉Ok4%N	?Li͗vzWh^UHX"kۈHʑ{P@Ej,XFaMa-"Vj~}#\/Z)[/^Zdu9C>iAA	?	x̑٤I9 zRfCQ4n!HB35&}o2vH$/LM@;>8_7Zo[-U;89LfVFQVy9Vhjma
{&ռExm a1HB¡Hj}*aY3Yr!9^kd9,ҸҜ
e<w.,3!_cl{7ܨYy:_l=9F
qOl*y
'1Ru|0WYHRIYNF,NDmvF<mAdw\Vc %(.V	)+2
ѡ'Y$C;tI,/d~|3R{gwu+[ݖ&nXZ׉B։E-Cߍ&ߍRZL 3g3
] ~P;B@)Ը)eTWmz*%wyIo-Xc^/ZF~bpfQ\?r@, %KPH=P	TwN؆{&jRu jB*%I2߼
lfpW	*zutyuu|ztj-F
x:'sdFc|;
Blot~_!<?ЙN}T/!wNqWƑVlWwX) LU{tfk#d#^tQr l[k#_KuA1OFG.b8:N͔kj矀%[滥9o

ҳi/zTxq9"*,6Bԫd٘(MMG{wG%'8uQE:9v2g~%H61]ZU1p&b>F;ĖsJChZzLy7&k%Ϭze3@8K{T/U%H3 {ZBj2MƷC\>n[q+Rqed?|tӣWŇ7kshnUAl9LI|@e\֖$[hR0d9|t׿wa~zUNd*M%(uK~mmil]Q8/礄\oi]i!]BC
Y$qOI_i!Gn^@7|/5\V
5ޝz]kwMJ 9gvU -]%4n1@]R *wy~O߮Gt\p8iШbQTTkhkʌ'Lz:o5h0lfu#
XXhux[* 0-a-;]O_SraI+tlFdeQz|yypѰJE:eOYM
  ߈ik@FEm-XUCGPQw{Nk+`)Y
#SZsC7i)Ĳ5q-eZ0b4^F!k:(`>G}Zb.gCr}ɎƗ\nNLRt)ӃuޕW* zɣ#/IYbl+.C:ݳօ}KI#.HØC9ުP	o$GVgk~g<Je7[wv0ET#j@s0C+5?nyA}Qݗn/>#xTr=A[/{j
aF/[zv6wAU;TjQ
_>>gXú4"X޻d4	KMiȰ~BAxD.ܸ +0: ~t3 XY&
Jsߨ˔D wL,VQfǜG"-0D
?̙PޫC.fTqSMw\'#LHvDv
rC"1uwZi
>i=eΤ|TJl3hrQ׽x+)43[
9aCD/%c:;_oCrKke3(Og&-ЈI䳟4pHsG"G$+ETGfyn!Evzj6՟3-l&*}fRteL"EXG<=j1'%\''
_({`~mY2?dp,0o#FLrar\b~` 3	!8Q5)⊔E+B
ؒWZ]skQums^ȳXh1zjULks?9RszE_~5nlYdkyhC|)bHgp2*V٩{qC,N_@쥏(KG!Й?Lhkc`ݫi1fe%HCcB>eD`~em.
˩bQQ}!Ds߸4QuA
ˢ2/n8mkh礮0no
JDK'pe'Hý9!ʳAR[8-cQOx?u^"'ik..!=(H*Up6C?tZ奮(aFfw)DFi]ŘRuZ?Kcv,yI[Cf7OeK̦Bju6AtR͡C~ek_
;so
(xѣ=yKW{@OE>\]{[;_s!DMRn 烑VDFPԴzX\t߹4:h7^~.9'owt~T^deN<#=K|/3V zp ,TP3 fP~MG`}UdO%-k0v]s2=pE@u1(c-6;]1ی"k`[)NH8&ϼ1ҦbrvgЪ\u
jF<ycrn8fAڰʂאOO1&'/PD+Ā$UxM6}ݧ[ů_t`:w◲W> ʨԀs"7(y$7#9'δ.vVnхxrKG	Fp?㻉0ד"j
W+
/E!\E,@%yʺJ(.ت3وzDJBۻ[%)8@mZ%KV +(Ɯ-Էd%l`o{B/;84,O52-n=34"þUt##hkofj/ܣI&ar+M3̆)O+YqdQs⨌(!n	jnG:?'1
"|b2HTQ#4ӲLTQ541H	Xz1Fg9wr'sq	eA3tŉ{sJٟP3ZLBaڹΫsl"R =hGNȬzP\q?D&ONAEg:6ǷŰ\Fdf<?:olnPWp`s)LStF=,Ft:y>U94aL
<@FDSYW}Ӧ;
D18܌;	{*AsнٗmU?ev٫g}gR%`pN\zMkѡg0D]G.=gA;cZ&V`Rq$~,ܹO7jeei*=?M,268A`T"}lo0U_
d!믭؜Ux|'\:(8,Nxaߑ΅O6P Iar {=[":+޵	Y"2SCoFBEw?ˑ.;
\G/.SF
LͿ\u3f/vYJR6'4B3J; G^5nlGd,޴)=yq,'kBY7Le$gGθhHeGuye:-0`2&Hwij5#$0,|nlHD&1<eGPjk-*zK>zۡ3`x@
W
3g,HcCB?#t$罟}0ýIyLtGyNbsC]&g 8ln`/k.o߀oT7ߢ2}ܓ hCwTDho2\{JMaYj$\@̈́?L'ND/Jpf0z
>T*q7!p=.b틻)$lu9e|$};ƢF
lݢHѕ>$74ԤZ,p?-4EC`mؾk1ToPӟX	hƛda{+GHJ6AQ3 ވՃ:"v|/**xYLJMP!fԲ@IgdJ_𑻠b}hCq)nA*~-ǔ=Ǽc	|-s'Ttev/Y <iz\VhDdEuYB~f.Z*=E|@&zRF5}~Bswdt4W-ɲreq DE*ij
/&CK7l+3`]o
W+p%M ^r8Ҿm"Mvj̾|"x8H=69L9j>尛lּ9BI/<ݎ 
M&t7%/ae{da"k7/\AVS5vs%WgA;\m.kr	ZZ%Bw`;vآ	N'5K9IlAe_ L2.:_{/*sd墸Ѥ	x!fV1Wێ֖F.s 9MG;s
s_bck#ђ4V׳+e
}Qc6W4zo`^|uwi2z@BoTA.E08'08Ȃ|W1p:VuyonJճu(.7l\W5rT4G[+*<% @߷Kp"ЗƸ[KegU>ӧlla.`Pүjv+я^Zi	4
2#7ECP:qT~<WЇHɍ-H}LaY5Ng
م)*xLStVnL4EJʮguPYDY`{nj[ƹlA`L&U&%}r.^jè	[e95<kkOEf0	"})gRH>:k+#3_]P[u^~)H q+|^~z9;)ݰ:g^ECxҕJA7J@-i2֓ӼgN:X6|ڱg+<l  ҧQY@*+	6n*d 
j:5:ouji-%# 2'7Կn_'mv;ͭfNzԜN+7TcU/l{x
wCԈ"1,d<rfKns|a`⯬7]SXkATha"*rxD/K-am2<]X"^9IVH(GfKv2ߌ2H+ˑG-գ%N 1enEGo)Ij:]'9!{MGɂљ\wdi)4G| 3%SRï)!jy'0	GKu1זwTc:7'"sMMbfwPyM.{w"sU{^T`M9hafFhmQb۶Lq^{=iCtf4	+i)MWMApi-{\GVʠl@_ ""]Bi-ĄJYpY䁇y40־~.fUm)H# Ws' oes:@8Ꞌ.ILUN5)e%vkz/CTo v:Q0A#{/'"V`;I}XB;Pʑ#) |ve2,s@/
4E)-7{R9ޯo[a6,7_1e6,>YCkc6F3
*`qyi`FB4(h+rboBp"sdr/wGj&>vrmO	GӋ>؇ErjLFJTMF-1Yܝ̡aUZ5/묆k~ 5Zjt$+WnE,KuE]ȻWм[?u=p"SW2}z8˃by[}RY9MD@ME*HXnBVT?ZjE~又1d=8(tD$#:WqB<CU؉餟e{QYTEbFLYc_"Ҋ'5X7B:)LfUddptuwT|H5DfalfתV^-Sn.A{	Ky=!|Sps$5
1t{X,؊}ӕĀ1XjawY|,$D$Zkkl<A@=.N@%ꯜyMf<NΘ=
E%}7YEvC1#rxj
ngP`#hS"7	 @AWEpu#iȭJz)
6YiZsya7R<3PْsǲwVۻAǑ &azw`nEL	A
] M
b
V뢃,BbM_aܲbV,anEA	rGLWAt08$r|+LesYPNj8=wߚgΪѳMNEO!\:gI&E41@s&TưcjXNv*2.wH^~MEc̅+Y*ޥO5I	#L1I̫dP,0r2	+\^n6xsHYIMx&%A2?88:3KC̕Dn&̃f&+uBbfT |%j4%-߿9L&SWXPA|uKk7Zb,~<DPU"msp7X+b*<rh6;Ӛ$-.񖱫H5YD˭
.N_`?9Fd2+ 9$brdrAq?j&w{OnY	A%	&{˕{v1tԻ+Z%yISęncn!&@yY|dܑ2ۢdTN: DǪfZlG=fml3/1M#XǥAJ'DYf=PTQFRmȚDMYh.EKA@ǔQ1HYv)T&@K¦͹(bx(m4QFdU%}}RSO\ߍ&QA*MҪA%pF~˙/"߂ߖ;XwP
6KNߩ[N
5'rt4NGUUˬ9O~[@-)BtjPYe5=WDf%
u5׺!"M$T)csJ^W^Z_o$</=bƹTa
5v	#Sё8}{M¥P_b*ثq)+ȻG@Ӹ([yZ35kPgޡ濜Mstto'>[)e|
xR7>*%P#gOnFC ӐLXx?L.oBc1-?psX
 ~JeX]B.·*|XddH)ZPװʝ%y2m Q97M7JHER0P˃:aF8}qAcc>b Dcd{7' Wnx"$(
SWς56NYUN>$*T}Tl3gc`h+MZCR\T*GQ_j1$B-E^aͨ~Ey.tǈVC]QlAfG@c|))hXِ{r}iV:|Rf҅S'c}{SEfOhZJ2~	ʖ֑Ok*F^B:L0X
jr{sNU"
<<-TykUZ
EmivLELv4|?xvӢ͝i^a!/߽]:uA=;BzC6[|4Z Rihv-ڹ6clŌRkmr0 ævRc%XMLٔ^1TbiU*"hbE8hy"udQaW̭^idKť^TҘ5Qq(.bYQPm %ÉU'Q6NqS]&U4\wǷ*8	-@7(keq\2]УDvx*@) k:&o0Әc'B1U+"^tX}兲-D#1kdψP/u(ͻ Ix]6[ϕ

#=庲vNhވVȹiR?4}^SpXkAr"ee`ʘqĦdKhXhekIhdY9y.I3jbPeMNW}2#ԡ^\?]wި:i=5)
P&bl,I9Tfp%&5nqݵk@Ǭ3ِlxYZ!^BA>TR8տbv,,/Ϻ~Zn9/р`@05=ِ-y^9a(r(	hdh3zS!IK9%P㪩vofؽ@	bZQ]＂e!jy4PI$swI@܌x,U[ySXmEۅw⶘8?vp5@\M~_X߽/	^L^u6&$N,g%t|(MTҕƤxZ]/"5A訠+MoW
#QDS.B}\1z71Mov@!)e*^88G꩸F]1UvGCc
{4#>oJ4[m30*NץꆯpDeؐsOM>68B*7nDZ{Y5eFkx-\Oh1^сLROwPSj8$e!d%-ѹ^_AnFgՒkťgu0L8;XeyfҶв
rhP5O9[QD!<v]@o/sx9no'}xGqa2z7z
9	򊕕sq \ ;lG߱_FWa.	ysl=3_J,t9cw>2Z/<BfAaAբp{mjQȀ4ĉ<ۧq;՞GdyPo/:b<:
yz
hsàY K!4O7XN')&%ZhJjUn8A$Lƌ#E,E,Q<1yfuN̷}6Gg%P w`]q =-
.zCe.;YfkdeźNFf~8jcދ~MgxI-@(A5
#bK-nMpĈ<gK>dw]o2*_4S).`%{uP!5owquԞsOFq,A3wz~pNkru]x_0i#R'-"I$84U2+':I
=? ܿ+Y]ӓ?779UKkRг v"n:7{dy҅mͻvF((&ur:Suw	Vl㲬35(ki!.v7kF"8 f$Io*!ߥKs=/6:U*>Fсa{}KuSlqc_rYit`[^%b,`sTX2Тsl`n{,+g"Xx6A"#͟
Se̛J?`#\V-_ul_Cg'T5/a4]c-U/DDl8ce8٧|H;\SByE3,^UʅPxEEHq!d`:mڽ7  9{Pm"5$m ^(`޽Z٭w.u+;h?fell,Ғ;v{jI"`xAb$'Ʃ˗Z y,vQ5Qɲ}A-37ECD4{JDmDH,hg!0q{.XV]2}i9~J]t?.J7W6/jK,`v6_z.|wf
^řX3t\;&t.oʛ
p>-26RQf2;R];
G|\NvWEd24-.֑oU.ʺQ3D3JKDDw1ݠ^2]2E;d5Rw^L4aXp5uʰa(+!6
xأBH!]'buMf$C|3Ϭ}<Hjkg6X]D^߉`
5*-hp*\0pU)833Qͭfteq;:A>kc$*M*}SGza=oʬ,;X"=TCd?[ηd7pT1pvR|eZD'_㟓Mwsq =y:vZ׮U"Z`=ke%ެ#WA̮k_;-}\i
hqbаO$LU 46iS NX&Jg^5FtW_4/R!W޺nT/rnWHtu5+|lϤ)
#A|QZ§ʆvXYVy-a8<^n	GDm+L:6H' ?V5lտO
Ϫoߝ;۝ߌin-$Ѱ:ΐSa pշkfn8-k>U1Rvj[_ɄYky`!CC:=hhBݡ,tTC\~s%ӃXJM$<3vUÞJ,"Rx9W7V7@bӃIe<\PsC7V6$UaeK_Άj
`nDw(*"WoYIn%ovl^?2i9:qgZ}W"kT+Cz(`8RR؞V,pD1?
^$-:Zg3j/D@RUn9PN0PDv~{x{\x?]2X)%<Ttz6:"-3̈́8Onh<V۾kFRipҖŒ2I"QFo¬@#wnT+{Bo[~g7qww.wr	_U_a,4s1Ӕ>>u*7i-U
Ta]8'b-[_RmW%~/f2a*֟3Ǖ#UkܿɮAj(!<ĳKjC|զnڡd8qͳSʈYكǱ,VYyL
0N//?~weQR8-$?XYS'qT(dJD/^SHЏqݦ͞liм\E=E(ǳP|Sɤ_sѳoE@vsyߏ9-psK=$b㧓q
Iն[r^ޫsA_`~TNEUC"o:c=h=bʓd!58K$ =fuh+nݤ^*{/Ͳw	AM\kų69swl'4L\O\*0,
vS}Eq8\/8.S+(064qdv2u5+ 2^eeoDÛ_0g4W
dh[byKkFfYqFky9Mx!8ܱ1!4F7
j0Z/<Zy>4Z"f/,/J H#+t[:\6^󞻵GWߧ/$=3IM25Mu/<m4~Y18>߈iR+n@/];8&	'>&#eE̽.*k32cאV6m夬Uz|ut:w w[?\jӶfECG$hhv>Ȳ.;܅$Io-l4"ʘ	c"
YZ<B֫ǲ:ğ@4M.ٷ!yIϿ#qۍV6p٨(ҳ2O?f_쟺s*O5aȱTYeBCݵ*\M OL;s?$hNq6@i!YĕBEVr;P0UQ	8<.~z?oFh-a"
(8om@y@մ&ÿ/n_K@ !43}P }*'wM
.5Hhw6<\U3^2Ed=xĩ]*qk1D36}bG0y|]xL	rO&i^7
/ <k2[緹sf!103S[!
}I\c$ltՖy
<6И0\%:(I]hg Ի{(1zksאѰ!*D)9zd	jqI*dY;8xYHS!-agv*\>8$1ŎҎڟ MKw<'UAR0HPS[LX( qZo"`v9+^61DbĹl {3.|Wu֡ fxqQ	^1
Ԙo6ЬN_n
',e3 14v}+Pf"ǆBw+x5c )+#⡻8d`~9tY|8zO
-T%nfuGjbFu=ϐhsJF+ʊXWC0H#Ew!"{ɷ&QC`&υ/w
[brۣh}+ vl=HfQۻۻI'
vTFXA4|LvJh)Qϡx5SR'v`4闏aw=MIm{D763kSngsq#u9hsi7zּ;{izkaFR 4kV
9(ъ6>u|tۇqyAv1WeqCK2+; c'=<uˠptC:yKƦt,]#+k - GGh)5-W1jPXg^UStsՍ |Iff2pRS`4~UWL
f	*AMgpI[قrZXM #;3MmڈсȒ&V7[gyVj5RHEi/q7<ѧ1ndMdٿ|^KVDY͐پs_GQ&ŗ#*/M"X^1n6C,Ag~wprvCn.:>=J24(yu`MgxEm+#WkJ5_
'WLՏUooB՝.p>)kk;[=sS{!m]u` 3>=S'Dz`zxr`6X\	T/zNjΣJFGEJ _ttQѲ>qLܹ'o7qFK{s{^4r&4ʳYo^kz~eWT]ΟqE6-_i (zq.)G JQuAkp1z!ȡEWJ"YT\QWQXD$TPK_ȕ{6kd9VS۲zTC&ƯH Lg.5S<85{z(AZy,	'޶Hy(nY!Q\1)!e %%pEb6PDuJK]=Yـ񰦠gpDMu]WhYͻV:j+Ơnq)	ĉiC`&pn(oTX)TЃ*(`e1Cr&AݪImV%-6gWGDU[|?$(Z;qdw6?]~{*(CniہR+:3%A!}{/-|{k&knKVP.NXu!p乧kzUL=,ZٴU+$!&E}<J;7w#zY*ؒ2̼\V|X@,<F!$mviѫN4v&,D^H>(u^Ff`!`,4By?'9Vzs||~0tPQ=Mq#](5NOfj=ld{nGG}s5jho
#dFբgjIns1¼7&h%<,yy.SE6YVjeO>TIe02zwO4`6U-х̮
j/ul	jemjz`7i5N2i\AMt"=+edRn$Gɤc}{)[Pr@<^=YhUv1y%:न17nR><DJr21Lz~&L5Y?vWv2K%
|}GҚ`s݅Z
(l"$qӵ* ݮ^V3iZ{+P V)m ̝UT6-N}A'v=&vk /o#{Ɉ	sWK⡇%"nNPK/miSbn:Q\l0N	R#3EC,gٓ6{uOϲN3CVw!=U5QXՠMqXjw
mO?㲒-숪?y'ٻ1ʞ{\'
1U\ )/b%#"<%叭6B^A;iQey	ѓrxP#'|p`|(FW]DQ>> 	7/HE$.!NG8\kǑ{.#*g!8nTEe8#9
nܹKGasȽ10>`1nw+8~2;JD
#&YQoMwS
k{\ӛS6Z8IYyKo:U8FcTG?_"D=!![?:n)
߈5n,sSl|g @
z6ϦꙤNj5!'PB&uTZ"%xN.Git0H8<Gژ}xO'W	XLZ;zL[Q-nǇF?	>fLҎѶ.X^D߸rWƑIP|S[#H}Y%nW²~ )
!|8iTPO^ u7nTɢxxU׽&FU*DdBԚVS8ݐۻ9oQa/,κpex@^Y_o领ݞaɫZP-U%:9IJd#"` Q'i=6Mu+jMuZR;Bݼiy@CT sPss=Vih/|N1^'<"\9MX%
")?6aG"z(.oh+ިXŸFt!H+{Px=ުo4~wkԞ	FTDT6#Uhİ{izU#In[@|Wp\iX N^'
.I;;
[u.c0A42/(U0uOѾ7ѭg`s\amlTEɍt~3d
sY2]^0%UbFO!ޜ$[td44|@]La+/uz/ѼDB	m6_v&x]jyNˢpԨܪg!@AU7mַڄlT<
z_-iD?
%ݝ
OJ4akg$fB#cFQi\?O:3`vѸ.I`ybζWD
AJ<JRhfʼ^< mRoQ#=CۊVYJ
̈e2*
GTA*?/CN>CZ2nwwTe\sg8}o:NQɘ*EƘS))u|r\8WڰcnF&%dqUX99
g-{lBVPX^T4ae{lL˱b.$KDe!.aҜ{=$lnǥQ kP9<-Ǧ~vPn>_t`{̗ҋ:ύmsVR;UV{
~LX?[1>0V	ڋ`8?h참砼asMJ}6`m x8KHFBjQgF$b1ܕwHn+,\BWB-v^9YιkHTYaFGl^|a/LCd0y5
]1L[T
U-Z߂8<ݛӝD(Eyv;R%*dr*XS.,އ[%hEŰ_Bߨ޹|nxyiTvír{RfT``,_zI5rWEj5Z_$wO*URks3OﲺyDQ\J2zֲrq,Y=!'j؈6Y3p&	
()Mi.A'նj#d;H
^\?U
Y 刞 |=>9Nw
Zp,A7IR5_o?n{Ehy[jnon(#mƑ>hX83_`}7	hRdp)p")1׃X$pl=V[ZF\Czd9x3cM
!d43TWoڵw[ޢfV% 0Qx"1PjQ^u%Sj7	ܗL^fOUm; B4Lr<}`Њme\Y}/e,ǵ|Q}VzUG%pK-\%ڡ[/z4/.< fxv */
6i1F֪7Vܣ~  ޗ9_A.Hǐ-
Eu
.
"K}BH^n, 4 ic>ZxM%zˎbm[-cRz8jK#	4*fPZ%2_si
nbw?Vqvm'[
xђş?EF$[F6H)6 '>,#^[lXV,*;U+{aC1pQԲ=kj0cZ[Dno.A_Q#hˠ40rch(=8;=tut~8:DTX~mu.Wu<7d*y*TA·_*|ܰW_Bä}4(F{JsJrv^zpYnla16<Tԍ[S2LaaX  7і}rPa7 CԦtȅ= mj]e)*4ǧihD"A,WS?wӢZHk{{ކ,5K0oD@kٝE
&ffd<qQ /:+kn{(kGսcN~o	`<$tAߎ<γ?	xյ"y-,ё?I!5͎Nc!Y=i.0C x{9zېBm;bg=73{ux7mi؛D[DI_Yo'?F@uKֆdխVɿc!^KiI[8++P?ǍV`ݘܚ,o,JQ!T_/{
%j}Gg#PaVy9#	b)
F pQE\2J\wujZ0.ety)}UfI0lm5FCB'=y^~L|q+~><i"M/窺Gј]^IY^&樀>ȍ%wᥐԀ8SέBbuF~F!M0 ;.lDCSy@m(+WP}dj6`4'w4y1s 0y:o*/Х&
+{#Noz(R!)ye_rG/kCq(h@.+tztH,M1a	V
VOWW%
dEHSð2j|^&:jOyzrIbl{٤6\q㑈mq\Hs*w97p7"W8UeUl-.n}哾D#P,[s?LX=}%Ghu-$;OY>yڰ0,o$뇱2>iW0`lpm\Ā~ҝluH]seVPU(圢9DڼH6ř(B]J 3ܽ__;n6/1嵿^fV3κ٩U-ъ!@&_ݛSx
_ô΋jmShJU[wv5.1ڈVuNcO8<f*ҽ_^]a{XCcWGܲϜH#nJ5F>6,bwґ[u.31oZ]Pkr3o%d_V=,]N#wph
N._N4(/
<UHC\4	Ի~Q7/w 
?+ۺ83?yBKz`kDw&B:?=	b)&",[5{D54|9uK7wb9Vݤ7EN133o=67'V`>=F#ƕC3cwrd'F&&W3:Z[Vh
D/*ô9H*E&H9a*BҼ x9
)ťdLj~-snFo`A$HQdlr:[kW}Z~yIjjTؖ#}xe8ByD),5RAK&*JþopD*7Dl̽I4^
@5hGUq('!I9͝ʎ󊨷lNmf,ʩY>6T At7:/]>W)-E,K@RONhX{.UP)(?eF77,6,3mPѭi~޵	n.fo&1>'5ܪ;=" u3Ndߛp)%Ӵ[`,6.arCSS`H[
Аu?`ǣN\J0f/<N	w"^!YUAxA1iÖCTT=Bh-޴\ktԐ~Ʉ3}a9~1Ax^c.B+*Wxc@$yRAїc@
YS,_Vx,j؈Zdd] U_y\\
_5iZމ9ڋ[H1?MGv5\\rAIe8Rܽf߸|M`jwN0Eyo1v1i'SGp;.izRTa_p.U %pt^$b=v8\LB7&",
(QT#3Dge11TB	4cR#њ|0mwE%>Y~8>q'CYs9L}a/a{inXlVN	#BN&5T8+sxmInwcx"I|GZ_K	4@oWʹ[g{wk >
}X+\VEb4hIɅ$b7,EZo⽬ZNU|>`i4s8;ŞABߺߛ0@[/d "D.MWƽ_cƀ4DJVf6#Du[n2g Y8`L]2}},C:Q`{ ݓ!YI!Kn}j)#O2ŪoE
rPhj|nhqY_(`),(L3,efAeɎ)~ۏa<Kw!wq*	cFEL3xYf괷}+H
z37Se=UŗrB-:$U)g7@H-c25>@=.nlWj[:oW
=9?Vԙ* $6J^e/h aګ<ɢt!8<^ Dق]W#p9Dd*	`G#zd
܄[{.u~u
u;))!p=`\Mҟz]to#T?4"֧vy,&z)@A2\U*~?09]c霕̆$HWh'+ s&R+:s 6.cS䠵0JG٧21y?> </tU$<8eJ#חc;ׇnA\9b<J/訏iCo?H۷7Vb}09n3QX6VR3oZ>:>ӋEn3Gh?	*֢!H󺜦ܼxD]:oIe.-{wO^!ۖ'DAHdg?	[.+4^	d[m!7 L)2yb3mTIX<
Tݖ(]R
4W YO{_7>]GN.3-<Vn>vxH!ֳLFYbe/ t-U!??-#l_aԸV:[>׺`g# KƉR4,eǄ+_RX
L^#FLP#)LgnTB*2#T UF?CD~X#rw;8wN;4fqwB b&\ʯ^Svgk<N[H\M<9s.-L5]`uuI8
?AÞȡXԦ*oZDQsp˨gJTQ" JE8Q{bS2GJ*pPhؕ7Ya|zUV;NP-Z`MeQ}@yl/5nݙB
?Tv忲P)	أIj'|_
Rx68D{!eমm*#.Xem[$peWΡh s\ֿsqqs
9P,nmT<)HpDkHAl*:!Z9P@@gŐSP*k(3[;&89Pll=B{6&^}b=M 2sk5-AyUa=eXfU+wsxoA<\lIS[ͩMC{MStS*֬lA҇v
BVX )v$+KrƂZ\^9߮P~*{ݭ馑wm$n{msq]˦'Y\b,m:yZb{Xm҄}[@),vY|?oHɿS(R~ [OPDPLh[~#<bA'&gb4uTtT驪q7t<-g١RyO=h1ܫ:
[c-봬mIt6%Ǣ9lyo6@61$YX
a:;a 
Hd6)&H09Ӗ/t0P?>%xux#tX,Pi#܆C}AU/@X4MP}jyTW+Zf``яBAes-.E/
v,diuy(Q-m0JTgL#pQnTjw`kEKdk\~r*$YFCQ%LK3GȰ܃"iKd$lbz\;<*]y<_k%&C$ 5T;V'QKƣP+)sUq*Psm
*Ŀ+$(FDޘ a5oLMzNc|2M/"#]h
x70yuo82.tXU/;@#>e$;νw³J
LҞ6tـ-7Ik]̜)nun&tµߋgJo#ИyՄ%yez2nSN^h2iGXOm_-))9-2=R׼BVczIM^1}'G͚M!G+DOt1>FJ>w{xoRg%ZVjPjkGhēIDnazt]QmrAMIk_+J"քP%Kgk=*^Yt,i{5icc͑k{^$q,;퍭mzz	4$<CpkRdX=c$WSUY w^Zgm/Xܴ0_):w,;[Ͳ7o湻ֽQwg=/A[මv!C/0+.Rt$J,8 iҽ
kh${bۋ+` **Le̯B=*֍V̷	jS?~i4˘y3RX3A>od<>WƝL!s:`7	787vRv~H5U*R7*V9㷧.]ض-~?폆1A^MAAmbdRB*z'5hOH]hEof"0عyb0˽??_\}?I>+B@}\L	O>VǽA>_G^.LP,G)!=^TdZzfaɓSɡKf4ocM#V(r 	6& c5\  |=觳6Pe1uǰ6 _6hG0}6NЇ6
a",]/*]?U=
/,V?4qsmBݹH.Zӻm4HQ GmUgaءHe7)fdaT
'hRi$r
WY:M(K N9-\cz4O7XճC[bmbx'MQI`3uy:cxium`#fxba]XޝS5U
貇PRS)f2ݡ#D?TpL>HERszWPxlJzB\xGNn ڏڻ]#]A#\iwj˨NDڃz(%(ҸR#<eohj:wSn9f
:9U0(/KgiKu[E/CnF	4RU(\} oZNNxlEXZf\|64b(( Oy|{ 7~9DW!XBCcv
q䈺."/	a-6yHVb4`$8F#7I{ԭS pb-a~cRYnCϻ!)aSv`X{D=< E6%5d˶F.+m`IB"+y37kqK?d5NX-]
\eM!(7`֬}\F@̯Cb*h
PZqw_<d5(}A˨hA3`Mz@Bj||i|qWe!T\.<v3(|]$
ďX_;
BK7_}ZxQcl"ש>BwD*͇1h> t6_$3,^ڃl#Ei|1zlf+PFUj$ʺ鯘SfM~rgږO&oz	ê 1`rDn=A
xVx(
1݋3~+Kjt5vg~"UۓT0asmh8Ǽݭe6WqCZU>X&#ϵ/z(7'553*}o"B[D4|9eQ{N}N_,}S3}#M1 Z&ʃ(=Ѭams5̬R/˪,FΑ^4.Dz;R㇩>9DrOb#y~}|P0ӊhEN≠yٜD[вfIʇJ\ZuȗX
l7USwvO)*X	]7f*RIVPvmX5KP)E6X;[ITGu4
7l=@v1-U!ae<.I@HD̢?'QrZb#p4?.|H.8W˭GMkdLo'ƂUVw
T@Ps!,zu3J=
ڲ_7@4E'.ԂXWN!{Xn2Dv12[?ˉ?Om8g"Ru4NL"վzb#Ɇ$vqW Ăg_Fr(Gm-cCϦZ}
BRkv@
r|,{y2)eϒ6f{꫶Ji
B~.&7oV%L]Л,֎9b0NgV.@Gkd{9ߍ{(\_sY  ,2sbbԗb:wGsYy+$[1$]89]ӉgK/(.>&qb75ҢJ3cW|3t0;Ӏ
F]=6%! Ha~U~aFA7՛S&x*Nv >ufE*mݨbJ%WkFw,6vj#EB}Z_jV4^WxPJeh}E@}"ZSKOt'15
P6~N}7Yh2( m֪MC;nP̝W'
tLC;xG9oqa7W373jR]#[iYF>mӽd&uy2;&{rGhK|n$>Z\_cԈn'}1RkyYZCr0=<<?)W_-	лPm_̀b_Vޥq1<Q܃_ίЮ=7uDvzZ/&M"z#B8^K;qI%!
%lV 2XJ{s`D sM<E|a0֏0l:nm4;]Ŋ$VȎ*A;Rz2/`]p<^Vc|jr8=kf7?˄ݗPȲ>TCoV,ljmYLB-!u4
Lzi=\ȴ\w^̄50?VHɋ:cuaS.
f
nLg4)U͋ާG3/d1lݞ+չv'(Ss+P>"[5`	\9Mf5r/]PƈU\-w vҙ5[&2^zsu1c0eL[5oƙc[0V#
H6^rn>1),d*
Bl@M}"v%C!tj;(я)|(FrzI5Ƴ~7P	xTj9dE]aXMPePnvדzQԻMmxBOO}no6ױ1(~~bt_n4rp]/{wOu7w<Cwv>nZ(Fjn7qM	hBi&coZz׼E9?A=c:joLWKo,bM#+Mfg,5a4P5gPT :+n66nҫ7"6秥/A艜{/:)8@
y3Jܜ&rw`ddn6ī9y%XLݗHd5fp)Dbѻ&#tbrK{@_TvCMˑPZ<7mLGJ*&i[1#5gq G^-U/kUUY0DR5aJ@RFo=eeEɱHfڅ }2.0ދXK-khd(y2ԄM
tΖMw\6Q2:lnn*_Rb[2}2Q>w|жH.,'Yw*
Jy)i:nRK9H觡1'ȅr$ɉepywQ;#A&hLr.nTF	Ak0W/Xq	ZKa\KfMk7"u=R[+j6TH֓EmTn5JNl0T^0H_Cnik"ZZOr<ΦYXNVP*be*nTǟB4m E*Z<)vtHmcb4) /F2ɥ˷iYC=uw	$KU)H,w{ ƭ5o/`>MPOڸUy8ΆycR\Q_QL\1rLk	~iī`U"<B>֓.Onml4-s6P"cuH1j̥7/刢ĉQ&Ovzws5v7>y6cwRi]צ ]Cc7
ߪd4z-ޱ:52̰Pծ7b[6C$bfZ){!d2/웤S<ڝv@2<K)UV6 #쉍&q Vfz]1w/yqkr8ຜD4Q$`LkALֱASS3rZp}Uǧ
`-a*Bkb!fk8u 龟?dH0!G	aL_XI>rSظؐ|oHQ-}s&2v*m qpy,3z[#{I|`q zaOU\gBGVQQO'VZCjVTl&XxKI5(t14'}:ן%*ΉKz¸Y&)0
er]fc<`n
wSP'ٹ㗕u]+χ:cIps3PtCkJLݍgR7^C{[mDI/F$3F-MY9UgP5XQL142(-&rMtzM<m1%?r=R
#0[;H
aҘDزYYnLƧͯC~~t3r#^َ)h`
;'L.|78G |,1*y3x~dڼp=GnUBҿȒU6l#s{K-V@~_cTޝ@tm%@JTGhfAֆm+Dr!]"x<ߕR/!Oi׳/ʱjOd	27ݓ7w&WG6D~S+=!֓͏X_)g!HFKTN鷨)lNǲ%NsAXJ=>j:@%_%G[Sr!
tl7L[}_ԪZd?='F<oި@t/כk
=}d@XNӓ75E˟f\)˺6;2W#7k1Xr{7Da8Eyth6:UP[qRVCP5c9RkvݨQ@j2Er.hvP
nwUz([OTWւ}T2?v3w-ێ)P_tV||5T!Q?mJsXl4u5WezY"h
xuwCXn^6Xl bRyt6q{c`̷-hg7sw8DJܲ_;~P\X2t7lXc21=N T+b ooj&UF@?^4M	?/jl*izx[49 >iՌTU~VcMȈa1NVȐ.wnJ-.ƻDؾѸ.^3H\ 3`zdoډFkʀ_]^PُUBVfe'``- 쫼ed+x
ǎJm8)j!"u׹21d/*Z\S՟w;wʚFyid4&\E:wiY,D\9joL}'t]KhfU?|V;VʨY.a,W*ë ?1] 7tr <'rٴd=bY-k`J0mjYFBKɬj=)YPHiv2K0}rS49FKڔT` ԣla1P*>x; !^ %{r4<C'bBJy-fxi<9;;nNzY
~Gƺ<A$!hՖuTH|sL)S!9ѝp G>~঱ŧGwrFT!)$݃RTI4VV~͒޶p*U QI^&p]ps/6_!CPd{]=;xrЭm5W;Mbwx8{znAL`w7 t5؍G9{5Zu߀9ۨhAf .t*:.S
UYF.)27m4Cj˃͊w=,<2̱v:d Zɻkǚ#JW~-D
2ɾyn2'ihѾm-*xqED\YȵSM6Iu.xv;sht;\
MGTpLCaOSExz F	[^cLHZL2)HRs} *o5a^A۱,^DxXz>?90?=-c
CS[u7bb4r+@bϩ1/ n/mَ)9"m(%NeHiN
eT K9P<~0V֐v@Ky:b]LFu
JE^^` gU]%^[ʭlo2k59&PC*]k'h"??Զy^w˸`=<9IVTm0f?*adMJ!SF&ϼЌ4DmJ}n5Q}W<0%GysCg^_	Q멧L$gQzHޟN? },`s] 2*lo, d,>= A}܃5/HxOvSD0 +Pwc}NsAj;G/ohj,-,<2H,&9K=Ns$eMV].VO6tAn7ŇdYqhu1B}zmQlHPFyrd6MY;o!
uINW+~655@ۓiȨRb
irYgk	uubN4Qu'iRo,
NDVu;q`2 ƽuܩ&h{S RoKO
2i6]67EOD)kr=-swfPnPy&AcReԫD%a/aԷiKj ْnջzǝQ'IvG1]aUrs5&EhDPˋoivᅛH7҂c::4BNz2bOz9&JjQpӿN PqxK[
5eދd3BetOqֆ},Rwm
ґp;?fQ8FٙZ 6D:J>65tJqWs
Yr0ZkMrj=ޠ4gs8VݰyJ7.Aef,95 URC$xGt'|<>f	<x|M:'9=th{tA8ALՇ	,lR˭SP	Tɏ]>2q]1x 7xX
l@v2jx>rY+^Al
Eߨ~6߮
{'C9 Yl1.M+=H6Ó词i'};T
Z0}nV**A(OǩVA!4%"Zcu{'n<<9gHʙFxS1瑾#u
cʹ%S
ds<څ U
n`uwPŊ+4Q&0-I68ЇQ鏞W_ҫ?|ŎljmSp0_Y b,E|>?65Dduɶcz/L[|}D݌3z,o mg`%y	f}$DvK몞*Bf̝sP[ C/X/aԷ_鿰ޒ}d4勪X]vwΧm~x|pvx\԰h{k˔n
mt<w.|G]zKȥD_!kgk[h0'>aB|DX%9d䡼(Fml:\t~*qz!A]\nlƋT)/-|U7oZ|rZ2֞/LON³tyu}pbE,-|WQrZ5=<Oy$i
@/Fq-tg 㫅'}U0:	dP32tkD}c0|S$vPȲY/V0,&A
Z^^(JN?ì*<S5G_6%;F̸Jv,+XLLU De#ȗ)Adԑomg\nvkd4PL3+}
|30ĴpD)KG	֯[aDQÎ'XBnzs|W:"DxEq)@8Ik}&fX".i~8>AW-}3Sp!'lԦZиǊI.y|*/:`Xg?R
H!RUb<zwξp
tvȍ"rD	@eXŹ7ŴY28"&J܄gC\B)jF )t'ྒྷ0%a
֊[ϐ{ƳxTS+M[m)7Egd4uVԑrI"Zvu-
5P{γ*$MW"z?Bq79Xq?~t[LF+~]vt+PW Ԟ;uNǲҽu[ ܎TVmIFvapVFk}]~P͖We^M4^]9pqn)F~4&
t2URPMT6tFUGkk/qT aƊZJ+Sb̊i@O=|Ӫu'oكX[smݚ3thEtm'C
ս!?Msy}wzB;v؋zv;lckg"ħYX4TMyʼꡒDHJ_zR4'3v 4}HWjV˯{By eƷCwʃttsS_`CeKtmbGZ10^pfUd8`:oz՝rW,6wE i5!ND_Ƕ:>n}B_@Yv=ճn0,j.l˻%
FtЪ(

rd/r40PfJ[۪9U*K5]=<} iGC&xqjQ5$dhZ+X\$Š*VᦗdB!oASCr%.'g(]a޸M^<clw4+QEE-	D~Ѡ]#^\@mvD KX>UNM.h)s?g/$?V5,Eܤ\t%l4i!'QD-R~c=c?AztƿyRd.?Ftg.15*UAuN+f 6K,UQ|%:Y.^hNIvAdz{wgE(z If&w#9nA[<qݒFZ_}V-fioH:X2ydaJVjKsVJHz>L|]Vor3Ɂ{e/^G[3xwK>ˑEd6pkȰj?VR^ˋߟdC<	LV
;75=@)T$LRPJe·yP\m.yr
jي`6vA>7ޤ/hHZg-36qKJqn%CcHPT;̈́x@3mU
L4,ehai7EMuwׯ!~ئ:x{/*NҷX}'n"?%?Az=ݥΪ.
XCnޛ۾d3'yI],f2eyKf(mv/Z4))h8ayB[<xmvW meS[ܞ) mUT`~<)TM	HJ/(b4I`*)W-]ۦN/1*kxMcNE.
SZ4<Řʒ)gOemS{1
I^Dy;u`ULtb:l0kw9t j-aAGYl ȥUbH8lڍvj+B
iZ1L}+O7J=)SbruYB^^/Y]RWNWHu.=Zݮa졺ʦK>geWsgH|51J"yyv+ڛ5Aj`:KfcE۪Aکhv_@DcrrJߤ-(J|Zzp?,2I~8Q_?qQP;J-A
n	e
O[=qQ\99[nPn"Ȳ!}_顰JO)JDQC5k\SH+2Y)kJf&d8>ʳOv6@Dz
i\H] p<$bǹs[H5) ک0[/R`h{O],K`uAA1gd0"Q_րf_۽t2`^B Y&})K7^x QA$ŇUiq*wǕlG̹Xٔf*jrбgIƓ;[(f77)nnTS9vf	jyQ9htw7:)Zߟcp"3]+hX@vrSǏW>P.ŗ
_ݘ;ty;$}JS6}ݜұ'_;&Uj4 j2 D}GWI.rn)}esk\"AfR**2HC깎juv"LWBP/м6m喍DD|7	@WEm}q7jݞI*8qrZ]LwL AH[b̍]&tJ/2=
m(M\
fzŧ[f(%l
 Kx*⦈)؎@dٹ<mCpMи̟[kUm3+y5%ȿܿCMH[oA:O=͝.OewX+>^eK!g,Ӽ!z*}ND9=෋&#Ѕ1Xs57Ȁh'fҳ.Ĩ c(O$DE|t64:Ŀ 33]
tgSPȍVrtOC|Di$m	=fk3Zx1t*J#s/!}-Fnk{+tj{1t1}ugnn:ެ{ō}0?y=ȳ9&ĦfeȆFXχ#5LDYtwqprm/ӃOsG;3np8.S gȟAHGebU/+,5@:/p*c=Gt#3DRΏ%qx4~P?nWܠ2b=Z3\`OJPN'Wq<Ht/wQǯ3S' Vd76[tiFR/C%0 s4qy+uݍ]\E^	Rwіٕ_;(juSwo0[mgݩ`c$6XES92gE3Ȃ+HΤFc\{EKS9YtXGh4Nݰ&qq)#;XJ}.EzT:t
 f[g\Hl(̂'A0CT̵ZNSSt^#fg!=twtQLd<Ni*S&euJF+|&7!hyM s0j
Rc*zȅ<إ\N
)Dh49Td?
htHME(O{R
;aPc.SrX%TfKBcPw1C^OI_qE']FӼcpɫ'j!J?鶚' =+	p<.PVX)2ƋPEwwS2pLMӇ2&CCuz应TpJ@s"s"Ι<HOqBwc?-{2ܕ즪ctJ>ս +xA	*A4;Ȁ-쭥p4+R<s^'gq'{VKѐie.pToŷ2(X㜼w?geab-6uJejY3|ho77L()uD麹	ų#6IwsÕḾWN;to
:S5	$U5
@?W|K=Zukm&m[KD˭/S7Fܙf}xϢe-Gio`PosE\WJ>].1e2.3[<+rV[nQ' K"؅5j[c0?/w?tɑ@ke	b S3J]{h뱩iPri?2xځj2V;/j4vz=
V##OT뀪	],3l\!=V <,[Std
Ə3k<B
]Zb`6X_d}'-K{Ҡ&H^c :"Mg$Њ9rq"8O6 Cy@DpuyV+q<)8PK2d(F9J:0d*mRۂ$~^/~[,-rKxA{nX9u$[lSL#$kɃ~hkW ^cCg_i
ɗ*HrZ~r_a^lȧԂQ*ּNr P|raOV*
1C
̉,"<[]\dk5׎qUC值w@DV+[aa5bS|b:I~,Bal[f2i]>Oh
̰)Iqy+ھ\.
`4l8}	[!3PM j/S&qAG
^Άr	難wg;SXa?רkf͍J鯺Їh	JFz$N9L!RT]>ܻB->YDke͟8֨gg;P;qeHPvnH3xf̍5M
0nQ1x9봍;?dmQ`!Z%[ms F"NKt ubrgygNx
Dh'N²8N$ȂXZ#"ˌX'Yelmא)x2RV\Lbh
XkU1{hBeXB((+
{Rĥ&5OH(gS10fCwh̀alYB`~,Ĕ=ir?	E_9B,)5Ur&b<&诡-д*y'|S0Rbzi͜aݰtF ]AHGm:~ l+,&^=ɹM	5O03(]0D>OެbPjaXrܹp!ŗ?98-_{^,_
 $19D]PIq8Iz`}&PmesDP&bK *AL:ӳA8)$SS-z=eϪ_&!\FZGww
p_ҁa[hgs"nux[_u8CրL3/R4M`
YnFpMrYn8j ľhAN^yN4_Jq#bd+SsÐ\g]HA(y#R/SHAhbuٵ-귌>DōWm8;hP-P6{8E
Gj&o&2ω_ҸI}V,.F
6ˇpoI,JGu?RܖO8َhߐ'ln|(v*L-eQ4X,L>á.-b@Um=;HTu!ץ'j4?cMF6.#wlK>
R@C> "Y
nZj9=NĵKc]{r[t`|oWSE1M9xҹh-JZpo἗1M"n촀$8Tw^Eǽ(}wyW)n77}<H͗"S;CTV˃czZܕJ /`Ͼ{wfjC {%EpH1"w["x'#) &00SG@$78Ma1X\/9H.#!\,Z<kB&ųzW{ŃgwG9MVKBf%F=7+ޏFw{US҉~u(اݖt7[SG"MuwOR<D՟:)MVwNMgи_6v/,U#t"ur	^`ZI/ mbqh1vAVks;x|m7z } ̙Uh9i_rݏgCYTEŗ.GKj)T徙sM6e(G[%}]WC50Z&~*JwKoG5ZMgF-noiexـ{ e+fZxT\p&]t_0|KN'#+m.7;;+`f_bgK?t\O%.8LS8Mbj4;u鮉N}Y_U(HMo;_nwbC=	o 5
Vvkl<kZuN&4NpnLaDN}ΰraoVFP	%骲O#!F	
ե|*Ycqb\ۍ1XOBTҪ/v]!fF0i*bjh-u(Ld9V
[Tj@y@d@+nom֖HRDFs0_Cʮ/Ӕr\^jCĞr뾝nKT!砸Z {U6pm#Yv9\`r%.jVEqmd@[5ܼWn͞x0RQ1$:&)ܜzJنi͓(:Us_,V&A#NH<=o峐Bg0ce<bv7s1e5o<>1V&kCL,DQD[9vcG1Mok IX~^n>QS
_q*/J):^ʩd?XsYHi.=սˌLIw~G
0jRVYj
ؗaǥzV1 #*"7'*R_X(Ztw Si.z)ܽG&͉';חb(a
ȕ4Jj.Q$߁L^?k*(QŠrQ=c8@9VhF_	@I=7~N
T+ Rz`e
,:OAԒjX|ױSE+Ki^7ͯ{Mm9HW@*?>?K߼|~
o7zʑ*荬E2Ov3Z4Ex$C)аU>Nk*^ퟜm zU45y]VPh TA,vw`UED@ԜZ]c=Td2R\Ǆ#6g[{w9Si}O)#1Rr&aSH	炋'nYUWS
D-vSﯮ/o$MB'܋{eqHLCjiuY],w`{ݼKjn}U^F\akK}'u^5Scl6? Z_LRy%*ҋKH_񾶔<]M#>/FXЇ ǰF]>`2K8	Ma	JwH:0/ZvLO.?
jܘ0$==<<hޝ(mC6O@^_bp򍕄>0
N}EW_dUuwX4~tiP 7W(l(>p319Xw\U7#/\#6X!iyB\K)
T݋?we%4 qhJ}ƨ/駟)L^}S!DWbD
z {~@Z)Jt*-R;r%x73\aSIJ'(pgD _FtS3nبa=OVL]ZWIsD-G0pen1uef^\8=vfOkT\MIfP9pBcpv!RSUTkRǇ})/>]};AGlw{Q8"X GA6MU|K\?41xa+-ِrF4qn]-)C/9`3䧕iC)"ǲC 
pOp5dvUS1#orH	c(Gq)Zx!8<s!E`5_c*Bqj	yEް+^Y=tF0&	":jo(4d Vz*fa642KD!3
+*-ٝ;? &b?Kc$niM.ehsKӾ/ļHv?fН)HޟБDDH=*1HnnBXlngdolsGzCEOG
rT4Tڇue''AŻ*#*L0$O>@V=k߿%6fTNqDmA`%@5(gDx3d"&NP5_Rj?T%r>BSx`M1Dp G#|I\X&lG,~m1LF*~#)̨]G;FCD%!jUQLfc	]߆0s9|4jT6oYTX1r
T҄fAc>''(u&bAt2z#9Pp$a@ 9IP,s[ݕ3nT9
twH.דppr!ccnP|nVnU	7SP5Ś$9<'鯑L6d bvzC!bM{63r9xBwes0g+^fT@a5.ZYl]".4!l yqg@I\i`^=vtw7j&*R@uר^^]OFl>ɃP
cK^џMtGoIK`BXK1]ȊvCw(*IY"
 Е{lqpx
[^yJ!r\PELP[j_($iodl,f _3O	PѤ@]=)i`x덧,{ɵ˻;}Cu<nDRc&:,AYRTz&}Zm)@gMnlmb*R5uޛVICu[Y|t1ar#p1[^>l<f^-|<ݡQ>ȻWɭ>
j6Fp3< :u(/4$~m6wtce
tg{.:Ax'23pW!؉L_$0#dS"rbrBήRV(@AjƭZuڊ$)>D۸?r%wK{kV0;0J;FA{:</^Y&]ohrOIT1l&%\A_aNrˠl$];@#D;n7.Ns;d"JQ"~E
rXD԰'5LXygQ|xrpgsO?..El=YwKwY&
W+H&ER)EP7I08EƴDz\IOn4W{ JY֭\!{;g?G0!oz#>Vz7h0)ZCL6i"UY9]^ЮD/HE@auk1v,/ՠ9?Nޕ*Y0Zr\=>r-Q_jPDAe_8ebrem4ènѾ~6\ǥƼ
Of~g3sK)\[h,UqKuI׌0gb9aںDs,_Bj.̽d ǢpC=w'쬹9vs/YCswB[9)|5)V@+V!oљ{jΎ)l"	g:/N[/ڒV>Ϥ<}iYH@gn=wFv"g5ZļXPUrs͓>ͻY0@搂A5kyJRi/͌t&o]˝H+=ԏ[L怷?~>=]/;?\\opԆ*\rAŋEIw|<PK-_ﾄ
nKOH@团+ϴ\@uu.;N~bkR)/}.OʔG^O:;Y&3'fop+D+{U7:RVq^kKE.P
9:pN+7=?S܎9N(({ޗK;>%:PPfzCv(^ }x(F6nP]7_I]"#bԵo+&#r#uH/DwiqtW$ ;Ŀx)-;ja'k)ᛅ';;0F64LT!҇L#o`̏89f16⤱Ҁ#8gaM!ƠW;_!J1zAP:TY cn/)vȢvOu1G` د7g^z˾Av779;2:0:JZ"Ч221wZrC0wjhs߮%N¨w
i ھ^X-k2a5-龔muLL87ŖuT?X˟˫磳iZ (7Sdw=OH5.aRB5)45u)±2wм_ԭG}Hw
cUzo9
ܴnCT,ԢJSiB,X
 ě{Yǭ6~aAE a	]<Vؓ}f
[q|(:	?CM
jT
JBF/Q0p8ŦAi-֊+-TBā	=</
),Oae	`j'&DbqojMZ
IbK=mK9EEbiWȠ.:I`_zg"tFUJZ2AnUȮzA(}"TShqWrӳi$1xrt&z3ך4D</&|KEYF|cy7Q;#Q:-z<QXdd}"(HC:{M;,豢-sCЫpYgQ\]Ns^>N&ޗ!	]*1zҨl<ʋ
gwRJ"JU"XjJ r _=t ܏=a5rw?*i:ʌ`i~yT
ꕬշk
غyܠ5O
}/;xZ}JE#]4=Eịq 膌?$]
⫹
ƕtXx?T.hצviǮN|.7IBvŠP.WirZ	/D;PLt󮻤np484aqSb//[VA~ѕ*?;޹^Cχ{1g̼>'rߍ
Ȋ8eb	"17\ ҂/Ye#y 焺B%vo'F$DE/7EmvwǟN/~Ώ>]8 Zv)T/Y֌M#˼[5f>cwr	ZȩHV#	kbs)+,
lНQ;)Η-J>++i@ᳶ^Pw*`$ 4(T0	3\qQъO{
,['4PnމJ
<[<[?!PSeRbhs+%my<F/n$	T>7:LgsԵqMkC؟24\4`ɕ^o\:
t܎PĲU\l?/7pMpJH4f:ZN*tL9ۙ?9 4	GR̷8,6}+JE|M?E٣BuӕJ(g@BS-CISf~`:;ݴdEWSYĮ&S~E6+Y&y'Dy`3h/8m ݭ;H06rz"*qp7wO+J}So{ݳ7Hxw=GcYIGx|0zŻStjb`&QĐR>Mr^k4ק.甙s?,gǗGO{I$vb֣ydʉ(Ͳ5.3j?Yt#
_v1~O'՘ՖU3z|:zR46X/p2y{:tuDo2 Bw	Dk{1'Ւb\m}? ])4W=(pT!N5{`xQp;c_+PmJVL+QN7n/V@g,"~Bٔ=5%m%sB!F<tcRsS$q
*fri:/{X1 ";uqeIJW:L P
 
y{H:ȝ3YZtZ44+	@\J]H
m6
$ĸ<ғrkLDwY
&wUtt>x8Z]łm~G5o;m 2{UϦٴyt@xm(b*3FFݙex:}%P:C1iyluu1QtY] GDaX	er"\Ey<">wt˿͝sG9
zA=ê>T<N`JT=JҾm92-&s?6޳7tdC
l[iZyj2=@1
0h>;v!桾Ek*Y ^1CO+jrg?L~@g*$}VQe&
MNwm0\$qu6n-zx碜ɫ5[n!2hEb(ݱh)Fۍi3&4N	x=Ll*	M.
b"&[7RivMh`+w5x俑\AUeA7<aU)/N^,1(c1܈b2U4g$=(h^m)e\'AyGc/S7Cs
+Ϧĕ]kBlD_؞/ڞKjvm][H[T;N;:ޘYF"^B:+(Զ䑭3bg	=kDKo=ީY~4QKO1V%2xbJBd?īg'87}`0j2GRGxv3F.ؚt;SKk&TIE>ˤE,+#w_zQDc12{_*Q|)"$.i.M-6H|kq8.rơzN/̗ԵL, I$|B%	,ox
,L\Kңok!öjMcxI&/\6_n(I%=w5@a6,1Th'o1C|ǲd>+q<O͕;C,+fմ.mS	+>

cT-;?
SN{g6ǳE\~ǱCMq.c*'@y:=>ck;erS-د^ aoͿFE.v>;[*Lunb\OWpgܓ#.StkF8"H5JdVzf}Stk
탒.L!+	2Zgr
,|2ȂifakDRiСJ|XZQ&ym
)&^!MEQXy$5<O
z\ܸ,GP+bI"ūJ$Ξze XT/$Y$+c1"($<\31է(Ȍ/~n?L%-W㹗P	d:E̽6Cx1o/N7
H_Jaey,wY#USicYl:w{q̈́fk]u"Z(_<==crs
7Д
Dcc0D~w1Y
?z9,?7vNG_st.,D{lL!wEBH򲔱.	9hYMdX_9&yE?>)Pnl{F=IJG[
+dOیuφ^,sxf<#YmMU'yNcn+b<.Q%X8[?89ynwX{ͅV%BXŐYŝ2=@K(;}l=6@O>FDb@w"jć?mxV<cErNpuIk9ؠ/D5{2@)/AwHДQw<n?`tɇ[^xi׶N%?{MRk1iQmP5RAw\XAm0G!p'Ńb3+ 4VkX
"Mq!a[%f8ϱ(gц8Ǆh%G^}=}*&7`wNV*r+mdg<bPG
=e]"W>ֺQۑ`<?"+<߱,[YS4Gm=x^Iw#Wg\ R)p;!6S
{a_['ΏKXP]Ee+گĤIY5!m{=!$a 6J
4V\Lڄ{	H*#ޡ\ֽ͚̆#{v(FoT ODȀyK(.!|</(電7+q{EW\-2i麷ގcoGa/>W|,_/r<\Ǵ:)u\UTl֛R@e} .<\Q	X5P/}ŃolJ/Mה+\CjhnibPR3Pjsakk
Ag	E{gIq`cP H)Z"|^>PWۢ[w̈#bX!
k"p6Lgb}֡1TXk<ҏ&,n+-2	=JCzv{{Mr݃%˨q觪MnOǭv'S9.%w FC`[PQvDOݡ걠rQE {?ť\]o	ER M3),U
%gwN
F=2.8Gs[f-z|MuF. v}d 
7gl˵VQ\i lp~(%~n4 Dͮ7Ź'ꡁs["!C')9<0aLXFsEeNoxL
~D>݅ L.6AnkkAZm$T4ԹbE>FҌ|$'k]oUFJuO׊8sZifR]au}nqcfv⒆6;;R 
>  -@
ʢ1'Rՙsy,1k>	\+ƑJI"rEp4?Ew&<Zv|ς}<O=eR`~Ȋ\mP4V*)hr]?>00hv}眗i	P?TB)7U+0GӔH+楔dLdu# tXݕJElm^}N\CܦYP,-Ճ;ǳ)s%2&H%~6,&ˇb/5woz`Ev|yqr]D_K(/
omy_lºݝD\}$CѢc36_s-iZ*UABAiV10[+hSqJʏ(%2ϡ:mVr_%0n_Qp7kC[S\тہ7_v}>=:p4SeovԒ%s/  ½ Xt\<Jfe7[$Gq.a&Tai(ldtw.*6L6b`2ZylZ?t倨kJB;
:IU-;?xvsz߯$"71Z#cAZ qR޵3s\SY慍r'mV6c_&oDjC^RȨ@]X
HwĳedӨR=-)WHj5\3M|3E{<Iam]Z]R7C,ƍn̜	wh-_[s9Iм\Ұ6|"ڔhs"%=l8'd!oV?2[?fٟN½pOhʟnnʩrdIx8XPfC#L#,~[q;d2=pKD1E@)>s|-DIQ(v6:T<`BGxTLkAsM./NYx3_vaܸ8@\wQSܕ<_LKopyT;ߐNo
!^Q-1}"4Ĭ)78m`Dܱk($9 R[+d-&2aT"{0b
XQfzqz8h >բ)]mux9>e7:>|`]Q	V:5g5
㿔3X1D4XD]_ׯuSku2팀*d:*[WGq2,gDH5)8QO~ՖED'Rav!}]!Z&(D9ѝ%3Lz&sQ7.?L(A
bi%C('Mjz6$,Nj#4
s|gW#$ tEN@s-rpMD\|TP!29QVhhmlv$gFֻr8Mb~
Es'&A;)[50S׮#˯p"MW<%D4XPDYf
ii#c*J<q
^Ag()E֤}ReC=Qd=\YJ ?QJDO>][
÷
bdߧ'(!/o!-nQ.ې7V9?EgnEO5W~7+L~'g7ŏ>]3 >b@-Og'ǣ+_Q~>!ETD`uA)y4HwX3LbUxyRY>Vmmx2VȷWOym0;-?e;X`OV@Q
SHx1/.|<	_`0@A1moz*%xuzq`P0Q=ze ܛ:|j	-bAdά;wN݂BuP1]$nAU?J<x#KԧrօjP*1 IgNY"Z(%@7ϟ[?D|%ݝ=d%rP[7AdLxf66Ý@o"A>gw;mu_rj!d٥wAT[4p	dPm/nǳA\M
Z ]{CaKgy
QQ"L)*O۟F}isH3s)<g\Gz4Sk;` w?tsӳ" ^*jqK*YsQx|(}*|LEM,~j4Tox^	$<<75xW҄_4z)rYzau
:@xA5w}.tǗP~JJv-2x?ܟ<>:[tT[.`#|%P~)\@u=/}0ui2 VD܏^Y3yCh:xôFpi/|焔
oըG`vn,	4x~=Mבs]PdMZk4G$
a!j\nsܸJi`d%H<
q*Ӎj^)X0I7+bׂΊ[]1böhcFu$vU)Go kodb\,q_6v769}wshbj(yʽ2naΠ%cm^VkklYA"W)Vڲ^G::vGo	UԴHϊ''XB%O}ؑaj,JBB6G'a]?i	{&^ %~2)#l!`^.C>QkΖ2w8OK[;EZ6=5~ (޺g,k68R+>y>.)B財
jnJRXz
CqOI
(nG~B<	$׊ *1_O+_FSZku
 bQJiҚEoVs8GX
󶒊<=
#ڴ7dv;-|]M֛JM{kϘw<m'}=~U~|n6FmΘ栲#0:lK1LRi_AvUG"^Tl #+$qSP//5mDc
MEII묘}]#&aՏȏwmՔLsl V:|%$XHDqPi#'VGLfyz6F]
}ƨ 4
qlHĆtʇhiUT#MϷgD:+I,܍VXiaJ\^mtrw_AbsFvk=j?gv{(i4YՋ.*7ʂs2>>adDEaNy>(<'j|؈&Eɺo~XfT^Ls=/@UQ3j5pg>`(Wyl>B0'|m/'1EeSWu;lD$W^)Q'yT'sReG
if^=hd+ܚz>[dyH4:j#*8+0~V~=k,5_ބ{탕ܛ|rkd4f>:HVkdmkqdn˶AfZ#q`W>*r!׬Ӥ7N6iX{!,+|IXbr`aɳ%H&!8ۂAV>ނs`~νޛԞS{ZŸ|ȹ9#"Q{܍y1TJve-4_nXL)enC8VE݆&Ğ[J1ʕ~k{'cRXE,.CG#L2(~7C;ԯdȜ/!%.F3̥nUpeu_k13T$`FX0bgw*.l!f<$V=hݲMxG
§eWNϦnpie>Iȍop¦}lfh,~I)Ήf)px1+)n"=,P(w{/pb@Їv#	`14$X}
)qIIʖѸq7g>B&V3y6 ܳ͆uҫP'S_&:1gzօ<nNy,ow;tL:أbWV T?dFUϣN2W73xu6s!p$H]˝()X!ep^{K^bZt"&始:C뇳L1ȫxNeLFuykJl*P=XR3LڦGPx#:10|oTZ#N࿕_$WnĕMj;#\Iɶp'zc)Owg x(r5}xƙv7|f_%٘-"<y@խHFBk^?윾 s(ͩvwɭCZ^,vs[9Y	$D;r*qZUB~sV˗WKKSL4k}f
V쾮D#^}c͸D
dc.aoJk-UA?C~MM41RoZ6y_C[_;f2CSXUx_nM2{X>.>3j-H˰GQzٷk	хhzr+2
ېP5.\KYND٥eCHzCfKݴ֤I`;sRs8Xt+w`ֻ:k@\_.~H_02$hGGJF\_>F{[90݁Lp<Ǘק(Yhd ԧ'$k2!GV5)Wb{Eˮ}vX,|BlFSҍa/8%dN-?ͻ&Z$s_#	Z_~-XR|r3::&<u)
.n̽sZzIG~*"[-QÒrP?|npKߐ\p%$	~{p	^>WO\^~$iZ.7"?stA,TK'YKEQ@t7NƓ<eNoV!JioCVp01ykuӛ4j*ae
$;D݊l//y~-:|e#1nM hnFUDkWH~"2e^<t-(T5(;w4#
w&C_oկDO:q}ʶձ~<i)-Xhr~}%;`3K߿+)6ʺ'҉4+^e~:~:=bJm{R['gC%4Ud}hv2Tc|/r`"1f4; z3P/<))kQôMo/|qz(Idqn[="O
)zNPu{6>5b[nXO'ESMغb7漘LPk\Ag F全e
EZID!?O^$=?(<m /b_ϊss){
rszq¿yGwmg)eX%t@Xs@75{)@W*S:̛߮&Ow$"ƽ8sdq:8

yPFLHwC3c-bwúTl;NeYt$˨^6-Fh8myܕJ;)kaRY4ĳ!;yy_<ƝmE 	z)VqE>U*%й[HʑI:?-tgK[gS<qOGXDg0"t4+6g)
7̪T1wB;[$D+Bq#Q/byX{M`^*caY(k{4sLͨwKJ)/l5"-q>\"*%</_=׫7k< A[垡
[{1v|4K8ZVh@Y܅LUE7u+b|e}Z5>V*%REǫ]vqe8xtsAK& oU7.7hrhf(Z06ťIjA0ƱRDBxK4_ߥkwy{˷p5 C
g.;uaDJA8PѦPPC'k1qCeGa{7"Hr5R^nwNOO[Y9rR}nJwb*	26Ԁ	>#]?"XX@Fؼ4ggrdHJajߺE0G].!}d;*栠ovPFKշcq?=PC'-2]wCp3c/OK+aX(w!+17Fvj`w͋pK/<65P|oiQνMuܛOjT~k^A+csT:C/GSM%~M._K8{90rUk?	t[9.cو.Bк}&3u!ެ!?Q >s]&n"jcfA;vs$<8렘P4ƪx9`D&biLVF%:2nVb!\޻jyOIԴaZ=]'H}3><*y~ZMU`ϯh4~qqsm:K<tYXI? N:o&1]tFyffn˦鹻ƾ.ǥeP[נ-C8<YųEa^S/%5=^CuGWgȹp5lםGI,mRwf0o;q_[j&C/}=6Xc$g+@yhoW_4V[9Jhƫz(0%=bkڷ֒
X"8Q7vߗs{Ĉuٱ7:^*9@Zrk(G>'A@dۚF㠞Mݔr{HQr˓;_ҷuڰ^+)DOXN"U0^xvA)/uvr'wUvs޳_z}Im3
iZ{޹;hjv7VRaW3_D蔦Ow=|rWYwK\$φ8͙9X-iiD(P#xTՉoXO>m%;HIYjXضcjb7F"V{EZ/>t%Nqq i0]*Xg$U$hTj 7[,![ڭvLg5FEqԪj'a#u̟->NG*>AneQeJWXD=!h~~P|WWs#!fn P?f ?x>fݫ$ $Tw[Z13TAynmsMN-BǾ|ĺ"Y(=zJv+xpмZm߻?r ?NŻoYjȾ"A.یJ04:Ua**ɤmp\˱. nshVEܘ-'Q>}{t.jsnbQ	XDFkT/G'otsBܴgJlQ
*Hf	;$wRFU~u/crT,$b45x07
}=HU#w^ԅ2[}#ۦj	U?Wc\Q$"A0˷ބgsA{qw)E
@N 5K+*B^2ZP69=c{^ǋH!E,{R)HI=taft@Fި!NVBE.Ru3.FU=<ELHz~qCIK"!z˛u1)XQ`ЊA(Tlyna<O<s|F'e,gK~;Xq5-NIþ6kef@J+u@g
kaMNPk0_IV6ytyTMc	+tܻ
+![Of(NT$S_"KcIc\	dy˵1uQT1ya
5,*屡;YMf)9mVM@?nYy׻ltٓYZlXINnNg|IV^}Td؄
cHb[єgᇛ	-Y!5l ZÆʺD`.׼Q<Gni\*2cJN n:-E0+Wy`fg}9(kh9`"nL:\3;	
1CE4<Pi4[eEڀoWٰrAqd"b"G܈Y6,eHT{x\8Ȭ^f`Gػ}Ci;dhW&|r㹁:5etvGX׳@X_ga!F"uU2S{SpݐAuf<

 5Eģsx[LZ)c -|]=>])w>S:*S-+R-NTjN3Q0P[v<bdj0(Gר[{.bqyAϑojolT`!9H D͟J&NJKoL&/-g5rUc+x8:B2nh>Ǻ{hx^ZFu@.
2'p sGk^YAmB-FznKW΁f:qJy|tm"7كWUJd7ykR/MSTJGYPr*rD
5PMБ`Q:mC m۶N{{gWyp2W:;O׭9cCG(Lz50؛n m_*#Q&̿/)Vf:'4<$5T?EnݔPT߫8.;\Uh(l'+كOtPc&$N;z]Cr@5l=rMcwHZ"=9VI))=9ܢ|jl5ߔǪnT4 ˔
n0S%(6vw0omFmmvY'ްz;f;fG{̔.=VQw_-
ʣF3ٯσ)r:gT)k%rm8HՏ9:n>F0IU.ZiA$2IgjbJZw KqayuCo7XQ[ñŲbY"AyOƪFHn.d-OFZl	9
)89Gf&j3@x˥)l"dh%÷|	fޅ\Z	s3զ&n+
0L$Cz`g"=γ){	ҟQFZMQB
I-tliq/9p:N0i'8g5o>ǏFn/ڶćHKih/e+88JwyP^^;_wĄ0Dte PhmCVNh@ɓpL)UXD7m;AT2w6YOL[>BU-8c|S w/#l1]A-_4!LR	GoKH^|KN{&6қzMs<[hr|n<4g9>]ʮK'T4S1yJXF!Hoy$b6
QfJjdٙpYN&]?	BCIUrEp#yeWEu/8~enllu6Ky!/Y,0Ye/Dlefx=\ת#Žim(lY63P1{>glst%z\0@Hܦ'w:n;5qf[8վK%t{=)B T;&Izl8+&
<A
ے]6(R5SZO'W;֑utqY\MMIZg$x4,RqbWMݴ#g)rA%a$۞Ǩ뮪b|]Խ֗&՜dt/$j{'ȸX=j `/oPax>Ȩ[|~SJ{B64f?mIQgqflIƘ(Na&6^'2A8s8_G5k|-k=3Mץ5NuTJp;&;,>mCZ-{w+v|p{@l(hYڴ:{]]n6nJ=G _g,>â$osFgL\lnn͗?o[J'_Ʉ)M`lz¯&6/`ǚdtßG2Q(.Ac11Zl9Uj%ii9ꄢXr<g*^cܰU\^S
eXubƅAa5
S
o޲mj0R_ co{{(Q2_#hu;\3rL}.\-C`GpFRNs]XF.0=ӽLh+}%j.ҽsl21<
x-Ƅ+argO]Beʡ
ryc?:&y	v'hɱPԳJ>}<:?8}vq#겧ΡIxy'[X3TY"9Hm[%@cWN-aO}ߧJV#$Fp";9_tH1o+Yiֻ9ɮ/oNo"X|{zqǥw]CYB:?Fy_#.ʙUǸp`,fk	
O`e[lgnˍSF_,Ŕ]~.1mTY}-G(iyA7I^3l"GSt|FID^(ՐX!TV{ao!=A`O/=mH)#X!zn*qoȲNܴ(	d%Q>0K !ӫή&	UnYwګܔS<Mww@?F?J	yhՠn"VU>t5ڝHRve:ZOWҮ;8}XoŴdG$x6/}]^FۤGp}z}t;r{ՍIÛ/f'^5՗Sz\6)ah#ֽ\Q:r$fkP꿸
6RHm_>OjսHގ=/鮐\ˣ~yNayJONtG,5g֟<n:ld]F)WHL-D-F3*_l =̣iU*h@B<f{L&Yyk$*		xB}0*5$D=6UtS̙@>&	.HYbQ7 XÍ
/` j.:$Pc ]nÜit`'F}'#Lku>uKGy~,z+?#&32vI!r=t.ѤgvzYl%lhb2UlZ6iˎ>6TL

	Vyi׉OjZlM`t@չ!g/gl5&$cz .pwcDE?,7җr^Jxt
$o	:&@aS>	.AsEyd
dڝ+4h
DEύq'%Ț+ NEO^86q
+	pɉG5=B`8
c萡X3o;C<:"l?C̄fd83A==}!VT}$p؜$}OVE|?ӑ&:s0hG!SaDlkNV<jI!nT/{Q1||mjnUwy!^MY즦sh6`?ݼί&yit![LY2dT'ZpM<yhNԅ.?AhyYmbrȷ,x)NϪCT8fzxփ_jgO<
]a*K	@"_(1Rx};	K+rPCHD]\~lꪏ;.V@R}7	M+KNԬg6}A@sɬ=*0($zE)<XkWX̠Kۯ	z-UEY_5%J3@mҮGj?MFBr-D*)Km
LH=I9CϸXpҐ=xzp+?xIHwrEF¼^Oy&0>\qE}cDI|c o#+Hu3LFRl&R
k1)Gvؚ'q"P(KxcO/$ޮ	jY]H0&-N*.L^L?Qݺj~FuPMv/*od*VY)mT$M+zZߝ=c{I]G5vm`ڃ	Y/.Ȟxx%&xc leH!J\aIUj$d0^b]wc DwE@!J<{NYsѶT=M%DMZ/]yal9V19vffXs̻;ЇEC'>LX6×#:0VwuuS+v(ݚ\v/M!VaR<!ɞ@~SPFs'nM3,)s	,0 <%}į#/Yp	Ғ Y-7Ve4)71YV&/aJ)%c{  VܮSo}p38*'`\iAF2mdVwy74BGSi^`'ב"l"Z0M|9um=Jmilb_qC_ЋKJe96n]e՗QhFz]k8muwɽ
V*\7mEyT%o]"#׿`5e( `N)	&=U|5|LG
Fh6}P|`ouWy5}ȯo:im&YLd-!uQ&90,,D)}~J^oT`M%^Jƨ&4yC{k'^2!)r	k>i1?Uӯw&&+AAAta(bAHKU$.-EME7 -ULT*$䬚
2	rDw&Pr4{lgk6j%˿vq|Bx^a׉=
p7*\c!	l u-V]eÖUL*'Ee]
&~ܯA8;mVwA
[Q
PbNta$	:@KT1ۻ~1eΨǚxiyNm0؍mc4MiTx{\.:>?k?Φ(a]EJ=<L'T%_ K3bvՍԔx/¼ݖa*_5*1&",׵rv0=|.GI^=T9<עPƆn6i҈yi	fiKK-4)AȜM4<0V\	jй
\?o3a*7o7xF0}4%2LHyCFxB?
?MLce?)k].nk
z>1xMv/A-Ȁ
s+i<p`Kn懾
FPD
(ޫ	h%	M]rG$Ф~9\9d
eNi%iI/?'$`OkS UQO~$Qg<//§\ھeu;ˏ~oVʢI05N  㖜F k%hJrC
r`?BQuJh3
ڏE35$BqOWJk٬CK
lXm&b1bmFZ=qsҝ0]o.`Jih#~qv,la2,`01{)q(Ĭ˘vEEuu#gv Tqߚhpy?[[mv@R8MܵJ"ſlg{fF0]$O oWkچ@6'}&,L
]d~.a6\V$X] +rT})3$D2<[GQEN&iyjn!_ŦZU.yy5<6+_.ϵIT.0#.so5M߇b] 7dђ?ӤܥFlͪ:u)=ֿ&{pW>\5f RӔqT
aIQI򄔾/c
z>5EP".@A@	^̀І
Fƅ2ZOQ83Jaxw
I~6dOxl+}bדfjCRB=)^1 (o
"Lъ"eSՀڛ'C,D-" b>F=++EM{=؟/Ꚍn.ysVG-ⲙ7_Xѷ?팸z$$Tf_Zg7SW!)ēLhrû2y0&*+ΐhT,PJ;qG873<ߖoil 3"M{ )yXD9޴ƻ;2B
Q
xQ%m?̴ͧb	zCMw͆Q|&G[<Vwϭ=죇Uk~3<H)1n)a«GbmTً.0޵Kཿ7hf6p!&\夓iG
}z%<M
	wvR˦"X\IY#F\ Vo3r	t`{g39x.9f0<>6J7άS)X$FϨJ
#a^ￓ}!绱PY^g7'{&(<7 s]\ykc\}6Az떬UMɛLd aĉHƄPGL=5U%RqRԔ]DdU~N.ړ{,-ԯvH΃R-fꞣ+dWtA긧\'wƎA6"Ep$0qv	1xkܥ	}%Kx	ńtڝv7 !S
"D3A'g,O^ĄC}vv5L
ŸP#cN_+i[Սw!/]*/%#t)\(7nQr1݈L&Ak_(,ކG}&ē B)zdYQeX,R<m7%!0&KrB3f8HI贕%ޅn*_g`cPS[<*PvCuǭӬHRD?RQQ#[}v>C)i=kTyS\$b/4o7Vsxۓ+o%6?3Rh)?!<S,jZnX
:rHMWW̝;Y!WxA46杭>IFA${)_'9 X9#5_nV@"!M^FM^)/&ZWScEi {!DeTa1H}j:$=2:ey*Wz5`=HaZA7nq;~8lDVx UW^H@Jep
Ȩ_;|YҴ@MsCiKrW%#_ꅺh: %u 1VX#,W?\eo@GBƿݴJ^adUEޭ
Mng*:C,Hs0߉Q$	DU`meeլFg15EWږW=$^sj9єbRGZLktǫ*9s: oxKD̏DB1dMyqq10eja7Kygf=lT
G#H88ܟ u!Ǹb)ghW#EA"Lyyz{1.-v9`Ǜ{-<}Yx"RNNI!迶10lbef?NN~zoKdL)nXl?GfوZ%Y>	\"d\:k~g$UfSx;4Cx >ʢs9xyVTO$[V?77@Wv=}&mƇHьΡug;?iI㦸n~;&wF%E
KQUaQGog|L%QD>wtJ
cVxO*mOBNv6B4P|e/,w
\2tgI^
#/HKӯ+
Ϡ5\/US>G6.l
Wėh)I{K3:T&%(O`k3lBTE0RYmb]4lJwP|P{;YrU-F)!ܽhL	~;ԫK+vQ of0O8kz:Crydqn"ܢszp3/<SɅ.nB;9l=GՒ/{V
fG{6k[Ne)~D.m)Aǳ'UߡVś[)L顺`N|qq9>wyrM%i؞o?dOW ;?lNO7g/
_rjYlǋ&+G åv*VTQTLƬ̃Ǥ%4 zXRyF%g8i
c\:UQE3Rꈼ
2#Asy+>	yt&&Hf]:cZcдm`<Dv~hL٨^˘Z,7-H>"%\k.}(rmiLwxMĺC#.𝑨&wS>"lӖ^6Xr^&2.:dr7RG51,Os{ݼyԞ߈MPtI
ꬽjmjPr1v0œ~DtZp[F5ϱ8uNu]\5Gnuv|ek<JzVv4|inLCͦ-Fe$jKŹ/5#	-6
e
+3˴y~Whn);h=};;o_0_7/4~B*7uAƵ?u1dP(~8[}
zpJI1ґ;;[F$Z)jK+/%,_!I[n)b23r\n<m5eI4w"S
v'!f^R(_d^׷); TeaIU%"KЯ\$.p3'ܓ/nnPz<:DQ75o]N&픃=}&E4su&st&UPKCj9uB`|^{O[C3Ml?cM6l:7Dv#{xuMg?}))$x޶
辨r"~45QE<pIJEfg7ցcY;f@r7vUVǀXC!/"JuACXɂۖ"F>(]Tody	}aR,dYxXzp%ҰQrP,COϚ2!oƓU5XbѲ
b$aJǿ[~:yνo߆X1>"͝kx]9њT?T:r_M茨SΚֆXi!zn4w/cT.{
W
TӅ9)t	U5cB6!QGmݔlPXNyz]{o28|jnͼ=TNZ^8k<JƿrPMiţ-~ZS*VN&VUfZg`F}g
kO1ssIMԭ>[c%2iݫg	}DCcnqcfB7ZZ̬"=ڬ6$7TqnGr!nC=A`0K£D`c+e˰\(l($./Rxٜ<=|j[She^f)qԑ
(\z!/m\MG{nYd`BĭEx|.pg&IIQԂGyb;*m~bdE[:h
%IS^8GBBǮb1f\D!e6,;.F.o5A
+yh2 	z(uJd7+y(k'22~hm<\`f 	3JTJ)	C
-ӬZ+ĬLAY7|Xa=<:>|<04R5Z?PDZ.noۑ>V# 2[eL!#WC[ +>MY*ʣVxdn/
Q_*:wB/'!-8RrNVdp`Kb>kI|Q˭O1-6RjQ:BxHҨlݳAwβc% MlR uQy3"r^{OC@55.MX@'l{c$ȇ3T뾂FR+̎g8Egc7/G[~J5qh(⦊*ٴ>Ex9?/pIػ$kXbMZ:|A%De5}e?naEab:LE9O\ZJu-0F,'N!	w47͊ 79-]5Q*&A2	ܡU%ɱzۮ^]kXv\1RݓXԛK-
C̚KH\z9W|wv~Jq4?a~Ft">.EP0HsAe|Ͳ
KF$D.\F|imb;Nz-s2!V3o6{?z@:1cD|*C5(f,%K, 1Syv0qvKx.iSj}vD
~F*LsL5_Je@|>ՏT<0ЯtV=>
OVӢ$l"MGWy񠱫
10ە^c" 8'Ի%PNgk"IL\Y߻aFߨKI$=u469s ކjť=EyaY
R_BݦO \	n(j啷FB:7v;MPڣ%*6ņP	(5!2<ԺΊ2gv	3&ъ%/Ilɖ;MŁ#x4] ($Y`嗳wt9N[).źePKYڈi/nlwF,r
/^F>F1	LZk֊ lW2_g%* 5p!t)u+Nf"slG,[kT:~$ȕnϺVB64bFU|CB
_0=>
#ȪDgA> o,ԺP1O$QW]ܴ[?/d#H,MHфr-vYcȌ8bc#1A׭g_z~ۏM0M+<WGDNJ5=}1KC^%VfXxe}Y<7	%ъ!HB$TE4'p[[۱ED4G%28ٮpj	[KLeUx>!dÏ-Ou1nF]	SePE4ջ=-d'볫.~jnCvq.D%ޑT#>8ENJ1Q>280
GI.:]ӷɽ* WL?:%i|l**ܳ}(󇌎k"Jꘆ*sJgNdk,yYFZyԉj_
n<܎iO'	ki?[jԟuNLMXiw7"FfKIIit6W "'
 WU\N߬Hv{]Ǣ&
uCm`yup@xMFw5CY兹}md%<S(c]v)xl̨X-NHһzno6o4~(TV/nwckmERT^U
<iq\RN`Z3/D8%AZ!J3_<z
O]iB1!x
mHOH8Rc-8B.Dk5qe z6bPo4Qh#DS;f{t:_@X-cԍ˚Gcn>ԀnկGn`t}XBvebZN}Y[NEÎ̕}5m{X;%l}L}3TсEL~+.đWceҶ 0,?K`,r#/50NL5%e*?^I?gxVu9v"j1uic/G馑{:K5֣{U~& D||S+owd.ohP
 {Wp1.@hM#vø=?"|7m
D}ogvuv$(#bX<#@(B)웪\! Ux!yDkvzI61׀~p&gjźհH3lmqcZPA.|w?91[)(yhv*caSDky^\gj{BJ׮o'\NlꚅH=A9&de|!o!b=.QG?DbC]nf0(mqȣ쯱J[k&n֪bC?ZHBE='Bf&Q*5>7㣘F-zb?"LRIV>/C|C$[lj.F"P#j Me1jBᐊv(bFcFgg\<#-pv5:k?Y!%B@(f{`$
E7	Onޒg7d?~ջwJE:@;#̧6 /~Dt,]2.`*p"RwǞ/lm*pM۽F*??|<:}K;	h0e7QY%<u@t}jLzGݣgޢLN8WZ)m<+?^׳MDTd }9/gĿ)eh>{A헖կW	iD#swncE܉P$p`>V
tuʍ@h~	׍$aΠ:ό'=2E
3TL4{'68<0qbz%6ŮLKlegN./}|uyI/~pOg{X~/'/^ǎvK">Hu"<G\5A1Q׵IxnA@"[m҃5@\;!51Qg@ARUP^by n#$4](w6,3gtj~i&	0};5.'F>CM6h@˶n$Xh'Cjw}Df&b;)S:s8H\c4MWvE=환=:LqF[Ēυ%JFPaV!QI&nt;TLD+O1CΊ@ơ*R_U,lƊ{%}DZ	n{kج^Ks>*D99xa/èRYfܴvm4S6VRo?^EpTpBv|a"pg܊J;c鵫܀VOժD<:Kiiƻ[속]bnpz򗮗]8qͽ!C=:kb­rRFwg*X796)Jh{Jf"_~o&XL0^??NXqSH7`E9\ ۅ	cj6VIN`&p8{&JEUDrK~./s{qY9tдX3ZH95`'u4h=bt<e1~o(y~0,6HhF̋r!Bmn[Pa0|ѕ̚FH+q}aur\'}B&^"U2i
XwpFWLhZ zT;.Ѳؗ߁yJ6>DYE}IӳeQc| o[-6{Jmc\ܥD\<ׯmDO9xKA}1߁rEcb]6UVP$hpǍ#P#Obǿ.S}E3KrSw	.RֵρKXJS6¿"=LmwZYƶB͚L
x֏ExtCh %.A%e~Şynz±Å)QrEa[4O5uxR[o/*sdwkLRSSq2ǞTrv4utl]ܐNW}ݼ
JG/5pT9[ղ
t[ǓovJPiE?~zA,*A|	ڼP
dM3<&QA
p9d=!둼.`n*<ZcP;CbLa`ȡ&i<[ |>ܧnsb]4Yv@nkU\WJJz",u=Lxn2%G
"K68-~j$[_tf
asnt##jX#ݻdZGnT!RYE
qt$Z2-5.Y,Z8ksQHM>X:qE[^K=" "9	!!TV?I٦$OMЫ&N0w|ܿa<Ǔw(62H
[;>ol$aMJZ6Jٞ={3daG^Gq`",@I_T)Z+r{1NóOܛxF/
PMS%fscV!4MjuP)	YCNƥZ}iBYIۺQȇx嶷}=OaA P+25u{*FW6bD tV)Den~-9l"?5k!CDy`}3TחX!B5T%,_0ٝ_oZsBaWTd/k_
㣋wys]rwnBQ̺p +.Z[&(My=J}mUL
E
K@?ͨ7۝ 1;leT?/h
mu7-q{R3bV`ZFl,V_eBJX|,GDUH>?3xtu4-lxQ:3uJފЉ얒ٌCh,IK弟-2ŕV0tnyM+MXVJVwԔkt0Pis}?Xt4.6'0i۽w[WS+0Ay7
~Kqq{L9Ah?p=0NU~[8 f9`Q8Y~iaCg3v|N! a⧲YOS4/?#{_4لV3uNRa,YY߭Zֻ?P afU=89L$Z3|۫NTT@gjY-oH2WYqq?_{ٳgz瞉].Y%"Hx᭒PMM4RW&RGr HCWPNj 2/|D/	gsR
}ڰ\)-79Kfs7lk'Y-Z*&H"oMuW}jU33aA@X <bM7]>\mH UQL=h4T@IKJՃ@oAc{%FRH[끕1w },kKbxա5F^V5p,MWu ,9u6)DTWqG\2E{uxAT|2m*wH+F -c`v*a"(|h]ThR<n6<5|̈́!LA/M\S/l	M(/ZPajM*iJ7k\rꏵ'0vz&r~BWR{=HG03G<߰xPP@QhG VaˋEɆ.jH;=y7/Ibx;0Nb}"x$vsp(&\3<6,깧2~'~f9>.B\-? 75
0

}h,Q=mi#>w+Fˏ%"y~˳vf
hP#|7y_"FwP̽%$-lB]'Vo?,ETt <Kvl؋n;x(Wpxb4Qډ5
K`1LtBE]@J
) $p4t5Wb{|F[i=-QV&RKU1X,Zhhcj4Ct'2䔫21q1]ɺtp&*EB]prvݍ^cN[U}7pn Od\/bRe Ñ~Qi
hbէ7|w3ӉWg0gSG|c_ )_;YHBR].w<h_R;N͒Kz.CzҦ1Ev"E@ʊ=@ΓZ|)хbWsV}~oKtCX
H8b 7Z	=cR^G!45f1Olw 9.OG?=?]^gγ#-&丂
 ?7aIMCEًEݝ!n\.^@ji)`[kE/|NXzqWׂu|Büވs!&CupLHܭOEoը	ak`A&>^Pg_Ktxf@pj]|/6՝kƈ5el]4&>Ę^l7c/s
B=Y'8
WMCژTt1LAsP)Th]wQ wR7p
,2
ZsOt=FZ̹f7yMұW_#Ih\5W,{p՛ݶj%ku}ңpܛuCry%,-5ESX4"`jKl%l@Sc<Ww*ڶ[[#s,:[[m#&1f2+y=x{b="!'͏?{y*_n*k2mnG٠AhS4N;
X
#]
3/ϯ)Ŏ2M};7GKV3H7yܵVUs4PkIE.V܋ ?\\ȯ/65,
xGAw!0x9fY<d;;F9s]"m2K$*鲂 tx"T7u!֨|-dRuwEkT7,&^.hX!zF
	 &DeTc#"ڗB*'猔8&Oluw{_+AG?^Ԑ9-2qjɅ"iMH+dUUq+]SF-	Fo-[gV[oquET))4:ĀnQCa?r6Aof&Ya;J=+4JwNbB[	9fb!Mv/.gDA_Vu?dYN3x>SkC<fI>x(#mee:
묉[!r.Vb?d0k "Rۜ"]t3Lعѝ,pz	.s庞rcؔnf
fu]*Eӊti(ߋB?tZMB*>Awd}l|[JbXkx#˰j
!4*@G&x7cn(8,B`XsS&%zQ,zx5`:"QQ7nN՛-vdGX+.X|N:fzKPt~ 
H`E3RגtK&,X?*,2~lRf[WB4O8o,i{p L4Hz%<SM;HBZ93)%f!b$Y뱧z,U%Ͻ׊n!_f,xwD\P馘/B
Lw/t!^:C/lyDkrΩy<[	TN7.]*-d1Ž.' =&HBw5/M4SK(${tDML1yy=J:Id׀Ȫ)e1h\KokPvZhisfbq'Q'l L$IrG]fx^N<h_DF#kxѽtrjN(5ߌ?X翇I-&hStDRE= UrHb8
){qk\٭nӣaQRI/utG+`:;cImTTgqպE6ωb\e&?j9}Zڝ`fcJ}l7_u;1IjYK\_qwBɲN/~ǫ,KL0:0pj%7Si}
bj(<Fgҭx,jR@7F"\{nnR
ws}1	+=Ƈf:ď&Bk/Z\ܕDFY@N+n,#jcT"B*HG[Y%rueC@k$~:]dfl.Rsu|^	;yږ[7ZȂ&2|6ԫUaq	纾,D)2"k5&腩H9aKł 
 pGv%}rˈ!3qQtPsҳJYCur_gT9{#n*B##/( ;	/ۭ~_8zm_kuي#~~TBJ v:pӕ֣,W+_eò,,	L/Ē/lu&N1)HY
֭ VO_-<Vqĕ .>T%Gc7{9e+gA^ٴfNXS0.
,
lS+V7(\66^O7+|	?Wg۳tybky1Jz~
O=Pf.8$q 
u@FME+Qvܑ|[YUti֥oԌ]\EaL>aL:H'QCj}p7J]p~EiE^kJAjRP5&ڤP:,&frąv<U A#f*n=);QAD~$ݛfm5H,]AھUeV.
hnYƬ띺ыTvj-qjHi@AO <		Yڤ3E`S@NvSU0^Oq7-6m#X842D:
_\kCq<R@1t&
&w8u"
egnWx沠ǰ*6s[lPwb%#>(#"(<^1+`M9,Y2yAsdO#ҲM5]ꏑeOa|SAkjO	mkĤ:?3Ĳn螎 QYt!$HZ
n&KrǬuskm˽
4>`VV(AiMcOLK s1q	~2+aIg8-$lT+p%}g]]nG'G?̈Y6rBW{rE/jɐ=lO5)v-.`дDdICdӴI(&S3JΑy<,".N"]d	oO~{"(d5ޙtVisYJ/+AhNt~vTov1x`W`7q*Fr^D#3/-]*4U$Rr8cJ3#1Y)D)GSᗄNjd04bPW?Nf?"*%!00Y`7c=<-0*x@hBCQ0	̢l"rnRY9+}[G++2:TچncK}ϕ=/ÑLGrQK̺J89.&[ѻ\Cѕ0`Oy
}vR~ᝋLPRЪeffF$m|bL+ײe`0)<vK287s<> nXAƐ%}H, ,i.9F&JrOQ`te=	Nܟ!kuD6Heȯ~::?95Bw:x<=PM%=k
^$5ksLgWWח7w8mtʍ(:<|JB,\[|ns^mfӋw|xoq}znϼ/ 7sA}>$T{hC9,u	&eg=i~ys2AlEXo;6v[ݙay'2#P6D^E}{L_塃sr+%+X=~ب8,?7&.D-ݧ#Xwh}
s14pr^ڽMGRW_XqxօX zdx;Ar'^r)s'=$qEG+u(GLϱ?b99IfsmF(5-nu&3Jb+M}!wD%xw30CM}0.R0*1`c5ЕOkTTw}܍K#IWƥhfbm썑{⿕䖊}GVܝ!.+xr6F"JF_7
[mձ;cK!! ϙ!PX믑O.\eSq\ƌ^UpcDm
QwQu"3I5\k:n7h|LL9P}麱ITcXP-VJa~&(dZ7~aF>uhr"b}(!,$EUĈJu#8ERs)[{@Okzscga(*=Z֥ ))֠px[qȔзڭxCw%]-rZ
o݈{&VHWFtq|
	YIs+{ ˷u.&:u68+7-(t=&(ŵ0{'tt.<wnˋS	g1VHC3"ZyLS' 9T5p*:A>m'z:\׷5htItio $BX8\/F/pxLL)4WDluMǪuxRpU0xcWQ=6T؃)з`+u0,h>CՂ5C.Ch|Kk4__:7Pgwг˷hx+i:5{1jA\xQr+Z<V>G3&Atv6;V@ܛcqd>gc TA iyy)q
:/lj}K$9esD<mR&[ݚzG |j.+14(k2zW9Q_)&$8lmm15ϭ\?a<Sch[`)U[s_ן+k9F/d:
c_I%L2]5939^+h76?1ո?rT?<B<̕x4|!R#2&\YnApoWQ?
J)Tt5l\oPPAk~eғ^E5\ވTO$\ѱJٔW r56QoDq(csaƏR$},QPz^ ĢXw7[^ڨ[ꋗ)̋-$'vҳXN2dXVJӨ&1`?X-ѓZ
-RUfE;Oum]:'$:]Tzݘ"n4nDZpFA.Ov:NӖvx{*dSCّ\ޱ"'b0l8j6A^ZD+67>@0	 3OPf7+K^Ӡz3_uH]IHxAɷ|i[>4'AzI=\~vg*==@j>Usg'$.lIv}8%^qNe;iE)T۪G0 0BʻG,4ioq`f~QPOM˵{.;bn;4_jƋT(I~=
"\_y|e2`5"}Hv7r6
	 L>{)KB]N5zL}:
OObK߇^v>$mt4k!];l#H2Z6J
<̛	HhIfTm7Wt"S
+'=rh}E$e֡4ןerj>Wv,jZRHJ\?ʀ8;~/t0PC]ݕ}<ɳyXXžz[XZ
!Svꬱׅ՗Fʶ-S|li垛4	Ԙw3yBEEg~3mwk!(b^pAmp%חzǣ_Xp2)9JK&ldaDZn.c,*FCSf{z'X,6ًikC`Y(ȌvlލId|m7a]ގ6Sr5@	Z=/IKWGF-r$V^ pЉ-0´1"l^i"]WgOs1	cS\3VI8=~B~ySԘuA7ex=o"N	
0ezvS=M$fu+ٗMA^nLtxyW=]\Ž6t~8_<uLJY~*־B'Vϭ2;{IVAplV->!][67;Ѡѽ"ň!	Jngj8)bdk[;F"#X䌸r/Yp'hDJ:U]IYK?qW!llj@z=zgsw3K{bWA-yCI134Săқۆf[*4RQ>|5魭-ԶOD*gj(oe52[9`,\qZ
Bs(w6NH0ߍzj;=88hQ6jLJsP<f* Vh
u_UsIvZf
RV%B#;ĻWܻFg.j\DB67i k1j{1ǣc`K` 2>#F9aתG8&RBwǂ DC
3P=/9-}At3.I8
?/ɽh@:O;c1~RsTSf!yh1#t
f#iMr_2U[{󿽊zM9]K=O+M9|h.0)B>%*$L0mom߮%ңFv6mq
zwn)bQ3%If1
0M74s¬5Vy(݇;ą0
O
`usMnިzXufe=r![.#w]X ӭˆ1;+)ZnIyI`Be!q"qbAڊSyy6kT@ā0z0bx<6R]D'ey;a#i(?f[=>l
1y sn.N݀oc4!\4Sd1
v{t3K^Ɨ:oPZmCA<9R6;&Ђ
KA^w[d]AVkѢ
g>mT~FK[]p+߅6Tݴ:`z%x谻4vRVrulP:+@&J[n*n*v;{277
ڈ5ҷ16َnjX7n6}O3eq5y^X%W/^AVEC;~$b?nX3SooV R[x'x/-I]55b1F:&7q.˞ϱ: L;=/)ĒV3Ѭj)U~XjA@>1c8zAT15
޹t5MPzArh\iŔgMA\nǢy*iQgLA Um	^W:/<7@t~WIW ֙4bI-x-+鎸Y:w?)A9}ݍTݛcJJqOm@Og6"{3"]f\s SHaUKPDAdd䤍'
Hw#qXJ]YǑx>ciNؔ3IիY
r>Ҙk+yu_
t;
{ovT
K">WVH ³*n65$k5YM7,a{k9&i7dE"ov`
ZPFלi,aB9ڦFUs]Qpej\D
\7ns|[SY$IC 1HpGU	Y_2.W /gP:;s$
)
ˉ9F[tQn{72 c
ؽ7|,VuS
=﬘`8^OyXd6;/x>@%ۋÛ0
$0IKL|7}5܂+c$E 7qB4MD_MLbC
<*3YF#B_g$"Nʩ$
HȞ3AtO> j#P=KIZхVB
̹jWJX|ȽG	vPݸsS$	bwX
_)vCg0s`#}M+A$PS%OF-3@rQdi`y68Rax:+;k.ez3](RٴTI-:z/"ϱ`F
ǈb4icM&g5;;$+$@n&j!^%w;/ݵh(
x@WGW-?T.;^H
ǝmYpenвCJowLoL@SVS8cz=#Y_^Tb
-V
tNߵ΅\(U@o>+VSd)˫Yi˳ӛopy63TG!e({M%J"JiA(ouxܞ((nCMƃFA9m
GO2߸d/1 W8x MM&D}jEB}>LQs(VRM}7?]B~M*y+	84`pz~~Izz[v.BM}TǞIXOb3g^i{K4Z/c1{ܬ=+QvhT^ܜ|^Frdz+F"}a-[íd2
 !p_:7bbժ($9;%.gR?h}e1!bOb1u,i]ڶ%3)5Le'm#WmDSVt o._-:y%(EDHм>KB;OxlD4q2moDj<&V9iFpBKV&ڀ+Z=7IŌTRx\[	}`ӞdSZs?j\֖lBra?v1w^i}A_!`DK9x0֠:{	Od~Nr˓
][
ꆶ4S{
I=pur`ֻT/`4NvpܟlR${
mc6|\'Pu.~	?>?
Zf"͂;{ˉ.
nƣtvf\,і݋%'Cp]u=lDt"غˮ5v
TEVA.63|Ef<p>{-uAiK[maTNA>a#K̫5Э'PO6
'vaWZXpA;=xY{qآIzB+4ͺ[ptY·Pd<8퓚
k-YJ*=}Ǡmo췽z>q{Ģ}_ҋ.l/|Jn
mfw}ɣϐQܟeޛJYVI⫺p&p׃K|~hklo0C/3G$ R~S䡮N	5DS&,Ui	=QsMcldbq 歨]+"_iQjE`Vk)*S4ur:i5}
T@Nޝ`?96W-sx#'i(>t96i|4V~]yei܂d#;?K`B,Կ9]!5{CzJ[X&I8'GM=,S`F2T&VifHSI0w$~4*vtl|Ɂ&mD')ㆸ?lg<]{l9DŇEK$TUKa}K75B{3A%kSߠdSΫ787n´Ivvg[QC4<Gn"= x[{{	贷}76nrbl}X'p|?g2]Oҋb$rg8ܢr3:_=;xjdx*EyE{2dZPEZ+1#jɜDOR7m<Vd,1;p#j\+7rpV8Hv_
RS
\nlkeԾS.I0^wƍ0ġV@; =z_Jނ=2L$;`i+A9rG\	kǢ8M e_j잚</CEF= 9[
`[/c8 4դfVy^dx|آF)Y#Jr%*7nkr	B?/	g# $ԔV˙$'4W%NԘ.@sob:}]0 ,(SWrko9pt䕎M50\ԓEU=gG14Xp綡JbjJ=_;&!6#,B܋ȇKMqsRoX/akqIb|,y714,	xW 04Z`Q;ȓǞRIT-	ܼL_#K['_0a?TLCR`R"Ap^\,93܍ifeg{s+;|޲ܱxckվ9
-Z%
9Ǹ:SSnr`y(F$X] Ǹn:*Ҍ#=2,bDey~U \䚦ESI2$FSK̝]RL3i[dY4=/:!/9Q2ڟf&E6ߤ\ 0QHO.ALР8La _NC7!6Pr0^ۡx(S;@x~@cTF8/Jl
7=O?30kWegKn/co?2P~Ύm"EɂKk(M6FtȢ$+o%NsnoUB6ہ[&y|$>=>S;-qY 3alE=6~ypΝz&
ȉ[E<?:ήn>d7s
]їGר61v{$<TV\a4>qH
uA7ssfCLxHG61	H%猍vڒ9=fq
kj9<i* 
A7S_zy/!s86ƨ>ó`-5BhF
(oT
s7ۮ.Չeݏ^XUQ/r0M".=By=q% BˁLUT3	!9mI ZzѣYU
B3yP5ڈ{q\[Hs/j8WA_v)"4]r|Ok[]<FrD.v+̸V+/c: ׆"2mzEN빞)-]T
e
cR(^Q|ȝņmWl[׷$8Nkp6QR
f**D+nlkwಡvѬ#kI30:dh&("@p25ݤ MLQB˔\87}$É*Z9`5s.N)$A\[_O}WIEاm6 kp	ÃzdV(ZKFN ^6lF&bƏ'mYnJLH랹YޞhGZ~n[[z?*7v6XvceK%_37Abq7ɩV>l[R9H=Ԕ6jB(myW`BD"V\Zg\<@KP#ؼҔgHh5"<6Mt)cQ1Yxe3B
_~aʱ>F\lD)P.xNSuAOut=r;AwiQ 8BvS431V
=Kx8^[զݡ$nCS,-Agv*vGg[uA^/:6㧁
aMMPVeOThJG"%;imO?29FW&ȋYrW^wnNaХu'ɠKbYIPn-=4:
.SP&fbTYETO3=CQ.SE|{Z~gCT)}M$$D0V2D.gPX{4vD[Xѹm%3 9(ф,dÛ1s>y.W^|#WX
y{tB٦'#NlY6lӘy`b6"T=Q9) =<{[4 MuxǙ:4CiwG[u['WW[\S!gp%ȑYD2||B$b{@إUlf8F[D#羲mU<g
iήlVėwbx&ڙy"ɡWOdikjwa!hH˧ZL'G&fj/D*ބɫcMp騖z|5ÛFuB,xv|͚*/ዙ0>:u3QB+G2?H
YL;>
яDR%77"i$X/J
^=;J݌<ZkW|Ȉ<_x?)VAzu:])t$
\KDqe:ss
H@Ɲ 
ΝzKeؤ㱵eh6H3:y{鴈i-B\ESӘX?_o	vMv,KjL,Q=?7X<hGm
uxc֞'(Sʎʙu*aK
d尔'ܺ`cj$1#0zb3UόUBA]a wӉ^2[$3&ڦu\<ţ |
F%U"ZEWe'Jrvf? DLjTԳ}
»e;﫹iHGNMwws!èAb'ptr)P]v:`Om
;U0I}$|oDƻ֨O3# /"/݈J/\
*R""!aGi${V[ynWc[*6 `X!LE~,ZN](Ԟ]ez׹y ːO
&8U_Xng.%XEy>%O{k?Doz+o;N*33xC>"Gz 2e'r6D'&bp݂&
i"QjJ43		EI!e҈f$"
7~'UYgT9>r~Y$HP]l9JxN6ӎ⋋`FnzR/oW(UU"}GL߰HJ`yZ<Z,Zy>n6xڱ7Ӿ>}}t~sWZ*:Ot;{_+_lr#l?V^7^q'd1yo@Y*͋.<vgxGt'vvcѿ7TuI?[7z,UN,1b1]R ~-_
~3ڻ5IACUt~|sZ(MU}FSS)g.Mנ,)2d$aWT+ n%3$T uB	Bw(UȆ4PHZ|ekY8RH`&+6dɃxa6ߙ~v@$yió?$:h{(Q2A#.i=^_޶bn @s(L[u*ԓu
9R ^YjAVz=5CssCޮ`:1vXFbzn-zL]bYEE
쀛e"MXb8GN
*(I^iEaF*:h?=&dd1lXx T-OUg'\1>wHpK`Se(Sjy#х-NwڲQ
ש8J) flX394-lIwEZf& TD5ޥ6hbt}e%9`'6jF(NAmiMpΑzYՐOO-nBHmni˪=]^,xD,N$ĉY=*Ö́m'w"BGV2"<Z^ԧj0%ĄʛZVaG4Q`˴Tcu_	@ ka;!NlPG"5cbM:IT\zܴ3.dILu EF1LHIx/3s]|v:'9dŰW>PrJKNle	!&寧->BS}5	G[Ja0ڭ?ai΁*Tۘ
rjF1P?DQ_6ZVe4S/fPzLkRMyp.E|Gk47ʆ`_'dun&j\eCHi2*Vd<`X#*|LRHTW]Yaxz䯘u;T?HnkxպOzAjA#fy8C=t'\48UFT4|XCu[wՄ\PJ=9"ia{%Vؗn֥wEϝaLnOn$vo['⠒R3U$-fyQpZVT\2w$UU,P"QW:5u"d@@-r 2i`48^I@z[SĊxjAb<~'TIV{XܭUabP )(kXj)q>KوQR{B*j3%5D4&EvP]eH`;=s 憃L~)7<Qx"53d>VN8mo
;(~
gVSr)V܏E(̖\*2A:t`6.&I?xa_W<ihڰ1QM$=ָGJ$By0U)0Sۯ	TۇS\T1l&#X+xPbFX1N5bwE!FąQV<T3@U>SٛAN?-EӺ֍ x>1&`FyoC[5*$.[}J3OvH;7f
Bg%LpJɐ{]MWjn6F+#t'Aȥb_WG-I _>7m$mfiX
QPe(IԒszUuQ:{K	Z.!l6VVm]XoMPlO&67k}KQ"O~ƮHiNrn ?):;)?y+y|lƨH;u7fF~0!_6Yi'W4A:Q&vk
VF@ UqEs*&SnXI,)yG0A8xhɗୟrAWʻZDpyB!CAnɴ!@k+Dz/+zquj,ӄ6)ɴlʷ|7v8A6qiʿ[4|a24hxyX\7ཟj9>b0WjJ[*-ڛ&{N=w-;Ŵum#0YSE:/ݲ1UԁSuďf}AMxLPQ

*#`Zb y<U2oH$@%kr8h7(sWzԵm|PE<z{]K0[(M&}g:2L+BeDeԝMK½,2j^

\rPgGb <JÊV)->$,;^OMv|~zt[g_v<]xByr 1m̼`j;{'>"I"!U~d'T*F!AXHŚKbx00t
"Wp4pǐtڨ ½ҍpJF%hzԹ &ڦcM]1bJ}֋s{M;"ǻК@?(ÁEIसPe 5!p^uwzEhx^C\^<cUME&yWN(&^DNn; kq{ah. H,5
2j%׸>7sCsY+;b{4RΟT| C񇣷秹&^R;w7012/C LqLfB-16ne^%^=,֟w|i6]jw"B$^[tHrs{נU52B1#Dq9>wv:H*yRW_f"_Ф(=E2<g^=KUb]\ʅп@VHj{Knrumsu|":En1ܼ4񓴌gZw~|WIShu)@%\NK,P)Rz@GTE϶.VHO'5nH<֔;:fZvќ57|?J n
7ivjh(PH͢GMvȢ4)[_8fpR$P	Ⱦ 8}m,``C酔#QlR|}FE5} Cs?R'fy,/=rx9o~Upu2[mh;)M6L!r-VPOY.G{s,	M,]GeTu
s\is]$<ا(
S~"i;+
:j}Vύu7ޣ
0r͇Q<8L*p)qE1
:t@l+m}d,gDڎrI.
tFkLF`ǡ6J6IYV\eƀxjPv^,`Z
x	g<V!}*(vXkP9$  ZΎ2>!̔gSmRfَYWhqe؜>rdMf0W:VXqfbX4GF<4Ύ:ڮfpbX|YFף4yOE=1n<c)q4}UcHy!|#S̾>4'gj߹'ccn7(m4n8f<M2#p	A_ٕWkERMD-df[ko
bkn{M??&[ͭͽ͝CϬ	лXN:vDڴcpPq7o>§uGhl_%b,3߻@/fiaNŻEPS1,'XJ:E w|v#Tbf
1TN
xrJi*"59z%	5G$r,UIfAԸoߤ>t$/7:RG, D9ZlզnYs6~h}]o=^MydxN-a7~QL$Pt_LnR*$H+-Vi.Bnnuą2YW}va4`jZkZƋW#)-,)Ϊ+~E'=GwV[K~pnԓ
ףINqBLaP'
 A
]掮	_Ѽ/rJ-0VLhRB,lS`	 'Y\q T줵vsv* Lw : āJ7X;EbKTͣξG'˷G,Gj@`mtlT$\/Ũ"lTEQW*W\=P;{wӠDJZD8J^@RRWrnkݧʔjΊ%P
8YXQ@ch;U>2hf<1NYN x@E8şz#85HkA7I"-Vȵڨ-71(:1\\hQ:ֈifpMI?z5dպ	QK%I)ތX+b[SSNG|ǤJ`6,Gpph9:ү~KK?z3b㵲}^oPE1O1=p\3vVz 3ފb`1m6_=d@-%V)m24QUg^,y)ƁS(dvM4nZȇ_N 1$U)}Ю7ܤNgIv,&uLgs</UOVdr6v@iy)22]'xP\ ~I,m4ރ1+HOj	]7ŸԬn6
2)	c%ȟ\8u-S\c[詨wS$E%C	_V|2Yh.Ck-|_<`ZMbFqZЇb2$OAZz#FfPoَtͷ =!In:82!
d7k[6kƃ.V[w 4K=$o;s=l`u!|΂;дȴ"%#tèɲ4Ͽ|d,]8%q47s`Cz7IgNϧnu7
7Xg|EX[*b9fagQAH8b`WȘj4}xz
(7 ᨺ4;n$"n)njjן\ݸXL
dԨl%̙3[-R! yZfɓ9
iX>M#N(`TG`3UB{TDJ0!,PyKH,V	>׽2F]QwʽM$FX6](iV64PG0_nXO@EvVåM^ovTKj`;pX^vIj8?S:!E6^wS5}ׁG=V<;.CXFbtUX!3Xo`0՛4g\{]El-JTaXS,hfV.pҳB
a?#흽=;fr5fpWA7A.;:?9O:=ώ~>:QYuH6yZ7hc@HS:4ELT;Ljmcx7ŗ-n]P>tOv9-Ob<5Ƹ:jw
L̽.uYB̼0G4SΣɿC#zUHjCaP<N'MN$t"]ap!7b65Zkn"zʫwmV$dlA_A6
n߭-j˲bمP>/BǰWYL>DO"TI^ڷP_eeR<!˨)Uyc$@ްO/*0"V:]̲*K
캉Wr܊|ۉ/Lcle?mbfaҸܿAO[t F\1,DYAэDMC
Rq
4b/ޭ#E=pTlJK*5"w"d,c&:=
Z	DFT rAe^V(![F'zڧ4<vE[|DQ_Qڕzar.jGzߠÆ2CoA+1̟Z?@jDH*ē[>$C1&*6yi?g#F%Tb{脄t8VY^܉<'5Hh7ݝoVI^V|B`T=8( 희gzu])"צ2*r3(E["q>EK!ģCGT#RX^
K3MqX@ƹ٭)	ca3Fz>g`zVjj*g!}]ͤOQWgIQ 4z̞e6KJB&}$uSv=1Rj<ϑ	083r+DVX@D=P1YiRpغ! p.x2<B9)GNQXPkfٴB&Εo{__IR?	DNTܸMH'屩ݵC@IO3xM^iRRaa\sdy(E!AgOU81graIƇ!1Xo=DFC	6vnmu֦7ī]="<_⣇WR<p{A
R}@<y&\yQ`;tۦugH7]50vP/v4e!]˭Y8`ak&kYdr)Ax4<u9IukW &yvgO
Vz2FbU܂	%QEБZ3Sv~ %ORta;5C/߇Rjhi!G[F-_("_Cd8'Zr9:_^sN/;]Kq4zB ^t`">ih3(3l[ghMg?ZD,~S؄ۚr4nK$ك]mA9ʃ j@99M3ٱJѳ~^ZGս<Iy4FH3_Lx a`Ó2G\ʪvW	 	༊f찴5[n.haZEq`H* Nu>S~gv!!"*Wz}%I.@d$]
t{ݾ.l{M`v@*9+Љ
;bP\T}XE+=QE:,$|쳟Òd2Uj+fN24`cn%En!ӈvKXj5O;pPĺTDpiE}R+UsF]ϜDm*(CYdl(6	G2KaMd5ɍ !:Fx?UНu= IJwFi^*zb"!Yڪl*90py5dxnF둢.X({Q$ۮiFwVF
,fy*OmV8l?fzG&6CԺg2bal3)[Aw3ٚÚrPܤʦ)QDbb"%Y?$$Y'Q1GZm2Ѩx>o-B
ZP]`u]yAnW^WFg/=ir5|Y^T9u"pQΥkd¶tSx<[lmWnߐm1#_<ѽ[Ot}I@ 

~-;w,9
q,#)iNq2Piblw䩘;)f_9yiOM[π,*]<"*v+PV %T 
>SQnGU^X 0Ϛݝ#ngEQñمinC~ww a:̑rk·2ag 	kuhV[k ŬFAf+uJJ6l7ҙ`8ׯb0eDXd)Uʚ?7d-A d_ֺ	Rp^Emw*uz7#<_~8'Ai8~
'z-3U>=Ly@I`1edg~|P$+5 a58W~trOxϝqi9i%tPKBT	"{ƛ'-|̒86"aeȪe?wMYj?ظ ;{	]V2+&lhA>=\AbI9d.QY{&"G*Jc.Y+R}U<zBz+>GDtcC̢k1k(Ua8R;ƙRM@J/>Wh2[X|"Õ]B7{Af46z3"5'~{Kg~0g>t	(Sz2ԣ(dbd؂g`v.hE=TZ e{EnAh$Ǖ_>x!\}R+0o4eLh**1s̭Ԁ-qh˷膢a"֘_y$_ҍ{P6lɝ~=6(}bG=dMڗnnM_rjWq/dd*f|}AςyK;kKeL=uM'oF2=FKGTʩ	x]V.muބ@V9.#<2y)&G)-H|Gj:]HUe+jLh
q=e/9E&,IXH!@NPo?SG{%`O9unZG6>BHckvRƏdZoDS!9|r^qQE%loCLީp'	>ǋ
[5NAfҏיHLz8V*)JӅ*sI)*
+ǟZ娚N?aJ27?Ow+ɔPl|cSx(t8v!'D`r[M&K"	<Fho^/vBT)ˬQ~^-ߙFf~=Mw垌QRE6!Ű-;Mnfi0(Ā"7.?k?йutFzd66R0d
jN&[낱=.8 l_~'d󫋙F\K=-)K5ԃ"ZQvv.eaCIy^H'dY
G(Sj߳,F<R
2`
s%~(<Sشrx*%$q4]Dѕ8*Zk'WD1F]z 4bV(@XMTdq&=@3EYޡ~[?	R{xߪ1(*ʓ6Yڟl7eY<BRsyNBgzTJ7vAṚ)! $C UEkVӚ47Dմ;u> W֋nJ@ ͕{=>{KS/J߻_Kp`a5<)USi}O'(RC%[1*i//aS@]@SQ;	Bx$!PI9CN	7y0_R"Ya9d/`90Gw;_eH-U͗Z7·T.(5oZk)~i˼W$XBǊX#Ad><lL-(9X݂Wǽ{tXPQ1(v7LGʓSn~7
얅](@@ VK\`Bkt5g "I G&.7xZSݽ嶃m	սσ*w$k>?lS&#%tו97y7|Ggx/.!v{5p*_;ZI{tpFd
u/}3~Td8|ϕ$dHE/.rL!V>1Z$ޫkLfJGóUu#v_\o	hokR Ln&
7ڔ{?~8?&G:{9{Wv"ٻ2!.Z"pqH1C\O
!z#&_d{rp#tBH^#ӷ}c}?i0?~[~N$n+~3Vkp4« "'d;m񵅻<I .Ӝ.G` HJ'	$UGA{Q
I
㫪D.LH0RX@CcH957dc 
2M&^)u	%Q
&'UaV0хJ",-GxijF>Ĳ<CJKY֨"c-bo!.Ʒ=f
eٜYs,z~Xʦ
rxh002jSp]6nܩ҃-n׶z:3eHSw~5qNin,kE26^SpWe/7&$_a]tֿç5R
 zC1ۏFU{kPʏ$EM(lb8?,l_RMuFW$Bƫq{dSRs"X+iqΒ;5e%`K7KnSWAJBkX	S+ԙ/Tg\WaYB\7JC3Dy?,|b(fi8o?ZJ^ia!gb<:սjЏԅPcl"ާ+!I;Cx<i- ˀKjvP5Jxׄ Z"#F:]$~}v}Z[e벳s[#F&,+[hg|K'̾Hl7	C{ЍЌ"u	>х[{gG)i'LB }^r_F/8z|,_@"y)Jj2!78\,wnBN܊Jԩ_<9>iuS<HTƐ	K}~En
n[i ץr}ٰ|l|ʇ73NDcW.aIڲBϚLD*slÊb?Շg}w`g*;7v^K[6T/#`_Ώ3nel n-_PNm."|72B!'*6,Jq3vMTHa؍RI֭|=([MB30B_U_.n:F$fE
麚2W?n-C ^<
i|DT	-ƪ
n'vH
k|-yN2
7e텨	EHbw6TΙɮK4GqO6aB}QkMSt0a9Qjܖ:w]$6;\ض77l[Z&ژ;Q;m2B٧kOeƶ#}ocj]jup:e
dV2Kh@x&5IGvބ67|毎[=Y6SZxo ynh~X,^Rol`aQeʬQh3Y⍋|e~y^==]kcf/xMv>F89A[͚g5(7~brORr{7(L"$8s3;?ZKi	岠y'ILqZMŚOD-EsuU3_Ϯ#y?{v:
򽔶=>MTmynqX:Q}l(][;d,
E?$q[P݀Y)Gd)Y+m -PzQ@8fH-gvLYԽb_;pm{moXJ^&_c쮑D{_+iUA+ʼJE,f_"Heˢ`SsGLMоWN$L'X)n+`-(T	)Q)و {)|comy|Xj8Cc*//2%o
U=pv	(e FAq)7KS̴-Oj]~qI&Hz9d\	[LLO4mAm7a{}gHhvw*3Ǣ|FryCU+׮PIlZhOMCx,V&y:!ͅ{7K=@F)B.aZ˭$0SǢ	"%-M.<WXT\"A7(gURssIƵN{˩Ia@G2`ߥǺ5Z#|j[D!6Y7ЅGj9Ἃ~>q? D;I<u%}4I9Ǧ'xP==8 SiǷLTb&nCw&"Gs(o͘w 6A4Ѳ;	:e$y}U԰X>CT	PJqhg`CU̵I[0r>$c6w+U(8uK[D"Ē)9yv!nɣىζo+cK3.ap{⨿4124Ř
.&x](ϳufBY+QA\c>#<Ȥl`:^jGEn`(]ځK^?Y%n#}`p@jl3?|<-#5S3gdzs[2GMa}Wx%¯'؜l	Ux;15{ʾjtBc&>4V;FJzpɌ-~$GQH2%y6+,2%Yc)85=+K0J5R"T|֏nK0()%tY^y#4OB C)Bһ\?xv~\HukQZO ns=V}h;O
M
m	r mBJS{^߿5BdOsyv|Fլ5bKĤM9m#գARZ⊸qdO]H] Ue`<USd[I{;8oP#P	,TY#`($6dk*
,!FH覬tR-IA0Ͽ e`NUC١~_0ʻ,ݍ30hWW&r&4fQ_,X5Kzhkd=Hqk'	U'6(ag4_`7N%Dll4-uʳE5Ϗv/vMw~BO&	"|g*
*t)xZY΋tc+WD
iZQe]c~c՝mJ8Y5!BP<
,?qub%2q((3ŰeH7OQH^{l`RuQ*
V"٠%"Dm~|uywsu?dD.e
SkWmJ՚s/݃}㈰f9E34Ƽh,}]\}0`k$u{v	BQb?HӶh|ypr};oou59@A+;$Gwڭ&-犕447WDAO"^߱s$$,$DH{ƳHvЄ|ԇNK9E?p2B@u =<U~1;#JI'XFe)#J<	qh(a@9ąRla?qphӻ嘟~c>) zIvF4LBVM98}z91H[wYZN7S*\8q8"jK	)jt%<
08y$GzoOEQŘXo7GXFr*N&`LzT?m~l-n
=%2Br;{EJY
R\yb[#c-57q9MԓW!O\$jW"ↂ*3Pͼ%&m Cx6FβIgLv	v"rvAjP>$e֦B}	Bl!GD=t@
䎱D(I8m _ĕWMe>U>	X_/ʞD#h?PL}
uu̺nQA)ߟ}͡}uv㛳뻫elBQO>QʥHCCuBKD^|seTQn(ߪr[UH纓	>u
TAt8d^HK:QwMz78ص3HEm~{@
b6fۿG%ji\U?4Ms,v8xjoH>v{Arƨk0M'ρO[2,`t@pt-82)O3TTX&S~ֶ'wkoÒ(%5?<AB[^ԶV[cA-o룻dS'TՅ"/M1w,:ӱ!ʪ,U<Ox[Vz
#KȈ#t,~'8XFy0,qBiҗ^3΋CkmAV?b!#V&g?,."~&\ĥWĽҕ@+}AdwZP .19kٚS	Iȶg玂ر3duA:j"ȫx^QP 6Z6/Ocoȗ(?3*Jx-CJ"fZS`tcȲw[75z OHC>XI| dE(KV8p~ûOӛ+R?s$dҸk:O!ZT`9KTcQl4C.gTY)JQ?EVրr*Z-kB@׫ 

 ΆL+iܐď{$}J]U̶xrS=St0gR1_da,	E+<v,Hj"
E_H
( \A*  !8d'Q%5H:
	,X_7a@l-Zt[-:)}9=:5ṗsn ehww%5It|DlhXq|_4A Uvjo)URYoٴZvknXZ_
P FA܍DHMRy	Ow793{"U_Ѵ1DI}}3ũYPXAzW*eA",IUceFCOHa:y'%IVBV[O{Yxp
FRXB
USȪ~)[*jgN9{ ¢m;H SCۗ1.aT@R^c4S?'9JT+aw{k˦B5"B!P :9K7Wl:^HT
ZmoY0[qL֚)̌$ip~(v?y:|̕Oe~8iXg[-"6,ЇzɟMq,1	TX;.*{s`R g|!T>EH紻o4D-go"&c
j֩Cw% 
L̔|?gǴoLk]
e9-<9%%6bۙGٻijd2;)y؃Y=PPk&.Jg^ngk
ĿƵM1`$YmgqE|/nRT qq	1/d|F:-ݝdx^tMY@SO?BtTi̜KYvج#LhٲGEEem9+٤,H0a\<{b7=|"m*
^3C|=\(\G/=t0	a}iEfp
e:j,M[G!Sa,
ڭ/>D}5;ib 'Lel_˝屏]aE4ܹXfm$5rlQ}6CGt!LZRJ.%KYdlvA"()Ybpٖ{4vGAbiBc!5CaqnM&VF~wVu}mf	Aü_ߕ
Lla_V
yCQ0
I-T=Y5¡zla4%KڕZc-uȒE&RԢ8Y
9Pz}fM|Z2@;x[F 5(x&XHv쵘RIDS8ǳL/$էm {E^plʹ{A.ҬUc eyrѵM<PLM;#>l}rd1IOΔ
@8X}#"dINW[Fuv&"&4 \5-Be	q\cno>h f.0L7qL6~]ckK&RQKDD.%x3Uz#n9=:]Bao<nGwkݼEs|,t5Z?A-w_3797Z:vFw9uv5N*RU+͛r|#*^"ōVuu"NJZ,doqIV7݉&/҅H-j3q\fEI13<3ć}#v`ptCU$\L5a>yw&}y۴,#̣ch	!1wK)IhJָ@iu^ٟHn\+eYR^k+Vbu
DߟoВGwnPC[CeAx6>̇qi[F̜7{&}vuL'LZbW4mjQQB]VACW~&񑱷26JW8ɫ_2lbaNuclV©(ֲnwYxݚ^i?]L\#ojQc`K{.dٹ  fZٍI
DLP/NB-7EJxXYuQv.-:Bv6vیb7Uix_?%O,]s.lzhdCy_wƢwDz-lWrU-u͆I꺧CmT	b @L
Q?n\܈
bj}29d\ !m:Rp	+p;GnYsPhmjv&9N)u;/e7PQ 4O.dJ u%Irq/vE5yJĽ#ϛx{x89.=
m1_kbDΚTt/Xa<FƞYQ$YdcdCF7Qs519^	7zW1y~P^ڶXۅ:0<Ϳ<B!oXfJ^% n[\97KCf<-sY;t/>_q,xQ۵ /HVD3 Iw #)RZs5YiI3EXsXm	п~ >kn{8hGv+хZ㽿WI*S-[޻p{檜9MKep0mH{ߺ~go75#a@3ߌBpUCbCp翱 "Q5}K^|šnBf)/Vldx|!K
q%!hmlt/iG}2J=:C)l=ǲTGwj㱢:V˚t(*A؂{񕻒	NGS"|
w{1[#@Y3!w_$R|2q.DrN~vwԳN'cr^[ɳ[O.?QX.CXoRu֚{(J E߭VGAyϦbJ
¹<|0%sq+"ڀwY ߫)O`Db\.;U` ٹRErcׄD[1Ƚd>WV^q#F}(!e#6CyJOST_9HfCV9w = Np,yS~٬(mffE64dOP`;xVC;+1UuDXPaDr괃o5cj7^dKݟ{е1iKHŸsssIV#i9KxP>&\u/BRi}:S TUǡlSmih{_gfCj>1G!wEvms`I`^mM#?3rB۷޷Ƿ<mFoTIl GUs`B:ԝ\KTp9,
악7sNeSCu]jJmV5x>bv_eUc"#+i+=&ʥT>J~m|sDKM/ɮ<Qg٦6F4O6^TL~jD&ŨA'@Z7J{z>?t];LHF^\{RAgk
:7aj^^A[:"DJP!xɃ	SH!
F8-Mzn%קڢ/jf*|Z^;`EngSQZsMSku<ִj]mFX}>^xwZ͞#%^%UG6(ў)0ЍhL6F6)F=RJ*~	Jzj0~x.˅SD=jeS	p5I\dŐ0IKk@YLBnngbT,`Q#EOO(@X>+;*w|ub?Йj50ƾj)DvTQ@`p㜏Xa *8*{t;#܆܍xe0$'a<}ɞON/y2T(gG ف_{ioR:?~qàrG.o;'eXב,C|ؠ/CŨ({<tysztX" .0/J5
%l5QSW/&#.y)w"i.0ǈ+O?+`N鎍%i6zxOB|y%֞g-exEC|rS4fS,>='	R704Xz7ۺ-IIzaY(nSӯY%(غR_.{4o
M1Ph5Ϩ~^^^ޥ%ߤkKK0Ȟ[&ۡ	; _;'F/|sߦvD
:A|v'd顟~t^B"D
-on>ty͋KہvQ(+820p۰,*ipN??~G9CaRKeRNE#imrP*`{at9u3ڍwṵ3WX;?ϯqOB!~>		m	*4^i7>\p0Clx瞲D^2L2"@VV!-"t:OYHm>ԅiO!wڷ= +ӭl5gH	Gqnޝe؁ҺqSgw_k$(S$2N̦,>^^ty@S?SOq|qurv	~T(O#=y&⓱;p'_ݜO
-Epb)̙l#FQ9t!MᩏȄ%qBәֳ۷ozۄNfUCZa
VzɌ:`D61n/~}/cWh.nP
ۚN8ҷ%j3cO7I;R::^BPЍHhFYgW%" 黸V[/YiA/|I ά'N`+?%}uw6~h=  \|cݞ}=^t+
B+-J^)\#6_NޝbFp*x
\TM~Vm!a'X_|M*7SMvxҜ*NǯLN\ϟ޷] y/	j;W,d{郙?yi~s9;oUZUxƎx8jg;uއf͊&RR&}<tq3Āo@:pǦsIlguMWpf.b@-5mT 0*<0vw
37v@h)sOOmy CYg߿xts
X]^^*gǽt$FKDܑ8_B?vAm15ϭn^IP_֍[rd+ &؞M&.X_W$\lu[PK#Pm0*2Y"+hPh4kH"oMqyn]Sxr*z1X`˝A?ʅjg!Ũjrgңi>iTp$IIohT&VysIˮrj([8bTOVćh>c0b0w+\xiSOPKsTˣ `\K_kG.]x<I%vpH	:qgۓ?$G7̃#I
4KSˍ/	qޒ34#kl9&:ZA8eBVmPNҬ1nB
gN;u Z+Ug @k>ꀧvvجw[fsS>T8.4VW5}L?䞮)ڝ"?ȒU{D	Q"`QE)j^WJٹě rD%ήoOnﮮnߧÿo9pܖ}!:ur?~~v|qn$EGS'8ޅ/~<	<\o"S8Mt_7W.?o/n
bxx5#IM-
Aqwf63
<ۻB).#c?(c-@Gy$58)9qpt9kΎQ[5[]l@!F~ڣYr:
y*JޥQL^ 1ʴD}r? P1W#MMbog/_{oGcYOz'84e>yH	<z%T|IvL͊ R}oƓ2ů*=	Z[˩DkLovٹd3컰ܖQ&ϿyKEu	=J[t[n`ͩk[fīIvSWg_82>9n1@=SݍFP{[koQ)ٗVhm-̵_N%Axrztr¿|bWNNNv'T*\(tfG	=#~^=(xJN;w>>[˓@]':ci,͝>'r.xљUH!yԽV{c9{Bs׋ЊB
%2\ߓ A_.h%޸2=\
FP7"-bאVt2)aB@8Kœ(d3?[aY'! ]k<ZiLt:oݗBvwǡ#x))iÃ(`Bرs+찜,$p:	J)(Ր	=ϑdǳ]MٌlL<ĆHH9HY_SocW"Auj7`DcwZ=D.KOU9ٌwl4u=Z3R݀Xf ʑUU_l7`m+ffί3+wݢD?b9CcUBCN.SSפH^q'%u4Mɋ;ݎUl` ?zבך8<^z;
YGk2BNN Lk\NwQ	mߵN"k
?wqow;/1q>ݜ9El
ֱt
I}}pzؙEZG(IP?^'fFlZN{څ>(A(Y*mvhݭRo
_B*1!͝NN58N-jƃfָ^iEf6oDq=ɧ<sN=[bK+/MDT20CjAd1	!@H7=]ow~$^
Fvn8Z34H68Kߒ_3l1h߻;i]- xQ 1atђo[tt{ߥ,kg$h)6b2ջ
2LfH#xPs#FgvJ"Ԙ>C"&%NP+\>0!W"oh`u}Yt%oJ@kF
(?pI>ڨoz0):ׇl.b*7掐l&|8tVاլWv1	ucB1k>Hj
L9`yH@ZxUOȦѧ47Ufr<uј>O/xo8HnMxmP{uDE	yD\Ić/y5)$(tҦdz-&R*Kq+4>T[K2wD/Nq"Z@X;R̨:H.8
χjq5b'f՞09]QW>,Ak(\6UJOuEԖUGoT@	=ݺ uo>@{֮Oм
I`%҄CE Θu߻O}{=+F}T"$dԡץN>j@8L━Bt4zMh=V'nı&}(^ F#</}4jɔe~)f8J8Un⽌٧Y8a!Ekg}+E>8|F y$9CYx8+*
,y9DV"Z=ar;ɇ«b>UP5ŀN]jԥwH7G9"9C(v!xZ}s{!go<Æ]!-W0Dq>RТGա흕L,A
uX&EWtIv.t"UP |8S	ꓚh:`'=;$3}i@0M*?):P/Z8XbBktcBʘ(	H^4e*^e++jBSOCw-[jKRT
+O[Y#=;^m|^O%Ƣ5]&L[IE~Tl["%'7dUKg+ĵ;oD(a-tɖ· SL薙dQ7Jr	>0Ѭl__ݞlv3w|#B,vW.?-eǭE+PMe)	t._xɕeY5Za#>+4F/k_4sP#Hr-nF%w0y`m LNR'6sMr%H9WXH-mXYQB{57S+e^[np7gas`||с J`:P</n΁V
FE fw4ѺlfnMI|F)$Q/~vv㎙G5׾:t8Ðq u2Pi(obv&R'嗺KBmRO9[gŒ[ZG]v)82I8;7X5($U!?

͎"s#&:t
^P8$s+MъMݽEp4qcl'1JD
@Ճ3e`wZ;`d5aI`BFA{35AS|Q~uvwmYѦZ
,C<{ꍫcb,}a@~j]BG141 q0Mc2Yrkx<1k4w-Gnk˘Ǡ$]O)hDsK4ijZbϨf܃
[Kd~w.*ր*i~FH^N{}䢂Q9r3arqnqk\V?V)4cʠ]RT1&TiiRȶ͇!{`
:)tj6P7L	s
zokfS(sGXU^/o_eunk&(TB^"s ɶ]D}n(E݃kk2)"AAh)1{NԺ"h JՇĚ@-f,mBogmެp@),L)яy;,{o'[`4]
/"E2_4fEGKahKH"E>{`ӐڛiTƢ`eZ8[Oukc^D|(ڍJ">VGlt[?Uk1eغi[]@Ơ|Pf5,)E\)6:.9giDH(ZǗ3Sړi.}`U2`@qF}QR>⫷Mjng{1iҸW4wQZ 6|da]w
cEOtHV;IĶ=!l5íQ><AËSBU:Tnma\&
I2,ʉr;[r<bDn&LsܷU₷73i˾?ZQ6fY7fk|FaG)AKd_D,d,w狀xUӁhEu#(ӜnU;8pLG9+BoCE!ߠR4$oizyOjh殐hh	*%bx<9]-d牋jZG؟gQX."Aи$δ~DFy7eI;&]~-3Ba
B+GIH:qvZ$AtM]JZΛ[zB+A(KE*. ޾ƀpӦ]/cn)X4k(f:41tkk7GWޑ.'ld;vv7Iizfg-0ũvL&wqIΈT=~;nnUE-0@y%V`NC?/U+֕cv}'G_P>֏OXu!	|*] E [qGg7(m89U)пJ2_76A&;@֙=C}T8+J%bw{sqZMxb7
߅-}/z_&Y*G]+1n}-.p6i?!];ƿNAE-V1SGMB47;ZkEhބZרRE'6viOIv̇I{*%Ş"~k7hV_<-\[m|7>E,[!fpr.Z6Tv7C8ϝ~>nymMbmNg~frtm{&qq4bOi^-aJWw)Y]yʯc8PmHQ\%eX~+faT@ק1;3R+hBD!U}'\rҏ.h<[d=Gh`o/]{xW5Uj3-IMUA
1A90@T
Q@ ^zl7#ɞMlwH>*ڤg4Pvi1	Zt3O#$Z0RKxs,JB
nf{HɆ&1S+Yׂ8&~#s<3G pV%(PHX9 s
({pscX	PTK9#%<ax4u@έ
!2FE;mhY
ӮLk+?όTF*V	)xU2UTl\O@Ztvy9:kG
UHs]s 4e;EMYN=2	3409N&^L<IwYS&<	,f~/&-լ%	* XDoY4dy)~pBXQB!sГ$<{]vһA'|Z:oE4dI0Fgh,6A}ni%qM[ALLF
u,D(~).n Ra҃-D	YWTc&jr1}(
~R$'D>Ó*f|Lt"Wϯ/..v\Qtӱ2'U*%#"T}D5ok~UYW4PЄx`
'Ľ4f5Eǹ^q&|n#|xQTG.85 Mkߘrt}5qqO/GvKfVkÕ%U
.&Iޏ]w8R+%'+8Xe93e~rAW͞7qhbSnE22޲w(oG"A6C'$oFḭ/^Q5Nj`ݠ4,xIk^nS.
mEI|Of$g}]~:?Oj^KQ/\wH^JKZs~ּ!tNSKVY?S<wT0$^g-4UĒ} M;e>9zB'oeM.(ܲzoTb`hamC"QR0̞mo;0N@	\ZQMs9""^T*oKv6=dh۷xfc7}˃86 e/𖄊8w!pn2pgI5P`),qsNĔ1("`9tSN
(&,<=&hp+pґR2}8 |
ϨH#IjX-\{:/ͱ kZlnJVe/]킀l9#' @38
C8-.` .| rWR		v*́ؽMl6^ފ
]F܀i$X|/(Q"K:n"Lj%MJK'QRjtQA.=<N}YZ1jݷO
➛?l&!lg>҃qn؛e4~B~@b4{\$u?blDr^X5	aW?!<
Ϩ6!Fn^6Z} )L6ArϞbVtODthOt!|%He}ORycpt X
/2(r6Mq1Q ,Q:LSU~LMXz
g~tG_=(o!|a
O	xrJNT7nfy)p1B@S4HPT$c
f>5;_(H5Lip]ay-(C!Xu5EXjn:#N{wܗn溙dJBp(1Kf`{ֶ
Td4y+c<UW* g*i3(\fFvYs([+87;}!a=
UvuyoBzP[7+Cd~}^K4,[Woϰ+'
]}
/G柳ΞώWQ{><Q)WkͰ
֯$%RQͅ>saFu	[q[&!@2蛲Y{';4uҥ	lpA}8f}
QnP:
n{7/5ّ/Gl*ŷO҉ۢRKf9ל~.E!uqo};.{ww9HoK~8S(G΃<|ׯ-]7y!IR}VѠPZxJ~}=dxp\4Lߝ3D?7.dv!
Qtз9D
+y''>}nX$q;M
Lk:A.dcI^΂Ozh'F"@Imm$<Î$̺S@rH]Z:FGni';:sd,7.	LExns o(.AqXN%ݼwtLG?A"=[5mGQXZ${^GdygH
sao_"jɇc0cX4,YZ[=֚|X~̄[4Gٳ+ĪV\1p'PQ%MIfX/R#- DQ|O*	zTkD_{'O.NEb!vFtMi	[NwFjMwZ܋
6%m׋C M^ݦV2,AX?k( @X(-"|AAACb@8wxHhK~)R.5K"h
|
yA[JDp_;k=b%S"=E-1ԏgNtZ>5O7gi> y=H}13|LHYiXA&F uiZίn|סm#7%J]
9sگ4+ze(Pb,dʐSO1[wZrٝYѫj<JpoXJ%^^/*<3T
&Wb*r*pC5~פ|{$c{UgS~x7# [Y
':pZ)X٨Ғ<ɣ<|<\!EK
)&X,$dD{ڷ'w'Btywv<Th4$z`H
`0ob] uEovw:؀~W23xb'uwgGw-*m#<¸z|{}s!SA
oڼNj׉PHĺΊGCӶڬbyٗ_Z*19yY
0}|pRs:T'W#/dDb!^%cN~&J0bI~D;6"}b*{mXşv7g_] KС:te|P4I.0U{7,Ǐ\sK.a؏`D77_?<9'x1Dwlᶎ9]UكqGΨIy /-ߜ?_3-تd{W'zrXW_*h[֫Uw%dH0;;ss=F˳uy{
ˍ\݄\I
V,-1Z[{ESSѹX2V3,G,V~YQ|s#
@˿Ր3vwYg#GMXو7`gow7ȥ0S};8ߖ)
%Zzx7ת,O|6{[1$_
7c)Gs41
>?uҰJ{<},A|"Քo4k F-8FL"$ۆ߯"ȃpc*+y
3ȕٱxlCxi{~ud`E\֣7
a+T _ѭ^XY(p7kNo1/d-7kdLa\]n8O+5*k*nJ
OFhOh\!bEa@\]
	Tw*@b .+yC;]ꔄ
 Yқդ\|`L/V
=`9gCSe
U"i_3hB9Z,G^vsڕh<zmdas0	
HA2'K2MWT4{=V{ #8~H]@yV)0^[oi&>'cI¤zNA0TXvvLM-iO '߳Ɣ^[oW+ҲDWήX?6&x~=M1;ۨR{Nc&p}IYG <d=l.ѵle_!$#Ev*s?g3W 'yr#l_A"wRHLZ_z+0Lуѫv}l2	|敉MEuZ)
yS
ˑ@d[JDuJL 8b$!hktkKF1i`Hcc1- #3~
EBhq^>yG@9 |hZc;3v32P%nkn8N-#n~ 
w?^ޔw:
EVuViH,9j7z/:~᜻ۚwy'c4~9E{obNfIۗ7"ؿ\$X?f:0߆a5=TNcWsi0U5;{}g&
re+siY_+wxr-ama0¾w'
Hx	
e荝cVZ&pncVGDUfyo4U7A䖽f, $8cDEcl!n7$uIǿ"ޝW9$rs^?^oaA?CU*posp1<
j_Y5@IlQȄ68y[O
iweɇ'&='JfPH`VBxYMq+V-LjBPlyx,.{,#^9A	XdjHjlQR^jfb`2_wQ#XԢ*F(&˗E5n2
ZiB{ҸIXf,a|T

LK55A/uid;	qHcQ=ǆdg8/fHwMѻ3=Ko͢@uythb..>n@^F/[۝'*֑#1n\x[]8Np!*MMZ
TǙi\WGE8r{ ĐNeIUB%_^)c TYn(rm-WA%(>r0I_[#" WZXڀ=,𺯦 Aԃasvvۻ)43q̂l2G@<P*֮oyI,l\c /Xqe9{D/h"ih v*]<	h>ǃVn`9In@ɦiEQ)"cƪJJoU뱥_w/-	E7$CbXzR 쨾)Yjw^B1t@=&Fy9ep.`f~3)ݿ/(vŪ"z9Ѱh=վ	zKDTL-M3ՉiރyKLaxJHzدI[%27.>C$ܲHU0hDl?I^#&>~׿W5raު_V_%AʑdNv8Zm)RD b_W$o9l<KǪR^NLNYA9f_|~Gao#;j/tcKDEpգ( RRzQ!*ڢxcxۚT#eG^H&&ڣV=SX7!Y8a\
QZMv*_ELnroZVrw9wxFIv.JZ_ή*"m2}OB_\P_ICMnyG=Zuo0HPpi"ʩ(
IWuEЭ82K@{`7n$O"ӎʱ> \LB@Bto7"dtd!dԞo>J Ge8B)duV] x0~{$\D6mnz+}
w\	-=ɨ#u3j:f8yLs* 
vX@b{DBMccy.[op3"wTQyg}ʤیZik^\
*tI:M /+hZ{DFn
TTz䴌74%7y#a޲w|MW~=fN=5w?
˭5c<,!0G*9?PC }׉w龟OYV ?<T	kwWii	.񰾮?}j$
x(-CwŶt&f>\&s-8ؗ/
YGf"	LQB>yL m ݠֿ1~6ho7"R]Q6Awc6ҚCܧdB۩l	&U%^~cۼQ
tNzis~tƆЀ+atAZh"Gu+jܕWvR}u[En5hapv,}'DjxC8 ,]^_]~+{łoM\hkXx싷WL@M,X$w4p1Fx~	/kc5:}?_*3YG *ƊR`^GLZ	EƪHRNߏ3[6JaY$	&tdOxeN~=WFg{OGɧشm!Rm#+eANWBI6*"=-sU\r)=hJ@vı}`827?dsԑe^W`&#t!*^]wꥫ_Xْщn.z3ޜYEan7q_Ej/NkHo4.SqDziN'ZQ,]<bfŉ]L2
C	`M:E~/IՊ_!{Y}u|!Y]?]y6olru2rb*p^PS|*yg):v:ؗr8s	E<Qq2u%almMM[A[oO,;0KƪNxo{L &Tov}xDX#KٸyFtIa	45|dd UaW8n6f*bW7-MH4I3[( O0NAw]G!fȿzHjRLRy,b$y[5d?nK|P9	Wlz9ӪMoyWǨlkˋ[]@whw겔J$2J?޶fyHžmc%Q"3Cm3 L;]m#)-gguKP~g[$~kBv%{5\
|<`P)6$!<p;J$`II2$|dRb]ξnl1W$!`
.ӵ햊a"OnKJ5J\=n]A]NދEo,oceeɾ+g/'.9:|e|ʅ0NRWc7y"D;bH|	oIfϬta8{<foBQv1nD8YQ!MǞƂԂ	ffXwzC捴
,~_|[󜤯.ZvƳrZg
pWU}qvIǃ&B?e\M{:@00bQ%qUvW{C }G1nډDN3gI7ߐt;]7{~xN9۳!TdX3ڤP)Ug'
]]֡Wx!guͨm^9-$\
߆dgPFM7!ߤ`U=ͬݫd&SZ!O)4<st㚟Hg>y1!`_ފxyDV}z2	WX& աyZL].Mg$#FlL(M|W%r謚B	'ޏ^y`iO%sJ_HԼe'.]}iۆeo:ZO:ѳ3)6X<E371*
~q\RE"	HOuZS?:HD<M#4.xu#S`~iK2"!MjYjIQDX`/(&Jy#0U4Vw%hv[Ai`ʑ'BƓi Alw&sJŖ1nM'3s>FX5dUP)C~<ȥG.-Y0 ;|K'"7'{gRq
#F"rAD;4n
Ca
ဏWcq_)Gq6?Lg.B3kH/u.նT؅SzJ(|s^.E~O& Tx3阂NCO,LIƛn_@YjW/GOoNߟTP1@~Us`8ri	1
YfVW#ѱfW5aQ%?U5
/mg#ҧB"ɇK)Em.X&bt+1$@;BhO[)Bhٷ$*GZVa'8_.Mġo4+[>|MD!G7q>?)@jZ)= NArK:MH"
ioo$aٸ^$P

$7ntYfۜd7"ҝi	sjbZ<S^[[A*Bm$}-=tР-zwc	j	ҹhz	ݎ䳛!;WJ;]O RDzwrcӁq)5-e:`W(3(d}b.Va-3>i=Wd}?XDE
C)b1bR?ibj99շ%a l 9堹4kH8꯵S-_t'hMWd^Ch2ݽM:GB>c*hӰId7ڬF(}e]$w4t^GCX(֤/aﶱDЈS_
	M*:LhG)~5?[5E#! r爝ߎR
;
L16tNNQ:X4%2RælY3A5I>瓱e:7?ªڒz_k0$><7紏>7x	h}Cxlӂ~b-B97QHsf<y^2'^)~OƓ
L½-"zƀ\3Y|yF8_$@t9&L-upis5	I,j ht!+jY+Ht4i!cr
X7{Qd$>߿9mFG
)u
	tCo`vm1((R)!ap_od. *~?HTH?Wcqp ̶N)N;]	>+mٖWM4jwYϴXj'c砾s}d.^(jHMDY-tk"d`Lh*Gl-

g-˓/q1,hе~C۾*smQ l<9Y8
qLS
/zmH1&|8[AJi;_[Ag>Qq69i1PKE\Y4ƜuԲ$YhKG_JoS3EX0ԇBmmBtL;jcGxR>=&H M̂z@Zt?9}op bβ\x,C fgշJڣ/Ý˟_?8;tME d n7i監o{"8DY,Vb'r%jc_a#l

Ta=rCQ]$-aTũ8/TYܓa#{~iᄋ>њtyqNȠjPU#0T&d T-PH0㾳ﬅ~]uN0Iu]eϲhk'΄9~SKhG:~ˇmG(jƃQ[?ʘ/>Zi݃-K{;A<h9\5fڡVGO2l "-K8cHKxŤSQE4hеPvoI>DΒ)k3gbGY5@ۦYf˔}	ܜgaw[mڰU2e8AK̈nM5˚[o\	ٯø5	ac%ܶY{^
E.#EiYV&`܏)
^sY ZJ9r[:yc7/|'J5廌N\A-!-UX`ڰ'_J*N9G#R:6JjBifjwn?l
"IhKQN&zv
`_3bP0	fPf	zUk\ĎeQTo!HnvBcAxoj8	xK]фfJ'	V{JpaPSM$!ԾFv&(yw7GWW8}z|uywvT|u{zZ>7ӟOR\'sAN?8cҹKY8,*>յ#E1$,yT?}̏O.ݣ
X}RFTT$72XdB*p,_Q6Ё2azF	w&BguC#ϷKU;8
TXH
Vi38^Z^"Ϣ
ڄ3hb.
Eލlk#{LaV2s<=WQ"b[
Y1q.IBыp`F|K7O7oz~QmQ?+!F{o7ʓAZQiX܊zܺsٕbc7.eԉ18W`-*V{ā|9>d";KOϟ۹pWQluvfܴHUŷBۣ&Uﺇz_'Rrg
WnN&θQX
ӿ؞=\zw$KF\Z2e[1qMeCk/+&S"pL G4j4b }4ʀwfkav+1Tl:єJ"	L@ҏ*rE$" Tb~lm&6Wz4Q?O^j7gǛ?ZtR6>r^7G߷05CjXd&!*v3!Z1p#m-+a,B%9ܙ4,vBnhOA`:lqQ,@ ȊtY(u&"
|zcS3;?/ŪjskF"?t(^JoXW@YʀiKTr*}.ѻ 
A1FhN+qPpy	McǪnHͧIR%i/B:{ʍe耢[׳a(4vx#:9IO9_mr@<Ț|L?F|[1[,I.B_}n(Q/])$K@~!N'E;tLbxN #MxEM$ PH
̕үcVNB:wQ,!GexH!I[+9$][ƇW+ӑ lܛեNa
]AFEK
"(\rl+;w҃.m[K/^kR)Ge9	l
Ok6i1frZa{E!_^̫yQ	7[s]$N} 
PϖUF鄡{#lC,揌SHGA:hŚ{O1)"SQwhR=ZRr޴y2C:ڭnkGVfrqT{1 c($6*74$?RM DX!n`Dng~=6K?X#$lzQH7I ,lia##:ޖhM$I[;8o~,BB/L$%vm!yE 3/?:#%\xʬ:׵v& iJxnz)܀#bT..z#>h tM+'	ȝ٤D1M5YqX;U7G(.Y'l>U3YJgAH%bfzw?dNd<!,$qT,a<#Sޑ2oZnu%WOz)vb%:αr-#HO{Oc7>qn'&
'V^dhG$O`	N^i+AA"®	aq<~sj Gq6<V4:	}os9̾;ϿLT=#jQbc?dY.
ECT1ac/a>LG)G cBjfw77i	m!oB]4ݝ(;qvYŚS۷ֻv4;J#Pn,̪NzkeNjE^$'ܨG	HhvP_+[ԭ+ (H?X?r
p䛒H|:+VVE
5r߱$z&Yxo+Ěڎ%o<T"xƷe|njr:}&y@+g|[`nY<$	
$Kc؊R
d1ÔߞףH,Qkz]OQa!%l:iTQSĨ6T:L˛S$ʝ;l@-M97PCpha!5\C[|BRs*+BeS"*qǘ f!~ݐpG[DlkE L +:yV$:=ԣyބ_1ۜ
Y2ǵQZ~8w}Ovc\c*(ZDj.Y
n)Uͯ(6^,JD)S)=)sP:Ǟ
I~]BKH`
x/	s9|ASXŢv!E+ޡXs ru<~4<v^hKB5U4*eq3xq͆&\Oxg6>^K,m^eK\m)PȜV;=>
(O%IĠwz9FH&t%3,;շ*2-~r%l)ن&ﺭ?3@`v`Ա]FWA#V2ӟDXЊOmHS}	'.I%XQH$׫E؝gB=Ul'w
	\it8!Flt#?SxOq#5f*5Հ^΢2	KsG	dtR[6vj
G
C+'*ˤttDD-m8
e9Oq'!2TJe-ORF{XZa7J:Cl:j%ˈ=og̾Nn]Rq*5W̟U_,Aq'l7
M3oTL=cM!9u =*oBBBVn[w,KFӂ<fBT"Raojoڭp3:Xb$gZDb|-ȽX6G[9"_`|kɡ(>^]/t加k#epJ|cU$ٰ7qoG1:F=EBP
D`'٭i
?y&t" ֈ*{߃14PsjM_2΋W=FgJN ]A}CQc.?g~{vuf}H~#a>{#!Z/%]HGO36f	VqllmÐU"# h
	46v7PZK2'"VJU۔fO!
@=>y:~
)2ɞ>cPn+<ʈ,P{4qJ/&󢍂_u~yurz~ȅ9(1N#p-riO7FgD8a 闔Κ8?2M)lTrJ?H wjqX\9yXtɂkpYԺ~dld̫}zb7R~
VʃEgҙo	
H|533mྯLҢ5[bai/_#?]!p x%;'d&N_^on(`HÔKQE7hk	0vځ,#CℜP/J;&=1kTK#^<6~C6	
XIo[bK9nϔ<&~Xh몀}w6jMaNGMwuUV6%[mVy{
A"&y.sgHge.1n~=yX`1$Վ/c_ʦt}D^/whv1(?f.=EٙyE,C-dmܥRaQq*j%*
f[rSĒ/GbȪ'Y	-:W}KXk
I՗
}eH
{ilqXL"x@1:Κ-vkՍf-\5MvveׇBl82&l
M=U_~O^3nS܋7 ѧۧ4NOcG9",iAC8.c3m:3OCezN43v/xJuoh58D|PLPext_<u>8?ݿ@q=O%O.n^paC*]mاjnU⬺--A94XDN߲eJ~g
Ⱦ=Nʚ-ZV%QYUњ<g	-Qg>
 ă 	&IFC>}x͘`"iU	;a!%f܂Ѣv;rk~ħ#L&{<g7z/ΎY,\k#\^Y}8̈b *IT^=M
DgJYܰ8ӊ0`(T1Ύӫ")"je)KkBS*M(OuJUqT@LBZ쐬qȵm)bHtr5By-&Dly7翼!EH/<R/AE7l
tT6ᯖf-#kIrEQ6v9=jeDBI	EzVBVO a_O锝w$:UDHQ}]Ci#'_7bt#Q)vSA _DYeKuS^>ATBW?r.mldL<PDLo0GoR`ǚ60&wwY?rc|_;:S\-gXm>F3f%
rj,H* E.^a1ABدȴF؁{Z:EM(^=")*[
E0]Rw!_GDUhDgPꌯ6!.͟gm5QFתvfL`w(TILU2Ab
Yo>rOG!TEې>{yOJQtņ֪tw_*TuON)ȒNy\sUiv{	(KyNW$ȣ5:jA5J׈"=쏊P1+Uk4ff=+%ff̾2b[2l `RC-Ox@zNZ!lMDr*ۭw0Gqt0$K-(~?/n?Gǧo
 3v޼;8<s~zY(F\,5	{_
w,0S!ĘW*Ya 0Abh}EhCgZC7%L	<
QikYD39ل@2X/).8ke	ˆQ=ʙOf<4mdx=ROnno#y\akS7R,7,.f7hRJ La]
(`,wuH)`WS>,+CLX%"H%Ek3_ 3obmzV7軇	28nib[T\5qsfm/%%dA&w>!џקWo<+
zdF~tT[K(IӁ1@|.GieN1hxReo/%r=_>bҭ?]%PqL6>PZQW(5y+D_F5AfrR4X
4#:Ee̶f80)024,B̫Lű08>X=-l&]Ef2 jeuKh	i*O~k.,Ochօ0RD@	cTC?E`eϔL:~"ofc_B\wOk"F$v)3oL'|eV
a4=2A?u"\ay~-1nجOY/{-?7_w/> %3[/])Qbrb14Okkw݌Л[}S观m?
{3f$	%L8m-7[繯).q|@1 .\iB~E=	]Gf޹%:ήTOc}T^4"mERc7g7{˧k<q6=@=_Nq7 s7]5Dű-w!n|nF33a?)tlJbkZm]͟)LosDO2ˬLLY(fwJ/ 1I@b$l%k)8
RCVxLi+1iz*Jd~
ic;$R`sIdN]zՖخ|{iw{}u-\ᖹ4R>->qUbM1QvU/чS4y0$-Cbb4{ W͞68ˇ͝9
n*@2n Vnx|1czO +\݊@eܧ2 k
Eƣ^8'ԁd/yӣv)\@еպ󰢰FRK߾ ;yc̈n^{_>Y¬qZZ$Z"-@uĊ$Yȅ>0*B
6sNSqq08"S9RSp<G\Zn,a6jD1
Xؖen%1k	ZL!-|*-WnO󓣻 LBBW&J6i*WCgvo20˳YҖW٨Ф>2AHrx}tZ 8uqtXNQB!Y!.*g1Te)UW_j
{oJwⶾ0Svy9F7a?"1#^]'"jo-\ߒհ0Fq3Q4Ath'NmA,ƴn|e.o\k*+`oQDo x(7.tH|1a/=GY*ZoՁ7<$DQzhRYOTj(H=U|QIh_i9;#iZR'SGw~^>9PM'-;ˊⵒ"JeJfP>h@2Y 	ö5V@`D
ifPU`PLvZH
ٵh{^@G_`H!TsSIjwGmT&_Fq媕[!QJLt6;%< зH3c QI)X*x0/qBd$'򞋼G<)k(6/E	S}YQЭI񲉤ѹjVc	^#zXfv7D)BGF''FLtб!؜kM7TarU+A\}aGZWG˦+.]cjSv,d$dw7V
ixHhS$)C^}TJ ۖdP$#$[vhf
T9g<Ș	I'dѦEV>15#ڊ	Y_'u}gWA1x=|$e~>[NSyMebxC"F
Rp)~+}TC=5ٸiGyI9(iY@
PACˆH
Pr"B{^r g+P#
"O	0*h\LYGrw\%[	D9RmPX9t^s3(\)%+y}![_2;Aηn喢(3i]ϊ6C.>2!(
+uMvWA@l49S(8$Yd;M_ik
jʋut.^vG
uy#$a9$&F29?
8D?!,Sd>y;i"=*uSf7}JƼn_z`}`*g4 Tf \[11A;(B4^f*( #pASbȫq
:lM,RRɉz'xkLoڍGA̭sS`[F=$ԤnJzMUvA)L^ӹeppow|6hǒ	Z	Hv3	)bHgpz$ֱ܊WLjZP?m,xdߤGH|m')Ĥ"Lg%!\/hCB皋=vWލ+t+Z*
LL*5-Tps}
މ	J-+	>|CWւ q#:rK\4u	@/"ab{ȫ	Bs(DF		A_&gxGrg\bxofԗ'dVƓWIrp%$bjVVz_j9wSKLqR67-&iƒ$}Apk=%
E-NJQbuat# 2q¥4>>vWv|/0qw Em߲=j9[Uu=tG#ʾ]G?es]3y1o{̞'$<
ۼ&]3^A@/UC >tJP>ԸGjЙ'qS٧H%#.uEeE
~8ÜjkMգm5^h<Vj
,%ahV7'E(lՉ`Q"?dڽ
9 WHMO>ICo	̕i%$o{@i}FsFnwK=!+tHrI4>^idsL/Y5c
w@䤬y[MיͯUll]K7;{ăLk'zbV|{Ɏ)
Ϸjta5#NXt:ZtR	ܖTc_v!O>pV9;ylڹ|هr4C(:A[*ؿ`>A$e߅US/Ͼěvme`
Xv}%0<E=%^ٶ*9j'aqQl*K>yZI2,P{*U,UD5o"qlA"7E\i]zZH&kL"о&kwC0Tknox駕ϫDO\OMvF8	&'I>FjD\&	>fCß}$@I xE%/e..N3$H0bdVێzL0
5i؏=S#hG'Goj__`1idU^FT7ngڂ_
_yXNZy?џ<84"{A.H4aH GHGOl!
LT{XCp܇LKP
 *NGVD-$uFæqի,~mvhrx=1Wpw57`v#s]]os/*=/f<w2>و8⚸j^k.Nxme0}vINau;s+(il;AS7Ŀ_p
YzPYJLN7qٷu<(=˹-OWJhqMTm7Jo"[C,H`t$0>	(JǞaY$(`C력*X' =`1\J6P6z kYIwXWdAgWnvBͣǁQܼP,$Mٓ}וm5sJ>z,C!ZMKB+|"@.`[DvP҆
U'H+J}?l=-ᔉ*boDuӀŒi̲D0ݰ%N 4h ?+|/Z}a;?ZUחrO@1=G.͛U.hݶw9@9.MXK
 ڴ8Fvu:Zڝk={5F}Zw?N)e[}M3'HhҪҢ͌똮u+X9wtuF+^[)]n.irY4V"xċ5%#vc*)1]H~`\QZd?j+l#٫1@HDDÎ?U0vmB$I֚hkؔ2Yl*
1f9c />Ĕظ7Ԙ?0>Y8<O$2@ib2<AvCjJ"?l޴9hӸ~ۉ7ʉ63# &w5aѐi(3lybal' wlsM
颕 p~yf#ET^%yjw%\݃}|bvϜi9{aAʈnX+]JuCjNM."V)t{0Edawy,n`&ʷ+
l^߭"(Y!p]wpػ͟~Mxw -@;%?D!e^; @hA0㙴'$ƢO̪к}a|,͛/{Ks/*
³ΠrwzǠO
+e_Hdv'ַĜ1(Qi6љ$$^ %8q4G|t=Ü^'N+'6 QJ;!50vr8[;*"S6PPGwѶ;l5
@
f#{}u>&}z="\~
<@UC5_
E-M
ŀ
w!s*rx4@6!d!g/'H$aj&=~Lf7)H9!c0 Q۷@	5}#Mǥ~`si{8
BxRdN1x:n%"%J Hg7$jn+L8O{$ϑyJ%#	w|=^p/&]LU$Pq2hX<ZONӉove#.N{ouq<jV'ذdS9*&BSmپQr|Cu7AE3vΌ8DƂo)yC6.V_4GyAp|;mP9,yѲdۿ$WG`׽dsrސ	g.&Yw`sJzqq	ο\V.%OɄ>7O0{qؾ;pRHDRM&gE34#}zwM._Xb&&i󞸔sIB3e#M/oгMz7Vi;R%o@
J̜kɕNcL$q&ă?hflYi޵bQ+]'=gߨ3~09|a>Ϋ0pz̵[nM5/+9Ish\-aAucKAMVU[k]:',R6еuşM9B1+L
-ppxH<J,0,/Q0s}=oΡ"N2kXć0YM6jP9i@󂿚E~L1?6Cwmlw:isvHDg1 k_k绂qJ	͚sfAbj5km5L(L<u5
k<'C	,!+WKq%D*Gkc,WOH15}kY23ʎuDٽC@ϝ5Ԡ/*ˮ`w{۫яdi\;+%i&],Z!s߸"֏h*؈>a̗fy9nQ]k|Z.J7_W_~ED[e k|N^^ćM& ;~گ|c785b".'>u ya}t=IYEF3'Ri}9*4`郵{|Q"`TSn1
{WA5ze<M啳%neWIK&~Hg52>!W.~кDwh,rxyB9ݨdq3*֚4+ddsbS)Ep*ODx"awT?E\&W@5
)*<xfl,NBΐ:Ehc:g_O#*=)H9qqzh8+g*fH4`IɳA>enQj0ۮ6?vXmɇ]FII6JpUv:J}҈VIg4.&fWy3fmx0n񠤘}|Eud}:.h2,{V#4NΑ.uXwt¸H*(D	j}E[uF4A:!ʜ䆟ܒà|lsK Z` w]eRA)[	VNP:Ĵ:;pv91Si|]_`$=.3$*@2[t<C//~S7X+NV7yo8@%P*E5!-<"u.Lu/~@X'i8s0p~pX#ƿq*ӂS*
4|,
+bOGP'įaWB;#Kjf d˼q2΋s-iɜhLֺ5#~ ޏA"rRIYD
ǃ_Ɲ
?ZC	6{rjmEmN-	A
㬟598~*O~{'D.K-`qӤ{ۣQ֭c,
Xb y>oI|@bC)_8{乀_&Z0~6+~A'0|ؚz7:w2n6*Q[oSqzB2'}ƽyr»uOWh	v+-|u]
0vRLm
b	稘/M#!AV$ 9`}AM~rjB,_u{OYFssEU-#Oq z85֝i胟__60Gq./wBbmg4NW5k-aÄ@FE25z+ʻQKWGLG cY `+RUomԑ^"Q҃E.E"ǭ";gI
Oi,_
ʲ_Ukbq%؏M;ɢfd4Z틥}%-Oy0񵳛49JgtNj}D !SO*[p}jff>DGgIZ,e]ъPiȍvjk`")Y|6hd$?eBJP`"?eP @pKk:T%B{iiO
"vl$zQP g}[$mae6Ĉģ8"PPviok;f HB9cf#DԎ<Si|5?UÇM?U>\{IõOB;(uio<L+O`:Q"xj/c~mk{g"|q?
|J?w_
L\MtTAKB"ک=xM⽨~y`4_+hOhA4~EU+re:]>_3\4sE;PD5x$D6,tV%(8"+Ot*va1gfh	5j2.NqDY0%zp')֊_zX1"ʁ0eP;+x۴n}NU095wl\ڂ~-.bڝ8mdik6Pɿ$!hC H{|)='sw6KqZZw+-U=`3:ehf9ra[dUTV~n$E$ja-?_K1&U5ZwvASx3ijgQnbNODn
KI^vBżKbw|
7 a
S=ɬ<"ָB%Bb70C31<Jt>GhLنH乵5q=fqDuAf<F.ӯ64,fA?|ЃQkcF=5ro2A2*hJ!UUo"p0lG%P5Y& Lž\a;{=C-c6/VVP21Q{w$S_֎[^2UU^"Qe_#\H[ 
 2F ͽF5M2^uZt)*1)Fc
,EC8A1БD:9gܜ	Z W=pu˻ߧi#g[_
#@:{&8X}SHodUdKNJ4"BWּ8=t9`%-Dr~˹Z|۫Kl#0{bj	M!E߀F!NĜɇ͇qbI>
ػA0Ta&
ȶZٺD{H^Vk	CAd{ntX~y}sC#@ݔkn1[?7bSe_xHִM[v4MXt
gz&e+@7kj7 [0^_  y"̆j\C0g>`:[ShSe
&sUGsrZnP1}KNoxHɺ:] eyE4ZVjB_1ctS-kI㹘<KrETN	g<ܙdӢB,s3fm閺y0!J{!+_F~ߓc_!HH]VՐ͂X>}֯b ŵJSq+@zHȄl w!z=Ѭb<e7	(h΄/<ikno#βɔPMp)'*;^>׉%%k\
"@@7Is2k2aJM
!鴤	P4Kۊ 0f\. :;}xJ]A`_U( M
yO4m4P͹s4Ş;
St. ]pWA<qzMI4vl"RTIݱ5VAroE9iTpP߳Uf|?ZD#
·-A]`=qAs5QZ)zJpj _fz+/LrtҺQY*x9^xwWw喑X
1H/#ꜷת\5.ah9	
\Z%@Lg1fD-wꜲ0\T3j1,Π,X(=
RuH1GAwk'1e66 `XU7ͲG	}v!'գɿML1pЍG51(EgBEMRBlA@~lIBaDXN;*nz23;Yiv3
9>K^b9eغoTC`pq;ȿy
1Ցo\P
?]%={u\Ա
q)\Γ`LD"L4Qg@P*s&%eגdXqt<w4f^hMĖFsd'?9̛;[٫q31,(W-^ݵ4l}nGy
++o^~?|d_q*^} rCx}C
zƣ>5me=clHuQAț7RgNa$~"_4$YϛpQt~2;7$fB%*K@!Sus偢.X7
vS;`*aT|D
T"ld!^"2v[eQ2tt&@_֎g٨+#66~[K}HԽ_U"d?
k7WjJ%:w5KI$6
9Cػ%L9obv|FZ4ڵLsVN$6uJ`غF۴3hGmbu3w\o,T}qP¿y#~KYBMƚ@gVL|{eOq 0lt'1;H7y.TaxwM	Bjj Tdמ"
ک[{/y<p F-]IcMx#o>UUv@Fc(S#W+<ȓƠ?ܩzmjMbw`=5qo4U;=5D!NO>6xV0<.z{,R1jUhO;Xn"nv%IcE$͆S%˙Zݏ-*;2)NP@5~]|0>h!/_`Oz7םv<RM3J+naV
Y=HqK)D:5fU$صr	s/|W&Et}u{ =e9hql	044iHq9}nब։,_j;}q(|KuR[XRrJU>fAO(,vbKRL 9LpյN/ONOUt,
EXG4QX	7[fDM>~ݝ->M3t4uwrբZ&((x,<b@^w|qbҘj4sjrT-j*)sO,|~*ajA
o h4xM	$Ps-
xݸs|ǵ@Gۛm׺å>T[bR97L;NF=VnB|}yR|TkG\?o, OѠ4J)h1Uz
8bYfTRVI[3쾅`Nы[7
u3]T3ZN/C2fY)jQf'}51Ӏ[gMP^@LQɫ4u<8/egԙ7ꁗv{t?<<tQIcF+2\w
+pO
aI@gZSB⁝+*X~˺I-0흭?1R*W#q@kaۡmTaC+!;qοj-ّ܂[6e?{d	<1,Zh]#O$UMs-4 >9
^o8jy~),,$%oFB8oEo	ԋ#O:2+WQo**BZJ}?>hƓ31XDMMO}i1KGY
":;wܖ swAݎ2er5^PB>&Q=lY:W\k.ﯙm"cʓ(cIgIb	i<Q³ht(dQ-%P'(NN}:˯ouU7Ł@6ømK!_ɜ쨀@!^`s&`^Cbg^	e3܇wR#lhGj_^|HtjV+Ȫ)sɸ	tX)(BaIrM|.=lEgz^dd ?KHG7>Ւ:<]AACHV|@q
71tgcAqY㩻/1yobGiPQ
de' 4AP;
lpn[ RbQCcv"}][<,/WY!,Z;۞[wx+5O%PdmdcSbLjFB"S<pMi^ }VYs[Iĸmm3?ՙ<]or%&=|)}!Z#-CTύo_٩%Ieb2J"j~7lR8d?*CSP/?95<7)L8H\tIzF$ls=d&kjB+#aT
x%l)fD[<!;D&#H8XQ9+Iav8LZ3"R~,im1ːk糮@?
tnwz}D^RӉ7zx2غIr _#*bqZQdAvE
qxFAYo(I/iD-7{$WTխE_Pkzj"hK/<|s_3H,\uR|ֳ"aеGR?z1'
XgA>TCf.^{Rq*g!Wi~rZ:bkfL/H4]Uֺz$q6
d޳%fw_ޞ{!L.'ŹC~r7xX&!>sz	0b'PV4BS[1+#3c6!|c&Śy_;iͧyEH.rK:g+ttWK}R+PF-etLK
@yV}M鏩"Xx*>Z:oo
VjG+k@yewBԅlwAh<%RkGPa6ӆ<Ƙf<UP !v#z/oΓ?6^+:#Di,
cS"uDʒ׀-hNF66d̃[^|jNvOIxXpo;7{%I$li릪VEQ^Thl
[''ʈ=Q\hfEA?[AؓI<_gb:\a	w·oXjRTo4#Af(|8m=ȦH-8Sc	*8F{g:9n4}Eg
vPWq-yBGՠǬzHA0~=6ޑ9^=2aTy^M5G<*Klm\}ty|wvuyS*:'
S9Įٺh-HWyFSs4$~셱	FYq 3^VpZgCo+= 
S~~" >VyX/V-ZűDǃǪr<m6)oШ+<gga?%4MK1MW]]W釫#t[X!X~	N|Pp~*E J
{
'ϔ9Ɔf5VqԆ
%ĸKoNrZ Tp1^#NPn?mc_ln.x45p}55CU!IU
"ݶe}oV( U6DíldY<?f vO_ȕ\GԬMhq'VDu0%Zĉ	ʗ~Dxۊ|wSi~qvrr~+{~Z]Ibmi$U 5:]Tk"UHPi>Vjwo҇dJ^ndV nOF#^I;T5A0~շBFE1"`0A[,W>SUƼ^Hjv
s,b*V}>oaՓ8^Ҡn߰O]޸}~綗U,!#66T$kYX쪠+6yΜW:.#CG4cjmsw2S |"_sMXɋPy'#}\8vֱnJͨ ?類]AJj=?>mvcA]L(T1WYŗԬ.:,3}(C#h1|&b20!O	m>UtRnwǡÁT(L&~9⦻9zHj|"]ef_HmkM4BcR&~fօ≠u'~ 
ѱڒ$ L4tNUH?Rg#ƹɾ}n*2]H\T¯(MX&;;>,pCU{ϔul&4XcM9Ⱦ+	ѫ6qu#ӽt'w4g:O=G-BL>gnFZH-$_f/uccLZC1aFVK9#*vUw/X84\M\Ms%O9]]^nOO/Ϝ'(1
XM9c)ގ΃<
|^
2#*+wg#ǹ@Zܧ"-4inGm5#_HrC<Q?F&Ĺ1"	(棺u9_
?AMI.иU2rzAXU2#eP
nkCehQ#6!*'P5
 7rߢok(|kmssm#[\![xk>E~F#+=}Pv,iyIlųkY
S<=g"9&KCqtQ;wj<s{i{y;a@nb?"+A4!ePbrI1TA*r{\K4fʾ#qϘ۔ T цT@^M[#A\kV<Q060B-6]I
niyt%m=?[JD
W.VKp$N<]b-̂d/@eCHT&s-'oyps75y9DLJ.{^-#Er w*{L˽McPQtN1n/AZaiW$`)ad-w?(?d5e	a·!;UpA&TTgofۯ_rOǽo['BxήIL4mŬz$Ŗ3~56\`*
)%5R~p4BrP>>gjW_Gꛈ8'aoŷXa/nX}-$maǲKWͧG2]Pi>l5ZISWgE֣7Xw [Ү?p.}1Ocd5u,i{6Z
NlBbvY[FDĔRaITj4
E@ݖF@䆂BD`b@3Ch(eR%,G0	2fr;՚q}f,OV63W2βZkP 	=~ϔP*G;N8E9Jr+'+B8Ђ<}lS%lQA5ةZPs(ExX
|FG8AEO"L&&]4&]e˙/^JVF6 3+9FE:EbC< eC&pLϺM[s}gKW6@sۻքѽ+}#uOͧ
<E!V1YZ>:ץ<cgwm iZ#MQso<fDIF
	Ss!	M@i@|BH[k8QX-nnj	2zeig,?t`)Mƕ˧:%We	9Ck*j
_@IDs%{}/g7w7^:[F,ns7ǻ@H+;\p-iS}oxG
ΐSOr$?n[wdO22u7i*hӲKH8ji.rn;
fB9s{ZJwn[m&y>P`Q!s#)g=ՏOV3ه~(>)Nrğ/M0^;A>J^V	>TfƈLLH-|j|)zC>Bl?
m\bKph߶FV,?τy{ft:
HBn>sRldsv#*@&U5seܥW M9NCӐZ6;ȮE	E,;ԥBg$%ԎNf[S2.܄:Lw+rvT燰܆5@D
2=G1n Idfz6O!բ>*p [KhZ1hރZ}~2e1\`ObM}TG4ݵ(yҔ!7L/bva(UM!N[(Fn!MI6*K%0РTh4j7/ttOUl(T?|@j+L
1 #BI}֚Y(Z`+"dry.WZ?YwsPڬ.+gY:^_RSkdi}<	oLgF)%ɱ͋wǷQ1Kz.(i⋤yS``"ۑ5'UcpAlTڑ9U#QJ\@ sJVwq~Su^)"}S7bW/O~)>=M,$nght/H?=u֗1,q蕆SmO1ۭ4DO@CM~dJⰵ`8RŏLúw08~xp4rۻ;Q(tf>R.s/tV~5-LPGg"zԚo2	57'Wc*iX/^d،ׯ<j ۧ@x`d
$];[
<:9>=>:>:?!5v{#>ݽߧ*(uaƷ/]DL*<~#M
o"o
וn+X4
K@ni>oN\+KN-f[miOYo4ӣ5svjf8HCawWFiͼ<!H%A.'fj9TQoà9%
KYA&*B֫լc{
g0M_1[V9W(QCb$D	kP"	l]O(Լ({!*	amjSw#c%QZ,c6ъG2|XB/Sg:EFFnN_yNÊ{
6 .VW H\X[1IQ'+-Aޖ$5ɭ=ޭCZBDhV|>apXs׬s:!KC<
~q-ͱ/į
_?jB@un9wmf9ߺ0@/%:/yqN2_g1XDgQ8Ƙ|<o"^
7>!ό:9۫pzRIRfcgjwvn"DqҝbXYy:M?ﷻatf	k
f!&Uh>Wu(-\B(`=cJ#W̢pz}+[vU4p_Gܪ^Y@..%ph7fh>ί؃kj$bӋ-;{]BWySn^]`ïϋ[rdSU3`޳X潸Yk}`I^зa<q,L`2]D&#WU{ WvO}c`/;Sˉ{n
H^H5,3׀{oC݁TQ
8U+&_t×ǜ&_c*-LAq9pSǻ+;KHЋ3SD^;?A׉~&Of(n LyeQ`UZB}i.GO.>`iG&wu_}
Qͼft5~0j$(T{8ɘ<bCiY ka&\m͐Mp"E!rgt_pl׷uJq;Ė!ܑ)-~* I1;ǻT}|Gr;A0{ۦi*SALT;|>>:3'A|dJkӛtCyusq|:9AT] Cv'5ܼCNDΞ>60DT80?r#sYph+Zv&#<1e;vC_!w#p)ߙ'}z_muC9#iɽgB QҚ] +X7>n>
;~K A	
::h,V3:ǆ,cOč,1||<4O;<y,K9v*7`a3A*/5QY԰aZxZf݃
8b.RvXSZRstȪrz2:"kpHaGZ09[L3lQR9b옟-"CВ<Yxķtoa
,A'l bH$-"*;FEFȱ7ٳ[o(*]ϓL;{[U]^v楧sl"QJb_s![}8:}=Ĵ' 5.OM4U#&wF]' Mk.!GTnзCU.	Ks-H$^ylw#zs"L\2
Z'!i,oL_8OrɊ/#[Y/hr5<V(WMt{rWczmlZ#Ql"vw F|&@wέ*oOxv3y[>g-\OHj3+;.Op irxnҵvWrEq=R^{PHh9J7]<'
7F|#-GKfuBźʅ^ϛX؈"G}3K/1յ`P0PM-xl턜HIYlA>X>8ϫEtH}+5W#tW*%^{\A*/q/л#ayLbu3%c߬ bǫ=#mDE{E[fǛ, Urܾ@1C?\{&`S1
8PM%d&?x`%"L]MT2n~iN>imz9|n^8t{WjHp`u 
	G`xKb?ͱ;ލHX47UҐFyUE-fl
WUϏnԑ;.遲-L>
֝Y_q䄖
	_և{li]M=ր9*rVjZlDe"9]{>|U5
'T7SP^3iǜ3# m!"ؗ.#`_,l{w9Y`sJk#$sr7vB@! -o$ ĵϏX-xR-`$_"(9Iސl6kD1sOB0Iq4g2sg[]ω$`͂JAt?U}DA7=2E܇#57O/pS`P,9:~ZFOjju#dccǣn`ġ3#QbsWq߆J!P2Qϫї"ֶ29p/I&ns5i,6cjxof_q
"렬\/)\~!tA>̠h+\`(NUvg	-pw1XvՑ7wG6ݜ`0춒ǻ01۱o®WI/!4`/&f,d;s Q"@^OG's0 5``C[ERxlm%;H3&A-ɼu4LFp@	g
p{߱(%zV,K֎2
~j'dM3=ȁd-8wi@7gE9Ğ&Ў;[ Ke/PlmFfȂ?۲ޏ4ZԿ揣yRFEc0+~fR8%C<#ڎ6ZF!@#U[Srݼ![z6{# ɰ]LœiU|#1;O\8XB(?z̐Ri!OhYB
/@,)aJw]HC=R? +jY
I3Ȼ!",yo6	3_SYtj,8*\g	P7x~b%^v<ȝʥq'8ZKykFy
ߔkEaS
R*SwNcMSEZt[?]$+Md^$.R("`]UV+Ƚz*io+)˃6CsҠ1|}|A 6+kCV r 
}pg6s]6xט~23h3⩬?	Bxuv7G^<4|nuYSo
_8+a]XmQr5Z& jY!ud~'(pz5i47Uri3CNj:5,$SjKN_
{;Fٰ{ ' e?lh|d"<.#d$>чNKLIQ/#<S`_zOg?+1?W>b,9ǘZoCUt_xwWeN7'X$IƎjU}53.dQ0RaI_gm0Pێnu`)U GjJO<8rۋm@`y{FXF2|΢1u #JÐz{uy}| 4 dFp਩"(q4֋Tɗ3k#YɮooKR(L[Wv,	H	>Q<<7=4!>[o'ZPs}2QRj='oJɂf-'ivrQUx򀩖QN2f>;SH"6>E!Mts  ;4FXINr57+(ZaWZQ,g٘s]v̻$)H@lNP夲Ni^.'\Jrhb+ZiaWQ̵Pw)M?hHutq Aw۝,rIpOMD"џ?90:E1SӰR^ 7Bw'՗I|{mȩr-^ڭ:Q	8!)mh	[	TKʹߡkKci>p]~)"
6#e~NNnEcm:1zޟmfi?j!  Y")9!I#2#iAL$To}S/!j .>CEa߰
c2Z<C{kht$$ ]ֳ0(/s<=zO?&̵ΎnHAE<19S,`EAoraknm+TF2Gc.h~,r.nIe<t[l*Ml\1ɫj|t(F\EYh`˷T$0C	LU?!; =KX2	b4Ŵmwc<o"$o/fJ#+\wyu+Ul& <S?!$q_O-4~8an{aqshԫN T=zwmZ;K[t?){M#)։X12(;6oBsY- h2͎tTpMr,FBJoFSmJ궲Qkk'
6__	%fЭZ<4K9\&c\So:$}lcܟZ:}~G%	4ٰ+y)ؖ!+sZGƏ~yF}7ZnlJŝKcv&h̺)Qٞ,4U,w	
Mկeͮ^/wŞ=̥0ZC
IksǓ.}z1XjJ%ؘU<	`{*_db!\1u $ًD 0jvU~=\roa.ahiۂX.f$d.6,m4nnB*I3c>;NgMM6.K9?-Gn?cHj<'^%\cKn[D`1=	8vg^J2/Lb)}LP?tqM,+C{z@$V)wM,	vtw
wOI(ʹ*
K=çv	;ҪbAYss{t}%h'A0#IxJBۤϬ_ip*0oHPxwip9w	m8"\b*yq	|e޳8-Pr>x~qMSUllCJ4̮|B	Y]xgDg	dj*qNlﴚr?ϘxtI'h%F{!Svk_mW&V2;ئƍ	SzZ}g͇(j[K F0(ͥ8B!/Vv4{QyZ}Y*w೏,U:0\3UiO \@
*ĝ5ngeU0cֲ@@}g~,]buO1zAPVaH0nYȽFXr޹kF
99:Nݮ6jɱX`UPD!4h4m?
}7$̯Q2(O']"U.$+]
'A7(C-EL ;Ѱ"0kiLܔ91$"CբN2THPKIܕol	?J<eA|[+
ԠO$)>*LRO/aFh++٨ZEE!.x麵#:q1;(Lb"/n>BYE&.Kld/ot1-7Bw/0]f1nJY3GnL	i.P?+t8_#IAA~c 3y)EncL'&\l˿n4tdQMi/ adJp5Mz,[-Eպ~icJ`,QQ%iatPpqV]@v[ >ʡ]Mtz&T'
QhZ'{nΤVβ)/ta_틂z-9gRJ`DV՛Y%|k	B.ᥥ
WiX0}$iVA_Pp,u>QL.%zVGvKUVHKU7tqj1|Gjb྇ ?첩<DdBSI6j[K$GOJ0h}HI{N#RZyRLuH+}ВrT,euł2{&ecjZ wSyQ<Ӭȅ.S2;ḽn]I5Q
{D$[?Q,,i߈Xd5+ܥ0ܺVN/m1
Ȑ&ʉ1NdFej3!0feqٕq:FLy1pz{{vZc,O	MfoCyoe62י!{"D]E1dbVN+'.Yr
3 Y>KG7nv,I 4oe457xLV(-jx·UxΓjv
ɳ|N77\H_gg52,U3'ql^QxNzm-K;y	sqy΄)nb{.{׆[p5^-Y3uuKLl9Ј?KkKy=,eZ~R/f?7R9?_ӽxhj/OxJQGO7/1ˮ|
k(pi1sOl;++nO,ww/hwvrL{(vfmޔ14>!ӭy^m"~?QnKaʜ~eMqΓuazХW̎]fs?itM-?J}moQE/9vH[8pf@iL6|Y$K,wh'X7x#@U~dι{+n$lD,n~*yU@l_*մ(|}Jq2Sr#	>6j7(e>8U.5pf:"
ೢ7<%wyt[H*Z.iV~`?Ϥt ]G+V8	R;rwNIZ&zi7P\M
ޖԁ]jTH6>̀rpQ1c#TPPf\:%sc>Ul.*Wf,$fV~Jak8rC3Ro	Ia2<<q@jňEN@|J"<hJ
WBg
\7i&tCޜ*93
eWvT{Dj@(|uGe"i$`Z"Y17aj^k"쵄<lIe &Z	JLuM$;X!M&U(Ѵ-|nѻUZeS]Y#UUꈨQVQkH̦VtI2(fwTNUrTxkT|%XłZ)>XwErOWJ`YXQ_l4،utoӯ
msB$DQ:d=Enʍ;烯_b\.^iggNȪdtdZ%[N`%<n.hN_b[P9&JK^eG^b3~(b?R2Al@x[Ɵ\C5:

̎c7XgKw`ǥplB
%i;fUn؃F¼EL;OxFÉ.J	wG2䑞>$!0P;))9''rWjCg[``Bp4_5G/>rQIvt"w[&7-e5mQπLQ8Fc$;}$SM6~k(J"qs155hw;2@KRɺh,_-AqkDbs ۺyR77TyVvpOFӵqWʡƕd!PUE~]'<*fsn9umpK]F87;;_3a?nA6J*#l4ϰ3hG^/Tbq(M#f$k'zKnh:L5U-+r/څ4^,3m? WؒwJJ4@#ŚVG]6_}*,cX:Dq9%^$߯IϰOuVF5_<^[ ~~D!YgB633GkdW yoZ{D R
ܟ/r%|_R=UWؓ^
@d#|!n;cɄ?i'i.VOG=:,6!V.D^Ɛ ɇUj^1{.cLPO)[1{9Q_Wb4(+Cl??:kE*Qjļ$
U&G|*>hy18*^-xg8~Vt:"$ҋb6G>Uw Jؤ$h[3dlmX49vF"D^s!<X>?Vm7ӓ${[
4Bh)PM\D
%IA9mXH ogaj&M*TAD5¤|saj
/6A'C>wcHCYc{%E46sSq
YPjT0eH_J$IXPĖOGW'ūz"k|<k{MpSZcQC͖y
R5	g<Ӡxb-أk{g?4)Lf)9_	[jZeBZκAj_naRp#D#ۜ;ÛqIn4«*F[*'::>}sr11|y0a&=(Whv76nn2V3]i6.;^)Teq/-DeJU35*7㕻Vm@
\Zxf`g@q,-gS>V
bQ} Y %
%*Vd/QL.&e(KY4ko
Jb9Ǆ!fo=D.zK?~ד=8t^vv/i	hqc=T5dOxApco=,;.ѻZг<[(b `r	ue>
Xgz=77NwwP/v녆Qz4]>k+S~@%hiNJGP-u,AY4hHvإ8sб ;.WIcc;:0M-6hW`s",D˭V8=7fLA0)MOC
cã.5ߥ)j</J|XgҔ@P>=9A<ж70Ygd/Hkh#R|%1YjR"|P"P͉wkb;&}." 5Ā(4XߙO;
t頤!&߮߸r\$sSuXx
AyJj,摠EѦlFRL!F՟FK՜[DXश(F\5]1\Ep`շ֋׹ ;'@2ydAͭTsqHhRM~i9$J)eovB`[a,fl̎eX1<0F#VuCWD{"0z|~z||{I6}b,4а),,Bm{H7kU∈2PK93O@\*	Z.D|%cc@ׁmdt^:tQ8L)؇b*>`I@9FS{H
ic\Ƀ[t.d<,௞<	ķD?ZS$)M{@tg>*S
6䔍z~[B9I?@'0RTݒ
D(x-s3"n|"g(/*&m~sG'GOu(`?vk:iQO6?~K/bGkS}|brIu~])<dCصѴ.)b#&4ߜHA|@lAZV,H[la!"D*?g.xN^<9]/z_}ZRnttu Q	-E͉URdp-ӑ3i¾w޼n>rpK +aY%$N ]Xgvi2tA%1d+\R75z$?B5x揋YvQ.`>%EǕa|Ӆ~hetq7 bŭu6pU*
5;N ӝ]~C81@漢LZw*} ءYx׮t{#BFnl_/nC]ԯq?&P5q{Z񸯟n7kA0*ʇ9Ƕ_Y,Ohnl{4
8#ܝٷ,l7׍#^+a¾HFeDA <fKm_I$-nTOnn-rig-GFzNtȋrErۅƃg n}y-
cB|OeWlB5w_N1nز=egb t伨j"U*"$}+	"ƴ%eqD>_M+
v-ſE?rR#HpTV!9/z$9HSnAzWBVH+_3#S$3OשTFp|:n" *0TᶾNxu[}y`|d(-MBYF99cPCՈ@tw	([>i
==bN!zFٚ٭F>$UXv6kpk&abxب>;-?}w۬j4Z{(jg+b!݃v2+jiɨb
tI΂t^vtiڸn\@RKl>A
q5.
\0zqWƓYP2k{;xDM߉{R;[y
)NNj#OXpސw71#A^HM?weC#<S%nV~W]ˊh/E4+d[$4>f&ç$e[䦪0@[tsV{,mWq1@v@і=Amڑ2ţvX}R{D+k'M-X /MVzWg]٢-n(:9盹;Bsy@t$F+)JhnŶ/O`7bޟA9؊;=̵<bAg/EV%OE#`F>2T&KF!~@nBb"H7rNnn`6qM9ų8L`RZF7w@~G/nQ+L]^*nk]zʤzM
ߍqJdez.}xRq{
qS<`nP.ܫJoD٢pcbÖh-&<Z?7":ցM?ʠm!^*ˀƣ2coM)Y1$/hp%mv 
;mi{9_e73P+bAXI &.%.mz>vڥTPs(֥o4֏
rUNOgsh )P~U͙*Y$))O6'.kEM정Ie5a*7fJ$+Ztl:gޔD9Nbw/l1JՀc5Lr=p{SƏ>vZp'`켲[n,3ɢvhL$J?"a7{gWKߦ-O}<8wAؗ/@kZ?К&Zhuɛ_Hw]{WHCΗK%VwM&ɘJ
RA9$M9/`cDo(>r=hV8bluT){gAmFŦPŔf|`2`a[2èht	QLLv^&uSie*wmlQ_/&MGeւSڲtWvw=]/e\XڣReWD4OuJڷA@ϓ]ZKۖzZ=ͼ~'<0]#Y΁?XʁjF
NBeSTߕIr'b"R{1TdvE/00b;Rðk-9XuBRo;W	'vfwaf**,9R+\íhQrl(Ml)[|ew:0ٸE1y"jgل^5u2bA&y u	=ٳ@
pzvIr>1?!S7hapAZ%;PaUx}KqtYJtRjRpo	zhnZiS&}6QCzE6qg#vR_xImϕsO1WIʚHdbP\Е^Bs Tj
0;"4 k(E>-ިǝn^OĿ;;ljMOa3;
6٫q/L("{8Ĭʭud4*ܰAI=SxB+R#hl7G֧c	,4/UAA*G,٥lch]Z˞ihr+ &x)֝f3ϱ幮dmXI?M -HVaNj#6%QypM_o`_%4^ztrPP,z,IN .k{V)TXQ9`0&7&\$V(7?mBI#CHALb߉Y1%:NcgX_AmՆ͇4Tջ c kUCQʿb7B>7QG-I&@* sXIRDZfwqZD:_Ǳn`Mvå3+!wee"M ZRB]pND^F)ˍp\1jz삃?eN_{>C ԕМ}Vf}#tV`'Jks8l,.;B0\{1[Jn%8H
G/+뙅Q۩w;pt}r<ڠ唈d4Q״5==R,q[zdv-BL3+)mLC
8z}v˧nE'Nܿ 廏؃SLB (6Ѱl{ۙ`,GXTk,|@"";tv9Ev~t,?};OH~d!L
"Tm
7a"6,L~*f̅jd:\f!)	dewC
0-VdU	F2?ZU9{BRӐYa"do4>F0K[qH<!''x\X!#U1dVSJhB*% wU%ׄM6bI<k!Lk	&3E"%606};L]Cd"%f§af&|:AMJ~>
_,h|]s
j,"дJ׌W:7tHz%OWcd<!#dR\ހL+Ï2i|.R^~2u}1|Zq\vuM*w+dobTH{'ѝETTܙ+pȕaXNo^)dTc.tſ-7dT.Uܓ&N)oLWFfx0N\vn~@#bo\m!Gn"+Sx_)s,z'}A%}q8^aR>àEr,%Y`++ᦜLǲ.^Jg{jӰSɝFSb6l⦝5Y^'Jv4M5֫Yepx֙x
C=o@@meůCs]^۳#cF?
4,fovg; WH r=?~P#Az
{ G
zMm
i8Rؽ谊i'=(k
BWm4"}n
nz*g(<i61 P)]Y
f)D9R iTKKwŔĝ\qrufkHmz#(<jy[EtWGCƵ	<VW(,ZT\y7آ*ngQuw8Mg4a%Iem
QaH%":7צt{%zM2#ȌohR>Dxzˊ|jEnv5!zEvVRL v$'KhvwQ,`*1f̴X u5n&,0xO 9d.OѮdܐr?)`0nX.jmτo0l/^]+0i:%aT>
jvw(g?JN쵴:nTO¯FhzCם?s%6MGj~[-܉.}b܉>ņx<lzRϋL*A}kw?D$Mp\+d,w6 ސcqąB^ZEkPaw
qs-ATtz1oced
ƌ;'_$tthṗlY^ձ!fݢ{U%܍c?=
#V&+'1\Ȓ?mzެ>KKZu1T`zMF%]>a=%QZ<_Tjwn! HU
ۭ%n t+7Qr%Gvsbbń5&(
4.")?E.{Rait~ln%r;nw}&VAzɌu [?:Zq? nh{2+Uih&߼֏_}G1;쾇M^]n۴L'J{0|GPxKuE
'n'4CBr̲E@\^c
f)d?u(BʔQ܌ֻޖ!ьVd-"/Mu(96r-KLyTqjJFm=x|^',K?pqk>p=[uW[?7"S¢
(uXYF&ۤVDHBi6d;E?n%}3wɨy-?N*ഴ¤(ʯC0LQҊvK9&3n]!5b'	Y<pe*J5`gıBrqKvY2LJ5wMUR~m#zv@Hv 6y`|S a+p) ZM=!hT~")}xh9h_9̉>&Z]<`nvUPl[34\"Azhe`>
r<~/p2c¦iINWl|HFO=">Pplv){C+>d!|[pnJ7']8곲n8z9س龉^x7\4{BuWVnˏ׵s )}YqdơnN 4FN('z\`o$J֣cRn+zM/S=t}~j^@Rq$;_pQ B`%ǐːM9߾
.j =Η*MXXHLSj3q%&weg.ޚVgeUNGC2\k+{]	nb泡s[߇OFjv M[d/4wVJ%Zcr"n0ZA&hYU?۹BI@v%"V։d!ւ ͍Ʀ=EqXY'نsMf95)(̻&pU
s5@Tc$bH*R
S@ܕHef
;:J?$S[!hE$(Y;*]ws^
xWqK,Q
,.t1[~m?^s~ut}t?NXɉIUļ
1&LN7h,/I6b(.DjNy6^FTԋ2&S⛟ñur͇꫑P|U92>s
% ?P!Ln|(\Yf'.R6ݮd%1Ҭa;ǿ:t%(
W_۲dH+2!sf*rZm
щâN$cӻ*,uE]wR,@lXPLTGiU5ގI,j*RPu$O=zlۺm%O;?MGuRimMb$@bqzK=Zgohɏ_:_iӝg戕Ǔd0Y9n(؏R[_7˯oGe/(Mc
[g!͐H$	i`룟WO%FuopWP20:j7*>۠|U)X:@P-Ю	hXD
r7';GI1|X8gWzRo5[ 
z/z\Cy_,)ts_U501/Rѓ"+:Ȑ] v^KH(=фP>GwYM@"Ďw)tR 4G#QGXZ|GT"*O{JpFlB 5kk&T&%?9ڳyg}(>|Q--*D+q@z({$K^aZEBmCՍީ.KCOӵ9q
cq)];
Pyc$*CnK`6L`NB\τ}-*˛_";jL],,Gyˣ{V
$c|pǃФL[ɪڤlhO Fa+C.ͳ@CO0E "Ù}, r?s:)%ǘe4C1IBV=kLFcOO,f#raݵʂZ+(A nR
-b2b<7rwkaP
1W}|4Ƨ'&X^M46W tWSy HH3AK^mwJY@羅jr~;iZx k,G+*_0
z-GؘVg#QnA'Mڦ"^^ԺqƤFB1T*DC'e
5Q,||gT Ev˫Tmex	'\f,օDGx*cYjxv9H2E%+KEJ& -o)obw^6Z]MLū=YLDG[{F,m^Ij|H>.Hj^BaUNG.<VvvmO"3+#6P)Zӄt1|ؔ}7\Ȕ07 FgozA([
e2-FD۳iHNbj6WBG3:bT=NHtti
.CƬ ¸n@Сr +A&H_.cP_\`/b;(lB`S,ofaݞ201U\c (L?1)S+&jy)o]&4cw
`"L0QYB]Dὖnon!wgZ
&QY}j$m.j +COy"꿡m#ٿ~)AdXlLbśDubU 3rvzx,7nqRu_|v'&e\=A~;zXLu|2@y+L<a/ѴWSҹ>ϦXI:`ޕkľ_>΀V.$q"65^)̇rAh)\Tl'o?A`R}+˻r1.mjsB%nzZ.@({4C7 s^΋ lӟmcﾭb=wv=Y]#BˠHOQqmmEڀV:Cn5۝f]ۻvzpѨdZ"|MBe$j>iz/{ T,aj0=T]V{o4@JW\]T:(ƾ>Y(6|QZ+[CӋ1k/Hv;fJT2u	4ԧ,on枟rOwJ:^<^QʈE:ZB7&P5.u7[K%/ho'ʶ-ΆAi؏G#%8[S
kV/>w}vJ{gmAVzZT=j\PŽF\ÀuK)W#N;N 
\g+mie"&Ak8e}S!2QGBa`]RxqGdm3ZG#An{38#(#G_N
$7Elfķn
'X2.[e/}
(<XbiC;FA%P*=Dk/Ƨt69 1x[L_ԭ<2fP`LJBIuPPoqU bWoX4+E$^~"QZ%9z*7vTq(纠(ѺqE:7Lgs~rD
'I]VN+|xEn/~ti\}[CQ1M6GĠ1(mbYB/BV}cDՂ-!!=~۫]H\LRܗlѽvJ׶n#ge>ߋ[~ml[i&kfl.?$WRw08.WI
^#aH4g>cX9D]$^^G>g'.{wK~|y~utD$rǛϢM(̜Kk:R^D	5;վFzqug=d#B%ăfXmг1UX,"x"y]Ŵ1!r
fܳ0ܲV>sͷe b&,>`]o۫'C7e	=^>	@ǦCJY0	`<Psቷ	Y'#"R{M^#"dX;dR*	h,رW;斖EZTݻW&j
A0{u$;l7$f#"8 =|Pe̖p	.Im9nH/2HGƖR 6i>I$2nҲ	3&5|yw*B 3G@ΐ+RFH83Rl7wfjσHd{"QOiicDmZq;wF[}B'[Pwr;X$޶6^ڸ|  ޔafhj'eR&TJ`BNua/[:!j{+ixlW:F=+FC
Pg Y_ƥ[\foHټpqD+f@ :X	ᩑ)U[砄3E\Z"L4uWQ2|8u8%4'p$z*ts{yuz?~<=:fqqGTBHbEXw+MCd_"*8'5Je VMD'%H~+2DD֕ƠsfLf=FV
8/8Sh4"G܋7G".u0 E1VÂ=1dH  GO	(,m\`j4qMGj/DFcc;
~oB_
 3rbXb5ٱm4xdk]3Bɋˏ.Uc(I!TDl,LoC2)BhW
P~ 
N /7仺KM!Rt5=J yBsU'
 Em`;R߳s2
],P<W%xcC%rc[AXp1C5mbj-VXyhFQ|pm8sbWޯ]]Q~{9Zx$M'r*
:wn掷|
=L|֠j/TE.)Z^L'{CJ8y-IMo=!uFr_|anp޸CVqɏo!.XoR[+WINH$vxg-E.C2ʺ"#I\>IKx-æN'2^[jݖ!BJ#%̸T[x/ՀNX`<0奀w5J\#DOG}2MDS3ҕӻcq1~2$=
ovv	sKBMY[pNs>J;.OO&&8o7gWBL;Z7)u-Dz?W7`zw]h3racMCn{h `ӍϘ^gRzC֠K;ȱN=G嚫`ߢd-f3{xTLRpiR<;_GYJҦ!m,V%"B
ɺǃ8%߻OpҶ~X4.ye<o|vIB9x^VU5#m|."ISQߏ[0 k{ w8(uk`~	Dz/ ;XV9JX7򼷤 QaTnQR+^Zק.t!Qx($gUfh/W|-/wd?\|{|&?DV~1?jt:Y

$8FVVq=NO~ x3298vADO9yp7~ Q)QI4"mឧQ˳&K
54=O#A/!iE6fY3M)n*hl \[lΉZefp͗ޱ8 .RS/TmG~EODڹU
}F.F󆂺x՝(+Z/x27嬎ARn?d?L#*ǗG%0,7`K@hf]`Rob)|WF܉,	 woꆤx/u54Ӟ	kwFo:ptD3i ai]ҍttWze?b~8`~llG'8eΜCç3#=Z>&HPѫ{,%E01.C'PtQ^~,<Ɔt3bD0X͘J`H&N$ht+ǊgĬ~ק'g7y-]K<dt w[" :Y֨1c	zH8{wgKs-q$AehN ǅXwZ8oM7sggҚTh7 (,l$Wv> ,}aA ^)煮脐9ӆԖǂKz| v⸩]'#X;%Q_6gUQM+nnj\m=C2eƯ4VH7
/ȨkjB1ٱUITsrT5 3Nݧ\Vn5!̊:gjYZrd,RS%jhvp =bi	yXù5ʻ~I3>'}P$ؒf5XW-}:+B,2v(΋E5ɹlY׬jQP6j1d>"̝64+EnMsts|v/ur^-D><h{
sJXb"n*g Jy̩g0Wn$ZG!%A	b6` 
VQrsHq
P4}un}
Ep0;U%}퉌.U^8l?˗r;PJS43Wa\$sN PAĊ	&,vq~ST9gHp)1x]B`0zǢFN`(4:mΖ $QSqG
F7¾5$|+脴Z U K2iK<HA<FANVVb1X}D"X*"dF:nCKA{1`nn/O󣋋[1,$vkO;(*
n?5u}fVTe*G*S6DiSkW'(qDZD {=WQ;k^Ƨ_fϝJ0)r^N\ϸ1^3
f='ͣ}.DG{-<;4&C6F-@M&zŢݯs昌4+1DA#a4_>)%ub0guV̖_=wCZt[;nnbGcBk{PQtq g]v
8.v+
Fo6K2VYoA\Uﻪ5ٓh44>w|,<_B.={v'"6cVA"Jc{:E[{,A:)@ʒpLҙsy=FZ=,VFUSd0=۫4
Ow#prQO&cKT9@24r闧tb[A%6Ƿ#@d$P6PMrD}XVGwq4~g9Hb+6	I"܃k%ڕI<VK&	@ƶ0_wO2C@@F]LzRNE5P{pIܤ)p0x
z}}zt"?:xKL.O>§ߝ]oo&howè0&pCk5Z::KAcFI:tD^JZ NvD#
(A12*1in{F>'ݚHȤoh?Yؖ#bMbrtd?9"*a&Vu
S*9↥y`.ɴ)s.	ZX	/bCh(%3\EZ<.鶨99/e+x\̽9^k 
?.cYQn0`t-
ԭeEd)cq
EČ6M!M<kS#"^׌ɷ`"Ϲ?g5~]7 i$.jL[985vPES-n4-v`²XP<cMxFq	Rů6`g)@,=~Hv5[d"=N-'JmA0WQ59ZU5̻j.{-  }!3}ezlXP+sIB6|E<W/e4+3O͒rvx&'&=tz#b8Z}>(W1]~8'?Mq"W2oٹf;9>q
ypq۸lo5vgK!u:O;8j?P
LhIR8B=/1)`=
l1^ebҤ$7qv}uL.xxy5<7WJ;Og'BQ ~VnN zw2+՚3v5גFG2FX1%̜؛DQKNq\ۙ<7[!5-][w* dU7;KoEl8~,&nY&;-#S^z$L8Wh.i 8 )瑖#@s Eb$eDl0
gw
XP۶~/4·u-AyE6/+?}(5YTC
ܵ^F	ۊz!v_E%U""\ҏ[TJ  |N5kplCX@%e @!Bq*6
DtƻІ+"հuUg7jĲhl٬rƼA	ky<w%Jc~b	N".8q0>,}7!4)0Oh-pGEd0
a_kNe吞[b%
 dn qX,rdj'Ec5NY1[sǥç_1̞ +3ʀ75H}Y+)r|&߸
g%8CFZWL >NdRrBx,)Xd4_n_ YI<,³rVO_yP"bj~ȥĆ%g]%3<M؊!
՚WhMxݴҔ*a 5f.L',?>ckq1,b\HZ#%p]+3b_h-5y$8e*HP}f.WV=c	~Etٔ (.*a21xj-|q e͘]mLͽacFb;n_>]#ute,&K-,n
ꇼ^w-MЇևxCwB+o[ϫ,3vu8.7slw;kn:;t=otR}H2JʇO|X:u0Z>SM%F`F]%06hiA&ᚂ{
lcT<s9MBqpWrksؤ)UT?{ɯv
x넀NY~Go9*ȳe;DKWDe'8׹,}PQ9Z$0^HgZrö1$O?aA:g14ς'ĮJ^0y7pZ
cQ4Cʋ޾ ;s+ l~-j`B@E]E`7ҳl.yVGzquZ-ѹt8C3 RgB>[`~>BS_
9tcRTn6y;{Y~^_0pyb)Qj)J|(o3&Q? l>\btܶ͞m4,NĂ0&8/
V/߃mP$wrF3>=>9bH}MQ ͵qv;<;>ێ}՘wM*ԝzb("E/-JTDc<{"^7Iʫ2hC+p} %i4q%aNm'veOK%~_eȕٙܡCCyIE;*@ŹǇ&2L}.Va١`lLnW߼t}|ݞW?b1 )R !9>	PWᙊ\iKל>ɍ͋] i6{߻~0zdO
}E!4߯A)Q
4oeau־!Cj\J[` ջ2W2	ȶ,E#6؜P}C8m`,
49,e+fx̟ͨ%hnt-U뼕y5~2rC'G@]:/FȼQinڝKR}HꤧGk´`,*ÔJpO;{~vmc"fv`nu$h?)P]sX-0)[b.=9
>DID2}J`%!_޾]:s(Z+F.3ziśFj#Fk(>#RUlf!ڇ!l9S MC#^i6&ytcl;%Ac,J,öYR,FY`k%">KZTZ(MQON{.	fc;מ(2)zw=fR
VQ(U 1i*,Sq#"s0HX@lq#M{OnD:ycMؙ2r밝 Jmqm5G R_~InNOO~3y85,0MJuQM
Z&MlYwzPW8z9߷bz#ZO_E-v<V6Hxg
+a1,k/iWcك?L]¾`yDl2ꡢpuP1wKz&*@E8T)
W7Żȡwr h#! =٫4]suoAj#rRR2hTj_^(Oߑo0a▖ǑU
b$t=xMU)'E3S:^Ƽ7:N
J>-XC%je7Rh}#iuQwxܸSje;tވ0@<^k{lڡ7+eEz@F
f˄eH#4c/TgCU닳7\<p e5~q eCՈHWt"{QlHɻ"X\n:	p>ݾo0ox_pY;rHcVOQm4|dWfX$X8S~z}VZeOA5~Mz>wmI}e V^W	RUQ+Im(6mvzI)dOԡKf\ƱTǦlPE$މy2R4
/U0l`
`;;`;A~/OCD܀=?
XD/Jsݻ@ԂAۢb4DؓUӁ̃Aj`Ф6MH45&^6zޒG/ln%An6m
3 nv$Mˑw  w`xXe_>;᪫+\m60hH9;ućnG s-9j=X3Sf}ℰ3τB-3O
JYK/>J
ňg6枃&@qa^wI5e3ͲeeXHseJpXr6w^%4IJtY
%7($Dσ8`~j.,Ҿ XǱ+Zfs?B 2*#ΰ`܀#(͌[1yǨɂšLұ=^J("«05wbSt T?/j<..MdsTu$qz {P)F|p/:G{|~zyy^4_4lt	?jdmyvHtZ
vUyksw"HDYSfYRj9,mZtO{k#:^;#W v[Us!&cϏʦk
2W$ޓ)`k5 .{wp /H]XlnI:"|U!!h^l.<ZJ WIƝi:s)*uumxIf]A)Q9Y]{=¹XMqBLf{q}9Y)%zi㋐ BΪXpu4@M$<1xW$_<xyZEV@J&є7^.Vo 
%=4au8[Rf`y\C\y:q!{N68h;H/ޭf)j(47FW!3Hr
"^|1ⶊbvcot#-S0n	
jmR8tK_/joeKݳ58g	J+Lw_*ȸ!6ȇ+ODOީ^AQe25Hc*ܿ+:dzQ X!!H3*uMU=.h$q77=5Et- #B
yjQvKC
 >.8&).4jNH9PnC}rnE;2-{5ca(tjmWlAH`poR3R/*B<|]zAJ*g!7ʇ[--㥃6@rngһW%kKEǽ7>GB3Jf	t\eB|jb((l,.-r;vrfd|x^dG]T.IQ	LDٽR׻aZ'?]lt#k+(xJ;#|n&.,FtB	C-1w)wrJ0qa!b<YxQ
XԎ`Z%74d@ecyB[~
!}s"3Ȁ@ALCJ.^cog؈1
"6QR#qu*wl`>Pv.jƦw;^ǯ3f`%	}u\5Mwyc$s.7V6dKU@E8cgez(1jhiΛrQcmvTZLg5?swO5sȉ/Cm_I'<>_,<Lucє^
D2	3|GePѷ*85!.\مKSSmލȍ7_^ܠ?#2(d2_Gkݼ.xCbkG~2e1
ϊ"P%+2XX״qMWI'c,rTd"wTzXAXOR|tRq+(?(e-IYu
_{8>}"$fG{
;F}ًnGCdt=TRX5`%XTk\/nx
4?8qmvpVL9Ӕy\^fkLl嬄JIN{]Y٦r~u7#JG
~ǣ?[%urq;ܸ9NzN#05$Xeb(BWZBTZUsnR_́&U-%_k]$(Nda$G)`>a	Gtvګ<6!M	$ƚn]吰TqPǹy/7SV304B&"E<J%#1JN#oMssTړ! Qv[FC"Zw;mbn=;Jh"[d_k_KZk_^N[XQy?hzlOZ_m?_kqKjZqZD6<<^%ۨs꼶~-gF"@c=!	eyl̺)Q7
$?) (eёZ4d=ie@xp/)+$xe&\6R^ЖfQzJ:}w͸yתBb4=SLaaPiI3`׫q[/W:{dY	LL\:>2th[;T
c_ލ[>+2b A6*#_Y F3V%az8ّlM棩q77JǓ3D5?@nʹ[91x`%!6mxy$f_ Ŝ-IwðFhR}j#<tӥFiHALɓ߰PVw[0N&,B' 2RT֓4e9B<)ҿJ@#DC̨]ayE?3-t-Z!tq	Bjz|Ss?1wS,9ipے P\biZr0w7DANz q&ae`7qrVrM,KwSZwM-.H*TTMN֬FՁی Kl;_=_/ƄF##݈muDSiBh1D
1hetSŗsD)>'S}֭YwN8dN7!nJc$^|V^<hIN4)ɩ*8ɏ'nXp/֎HpS|3]TՆRJ޸:9#'PIF<^	DsS4]y>,]fe^m#(oIٖبpڟuyLw?\Ds..3{R1-Qkl"%Z.X m,q;7s^/R{7Nǟ7=A+,$^̅y@>yf>b
pC#II0&G|14aѴ9IL
ֱΡX`	W$ylCLan^=jskBS~󌍄AՇڼ#-y)ub&riց8KݓeC_Au%.h`DBׯm*cX$u
f^`TE԰t6r0$B`@*4#,~Aa&RSZC2j'3!ʇpX~O5qbd,fEPLMn򰨵˟
p>b@Tg*uiטXϒz{Ipi#M֕܊Z]VD;XI ."Y^*u4uHOW-V4{
,_=2F~$
bߏQ][.u(Ohc!Nrar_ucuSEȬ}/ xe9X.g
c6m/CJߺpL &?爄]Bn+|Upx%(x%$ёAx:79
ip$\>p."nX㴦(jM[A}^˪rzrD{~u,fK=ph7Ru*=u2 [8E6c{юgK"ÀTD̻\eWRq?@@mM58"=|cuõF>3pi,;z
ðά\agRqX0`#V=e*>.Q_%BapB%6o@u1osԭqE]I˭
PAm
]_rVf="
󘓋2P́'Y
>rлzv+_LcC`	@!
.PyK{6pۖQ$%O]nVc3,<1V[{IB6B{ö)21<L,$vAu46lc<A?t^ջ	Ĉ`:xB1naaaWK?!/Gb][nyF%xԠ;(@:&	9RY!\u9meSҊAA6nC)i<@RחpE^TY#Cr[uvbU1F/j~FA"+KmoL(s"KX;2l5H iQJB!So9h|&V&q_f6%f`N@s$r/~`c	aU(Ri
/odcb".RR6j8G/yjByku{M6JJ,˛FNN3ttL-7dT c1(XRGhĶ/[z¶@1
:yW$@GU]!/b˪:^*SKbX'tFF!s	`DqA'vϹ@W }fQeY"G'Fbz?ͺ|м31)'PR)MsF/v;<_9nܐ	[QME3+nhi>hU.?ph|t_YZ{輘=e}"sЅ9B<5L't^=4|fc)2hlmgo]\b2 ])7([0'ͪ܍>)ىy</tF^R$K~
.%<JT8biZ oux.˨@:u
^BMH:rzf!D~[=	LQhBu3 %YFr9gaTzú+hfWaɟj)j-)WzY^h문4
L^\J>F͕џ]\1ԪBAEOU'&-K;_(j
צz͙NعuV)!\ѫ݊0C*`}H2z=Oi_X&R=
VV+FnPPDG!=jFdQd-e4W#pW%h°^S͉	Ǖzٔ4fhZC;p%RG8CLXrQk1SIV#	٭~fujPJS;:q[`v@ih)eFuy٧c.j,{H\pb'G0I}~5¼+0ɈnjI]
?Y߳dB_ӕ׷~#OcpKe6K.RmZZ5QJ2fathHNJTDǍ_'(eDG8N,I[n$(.XLeM1EYb׈r}MY<"|t
X1},v,Iq523#Cݧ!CVe	{\fؚOԬ+-bl92Fma] R{Y<^xyP1T3{)`-8)Ԅ)r
@8s v+;R:vT_nqlj:q}<n>e8
'Éjhufr"`$js.Q:3.|!*
?D]VeކS%L^a<(&{ƍ/zlUW*
;Zꟸ2|W(=ESF^4OЬc#㗢͉$.g([Ol"]NfMnV,R=CWT<qUy 8I'I_ǉLMx3ھZ)WfC`kbSBC+ß]jʊ<fr ;==7ʮ%iz:pBv3Y9/$UwCɏ-iھ)iޛD5Y	o,mH@NMݴ-#gg 0$syPHƢUҖpns3kJގYצhX8r:;5+L`2bPlhP읖
,ݠKgKTAo*2-8ꄕzJ SERo5ˑG
r*/M,25(TZ`39F[E8Ӳ2c$0$?|Euo"-p\,__/_]ٿwa{sP
Zegv]k j;EV
閞=9\.̙H4t rvh鉉a# teu,Pr [z$ Ǹsɟ)cTI%Un81X"Xbu=	e4^\ouu$ I^J"Bwtw:V+مĢZno	*̽\X@~NY
Y4DiNȊ@2/
bȨp9Y&̨6OYnc~RB ᖌr:5Amܳz6߶9ClG_Pw~}%x*O$-/E/KHHl"s
6"V;&[ĻඪHbb@v	kc6MϒQڶX;טvgߞ],lKVb=f&_dR^
=h$-ifO?D8{㡆{oσVWA"W[NZLƋf(Y)&M/]#x]	5
dqpuKjOpϻ+?DH-c[}=;?Wחާ+~1^U	0	۪Ò=U2Iufj-L*("F#F"<tT1*2".U#+O%fղ#'Mb^O4d^1ڣ+GRU&Xrըm-zU2&S <bfF-x Qi *!ڣAn9bmlº]	YKY>
D#͞.Lc>(4;jbl/xuZK7?aǱ;T]B$YtZAs]V
J7bjZ&̓E&*GG&R_\@qW^Q.p.~#;*!!5}dqqճlyHȱ|0?X;NYKGPg$}6	j.Xw'!E&OSj]AG{g7Y{xsyt||zs?62c`A(G?v|sssΊІe->}*YK_Ρ~:T珬!J0bMFѪ]@	IFHYxXv?	
c-,O_*HOY,ɰa=քỤzF_QN̬y⻇GةTf؀28d{yHf
gas61.{s=RV/}!\F6[1BhŰ<4T@w4y5`O۟}d 69.ޮ]Ban.)HL]^"[H*er:]. Td>t>EiXq9w!Ki[+
ZYZmnz!inڨk>cIÌ&hxgǏyR;	7`6BQKk1ccuE).Zr2AZ%?ڱBHl:yw/$+h7m[	2^JƝĕf׽H0D[g 4
}oc8оd!Z>&9$~;H;gPL%ޟƤ@5#>Ylz*rw	hwc=	ix$y-ZrJͭm-a~Z翷8NV*tO t?sg%X3LD1bq
{CWUv5sHwC;n3'|
)Yu4ֵ[yyzՖ^Kk[Dܕ*DR]qQ4Dd5{ΥweiCfj$Tmz-&|59$X͐2pÏ;8pBx`b*8x\SMmD63{;mqf{Նhc}Pԕ.xQ}O:ktW߯>ToI/rF(晍2W,[`1r' X7<>$LcST\EE[@Z>v$x"ЋӦTh2♠bd8s"ѷ	`XEj'*3]<nGXZ\2
s{7 ,NV֢ vHMpyts|vۚ㣏-??]_Fҧ§~_4ޗ$qN%g(@ä*\ʋ[_G--fL".1Rd#(2q䳷F1;w!J#uu@nuaIG߷QIsLBzl|O} "4ҏlȂGzn\*$! ZV#M-,f*thAθ@,cI"](4WNE֋fOr H(<fE/:1UY05#"d_S}+#`컧<)] 	Rȍ:>?!hxa6=j%LV~Eʳ2Krc<aw FaB$|}nQhk'A3N-ƥ)w>ՎA
~?VsEAE9ǻ6Ѓ|a|QֹigU-)ץ[LV.?&[n:_PQw)[Rm'-dUr [wJK=,!v,7 R~]@Ę!>Qlwբxst&)[5aM>ˍgr(4wQG3'?ĭ?5MaU`RՁ.|˳c4&o>ܜ~;pP9wRNNDdU*mw@qHHBzﰏ|i՜>sX<ޥ4( gd!d*hǽ6s\|$ڐetscˍH+4+_{;<	F-.~)rT~AG9=[c
h>uDZg7	a#7LZ-hUM[ѧ'3w)V135DNb;K{\H}ċ 7n	zi?jiy>GA5V^ZKOj[qI~@/iY4TSl%	-h^<ahã~Mx/K݅9˵K!BVN΃x'b*:jAh#R|DA~5	Z_X(-`ibf7'?.	/^FW[o "0n6b+X|CV.Ę0Q'		GVD=v[dq:U\H5/)Ie(Yij{i:!ы^ u&6;fo^dzu8o}sI5vaXkL:!%<swHKl##W͢WZ+
Ev/ShSU~i/]!LVחe~~y}ݞߤ*f#ߜJs}Pn]%hLz 7t*	{Q[1Dlr	3^ؗt[:r:xf繩r;nNۣ8u+ ŨD1fC u)V=4au#
0:;;xݒ55o.kLq0d؀jU|FV5gp>~Q A
w&%
#M6cU@]V7t))]nUe??<i!vYA
7 =t	)FQ_8)Ic>!΅oSMn{06OȤ<j^n2yJ`垈.`DkDmA.OAfQ_h+Z/v䗲Fu]
=]wLFŸ.tI7;>NP	Iv$φ╯1Ѓ\i
KbRb6)T[N)D/(  >'Q%FZ>^b*2AR;9
OPm/Go|IXmAP1X01			 7#Cia@ĐӀxH;"Z7+yl;ĤpXkO2m5Ŕ>P@ߨ,m6kQh	oZH EٜPi$}qZ 1H=`,G:U938RH0ttb|vsl9X_3wyƭ,~'ؒe-2D@GG~"Ơ,	ůPzr-:NxyPL.RD' {OGni0(7$vge?T3޸շ0 {ΩgL5o{@ Ѓ""x&oP& +^"c3%MP|pl8bCoKy뼜ڂ\?@Eu]|5`HrAr.C"xF|<I'I{^:#L=ҍf㬂Cۻfc(T
 0W>X͹4;HHjz&bHo5 %(5,uzq(:+!IdpWϹ[(eae6z^ l$A?]b,m:q	sWYEOmI@R[Cv˛~UxO ##K!w0)K1]9+_Qbק//ϯOAh҄b8C32wbԸA󵟧 Tp.5}%Ϊ_=1	ƞP!;#4IC;wRӷS:1Pp.'
8=rKw:Ã8hAи{7vk-b[i
&͘	VzACP!]}/h6`?@(I[jIS]LzDRԇRGpwC~,	]pqy1('xv%!n¬
+XxJl{;1k0OD0LWdz X-+_M=,u<+zִH$ayLrGNKmY7j Ԛz%+NQIO`K-L󬴽yv־T'[=(6D.
cH@6Cb)Stq8
-A)+2~{&^:	seۣRWjDRsluh{q|3u[aJЧ%
92*E;swk }cf`[	V
fK!$0ݖ
wug$]ͽ<rSPiO:)/҆~=_7>TzExkIGAxWk&fxN7>01a!0.\[>:,Aw-'ý8=HF,O*G2xj;JdԼs==,v$,[EE2dy墌NC0x5|
ȾRN&Oio彻w8촍gk^V?9'LڕQl/m)f gr~bVm@<xzv~uy-DPA3HHM(E#k.J/bd)ZoQ`Vw+ѩQyYGWqSDU4٣\pȣ{P*+;I,$7_T+^;WOAʐRwAl2i'/ΩF n-峻X*TLL7ۋR2IZb,Ta~"#ExCTɟUߦE:r%GGhd$\}cuOigpU}څČkH^Lӿݶe *eS&KZb0ݫD; xu{~lqUmF ~
~"'^:ר.gI\c|k?Lx/IZ?WV6,]Do B`)L%=D5xΥ
{YlbYIMD	\S gTari^508-G,H`(?]PԵ&N6/՟҄
 >1#)2^~|;mүjca]Ԍ䨝U
FtQzYŽ8I%sT>DRɍoO=A)hD^
XI( !F#.;zw+H̍Vb
2rȁkjlR}q0Q'(\;qs|g<x)dUPfy0鋓tڳr
 {ߋy) )Fk:빲w3mli>T_
S/Ɲݥ_fW)yViE7u7XexucU<ʽ=Ef o%6H¯WRdg*npXлBY{۷jѻuKI/4dEGտ4#}+\mcil<F-ߊAj%q}PW)hNBEDE^?}69D5TCc;:]>03eK?K^/l{.)<,Pm?DO
O5Ua|/[#};%=H@,pfe
C;nq+{0O^}?(mٿkhG\kuw3sb~4-v`sUF>и5c^{^wAYmPڂbABg֯/cjny:wGŪK
LY+:Ǝ#aƊ{ ;הK?b敶	DV~m55!РfYTqAJ~>2v!αB.pWVhD0d-0wF9$;.IQh)8oDX譮/}?bBuä6Bl-B3EРce|"co<B-&[#H)1Qê\pc;Dqy'tz Lsoղ
w4뷷]}y"RF4UnA쓨{
nݙSBcLD=s経?Ϙ9 Eӗyi 䚾Ƒ{[fnֽ}0D$RX^ERqq#
ke
	_)Í4RiДu@ J-E3N3;7pbE5UࢺO Rv>]QNQ{z^ XhzHl{=r0K
_=nXj@1&ҼDV0,-ƭ,q4KĐ@pN>ȉ]  z(jo,g*%2~gL*at'$3 P2=Dfԙ8G;zr;PnN\L"N>
|a2Gθ@1IcbWǼo8>DpTҾG2⣢.G7+jxJ9+\pWOqj 07V9Uv.[;Ab[|<(6gR+\$pY dV"[#,xeNNдB_@G&/.&d?nK[ϊ)آ-?Ji g;hs;d2M9$8~EnWq`1!y p-Ldx&H5z	86X)6s Ҟ|Rc4'4$_CdTƝ.}g;L$(6QJMALCnam0E41%g.|fܒehh
=mߤ@WV)? wW:UVYμ&D(2x_zCu⦪֑EÌoamǲ7n#nw (7!+ 9!w)_M5W\"4/ 
: JM\"7NkRl::M=ΠzXzfWROl"v"EZ
m6M.29ZNs/"p h{(тoD>m6oonpߺ0X쇤_
sG4I]UNiED6Z̳DmG I˯qQVWNgSvD&l⶷ml[߁mk6ڇ B~|mv|sQ-<{2rJU?
\E $!
R9*M_թM.B#'
Aė5OӇ<\8\TމBNlSL	I:zfQBΝ_5C&(ٲ^jĊ'_H}14hѝprjqq-J^.QT֮x̫xQ*şNXn7ۄk.edr~iqs_:3)
kp'D%~ ۤqC`I{eAUI-]hNum_0&d?WܑF?KMFmKWZb\Al]/u!ַg|x2(<-sMEz_?b!P(hTZ]Y8iR)ņy.e>j-u͛v-T\~hvٰl{u0'5I*1[|B-B"/{[+{Xk?CVD\9+AkyJ~e'!nz(azf( MwBw[Kl]X	/D"fP'@/j { ;o\ŊV/rޖB!26XV1]O~/k-l hV/cRchN=J8߃_`
8ZTe$<E*E4bkU,GN*H?ʔp=v"wI5*MikDn-[M+/͠}u'__w|xJ}K1fqp}pE{`H[ _̒
ZвHtg8r., CǲXѩ|স)<BnJ'Ɂ-7#{FbRKEumXuVc^d(
cy )IrsxgK-n10)PrbsNxP^ j#
2ߤ4orY\lIEv@1nN昌]U8$\X<4䋨"Tw7A8`~2igEYl㉇Q'Cq
ARp)-+$4[P=Tl}Dx7>^VX@E&siƪ7vڍD	#,.|AO0ٱ$f摹i_=Kv/b4W3咃uu$M+h $0A(,p	3c
_3|LPK	i.CP%V {Ӣ\.vc{_6@`KMbw.f9&g1GL'Dc"tW lCF¿u"\x*]s	ٖCL-G&4+b$ _$Km} \iH&웢<_144ˋdTsR4
^O?xl%OH?G^o>~ӌ6:F$3qi|;xYmxI	VK^hr[Y	OPvmK3j9Ԕ- S/Z|:$Ĥ tTǚ)aX>%XQoQTJn帮(0K/j
hTU4",D!<EQPZ~##%Yqw0%WF#LCd،LPll%~o)~w=?C>Pm{=:;L r,kxU0XZt~([åkRNn$uk|Vwj:?d-@T#7ReUE_u9H+"f E<ao7t9\bTkoI>mِr*Sv렽xLUuBOy}iܸ"ePrZ>y
v+$=X@6YDqBdo K0ձ+𿸜}̛Uc)LUwFu¶8Y`|/mk5[\Pyx41׋4Vҝ;}ow2x%
赙{-)*ߪr/Tɥj*CUE:b㯪W+^^<^5
likݽ=;hڴ:pIW\[^ʻVPae'lt܎=|f[dF4[ZB_j_
zݨPH?n7n$h@FA`HJ`*tkr`eh~jDדi
PVԷWYEsr,a;pkI6`nCU=>"`BrKBM&
MX\^[׻Ӌ˓C"63'O{_09'/ućpR˯v!z⋟I)
[h4A~:4|@Fs.g1U`1r`j(c ӒhYK]d m5r	>;;lY:ur%}Ydr+|2kNOgO"[0b< nRg&6)9>ipeF5P]ݴU4]`&ުisnUdmSFk;,L"MP2Wy޺Flc#G\DU̡ţד#CY-=N|0T,vd(^0$#
фfA%)^wEQskTy8/<(YhQb% jԛ$-?e]>qW3H#՗3잫2\UXr/w}؆@i.}z[}OrS$[zmc3ƇP`bƥa%mZ*q3ΥfE#>{iچK6$J9xmw0-5ݥ7uB9_,t
ć~V{r["0l-Z&h{tXG)hM8\>'تx5%HP᳃ۘ$ M&91~.Ha56tڱ12PqL0+D2zݭOly:*ێ]?;!Xv9~nU(B-Ev-m1=z`3lV=\x\k7MlAcd%}ys*}ϝ٘TRLO{LI!;8>]`7oþ<%<¶eͯUIAE03,b<|qa+ză ?3C12ĵEW+OIҷWz:)QhMi+ad%OZm2Z	a6%1jgO~L"oeH\)^9dgٝj6ȶvmFl"@/2~O3d3F)2^aPV;/k8cMaȳ2!k*Tb &
*C|z,,&8<{ZKW+k%CJٮlH$-I&Q$jޔq3f_7tptxֳƈTܔzWg? =ԯ&P"VߖlTcZٔ
H"cpW:ˏVEI]-

der%&[-)f"-Qp\q:x6^krH>+n̙؏Œ!oJGdwkn
^kWǐbv|W)y7/OepQ"iLꥨJggSrP
V+VE1	=&XZ/@ ȼ}`tg[/>}AqxwWAȜR-ݱ6`E0zUds~|cE~K?w3*	~ͽe&WǅT<fKYܳC;b+$D$EYΡICi%C8zhO6PμO Vb9뚨`җUHȕ=d[!'v^{CB#03P^\2?7
:TGs]+7r&gl*D{! ȐK+|X@!@ij뵫٦H"o{]{pbi_@{nՏ,,M]o`m`Yl`ۈ
'	ͦ?c9u~p,N=I]¢CmL_	QD'D̗t;YU A*3흅r}Cھ^s]̙b3RXCtgG~meE?gC
jg?tk"Wo@:ƹBYVٌ-sfo񇒖 \-U GCܝͯG˾6})tx&V#:y>:}sXZ
S\-z{l&`ufpyMG'3٥ "9߉JT$>p|N&
? ^Cօ
K使Ƞ,d@
/ B-d@PC^(פ{Rz9HQ&|2
jjmyrp-<KnDplC8C%bE=h*6U':=S7c0i-J"z~e4;Ӧ
82eM/YC]޶,esRXT@D7
cc^H
G%Q:_=< T具sfR-?Sϱbk9$ϻ_'d|l<
g68G+ȝ֕&%"䋅KEU>s!dXRo4E1U55$4
+*5lHУbMxigEmzSavk(&}$wr{D좘<UJJ[c$VdȍdgsjNui״mlGr
Mb#LAˆ8=ioʶok;	[#:_K,`/ p#j\GeҺJB]Pm2؈DHw4Bmǚ~_T%?.<QZY^O;j;VWC6ou~hܛ\_4~6oh*&eN'"R
n?5j6b'8woiV֩*"NZu0PJqbif (U^4-MVOWՌ~BHKE+]*wn{2x_{KA;|Q9!N'6p3ߚuTL[$gzj6nVֽ^?&I3Opϗ'Ǘ'sͼboog?^`lV',J1|Zj PLL+OkSj!0{d-1LP*D;MQ%<㏊E޹OtQ\|ZN=
vPoF.n\zÉ8/M] T6ۓ} HGt57o,n`O&sa/U?JÇx?$)tchL3nPa mMR8^EPn\X\G!lH{PKorg)Wy:svbEUcIfo~ڒ7ptgXa/byvy?`^hG18CKиAUŔSO[/}\==(GcgIzAEIp .ěZRSCnx .osgX_޻oW59nazrz}>SV;N4ۇ]>YY{?j&c1Hl Dڏn57ST3FD;)*+x/u.:X\> W4f,!VZ[7u]nʹɘl'VI`Ȓ!I|+4PAVq(ڇڻE*i\|!d: >lrry:G"
k.ȚN7n
t")Ņ3GL~ih=H_ך7`)m,_S޲ qt|r]xkƍN{'r	YPZǈx4a tV*Kox{Meboo;|~v1.5L6ׂh!d{K;2Q0>tv D7 уd|Q!}c6w5ΘxEe7T}3/}
965_/=,"}['%Q
$thCԚa9*&CK3;lR+.Qg	R2
5enTB,3*ȹx,5*61#Cs>ctC).zr;]㤜F(̊G7ttT-hrϚ/csPtu,9"06
jnxвƃjv[jEPPkti1H`Ɇ)16, ڙmTA1ouuYʹZ-~κu+TiWFLy8t\u`[ulmg_ҟNp	FZ@ߐuc
lЮ寣R)Y0.:?qú!7ㆪL>_~I}<	2a\ۍ@f8Q0}\o7K~p}9vA+ه|[@*l*ߜÒ3A8GSK%-G{E0 Y%:c?˙VcKE{];(}8`&b3<萩ˊi@-<xS^ӧ׀xFKoF; A5O04D2XwMfXv";?=?6[QT[	Ff:TE>5d;L, q>
^BYJhGTXO^en
{.y~ȿ\dM^4eU- * Js ^A_IpqB~oH`o֖iNzK
|2%ĴS>!O7>q(zfV)Xl|KmG'n\DPտUZ7y;~
v1^pYG¯⹟ФgIu] b~PQ*d+uDXV̭UJ1аAfJ=AM$۔"j|931«N.g
"59յr\},??U'z^͋`GlP
5V${a="z9I,j1fS$od0~9xǝt Wci!k+B%n^Pjdy+N"Զ`RC!b*ŔE'GEu_84RcDb>aGІiuu=l^קE;V@*Hnkn[\8 #9j4nvǓs rDiH}8-XU\<V(ˇge;#5wSu"'؛&S|F=/,MnfG5r"ڝ;ՠkݱ_GմTxj^m{W +`O&sDjoI
Кau>m35Dn&_?}V݉'vwT TZZp^rr8 
N)xj(a?ţpkOA_18d/f+dڧ^S߿.d?HMhZdUcrݠxvȞ9:>3%,(k=n¿$8Z0E]-i9wj);mZScէU֑Q$	'a:f#pwQV;5B{r)8R&ql=.Rf[|d}/Qӌh-jА:ZciJzb[޻˪2nFz\Ѭ,H45ii+(Ur6Bn#'Oϕ/MD)u(~Kx>r׾':V+_i1ϰhj##FP^gOLnUUc9$tI'yQ@YSf˜zd5ӝT&gAM|hb.MX
Hl;J?߸DϮ؄Qή_M	)r.Weλ1|-#{?rz!^R`$>rwfSѹbX'{>*wCR݋ff$ W/AycuD}ِ>ImnsFm1O>jC &¤!]zBjm!h$\2ֹj[&)P8K'Ԭ89?+ZbV3^n{3kSxrS?"YF3KI9,_	l-uW#Ү4݌>I)qk ޭw?ztsy#dM3ǷYNzaMEH;Ĩ ijF9k>+ gKc^r=l-D.o~Q4jm"ď<	헁B%s< Hr8"ʫ `諣mat뼛&M<K:LITU@@zpٴߔG?Ê?a,Eڦ\N}klz;œH'o}}X:Xhsu|35LrTqjpUi1&
 K(n"
%Ch3KQ9ޤY?±2 Y[Je2l7|jaGPI_>' Cv]tGcxHs	I8n{_fd,#a*^%͒)pҸ]}#W?~ۋSLbftvŭٱU?7, zȻt%&!b˫02k1|x)!_K}EFfK!'էޅ>
Z#z;UoyqjcV V68-:|KB.s-KhoGý7V	%'ϧ
C!w8!` n
zr`	He GKT%L?ݺO\>*q|ͪl<2ST Rft& d/Ǥ܃T0͆A0e4<,<m!^~bn+P55-Or# o,$0OR7.iJt!zV5;E08t?:j	Zhxո[T5|D a|h(
+(nR6sV3k#qsSX`kX[,؍z ^90;RBdU
kΤ^tYdmPl&"˚LQe(%TWO'hZ9Q彨[Vތ<(d##j,q[_5ʪKGYO,'^bv(g>z+6"\,0yNp$+\`%fu^&yl/|MG䬋r4K	`ܕrAfmbv'_dD]Y-=-fC3'h6B軹S1MMĜU7qPp>B̓u}a<@'h1Ā%M"Tݟ7Y=TZtmsԨ@̓ـ~%w%iͻ%MZ7dpxS2qxkv2{b	mّ@,
}ﱀQI";l^y/$tHxBho\= yaGz*e{j-e7Q򺏛6cM
YEU<~a%B9T,b
s4=Y5FXp	նRAgmub#v0u,Rf66	]
Gu<Ց8b;ͯjg#{bR[^D$}~1ğ`c<);{s5p>A@r{a!({А+BQgur SBᰡZ9,׃=OGnz5;Af;5P0Ba5Ų#p|c\n!ae@Jbw|!21L-T*GDtGҧ_
d`i`xIjU<]zAydʏ'2h=C.>Q@\nӕv=dv&}dzPc136ܶ-y'YܕF{:¿B/zpOX;,[P]$YPjo'AR$~kR2|@*±ێ<<cx^s#[)+t\Tfz;Y_HO:9{;cREه>~4w7?>QpQ<+:;=>9]jƹѾ2NZ<:mmcEP,+7ۮ;U/VD.CŒA9Bd$fO;^<XNv̂ HWc\]8֧,$Q XP!AK9~x۴PcQG%T]IWi,ֹ4I[/'71UESQ»n|!vHTk
YتA_,Cû-"D1$myƲS7Q[j5DrT	^rU[L 5nɚyݒ0ۊ_ksK`<ث+1YǦt[V&}i/~I97O6QwR?aAp0mw C7ʖ>,KR	
-+,60O5Fq۪[woBxkH{QGCQ'C/5 3^OH%4Z2ք*_sT0i3_){9:1j6gʚC[N6PKyvuhﴔlY&jk?W[m;bɿOSjNT҅Doh
^_#>J
ש:[IT aⱼ^˨2	FQD"aX6J7=ꮲ}|,gdYGA2_Ưe*pYKBYϕX2Vl&ep]1N<;FʕBҐ,--U:*>Ϯ\,D\)QKX1)5AlU햔U_h\:遁)9r-+/_`9۟HTk\#bguWYڝ	ER@hЫT4\ ktKudIx[aWůؒD~0ݍrr̆R٭ %M{6憟9>ӧ7ç\]q ^Qy-Xu{-GU
2D-p}b93}EZ[0VehKs]׳~,)q0:D62}|Kc	(]F. t峚;jnU=iO{1a
'qﶨHj#_nn	#cJv&pQmԔ%TgQ{moJVxnXMV-BDTg_ݰ|Vou֧M#
,`e#>"hN+#$yGQ8xՀ.zxY{6WGJd51ɒEMpBGdXl${2Sb^ՏYpnk	1*&F_*|GLa0'R%5)6	/]%dxh{.m 5'h Րo.3<0Z'Z"}Ć^4t(:Y)$Lծ8VrB:KݪBBoƒwVճ)H}oU_n+zp' <V 75{Q1Ol]B4o̓ُ(Jי,WaRGxZT3|2ϱH'].L	J
`}ֿ$
%kتB1146[3LbZ_Fvv /3:=#.7Uqi*ǙU1
tVqeX$H]yZ;WyLS4>4,W6V?1 ΤPjǙV'7ҞHHtM*+2Kz>lق.?L|jP+Y<j>\}EC0:mM?`:2'nB,2q`wA^E\ۏMkS}n[sS"́^ή>aA}n&-fR8o XᣡKS^KD%Zx4ѥRyk\$Sm2_փLd=VqbXAh{䦯zmY&@EW'BC7[שX tQ2iX.aA1(f_8@5S ~"WZ0ʸ	g2"#
>`k,[,Y5݀G?P9Sl+yktWۢ
z D$4dxRx9ųM3;
JӚ,F).EUJkYE	ub⪤$-_Րl#2].w8V>1KOӶb\Zը@K).`1xj]ot㲅k\t@t>'?_oeׅ`!^)WT,<!<J
z{tD>s\жM ,WZ|,2#)W21B9ŕ
x[~O*5$'-h/҈I!E(.äNՁC`W%E}sTiuc讱 T^v.xHkc^8	o;%ErBntE^is^s9d`֚CxLsF^
Iͳ'$d9XdKOpΫ:Uq^ґMȡ5Fu,?
|wb$Ŋ
OǏ56E+Ҵ#Hz&6P2?\ԤU(EЙZ2m她(YA
jRyF
p47.HS8T y-vXSu}rg7]׍\mmzKJy[⏦jAԏ+& rjI?QW_Q	dDٙa_49byjتa*Cq]m*s9?8^rGD+dVJP)SA>${0@x&<ð>$7
*sѬ̟3O9LnؙDsZ%"	5{j6)SYG;.:Na\AhMBb_uڻЯ]Rl͏GOac2JJ)|SRek7hE£槓Sq,5A_d)*|j|<
@~f !xzݯ]
)G1`׎Oȼx@Q~\v6
H{[|Sܦ a`Ux%
DE2nl<& 삶USZ	Ɏ.@BA _CMY>q\"P4 =	v	Pm	IءeMS{JˆM4kD7Ol2IhN`H8jq7`Yt.ՊP&!E3@h
(v&6r߳0{)|OGj_[Ϥp
q\D_f$2F 7ZP.HPsLM8K#ڎ9GsL69.c=ÑvX%}o=#k/)B3o
_@4 _Pt1GUs03emXP`;D*et<X~a8DMO 0*r'ln^	m=<xQ}& 	V#xbȨ4J]<:Xxa[:մyskIʍJ!ۋeb~/& D<đVbꝒFCg+K)&%x :}Vm\&G	T_-;QJ+ysHH#og+yﴴTqfA;Lk${ާ{}tl4fn"3məO
G@nf$
/\9An?)5@#-ŝqAnTvZ\G>f?bAn-'W7
t%_}W3bcKͲIe[.̅aK~XsG8]?W_dP$}-$3kc.]^XTHBD Iz]/dn^q`IIʭ)z
T)ĺKP*vsF3[k}h13X{ж>(/M f;P9NmoɌr1]l\]cF39orㆴnoyVn`o[	~yv1jעYMGƸ?PGuHLkw'Q~e7E 1FyVbɱ $؝Rlro(NcJ5z򅘭K>;-Z;\9
nYg9WIDLY"mwau'қuVEE
zIfSžqsGr%&Tk>oI
'JQiݴROe*
|bsۗI`ʒm#9 IO.<S;>B6xxu<5Zj⍠**<h݋8P/
̤SZ
ڵQ
j2KV{QMʷ.^)P(ʟO( `\|މ	8 n=
iv#g1_3>yC XeX>%N$'U^xF]
R{}zt||z#Ԃ_nnmJCTp-BQ?*AG#s'GuP
wY([
:
ȈQvfkع[&ԩHTRi#dU$oXLK5IZ' #h0(
~]=9-+b)?t}/e5wK{$OPcUK? ppZRCiCmR }(FjEUi)+w:a;+,%Gp/!D@ټ?_dbVs
;r.][0}UIs! NLkq,O7H[ul܅eWxTj4w?1RkG %@8fƛ8V]lɲ}AG10ׂ?olglC%/Hl客 6m|Gg[XVo	bQhP<	Kygf^14>11t+Ggu%W#_=k2i;sRd,<*7qnN|
Dr2:jYk$GDa9ߢ0c+ޜ^/>eB
6۝-o =J@y:u
v:CnZ`mI|,R|1]b=ftӜ=(ăog͝C
([$.#x&%}vix)W&}a(Y+
 q %gØB})ghA)j/XF De^mb|Nd2N+XT.O:>j1crhIQaBPR-Gѿ6뭈 5ڬvs|2/:,Q>(j{Jt(D%<MU]ju8YE*ybۥ1?YF$jVuP:MI:;F?ZYl2Hs+m,+e WN82x\$>rUPxu׳̼%g?G*Ff 	 ZCEC`XZxud1"sU-&sacEUN53~o6:JU+61B(|В{H..s]
Iy7NC2\)]X0xuC҄ mbJ~WRT82wA:xۓVùUK܏޿τ^aX)E5h޸ӧmWfIaLD25Rp݃#[(sG?	]eV._l'Lf7aVY0*!RMOODEkɨ} %'eT55j9;>.i}!ݢ'@LgR vvB =ow5m@[K@o-^7&ubZji[RӲAp,m+1ϋi_vV/0z2^`
48s=iD~oSQ}t)^ۖz<rVh~:/n^EQ5F`?~dY,&ZB75.b]PG
X:
ԩZ z0,asl~Hvt]q^{HСoKEjQ̓@u>Mn4^H䞘4!N%&Tͽ`55}HJʝVhe{
*A7^MV=`h~؋E)6},\$TBEzC%icvv9KinWOydכfc} F=KKHڑO!*o'' ۮ2Xjӄ	M75#en_M>۰[2IkMLhu/sEFa/g*J)HĪ>Gm,@|;/S<Sx	}? -4dTߣM{-I;uQ"Fv[b $orm1`YE89-Nr}6[fǏA*6b=>#}Xo&>
j	^V."(g~Uro\7RWU^P&u×k,z8[l6CF+@R #?3~(e4,
m5d"0PшTdE:h)>
X4nKmXٲbi%(=Y㨪llY{d2s8G=D13LĨ~h	悯ݼkD[	w*Y1ZIoVNeWAugCR/VH>"R 3X_Ewϥ8f)_~^1])@o!QnVG_$2^)nh<=g)Nom\JvRv=V!,A?Yxl${
q߻׵b	G
q+$g\{De|h-w:nA犭յFR(f80L@J%Yr98x`|N:*X]Woi\9_/;(BºCÏ[蚫 2Tcb-E?ko*c9
QPQ<6`|gE6Aƛj^8^Uvp[+5OqԊg94MZ%3{;XN9ȩM
Y_9EҡxƲ,Mǯ8m)ң8$AzfdNYA'Y="2!y ;
wp';ZI2S[k GVupyz|l4n
n[	4^r"h`j#xP< 2;clNi<a2ׇm`  	_ƌKL+_ܗj3IkX[="sх$:84ե1-Ǘɶ
Ө,Y	𠌢L'y)G?ggnk h@mF˒=~IݤV'g?BU=']	w	|8${!V#,/l:;
	lY1
|~A,{Fa;>qj	0B>%$b-Ós;@
h<z	IJXT&W
c)$b8#hK']ֽ$ׂNa괿;=xwڽ9V}lۦهˏ7/;Zppm#kyO(Abs'nuO{WJ²L 41BIE?*!Z7#_b1kc.	mxHD<\lW: TG$f='neQ
ڌׇ.<r6իlJ".Y]\Ue*MDr r{s$	Ĉoʥw=%!7Rxj=kYG͈j h|,˯q`o]D	,zܨzMPV3Z89 2Wն(_4(-NVWɏctbO'EWv$OR ]|1wF
Az^[1Je4(+5ýr9JG;f*(#Aϝ~ݲQp%DޔuLw,/ċ<#}kf/VTzD@MS>(&`-+>{(Kzp8x0Iz?μ}5(A7:^6{B L"b3tOEmJʗEҒ-lb~'{݂À\=|QS&{q5\:RH聒jm6!9ixʍ#r'ofr[&v[͵2J~k`t5ƹʋᦞbgm*Km[Q/ҒU /.};RtC8i@st/¬8lAi :L
Aۦ.ԝh*NXyt/y6#P=]T[r)lB*#כG_\z`qsp9O
svDT"͔s)ym8(!h%U'VV>7Bܿ~c?|f%M⢢K祐U/rmV{Z!B[C?Emllz?̍|Nb+[_dpbUnV@"ᕂV[<V8ժ<_Jx`4`SrTv$-y`Tzl0o*Ybſ{x;F-uy	Eic`R
tPi1	UɍZ?B	)(`#.8"DFH1x>
>5p#iyW_+^&^F5VT+F']"gd ]XUvA6.޶_IZ;NlS׫lMs!ý;hp*y^S}2ϩ<U\4k|'Zm{MSU՟
y0_T )}CLu#9(e)y6^\Q$z]nII
*Uwdo޳+67QuyʆH*Eg2*GmJeO}^RJjVTW^_PRJ-WQU
ͯfnx"T*.H3orZH&H<
o.}6?[k6
Hk7_LP]HLAf+">#͗[vg͞+yY/aR[zéj>
ʒU0W(lI"}y)ɲ_m8~!0t.F
2|-TP(_z%f(.W,䔯<4~(m!Ïw[f!%Kew4UFg_QI[Og.nj\=z@ȈpkQ#8qxmuSN)EI^^8tttA1]ho@JU*d< /h+/{Q/tci-[IŽpÛE>'\Drns!@KO@i1dC8C]U~6 'B:V4׈l@9Nkd^<0
_`tH:X/EebX;Z3犬j'EM ׳鐕ԨQzS@O8.Ŕո7Oz7O{/|vw|t~^gͅ1sK?10n4j~uB2ξ5+Z-JP&QS|mí.*Sx$u+ф&%$h
V2BcSXȃ1AD;6GX(&FjyeH݆fV?۵&*kt&,َNelSruh4FSCf[
J-`.K}BߵT j!pYh(iP,\!.A?r+7ﵳ6/(W$˳>6]P=V*oܪXe2\4%?WVT`QNv{':*J6NTDVVY)4  Wq27xW1@OQtCl fMj9ǅ)U)
,*0bCeX<}%Wݙ[d^
!=1mܥ"%#o:(PF(ׄGJ}@0pwe19Uppq%0.aԦ؋Sk$_

*MfQM8oTd6ؤu:O4q4u뼌2/͉*+^Lv,5Hث($Je\ObϕE9ȗ~UKi%BG{mg/qΐ+ލvG<6ePDs=ctz}}yݣHwrzqvzBh=
b<PS&!],fcaq>EwVLm
~K_P,}Hou̡Tf%ZƔq**T;kqsDqxNqYeX74Ţ >I7wakZ@O'E~nRx}.qUCd\5Ƴ,t( .T*kZU"ŜMT^թ{z_)è_EN"+z4}ںD]k`JH>?FbZ<+,Uӏt\<ahv[ecƽzVp6"/reSbLV4DITBbWe|.Nx+w$Ja"DyQLx=5l=o!YqbU8k%z=n0rh$OnV=0)NaVE5$ON| ;mflUOJG&I1AnܳUURv\co2߅;0]$BNib#MBE W?Uߌ̀|Z^O^cX*+HGZ]IdX9촂.1Č@.Q4Wը8IɵS*h_(G 
:+;įLގu}/½t%iݤc~I/q *k.Qn\ Zru`2Uu(`(-ffFBgXB<}zA& BMy
;|WeQ-B\S9Db|P;qd޺<ۥn֠|WbxQ>
((TU:§9XNZ-+ F+'s6+>4L=Of1vI6]*:.{<f
,*:{=	D/}@ 7]iHyD&%t	x=2\Yw.  xpoL #ZϽ+eT<c̒WG(DGK5Rp,6qE:` \Pr^t)Kx, u	C
Z c_3& yT>{=j?#5};Xv5yBD^Ngpdr\<A|(Z8ihE؀BiՉU{֩V$?Tv=̎ݩ8&E4&@ЗI4y(4sՂƄL4		~b6ݰ@#"qW2a䦉]DQ%	\F6n=/cz[9nJ-j.]>*{
To&x>EJsԎIE^LjlXC(&;(%z=}*:2'-f)nKe^8Wx xsfQbWڊTDCb)pX?O@Gts3 0"W>8u)/KN\Uz!"l"UFnԙI\bsGD
*>	K^OAXb>JKvE"JVFq2Uv>Pl_vo]lG/0O~SP|)y6{	~kCZPQ^HFõlèA\ĻC]bU᳻z|
BN=T
-.k"|H/۲&+P66ʸ#v2P)Jί.Bd{fx	6zαL<l7X6|4G)(دSZH_8sMj5x溙w1%.'KͬVsݼJjD;IV= l90i<2vsϭPu#mżNМ0.[d]5@FHbLB^l}q)P.Xn~K*F50$I!Umb*w(R1J>{ =ΎN7HDFW#)?NMCMhkUtO`l5|\I.RggU?ĔZvf_b/OKŧ'T~J=ĪlϰY^yZ
:Tmޕn(F|*cc8q.bp%$JrT!#*CAi;|rV莖{fGI=v>1ƑoaE_ھqp)xj7j#ncXU9@T/ P'E'ؼbT"R8Ѥ'
zzƞ]ħUKn#F v@o[hYy
@n.s]&p8(/sEM:&3>VKYڢ?TQ0yx|#;nW~F
n&1I`qoOFZ[~o]hHaL(k*|WFaXJm^DGV"c{1A:_dƋJJMTj5Lh^]T~HG!cEqVPqDi@&`H[7]\Yn!AԚdEխ&{9>	fZ\kPAfuZwKMꋤfG1r+&	\xK*H|PFf0pֳ_)il
ޢjO爙DfL>mF^c)cA)2.,<\5F'7ݦ  ,ি7	@R%nV
~u3bL*<4ݰwjeg9 ,)XZ.,LoŠF-}^$iVId/Iߗ2~ɉJxwW}7bTM@Ki
lW^dkCf;ijXhbС=A;؝)3T<w,ǵx˔Z=+R?04JxUYZhRɲK n<{2j늦F$ܕ;LDШQ͗tz|IQo(,}/EUP3|El7.>ܯ"yH涼"@ ܆2AqJ?}D㍀ù35|-<!ᴆ~w|<l9#j,KruYrC/#y>>7Q]i=TuR* Jub_MŸV84C7HIoDfBQ­c+Q͡}hSWM(Bx'҅TIBDvJ.,T9V*6kA/0bt<!zjĉ#b㯫bsapV>6bZnlN9Lc+%e?
-3T2Ho3 EOȆΑt@J|)&yEߊ(W1FI6(4jóOj|tKZ;$]P12`O_Jcʞb捬B2Yk?&\4P[?֮7w
C߸xu=]*=Ҷqs4E߯B=O/VӣMŪI2w%,6P%nx^HY;ϊlߛ|CٰX1c=%[wDUMT~?MD,xMk/е8xrk:1_mYk
砾J.C|#
hvG,{@&<ݟ҇p
'I'_!>	kd9f.u^)X8RHW$?VzN
qy"2q4Sfr`,m>3YMǧߺrI'4(Vⰴkg(r/y,(:DZm添Ja"SB\v+8wnu/:cUtF׀ɵu}puC*]_$F
,J_`ݼq`hEX"ytKA>MTG+L,rCߎNr3y]VJ\3黨x8yj6m:w+]AdtOTQEdl
(C!(
[`@^QqϞpX9FqN5y{Gu|fC&LKg\i7͚FHkYEmBSK
	c+COL֘N4	ZqtY[l@~ 3݄siI
)7*蝶0,xvӗrW<(Q8`$s Ƴ*k
zS }GN\ʋ5ӨfZyuoӅO}<gI$OyhapW1gh6ﻥ>ﻔbtRǱIN,G#$
qVodE]bV?4L= @ ZO[͜IK>lȡDǵL#Mn##qUSPhr"C+QJ8
{lǴl-] kӍʣ0<ƽ⋄fX$l|-t\l\DFx1|4

:D$#:${./xk:Y
/ǩv,Kʍ[D@90x>ݟ#7ogT'ҋ^!+;21k>iocvүZ+ޛp]&TLi@tZjBf~/jl!wk:ʧ3
?FY&;S
iH6Nt|(8(Z/flw!8[sAAg	c\ʢ}s)vdGj$]'0s6	Yx;PL}@E?dpoĽ. w{PRQ0Gr?r\VGd}R|U\Q~}2o`B"{yEl5#L߃<[K〚8?qMGLĠr!
~]4h܄	J1ŅTd=qcqc\TigP=Uȑi;]`F]Y7q?bdZ0[:ϣ.\aZJ,kNriVQ5fu՚a"tRRtcb	ȧts:	S-`/eJUUlt?GQl;%K3ɐq?9VfpY[%:bؽ[\5r5KL=4T]5Zpq萲f96$JS@Wϓ*=`PGgʢ܎6w38
ԃEXXS(s{|RBH<K4²#M`|HW( Ŧgod@GJY^,8:TW-*`?oyEڇq2}
Gvv8taQj֦G壼!yVM?=JYuq
w~Ngpiᷩ[adoX'K˗?Qq^3J@7NmcQH@-Y=vy:S>JEdB򟋇=VxOh)R"`~ZK]͸5i=k44leE
vOEHt`}l\yKƈCSq(].d>Y0|2Z
l7®
 ()z)Mtݩ+{x><z}*C;t9
^_s{}`!5Z/t4~삺<K#8hWmsܤɶBrF}57͛5J&:4$RgNH>=
żuMWE'W.n\tdmtPȴG/F+%czf`Cβ\<0C
	$%wS}ąi4M1]̩mƥ;̓ޛ<>dRX}]B~G1J4Ou-%0
:F$N]WocZR;1 B._1I*xuh>P	)m\4Ԏb=|c2,Rgl>SwA1ט46.]ײ::P>X!Q8t)(6P=_Ps@Lh\Ud^4V}\`O]xhw|): QůSAWVȿJ=	^ن+6ǖ/z3w-"W[j	鉐{	&%t1᭎G񠕧$:zчQ i#kOtb3/=M'hOH)$CX-3pJmNrAkc-g>^4$[bT,f[ROM1tV "ߨ`@`匿	pw_xQUNn3Jɿk+яEW֓4j@ԝkN&m*mӢhfN :'_FU^!̎n
*[ܹ%mU6td1y-ush !
UVɢXlx6_^-\@4C]_=hC$،v8 ▬iK!Dd:Q
9IӰ+;#z;Q͜;n|HSPw
ڣ=h`}xuҾ.߹Q8CEEgÕTJ^r 2~;	y!/{<Wb<5*PzR{N+o1_|%%?lzz[8a:6e^;ZA&oi`p,XsUf;|`^L;,~䟸C79w#IxL\aBv~\޷;Avᐹlwǫ!NxsFwV"8*U_	GM}&'I`@u/ocUz6k>9qTW;ՁXbw'[F'.J7u%ٳr4B;X [ZےoSqiI1YFo(kDG_׶"
_7YSCu|£c_Py7n?ϗd^N6{䬙,k꺶Eށ/+淇RXUR۴v|ҧ}v;Xih`Ɂk	T$
|)btHgB5~_$hrQɜTz!+ S܍C'WH̕)@2STjhORS6kPdf"\-h|ʛy`Yl^pc(@erPCO^	"IT?3K~ɟ2 4P/IMRx`}&?dk`a6kfJ]և;w3TA:I.Vk+T	dhB=7#s[MmpY9%~oePx4CT9ADy%_K<Z{{z O/4EK\B&%wbJIQxefg$NV;0OoG2z4.0+*9N7fkm,߳gl
-)>4꡽&Xt;+Wi+q%-9*_yD%γ+p@w5E)_`6]ewlNyPK~GwBgitow769qc&Ŷ!
4gueg@n޶| ݐWCrZ~4ݻZM	>`%Yg~ȩg5^z#?$wPcU@DJN{C1ʚ6e]!Aӳwy7KUJWDL+6o\mx\a?J1
I"/GӽB5ζړ	
V\ߺѴ-?Gt%ObbVk%ZNkHKf*1F@3::OK%iu!W*(0KDSS1(Ĭ~FKs(X`"~mi@[I٤@m
"B.V8bG{~Ǡ6#ᳯ܍͒U,n솰h@¨紦xl؊MZѥRฯqVDϳ)Z羚9n#\ihWR}>=:~<s!4J&5T@_@zb":W]=$g0
.6M7JN+< Z#=l;uϤ/5
Ioλ/ |SBͬ
4ЫEXf
DPW=.x`1$jړumàʖ9U}2_M[$tڻ89sq\V.|4/g]
D{GȎV*ZppC<=ߩT7]'Zy_ @ѯԷnZ*
,=PMDgo$ȇ
xح.Renz),/ͫ\O ,C}?|X񡈾E}GU<<p֮>_ ݠDUl-1]쵽w̍
xUQYmXѸهӓ浢-stYjjnC~_-aq^8W๟Pb]jhwq2M/gw6wC[w]QR	,t4(Bt(ɜ]aƝ-)1fr<K4zsF>wtM I#.^- ӣ+l2!d>e.OWR;_>8!i%1Rc!n+J	BY~nE[U̷X
il~:]^ޟ59vAx1s^Fw<ecڡFs]Ol2Aiϔ޶pndnG;?Wcq1Fg7gg_" =MUVB]!s`nX\%.?_wߟRۖlD^οbp0GOq<bĥHn< B5:6ݹy>1*Ysv^1](mnk⌸DYyJPm>ɪGE0]wm>	tTw?|L,AZ=5wPNCh1s'|zfz
Wtzn
T
W"RvaVLRyB7bvd
YKgF=}/(έޭ
gz'o2
+dGq!7/^
ܴaG9@w+6q!Y>&?fEL'S
.\[(=C%+hMsI07*3QT:GY3nk-^u=_zznM;v)/OAL[_g8̠g@1%{cWnc%<ѣk6|`ZǰM5!{g1TKhn"Л,n`V̾	#J݅*!fT^<l
^#DLR,ѸDbDu.%yJɦ	\ Db te
uBN6.S!rM
lB9<N8Zu`2[~>|:uԡ*IFY}bx,Z>'h?̅uofZES=*rMDDdxp;X4)]ݛ뛏W:KW6O4!&Mf8-`Qw:.)װ./Νnnxcd=MRDڐ8Yo,Zq@FYPTk֣hhW7mquFaV$C=!y>T{XQloUp8?}_(&etv?P){!gc;)b>/3&/L^MoCT6[yз_|=z QrDt닻<%ӌ)?Jc;I=dn|oO);HFT8/ 0Y2VtU#ww35׹1/MXKG,25k,aOǌ(!bAvuX)]HSmb峀F)j&sj#Q~  DS;ܙ}"FY:r^T6F[C2	aގ
`߽P<Bp_
5YQG\Ͷ#)!c̑Ŏl
|P+≶
^.ԐX
Y"(ڳ'`po~b_	a#K~ȇ`&t],oI<qE&ڰ'wHϱjӚ܇OpZ[df'+`f	'[xKhyR̽^3/g|`F[0M6,za>S|7J܍SeظgyRo]F
? TuݏAҪ:Q]tQDBoRȫ"
ݭ}J@^j`.5Y
g?.5^TJ3`J#*N}!˒4Ccj^ٯPxގ?}n`G^U|ZCEXn܏B _@K8Tۇm̥
T<<l5;RdpǂZ>-0@mOKv̟k@^qz?#1VU 4#̀L|WrV<D[?ީ5]޽	*x{RK@$KbqA185fEݣ`Iȳ`QӈPcBPå&Cm/}HnL]}>OLY]VB7#g[ul4.UgJ(~ae9eI..tTs Wz+w
KHX)L~sє(aWPLBxݗ}$6H5BiHX+xɵV4ѭWϬ}4ZVUeoL
-99 ox &m8ø_/cQZuzz_/i6 pވk>M_y>+S6N!0o_'vW4rݱgy4.b"$
[Ne!j(X"eF<wgrTT@1?XVүt>)e-ӿgI@I)UhwYV|oU_o4a0br[ܟaA'	˰iJ/ThFMzyORj&ݢ,!rAq y^eԭ"Dd֜l|ZDYܚ]~g/vDԡn:H'|JPۈ3,Fq>;B**F@S_xnscHݹTJ8v/TȎGh8!1m!W3?o0R?l$l a,'F TX/aURN|*oeA^eK$r஥
- يkyR!#|u~3n{Tͅ.?|;7kV+D2h߳Jp)ai8`4/z]9hyr"?O܂ћƝ{$%#+|[dw-Ǒ;h/(r]%j4hA:*0~ՙiޟnV{LHQu})h?b^-PwSUl}NE"pK8kS5 e0 LC>$Bg+_*!ym!i+UT!C.M@|2LG8jYXP ̛߲݇޺;EhMs=W=VU_A<b"n-8yǲs=s27w&;AL#tq_;T|gP+#hq`ѩ*`'tO, I;vfwǧ7ˋѹ?|<>=A3zDLo,^L<I}t'& nc;U)*mo'OeBspa֍&sݨ{hƵUQD%b^cXv~D1pYw]Nκ7Zr[_uӲ;P~PU˘H@/.rJiȏܳDg3;o΢BZRm0>mN]̛MVtot-959?_QLlyI0f.^ 9Pq~J3:8B.E:O屇X" Deۢ4d滫Y;]|0-J7xxۻȱ5&eqcWDyF]ڦǥY;iŚD
%cB']ԃz7v$;QsvF]trpc\L(cJ1ZVq%rIZ_G^JrKI
7Ohe«ݼ,1z[
Z56WbB,Z9*A63	^t&0N[suXkJp=!:% n{#v+ԣ!)@CA/@zT3$
M+.4ɮFi
i׹*>Pv>`krưq(Yy`T0bAQ1[a`Ɛ 3YkfAhqk$K2bhOMPjf9"D|<REW~^3Ebm``V|
p
+҉'1¸ȼ-mF]b0(,MXISczjч>#<*{ j/|N %t"Tn'+B!6tp+yUW{C /+CyED#-rHJL";Z펲\r7G?vO_WH!xer!YOŖL^ZePKɭF=VO2V01w$jvU|C7!
hlų6mn!yRү%:b2#C\޴	jhzZik=5<a}jX#CRyb=[w<< ;Η>qx};M^Sw?Ŕ*~SfDV
{<@33
9nAuk
XDsJ}QD^FOljyV5bC^/Y`8%cd
!܃X 
*61$]3Vs1
ܰA?Nؖ!ր<̒Zx.cgPv<.tqź۵)ׂʊͣ8A
!5Tp3m4X_S.rnK,1_P_{ZO7s#w5|?s91wԯ)4A\iSڙ\LOBȟp3wtzvfeU
L  u=qi~l__NU:v	ȏ:QAdT o8ϒViʼ_EÈi=DTi-Rnj|	iKTAUzTtt?	p="ݩ|AU9eӣnwvѻ>x'i; ([׽9Hޣo%&)%<jҾC
Å=AyKuYErH޹UmWrS%.Vu<Q\Up$vc^@ZDp(d#Nni25)*&j}cn./]{!VZ~6W(dGh%q1K+.LTbDq8JTz_II 
0\DŔ!ls
}牖Dװu'@8|37'7`3v׾ dandE``HyV0+*f¸}Wф?0.@KT[?ЈgbcoiYtֹIɇBa`C8?,Foc]%$0bƵ̧l
L^[*tFp,D)%3d+ebNlO-O.z
Op9sz^)zq?
_E1G{s!F>:Z"9	Kה7hղx
'?Q#<Jɏ-ċ=:	.*uIi"?Vc«s?<>[&{Хִv8<Hw%^M?NKyGGѹ
ͫ_x't6,KQϩ`>p|%s>2P՝{bc=uvY",2zYVE}Bw?WP0"ZT,}-)!IXO?uƫYWV|R&p7:QJ/:z8|>	)}fѨHeTAβev0jyxdRv3W^ݎ!G#6ꖒ΄P!yB؟&gX8]?\L[Xӆ$lDtob)~1%_3X؄yCO ^cËءQBc0[Z\:A^`4PAZ=TcTJOEzjr1zBh4]J(QaUlaw2Sc
;nz8pذ2aT&'+sloa[.ڊ@= -2L? XFOi-Nމ
J:4Thjn%<׈6J:) 5(	yr"SФ ?X܉F
+7K+}NUQb?xzzu|qzF/fu#FzLrfkqk@l ;tc*(ݳ_TNs=l-mPasZP|JGM{f[4yFNWeռSRL#<+%WuQ`
_ǺARQ*ڞ1＀ ]V"-ꄬ^-,]I,2	rC8	o6˾5
[jսX܆tO+<exf0DO}Ll"x4cٗ-yUk>OV'*[JDtӪxgtY o.a6 XL3lgf7YvI$`JwH[
a==D<`TP9M:roS~2{@NXAS+2אk|{
Hc
'B cm: ќ $j2.FctD625FyA;(ɘnyvY[i&>c3'__|&eUOX&4e`g.:n'TH7@{f
\SZʅ	{긮*U
>9gӁ]FL#Ipc<W+<~UoMͶvX^j,/J<X./Y\WBbQ`*2)1:5xvU:"q
yJڨ];WŋDƁXu?`q'ټvIN!=~a -4Hv.ni&|LDCwOK@d'16ŭŲ*J2*	`NT#VX	l K
B?qif?FzQe?+6ZTq[XuwH,~UcTEABEh@	ɍzR=mДyiynVr	n.2q#ƉSR8٫Jη_F9ߊ@2OR ,OnZ(B&eQ0fC׌xhûddqOWƠY$tq史hE.IZ l~FVY*bRF#"*֌r{זͷңfRHRD<\hC^~ߩ;཰wh3IY[YY:#W8xWSd;z|=O[z-V{F2'6*7voD(w}f1N
Зf̍'[p3e è@ivZ1`>%C2NE|E+u-=vglP-<ڏouӊ {P믠JşRjGT: 8+mj&U>*SLCJ}[Nd$'܏$?}r}7//30{3zCi`Y肵rleÖ_~@I"0>w+@Ѕ4@FuV#e%ΗpsѽHoX5r`nl.J:4<n6`Ud2gw*kȶ1In*!\0e7&v*{!ѓ V78!b)PYP67zmDe%XP,5mujq
XR؅2zS.|j{No_E*O+S"X$Wח7Ǘ=YfeLNE]\3~{<Je
28T~k
vU4'TNҤXOǪu"r0쎇'F!"m"ܗg#G` DΌH+=8PIR7Aߦ3yCXE̠V0rDxTLZK<L#IԷJ3\
I4N[-+bh^B5#[)I|
UG-Ԑ	jJ F4=(tc8mb4"/%V@ Hk#|scx%"n-5:#1kLj*`mu|-8MDq*C>[8_jAfyd\j[-w8׌\)D%7r3yLԘ!x6lNBGHr-@SB]h".OwK|dK*.Y
bPQ1	J$18m7S:Ʌ"ڭ!9Sk/l|VL&O}DiTQgjߗa~,cƪ=zUQͷD_mS^⟂ZK6Zh]rY1W7lw݂KEjgWeTdR]Kwn*On jY)ª}yswLږ ^NvpXȽ%p8] *#Z­aU|AXp/D?,wvd=Rɻgjlν[}}HB25	5$mĚo^.C-ctd.K1]urߟ3-nBeV'xR%eW#BJOOn4R|:hX|CczqY)@v :GXw1]_=@h[x;,V>cgt6YQ>Mr>Fr;TNzT-c'(ρل/Ym .EIG5,8|ĻMf96ªڀGX1t
	;b}7$N8󄳹HKFAGMQrkG}߄ԚZ`&9*fׅwyQՄǠ	fwqt
T"E6RJy-S:S즋/hhO+qJ@qgNKZG>7#Ш̆1ՆcJ4}Kj+R'
(UŹ(IG@GτDJ6_Ő
GĀajy߸{_lZ
Y.תugшq(ho(31#"Żއ_8B?m^<_2fYrAX1RZn>/ZEcl=怊8<4Fnu5

=*#-K}ۓl>pK˨|E/b1,#Gh/Q@H!7GpXN UϤY @Ts4SծU/U( 0_G\4z|Iu{JϋlYܸ
wct$7; QZzcC}8WbJ'xE3/Z͢;EqZڳuRǷzwɅm)&p-aO.U.Ipg	/?CPkzQ⚤$ɐJ"K|#AJ{aר"FPrVj%@#zExgN*`>8CR50Ds!!ãl/}M56a 
p	(Lܗu
:$|¨UIzuVW˔~=$3Lpu5?ۮ0ϼkRuy*xA"@Rd3*(o&>s09U[Yy,P(؇9IYiA0dIxtDU&SuK־cR}ӭ(خZ#$W`7qEhY!<=2iʱU@̥s3͝:{L]\\Gm:Sj}ԿŤcizU퇞A
-}џjrjܱ֮g6Ջ)[^LQ}1z76S`!VwrA̵懻{UFUJǿS5O`gRP$t75q	ܷH.?
D|ktVUE5bB
,Dx^Lz[V˷.Ǎٯ_u!KlT]gTFOuPsmXD'
.;@Haz'n	O\!;y﷼֡qɫ-@|ʙecT+XUT؞hT$HK
0tʷo[Ie!XcJo>-	T`Fݩ,3dG;,Q8@t{K4e3qH"ɴ@ewYT,0%vTwBN
n>eT1Q48$
!gk2l<փ0s	)m?<VUȕ_paPIa˳dуZ. ;,n΄$o[v_tI8?u/%/os	VVk*cmichiY%k<}K墙r񶛈vnUtx,%
ؙED0\ۼW12#1pϤiM͟Y:4>ҏn5Sjs	B9lQz_l[LUa]нG'רo'?gѤ|p"KGn鉚MTiKVb|.FPw	27<ߟsw8T2VxM,7d^sJʀxcWFJH6|N>UHMl$s$⍁Ɋ
nRy_h
1NFTƔ[+!vF0[9
nͬ'̯R}=|hu7r)r_y #qգ+(IgƋS&ws/E-HA >ds/Ee^Nn4W}7W":e
d~r(>!,a?K"'tLF>JIG*"vCF[;MLC"&.oj1Cl5WȌ߫?j+-3x$F]׎o:z`qrv/#k}ݤr'L,O:Pe`)ZBSLKH{ָȍіx?ϗ)j29yZcJ1:vR=lyfHTʞ:$>-%Nؔ
_2m>'0!ڲi&Go{o?\^޼[v2K[xUD.E&B
_:P5_,&\Ҟ.Z5 x-{x}\Sybza`,;<I\u:WaAI7Hev+g&DiT
n먈T%;,(ILU 0>糋˟+di)SO8rj.U[
?=XS[N[u Gǉ|p7kmWt~x2PnMu9ӄCT%ީ"ˇQ%|}`X>m->+QV·_QSCK̇D+5{=<|46+Lc/ u$JnXh^AC/GYF#I0wYVd m_nh
7+Z %@ŏ{ck@:jUc_#Z,DeQe1
6|!\C\T}.xEA42)U]֖jVv$ӽXSɪak:i~#I%*dn
F~?=X-w|N%[P 1+lppd!T$QV!o)JbEU1zjAZ}jrGQ"$nkiV}:D
gQGEEENQq+7X>fm3
uk\!%Ǣx!%"ŨeBԄ`ߺ1	X\Ou*
{.#`LT˸To]7?.^â:2d~I{r	`	u"$V`ZX7ԃIÈ]Wq#
<[
s*l**_ZɻM!ZN}
kg&H2"/@bԧڍ@VQK(T7bdl)V
X;Ω,RO.gw9D
]cabd@P<"o_1m
JH(|NV|b-J_2UhN+DF =Ym
hcD+HIU|Ooϝ;dt__=(
Y`HA/5oh򝉇JR+"7);|aUn*
A+1A+r &*-ft\0ԭ=u?Ϻ.-}`
:<df΅v#".y ^Xr0Py1+]6Dgt aF{d:?s?]ڲ~~;<^ƅBAQX'%VgkMC
qR$aSy~Y]n?ȼO+ZKq=سaOrw:2>ѧ
g1@z;_{n+'7&`_'Bbl,e͙˨neyCP@B*.ɉ*T&Hܳ<RrthC@kgXAC %%1L2I,JU䒅xi/>Q/tEe&HĸUP1!'⍟^\x'|Y֮764({	4UWZor݈+<ap7Q$1V
<$UJJ$!-#wbL>vaIy\JKC˗O} [o#O=\ 恴`أKf!=\T5
E,i5}YFAަ3פYA6Mɏm/E}- Qإ¡Jp:^1Q5txT W=RQ^)葁DmLuUX_J,;&Ce
?8j>/H"Q:5/05hSUx#r7//U|܍m]!4^Ņ2'5i#ˇʂo!秇
Iȕ2yeK.9}j[`۫b<lKɠ

Odf{z}}yݻ}>ݜ~VwPI3ot|͂͗8ص*/nt*\(	'¾zl&Fjx0jWbԹz3Y
Y0pBw
ݼTWؠT&)wIV٢`޹JL`A\ޘ3PXD".oFXRXLam4 |	Q4}ar%OpW6N32]rLxJ5H$0Lw1c|vQ=GRGt[ognFe{0.Je<;<SVc#uFtc|ɋԓSij&|-2zP<C)lۜ};,4]BT#bz&`5=*Y]ND$
Ivͼ*k8+|ttW"B|lU8};;)+MJ/!LX{8z
5le;히|A4t]</fz13?m]?&[3zx1>mDS0O9@I.[q:
-R"Z+򧯔Z-x#os(GTw+[u 0eH05IFdx-:}?ESĵtX&+I+~CA'7 !<u3]OȻx}SiÐ'_/&| mF}tLp5@IfՇ|fQBÙ+SWdU,yMJPOMo7bt骸|w-Xʯ5Q*9J
.DBWU^4ȿ,'>ڱ&j$_`5q^TR/j/́%sh[TO\*N[0FQEYj!+Xch m1͒SaAʣTׯݳ8f\2w?{,^UQhdEw%ECC%`NHlP
2:O'w%}Qg-eEVЩ%ZsaUi~>3p50j<~Mԝw1[\][e7ܱMv׸l`Dɩ18>=<HmjtlL=4y$&eC.[*F*wC\:kndz~$L[PQN^tasߍ
7Oi3猭f(MmC-g+qywv%AĬmd_v)HtaO騇F΀$pxzWK\EI	wQɌ}e\/九y(
60(/6/6ewp7}IDKY	Ɓ@0l ̬/x_ nğHKH 
;Ht(S4Txxj|UoUh[|Λmjք",݊%;3U[ 7-{(X[*L@ۢmPq'CQ+*"6LйRV|J0	B}WX
:yR7ih=;}'u4EoYaƗ0nz@x SՁ	.`D㛳K6D9 G!z&6oP&n/cdbeVUobi?ҀGXYmI7:[6w;o;HJ{7v
[=6"ʒ3 '(	b>
S*7\o!Y<aĚsߪFܙR(ҏƣOx
#͖ߦ1ɯxPP  ^rXD,`Qk;Ad5v!kubI(EyKU=(F

3ǡyb1ٖ*KVuڒ8%r).D^<>v6t~̐(8. r\>
G)xL)u
'@TG?J)
B& v\4B#}pA5SGܖl]fn*|j][v韶D2W~JޑȪVȴyQ>.`paȄ"|b83W^#>v!ᥠxBP9kJ5eE>$:fCR7bSQetX9fT,)
kH1V)$"80c-J|-䅽lwǽ@цrQ;+b}|-	cs@qx'(^E\?Rp1^\@
AX,m-)Rrx
@=m0x9&'(#2>ͮ>VSXLȵz5G$LHgnn<2q,7=ȦGoNqu،
Wbua{|KQ;SL@Mer5r^P=.e4~u_$}# [TW	B{6*x@cx$'xt$']Yg˭{?CL|ZתLs"R郚oB.e2kjEUTdq.?ɷcz_]gUdv㠹DqV<aEPrRo5p=VmK_F ;/νItwaxy<U5$;eT  WDu# s-kÌѡ1dy?kTM߷/boHcq+NTo,z*\ NpU! fԪD7lfD"Dlm
nX1*<vù+n-*M$tu{0"rU]@.AoDT@ffZF<p`N?8UL;D,GuwcA1`ԠF!) &>(
25#RC׸PgS}bFG$Xt i11OҚ\!rڏEp<830(yE5iR>ZF.KeUe"Q1D=˂jfco^e=S} FlmeUД]G+-\JLOQuCxv+?$C5`6}~܋ۺW)r	f[u)-5h6	Mn(?\}ʥ4{(]dce7,>wQm-S+KeJogx q2%Xڲ7	·[!G#3ˑ7ť
NSTܨ)͆'qfDcRr<n3n=ʤH~?Zp:M@ۜ&52q?lPtY6pLIPBl {f"O,vf}7ԷK̋YH+5A$tfS?rre-3y޺§J1.]KDI:=Al-7fAûMiFbSJ1tJ285ɼV
;fA]	+zUnxSZǝ''
?n53SufKlMX՘ޤ 8J6w U.snW;CT82
Am|{L˟O, w·dxj7sIE4-/>JȉD bUfIkvE2.R%hgC^xn?dKPE)hPɝVގ$g5筯0W'Wmgoo`qp/3q`ѳBO5mǆ<rT)
.&w!906fD8KMo/ʄ$@f80Fi٬K@&sF4E}D{<Uz7B*U#bFYbbb^إ9fr	kу8qX{pEZIY֘VpEZҪP2{b3Vl1^<r d֚*

	$pFx\3GѮ54vGJcρyPMŚ ¡?Ա)	}1@a
e+0/EddUɯߏ7ĐwkO<;v$xٌ4אѢr2_s^~Cɾ)ZvW"Y<Ewm+SaHxF2fW8ǗקJ-O*4Kdg[#u%AFVJؕR[#MZ)~9>1,𩹀ŗߨj/hAYd")&3i^	)a=bퟰwP7޻&*hN>sO2"
*F
0wf1ч!y:V
e%ءĽݦ!"򅋸$WP`D"Wʖ=pV%?!Ih ww۩6|+eʎj GCCzIL.%;A_K=+2G]{os[?lUM<(䄚׸+sۗ\
jM밳WS/x)c8C<D}EMV,ud|:ͼPR9'*)@+{7]Msqɧf(\=N:{=>_\[(U<û竴Ү>[ #TQ+HIJ=C1Ƃ3y-"z$ijLZR>-kbnl
jkGWiK};SFhA4d
TΓnF<P_86<0B8$פB$#<3>cIHZ? ~w0ʎQTԃO$mWk5 B0k^P̖5>)4~4.pNdiEӁqXPSg@r
J*tXV~W^s̾2κ觼;_P4= OSsl+E[S" mp.z4g[ũ`Ŭ=n"|t 4$ߍvS֫RĭB3wvQ^(bL=N7z6w-	[HAoKg#TpAU]
AoEs
b7*b~/&!Y*de.Vh¥"36u\=fyC9|Q+..N|Xq{&Hg|6Sl
@XG1BӘ};J'
!
31[>bKJ4-6S5(ͻPh%ucBM3/u."D'FrhX\h[սHaE&LG}f|kf3|1B,-*gnfCdFbkiTooW1W4̲j«mkKWbVXW  
ukG;ޣ:Uxo*L,u|BƤ)3` "*G7471Fi<)Td$u}uЅ)~@Q'FZ(AEX%[~ؗ[4q;ِ֡[@2>K?GKo&`X
ZzA2S4[xqLR8۝%c/)\H`xDɠ!_ĞICPAC!X}aAŠܫkDLgsů	B%sխЏ3
W
w^!f<i~>< Pe`עw>$'Q},jRĦcwh|+â%6Ѽ壼!yz3oY0d[`A!~5Vۏߦnў>؇݊^k*p;Yj_ŸFaLRooA	Pn#qASE߂)Gsj<0Pu:/fH9.FXY=U<%HY[09_j&lJYk~zh4WM++;وyz`PM\2钕X\&H/O}OR^ІiaWw."/ЛJ~y9%+Շ7yxhC;Q7@3ހ7WJn05Z/KYH3HD^,,9_ď]ٶ!#ݤ䍯s`6hHcY1ypMA
p=
I9xa'oFGsv1 
WۛGR$kB$&k,K@&8}}E !
:ˆ
J/oݰ*` )GgLAFRBV2͢Dvå;Lyy|3Ȥeh(EջPβ2ø+j6n*q4 MWcF_JɒETՙ!`e(DՇUq68wL4
L(BEyJѓU_ưHWG?Lݚ5kYjee ?!T(C2#+XwiC0^|~u(:6u*^a}\zJHlxYdL}6ֹ =_7	^ن+m"-_"spB?&-/=;WGv/h뢜Gou]-<%\
Rw*}\hO~2hTjxer}%!j
Hf)!,T]_E傢ZMgDA1*-)'ڦUWݸ3#Vytz0՝A0(lNnGtr̅=L[Ç^]|8?랂h]jn熂ɄRFO.JE(#QV +/OҿƭnvCFl#~U$YqsK(X7l*:>\: ynmkr3(aXU
/F
2]mP0R7/6ړR4ŀ.Fp	<	^-PP-9Iҹٜ͜;n|HUPu=ڃV?ևW'lBȼ,:+n5$];9`{|f_Ok$K9(Nbw!\w&?lzz[8\s)+ĬiHhMUr4kA77d|LLt4<C79w#)'Gd:Oa-P,hVeS@;^
q*h3UdN PeVP?$XtX~C9{S}Tyΰ\^Hk!HTr6
YM	\"֕Jd/-6ujH%81r!OE-f (YrI7g[r-=
Z= ꯘR0qIe\0`{K("<Q)>a0d4Tn> ӵ96w{M]׶%4Vvy7I)64Ç)yݎǈ:<lZ*lP0gTHƿ#$l߫) \c]cϲEVS.!+F<ڽVwc(~GP$u8x͵ȽUV`WD{̜3$QnZsuGBD=[Nj|D {8tV(+kRtxf)6SFB ,fZ?3%0WJ(C>ޡ랑ϥmoʑv?z tYuKM6_B 
_O2ᖸĹmTՉ	40JV?wgFW]6z^Sp䣷WCtF +e;X"bFHa32,ޥj_mnw"!y^u:(^$Wk)MɞW[juZw]C%uw_
/%5'P"ME_5^cDL=Q͇()m(=(PY ؾB$ATPO8M`ySAN:qd3th˺aeTrǾ_;l/]Ĥ.%hN ٖb<uREk/5_jОHef'A[Hn>}~=V{F#٦jw&4{<f1Ph3'YG~pe[]*ds$y%Xs_>CwuifUAmL<Gu#'(S1[T5~-P_uիfSbn;evBRh5>CĺsSA>΄sPpk/j_LDn_E
듶vmaъe>O+ac>kw^iAH75ZV@!e(j*ėXK*I
-kqxR^w[O4z!w3xDꃤ="B{w,CSMV$WN)U7h&Fy@8p̱~g$ŇA@MU?WЙFsVٵ,(CĔvS28Y΅w-&Cbb@9ȴp7r=TW[Sk~;%NP!@O;-"ƍ7߉mΆgx)=4R+]Qp8Rr1Uwfΰ-<í4-i	%ꆅKpԓwѢ+[BYSQ)wHOQ@2 ˏ@++cy.=ъWJ?DJ){|s1	{|pVn!T<-z&nD3s-w݇V-
/$R$zQZUt	Ď&xJs;M6	qw6%Ɵ̣݈Rb9<>Ex	(ZvqiD`im"%HQ;qKVkÎǈAxx=Xd>fv#+Y
q~!MS7.a|LevKPS&81Cv}]"iاx.UlVĳ"~9yJ[у:ʪ:cRGzYTHtv܊#^}5Ey%hPOۭzyTwƯÚ[]6x
*@zTU@wePAs
wd13@N$QZ5g#_HH˚NE]$M-Y:=sB0(keJ9y4L$jDu4rd8h*V$s5p(@Gi*z>qUa_Lw{,eESrlɤ7)7X~VB
ˆNa"<hfi)hbRl )}w<h[\,{{j$U%΢2x
hHfU)\E"ºt
_tnU7ܤ+&/l|Y2b)Q,\Cd(PuoޣmGЊU1=QOik0X<KŜYxm&
0K?2:K)9}B~&`h7u/vN>(
`syι\:%B,01<aOUBHR!6*}}Xcpgb6IqرC7.AܖI	I̛IdqrBxZ#0!{8
;mJ+JpR qi/v=IY;zse..Sdz=IbO ;snD׬f]QWo_Pݜd]l[g跚Ѣ$z/I>ͣj23z XSu4Fpe~AK`Y)(D(Ü=6W9^cq
Ie@>һbs
\WfCÎ1
,I2
bG |U*[@K@4di`J(K_&0JRh;%]{"a|-E/ִ?Ei.T\O͔*{L=o157듟_61iY6}aش"IZ1I
yWnɟMPsS4nF.D$V NL(?d	yH
,z	(Xnu+8St%HG5v,&m7w7d,oq&ChK
JPj6d)U~Jڨ(ڸ6<S@j^F\0psm=V*Jq/h-Q
*[9t<o׬a/ѧSq.Krd@gRC[]_
;b,vV翵|)PgPQ P-.M?C]Wt/1$DaS((ݛ[Lz~cx!l V:Jt#J(}="˚
d})8܍hϷr3e_Űޯn_>>6;ƨ?y
cӆ5iqLbHDCsD|
;bn.;vue}+Ъco
JK$QX,KrLx67 dFU/
^FQnK(Kp77aL /MK>e=SpSfOΨfG]2I?j`z	{#e5"0gob[<eu*
Y
&,:kΧv+[
ⱧZf$'7B#o'{*
~Z~
2~dr`$~t|wE;Ѧ5I¡_yD4Sг.A,߅ࣥ4ByN$-b䔓4fxC?e1LwT}"dG3H\psVl1aCI7PWg+6N͇CB0$vB-*<oJȱJ Q^B3^scxyQ@9MMCzթi`x[G37u] A)ည1k-[{1e[1nOib^7"eο%ذ"-sAL@Be+zAR$}B-%wOOv%udVҿy"'69S˯1&q^٥iWNO9e}*KH?4ḍH]<yEt;]s;
%`X}QP/θ셊`b}:BF5-3׺xNs7ѓ
2j(4^i3d$.p
4?FXt(-{=ԅGZ|"Cw-ٙVv*"z!Y.g^)IxA	ܱVàugBmE)}@4XXڭ6eRbb.0}>Bvie:L졈Q}wX8U{öz[[g[jOʚw9..m[zy0J#2wqK:dU*XT1Tr#!ӃH*{K*LtF(!CHYsZ6.Ѹ҆QOou7HÃ,pJ(a5])/ίOR =&Mxhp+ۏWO˨ .=Ч
\ehٯ1NH@-E8m%gY,[}#>945lkK8&ɼ@SYI1Y3(Pu>zt>Mn".Y:Q~;޸}ES^lV3}(?{yP.P}>epv
Tkʁaa	w(KcSzaLZL1 qv+U҆3+U}Bck<qL݃Ξ/lUN
%qًd=Prs1~[z@GZ@Tښ{R!xgf[T)Qc.Ng`/g@NR	fs߻b2GJLH1{gnNOz UWI!
Uƚ4)
@u	;I{d
(/%i0 ͞{6A6׊ܰSaU
^SѰep D7˼c8yQ~/]A )U~2*>wÞe1#

#NUY3:V	wk11GpRs=2jx"f7=S]yL2`#ME
0|j9m^{wQ:0~+T45bXPKɝWt.I\$YuX^@&>R>]bǾy+եY3dUM&,	k Vd\} L7)偁TG7r"07`܇{1Cb̀EAkCatTEC&8|R?>:(䐱mRbn&X~dzbB}d16z}#CxNylܖ34Ǩ*j)Q3gU}%Ͼ,?/qZsI)05ψ7'.
5c$S"Nd:[fX-Е,	(|or  [#{b	 {V@=|!rMh>SZ5vg ir )hM#](g<V֕?h̙4Xډe)Tm:Shծ[\C7)3'}7Ckn$wѫqCy¼PCoj1ni[I{Z i.>e(G ?#AHj1S,\q Ʉm/	LfqYf=lDBeN6P
A<zM9yzһ2ٙ1³#T
˒ۊĖ{CJM*B91IDT}??wO1= Y^.Ɇ[kA@%>+ڵ8((jI%Ue
6Cfl)Xò#4}~N`h@DUB #]-r)*qmLLQV)8pe!CQ?G7{2X}9gkcJBTQl'Aev;?\|<?xfWw^o怾HfL
+e<){=~7X<1tSZ%G罷/o./z8	LNXG㷂iLwj,TagI11%z"h?3:OBꩱgRP!_2sc/jvVݠQYH.ZW&7L5Iբ}eC`qSnXfշ Anexҕ޺)'mK%bŇhw*a,TNqm^`dې gmu6ʱp[,%Q1ΧޭPPZdaf._#k};_6r,ݷsGվm*k+Wj\N^)Q$OSaӁ^L֦UPe ZfĐ]x8ɹmhMtB<l4<$I&f1k@\j \ӳqyqHd8sQƎA/e"H!+l]6Cg*Z|h}nxEY+$7ꮔm	Մ.s=~ݠD3b}4[\ԃ/9Dn9m9@
ss6Pf\LܬYܽh(jVj޲'ѩOQ=R_~vK)A(ɚ˟wwg.rF
\cSxmlpp،嬬ڔQ>=0W@lZ$j;9}iW{ff\9"yU)*A!Z+!jX$m>Ct'd4!ьgd=;%f\IbQ~< %q1LN]BZWHҒSTEFD{T9
vMBa|Ѹ69:H6vG1lO0&beo(
|O\F?z+5+eE
e6sU
1®B݆"-{'z^ȄL֮!%t2ߟ"
u0[.`Q!qRb,E:H`qם|8SQ{?ݍ8fH T'C)liFA 9_sPcV|Pv!w>Dqr穀CZߘ.ytJ
*s6; 6!(+Vf,R
qdgm&8Z<M4#sFQb+iuwA\4
3t<Z
vOUrkU>u]}랕 QIDJ)GU!)@B}scINǴ.e%8'ZH w+ٍ"8(W4X'bCLlx8 geLcJ"igR$n"A<2@0BW#-`,`qQ18x`a~HJ#<S%ܯ"飼\z nv!xdò
kL5=/ɣR,ŤZ"j<xŉL&f`K$%s95۬.ϣWg;ڐgЊvRCZG`$1I&/-11
R|E<d]ͭ| ƜMLsk'M[hgs#rV#
P[@ft{S~~Y!@@t+c>v~mW<)䵻&
tdQ$yw-_s?ѫ`WT
ivp,u!v|8n;zi2œwcnz|mTch(74#4<oyZ!*9Jp8d'o\[ƥ(LKٕD.f%-J#6~~gq9Pp2fbJ	DL^v!2SE$h_,aX
˳]Ics6wN@nP_e 2	k-D1.[q%q~<(e3Vqo5Rq%x3c1,3-"Swo^3G-o{6d!P<쀍w<Ǵdrh±kDU+%]KgT1GgXA%S|+;ޡCt<!ѼMܥ%7gHFIm1Uȴx'6ܛI~a6t'IӒ9;4MHlN"=CzRӍ
xǦ(2MGQncn4n49Og,ILb5RVLGNCT"DU"\c	řHkStjz
hwgRCȼF&Hu:zob|[iQ[HxCr|ʠ&{tڪP\Fg䆩V~nqr3ׂ/@5cL=2Ӑ04OyR&rrwӛ>{)mCDx3Ǹ.QGfw"`wߊ@[JSɔ^KLe(0g16.XuH^)AUV,n.]NBtS<'ɩ"_nCi%5w}
0UƗ$p^|eC2(w$EMw6
+3)hCh6.DHf1{h|'.!
w>CN0a˝Ds\mδXuablVz6pnmb6Fؙ4>7 ah/
h({@8_'5A;̇[2fqA]b䆅?~JY[w7t˅pgJJZ$O rA~=Z>q7I=ƧmZ
wW)P]w;>?=Y문 !8tG8D_*]2b,KYhgu\D]O]@ޟ!U5Iw<<Fևs1>*y]r&
&sC_ϧCKJ
dC'_ЂW^˰Qq1xBM:᪼&W@vO7BAXFe[R/bQsn͢,$̸;jY<(RX=m
n4 >b31| %ϑѕU7a1Uj7LS%C)H-&
ŝw5c-\xD/q.ITS^UG 3ar#cg_b0%%F֗!ܨfR\Uĉ6au:d+|Yy}$ Ī,
h{Jm[+.TyUIP?S F:0<dm*/
ZMXa]ᩱyjٖƐ(UCuCD(|6U޼vǲӧS'K6^)!5,GbFKeAђ8E~CSC^/E7Q\zkW
u_Q<-a7qnUwD(5z1z%t
aW(qr8kf0jXWc)M(|iP6fe:_=|4W|[Cfq=Wu73+7,2;	?#U1fR#GK3	5y|6>fv	cH:pя4%.6/ BCCQeN߀GF!Ooh!{\[P44^ƿ7i<c[_eT2C+r\V@=.<Ix_e4MZF	˟5^dsoy7݊.M_^=QJ/ʹz)|2l}s;:(gG'GEZ<\_iK~Rtm֣}񾨽/^~v1*
.-|2g6B݃ÄL6-k<S]$Y[Gchl݁u떨Ǉ`
5	D8*z3 OzH
`	})o<>THWý	-vU]6"TS S~$3*FZIʕ-.?
A *2(`&*f'˗%}cko06EIG<(KFaP򍖆L-:;=?齽 B&X"'Ǘ'4G&nW@|>N'*XHOHǎX
xhn+Q ZџƇVsc0jJމ7MLNܞR<i@Vt],wA$^MLo-<&"ᛂR1qugExZK3S	Ҧ<Jb>"~6.u3@2ˣS
&|xe_"wbAӻ| rvAhǽru_Eoznq>.O)N_oهˏ7/;/~}Su3Er\k$e-N5eUi/D"Rd+R +y/kqG=&RPlW%GlSE eIдw,𷎺gg]0!yqUE9ٖnȪ"ROMWDSsS
& $tn,뛏'FU)2-i$)!K:|}kfh7@*&aĸ'P}
 F[gB= Dkl[+3pd4)0Gn}k(I',/W0wъ'
$6JFd+;ШrJ1ĒnX1:n=CvCr;Z(`)b'z(]G۳_Jܿ/ƅ8}Kyp~Dם_ވ)]ڂtￃA9AdWW"pbEǐBWo6@6ۈiM3sX&Aep3$3Ԇ-mW՟n_^\ݼu	}wrz}Mޗ]KBR-ln&h"'d%/7Jcv"W{tRczrΜq
,1ۉ(BUVB'1{/cz=(?I~4!u{e|^
V3Ufzh$\} dӅǼ$;=Ag&]bO"#BlƃuAThlE]7*T{p#5(^ V"߹=>hTIwHj<hclt@!$fAZ2se.J
v jU>"
 ݲp%Cd"D;zR,MAaAFq?q15ްd#H(Ed:Gx/d'P]C/7?~\&?r=
ԜaLK?^b1\Is
+Ct}M MKuP3Hu6֠p٥
IȎzYOT<BZmiv]ZeXb<]#=?:Oǚmp̰E	zc;+ƍ"%;D7^/
Qד]feo쇦Нfv.!]ޡD1<g|m>]kjoآ6u|wnʿqY)(v5,ֵfgOыZݾ:J/+[KC+2n[!{'aaՈ~<mл<!؇C
7balLE8PbIs
 j}^7yV12SpZ6,8 :{zƾ9Bj8꽁7#Lj}&YT=HP!IQ2yF< DL5rˉ:oU:{F%B
-K:7ZoNgvz,C0Wt#ž2H'*Q?r4WTxS1
IʻPB+˃
w@ZU||$J48*Q)Y|ZL`*.k"3tП: 3{/XDTb$ό,^@Rlvm8
Xi7G,lL|}6wBAU"$ܓͶ=1zwvN={UZt7H	B-
#|QbK+UR:$H
zbL65oB=z-BQz?~vȍ-LfFz=g/*Y!>ԅ}>[j-DBwOJ0kY@
$,ՙ־%[ $}HmWw礽wfps!Un)/G}fV,a0"KIȍ>?ϡO
wXQmx2s\ɚ;ͣX;d_Ju1i^n=S2;j{8NMO4ƤX!ըo5yU4/FmaLXpS~:Ce"+<:IUӭܯꠀth^2֬䖘	iқ֏i:s/:?UvF<Vn٫pjkYSL
'+\wEBic'GX%'mh54Z
踑!fj˜|KKQAw/
i	/sc۔}Z E=٥, ƫfc3#Sw'7S,ZbǏE52Gu^ HBZjkEPhtb]ڸax8X~F2u*v4ctSi\گ\ OKeG`XІ*nI*K|;{ʧ:j?1.Q0nxR݂6w2lz
d:ɴ28t~ɻ&:X `+&걷O
rcKqҖBtxkc,t={wvq
OuD,j<9'j!kR@~7(`.~Z)P
>$9"De
1!qerz]~B	@x(bP[._A*f>O?R	vc,**,k2Sm3,ʙ>xej)>s.2d@aV-4V8rnכV|݃#gJ!vDc	JֹU{qm8ŉ![Þ8#p}a_K\4f7ߜWi
༶mX-X
z6ɪ:=?-f(r(Oq9c7J1]&)RoIq}
X	٪QJa3\~6"ߊO׺KOrڭABp8Sϟvտnnen7:BpMHQiS$66kԫaӓVЍ/DJI)8@j	AHKSj>eb(H&Q)^hީɏE63.GMySu]OjK*a,،q-zMF8`<6iH<32pr u{k*RI͝(ԴJ*V|n
؆IkW!+X%JB<C}/n;˙7
K\:cըĘWHZ"HL4m!$^VO].etݳ1l>m]Qty͢t1,ЦفEr {R׌\ŝ[
Lx(Ph
諥D|͡L
rU'W=#.ɺWBjn{Y$s/۰f/4c>:S;T~5wO/?\E<lY@(	`N3n1c;G
4oQ}QGnz"F|vs`ۗ|*eWr.DOß0qB@ITx8S|-.
u}8p|'-f87cCXC8_h>>$NՆ<HR޳/-j
@d01_$n^fsjP@,56fvFDWðKO٩20^z+΂W+jaNDp 2QI&Ŭ"TIM1!^蛪2ԭcwL^^8ttt~CL||Z0݌XJ0:[^e7ei;rseR*x7*lԴQ>D'Ďn5
#TrM:tc>(KagDkȩo?2N7ּM9+VsU
NaMr^=`/?YOOՍbWL=9Uk!`)
|Zgoa\aGFNAjN[CVڝɶiTT=Ix!Ii񏽟n`QyaNYjfk	a~;ƦPf݋ٷiێnoĿ5e5no[gH	#"<3 걆;޸v\LUa@ݴy?G I`:x'*9ۤ=Xw0U
".gfB뭰)4Lt*֞_٭O-j
L)h4k߇jV=6?:L>Z%8[VrsvDZP, zݨju #sP^V{BC$[s;En`ʸCNWu_ ߮{^j]K@q3qa2ܠ]Wg0-ิ7ȇzC(hU]oQ=V+_^XMpnZEz{,)!k c!Cl_wpA+"j
7/C
~o}b_|blׄ";~ҒK|.R@,Ogz[xY$\uTqa{˼EBIb$*o ?*ަiޥri*c׉Ef\W]JBnAt:֯sR>#ܘ&JSo|4ISZ#.	enlY#HQߣJYB^ƭP-PmHuF{&)4YiZ誫ܛ\]_*H
nQnpu8:-fRM-e=xqk11.N/{Gǧnjt7_#Ir?3E^ӑgjbDb55ϝ|ňAq>Dog3
pPKMnRUs. jFE{-x>X]1Hv)1SJ> CyGy~?KL],us>	XvS<)Xx*͖HkO*);ƣw6e
!=.}Kش0R73zBc1BՆ௏aa\XuVKO[}<5y%c>?]CrJ=_aa5~̞/,&q㽴_y5V\O2zU׬4yT5{Ry#WQ[g:XV:V/Ye|HGlc|Y4Ct3aSx1OR?\tHV4\Uc=b{:ޡt-MmAXT03\,SeR=z,?A3-xu٨rCr]0=&iOeƷ'^A.ތH_'*%* b6Օuz5<ZFW?Uߌ%N|6]h*ܴ哞h=XT
w xG:<ZkHHU鲿v;nC:9nt>e_ՅmniAJWv,·ڈi۶Mp|5-[JF.ºv݊ŤB<) ,B/tHGk(u
Ne(dUY]D-|y[6/ǩv,n}bV3lc-jSx>ݟ#7J9
WMжWw
g=T8ΐ\аM!J^ΝG։B@
O$IR
1tRAP&Y Φ?/"ٵ<zTҭ	*Tq[TBuDR@xE	V֣F.BK&ݐ/]yŬ1KL HR.Ж9$֊FXЅCp_Tj)˸\T7ZRp!P5kMPeK8NL_i!G%^/ZMTFQ&!H"QJ;ˎ{Rtb>o<sH"!BLW1v/܊$\QZ#W5Eqylˊ?BЋnC҈h]G)72a3(+O\&s(LeeU + qVLEq+mF+`.਍&ߧ.q29ԚI;BۖUHT-2&MK+/CY\W2oܹN5}Hr^+\|Hs
F+GcT;<_L{7KJuSΤp6wԂaXsCwU6kej5$GyQ)O-qKhYυP
D뉦n9^:CGˠz~N`oY6ݒQ Ϥg7@#eDK/h63U;dVNt7Vh+N{mkF"q]W8(2AENօ%5caݱ\o]S}R&
O9p]VPExE!0ϭ(֙3loPS/G-jlC}{AF
sH07apQYGV'!Һ#^?ՒX3+M_*yU?)-nV*S6F:={"Oxy	Ie+O+{0˼VqǑ.$Wg
9 ٻqWdUPr4BU'&TE9i$57,&vvvujy3^Z<i=	TV|P)rQ1s.ǅ{QS	&&.-
h4qrm|@U3yf#[p|P4:x❮-xx@``1Er
p+@Je%7yEBQ zY\'[H;Ll4qe76-%B qZUuh ~XY,;>E$$b"hWTBvF"`qgԏD|OC,]oY|9Q,"`$[>K*{3j	GjމfNyd}=ވvmT֨[Q=%X>^&tjˌO?:1RytU;%"tfn. t,s	."tԾ:Wߔ<,KbA`Ees<R86E(Ѫ-Dw.*3kG%0lyJY;X4y7j,g~\jLԩ5d=L`[yU!%t@~: [=X2fLav.$AX
!993TeCM*r,
&Tc*uF**Hq봨j34l2K(&>;֯ ^~÷l1 foe=G虊5rM%_䐊UɈb4qB-;Bb$h`!zi-vלdjyh~W6uJo"ￖθcX^v{T%veM~v,BF KgY{jį~w(l,.L&)[4\uqO&ذ0PzCAf5I$J0z%\Fޤb~=5O$E:v\N$"^E@LT._`΂g3{9OwN?CakX ݚ"%/[Sl1.uB9ᨺ܎@ L3'>MBҞ*rsOn%ltg^~7};ވg=hzAXˋ+
H T\
&3IMCqKa`:Pgـ"j_Ȱ|G_8`Y݃rUWDhUd&ۭʤii5V`|J쾌4p-uīIWze@DYb1EO磻
-;wuLO01 Keu([ yd>ݏnsZE UcQy+	+<[ҐFO1e**Ϡ?Nu?'+θX۟_d}1yN#ٙٜyyэKU<GCm{8SUYn"ZwQIy̱{o3SL[i҆u`*}kܪ0>G頊_L.~Plw.jKܨ52E`TNa\sF -čm^!a#6k,^ED7)_A9ZV=h35h=kr>	םXLe+6㓩
hnuW.	cw	~<.y/ZhZMaxG]U{O-T{Ïl.6㳫׽O?OoOO/Oݳw秽pI؉~sz,e?{># pI^gZ=t˯|*<&Xd(pMxv,B\sH~WWRfL fNT(7ok;OsbbWPnt_rWᚊ$,MT蘛TK`iǵ#m
QR*vfb
n0Ս7N[hyChS7iMN&rf̪)XGonv"c9CnD5>֌S+!
=<(pDTch'1,YQ P
i逜tlF]P⯆+츋-AV͒m糶Pog?NEW;ҹ\ɷc>кC@Tmk^]$"ÐCLk`"n~&Mtj&PS3IMB)WxY&/ĉ%Tɒ㤹۪<*,őm[^`{>ߺ_V6d|a;[ہ0jV yCFc1UjĄQbcƷV7vj<M'.rL/(ncp_(C̓ôcH[c(6Χ7+EiBEwnQ!s5|I&{2ޣ;}lh!b̓493Xx	'u{1WT	<N4꾌[Wԗo#<톂aaӬ|%ԾGa'חJ=v?괋_]\_^tZp.zp~8p
AB{Jx"~JgŗQxxޤ>h-RLG;^ݲ(pU1O',SK2{L1fěܧhYJW՛c55%	T*:aL~I
z@rBݜAIi25r3t
-R_֮1:cgXZ\)"%qsϡlt6*4,TWpuՈK`*(NYUHGm'@4Oex*#yqp>Z@Bm!$.ѓli
`o uq;9x D<[P띨_xGTUi@tT7'2A,2ԶUTֱ18Fj, h+kEWb
c,?x*$ фdTZ[G?ݑ!O	v\j8Ua2Ǧ;*Ѳ雭J9ApV_#x/ʺ#Rx/x]m׮7;
zpWZIΨ{?DEjU`OҀv%4p׮:wS]#[MFt
?ڏ}?e˶J_p|wzѻ>;A$4Uoס4:RkHP҉1tV)1Dn&ʥ)uP*V-y$?N,:yZQA"䓄z.Ii7CE39wlߎԒ"|͑s v3A11ւJ8	|OQWNZF8FAz&CCeu\$}SkgN9 :)[5~KIG3"X36lP,TG>Vz{I>ivm+!I񆫜d
(Ln[¸zL: j+e&RZ-?89rk*w
M<W#lٸlNR7|?HUMKuRr Y#R{@he{"X+~6Ǐߙ~!7n4vz%ofvu7w+O',0}N݋Y]^I)`@"]4<+bnDOqvzztvݥj(%, gǑ`rr[.tPix2ǹEum(p75	X_]Y4ڔ2C~0tO|P~3I'7^Is_dڈC*daWVt<BXGMLOZQL M84r^v/Fl").'{>npD(Z"R u{W|EZ:~bKsܹX8F=/~55 ݷAXDܿz'l,8L.]Q]J&5$Y |nJbQNp7(M&FYVJp,F.%F*k
\
E+']{4M=*E27Ɇ`כ#P
)0F76l& B,n>:O碸=Dw0ɇk7ƯEu6Z
"r)&7j+3m,U	te'6}x|>K(\5oiG쇯W.:2(A(<F7Ιv:+ 
	3=N:rm1\(Eѡ;Vf8
Mz 
i>=*>#6d\fϮ|սދ[Wy%|xyVJ,^dL};{/I^yp^LKracćbXZ{O)C{,3/6nLSm1s: j8N~6A~7vxv&uDD'ʔ.R<u:I;K2$LYa09-&z5%j;\כhm_]v
"BZDT᷈#NӅպH*ۍgdq:9-+Uݥ?2GBؼ2Og/mNAܨ_VrM=֯^
v6uk2K¹o=j(,&lC9_D7i;!u8/bRʺ'^<|w~O=!I@<jYۭǰ殘szНQ\iz
~";gibEU.<JвhpX>3{w!2tBj]g#u#4}xz53&92c'[b'R$??QC<SՍx㻽3&Q2珂Ȅ?Ug'UL
MU0Jǌ{=Sn6:qc&]7ALUiRL`;OYn%h	խAY09@]ؗݤg(l;>2=s7`Cw9K~u`PsߙެpW^įpu_d\ G1jOX[\Et	2*X"Aa=c3帡fZϨ䴧8xQ\|1K)TU-OqM1l}h,Q˩oVj?`35CY
~#ʯp*ݠ}6VS {7]	-c@gWOi`!=scr'۽݌u7KQ/D17|?IHQMEiҍb
S'9 P%n;t>C
RVGtV!*֭0
l$]Ш勝
NG
aY=#3#dH0o*֖U]8d2;PMNHlzx]J_: /X0a/Q}4{'EDT"6̆FW.JطS2f{tX(Sǈ~b0-Oݿm7eف{|D$$]ʒ$ݝt'GDV*4F҂ HkTt~=NУ_{/=Zk_ 0"R%=]2.^{]S:}C<XHkDT.jGZՆF+N(
*&f	J|{m\^edL8ŝ;xX(HZDȶt}!>;?2XEfot[jLb~VБ>_m9$)Z
vA%Ѫ$?͏IV@*N$WoJNͦ2Pst)F95i %c~#Y:'(O>6Z39C rW\נFLqgk?gp^Q?[!i}
&0^E9Rnz~Yf5g6_ !|ӺfLu7'$]ڳ 4ݼl"XfޗS7|R,BJm6p:FUTF0'4Km)//-*D7WTR
z2ooěʀB+U
5 ^<yM֏G?1lS@1zg8~L{	n+X9m)z-UAާs8$CPV8i=7F۹; :SnEl:>.aE
5\&PDtNrZq)y-Y1PbPhȜS-S/Op/$rn\H,;a2:V\80:Ba]5HVȍp@['Hը}K۷(HwCU5
Ɵ1miCehU}_LbU]A\DURnoq|잨`/.&%i0pMуɗ֪[Lk} δ_=Ѳ9ycݝ;	(uqʩQ){pܫˣiwWR6펐ۚ@։+wh0ǁ\M#6AeRMSauvӻޫ_auk	K:W<XdE7Wnoׅd|z=6@F Pl<
S[Ab|]e
 _##O̭1W}^'~%,pbrŧ.+̈́$fkZS<2/-QܬJ	TL-DԤ
uWw"hԶ4S"!D6-7>O Yf$#@>)!R?ݱGi1

H8D%x_n
i c:yU쌀Jdy8'Z̕ \!Lu7yN{W1׷&YCŬZnn&fؼ޻!;DǶ[1QY}/	fYyr d\a>F*=5:z!QdS0-%u*W(C%#̢Y] mCjTƻNC-R#&=0 DQ+$v>_9B+Bsڹjn/%/5;HY}|E	:Y+`]06* #E>gv$O5a"~]cd>H)}Q>v{~o9Zmfc
+1H`W&NQ<@X1@QVv~pw{]z^;~QW͍+*Eܜxi-qD3S2
GW*.@^=ꑦ}{NGij_?e9<Ut Nx('@xoϘG,mKi9OpN}hZABRA5TNcojiW< x3Ŭjq>V<ӓJ ]nF
{(HUհ'[ 4& >d͠@B
֕I4k,APSE]8Oܐ'sUu46k`S9㴵QbϴiQU|OcZgRkouԣo@i/.whӼ0(Lz(FCXgbhnsbc/JV\%Eo
O@U|zYΊ((:NE5a]Xޓ:""41o]<2mH?s,ݥ^.z'W	&7i5*-I^7>tz^.w}/eJN %yz/Ί{W?!(4|W{x♓$<G@B٦gIpԎߟ1c~l~pI6冐e6aaޏ$NJv:dShPP"{m '|
/u,$đn(q[mȋivKVY5tL)Wga֚6V'Omvrf|f}P{mzymjMxDmNոىyŢˋӟ?w~8
NDZIkxY9ɇϗR
M޿rKxeand7,'kn,gzE5(!?H֪vvDtq0!z6,g"+*|>RmĎ
 !N-FxZMԄ텈Bɫ+?5k8hTܽPZ'93	=4A)PߔͼM먎*=)-V}lqU!dZ9;ϪC|)Yv~K'Ī;zyl0/ݯ \qMܐ8NE9ğE=!
w0Ai}L,KR+kTE5uVa*̎Sa2xBPWO0(/۽և( Vz,iq,5%f"۬ReT]-gqLK[0iUI06p;7K"n@Jz\Ե*?QbH91;;osQU&5+lQyV|a<Q(\VpO6
@DQ0X]JiV{-5h)J"*Ȩ͊a3,imcQ>Y@pk{4&/!+{wkdEt4+S#az!c cF#1#h_OPԝqҫ̔j2f4$#Eg
͖lV22g3{`V?HT
ww*]#^ʹFINxT6]4 nsI:+[MɽGxDĺ__q7mhR̻7ԸQR$תvΞ{a50o oJ>=l=~Ӵe*&
Z_V|ksA~gR*%VlFPa۲DMX%YDx8blGWڗa!
Φ PӆS<Ӛv[^5ӂd%:<]Mv;?z?HP]ee'`JLl^8Ȓ,8Z\6{%([fsZ.L1%2s]\ޟ~J\M%tQ\ȼ]ωHmD]eMqiB'xmJ 	.8P*aJf;@p2&<Fi6曮<|hZ` jZC,JmD)Aͤ>Ox-~1TmP]i98_rѫpmABc/ZbXzR[srewҩ6d6N$g^,h2PJk̀tAϪW8:?8b.~j{laZZ|6BEBS?;?~
mDsh/O5s4
y⧀V{>f4XE BX[񲳸GU&1`Q9Pf(ZST
oͱH"HS/IE:,jeF{p)	vf61nFs91ΡRʧh b$.4PIyטʙuu	B%"z.~ ((o}yxws[E^1%n׎{ W59NG.Q+f1Xj>i5qnGu߆8Q$a_Nt+-rܛr<],twgzb&I||mu[*
(H+CXÓ3͠w g	/48@7=bPr NaꍰzWBos\5{VEʢ(ȟ^e3/ֽ?hbKm|KNe_fKt'^Q[( p~E3$06#v 1h/<7
YpA]hIe؎Xs)H?<%
*1hb]h`/ƪ^"qp 6\%먾[(v<xI1=ϦY 94Y]>Dl
Eחn]R2R4L.u$])-yqhx4&K Ep1# Y`B<$d?N0!^|])kerU  }ԥ%qpT95nEȺfO=Ŭ=!X6<wHi$dR EQ}6+W{([>X7=(u0?bfп~Ro!ItafP"ksI;	|[nyzhA%GC=)I!A R@!!?ȿ+eWK^B.<q;Bz#V @
U|kĘ0il"rp8iƗ7Ew1Ӿ<D^t{RdGiRFE-\wGk6b$৓l\8+ۅg2vc@rR3PB՝6C0|=>;$cJ?p%}ڂ~r@IYәg_Km	N~dZTbF
Eڭ-K,Q̾ve蕱} BʸEMBf,_(fRGqYo$I x2gg~Tw""s	V] ܵZQ h,~$,nMbN٫eU%5kn~p:탎M{WE]N`SԵ9]<5ڟ!$#{>⨛G.ޟ^նLDܰ"2]
*f=j]WI7J޴++\P%&
}1sfwt>Cuhj瑑g*"}bT{vR@kꦻVB҆{ʱfF%"v
owpοּpR,6+(a,P2lJ#R*\QN~
P]5Q_qbI1G~WXtx!ྮOn7Co鲙2Ofrr/aH<<TtCT V;%ޑ6
$/U:6M2
Hh$KDʤm9x	pѳR6uDgBܵ
\YIcc\N삊{[zc>,վl,vA1֍Y7Io&'qhֶ.qpf4ܓy%$βKq\; /dF>pmBc3)h
 CB"Q\IoG'
??pQKᖤT1+	idkۙ<IPh+c1
}$$*G2C rUF!KzxV#4YhI#Y"(c%2ҶS"N>l1*Fi#sۘ	nKh
2l쐲ѧ;k \j> E6>vD⡦oJƝQBu7`1fL,Pqmފ4ۇ ^E*7BGNN/_iER>t뫳kDg=>Ϩ&cHw9?

[aR_WΊio&
цB]]sLJEi.TkcJ>0'=UCRPEY;KAZR=QQԖz]	u6!y.W'qUT
U<<V4La욨*d8VQ7DRLЂd'HKE!kmÅ3EAF9ȧK|Rֻ/~mmq5V0}rNBJ٭J)lb)RDI#yVb@Pf]nR4b
k,63ap
ϋ
rw{cN56娛WNz.>=8^XA*|$M՛׃鵝&Rq8'q"ѽ=.9iql%D)N޻ϟUU[77W.臓v;5:nJ~9OL)Á1Im73b	6"OOOH:IeK~<;>:?vX2/0mz^=M0ۢ&,E"W1u6~K*6l_|^?ntLj&*JˆԈ-q|j<ߑ"N^Ӿ
f/<V"=6%E2<uEa]@ozLٵћgX/#kʃj9ildc8tYhʟaAiL+@X\ɛkkX׮kn@S@Uۂ0èD_^־pQ+hOcUzvt|oojn|H˴%āftؠ|ƇJo-6\fN`'ԧJ+<c̵M{0.sF㑜2qIWjMEsZlk[>۵OUh!g(b#C\>D? J9bjg\@9 {bzQZMhucq7Z^^9I-~P4eMs ;أH
+Rk:wYȿ\(TkLJ`( ^>gLH&v
ێːeOi7Iwր2><DTMzf> nk%fc?4Y~8)
v>w7S$Qck+;Cr'>?'\@TM%AW8g( »ֲLHʈѝ*meuXOQ)a$a	#[Qōvx7E<t7^3/$
C@
R3fLH1SoV.FvZRmUZ]!uvCK?q;,&D|uɘD./vfewx_PVPbʳLzƳ! M<~[mCN''8DٮAsKY/(N?iߟ}z/W^q9g[vo!<F T	ֈs6\|uJ!6x|ںmx+
SIT(N/<xɽWoJ4
gmD6q٨@=`X_KP=7=ڗ-ªdwTRnTCpQ}F?Hڎ#CƋ搚.67Spa%r^q%tVʹj,GKt/lpcURsFH$i6,'f,V"tdئ@my\]DLd#WEdэ?rmr_b4{ƚoO4'~HZ_~-fe*ս9T{:?K碤ISw֬1WQƉKC7(`jN-L~].D9٘;vt,hX&keFBg_[Xfc-]6zco|s&0T%̋HJ2U4MY]
0@ˉI:h!IKq77v{
D%sPj#rIJAJA7xP ⏽G'fڐU
rP`N||Y΍שּׂ`5aa
so|^T1 4t[:[!xF!:-ls<){&6QϤa8tw"J瑍RN[wj)sǞ?:0
5iڎ)6myQؿÊs±A{xK^͋/t$
#g"	M`zݟj8)vHG$PI`%[%+Ϋ@:^pr׌Xi"L6A5ÜVR^;ywdIs b=*#Oգ]Fq E)1mnBj9
V]1)#Bn\ZGY1.5w."_4UCxquX=E岩Nq<':wTXj1P!y9c")\Lx	Bl 6ng3M8}y1@E=lyPkkkU
ƛb}H8Nǆ2#^Q`3u&A	i
A/`MHu 91'x "a;?(6&8Ŗu$U~v8IB/p9ѨLq7JǠ2qLQj&
$tx53ݝM~J#GYԋ%}*Ou=:y\qGKCIBH

-.
 QhC&#cITg{*8!pQ̇jp7R绑u+P)n?<8zm;N '3]67+vc̲ʭέ}5p%bJ$l-iӣENxW.^@ۚ#5֑I`g&ǹղzϗITbGMDElΏ;a8Ar<i<m"vKx2G֗LWl86!\~Ω| l?VGB.y,]#2Iظ|#O@&""4QgGg+FU LJx0q%,tՆ&h
dh;j˘AF٣鼲Xcan $9B 6@ p-7y>|j;cЇ25Z6,.g%7y&+gNpN0y"פ9t^pz/A'|g^ZSkx'rgW lGHL2H&+S8+QBZ#Ht,p
مjtkV88>_":
.d}0 Ha>|c[OWwyP<R/cP<a.I
]ͼDuܞiSȍo+ܯUB1?vBhۂL!Wkin
')Xxalsz.va.bN&F
FRm@GN%B6CQ[_3jt:Y3
Ip0m竅 SPؐb)#
%	TѓjT3~cBo7<υK%bOL뵫?-cׇ{^`<jCf<aIM {}_暎jpK$SB:8y	SO.P\Gu8.x𽄛l))L̫\o	WEdo TA
(rm@}3,.iuH+*B"Ɋb6lE͕F*nwojp\[@YLjHZ^$z?G`*,ju5j<B5ms$Q Z.y Ux{_l4v=fuUTsҦKvZsG4MXiˣg=-V1Z>2 ]c?(7slQ/ڏSd]׾˟ED 	(=-
D	+2}kjHtz QLdRR^˄ʖ";YaZwu(C3Eg#0XtPDpxY"
[}6h0F٢Jb>|~n*o4AU,1hnOid"PH Rb~%og\#ؐ;=[;vGd%)=iR9܍aajiFÊ᛾/Gjݸc쮲@{'>ܟ7BC.Nhx<9}7I I}m{j݇RZp7൶-vopDK$De{BÛ"]pd8S-=)^ZΧٗBD][rj{/Wp
׎,L:7N :xKfi-sݛw[>iq0u;z$r;.OGc=!=nu|b#SZJ ޡ}*,g@ ޑ'SE{5[K%xGf㋓OP ę[ͤy;1
@Z*٠2]gp705n<ZM-7VZl_vĆ'Oʳvm}-2n瀸(u`Lm5sqr?RtFX4ulJ\W/z↳;.I)3iـtppQoe2dv<9دI2d.͸hlE~
!eN0Ƙ$5JշT+$~Z{v{{kX@*&Rex8;s;P&+>u
`ZˡBt?Hs8/y~ײ=W<W> h,$vZP%RJ=m7@Id)@ ǮgMV2a¯[˩"z׫3&dڦSŬa :Xj
/Q{uG׫+W76SniE$T5ߦ"=Xˌg/BZxe?qjRGhA<&og a(YeQQ*9l6JQ(3Cu^^mmPZ\ػw"rv-1,!E);Lnt2TyZ%
A ʹ*mv'b|<l'AZA^?R:n<0G{&aRL0gHϓi-Ve*Q5nU/.a)OCO5v\1d; 穫7 Yhr["mź~ٖdB:f-RJڮɠ0cſk"\;I
4	̀fq{n˅<?AS`Ѷ*KKbրͷ7.nQN .rwڻߧ 1fs*am,i%fwu71Qw6[gdi@`gqAg$ϰcT8}DL;I@ev3
`7rkaT2GB	8a:
tW=u_O)^tȿv.4田43B6)$Ԧ9QXtkP4rHEX.f٠נ
Br 	ؗg[׆vٽm%!'s]Noxn4sN][bMa-G0wzr<@\*[Г/|SIFeHY
m+̠J˅ȨvazA ֹAkL*4L
|~J1Dd-lUG@WKpwgޜvy玓F*֥Ĩd~$yUXW~}`p&T!/J	|]WXU.^1,K^1?&uܟC0韒_nR@<ȀRb}&
| [KE^ ΥYBCss>v*:h8璹~gV3&g=0pL+B:9!e9ots"+SDDh)҉ڐnCS.peX@E8]ο?ݒuK+W+Ct&QSk,?b@u<$h:D)]S>))W_Uv3[͜"
^_
#uzhtwpemfo|n8s'mTD˓n~5-jw9.d1+!$.lJV>+[ba9sO`k8~/%zsxGPW%!GV9g#97jn|tL;3ko3.6e&j׋stߪ6|,sr^/M`EAHk'Gݰ>w5LCGAANrLAg`#oyՂ[էSg'@mLFb)ڱv
cajmIؘ}@'[aIDC-~e'-Q~::>YuRoԛ^lPe;.aɦ46
ެ&DzPҝ9ȸTY~ qXȮ2^~12OU#6-t0pf	ql--2Pd,ǂdKR$J/o`ȽGaUT6Nb1[μ7&Yo,IH*UT׏e 5aU"]CK*8ǋs!Ht$2zS!jT|&<)WUN]$fH3^ywF|-
Ɯ",U^٥X-;Dl"i7KDD!ևlh>AurE3_˹লΊ9lPg"`/,]R}VɐKa"P?<Bcr v;sGd"UR
D)|&v?qƗepR"#/`HYk){bv
=-m[4iPw8;p#<[wЛ^NY+_>+[7YYTi42M,;DCjg/-ltp`Hg兾Uj-j WݠDpW?̶(7鸬r T+GXjdׅRk]_2W[3
QKr{lh-fuﴐ>F@A$2vanA)~UX@joVuIkAG77H/igl*7{7r Q J}OF>Ԣ")@Xُ'yl{Cq~ܱ9m{-KQ`ፁþ1+`Y`TZ4<v|yKHa6`U$yeUkПZMFju&i4(}Uhfjf-I5MmE17dң3J	v~WbX֚G,je	i]4%mtgg~[V3Pf	ǵܱgu"#nq
3qv4S!-8_ko-S|Cl֯BsDyѩC3:mMg1p kN`QΉtbI@Zk/Z[$!Z/w67S@~׺nձ]S}rϐ'ЁrFB@X3T{菀26xEٯ<0Jb"e/a
ü:pފ
3t)!H#7k+IAdm.<rp o95%U ;޹w"Q%TTCvZ
	9[;tu،Mh:AmݏQ<H~UT97RbDط$U*@KdAAta%ƞR%2Doרw%"SVjG>9vzt||#cBQ1N}dKx?7gǄ`(-py䃪ej+3m; ,7#hFfS^JCm걇6ǹ#Ż6h7wJ^OȫM;;=YGeFR1DJ$A%?ke.j~ZZMo߈ev&lUv&w1<eܤs&ekYDK&~^Ty
m!#Yd<β\
WƖ)%J6̘$eL;RQn 0.Ru?^_s#1|*XKםwJBr/k6oAjPܕ1TzߓK{3gemh4BG:TBx֏F/'sop2=fЕ@]LDWͬ}`.#}_V۳KLT"<oF0pxJ)2T7Ѧ[b<ak?
?=b1xy%B9ږ-
RMj@4'b΋Kʎc}TL#oFu&ؕu쌐p2d9ppxv>d	jNQtk%p}LaE2I+f[Ϗw^1
Կr<IU}sv
-*/\XdI lcy7GYRV 
1CpA0SϪza=zA4;*Jܹ~`95OlUPĹٳѹ'ȁ;VRmeu
iN10
Ҍd7mPيPLk'>"g7KU!ҭrz_{XlXYO|
~~RZS[BqeR-eUoHɭ+
 ~kҡ['WT7ڙERՎ+.c0=~'
x+C'TbN۾kL}Rr'A^AXcdJ m<:YKX?';H׏ ":s63iJ2݈jjdq7u_沏	ݝ/
Nര㥱L?ȕ]AzlcN5d+!wgz[#s8O&_UY{ "&NO
	.{IIkOh[c[R'DZ/v"+BfH`W;뮌x×Qa/ԾhpkZ%O_#	ݫ7ζ#Vr^V[ntwfCPx+Z*Ǌ^6䓇2fΟiɈ=V1h !9G	;]"X+| RBt^Βuw|=E#c-ǁ#钍Kz.Ieg(D,]m:0H#(ikW+C2֛`\,)i1fmcIM!>S$aBfniT'ܔh

GI9i1n3*ܹKYh0,0Ⴥ3V~ [3wPXowL6uh's8/(q;k7hQf<V\o㩭ɭ( 
mv`b mFPxd)n7-@T[uzQ:s'55<mny"`{blJngΑipKde$3GcLo狖YdTݸ{}tuӻè3d
m(Rv	$,CIl<O_dTDr\@R|OTOsmznvŦdY$loQ'Ry?r3F:#p "zgY{<IO>Ke9W/9vIV+aYZU[JqVoGze̹im ldrsf
ܸQY-'=x;i3]q1Uzk1#7A9"?HuN]w|
?<t̺Rp*8%Ua!G^Ypߩ'2 lcU
+>UqǳOW_.a8+5=Z{弡:;w".9"T#4!DD#^5*4vMf%HBn(b*S%Hm'1/h4V"CJ빵"i j4O/árs{uƍw{EXP'V uXCVxS,fgl'O[ΐF!>G4卅J3횗pH)QX
;f'șIc^9D=a7IvR6ROsG<\pkւ<
$+
Cv9ZZMTO!zkg(V3*ږ4ڷYib#¶E*+jB,HU)hصero6(j=ENqc֔v쥷(Uz5^̥;'ROK_\@cn֌HW
lO%ўQTnKFMg쟊0C|[!F80<`&QQ6y
C;_F,XJyZ#@4UI;yXJK)m$]D}/#<7~X0`ƃk菇Q{iE1C[jЇ2&K	0n'`1^D2	tۡO*fwO
/){:}J{As= pkBߏpljo%|x@B_|v}*֌o=eEMsB"tD]jp_"n6*v.w[h9M;=7+)?*aiK ƴO?a#ݸ-Cwڢ2;URN|3*/(db<8󇥒]OCO>|j<`Ź˰%
\1),w2h"pII1GT29/d
{VOWgTRq{GHD`.X1-QfҾ2Ͽ7ܸ#۪(Y5I+\ FPʋt,$,[&e
o{7ՒmLt)yۉT8~ǸUVm眮޼黶~&m.s`` P+{L#bݞo+E>xPT+' O
?:y komv(	ٴ_%\a-P9~U¥"
rh"Ӽafۚ(Ų@MQuC珵ձCVf]McU{K" +}LoO8}4Zw*ZWQOGHtXsك%8֝O~Z'ڲQ,tDb܏gh	eg,lI"k)^OLPXPd,8hiטנ%*G<]Tf
zD'I7MwRL.m}TlLLt;$wmMqܺeMǷ@M5GNTS?'Ku#`X]>^8O拄:\za~B* Xzܿy>d6JT5VaNZ\άm.@v{מ(SᤫHU4GvQ 1}g5Jms(glG.%XY- x^rW
_h0aUv
AZz<C!i#Fd	JB@#$ABfCaiH/{ֺ*\rw/Y.糰Eҹ 3itV*4Ptz[c% iB1Z6SR$Zann<	15F:	˦wp4tzk;W*{3}j'2~"ў,YnNP-*:;6O'{vd*s)>X_BMSֳ=/vlq6=وgyUT)!A[>7A0D<8/Ա
@S(W4U|G77fHifHGF^a8>:p!y2bhDҬ.2x_wnykƖa*6ݵv{u$%eDН8S"WkuWJNt
7߽>KSu`%I>_ܖt$cir,6K%,cjtKfH~IgdG˪cbϻR1`UJmlNk9 F<޽΄B)hYWe132krIv7?1\H3]ÆKrʵ@[\)!h\7WiRv(xuҳH
UyD^ʛsQ lq2n!L,gn!1{=xGY J햄Ⲭ3tPZ`iֲ?֖ja\wN%qJTŠr%-He	W-S6BWJaJ.x}_T=`:D$ܰ.>_cϦȬ`
0riXNe.GԢH? .Øt=y{%5@ ViM[B6i)z3gdJPO64WK
h0K˰\z$֓E>C%mt&iDSLib1J :,o3rq*Wm.-q}e}Z88H0roFG-Q,K΁|G=,x5] DӑA`?YQ5F\-h->;=V	w\Mv^X6uߋ0Ĩz$cnܧA4xOq%8Tks{JB`t(=()d"d;%/niOtwPE&se9ѫXiv:ͨiU%l<:leo9+bQe[}K)(pDLt_	dI
!BNSIs`Oe;b*n#..TV7=_ߩzN
}@1T"n-dbȁˮ[khiZk嘚EE3lB^R`JzyzpD33$Nwkv<iǿrs(ԍSZ"E
Z`QjA`&+L7ˀ2hگ/?ÔjTw罏'ӣiwN,<<#ʗ %KeB𪄕[D\o] [/8dܬ8*ޥ͙ UKIƨ@7N5(\n027^OkP[F٤f'EX.effP&U18]bM~䜛@h?Gj%z^3ע2|4G5c&/P|0WIEEHRؙ,4Kůۦ{Y^
/I	:L{ 82~];Öc޵<Q*t8g@C`F"7[ab{Iu^,V?m.".<){@%&svEjI&9VpȻ	Ŗk*NHqg1.Aųaݭ$bR:Qv`hMIyl> 1$;13xĩYZʗ5^b[8WPGC/)#!v=vt:fF#HJQECjcV9(]]z!w4}qM1lH\3Ud?Ҝ xtq=^%,P<WElDtL5WK-1^KDIlPjdO|-w} E!fM*٦IB*]Ys[@J/x1¥gVP6l!U*iSvjBRdI}6wI"Z.%G^.})pIf9쩈>=Ex~VY=l,e~}}b
cG3Gػ1[|IlhU&n;%mç<^Bs!VB\ӽsυUH:Iۗa 4N
f_+Gm&~3_B"#\wnk~[IUL%+"04tE`;t>,a>K/\!\@	RC3W
R7:@oHЈ5ޏOoJ ѝxz
d[)8do;K?Y@Sg(sH30}[,.V9390ȭZj{?چ1`y7 >6P?G_q?Hp+;mʃ(񹔴rf Yq1@kzckD@'G^uA)ץ`@ \co`l'pCNlm*9[$V+JG".Gｲ%ҎϺ"{H5Jh$OO/r."y
$
lN$ב5hKJf*#nEY#75Ku*l'/U~+Mu)Nݐ$ᐦJ^_\k~F2wp@:Q	>fQ#:k1&U7Xp#aY|'tVH*t;XBH?̑6X#vkorW,U˃A*SomG+>PP-]G'Q!$oP3LL!^|qW>*.@^tkKZa.dJLOO:^7s3=MyYNp_ꌅ2t<$Ayvpꣃ2*
v=ቴъ4~|.H4TxD$hMkA{ױ^"fj֢&?'|	L*&}.E6	yh;dܟ3gLoѶo[ڏ	aг	q-="#tSu:znMH~R?rv{|ZֺdmZsMS}WCvi⾡焨fW6{oPǗ!mFW^pU%)O?%,(|HK<֦Ue{i$KӊvbzLY雼/ pgAc5'<6iz<e?Մ-dDr)}2SWK6Nu)vgPEAy@s~YME%%,q/<~ŴO*\F`Z"wZA(;Qa_7dww\6 DR@i{1@=w܌4:$Bڙ-JѸZ՜`YeLw	<zwoqKZC3O
q`+i52ca!C8)cPPdAx&o^ݸ
xTc;G yW	T}J-Rk{I1>T+x*oQI$~)ʺHxSDx	]ߖ;oK˿ոy)~)O]7ߘ`*+	V"p͉J~
CP_#^©Fĝ3,*g@|Cf^YńϖQ^0t 	r؍g~*6(dKY.Z.%<`m$	b	
ۏFINkJ18'vܳH=U}gwɇ3EӓI;MrqB]bLcab7J}wߞ*Q`|=kZ93]ƪ~Qo[YO ZSmgW8܍qo(f^0cnR9sι:*)rȞT턖46tH%<dD m)/USށ XjsygݾѦаp\%1-E~XtȲj ]6D39[ΰ9*Ev<͞;.$$; fPXJ%!ޖYxV,d+{2cv;R  sñzMd4a
^{~0-<<ARe6 GqMs7iayR&>;q+."/L]F!`.K\(7$3M2kWVr{QF#>]b7=YTY;xq>^ƹv%1FY={R'˷<P	pؙ)	; 2VIh;rgcͩͩfT"(Y~~苖q?!@&C!'2t[׷_%~m0m沉HTU%ިty<$ˈk?\& dVxzw|kSTQ,u7mH6EHE3#nuy\E"K%! za̕L>P/U/Z$ŗ{Q`sD]BXf$HB~t*=GLԈ-(珇k=/AF=Eflw ~L;dΧ;[kRR77hlb(0sHf參i;PadcǁNZ8Yt+Ϊ})xzECo]]|tptwW$ٷzbops&;׻󋋫2gl)߀'S3N˄Pak˫ո"[cOrdٿw$;x}uzt5>;LB31/9LUG1$Z.z.Jb°3<d_
zf,'BJz^;)ԏQX>0+q#oPq\M!N=xl+^u,@ya"݋[LXCzcXܯȭbe?6LhK?23>gN#D$Bwq2%gv#>Mȏn
PΫ]|1Qq12Hc2sn7˜yˉELkOkVMTRݢki*!Cn$2h
ѴG6=B<S6c0l"7wwٰ7xE2T^Z}(1Ae ;	^iu(PH51 ,'
Gdh`nE<zqE[vPW-rYs^r[S$MfBC*zWԽoSe3C%	%?JF^5(D$ȶSwyv?\wzW7 QJS8CA;-GՖٯ,lv zs'sqϧ	|T'2`dO! |S;nQ#)b53>8_@igmݒP\x>q96$=nYwT4cHm~pbP(\U~jKr/ybʔR݆F6N؃(r;;S}WLȞbFq]+=%PҌO??keHZD嶚گLwOCffyq"V^yh&۾jB:Q"Ot-ܦQu{gqzdդ;V6~cW5lxճvuyo✸&*$?:;9?&Fkta*܅#@eԭj"+F!CvX<f0Zv[r&XfD9gha@\n|<eBdbhY<t 3+$5%I( o}*(+	DhstYfr:vg7 Id`{|Z&vuu{{|q}t}v	~$h^?ǁ0Y1O+qm3Dw
AZBLG{m,rKW8gȰ~LіDRGx-QNλږ{E*od] Jl-s{ n^gyUr
\(GIѺ/k^zZZ?7xgge_tsKi".tN
9Ҵi"E|f֝WhUHK^Y$˂G'4F
8~,t'O'TӲt>sŘf7/faZݼxAtk6'$
#߶6EY.? ?)<|=~7#(o-l0TPhE 39"]_xmûYs/
E߈(ؔP~)!EB6M6xB$T;Z%xkJldAiQD<oЖ'O3GLmxwcs6W~2^ ln^f.X_wh(ŭlu@!Yvˀ頶
%װQ#.|8_z`*:wohGAnl+fQChfOzRаc; >7_$D-*Ӎ zE.g>@߿g3k:pX|^KUnb| ?k9YR֞p7a	2h`i5{Ϋr$L1ij}^H,rm|fQ )BLqۚ͎ rp;G.Ml"8aR`*!,MO4[:jaҺyɣFl7ҽПȅE <?|@9&e1\f%vZ_<V&BYw\7[gՓ
SPǱFoG2KmGAxmKV3E"r*7J(R1:*ŵ37#b	qԬ(5!
|̥@SM-rd>Fy=(f>Gnm1Q@|I>wKg_H"WC"\NĒ]6;_H\2j۫luȻkgi[^LRgO5;=F_1ACIt)q81"JG}@
7w&1/4ƅ)fPwP葓fv!?wprVT?R"in-V$XQc7/_޾DEMgB=:D:>
W+SXr`a}U, ֶ/&2JBf_>(RjIKb&vBx0@2VI.5"FLW-m'eM-
,Q܉.I ;'q}RCְuffzًcOD#xM#I7Tl[8hmUa\Dbt.ju"{=^&iHo#ZR2Vp ,5^h{jRs/ѭ`t!翸0bLE^-zï/Eaž&d5{Dk ಹ8I}*)
[Oͻʂ+eѨIVrb"	1F['n5mؘV씓W:,ى8ACͳgS-5#c!~Bw϶@c6}'4vB e9|'¢π
pj屻!6?I!'tek*B%+1ƶpL5qqK1<9Q1WQ[8Ŭ	 Gkcx&a@Hskn
BJNCԠw!fI+қv>J6e?RXt|5xۺN!MEl:o*jË4@N]o1/fdoj6`06=Xg}ĉA1'7i*w&s|Yd2\9v9n7ЃIcER
gfCO2ᦅۇ߻W#Bwy*zfMmt3?O'gWOitB]6JU4HiTPnUҗ|4Z/wz*h4=;^a?%|{kXj`n*R#H^ $,WI 	P</1Zy%Ftc;Wi\Z/ڛlJlO0\TSbe*XЄX9[D|wpuW5)<P;;f`)~0&}J]j7HUzj/1]_'}rKo:
fUjdk77BB.;xВ#C 5'ypb:$a^	ZP28ӱ_bحN\ .|{m[sTTMYGvx,@#*77m6Q&R
}
U
%+.Yf[0.&W&M CF3z(ʽ_	n@L>I0#(E .@cY0~tK 5.@<Ѹ9	{|֪hm ld\Mlw=RDm|u}~Vm{D{EJڧ"sn<.Z 3i	CQPqjA#6li@5ynݣqZ%"K'BBW(*iʞA,9]o|B#~L{f:-EPL\v*PczdAQZТ6ezі\|m+.fjHXc^}0jGb=_2hH;s	mK8(w*\Ifǽ	{>jN޹
pcOOi
-={_Ŷ)*F(̔lB# yhEl 9P7/} D@.RT'6F;p#Y_0a4<lRQ$7JtlYifwHj!	Czbl_pOZ+C#ژ_vj0\:k=tv;{7e#dBfQo%7nn:܈kD;
)m[E*;ݿ=R_9ChrH}ssʶ,H,&fwΎ177~QlGl4:xZ.ODfsM'L0OCF9|'g@8>
#ۈrlsEn[?O.(P&[	u(uof>mQƾIbFTqz2/x xQgKjwFi3=KSW]W#3bGGK/3(tOwk}~^LTx.s9^pWR)cE!BE#^D"6#wv{uY7ر&;LbHv#&!Z^8'GȇP8{=i:!R	"w_6 $pe9	+A	rƧl'͠18$z#N>mIMd*v[<a$4ҷ3L._kOVo<{F'g7듈
8h~p^}Iм<Vm	5}ZA!hU$sJ>Fxˇ󙡋.)$y4+7YJ+
+h"Gw8BѣXl!0LKsDή݇l>,!Ce/Q˞cZ&cGcHv\Ԯ-r>;*]npVxdcgk~7:*N5wڗز.@J{R~ԛw7~1Hdn|kEf587/rk4{Ŋ5
w4Y2۴'prX ׸}|6=됓%θ7k8m

z \;5љMb\D__?|X}`i~댒d,XA nGh~ӽ6wZmw]e/ƟҖrFb"9X,9!SJdܧڧ Ћ^F-Mcpj$pPbU)&FJ}-YAK͔WACmeE1jT楆oeB3җ1	.Ȼ=Y8NmIxU&1v[=iﱍfD4/fYIo7kpQػA"H0)@ppv/܏h|9.k[tMݰל4BUA9so*m*҃ua=uFw.K@ WKTzטϽ=_NNP|QH[ȐN<%uxH8qKwh4{^ߑCF"n	soȧr!mnB=eHkS~ZfZV)z[#lrm2E4*֡jq`vn6
rj
Fv=/y|
IWdh;_yT&)ץ<{T:2`&%ANّ0vFgk~$2}؜H6e^	_?vwo*hDOdG)Alz"՛ׯΩYڎx~K?ii}qۗD	ԏPR]_SErp{XUݻU
.;y^9k9n1pc#!
^T4i'A4=d)9Es̗L`0o6i`h〉6xYs)@-k~M0Ƈvuj	0ق۰4/I}m?6:GgKUwC"kqyPZdDkiy?I;=ԶU&]yn1>u!ħ3Br<{F\;=,J
+3ŢLm}k=?dSz.87MKgxn6ٱ03}M#;fʗG؆u_oƹfCWZxRSŤ'Eһփ0A~on

2H{ PFa;o,Y?oTtn|zZ9kn#	I%R_.`R#s4e5b:*TA0ZX!*Ed:.=`돴㾚mEJM@pV 8|S{-_f;wݾF^H=Fbn}cdN#Uݩ{STsl1D ꐸT<3xyPXoEvdg~Zdr]C1EM8NBcP\fڊ_5Z@VZ7>x\>XDv=i,9
AYId$]u#-HE8on  v/4Kiqz鿹--%>Q́-Qbɬ.4zZ+.jp98=e ˟cV$?j{"Z|^ByT[Sxo?>]>ߏgzG ED݉~(ǻ
nH2ap|uzU:`97YdV9*y-Zy	rx(N@
0#k}(Lő?A`z{Am^f:l.`	gV@-lM*w^WMPf.tw!V=В-٫p\9tɧsQ-Ygm:?2!ŗD,O8Ot3|[-D/XY_zS8 s?npwcusp89<%̀#,z[`J3#Jt2I`[LgL139y>?) Woj
RҟYR1U۱}}U(XeY*<{
H3'@&M/v uZ(	#
 a		!XAadjֽlܔG/l2}3bQɰÈفD6 n2e@DC&%icIݤfœH:HOӘ
vWYJN=܌&ן}[,x<,'ar!+TsEUGNqa_8LJkح<PLU̢HL[DJJ}"'a`tWGR׌v%f'4VQǍH!{3A ,[O%""SMT1Ch)wTg9n|p-o,ɺ|^zsm8ĤcNI:&hD]6*2KYI`!y	.bɥvk֌LfC<-qbKN`b$
|ڎVWIvzqʯ7MQO>@7c0,߈GxJȋi!Vm4K:AʫI(լn
Rw9BT왯1$U;SW^WeD<];٧,BܖVq+&JVQ/&Ho#x
ggw]3 
iP{Y(fy09D2G?ZLr3>`VQᐿ(ciS_۶80X6Z"<S^8P56h!n,/Ya|{{ ,Ҕ׎tr[h512=:=4s.D(iRHSz\ZT[
o협dR(UVp8ֺYp+ЊYk~5l %#լ 50_cU%w$GP0/r:4Vvm^Z"AB$`ruG#6 3Q}!e{Qn/1o%U1Uu|{c^vv1d=H"_dNb$[
fraӅ
8tg{Ľ;#։C'WK
]5,𑭈Au*wX,&`i+udi 6nr+IyP@;h[uA^iV1{3_hM|{D?IԔFJ?vtfjQȳz/[{W'?^Ph|5*vlQ~{̌,N(o@SڲyTeoEMTUJX0X1W^?b.ueN};[vg"Et!x 	77yyLxm
g8=VrfNA4M8ne8z	V~y
'hQ
Zj4Sm#6Bϖu+8܍vHPD)5xc@X@['ɉXU^ݔzy?#d'4ucYbs"f6|6|q[f~HbhP5B8̻>M;rϋUg_tZ,?W ׼uek~5vQ[uU
e3Emtz׸,猖Yé뱉<g	dWܾn7RKVIuvR5[9?ֿ|"U(DsݚA(ޡ/	2K4Pph4ry&wkә`#^fM!nrQa2gwUOk)J76ML9o
	eJ	Ŝ )ѣ%N22i_􈵫Lq<ES+M3	\6
p/NcH8-P[!fc5F ș6(lIBKKvU+L5 T%1#JgnQ~_=>AǫX"^s41ӷZ\:
Տ%@9P6"3cKC@f#:јmIHSJFS/)Zc )g37mEOKjfIKJ?ۄs?*&JMuyS)EJ
s{̓b&R`zYP9$۲>Ab$`uSNY9q?ۼ) B- )G	`]%Z:2it*ԽrF}B;{#q$hIT3^p3Kbkȅ8ٮ-&mAp	"$Xz׆AYA'C'󙄺4$9b2?7XN\TuBA%ġ#c
ðKD^6fsyɻy-H+2$<OObkXU]LEP&upH㓢4{isoᙝΝ=`#mU{x?aO'HY$xtiB
ѭcF	sS)&
^$uWj'!ꡪ*d-蒐)yzJ;vnLqhr	p:^T=&{c݆æ)+3^QW}Ȋ~]Xq fJ!CW2ٻwڊ' <,7_}LESzp	MIe$-D4+q<!:GCq{|v[AeMc*A/CcL RRulU׋rG0(}uYs@q#Vw˱n/*P}ϝ]~?wǬZ;w囶MxmeDۓE/ʺWb4p{ah[<Kϴwdu{C,c.FʜXw[~Yhv"E藻> p{Ny'JieGU/bRq[vAJX7+M)Uߢnod6yfUFӄLNmR5ْZb^Zl>D$/oՐal>#UH>!O>Ǌ$-F'i.YS7H%A'3Ic0ԏOukIsr^;X8'^螬eV2Q2F$ MԾu慀^ԋߝ%鉺Ɲ`xZX[ɰʙAdI)"Rfou]l4WIi3Ŕ߿h+3NM@kDVhb7r*S&4/IyPB.6$Ÿ}]RTQ:?;c㦶(m@d`\i
(hp3g5bXrs"b	Q:L Lz:dQﰽ[BA[e_}8S&%nl7Z&s	IBV0LX3\Э\8JdJMLܝݸ.2L E򕚰Ẃ[ܵ[(`<HDmہr;Crҙk"! x#EJvai7Z#*HWH:D&gm*0m9ÞϜ7"Qն\O۫$ҷ]D9M˗/,һ0U򬜹0Pue4lhL髎f !ͿLE`.4({苏'<P<u
AVVŌ"cP0גqaVx8FתqKz8DsL #qknY
Qv=+T9"肚&.<KďQ~,_Iܟ5
hPAMkB'9u\̇pRѭ$J%MBRnsVSۈt,MaC9
?%Dб9jCLSz[-|aIæPFqCH	E.rdK"4˼J'h,8y{ڠ`rۚ*t-vL@Be$+怳+ǌ	.>8>:?Um%?lwaKSV҄,Kv[ߧ؈ڴRډVq>1Nhpv@$W2Yѵ 0<tmၫL#ԛɻh[&vRhKR
fG\$<q5 Y`zTgbIyaI
Y72-S:2zTڧrq32s30y%	G0_
VԽ("6{Rn.%%=[y\]GAE
h{Τ4y;
r
w~.@XV$b~Ldniv
4Jw«7A*4q=ȡ+'t,\' Q	O'IUu2_RN@rƗcZjzw0iw|~zI$}jsBH{l*r~C]|5;/5[ ,\\(,4ۡ~֯*X}y	jg{~RrsnݡTL6o.Ж!qN.S(Du1Y/`*- zS*:&bZA	=4y{x,2<Jhr[ב3#tf34
,fL94S_tuFJR37.,Sfp* &VYglQv)ҥГ/VP15X+|gIaa=w<}lhjWqEDM
ww"cI0Kdzq{o!$a@W+k۪?'1X`_}p?+YZ`?pG'\Cj	`йȎDXڸNtU*YrR20!t޸%JUp]pCw[Qa;|xQ%1wGC	ceJn.U˗hrqm@`gX3G~ȧIlX*|;AؿW
ц
gE$,y C?("(E>bB2p,wkMѨe:
B HФIAYsIcwF?yHڽSw\?MO5XՂJk*j}_Qn`eE>Qv'R}튫mAWH:,w*B̔܏03rChўU,ɧJ)ZkB8xh<&y7-B.ͽ}?\*G @/A T^:O.Ì(լ7!֛ߣ0B"!ɺJiOۃiFnUh[m"Սe_|ݓvs}k1feֺ'%Ҕq/32ۗ㸶&J~Uq?
\CW>jhiWv]jnDD${>Э£;б(cmt aa)v ׶"9ο&ct%wPJ)@I6++BKqv(:OodAXbEM_yEhcqj'v)iweX@gus~tgxS#5aotS7.؅zEVU>EՀ%<!w!M@_?ZKjKDFOJ#u8L˺2\S\2^QO7J3|8%tA/O'2%xQArl߿VyR yIb)mu!'y#X:%WpI"r+ؐ/83(M4)A-\mʉK 6t.^%T.fڝDߓ
Ҵ!cKNuN+l2]9cQtڀmL򪍶<..2e#-VxqQJX֨d;p${)xgDg:tS&?_j[?Uv+qk@;9"m7CsOJDl9LoM *bv$y"uiu! @P,L^Ip39>^|w@PEFQ4^RZx\
ۧ:߽:27Dq+<k`F$SrVk#e^lŒUP	 Ek`ǢXNUI_h!SAȾEif6F̽U/դITČHܣ`TΛ.tGql(A;FF<[AХȼl/K$&IV/E:UFNx]"l7|;X@A]=+:x>BxI6_ޖ_r]/%$+x6p8A6H7 zzz͈ެqx-Hk `9ޖpPpuDY/
x{B
^D:3&>a;؅DʽlP۰ȿp0pȖ$D<mV;SYh]$z]|6EĻItHelս5Oz-ʺ&Āv|2Ʌ	go4W)4vrf^|՘0mOHW->מF 
ҫ4j
7w?C'Aᥫbkdt^܎e{XTE#^M2" zΜYzG1qvOŶ-a[5;JYM~}$Vԁ+ۛ`0j'2m"Wb&RYEؐ"[5Ɩ@,BR	S^GI 8Q;h쿐CVgֲ7htMoBg1~*%,uv}|MCo?q</)iuAsTN"P$n'oZbߕ"H`{#v_|܉7~vLn!#0AiV$ FK?4[)351t!>"
JuṠ3^_po\iR}iI8ނ"ۂwhؾڝۚ
$zًa~|r1K2./v#~ݺ57$~)xjhkJ~T;)p-~t7k<~Ȅ"YeM~aqI b.c'ӑ;kB 
	=7';@Qc]8f.u'k=M%WxXϲb:gTcyż:2a>&,ĕlikt>3aԁ"%EMxQCmAŰN!=r9?
#:䢶Q%#c갽Ѣ2ÔH6NM(qS'[cOמ(v6DW-l:-3Z+^`ć")JJbn5˘(&QM-^"%hOZ;;|<SAГ6Hl>k-w@[M+keԢ6Ws欣L@J4Mtf̜)j3 Ǐ;`O/ˆ8!
rZ;留(
*cJUoji4w;tg٪>ǆJi8Jg5k6nu3%&ڄ}Jж7?ʴ	 &ڒwjK^ۿm%V(9E_pCr]?|TuM7ûc93:vIn.`ϯ$~
pppKrǌh΋e-׃p9-f4k
;-T":U@(A$4P;9l&7&
iً
X87t9xߨ2A9>DVo2R&
X{ʭlwY؈p.9k#-9䜧WWW=2ut{'NOPfDdiVqU`)h[
pF'%0fi%=]`h\E=0SfO0dp}}ٍr{pfE-eR_">c~W5n*z}O=MsiMUC	 ۱߽w*]=
)cgo߶߅&yֺQ#aCdCV:ܛ;Ryhm8#E
 ջD
}.qDC0" B|Mڄ0XF&f,ڬY`K;(5+5FҿflHJ_est3W	gټ,~Q ?ηֆY:xEFt"놸m#b9Ͼ$N{EP[BY04\>V`>v_ x&{~
2iH-.1V ES(NT%:Q$#fnG|X` s?)&`[[;>
]Bd 8 
ip{u6ey x!l!Id3f/]um~h{؛#jԾ}-䕤5;*$~U(bJ=ivo1kԸjs
U	[%iOl#2O*i-L~[X0^Ho9|~Ӽg_flVj90
F]{H؈bD6r*;:SVg21m6qҋ%ViXP#HVٷ$M|ibi2+[!-nfć<iX7ԿınP88aqޗR-.=]l}=MYFgBwO?N(hĝ9"&^,	I']s/&j&msmGDakv~myV;cQ=~k5jprqx[Wf/l
{W|9$889ff=R'ouXbFokj\;d沪]Iv6s&"Lj˖`:0<xh!8<~Φ.Fh7y\DH'
jpzCht֕օ_BEE5=3n#q*?Dd.B>fIvT0kbo+C(*lAUy>b)J{j7kEڦ{#YYmfIgreZi	-`1es"Jina\"ldlhƯ-vYn/s#rj^HP3W)c
[Rnsc߮w^նp^	5;|8z0IE3wtVz ÆCWu[	s4 ݶy{liZL?`䌹y7z7))cxUCǃGz_A*)j{]<fFРu3ί6]ft@Y,Ίe_s8E;|Pܾ<{,3@%Dx$]Ӆ~'zHl{qߋEHn)!RgK!ZOKSA~ <ݝl /!J
H~,RmI5]~С	黛9#=A.DW`mn`NJƛ_N	6Ob~d[:f::$f/>kL7];8+؛
 }=;+]^]vu7]sQ·'emT)w>/SHϵgn!M(gdPڊ'oC/Et&urn@tiOλX:a!N7q67wk4bYa
&ۨ=ٙpۄ}x|8Tf$kVsQ0'qߟ(kVUDNV軠$!\pQ1
?`a|P&sm
z+F/a	BhYe[A 4z1AwB	B?7ab7#<}9aK75p->J?9y豲-*1ycjv("`#<!nE^1Ȋnk1bh4oG҈~zk\3Fz0їvbVx 5wiLo$U{
Cbc[(()zmiLª@ĉ[LMTrvS7zszR9\rE0e<8/HK]^1VS4C ֓%*+P@5?"|YIUv)BQÅ:eý.p-=IUܮ`A/KQ2f.woc*)`!ZkR<:Vi^ܻqS.=H{Eg2|=>;-QXJE<^iX)M ơeKnΆg)Z*
T&Ԋ@Xj{v*I/bz3y0p쩍@Zs_1D0*w!22Hn>iqyY_3or\g0YraI>ysxvsqfo2nb*d
2?U.N`RT2,16;MR+KeqM	w"=һ5kl_l7$K+ &)F]zBQsIW/jKsŵQ|X
{ 10{ijwSwʤ&z+Ab
pZp6n~1f;KKcN7]/{.NNϏ_<X
ټt3ÆuwWAXlaHb^N?wO//VzəC<Di ΔctP;ִJ5~~[.wM6T$$?E|0>>eI\ekntn.sLv~Og|ٍQ[to"H-%P%mC6⵫O߳Kk)(R7ЌV9^]>Li Mca;qj)B]#`|*19z'ΉO`3tşS}G3??__̟?-9?zN6䯓V)i70rhBhM^*lD$[k`ۂq[A2|6khfSҒF@}/jg"d &jy)v@dnԭ yNB8l}^jϳzuB.	H2'p4EALrZSSohc1G2cI%!zقխ244Yrl.T%%,O%("<jXp+Wgv}[x:OhY$h&@fWY@عNKt'ފb bw֌$dU`Fy.ĢP|(_}7i[a<6'S]lhY]҂ͧϋmՎ`6[،-ns`t6"pYvUtNSqqV nI`_36~t#n;;'d36Sbٹ2aPPak׳d(y<;;3z?[=X鰕օq@}S`	?l8_1Psn۝gZci6ve2qE#0G2:࢖Eh]S k|F<GMa;4W%hV1}2iL\(Nw;{{~*Y	g(J|:P,o@"ULPwGguo,
KM2 ݍ!󳙴i:x {DaG3X@V~|P TNݳ>f/pĤWB#&!@HS[R_VΪs6l~_HDCS5UQ(Wd@lR"z
x/Ϻ.YNJw~n(sr\5Əh7ZD,]fĐC\i-(Xe,q(aE6k0!!Z$	[q	4xE,L[6Z*FDBkw݈n׵&ONS-wιsb}c;PdkOy%g& dJ9Yn+:>"Rq`lh)~^k[\y}^V¦T&,GJ|WvC/uזd`UƝj҃KOrcT;VSP0UHbRrv\yIvq2dVk|x/}
vpE6/ݫC
"Uk󹙄-u/![_ zFJn'僲<Ɛj
3HsTF̈́h}GDZb:Gت(D+_Zs-}s?'tgR
#B3\G&
}L+SFRYx
`4} >[US"u.'jo-'z5E!s&O{Fʎy9sl*J4?"X15s#OGMW6kGg?sU*;2i;:c{<Ɲ<&<5z&Xf&ߩU}
La7+t{cdO4N&|%xFsuF"OcNWޒQ3
 +P_bIz9wSz'Ì:U6u_en+$i|
52Bİ+%Z
MkɵRރ
9~۰E;-'o<z0M5Yw 3ǃlp

_pdY HR_sBErۗ_@=?l4G}gŚ,b0L?j
OgSo	
i3|!|l־QH\	#eU )z0y(:k*5J`VWi x^k#\aej;yF?m2baՈ3)ƫp8ťs͓Fu'P$6kG'|-x́Xɚ۲@+_X:R&TY+5n:jGM򡨷M83=5A4x&UAve_$v#zbjb+m4fc%\^Azz^o,wлqCU5wO󇸽~z"MIObSDz.h^ҹ${nj3ꉁY)ysf2ehb[R޻O+z9Un0]5Q}˿h?lN7lqWv._0 u)y}uw;@Go:36rL1,j{0?me?I踷_awxx!
P|<oV+C*=맶BNbB}_J*^J|
qacK&vD~	cwʘRhE*:s1zEqI]feiv=0fnWݮyhcEV}{
E=EoخA&Hr(8p77CsӉ{ޞ_V2M
+zpxְkÑ{X$5l
>}7ma3J$zq#pKz,l߭7?P\>[L\8ic nPz췓}cCH=R슭S5i!ms7,0@^#Vy dA#ހ%h<|7"	kXN"%^_zHKқ|Fx\-
P.w
<Ч\
~ E3bkaN"QdO*
8Z-3eJ~87"'O)M2{lTߕyi\D=^n
rn!$s1.HjZa@8yltrBOCaI,h301=KIݪӾe.6(ti)zFr 
)Yzbz Ƨ'vHS~EF_jkh\rFb"c(.= c\@"熵׃bbN{kwAh
%cXG	2랐;;\/٧I
'мH1ev<[1l=#S"Qp7)2̐༈Vs`)_V,X-O#]7ofUXۄAS~[66ĶkP2#
/nQZ/DesM+=arj2D)%dӌKMXSonXD8Aq:7=@~%> q#9O	F1Pѡ">KSࢱG%[O(;RzvKWu#tRT>>0c*AS%) <eBU眞TspP,J@nhbO]P^OnH% #yߩ;F+$&c
@h|XFlNдؼ{mzJ[2`	ݳBusͫ@#7G5)ٜA$yzp16cؠ[[:JGi{!DXc=[퓴jV)	C{I!VI5CO!N"ܐ+Fs
!
bXγ>pow~2cOWa2$,&O%q#gkJkZЁEVU<b
&.y7h6-19/7npP[}/h>aµ[EgGj% IVҍD'B03׍@Ή
m:#PEBH-hmܩX,҉ZMgw[׆vDzcq?{.{KT-iӹ KbīÔTr;2 ˓?9&+
NhB&Kz/"IYNy7T;`Dd}X
?oSThh%{HzWFIG+1:AP>J
,bB;3auT䨔.$#hJ缰k<Zk!\oy;$d[ckYKg@Bo9?zn20lqf*CUbe}Rq|\ewFtD\`vh],# SUJ<#/.xB{=X̝EU{6X~S'
[`W_d5aneX΀I:>"VVm*vU߂T$fw;)v.mKM$W{W|j`	I(0P9{i^tvs%vQUfO{m<NLpO$zevC+S\h&]oeUU<i	ڏWL2!5*̈(O;E|\}fFZ<0Zo"i9!eu@}Us
]0]WTV̌fpu̾NxzQ=I&v' B?җGôi!E_!b
B6͓&WGH{v]
AuWTu/˴ <}.v
^T=fGz^ٸC1KnE!#B;ɝzğ.D0Y$px5t3-Ƙ{W߳qS+g̀o fXw߷n5_<-Ir|{Ԁq|d+[OۨO4;_wO6PL:[@^!So {jSaSQ*mp=+MW[r~fbpT7_,n1eWe_.
O! bؤ#d[AT#4@zcজL]%@(Z=0Ta;a~j_yFÈNG,"1;#ߗCquI7$ۮgXq	"Dұ&tTcI$y6LZ_;۶x()1ÇԪg.>+X1+vf-<WW=}?vߟoV𤁂(S􇅼 V	AYP|ѭ۷҄j۲[z$J#)se$0>
E(ٖT"߸Fܶ |{:=6~X%Nc'з,;\IA)xVР $xQ91E5{9ԏ \A9)=h$ֹf_HbZkif`JQ\:ٗBK4<x3ɽz`=k]1݀G$SN|6c4$,󼊱bAe5fW1jnD2딥r"ib̮3SZcN-1N #QU߰J!y&wgߎ}T
㦩*){(Ϫ䧰GAN٬a$ݏǵq5[xk$߈em&];#GUn߳s$]Inbt܀
Օ?f gCyh7f9o2x
mKմunX,_V= 8|\oo<崈TuVk?lu..mx|;ANc=*8Z'b΋ƃ{D(l
NTt#Zb!=ixrUfYFC8M{OR+_uzvx	n/E-c-UNF#F70KaYM}V	sI\!*;*D(f؄Y5Adb' ]	\&p$Ui=("e,v0wIt.Wf6Xn>rVaG2N'}alӕ6icO!)Yv_c;$K?76QBLxM-ͻ~V
qFHVu#Xk;ܝ/_,ox)oa~#u~y5z 3-˥sj+YpґFLߎ:=9N{ A9c\ZS7!ELgHe2ɵ]BXzN~W}cSNMRC 'u-.!D͟*#3//OznFSwLvq@ٸڹ}A{|9,)vEWHnRۢن*̚;af&K~.K~J
d8$L=6|L-x\ߐcrGuxzmcp4RGL̽|:wFV;=iSp`xBF$>+.u53QVFqt;TH7 J6Mt͘2#Rt)lِŅm(s{qY&rL7Rw"RTarL:oaKRTOv↪Fh=yALXkH}M؁sU;nHBBS;s4^8y6K{W5`zCmll#
%#ic nvegW4	GHM
fD@9eȝGGooMb\KlF@Εww`J鴢Z/.A[!q	d.r޾rjN;I㲣FܰС={٧pK~rZ$8c:3nP)ެ$ц" 
4(K4.V~ Ic1yLfJQ")_U֬g}K|TV!- pf*!oD.%z
czz{r{>v2tDnDkhfyw/AaD+?#ma1לSqp>%X_E㗵 °4{.ZuޥT=%v^q
y+<!"H}} 		ݫJ_+C}sj-AU-@iB$m%w.Ji]2n'EILvePKa`,eP<wl?ĹTlNWyЊID>6 2?~lS:kR%Y4г(a DzV @Rl|Erd,[Y
jo{Yd80rNAz>v΅dZy,[Ħu^n:lIdEEÈϝf [:btxax.vYmrp%9I uAIZ凂O"ܬ8~Х:O`?g:v֘D ]m.L54l}~<GW{:-!"Zϴn)KDn`0J(C~1k
Kn
yjc~AoHzT2t	
Lur>ݨ] EYB֎sgAqJyAs8?ewlxS#:VM HBnG9/>&x=Ҩ+Є hnhz%[:g'[lx@䮘nUœd3\0R},f} 
= 3B
	>gژWNX{wJ"';؊i]A/>R%%H-ժMυmtܑ|G+>"gz@f`b1^RAF%K%qRl۹+6<;o.BfL sV5(xD:
c/ʜ* PQg	,*O;I}7]´v
V'P} ֳ=Ahw]y"}v>3gEV7;e>Wp`O{c;"ȥx#7!:Ob>w/];9&̅ ɕ8ޯ;Qq鏶Bc~*rW%uѷ{GI)ND

N; Ѓئ\WՊv
vv=	&ʓ|8Y,R
tgrUh
 ?:ZN_9WȐrecH͚3
w$;/>_KfJF`qhNL[ҟf_arU9](VEFm
.PXdKV^9:1
ua74L*Im=&WO*g/A=`C|?V̐@-3No7fAz:eTm[JtlV[Fb9'轘Fn#6>-ni^"^FrEx0i<"{=<;
v
S4?eI"yV%ꋲÈ<ILv{&	V]-,ddtRJ+
t&Ln">fU͜FE`c֫FQiy4̌NUg:cbhܚfEA^ UTsE:o8taj[ $,@1s`hzb\ /L;7cQ &F%EAًJr{<
I&`ÿwbU%6_bI"cbMOo
1m<X]$Wka.tcx>^BJfŏǋQwW]TuՁJ|Vb2ZҮ@DU{Uo!6FHfvVX?N<_w ZrK./-z
5/:ؾ)(0QQBCQIu3@M_~utZqytR3ڴhE$OYx3tY"Kkz"twE]s&rε[q-bRE8'$*>ƠȽ z8ϓog
MCOv\.=vO~?
@ன"\$&ꔧ Oyb<(]hY@/FZe,1Z`zlW?Zh\K"B7wI4
)SH:hK"U2%6{_Ě!z!V&{Ԍ U>5Znl'(srzzU"+7*smQ(@Cih`}Q1}[`6%s
$;MGsoS,0%	μ.HL. qbV8.<G9w0Z?zD՗A]OORbfwnP?5|`H<x'S[ymhoEBB5$r=F\_e})E@tDl@@ɣ+3jka:Le)Tݴfj7.dE1OjM6C>3ݑm *r"P${VEb[Qy\GP@/9V)5^̬M(._,SS/4JÂάB%{9IEU{]iͨżQ(qM	nmY"-<{;:\!^.ߚ6
m1yW,׽:=xokqEZ>q GK9w#/`X
émQԺj7H2NH z0v	E&V4bC$%Iud:nm"+pggabQC]
jkw^ysGq)w4'S>s&y_݃DuY#s#q6i"Gڈd8e;fH-ǿiFʁAQ3R.m=lX8@'nU_kn9d1$ݒЬɈi{PЉF/cXĻ@ Wh=|t3sQ]oaP!HrAp:(1oz̖1IMs].j3isy?<	*\b04)Dmm^CGLΕOiMO$J˒
=IJɨ[ξR&l6홏1sK!&P~&/ByG?¯NN>6*w=H:D[8e@^ꄝET6>G74)b|Z )k@DR굏(
rM"35`٥>RMF3{ap|Zw0G)i"
r[LZX8qFn >
QAX;(F1rΪDo/>s`XfO҉t?_MUX9/>%cQKv'%CA\tx3 g"jWPBn2n4\l4è"bp%lt/71>;k46Vs\.V`zRuƃ.['j۝+"G&f?g!Cp8XiDVQ(0I	0@*SYqװ]p]}zo>_\]]|=^E n{[3yw~v-GHp~7fXp lpC~	YU@(iBY`_5s&G#ȗT=m;AD(MD|YJ#FwXg/
fT"  $nMm"	D
Ζ\} gUJ(i
@8:&b·-}1itT I7J6KozlTDa}T=R[tJ׸^Ll0"'荣eR=61/mmcV冾Lzx&҈<I.\	o+1hQ|fj @_C{7EJ b@J%5]WW&Ho-}YGE}nWgOOQw	HT.<an"ڋ1@s''19Hż&M cET>Rpq2p9ao!
}P6.TRzrz*nW<)1zRl#T&F,${4s<Uʙz 6 £ص3Fg*Lou$8jx_!` S98f S
Tg[=gdmB[moQDrOf.Ī
־$"DY	SDm%4UdPxC"*& OS@80.UWjˏaYzy@8vHZV}wHYNk=p?ek`"Ѷ%$qjgt}LiH
/a	:`V/O%2ӇwBU$"U'!ED[ޭh֣rLtmʦv b__l3O-!fwùÅ
&(Ӎm
ܯ@Y0X	[1~	q=LF=&
#=	_"1KU/D!y]U.l=UB!Ex#ڗ(`г6Ns<=!U;Dy'&y"}L/T'K߶bmd	Sm@tGҦ+RI_rؾsmD{`-ql]'^JUHCOWuӥ֠/ktSU&( a!USŷ771rrJo#}svTy8B}Vp^c	 զ00>:Ie&`}v~>~$ SEvQIyMJZ>Cya/wqSWyfz'ߓ:4Kw0F'"i1)kp}fn!EK U<²]Fّ;_Roy͊o&݇:ȖԡTKHWCQJh@={:ߗn6	B{,myپ2	[P!Mrd34%=PP5[5)M=MV]g׵F?>q[Z>~`dݹ
Yhcze*02
ĉVe޼~}y-qz};שֽ7ZDV{$үVE;hngΖtTXgcYr
l.4r2(^lX%4˝TD9;:%	h7W}!˧x7?lv`SCjܕ$k1jJZ4/kǅDKͽg!\fIORN/U/ȣG yΰU؀a>q-Dl^ʨt#t_:vH<S[\bZ#o((6&Juxӈ:hZrfadvT|	%ygB_)@v.,{dJSj.@tܬ)<.S. 63<+vQ+MBn =йRBTUq2w}kB3.bCJ(59Ljx]&(ynpgTɐF_	gƟO:;uf<+c#W^n	=D߉&y$풚}g.sh!{<b
pF6ukR?DJMo^1jE;ayXw{H
bAEJ
#Kg O$FVhfy9H8cMWp>)Z&<+r "Ц0)@w)>Y*>J$dA>4Zo}W
B]T&cӞ%J7ڱYCďZ&DAJjzlA)g>)Mq8rs5Όd-U+<y$tj¨$HidJR瀪6q%)3VT^hLFHSxZ(}n_ 2*^s`e\sN-BZ΃]+jᒭBD; M`m+!V'ڐՆGxN\f_ȅ,rmoy~+tzFJm*5VBrP ]"HE8p[Y,C=V0A((J$MFxDуL$ь5Y9[|v?״CFu-Tҋ:amY-U|}S?Y$֓vޗ/BW'!)
vtMڽ[PП{yY%:qW=jI%cEq[@ԈQPݫyo&NTGYO~X>}}<~IF&u˕VZa0<Mxx[rWzՁz e_zWWY
횥
Ճc_0䌶O[ؼ^Qm1+IT*ta.v_tֽogI9sl.Q`C{Lw dx8ݳTk-
<
$Meؤ'(n"6hb;\4 PF9/7
_n`BU"zG<4 v쒩cf8RgD",;{NP.j*gNj>N*6ʭ|
GH0b$xߚjmq'-kY׺Wf6g,FzM}of;zfPK$g.MK"ߕ.Eqυ{mu3>%qL{pCʯ	*]-jNY|s( Vatu}' >"j|@{X!CpBAxEZ`OK
[tCy1"&Sȿ̰Gk>>ZS.zpئd*Q8V઼X|+#$7x<$P]nM.tOT3w1}9Gm_BSrqO0b$nS{j!@:qI1.
-xRSkMǝ9&8]pAV9lIPxQPE ri9nIFY U
$6[v7z|U_K<+{BW+=m;I3)wipgb)ѢOS⊑6R67/)vEۡNngņ0pRinKVnRbӹ @%h&,EDbsr
s$y&aAmDa?ս>:ѹW{	)^|7y&W_7l)Jʘ=ܘr굏F!ѷ'NnH[qNoG'veK?Qu*ymM7k[<#t/TgTlݎ%{:|˓|Qα{ 
jPwqb:`D۱w"sUoQ݅Rk:=9Z=#:"..[q=_%x3Wn뀫Z_g&7?1Iyr*5RN2n~"@[gIYW?~Jl"o"
+_e <UF*/-I϶ȶQO>>d"vg")HT6nd$6EQ/QU{9Zs`JYv?&"|
S-Iܕ"8
Lf D,pضM^Rxj-Tv[>
ءwz}r׹p٪]}׍v˭CP)'fz/OΏON&z|!_o6aڒژX2(zt[(84\gɜ
żP[engr_	n^H%9iAJMמr+/BR
T9ua1닯@-w|UG-Z703*H"ʆ8M-ɴB^xnz,īk" 
vZ\]~`?l>_>E3sįȏoX2WqU#~	o mHCQWMAj!91\ܚM>.Y)aǜH?xRFQ=Q\iyQ[lğѺ/\S-xyW䄩r]}_&DoHNy\f;ڟ+:<z7N!*@_|9zKyw!	<<f|f^̻JMQTƍ/wO~:jӆʚdjd~gg痯 ^@{*^(ܪh4 qk8>@Eh[
DچF`o{|c7쯳WՊ/=>v1M|}
Wʝ˱%Mរ%,h7G$ף<|Zݽ(5l~߷
,h^趋{CoO9_HPSOeujl~n/ZQڗC 쯰 a^{-gngOnG	xD|YT:ƆEBe@V-D7M*$'#ؘ^KFfC|z>.w.e'~?Y2wdjG9/
cNb/gOfΞ0r֡
Q^e|!ځXey'	BLv;Y s
VןTpP}#M7{Qza@`6p>w< s:StUo0BՋxrsJ}WT@Hf["qa"cdhy<X}:loLq`P3Ka_`(m
nۀ-#("cnRYLvﲰ%,L u[TrT"iI,ȉˆ,ۯ6=BdI' o^*0:xHGDI94wo	|S=$$B+r+7en&(jL~@[^kG,,
c;7N|ak_9$׏_LU1鞋˖zS#Y6mkC+Cf@mBS_\u~C_۱he1#697%bJkxzN P ԭYj˽z5Q5޿!˳llI+7OiOfkUSӛ5ZG@{NxhVy/.fCm	Q*{Ay
dӥ7M}QK%MWpKc̍Z43֋0ڙVDD{̕7Z{ڙM?Χaw:AA2꣎TR;/[k?s@~";#t_:E;$$˚{ړ9U,u86|&+Q&8y>Kh}XąueEo@YLJ0;"q4יU^Gk
q^w(o~8n؊x<$ Im^1%p!
r5(.Y֨bEYVϬ%#;5k+{ e[H?{oFKv_1޿ o͸kk,۽I[/6s5cq>dCV{g$Hc-7Ӫ

%&Y6)0QzDe	VyMJFmRU$]߳%ٍ̀IAemMk"\IV4缜ż`Ўe?A5_[fKvGETi/2¥ξ^#]POzW
Z=)dPϧ	d7n0b6wZYEݢ6Ɠl3Q0Bf
G0uh"Zzp('ƯDAa#D6};4yIHU4_3&ED1x\^/ܜ)vb, tg"0vbP`ՅDY*υLxѨ$G<XSVotOGkR0kbJrz>ePoF鎅5]"UMrj4hQĸOʣԞ"hl#4^Wn cT9}	f漳(o~.hYwM<";2M2儀_nt3OAm-_!j=,Q}F.[:lm 8N)HߏN`"~Y'őv5cIU$Il1Arz
vE7(@}]*Uᓛ+BE@$LFuixGLf"_VYFQ;=u#liʉv
oN9
*F;}' lF\zx}XzB(p"H*$[y[kig۳u[az++,Z&ևu]J.BApj[SqTTS5_6q`)p]w!g1[>=%C\lV^!bK^*txքʇ´,ǥ)n6qjr_e
lwp\EXYʩE4rse"df q@l\l2(
^Q^Eju{JnMqo&7n(GH=(祈*÷q@
zTVuMIK,.na8zoks" 8=T[.|wZEqؽUūZ":%Hu݋ ɨj(.:ӕg"TRlm`ynNwIEH/~LB nBBRU"߾w
oWQ_? DZ颖)DUa,[p9o܃}CFCl.{iATp=P`ͫc(QuHuKCjȁfZg6k\D䄃WV2/Gϧ{E%+x'_}n0+;*lNDImev\fPYtg[vѸ^Q:,n,[m *mv-}ȕvca?k ϡts*\Jgf^ܕp7	@,F.r71N1(eTZ|PZGM-
ǫzd[*Lʘ-*ka$(-Ks_ɩE(+g]vX:	KLZ(aG/S鉩ZLZeUODa&Cn.TF?.ICuxHT"JyY2/B=)	t_ǂګ(#n!JV$%nl X$7lP`~mRR	N3ig*I*FJ~tC1
GevK*9ZZs0>~
祢 0tvIM
@HwW9Wr;S0yn$bV,0p:xAs
OHŇsGxV/W`kO?H˙ϡKktcHӼYZj÷?]Zl*W	tKrݷRg-g9e(7FuQ~rَ|VǠw^ǩ0`c!:fR$[벸.eh[p[W籎<<86|(~W2)csx8"JK"4CXuꤕq*ҙO,(; Kbҫ:^SJx/4u^*;qզ,PR&OX [/y,v$HC3ܮZw@1i!/ywUʂLR џ>x9B=^z?Kn؀/kbpЧFxQj(n7ED<g9@]}9hk9f157vǳ7tC-'>xe{k+(Ǻ4t0(Pm,}l^Pry&oskVg4 w-fg,us?vhWlM%	jI",Wk^m=/b<
Ľ}Ml-{S
o]k޵?)ioj΃,jvTphEG( b
~i__pF+e0
ib(ⶊ.e=E8Cj`5n$=wMnP	w
hmMEgXKrq"-)RW<?vkwʞ׏PKI6UTs%>ԱEuG[#~U%+MM[m,@|֜'lo)n%J.)4L!JyT9	WEג3FpA @wznܶOR;\Q0 ܒZ2jg=42v?S_¨Xۍofχod:dF~ L ^ޛyu460z"顊stkV.UƻKhFuָ1r"Xhm@A>gn/.l 0CuR?]3F.jJo5Kt ƕtDĆ!Z<Nd`&î'%&.*y1|6Q~jʯD130%D>~4,ӯzb2{D˾g2wy$KxXQyl6= ?CywZ/?/;&0jY	igq)F`폪Cz8AV? B,,:$(Z1ЮE
uUG0Mys}َΞ4L!z(Qџ.g][+ʳ%f1>
αXm/ ~֝Z^yӿwDH/AE='ggS_0fi>~w/<K!YaJJ
Q&%Q9#>ݏo݃CI9ʡ+jG>G1-@9tR|}#3KVu5ޕw'nqW^Ju35:*	lv_샻ntLŕcY*k$ddiYB@FL+S>+h6w8>O?w%Tg}6խYKV2gSQ?+ 奆D
ƿQ`}
Cf4BfxRڊ(H	ԩa}fU>v+evYLrJ(42ͫʆ٪R~x=(HdV&h
B_ǳZ4Ђ54Q5o?aq{#-TXT[Ǒ=+L~ɿJS4Xؑf1") ktb7	qr_;P c
JJ؅R_Fvk!.VagyY!\sS;&8-̹ձoqx6uETq혻{2ri>ig1
1n
DaV!1*[V	=6 vf)(ΊLm/o½݋~.Sp۵PWV}kdqoV~_bEL44;=fs'08\Q+!רyiW:{;Me&yČo;E֣KV Y6IL姱VJ<ml:(^ydon|W{og=3;{Ol*rwFdOU)u"9bw}sԔ	Tr~",=Ⱦ
g-w^g^RdSD@|o }^U_9˧!(m!֬j=z3>ڶ8c^sWoU͝}(<
}
a5	
[h͝$$T4WaVH"r6eAFMmKvG'DN;PDÝj _8~(D_Bo]2
F4ȸ͟ʃ!w3.AsHSpvA izU<nA/}DVOvڑx$V(y7^~}On<lcQ땽ꮰzaDD")v:9npDcaFBD
9Q*l{g^RZK9x\X
D
*?kX	Nyc`v#
} WXB v+ֈVs'6
\D˹c9݌+?$x@ZޠFo(nޖ>"1vbBZQ-eƨ)zAkJ^fKnŕ񇒄Kː!\mwH
c@ҠE=EB.>ϥm{e8wwZqv$ 9=-뻅
{maeY:*dލs(J^b58/
7_SCXn!9ji]Gc߯˒^v~iPtv:ٻ".Ajh6HzCʹFH_KvNgS]ewDO#x"ȭA^`iXQA~Kw
n&>Ćynz1_@hUwGg455ޝhߊtĮCԱĕƨY<"`~D+'Bn	U9>t(F*Ӽn4(;t	@MV~KNJ "BQ5}֍iS ZQ^ܴ;~ϥ7q&oø::~8|ryx}~Iסx*'zYY/.vB/_\p^i69s(䷽[7$ՠq_9'H/WH3AFuӓO˿HEYY Z>e Ee^%[u[("kނwߊ[J67?
 h~lؾ+@K7iW,q3)YlG+\┝	\bX~F yjcZp22=Ѡw; _jSF옘m*$yzmV B=1wEfsy?viY5$a|_i1՗qۦ0%bDeBt	z@SSɫqL2,#a%x!x,8Z1]
%6鉙nu_p$Jqhc/R竰/{ljDq#zZf>햐qϠS'p6ͼ?ZCQZk1,H~	Չa׆7~Q[ 6Cγ kR/ G-O{N+W CY
E͇ ki,2L-mAj:bۼ\
%Djԍj)H`cegua'd7Z/-^bS
U&p?xqAABBr7nxf>tlGA0Hˣj{?2FWq|cbv:֊a{Xf0k_O#yIPPF;zؿWV9l>WS 9sz-F_[l R9;[!Թ~Q\mX˭EQc%ٷlYӃb4A-A-7vKl"s3޺%-lb(%]=羵Vba6kgϙDVbisN?'k7rvx-T!JB2Z
;@q90RV=5/B2w|=@H^Wp)0۠Юp麧5-j&jCoj?xY-Zs]]kcAJ-긠jvTm1zx+~si >MJ*dq֖bTXU2[
#Bb\^/v@ZNFAޝJQ~CL۽KIn8׬zisXLyĢ]ND6avC8n;r])^g)UX&$0I@v
+{;c8OUe l=o§ҾTTjA͵TX~ B{kluŞ{70|Lc%f~86>d|WqH ?s+o(bDEDyJN(*#$@݃Zq4=#ADBʋH;e5ǜ7g?4VgBH@ozXPB[cO1ƲߨJf,WwAV3ImF)˵GR&ȶMpf[Ak]'<')R2<uGW,d
ѱl,,W|mqyy-(e<Am~}A5ASL9D_4'!K[q )B [r5pc%BqU$GO}ZjVq[zuDbȝ7^%
(!9
fy/eE߁p Qܠ}Ptwz2@-	豓' x27Tx>Κ	:8iz<c&8U֌?c Q9I
tb2x܏XV,(-B}w!a3oQ{xCe<wZh
c/~ .- 8aXRM?m{r`] &.؊ѨԪ:MD[vuc\<ەߥ٠o5i '0D SiC'|;EV(Mx*my#z%_	/PL~(
]+h!XKB[dD/;

y
9xg_fcTq2?|BoSF@QY77~87/?2.ܣ-V i0rsı\hDflQ>&BZK@)_1Expݸ$)PChlS͝}wU
ǩ:EPjI@ %ȱɌ0STތYeF!nf!*+*,[>0Ub	׳-v9k7<`CLdۻ%npc'&5)uڮ;IO4Yǅ'1a
lHBjy⢴5>2ۂ5*֨q_pn5r?V3衏k]<,+,77*ܻ	Ź)Rmu,<;̗q԰'͉r/DX(0Jtu"fGNjo_NO\UbMUau%wwBBSvdKa"h[pF
(3D}$MzO6@ck.>.kkT{tzD6Q[b7g49W?
5Aes΢F\PSNGNUFzuͫYZy!~n얂ڀ[s2S ll~	n>&kR$8.Qb9K|g2}:z@a 1t]4oNv־+ZvĻtb}dz؃8Hv[lկZ+%lPZUڭT1Iنζ^jr][O"ۭ1YnHJGF.aVK-!NE"mT~pwaw,\w9WdWNgvA%_ȎKuңe y*(RD+ۮxưD7_Uߝ5oߛ۝_j!?ŃyiX)}˝YX/%]$QOo'=@!gwןN?z6eJs΂k :	[{y.K6GSJ[M&kY7d t
~(vvX
IH];]7eޅx`wg*
2`No>,,s^rK!}n0=?IC+!w%A0ňõ+@ ^lxyr)2S`Pů=0M]&OEv0D?%0+=.4d$'ѷBL({;آUERuAzRjo4%7\Qqs
ѯ,$yKE緿Q~sՇk2	(R=z	X<Qx##=v?0>Tb*F{c{8; 	]9@tTB	WDZ٣޲HAqvq~u&bt`X{AhԹmnv	Vs&x>ΧI Qh#Vvy
Q1PXB1UuNG#@b{A0Kq\H󢪆"fǍȃ5lMyvQMDrb?6q%ŕ.Z-yQi&,Sm)  γrPEPy3_YɪC-9y.mqyyHI,r|-NgW	Djr@"T妕`c=I4vXʕůawjyԽl߸8Z]<TWƚ1{t'~,I#ȭ<n4i#g/@(H2%e`4I8B-?xvAΌ=y/?Lp$c_/t&1u[[Y{ؤWA){&Tdމxxm E+K f\A#[\PPp
a.ռ|p_=āN}5jR}&K&C"fC<yWeVO&X'γq
,]/JR+xG(:ph|lW_8!zs69?Oa]X Gl`B&P^D)FaRB>c<
Ϸ@Oy(֫UV8-T'DbЯ]E둶JWb\02Z+5?/'
q/Ւ!mEpmG,{)e
k
rE! `H5`U֢(47KsP822yLu+Y%(Zx	
N֠EnޭՃ@J"=e쁽IEv>]cj%)Ͷsum1b.gd 
aXZCeuP?nOg'a?PZTն:w?0Ph%G-^O}kP48;{Օug48;uPPi]f
xW>lK VW/o~|RwWq>o<zy327ы9N;eS#SNDlп1@` Kڏ 7uPMTH`ff=SMۡǛ|DFL*Yc~^}᧓0bhh<cNİ,1}1yD+w0b}8
F&&akh5r(&alq2G1:BAԇ,hgA~~gֻm0K}5K=!PVs-Xn	-=*ש#{.U{h	Fɂn5_.3ҸW$u2hQk@:}wi3v"fOcO<b76j>iZ9v]:5T!*09	#`u2xsﶌچ{XlT<MX~vJeiTОѡd5VGlXUOF/+3a0
hlHE\s(}nI-VT D?j誾A
 T讒
׻+[AB= GٮAG_Ԏ,2Պ.i3>͢Sn[y\A]fPƑ]*h
iRXÚ@$N(~i) _Pc
˻Rl84ru#<hjʗtVLS3%6)z3OxZ.`"65q7
;^<Tʕ[i`m/zxZ9Kg(υJIt
W4[t+^CWgJ%{y\mUc? .(Tuny̵QVh@GěI喇CL'%D7!6y2"PAdu[u`2kH(h'IhNª8a46n6S[*v+*`2&Vķ	ĉ{<&Q]؂[Sy`D$<fN;(sVr2:lwIzw)b_UoxP3:w|ϸ)W9ZNfmw)sRڌP~
8$ ,TsD%XJ|/-F
us{K)QU1
SV[4m0IKUJv?g?Ջ2:	 K.~=(FD쟦^PU*̼HR؆>}+$
!D0.ʚzymS1Ȍ3yҏuqQ "BE#0KͿW36J&4͎۲&v(6R:Ϣ\3{xX=>W{u x}scoQ3$``]RmSdW.45o>P)~YV+jߪ
I`6,j.Y-|\{߬Rѫ(½x{:~ȍRIAE_5eр9ԺA%t?s?9Y\ny$l!i	 z-*:"ܩ}*kȇ+*gZ1p<lxك{~+ BW*qNf#.#OimHQK7 fb2X])3kOaΟdJ\y	4Q"ٲïHBP1n~(]6Npu]l]&Q+\:Z&_qDLEzocF`	u)ot<6%T#PYIf* `|1`5jxʫjD2˶,0i"xRez˗GB7}eV6
<PsO:(l`u[:L}n|,m[O(u/䆶KctME%vuk|㧻hr~
RDaPAoB \_ Q@
ioxJH7،P-LVhAvK^?0
gY|"}.@b0=fD|P>dӼɀnBfJЍY0  +ǸNlV_MKg$٢fuؖQ.$뒚;Q5<Ϊy{Py$byG\sBH~Ec G㞒1b{6\'AGJӆhF%EQv}¤jauoz.4*:q"!p^rIL`Ӡq5AhNv%!"&Ɓ]0֠g(su Isc^42)xXO
^<M`lI`yϠ[4ZOvM*nɿkCu0ĞVK8°)
I]X	-ۺEʉ-3vQIxEg`
&RMٺej.FJcԇY7v|Q\~6?ݗߗ|'nn)+{^G-)OY&=Y|~Cly?-h[2~pKy9zA;[]CmZĉ::=L&bǰ]Myk5[5YBUCb"כ6'4wx7t(6XJǩVܹva!o",Eh4{1Ґ˯7	h7<x4-(1g+-r{+.Ry_@7]QMz|w٥)XԭԘ`V+deݒj8=!eš}TOdpZD΀:(mNr%;s]̿ӨG .ns
ߗk@ 3|ȥ*HWhڤidns5a,^֔|}-yx3/(
_'D+Svr4*0M:M7'% g	^g\u#OYhS
ze~Z?D©%:偺 Dzn@)j"X'V,d4ZjlЅpka0$.rƗf;=DgA<k)P-c_9[ɜk8|d+b.&o49H(5߱nZ5㒽-R'A,Ei%wn;|^$WF.mD5vk#۪Uu&^(5UzMW4R<:Z#ZbEjG6bz[3dQ2BN9X5\ٓ+`n|5e'\*mԆ!Ae]T)|E[j"OgIqckVb<]D{e/ċ*%*rj1b"bPS8j,CҊ{q%jJI%WINMRm_HLfim{On# Bh?_Lr$4DOO/K&&?csA?.Ocf)2>:x..jj^]N+xu1dmm^&EeӰ9T/E^#ȥ"^UxAv	ѝpmi)}XV䈠\7,5鶫m?KcU#|X	;9*`b-1ܺAȺN>TlJ76{Z}B>kJY=/,㙆,ǲ綛;57	М"ƬGȁI1X	e38sci.71㔦(o.܇1.;*rpS-($q1y]5M(^A|%Xԅ;dbCGAD΄uOI~&
"S]ؕk^Pz坢LJwG8[t벃*P5F#;w
j:V~Srzy7pcDD'/gOrMQ_,Smy"@
yU{mfĭ%*P9:,׃>uF\H`_|WZq"Al*f!DX[G"լ	l|,klr0Dp;7p}"$Qg1F|b? :o_QSLg^;
E2}uQk[QQis>Ɋ4Dċ?$hd3|b	e)NF7<Hy̍Q?*9kdF%m3".j5EP5SEgTUd07fNI#n@
`l"_7u̛#Ɏi5s.>aQLb7

z,CGjn,6ďQ;$ y&pϥ<ygԓ`^=aџȞ|na
JSd_{oRn=ƝpCVz~o<Qly;PbJg|`ŏ,i$am	R
,E'e8%4)<4DKHs_Bk:f\Ӿ66	jK8}.0hpVǻn3әDۂޗY*ҝ`/gF]adhR8MhA*(uavƕ/~7U`@}+to)W!(	-ZxhaQIsf'Te^sx}:
/[ A7|,	'kS#_i΂ǣj㾒?@\H0`RJݸ2̤JxhI.7n[J`mWZ먊{F!
su;~~?
Y58
@0<ZӸe`ɸᅕ"׊N݂o	fmpc-VaCu[34x!KZeG|\I*'E4?%[dMO#CPX<4+~3.\XG[!vQ!ݟ&8ӗ(pLi6*54ьKq?e\5.!r[#&{L^zʻS?iu{k3Ʊ.!k)߭
ym2cڝF"4Ӈ²{oc5]/:&=_' efzTE5gY Kdd}޹X=^j H,f}L
¤ↄnfRH&zv61Ds~-(tfxJ") ָЅ\1foS[]_(Deoæg[е$/ZJ(@5[SU.%S;.vr>-/2F$PblOCbW
{$u+V]Ol:"ۓL;i+UFqEW׫[Zd9awDYHx,jφݲCӋ7Ȏ߻w",+qTB升
P=h	 }
+00-w8*jʱyF/;ݟ?t/\]wߟ^^]84a)VX\<RT
1z;%j}MAJi	"v!\f+n>K#w4ry$ 3n= ǒnۊBv[fHh$a1(%VYWGK֮\$nB7
4Y&jwcE42"]|k?|Pc+GֳxkksA(6K|0WBԊ.,;;WQeov#g7f/:^Di!_MyME2c}1) ;CoË^϶51ZeNDEv;$iZm%S-{+ hvhK
N9x)FdeG|lI
jD&j.Tn	CmYaۭ	R/HTo8rpf bH
ꁻswҽh/۠_V4TUxH]E%92
Ȗ(5I7v$Jec)_壱=ڻWɖ_9C]8mzb-sU9WV`8dρ]x1W<$r nuBJƩ\N
X@3!1rt{}gq
)eWw3^u"L: _zxԝQE2դ.k/s$V5ߡٳ  nh{r,gu>G.oG
F5=[.hP{_3@/!Z'剎rYFexܨ%Bkn|K^[ʀ!=D̷4MIq^ 涠
ߏ?Q;9K[4ss{'i᳀ZPj'+4j'*'NhŕQ>p%Ŝ<0pkэ~+܋a	mONCh@^0/bamrG2]XHY?m.@`33-4QY%_8n
6qtvj~"屻*&6XqA]
Bۻy`&G1_ܡh](8#ZKRsf:eW?ڕWqEM᪳^Ma@	;"!"an3i0idﻥHǺhlVSwe\#[ø>C6ܕnK+}J/R>hA{gVN#RY4_Q-RE4/ve[wkzMGQ5\,9#vëygqy_7KrZj,@\dǝRGJTeݛlK`:|`;o`.ƎJ6=
Eqeڔp 1>[8(zoW*SkkO騬_w#ON?__	Ko(فEPA*{_U[Ѵb}P0g|Gnocbx}XCؿE.gmht@*#hS~`ڰW${ + ȉxI;!JZTͮou*z$Y:Dc!~.*{UL܌0<'e\<{BWǾQwGWI]-ZX=SV.[F쩑N.6y$zO'!
:Lygj|GhrwnENBζD 1~f		y

e/A10>
d1I,l8rIT!C.&XԽO9Z^qeDzŜӧ$dOg=!ё	b?oǓ]ݻg!ſ{F*WɶCsφΊfkM[֙׸,~xёG[8u|b	sO4k;fpTbֻ]j%J=6;gWV>C + _T72Y|U(;2^Ƭo26v9Ѣ͒ɚF'{51&]FIHCV~.K+w@-:ׅ;0]d
AiJZ&~tS5"F$4܌~`*YrJ؋:R'HNY@bXs
$zOE3E2Ђ{;%MU%u^io qknQ$؈$ǊWLDWx
,f
n[\l_KJLa>ьȧ|F\c"Q9aj̴˛{۪oP_=R5qP1+g7)6qq#Ǖ\
gaU@^q(er&|q]_F2zRE
9VU/z$SU>O4wqyݭ޶&6˛hʹ_E:׵laC7&M1OS
$׾s7%&2n2T{r1AwcR{^QwFDuӍyC`H7_sBnV<8@"nLX,<xL(ֽtJҢF #^sswrמ *הvƑ~=PPV8HZ@.4[ֈ"*m[A02+h8usVjA{;mM/~bm  d/./><=B(A`J^"i0U8lVbP2^Wb{~ٵ1Zeqsl$)h{|ѓIicg?`9p1p(e^<t=iK9榬z󣳓_^܈ݫ4cLcce'ϯ}	Ӓ/8]k,_	DCy0Acco]Lqs͍eWڀ!с
	1't%Qkee0&ف
Px-zow&:>3܂e$dkKZP0eE%kVLEz,=JVezѧ[MU/f]7^'ثܦΔe!M|*T'2^C?zDkb;XzC!e?pp]mdi/v"+'@!;#̏f
Hqyn_&wm>EbNG؂k{mWjXߓ@]a@_5|H3ʶwxNMoS	zޤv&
BTtY0P!`ݽ
FREQ`/Cg鮘žYLIDn~aqWvbݯo-[)]$?G<}13RComvH!$~thtم#Q'̇nOߢ<<|
r89u9djqrhU&֘20'M+648䱟0ĦUA-j\i'AUK{޵tonhNKų=FRb;[\OFI
]mȉ|R+\M7Ro}	5}jK^#VQPv[??P}*;ϭdJ'Q)7]7
'	_:H߷RzvﴴnAL6tC$%^	T
/(A8peA|SU8kP7EnXe"Th:54¾(8<ʞziDccM<Xm1s
j#A(I-MD6] vm&ѧzU5T
>z?~pelaI->ԟ[ۊc/X2{#A\n1_|1 ?$;ޱE#<i^ŭ>WXԋ+E&FbͬTMbUғ[zݍKg]ݻ_z:H{YeoA0ŝl!_*k9>w$ǖvNDnQ_;.k*kmx僝F>st|x}~fLځ68q1uցmKa,y$
4
ղ֚Cv.ҕkAy Z+آng.ޗp?uy/hUıiHImܪCNw8[<#;p[>p]d	?wev\ְ+\V;d?V`wGDϼD6a{E$ZLq~sUmS;BF0Qk8LIM/V.@.xaȡl<_2D)D:,iͿ=moKl{>ym僋tJ/ަ輆.We8׾ʉKL
Nf{j{c}ejK&Sw8=X좠/lnz)c/avSގ|\iJF"$2n"[_.E>FeƯo7v63wٲ2CKfF:dڜ|Q7\*BU%ŊUYC{l
AƵ!:yvWױYS?\P/@~"khc8ElSk8@+xzG?]g*ɖ1'87i)
)e`yzaCd$MWSL]N(-]PX0~#xX .ѐC^ob$TSAn~5%tD D!Qt
)R]Cr$n0\%İ,,h#"MKsR#=I(K6ETHO0/2^q	s L]IStɀuL9WYdxk*w.iJ3J<of5aYa2&4nYJ4
l37HI3)Rlqq=?ٱ˓/Rѫ<(t8U̡ٴ9'ԥ?QZ)5+jESY㾭Z2k <yJa ?ިHP)x+ r'2
l.VT5߭Y:N
		
Ԛe^%Y2[Qh&JyYtDHBy>Z
*/wnQ2⊇`:Õ}~fAr 3u\b
NRa-/pPng CɾdcG>H۽T=Svsq))D򹸫\n,xóϯbDG[*^0<Fg&yQ{O#)5-ܘqIq{D8GvO )b_ϖO\\x?l+CԱ="h$,N)_n&,:'eovHAa@^? Wޯij&e~RȍF$᫛HK
*kō FzK@/aT[;ۡo%O?Gsi!RQkc߯<@9P)idl(p{)D
X&mDxr/3LS8ЮM'鷢roŧɎPIB
gHѱͤu_
Z`s#1rr'WrlFeb
%~'[G5f;9{ l*[:&?m1`?ΜՄ(NI7ձdKs"D݊OPV~9z,ZX&WErSdguW)zW|W.W:WCv=-)Y77h46UdFlf&oBEN>MnAp.yNYociq>q6ɐp_;kpWشu`)臮ԠmC)ph7ZWSS^`!ى;4B"{ۖ}=l7fn܉kԇ	c:8ࠗhzKn/D࠻47Eߥ!^rEUXIiPIٿ͋i
ȃAE%=.B+%w2!`sQ7E mx.x>_>j|VAjj3( ʀ$Ҽ/BP8wSj3Gg]7zډW,&<Č:si+& *^1UTR}JS7.zՖ*I!- SQ]%z{{/HorCnPB.۷sw?h~!ovO~	8͝f;*ʛ/k#(JAjwmU"ɧ9ѫB5w;
S$5R OHDCxLO#.z_V;g, ,XT83t~KB*BM֡5`׾G	iθoޖ齊UusNZbcxI=52@-
ej^^#JLEDA^ίlgE{QYtA_TZ<p<2ȫi6DR U7R]lQ82MKC繼E40-mt9Yw_GB6WXmdq
MA\~WLun{{@$ޯQX5fNQԨ4".'?x[*
Ǚ#卂UقnUp|0`[}Za}sʧG%h
b^nuW6nVC	sJRiμ_%$ȣ[v>IJP]RRN7T!؏~:AMB{I,duȔ$Xmi
cy|A蚯 BMf1yE"vBP Ҝ';%63;ùZG_oo}ؽZ)өӑ;	#D?XWPƴ̌=RV!Z@@;9/,(g݊($"vxa6 Hj|KHg{/$h<uj7 k&wZؔ+<MfZpARWlwSu#T?ښP=&}a5iBԎ8'%pi#, j"ˁ-4t뙛j)\ԗ8i\X*WR9r$XP$cܧj&>iwY]?N@*.@nsoxes#lUTmr-eX_r`H>}h`nӖ})΄5Ld$W:0^GK7s  \88^ٙ^/^}>MD,\#k-ͽ}tg	z^
l=|=b@}5#5%2a[سiCn_rv+IkEh
`Xyb#9ODeZέZkC55TjV박^bAW,,6UQƇ9ʚ*թwy]. 9x
n|{/e~hj]0?`5߯8W
POf:]N6[{=/㲘E}dE'hIf={}L10_kHېlhur% agpC6@zeK+U->mA@XDMM.{=>cH05Zٖm9T{'D%
z~N,;'VY`2;C@ǜUbחթڍFiXPt]4Z|Q@ݟCJⰄcc>ߒ&C#85f[%լUvf?S1|>P|<O}e/f/T<&v$RM=%9l)%G	L9G#}7O
&D%:}¥MhxWYu;X"ۨ<Er
2)je_jXB*g[dTIC
~f}yn@h;EeW$EyVRgYm$m/(rVVkJt7>/lQ#gVCD7N@ߠIM᤺Kt-zW0u-brjvxRR>_hȮ Q`Em8 !ҘFb5XR! RAA
C'q{W=qء
؁:91'KVKEYyꊿBlYOgAfKpTFA^u~YcTIO `[opaFXvC>u,zܷ=GW*svIqO$ ܷ|DmΤ9b7 `swAjL+N{>
[ӐURa&%*[[vs_Qn\R+ vجt4JT3RPv+h߿*tJN% gIt&նM)-)ﴋNr Tk!!'On*P)NR>zl>K_7ZnWl۔$̋%@QXR}aΙ$+r0nX~3Z5UA>ˇ* ZQӿ<8~ICw4֙l6E>IrxOuaa&jDF)>Bv^Exy"xTL+!V3<h[6&#:#S	)]IJo`*$%z|	Htf9EzPa
yQDjRꁰLLZߕ3uyQ{Rr⥽::WH[jkMvo'g4p?m^Z%n'vM3Q}!W%Э%f<7iδ݄>Ց26FP(aTq_+3R Ж+EFm]IVtöIp-{#]Ԯ8?|}rĚBV%9:r7y{rgf`6^7fJ~{?C)2+mP"$-[Nv3}=}O׃G67FBnSzcl	(Qx?#	$gmѳ2=>o$.>ٱxKIXN|>a#FBUj~vجArLWQeκjlPNnUAk1ٯ)qV$r:N*3dB;7$1k$g,ozmC\r|%@zq W:/jԌi}ܓ:_,dradm*:QKb8ΚwMaiDҤed殱тR߯ə)ux͒"2FYV6KbtZR5^OܸYUopփ@bk=:^Jq¿d%6vuv?"G/]\Z'S={V
v' gO&Up"l@
,!E6-r~k5A_Iaau
sZj8q/YPa
eEWڄJ겹F{i~r,[mc/Woj'q<ﺃT5|0%w4:G؛xثD$}
@Y$ɰ_|S#/IVjn;gH9Iޡ{Jϡdp>*^޶ѫ(uS0A'p1a)c%K~ۊ.AkR>2z:Rcֿo{EXmRG7`x,1Fv{FwD(U-`0p8Q
lc9N^À_]&׶g77[Q +J+5r݁P3nCʽQ=\0
,+|"DT#1W4L#l!(HYpnIZ9,RurhY7
k+jz[a趼
P}UdY\ζޞ_[@W
5daeL~j=<3g	=zQ$ƥv;YxHw#rڥ B{^"t
wiU6{:-Lh-#Va03
M}NJjB
jOC˓ݓ_N"W+/y:6'Ex_2F6t+׏ D4-pD7xNQ[nnnmPh85.p&ÚAؒLy#
o&5rggPwV`wj$i}?ʺKL;]vO}47Z42!3%#!Ye3c]X8ܤ[?$1,̾H% 	ʤ
-XG,T4^+Y:M
*o)
 |s܂4ӀGYtY̤7s
,X5r7r*y4BMUY|F%ZQ|*|(6-wCy<|џJ'^ӻ9{WO|5ڔ'~%Ud3._Ş(hz jHq9*vq5lيOPz դ'Ϯ7̢'@HzcǈVswX
韄/9[-eLo x;r66~RDNgV$ qCm>3Nv5E6LpH=u>gk(VwvVY
T	
p[_GHQ{3<[9-0VKZ(@"\O?^tG_cyWw<lh
S&"5[#5Fj(aswnlhGE7r+f%6ރt4KcQ/J(
)Ra}Nzf)4M2+ؿ!]wW^V."2fEnmb PLWi;+BVF	#]Pt/<[K?ip]">)BKN$TA
ԍRM3LAy7vyn@\+Rt	lZV 2 jn(@~PiG<,ɶȦ5kGkPBMX<'nL
i@sb%rss2C0k6Kl1R~{(R&ݼDFb)QN_!G]E:N̨ҭU&h
i;.ˉbawh
!pLcַ?F..,
Yce!>yMD:k|WihO<q4Ez}{a^X~߂p>z,y{ץ[11yNc}Na%<)1$s<PGX%LA'c>.;ҍk|n
tB/_r{7V<Y\Qa5.{qQcW̺H@ϰ=Jan¾{\uZ	&G$`꛲~EjTSOYjQ$) q2=;<G_-.[7@'CVK1vEM	@YuKD	.Q;;E%L:4fWׇgW>R,Eo
78W3Bٻ+jmꆛՋx  Xy>t,{>NsgKhok -6Q=V1ס-h#J{s ;Wà}!GxW_$H]r7Mn^Q>^*\8:;?{yrxv}Ղ?!FUD[t˙	U@4 !xU
!y!=@0&2;RQlhJCK쌊KI?P?Frm(7PxŌhAKYE)n5OJܺu]ڭI
-1ɩ)7`WdP㦟,WEG'AcDw 4S)vC"г֩ga1UȘ%6תߥs8_v%ew,جj?W
قY_L~`E0 bJnY:|VKEAQ@׊G,{;H `;#ԔGY`׭#z/Hd_
~e/guZuG{e&@;7*hR\ˆ8*IΒ/k=TphmMC`[.y},
002ZuԖOI\GfR3\JIi!{7LĳӜU~sj-.T=܈C,3>H6#-
@ʑ%
˚a ܮ7{-+#jHg}@xpQOl_qWv[=-x4AQ D|eo]}{ӺyeiB/IQ]Q̟G`(EӃՒ]~ɎHP>)5ȚtXry'Mb |Z wVߦWX48_J&ԗ<+%
PЁ:ee޻9j׀֎_,^Nm\}r~E@O
GN%
yJ<ׯF(X$ "N{1?(;9{;E2DK5atUn^?tFt8%ǌ):Ҟ0(k]խ960mVhZ':jeqw

sn+JikK=F)2PbDD, /!>,BwV&~s9P!
_̶&jB)E1Ip?gqPZst ݍ^b6y{>GvzPDۢ(^PBoFk>.nnEx^d>ΏȯU3\&܋Χ>7s?
]fe5n$xϭm504N/{YEK|9VҋR{~r?o[
Fhq^_ct83d0KtR1^BVsmىL,5fibuQ
B=̥B%bRkW`,O!ۛV[Vh}i
Dn!y6W,MRL6fphSaDL[q  AqN髑]!x:K%IvBԴ;PmacbHGȉa]XgO9f1󖧱6ܖrLb"|T%HMbLX{\i`銺#Zfrc&Ks{Kd7/el0ysmw-?&h?忹
%?*r &݄b(hVIU#T}T!8ȑrjTXjt@[d;I;6dxL!CO+bDr~b|dwamB$n})Z4d3[je56fFǕ f~$wqb
7q\;[GvBm1=>9<y/nU{Pyn!Z<G"rw̩+
Ya5S
fEguWJD NC5Y77Dܯ)$/8LOkUM,to>'QVӵWHjbr7|3@IDT%mU~"='XPsL
/H6wM+ P
m趥)kӪ_C-
B@w>#NVQICZI@`G쁉S1\HƳI$%D62J8]n4	7+!mx݅\IhretkקB~IKOOKJ`4kOk8,|&V:wFGFA^|V3!i>@f"9"|:HdG^w&w7rV&pKHnt5b6lODzt"Y-)PQ_O1hIn+}v_
ALq
C0c䮚.RE"JPϳ=x(vg7b;0ooܳ	YF[.Tg;
]-l3d:~ߩtQςq-]6ʟyZ/Pʌ:U1lEA@Jh_kyqܯzh\@Siق=:j0R8yd,]SYTZ"تH`2u>ywr6Dl^*%
um1cB5>89m(}Ec;Vmg{u
<hf܊ʧf|͠Z0K:p~zUJ
IW5rS,<c83Zf^[uӹp P/|/CxP޴GKVdu"xs
cɋq	4'N?^ޗ
OLF򓭕Pݏ{tqpf_j0X5;}s$5X[;(R}Bэ4H}d.P11"Oi!VbhrEpl^]tX09gMz&5>e(A3=\abq`xp4s[X̂n*قS:~^ُ:Y4FӻVҪYY[`7*v%~ZX	UT=cp+@l_Ң?w(kmgb}6؍  IlT
?#J|@2J &FU﫢^= xFJ
T\!1t[\ʋŁt=b|zL C<~.
krz%͕Ew-{;˭8_;o7; XI^VXʻd>нfgDOt#11|V5Oz%.
9(.;pC|TV(Y(sM؞Qv!zJ%}LKi=.w謻?ݒ －n0z>
{q?r41j/#iM:YkB[²XKȇy9YWV嬈	ѡ6lۍ	v /j>C\AH!K[ Y]f+Y{Z l%=r%&1PI^
]Vjh6b/PiE8	x)jѫAN5i4+$j?l`G;	Z4OeQ^a)a~HWJu},.(-M5X+érw[@61Ԥ>˙T3قu^]+AzüUf I-#eOQAʀ 3#
%mk A neS3DaǽWM|	=tC,fc{/9\RkR6|rlK
.v|=ߗ&y7|_`|nǼJ%hr=k@zgln*:
~T}ai]EOQ`JTo|c܁߃b}~MofIs^q,f@of\xOpџ"I? [P##_¸2ꍇ.,߼EȠ	N͠/􅢜y
( C
ih,EG}	7\TfĶEjWTXb=(k.KA!oPVl6F,WLe6f
9Dh+ϡKtt;$ھ-C$;&Gq;GiT+KXfGmŅ
;4N  O֛be^'wV
AsŚa9ʿ5F"- 
webs: *G@# mكqVT)L
|6jHwV`O8s6%QSCA)
81-@.̖Dyc5(2؟^Um>^<o`4ev!Ma˾ smȻ:76)>Z/ ={/~.n/$]$CUsi?C}/Ja/t
7siy[iz^DlkPD
5Lٵº?;IދtO-sFG MB$Zů|>	K; N ʢS+>qrE-.q YKb(٣t1r`
+i
-Ā;3~B|hn3ah?*	C{SdR	 o
S5f-~Sޤ~:3i풓07/ ]t @DXbgZ Z\"B5IL#H
o{vRL޴_>ԪaU0s.%>X1}$W6
q;ȋYZ==|Kş@?埋MLqR-^tyxpss%໱诅zb-%;-D}~^SoOW"^t9
4~	*FD=~XxGiJ7G͘%0;oj$Ettqb*-~]FXnV.V%-hDE/4HR+-iʮ"mgQDx~ttN4-K:\bHH4]]aHI֥*0F3X9J趦?zLw=j@)G?'ʫ	
oڐrC_ACi\
Ґtvߚd%5N"zugvҲԕODQ6i-L(s#R<N@􌮓N~I[UQH{
Į'J3Zй$NQ&leM*u[4r<̏?'zhf 95S<1ݖ#zdƤ@hJL57M

ɃDUxDBP}!$e4w#8JVUh|ɺiyA	2x n$TV!LF\%jg_vnvvIA.	@X+3_FYV3q@4=1vM>֍*
MQPww=#D卻4{OgsT1[]MB5x^<RyIcV\rD&ޢJϋhD2SY<ợyr%vU|vb+~C#e[n?Y_HRcE\(~e=,{H'ry/Пa;AysbA>Bw(i;wR',֣Z[R¿~!v[Bfn,"@X/C:L*T@:]R,&糧BŒ1?c3iQHt0FV1*byW} $OX}mV75u#6hv*t2-{F>@.K?R) 2c.JP:jeΕ4} RҺpPq&JAXQPٗ#;dZ6rU _mnn{?/*
%UyI?+rHƖOWv
#K1Z^N:7ưx;c1On]wSUbU[qԐHr9غz*]TE)x}O(m1@Ӫ᭹+	2{` Aaŏdq]Зlf(w`/['WS%f<MݛWzho
pʾ&
jVy'6#rƜzMaiK+]So6X<" w7Ts;AZc)Aܦ^3\=$A*aTxryZggnw)/%$gPD顶d}:rx}}yiQ:tƤ-Ȼ6{\Rn*ZQ'
XP!?mJ""=8Wy {2D-1H\8#8
!EjlV+tZ}8	k-?.ZM%%/7Uf\̫fE'E"	^}om	V=RV<"J$qlxsQL#jtgO5$ :Y쑋5~IS
^yK<	9)*|*v]P6n''1
EM
ilrZz4Pt\!ʵpQ\+J! .#73 HY 6g)>!2[ָ#^\o.(2E9yˏqE'	ei~gKcX	Zf2X@*!a-?[}&OS8{.(;|ۛ/,Bs,r4OQ6&Í
({a1J~*7[`]KI@11oʢbW矏xإGa
ؾ;pɐ7Pڈ|1~OdWEAv[t~:AmgL:a`Nu,m/-( #.	4-QxVܛͽfɍb/M)qYLY-&CyM }
Q(U9bK
(29b;HxXbL*>Z9lݒq$"TyAr1QINFpU7t|3/(%.&
?ۄ6Q֡Cv{{ eQl&/+4v[??kv=+Bt|VjmGu2p	O.Ǯ3K=}XmŌPg;l-搐~\)W+Ns\$=&a×bFqlEiI	΋QNEOI3Ir [c)LL8yXve;DCos%.IJ?x;?۝ʯ0Oxe% H7xrYOv"5_6Oąe0T~{kڋd9;AP"S+Xn)UV,n@ljT<qi?(Cz =-fs4.ew:)`rCwJQ%2|{<Ҧ	E־T!,ukBwYvT7.h3$88v	P<*B}-ݯ5{3}I#F8h7fCri'N^9G/SEcZ$3ul
3vqwܝxd߷plE%vb>DW
])J[JP8
,v6v2{(3x{p:W :-Qx2ebҝQZ7^~,4rIiFVb}JFa8U
?M b B
ypڄrvԽ%*jvWJ&[}m(|\o'oQ*}{Բ.Qg7f`K3$1R16_IDXw:^`f'J:"dwg{)I醗3QC2}*{Ӫ3D}0byĢy$?fRj[Ù{SOZnǋzD=5'6,Ƀ.hVrS-JJm,Q&>yuh7'ѻм(@\,'+oqDBQ;X{ ZFѸk
e[%	cFt/y\7̨m@r٫(a9ӳɻ/T(ʂpRnD;qe9Iڔ|%V]sY]n(rЭJN@k>}LZU-VJh5o.I][,4膘͓
ɛh z瀛/X>vny[+lxZLܵP7גhuS3=3
تz:IA
x!t
Yv7;乁x4^ABV*%euM9{N1CpF5GsAF7s	ml{nSLhbf?Qlt#(I%E9q8l%^E3Z)g`
?0rx,GO"X2}5\MLT'բ,+wّSA¸pΨ3 +d8LcmŅ8Q|6S XrDw?^.
=MQdpoَVQ@>ld%-|*`s<%{4ioS}<ww7V =aE[]aK*yxK_.R':!MjuVڪ[{nbȎ9;3ڝ;B
݈(!;|r4`J)q\t51l_ފ!gqBF.ZӸɓ-jCi8ob^OQ.zkK
r3z.Ypw71&&e{AI(7w	rĬ&V{ݪ~1ʃP>ʻy($WF6,AڋFw(ѬP|PRm\6j'pKEw&\0;1i.	[  ve}r	^|"[9Z/K)JJ^0҂K)I7:[X>{&Ґ{m캠i%*
K"/i96Q=%YvPP+ʮ.ϏOk3O Q#*Bt|Œn<t'DxrECQ2)1`SWs)9/NNn͉(O Aie֣,wn1h\DLa0O1&Ʊ+IiywIqw48  {D
Dލ)?AoG.RO %n$+u]gXC5UY}<tQ{#ڊzறZoawh U
hW7^yZxE$U6JCJ=*H\ZnAMoR-ޤC(fAݔ{tQmHȂDf>W5%YU!2|$:gOEӷZ& ȘXRY>Sz\p}(2h*]iAYc직^s5K6(Lb [t`^@ʉN-)#\8Bkbr%K<tG2j˟NZ3"k.E+M]8sKxϺMGk}zGYnG&kB/ùS!KuXR6suiH@4]y(GW`ƠlJVöGh{yvH(U*2#46|3rtCeZVBq[#Zgx/7V~IAkqh{5]^[dj_\)Je8gOlZ^ͅ|8X7sr@T"P.+(ޖ\\@ٹ[ANV/<C ʭmD R[xKdF-M-s-޶uQ٤Bk?hIh'o1n;qY>ts}qTVۣ	[ӷBmYD8lɑ%/Hi°}wpb_CJ`<TBc]1mh|p?㭯ˠ˚U&mhRzKʰP=NJwɰtu[c
f&=
&;^KVP!Tb[H-Ac9-y͇>xPҕH[[P;!sD[`|ՏlVo: 5aT.1FiL2'TvM5^ q594z,ʻ(w8-XޕRiȰ/~н<wq8:ngMhb<іݷEW!>~{,N*;f*<$hR#nݡZ7Mtn|
ϯ63P^..lbC>~8:z8"BDj:&GjYkb'~6З<vlˏU=Jܾ;
 TEj
	rc6*~iFϱ?tҽ<X)SYj6UnߺYLV.HfH"MKZXm+ZKgEvBϩm!%IJQ[#S!Í]SgB_06% 	T 5Q:HJ: #, &|X!cnM[+<P.iBj-Ka+"^~I#oo͍W3-4ѶTb[qO>#[R
"+W8ѭⲶ`v;Y*}-|231_ךjuF5HnYƭvǤz:WXPȷ?(괦}L2"+ZlZUotzޢ^*;33 db$@f'EPĨ:ʭ|qloa|N$)L)S	?{^!Qtx]1V*sA.Nzʾ<Mn]ɟJLAr5w1}sy7^[MPK#Lk  +ʇjVR_<`hHu~DA4Z9fe(Q)[o=8C;TlXv=/O[]'f^O&mx"S\+~;GiK
lUS׽deOgV5q@}uxs
;{]^-3rd'	?eƁ]ni{m`ҕ7yi-?HBzg\7#Xl47`lڄvYQJHsZ**!3|/ʲS@qt%+˟fm,';DǕf~;$̹]HxQ]y%^/nmSp+/PqWL.@uWup(qZ8d!a_2sT3y_?9;5wv߻:T!@i-?Dʽ`_WD|Z^7ϐ׷ٖOy >܄˓}MHϔgzM$t3PJ]<]<_'gw/OOGO~<Ay/{jff$PO[l? ?хjGp'ԠWw;\E_F".R_EH\|Y$#택t/zif7wK=
*RT*C0ǁ@QbԽxw070uk
ns}hV(y[A
k; ̩$h#hM>iђy?~/VHc5Ū=U/jI^րo{!aMI_
bNǉז?,fVϑң,NK#
̓Pws}%1z|RqzɂF:`$<dg^<F쐜
j.C[r63d7[,F77:T0|#vPpݩ\Her$wv[{a^K7BNϠSd{q7_ "6+3T%'iEGQ.iiPE)ɽ6R6b#\CEŤZըPg
DHnPh7[ɜB]wPUX:6Kcȶ$ (8MP/ GeĿK \RA7ࠞN.~B3ߺYgpu.[suA?z&Y69.\ꈵ͝#NFk
Gz*xf-J!UT^F_g+rk1Dm\qw#kYEh7v!w	2o,4,k
]@nD^,T(ێ/{{#4Y_z:!Ђ+-l{K
}ȓjS;-mlфvC	Ze߽q;ykVcC	Ƿ%s{Bac>@XQaCUZȕH5-4QM?,FevaYy{EyIlhӗTe&Oz[0+-`}ȟ3E7/1J=d,D9̿dx`~z,4f-6	;1^Z!_GĪHbK`&ѾOtk@BYG2eUǇXr$VB.qgZtN2nnpe]]"ώVC'!w"ZsUjU65;G35h5(hERh$g@xdr>eӤ
Y=]Z]U=]*'-+	kw!{|{8#~
BN\7.x-rm_yS傴aCH*&4Uƻjx
u("'8=6|;qOP?
.$O	_@(&|t@ھҥD QC[ض7;M70|?kfKG 0|rfqvǻ3 G Mnݺuo*;;sI-fj]obh.N1XIM{^EeFkY1v,>bvw[
Œ[ hk(#xITrAk%	0w:N+=|;@+]-v`Òp?os~ĕ6Uv"H-o ӗ+/TDr8@:P1f}7T右%4 e%K-*캨0ގQS.(EL ȿ "7莥wѪ<diR?X9!Eew|HHv0_L<=%R?1ě\'4~ݗTx|Uwfg,}{ P$a oUT;%ʧ@cXH!q`'zR$^Ss{BhTh߇~3Mf3So#0+t4!) 6+Qz!½#䝟J뎺oێgu-KkCvϑ+?^׺҉'Nm C\'R[1"*@,7{tsQU݊ި[&瓫<yH{<ڵȔNɒzOCΩ'zF
rjJIPC!;#ъUSZal|`\E҃_../Ob+;7 {!4@M^@Ddeˣ-0^O$z/F4e=0	bM=K).fD<jf>!O~EՌb֫GIÖ=D+SˁG藃곒=~\m{xN=j[12Evc	F\\B
7pֶ-|6Rۏ!cTa(̬hvvwnPB0@䠵MtBGMgjN&0B(8Z#ӽffn#~K#1HdNY~WCE틟/?k lړbx>A\t@X /gyF.k.Rp՜v-11v19ۮuo(
,~cndn7r[.OAz 7ռRNWG$SLȤ=gцxYzB
kt-3r*(ખd[a5@U5*kdQCtҺF`o(d9PaZ.h}rᆨ'|x)Exz%.05\HQ[N:+W]h6}G[v+QV<(5Kl$| oa(]Cac9u{ Np9ӼC؈I{g[8ګ( w:$UO(zz82|ȪM
duzu}~ԯ^//                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             