diff --git a/emis-biz-web/src/main/java/com/xdadan/erp/web/emis/EmisCommonController.java b/emis-biz-web/src/main/java/com/xdadan/erp/web/emis/EmisCommonController.java index 766248564..f905180ef 100644 --- a/emis-biz-web/src/main/java/com/xdadan/erp/web/emis/EmisCommonController.java +++ b/emis-biz-web/src/main/java/com/xdadan/erp/web/emis/EmisCommonController.java @@ -36,6 +36,7 @@ import com.xdadan.erp.emis.domain.vo.Sender; import com.xdadan.erp.emis.domain.vo.WaybillOrder; import com.xdadan.erp.emis.service.*; import com.xdadan.erp.emis.service.print.IXddTplPrint; +import com.xdadan.erp.emis.service.print.tanex.TanexGMPrintTplImpl; import com.xdadan.erp.emis.service.print.tanex.TanexSubBillPrintImpl; import com.xdadan.erp.emis.service.print.tanex.TanexTplPrintImpl; import com.xdadan.erp.emis.utils.WaybillHelper; @@ -421,8 +422,9 @@ public class EmisCommonController extends EmisBaseController Map order = emisBaseService.getWaybillPrintOrder(billCode, "1,1",tplCode, "zh", tplCode,printManCode); if(order!=null) { - IXddTplPrint tplPrint = new TanexSubBillPrintImpl(); - tplPrint.genPNG(order, os); + IXddTplPrint tplPrint = new TanexGMPrintTplImpl(); +// IXddTplPrint tplPrint = new TanexSubBillPrintImpl(); + tplPrint.genPNG(order,tplCode, os); }else{ log.debug("获取运单信息失败"); diff --git a/emis-biz/src/main/java/com/xdadan/erp/emis/domain/vo/WaybillOrder.java b/emis-biz/src/main/java/com/xdadan/erp/emis/domain/vo/WaybillOrder.java index 5c0822f8e..bb02a9950 100644 --- a/emis-biz/src/main/java/com/xdadan/erp/emis/domain/vo/WaybillOrder.java +++ b/emis-biz/src/main/java/com/xdadan/erp/emis/domain/vo/WaybillOrder.java @@ -275,6 +275,9 @@ public class WaybillOrder implements Serializable { /* 是否特殊报价 */ private String blSpecialQuote; + /* 是否敏感物 */ + private String blSpecialGoods; + /* ext_info */ private String extInfo; @@ -537,6 +540,7 @@ public class WaybillOrder implements Serializable { voItem.setFeeRemark(dbWaybill.getFeeRemark()); voItem.setBlSpecialQuote(dbWaybill.getBlSpecialQuote()); + voItem.setBlSpecialGoods(dbWaybill.getBlSpecialGoods()); // voItem.setThirdCode(dbWaybill.getThirdCode()); @@ -757,7 +761,9 @@ public class WaybillOrder implements Serializable { // dbWaybill.setBlBill(this.getBlBill()); // dbWaybill.setBlBillText(this.getBlBillText()); - dbWaybill.setBlSpecialGoods(this.getBlSpecialQuote()); + dbWaybill.setBlSpecialQuote(this.getBlSpecialQuote()); + dbWaybill.setBlSpecialGoods(this.getBlSpecialGoods()); + dbWaybill.setBlOverWeight(this.getBlOverWeight()); dbWaybill.setOverWeightNumber(this.getOverWeightNumber()); diff --git a/emis-biz/src/main/java/com/xdadan/erp/emis/service/print/IXddTplPrint.java b/emis-biz/src/main/java/com/xdadan/erp/emis/service/print/IXddTplPrint.java index 4e655ca42..d83b39726 100644 --- a/emis-biz/src/main/java/com/xdadan/erp/emis/service/print/IXddTplPrint.java +++ b/emis-biz/src/main/java/com/xdadan/erp/emis/service/print/IXddTplPrint.java @@ -7,13 +7,13 @@ import java.util.Map; public interface IXddTplPrint { - public AjaxResult genPDF(Map order, OutputStream os) throws Exception; + public AjaxResult genPDF(Map order,String tplStrBase64, OutputStream os) throws Exception; - public AjaxResult genPNG(Map order, OutputStream os) throws Exception; + public AjaxResult genPNG(Map order,String tplStrBase64, OutputStream os) throws Exception; - public String genPNGBase64(Map order) throws Exception; + public String genPNGBase64(Map order,String tplStrBase64) throws Exception; - public String genPDFBase64(Map order) throws Exception; + public String genPDFBase64(Map order,String tplStrBase64) throws Exception; } diff --git a/emis-biz/src/main/java/com/xdadan/erp/emis/service/print/TestUtil.java b/emis-biz/src/main/java/com/xdadan/erp/emis/service/print/TestUtil.java new file mode 100644 index 000000000..8d5cfa54e --- /dev/null +++ b/emis-biz/src/main/java/com/xdadan/erp/emis/service/print/TestUtil.java @@ -0,0 +1,107 @@ +package com.xdadan.erp.emis.service.print; + +import org.apache.commons.codec.binary.Base64; + +import java.io.*; + +public class TestUtil { + + + /** + * + * @param path 文件全路径(加文件名) + * @return String + * @description 将文件转base64字符串 + * @date 2019年11月24日 + * @author rmk + */ + public static String fileToBase64(String path) { + String base64 = null; + InputStream in = null; + try { + File file = new File(path); + in = new FileInputStream(file); + byte[] bytes = new byte[(int) file.length()]; + in.read(bytes); + base64 = new String(Base64.encodeBase64(bytes),"UTF-8"); + System.out.println("将文件["+path+"]转base64字符串:"+base64); + } catch (Exception e) { + e.printStackTrace(); + } finally { + if (in != null) { + try { + in.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + return base64; + } + + /** + * @param outFilePath 输出文件路径, base64 base64文件编码字符串, outFileName 输出文件名 + * @return String + * @description BASE64解码成File文件 + * @date 2019年11月24日 + * @author rmk + */ + public static void base64ToFile(String outFilePath,String base64, String outFileName) { + System.out.println("BASE64:["+base64+"]解码成File文件["+outFilePath+"\\"+outFileName+"]"); + File file = null; + //创建文件目录 + String filePath=outFilePath; + File dir=new File(filePath); + if (!dir.exists() && !dir.isDirectory()) { + dir.mkdirs(); + } + BufferedOutputStream bos = null; + java.io.FileOutputStream fos = null; + try { + byte[] bytes = Base64.decodeBase64(base64); + file=new File(filePath+"/"+outFileName); + fos = new java.io.FileOutputStream(file); + bos = new BufferedOutputStream(fos); + bos.write(bytes); + } catch (Exception e) { + e.printStackTrace(); + } finally { + if (bos != null) { + try { + bos.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + if (fos != null) { + try { + fos.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + } + + /** + * 单元测试 + */ + public static void main(String[] args) { + + // private static String tplName="/Users/alan/work/git/tanex56/emis-service/emis-biz/src/main/resources/tpl/tanex_zd_tpl.pdf"; + + + //定义文件路径 + String filePath = "/Users/alan/work/git/tanex56/emis-service/emis-biz/src/main/resources/tpl/tanex_zd_tpl.pdf"; + //将文件转base64字符串 + String base64 = fileToBase64(filePath); + + System.out.println(base64); + //定义输出文件的路径outFilePath和输出文件名outoutFileName +// String outFilePath = "E:\\FileTest\\logs"; +// String outFileName = "test.log"; +// //将BASE64解码成File文件 +// base64ToFile(outFilePath, base64, outFileName); + + } +} diff --git a/emis-biz/src/main/java/com/xdadan/erp/emis/service/print/tanex/TanexGMPrintTplImpl.java b/emis-biz/src/main/java/com/xdadan/erp/emis/service/print/tanex/TanexGMPrintTplImpl.java new file mode 100644 index 000000000..8abc34df0 --- /dev/null +++ b/emis-biz/src/main/java/com/xdadan/erp/emis/service/print/tanex/TanexGMPrintTplImpl.java @@ -0,0 +1,290 @@ +package com.xdadan.erp.emis.service.print.tanex; + +import com.alibaba.fastjson.JSON; +import com.itextpdf.text.Element; +import com.xdadan.erp.common.core.domain.AjaxResult; +import com.xdadan.erp.common.utils.DateUtils; +import com.xdadan.erp.emis.service.print.IXddTplPrint; +import com.xdadan.erp.emis.service.print.ItemCell; +import com.xdadan.erp.emis.service.print.XddBasePrint; +import com.xdadan.erp.emis.utils.sensitive.Convert; +import org.apache.commons.collections.MapUtils; +import org.apache.commons.lang3.StringUtils; +import org.apache.pdfbox.pdmodel.PDDocument; +import org.apache.pdfbox.rendering.ImageType; +import org.apache.pdfbox.rendering.PDFRenderer; +import org.springframework.core.io.ClassPathResource; + +import javax.imageio.ImageIO; +import java.awt.image.BufferedImage; +import java.io.*; +import java.util.*; + +public class TanexGMPrintTplImpl extends XddBasePrint { + + /** + * 模版文件 + */ +// private static String tplName="/Users/alan/work/git/tanex56/emis-service/emis-biz/src/main/resources/tpl/tanex_zd_tpl.pdf"; + private static String tplName="tpl/tanex_zd_tpl.pdf"; + private static String tplPath="tpl/"; + + + @Override + protected ArrayList getItemCelconfig(Map orderMap) { + ArrayList printItems = new ArrayList<>(); + + return null; + } + + /** + * 单元条目配置 + * @param orderMap + * @return + */ + + protected ArrayList getItemCelconfig_old(Map orderMap) { + ArrayList printItems = new ArrayList<>(); + + String package3dm = ""; + String packageWJC = ""; + + String pdfInfo =MapUtils.getString(orderMap,"pdfInfo",""); + if(!StringUtils.isEmpty(pdfInfo)) { + String[] pdfInfoArr = pdfInfo.split("]"); + if (pdfInfoArr.length > 0) { + package3dm = pdfInfoArr[0].replace("[", ""); + packageWJC = pdfInfoArr[1].replace("[", ""); + } + } + + // 设置打印参数信息 + String orderSn="订单号:"+MapUtils.getString(orderMap,"order_sn",""); + printItems.add(new ItemCell("package3dm",package3dm,12,true,Element.ALIGN_CENTER,"Text")); + printItems.add(new ItemCell("packageWJC",packageWJC,16,true,Element.ALIGN_CENTER,"Text")); + printItems.add(new ItemCell("orderSn", orderSn,6,true,"Text")); + + String logisticNo=""+MapUtils.getString(orderMap,"ydSn",""); + printItems.add(new ItemCell("logisticNo", logisticNo,7,true,Element.ALIGN_CENTER,"Text")); + + // 条码显示 + printItems.add(new ItemCell("barcodeImg1", MapUtils.getString(orderMap,"ydSn",""),1,true,"BarCode")); +// printItems.add(new ItemCell("barcodeImg2", MapUtils.getString(orderMap,"yd_sn",""),22,true,"BarCode")); + + String mobile=MapUtils.getString(orderMap,"mobile",""); +// mobile= Convert.mobile(mobile); +// String address= Convert.address(address); + String consignee=MapUtils.getString(orderMap,"consignee",""); +// consignee= Convert.chineseNameFirst(consignee); + + printItems.add(new ItemCell("company", MapUtils.getString(orderMap,"company",""),7,true,"Text")); + printItems.add(new ItemCell("consignee", consignee,7,true,"Text")); + printItems.add(new ItemCell("mobile", mobile,7,true,"Text")); + printItems.add(new ItemCell("address", MapUtils.getString(orderMap,"address",""),7,true,"Text")); + + String goodsInfo=""+MapUtils.getString(orderMap,"goodsInfo",""); + printItems.add(new ItemCell("goodsInfo", goodsInfo,7,true,"Text")); + + String parcelQty = MapUtils.getString(orderMap,"subSeqNum","")+ + "/"+MapUtils.getString(orderMap,"parcelQty","") + +"|"+MapUtils.getString(orderMap,"billWeight","")+"kg" + +"|"+MapUtils.getString(orderMap,"totalVolume","")+"m3"; + printItems.add(new ItemCell("parcelQty", parcelQty,7,true,Element.ALIGN_CENTER,"Text")); + printItems.add(new ItemCell("sendDate", MapUtils.getString(orderMap,"sendDate",""),7,true,"Text")); + printItems.add(new ItemCell("packType", MapUtils.getString(orderMap,"packType",""),7,true,"Text")); + printItems.add(new ItemCell("paymentType", MapUtils.getString(orderMap,"paymentType",""),7,true,"Text")); + printItems.add(new ItemCell("dispatchType", MapUtils.getString(orderMap,"dispatchType",""),7,true,"Text")); + printItems.add(new ItemCell("shortLogisticNo", MapUtils.getString(orderMap,"shortLogisticNo",""),20,true,Element.ALIGN_CENTER,"Text")); + + String printInfo=""+MapUtils.getString(orderMap,"printDate","") + + "/" +MapUtils.getString(orderMap,"printMan","") + + "/" +MapUtils.getString(orderMap,"printCount",""); + printItems.add(new ItemCell("printInfo", printInfo,7,true,"Text")); + + String remark="备注:"+MapUtils.getString(orderMap,"remark",""); + printItems.add(new ItemCell("remark", remark,7,true,"Text")); + + String extData =MapUtils.getString(orderMap,"extData",""); + if(!StringUtils.isEmpty(extData)){ + // 解析gson数据 + try + { + Map mapExtData = JSON.parseObject(extData,Map.class); +// printItems.add(new ItemCell("k1", MapUtils.getString(mapExtData,"k1",""),8,true,"Text")); +// printItems.add(new ItemCell("k2", MapUtils.getString(mapExtData,"k2",""),8,true,"Text")); + printItems.add(new ItemCell("k3", MapUtils.getString(mapExtData,"k3",""),15,true,Element.ALIGN_CENTER,"Text")); +// printItems.add(new ItemCell("k4", MapUtils.getString(mapExtData,"k4",""),8,true,"Text")); +// printItems.add(new ItemCell("k5", MapUtils.getString(mapExtData,"k5",""),8,true,"Text")); +// printItems.add(new ItemCell("k6", MapUtils.getString(mapExtData,"k6",""),8,true,"Text")); + } + catch (Exception ex) + { + } + } + return printItems; + } + + /** + * 主要控制模版的字体显示 + * @param orderMap + * @param os + * @return + * @throws Exception + */ + @Override + public AjaxResult genPDF(Map orderMap,String tplStrBase64, OutputStream os) throws Exception { + AjaxResult ar = new AjaxResult(); + +// ClassPathResource classPathResource = new ClassPathResource(tplName); +// InputStream tplInStream = classPathResource.getInputStream(); +// InputStream tplInStream = new FileInputStream(new File(tplName)); +// + // 生成pdf文件 + byte[] bytes =Base64.getDecoder().decode(tplStrBase64); + InputStream tplInStream = new ByteArrayInputStream(bytes); + genPdfByTpl(getItemCelconfig(orderMap),tplInStream,os); + + return ar; + } + + + @Override + public AjaxResult genPNG(Map order,String tplStrBase64, OutputStream os) throws Exception { + AjaxResult ar = new AjaxResult(); + + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + genPDF(order,tplStrBase64, bos); + PDDocument document = PDDocument.load(bos.toByteArray()); + PDFRenderer renderer = new PDFRenderer(document); + BufferedImage bufferedImage = renderer.renderImageWithDPI(0, 200, ImageType.RGB); + ImageIO.write(bufferedImage, "png", os); + return ar; + } + + @Override + public String genPNGBase64(Map order,String tplStrBase64) throws Exception { + + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + + // 生成pdf + genPDF(order,tplStrBase64,bos); + PDDocument document = PDDocument.load(bos.toByteArray()); +// bos.close(); + PDFRenderer renderer = new PDFRenderer(document); + BufferedImage bufferedImage = renderer.renderImageWithDPI(0, 200, ImageType.RGB); + + ByteArrayOutputStream out = new ByteArrayOutputStream(); + ImageIO.write(bufferedImage, "jpg", out); + + Base64.Encoder encoder = Base64.getEncoder(); + + String base64Str = "data:image/jpg;base64,"+encoder.encodeToString(out.toByteArray()); + System.out.println(base64Str); + + return base64Str; + } + + @Override + public String genPDFBase64(Map order,String tplStrBase64) throws Exception { + + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + // 生成pdfbase64 + genPDF(order,tplStrBase64,bos); + byte[] pdfBytes = bos.toByteArray(); + String pdfBase64Str = Base64.getEncoder().encodeToString(pdfBytes); + return pdfBase64Str; + } + + + public static void testPrint(int i) throws Exception { + +// String newPDFPath = "/Users/alan/Downloads/ynmb_blank_t21.pdf"; + + Map order=new HashMap<>(); + order.put("orderSn", "DT20210901001"); + order.put("ydSn", "SF1374689807723"); + order.put("kdgs", "TANEX"); + order.put("pdfInfo", "[山东淄博-胡志明][越南DN]"); +// order.put("packageWJC", "."); +// order.put("address", Convert.address("上海市黄浦区河南南路1009弄3号902室上海市黄浦区河南南路1009弄3号902室上海市黄浦区河南南路1009弄3号902室")); + order.put("address", "上海市黄浦区河南南路1009弄3号902室上海市黄浦区河南南路1009弄3号902室上海市黄浦区河南南路1009弄3号902室"); + order.put("company", "SDSDS"); + order.put("mobile", Convert.mobile("13818228246")); + order.put("consignee", Convert.chineseNameFirst("张三")); + +// order.put("consigneeAndMobile", Convert.chineseNameFirst("张三"+" "+"13818228246")); + order.put("send_address", "Vancouver"); + order.put("send_company", "2324"); + order.put("send_mobile", "1604-683-1088"); + order.put("send_person", "Vancouver"); + order.put("extData", "{\"k1\":\"阿尔巴尼亚\",\"k2\":\"阿尔巴尼亚快递\",\"k3\":\"阿尔巴尼亚国际特快\",\"k4\":\"1-10工作日\",\"k5\":\"阿尔AL\",\"k6\":\"山东淄博-阿尔巴尼亚地拉那\"}"); +// order.put("sendPersonAndMobile", "Vancouver"+" "+"1604-683-1088"); + order.put("goodsInfo", "日常用品"); + order.put("parcelQty", "1"); + order.put("packType", "纸箱"); + order.put("paymentType", "现金"); + order.put("dispatchType", "派送"); + order.put("shortLogisticNo", "123213"); + order.put("remark", "test"); + order.put("billWeight", "12"); + order.put("totalVolume", "12"); + order.put("subSeqNum", "1"); + order.put("sendDate", DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD,new Date())); + order.put("printDay", DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD,new Date())); + order.put("printDate", DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS,new Date())); + order.put("printMan", "12321"); + order.put("printCount", 1); + + ByteArrayOutputStream os = new ByteArrayOutputStream(); + + IXddTplPrint xtp = new TanexGMPrintTplImpl(); +// xtp.genPDF(order,os); +// xtp.genPNG(order,out); + + // 生成pdf base64 +// byte[] pdfBytes = os.toByteArray(); +// String pdfBase64Str = Base64.getEncoder().encodeToString(pdfBytes); +// String newPDFPath = "/Users/alan/Downloads/test_"+i+".png"; +// FileOutputStream out = new FileOutputStream(newPDFPath);//输出流 +// StringBuffer sb=new StringBuffer(); +// sb.append("JVBERi0xLjYNJeLjz9MNCjE5IDAgb2JqDTw8L0xpbmVhcml6ZWQgMS9MIDMxNzIzL08gMjEvRSAyNjAxMy9OIDEvVCAzMT" +// +"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" +// +"NwYWNlWy9JbmRleGVkL0RldmljZVJHQiAyNTUgMjggMCBSXS9GaWx0ZXIvRmxhdGVEZWNvZGUvSGVpZ2h0IDE1L0xlbmd0aCA0NzMvTWFzayA1NSAwIFIvTmFtZS9pbTUvU3VidHlwZS9JbWFnZS9UeXBlL1hPYmplY3QvV2lkdGggNDU+PnN0cmVhbQ0KSIn7/x8FvHtv/sEGBHZLfPwUn/ofN3jx8pUNExJQtnn95i12pffuP7gLVGF97eGjdY+fPH3GUgbkJec+x6b2Qi7Q1NCL1ZcuX7l67fqNm7dun7gz2YGJ6S6bG4baY0Cla4+fOMmCcIX4qdNnzgLpc+dRle7dB1S7v/zAQSZUoHXo8BGgW44iq90QqcwUunHTZrCCBCbvLdO2btsOUb5j5y4mpt17EGoXLmJiWrxkKUguf9nyFV4rV9lnrS6JlFkDElmruq6MyWY9TO3EScpMno6TgRISU6YmdMdPmz5jZsms2VPnzGWaBxR0mK8KlFkAVVxlw1RWXQMypbauvqGxqbklprWNKbq9o7Oruwck3NvHxNQ/Aaw2NY2JSS4dKJaRyZSVnZOblw9xbUFhUXFJaX40E1NZeQUTUyVYcRATU3BIKFA2LDwiMioaKSxifGMl4uITmJgSQ5KYklOAau3smRwcnZiYnF1c3dw9wIocrD3FwQwvbx9fHz8gwz+AiSkQqFhJmUkF6AMmdjV1DU1Q0Grr6OrpGxgaGYM0mJiamVswMVlaWTPZ2P5nYGRiYgZFGysbOwcTEycXNw8vH7+AoJCwiKiYOJOEpJS0jCzQU/JMTAr/AYQrN3gNZW5kc3RyZWFtDWVuZG9iag01NyAwIG9iag08PC9CaXRzUGVyQ29tcG9uZW50IDEvRGVjb2RlWzAgMV0vRmlsdGVyL0ZsYXRlRGVjb2RlL0hlaWdodCA0Ni9JbWFnZU1hc2sgdHJ1ZS9MZW5ndGggNzEvTmFtZS9pbTYvU3VidHlwZS9JbWFnZS9UeXBlL1hPYmplY3QvV2lkdGggMTM5Pj5zdHJlYW0NCkiJe8CAChj/P0ATYfh/gByRemJEGsgRsSdGBF2AaiLydBShnS/IFGkgR4S8WCYm/WBJhw8IimCmcMb/HwiKMGMRAQD/EyjNDWVuZHN0cmVhbQ1lbmRvYmoNNTggMCBvYmoNPDwvQml0c1BlckNvbXBvbmVudCA4L0NvbG9yU3BhY2VbL0luZGV4ZWQvRGV2aWNlUkdCIDI1NSAyOSAwIFJdL0ZpbHRlci9GbGF0ZURlY29kZS9IZWlnaHQgMTUvTGVuZ3RoIDM4MS9NYXNrIDU3IDAgUi9OYW1lL2ltNy9TdWJ0eXBlL0ltYWdlL1R5cGUvWE9iamVjdC9XaWR0aCA0NT4+c3RyZWFtDQpIiVtjxLR2HRMYyDMx5a7fsHHT5i1b527bvmPnrt179jLt23/g4CEmJq3DTExHjk5iYpo8BaKYiaN+6rTpM2bOmj1n7rz5CxYuWrxk6TIm7uUrQHIrVzExrq5hYqqtgyqub2hsam5hZWotbGtnYuro7Oru6e2DyvVPYGKamM3ElAPl5+blF8SBGG6FRcVgkZLSsvIKiGRlFRNTtSxTTCyEGxefkAhhJSWnpEJYlmnpGRCWcCYTUxYjU0AghBsUHAK1gjk0LBzmjYhIewgrioMpmpHJzR3M0fHwZIKp8PL2gbGZfP0gtAsrkz8Tk7gtmGNnD5dncnB0QnCcmWGKXY2YjE3AHFOENJOZuQWCY2kFpqw5mGwYmXR0mdCBnr4BuhCHEBOTISMTkxqGYnUNTXQhLaAqbWAcK7CiyygqKaMLqUgzMalyMzGJiaPLSEhKoQtJyzDJyvEyMfHxo8sICGJYJiTMJCLKwMjEzIIuxcbOgSbCycXExP0fAAaLVZQNZW5kc3RyZWFtDWVuZG9iag01OSAwIG9iag08PC9CaXRzUGVyQ29tcG9uZW50IDEvRGVjb2RlWzAgMV0vRmlsdGVyL0ZsYXRlRGVjb2RlL0hlaWdodCA0NS9JbWFnZU1hc2sgdHJ1ZS9MZW5ndGggMTcwL05hbWUvaW04L1N1YnR5cGUvSW1hZ2UvVHlwZS9YT2JqZWN0L1dpZHRoIDEzOT4+c3RyZWFtDQpIiY3Ryw3DIBAEUCMOHCnBpVBKSsGluRSXkCOHJGPMd3fBcjg+yTOzclj40whCzEQ+QuxEfkLWiUCIA7Yn8cD+JACOQd4M1CA6Cj/D/CE2Cj8sniUOc5dsg7DRHnL0BWyiSkL/hk5CB9kkdFCawwa5LGSQz9IH5Spar4v0MlOkl9kivcxVadEVWrRuEmRMC1q77CKmLjJEID/KbYpCmu2Y4Lu8cPtO8iwkAA1lbmRzdHJlYW0NZW5kb2JqDTYwIDAgb2JqDTw8L0JpdHNQZXJDb21wb25lbnQgOC9Db2xvclNwYWNlWy9JbmRleGVkL0RldmljZVJHQiAyNTUgMzAgMCBSXS9GaWx0ZXIvRmxhdGVEZWNvZGUvSGVpZ2h0IDE1L0xlbmd0aCAzMjIvTWFzayA1OSAwIFIvTmFtZS9pbTkvU3VidHlwZS9JbWFnZS9UeXBlL1hPYmplY3QvV2lkdGggNDU+PnN0cmVhbQ0KSIl1kGVXAkEUhs+qOKio74odgI1iIBaKgaICJmInKHZ3F3b/5XEXRHZWfb7M3Hmfc8+9Q18BjwMsb++yB5g/gE9K73ho7i1s9PAoc5+eAdsLpdwFcHnFZtc3bK11+4FbKnBI4DIeMaH9mJVPToGzc1GmCmBL75WG2zuMu7u3D/4g4FLVErC8sipJ19al7oZvE7ByQZnO2IBZj2RJ75zEnfctAMpFGkLNA6NjreGFxsPuhHMSmJqmYXoI0NvX/2MMhC6uQfcQMDxCpbQLk3R0dtm/ncLgYXE4DcJ03W2UpbZOCOvNDaZG0UoTzaZmY4swGrHKXUrzC4jYsqhYX1JqKCuvqDRWmaqFF10N98sVSFGkBrqmZ2RmZedotGKhy837SxWJT0gkkk/jk9TJ/6kiXERklCKaEKKMiY1TydMvFcX1UQ1lbmRzdHJlYW0NZW5kb2JqDTYxIDAgb2JqDTw8L0JpdHNQZXJDb21wb25lbnQgMS9EZWNvZGVbMCAxXS9GaWx0ZXIvRmxhdGVEZWNvZGUvSGVpZ2h0IDM1L0ltYWdlTWFzayB0cnVlL0xlbmd0aCAyNzkvTmFtZS9pbTEwL1N1YnR5cGUvSW1hZ2UvVHlwZS9YT2JqZWN0L1dpZHRoIDExMD4+c3RyZWFtDQpIiU3RsWrDMBAG4LMFdac43TJVhb5ARw+hKs6L9BE6ZjBxQgYvIX4lB0E65hUcOmQ1dHFB6O/p3Li5RXyI0/HrAKktoDGWgk/5IKK0J6OApCE9qGRVo1YRt1ovgltNgU8Wt7KKlxK4ql9mpiN7J/KzZaFZk0HZh0u7iLUVvXuF86g3IhxGEUWwN3fPPH2i1zzdZxd+rBoVYkT/uhh/o0r7ML0Kr9BDlTqyjyJH04pj5SKIuvs8FsFPj7rd5QqDZkd9rt1VWa6/R8VZblD3oq8unosWQW0fzwtWtziJXkWttZzo8OONK1EfBsGZnrWxtgmx3RMp1KpRLIV10D5pkpYoQRO0S9tEttfwv2Nv/nZ5ui71F8aRFasNZW5kc3RyZWFtDWVuZG9iag02MiAwIG9iag08PC9CaXRzUGVyQ29tcG9uZW50IDEvRGVjb2RlWzAgMV0vRmlsdGVyL0ZsYXRlRGVjb2RlL0hlaWdodCAzNS9JbWFnZU1hc2sgdHJ1ZS9MZW5ndGggMjU0L05hbWUvaW0xMS9TdWJ0eXBlL0ltYWdlL1R5cGUvWE9iamVjdC9XaWR0aCAxMTA+PnN0cmVhbQ0KSIlt0MFKxDAQBuAJXYwHoT6AmDfZIr7I+iQpVoiPtaWHXnyIFA97zd4CWzL+M6nSg6Ed+NLOJDPMsq54Q/Fc16JqN0WVYyLCVsJPYW3/k4aQrST96XWvNFYhs010iptm0ZvUEo2il+wG1YRgh2xVPIiImqqAhAOZ7RvOLYdHM/d6MzzFOr6IVpxuVtMd/U7l2CF/E309tyJeu8iZ7p6c1IaWnbIfOfXvD50q+YljmH7VDryE6d6rorF8DSOJLlxwn1tYPkVoOeKiISauSgb6TuhMxn4mj/1FhFFRdKqe2XBqMNkPIntG/yhZmp06rkrSOyrOOhtdToLoBxwFLZ0NZW5kc3RyZWFtDWVuZG9iag02MyAwIG9iag08PC9CaXRzUGVyQ29tcG9uZW50IDEvRGVjb2RlWzAgMV0vRmlsdGVyL0ZsYXRlRGVjb2RlL0hlaWdodCAzMC9JbWFnZU1hc2sgdHJ1ZS9MZW5ndGggNDc2L05hbWUvaW0xMi9TdWJ0eXBlL0ltYWdlL1R5cGUvWE9iamVjdC9XaWR0aCAzNDI+PnN0cmVhbQ0KSInN1E1qGzEUAOA3lYm8KDwvvTBRfAN350WIUii5Ru0btDtDQ6TGpcrKuZLMQOYaM+QCCt1oMej1jTNubJChu1Yb8cTH8H6kiaahv1zxv6CK3C7wuhZJ0SNV1FCg1iRNSJRAWVOrI2rVKQra4xEF9Hl6zt+VdgCimnz9qYleCGVJT+PnzYdqstzM+Hgzf35vKOn2HJ3r6Ha0+KGYJuVKuh8tHmafxtPBaD34eH+xHWpqdasRq45auICeVmThGgCGMIB3vHPQU1VG46mGCGZP6yLACq64ErTCc0BMo0GqAtMoUkFdrspZHWVbJCBruHMYZCuYio668NlSK3uKaDHKJKjY0aAi7iismMqA1oTiNQFulpU1By3cdQl4WYsugQiXGlusEYyHBZcVQXrt1paDGYy5LAGFBc9lxfnlFUZVS9CvzWIKiGWmWfFuMuRc/Bmo/QjSmaQmMwJKPC2S9gawH2zXLGoyg+XJcxprezuVb7Q6RaOmElZT8Yfq8iQ1VA6/LL8fUJWjIalAqnxYNNv+lncJ4D44XD2N103zRh2WuZdyqxpCF5fNr/1RQulEjs51Q0LGbwfPsBtshrbA9Vo8erFWecxQvmhr8uqI1iboDGXoKJh//nf5Dc02mm4NZW5kc3RyZWFtDWVuZG9iag02NCAwIG9iag08PC9CaXRzUGVyQ29tcG9uZW50IDEvRGVjb2RlWzAgMV0vRmlsdGVyL0ZsYXRlRGVjb2RlL0hlaWdodCA2Ni9JbWFnZU1hc2sgdHJ1ZS9MZW5ndGggNzgwL05hbWUvaW0xMy9TdWJ0eXBlL0ltYWdlL1R5cGUvWE9iamVjdC9XaWR0aCAzNjI+PnN0cmVhbQ0KSImV1j1u2zAUAGAKLMIliNq9CN0bdMxglFfJQYySQA/QKxHokLFXIJChq0YOAtn3Q1LUTxJbg2FRny2S7+k95QzHkD84gulOSP++Sas9EnR0Gs4s6XSTnmX2cKLf0DN9c00Pe+0ONM87iVt0FrbqtoQDPRTtTNWzylGIEYZovNe5aq+v0GnRdbrxSNPsXJJB0KUwVj2pPH2kp2v0rIqObSbhGm2r9qB1hfgB4OtGz0tQVEmMAz0Wna/Rcdw9DeIWnd7TuuoJB8SRzv5U9LTokkMzaG/Xuu7gXsdF1xx0lCcKtNnpT2/rUHQQn8u16R70s7lSB1iRF6rXomr/U4OebRBfYDE5snaMDjQNgdaocQPOih/ulVb4kDj/Y6vdhbTBzYcdcxiBqsNjp2knBGvd629FTw+sMwTVsYZhcYeJtuih6HjXaSydCa8I41mPqGGJVasSHdIKixZqyhqRI6Uy6AtrqH9ND0liQYThIfO/sI5Np17jT6OC4deqVdHnooemk4TSCVOlfON7sp4ov1HnXiex0XPRp73G1dkcNBGeIf4Gc+j7fdHCG1odadjxkvkwBJNMW+2ahg1wZqO5RJ6e7jmrQNuiIRQeA7rT7vR03umgYdKU1Jq1pKcaPp7PlwMdITs22pKu+Q2rrNrxCOoXpLghmGhJhAMtmsbdLdpgni01dq0la1k1dYxF+2E1E9aPMkdJYaeO8atpsdIXarQqUYaQRvVn0bJpL2xqemI9YTBfmnZq0ZYbKz0N2E6wY1B4Fj1WPf6D87Fo60bWtOHLKk3RU3vlwPR5gAjhCmesFJ22RXvZa4xnwJBSk2n6NRcthk57rD6010L2OhedqJZVHfCMSpcTW41BiUtjm7G7Dhx1uIteawph4Po4G9LYTTj/Ak6lvEOYpr30VLQM/z/+L2m6y15TT24607tTxg0/1GMsBbFtjeDfHM0k6LTRHHTszCtNhQB6myudYK39Wmd6CCeb41pz5aH4t3fNqiOtqNdceajMrvXxwWmW9DukO957x94ff3cj/wF/vrYzDWVuZHN0cmVhbQ1lbmRvYmoNMSAwIG9iag08PC9GaWx0ZXIvRmxhdGVEZWNvZGUvRmlyc3QgNTQvTGVuZ3RoIDExODAvTiA4L1R5cGUvT2JqU3RtPj5zdHJlYW0NCmjehFbfbxs3DP5X9Ng+ZNRJul9AEcBpnNZAUQN1sq41/CDfybZQ3cnV6bK6f/0oyb54w7o95CSR/D5SFE2mIJSUJGMFqUhWV6QmLMcdJZngnGQZrgI/LCjxwwmjrCZv3sCdHNSD7T3MWrtVK9vvV769+aD3Bw/3amhU38reB4sh0FHyCeZ9Y1vd7+Gp1+/ubp4eH7Li5j18lJ36N5bVuPWno4JH/ND4hUB3e3vt/b0yz8rrRk7seIXgLLIG7d94sl/xfJXH3T2it9IPCftV3m//E3uvdzvlVN+oYc0EbJ16VtBIZ3totGvGbmfUD2itlw1mw8Nh7PfSjZ2Rowe7t736Bi6kw2vTKsJr+D5arwYUGUXqAvZOPivMfQXb0RjloZX7vXLnpd0aUMbo46AHUF0rhwOEpOOyMxaJYedk4zWGsx+1ibRG7fzLycU0d7ofBzgq5w92HGTfpjCQfovJmQ4RejkkZDy9yK+EkT7CvZOt6qT7BjuNccGHwYQIl3NYpVR9aTUmMdzhaxJgwowaBg0mmVoFQ9L8jAvJCgrz0VncCGhGF57ghIcCn8B+U/1WOjxVMBE39nhKwVnX7hReWPeY15KBsXssHdNbD7/hp1U7cGqvB7yMaqGTTQxI7Z1ScDTjkHLl/7TDiAnT1oE/oG46yWb0CrqRZBWHKGvD00e2RrXaGAn47pM9xtPJoRlNDKiqgvL7KB0iwvYgzS55OAvxp1QzmMXCgFnyNrsqtlksJfwxXa4+iwU2m8Pbi/t5As8TeH4Fnk+oRbJZJJvFlc1ispn7A3xM7pbJfJnMl1fmy7PBhOpG4/XRnGCZHvcpQZ8S9OkK+jRhviTl48E6LGXlOqzRrRlAJqxManmFlcmtnChkTIPEn+clDSqBVQKrK7CaUDrZ6GSjr2z0ZKMwDX1yZ5O5Teb2ytyeDSZUq591EKQkjAk4JuB4BRwnxCkpfUzC6SLepJZ0aX23t2vs2Nj9Nv/ToN8u7lcnrPJu0e9s6O6hY95/xkZNaWxwoYM7ffTWhZ4ftJdOiNBg8I+mDJ/XdB3QOB9KwkpKuGBEFCX+MVLWJSlxCDBeb+owDXgpcLasBeOkoDnKKxSdVy42GVIUEclwV0U5Th2eRWvO1lwIUoqKFJUgeUFJUeek5DXuOckxBSValzVHBBLi9YqiIHmYcXVBSpxvZclIHjhwLdCBKHKkxiBzjoFmpA5yUaKORnmIl+M8DGtBkYvGyxCBkeaUE4Fx5iyc8RKFIAK5c/TNcHYyTonA+Bj6CTHlrNxUlFQZ7gSp2DqngTzcvMD7IhGSihwd5yGDmIewxiBoHM5hxTxsyjLj65CBkvENYxxjD1+REoe7EqnphtUUI+KUVeg7p5s4u5auVeE38erdXfYaPsWe506vYqm8xrc+Ho3qsHMREc1nYZ57UtMc3srjexWKCJNTnCe9JzcsF/Bg5H7Ah48VcXdnf6xvMi6iLlRWFvCbqHyQnTZndySUJsHaJB9eR+Wv/h8IupV3yjfYeSy2ARNFn1M0HCt34aXRzSzOTworrO/fiaheqvSlquGP8yVEVtze/iXAAEv18UoNZW5kc3RyZWFtDWVuZG9iag0yIDAgb2JqDTw8L0xlbmd0aCAzNTI4L1N1YnR5cGUvWE1ML1R5cGUvTWV0YWRhdGE+PnN0cmVhbQ0KPD94cGFja2V0IGJlZ2luPSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4KPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iQWRvYmUgWE1QIENvcmUgNy4xLWMwMDAgNzkuY2I3YzVhMSwgMjAyMi8wNC8xNC0wNToyMjozNSAgICAgICAgIj4KICAgPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4KICAgICAgPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIKICAgICAgICAgICAgeG1sbnM6eG1wPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvIgogICAgICAgICAgICB4bWxuczpwZGY9Imh0dHA6Ly9ucy5hZG9iZS5jb20vcGRmLzEuMy8iCiAgICAgICAgICAgIHhtbG5zOmRjPSJodHRwOi8vcHVybC5vcmcvZGMvZWxlbWVudHMvMS4xLyIKICAgICAgICAgICAgeG1sbnM6YWRob2N3Zj0iaHR0cDovL25zLmFkb2JlLmNvbS9BY3JvYmF0QWRob2NXb3JrZmxvdy8xLjAvIgogICAgICAgICAgICB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL21tLyI+CiAgICAgICAgIDx4bXA6Q3JlYXRlRGF0ZT4yMDI0LTA3LTA0VDE3OjI2OjU3KzA4OjAwPC94bXA6Q3JlYXRlRGF0ZT4KICAgICAgICAgPHhtcDpDcmVhdG9yVG9vbD5wZGZGYWN0b3J5IFBybyB3d3cucGRmZmFjdG9yeS5jb208L3htcDpDcmVhdG9yVG9vbD4KICAgICAgICAgPHhtcDpNb2RpZnlEYXRlPjIwMjQtMDctMDVUMDU6MTk6MTQrMDg6MDA8L3htcDpNb2RpZnlEYXRlPgogICAgICAgICA8eG1wOk1ldGFkYXRhRGF0ZT4yMDI0LTA3LTA1VDA1OjE5OjE0KzA4OjAwPC94bXA6TWV0YWRhdGFEYXRlPgogICAgICAgICA8cGRmOlByb2R1Y2VyPnBkZkZhY3RvcnkgUHJvIDUuMjUgKFdpbmRvd3MgNyBQcm9mZXNzaW9uYWwgeDY0IENoaW5lc2UgKFNpbXBsaWZpZWQpKTwvcGRmOlByb2R1Y2VyPgogICAgICAgICA8ZGM6Zm9ybWF0PmFwcGxpY2F0aW9uL3BkZjwvZGM6Zm9ybWF0PgogICAgICAgICA8ZGM6Y3JlYXRvcj4KICAgICAgICAgICAgPHJkZjpTZXE+CiAgICAgICAgICAgICAgIDxyZGY6bGk+QWRtaW5pc3RyYXRvcjwvcmRmOmxpPgogICAgICAgICAgICA8L3JkZjpTZXE+CiAgICAgICAgIDwvZGM6Y3JlYXRvcj4KICAgICAgICAgPGFkaG9jd2Y6c3RhdGU+MTwvYWRob2N3ZjpzdGF0ZT4KICAgICAgICAgPGFkaG9jd2Y6dmVyc2lvbj4xLjE8L2FkaG9jd2Y6dmVyc2lvbj4KICAgICAgICAgPHhtcE1NOkRvY3VtZW50SUQ+dXVpZDoyN2M1MDc3Yi1hMzJhLTAwNDQtODgyNi04ODQ4M2JkZDJkOWM8L3htcE1NOkRvY3VtZW50SUQ+CiAgICAgICAgIDx4bXBNTTpJbnN0YW5jZUlEPnV1aWQ6NTFmMThlMDAtODFiMy03YTQ1LTk3OWEtOGEyYWQ5ZDUwYTZmPC94bXBNTTpJbnN0YW5jZUlEPgogICAgICA8L3JkZjpEZXNjcmlwdGlvbj4KICAgPC9yZGY6UkRGPgo8L3g6eG1wbWV0YT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgIAo8P3hwYWNrZXQgZW5kPSJ3Ij8+DWVuZHN0cmVhbQ1lbmRvYmoNMyAwIG9iag08PC9GaWx0ZXIvRmxhdGVEZWNvZGUvRmlyc3QgMjQvTGVuZ3RoIDE2OS9OIDQvVHlwZS9PYmpTdG0+PnN0cmVhbQ0KaN4ci0sLgkAURv/K3am0mHvHeWSIoDMGUYGU9CBCJC3cZKAt+veNLr7N+c4hAQgkIVRACqQE0kBEEMfM9N/3CMS2XTPcODnvcGfl79Oyon61Q5I451wcq405Ta27Z2T7x0z0RNiuHsZ933TPrm18u+LIBWoUpLkmvcClh+gFc+cin6ekjJs1KIXJdJQpneJa2ChdhmSzisKAldci98v8UrruL8AA0tMvdQ1lbmRzdHJlYW0NZW5kb2JqDTQgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0ZpcnN0IDUvTGVuZ3RoIDE3OC9OIDEvVHlwZS9PYmpTdG0+PnN0cmVhbQ0KaN5kjkELgjAcxb/KbjoC3cRphQiidAuCDl28DLfhH3STbWJ9+xZFEN0eP9778egeEVRVabP60di4ETNocN5ybyxOWyu5B6M77mXcHTOS5aQkOS2zgpU7so8IiT6tMF6EOvEhpAe6WIO2bUsCUm+UDGbG6dmIXxcjjB5o/nWFoVgH+SdjScZQH99AC7M5VL6gks6Fc3xC9yJH7QhaOhlKV5iXCRRI0eMe47p+CjAADuxILg1lbmRzdHJlYW0NZW5kb2JqDTUgMCBvYmoNPDwvRGVjb2RlUGFybXM8PC9Db2x1bW5zIDQvUHJlZGljdG9yIDEyPj4vRmlsdGVyL0ZsYXRlRGVjb2RlL0lEWzw4NUQ1OTUxRDMwOTYxMkE4MTNFQjI2OEJFNEI2MEVFMT48OUY4Q0IzMjFGRDA5NDkzQ0FBRTAwMUZFNTc2M0MzRDY+XS9JbmZvIDE4IDAgUi9MZW5ndGggNTAvUm9vdCAyMCAwIFIvU2l6ZSAxOS9UeXBlL1hSZWYvV1sxIDIgMV0+PnN0cmVhbQ0KaN5iYgACJsbUuQxMDKy/gASfCJBgZAMRfECJNicgi4GBkSDB9BNTjPEvQIABAAo2BS0NZW5kc3RyZWFtDWVuZG9iag1zdGFydHhyZWYNMTE2DSUlRU9GDTIgMCBvYmoNPDwvTGVuZ3RoIDM1MjgvU3VidHlwZS9YTUwvVHlwZS9NZXRhZGF0YT4+c3RyZWFtDQo8P3hwYWNrZXQgYmVnaW49Iu+7vyIgaWQ9Ilc1TTBNcENlaGlIenJlU3pOVGN6a2M5ZCI/Pgo8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1ldGEvIiB4OnhtcHRrPSJBZG9iZSBYTVAgQ29yZSA3LjEtYzAwMCA3OS5jYjdjNWExLCAyMDIyLzA0LzE0LTA1OjIyOjM1ICAgICAgICAiPgogICA8cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPgogICAgICA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIgogICAgICAgICAgICB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iCiAgICAgICAgICAgIHhtbG5zOnBkZj0iaHR0cDovL25zLmFkb2JlLmNvbS9wZGYvMS4zLyIKICAgICAgICAgICAgeG1sbnM6ZGM9Imh0dHA6Ly9wdXJsLm9yZy9kYy9lbGVtZW50cy8xLjEvIgogICAgICAgICAgICB4bWxuczphZGhvY3dmPSJodHRwOi8vbnMuYWRvYmUuY29tL0Fjcm9iYXRBZGhvY1dvcmtmbG93LzEuMC8iCiAgICAgICAgICAgIHhtbG5zOnhtcE1NPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvbW0vIj4KICAgICAgICAgPHhtcDpDcmVhdGVEYXRlPjIwMjQtMDctMDRUMTc6MjY6NTcrMDg6MDA8L3htcDpDcmVhdGVEYXRlPgogICAgICAgICA8eG1wOkNyZWF0b3JUb29sPnBkZkZhY3RvcnkgUHJvIHd3dy5wZGZmYWN0b3J5LmNvbTwveG1wOkNyZWF0b3JUb29sPgogICAgICAgICA8eG1wOk1vZGlmeURhdGU+MjAyNC0wNy0wNVQwNjowNzo0NSswODowMDwveG1wOk1vZGlmeURhdGU+CiAgICAgICAgIDx4bXA6TWV0YWRhdGFEYXRlPjIwMjQtMDctMDVUMDY6MDc6NDUrMDg6MDA8L3htcDpNZXRhZGF0YURhdGU+CiAgICAgICAgIDxwZGY6UHJvZHVjZXI+cGRmRmFjdG9yeSBQcm8gNS4yNSAoV2luZG93cyA3IFByb2Zlc3Npb25hbCB4NjQgQ2hpbmVzZSAoU2ltcGxpZmllZCkpPC9wZGY6UHJvZHVjZXI+CiAgICAgICAgIDxkYzpmb3JtYXQ+YXBwbGljYXRpb24vcGRmPC9kYzpmb3JtYXQ+CiAgICAgICAgIDxkYzpjcmVhdG9yPgogICAgICAgICAgICA8cmRmOlNlcT4KICAgICAgICAgICAgICAgPHJkZjpsaT5BZG1pbmlzdHJhdG9yPC9yZGY6bGk+CiAgICAgICAgICAgIDwvcmRmOlNlcT4KICAgICAgICAgPC9kYzpjcmVhdG9yPgogICAgICAgICA8YWRob2N3ZjpzdGF0ZT4xPC9hZGhvY3dmOnN0YXRlPgogICAgICAgICA8YWRob2N3Zjp2ZXJzaW9uPjEuMTwvYWRob2N3Zjp2ZXJzaW9uPgogICAgICAgICA8eG1wTU06RG9jdW1lbnRJRD51dWlkOjI3YzUwNzdiLWEzMmEtMDA0NC04ODI2LTg4NDgzYmRkMmQ5YzwveG1wTU06RG9jdW1lbnRJRD4KICAgICAgICAgPHhtcE1NOkluc3RhbmNlSUQ+dXVpZDo0OWEyNTI3OS1lNDZhLWIyNDgtOWQ4OC05YjgwNTU5NDdkNmI8L3htcE1NOkluc3RhbmNlSUQ+CiAgICAgIDwvcmRmOkRlc2NyaXB0aW9uPgogICA8L3JkZjpSREY+CjwveDp4bXBtZXRhPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgCjw/eHBhY2tldCBlbmQ9InciPz4NZW5kc3RyZWFtDWVuZG9iag0yMSAwIG9iag08PC9Bbm5vdHMgNjggMCBSL0NvbnRlbnRzIDEwNiAwIFIvQ3JvcEJveFswIDAgMjE1IDM2OV0vTWVkaWFCb3hbMCAwIDIxNSAzNjldL1BhcmVudCAxNCAwIFIvUmVzb3VyY2VzPDwvQ29sb3JTcGFjZTw8L0NTMCAxMTMgMCBSL0NTMSAxMTQgMCBSL0NTMiAxMTUgMCBSPj4vRm9udDw8L0MwXzAgMTA1IDAgUj4+L1Byb2NTZXRbL1BERi9UZXh0L0ltYWdlQi9JbWFnZUMvSW1hZ2VJXS9YT2JqZWN0PDwvSW0wIDU2IDAgUi9JbTEgNTggMCBSL0ltMTAgNDIgMCBSL0ltMTEgNDUgMCBSL0ltMTIgNDYgMCBSL0ltMTMgNDggMCBSL0ltMiA2MCAwIFIvSW0zIDYxIDAgUi9JbTQgNjIgMCBSL0ltNSAzNyAwIFIvSW02IDM4IDAgUi9JbTcgMzkgMCBSL0ltOCA0MCAwIFIvSW05IDQxIDAgUj4+Pj4vUm90YXRlIDAvVHlwZS9QYWdlPj4NZW5kb2JqDTU2IDAgb2JqDTw8L0JpdHNQZXJDb21wb25lbnQgOC9Db2xvclNwYWNlWy9JbmRleGVkL0RldmljZVJHQiAyNTUgMjggMCBSXS9GaWx0ZXIvRmxhdGVEZWNvZGUvSGVpZ2h0IDE1L0xlbmd0aCA0NzMvTWFzayA1NSAwIFIvTmFtZS9pbTUvU3VidHlwZS9JbWFnZS9UeXBlL1hPYmplY3QvV2lkdGggNDU+PnN0cmVhbQ0KSIn7/x8FvHtv/sEGBHZLfPwUn/ofN3jx8pUNExJQtnn95i12pffuP7gLVGF97eGjdY+fPH3GUgbkJec+x6b2Qi7Q1NCL1ZcuX7l67fqNm7dun7gz2YGJ6S6bG4baY0Cla4+fOMmCcIX4qdNnzgLpc+dRle7dB1S7v/zAQSZUoHXo8BGgW44iq90QqcwUunHTZrCCBCbvLdO2btsOUb5j5y4mpt17EGoXLmJiWrxkKUguf9nyFV4rV9lnrS6JlFkDElmruq6MyWY9TO3EScpMno6TgRISU6YmdMdPmz5jZsms2VPnzGWaBxR0mK8KlFkAVVxlw1RWXQMypbauvqGxqbklprWNKbq9o7Oruwck3NvHxNQ/Aaw2NY2JSS4dKJaRyZSVnZOblw9xbUFhUXFJaX40E1NZeQUTUyVYcRATU3BIKFA2LDwiMioaKSxifGMl4uITmJgSQ5KYklOAau3smRwcnZiYnF1c3dw9wIocrD3FwQwvbx9fHz8gwz+AiSkQqFhJmUkF6AMmdjV1DU1Q0Grr6OrpGxgaGYM0mJiamVswMVlaWTPZ2P5nYGRiYgZFGysbOwcTEycXNw8vH7+AoJCwiKiYOJOEpJS0jCzQU/JMTAr/AYQrN3gNZW5kc3RyZWFtDWVuZG9iag01OCAwIG9iag08PC9CaXRzUGVyQ29tcG9uZW50IDgvQ29sb3JTcGFjZVsvSW5kZXhlZC9EZXZpY2VSR0IgMjU1IDI5IDAgUl0vRmlsdGVyL0ZsYXRlRGVjb2RlL0hlaWdodCAxNS9MZW5ndGggMzgxL01hc2sgNTcgMCBSL05hbWUvaW03L1N1YnR5cGUvSW1hZ2UvVHlwZS9YT2JqZWN0L1dpZHRoIDQ1Pj5zdHJlYW0NCkiJW2PEtHYdExjIMzHlrt+wcdPmLVvnbtu+Y+eu3Xv2Mu3bf+DgISYmrcNMTEeOTmJimjwFopiJo37qtOkzZs6aPWfuvPkLFi5avGTpMibu5StAcitXMTGurmFiqq2DKq5vaGxqbmFlai1sa2di6ujs6u7p7YPK9U9gYpqYzcSUA+Xn5uUXxIEYboVFxWCRktKy8gqIZGUVE1O1LFNMLIQbF5+QCGElJaekQliWaekZEJZwJhNTFiNTQCCEGxQcArWCOTQsHOaNiEh7CCuKgymakcnNHczR8fBkgqnw8vaBsZl8/SC0CyuTPxOTuC2YY2cPl2dycHRCcJyZYYpdjZiMTcAcU4Q0k5m5BYJjaQWmrDmYbBiZdHSZ0IGevgG6EIcQE5MhIxOTGoZidQ1NdCEtoCptYBwrsKLLKCopowupSDMxqXIzMYmJo8tISEqhC0nLMMnK8TIx8fGjywgIYlgmJMwkIsrAyMTMgi7Fxs6BJsLJxcTE/R8ABotVlA1lbmRzdHJlYW0NZW5kb2JqDTYwIDAgb2JqDTw8L0JpdHNQZXJDb21wb25lbnQgOC9Db2xvclNwYWNlWy9JbmRleGVkL0RldmljZVJHQiAyNTUgMzAgMCBSXS9GaWx0ZXIvRmxhdGVEZWNvZGUvSGVpZ2h0IDE1L0xlbmd0aCAzMjIvTWFzayA1OSAwIFIvTmFtZS9pbTkvU3VidHlwZS9JbWFnZS9UeXBlL1hPYmplY3QvV2lkdGggNDU+PnN0cmVhbQ0KSIl1kGVXAkEUhs+qOKio74odgI1iIBaKgaICJmInKHZ3F3b/5XEXRHZWfb7M3Hmfc8+9Q18BjwMsb++yB5g/gE9K73ho7i1s9PAoc5+eAdsLpdwFcHnFZtc3bK11+4FbKnBI4DIeMaH9mJVPToGzc1GmCmBL75WG2zuMu7u3D/4g4FLVErC8sipJ19al7oZvE7ByQZnO2IBZj2RJ75zEnfctAMpFGkLNA6NjreGFxsPuhHMSmJqmYXoI0NvX/2MMhC6uQfcQMDxCpbQLk3R0dtm/ncLgYXE4DcJ03W2UpbZOCOvNDaZG0UoTzaZmY4swGrHKXUrzC4jYsqhYX1JqKCuvqDRWmaqFF10N98sVSFGkBrqmZ2RmZedotGKhy837SxWJT0gkkk/jk9TJ/6kiXERklCKaEKKMiY1TydMvFcX1UQ1lbmRzdHJlYW0NZW5kb2JqDTEwNCAwIG9iag08PC9CYXNlRm9udC9YT1dOTkkrQWRvYmVIZWl0aVN0ZC1SZWd1bGFyL0NJRFN5c3RlbUluZm8gMTA5IDAgUi9EVyAxMDAwL0ZvbnREZXNjcmlwdG9yIDExMCAwIFIvU3VidHlwZS9DSURGb250VHlwZTAvVHlwZS9Gb250L1dbMFsxMDAwIDIyNCAyNjYgMzkyIDU1MSA1NjIgODgzIDY3NyAyNDFdOSAxMCAzMjIgMTFbNDcwIDY3NyAyNDcgMzQzIDI0NSAzNzBdMTcgMjYgNTYyIDI3WzI0NSAyNDddMjkgMzEgNjc3IDMyWzQ0NyA4MDggNjYxIDYwMiA2MTAgNzA4IDUzNSA1MjggNjg5IDcwMyAyNzUgNDA0IDYwMiA1MTQgODcxIDcwOCA3MjcgNTg1IDcyNyA1OTUgNTM5IDU0MSA2OTYgNjE5IDkyMiA2MTIgNTkxIDU4NCAzMjIgMzYyIDMyMiA2NzcgNTY4IDI0MSA1MzIgNjEyIDQ3NSA2MDggNTQzIDMzMiA2MDMgNjAxIDI2NSAyNzYgNTI0IDI2NCA5MDEgNjAxIDU5MCA2MTIgNjA3IDM2NyA0MzMgMzY5IDU5NyA1MjcgODAwIDUxMSA1MTggNDY4IDMyMSAyNzMgMzIxIDY3N104MTQgOTM5IDUwMCA3NzEyWzU5NyA3NjkgNjgzIDExMzYgNTAwXTIyMzUzIDIyMzU0IDU2MiAyMjM1NSAyMjM1NyA1MDAgMjkwNjQgMzAyODMgNTUwXT4+DWVuZG9iag0xMDUgMCBvYmoNPDwvQmFzZUZvbnQvWE9XTk5JK0Fkb2JlSGVpdGlTdGQtUmVndWxhci9EZXNjZW5kYW50Rm9udHMgMTA3IDAgUi9FbmNvZGluZy9JZGVudGl0eS1IL1N1YnR5cGUvVHlwZTAvVG9Vbmljb2RlIDEwOCAwIFIvVHlwZS9Gb250Pj4NZW5kb2JqDTEwNiAwIG9iag08PC9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDgyNT4+c3RyZWFtDQpIiZxX244TMQx9z1fkB8jajnOTENJeQOIRqMQjQksXirastlrB72Nnpjsd2qWZqNKo7fj4cuw49qMB66N30RIGx5ZdIbtbmx/ms/1lHg1akI8+fcwukL3dGnCJ7B9r9M3WELKDLF/vzSfzQT6P8gIhiMqqjPC0PiR0+Vgd2FeIjvJMHQyqRhcWuSf6fAwuxQOFBEUtgI0O/6d1DG2JarAEXngc2Cwqf9Jdgux8K5sUsgqd1al55CadexD6mqIIGoUASXmZBVihA/AAFl3MBzBUofMwAgfcAZM0xeVOejjAeOdjCyYog4s99Ml10ME4j6vRR47uMGXsmBtQoY/7QLPIGqmXep2VVaOxWNUvh7ELsQNWHOflRKagTWMxJSlrdhfDMtaTvxiWuqwVcD2oMC+tVljpMYbAXdZQGi53lDLqbdRxcFB6ZOqoSiToyjiStPIePql0OOmx66Sin/euVh99mZ/wVhz3FAqnOZGtsQV0He0EQ3SZl98CKICOFovSLGOXuc4UJNI5Z7mfiV1PEqTNdiU9h64ZA8s/B6GVzsJdgwaW5BaEp38PU2PS7J2eGkdVZ2ZGVOt29108FYK99zbI3EMahai9E5W+xl7Vgl7/8pTM+8CqWAxcvN+CvXmojr0gy35YCUQUT4rmvaTYH+RoLwdVRhyUcZHr96zkZM1r0m1kkPct8hGVrgHARwAmjUh/1OGfS2UkJL1fBkw4wviyx7COzjKNZVkshMIBEI+NyIoyyku8MvNVfnhcRASSjiFRHZkwSZPjZTaNe7/yhCG5tUM8u1N4gDGshj1FuPQjl1hn26idVG9e3HtdJg+qdKAptbURysF4LgGYhHVbPL8BIcXRVIO3AVuWKmnPjTuVRsRZhwUVqcGEogHqoc3PQeGMgahvBnmhOWnesDzL0qFsJj0pB7JiH32eqg6fa3u6OJM68NKyKf1ClNLUZXytbO3ZZOWN1M1LxIyaMaWThKeoxTWxc7WqIYDdWHCYUCUvPq7vvz5tfq+vH+4fdpvt+mm3ubW7jbm4hi8SpF3dGbKrnZyyXLS1y+wQ5d9v5jXiZYR4hRDDJdwEBsR3b1Y/zduV+SvAAFgbRkANZW5kc3RyZWFtDWVuZG9iag0xMDcgMCBvYmoNWzEwNCAwIFJdDWVuZG9iag0xMDggMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCAyNjM+PnN0cmVhbQ0KSIlckNtqhDAQhu/zFHO5e7HEyCotiOCuFbzogdo+gCajG6gxxHjh23eMyxY6kMDHP/+c+LUua6M98A83yQY99Nooh/O0OInQ4aANEzEoLf2dwi/H1jJO5madPY616SeWZcA/SZy9W+FQqKnDI+PvTqHTZoDD97U5Am8Wa39wROMhgjwHhT0Vem3tWzsi8GA71Yp07dcTef4yvlaLEAcW+zByUjjbVqJrzYAsiyhyyCqKnKFR//Rkd3W9vLWOsoWoQrYocqIyORMlVVRtlCYFUZpcnomEKNJA8a5dBNH5pXwKXe71tn50FngsIxfnaI9wu7DANro2+DivnSyQa3vsV4ABABBNe3gNZW5kc3RyZWFtDWVuZG9iag0xMDkgMCBvYmoNPDwvT3JkZXJpbmcoR0IxKS9SZWdpc3RyeShBZG9iZSkvU3VwcGxlbWVudCA1Pj4NZW5kb2JqDTExMCAwIG9iag08PC9Bc2NlbnQgOTY3L0NJRFNldCAxMTEgMCBSL0NhcEhlaWdodCA3NjMvRGVzY2VudCAtMjgzL0ZsYWdzIDQvRm9udEJCb3hbLTE2MyAtMjgzIDEwODcgOTY3XS9Gb250RmFtaWx5KEFkb2JlIEhlaXRpIFN0ZCBSKS9Gb250RmlsZTMgMTEyIDAgUi9Gb250TmFtZS9YT1dOTkkrQWRvYmVIZWl0aVN0ZC1SZWd1bGFyL0ZvbnRTdHJldGNoL05vcm1hbC9Gb250V2VpZ2h0IDQwMC9JdGFsaWNBbmdsZSAwL1N0ZW1WIDExNi9UeXBlL0ZvbnREZXNjcmlwdG9yL1hIZWlnaHQgNTUxPj4NZW5kb2JqDTExMSAwIG9iag08PC9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDM0Pj5zdHJlYW0NCkiJamAgCBgJKxkUQAHBdBgoN9AQcAy0A+CACSDAAKgwAOwNZW5kc3RyZWFtDWVuZG9iag0xMTIgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCAxMjQ0L1N1YnR5cGUvQ0lERm9udFR5cGUwQz4+c3RyZWFtDQpIiWxReVATZxTf5ciusMZCWAdMTNKKN0hARLTqFFEEj6B4gKgokCWmhABJwCJ2ahVyQLJZDhEtWigCWtRoEUvHSUs9sI6jTKnWEWp1nFqrtTqdHm/DF6dNmPaPTn1//Ob9jjfffO/hWIAfhuP45Kz0TKUybXaSqjiPSWU0Rs16oyo6g1GXaXP1vsBiXsxLOErKT8b58ABeStFoPnKOfjO6JVCajb1HySQhXdQbtqbJmP39WiFcmgC3Q+AmNVUScI+KxAgcF4zLVld/5Bp7YMXS2OTikgq9Rr3TKI9TKBKifJjow1jFGMbKx4Ly9RUGI1NkkKfp8ov1JcX6XCOjmiNP0mrlGb5hgzyDMTD6cq8Yk7J+Q0UJI0+Uq5iCV34jeplGp87LNRpe7a5gdIxek/9qMzVXt1uDYRguE2QLzo7fENKJ4ZiftzCBd39YOmbGZfgdv5v+NkS5RsNd+AuXe63L/wWiaPe50T0vzwn4SM92Gg3x0YHu1wToE88mGnzk5QDxUpE31sOQx8sV7he0r0M+JtwHCXALEnBYDAn+wLon0DlqdU6OU93X53T2ndec3SrzlAf8TxPy4+6C6A7O+/0E+sdh/fygewNdfsY4sN+JME34EW3nmgM7yF2okOZ6HT2OPhLWgtJq+kX2iDDNQFOsaK0YKZHczkXKYon7jnt2CLNZF5nT9q8rQ3MVSIKmJ/fsdRpb1bAEovofHoMsEroEWnSkKmO7EY3rjHCq27dxKniz42h745/dPB5uMTDWfLGQbxvGIes7PuN+2A7+V7DSxouqEe3leFV497aepNYkEn0LPTR6TiSb5lVnSB+7NYITF7u/qHO0tZgbyx1ljrebNC2Vm4rji1ILFigjt6Yfr2w1HNSf+rK9t/c+ycNJ+nrNeUuviXxO5Jh2WJQ1JAQRbY4LXJ20ucnClYkr81muUOYo5OQLJqHVKIjllLJZRP1NCGBhtdizmWB0FcivWdrBHM6xG0hYePRQ071JwjQQwdnbMOtO8t1QODkMKcNLR0RZ7rvuUrq4Q9epbV+5Mfx06XHdhyWkJ9pzgQYDcbmm13K6mnxCVOVstCSIEzLZ+m2yaKKn7jN20EaiKmLZuyl7s82HCxvVdXkPT4PuOhDHrCdq2xzdBZXLdy3ZTYqeQQrfTqMYM5ppmWFfxUbYZl5v/L0OprIREOdoRnGtc85ERbjQxAdTH2zpL/q0pReWG+tVHSUf74t+f7fRSoqGSy1rrqRDmO5qyW97YCFI2Ue1gybr83DR1jX7Z1ehKWbzjw2Xmg+SH7RY643i0ixHvU4mesblcqsa4kghLxkC6RDOqx6G9cMfvISGEYEuRflWYurKK5m3CkbIeWb63PQbMTfS4zYjRQaSVp8o6mQO6YA+BfGDjweAXAoR20Gqb3C29LWeRJFWNPH4HNeTkeGfB2Auuc6C/M3x3htJCVgEAdaqZ7IfiOooJLCgReKnxFG2oale2tJkOVhu2WnS2pmGune4zJpENN+G/NgojowjnnKAsbDAu08pEYOC7exKWTzRxXba2+2kEPPH8SCRhJdR0zokAX+F8nJq2hFJYEQo/zo1rUsSODsUsbWSwJRawXDQ98HXWijqWis13kaFjO4J+9dxBbmC/6t8FfR18OcHDlDUVS/8k/5bgAEAVS1cXQ1lbmRzdHJlYW0NZW5kb2JqDTExMyAwIG9iag1bL0luZGV4ZWQvRGV2aWNlUkdCIDI1NSAyOCAwIFJdDWVuZG9iag0xMTQgMCBvYmoNWy9JbmRleGVkL0RldmljZVJHQiAyNTUgMjkgMCBSXQ1lbmRvYmoNMTE1IDAgb2JqDVsvSW5kZXhlZC9EZXZpY2VSR0IgMjU1IDMwIDAgUl0NZW5kb2JqDTExNiAwIG9iag08PC9GaWx0ZXIvRmxhdGVEZWNvZGUvRmlyc3QgNS9MZW5ndGggMTc3L04gMS9UeXBlL09ialN0bT4+c3RyZWFtDQpo3mSOQQuCMBzFv8puOgL9O5yTEEGUbkHQoYuX4SYOdJNtYn37FkUQ3R4/3vvxshIBqqq02fxkbNyIRWnlvOXeWJy2VnKvjO64l3F3JEByYJBnjBSUHaCMAKJPK4xXMZ74ENIDXaxB+74nAY1vlAxmwenZiF8XhQJYTr+uMBTbIP9kNCEU9fFNaWF2h9gLjtK5cI7P6F7kqJ2Ulk6G0lUt66xGJUWPe4zr+inAAA+qSDANZW5kc3RyZWFtDWVuZG9iag0xMTcgMCBvYmoNPDwvRGVjb2RlUGFybXM8PC9Db2x1bW5zIDMvUHJlZGljdG9yIDEyPj4vRmlsdGVyL0ZsYXRlRGVjb2RlL0lEWzw4NUQ1OTUxRDMwOTYxMkE4MTNFQjI2OEJFNEI2MEVFMT48NTQ1RjMwRDAzM0QyNEY0MEE0QUREMUNDNUMyNjRFMjg+XS9JbmRleFsyIDEgMTggMSAyMSAxIDU2IDEgNTggMSA2MCAxIDEwMSAxN10vSW5mbyAxOCAwIFIvTGVuZ3RoIDc5L1ByZXYgMTE2L1Jvb3QgMjAgMCBSL1NpemUgMTE4L1R5cGUvWFJlZi9XWzEgMiAwXT4+c3RyZWFtDQpo3mJirH7NxNjayfS/s5uJgWklEwPzPCDtxPS/oIKJgYEBjBkn9QPFwpgYGCcB5euBtDQQ+wLlHIG0AhCnMzGwWgL5hgjMxA8QYAAkCwzUDWVuZHN0cmVhbQ1lbmRvYmoNc3RhcnR4cmVmDTQxNzI5DSUlRU9GDTIgMCBvYmoNPDwvTGVuZ3RoIDM1MjgvU3VidHlwZS9YTUwvVHlwZS9NZXRhZGF0YT4+c3RyZWFtDQo8P3hwYWNrZXQgYmVnaW49Iu+7vyIgaWQ9Ilc1TTBNcENlaGlIenJlU3pOVGN6a2M5ZCI/Pgo8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1ldGEvIiB4OnhtcHRrPSJBZG9iZSBYTVAgQ29yZSA3LjEtYzAwMCA3OS5jYjdjNWExLCAyMDIyLzA0LzE0LTA1OjIyOjM1ICAgICAgICAiPgogICA8cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPgogICAgICA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIgogICAgICAgICAgICB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iCiAgICAgICAgICAgIHhtbG5zOnBkZj0iaHR0cDovL25zLmFkb2JlLmNvbS9wZGYvMS4zLyIKICAgICAgICAgICAgeG1sbnM6ZGM9Imh0dHA6Ly9wdXJsLm9yZy9kYy9lbGVtZW50cy8xLjEvIgogICAgICAgICAgICB4bWxuczphZGhvY3dmPSJodHRwOi8vbnMuYWRvYmUuY29tL0Fjcm9iYXRBZGhvY1dvcmtmbG93LzEuMC8iCiAgICAgICAgICAgIHhtbG5zOnhtcE1NPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvbW0vIj4KICAgICAgICAgPHhtcDpDcmVhdGVEYXRlPjIwMjQtMDctMDRUMTc6MjY6NTcrMDg6MDA8L3htcDpDcmVhdGVEYXRlPgogICAgICAgICA8eG1wOkNyZWF0b3JUb29sPnBkZkZhY3RvcnkgUHJvIHd3dy5wZGZmYWN0b3J5LmNvbTwveG1wOkNyZWF0b3JUb29sPgogICAgICAgICA8eG1wOk1vZGlmeURhdGU+MjAyNC0wNy0wNVQwNjoxODo0MiswODowMDwveG1wOk1vZGlmeURhdGU+CiAgICAgICAgIDx4bXA6TWV0YWRhdGFEYXRlPjIwMjQtMDctMDVUMDY6MTg6NDIrMDg6MDA8L3htcDpNZXRhZGF0YURhdGU+CiAgICAgICAgIDxwZGY6UHJvZHVjZXI+cGRmRmFjdG9yeSBQcm8gNS4yNSAoV2luZG93cyA3IFByb2Zlc3Npb25hbCB4NjQgQ2hpbmVzZSAoU2ltcGxpZmllZCkpPC9wZGY6UHJvZHVjZXI+CiAgICAgICAgIDxkYzpmb3JtYXQ+YXBwbGljYXRpb24vcGRmPC9kYzpmb3JtYXQ+CiAgICAgICAgIDxkYzpjcmVhdG9yPgogICAgICAgICAgICA8cmRmOlNlcT4KICAgICAgICAgICAgICAgPHJkZjpsaT5BZG1pbmlzdHJhdG9yPC9yZGY6bGk+CiAgICAgICAgICAgIDwvcmRmOlNlcT4KICAgICAgICAgPC9kYzpjcmVhdG9yPgogICAgICAgICA8YWRob2N3ZjpzdGF0ZT4xPC9hZGhvY3dmOnN0YXRlPgogICAgICAgICA8YWRob2N3Zjp2ZXJzaW9uPjEuMTwvYWRob2N3Zjp2ZXJzaW9uPgogICAgICAgICA8eG1wTU06RG9jdW1lbnRJRD51dWlkOjI3YzUwNzdiLWEzMmEtMDA0NC04ODI2LTg4NDgzYmRkMmQ5YzwveG1wTU06RG9jdW1lbnRJRD4KICAgICAgICAgPHhtcE1NOkluc3RhbmNlSUQ+dXVpZDo1NDQ0Yzk0Ni0wNzQzLTJjNGEtOTFmNi00YzUxZjgyZjMwZmI8L3htcE1NOkluc3RhbmNlSUQ+CiAgICAgIDwvcmRmOkRlc2NyaXB0aW9uPgogICA8L3JkZjpSREY+CjwveDp4bXBtZXRhPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgCjw/eHBhY2tldCBlbmQ9InciPz4NZW5kc3RyZWFtDWVuZG9iag0xMTggMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0ZpcnN0IDI2L0xlbmd0aCAzNzQvTiA0L1R5cGUvT2JqU3RtPj5zdHJlYW0NCmjerFJNT+NADP0rPraHHWc831JVKd0QkIBV1UZC2qqHtgmhKiQIwmr59zuJwwGVA4c9JG9sz7Pfc2ItJOAUkPbgNKgQIwOGNMxmmKUTvKoe/8QrxX181TDFbBULF82hLY9NHY/LLM/aw0cCQry2ms8xb5suVtOy3VfrtqnXXfnj5lg/dNAPXHFbNxx/77I9eOb1zGP1WL5u7NAJXMIgGYjBMFgGx+AZmOeZ55nnmecVg2YYu3DSDcntfD76/kK5pHENU8xBY15g8Rdvr2ezqHoJNIzCVXXoNk7IEIIHlWihjQFKnKA4SJEVztMW12/77v25wrtjWVcdFpPn3eG0qytVPk2x6Ctp07Td/1FDJIyXHshpkUSUISZ0VBVsH3+h5qTOVKQQhs1iuozRLyAzfunvyLO9vEXXYH4P1hhlB6G4+LlJhDMU1BYXlxspEhifLRZLkGdOpIzr652QYgcJCTIayA6cMx/73Uv8L6vPZv4JMAABC8KKDWVuZHN0cmVhbQ1lbmRvYmoNMTE5IDAgb2JqDTw8L0ZpbHRlci9GbGF0ZURlY29kZS9GaXJzdCA1L0xlbmd0aCAxNzcvTiAxL1R5cGUvT2JqU3RtPj5zdHJlYW0NCmjeZI5BC4MgAIX/ireSQZloxYggit0Ggx126SKpJJSGGm7/fo6Nwdjt8fHexytqgEDT5N3uZ2PTjq9KK+ct88bCvLeCeWX0wLxIhyNGmKAKkaLCJa0OqE4QSj6tON64PLEppge4WANCCFlE8o2yyawwPxv+66KoLGqCv6445Psk/mQ0wxSM6U1pboID1QtK4Vw8xxZwLwnoZ6WFE7F0Veu2KKkEH+EIYds+BRgAD1BILw1lbmRzdHJlYW0NZW5kb2JqDTEyMCAwIG9iag08PC9EZWNvZGVQYXJtczw8L0NvbHVtbnMgNC9QcmVkaWN0b3IgMTI+Pi9GaWx0ZXIvRmxhdGVEZWNvZGUvSURbPDg1RDU5NTFEMzA5NjEyQTgxM0VCMjY4QkU0QjYwRUUxPjxEMDI2RTk0MTJFQTY0NkUwOTg5NURGQTYxM0U5OEQyRT5dL0luZGV4WzIgMSAxOCAxIDY2IDEgNzMgMyAxMTggM10vSW5mbyAxOCAwIFIvTGVuZ3RoIDQzL1ByZXYgNDE3MjkvUm9vdCAyMCAwIFIvU2l6ZSAxMjEvVHlwZS9YUmVmL1dbMSAyIDFdPj5zdHJlYW0NCmjeYmJc0szAxBjzhYGJgeE/iGBgRCL+b1L8y8TAdBUowcjPABBgAK3CB0QNZW5kc3RyZWFtDWVuZG9iag1zdGFydHhyZWYNNDY0NTkNJSVFT0YNMiAwIG9iag08PC9MZW5ndGggMzUyOC9TdWJ0eXBlL1hNTC9UeXBlL01ldGFkYXRhPj5zdHJlYW0NCjw/eHBhY2tldCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+Cjx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDcuMS1jMDAwIDc5LmNiN2M1YTEsIDIwMjIvMDQvMTQtMDU6MjI6MzUgICAgICAgICI+CiAgIDxyZGY6UkRGIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+CiAgICAgIDxyZGY6RGVzY3JpcHRpb24gcmRmOmFib3V0PSIiCiAgICAgICAgICAgIHhtbG5zOnhtcD0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLyIKICAgICAgICAgICAgeG1sbnM6cGRmPSJodHRwOi8vbnMuYWRvYmUuY29tL3BkZi8xLjMvIgogICAgICAgICAgICB4bWxuczpkYz0iaHR0cDovL3B1cmwub3JnL2RjL2VsZW1lbnRzLzEuMS8iCiAgICAgICAgICAgIHhtbG5zOmFkaG9jd2Y9Imh0dHA6Ly9ucy5hZG9iZS5jb20vQWNyb2JhdEFkaG9jV29ya2Zsb3cvMS4wLyIKICAgICAgICAgICAgeG1sbnM6eG1wTU09Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iPgogICAgICAgICA8eG1wOkNyZWF0ZURhdGU+MjAyNC0wNy0wNFQxNzoyNjo1NyswODowMDwveG1wOkNyZWF0ZURhdGU+CiAgICAgICAgIDx4bXA6Q3JlYXRvclRvb2w+cGRmRmFjdG9yeSBQcm8gd3d3LnBkZmZhY3RvcnkuY29tPC94bXA6Q3JlYXRvclRvb2w+CiAgICAgICAgIDx4bXA6TW9kaWZ5RGF0ZT4yMDI0LTA3LTA1VDA2OjE4OjU3KzA4OjAwPC94bXA6TW9kaWZ5RGF0ZT4KICAgICAgICAgPHhtcDpNZXRhZGF0YURhdGU+MjAyNC0wNy0wNVQwNjoxODo1NyswODowMDwveG1wOk1ldGFkYXRhRGF0ZT4KICAgICAgICAgPHBkZjpQcm9kdWNlcj5wZGZGYWN0b3J5IFBybyA1LjI1IChXaW5kb3dzIDcgUHJvZmVzc2lvbmFsIHg2NCBDaGluZXNlIChTaW1wbGlmaWVkKSk8L3BkZjpQcm9kdWNlcj4KICAgICAgICAgPGRjOmZvcm1hdD5hcHBsaWNhdGlvbi9wZGY8L2RjOmZvcm1hdD4KICAgICAgICAgPGRjOmNyZWF0b3I+CiAgICAgICAgICAgIDxyZGY6U2VxPgogICAgICAgICAgICAgICA8cmRmOmxpPkFkbWluaXN0cmF0b3I8L3JkZjpsaT4KICAgICAgICAgICAgPC9yZGY6U2VxPgogICAgICAgICA8L2RjOmNyZWF0b3I+CiAgICAgICAgIDxhZGhvY3dmOnN0YXRlPjE8L2FkaG9jd2Y6c3RhdGU+CiAgICAgICAgIDxhZGhvY3dmOnZlcnNpb24+MS4xPC9hZGhvY3dmOnZlcnNpb24+CiAgICAgICAgIDx4bXBNTTpEb2N1bWVudElEPnV1aWQ6MjdjNTA3N2ItYTMyYS0wMDQ0LTg4MjYtODg0ODNiZGQyZDljPC94bXBNTTpEb2N1bWVudElEPgogICAgICAgICA8eG1wTU06SW5zdGFuY2VJRD51dWlkOjA4MTIzYTBhLWJlNmItNzI0NS05ZjEzLTUwZmRhNTJjNTY4NTwveG1wTU06SW5zdGFuY2VJRD4KICAgICAgPC9yZGY6RGVzY3JpcHRpb24+CiAgIDwvcmRmOlJERj4KPC94OnhtcG1ldGE+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAKPD94cGFja2V0IGVuZD0idyI/Pg1lbmRzdHJlYW0NZW5kb2JqDTEyMSAwIG9iag08PC9GaWx0ZXIvRmxhdGVEZWNvZGUvRmlyc3QgMTIvTGVuZ3RoIDI1Mi9OIDIvVHlwZS9PYmpTdG0+PnN0cmVhbQ0KaN5skE1rhDAQhv/KHNdDHc2qSUECgpVCP1hUWOiyh6rZbECSwqal/feNjr31kmd4J+98FQUkwAtgmYCyxLra4aOav4LYX8KjIcK6DYkHO7rJWB3CQ93UbvwT4D58a6XExlkfstXkBtU5qzs/3T0bffWwtGipLF/Dt/d6AEG+xWnUPN1OxVoJeEJICYyQEzhBEMggyCDIIMgg9oSMsNlJ5CTyda6zlNve/0yesu0METaQYdNj/40vT2UZpj4AWztiq0Z/StOYi1QELYkZsITFyT5cleVxkedn7D4H//Oh8GgmrTz2u9lpc/NmfHUR9kumstZ5KX8FGABuf2WiDWVuZHN0cmVhbQ1lbmRvYmoNMTIyIDAgb2JqDTw8L0ZpbHRlci9GbGF0ZURlY29kZS9GaXJzdCA1L0xlbmd0aCAxNzYvTiAxL1R5cGUvT2JqU3RtPj5zdHJlYW0NCmjeZI5BC4MgAIX/ireSQZlkxoggit0Ggx126SKpJJSGGm7/fo7tsLHb4+O9j1fUAIGmybvdz8amHV+VVs5b5o2FeW8F88rogXmRDkeMcIkoKguKK0IPqE4QSj6tON64PLEppge4WANCCFlE8o2yyawwPxv+6yKoKuovVxzyfRJ/MpJhAsb0pjQ3wQH6glI4F8+xBdyrEvSz0sKJWLqqdVuUVIKPcISwbZ8CDAARi0g1DWVuZHN0cmVhbQ1lbmRvYmoNMTIzIDAgb2JqDTw8L0RlY29kZVBhcm1zPDwvQ29sdW1ucyA0L1ByZWRpY3RvciAxMj4+L0ZpbHRlci9GbGF0ZURlY29kZS9JRFs8ODVENTk1MUQzMDk2MTJBODEzRUIyNjhCRTRCNjBFRTE+PDlBOEQxNzAzMjI3QTRGRTlBNDI0QzlDMTZFQTBCODEyPl0vSW5kZXhbMiAxIDE4IDEgNjYgMSA3NiAxIDEyMSAzXS9JbmZvIDE4IDAgUi9MZW5ndGggNDIvUHJldiA0NjQ1OS9Sb290IDIwIDAgUi9TaXplIDEyNC9UeXBlL1hSZWYvV1sxIDIgMV0+PnN0cmVhbQ0KaN5iYtx2gYGJ0WsVAxMDw38QwcDI9P9I9n8mBqZoIJeRjwEgwACNewckDWVuZHN0cmVhbQ1lbmRvYmoNc3RhcnR4cmVmDTUxMDIxDSUlRU9GDTIgMCBvYmoNPDwvTGVuZ3RoIDM1MjgvU3VidHlwZS9YTUwvVHlwZS9NZXRhZGF0YT4+c3RyZWFtDQo8P3hwYWNrZXQgYmVnaW49Iu+7vyIgaWQ9Ilc1TTBNcENlaGlIenJlU3pOVGN6a2M5ZCI/Pgo8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1ldGEvIiB4OnhtcHRrPSJBZG9iZSBYTVAgQ29yZSA3LjEtYzAwMCA3OS5jYjdjNWExLCAyMDIyLzA0LzE0LTA1OjIyOjM1ICAgICAgICAiPgogICA8cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPgogICAgICA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIgogICAgICAgICAgICB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iCiAgICAgICAgICAgIHhtbG5zOnBkZj0iaHR0cDovL25zLmFkb2JlLmNvbS9wZGYvMS4zLyIKICAgICAgICAgICAgeG1sbnM6ZGM9Imh0dHA6Ly9wdXJsLm9yZy9kYy9lbGVtZW50cy8xLjEvIgogICAgICAgICAgICB4bWxuczphZGhvY3dmPSJodHRwOi8vbnMuYWRvYmUuY29tL0Fjcm9iYXRBZGhvY1dvcmtmbG93LzEuMC8iCiAgICAgICAgICAgIHhtbG5zOnhtcE1NPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvbW0vIj4KICAgICAgICAgPHhtcDpDcmVhdGVEYXRlPjIwMjQtMDctMDRUMTc6MjY6NTcrMDg6MDA8L3htcDpDcmVhdGVEYXRlPgogICAgICAgICA8eG1wOkNyZWF0b3JUb29sPnBkZkZhY3RvcnkgUHJvIHd3dy5wZGZmYWN0b3J5LmNvbTwveG1wOkNyZWF0b3JUb29sPgogICAgICAgICA8eG1wOk1vZGlmeURhdGU+MjAyNC0wNy0wNVQwNjoxOToyNCswODowMDwveG1wOk1vZGlmeURhdGU+CiAgICAgICAgIDx4bXA6TWV0YWRhdGFEYXRlPjIwMjQtMDctMDVUMDY6MTk6MjQrMDg6MDA8L3htcDpNZXRhZGF0YURhdGU+CiAgICAgICAgIDxwZGY6UHJvZHVjZXI+cGRmRmFjdG9yeSBQcm8gNS4yNSAoV2luZG93cyA3IFByb2Zlc3Npb25hbCB4NjQgQ2hpbmVzZSAoU2ltcGxpZmllZCkpPC9wZGY6UHJvZHVjZXI+CiAgICAgICAgIDxkYzpmb3JtYXQ+YXBwbGljYXRpb24vcGRmPC9kYzpmb3JtYXQ+CiAgICAgICAgIDxkYzpjcmVhdG9yPgogICAgICAgICAgICA8cmRmOlNlcT4KICAgICAgICAgICAgICAgPHJkZjpsaT5BZG1pbmlzdHJhdG9yPC9yZGY6bGk+CiAgICAgICAgICAgIDwvcmRmOlNlcT4KICAgICAgICAgPC9kYzpjcmVhdG9yPgogICAgICAgICA8YWRob2N3ZjpzdGF0ZT4xPC9hZGhvY3dmOnN0YXRlPgogICAgICAgICA8YWRob2N3Zjp2ZXJzaW9uPjEuMTwvYWRob2N3Zjp2ZXJzaW9uPgogICAgICAgICA8eG1wTU06RG9jdW1lbnRJRD51dWlkOjI3YzUwNzdiLWEzMmEtMDA0NC04ODI2LTg4NDgzYmRkMmQ5YzwveG1wTU06RG9jdW1lbnRJRD4KICAgICAgICAgPHhtcE1NOkluc3RhbmNlSUQ+dXVpZDoyNDFlYTYwOS02OWYyLWUzNDQtYmY4OC0wMWE0ZjA4M2VmYWU8L3htcE1NOkluc3RhbmNlSUQ+CiAgICAgIDwvcmRmOkRlc2NyaXB0aW9uPgogICA8L3JkZjpSREY+CjwveDp4bXBtZXRhPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgCjw/eHBhY2tldCBlbmQ9InciPz4NZW5kc3RyZWFtDWVuZG9iag0xMjQgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0ZpcnN0IDEyL0xlbmd0aCAyNTEvTiAyL1R5cGUvT2JqU3RtPj5zdHJlYW0NCmjebJDdaoQwEIVfZS7XizrGtUkECQipFNrCokJhl71YTWqFJSlsWtq3b3TsXQnkG86c+Uk4hwyEgLyQUFWo6x0+2utXFPu3eE2QoG5j4sGN3sxuiuFBN9qPfwKU0dYqhY13IWZr4wfbeTd1wdw9z9N7gGVES23FGh4vegBJdUvlbK/mduJrJxAZgRFywj1BEsgpySnJKckp94SCsNWRKEgUnLAuc1Zqe/c/m7N8+4YEGyiw6bH/xpenqopbHyBfB2Nrx3Aq0jKLB5jkKd9zKPgiMGClTCWTZ+w+h/DzYfF1NpMN2O9u1hl9CTbBftFr53xQ6leAAQBoZWVIDWVuZHN0cmVhbQ1lbmRvYmoNMTI1IDAgb2JqDTw8L0ZpbHRlci9GbGF0ZURlY29kZS9GaXJzdCA1L0xlbmd0aCAxNzgvTiAxL1R5cGUvT2JqU3RtPj5zdHJlYW0NCmjeZI5BC4MgAIX/ireSQZlkbiOCKHYbDHbYpYukklAaarj9+zk2BmO3x8d7H6/YAwTqOm83PxmbtnxRWjlvmTcW5p0VzCuje+ZF2h8xwiWiqCworgjdoX2CUPJpxfHK5YmNMT3AxRoQQsgikm+UjWaB+dnwXxdBVXHA5dcVh3wbxZ+MZJiAIb0pzU1wgL6gFM7Fc2wG96oE3aS0cCKWrmpZZyWV4AMcIGyapwADAA+vSDANZW5kc3RyZWFtDWVuZG9iag0xMjYgMCBvYmoNPDwvRGVjb2RlUGFybXM8PC9Db2x1bW5zIDQvUHJlZGljdG9yIDEyPj4vRmlsdGVyL0ZsYXRlRGVjb2RlL0lEWzw4NUQ1OTUxRDMwOTYxMkE4MTNFQjI2OEJFNEI2MEVFMT48OEZBQTA1QTlBNzg3NDUwRThDNUY0QkEyOTA4OEMwNDQ+XS9JbmRleFsyIDEgMTggMSA2NiAxIDc3IDEgMTI0IDNdL0luZm8gMTggMCBSL0xlbmd0aCA0Mi9QcmV2IDUxMDIxL1Jvb3QgMjAgMCBSL1NpemUgMTI3L1R5cGUvWFJlZi9XWzEgMiAxXT4+c3RyZWFtDQpo3mJiPLGQgYnR4g4DEwPDfxDBwMj0/5rlfyYGpiggl1GAASDAAIvKBwgNZW5kc3RyZWFtDWVuZG9iag1zdGFydHhyZWYNNTU1ODMNJSVFT0YNMiAwIG9iag08PC9MZW5ndGggMzUyOC9TdWJ0eXBlL1hNTC9UeXBlL01ldGFkYXRhPj5zdHJlYW0NCjw/eHBhY2tldCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+Cjx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDcuMS1jMDAwIDc5LmNiN2M1YTEsIDIwMjIvMDQvMTQtMDU6MjI6MzUgICAgICAgICI+CiAgIDxyZGY6UkRGIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+CiAgICAgIDxyZGY6RGVzY3JpcHRpb24gcmRmOmFib3V0PSIiCiAgICAgICAgICAgIHhtbG5zOnhtcD0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLyIKICAgICAgICAgICAgeG1sbnM6cGRmPSJodHRwOi8vbnMuYWRvYmUuY29tL3BkZi8xLjMvIgogICAgICAgICAgICB4bWxuczpkYz0iaHR0cDovL3B1cmwub3JnL2RjL2VsZW1lbnRzLzEuMS8iCiAgICAgICAgICAgIHhtbG5zOmFkaG9jd2Y9Imh0dHA6Ly9ucy5hZG9iZS5jb20vQWNyb2JhdEFkaG9jV29ya2Zsb3cvMS4wLyIKICAgICAgICAgICAgeG1sbnM6eG1wTU09Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iPgogICAgICAgICA8eG1wOkNyZWF0ZURhdGU+MjAyNC0wNy0wNFQxNzoyNjo1NyswODowMDwveG1wOkNyZWF0ZURhdGU+CiAgICAgICAgIDx4bXA6Q3JlYXRvclRvb2w+cGRmRmFjdG9yeSBQcm8gd3d3LnBkZmZhY3RvcnkuY29tPC94bXA6Q3JlYXRvclRvb2w+CiAgICAgICAgIDx4bXA6TW9kaWZ5RGF0ZT4yMDI0LTA3LTA1VDA2OjE5OjUzKzA4OjAwPC94bXA6TW9kaWZ5RGF0ZT4KICAgICAgICAgPHhtcDpNZXRhZGF0YURhdGU+MjAyNC0wNy0wNVQwNjoxOTo1MyswODowMDwveG1wOk1ldGFkYXRhRGF0ZT4KICAgICAgICAgPHBkZjpQcm9kdWNlcj5wZGZGYWN0b3J5IFBybyA1LjI1IChXaW5kb3dzIDcgUHJvZmVzc2lvbmFsIHg2NCBDaGluZXNlIChTaW1wbGlmaWVkKSk8L3BkZjpQcm9kdWNlcj4KICAgICAgICAgPGRjOmZvcm1hdD5hcHBsaWNhdGlvbi9wZGY8L2RjOmZvcm1hdD4KICAgICAgICAgPGRjOmNyZWF0b3I+CiAgICAgICAgICAgIDxyZGY6U2VxPgogICAgICAgICAgICAgICA8cmRmOmxpPkFkbWluaXN0cmF0b3I8L3JkZjpsaT4KICAgICAgICAgICAgPC9yZGY6U2VxPgogICAgICAgICA8L2RjOmNyZWF0b3I+CiAgICAgICAgIDxhZGhvY3dmOnN0YXRlPjE8L2FkaG9jd2Y6c3RhdGU+CiAgICAgICAgIDxhZGhvY3dmOnZlcnNpb24+MS4xPC9hZGhvY3dmOnZlcnNpb24+CiAgICAgICAgIDx4bXBNTTpEb2N1bWVudElEPnV1aWQ6MjdjNTA3N2ItYTMyYS0wMDQ0LTg4MjYtODg0ODNiZGQyZDljPC94bXBNTTpEb2N1bWVudElEPgogICAgICAgICA8eG1wTU06SW5zdGFuY2VJRD51dWlkOmJlYjNjOTYxLWRlZDUtM2U0Ny1iMjVjLTE1NTAwYzIzNjIwNzwveG1wTU06SW5zdGFuY2VJRD4KICAgICAgPC9yZGY6RGVzY3JpcHRpb24+CiAgIDwvcmRmOlJERj4KPC94OnhtcG1ldGE+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAKPD94cGFja2V0IGVuZD0idyI/Pg1lbmRzdHJlYW0NZW5kb2JqDTEyNyAwIG9iag08PC9GaWx0ZXIvRmxhdGVEZWNvZGUvRmlyc3QgMTIvTGVuZ3RoIDI1MS9OIDIvVHlwZS9PYmpTdG0+PnN0cmVhbQ0KaN5skEFrhDAQhf/KHNdDHXXVRJCAkEqhLWxVWOiyh9WkVpBkadPS/feNjr31km94895kkjyHCBiHJOVQliirHT7o+duL3Zs/RghQNr5xbwarJjP68iBraYc/AQpva4TA2hrnu5WyvW6tGVun7p6m8d3BckVDY9lavl5kD5xyS3LSs/o85eskYBEhJiSEjEAWThZOFk4WviekhC1AIiOR5QRGWDc4C7G9+5/N42T7hgBrSLHusPvB58ey9FsfIFnvx0YP7pRl4T4qYoi5LxLmkzxkC4si5Gdsv3p3u2o8TmrUDrvd9fIx6PnF3QLslkZljHVC/AowABBEZWANZW5kc3RyZWFtDWVuZG9iag0xMjggMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0ZpcnN0IDUvTGVuZ3RoIDE3OC9OIDEvVHlwZS9PYmpTdG0+PnN0cmVhbQ0KaN5kjkELgjAAhf/KbjoCncuphQiidAuCDl28DLfhQDfZJqt/36IIotvj472Pl1UAgbpO281N2sQtW6SS1hnqtIFpZzh1UqueOh73R4xwjkqUZyUuSLlDVYRQ9GmF8crEiY4hPcDFaOC9TwISb5SMeoHpWbNfF0FFdiD7rysM2TbyPxlJMAFDfJOKaW9B+YKCWxvO0Rncixx0k1Tc8lC6ymWdpZCcDXCAsGmeAgwAEHBIMg1lbmRzdHJlYW0NZW5kb2JqDTEyOSAwIG9iag08PC9EZWNvZGVQYXJtczw8L0NvbHVtbnMgNC9QcmVkaWN0b3IgMTI+Pi9GaWx0ZXIvRmxhdGVEZWNvZGUvSURbPDg1RDU5NTFEMzA5NjEyQTgxM0VCMjY4QkU0QjYwRUUxPjw0NDQ3NkJCQTZCRTI0QkE3OUU1OTI0OTlERjFENTZDNz5dL0luZGV4WzIgMSAxOCAxIDY2IDEgNzggMSAxMjcgM10vSW5mbyAxOCAwIFIvTGVuZ3RoIDQyL1ByZXYgNTU1ODMvUm9vdCAyMCAwIFIvU2l6ZSAxMzAvVHlwZS9YUmVmL1dbMSAyIDFdPj5zdHJlYW0NCmjeYmK8VczAxKjGy8DEwPAfRDAwMv1/wfGfiYExCshlFGAACDAAbyUF6w1lbmRzdHJlYW0NZW5kb2JqDXN0YXJ0eHJlZg02MDE0NQ0lJUVPRg0yIDAgb2JqDTw8L0xlbmd0aCAzNTI4L1N1YnR5cGUvWE1ML1R5cGUvTWV0YWRhdGE+PnN0cmVhbQ0KPD94cGFja2V0IGJlZ2luPSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4KPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iQWRvYmUgWE1QIENvcmUgNy4xLWMwMDAgNzkuY2I3YzVhMSwgMjAyMi8wNC8xNC0wNToyMjozNSAgICAgICAgIj4KICAgPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4KICAgICAgPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIKICAgICAgICAgICAgeG1sbnM6eG1wPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvIgogICAgICAgICAgICB4bWxuczpwZGY9Imh0dHA6Ly9ucy5hZG9iZS5jb20vcGRmLzEuMy8iCiAgICAgICAgICAgIHhtbG5zOmRjPSJodHRwOi8vcHVybC5vcmcvZGMvZWxlbWVudHMvMS4xLyIKICAgICAgICAgICAgeG1sbnM6YWRob2N3Zj0iaHR0cDovL25zLmFkb2JlLmNvbS9BY3JvYmF0QWRob2NXb3JrZmxvdy8xLjAvIgogICAgICAgICAgICB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL21tLyI+CiAgICAgICAgIDx4bXA6Q3JlYXRlRGF0ZT4yMDI0LTA3LTA0VDE3OjI2OjU3KzA4OjAwPC94bXA6Q3JlYXRlRGF0ZT4KICAgICAgICAgPHhtcDpDcmVhdG9yVG9vbD5wZGZGYWN0b3J5IFBybyB3d3cucGRmZmFjdG9yeS5jb208L3htcDpDcmVhdG9yVG9vbD4KICAgICAgICAgPHhtcDpNb2RpZnlEYXRlPjIwMjQtMDctMDVUMDY6MjA6MjQrMDg6MDA8L3htcDpNb2RpZnlEYXRlPgogICAgICAgICA8eG1wOk1ldGFkYXRhRGF0ZT4yMDI0LTA3LTA1VDA2OjIwOjI0KzA4OjAwPC94bXA6TWV0YWRhdGFEYXRlPgogICAgICAgICA8cGRmOlByb2R1Y2VyPnBkZkZhY3RvcnkgUHJvIDUuMjUgKFdpbmRvd3MgNyBQcm9mZXNzaW9uYWwgeDY0IENoaW5lc2UgKFNpbXBsaWZpZWQpKTwvcGRmOlByb2R1Y2VyPgogICAgICAgICA8ZGM6Zm9ybWF0PmFwcGxpY2F0aW9uL3BkZjwvZGM6Zm9ybWF0PgogICAgICAgICA8ZGM6Y3JlYXRvcj4KICAgICAgICAgICAgPHJkZjpTZXE+CiAgICAgICAgICAgICAgIDxyZGY6bGk+QWRtaW5pc3RyYXRvcjwvcmRmOmxpPgogICAgICAgICAgICA8L3JkZjpTZXE+CiAgICAgICAgIDwvZGM6Y3JlYXRvcj4KICAgICAgICAgPGFkaG9jd2Y6c3RhdGU+MTwvYWRob2N3ZjpzdGF0ZT4KICAgICAgICAgPGFkaG9jd2Y6dmVyc2lvbj4xLjE8L2FkaG9jd2Y6dmVyc2lvbj4KICAgICAgICAgPHhtcE1NOkRvY3VtZW50SUQ+dXVpZDoyN2M1MDc3Yi1hMzJhLTAwNDQtODgyNi04ODQ4M2JkZDJkOWM8L3htcE1NOkRvY3VtZW50SUQ+CiAgICAgICAgIDx4bXBNTTpJbnN0YW5jZUlEPnV1aWQ6YWNhOWYyNzktYzcxMS03NDQwLWE5ZjgtMmE0OTU3YWNjM2FjPC94bXBNTTpJbnN0YW5jZUlEPgogICAgICA8L3JkZjpEZXNjcmlwdGlvbj4KICAgPC9yZGY6UkRGPgo8L3g6eG1wbWV0YT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgIAo8P3hwYWNrZXQgZW5kPSJ3Ij8+DWVuZHN0cmVhbQ1lbmRvYmoNMTMwIDAgb2JqDTw8L0ZpbHRlci9GbGF0ZURlY29kZS9GaXJzdCAxMi9MZW5ndGggMjUwL04gMi9UeXBlL09ialN0bT4+c3RyZWFtDQpo3myQTWuEMBCG/8oc10MddTWJIAHBSktbWFRY6LKHarKpsCSFTUv77xsde+slz+R95ythDBIQCWS5gKrCpt7hg75+BXG4hMNAhE0XjHs7OTVbE8JD0zZu+hOgDGmdlNg664NbKzfq3lnTe3X3PJt3D8uIjtryNXx9a0YQVLdUzvqqbie2dgKeEFJCRigIlCLIE+SJPSEnbJkkchI5I3CCoMx10FnK7d3/bJ5m2zdE2EKO7YDDN748VVXY+gDZugZ2evKnIhZlUkKai5iF2em+iBmkPFluZ+w/R//zofE4K6M9DjvjnLo92ouLcFiM2lrnpfwVYACni2UYDWVuZHN0cmVhbQ1lbmRvYmoNMTMxIDAgb2JqDTw8L0ZpbHRlci9GbGF0ZURlY29kZS9GaXJzdCA1L0xlbmd0aCAxNzYvTiAxL1R5cGUvT2JqU3RtPj5zdHJlYW0NCmjeZI5BC4MgAIX/ireSQZlkjhFBFLsNBjvs0kVSSSgNNdz+/YyNwdjt8fHexyuOAIG6ztvNT8amLV+UVs5b5o2FeWcF88ronnmR9ieMcIkoKguKK0IP6JgglHxacbxyeWZjTE9wtQaEELKI5Btlo1lgfjH810VQtaevKw75Noo/GckwAUN6V5qb4ADdoRTOxXNsBo+qBN2ktHAilm5qWWclleADHCBsmpcAAwAMqEgoDWVuZHN0cmVhbQ1lbmRvYmoNMTMyIDAgb2JqDTw8L0RlY29kZVBhcm1zPDwvQ29sdW1ucyA0L1ByZWRpY3RvciAxMj4+L0ZpbHRlci9GbGF0ZURlY29kZS9JRFs8ODVENTk1MUQzMDk2MTJBODEzRUIyNjhCRTRCNjBFRTE+PDExQjg5RTJGMDRGMzQwRjQ5NjBDMzQyRkEzMDlDOTVBPl0vSW5kZXhbMiAxIDE4IDEgNjYgMSA4MCAxIDEzMCAzXS9JbmZvIDE4IDAgUi9MZW5ndGggNDIvUHJldiA2MDE0NS9Sb290IDIwIDAgUi9TaXplIDEzMy9UeXBlL1hSZWYvV1sxIDIgMV0+PnN0cmVhbQ0KaN5iYnzjysDEKGLHwMTA8B9EMDAy/f91/T8TA2MkkMvIxwAQYAB5fQbMDWVuZHN0cmVhbQ1lbmRvYmoNc3RhcnR4cmVmDTY0NzA0DSUlRU9GDTIgMCBvYmoNPDwvTGVuZ3RoIDM1MjgvU3VidHlwZS9YTUwvVHlwZS9NZXRhZGF0YT4+c3RyZWFtDQo8P3hwYWNrZXQgYmVnaW49Iu+7vyIgaWQ9Ilc1TTBNcENlaGlIenJlU3pOVGN6a2M5ZCI/Pgo8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1ldGEvIiB4OnhtcHRrPSJBZG9iZSBYTVAgQ29yZSA3LjEtYzAwMCA3OS5jYjdjNWExLCAyMDIyLzA0LzE0LTA1OjIyOjM1ICAgICAgICAiPgogICA8cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPgogICAgICA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIgogICAgICAgICAgICB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iCiAgICAgICAgICAgIHhtbG5zOnBkZj0iaHR0cDovL25zLmFkb2JlLmNvbS9wZGYvMS4zLyIKICAgICAgICAgICAgeG1sbnM6ZGM9Imh0dHA6Ly9wdXJsLm9yZy9kYy9lbGVtZW50cy8xLjEvIgogICAgICAgICAgICB4bWxuczphZGhvY3dmPSJodHRwOi8vbnMuYWRvYmUuY29tL0Fjcm9iYXRBZGhvY1dvcmtmbG93LzEuMC8iCiAgICAgICAgICAgIHhtbG5zOnhtcE1NPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvbW0vIj4KICAgICAgICAgPHhtcDpDcmVhdGVEYXRlPjIwMjQtMDctMDRUMTc6MjY6NTcrMDg6MDA8L3htcDpDcmVhdGVEYXRlPgogICAgICAgICA8eG1wOkNyZWF0b3JUb29sPnBkZkZhY3RvcnkgUHJvIHd3dy5wZGZmYWN0b3J5LmNvbTwveG1wOkNyZWF0b3JUb29sPgogICAgICAgICA8eG1wOk1vZGlmeURhdGU+MjAyNC0wNy0wNVQwNjoyMTowMyswODowMDwveG1wOk1vZGlmeURhdGU+CiAgICAgICAgIDx4bXA6TWV0YWRhdGFEYXRlPjIwMjQtMDctMDVUMDY6MjE6MDMrMDg6MDA8L3htcDpNZXRhZGF0YURhdGU+CiAgICAgICAgIDxwZGY6UHJvZHVjZXI+cGRmRmFjdG9yeSBQcm8gNS4yNSAoV2luZG93cyA3IFByb2Zlc3Npb25hbCB4NjQgQ2hpbmVzZSAoU2ltcGxpZmllZCkpPC9wZGY6UHJvZHVjZXI+CiAgICAgICAgIDxkYzpmb3JtYXQ+YXBwbGljYXRpb24vcGRmPC9kYzpmb3JtYXQ+CiAgICAgICAgIDxkYzpjcmVhdG9yPgogICAgICAgICAgICA8cmRmOlNlcT4KICAgICAgICAgICAgICAgPHJkZjpsaT5BZG1pbmlzdHJhdG9yPC9yZGY6bGk+CiAgICAgICAgICAgIDwvcmRmOlNlcT4KICAgICAgICAgPC9kYzpjcmVhdG9yPgogICAgICAgICA8YWRob2N3ZjpzdGF0ZT4xPC9hZGhvY3dmOnN0YXRlPgogICAgICAgICA8YWRob2N3Zjp2ZXJzaW9uPjEuMTwvYWRob2N3Zjp2ZXJzaW9uPgogICAgICAgICA8eG1wTU06RG9jdW1lbnRJRD51dWlkOjI3YzUwNzdiLWEzMmEtMDA0NC04ODI2LTg4NDgzYmRkMmQ5YzwveG1wTU06RG9jdW1lbnRJRD4KICAgICAgICAgPHhtcE1NOkluc3RhbmNlSUQ+dXVpZDo4OWYxNDhiMS1mMmZhLTA1NDEtYmZkZi1mZjQ1NDE3YmY2Mjc8L3htcE1NOkluc3RhbmNlSUQ+CiAgICAgIDwvcmRmOkRlc2NyaXB0aW9uPgogICA8L3JkZjpSREY+CjwveDp4bXBtZXRhPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgCjw/eHBhY2tldCBlbmQ9InciPz4NZW5kc3RyZWFtDWVuZG9iag0xMzMgMCBvYmoNPDwvQkJveFswLjAgMC4wIDczLjU2IDE2LjAyNl0vRm9ybVR5cGUgMS9MZW5ndGggMTMvTWF0cml4WzEuMCAwLjAgMC4wIDEuMCAwLjAgMC4wXS9SZXNvdXJjZXM8PC9Qcm9jU2V0Wy9QREZdPj4vU3VidHlwZS9Gb3JtL1R5cGUvWE9iamVjdD4+c3RyZWFtDQovVHggQk1DIApFTUMKDWVuZHN0cmVhbQ1lbmRvYmoNMTM0IDAgb2JqDTw8L0ZpbHRlci9GbGF0ZURlY29kZS9GaXJzdCAxMi9MZW5ndGggMzA4L04gMi9UeXBlL09ialN0bT4+c3RyZWFtDQpo3oSQwU7DMAyGX8XH7dA5SdMknaZKk0rFYUJVW4TEtMPWdqXaaCcREEh7K16QtB4DTlzyOf9vO7GVAgaagZAGFguMlxO8rY9vTiz27mhginHmjJuu7Ku2a1yYxkncl98ChC4tiyJM+s46d1n1uzrvuya3lbdqmycLwxMZtdVj+LiNd2Cobqhs62P1slZjJ9CcIAgBgTxDniHP+ARJuGSSqEnUiqAJhjIZ3UZsomj4deqOO+C+f5nmuojrJv5fhPm7ibE81D9jgsSkwOIdkz1IFipMQYwDYVaXds39cMYM8EDNAhM6S8yUBK4deLDB/HVnP041PrRVU1ssJqdteSicMsXifiKYkB7THpPwK+R6LoI5k7hKkQNHFbCzYDpkh+as2POnKx1aLruut1H0JcAAaBeDOA1lbmRzdHJlYW0NZW5kb2JqDTEzNSAwIG9iag08PC9GaWx0ZXIvRmxhdGVEZWNvZGUvRmlyc3QgNS9MZW5ndGggMTc4L04gMS9UeXBlL09ialN0bT4+c3RyZWFtDQpo3mSOQQuCMBzFv8puOQL9u9RJiCBKtyDo0MXLcBsOdJNtYn37FkUQ3R4/3vvx0hIBqqqkWf1obNTwWWnlvGXeWJy0VjCvjO6YF1F3JEAyoJCllBQ53UO5A9h9WmG8cHliQ0gPdLEGbdsWByTfKB7MjJOz4b+uHAqSwuHrCkO+DuJPlsckR310U5qbzSH6glI4F86xCd2LDLWj0sKJULqqeZmUVIL3uMe4rp8CDAAL6kgmDWVuZHN0cmVhbQ1lbmRvYmoNMTM2IDAgb2JqDTw8L0RlY29kZVBhcm1zPDwvQ29sdW1ucyA1L1ByZWRpY3RvciAxMj4+L0ZpbHRlci9GbGF0ZURlY29kZS9JRFs8ODVENTk1MUQzMDk2MTJBODEzRUIyNjhCRTRCNjBFRTE+PEU0OUVGQkQxREUzNDREOTg5QUQyQUE5NzQ1OEEyRDA1Pl0vSW5kZXhbMiAxIDE4IDEgNjYgMSA3MCAxIDEzMyA0XS9JbmZvIDE4IDAgUi9MZW5ndGggNDkvUHJldiA2NDcwNC9Sb290IDIwIDAgUi9TaXplIDEzNy9UeXBlL1hSZWYvV1sxIDMgMV0+PnN0cmVhbQ0KaN5iYmT4J8LAxMjAVMzAxMDA8B9MMjAy/WfkWfQfxN4NEmGaDCIZBRgAAgwAqj4GqA1lbmRzdHJlYW0NZW5kb2JqDXN0YXJ0eHJlZg02OTUxMA0lJUVPRg0yIDAgb2JqDTw8L0xlbmd0aCAzNTI4L1N1YnR5cGUvWE1ML1R5cGUvTWV0YWRhdGE+PnN0cmVhbQ0KPD94cGFja2V0IGJlZ2luPSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4KPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iQWRvYmUgWE1QIENvcmUgNy4xLWMwMDAgNzkuY2I3YzVhMSwgMjAyMi8wNC8xNC0wNToyMjozNSAgICAgICAgIj4KICAgPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4KICAgICAgPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIKICAgICAgICAgICAgeG1sbnM6eG1wPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvIgogICAgICAgICAgICB4bWxuczpwZGY9Imh0dHA6Ly9ucy5hZG9iZS5jb20vcGRmLzEuMy8iCiAgICAgICAgICAgIHhtbG5zOmRjPSJodHRwOi8vcHVybC5vcmcvZGMvZWxlbWVudHMvMS4xLyIKICAgICAgICAgICAgeG1sbnM6YWRob2N3Zj0iaHR0cDovL25zLmFkb2JlLmNvbS9BY3JvYmF0QWRob2NXb3JrZmxvdy8xLjAvIgogICAgICAgICAgICB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL21tLyI+CiAgICAgICAgIDx4bXA6Q3JlYXRlRGF0ZT4yMDI0LTA3LTA0VDE3OjI2OjU3KzA4OjAwPC94bXA6Q3JlYXRlRGF0ZT4KICAgICAgICAgPHhtcDpDcmVhdG9yVG9vbD5wZGZGYWN0b3J5IFBybyB3d3cucGRmZmFjdG9yeS5jb208L3htcDpDcmVhdG9yVG9vbD4KICAgICAgICAgPHhtcDpNb2RpZnlEYXRlPjIwMjQtMDctMDVUMDY6MjE6NDgrMDg6MDA8L3htcDpNb2RpZnlEYXRlPgogICAgICAgICA8eG1wOk1ldGFkYXRhRGF0ZT4yMDI0LTA3LTA1VDA2OjIxOjQ4KzA4OjAwPC94bXA6TWV0YWRhdGFEYXRlPgogICAgICAgICA8cGRmOlByb2R1Y2VyPnBkZkZhY3RvcnkgUHJvIDUuMjUgKFdpbmRvd3MgNyBQcm9mZXNzaW9uYWwgeDY0IENoaW5lc2UgKFNpbXBsaWZpZWQpKTwvcGRmOlByb2R1Y2VyPgogICAgICAgICA8ZGM6Zm9ybWF0PmFwcGxpY2F0aW9uL3BkZjwvZGM6Zm9ybWF0PgogICAgICAgICA8ZGM6Y3JlYXRvcj4KICAgICAgICAgICAgPHJkZjpTZXE+CiAgICAgICAgICAgICAgIDxyZGY6bGk+QWRtaW5pc3RyYXRvcjwvcmRmOmxpPgogICAgICAgICAgICA8L3JkZjpTZXE+CiAgICAgICAgIDwvZGM6Y3JlYXRvcj4KICAgICAgICAgPGFkaG9jd2Y6c3RhdGU+MTwvYWRob2N3ZjpzdGF0ZT4KICAgICAgICAgPGFkaG9jd2Y6dmVyc2lvbj4xLjE8L2FkaG9jd2Y6dmVyc2lvbj4KICAgICAgICAgPHhtcE1NOkRvY3VtZW50SUQ+dXVpZDoyN2M1MDc3Yi1hMzJhLTAwNDQtODgyNi04ODQ4M2JkZDJkOWM8L3htcE1NOkRvY3VtZW50SUQ+CiAgICAgICAgIDx4bXBNTTpJbnN0YW5jZUlEPnV1aWQ6NmEyZjRhYWQtM2QyMC1iZDRjLWJkNTYtNjBiNGE3NmNkMWRhPC94bXBNTTpJbnN0YW5jZUlEPgogICAgICA8L3JkZjpEZXNjcmlwdGlvbj4KICAgPC9yZGY6UkRGPgo8L3g6eG1wbWV0YT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgIAo8P3hwYWNrZXQgZW5kPSJ3Ij8+DWVuZHN0cmVhbQ1lbmRvYmoNMTM3IDAgb2JqDTw8L0RBKC9IZWx2ICAwIFRmIDAgZykvRlQvVHgvS2lkc1s2OSAwIFIgODUgMCBSXS9UKGRpc3BhdGhNZXRob2QpPj4NZW5kb2JqDTEzOCAwIG9iag08PC9CQm94WzAuMCAwLjAgNzQuMDQgMTcuMDE4XS9Gb3JtVHlwZSAxL0xlbmd0aCAxMy9NYXRyaXhbMS4wIDAuMCAwLjAgMS4wIDAuMCAwLjBdL1Jlc291cmNlczw8L1Byb2NTZXRbL1BERl0+Pi9TdWJ0eXBlL0Zvcm0vVHlwZS9YT2JqZWN0Pj5zdHJlYW0NCi9UeCBCTUMgCkVNQwoNZW5kc3RyZWFtDWVuZG9iag0xMzkgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0ZpcnN0IDI2L0xlbmd0aCAzNDMvTiA0L1R5cGUvT2JqU3RtPj5zdHJlYW0NCmjenFJbS8MwFP4r53F7sGmSpkmhFAZ1KF4oW0Fw7GFbu1oY6ZhR9N97kjMV7+BLvnPN952TpCnEkGYgEgGGQ8I1GAVKGchzVk5G7KzdPWJJvcWjgzErZ5g4tZuh6W2HZlVOy2HzGoAMy2ZFwaaDdZidNMO6nQ+2m7vm5LLv7hx4whldq4N5uyrXYKjPd/btrrlfaO4joAWBIgjXg6GgkQQJ5cjTRy8l0ASGKmPyCAwxcBlqlkXh9VZ4XGPsqOfPcc3HecNYmX4fBhJWgQhMrFodWuteCdms3bgFl1kkcffcqChNBZbKSOJ8IhZRapZs/rB2z/uW3fRN1zpWe3ti7eCCXP9A36yYi+N7jYOAac3qJ3Z1keeo6E1NoJdRJrQw2KEjLTRqUz4CXpYy4iv/aH/orTu322H8PzGfZfy0FJFxUhHj5+QiSoArXImWv+7kRYABAGoRu/INZW5kc3RyZWFtDWVuZG9iag0xNDAgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0ZpcnN0IDUvTGVuZ3RoIDE3Ny9OIDEvVHlwZS9PYmpTdG0+PnN0cmVhbQ0KaN5kjkELgyAAhf+Kt5JBmWjFiCCK3QaDHXbpIqkklIYabv9+jo3B2O3x8d7HK2qAQNPk3e5nY9OOr0or5y3zxsK8t4J5ZfTAvEiHI0aYoAqRosIlrQ6oThBKPq043rg8sSmmB7hYA0IIWUTyjbLJrDA/G/7roqjEBam/rjjk+yT+ZDTDFIzpTWluggPVC0rhXDzHFnAvCehnpYUTsXRV67YoqQQf4Qhh2z4FGAAPRUgvDWVuZHN0cmVhbQ1lbmRvYmoNMTQxIDAgb2JqDTw8L0RlY29kZVBhcm1zPDwvQ29sdW1ucyA1L1ByZWRpY3RvciAxMj4+L0ZpbHRlci9GbGF0ZURlY29kZS9JRFs8ODVENTk1MUQzMDk2MTJBODEzRUIyNjhCRTRCNjBFRTE+PDkwQTRDRjgzNUVDNjQwOTFCQkJFMkIzNUI2RTNFODM0Pl0vSW5kZXhbMiAxIDE4IDEgNjYgMSA2OSAxIDgxIDEgODUgMSAxMzcgNV0vSW5mbyAxOCAwIFIvTGVuZ3RoIDUzL1ByZXYgNjk1MTAvUm9vdCAyMCAwIFIvU2l6ZSAxNDIvVHlwZS9YUmVmL1dbMSAzIDFdPj5zdHJlYW0NCmjeYmJkFHjIwMT4/8NqBiYGBob/YJKBEYX8zyiX9RfIZgwFyTLuBpPbwCQ/A0CAAQBf7AkFDWVuZHN0cmVhbQ1lbmRvYmoNc3RhcnR4cmVmDTc0NDQyDSUlRU9GDTIgMCBvYmoNPDwvTGVuZ3RoIDM1MjgvU3VidHlwZS9YTUwvVHlwZS9NZXRhZGF0YT4+c3RyZWFtDQo8P3hwYWNrZXQgYmVnaW49Iu+7vyIgaWQ9Ilc1TTBNcENlaGlIenJlU3pOVGN6a2M5ZCI/Pgo8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1ldGEvIiB4OnhtcHRrPSJBZG9iZSBYTVAgQ29yZSA3LjEtYzAwMCA3OS5jYjdjNWExLCAyMDIyLzA0LzE0LTA1OjIyOjM1ICAgICAgICAiPgogICA8cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPgogICAgICA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIgogICAgICAgICAgICB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iCiAgICAgICAgICAgIHhtbG5zOnBkZj0iaHR0cDovL25zLmFkb2JlLmNvbS9wZGYvMS4zLyIKICAgICAgICAgICAgeG1sbnM6ZGM9Imh0dHA6Ly9wdXJsLm9yZy9kYy9lbGVtZW50cy8xLjEvIgogICAgICAgICAgICB4bWxuczphZGhvY3dmPSJodHRwOi8vbnMuYWRvYmUuY29tL0Fjcm9iYXRBZGhvY1dvcmtmbG93LzEuMC8iCiAgICAgICAgICAgIHhtbG5zOnhtcE1NPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvbW0vIj4KICAgICAgICAgPHhtcDpDcmVhdGVEYXRlPjIwMjQtMDctMDRUMTc6MjY6NTcrMDg6MDA8L3htcDpDcmVhdGVEYXRlPgogICAgICAgICA8eG1wOkNyZWF0b3JUb29sPnBkZkZhY3RvcnkgUH" +// +"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" +// +"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" +// +"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" +// +"3ZjpzdGF0ZT4xPC9hZGhvY3dmOnN0YXRlPgogICAgICAgICA8YWRob2N3Zjp2ZXJzaW9uPjEuMTwvYWRob2N3Zjp2ZXJzaW9u"+ +// "PgogICAgICAgICA8eG1wTU06RG9jdW1lbnRJRD51dWlkOjI3YzUwNzdiLWEzMmEtMDA0NC04ODI2LTg4NDgzYmRkMmQ5YzwveG1w" +// +"TU06RG9jdW1lbnRJRD4KICAgICAgICAgPHhtcE1NOkluc3RhbmNlSUQ+dXVpZDoyNjQ3YTk2MS1mMWQ1LTAzNDAtOGNhMC0wNDYwY" +// +"2M1YmYwNWY8L3htcE1NOkluc3RhbmNlSUQ+CiAgICAgIDwvcmRmOkRlc2NyaXB0aW9uPgogICA8L3JkZjpSREY+CjwveDp4bXBtZXRhPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgCjw/eHBhY2tldCBlbmQ9InciPz4NZW5kc3RyZWFtDWVuZG9iag0yMDEgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0ZpcnN0IDUvTGVuZ3RoIDE2MS9OIDEvVHlwZS9PYmpTdG0+PnN0cmVhbQ0KaN40jMsKwjAQRX9llrqQ1FcmhRIoxOLChbSuFBe2qbFQkoXF7zfN1U3OzL05IyVlVBTClAtx7MdP3C7P+DhaClPH4uC7YAfv4ng2lQndP6A8fqu1FlXwU2xLG9q+Cd41k12dBveaaL5d4yyn8fowLSl4szn0o33feDMnxFtgB0iAgSSRyoA1AE/BUz8PHe8TZI4OG0PnFN61/gowAMjSPJ4NZW5kc3RyZWFtDWVuZG9iag0yMDIgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0ZpcnN0IDUvTGVuZ3RoIDE3Ny9OIDEvVHlwZS9PYmpTdG0+PnN0cmVhbQ0KaN5kjkELgjAcxb/KbjoC/TuckxBBlG5B0KGLl+EmDnSTbWJ9+xZFEN0eP9778bISAaqqtNn8ZGzciEVp5bzl3lictlZyr4zuuJdxdyRAcmCQZ4wUlB2gjACiTyuMVzGe+BDSA12sQfu+JwGNb5QMZsHp2YhfFwVGAIqvKwzFNsg/GU0IRX18U1qY3SH2gqN0LpzjM7oXOWonpaWToXRVyzqrUUnR4x7jun4KMAANCUgpDWVuZHN0cmVhbQ1lbmRvY" +// +"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" +// +"CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgCjw/eHBhY2tldCBlbmQ9InciPz4NZW5kc3RyZWFtDWVuZG9iag0yMSAwIG9iag08PC9Bbm5vdHMgMjQ4IDAgUi9Db250ZW50cyAyNDkgMCBSL0Nyb3BCb3hbMCAwIDIxNSAzNjldL01lZGlhQm94WzAgMCAyMTUgMzY5XS9QYXJlbnQgMTQgMCBSL1Jlc291cmNlczw8L0NvbG9yU3BhY2U8PC9DUzAgMjUwIDAgUi9DUzEgMjUxIDAgUi9DUzIgMjUyIDAgUj4+L0ZvbnQ8PC9DMF8wIDEwNSAwIFI+Pi9Qcm9jU2V0Wy9QREYvVGV4dC9JbWFnZUIvSW1hZ2VDL0ltYWdlSV0vWE9iamVjdDw8L0ltMCA1NiAwIFIvSW0xIDU4IDAgUi9JbTEwIDQyIDAgUi9JbTExIDQ1IDAgUi9JbTEyIDQ2IDAgUi9JbTEzIDQ4IDAgUi9JbTIgNjAgMCBSL0ltMyA2MSAwIFIvSW00IDYyIDAgUi9JbTUgMzcgMCBSL0ltNiAzOCAwIFIvSW03IDM5IDAgUi9JbTggNDAgMCBSL0ltOSA0MSAwIFI+Pj4+L1JvdGF0ZSAwL1R5cGUvUGFnZT4+DWVuZG9iag0yNDggMCBvYmoNWzY5IDAgUiA3MCAwIFIgNzEgMCBSIDcyIDAgUiA3MyAwIFIgNzQgMCBSIDc1IDAgUiA3NiAwIFIgNzcgMCBSIDc4IDAgUiA3OSAwIFIgODAgMCBSIDgxIDAgUiA4MiAwIFIgODMgMCBSIDg0IDAgUiA4NSAwIFJdDWVuZG9iag0yNDkgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA1NDE+PnN0cmVhbQ0KSImUVMuO1DAQvPsr+gfw9sNu2xJC2mVB4oiIxJEDsDzEgGYu/D7dsWczq8wwWUWKkri63FVdzj4giEpUYMoxQYqN4fA1fA8f4XfYBwK0y++iNWaGz7uAsTD8heAru8CUIlZ7/BU+hPd27W2BMBvlTMZ0no+YYl3TIbwgilyf0GGnGi08qz3jE82x6AkhY/MdEDTS/1iHtOdQIzCK+djdbI4/2y5jjbLVTc7VQVc5fY5pIycOuhKzXqBzZdfJCPw6fAsUUwIRgUwg7J0Y7YNRikTRTos+RrubdMnJiW2Dm3c7hPs/c2MXsEl6VgxKZ6H1iLT9O46POJwx1iCr6fXn6tOvkRSKx7TjZQteye3qBWlVkNgV+cucitRmR3KJ6dh8XtVIO9akqBWySbHEmYW9QNebWHYH3vQm7f6kkVArKesS9UaWmuLDESm+Ya+pSw237BqvhU0Qh6wNYTMvZXhph9t9jE1tYtXPX++gLR3M6MzLaDVWayUtEcAF7L+R60eDWMdWG7rNtOW0Zd1+2GwElqFuwCwmNxdIrfi0hyh64oD6SsebzcXnRu0Ry6fYyn5STrC2P0ldUkeP2T62TzZ8a+DSX8j+bEbKQ4OVyZxsKv7RViw3l4wZzFTKWcOLergWd+6mWQLCD8BIhRx58xo/mRaYHgLDdLDDVJsRWymrff0SXhLdKuodoeZbvM8Jid6+mn6GN1P4J8AA9nNbQw1lbmRzdHJlYW0NZW5kb2JqDTI1MCAwIG9iag1bL0luZGV4ZWQvRGV2aWNlUkdCIDI1NSAyOCAwIFJdDWVuZG9iag0yNTEgMCBvYmoNWy9JbmRleGVkL0RldmljZVJHQiAyNTUgMjkgMCBSXQ1lbmRvYmoNMjUyIDAgb2JqDVsvSW5kZXhlZC9EZXZpY2VSR0IgMjU1IDMwIDAgUl0NZW5kb2JqDTI1MyAwIG9iag08PC9GaWx0ZXIvRmxhdGVEZWNvZGUvRmlyc3QgNS9MZW5ndGggMTc3L04gMS9UeXBlL09ialN0bT4+c3RyZWFtDQpo3mSOQQuDIACF/4q3kkGZ0xkjgih2Gwx22KWLpJJQGmq0/fs5NgZjt8fHex+vKAECVZU3axitSxsxa6N9cDxYB/PWSR60NR0PMu2OGGGCGCIFwwfKdqhMEEo+rThehDrxIaYHuDgLtm3LIlJvlA12hvnZil8XRQyTPfm64lCsg/yT0QxT0Kc3bYTdPGAvqKT38RyfwP1AQDtqI72Mpauel0krLUUPewjr+inAAA7vSC4NZW5kc3RyZWFtDWVuZG9iag0yNTQgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0ZpcnN0IDUvTGVuZ3RoIDE3NC9OIDEvVHlwZS9PYmpTdG0+PnN0cmVhbQ0KaN40i00LgkAQhv/KHPWy4+qmLsiCYBJEILbQITrU+pEQu0Jb1L9vLLq8M/M872QRRFAUWJUBbvrbE+jUA8UYYtWSWFvjusmOtDZVXTnzByBzqrVKYe2sJ/19l9kPLhgE1hr1C+sBRCRT3G2LgkQDMV9a2PbGH3kiWZQDXyVM0Ix5zFIBPJVMJOKE+8fFv+ceD1M39h510E33+ezNVRMNcUksrXVeqY8AAwCiYDhlDWVuZHN0cmVhbQ1lbmRvYmoNMjU1IDAgb2JqDTw8L0RlY29kZVBhcm1zPDwvQ29sdW1ucyA0L1ByZWRpY3RvciAxMj4+L0ZpbHRlci9GbGF0ZURlY29kZS9JRFs8ODVENTk1MUQzMDk2MTJBODEzRUIyNjhCRTRCNjBFRTE+PERDQjcxQ0ZCMjg3NDQ3NEU5RkVBRTc0MDU5RDNFMUJDPl0vSW5kZXhbMiAxIDE4IDEgMjEgMSA3MCAxIDI0NiAxMF0vSW5mbyAxOCAwIFIvTGVuZ3RoIDYyL1ByZXYgMTQwMTU0L1Jvb3QgMjAgMCBSL1NpemUgMjU2L1R5cGUvWFJlZi9XWzEgMyAwXT4+c3RyZWFtDQpo3mJiZFIVYGL8d/st038mY3Ug6+wtpn8MDExMDEDAxMhkcg7IYuwCEkzJIDFDENcQzuIHETwAAQYAEwwKww1lbmRzdHJlYW0NZW5kb2JqDXN0YXJ0eHJlZg0xNDYwMjUNJSVFT0YNMiAwIG9iag08PC9MZW5ndGggMzUyOC9TdWJ0eXBlL1hNTC9UeXBlL01ldGFkYXRhPj5zdHJlYW0NCjw/eHBhY2tldCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+Cjx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDcuMS1jMDAwIDc5LmNiN2M1YTEsIDIwMjIvMDQvMTQtMDU6MjI6MzUgICAgICAgICI+CiAgIDxyZGY6UkRGIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+CiAgICAgIDxyZGY6RGVzY3JpcHRpb24gcmRmOmFib3V0PSIiCiAgICAgICAgICAgIHhtbG5zOnhtcD0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLyIKICAgICAgICAgICAgeG1sbnM6cGRmPSJodHRwOi8vbnMuYWRvYmUuY29tL3BkZi8xLjMvIgogICAgICAgICAgICB4bWxuczpkYz0iaHR0cDovL3B1cmwub3JnL2RjL2VsZW1lbnRzLzEuMS8iCiAgICAgICAgICAgIHhtbG5zOmFkaG9jd2Y9Imh0dHA6Ly9ucy5hZG9iZS5jb20vQWNyb2JhdEFkaG9jV29ya2Zsb3cvMS4wLyIKICAgICAgICAgICAgeG1sbnM6eG1wTU09Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iPgogICAgICAgICA8eG1wOkNyZWF0ZURhdGU+MjAyNC0wNy0wNFQxNzoyNjo1NyswODowMDwveG1wOkNyZWF0ZURhdGU+CiAgICAgICAgIDx4bXA6Q3JlYXRvclRvb2w+cGRmRmFjdG9yeSBQcm8gd3d3LnBkZmZhY3RvcnkuY29tPC94bXA6Q3JlYXRvclRvb2w+CiAgICAgICAgIDx4bXA6TW9kaWZ5RGF0ZT4yMDI0LTA3LTA1VDA3OjI3OjQ2KzA4OjAwPC94bXA6TW9kaWZ5RGF0ZT4KICAgICAgICAgPHhtcDpNZXRhZGF0YURhdGU+MjAyNC0wNy0wNVQwNzoyNzo0NiswODowMDwveG1wOk1ldGFkYXRhRGF0ZT4KICAgICAgICAgPHBkZjpQcm9kdWNlcj5wZGZGYWN0b3J5IFBybyA1LjI1IChXaW5kb3dzIDcgUHJvZmVzc2lvbmFsIHg2NCBDaGluZXNlIChTaW1wbGlmaWVkKSk8L3BkZjpQcm9kdWNlcj4KICAgICAgICAgPGRjOmZvcm1hdD5hcHBsaWNhdGlvbi9wZGY8L2RjOmZvcm1hdD4KICAgICAgICAgPGRjOmNyZWF0b3I+CiAgICAgICAgICAgIDxyZGY6U2VxPgogICAgICAgICAgICAgICA8cmRmOmxpPkFkbWluaXN0cmF0b3I8L3JkZjpsaT4KICAgICAgICAgICAgPC9yZGY6U2VxPgogICAgICAgICA8L2RjOmNyZWF0b3I+CiAgICAgICAgIDxhZGhvY3dmOnN0YXRlPjE8L2FkaG9jd2Y6c3RhdGU+CiAgICAgICAgIDxhZGhvY3dmOnZlcnNpb24+MS4xPC9hZGhvY3dmOnZlcnNpb24+CiAgICAgICAgIDx4bXBNTTpEb2N1bWVudElEPnV1aWQ6MjdjNTA3N2ItYTMyYS0wMDQ0LTg4MjYtODg0ODNiZGQyZDljPC94bXBNTTpEb2N1bWVudElEPgogICAgICAgICA8eG1wTU06SW5zdGFuY2VJRD51dWlkOjUxYzA4NjQ4LTgyZDktZWI0Ni04MTlhLThlYWU5NmM1MTAxODwveG1wTU06SW5zdGFuY2VJRD4KICAgICAgPC9yZGY6RGVzY3JpcHRpb24+CiAgIDwvcmRmOlJERj4KPC94OnhtcG1ldGE+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAKPD94cGFja2V0IGVuZD0idyI/Pg1lbmRzdHJlYW0NZW5kb2JqDTI1NiAwIG9iag08PC9CYXNlRm9udC9BZG9iZUhlaXRpU3RkLVJlZ3VsYXIvQ0lEU3lzdGVtSW5mbyAyNjAgMCBSL0RXIDEwMDAvRm9udERlc2NyaXB0b3IgMjYxIDAgUi9TdWJ0eXBlL0NJREZvbnRUeXBlMC9UeXBlL0ZvbnQvV1swWzEwMDAgMjI0IDI2NiAzOTIgNTUxIDU2MiA4ODMgNjc3IDI0MV05IDEwIDMyMiAxMVs0NzAgNjc3IDI0NyAzNDMgMjQ1IDM3MF0xNyAyNiA1NjIgMjdbMjQ1IDI0N10yOSAzMSA2NzcgMzJbNDQ3IDgwOCA2NjEgNjAyIDYxMCA3MDggNTM1IDUyOCA2ODkgNzAzIDI3NSA0MDQgNjAyIDUxNCA4NzEgNzA4IDcyNyA1ODUgNzI3IDU5NSA1MzkgNTQxIDY5NiA2MTkgOTIyIDYxMiA1OTEgNTg0IDMyMiAzNjIgMzIyIDY3NyA1NjggMjQxIDUzMiA2MTIgNDc1IDYwOCA1NDMgMzMyIDYwMyA2MDEgMjY1IDI3NiA1MjQgMjY0IDkwMSA2MDEgNTkwIDYxMiA2MDcgMzY3IDQzMyAzNjkgNTk3IDUyNyA4MDAgNTExIDUxOCA0NjggMzIxIDI3MyAzMjEgNjc3XTc3MTNbNzY5IDY4M10yMjM1MyAyMjM1NCA1NjIgMjIzNTdbNTAwXTI5MDY0IDMwMjgzIDU1MF0+Pg1lbmRvYmoNMjU3IDAgb2JqDTw8L0Jhc2VGb250L0Fkb2JlSGVpdGlTdGQtUmVndWxhci9EZXNjZW5kYW50Rm9udHMgMjU5IDAgUi9FbmNvZGluZy9VbmlHQi1VVEYxNi1IL05hbWUvQWRvYmVIZWl0aVN0ZC1SZWd1bGFyL1N1YnR5cGUvVHlwZTAvVHlwZS9Gb250Pj4NZW5kb2JqDTI1OCAwIG9iag08PC9CQm94WzAuMCAwLjAgNzQuMDQgMjQuNjUyNV0vRm9ybVR5cGUgMS9MZW5ndGggMTMvTWF0cml4WzEuMCAwLjAgMC4wIDEuMCAwLjAgMC4wXS9SZXNvdXJjZXM8PC9Qcm9jU2V0Wy9QREZdPj4vU3VidHlwZS9Gb3JtL1R5cGUvWE9iamVjdD4+c3RyZWFtDQovVHggQk1DIApFTUMKDWVuZHN0cmVhbQ1lbmRvYmoNMjU5IDAgb2JqDVsyNTYgMCBSXQ1lbmRvYmoNMjYwIDAgb2JqDTw8L09yZGVyaW5nKEdCMSkvUmVnaXN0cnkoQWRvYmUpL1N1cHBsZW1lbnQgND4+DWVuZG9iag0yNjEgMCBvYmoNPDwvQXNjZW50IDk2Ny9DYXBIZWlnaHQgNzYzL0Rlc2NlbnQgLTI4My9GbGFncyAzMi9Gb250QkJveFstMTYzIC0yODMgMTA4NyA5NjddL0ZvbnRGYW1pbHkoQWRvYmUgSGVpdGkgU3RkIFIpL0ZvbnROYW1lL0Fkb2JlSGVpdGlTdGQtUmVndWxhci9Gb250U3RyZXRjaC9Ob3JtYWwvRm9udFdlaWdodCA0MDAvSXRhbGljQW5nbGUgMC9TdGVtViAxMTYvVHlwZS9Gb250RGVzY3JpcHRvci9YSGVpZ2h0IDU1MT4+DWVuZG9iag0yNjIgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0ZpcnN0IDUvTGVuZ3RoIDE3OC9OIDEvVHlwZS9PYmpTdG0+PnN0cmVhbQ0KaN40jcEOwiAMhl+lRz0Y5nTAkoVkCS47eDCbJ42HbSCSLJAo+vwyqhc+2q9/SylkUFVE1ivS6vkTq/M9PgbWRHZRHNzklXUmfk+ykX76N6CMY50QpPEuRFsrP+pW22D7oDadNu95eEJesGUMbe+dWeTRmkcAmkQ6ijOXQY7Aceuy1+pZva4sXzrAdog9giIYIoWAZ4gtAnMcc/yXQ8eKBFqiw4phnKXmTYivAAMAl21GRQ1lbmRzdHJlYW0NZW5kb2JqDTI2MyAwIG9iag08PC9GaWx0ZXIvRmxhdGVEZWNvZGUvRmlyc3QgNS9MZW5ndGggMTc3L04gMS9UeXBlL09ialN0bT4+c3RyZWFtDQpo3mSOQQuDIACF/4q3kkGZWMaIIIrdBoMddukiqSSUhhpu/36OjcHY7fHx3scraoBA0+Td7mdj046vSivnLfPGwry3gnll9MC8SIcjRpggikhBcVXSA6oThJJPK443Lk9siukBLtaAEEIWkXyjbDIrzM+G/7pKRDEl1dcVh3yfxJ+szHAJxvSmNDfBAfqCUjgXz7EF3CsC+llp4UQsXdW6LUoqwUc4Qti2TwEGABEwSDQNZW5kc3RyZWFtDWVuZG9iag0yNjQgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0ZpcnN0IDUvTGVuZ3RoIDE4Ny9OIDEvVHlwZS9PYmpTdG0+PnN0cmVhbQ0KaN40jMEKgkAQhl9ljnbI0VVTIQTBpEOE6EKH6JJu60LsRE5Rb99KeJmZ//tmZpNDANstlo0rRxBJ5nJbFFiVHpYDXVVHVnc8rA9GjwyhAHlzK3qFVetOdranwVjtxqaqK+oXAPnyqSbLTu/V/Q15+oczhhhrifKDDYhwxtiqns9hlPtRLCDMAj9JhXORH2WuB4kvRHLB7nXl70PhyQxaMUpvGunJB9JmYtMfaYVy1qW1xEXxE2AA4hk/cQ1lbmRzdHJlYW0NZW5kb2JqDTI2NSAwIG9iag08PC9EZWNvZGVQYXJtczw8L0NvbHVtbnMgNC9QcmVkaWN0b3IgMTI+Pi9GaWx0ZXIvRmxhdGVEZWNvZGUvSURbPDg1RDU5NTFEMzA5NjEyQTgxM0VCMjY4QkU0QjYwRUUxPjw3Q0M5QTdGMkUzNTE0QjJDQURGQzVFMDYwNENDMzJCMz5dL0luZGV4WzIgMSAxOCAxIDY2IDEgNjkgMSAyNTYgMTBdL0luZm8gMTggMCBSL0xlbmd0aCA2MC9QcmV2IDE0NjAyNS9Sb290IDIwIDAgUi9TaXplIDI2Ni9UeXBlL1hSZWYvV1sxIDMgMF0+PnN0cmVhbQ0KaN5iYmSyvsLE+O+YMRMDA8N/EMHE9J/J4wGQxWwA4k4HEox7QCxpEOEI4v4EEQIggh9ESAIEGACyQQlpDWVuZHN0cmVhbQ1lbmRvYmoNc3RhcnR4cmVmDTE1MjA1Ng0lJUVPRg0yIDAgb2JqDTw8L0xlbmd0aCAzNTI4L1N1YnR5cGUvWE1ML1R5cGUvTWV0YWRhdGE+PnN0cmVhbQ0KPD94cGFja2V0IGJlZ2luPSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4KPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iQWRvYmUgWE1QIENvcmUgNy4xLWMwMDAgNzkuY2I3YzVhMSwgMjAyMi8wNC8xNC0wNToyMjozNSAgICAgICAgIj4KICAgPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4KICAgICAgPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIKICAgICAgICAgICAgeG1sbnM6eG1wPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvIgogICAgICAgICAgICB4bWxuczpwZGY9Imh0dHA6Ly9ucy5hZG9iZS5jb20vcGRmLzEuMy8iCiAgICAgICAgICAgIHhtbG5zOmRjPSJodHRwOi8vcHVybC5vcmcvZGMvZWxlbWVudHMvMS4xLyIKICAgICAgICAgICAgeG1sbnM6YWRob2N3Zj0iaHR0cDovL25zLmFkb2JlLmNvbS9BY3JvYmF0QWRob2NXb3JrZmxvdy8xLjAvIgogICAgICAgICAgICB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL21tLyI+CiAgICAgICAgIDx4bXA6Q3JlYXRlRGF0ZT4yMDI0LTA3LTA0VDE3OjI2OjU3KzA4OjAwPC94bXA6Q3JlYXRlRGF0ZT4KICAgICAgICAgPHhtcDpDcmVhdG9yVG9vbD5wZGZGYWN0b3J5IFBybyB3d3cucGRmZmFjdG9yeS5jb208L3htcDpDcmVhdG9yVG9vbD4KICAgICAgICAgPHhtcDpNb2RpZnlEYXRlPjIwMjQtMDctMDVUMDc6Mjk6MTArMDg6MDA8L3htcDpNb2RpZnlEYXRlPgogICAgICAgICA8eG1wOk1ldGFkYXRhRGF0ZT4yMDI0LTA3LTA1VDA3OjI5OjEwKzA4OjAwPC94bXA6TWV0YWRhdGFEYXRlPgogICAgICAgICA8cGRmOlByb2R1Y2VyPnBkZkZhY3RvcnkgUHJvIDUuMjUgKFdpbmRvd3MgNyBQcm9mZXNzaW9uYWwgeDY0IENoaW5lc2UgKFNpbXBsaWZpZWQpKTwvcGRmOlByb2R1Y2VyPgogICAgICAgICA8ZGM6Zm9ybWF0PmFwcGxpY2F0aW9uL3BkZjwvZGM6Zm9ybWF0PgogICAgICAgICA8ZGM6Y3JlYXRvcj4KICAgICAgICAgICAgPHJkZjpTZXE+CiAgICAgICAgICAgICAgIDxyZGY6bGk+QWRtaW5pc3RyYXRvcjwvcmRmOmxpPgogICAgICAgICAgICA8L3JkZjpTZXE+CiAgICAgICAgIDwvZGM6Y3JlYXRvcj4KICAgICAgICAgPGFkaG9jd2Y6c3RhdGU+MTwvYWRob2N3ZjpzdGF0ZT4KICAgICAgICAgPGFkaG9jd2Y6dmVyc2lvbj4xLjE8L2FkaG9jd2Y6dmVyc2lvbj4KICAgICAgICAgPHhtcE1NOkRvY3VtZW50SUQ+dXVpZDoyN2M1MDc3Yi1hMzJhLTAwNDQtODgyNi04ODQ4M2JkZDJkOWM8L3htcE1NOkRvY3VtZW50SUQ+CiAgICAgICAgIDx4bXBNTTpJbnN0YW5jZUlEPnV1aWQ6YWQzMzcxMjgtMjRjZS1hMTQ3LTk1ZjctY2Y2NTY0MWYwNjY3PC94bXBNTTpJbnN0YW5jZUlEPgogICAgICA8L3JkZjpEZXNjcmlwdGlvbj4KICAgPC9yZGY6UkRGPgo8L3g6eG1wbWV0YT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgIAo8P3hwYWNrZXQgZW5kPSJ3Ij8+DWVuZHN0cmVhbQ1lbmRvYmoNMjEgMCBvYmoNPDwvQW5ub3RzIDI3MCAwIFIvQ29udGVudHMgMjcxIDAgUi9Dcm9wQm94WzAgMCAyMTUgMzY5XS9NZWRpYUJveFswIDAgMjE1IDM2OV0vUGFyZW50IDE0IDAgUi9SZXNvdXJjZXM8PC9Db2xvclNwYWNlPDwvQ1MwIDI3MiAwIFIvQ1MxIDI3MyAwIFIvQ1MyIDI3NCAwIFI+Pi9Gb250PDwvQzBfMCAxMDUgMCBSPj4vUHJvY1NldFsvUERGL1RleHQvSW1hZ2VCL0ltYWdlQy9JbWFnZUldL1hPYmplY3Q8PC9JbTAgNTYgMCBSL0ltMSA1OCAwIFIvSW0xMCA0MiAwIFIvSW0xMSA0NSAwIFIvSW0xMiA0NiAwIFIvSW0xMyA0OCAwIFIvSW0yIDYwIDAgUi9JbTMgNjEgMCBSL0ltNCA2MiAwIFIvSW01IDM3IDAgUi9JbTYgMzggMCBSL0ltNyAzOSAwIFIvSW04IDQwIDAgUi9JbTkgNDEgMCBSPj4+Pi9Sb3RhdGUgMC9UeXBlL1BhZ2U+Pg1lbmRvYmoNMjcwIDAgb2JqDVs2OSAwIFIgNzAgMCBSIDcxIDAgUiA3MiAwIFIgNzMgMCBSIDc0IDAgUiA3NSAwIFIgNzYgMCBSIDc3IDAgUiA3OCAwIFIgNzkgMCBSIDgwIDAgUiA4MSAwIFIgODIgMCBSIDgzIDAgUiA4NCAwIFIgODUgMCBSXQ1lbmRvYmoNMjcxIDAgb2JqDTw8L0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggNTQxPj5zdHJlYW0NCkiJlFTLjtQwELz7K/oH8PbDbtsSQtplQeKIiMSRA7A8xIBmLvw+3bFnM6vMMFlFipK4utxVXc4+IIhKVGDKMUGKjeHwNXwPH+F32AcCtMvvojVmhs+7gLEw/IXgK7vAlCJWe/wVPoT3du1tgTAb5UzGdJ6PmGJd0yG8IIpcn9BhpxotPKs94xPNsegJIWPzHRA00v9Yh7TnUCMwivnY3WyOP9suY42y1U3O1UFXOX2OaSMnDroSs16gc2XXyQj8OnwLFFMCEYFMIOydGO2DUYpE0U6LPka7m3TJyYltg5t3O4T7P3NjF7BJelYMSmeh9Yi0/TuOjzicMdYgq+n15+rTr5EUise042ULXsnt6gVpVZDYFfnLnIrUZkdyienYfF7VSDvWpKgVskmxxJmFvUDXm1h2B970Ju3+pJFQKynrEvVGlpriwxEpvmGvqUsNt+war4VNEIesDWEzL2V4aYfbfYxNbWLVz1/voC0dzOjMy2g1VmslLRHABey/ketHg1jHVhu6zbTltGXdfthsBJahbsAsJjcXSK34tIcoeuKA+krHm83F50btEcun2Mp+Uk6wtj9JXVJHj9k+tk82fGvg0l/I/mxGykODlcmcbCr+0VYsN5eMGcxUylnDi3q4FnfuplkCwg/ASIUcefMaP5kWmB4Cw3Sww1SbEVspq339El4S3SrqHaHmW7zPCYnevpp+hjdT+CfAAPZzW0MNZW5kc3RyZWFtDWVuZG9iag0yNzIgMCBvYmoNWy9JbmRleGVkL0RldmljZVJHQiAyNTUgMjggMCBSXQ1lbmRvYmoNMjczIDAgb2JqDVsvSW5kZXhlZC9EZXZpY2VSR0IgMjU1IDI5IDAgUl0NZW5kb2JqDTI3NCAwIG9iag1bL0luZGV4ZWQvRGV2aWNlUkdCIDI1NSAzMCAwIFJdDWVuZG9iag0yNzUgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0ZpcnN0IDUvTGVuZ3RoIDE3OC9OIDEvVHlwZS9PYmpTdG0+PnN0cmVhbQ0KaN5kjkELgjAcxb/KbjoC/TucqxBBlG5B0KGLl+EmDtTJNll9+xZFEN0eP9778bI9AlSWab25UZu4FrNalHWGO21w2hjJndJLy52M2yMBkgODPGOkoGwH+wgg+rTCeBXDifchPdDFaOS9TwIa3ijp9YzTsxa/LgqMHDL4usJQbL38k9GEUNTFN7UI7S1iLzhIa8M5PqF7kaNmVIu0MpSual4nNSgpOtxhXFVPAQYADphILQ1lbmRzdHJlYW0NZW5kb2JqDTI3NiAwIG9iag08PC9GaWx0ZXIvRmxhdGVEZWNvZGUvRmlyc3QgNS9MZW5ndGggMTUwL04gMS9UeXBlL09ialN0bT4+c3RyZWFtDQpo3hTKuwrCMBiG4Vv5x3YwX9Kmh0AIFKSLCtIGHMShhzQWoe0QQe/eurzDy1NmxElrHKsI1bj2rl0X34bxcJ79M5BIyE678DFqkqgt7Af1RJKrHJeT1sbgSonYSYPGDeEuUsV4SSIVrCwkJVyxXEoSMmN5kT3Qvvvw3Rxu8+hdgI22bnjZ/cT4F9WyrMGYnwADAOugKdgNZW5kc3RyZWFtDWVuZG9iag0yNzcgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0ZpcnN0IDUvTGVuZ3RoIDE3NC9OIDEvVHlwZS9PYmpTdG0+PnN0cmVhbQ0KaN40i8sKwjAQRX9llu2mk7axbSAECrEIIpQacCEutC8LkhSMon/vVHFzuXPOnZwBAylRlwFu+tsT6DQDxRiibkisbeu6yY5Ua11p1/4BiIJmjVJYOetJf99F/oMLBo6VQfPCagDORIa7rZQkakjiZYVN3/pjnIqIFRBnIuIph4SJKOMc4lUacVaccP+4+Pfc42Hqxt6jCbrpPp99ezVEQ1wSS2udV+ojwADVojifDWVuZHN0cmVhbQ1lbmRvYmoNMjc4IDAgb2JqDTw8L0RlY29kZVBhcm1zPDwvQ29sdW1ucyA0L1ByZWRpY3RvciAxMj4+L0ZpbHRlci9GbGF0ZURlY29kZS9JRFs8ODVENTk1MUQzMDk2MTJBODEzRUIyNjhCRTRCNjBFRTE+PDM3OTNFN0M3NDgwOTQ0NjZCRTk2RTEyQTNFNEYxNjU2Pl0vSW5kZXhbMiAxIDE4IDEgMjEgMSA3MCAxIDg1IDEgMjY2IDEzXS9JbmZvIDE4IDAgUi9MZW5ndGggNjcvUHJldiAxNTIwNTYvUm9vdCAyMCAwIFIvU2l6ZSAyNzkvVHlwZS9YUmVmL1dbMSAzIDBdPj5zdHJlYW0NCmjeYmJkCk5kYvy3bhPTf6aEJCBrwQImBgaG/0z/GP6/AbEYkAhGpmR5EKsLSDAng1iGKASjAIj4AiJ4AAIMAHJyDkANZW5kc3RyZWFtDWVuZG9iag1zdGFydHhyZWYNMTU4MTI3DSUlRU9GDTIgMCBvYmoNPDwvTGVuZ3RoIDM1MjgvU3VidHlwZS9YTUwvVHlwZS9NZXRhZGF0YT4+c3RyZWFtDQo8P3hwYWNrZXQgYmVnaW49Iu+7vyIgaWQ9Ilc1TTBNcENlaGlIenJlU3pOVGN6a2M5ZCI/Pgo8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1ldGEvIiB4OnhtcHRrPSJBZG9iZSBYTVAgQ29yZSA3LjEtYzAwMCA3OS5jYjdjNWExLCAyMDIyLzA0LzE0LTA1OjIyOjM1ICAgICAgICAiPgogICA8cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPgogICAgICA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIgogICAgICAgICAgICB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iCiAgICAgICAgICAgIHhtbG5zOnBkZj0iaHR0cDovL25zLmFkb2JlLmNvbS9wZGYvMS4zLyIKICAgICAgICAgICAgeG1sbnM6ZGM9Imh0dHA6Ly9wdXJsLm9yZy9kYy9lbGVtZW50cy8xLjEvIgogICAgICAgICAgICB4bWxuczphZGhvY3dmPSJodHRwOi8vbnMuYWRvYmUuY29tL0Fjcm9iYXRBZGhvY1dvcmtmbG93LzEuMC8iCiAgICAgICAgICAgIHhtbG5zOnhtcE1NPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvbW0vIj4KICAgICAgICAgPHhtcDpDcmVhdGVEYXRlPjIwMjQtMDctMDRUMTc6MjY6NTcrMDg6MDA8L3htcDpDcmVhdGVEYXRlPgogICAgICAgICA8eG1wOkNyZWF0b3JUb29sPnBkZkZhY3RvcnkgUHJvIHd3dy5wZGZmYWN0b3J5LmNvbTwveG1wOkNyZWF0b3JUb29sPgogICAgICAgICA8eG1wOk1vZGlmeURhdGU+MjAyNC0wNy0wNVQwNzoyOToyMiswODowMDwveG1wOk1vZGlmeURhdGU+CiAgICAgICAgIDx4bXA6TWV0YWRhdGFEYXRlPjIwMjQtMDctMDVUMDc6Mjk6MjIrMDg6MDA8L3htcDpNZXRhZGF0YURhdGU+CiAgICAgICAgIDxwZGY6UHJvZHVjZXI+cGRmRmFjdG9yeSBQcm8gNS4yNSAoV2luZG93cyA3IFByb2Zlc3Npb25hbCB4NjQgQ2hpbmVzZSAoU2ltcGxpZmllZCkpPC9wZGY6UHJvZHVjZXI+CiAgICAgICAgIDxkYzpmb3JtYXQ+YXBwbGljYXRpb24vcGRmPC9kYzpmb3JtYXQ+CiAgICAgICAgIDxkYzpjcmVhdG9yPgogICAgICAgICAgICA8cmRmOlNlcT4KICAgICAgICAgICAgICAgPHJkZjpsaT5BZG1pbmlzdHJhdG9yPC9yZGY6bGk+CiAgICAgICAgICAgIDwvcmRmOlNlcT4KICAgICAgICAgPC9kYzpjcmVhdG9yPgogICAgICAgICA8YWRob2N3ZjpzdGF0ZT4xPC9hZGhvY3dmOnN0YXRlPgogICAgICAgICA8YWRob2N3Zjp2ZXJzaW9uPjEuMTwvYWRob2N3Zjp2ZXJzaW9uPgogICAgICAgICA8eG1wTU06RG9jdW1lbnRJRD51dWlkOjI3YzUwNzdiLWEzMmEtMDA0NC04ODI2LTg4NDgzYmRkMmQ5YzwveG1wTU06RG9jdW1lbnRJRD4KICAgICAgICAgPHhtcE1NOkluc3RhbmNlSUQ+dXVpZDpiOGQ4MTc2Ny05Yzk1LTg5NDUtOTM0MC0wOWI2MmYzNTMwNjQ8L3htcE1NOkluc3RhbmNlSUQ+CiAgICAgIDwvcmRmOkRlc2NyaXB0aW9uPgogICA8L3JkZjpSREY+CjwveDp4bXBtZXRhPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgCjw/eHBhY2tldCBlbmQ9InciPz4NZW5kc3RyZWFtDWVuZG9iag0yMSAwIG9iag08PC9Bbm5vdHMgMjgwIDAgUi9Db250ZW50cyAyODEgMCBSL0Nyb3BCb3hbMCAwIDIxNSAzNjldL01lZGlhQm94WzAgMCAyMTUgMzY5XS9QYXJlbnQgMTQgMCBSL1Jlc291cmNlczw8L0NvbG9yU3BhY2U8PC9DUzAgMjgyIDAgUi9DUzEgMjgzIDAgUi9DUzIgMjg0IDAgUj4+L0ZvbnQ8PC9DMF8wIDEwNSAwIFI+Pi9Qcm9jU2V0Wy9QREYvVGV4dC9JbWFnZUIvSW1hZ2VDL0ltYWdlSV0vWE9iamVjdDw8L0ltMCA1NiAwIFIvSW0xIDU4IDAgUi9JbTEwIDQyIDAgUi9JbTExIDQ1IDAgUi9JbTEyIDQ2IDAgUi9JbTEzIDQ4IDAgUi9JbTIgNjAgMCBSL0ltMyA2MSAwIFIvSW00IDYyIDAgUi9JbTUgMzcgMCBSL0ltNiAzOCAwIFIvSW03IDM5IDAgUi9JbTggNDAgMCBSL0ltOSA0MSAwIFI+Pj4+L1JvdGF0ZSAwL1R5cGUvUGFnZT4+DWVuZG9iag0yODAgMCBvYmoNWzY5IDAgUiA3MCAwIFIgNzEgMCBSIDcyIDAgUiA3MyAwIFIgNzQgMCBSIDc1IDAgUiA3NiAwIFIgNzcgMCBSIDc4IDAgUiA3OSAwIFIgODAgMCBSIDgxIDAgUiA4MiAwIFIgODMgMCBSIDg0IDAgUiA4NSAwIFJdDWVuZG9iag0yODEgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA1NDE+PnN0cmVhbQ0KSImUVMuO1DAQvPsr+gfw9sNu2xJC2mVB4oiIxJEDsDzEgGYu/D7dsWczq8wwWUWKkri63FVdzj4giEpUYMoxQYqN4fA1fA8f4XfYBwK0y++iNWaGz7uAsTD8heAru8CUIlZ7/BU+hPd27W2BMBvlTMZ0no+YYl3TIbwgilyf0GGnGi08qz3jE82x6AkhY/MdEDTS/1iHtOdQIzCK+djdbI4/2y5jjbLVTc7VQVc5fY5pIycOuhKzXqBzZdfJCPw6fAsUUwIRgUwg7J0Y7YNRikTRTos+RrubdMnJiW2Dm3c7hPs/c2MXsEl6VgxKZ6H1iLT9O46POJwx1iCr6fXn6tOvkRSKx7TjZQteye3qBWlVkNgV+cucitRmR3KJ6dh8XtVIO9akqBWySbHEmYW9QNebWHYH3vQm7f6kkVArKesS9UaWmuLDESm+Ya+pSw237BqvhU0Qh6wNYTMvZXhph9t9jE1tYtXPX++gLR3M6MzLaDVWayUtEcAF7L+R60eDWMdWG7rNtOW0Zd1+2GwElqFuwCwmNxdIrfi0hyh64oD6SsebzcXnRu0Ry6fYyn5STrC2P0ldUkeP2T62TzZ8a+DSX8j+bEbKQ4OVyZxsKv7RViw3l4wZzFTKWcOLergWd+6mWQLCD8BIhRx58xo/mRaYHgLDdLDDVJsRWymrff0SXhLdKuodoeZbvM8Jid6+mn6GN1P4J8AA9nNbQw1lbmRzdHJlYW0NZW5kb2JqDTI4MiAwIG9iag1bL0luZGV4ZWQvRGV2aWNlUkdCIDI1NSAyOCAwIFJdDWVuZG9iag0yODMgMCBvYmoNWy9JbmRleGVkL0RldmljZVJHQiAyNTUgMjkgMCBSXQ1lbmRvYmoNMjg0IDAgb2JqDVsvSW5kZXhlZC9EZXZpY2VSR0IgMjU1IDMwIDAgUl0NZW5kb2JqDTI4NSAwIG9iag08PC9GaWx0ZXIvRmxhdGVEZWNvZGUvRmlyc3QgNS9MZW5ndGggMTc3L04gMS9UeXBlL09ialN0bT4+c3RyZWFtDQpo3mSOQQuDIACF/4q3kkGZZG4jgih2Gwx22KWLpJJQGmq4/fs5NgZjt8fHex+v2AME6jpvNz8Zm7Z8UVo5b5k3FuadFcwro3vmRdofMcIloqgsKK4I3aF9glDyacXxyuWJjTE9wMUaEELIIpJvlI1mgfnZ8F8XQRQfMP664pBvo/iTkQwTMKQ3pbkJDtAXlMK5eI7N4F6VoJuUFk7E0lUt66ykEnyAA4RN8xRgAA+2SDANZW5kc3RyZWFtDWVuZG9iag0yODYgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0ZpcnN0IDUvTGVuZ3RoIDE0My9OIDEvVHlwZS9PYmpTdG0+PnN0cmVhbQ0KaN4UikELwiAYQP/Kd9wO+TnnpgMRhNilgtiEDtGhpdkuLppB/fvs9OC9JzlQUAq3pkDjlsmPSwxjcpv9HB4JKgb2no9QYg8ce4v2g4edUlrjEViV04CDv6Vz3REmmIBGEtHyBhhtSZPZUSIrWV9wfE/p+/R4ml3wCW1xde7l17VE+9cmxiVp/RNgAMeWJ/ANZW5kc3RyZWFtDWVuZG9iag0yODcgMCBvYmoNPDwvRGVjb2RlUGFybXM8PC9Db2x1bW5zIDQvUHJlZGljdG9yIDEyPj4vRmlsdGVyL0ZsYXRlRGVjb2RlL0lEWzw4NUQ1OTUxRDMwOTYxMkE4MTNFQjI2OEJFNEI2MEVFMT48MDdBRUM1NTU0RTQ2NEQ4MDhBN0RBRTlFRDJCNzRGOTg+XS9JbmRleFsyIDEgMTggMSAyMSAxIDg0IDEgMjc5IDldL0luZm8gMTggMCBSL0xlbmd0aCA2MC9QcmV2IDE1ODEyNy9Sb290IDIwIDAgUi9TaXplIDI4OC9UeXBlL1hSZWYvV1sxIDMgMF0+PnN0cmVhbQ0KaN5iYmTKVmFi/DftJ9N/pgppIKvjGdM/hv+PmBiZqh4xMTAwdgEJpmQQyxBIMMAJRn4Q8RYgwABQHQ38DWVuZHN0cmVhbQ1lbmRvYmoNc3RhcnR4cmVmDTE2MzkzNA0lJUVPRg0yIDAgb2JqDTw8L0xlbmd0aCAzNTI4L1N1YnR5cGUvWE1ML1R5cGUvTWV0YWRhdGE+PnN0cmVhbQ0KPD94cGFja2V0IGJlZ2luPSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4KPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iQWRvYmUgWE1QIENvcmUgNy4xLWMwMDAgNzkuY2I3YzVhMSwgMjAyMi8wNC8xNC0wNToyMjozNSAgICAgICAgIj4KICAgPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4KICAgICAgPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIKICAgICAgICAgICAgeG1sbnM6eG1wPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvIgogICAgICAgICAgICB4bWxuczpwZGY9Imh0dHA6Ly9ucy5hZG9iZS5jb20vcGRmLzEuMy8iCiAgICAgICAgICAgIHhtbG5zOmRjPSJodHRwOi8vcHVybC5vcmcvZGMvZWxlbWVudHMvMS4xLyIKICAgICAgICAgICAgeG1sbnM6YWRob2N3Zj0iaHR0cDovL25zLmFkb2JlLmNvbS9BY3JvYmF0QWRob2NXb3JrZmxvdy8xLjAvIgogICAgICAgICAgICB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL21tLyI+CiAgICAgICAgIDx4bXA6Q3JlYXRlRGF0ZT4yMDI0LTA3LTA0VDE3OjI2OjU3KzA4OjAwPC94bXA6Q3JlYXRlRGF0ZT4KICAgICAgICAgPHhtcDpDcmVhdG9yVG9vbD5wZGZGYWN0b3J5IFBybyB3d3cucGRmZmFjdG9yeS5jb208L3htcDpDcmVhdG9yVG9vbD4KICAgICAgICAgPHhtcDpNb2RpZnlEYXRlPjIwMjQtMDctMDVUMDc6MzI6MTArMDg6MDA8L3htcDpNb2RpZnlEYXRlPgogICAgICAgICA8eG1wOk1ldGFkYXRhRGF0ZT4yMDI0LTA3LTA1VDA3OjMyOjEwKzA4OjAwPC94bXA6TWV0YWRhdGFEYXRlPgogICAgICAgICA8cGRmOlByb2R1Y2VyPnBkZkZhY3RvcnkgUHJvIDUuMjUgKFdpbmRvd3MgNyBQcm9mZXNzaW9uYWwgeDY0IENoaW5lc2UgKFNpbXBsaWZpZWQpKTwvcGRmOlByb2R1Y2VyPgogICAgICAgICA8ZGM6Zm9ybWF0PmFwcGxpY2F0aW9uL3BkZjwvZGM6Zm9ybWF0PgogICAgICAgICA8ZGM6Y3JlYXRvcj4KICAgICAgICAgICAgPHJkZjpTZXE+CiAgICAgICAgICAgICAgIDxyZGY6bGk+QWRtaW5pc3RyYXRvcjwvcmRmOmxpPgogICAgICAgICAgICA8L3JkZjpTZXE+CiAgICAgICAgIDwvZGM6Y3JlYXRvcj4KICAgICAgICAgPGFkaG9jd2Y6c3RhdGU+MTwvYWRob2N3ZjpzdGF0ZT4KICAgICAgICAgPGFkaG9jd2Y6dmVyc2lvbj4xLjE8L2FkaG9jd2Y6dmVyc2lvbj4KICAgICAgICAgPHhtcE1NOkRvY3VtZW50SUQ+dXVpZDoyN2M1MDc3Yi1hMzJhLTAwNDQtODgyNi04ODQ4M2JkZDJkOWM8L3htcE1NOkRvY3VtZW50SUQ+CiAgICAgICAgIDx4bXBNTTpJbnN0YW5jZUlEPnV1aWQ6Nzk1YjhlZTUtOTgzMC1iMzRiLTgwZDAtMDdlMzFjNzE5ZWQ0PC94bXBNTTpJbnN0YW5jZUlEPgogICAgICA8L3JkZjpEZXNjcmlwdGlvbj4KICAgPC9yZGY6UkRGPgo8L3g6eG1wbWV0YT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgIAo8P3hwYWNrZXQgZW5kPSJ3Ij8+DWVuZHN0cmVhbQ1lbmRvYmoNMjg4IDAgb2JqDTw8L0JCb3hbMC4wIDAuMCA3NC4wNCAyNC42NTI1XS9Gb3JtVHlwZSAxL0xlbmd0aCAxMy9NYXRyaXhbMS4wIDAuMCAwLjAgMS4wIDAuMCAwLjBdL1Jlc291cmNlczw8L1Byb2NTZXRbL1BERl0+Pi9TdWJ0eXBlL0Zvcm0vVHlwZS9YT2JqZWN0Pj5zdHJlYW0NCi9UeCBCTUMgCkVNQwoNZW5kc3RyZWFtDWVuZG9iag0yODkgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0ZpcnN0IDUvTGVuZ3RoIDE3OC9OIDEvVHlwZS9PYmpTdG0+PnN0cmVhbQ0KaN5kjkELgjAcxb/KbjoC/bu0SYggSrcg6NDFy3ATB7rJNll9+xZFEN0eP9778bISAaqqtNncpE3c8EUqaZ1hThuctkYwJ7XqmBNxdyRAcqCQZ5QcCrqDMgKIPq0wXvl4YkNID3QxGnnvk4DGN0oGveD0rPmvqwC6Jxl8XWHIt0H8yYqEFKiPb1Jx7S2iLzgKa8M5NqP7IUftJJWwIpSucllnOUrBe9xjXNdPAQYADFNIJw1lbmRzdHJlYW0NZW5kb2JqDTI5MCAwIG9iag08PC9GaWx0ZXIvRmxhdGVEZWNvZGUvRmlyc3QgNS9MZW5ndGggMTc2L04gMS9UeXBlL09ialN0bT4+c3RyZWFtDQpo3jSL0QqCMBSGX+Vc2s2Om5oTZCAs6SJEbNBFdNNcJsQWuaLevll4c875v+/86wJiKEus2jAaYJyH3AmBsopwa24voBmoS4DDCmUXnjZWu360QzhbWUunFwDF0q2d9UH/6kX+hzOGFGuF6o0tMDpj7Iz2R5oUJEkZUB6TLGfBJSThYccZYSw74f559p+7wcPYD8ajiqare/idG8bJj7pxK1Szrqx1XoivAAMAt7Q6RA1lbmRzdHJlYW0NZW5kb2JqDTI5MSAwIG9iag08PC9EZWNvZGVQYXJtczw8L0NvbHVtbnMgNC9QcmVkaWN0b3IgMTI+Pi9GaWx0ZXIvRmxhdGVEZWNvZGUvSURbPDg1RDU5NTFEMzA5NjEyQTgxM0VCMjY4QkU0QjYwRUUxPjwzMzAyQkExRTcxQkQ0ODA3Qjg1MTk4NUJFMjg1RkZDNj5dL0luZGV4WzIgMSAxOCAxIDY5IDEgMjg4IDRdL0luZm8gMTggMCBSL0xlbmd0aCA0MC9QcmV2IDE2MzkzNC9Sb290IDIwIDAgUi9TaXplIDI5Mi9UeXBlL1hSZWYvV1sxIDMgMF0+PnN0cmVhbQ0KaN5iYmRqPMbE+K8hmomBgYGR6T9T3w4gi3EPiBAAEXwAAQYAjQcGWA1lbmRzdHJlYW0NZW5kb2JqDXN0YXJ0eHJlZg0xNjg2MjgNJSVFT0YNMiAwIG9iag08PC9MZW5ndGggMzUyOC9TdWJ0eXBlL1hNTC9UeXBlL01ldGFkYXRhPj5zdHJlYW0NCjw/eHBhY2tldCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+Cjx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDcuMS1jMDAwIDc5LmNiN2M1YTEsIDIwMjIvMDQvMTQtMDU6MjI6MzUgICAgICAgICI+CiAgIDxyZGY6UkRGIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+CiAgICAgIDxyZGY6RGVzY3JpcHRpb24gcmRmOmFib3V0PSIiCiAgICAgICAgICAgIHhtbG5zOnhtcD0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLyIKICAgICAgICAgICAgeG1sbnM6cGRmPSJodHRwOi8vbnMuYWRvYmUuY29tL3BkZi8xLjMvIgogICAgICAgICAgICB4bWxuczpkYz0iaHR0cDovL3B1cmwub3JnL2RjL2VsZW1lbnRzLzEuMS8iCiAgICAgICAgICAgIHhtbG5zOmFkaG9jd2Y9Imh0dHA6Ly9ucy5hZG9iZS5jb20vQWNyb2JhdEFkaG9jV29ya2Zsb3cvMS4wLyIKICAgICAgICAgICAgeG1sbnM6eG1wTU09Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iPgogICAgICAgICA8eG1wOkNyZWF0ZURhdGU+MjAyNC0wNy0wNFQxNzoyNjo1NyswODowMDwveG1wOkNyZWF0ZURhdGU+CiAgICAgICAgIDx4bXA6Q3JlYXRvclRvb2w+cGRmRmFjdG9yeSBQcm8gd3d3LnBkZmZhY3RvcnkuY29tPC94bXA6Q3JlYXRvclRvb2w+CiAgICAgICAgIDx4bXA6TW9kaWZ5RGF0ZT4yMDI0LTA3LTA1VDA3OjMzOjQzKzA4OjAwPC94bXA6TW9kaWZ5RGF0ZT4KICAgICAgICAgPHhtcDpNZXRhZGF0YURhdGU+MjAyNC0wNy0wNVQwNzozMzo0MyswODowMDwveG1wOk1ldGFkYXRhRGF0ZT4KICAgICAgICAgPHBkZjpQcm9kdWNlcj5wZGZGYWN0b3J5IFBybyA1LjI1IChXaW5kb3dzIDcgUHJvZmVzc2lvbmFsIHg2NCBDaGluZXNlIChTaW1wbGlmaWVkKSk8L3BkZjpQcm9kdWNlcj4KICAgICAgICAgPGRjOmZvcm1hdD5hcHBsaWNhdGlvbi9wZGY8L2RjOmZvcm1hdD4KICAgICAgICAgPGRjOmNyZWF0b3I+CiAgICAgICAgICAgIDxyZGY6U2VxPgogICAgICAgICAgICAgICA8cmRmOmxpPkFkbWluaXN0cmF0b3I8L3JkZjpsaT4KICAgICAgICAgICAgPC9yZGY6U2VxPgogICAgICAgICA8L2RjOmNyZWF0b3I+CiAgICAgICAgIDxhZGhvY3dmOnN0YXRlPjE8L2FkaG9jd2Y6c3RhdGU+CiAgICAgICAgIDxhZGhvY3dmOnZlcnNpb24+MS4xPC9hZGhvY3dmOnZlcnNpb24+CiAgICAgICAgIDx4bXBNTTpEb2N1bWVudElEPnV1aWQ6MjdjNTA3N2ItYTMyYS0wMDQ0LTg4MjYtODg0ODNiZGQyZDljPC94bXBNTTpEb2N1bWVudElEPgogICAgICAgICA8eG1wTU06SW5zdGFuY2VJRD51dWlkOmVjOWVkM2JhLTFiMzUtN2I0ZS1iOTI1LTk4ZGEwNDUyOTIzMjwveG1wTU06SW5zdGFuY2VJRD4KICAgICAgPC9yZGY6RGVzY3JpcHRpb24+CiAgIDwvcmRmOlJERj4KPC94OnhtcG1ldGE+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAKPD94cGFja2V0IGVuZD0idyI/Pg1lbmRzdHJlYW0NZW5kb2JqDTI5MiAwIG9iag08PC9CQm94WzAuMCAwLjAgNzQuMDQgMjQuNjUyNV0vRm9ybVR5cGUgMS9MZW5ndGggMTMvTWF0cml4WzEuMCAwLjAgMC4wIDEuMCAwLjAgMC4wXS9SZXNvdXJjZXM8PC9Qcm9jU2V0Wy9QREZdPj4vU3VidHlwZS9Gb3JtL1R5cGUvWE9iamVjdD4+c3RyZWFtDQovVHggQk1DIApFTUMKDWVuZHN0cmVhbQ1lbmRvYmoNMjkzIDAgb2JqDTw8L0Jhc2VGb250L0NvdXJpZXItQm9sZC9FbmNvZGluZyA5IDAgUi9OYW1lL0NvQm8vU3VidHlwZS9UeXBlMS9UeXBlL0ZvbnQ+Pg1lbmRvYmoNMjk0IDAgb2JqDTw8L0ZpbHRlci9GbGF0ZURlY29kZS9GaXJzdCA1L0xlbmd0aCAxODYvTiAxL1R5cGUvT2JqU3RtPj5zdHJlYW0NCmjeNI49D8IgEIb/yo06GGprgSYNSRWbDg6mOmkc+oFI0pRE0d8vcLrwcPfcmztKIYGyJLJakEZNH1+d7/7RsCSy9WI/D3Y0s/bfo6ylHf4NKPxYKwSp7ey8rUbbq0YZZ05uXLVKv6fuCWnOwhjak511kAejHw5oFDu7tZAWWSziBRi4dLIHjivCEqOm8XVlaegAyxAbBEUwRAwBTxBrBOY45vgvh47lEbRAhxXDOIvNmxBfAQYAeW5JVw1lbmRzdHJlYW0NZW5kb2JqDTI5NSAwIG9iag08PC9GaWx0ZXIvRmxhdGVEZWNvZGUvRmlyc3QgNS9MZW5ndGggMTc4L04gMS9UeXBlL09ialN0bT4+c3RyZWFtDQpo3mSOQQuCMBzFv8puOgL9q9NJiCBKtyDo0MXLcBMH6mSbrL59iyKIbo8f7/14SYkAVVXc7HZSOmz4IldprGZWaRy3WjAr1doxK8LumEJKgAJJaFrk9ABlABB8Wn688fHEBp8e6KIVcs5FHo1vFA1qwfFZ8V9XDjTLSPZ1+SHfB/Eny6M0R314kytXziD6gqMwxp9jM7oXBLWTXIURvnSVyzbLUQre4x7jun4KMAAO8UguDWVuZHN0cmVhbQ1lbmRvYmoNMjk2IDAgb2JqDTw8L0ZpbHRlci9GbGF0ZURlY29kZS9GaXJzdCA1L0xlbmd0aCAxNzgvTiAxL1R5cGUvT2JqU3RtPj5zdHJlYW0NCmjeNIvBCoJAEIZfZY562dFV0wVZsEw6hIgtdIgurWZC7ERuUW/fSnWZ+ef7/lkICCDPsWjcqIEL7u5WSiwLD1e0JAgTUGcHBx/L1pXWRlM3msHFpqxK0n8AIvv9VmSs05v++gSRfuGMIcZKoXphAzycMba9tocwEiyKOYRZwJKUOxexKHM7SBjnyRF3j5N933rcj93QW1TedKG73dIwTnbUNfmoZl0YQ1bKjwADAJUCOhMNZW5kc3RyZWFtDWVuZG9iag0yOTcgMCBvYmoNPDwvRGVjb2RlUGFybXM8PC9Db2x1bW5zIDQvUHJlZGljdG9yIDEyPj4vRmlsdGVyL0ZsYXRlRGVjb2RlL0lEWzw4NUQ1OTUxRDMwOTYxMkE4MTNFQjI2OEJFNEI2MEVFMT48NzE3NUI5RkE4ODI3NDM5RkE0RTBCNjNDMzFGNUUzNjY+XS9JbmRleFsyIDEgMTggMSA2NiAxIDY5IDEgMjkyIDZdL0luZm8gMTggMCBSL0xlbmd0aCA0Ny9QcmV2IDE2ODYyOC9Sb290IDIwIDAgUi9TaXplIDI5OC9UeXBlL1hSZWYvV1sxIDMgMF0+PnN0cmVhbQ0KaN5iYmSawszE+C9XhYmBgeE/iGBi+s+08D2ItQdIMMaCCAkQIQAmAAIMAOJrByYNZW5kc3RyZWFtDWVuZG9iag1zdGFydHhyZWYNMTczNjcyDSUlRU9GDTIgMCBvYmoNPDwvTGVuZ3RoIDM1MjgvU3VidHlwZS9YTUwvVHlwZS9NZXRhZGF0YT4+c3RyZWFtDQo8P3hwYWNrZXQgYmVnaW49Iu+7vyIgaWQ9Ilc1TTBNcENlaGlIenJlU3pOVGN6a2M5ZCI/Pgo8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1ldGEvIiB4OnhtcHRrPSJBZG9iZSBYTVAgQ29yZSA3LjEtYzAwMCA3OS5jYjdjNWExLCAyMDIyLzA0LzE0LTA1OjIyOjM1ICAgICAgICAiPgogICA8cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPgogICAgICA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIgogICAgICAgICAgICB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iCiAgICAgICAgICAgIHhtbG5zOnBkZj0iaHR0cDovL25zLmFkb2JlLmNvbS9wZGYvMS4zLyIKICAgICAgICAgICAgeG1sbnM6ZGM9Imh0dHA6Ly9wdXJsLm9yZy9kYy9lbGVtZW50cy8xLjEvIgogICAgICAgICAgICB4bWxuczphZGhvY3dmPSJodHRwOi8vbnMuYWRvYmUuY29tL0Fjcm9iYXRBZGhvY1dvcmtmbG93LzEuMC8iCiAgICAgICAgICAgIHhtbG5zOnhtcE1NPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvbW0vIj4KICAgICAgICAgPHhtcDpDcmVhdGVEYXRlPjIwMjQtMDctMDRUMTc6MjY6NTcrMDg6MDA8L3htcDpDcmVhdGVEYXRlPgogICAgICAgICA8eG1wOkNyZWF0b3JUb29sPnBkZkZhY3RvcnkgUHJvIHd3dy5wZGZmYWN0b3J5LmNvbTwveG1wOkNyZWF0b3JUb29sPgogICAgICAgICA8eG1wOk1vZGlmeURhdGU+MjAyNC0wNy0wNVQwNzozODoyMCswODowMDwveG1wOk1vZGlmeURhdGU+CiAgICAgICAgIDx4bXA6TWV0YWRhdGFEYXRlPjIwMjQtMDctMDVUMDc6Mzg6MjArMDg6MDA8L3htcDpNZXRhZGF0YURhdGU+CiAgICAgICAgIDxwZGY6UHJvZHVjZXI+cGRmRmFjdG9yeSBQcm8gNS4yNSAoV2luZG93cyA3IFByb2Zlc3Npb25hbCB4NjQgQ2hpbmVzZSAoU2ltcGxpZmllZCkpPC9wZGY6UHJvZHVjZXI+CiAgICAgICAgIDxkYzpmb3JtYXQ+YXBwbGljYXRpb24vcGRmPC9kYzpmb3JtYXQ+CiAgICAgICAgIDxkYzpjcmVhdG9yPgogICAgICAgICAgICA8cmRmOlNlcT4KICAgICAgICAgICAgICAgPHJkZjpsaT5BZG1pbmlzdHJhdG9yPC9yZGY6bGk+CiAgICAgICAgICAgIDwvcmRmOlNlcT4KICAgICAgICAgPC9kYzpjcmVhdG9yPgogICAgICAgICA8YWRob2N3ZjpzdGF0ZT4xPC9hZGhvY3dmOnN0YXRlPgogICAgICAgICA8YWRob2N3Zjp2ZXJzaW9uPjEuMTwvYWRob2N3Zjp2ZXJzaW9uPgogICAgICAgICA8eG1wTU06RG9jdW1lbnRJRD51dWlkOjI3YzUwNzdiLWEzMmEtMDA0NC04ODI2LTg4NDgzYmRkMmQ5YzwveG1wTU06RG9jdW1lbnRJRD4KICAgICAgICAgPHhtcE1NOkluc3RhbmNlSUQ+dXVpZDpkZDY5MTE5ZS0yOTJmLTRiNGYtODgyZi02NzA2MDUxMTg4OWU8L3htcE1NOkluc3RhbmNlSUQ+CiAgICAgIDwvcmRmOkRlc2NyaXB0aW9uPgogICA8L3JkZjpSREY+CjwveDp4bXBtZXRhPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgCjw/eHBhY2tldCBlbmQ9InciPz4NZW5kc3RyZWFtDWVuZG9iag0yMSAwIG9iag08PC9Bbm5vdHMgMzAxIDAgUi9Db250ZW50cyAzMDIgMCBSL0Nyb3BCb3hbMCAwIDIxNSAzNjldL01lZGlhQm94WzAgMCAyMTUgMzY5XS9QYXJlbnQgMTQgMCBSL1Jlc291cmNlczw8L0NvbG9yU3BhY2U8PC9DUzAgMzAzIDAgUi9DUzEgMzA0IDAgUi9DUzIgMzA1IDAgUj4+L0ZvbnQ8PC9DMF8wIDEwNSAwIFI+Pi9Qcm9jU2V0Wy9QREYvVGV4dC9JbWFnZUIvSW1hZ2VDL0ltYWdlSV0vWE9iamVjdDw8L0ltMCA1NiAwIFIvSW0xIDU4IDAgUi9JbTEwIDQyIDAgUi9JbTExIDQ1IDAgUi9JbTEyIDQ2IDAgUi9JbTEzIDQ4IDAgUi9JbTIgNjAgMCBSL0ltMyA2MSAwIFIvSW00IDYyIDAgUi9JbTUgMzcgMCBSL0ltNiAzOCAwIFIvSW03IDM5IDAgUi9JbTggNDAgMCBSL0ltOSA0MSAwIFI+Pj4+L1JvdGF0ZSAwL1R5cGUvUGFnZT4+DWVuZG9iag0zMDEgMCBvYmoNWzY5IDAgUiA3MCAwIFIgNzEgMCBSIDcyIDAgUiA3MyAwIFIgNzQgMCBSIDc1IDAgUiA3NiAwIFIgNzcgMCBSIDc4IDAgUiA3OSAwIFIgODAgMCBSIDgxIDAgUiA4MiAwIFIgODMgMCBSIDg0IDAgUiA4NSAwIFJdDWVuZG9iag0zMDIgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA1NDE+PnN0cmVhbQ0KSImUVMuO1DAQvPsr+gfw9sNu2xJC2mVB4oiIxJEDsDzEgGYu/D7dsWczq8wwWUWKkri63FVdzj4giEpUYMoxQYqN4fA1fA8f4XfYBwK0y++iNWaGz7uAsTD8heAru8CUIlZ7/BU+hPd27W2BMBvlTMZ0no+YYl3TIbwgilyf0GGnGi08qz3jE82x6AkhY/MdEDTS/1iHtOdQIzCK+djdbI4/2y5jjbLVTc7VQVc5fY5pIycOuhKzXqBzZdfJCPw6fAsUUwIRgUwg7J0Y7YNRikTRTos+RrubdMnJiW2Dm3c7hPs/c2MXsEl6VgxKZ6H1iLT9O46POJwx1iCr6fXn6tOvkRSKx7TjZQteye3qBWlVkNgV+cucitRmR3KJ6dh8XtVIO9akqBWySbHEmYW9QNebWHYH3vQm7f6kkVArKesS9UaWmuLDESm+Ya+pSw237BqvhU0Qh6wNYTMvZXhph9t9jE1tYtXPX++gLR3M6MzLaDVWayUtEcAF7L+R60eDWMdWG7rNtOW0Zd1+2GwElqFuwCwmNxdIrfi0hyh64oD6SsebzcXnRu0Ry6fYyn5STrC2P0ldUkeP2T62TzZ8a+DSX8j+bEbKQ4OVyZxsKv7RViw3l4wZzFTKWcOLergWd+6mWQLCD8BIhRx58xo/mRaYHgLDdLDDVJsRWymrff0SXhLdKuodoeZbvM8Jid6+mn6GN1P4J8AA9nNbQw1lbmRzdHJlYW0NZW5kb2JqDTMwMyAwIG9iag1bL0luZGV4ZWQvRGV2aWNlUkdCIDI1NSAyOCAwIFJdDWVuZG9iag0zMDQgMCBvYmoNWy9JbmRleGVkL0RldmljZVJHQiAyNTUgMjkgMCBSXQ1lbmRvYmoNMzA1IDAgb2JqDVsvSW5kZXhlZC9EZXZpY2VSR0IgMjU1IDMwIDAgUl0NZW5kb2JqDTMwNiAwIG9iag08PC9GaWx0ZXIvRmxhdGVEZWNvZGUvRmlyc3QgNS9MZW5ndGggMTc4L04gMS9UeXBlL09ialN0bT4+c3RyZWFtDQpo3mSOQQuCMBzFv8puOgL9u1yTEEGUbkHQoYuX4SYO1Mk2WX37FkUQ3R4/3vvxsgIBKsu03tyoTVyLWS3KOsOdNjhtjORO6aXlTsbtkQDJgUGeMXKgbAdFBBB9WmG8iuHE+5Ae6GI08t4nAQ1vlPR6xulZi18XBbYvCHxdYSi2Xv7JaEIo6uKbWoT2FrEXHKS14Ryf0P2Qo2ZUi7QylK5qXic1KCk63GFcVU8BBgAO+UguDWVuZHN0cmVhbQ1lbmRvYmoNMzA3IDAgb2JqDTw8L0ZpbHRlci9GbGF0ZURlY29kZS9GaXJzdCAxMi9MZW5ndGggMTgxL04gMi9UeXBlL09ialN0bT4+c3RyZWFtDQpo3qzOPwuCQBzG8bfyG23oft5fTxBBCJcKQg8aokG9yxxSyQvy3WdtQWPr832Gj+YQghZAeQRJgpsswMwOtSuHvi29Xe+69uqBMjCX5diuMAeBuUHzxP02SdIUD8DokgosXONPXJNYSAGxIpIpCSxUhDIONNREn7F81H4eHR472zqPJmiG21j18wrNe876fvBp+hdITFjEIlCcMKo/DikkxIIoLtUPSWXt3U3Tt+QlwABqz0+sDWVuZHN0cmVhbQ1lbmRvYmoNMzA4IDAgb2JqDTw8L0RlY29kZVBhcm1zPDwvQ29sdW1ucyA1L1ByZWRpY3RvciAxMj4+L0ZpbHRlci9GbGF0ZURlY29kZS9JRFs8ODVENTk1MUQzMDk2MTJBODEzRUIyNjhCRTRCNjBFRTE+PEQwRTkyNzE1NUVFRjREN0I4NjRGQzFCMDc5QjlBQTY2Pl0vSW5kZXhbMiAxIDE4IDEgMjEgMSA4MyAyIDI5OCAxMV0vSW5mbyAxOCAwIFIvTGVuZ3RoIDcxL1ByZXYgMTczNjcyL1Jvb3QgMjAgMCBSL1NpemUgMzA5L1R5cGUvWFJlZi9XWzEgMyAxXT4+c3RyZWFtDQpo3mJiZFp+mIGJ8V9UPgPTf6YtS0FsnxgGJgYgYGT6x/D/7H8wmwFKMjJtbwSxGbtAJFMyWNwQQTJCSAEwKcIAEGAAtQcOBg1lbmRzdHJlYW0NZW5kb2JqDXN0YXJ0eHJlZg0xNzk0OTMNJSVFT0YNMiAwIG9iag08PC9MZW5ndGggMzUyOC9TdWJ0eXBlL1hNTC9UeXBlL01ldGFkYXRhPj5zdHJlYW0NCjw/eHBhY2tldCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+Cjx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDcuMS1jMDAwIDc5LmNiN2M1YTEsIDIwMjIvMDQvMTQtMDU6MjI6MzUgICAgICAgICI+CiAgIDxyZGY6UkRGIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+CiAgICAgIDxyZGY6RGVzY3JpcHRpb24gcmRmOmFib3V0PSIiCiAgICAgICAgICAgIHhtbG5zOnhtcD0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLyIKICAgICAgICAgICAgeG1sbnM6cGRmPSJodHRwOi8vbnMuYWRvYmUuY29tL3BkZi8xLjMvIgogICAgICAgICAgICB4bWxuczpkYz0iaHR0cDovL3B1cmwub3JnL2RjL2VsZW1lbnRzLzEuMS8iCiAgICAgICAgICAgIHhtbG5zOmFkaG9jd2Y9Imh0dHA6Ly9ucy5hZG9iZS5jb20vQWNyb2JhdEFkaG9jV29ya2Zsb3cvMS4wLyIKICAgICAgICAgICAgeG1sbnM6eG1wTU09Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iPgogICAgICAgICA8eG1wOkNyZWF0ZURhdGU+MjAyNC0wNy0wNFQxNzoyNjo1NyswODowMDwveG1wOkNyZWF0ZURhdGU+CiAgICAgICAgIDx4bXA6Q3JlYXRvclRvb2w+cGRmRmFjdG9yeSBQcm8gd3d3LnBkZmZhY3RvcnkuY29tPC94bXA6Q3JlYXRvclRvb2w+CiAgICAgICAgIDx4bXA6TW9kaWZ5RGF0ZT4yMDI0LTA3LTA1VDA3OjM4OjQ2KzA4OjAwPC94bXA6TW9kaWZ5RGF0ZT4KICAgICAgICAgPHhtcDpNZXRhZGF0YURhdGU+MjAyNC0wNy0wNVQwNzozODo0NiswODowMDwveG1wOk1ldGFkYXRhRGF0ZT4KICAgICAgICAgPHBkZjpQcm9kdWNlcj5wZGZGYWN0b3J5IFBybyA1LjI1IChXaW5kb3dzIDcgUHJvZmVzc2lvbmFsIHg2NCBDaGluZXNlIChTaW1wbGlmaWVkKSk8L3BkZjpQcm9kdWNlcj4KICAgICAgICAgPGRjOmZvcm1hdD5hcHBsaWNhdGlvbi9wZGY8L2RjOmZvcm1hdD4KICAgICAgICAgPGRjOmNyZWF0b3I+CiAgICAgICAgICAgIDxyZGY6U2VxPgogICAgICAgICAgICAgICA8cmRmOmxpPkFkbWluaXN0cmF0b3I8L3JkZjpsaT4KICAgICAgICAgICAgPC9yZGY6U2VxPgogICAgICAgICA8L2RjOmNyZWF0b3I+CiAgICAgICAgIDxhZGhvY3dmOnN0YXRlPjE8L2FkaG9jd2Y6c3RhdGU+CiAgICAgICAgIDxhZGhvY3dmOnZlcnNpb24+MS4xPC9hZGhvY3dmOnZlcnNpb24+CiAgICAgICAgIDx4bXBNTTpEb2N1bWVudElEPnV1aWQ6MjdjNTA3N2ItYTMyYS0wMDQ0LTg4MjYtODg0ODNiZGQyZDljPC94bXBNTTpEb2N1bWVudElEPgogICAgICAgICA8eG1wTU06SW5zdGFuY2VJRD51dWlkOmVlODk0MDBmLTUyOWYtM2I0MC05NjBkLWI2MzQ3Y2M5MWI0NjwveG1wTU06SW5zdGFuY2VJRD4KICAgICAgPC9yZGY6RGVzY3JpcHRpb24+CiAgIDwvcmRmOlJERj4KPC94OnhtcG1ldGE+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAKPD94cGFja2V0IGVuZD0idyI/Pg1lbmRzdHJlYW0NZW5kb2JqDTIxIDAgb2JqDTw8L0Fubm90cyAzMTYgMCBSL0NvbnRlbnRzIDMxNyAwIFIvQ3JvcEJveFswIDAgMjE1IDM2OV0vTWVkaWFCb3hbMCAwIDIxNSAzNjldL1BhcmVudCAxNCAwIFIvUmVzb3VyY2VzPDwvQ29sb3JTcGFjZTw8L0NTMCAzMTggMCBSL0NTMSAzMTkgMCBSL0NTMiAzMjAgMCBSPj4vRm9udDw8L0MwXzAgMTA1IDAgUj4+L1Byb2NTZXRbL1BERi9UZXh0L0ltYWdlQi9JbWFnZUMvSW1hZ2VJXS9YT2JqZWN0PDwvSW0wIDU2IDAgUi9JbTEgNTggMCBSL0ltMTAgNDIgMCBSL0ltMTEgNDUgMCBSL0ltMTIgNDYgMCBSL0ltMTMgNDggMCBSL0ltMiA2MCAwIFIvSW0zIDYxIDAgUi9JbTQgNjIgMCBSL0ltNSAzNyAwIFIvSW02IDM4IDAgUi9JbTcgMzkgMCBSL0ltOCA0MCAwIFIvSW05IDQxIDAgUj4+Pj4vUm90YXRlIDAvVHlwZS9QYWdlPj4NZW5kb2JqDTMxNiAwIG9iag1bNjkgMCBSIDcwIDAgUiA3MSAwIFIgNzIgMCBSIDczIDAgUiA3NCAwIFIgNzUgMCBSIDc2IDAgUiA3NyAwIFIgNzggMCBSIDc5IDAgUiA4MCAwIFIgODEgMCBSIDgyIDAgUiA4MyAwIFIgODQgMCBSIDg1IDAgUl0NZW5kb2JqDTMxNyAwIG9iag08PC9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDU0MT4+c3RyZWFtDQpIiZRUy47UMBC8+yv6B/D2w27bEkLaZUHiiIjEkQOwPMSAZi78Pt2xZzOrzDBZRYqSuLrcVV3OPiCISlRgyjFBio3h8DV8Dx/hd9gHArTL76I1ZobPu4CxMPyF4Cu7wJQiVnv8FT6E93btbYEwG+VMxnSej5hiXdMhvCCKXJ/QYacaLTyrPeMTzbHoCSFj8x0QNNL/WIe051AjMIr52N1sjj/bLmONstVNztVBVzl9jmkjJw66ErNeoHNl18kI/Dp8CxRTAhGBTCDsnRjtg1GKRNFOiz5Gu5t0ycmJbYObdzuE+z9zYxewSXpWDEpnofWItP07jo84nDHWIKvp9efq06+RFIrHtONlC17J7eoFaVWQ2BX5y5yK1GZHconp2Hxe1Ug71qSoFbJJscSZhb1A15tYdgfe9Cbt/qSRUCsp6xL1Rpaa4sMRKb5hr6lLDbfsGq+FTRCHrA1hMy9leGmH232MTW1i1c9f76AtHczozMtoNVZrJS0RwAXsv5HrR4NYx1Ybus205bRl3X7YbASWoW7ALCY3F0it+LSHKHrigPpKx5vNxedG7RHLp9jKflJOsLY/SV1SR4/ZPrZPNnxr4NJfyP5sRspDg5XJnGwq/tFWLDeXjBnMVMpZw4t6uBZ37qZZAsIPwEiFHHnzGj+ZFpgeAsN0sMNUmxFbKat9/RJeEt0q6h2h5lu8zwmJ3r6afoY3U/gnwAD2c1tDDWVuZHN0cmVhbQ1lbmRvYmoNMzE4IDAgb2JqDVsvSW5kZXhlZC9EZXZpY2VSR0IgMjU1IDI4IDAgUl0NZW5kb2JqDTMxOSAwIG9iag1bL0luZGV4ZWQvRGV2aWNlUkdCIDI1NSAyOSAwIFJdDWVuZG9iag0zMjAgMCBvYmoNWy9JbmRleGVkL0RldmljZVJHQiAyNTUgMzAgMCBSXQ1lbmRvYmoNMzIxIDAgb2JqDTw8L0ZpbHRlci9GbGF0ZURlY29kZS9GaXJzdCA1L0xlbmd0aCAxNzgvTiAxL1R5cGUvT2JqU3RtPj5zdHJlYW0NCmjeZI5BC4MgAIX/irclgzKXGSOCKHYbDHbYpYukklAaarj9+zk2BmO3x8d7Hy+vAAJ1nbWbn4xNWr4orZy3zBsLs84K5pXRPfMi6Y8Y4QJRVOQUl4TuUbVDaPdpxfHK5YmNMT3AxRoQQkgjkm+UjmaB2dnwXxdB9FAV5dcVh3wbxZ+MpJiAIbkpzU1wgL6gFM7Fc2wG97IA3aS0cCKWrmpZZyWV4AMcIGyapwADABHzSDYNZW5kc3RyZWFtDWVuZG9iag0zMjIgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0ZpcnN0IDE5L0xlbmd0aCAyMDkvTiAzL1R5cGUvT2JqU3RtPj5zdHJlYW0NCmjetNAxa8MwEIbhv3JjMlSnO59rCYzBULK0hRALOpQOSaSqHiqHWoHk31ceAxnb9b4bHl7DoMFUQEJgBNhoaFt86lfY++kQhinFIfuHlzF+ZSAG91n+4xo3ILhx6C74+ty2XYdbYCrTDnfhmN9Fq1pqAtKi2FbAulaGBIisIrYfOJwP+XoK+Db6GDK61XFK8xhTCGt0y9CnNOWu+0uM1YoeZcE0qmEuOFZSmbuY79M+Xf+PUpuSYeldKIYaMHa53+uy9/4nzPMt5VeAAQAzz3k2DWVuZHN0cmVhbQ1lbmRvYmoNMzIzIDAgb2JqDTw8L0RlY29kZVBhcm1zPDwvQ29sdW1ucyA1L1ByZWRpY3RvciAxMj4+L0ZpbHRlci9GbGF0ZURlY29kZS9JRFs8ODVENTk1MUQzMDk2MTJBODEzRUIyNjhCRTRCNjBFRTE+PEQzNUQwQzVFQjg3RDRFRDJBRDc2NzQyRjg4NDNBQUYzPl0vSW5kZXhbMiAxIDE4IDEgMjEgMSA4MiAzIDMwOSAxNV0vSW5mbyAxOCAwIFIvTGVuZ3RoIDcxL1ByZXYgMTc5NDkzL1Jvb3QgMjAgMCBSL1NpemUgMzI0L1R5cGUvWFJlZi9XWzEgMyAxXT4+c3RyZWFtDQpo3mJiZNo3k4GJ8Z/zCgam/0ync0Bs06kMTAxAwAgl/zH83/cPzGYgQDIynQsHs7tAJHMymG2ITjIKgEgmAwaAAAMA6nUOGQ1lbmRzdHJlYW0NZW5kb2JqDXN0YXJ0eHJlZg0xODUzNjcNJSVFT0YNMiAwIG9iag08PC9MZW5ndGggMzUyOC9TdWJ0eXBlL1hNTC9UeXBlL01ldGFkYXRhPj5zdHJlYW0NCjw/eHBhY2tldCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+Cjx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDcuMS1jMDAwIDc5LmNiN2M1YTEsIDIwMjIvMDQvMTQtMDU6MjI6MzUgICAgICAgICI+CiAgIDxyZGY6UkRGIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+CiAgICAgIDxyZGY6RGVzY3JpcHRpb24gcmRmOmFib3V0PSIiCiAgICAgICAgICAgIHhtbG5zOnhtcD0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLyIKICAgICAgICAgICAgeG1sbnM6cGRmPSJodHRwOi8vbnMuYWRvYmUuY29tL3BkZi8xLjMvIgogICAgICAgICAgICB4bWxuczpkYz0iaHR0cDovL3B1cmwub3JnL2RjL2VsZW1lbnRzLzEuMS8iCiAgICAgICAgICAgIHhtbG5zOmFkaG9jd2Y9Imh0dHA6Ly9ucy5hZG9iZS5jb20vQWNyb2JhdEFkaG9jV29ya2Zsb3cvMS4wLyIKICAgICAgICAgICAgeG1sbnM6eG1wTU09Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iPgogICAgICAgICA8eG1wOkNyZWF0ZURhdGU+MjAyNC0wNy0wNFQxNzoyNjo1NyswODowMDwveG1wOkNyZWF0ZURhdGU+CiAgICAgICAgIDx4bXA6Q3JlYXRvclRvb2w+cGRmRmFjdG9yeSBQcm8gd3d3LnBkZmZhY3RvcnkuY29tPC94bXA6Q3JlYXRvclRvb2w+CiAgICAgICAgIDx4bXA6TW9kaWZ5RGF0ZT4yMDI0LTA3LTA1VDA3OjM4OjUxKzA4OjAwPC94bXA6TW9kaWZ5RGF0ZT4KICAgICAgICAgPHhtcDpNZXRhZGF0YURhdGU+MjAyNC0wNy0wNVQwNzozODo1MSswODowMDwveG1wOk1ldGFkYXRhRGF0ZT4KICAgICAgICAgPHBkZjpQcm9kdWNlcj5wZGZGYWN0b3J5IFBybyA1LjI1IChXaW5kb3dzIDcgUHJvZmVzc2lvbmFsIHg2NCBDaGluZXNlIChTaW1wbGlmaWVkKSk8L3BkZjpQcm9kdWNlcj4KICAgICAgICAgPGRjOmZvcm1hdD5hcHBsaWNhdGlvbi9wZGY8L2RjOmZvcm1hdD4KICAgICAgICAgPGRjOmNyZWF0b3I+CiAgICAgICAgICAgIDxyZGY6U2VxPgogICAgICAgICAgICAgICA8cmRmOmxpPkFkbWluaXN0cmF0b3I8L3JkZjpsaT4KICAgICAgICAgICAgPC9yZGY6U2VxPgogICAgICAgICA8L2RjOmNyZWF0b3I+CiAgICAgICAgIDxhZGhvY3dmOnN0YXRlPjE8L2FkaG9jd2Y6c3RhdGU+CiAgICAgICAgIDxhZGhvY3dmOnZlcnNpb24+MS4xPC9hZGhvY3dmOnZlcnNpb24+CiAgICAgICAgIDx4bXBNTTpEb2N1bWVudElEPnV1aWQ6MjdjNTA3N2ItYTMyYS0wMDQ0LTg4MjYtODg0ODNiZGQyZDljPC94bXBNTTpEb2N1bWVudElEPgogICAgICAgICA8eG1wTU06SW5zdGFuY2VJRD51dWlkOjQyNWRhNThkLTViNDctZmE0YS05Y2Y5LWI2ZjkyMTkyY2Q0NjwveG1wTU06SW5zdGFuY2VJRD4KICAgICAgPC9yZGY6RGVzY3JpcHRpb24+CiAgIDwvcmRmOlJERj4KPC94OnhtcG1ldGE+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAKPD94cGFja2V0IGVuZD0idyI/Pg1lbmRzdHJlYW0NZW5kb2JqDTIxIDAgb2JqDTw8L0Fubm90cyAzMTYgMCBSL0NvbnRlbnRzIDMyNSAwIFIvQ3JvcEJveFswIDAgMjE1IDM2OV0vTWVkaWFCb3hbMCAwIDIxNSAzNjldL1BhcmVudCAxNCAwIFIvUmVzb3VyY2VzPDwvQ29sb3JTcGFjZTw8L0NTMCAzMjYgMCBSL0NTMSAzMjcgMCBSL0NTMiAzMjggMCBSPj4vRm9udDw8L0MwXzAgMTA1IDAgUj4+L1Byb2NTZXRbL1BERi9UZXh0L0ltYWdlQi9JbWFnZUMvSW1hZ2VJXS9YT2JqZWN0PDwvSW0wIDU2IDAgUi9JbTEgNTggMCBSL0ltMTAgNDIgMCBSL0ltMTEgNDUgMCBSL0ltMTIgNDYgMCBSL0ltMTMgNDggMCBSL0ltMiA2MCAwIFIvSW0zIDYxIDAgUi9JbTQgNjIgMCBSL0ltNSAzNyAwIFIvSW02IDM4IDAgUi9JbTcgMzkgMCBSL0ltOCA0MCAwIFIvSW05IDQxIDAgUj4+Pj4vUm90YXRlIDAvVHlwZS9QYWdlPj4NZW5kb2JqDTMyNSAwIG9iag08PC9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDU0MT4+c3RyZWFtDQpIiZRUy47UMBC8+yv6B/D2w27bEkLaZUHiiIjEkQOwPMSAZi78Pt2xZzOrzDBZRYqSuLrcVV3OPiCISlRgyjFBio3h8DV8Dx/hd9gHArTL76I1ZobPu4CxMPyF4Cu7wJQiVnv8FT6E93btbYEwG+VMxnSej5hiXdMhvCCKXJ/QYacaLTyrPeMTzbHoCSFj8x0QNNL/WIe051AjMIr52N1sjj/bLmONstVNztVBVzl9jmkjJw66ErNeoHNl18kI/Dp8CxRTAhGBTCDsnRjtg1GKRNFOiz5Gu5t0ycmJbYObdzuE+z9zYxewSXpWDEpnofWItP07jo84nDHWIKvp9efq06+RFIrHtONlC17J7eoFaVWQ2BX5y5yK1GZHconp2Hxe1Ug71qSoFbJJscSZhb1A15tYdgfe9Cbt/qSRUCsp6xL1Rpaa4sMRKb5hr6lLDbfsGq+FTRCHrA1hMy9leGmH232MTW1i1c9f76AtHczozMtoNVZrJS0RwAXsv5HrR4NYx1Ybus205bRl3X7YbASWoW7ALCY3F0it+LSHKHrigPpKx5vNxedG7RHLp9jKflJOsLY/SV1SR4/ZPrZPNnxr4NJfyP5sRspDg5XJnGwq/tFWLDeXjBnMVMpZw4t6uBZ37qZZAsIPwEiFHHnzGj+ZFpgeAsN0sMNUmxFbKat9/RJeEt0q6h2h5lu8zwmJ3r6afoY3U/gnwAD2c1tDDWVuZHN0cmVhbQ1lbmRvYmoNMzI2IDAgb2JqDVsvSW5kZXhlZC9EZXZpY2VSR0IgMjU1IDI4IDAgUl0NZW5kb2JqDTMyNyAwIG9iag1bL0luZGV4ZWQvRGV2aWNlUkdCIDI1NSAyOSAwIFJdDWVuZG9iag0zMjggMCBvYmoNWy9JbmRleGVkL0RldmljZVJHQiAyNTUgMzAgMCBSXQ1lbmRvYmoNMzI5IDAgb2JqDTw8L0ZpbHRlci9GbGF0ZURlY29kZS9GaXJzdCA1L0xlbmd0aCAxNzgvTiAxL1R5cGUvT2JqU3RtPj5zdHJlYW0NCmjeZI5BC4MgAIX/ireSQZnLGSOCKHYbDHbYpYukklAaarj9+zk2BmO3x8d7H6+oAAJ1nbebn4xNW74orZy3zBsL884K5pXRPfMi7Y8Y4RJRVBYUHwjdoSpBKPm04njl8sTGmB7gYg0IIWQRyTfKRrPA/Gz4r4sguq9I8XXFId9G8ScjGSZgSG9KcxMcoC8ohXPxHJvB/VCCblJaOBFLV7Wss5JK8AEOEDbNU4ABABB4SDINZW5kc3RyZWFtDWVuZG9iag0zMzAgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0ZpcnN0IDEyL0xlbmd0aCAxNzQvTiAyL1R5cGUvT2JqU3RtPj5zdHJlYW0NCmjerM6xCsIwFEDRX3ljHczLS1PbQAkUpIsK0gYcxMG2MXYwLRjB/r11EQRH53uHkwngkMVAkiDPcV1EWHRDY+vBuzp0y23vrgFIgLnMo1tgCRJLg+aJu02ea417EDSnCivbhqPkLJEJAZFiJBQInrKMUiAumVDxCetHE6bR4qHvnA1oonbw9955axdo3qHwfgha/xXDBZNx9sEozmglf2Nu49lP35SXAAMA1ypQ6w1lbmRzdHJlYW0NZW5kb2JqDTMzMSAwIG9iag08PC9EZWNvZGVQYXJtczw8L0NvbHVtbnMgNS9QcmVkaWN0b3IgMTI+Pi9GaWx0ZXIvRmxhdGVEZWNvZGUvSURbPDg1RDU5NTFEMzA5NjEyQTgxM0VCMjY4QkU0QjYwRUUxPjxCNjU1RjRBMkYwRUI0NTZGOUUzN0I0QzkzM0Q1MDM4Mz5dL0luZGV4WzIgMSAxOCAxIDIxIDEgODIgMiAzMjQgOF0vSW5mbyAxOCAwIFIvTGVuZ3RoIDY2L1ByZXYgMTg1MzY3L1Jvb3QgMjAgMCBSL1NpemUgMzMyL1R5cGUvWFJlZi9XWzEgMyAxXT4+c3RyZWFtDQpo3mJiZLrazcDE+E9nHwPTf6ZHYSC23GoGJgYgYGT6x/B/238mRqanniARpmSwuCGIZDREYguASV4GgAADANCVDWQNZW5kc3RyZWFtDWVuZG9iag1zdGFydHhyZWYNMTkxMDY4DSUlRU9GDTIgMCBvYmoNPDwvTGVuZ3RoIDM1MjgvU3VidHlwZS9YTUwvVHlwZS9NZXRhZGF0YT4+c3RyZWFtDQo8P3hwYWNrZXQgYmVnaW49Iu+7vyIgaWQ9Ilc1TTBNcENlaGlIenJlU3pOVGN6a2M5ZCI/Pgo8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1ldGEvIiB4OnhtcHRrPSJBZG9iZSBYTVAgQ29yZSA3LjEtYzAwMCA3OS5jYjdjNWExLCAyMDIyLzA0LzE0LTA1OjIyOjM1ICAgICAgICAiPgogICA8cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPgogICAgICA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIgogICAgICAgICAgICB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iCiAgICAgICAgICAgIHhtbG5zOnBkZj0iaHR0cDovL25zLmFkb2JlLmNvbS9wZGYvMS4zLyIKICAgICAgICAgICAgeG1sbnM6ZGM9Imh0dHA6Ly9wdXJsLm9yZy9kYy9lbGVtZW50cy8xLjEvIgogICAgICAgICAgICB4bWxuczphZGhvY3dmPSJodHRwOi8vbnMuYWRvYmUuY29tL0Fjcm9iYXRBZGhvY1dvcmtmbG93LzEuMC8iCiAgICAgICAgICAgIHhtbG5zOnhtcE1NPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvbW0vIj4KICAgICAgICAgPHhtcDpDcmVhdGVEYXRlPjIwMjQtMDctMDRUMTc6MjY6NTcrMDg6MDA8L3htcDpDcmVhdGVEYXRlPgogICAgICAgICA8eG1wOkNyZWF0b3JUb29sPnBkZkZhY3RvcnkgUHJvIHd3dy5wZGZmYWN0b3J5LmNvbTwveG1wOkNyZWF0b3JUb29sPgogICAgICAgICA8eG1wOk1vZGlmeURhdGU+MjAyNC0wNy0wNVQwNzozODo1OSswODowMDwveG1wOk1vZGlmeURhdGU+CiAgICAgICAgIDx4bXA6TWV0YWRhdGFEYXRlPjIwMjQtMDctMDVUMDc6Mzg6NTkrMDg6MDA8L3htcDpNZXRhZGF0YURhdGU+CiAgICAgICAgIDxwZGY6UHJvZHVjZXI+cGRmRmFjdG9yeSBQcm8gNS4yNSAoV2luZG93cyA3IFByb2Zlc3Npb25hbCB4NjQgQ2hpbmVzZSAoU2ltcGxpZmllZCkpPC9wZGY6UHJvZHVjZXI+CiAgICAgICAgIDxkYzpmb3JtYXQ+YXBwbGljYXRpb24vcGRmPC9kYzpmb3JtYXQ+CiAgICAgICAgIDxkYzpjcmVhdG9yPgogICAgICAgICAgICA8cmRmOlNlcT4KICAgICAgICAgICAgICAgPHJkZjpsaT5BZG1pbmlzdHJhdG9yPC9yZGY6bGk+CiAgICAgICAgICAgIDwvcmRmOlNlcT4KICAgICAgICAgPC9kYzpjcmVhdG9yPgogICAgICAgICA8YWRob2N3ZjpzdGF0ZT4xPC9hZGhvY3dmOnN0YXRlPgogICAgICAgICA8YWRob2N3Zjp2ZXJzaW9uPjEuMTwvYWRob2N3Zjp2ZXJzaW9uPgogICAgICAgICA8eG1wTU06RG9jdW1lbnRJRD51dWlkOjI3YzUwNzdiLWEzMmEtMDA0NC04ODI2LTg4NDgzYmRkMmQ5YzwveG1wTU06RG9jdW1lbnRJRD4KICAgICAgICAgPHhtcE1NOkluc3RhbmNlSUQ+dXVpZDo0ZjJhNTgyYi0xOWI0LTcxNDgtYjExMC1kNjU2Zjg4OTdjOWI8L3htcE1NOkluc3RhbmNlSUQ+CiAgICAgIDwvcmRmOkRlc2NyaXB0aW9uPgogICA8L3JkZjpSREY+CjwveDp4bXBtZXRhPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgCjw/eHBhY2tldCBlbmQ9InciPz4NZW5kc3RyZWFtDWVuZG9iag0yMSAwIG9iag08PC9Bbm5vdHMgMzMzIDAgUi9Db250ZW50cyAzMzQgMCBSL0Nyb3BCb3hbMCAwIDIxNSAzNjldL01lZGlhQm94WzAgMCAyMTUgMzY5XS9QYXJlbnQgMTQgMCBSL1Jlc291cmNlczw8L0NvbG9yU3BhY2U8PC9DUzAgMzM1IDAgUi9DUzEgMzM2IDAgUi9DUzIgMzM3IDAgUj4+L0ZvbnQ8PC9DMF8wIDEwNSAwIFI+Pi9Qcm9jU2V0Wy9QREYvVGV4dC9JbWFnZUIvSW1hZ2VDL0ltYWdlSV0vWE9iamVjdDw8L0ltMCA1NiAwIFIvSW0xIDU4IDAgUi9JbTEwIDQyIDAgUi9JbTExIDQ1IDAgUi9JbTEyIDQ2IDAgUi9JbTEzIDQ4IDAgUi9JbTIgNjAgMCBSL0ltMyA2MSAwIFIvSW00IDYyIDAgUi9JbTUgMzcgMCBSL0ltNiAzOCAwIFIvSW03IDM5IDAgUi9JbTggNDAgMCBSL0ltOSA0MSAwIFI+Pj4+L1JvdGF0ZSAwL1R5cGUvUGFnZT4+DWVuZG9iag0zMzMgMCBvYmoNWzY5IDAgUiA3MCAwIFIgNzEgMCBSIDcyIDAgUiA3MyAwIFIgNzQgMCBSIDc1IDAgUiA3NiAwIFIgNzcgMCBSIDc4IDAgUiA3OSAwIFIgODAgMCBSIDgxIDAgUiA4MiAwIFIgODMgMCBSIDg0IDAgUiA4NSAwIFJdDWVuZG9iag0zMzQgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA1NDE+PnN0cmVhbQ0KSImUVMuO1DAQvPsr+gfw9sNu2xJC2mVB4oiIxJEDsDzEgGYu/D7dsWczq8wwWUWKkri63FVdzj4giEpUYMoxQYqN4fA1fA8f4XfYBwK0y++iNWaGz7uAsTD8heAru8CUIlZ7/BU+hPd27W2BMBvlTMZ0no+YYl3TIbwgilyf0GGnGi08qz3jE82x6AkhY/MdEDTS/1iHtOdQIzCK+djdbI4/2y5jjbLVTc7VQVc5fY5pIycOuhKzXqBzZdfJCPw6fAsUUwIRgUwg7J0Y7YNRikTRTos+RrubdMnJiW2Dm3c7hPs/c2MXsEl6VgxKZ6H1iLT9O46POJwx1iCr6fXn6tOvkRSKx7TjZQteye3qBWlVkNgV+cucitRmR3KJ6dh8XtVIO9akqBWySbHEmYW9QNebWHYH3vQm7f6kkVArKesS9UaWmuLDESm+Ya+pSw237BqvhU0Qh6wNYTMvZXhph9t9jE1tYtXPX++gLR3M6MzLaDVWayUtEcAF7L+R60eDWMdWG7rNtOW0Zd1+2GwElqFuwCwmNxdIrfi0hyh64oD6SsebzcXnRu0Ry6fYyn5STrC2P0ldUkeP2T62TzZ8a+DSX8j+bEbKQ4OVyZxsKv7RViw3l4wZzFTKWcOLergWd+6mWQLCD8BIhRx58xo/mRaYHgLDdLDDVJsRWymrff0SXhLdKuodoeZbvM8Jid6+mn6GN1P4J8AA9nNbQw1lbmRzdHJlYW0NZW5kb2JqDTMzNSAwIG9iag1bL0luZGV4ZWQvRGV2aWNlUkdCIDI1NSAyOCAwIFJdDWVuZG9iag0zMzYgMCBvYmoNWy9JbmRleGVkL0RldmljZVJHQiAyNTUgMjkgMCBSXQ1lbmRvYmoNMzM3IDAgb2JqDVsvSW5kZXhlZC9EZXZpY2VSR0IgMjU1IDMwIDAgUl0NZW5kb2JqDTMzOCAwIG9iag08PC9GaWx0ZXIvRmxhdGVEZWNvZGUvRmlyc3QgNS9MZW5ndGggMTc4L04gMS9UeXBlL09ialN0bT4+c3RyZWFtDQpo3mSOQQuCMACF/8puOgKdyzkLEUTpFgQdungZbsOBbrJNrH/fogii2+PjvY+XlQCBqkqb1Y/Gxg2flVbOW+aNhWlrBfPK6I55EXdHjHCOKMozigtCd6iMEIo+rTBeuDyxIaQHuFgDtm1LApJvlAxmhunZ8F8XQXRfksPXFYZ8HcSfjCSYgD6+Kc3N5gB9QSmcC+fYBO5FDtpRaeFEKF3VvExKKsF72ENY108BBgATcEg6DWVuZHN0cmVhbQ1lbmRvYmoNMzM5IDAgb2JqDTw8L0ZpbHRlci9GbGF0ZURlY29kZS9GaXJzdCA1L0xlbmd0aCAxMzcvTiAxL1R5cGUvT2JqU3RtPj5zdHJlYW0NCmjeFIrBCsIwEAV/ZY/twa7ZRKIQAgHpRQVpAh7ES9sYi5B4WEH/3nga3rzRCtZgDO5dg24uY/QlJ8/z6rikB4MgCPdapBZ7UNgHDB88HYyxFs9Aol4DDnHiK8luu1EEpEWntASxq0JooMq6b+jfI39fES/LnCJjaJ6yxfA3LufC1v4EGAD4JiWcDWVuZHN0cmVhbQ1lbmRvYmoNMzQwIDAgb2JqDTw8L0RlY29kZVBhcm1zPDwvQ29sdW1ucyA0L1ByZWRpY3RvciAxMj4+L0ZpbHRlci9GbGF0ZURlY29kZS9JRFs8ODVENTk1MUQzMDk2MTJBODEzRUIyNjhCRTRCNjBFRTE+PEFEOTUwODQ0N0Y1OTRFMThBQTJGRTI5NUFDRkE3QkM2Pl0vSW5kZXhbMiAxIDE4IDEgMjEgMSA3NCAxIDMzMiA5XS9JbmZvIDE4IDAgUi9MZW5ndGggNjIvUHJldiAxOTEwNjgvUm9vdCAyMCAwIFIvU2l6ZSAzNDEvVHlwZS9YUmVmL1dbMSAzIDBdPj5zdHJlYW0NCmjeYmJken2KifGfWAfTf6YfPUAWRynTP4b/a5kYmX53MDEwMHYBCaZkIMFgCCMYgQQjowCI+xwgwABjpA4eDWVuZHN0cmVhbQ1lbmRvYmoNc3RhcnR4cmVmDTE5Njg2Mw0lJUVPRg0yIDAgb2JqDTw8L0xlbmd0aCAzNTI4L1N1YnR5cGUvWE1ML1R5cGUvTWV0YWRhdGE+PnN0cmVhbQ0KPD94cGFja2V0IGJlZ2luPSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4KPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iQWRvYmUgWE1QIENvcmUgNy4xLWMwMDAgNzkuY2I3YzVhMSwgMjAyMi8wNC8xNC0wNToyMjozNSAgICAgICAgIj4KICAgPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4KICAgICAgPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIKICAgICAgICAgICAgeG1sbnM6eG1wPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvIgogICAgICAgICAgICB4bWxuczpwZGY9Imh0dHA6Ly9ucy5hZG9iZS5jb20vcGRmLzEuMy8iCiAgICAgICAgICAgIHhtbG5zOmRjPSJodHRwOi8vcHVybC5vcmcvZGMvZWxlbWVudHMvMS4xLyIKICAgICAgICAgICAgeG1sbnM6YWRob2N3Zj0iaHR0cDovL25zLmFkb2JlLmNvbS9BY3JvYmF0QWRob2NXb3JrZmxvdy8xLjAvIgogICAgICAgICAgICB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL21tLyI+CiAgICAgICAgIDx4bXA6Q3JlYXRlRGF0ZT4yMDI0LTA3LTA0VDE3OjI2OjU3KzA4OjAwPC94bXA6Q3JlYXRlRGF0ZT4KICAgICAgICAgPHhtcDpDcmVhdG9yVG9vbD5wZGZGYWN0b3J5IFBybyB3d3cucGRmZmFjdG9yeS5jb208L3htcDpDcmVhdG9yVG9vbD4KICAgICAgICAgPHhtcDpNb2RpZnlEYXRlPjIwMjQtMDctMDVUMDc6NTE6MTYrMDg6MDA8L3htcDpNb2RpZnlEYXRlPgogICAgICAgICA8eG1wOk1ldGFkYXRhRGF0ZT4yMDI0LTA3LTA1VDA3OjUxOjE2KzA4OjAwPC94bXA6TWV0YWRhdGFEYXRlPgogICAgICAgICA8cGRmOlByb2R1Y2VyPnBkZkZhY3RvcnkgUHJvIDUuMjUgKFdpbmRvd3MgNyBQcm9mZXNzaW9uYWwgeDY0IENoaW5lc2UgKFNpbXBsaWZpZWQpKTwvcGRmOlByb2R1Y2VyPgogICAgICAgICA8ZGM6Zm9ybWF0PmFwcGxpY2F0aW9uL3BkZjwvZGM6Zm9ybWF0PgogICAgICAgICA8ZGM6Y3JlYXRvcj4KICAgICAgICAgICAgPHJkZjpTZXE+CiAgICAgICAgICAgICAgIDxyZGY6bGk+QWRtaW5pc3RyYXRvcjwvcmRmOmxpPgogICAgICAgICAgICA8L3JkZjpTZXE+CiAgICAgICAgIDwvZGM6Y3JlYXRvcj4KICAgICAgICAgPGFkaG9jd2Y6c3RhdGU+MTwvYWRob2N3ZjpzdGF0ZT4KICAgICAgICAgPGFkaG9jd2Y6dmVyc2lvbj4xLjE8L2FkaG9jd2Y6dmVyc2lvbj4KICAgICAgICAgPHhtcE1NOkRvY3VtZW50SUQ+dXVpZDoyN2M1MDc3Yi1hMzJhLTAwNDQtODgyNi04ODQ4M2JkZDJkOWM8L3htcE1NOkRvY3VtZW50SUQ+CiAgICAgICAgIDx4bXBNTTpJbnN0YW5jZUlEPnV1aWQ6NzU1M2IyMGQtNGMyMi1kZjQwLWJmM2EtZGU4Mzk1MjdhZDc4PC94bXBNTTpJbnN0YW5jZUlEPgogICAgICA8L3JkZjpEZXNjcmlwdGlvbj4KICAgPC9yZGY6UkRGPgo8L3g6eG1wbWV0YT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgIAo8P3hwYWNrZXQgZW5kPSJ3Ij8+DWVuZHN0cmVhbQ1lbmRvYmoNMjEgMCBvYmoNPDwvQW5ub3RzIDM0MyAwIFIvQ29udGVudHMgMzQ0IDAgUi9Dcm9wQm94WzAgMCAyMTUgMzY5XS9NZWRpYUJveFswIDAgMjE1IDM2OV0vUGFyZW50IDE0IDAgUi9SZXNvdXJjZXM8PC9Db2xvclNwYWNlPDwvQ1MwIDM0NSAwIFIvQ1MxIDM0NiAwIFIvQ1MyIDM0NyAwIFI+Pi9Gb250PDwvQzBfMCAxMDUgMCBSPj4vUHJvY1NldFsvUERGL1RleHQvSW1hZ2VCL0ltYWdlQy9JbWFnZUldL1hPYmplY3Q8PC9JbTAgNTYgMCBSL0ltMSA1OCAwIFIvSW0xMCA0MiAwIFIvSW0xMSA0NSAwIFIvSW0xMiA0NiAwIFIvSW0xMyA0OCAwIFIvSW0yIDYwIDAgUi9JbTMgNjEgMCBSL0ltNCA2MiAwIFIvSW01IDM3IDAgUi9JbTYgMzggMCBSL0ltNyAzOSAwIFIvSW04IDQwIDAgUi9JbTkgNDEgMCBSPj4+Pi9Sb3RhdGUgMC9UeXBlL1BhZ2U+Pg1lbmRvYmoNMzQzIDAgb2JqDVs2OSAwIFIgNzAgMCBSIDcxIDAgUiA3MiAwIFIgNzMgMCBSIDc0IDAgUiA3NSAwIFIgNzYgMCBSIDc3IDAgUiA3OCAwIFIgNzkgMCBSIDgwIDAgUiA4MSAwIFIgODIgMCBSIDgzIDAgUiA4NCAwIFIgODUgMCBSXQ1lbmRvYmoNMzQ0IDAgb2JqDTw8L0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggNTQxPj5zdHJlYW0NCkiJlFTLjtQwELz7K/oH8PbDbtsSQtplQeKIiMSRA7A8xIBmLvw+3bFnM6vMMFlFipK4utxVXc4+IIhKVGDKMUGKjeHwNXwPH+F32AcCtMvvojVmhs+7gLEw/IXgK7vAlCJWe/wVPoT3du1tgTAb5UzGdJ6PmGJd0yG8IIpcn9BhpxotPKs94xPNsegJIWPzHRA00v9Yh7TnUCMwivnY3WyOP9suY42y1U3O1UFXOX2OaSMnDroSs16gc2XXyQj8OnwLFFMCEYFMIOydGO2DUYpE0U6LPka7m3TJyYltg5t3O4T7P3NjF7BJelYMSmeh9Yi0/TuOjzicMdYgq+n15+rTr5EUise042ULXsnt6gVpVZDYFfnLnIrUZkdyienYfF7VSDvWpKgVskmxxJmFvUDXm1h2B970Ju3+pJFQKynrEvVGlpriwxEpvmGvqUsNt+war4VNEIesDWEzL2V4aYfbfYxNbWLVz1/voC0dzOjMy2g1VmslLRHABey/ketHg1jHVhu6zbTltGXdfthsBJahbsAsJjcXSK34tIcoeuKA+krHm83F50btEcun2Mp+Uk6wtj9JXVJHj9k+tk82fGvg0l/I/mxGykODlcmcbCr+0VYsN5eMGcxUylnDi3q4FnfuplkCwg/ASIUcefMaP5kWmB4Cw3Sww1SbEVspq339El4S3SrqHaHmW7zPCYnevpp+hjdT+CfAAPZzW0MNZW5kc3RyZWFtDWVuZG9iag0zNDUgMCBvYmoNWy9JbmRleGVkL0RldmljZVJHQiAyNTUgMjggMCBSXQ1lbmRvYmoNMzQ2IDAgb2JqDVsvSW5kZXhlZC9EZXZpY2VSR0IgMjU1IDI5IDAgUl0NZW5kb2JqDTM0NyAwIG9iag1bL0luZGV4ZWQvRGV2aWNlUkdCIDI1NSAzMCAwIFJdDWVuZG9iag0zNDggMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0ZpcnN0IDUvTGVuZ3RoIDE3Ny9OIDEvVHlwZS9PYmpTdG0+PnN0cmVhbQ0KaN5kjkELgyAAhf+Kt5JBmWTGiCCK3QaDHXbpIqkklIYabv9+jo3B2O3x8d7HK2qAQNPk3e5nY9OOr0or5y3zxsK8t4J5ZfTAvEiHI0a4RBSVBcUVoQdUJwgln1Ycb1ye2BTTA1ysASGELCL5RtlkVpifDf91EURJUVRfVxzyfRJ/MpJhAsb0pjQ3wQH6glI4F8+xBdyrEvSz0sKJWLqqdVuUVIKPcISwbZ8CDAAO8EguDWVuZHN0cmVhbQ1lbmRvYmoNMzQ5IDAgb2JqDTw8L0ZpbHRlci9GbGF0ZURlY29kZS9GaXJzdCA1L0xlbmd0aCAxNDUvTiAxL1R5cGUvT2JqU3RtPj5zdHJlYW0NCmjeFMrNCoJAEADgV5mjHtpx/NlcWBaE8FJB6UKH6JDutgmhEhPk22fn79uWkIDWuKsirNzU+XYaQ8tucxjCk4FSsI91hBhryLG2aL943GttDJ4gpZUabHzP14JErqgEKguhZAaUJUJmEkhJIUndsP10vMweL4MLntFG8/3d+9eZlxjtH6pxnNiYnwADABsYKL0NZW5kc3RyZWFtDWVuZG9iag0zNTAgMCBvYmoNPDwvRGVjb2RlUGFybXM8PC9Db2x1bW5zIDQvUHJlZGljdG9yIDEyPj4vRmlsdGVyL0ZsYXRlRGVjb2RlL0lEWzw4NUQ1OTUxRDMwOTYxMkE4MTNFQjI2OEJFNEI2MEVFMT48ODNEQjY4QURGM0QxNDNENzg2MkMwQzVBMUY1NzVFMDA+XS9JbmRleFsyIDEgMTggMSAyMSAxIDc4IDEgMzQxIDEwXS9JbmZvIDE4IDAgUi9MZW5ndGggNTkvUHJldiAxOTY4NjMvUm9vdCAyMCAwIFIvU2l6ZSAzNTEvVHlwZS9YUmVmL1dbMSAzIDBdPj5zdHJlYW0NCmjeYmJkZspkYvz7/zPTf2Z+RSDr4wOmfwz/FzMxAAETI7OQOojVBSSYk0EsQxSCkR9EvAcIMABafwzdDWVuZHN0cmVhbQ1lbmRvYmoNc3RhcnR4cmVmDTIwMjY2MQ0lJUVPRg0yIDAgb2JqDTw8L0xlbmd0aCAzNTI4L1N1YnR5cGUvWE1ML1R5cGUvTWV0YWRhdGE+PnN0cmVhbQ0KPD94cGFja2V0IGJlZ2luPSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4KPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iQWRvYmUgWE1QIENvcmUgNy4xLWMwMDAgNzkuY2I3YzVhMSwgMjAyMi8wNC8xNC0wNToyMjozNSAgICAgICAgIj4KICAgPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4KICAgICAgPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIKICAgICAgICAgICAgeG1sbnM6eG1wPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvIgogICAgICAgICAgICB4bWxuczpwZGY9Imh0dHA6Ly9ucy5hZG9iZS5jb20vcGRmLzEuMy8iCiAgICAgICAgICAgIHhtbG5zOmRjPSJodHRwOi8vcHVybC5vcmcvZGMvZWxlbWVudHMvMS4xLyIKICAgICAgICAgICAgeG1sbnM6YWRob2N3Zj0iaHR0cDovL25zLmFkb2JlLmNvbS9BY3JvYmF0QWRob2NXb3JrZmxvdy8xLjAvIgogICAgICAgICAgICB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL21tLyI+CiAgICAgICAgIDx4bXA6Q3JlYXRlRGF0ZT4yMDI0LTA3LTA0VDE3OjI2OjU3KzA4OjAwPC94bXA6Q3JlYXRlRGF0ZT4KICAgICAgICAgPHhtcDpDcmVhdG9yVG9vbD5wZGZGYWN0b3J5IFBybyB3d3cucGRmZmFjdG9yeS5jb208L3htcDpDcmVhdG9yVG9vbD4KICAgICAgICAgPHhtcDpNb2RpZnlEYXRlPjIwMjQtMDctMDVUMDc6NTE6MjQrMDg6MDA8L3htcDpNb2RpZnlEYXRlPgogICAgICAgICA8eG1wOk1ldGFkYXRhRGF0ZT4yMDI0LTA3LTA1VDA3OjUxOjI0KzA4OjAwPC94bXA6TWV0YWRhdGFEYXRlPgogICAgICAgICA8cGRmOlByb2R1Y2VyPnBkZkZhY3RvcnkgUHJvIDUuMjUgKFdpbmRvd3MgNyBQcm9mZXNzaW9uYWwgeDY0IENoaW5lc2UgKFNpbXBsaWZpZWQpKTwvcGRmOlByb2R1Y2VyPgogICAgICAgICA8ZGM6Zm9ybWF0PmFwcGxpY2F0aW9uL3BkZjwvZGM6Zm9ybWF0PgogICAgICAgICA8ZGM6Y3JlYXRvcj4KICAgICAgICAgICAgPHJkZjpTZXE+CiAgICAgICAgICAgICAgIDxyZGY6bGk+QWRtaW5pc3RyYXRvcjwvcmRmOmxpPgogICAgICAgICAgICA8L3JkZjpTZXE+CiAgICAgICAgIDwvZGM6Y3JlYXRvcj4KICAgICAgICAgPGFkaG9jd2Y6c3RhdGU+MTwvYWRob2N3ZjpzdGF0ZT4KICAgICAgICAgPGFkaG9jd2Y6dmVyc2lvbj4xLjE8L2FkaG9jd2Y6dmVyc2lvbj4KICAgICAgICAgPHhtcE1NOkRvY3VtZW50SUQ+dXVpZDoyN2M1MDc3Yi1hMzJhLTAwNDQtODgyNi04ODQ4M2JkZDJkOWM8L3htcE1NOkRvY3VtZW50SUQ+CiAgICAgICAgIDx4bXBNTTpJbnN0YW5jZUlEPnV1aWQ6NTQ5NDkzNjUtNGRmOC1lZjRmLTk5YzQtOGI1YmU5YjNkZGZkPC94bXBNTTpJbnN0YW5jZUlEPgogICAgICA8L3JkZjpEZXNjcmlwdGlvbj4KICAgPC9yZGY6UkRGPgo8L3g6eG1wbWV0YT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgIAo8P3hwYWNrZXQgZW5kPSJ3Ij8+DWVuZHN0cmVhbQ1lbmRvYmoNMjEgMCBvYmoNPDwvQW5ub3RzIDM1NSAwIFIvQ29udGVudHMgMzU2IDAgUi9Dcm9wQm94WzAgMCAyMTUgMzY5XS9NZWRpYUJveFswIDAgMjE1IDM2OV0vUGFyZW50IDE0IDAgUi9SZXNvdXJjZXM8PC9Db2xvclNwYWNlPDwvQ1MwIDM1NyAwIFIvQ1MxIDM1OCAwIFIvQ1MyIDM1OSAwIFI+Pi9Gb250PDwvQzBfMCAxMDUgMCBSPj4vUHJvY1NldFsvUERGL1RleHQvSW1hZ2VCL0ltYWdlQy9JbWFnZUldL1hPYmplY3Q8PC9JbTAgNTYgMCBSL0ltMSA1OCAwIFIvSW0xMCA0MiAwIFIvSW0xMSA0NSAwIFIvSW0xMiA0NiAwIFIvSW0xMyA0OCAwIFIvSW0yIDYwIDAgUi9JbTMgNjEgMCBSL0ltNCA2MiAwIFIvSW01IDM3IDAgUi9JbTYgMzggMCBSL0ltNyAzOSAwIFIvSW04IDQwIDAgUi9JbTkgNDEgMCBSPj4+Pi9Sb3RhdGUgMC9UeXBlL1BhZ2U+Pg1lbmRvYmoNMzU1IDAgb2JqDVs2OSAwIFIgNzAgMCBSIDcxIDAgUiA3MiAwIFIgNzMgMCBSIDc0IDAgUiA3NSAwIFIgNzYgMCBSIDc3IDAgUiA3OCAwIFIgNzkgMCBSIDgwIDAgUiA4MSAwIFIgODIgMCBSIDgzIDAgUiA4NCAwIFIgODUgMCBSXQ1lbmRvYmoNMzU2IDAgb2JqDTw8L0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggNTQxPj5zdHJlYW0NCkiJlFTLjtQwELz7K/oH8PbDbtsSQtplQeKIiMSRA7A8xIBmLvw+3bFnM6vMMFlFipK4utxVXc4+IIhKVGDKMUGKjeHwNXwPH+F32AcCtMvvojVmhs+7gLEw/IXgK7vAlCJWe/wVPoT3du1tgTAb5UzGdJ6PmGJd0yG8IIpcn9BhpxotPKs94xPNsegJIWPzHRA00v9Yh7TnUCMwivnY3WyOP9suY42y1U3O1UFXOX2OaSMnDroSs16gc2XXyQj8OnwLFFMCEYFMIOydGO2DUYpE0U6LPka7m3TJyYltg5t3O4T7P3NjF7BJelYMSmeh9Yi0/TuOjzicMdYgq+n15+rTr5EUise042ULXsnt6gVpVZDYFfnLnIrUZkdyienYfF7VSDvWpKgVskmxxJmFvUDXm1h2B970Ju3+pJFQKynrEvVGlpriwxEpvmGvqUsNt+war4VNEIesDWEzL2V4aYfbfYxNbWLVz1/voC0dzOjMy2g1VmslLRHABey/ketHg1jHVhu6zbTltGXdfthsBJahbsAsJjcXSK34tIcoeuKA+krHm83F50btEcun2Mp+Uk6wtj9JXVJHj9k+tk82fGvg0l/I/mxGykODlcmcbCr+0VYsN5eMGcxUylnDi3q4FnfuplkCwg/ASIUcefMaP5kWmB4Cw3Sww1SbEVspq339El4S3SrqHaHmW7zPCYnevpp+hjdT+CfAAPZzW0MNZW5kc3RyZWFtDWVuZG9iag0zNTcgMCBvYmoNWy9JbmRleGVkL0RldmljZVJHQiAyNTUgMjggMCBSXQ1lbmRvYmoNMzU4IDAgb2JqDVsvSW5kZXhlZC9EZXZpY2VSR0IgMjU1IDI5IDAgUl0NZW5kb2JqDTM1OSAwIG9iag1bL0luZGV4ZWQvRGV2aWNlUkdCIDI1NSAzMCAwIFJdDWVuZG9iag0zNjAgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0ZpcnN0IDUvTGVuZ3RoIDE3Ny9OIDEvVHlwZS9PYmpTdG0+PnN0cmVhbQ0KaN5kjkELgyAAhf+Kt5JBmWTGiCCK3QaDHXbpIqkklIYabv9+jo3B2O3x8d7HK2qAQNPk3e5nY9OOr0or5y3zxsK8t4J5ZfTAvEiHI0a4RBSVBcUVoQdUJwgln1Ycb1ye2BTTA1ysASGELCL5RtlkVpifDf91EURJgcuvKw75Pok/GckwAWN6U5qb4AB9QSmci+fYAu5VCfpZaeFELF3Vui1KKsFHOELYtk8BBgAOkkgtDWVuZHN0cmVhbQ1lbmRvYmoNMzYxIDAgb2JqDTw8L0ZpbHRlci9GbGF0ZURlY29kZS9GaXJzdCA1L0xlbmd0aCAxNDYvTiAxL1R5cGUvT2JqU3RtPj5zdHJlYW0NCmjeFIuxDoIwFEV/5Y0w2Ecp5kHSNCExLGpioImDcRBaK4OF4ZnI31uXO5xzLjVQgNZ4aDNs3TL6YYlhYLc7zeHFIEuwz1SEHDuosLNov3g+am0MXqCUSfXY+4lvioQqGgmSlChJpScJqvYgayVqUnccPiNvq8fr7IJntNn62N4+sk0wx/9iG+PCxvwEGABwXSmgDWVuZHN0cmVhbQ1lbmRvYmoNMzYyIDAgb2JqDTw8L0RlY29kZVBhcm1zPDwvQ29sdW1ucyA0L1ByZWRpY3RvciAxMj4+L0ZpbHRlci9GbGF0ZURlY29kZS9JRFs8ODVENTk1MUQzMDk2MTJBODEzRUIyNjhCRTRCNjBFRTE+PDcwQThENUUyRDY1MzRGRkZBQUFCMUQ0QTAwOTFFRDU3Pl0vSW5kZXhbMiAxIDE4IDEgMjEgMSA3OSAxIDM1MSAxMl0vSW5mbyAxOCAwIFIvTGVuZ3RoIDYzL1ByZXYgMjAyNjYxL1Jvb3QgMjAgMCBSL1NpemUgMzYzL1R5cGUvWFJlZi9XWzEgMyAwXT4+c3RyZWFtDQpo3mJiZJbkZWL8+yKa6T+z2k4g65YH0z+G/9OZGIAAiWBk1jgNZDF2AQmmZJCYIYhrCGfxg4gPAAEGAJXaDJ0NZW5kc3RyZWFtDWVuZG9iag1zdGFydHhyZWYNMjA4NDU4DSUlRU9GDTIgMCBvYmoNPDwvTGVuZ3RoIDM1MjgvU3VidHlwZS9YTUwvVHlwZS9NZXRhZGF0YT4+c3RyZWFtDQo8P3hwYWNrZXQgYmVnaW49Iu+7vyIgaWQ9Ilc1TTBNcENlaGlIenJlU3pOVGN6a2M5ZCI/Pgo8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1ldGEvIiB4OnhtcHRrPSJBZG9iZSBYTVAgQ29yZSA3LjEtYzAwMCA3OS5jYjdjNWExLCAyMDIyLzA0LzE0LTA1OjIyOjM1ICAgICAgICAiPgogICA8cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPgogICAgICA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIgogICAgICAgICAgICB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iCiAgICAgICAgICAgIHhtbG5zOnBkZj0iaHR0cDovL25zLmFkb2JlLmNvbS9wZGYvMS4zLyIKICAgICAgICAgICAgeG1sbnM6ZGM9Imh0dHA6Ly9wdXJsLm9yZy9kYy9lbGVtZW50cy8xLjEvIgogICAgICAgICAgICB4bWxuczphZGhvY3dmPSJodHRwOi8vbnMuYWRvYmUuY29tL0Fjcm9iYXRBZGhvY1dvcmtmbG93LzEuMC8iCiAgICAgICAgICAgIHhtbG5zOnhtcE1NPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvbW0vIj4KICAgICAgICAgPHhtcDpDcmVhdGVEYXRlPjIwMjQtMDctMDRUMTc6MjY6NTcrMDg6MDA8L3htcDpDcmVhdGVEYXRlPgogICAgICAgICA8eG1wOkNyZWF0b3JUb29sPnBkZkZhY3RvcnkgUHJvIHd3dy5wZGZmYWN0b3J5LmNvbTwveG1wOkNyZWF0b3JUb29sPgogICAgICAgICA8eG1wOk1vZGlmeURhdGU+MjAyNC0wNy0wNVQwNzo1MTozMiswODowMDwveG1wOk1vZGlmeURhdGU+CiAgICAgICAgIDx4bXA6TWV0YWRhdGFEYXRlPjIwMjQtMDctMDVUMDc6NTE6MzIrMDg6MDA8L3htcDpNZXRhZGF0YURhdGU+CiAgICAgICAgIDxwZGY6UHJvZHVjZXI+cGRmRmFjdG9yeSBQcm8gNS4yNSAoV2luZG93cyA3IFByb2Zlc3Npb25hbCB4NjQgQ2hpbmVzZSAoU2ltcGxpZmllZCkpPC9wZGY6UHJvZHVjZXI+CiAgICAgICAgIDxkYzpmb3JtYXQ+YXBwbGljYXRpb24vcGRmPC9kYzpmb3JtYXQ+CiAgICAgICAgIDxkYzpjcmVhdG9yPgogICAgICAgICAgICA8cmRmOlNlcT4KICAgICAgICAgICAgICAgPHJkZjpsaT5BZG1pbmlzdHJhdG9yPC9yZGY6bGk+CiAgICAgICAgICAgIDwvcmRmOlNlcT4KICAgICAgICAgPC9kYzpjcmVhdG9yPgogICAgICAgICA8YWRob2N3ZjpzdGF0ZT4xPC9hZGhvY3dmOnN0YXRlPgogICAgICAgICA8YWRob2N3Zjp2ZXJzaW9uPjEuMTwvYWRob2N3Zjp2ZXJzaW9uPgogICAgICAgICA8eG1wTU06RG9jdW1lbnRJRD51dWlkOjI3YzUwNzdiLWEzMmEtMDA0NC04ODI2LTg4NDgzYmRkMmQ5YzwveG1wTU06RG9jdW1lbnRJRD4KICAgICAgICAgPHhtcE1NOkluc3RhbmNlSUQ+dXVpZDozNjM2NjE1NC04YTU1LWU1NGYtODAzNy02MThjMDk0NzUxNzI8L3htcE1NOkluc3RhbmNlSUQ+CiAgICAgIDwvcmRmOkRlc2NyaXB0aW9uPgogICA8L3JkZjpSREY+CjwveDp4bXBtZXRhPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgCjw/eHBhY2tldCBlbmQ9InciPz4NZW5kc3RyZWFtDWVuZG9iag0yMSAwIG9iag08PC9Bbm5vdHMgMzY1IDAgUi9Db250ZW50cyAzNjYgMCBSL0Nyb3BCb3hbMCAwIDIxNSAzNjldL01lZGlhQm94WzAgMCAyMTUgMzY5XS9QYXJlbnQgMTQgMCBSL1Jlc291cmNlczw8L0NvbG9yU3BhY2U8PC9DUzAgMzY3IDAgUi9DUzEgMzY4IDAgUi9DUzIgMzY5IDAgUj4+L0ZvbnQ8PC9DMF8wIDEwNSAwIFI+Pi9Qcm9jU2V0Wy9QREYvVGV4dC9JbWFnZUIvSW1hZ2VDL0ltYWdlSV0vWE9iamVjdDw8L0ltMCA1NiAwIFIvSW0xIDU4IDAgUi9JbTEwIDQyIDAgUi9JbTExIDQ1IDAgUi9JbTEyIDQ2IDAgUi9JbTEzIDQ4IDAgUi9JbTIgNjAgMCBSL0ltMyA2MSAwIFIvSW00IDYyIDAgUi9JbTUgMzcgMCBSL0ltNiAzOCAwIFIvSW03IDM5IDAgUi9JbTggNDAgMCBSL0ltOSA0MSAwIFI+Pj4+L1JvdGF0ZSAwL1R5cGUvUGFnZT4+DWVuZG9iag0zNjUgMCBvYmoNWzY5IDAgUiA3MCAwIFIgNzEgMCBSIDcyIDAgUiA3MyAwIFIgNzQgMCBSIDc1IDAgUiA3NiAwIFIgNzcgMCBSIDc4IDAgUiA3OSAwIFIgODAgMCBSIDgxIDAgUiA4MiAwIFIgODMgMCBSIDg0IDAgUiA4NSAwIFJdDWVuZG9iag0zNjYgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA1NDE+PnN0cmVhbQ0KSImUVMuO1DAQvPsr+gfw9sNu2xJC2mVB4oiIxJEDsDzEgGYu/D7dsWczq8wwWUWKkri63FVdzj4giEpUYMoxQYqN4fA1fA8f4XfYBwK0y++iNWaGz7uAsTD8heAru8CUIlZ7/BU+hPd27W2BMBvlTMZ0no+YYl3TIbwgilyf0GGnGi08qz3jE82x6AkhY/MdEDTS/1iHtOdQIzCK+djdbI4/2y5jjbLVTc7VQVc5fY5pIycOuhKzXqBzZdfJCPw6fAsUUwIRgUwg7J0Y7YNRikTRTos+RrubdMnJiW2Dm3c7hPs/c2MXsEl6VgxKZ6H1iLT9O46POJwx1iCr6fXn6tOvkRSKx7TjZQteye3qBWlVkNgV+cucitRmR3KJ6dh8XtVIO9akqBWySbHEmYW9QNebWHYH3vQm7f6kkVArKesS9UaWmuLDESm+Ya+pSw237BqvhU0Qh6wNYTMvZXhph9t9jE1tYtXPX++gLR3M6MzLaDVWayUtEcAF7L+R60eDWMdWG7rNtOW0Zd1+2GwElqFuwCwmNxdIrfi0hyh64oD6SsebzcXnRu0Ry6fYyn5STrC2P0ldUkeP2T62TzZ8a+DSX8j+bEbKQ4OVyZxsKv7RViw3l4wZzFTKWcOLergWd+6mWQLCD8BIhRx58xo/mRaYHgLDdLDDVJsRWymrff0SXhLdKuodoeZbvM8Jid6+mn6GN1P4J8AA9nNbQw1lbmRzdHJlYW0NZW5kb2JqDTM2NyAwIG9iag1bL0luZGV4ZWQvRGV2aWNlUkdCIDI1NSAyOCAwIFJdDWVuZG9iag0zNjggMCBvYmoNWy9JbmRleGVkL0RldmljZVJHQiAyNTUgMjkgMCBSXQ1lbmRvYmoNMzY5IDAgb2JqDVsvSW5kZXhlZC9EZXZpY2VSR0IgMjU1IDMwIDAgUl0NZW5kb2JqDTM3MCAwIG9iag08PC9GaWx0ZXIvRmxhdGVEZWNvZGUvRmlyc3QgNS9MZW5ndGggMTc3L04gMS9UeXBlL09ialN0bT4+c3RyZWFtDQpo3mSOQQuDIACF/4q3kkGZyxkjgih2Gwx22KWLpJJQGmq4/fs5NgZjt8fHex+vqAACdZ23m5+MTVu+KK2ct8wbC/POCuaV0T3zIu2PGOESUVQWFB8I3aEqQSj5tOJ45fLExpge4GINCCFkEck3ykazwPxs+K+LIEqKPf664pBvo/iTkQwTMKQ3pbkJDtAXlMK5eI7N4H4oQTcpLZyIpata1llJJfgABwib5inAAA40SCwNZW5kc3RyZWFtDWVuZG9iag0zNzEgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0ZpcnN0IDUvTGVuZ3RoIDE0Mi9OIDEvVHlwZS9PYmpTdG0+PnN0cmVhbQ0KaN4UyrsKwjAUANBfuWM7mNvEpA8IgYIURAVpAg7iUpPGLongFfTvrfM5bQUVaI27vsDe5ynYnKIlvzku8UHABbh5HbHEASQODt0HTwetjcEzCL7SiGO401Wxtqs64LJmTS2BbxWrgTeCqVbc0L4n+j4DXhYfA6ErYs7+tU9zLtH9oU8pkzE/AQYAsIAoDQ1lbmRzdHJlYW0NZW5kb2JqDTM3MiAwIG9iag08PC9EZWNvZGVQYXJtczw8L0NvbHVtbnMgNC9QcmVkaWN0b3IgMTI+Pi9GaWx0ZXIvRmxhdGVEZWNvZGUvSURbPDg1RDU5NTFEMzA5NjEyQTgxM0VCMjY4QkU0QjYwRUUxPjw5ODEyODk0QjFGRTA0RTA0ODNGODE0NkFBQzNGNEM1Rj5dL0luZGV4WzIgMSAxOCAxIDIxIDEgODAgMSAzNjMgMTBdL0luZm8gMTggMCBSL0xlbmd0aCA1OS9QcmV2IDIwODQ1OC9Sb290IDIwIDAgUi9TaXplIDM3My9UeXBlL1hSZWYvV1sxIDMgMF0+PnN0cmVhbQ0KaN5iYmTW38bE+PfSHqb/zDYRQNaRlUz/GP73MjEAARMjs30JiNUFJJiTQSxDFIKJH8R6AxBgAHF2DVQNZW5kc3RyZWFtDWVuZG9iag1zdGFydHhyZWYNMjE0MjU1DSUlRU9GDQ=="); +// String tplStrBase64=sb.toString(); +// String pdfBase64Str =xtp.genPDFBase64(order,tplStrBase64); +// System.out.println(pdfBase64Str); + +// xtp.genPNGBase64(order); + } + + + public static void main(String[] args) { + try { + + for(int i=0;i<1;i++){ + testPrint(i); + } + + +// xtp.testPdfPrint("/Users/alan/work/git/doitinfo/ai/logistic/src/main/resources/print_tpl/ynmb_blank.pdf","/Users/alan/Downloads/ynmb_blank_t21.pdf"); +// testPdfPrint("/Users/alan/work/git/doitinfo/ai/logistic/src/main/resources/print_tpl/ynmb_blank.pdf","/Users/alan/Downloads/ynmb_blank_t21.pdf"); +// testPdfPrint2Png("/Users/alan/work/git/doitinfo/ai/logistic/src/main/resources/print_tpl/lt_blank_bd.pdf","/Users/alan/Downloads/ynmb_blank_t10.png"); +// testPdfPrint2Png("/Users/alan/Downloads/ynmb_blank_t21.pdf","/Users/alan/Downloads/ynmb_blank_x1.png"); + + + } catch (Exception e) { + e.printStackTrace(); + } + } + + +} diff --git a/emis-biz/src/main/java/com/xdadan/erp/emis/service/print/tanex/TanexSubBillPrintImpl.java b/emis-biz/src/main/java/com/xdadan/erp/emis/service/print/tanex/TanexSubBillPrintImpl.java index a8d241630..680988817 100644 --- a/emis-biz/src/main/java/com/xdadan/erp/emis/service/print/tanex/TanexSubBillPrintImpl.java +++ b/emis-biz/src/main/java/com/xdadan/erp/emis/service/print/tanex/TanexSubBillPrintImpl.java @@ -123,7 +123,7 @@ public class TanexSubBillPrintImpl extends XddBasePrint { * @throws Exception */ @Override - public AjaxResult genPDF(Map orderMap, OutputStream os) throws Exception { + public AjaxResult genPDF(Map orderMap,String tplStrBase64, OutputStream os) throws Exception { AjaxResult ar = new AjaxResult(); ClassPathResource classPathResource = new ClassPathResource(tplName); @@ -138,11 +138,11 @@ public class TanexSubBillPrintImpl extends XddBasePrint { @Override - public AjaxResult genPNG(Map order, OutputStream os) throws Exception { + public AjaxResult genPNG(Map order,String tplStrBase64, OutputStream os) throws Exception { AjaxResult ar = new AjaxResult(); ByteArrayOutputStream bos = new ByteArrayOutputStream(); - genPDF(order, bos); + genPDF(order,tplStrBase64, bos); PDDocument document = PDDocument.load(bos.toByteArray()); PDFRenderer renderer = new PDFRenderer(document); BufferedImage bufferedImage = renderer.renderImageWithDPI(0, 200, ImageType.RGB); @@ -151,12 +151,12 @@ public class TanexSubBillPrintImpl extends XddBasePrint { } @Override - public String genPNGBase64(Map order) throws Exception { + public String genPNGBase64(Map order,String tplStrBase64) throws Exception { ByteArrayOutputStream bos = new ByteArrayOutputStream(); // 生成pdf - genPDF(order,bos); + genPDF(order,tplStrBase64,bos); PDDocument document = PDDocument.load(bos.toByteArray()); // bos.close(); PDFRenderer renderer = new PDFRenderer(document); @@ -174,11 +174,11 @@ public class TanexSubBillPrintImpl extends XddBasePrint { } @Override - public String genPDFBase64(Map order) throws Exception { + public String genPDFBase64(Map order,String tplStrBase64) throws Exception { ByteArrayOutputStream bos = new ByteArrayOutputStream(); // 生成pdfbase64 - genPDF(order,bos); + genPDF(order,tplStrBase64,bos); byte[] pdfBytes = bos.toByteArray(); String pdfBase64Str = Base64.getEncoder().encodeToString(pdfBytes); return pdfBase64Str; @@ -236,7 +236,8 @@ public class TanexSubBillPrintImpl extends XddBasePrint { // 生成pdf base64 // byte[] pdfBytes = os.toByteArray(); // String pdfBase64Str = Base64.getEncoder().encodeToString(pdfBytes); - String pdfBase64Str =xtp.genPDFBase64(order); + String tplStrBase64=""; + String pdfBase64Str =xtp.genPDFBase64(order,tplStrBase64); System.out.println(pdfBase64Str); // xtp.genPNGBase64(order); @@ -250,11 +251,10 @@ public class TanexSubBillPrintImpl extends XddBasePrint { testPrint(i); } - // xtp.testPdfPrint("/Users/alan/work/git/doitinfo/ai/logistic/src/main/resources/print_tpl/ynmb_blank.pdf","/Users/alan/Downloads/ynmb_blank_t21.pdf"); // testPdfPrint("/Users/alan/work/git/doitinfo/ai/logistic/src/main/resources/print_tpl/ynmb_blank.pdf","/Users/alan/Downloads/ynmb_blank_t21.pdf"); // testPdfPrint2Png("/Users/alan/work/git/doitinfo/ai/logistic/src/main/resources/print_tpl/lt_blank_bd.pdf","/Users/alan/Downloads/ynmb_blank_t10.png"); -// testPdfPrint2Png("/Users/alan/Downloads/ynmb_blank_t21.pdf","/Users/alan/Downloads/ynmb_blank_x1.png"); +// testPdfPrint2Png("/Users/alan/Downloads/ynmb_blank_t21.pdf","/Users/alan/Downloads/ynmb_blank_x1.png"); } catch (Exception e) { diff --git a/emis-biz/src/main/java/com/xdadan/erp/emis/service/print/tanex/TanexTplPrintImpl.java b/emis-biz/src/main/java/com/xdadan/erp/emis/service/print/tanex/TanexTplPrintImpl.java index 7aea4a968..afbb6dd3b 100644 --- a/emis-biz/src/main/java/com/xdadan/erp/emis/service/print/tanex/TanexTplPrintImpl.java +++ b/emis-biz/src/main/java/com/xdadan/erp/emis/service/print/tanex/TanexTplPrintImpl.java @@ -28,6 +28,8 @@ public class TanexTplPrintImpl extends XddBasePrint { * 模版文件 */ // private static String tplName="tpl/tanex_sd_2.pdf"; + private static String tplPath="/Users/alan/work/git/tanex56/emis-service/emis-biz/src/main/resources/tpl/"; + private static String tplName="/Users/alan/work/git/tanex56/emis-service/emis-biz/src/main/resources/tpl/tanex_zd_tpl.pdf"; // private static String tplName="/Users/alan/work/git/doitinfo/ai/logistic/src/main/resources/print_tpl/tanex/tanex_sd_2.pdf"; @@ -120,7 +122,7 @@ public class TanexTplPrintImpl extends XddBasePrint { * @throws Exception */ @Override - public AjaxResult genPDF(Map orderMap, OutputStream os) throws Exception { + public AjaxResult genPDF(Map orderMap,String tplStrBase64, OutputStream os) throws Exception { AjaxResult ar = new AjaxResult(); ClassPathResource classPathResource = new ClassPathResource(tplName); @@ -135,11 +137,11 @@ public class TanexTplPrintImpl extends XddBasePrint { @Override - public AjaxResult genPNG(Map order, OutputStream os) throws Exception { + public AjaxResult genPNG(Map order,String tplStrBase64, OutputStream os) throws Exception { AjaxResult ar = new AjaxResult(); ByteArrayOutputStream bos = new ByteArrayOutputStream(); - genPDF(order, bos); + genPDF(order,tplStrBase64, bos); PDDocument document = PDDocument.load(bos.toByteArray()); PDFRenderer renderer = new PDFRenderer(document); BufferedImage bufferedImage = renderer.renderImageWithDPI(0, 280, ImageType.RGB); @@ -148,23 +150,23 @@ public class TanexTplPrintImpl extends XddBasePrint { } @Override - public String genPDFBase64(Map order) throws Exception { + public String genPDFBase64(Map order,String tplStrBase64) throws Exception { ByteArrayOutputStream bos = new ByteArrayOutputStream(); // 生成pdfbase64 - genPDF(order,bos); + genPDF(order,tplStrBase64,bos); byte[] pdfBytes = bos.toByteArray(); String pdfBase64Str = Base64.getEncoder().encodeToString(pdfBytes); return pdfBase64Str; } @Override - public String genPNGBase64(Map order) throws Exception { + public String genPNGBase64(Map order,String tplStrBase64) throws Exception { ByteArrayOutputStream bos = new ByteArrayOutputStream(); // 生成pdf - genPDF(order,bos); + genPDF(order,tplStrBase64,bos); PDDocument document = PDDocument.load(bos.toByteArray()); // bos.close(); PDFRenderer renderer = new PDFRenderer(document); @@ -214,9 +216,10 @@ public class TanexTplPrintImpl extends XddBasePrint { ByteArrayOutputStream os = new ByteArrayOutputStream(); + String tplStrBase64=""; IXddTplPrint xtp = new TanexTplPrintImpl(); - xtp.genPDF(order,os); - xtp.genPNG(order,out); + xtp.genPDF(order,tplStrBase64,os); + xtp.genPNG(order,tplStrBase64,out); // 生成pdf base64 byte[] pdfBytes = os.toByteArray(); @@ -230,15 +233,15 @@ public class TanexTplPrintImpl extends XddBasePrint { public static void main(String[] args) { try { - for(int i=0;i<1;i++){ - testPrint(i); - } +// for(int i=0;i<1;i++){ +// testPrint(i); +// } // xtp.testPdfPrint("/Users/alan/work/git/doitinfo/ai/logistic/src/main/resources/print_tpl/ynmb_blank.pdf","/Users/alan/Downloads/ynmb_blank_t21.pdf"); // testPdfPrint("/Users/alan/work/git/doitinfo/ai/logistic/src/main/resources/print_tpl/ynmb_blank.pdf","/Users/alan/Downloads/ynmb_blank_t21.pdf"); // testPdfPrint2Png("/Users/alan/work/git/doitinfo/ai/logistic/src/main/resources/print_tpl/lt_blank_bd.pdf","/Users/alan/Downloads/ynmb_blank_t10.png"); -// testPdfPrint2Png("/Users/alan/Downloads/ynmb_blank_t21.pdf","/Users/alan/Downloads/ynmb_blank_x1.png"); +// testPdfPrint2Png("ynmb_blank_t21.pdf","/Users/alan/Downloads/ynmb_blank_x1.png"); } catch (Exception e) { diff --git a/emis-biz/src/main/resources/tpl/TAN-CM-130.pdf b/emis-biz/src/main/resources/tpl/TAN-CM-130.pdf new file mode 100644 index 000000000..2aa9f84db Binary files /dev/null and b/emis-biz/src/main/resources/tpl/TAN-CM-130.pdf differ diff --git a/emis-biz/src/main/resources/tpl/TAN-GC-130.pdf b/emis-biz/src/main/resources/tpl/TAN-GC-130.pdf new file mode 100644 index 000000000..b778f297c Binary files /dev/null and b/emis-biz/src/main/resources/tpl/TAN-GC-130.pdf differ diff --git a/emis-biz/src/main/resources/tpl/TAN-GM-130.pdf b/emis-biz/src/main/resources/tpl/TAN-GM-130.pdf new file mode 100644 index 000000000..528f9c634 Binary files /dev/null and b/emis-biz/src/main/resources/tpl/TAN-GM-130.pdf differ