使用freemarker导出word

整体步骤：

• 制作要导出的word模板，另存为xml格式，使用idea编辑。
• xml模板编辑完成，修改文件格式为ftl格式。
• 编写代码，封装导出数据，使用模板。

注意：编写模板时，同一行文字应先在记事本中写好复制到模板中，不然生成xml文件后会自动换行。

0.依赖

        
        
            org.freemarker
            freemarker
            2.3.28
        

1.Controller

	@GetMapping("/exportWord")
    public void exportWord(@RequestHeader(value = "deptCode", required = true) String rootDeptCode,@Valid ParamVo vo, HttpServletResponse response){
        String filePath = testService.exportWord(rootDeptCode,vo);
        File file = null;
        InputStream fin = null;
        ServletOutputStream out = null;
        try {
            if (StringUtil.isEmpty(filePath)){
                return;
            }
            file = new File(filePath);
            fin = new FileInputStream(file);
            String fileName = "bill-charge";
            response.setContentType("application/x-download");
			//下面三行是关键代码，处理乱码问题
            response.setCharacterEncoding("utf-8");
            response.setHeader("Content-Disposition", "attachment;filename="+new String(fileName.getBytes("gbk"), "iso8859-1")+".doc");
            out = response.getOutputStream();
            byte[] buffer = new byte[512]; // 缓冲区
            int bytesToRead;
            // 通过循环将读入的Word文件的内容输出到浏览器中
            while((bytesToRead = fin.read(buffer)) != -1) {
                out.write(buffer, 0, bytesToRead);
            }
        }catch (Exception e) {
            e.printStackTrace();
            log.info("导出异常：" + e.getMessage());
        }finally {
            try{
                if (fin != null) {fin.close();}
                if (out != null) {out.close();}
                if (file != null) {file.delete();} // 删除临时文件
            } catch (Exception e){
                log.info("导出错误");
            }
        }
    }

2.service

@Override
    public String exportWord(String rootDeptCode,ParamVo feeBillVo) {
        /** 1 查询业务数据集合*/
       List exportList = new ArrayList<>();
	    /** 2 封装导出*/
        DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyyMMddHHmmssSSS");
        String format = df.format(LocalDateTime.now());
        try {
            WordExport emw = new WordExport();
            Map dataMap = new HashMap<>();
			//需要遍历
            dataMap.put("feeList", exportList);
			//直接显示，无需遍历
            dataMap.put("deptNameZhang", "whatever");
            emw.createWord(dataMap, "bill-charge.ftl", "/templates/bill-charge"+format+".doc");
        } catch (Exception e) {
            log.error("导出异常：" + e.getMessage());
            e.printStackTrace();
        }
        return "/templates/bill-charge"+format+".doc";
    }

3.其他

3.1 工具类-传入名，生成图片，图片转base64码返回

package com.xwj.property.fee.util;

import sun.misc.BASE64Encoder;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.font.FontRenderContext;
import java.awt.geom.AffineTransform;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.io.*;
import java.util.Date;
import java.util.Objects;

import javax.imageio.ImageIO;

public class UtilsGraphics2D {

    private static final int WIDTH = 200;//图片宽度
    private static final int HEIGHT = 200;//图片高度
//    private static String message = " 青岛有个很牛的有限公司";
    private static String centerName = "";
    private static String year = "";

    /**
     * 传入公司名，调用生成图片方法，图片转base64码返回
     * @param message
     * @return
     */
    public static String ImageToBase64(String message) {
        byte[] data = null;
        try {
            BufferedImage image = startGraphics2D(" "+message);
            String imgPath = "/templates/" + new Date().getTime() + ".png";
            ImageIO.write(image, "png", new File(imgPath));
            // 读取图片字节数组
            InputStream in = new FileInputStream(imgPath);
            data = new byte[in.available()];
            in.read(data);
            in.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 对字节数组Base64编码
        BASE64Encoder encoder = new BASE64Encoder();
        // 返回Base64编码过的字节数组字符串
        return  encoder.encode(Objects.requireNonNull(data));
    }

    public static void main(String[] args) throws Exception {

    }

    /**
     * 传入公司名称，生成印章图片
     * @param message
     * @return
     */
    public static BufferedImage startGraphics2D(String message) {
        // 定义图像buffer         
        BufferedImage buffImg = new BufferedImage(WIDTH, HEIGHT, 2);
        Graphics2D g = buffImg.createGraphics();
        g.setColor(Color.RED);
        //设置锯齿圆滑
        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

        //绘制圆
        int radius = HEIGHT / 3;//周半径
        int CENTERX = WIDTH / 2;//画图所出位置
        int CENTERY = HEIGHT / 2;//画图所处位置

        Ellipse2D circle = new Ellipse2D.Double();
        circle.setFrameFromCenter(CENTERX, CENTERY, CENTERX + radius, CENTERY + radius);
        g.draw(circle);

        //绘制中间的五角星
        g.setFont(new Font("宋体", Font.BOLD, 50));
        g.drawString("★", CENTERX - (50 / 2), CENTERY + (50 / 3));

        //添加姓名
        g.setFont(new Font("宋体", Font.LAYOUT_LEFT_TO_RIGHT, 30));// 写入签名
        g.drawString(centerName, CENTERX - (40), CENTERY + (30 + 50));

        //添加年份
        g.setFont(new Font("宋体", Font.LAYOUT_LEFT_TO_RIGHT, 20));// 写入签名
        g.drawString(year, CENTERX - (60), CENTERY + (30 + 80));


        //根据输入字符串得到字符数组
        String[] messages2 = message.split("", 0);
        String[] messages = new String[messages2.length - 1];
        System.arraycopy(messages2, 1, messages, 0, messages2.length - 1);

        //输入的字数
        int ilength = messages.length;

        //设置字体属性
        int fontsize = 20;
        Font f = new Font("Serif", Font.BOLD, fontsize);

        FontRenderContext context = g.getFontRenderContext();
        Rectangle2D bounds = f.getStringBounds(message, context);

        //字符宽度＝字符串长度/字符数
        double char_interval = (bounds.getWidth() / ilength);
        //上坡度
        double ascent = -bounds.getY();

        int first = 0, second = 0;
        boolean odd = false;
        if (ilength % 2 == 1) {
            first = (ilength - 1) / 2;
            odd = true;
        } else {
            first = (ilength) / 2 - 1;
            second = (ilength) / 2;
            odd = false;
        }

        double radius2 = radius - ascent;
        double x0 = CENTERX;
        double y0 = CENTERY - radius + ascent;
        //旋转角度
        double a = 2 * Math.asin(char_interval / (2 * radius2));

        if (odd) {
            g.setFont(f);
            g.drawString(messages[first], (float) (x0 - char_interval / 2), (float) y0);

            //中心点的右边
            for (int i = first + 1; i < ilength; i++) {
                double aa = (i - first) * a;
                double ax = radius2 * Math.sin(aa);
                double ay = radius2 - radius2 * Math.cos(aa);
                AffineTransform transform = AffineTransform.getRotateInstance(aa);//,x0 + ax, y0 + ay);
                Font f2 = f.deriveFont(transform);
                g.setFont(f2);
                g.drawString(messages[i], (float) (x0 + ax - char_interval / 2 * Math.cos(aa)), (float) (y0 + ay - char_interval / 2 * Math.sin(aa)));
            }
            //中心点的左边
            for (int i = first - 1; i > -1; i--) {
                double aa = (first - i) * a;
                double ax = radius2 * Math.sin(aa);
                double ay = radius2 - radius2 * Math.cos(aa);
                AffineTransform transform = AffineTransform.getRotateInstance(-aa);//,x0 + ax, y0 + ay);
                Font f2 = f.deriveFont(transform);
                g.setFont(f2);
                g.drawString(messages[i], (float) (x0 - ax - char_interval / 2 * Math.cos(aa)), (float) (y0 + ay + char_interval / 2 * Math.sin(aa)));
            }

        } else {
            //中心点的右边
            for (int i = second; i < ilength; i++) {
                double aa = (i - second + 0.5) * a;
                double ax = radius2 * Math.sin(aa);
                double ay = radius2 - radius2 * Math.cos(aa);
                AffineTransform transform = AffineTransform.getRotateInstance(aa);//,x0 + ax, y0 + ay);
                Font f2 = f.deriveFont(transform);
                g.setFont(f2);
                g.drawString(messages[i], (float) (x0 + ax - char_interval / 2 * Math.cos(aa)), (float) (y0 + ay - char_interval / 2 * Math.sin(aa)));
            }

            //中心点的左边
            for (int i = first; i > -1; i--) {
                double aa = (first - i + 0.5) * a;
                double ax = radius2 * Math.sin(aa);
                double ay = radius2 - radius2 * Math.cos(aa);
                AffineTransform transform = AffineTransform.getRotateInstance(-aa);//,x0 + ax, y0 + ay);
                Font f2 = f.deriveFont(transform);
                g.setFont(f2);
                g.drawString(messages[i], (float) (x0 - ax - char_interval / 2 * Math.cos(aa)), (float) (y0 + ay + char_interval / 2 * Math.sin(aa)));
            }
        }

        return buffImg;
    }
}

3.2 word导出工具类

package com.test.util;

import freemarker.core.ParseException;
import freemarker.template.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import sun.misc.BASE64Encoder;

import java.io.*;
import java.util.Map;

public class WordExport {

    private static final Logger log = LoggerFactory.getLogger(PropertyUtil.class);

    private Configuration config = null;

    public WordExport() {
        config = new Configuration(Configuration.VERSION_2_3_28);
        config.setDefaultEncoding("utf-8");
    }
    /**
     * FreeMarker生成Word
     * @param dataMap 数据
     * @param templateName 目标名
     * @param saveFilePath 保存文件路径的全路径名（路径+文件名）
     * @Author boguotong.ex
     */
    public void createWord(Map dataMap, String templateName, String saveFilePath) {
        //加载模板(路径)数据
        config.setClassForTemplateLoading(this.getClass(), "/templates");
        //设置异常处理器 这样的话 即使没有属性也不会出错 如：${list.name}...不会报错
        config.setTemplateExceptionHandler(TemplateExceptionHandler.IGNORE_HANDLER);
        Template template = null;
        if(templateName.endsWith(".ftl")) {
            templateName = templateName.substring(0, templateName.indexOf(".ftl"));
        }
        try {
            template = config.getTemplate(templateName + ".ftl");
        } catch (TemplateNotFoundException e) {
            log.error("模板文件未找到", e);
            e.printStackTrace();
        } catch (MalformedTemplateNameException e) {
            log.error("模板类型不正确", e);
            e.printStackTrace();
        } catch (ParseException e) {
            log.error("解析模板出错，请检查模板格式", e);
            e.printStackTrace();
        } catch (IOException e) {
            log.error("IO读取失败", e);
            e.printStackTrace();
        }
        File outFile = new File(saveFilePath);
        if(!outFile.getParentFile().exists()) {
            outFile.getParentFile().mkdirs();
        }
        Writer out = null;
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(outFile);
        } catch (FileNotFoundException e) {
            log.error("输出文件时未找到文件", e);
            e.printStackTrace();
        }
        out = new BufferedWriter(new OutputStreamWriter(fos));
        //将模板中的预先的代码替换为数据
        try {
            template.process(dataMap, out);
        } catch (TemplateException e) {
            log.error("填充模板时异常", e);
            e.printStackTrace();
        } catch (IOException e) {
            log.error("IO读取时异常", e);
            e.printStackTrace();
        }
        log.info("由模板文件：" + templateName + ".ftl" + " 生成文件 ：" + saveFilePath + " 成功！！");
        try {
            out.close();//web项目不可关闭
        } catch (IOException e) {
            log.error("关闭Write对象出错", e);
            e.printStackTrace();
        }
    }
    /**
     * 获得图片的Base64编码
     * @param imgFile
     * @return
     * @Author boguotong.ex
     */
    public String getImageStr(String imgFile) {
        InputStream in = null;
        byte[] data = null;
        try {
            in = new FileInputStream(imgFile);
        } catch (FileNotFoundException e) {
            log.error("加载图片未找到", e);
            e.printStackTrace();
        }
        try {
            data = new byte[in.available()];
            //注：FileInputStream.available()方法可以从输入流中阻断由下一个方法调用这个输入流中读取的剩余字节数
            in.read(data);
            in.close();
        } catch (IOException e) {
            log.error("IO操作图片错误", e);
            e.printStackTrace();
        }
        BASE64Encoder encoder = new BASE64Encoder();
        return encoder.encode(data);

    }

}

3.3 word模板

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<?mso-application progid="Word.Document"?>

    
        
            
                
                
                
            
        
    
    
        
            
                
                
                
                
                
                
                
                
                
            
        
    
    
        
            
                
				# 遍历集合，指定别名
                    <#list feeList as fee>
                    
                    
                        
                            
                            
                            
                            
                        
                        
                            
                        
                        
                            
                                
                                
                            
                            
                                
                                    
                                
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                        
                                    
                                
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
										# 遍历：取集合中字段
                                        ${fee.roomFullName} 收费单
                                    
                                
                                
                                    
                                        
                                        
                                            
                                        
                                    
                                    
                                        
                                            
                                        
										# 遍历：取集合中字段
                                        日期：${fee.dateTime}
                                    
                                    
                                        
                                            
                                        
                                           
                                    
                                
                                
                                    
                                        
                                            
                                        
                                    
                                    
                                        
                                            
                                        
										# 遍历：取集合中字段
                                        亲爱的业主：
                                    
                                
                                
                                    
                                        
                                            
                                        
                                    
                                
                                
                                    
                                        
                                            
                                        
                                    
                                    
                                        
                                            
                                        
                                        
                                    
                                    
                                        
                                            
                                        
                                        您尚有如下费用需缴纳：
                                    
                                
                                
                                    
                                        
                                            
                                        
                                    
                                
                                
                                    
                                        
                                        
                                        
                                        
                                    
                                    
                                        
                                        
                                        
                                        
                                        
                                    
                                    
                                        
                                            
                                            
                                        
                                        
                                            
                                                
                                                
                                                    
                                                    
                                                    
                                                    
                                                
                                            
                                            
                                                
                                                    
                                                    
                                                        
                                                    
                                                
                                                
                                                    
                                                        
                                                    
                                                    费用名称
                                                
                                            
                                        
                                        
                                            
                                                
                                                
                                                    
                                                    
                                                    
                                                    
                                                
                                            
                                            
                                                
                                                    
                                                    
                                                        
                                                    
                                                
                                                
                                                    
                                                        
                                                    
                                                    账单月份
                                                
                                            
                                        
                                        
                                            
                                                
                                                
                                                    
                                                    
                                                    
                                                    
                                                
                                            
                                            
                                                
                                                    
                                                    
                                                        
                                                    
                                                
                                                
                                                    
                                                        
                                                    
                                                    单价
                                                
                                            
                                        
                                        
                                            
                                                
                                                
                                                    
                                                    
                                                    
                                                    
                                                
                                            
                                            
                                                
                                                    
                                                    
                                                        
                                                    
                                                
                                                
                                                    
                                                        
                                                    
                                                    应缴金额
                                                
                                            
                                        
                                        
                                            
                                                
                                                
                                                    
                                                    
                                                    
                                                    
                                                
                                            
                                            
                                                
                                                    
                                                    
                                                        
                                                    
                                                
                                                
                                                    
                                                        
                                                    
                                                    未缴金额
                                                
                                            
                                        
                                    
                                    <#list fee.billList as bill>
                                    
                                        
                                            
                                            
                                        
                                        
                                            
                                                
                                                
                                                    
                                                    
                                                    
                                                    
                                                
                                            
                                            
                                                
                                                    
                                                    
                                                        
                                                    
                                                
                                                
                                                    
                                                        
                                                    
                                                    ${bill.chargeItemName}
                                                
                                            
                                        
                                        
                                            
                                                
                                                
                                                    
                                                    
                                                    
                                                    
                                                
                                            
                                            
                                                
                                                    
                                                    
                                                        
                                                    
                                                
                                                
                                                    
                                                        
                                                    
                                                    ${bill.payMonth}
                                                
                                            
                                        
                                        
                                            
                                                
                                                
                                                    
                                                    
                                                    
                                                    
                                                
                                            
                                            
                                                
                                                    
                                                    
                                                        
                                                    
                                                
                                                
                                                    
                                                        
                                                    
                                                    ${bill.price}
                                                
                                            
                                        
                                        
                                            
                                                
                                                
                                                    
                                                    
                                                    
                                                    
                                                
                                            
                                            
                                                
                                                    
                                                    
                                                        
                                                    
                                                
                                                
                                                    
                                                        
                                                    
                                                    ${bill.chargeMoney}
                                                
                                            
                                        
                                        
                                            
                                                
                                                
                                                    
                                                    
                                                    
                                                    
                                                
                                            
                                            
                                                
                                                    
                                                    
                                                        
                                                    
                                                
                                                
                                                    
                                                        
                                                    
                                                    ${bill.unpayMoney}
                                                
                                            
                                        
                                    
                                
                                    
                                        
                                            
                                            
                                        
                                        
                                            
                                                
                                                
                                                
                                                    
                                                    
                                                    
                                                    
                                                
                                            
                                            
                                                
                                                    
                                                        
                                                    
                                                    
                                                    
                                                        
                                                    
                                                
                                                
                                                    
                                                        
                                                    
                                                    合计大写：（人民币）${fee.totalMoneyChinese}
                                                
                                            
                                        
                                        
                                            
                                                
                                                
                                                    
                                                    
                                                    
                                                    
                                                
                                            
                                            
                                                
                                                    
                                                    
                                                        
                                                    
                                                
                                                
                                                    
                                                        
                                                    
                                                    合计：${fee.totalMoney}
                                                
                                            
                                        
                                    
                                
                                
                                    
                                        
                                            
                                        
                                    
                                
                                
                                    
                                        
                                        
                                            
                                        
                                    
                                    
                                        
                                            
                                        
                                        
                                            
                                                
                                                
                                                    4848225
                                                
                                                
                                                    195580
                                                
                                                
                                                
                                                
                                                
                                                
                                                    
                                                
                                                
                                                    
                                                        
                                                            
                                                                
                                                                
                                                            
                                                            
                                                                
                                                                    
                                                                        
                                                                            
                                                                        
                                                                    
                                                                
                                                                
                                                                    
                                                                
                                                            
                                                            
                                                                
                                                                    
                                                                    
                                                                
                                                                
                                                                    
                                                                
                                                            
                                                        
                                                    
                                                
                                                
                                                    0
                                                
                                                
                                                    0
                                                
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                        
                                        
                                            
                                                
                                                
                                                
                                                
                                                    
                                                
                                                
                                                    
                                                        
                                                            
                                                                
                                                                
                                                                    
                                                                
                                                            
                                                            
                                                                
                                                                    
                                                                        
                                                                            
                                                                        
                                                                    
                                                                
                                                                
                                                                
                                                                    
                                                                
                                                            
                                                            
                                                                
                                                                    
                                                                    
                                                                
                                                                
                                                                    
                                                                
                                                                
                                                                
                                                                    
                                                                
                                                            
                                                        
                                                    
                                                
                                            
                                        
                                    
                                    
                                        
                                            
                                        
                                        
                                    
                                    
                                        
                                            
                                        
                                        
                                    
                                    
                                        
                                            
                                        
                                        
                                    
                                    
                                        
                                            
                                        
                                        
                                    
                                    
                                        
                                            
                                        
                                        
                                    
                                    
                                        
                                            
                                        
                                        
                                    
                                    
                                        
                                            
                                        
                                        
                                    
                                    
                                        
                                            
                                        
                                        
                                    
                                    
                                        
                                            
                                        
                                        
                                    
                                    
                                        
                                            
                                        
                                        
                                    
                                    
                                        
                                            
                                        
                                        
                                    
                                    
                                        
                                            
                                        
                                               
                                    
                                    
                                    
                                    
                                        
                                            
                                        
                                        单位名称：
                                    
                                    
                                        
                                            
                                        
                                         (
                                    
                                    
                                        
                                            
                                        
                                        盖章
                                    
                                    
                                        
                                            
                                        
                                        )
                                    
                                    
                                        
                                            
                                        
                                         
                                    
                                
                                
                                    
                                        
                                            
                                        
                                    
                                    
                                        
                                            
                                        
                                        下载APP 缴费更方便
                                    
                                    
                                        
                                            
                                        
                                        
                                    
                                    
                                        
                                            
                                        
                                        
                                    
                                
                                
                                    
                                        
                                            
                                        
                                    
                                
                            
                        
                    
                    
                        
                            
                                
                            
                        
                    
                    
                        
                            
                                
                            
                        
                    
                    
                        
                            
                                
                            
                        
                    
                    
                        
                            
                                
                            
                        
                    
                    
                        
                            
                                
                            
                        
                    
                    
                        
                            
                                
                            
                        
                    
                    
                        
                            
                                
                            
                        
                    
                    
                        
                            
                                
                            
                        
                    
                    
                        
                            
                                
                            
                        
                    
                    
                        
                            
                                
                            
                        
                    
                    
                        
                            
                                
                            
                        
                    
                    
                        
                            
                                
                            
                        
                    
                    
                        
                            
                                
                            
                        
                    
                    
                        
                            
                                
                            
                        
                    
                    
                        
                            
                                
                            
                        
                    
                    
                        
                            
                                
                            
                        
                    
                    
                        
                            
                                
                            
                        
                    
                    
                        
                            
                                
                            
                        
                    
                    
                        
                            
                                
                            
                        
                    
                    
                        
                            
                                
                            
                        
                    
                    
                        
                            
                                
                            
                        
                    
                    
                        
                            
                                
                            
                        
                    
                    
                        
                        
                        
                        
                    
					# fee_index中fee是上面集合遍历时指定的别名
					**<#if fee_index?if_exists+1%2 ==0>**
					****
        
        
                
            
        
    
    
        
            
                
                    
                        
                            
                        
                    
                
                
                    
                        
                            
                        
                    
                
            
        
    
    
        
            
                
                    
                        
                            
                        
                    
                
                
                    
                        
                            
                        
                    
                
            
        
    
    
        iVBORw0KGgoAAAANSUhEUgAAAL4AAAC6CAIAAAHogFBKAAAAAXNSR0IArs4c6QAAAARnQU1BAACx
            jwv8YQUAAAAJcEhZcwAAIdUAACHVAQSctJ0AAHARSURBVHhe7d0HuFbFtT/+3ORnqtEoiRoLlqhg
            7CV6RaPR2LADdlGj2DGoYEVQRLBhwYax965YIgI2sKIRFAtibGBH1NhSNTfv/7P32mfY5y2HcxBM
            7v/yfd5nP/OuWbNmzZo1a9bs/ZZvVLr0qmzf9CqXG73q8nfp9Y3K1gfPllch6L/+67++UUKlUikX
            XGGrrbZ69dVXEyWvz5DV1RX0z3/+8//9v/8377zzzjPPPNHg1FNPVSBomWWW8VbtP/7xj3/961/K
            rg0FAdYQAVtuuSVBJ5100u9///ugqGooSOcaB5S/+93v/uhHP/re97631FJLde7c+cgjjwxBkydP
            /uSTT7744guCCu68yxmClD/44APXdu3aKbz33nvt27dX+Oijj2hE0Pe///0f/vCHU6ZM+ctf/rLQ
            Qgu98847OGnkWi0IVKyyyiqrrrqq65dffumKQtChhx46ceJE5bvvvnuttdZaffXVgx8DZKUk6NJL
            L73kkktQ9tlnHwXXvffem+F+8IMfPPPMM2ph9OjRlOrRo4daQ0MhWrmZIG28VdG/f///+Z//UfCW
            UgMGDNh5550Z+4EHHvjjH/84dOjQQYMG4VHFzMcff3xwzhB0TY6rc6jbddddXa+44oo///nPwVDZ
            tmfv3r2jM1JopIB59913byZo0qRJ2ftKRYFGxVxA10Mr//iicsYVlROHmbVNNtnkxRdfXHnllc3s
            CjmKhkmQudCDKxBk4v/6178Wgv44tXL+dcZ522238WxsyK6UxYyzmSDUBDPtypXmm2++yvnXZwx7
            9XVFf/311/kEV9LWW9fPP/+8mSBjMfIYP424nAKGJZZYYuutt+ZHqkwIe1MB83e+8x0M3/rWt0LB
            GYKUkSBcnqCsOkc4JM+Ot9EyccbbGYJQAZU6YFI+++wzb9944420xMCiNeriTS4CczNB2Zsm8eoo
            n1ijEGuNsQ2NvmYt6KFXtaBARAJhRHnxxRdX5pCuUaugGypHuVqQxn/PEQ3MCEHeGpr1RdDJJ58s
            HqGY8m9/+9smS1khkwJlQUQEBJDp06e/+eab77///vPPP6/zmDXWsfqFPWWeQRecUC3I1AImNlJY
            brnllGP6xIrDDjvMAqYFG3Xo0EFVQjNBlRdeadVr0qvZKwpl+gxBX/n1jeodqqqcXoilXWwGPV4n
            nD+bNDrunFxQk9dBlNnYddlll33kkUe22267zJw53ZVnxMQlNBNkpjJSDgWCYi8IQWeccYbyyy+/
            rKq8RAItCXL98MMPc7ZCx1/96lc/+9nPFAj65je/mdcUaCaI1weUqcN9p02bRoUxY8bccssthx9+
            +K9//WuCLFquSFDBnaOZIMhkVyp82pUHMoSIY2i33357v3791CKSFZpi+/GPf+xarRHPtnMlcXau
            Rx99NDz4448/FvZtZ8p/+9vfnnzySX3giV0va1UWFIvYVmWfUu262267devWzeZjXOi21gMPPPCU
            U065+OKLMUBq1UwQY9ut7GLKmLKRVyrennDCCTFrUWVcCoAHP0GZxCqNYpMKqLZEs5C0/W8zBtvM
            O9M+/fRTNrJfMjYerYK5mSAtA/YpVxQQNLLaQRdl+1rOFmEEdIzzhRdeyPa1siAQH0KEa4RH05/V
            3vVg5YFxCksvvbQdkR9RNusz3wddmwlSDbGjucYSyWZH7baHVPY81hjRDW3BBRekjnJCM0GMHbrE
            bsXYCjTiBPzIxGUK5LV6Et4U8NeZtXKo9TZmDcIhCYq3NCIoLZEgVgsK8cFBkKvV36lTp6DAK6+8
            4mosrjGC4G8mqCA1FcphRAFi0Sa26NU1e1slqIzgZqMII95KtFBiaFHrGmgmiKpMqAAKuBVMtqFJ
            ImL/khlZ/TE0PK7FvlYlKJOdw1Zljueff37LkqBrr72WsWkkv5LQhCA8rvCnP/2pmaCXXnop9jVl
            1TrnfmKQbfK+++5D6dq1q4LaSG+DWaus5xmCYm+KPatqw6q7i1W9Zgj66q/ZJmh2vZop9O9FXYWs
            t7SEAubZFT3egsySj0VZEoZBrmpZy6CCCBIy9IRwbgs9TgtFxMhRLDFoQaFcSAaUuIZCEViSQrF9
            QygU5SqIFqJuKBRADCUCM1dI8IjQHgjuUEjZCrVXGqtCKLTeeuthSwrJoAUbSTSiCGT96FIZP/NE
            9yJrJjqHMkpDhRLixJIKzCZtoKtI/vbbbzvpRq3VLA4gOvyYMvFBgqAJOFDbZ4zEXsRCKDFlWgUD
            pHImq5FCDCAGgYK3Ao0RhIV0HERbtukbP378YostNnLkSFMmnT/qqKMkFwMHDsR244034jR6J+x3
            3313kUUWkbEssMACIZmd1Gb2zAMZStZxI4XYOa5RELY0I8IEBZ5++mkiFO69915VTmxOvldddVU0
            SaCWWmzc6Oc///nkyZOVWdqVNJIVsJHvmnVcVyGW0Gb77bd3bL311lujgB4biPLw4cO95ddSJnMn
            fZKrop9zzjkrrrjiSiut1KVLl2effZYnyaMOOOAAEkzTLrvscvPNN6sKjwmxMU69wEwU2iOHBlde
            eaUCuisbXH755Ri6d+/urTRu4YUXRrznnnt40plnnrnGGmvICm0wGvLr9957j/b77bcfU8nt+G/4
            kCYhc88996SQLlAaKmTXgyi4Em1DdWVeV6LZHxzV6a1Q2eOYrOETz1Z2OLxy9tWV7kdXdjwcxSrL
            +qhUpk6dan3JwvA7vJodV0jyAxlr6FCl0E9/+lMTwQfDE7G6ohOnjGihRf4AtMxuTlw/ovL5nysv
            vFqZ/qfsddplRPFfDf/whz+YI8vNKtOWPZyjk9i4IkYXhQ5VCv0wB1awXKWuQdFMmYV4j8ISSywx
            QyENBfdPPsuywr2Oc+ZAobcTs2kKA1NIfmBlaQvaxhXUFuXQoUqhgI7jitsVDBR0E3keA3hrgWy6
            6aaVcROzfDm9bhnVs2fPO++806QEs6suTRw5sXWA5rpwDeFZry0oFNAsXQNp60Bk/CCCIJTOlQF7
            WeZhuS9m/efZY+jH2OgKOWPhRlmprkIWUXAEmjUoJckg14v4EelpWSFL7K677lKgjWkt72VxLyZ0
            CiThDRUK/41mUUAPYhicb4k9RJsyzpTyZXD6Ou6442SX2kIyT3G7rCmJRimX4+1MFArW1ABdmYVY
            PiiB8G5TVrxv2lyThVAcmJQhpqwusupGChUsJWTcOeiaruUps5cZbtzjAhbCY32JNwqqbMD4KRQ2
            RnGNkUMmGhoplPgAJa5srhDmcbb/61//SqirBM05YMSIEWbQbq8/9rBq7BI4bXMcCIVCtvRkoTiX
            ogcybaAFhUQqsDOgaOmqe5HN3p6mzPQ98cQT2Cyo0aNHS06s9oMOOkjKYb6Eg1hla6+9tmC95JJL
            RiubDGJEXXuLLqKMWF+hdWvAAOi0jLfrr7++t0LcL3/5SwVC999/fwWwJQXPU0891bt3b4W33noL
            nUspMxtReX01onk9hf4TXplCtffqqii1d/Vqm7T8Cv5WyPnPMs9/pja79Cl86t+CQ0+t1sbijAVZ
            hnX73//93woSK63SnQWw/lGibOnlUjNErCtvdt46iii8+OKLOXszZBlcXW2syWgf2HbbbUObOF0E
            dFM8K2pSRSE2k0BoUwaiJs4Ccfsj2AK//e1vW9LmueeeCxGOVKEN6QShONOwjeAbA4XUcUTzMjEl
            OhAnp6SN7oN+wQUXtFmbsI1TC210lmwTbKBcd7+DuPmU6Zhj9mgTlNAG2CYogSCmcromeGsA7No2
            bTbccMP8WF1g6623LtuGARxMZZzRgatNMbJMVbFBJm2ojkKIslY2UWXaSOxz2QUOOeSQhtqYhSrQ
            xg7lqOuYJz1t166dHThuDquN3TSuSQ/0VEt110gBwjaZ0Oaorw0RAZMdnqFjshRs4wTJFqQTCy64
            YNRCnEDi6q1r3BuARHfl49OmTaMNHrYMBmkrOQpZF420sRYGDhx4xBFHKMfxlmGY1LpwIjNKjVle
            bTzMCT1ihbOct6Cw0EILobCNq0OjMVCLKH6pVgbC5LIRLtjQNnqSvliK0iiGof7mm29OeviNLCKi
            HBEoQXdF0UQ5CkGPt7RXWHzxxbVVBQ7RBnzhhRdiGzJkyKGHHjpy5Mj62jz44IP8wwgOO+wwa+rg
            gw+WT0kxeYzTwiqrrOLcNHHixNVXXz0e0AQ0jFu3rs8880wQubC3Osb5+OOPO8xjC4wdOxbR4lp0
            0UVPP/10k1VfG83kvJdeeqkUeNCgQU7KG2+8MSIHd0YJOK2xtkL0Sldl/FWIWrZUu+qqq7oSwiPN
            mo5owAfOPPNM2dn9999fRxscsl3eoHsNnn32WRbaZ599hg4damqkvcp77723K4VcdeatyKt8ySWX
            GENAW9ff/OY3GOKTGRdddNGee+4Za4rTmBrp4q9//WtX6Sz+OtpE9JPPHnvssbfddhvbnHvuue+8
            884xxxxjHdLp1ltvNThtd9ppJ1f6ueJE33777fXtCvRz5fiuO+64Ix5Xlthtt91ow3/FGEGPNqZV
            czlyQ200fvTRR7HKW48//vjJkyejhG9C9lAgx4knnjhgwADX/v37o6d9Kp6zKdBGwbIICrZTTjmF
            NtzlpZde8vbyyy+X3mvVMPrRRn7PqmusscZmm23G4SdMmEDWFVdcwaomiFX22GOP7t27kxK3jFjC
            FRElrlGgzdVXX80e3t5www0R/awvc+ec+vDDD7O99attdqKo1cZ6MYtGT8o111wj6vAyrmOVUmL3
            3XdPh6PLLrvMda+99qpceUfRPL32Oo5naJ5bMItGsO+++4Y2loW9z+nHOdDUx7NFA66jDY+xQJiE
            0w0ePJgqP/nJT+wvt9xyS0TVSZMmsR8Yt+sH06cXbUc9Wtm5T+VPn2bXrQ++dXD2WDtgajR87bXX
            NLESRTwNr7vuOlaPxztQf6Z4qLkUb+ghFrsOGzaMBmJg+E3awwPnDh2aNezRr/Lw+MoZVxZ3d7Y+
            eHjvfmp5zAorrMCfSLBaLXJW79Chg3lhD9Gva9euqkAwq6ONSGDTfuihh/r06XPyySezB9uOGjWK
            aNoIWVxkueWWy7aVHMf36581lI/SJm7FeeXaOEfa2iwWA1Cmk1hMG55n3u13BNo0zHjfvn2zLmq1
            YUyN2VObo446yqHf8ouEIRo7SxNKp2ba7HpkZexTlTfeqdzzcGX/E1BoY1cRFPBEJqTAbyih3L59
            e2J5Nx77lL7qz5TZZQ+Ooo2+RUkBA2XcuHGMych2DKNksNjDC20uu63y8ITKxbdmNwb/8tfKNgd/
            8eATajP7N3mxpcS1rRIw70YYEqzw0047LRtwXdtgTeA3t99+u4KDNxVFKlZxoCedkciyBxVtvXY8
            PDPMdtnT+fPPGorfMPDMM888JGjl6q3opQoEcXui6NqrVy8bQB1tcIMNwX5pM5MkAEs+8sgj1GcV
            UmKscQNLlRhXOf+GGTcoz7qq8mn2UBe/K4a42m1cF1hggVhitkIjJ9CufPbZZyvU0cba22ijjdRh
            pY1mw4cPDz0Icp4y8eRmhs2BodCpKb8pa8BvcDKJt/yXA8mKOnbsiEi+kLbJJpuYqXPOOSeT1cg2
            Adqw0DbbbCMTDUr5zBB6JHibja8JJjQxKEC4mgLnQ+S28Rggdoasi7ramMu8eYE77rjDmo8tHdgm
            7VMJ2FyTbXLaDORiMmJoA3FmSNo0tI2ZigaBsI1CaJNsE0CPpZ7zNrONt67CkkL5PGUkyrSJt9CS
            NqQ/8MADK664ooKFRxuFsI148/zzz4dtYqYgZoQe8bYKoY1IEWwBM2WHsk/lymRzOpPTnTWlmXBs
            hSuE3yRtUCxsLhl9qHJNCKIrOrYgQlBAQVSjjQKE39TXJhpA6ME2xfum/MZM8cdMfA7iVBVvmhAU
            14jFMVNaKbMr24Q2EgkpFOLMT74Rb+QS4TcgmIbflLUB4qB4kyPeuqaZyllmeHEtZmKbKqSTbzRO
            u6ZyXKHsPVEbCEr4b1gIdB/0OIfXX+FVayqQ4o3+TE1cvVUVbxVcgxII5pipqDLRwiBtxOJlllmG
            NrLHeKjb0go3UwKlyQZBM+5RYPZW3mPPIzdskxZLXE0iSsxLUEJIULxVcDQLou1PGokiy1GboQW/
            0Rh4T2ijJ4JiZwA66U8+QAg25bhr7y0iJIqrhuiuH330USY0f6RCj1133TWYi3lvvTY2FEZ+6qmn
            JKYyN3uQLAclOtB3uEUoFwUUKYQCh0t0emjl5GumKGQPFinOOuusLBdopI2plQBI2Pr165dmSvfr
            rLNOeU3FgwKgjWtQXJWjoBU4gXtrGChyDBkSY9x0000yCjrZwK3c+rkfbdZee+0/lmBLD224yz33
            3INiZJJRo3SlB4orhuWXX15/gBIfH3bUReclynIj+b+CbcFWaMwiiOGZr4ZebBbiYUQZ0mTMcdgD
            TuMtcZmI/FlJaBPlgHKnTp3iKYlZQNl0003ZNWqrcOONN2aNq7Xpdlj1x7riVfvRrxY+DNby58TK
            tVWc+2UJdUmb/4zXXG3+t7z+4x7g/Ue96linS6/KdXc3e13fdI1XFb2qqupavEYUlHg1qx0xg1Ku
            zQpa5bWJmK4hMArB0Kw2pxeFptrEk2oTJRXik0fpVcc6efJlz7s8xxVXXBGFMsrE7LPk+Yca4q0q
            e2oWZPNbbtddd13Qy7jllltSHLeXFdTLL7///vsTvRayomDTRXZrtzkkuKGVQqRWYAtPTaJQRpk4
            derUrEHTxlC8GlnHTmqLtCdKjH7XAPERs9he4+mRNAE97v8D69Bg6NChciw5z7nnnhsNb7jhBlZg
            xP33399JSUMpHbotdb/99is+F9cc+OX4OIFiO+20k7ZlDBs2LIQreCvRlTXG8d/xPapqYXT2XjxZ
            jg5tso6W5uGNN96Q0O6+++4OrgoQtxvlQeSGdWQejvx77bVXcCrIaOhntMrm89JLL91zzz2zW5hN
            +PzzzzWJW72LLbaYhjI9nCeeeKJydkOlhGSdIUOGmOpIncqQgYMu4uuDMjKJRFhHQqP5hAkTMtVz
            9aLAGdHZEc+sWyflqQlxCCxbxwkS88iRIyVW7du3d3iQ3Gj7yCOPSPNkcJtvvjltxowZg/mtt97C
            HFh11VUJkYVpaDJRDAZFphYMgQ033FCaG5wbbLBB5OAmafTo0RJcZaZhDvLJAf3y3LJ1jF+5DGep
            r8k6sbIWXXRRaTHThHWy/vL1ZVU71DtXqV1iiSUiqy5jyy23xGmEOI855piC+o1vHHHEESgSRuWI
            DppHFZCjR3oqaxvdOeIuueSSTqZVvjOnrKPjZ5tDKMVTa53HHntMbUz+iiuuuNpqq8VNUYWOHTsS
            6DSEoawo35k4cWI8xIrvY8SNz0B8zZMayjGAyZMnWyOMgmIryNXJYA70pSNwSIgPtJato7ZgbYID
            zVeyjmbG0whqIVkHf5zuzBvfEVZM44ILLujoqfD+++873VkFGOJJIC8QmB5++GGixGZ0Z2RC+Au6
            kxeeWus4MDkBOznhUbbEHGHRHd9EXx199tln88wzj36T70AoXBfB0Dbr6PuD1sGZDr+ZMRUGTK0n
            n3zSeZXbi532e0FdYamllnrnnXdiOwvh1lo8qqZcjGfeeedVjq9aWLzKYR37d+ooTo5OoPjjqRWj
            KItlNkG+wEDoEZXbOorWWqcWcVMunuUH4n5Y+A7QLMGGZYbVgjFTNOjBGQgK38HTuXNn5eHDhyuX
            rVMXJpxr4xfI4nlCLim7ZcFngyesEx29mn+1vAwHavxxLzJQjGIWrBN3ScMJy9ZhAhMl+mR3e77z
            HQsnVpZQ8oMf/EBZYA5QxcRaYvExESsLPy9Qjs/rRlSOlRXWIVzDo48+Olc+A9uFNBBl8JBgqcbK
            4kE81LJio/ApVaHYsssuS89oGM9GMaCfd9556DPu10KbrGNrJEikpE3gtNNOM4C0Z0VsCpTjTrw1
            sXTNJWUfzmG+oEPeIitHIawjjuri1FNPReeqiWI7D+YAsdwhapnm+9//PqKlrQtVIhGvyZWdAczG
            H82jx4C3Z599Ngai8LTZOtpLZJVjZQXCOjyC0Eh27Vbe5o2aLTFvzSeHFxqMJIhiashJKPtOQWoF
            4mZWyGSjWE3KmRI1CLZAPIo+//zz6T8re1YCWUWp1EG8Tffh4fHHH9dTPB5oEzp16qQh5ZS32247
            5aKPBoioHGAd0TQyQ1tkbdwp7+ihs1wcZeONN9ZRrCkHnVTbWuvUZoPhL4HwozvuuKN435TvBOIz
            nlWIlVW1o0dVQiPfiW8OxEmCYkJS+gpBijvhOxEK056VdnTQHFtYJ6Jy3mdzzIJ1omHtyqras3BW
            +Y6ZTHGnESIqB8J34ssC8SsEbUL4jjmIQAONcuWvumeVrUNQgqhcyMt9J4j4XelUa53IQRLsGkVd
            E6ws9PhWB+sQcsoppyg7baL37ds358pgALmMLF0I3xG/CIyVBY18h3ViFKFnQLlsnbbFnbJ1JN2F
            jCbU+k45VwZa2jKDuRa22NAvw8efVSZMyr7q9sSz/3zs6b8//NTfH/pDcX1k/GcTJ4+65574kZUA
            xYqGTZlhoHzOStYJymuvvYahvLLEnRkKlNFK62hsGgMMlChRjlUmTKBEOGAaUEjwlpYJTtj0FkTj
            7aabbvqvkQ/P6HTbnpVtehbl7X6bfesgVXntesQJ/foV01sCK6dOFaQ84Tt8VplbiYDRHdAz6Z8+
            PpUwK74TLcs7emSD5RgUsKPrOK0s+lEu668RaBlf/4vXG+9kH4W6fHjl1nubvS6+JRiG965jHUh7
            VvKdgBgk9+nQoUPykYg73bt3V661TtviDqFGa7NgI9ZRFiaVWSfKJPId5dR9rXVUJQRPwJ6VfQYq
            rLNP/+wDP/DQ+EqvUypHnFE58ozsesSQ7HXI4NCKde68805dAIuIO5QxhSEc0bUclcM6yy+/vCps
            VJJSKV955ZXKG220ER5NdJuaZzrMQtwp7+jlqBygdCa3ZJ20o/NzFKcHhaAEmlnH9cNPskdtY5/K
            nu9dcXvllnsrZ12Zfdf26rsqb74XWrFOdAdMELkytOw7wd8IskFG6dWrl3LbVhbTWsCBp556KsTB
            YYcdhsJ3TJGDTzCA0zDrOOmgx5IUleO0FaK4EoZMgyrreAk6H36craz3P6ocfNIMTc6+OuPe/Sjl
            O488Ie6lrrDCCsTG/aCqqBwdsUs8C0/gQaygufLee++dycwRe1a4W3GjtpXWMTnaZGe4euBH9LBn
            Fe+/852xY8dmRsphJRpArCzX6dOn00CYpLdawlln4IknirVFj116VU67tHLZ8Mq0Dyt//Xvlnfcr
            706v/P0f2ecNBw4Lni/HvxDCAwxBTlgnFJBtvvfee/rlrVEL5qNo0ITYyMyl8sEHH6zhWWedpVw0
            aaV1yuC90pb4XCBByoMGDaLWjTfeqBywko0/MHnyZHZBfP/99+P2DXAoenMuQiin9kuKCjRVvde+
            tj3kf158zfwbOeF2n29961tPP/00CUsttZTl88477ygvssgikm89KgOfpUM5V44Z2m+//ShgLpXP
            PfdcNj300EOV77nnnmyorbQOG0sTdKwPo5VQnWi2808PFr194xsLL7wwemD8+PE4OTynY82U7yy5
            5JLBsPrqq6ddrHySYG5N4lasjcOiOPbYY5WPOuooAeXoo49WG8eUSy65RFkrZRlQiGWgWMhWVkRl
            b9H570svvTRmzJhgg33yn1R0lCckxhUrq/jARaCV1nnzzTd//vOf77XXXilYBMI6P/7xj9Vee+21
            zz//fHrwhnPttddGv/feeydOnLhKDgd0niJO44QI2FOnTsXG3ZSfeeYZ5d13312tVE1Zlowu/CuX
            EW5oNa288srxrVa5MieK6Cs4AqOolb6OGzeOi5V3dHbRxYUXXkiUcSXrmAx0tRlTm1YWF2X+9BgE
            DjjgABJ32GEH5R49emy44YYXXXSRcsqSYc899zRyNuLAfNCsOtfgBIWCqQkaak6I/XH//fdXjmzY
            VTketILB8CY8b7/9dlCgHJXXX399e3Zkg1ZfEDkaISyFOfKd+CxpIKwjpST20UcfzUittI4o4xh1
            0kkn5b1UQ7qx7bbbnnfeeXh+8YtfoKRPxcL9999vO8u+MbL99hGtEgQ/TeL3mwJxCl1rrbXQOTmx
            V1xxBbp1pByf7MGjVtDNW2ROyvQou+2229Zbbx22SDu69eu81rlz51hxYFkx7pNPPmkbkccGG8z6
            yvrggw8kAl27dtXeOlL+7W9/67reeuuhRO5jwhGtfJS4vzNs2LCzzz5bLU4FHZtJYUj88xYiyY5z
            FmceOnSoFYQ5jmwrrrgiCrZ0jQJ+tQKqsuDCQeIU2q9fP5RQzNaTmoCjLKs5bakSd1HkrrkBZuDm
            m29WK55qKBhlpFZaRzDnydakbkA5cPzxx5966qkkipdBGThwIAaBgHVSNhhR2exRHQ+G/v37CwQ0
            1nzw4MGIJKRyt27dNCzDsUgrK1SZXZQxg8WerAMEmozoQq1ruXDxxRcbS/kUWgYHP/LII9dcc021
            bcsGOaoVG987EFmVww+t5A022IDQFI+kM5ncUq68xhprGJXlY4nZgxjll7/85brrrhtLQPSx4jSM
            xVi+v1OG8evINOhFIFMO/l122YVwAyNBlSUWUVncsZoYLtcliwwO4qIM/cvWGTVqFFFyWnRBnYT4
            eYe2WceeR5zpJUVotLz5kR03vgMXK2vAgAF4yrjtttt0Ew+LrX+68m38VWAyzPGJA06qSfz2cC1q
            n/Y5+jm77LzzztGjJWnJUEytkZshCxlxs80247lSJDzmQ3OplrJtVLldu3Z56wwRGdpmHX3IF954
            4w1lsUN52rRpygYj/Ymy7UM5sOqqq9Imdi5bpv4Ei+WWW46/sIUtM9jIcR09ejSGyHcmTJgg04sn
            v3Y0+VufPn2UA4ah9pZbbtEqBfhwB5T27dvjsXPh+ctf/iK3cM6IIGX7r+r0d7/7XS5yBuLbgPxL
            uW3Wief5vGCm4Nv4JalSpMjHbS7MCijAiKY06ztPMjVZZ5111HJPlFhZFguKrcDIRY1c+RngL9Ec
            OnXqJMPErExC1k2OsJF0VKppnuLul7QguiPW+Imyjqh0ww03KIsDap0ZNY+b0621TpzRLVELhB/V
            BbfUR3FnpATeK82NlWW/k6encKCVJrFn0enb3/62kITTYlGmOjuWrWPxaoKI3waPx2yjeEuaZG/e
            eedNd93xi0ERhsI6sdAUMIR1DIqQeHJpS1WbDmUZ2mSduINhD9J3GfYIPNTVR7IOTocdtfJXS4xR
            2IiQ8h0MoxLvYzyso3n5vjKlQzieAO1Tw5gMZ+NchQwx1GSd+eabT78c0HJWpfdgC8TJRlAvROef
            9wnhMzAL1mnN53cMEn/Uph3daMUpGpvPdOcUW3wmvWwd0JGdCCU9R8cZiJWFAexlxNpu4i1oq9b4
            tQ3+TIkSxF0Owj3jbfAkzEo22FbrGLbBB6ws/iJtk+/ZKWLSQAEdA/PF7RHEsI4jMkositpPGcTz
            LHkAnkmTJpEQyyEOX+WVlcCPBOlcnWxKMMTK2nXXXVF0pywJ1FZCSCznxTMr1sma1UPtyqITShw1
            odGOHnEneMqofdoXO3psyQGKBXPAyNO9wTijB1tAnNaRPFjZwsRffiYRGZw0OkRlaJN1sh5mhrJ1
            IhtMoCuN6QGWWHhHvMVfXlkhAZTr7lnoEXeA2CLxL1kHzIT54A6RdrYSs7Ky/o9i5taZ+0qvudZp
            6ZVZp+anz+r8KppCXWKjQu2rXFXL1vraFl6JrbaQXiitZOvaq/LO+3N9p8Frm56Vt+dap9FrrnVa
            es21Tkuv+ta5+q7i21zpm13Z1728mr4PlmpnVDXVlquK2iZ6uTajp1eJodkruit1WnVt1GNc41VF
            zwqNBV57VzM71LfO34pj8f85fPllMzu0YJ2RI0deXvr2W/lrcIFEcYD44IMPoozoYJFOBlOmTAk6
            lCWkZy9wyy23pKqqxztlOB8EDxQnxhKckwkJOXFTDahx6623JuEJiZIK119/fXacbL11fv3rXxfn
            kBbxrW99i9xnmn6VDtZcc82spxzppkEVHnvssWCApfMv5ATSwGrhmFYw5TfYC2oTnLaLum98Y+zY
            sUFkHafQgtoifvzjH3/JNG21TnyTsS7iyVTZOgvkXzC87bbbku84K6Jssskmart37563y8B3tBo0
            aND+++//wx/+0HE3vhR54IEHHnLIIXVuSjW3ziKLLJJ917GE4447LiTDoYceijJu3LhkHQf9oq4G
            5513HoZZtM5HTd9/rYXVhKFsnSWXXDLZpYwjjjhCbfyyX8I///nPeIgKztx/zp9k/vSnP/3+97//
            t3ofqStbpxYsEl27/vKXv0S5+uqrk3X+mP+xTl38Nf81l1m3jmH07t07fZcyvh1KaNk6VKfNRRdd
            FLWu559/PiHjx4/XZODAgWqPOuoo5eKDIPkwRowYgf6T/Bueu+yyi9pLLrlEFCBhr732qvKgsM5S
            Sy111VVXxb+OlRHWufLKKwlZaKGFUKqsYxQcUy3EWPbdd19dfFXraFZ+mB8QPsvWwU+V119/PWph
            1113RYy4c9ppp6mNX4ssP8ZGhKq4Q/J3vvOdeeaZJ+74JYR1BDVN4ktLZYR14hsPgSrrGEVMQ4IV
            zUm/Duu8kv/syjbbbPPAAw9YzOhhnffff//BBx885phj1LKL8pv5z7UflH/FNvC9733vm9/8Znzd
            dqutthJxhSFQKDhydMr/0WveeedVji/aLrfccroTYpTDOqxASODd/G8z/iOsU447f/jDH4wtrBOo
            jTvlL1VAOe4UpFZgrbXW0l3cSExxp4z/LOsoL7744rHsy9b505/+NHXqVMtebTxB/Hb+HemEZJ14
            uJpqv/vd7/LKJ598kuT55puPkLhzHsBGVNyrLUflLl266EWm859lnTLK1glE3KmLZB1QSM8wfvCD
            Hwicb731FoYF8//GKn/6tYyyderuWXPKOgb/0ksv5d9QngFbQK11rAtVN954o7IpXXnllcUXooYM
            GbLSSivJhtCtMjyqlAN2rhCIc6ONNvp5/tveUVVrHaEasxxX7QorrDBx4kRvQThni8GDB+tIwoUi
            ipetozxp0qRgDjz//PM6/UrWYQIi6mLatGkYytaJuGN6Y3hirTiNk0XSQ4LYsyLuYEN/+eWX8SBC
            xJ2gK9Rah3zMsmEM0iVDirauYM9CV6tMq2QdqzUYamERYJhF61DU+OsiBqBQ1zo777yz/u644w4M
            dnTlvffeG0+yjuaPP/44umUrgpSzQRrzEUGn7soi0NrR8IknnlCOZ9ZOEspDhw794osv1CqXV5a+
            UOoiRtFm62y22WZ0minECNbh4crLLLOMwVBatiLuUJR10FlHuUePHsqOJoSvt956LMI66PIdWn78
            8cfK8RheOCCnbB1lUSOsYzCaY9ZcWaaqzOiEOxawSDnuWKfoM4V+22adTz/91LKaKWJ500/ZYjbD
            VJ8+fbrQoLz99tujW1nKF154obJ1Tvgnn3wiFdpggw3QY/ZEpSjXWof/68XGl6xjPJiFVWXTo3zY
            YYeF8CrraIU+UwivmNtgnSpobEjAU4KiEJRMbg47rn2Xcqquu+46Km6xxRYYWAddmh9sAWPecMMN
            jTCClEKUy9aRKDJ09BIYM2YMZkbEjFOZnypbX9RgHTzxkyKsU/SUf0oumifQEHhAvFX4StbhHaEu
            QUFh8lBUN0HRQUJYJxAnCQi2QFDA0cnKMgDlqpVVtK8B98QsD1I+8sgjczGZcOf7YICydWTVBTWH
            OdCdgaTUoc1xJ0HH/NMORVbZOryxXbt25FojZpixwvkNLFZW1IJwgP7ZZ5+hx8qKT9ngVBZ3rJRy
            VA7rLLroopZMaA+mIQS6du7cGbOkHD0+sCGKEy7rURsf5Bg2bBhKwMkDHWLxss4bb7wxZcoU3UUX
            xM6idTTr2LFjmLlsHS5jGCbBJKuF+GTFhAkTUHbbbTe1gazjSsWBCE984MEZiihBRLmudchxFW5i
            qPCjH/0oF5YhzFq2zjnnnEO4nYv140TGH3OlMsh0oqFFFLm1PYGxvDWj3s6idbQ3yaussgqhsPDC
            C9tBzDztBY5wgQgcUN7Ru3XrpjZlwBC58qBBg9AdkfA4QyprlaxjA7a4+Gl0wfT0dvLUkHUQA9wQ
            s2mgkoiDcsYZZyjbEI1WLpIrOwOvvvoqacZCsre5stmB9r0cKHbbWbGOrYTqcuUsc/rnP6klvsa6
            ZZfw0ugMqrJB12233bYQ1GQdxKgtl5N1oguuZ25jA0KxCjAkfhD4MXNetU6hKPYsw5MNKkc2WAZO
            tQ6AavOeC3jLhYNBX222jhnjotJZ7W3YchniyGUdM8anwFtEBSmSPrhx0OHgg7P/jJPmS4iEzIK6
            yiq26ly9Ask62o4bN85q0qm+tJJnjh492jQUrDlWW201VbTS3WWXXUagbRFnnz59lPlUrnszMIEt
            Mu88A7uQ6UCzxhpraPhC/kNPs26d2LMK7XLrqKUcup6EvcL8ORQSvKW6JpdeemlB+te/ZuMdjOgu
            7rqLPrn4ZptjQlQBS5keeQD3FM41nMW4w7Riweuvv66xvFPcDbAOCqs5wpDOOnoVLFFqse++++I5
            +eSTi/cvv2zyUQLt27fXxXP5H9+svfbaRQcNsHjpa/thHVunhpIGtaJPLj5DpDA2JuX43CCYwlde
            eUWgMBaOw2WcRTV0ZGOyNlsnM3UDjxB3CjWbrFO+c9p6CJnMGqldHLVbQOxTgaq7X0Zele+ojXOW
            M3oMgZlEUs5udgVp25kFkQvOx9h669xzzz3Wgl2QUW+++WbLO/O9Jkh8L7roIoE20LNnz0suuSS+
            9udA5MCJ6JrgbSjKO5TjDtnWW2+tyj6iiwMOOEDZaUOnRLkGlK+//noMVoG3VpDmW265peacDmXA
            gAEoxx13nHLfvn0JseupLVuHBelvEZWtQ+B+++0nzyiGBK23TtXdL9GHuBAC1q18oTB5/u1FzIHy
            074yjEFt+Ywu2Y2qhLpxJ/57NN11x1a+6x75TjnulM9ZYR2gv6y1bJ28w+aYBeuYtwMPPLBr1648
            6LYct9566w477LDTTjspDB8+nC2sKQfOTTfdVBO5Q/C4xneGAueffz4ep3ZlSUqXLl1EBOVRo0Yl
            fjnkNttsE4mCAn5szEoHO72yXUkTW5uyWojj25133okimSKERyg7kSXrGAuKw81NN91kCYd1LOfb
            b789+r377ruzGZ0F6yhD7Z4VccdIkqfUxh0jjKoWUPXExuYlHNjULYSCo9WIJzbxM+uQrFN15zSs
            85XOWVXWMXsnnnjiMcccI09Dt85POOGE/v37H3/88W2yDk8RKcro168faZHvVVnHQjjppJOCTewo
            ROQ3A1AEPuN/5JFHlOnmGipl3AMGSIjK1qEkCWpDZ5Jnm3V0E6C6NCEkiju6REwM8RW6MsTdqEqI
            X6Asw57FMWPPevvtt81qWEdfVlM6Z4kXIUF3EXfsWRQ4Jf8po0CjuGMLz5vOUBVmj3V4jdW+xx57
            xI/zhroXX3yxXQARqCjZVxAgRAG46qqr0tck0eP5bBRWWGEFdJOMJ0BLXQgKyiTssssuVisoRBk/
            GAkJHI1uDkeYBTIqycjUbr755voVjwy7bB0xBWePHj1w2sKZwOaobC8Wd6655hq1Gt544410mBXr
            kNjCExvas075vrK2UL6/U4sZ0fqLLyovvxE/3OT1j/jJpuyVFf72xMQpz73Q8+CeyUaxZwXKuU/d
            JzbBBsstt9xs3rPuvfdeHRBn8GK7MksHlJl/r732UoDdd989EhDbvHIgvphdhgnUdosttlA21Tfc
            cEPlvQ+y31GnRJUC5VeXXv9z672nDB5MuObFL53kKFunQ4cOOh05cmSV7/B6dNEgrMNBbFv8hRvm
            ahawKbfNdxhFg4BuQAFRQS1dF1xwQW7FP00FbVyjkJAtjxJkaxoefvjhypbJm6++VtntyBmdbnvI
            jHKXXlUm+/OTE+V+mUlKYB2iUqfKKe4oMwH1WE0ZRH3rMcZiFPSPVoE2xx0hRuZiTTmGOK1ETx07
            dgyfJN1sYADSVTm/PPbYY9EZ2K2EW8QEy17D6dOnK2cHtycmzujxN8dV/vRJZc9js78+3P2o7Ld4
            rvl9VvbaNjPTFz36rbjiiplJSrCpESV10p2AJXv6OP/OrtCOLmmm29ixY5Maq6++uiBNjdlgnY03
            3jhasoKOI99J9warpNees2qfFFfj9vtn9NhzEF+tHHpK9Y9+ee11LIYvu/RaKf/tsVqkc1Y4dYId
            AN0hOd4avHxHOiKSsk5skQltto6cwhYQK7audX70ox854OKBuPnWeuv85je/+Uv6+Csl/vC8cFo5
            aGDlzCuzV/rTSq9dsj/SrLLOU089Ze+Tr+vU5kABq0Z54MCB6HFDtmwdSbxDua3g2WefFdeVn376
            6dA8EFt+G6yDm43j/o5sSnwJ6/DesL24U45EUGudEJIYEjbZZJPPr2n6c9PR+Scs8ex7fOkn0Zp+
            GG2Hw/CwjpVFVEA2LNzEGb3cRdwbjFw5rPPiiy+qFRyEHha0kRsRHplUtErNoQ3W6datm8Muu7z1
            1lv0cD7kTcZvMcchWB8K6KRnw2uyziqrrGLlRwiwieCJZxJlzLBOt0Mr//hH9iNWhBw3dMafi8br
            9bcj7rCOsyhRgc6dO7/77ru8xpBEYhR5kLKYgm6f1UVYx5JRa4KVF1pooYUXXjiiuIKQ6lwNGHjT
            rMSdlO/ogCCBMOXKAZ1VWad8Rr/rrrtQyoeAQDPfGXZjFoNsqHZ3jqN81R2Vo8/Kfj+OJii5deLH
            DgLlT+S2HHdaQNwbBOU2xx1OyBbGGdYhwsqSSska0K0sZfuXclIrrMOHYw3CVltthcGqDIaEZtax
            lx8wIPOdHv2yrm+7N/sj1iefrezUp/LBnypj/4CHdUwvUfHDB2Gd8ePH6yJy93I2uOGGG6KHvwRe
            eOEFS4kJMDvKkQMGMv/881MVQ5utwz/DtEyQjtFkEYoo6HBIfQQPU1LL0sMQ6oaNuuR/cy2i43FV
            DjSzjtcJF2RxZ8AFlZden0HcLv+P2j9OoSXr2I81ZBFi+bVyba5sGnTEOnjKsJ0b/OKLL85f4pEk
            pHMWBstWDG2DdaS/ZMG8885rqKEEeBtPgtgiGOC///u/KacDXQqK2GwoynQlqm/fvniuyH+RKdDM
            OuLuR59k1jn7qsqnn2cLijeJRw88kRHF7K0P/tcOh8Vt+ejCrCjXWkdmrKP77rsPTxmRBHKfCMa5
            CoV1QIEHYGiDdST70bguREQuyurx1lEw+dETTzyBLlUnJLwmvnd/4YUXKmcOnAv/8z0PFd1RwsoS
            bo4/PwvPn/658sa7lU8+r/zji8ozL2ZmYp3f9OWeufgMEXfDOlYQBRz9KdCrVy9lJ3i1YMDlVuBt
            WEfBIphvvvksrqC3zToamK5GaNeunTDJ5PGWoiJRYO2110bXnJC7774bJe7dyMSU40lxpuXnf46R
            N3s5Q+x6ZGW/4ys9+md/udxE/9t1v9ddLj6DEzIhYR2mp8AZZ5yBfvbZZyvHBIABr7zyytEkwBZW
            FgPRX3Ko/OGHH6Ivkf/vRxusk6APO2WkmGCrViZR4kC0MowbN06QDjjmYDO96I58BhAQKdXG7s6Z
            s4PFU89nwaWq99pX36GPPvSQ1a252SbKQib8gQceULamlFlH7VlnnZVpk4NH0Dzu7wS0ZZHI1yQi
            Ys20adNkABpKU2bROpott9xyYq3+eC/zp+1AIbDaaqtZRDghFvn111+PHslF4OKLL1ZLMzI7depk
            9WUPUuxKN96T58dXVM7Mk+O4RuHCmyoTJn34/nSRzhg0t2xDGuERDXWhbGVRQDaYaZPDgb5sHcwM
            QQJiDIrjmDDTnHRug3XIcj7QTGO7gHTTcmAdYS/1Zy8LxD+J0O+1116TPSrH/R0HjoJj6aWLf73M
            UX4m8cYbb2gVVltqqaXshjqy+zAHOAo43BqtmafP7bffTqzgUghdeun4iElE5bivzC/QL7roIvwc
            OdgkJWKlXpyoo7uIyiYp1yhH661jW6ETF81bZdB92TrUqvIX+Y4mv/jFL/Qd1pHvBAPE+ANl67C7
            kCReKBuYyQzr0JsEbJB3OMNf1ltvvULol1/GndOydcaMGYMuG8TvDBVsgMF6F3HEQZHxK1nHQVEC
            RkQ0DCTrdOzY0fHCKVSipdeotYtpYj9Cjx/MPOCAA9Atb5SAUIWy8847Ozd5q+yIqDxx4kRvWc32
            ZwzsLsEhISE+v2U8yrvvvruGRqhJ3Khmi+eee86Ornb48OHo8ZMi6YxOSWWnUPJ1ZyBhHRODuc2n
            0LpI1qFZ+c5pUZ0jPqFSPqPHpwwC8bSvCmzBZdSyb0GqQflpX6Cc7wTi7pdMunjf4A5GUMI6wdbm
            XDkgd+CoEF9ccaoUyYi75557RowYIR796le/sndQNHkQhRB79uyplblCGTZsGM5AOfoEHn/8cRJs
            0mqdyyST1imLjx07NsrBZo8jNn7/N1C2jg1I8/grybhzGhCbqW0uG1nHRGq47bbbZh211Tq27aKf
            GsSTYr3qIO5+FW1yRNxp5dO+8idUynFHUK89oyWUrRNxB7HKOoH0tK/WOrMYdx599NE77rij6h5g
            glW94447YrDIq6xjp0SXejDNgAEDgpggOqiN6BNgHcuTT92Z/8aiIwiLWGsKoGA5qyrfb9eckPiZ
            2HgEVLbOkUceic6bQlVgHa4hNnXt2tVhIoR8JeukO6d1keJOoGwdU1oVd8qIINqm7xSXvwkQSE/7
            dNqaOxhZYlWDr2QdSa0NkisaqkOTslPMQQcdFEdw1gGU2ETDOtJQB4XTTz8d0clTXh8/emUw6N66
            WuT4WUdk4S8ovXv3FqTitBE/V4sIqcAB6WAYKBZsCMTszI1ywgkn6O64447jrcEfEL/xhOYyaQE7
            Fm+C9atrQyBEctS2uGO0kO6cxlsdpD0rKDw/rax090tP5bhT3rMCrIMnvlP8yiuvWEoR7GeK2LPC
            OoH4NDfTFO+b48UXX1SbnvZlVmlCpn2ewWFr857FnEcdddTJJ58s3Uo/FkwVngzxNoDhsssu01P5
            3mBYh1oYTL4mFgKKgKV8zDHHoA8aNEhbZeYL30kQiQYOHMiVFMzH4MGD825PjdsgZes49BLVv39/
            taRBcEYhAlxd6/CdY489lvsQ0mbrxJNiIVazuDcIZtjOyhApWpfznVrfCcQ3AfZu+gaScjlXLsed
            BOuXn4qgCuIr59IKsyuUrRMQd6gRPIHgBOWydRLxK+U7zzzzjITFwtGrs5+UhKKGJIvfYIMNRo8e
            nadBWR4UnUFYx4kRwyGHHKLWBKI4AQs3i+T36hlarTREbXZMb2AdkNTZGe677z7BS6azZf7XdZIp
            zUVc/eb9j4nvFItB6PKdXJEMJ510klYOccrJOoZDDk4namX51KhRozSfxWwwgSxxMVc7g7hTVJQQ
            1gnEnmXfLd43R6M9qwqR75T3LIk4eu1d94DQW1CbP89K1nFGcbIVKJP+zIStzdaxJsUIvm2Z9OjR
            Y+utt47PkYWNSOeZGMqQrfz+97+3BWAI6zT6lZBOnToRGBstryQ5tsIq1FrHtqgLmY7uSHC1W3Eu
            QHf45siiGHrkO3xWOeKAA13nzp2jI4dBdIhPPcxi3JFZRtxh+7i/U3XOKqP8TYCWrQMp7gDHjHNW
            FWqtE6jaswpqDgrU5sozRZut8+abb3JLbfRnTpxiBSB+9PLLLysrqMIQiNsuZesw4vL5V0LQTWbB
            l0NzGUCyjuDC83Mls4/8Pf3005KseEuOqnXXXXfSpEk2/nz4GQRsckQZPHIOHdn+dG2PUw7vthVE
            d6BHEqypXGoBpncMnDhxovJXjTsto/zppsiVcwUKULTga0KjPUuubORpKwlYI5wrGpZRe85q9O01
            MHjnrKIuh/mzqc9i3BFEbAQzRfv27fmUaMfX3s3/i0aXyjYLiELsTQG5j1bO+qpworAOS4lBOFmh
            ZeuYas3jMVm5oyFDhqDLiZUjsYpPN9me0G0XYR0r9Pnnn4/nbqZw0UUX1bsmZiXLS1pvnYg7M4V4
            lMktgU4orlXlQDy9iT1LFdjvKS2QBWcL1sEQ/hJ7Vll4bAUOEChxfyesE/eVmT6sIyTLD5VTmGMm
            zQu01TrTpk3jF3XBUzDUWkfcMTwbqrKtRBCJf+0JJOuIXNaXWkGBReabbz7lqpVlDDZNfWloVBjW
            WWcdb4VqFB2hSLWVwzp8ECXaxsrKNc0+3JdWFgPFtiUv49RqsRVoq3XibghtopsE0xJ7Vtk6Cqqk
            joa32267KUe0LscdEdoAxo0bxzpxznq19IncKVOmyM5FBDwg4oYhgHUwrLHGGhZUrsLfmRil/E0A
            ymgVUc+ZI9gCjC64oIdkaNeuXSztGZgF67D6iiuuSPsy0o5eto71rMr0mvCrrrpKOWapbJ1QlMy6
            1uHnlNYpHpBAJOFhHSPPus8RLla2zumnn06x+Ma1rgu+JmiL+Pbbb4dwSMILzJp10jkroco6eIwk
            /uisfApV62gmnVUbsYMvKNdax3Ybx3TDMKV8E1vAtuItTTCYczzGqRzo27cvsWEdUdmYpZrKZbBj
            bPOsY/EWcpuQ2SUwh6xjR6cxoJStI51VtppUpc+cKpfvYLCOwWMD+VFYhxFjtsGmw3zBIwnQxFkv
            +AGd2LAO4I9CGVIeAmNlhcwE9s3sEphD1rFNihEBjm0VXHnllcrbbbedOBJpiEOQcp8+fdCdITWP
            b/iFdRwR1C600ELJOjHbEHsWa2IYO3as5s4BNEREiclP1kkw7EybHLowiojKwj9K8CjrkZC48TCn
            rEN1/h94/PHHDWz33XdXdgpVtmHjdFW2f6HbdJVtMehpZaGYzEbWoQmKbU5zwYuG8Vke58G61uGq
            mTY5qBfWiZVl9bGdPSumhBBdYJgV6xAt0C6cg+eDQpV18IMx2ObHjBmDJ57z1Z6zZIN4NtlkkxAF
            8WHopZZaSjnilOguzRMsGMvcrpz/S18KatEXWM6a2NEJFI9pxbLRC5x//vnoVMI5ffp0wbhjx46s
            4CSELomNPFBfhKywwgqGOSvWyTWpg1rrxB0Mm26iNDqFlu9glPHT5t/tK59Cg1K2TiDuYMRJIm5y
            lyHi4Fl22WXpWXUHI+5+QcjJ0FbryLgkmnURAbLWOj//+c/pFDw33HCDY2QgDvdCo7KjpsFwEDzG
            H81BzLKKaY8T+LzTo+SoQ4cOnAtlpZVW0kTDokGTdfbaay9ZZe/evQkve9CoUaPwL7HEEmSS88IL
            L4QaTiQTJkyw0HRRCIK2WmemqLVOGelpH1vsXbpzCjw57VnBExAUzGfeuoDlwILhqoEW7n6R3KY7
            GLNoHRuNmZwpJBfJOgJeQW2C/TuqYPDgwSh2+nirFXuhWDhBCQiiG264Yd66wLbbbiswiaDF+3XX
            jaAWsDkW1HXXvfHGG1ln3333Ld63AvoqBEHrrfN/Ea2yzjOTs//jfuGV6hdiI3oVpfxq1OorvmYq
            tlybyo1aBfHZPzazQ33rzH3Fa651WnrNtU5Lr7nWaek11zpzX7Py4jfHnTPXdea+2v6a6zpzX7P4
            mus6c1+z+GqD63Q9tHh1aypUvRK9EcNMX9HQNRVSVbxmyhCvRgyJWEVPryqGMltdYvnViCERq+jp
            leiJM96mVxXDLL9mKqeWgX9UuUF6tdZ1dupT+fizyt/+1vT6e/5Kb6teVbVVnLVtq5iraqteX6Vt
            1auKv6pt66uqalt+VfFXtW1Z1Ezb1lLK5ara8qte28//UjlkcLUnpFdrXWeXPpmsufg/hS+/rP6z
            5vJrFlzntdde69Kly09mHxZaaKGRI0fGDfvnn39+iy22KCpK2HjjjSdPnpxu6ge+/PJLDX/2s58V
            TDPD2muv/YfSt8cSnnjiiTXXXLNgKqF79+7xczUFX+uA/6OPPtp1110LKU1YZJFFttpqq9dff73g
            a4Bhw4YtscQSRZsmLLbYYo8//nj2FLIEHf3xj39cZ511CqbZgQ4dOowaNaroaLa7ziuvvPLrX/86
            nsJ985vf/F7+TeUftBFapWea3/rWt+66665wi2eeeea/m35vWRfYgr9Tp07x8zmhQ+CLL74YMWLE
            T3/60xA4T9PHnDX89re/ndomrLzyyryExYGov+a/6wH33XffkksuGW0pkxpaIdbJZ5999uc///nv
            +ae4io5bBLYPP/yQl4TABJINzdqIThvhrLPOateuXSiQsMACC9x///2f5j9D8Zf8p1byQfyLTcrf
            I//Od75TNGg1zB2kufjxj3/8+9//PvscAcxR1/nVr371p/zHEmIkrccHH3yw7bbbhrp1XYf8pZZa
            6uP8twaiSfRehagCZk1fzllwwQUvvfRSJi7qmkMrq+qNN96Ip69laL7llltylOC8/fbb+SVNGPfI
            I4+s/uhcA2hY13VaiUMPPZR/lE0aXr7++uvHx1Tmn3/+q6++Oryn7DpLL720INTWuQjh6TMHX6vr
            CM66j6rWozWu0759e65jeNGkZYgNVa7DIkVdDbjO1KlTW3CdYPt3uU74biEuF2gsv8x/NxHDj370
            oxZcp5XmSgjh/07X0dlzzz1nGKzfAnr37m1JEdLIdUKUncgG8eqrrwrURcsmfDf/HFnMIjYNOQo6
            g5522mkiDeK0adN69OghGqPbfWwBmd7NwWTREYwdOzY+8ALGlfeTYbvttnvzzTdNEg8+5ZRTksAz
            zzyz2acvm4PksuusscYasjS9aDJmzBgTHPRGSK4jnPfq1ct4Q5kwOMzUdYzL9HP6aFgXDCupYkb8
            /xGuU/t5wiocfvjhLbsO+0ovJARgRmWv2W9e/PznpjY+xWPYMtBwHZ2aDMkvhtVXX93sPpv//Z6E
            pmfPnqussgr6qquumn5CSytZagiPP0cIXHPNNYs3/fPCvPPO27FjRw1XXHHFPfbY45FHHsEguaZ5
            5FK0Fd7Gjx9flpDKCuzw2GOPbbDBBiGQKLm8qokTJ1511VUS3qBzQeZaIYeDQvKM5Dq24MGDB8co
            Qp8oGO+dd97JF1t2HTlv0Ovihz/84QUXXPD/K9cpb1hS17RhPfXUU6yGWHadMlqzYbFsysHrQvO6
            G1ZRPVux1lprsaTRia+nnnoqTwp67YbVCHjmuk5917FARSCc4HyxXP51v0auQ+zxxx/PXvxGiLrw
            wgvfeecdG0cZgoftI++zPqpc55577hESnHeE9zS1ZVDShqJWp7LXcFyQlNjdEGG++eaLHKUKjnvW
            g6HRs3///umTkXVdh3E++eSTGAWDm2yUua5T33UCegkU7xu7DhMAITB9+vR99tnHZBeNm1CIaIwq
            10kChTS7YdXnXkH6PHDgQMrgcWRjjfAezmRPibZPPvnkMvnPcddFrVYtpMkMhb+Vuc7/GtdxZkHf
            fvvtHVuE4vK1jJRgtsZ1vv3tb8tgoqH8I9Y95k033VQKYkpEkZdffpkRNTRaKS0K+n333bfNNtuk
            2zxLLLFECFlppZUEgyCWIb8RA+RV66yzjpljymyc+X80Pv300wTKug455JAkMIG0k046KRR46623
            kusINiYghMh+pNtMQX6HDh2S/2kbnYZuCWeccQYTmVHZjGNgjOjRRx/dcccdCQG9CIct5Drm4uGH
            H95kk01CoCZVV5CK3XzzzeF//2bXQadEK4F5pq5Dvlwn3TRiQXtH1Ro1T1wEj4bl+zplmG+TEf02
            ynU6derkNBcdBQiE4cOHt5zrtMZ1Con5b/U+9NBDJjjachp+X+60DA2Ni7+GQNuitma0qG5CXdcp
            d9oa/HtcRzD43e9+5+AghLYJTobpf+hacJ3aNDnou+yyiyN69+7dDzvssMsuu4zAyy+/vF+/fijo
            O+ywg60zMgyhK/1cn6lKriOGbbHFFpjBceyiiy4ixFHrgQcesKCDP6XJROk9OrVdGnUIb43ryE7I
            IZyVzjnnnH333ZcQeh588MFMh37ttddOmDChmK1KhTdcf/31MaK+ffvihD333FPbsPMNN9zA0YUW
            lim7jh3q9NNPb+tc4Hek2GyzzULI1+c6swVtch1zY/IsFHRzfMcdd8QXFm06p512WkRgIW3vvfe2
            UtFFneQ6KeqYeLuYjQAz2P4iGBDewi3B6NSBSMYWwltwHSMKITSPFFDV+uuvz3rRqTgadM5NeLpR
            dPbZZ+sO3bi4S4xI7UxvCc4WcB2azynXee+996zv+Pu32YIuXbqwY7jOlClT2DHoXMR+fFsOocVi
            lTSgizTodhN00atbt26IXbt2HTRoUPyf3I033tinTx9i0dVyr9DcWSaEk7PbbruRSQhIgRfK/06R
            l9hHLOu8z9uOOeYY5yb08t1kc1bXdUQXZolOCecxeZ8zXIdwuY6jX3Q6ZMiQ6NTK0YTO0enJJ58c
            IyIkAgAX4bV1XYe/il6YZxf22GOPNBez33W+HtD+9ddfd7JlLDCj8k1Ekea6665LtwdTrtPWBxF1
            n2E1QmtcpxGS67QSLZywqlynqJ5z+Ppdx8SMGDHiN7/5jU3axmHnrp1FM23Z8XE8rjb7wtOb4K3M
            VwCwGQOB8nFGLLuOddy+fXtHj8gGzOKVV17JrFawvSmlLLUgnAJkhvD+/fsL1CFw1VVXveSSS4Ju
            FluOOjwVv+iY5SMN0LlzZ5tpCF82/0vgEH7iiSemqLPVVlvx9aBb9DQ3UpuUt8ZFiDRr4YUXxgyN
            XGf69Om9e/eOTuuCnQcPHpwO5FdccUXMURkHHniguTCDmcSv33WMXHoRxpWNCgacoKhrgnREwAhb
            WEwp15kpyq5TRuQ6LbhLC2hlrlPrOm0C4eutt55cJ4Q3ynUSRFMHn4ijZTRynddeey3umjaCgUhS
            P89/aNWMHHTQQbVmnLNpcl3w0zfffJNN7dCwxhprRHRt5DqmYezYsU40YG1JX7KjTnNY9DFO/OzC
            vohWBoGaRFtGjILY9vzzz8dyEVEuvvhiSwq/VZt+ffndd9894YQTQkivXr3Sl93b5Dq6MOu606le
            LABhIzf7DBi1ABCKlTFq1KhkikauM3LkSKGaDWkuezNAEJO4BU3wS/wl+0JdZqMcYfN99tnHOTE6
            CrO4yucOOOAA+ud6ZX9+tdNOO2GOCBRBGk/8TzL8G1xHZ3XvJjdynQSeoe3WW28ddknwtk3PsMqQ
            sbJjBIaWT1hBb5PrlMGzjzvuuNpbheXDeSM0cp2qE1ZsXuVcpxHK93USnActswWa/5gi/PCHPzz/
            /POJDeFf032dMix0S4Qjw/777y9LkGdIUEABrr322oEDB3Lz4DGMyHs4k/0liJIVMxSqJzRyHVVm
            3RlEQz5ESDzZKKPsOppIR6IjaYdJzcVnN9k22WSToG+88cYxW1Wu4/zidGYsVrBRSDgwG4vt1ZRg
            MK/PPvvsTTfdhOeCCy6gYcwuOc7hITyBtpIqkS+EU/Luu+9mIvsv4WqDrW/fvoxGoHjgiLfzzjtH
            2/POO0+oS4atBa2EW+YSF8ePH7/vvvtquMMOO6y99tr0yQc9AyKlnSGZUXgjgXBHv7fffrtIHuao
            6zz44IMWh+mhykorrfRy/n/vZVhMp59+Oh8Pje1o6RmWSBPEuiCz/FEva7Tu3WRC4oRVRtl12oQq
            10lA4aORGUQYq01Nyvd16iL8qeonYYAXnnLKKcJzsKUTVvlusq7t70X2OjOIGSJHy8+wyiB8aP7H
            XNX4+l2H6sOGDRMzxBKHCH6Tpjy5Dh5uwcFBkiQABE/Hjh2tHtOA/v777xeRM/9dmfj5qTLeeeed
            Tz75JFJjYuUxiy++uE6lBRSYOnVqwdeERx99dPXVVw9N6qLKdaQmq6yyyqKLLipFSN4P8803H4qO
            yjBVtTtXFexNwl7wSy9ef/11LmKJU140CiUdwcJ0yyyzDB994403ENXG5hKKtQxs9tb33nsvBCaw
            6m233RY++oMf/ODkk0+mAPqUKVP4a2glcI4ePbow+5x2HfuoKM3oK6+8criOuYwTFm+oQnKdMBlY
            SQ4LKdexuTz++ONho8TTGnDEPn36xBo1PbZOHlDUNeGll15aZ511sjmsQahn7rmOsB/8ch1+Y3RR
            O2soOqjBWmutxVzGGIge4ayzzjKvGjKsXEdMKipKwJ9Zv8ZEiV5G4jEv9913n6Mo4ZHrMBH7u8p1
            cmX/ywL4mnIdcdv4TYkEzSqPDICWgm3QoyoVBJKIuhjkRssvv7wIseyyy6YjQHIdQqwSQQJDGZih
            eFN6a42mZFAIFBUkocGTsNRSS9XdxfTCppMnT37xxRflGSuuuGLwO7yMGzcufsAtDSGVIb0tEwNR
            BbfeeqvkrOiphOQ6Vo6TkZitR2OxACZOnEjChAkTrLQOHTqEMjFSkKPIwCJ9tv1tttlmwWC7FD+q
            vIdwC0ATDfF07do1hD/zzDMijRwA0XiHDBkS2hJobTN+1ni2uw7lTD/VgXuGrq768zboGKrGEEgN
            p02b5lgrSFRhtdVWe/jhhw2YFxpGuptsQVj9fKLgaxHY8EdDiKDYAj1SEApTTOpqRQY9fTY5dG4Z
            xs4CyRpppE888YRpI03veiz6bvrMMuEWvb1DMIhOzahdGF06KBhIRKJt0jzd19FL+RmWheFtdJrm
            hRnTCYuE8n2dnj17WrGEC3LCWz4/zTHbXee1117bdtttaQORpTIZS02aNIk5EB3wjj322LrnZ8cQ
            WwAe47Qc5bMfNcdjjz220UYb5bKz//1M9pJzCACsWfC1CH7QvXt3iYWGTHPSSScFXa5trSMSS437
            778/6OwYtjYQtg4i3HzzzRZlKDNTyBLicxGGySZOLkHfYIMNLHEjFXFHjBgh988HlClmgPxAOhi/
            NBqdCgByDg3FKpuXVtrK6my1YY1GrsO9OL2G7dq1cy6TGtKkkeuYLy5Lz+g0jr3VmO2uU/fzOkzm
            oC66ShcsFJHWfBheFeSA888/Px72EnW5V9CNJIQLp2IABmDc3CYZOKWqxJ8Qaz3aJrD1fvvtZx0T
            YmGlb0TYIEI4r1p66aV5UtAjQhQSS5BUmr/QpBwwIlxlKpYgt5X5kWNiKCCmBt2Uc2W9qHrkkUfM
            dNATaHj00UenI5vDDpdCtwKV0U0/Y/7yl79k2KDbValX5TpmhPdgwKZ3+S8ejnL55ZfztmBIrgNM
            l4+yGqyhNlPl63EdnelSx8ZptJZOzByYJ4gyl+Lp2OT/hhdVhio1Cw+IWSSEl5jp8oZVnq1o6LAg
            /hEYiiUQVXaF5JdBJzyQ6E5eoguBSXL0sv3220vgaGKMgwcPpidN0E8//XRZOcmFoBzRURi9SoEY
            WtlEwR9lV8zBA2lGxZtevXoZI30Yc8yYMWJDVEVHUHYdvivwE8j+lqXQFQPhT8FQdh2+6OSf5ihB
            qzmYJtd1nagKMMTZZ58teOaz8O2kOti8rUjDE4HNejBIXZPrJHjr6BhPHxuBM/G/Wtcpg5kYIpur
            xhg7dmy4DpRDnVyHnjQR20899dTkOvEZ0BaEx+yGAgmYiVIVPOEuiI2ESAeZS0yilTkW0iICQV3X
            SXeTSZOx2ZFjRAn0l1Mn1/k3PMOaqeuEgRxxwdKRahh5aMbukjJYbLHFbAcGEGzsaDxF+xyEzBbX
            oYntgALRb1UhrhtuuKHdljJEyW/SKWymroM+YMAAmURZLCy++OL33HNPKJBgjDI5x5ngTLk5Vzjz
            zDPNWQgJCQoCgBXIvOwjcZECWo3ofOKGG24Ii9V1HTD3XCRsWwa1w1//g1yHNiZJGBdUUALKdlzG
            NeDQjK72XbYWXSNNDmhLAuEKRoUiI37hhRd4GOYyNE/SxLPNN9+chxX91YAcO+PBBx8c/HIUsxIK
            lGEtxt058zFy5MjIUqFbt24OQYQ4Z51wwgkWLiH81WIwLvLfeuut3r17c6aQn8DjzW7owCYxE+E6
            q666agjnOk8//TTh8VA2+WvZRMOGDQsXsVXV/aiXY/aaa64ZAp20Ix/XKRtG2DM1NlxLIpRBR0Hn
            RjRfZJFFom3Cz372M07/tbqOzp599tnax59VSLcEyw8iWCS+eoJe/oBp3e+cM2XdD120Bg7J6X5j
            ayCPPuCAA3bZZRcHloBy+a1jVNeuXTfeeONlllkmPUmogqllsUJiCenxZxXSg4iCL9/p6rpOUd0E
            J18DxIBtyy23FO8RhbT4N5Nc9jeErtiwoslMMNtdR5jdaqutLCw5bOfOnXm0WefjgoQjNGIVcAYz
            8HRh4JNPPnnjjTdsB1EFNi9yOIp1mT6853RjcSOCJgE+d+mll0YAaARux7eiR0E+RQVTdd9995EW
            cVtOXvnL3ypPT6oMuriy7/GVbodVj3qmrx0PrxxwYmXo1f/649RP3p/+uwsvtI71DjwpFHA4jxNW
            FRq5Ts+ePcUhSooQJp6ejVwHndmxhX3YP77wJRiboHAdbFaaDTSU2XTTTdk/TB0IqxZv8k4tzljG
            s991QmNhJhAu7Kq/gtQYNnUDMLaf/OQnt99+Oy1BRJWy2AjQWYfdcxtmQKlFWLAFCLwXXXSRmKxH
            K9g6LiqabjSPefDBLz/5rHLBDdkP3VWNdJZf3Y/5182jpk5+aYsttlhwwQWdcWLIECaqQiPXMfwY
            Zrt27c4991z20byR68h17FPBn0ynnFynPC+a3HvvvWH/RmAcKTbmTMXZ7jqG4RAo8pcxbty4iRMn
            qsJAV9klCvoTTzwxZcoU44+2XCcyFQNwgBdj8Dgbr7feejFsBwqJ5Nprr73OOuusttpqdb2ETTHY
            1xrB2jJzlqwe2UuyGXQyxYBTTznl09emVo4+q7JtzW8s7nB4ZcAFokjl2LOzH2FMdAHphAsqV95R
            ufTW7Of1tj2ksk2pVen1j8EXXT70vA4dOkg2Y8iNwIZyKVoZi605jVTcWmuttagqK0jpsNW17777
            durUCb+k/rzzznvkkUdYzzDt+zG0bIR5Yd1119177715SczLyy+/HPY3L4JuyhTrYo6nyXb3cmwA
            DpuenFOUi0Q6Im736dNHGIy2yXUaofwMq+4JS3DadWYf9ZoJROORj1R27F09Ri/b1uTXM4ZHJlSO
            GFIZ9WjlyeeK1+TXKv/4ovLlPytvTas89XzlyWez1xMTK78fU9nv+CThy517Dz92IFPM1HUSuHib
            fq7AdtO9e/fYhfmoRL6K2cTrPT50YWfHLB9F//e7jjRln332Mcdgc43lUus6cWRgkfKnBJPr8ABL
            TW6UEAJlnfF3UHPCdbSSS7779jtf3jyqWVCJl1hyysWVjz4R5SsPj6/s2beyfa/iN2BbeOFhxCYh
            X3bpNbx3v7quY0T2UFuMowCwFX2MlOtcfPHFIk3YgRtJxdDNnxOcWI7ZVdtwkUauI+QrY2bAK664
            QogiTeTeb7/9Yk9Av+WWW6TtYeoqRO+i8oN28znkOjGv0h24//77bb2xPbfJdWQDch0qhpwEksmP
            Lma761DPXnZC//6fX3NHNutpdJxm/xMqY/9Q+fs/Mr/xEnWOOSvLoKe+k72m5NeqQvZ6u/L4xMpB
            A5OoFlyHWR5++GH5jcUGTgP0SYOFsgXwc5FevXoJG5jt4w899JDaoNd1Hati+eWXx8xEdjHpMH7+
            5ITF2ujmyCZoLmrNnhC9h8DZ7zrWhHP42By8e5NNNpHB2YDt3LzBCLnt4MGDndvRbW19+/a176KD
            40NsZA4+lhcJQXduKtRtgjGUXWfeeeddY401CCR2wIABkcfgmT59ulSJHHu/cIgSzevCVNH2+H7N
            XWeXI7KN6c9/LZzmf/LrQ+OzzavnSZXDT81fpzW94m3T65BBmWVKeU+4jhk1uhhabqdsmMxy1VVX
            ORAYhcXdo0ePN99806hNGM3pH2zyAVOLLsycddZZyYzCCU6jKLuOQ+i1116b9/PQzTffHL/7ZCVL
            d+68804C7VDHHXcc6+VWzB4Fjh49Gl13Tq8EhgIsk2k5dqxswVwUZpztrjPT+zq8+/DDD4+UmZ+V
            P2BaFxZE7ZdpvC27jjAbX+ErqnNYx/LEuGnBOjP9Mk191/HiAc+/nKUyL0/NAokZeuipzG+GXlO5
            7LbKlbdnCXJcLx+eUSTL3r48pfLFl5UHnqjsekQSFa6z6KKLhtplCAZxB7nQpglfJdeZZZiRRh9r
            NxdzasPilY6+R+X43e9+F/dIdJa+EcEV2GjQoEGn5Dj++OODGTbaaCMWxMNSXbp0OfLII4PuuNGy
            61hP3PHkk09m5RAb0EtI6Nev34xNugEauo7XXsdWxjxV6Ts0+7c5rjP2qUr3oyt9Ts9c6pPPs5j0
            8adZGvTBnyqvv1W5+s7szOUU5oT/179VLrklyQnXYQcxOBTbY489wrmrXMchlBljCJ07dw6zQF3X
            sSSuueaaGPsJJ5yw+uqrM3LwJ+hFWqNHVpUyhi9ic2LlGUcffXTok0BObsJTTjrpJIlRCJmzaTIY
            WEJQyq5TRuQ6n+R/eAwp13HAFjD4R9BDSBlVrlMXzB3PsBoJqUJLrhMv4efN9/SdbVj8ZtIrlT99
            WjnvukqXXgWDpHjv4yqHnZo1F5Y++jjb3V54OftThZwh5TrWbmiV7t9Uuc4s301uhPLjz/IJi+/a
            GTJVSjAj/4ZnWKbKtsoJyhgyZIhDuI4LFZogrtqnRYtg4+m9e/cWP1yttiCWIRuwHI2N6whvFgdm
            2G233eR6BNooJYOWEaIeLVyGppWwb6s+++yzCbngggvsnrWbV0uuI18xxrvHZsM0bdLkIZdlkea1
            NyuHntKMM2PuWTnopMqEF4vEaNKr6aj/z669nr3gClunhRSdymMs69D2nHPOMaigz9R1HAWcQmJE
            Z5xxhrBx2GGH5caojxNPPHHatGkky12ef/55YRjRuhWuwkRlSJaT6/BIiUcI0Sp9E3KO5Dq193Va
            CcqlZ1gCRkEtwSnxscceY7joK2GmX+GTVDJThH1OVvfnCixKWVrmOtf/vvqxw059sujy0pTKn/+S
            mWzs+MqZV2b/qEKT6X+qXD+icszQSq+Tsx3tslsrU9/NeAQnJpYbHTe0mZzHnin6axEzdR1LtPzT
            TBZGMaOzA2XXIfxr+jKN6MeRnaGEDYhCo7dQpsh7jj322GOOOcaxSwTK65sxDxw4kONjSAh+xwSr
            CoMANnz48IiosbzQMVjT6zR9BJMtttxyS1s+OmmOxKH5hx9+SPMxDz74j5deK9/Ha/ZyUN/h8MrO
            fbJXv3MrF99SuevBzBuemVx58bXKS69nMWbCpMpdY7KbQHv1rWz323Lzfx566tMj7jWiTPXmMASp
            YW3Ucapw4HJsDAswEeMYddlEMpLa8yP3EmbE+6KD5gi7Gf6NN94YUQe/xdO/f39VQLhwSLirTqOJ
            srxzTkWdrwKxt5zr1EYXR9D/bvrhrTIanbAcQSMJbQSbvU6LBglf/jM7TPU5LRt/1Uhn+SUNGnDB
            Ry+9um+PHnWPP41yHRq2/MXhoNeC9cqf16mLlOvgZ710N9kJ69/wM5R1wU8tiwMOOMC5SXp/2WWX
            /SP/VIAU5LbbbrPFoINs3yKjoiGtvfba2+e/y1TGXnvtJX3RpAoPPPDAx/kHMIxKFNlpp5203W67
            7QipnSfWOfjgg602DYUoKU4oKYsySXrp0aOH+P/XTz+rPPfHLHjs0y97Bi7eVI16pi8hZ+felf0H
            VM686ovJr7304uQtttiCPubeCg7N5T0L579vIiKamE033ZTmINLELEo1ll12Wdt3WEBDqaSG9BcJ
            gliGtI/y7NDIdXRkpV1++eWE3H777Xw09nf8opQVi37TTTfJIx0DCXQVyzNdb7vt7rvvjk+3Zfb6
            elzHSMr3dSR0kWq05r5OGausskrdXCfBKpzp53XkOpdcckltrsOHIqSZrSVKP1fQCOI8W7+df/nS
            kSQMapFw4vfy71aiy0iC/laD3xKc5Z9mIlkwCIFliEZ1vxGRYHTp8zqNUJXrfE1fpmEjw3NWhF69
            elGC7UCi+sQTT1gQIJWO/bKR66BYjmPGjAn+hPHjx8dJnkATs9lmm1mdOtp7772d1dHLrsNGnTp1
            GjFiRNG4CZxP22LDLqGR6zgNCWN6Mfdy7ZSDW7I/bfH3dchZcskl11tvPUrKtOZr+hC+xSO+5hb6
            5WqrrZaYV1555RtuuKHQsgk2kQMPPFAYjrZ1XUftsGHDhF78o0aN6tmzJ1V1Ku4KFSGnDCOKqO86
            cuTIzp070wS/hlYU4f8e1+EWjriswxYbbbRR3E2OqlpUuY5p0AqE7vi8jnBljmsloPCVBfJvJYMI
            zBz4zd+11177ve99D5FB0zciwtuIIrCMsnCuw9U0NB+mvPwjKQJDCNxqq62YNdra7BZddFEjnXfe
            eYX35Dq9e/fmTJlajRHjDQSFcJOXch0Kh7YcxX4R7gXcxeIxUkm9slba6o5D6Bq/RNueFS5V98k5
            JOHsX36GZeJqP9buKsHKBtxkrkLgbHcd6YvAI1cHBf3Vqp5Q5TpSmYlN34rdeeedl8th/Pfff3+V
            95CpI4bGDJYOu2MWn2UqUmZECogurIzfBDiGxDdhy+jYsaPEK2QS+Oabb4bA1157jW5B15abkmYa
            +GUSYoa4F2arZfr06aGhq70ABb+q8jXBJrXhhhvGkFdaaSVxBREPc9EhOnU2tPD0wmstpDgbgv1o
            mWWWkf3Yu52eqKSt8W699dbGDksvvXSyZ13XMSPikyyQcMPfb7/9wuYUSM+tyq4DFMhHvNwvfvEL
            bUkIQV9HrtMIVa5T976OBVH7DKsKcr2W7+uwRbqvU4aktc4JqwF4oTwxDjiQvhFRVLcOJkbAEL1C
            iHjJz4q6Ehrd10lIJywC7TJ2HIYq6prQyHVq7yYXdU2ocp0EPjQHn2GVIauwqbdv317qUBeLLbbY
            /PPPn5aUyI+Czg/s+lOmTJk6daqrVCOEOIBYslW2AL4iwDjEiRaXXnqpdYl5qaWW2nPPPYV3DBaT
            nQtDAslRYKYQ0gh6tJGFwB133NG+pi2IQDIVdGt90KBB4a/mcsCAAaJC0M1uZBVlML3IFEJSXKxC
            I9cRU3mDhgIkzTluC65jqSyyyCI0AWmc2ElyW13H1YhCW3HRai9Wy2x3HXLZgr1g9OjRLT9mqoLB
            CwOw0EILyXVEb6CrE0G416qlH0kpI3Vqc7nmmmu4ICEyHoEhcp1GIIopQ1sSeFhRUYJcxy6gd9mA
            07UDVPDLQBdffHHWN8ajjz465Tp9+vQRRykgMAwePBgFXUfJLFDbEYay6caNG8fzcmPMU/aJlCYX
            zfKGXMcOaI4xc5daH4Kqr/BJ8DE7/0sSWnadry9Ntu7tNTIvOWz6IEgrQV2LyUhEmvSbB2CQwdDI
            dZ555hnbsE5F1O7du9tH4gtHrFxE1wbgmscee6wutF1jjTWs9VrhyXWAJhwitOrWrZsUwd4aHUVD
            06+MEgrw+6BTySZlrWsoejX6Cp8BhnDnMoMiRFg64YQT0t5R6zqgUwdY3YHQssMOO9Ruzcl1gGta
            UcEvQ6j143+P69i50+d12orWPMMqu04YAqqeYcUJE4ItIYhlcB2dhnC7TPmmUTBA2XXKSLlOwdci
            LImq+zpFRVN3XOfhhx+O77tA/L4O4YJZ1ed1mKiFTvlE3c/rlF0HotNGqHKdoUOHFs3KDefEhmU+
            TB44+EQqI4SaWqeGoCdYVUJ6Ck7JdcpCUGo3LAwik33N8GCdddaxRi1HY7ZhzTfffAYsGnfp0iU2
            LIvymGOOQQl+wBCFFN6T61iFciDrPhic3V588UXxgxCbVJpFDYOhlSgvJ1NLAVh33XUjTa5yHczR
            yt535JFHCg9hDUm9mBRVjZBGZMt79tlno6EMydlQrTR/++23b/mWICOITLzWqBkw/mRUW5noHPwy
            DbtHgkJduc7CCy/M1uZMRjlp0iREVQksYknZZfBQjus45RZ1TTBhNi8DxmNXir8i5zoic0qk0jMs
            E5BuCUpNOnfuLDAQwlJOWHw0TKAqGoJZJBk490MPPcT/OKsFalKzuf3ud2WgXCf8kuugFC0bgEBd
            YHNNGwdXkBUhRl8JEvC4l1PlOgmkMQtDhTW4jqClYaZZi8DjAG9LjVAhkXC6JtDY0/ewGoEluY7J
            is1XBAplzNQcfIZlDaUPXQjRfJYeOksPIsowPDNqSqLtGWecEQ9uyiCq9R8wLbtOGZwmfcBUqEu/
            YGo60+E83U3Wo/y39neTWwMzTaA51pALpt9Ntl7Lf4hUi0auU4W6uU5r0CbXKW9YZcxZ17GGHEOy
            BfW972222WbJdZ577jkH9VgQaS3iOeyww957771YUlzHksIQzYOZMwmSLbvO6quvPmHCBFPlKH71
            1VejR/PUEddxflarFydMxwq16OZV2Ive7afrr7++hiKczUv+FH211XVOOeUU3kmgCMp1YvckYdSo
            UaEAFNbPg3REYrPFtzp06IA5lE8WSKOAnj17Est7NOFttT4Ue03eSRb4Uwpc13Uw0ySYwXYRAilj
            k3IgCAVSkJ6zrqPvKlTRDYyL1Ho0iMy2p4KvOUJIQpXrJLBySpN1dMcdd9TyNELkOiRHjxB9tcl1
            yuD0J510UsxHbZocwjloBGNVHFfMjq4TJBx8kRvlImcg3RIMOQnlNLljx44tb1h0q/uDcAmswaW+
            pg9d0EZ6wQTw9ttv6yY0MJ1Tp05FlEZY6JYXkzmmsmNK61KazCIOpSGkLmwupnmllVYiBOKHhkgI
            10l352b6eZ0y2rdvf8stt5BMvhycwvmAKuPHj99www31YjdZZJFFCu5WIFyHBxMi1NV1Hfs4OuHm
            1aGSm8YAE6S34iUnyAc6A04MV1xxRbgO8zJ18D/99NNSw4gTPF66GSMaM2bMEvlPpXIRPUoZEeVw
            Q4YMSXfznTboE/wBZcF4zz33DIY5nuu05ss0fJlLCbxSkNoTVqPDeQL5S9b89yf6V3GdBK7MyinX
            yVZfDk7AcLUBoBFa4zqF6Fy4JL0217EknLAiv2kEXl73bvJsx5x1HfuIWbdNgMD48ccfh+twcIcs
            ROHROTnWtOvZZ58tZgT/0UcfHa7D4XbaaacgliELCeuH68THu/Cn+zr8slu3btOmTVMlJ7jpppti
            SamyRUo7CkH1wINDeJXrmFR7fxJo78+smKc1mpAZ2UwQy+Bkch1bg7Y2js0339zYdUTzkSNHhvAE
            jv7444+vvPLKoYyRhivoRWosBhMCLMae+CUxlh+K9SNZFDCC35UyLY+UT8fabgFJiGtEdJizrmNg
            RpUQU1tFj1CB6NoaeoJcOB2Cyq6THn/GCJkvEG/BHNslRaNCUD3YGkwAZg3LrvPoo4+KlyGwbHEr
            RAZjyjnWySefXDd7wx8NHdnuu+++pIDRhfCEqiHbUCJIB5Icp4qIQDwmfegCCr78J8OuvPJKHlYI
            qoGMQjCOZ1iNwFznnXeejniJxXzIIYcEnevMwcefehIDnCZmIyzcsLVcT+bv4Aa77767vsJ1bMk9
            evTYtDFs/zfffHMx5hKYUjiMXm688UYJJsnCw2677SZOBE9Kk80f22288cYh8/jjj3eSogAT88u6
            rpPQ6HDuzOVMrndJCWeNoAsyQsfA6KgMgdl5U9AyhUcddRRVKUwlm2B0ZINOnxIkjfIxOgVHEJIZ
            QeQI1zGin/70p3ZSQghfo+l/yoQc7oJNRyNGjLBjRu877LCD0MhomYqz3XXKuc5sgT0o3ddhjipE
            p8WbViD4EyxBCVZ05IQlwOioYG1iTq5Dk86dO4e/JmD4Kq5TdcIqf9SrLs466yx7GX4uMnToUC5C
            YTuXtjHrZdexKpav9wumyXXshlZLLAAOce+994bwMrhR+UFEIFNxjrpOu3bttt566+2bPp0ehUbX
            8tstt9zSagjVy67TCHIjw7711ltvv/12azeWhSbOHYLzbbfd5iqKFMulhCrXiQcRYDLMNIHa/u53
            v9tjjz0o1rVr1549e0p3EMH6sy9gbuQ6NJe8b5f/D/I+++zjoBBhT6c6CiEXXXRRCJei9e3bV04T
            ihmRFY/BiJ577rkUL9M3IlzJpAwlr7/+eh2FzcuuIzencFj1gAMOcPJFLLsODTfYYAMbnI6cLk9o
            +jFNdCc4oVpDSSf+6L0Z5qjrxAnLhGWz0RZISNMJqzWuk9LkRicsm3e6m1yGWZQ9REdVz7DSjxbG
            swIKmA9GTOsyPf5s5Drl+zoBPbpa5Q4QwbPmmmvabaMWQitIn9eJExZXDnpynUZIrhP8hdwcQSm7
            TiM4W6SfK0gNq/E1uA7jmgynnssuu+yMM844M/+ia0L57ZgxY2LMDudcPoZR13W8lSeee+650ZBb
            9OnTp3cOh5ognn766RKgmNFGrsOOlrXAA4MHD546dSpL1XUddM3LnxLkrNKdIUOG6Mt61XXISZCL
            iIUpYATIKbuOjcx5MxROYBMOHelLI9cxro022kjmpyP5Mjlhc/wWj7FX2TlB1d577x1C7HFGcdBB
            B4XCCVSyd9eaqxm+HtdhPlG3fGSoC0pHntga15nlZ1gzRStdJwHF7EaomymqXGemaOQ6ostMP2A6
            UxBe91OCrcL/LteRu1jlFpkt3JiNPHjqug4dLCkew8TQr18/pwYQDGxM4UYUkysEfcCAAdzRTDRy
            HXQMw4YNI03A23fffeOmUdl1CJQ3iBkhM0EsjGSLHH5gRKGVYCkjJIS2yyyzjDBGclQFbBzy9LQB
            laMOdxEwCD/wwAPr/mZPGQsssED//v0JJGG//fazmSLyto4dOxpIKMmwUSjDWOwG0Xsz/O9ynZl+
            cbjsOvIeCZN9TUPn0ro/V1A3TW7kOvjLsNPJ5Y207DrmmMDaO4StOWGtV/qf80aYaa7TCHVPWK2B
            sXC4ovsy/ne5jvTZmr7wwgst/QRvHVmtGIcI6+/oo4+2UqNKyEFBt7s7MoRWHMuxwlIL/hNPPDGY
            HUGtMMT9999/t912W2ihhUKB5DpG4ZRkIeKBzTbbLGaxra4jrT7vvPNCCGbeYAiOWsOHD48P4YOs
            S6DCcPDBBxtybdRpBF3vtdde5JMJxhVXKyo2prLrsO3aa68tK8oNMOzQQw+NQM5Eu+yyi/iHyJiO
            fqGtGDlx4kRLK1Plf2muEzCdgXQ3udEJqxHmyT9eE0IsyrohrZW5TpxHIow1ch0egKfqhFU30lSd
            sHhbpuK//jVT15H/XXXVVelYV4jLEZSy66RcB51DlH+uIE5YzG57tSxz2XP4bnJd1wFbRtw2rcLo
            HFGePHlyqNWaNPndd991PLb0oXv37tdeey0JTjQCQyyL1rgOPZdffvlNN92UkJ122unyyy8PTSBp
            NW7cOOZjXJ0Ke+wbdHlJHIJkDEsttZRRk7PJJpssueSSMfwIALwN8y233LLPPvvEzV8nI3OQ99/Q
            dYSfhx56SMMRI0YMHDiwc+fO+e3cTZ19TPzIkSOlaIbPOCEnAWWllVaiBmax1s5LcwLfeecdyuid
            DuKHCGeAhAvYTB10GoZwBuevOkV3Pfnkk/NZGv3ggw++//77IXCOu0483I6q1qM1rlP3hFVU5wjX
            STwzRcp1ivYzA+tHrlO0r0GjJ+dlNHKdBPHj1Ho/QxnPsGoFljHLn9cpf0rw35PrGHD79u0laOD4
            kApRToVa4hJLLOE4TQK0xnUMzyxa+iEkIOB369aNS9lugO2iMGHChB122CE+DEX4scceG7Vvvvlm
            zArh1qgUO+R07do1rd0y2BddQ11YoyGwDNGIhqEVFxEnXn75ZX1J9rlR8NgyFl98cb1w3B133JEO
            hfQmVLkOgaIafhv0GWecYZMlcNKkSXX/oZ1KIRzYJ1wBmIuFEenmfJf8z1YYwl3na/pr1a/VdYRK
            SlNotsCA67rOlClT7BcFUz0Ys5AeJ6wypBpyZK6Jx5TIHoqKJtjv+MQ666wTcpyBTU+t6yRwuNNP
            P12MCf66sIREe4GQHArwy6KiCbTdcMMNdVQIbQLXie9WF3xNMOVy4RAoKdGWFxZ1sxUMJV8utClj
            truO+CwYMj1k3zVt+n4ulN9GGcpvUzldA5FqhPyAt6xmjarNmzZrmwpSkyKnK4FnmLxoC4JHUdGE
            EP7ee+8Fw7Rp02KGiuoaECg1CWbI1ZmhPHj79ttvR9aJn0oUS1UBZR2lk1SCJoSnkeaNsgIKzUOg
            q7apKlB+m8rpmpDXN6MkpKpaE2WYPa6zc5/KX/5qBHNf/4devLxXza+3pldrXWfbQyr79M9+unHu
            6//Oq0f/GT8YXftqrevMfc19Vb3mus7c1yy+5rrO3Ncsvua6ztzXLL7Cdd5+//8D7Ozc/52g0EUA
            AAAASUVORK5CYII=
        
    
    
        
            
                
                    
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                    
                    
                        
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                        
                        
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                        
                    
                    
                        
                            
                                
                            
                            
                                
                                    
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                    
                                
                                
                            
                            
                                
                                    
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                    
                                
                                
                            
                        
                        
                            
                                
                                    
                                
                                
                                
                            
                            
                                
                                    
                                
                                
                                
                            
                            
                                
                                    
                                
                                
                                
                            
                        
                        
                            
                                
                            
                            
                                
                            
                            
                                
                                    
                                        
                                            
                                        
                                    
                                
                            
                        
                        
                            
                                
                            
                            
                                
                                    
                                    
                                
                            
                            
                                
                                    
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                        
                                    
                                
                                
                            
                        
                    
                
                
                
                
                    
                        
                    
                
            
        
    
    
		# 取值图片的base64位码。
        ${deptNameZhang}
    
    
        
            
                
                
                
                
                
                
                
                
                
                    
                
                
                    
                    
                
                
                    
                    
                
                
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                
                
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                
                
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                
                
                
                
                    
                    
                        
                    
                
                
                
                
                
            
        
    
    
        
            
                
                    
                    
                    
                    
                    
                
                
                    
                    
                    
                    
                    
                    
                
                
                    
                    
                    
                    
                    
                
                
                    
                    
                    
                    
                    
                    
                
                
                    
                    
                    
                    
                    
                
                
                    
                    
                    
                    
                    
                
            
        
    
    
        
            
                
                
            
        
    
    
        
            
                
                1
                1
                31
                180
                Microsoft Office Word
                0
                1
                1
                false
                
                false
                210
                false
                false
                15.0000
            
        
    
    
        
            
                
                    
                        
                            
                            
                            
                            
                            
                        
                    
                    
                
                
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                
                
                    
                    
                    
                        
                        
                    
                
                
                    
                    
                    
                    
                
                
                    
                    
                    
                    
                    
                        
                        
                            
                            
                            
                            
                        
                    
                
                
                    
                    
                    
                    
                
                
                    
                    
                    
                    
                    
                    
                    
                        
                            
                        
                        
                            
                            
                        
                        
                        
                    
                    
                        
                        
                    
                
                
                    
                    
                    
                    
                    
                    
                        
                        
                    
                
                
                    
                    
                    
                    
                    
                    
                    
                        
                            
                            
                        
                        
                        
                    
                    
                        
                        
                    
                
                
                    
                    
                    
                    
                    
                    
                        
                        
                    
                
                
                    
                    
                    
                    
                    
                        
                    
                    
                        
                        
                            
                            
                            
                            
                            
                            
                        
                        
                            
                            
                            
                            
                        
                    
                
            
        
    
    
        
            
                
                
                adminUser
                
                
                adminUser
                2
                2020-12-22T09:30:00Z
                2020-12-22T09:30:00Z