Servlet传统配置方式和Servlet3.0使用注解的方式

一、Servlet的传统配置方式

　　在JavaWeb开发中， 每次编写一个Servlet都需要在web.xml文件中进行配置，如下所示：

<servlet>
    <servlet-name>ActionServlet</servlet-name>
    <servlet-class>com.web.controller.ActionServlet</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>ActionServlet</servlet-name>
    <url-pattern>/servlet/ActionServlet</url-pattern>
</servlet-mapping>

发一个Servlet，都要在web.xml中配置Servlet才能够使用，这实在是很头疼的事情，所以Servlet3.0之后提供了注解(annotation)，使得不再需要在web.xml文件中进行Servlet的部署描述，简化开发流程。本文所讲的基于注解方式配置Servlet不是针对Servlet3.0的，而是基于Servlet2.5的，通过开发自定义注解和注解处理器来模拟实现类似于Servlet3.0的注解方式配置Servlet。

二、基于注解的方式配置Servlet

　　JDK1. 5版本之后， JAVA提供了一种叫做Annotation的新数据类型，中文译为注解或标注，它的出现为铺天盖地的XML配置文件提供了一个完美的解决方案，让 JAVA EE开发更加方便快速，也更加干净了。不过Servlet2.5默认情况下是不支持注解方式的配置的，但是我们可以开发自定义注解，然后将注解标注到Servlet上，再针对我们自定义的注解写一个注解处理器.

原理：
　　首先，浏览器发出请求后，经过过滤器。过滤器执行初始init方法。工具类扫描配置文件中指定的包。扫描工具把指定包下的所有类的字节码文件存放到Set集合中，然后遍历set集合，如果set集合中的元素（包中的各个类的字节码文件）用的是WebServlet.class这个注解类型编写开发的，那么就获取当前set元素的在注解中定义的value值（URI地址），这个value值在注解接口WebServlet中定义的是Servlet的访问URI。因此过滤器的初始化init()方法就把"指定包下的所有使用WebServlet注解开发的普通类的字节码文件"作为值value,使用注解中的String
value()定义了Servlet访问的URI 作为键key， 存放到 Map<String, Class<?>>
classMap 这个Map集合中。map集合存放到全局对象ServeltContext中。然后在过滤器的doFilter方法中，在ServeltContext中获取到这个map。过滤器如果执行了，那么肯定是用户发出request请求了。先通过request对象获取用户的URI,在map集合中找到此使用注解的java普通类，反射创建此java类的对象。如果没有指定调用哪个方法，那么就根据用户的请求方式get还是post，调用相对应的方法。如果指定了方法，先根据URI在map集合中找到对应的字节码文件，创建java普通类的对象。根据地址中"!"后面的方法，反射执行java普通类对象的方法。当然，有了字节码文件，就能获取到java类中的所有方法，当然也能获取到注解中定义的参数值，从而作为参数执行java类的init方法。

具体的做法如下：

2.1、开发用于配置Servlet的相关注解

　　1、开发WebServlet注解，用于标注处理请求的Servlet类

package com.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 自定义WebServlet注解，模拟Servlet3.0的WebServlet注解
 * @Target 注解的属性值表明了 @WebServlet注解只能用于类或接口定义声明的前面，
 * @WebServlet注解有一个必填的属性 value 。
 * 调用方式为： @WebServlet(value="/xxxx") ，
 * 因语法规定如果属性名为 value 且只填 value属性值时，可以省略 value属性名，即也可以写作：@WebServlet("/xxxx")
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface WebServlet {
    //Servlet的访问URL
    String value();
    //Servlet的访问URL
    String[] urlPatterns() default {""};
    //Servlet的描述
    String description() default "";
    //Servlet的显示名称
    String displayName() default "";
    //Servlet的名称
    String name() default "";
    //Servlet的init参数
    WebInitParam[] initParams() default {};
}

将Servlet在web.xml中的配置信息使用WebServlet注解来表示，使用注解后，只需要在相应Servlet 类的前面使用类似@WebServlet("/servlet/LoginServlet") 注解就可以达到和上述 web.xml 文件中配置信息一样的目的。注解@WebServlet中的属性值"/servlet/LoginServlet"表示了web.xml 配置文件中 <servlet-mapping> 元素的子元素 <url-pattern> 里的值。通过这样的注解能简化在 XML 文件中配置 Servlet 信息，整个配置文件将会非常简洁干净，开发人员的工作也将大大减少。

　　2、开发WebInitParam注解，用于配置Servlet初始化时使用的参数

package com.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
* @ClassName: WebInitParam
* @Description: 定义Servlet的初始化参数注解
* @author: hdb
* @date: 2017-10-1 下午3:25:53
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface WebInitParam {
    //参数名
    String paramName() default "";
    //参数的值
    String paramValue() default "";
}

2.2、编写处理注解的处理器

　　上面简要地介绍了注解的定义声明与使用方式，注解在后台需要一个处理器才能起作用，所以还得针对上面的注解编写处理器，在这里我们使用Filter作为注解的处理器，编写一个AnnotationHandleFilter，代码如下：

package com.web.filter;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.annotation.WebInitParam;
import com.annotation.WebServlet;
import com.util.ScanClassUtil;

/**
* @ClassName: AnnotationHandleFilter
* @Description: 使用Filter作为注解的处理器
* @author: hdb
* @date: 2017-11-12 下午10:15:19
*
*/
public class AnnotationHandleFilter implements Filter {

    private ServletContext servletContext = null;

    /* 过滤器初始化时扫描指定的包下面使用了WebServlet注解的那些类
     * @see javax.servlet.Filter#init(javax.servlet.FilterConfig)
     */
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("---AnnotationHandleFilter过滤器初始化开始---");
        servletContext = filterConfig.getServletContext();
        Map<String, Class<?>> classMap = new HashMap<String, Class<?>>();
        //获取web.xml中配置的要扫描的包
        String basePackage = filterConfig.getInitParameter("basePackage");
        //如果配置了多个包，例如：<param-value>com.web.controller,com.web.UI</param-value>
        if (basePackage.indexOf(",")>0) {
            //按逗号进行分隔
            String[] packageNameArr = basePackage.split(",");
            for (String packageName : packageNameArr) {
                addServletClassToServletContext(packageName,classMap);
            }
        }else {
            addServletClassToServletContext(basePackage,classMap);
        }
        System.out.println("----AnnotationHandleFilter过滤器初始化结束---");
    }

    /**
    * @Method: addServletClassToServletContext
    * @Description:添加ServletClass到ServletContext中
    * @Anthor:hdb
    *
    * @param packageName
    * @param classMap
    */
    private void addServletClassToServletContext(String packageName,Map<String, Class<?>> classMap){
        Set<Class<?>> setClasses =  ScanClassUtil.getClasses(packageName);
        for (Class<?> clazz :setClasses) {
            if (clazz.isAnnotationPresent(WebServlet.class)) {
                //获取WebServlet这个Annotation的实例
                WebServlet annotationInstance = clazz.getAnnotation(WebServlet.class);
                //获取Annotation的实例的value属性的值
                String annotationAttrValue = annotationInstance.value();
                if (!annotationAttrValue.equals("")) {
                    classMap.put(annotationAttrValue, clazz);
                }
                //获取Annotation的实例的urlPatterns属性的值
                String[] urlPatterns = annotationInstance.urlPatterns();
                for (String urlPattern : urlPatterns) {
                    classMap.put(urlPattern, clazz);
                }
                servletContext.setAttribute("servletClassMap", classMap);
                System.out.println("annotationAttrValue："+annotationAttrValue);
                String targetClassName = annotationAttrValue.substring(annotationAttrValue.lastIndexOf("/")+1);
                System.out.println("targetClassName："+targetClassName);
                System.out.println(clazz);
            }
        }
    }

    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        System.out.println("---进入注解处理过滤器---");
        //将ServletRequest强制转换成HttpServletRequest
        HttpServletRequest req = (HttpServletRequest)request;
        HttpServletResponse res = (HttpServletResponse)response;
        Map<String, Class<?>> classMap = (Map<String, Class<?>>) servletContext.getAttribute("servletClassMap");
        //获取contextPath
        String contextPath = req.getContextPath();
        //获取用户请求的URI资源
        String uri = req.getRequestURI();
        //如果没有指明要调用Servlet类中的哪个方法
        if (uri.indexOf("!")==-1) {
            //获取用户使用的请求方式
            String reqMethod = req.getMethod();
            //获取要请求的servlet路径
            String requestServletName = uri.substring(contextPath.length(),uri.lastIndexOf("."));
            //获取要使用的类
            Class<?> clazz = classMap.get(requestServletName);
            //创建类的实例
            Object obj = null;
            try {
                obj = clazz.newInstance();
            } catch (InstantiationException e1) {
                e1.printStackTrace();
            } catch (IllegalAccessException e1) {
                e1.printStackTrace();
            }
            Method targetMethod = null;
            if (reqMethod.equalsIgnoreCase("get")) {
                try {
                     targetMethod = clazz.getDeclaredMethod("doGet",HttpServletRequest.class,HttpServletResponse.class);
                } catch (SecurityException e) {
                    e.printStackTrace();
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                }
            }else {
                try {
                    targetMethod = clazz.getDeclaredMethod("doPost",HttpServletRequest.class,HttpServletResponse.class);
                } catch (SecurityException e) {
                    e.printStackTrace();
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                }
            }

            try {
                //调用对象的方法进行处理
                targetMethod.invoke(obj,req,res);
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }else {
            //获取要请求的servlet路径
            String requestServletName = uri.substring(contextPath.length(),uri.lastIndexOf("!"));
            //获取要调用的servlet的方法
            String invokeMethodName = uri.substring(uri.lastIndexOf("!")+1,uri.lastIndexOf("."));

            //获取要使用的类
            Class<?> clazz = classMap.get(requestServletName);
            //创建类的实例
            Object obj = null;
            try {
                obj = clazz.newInstance();
            } catch (InstantiationException e1) {
                e1.printStackTrace();
            } catch (IllegalAccessException e1) {
                e1.printStackTrace();
            }
            //获得clazz类定义的所有方法
            Method[] methods = clazz.getDeclaredMethods();
            //获取WebServlet这个Annotation的实例
            WebServlet annotationInstance = clazz.getAnnotation(WebServlet.class);
            //获取注解上配置的初始化参数数组
            WebInitParam[] initParamArr = annotationInstance.initParams();
            Map<String, String> initParamMap = new HashMap<String, String>();
            for (WebInitParam initParam : initParamArr) {
                initParamMap.put(initParam.paramName(), initParam.paramValue());
            }
            //遍历clazz类中的方法
            for (Method method : methods) {
                //该方法的返回类型
                Class<?> retType = method.getReturnType();
                //获得方法名
                String methodName = method.getName();
                //打印方法修饰符
                System.out.print(Modifier.toString(method.getModifiers()));
                System.out.print(" "+retType.getName() + " " + methodName +"(");
                //获得一个方法参数数组（getparameterTypes用于返回一个描述参数类型的Class对象数组）
                Class<?>[] paramTypes = method.getParameterTypes();
                for(int j = 0 ; j < paramTypes.length ; j++){
                     //如果有多个参数，中间则用逗号隔开，否则直接打印参数
                    if (j > 0){
                        System.out.print(",");
                    }
                    System.out.print(paramTypes[j].getName());
                }
                System.out.println(");");
                if (method.getName().equalsIgnoreCase("init")) {
                    try {
                        //调用Servlet的初始化方法
                        method.invoke(obj, initParamMap);
                    } catch (IllegalArgumentException e) {
                        e.printStackTrace();
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    } catch (InvocationTargetException e) {
                        e.printStackTrace();
                    }
                }
            }
            //获取WebServlet这个Annotation的实例
            System.out.println("invokeMethodName："+invokeMethodName);
            try {
                try {
                    //利用反射获取方法实例，方法的签名必须符合：
                    //public void 方法名(HttpServletRequest request, HttpServletResponse response)
                    //例如：public void loginHandle(HttpServletRequest request, HttpServletResponse response)
                    Method targetMethod = clazz.getDeclaredMethod(invokeMethodName,HttpServletRequest.class,HttpServletResponse.class);
                    //调用对象的方法进行处理
                    targetMethod.invoke(obj,req,res);
                } catch (SecurityException e) {
                    e.printStackTrace();
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                } catch (IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    }

    public void destroy() {

    }
}

AnnotationHandleFilter过滤器初始化时扫描指定的包下面使用了WebServlet注解的那些类，然后将类存储到一个Map集合中，再将Map集合存储到servletContext对象中。

　　

　　在web.xml文件中配置AnnotationHandleFilter过滤器和需要扫描的包

<filter>
        <description>注解处理过滤器</description>
        <filter-name>AnnotationHandleFilter</filter-name>
        <filter-class>com.web.filter.AnnotationHandleFilter</filter-class>
        <init-param>
            <description>配置要扫描包及其子包, 如果有多个包,以逗号分隔</description>
            <param-name>basePackage</param-name>
            <param-value>com.web.controller,com.web.UI</param-value>
            <!-- <param-value>com.web.controller</param-value> -->
        </init-param>
    </filter>

    <filter-mapping>
        <filter-name>AnnotationHandleFilter</filter-name>
        <!-- 拦截后缀是.do的请求 -->
        <url-pattern>*.do</url-pattern>
    </filter-mapping>

AnnotationHandleFilter过滤器初始化方法init(FilterConfig filterConfig)使用到了一个用于扫描某个包下面的类的工具类ScanClassUtil，ScanClassUtil的代码如下：

package com.util;

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.net.JarURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.util.Enumeration;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

public class ScanClassUtil {

    /**
     * 从包package中获取所有的Class
     *
     * @param pack
     * @return
     */
    public static Set<Class<?>> getClasses(String pack) {

        // 第一个class类的集合
        Set<Class<?>> classes = new LinkedHashSet<Class<?>>();
        // 是否循环迭代
        boolean recursive = true;
        // 获取包的名字 并进行替换
        String packageName = pack;
        String packageDirName = packageName.replace('.', '/');
        // 定义一个枚举的集合 并进行循环来处理这个目录下的things
        Enumeration<URL> dirs;
        try {
            dirs = Thread.currentThread().getContextClassLoader().getResources(
                    packageDirName);
            // 循环迭代下去
            while (dirs.hasMoreElements()) {
                // 获取下一个元素
                URL url = dirs.nextElement();
                // 得到协议的名称
                String protocol = url.getProtocol();
                // 如果是以文件的形式保存在服务器上
                if ("file".equals(protocol)) {
                    System.err.println("file类型的扫描");
                    // 获取包的物理路径
                    String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
                    // 以文件的方式扫描整个包下的文件 并添加到集合中
                    findAndAddClassesInPackageByFile(packageName, filePath,
                            recursive, classes);
                } else if ("jar".equals(protocol)) {
                    // 如果是jar包文件
                    // 定义一个JarFile
                    System.err.println("jar类型的扫描");
                    JarFile jar;
                    try {
                        // 获取jar
                        jar = ((JarURLConnection) url.openConnection())
                                .getJarFile();
                        // 从此jar包 得到一个枚举类
                        Enumeration<JarEntry> entries = jar.entries();
                        // 同样的进行循环迭代
                        while (entries.hasMoreElements()) {
                            // 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
                            JarEntry entry = entries.nextElement();
                            String name = entry.getName();
                            // 如果是以/开头的
                            if (name.charAt(0) == '/') {
                                // 获取后面的字符串
                                name = name.substring(1);
                            }
                            // 如果前半部分和定义的包名相同
                            if (name.startsWith(packageDirName)) {
                                int idx = name.lastIndexOf('/');
                                // 如果以"/"结尾 是一个包
                                if (idx != -1) {
                                    // 获取包名 把"/"替换成"."
                                    packageName = name.substring(0, idx)
                                            .replace('/', '.');
                                }
                                // 如果可以迭代下去 并且是一个包
                                if ((idx != -1) || recursive) {
                                    // 如果是一个.class文件 而且不是目录
                                    if (name.endsWith(".class")
                                            && !entry.isDirectory()) {
                                        // 去掉后面的".class" 获取真正的类名
                                        String className = name.substring(
                                                packageName.length() + 1, name
                                                        .length() - 6);
                                        try {
                                            // 添加到classes
                                            classes.add(Class
                                                    .forName(packageName + '.'
                                                            + className));
                                        } catch (ClassNotFoundException e) {
                                            // log
                                            // .error("添加用户自定义视图类错误 找不到此类的.class文件");
                                            e.printStackTrace();
                                        }
                                    }
                                }
                            }
                        }
                    } catch (IOException e) {
                        // log.error("在扫描用户定义视图时从jar包获取文件出错");
                        e.printStackTrace();
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return classes;
    }

    /**
     * 以文件的形式来获取包下的所有Class
     *
     * @param packageName
     * @param packagePath
     * @param recursive
     * @param classes
     */
    public static void findAndAddClassesInPackageByFile(String packageName,
            String packagePath, final boolean recursive, Set<Class<?>> classes) {
        // 获取此包的目录 建立一个File
        File dir = new File(packagePath);
        // 如果不存在或者 也不是目录就直接返回
        if (!dir.exists() || !dir.isDirectory()) {
            // log.warn("用户定义包名 " + packageName + " 下没有任何文件");
            return;
        }
        // 如果存在 就获取包下的所有文件 包括目录
        File[] dirfiles = dir.listFiles(new FileFilter() {
            // 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
            public boolean accept(File file) {
                return (recursive && file.isDirectory())
                        || (file.getName().endsWith(".class"));
            }
        });
        // 循环所有文件
        for (File file : dirfiles) {
            // 如果是目录 则继续扫描
            if (file.isDirectory()) {
                findAndAddClassesInPackageByFile(packageName + "."
                        + file.getName(), file.getAbsolutePath(), recursive,
                        classes);
            } else {
                // 如果是java类文件 去掉后面的.class 只留下类名
                String className = file.getName().substring(0,
                        file.getName().length() - 6);
                try {
                    // 添加到集合中去
                    //classes.add(Class.forName(packageName + '.' + className));
                     //经过回复同学的提醒，这里用forName有一些不好，会触发static方法，没有使用classLoader的load干净
                    classes.add(Thread.currentThread().getContextClassLoader().loadClass(packageName + '.' + className));
                    } catch (ClassNotFoundException e) {
                    // log.error("添加用户自定义视图类错误 找不到此类的.class文件");
                    e.printStackTrace();
                }
            }
        }
    }
}

经过以上两步，我们的自定义注解和针对注解的处理器都开发好了。

2.3、WebServlet注解简单测试

　　编写一个用于跳转到Login.jsp页面的LoginUIServlet，LoginUIServlet就是一个普通的java类，不是一个真正的Servlet，然后使用WebServlet注解标注LoginUIServlet类，代码如下：

package com.web.UI;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.annotation.WebServlet;

@WebServlet("/servlet/LoginUI")
public class LoginUIServlet {

    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException{
        request.getRequestDispatcher("/Login.jsp").forward(request, response);
    }

    public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        doGet(request, response);
    }
}

在浏览器中输入访问地址：http://gacl-pc:8080/AnnotationConfigServlet/servlet/Login.do，根据web.xml文件的配置，所有后缀名为 .do请求，都会经过AnnotationHandleFilter过滤器的doFilter方法，在doFilter方法的实现代码中，从HttpServletRequest请求对象中得到请求的方式类型(GET/POST)和请求的URI 。如有请求http://gacl-pc:8080/AnnotationConfigServlet/servlet/LoginUI.do，此时请求方法类型为GET， URI 值为/AnnotationConfigServlet/servlet/LoginUI.do。从ServletConext对象中获取到在过滤器中保存的Map结构，根据 URI 获得一个 Key=”/servlet/LoginUI” ，从 Map 结构中根据此Key得到Value ，此时Value就是要请求调用的那个Servlet类，根据Servlet类创建对象实例，再根据前面得到的请求方法类型，能决定调用此Servlet对象实例的 doGet 或 doPost 方法。最终客户端发生的后缀为.do请求，经由AnnotationHandleFilter对请求对象(HttpServletRequest)的分析，从而调用相应某Servlet的doGet或doPost方法，完成了一次客户端请求到服务器响应的过程。

　　使用注解后程序流程如下所示：

　　

　　运行结果如下：

　　aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAv8AAAEKCAIAAAAKLq1CAAAgAElEQVR4nOy8eXAk2Xngh/7TXseu7XWEFHaEpQjxFIeUyOFoOGpJlMzhcDjTHHPYO2PZVCgshdWyl5KWIsVj2dMHGo37PgqoGyjUfd/3XZl13/d93xeqClW4UTX+I7MKQAPdM0NS2l2HK36BKGRl5cvv5UO9X37fK4yZTCaRSEQgEJaWln7+859/6gtfeTGf/sJXPv3SVz790suX+cwXv/qZL778mZde/sxLL3/mixBf/eyXXoH43O/9wf/Pr5tXRt372S+98tkvffWzX/rqZ794iS999bNf/OpnYOArMuKzX/rq1bdf4XNfeuVzv/dCnv/eT8LFGV6c8wtP7CPO8EuvjAJ8Znx++qWXP/3SVz71hS9/6ne//Dswvz988uVP/e6XP/WFL98w1F8a8oVLvHSZ663858BXPn0lkC9/6nfhwK9H+s/Z7if+GPlP2WPDq/zsSX7hhu2jLr3Wmf/5RPTLxPvx+XVH+pWrg2fYvb/7bD+/cNj8ShH9+sfkMwPmv/gx8/8F/u7v/u7Ro0dbW1sUCkUoFI4JhUIsFjs/P/+pL3zlc1/8MmqbdHg6eCEfXuHsw2e3/JfPwb8UveucfCy6Jx92Twbd40H3eLB/PNg/7u8f9/ePbuR8//CCzuH5cDv0xn9BjmA6R4POUb9z2G8f9tuH50P67cN+57DfOep34H0uuHa2Hz5D5/jDzvEA5mjQvoF++7DfOuy3Ds9bB+d7B+ctiMPz1mG/ddhvH/Wfecv107j51eMX8+G/FHCLzwv5ecFeC+GTN3pTV0O0rtJ+Xj/f0PSv0ocfeVEuhspNo+WGk7wcF9ylH92Zv5Zz/kRv/6iDvyje/rNbDq9xtVs6z712LwjqRec2bPe8dRWo6Y/+ixt9tlz5s+1/FDd/XnVPLvPh1efPZfgRPehBOx8Pusf960A7DPkEU8bZ+eCv/69757/uxwZi89d7wK1/+Jtf7wF/lcf3v/WNs/4AvU3+/Be/8umXXv7xj3+8vLy8u7s7trOzMz8//xv/4/+M2SHVumeR6qmrcOIqHF/HXTjxFE89xTNv+dxb7nvLfV+l768MApWBv9IfEahCDALVQRCi9isR+OWo/pL4b6Qy8FcGvpvwPkN54C0PPFdxX8VVukzfOaLYdwyxX6bQt0Hk+9Z835rvW3Ln5sypKXNiTB0DySND/EAX62oj+5pIRxPZ10T2NdGuOryvCrWVwZYi0FQEmnJ/U+5vyvxNRaCtDHfV0UNt4kSXPNGlTvUXnOlTZ7r0kNSZ9iY0w58wiTNN4kyTPFMnzzTJ88uok2fq5Jk6capKnKriJ8rYiTJ6rIgcycIHksC+yN8SeJoCT1Po3RP6WiJfW+zflwZ78vCRPHqiiJ0oY6fK+KkycaZKnKsS56rkuSrZV0OkLgFtSfRViXNl/FwZP5PHz+SxM3n0VBo9lUaORaEjYeBA4O/yPG2Os8mw12mWCs1SYdjrLOce293hert8/4EweCQOn4gjp5ILzq5yKomcii8heQ7wS9EzSfRMGj2Xxs6lsb4s1pfFf33E+rJYXxo7l0bPpdEzSRQ+Q3H4RBQ8EgYO+L4uz9Nhu/aY9jrdWqFbq1C8nCvxXosRPucz+JhXkUbh5i52iJyKwydQo4LAAd/X5Xo6HHeb7WqxnXssR5PpaLIcTZZzj+XcY7taXE+H5+sJAofC4JEodDzs8LMbuxq+BB/Zjc90xZW3P8OVV8VQd4WOhcFDYeBA4O/xfV2ed5/r3ef5unz/gTBwKAweCS5e6nDcbbZzj+loMB0NtqvFuRbODSNn1IEv6OcbzvnZ3Yadf+0SRG9q6xkil4ZH6FgUPBIGDi/i9XR43n2et8v3dfm+HrQFuogcV4vjbnPcbY6nwxsOG1H4RBw+EYevRnpDc3BQUpgzaQQ+bVn0TBY9l8XOpbEzafRUEjkRh4+EgZ7A2+G6mmxHne2os+wNpr3BtDc4rhbfuy8KHEjCx9LIiSxyIoueymNn8tipLHYqi57IoifS8JEkdCgOHIgCXXGgKwp0Rf6uyL8v9HVEvo7Q1xZ6W0LvntCzJ/C0BN49ka8t9nckgY40uC8L9+SRQ2XsWB0/USdONYlTTfJMmzzTJs90yTNd8lyXOoc+GyEMEOkzIH0+Akyfg+kzMHNmzJyB6TMwfQIkjwyJQ32sp4t1tZGOJtxWh1q6aEcf6wHJQ2P62JQ5NWfPrLlzW74/wp7v2wt9e2HgKAwcRRgnRGnQPBx87y/u7R2cFfZOXkTrBorPodk7m1/Z7B73n7fDJ2Wvd4b4f/6qEYlmBLyMgJcX8goiXkHEK4t4FRGvIuI2RNyGiLsn4rZF3LaIvS9id0Xs3vPpXvt1X8xui9ltMbcl5u6JuQ0xty7mVsTciphXEvMKYl5BzMuLeBkhr+b1/O/f/NPW0SDRHDQOBlgC5Tf+p9+CBGhsfn7+dz7/+2g8MdM4cWQOHNnDIQeOzBWcuSNXHnKgM0/pzFs+95X7/grkB/1ABSZY7Qdr/VBtABGuDcJ1mMgnJPzLUbsg9El4roFVB8GP6UkfqUcXStR/BnfpAtclRm7kKF1YkS1/Zs2cmNNHxmQPSPQMsX1dpKUJNTWhpibU0oTb2khbE26pg01loKHw1eTeqtxTlXmqUk9N7m8oQy1NtKtLHBqSx4bUiSF5YkidXpA+NaRPr2wZcuFJaeiD4FSfPNUlTnTJU13yVJc8u/wZoU+d6VJnuuSpNnGiSZyo48eq2KEqeqCM9BShfam/JfY0hK6KwFkRuqpCV13kbog8TYm/LQt1lZEDZfRIFTtWx0/gD6PUmS51rkv39dfQpfq6VF+bOtckz9SJM1X8VBk7UcRO5NFjWeRYEjoUB3sC3z7f02I7GwxbhWoqkgxZIpCjmIo0S5Vhb7JcLa5nH/5kDx3fxAn0RBg8eh6i61tG0+Fw8r4yc8cuTdsjRtNb7NJkH3veZH8xpcGzWuhYGDwU+Hs87z7X3WY7mwxrFY7XkCUboXgbLFeL49nn+3o3xwvPbdAx4cMOt5yKw6eXXh3Nowd8X5frbrOcTYatRrdUqOYSxVgkg3kSmCeDBbKxSDEWqeYy3VZjOfY47g7P2+X7eoLAwaj3RCGY690ogufaM0n07Eq3XPKekYrBlylwKAwcCoMQVy7TpSsFnzncXa49lqPJsNcZtjrL0WS7WlzPPs8L+VyL7dpjORoMe41urVLNZYq5TLfVmI4m293mers8X4/vP4A06OK0P4qrF+6mwEPHotDF5bjOjWP1ufuMpAfyG1eL5Wwy7HW6rcaw15mOBsvZZDmbTHsDuog0c5lmqdCsVbq1xrDVWc69C9sbRip6QaTXIhKHjiEk4RNJ+EQSPpVEjsXhI1HoUBjo8bxttrPBtFXo5iLNVKSaihRjkWIs0q01trPJ8+4LAwei4KEoeCgJHUlDR5LwkSR8KA4dioMHIn9X4O3w3HtcVwPGWec46xxHjeOosu0Vtq3MspZY1iLTUmRaimxbiWOv8Jw1vrsh9LbE/n1pqCuPHCgih9AnD4QaIn6sjh9rYkcw8SNt/EibONYN0SeO9ckTQxL6eWJInugTh7rYgS66r4l01KGWKtBU+Otyb00ZbGrCbV2sa0gcgqkjY/rYnDm15M4grLkza+7Mlju3XXagwoUDfVz7eY4A3ehA/xz2s3Hv/2yEwhkOEyLHYRa4zAKXXubSK1x6jUtv8OgNHr3Fo7d59DaPvv8JafPobT69zae3+PQGn17n02s8eoVHL/HoBR49z2XmuMwMl5nhMitO5/vf+NPWETxHFzoD7A4ZygCN/eAHP/jsF36v0j62JjvWZMea3Lcm94fPL2/Zt6d7jsyhM3fsKpx4iqfe0pmv0vdXB1CyJ1jpB6v9ULUfqvXD9f7IdaINmNgnJPrLUb/gk8rWDdRgwtf4mPL0TC4KMsVn8FUu8I54xo0u6ZGr2HfkT23ZY3OqZ0rug7GWIdLShRoaf00TqGlDDW2oqY+0dOE9TbCu8ldVvrLSW1J4SjJ3SeYuKbxVVaChjXQMiR6QPIQAk0dg8gi4iuESl7YcA8ljIHUMJI8NySN94kifONQnjvTJY0PyGEidXMaQPNYnj/WJI138UBs70MZ6mmhPE+mqQi25vyF1V4SOotBREDqKQmdJ6CyL3TWZtyEPtFThfVWkp4keaOOHusSxPnmsT50a0mdgpg9m+2C2b7wEkOkDmb4hfQ6Zljp+rIoeKaKH8vChLHwgCfRE/o7A0+K6mix7lWYqEPWZbXVsRx0n6NIksEAxV+i2OtO5x3F3+L4e33/A9/f4vh7fB98K8/09Abyxy/N2ud59rqfD9e5Dt8swvi7PBz3f53r3oVmT7+8JAoei0PFw5r552n7O3f9NCY/LtgRN9qMpLXAAnSQ8W7v22I4Gw1qlGAtEfXpbHcer4wRdmgjkKeYyzVZnQgri6z4vXoH/4OIlaMtozgscCgKHgsCl5q6a1q4utaNJ4FUxrCKCkYexighOGcOp4tuaJNGQo5hKdGuN6WiynS2Ou831QD15AdzDng6ckxiJBdSTV7vloivCx6P8E8/T4brbXChp4e5w4KNda2hoAEx7nWGtUs1lsrFABHJEQ45sLNIsFYa9wXQMbcBaoVnKFFORDOaJhuwutI+1ynQ02a4W293muDtXBobvAqhvr27p8f09PtTPvh5vmIPhevZhRsmY4eUQBCDgay24dOFGg3B0WP7o8kH44D0vhVyjWyoUU5EE5HYNWRKQI4MFiqlIMZXIYIFkyO7q0wRtalef3jVkiUCeBBaplgrD3mC7WlwoPXYpUnjkDFu5+rdwufO7fF9P4O8J/QfCwKEISrkFegJ/l+/tsJ0NhrVMM+bJhgxJn97VpQnaFEGXJoMFuqXKdjZ5ng7P2+F794W+faGvK/TvC3z7Am+H72lzXE22vcqwlmjmPN2Up5kKNGOeasxTwSwVSFMMKbIuQdYliNr4riZGVMfIugTVkKYbc0xzgW0r85x1oWdP7O9IAvvS4L4s2JWHuvJQTx7uyUNdeairCHXlwX15sCMPdhTBjiK0rwh1leGuKtJVRXvqaE8zRBvraWM9TaSrDnfUobYyuKfw12WeqsRVFjsLMm9V4W+oQy1dtGuI94DEoTF1ZEqfmNInpsyJOXNqzp5CGmTLn19PAjUPPrb9fOwkULN3NrO08eu1n7W//n4tEEzQyAkaOU0jZ2jkHIOcZ5ALDHKZQa4wSTUmqcEkNZikFovUZpHaLOL+82mziJ2rv7ZZpBaLtMciNVikOotUYZEqLFKZSS4wyXkmOUcnZ+jkNJ2coJMrVut7f/ZHI/vxVweNg8Hnv/iVu3fvjv3mb/7mFpbgzXZMsb0bMQ+xJDq2VNeeOXDljt3FE0/p1F8+v+w94Wo/XOtH6v1ovQ/pTrwxiDcHiSHJj03iVyb+SYjdyMc3s49MXF1oUz9c64cuERwSuEz1AliSKn1/pQ8VHL2lc1fhxJE9tKW65njbGG0C4bo+VNUGytpARR+qGcINILpnCDf1oZouUNH6yxpfSektKtwFuaug9JY1gZo+sgfG98FEF0x0wcQ+GB/RhQDiXSDWBWJdECLeA+I9MNEDEz0w2TMmD8BkD0z0DLGuPtY1xLpAvAcmDsDkkRHmEEwegskDINEzxHv6WFcf29fH9vWxjj7a0Yb2VIGa3FOWOHNie1bsyIntebGjIHWW5N6qwl9Xh/Y04Y42uq+PdfXxHpA4BFPHxsypOXtmzp1bcn3LqAiY75tz56bsuTFzCiRP9PFDTbSninSV4a48uC8NdMS+ttCzx3c3uM4a01qiAFmCNo6Th7DyMF4V29Gmd4E82VSmWavQJztcsnE2mY4Gy9FkOZts1x60HdoI5QYY9jrT3mA6GsyL4k6T5bjYAaqMcL37o2KBJALnLaTPGMy1G/Rnsx2jvNFwspdGz+Bik/+AP5xgrtSb7HWGrUozl0iGzLY6jpGF0LIgThXb0aZ2gTzZVKJaqgx7g+3c41yKdxjyHhyyc4/l3GM5oS2wqXA9cFmE44bags2AaioSDdkdTQKnCKMlgS2RF8F3rXPtaxz7OtexwXchBO4tsR8jj0AORDYWqeYyzVKh22oMWx3GXmfYagxbjW6tQjDsdUgvOJ59nq8nCB6JwydXamFQV4TgYh/X3WY54PwT7RJ0OIFxBbq1SjOXKcYCGcwRDRmCNjk0tghendjVZ8jGIsVcppiKFGOBDOZJQJaozxB0qW1Nclub3IXTaRX66Pxt18cGXL4ZUmfY6wz7pa6Gr1eDYatfPT3oIHDnXylCXRqll9472h+uM0IHH17EPZZzb9QzVHORDOZ39eltTQKriGDkIawiglfFtzXJHW1qWx3HKaMYeQgtC2LkYawyilfFtzUpSPjo1ioUC/yHYKsz7cOmHc3LIUM70G01KHUEp5ccTWjUcd1tWFJdLY57j+1sMKwVqjFP1Kd2NPEddQyvjOIUEawiuqNNkYA8zVJh2esse4Nlb7AcDZajwXbUWfYay15l2io0U4ECZIi6BEET21HHCOrojiq6o4psK0N4eRAn82OlXqzEgxa5UEIXSuDESLx4eXBHFSZq4xQgzTDl2bYSz1njueoCV13gbgg9DaGnIXTXhW74icBVE7qqAmdV4KoK3TWRuy72NCTehtTXkPqaMv+ezL8n97fk/pYi2FIE9uT+htzfkPvqUndF7CwK7Xm+NSNyFKSeitzfUAVbmnBHF+sa4j3o5nP04WlKH1uyp9bcGVwLuyRAkP00uqeZxtFlsp+Q3CXq+ydTC+vtg9Pc1e25xtHSBuHu+/dewBKCkGsePUN9/2TtL9+reLyRXVxsF5fYxSWIuDQRlyHiciRcgYQrkHAVEq5CwtVJuAYJu0fCtkjYNgnbJmE3fnZ/dPCNn92/cUubhN0jYRskbIOEq5FwFTKuTMYVyLgCGZcj4zIkXIqES5BwCSIuRsQVjMa7f/LaZfuJNwfobfLLL7889tuf/WKtfWQM18BQDQhVL1EDQzUwPKJuiu2ZE21bquvIHrryR57iia90FqgO1afWj9T60Xo/1ujHGv34SHf2Bqm9QWpvkG59LFK/NHu/JMkbeb6EfVKXujFHdbMnvbAkF6gOApV+oHLuL595C8fOTM+WaltiTVO0BoZrQLCiC5QMgQoQrhmjTXOsZYrugZE6EKrqAxWdv6TxFtWegtKdV3uLukAViDSN8Y4x3jbG28ZYC4zugdE9INq8iT0g2oIAY20w3jHGO8b4PhjvgLE2EG0ZInuGSAuIto3xjjHRNSV6xkTXmOgaE/vGeAeMd4Bo2xBtGYYHAaJtfbipCVSV3qLckZXZM1J7RmrPSh1ZuTOv8JRUvoomWNeFmrrwnj7aMkQ7QLxrTB5YMsfW3Kktf2bPnzsKfUdx4Cj2HYVze/7MmjuzZI7B5KEh1tOE26pQSxFsyfx7El9T5GkI3XW+s8a1V5mWIsWQ3lFHMVIfWuLHKMJ4VXxbl9415EhgkWouQzMuzVymmEpkY4FsLFBMJWiSpsHVnALpUjWHbCxSTCWKqUQ1l6jmEtUElXsKJDA/TAzscTz7PP+BIHgkCp8MJ+xRvudUFDq+WIExWnQyzBsJIQ2CamdXhUkUPOL7ulxPm+1sMu115qWZhm6t0i0VmqVMMeZ3dUmcIoIS+5BiH1oWwqni21oo3gLFdBEvFYoXLFCMRYqpSDWXqOYy1VSimEoUY5FiKtEsFbq1Bs3rDFsdbsJcohgLZCBH1Gd2NHBDm3znGtu6zDQt0oA5snaWpJ0j6+epwCLNuMyybPBdSEkAq4hCEy1Bl97VZ4mGy2R29ZldfZqgS+/qM0QgTzYWqZYK3dZguVpcbxdargStFoJ6QxQ8Evh7PA+Uf6pQjAWiPkPQJgna5I42uaNNwQ1BB9RnR+zqMwRtalsTx6uiWEUYLQ1sibwbfNcG34WU+DGK6LY2tavPEvQZgi5F0CZ3NIltdRyviuNUMZwqDr0KpUyg3iMBeRKQIwHQ8ChAG8lgfrg9RwJyRCBHAvIkqBpogsYMtE/uaj9kSUB+NAJHg5BmqdDMZaq5dMnJcsP9c8MrWIKO/AwUUwlOXOlSO5o4VhFGSfwIgXud50AI3FtiH0oaRMtCKIl/S+RFCFwIvnNT6N4S+5CSIFoexqniO7o0CciNBjnUNAnIXfxFgFdCJo6CAnJkME8xFqjGIs1colsqDGuVYasxrFWGtcqwVujWMsWYJ+lTBE0Mrwxj5SG0LIiSBFCSAFYR2dEkSYYc9PdFAQsUY54M5ihgjgxkyUCGZEgTNPFtZRgr86PEHpTYgxJ5UCI3UuTeEjg3+fZNrnWDY15jGVcZ4DLNsEzVrTGNCK4VKXBhJL5tZYiojVGBNMOUZ5jzTHOeZcmzLHmWOc8y55jmHNOUZZoyTDBNB1IMIMkAU0xjhmnKss05jiXPteZ5tgLfXuTbSwJHWegsi5wVkbsiGSJyFgW2HM+S5pqSfGtW5ChI3BWZr6EMNNWhtibS0ce6+lhXH+vp4z1DvAckD4cCdG7L921QBuiS/VQ7x/FyL1H5aJIfg2r7eGJutdU7vf7S3ffvffjCx93376WqvWeodo5X//y7ZYcjhEGEMYgIBhHBIBJYRAKLSGMRGSwij0UUsIgSFlHBbtSwG3XsRgO7DnG5xbvv31v78c+f2TLcc6OG3ahgN8rYjQIWUcAhcjhEBodI4RAJHCKORUSwiAgWEcYi8nrdu6+9ctl+AtVB63Dw6ZdeHvvtz7y0f3gCBMr6QEnvL+n8Rb2/qPeXYAJlfaBsCFYMwQoYqZtje9ZUx57pxbP+qudRTfd2UfF62jYbL+Vh9an3481+otmHpCe9N0i3BpnWINsaZNv/bLQuyHwSPqaQPdfMnmdOQz6ONr1Ykq5mlfqh6nmoehasnPqKR55s15FsWWN1S7RqilTBUBkMlsFw1RStW+N79lTHlmxb401LtG6KVMBQ2RAo6nwFrTev8xUNoaoxUrfEW5Z4yxRtGqN1MFIDw1Xwkv4aQlXD8DkYqgHhOhipg5GGMdo0RfdMsZYx2gQjDSBUN4SqhlAdjDSN0ZYp3jbH26Z4yxRvmWItU2wPjDbBSBOINMBIE4w2jbGWKdYCo01DqKr1FdWurMqVUTqzCmdW4cxCcqb1l3XBqj5UM4TqhnDDEGmCsZY52bWmDxy5Y2f+1FU8cxfPPeW+p9R3F89dhVNH/tSaOTIleoZYWxtqqvx1ha8u9dYknprIVRU6q3xnheeosCwFiiG5owpjJF6U2IuRBbHKCE6d2NamCboMNN+QgNyuPr2jSeJVcbw6vqNJEnRpoiG7a8gSdOkdTRKvjuNV8W11YluT3NGmCTp4nobm7B1taluTwKvjO9oUEcxTLVWmc48DLSoKHUMSA3mPJHwiCh1Ba3Q4rhb7UuqIOVx0woe0KXQsjpxC64EuSjz+HtfdYtrrNHMJWh5BHkIxFqmmItVUJIO5HU0CKw9tiTybQjdSEsDIoXhTBF0GqndcijeGV8Xw6vi2JgFLgya5rUluqxM7muSuLkMEctDB4RlXn7lU4QqjJYFNgXudY1umGxcoutld9eS2/AlWMo4RT+CkT7flUzuqWZJukW5c5dg3hV6UJICSBtHSIEYWwshDGBlEEC0LoqVBlDSAkgTQ0iBWEcWrEwRdhgQWadYay9Xi+XrC4GjRzKk4dAx1BcteG+a6YhhZECn2QWyJfUixHynxQwdEy0JouK0QWhZCSQMoiQ8p8m4KXOtc+wrLskQ3LjFMa1zHpsiHUUTw6gROFcepojhlBKeMYBURrCKCUUQwiiheFd/RJHf1aSghBHUFThnFq2J4VRyvTmyrE3hVHKeM4RTwG7HyCEYewSoiODihkoBGCw7Kc8jDWHkYIw9jZGGMPIxVRPGq2LYavhwEXQoabDvaFOxhyhhOEcXKw1A4UIURD43MZ9CmCNrUjja1rU7gVVGcIoyRBbZEnnWufZlpXqSDKyzLGte+wXdtCj0bfNc6177KtqywzKtsK5y6E3qRkgAGyphqoLiilyqbURwUtSqGU8VwyhhOGYXAKqJYRRSnHPaJJknQpnZ1aaI+Q4KNDSJL1KcImjheGcbKg2hpACX2bQk9m0IPShLAysPb6jgBClwVx6uieGUEr4zglWG8MoxThNAS35bIjeDZ19nmdbZ5Df5pWWWaVujAMlW3RNEsEFVzu/Lpbek0TjJHUCyStSt0YINjQQqcWKlvRxUiaeNEbYykjZI00M8IUR0mqsO7qhBBEdiR+3dk3m2ZhyD3ERT+XWWApA6RNWGKNkLVxWj6GMOQYIJJljHFNmW4lhzflhfYiyJnSWDL8ywZjinJBuMcU4pvzQkdRbGrLPXWFP6GKtDUhFqaUFsTbmvCbW2ko491geShKX1iGa2JLgzsxYF9aD/FZs+fafozzUCmGch+BMGPIl/vPpxarLUPr7/0cewnlGs+Q77RXXj3W3mzybU061ma9S7P+pZngyuzoZWZyMpMbGU6uTqdWp3Ork7nVqeLq9Ol1enS6mRldbKyOrn6H370jO5cfr76H35UWZ0sr06WVqeLq9O51enc6nRmdTq1Op1cnY6vTEdWZkIrM8HlWf/yrG951rM0m1bI3nn5S5ftx18dHJwOPv3Sy2O/9ekv7B+e6HwFrbeg9eY1npzGk9d681pvAcZX1PmLD4XBbyI9nyMV/khU0ET+6cDxBp3w7+7/4n+dffTnmJk7WeditN6PN/qJRj/Z7Kf2BqmhYWTbg1x7kG8P8p1B4YXkfznaF+R+fTwjWJln+IQudTk79ZGSdF2YYEOCSoq1s3DlNFg89Ob2Xak9e6xmjVas0Yo5UjGHK9ZozZ5oOtNtd7brzuw7Uy1HommL1SyRiilcBoNFwF8AAkVTuGKO1myJpjXeMEdrpnAFDBbBYBEMFIFAEfAXDdATmBIQKIHBMhisGMNVU7hmigniLscAACAASURBVNbM0bopWjOGK2CwDASKQKAMhqqmSN0ca5pjTXOsYY7WoX1MkZoxUgPDNWOkZo41LPGmNdGyxJqmcA0IlPTenNaT1XpyGk9O48lpvQWdr2gIlIFgBQhVgFAVDFXBcM0UbVgSbVu668oduQsn3uKpr3wOVQN95TNP8cSVP7ZnDszJDhBpagNVla8s95SlnrLEVRa5KkJnReCsCJwVtrVAM6QIqghG6kWJvWipHy0PY5UxnCqOV8e31Ql4LpeHUdLAlsi7JfKipAGMPIxTxnDKGFYRQctCKEkAJQ2gZSFofsIqYzjYG2J4VRSriKDlIZQ0iFFEdrRpkrFItzfY7g7P1xMGjySRs6HBnIhCx4LAAc/TgVbMQAkY6K56tDKG44YXmYpCcLlHHD4RQeuaPW2mvU41FaGpl6BLE/SZXX121wDnHqimIhnI7WgSGHloS+jeFLi2xD6ULIRRRLEqWOB2NIltKF6Jf0vo2RS6t0RepNgHxYiSBJASP1LsR0kCGHkYp4rtwJWRBF4VwykiWFkILfEjRd5NgXuda19hmhephlmiempHPoGTPEYJHmxyP0BwHm7xHqGE4xjxU7x8ZlezQAVWWJY1jn2NY1/j2te59nWufY1jG2Jd41hX2dZVtnWNa0cI3EhJAC2P4DVJIlCgWWtsd4fnO+DDC0eOhIEDrrvFtNWopgJRl8Irwyixd4NrW2GaIZaZ5mWmZYVlWWVbV9lQE/Z1rmOd51jnOda59jWubY1jW2VblhjGBaphlqybJeuXmOZ1vgspCWAUEYw8jJGHMLIgRhZAy4JoWQgtD2PkEawSspP4tjqOU0YwcNbEhxT7INlCSQJIsW9T6EHwXRs8J8Q6z7nBcyIE7k2hZwvyM5F3U+iBci3wPlzHBs+J4Ls2hZ4t0fBo0gBaGkRLg1BuZlPghg67znVAnbnBc0HHhJpGSQIoiR8l8aOlF9oHvR0l9m0J3etc+zLTNE81zJK0CzRgmWle49o3eM41jn2VZVlmGJfo4DLDuMw0r7Csqxz7Os+JEEAjBEoOuS9OFQpH5N0UeTeF3k2hBwL6I7rSJ9IgWhbEykNYeRiniOCV0W1VbEcd39EkttUxvDKMUwQxsgBK4tsSeTYErg2ec1PgRop9aGkAKwuhJQGU2LsldG/ynVsC15bAtSV0bQldGzzbGtuyzASXaPolmmHEIlW3QNbME5WzBNk0XvIULRhHch8j2E9Qgmm8dG5XuUjRrjLBTa4NLXKPCmRYiRsrdmGETrTQjubbUXwrkmve5JgQLHCDCWyyjVscE5JnQfGtaKEdK3LgJa5tqZsg9xGVAbI6TNFG6IY4y5TmWrMCe4FnzXHMKbYxwQJibGOSa07zbTmBoyhylaXuitxbU/obSn9D6W8qA01VYE8b6ejjPTB1ZM6cWXJn1vy5rdCH7KdxMPjeX9zL1bvuZA3C8zHwjkjdQLa6/+DpQrV1cP2lkXxcr3mNtvtStWfI1vbnv/ONHAg4ZiYcMxOumQnPzIRvbiIwNx6YG4/MjcfmxxPz46mF8czCeH5hvLAwXlgYLw1Z+fsfXreuu+/fW/n7H0I7QPvnF8YzC+OZhfHEwnhifjw2Px6ZHw/Mj/vnx32zE57ZCdfshGN2IiEV3/n9LzxjP4enH47s5xTyHrU7q3Zl1O6M2p1Vu7NqT07jybGA+B2s58uSwV+6BusRw4eJn3wY/s6Pfvj6j5/87Zv/iAlWz8O1czX9b2JD9UnuDVKtQbrleXhr7OIxJd59d+yRcVDolIjvjt1hlmDpiYm/M3bz46FxkO8M8jHxnefscLEn86P3ucMs/XKedFOqqbTz3bG3GaWbU0pQxmtvkN7rQ9gY7419V2Tb66eu0+wnL5G4RnxEox9vnEdrZ5HaaaR6HCweeLMdV6phj1ZskbI1UrZGKpZI2RarORJNV7rtzfU8ua4r3XYmm/Z4zRqtmsMlY7AI+PNgoGAKlcyRijVWs0SqpnDJGMgDvozBmzF4M3pPWgeT0Xkyem9G780avDmDL2fw5YFAEQwWjcGSKVw2BktAoGjw5XWerMGbA/xFMFg2hqumcNUYLhtDZWOoZAzCgMGyMVwxR2vWWMOW2LPGGqZwFQwUDd6czpvTeXN6X17PfDh26/F2oAgESmCwBAZLQLAEBEqGQMkYqpqjDVuy7cz03Pkjb/HYVzoNVM4D5TNf6dRbOPbkjxyZriXRAsI1ja+k8hQUnqLMXZS4SmJXSeQqC50VobPCtRZoQIqgCmMkHpTIjRJ70dIAWh5Cy8NoWQgtC2JkQZTYB6cBmOYVlmWd60AI3EixH/rE3xS6EXwXQuDaFHq3xH6kNIga5RLgXD00MXi2JH6cKr5ryFOtNaarxfV2BcEjaB3P6FvWfN8+29mkWysUME80ZHZ1cOpoR5cmgQWqpcp0NKFv2QiDR9C36KF0Ed+7z3Y26eYyyZDZVsVwigheNbzp16V39VkSkKcYCyQgt6OOY2TBTbiK4dkS+1Gyq/FKfJsC1zrHtsw0LTGMK0zzKtu6xoGMxL7Gsa+xbaNOgJwPLQ2ixL4tkWdT4Nrg2tfY1hWmeZEGzpN1M7uqyW3ZBFb8GCV4uMm9v8H6xTrz/gb7wSb34Rb/MVr0FC+bJqjnyfoFKrBAMcxT9PNk3RxZC0PSzpGg57o5sm6ealhimte4DoTQi5KFtzUpkrHIsDfY7g68rtzX43k7LHudaioQdUm8IowUutfYlgWKfpaoniWqZ4jqGaJmhqiZJWpm4YPr5in6eaphgQos0sBFOrhEB5cYxiU6CHnA9K56hqhZpBvXuI5NsQ8lC6HgXJQPJfHBCiILo+URjALK4kRwijBaGkBCS50gy+G7EAI3tPIJyictUoGFSyzSIauwrLKtKyzLCtO8zDAt0Y1LdHCRBi5SgUUqsEQ3LjOgfWyrkBpy7Wsc2yrLsswwLdHABaphnmKYJ+uh7lqggUsM8yrbtsZ1rHEd60Oz3ODBLoUQuBECN0LgQghcCL5jlW1ZpINzZO0MUT1PMSwxTJDirHFsKyzzMsO4SAMgFmjAAg1cpBuXmaYVlmWVZVlmmpbo0AnoL4czxLrKtq5xbGtcxzrPCRUTEYLRCbgRAvemwL0pcCNFXpTYj5EGsfIQRh7EyAIYmR8t9SFFboTAtca1QxK8wXMg+M5NvmuDa19jWVaYxiU6sMwAV5imVZZ5jQ1vWaDo5imaeYp2gaJboOoWKLp5knqOqJolyKfxkqcYwfgW58Ea/f4K9eEGcxzJncAIp7dl8yT1Ck2/zjZt8W2bXMsG27TBNq4zgTWGYZWuX6VqVyiaZbJqiahY2JUtEKQLu/IlkmKZrFqhqNfo2nWGHsEybLFBFM+CEdpxYteOzENSh2j6GMuU5lpzHHOGbUqygDjTEGOBcY4pxbVkeNacwF4QOUsSV0Xmqcg8Vbm3KvfV5L66OtjSRbuGxNHFV+ILfXsBtp93/+JeptpxxCrPEn8W51VczyFVbt+fmCs3e9dfuvv+vXa73W63775/b7TRfXW7O1F5hnSlPfftr2cMOuvEA+vEA/vEA+fEA/fkA+/kfd/k/eDk/cjU/djU/cT0/dT0/ez0/dz0/dz0/cIlln/wD6MmoFaWf/APo1eh/bPT91PT91PT92PT92NT9yNT90OT932T972T990TD5wTD+wTD6wTD+JC/ltf+tyz9nMG28/v7h+ejNRHdRW1J/c2xvMV8Yd/Yf9Q4Rz/MPgNLeMz//dffevHi1N/6/vwZ6EPv/oTyapEi0b8NN7oJ5r9ZBNe4pO5SPl4Ht8ae2QcFI1Lt4YiUuwMRtyYB1JM33pkvOmlmPg7Y4uKF+aQXKz3xqbcnzjD1B7k26Xd746NTblHkiSfGhsbW5IPTcjBfG9sbEneLhG+O3aHWbrBjS40qD/CPrSf9DWuy9AzPnTZiuKNfqx+FqueRqsnoVJqEza+d1bBsj1agTJA9njdldrzZjv+/IEv1/NmO+7UnjNZt8eq1kjZHCqCgbwxWDCFSuZw2RqtWMJlUzAP+jIGT0rvTupcSa0rqXUmta6kzp3Uu1N6d0rvSes9aYM3Y/BmAV8ODOTBYMEUKhoDBcCXM3gzenda78kYfDkwUNj52WXnvPUP7AIYLIDBIhgsmUJlS6RqjTUcyT17vGGJVk2hEuDPA/48ECiAwSLIeTx2a5wQKptgSmCwBAQKgL8ABsvmaN2ebDkzXU/+0Fs8DpRPg9XzYOUsUD7xFY88uQNnet8SbwKhisaTV7pyclde5ipIXEWxqyR2lcWuishV5dmKDDBFVIexEg9K5EKKvEixDykNbIn9WyLfphCezldZ5kUaMEfSzpP1i3TjCtsKfYKv85xwlgKuEXi3xH6kJICE78uhG1YvQuBe5zk3RT6MMkYw5KiWGtN5zX6CR8JAj+tpM+01qrGwq0ttq2N4ZRRKL2EV0R1tGq71QO8NHEJfNRcGD/m+LlTooRjzBE0CIwuipQGMPIRVRuGqlj5DAnLQipwddRwjC2wKXBs8B0Lg2hR5t8T+LUlgS+TbguLlQfEaZkmaGaJ6jqxdoBoWaeAS3bhINy7SQOj5Ksu6znPC9/fwTb99jW1ZYZgWacA8WTdL1EwTlJN42QRWMo4WPkLyH2xy72+w72+wPkBA9sN7hBQ8wYif4mRTO8ppgmpqRzG5LX+Klz7FSZ/iJEOkT/GyyW355LZielc1R9EvMsyrHAdC5MMoogR9lmquMByjhdgttrNJM5eI+hReGUaJPOtsyyJVP70jn8CKJ7CSCZxkAieFeIqTPcXJnuJlk9uKKYJqelc9O5ShBRqwSAPmKfpZknaaqJkhaSH72YLtB8qBeZEiL1LihxbHoOURjDyMlYex8tBQmt0bPAckjutcxwbPMcyHAXMkzQxBNU1QTRNUUwTVNEE1Q9TATVMN81T9PEUHyd8sUTOzq4Z2ntnVwKumKIZ5qmFhyBxZO7Ornt5RTm7LJ/Hyp3goLvn0rnrkQEsM0/IIpnmFCRmJbY1jg3xonWtfYZkX6eAcWTdD0izQgGWWZZ3nRAg8GzznGse2yjIvM0CoW+bIulmSZpakhQ2SpJ0hqodXUHERDtWwQAUWaAA0ZpaZ5lW2DSqcbfBdG3Bmy7HOtUPOt8w0r3JsCJ5zS+hBiv0osQ8l9qElPrTEuyVybfDtqxzLMsu8zDKvsMwrLMsqy7xMBxcp+jmiZnZXNUfSzFP1i3RgiQEu0YFFqn6Bopsna+bJ2nmqboGqX6Tq58maOaJyZkc+vS2ZQPMfbbI/WKX9fJEECdDjTc4TtGAKL5kjKhep2hUGsELTLVG0S2TVAlGxsCufJ0jndqSzePEMTjSF4U+heZMozhSGO4Xlz+CEM3jR/I5kYVe2SFSskFXrNB2CBSK5ZozQsSPzkjVhOpDgWLJsU5oFJplAnKGPssA4y5hkm9Icc4ZvzQntBbGzKHGVJa6KxF2RuitST1UZaGoiHUP8wJQ+NWdPzblzK1T8KsD244gWGRrfdf79Pz558SLlH/zjE7bWx9ZdwRLM/u2PH0ayNY7O9wx3379XqVQqlcrd9++9aLv+CtZg9oPf+bd+MpH57a9zvv117ltfF7z1ddFbX5e89SeKO3+ivvPH+ju3jd+5bXrntu2d2653bnveue27yvTdu6MmoFam7969vIP3nduud2473rlte+e26Z3bhu/c1t25rb7zx4o7fyJ960+Eb32d/9bXuW99nfPtr9tWFm7/D//Nc+znU0P78dxgPx/wff+aO3jH8mEg8cO+7zXCxm/f+YNP/ezRo8/hin8qHHzfOfg/DIOv/SOXavNf2E9rkG4NMuDSrbGxh2CJ+O7Y2JS72BkUOyXSu2OPjYPSfon07tjYtLu0Pyjuex7fejZPAz0eGwfFfYgS8d3n5XTe240NjecFj++KXR+v7uZkvTf2rtgJ/1rafRduIt8Z5CAZmnLfnCVqXV5+1B8xsh97q58e8WIH2usnIZ4RoEY/Xj+L1SD7OfDnjP80NvYjQcUehbFFq45E3Z1qeXP7/kLPl08g3h77Jj7sTNQdsP0UjIGcMZA3BQvmUNESLpmDBaM/a/CmdK64zhnXOmJaR0zjiGudca0zoXMmdK6RA6UgBwJ8OdCfFyDvjH1rl+fLGjxpnTupc6f03ozBl9v56ditnylAfx705yCM/rwxUDAGS+Zw2RKp2uMNR3LPnmhaozVzuGwMFozBoilUMocrZt6TsVtPiJGqOVKxRCrmcNkYLIGBgsGXNwZL5kjNnthzZbqe/IGveBwon4aq56HKWbB84i8eenI9R6ptiTWAYFntzildGbkrJ3Plpa6ixFWSuMtiV0XsrvLtRQaYIqnDOKkHKXQhhe5NkWdT5EEIPBt8eDpfZhgXqPpZonpyWz5FUM6RdZAArXLsq2wb9Km9yrGt85wIoWdoP9CyEh9S7N0UejYErnWeEyHywvZjrbFc7WfsB/qvPFx3i2GtkIHcjiaOU4Sx8hBaGkRK/GhZCK9OEIE81QKvm+b7D6GvhgkDB3zvPse1x7BWyEB2WxWDlq2gpAGMPIJTxbc1V+xnWx1HSwMIvnOda9vgOTYELoTwSrwrDOMCRT9DVE1uy57iZVM7yhmiGk6QUOCkwjxFv0Q3rrCs0K38Ote+xrZCxZFFqmGOpJ0hqKa2FU/xsgmc9AlWPI4RPUYLH6EED5H8h0jeQyT/EZL/CMl/jBSMo4VPMOIJrGQCK3mCEY2jhI+Q/EdbvBGPkfzHKOE4RvQEK3m6LZ8hauapwDLLus53I6UhvDpJBAtUS4Vmgb/DRbdUSIbMtiqKlvgQXNsyHZjdVU5gRI+Q0KEEj9HCcbRoHC0aRwvH0cJxtOgJVvIUL5vcUUICNE/RL9LBJbpxgQbMUwyzZN0cxbDMtECVL7Q8jJIGkRI/UuTdEnmQYh9U94TsByMPYWVBjDSAEvs2hVCvOqDqFYLv3OA5VpimBYp+hqCcxMueXiCf3IGkQT1L0swS1TO7qpld1TRBObUjn8TLnuKkT3HSSUjUdpTTQ3Oa3lVNEZST2/IJnGQcI3qMEo6ACovTu+o5imGkrcPkDbhIBxfpxiWGaZlpWWVb17n2dZ59VOybp+iXGKY1rh0h9CDF/k2hFwFlWdiWZQYIJdKmCErIVie3Id+STmAlT7CSJxgxPGx21bMkHeRqUF5thWlZ4zoQAjd8ayF0QznINY4NShYuUA1LDNMq27bOc24KvVsiL1LkRYm9KLF3U+Bc59lWWGYoLQcBefbMrnp6RzGJl80QVLCsM8BFOrBIMyzQ9ItU3SJNv0gDlmjgEh1cuBAg2VOM8PEm+/4q9T8ukn6xTLm/Sn+wzny0yXmC4k/hxLO78gWyao6omCXIZnYk03jRFFY4hRVMonmTaO4Ekj2xxRpHMMY36OMIxpMt5gSS9RTFmcTwpnGCWbxobkeyRFKu0rQbLBDJt+IkbqIqSDXEWeYsy5RmGpMMIM4wRJlAnAkm2cYU25TmWrJ8W05oL4icRbGzJHZBlOW+hjrU1sd7YPrElDk1586sub6tMLBB9vP9e/ZwgaLyjKAO+TjLdOhqD+MqRn/6b/7xQShTZVx76e779/L5fD6fvy5So+1MtYep9jA1F5j96V/81r/x7e7QvvEa8xuvsV5/jfv6a4LXXxO9/jXZG19TvvGq9o1XgG+9Ar75iuXNVxxvvuJ68xXPJabffXd0/NHj7vv3pt99d7SP+81XHG++YnvzFcubr4BvvqL71iuaN15RvvGq7I2viV7/Gu/11zjffI31zdeYr79mWZx97b/7r56X+7lU+YIyQJf4/Xnz5xXHqcwHZ44/0GH/7V/e/lcStcGe7v58jfwbm8e/Rx38b/bzP8bs3/vJFGQ/qdEy5/YgHxXfGRsb++5718tS32GVSvsjubkB5fStZ+zn4teLvJHn8a33iLFBsTNws96DHAt+Y2dQjIm/867Y3RkUjUu3vit2f5T9wBiXRrqTj4nvjL13592xOyyoauZ+NKygPb9S1s+1+1mIoQCN7AdKBaWvc6MAXc8ANc7j9fN47TRWPQmXDgN54z+Njf1IWIXSnvZY1R6rOhLD3E+h64ftJ+RK1B2xqi1SGtpPzhTMm4N5c6hgCuQAb1rvTmgdMa0jonVEIQHSOuM6Z0LnSujdSf1FEihl8KYBb9bozwm3rtiP3p0yeNIGb3b7p2O3fiofek/O6IdlyxQsQsuSbPGGM7nnSDRt8bo1UjWHYSuyxmo24cTYrafkeN0aq1mjVUukYg7B1TpTsGSJ1hzJljvb9eYP/cXjYOU0DK0BL5/4i0feXM+RapujdSBY1niySldG4czJXQWZqyh1lyTussRdkbirAnuRYUyRNGGsxI0UOrcEToTAuSFwr3Edq2zrCtMEJc/hlStYyVO8bHpXPU8xLDHNKywrlNVfZppX2VbIfpCSABKaGsU+pNi7JfJsCj0bAvc6z7Up8mGV8V0gT7PVWZfW/UiiZ+Lw8Y32g5GH0NIAVGDCqxO7V+znYGQ/PG+H42oyrGWSIYNXRpFi75bQM1yaE9/WpAi6DBHIUYwFEpDdVsfQUj+C71jjQHOeY53nXOM5Vzm2FaZ5mQ7C8W7Ln2DFTzDiSbx8mqCaI+lg9YFu98m6BSoAV1UgC4SKNfTh1LijgGdEnHQCN8y44Ifg4GnyySULeYwSPELyHm5yHyDYH2ywPthgf7DBfrDBfoDgPNziPUYJxtGiCZwUms6XmOY1nnNL7McqowRdZvgNowLFWITzW9LAFt+5yjQtkLVTeNljJP8BgvNwk/toKEBDSxA8RgmfYCVP8fKpHeUMUTNH0S/SwWWWeYVtWWaalxhGqMSzyrEjhB5o/RZU0LywH0lguPQnjJGHoNwPGl7i490UwOtdkCLvltC9xrYuUg0zu6qr9gPln5Qzu+oZovrCe7aHVoERP0GLnmDEE1gplNcZvXECL32CFUPZtYdbvIdb/EdIwSOk8DFa/BQvnyZq5qnAIlxEMy7RwaVR9YoKLNDAZcZoITNU4bIsMUyLdOMqx7YBLbGShVHSAFLs2xK6ETwHnBckqkdaBp3eOEY0jhGNo0XjGPEETgZ3JlkHqw/duMwwr3HsCIEHWisNLzAX+5AizwbPvsIyL1CBObJukQausCxrPCdC6NkUwvaDhuyHY1thmhbp4CINgPNeFP0sSTNNUEEGNkNQQUdYZpqXmaZlpmmZaYRYYRpXmKYVpnmJDi5S9QsU7TxROYWXPEHyH24wf7FMub9C/WCN/sE648EG6/EWdwItmMSJZ3Zk09uSaZx4Eit4iuE9RXMnUNwJJGdiiz2+xRpHMB8jGI/XaY836OMIxvgm88kWawLFmUTzprH8Gbx4YVe+TNVuMMEtngUnce+qQjRDgmXOsoxpJphkAHGGPsowxJhAgmVMskxprjnDs2YFtpzQnhfY80JHQWgvCB0FqaeqCrZ00S4w/Dcf1hz87/4h+7GFC1SV9zp337+398LH3ffv0dVeutrLuITJn7n3I8h+vAy1l3mJu+/fS73wcff9eyy1F0YDY/ZnfvFb/62PuMN4/Tbz9dvsN25z37gt+NZt0bf+UPbmHyrf/Jr2268Cb71qfOtV69uvOt5+1fX2q54h09/73uVGn3k+/b3vQbu5337V8far9rdftbz1KvjWq7pvv6p581Xlm1+TvfmHom/9If9bt7lv3Ga/cZv1+m3r0uxr//1//Vz76R6e6nxFra9wsdLZW9B6C1wg+tojrsz44Mz1epn9rz7/1d/7/Lv/7o++/8Pbf/2zV77/o3/zV4l//dMP7/LO/3ij88af/zDeuFT2ag2yrdLuu3DSBZKV0v6gtD8oxcXfGYMyQAMP+4UJm7GxsbH3SHE4VwS9pdTxjN96jxR7kf1cTvlctp/iTVwTIPejMWh90sDFem9s2u1kvgfXwqLiO2Pv7UbhAhmkQfKpsbEpMeG7cIN3mMVcu59r9bMR0dtXkk+w/dgZFyG/zSg+sypIPDk29l2RdfR80p3cc98fveGpO9E4j9fPYrWTSPkwkDf9ZGzsn0R1Z7xG/cXY2C8oq9+Gd3xjJ+rPm35y0fw7q8aKNVLavShLPdwN5M1B5+IbY3/2kw/+bGxsbOw/YuWYPx379szaL4b73Md7UoA3BXjT+ItjPdjx53Z/enHo/2XTbvCkDJ404M2AvuzOT8du/UxuCuQhzMHC7s/Gxm6NE8NlS9S38u2xsbfo8hTwo7FbP8LRXoePcetHwroj0XSKJ8duTVKTTXuiYTdRvjFq402iOFK2xRty/HfH7sz85M7Y2Nitn2tOI7UC6p3hPnc48nTHGtP//ditf/9PD8fGxsa+SaC6CjJ3UeouSaDil7vCtxcYYJKoDmElbqTAgeDbN3j2Na5jlW1bZpqX6OACRT9Hgis4T7CSCZwMKr5AN83LTMsy0zyyn02hFykJoqRBpCSAFPug2XFT6EEI3Bt895Y4gFMliEDh0qrn46uVr4PnVr6U0R0dVPmqP1v5gu1nj2GFcx7QEhzIfrCqOH74JTUymCcaMnhVFCXxbfDsq2zLKse6yrFBSSw4Xqp+jqSBMhNPMOInWMnktmKGqIHmMCgrME/WzVP00ByzwratcuyrHNsq27rKtqwwTYtUwxxJMz3MCkzuKCZ3FFME5TRRPUvSzlF0cxTdLEkzs6uC7tef4iRPMKJxtPAxkv9oi/dgk/PBBmQ/MA822LC1jOyHalhiWtZ4zi2xD/p3QQRdZvgluwxBm8TKQ0ihe51jXaYZZneVT7Hih5vc++usBwjOwy04kzQCVh+CaoaknacYFhmmFbZ1nefY4LvWeY5Vjm2FZV1hWzf4ri2xDy0PYxVRjDyEkgYgux0uCQ+hoa9lycNYeRgH179CaGkQqothZCGsPIyRBhB81wrTPE/WzRCU0wTlNEE5RVBCdbcZogZa5DRLVA+zPtKnOMkThj8vfQAAIABJREFUjHgcLRxHCZ+gRU+wkgmcFPaeoVw+wYrH0aLHKMEjpOAxSvh4pCAENTRWV9i2FWg5Ecu8wjRBK4qgbNAy07zGgeq27g2+E1pYA8cr8qFlYawyipGH0bIgWuJHijwbXPsywzhP1k1DuR84vScZIr1QH4p+kQYuQYU2lnWNY98UelDSIE4Zu7pSPrgldK9xbEt0EMoprrJt63zXpsgHLY5GiX1D+7EuM4wLNMMCbVT108+RtbNEzTRBNbWjnCVpF2ggtDhvuMjJts61rXNsa1zbGte6xrGusswrDHCZDixSdHO7yimc+AmS/xDBeoRgPdxgPdxgPUSwR/YztS2ZxIknscKnGMEEmv8UxZtA856ieE9RvAkkd2KL/WSL/WST+WSTNYFkTyA5T9GcSQxvCiuYwYlmd6SLJOUqTb/BNiEFdrzUS1SHaYYk25xjmtJMMEk3xOn6KN0QYwIJpjHFMqU5pgzXkuFZs/whPGuWb82JXWW5v6mOdIHkEZg+MWbOzLm+Fbaf/rvf/xtbqEhV+WhXoat8d9+/V3jh4+779xhq3wim2sfU+Iz+zL0fPwpn60yNbwRL8/+y995Bclx3nmf2zu1FzN5d3G3E7O7EzewYOcrMiBJ3d3ZmbjQjzMrQACBAECRAJ0eKpEgZkiBEigQJwhvCNxpo731XVXeZLu+99957X9XlffX98TLLd8MQFDUSEN9AVGW9fJkvM6vep3+/3/v9NCsMzb6nfmrZ9t++p366wtCgGmJqUEyNQOd69/N/op2fXdm5Y2X3DszuHau7d+Af30Hcs4OyZwdtzw7Wnh28PTsEe3aIntghe+Lbin3fVu37F6DWI+576qen9+/v2AKaKfd9W7bv25Indoie2MHbs4OzZwdzzw7anh2kPTvW9+zAP75jdfcOzO4dK7t3SPsv/MOf/F+96eevvvQ3mUKZowuymwJL3wNEoeLK2KGacX+F9p/+x8Pfhb7xE+hGHhopQRNVaLIIDcSgq4H/dyH1R5fy3973s2bQT6LuStZJp/pApHNPptm1F4KgC7Q0gkRNMOramG6nn7Tqo77901ZgB1IdRV4rUfuh08o2o5GVsGsvQZmu+wUX+8CLDm0ZcgRBp5Xgxc6VgJd/EYIuktucYoGpvS30A0Ef8GqejZpseT8EXSAj6PPYkt+drLmTyg8Q+pEu7YegC0RgBDLiH4OgI5ya04h/DNo/bqw5E8r3IQiC9o8Za46E8n0Iep9TI5yAoBPKdvNPxRIpm0IFg09wGIIOEWJKe3ThPQiCoDexYbktShl7HIJOLnvSarel/zHou6N6uTUiM4dm34WgX1P4Ojdf5546DEGHyUK9/ML3IQg6Mqa0s+UWFnn42xAEfXcUo7RzVISfQ9COASlf6548DEGHSTyNm6d2TxyGoMNkgcGPH9wFPTyN0/v4Og9P4+Zp3cDMM9ka99P30YwxKDZpLj0MfWdYK8Eeg/pOLNjjCif3LQiC+k7O22NSa5Q08jgE7bkmSSqJp6C+UwvOpFy8+B2o701cVGqJSMzaSw9Dfb9hyuwJ6vheCOr7NbWgD5YMYe/QbuiReZ8hVNIFnNd3Qt+bsEqs7F9AEPT96WWVl6r0UZQ+stJPUgaISjj2eVXiXeLC9DOEk93AyvpXpdcwsitoMRzFOcc+N8M4M0UDxoxTE5SzM8yP57mXlkWXUeLLKPHlFTH4ZQezxSARXjUN4kJu4FVgzct1nPom0TDGsM/w/EvSOEj5A694N1fWTVtGPU8yHeMM+2Qz6jnRGvVMMJbBXhhlclkSnuN5JhjWYaJucF07RNIPU0yjNOsYwz7BdE6xXTNczzTbOUY1DRI0/avSqyjRFRSgH8lllLhBP+dnmWenYOPNSeBpmuPAtLfU8DvAMRyw52sVCeBASy4tCz6e55ydZpyZop2ZZpydYZ6dZZ2f51xY5F9aEYJY3csr4FicczPMM1O0U+Pk4yPrx4ZwHw1iAQN9MID5YADzwQAaNtjAyEI4MUY+M838eJF/GS3th60IpjG6dYIJL+QeZ9jGqOahde31NdmVZcGFOdaZCcrxYfwH19HvXVs5MoD58Cb2o2HCsVHicTjip2ny+XiBf2lZBC8rI2gGibobsPdK0b+muIFXDxL1IxTzKFjPT9IDzyZCP/pBeNGfaYxqHqOZ4XwBLYvpJpn2htvx8rLg43n2x3Ns2J8Iwq4XuBcWecDcCBj01DjpxBgR9gkCD90oOGcKwMqT45ST4+QT4+QGDJ0YI58cpwAvHjBSXsXI+rFKJM5G1g8HSosBuCOPrvomWDgGj1feMl4rWN44QjYME3UDWOVVtPjiIu/8LAtEhgHygBluktYINkKeEGk/sjRsiGQco9um2O4Znq8lRYJ1mKQfwCmvoMQXF/nwHxJ4zU0QWk7UDRG1IBIfLNxDwtJhATsQCPSGY/LWFAN49QBefROvvolX3cSrbiAutv412bVV6VW0+BpKeGWZf3Gec26afmaCdHIEf2IYf3wId2wIe2xw7fgw7sQI4dTY+plx4ulx4qmx9VOjhFOj+FNj+FNj+NNj62fG1k+P4U+P4k6N4E6PYE+P4E6P4s6M4c+MEc5NrJ+bJJ2fIl+YoV5ZYPWv8G+uSYYJygmKbpZpXuQ5USLvssC1xHMscqwLLPMix7rEtS3zHSiBCyV0ooQujNCJETkxQida6EQLnCiBEyvzE9VRmjHFthW4jhLfBYf+iBH6kZkCiwzdAl2/CMSA9fqhE9vH/bx+6MQKU98hod7zyltHja7oCkvfKhRL/86xa9t3+M6xayiWHsXSo1sk0nve/dKf6lYWMU/vWj2wC3tgF/7ALuKBXaQDO2kHdjKffYz13CO85x4RPveI9IVHZC88onjhERWi088cbHR++pmDPbeoXnhE+cIjshcekb3wiOi5RwTPPcJ97hHWs48wnnmMemAn6cDO9QO78Ad2YQ/sWj2wS3bz+v/3n//jNvRTaclqGOEZI1xDhGuImDwoLu+tCvdLl078PfS556AnhqEDw9BOFLR3Bto7A+0egf71ErTjDPStYzue+kUH/bg36t6NwPTe/VPATpOuB9L1IIwvLYgjuNiHmIJazUIBK2EXbPhppx8rYRd0gZr+ZPQDB/RAEARBe7tCgvgXob0ERUr5IewCg1+QAQwB+kGinpFIoJpno+Yx4x+D9k+Ymq6uds+Xf2IP9NiS35WsuRI1Z6K2fhKCTiqdCf/4HuixJb+DcwHagycs7X90ye8w4h+FLhDiNTv7AgRBEHQBD4f+VK3RqjVaMYeLBr/oMAS9TUyonPHF9yHoPZbcGpHbokrx4nehPdelKbXLDOhHYYvILIw3OhD0+1N4veLC96F/HZBy1U6O0s6hju6AHj1Pd/G0bp7WM3kYgn5NERqov+zY8eGZdVOIOLwbemSWYAwIDT6B3ivQe4V6n9AQmH4H6nuXITGHpeaw1BKRWqNSa1QqmP8OBEHQ41fFCYUzqXTx34L63lpPKhwJuT0ud3DegvoOEVMq0mmo7/SiK0Ud3wM9tkS2x+X2uMwWk+KOQ30nF10p+uReaNcqO1gyhMpGLe7h9vPq+0AotXN/CfX9HBVkavx0dYCq9pNVAUA/64ogoJ9lnn2GYRwjqYcIyps4xQBWfr3xF/Cy8BIws8NhnsymZR4jvbYqv7Yqu4aRXcXIQMgzmIyHyaYhkmGIqBuE/V/aGwTtDYJuiGyaYDpnBcElWXu+n9tb8Q5KKLSteDdVWtZ8pVDy2IIwAPhmhGwYoZhG4WVfIIUgQj808xBRe31NDv9xvCq7tiprjneJf3GB+/E8+3xjvIu8yytwlDeymlpyFVntPIBT38BrbuA18FJtnKp/VXZlRQRiMi4u8i8uCy+tiK6gpWBOAvMZSJ13DSO5siK8uAhCN+CQ5xZnCv6jIdxHg9iPBrFg4j8+Rjo1STs3x7m0IoadMmTjKNUywbBPglxEdNs43QpSLF5flV5Z5n88yzw9QTk2jP/gOvr9/pUPbqwCAxIIcz4zzTg7wzo/x7mAxDD1Y5U3QBJIqhlkeQa5/kDo1QjFNEa3jtFto1TzCNkIbjEYEUw/FNMo1TJOt04w7ZNw5kYXyOw3w/WCrEiNNXfX0GBdvRhgdCMA+Srw7yxwzs0yzkxRgRXtxCjpxCixGVA8wwIRx2dnG2KdnWWdm2Wda6xfW+RfRkmAyQpZpAbHot3Aqa5jFQBbB3Cqm+takMEZ2HjaxkuzggxPcOYeimlwXTuAVVxFSy41bEiLPDiWCAknAvkL4C8F4hkcoZiQwibBRXEEJAudF/hasjCormFkA1jlzXU48cQIxTRCgaPIbxLUjQihKyuiqyjxVZT4GlpyFRgdV4SXV4TXMNIBnHKQqBumGEdaBNYBDAJzLE51AwtgSNaPFl9Z5l9a4H48yzw/zTg3RTs7STk9QT4zSTk7RT0/Qwc6N007P0M7P009P0P7eIZ+YZZxcZZxYZZxYZZ+YYZ+YYZ2cZYOdGmeeXmBdXmBfXWJc22Zdx0juomVDRNU42TdNN00x7Yt810osW9Z4Ibph21a5FiXuPZlgRMldKOELpTAiRY4UXw7im9f4dlXeLZlnm1V4l1XhamGDZYtz7UX+c6ywF0VeWsiby2Wqx34yS8kejeaY1lhmYFQLDOK3RS6W5w2YdolNgReOXTM7ImvcswdWrsrSQyBI1/9CwMWg3vxIP7Fg+svHiS9eJD204O0lw+yXj7IeeUA75UDwlcOSF47IHvtadVr+1Wv79e8vl+3tbRdb1Wv71e9vl/22tOy154W/eyA4JUDvFcOsF45wHz5IO3lg9SfHiS+eHD9xYPrrzyvmB7/lz/9z73p568f+Hq2WG1WtLCCF3Gx1eOPXc8J/z5D+H/+6B/fgHZfgl5ZIErtck9eBa83rhjCVVOsZgbJnWPt9JME9NPT9tNh4AnM7IV27d2/6/TFXeDTViRK1wNIuDTs4YIuULeN+2kep5fn69ahPxvKD6H9UzzCzj0EObLya+eycmoPcHvVvc01X7UG/bhhk08n/TTXfCVhymkEOwPfliNREy/th/bgx05Cjy757Ub8o3vw+MX9bSYfwECP44VN+ikZg+JfQ9Bhckrj3lg6AkHvs+X2mNIeV0qWYPpxm/tB3I89JrMy34CgX60GhQa/CMgYEJtUFx+G/vWmQqDz8rVuPmvyX6GdF9k+oSEgMgZm3oWgd+kSM+NXEPSrtRBYUS82hySWsNQaIY8+Dj26QLREJOaQ2BQUm4ISc0hiicy9C/W9x5bZ4nJ7Qu5IKBxJuSMpd3DehCAI2tMv2VC5UyqP4BDUd4iUUrpSSueG0sU/BPW9Tc5qyGegvrPLngxtYi/02DLVuaF0biicG4r1U1Df6WVPljn1BLQbyw6VDeGKSYt7GNo/pKsawxVDsKQNFNXenMzJ/xXU94vVCFsfYupCdE2IqgmR1SGSKryuDBOU4TVpACV0z7Msk1T9GEk7TNQMrWtAuMZ1rBKEqYIJCY5uRknAKhiQreQmQXuDoAH5V8DKrDG6bYwO57gboSCp6igmkCUPBO6sKJIYdTNnT6Me562zHao7sx225vsBSW7m+D6QchBJiOecZLsaaX9nuO4Jhm2EYgSJ427g4fwryHgV7eMVX0FLGmYPJDeMDk4VCBw6FNMIxTzSTGQH50cGiWeaOWyIumGKaZRunWA6JliOMbp1hGIaJunAlAbiOS4i8Rzn59hN7884+dQ46dQE5fQk7fQU49wc+9KyqH9NOUjUj1AtY3TbBNMBCANUoZpAbD8Da/KrK8IL8+yzk9QTI+sf3lg9MoA5Oog7NkI8OUE9Pc0AscCXlpF5Gg/n7hulWSaY9ikO3OcEE2SzBDkGkeyCDDvstSGDvAaGQZIBOInG6TbgZwTZvecEwXkhiMgOg0oaszzvJNM+SjHBfLyubSRgBMl4Bgka4OW5vMS/ABZ/zTDPTNHPAJvKPPfikuDycnMlOSCnK2gJki0JXlIOCokMkYyjVMs4wzZGt4GBAHfqMLxuXz9MNo3RrBNMxyTbBWfmpFlGaQjDsZxTbBcYNbi8o1QzSB05gFMONNerty1fv4HXwI5XkMIRuU2zPN+CCNRB22gWYBGH5njeSZZjlGoaIuoBck0wHZMsFwK11jGaeYRsGFzXAtPUdazyBk51E68eJGhu4hGmwamGiLoRimmcYZtkOSdZjim2Y4rtmGLZJ5g2UKwDfCVHyIYRkEhzXXMTr7qBlV9flfajxVdXRFeWhZeX+JeX+VeWBVdWBFdXBFdW4BdXV4TXUMJraNF1tHgAIxnAiAcw4gGMaAAtHsCIb6xKbqxKbqxJbq5JB3GyQZx8GK8cJWrGybpJUD2DY1/kuZaFXrTEvyL0LPGcixzbPNuyyLUt8R0rQjda7EUDAOI7UHzAPfZlnm2JZ1uVeAmqMEW/wbTmOfYir4V+ornai28cEaosJIkbK3A2hAMSwsK3i7Ct5ObIa78+ZfOl1kXObhHvXApL5MiDX7SQiJQ3X6W++SrtrVdpb73KOvQK59ArvEOvCA6/LHnnZdk7LyvfeUn1m5e0772ke+8l3fsvGbeWoeut7v2XdO+9pPrNS6rfvKR452XZOy9L3nlZcPhl3qFXWIdeYR16BRyU+f7bshXU4w98Lpmva0Jd9PO5Lz+YLVbhaqaOtMSRljjSYkda69HEwhc2iV/48ZtPQv9yCjpEhi4bv/CLURTHKLKn3hhh/PtTm98gbf6H0c1/N7/5L0++1Yx6btJP3buh+rAPXpaFWGsalpuGVEf7IGgvQWkl7IIuHD3dBzWsOx1hOhbCLgg6ugJSBMHcA9QR9QyvjQd2Hf7Fvq3XfPVKnBiY2gPt3LO/sfRdtrwf2rN/Z3PpO6Afv3ujRjoFQSeVcIAzQj8uE/4xCDrCBUHNyiMQBCJ7JEv7EcdWzWHEPwpB77Fr9njNbsA/CkEQtH/UULPH4UCf99g1W7yGP3EBH6vZYjUr+wIEXcDFatZo1RKtmiNlY0jyawg6TMlqvenlDyDoCE/pSCqdSZV0+bvQ3uuytNpt7X8M+u64SelIyO2x+fcgCDo+Yw5LLGHi8O43sBGJVXf5Eeh/DWvFppDIGBBxZv8XtPsSLyKxRCXW6NxvIOg9tgze8cScLSa1Rsmjj7+Jj8sdCQpinpHZYjJrVGaNAeKZfx/qe5+ncKaU7rQKlvXaY9D3Jqy0ib1Q35llT1btFR2CIGgnmubJqDyZpQ8gqO/sii+vpZyF+s6t+HJqOfp7EPS9SZvKk1F5bP2PQX0firS+AmtmH7QbywlXDeGqMeIf3A1Bj+O54aohVEZ99OR1RUHuFr4B9f0Sl+CZ4hxjjGWI0XVRqjZK0UZJmihRHcUpwxiJf0ngnmXZphiWCbp5jGYepZlHKKYRJKPdELx2XXdzXTsIVpJTzCDv81gjiS0yO06x3VNs9xTLOclywO4YpLTCFMczJwguSWNopHo8wVha76x0UWqrdKG+VaULYDcyFPH6/Jomg1YkliSReYF/lued5Xlneb4ZJBZ4XhBYEAZBzdFJph2kYYQF0u82x6sfIupacis3ZiPnRNPEYgM5r+GEimz3FMcN4wLD3qxmSjWP0qxjDNsEyzHFcc/wfaBEwyzfN8OFqyuMUk3IbKpq5usD6fUW+WDR8sewV4gPrD6DJMMYww5qbc7yfXMCP6gOAcosTDLtI2TjTbyqHyO5vMg7P8M8NU4+NoQ/ehN7bGT95ATlzDTz/DwXyRukatiQQPwQSGAN6kiAch9t1Rv4vlmeb5rjnmI54XR8NPMI1dwA3EmWc4brbVQCWZbG4OpaoCaXIglu0AzHPcmEn5Bxug2kgR5n2EDK5hGyYZCgHliTX0OLkVQ6fNimgpFdX1MiCQMBhupgEkVQewROO9RAMc9Ms+YGuE0gFbV9gmGfZDeGDAyNXrgYRbP+BlyqAtiuptiuCaYdwMQo1TJKQ9TM5mwZQ8gJrs7BA9U5QqAsPEaVXtVk4WdbtYFWJJYlkXlBYIbrae4CqnPAacTd02xno+baEGxjg5MijtOt4zQr8DNOMOzTbNcszzsnCMwL/Q3N8b0zXPcU2znJcjQ0xXRMMmwTdOs41TwGQJakH1rXDhE0QwT1EAGsNWssudcMrWuGidpRkm6UrB8jG8YohjGKfoyiHyfrxymGcYphgmqcoBknaMZJmmmKZppimGdY1jm2fZ7rXOS7lwTeFZEPLfZjJAGUyLcscC1yHQsc6xLPsSJ0o8Q+jNSPEfswIjda4EIJHCiBY4XvWObbl/n2VYmPoIpSDBssa4FtL3GdZb67KvTWRN6aL1W/MLJ8/MKAyp5gqINkRYAk8zdElvnJcliUraRoiqrwUxV+jSPxq/fOOUNZqsJPuxfSORMf/d1XbQw664Nfsz78NefDt3lH3xYcfVt07G3psbdlx99WnXhbc+KQ7tQhw+lDpjNvmc68ZT3zhu1OZDrzhunMW4bTb+lOH9KeOKQ6cUh14m3Z8belx94WHX2bd/Rt3vF3heeOa+dnFgdHjz/3LKCfBgDB9PP5r3wjV6rJXDmZKydz5xsyBWU504vluf/+1Z+MQruuQyeV0E0HhM5DE0nomuU15eY/sTehyfR/QW3+0bc/EhiCnfl+knC+H5+FsBMC/i/V0b7WdeyNpexIHA/i1VKi9kMQbOxBDDawGaklCRBYKg/n/rmdFe+3kzO6Ja8P9AEPWckFFq+dVCIL2mEfljtZI56EoJNKeDGXCf8YtH/chGQ4hP/tf//k/kYsM/5k86Rg9InXbHH/6OMQ9DheGAfEA0HQBRxIcqjHI6HM0G/YNUusZo7VzNGaKeIdggN+991U5lY+hKAPBCp3Wu1Jq2Wo70FPDMizam+WPgmMb3uvSTaUTtPVRxvH5sjtCbnddPVR6DujRpktLrXFZMLF70CPXxEl5I6k3JlcOAJBR/hKV0rpslxrhHAf4SudKaUrrZKivgtBEAR9b9yicGwonCmFM6V0pRePtF3470+Lr++EoJ0Yujen9tqv74SgXRiGT/w21Pf2h+eQVvsGFAVtoKilnYP6zq/4CxpfQUM52+ik76hE6y9qAyXWzD5oN44TroJ6usaI4p3GgWY9Gn9J5RW/CfW9QUgLbSm+NcUxb7CMSYYhSTckKfokWZdc18SxighaElgSeBfgOkHNGWKK7ZpiOadYcPEKkEB5ig2XKAKli5pTBc83x/eD2R3+4eYjpZ34/lm+f14ICmJvrGqyWF1LtYpGidMtqpzitq5y2roLSPyDViZBndGlRoUvcWQRrpEZXZJEFkRBsPhrGjhlEE2x3Y3xNoY8BU+NMLXMC+BiUqB01LwwON9eOhSpeQ7XRQe4MCcIzItCi5LIsiy2okigFIllUAlVFAKgBopwjdNt4zQrqGQ5TDYMErQDWGU/RnoNLbmGmDSu49RDZOM4wzEDVrmLw0uSCFwrFK7WGZjleiYZNhD43I8WX1rknZthnBonnxglnpqknZ1hnV/gXVoRX1tV3CBohynmDugBhVRX5HGUHJwnXMIMKbMaWRSH54WNa+gEJU6BRwygz7wwCA9WnkQrUxik1jpWm13TZOGqq8CzKQwgj4ofFCeZE/jn+N5ptnOcbhkhG4bgmhvK/jVF/2oz9ghJRN6ojOaagnmlIe8MzwseyAVxuFnuDan4Bj+lrZTWrF0fbikEG27uKA4viELzjZp3vGbxMvhp5yE175DHAxwaGC9X5Am0MrWqzmC1OZy+gNPlsbo8VpsDxelW5PElSQQctFGfdQm5rQtIQb1pjnuS7WqUoJ/l+2f5vjmeb47nneP55gWBRVFoSRJZAqVPQfVTaWxZElkUg1E3kAiU4fPPC3zzfO8czzvL9cxw3CAUaYrlmGY5pln2qXbNsB2zHOcc1zXHcwPN89zzXPc8zzPP88zzPYsCb0NLAu+yyLcs9q9IgmhpCC0NYaShVXloVRbGSPwrIs8S37XIcywLAPoE1xThNWlwTeLHiL0YkRstdKOFbpTQjRK6sfIgUROnGtMsW5FjL/GcFb67JvTWhN6aJlwzuML7f/DqB2euitRmZ7RgD+cRFbrl6KlIU85IwRkpvHP8cjJbcSJvP7nOfesbEYvNRsQ7iHgnEeci4VwknIeE85JwPgrOR8GFaGsh2lqEthalrUVpa7E7V5S2FqGtgX6C1DUfBecj4bwk+FguGlmGx81cu77rb79i8UTscZh+AAAh9PPVb+ZKdYW3qPAWFd6SEpE1LCkx/m7g8D9xTBt9/3wEeocLjfn+K3PzPd3mrzSbD3I3/z1m86vEzX/3yOkFosQCyly0hP4QT22Rxqf578JUIy0hkgixJTEPDEZTfDgZdO/kh/yLfdD+KUszw2EPrOFf7EN8WLef7nmLHIbNNIbdqQu3SmC4VfZCW1se56YsvWRGuAfIFKkawxVDqGwIlvSBoi5Q0PryGm9O481pfPk2eXNqb07lyarcWaUr3SZ343VK4UopXCmlK610Z1SeLCxvTu3JqTy55hZPTuXNqbw5tTev9uZV3pZPvTmVN6/25tW+gsZf0ASK2kAJSBMoavxFjb+oCRQ1gZI2ID0M9R2mlTSBxpaSNlDSBcu6YLm5S0sPumBZF6zoQxVQUhdWBH6hD1d1wYoWKXkhc+fFzpzAnuPbMhxLhmXOMM0ZuilDM6bJ+hRBk8Qq42hZBCWLrEgjy5LwUutU0ZAoDPwXi41q23DN6ghcKhwpWN1S1xopdi2NARsAErVTwBuKBCNsvwGl2lsKtjfsQJV1U7lFLWXMO3dpAhBwnGFUG6D6N1wMXLmBVm6AjSh5ojHJNdhoUdxryKAKOvC7yRMoRXIFqSIOqpE3io03So631b2XttUkR6tSq+r0mja7ps2uqjNICXqkJrwoNC8MziN1OoEJZ4xqHoFtb3A1iRGqZZLlmuX7FyXRFXkSpQDjAgXt4Qrzi+IQAKAMQDSzAAAgAElEQVRRsmEQr+rHSC8vCc7Pss/NMOFV+iBimmgYpVmn2O5ZfmBeGFoUA15JgA5X1UiJWVC+HhRUB9kUFUnknIPzAv8s3zvN9UyxXZNs1wzPNy8MLkmjcD/qzJo2h9XlcfoCjLCGAlabW1VnMMoNlCLRrMoua1zV+LIsuigKAgaaZNjG6ZZRqhnYdcZo1gmmc5rjaeIFYBQJKJneVjoeAM2KPAGuEqJkS0H4BJIiMgXsixhkvK23tV1gL+QJR84ZlItvlHNfaRai30CuZ3pVA3MPUpGtRDAW4WuiAwyUQiuT8A1Vp1dbT0YeX5HFlqTRRXGkSVSA2FpqyK/I4+Bpx6jSGFUao06vqdNr6vSqagOjSKLkCZQ8DksRRykSKAXyVh5bkUWXpZFlSWRZHF4Sh0Cl1SURrGVxaFkSWpaEV6SRFWkUJYuiZFF0Q/IoWh5Dy2MYBSJ5bFURW1XG1pTxNVUcq0pglQmsKo5VxrCK6Ko8hAYWIKEXLfGvyoJYRQSviuOUEawijJUF16T+Nal/VepfkwZWpQGCKkrWJemmLMte5DjKXFeV76oJPDWhpyb01uS+oiOS7Z9df+Xw8T3PvtTQ3mdf2vvsT5t6rqknbqUnn33x3upHD/z5ni/A2vvFP9/7pf+670t/se+Bv3zyy3+5/yt/tf9rn3vqa59/+m8+//TffvHA17/4zNe/9MyDDzzz4APPPPjlZx/88jMNfQN+cbD97YEHv3zgwS8//eADT339gf1/+6Un/+aL+772+Se+9vm9X/ncni//9e4H/mrXl/5i15f+4qX/9pWrP3rWG8sZQ6UG+gDBlS6+8LVv5sp1pb+s8ldaZYloa+sPXX/3eyp/ZYWh+LMnPug7RICmYn+yvvl/4Dah646+11F/9vzHBJnHFKmD0u7d5h83sAB9gtJdt6+7L16xfSXUrsoVPdPztGbo2bJgxRaUY+5QtGbqqUjNFAE2j5oxUkUqnlb0wbIuUNIGihp/QeMvwJDhh6X2F9S+gtpXgGGlTXlV58a8yoe0h1UEUvkKKvDW3y5fEd4F3lLSBMpA2mBFG6w03rZI9jbUd5jWvhE07m4frICPdMGqLlTVhWu6cE3fIl24qgtVtaGaJlhVBSoKX1nmKUncRZGrKHAWePYCx5ZnWfMMS55mzlOMWaI+Q9CmcZrUmjq1qtrAqDYwyg20MoVWpTA9pU6vqtPAbg9+oBE1tmcanwK/FdCqJgv/+gPXlQmgTI3UpRZTUIss7dxjRYQwU2vFDKwuh9XlsNocoI01bRarzWG1OcShBk57o/cAOwebWdOATnJr2uyaJrumyaxpmhuxLQINADeACW9Nk13T5rA6GAJgg5a+AJ9ky/kg81xiRRZflkQXhMFZnnea7ZyCo21ck2zXNNcLTGiAI0HPOF2+6StUgcX/4Tmed4plH6OahohwsdVGTiYQgT7OcExzvSAMZQWGs0yzQ30Bry/g9AVgn4AvHZAmi1ED2IovS6NLkvCCKATbUcThJWkMRGghwelI7VWEYgnGEt5QwMHdZtsvaQZcDbQisSKNAtvYHOJvAkulEMNSI7d1kxVWNZkOgXuE1eawuuYj0XwqNNk1Dfwp4DOcPo9tPbGWZi1q7b/Hs7Ha8Wzo8rjmrQf2yzIC95XOa6JrtoftQ3DPsAsYo0qhlW1PZtd4wXAagp80nDaHbbnOWG22Q2vazJomvapJr6pTa2r416Bd8HasJo3TNpQBwmszeG0Wr83idVm8Lkto0bo+u67PEnRpgjaF1yTx6iROFV9TRFblIbQ0tCaP4FQxgiaxrtsgaBIEdZygiuKVYbwygldG8cooQRUjaZNUY4ZhKbAdZY6zwnNV+e6awANL6K1pwzV/qhbNNRVrU71b8W7lb6HE74aSn0z2RL0DfVrp56F8ua4OVNSBijpQVSHShWIF2nelIz/EoAbdKnyUc2Tww388euznu06uPHps/o2bJLI6ZAjXjZG6MVLvDUCJuitZd23AhU49n0XJ0u4qXdsXK71lpdLe5dxvWaA0XrfEmgLF2zvUqOVu7FYElqFF+giY+2u6UFUX2oozYKn9ZbW/pPaXVP6iyl9U+Usqf0ndIuRt+dYKlJGnBd6ian5UUQOCCVY1waomVNMEa/BreDuQ/G2o7zC9inzUrUY/lebGUE0TqmnbBTZqgjV1sKoKVBX+itxXkXrLYndZ6C7znSWuo8Sxl1i2IsNapFkKFFOBZMqvG/J4fRany+J0WayuMVuDOQP8Fjd+SQvI3/Hw7Ah+ozs+7a3mr3/DitPOMXetDiNQl++sQ2BKwDWHtt1p4w2FrfpB/HFNtXzUsiP8KWLBMnWdZPdUp0qhFIllaXRRHFoQBhG3WngRCRxZAyFQLScA96MD8U/JZUlkQeCf5cI2JJB6BwQ1jzPsk2z3LD+wKImuKJIYdQaQSouHEeBpGWRU6rqS4FSzMLQBc5c0ttQ072XWdMDIAUdowbfbXG1EuG9xgwp4QwEx4KXQiiRKjjj1xOEFURixKqXAxI/tNCx1doW8LuGNiLruIKF1vMiJEba541s8A7d4PHrYL5t8j1wT5OjGMqH7MW7hs62H3DIi0A8suBPCNjIWCcYiAb5uQHmCPk/Q5wmGhgpA68biurFIBDI1ReqQsUBuvs4T9bl1fWZdlyJoN3DqJE6dwCrjOHVyXZsi6jNkQ5ZkyJD0aaJug6hNEnVJoi5J0m2QdCmKMUO3FJi2EttZ5bqqPFeN567xPS0A5IEdYSAYqCGxD04LBBJDg+IYoDwqkKxFcqBAU4ouKQN1ZbCHVHcidatCd6NufPmE6kE/qhb6UQWq9gA/tvAt//R3Kdf+hTz9vEghVQermmBNE6rrQnVdqK6P1A2RujFcN0TqxkjNHK1ZmgxUbxiBgB3I1bNiaLsNpqFtjDF3hCy9a61vW3G9G2isXbK0yBxrVzvKdACNAaiTY+r6cF0fruu2kLZLmjC4i2Dur8LY6q8o/WUgBfKi8RaWr0XedjW2+8sKf6XZ3r+FfGW5ryz3lWVe+AWyY7VdlWZvcINWdTSrtLfvbKYMVJWBjv6rcn9F5q9IvRWptyLxVETuitBd5rvKXGeZ4yix7CWGrUSzFqnmIslUIJoK64Y83pDD6XOAcrD6Aq7zl7T5t3vTD9X4ax7R+i1lrqw3DTn3CH06jECtvrPmX9gVMPE0/9pu17anjezbs8NumXq0aTdftZq1mmcFz3Ywn8F4gVYmUQrEv6bcALmOsLp8w34GEiYRG50YS3h9AavJYpQbKFl8SRJeEAZAaNEUEv87JwgsiMJLsjjIOYkFYNrSYSusEHsMrdxqY1tDMAjTsB4hzh3EvAdCu3o5N9tNIA01rsBam/dtA6NKr7WAWhtVmLqvf/kWd8rcdXfMWz883Y9E2/1t3aXzuO32y62NneZudbqA2x/X7tNrHVTXTUQaE4HMvdTcXu4WCValVWRzhWypkC0VshWRpUKBVYZlLpPNRbKpSDIWSIYcUZ8l6jPrujRBmyLqMyRDjmLMU80FijlPMeUoxizFmKWYchRTjmrKUU15uqXAsJVY9grHWeW6alxXje+u8d01vqedgbw9GEjcZKB7A0CK30cAatJPrlxXdXm+2hQAqqoDVXWw1gSgcF0frhvA/5GaMVIzRWEGssbq1ljdFq/bEnV7ou5ItJNHtxJ3qZ7s0m2J6QkxPWnGEusCmtgWtplIJ8fAKBOp64C6ISZU17bcg563WdVQr2cOFqByf13pr8v9NZm/KvNVZN6K1FuWessSb1niLUm8ZQn8tiLxVuCNnpLYUxK7W+QpiT0lCayyxAN2L0u8ZbGnp0piT0nkBiqKXEWhqyByFcEWuA3cQ0XsLbc0bkrsKYnhA8HnJoYPVxJ1tPeURB64vRhu39ISaS90FQWuksBV4rvKPFeZ5yxxHCWWo8SwlejWItVSJJsLRGOeYMzh9TmcPovVZdd02TVdbk2Xw+rzWEOhdXVV5x+slp4TebVzju+9veV3/x6iT7sdiGSptQVTb3/O2zRrqmeHtS712LF7tmuf+To8fRUkj1ERpy8AL0zTuabL47rAopMqTGW8oYCDQ0k2mkHWIJxWFluRJ1BIUA7OUITRtu0Wt8JK17i67Dewg6wDSsztns3bv0FI/icCsDPp84ibLIdDXGm97Cjb3IJb3NZb3JTb233rXboOsfVDu50XuPW5vd3HdbtzIyEhd+QWIcetkqxbimyt9RTVWqNaaxQbUJViq1JtVaoVqEKxlCnmEsVSJJuLJFORbCqQjAWSKU82FSjmItVSolnLNGuZZinRrEW6pUi3FOnWEsNaYthKTHuZ5aiwnVWOq8Zx1biuGs9d4/UEoF5GIPFdGIE+fQBS/S4BEEI/7VHPCm9J4eshpa+s9FdUgUoPAIIxCA5ERRiobo7WLbG6BSGMnkRy+4ByC2Tp5WBq8zRtbZvp6WMyRuqGSK0hPSIdULhN2nDTC6NuKNiUCpESkQIoUJP3lL8m65IUyNeUBJHYWxF5ykJ3WeguCd0lgavIdxUFriLfXRK4y0J3WeAuC9wlvqvIcxaacrTIWWxRqf1tqwpcR4FrL3DsebY9x7bn2LYsy5pl27Jse45jz3MdBW6zzwLXgbS0wW1AM469wAUHdZXgwzmaPTc6B6859jzXXmjtmesocFpb2nIsW45lyzNteaatwLQXGbYC3VqgWQtUS4FszhNNOYIhi9On17TpVW0Ko9lAqzfQ6hRGk8ZoMhhtdk2XwxoKbWvLPyVYua+e6NZOGK2+jHVTZR1Z8tabKprZIwstuQPSjdhbOHeAvoDvoKg7OU+ipWFRaHEYIUEtn8i8105y7RcBgZ677vy+urQVzZCtNbJtS1G2ELVV9hrVXqPZazRbjWqrUq0VCsAga5liKQFRLSWqtUyzVui2phi2CsNWYdoROapsR5XtrHGcNa6rxnXDamUgQS8GagOge20E+n3ygsH001zx3rLcvU2eghzIW1L6yspARR2EAUgbqmvDdV2org3VdaFmOKohUjMgDGGK1k09rSld4S+mT6xWdukZK9Owzeg7jDSRDh9TTdvONK1Yo+qmmQAsBaIGx8iAGuzir0mAfG0Cjyl4ZEVdgune0yaBGxbfXeW5yhxHkW0vsu0Fli3PtOXo1hzDlmPa8yw72F5k2vMMW45uzdKtWbolSzN3yQKLbs3RLbnG2zaZs1RThmJKkY0bJEOSpE+u6+IEbWxdFycZkmTjBsWUppoyVFOGZs6AxmRTimRMkvRJkj5JMiSRZimqKUMzZ+nWHN2aa+k5TTGlyKYU2bgBy5SimFIUU5pqSlPNGZo5SzNnQMtGM5Jhg2jYIBk2SIYUyZgmmzIkY5ZozKwbMgRDBqdLr2k30OrkijK+pIgtyaML8siCLLIgiyzKY0vKxLIqiVKnVrVZrD7fCkCf+c/0H4TabTlb+Wi2nPh7wRMS6tQIFindwjxzhyfZOM9W/84nopNOZ1C3A/HTNB/+QWo7Btoag24NQA0GAgAEW4MqsGwVqq1Cs1XpdliMFjEdsFiOGttZYztrwPYDzD/dANTJQLdhBJK2M5DsszAC/S4AEEw/zWyHjjSQxJGWODISR0bizEicWViunMwNAxCIClIHa5pg05XTCERFVuXAsSyGCBLssnUwb08X0jbSd+t2Imbax992QZv3BiGbQE0VuAOskSAS+9rVzTGAXRDxG0Ke7FbB1O9qqvF94DhrHGeV46yyHBWmrUi35qnmLMWUJZsyJFOaaEwTTWmyKUsxZ6mWHMWcJZuyREN6Xb9BANJt4GEl24Q0wLcK+RSnTWA18VVVFK0KoxTBFXlgWeZfknqXZf4VRQCtCq+qomvqGFYTx2riOG0cq4mvqiJoZWhFEVhRBFCKIFoZwqjCq6ooVhPHaxMEpH/QeE0dW1VFV1URjCqCUUVWVRG4Q3UMdIjXJnDaBE7T2ji6qoqglRGMKrqqjq1q4mua5Jo2uapJrmqSGE0SpUosKaIL0vCsJDgt9k+LfFMi76TAMyn0TYsCs5LQvCyyqIivqDdWtVmcoYA3lQjmMtG89Yx7X/dcWzk+bmfWbw8laQ8caQSjtFDUJ7mtnQ6ye+fW7O2H+pTdpvd1T01BnQxkq9FsAIOAqlRblWav0RExEDHtNaajxnTUWEDOGstZYztr7NYf/C2MQD0dYd1GIEkHA30SL1gvBvq3BUAw/fz1A1/PFisCS0JgSQgtSaE1KbQmhbak0LYhArKnRPa0yJ6WOLMyd0HuKyn9FVWgqgpW1cGaOlTXBIFq7atygEGorgu32Fe6bC13qu74326s6RlS03H1OwJokPvaw/EkbXE53cJO02qYAXIj0WrgeXXVeK4tUMZVY7eLBeRsitkqR43hqDIcVYa9QrOWKOYC0ZjF61M43QZWl1zTJle1iTVdEqfbwOvTBEMGr0vjtBtrmgRGFceoYkBoVQytjKGVUZQyilJEVhSRFUUEBd72UGRFEVmWhxak/jmxd1romhI4J3n2ca5llG0a41gm+fZpoWtO7J2X+Bak/kVpYEkWXJAG5sTeGZF7WuCcFjinha4ZkXtW5JmX+BZlgWVFGK2KoZTRFUV4SRZalAYWJP55iW9O7J0VeebE3nmxr7W3ZXloRRFeloeX5KElWXBRGliQ+sEu8xLfvMS/KA0uykNLisiyIrqsiC4poovy6Lw0PCv2Twq943zXGM8xyrEPs21DLOsw2z7GdU7wPVNC36wktKiIo9SpNX0eZywCO8H9Kecz0C1DRm5jx+3CUD7zAd7RcD7z0/iD0b2yA23pC2sRTD+OGt1RY7QIABCz5TcfAFArA/UwArUz0G1GAt3CCBT47XrB7gqAPgkDwfTzVw/8LVLlNMozRXmmGN8U45vifHOcb44LzAmBJSGwJgXWDbEjLXXl5J6iwl9R+WHzDzCcqIN1EOCiaahxpF6w0tAdnXHvS9DrsnYECHfcueZ9bbvliBWnl0Oq2wnVZrnpZa1pwxpnje3shTKOHoK/DC1/GdC7ZavRbFWKtUKxlknmAsGYxepSGHUCrY6jVPEVVWxZGVtRxdHqBEa9saZNYdQbKFV8WRFdlIUXpCGgeWloXhqclQRmxf5ZsW9W5JsVN+SHJQkgDfyzYv+00DPBc4yyrUNM0w2G4TpNe42ivkJSXKOoBmi6IaZplG0d59oneI5JvnNK4JrgOcc4tmGWeZBpHGQah5jmYZZ5lG0Z59on+a4ZkRd0PiPyTgnck3znBM8xzrWPce1jHNsY1zbOdUzwnJN815TAPS30zIi8syLfrMg3I/ROCz1TAvck3zXJd07wnOM8xwTfNSX0TAt9s+LArCQ4KwnMSAIzksC0yDfBd49yHIMs602G+QbdOEAz9NP0A3TDTaZ5mG0b4zmnhL45aXhZlVzVZXGGAt5YWjdX7of+3Nd9/UHp3zAD3coIdMv18HfqBfs3HQaE0M+X/iaTL3P0IY4+xNGHOYYw1xDmGiJcY5RnivJNMYBBfHNCaE+JnVmZp6DwVYD5p5t+WoJ8txhSy2jv6DL1XPfU0y7Xes867miruU+KPAFN0OmmHG+bY/U2QacbcVofbvC4g0e/4/sAviStX5utvloka41kqRAt5XVzCWfIr2rTKFViSR5ZlEdAUMu8NLIgiy7JY8uK+IoysaSIL8gic5LQjMg/LfRPC/1TQv+k0D8h8I3zPWM89yjXOcp1jnIdiJxjPOcYzzXOd4/z3eN81xjPNcZzDbNtNximfqruMkl1gSA/j5OcWROewvDOrAo+xksvE5XXqLoBmuEGw3STaR5iWW8yzQN0wzWK9gpJdYWkvkrR9FN112n6GwzTEMs6ynWM893jPNco1zHMtg0yzTcZphsM0w26cYBuBJ0MsizDbNsIxz7KdYzxnOM8cCbOUa5jhGMfBoYctnWIZR1m20CHk0LvlNA3KfROCr2TAu843z3CsQ8yLQN0Qz9Vd42ivUJWXyYqr5DV/VQdOJNxnmtGHFxUxDHaDNaQv08/93Vff8j6nWAgZw8G2gqAekdDb2EEuk0vmOz31wsG089ffvFr6XyZpQ2wtAGWNsjWhdi6EEffxkA8U4xnjgutG2JHVuouKOD1X73pR7UN/dwV93wa6CNpQR9AxN1Rxp3c04I+t2PgaZh2OrnHsTX32G/BPY0vG8laJVoq6+YSwVTE6rMYzcayMrYgA+ac8Lw0PC+NLMgii7Lokjy2pIgtyqPz0tCsODAl9E0KvBOIxvieUa5zmGMfYlmHWNZBlnWQZRlkWQBMjHDsI1zHCNcxwnGMcOwjHPtNphmgz8d46dk14SkM7/gK+6MlxvEV9mkEgADiDNANNxmmAbqxn6q7QlZfWldcIiouk1RXyZprFO11Gmx3GeU6RziOIZb1JsM8QDNcp+n7qfp+qg5A0gDdeJNpHmw5GUBpIwB92LYhtnWQZR1kWgAnjXDsYzznhMADi+8Z57tHuc4hlvUGAz6TyyTVxXXFBYLs4rriClndT9XfYJhGOI4pkW9BHkVr0g3n1336ua/7+kPWvQ+Ltm/NQI5OBuptBNqWgbaJhr6FEegzBaDfvhesjX6Yah9T42dpA0xtgK0LsnXBVgDiGqM8U0xg3RA7MlJ3XuEtw86vLvpRBbagn3to8tkCfeRburTa0afb5OP7RCYfdpfJh7Ut99Dvinso7d8xkrVKNJcJpiLekF/TZVDq5JI8OicOzImDc5JQg34WZNFFWXRJHl2QhuckwRmRv4E+43zPON8zynMNI/BxA9hdGMYbiN0FMBAQsK/coBuvkjUXCfKzayKAPkeXGB/MU48uMU6iuWexoovr8ssk1VWKpp+qH6Abr9MM1yhaABwX1xXA4nKVou2n6W8wTIBXhtk2YCIChpmGGggFzD/DHPsIB9BPE32GEPQBJwxwapzvnhB4JmCrlXuE6xhkWYAJ6jJJdWldcYEgO4+TXCDILhOV1yjaAbphmG2bFHrnZRG0JnWffu7rvu6rVXfEQLe2A/ViIPq2DMTa2hF2l0Yg33ZGoN97L1gr/ZQYah9T7WNqAkxNgIXQD6eFfrjGmMCaFDnSElde7i0p/BWFtyxyZNiGCEsXZunCbH1YZM8ofJUe9HMn6KPwV0WOLEsfYerCDF2YqY8IHVm5v9q4oHdq8pFta/LZJqbn9k0+nQE9t+fq6uaeW5p8mvRjqaybSnhDAafPrWpSK8r4gjQ8K/LPigJz4uC8NAzQB17XLQvPS0Iz4uCUyA+jTyv9sO03mRZAKtdpeqBW71XTJsS0XKcZrpBUH+Olp1cFJ1Ccj5aZHy7Q3p8jf7hAO77CPrMmBEhxlQybf67T9MDtdRGx/Vwhq68B+qEbB5kWEIB8g2ECLa+SNVcpGoR+YNtP0xDFcYxyHSMcxzASuTzItABuA56yIZZ1hOsY57sb6LMN/XyMl14iKq9SNNdphiG2bVLgnZdFUJrUmj6HM9ynn/u6r/tq0ydnoG5H2DYM1O0I62agTxIJ1Dsp4hYAdFtGoH87ANRFPxo/UwOcX0G2Hji/Ilxjg36ifEtSZE+LnVmmLoQTWBapikWafImmWKIplmhK8GKRKl/jG0lyF9sQlThz6uCt0UcZqAHcIcnda3zTItybcpGmXKApgBZpSpzIxjbG5f7ap+TtkgdqmxB0X/d1X/f1u6+e0899fXKJvTWWsw16WM6a2FtTBOptq6W65b9dtU1Sgbqsw3GxFVsgJpY2VuiY+8OwwAKjjhXT+jCcIKY1fUx3WUlTrKmO/Hw9kwm3yhrrkZf4dhIdN2Rv1TalqG4l0Js5WteHb+n56kIfjiHcij5cY5RvSTA0gRWmaomuXGKoUEzN9UXeu1cIP/mQ/Nz7xBc/JL17GX99gYfh6jEcHZqtQ7O0GLYOL7RSlV6aOsA2xtjGGM+cZBtjbEOUovSSZC4s34xiaVEsLZqtw3D0GK4BwzVMrYsHVuhXZgmXpnFXZgnXl6gTeMEKU7vM1GJ4Jq4l1ZN77szb1WXy0YdrmxD066Nnnnr+J7Ce69T+W+nJbj17l9q3nX6875kfP/HMj544+KO9B3+498AP9hz4weNPv7D7qecff/r5x59+4fGnX9gDNh54Abx9/OnnH3/6+d1AT7XquV37n9u5/9nHnnymQzuffGbn/mc79eQzj+47+MgTTz+896mH9z71/T37v7/nye89/uT39zz58N6nHnni6Uf3HXh038HHnjwI9wD3dvDRfQcf3XfwsfaPdu5/dhfc7bM7n3zmsScPImprsOup5zrVcj47208YtN/91HONMTbbI4d4dN/BjvPctf+53U8/v+fAD/Ye/OETz/zoiWd+9MQzP972FtzXfX1m2oSgz/wcfi/15pEzcySxxNdGPxJfbY4kfvPImbvu9q5nge4J5ZZzUPe01ZzR2vX07enAXeiFHjr4W9fhIyeXiVxz9Daintm6IFsX4hjCiNUnyjNGeQj6cAwRLN+0SJEt0VWLdM1rp/D7DxGPD0nRdDtXEZDpwjxlAMOwnxiWPvU2+Rcn11a5lnWxHS+04gQWLN+8lXACC05oJYjtRKkLL7bfWKZfm8XjORK1xe0MhN2hqDMQVltceJbkyjT26hxpmalFcwxUVUDur91bb5clVt+EIJsvVqltfnoq3ytVN8vVOlAJqFJrqrGxY3svFWFVe6nWpWqxXC2Uq4VyBVYJUblSKFeLDbX2s9X2jp63OPoWJ9xzrx7tew+z7WSa1w25qpvl6r27Wfd1X/dUmxD0WR36Z6+9/nvclckTO/ThWXWo3ko/6lD90IdnTZ7Yb+Hyfqqzz52q+m9crkD82sicNX6rFe9sfYhjCHNaoIdnijXEMUTRLO0iVY5iqo/dpOz6FWGJ7jA4kwpDhCX2EVlOAsNBYrs4Ur/GHDN7UiiWc/evCOeneHR1gKryUZU+itJLVnjICg9Z7iYrPBSFh6LwUpReqtJHU/lpKv/UuuVI4wUAACAASURBVPjaHEFl9yZypUSuWChXC6WmErliIldS2bxXprFDGPaawEJUeGUIAN2dt6sjwNkar29CUKW2mcjXgeJbKNaq3JaK3rki3cpupVooUw2lK8FUOZAqBTZK/mTRlyz4kkX/Rsm/UQqkyoFU2b9R8m8U/cmGSuBT/0bJn4R38SbynnjOHcu6WuSOZd2xrCee65A7lnVFM85Iyh7esIeStlDSGkxYg3FbMGEPJx2RlDOadkUzjR6AXLGsK5YBcnd2nvfEc+44aJbpPHQi703kvYmCN1nwJgpe+G0e7AXOp1WNXXzJAiJkjGCYPXeJ572Jgj9ZDKTKwXQllKmGM7Wtr/x93ddnrE0I+qwO/ZOXX/897qpS2zzwg5c17fSjCdUP/ODlSm3zbvrs+km/i3lhm1mmdTLaasJKbKFkYRttAm1so2JTqd9JVeubR09dsG1LP3+bKVS4xijPGOOZY3xzgm+OC+AcP7BwAvMyXY5ma188svyLfpHCnmSIfXNY88ii7vqM+uqE8sq48uqEcmBGPbqsX1q38hQBrSf9q+vi107gaOrALdU/T0Ezxf6NfCpXTmZLWymVKwc28ii6+NIMESuyUzWh20Of2wpwtnXRT6tui4RuxUOfBIyiuXo0CyuSrUeytTCgn3Q5mCoHNkoBADobxcBGKZAqB1PlJhg1tiNUFGjZpQFAHfImct5E3tcibyLvTeQ88awrlnFF085IyhHZcIQ37OGkI7LhjKRc0bQ7lvXEs43dEVjp6Bb+qLXn9jbIp8mCL1nwJ4uA4Xww4RV8LSQEOmzu1WjfKrBjc5emwFHA9Qmmywj6wPRzl3fqvu7r09QmBH1Wh/7JK6//HndVqW0e/OErunAb/ejC9YM/fKVS2/xUL+ztTBzd082dEk8iX09sBz31jTZ1Uk6H7g5K0r8tVeubH525tB39/PUDX88UKiChs9C6IbRtCG0bQitQUmhN0pReNFODZml+egz9zqhCaI7Pr1v7ZzXnRhQf9Ut+c0n49sf8Q+d5hz/mv3dZdHxAcmFMeWNBi6I5VK7Ub8YUPz9LomuC26h/kUYUadyxfHijEGlXuJdcsTyep7o8S8KJnRxz6q69XR1r2gH9VGubiUI9UYAfFOa2/1K58r3iodsU/FXJ1iPZWiRTDacroXQlBLNOKZAqBVKlYKocSpdD6QqwDLVsLwVT5WC6EgTMlG7gUdGfLPiSbaDjSwKM6BRAJW8854ln3bGMO5ZxRdOuaNoVS7tjGU88603kttm9hzaKSM9dx90oBoCQIQQ2SmBLY6/u3lrbB1OlYHPfVhgCjQsIFxaR61YJZ6qRbC2SrUXvo899/a6qlX6sEQFW98NjtP/0IgZ6AQ39dO1Pr4l/qAmKP6VDv3jvkOV3sKtKbfPZH/9MH2mjH32k/uyPf9agn00ydEe6+x/822adW6NP4RbQ08U97QBUuHsDzC0ZJVWoZ4q1bLGaLVYzxdqtsaZ0u6rWN0+cu2JL9FgL1lblVGRPi+1psSMjdmTFjozYkQEVTwWWJE5gxAtMp8dZP7rAp+tiw6vGc+Oq966Jf3me99MTrB9+wHjuffoPjzKfP0L/0VHmyyfZb37M/2BAenFKPUWwCG2pn1wQXJwXMbTBnpomSpboEms440/kA8lCt4JdW3yJvDWcWaKKxvDidblX4qncAn1ub027PQHbfpKF5kPDZDKrlUq1WqnVqrVatV6v1eu1arVSr9ckEgmZTA4lM9vZhO4d93QajbK1SAY2/4TSlVC6HEqXW7knnKk0PgJ2oMZH7QKmI4AFXRgBq9QigA7AYJPzxnPeeNYTz3rjOW8i50vm23cvbaNgg05amabloMEmscGs1qLmvsGWrlpG2jrexu6lXmpenA70uee3777u655oE4JiuXognZ6XP3mWDk0I//gM8X87NAd96zy0cxb6hyHom5egU6xnAqncPT/0i6+83r0xVdzMlXsrVdy8o67gDvOVXKGUK5RS+cpdn9VdqFLb/MFPf2Fopx9DpP6Dn/6iUoMH0sCaAr7v06UfoE/IPbfl59oCfYpAd2bpuSPzTLZYyxTKa67EaU3ooi5M9CRzxcqtGei26ef0hX5AP+qe9PP5r3wjV6pJXTmpKyd15WXuvMydR97mmJogUeLACqz/9Bp2VREdWDMdHZH/6pLwxyc4T79H33OYcnhAEtsobGRKb14T7TxE3vtr6sH36S+d4h66Kj45rhxZt63rEv/8CwJJ6WPoQh0iq7yXZ/GGQMobz3vjeU88726RN56PZUqxTMmfLDQ2ekDLWF4fSF2axuGlbpYpeUferq3SGNoSPTxfDAajUil3A1C9XuPxePl8nkyhBGPp3w76xDroB5h/MpVwO9CEM5VwpgqryUbgo2qXmiaircigwR8ISDVgpWEQgqEHbG+lltBtqIVsWg7aSTA9uK1dHVegTVt30rpXNZJps/p8Gnfwvu7rk2sTggLp9IriG97kf9zc/OvNzT/b3PwPm7W+YBB6+wb0jYvQAx9D//7n0POL/+2eA1BPzsiVN7+JNX2TYOnQQwTLNgC0NbLUcoXSQwTLQwQLL5iK52p3d1Z3oUpt80evvtFNPz969Y0O+qmTod27d//sBzuWT33x06Wf3J0B0HaBPnfBQMU2Brq3AJQp1hzx3Ask2/+Y1zX0OsMZShfuCQBV65tnL9+wJ3pkA0Lo56vfzJXqcm9R7i0pWiT3FqWuPFXppat8b1yhHV0wjlCd740oXrsoeO4Ya8+7tO+9RXr9iqBYrm5ubm5ubq6wnd/6OWHHr9Yffou07z36D06wf3lZ9NGEao4fOL5iPnSFxtSFW8XQhW+imSy13RXJ2SM5RzRvi+QaskfznkQhkikBuRMFezRvi+Ts4Zw9kreFc85wjqGy30CxyeqQ2FvtWNZ+p+jD3YJ+aDRauVzqCUBkMplIJBKJRDKZ3M09vlj22PGTBrv/3v70xJr0A5xfAIA6FQETeQsDASSKIBM8sm8tnKmaPJEHv/GQyR3ehie2sic1DTAIuHTsi/BHD+pqqjeLbLVjdw/dY2/Ttp207tjp8NrmLujt/veOfKD/FO7v7SiUKl+80v/qq69iCJTf2ml4Y9nTZ897Y9nPZMif7Ql8qrdbINddvNIfSpVvf5dNCHJED2xufmFz8/nNzfc2N1+s1/9npfx/VgpQvQDRmNCfvwP9729C0LPQz9HP39uz3Yp+HkIbug3kD6END6ENWwHQVsiSylcGVMH/vqD/hLafrQxI2xiW7pR+du/e/ZNnv3Nv6SeUKh0/dZYrUXd+dK8Y6LcCQLdkoFShnsmXfrxs/Pt++YsrRqw2vKwKHpzT/32//E2sJVes3BZC3SH9NBgIpp8vfO2buXIdlO5qUVnpK4vsaaY2yNAE/uHltWFu8KNZ3WtXxM+cYO98l/qvb5JevtREn83NzUWW8xsvY//uZ/h//Dnhu4fIe96jv3CK88t+yZklw4wk+q3X8QxtiKWPADH1EbomeGWWoPIkLeGcNZwzh3PmcM7UImc8H0yXAoic8YIpnDOFcqZQzhzKmUI5hTt5cWadrA7xHfk79nZ1VK5w9Y56plKpzmhq2ZhlCT/Is75Jv/Bl6oU/31AfBd/wgN/vcjob9NNq8vHFsh8dP3nPfy71dv9Hx096Y1lg/tHZvB8dP+mOZADrINBTgxEH2dg6u3fL7Ik8+M2HTJ5IOF0B6jQg9YaJXsiSrmitnjffOvTqq6+++uqrfJkGnIw7knn3N++9+uqrb751SGvzgo1aq7e1JejWHUk3W1q9zbFka1prc7CBjeLFK9dGJmZaG/RWZgv1atwR67P9jbjr6dAby4Ixvvrqq6OTsw2c7a1eH+HJTLDj7ZxG6+EEct1dP3t3AR+Nx/WePPx3fQL2QPLilf5PMvbtr7O368uut/uvD46EUmU8mXnLK3939LO5+X9vbj67uUnb3LRtbuLKpR//85E//ud3+soZaDMLcVjQ596FoMegP34D8kbF9+T6A21JP0u6arXSoYeWdPl8/qElXU8A6tlVPFcTOBP/84bihtB3m+iz5VkVStFz56Ln/n/2zjs+jurc+xNuIMnNhXuT3HtjIDekQALJTagmdmIwkJA3Nw0TmrEhBmOKwabZxrYMxLZkY4IlNxWrF6tLliytellJu9pVL9t7nZmd7b2X2fePszuaLVqtcUvZ+fz+GM2ec+acM0f7fPd5npn5Kxl0APoQx+OqBELhbTt2Cwwx9CMw4Nt27F6Ofv74xz9+PvrBrL7so58+F92yj36K2XxGF84Wq3ft2Zt8nV8VJ9DViYI5vKEejm7N8amttVyH2+fwhhyeoNHu2VCysOb4FA+xObz4JQJQEA8fP1OSSD8sEv3c5/bji2ggqiDBQEyJlSYw1vbzH9rZc2oQfrtobvMn478/QF3/ft8reUyXN0CgD2xw/WJX7w+3Xfjf1zvv3d71s53dj+3qf+KjkZeOM3eVLpQydI+821s7IBjjG8b4hlG+YZRvaB3jV1PoEp2Lhzl5mJMLpHUR4utdSosHsfkisvrEBjdX6+JonByNk6txirWuKsp4C108Jnak6fJJ8eaKpPRzsLznoRZH04UXxH0P5L5zzwMfLnTS5pqrt5F/5fT29iaGuhK/EI0uXGv3n4h+C5P301dX/0hX/whhLyn9VEo/dQUzH+vyibOjemdIDBvuvvd+kVqfxBeSAiwciXQVBJTDmGXrnSGuFD7w4cdcKYxZfXmn8in9VIMTZ8xy9mcdUBucaoNzf9YBxixH7wxxpQip5BkwomhJB3FG8mC5Uviz3BOHso+AAob4cYUMKXgoMg9xijhUmHOc5dAnWuDzG1GjC2fOcQlbaHDhzDlOVz810gcHSYk9JH1UXl3b1U9NJ0IH0Cey5Gz+0spzn5tFUsNH0skBy/VSpuuydOCyXLjUHVuOfowuvLy6LvUkfF76WRUOfxAOy8LhUDi84HW/c8OfIWgT5EWgsAEKGyHFDFRWA11ohryGP1/GwS5HP/dXzifSz/2V84Rc/rTox+YOFNHUa/Kmz00hFneQfDyFK2g5+tEePQoE6lqcvriDcVUCofDr7+5LpJ/X392Xmn52v/pQQ84PZHU3pk8/ZMphi9U73n6HLVandRUuRybQNY+COb3B3F7ZmhzG+RmUiHM5vcH8ITk46Fwp+HVnsi2Ofk4WVaRLPwtoYCGWfpgS68H8vnVv9B1ql72UN/nkYdov9w5tOzXp8i55fZzewEunJn57aOT3h0Y25Iw9fZS2+TPG+j2D/y+L+vQR+rbT03/tVa9/s+9gQd+YwDAaVUEztWVknoc5WBo7S2PnYA6u1snXu4B4OhdX5+LpXEqLR2X1qqMSGdxszLGI2hdQO1vjaKHO57fQx8QOMvoUdXG/eOfGRBVQuCle2hVHPyY3PiKz3VrpGhh4Qtzw7SOvfndD7oVn2eH/ekf5zIc5oWAs/aTxhWiMox/bRdMPuU2DC1cbnIeyj3ClcByLLK9Y+okiFEE/8YUTgSneSxGPFGqD41D2Ea4UIe9zpcih7CNqg5NMGNHOI6SBkEq6SCzixA1O0mAdIb0jROmjUvqo5VW1gJ+W7VsyZ0/MWEha0UZeuhEls8hSb0H37MF4kSKYccfLq2opfVRiICnOSDbDl6iLhY+k/wLXpAP/oPTztXB4E453+H1Mr7vYZnnyq1shaDNkk0FeCeTnQbgUCguhsBgKar93GQe7Iv3cXzyTFINWpB8iILXmE+aaT5if9EiI+BT4aM0nzOUAKK6piOF3eF0eH3rwIBBojfxn0sjXW7s+TKSft3Z9mJp+8vfeDfa3bnq8OOt/F8v/c0X6aaP0FxSXg322WP3ZidPA95OuLpmBri0AOb3B0z2SNQdGz9FUDm+QOPjXTtGaA6OdJCRKH4ASfT9nSqpXoB+XH19A/AtojOYR/6TMPimzv7638q5nLrxbJ/zDIdpPX2757fvnbU5feKXNYHVv2Nu++o2Op48y95+X3ru5642sKvCyC6C/FLa00dhs1DGrdjDExqFFJVtp4sMWvtrKhS082ByR2sxTm7lqC19t4cFWIWKj8zU0oW5G7VhAHG1j7EPFHeMyF/lJhl+8cyPImIvTF+/cmOJlpWT6AStmS9HchZ6n3B2rdmz4ks/r8fm83ysKrW8Kf32LMhgMEADU1dW13Bfihe4BIsBBDkBkH/lkVzToc+JUPmx05p3KpzJm4iIUcf528rekwYUzZzl5p85gVp/eERKp9atuvgWCoJtu+vesv+SsW/+oSu/Q2QOjEws33fTvEARBEFTfSgEQIIYNoDAEQdnHcsVqw9333hfn+9E7gmqj66H1jxWW1RCFG9q6ACiIYSO5hajzBjE4Q5R+at6pfLXBkXfqDKWPqneEGLPs8qpawuMS8Vu48K7+kbzo2IFDiznHWYoERcxGxMYzZjl5p85orF69I6ixeAvOlnIkMGOGHZkBZwjgUXtXP5hASh9V7wiq9PZD2TltlL7IwX4qoB/geQIH92cdgI1O8tUBk8yTocQ1Ys5x4wosChRETIf8EWiNWADtXZEFAOwfcQWXfFQR7gmotLZ9+7NA4X37D6i0Np0toNLaDh1e6n9n75DO6i+rPEeca4YlOpR9BDY4DaRu7Nq1u717AJyIzFtx65PoM+gbQASwCD89nvfp8TzCZoMrJdNYCPiIq544e3HLlQgAkefnqnUgKf0kvWrGZaaRCOFFLmt3zGX9HPRDPju5z8v1Kk5hCArjN4TDPwr4Nzz80Te/+CL0lZegf90KfWEzBD0NQb+HHn4dCkxD4QUoLIVw7EtpGlQo2ZYu/RTPBIOBB46P27zh1QepBPc8cHwcINGK9OPy+NZ8TEtUBIlIfyZSS1L6IQBItXdvnJajqEAo/Pbeg4n08/begytGvp576rd/JG14SvoBYS+Q3AMbnbv27AWOHwKDgGeob4QB4mJtlH5jlJO2bn3lueee27r1leb2roLi8qsdBbtcaUCe0IRAv2b34B8O01Cj0+EJOD0BEWx97AD1ob1Dar3Dnl7kawl9EqJgQTxcUF6bkn6Wsp69c7CPrCmFc1rheunds9B3Tt24rga6Kw+6ZdMsW74i+oDtr0UU6NYt0I8Kv/ZYLfTds1t3ldKEJkIffFpd1Tk+yEIHF9G+GSV1QSlAbALExkdsAjgqtY1PCI6Irba0jwt7F9D+BbSig551opmh9JKjXYVd3C/euXHN8SmyvnjnxnwKNxF9wEvaxxRLz3qOLBerrad0bXjojh0v3H7dr49dv7n6umfLoOd7vvEe/ZuP7w8E/MFgIBQMhELBzs7OpPSzP+tAeXUdGWLI/p64/bxT+cSXHXOOC/bj6Ke8uo7sNiivrmXMsvWOoEilX3XzLXUtnVqbX6Wzr3v40XUPP6rU2ZQ623t79it1Nszqq2vpWHXzLSKVHnDS4WO5RABLtJT1HJPBozY4H1r/6KqbbxHDBoMzVH++a9XNt4hhI0Cf7GO5hPeCoB+9MwSiV+C7W6Wz6+wBSt9wWVUtkXNN0A+RuksMnEhnidJPLaWfCrw45VW1jBk2SEsan2blnTyDmj1Kne1Qdg5ID1IbHPuzDpRX1YKMogMffsyRqJU62779WWVV53T2ADjIlcKgJGGQiNkm20itzd/c3kUY0cQCZHMIWgOzwYwN7ZVX1xmcOE+KHPjwY54UYc5xovQTWnL52AJKzLpvf1Znz6DW4tVavPTJhX37s5Qai1Jj3bc/q6zynNbiYwuUBz78iC1QaC2+sspznb3DenuQK4GBtww2AMrhEBNLhoBEA09Ya2JQiYswDh0I10uK6mTCIJZrYvbPVe5AUrdQ0jUQFygkpjHucsf9X18s/cQhaXl1HRlVE3uVnH6CUDjwpYDj67/K+jL0LARthr6wGYI2QtCfIOgJ6Fc7oAATCo9B4XkI16RLP4kAlFhgOfp54MzkA2cmQXKPzRtefXQsGAysPjpm80Y+StP3s2bvMFkR9Ek4GMcuib1aMvx2j8vjk77zDqEUEbRLoR8X5V+OvftAmvRDQAzYiBznNko/AJ02Sv9zzz0HnEMFxeVgp43S/+ZbO8CS4IjVW7e+Qp9mXVMn0OdPA3J6g2yZcf17vWt2dP1yd9+hcwsfVc6DP6sHJM6oNyhNAEqaBrQy/Xz/rnucvtCMInKL+4zKHZVnRumeVrhf+6AU+p/j0K1vQqu2Qt/eeuuanXLYsCL60GfFP/rVXuhbW6H/fgG6eRt067HtWZV0kZnQB0dKS1pHqSyMytUNs7FOhnBGrBOgdgFqF6A2AWrjI3Gy8xE7V23tmZFSphSDbN3AouZsKzUrr35SHYxL9CmgcL9458Y1uweBUqPPqCI0mkA/dqzBNHlfyQffuu5ne3/+TpXH7fJ63F6vx+f1+n2+ALgRLBgIBgMXLlxIXNwxX9B2f0FxWSL95CXbT/plbYzLd3bhIEik0tt19kBdS8e6hx9Vam2YxauxeM41ta97+BG5xqIxuzVmz8Ejn4IvslWrbhYotXWtnevWP6o2OIkgl0ilu/ue+wRKrUChXXXzzcCBNDIxr9I71q1/tP48BUSOYKProfWP1Z/vqj/f9dD6x2Cjm0hJIUBKrXccys7hSNQ6e4AtVh348CO2SDU+vVhWdU5r8+vsAR2I2vRTgauGJ0PIVmTJ9+PEDc4QiO/oHUGOBD6UnaPU2bQ2P2b1lVbWdPQMYlYfZgUcMKSzB4CbhyOBdfaAxuzJLyphi1UKrfXQ4RyWSKm1+VGzJ+IxmuWQAw0J5pND4FecxyIp/USAxhoBGgB/jFm2Wu84lH2EK4HBwYKzpVwpAk4N3HUgnqWzBXRW3/jkQu6J07DOjhndmNEN6xy5J07TJ+YVqPnQ4RyWQIGZPLDOfqagmMWTYSZPWUVNZ8+QzhbgiNWHsnPUeke05YhXicAsYv2AsQCzDXiIvCUmxxALmGz4AXykU51MPMCo79q1m+zFvJodSPyHigs2EQXijhN/xvl+CPAC/9cXSz/LnWW5XiWnHwcUNkG4BfKbrvMarrMpIehpCHoasrEhLwvyz0I4EwqPQOEpKCj8Qfr0YyQBUNJPl6Wf4+MAfVYfHTNGAYiAoQeOj6eT9xMBoHf7gCLoE/2TrLiUneQJ1G7c5MZ1ZofL4xO8/jqh1PTz/oHsRPp5/0D2cvTz1pZHw/2QrO7G7B0/S9/3Exf2Akk/mNX3Wd5psEO+7auguJw+zYrLhoaNzqyP/hL58+8tCub0BtlSw+NvX/jZtpbNBwd+tq0FaP32tuoevtMbtKWZ8pwyDzqIh89WNaSin8jTDqW2SZltUmaflDmiTzt0zCicMwrnwTMU6NZj0J3F0C1boR+8B929639+ncWVqO12u81ms9lssEZ//8tnoF9kQWv3QWv3Qavfh+5/B7rvXegn70Hfexta9WfoB/nQLScOF/WOSywRiS2fFLXkVXUOc7ERvn6Er+9fQChTsvN03nk67zyN10rjtdJ4FxiCWZmOrTSxlCaW0rQoN3RPSSjTikGufoirG+Ro8yo7j1f0TiV7bxcAoPueLQbokzTaRaDPSCL9CLbZq2+57TfboZ2jj3zaxhPKmke4L40E/9gZ2pPfvgRAgUBra2vi4k76LXkp9BPjF3HilD5qWVWtzh7Q2vy1zRcA7qAmF2py1TS2/eKh9VLEOEibuvGmm/6SfQw2Oofo03f84E6+XFPb3LHu4UdVers2enuXUKn96T338eUajcULhFm8mNWn1NnXPfxoXWunLuoKWrf+0fpWSn0r5aH1j6qNrrhMI509MD4DvDJurc2HWb0AU2hTC7knT8NGF2b1oWZ33skzjFk2gSAgbQVYCGCzARxorN68k2cYMyydPdDZO1RWeQ6zejGLR46aiAhRNE6UpdBagR+ILVZpbX7U5M4vKmEJlXKN+eDhHJZQgVl9qMmdH6EfdpyNKSgu48kQcqYRV4rs2rUbxN0AaMKGZPRjcDKXgCaotwc1Zm9BUSlHrFZpbYeyczhideTg2VKuBFbr7Ieyc7gSWG8P6G0BnS2gs/q1Zi99Yj4375Qas6J6J6p3qjW2MwVnF7kyOWw8eDibxZNpDC61xnYm/+wCR6oxuEorajq7B7UWP0ekOpSdo9LbGbNsIgwKcsaJ6TWQ1iRwOSRNNEnqOwFZw0R8h4CPFauD5ZpYADDQVe5AOvQD/kM/H/2kbv9S6Ae0n/j1EoYg2QRU1gi55VBYD4X1kFcBQU9C0AbIy4bCbCg8DYVpUHgMCi9CHvWrSQ1wCi2HPsZlOMPiidzSBWJeqw9SjS6cOAL2LZ50s55dHt+aNzvJGT8uj++T+sU1b3aC4+n4foAA+jD/8Ic4pYh87fn4k0T62fPxJ0np59UXfskq/8bx9+97gsQ9L296nF5wS4q8nzi4IbCGLVZ/lncas/rIoENQDhmYjLH8FNEVZqDLBUAOb5Al0j7yctV9zxbvOt7vcPkQrW1kRk5fUOnNzktFHxIDBfFw2bmWVPQD3nTBEJkZIjNDbGFILEyJlSm1TUht03LHrMJeN8C5btWeLz/YDt3xLrT6IPTYCeixY7duODa5KFBHN55Ies+2ImhDBfSnWmhDNfSHcug3hdAjx6H7PoS+t/Mr97dd980djVQhU2pjSmxMiY0hsdX3z7378Wmm2EgTGEZ4hhGenhCVpx/m6joYwgkBOifC5kTYnFg7I8K6J8SUaeUQVz/E1VN5errI+PaHp1rHBNNI/G3t4N4uAEAE+tASol0E+ozII+94J+jHwXi49y933/7CWWjP9A294YdGQ7+cCv93T/jLTxT29g37vF6/zwseBdTS0pK4vlf8lkzcJ76su/pH4iJfMW4JJw4cDOMzLK3Nh1m8fBn6zVU31zSehw0OKWz4xUPrf7FuvVitq6pr+fm6h8UqnUpn+/jwJ99cdTNXivBk6KpVN9c2X8CsPqFSm19cyZdrA7aYWAAAIABJREFUfnrPvTwZgprcqDkqi0ehta57+JGNm7dorT6t1X/o6Gerbr5ZqNQKlbpVN98CqEio0hWUVBFuHrZIdeDDj1hCpcbikaGmffuzxibmVDrb8ROnxibmNRYPfWox9+QZjcUbjUMhRMIKc5ajtUUcJ0sgZXIjJlfuydO0yQXU7EZNrjHm7L79WVJYD0yRFDHu259Fm1xQYBbg5sGsXsTozC8qXhTIZajp4OHsBYFcY/EiJld+UQlHogY3phG3zhFuEjDJII2aQeRUOUOUfioIZhFXwejCeZEEbYda79ifdYDSOwxQZnxqMe/kadToUmoshw7nsIVKrTVCYxyRSmcLdPYOvb9rN0ek0ln9WouPPrnQ0TUgVxv37cu60NmHaB2I1jE2PnM875RaY5WpDQcPZS9yZajeqUItZ/KL5lliVOcsLa/u6BrAzF62UHnocI5KZ1Pp7PuzDjBm2CAvKu/UmYjZliJ1TW2G2DUZF3lpbu+K82wB8WToyTOFJ88UgmVMDjylrp7ohpnhiMnHr3IH0ol8JaZJLRf5Svy/Jv/PJjZO0A85Upb0LMv1KvHrJQxB/3cCeqMO+kk2NNwHhVWQXwT9ajf0q/cg/zwUnoHCDCg88oXw9HVhwRdV+rnlUOZzKMVzBcnpPg/u7jO68AezBkH866KaSry9y+IO1nRzH3ypvuj8YjpZz0Ag5tX0wANAAJvIfybNes7KPp5IP1nZxxPpZ8dLj5zac++GJ/5AcM+TG35fc+iuuGdAJ3aMDDeAhIhoF7FDkA19mkWEvYi74unTLHK8bEmX5XawKwlAdi++wIfXPPPXH/3m8M5DzQ6X1+4J2b243Ruye0KXh3uiCuLhyob2VPTznR/+xOEJgLe704VGutA4LjKNi8xMiWVSapuR25hCwx0PbP3a/w1Av66GHj8NPVkNbWyC/lR+6wsFA/QZTnT7sLwfeu4c9Eov9FIP9EIH9Gwj9Mcy6LFc6JcVX3u8/66fv8WUWidkdmZUdLF5w+Z3RljqMaFxTGgcFRpHSTt9C3DfjITJUwMxuKrOCWH3rJLKNw7zDcMCwwjfODiv/NOf35uBfVPIyre1J3X5EOhDTaSf0bUVr307/9Rnd7xR8s2PW75fJr4lZ/yhvbVU+ozH7fZ6PAQAlZWVJa7vFN+SRJIjsQ8yf6vrmuKyHYmvS8KRDkJCXClccLYUNbkxq1djdqMm1xBt6sabboIg6Mabbvog6+Ofr3tYpMSECs3P1z0MnNhPPvXs7T/4IVusAn4gkAq9atXNfLmGJ0N/eve9XAmMGJ2I0YkYXYjRhZhcMo35Fw8/8sKWV4jAGfAPYRYvlTFHtCBQYCyh8sCHH7GECszi7egZJLwyo4wZtd4OGxzzPMn7u3ZF/DSYVWcP6B1BSh+VKMmc5RiiD/UBDwHatz9LobFoLJ5FgfxMYbFKZ0OMDlhvLy6rLC6rVOlsQGq9vaS8qqSiWoaaDh7OWRTINWaP2uA4U1i8wJdJEcPBQ9kLfBlqdsNGV35RCVus1jmCIPWHmG21wQnODrqUd/KMSmfPO3kGFCitqCFuraf0U8ElWxDID2UfUesdekdQpSMnLGcpEBNmdMth08FD2Sy+HDN5EL0zv7CELVBozV6txTs+uUAMvLSiRmNwoXqHVKnbt29/pJF9+6UKHaJ1yFSAfqSozqFCzKfPFM2zRIjWEaEfk4clUBw6nKPUWnX2AEesAlP3/q7dbZS+vFNnMKufHL/bTnrqTFxOd1JEiINymHTLVWJ18tpeFCjibjQrr64DhYnWrmYHiAwzsJFRI+4/jtxyiqznxP9r8hi3R7OhjaTJZ85xyWl8RPCOfBbjxWQ9b29+7v+dgh49Bd2xHxpug3A+FFj4QmD2Onzmi+GJG8JjN4SnvhIW/jtf+X6aWJOmlot8AdAh68HdfUv7WYNp3vGeVDZ3IL9+4p6n8scXlEkf/bzcHe8n7roLyOXx6S1OkARNPhhXJRAKf3zsVCL9fHzsVOKbLvJ23UsOdR16aw3S9K/p3PEOcnrAtnXrKyDfmch9Thr2AgXefGsHqLVn7/5lnwnkurIAtGIa0AqOH0/wdEX3d9e+/vres1H0uWy4E08/ofC5FkpK+vnB/9rd/lGudoyrHePpxnh6msAAGIgptswprHNy63s5525YXXnLByzoT1XQixeg1weg9yah7f03v9XYMUhnMplMJnNnSR/09hB0gA99MA+9w4C29UIvnIc2VNz8/uL191Xs+2vTlNw5GasDxwqPl7YtIm66yAKSgWhRDbE0vdNiOktOZ8npLEUnQ9g7B48JzaNC06jQNCIwz8Huv55tOXSiYgELTSagT4p7u2JcPlH0SaQfKy9bXXDn9Gd3iqvXXDh3pKB1hDIy63I63C6nx+WKApDH7/OeOHHiEr9QUgT4iS9WIq8WJMR09g5prT6NxYOaXIjRCRscar1dpbOptNbK2qafr3tIIEflqFGOGGWIQYYY5KhRoTErtVaV3q42OGCjEzG5ULMbOFdAC7DBDhscsMGhNjhgg0OKGH/x0PqahvNRKoqwEWpyxXiJEmVyIUbQH6tKZyUwBTY6UZNbY/HGvFYiOqjIw6nBS1utXo3Fg5rcqMlVUl7d3tWn1tvVOptKa1ViZsWSLEqtVaWzqQ0OQGxAqMmFGKPTEhmsW2PxYlY/cWrSO0NIrw0B0UCbP0b2AMC1mIdBR+5UD+rtAZ3Vr7V4MZNbo3eheieqc6A6B/DioDoHqneiepfG4NIYXBqjO1YujcGF6p2o1oFgdgSzIZgN1thgjQ3B7NHqSwVg1AprrIjWjuqcqMGlMboxkwezeIFzbkk2//gMC/iurslbO1a8x/vvpQOf4170q6MwBKFW192H77lpO/SdQ9B3D0K7cyHP+PXhma+Ep/8jPHNzmHd7GLm7duEp1H6V3nSRSD9xJPS56Qe4gu769Ucnq4bSf96PyY27PL53vv3td779bYA+5LvAiONxtS6KfsL90Fj+rRuf/u0rmx6fKFp1Bd90kaAkYa84XbMo2Ep50B7c6Q3WtVAcLs8VRZ+06Oe2O35sd/tH2JoRtmaEg41ytGM8PY1vGBcaGSLztNSyoLCOstFb73r+B1msr33Mg14fgD4WXJeLfvkM9tUjc9//sDO3qT+/deCujztuOqO4sUj/pdMY9BkCZXGgbb1f/4j7g72Lt/10M01gmlK4yJpUuEa4usd+t4nJ18woHAyxdVyyJJrIdIEhHJwRDc2KOhiivnmEJrbSxJYxsYUmskzIHXQu/Ks//nlSZpvTLPvyihWjXdSohuUhUZR+yO/UPXLkiN1qddhsDrvNabc7HY5EADpy5MhySzDNFwtrbf7ck2cm5nlJP4WNzoOHc3gyFDycUK13HDyczRarMIsXNbsRo1OKGDY89SxbpFRprYsC+TdXrTrwl2wZYpDCeimsl6h1EpVWCutliFGuMSkwi1JrIxgIjpKTWm8jHCpAYrXu5+serqpriTmutwN3TqRuVITHCDG5YKMToJgSsygxi1JrUWqtSq1NrXcgJpfG4tXaAjp7ELxSNPLQxSX08RHjgg0OiVr3l4OHZ9kipdaiwMxyjUmOGmUkRUaks6nBiICi3AO6odY7YKMLNXs0Vh84td6x9BAjPQl9QFY1Fs1/0lg8GosXs/qiDBTUR/sMqujtAZ3Nr7X4MKMb1TsRzA5rbDBqVaNWNWJRoxYYtcIaG4zZEcyOaIEciNaB6BwkSLJHoccKpEatAICi8OREtA5YY1OjVhi1wpgN0TpQvQs1uDVGt8bs0Vi8sNFVUlEtxywai1cO7iDrG9Y7Qnonrl/m+UZXSEvL9Wqd8TJ2QGvzl1XVgnsLYKNzHylC+jcl8I531Op6vuhF6BkI2gpBu6Drd0Mbj19fev7r5d3ferftG3uYO1G767KfOunb1F3+8IPv9qSgn5/t6HL5w+k0FSeTKzTC5Nz24Mu3Pfiyy+MzukLp9AoYfr3FCaJdVsBMbtzkxo1uHDzzEByPa8cfCh8+XphIP4ePF/qXece7v+cLob5Uz3q+xAkHpoQ2tXi+sw/sn+/se/OtHWqDYwVIuvhXxCfBoM/zcvjoa+GXfzO83ROyevCLfUDi56Cf+rZemQlnYanoxzfMQqgslAoAiKsd4+loAsO40DQuMi4oLQsKy4maQej7H/6y0fzf+brrTmCrakzfabbe3m6/o0b+nZPj38kbvb1a+sMOx+1tttuaLP9VbYRysW+e0T5Wb/zC9/YXnZ8i3UrmnlG5p6PKr+16+sW3+ahzVu2KBMWkEY3w9T0ziq4p2TBHOy61AdEltmmliwvbN2x6q7RlgKONxLw+X7SLQB+CfvzBmB8o+9LbLnF9A9/PcvSzpKjR1dmDWptfY/EgJhdgl/5RJoh8QRD04cEcgD6Ae8QqTKTExCqtRK2XIkYZaoq4TPR2NQkRgN9IqbUqtRYFZlFgFqEC+/m6hytqmxQa85IwgDJWMgyp9cBdFMEg0CWl1qrAIlUUmEWhtar0dtjoQs1ezObX2omXb+Cx8BFBH7XeEe1ShHtkqDE6Lr0Ejog0IlJ/DA61nnCG2VR6e9T9A95EFtBFsUAfA15+zOLTmIHPyY0Ar5jJjZo9SxXt0T47QuCOLa3Fh5k8Gr0L0drViEUFm1Vqk0ptUqqMSpVRqTapYLMKNqsQixoIsBFqVWsibh61xqbWWJeOo5FiUcpxojonorXDGhtoAdbYYK0d0TkRvQs1ulGTW2P2aMyeRYEChBe3b9/e0TuktQVIM3yZTeA/sLikmNrfJvoYovQDNKOaeqftte9m3w7t+iK0/yt3Vt6zc+QdJjJ/hU69HP38bEdXan0++jG4cGs08TkRVpZrKunvz3R+lPqD4SMnSxLp58jJEn8wOf2sqMsy7WqDgwh7FRSXJxa4OO9RGjAUB0DpYJAlGQNd7F3xF/3coOUVCIWbOgYi9IOloJ9FJAaAeLoxvp4uMNAEhkmJia20LirMb2UV3vDgsWdGPevHQz/odN/d714z5l/H8D/MDKyfCDzMDKyj+9eM+X7a7/n+BdfDtNAzVPf1DxzddaR2Tu0la5YslXfXX46/+OoHYszN0/km5I5JuXNC7pyQOSakDqbUwZQ6GFI7Q+ZgyhwMqZ2r9Qk1rk3bdmUdOcnX43PoMuhD5p4V0UcWGpbF0M8lrlT9FZITB+8l1doDmNWHmj2I0RXxsmitSq1VgVnkGrMMMQL0Eau0IiUmUmiECk0EgKK4II8CkCq2OmhBjppkqEmGGqWIUYoYpIhBioB94HExyTVmeZRplFqbUmdT6ewqvUNtcMJGl9rgUOnsSq1VrjHLNWY5BgpblTpAPx7M6tfag1p7UBclCcBzpEE5VDqbAlviHmmU58QqLUk68ohAZ1Q6O3lcCsyq1NnUBgdscqNmr8bqxwAWOIn5BGePTqnJBRudsMGpNjjVYEQAgKwEOQUjtWxBrdWPmX0aoxvROdSoFUCPQmmQK/RyuV4u18sVernCoFAaFaqIlCqTUm1Sqs0RKoItKoQkOCrEqgZOI50D0TpgzK5GraC8GrWqNXZY64B1TkTvQowuEq65EZMnimuByAw7opx35VZmRldXYQi6Vqd+5Y0diQetnrDLv4KsnnA6TV2WXi33Pbzi97MvGD6WX5lIP8fyK33B+P5fZV2iVUoHidL1CaXHQ0sAlELey49HhAKhcEsXVUrQD5Ym/QD3D98wxteP8XSzMhNHZWWrrG9/WPiFH2U9cQF73xLegoR/zwv/nhd+Whx+Vhx+ThT+Iy/8O374z+rwHlP4D+fR6360b1d2Rex740lSL+n9j4//7smt0zxYbgpwMP+syjOtcE8pPdNK96TSPalwTavcbMwvMwYm2MrfbNiy/8gJgQFnaZNHu5ZDn6Qun2FZaEgWGorSjy8YvjiOcV5V6RwhrT2otQc0Vh9i9sBGp0pvV2ptigj6WGSoSYoYJWq9WKUTKbUg91kgR4UKjUgJcMEgRUwyjRngiFJnV0YpIQJPqEmKGKWwQQIbJGq9mCSJWi+BAQmZZKhJpjHLNRZANgqtTaW3q/ROtdGlNjhVOrtCa5VjgH4sBP2ojS7E7NVYA1iUfnQOMKgAZvVrLF7E5IZB9bjOgBEBnotIK1LFjCgCQDqbSm9X6exKXWRaFFqbSu+AjS7E7EUt/igW4NFTB7X2IGZbOrta71DpHSq9XQmQzuhCTB7UEiGnSLftIa0tgFn8mNmLGlwwZlchFoXKCLhHJtPJpDqpVCuT6WQynUyuJ4uERCYgpTqCREAKtVkJmwkAgjG7CrWpEEsEmxCLCrWpMbta64B1Tljvgo2xMnkinGcPau0hMMlXeaFmdEUVhqBrdepXXt/xD9yULxg+frY2kX6On631BcPXas5T6XIwU1IYMrkuJkaWioTCcUrNQJeRhwKhcFvvmNSEL2IkAMKS0Q9AHypHM8LBRrjaUa5ujKcb5elGeboxnnZBYRagDqHGmV83dNtPn/rWC43bRq0nnOHT4fCn4fDRcPjTcPhUOJznCL8yYr15U933736qoIkGXprB0vjZWICtDXCj4mABliawiPrnkYhOVl1Yve63Hx/Jn+WjsCUoMwbEhoBQHxAZAjJjQG4MzPCRAzlnHlz329LGbrER5+rwdBJ9Uke7CPQh6EeMOXzB8N+svAE8In/I4w95fEG3L+D2BtzegMvrd3n9Lo/f5fE5PT6n2wvkcHsdLq8j8qfP6fE5PT6X1+/yRipGFVvd43O6gaIVgaKfujx+l8cfOSlozRdw+4JRkbrk9bu8AaKAxx9aGkUA9waIQYU8/pDHH3T7gpG6Hj/weEc7Ex2OmxgOMSKiMwF35ERL0+ImnZp09jDp1LFn95FaiFSMq7t0Fbz+kMcX9HgDbo/f5fa5XIS8KRUt5l5OfrfH7/YE3N6A2xNwe/xutx985CZ/5I3MuWdp5oMJI8W9gWu/dDO6jAK/066Jtr+14x+4KZHGUd46mEg/5a2DIs3ftGm4OvJflEKfU4HLJLXB2T02C+gnDoBisp6pLA3w+oxwsBEuNsrVjnK1o1xAP9pRnm6Mp1tUWiVat0zvnZebs46evetnG7+89i8/fqP1t3nTzxZzf3N86q7XW7605uMfr9104FjpjNwm0gelxpDcHFJacKUFV1qjsuBKC66w4AoLLjPjEmOIrw9ydcFxoXHPoby1j2z408Y3Dhw+XVbXUX++r/xcx4FDp5589rW1jzx54OjJBYVFasI5urRynFeMdg2RxNLiYQjqGGM39000/U2qsZfZ0MNo6B6v76bXdo5Wtw9VtvaXN/WUNnaV1FOK6zqKai8U1rQXVJ/Pr2o5U9F0urzpVFnjydKGEyV1J0sbTpU3na5oPlPVWlDdVlTbUVxPKW3qKW3qKW3sLmnoKqnvLK7rKDrXXlh9Pr+q9Uxly5mK5tPlTafKG0+VN50GdStb8qta86vPF1SfL6xpKzzXXlR74Wxdx9m6zuKGrtKmnvLmvorWgYrW/vLm3tKm7pIGSnE9pbiBUtzQVdzQVdrUW3F+oPoC9VznWF0Xvb57vKGHAQZV10Wv7Rw910GtbhusaOkrbeyKdKamLTKcymhnyhqiajxV3ni6ojm/qrWgpq2oNtqNxu6ypp6ypp7Sxu7iekpxXUdxPaWsqbeidaCqfbimY7SWQqvrHm/oZZLns44ydq5jpLptqLK1v7ylr7y5t6ypt7Spp6y5t6J1oKptqKZj5FznWF0XDXS7oXu8nkKr6xitbadWtwxW1veU13SWlLcVl7aeLW4pKm4uLGoqLGoqLGosLGwsLGwsKGwsKGgoKKgvyK8vKKgvKGwsLGoqOttcVNxytqTlbElrcWlrcen54tLWs6WtZ0tai0vPl5S3l1Z1lNVQyqo7SysvFJe3FZe2Fpe2Fpe3lVR2lFZTys51ldd1lzf0lDf1ApU19ZY19Za39Fe2DdV0jICR1vcwGnqZjdd69WZ0GRWGoGveh39ItY+xhxfVC1gM/Sxg+PCiun2Mfc27dylqJtQfo5YEtfZPtA4s6XycBifOD060kdRO1tBE+9DEhVh1DE10DE2mUCfQ8LKifC71jS9OCjQiY4R+FhPpJ3LHOwcQj26Mqxvj6kYJRdw/+lGeniY0zSrsEr1XZfKrzEGVOdA/wT9Z1vr+R7lv783e9eHxU2WtA5NCtRWHrbjahsNWHLbisA1XWaOgY8IlRlxsxKUmXG7GlRZcbcXVVlwFZMGVFlyk83WMzP61sPr9D4/s3Ht410dHc8/WdNPmpcaAwoyLjfgcehGJPoB7RpZ3+QzJQoOy0KAsxFCFwhAkNOBxEvzNiK8L8XRBrtbPxXxsxL2gtM9IzZMi/YQAY/BQOgehsVWji8qRBQV1XjY8KxmaEQ9OiwamhAOTgoEp4eC0aGhWSp2XjSwqaRx4nKeZEOomhDqmAGPw0HEuQueoxxaVIwty6px0aFYyNBNpYXBGPDQjGZqVDs/JqPPykQXF6KJyjKWisdU0NkzjwHQOMs7DmELdpNgwLTVPS02TYgNomcnHGHyMwcfG+diEUD8ttcwp7Yuwm436OJifqw3wdCGeNsDReNmIe1HlmFNYpyWGCQFG58BjLNXoogL0hxjO4LRwYEo4OC0cnBYNTouGZiXUefnoopLGgelcdJyHMQXaSZFuQqhl8rFxLkJjw3QuwhTopiSmWYVtXuVaRDwczM/ThXi6EE8b5GoDXMzPQb2LsGteaZ+VWWakpmmJaUpinBQbpyWmGZl1XmlfULtYiIeN+riYn6cN8rAAB/Wy1W6WwrEgsczyDVMslDmjGp9U0CdkdKaUxpCMjUvG6KJRumiUJhylCUdGBdQRHpXKo1J5IyOCkTHhKE00RhePjUto4xIaU0JjSmkMCW1cMjYuoTGk9Ek5Y1rJnIOZs+rxaSV9QkYbl9DGJfQJ2Tg4voAwWegERzPBwyb4WiZfy+RrGXzt0jwjHo7Gz8UCPF2Qrw9d8wWc0eVSGIKueR/+UbWA4TRliEw/NGVoAcMFhiQ3Tl9bsS9SHEI6nKPDuXHS41w9ztPjPD3Oj5VAH5mcJctoxEWxEhtxsRGXGHGJKUZSMy4147JkksdKYY74RJJKmVKqWAH3ityMgzARQT8EAxH08xOHJzDG19P4ehrfQBMYaHwDjW+g8fRjQHz9GN8wxjeOi8xMqX1S7uJofFJjALGGUFsIteMR2aKy4yorLjXhIgPO1eILGD6niQrFZ0maQfE5Dc7S4nwDLjbicjMO25YEwIjAI5ERX8DSSvRJP9oVQR9pRGEIGpCGCPUnShKvvquoXnGwR+jvFni7eJ4LLFvrjKGBiZ4blVcOicv6+cXdnMLOhfwLc2faZ06fnzrZOnmimZnXNH68gf5Z/djxBlpuE+NEy8TJ89NnOuaLujml/YKKYWnFkLisX1DSyznbtVjYOXemfeZU62ReMzOviQGU2zSeByq2Tp06P326fTa/Y76wc6Goi3W2m322m322m3O2h1PSxy8fklSNKM7R4XM0dc2ooooqrRwSVwyKygdFZQPC0gFhBVV2jg43TunPL1jb2c5OrruL7+0RBroFPgrXdYFla5s3NU1itTRl5ZCouIcNhnO6beZU6+SJlgkwnNxGem4j/XhUec3MU20z+Z0LRd2c4j5+ab+gfFBUOSwuHxSW9PKKulj5HXNFFFbpgLBqVFnHxJpnTG2L9k6uu0cY6BWB+fR18b2dHGf7orV11tg8pW2c0DQwNfUMtG4cqWdqmqb0LbOmtkXbhaU++7v5Pgrb1TFva582tY5jDUPKc12iylZWWeN8af1sSe10cc3U2eqJokpmYQWjoJyeXzp25uzIqYLhk2cGT54ZPFUwfPrsSH4JLb+UXlBGLyijF5aPF5bTC8roBaW0/BJaQdl4UdVE8bnp0oa50vq54pqpogpGQQmtoJRWVMksrp0uaZwvbWGVtrFKO9ilXZySbk5xN+dsN6eom1vSL6waVdZPaFvnrRc4LgrP2y3w94qDV3OtZnRFFYaga96HjP4WlGiSEs3WQKwIezcYawqHZRETSVjMEXlohBRCAeYVmFq6MmJ8gSFmqEKM6HNnJtSRVy8QL9+cQkJTSGgaCU0j+DSCzyD4DLokMhLMoSRa0OBzGnyepAUgLLkWL0Yxb7oYF5rAI57HRZZxkZkuNNGFRrrASBMaaUITXWiiC80MiXVC5phSuGdU3lnYP4cGONqg0IBLTLjYGBLqQ3xdiKMNzWlCc2hoDowETYU+S0LwaQSfRkLTSGheE2JpQxxdiKcLCQw4WxeaQ5eeZ3gZo12DsegzIA2FISijjDLK6G9f19zuZvS3oxUZKAUADcYBkCwlACmWAIiWGoDUywFQ6DIA0DIMdNH0A95yOiG1gXd7TUjtTKmNKbEyJFaG2MIQWxliK0NiZUhsEzLHpMI1rfLOwP5Z2D+HBOfRYLRboXk0NI8C7klGP8ujzzQJfaaQ0BRpysiv7vrc6DOcHvqk8vpcU5fPksShXlGwVxToEfq7eO4Olr1t3twyrW+c0NSNw+fGlFVUWeWwtHJYWjksqRiSVAyJI36Xfn5pv6BsQFg+KCofklRSpVUj8poxZS1dXTOqqByWlPXzi7vZZ7tYRV2sIgqrkMIq6mIX93BL+vigVsWQuGJYUkmVVY3Iq0cVoO45uvocTVUzpqwZU56jqesYSMME1jilb5rSN07pGieBEwUFTpRzdLiOqWmc0rfOmdtZjg6Oi8LzdAt8vaJgjzDQzfdSeO5OjrN9wdIyY2iY0NTSVDWj8qoRWeWwtGJIXD4oLh8UlUc9SWUDwtJ+ARhUxZCkiiqrHlPWjCmrRxXVI7JqqrRySFzWLyju4RRSFs/2cMuHJDU0uGFK3zJnaWc5KDxPjyjYS8ynKAA8QBSuu5Pj7GA7LrAcF1j2dpb9AsvRwXF1ct0UvrdL4OsW+qNOo0A339vAYUI2AAAgAElEQVTFcVNYjo45a9ukoYWONY3ADUOqhkFl/YCirl9e1yer7ZWe6xbXdImqOwVV7bzK85zyFlZ5M6uilV1xnlPZxq1s51W2cSM6z6k8z6loZVe0sCpa2ZVt3OoL/BqKsKZTWHWBX3meU9HCqmhhVbZxqzr41RRhdbeosltQ0cMv6+GV9nBLenjFvbziXn7poLh6TNUwqTu/YOvguCk8b7cw4/vJKKN/ZF12ABq+NABiJgIQHANA058XgFI7gS6Ofr5/1z1OX2hK4ZxSOKcjD2J2Timck3LHpMwxKQdyTsicUwr3tMozo/bNwv45JDCPBufR0AKJfuaWoZ/ZK4k+F3Vbe2K06++De4DEoV5xEBjsboGPwnV3sB3tC5bzc6bmaX3jpLaegdYzkHoGClQ3jtSOw7V09Tma6hxNdY6urqXDteNw3ThSN46AkrU0VTVVVj4gLOnhFPdwSnp5JX38kn5B2aC4YlhaPao4R1PX0uG6caQOtMzUNExgjZPapil905SuaUrbOKmNHJnWt8wYW+fMUZlaZ00ts8bmGUPTtL5xStc8bWidM7ct2jo4rk6ep4vv6xb6CZ4DEb1OjrN9wdo6a2ya0jZOYEQEqnYcBqobh2vpkUHV0FTnaOracbiOgdYzNfUMtJauPjemrB6RVQ5LygeEJX38s92ckj5BJVVey0CbZoznF2wX2C4K3xuhHzClYqIPvm6Bt4sfEYXn6QLQI/D3CAM9okCvKNgrjmBTj8DfzfN2cd0UlrNj3tY+bT4/YWhl6FoZupZxbQsda6ZhzWOaplG0aQRppKobhpT1A4q6Plltr6yuT17Xr6gfiKpfUd8vr+sDwCSr7ZHW9srq+uX1A4qGIVXDkCpSsUda2yut65PVDSjqh5R1Q4pzg7LqQUnlgKhiQFQ+ICofFJcNiiup8tpxtGna2MZydHLBPAd6xdf+CzqjjDK6oroUBko/CjYWFwW7AgA0ewkAlA4DRennR/e6fPisyjuj8s6ovTNq74zKi1gCmC2A2fxRBTBbQAsUfYiI1hGKPq8FB3/GCl9RmB0oREhDli2EJhNCEgxkjUidVJaQahkpU8scL8XfjkxBuSkgM/plBp9U75XovRKdR6x1J5NLhEWldYmW/nSKNE4haufDVp7azFEaOUoTV2Xmqi08tZUH2wSoXahxglqk1jwSHZBXovOCfbHWLdFGD+q9Er1XGpUk0jdQ0ivV+6QGP3iEgdwUVJiD0REFwYjkxkBkRNGWVx4U5hJrXWKtW4S5hBqHALXxYStPbeGpzVyVGQyKj9iEGqdY65HofVKDX24KLDOxQdCTGJnJ/Yy5BApTUGEMyA0BucEv0/ukOq9US8gj0XokmEeCuSWYW6JxS1CXGHWJUacYcYpRpzjyZ/QgOI44xYhThDhFYJ9cAHGKEIcIcUQ+RZ0i1ClE7ALYxoetfLWVD1t5sI0H2/iIXahxibWeyFSblul/Rhll9A+nRLOV2swtZxzVluT2lLC2wPiSzXFSe62xxZh1LEY4Zl+ZEwjpksqZXOSnImGOZejn9h/f6/Lhc7A/IsSP2oJlde2bt+8ltGn73k3b927evm/z9n2b39z/wpv7X3grC+jFHVkvRvfj9CLQjowuq96KTvib+ze/uQ9clE3b925644PnX4/qjQ82vfHB85Eje+K08bU9G1/bvfHVXc+9+v6zr7z3zNZ3nnp555+27PjTlh1PvbTz6ZffeXrru8+88t6z297f+NruaK1Im5ve+GDTG3s3vbF30/a9m97YGz0LuQCxWkiL54294KPoEtq3+c39L7y1n1gk0TWz/4U392/evm/zUhViFJFxLTeo51/fs/G13c9te//ZV9595uV3nn757ade2vnUSzv/tGXHUy+//cwr7z736q6Nr++J9OHN/cTSJSvpMo5fzzFrfv8LbxJ93rf5jb3xev2DTYRe27PptT3PR7WJpOdf2/P8q4R2R7VULOGj3c+/unvjq7s2bnv/uVfef/aVd5+J6D3ShftgE+m/NfOfmFFGGf1zqqKhIw6ACPq5z+XH59HAPBqYRwLzSEBnD25+c184s2W2zJbZMltmy2yZ7e95e3FHlt6Zmn4QoCBBP3ZPKKOMMsooo4wyyujvUSvRD4h8IRFp7cHN2zP0k1FGGWWUUUYZ/R0rJf386F6XDwf5zuC961pbYNP2vTgetrlDGWWUUUYZZZRRRn+PwvHwizuydEnp5/t33eP0hqbkzimFa0rhnlK4Mav/+df3/PPQT1VVVTj8zzLYjDLKKKOMMvonEUE/5JvhY552yJTamBI7U2qfkNlRi2/ja7twHLe4Qv8MAvRzzbuRUUYZZZRRRhldRuE4TqafhcQ3XYB3WdBF5nGRBTV7n932foZ+Msooo4wyyiijv18l0s/C0ltOf/gTuzsA3uIO3mYKm9zPvPJuCMdNzuA/gwD9XLn2w/3QRemaT8jV1EjKzeb0XvMeZuYho4wyyujvVKFk9OOKvuP9f+1uP5WNUTnYCEc3wtXBRtfTL79zUfQjZH5Czf+6kPnJNR/q51D69DPd/uTAiX+bbn/yotonsMbTdV2GfuI0MjISDASCwUAoFAyFgjgewvFQMBjA8dD09HR/f7/WbLvmnczMQ0YZZZTR36NS0c9td/zY7vYNLaLDLHSYjQ2zMbXB9dTLb4dCuMERTEd6e4B6+t9wn2a06D8NDn96tYQ5D77a6AgaHMHGl9fmsJYpxspb/WDeFHlnGU19uvbPbWn1NlGAflYsZnUFqKe/ivs0o0XfsDi96bcPmAbvh5544om3Xnqs5egPUtPPCg3K+7KP9Ak+10j/BkWlUgMBf6Lhx/HQ+Pi42+0eGBhA9dZr3s/MPGSUUUYZ/d0pFEpNPy7f0AI8tIgML6LDLExtcD710s706UejmhEPPRt2cxT0bWpRb3q1ovSTBGuEOQ9CK2wJJHQV6Ic/kSseeibs5ijor7BH9qffPpl+nnjiiW0vPJ4+/dDLd0a2I310yic7Y7dsCmpwBA3yvuzyBVIttP3IJ+3yuG4sFO9MsVXSQbFEtJqsjJzlymhoaMjv9yU1/P39/b29vb29vf39/SlamPp07epPhWmsN2iFFcLKWw1FiHy5U5DPFU/trLzVL1PItRpfhtLo2CXOw8qXVZCwbNJaRfGLKiigfFI8CVZXQhPL4LiA8slyH2WUUUYZXQVF6MexDP3YXL6hBXhwERliIUNsDaCfYAjX2YPpaLb9SSfSHNaddmsaJ+vXr1B+Ie+Blyk6uzD7wVcb7MGGlxPI5mVKTOEH8ybJO3Zh9jGKzh7Utb6aGpBebE2r8zp7hH5WLEavupsYJq349jQb19nj6eeJJ55ITT+JLfA6P8nuRCN/Svuyj/Tx7EHdZCVxkNf5SfFkUGdfKN5ZOQbKlC3o7EGdfaEYFF7aSRTadqRyLPrnWNnOpXPFnuVKaHBwUGGwtQicoxMfu0fvHc69czD3W1bWQWD4NSiqVCj6+/sTK04eW7vcpX/gmDCyeFItkLXZC7FrzB6cPLY2Uje6PsG5Gl5OLBxTgLSwky1pokuXfx7Svaykg5+0SZOVX1ozyf5MqDtWFt0nFmR0/aTa4tvMKKOMMrqCCobwF3dk6R34oibheT+AfgYX4KFFdIilGY7Qz9vp0o8tMHzyq7hXGFb8OewYH8n/d73dn6o8mX5aXyVjypKNaX01hoGiAsZp8tirUVMknCR9tIQ7pOPpKB36MTsDwyf/FfcKw4oXw47xkfybzA5vmu0npZ89rz3ckPNDWd1NK9PPZOXOI308+zK/8mPgZsk+RYxTDAZVFpf18eyx5mqycmdZHzCTcXareDJagHSuuL6lgIs0J+dgec9DLY6mCy+I+x7IfeeeBz5c6KTNNVdvIzs/ent7ky6G5IDb+uoS/USxJlFLi80uzH6QvA+YhvLiUl3Ki0vAJMx+8NXsOPB6mUIinrXZCzF9IxHVlZiHlS9r/EXcmfwqZ5dVZu/cubNsgdeZ4GJcwt+F4ii+LE8/BCEtT1qXdQlllFFGGS2nYNT3s6hZAiB3TORrERlmoVQ2RuVoYYPrqZffdrj8sDmQVOzBfYO5/9b/2Q1A4v4NYXNDWPCHMHJM0v0Ycbz/sy/PUbbFV5/LvX8LBTYLDq7etnnL2oNHt91/VACbA7BZcHD12oNzAdgcgJu3QVso9KPL/riHVufSQVPRffrRtZubA7CZshmCoNXbauaS9zypAP0kHmc0PD7w6Zf7P7seSNz/RNjcEBb8Powck3Q/ShzvOXYDvWptivaT0k/+vnvA/iubf1184CeL5f9F0E9s9fnCnZVU8hFx7+Gc3kVzAGZUHu5A48612HG0kBHzZ7TMfGFO7yKj8nAHuthxtLCj93DpPGwOUEt3FjLQ5pzYU5CV7CxkJb0+ac58D998a6VrYOAJccO3j7z63Q25F55lh//rHeUzH+aEgjFWP7FuiuURXVHpin50bXyVZmJZJvt0ab0lLuxAdDFvq4mu5Cs5D+ldVkblztL5xPMSq2Wx4+jh0srDpfNL64eosswCoJYebRbHLkjiOKP3cHLWSr7MLmUJZZRRRhmlkMPlJ/J+kvh+7G4/gT7EPV8p6Kf/06+GPJJwQB328sPuqbCxPCx7LbzwKL7wuzB3C85/HZ9/Bmf8KjBwb/+nNyBmX0x1Ev3UmAOwmbI5Yh4omwHTmANw8zbwDbi5GXwqOLgll24GNokSrRijJNYobS1HP31HvpQwzFfDC4/gC78Nc/+M81/DpUdxdXVwfkf/p9enaH+5yNfGp3/3BGnDk9IPI/qrPaeX2nE0zpgc7kBhM9qcQ+zH2Tm0OSdqooCZNAeopREjtNhx9HBHb2FO76I5aiYJM0a2ZyvRD5xgvdKf+c35Mxd6nnJ3rNqx4Us+r8fn836vKLS+Kfz1LcpgMEAY/q6ursS6y17xKLikouc4SJrLvZ9Ye+ZADIibAzVb1t6/GjD32ihtg7VKWrHEwgZEnritzr0y85DGZY1bFaQLSrAOtXQnQU7xxSI7kWVGsHUM/ZAqEseppTvJIH6FllBGGWWUUQoB+kn+ni9wx/soVzvG1Y3x9DS+ATG5n9n6bgr6WezbSy/6rg9rCOtPhUXPhNm/xmcfwpkP4CM/wvu+g1Nuxntvt52/beSvX5pp2xpfPZ5+AjVb1h6ci/m1DUQ/unZzM2UzyX7Qm7fdv2Ub+IVdsyW1aYv6h9LQcvQzVvU4veg70WE+HWY/js+uw5n34yN34X234ZRVuOTUj5tuVIxns3reS9H+cvTjonzx2HurV6CfiCJGDjbH/9SOaMmkkYgnpmS0BUblzshBtDmH4CdgJiM7MQ6kNOgHJlmvi1iXOnNP6drw0B07Xrj9ul8fu35z9XXPlkHP93zjPfo3H98fCPiDwUAoGAiFgp2dnYnVV6SfZRZe8s7EOHgSHTZLRyibV+fSo3QeQ1GAe6IV6UfXpuP1ueR5SOeyrkg/aHPO0WZGavohys8XxiF4aWUS+lk6I2npXvYllFFGGWWUUqnp5ycOT4DGN9AFBrrQRBeZUbPnmVfeS0E/sDkgmmvsPnwDOv5CGMvFp9bitLvxwTvw7m+F2r4R6vwfeel/dB/6F8FEaZK6c7n3b9m2GYIgKOrCiRwhfm0LDq6OfA9GfT+BiPtnLvf+pWJkUTav3rb5aHrGJkHL0Q9sDkyc3959+Hp0fHMYy8VZz+LCfbjsNC7Oxfmf4sI889wnP2n5j1+3fyN1+3H0s+Olx8L9kKzupuyda1b0/UTsk7j3cOk8tTQhkpDUQxMxPGhzDvnHNzBC84U7K5sjNm++cOfOaMmImSRHTBbjXU2EGym5LtZuGdR1psn7Sj741nU/2/vzd6o8bpfX4/Z6PT6v1+/zBcANUMFAMBi4cOFCYvU0I19LkJSSfmAzJboCKZtj1tjSaoSgbTUx/h5iP1pmCwWOBaOlbflTX9o8pHVZyfRDRtsYzAUuHPEyQavS+bjyqSJf4kCStbp85OtzL6GMMsooo9RKRT/f/eFPHd4AQ2xmiC1MsXVCYtOYvc9tez81/cDmAGp0UPPvNzP+hDN/gfd9B+/8Zqj1plDTjYbKGwdyv4/qTUlr0Y+uhaBtNSTfTyRZh2we5nLv30JJ9P3UHF0Lrc6lE4GwpeoR71G6v7ZjlYJ+YHNAhch7j9xqZjyJiw9ta7/jJy3/QdatNV85huy5s/arKdon089rL/6KVf6fx3fdv4HEPVs3/5pecGvyvB9x7+GcXmqclUrl+wnA5qjtiUn1mC/M6W0uBV6ByH4hA9iqJTNJ5H/ACSlES9buMsnCe8Vefcttv9kO7Rx95NM2nlDWPMJ9aST4x87Qnvz2JcMfCLS2tiZdSGn4fkgxrLiYVKJrMFogSbOxvp+DcX5HIguNIPXYwFkyXr9c85DWZSXRTwwTJ6GfmCUUDyvJ6YdEYFRzYg5Zur6fjDLKKKPLLoJ+WNolxbzldFJmm5TbJ+WOKYUTs/o2vrZ7RfqBzYGOA9f7J3+L99wWav+vUNt/h+quD1VD/pp/oWR9IT7dJ14R+qEfXQsR7AItZT3ff1RQsyU272cu9/7VuQe3rD04RziEQPyLlAbUvC259Uqp1PQDmwMXPrjOP/l/uPjEA82rTtoOvGt4bqf26TeRJ19X/nGr5Hcv8H7drqu7pebLy1Un6Gfny4+e+uC+Jzf8keCePz35h5pDP4p7BnRc9agdio84gI3IUT3cMR+NecVmAkUEqi+Zw8in4t7DOZWFJIsVdfkQvgSiG5eZfmzjD/V+fPftL5yF9kzf0Bt+aDT0y6nwf/eEv/xEYW/fsM/r9fu84BE4LS0tidXToh/yeljB90PONkv20RYK/WjuMr6f2PbnKJtXR1xQNVtWTsG+tHlI97IuXdyoEzE+oEmmH0BLS9G0peqFjAC1tJIasx4A8UQZKFmCWpwPKaOMMsro6iiOfthanE3Qz/fvusflC80qXbMq96zKPavyaG2B51/fszL9oKrRYzfi1J+GOlb5W/9LePIGT9W/hKqhUDXEzIFkvOGU1cE9X3ERAcHB1RC0hVKzZe3BZpCISvL9ALM0l3t/1K4sBzqRlKC0/UCp6Yc90Tx67N9w6k9w4WcPNK+qtp+ssp4sN+WW6P96FjuWDx95dn59K1r94+Ybl2uBwJq83feRQ12HdqxFmr6aeMd7XPWIIydl3g8oE4mRRQ1b7M/3FD/BI7/X4zxGFxv5uljZR9aWv/bt/FOf3fFGyTc/bvl+mfiWnPGH9tZS6TMet9vr8RCGv6ysLLF6GpEv4BSkbAZHlqefSFMxSB27tAAYbaGAj9LKK1oKgSVJ0r9887DyZYWJZRMLH0trhigQ9fkRy4a8TyyJ6OpaWg+R+7xyeqlL9xim08OMMsoooyurRN8PiX5+dK/Lhy/A3gXYtwD7FhC/zh7ctH3vivQz17VfcPYbobZvmKv+tf/DL0w0vNRzAMIKoFA1JDkBMc49e82HnaZS08/Q2ccFZ78eavu6k/bSi03fe6B1FVm3nbuxBa25u/VrKdonk81Y/reef+Z32zb/eqLo5uWedkiuS40ENRJZJPHHNNqcs3NnvKUhskCSGSHSDWWJ9ulKR76MrEOq/DunP7tTXL3mwrkjBa0jlJFZl9Phdjk9LlfU8Hv8Pu+JEycSq6/o+6nZskQwyXPkU9IMmaEjKczN20CQK741UjtLTLZEQlH8uiLzsPJljafnGJECYURuWZx7ZomnybcQxq2H+cKdOw93/H/2zju8qTPP99qd5977PLt3d/beuzOz9+7OTEIKhAQCBGeG1JlMJpNGMxgbjBsYg8F0MIEkE5IYQgAHbIp7kXvFgHu3JVfcZTVLVpfc1CVLLrKl+8eRjrosV9nO7/N8Hz/y0XtevUc6es9H72mdti6dAPYDgUBcFsR+hCotYdgYtUb30mtvYF58dbN6UtstmOwWaJCMKKe8g7+Y0X4qflo/GP/P9IhfPPkCQ8LH8iQaOqGs/PbanpsYUTSm6Ltfu3yxnYxj+yn67leD8f9Ej/jH6vCXqQ1RPImGR6mi1P041PB3Vdvft+b9h2P14Znbj64cM1nyj9Nljq717PI3ZClz7do1hUymlMuVCvmoQjGqVFpv+K9du+bydsL7AIFAICsuevsZ1fYOG4Pazxb1pJYwOIVmZHTa+/jlGe2HQaqu+Gl9U7o3f2jEZPpkd+UPRd/9mtyY4PLFdjKO7af16VdF3/2q/M5mUmc5OnFYNlGTsJNSfW1r3n/MWL8z93X/2drPF87h8nbC+wCBQCArLujYD3HYGDP76R2cQkIYnBKOTh90wn5WTWY86hkCgUAgEMiKi6n9kJCMaMfM7Weyd1DTO6jpHZwSjk57H/9iVP1zsR8IBAKBQCCrL6PqSZ+QKyKVljSiJY1oySNastF+1m9WT2p7ByZ6ByZ6ByZ7ByaFo1PewWA/EAgEAoFAVnBQ+yEb1IeC2s8Lr2xST04T+GoCf6yXP0YQjAuVmv3HQkfVrm83BAKBQCAQyNwyqtb4hFwRq7QUoTF6+1mz7nX1xHQPd7SHh0Q1opj0CroA9gOBQCAQCGTlBrUfqtAYvf08v3ajemKqmy3v5si7OcpujnJEPrHv8DmwHwgEAoFAICs3iP1I1No+kZZmyDhiP8+t3aCamOpiSbtZsi62rJslG5GP7w04DfYDgUAgEAhk5Qa1H5pYSxNr6WItXYzaz8uvqcY1XUyxIZJh2Zi7X4hqzPXthkAgEAgEAplbVGMan5ArUrW2X2yM3n5+/9KrqnFNF1OEZlim3u173Kb9MNi8sqq61Mw8CASyUCmrqmOweS7vJiAQCGSVBbUfhljLkOgzPmWwH/W4ppsp7GYIu5nCLqZwWKradTDY2n7o/czisqrBoWEtAAALx+DQcHFZFb2f6fKeAgKBQFZTEPuRjWmZEi1TomVKtUypqf1MaAgsEYElIjCFPUzhiEy10/uYtf0Ul1WJxBKdTodnaCAQyEJFp9OJxJLisqqFHVuFISUIBLK688VXj7746pH1YzSo/bCkWpZUy5Zq2VLthMF+1qsnNES2mMgWIRHK1Tu9j6nHpixqScvKn56ebmBqIBDIwmZ6ejotK39hx1bnOaS04f3+F9/tevH9Tp5E09LDfnN33Zu76zrJoFMLGRpXmJubGxsbGx0dHR0dHRsbGxsbGxMTk5ubS+MKXd48CGQOoXGFpVW4ew+iL1/+8vLlL+89iC6twi3e+uxYgNRjUz4hV+TjWo5MH67MaD+vjk1MUXgSCk9C4UooXIlYPrbzYLC1/aRk5Gq12iaWBgKBLGy0Wm1KRi4ytrpQnQI6pDS32T/eq9n4HhPzT9GI+uA6p3Gd0z9LAVrEq94j9qMeG7dITk4O2A9k5UU0XlaN//HH28nY9NLympbW7pbW7tLymmRs+o8/3i6rxvNE44vxug4ECLEfxbiWJzdmErWf8ckpGl/aZ4hYMbbb9/jYuG37aWFrIBDIwgaxn+np6YXtFJAhpbnN+5+b6/7lt1mY/+775u66DoL01sOE2/diCb2CJRagbprg0uWvTp46E3z8xPETJy1yIuTkiZCToV9c6erjL1YbxBOLt3T27AfGfiArL6Lx3EdFUVFxlTXNsbnkw99R/xxM/POxbq9Lz36Mbysqa4iKist9VLTgAuR47GdsHLGfab4cjcF+nnv5tfHJqf5BOWNQ0T+oYAwqpKPj7n4h9uznGUczYygs8kDXN8M1n/HKPuhrutHF4DozFwTysw1iP1qtdmH7BaTauc17Oxr/4vudb+6ua+4Zv/swrrSutbSu9dq9+G7iyFIK0KXLX126dOns2bP5+fmZmZnR0dHXrl27devWvXv3oqOjExISkpKSEhMTQ7+4smhtmMx2jtTUlNlWTuMKc3JydFYs5dgP/vo2jEPeuE5J8XNcBIPxK1ya1joRylW3bVc7ZiiW4ofBYAJTXN9aNIXejt5fQ1M7wt+wXWDmRV7slFXjo6LiqnCEU7f73jnW92UM/yleVtwgvZfF+SCo/sClmuwnzVFRcWXV+AV80RmP+0HsRzk+LVDoM6CYRu1nw4Rmmj0yaohKrprcG3Danv20czXWuVbF+Vsc8ZV0wTuF/Jq+UFX737KS91y+vOPal55R1z6jt96yORcEAkGyPO3nzd11zT1jkQ9jS+taSTROD4VZXNty40FCN0m8ZAJ09FhwaGjozZs3TQ9pIpFIaWlpKSkpGRkZ2dnZ6enphw8fXrw2ZGdnWwsKAqu9g/LjLT42hc1mz81+8vLyXGs/5nFCHTrC33ALx9t5Fn99G8avkCehXHUzbpm9czQ8iSbFD/PGdcpSLEVOIMZ+C/WNdAvH2ylmWASNqZEs8SLgr2+z/UId4W/YEs0UP7NPzWQRLITJWGxhl4XGFf744+3q2uZzP1HePET85DRZKJ2cnprQ6bQ6nQ7XJli/K3//+eLCUtyPP95eynUbsZ/R8elBxfSgUp/JacOdLiY00zyRmidW88RjPPGYQq3ZF3jOnv108jSmqSTK3FP7NhfrfDu196g4Xf9FHWX7uTMfnv/u6Mdn45Ay5elHzObCh280UdaNVwsvvLHtAl7TyaMYHmg6eZrOlEB7FhzJ03TyNE+uzvCTZeNVSqRDncZgMBjvQoslgkCWPsvNfpBjfVp7VHcexJTWtdJYAt6gmMUfae+lP61q+vFBQg9JtDQCdPTosa+++urOnTt5eXn5+fmVlZV9fX2IA/X09GRmZmZnZ2dmZrrKfqRV1cQXXuBv38VmsxMTE5yvE5uWFRoaesMhoaGhiclpi/0O8yQaXo69zla/1Z/FyITeJ0wsqiP8Df1G16lRmbnE7ogIgumLUq66mYxU5QRajgAZF6HQ27j4lKtuSLFFWwTzOLKfGZfRVE9zAi2fMluoBVuW0ipcMjYdW0B860jPtkNtHxxrD7nR+degMt+vmhXK8Ud2610AACAASURBVInxiQ/8Hz33UfJ39yqSsemlVbjFfgPR6O1nYnpIOT2knB5WTg8rpzXThrucTk5pB2TjA7KJQdnEoGxidFzjFXTBnv108zWmcU/t21KiO9imq+j4Vkf6S23Oy8cC/nY+/PpRgu4SWbf1YsntpzUPIi9azGVI4V7MtosNmu7UwI1vbMNgMHtTbRazmCXwvo3plItvbLvY4HDehvCNb4QXzlA/BOKCLCv7QdSnrUcRfj8aUR/+oJjFG6Fzhkh0flMnpaCiYckE6Oix4KtXr3777bdxcXFRUVH3799/+PBhYWHh0NCQVqulUCg5OTkuHPsRNrfS/QMGr343K/u5dfun0NDQhrbeyw5paOsNDQ29cfPWor7DPImGlxNoc9cV/vo2o/0gG1STsYcUP2Q7WuhtEAjDFI3FltU4zGDnheYbOyMihlc3tCQn0MTnTObFGEdBjItgb4hrkRbB6p2f89iPyadgKnAm7UeFb+GW5d6D6NLymuBrz7YFtP7Rr8HtYM0ru4t/9ee8jbtzmf0sch/nhY9if/1O9PajmaXlNfceRC/2G4gGsR/VxPTIqD7CUYP9vPDKJs2UdkSh0Uc5pZqYPnAs1J79EAQaND/WcP61QLejRUfsPzNN2Ia9/9xnbi9c/ua7dQmCPxVqvTu0B3DaP54twDYSTOcipAZiMIEPBZTQNzCbrlIIAg1BQAl9Y1toI/IAszdVQxBoCI3hm+z8znhoVpVt9JUICvc6/Mny0LRhEIiLsqzs583ddW09stv3YkrrWlm8Yf6gmCMQ0tmDVOYAkdLfSaDUPyPlleJuPIjrJQ2+ubtuxgrX2cLJxhw9Fvztt99GRkYi4z1MJrOkpCQhISE5OXlgYECr1WZmZsbExDhvP2fOhVrH8SzZ2dka+6jV6pGRETabHRsb42QbQkND65ra65ragxyClAkNnaF583yHeRLzrWBOILrdtW0/Jh2ouf2YGo8d+7GjFDZ751m039QJrLboiBmk+GEwfuGm++NMNwRXkX1hZs22pQ6LtwjmmcfYj8ki2N61V+iNMRmWW6BluXz5y5bW7g+OVLn51L1xoHLtjie//lPG8x+nJWZU0cg9h688/ve3Hzz/YczrOxNaWrsvX/5ywVbdmYLYj3pSK1IZY7Cf9Zs101qhUiNUaoTKKeHolGpi2jv4i/EJy9NPkN6ZOKBB8+ad9lcqxpnsrzTtb9bF/x/ft/+5prGNOKD58l7mbx6Ov56p9WybejdOcfhsmOlcxAENETGbg4EeVh/hpUaNZWGzFHpgAqPQf9MCMQcLrYuVfLvNI81Qfmt4CfKKhpJRBzEeaVZVQSCuy7KyH1I//9a9mNK61olJzZGjJz76zGvb23+mMAR9rMENfz74n++ffO4tv9rGtuziumv34ol0p062mnPvdvRY8A8//BAVFYXH47u6uhAHamlpiYyMTEtL02q1HR0dkZGRsxr7mZX68CSa7OxstUPmYD/l1bjyapy7Q5AyztjPfN5hnmSW9mN37Mc4CGRnz5dFGbMskDfYrd8idvTCfHb9DkGLChd7ERw0z5mxH5Pm2bYfylU308GhhVkWxH7+FFD4+r7S33+c97/exv73zXE/xdUxqYTjX+Wt+TDutR0pG3emvL0/3cJ+ePNcdWfK+MS0T8gV9eS0WGWM3n5efHWzZlpr+oR6ctr7+GV79kMe1CBppEje+fZJWePXms4PB/P/+ZWtr7+6Z997PufeDbz85sHzvwzo/9dQ3Z7HU+/el/9l32l0LvKghjxIubwVgzlYaD5RQ24K34zZdrlJQx7UxBy07bdGtoaXDWrI6YHGetIDN39LQR6XfbttXzpSbeE+pGRT+GaTufela8iDhfswgTEWbYBAXJFlZT88ieb7COzgiHRiUvP197duR2Df/3AXgcqhMAR/8vzyLc9bz2+PrqvHPa5u+z4C63ydc+vdjh4LjoiIiImJiYqKioiIwGKxbDZbq9Xm5eXdunWroaFBq9WGh4fPds+X8+rDM7efJ0+eWgS1n/v3I5189dDQ0KfFZU+Lyxzbz9PisiJdlJP2M+d3mCcxsx8T45ml/ZgNJJge9Wxx2I3dY03m6g0UOyM6JlhJgG29sDUWoj8nzugci7EIlpn72I/FQT+27cf2EN18lgXZ8xVwueS/Psz4t7cS//UPMf/+dkxUKj7zUcPaTxLdPLLf3v/orf2P/UOLbe75WiT14RnsZ2xyWqI2ZspgP1umpnUSlfGJscnpg/bthzqkQdLWx4pIvDBN8dBU/crt479iNh3GRKkx8ROY5CkMdhzzUISJHPh/WfJf3FG/v/s4Ohd1SHNlK8Yzg3Jlq02nCfTcisFsDS83KU8d0lAzAjd/R6FaTBzSUDMCMT6F1mXKv9vmmYGUKfREamsJ32woGeuD8czQUIcKPTGBsdZ1QiBLnmVoP4IhycSk5vtrN929At/+884eUh+ZIbj9IOH/ffrwNx9FFNe05Fc+m5X9IH3cbFty9Fjw3bt3IyIi7t+/Hx0dHRkZ+fDhQ61W29/ff+PGjaKiIq1Wm5CQMIfjfpxUH55Ek52dPTITbDY7MvKukxWGhoYiF3fupXEdBCnjvP3M7R3mSUztx3RgYLZ7vuyM/ZhlhrGZeXmDnX1eZgXsYFANe80z3Qu2mItgyMKM/cx43M/CLQty1PP95Op/eTPqX998+Ms/3Pu/7z10D87wPpfvtjfv/YMl7x+seO9AZXhMvb2jnhdDfXjm9iM1xMx+pCZPjDkc+6ENa5AMSkvxDec1+JfvhP0Rs+Ygxj0O4xWH+TwfszsNszsNsyMe88EdzJ9vYN797k8ep9C5DKF8uTUw3nJioefW8ErDv5Xfb8NgDGUyAzHoU5mBGJ9CmtXjyu+3eWZqrB4b6mwJ32woGe+D8czU0IYLPTHWbYBAXJBlaD/cAZFEPiqSKkVi6YhQ1NpFJdJ4GSnX//WDyP/xXsSTyqbc8pbZ2s8cEnT02LVr1zo6OpAT3WNiYm7evNnT06PVaiMiInJycrRaLRaLXeyjntlOcPfuT05WGBoaOqpUjSpV773/YU5Ozu1bN3eE3Dz/7Y0/79/9532Hbt26mZeX9977HyJlZmU/8wxypjRydR/zra+Te75mGlToCH9jsa6yQ7l6PdDbONJj56gdkyW1s+fLZBDF6Bnm0xf/QkG2mufkEJfpp4AMXNk752shlwU5472yuuGzwwn/8427v9x6972DWHxTR2sHxeNk1Zt7at7Z33DoIq60vHGJz3jX249mWjo2LVVPy8amZWPWYz+GjE06Ou6nf0TTP6JhjkilijhV8x+Vxf/2i7fOYnbcwRzLaiRwkWedCOUr22M/4dVmxQq9MIFevhgv30AMBrPle0qCr3mZzECMbyFaoVemfnr199sMjwu9kPKt4VtMXscrU195grMNhkAWMcvQflj8ERp7kETndZJZLd10XDull8Z7+a/nfvH2Xcy2n56W1y+N/RwJOhoWFqZUKpEjfqKjo2/fvl1XV6fVamNiYrKysrRabUlJyWLbT2pqSmpqSmJiQmJiQmxsTGxsTFTUg6ioB/fvR96/HxkZeffu3Z9+/PEHJyuMNrBmzRvI1Q4/y9D0ScQ7bpxefzwcud7PmjVvoMUW+03mSQyDOibjCogDzeqMd3vnfBmzFCdMmTTV/mvZG1wxWQSz60AajcG153yhrTJeWcBySU0XwfjJ6rEaDFu4ZUGudlhW1fxpQOyvtt1550BaZV1Pdy/r00M1m7c3+Z9vflzSvuBXO5wxhrEfrVRtyJjWYD/rN6sntb2CCcLABEEwQRBMCJWaA8dCJyZt2w9TqGEKNXwxTSmO0JW+eOjcXsz71zEXyjF3KWtPJ5Q30YgcZWhC9X+7rttUpvunBN0/Zure33sWmcs8hfsxgYnov63hW9zCay3KtIZvwWC2hFGYWYFbwsL3YzD7s6zr0TCFmtqwbRjfwkRfDAYpb/oqSLWt4Vt8C5GJib5IPeYNgEBcl2VoP3T2IInO6yKzWnvo+HZKdQuR0Mf99buXMNt++sXbt5fOfo4EhYeHd3Z2arVaIpH48OHDO3fuJCYmZmRkXL169ebNm1FRUadOnVpU+1nU5ObmIvZzvyZrje8ffuMVptPpcnPneI3KOUR/HWfblwdEd4QZxn5sxGTvicMLIS7V9X6MgxlmomB/txeC47PSFnsRnLmaNrI4tq0oJ9DpRVi0ZUHvdFHdcC+x3Pdczt/80j8LyPc/VxsR31ZW2bRId7pwnInJaZ+QKyKVljyipRgypjGc8a4Ym6rpU1RTFdVURS1VwRWPewVdsGc/bJGGLdIMybom+o5MZW7dcCQBs/0B5loXJpqJeaTGJEsx92gnunTv1OswWMVv8nW/+NO3bSQBMpdlnoVvwQQmiTRsUeEBzLa/PzN9lvJ3NwxG/6yGnRW4JYyin+gWXm9ZCQbjW4hOSfLFYDCYA1nIv4UHHK1QhvohEJdmGdoPuZ/fTWG39vQ3dFBrWohl+O4eKuf1nZf/c/tP/7n9p8fl+KWxn4uXLiPH+iBERkbevn37+vXr33333ZUrV86fP3/q1KnTp08v5p0uFjc273SxlPazsEH2ndnsbZfuWs+wCPYXYXGXxUV3OXUQxH4E8ukm7nQTb7qJN93Mmx6dMFztUK7WlPeKy3vFZb2SMoKEJRzbF3huYtKyI0Z6Z65YwxVrRuRtkzVusV+8TWTL/+HdrzBf4DGJ/N/W6r4k6s4QdK/jdf+tQLe+VPePn1zPL29BZkGDnVFy3cKv+mG8s80KI/9yxRpuu36EFmv4yYIzr58r1nDFlKtuyCyF3rYLaLjiQm9MINb2UxDIkma52U9kXK6TWezOq6uPH/rFlcMOWdy7nC5ycnNzY2JiYmNjY2Njkf1csbGxK9d+IBAaV1hahbv3IPry5S8vX/7y3oPo0iqcq+7aOzGpReyngTPdyJlu5E43cQ328/zajTLVZEnXUHHXUHHncFHnMHN41OPQaXv2w5do+BLNiIygLd4S89VHfImmsqHzt+5f/8P5YkyK6N9LdP9cqMM8YP7Difzf+tys7WIj5SEQiIMsN/uBQCCQVRDEfvio/XCmG1H7eW7tBplq8mkb/+kz/pNn/IJWXv+gYo//SXv2MyDVDEg1Q1KhpvovhCS/yqfRUvJTZcPXCd/88fq1k3t/yNv9fcaXcSXNpAGkJAQCmTFgPxAIBLLgQe0HzzEO/yj19vPya9LRiUfN7Pwmdn4TO6+JTRfI3f1C7NnPkEyDRCLGy7PfHUr/S8399+oyfGikZ+hTEAhkVgH7gUAgkAWPqf2gAqS3n9+/9KpEOZ7XyMhtYOQ2MHIaGDSBbLfviUmNbfsZkWsgEMjCBuwHAoFAFjyTGjP7QQTIzH5y8PRsXH8Wjp5VT+/jS3f7Hre2n1sRSQq1RqSAQCALHIVacysiCewHAoFAFjCo/eDY03i2LfvJxtGz6mmI/VD50t2+JzRW9hMRlaZQayRKCASywFGoNRFRaWA/EAgEsoDRaLQ+IVd48mkc2yhA5vZTT8/G0bNw/dm4/j6+zNp+qutaHxfXKdQa2SgEAlngKNSax8V11XWtC/vNB/uBQCA/51jYD86G/eDo2XhGNp6R3cDsE8jc/UJuRSSheRifXVLZqFBrIBDI4qWksvFhfLbpVw8CgUAg84lPyBWebLqebRQg8+N+Gpg5DazcRnZuE4cmkO8JOOXyLQEEAoFAIBDIfKK3H5ZRgIxnvEuUE7lN7NwmTl4zL6+FTx9U7j102uUthkAgEAgEAplPEPupYxkFCLWfDdLRiUct/EfPBAXPBgqeDdKHRj0On3V5iyEQCAQCgUDmE5+QK1zZdB3LKEBK9E4XUtXk4/ahxx3DTzqETzqFjGG1Z+C5ZAAAAAAAgBWLTqcztR9EgJToXU5lak1Rt7ioR1xEkBQRZEzhuFfQheTk5GAAAAAAAIAViEwmQ+2n1tp+Xnhlk1w9VUqUlxIVpSRFKUnJEk3sP3oRsR8dAAAAAACASxkfH+fxeIODg2KxWGqCTCZD/qLI5XKFQjEyMmJmP0yjABnsZ/1m+dh0OVVVTlWXU9Xl1DG2WHMg+BLYDwAAAAAAy4F52k8N0yhACsR+Xnx1s3xcW9U3XkmbqKRNVPRNsiUa7+AvwH4AAAAAAFgOLIz9MKdrTexni2JcW0WfrKJPVtImK+mTbMmU9/HLYD8AAAAAACwH5m8/NWA/AAAAAACsIOZpP9VMowAZ7Uc+pq3sG6/om0ACe74AAAAAAFg+zMt+pNPVTKMAKcYR+1m/WT42XUZRlZLVZWR1KUXNgqOeAQAAAABYNtizH6VSqVKplEqlA/vhSKerGUYB0tvPC69skqmnigiyol55IUFeSFAwheNwxjsAAAAAAMsEm/ajUChUKtWGDRtMBciu/TDM7WfNutelKk1Bh7CgU1jQISzoENGH1Z5HzoP9AAAAAACwHLC2H0R9fve737m5uXl7e6MCZNN+qhjG4R+9/Ty/dqNkdDK3RZDbMpDTPJDTMtA3oPQ4fAbsBwAAAACA5YCF/SDq8/zzz3/yySeXL1++ffv29evXEQGyZz+oAOnt57m1GyTKiUw8OwPPTsez03FsCl++J+CUq+wHg8Es2VwAAAAAACx/LOxHpVJ5eHhcunQpISHh0aNHpaWltbW1JSUlKpXKgf0gAmSwn5dfEyvGU2vpqbV0bA0NW00jcSW7fU/Mx34wMzHj7LOq33QWm/POpzEAAAAAALgWm2M/1tgb+6lkGAVIbz+/f+lVkWIsuYqSVElJLCcnlJOIbPEun+B52o/z/844uzOFnXGg+b8WAAAAAABLz3zOeEfsp9KG/cjHEspJ8WXE+LLe2BICgSXc6X1sie1nVsMzNi1nDuoz28IAAAAAACw987Wffhv2s14kH4sv640vJcQWE2KKewjMkR3eR5fefpyszXSitf3Yqwf2fAEAAADACmUB7McgQEb7EcrV8WW98SW9sSULZj+zPdRmtvZjc/ocVAbsBwAAAACWOfOxH7aJ/VRa7vkqI8WXEeNKe2Nmv+eLxBKQWALTKUs59mMhVbO1GZvlkSWCQCAQCASy2HFmYz1P+6noNwqQmf0kVlISKygJFeT4clIvW7TzoLNHPdts92Lbj2PFsdgd5jwO6gQAAAAAYDFwRoAWzH76p+XoGe8ixTi2hpZcrY/zZ7zba/Hc7McZLzEd43FQ2LHNgOgAAAAAwPJhRgEaHx9va2vLy8uLMSc2Nhb5i5KTk9PZ2WltPxXW9iNWjqfWs9LqWWn1rFQcm8yT7/E/OU/7me0oy2xlxV55Zwo7Y2MAAAAAACwNzthPXl4en89XG0Au8CMWi4VC8ciIcHh4ZGBgkM3mdHcT8vPzbdpPhan9PL92o1g5mdXEz2oSZDYLMpsGqAKlxyGn7nSxsGM/jl/LyfLOTDc1MFAfAAAAAHAtzthPVFQU6j0KhVIml0ulMh5PwGZzGUw2jcboIRDxDc29vaQHDx/Ys58K1H7WrHtdotLktY3ktgnz2oR57ULakMoz8Nzytx/nB5YsXsWZvWMAAAAAACwNTtoPekFnmUwukUhFIjGDwe7r6ydT+np7yS2t7fX1jd3dBGv7Kbe2nxde2SRVTRV0SR93yx53ywq65fSRca+gi8vcfmzO4oz62HwAAAAAAICrcN5+RkdH5XIFoj7Dw8I+Wj+JRO3pIXZ09DQ3t9XVNXR19di0n3JL+1m/WaaeLuwdLSSOFhFVhSQVQzh54NilOdvPjFIyW2txgMX+LAfF7JWEESAAAAAAcC0usJ8XX90sG5suJo+VUMaLKePFlHGmWOMd/MVi2I/pjifHszhgxkOqLQ7rsfYemw0ABwIAAAAAl7A09lNubj9b5GPaUupEiT6TLLHG+/gc7WdGh1jAgZ+5AZYDAAAAAMuKxbUfidF+yi3spwS1H8rEfOwHAAAAAABgViy6/dBt2M9m2dh0EXmsmDxWTBkvJo8zRfPa8wUAAAAAAOA8LrAf5Kjnp72jT4lI5nvUMwAAAAAAgPMshf3QLeznlU1S1dSjLmlBl7SgW1bQJaMPz/eM95VISQf74L2qd7/Mh6z0HLxXVdLBdvUKBQAAADjLEtkP3cR+1qx7XTKqyXk2kts2kvtMmNsmpA2pPY+c/7nZT3HXYBNT4upWAAtAE1OS1spzdSsAAAAAZ1lU+2GZ2g/d7E4XExmN/IwmQWbzQGbTAHVgdN/hs0tvPwt1s4u5Udw1uIC1Aa4F7AcAAGAFsdj2U2ZtP8+t3SBSjKfUs1Jx7FQcJw3HpQgUc77Pl5OX4bHHbC/843zhGQH7WU2A/QAAAKwgXGE/L78mUownVdOTa/qTaxjYWiaZJ98bcHpBrvfjzD0uZlXAtORs1coxYD+rCbAfAACAFcQS2E+Zhf38/qVXhfKxhEpqQmVfYhUtqbqfxJXtCTi1ZPYzh7Eie/U4bq1jwH5WE2A/AAAAK4ilsZ8yK/tRx5WR48spCRV98ZU0Ele6x//kUtqPvfodlJ/tqNKMgP2sJsB+AAAAVhBLZj9llvZTSoorI8dXUOMracT52c9sx3Kctx+LGtDHC3IAENjPagLsBwAAYAXhIvuRqeNKSfFlFMR+lvnYj8WzC3XsM9jPagLsBwAAYAXhOvspI8eVU+MraQlV9JViP84UcB6wn9UE2A8AAMAKwlV7vsYSKqgJlbTE6v6kGiaJt9yPetZZ7QWbP2A/qwmwHwAAgBWEC+znuZdfE8nHE6vpSTUMbB0rpZ5N5sv3Hpr7Ge+Ld9yPMy9hs7DjpUAA+1lNgP0AAACsIFxiPxtEivGUOnYqjpOG56U38KkCpcfhuV/t0Pl/HUy0WQxVGXuzgP0ACGA/AAAAKwgX2A9yp4v0RkFG00Bm82BWy3DfoMoz8Nxysx9nZpnPvjCwn9UE2A8AAMAKwgX2g97lNKdNmNsuyuuQ0IbGvIIurA77gbGfnydgPwAAACsIF9jPC69skqqmHnXKHnXJCrrlBT2K/pGJ/cdC52A/NuVjVgWcBOwHcAzYDwAAwApiVvYzOqoaHVUplUq5XDE4OMznD3C5fBaL29tLno39rN8sVU8/6R192qt6SlQ9JaoZwknv4C8W1n7sHa8zZ/tx/qhqJwH7WU2A/QAAAKwgZmU/avXY22+9dfjQoS8uXUIScffu44ICOp05C/t58dXNsrHpItJYEXm8iDxeRJlgijXex2dtPzOax0Kpj4MZwX4ABLAfAACAFcRs7SfoyBFscvITA9XV1c+ePZut/WyRjWmLKRPFlIliymQxdZIpnjp4/PLcjvtZuYD9rCbAfgAAAFYQLtjzZdN+vMF+gJUM2A8AAMAKwiV7vraY7fkijzNFmrkd97OiKe4abGJKXN0KYAFoYkrAfgAAAFYQrtjzhRz1TBh90otE1S+cPHDs0s/NfnhidWmfGLI6whOrXb1CAQAAAM7iinO+XtkkVU3ld0rzO6WPumSPumT04XGvoIsr3X5YbG5lNS43vxCy0lNZjWOxua5eoQAAAIDFwgV7vpCrHWa3Dme3Dme3jmQ/G5nPtZ6XD1zeyLBI5upWAAvAsEhGZw24uhUAAADAYjFb+/nu228fFxTUGGhubu7p6Zmd/ejvdNHAS2/gpTXw0hr4FIHCY653OTVlPuefzx8ub8SFrw4sLGA/AAAAqxgX7Pl6bu0GkWIcW8tMrmUm1zKSaxkkrszd/+SCjP3MVoAW8OqFYD+rCbAfAACAVYxL7vH+mkg+llDZl1DZF19Bja+g9rLFu32Pz+1az05is7B1/WA/AALYDwAAwCrGBfbz+5deFcrH4spIsaWkmFJiTAmRwBLuPBi8IHe6sMmMN/+abYU2AftZTYD9AAAArGJcZD8ydUxJb3QxIaqYEFXU08Mc2el9dP53ujCdYnHDL3vF7M01B8B+VhNgPwAAAKsYl9jPeqFMHV1MiCrqiSrqeVjY3cMY2TF7+zFlxpubWpe0OQXsB0AA+wEAAFjFuMZ+RvT2Q4gq6nlY2DMf+7HWHcc2Y33cD9gPYA3YDwAAwCrGtXu+kBB6mMI57PnS2RrysVYZiynW0mPvKOnZAvazmgD7AQAAWMW47Kjn2DJybBk5tpQUW0qa81HPCPaUxd7Aj71nHczoDGA/qwmwHwAAgFWMa854FxrOeEcytzPerXdgOR7CsRgKctJ+nB8KAvtZTYD9AAAArGJcYj8bRIrxZP3VDpnJtUwSV+ruF7I0VzsE+wGcAewHAABgFeMC+0HudJHWwEtv4KU38NMb+BSBYm/AHO904fhaPg52h5keKmQxXAR7vgCwHwAAgFWMC+zH5l1O9831LqdzsJ8ZD22GsR8A7AcAAGAV4wL7eeGVTVLVVH6nNL9T+qhT+qhLRh8e8wq64JKxH5uA/QBgPwAAAKsYV9jP+s1S9fQTwugTwuiT3tEnvap+4cSBY6Fzth/HWJe3V/l8dnvpwH5WF2A/AAAAqxgX2M+Lr26WjU0XksaKSGNF5PEi8jhTpPEO/mJBjnq2YLYqM2f10YH9rC7AfgAAAFYxLrGfLbIxbTFlwpBJpljjfXxR7GcpAftZTYD9AAAArGLAfhYMsJ/VBNgPAADAKmaV7/laSri8kWGRzNWtABaAYZEM7AcAAGAVsxyOeh6dz1HPy4fR0THesBSyOjI6OubqFQoAAABYLFx8xjsS+vCYV9DFlW4/AAAAAACsCFx+tcPh7Nbh+Vzt8N69e5cuXTrjIi5dunTv3r35fAAAAAAAACwxrrvTBZ6HhiJQ7D00lztd/HjzZkRExNDQ0JSLGBoaioiI+PHmzXl+DAAAAAAALBmuuMvp2g0ixXhyDSO5hpFUw0iq6Sdxpe7+J+dgPxcvXhwZGZmcnFS4iMnJyZGRkYsXL87zYwAAAAAAYMlw3n6USqVMJheJxCMjwqGhYQqF1ttL7uoitLV1Nja11tTinL/H+2tC9O8TJQAAIABJREFU+VhCBTW+ghpfQY0rp/Syxbt9T8zBfs6cOTM1NeVYUEyv+4z8i063V8xiFsdMTU2dOXNmnh8DAAAAAABLhpP2Mzo6iqjP8PDI4OCwQDDY20vq6uppa+9sbn6GwzdV19Q7az+/f+lVoXwstowUW0qKKSXGlBAJLNEun+C52Y9Go5E7BwaDsfjr5CyO0Wg0YD8AAAAAsIJwxn6ysrL4fL5cLpdIpCKRSCgUjYwIGQwmjdbfR6NTqX1kMpVIJLe2tqWnpztnPzJ1TElvdHFvdDEhqphAYAl3Hpy7/cjsg8FgLB7Ym4j8a42DyhHAfgAAAABgZeGM/TQ3N2dlZT14+MBx0tPTKysrnbGf9SMydXQxAcn87UfqEAwGg/61N8XxvI4B+wEAAACAlYUz9sPj8QYHB8ViselGXyaTIX9R5HK5QqFw3n56o0t6o0vQPV/H52Y/k5OT4pnAYDDIXwR0imkBxziofHJyEuwHAAAAAFYQLrGfV4UydWwpKbaUFFtGnudRz5OTkyKHYDCYWU13/JQ1YD8AAAAAsLJwkf3Ix+LKKfEV1IRKWkIVnciVuvuFzNl+hPbBYDDIX2vQZ01LOn5sE7AfAAAAAFhZuMB+kDPeE6voSdX9STWM5FoWiSffE3BqbvajVqsZM4HBYGacgk5E9cheMQvUajXYDwAAAACsIBbRfk5cYUmmy2jGGO1HpBjH1jJT6tmpOE4qnkcRKDzmdK1n5+3HGgee5Lz6gP0AAAAAwIpj8ezn4IkrLMl0Kc0Y9E4XG5A7XaQ38DOaBjKbB6kDo/sOn52z/dCdAIPB2Hxss4z1AweA/QAAAADAymLR7advCo18TPvSq1swz6/bKB6dzGwezGoZzm4dyXkm7BtSeR6Zy11OEfuhOQcGg0H/Wj9lOt3isc1ZUMB+AAAAAGBlsYj2c/wySzxVQp1EIxvTvvjqFv093nPahLltotx2cV6HhDY05hV0YW72o1KpqPaZ8VR2e7M4qNMClUoF9gMAAAAAK4jFsx/v4C+YIk0ReRyNwX5e2SRRTeV3SPI7pfmd0kddMvrwuFfQxTnbD9mlgP0AAAAAwMpi8eznQPAlhnDyKVGNRqaefnH9ZswLr2ySqqYedckedckedcsLuuX0kfH9R+doP6Ojo0SXMjo6CvYDAAAAACuIxbOf/cdC+4UTjwlKNFL19AvrN2NeWL9Jqp4q6Jajmaf9EFwK2A8AAAAArCwWz368jl6kj4w/6pajkaqnXli/aYHtR6lU9rgUpVIJ9gMAAAAAK4hFtJ+gC/ThMeTYHiRS1dQLryyo/Vy8eJHL5YpEoi4XIRKJuFzuxYsX5/kxAAAAAACwZCym/ZynDanzOsRoJCrNmlde19uP6aAQfWTca072c/PmzTt37vD5fKWL4PP5d+7cuXnz5jw/BgAAAAAAlozFsx/PI+dpQ+rcdjEag/2YHvXcJZvPOV86ne7GjRsXL1484yIuXrx448aN+XwAAAAAAAAsMbO1H4VCobKFUqm0Yz8iNItiPwAAAAAAALNitvajUqk2bdr00ksvvfTSS+vWrXvnnXeCgoJu376tUqnAfgAAAAAAWAHMbezHw8PDz8/v8uXL6enptbW1Dsd+FnnPFwAAAAAAwKyYw3E/iABdvHgxOzu7vb0dUR8bRz0fOU8bUue1i9EsgP1MTU2BAAEAAAAAMGdILMHU1JTjMoj9DA0NSSQS9ABnpVKpUqny8vJQ9Vki+9EZBAgCgUAgEAhkDplRfVD7EQqFUqlUbsLo6KharR4dHUWnKBQKpVLpxBnv87MfAAAAAACARQWxH4lEgviNA5Ar4Jhe7ZA2NJbXIUEjUU2teWUT2A8AAAAAAMsaxH5kMpm166DGYwqM/QAAAAAAsLJB7MdadEZHR5G/FjhrP6a3wKAPj3kFXQD7AQAAAABgOYDYj7Xl2MN5+5GgAfsBAAAAAGD5gNjPyGyY4Xo/a155XaLSmF4GkTak9jxyPjk5WQYAAAAAALAy0el0noHn+gZVOc+EaCSjmjXrXsesWfe6ZFST82wETd+gyjPwnKs9DwAAAAAAYF7sCzzXN6jKbh1Gg9rPRsnoZFbLEBrqwOi+w2cjAAAAAAAAVjIeh89SB0YzmwfRiEcnn1+3EfP82o1i5WRGowANVaD0OHTG1boGAAAAAAAwLzwOnaYIFOmNfDRi5eTzazdinl+7QaycSGvgoaEIFHsPndbpdHKxGAJZhqFQKFDPz7AeCGQJsqxW12XVmJUYnU63N+A0hS9Pw3MN4YmVE8+v3aC3n1Q8Fw2ZL98bAPYDWb5ZbltlqGdp6oFAliDLanVdVo1ZidHpdHsDTpH58lQcB425/eC4aMB+IMs8y22rDPUsTT0QyBJkWa2uy6oxKzE6nW5PwCkyT55Sz0mxaT9peB4aCl8B9gNZzlluW2WoZ871VNf13EvBnY2s9r1efupWZXhMdUVV5wB3QCYSLchLQyCzjfOrvUwk4nO5VDIZj8MlJSbW1tRQSKRhgcAljeno6sl/XPQwNulhbFL+46KOrh6Xv5PLIaj92Bz72ShWTqY38NMb9AcEUQQKD9vH/bRf37r1ersTL5nth/HLlmf7YTB+ea5eeMjqywraukM9NuuRjAhlIlFkGv7zW/E+Od9dqr4dkv5k540674hOryv1ZzPC29oo4uGRBXn1xU+2v52Oritsq1tY9vWtGEu2hnWh8xofI1VZ9bHtYW7W5c0mWiXbzy2s3eke2LoNZnN1hVkvAMoq7OGdXO3FIyO1NTUFBQXx8fHZ2dlMJpPP53M4nOamps62tiVuTFkHJzwqBVtQVdbBwVOGiuraYlPzyjo4Ln8zXR6TPV/cVKvjfgznfDUJMpoGMpsGqANKj8NnbI/9IFoz40u2h7khxdAHEMjCZflv3aEex/XIRKIrD2u3YIP8y7+5lFFwk5y8K7phb3JHQApp19e4Azcef/NDZWsLSSoUWsyIbon9sxegYQsUe/aD/Fy0+tFo02ZMn7WoTV++3YZFmYmUSRD7Ec/UY2f7mVfl52/+EkglXWFb9bWJLbr09utbf6b2Ixoerq2tLSsrS0xMbG1t1el0aWlpOp2Oz+fz+Xwikdja1LRkjeno6vnxAZYnm+yX6H7pnv9L93y6WNc3Mpmc9QRGgEyOeualNfCQgR70nK+NYuVkRtMAch68/no/gef09mPx9bAC6YMc/jjAOCVMEIjTWf5bd6jHcT0/Rteti/N8i7SpRVQh11BKG+mBjwn+dZzD2X37rjVfyMvYfuVe+P0KNoNnXVueH8a4MbaR9utbF8mN7NVsx36M1mLbfvJMOlf/7Gx/K6/RzzXD2I/1jLPrgfP8MJitW/0NbynSmZu+w2A/FuFzOIWFheXl5ffv3y8tLUVOq87Pz9fpdNPT01KpVCgUdnR0sBmMJWiMXCzOf1x0N6umZ0jXM6j7pXv+/zpQTB7RUUS6Qjw5/3GR7bmy/TCWPyHQFcnth3ZHEw3rrUmxbD+M2zW7I5EujU6n24uc8d7AT0cu69M0YHm9H0R9sluH+wZVpvbjoKPpCtuK2o/Z+whDPpDFzPLfukM9DuqpqulZ+/2JV1sPHGZ6s8Ya1VpOH2f4FmPAp0Hgn0M7EN5+a9gvbPjDd4Pul5TZ6HxWiv0YpMHWmI2NsR/LQaA8P2TcyMSQ/Kx/i9qRD6d74Dw/DMbPzx/jdz1sq1tYe54fxi0sDPkXdSbY82WR2urqoqKivLy89PR09KIyjY2N6GOZTCYUCnF1dUvQGLlY/DA2KbasG/Ge/3MU9+sLXf/xDe3/hrGqntEexiZZlW//wQ2DcfPzdzNdmdt/cMO8ec0wXqj/WG1NREcT26+9qTceu3t+l0OQ6/1QBcqMJkFm00Bm82BW86BkdHLNutcxz63dIFJOpOK56Q38jKaBrJYh6oCJ/YiRkVjboO+dpf2YfqWX8fsCWaFZ5lt3qMdxPedv5f5jzMbfZ33+fmdwsjxcMCy/ldbs3znsXsHZn0bZ/V3j33nvXBh42+378zcjq6xrM7GfbH/M1uthhp+iYe1mAyFWQyOGuRCJyfbXl7GuRCy3MaN1zWKTkta9XLa/fkZ07MdQzPaeL5v2I5Yj8oE8Zflb1P7Qi7X9tIe5WR5RhMqc/qUNumZoZ7Yfxmy6dc0/07GfxwUFFRUVRUVFFRUVqPEoFIqYmJiLFy+Gh4frdDqtVtva0uKgknW2mENj5GLxw9ik5IouU+/5zVX6v1/oqn3WZ8t+9J/dD6b2037tTeM6bHjK1sSua26GubL93a4hQ5jLaTe0ZUzsZyCzeTCrZTCrZUh/p4vnXn5NqBhPqmFg69mpeG46cq3nw2dndc6X2Y8DpEOx/tpAIAuUZb51h3oc1/P26fBNHqkbfdLeOpr+yemsK/drDhBl2xuHP37E3PWAsP1y403RX/zom16L+ovPKRvj9ub2Y9itY9y6m47QmB5EjE5HBlTQbt1mJXZndHLspytsq9tWi97PriRhkD1fduxHv6NBfx6JjaEXq7GZrdfbbR5OZOucFfvHNriZ7Asz2Uz+rO0nNiamurq6qqqqoqKioKAgKSnpzp07VCpVo9Hk5+eXlJTgcLi///3vWCxWp9PR6XTHLzSj+jhuDJr8x0WphXUDCt3wqA7xnhGVTqjSVeFIuY+e2pnL3H7Mjw/L88O8ea19honouU0LsZ/HSRecQ1D70Q/8tAwZ7/P1+xfXj8jUsWXkhEpaUg0jpZ5ter2fGQ7oMXxDjPZn3NXtl2d9+B4EshBZ5lt3qMdxPWuCLr3pWbwxuGbT7d63Uijv5zLff8R+P73/rw+In37b/mEw/m89azZX/PrXEX94f89j69osx36MjmJlP1abdnRXlInE2KrEqRlNa7Ds6PLCwvLsnfClVxTDIcbocTxWJa63Iz3qVretYXlhW/39HI/9mBrPQnoJ7PlCw6LT4+LiGhsbs7OzY2JiwsLCWltbp6enhUJhdHT048ePdTpdcnLyt99+q9Pp+vv7Z3ytGbf0Th71fD82qX9YJVLp/u1I/f/cVyhR67hidUrao9KKajtzmdlP1zU3a9GxOVFuPO7HL0+/5huGRed36M/Cqo9Op+vq6pKb2k/zQJap/bzyOua3L7wyLFU9eNoVVUxAHIjIkbj7hViO/Rj39lnvUTY5rM/8gL7lPCAGWblZ5lt3qMdxPRuOfLPBP2LrwScbDuRsOJi+0Ru7OSDz7Qs1H3317MMTDX88UP5SrPfGnw5t8Y3xPDRv+7FxSpRz9jPzjKY1ODjuxzCv31Y3zFa3sGzLeQ17tSx+QyNjP3l+GP8ww54yO2M/llUZ3qUZu98Zf9xiDJ05jP2gYdHpDx88SEhI+Prrr2tra6enpycmJnQ6XXZ2dkZGhk6ni4mJQXZ+0Wg0Z17O8Zbe+TPeYxKwtc3P8K0dLW2dze3dqRl5XwZ8WlNRYmeWuY79mFSCrBjo6jH/XWALOOozODhYUFAg19vPGapAiQz8ZLUOZ7eO6O3nv9asHZIo7+Q2Rz5qu/+kM6qIQGAKdx4MtrAfs9Ed9B3R9xEmX37D+5Xnh55oYDUGC4HML8t86w71OK7n4jel69588tqHOVt25/yBuGcX7Ugw40v/vPgPguve8cG97Vf//rHa944+ecv/0fXbFda1zcJ+xNn+Jr/B8vz0x3LObD9OzWhawwz2k+e39Xp7tj/GL8/y2J0ZDhLICwvrsrq0D7pTzLIZpsVMf69uDeuyt+fLNLb3Ypgrzs/efuRiMZVIvHHjRl5enkqlkkqlOp3u6NGj0dHR169fP3fu3NWrV8PDw8+dO8diMpegMWhMr3aYV1CYfOPUQ9/Xvgz4tKai1FZ5K/sxjtwYnrI5UWwyi1+2XNz+g5tx62+hR3PIQu3wQmM29tNiPvbzX8+/PChW3MqoD89quJPbHPHoWRd9aPv+Iyb20359q8k5kxb2g+75M/wuQWQQGdf1z4bzvyALn2W+dYd6HNfztLhj3ZvF697NXJP66b/U7nq7/ei7Pce29508mB/zwdnGv16s3Xuvxy+H8tmphieFrRZVmV/vx6a4GMpY7VEy9N3O2I/NGc1rFpvWMMM5X4bWGg7TMXaJiLLYusghGr392Dmz3fQAauOQUDbab+ubYd9+jL9UkZ68PczN9Ohvi2EwsB+xWC4WN+LxAoGAz+fLZDKdTldcXPzo0aP09PSWlpZTp05duXIlNDR0XK1emsbYS86ZbREH1n7ha1OALGzG5F+j9NiciARd541llsPhz6Y7vGbe8/Wfz788KJLfSK2+mV6LOFBHn+CzfYcQ+8nzw2AsvzNmX0L/bMsfIiajPvrTNeHAZ8jCZplv3aEex/UMcAdOXypf98fH6zwj/yFmwy9K/vBC8943uoK2dgVsJe9462jq/qTOv55pvX6nkk5bERerdWA/2eYDUWZj5HqX8st2fGERi8s65/lh3MKyr/uZHuJj7xAcpK+261VIA/S/8jFmfTX6lOUmDbEfVA1X47i+k6t927NnXC5XLBbrdDosFpuUlPTgwYPHjx+fPXv2yy+//Prrr11uP1FRUTln3gnft+Z8gIfJ9PYfzA8xM+zVufYmxmpFsjnRxvliqHO7+LNDd3iZ7/nSH/Vsx35Sqn5MrbmZVnsro66dyvvEIwDu8wVZtlnmW3eoZ8Z6Wlsp3kfK1v2x4DnvsN+k//X5it2/w3/wu+a/vfHs2PuXsv4U0nDxh3o8nmB9redlmUW+rgdiPyaD6/qJy2aTs8ri/Grf1tpKo9F0Ot2TJ0/S0tLi4uKqq6svXLhw9erVy5cvj6lUS9kYm4mKiso+/VbIvo9c/q66Kmb2Y3PP18202pvptbfS625l1LVTeJ94+IP9QJZtlv/WHepxXI94eKSlhXzhq8r17xT87y8+/XXyx/9R9faWtLCPblV9Glb/bXgNHk8YGRxekFdf/MBVzVZVZrXai4aHBTxeaGjoN9988/XXX9+8eTM0NPSLL774+uuvVUrlEjfmZxubO7ws93xZ289v16wbkih/ym5A00HlfwpjP5BlnOW/dYd6ZqxHMiJkM3hPCtuO/x27af/F1w/f3uX3+LsblY+fttJpnJVzi1PIasusVnuFRKKUydRK5ZhKNa5Wj6vV4yrV2OioSqlUymRL3JifbdD9XFwuNycnR25zz1fzQFbLkJn9/O6FV0akqnsFbfcK2iIfPYt81NpFH/jc8zDYD2TZZkVs3aGeBa8HAlmCLKvVdVk1ZiXGxH70Az/GM95//9KrQrk6pqQ3upgQXdwTVdTdwxjecSBIBwAAAAAAsJKxe8b7cy+/JlKMJ1bREir7Eiqp8RWUNtrID/eSdnof2+l9dIf30R0HgnYcCNq+P2j7/iNIPvcK/Nwr8HOvI2gMTwVt339kuxdaINDwVBBSyY4DR3d6W2bHgaPoszu8j+70PrbzYPAun+O7fU+4+4Xs8T+1J+DUnoDTSNwDTu/2P7XT7+QO35DtB0987n38swPBn3od/dTr6KdeQZ95BX3uFfT5/qDthqp2+wS7+57Y4x/iEXDKI+DUXkP2+J909w3Z7Xt8l0/wTu9jOw4Ebd9/5HOvwyYJtB90eY9s3x+0HWm899Ed3sd2Hgze6XN8l++JnT4ndh48vuPg8e3ewZ8fOPbp/qOfeAX9bV/QRx6BH+45/MHugD/t9P/TTr/3d/i+t8P3ve2+7+/w/dMu/w92B/zF/dBf9x7+yOPIx55Bn3gd/dTr6CdeRz/xCjLG88jHnkc+3heI5m/7Dv/NwyymzxqLeVgWm00CP94X+LHnkU+8gj7df/SzA8Gfewd/7n38c+9gYw4Ef37g2GcHjn22/9hnB459duDY52ZBSx7ffvCEg+xA4nNip8+Jnb4hu3xDdvuddPc/6e5/yj3g1J6A0+4Bp9z9T+72C9nlG7LL98RO3xM7fY7vOIjmxI6DJ3b6oDOedg84vSfglD7+Ie6+J3b5BO80rthHrD9c5APd6X1s58FjOw8G7zoYvMsneNfB4J0HjV+K7cZ5j2zffwRdDXZ6H0Xm2qkvb8jB4F0+x3f5ntjtG+LuF7LH/+TegFMeh055HDq17zCSk/sOhXgEnPAIOL7XP3iP3zF336PuB4PcfY66+wbv8Tu+NyDEI+CUx6HT+w6f8Qw8u+/wWY/DZ/YGnN7jf9LdL2S37/GdB4/t8NZ/VT/3OmJr1T38uefhzzwPf+Z5+HNPw0qONB5dXm870b8Px3cj303fEHe/EHf/k8gbu/fQaSR7Dp12P3TKPeDk7oCQXf4ndvod3+l7fJdv8G7fYHefYHef4D2+x/f6nvDwPeHhG+LhF+Lhf9Lw3Ty5xz/E3S9kt++J3T7Hd/no323TXsjwRUN7D7R5pj3JUUMZs57E3f/knoDTew+d9jh8Zt/hs/sCz3keOe8VdN4r6AIEAvEKuuB15Lxn4DnPw2c9D53Z5xfi4R281+vIHo8Ad3df953euz/32vWpx67P9u363Gv3dq/dOw64u/vu8QjYuz/IwyfYwy9kX8Apz8NnvI6c9zxyzjPw3L7Ac/sCz3kcPrP30Ok9Aafc/UPc/QxfcN8T+m+lX4i7fwjSgXgcPoPM4nnknOeR815HznseOe8ZeG7f4XMeh8/uPaTv6Hb5HN95EN1qB5l0vMd2+QQj1e4NOLU34DSa2zEZPRxFhvWdLpC7nGLrWNg6ZnItI7mGUdrJ7+gXETmSXra4ly0isJAI9WHaiv5ZEVqmx3K6qJcl7mXbCkvcq38JkWGihMiRELlSEldG4slJPDmZj0RB4stJPDmRK+/lyggcaQ9L0s0UdTGEXQxhF2Okq3+kq3+kmzHSwxQSWMJelpDIFpO4EjJPRuHLDVFQ+AoyT07myUhcKbKYBJaIwBT2MEaMYaIxLIuN5TUuHYElIhga38uRENgSAkvcwxIjzevoF7bTR9pow619Qy2UwSbyQCNR0EDkN/Ty8L08PIHb0MtrJAmaSIJmymArdehZ33A7faSjX6gPXdhBH2nXZ7idhmSozSJ9+gfttCFDGavCfTPFZkmkQrq+VZ0MUSdT3KWPqIsh6mSIOhnCToaws98qDDQiwyySLpajdLMk3SxxN0vSw5IQ2BICR9rLkRK5MqJhfSBxZUR9pL1IOEhk+nBlRC6y5ijQUPhyMk9u9qHbXKVZQv2qyJEQ0XD1DwwrreFLYbGSs8W9bDHRZEbjem6sClmxZWRkhRTIqQI5dUDeNyCnCmRUgZTKl1D4EjJXTOaKSBwhiSMicyVknpTCl1MFcqpASR0Y7RtU9Q2MUgVKikBB5stJPBmJKyFykIYZv4Pmq7F+3e5mDHczhg0rucnyspEGS2x9T00bj0SmXwr06ylQGCInCeQkvpzElxF5UiIPnUVC5krJXCmFK6VyZVSejMqTU/lyqkBBFRg+HZ4MKWn67hm/Yma9hLiXLSayJUS0wSyxZSdj9obLyXw5RaCgCJTUgVHqgKpvUEUbUkMgEH0GVUjH0idQUrkyCltCYQjJ9CFSn4BE4RFJHCKBRexlEYlsIolDInFJVAGZPkRhCqkcCZUro/IVfYLRPqSSQVXfoIo6oKIOjFIESsO3G/mCy0iGPhDtQCgCBfqt7BtU9Q2paENqQyWj1IFRikBh3XvrezCTTozIkZC4MoMw6NPNllf1CjMaBagA6e1n06ZNUfHYos7BVBw3FcdJwXFS6tnYOlZyLTOphpFU3Z9YTU+soidU0gzpizePfnoVPbHKWFI/vYqGTEys7k+qZiTVMJJrmOZhJFX3J1X3I2USq/uTahhJNYykWmZyLSu5joWtZ2PrOdh6TgqOk4LjYus5yfWcpDp2Yi07vpoZW0mPLqM+LCE/LCFFFROjinujigjRxb0xpcS4MnJ8OSWxqi+5pj+lnpWG56Y38Azhp+F5qciS1jKTahiJVfSEyr74cmpcOTWughpvjOliIqGZpYqWUEU3ST+SuEp6dHnfw1LK/WJyRCHxzhNi+OPeW48IN/K6r2d3fp/Z9m1a6zepLd+kNP89pflrbNM3Kc3fprd+n9l2Lbvjh9yum/k9twt6f3pKuoPkCfHOE+JPT3p/ekwIf0wIL+i5jeZRt3l6bhf0hBf0hBcQwh+bpIAQXtBz+5Gx/C3zWNRw26xwz+2CnvDHhPDHvT89Id55SrpbSI4ookYUUSOKKIaQ7xaS7xaS7j4l3X1KNAnpbiESckQROaKIEllMjSzuiyzR514J7V4J7V5J3z39v0io90qo90uoD0r7Hpb1RZXRYiposZX0uCpGQjUzoYaZWMNMrGEl1rISa1lJtaykWrYhnKRaTlIdJ7mOi63npeD4qQ2CtAZBWgM/rYGf1sBLxXNT6tnJtUxklUuo0q+r8aYfLrK61jCSa5nJdSysPvovhY3vBbKSV9PRtTe5lonMpS9cw0iqMazYyLpdx8TWsVLqWak4dhqendHIyWziZDZxMhvZmY3MjAZGOr4/rZ6eWkfD1vSl1NBS6/rTcKx0PDejkZ/RJEAO38tsGcxoGkhv5Kfhuak4DraOlaxfkw3f0wrrUOPKqXHllLhySly5fvVOqKQlVtGTavqRpTNps2mQp5D3AQ0LW8fG1rNT6jkpOG4qnpuK56Y28JCkNHCxeE4yjp2MY2PrWSn1rNR6Vmo9O62enV7PyajnZOC4GXhuBp6X0cDPaOCn43lpSBdk6H+SaxhJNf2J1f2J1fSEKvR97k9C32d9q5CSjKRqfWeCdDUWjcfWsVPqOak4bloDL71RkNE8mNUynN06os8zCORnn9bhrOahrKbBrEZBRj0nvbo/rYyaWtSb8qQLm9+WnNOSlNGQlNWYlN2UnNOSnNuKfdyZWtybVk5Nr2Fm1LMz8byspoHs1uGslmHk+OLM5qGMpoH0RgHS96biuCk4Tko9J0XfaXBScVzjV7JpILN5KKtlKKtlGLkfRVbrcFbLUGbzYEbTQFoDPwX0cBFpAAAIJ0lEQVTHSa5lJlb3J1TS4iuoceWUmFJSbBk5towcV06Jq6AmVNKSqvuT61gpiMkYkornpuF5aQ185FVKuoXRCdhNmzZhfHx8Xl6/kSpQpOLN2mfo7ln2O0Rj55KEdkO1TORf/XT9RFZyLboJsQ76Kix96gwx/stOrmNj69jIg6Q6dlIdO7GGGV/VH1dJiy2nxpZRYssosWXk2FIS8l7EV1ATKvuSqunJtYyUelYqjpuGvAV4XloDPxXPS8VxU+o5WBPVQ/TLJIxEOwtrWEDTf5mJNYzEakZCdX98VX9sBQ21n8hC0t1C0p2nxPAnxNsFvTfze27kdV/P6byW3XktuyMsqyMss/1adsf1nM4bed0383tuFfSGPyb+9JR0t5Byt5Byt5BsiEGGnhINPmSZO0+Id54S76DaZBaLWXpNYl2D8SXuPDFWeLeQfLeIElFEjSimRhZTI4upEUhQDSokm6WIbGJIiPpQUfVBdSfSPPdKqPeKDQJUQn1QSn1Y1hddToupoMdW0uOq+uOrGAnVzMQaZiKiPnXs5DpOch0nuZ6bXM/F1nOxOF4KjpeC56fi+akN/NQGfiqen4bnpeK5KTgOtp6NrHJJNlZsk8088hWtN3yL6jmGFYZtWDmZSbUmKznqSfVsfUlk7UK1yay8wYFwrDQ8O72Bk97ASW9gpzew0vGsNDwzFcdIre9Pqe1PqetPqWem4thpeKSb0H+HDd0KPxXPs/zRYieWa7hxkdFfGibfSpPoJ+rfAfM3oY6VrH+WnYLjpOC5KXheSgMvBc9NwXOxeA4W7YNwnFQcJw3HScNx05Hgeel4XnoDL62Bh346+mUxvnUsY6+C9hLGJtlpc63JB4TOWMdCGpmKdIVNAxlNgxnN+mRCID/vZDQNZjQNZDQKMhr46fWctFpmahU9pZyaUkrGFvcmP+1JftyZ/KQr+Wl38tOe5EICtoSUUk5NrepPq2Wl13PS8byMBoG+EqSDMumjDHaBhIM8QOwn1aAm6Y3IjIZvZRPyA0+Q3ihIxfNS6jnJtSykH0uoosdX9sUhIxQVffGVtIRKmuFXq6ErM0T/88zwQn0DypfXv/7RRx9hQkJCnl+7ISYB29QnRpqFjLUYVMPYlSTZiYWjGGcxTtG7C9KBYk06UKzRadCei51cx9a/XA0z0UQvkmqZpq+bWMNMrGYkVNHjK2nxFX1xFX3I71pkzEb/o7y6P6mGga1jGTZjXGMMzUg29ONJJtsni9dKdpgktLWm9lOmt597ReTIInJEIfluIfnOU9JPT4i3HxNvFfTeekS4iSS/5+Yjwq2C3tuPieFPSD89Jd8ppNwtoqCGYfAMiqlJzDtkqzgubzSeSCtfiSzuizRvra2Yju7Q7KTPPNT7+kEg6sOyviijA/XHVfXHVyMOZCFAHCwiQPXIB81LwfFMPnfzddviozRZA9FBR1sxirjZSmvcHlt9iUzW58QaBpKkGkZSLSO5jomtZ6Xg2Kk4diqOhSQFx0qpZ2LrmNg6BlY/UMRGuoxUPDcVz0ODLJfFmuxwRTVbww0Lji6y6aKxbX9/kV8gFl9PpLY6dnI9G4vjYHFcLI5jDDJ8a5JUJIbuz+zTMYqjrSUy+S1k7E/MehK2VR/CMPyS0WsQto6dgkPeRr0cp0EgP/uk6jWFl4rjptZzUmpZKdUMbBUdW0FLLqcml1GSSsjJpeTkUkpyGSW5jIqtoGGr6Ck1jJRaVkodJ7Wem4rnIT81U/F8iz7K5NttFnS7bChv/Eqi7UnB87D1HKTbQUcZ9Jv+SuO+F/0vulqmhbfof6HVs7H1nKY+cUwC9vm1G/fs2YO5du1aYGDgr/7jv6ITsBS+vLB9QN+1LXxs96q2CyPbCWQh9WEkVCO9GDOxhplUayhQhbwLyBuB7MXQ77+wejvQF+XM3IDZJ7GGmVDNiK/qj6ukG+yH+qCEcr+Ycq+Ycg+VmCJqRBHFMK5DuVNIvlNI/v/tmj1LAzEYgPsnBAfRW3qDXF0KDg4iFItIsYsdBBEqiEtFBEFcHFxcBUsRakn7E1wseK21s7vQs1YKuliXc/HcHJK7S9Mkl9y1RfHgGY42l7zfeZsUPtsdht0lVI0+KM0BB35X4QPj4sa4qBp5LqTMzJFPDPAxrXy1lb9poSswdAuGHQLp6BCohA6B7Cswxv4t53HfkzDGwL4HhjEK6Vq75MSnk7H3HZdGBzTwb+2Zm114BTzUGBaxD7xeROnpKoLlpojpBJGuJw3yFbeG1JC1S+hM1+nVYLscEhLSrTS7FWdzbLzAf6eA+jOotYH+BHQD3NroBtANUGuDOryARj+iKvfkhOVml9hwGTAz0Sl0WEajpL6y/2piJ7jbIRCAu871w9vjq3lZqkxMTqVSqVwuF8lms5lMJpFIKGosOjtXKJY/Pi1Iz37o51sM6rvi81g9NriEIviSX4p+YUyrZ1rvpvVuftGwQiQh7dZz6PPy0FzJjROpkBaNVYF8oS4RJMX856+YLqNINDkV/oic/5BRF+SQgHjXIlrVGodU4js+8WGhWI7OzilqLB6PJ5PJdDodOTk7Pzg+3dk7XFvfSKykZlRtEEXVFDUmD2UqmTk939UcOAsNTx1v3FWiiGl50LuqNqPGhOHoyxhMkxBbWmp1clp5vVy7ydgH9yklfhTS6eJ+16h4BZU2OAPPNRQtPNYSlCdYhPvJqfHnWvAS9LslH7ehcKcH1n10NXlQTo0zwO+KovJzBGAUHIp44gIPJSUlnSJVAMcaq2yY1p5fWFxaXs1sbm/t5Hb3j34AvedOXZtlVAAAAAAASUVORK5CYII=" alt="" />

　　从运行结果中可以看到，我们的注解处理器成功调用了目标Servlet处理用户的请求，通过@WebServlet注解， Servlet不用再在web.xml 文件中进行繁冗的注册，这就是使用@WebServlet注解的方便之处。

2.3、WebServlet注解复杂测试

　　编写Login.jsp页面，代码如下：

<%@ page language="java" pageEncoding="UTF-8"%>
<!DOCTYPE HTML>
<html>
  <head>
    <title>登录页面</title>
  </head>

  <body>
    <fieldset>
        <legend>用户登录</legend>
        <form action="${pageContext.request.contextPath}/servlet/LoginServlet!loginHandle.do" method="post">
            用户名：<input type="text" value="${param.usename}" name="usename">
            <br/>
            密码：<input type="text" value="${param.pwd}" name="pwd">
            <br/>
            <input type="submit" value="登录"/>
        </form>
    </fieldset>
    <hr/>
    <label style="color: red;">${msg}</label>
  </body>
</html>

form表单中的action属性的URL="${pageContext.request.contextPath}/servlet/LoginServlet!loginHandle.do"，/servlet/LoginServlet表示要访问的是LoginServlet，!后面的loginHandle表示要调用LoginServlet中的loginHandle方法处理此次的请求，也就是说，我们在访问Servlet时，可以在URL中指明要访问Servlet的哪个方法，AnnotationHandleFilter过滤器的doFilter方法在拦截到用户的请求之后，首先获取用户要访问的URI，根据URI判断用户要访问的Servlet，然后再判断URI中是否包含了"!"，如果有，那么就说明用户显示指明了要访问Servlet的哪个方法，遍历Servlet类中定义的所有方法，如果找到了URI中的那个方法，那么就调用对应的方法处理用户请求！

　　LoginServlet的代码如下：

package com.web.controller;

import java.io.IOException;
import java.util.Map;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.annotation.WebInitParam;
import com.annotation.WebServlet;

/**
*
* @ClassName: LoginServlet
* @Description:处理用户登录的Servlet，
* LoginServlet现在就是一个普通的java类，不是一个真正的Servlet
* @author: hdb
* @date: 2017-11-8 上午12:07:58
*
*/
//将开发好的WebServlet注解标注到LoginServlet类上
@WebServlet(
            //Servlet的访问URL
            value="/servlet/LoginServlet",
            //Servlet的访问URL，可以使用数组的方式配置多个访问路径
            urlPatterns={"/gacl/LoginServlet","/xdp/LoginServlet"},
            //Servlet的初始化参数
            initParams={
                    @WebInitParam(paramName="gacl",paramValue="hdb"),
                    @WebInitParam(paramName="bhsh",paramValue="白虎神皇")
            },
            name="LoginServlet",
            description="处理用户登录的Servlet"
        )
public class LoginServlet {

    public void loginHandle(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException{
        String username = request.getParameter("usename");
        String pwd = request.getParameter("pwd");
        if (username.equals("gacl") && pwd.equals("xdp")) {
            request.getSession().setAttribute("usename", username);
            request.setAttribute("msg", "欢迎您！"+username);
            request.getRequestDispatcher("/index.jsp").forward(request, response);
        }else {
            request.setAttribute("msg", "登录失败，请检查用户名和密码是否正确！");
            request.getRequestDispatcher("/Login.jsp").forward(request, response);
        }
    }

    /**
    * @Method: init
    * @Description: Servlet初始化
    * @Anthor:hdb
    *
    * @param config
    */
    public void init(Map<String, String> initParamMap){
        System.out.println("--LoginServlet初始化--");
        System.out.println(initParamMap.get("gacl"));
        System.out.println(initParamMap.get("bhsh"));
    }
}

运行结果如下：

　　

　　可以看到，我们使用注解方式配置的Servlet已经成功调用了，loginHandle方法处理用户登录请求的完整处理过程如下图所示：

　　

　　Servlet3.0是支持采用基于注解的方式配置Servlet的，在此我使用过滤器作为注解处理器模拟模拟出了类似Servlet3.0的注解处理方式，简化了Servlet的配置。这种使用自定义注解+注解处理器的方式山寨出来的Servlet3.0大家了解一下即可，了解一下这种处理思路，在实际应用中还是不要这么做了，要真想使用注解的方式配置Servlet还是直接用Servlet3.0吧。