sso单点登录的入门（Session跨域、Spring-Session共享）

1、单点登录，就是多系统，单一位置登录，实现多系统同时登录的一种技术。单点登录一般是用于互相授信的系统，实现单一位置登录，全系统有效的。

　　注意：区分与三方登录（第三方登录） ，三方登录：某系统，使用其他系统的用户，实现本系统登录的方式。如，在王者荣耀中使用微信或者QQ登录。解决信息孤岛和用户不对等的实现方案。

2、单点登录方案选择：

2.1、方案一、Session跨域（熟悉即可）。

 所谓Session跨域就是摒弃了系统（Tomcat）提供的Session，而使用自定义的类似Session的机制来保存客户端数据的一种解决方案。
 如：通过设置cookie的domain来实现cookie的跨域传递。在cookie中传递一个自定义的session_id。这个session_id是客户端的唯一标记。将这个标记作为key，将客户端需要保存的数据作为value，在服务端进行保存（数据库保存或NoSQL保存）。这种机制就是Session的跨域解决。
 什么跨域： 客户端请求的时候，请求的服务器，不是同一个IP，端口，域名，主机名的时候，都称为跨域。
 什么是域：在应用模型，一个完整的，有独立访问路径的功能集合称为一个域。如：百度称为一个应用或系统。百度下有若干的域，如：搜索引擎（www.baidu.com），百度贴吧（tie.baidu.com），百度知道（zhidao.baidu.com），百度地图（map.baidu.com）等。域信息，有时也称为多级域名。域的划分： 以IP，端口，域名，主机名为标准，实现划分。
 localhost / 127.0.0.1

 使用cookie跨域共享，是session跨域的一种解决方案。
 jsessionid是和servlet绑定的http session的唯一标记。

 cookie应用 - new Cookie("", "").
 request.getCookies() -> cookie[] -> 迭代找到需要使用的cookie
 response.addCookie().
 cookie.setDomain() - 为cookie设定有效域范围。
 cookie.setPath() - 为cookie设定有效URI范围。

代码实现如下所示：

 package com.bie.controller;

 import java.util.UUID;

 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;

 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.RequestMapping;

 import com.bie.utils.CookieUtils;

 /**
  *
  * @author biehl
  *
  *         1、单点登录实现方案一，Session跨域实现
  */
 @Controller
 public class SsoController {

     /**
      * 请求控制层的方法
      *
      * @param request
      * @param response
      * @return
      */
     @RequestMapping("/sso")
     public String test(HttpServletRequest request, HttpServletResponse response) {
         // JSESSIONID代表了系统中http的唯一标记

         // custom_global_session_id。全局session的id
         String cookieName = "custom_global_session_id";
         String encodeString = "UTF-8";

         // 获取到cookie的value值
         String cookieValue = CookieUtils.getCookieValue(request, cookieName, encodeString);

         // 判断cookie的value值是否为空
         if (null == cookieValue || "".equals(cookieValue.trim())) {
             System.out.println("无cookie，生成新的cookie数据");
             // 生成一个cookie的value值
             cookieValue = UUID.randomUUID().toString();
         }

         // 根据cookieValue访问数据存储，获取客户端数据。
         // 将生产的cookie的value值设置到cookie中
         // 参数0代表关闭浏览器自动删除cookie.
         CookieUtils.setCookie(request, response, cookieName, cookieValue, , encodeString);

         return "/ok.jsp";
     }

 }

解析域名和设置cookie的方法工具类：

 package com.bie.utils;

 import java.io.UnsupportedEncodingException;
 import java.net.URLDecoder;
 import java.net.URLEncoder;

 import javax.servlet.http.Cookie;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;

 /**
  *
  * Cookie 工具类
  *
  */
 public final class CookieUtils {

     /**
      * 得到Cookie的值, 不编码
      *
      * @param request
      * @param cookieName
      * @return
      */
     public static String getCookieValue(HttpServletRequest request, String cookieName) {
         return getCookieValue(request, cookieName, false);
     }

     /**
      * 得到Cookie的值,
      *
      * @param request
      * @param cookieName
      * @return
      */
     public static String getCookieValue(HttpServletRequest request, String cookieName, boolean isDecoder) {
         Cookie[] cookieList = request.getCookies();
         if (cookieList == null || cookieName == null) {
             return null;
         }
         String retValue = null;
         try {
             for (int i = ; i < cookieList.length; i++) {
                 if (cookieList[i].getName().equals(cookieName)) {
                     if (isDecoder) {
                         retValue = URLDecoder.decode(cookieList[i].getValue(), "UTF-8");
                     } else {
                         retValue = cookieList[i].getValue();
                     }
                     break;
                 }
             }
         } catch (UnsupportedEncodingException e) {
             e.printStackTrace();
         }
         return retValue;
     }

     /**
      * 得到Cookie的值,
      *
      * @param request
      * @param cookieName
      * @return
      */
     public static String getCookieValue(HttpServletRequest request, String cookieName, String encodeString) {
         Cookie[] cookieList = request.getCookies();
         if (cookieList == null || cookieName == null) {
             return null;
         }
         String retValue = null;
         try {
             for (int i = ; i < cookieList.length; i++) {
                 if (cookieList[i].getName().equals(cookieName)) {
                     retValue = URLDecoder.decode(cookieList[i].getValue(), encodeString);
                     break;
                 }
             }
         } catch (UnsupportedEncodingException e) {
             e.printStackTrace();
         }
         return retValue;
     }

     /**
      * 设置Cookie的值 不设置生效时间默认浏览器关闭即失效,也不编码
      */
     public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
             String cookieValue) {
         setCookie(request, response, cookieName, cookieValue, -);
     }

     /**
      * 设置Cookie的值 在指定时间内生效,但不编码
      */
     public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
             String cookieValue, int cookieMaxage) {
         setCookie(request, response, cookieName, cookieValue, cookieMaxage, false);
     }

     /**
      * 设置Cookie的值 不设置生效时间,但编码
      */
     public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
             String cookieValue, boolean isEncode) {
         setCookie(request, response, cookieName, cookieValue, -, isEncode);
     }

     /**
      * 设置Cookie的值 在指定时间内生效, 编码参数
      */
     public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
             String cookieValue, int cookieMaxage, boolean isEncode) {
         doSetCookie(request, response, cookieName, cookieValue, cookieMaxage, isEncode);
     }

     /**
      * 设置Cookie的值 在指定时间内生效, 编码参数(指定编码)
      */
     public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
             String cookieValue, int cookieMaxage, String encodeString) {
         doSetCookie(request, response, cookieName, cookieValue, cookieMaxage, encodeString);
     }

     /**
      * 删除Cookie带cookie域名
      */
     public static void deleteCookie(HttpServletRequest request, HttpServletResponse response, String cookieName) {
         doSetCookie(request, response, cookieName, "", -, false);
     }

     /**
      * 设置Cookie的值，并使其在指定时间内生效
      *
      * @param request
      *            请求，请求对象，分析域信息
      * @param response
      *            响应
      * @param cookieName
      *            cookie的名称
      * @param cookieValue
      *            cookie的值
      * @param cookieMaxage
      *            cookie生效的最大秒数。不做设定，关闭浏览器就无效了
      * @param isEncode
      *            是否需要编码
      */
     private static final void doSetCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
             String cookieValue, int cookieMaxage, boolean isEncode) {
         try {
             // 判断cookie的value值是否等于null
             if (cookieValue == null) {
                 cookieValue = "";
             } else if (isEncode) {
                 // 判断是否需要utf8编码
                 cookieValue = URLEncoder.encode(cookieValue, "utf-8");
             }
             // 创建cookie，最好做非空判断的
             Cookie cookie = new Cookie(cookieName, cookieValue);
             if (cookieMaxage > ) {
                 // 如果cookie生效的最大秒数大于0，就设置这个值
                 cookie.setMaxAge(cookieMaxage);
             }
             if (null != request) {
                 // 分析解析域名
                 String domainName = getDomainName(request);
                 // 如果不等于localhost这个值，就设置一个domainName
                 if (!"localhost".equals(domainName)) {
                     // 设置域名的cookie
                     cookie.setDomain(domainName);
                 }
             }
             // 从根路径下的后面任意路径地址,cookie都有效
             cookie.setPath("/");
             // response响应写入到客户端即可
             response.addCookie(cookie);
         } catch (Exception e) {
             e.printStackTrace();
         }
     }

     /**
      * 设置Cookie的值，并使其在指定时间内生效
      *
      * @param request
      * @param response
      * @param cookieName
      * @param cookieValue
      * @param cookieMaxage
      *            cookie生效的最大秒数
      * @param encodeString
      */
     private static final void doSetCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
             String cookieValue, int cookieMaxage, String encodeString) {
         try {
             if (cookieValue == null) {
                 cookieValue = "";
             } else {
                 cookieValue = URLEncoder.encode(cookieValue, encodeString);
             }
             Cookie cookie = new Cookie(cookieName, cookieValue);
             if (cookieMaxage > )
                 cookie.setMaxAge(cookieMaxage);
             if (null != request) {
                 // 根据获取到的request请求，设置域名的cookie
                 String domainName = getDomainName(request);
                 if (!"localhost".equals(domainName)) {
                     // 设定一个域名。cookie就可以实现跨域访问了。
                     cookie.setDomain(domainName);
                 }
             }
             cookie.setPath("/");
             response.addCookie(cookie);
         } catch (Exception e) {
             e.printStackTrace();
         }
     }

     /**
      * 得到cookie的域名
      *
      * @param request
      *            请求对象，包含了请求的信息
      * @return
      */
     private static final String getDomainName(HttpServletRequest request) {
         // 定义一个变量domainName
         String domainName = null;

         // 获取完整的请求URL地址。请求url，转换为字符串类型
         String serverName = request.getRequestURL().toString();
         // 判断如果请求url地址为空或者为null
         if (serverName == null || serverName.equals("")) {
             domainName = "";
         } else {
             // 不为空或者不为null，将域名转换为小写。域名不敏感的。大小写一样
             serverName = serverName.toLowerCase();
             // 判断开始如果以http://开头的
             if (serverName.startsWith("http://")) {
                 // 截取前七位字符
                 serverName = serverName.substring();
             } else if (serverName.startsWith("https://")) {
                 // 否则如果开始以https://开始的。//截取前八位字符
                 serverName = serverName.substring();
             }
             // 找到/开始的位置，可以判断end的值是否为-1，如果为-1的话说明没有这个值
             // 如果存在这个值，找到这个值的位置，否则返回值为-1
             final int end = serverName.indexOf("/");
             // .test.com www.test.com.cn/sso.test.com.cn/.test.com.cn spring.io/xxxx/xxx
             // 然后截取到0开始到/的位置
             if (end != -) {
                 // end等于-1。说明没有/。否则end不等于-1说明有这个值
                 serverName = serverName.substring(, end);
                 // 这是将\\.是转义为.。然后进行分割操作。
                 final String[] domains = serverName.split("\\.");
                 // 获取到长度
                 int len = domains.length;
                 // 注意，如果是两截域名，一般没有二级域名。比如spring.io/xxx/xxx，都是在spring.io后面/拼接的
                 // 如果是三截域名，都是以第一截为核心分割的。
                 // 如果是两截的就保留。三截以及多截的就
                 // 多截进行匹配域名规则，第一个相当于写*，然后加.拼接后面的域名地址
                 if (len > ) {
                     // 如果是大于等于3截的，去掉第一个点之前的。留下剩下的域名
                     domainName = "." + domains[len - ] + "." + domains[len - ] + "." + domains[len - ];
                 } else if (len <=  && len > ) {
                     // 如果是2截和3截保留
                     domainName = "." + domains[len - ] + "." + domains[len - ];
                 } else {
                     domainName = serverName;
                 }
             }
         }
         // 如果域名不为空并且有这个:
         if (domainName != null && domainName.indexOf(":") > ) {
             // 将:转义。去掉端口port号，cookie（cookie的domainName）和端口无关。只看域名的。
             String[] ary = domainName.split("\\:");
             domainName = ary[];
         }
         // 返回域名
         System.out.println("==============================================" + domainName);
         return domainName;
     }

     public static void main(String[] args) {
         String serverName = "http://www.baidu.com/a";
         String domainName = null;
         // 判断如果请求url地址为空或者为null
         if (serverName == null || serverName.equals("")) {
             domainName = "";
         } else {
             // 不为空或者不为null，将域名转换为小写。域名不敏感的。大小写一样
             serverName = serverName.toLowerCase();
             // 判断开始如果以http://开头的
             if (serverName.startsWith("http://")) {
                 // 截取前七位字符
                 serverName = serverName.substring();
             } else if (serverName.startsWith("https://")) {
                 // 否则如果开始以https://开始的。//截取前八位字符
                 serverName = serverName.substring();
             }
             // 找到/开始的位置，可以判断end的值是否为-1，如果为-1的话说明没有这个值
             final int end = serverName.indexOf("/");
             // .test.com www.test.com.cn/sso.test.com.cn/.test.com.cn spring.io/xxxx/xxx
             // 然后截取到0开始到/的位置
             serverName = serverName.substring(, end);
             final String[] domains = serverName.split("\\.");
             int len = domains.length;
             if (len > ) {
                 domainName = "." + domains[len - ] + "." + domains[len - ] + "." + domains[len - ];
             } else if (len <=  && len > ) {
                 domainName = "." + domains[len - ] + "." + domains[len - ];
             } else {
                 domainName = serverName;
             }
         }

         if (domainName != null && domainName.indexOf(":") > ) {
             String[] ary = domainName.split("\\:");
             domainName = ary[];
         }
     }

 }

效果实现如下所示：

C:\Windows\System32\drivers\etc\host配置文件配置一下地址映射。

# sso test
192.168.0.102    www.test.com
192.168.0.102    sso.test.com
192.168.0.102    cart.test.com

域名访问，实现session跨域的效果：

2.2、Spring Session共享（ 了解即可）。

 spring-session技术是spring提供的用于处理集群会话共享的解决方案。spring-session技术是将用户session数据保存到三方存储容器中，如：mysql，redis等。
 Spring-session技术是解决同域名下的多服务器集群session共享问题的。不能解决跨域session共享问题（如果要解决跨域sesion，就要搭建前端服务器nginx来解决这个问题）。
 使用要求：
 　　配置一个Spring提供的Filter，实现数据的拦截保存，并转换为spring-session需要的会话对象。必须提供一个数据库的表格信息（由spring-session提供，找spring-session-jdbc.jar/org/springframework/session/jdbc/*.sql,根据具体的数据库找对应的SQL文件，做表格的创建）。
 spring-session表：保存客户端session对象的表格。
 spring-session-attributes表：保存客户端session中的attributes属性数据的表格。
 spring-session框架，是结合Servlet技术中的HTTPSession完成的会话共享机制。在代码中是直接操作HttpSession对象的。

Spring Session共享、图示如下所示：

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAA7oAAAJ/CAYAAABWVq/eAAAACXBIWXMAAAsTAAALEwEAmpwYAAAgAElEQVR4nOzdeXhTddrG8fukpUAp+1KFStlmZJEiKQiMyCagKDpaBYFxQVFxQRkXcAFkEVwYB0ZxFwQFQVAQZB8UCwxWxBZlR4rsSwFLC21p0yTn/aMkb0PTBWibNHw/19XL5OSckycxJLnz+53zSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKXN8HUBAICAYbFarV0Mw+hqmmYHSY0lVZdU1cd1AUBuqZJOSdpjGEacaZo/JCQkxEpy+rYsAMWJoAsAuCQtWrQIK1++/FBJj0qq7+t6AOAi7Jf0SVZW1tvbtm1L83UxAC4dQRcAcLGM1q1b32sYxkRJV0hSZGSkunbtqqioKDVu3FhVq1ZVpUqVZLFYfFwqAEhOp1Pp6elKTU3Vnj17tHnzZv3www/av3+/a5Wjpmm+sGnTplmSTB+WCuASEXQBABcsKiqqUnBw8AeS7pOk9u3b69FHH1VUVJQMg48WAGWHaZravHmzPv74Y/3000+SJMMwPs/Ozn5i8+bN6T4uD8BF4tsIAOCCdOjQoUZWVtYKSW2rV6+u0aNH64YbbvB1WQBwSUzT1Lp16zRu3DidOnVKpmn+XKFChV5xcXHJvq4NwIUj6AIAiqxly5bVy5UrFyspqmXLlvrXv/6l2rVr+7osACg2J06c0LBhw7RlyxZJ2pydnd1ly5Ytp3xdF4ALw0FTAICiMsqVKzdVUlTr1q31/vvvE3IBBJzatWvr/fffV+vWrSUpqly5cp+IwSGgzOEfLQCgSKKjox83TfP9q666SrNnz1ZoaKivSwKAEpORkaEBAwbo4MGDMk3z8U2bNn3o65oAFB1BFwBQKKvVGmUYxsagoKCQGTNmqFmzZr4uCQBK3I4dOzRw4EA5HA6baZptExISNvu6JgBFE+TrAgAA/i06OrqcpO8lXTF06FDdeOONvi4JAEpF7dq1VbFiRcXFxQVJ6lK3bt2Pjx496vR1XQAKxzG6AIACmab5D0nN2rVrpwEDBvi6HAAoVQMGDFC7du0kqZkk3gSBMoKgCwDIV58+fYIkvSxJQ4YMkcXCxwaAy4vFYtGTTz7puvryufdFAH6ObywAgHz98ccf90j6S/v27dW8eXNflwMAPtGiRQu1a9dOpmn+NTExsa+v6wFQOIIuACA/FtM0R0jSQw895OtaAMCnBg0aJEmyWCwjxHdowO/xjxQA4FV0dHRnSc2joqJktVp9XQ4A+JTValVUVJRM02xx7v0RgB8j6AIA8nOnJN12220yDLrRAbi8GYah3r17S5KcTucdPi4HQCEIugAAbwzTNO+QpBtuuMHXtQCAX3C9HxqGcYckfgEE/BhBFwCQR3R0dGtJVzVv3ly1a9f2dTkA4Bfq1KmjZs2aSVL9Nm3aXOvregDkj6ALAPDmTknq3JnD0AAgN9f7osPhuNPHpQAoAEEXAJCHaZo9JKljx46+LgUA/IrrfdEwjB4+LgVAAQi6AIDzWSS1DAoKUuPGjX1dCwD4lSZNmigoKEiSWorv0oDf4h8nAMCD1WptJCk0MjJS5cqV83U5AOBXypUrp/r160tSpejo6Ia+rgeAdwRdAMD5oiSpUaNGvq4DAPySa7aLaZpRPi4FQD4IugCA80VJYtoyAOQj1w+BBF3ATxF0AQAeDMNoITGiW5LmzZunlJSUIq+fmZmpJ554QkeOHMl3nenTp+e7zwEDBnhdvm3bNqWmpuZZbrPZLuhEZCtXrpTdbteJEyd06NChIm8X6Hh+A1eu98cWvqwDQP4IugAAD6Zp1pSkGjVq+LqUgHXkyBF9/PHHRV6/QoUKatq0qd59991810lPT9fkyZPd159++mn35WPHjrkvP/nkk+7Ly5cv15AhQ5SRkaH+/fu7/+6//36dPXvWY9m0adPyve+XX35ZZ8+eVXp6uj799FNNmTKl0MeUmJiomJiYCwr8ZY0vnt/Tp0+rb9++2rVrV0k8JJyT6/2xpi/rAJA/w9cFAAD8i9VqjZdknT17tq6++mpfl1PmtW3bVg0b5pyvxm63KygoSIaR9+N379692rhxo/t6hw4dFBYW5rGOaZoe26alpWn9+vWyWCw6e/asXn31VY0fP14Wi0W9e/fWkiVLJEndunXT6tWrJUm9evXS8uXLJUkOh0ODBw/W3/72Nz300EPu/dpsNnXo0EHx8fEe979nzx499thjeWpPTk7O94eRVatW5VnmdDp177336vHHH9cNN9zgdbuy5MCBAxo6dKjmzp2rkJAQ93JfPb8bNmzQv//9b3355ZeyWBjTKAm7du1yzZSIT0hIaOPregDkFezrAgAAfqeKJFWqVMnXdQSE0NBQzZs3T6ZpasyYMYqIiNAjjzySZ73OnTt7XLfZbFqxYoWrjYlX0dHRMk1Tffv2dS/r16+fnnrqKVWuXFn9+/eXJIWHh7sv5xYUFKRJkya5A7VrHdM0Pa5LUmRkpN544w2tWrVKdrtdwcH//xUiOjpaCxYsUOXKld3Lzg/lua1du1aGYQREyJWk1NRUHThwIM9yXz2/7dq1U1hYmFavXq3u3btf+gNEHqGhoa6LVXxZB4D88TMfAOB8VSWCbnEZOXKkbDabXnnlFS1dulSrVq1S37593X9du3bVgAED9NJLL130fYwdO1azZ8/WvHnz9MQTT+iGG27QnDlzvP49/PDDknKO6Y2JidHjjz+u3bt3ew3Cue3fv19Op1M2m039+vXTwYMHPW5fu3at+/Kvv/6qf/zjHzpz5ozXfa1cuVI33XRTvve1ZcsWRUdH69tvv1W3bt301ltvScoJ/xMnTlTXrl3VsWNHvfzyy0pLS3Nvl5KSoueee04dOnRQ7969NXXqVEVHR8tms7n3mZGRked+bDZbkfb/5ZdfqmfPnurQoYO7JkkaOHCgpJxR+OjoaJ8/v5LUs2dPr6O9KB653h+r+rIOAAAAFJHVas20Wq1mVlaWiUu3b98+87777jP/+c9/miNGjDAnT55sOhwO0zRNc8WKFWavXr3M3377Lc92VqvVtNvtBe7btc7zzz9vbt261fzzzz/N/v37m3369HH/xcTEmNddd53Hst9//91MT083T548aV5//fUX/Jg+//xzs2/fvu7XiNVqNe+8807TZrOZv//+u9mlSxfz3XffzXf73r17mwkJCfnevnnzZtNqtZovv/yymZaWZp45c8Y0TdMcNWqU+eCDD5rHjh0zT506ZT722GPmmDFj3Ns99dRT5iOPPGKePHnSPHHihPnQQw+Zrteya5/p6el57sf1OAra/8GDB02r1Wpu2LDBTE9PN7du3ZrvfkzT9Onz66rplltuueD7RtFkZmaaVqvVtFqtZ339ng3AO6YuAwDOFyQp32mRuDBffvml7rzzTt15551yOBz6z3/+o4EDByo0NFSGYWjq1KmqW7euxzbZ2dmSpB49ehTpPpo3b64dO3bIbrcrMjJSr7/+uvu2nTt36u2339YHH3yQZ7tc0y8lSXfddZfXqdJ2u10LFixwX7/33nv1448/aufOnYqKyumuEhYWpvHjx2vdunUaMGCA1+nZLsePH1edOnUKfVz333+/e+Ts1KlTWrZsmWbPnq3w8HB3HS+99JJGjx6t5ORkrV+/XjNnzlTNmjnnB3r44Yc1ZMiQQu+nKPsvV66cDMPQsWPHdN1116lFi4JPthsaGuqz51eS6tSpo5MnTxbpsePC5Tr2Of9jCwD4FEEXAHC+VEk1MzIyVLUqs/IuRVZWlvr376+DBw/q888/19atW7Vt2za1bNlSFotFmzZt0n/+8x81atRItWrVUvPmzdW8eXOlp6crNDTUfQKp/Lz00ksyDENNmjTR2rVrFRIS4u5/7Joqm56errS0NPf1atWqeQ29Us5JlXKfEMvFNR3XxTAMvffee/rzzz/1/PPPS5KGDRumRx55RHfddVehIcws4PjS3CIiItyXjx07JtM0vU4Bzs7OVlJSkiSpfv367uXnn8yrIIXtPzw8XK+++qrefvttzZo1Sy+99JJat25d5P1Lpff8ouSlp6e7LubtHwXALxB0AQAeDMM4bZpmzfT0dILuJZo1a5a+++47RUZGqmnTprrnnnsUFRWlcuXKSZLOnj2rX3/9VTt37tSOHTvUtm1bSdLhw4d1xRVXFLp/18htgwYNNH36dFWpUkUtW7aUlHO86vLlyxUTE6PVq1crJiZGCxYsUK9evfLdn9PpLPRYUtd6c+fO1YcffugedW7QoIGGDx+ut99+W7feequaN2+e7/a1atXSn3/+mWck+3y5w7DrrMNLly71+ty4TtR08uRJd8A9fvy4+3bX2ZAzMzPdI625j78tbP9Szhmru3fvrnfeeUfDhw+/4GNgS+v5laQTJ06oVq1aF1Qfii5X0D3tyzoA5I+gCwA4X6rk8UUOF2nQoEEaNGiQJM82Q+c7ePCg4uLi3Ne3bt1aaJDJrV69eho+fLg+/vhjderUySPAFcXvv/+u5OTkIq27ceNGvfXWWzJNU++8845atWqlb775RpIUExOjw4cPa/DgwRozZoxuvPFGr/to1qyZe2S7qMLDw2W1WvXWW29p2LBhqlWrlvbs2aOUlBRdd911ioiIUOPGjTVlyhSNHj1aZ86c0cyZM93bN2jQQKGhoVqyZInuv/9+ZWVledxe2P6PHj2qpKQkXXPNNbrqqqtks9ncI9NVquScePfXX39V06ZN3dd99fxK0rZt2y7oNYQLw4gu4P8IugAAD6ZpnpbkcXZaXDpXmyFvOnTo4HF95cqV6tevX5H2m5mZqa+//lqJiYn65ZdftHXr1nynJp8vOztbWVlZeuCBBzRmzBhZLBbNmTMnz3quqbU7d+7UU089pUGDBunBBx/0aIHj4mpt9OKLL6pnz54aPXq0R29ZKefY43nz5hX5Mbq8+eabeuONN3T33XcrOztbjRo10tChQ923v/HGGxozZox69uypxo0bq0+fPtqyZYskqXz58powYYLeeustff3116pdu7a6du2qDRs2FGn/DodD48aN0+HDh1WvXj2NHz/ePeIcGRmpmJgYDR06VGFhYe6RXl89v1JOf90+ffpc0POLosv1/siILuCnCLoAAA+GYZwyTVMpKSm+LiWgZGRkePS7zc+aNWt05MgRde3atUj7LVeunPbu3atrr71WDz74oCIjIz1ur169uqScnq6ZmZketyUkJEiSXnjhBd10000aOXKk+zabzSaLxaJjx465p1o3bdpU8+bNU/369ZWZmSmbzaYjR47IMAyVL1/eve3AgQN17bXXav369V5DWPfu3fXxxx8rPj4+z/GpktSyZUvFx8fnWV6jRg1NnDgx3+eiUaNG+vzzz93XXSHXpVOnTurUqZPHsnvvvbdI+4+IiPA4YdT5RowYoREjRngs89Xzm5CQoOTkZHroliDX+6NhGLxRAgAAlAXR0dFvWK1Wc8aMGT5r3RGIOnXqlO9t7du3d1/eunWrGRsbe8n3d/PNN3tcdzgcZt++fc1Ro0a5l509e9aMi4tzX2/Tpo378vfff2/26tXLvO2228x33nknz/5/+eUX02q1mm3btjXHjx9/wfVt3rzZ7Nu3r0e7n+Lmre1PafLF85uenm726dPHa8sqFJ/p06ebVqvVbN269euFv6sC8AV6RwAAPFit1n9ImtW7d2+NHTvW1+UEjLNnz6pixYoXfNvFcjqduVuglAin0ynDMC66FVVGRoZCQkK8TtEtDlu2bNHAgQMVFxfndeTT313M82u322Wz2fK0NkLxeuWVV7R06VIZhvGP+Pj42b6uB0BeTF0GAHgwDGOzaZras2ePr0sJKAUF2eIOuZJKPOQWx32UdBjLbwp0WXExz29wcHCJ/XCA/+d6fzQMY7OPSwGQj5L/FAQAlCmZmZm7JGXv3btXTqfT1+UAgF9xOp3au3evJGWbprnL1/UA8I6gCwDwsG3bNpukHZmZmTp48KCvywEAv3Lw4EFlZWVJ0vb4+PhsX9cDwDuCLgDAm7WSPHq7AgCkH3/80XVxnS/rAFAwgi4AIA/TNBdK0tq1a31dCgD4lVzvi9/4sg4ABSPoAgDysFgsayWd+uWXX5SWlubrcgDAL6SlpblOcHaqSpUq/BII+DGCLgAgj3PHnS1xOBxMXwaAc3788Uc5HA4ZhrE4NjbW7ut6AOSPoAsAyM9CSVqxYoWv6wAAv7By5UpJ/394BwD/RdAFAHhVvnz55ZKOrVmzxtVKAwAuW3/88YdiY2Ml6ViVKlWW+7gcAIUg6AIAvIqLiztrGMZbpmlqxowZvi4HAHzqs88+kySZpvmv2NjYTB+XA6AQBF0AQL6ys7M/NAzjz2XLlunIkSO+LgcAfOLIkSNatmyZDMP40+FwfOTregAUjqALAMjX5s2b0yX92+l0atq0ab4uBwB8Ytq0aXI6nZL01rn3RQB+jqALAChQcHDwe4Zh/Llw4UL66gK47KxZs0YLFy6UYRh/BgcHv+/regAUjeHrAgAA/s9qtfaWtLhKlSrm3LlzjTp16vi6JAAocUlJSbrnnnvMM2fOGIZh9I6Pj1/q65oAFE2QrwsAAPi/o0eP/n7llVdWy8rK6rBz507deuutMgx+KwUQuJxOp5577jnt27fPkDQ5ISHhXV/XBKDoCLoAgCKpVKlSbPny5XsdPXq0bnJysq6//nrCLoCA5HQ69frrr2v16tWS9EtWVtaAEydOOHxdF4CiI+gCAIokOTnZUbdu3e8Nwxiwffv20KSkJF1//fUKCuKjBEDgyM7O1oQJE1zH5Z40DOPm33777aSv6wJwYfh2AgAosqNHj5664oorlloslrt27doVFhcXp+uuu05VqlTxdWkAcMkOHz6sp59+Wv/73/9kGMYx0zS7JCQk/O7rugBcOOacAQAuWFRUVMPg4OD5klqHhIRowIABeuCBBwi8AMqk06dP67PPPtPs2bNls9kkKcFut9+9efPmvb6uDcDFIegCAC5Kly5dKpw+ffoNSUMkBYWEhKhbt27q2rWroqKixJmZAfizpKQkbdmyRT/88INWr17tCrgOSe9WqVLlxdjY2EwflwjgEhB0AQCXpHXr1s0Nwxgv6e/K1Z89LCxMVatWVVhYmCwW2rYD8D2n06m0tDSlpqYqLS3N4yZJiySNSEhI2OGb6gAUJ4IuAKBYtG7duq5hGP+Q1FVSe0nVfVwSABTklKSfJP1gmuYXmzZtOuLrggAUH4IuAKAkWDp06FDNZrNVN02zmmmafN7gkhiGsVGSTNNs6+taUHYZhmEahpESEhJyKi4uLkU5I7kAAAAAUPqsVqtptVpNX9cBACgbOGgKAAAAABBQCLoAAAAAgIBC0AUAAAAABBSCLgAAAAAgoBB0AQAAAAABhaALAAAAAAgoBF0AAAAAQEAh6AIAAAAAAgpBFwAAAAAQUAi6AAAAAICAQtAFAAAAAAQUgi4AAAAAIKAQdAEAAAAAAYWgCwAAAAAIKARdAAAAAEBAIegCAAAAAAIKQRcAAAAAEFAIugAAAACAgELQBQAAAAAEFIIuAAAAACCgEHQBAAAAAAGFoAsAAAAACCgEXQAAAABAQDF8XQAAAEBuUVFREcHBwSPPWzz43H8/yr3QbreP37x586HSqQwAUFYQdAEAgF/p06dPUGJi4mHDMMILWs80zaQmTZrU++qrrxylVRsAoGwI8nUBAAAAuW3fvt2sV69eY0ltCll15vfff7+kNGoCAJQtHKMLAAD8jtPpnF+E1YqyDgDgMkTQBQAAfsdisawxTTO5gFX+rFq16ppSKwgAUKYQdAEAgN+Jj4/PNgxjUQGrLIqNjbWXWkEAgDKFoAsAAPySYRj5Tk22WCxMWwYA5IugCwAA/FJqaup3kk57uel0SkrK96VdDwCg7CDoAgAAv5SYmJhlmqa3syovTkxMzCr1ggAAZQZBFwAA+K18pi8zbRkAUCCCLgAA8FuGYayQlJFrUYZhGCt9VQ8AoGwg6AIAAL8VHx+fIWm567phGMvOLQMAIF8EXQAA4NdM03RPVXY6nUxbBgAUiqALAAD8WkhIyFLX5dDQ0KUFrQsAAAAAQJlgtVoXW63Wb31dBwCgbAj2dQEAAABFMN8wDNPXRQAAygbD1wUAAAC49OnTJ+iPP/5oYJpmM0nNJDU9998O51aJk7RD0k5JOwzD2NGoUaN9X331lcM3FQMA/BFBFwAAlLoOHTpUzMzM/KukZoZhuMJsM0l/lVT+AneXJel35QTgHaZp7pS0o0KFCr/HxcWdLc66AQBlA0EXAACUmA4dOtTIzs5u5nA43GHWYrE0M02zgfL5HhIeHq6GDRuqQYMGatiwoftPkvbu3evxt2/fPiUlJeV396akva7gq5wQvKNixYo74+Likov7sQIA/AdBFwAAXCojOjr6Kp2bZnxu2rEr2NbxtkFQUJDq16/vEWYbNGigBg0aKDQ09ILuPCMjQ/v27dO+ffs8QvDBgwflcOQ7o/m4zk2BNgxjh6QdFotlx8aNGw8pJyADAMowgi4AACiS6OjocqZpNtH/TzNumuu/lbxtExoamifMNmzYUBEREQoOLtlzYtrtdh06dMhj9Nf134yMjPw2S9e543/leSxwYnx8fHaJFgwAKDYEXQAA4OH666+vnJ6e3tR17KxhGK5g21j5dGyoUaOGxzRjV6itU6eODMO/vm6Ypqnjx4/nGQHeu3evkpPzndFsl5Qoaadpmu5jgStVqrRz/fr1Z0qteABAkfjXJw8AACgtRtu2bcNN02zqOsOxaZrNDMNoappmhNcNDEP16tXLc+xsgwYNVKVKlVIuv2ScPn3aY/TX9XfkyBGZpvcZzYZhHHI6nTssFov7TNBBQUE7NmzYcFxMgwYAnyDoAgAQwApo19NMUjVv24SEhCgyMjLPdOPIyEiFhISUYvX+w2azaf/+/XlC8P79+2Wz2fLbLEV5p0DTDgkASgFBFwCAAHAx7XqqVKmSJ8w2bNhQV155pSwWSylWX3Y5nU4dPXo0z3HAe/fu1enTp/PbjHZIAFDCCLoAAJQhxdmup3r16n53/GygME1Tp06doh0SAPgIn24AAPgfn7brQcmiHRIAlDyCLgAAPlLW2vWgZNEOCQCKD0EXAIASFujtelCyaIcEABeOT0oAAIoH7XpQ6miHBADeEXQBALgAtOtBWUA7JACXO4IuAABe0K4HgYh2SAAuFwRdAMBljXY9AO2QAAQePo0BAJcD2vUAF4l2SADKIoIuACBg0K4HKD20QwLgzwi6AIAyh3Y9gP+iHRIAf8AnOwDAX9GuBwgwtEMCUFoIugAAn6JdDwDaIQEobgRdAECpoF0PgAtFOyQAF4ugCwAoVrTrAVDSaIcEoDB8ewAAXAza9QDwS7RDAiARdAEABaBdD4BAQTsk4PJC0AUA0K4HwGWLdkhAYOKbCABcPmjXAwAXgHZIQNlF0AWAAEO7HgAoWbRDAvwfQRcAyija9QAoyI8//qh27dopKCjI16VcNmiHBPgPgi4A+Dna9ZQNS5YsUe/evS9om//973/q2LFjCVX0/9LT03XXXXfpiy++UM2aNd3LO3furDVr1njdJikpSQ8++KC+/vpr91mx9+3bp3HjxunTTz8t0v3Gx8dr/fr1evrppy/9QXiRmZmp9evXq0uXLkUKc65jMStXrqzjx49r/vz5eu6550qktk2bNumaa65RuXLlNH36dN1zzz1ezy5+9uxZJSYmqmXLlpKkV199VbfffrtatWql+Ph42e12tWvX7qJqiI6OVmxsrCpXrnzRjyNQXzuS9Oeff6pnz56Kj48vsftwoR0SUPo4/SUA+Id82/VkZWXVkeQRUE3T9Jt2PdHR0fneVhpfIP3FpEmTPIJumzZtdMUVV3isk5GRodWrV7uvjxgxQmvWrFFMTIycTqfXUfWUlBSPbaKjo1WjRo1860hJSdHGjRs9lsXFxalq1aoeQaUwixcvVqtWrTxeS7GxsYqKiiryPv7yl79o5MiRuvXWW9W4ceM8t9tsNnXo0EFhYWEey9PS0jyWpaWl6eeff/YIs06nUyNHjpTdble3bt3yrWHlypVatGiRkpKSlJGRoapVq+qZZ57R+vXrFR4eXuTHciESExP17LPPavbs2bryyiuVmJio2bNn6+GHH86z7nfffaclS5boo48+kpTzHA8YMECSVKlSJb344otq166dnn32WZUvX14///yzhg0bJiknJAcFBXkcXrBmzRqlpKSoWrW8Rynw2vEdwzBUo0YN1ahRI897ZgHtkAyHw9HIMIxGkm5x7ScrK0tWq5V2SEAhCLoAUIoKatdjmmaZbNfjCrNbtmzRwIEDFRcX55fH9R44cEBDhw7V3LlzS6W+SpUqacmSJR7LCgpkM2bM8BpOzt/GYrFo1apV+e6nbdu2eZYtW7ZMf//73wsrWVJOgOzevbvS09NVrlw59/2vXr1ay5cv14EDB/T111+71//iiy8UGRmpM2fOqEuXLl6f23vvvdfjekhIiHs00Gc4Z70AACAASURBVGKxeIwMOhwOXXfddR7Lzg8GTqdTY8eOVXx8vCpVqqTbbrvN4/b09HSdOXNGv/zyi1q1aqWGDRtqyJAh+u9//ytJOnPmjIYNG6bg4GB99tlnHttOmTJFTZs2LdJz5U1mZqZGjBihRx99VFdeeaUk6YknntB9992nTp066a9//avH+vPnz9f9998vSTp27JhsNpsaNmwoSWratKlmzpypTz75xH3iI9dzc+LECQ0YMEDTpk1T5cqVdfbsWdWtW1c2m0033nij1x+ZeO34p9DQUDVv3lzNmzf3WF5IO6Q6yulZ3tn12nA4HLJarbRDAs7x/TckAAhA+bXrMU2Tdj0+kpqaqgMHDhT7fmfNmqUFCxYoNTVVMTExkqQFCxYoIyMj34AQExOjlJQUpaenq1u3bqpWrZoGDRpUpFEnp9Ppvp+iOH78uDZs2KCxY8d6hObU1FRJUrt27VSpUs5vLDVr1tSXX36p1NRUxcXFScr58tyxY0clJCQoNDTUvVySunbtmufHlty3u+otzuO/MzIyNHLkSGVkZOibb77J8+PAL7/8olGjRun555+XJF1xxRW64oorPJ7bmTNnqn///nr88cfdy06cOKE+ffooIsLrCciLxOl0atSoUYqIiFD//v3dy+vVq6dnnnlGQ4cO1YcffqjIyEj3bVu2bNGYMWM0duxYOZ1OZWZmqmvXrnn2vWjRItWrV0+zZ892B/1HH31U9evX1/r16/XRRx9pxowZhdZ3Ob92oqOjPUZ7XQGxc+fOHvdZo0YNLVq0qNju92IFBwe7Z+nkfk0U0g6pkqToc3+5t7FbrVbaIeGyQtAFgIuXb7ues2fPRnj7gnY5tuvJzs7WJ598omXLlunEiROqWbOm7rzzTg0aNEgWi8U9EjxmzBhNmTJFhmHo1Vdf1e7duzV16lQFBwdr1KhR6tSpk6ScL6Kff/65FixYoKSkJNWsWVP//ve/1axZM/3888/6z3/+oz179qhOnTp6+eWX1aFDB0nSwIEDJcl9vbimVd977726/vrrdffdd2vu3LkqV66cpJxRmvO/LLvCwoIFCyTlfMFevXq1YmJiNG3aNHdoe/311/XSSy9Jkl555RWPfVgsFvf23pw/Kvf5558rODhYlStXdk+BTkhI0HvvvafExERFRkZqxowZ7kDhcOSc/NU1uua6vnTpUj300EMe+7bb7e7H65KcnKxdu3apQ4cOSkxM1IgRIzR37lxJ0sGDB/Xvf/9bkyZNct+f0+n0OtLtbdm+ffv0zDPPqG3bthoyZIgGDhyogQMH6vbbb1daWpo++OADrV27Vq+99ppat24tSZo4caLWrl2rkydPuqeWV6pUSVOnTpUk9ejRQ6tWrdJ3332nW2+9Nc9U2KKy2WwaPXq0kpKS9OGHH+a5/bbbbtPJkyc1cOBAjRw5UjfeeKMkz9fh2LFjVbduXT3yyCMF3teoUaP0xx9/qH379poyZYqSk5O1d+9ezZ8/v8DR18v5teOyfPly95Rq1zG6uUeAd+3apeHDh+e7vT8wDEPh4eEKDw/Pc/x2Ae2Qgk3TbCqpqWEYd7j2c/bsWUVHR9MOCQGJoAsAF6l169Y/ORyO685fbpqmgoOD8wTZy7Vdz4QJE7R9+3ZNmjRJjRo10vbt2/Xiiy/Kbrd7jKglJiZq4cKFevPNNzVixAh17dpVS5cu1eTJkzVp0iR30J08ebLWrFmjV199VS1atNCBAwdUsWJFSTlTVkeOHKkmTZpoypQpev311/Xtt99KypkaXFJTq9evXy+LxaKYmBi9+eabeaYgXqhVq1a5g+64ceM8bnM6nUWeSnro0CH3dN3c5s6dq169emnKlClq3ry51q9frxtuuKHAfY0YMUKTJk2Sw+FQly5dJOUEmfOfyxMnTuiVV17RypUrVb9+fe3fv19JSUkKDw/XTz/9pDNnzniM0lksFo9jkF3TT88/LlnKGZ19/vnndf3110vKeS089dRTWrNmjbZu3aqePXtqzpw5HmF1+PDheuSRR9SjRw99++23slgsOnv2rM6ezTmZbVpamiSpZ8+el3TSphdffFEpKSl699138z1G/sEHH1R4eLjGjBmjvXv3ehyz63A4tG7dOk2cOLHQ+7rhhhvUsGFDhYaGavPmzXrggQfUt29fzZo1q8DXxuX82rlcVKlSRa1atVKrVq08lufXDmnv3r2y2+0RhmFEmKbZQ8r5DHM6nbJarRsSEhLa++SBAMWAoAsAF8kwjAJ/6TZN0+vf5SQlJUVLlizRtGnT3McmRkVF6bHHHtOUKVM8gq7rrLS33HKLlixZooEDByo0NFQ33XSTFixYIIfDoYyMDM2dO1fvv/+++4tco0aN3Pvo2rWrMjMztWfPHoWFhenw4cOy2+0lfizz9u3bVblyZT3yyCN64oknNH36dKWnp6t3795KTU1V1apVPda32+3avXu3srKy9MADD+jYsWO6//773VPUz5w54xFIxowZ4x6htFgsBU6rzD0qt3DhQg0ePFjvvPOOe9m2bduUkJCg0aNHa8qUKbrjjjv02muvqWPHjh5T5L0dGxwTE6PHH39czZo1U3h4uOx2uzusuKaZXn311QoODtZvv/2m1q1bq1mzZtq0aZNuvvlm/fTTT+4fLKScYHL+qF5BKlSo4A65u3bt0qJFi5SZmanatWtr2rRp+U47XrNmjUzT1IABAzRs2DBde+21uv32293Hi+7evVsvvPCCx/GjF+rpp5/W0aNH3ccLZ2RkqEKFCh7BLD09XfPnz9dXX32VZwbH+vXrlZKSoiFDhuQ5YdSff/6p559/XnfddZck6eabb5aU8/xNmDDBHY4nTJhQUA/Xy/q1c7m7mM8j0zQ5ZgZlGkEXAC5SQkJCh3bt2tWx2Wy5e9g2Mwyjqd1uvyoxMVGJiYke2xiGobp16+aZutywYcOAnLp89OhRmabpEUYlqX79+kpOTpbT6XQvc03bdY2G1apVS5JUvnxOS2CHw6HDhw/L4XDo6quv9np/U6ZM0bfffquoqCj3drnvoyRs375dtWvXliTdfvvtslgsioiIcJ+M6oEHHtCECRMUERGhzz77TCdPntRDDz3k/lI/fvx4Pfroo/rmm2/cx5F269Yt30ByIaNy/fv3V82aNd1hxWazacKECe4fEaScEx5Vq1ZNX375pcdxpa5RMdcomZTzo0KfPn00ceJE/etf//IIGxkZGe7jNa+//nqtW7dOrVu31tVXX60tW7aoW7du2rBhg0e7mKysLNlsNvXo0SNP7d6W7d69WytWrFBsbKz27dvnDoTff/+9vv/+e49109LS3Md8rly5UmFhYe5jd5988knVrVvX/QPEX/7yF1WtWlWrV69W9+7di/Tcns91LKVrGuzNN9+sjz/+WPXr13evc9NNN6lChQpez/Y8Z84cPfDAA1q9erW+/PJL9+v31KlTiomJ0d/+9jf3urmPKc193XWcbH4u59eOS69evdyXCzpGt6xyTV0+v4XRkSNHCgq2B5Wrf6+kHQ6HY8fmzZtPlFrhQAkg6ALAxTM3bNiQJClJkkdDyRYtWoSFhIS4T0bl+jNNs8nhw4eDDx8+rPXr13vszHUyqvNDcFk+GZUrAO7fv1/XXHONe/mhQ4cUHh5+wSeaqV69uqScMyi3aNHC47ZDhw5pxowZ+uqrr9SoUSPFxcVp5cqVl/gICrdy5UrdcsstWrx4sSTl6aV7++23a/HixWrfvr3mz5+vmjVruqdTd+7cWREREbLZbAoKClLfvn0l5Yzoui7Xq1dPkydPdu/vQkblzm8J88Ybbyg0NNQjlEjSc889pwceeED16tVzj5jm5/7779eJEydks9lksVjcYSUpKUl16tRx1zB9+nQ9/fTTatKkiZYvX66NGzeqbt26HidiOn36tK6++mp98cUX7mWucJT77MCu6afZ2dkyDEOvvfaaBgwYkO8ZhDMyMtzHwO7cuVOhoaEKDQ1VixYtNG/ePL355pt5Au0999yjWbNmXXTQze3o0aPKyMjIM8KcO9DllpCQoK1bt+qNN95QWFiY3nvvPT377LMyTVMTJkzQXXfd5T6DsyR3mPZ2luHiGtENtNeOJF1zzTX6+OOP3T8ieDtG98CBA3rvvfcKfBy+ZpqmkpKSPKYguy4nJ+fbXtcuabdynZHZNM2dNptt57Zt29JKq3agNBF0AaAEnPvi8Mu5P7fo6Ohykhq7Tl6lXO2FkpOTw5KTk/OcJKlixYpe2wtdddVVftFeqCC1atXSjTfeqAkTJmjcuHFq1KiRduzYoQ8//NDdUuVChIeHq1OnTpowYYLGjBmjxo0bKzExUWFhYbLb7ZJyQkatWrU0Z84cj21dI+a//vqrmjZtmu8IusPh0OLFi3XzzTerQoUKhdbUr18/jxByvttuu00DBgzQzz//rIkTJ+ZpXXPs2DH3DwInT570OL4wJSXFfRIf13TQypUrF3iyHdftd955p5566in38nfffVe//PKLpk6dqptuuklSzlTaHj16qFOnTho9erTHyX/yExISonr16ik5OdkdGKSckW3X9PS2bdvq008/lc1mU/fu3dWlSxd98MEHeUbaDh8+rHr16hV4f7m5WrC4TnJUFPPnz1efPn00duxYSTkhITY21mN0UMp5fidOnKgdO3aoWbNmefZzIa+LqVOnqkePHh4/5GRnZyszMzPP8bvZ2dl688039eijj6pq1aq6//779dhjj+mTTz7RyZMnlZ6e7jHF/2Lw2slxfispb+rXr68333zzgvZbUux2uw4ePOi1vZDrGHMv0vT/LYV2mKbp6rO7h/ZCuNz49zckAAgw575o7Dz3902um4y2bdtG5D6Ds9PpbCqp2dmzZ8N37NihHTt2eOwrKChIV111ldcQnN/JcHxh3Lhxevfdd/Xkk08qJSVFERERGjhwoO6+++6L2t+ECRP09ttv64knnlB6eroaNGigCRMmqFGjRurXr5+GDRumOnXqqF+/fh6j5pGRkYqJidHQoUMVFhaW72jgzp079fHHH+uOO+4oUj0FhVyn06nVq1froYce0uzZs92jVrn99ttvaty4caH34wrATqdTP/30k5YuXarhw4eratWqOnz4sGbOnKkbb7xR0dHRXkfK77jjDvXp00d16tRxP/bOnTt7PA8LFy50TyHv2LFjgfXs3r3bY4rnd9995x6FrlGjhjv0hISEyGaz6fvvv9fMmTM99vHrr7/mGZkvbnfffbfHVPeEhAS1b98+z/+LkJAQ3Xnnndq/f7/XoFuU14XNZtP777+vuLg4zZo1y+M43f/+97+qW7dunv83kydP9hgpDQoK0uOPP67HHntMQUFB+vTTTz1aI504cUJHjhzRmTNnlJKSIiknWJ86dUpOp1MvvPCC4uLi3CN7wcHBvHb8XEZGhteTRB06dCjfH3VM00yS5HGmZJvNtmPz5s2HxZmSAUkEXQDwF+bGjRsPKudYKY8E1rJly+pBQUHNDMNo6urHK6mZw+FouG/fPmPfvn2KjY312Fl4eLjX44CrV69eYtOgW7Zs6bVlT4UKFfT888+7+5oWtl1h10NDQ/XSSy+5z0qc27BhwzRs2DD39X79+nncPmLECI0YMaLAx/Hbb7957WN6IY4eParMzEzdcccdaty4sUaPHq3MzEzde++9euaZZ9S6dWtlZ2crJCREK1ascB8jmHvKsiSPL7m7du3Sf//7X61YsUI1a9ZU37593WebrlSpkiIjI/X222/r+PHj6tWrlwYMGOBxLGhR+sPWrFnTfZ//+9//3DW4jrOMi4vT6NGjFRYWpmPHjrnb4MTGxurIkSPq1q2bu33T+RwOh8djmz9/vpYuXap3333X6/qmacrhcOjUqVOyWCxeX7e5j7c8f1uX84/n7tKlizp37qyMjIw82+UexTxfYa+LjRs3auzYsYqIiND06dNVo0YNTZ06VR9++KEsFouqVq2qUaNGeWzzzTff6IcfftCMGTN0+vRprV27VsuWLdOxY8c0btw4ZWZm6p///Keuvvpq9ezZU23bttXvv/+uxYsXq3bt2qpdu7bGjRunmjVrqmbNmu7j2ocPH65169apVatWqlixIq8dPzj0wzRNJScn5wmz+/btU1JSUr6bSfpD50ZoXf1v7Xb7zi1btpwqrdqBsoqgCwB+7twXmh/P/bl16dKlwunTp/8qzynQzSRdnZSUVD4pKUkbNmzw2FflypXzjP42bNjQ60jT5eq3337z+FJ9Mfbs2aPGjRvrhRdecJ8dOiYmRrVq1dLhw4f19NNP68iRI7rnnntkt9s9ppbOmzfPvZ/cU5c3bdqk7OxsTZ482T3N06VatWrq37+/+vfvr927d2v+/PkeX+7/+c9/eq3TW7ALCgrSjBkzPK4vXLhQktSmTRt99NFHysrKUrVq1XTFFVdIygmTo0aNUkhIiPsEUIXZvHmzIiIi1KBBA4/lhmGoYsWKcjqd6tixo+x2uzp27Ojx+jQMQ9dcc02+U1GzsrI0ZMiQfO/bMAw99dRT2rVrV75h+XyFvS6ioqI0fvx4XXvtte5lDz/8sB5++GH3WYXP16ZNG7Vu3Vqpqal68MEHFR0drXvuuUddunRxj+LefPPNWrhwoWbMmKHDhw9r8ODBhbbzeeutt5Sdne0Os7x2vL+3VahQwX0m6+LidDp15MiRPNON9+7dqzNnzuS3WZakXTp37KzOBdsqVar8Hhsbm1msBQKXEd//xAUAKFZ9+vQJ2rdvX6TT6XQfB5zrmODq3rYJCQlR/fr1vfb9zX0sHYrONM0ijSQVdb1AlJaW5tHz9nymacputxdLG5n9+/d7nMzI32RlZfFv7QKU5mvHm6ysLK99aQ8cOFDQCcFO6dw0Y50LsxaLZUeDBg32f/XVV0U/8BxAkVyen6wAcHky8muHJOkqrxtcZu2QACC3EmjXw/GzQCkh6AIA8m2HJKmJ8jnMJRDbIQG4/NCuBwhMfBMBAOSroHZIkrzOGyzL7ZAABC7a9QCXF4IuAOBi5NsOyTCMcG8blJV2SADKNtr1AJAIugCAYpZfOyRJDZXP544v2iEBKLto1wOgMHx7AACUioLaIUnyerpZ2iEBlzfa9QC4WARdAIBP0Q4JAO16ABQ3gi4AwF/RDgkIMLTrAVBaCLoAgDKHdkiA/6JdDwB/wCc7ACBg0A4JKD206wHgzwi6AIDLAe2QgItEux4AZRFBFwBwWaMdEkC7HgCBh09jAAC8oB0SAhHtegBcLgi6AABcANohoSygXQ+Ayx1BFwCA4kE7JJQ62vUAgHcEXQAAShjtkHApaNcDABeOT0oAAHyEdkjIjXY9AFB8CLoAAPgf2iEFMNr1AEDJI+gCAFCG0A6pbKBdDwD4Fp9uAAAEANoh+QbtegDAPxF0AQAIYLRDKh606wGAsoWgCwDA5Yl2SF7QrgcAAgNBFwAAeAj0dki06wGAwOdfnzwAAMBvlbV2SLTrAYDLF0EXAABcKp+2Q6JdDwDgfARdAABQYoqrHVKDBg0kiXY9AIAiIegCAIBSdzHtkApAux4AgAeCLgAA8BuFtEOSaNcDAAAAAAgEVqvVtFqtHDsLACgSi68LAAAAAACgOBF0AQAAAAABhaALAAAAAAgoBF0AAAAAQEAh6AIAAAAAAgpBFwAAAAAQUAi6AAAAAICAQtAFAAAAAAQUgi4AAAAAIKAQdAEAAAAAAYWgCwAAAAAIKARdAAAAAEBAIegCAAAAAAIKQRcAAAAAEFAIugAAAACAgELQBQAAAAAEFIIuAAAAACCgEHQBAAAAAAGFoAsAAAAACCgEXQAAAABAQCHoAgAAAAACCkEXAAAAABBQDF8XAAAAkFtUVFREcHDwyPMWDz73349yL7Tb7eM3b958qHQqAwCUFQRdAADgV/r06ROUmJh42DCM8ILWM00zqUmTJvW++uorR2nVBgAoG4J8XQAAAEBu27dvN+vVq9dYUptCVp35/fffLymNmgAAZQvH6AIAAL/jdDrnF2G1oqwDALgMEXQBAIDfsVgsa0zTTC5glT+rVq26ptQKAgCUKQRdAADgd+Lj47MNw1hUwCqLYmNj7aVWEACgTCHoAgAAv2QYRr5Tky0WC9OWAQD5IugCAAC/lJqa+p2k015uOp2SkvJ9adcDACg7CLoAAMAvJSYmZpmm6e2syosTExOzSr0gAECZQdAFAAB+K5/py0xbBgAUiKALAAD8lmEYKyRl5FqUYRjGSl/VAwAoGwi6AADAb8XHx2dIWu66bhjGsnPLAADIF0EXAAD4NdM03VOVnU4n05YBAIUi6AIAAL8WEhKy1HU5NDR0aUHrAgAAAABQJlit1sVWq/VbX9cBACgbgn1dAAAAQBHMNwzD9HURAICywfB1AQBwsVq3br3BMIzrfF0HAAAoXqZpxm7atKmrr+tA2cUxugDKLEIuAACByTCMLr6uAWUbU5cBlHnx8fG+LgEAABST6OhoX5eAAMCILgAAAAAgoBB0AQAAAAABhaALAAAAAAgoBF0AAAAAQEAh6AIAAAAAAgpBFwAAAAAQUAi6AAAAAICAQtAFAAAAAAQUgi4AAAAAIKAQdAEAAAAAAYWgCwAAAAAIKARdAAAAAEBAIegCAAAAAAIKQRcAAAAAEFAIugAAAACAgELQBQAAAAAEFIIuAAAAACCgEHQBoIQ4HI4CbzdNU9u3by+lagDAE+9RAAIZQRcASsigQYP0+++/53t7dna27rvvPo9lv/76q9d1p06dWqy1Abg4+/fv13PPPSdJOn78uPr37+/jii5eab5HmaapkydPasOGDdq/f3+e20+dOqWtW7cqMTHR6/bTpk1TRkZGgfchSUlJSbrllls81t23b58eeughr+tv27ZNqampeZbbbDZ17Nix0PtzWblypex2u06cOKFDhw4VebvCrFq1Ks+yXbt2eX0OJen06dM6ffq0JOmrr77yuo5pmpo7d26x1Qj4q2BfFwAAgapjx4567bXXNH36dBmGUej6drtdM2fO1Jw5czR69GiFhoa6b5s9e7ZiY2M91p81a5aknFGZv/3tb2rUqJGknC91cXFx6tmzp2rWrOlef//+/frxxx+1ZcsWDRw40GNfjRs31pQpUzR48GAtWLBA27Zt08CBA7Vu3TqPOnwhd72GYahy5cpq1qyZ7r77bnXr1u2C9+Orx5SUlOR+fi2WS/ud2Zf/D8///1GtWjV16tRJzzzzjCpXrlxs91PSoqOji7TeX//6V82ZM8d9/bvvvlONGjUk5YSQZs2aFbi9w+HQddddp7CwMI/lGRkZCg4OVkhIiMfy5557Th988EGedatVqyZJOnz4sOrVqydJOnLkiDZu3Fikx+FNab1H9enTRykpKapWrZrCw8PVrVs3RUZG6u6771ZGRoays7NVpUoV1a5dWx07dlSTJk089rN7924tWrQo37Ca2+LFi9WqVSuP2mJjYxUVFeV1/eXLl+u3337TRx99pEGDBrmXm6aps2fPevyQ0b17d491cnv55ZcVGxur9PR0ff7556pevbqeeuqpQustzMsvv6wePXp4LDt69KgmT56sWbNm5fk39+GHH6pOnToaOHCgJk6cqD59+rhvu/feezVr1iw5nU5NnDhR99xzzyXXB/gzgi4AlJD77rtPCxYs0LJly3TrrbcWun5wcLDefPNNvfDCC1qyZIn69u3rcbvrS6M3tWvXdn8Z79WrlyQpKCjI4wt67969PbbxFoAWLlzodf8HDhzQ0KFDNXfu3DxfzEvLunXrVLFiRaWkpGjjxo2aMmWK1q5dq1deeeWSg2Nx8/Z8hYeH5/v8Xixf/j9ct26dKlSooP3792vs2LEaPXq0Jk2adMn7LS0///yzx/WjR4/q73//e57luQOgaZpavHixxowZI6fTqa+//lqnTp1SXFxcnv336NFDzz77rPv6mjVr3JfT0tLUq1cvTZ48WW3atMmz7e23367OnTu7t+ncubMWLVokKSecui537tz5Qh+2h9J6j0pJSfE6MnnixAn98MMPef79btmyRUOGDHFfz8jIUIUKFdSlS5d8a/vhhx/UvXt3paenq1y5cu4fwVavXq3ly5frwIED+vrrr93rf/HFF4qMjNQzzzyjwYMH68svv/R4v7TZbOrQoYPHMknas2ePHnvsMa81xMTEeFz/9ttvJXkflb1QPXr08JhqnpWVpb///e/u66tXr5bNZtOqVavkdDo1d+5cOZ1O9+fB8uXLtWvXrkuuAyhLCLoAUELKly+vcePG6aqrrtL48eO1evVqr+vl/kLm+iIZFBSkNm3a6C9/+YuknJCUe2ThxIkTqlOnjmbPnu2+7ro9JSVFUs5IUu5tkpOTL/qxpKam6sCBAxe9fXExDEPVq1dXz5491b59e/3jH//QvHnz1K9fP1+X5sFfnq/cSqImi8Wihg0bavDgwRo6dKicTqff/eiQn6CgII/rrrrPX55bXFycDh8+rGuvvVZLly5VzZo19c0336ht27ZFGlkdMGCA0tPTlZmZqYyMDL366qset7sCrDeuUJmVleW+XJSpvAUpzfeo/Hh7vbRs2dId8hMSEvSvf/1Ln332WYE/0DgcDqWmprp/dHA4HOrYsaMSEhIUGhrq8WNE165dFRyc8xU4KChIkyZNco+4ux6DaZoe1yUpMjJSb7zxhlatWiW73e7eh5QzQ2DBggUeI6ymaRZppNwb13PudDrVrVs3paamKj4+3uu6bdu2lSR9/fXXuuGGG/TKK6+4ly9fvvyi7h8IBGXj0wgAyqg2bdooPDxcI0eO1HfffafVq1e7/1asWCFJ7uuLFy/W8OHDlZWVJcMwVK5cOc2ZM0dz5sxR3bp13ZdnzZqlKlWq6P7/Y+/O42pM//+BvzrqoA8xtsbYM8bMyCznaGEKESMRUkYYYj6W+JjMZJAQ0Wck8SETss7YapBJtpk+/JKltDg/1wAAIABJREFUsWSsxZgwLSqTOqWis71/f/Q996fTOadNQvN+Ph49nHPd23Vf575v9/u+rvu6Jk4EUBr8ffzxx8J0R0dHHDp0CDY2NvD29sZbb72FoKAg2NvbV5jXGzduQCqV6r151jRV7d27t1aTT7lcjlWrVsHBwQF2dnZYuHAhCgsLtdZ3+PBhDBgwAKtXr66NIhWYmZlh/PjxOHjwYJXyU15l88pkMvj4+KB3794YPnw4tm/fDqlUCrlcDqC0RnDcuHGwsbHB8OHDtW6k9ZVX2fLVfL5w4QLGjRsHW1tbjBkzBsnJyVXevj4v6zcsKSlB48aNIRKJDC6jUCgQFhaGYcOGwcbGBkOHDsWWLVugVqsBlL5P6ODgILxfePXqVdjb2yMpKQm2trY4d+6csL1nz56hb9++emtSX6Tw8HAAwJMnTxAaGlrtpqkZGRmIjo7Gzz//jMTERERHRwt/mgdUhvz444/48ccf0bBhQ+FzZU3SR48ejW3btlU4T11co4DS2k5XV1dYW1tXsbRKm2bPnz8fDx8+xIgRI+Dk5KTzpzl+NMRisfAHAEePHtVp8qxUKmFiYoIdO3bA1dUVXl5euHv3bqXvW//5559Qq9WQy+UYO3Ys0tLStKbHx8cLn69evYrx48fjyZMnVd7fsjRlLhKJcOrUKQQGBkKpVCIkJARbtmwBAGzcuBEnTpwQHpi89957mDRpUo22x1h9xDW6jDH2Auzduxc7duxAYWEhEhISoFarMXHiRHz55ZcGb/QGDx6MCxcuYPLkyUITwMTERBw9ehQJCQnw8vKCkZERBg4cCFdXVwwZMgQA4ObmBkC72dzJkyfx5ptv4tatW8jJycHEiRPRokULTJs2rUbvje3cuROenp5ISEjQqlVZsWIF0tPTERERgYYNG8LX1xchISHw9/cX5rlw4QJiYmKEGpLa1K1bNzx48ECoSaxKfqqad39/fzx9+lTI+7x587SWLyoqwqJFi/D2228jNDQU3377rdBU0VB5lRcVFYX169dDLBZj0aJFWL58uVADVtn2q6u2fsP79+8L6Wq1Grdv30ZYWJjO+37lf/fAwEAkJSVhzZo1sLCwQFJSEhYsWAClUgkvLy+4ubnh+PHj2Lp1K+bMmYNVq1Zh1qxZeP/99+Hg4IBjx47hk08+AVB6fDdv3hy2trbPVSbV8fPPP+Pp06cASmsLJ0yYgA8//FCYrmkiqrFz506Ym5vrrKd8c18NzcOJ69evY/78+SgqKoKTkxNatWpV4zyPGDEClpaWeqfV5TUKKD3WAe1yKioqEl6pyMrKwptvvinkLT8/H7Nnz0Zubq7BmkypVFrpdcXPzw9r1qyBSqUSmj6rVCqIxWJ89tlncHFxwYgRI9C9e3edZsqGiMVijBgxAnPnzsWuXbuE82nbtm0YPHgwHjx4gK+++gpubm618t66XC5Ht27dMHnyZLRv3x4zZ84EUPrwatGiRTAxMYG9vT1WrlyJoqIiYTm1Wq3zygpjjDHGXgMSiYQkEgm9ymxtbYXPN2/eJEdHR0pKSiIiopKSEr35v3nzJqnVarK1taXHjx9TWloaDRkyhIqKioiI6PLly/Tll1/qLJeXl0f79++nUaNG0eXLl2nKlCm0f/9+Kiws1Jrv+vXrpCk7zV9wcLCQXlRUpPW57DIlJSXCenJzc0kqldKdO3eEtLNnz5K9vb3WMrdv365p8WmtR5OXsn799VeysbGpVn6KiooqnTc3N5ckEgndvHlTmH7u3DmdMnj69CklJSXRpk2bSCKRkEKh0NpW2Xn1lW9qaqrW+qVSKalUqkq3/zJ/w7Lb7tWrF40aNYr27t1LarXa4DJ5eXkklUrp6tWrWr9fdHQ0OTo6Ct9TUlLIzs6O1q1bR//85z+FdV6+fJn69Okj7Mv06dNpx44dVJsyMjIqvJ54eXlRbGws9erVS2eavjSNkpISsrKyIiKivn37Gpyv/LSy3/v27UsuLi7k4uJCUqlU+FzRdquqLq5RZX/jIUOGEBGRSqWi/v37C+mffPKJ8PnKlSvk4OBAUVFRJJFIyNnZWe+fRCIhpVJJRERKpZIkEgk5ODgIf5q8p6Sk0ODBgykrK4uIiKysrLSuJ2W37erqSu7u7jp/o0aN0ioDtVpNM2bMoGvXrhERkUQioc8//5yWLFlCDg4OFB4eXnnhG6BWqykpKYkiIyNJIpGQo6MjBQcHU2RkpM68KpWKli9frnWt0Ch/fGi+a8rqVaa5xrzs+wz2euMaXcYYqyM9evTAwoULce3aNYM9tT579gyNGjVCYWEhmjRpghYtWqBFixYYPXo0PDw80LBhQzRs2FB4on/79m18//33uHv3LgoKCjBo0CCh182wsDAcOnQIs2fPxtOnT9GqVSs0a9ZMqPkt35HRjRs3qrU/WVlZICK9zf0UCoXwuX379tVab3XcuHED7777brXyU5V5s7KyAJS+k6dRvmYmNDQUhw8fxgcffICGDRsCgE4zysqU7RW7adOmICIolcoqbR94ub9hZb05l10mMzMTRCT0DK7RsWNH5ObmCjXyFhYWGDhwIL7//nts2bJFeL9RKpWibdu2OHXqFKRSKa5du4Zvv/22Wvv6vKZNm4aPPvoIvr6+1VpOLpcLxweg22GRRkXv244dOxZeXl4AtDujKt878/N6EdcooLSpsGa/Hz9+DKB0GJzGjRvr3YZIJMKECRMwatQorFixAkeOHNE7n76eszXvGWt6uwYACwsLuLu7Y9WqVQgODoZKpYKJiYnedaampup937r8toyMjPDdd9/h8ePHmDt3LgDgm2++wdSpUzF69GhMnTpV7/qrgogwd+5cfPTRRxCJRDh48CAyMzMxZ84c7NixQ+8yixYtAlBai6/ptKpsja6mtQljfycc6DLGWB1ycHDAs2fPoFarkZ2drdMRy6VLl7Bv3z54e3ujVatWuHz5Mho3boyLFy+iT58+sLKygp2dHRYvXgwrKyt07twZAwcORHx8PDp06IArV67gypUr2LdvH77++muhA6qSkhJcvHgR27dvr3YwZohmiJWjR48KTQ71qWlnLJX566+/EBkZKdxkVjU/VZlX0zHNo0ePhM/Z2dnC9PT0dOzcuRP79++HhYUFEhIS8PPPPz//TlVx+7XlRf6GZZdp3bo1gNJ3HMs2pU1PT4e5ublwHqSnp+P06dMYOHAgtm/fDolEIszr5uaGo0ePIjMzEwMGDMAbb7xR7Tw9j48++qhGy+Xn58PMzAxAaXP0rl27olOnTkIglpiYiEePHuHmzZsG16EJcqua/jxq+xolEolgamoqNF3WvE+alJSEzp07683Dhx9+qNUsvDZMnDgRf/31F+RyOUQikcFAV61WV2lsZE3Pxps2bRKG/+ncuTPmzZuHdevWwdnZGe+//36N8ioSiXD06FEAwC+//AIzMzOYmZlpdSxlqAM0mUwmdORlZWWFI0eOYMCAAS/k1RHGXnXcGRVjjL0gaWlpQsclZS1atAhWVlYYOXIkBg8erDXt4sWLsLa2RkJCAj788EPs27cPjx49wv379/HVV19BIpHgp59+QmZmJg4fPoxGjRrB0dERZmZmwvAYmk5t7t27J3QOExUVhRYtWqBHjx412hfNjfrVq1eFzoLMzc0hkUiwevVqZGdnQ6VS4ffff9cZnqUyKpUKP/30E549e1bpvESE3NxcHDt2DJ6ennB2dsann35a7fxUNm+HDh2EcWkLCgqQkZGBH374QVheqVQCKK2pLCgo0Hm3T195VUdl26+JF/kbVqZVq1YYOHAgAgMDcffuXahUKty8eRObNm0SOixSq9VYvHgxxowZA39/f/z+++9aQyU5Ozvj5s2biI6OxujRo7XWHxMTAycnp1ofvqk6yneSpHmvNC0tTRj3ViwWY8KECVrHhFwuh6enJ5o1a6azTrVajczMTK31Pnv2TOt7TEyMwTz98MMP+O233wxOr4trVGZmpta7yosXLwZQWsPYp08fg3kra8SIEXr/qkMsFqNdu3YoLi7WqmHX+P333/Hrr79WaV2XLl2Ch4cHDh06hPXr1wu1qUBpjb2bmxumT5+OkydPGlxHda57teV5xlxm7HXENbqMMfYCZGRkYMaMGbC3t4e3tzd8fHzw9ttvAwBWrlwJhUIBY2NjnVqF06dPw9/fH35+fli8eDGWLFmC5cuXC8NUPH78GFFRUfj000/x008/GWwGWds6deoEV1dXeHt7o0mTJsK4kEFBQVi5ciXc3NygUChgYWEBb2/vaq379u3bCA8Px8iRIyucz97eHkZGRjAzM4OlpSX8/Px0bpSrk5/K5g0KCoK/vz8GDx6Mbt26wdXVFbdu3YKxsTE6d+6MsWPH4ptvvkGbNm0wduxYrV6BDZVXdVS0/Zp4kb9hVQQEBGDDhg2YNWsWZDIZ2rdvD09PT6EztR07duDx48f44osvIBaL4e3tjaCgIPTu3Rvm5uZo2rQpHBwckJycrFXTCwBhYWHYtGkTZs6cWelx9KIYGsYlISEBPXv2hEKhwJo1azBz5kyYmZkJzUvFYjEWL16Mb775Bjt27EBRURGio6Mhl8sxZcoUdOvWTWvddnZ2VR4yJjo6GgqFAh9//LHOtLq6RpmYmOg8YLtw4QIuXLiAhQsXVnk/9NHXdNnOzq7Cdd29e1doyQCUNtEvKSnBpEmTsHTpUohEIr2dUmm2dfv2bcyePRtffPEFJk+erPd8nD17Npo2bYoFCxZg8ODB8Pf31+mUrqrXveelVquhUqm0auYfPHjw0sZDZ6wuvZj2ZIwxVgc0HVUY6pHzZfrll1/w8OFDeHp6Ijo6GpGRkcjMzIRIJEKDBg1gbGwMIyMjyOVyPHv2DCYmJvjuu+8we/ZsTJgwAffv34ePjw+uX78OOzs7LFu2DPHx8SAieHp6YuzYsTA2NhZuXmxsbIT3H+/du4cLFy7AyckJzZs3F/KkSX/V7N27FxkZGfjmm29edlYqFBMTg40bN+LYsWN/y+2/CsaOHYuRI0fqjJvs5OSETZs2wcvLq0rloy9Aqkh4eLiwjL4mo4aakRYVFWH48OHYsmULjh07hvv372PJkiUwNTVFdna21gOSjRs34uTJkwgODkZubi7ef/99NG7cGAEBAVo17GV7J9Yw9A5rReriGtWgQQNMmTIFc+bMEYLta9euwdvbG4sWLYKjo6OQHzs7O5w9e1Ynn1KpVOsa/+jRIygUCjx8+BBffvklzp8/DyMjI62m4AC0vickJMDf3x9NmjRBVlYWpk6dismTJwMoDbr/9a9/wc/PDyNHjtT6LTXNnLOysuDm5ibU+KampqJjx45CE++HDx9i7NixOH/+vFYAefXqVZw7dw6zZs3S2a/KrnuZmZlo2LAhnJ2dkZCQgH79+mlN17wjrTFw4EAsWbIE3t7eWLduHQAIzcgbNmyIlStXwt3dHffu3YOJiQk+++wzfPXVV4YOj5dOc75duXKFYxXGGGN/P69yr8ua3mL1USgU9PTpU3r69CmVlJSQUqkU5s/Pz6eSkhKtnnGrIi0tTfickZGh9a++eV4l8+bNo8uXL7/sbOg4efIkpaenk1KppBs3btCwYcNo06ZNf5vtv0pkMhlFRkaSo6Oj3t63Dx06RE5OTnTw4MEXnpeNGzdWKY2otPfgefPmkUqlosDAQCoqKqJFixaRRCIhGxsbCg0NFeZVKpW0ZcuWap/7NVVX16iIiAit74cPH6ZDhw7pzOft7a13+fLX+IMHD5KrqyuNHTuWdu3apTXt+vXrWt81vZrL5XK6d+8eJScnU2ZmptY8T58+pYSEBOF72Z6KT548SU5OTjR8+HBav369Tt4uX75MEomErKysaMWKFXrzb0hl173x48dTr169yM/Pr1rrLUtfr9wqlarC3/5Vwb0us9rAT0kYY6+tV7lGl73+duzYgcjISOTl5aFVq1YYNmwYpk2bhgYNGvwttv8q6d27N958800EBASgZ8+eLzs71SKXy3WaidL/dQz0ojpqY3VHrVbDyMiIf8taxjW6rDbwwcMYe21xoMsYY4zVPxzostrAvS4zxhhjrErqsofYVxWXAWOMvR440GWMMcb+BtRqdaVDHWVnZyMjIwMAhM5vUlJSkJOTg+LiYvTv319nKBoNfR0JVUd6enq1O1V6/PhxlTqWys7OxtChQ1FcXCykPXjwAFOmTNE778sqg5o6c+YMNm/eXOvr3b17tzAWt8aJEyewcePGWt8WY4zVNh5eiDHG2Cvvxo0b8PT0xJkzZ2BqaqqTnpCQ8EKGy8jOzsaGDRuQkJCA/Px8mJqawsPDAzNmzHgh25o+fTqioqK0hgKpqTt37uDSpUtIS0tDSkoKUlJSMHjwYPj6+hpc5syZM4iNjRWCJiJCYGAgZs2aBaVSiY4dOxosZz8/P5w+fRqurq5Qq9V690Emk+HUqVN6lzcxMcGGDRvQvXt3dOvWrQZ7bFhMTAw+/PBDrWMnLi4OH3zwgc68L7MMaqpTp05YvHgxnJyc0LFjR61pGzduRFRUlFZabm6uVo+9GoWFhcKrIA8ePMCePXswZswYrXnee+89rFq1CtbW1tXuvZoxxuoSB7qMMcbqjdTUVHh7eyMyMlIrGDGUXhGlUompU6fCwcEBkZGRaNasGdLS0vDw4cMXkndzc3P89NNPtbY+pVIJhUKBjz76CIcPH8bp06chFouFYVfKBjqFhYW4ePEiXF1dERcXh8zMTABAUlISunTpAqlUipCQEL2BoT47d+7UGtpKY8CAAcJnqVSKZs2a6cwzffp0nbQTJ07U6EGGWq2Go6MjioqKYGJiImz/1KlTOH78OFJTU3HgwAFh/j179tRpGdSElZWVVsCuQUT4/PPPtdKKi4tx6dIleHl5aQ3TI5VKcfr0aQDAtGnTEB4eLqRr7Nq1C5MmTYJYLMagQYMAlB5TarUaYrEYCxYsEOZdsmQJ7O3tn2u/GGOstnGgyxhjrN7Iz89HampqldMrkpKSgoyMDEyaNAktWrQAAHTp0gVdunSplby+aD169ECPHj0AAAEBATqBoibQAf4X4Li5uQEAZs2aheLiYixevBgAcP78eRw7dgxisRjDhg1DUVERFAoFfHx8sGvXLshkMhQVFWHAgAFo3rw5vvjiiyr1Dh0bG4sGDRqgpKQEnp6eWLFiBbp27WpwfqlUqhWga3ovLjvGqFqtRosWLRAdHQ0iQn5+PhISEgCUjq1qZ2eHK1euwNTUVEgHAAcHBxgbG9d5GVSXWq3GqVOnkJqaiuLiYuE3LikpwcaNGzFnzhxhX62trStd32+//aaTlpGRgcTERMyfPx87duzA/v370bx5cwQEBCA5ORm7d+9GgwYNoFKp/pa9gDPGGGOMvVCv8ji6rHZdv36dJBKJzhiqmnTNmJ6aY6L8saEvXbPs2bNnafTo0WRra0uzZ8+mvLw8IiodL7RPnz7k7++vd+xWIqKSkhIKCgqi/v370yeffEK+vr705MkTYfq+ffto0KBBZGtrS8HBwRWml99HuVxO3333HTk7O5O1tTU5OTlReHg4qVQqrfl//fVX8vDwIBsbG3J3d6ekpCQiIlqwYAG5uLiQk5MTSaVScnFxIRcXF1IqlTrnjUQiIaVSSUREDx48oKlTp5KNjQ1t3ryZioqKaPfu3SSRSOjRo0dERBQeHk5r1qzRWkffvn2JiGjUqFFCGRIR/fvf/xY+L168WGebjo6O1L9/f5JKpeTo6Kjz5+zsrLVM2d8iJydHZ19u375NLi4uREQ6+6r5HhAQQPHx8VrL2dnZUXZ2dp2WQU3Ex8eTWq2mhIQEcnFxoVmzZlFycjLJZDKysrIS5lOr1Vr7WP580Cg71qom3cfHh44ePUo3b94kNzc3UigUdPnyZbKzs6Pff/+diIjy8vJowoQJpFAonmt/GNOHx9FltYE7o2KMMVZv7Ny5EwCQkJCgNeyUoXQAOHz4MMLDwxEdHY2cnBwEBwcDAMzMzBAUFIT4+Hi4uLhg+/btWp0ZAcCKFStw+/ZtRERE4MiRI8jLy0NISAiA0s6VgoODsWLFCpw8eRJOTk4VppcXGBiIuLg4rFmzBufOncPKlStx6NAhnU6HoqKisH79evzyyy948803sXz5cgDAt99+i+joaAwfPhwmJiaIjo5GdHS0wbKTy+UIDQ1FQEAAFi1ahIYNG6Jbt26YMWMGsrKy0KtXL6SkpAAore2uqOa1rNjYWOFzQECAzvQDBw7A2NgYBw4cQGxsLLZv347Y2Fjhr7odVFWFn58fLly4gLi4OCFNpVLByMjopZRBddjb2+P8+fNo3bo1Dh48CDs7O6SmpuLZs2do2LChMJ+RkRHs7e0RGRkpND0eNGgQpk2bJswjl8uhVqu11q9Wq5GUlIQtW7bA09MTixYtQkFBAZYuXYrAwEB069YNRITGjRujZcuW2Lt3LwCgoKAA2dnZ1fpjjLEXiZsuM8YYe228iPcAvby8hKbJnp6eQqAIAHZ2doiOjsaePXvwww8/4MCBA/jPf/6Dd955B3l5eTh27Bj27t0Lc3NzAMCECRPg6+sLf39/mJiYwMjICFlZWbC2thaamBpKL0smk+HIkSPYtm0b3nnnHQDABx98gBkzZiA0NBReXl7CvP/617/QqlUrAMDYsWPx5ZdfCh0h5eXl4dChQ1Cr1fDz88OiRYsMvutqYmKC9957D7NmzUJISAgWL14MBwcH9OrVC02bNkVkZCTOnDkDKysrXL58GbNnzwZQ+t7m3bt3UVJSgkmTJiErKwsTJ06EkVHp8JdPnjzBiBEjhO0sXboUH3/8MYDSYGzNmjUYOnQoOnfuDAAYOXIkLl68WKtNYsu/FysSieDq6govLy+89957MDc3h1KphKmpaZ2XQU1kZmYiMDAQXbt2xezZs/HOO+/gzp07et95/uyzz/DZZ59BKpUKAbemqbrmPeTyZXPs2DFERkYiMzMTH374IZYsWYKmTZti2bJlkMvlMDY2RkFBAd5++23s3LkTLi4uWLt2bbUfSvAY6IyxF4kDXcYYY68NQ70uP482bdoIn1u3bo3i4mKtHnObNm2KGTNmYNy4cViwYAEWLlyIAwcOICsrC0QEDw8PnXUqFAqYm5tj+fLlWLduHXbv3g1fX198/PHHBtPLyszMBBHBwsJCK71jx47Izc3VqoVr2bKl8Llp06YgIiiVSojFYoSEhMDZ2RkRERGwtLSEj48P1q9fr7ccjIyMEBYWhg0bNiAtLQ0JCQkICwsDAGzfvh0ODg7w8PBAhw4d8NZbb6Fdu3ZQKpVwdXVF9+7dYWxsjBUrVmDatGk4dOiQEKgOGDBApyb56dOnEIlEEIlEOHLkCJo0aYKYmBhhuqYGEgAWLlwIR0dH4XvZGnCq4B3dsjS9HJd9b9XCwgLu7u5YtWoVgoODoVKpIBaL66wMnoebmxtcXFwQFRUlPLhISUnBW2+9Va31XL9+HQAwY8YMbNq0SUg/d+4cIiIisGDBAsTExGDBggUwNTWFra0tzp8/D5FIBCsrK0RGRuLGjRswMzPDsmXLsGzZslrbR8YYe14c6DLGGPtbKywsFILnP//8E23atNE7LIyZmRkmT54MLy8vrWDq6NGjePPNN/Wu28nJCY6Ojli/fj3mzZsn1KgZStdo3bq1kB9LS0shPT09Hebm5lUafigmJga//fYb9u/fj4iICHh4eMDCwkKoZdRn586dGDduHKKiotCpUyckJyfD398fZmZmEIlEsLOzQ3BwMNauXQsAMDY2xuHDhwGUBpvt27eHXC5HgwYNhGFpnjx5Inxu164d1q5dC5lMJtQ+lq/V09Q86qvRtbS0RHh4uNBE9/Hjxxg8eLBWx1qpqan47rvvKi0fAJg4cSL++usvyOVyiEQimJiY1FkZ1MSdO3e0mh4DEMa01TRDLhv0A9qdjmlYWlpCrVZj//796NKlC65duwagtDYdAOLj49GhQwfEx8ejbdu2EIvFyMrKQvPmzXWOvZ49e9ZoXxhj7EXjQJcxxli9YWZmBgC4evUq3n33XeG7oXQA2LBhA+bPn4+cnBxs374dw4cPBwDcvXsXcXFx+PTTT9GuXTvIZDIcOnQI1tbWEIlEMDc3h0QiwerVq/HNN9+gVatWSElJgUwmg7W1NTIzM5GdnQ1LS0t06NABcrkcRISsrCy96WW1atUKAwcORGBgIAICAmBhYYHk5GRs2rQJEydOrFJZXL9+HYGBgVo14DY2NlCpVAaXKSwshKWlJfz9/TFy5Eh8//338Pf3h0gkglqtRmFhIYDSoEqfrKwsIUjPycnRGi9WJpNhypQpAIB79+6hQ4cOcHd3h0wm01nPkCFDtL5rHgR8//33le53x44dERQUVOl8ACAWi9GuXTvk5uYKwXNdlYE+KpUKMTExGDJkCBo1aqQzvXv37jqBKxFhy5Yt2Lx5M3x8fPDZZ59pPSRQq9VITk4GAPj4+ODhw4cICwvDunXrkJycjHXr1sHHxwcAsHjxYvj5+WHp0qVQKBS4e/cu7ty5g7/++guxsbF6h1aKj49HQUEBhg0bZnC/KhITE4OwsDBMnz5dCLQZY6w2cKDLGGOs3ujUqRNcXV3h7e2NJk2aCAGSoXSg9N3XkSNHoqSkBE5OTpg6dSqA0uA4MTERe/fuRWFhIVq2bAl7e3vMnz9fWDYoKAgrV66Em5sbFAoFLCws4O3tDaA0aAkICEBGRgbatWuHFStWwMjIyGB6eQEBAdiwYQNmzZoFmUyG9u3bw9PTUxj+pjK+vr4V1vzqG8/1rbfeQkBAANatW4eQkBA0atQId+7cgaWlJZYvXw6ZTIaQkBChgyJXV1et5a9du1alDpri4+PRs2dPfP311zrTpFIpTpw4Uavv6NrZ2VU4/e7du0INfV2VgT63b99GeHh4lQI+tVqNhIQEbNu2DcXFxQgODkZMTAz27NmD8eN8bmjgAAAgAElEQVTHw9XVFY0aNcLu3btx69Yt+Pr6wsrKCs2bN8fKlSsRFxeHpUuXok+fPiAiKBQK5OXl4fTp05g4cSKMjY2FIaquXr2KrVu3CrXHAIRj+cGDBzA2rvntZFhYGDZt2oSZM2dyoMsYq1Uc6DLGGHvl9ezZU2/HNfrS/fz84OfnpzOvofShQ4fqDR7Nzc213lvUp0WLFli1apXeae3bt0dUVFSV08vvS6NGjTB37lzMnTtX7/r17buhctKnbE2jVCpFYWEh1qxZg8TERPTr1w/R0dHIy8vDuXPnMHPmTDRu3BihoaEwNTXF6tWrMX/+fKEpr0KhgFgsxokTJ4Sms2Wb6wIQapIfPXqEY8eOCe++1oWzZ88KedC8o5uQkAB/f380adIEWVlZmDp1KgoLCxEcHPzCy8CQa9euwcHBweD03NxcxMXF4dq1azh//jzeeOMNeHh4wMXFBQ0aNMCAAQOQkpKCbdu2YefOnfj888+1WgD8+eefGDFiBN555x3s3r1bCMj79esHJycnqNVqjB49GrNnzxaCV39/f1y8eBHBwcFaHaf16dMHn376KYyMjHR6Aq+J8q0aGGOMMcb+tngcXfY8DI3NWx/Z2toKn1UqFQUEBGhNDwgIIJVKRadPn6anT5/qLJ+YmEhqtVorLSsri0pKSsjDw4P69etHYWFhtH79epLJZERE5ODgoDV/Xl4ejRo1irKysmjevHkG81p2TN/KFBYWUmBgYIXzXL9+Xet7amoqEZWOU3zv3j1KTk6mzMxMYXpdlIEh8+bNo8uXLxuc/uTJE5o7dy7t3LmT/vjjD4PzERGlpKTQli1bdNLv379f4XLlpaWlCeNUvwiHDh0iJycnOnjw4AvbBnv98Di6rDYY7pGCMcZecZr/BHmIClYTmh6by/fkXB+V7UX6RSKiCju7qu58r6P6vG+M1RXNEFhXrlzhk4nVGDddZowx9rdUnWa+r7u6CHIBVDnAq8+BYH3eN8YYe53Uzf98jDHGGGOMMcZYHeFAlzHGGGOMMcZYvcKBLmOMMcYYY4yxeoUDXcYYY4wxxhhj9QoHuowxxhhjjDHG6hUOdBljjDHGGGOM1Ssc6DLGGGOMMcYYq1c40GWMMcYYY4wxVq9woMsYY4wxxhhjrF7hQJcxxhhjjDHGWL3CgS5jjDHGGGOMsXqFA13GGGOMMcYYY/UKB7qMMcYYY4wxxuoVDnQZY4wxxhhjjNUrHOgyxhhjjDHGGKtXjF92Bhhj7HlJpdKXnQXGGGOMMfYK4Rpdxthri4jiXnYeGGOMMVb7+P94xhhjjDFW70kkEpJIJPSy88EYY+z1wDW6jDHGGGOMMcbqFQ50GWOMMcYYY4zVKxzoMsYYY4wxxhirVzjQZYwxxhhjjDFWr3CgyxhjjDHGGGOsXuFAlzHGGGOMMcZYvcKBLmOMMcYYY4yxeoUDXcYYY4wxxhhj9QoHuowxxhhjjDHG6hUOdBljjDHGGGOM1Ssc6DLGGGOMMcYYq1c40GWMMcYYY4wxVq9woMsYY4wxxhhjrF7hQJcxxhhjjDHGWL3CgS5jjDHGGGOMsXqFA13GGGOMMcYYY/UKB7qMMcYYY4wxxuoVDnQZY4wxxhhjjNUrHOgyxhhjjDHGGKtXONBljDHGGGOMMVavcKDLGGOMMcYYY6xe4UCXMcYYY4wxxli9YvSyM8AYY4wxVtYHH3zQ3tjYeFG55On/9+/msolKpXLF9evX0+smZ4wxxl4XHOgyxhhj7JXi7u7e4I8//sgwMjIyr2g+Isp+++232+3fv19VV3ljjDH2emjwsjPAGGOMMVZWUlIStWvXriuAXpXMuuvkyZNH6iJPjDHGXi/8ji5jjDHGXjlqtfpgFWaryjyMMcb+hjjQZYwxxtgrRyQSnSai3ApmedysWbPTdZYhxhhjrxUOdBljjDH2yklMTFQYGRlFVzBLdFxcnLLOMsQYY+y1woEuY4wxxl5JRkZGBpsmi0QibrbMGGPMIA50GWOMMfZKys/P/y+AAj2TCmQy2cm6zg9jjLHXBwe6jDHGGHsl/fHHHyVEpK9X5Zg//vijpM4zxBhj7LXBgS5jjDHGXlkGmi9zs2XGGGMV4kCXMcYYY68sIyOjEwCKyyQVGxkZ/fyy8sMYY+z1wIEuY4wxxl5ZiYmJxQCOa74bGRkd+780xhhjzCAOdBljjDH2SiMioamyWq3mZsuMMcYqxYEuY4wxxl5pYrH4qOazqanp0YrmZYwxxhhjjDHGXgsSiSRGIpEcftn5YIwx9nowftkZYIwxxhirgoNGRkb0sjPBGGPs9WD0sjPA2N/Jxx9/fMHIyMj6ZeeDMcYYY4z9PRBR3G+//ebwsvNR1/gdXcbqEAe5jDHGGGOsLhkZGfV/2Xl4GbjpMmMvQWJi4svOAmOMMcYYq+ekUunLzsJLwzW6jDHGGGOMMcbqFQ50GWOMMcYYY4zVKxzoMsYYY4wxxhirVzjQZYwxxhhjjDFWr3CgyxhjjDHGGGOsXuFAlzHGGGOMMcZYvcKBLmOMMcYYY4yxeoUDXcYYY4wxxhhj9QoHuowxxhhjjDHG6hUOdBljjDHGGGOM1Ssc6DLGGGOMMcYYq1c40GWMMcYYY4wxVq9woMsYY4wxxhhjrF7hQJcxxhhjjDHGWL3CgS5jjDHGGGOMsXqFA13GGGOMMcYYY/UKB7qMMcYYY4wxxuoVDnQZY4wxxhhjjNUrHOgyxhhjjP0NPXv27GVnwaBXOW+MsdcDB7qMMcbYcyoqKsKQIUPw+PFjrfR+/foZXCY7OxtDhw5FcXGxkPbgwQNMmTLlheWzps6cOYPNmze/7GywMtRqNQoKCiqcJzs7GxkZGQD+dyympKQgJycHxcXF6N+/P+Ryud5lz549+1z5S09Px5EjR16ZvO3evRu5ublaaSdOnMDGjRurva6KvE7ndU28qGvBt99+K3z+448/8O2330KtVgMAVCoVgoODQUTVXu+BAwcqnK5QKDBu3Dit36syTk5O1c4HACxatAgqlcrg9B9//BFbt27VSpsxYwYUCoXwvfwxzCpm/LIzwBirmhs3bsDT0xNnzpyBqampwekJCQm4c+dOhfPWZDtl1y8Wi597f8rLzs7Ghg0bkJCQgPz8fJiamsLDwwMzZsx4IduaPn06oqKiIBLV3vM+hUKBiIgIHDt2DH/++SfUajXatm2Lb7/9Fu+++26tbefIkSMIDw9HZmYmPD09ERsbW+v78jxeVPnWVK9evdCuXTu90zIyMnD58mWtNKlUihYtWhhcn0wmw6VLl7TSEhIS0KxZM7Rs2bLK+YqJicGHH36odZ7FxcXhgw8+0Du/XC5H79690aRJE630wsJCrbTCwkJcvHgRDRo0gFQqrVJevvjiC8ycOdPg9E6dOmHx4sVwcnJCx44dtaZt3LgRUVFRWmm5ubk6+dTkLTExka8zNXDnzh1cunQJaWlpSElJQUpKCgYPHgxfX1+Dy5w5cwaxsbFCYEJECAwMxKxZs6BUKtGxY0eD5ezn54fTp0/D1dUVarVa7z7IZDKcOnVK7/ImJibYsGEDunfvjm7dur3UvD148AB79uzBmDFjtOZ57733sGrVKlhbW1f5XKlMdc/rqm73nXfewb59+7SWq+51qjbU9rVA48SJE8Kx3KVLF6SnpyMuLg4DBgzAli1b0KBBAxgZGQnzjx8/Hmq1GhkZGYiPj8eoUaPQqFEjPHjwAAkJCXBycsLx48cRGhoKNzc3HDt2DKGhoVp5OH78OBISEmBubq73Xumrr77CvXv3dNJzcnIwYsQInfTo6Gh9RQag9MHU8ePHERAQoHd6RkYGfvjhB2zfvh1Hjx6FlZUV2rRpg2vXroGIcPXqVWzevBlPnz7Fjh07tMqCGcaBLmOsRlJTU+Ht7Y3IyEitmxFD6RVRKpWYOnUqHBwcEBkZiWbNmiEtLQ0PHz58IXk3NzfHTz/9VKvrfPbsGWbOnAkiwty5c9GzZ08olUrcuHEDjRs3rrXtZGVlYdmyZfj3v/+N/v37Q6VSYdasWbW2/urS93u/iPJ9HiYmJgZvQHr37q2TJhKJEBsba3B9VlZWOmnHjh3Te+Ojj1qthqOjI4qKimBiYoIBAwYAAE6dOoXjx48jNTVVqxZiz5496NSpk5C306dPC9NUKhWsra210sreOF+8eFFr24WFhRgwYIBOetmbJisrK703fUSEzz//XCutuLgYly5dgpeXF6RSqXDjKpVKhTxNmzYN4eHhOnmrCr7O/I9SqYRCocBHH32Ew4cP4/Tp0xCLxcIxoO9hh6urK+Li4pCZmQkASEpKQpcuXSCVShESEmIw+Cpv586daN68uU665tgFSn/bZs2a6cwzffp0nbQTJ07Uad527dqFSZMmQSwWY9CgQQBKy1OtVkMsFmPBggXCvEuWLIG9vX2Vtl1WTc/r8udiZmYmRowYUeE5CtTsOlVdL+Na4OTkJDww3L59OxYuXIi3334bAGBjY4MLFy4AKH2w/OOPPwoPL0xMTLBv3z6dhxkaQ4cOxdChQ7X2DSh9cPzrr7/qtL4ZMWIE1q5dK3xXqVQIDw/H3bt38eTJE7Rt2xaffvopRo0apbWcvv365ZdfYGZmBiMjI70PZYqKirBgwQL4+vqiTZs2ICKsWLEC69evBwB4enoKZf7JJ59wkFsNHOgyxmokPz8fqampVU6vSEpKCjIyMjBp0iThCXWXLl3QpUuXWslrXdiwYQNKSkqwY8cO4cZbLBbDxsamVreTk5MDtVqNfv36wcTEBCYmJrW6/uqqye9d1xQKhcGbn7JNwjTUajVcXV2rvP5Hjx7hwoULWLZsmdbNdX5+PoDSm7N//OMfAICWLVsiIiIC+fn5SEhIAFB6A2VnZ4crV67A1NRUSAcABwcHGBvX/L/qBg0aaH3X3GSVTy9LrVbj1KlTSE1NRXFxMXr06AEAKCkpwcaNGzFnzhwh39bW1pXm4bfffqtp9vk6U0aPHj2E3yIgIEAnwNf3sMPNzQ0AMGvWLBQXF2Px4sUAgPPnz+PYsWMQi8UYNmwYioqKoFAo4OPjg127dkEmk6GoqAgDBgxA8+bN8cUXX1R4zGjExsaiQYMGKCkpgaenJ1asWIGuXbvqnVdzjr3ovGVkZCAxMRHz58/Hjh07sH//fjRv3hwBAQFITk7G7t270aBBA6hUqirtoyFEVKPzuibnKFD961RN1MW14Ouvv8aNGzdQVFSEQYMGwdjYGNu3b8dXX32FlStXwsPDA0FBQVi7dq3OqyHPKzs7G2fOnMGZM2eE38POzg4///yzcM0GSo/J9evXQyKRYNWqVRg+fDjWrVuHoKAgHD9+HF5eXvj4448BAImJiULrG02w7+7ujvT0dACAra2tEKgqFApERkbi8OHD+PPPP7Ft2zasXbsWcrkcMpkM//3vfwEA3t7ewr2Ej48PRo8ejT59+tRqWTDG2HOTSCQkkUioJq5fv04SiYSKioqIiCg/P5/mzp1LvXv3JmdnZ9qyZQtJJBIqKSkR5j179iyNHj2abG1tafbs2ZSXlyesT6VS0Y4dO2j48OFkbW1NTk5OlJSUpLOd8tsvKSkhIiLNvpTfJ33pleUnPz+f+vTpQ/7+/jrb1SgpKaGgoCDq378/ffLJJ+Tr60tPnjwRpu/bt48GDRpEtra2FBwcXGF6+X2Uy+X03XffkbOzs1AW4eHhpFKptOb/9ddfycPDg2xsbMjd3Z2SkpKIiEihUJCdnR39v//3/yr8DZ93O/rKt/y+5OXl0ddff022trY0bNgw2rZtm85xUbaMy/6ums/R0dHk4OAglNeFCxfIw8ODrK2tadiwYXT+/Pkq/d61Vb7Py9bWtlrTevXqVeH6yk8PDg6mvn37aqUlJibSlClTqG/fvvT5558L+0pEpFQqtc4ZzfeAgACKj4/XWo+dnR1lZ2cTUek5IJFIyMHBQeuvfJpEIiGlUqk37wUFBZVeg+Lj40mtVlNCQgK5uLjQrFmzKDk5mWQyGVlZWQnzqdVqrfyWvw7oKy9Dx4gGX2cMnwcLFiwgFxcXcnJyIqlUSi4uLuTi4qJzPGnKR3MMPHjwgKZOnUo2Nja0efNmKioqot27d5NEIqFHjx4REVF4eDitWbNGax2aY3rUqFFa/3f8+9//Fj4vXrxYZ5uOjo7Uv39/kkql5OjoqPPn7OwsLFMXefPx8aGjR4/SzZs3yc3NjRQKBV2+fJns7Ozo999/J6LS6+aECRNIoVBQTdX0vC4vIyOjSvcJ1b1O1URdXAs0NL/pkCFDiIjov//9L928eZOcnZ3pyJEjdPPmTWEaEZG7u3uF/2rmLX9tLpuXkJAQ6tWrF92/f5+IiB4/fkz9+vUjotL/1/ft20efffYZubi40NmzZ4Vl169fL3zWXG/c3d3p5s2bRPS/a3V5zs7OlJaWpvU9NTWVcnJy6NatW5SVlSVc+1JTU+nYsWNkb29PmZmZwnpHjhwpHLdVpblOvux74JeBa3QZe035+/ujqKgIhw8fBgDMnz9fZ57Dhw8jPDwcSqUSc+bMQXBwMAIDAwEAa9euxenTp7F8+XL06NEDqampaNy4MXJycqq0/Z07d+p9l85QekX5MTMzQ1BQEJYsWYKzZ89i3LhxGDt2rFaTqRUrViA9PR0RERFo2LAhfH19ERISAn9/f6SnpyM4OBgbN26EpaUl7t+/DwAG08sLDAxEUlIS1qxZAwsLCyQlJWHBggVQKpXw8vIS5ouKisL69eshFouxaNEiLF++HHv37hWedvfs2bPCMnve7egr3xs3bmhtw9/fH0+fPkVMTAyICPPmzaswT/pcuHBBWB4obVa1aNEivP322wgNDcW3334rHHcV/d61ud/PQ6FQGGxWbKhGt6rNkNPT0/HLL7/opEdGRsLJyQmhoaF4//33ce7cuUqbQ/r5+WHNmjVQqVTo378/gNKakrLlKhKJtN6J1NSklE3T1OZV1ExY37Rp06Zh+vTpsLe3x7lz5/Dmm2/i4MGDOHDgAFJTU/HGG2+gYcOGwvxGRkawt7dHZGSk0IHKoEGDtGpI5XK50KFMTfB15n/ngaazno0bN+KHH34QmuMb6txGLpdj69atuHr1Kvz9/fH555+jW7dumDFjBj788EP06tULKSkpaN26NVJSUqpcQxQbGyu8S6nvfcMDBw7Azc0NBw4cQOfOnZGWloYOHTro5G3z5s0vPG9qtRpJSUlISUlBeno6tm7dioKCAixduhSBgYHo1q0biAiNGzdGy5YtsXfvXkycOBEFBQV4+vRplbap0apVK73pVTmva6I616maelnXggkTJgifc3JyhHeTn7cjprKdSKnVaqGZ+NWrV9G5c2fcvn1baCZtbGyMR48eYfLkyQgKCtLqLAsAfv75Z611zZw5U1jWkCdPnmjVFMvlcojFYrRs2RIjRozQOk/S09Nx5swZZGRkYOrUqcL/x1KptNLtMMbYS1FbNbqPHz8miURCt27dEqafP39ep2ZO85SSiOjEiRNkZ2dHRKW1OlZWVnTp0iWD2zH0p3naWL7mpfzyZdP15efnn38W8qNRUFBAGzdupH79+pGTkxPduXOHiIhyc3NJKpUK34lKn6La29sTEVFWVhZJpVKKjo7WWp+h9LJlmZeXR1KplK5evao1T3R0NDk6OmrNn5qaKkw/d+4cSaVSUqlUdPv2bZJIJCSTyXTKU6M2tlN2nvK/Q1FREeXm5pJEIhGeKmuWr26N7u3bt3Xy//TpU0pKSqJNmzaRRCIRaj4q+r1rq3yfV9kn8VWZVp2aktDQUDpw4IBWrcHNmzfJ0dGRioqKqG/fvpScnEyff/45qdVqIvpfTU/5WlgiopSUFBo8eDBlZWUREZGVlZXwexUXF1Pv3r218lJZbV55VanRJSLav38/OTk50b/+9S/hvLt9+7ZWbVx5+mpxHjx4oDedrzOlqnse5Obm0qBBg8ja2poWLlxIxcXFBo8BhUJBsbGxpFKpaNWqVRQbGyvsPxFRREQErVq1ipRKJQ0cOJDS09OJqLQmKykpiWxsbGjixInUu3dvGj58uFCD3KtXL+Gzi4sLXblyRdimSqWiJUuWaNXA6jse1Wp1neYtIiKC1q5dS0SlNb0eHh40YMAAsrOzo/79+5NEIqExY8aQg4MD5eXl0ZIlSyo8PvX91fS8Lu9VqtElevHXAg3NNXTOnDkG16uZpmm15O7ubvBffTW6Zctk+vTppFKp6NSpU/T1118TEdF//vMfCg0N1dnuJ598YjBPRLotg/TV6Obn55Otra3w/wARUf/+/Sk3N5eIdMtDk1cHBwet9OvXr1eYF324Rpcx9srTPAk1NjZGdnY2AGj1eKivV8M2bdpofS4uLhZ6KVSpVOjevbvB7RnqDfV5lM1P69athfxo3klq2rQpZsyYgXHjxmHBggVYuHAhDhw4gKysLBARPDw8dNapUChgbm6O5cuXY926ddi9ezd8fX3x8ccfG0wvKzMzE0QECwsLrfSOHTsiNzdX6wl02R51mzZtCiKCUqlE27ZtYWRkhD/++MNgLVptbKeyGoCsrCwAEDou0ixfXe3bt9f6HhoaisOHD+ODDz4QnuJX9cl8Xey3Pnfv3sWXX36pd9qjR4+0jkWN48ePA6heTYmHhwdatmwpdBoil8sRGBgIT09P4fx599130bx5c0RERGgdw5pa2LLvt1lYWMDd3R2rVq1CcHAwVCqV8B52SUkJ5HK50JlOWfrSnoebmxtcXFwQFRUllH9KSgreeuutaq3n+vXrAEqHyNi0aZPOdL7OVO88CAkJgbOzMyIiImBpaQkfHx/h2CvPyMgIYWFh2LBhA9LS0pCQkICwsDAApZ38ODg4wMPDAx06dMBbb72Fdu3aQalUwtXVFd27d4exsTFWrFiBadOm4dChQ8I7owMGDNDp3O3p06cQiUQQiUQ4cuQImjRpgpiYGGF62eNz4cKFcHR0rLO8nTt3DhEREViwYAFiYmKwYMECmJqawtbWFufPn4dIJIKVlRUiIyNx48YNmJmZYdmyZVi2bJnecjVEU7Ne3fO6puqiRheou2uBxtq1a/WegwCETsdCQkIwZswYoTMqff9WNgSQJg+2trZYsWIFMjIy8PPPPyMkJERn3mfPntW4rBUKBYyNjXHhwgX06NFDqyOpZ8+eoVGjRsL3sjXZmmvCkydPAAC///47NmzYgMuXLyMyMlKnlQTTjwNdxl4Tf/31F5o1awaxWCwEtY8ePRI+a4LfsgoLC4WbyD///BPm5uYQiUR44403AJT2XKrpXKIulM9PmzZt9PZAaGZmhsmTJ8PLywtqtVroOObo0aN488039a7byckJjo6OWL9+PebNmyf0RmkoXaN169ZCfiwtLYX09PR0obwqY2ZmBhsbG3z//fcGA93a2E5lKjsuNDcpz549E36HwsJCnfWU/Y84PT0dO3fuxP79+2FhYYGEhAStJluVqYv91qdbt25C4PrTTz+hRYsW6Nu3r3DzqZmmj0gkqnCYiLK9mZYfTmjlypXCkDVl+fj4YNKkSWjXrh0++eSTCvM+ceJE/PXXX5DL5RCJRMINcUFBAbp37449e/YI82r2p+xx/TzDpNy5cwfTpk3TStOMM6ppeli+d9KynSBpWFpaQq1WY//+/ejSpQuuXbsGABg5cmSN81ZV9fU6ExMTg99++w379+8XHppYWFhU2APrzp07MW7cOERFRaFTp05ITk6Gv78/zMzMIBKJYGdnh+DgYKF3WWNjY+G1hH79+qF9+/aQy+Vo0KCB0KHbkydPhM/t2rXD2rVrIZPJhB6Xyw4ZA5Qej5pOql5G3uLj49GhQwfEx8ejbdu2EIvFyMrKQvPmzXXKvbLXT56HofO6pqpznaqJl3EtKCkpwZMnT5CTk6O3R+myD0zKN9mnao6xm5GRgbZt26Jx48YYOXIkpk2bhvbt2+O9997TmbdRo0YVlnXZ3vsLCgqEoH7mzJlITk5GVFQU9u7dC2dnZ638y+VyrSbgu3fvFj6X/f1mz56NmzdvwtXVFUuXLq1wWCmmjQNdxl5xjx8/RsOGDXHgwAHhIt+hQwdYWFggNDQUy5Ytw5MnT/DDDz/oLLthwwbMnz8fOTk52L59O1xcXACUDnvRt29fBAYGYunSpejatSv++OMPvbXChpiZmQEArl69infffVf4bihdX36GDx8OoLT2LS4uDp9++inatWsHmUyGQ4cOwdraGiKRCObm5pBIJFi9ejW++eYbtGrVCikpKZDJZLC2tkZmZiays7NhaWmJDh06QC6Xg4iQlZWlN72sVq1aYeDAgQgMDERAQAAsLCyQnJyMTZs2YeLEiVUuj/nz52Py5MmYN28epk2bhi5duqCoqAiJiYno2LEjunbtWivbqUiHDh3QtWtXg8dF586dYWpqiiNHjmDixIkoKSnBrl27KlynUqkEUFoj1apVK61xHIGKf2+g9so3JiYGYWFhmD59erWCpdzcXISGhuq8S1j+6fyYMWOwbds2AKW1aGV7Ty5PM33UqFGYPXu2kK552r5161Z8+umnACD0JNq3b1/4+/vDz88PkZGRFeZZLBajXbt2yM3N1boJysjIMDgecG3p3r27zs0qEWHLli3YvHkzfHx88Nlnn2kFLWq1GsnJyQBKA/qHDx8iLCwM69atQ3JyMtatWwcfHx8AwOLFi+Hn5yf0BlwZvs78z/Xr1xEYGKhVA25jY2PwHV2gNOi3tLSEv78/Ro4cie+//x7+/v4QiURQq9XCgy65XK53+aysLCFIz8nJ0XoXXCaTYcqUKQCAe/fuoUOHDnB3d4dMJtNZz5AhQ7S+x8bG1lnefH19UVxcjLt37+LOnTv466+/EBsbq3f4ovj4eBQUFGDYsGF6t/k8DJ3X1aW5NlX3OlXda2hdXQu+/PJLJCYmori4GEOGDMGcOXOQn5+vVbupT9n+FUgcvkgAACAASURBVNRqtfB/lcakSZP0LldQUIAdO3bgyJEjiIiIQMuWLdG2bVtkZWXB0dFR7zLPnj2r0jFRVFQEZ2dn9OjRQxhmqUePHti7dy8eP34s3IMBpa0gGjZsqPWwRV+NLgAMHjwYq1evRsOGDfHDDz/AxsamwhZ57H840GXsFbdq1SrEx8fD3t5eqynmypUrsXTpUgwaNAjdunWDm5sbbt26pbVsz549MWLECMjlcjg7O+Of//ynMC0wMBDr1q3DzJkzUVRUhM6dOwsdVVVFp06d4OrqCm9vbzRp0kR4+mooHQA++OADjBw5EiUlJXBycsLUqVMBlN60JiYmYu/evSgsLETLli1hb2+v1cFWUFAQVq5cCTc3NygUClhYWMDb2xtA6ZPRgIAAIRBYsWIFjIyMDKaXFxAQgA0bNmDWrFmQyWRo3749PD09q3wzDpQ2QdyzZw/Cw8Pxr3/9C48fP0bjxo3xzjvvCMNm1MZ2KhMUFAR/f38MHjwY3bp1g6urK27dugVjY2OIRCIEBgZi9erVOHDgAFq3bg0HBwdhXEJ9OnfujLFjx+Kbb75BmzZtMHbsWJw7d06YXtHvrVEb+x0WFoZNmzZh5syZVQ50CwoK4OPjAysrK2FoCjs7OwDQ+3R+/PjxAEpvMH799VccPXoU8+bNQ7NmzZCRkYFdu3Zh4MCBkEqlemvgRo4cCXd3d7Rp00Yoh379+mmVyU8//SQ0v9PkxZC7d+9qPbm/evVqjVtgaJru5ubmVnm4IrVajYSEBGzbtg3FxcUIDg5GTEwM9uzZg/Hjx8PV1RWNGjXC7t27cevWLfj6+sLKygrNmzfHypUrERcXh6VLl6JPnz4gIigUCuTl5eH06dMYO3ZslfLA15n/8fX1rbDmV1/Q89ZbbyEgIADr1q1DSEgIGjVqhDt37sDS0hLLly+HTCZDSEgIFi1ahIKCAp3haq5du2ZweKCy4uPj0bNnT3z99dc606RSKU6cOKFTo1sXeVOr1Rg/fjyMjY2F4ZmuXr2KrVu3CrWTAITf8cGDB881nBdQ/fO6ujQBfXWvUzW5hmq8yGuB5lxZuXIlevfuDVNTU2zYsEGrdlND87D//v37QmsalUqF33//Hebm5lrzlr/GPHz4EEQEV1dXDB06FAcOHIBKpcLSpUtx/vx5hISE4LvvvkN6ejq++uorrVd43N3d9Xb4qbFq1SoAwD/+8Q/ExcUJx7parcbmzZuxb98+hIeHC8G5WCxGYmKi8KBGQ7PPRCQ0ezc2NsbgwYOFhyMnT57Eu+++azAvTBuPOMxYHdJ0BlC+aVd9p3nvrvz7eOzFi4mJwcaNG3Hs2LGXnZXn4uTkhE2bNsHLy6tK+3Lr1i3MmzcPdnZ2mD9/PtLS0rB161YkJibi8ePH+Mc//gGRSAQiEmoDVq9ejYsXL+LEiRNo2bIlxowZg8GDB0MsFkMmk+H48eM4evQoHj16BCcnJ4wbN064uerXr5/eZnv60jXNjf8/e/cdFcX19gH8uysgIFgRNNYQY4pGE7ARRcQWMSSxYokRrIgNEnsLKgKCJSoKqNgbNooUC2pQQaIGokHEggYVBFSqlGXbff/g3fntsgUQFMXnc47H3dkpd2buDPPMbbL7gPz3uLg4uLq6wsDAAJmZmZg2bRomTZoEsViMYcOGYevWrWjfvr3Suv7++29IJBLk5uZi6NChuHbtmsJD7qBBgyAQCFBaWgoLCwts3rxZ5XHLyclBdHQ0bt26hatXr6JJkyYYN24cfvzxR+7h7eHDh9i1axf+/vtv/PLLL/jll1+45R8/fgx7e3t07NgRixYt4gKRRYsWIT4+HlKpFD/88AN+/fXXCs9hVX1I9xkLCwuF8Vrl8xNQFlxevHgRGzduRHx8PKysrDBlyhTk5uYiNjYWMTEx0NPTg6enJ/T19fHXX39h0aJF+PXXX9GnTx+IRCJMnDgRnTp1gpWVFYYPH47u3bsr9KIrkUjAGIO/vz9GjhwJX19flVV/zc3Ncf36dYVAt7CwEOvWrXvjaQsKCoJYLOaCV1dXV1y/fh0rV65UGOPcxcUFt2/fBo/Hw/bt25XaUlfG61zXVW1msGPHDhgYGODcuXNVvk9V9R5am/eCHj16qHyJIavSvGHDBujp6eHSpUuoX78+TE1N0bx5c9jb2+Pnn39GaGgoTp48iU8//RROTk6IjY3FX3/9hT179mD58uVo06YN/Pz8cPjwYVhaWmL+/Plo2rQpSkpK4OPjg6CgIPz666/Yvn17lc7PokWLuNo8sp6YMzIy4O3tjc8++wyBgYFYt24deDwetLW1sXjxYq52kbm5OeLj4+Hq6opbt24hIyODG5/9ypUr0NbWhkQigYmJCXbu3KnQtrcisnyWkJBAcR8h5M2pTq/L7zN1Y2aSmnfhwgWWlpbGxGIxS0xMZLa2tszf37+2k1VtwcHBzMbGhp08ebJS8xcVFbErV66o/V0qlTKJRMJEIhETiURMLBazI0eOsA0bNij0uqvK/fv3maenp8I4mEFBQSrnPX78uMrp5XvOlPW0KxQK2aNHj1hycjI3diJjjN26dYs5OjoqrUcikbDevXszsVjMevbsyczNzZmzs7PSfNnZ2ezZs2fc2KTqvHr1is2fP5/t3buXpaSkaJz34cOHbOfOnUrT5Xs9fps+pPuMfC+vEomErV69WuH31atXM4lEwi5dusRKSkqUlo+Pj1fo/ZUxxo3hOW7cOGZlZcV8fX3Zli1buN7ky/f+mpuby4YPH84yMzPZwoUL1aZVXS/gbyNt5T19+lSpB++aVNXr+nW87n2qqvfQ2rwXqOr5WH76zp07uR6sGWPsjz/+YHfv3mWjR49mrq6ujDHGpk6dykaOHMk2bNigcl1Xr15VGLlCXmpqao3cRzIyMhTym1QqZcXFxaygoEDpmpA9G3p6erLvv/+eeXt7V3v78uv+UHtdpsiekLeISnTrfklLbduzZw+OHj2K3NxcGBkZwdbWFtOnT1eqNkjeP4WFhRrb0bP/7523up3cvK8+pPuMfC/SbxJjTGNnV1WdrybVxjYJeR99yCW6H9wOE1KbPtRAlxBCCCGEvH0fcqD75l8HEkIIqRRNvacCZSUYd+7ceUupIYSQdwNjDM+ePavtZBCU9YKdnp4OoKznYELeZRToEvIey8rKwtChQ1FcXMxNS01N5YZVqClFRUUYMmQIsrOzFaaXH0NPJicnp8pj2gHAtWvXFHr0fVecP3+e6+r/1KlTiImJUfhdJBIpdVohG5akKqZMmYL79++r/V0kEil09qFJcXExsrOzuX85OTlVSosqbyK/SaVSHDlyRGloCHlisRgBAQGQSCRISUmpcJ03b95EQkJCldKxadMmpV7L66LqnkNZr6sVkUqlmDRpEjIyMhSm+/r6IigoSGn+69evK3xX1bGXKj4+Pli/fr3CNKFQyHXIReoGkUjEDRMl7/z585g8eTJKS0trIVVvzrt8D3v8+DGcnZ25IYDOnz//xrf5LpP/21VaWqpxjPbyHj9+jBMnTryJZJH/R8MLEfIeCwsLQ9euXRXao0VHR6scH1DG3Nxc49AGeXl5uHHjhsK0uLg4NGrUiOvOvyLu7u744osvMHXqVNjY2MDQ0BBA2U29Xbt23P+pqakKD7j79u3jhpB49uwZRo8erdCTJgCkpKTgr7/+qlQ6yvPx8cHhw4ertExcXBwWLVrEtftr3Lgx1qxZgxMnTnDtJUUiEXbs2AFHR0duuT///BOxsbHYvn07AgICEB0drbTux48fg8fjcfvTp08feHh4YM+ePZVqe7Zq1SrcunULz549w0cffcT9DwAjRozAmTNnuHnT0tK4NAwdOpQbOiEpKYkbsub27dvo3Lkzt0xWVpbCMDxVzW+yoSDK09PTw6lTp8AYg7u7O/Ly8jBmzBiN++rn54cxY8bA3d0drVu3xvLly9WORfno0SNs27YNwcHBSuP6ykilUjg5OWHDhg0wMDCAsbExNmzYgN27dwMoy2fe3t7YsWOHwvHYunUr4uLikJ+fD319fYwbNw4zZszQmPbXkZWVBUdHRwQFBdVoW8zXuWfIPHjwAKGhoZUKivl8PqysrBAREaEwrFlCQoLCd5kFCxYoBLe///47993c3BwtW7YEUDZ26t9//w2g7GXS4cOH0aJFC645yEcffYTWrVvjxYsX2LRpE7e+5s2bY8uWLRWmWx2RSITAwEBERkbi8ePHkEqlaNmyJTw9PWt0qI/w8HDs2LEDGRkZcHBwQFRUVI3ngep4U/nydcTGxmLFihUwNDSEg4ODwm8uLi4KvSo/f/4c33//fZXWf+PGDYwbN05p+qNHj5R6ZV6xYgW+/PJLrFq1SiFAlb8ny3+WUTXMmWwbNX0Pq+jcydq4x8XFQUdHR91hgZ6eHkQiERo1agRfX1/4+vrC2tr6ve8HwtzcXGMfCDKFhYXc/UYoFGL8+PH47bff8O233yI3NxcrV66EjY1NpbYZHByM9PT0Gh1ikCiiQJeQ95BUKsXAgQNRVFQEbW1tbvzEixcv4vTp03jy5InCW8JDhw6hXbt2AMoeQFWNdSrTvXt3pWmRkZFcF/iVsXDhQowdO5YbB+7YsWMAAFtbWxw7doz7X/bHYOXKlbhz5w7+++8/ZGZmYseOHfj999/x8ccfK42lV5lB29WZM2cO5syZo3GeV69eoV+/fmrbUfft2xeHDx/G1q1bsXjxYrXrmTp1Kh49eoTjx49j5syZmDlzJg4ePIisrCyYmJjg5s2b+PHHHxX255dffkFQUBAiIyMr9VDm6uoKALCzs8OxY8e4/2XkB58vP8am/FtodZ9lXje/RUVFoXv37tyLE/nPpaWlWLlyJSQSCdauXavxoVk2BjAAbN++Hd7e3nj+/DnatGkDc3Nz6OnpqVxu6NChCt9LSkq488rn81FaWorr16+jf//+GDVqFPbu3YvY2Fj07t0bd+7cUXjoEYvFmDZtGqytrXH06FE0atQIT58+fWPVKU1MTBASElJj63udc1hQUIDZs2dz04qLi6Grq4t+/fqp3c6yZcu4gFLWWZBsPw4fPozk5GR07dpVYRk/Pz8UFxcr3GNk30NDQ6Gjo4Pw8HAA/xujNCsrC/PmzcPmzZvxzz//oHv37jAzM0N8fDxWrVqFs2fPYtu2bZgxY4bSWJVVJRAIMHPmTDDGMH/+fHz11VcQi8VITExUm/deR2ZmJlatWgUPDw/069cPEokEs2bNqrH1V9WTJ0/g7OyMo0ePcoHPm8iXvXv3VpgmFAo19mPBGMOhQ4cQGhqKwMBA7m8bANy/fx8eHh5KwxwZGxsrvcAFyl6wZGdnc8GhvIkTJ1Z6P9zc3HDkyBHunixjZWXFBbPyn+W9rXtYVc5dXFyc2r9vjDGUlJQo1OiKjo6udC2Md9nFixcVAnYvLy+F8XNlQ0bJ6OjoYPXq1Zg7dy48PT1hbGys9gUsUPYyQf6eKutgUF3tOKDytVuIahToEvIeYowhPz9fYRzFPn36ICEhAfr6+tx0ALC2tubGEATKHixkpaaV8fz5c24sN/lgKT8/HwDQs2dPNGjQAADQrFkzHD9+HCYmJti6dSs+/fTTSm1j5cqVOHDgANLT0zF37lzo6+vj2bNn+O+//xSCNaBsHL3aNmfOHPj4+HDjM4pEIpU93bq5uXF/NO3s7ACUHbeXL1+iVatWePLkCU6dOsUFp/Xr18fq1avRpk0brFmzBhcvXlS5ffkgxc7ODk+fPlX4v0WLFhpLr5o1a6b0YHf37l2lkilZKUl18psqL168wOzZs2FpaYmZM2dyQawsiCmPMQbGmMJb8jNnznAlqeWrkqtS/gEFAPr164fz58+jf//+0NHRwcKFC2FkZAQA+OuvvxTGuHz48CHS09Nhb2/P1Yj4+OOPlWocvKte5xx+9dVX3ENWQkIC1q1bh3379mks7QGAwYMHq5weGBgIPp+PsWPHAvhfCZcsYJEPAtQFBTKpqamYMGECevToARMTExw7dgxmZmZYsGABwsPDoa+vDysrK9y4cUMpWKiqrVu3orS0FHv27OH2XUdHR6HEsCa8fPkSUqkUVlZW0NbWrvXes/Pz8/HkyZM3ug0+nw9/f3989tln0NXVRVZWFuzt7TF16lTcvXtXaf7evXvj888/x61bt/DRRx9hwYIF3G8lJSUQCATQ0dGBg4MDBAIBTp06pXbbV69excWLF1UGuUBZDQb560LGxsYGR44cUZhmYWHBfbaysuLG1y4uLubu/fKfgbL8L7t3vY17WFVYWFioDbBkL6E0vTCvK8LCwhQCXVW+/PJL+Pv7o23btkhKSkLjxo3Vzit/T42NjUVwcDDX9EIqleLGjRs1fl/50FGgS8h7TPbQJevEKCIiQqlaYfnhRvh8vso2cjLlS3T3798PLS0tGBoacoFXQkICtm3bhpSUFLRr1w579+5VKpGTVYcF/hfk1a9fH3Z2dtDX14ednR3X5pcxhqCgIGzcuBEODg44duwYZs2aBYFAoNRBk0gkwrZt26pV0tG/f3+Ft66lpaVqg0pVOnXqBH9/f+57cXGxyjfy8m+GX716xbXdGTRoEPcAVr56b7du3QAAy5cvx9KlSxWOq1AohIWFhUJaS0tL0aZNG4USXU2l7/b29uDz+bC3t1eYrirQLe918psqDRo0wG+//YaePXuCMQYvLy/88ssvah/2srOzMXr0aJXnSFdXV+O2ZPh8PhYuXKgwzcbGBgEBAcjNzUWTJk0wcOBAAGVt0mNjY/Hbb79x87Zs2RK6urrYsmULFi5cqHL4GqFQiE2bNuH06dMQiUTo27cvli5dypWqBAYGYvfu3Xj16hVGjhyJ+fPnq51efqgckUiEnTt3IjIyEi9evECzZs0wfPhwTJkyBXw+n5vf19cXmzdvxqNHj9C2bVusWrUKX3zxBZfG1zmHz549w6JFiyAUCtXmrYiICC6vFhUVwdnZGX/88Qf+/PNPFBYWYtSoUTh8+DC6deuGP/74AwBgaWmJ48ePc+uQT4dIJFL4LHs5JxAIAJS9YDt9+rRCDQY7Ozvk5+crVWPdu3evwnxVIRaLERoaCjc3N40Bfk2cH9k1KQua9u7dq5AH8vLy4ObmhqtXr8LIyAjDhw/Htm3bEBcXh3v37ikNrSRfFVX2u6urKzZt2oShQ4di/vz5uH79OjZt2oSHDx/C2NgYS5cu5bYvO46y7/Hx8W8kX166dAlhYWFYvnw5kpOT0alTJ2zYsEHh+MrufbGxsbh27Rrc3NwUgtj09HRMnjwZZ8+e5fKhpto/+fn5cHd3x3fffadUw0CmXbt2EIvFXKDToEEDrF69GkBZSd/z588BABs2bFAoVQb+V4vJyspK5Wfgfy/2lixZojad8qp7Dyt/7goKCuDm5obY2Fg0bdoUw4YNq1Q69PT0IBQKlaZX5lyry2+yZVeuXAkfHx/weDy4ubnhwYMHCAgIgJaWFlasWIG+ffsCqPhe+7ru3r3L3ZeBsvuN/AvWAwcOcJ9zcnLw3XffKa2DMab0HCWVSnHy5Em0b98eQNl9Zc+ePfDw8FDY1syZM2lUjhpGgS4hdciyZcuwceNGSCQSrnqhRCJReECTSqWVroaclpaGc+fOKU0/evQobGxs4OPjgy+//BKxsbGwtLQEUNZZzf79+yEUChEXF4f169ejU6dOOHr0KBISEuDl5cWtR9ZxxpUrV9CiRQuF0rHg4GAMGjRI6c25ra1ttavz5efnK/wxed233jLPnj2DsbEx9738MaiMw4cPY8+ePSgsLERcXBykUikmTpyIuXPnKr3FL09Wglq+A7ABAwZw517Wmda+fftUrmPQoEFqf1OnMvlNFX19fe6t9YYNG5CWlqaxeqmhoSEKCwtVjpu5adMmhbaYMiUlJSpfPnz//ffcw5CJiQl69+6NgwcPKlRpP378OLp168aVjABAw4YN4eXlhd9//x0xMTEYP348xo4dqxDwrlmzBmlpaQgMDET9+vWxZMkSbNiwAa6urkhLS8O6devg5+eHzp0747///gMAtdPLc3d3x507d7Bx40aYmprizp07WLx4McRiMZycnLj5goKCsGXLFujo6GD58uVwc3PT2C69onP49OlTzJkzBzk5OWofwMzNzRXy3tq1a9G5c2cYGhrC2toakydPxtOnT9G8eXM8ffoUQNlDoqGhoUJe2bp1K/dZ/uFSW1ubezknX+q/cuVKpbR07979tYNaVZ48eYLi4mKlqrDl1cT5kQW2sjaSiYmJCttwdXVFSUkJwsLCwBhTCnoq49q1a9zyQFlAtHz5cnTo0AE+Pj7w9PTkAsjy6XlT++3k5ISJEyciOjoaly9fRu/evXHt2jXs3bsXPj4+SjVEZPcO+dLRvLw8CIVCrrYAUFZzRBWpVIply5ahfv36OHv2LObNm4crV65gwIABXH8SQNkLKE2d5MkLDAxU+K6qFLd8ia7M27qHlefq6oqioiLufKsquezevTtXOp2VlYUbN26Ax+NBR0eHq8k0f/58LF26lFtG07nWlN+AsnbFISEh8PLywrJly2BtbY2IiAj88ccf2LhxIxfoarrXVsfnn3/OvZDOysrCtGnTFNIn/+K9adOmStXhvb29wefzFYJloKwmgvw1tHPnTtjb2ys8N5A3gwJdQt5j5dtd8vl8jBgxAk5OTvjiiy9gYmICsViscIPl8/kaqwTKv4kMCQmBo6OjQjXYpKQkJCQkwNXVFT4+Phg2bBg8PDzQp08f8Hg8TJkyBVOmTOFKATp16oSIiAj4+fmhUaNGXJCdl5eHFi1a4OjRo7hy5QpSUlIUqt8eO3YMBQUFmD59eo0cqzfpzp076NChA/e9/DEAykol5asvy38GgPHjx2P8+PHcMnw+H0uWLIGLiwu2bNmiUConTywWc8FWs2bNFB6kGGPcH+3ybZ179eqFL7/8kvvepk0bhRK1jIwMpd4jq5Lfli1bhuvXr0MqlXKl1vKfz549Cy8vL+Tk5GDDhg1cCaIskJF/yNPT00ODBg2Qk5Oj1CFaTEwMiouLkZ+fz3VYVFxcDEtLy0pVB5w+fTocHBwwfPhwrhOjffv2ISAgQGnePn36IDQ0FIcOHcL+/ftx4sQJbNq0CR07dkRubi4iIyNx+PBh7sFwwoQJWLJkCVxdXaGtrQ0ej4fMzEz06NGDq/Ggbrq8vLw8hIeHY9euXejYsSMAoEuXLpgxYwZ8fHwUAorZs2dzD7djx47F3LlzuZccVT2H//zzD+bNm4c5c+ZgzZo1lWofHxERgfT0dKxYsYLbv6lTp6KoqAguLi748ccfUVBQgMTERIX8B0ChJFZWoiuVSlVWhT9y5IhCabCMpqYZmmqyqCNLh6bq+DVxfirq2Ck3NxcxMTHYv38/t/y0adMq7HOgvIkTJ3JNTYCyauoCgQAPHz6EgYEB0tPTuSYZFamp/dbW1oabmxtmz54NsVgMFxcXNGjQANu2bYOPjw9+/fVXpW27uLhg4MCBuHXrFjZv3oyXL1/iwIEDaNOmDQCgoKAAERERSsvJOsBLSkrC3r17MWLECJSUlODy5cvYtm0bZs+ejR9//JF7oaalpaVUulxRr7qfffYZduzYgeLiYixevBhr1qxR2aGUrFO2t3kPk8nJycHly5dx4MAB7rxMnTpVof0oADRu3JhrHy9f+8jExAQvX75ETk4OHj9+jKZNm3JDDmk61+rym8yYMWOgr6+PoUOHIjw8HA4ODtDX18d3332HoKAgSCQSFBQUaLzX1pS4uDi8ePECFy9eVLpvqsIYw5UrV7Bo0SJER0fDwsKCqzkmFAq557Br165h9+7duHHjBvfiVJ78tqpS04yoRoEuIe8x2U1Qvu2OqakpRo8eDW9vb6xbtw4SiUShGmJVSnTHjRuHZs2acYGuUCiEu7s798cHKHsD2rhxYwQGBir1UCkWi+Hn54eYmBj8/vvv6NatGxo2bIhnz57BwcGB+0O/bNkyLFu2DAAUOlRq2LChQq+3QPU6o6oJjDE8fPhQIbA9f/48hg8frnG5Zs2acfs1aNAghc/qdOrUCUuXLsWtW7fUBrqFhYVccCirTq3q/JZv6wxofnhXpSr5zd3dHSUlJRgwYADXlqt79+6IiopCYWEhZs+ejS5dumDx4sXg8Xhcaa3sj765uTnOnTvH5bMJEybgyZMnKnv+jomJwaZNmxAZGVml/QGATz75BHZ2dli6dCn8/f2xfPly/PTTT/jkk09Uzm9oaIgZM2Zg/PjxWLx4MZYuXYoTJ04gMzMTjDGVvbSKRCKYmJjAzc0NmzdvxsGDB7FkyRJ88803aqfLy8jIAGNMqafXtm3bIicnRyGQlT8+hoaGYIxBLBZz1eircg75fD4mTJiA4cOHY82aNdwDb3nyNSIsLS3Rvn172NvbY9OmTbh06RJiY2OxefNmAGVV8y9duoT4+HilmgryJbGyzllKS0shEAiUqi6PGzdO5bGWJ+vdvTpatmwJHo+HlJQUtTU/auL8VFQLIjMzEwAU9ke+9LGyZL2ty/j4+ODUqVPo0qUL91Aun15NanK/O3ToAHNzc/z3339cUOjq6ooJEybA1taW22+hUIjY2FgkJibCz88PLVu2hKOjIw4ePIgZM2bAz88PFy5cwMmTJ5XuyVKpFGvXrkVUVBT8/Py4derp6WHjxo2Ijo6Gl5cXQkNDsXz5cu5vkryXL19CKBQq9Z4MACNHjuSqtv70008QCATIy8vTOCTc1q1bMXv27Ld6DwPKSiuBsnMlU5Vqv+3atUNaWhpCQkKUOu3SdK4rym+y9q2y+74sYJbNK5FIKrzX1kTb9oKCAuzcuRPLli3Dpk2b8Pz5c4XaAqrExMSgtLQUvXr1wq5du7B79274+PhAX18fUqkUurq6uH//Pvz8/Lh9llWFB/73coOC25pFgS4hddDEiRPx4sULCIVC7o25FlCwbAAAIABJREFUTFVKdMsHFWvXruWGVJE3b9482Nvbo1WrVlzVIqDsoVogEGDfvn24cOECHB0d8dNPPyEwMBC//fabUpDHGINIJEJ8fDzat2/PjdP3JmgKMNX577//4OnpiebNm8Pd3R1AWbXr27dvY9KkSRqXrahEVx3ZG3CpVIqsrCylkp/GjRtj/PjxFaZdVbXfmqIuv2VnZ6vsmKN+/fqYPn06vv76awDAli1b0KBBA0yZMkXtNj777DPcvn1bKQgEymoZmJmZKU0v35Oli4uLyhcSTk5OSExMxLBhw9ChQ4dKlZI1bNgQkyZNgpOTE6RSKddBVUREBFq0aKFyGRsbGwwcOJBr5yt7AaBuuoysWvfjx48Vhn9KS0uDiYlJjQzzouocdu3aVW37RXUaNmyITp064eeff4ajoyNKS0sVqmXa2Nhg06ZNePHiBebOnVvh+goKCtChQweuCYN81eWKOtWTD3QtLS1VlgxWZn969uyJffv2qQ1038b5kQUhz58/5z7LghXgf22vBQIBFyQUFhYqrUf+HpCWloa9e/fi+PHjMDU1RVxcHM6ePVvpNNXkfqekpOD69ev46KOPEBkZiaFDh+KTTz5BaGgojI2NuTahWlpaiI6ORseOHbFu3Tr8/fff8PDwwPDhw2FkZAQHBwc0adIEAQEBCtdhQUEBFi9ejEePHiEgIIArgZbXr18/mJubY/369bC3t0d4eDhcXFy4lytA2YsXVS8lZPlTNkzMv//+Cy8vL0RGRnIvmRISEuDk5IRVq1ZhyJAhCsu/7XtYRflJJi8vj2tGID8u/Oeff46QkBA8ePAAbm5uGrclU938JlOZe211ZGRkYP78+bC0tIStrS3MzMwwbdo0FBQUqP0bJWszbG9vDy0tLTg6OkJHRwcBAQHcs4Genh6ePXuGWbNmvZEh6YhqFOgSUgfp6OigVatWyMnJ4d6EyqrDGBoaaqyGI/t9+PDhCn8st27dir///hsBAQFcBwxFRUUYNGgQ+vbtC1dXVyxbtgwnTpxAo0aNAJT1vjp48GAIhUIYGxvj448/5kp35EsmFi1ahKSkJOTk5IAxhj179mDFihVo1KiRQpVbsVis0GFGWFgYfH194ejoWOmONICKh1iSJ3vz6ufnh+DgYPz888/cH7uHDx9i5cqVGDNmDFatWoWmTZuqHY+0fInuwYMHwRhTGEbo6dOnkEqlCtWcgLKOqf78808AUHpAkvVSWpHz58/jv//+46qCN2nSRKm0XF5lxwEEVOc3ALh586bKUgVtbW18/fXXYIxh06ZNuHnzJvz8/DRuo1u3bggODuZKR65evYoGDRqgU6dOiIqKQrNmzVBcXKzQZraywzJkZWVBIpFAIBAgJycH9+/fVypBf/DgAaKjo/Hdd9+hVatWyMvLQ3BwMHr06AE+nw8TExOYmZlh/fr1WLBgAYyMjPDw4UPk5eWhR48eyMjIQFZWFjp37ow2bdpAKBSCMYbMzEyV0+UZGRlhwIABcHd3x+rVq2Fqaork5GT4+/tXaQgUTdSdQ3lVGWLM1tYWISEhSE1NVXjZ8e2332LVqlX49ttvuQfWZcuWoXHjxgrrb9y4MUaMGIGlS5dy1VHLk1VFPnToEL755hulqtDdu3dXqq78OveMRYsWYdKkSVi4cCGmT5+Ojz/+GEVFRYiPj0fbtm3xySefvPHz06ZNG3zyySfw8fHBqlWr8OrVK+zfv5/7vX379tDX10d4eDgmTpyI0tJShY5zVJFVGc3IyICRkZFSfwiyktWbN2/i888/V6p+W1P5Mj8/HwsXLoSzszO++eYbzJw5E3379uXGhpXH4/FgZWWFS5cuYffu3bCysoK3tzeCgoKQkpICIyMjzJkzB4GBgXBxceGWe/HiBbS1tXHo0CGN48EbGhpi1apVmD59Oho1aoQHDx5wtUxsbGxw+fJlAGX3cNnfEFW9xWdkZKBevXpwdHREv379YGBggK1bt2LFihVK93CxWPxW7mHy2rRpA1NTU7X5SaZ///5cvxrBwcHc9K5du2Lz5s3YuXMn+Hw+zpw5w13P6lSU3yqronst8PrPBnFxcVi6dCmGDx8OZ2dnAGVjc/v6+sLJyUnlsxNjDG5ubtDT01Mo9Z00aRIYY3jy5Al0dXVRr149jUOzkTeDAl1C3mPqhmORefDgAffHR1YdRiqV4q+//kJERAQWLlyIRo0aIT09HQcOHMCAAQNgbm6u8k38sGHDMHr0aBgbG3N/4K2srBQCxpCQEDDGMHXqVLRv3x7r1q2DgYEBLly4AAsLC0yaNEnlkEMuLi7Q09NDw4YNMXbsWDg6OmLx4sXIz8/HsGHDuGCzXr16ePHiBVasWAE3Nzf4+vrC398fM2fOrNIfs/IdSMgHlo8ePVIIMmUBZlJSEvbt28cFbuHh4Vi3bh0mT54Me3t7fPnll3B2dsbOnTvx0UcfYfPmzZBIJAgPD8fAgQMVOgUZOHAg1q1bh+joaAwYMABAWa+hM2bMgKWlJZydnTFv3jyuevTatWshEomgpaWlVC3LxMRE6YFBFjBIpVLuwenu3bsK+5Wbm1vl9s9VyW+MMRw7dkzt0C45OTncOLp+fn7Q19fHq1ev8OzZM66t19q1a5GRkYHU1FQcPHgQHh4euH37Njp37owzZ87A1NQUN2/exBdffAFTU1OMHTsWDg4Oal82iEQi1KtXj8vfT58+RWBgIMLDwzFu3Dj4+flhz549mDp1Knr27ImRI0eiV69eqFevHho2bIj4+HgcPnwYhYWFaNasGSwtLRU6cPHy8sLatWsxatQoiEQimJqacg9LEokEq1evRnp6Olq1aoU1a9aAx+OpnV7e6tWrsXXrVsyaNQt5eXlo3bo1HBwcuBKkyqrKOSxPXU0QVSWd27Ztg1gsxk8//YQZM2Zg165daNq0KXx9faGrq4uYmBjEx8fD3Nwc7u7uiI2Nxb179zBp0iQsW7YMY8aMQdeuXbFly5YKh9uoX78+XFxccPDgwQo7d3mde0bbtm1x6NAh7NixA7Nnz0Z2djb09PTQsWNHri1yTZ0fTby8vODq6orBgwfj008/xYgRI5CUlMSNM+3u7o7169fjxIkTaN68OaytrXHt2jW162vfvj3Gjh2LBQsWwNjYGGPHjkVsbCz3e7t27TBixAg4OzvDwMBA5cvB6u53Xl4eZs6cie7du3PNUubMmYOSkhLo6upCJBJxVT51dXXB4/GQnJyMr776CpMmTcKFCxfg4uICW1tbbN++HcOGDYOlpSVOnjyJ48ePY/To0QDKqvfKqs9XRqtWrSo9ryrfffcdLCwscPjwYWzevBkGBgZo0KABUlJScPXqVZiZmXE9xh86dOit3MPKW7t2LVauXIlBgwbh008/xahRo7gOInNycvDgwQP07t0bO3fuREZGBp4/f47Y2FiMHDkS69evR9u2bbnmL3v27MG8efM0HpOK8ltVaLrXAq93nQPAN998g23btil1PteuXTsEBwcrNfcpKSnB6tWr8e+//2LXrl2oV68eGGPIzc1Fw4YNIZFIEBoaWu38RF7fm6nHRghRyczMjAGodvfxsvZ1svXIf4+Li4OrqysMDAyQmZmJadOmYdKkSbh37x7OnTuHM2fOcJ0WDR48GDo6OsjLy8Pp06cRERGB58+fw8bGBuPHj+c6epC9QS9P1fTAwEAUFBTAwcEB27dvR1RUFFdKxefzwefzIRaLIRQKIRaLMX78eIVOS+zs7LBv3z6uV9YGDRoo/JG2tbXl2gra2NjA398fTk5Or9W2SWbJkiU4f/48dHR0IBAIMHr0aCxevBhA2dvnc+fO4ZdffgGfz8e1a9fg7++PzMxMLFmyRKGqto+PD2JiYjB8+HAkJibC0dERAQEBiI+P595m8/l81KtXDxKJBEKhEEKhEN988w1sbW25tsuhoaE4evQoMjIyuPm1tLTA4/EgFAohEAigra2NiIgIWFtbK7SzAsqq14WGhsLT0xORkZHQ1taGrq4utm7dilWrVgEA7t27h88++0ztMZH93r9/f2680qrkt23btiEkJAQhISFc5zfdu3fHjRs3cOLECfj7++Onn37CrFmzuIe2+fPnIz4+nhuftn379mjfvj3atWuHtm3bIiAgACEhIVi6dClWr14NZ2dn7sGuWbNmiImJwbFjx5CcnIzCwkLumMsCSqCsiqHs4TApKQm2traYNGkS1wkMUFY6cujQIYSEhIDH42HatGlvrAr92/I69wx55ubmCvet58+fQyQS4dmzZ5g7dy6uXr0KHo+H4uJieHl54cGDB1wHdD4+PlxnMjExMdixYwcSEhLg6emJ+fPn49tvv8WkSZPg5uYGc3Nz/PPPP1i6dCk8PDywYsUKHD16FFpaWhAKhRgyZIjKh2N3d3dYWlqia9euMDQ0xIMHD+Dk5KTU3q2m7hnvgrCwMPj5+b3X+1FQUIBdu3bB2dlZ6QVrWloa99JOW1sbkydPxsSJE3HmzBlER0cjMTER/fv3x7hx49C2bVuEh4cjNDSU671+1qxZaNWqlcIQLuXJ+gJQV8rbp08fhRJd+SHiwsPDIZFIMHjwYG6ec+fO4dy5c3j06BFevXoFCwsL/Pjjj+jWrRsePnyIq1evIiYmBklJSbCysoKjoyNmz579zt3D7t27h4sXL6JVq1Zo3bo1WrVqBYlEwvV0vnjxYjRu3Bjr1q3DsGHDcOjQIY1jt79tr3Odm5ubc7XRNJGN2iDrldnAwAAbN27kqlEzxtC3b18UFxcDKKtqLavFIr+t8+fPV6rZUUWdn1WG7GVkQkICxX2EkDfHzMyMmZmZsZrw77//Knx/8uQJY4wxoVDIHj16xJKTk1lGRgb3+5EjR9iGDRvYvXv3NK73/v37zNPTk2VlZXHTgoKCVM57/PhxpWkikUjtusViMSstLWWlpaVMKBQykUjEpFKpwjyjR4/WmL7vv/+e+xwcHMxsbGzYyZMnNS5TkcLCQvb8+XOWmZnJCgsLNc4bFhbGDhw4wIqKipR+k0qlLDMzkwmFQqX9khEKhay4uJgVFxezkpISJhAImFgsVjs/Y2XHtKSkhJWUlLDS0lKF+W/evKk0v6pp1VXV/JaQkMCuX7+usIynpydjjLGoqCgWHx+vtA1NeYcxxiQSCdu4cSPr2bMns7OzY0VFRSw9Pb3CZcRiMZNIJEwikTDGGEtKSmJHjhxh+fn5GpcVCATs3LlzLC8vT+N874uqnkN55e9bJ0+eZCNGjGBjx45lBw4c4KaHhISwpUuXKl0fO3bsYA4ODuz58+fctD///JONGzeOrVixgv35558K8xcWFjIXFxcWEhLCGGNsz549bODAgczd3V1l+qRSKZNKpaxv377MzMyM9enThx08eFBpvpq6Z9SGCxcusLS0NCYWi1liYiKztbVl/v7+tZ2sN0ogELDi4mLu2hWLxczb25tFRUUxgUDAUlNT2ZAhQ9jgwYOZvb09u3PnDresWCzm8rg6vXr1YtnZ2Wp/7927N/dZlgbZ5x07drB+/fqx33//nZv+7NkzFhUVxR49eqTxnv7q1St27949Vlpa+l7dw1JSUhS+S6VSlpqaygQCQY2sv6a8znU+d+5chXOsikQiYXPnzuW+R0VFMaFQqDRfaWkpKygoYPn5+SrzwY8//ljpdNUE2bNnbT8D1waK7Al5i2qqRJeQD5msGveb6lyL1DyxWAwej6dUhZIxBqlUqrJqZVFRkcJQOB+6PXv24OjRo8jNzYWRkRFsbW0xffp0lceOEEJkPuQS3Q9uhwmpTRToEkIIIYSQt+VDDnSr3+c9IYQQQggh7zjGGJ49e1bbySCEvCUU6BJCCCEfkOzsbLVjwn7oyg9HpG4aeT+JRCL88MMPStPPnz+PyZMno7S0tFLrycrKwtChQ7kOhwAgNTUVkydPrrG0EkKqj4YXIoSQ91hiYiIcHBwAlPXMaWhoiC+++AKjRo3SOF6yuvVcuXJFYRzHtyUrKwuOjo4ICgpSObxVVcgfExnZGKSybSQlJb2R/S1/Pho3boy+ffvi119/haGhYY1t523p1q2b2qEx0tPT8ffffwOofv7RFHi/zaYenp6eGDFihMZpNjY2ePHiBZo3bw4A3GeJRKIwhBdQ1jP9ggULuO8ikQiBgYGIjIzE48ePIZVK0bJlS3h6euLzzz+vsf0IDw/Hjh07kJGRAQcHB0RFRdXItVVTavJ6r67Y2FisWLEChoaGSvcNFxcXlcNbhYWFoWvXrgp5PTo6Wu2wQISQ2kGBLiGE1AFXrlyBnp4e8vLycOPGDfj4+ODy5cv4/fffa/1BsrwnT57A2dkZR48e5QIDExMThISE1Oh2VAVd6rahKk3V3bauri4eP36MVatWwdXVFRs3bqz2et82bW1ttePnWlhY1Nh2ZMGsLGCOi4urkfNQkbCwMPj6+nLfpVIpbGxsFOYpP+306dOwsrLihv3o06cPTp8+jaioKNy8eZMLbM+cOYPExERuOYFAgJkzZ4Ixhvnz5+Orr76CWCxGYmIi9PT0amyfMjMzsWrVKnh4eKBfv36QSCSYNWtWja2/qt7G9S6VStG7d2+FaUKhUONLEsYYDh06hNDQUAQGBqJdu3bcb/fv34eHh4fSeKpSqRQDBw5EUVERtLW1uZeJFy9exOnTp/HkyROcOHGCm//QoUMK6yWEvF0U6BJCSB3B4/HQpEkTDB48GL169cLPP/+MY8eOYezYsbWdNAX5+fl48uRJbSdDwZtIE5/Px8cffwxHR0c4OztDKpXWyksHc3NzGBgYcN8ZKxtlwsrKipsmlUrRtGlTpaBWJBLBzs5O5XpFItEbSO3b9cMPP6Bfv34wMDAAj8fDjBkz4O/vrzCPqmmqtGzZEmfOnOG+P3jwAB07duS+b926FaWlpdizZw8X8Ono6KgsMayOly9fQiqVwsrKCtra2tDW1q7R9VfV27je+Xw+/P398dlnn0FXVxdZWVmwt7fH1KlTcffuXaX5e/fujc8//xy3bt3CRx99pFDqXlJSAoFAAB0dHTg4OEAgEODUqVMAyq6d/Px8xMXFASgbj7pPnz5ISEiAvr4+Nx0ArK2toaVFj9mE1KZ36zU/IYSQGtGwYUP8/PPPOHnyJDdNKBTC29sb1tbW6NOnD5YuXYrCwkKVy1c0b15eHubNmwcLCwv88MMP2L17N8zNzSEUCgEA169fx/jx49GzZ0/88MMPCg+AsuqBFhYWXJXVxMREmJubo7i4mPt87do1jB8/Hr169YKdnR2Sk5MrvX1V5LdRnqo0VXQcZOs7deoU+vfvj/Xr16vcbmlpKfT09MDn89UuIxKJ4OvrC1tbW/Ts2RNDhw7Fzp07IZVKAQDHjx+HtbU1CgoKAAA3b96EpaUl7ty5g169eiE2NpbbnkAgQN++fRWO+enTp3Hp0iVcunQJwcHBAMB9v3TpEgICAlSmXVtbG8eOHVP5T1UA9c8//2DUqFGwsLDA3LlzkZeXh5ycnEqlUZWKlpUdz9jYWKXtylSUl4OCgrBgwQI8evQIOTk5SEtL434bNGgQfH19ER0dDTc3N+74FxcXw87ODnZ2dly7zvbt2+Phw4fcsomJiejcuTOAsuGVQkNDMW3aNI0l1RXlg8pcG/b29gD+l5fL53tN146qa0Q2Tf738vm3Otd7Te33pUuXuPQkJyejU6dOCAgIQExMDPfv4sWLAMqqK0+fPh0tWrTAqVOnuDz9xx9/QCgU4uzZs4iIiMCxY8e4NMjT0dHh/gFARESEUvtcsVhc6y8ZCPnQUaBLCCF11KefforU1FTuQW3NmjW4e/cuAgMDER4ejtzcXGzYsEHlshXN6+rqilevXiEsLAy7d+/GlStXFJYvKirC8uXLceXKFfTr1w+enp7cb3v37gUAxMXFaaxaGBQUhC1btuDcuXNo0aIF3NzcKr39qlKXpsocs2vXriEsLAwzZsxQmC6VSnHnzh34+vpizJgxGpdxd3dHdHQ0Nm7ciNjYWKxduxbBwcHYvn07AGDUqFH4+OOPERAQAKlUCm9vb8yaNQtffvklrK2tERkZya37woULaNy4MXr16lWtYwKUBSA//fSTyn+qSnRPnTqFHTt2IDQ0FC9fvsS6devQtGnT105jZZdVtV2Zis6hvb09SktLYW9vD1dXV7Ru3Zr7raCgAHw+H/369UP//v2Rnp4OANDX1+eCo/r16wMADAwMoKWlhZycHAgEAqSlpcHU1BRAWfXd4uJipaqw5VWUD2Q0XRsVXV81ce2Uz7/Vvd5rYr+dnJyQlJSE6OhoXL58Gb1798a1a9fg5OQEsVistE1ZSbrshYWdnR0mTZqE0tJSjB07lpv24sWLCo/HsmXLcO3aNURHR3PTVLXZJoS8XVSnghBC6iixWIx69eqBz+cjNzcXkZGROHz4MExMTAAAEyZMwJIlS+Dq6qqwXEXz5ubmIiYmBvv374eRkREAYNq0aZgzZw63DmtrawgEAjx8+BAGBgZIT0+HWCyuUlW+2bNnc+sfO3Ys5s6dC6lUivz8/Aq3DwCWlpbc53HjxuG7776r9LYrcxxkJk6ciAYNGihtm8/no02bNhg9erRS9XH5ZfLy8hAeHo5du3ZxVV27dOmCGTNmwMfHB05OTuDxeFi+fDns7e2hpaWFBg0acMHzqFGjMHfuXBQXF0NfXx9hYWEYMWIEeLzqD5m4efNmpbaPMvKlrDJOTk5o2rQpgLIAcs2aNdVOY2WWld+ug4MDFwBVdA4fPHiAzZs3o3HjxmjdujVKS0vh5uaGy5cvAyi7hvr374969epx24qKiuJKdAEo9NTbs2dPXLp0CYaGhujVqxeXRtlLAU35vzL5QEbdtVFR1fjKXLuVUT7PV+d6r6n91tbWhpubG2bPng2xWAwXFxc0aNAA27Ztg4+PD3799Velbbu4uGDgwIG4desWNm/ejJcvX+LAgQNo06YNgLIXHREREUrLle/oj8/nY8SIEXBycsIXX3wBExMTiMViCnQJqWUU6BJCSB2VmJjI9eSamZkJxhjGjRunNF/5krmK5s3MzAQAhU5Wyvco7OPjg1OnTqFLly5ciZeqKoCaNGvWTGH9jDGIxeJKbR9Q7oxKvmOgyqjsMZMvAVS37fLkl8nIyABjjCv9k2nbti1ycnK4B3lTU1MMGDAA+/btw86dO7kgytzcHC1btsTFixdhbm6OW7duKZSoAVDoTElTG12grG3p3LlzVab7+fPnMDY2Vpru7e0NAAq/GRsbo7i4GFKptFJpVKcyy8pvt3nz5tx2K3MOHRwc0LlzZ0ydOhXBwcFckJyamoqRI0di5syZGDVqlMKyshJdoKwzKpkhQ4bA09MTDRo0UOgAqmXLluDxeEhJSVHbw3Rl8oGMumujosCqstdORcrn+epc7zW53x06dIC5uTn+++8/NGzYEEBZCfaECRNga2vL7bdQKERsbCwSExPh5+eHli1bwtHREQcPHsSMGTPg5+eHCxcu4OTJkxg+fLhSmmVVoCUSCXr06AEAMDU1xejRo+Ht7Y1169ZBIpFQ1WVCahkFuoQQUge9ePECR48exfz58wGAC2IiIiLQokULjctWNK+sY6Pnz59zn7Oysrjf09LSsHfvXhw/fhympqaIi4vD2bNnq79Tldx+TansMXudklP5ZWTD1Dx+/Jhr0wmUHUcTExOulC4tLQ2XLl3CgAEDsHv3bpiZmXHzjho1ChEREcjIyED//v3RpEkT7rfOnTtjx44dXACSnZ2NwYMH49KlS9w8T548wbZt2wCUVXmX9SgcEhKCpk2bom/fvtxDvew3ebKXCIWFhVyA//jxY4X0a0pjRSpatvx2jY2NwefzKzyHn376KXJycjB79mz069eP63QIKGvzaWxsjLi4OIwYMUJjaWlCQgKKi4vRp08f6OnpQSKR4Ouvv+Z+b9iwIXr27Il9+/apDXQrmw+qo6JrRxYwCgQC7niqascvn3+re73X5H6npKTg+vXr+OijjxAZGYmhQ4fik08+QWhoKIyNjbk2/FpaWoiOjkbHjh2xbt06/P333/Dw8MDw4cNhZGQEBwcHNGnSBAEBARXeL+VNnDgRL168gFAo5EqZCSG1h9roEkJIHcEYQ05ODiIjI+Hg4IDvv/+eq65rYmICMzMzrF+/HllZWZBIJLh//z6uX7+utJ6K5m3Tpg03Lm1BQQHS09Oxf/9+bnlZe7iMjAwUFBTgyJEjCuuXlbTcvHmT69ynKira/utQlaaqHLPqMDIywoABA+Du7o4HDx5AIpHg9u3b8Pf3x8SJEwGUlY6tWLECdnZ2cHV1xf379xWGZ/n+++9x+/ZthIaGYuTIkQrr37dvHxfkqtO2bVt4eXkpTMvJyYGPj49CtV0ASm11Dx06xP22detWFBUV4fHjx9i9ezd+/PHHSqWxIhUtW367P/zwA4CKz+H169cxbdo0jB8/HpMnT0Z+fj637/v378fPP/8MCwsLLn8VFhbi2LFj3FBBQ4YMgUAgwKFDh5CamoonT54gLS0NWVlZyMnJUUjjokWLkJSUhIULFyIlJQUSiQQFBQX4888/8fDhw0rlg+qq6Npp37499PX1ER4eDqCsWvaBAwc0rrO613tN7Xd+fj4WLlwIZ2dneHh4YPv27VyQXr4WAo/Hg5WVFe7fv49p06bh7t278Pb2RkZGBlJSUmBkZAQXFxcEBgZWevtA2YuCVq1aobi4WOGaCwsLg42NTY0PoUYI0YxKdAkhpA6wtLQEj8dDw4YN0blzZyxbtgzffvutwjxeXl5Yu3YtRo0aBZFIBFNTUzg7O6tcX0Xzenl5wdXVFYMHD8ann36KESNGICkpCVpaWmjfvj3Gjh2LBQsWwNjYGGPHjlVoz9muXTuMGDECzs7OMDAwQFRUVJX3V9P2X4e6NFXlmFXH6tWrsXXrVsyaNQt5eXlo3bo1HBwcuCqze/bsQXYiJQrSAAAfUElEQVR2NqZMmQIdHR04OzvDy8sLFhYWMDExgaGhIaytrZGcnKxQ0vu6CgoKMG/ePHTv3h1//PEHsrOzuSq6qsbVlZXofvXVV/jpp58gFArx/fffY+rUqdw81UljRct26dIFw4YNQ2lpKWxsbDBt2jTuN03nsFOnTti+fTuMjIyQkJCAJk2aIDs7G87Ozvj8888xfvx48Hg8ODs7QyQSYeTIkXj8+DGWL1+Ojh07wtTUFNbW1tiwYQNSU1MxY8YMzJ49G/n5+XB2dsa2bdu4QK9t27Y4dOgQduzYgdmzZyM7Oxt6enro2LEjVqxYAaDifFATNF07fD4f7u7uWL9+PU6cOIHmzZvD2toa165dU7u+mrjeq7vfeXl5mDlzJrp37w5bW1sAwJw5c1BSUgJdXV2IRCLo6uri/v370NXVBY/HQ3JyMr766itMmjQJFy5cgIuLC2xtbbF9+3YMGzYMlpaWOHnyJI4fP47Ro0crbE++uroqDx484GoTAICvry/8/f0xc+ZMDBs2rFL7RAghhLxXzMzMmJmZGSOkrjl16hSzsbH5YLf/LhgzZgw7cuRIhfO9fPlS433o9u3bbOjQoczDw4NJJBKWmprKli9fzmxsbFiPHj2YtbU1GzBgAOvfvz/r168f69OnD3vx4kWNprGyy/7777/MzMyMFRUVvdY6GWPMw8OD9enTh/Xv35+dOHGCDRo0iLm6urLS0lJuntLSUrZixQo2bdo0peV79+7NwsLCWN++fdnBgwe56StWrGDDhg1jmZmZr522t6EuXDv5+fls48aNTCKRKP329OlTJvvb27NnT7Z9+3ZWUlLCgoODmbOzM+vfvz9bs2YNe/jwIROJRCw4OJg5ODgwxhh79eoVmzhxIluyZAljjDGxWKxw7ch/v3r1Khs0aBAbPnw4s7CwYLt37+bmGzJkCEtNTX3vjzN5P8nyf20/AxNC6jgKdEldceHCBZaWlsbEYjFLTExktra2zN/f/4PZ/rskLy+PHT16lA0cOLBSAV9hYSFzd3dX+3tRURG7cuWK2t+lUimTSCRMJBIxkUjExGJxjaexssvWRKDLGFMIkNLS0tTOV1BQoDRtzJgxzN/fn505c0ZhulgsZocPH1YZfNWmD/HaEQgErLi4mDsXYrGYeXt7s6ioKCYQCFhqaiobMmQIGzx4MLO3t2d37tzhlhWLxezJkyfc93///Vdh3bLfhEIhe/ToEUtOTmYZGRkK8wQHBzMbGxt28uTJN7WLhKj1IQe61R97gBBSabIbjaaxQwl5H+zZswdHjx5Fbm4ujIyMYGtri+nTpyu156yr23+XWFhYoEWLFli9enWF47TWluqkUdOyiYmJcHBwqLCXa/I/dO0Q8mGRdYCXkJDwwcV9H9wOE1KbKNAlhBBCCCFvy4cc6FKvy4QQQgghhBBC6hQKdAkhhBBCCCGE1CkU6BJCCCGEEEIIqVMo0CWEEEIIIYQQUqdQoEsIIYQQQgghpE6hQJcQQgghhBBCSJ1CgS4hhBBCCCGEkDqFAl1CCCGEEEIIIXUKBbqEEEIIIYQQQuoUCnQJIYQQQgghhNQpFOgSQgghhBBCCKlTKNAlhBBCCCGEEFKnUKBLCCGEEEIIIaROoUCXEEIIIYQQQkidQoEuIYQQQgghhJA6hQJdQgghhBBCCCF1ilZtJ4CQD9GECRNqOwmEEEIIIYTUWRToEvJ2ZQBomZycXNvpIIQQQgghH4aM2k5AbaBAl5C3SE9P77Pi4uLPajsdhBBCCCHkw6Cvr3+vttNACCGEEEJUMDMzY2ZmZqy200EIIeT9QJ1REUIIIYQQQgipUyjQJYQQQgghhBBSp1CgSwghhBBCCCGkTqFAlxBCCCGEEEJInUKBLiGEEEIIIYSQOoUCXUIIIYQQQgghdQoFuoQQQgghhBBC6hQKdAkhhBBCCCGE1CkU6BJCCCGEEEIIqVMo0CWEEEIIIYQQUqdQoEsIIYQQQgghpE6hQJcQQgghhBBCSJ1CgS4hhBBCCCGEkDqFAl1CCCGEEEIIIXUKBbqEEEIIIYQQQuoUCnQJIYQQQgghhNQpFOgSQgghhBBCCKlTKNAlhBBCCCGEEFKnUKBLCCGEEEIIIaROoUCXEEIIIYQQQkidwqvtBBBCCCGEyOvSpUtrLS2t5eUmO/7//9vlJ4rF4jX//vtv2ttJGSGEkPcFBbqEEEIIeaeMHj26XkpKSjqPxzPRNB9jLKtDhw6tjh8/LnlbaSOEEPJ+qFfbCSCEEEIIkXfnzh3WqlWrTwB0q2DWAxcuXAh/G2kihBDyfqE2uoQQQgh550il0pOVmK0y8xBCCPkAUaBLCCGEkHcOn8+/xBjL0TBLdqNGjS69tQQRQgh5r1CgSwghhJB3Tnx8vIjH44VqmCU0Ojpa/NYSRAgh5L1CgS4hhBBC3kk8Hk9t1WQ+n0/VlgkhhKhFgS4hhBBC3kn5+fnnARSo+KkgLy/vwttODyGEkPcHBbqEEEIIeSelpKSUMsZU9aoclpKSUvrWE0QIIeS9QYEuIYQQQt5ZaqovU7VlQgghGlGgSwghhJB3Fo/HOwOgWG5SMY/HO1tb6SGEEPJ+oECXEEIIIe+s+Pj4YgCnZd95PF7k/08jhBBC1KJAlxBCCCHvNMYYV1VZKpVStWVCCCEVokCXEEIIIe80HR2dCNlnfX39CE3zEkIIIYQQQggh7wUzM7MwMzOzU7WdDkIIIe8HrdpOACGEEEJIJZzk8XisthNBCCHk/cCr7QQQQsiHpGvXrh35fH5/Pp9vAaALY6w5gKYA9Go5aYQQQuqGEgA5PB7vBYB/pVJpnFQqvXjr1q37tZ0wQt4mCnQJIeQN69ChQ/2GDRtOBDAFQM/aTg8hhJAP0l8AdhcUFOxPSUkpre3EEPKmUaBLCCFvDu+bb74ZwePxvAGYAkCjRo1gaWmJr776Cl988QWMjIzQsGFD6OrqgsejWzIhhJDXxxiDQCBAQUEBXr58ieTkZCQmJuLKlSvIz8+XzfaIMbbwn3/+CQJAzQFInUVPVYQQ8gaYm5s3YoztAjASADp16oSJEyeib9++0NHRqeXUEUII+ZAIhUJcvnwZ+/fvR1JSEgCAx+OdADA1Pj4+X/PShLyfKNAlhJAa9s0333zJ4/HCAJgaGRnh119/xeDBg8Hn04huhBBCao9UKsW5c+fwxx9/4OXLlwDwCIBtQkJCci0njZAaR4EuIYTUIDMzsy48Hu8CY8yoZ8+eWLNmDZo2bVrbySKEEEI4OTk5WLZsGa5fvw4ej/cSQP/4+PjE2k4XITWpXm0ngBBC6opu3bp9xhiLAdBs5MiR8PDwgL6+fm0nixBCCFGgp6eHoUOHIicnB3fu3NHn8XhjWrVqFfrs2bPs2k4bITWFAl1CCKkBX3/9dWMej3cRQOsxY8Zg0aJFVFWZEELIO4vH46FPnz7Iz8/H7du39QAMNjExOZiZmSmo7bQRUhPoKYwQQqqPx+fzDzLGOvbo0QPz58+nHpQJIYS883g8HubPn4/u3buDMdaRz+cfBDVtJHUEZWRCCKkmc3PzqYyxnY0aNcLRo0fRvHnz2k4SIYQQUmkvXrzAmDFjkJ+fD8bY1H/++WdXbaeJkOqiqsuEEFIN3bt3byOVSsPwf+3de2xUZf7H8c+Z6QXbCgUL5VYVqjEg8LMdcIEg0EoBgUgprYDbuOjuuiQm64VgFAUUq+IFiCBmE3ddEMiylS1CCyvbpWFbsMtCQVoQUXB/BqUtl9JSWuhl5vn9wW8mJVCZ6cVD8f1KJjkzZ845n1NIn37Pc57nSCFvvfWWBgwYYHckAAACEh4ern79+mn79u2yLCuxb9++606ePHne7lxAa3DrMgC0gtvtfklSxMyZM/XAAw/YHQcAgBYZPXq0ZsyYIUkRHo9nvt15gNbi1mUAaKEhQ4b0DQ4O/jYsLCzo73//uxUeHm53JAAAWuzChQuaNGmSqampaXC73f0PHjz4g92ZgJaiRxcAWsjpdM4zxgTPmjWLIhcA0OFFRERo5syZlqQQp9M5z+48QGvQowsALTBs2LCebrf7f0NDQ0O2bdtmRUZG2h0JAIBWO3funCZPnmzq6urqg4OD79izZ0+53ZmAlqBHFwBawO12PycpNDU1lSIXAHDT6Nq1q6ZPn25JCm1oaJhrdx6gpSh0ASBAY8eODZL0hNPpVHp6ut1xAABoU+np6XI6nZL0eFpaGk9pQYdEoQsAAaqqqhop6bahQ4eqR48edscBAKBNRUdHy+VySVLU8ePHR9qdB2gJCl0ACJBlWdOky49iAADgZjRmzBjv4jQ7cwAtRaELAIGxJCVLFLoAgJuX99nwlmUliwls0QFR6AJAAO67777/kXTnXXfdpd69e9sdBwCAdtGnTx/FxsbKGNMvLi5uiN15gEBR6AJAABwOx1SJ3lwAwM3P29Z52z6gI6HQBYAAGGPul6Rhw4bZHQUAgHblbeu8bR/QkVDoAkAALMsaLEl33XWX3VEAAGhXTdq6wXbmAFqCQhcA/HTfffdFSorp0qWLunbtanccAADaVbdu3dS5c2dJut3lcnWxOw8QCApdAPCT0+kcJEmxsbGyLCagBADc3CzLUmxsrHd5kM1xgIBQ6AKA/wZLUv/+/e3OAQDAT8Jb6Lrdbm5fRodCoQsAfjLG+Hp0ATtcunTJ7ggAfma8F3e9c1QAHQWFLgD4r7ckRUdH250DN6ny8nL98MMPkqQxY8ZIko4fP64zZ86otrZWY8eOVX19/TW33bVrV6uO/f333ysnJ6dV+wBw8+nZs6d3sZedOYBAUegCgP86S1JERITdOXCTKigo0OLFi33vjTF6/fXX9d1336mkpES33367QkJCrrntSy+9JElKSUlRcnKyUlJSrnolJiY2e+zg4GC9//77+uabbwLKfOzYMaWkpKiysjKg7X4KJSUlcrlcqq2tvSFy1NfXq7y8XMnJyfJ4PH5vf/78eT3yyCM6evRoO6YErq1Jm9fZzhxAoILsDgAAHUgXiUIX7SclJUU7d+5UaWmpJOnLL79Uv3795HK5tHTpUg0ZMsSv/axevVqRkZFXfd600HW5XOrS5epJVH/3u99d9dlnn312zQLb4/Fo4cKFevbZZ695PFwtOjpan376aUDbdO7cWXPnztWCBQu0YcMGORz0U+CnEx4e7l1k1mV0KBS6AOC/LpIUFhZmdw7cpFJTUyVJTz31lGpra7VgwQJJ0ueff65t27YpJCREU6ZMUU1NjRoaGjR37lytXbtWlZWVqqmpUWJioiIjI/XrX/9aTqfzusfLzc2V0+lUXV2dZs+erYyMjIDGoOfn58uyLD3wwAMtO2H47Re/+IUiIiKUl5encePG2R0HPyNN2jwKXXQoXBIEAP91lq64ug20qaysLC1fvlxRUVFyOp2aOHGi1q1bp//+97+qrKzUxx9/rJycHD366KOaPn26pk2bpqysLOXl5Sk8PFx5eXmSpD/96U/KzMxUZmam4uLifMujRo266phJSUmaOHGivvnmG82ZM0dJSUlXvKZMmdJs3u3bt2vChAnNrvfespudna3x48drwoQJ+s9//qP169crISFBSUlJys/PV0VFhYYPH67du3f7tr106ZJGjx6twsJCSdKGDRs0fvx4jRgxQu+++67ve5WVlZo7d65GjBihKVOm6I9//KPvNuHW8ubfsmWLEhMTfcetr6/X22+/rYSEBI0aNUrz58/XhQsXfNudP39e8+bN08iRIzVlyhTt2bPnqn16b6du7ryuZfz48crNzW31eQGB8N7FZIzh1mV0KBS6AOA/bl1Gu6mvr9fKlSu1ePFivfzyywoNDdXdd9+tOXPmqKysTEOHDtXx48clXZ6gyt+e16aFUdPxv14bN25UUFCQNm7cqNzcXH300UfKzc31vX5sgqpDhw5p8ODrT8R67Ngxffrppxo+fLheeuklfffdd9q6davGjh2rZcuWqVu3bkpISNC2bdt82+zYsUORkZEaPny4vv/+e73zzjvKyMjQjh079NBDD/m+t3DhQlVXVysnJ0erV6/2FcZtac+ePcrOztacOXMkSRkZGfrqq6+0YcMG5eTk6Ny5c1q6dKnv+4sWLVJVVZW2bNnyo5l+7Lyu5d5779WhQ4fa7sQAP3gv7lqWRY8uOhQKXQDwn1OSLMuyOwduQsHBwRowYIA+/PBD/fWvf9WCBQuUkJCgVatWae7cuUpMTFRBQYHcbrf27dsnl8slSWpsbNSRI0dUV1enX/3qVyorK9Njjz2mqVOnaurUqaqurvYtT506VQcOHPAd07IsLVu2TJMmTdKdd94pSUpOTpbb7fYr86lTp9SjR4/rfm/GjBkKCwvTpEmTVFFRodmzZyssLEwTJkzQiRMn5Ha7lZqaqp07d/p6OrOzs5WSkiLLshQcHCzLslRWVqawsDDde++9kqSKigrt3r1bzzzzjG677TZFRUXpN7/5TSA/dr889thjCg8PV0REhM6dO6dt27bphRdeUHR0tCIjI5Wenq4dO3b4MuXn5+uZZ55RVFTUj2Zq7rya06NHD505c6bNzw/4MU3GhF9/PARwA2GMLgD4r0rSbbW1tdecxAdoDcuy9MEHH+j999/XiRMnVFhYqA8++ECS9NFHHykhIUGzZs1STEyMevfurT59+qixsVEpKSm65557FBQUpIyMDD355JPatGmTb4xuYmKiNm/efMWxLl68KIfDIYfDoZycHEVERCg7O9u3Pikpybc8f/78ZseEGmP8uvDjnajKO9YvKipKkhQaGipJcrvdcrlc6tWrl/Ly8uRyuXTw4EG9+eabki5P4PTaa6/pvffe07p16/Tiiy8qLi5O5eXlkqTbb7/dd6z2uOOib9++vuWysjIZYzRr1qyrvtfQ0BBQpubOC7iR1NTUeBer7MwBBIpCFwD8ZFnWeWPMbRcuXKDQRbtYvXq1Hn30UWVlZemOO+7QkSNHtGjRInXu3FkOh0OjRo3SO++8o+XLl0uSgoKCtGXLFkmXn7vbt29f1dfXy+l06pFHHpEkVVdX+5b79Omj5cuXq7Ky0vd/uKio6IoMLpfLN0nV9URFRens2bPq3bt3m5x/amqqtm7dqtLSUiUmJqpr166+dQ899JDGjRunFStW6Pnnn1dubq5uvfVWSdKZM2d8xeSpU6faJEtTTYv5bt26SZK2bt3a9PmiPk1zeJe9xe+1XOu8mnP69GnfRQLgp9Kk0D1vZw4gUBS6AOC/KumKRh9oUxcuXNCgQYO0aNEiJScna82aNVq0aJEcDoc8Ho9vwqPmJloqKytT9+7dJV0u/ryTU0mXJ2164oknJEnffvutYmJilJaWds3n306cOPGK980VXwMGDNDhw4f9Gqfrj8mTJ2vVqlU6ceLEFeOJS0tLVV5erkGDBikmJkb19fUyxqhv376KjY3VypUrtWjRIlVXV2vt2rXN7r+8vFzR0dGtyhgdHa34+Hi9++67mjdvnqKionT8+HFVVlbq/vvvV0xMjPr376+VK1fq1VdfVXV1tT7++ONr7qu582qul/zw4cMaOHBgq/IDgWoy0Ro9uuhQKHQBwE/GmCpJvjGEQFvr3bu3Fi9erPfee09Lly5Vp06ddPToUQ0aNEivvfaaKisrtXTpUr388ss6f/68UlJSrtj+4MGDfk1SlZ+fr8GDB+u55567ap3L5dJnn33mV49uUlKSMjMzNXPmTP9P8kfceuutSkhI0JEjRxQfH+/73O12a/Hixfrhhx/Up08fZWRk+IrBJUuW6JVXXtH48eMVGxurtLQ0lZSUXLXv+vp6Pfnkk0pOTtbjjz/eqpxvvfWWlixZotTUVDU0NKh///56+umnfeu9mZKSknT33XcrNTVVhw8fvmo/P3Ze15Kbm6u0tLRWZQcC5W3zvG0gAAC4ycTHx2+Jj483u3btMkBbq66uNgsXLjSTJ082b7/9tjl79qw5duyYWbNmjfntb39rfv/735uamhpjjDGFhYVm9OjRZtOmTeb06dPm5MmTZty4cebpp582WVlZxhhjhg4datLS0nyvlJQUM23aNFNeXm5GjRpliouLr5kjPj7eNDY2+pW5oaHBTJs2zezbt69tfgjGmBkzZpi//OUvLd6+uLjYxMfHm7q6uqvWnTp1ykyfPt0sX768NRFtUVRUZKZNm+b3vw3QVgoKCkx8fLyJj4/ffP2WErhx0KMLAP47LV0eJwe0tYiICD344IN68cUX1alTJ0mXx4PGxsZq0KBBiouL8/X2DR8+XJmZmeratatmz56tkydPasaMGWpsbFRiYqKky72jmZmZvv17b102xmjkyJFtcrtxUFCQXn31VWVkZOjPf/6zb7KplqiqqtL27dt19uxZPfzww63Odi3du3fXH/7wB99jmjqK2tpaXy+xPz3tQFvyzvRtWRaNHzoUnpEBAH6Ki4t7zrKspenp6Xr22WftjgNcxfg5C7K/3/NXbW2tQkJCFBTU8uvnI0aMUM+ePbV48eJWFeElJSWaPXu2CgsLFRIS0uL93EgaGxtVX1/fqgsJQEstW7ZM69evl6Tn9u/fv9zuPIC/6NEFAD85nc4Sj8fT4XqD8PPhb/Ha1s+CbosCrLCwsA2SSIMHD75qJumOLigoqFUXEYDW8LZ5xpirB78DNzDH9b8CAJAky7JKpMsz1gIA8HPgbfNCQkIodNGhUOgCgJ/27t1bLulMeXm5qqur7Y4DAEC7qq6u9j6b+vSePXuafyA0cAOi0AUA/xlJ9OoCAH4WmrR19Oaiw6HQBYAAGGP2S9IXX3xhdxQAANqVt60zxhywOQoQMApdAAiA0+nMkaT8/Hy7owAA0K7+9a9/eRez7cwBtASFLgAEICIiYpeks8XFxaqsrLQ7DgAA7eLcuXMqKSmRpDNdunTZbXceIFAUugAQgJ07dzZKyvZ4PNq1a5fdcQAAaBe7d++Wx+ORpOz/b/uADoVCFwACZIzZJEkFBQV2RwEAoF00GaKzyc4cQEtR6AJAgDp16pQrqfbzzz9XTU2N3XEAAGhTNTU1KiwslKSa0NDQf9qdB2gJCl0ACFBhYeFFY8wntbW1+tvf/mZ3HAAA2tTGjRtVW1srY8zGwsLCi3bnAVqCQhcAWsDhcCyRZNauXau6ujq74wAA0Cbq6uq0bt06STJOp/NNu/MALUWhCwAtUFRU9JWkTyoqKrRlyxa74wAA0CY2b96siooKScrct2/fUbvzAC1FoQsALfe6JK1Zs0aNjUxICQDo2BobG7VmzRrv2zfszAK0FoUuALTQ/v37iyVtKS0t1SeffGJ3HAAAWiUzM1NlZWWyLGvz/7dxQIdFoQsAreBwOF6R5FmxYoW+/vpru+MAANAiX3/9tVasWCFJHsuyXrU7D9BaTrsDAEBHdvLkybKePXve4vF4RhUVFenhhx9WcHCw3bEAAPDbxYsX9dRTT6miokLGmCX79+9fb3cmoLUodAGglSIiInaFhoYmV1ZW9qioqNCYMWPsjgQAgN+WLFmif//735J0qLq6+pcVFRVuuzMBrUWhCwCtVFFR4Y6Ojv6nw+F47KuvvurUvXt3DRgwwO5YAABcV1ZWlj788ENZllUp6cHDhw+ftjsT0BYodAGgDZSVlVX06dOnyBjzaEFBgSMqKkoDBw60OxYAAM3auHGj3njjDUlyOxyO5KKion12ZwLaCoUuALSRkydPfturV69DkqYXFBQ4Ll26pKFDh8rhYN4/AMCNo7GxUStXrtSqVaskqUHSI0VFRVttjgW0KQpdAGhDpaWlR3r16vWFZVnJBw8eDN67d68GDx6srl272h0NAAAdP35czz//vP7xj3/IsqyLktL279+/2e5cQFuz7A4AADejuLi4gZZlfSJpoMPhUEpKitLT0xUTE2N3NADAz9CJEye0bt06ZWVlyePxSNKXxpi0AwcOfGl3NqA9UOgCQDsZMmRIeFBQ0HxJz0nqJElxcXFKTEzUkCFDdM899/AoIgBAu2hoaNDRo0dVXFysvLw8HThwwLvqkqRljY2NbxQXF9fYGBFoVxS6ANDOhg0bFuN2u1+Q9EtJXbyfOxwOdenSRZ07d9Ytt9wiy+JXMgCg5Ywxunjxos6fP6+qqipvz61XlaT1Tqdzyd69e0/YFBH4yfBXFQD8REaMGHHLpUuXkiUlOhyOEcaYgeL3MACgfRjLsr70eDyFkvI6der0aWFh4UW7QwE/Ff7AAgCbuFyu4KCgoG4NDQ3djDHhducBAHR8lmXVBAcHVzQ2NlYUFRU12J0HAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQLv5P6EteTvJ9jrtAAAAAElFTkSuQmCC" alt="" />

基于Spring-session的代码实现如下所示：

首先在配置文件中配置spring-session的filter拦截器。

 <?xml version="1.0" encoding="UTF-8"?>
 <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns="http://java.sun.com/xml/ns/javaee"
     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
     id="WebApp_ID" version="2.5">

     <display-name>sso-cross-domain</display-name>

     <welcome-file-list>
         <welcome-file>index.html</welcome-file>
     </welcome-file-list>

     <!-- 重要:spring-session的filter拦截器 完成数据转换的拦截器，spring提供的filter实现数据的拦截保存并转换为spring-session所需的会话对象中。 -->
     <filter>
         <filter-name>springSessionRepositoryFilter</filter-name>
         <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
     </filter>
     <filter-mapping>
         <filter-name>springSessionRepositoryFilter</filter-name>
         <url-pattern>/*</url-pattern>
         <dispatcher>REQUEST</dispatcher>
         <dispatcher>ERROR</dispatcher>
     </filter-mapping>

     <!-- 字符集过滤器 -->
     <filter>
         <filter-name>charSetFilter</filter-name>
         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
         <init-param>
             <param-name>encoding</param-name>
             <param-value>UTF-8</param-value>
         </init-param>
     </filter>
     <filter-mapping>
         <filter-name>charSetFilter</filter-name>
         <url-pattern>/*</url-pattern>
     </filter-mapping>

     <!-- 加载springmvc的配置文件 -->
     <servlet>
         <servlet-name>mvc</servlet-name>
         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
         <init-param>
             <param-name>contextConfigLocation</param-name>
             <param-value>classpath:applicationContext-mvc.xml</param-value>
         </init-param>
         <load-on-startup>1</load-on-startup>
     </servlet>
     <servlet-mapping>
         <servlet-name>mvc</servlet-name>
         <url-pattern>/</url-pattern>
     </servlet-mapping>

 </web-app>

然后配置提供数据库的表格信息：

mysql文件路径在这里，找到以后运行一下sql即可。/org/springframework/session/jdbc/schema-mysql.sql。

 <?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:mvc="http://www.springframework.org/schema/mvc"
     xmlns:context="http://www.springframework.org/schema/context"
     xmlns:dwr="http://directwebremoting.org/schema/spring-dwr/spring-dwr-3.0.xsd"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/mvc
         http://www.springframework.org/schema/mvc/spring-mvc.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context.xsd">

     <!-- 指定扫描的包 -->
     <context:component-scan base-package="com.bie.controller" />

     <!-- 为SpringMVC配置注解驱动 -->
     <mvc:annotation-driven />

     <!-- 为Spring基础容器开启注解配置信息 -->
     <context:annotation-config />
     <!-- 就是用于提供HttpSession数据持久化操作的Bean对象。
         对象定义后，可以实现数据库相关操作配置，自动的实现HttpSession数据的持久化操作（CRUD）
      -->
     <bean class="org.springframework.session.jdbc.config.annotation.web.http.JdbcHttpSessionConfiguration" />

     <bean id="dataSource"
         class="org.springframework.jdbc.datasource.DriverManagerDataSource">
         <property name="url"
             value="jdbc:mysql://localhost:3306/springsession?useUnicode=true&amp;characterEncoding=UTF8"></property>
         <property name="username" value="root"></property>
         <property name="password" value=""></property>
         <property name="driverClassName"
             value="com.mysql.jdbc.Driver"></property>
     </bean>

     <!-- 事务管理器。为JdbcHttpSessionConfiguration提供的事务管理器。 -->
     <bean
         class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
         <constructor-arg ref="dataSource" />
     </bean>

 </beans>

简单的控制层代码；

 package com.bie.controller;

 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;

 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.RequestMapping;

 /**
  *
  * @author biehl
  *
  *         1、SpringSession
  *
  *         spring-session表：保存客户端session对象的表格。
  *         spring-session-attributes表：保存客户端session中的attributes属性数据的表格。
  *         spring-session框架，是结合Servlet技术中的HTTPSession完成的会话共享机制。在代码中是直接操作HttpSession对象的。
  *
  */
 @Controller
 public class SpringSessionController {

     @RequestMapping("/springSession")
     public String test(HttpServletRequest request, HttpServletResponse response) {
         // 获取到attrName属性值
         Object attrName = request.getSession().getAttribute("attrName");
         // 如果获取到的获取到attrName属性值为空
         if (null == attrName) {
             // 获取到attrName属性值设置到session中
             request.getSession().setAttribute("attrName", "attrValue");
         }
         // 后台打印消息
         System.out.println("80: " + attrName);
         // 返回到jsp页面
         return "/ok.jsp";
     }

 }

页面效果如下所示：

然后发现，请求数据已经自动入库了，时间到期后自动删除。