diff --git a/docling/backend/msword_backend.py b/docling/backend/msword_backend.py
index c09afd274a..2cc8689051 100644
--- a/docling/backend/msword_backend.py
+++ b/docling/backend/msword_backend.py
@@ -13,7 +13,7 @@
 from copy import deepcopy
 from io import BytesIO
 from pathlib import Path
-from typing import Any, Callable, Final, NamedTuple
+from typing import Any, Callable, Final, NamedTuple, TypeVar
 from urllib.parse import urlparse
 
 from docling_core.types.doc import (
@@ -23,6 +23,7 @@
     DocItemLabel,
     DoclingDocument,
     DocumentOrigin,
+    FloatingItem,
     GroupLabel,
     ImageRef,
     ListGroup,
@@ -53,7 +54,10 @@
     get_pil_from_dml_docx,
 )
 from docling.backend.docx.latex.omml import OMML_NS, oMath2Latex
+from docling.backend.msexcel_backend import MsExcelDocumentBackend
+from docling.backend.mspowerpoint_backend import MsPowerpointDocumentBackend
 from docling.backend.utils.archive_limits import (
+    ArchiveLimitError,
     ArchiveLimits,
     check_archive_limits,
     read_member,
@@ -158,6 +162,7 @@
 )
 _MC_NS: Final[str] = "http://schemas.openxmlformats.org/markup-compatibility/2006"
 _V_NS: Final[str] = "urn:schemas-microsoft-com:vml"
+_O_NS: Final[str] = "urn:schemas-microsoft-com:office:office"
 _WPS_NS: Final[str] = (
     "http://schemas.microsoft.com/office/word/2010/wordprocessingShape"
 )
@@ -175,12 +180,23 @@
     "wp": _WP_NS,
     "mc": _MC_NS,
     "v": _V_NS,
+    "o": _O_NS,
     "wps": _WPS_NS,
     "w10": _W10_NS,
     "a14": _A14_NS,
     "w14": _W14_NS,
 }
 
+_EMBEDDED_DOCUMENT_FORMATS: Final[dict[str, InputFormat]] = {
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": InputFormat.DOCX,
+    "application/vnd.ms-word.document.macroEnabled.12": InputFormat.DOCX,
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": InputFormat.XLSX,
+    "application/vnd.ms-excel.sheet.macroEnabled.12": InputFormat.XLSX,
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation": InputFormat.PPTX,
+    "application/vnd.ms-powerpoint.presentation.macroEnabled.12": InputFormat.PPTX,
+}
+"""Content types of the embedded OLE packages that are converted, by input format."""
+
 _OOXML_ROOT_RELS: Final[str] = "_rels/.rels"
 """OPC root relationships part; its ``officeDocument`` type identifies Strict vs Transitional."""
 
@@ -643,6 +659,22 @@ def _normalize_strict_ooxml(archive: zipfile.ZipFile, limits: ArchiveLimits) ->
     return normalized
 
 
+_RefT = TypeVar("_RefT", bound=RefItem)
+
+
+def _remap_refs(refs: list[_RefT], copies: dict[str, NodeItem]) -> list[_RefT]:
+    """Point references at the copies of their targets.
+
+    A reference to an item that was not copied is dropped. A ``FineRef`` keeps
+    its character range.
+    """
+    return [
+        ref.model_copy(update={"cref": copies[ref.cref].self_ref})
+        for ref in refs
+        if ref.cref in copies
+    ]
+
+
 def _normalize_list_style_types(docx_obj: DocxDocument) -> None:
     """Change the style type ``list`` to ``numbering`` in the styles part.
 
@@ -817,6 +849,17 @@ def __init__(
         self.vml_imagedata_xpath_expr = etree.XPath(
             ".//v:imagedata", namespaces=_OOXML_NAMESPACES
         )
+        self.ole_object_xpath_expr = etree.XPath(
+            "ancestor::w:object[1]/o:OLEObject", namespaces=_OOXML_NAMESPACES
+        )
+        # Part names of the embedded documents already converted, so a part that
+        # several objects share is converted only once.
+        self.converted_embedded_parts: set[str] = set()
+        # Embedded documents converted, and their decompressed bytes, including
+        # those of the nested Word documents. They count against the limits.
+        self.embedded_objects_converted: int = 0
+        self.embedded_total_bytes: int = 0
+        self.embedded_objects_skipped: int = 0
         # self.initialise(path_or_stream)
         # Word file:
         self.path_or_stream: BytesIO | Path = path_or_stream
@@ -967,6 +1010,10 @@ def convert(self) -> DoclingDocument:
             # Reset mappings for a fresh conversion pass
             self.paragraph_comment_map.clear()
             self.paragraph_to_items.clear()
+            self.converted_embedded_parts.clear()
+            self.embedded_objects_converted = 0
+            self.embedded_total_bytes = 0
+            self.embedded_objects_skipped = 0
             self._deferred_empty_paragraphs.clear()
             doc, _ = self._walk_linear(self.docx_obj.element.body, doc)
             self._add_header_footer(self.docx_obj, doc)
@@ -4409,14 +4456,215 @@ def _handle_vml_pictures(
                             )
 
                 is_spacer = self._is_invisible_spacer(pil_image)
-                elem_ref.append(
-                    self._add_picture_to_doc(
-                        doc, parent, pil_image, is_spacer=is_spacer
-                    )
+                embedded = (
+                    self._convert_embedded_object(imagedata, self.options)
+                    if isinstance(self.options, MsWordBackendOptions)
+                    and self.options.process_embedded_objects
+                    else None
                 )
+                if embedded is None:
+                    elem_ref.append(
+                        self._add_picture_to_doc(
+                            doc, parent, pil_image, is_spacer=is_spacer
+                        )
+                    )
+                else:
+                    filename, embedded_doc = embedded
+                    object_group = doc.add_group(
+                        label=GroupLabel.SECTION,
+                        name=f"embedded: {filename}",
+                        parent=parent,
+                        content_layer=self.content_layer,
+                    )
+                    elem_ref.append(
+                        self._add_picture_to_doc(
+                            doc, object_group, pil_image, is_spacer=is_spacer
+                        )
+                    )
+                    self._add_embedded_document(doc, embedded_doc, object_group)
 
         return elem_ref
 
+    def _convert_embedded_object(
+        self, imagedata: Any, options: MsWordBackendOptions
+    ) -> tuple[str, DoclingDocument] | None:
+        """Convert the Office document embedded in the OLE object of a VML picture.
+
+        Word stores an embedded Word, Excel or PowerPoint document as a package
+        part, and the ``v:imagedata`` only holds its preview picture.
+
+        The package must pass the archive limits of this Word document before it
+        is opened. ``max_embedded_objects`` and ``max_embedded_total_bytes`` are
+        shared with the nested Word documents, so they bound the work over all
+        nesting levels.
+
+        Args:
+            imagedata: The ``v:imagedata`` element of the preview picture.
+            options: The options of this backend.
+
+        Returns:
+            The file name of the embedded part and its converted document, or
+            ``None`` if the picture is not the preview of an embedded Word, Excel
+            or PowerPoint document, if the part was already converted, if a limit
+            stops it, or if the conversion fails.
+        """
+        ole_objects = self.ole_object_xpath_expr(imagedata)
+        if not ole_objects:
+            return None
+        rel_id = ole_objects[0].get(f"{{{_R_NS}}}id")
+        rels = self.current_part.rels
+        if rel_id is None or rel_id not in rels or rels[rel_id].is_external:
+            return None
+        part = rels[rel_id].target_part
+        input_format = _EMBEDDED_DOCUMENT_FORMATS.get(part.content_type)
+        if input_format is None or part.partname in self.converted_embedded_parts:
+            return None
+        self.converted_embedded_parts.add(part.partname)
+
+        filename = part.partname.filename
+        if self.embedded_objects_converted >= options.max_embedded_objects:
+            self.embedded_objects_skipped += 1
+            if self.embedded_objects_skipped == 1:
+                _log.warning(
+                    f"Embedded document {filename} and the next ones are not "
+                    f"converted: max_embedded_objects ({options.max_embedded_objects}) "
+                    "is reached"
+                )
+            return None
+        try:
+            with zipfile.ZipFile(BytesIO(part.blob)) as archive:
+                check_archive_limits(archive, self._archive_limits)
+                package_bytes = sum(info.file_size for info in archive.infolist())
+        except (zipfile.BadZipFile, ArchiveLimitError) as exc:
+            _log.warning(f"Embedded document {filename} is not converted: {exc}")
+            return None
+        if self.embedded_total_bytes + package_bytes > options.max_embedded_total_bytes:
+            _log.warning(
+                f"Embedded document {filename} is not converted: the embedded "
+                "documents would decompress to more than max_embedded_total_bytes "
+                f"({options.max_embedded_total_bytes})"
+            )
+            return None
+        self.embedded_objects_converted += 1
+        self.embedded_total_bytes += package_bytes
+
+        backend_cls: type[DeclarativeDocumentBackend]
+        backend_options: MsWordBackendOptions | None = None
+        if input_format == InputFormat.XLSX:
+            backend_cls = MsExcelDocumentBackend
+        elif input_format == InputFormat.PPTX:
+            backend_cls = MsPowerpointDocumentBackend
+        else:
+            backend_cls = MsWordDocumentBackend
+            backend_options = options.model_copy(
+                update={
+                    "process_embedded_objects": options.max_embedding_depth > 1,
+                    "max_embedding_depth": max(options.max_embedding_depth - 1, 1),
+                    "max_embedded_objects": options.max_embedded_objects
+                    - self.embedded_objects_converted,
+                    "max_embedded_total_bytes": options.max_embedded_total_bytes
+                    - self.embedded_total_bytes,
+                }
+            )
+
+        # A broken or unsupported embedded document, or a missing format extra,
+        # must not fail the conversion of the Word document. The preview stays.
+        try:
+            in_doc = InputDocument(
+                path_or_stream=BytesIO(part.blob),
+                format=input_format,
+                backend=backend_cls,
+                backend_options=backend_options,
+                filename=filename,
+            )
+        except Exception as exc:
+            _log.warning(f"Embedded document {filename} cannot be opened: {exc}")
+            return None
+        if not in_doc.valid:
+            _log.warning(f"Embedded document {filename} cannot be opened")
+            return None
+        backend = in_doc._backend
+        if not isinstance(backend, DeclarativeDocumentBackend):
+            raise RuntimeError(
+                f"The backend {type(backend).__name__} of embedded document "
+                f"{filename} is not a declarative backend."
+            )
+        try:
+            embedded_doc = backend.convert()
+        except Exception as exc:
+            _log.warning(f"Embedded document {filename} cannot be converted: {exc}")
+            return None
+        finally:
+            backend.unload()
+        if isinstance(backend, MsWordDocumentBackend):
+            self.embedded_objects_converted += backend.embedded_objects_converted
+            self.embedded_total_bytes += backend.embedded_total_bytes
+        return filename, embedded_doc
+
+    def _add_embedded_document(
+        self, doc: DoclingDocument, embedded_doc: DoclingDocument, parent: NodeItem
+    ) -> None:
+        """Copy the body of an embedded document under a node of this document.
+
+        ``DoclingDocument.add_document`` copies the tree, but the captions,
+        footnotes, references, comments and rich table cells of the copies still
+        point at item indexes of the embedded document, so they are remapped
+        here. The page provenance is removed, because a Word document has no
+        pages.
+
+        Args:
+            doc: The DoclingDocument being constructed.
+            embedded_doc: The converted embedded document.
+            parent: The node that receives the copied items.
+        """
+        first_copy = len(parent.children)
+        doc.add_document(embedded_doc, parent=parent)
+
+        copies: dict[str, NodeItem] = {}
+        for source_ref, copy_ref in zip(
+            embedded_doc.body.children, parent.children[first_copy:], strict=True
+        ):
+            for (source, _), (copy, _) in zip(
+                embedded_doc.iterate_items(
+                    root=source_ref.resolve(embedded_doc),
+                    with_groups=True,
+                    traverse_pictures=True,
+                    included_content_layers=set(ContentLayer),
+                ),
+                doc.iterate_items(
+                    root=copy_ref.resolve(doc),
+                    with_groups=True,
+                    traverse_pictures=True,
+                    included_content_layers=set(ContentLayer),
+                ),
+                strict=True,
+            ):
+                copies[source.self_ref] = copy
+
+        for item in copies.values():
+            if item.content_layer == ContentLayer.BODY:
+                item.content_layer = self.content_layer
+            if isinstance(item, DocItem):
+                item.prov = []
+                item.comments = _remap_refs(item.comments, copies)
+            if isinstance(item, FloatingItem):
+                item.captions = _remap_refs(item.captions, copies)
+                item.footnotes = _remap_refs(item.footnotes, copies)
+                item.references = _remap_refs(item.references, copies)
+            if isinstance(item, TableItem):
+                cells = item.data.table_cells
+                for index, cell in enumerate(cells):
+                    if not isinstance(cell, RichTableCell):
+                        continue
+                    target = copies.get(cell.ref.cref)
+                    # Like _remap_refs, a cell whose target was not copied loses
+                    # its reference and keeps only its text.
+                    cells[index] = (
+                        cell.model_copy(update={"ref": target.get_ref()})
+                        if target is not None
+                        else TableCell.model_validate(cell.model_dump(exclude={"ref"}))
+                    )
+
     def _handle_drawingml(self, doc: DoclingDocument, drawingml_els: Any):
         """Handle DrawingML elements by converting to image via DOCX->PDF->PNG.
 
diff --git a/docling/datamodel/backend_options.py b/docling/datamodel/backend_options.py
index 41564b2dbc..c7b2cf5805 100644
--- a/docling/datamodel/backend_options.py
+++ b/docling/datamodel/backend_options.py
@@ -574,6 +574,53 @@ class MsWordBackendOptions(BaseBackendOptions):
         ),
     )
 
+    process_embedded_objects: bool = Field(
+        False,
+        description=(
+            "Whether to convert the Word, Excel and PowerPoint documents that are "
+            "embedded as OLE objects. The content of each one is added after the "
+            "preview picture of the object, and both are grouped together. An "
+            "embedded Word document is converted with these options, and an "
+            "embedded workbook or presentation with the default options of its "
+            "backend. Each embedded package must pass the archive limits of the "
+            "Word document (max_total_bytes, max_file_bytes and max_member_count). "
+            "Linked objects and other embedded objects keep only their preview "
+            "picture. Opt-in (default False)."
+        ),
+    )
+    max_embedded_objects: Annotated[
+        NonNegativeInt,
+        Field(
+            description=(
+                "Maximum number of embedded documents to convert when "
+                "process_embedded_objects is enabled, counted over all nesting "
+                "levels. The other objects keep only their preview picture."
+            )
+        ),
+    ] = 32
+    max_embedded_total_bytes: Annotated[
+        NonNegativeInt,
+        Field(
+            description=(
+                "Maximum cumulative decompressed size in bytes of the embedded "
+                "documents to convert when process_embedded_objects is enabled, "
+                "counted over all nesting levels. An object that goes above it "
+                "keeps only its preview picture."
+            )
+        ),
+    ] = 512 * 1024 * 1024
+    max_embedding_depth: Annotated[
+        PositiveInt,
+        Field(
+            description=(
+                "Maximum nesting level of the embedded documents to convert when "
+                "process_embedded_objects is enabled. 1 converts only the objects "
+                "of the Word document, 2 also converts the objects of an embedded "
+                "Word document, and so on."
+            )
+        ),
+    ] = 3
+
     use_outline_level_for_headings: Annotated[
         bool,
         Field(
diff --git a/docs/usage/advanced_options.md b/docs/usage/advanced_options.md
index b0e061c482..bf83540e30 100644
--- a/docs/usage/advanced_options.md
+++ b/docs/usage/advanced_options.md
@@ -501,6 +501,65 @@ doc_converter = DocumentConverter(
 )
 ```
 
+### Word embedded documents
+
+A Word file can embed an Excel workbook, a PowerPoint presentation or another
+Word document as an OLE object. By default, Docling keeps only the preview
+picture of the object. Set `process_embedded_objects` to also convert the
+embedded document:
+
+```python
+from docling.datamodel.backend_options import MsWordBackendOptions
+from docling.datamodel.base_models import InputFormat
+from docling.document_converter import DocumentConverter, WordFormatOption
+
+converter = DocumentConverter(
+    format_options={
+        InputFormat.DOCX: WordFormatOption(
+            backend_options=MsWordBackendOptions(process_embedded_objects=True)
+        )
+    }
+)
+doc = converter.convert("report.docx").document
+for group in doc.groups:
+    if group.name.startswith("embedded: "):
+        print(group.name)  # e.g. "embedded: Microsoft_Excel_Worksheet.xlsx"
+```
+
+Each object becomes a group at the position of the object. The group holds the
+preview picture, followed by the content of the embedded document, for example
+the sheets and tables of a workbook. An embedded Word document is converted with
+the same options, so its own embedded objects are converted too. An embedded
+workbook or presentation is converted with the default options of its backend.
+Linked objects, and objects of other types such as a PDF or a text file, keep
+only their preview picture. The `format-xlsx` and `format-pptx` extras are
+necessary to convert embedded workbooks and presentations.
+
+An embedded document can come from an untrusted source, so limits apply. An
+object that goes above a limit keeps only its preview picture, and a warning is
+logged:
+
+- Each embedded package must pass the same archive limits as the Word file
+  (`max_total_bytes`, `max_file_bytes` and `max_member_count`), before it is
+  opened.
+- `max_embedded_objects` (default 32) and `max_embedded_total_bytes` (default
+  512 MiB of decompressed data) apply to all embedded documents together,
+  including those inside an embedded Word document.
+- `max_embedding_depth` (default 3) is the deepest nesting level that is
+  converted. With `1`, only the objects of the Word file itself are converted.
+- A package that several objects share is converted once.
+
+```python
+from docling.datamodel.backend_options import MsWordBackendOptions
+
+options = MsWordBackendOptions(
+    process_embedded_objects=True,
+    max_embedded_objects=10,
+    max_embedding_depth=1,
+)
+```
+
+
 ### AsciiDoc comments
 
 AsciiDoc comments carry editorial notes, review remarks and blocks that were
diff --git a/tests/data/docx/groundtruth/docx_embedded_objects.docx.itxt b/tests/data/docx/groundtruth/docx_embedded_objects.docx.itxt
new file mode 100644
index 0000000000..cfe8a7f2a9
--- /dev/null
+++ b/tests/data/docx/groundtruth/docx_embedded_objects.docx.itxt
@@ -0,0 +1,29 @@
+item-0 at level 0: unspecified: group _root_
+  item-1 at level 1: section: group header-0
+    item-2 at level 2: section_header: Quarterly report
+      item-3 at level 3: text: The budget workbook is embedded below.
+      item-4 at level 3: section: group embedded: Microsoft_Excel_Worksheet.xlsx
+        item-5 at level 4: picture
+        item-6 at level 4: sheet: group Budget
+          item-7 at level 5: table with [4x2]
+      item-8 at level 3: text: The roadmap slide is embedded below.
+      item-9 at level 3: section: group embedded: Microsoft_PowerPoint_Presentation.pptx
+        item-10 at level 4: picture
+        item-11 at level 4: chapter: group slide-0
+          item-12 at level 5: title: Roadmap
+          item-13 at level 5: list: group list
+            item-14 at level 6: list_item: Ship embedded object parsing
+      item-15 at level 3: text: The meeting notes document is embedded below.
+      item-16 at level 3: section: group embedded: Microsoft_Word_Document.docx
+        item-17 at level 4: picture
+        item-18 at level 4: text: Meeting notes: approve the budget.
+        item-19 at level 4: section: group embedded: Microsoft_Excel_Worksheet.xlsx
+          item-20 at level 5: picture
+          item-21 at level 5: sheet: group Actions
+            item-22 at level 6: table with [3x2]
+        item-23 at level 4: text: Next meeting is on Friday.
+        item-24 at level 4: text: 
+      item-25 at level 3: text: A text file is embedded as a package.
+      item-26 at level 3: picture
+      item-27 at level 3: text: End of report.
+      item-28 at level 3: text: 
\ No newline at end of file
diff --git a/tests/data/docx/groundtruth/docx_embedded_objects.docx.json b/tests/data/docx/groundtruth/docx_embedded_objects.docx.json
new file mode 100644
index 0000000000..8c092c09ac
--- /dev/null
+++ b/tests/data/docx/groundtruth/docx_embedded_objects.docx.json
@@ -0,0 +1,955 @@
+{
+  "schema_name": "DoclingDocument",
+  "version": "1.10.0",
+  "name": "docx_embedded_objects",
+  "origin": {
+    "mimetype": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "binary_hash": 10126384585997278569,
+    "filename": "docx_embedded_objects.docx"
+  },
+  "furniture": {
+    "self_ref": "#/furniture",
+    "children": [],
+    "content_layer": "furniture",
+    "name": "_root_",
+    "label": "unspecified"
+  },
+  "body": {
+    "self_ref": "#/body",
+    "children": [
+      {
+        "$ref": "#/groups/0"
+      }
+    ],
+    "content_layer": "body",
+    "name": "_root_",
+    "label": "unspecified"
+  },
+  "groups": [
+    {
+      "self_ref": "#/groups/0",
+      "parent": {
+        "$ref": "#/body"
+      },
+      "children": [
+        {
+          "$ref": "#/texts/0"
+        }
+      ],
+      "content_layer": "body",
+      "name": "header-0",
+      "label": "section"
+    },
+    {
+      "self_ref": "#/groups/1",
+      "parent": {
+        "$ref": "#/texts/0"
+      },
+      "children": [
+        {
+          "$ref": "#/pictures/0"
+        },
+        {
+          "$ref": "#/groups/2"
+        }
+      ],
+      "content_layer": "body",
+      "name": "embedded: Microsoft_Excel_Worksheet.xlsx",
+      "label": "section"
+    },
+    {
+      "self_ref": "#/groups/2",
+      "parent": {
+        "$ref": "#/groups/1"
+      },
+      "children": [
+        {
+          "$ref": "#/tables/0"
+        }
+      ],
+      "content_layer": "body",
+      "name": "Budget",
+      "label": "sheet"
+    },
+    {
+      "self_ref": "#/groups/3",
+      "parent": {
+        "$ref": "#/texts/0"
+      },
+      "children": [
+        {
+          "$ref": "#/pictures/1"
+        },
+        {
+          "$ref": "#/groups/4"
+        }
+      ],
+      "content_layer": "body",
+      "name": "embedded: Microsoft_PowerPoint_Presentation.pptx",
+      "label": "section"
+    },
+    {
+      "self_ref": "#/groups/4",
+      "parent": {
+        "$ref": "#/groups/3"
+      },
+      "children": [
+        {
+          "$ref": "#/texts/3"
+        },
+        {
+          "$ref": "#/groups/5"
+        }
+      ],
+      "content_layer": "body",
+      "name": "slide-0",
+      "label": "chapter"
+    },
+    {
+      "self_ref": "#/groups/5",
+      "parent": {
+        "$ref": "#/groups/4"
+      },
+      "children": [
+        {
+          "$ref": "#/texts/4"
+        }
+      ],
+      "content_layer": "body",
+      "name": "list",
+      "label": "list"
+    },
+    {
+      "self_ref": "#/groups/6",
+      "parent": {
+        "$ref": "#/texts/0"
+      },
+      "children": [
+        {
+          "$ref": "#/pictures/2"
+        },
+        {
+          "$ref": "#/texts/6"
+        },
+        {
+          "$ref": "#/groups/7"
+        },
+        {
+          "$ref": "#/texts/7"
+        },
+        {
+          "$ref": "#/texts/8"
+        }
+      ],
+      "content_layer": "body",
+      "name": "embedded: Microsoft_Word_Document.docx",
+      "label": "section"
+    },
+    {
+      "self_ref": "#/groups/7",
+      "parent": {
+        "$ref": "#/groups/6"
+      },
+      "children": [
+        {
+          "$ref": "#/pictures/3"
+        },
+        {
+          "$ref": "#/groups/8"
+        }
+      ],
+      "content_layer": "body",
+      "name": "embedded: Microsoft_Excel_Worksheet.xlsx",
+      "label": "section"
+    },
+    {
+      "self_ref": "#/groups/8",
+      "parent": {
+        "$ref": "#/groups/7"
+      },
+      "children": [
+        {
+          "$ref": "#/tables/1"
+        }
+      ],
+      "content_layer": "body",
+      "name": "Actions",
+      "label": "sheet"
+    }
+  ],
+  "texts": [
+    {
+      "self_ref": "#/texts/0",
+      "parent": {
+        "$ref": "#/groups/0"
+      },
+      "children": [
+        {
+          "$ref": "#/texts/1"
+        },
+        {
+          "$ref": "#/groups/1"
+        },
+        {
+          "$ref": "#/texts/2"
+        },
+        {
+          "$ref": "#/groups/3"
+        },
+        {
+          "$ref": "#/texts/5"
+        },
+        {
+          "$ref": "#/groups/6"
+        },
+        {
+          "$ref": "#/texts/9"
+        },
+        {
+          "$ref": "#/pictures/4"
+        },
+        {
+          "$ref": "#/texts/10"
+        },
+        {
+          "$ref": "#/texts/11"
+        }
+      ],
+      "content_layer": "body",
+      "label": "section_header",
+      "prov": [],
+      "orig": "Quarterly report",
+      "text": "Quarterly report",
+      "level": 1
+    },
+    {
+      "self_ref": "#/texts/1",
+      "parent": {
+        "$ref": "#/texts/0"
+      },
+      "children": [],
+      "content_layer": "body",
+      "label": "text",
+      "prov": [],
+      "orig": "The budget workbook is embedded below.",
+      "text": "The budget workbook is embedded below.",
+      "formatting": {
+        "bold": false,
+        "italic": false,
+        "underline": false,
+        "strikethrough": false,
+        "script": "baseline"
+      }
+    },
+    {
+      "self_ref": "#/texts/2",
+      "parent": {
+        "$ref": "#/texts/0"
+      },
+      "children": [],
+      "content_layer": "body",
+      "label": "text",
+      "prov": [],
+      "orig": "The roadmap slide is embedded below.",
+      "text": "The roadmap slide is embedded below.",
+      "formatting": {
+        "bold": false,
+        "italic": false,
+        "underline": false,
+        "strikethrough": false,
+        "script": "baseline"
+      }
+    },
+    {
+      "self_ref": "#/texts/3",
+      "parent": {
+        "$ref": "#/groups/4"
+      },
+      "children": [],
+      "content_layer": "body",
+      "label": "title",
+      "prov": [],
+      "orig": "Roadmap",
+      "text": "Roadmap"
+    },
+    {
+      "self_ref": "#/texts/4",
+      "parent": {
+        "$ref": "#/groups/5"
+      },
+      "children": [],
+      "content_layer": "body",
+      "label": "list_item",
+      "prov": [],
+      "orig": "Ship embedded object parsing",
+      "text": "Ship embedded object parsing",
+      "enumerated": false,
+      "marker": ""
+    },
+    {
+      "self_ref": "#/texts/5",
+      "parent": {
+        "$ref": "#/texts/0"
+      },
+      "children": [],
+      "content_layer": "body",
+      "label": "text",
+      "prov": [],
+      "orig": "The meeting notes document is embedded below.",
+      "text": "The meeting notes document is embedded below.",
+      "formatting": {
+        "bold": false,
+        "italic": false,
+        "underline": false,
+        "strikethrough": false,
+        "script": "baseline"
+      }
+    },
+    {
+      "self_ref": "#/texts/6",
+      "parent": {
+        "$ref": "#/groups/6"
+      },
+      "children": [],
+      "content_layer": "body",
+      "label": "text",
+      "prov": [],
+      "orig": "Meeting notes: approve the budget.",
+      "text": "Meeting notes: approve the budget.",
+      "formatting": {
+        "bold": false,
+        "italic": false,
+        "underline": false,
+        "strikethrough": false,
+        "script": "baseline"
+      }
+    },
+    {
+      "self_ref": "#/texts/7",
+      "parent": {
+        "$ref": "#/groups/6"
+      },
+      "children": [],
+      "content_layer": "body",
+      "label": "text",
+      "prov": [],
+      "orig": "Next meeting is on Friday.",
+      "text": "Next meeting is on Friday.",
+      "formatting": {
+        "bold": false,
+        "italic": false,
+        "underline": false,
+        "strikethrough": false,
+        "script": "baseline"
+      }
+    },
+    {
+      "self_ref": "#/texts/8",
+      "parent": {
+        "$ref": "#/groups/6"
+      },
+      "children": [],
+      "content_layer": "body",
+      "label": "text",
+      "prov": [],
+      "orig": "",
+      "text": ""
+    },
+    {
+      "self_ref": "#/texts/9",
+      "parent": {
+        "$ref": "#/texts/0"
+      },
+      "children": [],
+      "content_layer": "body",
+      "label": "text",
+      "prov": [],
+      "orig": "A text file is embedded as a package.",
+      "text": "A text file is embedded as a package.",
+      "formatting": {
+        "bold": false,
+        "italic": false,
+        "underline": false,
+        "strikethrough": false,
+        "script": "baseline"
+      }
+    },
+    {
+      "self_ref": "#/texts/10",
+      "parent": {
+        "$ref": "#/texts/0"
+      },
+      "children": [],
+      "content_layer": "body",
+      "label": "text",
+      "prov": [],
+      "orig": "End of report.",
+      "text": "End of report.",
+      "formatting": {
+        "bold": false,
+        "italic": false,
+        "underline": false,
+        "strikethrough": false,
+        "script": "baseline"
+      }
+    },
+    {
+      "self_ref": "#/texts/11",
+      "parent": {
+        "$ref": "#/texts/0"
+      },
+      "children": [],
+      "content_layer": "body",
+      "label": "text",
+      "prov": [],
+      "orig": "",
+      "text": ""
+    }
+  ],
+  "pictures": [
+    {
+      "self_ref": "#/pictures/0",
+      "parent": {
+        "$ref": "#/groups/1"
+      },
+      "children": [],
+      "content_layer": "body",
+      "label": "picture",
+      "prov": [],
+      "captions": [],
+      "references": [],
+      "footnotes": [],
+      "image": {
+        "mimetype": "image/png",
+        "dpi": 72,
+        "size": {
+          "width": 144.0,
+          "height": 76.0
+        },
+        "uri": "data:image/png;base64,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"
+      },
+      "annotations": []
+    },
+    {
+      "self_ref": "#/pictures/1",
+      "parent": {
+        "$ref": "#/groups/3"
+      },
+      "children": [],
+      "content_layer": "body",
+      "label": "picture",
+      "prov": [],
+      "captions": [],
+      "references": [],
+      "footnotes": [],
+      "image": {
+        "mimetype": "image/png",
+        "dpi": 72,
+        "size": {
+          "width": 3001.0,
+          "height": 2251.0
+        },
+        "uri": "data:image/png;base64,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"
+      },
+      "annotations": []
+    },
+    {
+      "self_ref": "#/pictures/2",
+      "parent": {
+        "$ref": "#/groups/6"
+      },
+      "children": [],
+      "content_layer": "body",
+      "label": "picture",
+      "prov": [],
+      "captions": [],
+      "references": [],
+      "footnotes": [],
+      "image": {
+        "mimetype": "image/png",
+        "dpi": 72,
+        "size": {
+          "width": 1627.0,
+          "height": 946.0
+        },
+        "uri": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABlsAAAOyCAIAAAB7QvRaAAAgAElEQVR4nOzdPXbiSN83YPs9zz4mgQnmzApgBaaTjjqdDEKTdNZhZ52Y0GSTdtTJwArMCuZMMBDcsxK/xm4bSeijhEqA0XWd85ynP6BUJZXVo9/9r9L14+PjFQAAAAB0xv87dQcAAAAA4KgkYgAAAAB0i0QMAAAAgG6RiAEAAADQLRIxAAAAALpFIgYAAABAt0jEAAAAAOgWiRgAAAAA3SIRAwAAAKBbJGIAAAAAdItEDAAAAIBukYgBAAAA0C0SMQAAAAC6RSIGAAAAQLdIxAAAAADoFokYAAAAAN0iEQMAAACgWyRiAAAAAHSLRAwAAACAbpGIAQAAANAtb4nYcnKdMZxt6ra2mQ0zjUyWcft7MsmhXcyggHOWuC0fcD8+iXd8p3zHXQcAAA5QUiO2+mddt7X1P6smnQEAAACA1pWtmvz735pFCZt//27UmdPbzIZqA86BC0F3mO00Yf4AAMBhyhKxA4rE3rfN7I+pIrcz4ELQHWY7TZg/AABwqNKd9esWib3vRZPLSd+DxTlwIegOs50mzB8AADhcaSJWs0jsPS+a3MyGo/mpO4ELQZeY7TRh/gAAQCOliVjNIrH3WyJm3cmZcCHoDrOdJswfAABoqDwRq1Uk9p5LxAAAAADojPJErFaR2PstEQvRu314fHV/c+reAAAAAHCwikSsRpGYEjEAAAAA3oPcRGwwGLz+MrxI7K1ELPFtAAAAADg3uYnY77///vrL4CKxXYlY4tsAAAAAcG4qVk2Gu+xdxAAAAAC4GPmJ2G+/1V02uSsRG/z2W/NuAQAAAEBL8hOxX3+tu2xyVyL2+6+/Nu8WAAAAALSkYNVkv2aRWLJErB+hWwAAAADQkoJErFezSCxZItaL0C0AAAAAaEnRzvr1isQal4htNsvJcHj903A4WW6Cti9rq51IUt157k3dBpazyW44k1ntBupr3OdMrw9sI/hYza/4c3cTTZx21mzS3Xke0+zgDm12V6LRdYjUzvJnK09DKm/imFOorBvndT/ZSZ6fA39Ijz20zTLOVIzQkcS5a3BPjXdzPttpBgAAl+7xp8V492fjRer329+WW98N8r8a8N3H9WI8uMoxCPhuw3aSPc375t06Z4h5g9o1tPu75Dfy2zxkPLvv5x2zjjb6XNRC1dWscSGSx2o+c9Z3+U08tVE16NRI65yiwCb3B1VyiMQ3d4PPO6sVHY3VTqqpn5/NjK7wKh0whZJfCb4UFbe4WPel0gPnHiAxgMRHd3+ce4Jq/ZC2NrTHgjtl3gHDp2LV2Mpvzil5HXn7Sng78W7O7f6zBQAAlCmqEatXJPa2aLJ+idhy0h/NV3l/s5qPhpPlsduJZDMb9qd53VlN+0GdKRpP6PcP0LjPxS20cRWaX/Hn7uY38dTGtD+sKGSKarOcXBedvJcOjWpd+afBjeY5zdQdVqx2rpbf0qPbXqX9Fg6bQolV3qHvAkkUtubdts7sfrJTdILCbwzHH9pyknfA+lOoqee5vN+R3IlYJt7N+WynGQAAdEJhIlZnJ7Hds2XNXcQKnrbfPD0VBD0UxGonls3sj5JsI+ABbPsIWfL9NgbTuM/bp7uSFuJehQhXvKq7raaPWU9nv3Q8L2o8umfzp4TV9I/wACBWO5vZ1/3x7d0uDp5CiQA/7F0gyb0P9/pxbveTndKf0pBenWBoJTezWlOoeT8KJ1e9H4lYN+fznWYAANARhYlYnSKxA0vEyjOYnwIeCmK1E01JivBiNf1W1pnSR66t+dfoz5FN+1zd6a1IVyHCFc9NaOo2EkvQeJ5VXYW3BktHFxwAxGrnavPX9/0BZm8XDaZQqkjs+1+1Xo+b7cfZ3U92qn5Kq24MJxhatCnUUMXkCvzBinhzPuNpBgAAXVGciIUXiR1YIlaZwfxU9YQRq51YgrKW+Y/CB52Q7wc/vwVq2uewMOO5kQiPeBGueGgT5aOOIzwP2wqZxtWjC5tAsdq5WucFYpnbRbMplCwSC1k3mYzoMv04s/vJzrr6p7T8epxgaLlRaErse1l+N6pPXdAPeryb8/lOMwAA6I7iRCy8SOygErHAGp2t0ieMWO1E82/lI+Czwuev6kfIl+9//fp39acCNe5z+EVo/ogX44ovf9Tob8uRWOAFf1Od9wSNLmBYsdq5+udH3hBTt4umU6j34VOtdZOJNZOH9uM495Od/LOYVXw9TjG0HyG5zxFC55CfsfnXb//EaCfk5nzG0wwAADqkJBELLRI7qEQsvEZnq/iRKVY70fz9PTDfKHhqDx7QalUrRyntSsM+18x0wla1FYlxxesEYm3PmrqBWHV/foSNrnJYsdp5mjd/5w0xebtoPoXqba6fWDOZ6sfZ3U92VvOCl0BkFMWBpxjafB5rCjUSOLsqz3C0m/MZTzMAAOiSkkQstRCpxCElYvuRxGC8WL++NH69uMscuaiuKFY78aSehQZ3i/VrV8aZruTnQvkDKmojkoZ9znne3HU6r9dNIrEYVzwZh2RbeFyv77IdbvOJdP/kpXqzHdHe+Ssvgfr778To3q5mzmWoGFasdpLz6+e0eGokfbuIMYVqba5fUCJ2fveTfGU3hYKfrlMPbTDeTaHssY4eOh92U412cz71tQAAAH56ffLePqO+Gi+yfza42z2jZ6zf/vN9/2u7P0tLfuLlU/vNZz6T24NY7awTjyD5Pa74SLYjuZ/a723pUXJ7m/1AWZcrtNXnnFMc8JH9D+aOKsYVT/cmr4Vsh0umf1OZzub25iVBKr0KufMi2+29D7XXTm5TqY8tFovijx40hZInqeKKFcyzWPeTQAG3nfwf0nX5h/LaOt7Qgm5R9aZiVU/KT2T1TTXoVhjv5nzEf7YAAIAyZTViiaqLkmVIB5SIpWt0nv5j//5mf7nlzX3qASOvB7HaacFzZ/Z6kn7M2S9kyRQzjBcPt5kB9W4f8h7foojS57xO7/f60Cqx6Fd8cPc5p4WnDn9J9re9SZOuFhkv8sbz1J3MZQjYJyvvQvRu/0w/sx+1ne2pTvz25ubtd5GmUI3N9fNLxM74frKTM0eyP6Q5Tju0bZ/Tf7J3OYOm0EEys2tw9+feTTXgBEa8Ob+LaQYAAJ1QmogltuYpfGA5YBex1KNFzgPK2+FTD977C2titdOC8Zfcztx8LH9gSjyo7yUIu0Y+55UiNBejz4Wdzj61H/aEF+eKJ+OQTx8Kmkif5bae19MPx+OP+eduvz/V8i9EJssKCCZjtVNyqmNNoeROYuVXLH8XsTO+n7zZz5aepX9IK2LrYw+tqM+f606hw6RnV9FdrvrHK9bN+T1MMwAA6IjSRCykSCz9vBEk+ZWS5+SrqhfIxWonvsJoI/XkundOU/lI8YgyBUyRxOhz0fPmfjuHPeFFv+IlKW6qhbakfnrKArG6O8cXXoj0sCobitVO2eWKNoWSf13ao/wSsfO9n7wJ+yHdd8KhFQacmftYW1VQ6ZtqYGcq22lwc34H0wwAALqiPBFLKHrN4NtzQvCiyeSjRdnj71bymSD7yBSrnfhKoo2ytxWkigdKR1RVt3WAGH2uyHQal13FueLZffULW6gVQR0k1ZXykxf8oouqttJRVsVViNVOWfYYcQoFbq6fOO2JSOJ87ydvAn9IS2PrIw+tNPNJ3cdainyCA6jym2q0m/M7mGYAANAZ5YlYIhQo+A/y3fNG8KLJgte8FfQg8UyQeWSK1U50ZQ/1qZVdGalnt/IRRY/EDu1zcCN7DR3whHfkK97/bTAYjLevyFs/5q77iqpyRMGXoeJCpKKs8qsQq53wvLzZFAoMMRPzKHHXOtv7yZuDf0hPN7TyIqg6W78dKBlAVXSm9KYa7eZ8/tMMAAC6o6JGLPHEUvEf5IeUiFU8oTwrDOVitRNd+ZkIq/SpHFGdgqGQ4x3a5+SDYlWa0bQmJNIVT2YH86+z4k70bh8eHu7vb296gVlvbU9HWK8Xd3fjwSA8Ua5WcSGCF2PFaueqNC+POYWSM7VwXW5yHuVuq39e95M3B/+QnnBoFbO6/XWBydlV9SMWeFNtdHM+/2kGAAAdUpGIVf0H+QH76ucXaBQrCuVitXM28rf7LlCjYKhNqQqMgEy0UZDXxhVfTf8oycSOoNe7ub29f3iIWIUWq9osZtVasahTKGhz/coSscu4n+ycbmi1plDbkU+T+Rzt5nzB0wwAAN6fqn3EKv6D/O2/7w/aRSxIweNFrHbiO7TYp9ZymshFYhH6HNRGkwfgaFc8fepW0/5wMlte0MNm9YVInIGSqxCrnavSCR13CgUsw6ssEQtz/Ez60B/SEw6t1hRqQ60kq6QzsW7O72CaAQBAh1QlYuVFYgeUiCUEp2glPYjZThy1e3OYqE9KMfoc1kacB+BmV3zv1K3m01H/+qxzsc1yNvk6D/pozZNTWHkSq51wEaZQwDK8yiqd87qfvDneD2lCs6Edfwpl1XsVcqybalA7ZzrNAACgSyrfNVlaJFa/RCz5iLKa9q8DjHKDgFjtnI161QyXoOYDcLwrnp+pnGcuttlmYcPr/mg6r/NsX+6oT/5bbU3o/SlUWYWYXyJ2efeTndMNLeCyH68GqkmiGO3mfMHTDAAA3qHKRKysSKxZiRiNtLzcKEj9B8WzWASUKiTKeM7FhpPTbi72nIPNJsPh9XW/dhYW62fxOD/T0adQ1eb6dTdyokNi3VTP4eYMAABUqkzEyorEDigRaybWspoz36P4WKezQ9JXvCwS21rNp9tqsaMXi/0sCHvJwabzVbyqsIzgDcCO1E5EFZvrL3+81dzE+zE78/tJE60PrdUp1ELh7Qlvzhc8zQAA4DSqE7HikgwlYjHV2/GGRqoisa3VfFsstl9k1JLNcjKsXxC2L9YT+7uNZUs31+/e2uQTerdTaI+bMwAAXKTqRCzxhJl5vjx6iRjv35msJ+rd/nkX0JHVfDQ8xgLKzWzYH0XcKOyiVUyh0s31670zkI45i0XdAADAsQQkYomnhNTz5UElYrXfPt9yO7wXsa94YCZ2tZr+0XYmtpz0p9KwaEo21y8sEbvg+8kFD+3dcS0AAOCsBCRiRUViSsR413q3D+ugQrF2M7HlxOvk4ireXD9RIjb+eHPMPgEAAHBmQhKx/CKxw3YRi7Us5fKWt5zhJuVtOHhHnlaueO/24XF9N66KxVbf/2orEtvMvobkYYPx3eJu3FIf3pnKKVS4uX6iRCcT41/e/eTNBQ/taGLdnF0LAAA4KyGJWH6RWPMSsfHisaaH27zsLVY7vBdRr3jv9v5hvSiPxVqLxDZ/fS+Pd7ZR2Hr9+HB/e/NrUIt1n9iLfnxjtXMKRZvrJ7K0khj/gu8nxx3a+5tCx1zVeMHTDAAA3ougRCyvSCzCiyZjvUy+my+l7/Lrz6Jf8d5NRSzWUtleQSA22OZgi/XzU/D97U0v+oNwrMlzppOwoEisuEQs5YLvJ2c4tJApdPBPX3IiHHPsIYM6w2sBAABdE5SIFb9ukmhO9fDWRP0+n/PW0s+x2ON6vcjLxdL7UcWSfXIejO/W68fHh20OdtOJgpB2ptDNx90K090tK6xEDLLe480ZAACoFJaI5RSJHbpoMtaOLB3ZdqvQOUdLgWqmEke64r3ezTYXy43FYlv+SO0hNl483N8WFoSFXvGAJ/bCVy620U6bCg+aXDf5OpDSErELvp+cbminn0I1xx6p5rH4R/WCpxkAALxDYYlYws//jo+waNKyybR6D0tnt14t7AEvUrdbv+LbWCz9IsoWDpl+cB4v7o/19sMzXTQZcQoli3pemw0uEbuM+0musxtalCkU1kiTsbdxcz67awEAAJ0TmIglHghe/jv+4H318x5VDxGrnfNU+bB0JiVieaU4ZZLdPtXMCT/g7Zd23+6YenAef6zIw0Kzg3rnpvgqxGqnQktTaL/Z8l3ELvh+crqhVR+tyQ0ht5GMei93DLurNrk5X/A0AwCAdygwEUv8h/zzf8dHKRELfAKeDa+Hw8lsuSz+bKx2Tir1sFT1bsMzKRGr+4AXrduNrvhms5zNJsOnv6vYGyy5HVXLKgOx1GN26fArz01ysWbJz2+sdsq1NIX2f5pq7CJ2EfeTfMcdWuXRklez7XW31S+MLZ5brdycL3iaAQDA+xC6ajJZcnHVoEQs3VLoE/BqNZ+ORv3rZIIRq53zUWNEmQ2oTifZ5+rN51Pdrv0AHOeKPz1i9vuj6XS+WlU/t2am/SmFh4lVT+yhdTmx2qnQ0hTKbq5f9aLJy7ufvDnd0KqOFmdvvLIfjTpjL7urxro5X/A0AwCA9yc0EUvvrd+kRCy1jqXeE3DqSTZWO+cjfERnE4jVuwqp59/6FyH+Fa9VwhJdrZWvdS55+ZP25q/vgXU5sdop19YUKgrxCzp7efeTNyccWvnRUlOoNJwtm4mlPxo1xl768xjr5nzB0wwAAN6f4J31d8+XT08nDUrEMk+q86+z0lCipCQkVjvnI7VIr2RE5xOIZa9C6RPe8ts0kS8dcBGiXPE665/a3a0t9XBcEc7Vu+Rl1yE4hYjYTrmWplDy9P7977KiROwS7ydvTji08Cn06UP6UKE/HhU/Gumbamhvqto5/OZ8wdMMAADeneBELFkk9uNHk13Eeh8+JZ4JSkOJzexr4okg8yQbq50zknpaWk2/5T6+LSej8wnEMltXlz3hpR8VD7kIca54at1SeSR2xF2Oyqtg6l7y4utQL5aM1U6ptqZQ6v2AP94u5V708tqNy7ufvDrl0OJMoeI+V2bFgRFUujdV7Rx+c77gaQYAAO9OcCKWLBKbzxuUiGWfgFfTP8IeUsqLCBq0kxay3XFb0k9LV/PRcG9I55WHXWUXpxU9KWb7XXERtnIuRJQrnmqksL9XmQfS1p9Hi8tXDrnkBeNKP2MHDCpWO6VamkLJCz2fv321MHpp534SqN3bzimHdvAUSkdQ+dFRwM9GduwhvcltJ9LN+fL+2QIAgHcrPBHLe4/9gaUhmVf4rab9yf6btDazYfrxYv9gsdqp/b671mRP8tOQhm9j2ixnw+szy8P2HhRznxQ32UfFwjqdigsR5YqnA5i8/r608ke0KqgC2Y7k7Zy9N5hQOePKDCks8IjVTomoUygh970IJeldtPtJoCPedo49tJTtzM4cbDnpV06hyugo8GcjM/aA3uSLdXO+vH+2AADgvQpPxHKeLw8uDck8E2yfUhIPF1ebp8ffYfYZZfzxprV20m18nZ3uTfd7I7paPY3p+ll/FPDYdnzZPCP9pHj1fA0yj4phEUrehYhxxbMdfu5v8lBPT7fZVnJmzdMz6/Wb/FStQvYRez5K9uN5LNf5j+pBz7+ZJ/a9ExMaZMVqp1hLU2iv2a3Q91M+i3E/CdTybeeUQ3s52OvwNpunn66gq5n5F2c7KWb583AwKHsnbHbsVb0JbefQm/NR/9lqfpsCAIAL9vjTIvEf6ePFY55F9nkg4HMFH9lvq0ponw5rJ7+Zwd367RPru0FJG4nvJ7+Uo7ydzAcajalKvD7X7XLJ4aovRIwrXruNvB6nRl1xBgNObLNBHdBSbpdjtfMYMNObHDfwfO9f6Iovxrovhak125veWI41tERHxuOwYxYNLbTLg7u7t082GftgPN71vc2b89H+2YpymwIAgItVo0Zsr0isye5B+/9ze7mi/4k8Uju566tOsxIlt7BlX3lVxHEFdvlVWXlP9YWIccXrthFnq6h99U5ccL4QNDWqxxSrnRARp1DS/nSqWAgY674U5qi3neMO7cXHoGMWXs3885P3/V/LPxE49t9/+638A7Fuzpf3zxYAALxLdRKx7CKvRrvM3Hyu8T+3D+4+Fz2dxWrnfPRuv1Q+Lg3uvnw6Rl8ChXT5zfjLbaMIJcYVr9VG4x4XqxEEjRf3H3e/K9tI+/cvAVcjYEyx2gnSzhTa2/ywMsW/vPvJm1MMLST6Kb6aYT8eIfFoyNifhvyh6jOxbs4XPM0AAOAdqZOIZf4n6YYvmKvxCFz6ABylnbzXBpxO5ePS00BafvNhXTf3gQuBxov7sqe7kAsR44rXaKPV59HQSOz5tCV+/srrQCpziMAxxWonSKwplJKtoqlO8WPdl0Ic+bZzzKG9ajaFQnoc1tXqlgLrDiPdnC/wny0AAHh/aiVi6f8Ab/wissBH4MoH4Bjt5D+4neqV9r3bh5Ih1UkEjifoKlR3PehCRLniYVUag7s/2yoQexb0ZPxzIMmfv/KpWT648DHFaidMpCmUlMkMglL8WPelAMe+7RxxaG+HbDaFqn5Mw7taMfbwusNIN+fL+2cLAADenVqJWKriomGJ2LOb+6qtigd364AnjAjt1FtH176iIYWdkJPYPuKVncPAaxl0ISJc8fIn2xfjRbt52FbVk3FiIMFFYk+D+7Po/IwXD+FjitVOoDhTKNViKjMITPFj3ZcCjnTs287xhvaqZAqFRKolX68b3ZX8pNUrdox0c77Af7YAAOB9qZeIxV+l0bt9WBc+BD89D4Q+dDdvJ+/J66R7FD8N6XE7prdODcZ368f4KUREN/cPRRch/FoGXogYM+fpkbQ4gRmMF0+Po8c428Xd2PYhMZDwIrGCJOFlTLU6F6udQFGmUNJhKX6s+1LAgY592zna0BJHzAu1gg+17XBe7nNAdHdz/5g39PrhbqSb8wX+swUAAO/KqV92+WKderq4Gjw9XywOeU9803aSjyeD7WP/AX04juQz4nhx6t6krRd3iae8g65l8IWIMXOe+5t4rHw+4NEvfboXNftQMB2e2nxtMmw6x2qnqQhTKEo3It2Xqg5zgtvOkYa2O17TKZTsb7POJifXc5IVW92bc3f+2QIAgPNy/fR/V7w/m9mwP109/7KVug7elcR02D6DH1y/Fasd6C43ZwAAeB/qrZrkbKz/WZ26CwBkuTkDAMD7IBE7H5vZcDiczGbLjVeFAZwNN2cAALhAErGzslrNp9NRv389WZZ/cPPv32+/DnyBHgAHcnMGAIBLIxE7TxVvEtz89f1tXU74C/QAaMbNGQAALoRE7Dyt/lmX/bWNagBOwc0ZAAAuhETsfPR+/X33m7I6hM3s63z3O+tyANrk5gwAABdIInZG+r8N3n69mn4r2q1m+W2aKEKwLgegXW7OAABweSRiZyRVh3A1H+Xt4LxZTkaJGoSrwacPqhAA2uTmDAAAl0cidk6SdQhX28eu6+Fs+bZAZ/P0wDXspx65LMsBaJ+bMwAAXJz/O3UHSHiuQ0hty7yajvrTkm+MP9603CeAznNzBgCAi6NG7KzcfBzX+rxnLoAjcHMGAIBLIxE7L7WeugZ3nz1zARyBmzMAAFwYidiZufl8N6j+1LPxl1vb1AAchZszAABcFonYuend/hn02DVe3KtBADgWN2cAALgoErHz07t9WFQszxncrT1yARyVmzMAAFwQidhZurlfL8YFxQiD8d36wZIcgONzcwYAgEtx/fj4eOo+UGCzWX774+t8tXr57WAw+P3Ln59veh64AE7IzRkAAN4/iRgAAAAA3WLVJAAAAADdIhEDAAAAoFskYgAAAAB0i0QMAAAAgG6RiAEAAADQLRIxAAAAALpFIgYAAABAt0jEAAAAAOgWiRgAAAAA3SIRAwAAAKBbJGIAAAAAdItEDAAAAIBukYgBAAAA0C0SMQAAAAC6RSIGAAAAQLdIxAAAAADoFokYAAAAAN0iEQMAAACgWyRiAAAAAHSLRAwAAACAbpGIAQAAANAtEjEAAAAAukUiBgAAAEC3SMQAAAAA6BaJGAAAAADdIhEDAAAAoFskYgAAAAB0i0QMAAAAgG6RiAEAAADQLRIxAAAAALpFIgYAAABAt0jEAAAAAOgWiRgAAAAA3SIRAwAAAKBbJGIAAAAAdItEDAAAAIBukYgBAAAA0C0SMQAAAAC6RSIGAAAAQLdIxAAAAADoFokYAAAAAN0iEQMAAACgWyRiAAAAAHSLRAwAAACAbpGIAQAAANAtEjEAAAAAukUiBgAAAEC3SMQAAAAA6BaJGAAAAADdIhEDAAAAoFskYgAAAAB0i0QMAAAAgG6RiAEAAADQLRIxAAAAALpFIgYAAABAt0jEAAAAAOgWiRgAAAAA3SIRAwAAAKBbJGIAAAAAdItEDAAAAIBukYgBAAAA0C0SMQAAAAC6RSIGAAAAQLdIxAAAAADoFokYAAAAAN0iEQMAAACgWyRiAAAAAHSLRAwAAACAbpGIAQAAANAtEjEAAAAAukUiBgAAAEC3SMQAAAAA6BaJGAAAAADdIhEDAAAAoFskYgAAAAB0i0QMAAAAgG6RiAEAAADQLf/333//nboPAEF++eWXU3cBAACAS6BGDAAAAIBukYgBAAAA0C0SMQAAAAC6RSIGAAAAQLf839uvbFlNFG/vajCjiMULQAAAAIhLjRgAAAAA3SIRAwAAAKBbJGIAAAAAdItEDAAAAIBukYgBAAAA0C0SMQAAAAC6RSIGAAAAQLdIxAAAAADoFokYAAAAAN0iEQMAAACgWyRiAAAAAHSLRAwAAACAbpGIAQAAANAtEjEAAAAAukUiBgAAAEC3SMQAAAAA6BaJGAAAAADdIhEDAAAAoFskYpybzXI2GQ6H16+efj1Zbjan7hYAAABwMRokYsvJ9S60mJ1HYLGZ7YKUyfLUvaGuzWwyvO6PpvPVavX2h0+/no/6/ettLnbCvgEAAAAX4/BEbPljvvvN6vtfxw4rlkuJ10XZLCfX/el8VfiBbS4mFQMAAACaOzgR2/z7d/K3q3/WzTsTbjkZjn4c84C0bDnpj+bVH9umYor/AAAAgGYOTsTW/6SLef7+92i1O5vZcFRSSsS783xFgz89H53LIl0AAADgfTo0EcuUiB2xSGw56U/FYZek/hVdTf+QiQEAAAAHOzQRy5aIHatIbDmpUUzEO7CZfT3gisrEAAAAgMMdmIjtlYidZHN93r3N7I+c+rDB+G6xXj/+tF7cjXOnBgcAACAASURBVAd7n5GJAQAAAIc6LBHb/PX9Z4wxGLxlFUfeXD9X7/bhNUd5vL85dW+osvy2l4cN7hbrh/vbm17v9U96N7f3D4/ru2wqtpp+s8c+AAAAcIDDErHEmsnff38LKo64uT4XYfkjs2BycLd+uL3p5X22d/uwF4rNf4jEAAAAgPoOSsQSayZ///jx99dfn0ORGO/H3g5i48XDbW4a9lPv9mExTv3J/KuVkwAAAEBtByViuxKxwW/9/m9vhTtKdgi3W3r7YrwIWOd6c5/OxOxeBwAAANR3SCKWLBH7tdf79a1IzLpJgmUCscHd57B9324+p9ZOisQAAACA2g5JxFIlYldXiSIx6yYJlAnExl9K10sm9W6/JMvERGIAAABAXQckYont0H//tXd1pUiM2tKBWHCB2Iubj6lITAwLAAAA1FM/EUusmXwuEVMkRn2Jt5U+zaNPH0ILxF6kIzHb1wEAAAD11E/EElnGc4lYukisTjqxWc4mw+ufhsPJ8nj1ZZvNcjJMHnt22MHTzRzaSvckYtUDArFsJHYOlYmNZsLzT0KzebQ9vlkIAAAAgWonYvslYqkisdB0YvsA3x9N52/p2mo1H/Wvh7P8b29mP/OC0duKzav56DVCuJ4ss59L/mHeofuj+Sp57OmoXxrJ7RredfF5CMlmnlspGAEJ6TWTP4PVWlKRWGIrsZAJkPpUyfVaTvI+FHsmbNt7/klIf7usY/t9WE62x699bAAAAOiq2onYfonY1VXvw6d66yYTD/Bpq2m/OMeIovDQV9tILvzgm9kwt52nEYgjqqTWTI4/1tlD7FUyhS2YdMXhbOL4xfM1/UrV4p40mQlP3+1Pc2djnYm0mX2dp/9kNf3DJAQAAIBidROxvBKxmpvrPycIxX89H7WXKFUcOvzgm9kfBUHGlTiiUnrN5G4a1ZGccolJl/7jkOMXyrxStaitBjOh9LvVX3+1/JbTyiGFdwAAANAZNROx5HK35DN3cnP93RK23BYqUoBtC9NvrdSJBRw6LIWobKitEVyIVInYodFNQZFYyGseUscvSnCDSsSazISQ6RgyGxPvft05MGcEAACAjqiZiCWyhNQzd7I0p3TdZG49y5751xaKrMIOHRBnrVO7YOXz/sNAB0c3BdVgAeWK6RKxoukaUiLWZCYETseq2fjPt+yKyWdKxAAAAKBMvUQsmSWkn7kDN9fPrWfJUVFodoD9vZaKlQdy378GhXoisSJhixYrpYrEdnMupEgsQEiJWIOZUGM6ls/Gv//O64ISMQAAAChVLxErKhELLRLLBmKD8WL9+Gy9GKf+JnYkttmr5kke+26Q/ruyo692LwVM9z/TRuBLNzsoyqLJTJHYbs5V7ySWOn7Rhcp8KE+DmbBXILb7/nY6plsIm40/G3g5vBIxAAAAKFUrESsuEQsrEssEYuPFw/3N6+sqb+7XqVwqHav1bh9e4oJEcDZePL66r3pbYTYQGy/WyWM/tZ5O5EI2Ahvcpdq4f8g00aBAqTuaFDOlisRy/zh3ImZL1HIvVP4bJArUngl7PwiJ72+nY6aF6nj4qQc/G3g+/N1HJWIAAABQpk4iloyVxh8zIVSqSCz/CT6dA4wXmRyrd/tnMhOLuewwE4htD52tobm5T8cYVSVeg7s/bzNtZJpQJJYv0qLJjN3ZTszE3LAroPor9aGqeqv6MyF9BvJm41U6IK6KxMZfUj24ud1vEAAAAEiok4gVr5ncuvm4CwGqym62McLn/bqu3odPuVtDNZUOxHIPfZWNMSpCiEwG8drEx2QLisTaVb0+Mm8O7Qdy5ROtqkSs/kxITce9YPhV7/ZL4geqdDbuxdMAAABAuRqJWNmaya2qdZPJ2pzBpw95VSypSCxeopSqCspPMJ4FB1pFoVq6Baq1seFVwWrKrMHg58dyrnTIvvovjRwwE5LTsSzMuvl8F/SSANvoAwAAQF01ErHyErHKzfWTgVpBIJaJxGIViaWqgkrraVIxRsnhi1OSwHduEltixpUvm3ybxr//XlxitpvrFXHTATMhsXi4ME97kfxpKJ5MhT9MAAAAQJHwRKyqRCydAezvApYM1Iqf4QNWwtUWWpNzlVn6WbhSrSQlaaP/FyZoH69GyvbWT0zj314/VvahihKx+jOh+ucotw1rcAEAACCi8ESsqkQskwGU7SZeFgT0fxsMBuO7u8V6/VC4vLGWVHFa1QKzoGWPbSz1I56yWPJtGg9++/D6sb20KUKJWHUHQvb/qnpv5oF9AAAAgK4LTsSSL4osegZPFollU4bqQO1F7/bh4eH+9vamF+s5P1mTVJ0eJMZQVJZj36Zzt7uI2Wu4i0dLpkKMErE4AorEzEYAAACoLzQRSxZaFZa2lBaJ7ZyuqCUgPUiOoWAIpf0P3NadNiUuYuYaJkrE+rtrVfShRiVi+TMh8YMUkmWZTgAAANCG0EQsrMQrVSSW2oYrtbv9UdXZt4mLU7b/Vi9/2WRwidghEj9INRs/JJ8FAAAAcgUmYoGxUupVkee3zCvoyAHLJmminbKn9LUtOkbRoslU2hRcItbQfHRdqT9t+zUEAAAA0EWBiVhyL66yB/nUA3zxusljiv5qQxs3nb+iZZOpRZMFwVl4idhxZ4J8FgAAAKIJS8QOW/OYfISPnku1puxFhcTWJDUtm5X5e+tnS8QKlk2+aiHxOt3qYQAAAGAnKBHb/PX9oDzrPIrEOC/tRI6Zcq78IrHiXDb3Q7boAgAAgAsVlIgdWuCV3lz/9CQcZ6fJUsDSaVm+W9lr9VfOp3ZVXJbHAgAAwKUKScQOX+ll6yP2RdpaPzUt99KrXZHYbhLu76ufs2zy/azvBQAAAA4Vkog1yAjOa93kefWms1LLJiNdk/3yv13u9naIzL76Ka8fCt9XHwAAAHi3AhKxJpuBv8MiMXufH9XhMyQ4qH09RN6V3atX27Xa+qLJ8eKxlvubdvsDAAAA3RGQiCWSh8HdOuDJfTHefXn+Y/n8/yOtlOMSpCbDoUVi5Ysm8zbwz9syP7tsUokYAAAAdEF1Irb8MX/7dVhIECXwiKZBFmdr9XakwqoDX7+Qfv9p3sTMWTb5U+51fflQ2yVi7bxoEwAAAKinMhFLluIEhgTpwGNvVdzpVlIGHdnO6u27+ZgoIzxsPqQuU+7EzO6tv7+v/lY6MD1qidjJw2IAAADorMpELJk8hIYEOUViNWpjlpPr4XAyWy7j5AXJIwdkELYRO4bUDHldWVtHsnLxavDpQ97EzFQH5u+rn/O2yf0PRZTo1DvcZA8AAAAuRFUidkCJ2NVV78OnXRax/9xfnkttj7hazaejUf96Uj8qKVUzg7CTVFvSAWn9SCwViBVdp91BtjOuMurcfihvq7H2KBIDAACAE6lKxA4pEcsEHi95R3BtTPRVi8lSocoMIrk9lW3E2pNaN1k7EksHYoXX6e3Kb2dcUdiVnB671Ky1a5/80VAkBgAAACdSkYglo4c6IcH+usmaixdrH7FYrQzCLmJHkl7SWC8SywRi+WsmU5IzLjOrkssmj1EiViugvdrMhtslxLPlRjkZAAAAxFOeiKVWmtUJCXI2108WiZW8XrD+qy0rJTOIiugllbVYNNmi1Mrap+vydRYa+WxmXwMDseQsXOfuq5/y948frZeIZQLaqvdsbksWt0uIp6N+fxh8hgAAAIAK5YlYsmKqXkhQXiRWXKp10L5lFXLWcBZIBWLjjzdRDk+uTCS2mv4Rlvgsv02TZXylFWKJZZM/Cov/dlP177+PsYtY8kejIhJLruEV0AIAAEA8pYnYwSVi2SKx5+f+VKlWQUlQnQggfF/y9JsNi6uR0i8wtItYu3q3X5J7iV2tpt+ql04uJ6NkgVjFksndLJzPX7+2d113yyZXq6LPxJT+0SgbdCr8Mx8BAAAgntJELFkiVrdiKpVCPdeEBSQBLUUA6XKkohAiE7YoyWldenv9q6v5qHxl4GY2TOdhlXuIpXcre7Z/Xfc/1O61z7xVYFTwRtX06tCQ3dIAAACAQGWJWKMVjKn866WeqyoJSEdSlRFAjTf1ZTetejp0NnnJFh9ZM3kEN5/v0mHUalq4XdZmNuxPMysfx19uy+dIehZuhUzktsuxMklg3nR8Gu4fydEKxAAAACCmkkSs4SZGqcf+l/RqLwkYvkUBm+UkXf9TEAGkl17mJAn5MpHY06H7yWPPhteZ4iOB2FFkV05ePYdi18PJLHFln67PZHi9F4ddDe4+V16knCKx/U5kY7PWywP3i+MS0/FlvJnhqlgEAACAmEoSscO31X+xv7n+XhKwmo/618/6o3kqAQiqiXn7evVr+LKRWPrY2bAlJGshir0ysa3VfPp6cV6uz3x/W/zB3Z8VBWK58qKlkNgsruwPQnI65ozXfAQAAIC4ihOxBtvqv8jZXD8//8hRGIjtL4ML7c1+NVKhysV4xNO7/TNsTqQFXqPsfDmHRZNboT8IzyyZBAAAgMiKE7GmJWJ5m+uHBlMlcUduPU/QlmLBaZyCnOOqn4kN7tb3gdcoM19yo91MbHaUFYo1EloBLQAAAMRWmIg1LhHL3Vz/KiSYGi9K4o6Di8QCk5cDF+PRRO/2YTEODsXGi4fwSxQ0X1Kx2TFKxLZu7hchmVjpTwMAAABwkMJErHmJWH6R2M/4o/hLVQlAbqL2GrdVqDh0zbCFiG7ug0KxwXjxWC8hqp12HW8T+5v7dUVEW6MYDgAAAAhXlIgtfyTevXhoRpCuz5n/WL7+8uZ+nR9/hCQAB248VXXobdgifjilm/uHomvzbHuBHmpfodQkLJjJyc8cq0Ts5cC3D4Wh2GB8t5bPAgAAQCuu//e//7386pdffjnysTfL2bevr6/VGwzGX/68vwkNADbLyR+j3Vc//XlfKzt4PvT3+Spx7M83PelDDP/999/LLw6dUZvN8q/E1Xm+vl8+f7jg65Oejj8HfBv8w9ABjScVAAAApJwyEeMiCS+IzqQCAAAgruJ3TQIAAADAJZKIAQAAANAtEjEAAAAAukUiBgAAAEC3SMQAAAAA6BaJGAAAAADdIhEDAAAAoFskYgAAAAB0i0QMAAAAgG6RiAEAAADQLRIxAAAAALpFIgYAAABAt0jEAAAAAOgWiRgAAAAA3SIRAwAAAKBbJGIAAAAAdItEDAAAAIBu+b+3X/33338n7AeXx4wCAAAAzpMaMQAAAAC6RSIGAAAAQLdIxAAAAADoFokYAAAAAN0iEQMAAACgW3bvmvzll19O2A8uxtsrJs0oYvHeUgAAAOJSIwYAAABAt0jEAAAAAOgWiRgAAAAA3SIRAwAAAKBbJGIAAAAAdItEDAAAAIBukYgBAAAA0C0SMQAAAAC6RSIGAAAAQLdIxAAAAADoFokYAAAAAN0iEQMAAACgWyRiAAAAAHSLRAwAAACAbpGIAQAAANAtEjEAAAAAukUiBgAAAEC3SMQAAAAA6JbKRGw5uQ4yHA4ns+Vmc4xOR7CZDd96Pnsvne6A5HRzYQAAAIB2RKsRW61W8+mo3x9O5BgcavljvvvN6vtfphIAAADQguirJlfzaV9xDwfZ/Pt38rerf9an6gkAAABwyVrZR2w17U+WbTTMZVv/s0r9/u9/RasAAABAfG3trD8fycSoKVMipkgMAAAAaEd775qc/xCJUUu2REyRGAAAANCK9hKxq/lX24lRw16JmM31AQAAgFbUSsTGi8cC6/V6cTcepD8uzqCGzV/ff5aIDQZvM8m6SQAAACC+SDVivV7v5vb+4XExTv6pSIxwiTWTv//+FolZNwkAAABEF3nV5M19KhNT4UOoxJrJ3z9+/P3116YQAAAAEF30fcRuPt8lFk+q8CHQrkRs8Fu//9vbJPKGBgAAACC2+Dvr9z582kViKnwIkywR+7XX+/WtSEyqCgAAAMTWwrsmk2mGOIMwqRKxq6tEkZhUFQAAAIishUQsmWZAkOWP+esvf/+1l45VpaoAAABAXG0kYsk0Q4EPARJrJp9LxBSJAQAAAC1qIxGrbbNZTobD65+Gw8lsWbMqqHkLZ2qznCUHdui40qfn/M7Obs3kS4lYOlatv7l+k/GmT/llTScAAADg2ckTsW120e+P5qu3SGS1mk9H/eEkNIRo3kKR5SSRi1xPqmKZxMeHs4BDV31+Mxte90fT5MC24yptfPudbJPb8zPKtlLYSKJX5SPeHSpsuGVN7ZWIpdfeFq+bbD7edGuT7Cm/ep1O18PKCQAAAAC8E20nYm8BR77lZJtd5P3Naj7qh0QQzVsospl9ne9+N7j7fFPxhZoL/RIx0GthVOrow/40d1xXq2lYvvPaTu75qdVI2/ZLxNLvLK2xbvLw8S4n1/1p/lR6aWE+qk5FAQAAgPegjUQsGfWUfm4bXpR9YD6qCDGat1Bs+S0ZSI2/3GYzqz01F/olYqC93HAz+6MgDnuxmv4RNK7SdkIbaV1eidhhm+sfPN7KmfRiPpKJAQAAwAVou0Zsv/jpVVXo86w0tGneQrHaBWJbYQv9Xo9QXCIWMrCQcVW2s5p+O4OAZ/PX9/0Ssat0zd33v4IWPR443qCZ9GL+9TxSRAAAAKCBFhKxZMBRvGgyXYJVrDi0ad5CsfoFYlu1XrKZKBEbf0zlbYEDqxzXOnEhitTftD6+omK5uu8sPXi8oTPppSdnkSICAAAATcRPxFKB2KcP+VFSugSrXH5VTvMWih1UILZVo0gsf6Xg3sFLlY/r+9eQnOf0kVhxsVytmrvDx7v8ETyTArsCAAAAnLfoiViq3qZozeRmr5pnMF6sH5+tF3eD9N/lLZlr3kLgEIILxLZqVDXlbSa/f/Cr5Li2AxunRlY2rlXifYnJczPOnJuT5zvF+6nVKhI7eLzZQGwwvlusX0/543q/hXqzCQAAADg/cROxzXKS3J88sxpw97FMnDVerB/ub17fMXhz+/C4GCf/fn+hWvMWisdwaIHYVnBVUyKGScVAmXgmNa7twO4fUgMLCWcGd6lzk2mhznscW1H2ys16RWI/1Rxv+ow/f/n2pvfWj962hfV5nTIAAACgoViJ2GaznE2G/VFImJSJs8aLXebz6uY+nUFk4pDmLRQ6vEBsK7SqqSgGSr+mM29cTwNbJ0rgKiOxwd2f2SFkTs1pi8SSl3IvQU2dzrDKrLrjzZzx/Ovdy84mAAAA4F2rlYjNR9dF+v3RdJ4u2yoKk9JxVlFuls4g0nFI8xaKNCoQez7ox90xS6KmgpWCqYFt87DcL/duv+wOUjGu/KuQ7OWJK56K10xuJTsa1M/a400cv/R6p5o4+UpTAAAAoJEW3jX5rDDOSWcQZUVYxTFG8xYKNCsQe5ZY6Fd8xKISseTAipacbt18vgs4SknEkzozp1S2ZnKr3rrJ+uNNHr/wPRDlTQAAAADvTiuJ2OBuXZiHpZeplcU+hWU5zVso6FnTArGt5EK/wiMWFEYlNxcrP3rvw6e3pKhkXEVvNjhwh64WlJeI1dxc/4DxJjPI4m/vNQEAAAC8a60kYqUr+ULroK4ya+Z2bTZvIVd6LeZBBWJbAUViBYVRVfVSSYmkqDgoys2Y9r4fWa10rXrIyRxq/qP89QgHjPfm/nG92L7Cc3A1Lv42AAAAcFnaWTW5mvaHk/z0IrVMrSqDyF2p1ryFXKkVkwcWiG0FFIklIr1kolfwx/kSSVFhjVdVrNaKWpuSVZWIZaKsimq2w8bbu9m+wvPh8b4iAg0KIQEAAID3oK19xK5W81FuJlZjmdpVfsFV8xZypFdMHlwgFnTERKRXmegVCshnDm/8WBLLRAsvZbJIrDyJOv/xAgAAAOehtUTsavtqyoI6sZ8CEoyKgqvmLfwUq0As6IiJSC8ZA9UMyqq3tSqNC9vaFWvzb53P7qr9CqviwovETjJeAAAA4B2qlYiNF4+F1uuX3ZhS5l9nmQSjzl5Z+Zq3sGcdr0Bsq6JIrCj5KgjKApxya/ys9T91Plu1ZnIrVSRWsRdcazbL2SQ5SQAAAID3LFqNWK/3vBvTepHat2s1/VZYJha0yK00XWrewrPvXxMFYtX7t1eqKBILSL7mo+tK/VSn36PAbDP5Xs3j7+C1jcKGw+v+aDp/7+cbAAAAeBV71WTv5n59l6wUy+RLyU3ADtO8hYzVKtNg40isNISLsotYWn5MdPbbaiWvZFkGmMr+iuvhIo53s1nOnoOw65coTBYGAAAAl6WFfcR6t1+SdWLN8qXULlLHaqFpJJasasq2tfnre36JWLJi6v2qMYrDBtxqkdhzQdg2BuuPpoIwAAAAuFyt7Kx/8zEZiZ3TLleBGkdixesmw/bO6oBkNFhHW9Nps5wMrY0EAACAbmjnXZOpSKyoqqf5tviRNtb/aZB4L0DTSKxw3WQL7wV4pw5d/drO5vrLSX8kDAMAAICuaCcRS70f8H0UiQ3u/vzzU7RIrLBILJEDjT/eNDnEO3f4ItH46yY3s+HIeyQBAACgQ1pKxFKbdxVEGM2DsohR2/jLbS/V6YaRWEGRWAvb6r9TDV6QEDthXX6rfm3nYHy3uBtXfQoAAAB4H1pKxKJpvt98SAuDu8/beq3UYs94bwRIJDiJHKhszeR48VjL/burNmtyXeMWiW1mX8vqwwaD8WK9fny4v735NeJRAQAAgFNqKxFLLZs8d9sCsedfRIzEcovElIi9Sr5g4G4dEPotol2ZtPwN/gfju7ttEPb4+PBwf9Pr8n5vAAAAcImOXSPWICn7mSE1byH7py8FYs/iRWK5RWJlJWKpNZvvQe66x8BRLH/s6rLCXjDQ0s502UBsML7bBmEP97e3gjAAAAC4WCdcNRm0+K10u6nmLeyJF4nlFIkFl4i9i3cRNJBcMxlYLBeyM90B0rNjvHi4vy0Kwpov4AUAAADORFuJWFEOVfgSxnw5KUTzFkpFi8R6H3avrvzZz/JdxAo24z+hQ4K5/m8BH0rOjrASsZaKxJK1alfjxfvbjw0AAAA4xCl31q+Z++REJ81b2BcvEttFdy/9rLGL2DsoEmtQMnVAiVg6YWwlMhx/LM/DGrwdEwAAADgvLSViqbgkFXokS30qc5/kLk9vrTRvoVy0SCzR0ed+VrxoMln8diZFYmUKAqJewBsZDykRy6ybjLO5fp1ozqJJAAAAuBwtJWKpuCQVetTKfSo3bz+shQqxIrFMkVhliVitqO9qMxsOh5PZbLk5STlZYUBUnTomlyrWeeVmS5vr/1QVzSkRAwAAgMvRTiKW2p4pE3okc42KuCnVzC6xaN5ChViRWLpIbBepDD59yOtJKur7/ld54rMtflut5tPpqN8fztoJxcryxsKAqPIcp7K08BKx1jbXD5OaSQAAAMD71koilk4PMqFH+OK39Lbnu12emrdQJVIklioS+2sXBBXFQMmoryISS64GrRUrVQqrVGsQECWztDolYi0XiZW3JxADAACAS9JCIraZfU2mB3uhRyrXmH8trG8qLjRr3kKVSJFYskjs+1uEVdiTdBHU9FvxYZffpofGSnUUxnINAqKDS8Sy56eqiq6msqKzzJQGAAAA3rnYidhmOelPk+vp9lcIpl4aWBj8LCejwkKz5i1UihOJJYvEVqXb6ucc9Wo+muQfNx3QFKzBPFRA7NQoIEqWiNUo23uWikIjrJtMVxsWRaub2R9Te4gBAADAJYmYiG02y8mwP8pkJTnxTzrQeg5+slFEJs3KRifNW6gUJxJLRTg/lZV0pSOx3IFlA5rIgVg2dpr+kc2JsplnPXVe77gnlWDFWDeZGWtOtLqZDZsMFwAAADhHtRKx+ei6RL8/mmejg8Hd55wgKhNoPbXbH75FP5vlbHidydX24qzmLVRKL808MBJLRzgvSovVMpFYemDbkU2yAU3UTcS2Mn1eTfvD2c8epM/sYLAf91VpuP9Z6vTELhLbnu3hZFZ6tn+K/qZLAAAA4Jjaedfkq6L6pWygdXW1mo/6P4O1UTaDyIvVmrdQJX2EQyOxbMJVWRi1/4XdwLYjy4SOh4ysyl4XVtOfPUid2fGnT/XbPnxb/RexN9fPFvGt5tOSsw0AAABchlYTsfGX24IioN7tl2zwU7OV5i1UiROJ7a2brCqMuvl8F156FX3J5LO8tZ57xh8/1G+5wbb6L7K7nDWtEttPVgsNxuO3j0YoTwMAAABOp8VEbLy4LylfCg1+iougmrdQIUokll03WV0YVSPrOyzqqxTQgwNPatMSsb3N9f89oImU0LM9uPvz/uP+ElgAAADgPWorERvcrcvysKttFPFndaI1uPuzOPNp3kKFKJFYuuAqqKjr5n4RktKUR46NVKWNB0ZxjUvE9jbX/+efA9pIC0lWX2ZR4lLaSAwAAADesxYSscH4bv34EJCY9G4fypOf8aKimeYtlIsRiaUjnMAY6OZ+XRHTVEeOjZSmjQdHcc1LxLJFYn//XfzJUFVlYoPXWZS4lJZNAgAAwHsWLxEbDAbj8d1i/fhwHx5C3dyvF+Pc5GUwXgRFPs1bKBMjEktGOOExUO/2oTAU22aOjZK+Jh1ocFaXPxIvAD30HZnphHG1irH3fdkkejrVb+NNXMpD95UDAAAAzsD1//73v5df/fLLL6fqxGY5+/b1+/xnuDEYjL/8+fmmVycwad7CmUoPbDuyT18+394cbWTPx3995eJgvPjzvvLY//3338svTjijDpIa6/FPNSXe7aQCAADgTJ1FIsYlEV4QnUkFAABAXC2+axIAAAAAzpBEDAAAAIBukYgBAAAA0C0SMQAAAAC6RSIGAAAAQLdIxAAAAADoFokYAAAAAN0iEQMAAACgWyRiAAAAAHSLRAwAAACAbpGIAQAAANAtEjEAAAAAukUiBgAAAEC3SMQAAAAA6BaJGAAAAADdIhEDAAAAoFskYgAAAAB0i0QMAAAAgG75v7df/ffffyfsB5fHjAIAAADOkxoxAAAAALpFIgYAAABAt0jEAAAAAOgWiRgAmgEOUQAAIABJREFUAAAA3SIRAwAAAKBbdu+a/OWXX07YDy7G2ysmzShi8d5SAAAA4lIjBgAAAEC3SMQAAAAA6BaJGAAAAADdIhEDAAAAoFskYgAAAAB0i0QMAAAAgG6RiAEAAADQLRIxAAAAALpFIgYAAABAt0jEAAAAAOgWiRgAAAAA3SIRAwAAAKBbJGIAAAAAdItEDAAAAIBukYgBAAAA0C0SMQAAAAC6RSIGAAAAQLccmIhtlrPJcHj9ZjiczJabTdy+AQAAAEB89ROxzWwyvO6PpvPVaveHq9V8Our3r4eT5YXFYsvJLvabXdjYTiZxUksNJa0AAABAC2omYsvJsD+drwr/fjUf9QVHRLL6mbQOJ+YUAAAAEE+dRGw5uR6VpGGvVlOhGFGt5uYUAAAAEE94IracjOahn11N/5BfENVq2p8sT90JAAAA4CKEJmKb2dfgPGxLJkZ085FMDAAAAIggMBFbfptWL5dMW02/iS+Ia/7DnAIAAAAaC0vElj+yBWKD8d1ivX58tV4vxoNB5jPiC2Kbf1V6CAAAADQVlIhlArHB3frx4f72ptd7+6Ne7+b+4WG9GKe+JxKj0njxWGC9Xi/uxpmcdfX9L5EYAAAA0ExIIpYOxMaLh9te/gd7N/fru2SCIRLjcL1e7+b2/uExnbOKxAAAAICmAhKxVCA2uPt8U/bh3u2XZH4hEqOxm/tUJrb6Z32yrgAAAAAXoToR2/z79+434y9F9WFvbj4ny8T+/ldBD02ZUwAAAEBM1YnY+p/dWyYHv/Wrm+x9+LSLLxT0EIE5BQAAAEQU9q7JnwafPlRViG2l4gsFPUTQ+/X33W/MKQAAAKCRykQsuWjy919DArF0fKGghxj6vw2qPwQAAAAQolaNWDDxBZFJWQEAAIBo2knEkvFFyBK3zXI2GQ6vfxpOZsuDlsVtlge3kvzqcHLY4auPkRzl9kA1R5oZ30G9PP2pPoqODBMAAAA4SDuJWB2b2fC6P5rOV28b+K/m01H/ejgrTh+23/mZUrx9ajkZ9kfZVsoayfRg99XV/OmLk+VBoyk8xCQ7yu2Bfo405FjZTj738m34uxNyXdLY6U/1UXRkmAAAAMDBaiVi4Tua39w/vnq4Ldl8bDMb9qer3L9aTWukD0/tjOY57QQ0spzk9WA1H0XLxJaT6/40r3e7Y5XlWC9N5J+mp/GFdvMMTnUsZa88vaBhAgAAAG2pTMRS+zd9/ytqFrCZ/VEQXvw83vSPoPChtJ3SRp5zj4K/i5OJlR0h9GDLSUkTYd08/aluKPmGh5JPvfdhAgAAAMdQb9Vk1EisKr14PmBA+FDZzmr6rSAzWn4r/eb8a9PkI2SMVQcrzcN+frNip/kzONUxFb3z9MKGCQAAALSlOhFLvTcyYhRQkUYFH3H91/fKduY/8trYzL5WVG89HfxHVdtlAsf4drCcXlZ3cvvNr98jdCPSqQ44Un2bxKGLFk2efkYBAAAA70N1Itb78CkRiT0v0otQJxYS9LwesbRS6/vXkBgkL8AIClDm89Bu5lj+qPflnH3aNgHpzNV2j/7iTx37VAceq5ZUIPbpQ16J2BnMKAAAAOCdCFg1mdxJbOvlTYzNUrG9NGowXqx/bsW/XtyNkxlc6VrNZBS0a2O9SLeQFzbtxVVvX9/rwIGyRxiM7xbr11E+rvc7uT/Q4vMU3Mmjn+oWpMaQv2byDGYUAAAA8F6E7CN283Gc+ZPVcyo2OzgWy2RF48X64f7mNefo3dzePyyShwzZvmxwl2ijd5Np4Wr1T2arrUwXkl/f78BB0kd4PsDtTe8tzeltO7ku72VmO/lDOnn8Ux3bJr2R2vjjTc6HzmBGAQAAAO9G0M76+5HY1TYVm4761wflYumgZ7zYZRe7Q96v73ZFOZUBxuDuz9tMGzf3qQQjU9KT7kL11+vLDPJL9gDPeqWHSS+ZPKiTpzjV0Ww2y9lk2E/mYYO7z3mB2BnMKAAAAOD9CHvX5M3nu4KlcYfkYqmgZ5te5H6qd/tllz9UBBj5eVMqyEuX9KSzpoKvFw46yPqfxOq7/Bxnv5eplCWok+Vh1ElOdT3z0XWRfn80nafWQhYEi2cwowAAAIB3JCwRS4cJ++rlYsmsKH8N3ItkJFUWPxTmTcU5TVBcVTHocsmqpYK94H8q7GVYplYaRp3BqY6oMOu6rGECAAAAbQtMxLKLznI952LVm+4ntnwqq526Sr/msmSNWv5W61v933ZdTjYQGlc1CECSIU1xB58le5kQoZMnOtWtGNytC/Kwc5hRAAAAwHsSnIhtS6b+DNgualX1Kspk0FMRFSVfc1lc0jP4rR/w/ZTguOrwSOzm/nG92L7jcHA1Lu5gmUQnDywyO4dTHU3xMseLGiYAAABwBDUSsed94NeLcXUt0DYVmywL/jIR9JQtcHuRKMkprMipCkH2paqvyuOqJqVPvZvtOw4fHu9z975KfC43pamR8xR18gxOdUSr6TZqzfmLyxomAAAA0L5aidjVcyj2sF4EbDk/Hw1nzReVBZT0VERaVSrSj9PVBCVLxCqGGKWT7Z/q5lbzUWHSGug9DBMAAABoWd1EbKt3c/vwuN6uCCz92Gr6R04mlih9Ckkeqmu0SiOt/K/XCJva3x8rQGXNUn4nz+FUR7efiV3kMAEAAIA2HZKIPettVwQ+bhdRFicEq+m3vYqeRBpVc3FaKxuZn3yB3GY5m3yd5/x5YtFkpfwisTM71QXGi8dC6/XLTmwp86/poPV9DBMAAAA4IwcnYi+2iyjLcrFsepH+y9F1pf50Vfj9Q0UIm2L0YjmbDIfX/dF0XjHECKv4TnWqG+o9564P6/QbHfKC1hfvdJgAAADAkTVMxF4852L5yyiL3xBYW/62T83iomNvGbXZLGfPQdj1SxRWHM4kX4dZLfJavjZOdQPbNzqktq6b/2i4m9iLMxsmAAAAcCxRErFnz+U8+6+izERiteqzzkKUsOm5IGwbg/VH09IgLKL3d6pL9G6/JOvEEpHYRQ0TAAAAOIp4idizbbVYeolb4Rv9Tqde+VVjm+VkGLA2stjJ9zo7Czcfk/PKFmAAAADA4SInYlstLXF7p5aT/ujwMIydVCR2fjkrAAAA8H60kIjtLXHrbj3PZjYc5bxHsqbunr+01PpVJwUAAAA4WCuJWHaJW1ctv1W/13AwvlvcOVkhUq/9VCQGAAAAHKw8EVtOrl8NZ7VqcpKRWFF4MV481nJ/U6cHxSK/mLHIZva1rD5sMBgv1uvHh/vbm19b78upTvWRdWSYAAAAQEMt1YgdLXY6X5u/vucUiA3Gd3fbIOzx8eHh/qZXvGV+vfN35JcFnEjn5xQAAAAQR3kiloggIq1SS618O72AUR0YNmUDscH4bhuEPdzf3pYFYXkOPPVndqrb0pFhAgAAABGF14jV3Mo8IKg41eboR8lQ0kHaePFwf1sUhG3+/Xv/D2t1MreFpI7sQ9+RYQIAAAANlSdiDbKjopAmftlZI5UZSmXYlG/5I7GH2HjRbMOqyk7m17Gd2aluriPDBAAAANoWXiO2+v5X7AKcU5X01MlQIuzQNf5Ynoc1DnoCUruOVE91ZJgAAABAMxWJWHIv83oFOImYZ/Bbf/fnybKzU5X0JPtQkaEcWCKW/Fpq+OGHqNHJgtTuHE51TKkTtTurlzZMAAAAoHUViVhq2eT8xzK43eIkKRmyVZf0bGbD4XAymy03MYt/wuuvIpSI/f5r+Ub6RYdIdrK0Pq/wXJ/DqY4odaISZ/XChgkAAAC0rmrV5M3H8e434ZFY6k2L6UgoVdJTtRJz285qNZ9OR/3+cBYtwkj2oXRQB5aI1ZHacSwp9ERl32pZv4W3Zlo41fGkTlSy8O6yhgkAAAC0r3IfsWQBztX8a1iGkAppsttopVZilgcYJcFaM8k+lERixWFTDeVlS4WBWOiJWn6bFvbxHE51LOkTlerhJQ0TAAAAOILKRKz34VMiEltN/wjIxFIhzd42WqmVmKvpt+ISrfJ2mkivBi3K+crCpnBl6zI3s6+FgVj61BecqNIGzuJUx5EZZ7qHlzNMAAAA4Ciq3zWZihueM7FJ+drJ5WSUXN726UO2ECe1EvNqPipoLx2C5LTTRKoP+SFKedhULixx28z+KI3c0mnkfLS3yq+qgbM41c1tlpN+apzZHl7GMAEAAIBjqU7Erm4+3w2Sv1/NR8PJsiDjWU6Go1QxT17skA4wnhOMveYyYU/0+CK1GjQnRKkMm2o0n5u4bWbDftUR9tLI/u7Mb091ZQNncaqb2DwPc5SJJveWO773YQIAAABHFZCIZUqVtlbzUX+4DWd2scNzdLHNLlIZTUHskAkwrrbN7TKMzXK2F/ZE3/IpO6htzDf72YWwsKm8+XSWlWw9f4A/ZTYdy6aRz2f++ln2VBc4g1Ndbj66LtHPGebg7vNNtpWzHyYAAABwRkISsave7Zfx3h+utuFMPx1d7GUXRXU42QAjGfVc90fTTAqSl4E0tTeo1Xz6swvJFGYwGOx9NUS6Bi3Zet4Ai3u5l0bWdQanOq78SXVxwwQAAADaE5SI5dQqhRjc/f/27h63bbRdwLANnH2ksacYzAqkFdhfkyptOrm0m3Qp06WRSrtLO1WakVZgrSCYYqRiZiU+ln9Jir8iadF6rgs4QD6MQpEvqQC8zyPqx2XRHE6jDfb0BbftiJL31p/+qHxRngYpazSZvLx06zH8uTVyawtl2W4IS92hydf8i+rADhMAAADoUc0idnRy+aNpEytKF88brFF66myoheqIcv/Wv+248boHOJr+uP5YVt0q93Iy//Gpiz056nGpuzKZXxfNdh3SYQIAAAC9qlvEmjax0XRVmC6enF3P6xSMkgbSWsUxtfxqXZ2ppcc5usRXLDMPEtso38s66zOApe5C1UV1IIcJAAAA9K1+EduUmdtVrSg2msxv6wzhnF1Xba9GWGunrDa1niSqmlp6WafEc/i3vjb5uKGCld9en9Hvp3lvNYClbmU0ma7uqi+q936YAAAAwJtoUsSOHtLM3Wo6KZurmsxXt7WbQ1lk20SQWmGtnYJd6KacnF2v5vmr9XB0L++QGBK7+bko2M27zbaeXzfaLHSNRpTcwL6XurnR/WFOppsDva65e+/yMAEAAIC3dfzvv/8+/unDhw8N/t56vfjr+7c/fy1ffl9yNJp8+vrl8myX4LBezO439vJblW02tav14uLz009M3r/91x/XHb77w+G9/NphD0e3no1Prx43P6qIPv0v9X///ff4h2ZXVLcGcEXRoUFcVAAAAByQXYsYQ9KgiPVPvKBzLioAAAC61fBbkwzS6u/nSb2jP34zBwUAAABQShEDAAAAIBZFbLAWF8fj8cVstlivK165/ufX8x8LfmoSAAAAgBeK2JAtlzdXV+enp+NZaRRLfGkSAAAAgCqK2GCd/j56/uPy71XJCxc/b17+7DFiAAAAAFUUsXfh1z/FQ2LJIOZLkwAAAACVFLHBOvntj5c/L6++L/JftZ59ew1iRsQAAAAAqiliw5X42uTR0c23vGeJrWefrxLPEJt8POt/twAAAADeOUVsuJJDYpsxsdPxxWzxksXWi9nF+DTZw3xnEgAAAKCO43///ffxTx8+fNjrnrBtcXF8flP9sieT+d31AGbE/vvvv8c/uKLoiosKAACAbpkRG7Kzj5P6L/aVSQAAAIBaFLFBO/syHVW/amM0/SKIAQAAANShiA3byeXXOmNio+mPS78yCQAAAFCLIjZ0Z9erqjmxyfxWDwMAAACoSxEbvpPL2+IoNprMV0N4nj4AAADAu6GIvQsnl7d3q/l0MnoNY6PRZDpf3d1enxkPAwAAAGji+N9//33804cPH/a6JxyI//777/EPrii64qICAACgW2bEAAAAAIjl/17+9DKFAZ1wRQEAAADDZEYMAAAAgFgUMQAAAABiUcQAAAAAiEURAwAAACCW47u7u33vAwAAAAC8HTNiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyvRWxxcfzqYtFsM4m/PJ6tO95H3qX1bLzz9TRAB3Y4bye5cM3tvNRdnS/nHQAA4DAVzIjd/HTvBwAAAMBBKvrW5OEnsfVsbOSjPcsIAAAAvDuFzxE78CS2nn2+Wu57J94/ywgAAAC8Q8VP1j/kJLa4OBVy2rOMAAAAwLtU8luTv/45zEfkr2fj85t978T7ZxkBAACA96qkiC3//OsAk5jv+XXCMgIAAADvV0kRO9AkBgAAAEBsZUVMEqOFk8vbu2fXZ/vem9YO7HD2YzRd3TWz81I7XwAAAJQpLWKSGAAAAAAHp7yISWIAAAAAHJqKIiaJAQAAAHBgqoqYJAYAAADAYaksYpIYAAAAAAclt4iNRqPE/1r+vXqjnQEAAACA3uXPiH36NEn8r5ufi7fZGQAAAADoXcG3Jv/3URIDAAAA4CAVPUfsrOcktl4vLsbj4yfj8cVifQhPK1svZhfPRzW+mBUeUuZ1i4bH3tXqDewspHbnYW+abiCxrLusa0cediOxrD2ua+qId1qzly21Xfx9WTwtQNnnrVLLD2RiQ+mT/7CUs8P4xw0AAODA3D2bvyaw0XSV+t/3JvO7Mtm/XGo1nySfU/b6N0vepNHerKajrRenN7D93pV7XfQOr/uSftvn/7q93bzX1X//XVavu+00WMbkYWa2+bqV8tVrvy6vfz/vPZsoOZz0y/KX9X5dm11izfao/hnsZfHr7mbbLb5u62lLmR0f5R9S5b9eeR/c5tspOiFPe5Z76MkPVJ3VabA7AAAAlCn+rcm+psQWF6fnN8u8/7K8OR9fFLxNk71Z//VnYvuTj2fNd3IH98d1tX1YN+efM5Mr+a9bXp0WHXr2b++wev1tpyPr2ThvVdqvS92/342Hw8hf1vt1vTodt5hiynurondqdgZbL/7+LL6nd3xz6A3X+P7o866cphtaLy6Oi07I057lLubp76+Fq85vmKz+fnmP0e+nDXYQAACAtOIi1ksSe7j9LPnv9/eNBffg9fdmL0FscVF0XMur74s6rzsqPPQXu69eP9vpynr2uaQl1GgTJataZ107kt86kzpLTFVv1eAMtl78/VnPvm2f9j9+O2mwiZKFXF5lY3bZnnwu/UQ9ylvMk9/+eP0fv/6pesP1P79e/tzsSAEAAEgrKWKp8YVOklj5zffz+xTcy9dNYvsIYrm35i9uvj3fB5e/rmr0rc3q9bCdzmQHfbako+L23y/rYRuvJ6BHFef2ZV86WNjKA27wRm0Xf4/Sn/QnjQanKhay7qHX+kQVbTH571r1kJgRMQAAgK6UFbGT/33qNIlV3nw/v1F+wKiXxPYRxKoObPnnX+s6rytNNy1Xr/PtdKVWSSq59ur8/TeoOnWXtf3nqFYPe3ijOnW03eLv0yoviDUZnKpx8HUOvX4Pe9ji1scq+f94qBoSMyIGAADQmbIi1m0SqzlDs1EQMOoksb0EsZ9VB/aYxKpfVzwk0n71ut1OZ/7J7RpbCq+93EGhnL//7duv6lftrsa5fdHqc9TgBFZXzbaLv09//8zb9waDU7WunJtv3//uYDMJWx/x5Pcmq4bEjIgBAAB0prSIZZNY9WNuitWfodnIvwevTmL7CGI/a8SQ+zvdda1oUhAfuli9LrfTmV9/1uwJBdde7QNaLht1i4aaBLFW69qwvzxPJ+Zru/h79etX3r7XH5yquZLLm4JfSmi2mYSts19/SMyIGAAAQHfKi1gmiZXfX5faTgajyXy1evrFy9V8Okr/1/zplnQS27573EcQu7l5PbLRdL7KP6BfP7+/rsBoMl09v26SOfDcW+JuVq+77XQnFapeli9nXfKvvfwDKtpGb5Kl4nknnlf1brWaZndk5ySW019eDzjviEs/si0Xf69e9/3p+O/3usng1PZK7nTl5G/m5dxvPlNb28p+xOsPiSVGxN7qJ3QBAAAO18u92/w1No2miVu6VCVJ/pekgr+c998fvN7FF74m/61SL8q+JL2vk3neniZfk/+KOlbZdpRzTNljLnrXzOtydqqr1evsLNRaxpKX5C3N1la297b0LXL3Nu887XjaSw4ne93lLFlmR4qWtcE+FGyn+iVdLf4uO73jceduK2fH5vN57ku39776yqm1TNsf3rzjy24ru5m6K5R4XduFBAAAoGJGrKMpsfQMzf3d3PXZ9ld+zq5Tt6n50xKpKbHM3uxjQuz17ebZYzr7kpNjHo79qPp1SV2tXndnoXM5y3K/J+mQUDUSeH8Kbi8zB3RyeVsUJnsymn7JWdX7Hfma3I/dljU7kJRzwNtHXP2R3W3xd7K8Oj2uqdYvZW5WO7nXZzU/85mVHE1/bF052RXIlZ5R3P43IH9buw6JJUbEfGcSAACgrcoi1kUSS91/5tx9vrzV5Y9EjanxLLHU3qQfKfW2QSxzZ/4o8xS2jcnXnGNPv26rPXS1el2ehY7lLkv2S7LbEoWg4BQc1QiO7SWfd/7pfwXLmt6PnQpT6ngLDzhbs6rq246LPwTFq10hvZJFK1B55aQbc9k/OeXbqvckscS7eaw+AABAa9VFrIMklrz/LL+JTb1X/r1hURLLjGu8bRDLP6jk7MeDgr3KSWcJXa1ep2ehU4UnK32us2Un1SOKjygzntWvktmd8rNcQ6a/5GecB3V+lfVlO7st/hDsHMTSV05RWay+clJhrfyfnNI5sHpDYkbEAAAAulSjiLVOYsn7z7L7+Ox7Fdwb5iexAQax9OzH0Y571dXqdXwWOlSyLJkFTEnNvJUeUc/jTtnn6hep/wT1/Ldp8KXg+gNpOy7+IOzchWrH4fIrJ3Xiqz7cpatZZ0jMiBgAAECn6hSxzKxT4ySW/FJZ5a1cMsYU3BvmJbH631/qQeGdeXrhig++rJV0tXpdn4XOlJ2srSm7hFTWKD+igXwD8PT30Wg0mUw3P0a49eSuZqqu8NTCleS3XRd/CHbuQsl/LCrmzGpfOZU7U7qadWKpETEAAIBO1SpimfvChkksOdtQ42tOiZvDonvD7SS214fq170z3+k+tqvV6/4sdKR89erNKVUeUa/jTsmccfNtVvzZOLm8vb29vr48O9klaCQLYPUVnvqMFEbNLhZ/bzoZEavaSNka3J/P1Wo+nU5Go7aRqnpIzIgYAABAt+oVsVZJrOlsQ+LmsOhOPpvEZvsMYmVHlbzRLbuPLb7v7mr1ejgL+5Uc9Kk8orcbd1pefS5pYi2kBptqJJGB56yBaDfadf+fT84uL69vb9vO/FUPiRkRAwAA6FbNIpZNYg3Ghuo+ZelFnXqRTmJXV/v7lcmeJza6Wr1ezkIndr29b/Qt0H77UHrjy6vT8cVs0XUWazLYtFHrqWXvua108qXJ6gV4o7JYNSRmRAwAAKBjdYtYo5+vK9L4Vq64vKUfHZ701kGstrb1oavV6/AsdOCNbu97DXxbG1/eXJ2fHvfRxR7UW7MaKefN28pourqrqeXQVYnUL0RW6uTKWS9mF99uyl5R9WMWRsQAAAA6VruI7ZzEErdyy6vT4xrOS28dn6R/APPVYIPYbrpavZ7Owv40G/TpWX586rmLNTHML76208VZ7z0JrjctbHx8en51U5HhkuVt+3QZEQMAAOha/SLWyZRYh/KT2B6C2N57DDX0+2z9gjy78dDFxhdtHy7WvAAO/aci34sdrpxNB5tdjMfHx6c1Wtj2+2wPiRkRAwAA6FqDIraPJFY225KXIQ5sQqylriaDBj5hNIChmbIktrG8udpMi+1/WIwepwufBsIeO9jVzbLJlzPLh8SMiAEAAHSuSREb/pSYIBZGs4dB9a4qiW0sbzbDYnv+0NCP9eJi3GAgLE/JkJgRMQAAgM41KmJDT2KCGPtycvmj6LcekpY35+O2X6Cs641+JfHQ1fj26Xo2Pj1v0cK23yg9JGZEDAAAoHvNiljmJrtOEkt+R6lzmUGhgX+7bwddrV6vZ4EHNZvY0fLq81s1Md7C4uL0qpOBxcIhMSNiAAAA3WtYxDJTWXueElv8TP8e4vLTXd45AAARlUlEQVTPv6QG9ubk8nZVa1BMEzsci4vOfpW1aEjMiBgAAEAPGhaxbBKrnsrq8RfvskHsAJNYV6t3eL87WPrLfPtzcnl7t5pOqrLYm1yoA3vU2kFaz77V6WGjyXQ+nVS+rOCiNiIGAADQg6ZFLJPEmt3ZT+Z3Dd1eFt8AbgexA0xiCV2tXrdngS0nl9e3q3l5FjvkC/XAlH3jeP3Xn+XVcZPCVqu72+vLs9+q3yp/SMyIGAAAQB8aF7E2SazT53zlBbGDLg1drd7hPW2tjjcemDo5q8hiQxpsi6X4AfaNFQSx0aaDzVcPMfn68uykfk/OHRIzIgYAANCH5kWs1ZRYd/KD2EEnMRI67Bq9echid6vVPK+LNXwGX/Pj9WsKvctm1tFkulrd3d1uOtjZLu0q7ywbEQMAAOjFDkWsYRLr54FP6SA2Gr3u0GElsa5Wb6CP3Xoze8xDJydnmy6Wm8XeitmihIafheLpwkyVn8xvry8LB8LqXYE5+2ZEDAAAoBe7FLHdp8Q6G+ZJ3YuOpj++Jh4cf1hJLMHXJpOadY29P2V+k8XSP0S5+2mo1zT3fsjvQZvPQrpxTebXZ+33J/lP6+O+GREDAADox05FbDuJ/VPy2sQXgboaT0oHsU//Ozn7mPght0NKYl2tXh9nYTgqu8YwvkF4cvm1+vcGiyQKYK2OkzxkKSWp2Q+vFl86qeQ4+VjRw2oGysTOPX5OjYgBAAD0Y7citpXE/qwZHGrdys/Gx+PxxWyxKHrtVhA7OjrYJJbUzep1t529SjW+qhPe87zUer2YzS7G9+tV8Wyw1GXaTNOmaUSsjup/KuqtY2UQS4W1sg9gonxuXmZEDAAAoCc7FrHMnMVyWXLXmBxuqXsrv1zeXJ2fnx7nFoacIHa4Sayr1ev8LOxdgyMq+hmGTqxn49PT86urm9JPwZPkTjeU/KvVj+VPHbLhopQmn4WuLp3agbJ4gs1ZBAAA6NKuRazBtEvqFq/ZrXzeVMR69i0niB1sEutq9To+CwNQ/4h6DWIpldN3LSa3Gp3B1EjSQE/g3jRYyZKv2zb6Jm6DS/C1121q3esF4ywCAAB0auci1iCJpeZibr7NSqNB1WzL+q8/E03hNYgdbBLravU6PQuDkDrhJUfUcxBr8vXNVs8zS5/B0pCz+H6V+JQM9QTuTfrKKVnJ9L82aamuVpFCm1yCie3++mfxesE4iwAAAJ3avYjVT2INfpoyMwC2PRVRHMQONYl1tXpdnoWBSCWi5dX33LKxuDjveUIs9SW88ssuOSLWuHCkv09XFjXTAWa4J3BvaubhdFgsU/rly4aXYHJI7KcRMQAAgJ60KGINklj6oWNXn+vdgaZ714OyINY8idV5wvz+dbV63Z2FjL0tYzryHd2cj7cOqf8ellnYojC3kSqNOxSO9EPICt8pc8zVJzCe7GchdyXTYbhC8aRZ40swOST2y4gYAABAT9oUsfpJLPPC5dXpxfZPGK5n4/St4/Y9YHkQq5XEmv5k3wB0tXpdbWdjGMuYfQr5/SGNX45pvZiNj/vvYUfZUpUX5h72Z/a55VcZMwUw953W2QAjiOXJfBZuzrc+CouL04oBsexpz/sBiq2PUx2JIbGXH2uo/DFLAAAAmmlVxHZOYpv7x0S7OFrf38ePszeg2/eAVUGs8ZTYzbfZdhManm5Wr7vtZO1vGbcvwOX9MR0/OD2v+5W3trKl6iHMJZdkvZhlV3anwpF9o3QCPHo4f5kAI4jly145m4/C8ylbr+9PV3XIyvbYm/PkWX/4NB3nV7WKhpzzc5MlE4Xr2fj4RX6MBQAAYFu7ItYiiSXbxfHp/X189s5xlyDWOIktr572Ydh3kl2sXpfb2drI3pbx7Mt0VP2qvm0njOXN1cu6PsS5zMru+FSorSSWPoHb508QK5ITU59P2elp4nSNJpOiKyw9JHaUPut5n6a6tjbsO5MAAACda1nEWiWxUrsFsRpJbPtu8+GVw/4CZfvV63Y7w1nGnEaUZzTqNZw1XdedQ1XNw239PgHUPGd//P570X9qdjImk9rXyFZh9Vh9AACAzrUtYg2SWJNpntH0y25B7FB/cbLt6nW9neE4ufxaeQWOpl8/9bsXzWbVJl8vdw1VdQ63i/cJoM45u/8I/K/4vzZIYpP59cfX/1X1YxTZ3mxEDAAAoHOti1jBsFCOBvfyOXfydYNYZRLLeUjPe9Bu9XrYznCWsbJs3B9I7yM2Dda1ZWg8u57Xe6fJ/Hr4QXOfqs9Z1Yxd3ST2cCoS/1JWzVJmtmtEDAAAoHvti1iDOYma9/J5d/L1g1hlEsufaqua2ti/FqvXx3YGtIwnl7clh/RWYajmmNho+qPt4FatM6iH1VCxktUzdrVC6NOpSEbkqs9JOjgbEQMAAOhe+yLW6Gk6Z9erimwwmq5y7uSbBLHqJDaIp7HvYNfV62c7g1rGokOqtyDdKA9zjybz1j1sY1Nyyhb/LQ/7fStpYvVm+aryZOJUNBgSS43eGhEDAADoQQdFrNkDpk8ub1eFd/P3d4+3ecGgWRCr/uLk5Y+tfDLwR+s/2Wn1+trOsJbx/pDuNsf0skejyXR1V3dBOnJ2Xbys9zs0X12fdbQ/Z9e3Re/U4Dpgs5J3eSs5mdddxOKTvjnjia3sOiRmRAwAAKAPd/uxSsWLo9FoMp2v3nYPEnexo82t65u+eztdrV4H23kny5icIJvMe3+3+TS5ro8L08vKPLzT6/u8+afoYCQX8qGl7rSBUWdnPHHBjnbYGwAAAKoc3//f7jkN3of1bHx69ThnaISK4VtcHJ/fPP5xMr/zFVgAAIDOdfGtSRi61d/L6hfBQKz/+fX8R08RAwAA6IUixju1no3H44vZbLEe+q+EQkOJguspYgAAAL1QxHi/lsubq6vz09Pji0X5CxMjNwoDg2dEDAAAoHeKGAeg4pf7kr9VqjAweEbEAAAAeqeIcQCWf6/K/rOniPGeGBEDAADonyLGO3Xy2x+v/6NsSGw9+3bz+r/M3DB0RsQAAAD6p4jxXp3+Pnr58/Lqe9GjxBbfrxITYmZuGLrFz5eCO/l4ts89AQAAOGCKGO9Vakjs6OY87/H668XFeWJA7Gj06X9mbhiy5EijfgsAANAbRYx3KzkkdrRpYsfj2eLl25Pr9eJifJrqYb6ExhCtF8+X7f01e5oYaXS5AgAA9Ob47u5u3/sAu1lcHGeKV4XJ/O7a19AYmKLr2OUKAADQHzNivF9nHyeNXu+pTLwjvjMJAADQI0WMd6xREhtNvwhiDFDm679PPPMOAACgT4oY79nZl2leTMgz+XopMPBuCGIAAAC9UsR4104uf9RqYpO5JzIxUOlfTX0k4AIAAPRLEeOdO7m8nVd8d3I0XelhvCO+4QsAANA3RYz37+x6NZ8UTIqNJtPVrXEb3pGRATEAAIDeKWIcgpOz69vVJou9drHRaDSZr1a31+ICA3f2ZT59SroPBddEIwAAQO+O7+7u9r0PAAAAAPB2zIgBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACxKGIAAAAAxKKIAQAAABCLIgYAAABALIoYAAAAALEoYgAAAADEoogBAAAAEIsiBgAAAEAsihgAAAAAsShiAAAAAMSiiAEAAAAQiyIGAAAAQCyKGAAAAACx/D+3EEE57pFxcwAAAABJRU5ErkJggg=="
+      },
+      "annotations": []
+    },
+    {
+      "self_ref": "#/pictures/3",
+      "parent": {
+        "$ref": "#/groups/7"
+      },
+      "children": [],
+      "content_layer": "body",
+      "label": "picture",
+      "prov": [],
+      "captions": [],
+      "references": [],
+      "footnotes": [],
+      "image": {
+        "mimetype": "image/png",
+        "dpi": 72,
+        "size": {
+          "width": 144.0,
+          "height": 57.0
+        },
+        "uri": "data:image/png;base64,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"
+      },
+      "annotations": []
+    },
+    {
+      "self_ref": "#/pictures/4",
+      "parent": {
+        "$ref": "#/texts/0"
+      },
+      "children": [],
+      "content_layer": "body",
+      "label": "picture",
+      "prov": [],
+      "captions": [],
+      "references": [],
+      "footnotes": [],
+      "image": {
+        "mimetype": "image/png",
+        "dpi": 72,
+        "size": {
+          "width": 55.0,
+          "height": 47.0
+        },
+        "uri": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADcAAAAvCAIAAADIPMXnAAAC60lEQVRYhe1YvXLaQBA+BQpnxokpzBtAigxtXMgvgBAIV1AkGXeihMZdkkmRBxDjNKFTQ0HFWLJ4Az8BkyLwBk5NBXe5PyT0AyPrbkYp9BXH7t3e3qfb3TsJBSEE/nu8yptAKpQzz5xOpygAQAgyCQZd4Oz1WbPZrF5e5sYS8+j3+yRdaMqg0A+RyqXSZrN5fv7rum5b16vVaua1skc8KaGViL7b7S4u3qqq6jhu5oWA4F5GacY6ttsthPDN+fnV1YfMCwExlsB5eDhh0O12bdv21UajkXktAZYAdTqGL5NwY+K4gbjFoUfb7e7jp89svFzKvpAQSxbfg2pBvKEUWV+lUmFD5XJOLHFaOs6piB/CMLqZFwIiLCFE7XaHK/tokyY4lACTxS83obx0XSelcW57iSOu+3uJUJCOh5sn6S1B8FRH/IxMpBg/P7NCpMbBo5v2RjEMI/tCwhFv7xW/2evhohHcVKHqCfM6NiIh8iInEYwtnsBPSmoK3eO+GG5AeEAChG5I7zFt9XRyqx6AtJZ+ZEzyx5RQjb+oXwRCebnwHlMa5xdxhCPeSiwa6RBhCQXfGtNDKOL39z8R4B+19PikIoT805d28vseoe/fvmZeSyn+25CGgqU8FCzlQQLLxeB6vBZ3cwp57OV6fD1YpOr0gSLwTNU0VWB6RGQmRA40rgaj2NzyLNW0LBWrqrVaUYEbhp1E/WAFT4g7jyCBJZtH6NJftLJMJiCmqdx9wJayZNNWe4EZJjrhLnwFm1CWyQwJEiKu9vQajsCf5dOormDUR5PfK5J+CtOeAB01bzRqrt2wfTC/DPG02rsGm0+k5XwecRJHbWj3ZvUWsHgAEnEqL1X/6X9p6/EP4PFnZxQmc5ZGmPAJHyEnSePr8e2s51nLEX36l7Jkz0i3T8FpTWi1gr0E2p21pLpyOzvu/f1dyAmuEHIc1PQemUuKZTGoz3r2UBva+OEnvDOO4m1DHgqW8lCwlIeCpTz8A/yfTw2BugvpAAAAAElFTkSuQmCC"
+      },
+      "annotations": []
+    }
+  ],
+  "tables": [
+    {
+      "self_ref": "#/tables/0",
+      "parent": {
+        "$ref": "#/groups/2"
+      },
+      "children": [],
+      "content_layer": "body",
+      "label": "table",
+      "prov": [],
+      "captions": [],
+      "references": [],
+      "footnotes": [],
+      "data": {
+        "table_cells": [
+          {
+            "row_span": 1,
+            "col_span": 1,
+            "start_row_offset_idx": 0,
+            "end_row_offset_idx": 1,
+            "start_col_offset_idx": 0,
+            "end_col_offset_idx": 1,
+            "text": "Item",
+            "column_header": true,
+            "row_header": false,
+            "row_section": false,
+            "fillable": false
+          },
+          {
+            "row_span": 1,
+            "col_span": 1,
+            "start_row_offset_idx": 0,
+            "end_row_offset_idx": 1,
+            "start_col_offset_idx": 1,
+            "end_col_offset_idx": 2,
+            "text": "Amount",
+            "column_header": true,
+            "row_header": false,
+            "row_section": false,
+            "fillable": false
+          },
+          {
+            "row_span": 1,
+            "col_span": 1,
+            "start_row_offset_idx": 1,
+            "end_row_offset_idx": 2,
+            "start_col_offset_idx": 0,
+            "end_col_offset_idx": 1,
+            "text": "Rent",
+            "column_header": false,
+            "row_header": false,
+            "row_section": false,
+            "fillable": false
+          },
+          {
+            "row_span": 1,
+            "col_span": 1,
+            "start_row_offset_idx": 1,
+            "end_row_offset_idx": 2,
+            "start_col_offset_idx": 1,
+            "end_col_offset_idx": 2,
+            "text": "1200",
+            "column_header": false,
+            "row_header": false,
+            "row_section": false,
+            "fillable": false
+          },
+          {
+            "row_span": 1,
+            "col_span": 1,
+            "start_row_offset_idx": 2,
+            "end_row_offset_idx": 3,
+            "start_col_offset_idx": 0,
+            "end_col_offset_idx": 1,
+            "text": "Travel",
+            "column_header": false,
+            "row_header": false,
+            "row_section": false,
+            "fillable": false
+          },
+          {
+            "row_span": 1,
+            "col_span": 1,
+            "start_row_offset_idx": 2,
+            "end_row_offset_idx": 3,
+            "start_col_offset_idx": 1,
+            "end_col_offset_idx": 2,
+            "text": "300",
+            "column_header": false,
+            "row_header": false,
+            "row_section": false,
+            "fillable": false
+          },
+          {
+            "row_span": 1,
+            "col_span": 1,
+            "start_row_offset_idx": 3,
+            "end_row_offset_idx": 4,
+            "start_col_offset_idx": 0,
+            "end_col_offset_idx": 1,
+            "text": "Total",
+            "column_header": false,
+            "row_header": false,
+            "row_section": false,
+            "fillable": false
+          },
+          {
+            "row_span": 1,
+            "col_span": 1,
+            "start_row_offset_idx": 3,
+            "end_row_offset_idx": 4,
+            "start_col_offset_idx": 1,
+            "end_col_offset_idx": 2,
+            "text": "1500",
+            "column_header": false,
+            "row_header": false,
+            "row_section": false,
+            "fillable": false
+          }
+        ],
+        "num_rows": 4,
+        "num_cols": 2,
+        "orientation": "rot_0",
+        "grid": [
+          [
+            {
+              "row_span": 1,
+              "col_span": 1,
+              "start_row_offset_idx": 0,
+              "end_row_offset_idx": 1,
+              "start_col_offset_idx": 0,
+              "end_col_offset_idx": 1,
+              "text": "Item",
+              "column_header": true,
+              "row_header": false,
+              "row_section": false,
+              "fillable": false
+            },
+            {
+              "row_span": 1,
+              "col_span": 1,
+              "start_row_offset_idx": 0,
+              "end_row_offset_idx": 1,
+              "start_col_offset_idx": 1,
+              "end_col_offset_idx": 2,
+              "text": "Amount",
+              "column_header": true,
+              "row_header": false,
+              "row_section": false,
+              "fillable": false
+            }
+          ],
+          [
+            {
+              "row_span": 1,
+              "col_span": 1,
+              "start_row_offset_idx": 1,
+              "end_row_offset_idx": 2,
+              "start_col_offset_idx": 0,
+              "end_col_offset_idx": 1,
+              "text": "Rent",
+              "column_header": false,
+              "row_header": false,
+              "row_section": false,
+              "fillable": false
+            },
+            {
+              "row_span": 1,
+              "col_span": 1,
+              "start_row_offset_idx": 1,
+              "end_row_offset_idx": 2,
+              "start_col_offset_idx": 1,
+              "end_col_offset_idx": 2,
+              "text": "1200",
+              "column_header": false,
+              "row_header": false,
+              "row_section": false,
+              "fillable": false
+            }
+          ],
+          [
+            {
+              "row_span": 1,
+              "col_span": 1,
+              "start_row_offset_idx": 2,
+              "end_row_offset_idx": 3,
+              "start_col_offset_idx": 0,
+              "end_col_offset_idx": 1,
+              "text": "Travel",
+              "column_header": false,
+              "row_header": false,
+              "row_section": false,
+              "fillable": false
+            },
+            {
+              "row_span": 1,
+              "col_span": 1,
+              "start_row_offset_idx": 2,
+              "end_row_offset_idx": 3,
+              "start_col_offset_idx": 1,
+              "end_col_offset_idx": 2,
+              "text": "300",
+              "column_header": false,
+              "row_header": false,
+              "row_section": false,
+              "fillable": false
+            }
+          ],
+          [
+            {
+              "row_span": 1,
+              "col_span": 1,
+              "start_row_offset_idx": 3,
+              "end_row_offset_idx": 4,
+              "start_col_offset_idx": 0,
+              "end_col_offset_idx": 1,
+              "text": "Total",
+              "column_header": false,
+              "row_header": false,
+              "row_section": false,
+              "fillable": false
+            },
+            {
+              "row_span": 1,
+              "col_span": 1,
+              "start_row_offset_idx": 3,
+              "end_row_offset_idx": 4,
+              "start_col_offset_idx": 1,
+              "end_col_offset_idx": 2,
+              "text": "1500",
+              "column_header": false,
+              "row_header": false,
+              "row_section": false,
+              "fillable": false
+            }
+          ]
+        ]
+      },
+      "annotations": []
+    },
+    {
+      "self_ref": "#/tables/1",
+      "parent": {
+        "$ref": "#/groups/8"
+      },
+      "children": [],
+      "content_layer": "body",
+      "label": "table",
+      "prov": [],
+      "captions": [],
+      "references": [],
+      "footnotes": [],
+      "data": {
+        "table_cells": [
+          {
+            "row_span": 1,
+            "col_span": 1,
+            "start_row_offset_idx": 0,
+            "end_row_offset_idx": 1,
+            "start_col_offset_idx": 0,
+            "end_col_offset_idx": 1,
+            "text": "Action",
+            "column_header": true,
+            "row_header": false,
+            "row_section": false,
+            "fillable": false
+          },
+          {
+            "row_span": 1,
+            "col_span": 1,
+            "start_row_offset_idx": 0,
+            "end_row_offset_idx": 1,
+            "start_col_offset_idx": 1,
+            "end_col_offset_idx": 2,
+            "text": "Owner",
+            "column_header": true,
+            "row_header": false,
+            "row_section": false,
+            "fillable": false
+          },
+          {
+            "row_span": 1,
+            "col_span": 1,
+            "start_row_offset_idx": 1,
+            "end_row_offset_idx": 2,
+            "start_col_offset_idx": 0,
+            "end_col_offset_idx": 1,
+            "text": "Book venue",
+            "column_header": false,
+            "row_header": false,
+            "row_section": false,
+            "fillable": false
+          },
+          {
+            "row_span": 1,
+            "col_span": 1,
+            "start_row_offset_idx": 1,
+            "end_row_offset_idx": 2,
+            "start_col_offset_idx": 1,
+            "end_col_offset_idx": 2,
+            "text": "Ana",
+            "column_header": false,
+            "row_header": false,
+            "row_section": false,
+            "fillable": false
+          },
+          {
+            "row_span": 1,
+            "col_span": 1,
+            "start_row_offset_idx": 2,
+            "end_row_offset_idx": 3,
+            "start_col_offset_idx": 0,
+            "end_col_offset_idx": 1,
+            "text": "Send agenda",
+            "column_header": false,
+            "row_header": false,
+            "row_section": false,
+            "fillable": false
+          },
+          {
+            "row_span": 1,
+            "col_span": 1,
+            "start_row_offset_idx": 2,
+            "end_row_offset_idx": 3,
+            "start_col_offset_idx": 1,
+            "end_col_offset_idx": 2,
+            "text": "Ben",
+            "column_header": false,
+            "row_header": false,
+            "row_section": false,
+            "fillable": false
+          }
+        ],
+        "num_rows": 3,
+        "num_cols": 2,
+        "orientation": "rot_0",
+        "grid": [
+          [
+            {
+              "row_span": 1,
+              "col_span": 1,
+              "start_row_offset_idx": 0,
+              "end_row_offset_idx": 1,
+              "start_col_offset_idx": 0,
+              "end_col_offset_idx": 1,
+              "text": "Action",
+              "column_header": true,
+              "row_header": false,
+              "row_section": false,
+              "fillable": false
+            },
+            {
+              "row_span": 1,
+              "col_span": 1,
+              "start_row_offset_idx": 0,
+              "end_row_offset_idx": 1,
+              "start_col_offset_idx": 1,
+              "end_col_offset_idx": 2,
+              "text": "Owner",
+              "column_header": true,
+              "row_header": false,
+              "row_section": false,
+              "fillable": false
+            }
+          ],
+          [
+            {
+              "row_span": 1,
+              "col_span": 1,
+              "start_row_offset_idx": 1,
+              "end_row_offset_idx": 2,
+              "start_col_offset_idx": 0,
+              "end_col_offset_idx": 1,
+              "text": "Book venue",
+              "column_header": false,
+              "row_header": false,
+              "row_section": false,
+              "fillable": false
+            },
+            {
+              "row_span": 1,
+              "col_span": 1,
+              "start_row_offset_idx": 1,
+              "end_row_offset_idx": 2,
+              "start_col_offset_idx": 1,
+              "end_col_offset_idx": 2,
+              "text": "Ana",
+              "column_header": false,
+              "row_header": false,
+              "row_section": false,
+              "fillable": false
+            }
+          ],
+          [
+            {
+              "row_span": 1,
+              "col_span": 1,
+              "start_row_offset_idx": 2,
+              "end_row_offset_idx": 3,
+              "start_col_offset_idx": 0,
+              "end_col_offset_idx": 1,
+              "text": "Send agenda",
+              "column_header": false,
+              "row_header": false,
+              "row_section": false,
+              "fillable": false
+            },
+            {
+              "row_span": 1,
+              "col_span": 1,
+              "start_row_offset_idx": 2,
+              "end_row_offset_idx": 3,
+              "start_col_offset_idx": 1,
+              "end_col_offset_idx": 2,
+              "text": "Ben",
+              "column_header": false,
+              "row_header": false,
+              "row_section": false,
+              "fillable": false
+            }
+          ]
+        ]
+      },
+      "annotations": []
+    }
+  ],
+  "key_value_items": [],
+  "form_items": [],
+  "pages": {}
+}
\ No newline at end of file
diff --git a/tests/data/docx/groundtruth/docx_embedded_objects.docx.md b/tests/data/docx/groundtruth/docx_embedded_objects.docx.md
new file mode 100644
index 0000000000..32535271af
--- /dev/null
+++ b/tests/data/docx/groundtruth/docx_embedded_objects.docx.md
@@ -0,0 +1,40 @@
+## Quarterly report
+
+The budget workbook is embedded below.
+
+<!-- image -->
+
+| Item | Amount |
+| - | - |
+| Rent | 1200 |
+| Travel | 300 |
+| Total | 1500 |
+
+The roadmap slide is embedded below.
+
+<!-- image -->
+
+# Roadmap
+
+- Ship embedded object parsing
+
+The meeting notes document is embedded below.
+
+<!-- image -->
+
+Meeting notes: approve the budget.
+
+<!-- image -->
+
+| Action | Owner |
+| - | - |
+| Book venue | Ana |
+| Send agenda | Ben |
+
+Next meeting is on Friday.
+
+A text file is embedded as a package.
+
+<!-- image -->
+
+End of report.
\ No newline at end of file
diff --git a/tests/data/docx/sources/docx_embedded_objects.docx b/tests/data/docx/sources/docx_embedded_objects.docx
new file mode 100644
index 0000000000..8afc83e782
Binary files /dev/null and b/tests/data/docx/sources/docx_embedded_objects.docx differ
diff --git a/tests/test_backend_msword.py b/tests/test_backend_msword.py
index c0245ed6ce..ba4b107528 100644
--- a/tests/test_backend_msword.py
+++ b/tests/test_backend_msword.py
@@ -6,7 +6,10 @@
 import re
 import threading
 import time
+import zipfile
 from contextlib import nullcontext
+from copy import deepcopy
+from io import BytesIO
 from pathlib import Path
 from types import SimpleNamespace
 
@@ -20,6 +23,9 @@
     ListItem,
     PictureClassificationLabel,
     PictureItem,
+    RichTableCell,
+    TableCell,
+    TableData,
     TableItem,
 )
 from docx import Document
@@ -31,6 +37,7 @@
 from lxml import etree
 from PIL import Image
 
+import docling.backend.msexcel_backend as msexcel_backend_module
 import docling.backend.msword_backend as msword_backend_module
 from docling.backend.docx.drawingml.utils import get_libreoffice_cmd
 from docling.backend.msword_backend import MsWordDocumentBackend
@@ -66,8 +73,18 @@ def docx_paths() -> list[Path]:
     return docx_files
 
 
-def get_converter():
-    converter = DocumentConverter(allowed_formats=[InputFormat.DOCX])
+EMBEDDED_OBJECTS_DOCX = Path("./tests/data/docx/sources/docx_embedded_objects.docx")
+
+
+def get_converter(backend_options: MsWordBackendOptions | None = None):
+    format_options = (
+        None
+        if backend_options is None
+        else {InputFormat.DOCX: WordFormatOption(backend_options=backend_options)}
+    )
+    converter = DocumentConverter(
+        allowed_formats=[InputFormat.DOCX], format_options=format_options
+    )
 
     return converter
 
@@ -88,6 +105,10 @@ def documents(docx_paths) -> list[tuple[Path, DoclingDocument]]:
     documents: list[dict[Path, DoclingDocument]] = []
 
     converter = get_converter()
+    # The reference output of this file shows the converted embedded documents.
+    embedded_converter = get_converter(
+        MsWordBackendOptions(process_embedded_objects=True)
+    )
 
     for docx_path in docx_paths:
         _log.debug(f"converting {docx_path}")
@@ -100,7 +121,11 @@ def documents(docx_paths) -> list[tuple[Path, DoclingDocument]]:
             else nullcontext()
         )
         with warning_context:
-            conv_result: ConversionResult = converter.convert(docx_path)
+            conv_result: ConversionResult = (
+                embedded_converter
+                if docx_path.name == EMBEDDED_OBJECTS_DOCX.name
+                else converter
+            ).convert(docx_path)
 
         doc: DoclingDocument = conv_result.document
 
@@ -124,7 +149,12 @@ def test_e2e_docx_conversions(documents):
             not IS_CI
             and not has_libreoffice
             and docx_path.name
-            in {"drawingml.docx", "textbox.docx", "test_emf_docx.docx"}
+            in {
+                "drawingml.docx",
+                "textbox.docx",
+                "test_emf_docx.docx",
+                EMBEDDED_OBJECTS_DOCX.name,
+            }
         ):
             print(f"Skipping {docx_path} because no Libreoffice is installed.")
             continue
@@ -2706,3 +2736,262 @@ def test_body_level_alternate_content_with_no_usable_branch_adds_nothing(tmp_pat
         "Paragraph before AlternateContent",
         "Paragraph after AlternateContent",
     ]
+
+
+# Embedded OLE objects. docx_embedded_objects.docx was saved by Microsoft Word.
+# It embeds a workbook, a presentation, a Word document that embeds a workbook of
+# its own, and a text file that Word stores as a binary OLE package.
+_EMBEDDED_EXCEL = "embedded: Microsoft_Excel_Worksheet.xlsx"
+_EMBEDDED_POWERPOINT = "embedded: Microsoft_PowerPoint_Presentation.pptx"
+_EMBEDDED_WORD = "embedded: Microsoft_Word_Document.docx"
+_EMBEDDED_POWERPOINT_PART = "word/embeddings/Microsoft_PowerPoint_Presentation.pptx"
+_EMBEDDED_WORD_PART = "word/embeddings/Microsoft_Word_Document.docx"
+
+
+@pytest.fixture
+def no_libreoffice(monkeypatch):
+    # The previews are EMF pictures. Rendering them needs LibreOffice and is not
+    # what these tests check.
+    monkeypatch.setattr(
+        msword_backend_module, "get_docx_to_pdf_converter", lambda: None
+    )
+
+
+def _convert_embedded_objects_docx(
+    data: bytes | None = None, **options: int
+) -> DoclingDocument:
+    stream = DocumentStream(
+        name=EMBEDDED_OBJECTS_DOCX.name,
+        stream=BytesIO(data or EMBEDDED_OBJECTS_DOCX.read_bytes()),
+    )
+    backend_options = MsWordBackendOptions(process_embedded_objects=True, **options)
+    return get_converter(backend_options).convert(stream).document
+
+
+def _rewrite_docx_parts(replacements: dict[str, bytes]) -> bytes:
+    out = BytesIO()
+    with (
+        zipfile.ZipFile(EMBEDDED_OBJECTS_DOCX) as source,
+        zipfile.ZipFile(out, "w", zipfile.ZIP_DEFLATED) as target,
+    ):
+        for info in source.infolist():
+            target.writestr(
+                info, replacements.get(info.filename, source.read(info.filename))
+            )
+    return out.getvalue()
+
+
+def _embedded_group_names(doc: DoclingDocument) -> list[str]:
+    return [group.name for group in doc.groups if group.name.startswith("embedded: ")]
+
+
+def test_embedded_objects_are_not_converted_by_default(no_libreoffice):
+    doc = get_converter().convert(EMBEDDED_OBJECTS_DOCX).document
+
+    assert not _embedded_group_names(doc)
+    assert len(doc.pictures) == 4
+    assert not doc.tables
+
+
+def test_embedded_objects_export_without_page_references(documents):
+    # The Excel and PowerPoint backends give their items page provenance, but a
+    # Word document has no pages. DocTags export fails on a dangling page.
+    doc = next(
+        doc for path, doc in documents if path.name == EMBEDDED_OBJECTS_DOCX.name
+    )
+
+    assert "<fcel>Rent<fcel>1200" in doc.export_to_doctags()
+
+
+@pytest.mark.parametrize(
+    ("options", "expected"),
+    [
+        (
+            {"max_embedding_depth": 1},
+            [_EMBEDDED_EXCEL, _EMBEDDED_POWERPOINT, _EMBEDDED_WORD],
+        ),
+        (
+            {"max_embedded_objects": 3},
+            [_EMBEDDED_EXCEL, _EMBEDDED_POWERPOINT, _EMBEDDED_WORD],
+        ),
+        # The presentation goes above the budget, and what is left of it is too
+        # small for the workbook in the embedded Word document.
+        ({"max_embedded_total_bytes": 100_000}, [_EMBEDDED_EXCEL, _EMBEDDED_WORD]),
+    ],
+    ids=["depth", "count", "total-bytes"],
+)
+def test_embedded_object_limits_cover_all_nesting_levels(
+    no_libreoffice, options, expected
+):
+    doc = _convert_embedded_objects_docx(**options)
+
+    assert _embedded_group_names(doc) == expected
+
+
+def test_objects_of_a_nested_document_count_against_the_parent_limit(
+    no_libreoffice,
+):
+    # Move the Word object, which embeds a workbook, before the other objects.
+    with zipfile.ZipFile(EMBEDDED_OBJECTS_DOCX) as archive:
+        document = etree.fromstring(archive.read("word/document.xml"))
+    namespaces = {
+        "w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+        "o": "urn:schemas-microsoft-com:office:office",
+    }
+    word_paragraph, excel_paragraph = (
+        document.xpath(
+            f"//w:p[.//o:OLEObject[@ProgID='{prog_id}']]", namespaces=namespaces
+        )[0]
+        for prog_id in ("Word.Document.12", "Excel.Sheet.12")
+    )
+    excel_paragraph.addprevious(word_paragraph)
+
+    doc = _convert_embedded_objects_docx(
+        _rewrite_docx_parts({"word/document.xml": etree.tostring(document)}),
+        max_embedded_objects=3,
+    )
+
+    # The nested workbook is the second object, so the presentation is the fourth.
+    assert _embedded_group_names(doc) == [
+        _EMBEDDED_WORD,
+        _EMBEDDED_EXCEL,
+        _EMBEDDED_EXCEL,
+    ]
+
+
+def _zip_bomb() -> bytes:
+    out = BytesIO()
+    with zipfile.ZipFile(out, "w", zipfile.ZIP_DEFLATED) as archive:
+        archive.writestr("ppt/presentation.xml", b"\0" * (2 * 1024 * 1024))
+    return out.getvalue()
+
+
+def _linked_excel_rels() -> bytes:
+    with zipfile.ZipFile(EMBEDDED_OBJECTS_DOCX) as archive:
+        rels = etree.fromstring(archive.read("word/_rels/document.xml.rels"))
+    for rel in rels:
+        if rel.get("Target") == "embeddings/Microsoft_Excel_Worksheet.xlsx":
+            rel.set("Target", "file:///C:/Reports/budget.xlsx")
+            rel.set("TargetMode", "External")
+    return etree.tostring(rels)
+
+
+@pytest.mark.parametrize(
+    ("replacements", "options", "expected", "warning"),
+    [
+        (
+            {_EMBEDDED_POWERPOINT_PART: b"not a package"},
+            {},
+            [_EMBEDDED_EXCEL, _EMBEDDED_WORD, _EMBEDDED_EXCEL],
+            "File is not a zip file",
+        ),
+        # The package is refused before the PowerPoint backend opens it.
+        (
+            {_EMBEDDED_POWERPOINT_PART: _zip_bomb()},
+            {"max_total_bytes": 1024 * 1024},
+            [_EMBEDDED_EXCEL, _EMBEDDED_WORD, _EMBEDDED_EXCEL],
+            "exceeding the max_total_bytes limit",
+        ),
+        (
+            {"word/_rels/document.xml.rels": _linked_excel_rels()},
+            {},
+            [_EMBEDDED_POWERPOINT, _EMBEDDED_WORD, _EMBEDDED_EXCEL],
+            "",
+        ),
+    ],
+    ids=["broken-package", "zip-bomb", "linked-object"],
+)
+def test_embedded_object_that_cannot_be_converted_keeps_its_preview(
+    no_libreoffice, caplog, replacements, options, expected, warning
+):
+    with caplog.at_level(logging.WARNING, logger=msword_backend_module.__name__):
+        doc = _convert_embedded_objects_docx(
+            _rewrite_docx_parts(replacements), **options
+        )
+
+    assert _embedded_group_names(doc) == expected
+    assert len(doc.pictures) == 5
+    assert warning in caplog.text
+
+
+def test_embedded_object_without_its_format_extra_keeps_its_preview(
+    no_libreoffice, monkeypatch, caplog
+):
+    monkeypatch.setattr(msexcel_backend_module, "_OPENPYXL_AVAILABLE", False)
+
+    with caplog.at_level(logging.WARNING, logger=msword_backend_module.__name__):
+        doc = _convert_embedded_objects_docx()
+
+    assert _embedded_group_names(doc) == [_EMBEDDED_POWERPOINT, _EMBEDDED_WORD]
+    assert "docling-slim[format-xlsx]" in caplog.text
+
+
+def test_embedded_part_shared_by_two_objects_is_converted_once(no_libreoffice):
+    # A crafted file can point many objects at one large part.
+    with zipfile.ZipFile(EMBEDDED_OBJECTS_DOCX) as archive:
+        document = etree.fromstring(archive.read("word/document.xml"))
+    namespaces = {
+        "w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+        "o": "urn:schemas-microsoft-com:office:office",
+    }
+    paragraph = document.xpath(
+        "//w:p[.//o:OLEObject[@ProgID='Excel.Sheet.12']]", namespaces=namespaces
+    )[0]
+    paragraph.addnext(deepcopy(paragraph))
+
+    doc = _convert_embedded_objects_docx(
+        _rewrite_docx_parts({"word/document.xml": etree.tostring(document)})
+    )
+
+    assert _embedded_group_names(doc) == [
+        _EMBEDDED_EXCEL,
+        _EMBEDDED_POWERPOINT,
+        _EMBEDDED_WORD,
+        _EMBEDDED_EXCEL,
+    ]
+    assert len(doc.pictures) == 6
+
+
+def test_rich_table_cells_of_an_embedded_document_point_to_their_copies(
+    no_libreoffice,
+):
+    rich_cells_docx = Path("./tests/data/docx/sources/docx_rich_cells.docx")
+    doc = _convert_embedded_objects_docx(
+        _rewrite_docx_parts({_EMBEDDED_WORD_PART: rich_cells_docx.read_bytes()})
+    )
+
+    rich_cells = [
+        (table, cell)
+        for table in doc.tables
+        for cell in table.data.table_cells
+        if isinstance(cell, RichTableCell)
+    ]
+    assert rich_cells
+    for table, cell in rich_cells:
+        assert cell.ref.resolve(doc).parent.cref == table.self_ref
+
+
+def test_rich_table_cell_whose_target_is_not_copied_keeps_its_text(backend):
+    embedded = DoclingDocument(name="embedded")
+    table = embedded.add_table(data=TableData(num_rows=1, num_cols=1))
+    target = embedded.add_group(parent=table)
+    embedded.add_text(label=DocItemLabel.TEXT, text="rich", parent=target)
+    table.data.table_cells.append(
+        RichTableCell(
+            text="rich",
+            ref=target.get_ref(),
+            start_row_offset_idx=0,
+            end_row_offset_idx=1,
+            start_col_offset_idx=0,
+            end_col_offset_idx=1,
+        )
+    )
+    # Only items in the body tree are copied.
+    table.children.remove(target.get_ref())
+    doc = DoclingDocument(name="word")
+
+    backend._add_embedded_document(doc, embedded, doc.add_group(name="object"))
+
+    (cell,) = doc.tables[0].data.table_cells
+    assert type(cell) is TableCell
+    assert cell.text == "rich"