diff --git a/OpenXmlPowerTools.Tests/Html/HtmlToWmlReadAsXElement.cs b/OpenXmlPowerTools.Tests/Html/HtmlToWmlReadAsXElement.cs
index 9a2e2c85..930da5e8 100644
--- a/OpenXmlPowerTools.Tests/Html/HtmlToWmlReadAsXElement.cs
+++ b/OpenXmlPowerTools.Tests/Html/HtmlToWmlReadAsXElement.cs
@@ -63,7 +63,7 @@ public static XElement ReadAsXElement(FileInfo sourceHtmlFi)
html = XElement.Parse(sb.ToString());
}
#else
- catch (XmlException e)
+ catch (XmlException)
{
throw;
}
diff --git a/OpenXmlPowerTools.Tests/Word/DocumentAssemblerTests.cs b/OpenXmlPowerTools.Tests/Word/DocumentAssemblerTests.cs
index f0241bf0..49387d26 100644
--- a/OpenXmlPowerTools.Tests/Word/DocumentAssemblerTests.cs
+++ b/OpenXmlPowerTools.Tests/Word/DocumentAssemblerTests.cs
@@ -118,7 +118,44 @@ public DocumentAssemblerTests(ITestOutputHelper log) : base(log)
[InlineData("DA264-InvalidRunLevelRepeat.docx", "DA-Data.xml", true)]
[InlineData("DA265-RunLevelRepeatWithWhiteSpaceBefore.docx", "DA-Data.xml", false)]
[InlineData("DA266-RunLevelRepeat-NoData.docx", "DA-Data.xml", true)]
-
+ [InlineData("DA267-Repeat-HorizontalAlignType.docx", "DA-Data.xml", false)]
+ [InlineData("DA268-Repeat-VerticalAlignType.docx", "DA-Data.xml", false)]
+ [InlineData("DA269-Repeat-InvalidAlignType.docx", "DA-Data.xml", true)]
+ [InlineData("DA270-ImageSelect.docx", "DA-Data-WithImages.xml", false)]
+ [InlineData("DA270A-ImageSelect.docx", "DA-Data-WithImages.xml", false)]
+ [InlineData("DA271-ImageSelectWithRepeat.docx", "DA-Data-WithImages.xml", false)]
+ [InlineData("DA271A-ImageSelectWithRepeat.docx", "DA-Data-WithImages.xml", false)]
+ [InlineData("DA272-ImageSelectWithRepeatHorizontalAlign.docx", "DA-Data-WithImages.xml", false)]
+ [InlineData("DA272A-ImageSelectWithRepeatHorizontalAlign.docx", "DA-Data-WithImages.xml", false)]
+ [InlineData("DA273-ImageSelectInsideTextBoxWithRepeatVerticalAlign.docx", "DA-Data-WithImages.xml", false)]
+ [InlineData("DA273A-ImageSelectInsideTextBoxWithRepeatVerticalAlign.docx", "DA-Data-WithImages.xml", false)]
+ [InlineData("DA274-ImageSelectInsideTextBoxWithRepeatHorizontalAlign.docx", "DA-Data-WithImages.xml", false)]
+ [InlineData("DA274A-ImageSelectInsideTextBoxWithRepeatHorizontalAlign.docx", "DA-Data-WithImages.xml", false)]
+ [InlineData("DA275-ImageSelectWithRepeatInvalidAlign.docx", "DA-Data-WithImages.xml", true)]
+ [InlineData("DA275A-ImageSelectWithRepeatInvalidAlign.docx", "DA-Data-WithImages.xml", true)]
+ [InlineData("DA276-ImageSelectInsideTable.docx", "DA-Data-WithImages.xml", false)]
+ [InlineData("DA276A-ImageSelectInsideTable.docx", "DA-Data-WithImages.xml", false)]
+ [InlineData("DA277-ImageSelectMissingOrInvalidPictureContent.docx", "DA-Data-WithImages.xml", true)]
+ [InlineData("DA277A-ImageSelectMissingOrInvalidPictureContent.docx", "DA-Data-WithImages.xml", true)]
+ [InlineData("DA278-ImageSelect.docx", "DA-Data-WithImagesInvalidPath.xml", true)]
+ [InlineData("DA278A-ImageSelect.docx", "DA-Data-WithImagesInvalidPath.xml", true)]
+ [InlineData("DA279-ImageSelectWithRepeat.docx", "DA-Data-WithImagesInvalidMIMEType.xml", true)]
+ [InlineData("DA279A-ImageSelectWithRepeat.docx", "DA-Data-WithImagesInvalidMIMEType.xml", true)]
+ [InlineData("DA280-ImageSelectWithRepeat.docx", "DA-Data-WithImagesInvalidImageDataFormat.xml", true)]
+ [InlineData("DA280A-ImageSelectWithRepeat.docx", "DA-Data-WithImagesInvalidImageDataFormat.xml", true)]
+ [InlineData("DA281-ImageSelectExtraWhitespaceBeforeImageContent.docx", "DA-Data-WithImages.xml", true)]
+ [InlineData("DA281A-ImageSelectExtraWhitespaceBeforeImageContent.docx", "DA-Data-WithImages.xml", true)]
+ [InlineData("DA282-ImageSelectWithHeader.docx", "DA-Data-WithImages.xml", false)]
+ [InlineData("DA282A-ImageSelectWithHeader.docx", "DA-Data-WithImages.xml", false)]
+ [InlineData("DA282-ImageSelectWithHeader.docx", "DA-Data-WithImagesInvalidPath.xml", true)]
+ [InlineData("DA282A-ImageSelectWithHeader.docx", "DA-Data-WithImagesInvalidPath.xml", true)]
+ [InlineData("DA283-ImageSelectWithFooter.docx", "DA-Data-WithImages.xml", false)]
+ [InlineData("DA283A-ImageSelectWithFooter.docx", "DA-Data-WithImages.xml", false)]
+ [InlineData("DA284-ImageSelectWithHeaderAndFooter.docx", "DA-Data-WithImages.xml", false)]
+ [InlineData("DA284A-ImageSelectWithHeaderAndFooter.docx", "DA-Data-WithImages.xml", false)]
+ [InlineData("DA285-ImageSelectNoParagraphFollowedAfterMetadata.docx", "DA-Data-WithImages.xml", true)]
+ [InlineData("DA285A-ImageSelectNoParagraphFollowedAfterMetadata.docx", "DA-Data-WithImages.xml", true)]
+
public void DA101(string name, string data, bool err)
{
var templateDocx = new FileInfo(Path.Combine(_sourceDir.FullName, name));
diff --git a/OpenXmlPowerTools/Word/DocumentAssembler.cs b/OpenXmlPowerTools/Word/DocumentAssembler.cs
index f766ce7a..a688e88e 100644
--- a/OpenXmlPowerTools/Word/DocumentAssembler.cs
+++ b/OpenXmlPowerTools/Word/DocumentAssembler.cs
@@ -15,46 +15,75 @@
using DocumentFormat.OpenXml.Packaging;
using Clippit;
using System.Collections;
+using DocumentFormat.OpenXml.Drawing.Wordprocessing;
+using Path = System.IO.Path;
namespace Clippit.Word
{
- public class DocumentAssembler
+ public static class DocumentAssembler
{
public static WmlDocument AssembleDocument(WmlDocument templateDoc, XmlDocument data, out bool templateError)
{
- XDocument xDoc = data.GetXDocument();
+ var xDoc = data.GetXDocument();
return AssembleDocument(templateDoc, xDoc.Root, out templateError);
}
public static WmlDocument AssembleDocument(WmlDocument templateDoc, XElement data, out bool templateError)
{
- byte[] byteArray = templateDoc.DocumentByteArray;
- using (MemoryStream mem = new MemoryStream())
+ var byteArray = templateDoc.DocumentByteArray;
+ using var mem = new MemoryStream();
+ mem.Write(byteArray, 0, (int)byteArray.Length);
+
+ using (var wordDoc = WordprocessingDocument.Open(mem, true))
{
- mem.Write(byteArray, 0, (int)byteArray.Length);
- using (WordprocessingDocument wordDoc = WordprocessingDocument.Open(mem, true))
- {
- if (RevisionAccepter.HasTrackedRevisions(wordDoc))
- throw new OpenXmlPowerToolsException("Invalid DocumentAssembler template - contains tracked revisions");
+ if (RevisionAccepter.HasTrackedRevisions(wordDoc))
+ throw new OpenXmlPowerToolsException("Invalid DocumentAssembler template - contains tracked revisions");
- var te = new TemplateError();
- foreach (var part in wordDoc.ContentParts())
- {
- ProcessTemplatePart(data, te, part);
- }
- templateError = te.HasError;
+ // calculate and store the max docPr id for later use when adding image objects
+ var macDocPrId = GetMaxDocPrId(wordDoc);
+
+ var te = new TemplateError();
+ foreach (var part in wordDoc.ContentParts())
+ {
+ ProcessTemplatePart(data, te, part);
}
- WmlDocument assembledDocument = new WmlDocument("TempFileName.docx", mem.ToArray());
- return assembledDocument;
+ templateError = te.HasError;
+
+ // update image docPr ids for the whole document
+ FixUpDocPrIds(wordDoc, macDocPrId);
}
+
+ var assembledDocument = new WmlDocument("TempFileName.docx", mem.ToArray());
+ return assembledDocument;
}
private static void ProcessTemplatePart(XElement data, TemplateError te, OpenXmlPart part)
{
- XDocument xDoc = part.GetXDocument();
+ var xDoc = part.GetXDocument();
var xDocRoot = RemoveGoBackBookmarks(xDoc.Root);
+ // process diagrams part
+ // TODO: consider splitting this method into two for clarity, so, for example, there will be
+ // TODO: pipeline-like processing: first the diagram, then the document part, or vice versa
+ var diagramPart = part.GetPartsOfType().FirstOrDefault();
+ if (diagramPart != null)
+ {
+ var diagramDoc = diagramPart.GetXDocument();
+ if (diagramDoc != null)
+ {
+ var dataPartRoot = diagramDoc.Root;
+ if (dataPartRoot != null)
+ {
+ dataPartRoot = (XElement)TransformToMetadata(dataPartRoot, data, te);
+ // do the actual content replacement
+ dataPartRoot = (XElement)ContentReplacementTransform(dataPartRoot, data, te, part);
+ diagramDoc.Elements().First().ReplaceWith(dataPartRoot);
+ diagramPart.PutXDocument();
+ }
+ }
+ }
+
// content controls in cells can surround the W.tc element, so transform so that such content controls are within the cell content
xDocRoot = (XElement)NormalizeContentControlsInCells(xDocRoot);
@@ -72,7 +101,7 @@ private static void ProcessTemplatePart(XElement data, TemplateError te, OpenXml
ProcessOrphanEndRepeatEndConditional(xDocRoot, te);
// do the actual content replacement
- xDocRoot = (XElement)ContentReplacementTransform(xDocRoot, data, te);
+ xDocRoot = (XElement)ContentReplacementTransform(xDocRoot, data, te, part);
xDoc.Elements().First().ReplaceWith(xDocRoot);
part.PutXDocument();
@@ -85,12 +114,12 @@ private static void ProcessTemplatePart(XElement data, TemplateError te, OpenXml
PA.Repeat,
PA.EndRepeat,
PA.Table,
+ PA.Image
};
private static object ForceBlockLevelAsAppropriate(XNode node, TemplateError te)
{
- XElement element = node as XElement;
- if (element != null)
+ if (node is XElement element)
{
if (element.Name == W.p)
{
@@ -102,7 +131,7 @@ private static object ForceBlockLevelAsAppropriate(XNode node, TemplateError te)
if (otherTextInParagraph != "")
{
var newPara = new XElement(element);
- var newMeta = newPara.Elements().Where(n => s_MetaToForceToBlock.Contains(n.Name)).First();
+ var newMeta = newPara.Elements().First(n => s_MetaToForceToBlock.Contains(n.Name));
newMeta.ReplaceWith(CreateRunErrorMessage("Error: Unmatched metadata can't be in paragraph with other text", te));
return newPara;
}
@@ -117,9 +146,9 @@ private static object ForceBlockLevelAsAppropriate(XNode node, TemplateError te)
var count = childMeta.Count();
if (count % 2 == 0)
{
- if (childMeta.Where(c => c.Name == PA.Repeat).Count() != childMeta.Where(c => c.Name == PA.EndRepeat).Count())
+ if (childMeta.Count(c => c.Name == PA.Repeat) != childMeta.Count(c => c.Name == PA.EndRepeat))
return CreateContextErrorMessage(element, "Error: Mismatch Repeat / EndRepeat at run level", te);
- if (childMeta.Where(c => c.Name == PA.Conditional).Count() != childMeta.Where(c => c.Name == PA.EndConditional).Count())
+ if (childMeta.Count(c => c.Name == PA.Conditional) != childMeta.Count(c => c.Name == PA.EndConditional))
return CreateContextErrorMessage(element, "Error: Mismatch Conditional / EndConditional at run level", te);
return new XElement(element.Name,
element.Attributes(),
@@ -157,7 +186,7 @@ private static XElement RemoveGoBackBookmarks(XElement xElement)
while (true)
{
var bm = cloneXDoc.DescendantsAndSelf(W.bookmarkStart).FirstOrDefault(b => (string)b.Attribute(W.name) == "_GoBack");
- if (bm == null)
+ if (bm is null)
break;
var id = (string)bm.Attribute(W.id);
var endBm = cloneXDoc.DescendantsAndSelf(W.bookmarkEnd).FirstOrDefault(b => (string)b.Attribute(W.id) == id);
@@ -171,8 +200,7 @@ private static XElement RemoveGoBackBookmarks(XElement xElement)
// the content control, which contains the paragraph content of the cell.
private static object NormalizeContentControlsInCells(XNode node)
{
- XElement element = node as XElement;
- if (element != null)
+ if (node is XElement element)
{
if (element.Name == W.sdt && element.Parent.Name == W.tr)
{
@@ -187,7 +215,7 @@ private static object NormalizeContentControlsInCells(XNode node)
}
return new XElement(element.Name,
element.Attributes(),
- element.Nodes().Select(n => NormalizeContentControlsInCells(n)));
+ element.Nodes().Select(NormalizeContentControlsInCells));
}
return node;
}
@@ -200,7 +228,7 @@ private static void NormalizeTablesRepeatAndConditional(XElement xDoc, TemplateE
var tables = xDoc.Descendants(PA.Table).ToList();
foreach (var table in tables)
{
- var followingElement = table.ElementsAfterSelf().Where(e => e.Name == W.tbl || e.Name == W.p).FirstOrDefault();
+ var followingElement = table.ElementsAfterSelf().FirstOrDefault(e => e.Name == W.tbl || e.Name == W.p);
if (followingElement == null || followingElement.Name != W.tbl)
{
table.ReplaceWith(CreateParaErrorMessage("Table metadata is not immediately followed by a table", te));
@@ -213,6 +241,52 @@ private static void NormalizeTablesRepeatAndConditional(XElement xDoc, TemplateE
table.Add(followingElement);
}
+ var images = xDoc.Descendants(PA.Image).ToList();
+ foreach (var image in images)
+ {
+ var followingElement = image.ElementsAfterSelf().FirstOrDefault(e => e.Name == W.sdt || e.Name == W.p);
+
+ if (followingElement == null)
+ {
+ image.ReplaceWith(CreateParaErrorMessage("Image metadata is not immediately followed by an image", te));
+ continue;
+ }
+
+ // get sdt element (can also be within a paragraph) and check it's contents
+ var sdt = followingElement.Name == W.p ? followingElement.Elements().FirstOrDefault(e => e.Name == W.sdt) : followingElement;
+
+ if (sdt != null && sdt.Name == W.sdt)
+ {
+ // get sdt properties
+ var sdtPr = sdt.Elements().FirstOrDefault(e => e.Name == W.sdtPr);
+ if (sdtPr != null)
+ {
+ // check for properties if contain picture
+ var picture = sdtPr.Elements().FirstOrDefault(e => e.Name == W.picture);
+ if (picture == null)
+ {
+ image.ReplaceWith(
+ CreateParaErrorMessage("Image metadata does not contain picture element", te));
+ continue;
+ }
+ }
+ }
+ else
+ {
+ // there might be the image without surrounding content control
+ image.RemoveNodes();
+ followingElement.Remove();
+ image.Add(followingElement);
+ continue;
+ }
+
+ // remove superflous paragraph from Image metadata
+ image.RemoveNodes();
+ // detach w:sdt from parent, and add to Image metadata
+ followingElement.Remove();
+ image.Add(followingElement);
+ }
+
int repeatDepth = 0;
int conditionalDepth = 0;
foreach (var metadata in xDoc.Descendants().Where(d =>
@@ -249,8 +323,8 @@ private static void NormalizeTablesRepeatAndConditional(XElement xDoc, TemplateE
while (true)
{
- bool didReplace = false;
- foreach (var metadata in xDoc.Descendants().Where(d => (d.Name == PA.Repeat || d.Name == PA.Conditional) && d.Attribute(PA.Depth) != null).ToList())
+ var didReplace = false;
+ foreach (var metadata in xDoc.Descendants().Where(d => (d.Name == PA.Repeat || d.Name == PA.Conditional || d.Name == PA.Image) && d.Attribute(PA.Depth) != null).ToList())
{
var depth = (int)metadata.Attribute(PA.Depth);
XName matchingEndName = null;
@@ -282,8 +356,9 @@ private static void NormalizeTablesRepeatAndConditional(XElement xDoc, TemplateE
}
}
- private static List s_AliasList = new List()
+ private static List s_AliasList = new List
{
+ "Image",
"Content",
"Table",
"Repeat",
@@ -294,13 +369,12 @@ private static void NormalizeTablesRepeatAndConditional(XElement xDoc, TemplateE
private static object TransformToMetadata(XNode node, XElement data, TemplateError te)
{
- XElement element = node as XElement;
- if (element != null)
+ if (node is XElement element)
{
if (element.Name == W.sdt)
{
var alias = (string)element.Elements(W.sdtPr).Elements(W.alias).Attributes(W.val).FirstOrDefault();
- if (alias == null || alias == "" || s_AliasList.Contains(alias))
+ if (string.IsNullOrEmpty(alias) || s_AliasList.Contains(alias))
{
var ccContents = element
.DescendantsTrimmed(W.txbxContent)
@@ -312,7 +386,7 @@ private static object TransformToMetadata(XNode node, XElement data, TemplateErr
.Replace('”', '"');
if (ccContents.StartsWith("<"))
{
- XElement xml = TransformXmlTextToMetadata(te, ccContents);
+ var xml = TransformXmlTextToMetadata(te, ccContents);
if (xml.Name == W.p || xml.Name == W.r) // this means there was an error processing the XML.
{
if (element.Parent.Name == W.p)
@@ -337,6 +411,92 @@ private static object TransformToMetadata(XNode node, XElement data, TemplateErr
element.Attributes(),
element.Nodes().Select(n => TransformToMetadata(n, data, te)));
}
+ if (element.Name == A.r)
+ {
+ var paraContents = element
+ .DescendantsTrimmed(W.txbxContent)
+ .Where(e => e.Name == A.t)
+ .Select(t => (string)t)
+ .StringConcatenate()
+ .Trim();
+ int occurances = paraContents.Select((c, i) => paraContents.Substring(i)).Count(sub => sub.StartsWith("<#"));
+ if (paraContents.StartsWith("<#") && paraContents.EndsWith("#>") && occurances == 1)
+ {
+ var xmlText = paraContents.Substring(2, paraContents.Length - 4).Trim();
+ var xml = TransformXmlTextToMetadata(te, xmlText);
+ if (xml.Name == W.p || xml.Name == W.r)
+ return xml;
+ xml.Add(element);
+ return xml;
+ }
+ if (paraContents.Contains("<#"))
+ {
+ var runReplacementInfo = new List();
+ var thisGuid = Guid.NewGuid().ToString();
+ var r = new Regex("<#.*?#>");
+ XElement xml = null;
+ OpenXmlRegex.Replace(new[] { element }, r, thisGuid, (para, match) =>
+ {
+ var matchString = match.Value.Trim();
+ var xmlText = matchString.Substring(2, matchString.Length - 4).Trim().Replace('“', '"').Replace('”', '"');
+ try
+ {
+ xml = XElement.Parse(xmlText);
+ }
+ catch (XmlException e)
+ {
+ var rri = new RunReplacementInfo
+ {
+ Xml = null,
+ XmlExceptionMessage = "XmlException: " + e.Message,
+ SchemaValidationMessage = null,
+ };
+ runReplacementInfo.Add(rri);
+ return true;
+ }
+ var schemaError = ValidatePerSchema(xml);
+ if (schemaError != null)
+ {
+ var rri = new RunReplacementInfo
+ {
+ Xml = null,
+ XmlExceptionMessage = null,
+ SchemaValidationMessage = "Schema Validation Error: " + schemaError,
+ };
+ runReplacementInfo.Add(rri);
+ return true;
+ }
+ var rri2 = new RunReplacementInfo
+ {
+ Xml = xml,
+ XmlExceptionMessage = null,
+ SchemaValidationMessage = null,
+ };
+ runReplacementInfo.Add(rri2);
+ return true;
+ }, false);
+
+ var newPara = new XElement(element);
+ foreach (var rri in runReplacementInfo)
+ {
+ var runToReplace = newPara.Descendants(W.r).FirstOrDefault(rn => rn.Value == thisGuid && rn.Parent.Name != PA.Content);
+ if (runToReplace == null)
+ throw new OpenXmlPowerToolsException("Internal error");
+ if (rri.XmlExceptionMessage != null)
+ runToReplace.ReplaceWith(CreateRunErrorMessage(rri.XmlExceptionMessage, te));
+ else if (rri.SchemaValidationMessage != null)
+ runToReplace.ReplaceWith(CreateRunErrorMessage(rri.SchemaValidationMessage, te));
+ else
+ {
+ var newXml = new XElement(rri.Xml);
+ newXml.Add(runToReplace);
+ runToReplace.ReplaceWith(newXml);
+ }
+ }
+ var coalescedParagraph = WordprocessingMLUtil.CoalesceAdjacentRunsWithIdenticalFormatting(newPara);
+ return coalescedParagraph;
+ }
+ }
if (element.Name == W.p)
{
var paraContents = element
@@ -345,11 +505,11 @@ private static object TransformToMetadata(XNode node, XElement data, TemplateErr
.Select(t => (string)t)
.StringConcatenate()
.Trim();
- int occurances = paraContents.Select((c, i) => paraContents.Substring(i)).Count(sub => sub.StartsWith("<#"));
+ var occurances = paraContents.Select((c, i) => paraContents.Substring(i)).Count(sub => sub.StartsWith("<#"));
if (paraContents.StartsWith("<#") && paraContents.EndsWith("#>") && occurances == 1)
{
var xmlText = paraContents.Substring(2, paraContents.Length - 4).Trim();
- XElement xml = TransformXmlTextToMetadata(te, xmlText);
+ var xml = TransformXmlTextToMetadata(te, xmlText);
if (xml.Name == W.p || xml.Name == W.r)
return xml;
xml.Add(element);
@@ -357,7 +517,7 @@ private static object TransformToMetadata(XNode node, XElement data, TemplateErr
}
if (paraContents.Contains("<#"))
{
- List runReplacementInfo = new List();
+ var runReplacementInfo = new List();
var thisGuid = Guid.NewGuid().ToString();
var r = new Regex("<#.*?#>");
XElement xml = null;
@@ -371,7 +531,7 @@ private static object TransformToMetadata(XNode node, XElement data, TemplateErr
}
catch (XmlException e)
{
- RunReplacementInfo rri = new RunReplacementInfo()
+ var rri = new RunReplacementInfo
{
Xml = null,
XmlExceptionMessage = "XmlException: " + e.Message,
@@ -380,10 +540,10 @@ private static object TransformToMetadata(XNode node, XElement data, TemplateErr
runReplacementInfo.Add(rri);
return true;
}
- string schemaError = ValidatePerSchema(xml);
+ var schemaError = ValidatePerSchema(xml);
if (schemaError != null)
{
- RunReplacementInfo rri = new RunReplacementInfo()
+ var rri = new RunReplacementInfo
{
Xml = null,
XmlExceptionMessage = null,
@@ -392,7 +552,7 @@ private static object TransformToMetadata(XNode node, XElement data, TemplateErr
runReplacementInfo.Add(rri);
return true;
}
- RunReplacementInfo rri2 = new RunReplacementInfo()
+ var rri2 = new RunReplacementInfo
{
Xml = xml,
XmlExceptionMessage = null,
@@ -442,7 +602,7 @@ private static XElement TransformXmlTextToMetadata(TemplateError te, string xmlT
{
return CreateParaErrorMessage("XmlException: " + e.Message, te);
}
- string schemaError = ValidatePerSchema(xml);
+ var schemaError = ValidatePerSchema(xml);
if (schemaError != null)
return CreateParaErrorMessage("Schema Validation Error: " + schemaError, te);
return xml;
@@ -450,20 +610,21 @@ private static XElement TransformXmlTextToMetadata(TemplateError te, string xmlT
private class RunReplacementInfo
{
- public XElement Xml;
- public string XmlExceptionMessage;
- public string SchemaValidationMessage;
+ public XElement Xml { get; set; }
+ public string XmlExceptionMessage { get; set; }
+ public string SchemaValidationMessage { get; set; }
}
private static string ValidatePerSchema(XElement element)
{
if (s_PASchemaSets == null)
{
- s_PASchemaSets = new Dictionary()
+ s_PASchemaSets = new Dictionary
{
{
PA.Content,
- new PASchemaSet() {
+ new PASchemaSet
+ {
XsdMarkup =
@"
@@ -477,7 +638,8 @@ private static string ValidatePerSchema(XElement element)
},
{
PA.Table,
- new PASchemaSet() {
+ new PASchemaSet
+ {
XsdMarkup =
@"
@@ -490,13 +652,15 @@ private static string ValidatePerSchema(XElement element)
},
{
PA.Repeat,
- new PASchemaSet() {
+ new PASchemaSet
+ {
XsdMarkup =
@"
+
",
@@ -504,7 +668,8 @@ private static string ValidatePerSchema(XElement element)
},
{
PA.EndRepeat,
- new PASchemaSet() {
+ new PASchemaSet
+ {
XsdMarkup =
@"
@@ -513,7 +678,8 @@ private static string ValidatePerSchema(XElement element)
},
{
PA.Conditional,
- new PASchemaSet() {
+ new PASchemaSet
+ {
XsdMarkup =
@"
@@ -528,81 +694,542 @@ private static string ValidatePerSchema(XElement element)
},
{
PA.EndConditional,
- new PASchemaSet() {
+ new PASchemaSet
+ {
XsdMarkup =
@"
",
}
},
+ {
+ PA.Image,
+ new PASchemaSet
+ {
+ XsdMarkup =
+ @"
+
+
+
+
+
+ ",
+ }
+ }
};
foreach (var item in s_PASchemaSets)
{
var itemPAss = item.Value;
- XmlSchemaSet schemas = new XmlSchemaSet();
+ var schemas = new XmlSchemaSet();
schemas.Add("", XmlReader.Create(new StringReader(itemPAss.XsdMarkup)));
itemPAss.SchemaSet = schemas;
}
}
if (!s_PASchemaSets.ContainsKey(element.Name))
{
- return string.Format("Invalid XML: {0} is not a valid element", element.Name.LocalName);
+ return $"Invalid XML: {element.Name.LocalName} is not a valid element";
}
var paSchemaSet = s_PASchemaSets[element.Name];
- XDocument d = new XDocument(element);
+ var d = new XDocument(element);
string message = null;
d.Validate(paSchemaSet.SchemaSet, (sender, e) =>
{
- if (message == null)
- message = e.Message;
+ message ??= e.Message;
}, true);
- if (message != null)
- return message;
- return null;
+ return message;
}
private class PA
{
- public static XName Content = "Content";
- public static XName Table = "Table";
- public static XName Repeat = "Repeat";
- public static XName EndRepeat = "EndRepeat";
- public static XName Conditional = "Conditional";
- public static XName EndConditional = "EndConditional";
-
- public static XName Select = "Select";
- public static XName Optional = "Optional";
- public static XName Match = "Match";
- public static XName NotMatch = "NotMatch";
- public static XName Depth = "Depth";
+ public static readonly XName Image = "Image";
+ public static readonly XName Content = "Content";
+ public static readonly XName Table = "Table";
+ public static readonly XName Repeat = "Repeat";
+ public static readonly XName EndRepeat = "EndRepeat";
+ public static readonly XName Conditional = "Conditional";
+ public static readonly XName EndConditional = "EndConditional";
+
+ public static readonly XName Select = "Select";
+ public static readonly XName Optional = "Optional";
+ public static readonly XName Match = "Match";
+ public static readonly XName NotMatch = "NotMatch";
+ public static readonly XName Depth = "Depth";
+ public static readonly XName Align = "Align";
}
private class PASchemaSet
{
- public string XsdMarkup;
- public XmlSchemaSet SchemaSet;
+ public string XsdMarkup { get; set; }
+ public XmlSchemaSet SchemaSet { get; set; }
}
- private static Dictionary s_PASchemaSets = null;
+ private static Dictionary s_PASchemaSets;
private class TemplateError
{
- public bool HasError = false;
+ public bool HasError { get; set; }
+ }
+
+ ///
+ /// Gets the next image relationship identifier of given part. The
+ /// parts can be either header, footer or main document part. The method
+ /// scans for already present relationship identifiers, then increments and
+ /// returns the next available value.
+ ///
+ /// The part.
+ /// System.String.
+ private static string GetNextImageRelationshipId(OpenXmlPart part)
+ {
+ if (part is MainDocumentPart mainDocumentPart)
+ {
+ var imageId = mainDocumentPart.Parts
+ .Select(p => Regex.Match(p.RelationshipId, @"rId(?\d+)").Groups["rId"].Value)
+ .Max(Convert.ToDecimal);
+
+ return $"rId{++imageId}";
+ }
+
+ if (part is HeaderPart headerPart)
+ {
+ var imageId = headerPart.Parts
+ .Select(p => Regex.Match(p.RelationshipId, @"rId(?\d+)").Groups["rId"].Value)
+ .Max(Convert.ToDecimal);
+
+ return $"rId{++imageId}";
+ }
+
+ if (part is FooterPart footerPart)
+ {
+ var imageId = footerPart.Parts
+ .Select(p => Regex.Match(p.RelationshipId, @"rId(?\d+)").Groups["rId"].Value)
+ .Max(Convert.ToDecimal);
+
+ return $"rId{++imageId}";
+ }
+
+ return null;
+ }
+
+ ///
+ /// Calculates the maximum docPr id. The identifier is
+ /// unique throughout the document. This method
+ /// scans the whole document, finds and stores the max number (id is signed
+ /// 23 bit integer).
+ ///
+ /// The word document.
+ /// System.Decimal.
+ private static decimal GetMaxDocPrId(WordprocessingDocument wordDoc)
+ {
+ var idsList = new List();
+ foreach (var part in wordDoc.ContentParts())
+ {
+ idsList.AddRange(part.GetXDocument().Descendants(WP.docPr)
+ .SelectMany(e => e.Attributes().Where(a => a.Name == NoNamespace.id)).Select(v => v.Value));
+ }
+ return idsList.Count == 0 ? 0 : idsList.Max(Convert.ToDecimal);
+ }
+
+ private const string InvalidImageId = "InvalidImageId";
+
+ ///
+ /// Fixes docPrIds for the document. The identifier is unique throughout the
+ /// document. This method scans the whole document, finds and replaces the
+ /// image ids which were marked as invalid with incremental id
+ /// (id is signed 23 bit integer).
+ ///
+ /// The word processing document.
+ /// The current maximum document pr identifier calculated
+ /// before the document has been processed.
+ private static void FixUpDocPrIds(WordprocessingDocument wDoc, decimal maxDocPrId)
+ {
+ var elementToFind = WP.docPr;
+ var docPrToChange = wDoc
+ .ContentParts()
+ .Select(cp => cp.GetXDocument())
+ .Select(xd => xd.Descendants().Where(d => d.Name == elementToFind))
+ .SelectMany(m => m);
+ var nextId = maxDocPrId;
+ foreach (var item in docPrToChange)
+ {
+ var idAtt = item.Attribute(NoNamespace.id);
+ if (idAtt != null && idAtt.Value == InvalidImageId)
+ idAtt.Value = $"{++nextId}";
+ }
+ foreach (var cp in wDoc.ContentParts())
+ cp.PutXDocument();
+ }
+
+ // shape type identifier
+ private static int s_shapeTypeId = 1;
+ private static int GetNextShapeType() => s_shapeTypeId++;
+
+ // shape identifier
+ private static int s_shapeId = 2000;
+ private static string GetNextShapeId() => $"_x0000_s{s_shapeId++}";
+
+ ///
+ /// Creates and returns the image part inside the given part. The
+ /// part can be either header, footer or main document part.
+ ///
+ /// The part.
+ /// Type of the image part.
+ /// The relationship identifier.
+ /// ImagePart.
+ private static ImagePart GetImagePart(OpenXmlPart part, ImagePartType imagePartType, string relationshipId)
+ {
+ if (part is MainDocumentPart mainDocumentPart)
+ return mainDocumentPart.AddImagePart(imagePartType, relationshipId);
+
+ if (part is HeaderPart headerPart)
+ return headerPart.AddImagePart(imagePartType, relationshipId);
+
+ if (part is FooterPart footerPart)
+ return footerPart.AddImagePart(imagePartType, relationshipId);
+
+ return null;
+ }
+
+ ///
+ /// Method processes the image content and generates image element
+ ///
+ /// Source element
+ /// Data element with content
+ /// Error indicator
+ /// The part where the image is getting processed.
+ /// Image element
+ private static object ProcessImageContent(XElement element, XElement data, TemplateError templateError, OpenXmlPart part)
+ {
+ // check for misplaced sdt content, should contain the paragraph and not vice versa
+ var sdt = element.Descendants(W.sdt).FirstOrDefault();
+ // get the original element with all the formatting
+ var orig = sdt == null ? element.Descendants(W.p).FirstOrDefault() : sdt.Descendants(W.p).FirstOrDefault();
+
+ // check for first run having image element in it
+ if (orig == null || !orig.Descendants(W.r).FirstOrDefault().Descendants(W.drawing).Any())
+ {
+ return CreateContextErrorMessage(element, "Image metadata is not immediately followed by an image", templateError);
+ }
+
+ // clone the paragraph, so repeating elements won't be overridden
+ var para = new XElement(orig);
+
+ // get the xpath of of the element
+ var xPath = (string)element.Attribute(PA.Select);
+ // get image path
+ var imagePath = EvaluateXPathToString(data, xPath, false);
+
+ // assign unique image and paragraph ids. Image id is document property Id (wp:docPr)
+ // and relationship id is rId. Their numbering is different.
+ const string imageId = InvalidImageId; // Ids will be replaced with real ones later, after transform is done
+ var relationshipId = GetNextImageRelationshipId(part);
+
+ var inline =
+ para.Descendants(W.drawing)
+ .Descendants(WP.inline).FirstOrDefault();
+ if (inline == null)
+ {
+ return CreateContextErrorMessage(element, "Image: invalid picture control", templateError);
+ }
+
+ // get aspect ratio option
+ var ratioAttr = inline
+ .Descendants(WP.cNvGraphicFramePr)
+ .Descendants(A.graphicFrameLocks).FirstOrDefault().Attribute(NoNamespace.noChangeAspect);
+
+ var keepSourceImageAspect = (ratioAttr == null);
+ var keepOriginalImageSizeElement = inline.Descendants(Pic.cNvPicPr).FirstOrDefault();
+ var keepOriginalImageSize = false;
+
+ if (keepOriginalImageSizeElement != null)
+ {
+ var attr = keepOriginalImageSizeElement.Attribute("preferRelativeResize");
+ if (attr != null)
+ {
+ keepOriginalImageSize = attr.Value == "0";
+ }
+ }
+
+ // get extent
+ var extent = inline
+ .Descendants(WP.extent)
+ .FirstOrDefault();
+ var pictureExtent = inline
+ .Descendants(A.graphic)
+ .Descendants(A.graphicData)
+ .Descendants(Pic._pic)
+ .Descendants(Pic.spPr)
+ .Descendants(A.xfrm)
+ .Descendants(A.ext).
+ FirstOrDefault();
+
+ if (extent == null || pictureExtent == null)
+ {
+ return CreateContextErrorMessage(element, "Image: missing element in picture control - extent(s)", templateError);
+ }
+
+ // get docPr
+ var docPr = inline.Descendants(WP.docPr).FirstOrDefault();
+ if (docPr == null)
+ {
+ return CreateContextErrorMessage(element, "Image: missing element in picture control - docPtr", templateError);
+ }
+
+ docPr.SetAttributeValue(NoNamespace.id, imageId);
+ docPr.SetAttributeValue(NoNamespace.name, "Templated Image Content");
+
+ var blip = inline
+ .Descendants(A.graphic)
+ .Descendants(A.graphicData)
+ .Descendants(Pic.blipFill)
+ .Descendants(A.blip)
+ .FirstOrDefault();
+
+ if (blip != null)
+ {
+ // Add the image to main document part
+ var stream = Image2Stream(imagePath, out var imagePartType, out var error);
+ if (stream != null)
+ {
+ var ip = GetImagePart(part, imagePartType, relationshipId);
+
+ if (ip == null)
+ {
+ error = "Failed to get image part";
+ return CreateContextErrorMessage(element, string.Concat("Image: ", error), templateError);
+ }
+ ip.FeedData(stream);
+ stream.Close();
+
+ // access the saved image and get the dimensions
+ using (var savedStream = ip.GetStream(FileMode.Open))
+ using (var image = System.Drawing.Image.FromStream(savedStream))
+ {
+ // one inch is 914400 EMUs
+ // 96dpi where dot is pixel
+ var pixelInEMU = 914400 / 96;
+ var width = image.Width;
+ var height = image.Height;
+
+ if (keepSourceImageAspect)
+ {
+ var ratio = height / (width * 1.0);
+ if (!int.TryParse(extent.Attribute(NoNamespace.cx).Value, out width))
+ {
+ return CreateContextErrorMessage(element, "Image: Invalid image attributes",
+ templateError);
+ }
+ height = (int)(width * ratio);
+
+ // replace attributes
+ extent.SetAttributeValue(NoNamespace.cy, height);
+ pictureExtent.SetAttributeValue(NoNamespace.cx, width);
+ pictureExtent.SetAttributeValue(NoNamespace.cy, height);
+ }
+
+ if (keepOriginalImageSize)
+ {
+ width = image.Width * pixelInEMU;
+ height = image.Height * pixelInEMU;
+
+ // replace attributes
+ extent.SetAttributeValue(NoNamespace.cx, width);
+ extent.SetAttributeValue(NoNamespace.cy, height);
+ pictureExtent.SetAttributeValue(NoNamespace.cx, width);
+ pictureExtent.SetAttributeValue(NoNamespace.cy, height);
+ }
+ }
+ }
+ else
+ {
+ return CreateContextErrorMessage(element, string.Concat("Image: ", error), templateError);
+ }
+
+ blip.SetAttributeValue(R.embed, relationshipId);
+ }
+
+ return para;
+ }
+
+ ///
+ /// Determines whether the input image is base64 encoded string or path
+ ///
+ /// Input image (either image path or base64 encoded string). Base 64 encoded string
+ /// should start with MIME data type identifier followed by raw data. Example:
+ /// data:image/jpg;base64,/9j/4AAQSkZJRgAB...
+ /// Image Part Type to be embedded in the document and to be
+ /// referenced by image control
+ /// Error message
+ private static Stream Image2Stream(string inputImage, out ImagePartType imagePartType, out string error)
+ {
+ string imageType;
+ Stream stream;
+ if (inputImage.StartsWith("data:image"))
+ {
+ // assume the image is base64 encoded format. See https://en.wikipedia.org/wiki/Data_URI_scheme
+
+ // get the image type and data
+ imageType = Regex.Match(inputImage, @"data:image/(?.+?);").Groups["type"].Value;
+ var base64Data = Regex.Match(inputImage, @"data:image/(?.+?),(?.+)").Groups["data"].Value;
+
+ try
+ {
+ var imageBytes = Base64.ConvertFromBase64(string.Empty, base64Data);
+
+ stream = new MemoryStream(imageBytes, 0, imageBytes.Length);
+ }
+ catch (Exception)
+ {
+ imagePartType = default(ImagePartType);
+ error = "Invalid Image data format";
+ return null;
+ }
+ }
+ else
+ {
+ // assume this is path fo file, so get the extension
+ imageType = Path.GetExtension(inputImage).Trim('.');
+
+ try
+ {
+ stream = File.Open(inputImage, FileMode.Open);
+ }
+ catch
+ {
+ imagePartType = default;
+ error = "Invalid Image path";
+ return null;
+ }
+ }
+
+ switch (imageType)
+ {
+ case "jpg":
+ case "jpeg":
+ imagePartType = ImagePartType.Jpeg;
+ break;
+ case "png":
+ imagePartType = ImagePartType.Png;
+ break;
+ case "tif":
+ case "tiff":
+ imagePartType = ImagePartType.Tiff;
+ break;
+ case "bmp":
+ imagePartType = ImagePartType.Bmp;
+ break;
+ default:
+ imagePartType = default;
+ error = "Invalid image type";
+ return null;
+ }
+
+ error = string.Empty;
+ return stream;
+ }
+
+ ///
+ /// Method processes internal paragraphs (marked with a prefix)
+ ///
+ /// Source element
+ /// Data element with content
+ /// Error indicator
+ /// Processed element
+ private static object ProcessAParagraph(XElement element, XElement data, TemplateError templateError)
+ {
+ var para = element.Descendants(A.r).FirstOrDefault();
+
+ var xPath = (string)element.Attribute(PA.Select);
+ var optionalString = (string)element.Attribute(PA.Optional);
+ var optional = (optionalString != null && optionalString.ToLower() == "true");
+
+ string newValue;
+ try
+ {
+ newValue = EvaluateXPathToString(data, xPath, optional);
+ }
+ catch (XPathException e)
+ {
+ return CreateContextErrorMessage(element, "XPathException: " + e.Message, templateError);
+ }
+
+ if (para != null)
+ {
+ var p = new XElement(A.r, para.Elements(A.rPr));
+ foreach (var line in newValue.Split('\n'))
+ {
+ p.Add(new XElement(A.t,
+ para.Elements(A.t).Elements(A.rPr).FirstOrDefault(),
+ line));
+ }
+ return p;
+ }
+
+ return null;
}
- static object ContentReplacementTransform(XNode node, XElement data, TemplateError templateError)
+ static object ContentReplacementTransform(XNode node, XElement data, TemplateError templateError, OpenXmlPart part)
{
- XElement element = node as XElement;
- if (element != null)
+ if (node is XElement element)
{
+ // TODO: need to figure out potentially better place for handling Alternate Content
+ if (element.Name == MC.AlternateContent)
+ {
+ // assign new DrawingML object id (for repeated content)
+ var docProperties = element
+ .Descendants(W.drawing)
+ .Descendants(WP.docPr)
+ .FirstOrDefault();
+ docProperties?.SetAttributeValue(NoNamespace.id, InvalidImageId);
+
+ // get the fallback picture element
+ var picture = element
+ .Descendants(MC.Fallback)
+ .Descendants(W.pict)
+ .FirstOrDefault();
+ if (picture != null)
+ {
+ // get the shape type element (it's okay not to have it,
+ // as the shape might use the type defined previously and left
+ // in other shape after copy-paste operation in the editor)
+ var shapeType = picture.Descendants(VML.shapetype).FirstOrDefault();
+ var shape = picture.Descendants(VML.shape).FirstOrDefault();
+
+ if (shape != null)
+ {
+ shape.SetAttributeValue(NoNamespace.id, GetNextShapeId());
+
+ if (shapeType != null)
+ {
+ // get next available shape type
+ var spt = GetNextShapeType();
+ var shapeTypeId = string.Format("_x0000_t{0}", spt);
+
+ // replace the attribute in shape type and in the corresponding shapes
+ shapeType.SetAttributeValue(O.spt, string.Format("{0}", spt));
+ shapeType.SetAttributeValue(NoNamespace.id, shapeTypeId);
+
+ shape.SetAttributeValue(NoNamespace.type, string.Format("#{0}", shapeTypeId));
+ }
+ }
+ }
+ }
+ if (element.Name == PA.Image)
+ {
+ return ProcessImageContent(element, data, templateError, part);
+ }
if (element.Name == PA.Content)
{
- XElement para = element.Descendants(W.p).FirstOrDefault();
- XElement run = element.Descendants(W.r).FirstOrDefault();
+ if (element.Descendants(A.r).FirstOrDefault() != null)
+ {
+ return ProcessAParagraph(element, data, templateError);
+ }
+
+ var para = element.Descendants(W.p).FirstOrDefault();
+ var run = element.Descendants(W.r).FirstOrDefault();
var xPath = (string) element.Attribute(PA.Select);
var optionalString = (string) element.Attribute(PA.Optional);
- bool optional = (optionalString != null && optionalString.ToLower() == "true");
+ var optional = (optionalString != null && optionalString.ToLower() == "true");
string newValue;
try
@@ -617,7 +1244,7 @@ static object ContentReplacementTransform(XNode node, XElement data, TemplateErr
if (para != null)
{
- XElement p = new XElement(W.p, para.Elements(W.pPr));
+ var p = new XElement(W.p, para.Elements(W.pPr));
foreach(string line in newValue.Split('\n'))
{
p.Add(new XElement(W.r,
@@ -629,8 +1256,8 @@ static object ContentReplacementTransform(XNode node, XElement data, TemplateErr
}
else
{
- List list = new List();
- foreach(string line in newValue.Split('\n'))
+ var list = new List();
+ foreach(var line in newValue.Split('\n'))
{
list.Add(new XElement(W.r,
run.Elements().Where(e => e.Name != W.t),
@@ -642,9 +1269,10 @@ static object ContentReplacementTransform(XNode node, XElement data, TemplateErr
}
if (element.Name == PA.Repeat)
{
- string selector = (string)element.Attribute(PA.Select);
+ var selector = (string)element.Attribute(PA.Select);
var optionalString = (string)element.Attribute(PA.Optional);
- bool optional = (optionalString != null && optionalString.ToLower() == "true");
+ var optional = (optionalString != null && optionalString.ToLower() == "true");
+ var alignmentOption = (string)element.Attribute(PA.Align) ?? "vertical";
IEnumerable repeatingData;
try
@@ -672,12 +1300,32 @@ static object ContentReplacementTransform(XNode node, XElement data, TemplateErr
{
var content = element
.Elements()
- .Select(e => ContentReplacementTransform(e, d, templateError))
+ .Select(e => ContentReplacementTransform(e, d, templateError, part))
.ToList();
return content;
})
.ToList();
- return newContent;
+ switch (alignmentOption.ToLower())
+ {
+ case "horizontal":
+ // keep the properties of first paragraph
+ var pPr = new XElement(W.p, newContent.First())
+ .Elements(W.p)
+ .FirstOrDefault()
+ .Elements(W.pPr)
+ .FirstOrDefault();
+ // create runs from repeated content
+ var runs = newContent.Select(x =>
+ {
+ var run = new XElement(W.p, x);
+ return run.Descendants(W.r).FirstOrDefault();
+ });
+ return pPr == null ? new XElement(W.p, runs) : new XElement(W.p, pPr, runs);
+ case "vertical":
+ return newContent;
+ default:
+ return CreateContextErrorMessage(element, "Repeat: Invalid Align option", templateError);
+ }
}
if (element.Name == PA.Table)
{
@@ -690,22 +1338,22 @@ static object ContentReplacementTransform(XNode node, XElement data, TemplateErr
{
return CreateContextErrorMessage(element, "XPathException: " + e.Message, templateError);
}
- if (tableData.Count() == 0)
+ if (!tableData.Any())
return CreateContextErrorMessage(element, "Table Select returned no data", templateError);
- XElement table = element.Element(W.tbl);
- XElement protoRow = table.Elements(W.tr).Skip(1).FirstOrDefault();
+ var table = element.Element(W.tbl);
+ var protoRow = table.Elements(W.tr).Skip(1).FirstOrDefault();
var footerRowsBeforeTransform = table
.Elements(W.tr)
.Skip(2)
.ToList();
var footerRows = footerRowsBeforeTransform
- .Select(x => ContentReplacementTransform(x, data, templateError))
+ .Select(x => ContentReplacementTransform(x, data, templateError, part))
.ToList();
if (protoRow == null)
return CreateContextErrorMessage(element, string.Format("Table does not contain a prototype row"), templateError);
protoRow.Descendants(W.bookmarkStart).Remove();
protoRow.Descendants(W.bookmarkEnd).Remove();
- XElement newTable = new XElement(W.tbl,
+ var newTable = new XElement(W.tbl,
table.Elements().Where(e => e.Name != W.tr),
table.Elements(W.tr).FirstOrDefault(),
tableData.Select(d =>
@@ -715,16 +1363,30 @@ static object ContentReplacementTransform(XNode node, XElement data, TemplateErr
.Select(tc =>
{
XElement paragraph = tc.Elements(W.p).FirstOrDefault();
- XElement cellRun = paragraph.Elements(W.r).FirstOrDefault();
- string xPath = paragraph.Value;
- string newValue = null;
+
+ // TODO: to check for other types (if needed, of course). Also, would be nice to refactor it, say, with
+ // TODO: different condition, for example, with switch case which checks the type of content.
+ if (paragraph == null)
+ {
+ // check if this is emebedded image
+ var image = tc.Elements(PA.Image).FirstOrDefault();
+ if (image != null)
+ {
+ // has to be wrapped as table cell element, since we are re-formatting the table
+ return new XElement(W.tc, ProcessImageContent(image, d, templateError, part));
+ }
+ }
+
+ var cellRun = paragraph.Elements(W.r).FirstOrDefault();
+ var xPath = paragraph.Value;
+ string newValue;
try
{
newValue = EvaluateXPathToString(d, xPath, false);
}
catch (XPathException e)
{
- XElement errorCell = new XElement(W.tc,
+ var errorCell = new XElement(W.tc,
tc.Elements().Where(z => z.Name != W.p),
new XElement(W.p,
paragraph.Element(W.pPr),
@@ -732,7 +1394,7 @@ static object ContentReplacementTransform(XNode node, XElement data, TemplateErr
return errorCell;
}
- XElement newCell = new XElement(W.tc,
+ var newCell = new XElement(W.tc,
tc.Elements().Where(z => z.Name != W.p),
new XElement(W.p,
paragraph.Element(W.pPr),
@@ -747,7 +1409,7 @@ static object ContentReplacementTransform(XNode node, XElement data, TemplateErr
}
if (element.Name == PA.Conditional)
{
- string xPath = (string)element.Attribute(PA.Select);
+ var xPath = (string)element.Attribute(PA.Select);
var match = (string)element.Attribute(PA.Match);
var notMatch = (string)element.Attribute(PA.NotMatch);
@@ -756,8 +1418,7 @@ static object ContentReplacementTransform(XNode node, XElement data, TemplateErr
if (match != null && notMatch != null)
return CreateContextErrorMessage(element, "Conditional: Cannot specify both Match and NotMatch", templateError);
- string testValue = null;
-
+ string testValue;
try
{
testValue = EvaluateXPathToString(data, xPath, false);
@@ -769,27 +1430,24 @@ static object ContentReplacementTransform(XNode node, XElement data, TemplateErr
if ((match != null && testValue == match) || (notMatch != null && testValue != notMatch))
{
- var content = element.Elements().Select(e => ContentReplacementTransform(e, data, templateError));
+ var content = element.Elements().Select(e => ContentReplacementTransform(e, data, templateError, part));
return content;
}
return null;
}
return new XElement(element.Name,
element.Attributes(),
- element.Nodes().Select(n => ContentReplacementTransform(n, data, templateError)));
+ element.Nodes().Select(n => ContentReplacementTransform(n, data, templateError, part)));
}
return node;
}
private static object CreateContextErrorMessage(XElement element, string errorMessage, TemplateError templateError)
{
- XElement para = element.Descendants(W.p).FirstOrDefault();
- XElement run = element.Descendants(W.r).FirstOrDefault();
+ var para = element.Descendants(W.p).FirstOrDefault();
+ var run = element.Descendants(W.r).FirstOrDefault();
var errorRun = CreateRunErrorMessage(errorMessage, templateError);
- if (para != null)
- return new XElement(W.p, errorRun);
- else
- return errorRun;
+ return para != null ? new XElement(W.p, errorRun) : errorRun;
}
private static XElement CreateRunErrorMessage(string errorMessage, TemplateError templateError)
@@ -821,7 +1479,7 @@ private static string EvaluateXPathToString(XElement element, string xPath, bool
try
{
//support some cells in the table may not have an xpath expression.
- if (String.IsNullOrWhiteSpace(xPath)) return String.Empty;
+ if (string.IsNullOrWhiteSpace(xPath)) return string.Empty;
xPathSelectResult = element.XPathEvaluate(xPath);
}
@@ -830,28 +1488,29 @@ private static string EvaluateXPathToString(XElement element, string xPath, bool
throw new XPathException("XPathException: " + e.Message, e);
}
- if ((xPathSelectResult is IEnumerable) && !(xPathSelectResult is string))
+ if (xPathSelectResult is IEnumerable enumerable and not string)
{
- var selectedData = ((IEnumerable) xPathSelectResult).Cast();
+ var selectedData = enumerable.Cast();
if (!selectedData.Any())
{
if (optional) return string.Empty;
- throw new XPathException(string.Format("XPath expression ({0}) returned no results", xPath));
+ throw new XPathException($"XPath expression ({xPath}) returned no results");
}
if (selectedData.Count() > 1)
{
- throw new XPathException(string.Format("XPath expression ({0}) returned more than one node", xPath));
+ throw new XPathException($"XPath expression ({xPath}) returned more than one node");
}
- XObject selectedDatum = selectedData.First();
-
- if (selectedDatum is XElement) return ((XElement) selectedDatum).Value;
-
- if (selectedDatum is XAttribute) return ((XAttribute) selectedDatum).Value;
+ switch (selectedData.First())
+ {
+ case XElement xElement:
+ return xElement.Value;
+ case XAttribute attribute:
+ return attribute.Value;
+ }
}
return xPathSelectResult.ToString();
-
}
}
}
diff --git a/RELEASE_NOTES.md b/RELEASE_NOTES.md
index 70d43b60..ebb14baa 100644
--- a/RELEASE_NOTES.md
+++ b/RELEASE_NOTES.md
@@ -1,3 +1,6 @@
+#### 1.7.0-beta1 - Jul 5, 2021
+- DocumentAssembler: Support for images [#31](https://github.com/sergey-tihon/Clippit/pull/31)
+
#### 1.6.1 - Jul 11, 2021
- New docs site generated by DocFx [#33](https://github.com/sergey-tihon/Clippit/pull/33)
- Tests suite cleanup, samples converted to tests [#32](https://github.com/sergey-tihon/Clippit/pull/32)
diff --git a/TestFiles/DA-Data-WithImages.xml b/TestFiles/DA-Data-WithImages.xml
new file mode 100644
index 00000000..b0222b91
--- /dev/null
+++ b/TestFiles/DA-Data-WithImages.xml
@@ -0,0 +1,28 @@
+
+
+ 1
+ Cheryl
+ True
+ ../../../../TestFiles/img.png
+ ../../../../TestFiles/T0936_files/image001.png
+
+
+ Unicycle
+ 3
+ 9/5/2001
+ ../../../../TestFiles/img2.png
+
+
+ Tricycle
+ 3
+ 8/6/2000
+ data:image/png;base64,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
+
+
+ 6
+
+
\ No newline at end of file
diff --git a/TestFiles/DA-Data-WithImagesInvalidImageDataFormat.xml b/TestFiles/DA-Data-WithImagesInvalidImageDataFormat.xml
new file mode 100644
index 00000000..7b35fc41
--- /dev/null
+++ b/TestFiles/DA-Data-WithImagesInvalidImageDataFormat.xml
@@ -0,0 +1,28 @@
+
+
+ 1
+ Cheryl
+ True
+ ../../../../TestFiles/img.png
+
+
+ Unicycle
+ 3
+ 9/5/2001
+ ../../../../TestFiles/img2.png
+
+
+ Tricycle
+ 3
+ 8/6/2000
+ data:image/png;base64,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
+
+
+
+ 6
+
+
\ No newline at end of file
diff --git a/TestFiles/DA-Data-WithImagesInvalidMIMEType.xml b/TestFiles/DA-Data-WithImagesInvalidMIMEType.xml
new file mode 100644
index 00000000..1a765357
--- /dev/null
+++ b/TestFiles/DA-Data-WithImagesInvalidMIMEType.xml
@@ -0,0 +1,27 @@
+
+
+ 1
+ Cheryl
+ True
+ ../../../../TestFiles/img.png
+
+
+ Unicycle
+ 3
+ 9/5/2001
+ ../../../../TestFiles/img2.png
+
+
+ Tricycle
+ 3
+ 8/6/2000
+ data:image/invalid;base64,iVBORw0KGgoAAAANSUhEUgAAAMcAAACTCAYAAAA6Gg0nAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAB3RJTUUH3AUIByMa4vhJ9QAAAAd0RVh0QXV0aG9yAKmuzEgAAAAMdEVYdERlc2NyaXB0aW9uABMJISMAAAAKdEVYdENvcHlyaWdodACsD8w6AAAADnRFWHRDcmVhdGlvbiB0aW1lADX3DwkAAAAJdEVYdFNvZnR3YXJlAF1w/zoAAAALdEVYdERpc2NsYWltZXIAt8C0jwAAAAh0RVh0V2FybmluZwDAG+aHAAAAB3RFWHRTb3VyY2UA9f+D6wAAAAh0RVh0Q29tbWVudAD2zJa/AAAABnRFWHRUaXRsZQCo7tInAAAgAElEQVR4nGy925IkR5IspuYeWVUNYAZzzu4RivD/v4U/wHcKyUNyZXeAAdDddckMdzM+mKq5RwE5MuiqyswID3O7qF3d/re3ETADzAAEAAPAH/M/fOXfzYAIh5nBAEQA8IDB9E0Eoi5TX8L1T/pbvSL4GVtL+fQKRN7XDDDAwre11uL4o/Et51XzbxFxWUfE/nP8eV26vv4ef7EwfsjsQoF1HwN8I4lot689DAhr+V3Pv7eNDgbAIxBma2/M0AxwX2vqsLWNsZYekb9Es0Wutmiy07t9esSdM6wZglRd689nDz0HgGm53jkcY87kGRistUUn7/lPRK4BBo9Aa/y7JRFy7wLNklWbDTQLRAw0/5JrFJ1IW4udB9Z7eh4gtzL5YfEMWQsB4JgXftCX6+P4q1cAaHqfD2XOhUTkTS0J1lqDwTBn7ri1ht4M0/1PdzAty/WGXe4ZeiIxn+U1GgWmrb1CA9dRQmu13IvIF8/nBlnEel/CEraof1mr1uYlmKJdBLb7GizWPeoOekYDHIawXFwJ0dg+FvrMWkFQUCOW0mgi1kbYFIAiXdETEzCuppSGrrG/uKd8FHhdDGu9JJNbftZrAS3/b4tu0mlmkW9HQxEtLAVQBGxUvG4wPbwdCATCDdFsUwL5vnSF7dK6SA3ns6ZAc8fM6otSvodL87e/sBixUXh7WbO8Dpmh1EgA4cmQWqA2zn2x6Yx16c+2qZjuExMHNaQWHtuXPGkIhycBuZmpRdrlUVz33FR3aeWNybQ2McyVANe1OWkWAbRmcN8fLpmhBRCRmjEAMoU22+AAnFZBcliMTlrnPl+1IQJwzz2xei9gYRcZyX2hRiWdPRwRgWateN3an4127EpQ2pbrahBT5rM5H+vWWrFSKQvLtRbf35yk3SRWAgLgQMBGpGBYS6sIIKITtRxAdyoVW3xptL5tPe9FKWwKLKjpy4LWFhsO8APhUebEeZXLwvUlM7TghVw3DjKlbrzM/4yEP+7A0VODefjGnLIDJPRna0VK7swgU7veiDI2FlHarZnlZrusSGyXMF7aytqhNnmZ1gjb0VoywifuiUgBdFrD/bM+dU9aY2uwiGToWn5crh0RCA+gte09CqEE8boExATQZJXS0slKBkWq9p60SL0Y2E1FSBC3ay8NK5o0WkApEK17PefpkzCKAt82yMJ/zXjjDRbumj15sOXnuafamyabR4UMKs9tkcDc+Fk2woFehiAQ7mjW8msOhAVaGKwFjuGSmLxDkEHMFlOVJo1AozS6LxNeOqsMDompDwTQumFy5SLmRv3612MjDkhJWYLWyseJANqhNTVaJ+fnrITduGvGa4eXGJVmDRdT2NUyUbPPubZuF92gNdCuRqQZCyTtWk+L2VrDcNKJ13Z3tB0TmyHci7mtbc/DPQmnxubmLrJdrYQuKrgDlzWMEr50Mxu6pcavdYSjoaWya7lO+ZCumwYQtI5ORpViEKOhT3g4mnUyIS0zci2OgD2CUGena+63tQaX9eMaRa0Gft9EBCm4FPlmrWjmRsUZlkIRgVm8ASrrgI0UrqRNKv7jLkeKt24XRreNwkHzb4QmetDcsHKIPBcUTQvQ9QIRjk6H8CjhkGMfmKVyqdHTFCwG3L6TyjEZZlK7u5P5JoBoiDDEXI5yeKDfOmIC48xnaE3EXdDiwmMeS8NdJGPDxZ4s3VrDdDFfw3lm4GLOtGJo+SyJuVOBpFB6baLeWWZ/KYqCM3NbR6s3qZ0NEf7pWRI7hG+OcwCImddsyxJIeE3+Dz8vCGZmJRhal2+aTs5/fk7CmHQEQPieN/G/gH9GH88neUwO+QbtZixoGDSnu7UW/HSPspDNLJUczZ1Bvqr2nfaIFgowHN8eydkUtKT1ttl5Y2pbaunoi0taJA5tKZ6l5aGowdq7xPMuRl68nlqMTiOxYhSu2zSzk2CM0qRGp0alEAsmlRO8WUGgYcwUqikLsq1Vm7QcWCoEMcMyZ1hmUoyQtHCPYp4IQz/IlH0J8+7bBFJgrCUUGiOxQO8HnJtuyYFUSIHdF5RSCjDK5L6wM2FCrp3+RTPCj09WEloLII+5mFaQpfYyimb1OTnDIKSdqXA8qKysFXyV8PfeS+OLjvJpAEsfsqWFo55cESfP/7j2pegQaG7kRSxpbwlxTd8V38EwY64IWvEAcLwNxQ3z6s028LATWsDbHRhAzIRYLRpiTjRkZKolpy+zvmmVhBFcmZikLW2RRA+Yt/IVjPduPR/OY8KQZrP1HZ5YQZnw1HxB5gWhYzPDHI6jp8kGEvuHKbayubQR8OmpIKIvNtAu8bki0szDG5ovDVba86RzMR2t2dJwQEbGyIEt7TtIkDL9QeUj5VCb2vJ3k5LJx0waVLg2APpD0uAOS5+NUCUmYH2tG0ghFrNMT+UomFLCgTRgRivusULmKV9cweQ6Wz61O0iHgA8Ryz7RX4qopVWixQxfDJ08JGSzaJ5yK8Wayj4DOZEQV8K1vKVNSdumAA0Heq+3k3WjMGh+MQllDXQuA41hAJc5ap1RgoRdy2mNTTYCsqiIgAI6Jm2/QQmDo3lbzx0BDAXdln+BIF7MJeQGj4rAU7BkzZaQn9MrOrECykn9Vhoun3NEIOYsJVTEM5rsYDSFZhzEvXv0Q4IcGZ24sAGVcCoaMkpU1E3mvxFnb/ByLvgWkcDG6N9MT2Yt66S9QCtlUc4/APNtrfwoUy4IGJr1T3mNMjdlXYLwqFCH2eXzJkPtgb77WvqJyqtYNtIKpJ9F+lJIpKfJSusqtKgKtgSFQf5kwVLeQ8pTvuwFjhpwXI0j/7oJpExeSmkuslH7LElNBymQ2rBFy99iyWX9pMuVUykpWfHtWsnlwXf/IKNh0xY2iyUTn2BS5g9K625JMJjyBotRCyKEwXoD3GFHK/xaciRVbS0/Fwn1MoxalNy237nZvD4FXBp5DEIIAD69lIbBmPyyEiRdXRpRa0cEGtbvV1hbUo31BdJHsDSWwNknelYEDSilULrPUL7J2i9cXkaOFtOmL3ZWMAUBDB983g3yRYawW8g35n/Id0vw1/6FK5Kl99ezZxBwKcCAlVUqGtHYHsd2YV1gzyE7M5tYa0BvbRGJhCo4UVhUuM8Kx18uUouWQMSGn4muNwtkrWUgIJZmsmhUYgzxLU6ojerWNvhphIPpcxgA651CbRlynp5RnNaASWvFcJbxczDAnBZ3TzJt/ypgIUHN0G27mO49ahdo5WjCOhC59gCI22NRxix9h017Foybgd6b7n5RGhWl2nJaybMrCBORQRl9HgAacV1m7rcABZA+DZUjYBVBij9JBwBkWHby12hynqOSxkZYuWfNJYRlncjMTKSvSLBybAjmOAxhDpTP2Aot6HrUKlfBpiNztFCIrbZrt3d5AVoMqaPYNj+jA8vJLEavjRcz0/wHv7dr19IExH2wxXP8d/pEbz0t1nRMBJq0sASI96/yjPTEywlshbM30z69hNfCMowJQwz6MgFYk3mmtvTKJiw64YrbS/uRyRq27JqUjLUMlc6A3RrC0hr0ntp8MB1kfE53qzBuVjZIeMSYywGWMiCvAYENGsXaT9Fe7zngzWHMOiGCUFncEVXdsD1s8UXCsaAPsr2oFHrL6J01JDQXsjBGlODMKqykca49KpFsWf+AQQfblTTis8EsYXhZsyt/GtpVeGUBybnSOIfvGArYFiCNlD+0ChPGthn15KltYmN22xYMYPhccCJqNUzmSJJXWn+ryAAi0K2lZiA23ZW24BMoVKt8IN/Vuud04vuWloPwqZX1ymcxKoShRVaewMpSSQtfQq1au54x786dR9VMrfD3BCzQDqPl5D2clsxAp10aXGuIS7RPut7M0KX+qSAKHkmT+tUX2X0NswbJ8AIiZFGGZWU59azuDlOYVowNQ2udeRqunTmvyRC/nwlXd0U86SMU/xkKLchHyMvNgnLuLX2xDa5ih0tSBJA1U3gfzEGJ9rmvpCQQwOFb2G5pcOFDkSkKH4dCBtgk++J85oV25pFVqHCgLZgVJuuE6zqKEGQwCmMp31hbaCrY20z7xcEPcQcTPViFgCZwrs+a1rTWjdjriazWKbhWbNSYA4r9OWhtx7K2yScOA2GOO5ywsTR1PWc66IIzif2dmWfRn7mgyrEkk4Rt5kIOPEmBQAayFHZuBQw2hYMqK5Oob0iQ/pttZFnKMICE2I25g+SidZO2NJutndz2i/dpWIIh5UQCy4HXJoncnwx0vrM9g/HBpJDX09rliwc2zb2YNkNuqItstwnQMUZt5ucYsW5wxZ3bdWIljppZEXYFUvkxCRzrdATYqOboRCUskpN1uV8EPJbFU8RDlq+hwcMZLqTmsFWysWTftjj/9R7alNoYWQzHel5ThRctiC3VIp7yIJS0jOwInpSW5r33ojnQWVVdiVCAdQqKB0svBAkD1ulRbAVcEogsfQiEtbW2emaxp6yzo4WspG9ZaQko1922kLquwr1oUVTRhl/5B5FGQnVo9GH1DZ9RllA3FNqIPZezCxX3Q/+W0hOdNgE59NiX4ARSkxiM8XRpaIN1XnDH9fw3cC2LkCpWfN/4b5YkXHltVYVuawgJ47Y4agD3YGCAFiFk3dryfQIIa5+Yt1UyKZDFfpW0DVuhXdPnld3enMSLQuCXnVaVf1NugoYU3lH0mrKsRSMKvqJBuqenZYuN1lnSnf6AhBol/PlzhU2x8jvasyYmYbI1C/YozGWqld8B3Oe2ViCjY43FRg6F4fcwjixkhCPG4tjKXrN4r1/sLmmxqcikbNQ1pIr2EDmq6DLWc9V+OpV8ATXUxvInV2CmWG+Z/aNqmVrjBnlp2CyBNoQIWKXbrZxSgNpBTlRrSxqLLiv7qlqjEi5oUxSdIoMIe3Izl/ak5QosvwFyxNtmKpMzfdt0hQeljWWNBhNTKWSy0lHaRzSbI1jB2dbfweoA4WXL8vxmaX0NqfkmNgVAJi58TIycC0vFkSUnpBPXFc44jzFSdbQss1hxagSA3q/PXe0B1jZfRVoYjITxmSFLydKXzUcRPAJSY6l8xvqxopoMumRaHBTcZMWV++E+fN6bWPchd2P7cdvDRft03Pk4sWhc8LLtZUErqGK0eAod6/lXCBk4hMGztHfFqnfH61JerUy2PrclB0GHrxbMl0cw9JZS6x6XJJV4RQ9okkFuRDmOLBzzKY3IatgiiuLb5Ls9GSa9EFHVmmES/HRwy4yJkNJG+eGNcLRSW0IyUZCsh3IQ1FcTQBft6vJ6vLy8A1f7vUGEQF0XtrLWDZ2XsuV+ACUwcjiLkiKunnSHaNj06sWsi27YFA+w0vYBk4O8fd6lGTayKiChv6mQsXS6WUF1hK53tS751va3yOCtvpb8YktRXmL862q7/1sCH/sngEMNJL6FP4q1L7j5StC62dyILF8kNhq4OJ6btpVAACs5l2QQqMmMMrb3kiuQAkKNM3ciWUOwREBrrzW6lyXak4ykbsJGU75GeYSF5ebYyiekZSk87k6ovgtr/q2ZPkftTEYQVF3Wd8sN1dUZPHBFChtUmO++CaBoF4CZLJZDdeF7H03u5lZBQGEXXbatLoFdZSOxaLd9Dlg+XJiX1pfCzU+snIthaWZpMfFV/iNLIqosGLTuukEjW9STmSmopHKdKseIRevUCliPbQVt0zgZjikfwZeztROiyqq3xe+lEfpbBGC+cKVoWH6ftSwkYxTFAokXNz1Q+QmQmSKufwtBgQy5zV1bEgYtR4w39/oyNefSJGUpK4O+8FY10JghYpL5lhUrqAEDGq0hn8/d0VunHKXSqaxwBPxMhm+bRts1tKylrNSUVQsJFi1CxPZ4QW0cVWNmaJhzhT0vSm37IVhic3lR4qpqIWRHriF8blwplqUVY0FjfVaMvyupnY8+KeIlBlelEfuHQEaqKy+6Je9t/OP8tqx9Tyi3lOxCHg2BoxJJVR6xS7ZdzJ6ew3dGkuYRht3MbgSqjHr6yjIjAsNsy9Suv6eGSSaruhhQJswwZ+ZLeu8rVGmW0G9iwQa+J4e0HQ1zpEZVd1gwOrOEZTGRnMYggxTc2DRa+UL8TGp6r2z+7m/tm5sFuMHemeIM5mWwGE3vezAkmkwcvkgtOCo2KVYsJ902QV6LkGXS5sodK3ShZVFuZK1UQKg3xZ+ymrr+FaYuy7P7mip+BNdt10ujsISid1hRQwURLsWcW5BEJUN7JFU83JA9HQHLfjKPxYsbDY5R0GVVbwJWcKcWb3rApQVhtsqIyT0eulpbCTl+RsV0zQxTIcQIdu+R5TamyAfQphiFIDPJgwwprc3Kx5VsU4DAMuGHuVVlftbYIUZO7VVJRgkHoYXgQ9LJU6NpuU4KWgcgR1aRMoPFWNaWekTCANJB1wvRm06qs8d1WToJJ6Vk+3z1XbiidahnKUbZoEs+0XbvCCgTuBk+qGRk1Wgl7VLJ7GIgmnzugbEKpLDKrKxwI53k526GoPJQ1zB/lBVIP0/PZYUMYoJdfSglpu/nNmpPcemEXPWAhmPs5pTUMsdFQneaCucCuY5oe5cW6k7DsPp4scycBbIKVD22F0vsmxazpZkQwAw01kHpP3Ey00lN21qrqlAAgEc2Ec0o5pgZ9imCNwkdiWioGkuEb3FwmclQtqUVc2WdlszKFkHTRnx+FT33KFwZf8hiL1yeS3bxm7EQ0pEDCIpx8+fMLVghgVo+wLoyhZJtWUbRVNbrYkJswasZVS6yB3C0dtHL+lqTmCcIyWTNfE76U+IDQftdaZA2YuJN4FOJRwWMKuNEJWahcPdi+FSCfEZbVqPuSJ/WzHDItCt+X8IhJxuUTDEhAma9Lq7d9+B/Wm6IO8ONznLyafLLkw2mV/Y0PkXA0jVYuF4aPEDhLElclqxw5kXibDGa4JMiZORBWbqdLy8Ci+2HqoA16gBtyAo/pmCsaRuoZbTtahSyHTpta83b7TRJjah+9EbGs76VgEiZVetJlLXZH0EDDmJ77tCzfdID+/NXC8tWtHiBi2YZZGAtW+u6cH3gCnEiin8uId7ttVupsmIyVVhMbvvnqkoAsKZaGHHyRur9OWlx1miDRE7H3Dq8AGTdybZJU6DPRSE24mylB/tClYRZ1gCY40LTvL1n/NlBvtkYFnp+7aIZFKNflaiZBHTmZYyZ7dj8FICRs43hbFtDqIDOsEEOrKwrdHtb0Sgus3wSsIeam6CaKNWPKYTt66G4V0tYBM8pX3xs5Q0WnEiGSqHy4dVJt3Y8w+rWKPXNcgN3n8mjhByWUTn5E4ilFFdUJT87sZKMHleeSX+PGtxS86qn/ELXTZhWeREEsi48Kzrtt1rsIN70amO4uG8RF2sJLYuKRPVUsa2vBBvab+AAm4r2PMHypaIe0AyF2WURlh+yNkiLtBaZqeV1jGZPzUSO5XBLi4kJVRrxp6hSpObrJMigYLcN20uDChZMI9tEZtqnCitNu/qJoHXH/DffE3RcAnMxAiao4ysbTYvWeiZFozxeWo0tM1sbzucWg/+pd57Rn+ys64wlrEhRwTkFTBz0e+KSAW/EJ16heoPPVMvyhdYWbJEoAEY/7qLkZYVl2ZqSiCjftSjbV/xKdX3TP12LhFXg51IWVP6WkIA6WGy9TxThsUNOXtykYFdFx7XaYSngYzoKX+8X1xOn0JChmNmWhklocE3AVIjyYtbXAwZxqco6Cke6moW4QEQOijOxvTH6lOFQWTdl+EvtlGlYxWpiDEdA1b57I9WCYHzJqW+AaQxNaLOwCXRep6asoGESl4tRJyMec78DlYa1bOIB0ro5uUQ5lk9G/bpGLX171r96nxevRywLYsL93JeQdbGyhgC2iRyLgf68LmzwBVWXJ8gq385nqNYe6Qt9Wu+n31eA4hOMghRnW0hiX4i1UtKfrVxBLrEoy5A2mazHOd7OjPe2yMSbAau3udhLcmYAE2pFMFPdFAkHRaiSmbMKiL6DCuFawwQhQHC0Dh84iAYQbdWYOTeYUCooENEX3Fi63i48EhssqapVfa4MfVy/p8kX05C96PnelN8SysLyujOFeQ8ryimsO0mYmjZATjC31q+K4dKZtu/blRNKH+xZ7s/M8KcPy3ohLjDl8j0pR2w0rntENQTtOmm/eY3koYbPvGTSrancqAi+NPbnZ9sDA4GlFPU9waMicADqBaloI7RWqzla0zXQzlZIe79vAMcJwDgW0gLoFjnpzQSnbGEzW/OJVhkBodj0vKE7HA2qjD/Q0IzFg2YYg40wbS2u0Tp59KpeFdNuGC+b5Qk7GmGHU+BUqLePiUmKo9ZbGdfNwuyJp0pOFYxQkZ+0q2ho9Z2gdUyG9hXmTrWUXXmyNGb009aGRQQz5Qm9cgjEWtOuTWvZssIh5gbWpJjP4vFJwKRpYzH8FZahnl0l8lfsT8uvK29CuddJffY5VlJ57cd+zes6aTEoyMtXsdo+BP7iWdfldv/Gxe2Q1aDKNq17VRTUv0aHPCKdOwMw3fDY1gIjVEJqUY812iWHeSHLrdER0a/wBsCDBAqkSZVhrDyJt6rrwgz0ngJag4ORhX0N8vUNbikE07D6ENzZ6roz8NqA3a9Z7+Z/mmyjNDktX7birs2UIVvhSVmRtXGtq988LeTpGhzA73DKy5ySGNTcg9RJyzrZ9vlkZq8wYy59acvVl7MF7a8KkbeKzZIty79bB63B0yTxUl7LTzlvl+9A9NQdu+jr/FxSb4axV6mx4HVBbimnv9ynel2VhYhzEdYCOV4tEYrGOmlcuTkAjqxoAEjHyMDKIQfHpYVAWY3luHoAPh0RvqIZZojGtkxfxA0+pDq6PAJVniqJjoQXqjpdRihbKH0G3BytAb11NDN0LK2jKRxVyqwBr4ymKSoRkc57UGXtsGRpJUJBvUVNzgVdGYk7UoLmW2lcWVogWlbmCqotH4yBCTmL2z3AIsZPyOISppQUrfE2IC0NlSyUUfvkCEtQHAD6sjAt9Eyy1RROQarNkjYDorXKiQBLOCqDTujkMz5z9eXlFwEgrHIvf6tKUTbIV4GvsnhLFhb64nNZq8BBhYlF600v6Tqf/agAcAhPK3Qa9eamDWKF2bSBn28Ai5yBtN8h/1z9CHu/StYMRS2WRooPBmbBgTEdHZY936rYrtDvtYiumZJMCxLOuDqV2kSVqKtAsEoZNirtCaQ9u1yCpYdi0s1BReFOUy5o4dAcPFsLrt9KMHn9PeR4cQdoYdew56X9tDcVNNjvFWtvC8Ob9k0hzKW9a4/11T2aIyujciOuuSyMLFxFPD7ZrhJC7eHaG113Z2h9O7avV23Zdv3din6GcvsFCsWUNFnBxxUJA+CBY+5405bWTzoELUYwBEem8zRFzkiMtfankJ1fRHFFsaV1K7SoDSetQKEpJy7SNB4yv8G+8wAOwRHX3gRghFefCbTh4YjYqmszVt66ZniLDqkgFr7ns2KtQ1Id0tra8Ere5PcM4BEMvMLFilGLqxzCotY/1ApQGm8PQ5NBt+cCADcO22PAdrEQ97Sh5rwpVSW4qs8N1W4BhEOpJDLVpSCKGIlKbmnPlXxbZN9em7DE3irApjiRqawhyuSF3D9TBBKI3bkn9lbAIItqmbBmrk4O+S5U2mdrWfmgGcUHFAfnbjUxMpEAWlsDCCgw2Upq1SuxYDJzF/zb7rSL2UTDzFFZmTW1KxTujXRzpV3UsJPDlnPbx1jqWHAF0nxllpc2XNl2adxk1BEBjLl2k7i+ccp5TRe89jhhOXEojlMEShAV6MsPZ3g4XMSNKpUwaeVVDLWxrK5Jx903S2YrO1+O9QRa07ACWVLC0maFElR5UXkrlde1xZTaK2u0+p7RJrdN0YgctTZkCFzWw/N+5Wdi3SshfLtkvnOfeUUpIaQUN35O64rdd5MPiMWPkoPL0LnYauxiJWxT10mRbxlyaRbfG3L4TiZa5enbNgZy7xtGtlQKC7atXXW3IvRFNHY0AnBFyzYmBpwpDpnhxfiIyK64dizGKdqumL8OgykBocktDaRNCKt7J87KdQ75LRpQvVXYlZAwP4OgtSzrvEETX35SDSsQ3agp/7J8Xcusvbd6xlX2slkSWLYxT5ZrVg2VFpIzbNuRjKa7KClonsh1np65pLasbwkjk3ufwBJLWnJvWrNLz4osXpfSBGoYdukw7vUqYtUzgdW3gDLXwTCsBjysxdiiK2k8aZUXHQtUrZSF4KVkgWbwsNiiFVztJr+5IDKTB5Y5xQr1KdxXzLuejRj0GiaUBOdTtTV8gGYvsLLrRkuUhBE6z8+HLwYUc1yDNcsH0ecms8/1t1gaWVErMTefKOu5ilHIDFuUxbcmrVLVf3pZaeJiENKj/l7rrm/86VXh2wvc2og9+Az8cyFAA8xa9ZMg1vWrr9z0e254Tb2HMTAQpdDismLAhvImGZbPVmhGAs1WR8HnB9z4Jf2hKPo0UGgKXSTPeFlVMfX23Qsd96oG7qeU66aAbP9Z+xeGQ6Pem3Dw9aMwoFpCVfuelYucgg05tA1qCtIDe2V1NieeC+9CD2USJUjAmhCQg4S1Gb33LGEBYNYXLQJMMO1PqGuTEBsDVVCHlrAIFljJTDV/UesVh2k9hHCZeV896AsGXF/JFOv7UjxA0tRNg9S00VjhubqGoTu7DxlerztJSfH512hVObpXZtlXOYjZFW2bzB2pXqxRA1cr9eaAr4vZUiCGKu2hbochI4eFBvVMnyzmftQBiiK2aKLfwzGGf5q+sa5ZbFWW4frM2IS89AIFTc7aYcJwZMyVml8vH4F+0KwNL/PnM6fzTZraiis3RdOXpoP8AS5CpRLlHZbG3uhNjZVZdZ0SlbAoJnDogW37Pg1SkEi7xZXZrSQfhWpRjg5iJES83Y7Swld1F8VIziHMbq6FVLfe/uoVqstraUMqSsY9/Au5WtvJz3WGq3Zy1epivafM7yqh531Jw3Xh6zVIigWJVX5eH/2zeUzmXak1I3sAACAASURBVL0nvZqfgtdzTC81KeW8DQssyl6YWZZdyKSWbA29E/oqcsYFGh+gQrj1/XymmqyiYRDeCmrq6DwDcFQms6wqhaNM51a5GRQpo4/fkLVEyOIx60c6tzPQoYfeivtQvIGOozYgZ05RWKpYDtCBmJ2Jo2o2oiN84tOLnXLVUYeAzWNtfsuEZzZBSTm3TMgBHAW6zLP7zAjGeSRNGtKqWbBK1WixGjD7YpnpK7dhDCXvmXJkB9rkvVQmU9l9wRwNb0OqlRmoGjQJeTGENQZIVoY+FkdcGITTIPLHtoZBwFWst3yVrikjO01hleNZLJN70lxFiY8Fe+THmqE8cc//xFDkK9e3w9W2OHL7z4LuJUwVgbqikCTsRGsDAOkPK786uNZ+S77INue8snvgWKM9N6lctChZAQxDFWVVWNdKgMIjJa82gqJQmmtdj0COUq6IwhY2RVwEK/avbtfqqQbXpWNh4s9fDERmZvvVG8/mp1brEHQoqzMzMhM2If1rjNbl9BkmMrV1xr8hsl2W/kpNvyHULM/OGGffyi32M0dSc/rSjAG42XWPSH/pjv3R9f6+D1prxOoRkRUDcK1m3ei5oo8Ba7P2L99j5DIzZ3iMG4/IW4yc8VXej/DVRBNazVEjRCmEVISFAST8n1+BDOOaRiSx8jg6Agf3NyoAokfpHXkcnzGpnfFqRGbImTbfb+SaKMHSBw9GnxrmGNRmim0vaS1mN7ucvxGR1xRsCPc6d+SiBXSNxQe8tDalLgoAOGyd/6VNpDtYX9Z15ZynBTJq57xQVtKm/3TrjSHQCqrD26hmn5RFzjvS+EKTVZI/oWfKlUv0ZGmSBrLKykQngMsqYxYylk+y4JoIo41u/RPDc+f3IMi+muJvMQTXhYbqqJSPluHrzUdr8s/Un6I93J7SMzxx8sxI5Vq6UVBouVOYe61RuTWTVY9AVLmRnpAr3yBSvccfcxj1phqoZFI4l+YQL87TUd2btLhGy36M+FTGIHxK4XCm4Ff7I4WJu9j2coJYUaU01Tzz0znVnHFoqVgdPBNzlQ3wMiRqqSwUz9mCC1O9zkwWyfm83x2P+8zrbw0s0uTjnMsKt4ZBwWjcxKfbgafnjpeXBmMZ+tEZfuYXzbOAspllOYay4kjoUNCgcVwmtXdts1+RgBguFUQOzVMvSrFFjUGyypIXGlUJDz9dGfZGwTNwnhXX1XOr52Dya2zhTq0/cJ1fttyqreaMSiaM1iCLR28x85wW+VOdwqOzMSpXo8DBsiDq81EuTK8ilaqjYcuN4x679trAcaGh8jSiOsuKhuARzQg8zwnlQWRHywiuiJFMXuI4Vb0mxGDIrIlpqUWqG3BLUtEX6exvFoZdT7jCcdKguwOfuz1T25giVoFq7qYG/OAmPh4THx+OOYHwhunGBpq0Aq01jMHTmVoHZl9OMGv5Daia6Y9h6PeAfTtTqzjw8nLg6anh6IbjMPatsAaM2jbPC2EzmGbuBscIyXLQ/CftsDVR5YbXqF5FXGjhgpzbTIqJ/eBCJFTKcmarqWzEp0CHibxr37QOs5qzKyimBKCUVgqG9l/7JYSBGqLwZBMROhGrwUcUfAGnuadiY3AntrUQgVRv99KnZCH5W6zO5hT8EP8EhccM1gIjHmyIy/MCF2TNe97tBQBwnoHHGLjfB3oDDtnG0lB2hQb7S/Om9ncyc17yVtAiezRWEjCoxetzyA02woI1sjIXUkdAWE7xgPU1ytKA+33g690xz6Dmb3l+BRotS1q4cfL5Wg5n8EcUIbXjMVfUVNN6BitH0QI2Dfczs869TTRzHEfg5UvD03PDU++wyM7E4EM0asBOizBjorMLTrVlMvgmcreATiVavQ2mfd5gY67eGckM/pz3XUomeWTF2/SA1eNSYdNltTGvuSMAPPBy83vbhNPhtlsDHBiRPRwa2PHktxKmWft2ZfZm18mRdT9x30UI8/cqcyISaVTEvtEIoqdI2BrCOsIDpwsjZM5rDMcvb4H394m314ExMwKJmBkNLQanCqrDKVkladf7VamB6qNCIM4YeUGUFg33EraqDqDFiUbmhMOpylZob2liPWQYMAbweABvb46HNxL5KJ/DrG0lBUtTFyzdd57BfOUG9o3RhpoLojSYG8bMAh47Hd8/Jo4jcORRughZRDPcuuHLs+HLF+DWgBpKwaUJx/dNq19CkqKT7evm71VIuXZl0kLVA8g6heBXFDxtghecoFIdmCWQn8UD0BiBQKS16i9pdZXZM8B7zgsIAB+t/swjF4A280JN9+wSeCqKEmxW2phdsthlGbbXOgIyP+c11TCgyJT7kX/rec/pwOsr8PV3w+u3ge+PjmgdiCMRB63aEaxfKiEJR3inVnFoMohS6quRR/vCsG6ZHz1MrNAg1kNr05WJXtWdsl1WTCBocY7A4yMHPj8eztEyOotPJ/6kpncebqkeik6h9AyyQyc0rXChOJbRGV/HfFunZn8yjEcO2G0E+82yWPF8BE4E2sFNpRN7PgIfHxPv3w0vzwd++DFwHA06NrjYmjT0wsAoGqxK4E1ein7JTPtA7wUr9vJvwdCVjNs+DKFVMSlCFQSf9xPVhhDWMMMwPgLnmcx23ieGA+djYoyJ2Q/0Znh57vjhi+HlZng5MrEWkT07Z6wF7UGXS2uroBufKzZKiGdTtKlIyXupC5imtobHCXx8d7x9n/h4GN5eJ86TRZfhTG6nj2nIiOGRQ7MC5SzDiEdb1sSrRgYrmResc5HVyDVNrEK8AGIfME8rY8gE1AxEG1BkKx+150Nx43wa7g/gfp84R/oTHkj1JNkjwyctHdYXF4lRphtab+WM1bQVOYG2MwJYXLgyshEBjGAGhELuBm9Wc4IFEUObFsYCUcPrdLzeB37744Hb7cDT0w3Pzx08wQ23W+DomTMyzsmypjulRdKQOXedwkuuElMXbg90GXFknqaYC0g/cjJ/0DLSlp+LWruERXBtr126vwfevw+8fjjuo2GyWDPRcsLetJAHzp5X/Po60M3RzfF8BP7x8zNeXgxfnoHqyJOMMJncKCzq2++9YTByJUicEyYBV54GMpiknAfuH8D7q+P7d8fHxz3hchgiDsS4IZBT6rvR3E0k0mnpFnDAAp+eR0ilNkht0zUjyYyjPVHhtqSx8GqUfwFjINQhm5L/dSv5Kd/a+JATmLPh/jHgDpzTMYbKMzrqOOcIdEViynulYeZFAznMLdGe+tojz/ljtG2PztUAO7Edx8xIbG2IiVxpjV3sywSUJSATN8sYe+L8Z4wz8H4G2qsjMGAWaC3w/HzDTz92PHWgHxldUTLSJLHUCKvWKKrJzGtETb43eUZeICtjhRodhtOBcRoep+c54GZ4PDy1PQWw3ZLJ3YGY2VMTkY5vDo884NYQ6KxyXbRqoTIjzkVGw/Ac8ne64+2/BuCOH358ws9/v+OHH55w6wm1erv2c48ZmN5xf514ej7w/uE4HxPTgceYGOfExyP3trWjikgjGs5zJB38gHtH4KnK8MvCTCm1o6CdhmtMDxyP0eHTMB6OMQPDZ9bR2DqjQbU04one6Gw2w+3W0Qw4bhtcoAUwW/Frxe/hefOPe9ZGTQ/Mc2akidYhiZ2hV7BUpM4qJAfm9YIWoRfDKlavPoHOyk11hV2GwgWKeQo7AIzILetTOQ1albyOgguo5psQWNaXVW/lkYk7qonsoenolj+/vk18vA0cBvQDePly4G9/z9NqLRzGBKQgoMKgGrXfLKEAIvAIpFAwYjdnzu31AXz/duLb28DdewlMZsAtGUTBibeR+FzVyLjVviyV4FQIhiwbEexxTDegZQhdhrr3ni2y7Qa44/u3idfXE0dzPD/dcOsNT0+NvTXpW97vjtfXDyKUk8KbUYgMQBzAeFqBmsgOzHy29DOkPGVaChF4yWD5NNumI5rh+Od/DTI0z27jLNrWMiNePRdVK6T6I1qW+0RFEQqzZovr0/MNT08d/QDuH5Gl0HNiTMeMozSfWeMInAV98jxzVOJpJcJXpKv1DM+tGiI97BKikJAjM83N2pqXValP4d0t+xoowgaQwS9fxC3XS+YihMe3U2sDGfYMYPBYApih00EfFPhmHcMTOuKceAzHx93x0083PL10noAkWCuGTfirMftijkcYHu+B+93x9v7AmJYCQj/N7QnOVoPwdGh95DoyW27JAyMVTT+MyojWNQzRskylKBdSE6R9ADoGW+eH+0zkcd4D7g29HTjPJxy3wB+/OL7++ht8Tjy/vOD29ITpjnEOHE83WOu4PT2hHcDxbHicuSfzdNxeFAzJ/cOhRKZQgGmTUAeSau05USQtiFiAuK6Z4Xi7r0l+rWUBVqEVb8U+yyHvlwkfcxOaxBKRyarhuD9OtDbRNNu1LNCBOXXwCt0dpOYtl6jl8cp5JgcuhXylvWOtxGAbq68ggKJHWTbdK9JzOapAsoB1n2UFW8Gy1feNq5+C7eVWR8ZB8gXDYZoj64BrcDKZDUht2Fd0bX443t7f8PJyw8vzgePo1WqLAB73wMfHmRbUnVq+4TEMj8egdj0wpyEb2oy094SNmgcQuY5ItYzWOkbvVLrrhgqeFG/Qkq6+kBQ2FaSer4GXHw6MM9fnI0Ok80EFeT7w+v0NFsDj9Y7z/cEJjo8c3eQOnKlsjy9PiHB8+dtPgAFzTs5Ndvz4bzd8+fEF1gPjjOxYNaA/ZW6lHahEZg7NYFemEBFWr38KOuv8zHCA8yh0LK5HmrXWO1RfVJsfgYaECBK1qSiIuJSbpDCiM6mDqhbVcQQGBVPyUJu8gPC/89pNoy0LNy1NuUd+8uH3HEauUSFPQYIqZyaKKq17eSkQCLZVMprE74ihDUlw2ML/+XMKt4niDTAOLMqPRAle+UXETRYdVRpiz7h/OO73Eyo/MXT4dIzpGI+BVftkxArP8LgB0aoMxbcOO5uBFpPKQhGfDNLmmmdGArnfVUafXUbJlCPX3Jrh4/3E7bhxoEJWH5yPB377v7/ix5//jvPxQAyrwtWP1w9OdOwYj3tWeU8A3lhhmyUxHmzBGo7zfsKa4fv3r4TBEgLDx3fg6csL+q3hvD9g3dBvB174tx9+foEdACYww3EcgKKaSjJm41SmALKGLlHMEWyLCxIyR/UDfeYiVQG6YjVkgIgKa1Z2tZhPeHhBPtI6Pz8btrw0fHr5N5I7p0xHBLE+Y/Rb7iPxviRzsxS10lJzUMC5GnvYE3+Zlsir7lp/zgAI36qwkcyiT0ZdP+mQWewCgBkd8v37ud6YXtEmt0Ac6d0I5sTI39PPYEuVGbIm6YD7La9TxnuFf31oXZlP0jhWd4PjaSmzCIBBg6JamxWAKYvNGcrxyGs/7id++OEJ77+dwJeGb7+9ISJwf33A58Trfz5w//0rfI60Lq0DDpz3sfjJDBYHo1RG65+bb565sjaZVmCpx/F0w5wDNhMmz9eOd7uj3fg5OKyfuD+d6MeB8e8D/UuqgTkGjtuBL397gUfg9tKzxN4bxsdYB5HyjJXDWP7RwNH1jD6NmfVDDWBUReN2kMQ2JlxcOYu2CQOxq8eq59l9BjeMlmUZYkRraoTHgl/i7TkRbc3ZXRgbhS8XPIoKWVqPxLzU3qAwbGg54aRGkzLht5d0jDGqniw8qrNNJduJwYNpEkEkrKSZR7VqQsKOjYmdRyREACcFiknL1rLGSh2QZjk2ISJq4EUpnHRwshehAfNcsNHcysp5WV1aTb63Dm8JtEgYfPQM11r0uubHY+L+deCf/9c/8bd//Iy3b6/o/YbH2wN+5tCNZh3wG8ZwHsYZaHBYbzisQ2emqIBVkTfrVmUeCv2jkXZUauMcKQBVSn/mNXxmAAc5WHDeHef7O+7vr2j9yMADBf3phxvsCXj+6RkvP71gPBxff/0DP/ztRwCGt2+veDqeccAVjWKZR4vMFiKFI1FDwFtOtXB33LrBjoZ5bodeRiIn5yExKk0oZ63aFPMh58aAirTU1BDmXDIC5PmeI9tRt2l15xgo8bLlN2ggRPNWRWeZyU2raH3TiMa8Swm1hDnD2L0d1aYbiFVwB6uit/RHCtmtvhMw1xCB8KMigCu7TUjFzoXUhla4PWc7RxbtUbMLAkXkGYEVbSsnk/5HT6KYZxZbuukIAM2ZeU5r1w+rxXt4Ou2RU0i+f73j/HDc+hO+/fYdj7cH5neHvzX88f0VMTKaFo+GZk+wkWHfcdzRjxSE3gGfycStGawHYgR7zFNolZitSGIPltOkMg7jpMtu6dyT1geeAQT8wy/WIy/UEA9DtA5HZ1tA4P464MfE6y+vsFtDa0+4v75hvAHznPCH433es00WLC62BnbYb1qQWDh42KW1jjFZTJMAPC1HD8RAJlFcOQiUc7wym8Srs+PzSxq9hpSdoDPZqs2zN+OgZgCWDKcjrhS/1gy56YFxY4TqYNIOSt5Ja4EjgKRp6Q+05QeA/obK2JP3vSwH0IAhjczcTA0Q4BqbtH+HJMnCykpATm9uddKcKa3s7lMImEwfwYKw3APoJKPzuLhoQKA/G8YY/C2fr1njqbwGzIbzPnB+DPR+4O1f7xgfjh9+esYf//HAxx8fOI4b5seJOi2Y0Ch11wl0wDEQt7z+rQFoI599AoYj6eKBOEeFxfMYO8COxqJH58R3glWVgzjlfwYONM5Z7nBjy9shfcQiSK2xkz42Mc8BwY6GA/Yw+IfD20TzWwr96QWBj4IxAC4nUIpJyosnYel41RwnM1gL5i+8vlOoxVSlqsQVCwmFOeUgi+mQeBMAo196aDGbtDXS5FtLRo5gsaecLK55BIYP9MneAeKKEANtGlwNOOUnaY+EQwlbQKFIK6FAhgQlYVlvvYILNVdpjx7MqIToioJH7YVZZvYVgtMZh2ZthZRnftfW3JyEkvyOKqqDDq9ZIGbmVx53x+QQ8V//63f0fsP3P76hoeH9t3f4CHx/+gHn+wmLhsc98w2tG3zMxOddeSg6tFtE0bk+CT2QrdGrx0RwWsnlRAuzBINRuOkFuRsUuqf1DauDfPIDKUQFdyMtKVTRsM95PgcFSIEiIHTkABnkGL42BJvTbY2HCQZYqRnaVsCuh6a4OgMZaanw5LbZTck4Wqg5lcDLTadzw1VwLS21hhJ7WaK4Ctl27C5LJ/9cmLqhwTHXQfTCX0BGvrqnD0WhMPYmUF+hmn+wGnMkDKkQKEwmy5ODsceY0FwV9X188nZqI4v55UJb46lNtDDUUEYNmmtYll3lH7l+wdls+p3D8fH6wPOXF5xj4P71xHwHXr+9pnBYw/31Dvg7zvc7lK+BNZyPs5SZ9tFVMlK8QMXntPjYIauYFuVwA8j3dTY7/zbHRDuW31kOOvND4QHrsfpLIhBwjHNWZDUeXv7e3iOviTa1Dr3peY3WD1jv0Mwt8dtx1WiyIpYOpZBT28y5KKIHDZRlyN3hYTjSlkjGmdPkLjCjSaZSld8UQ0sIGVPX//aIWDm2UbkOl88CQCN20o+aiAh0ky8gtgc1t9V61XyTWoSM6w2TZfxmrCb1fRZs4988m7QsGVcVxdZz7tUaH6MdQ5G+eInlqhLQTG5SYTHjX30bZLpgwKOOho7GSuKMKn28DXz95QP/+LcX/PIfX9HjCTYOfPz2qPMy5pmMedgPmGOwN2NFEIMDdY3HP0jzBDc/xIDhRcdSWlsiqUY5Idh5SSiloAl5RnmG3jKXwUQTB23kc4ZPtH4wV4BcIy2BU+uUcx+KLDJ4zSU5GdgYMFHlQSYCG47VF7yYAyFNJAwDEicZY+/bVhQo5uZQVYKF76lkgwmy5X5sUMqsytarZAWxiIvMnB9mGNPzth3stAveUxplDZBu1rc1eY0LqrCxx3bmeSsokBuQ1x18Puub1pGwUDALFpnMegpDnvEhwcRFyBGEH0n8UsWuDStTKKQhy0Os70trB5IW54djDuD+9sA8M7R6vg/8fn7Dx+8fiPFAmx3jPsisrN51IGKmAWwL9obWsoVPtEfAgnsurb3vnwuW6ykbEQlzJ2ASjDV7KslJNDLXMGggB9qx9yOMgtsypBWWUbGaUIlFF1SdVy++RqSgG4V3jpnFqbi+DkgLczOhL++AnI9WtftlIEHGWmawGLSYYFkYAMl8kYydZSPkJE/YpX4ODy/YUcrWsmZIjUQBx3j4wqxQ5yIwTiKdY93bw9B7ywnorW01ZMlsvSehYCYIDzMZN0PjOYZ5scwD5SE8WKHQTfCL77e/K9eSQpB/k2vh7C/JHJJRm61dcIuy4uE5gV5nOD7eHe/fv+Htnyf6ccPb11fEmZbFR+B9PuCPAMwxMaDkpSKEVYncHDFaRRzz0YMYtZVfFRGIqaiD/DUqSWzYXr5IWO7FXNp5uqzIhM+J4/kZPmbyTBj8Ppfv1bDWAxa8NiT8HFF0233IYFNO+pppToMJ6Ira8LN+sp5XuR0LHNUItG9kIwyoDj8UMaUWZV0BEWsJ0XK0FaPfrYEWjsKOy3tm7oTriG2omeL3qgfqFsAjcLt1zEcK23wY3A3nw/H+/Y7npwPn/US/dTy9HFlSAKA/tzzE82A7LWPmw8EuMJoE+ifi99TYiw4ZhbHyP/aX8hAi3Zo4oS6/5Y95oAIPFdqEkNcGUQI5yCwAzIb5Dnz95Tu+fPkBv/y/vwAT+Pg2EPMNrXXM+0xmVsOGWyY/W89QrwdwNMSYy6eU48pcVtJiQbt4eDIkMkRNs7gihgAwLRN1Zpcjl/2kQGYpAK1dws/eb3nysLV0+HtPiBcGv4HHu7PKeHINzP/IFVh9R4DPkdl3A9rtSObXUdyTTcusx6laQXK70gmHV7mlzGZsRwlsG1y7rKuhzGGxTuHiLY4PMJKR42UyALiZvYtUbpwIuxx24wBsElOerPt/Nfzzlz/weJxAGL79+h0xDON9YH4M9OOG8An3if5y4OmnJ9y+HHj68QnWgJ9+/glxBJ7+/pyb2ABrfZ1b3jhWW1GnDaxu8YjcGP0qPnbWfal0PlYn4Jaerme2YNRNZdSxpsVrFm8e1tMwPwJvv78jHsAv/8eveHm54/51oCFzMu04MD9GFQ6YpbMcNMXhbVk1hbE9Mq8wCasZIDA4S1kaYjhiTORpKVFJypiROSg65epxBxlYQ9QWOoniB2cDSjPD8FkMG+55XmKDnNpVFd2T3q23zAESIkc4fE704+CaCVcHG/eGBp8rOx8Jtw7unwd8Tjgcx8sTDsX+FcbUf0uj6wYlWVimKqxwYvUhqwkbW3RGwXw6ThmWV7wx4UmGG6W5gOh1N8QI+EcAZ+D7H19xf/vA/f2O47Xj9V9fM7owA4YjN2VmnsXfTzpxLRM7f3zD4/nAN8+M+28v/wKeDE8/v+B4OvDl7z/ip//2E/oTN7gHjieDn5kriJEwzQfXKY0Fz4y5NH4P6ABKMaHLnC+XZUWhqi15UNOD6XWVVGQh4vv7A+MMfHx7x9vvrzjsCXZ2nGPAZk9Mfzj8nFn60460AorUGer3UBWjTo5CluZ48OhqoY+ZKmHCgQFYbznsjgzqhCcxnBNGGtDX+RlytBUg8Yezwjng51jdnMYQcW/Fb+3WU1HfWiZIB/0KnnFu/M6q5evwecIZyw6wxGkw4pVYNKs6OjA/ZnZwHqi9CfK+j8mTnSKJULkNFs0FgDWEbHsRDhn9C0Oa3sLKYaVlo5ytvKIiKYoUyRlMRWWpCQCMj3z4r79+w8fvr7j/+or5NvH4+gHQUYuHl1nOwxPomD11mKVmCouqmbFxIO6pLawB/grEa+Dt11egA28/vuPrlz9wfLnhfv/A7csN//hf/jv++O1f+Mf/+O9AC9xebggALz/ecuN7Ot1p4R2KwgWhk4xE660KLO1IpztrrmxZoiaNlgIZ0/D+duLt6xs+vr3h8TaAk+eJucG7M0FIAjYAPsnYUQEJNy+IAQgWKvMuxRQIKiYlGLNrkxYwR4sgYlZ4V7SPCNiR4VTlnnSuSkxf5e4KRPBv/egVQNH7pYhVPR2Rvgf9ymmeY4Qi6Gsg951Q3uhYB/mwWJYtsEoJZKSMVQcMGpTL4BIOMvimPqTWlrXYIk9yViVERMUVi2bxLQAaEDpjglCNjiSQCR9nkqYB8DNrZ+5vH/j22zcgGt7/+Ibzj3fM7xMdHXFmIqr1jnOOrBIlDAKyXMMGEHRQCvNOr1CxfCJnQFyJIL9PvN8faN875nzg8Xrg7dfviDbw8fUdERPHl2fcXp7w87/9A8fLDbfnA/1I6zFnOvP9OMpayjpMCgUQLDfxVBhhOCTs3hgiNrx//cB5H/j4/R0f398Y6j5SyEbmbZwTBO3WE0dT49XzhFfuAGqFVsI2mKkWDnRAZ6PngTsNNZIl8hCj3niOX28aXEwozu8brdYNiHPmOEE6wftxZunMO/DyhNC5KMBi7F0Pd0trE5Fan4JlfR+kwc/yWX3OLE+xtP5+zu08jkRDyXfJr9hOJEu9kL/VrFxQk8sRl/apV2w5BtqFah7hA3mgznjwkNXh5R3AoEWhuMbI2vrHxx3j/cTrb99wfjxwvt4RH569ldOAu+HwW9YJAUAzTDgL09KBbNayBGEaE35Zd3T0zpIWr17j4HCk4Ho1mxcONDuyQebegDvNbDOc3zL8FU8P3OMDH//fO24/PuPnf/9v+PLvT+hfemJxQhHQKqiIMQ4yMx+/cVRMR8PjfWCeAX8AczjiDHz711dgGPwxEXdOzzAgujKHyRiy1jrNNi1CVEHhHGd+N6yc2fSt6Igra8y8gybPRMw8B54hWUjwYDAqg2rV9QkfK/sdzGw7sP6mSNEmCDFUdxYr2rUJRkabDFAoVqfskrzwRAp2S2EN1bHJQgbPl+TMMihAIMUgQR8ADqvqB1jmUY5a0CYMIS3CKRQpDIE62w/STBm/LwFjKC2cJSOutIshTkdz4Hw/8fp6x3gMvP3+HePjgfF+x/g4YZP4sAE4G5qn2T/ix0MGNgAAIABJREFUqTRHDg3IaAhuoBPFCk9BB8HCCMAd884aH99iszKlYPBgBuKhrsFcdQtFTg6gpVWKR+SIHjsxfj/x+PWO9v8Ynv/9BV9+/BE//vwjPAJPzx0frw98vL7j1g+8/NsLpjtuzx2Pe2bPn3rH+7c7fv+PX2F2y4YghmbHxyDcMeQBKQb01MzBnExrWWiX0CgZzDTrR4Wk9HWUdwjzVDIWZSlUIt66we8DOWk8y0OkgdvRE8YcmSWPkfvpvtbjPtFa1o7Z0QnJ0kmfY+Zky6OX9g4E+u3AmGf6VmMWtIrdR3PAbgY/R2XD4eK7THq6Sj8KBRE+KqTbBNeoDDzSoSeNbLYKoOR4J8cRGqFf/RRKvAjP0UcAqKFAh4cFZQH4ZFVpJ+OdjjYdHQ33b3cgAq+/fMPj9Y7x9sDje/oNMR1wYN4HmrWsR/rgRtBst6OnaQw6ughMDEQLHP3APAfMgTFHDYMA0sQ2NrCYBBcUHKmpkaUs7mdqwzMtimNAGRpVw/ojnVybURgaHpjf75gfgfP3D7weXzH+1/+Bt6+v+fZg77c1PP/+AhhwHDe0IzXdBw58/+Ur/O5w3OHdGZRI5dPYlWa9w+fEPCdg2a0Xw+GW+zbvZ+LpGYieiaRSWEPKNhkpXFCDmfCKSFrmLQLMK1iGUcloVTbyWBnn7PBLC9I3zZsJ4WWRWmf5Ceuozo90LI+nG5y5kjnmZSCdIpympOyM8hlUCpR+XBYz+pDgkQEIH33mWRWFYtQ8J0vSFABZVi2Y2TrmuaIVKdA7lIr9n0xCATh9advORF6MTP6McwDvgd//5z9h0dIqvD8w30/EQD6AnP9BST0ZW2Ys22aWLLg57EiN4z5hR4djwmf2WMQ5ciOYtEknV9jWK5kIS2JXTJ6OuwGacJzfsciusUghdExmY6kFEo+kmeeRAvAAHun8tVvH1//zt8LVRjhirWG+TzjYRNTTD4kBxD1w9FsKxktGDf3jkT0kLKTyOaCKgRgOb4QpY2bkpbLryOpYn4xQZabZTCc9eq3LAlW6UaFNClEEEPfJubbs0ZCWZbShHGDyznyMZFb6MVG8w+CtHPvtlXBXyCVgT9nlqKhVHZQEoFIOE0QKRCg+l/AxRxb8nAIyqkerZPHB1EIkPeFRFqpQBwLHOJmRlPvgMr+xPqw4ssoU3NBbw+M1C9X8MfH623e8f33F+f09own3wHi747jd6Aw34tB8+ON4otnJZFyDVf+vRuBgBuZjQp1gfUYeBhkdLVJT9WaYnqUGavcQ42RcgZGh28rTmeLw0hpqYA05bZsyOHLSYTYdBUwQTiac5RBxBnwOPL7fcfvxmZvBkahzYn6nsDcURJOPMyLgp6PNrd+jGwVkqzawLcxpjf0ttHGRmtXHrM8jgMZBcsEQYQ8A7DRMDC8rk8IU4Qx6JKMHGdynL1hkpFtsPAOGz+fISNUGn/RSs9z+mjrLpKV1qigVkNa8/NYsGWm9MbCB6nXxyAjlLpTZ3NiybwW43leWif6Ows6u4W6uS5Ah8qQlT3zL0oU0Z2DrQ+C8nzjPB8bXrOA8v70jHoH5NoC7r/i8G47jlgfUnIHejurXTetgUB+1JBVtaWqwuMwH0G8GRMsI1An4CBxHR7wH/HlWj7chD49prV+64nL7RzrjB0OuNK2h1HSVgQMAo1jAsnCzcakG9E4hyZBwTM9BEC21z/G3PNUhAjjPe5Z4RKDZrTag3zoHiAXmfCAsRxb7gxMRG9K38EksvZisH32L7au6lPCldcSRwtF0NkhKYmrY48gq5ZkWLDbmjRnMeeQ4WCkDHUGRl0lfpPIRLh8nBaSgVESGdHeh2CJRjWFfM4PVEdRYlsJ5PQCa7t+PznA9CuL125HQHNkfngG21PI+ciZYCu2q2BBkq2AGrY48CTgPFAVwNJZA2EycywlNON9TW7z98Q3dOsb9gW//+S+ET9j7Jo3N0CYQkRp0xoAdhtlOxMGMqRqDjnT2D2JDZzWoj7nUOrCORHvKCItHJE4H4DHgL4Qx3tMxJ9bN2iNkQooJymgZVWuNkS/2CyguPx4P9COFN9flGTKOPHUIlpllYyjSmJTIAro8AjqHTmZRop885MZy2okzq9+e8vvzDMQ90NATmrVZER87ctxMnr+Yu7UXdGZkJfsGLRSW5E40wONEjxxQ5izz4KYmY44B77cc3GYatxOXUvPWsu8jnev8+vF0wMdEbw04OWKIEeL5mOhPPRHBxui3ls+Xe+uwQSfd154H5Dc4ukmYeYgBo4iIPNohHik4EV7QWQxOHZtZfGdUsAE6LzAYyZOv2Cj4/ZZVCdUqboZ5piJtR8MxXgdef/+GeQ7MQYcwOs73D/g5cb6+Z17CgXE/0XtjQim1u5rwZaKsNR5jFisbvPsuhI7+GCkPdTZgcFGdUAWEEDTFDZXgW9e0Mt8RKl1g33KnYJERJh1qWOLXNibQM+IDMD9C/6vKHfhSNWlML2dQB6sYUCFtDzqtp1c/gaqN5yM14zizyV+aVHVGsOx2zF7tE24tIURfR7GlxlbCkfkMqWeGVZ3CBgjxLOwPAGCkyVfsgu97DkTjzLEIhtLb6mqs4kohBGR1w/57lXu0RCNTESh9cc9LVBY9ECr8E4OA0J7OsANo/HpmvpMOPh2dfmzWsOnB+eyt2LAcfr38dEw4DlrBhLrko+E4/vN//594fL/nYmdjgxEwz4wgzccADglNxoogE6R7GTPBwU0OSq/i4zTzuYAkvnOxPgRe+Vk6dNnzEWWdjDNvNfeoP7NURAuhIybnEQ2ZPAKAbom9qR37wTmvWwKqJb5LqKMmEwejHoFQVjYc/WBod/9+bxgPmmlzVs0uDnSfOX4TpAE4P0n0Y8EdgLw+ci2NsDLA8+qswRpbkQ8KLIVKGW+fuUfj4SXY2gv0hDWrIYmRSvpvGSWa5bNk/iIZ1raCTJ2Elck4XzB5IuHoEyoqJL/PRpRA7JNNKkGH9R14Khl0W8pWL4b1FQnL4s9VVdvEeo1uAYsIYIKbortVJFLh8HbIghqO8euJHj17Z5EJJFjAHoC1PNTdRhKwsq1tWyioOTW0ICKZQHxhnHzE0TIxc7KfORB9l7JkkDlG1dfkccKk1SM3XFjXR2Zd52A5QM+6oOCcWwwVQJLppmBIWhuN9wQFCgeq1KGVYx7QdBVVaOR8I2rV6lNOc95vDB1b46Eq3PxQoVwyQGnTalBClvArmEDFUllgBOkhrZo/+8lhAkAWDGJSUKyshzC1InSYZ1blkmkzLEshmQ54OsW9raF7JgecER2tL7PLq2UVUCCHUSBk9FA5KLccehHOgzIJqRBAduQtIciEZfqExqoMN83fBccaZRK1ihTnYnpl7zMiR/hF39mQwmIaY0DEIxQQ9EePeIysf3JbRI0cyZMT41olWNrTkZLWNPLclulWb7knBX1sUYCLRpAjzpLjMMCI72+tNkLJo+vLCtcKd/ajr0QUUtv6fbLEOR1vWNbrNx60UtWZnEhSSSLLKNwSVzKHRsjwmZX4Cc9qVMrYNoBODLzuv8PPcobZQKVyinYk085zlFNcZR+0RkDuSc4Pzh7whG5Jy3I4QZglHykobI6tyljrXyfGRlBxQXsDlngkj8T04gtj/0m2ImtfrJSgQq4YvWCXN0cbqoMjs9qiwaVJLjLrffQDg1bVujJQzD+BFsxaoZUAYa18zWBQgHpmilehgsVYVRRi2AgccWSUA401K8CK3sw82BJHQhp16kEQQdnLrdlI53okhErmK62jCAu5Kc4UutJesVJS8ECcCXCsJy7PuVVkypYhxxouYMZEkSibv7dby58PmvimjP/qT5YQ+vTS+EHo0G4cssYeX2kVwU8lw1KT5rPF6VWukaHqnr4QnNP+eECQliphpOCrb0Xl3irvVkRN7cNtazFVY1aAUSWjEIj+BugUYNVnAciMcVMWmRG5snrJ+KpbK+f3ULTPafGsWn3SQjI7bsH5Xikk1YbcDDZt9frUs1+VoUUqMLtZnmtunFaCuJal6CLkyZgOu6WD70cq3oxM8f6yJFQSCXcnBSlKMR8ZRdT5m8kUzQOhikVkXD+Tb4xJC79WyyyF4rMweCzHlh6VTHAmDdOPSYG0S8RKDngyS1Zget9DWmB1qBiFDMLIjeCTfKeCbmQ2mVgfK8Qry5PLsdI+WVC5bR6Tiu4ZEKn1C4Y1rY2fj6hy7qaz0CNzOmWh+Fl3hmm3a1aX5cEkJy1YNgRlHqgmlcjySgPTyq3emKgSf2z+vLEb047tmS0Kt6+N1P7k3qcx40SZyH70fuvpF956OeZaX1jOtRK84c2XlS1eoX2wDETo0NEWVGq2fINMKBMSq1mNflhMHc+QQm9hCethtR6V0As9KOTbsjza802ZTUwoI2uUsJiemoiYWEwkTbpj5dWz8Ol/NLXp32xMJeJsTJLMr/izleNXZfXAKhQDGBePdX1fG1/wqJhVjIxKcmrzYybjCL5FBHBIITgUf68rx4rKFORrvaxAXlMjZpiUa31Farb/KqRaa7Ycqa920IqaYfkLUAce/aQcDrC0+L4/YkijvyWLv+YIBC1WrJxBmbdPwsG9a4yy7WFcFUPm8dx2sczaHyWUVdvkshxSsMioItjno0iTkcF1P4+EeardiqBTXWH9qLPWMWLljUiTWvdnCO+BAzNNXD4UIdGxPpjaLar3tyolS+ssk5ybGhU3xhbuBICag0onqYj+KcQmIlQE6TFy8Uo4yZROcrcDdkusnFPZWQI/JteQYVtzy/H5JHw14LMEpd0YFxfEODpUwVsCYumzuJzHDqgpScEpV0y9cDLnLRGeLcshulsxhKxOhWNbhhxNc3R9wqd6IXgd9tLoubQTFSmsDk5p7lghUDKCI/1M0bYssPwWXwEFMaXG8Qiiyvmec3L85q4gCEcP9btcT8uCR+VOfAKtJRrwCfjJ0TR9rSGmZ4l60SmFJp36tELWN8E8mY/aezyc6+osukxpLQVxxJjZ+sha+RYGU/hrpNYck1ldM0QwyUXn2BhxUj1KhVfH0lQicgWwIi7l8I0RIM20ktavGbKHrYpgj2rtzD4GrxxEt4ZojIrRn3H5F3PmiHtifj99dZ2pjVR4k8w8x8wE2H2WSQ75Pmc++zxTIs0C5gcAh3lH93Q60R3hA/a4ZZlLZ9k0HLjlRrUbcmLi2VQelEKtIMN04B6ILwG/JV3nTLhovRdzzggcD/kMWBAS9KeOTnQAGDp8WCUKG7Zj6qqdtsSMFmtZ95jjGs0nzEVE9X1UgEJa2cgnFqvfApn4PJ6OLFGx4PRECrWguVFQT8Ik+cVsEAs3fg//f1vf2hxHkiTn+agGSM7s3a3MZPr/v0wfJDuZTHu7MyQBdFVmhj5EeHoUOKDNgAS6q7My4+Hh8SjY8mLD9ZyonfV1kXyfHAToRg4xs2x+TFQmBSM+6+v0DHMOBudcjt0ovBTKhFHn5QGMRcbZq2jdI8xzbZaHfLkhNiMKwlC9b3hTjQuojxCKVKTmdTR1j3W8Mz5uPebzckqvqGLWALcIcQPF9FgEn9MacVVYsZ3kW9htmBSqUqPhptVw1wFHRgS8wThNM9gz8gKleDC/GKuYP3JtB881huUtYDrlWr4U2IzcT43SD7hQeGl+QN0F2Aj4dE4gnqtig6YghJoBZ2DoteJhRCQTbpBKtPmeBUCrjBLnFrFFsw2nfKRVUSlLkCprDclQUOu82i7LCdJhU62MGbeS2v3v4WHnFfCpBWNWFDOR2ubnucKt7UE2aF0l2nDXJhxuicwK9B3hr/iwXBxWDOazmm9sSjW/kK/dtiCVpsCWeH53fRUFSSWCs9rudf7s+PIJ6QiqDyiHbYuPiAdqVMXWHlz+sE0nbuWIYBv8+JiqxwMBOwgJ60oRwgsa0IYfSj2itdaSoSgQnid1GwnMnZOYgkwb08MpWJaTA8BqA3jgnmizYMla8RbbsVAvQSSs6Oeu3qNRI3ayhZ1oXHGuK8r5PeCncnh+hkiA61ujbuH13FbUm3HwhPlDLD1YXjtbTfEr5rHIMrfy9BagvCBit7KCIWybHSV8QpyfzyX7pCyFzBPJhhDoYhvqbflb4Yp3wgwoh7cnkLXEgnrel//M2aqg7TYuNQkfGZ0tP4vC7vX7iwkgeNJrPede3FrRIw3HjaWFxeVmRb39Hh0aC1yGSESWmLQda5jAhBe81WCinAmJh43EMyWYnCosXKNCN5dsr/XxgHHz8/R8/JraSNb9EEa2g3VEqn5lQdw+YABY0bwTrJ3NU3Dxmrv8v/UWOH2gGBtuCtrxANtea++Rz3GFsOGdd6usXXVLi3CrZI2R/CtIFZ8rqymAM7z9iqanDY1LSpoBO3j3ok1zlu4RyjT90de1uVFYM56UFKX/XnvVFQuZBLiWCtRQgDkld0zYMh6t0JAIYBsh29O6fR4ZvaAnCqMSnGTHCrVchraw26drKV60aA4xN3oA0EnT+Xj3ijWwI/ka7YcAdo7DhgvqGrS2xHhdHXZjoT6qtNi8zZG89cQIwXR8WV3FMd5DkA+fuYuGKGGZcqGpbgcxTG27xsCUtTZPbBp5dllkW453Pa5YuqcSMIa0HjzoJGMz5nABveJApkUA7rHSGobyMBSLxJcZyoBn9g0o6wPT3FLau1OTe2B2NVgtaK/Ng8la0F4eQKkovaF/ed390ejAXBPlsPC8y/c3jFybNJHhPao8Ru0tSlYih9MKOBRuA4BZYC3VQ0UzxJzTy/etAM1rkvioaxRg9RZ97i7YJc4CpWJenpSttUWcyoC/ALMoyRx1chGRhX1yZbOo4TLTcz3W8n6izToRUkcFwjqHy5DVfe69RUdjxNSeRwt4FxNOSnO4310TPUngI1386aR7eJYJu4bERNn02oEaueGdqOumxNKKpFAqKSnhkWpzznGzWMl7bWjBkpQrGlzgeQR+MYvMDUB1+rORtQBhg8O0ViuGDQ/Yg9ni76wtdHSnB0k2hLexZZ7BD6Xx3hMeivcje1uvVxiXtbDOifnH6dBjvW8BXm+uYGsayqtF7AHMIxTgAuzr5YORXxvwuz+5CI8CvBzo314xTh/dj7ocntXm7F1UvO5+ik8ZZ2LuHtUC1+lD79bl5IMzTW5mfVave6aKGV15AJpt79V6PHfkvMBe/NoaWlRWVA7EXuZIoDARWW7e2oKRy1875/QIoxhxOEOE0uCpBrMoV8Eu5SHiKDPFIZStxXgnKOcw2mFfg1EzdMd3CmI1QYy5Cb9mLW5VV9TIuPu3EPqixfUIduPfq6xIwsUNVYDda2vE64glg3rbRW+k45gt49f0A+KTQL03ynbuwwP1gGVn3FsUz1kUMNKr2cTO8rr1lBVqtWAEK2Vl7m5Hv8947VjoEQvNeWI+B2wMIPrN7c8JnMBqC+2l7s0HfPLiqgY8DPVZfCzRwXjJDdX6MXD++OFU8ksBfuv4spya7t8Ov6fu53PZ3EV19BoMwmtX7qV2de4dX3xwgTc5XVjnhXVyUrthWnGLP5yxY7VBe7jvxxiRDPWZxOta8NaVZMEiT2b08pGcw2Ktnp8Bmccd+JHeDUSyvyj4hYWrETN3p9NX5KpsLlgvG2H463QZXpJP58ICSq8bSfSdzKsxexUINifcDbOQLS42w7UdZdfuVHjHGqImn48lrl1CuG8imKIa8AHMIwAO4fxZj+6NYkN3Qo+b1hB5Fp9C4jx9xF0VKPB5uFvogfA+EbzuLL/ukQ/MYSJpF7hdE3YgMUfmNGHEE7XCleE5MZ5Pryo+h+c4VgFOv68yATudNGB5wurhhQ7s3AwuH+CGtVC+NtRXP+w9kvPPE+8/3tH//g29VsyPidYP1KPhQAsnUvfgi3VNh2xH316umGF9XBiRjG3BNFzXxHoO4EPsjjNn3a38ciEqHRgv8J7zUtFfH1hlRtLPUwL4ckQ/SMQvtag8BQEOWvSULMT0kDB4gassZI4zpXZbBEuOmMCNfJNFgayFDDIeRPXYpYbijee1UYHBgEPxp4Ma79/pDFR2Jerl9f58upMP9oLj4hlR/QNh3op3yRX3d7U1n2LXmzMiUXFql4nq7nUrSgmedQ8argV7rmvzUoEyog4pniS12T2Loc+JhmUxYalwjptZ9eZl4BZTufcTmyqDN5N3IhMTtV0AUOKRvYi6HrsW1seF9gDm2xP2cwAfBvs5Y58i7oBDrYWJQLAeKKKirerQCEBbXm6xwLgoWmZPhyXtiAOOeidYwfjnO378ecb0jor62tFKx/zSYEfF8RJPeF0T9mFY7cR6Hyh14nmdPiIz9nGZeR9/Lag/vPekfm0ec14A2vTHMx+AvRvKA9E4ZihtYb09Maehf+2xfqBHg1sQeTHkwA1MOxrmmrDJmMe96XpG/MaEoZF9Y2wGlIn9dNg6y+5fKTSaxQ2NRS7NvRu8ihlB5ux4ylk5Tt5XtYEbzW4fFr24zQV5QoOnpmpe+DRSrz+hb2KHHXZA6t4h+PBl/sxoc8+zngocrXt8wrjDSMdN84JCrBgs7OsArUpYV4s18BnqxjKFSUX34NEuc9gAL1RkILYt2WvbuBVwcsHroPz6/aUAY2G+TxSvk8B8Xpj/esIewPxx7Qd/ViDiB69gnbgQ244Fto1GgIkFczsPzMjoY8XDLQvKVb1EqPt7DPDJJ9dCeYntPyfsNTzyWTFLxTwr7FGBR7TlLsP6Od1oLHOc3hbm01kkwLBOx+YVBjv90uttAi/+3vK1OKt0VB+88Czorx3zffmjxFpBea1YH5fno2rB83/+ifb3w0t5OlC/dpTZQ9bCE0Xg7tQ9n3u4vB16AvUoGyZT3pYZ+qzAFbA/WNCtQKn6grLp+wBUMy9AZSoBwYgHjC6tRuISWB8LfbForbjrxsRuSfXAJfodMv6rDoUqPQeZxGIeA54TqAv1iNobc1hRX+pebCEvzUzpgjzIETc74VjQsJNlpThnvi5Dfz0wrkuxBoKSbX5t1nD5EAgnB/qjY46xM95eoRlNM8V8TBC8nXOdwy3Jx8L454mylgvonCiYKB8FbsT0/AkL4Zd6WQg3f+qKsBNPMEz4GCOACSlXrHJ63/R6iyux8eq5PLs+DTPG3JTWUF9icsuz4uoeIPNJsiVKXOxjof6tbhp3Pt2yeomIe+j2pVOaPE766nkBDKAcDnesA/jinr79m8cO88cAvja03tBeKqotF79VYH+eWIevdT0P35tSo588+l/4vLbmz1dBVGEvCnrU4aFKRuoMGBB9KEww1lajSNF2PGGAs3vxNUhWEMYvbw9GhBHdtRMRkEXiC+6dVjHg8sP1ZzO4yy8oMcK+gE0y3i4ZCb8eqoq24w1vOlpeonJEjLKAacMt52aq4FTtYPk4Ys7SCmam7KrVYssHuYX7xeExzCQsbEA1H7dPKEdKuga/Pz8myuFua50TNi6sdWG+X5hvJ/B9cSfB3o2C1NLJpJbbvK0IKwl5MOoIAhQLPto0HkMPxG+oLlGp5Qbh5FG6cm/oOYPajDXYNMy3gvIR+/ha4zea1tG+HJhtAWdFOyrWM2KOo3qytwF48W7Q8iWg5cOiENMp1kLBLOZkwot7J5sei+FcmMXQSsF693jJyzIMhb255+UU/Rqw1lxRXo/IIc2dDMeqMFYo12Ap5/J6q+hE3LOuZiCCnvqISiCE5VCsUgYj37auGJXEGDByY2UC9RFA2KrXvHsFZVfQjSjbJp1dHK+zPREzusuuAry6YLqGwyfjLQNiaNcaC/1bx2oDc/h4/Noq6goLGwV8axlqeCwWOO6mH4QCmt/gulYMSENY8+aep7nQFHrA5sGw/9pZjfZoQATIWMA8L6z3C8UG5jTMfzx9ogqA0gra14rxJqUo8KRkAVkPqQv2a/y5fM0zYposH++vKNEsYLHMvrP8gl4xVSRqtXZR5/JpLVSn/UXlfysR/F9A84DdHtOfmPoVAZEM7VtT09cA7BHx2tFg5/JBcic8zvwauapgFOujOIXcgfluaL/5Q0JrLZhvYxdHrsk26TByowCPhRYTN+a7J2bttXlff++ammSxOwxeWEEdXZ42sTP+OCKY330uawfv1SKp3SAKeVnMdg4PVNxD1e75mL7iEbwlhHqd0duxfJjBWtPjhWugvlS0l7I/wBt3qvPvsUDbFtAAq178FtSr9zbbPs9l7kVqWPn1MVC7CxJqcb55LO/jaBEXWAWuidIOp1OvmExixb1csZhc6J+z6E+PUA6bPoDkvJzBeg7UMrF+Dqzvl3u854LNiRJwh5WhhoGCFjCIquBwrkGVrSuEuqGG8JOjivpr1J0IbeFXomjhdk0W8uyhZMGo1A3f/Kf8WSDoUJaBhYmODswJmxPzI0b/dL9yPQ3zbaJ9bT6wOeSnPoD5FnCtAOX3ivUxsMzpZg7htmVoL2qdZrdlrQXzAFY3n2MLt8Q8i/mMaoDl+aL+6g8ZWvNCORpWD3c5G+pxeEJ5Ag6fzOFY0Of28EWWXndN3sQCnzVfbaAeBeu6dtWwFcRstGTWgupfrBqYC30nVsKCLQD23VBfK+Z5OXwyoLxEoVk1rBHWfCACPLj1bu456qtP3LBpMS+3+gRyuFaXBo2pjNJn5kJWpPIrcxC1xBOZIqBdwOrVBWQ/HL3soKwst9iF+YLiYybbt4rrx+kl32dMUcGC/deJ+WaR11mgVe/Oc4TgTn+EWPwh5xQPHHAIioUZcCn/2+nmEe+kV/Cruu0XmKKiUIGc5dL1AKChBSxzBQuRCXVS26vvFz8zysoxPDH6Y2CChY2GdboAlgdgzcsoanUhLK14bddLBZ9rsUvXA0qvawHn2oTJuJZXEHwTvBnPhfpwaGQRtPfdFFX897PAythP3VofF+bbE/XoqN8OYDY3Xq3v0UK1Ny8stCIPEiU7gMuol+HHTkejE4sr0YvXpeV2hTijXsNQGwI+WMP1mP7IrIcPuJpRRmEWTLBjCr/Z6d6m9OqZV5/zAAAgAElEQVQJty9QMJoy67VGO+mYCFZzf1lQt1Z8av1+ZsRpjm9jKO9aXvRWEUPiGEuMooEGUTJdj4rxPgD7AGrB9X1g/tcTiLbJEZNJ6iphmXMe1TYoujBZjRQgyX9fP4l4wxECuAJKtRR0ww3E9ig9rlUiCvGY59rCXkJBuJrE1oQX4t/4eoG6spVouGRg56LiCly1q/bwlZ0dmBXt793ZvY+F9u/+nvHncIq6AOWbP1mLLci2DGVGSQ7cGM+nw796OD2LmHG8nk7Lt9oxz4lrXqhfKsZPdmsSbgKtNaz5BN4X1qtTqD4uFMAxYdFNWvvh0BvuYTlfzGIgeRGa8taAUjBPT2LOsbyNoUAVHMyb1ILujTTpSZrL0I+O6/ncH4SxgNpUnx+KVIvDmdIr2kuFdWcDbM5odo9Vd8CeAMzLh33aQ2N6BLjg43IQ9TulYH54M0579edho3nSp+58iLs/MH5YTgHbMNi4/Imp//iAvf/EHBZ9DdFbbW5VXVh452651/6Nu2ftzIoowK/DwLqEIrRoE83qpf5r/88VxoVgwFkxCnhHgwM5poNJ/JLjdgUbGOhoGOFJyW4RymF7vCiFAa0mr4EdzTQ0XCjg4GSbBvuHCu/m/xsopaH+zR/64/mtAvuXVxCvarDvy3vKhwXTVVHPgC3DgLXCWFrs6UT7W0drDXNeXsuHGH7RCub3C+ieC+m1AC9BExeDnTHhchaPU0rF+pePaVpRc6UWCNsMa93BtsvkjEav/npEU2DMOzvXZjFrL+hlXrCrAy/dCabuhWd4caVYgOPDa8WjsopnmZuzFeUoKLawrHhcMBZK6T6+08Z28/UbPOBbBfYEap/RTQa0R3UL9mKoD69lKod5fHA5J10Onx44G4B++Y1+TPSXjjne3ePMD4x/vcN+Or3r83LXjUB1GqRqNhVYe7VQodp+2/XkLniER2ULrWKDjoLLTr/PsNgdRwTgEnTb76Falq1AEzMUyuMFF2Qq2BWff4Z3mmgBk0p4GQbwAmauKH7fvHbFwELFgYqOhYKOnvwIgDVjL5pT2raw/jjRX/lAnoW5FupHBz6AimMPKAAQiTwArwUXLhy/eb2WP+IBwDDM83KFmgVlOEwrA8BVMH8C+FsBJjCuglYOV0yYJ2cvzzXVSB7aS/GB4hEjz+HVG2Sfilk8RbdilRP10dCPgvH2Djsa6kvHKv74Ne8ZqvH4hII+/tc/0f/7N9gVv/j2BbYK2iM48ahw5dNCWRJtwxmPeZofQoM34KziJR/mZ1xeK8oRLP4BrOdA6RX10bGewylBFGC4kFwfXsWKh1O21hz61Fr9+ckfC2sMtFpw/ecb5n97gV0D148BvIX7BUlMAiAKtjdmtlAD+Q1ZfCpNi844S/+vIWwKhrGVLqsAoYzHDAyiy1YIwp+1vQqJDMMufwfp4bWVRl5In4Z0BSqgq2hL3kRf9FYtYB6fn9Livlbc6YDvpSvRAD4cobaX6t0E/1adtn27ezA2uuEjlPQwRw2884DU681Qv1W31qi7kLW+VKyPhbEu4McCfne2iclEY2xzAuVLQX00XO8D+PAymWUL9ar+7BYzzOf0sv7u0GmN5SzljHbjsfzhoo9IYRSX17Iq+lx/AP/nA+3xQP29Y/24UL59hQ22Ll4+7dsATH9WhEXG24cZhxu+eGYlPAQ8gIBbcOaHbSznrl8bCFWw4DU23RkIRIJwleEplgWPVd4/UN8N+H7CPpymnP/7CkGyUAwJKanStSHIQMOBhYUegj43mWoh6oIAEj+GtmSbqCgIoSWQEVxj0JzFl+qR1ZIMVAkVk6Dzuv4zKUkDqQFegxRxjzhH77O9SioOwDoic6GP3zXwMQUI5XLLX7fahjd7HrC6MD/e/d+vh7cFnK7gLeKogu7v/J467fZ9B93+3VmlMS/sOWSvoT0XUL42lCveYwV2qlIAjwLrnizsvWH2gE9PeNZ8RslRpArahM/0jZL9sipq5Ev6u8crcxlQF8qHM2rdEefTqzT/UVHKwPE/CtbHQnk9vLTgJRI1q8BaWIaz7C4y9lh4L0OLYChu6Ioal1SE6C41LFoPGnhF4s5WTCb3IVso3hY63y9c//eJZgv2HLDA+0FHJOuVvzO9trYlJXNUt1grd0HLHLwZRK+WdMD8vsIjENffcxiZJSr7NxbXpZiWLRS23xuNVXE9hdi6tripHDPhZsGZqedryLTV+IQJslq+N1l5kD5duRT/+0QwkR/x2kdBWW0bIg6w8n/nL51JhTNiHLfDr4WF+udy4W4BFDkFptke/GGAtyNbwVzBrqVp7y5XsR9Ro+cVFg3rNPReMJ8eFtg0f4jq4Tk3tIry4knqbsG372DOJq7/fMJxcA3RCezaK8prR2mPjfdqqTvPsMyD+1o75kJikLAfEtKPyFivy+nCafvfZRjmGJgfxZ+kFEnB+TGx/rziSN1DRBnZPk4BFUs/Ix1K5F021LEIdAli5B1oXf24aLmpHBmICbZkqEZYBSDyIkgr4h8GxGSO3FbHfLCkOjyXvEaE2mZlLgmmOTOWDQZ3KKhbrDhd59Sjkg2MzyjUNbI3B7yMxQng4Yr38IqCdZ5wv9PR4BColeLT9oGkXFTY5vd+1h1vxRTj/foyY5cn77KgzmREenHW8d0w/7i8vAVBKLwtlN+cOW0cp+rVJRhzetEod+IKzx/lUJ5GAMq7n3UMoKR7ngAuGJ5R3NDSst1NrR8UNcRHVPR67DbIiYraD6xVsH4Pu9AK+qNjnAMIPrkcESjFLKjxzydQvZPOp2P4tVxEB9goLIQ+U1CtL25nRYYV/tW2Jc1RBkVI2FxgiOxUhayvK8xuAU7vY2wh2237WlSa+98ViDO4nmHxSwhSHphQk0dpn0xCS3e1NsyUAt2Th3V7zooehqIlD0dPm5Vt7N1y5DDjkxjJkX5wtqeVivatYf1YwZU5GYCQEimj9o6evoA1eCXuu3qS+IwKtV5gMTGynLZnBZQZBZSrOOp4Rok9fADFfE7gXTV3NXI6axrwewWe0SMyvcuy+wEqr0018U0/w3qQWZG7FoKuQIy65M/nOP1qf+jmBhpmcCULV2y6rGrBcncdIuN2SzZxhXVmYo3HSDHlQVJE1n4PPUIOTKViDJCDl0vCVYIRkmXPYTfi2p9ViyJCJUH8vqTPV6zgK9X1WHPtv2s3yJfD+Xwv/CzCJqR33JOABEzcEZa3+FWkvO0GOicYdWSvLMWtkVOZ+0QMQLOG+UPvQ40HoMK5sJy74Ynw7BRPubfz4Q5cpQFv95jQzuVFml8LagPKCQ+yX6uXqvSosHj6II/6WjH+uGBffVRT+7cOZtnXMi9UdOW44MET9m0b2gYdOjp+J9CqYDoJ6WZor3Ic4NbJA+fIl282nxQiXayFkLhnWFsAiZUZCbQNqaiAa1+Lw7Nd8ISny36/VI4ZbVeiEtZ77uMiy+TGYqYYQYo4g9WpYQBo4clu0SvIW7HMJP9ELay0/Fmd8t/4SrJOglj6yuwWjYAy+qm4FKKB9b2C5S+GiivYlnsMQ9iV4x+uSqBzn+tqXiR4AEevmB9OzKzp3oOFmDRirBzYAfzeDxryDC0dPuPNYxUDPIZ9i/qvEXEFvHqjlrr7VZYtrPcVzVYhS/GU4l4hxIkQOzElEmMKI1NKUgsiOFlLYlcqkEroyFkRQFAAKaAtMtIllFNMS9mfLCHKVpQHItUgZv9VaCSoFDUqmtgcepua7NmmI7dgyosQfmB7Q9lEesDPsQfX4sJAoeLa7wohQEMokiEadxhQXMHykLoD7gxtFITLqHCwm6Cd5/ol/lQm7DOrAAaubbju2Xov8pwDKF+B+baAc6LUA2UZVp+x/92n+cc094riWfXpazt6j6pqvr7uFVVUH643L9+BWdFmBUto5pmIh9Yw/jxR/qye0HwtsJ8L+I+6Kzzsx/B6rdfG55AzsJSAFwiyWAgyrW+GV3TT/g65aXkci832jaZoi4Dkpn5Gn/QzEjIekKjL+4HYvoLERIr++YvXEsTIXpC5Ea6c8Y3tq8qi5fqq7N3uwqvP5Zq53yrVzN5K4p5fl++3bdHVqnH71LvHzb+zXz5BwMvXcVd9KafFpzJUFshmTRhQvJx9Gewb0EpDeRSUYV4dHYnC9vA6vYUJDFHW9eGVwlsOhmSPTONMK6uzRHxqezcoxyqyWaizw13BBE4nFAqA9SjuzU7V/wGgcuhQWErgQkvGgQEeGY+2BYrCS97crS7FxbYtH+GB6GkY8Ol1Ehiq5Yrr0hfIC/g1bK9JeWAdt5in/F7ewUrvLen1Ouh7fJGD30xJUGBzzHXnzFRvlb8UrPNe87UF4/7qKwNYv2fFTkA2O/Jy3INM8ebAnb6ZjBJJDwojPZJiohFn2bfQ0oh6HBq7ei6UF6/HopwM84z/euPJxQA6vuJU3ooDCWiKJrIBbzu03/V8+04dkVSwuLPseNWhu8t3fxwOrZ7wsqZe/LnvFejaoDsViXCxflDRKwFSc8qkUkiz5fWAu6LgEe+akaBae5FM1zEhlaGOhITQgMJEOMKWo7WPJNsvipClw6cVFWTwr8wmKdVX8MCBHQwm/6UA3DYRm49kpZ9RAfhzWnB5wDvk+ysIyPYo1VdlylZqXXYCEEC6jooTKdzcbdHD+bUUcucqe7yipHuoe69rUgwH5Me+ZgG8HfUd7kEwUR8N5VT81//esX4CdgKXXQE/beeieIoTI5EVBnx1xQLIDtp+pcvHcbtvFlv6dfo+/YbunuwNPi/giegFmsDP6WkVahJvbAZ12uOnDi/WX2woN7LFwhbK3qAFw9iWvKTFupoQgrm1IGpuYQ3WxpfC6e6FGuhvPNiVIGUh5taJ/qTSi7cSbuV2ieOf8R6+v0WwnX0N4yUFqbwijYVioLrvd2XSE/rK65ZyEcbSs1H4c54De3cYT8mLtORdWIPFWOe+d4Si9bbj6hW5e3iREx6XSuhcSi4M1BkG9xn3cmHvaQG8xTmKVx+/v2B9d5lhPCb1GNt3GAbWW4NFORCNOhWLnpixlcXaJuQ96RV5TxUd5QmvzpiUDU/rRVsMtdPfzFobljrzAGTh2fncNgeOOPoOItCxBbPsArcKFuhRWInbG1h2QYqAgT9pTi47W0LFNzw4slxaNzdPITU5M7d+Egdhb8UBFSo6FDwqe8MFjeTQM1SiABKCUREEn+4lFrj9XcpCr0n4k6t+3dfrHrPHJSXNIFXBM3dXa+Ld+95QCTMR7jGHm0XVsYlLCttdDlx2Yhd8YmAs7iV86Nzbiky2DxVsv1fU+QqshfVcuOyMk+4QxKzIcJOrBaT2OS1RQHTCnhrBe6Kd9ceFjq5cztnQvnaHVbvpBaxBuuc1sW2RXLl4J1kvpI2UZZv7X3LBwMATAAlQgI09jAfapgl1KLavCeSYQqm6BuLvGqFqzouQaVFkw+tkyyu3T4hHg0FEznsVBr/HOnxdFviVrpHjlzvfrzA5v5dCP+M6Dzxw4h33uigar5yw1JqkKl44kk9IHhzpu9Zc073koLhCjOAM78q7LEbWjzGePCCAqJiWpR4/4CUj0aWIaniUF8xPA8KFIRiSK05SjodVCwfcd1yxDhkPIgOuzJEPYRlQnhU9byDfmN02O8a8EC0GESSBmRuJkj6TJXHrLFvsOp7jmrEVgGUh+XDLzvvmADI2Ez7+vYJ9GCQlY/YRxHoxZFX4D0gQcw0TfZiln1JRWHIiqz+TMN0ZobtS56BcnjcL751edmGSsGf+n15P3o1xWb5W9ieW7KrEh+/O5ISAXlaq/LMMKBUHIl0/W2Y2XMlU+On7LGTgODqut7HzWpjF5xO8NuBADMy7kyK27xewSCpTQkQgEDeQheV6120vs6S7MtFswmcuE6vxD6GCtJxjY4iXlSDj67QUfqiEgUrDIDZfl4svYQkWRrg2ivpEroT1z6s4opMuM0DK9Fao604CUz8dbLbMUsgsFjIXvI8cjt6/7oyY3i2owqO6wyc6/pLec1/XX39ZGAAJ5ud8iWIf3q2une8he5jPhMBnj5gJgLpPkuWIuhYFkZ6aMsZPrS/VPcTICVlC8wqrBns1b18uQKs9YhrxhPJ1KsbU3ggVuNyp9MXCe/K8894xtuKeddkrusg8doZi/HlzK1Qdc6+PKTswY3LpLiC8tkoeeAVqratY2+wW1Yrexzl2lkbnXgk6cVl1ZvJVGqLtyOGzABr2q3IApy66DRvAkhBtJqMOlaGzsI5Hli00a6LaFqK8mszI3dVceRTGCvzZSvfA/fH7L7d74b8V//wa8dx/Snis/Mban67XzU2mKynp4uxk/q7t+gm03xrmGXVUZQLm7QSo5pNLrgP4zT+gPgA8G8pPRKv2fbUZ/tF08/5k9MaWMZkG93J+ZzlR63fQhb1KEiq7CRQZJGYcmI1mUDx9ZuQ+FOZgeSA51lAMIJHKwlxAdynlbOlAXJEOsEoUW2wF3LJwEB/PKG1XEEtRu8NKzZQqEZTWaGmt+14E9Gx/svCrGoeUWc6Ze3993ddBuq7WVEDIg9v75GVYwqH3sTKBYpsxNtLVSaVkM3EvoMxJSlG3XLej8xky0NJrCGxn+rS6e9lJxBgM6/vc51B/P1D/nCjde88HFtZ1+WDt2gGL6SgvC+WqaC8N692wzOusFYdQ4kQkkIz5HN+5uirNPDH37nH9XY9ZptaJgaDoqJ6IG8YLN7CqVIyPMsVc6n17aelo5ywIUrE8pDpJP459uL4aWYcGwUJy/VypREKKntH+Pbkl3D737zNrpY6+XG2lmjAKkrxh9ip32rWknSCbJxVltOG1rMqQZBR970FhBUJDVnzWV93vPJ8Rv+55JoqP2B8ZDkIlxkWytHcPy9jNz4/VBStK+JetiGWdMlnf/X1jzPBNMoZYF/BzxaSTYJl6Rf2PBpwF5YezjiMMGa/pCtBCkRkaNKeYQXrIYx0qLGNeTnbpuG1JhhVUkezYaR+YCJTDz6+ve/OzcKuMod2gTqY+mWyk9tqn/yjCKuTLVbC4Yclc2kc6k1lS3q3+MDaiF1IYans9zKDfQ9Oc7UYIay6rVLCsMD9HZ/Ie+fPkjeh51Mtu6Z6Vh6nwimdNHMkGQiKuO78r7T2G0+qyxc3rVIHJBINZQu25z3Qk0+bpAqTPDFG2sdHJBeZPCJ1jWMco6F+PeGyFwb74TbWf3qXq0sjcGPvsW0jiRNm9n8QmA8ceg6N1e/uar7JbCGRGzjoU7Dfdbe6ClIObxgPkzSnJwqiFo9AARHaB5BnLQca2UYCK4/LBinVo2+ZaUhGq2toKuLYy0lILTvAOZPUaFOoTTvEOCSIVHwlI0Jbz2vSu9Gq+Xrl6eS7hdrEwihvupSnahXtKkDug1+akoN4jUybhFLGiSgO+Q1kMvUZXyBMcc/6GP+H5ZeIgGzs/D8SuzvR6mo57vLbehh/To2G++9BqPsmirbZPk/93CtevNcH2r3udGcGliCgF8L1sW53DGFor2uO5tc5u2/XZY+QmfZY85AObeyFy43cLNsPSUGFYIOLCRPsYDwC52Xd5IikYr1m3FWlbsLKVVKaHnpEsS7aQ3HhZWNvXUYDMK/r/G+QxM7xh2JpfzesOiNXL5Ag/MUOjDFG1onJbmaXrCPLk+LCk9+vcMqGC2A/23PtJkK30mVvyesyqZOaTgpl/hph+wlOeOHDgiee+To8RqTR/thbKmz8zxQCsVTBw4cCxFdev3fc1aMwt3THruZhMuGdJiCSS9UH69V109HWHUvdam4zyaeMVpdxFQ000snj+Ow4muAtM2b+dyB5MNKtWb8FjufeasQX8mQoRKGKEdOw3p4KzJKLcdkAGQRnxcvv0zKMzQOW+8WcNd0v6mS/6FWrd7TKQE3E5puPv//pLxaJSCEWUijRW7PWdOCUi9yt0tDA6dyha9/58XkdOFVRIargC0cIM5hXTIozkwFr+sKA6DQMX9ligOMOCiuPR9yf4PvUUk9F82i/nJcewqVwKKenTz3izgiKu7rUCQY3s5u9qxmtRAAi4clVr9lJ58cL2OahVJwidMJtyyqd304bJ2RIUUajcj6jN6g47pLD34DzfG602S2b4s5z/EdjStXO+mAdC76I7ERNT0v6IsrXbn+xlchPU3aNlf8X9UR2Zkrx+LXI4M/icDNNYJZcNhPaPMpKz0djnyFURurrX8DFALVZW0fHEub2+71siXYY/AuKClz9Rka0vf2rWwh47+5mUIdPKchpBPd5Z8ww5x1RSbMhK6Kg+H2y2uzzcHLB6WJO3A5+uQjeW+XL/OTfiTikCikEymh640AK80KuwIM2vJzjIAI9ixwITgA0+JE8V9iPur+24jHdoe69+VR8yJMT+QMEB20LCnVIpdi5hYQ0U78U9TfZQ9st3XoenxX3L5qKkz6B4UolmnF/OtSN+3nbgKm4TIAJgIaJBRoVQGUkxdMr0pputSobFEb8UlahjYeHAsd/b0TEw8FIeMDv2Zx6/d8znwngOlJfqY0utJiMA5Lo+noVnqchWefzSeeR+lD1tnOgwWi5LDBKDXMUrCp7dCl07UnBx6ygRRAMdA7arfhkVUCwZyCrspS1i8RiD2WOvh3BMh0fbq+FlVGwqC73mSPDB30XFnTjCK2WQQ+Wp+978e4/2K14nj3nu25yUm/2VWimPYvvfEnMGpRoxIVaG+1P2mu5xVw0VOPezQvyL3oB3ztcTmZNKZlmGIVfUERzy9CtYEk50L3Vk3JkJhxVKlyfCcKIjo6kTNQztwNqKOiH64bSxd6SjAx8F7WjAubDeDXg1rDqAUn3S+z8BRN0XDSI9l2TC19sLFEQX5GCTbkdHmQlO3qSPvuyfLMTd+ggYkUqNRFDEHTrE3KhDapWLJXXAUhMBDCkEWS619CLZL2asCWJUzieFyPegGOfxyaJmhkkBJ0NdHzqv67ABDMjKIM9LViYrCHkTv2tabipC2ddlMm7Ah7qtLXQslDAc+z1ck1pnud9ujX3PL5yo8S+naRty4xutOT2ncPr95LF3ndEpZ4flXI4wv+1XKwZBKHWLyty6VV15Eh/BeuLCQr26Py8GAKz4IOow9HY09N865ncpgCFXUdxDgk63/Tn4Y0KLPLoQvHMIOVbIgbXKhvOmZTJSOXjFBNwICYDwKvE0V6NgPR9C3dCKoSTvQ6+RskhhmNWmxc9JPdufPpBz4YpWskAIMjmcE2nrinhAtLHUhoc8k5GQxyBbRmNi0LCGHEuIHZIBYHUAIP+LfU3FHvk9/huiCVG3n2MvevK5f0ayg4Wq6rrzr7Zfw7uT3L3gBezh0f5LDbVnfrYkzn2g9gCHbVvsj/JV+cyLNzSZe7sRXkiwV3sw4zMqwQvdv4JqMSK0oBp2rLIzBfP6LoG542QFuN5MlWEamSWVDueKIipt3mziRoo/7TGt/YAPgWEIx+hsxbUHVJDGVKeXI9heG4si5W5l7z0IJJ8+cELztfz9DRaRF6ex62E19Cy5rEHMXOaq/Cd83WeGpYI1qLoW8yoO5w6wKIKvp9UWX8O9zYSE9p3xmsNMkTaZacyrJcxVOafYy7WNlwJhJoazvHAdzK5zr0vIj4OsK5RF1DsL6CVfLkvkruYYyDKq+Vxl79lm8ZhQ+5WupHXhWwmqSHaq5EJTRbjp5LZ4m8ScSLdOoVBFywKp15w8ozBmaoCWtoFew8CGLW45FY8HMvaW011TqHLQOtPnq6GSCkLFYXnIAud1MPz0wxpwwHnGASCUbOz9yZ+rDHv2WIKpqhZQvCS+raa9zldet9dKeLMV1kiMTHwQTrMkg35f+Zp6O8f8fikiuTCRNJ/JAf2c9Qf8b95WUraSuWdoSUEZI2XvTTkibJdRuvfz1P1deyxywR88uxfMbWVI+Jk9zzxI3ug8ClPl3zxMBskkfD+zF/djFXTB3ljh819LIuizsrU60HBtK6PYhHHMCAvvOdzPCS8yWGoL4mf75vJ54hTYDkEM7Hun4itznr2q7qrj3nuSuXjtaba82rscoXCVTH4pUtN46/rpbnIcJQjN6K7Bx8rN26cw8uN98MR4zyK1Sf3rfRLo7BelBhwVyvQBG6IpcRmW5oJLQLkaQTc2MFv6jWEFuykFK7frYqtReA4Si/yvhwBImyl6rKTMQi2cna2Jtk+vEXzKVuzz6+kfDLTC3BoGvOp7E04nTlYZe92HnXkmuW5yQBzzwqyxF6hlurNugbCd8iIu1rQWwhmG01IAx9cnCNvaFngnF/xnzDYrO0Liuuz/tOfytlSYspkifu7d+1sSBKXtGuQFFImJs5HBoAwI2nFfyQYyt0NloWnI2X7+O1vvbJxodAQsBbSiiGTfj4on70a1pM/LqntsEuLCjMf20Nvv/fi9olbPsXRlDYQvFSZ/ttUUIo1C4QJ7Cohpk8u+Xknv5t/FHFEgxt4gBXt8nTZAZCbCttSwOgVsjtKIfU3IoBN3D3LH1wpO1xb/+/bSRPh3QTT+XmaAV82HBSyccd261TsLct17Rw9EOJSLOVgxKljFz7s/7kBon/5G+8c7dcHIMCKvW4Yw1wQraOXdyqrnOcEVTM3JyGTmijJwry5GuibzEvwN72Ht+2MxkcNpkUUE1XP/nrvcNlKooSCUK57J8ke4vQLlrYit8u9zCxAXodhAPIYwMoFWHtaWAypy/McWdj2bLrcr8o9SSZoOwdXkGiG5d/+toiCALbT6ypicQqjfcbV+aMqkFjCXL4smIMJ+aTJ2rPdSHz5hTK4huwtDxZHEYqHiApFwptjzXefsT7bejA24N4hrkvhWzS3XmHsbP1PimkDiq+Xv5ZF5hxyZY9CDOimO6isX/tD5I51YBmiC88xec//u1IOSxJwTz0hSO0w/Il8mOUijfoD4LPgI0dCJNNSN+FZvEJXHI+XALwqKi+hnxaC1UhiVwRMFIx8f383PzjelzaNyEe6VCBg12+nX+VXOtLQItMduCaIAAApgSURBVFUKbXFofIJRZr0Yh/hz68tNmbIVvmfe/bCY41A8tEBgQQgUj3+Hjz9V5Siiyatsnkv7p+cJEnTmiNBu68qAQxg8K9N9FBxAAyKhpn12kVJ+gUE8TUj26uwEpIcEREOLrlb8QEjawSy4RvJIWRS/ItbEZ3SRbAYWOl5wRgmJwBYljnNSCNNYdaDaDfqpgnM7i8ryAQnnPeVPl68/5fZ3HoYWIzzPJY7U2SehzYsnX5FZKVHL7CAT+rQQbDlNoWB3748dGGaFvweBOti+GQ0euHoy7kWNUgxPvcmt+86RclS5fYv+AFKF9NBkvpQ/us8pdpHXIG0Xn75fdadRZUnrPr18JhOytEqu0kLTG5b43tN7fWWZbr1HcFl0ea174C2mU9fLRZNce9lrk9EU8KnpvYr5uK+fU8Y65XwVnb5HliydkSmh91yYqDlZJkzGl2oDAFkXxhbU3bty8OPvAsiN+BzM5YpaOcJca8oNEQed8SnD2Ew1q+o0K6SCNImTr6vfPk9W+K8hQVY0Fwt3wUoSasYWr9nwwAHlZrjjgpTZCPAe8+EyP3AvFJVA0WzlOOBXc6Sa3L+yr9x5tglnAeUaFu4+xyAFlYjKys9k9O5PkMrcXd3skaJcqQ/XtPZ9c1Vk1npSQsU/+b75uSSOMzKRYXQTfEScWt1VOivkFk/ILm8vrTvLlD8vUn/H/kBuqehN3VD+Q50XDNP8JW6fBJQ/FT2rtn9NmVgxEkbBYPZEWi3Zl5HyIrw2WTveV//E7TDJRI9BpiUnxRRIShG4P9kYkJUXjyPvIXBzwQNd/0/5lTuwzdQwy0AyCKIv4tj/zyOjc25aPtxX0W/1x0qpZg+hnsqcvFTClyyWG0t5F17vDoypHncygHsyYmKNYCXivj8bMZ7C3PunyTbydEg7WfMcUuYuaUGJlDVObGDgwogCszxisYQwuUCttAEVB47tkrVBSiTmaYb3bCtDcxduipgSigdyR2CBHrwSt7cPrO/Px1YERVLK2lraTBHZLkxiZGYSGCVAM2zISby57ad8MYWD3omBMq179mTeIX3ClfAKIzD2b6mgpHw7NAOmxf7SqsuoaVySB9q0nYwdlAyVkco+/66EUkZ5jxaQkhBVlltnnNmrz305lAchgrK9L/cmx7d6EjA9L80AKWvehwoeefI5OStqOn7QcKfPKFpZoHmIyiXwJqiVcs6W/rD05HPJh5L9Huh3qE1SlsOXSdesuVlAC7aHFkDCrtE2mWnh7/gZvk1HglWZX/cMMVVIXoQWbm7FcC9wj7P8KvfnludiRNWV/oqH/TsPNh+qv1rwZKBsIR5wuviC4cTEGZ6G61xggbg+iYSClGbcYj+pqaaVZB/ExyCw75/FHG482LjUd/+2wE4+42xIECYYca66qv/uxLnXrXPV3isHQm+uL346m+lGDFvg+9wwjG3KuuqLFG3cHVz+meFuQwC6JNqQnDURD6CeiZyoImPgisNPyP0DLh4SH9GwvJG2D8w3RHNcVV5CSnCk91KYZxCBda/awJEBCvFcaA6wEFtCopJ6MjSZFWmweHKWrCOxs6weD1DZelpAYulMSOi4XfizxZ0gXJrxuRV8JgW9AOO0u7X3QjwOURXtq69Mt7DKgB7KI7d7mUtumsJWwhyqK24h1VyALQt3MkgUsUhb/p4engaMxINnrfKDifhpzIGo1numu9v3wIvc61vurrIH2iZE4M1WyLoA0l3cvmcEycVU+BxTdjzUdMO52cpuoKB8st6q4GVcwUaaOz0sRoLAQYAre4IMtQSR5OovXJh7zSUsotbLL87TIpRj73xek8pPMnuTcwh3HkjI3a9Nf8fDJnrn5Eh/j+NxGg4qE+9QccFCJmIILQj27v7ivkd3kdOI/wHVh9Gg0GTkO7x7Ivb4+JoeOLZxpVweaGCehsleQEE4hw1mdivD9XttHPbfBNO0qz3bHSae3P70GF/SttZ7E7sfBLFiDoNqumEOgKOFL+n1ErkcKEpQ5QkGaIHdTY+44rGdZ1bCsq+pkhAV5t3nWtGW9Pj8Cwtrdz7UuAPvE6D17mAJPbb4+aOqH0kAMmuSISTp0WzBCcgcHA1wUF7OcKu2iDkd77ngBD8aLYCelaUoAGuUKTCGhWfc58CCqpd4DYdqba//gQeEIhRtMJZY0KwpnpxPEORDNLnjlpLBipYONAxceASiqPE+1UMrJnzgdYsyaYg8xWZgpl1du5mO5USULgo//RnpCWXVLaqZ4w05yZ5LCzXQhBaW6Zs8LiYTb0CGX2yHxP63PFP2EqocZWmFB4mMQ7JTz8g89zUr3JPVIo2Qcemd0sQWMuLbewwgou/XuyTkoUL5HSKusOKAnLxgybXEnvtA49E2SPH3MPhnAL52MM6qgTsbg3Q2uQJJe0G4hv2+e5zGveC90xMrduOn6Is7Ls9NQoKQmXIACGmoTVpZfXlheUxmMQinLH02RxcRBBMbKBNE1lF8Ztt7K8Msb53JioWqrHIGHcJtdLHccPoZsSzcItqoXJaNtKmCVtmafP5SGk4Bq2qO6CmI2TPdqJCv79/chcfvbOxrAtjhl4SF77Q44Hs5eA5W9bk5XrEtVLq+huABekIJyYX8JKOs7LL9DK4t/u00JBt4AaRJIPd95nBu1ua2tDYSCi7eY9/bnTHkuubNPOSok+eV2bA80yrDsjsEVbDPU+X7SHXznBmH1vg7PYI+P1fqMrYTNBXJdC+JEsBbe3X0uh3IAarsqzv3vl0VhYUW3QPre3Lnbn1k6dkMzxvV4ZdPr0TciMCEYAoDq3siTik6HRbjJ8TqBKLUm5B9HI/IP0s4OdcGGdSfzbWLa/Lgn2vkKhzP01D0rZR+nQHVarnAk7sreGDgRN2vuODirzYfQVSAEKWFlQRyKYde42THEeX8FYqFHEgf2+KyDVnvFfcE5JFFNB4cZHHdDBg9Mh8+pNFKgHorPc+jR0poVKhMW34eGJkwX/99cJxmG/TYB/XEi/SREsgf4vY3j3+2WCqNfs8IW3qTbjZnSVlTxNd2VHCChHKVdGH3shADa6L0TDtZE1YmyfHxmPWlqk+q1T0hNEFWg4dGOKc6nmNnZ3gAjo+5N9ft05UWI4BgSTmrbsdW6L6x930gkcc0asm954upmrS57vEmVBOkPBHfpZomFzDmg+5Hn6ODmd6PvduEcm4qPC7oAQ1phubtbhjuU1V4HQb6gk6KMO/VFy57x36WXzbHOagWVUSG01k2QW965Dx4gjEuZUMIieaMkl1CPjy27nf3qEghJ6JU72I4YpPIU4uiY6ZR+JeCyzkkZV9HsMsts5JvDGI5FV0T3j185nFwMyQc7A7IUzw0illH5n+OACJPXCA2V5+Ih+G+umMLnJ4zx5x7Byu8OIa7oW4awXfjPhYVYAozWzD66cf+ZOz74r0JD7MOmhUBFE+3qDJB2D3SOmE+6u1+3roK6QZ5YYa9BSzNEW3v7Um8G/bVl73rpFs18V7Eu64vOJQLAQVTKb5z7zPASEPqljPvEnZOacR+l9Saxpl7S4PB6rT/D+kZVStE96vLAAAAAElFTkSuQmCC
+
+
+ 6
+
+
\ No newline at end of file
diff --git a/TestFiles/DA-Data-WithImagesInvalidPath.xml b/TestFiles/DA-Data-WithImagesInvalidPath.xml
new file mode 100644
index 00000000..85129613
--- /dev/null
+++ b/TestFiles/DA-Data-WithImagesInvalidPath.xml
@@ -0,0 +1,28 @@
+
+
+ 1
+ Cheryl
+ True
+ ../../../../TestFiles/invalid.png
+ ../../../../TestFiles/invalid.png
+
+
+ Unicycle
+ 3
+ 9/5/2001
+ ../../../../TestFiles/img2.png
+
+
+ Tricycle
+ 3
+ 8/6/2000
+ data:image/png;base64,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
+
+
+ 6
+
+
\ No newline at end of file
diff --git a/TestFiles/DA267-Repeat-HorizontalAlignType.docx b/TestFiles/DA267-Repeat-HorizontalAlignType.docx
new file mode 100644
index 00000000..90da4cf6
Binary files /dev/null and b/TestFiles/DA267-Repeat-HorizontalAlignType.docx differ
diff --git a/TestFiles/DA268-Repeat-VerticalAlignType.docx b/TestFiles/DA268-Repeat-VerticalAlignType.docx
new file mode 100644
index 00000000..2ef83762
Binary files /dev/null and b/TestFiles/DA268-Repeat-VerticalAlignType.docx differ
diff --git a/TestFiles/DA269-Repeat-InvalidAlignType.docx b/TestFiles/DA269-Repeat-InvalidAlignType.docx
new file mode 100644
index 00000000..1139aeac
Binary files /dev/null and b/TestFiles/DA269-Repeat-InvalidAlignType.docx differ
diff --git a/TestFiles/DA270-ImageSelect.docx b/TestFiles/DA270-ImageSelect.docx
new file mode 100644
index 00000000..fac3e305
Binary files /dev/null and b/TestFiles/DA270-ImageSelect.docx differ
diff --git a/TestFiles/DA270A-ImageSelect.docx b/TestFiles/DA270A-ImageSelect.docx
new file mode 100644
index 00000000..2adf96f3
Binary files /dev/null and b/TestFiles/DA270A-ImageSelect.docx differ
diff --git a/TestFiles/DA271-ImageSelectWithRepeat.docx b/TestFiles/DA271-ImageSelectWithRepeat.docx
new file mode 100644
index 00000000..65ee59a0
Binary files /dev/null and b/TestFiles/DA271-ImageSelectWithRepeat.docx differ
diff --git a/TestFiles/DA271A-ImageSelectWithRepeat.docx b/TestFiles/DA271A-ImageSelectWithRepeat.docx
new file mode 100644
index 00000000..7c75c293
Binary files /dev/null and b/TestFiles/DA271A-ImageSelectWithRepeat.docx differ
diff --git a/TestFiles/DA272-ImageSelectWithRepeatHorizontalAlign.docx b/TestFiles/DA272-ImageSelectWithRepeatHorizontalAlign.docx
new file mode 100644
index 00000000..740130c9
Binary files /dev/null and b/TestFiles/DA272-ImageSelectWithRepeatHorizontalAlign.docx differ
diff --git a/TestFiles/DA272A-ImageSelectWithRepeatHorizontalAlign.docx b/TestFiles/DA272A-ImageSelectWithRepeatHorizontalAlign.docx
new file mode 100644
index 00000000..3bb1bbfa
Binary files /dev/null and b/TestFiles/DA272A-ImageSelectWithRepeatHorizontalAlign.docx differ
diff --git a/TestFiles/DA273-ImageSelectInsideTextBoxWithRepeatVerticalAlign.docx b/TestFiles/DA273-ImageSelectInsideTextBoxWithRepeatVerticalAlign.docx
new file mode 100644
index 00000000..c717101f
Binary files /dev/null and b/TestFiles/DA273-ImageSelectInsideTextBoxWithRepeatVerticalAlign.docx differ
diff --git a/TestFiles/DA273A-ImageSelectInsideTextBoxWithRepeatVerticalAlign.docx b/TestFiles/DA273A-ImageSelectInsideTextBoxWithRepeatVerticalAlign.docx
new file mode 100644
index 00000000..aa8e15d6
Binary files /dev/null and b/TestFiles/DA273A-ImageSelectInsideTextBoxWithRepeatVerticalAlign.docx differ
diff --git a/TestFiles/DA274-ImageSelectInsideTextBoxWithRepeatHorizontalAlign.docx b/TestFiles/DA274-ImageSelectInsideTextBoxWithRepeatHorizontalAlign.docx
new file mode 100644
index 00000000..cd2ccab4
Binary files /dev/null and b/TestFiles/DA274-ImageSelectInsideTextBoxWithRepeatHorizontalAlign.docx differ
diff --git a/TestFiles/DA274A-ImageSelectInsideTextBoxWithRepeatHorizontalAlign.docx b/TestFiles/DA274A-ImageSelectInsideTextBoxWithRepeatHorizontalAlign.docx
new file mode 100644
index 00000000..dba63a74
Binary files /dev/null and b/TestFiles/DA274A-ImageSelectInsideTextBoxWithRepeatHorizontalAlign.docx differ
diff --git a/TestFiles/DA275-ImageSelectWithRepeatInvalidAlign.docx b/TestFiles/DA275-ImageSelectWithRepeatInvalidAlign.docx
new file mode 100644
index 00000000..e05e5583
Binary files /dev/null and b/TestFiles/DA275-ImageSelectWithRepeatInvalidAlign.docx differ
diff --git a/TestFiles/DA275A-ImageSelectWithRepeatInvalidAlign.docx b/TestFiles/DA275A-ImageSelectWithRepeatInvalidAlign.docx
new file mode 100644
index 00000000..8e7bf525
Binary files /dev/null and b/TestFiles/DA275A-ImageSelectWithRepeatInvalidAlign.docx differ
diff --git a/TestFiles/DA276-ImageSelectInsideTable.docx b/TestFiles/DA276-ImageSelectInsideTable.docx
new file mode 100644
index 00000000..552e873b
Binary files /dev/null and b/TestFiles/DA276-ImageSelectInsideTable.docx differ
diff --git a/TestFiles/DA276A-ImageSelectInsideTable.docx b/TestFiles/DA276A-ImageSelectInsideTable.docx
new file mode 100644
index 00000000..e8a6261f
Binary files /dev/null and b/TestFiles/DA276A-ImageSelectInsideTable.docx differ
diff --git a/TestFiles/DA277-ImageSelectMissingOrInvalidPictureContent.docx b/TestFiles/DA277-ImageSelectMissingOrInvalidPictureContent.docx
new file mode 100644
index 00000000..72127c40
Binary files /dev/null and b/TestFiles/DA277-ImageSelectMissingOrInvalidPictureContent.docx differ
diff --git a/TestFiles/DA277A-ImageSelectMissingOrInvalidPictureContent.docx b/TestFiles/DA277A-ImageSelectMissingOrInvalidPictureContent.docx
new file mode 100644
index 00000000..8d6be62b
Binary files /dev/null and b/TestFiles/DA277A-ImageSelectMissingOrInvalidPictureContent.docx differ
diff --git a/TestFiles/DA278-ImageSelect.docx b/TestFiles/DA278-ImageSelect.docx
new file mode 100644
index 00000000..1e578579
Binary files /dev/null and b/TestFiles/DA278-ImageSelect.docx differ
diff --git a/TestFiles/DA278A-ImageSelect.docx b/TestFiles/DA278A-ImageSelect.docx
new file mode 100644
index 00000000..d6315ea3
Binary files /dev/null and b/TestFiles/DA278A-ImageSelect.docx differ
diff --git a/TestFiles/DA279-ImageSelectWithRepeat.docx b/TestFiles/DA279-ImageSelectWithRepeat.docx
new file mode 100644
index 00000000..65ee59a0
Binary files /dev/null and b/TestFiles/DA279-ImageSelectWithRepeat.docx differ
diff --git a/TestFiles/DA279A-ImageSelectWithRepeat.docx b/TestFiles/DA279A-ImageSelectWithRepeat.docx
new file mode 100644
index 00000000..7752f197
Binary files /dev/null and b/TestFiles/DA279A-ImageSelectWithRepeat.docx differ
diff --git a/TestFiles/DA280-ImageSelectWithRepeat.docx b/TestFiles/DA280-ImageSelectWithRepeat.docx
new file mode 100644
index 00000000..65ee59a0
Binary files /dev/null and b/TestFiles/DA280-ImageSelectWithRepeat.docx differ
diff --git a/TestFiles/DA280A-ImageSelectWithRepeat.docx b/TestFiles/DA280A-ImageSelectWithRepeat.docx
new file mode 100644
index 00000000..aff28980
Binary files /dev/null and b/TestFiles/DA280A-ImageSelectWithRepeat.docx differ
diff --git a/TestFiles/DA281-ImageSelectExtraWhitespaceBeforeImageContent.docx b/TestFiles/DA281-ImageSelectExtraWhitespaceBeforeImageContent.docx
new file mode 100644
index 00000000..5e6c19fc
Binary files /dev/null and b/TestFiles/DA281-ImageSelectExtraWhitespaceBeforeImageContent.docx differ
diff --git a/TestFiles/DA281A-ImageSelectExtraWhitespaceBeforeImageContent.docx b/TestFiles/DA281A-ImageSelectExtraWhitespaceBeforeImageContent.docx
new file mode 100644
index 00000000..3531057f
Binary files /dev/null and b/TestFiles/DA281A-ImageSelectExtraWhitespaceBeforeImageContent.docx differ
diff --git a/TestFiles/DA282-ImageSelectWithHeader.docx b/TestFiles/DA282-ImageSelectWithHeader.docx
new file mode 100644
index 00000000..1082a1bb
Binary files /dev/null and b/TestFiles/DA282-ImageSelectWithHeader.docx differ
diff --git a/TestFiles/DA282A-ImageSelectWithHeader.docx b/TestFiles/DA282A-ImageSelectWithHeader.docx
new file mode 100644
index 00000000..b7c30c26
Binary files /dev/null and b/TestFiles/DA282A-ImageSelectWithHeader.docx differ
diff --git a/TestFiles/DA283-ImageSelectWithFooter.docx b/TestFiles/DA283-ImageSelectWithFooter.docx
new file mode 100644
index 00000000..0008d8d4
Binary files /dev/null and b/TestFiles/DA283-ImageSelectWithFooter.docx differ
diff --git a/TestFiles/DA283A-ImageSelectWithFooter.docx b/TestFiles/DA283A-ImageSelectWithFooter.docx
new file mode 100644
index 00000000..d8715c10
Binary files /dev/null and b/TestFiles/DA283A-ImageSelectWithFooter.docx differ
diff --git a/TestFiles/DA284-ImageSelectWithHeaderAndFooter.docx b/TestFiles/DA284-ImageSelectWithHeaderAndFooter.docx
new file mode 100644
index 00000000..3b0a2266
Binary files /dev/null and b/TestFiles/DA284-ImageSelectWithHeaderAndFooter.docx differ
diff --git a/TestFiles/DA284A-ImageSelectWithHeaderAndFooter.docx b/TestFiles/DA284A-ImageSelectWithHeaderAndFooter.docx
new file mode 100644
index 00000000..2b157c45
Binary files /dev/null and b/TestFiles/DA284A-ImageSelectWithHeaderAndFooter.docx differ
diff --git a/TestFiles/DA285-ImageSelectNoParagraphFollowedAfterMetadata.docx b/TestFiles/DA285-ImageSelectNoParagraphFollowedAfterMetadata.docx
new file mode 100644
index 00000000..123b8152
Binary files /dev/null and b/TestFiles/DA285-ImageSelectNoParagraphFollowedAfterMetadata.docx differ
diff --git a/TestFiles/DA285A-ImageSelectNoParagraphFollowedAfterMetadata.docx b/TestFiles/DA285A-ImageSelectNoParagraphFollowedAfterMetadata.docx
new file mode 100644
index 00000000..9de4810a
Binary files /dev/null and b/TestFiles/DA285A-ImageSelectNoParagraphFollowedAfterMetadata.docx differ
diff --git a/docs/images/word/documentassembler/image1.jpg b/docs/images/word/documentassembler/image1.jpg
new file mode 100644
index 00000000..8f3f4046
Binary files /dev/null and b/docs/images/word/documentassembler/image1.jpg differ
diff --git a/docs/images/word/documentassembler/image2.png b/docs/images/word/documentassembler/image2.png
new file mode 100644
index 00000000..6a97b599
Binary files /dev/null and b/docs/images/word/documentassembler/image2.png differ
diff --git a/docs/images/word/documentassembler/image3.png b/docs/images/word/documentassembler/image3.png
new file mode 100644
index 00000000..0faca5ce
Binary files /dev/null and b/docs/images/word/documentassembler/image3.png differ
diff --git a/docs/images/word/documentassembler/image4.png b/docs/images/word/documentassembler/image4.png
new file mode 100644
index 00000000..0450d8d9
Binary files /dev/null and b/docs/images/word/documentassembler/image4.png differ
diff --git a/docs/tutorials/word/DocumentAssembler_ImagesSupport.md b/docs/tutorials/word/DocumentAssembler_ImagesSupport.md
new file mode 100644
index 00000000..ab28e77f
--- /dev/null
+++ b/docs/tutorials/word/DocumentAssembler_ImagesSupport.md
@@ -0,0 +1,30 @@
+---
+uid: Tutorial.Word.DocumentAssembler.ImagesSupport
+---
+
+# Key highlights from [#31](https://github.com/sergey-tihon/Clippit/pull/31#issuecomment-874335292)
+
+1. Image can be provided either by base64-encoded string or by specifying the filename. The Assembler will have to figure out the image type, based on either MIME or file extension. Here are both examples:
+
+ - `../../md-logo.png`
+ - `data:image/jpg;base64,/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAgGBgcGBQgHBwcetc…`
+
+2. The image content control will be surrounded by new type of select (in similar to repeat or conditional) – `Image Select` and `EndImage`. I found this approach easier than dealing just with the image content control. Here is the example:
+
+
+
+3. When used in repeated context, the image is used with relative XPath (in similar to other fields):
+
+
+
+4. Very similar situation with the Table:
+
+
+
+5. Here is example of data xml file:
+
+
+
+6. There is still a lot to be improved and some issues to be resolved, such as using templated image in header/footer, managing image size (preserve original/modify based on template/maintain aspect ratio etc.)
+
+7. Samples can be found in `DocumentAssemblerTests.cs` merged in [#31](https://github.com/sergey-tihon/Clippit/pull/31)
\ No newline at end of file
diff --git a/docs/tutorials/word/toc.yml b/docs/tutorials/word/toc.yml
index 7ebe3abc..e013d9a4 100644
--- a/docs/tutorials/word/toc.yml
+++ b/docs/tutorials/word/toc.yml
@@ -4,3 +4,7 @@
href: DocumentBuilder_CustomISource.md
- name: TableCellSource
href: DocumentBuilder_TableCellSource.md
+- name: DocumentAssembler
+ items:
+ - name: Images Support
+ href: DocumentAssembler_ImagesSupport.md
\ No newline at end of file