From 733360c7b233e9dadb843086c1aba70983155421 Mon Sep 17 00:00:00 2001 From: Alexander Vaagan <2428222+vaaale@users.noreply.github.com> Date: Sat, 26 Apr 2025 16:30:09 +0200 Subject: [PATCH] A new HTML backend that handles styled html (ignors it) as well as images. - Updated unit tests - Added documentation (Example notebook) Note: MyPy fails. Seems to be a known issue with BeautifulSoup: https://github.com/python/typeshed/pull/13604 Signed-off-by: Alexander Vaagan Signed-off-by: vaaale <2428222+vaaale@users.noreply.github.com> --- docling/backend/html_backend.py | 768 +-- docs/assets/docx.png | Bin 0 -> 2131 bytes docs/assets/html.png | Bin 0 -> 2602 bytes docs/assets/pdf.png | Bin 0 -> 3629 bytes docs/examples/backend_html.ipynb | 313 + .../docling_v2/example_01.html.itxt | 19 +- .../docling_v2/example_01.html.json | 76 +- .../groundtruth/docling_v2/example_01.html.md | 4 +- .../docling_v2/example_02.html.itxt | 18 +- .../docling_v2/example_02.html.json | 56 +- .../groundtruth/docling_v2/example_02.html.md | 2 +- .../docling_v2/example_03.html.itxt | 36 +- .../docling_v2/example_03.html.json | 128 +- .../groundtruth/docling_v2/example_03.html.md | 10 +- .../docling_v2/example_04.html.itxt | 2 +- .../docling_v2/example_04.html.json | 11 +- .../docling_v2/example_05.html.itxt | 2 +- .../docling_v2/example_05.html.json | 11 +- .../groundtruth/docling_v2/example_06.html.md | 1 + .../docling_v2/example_07.html.itxt | 44 +- .../docling_v2/example_07.html.json | 130 +- .../groundtruth/docling_v2/example_07.html.md | 10 +- tests/data/groundtruth/docling_v2/mixed.md.md | 2 +- .../docling_v2/mixed_without_h1.md.md | 8 +- .../data/groundtruth/docling_v2/nested.md.md | 63 +- .../powerpoint_with_image.pptx.json | 2 +- .../groundtruth/docling_v2/test-01.xlsx.json | 2 +- .../docling_v2/test_emf_docx.docx.json | 2 +- .../docling_v2/unit_test_01.html.itxt | 13 +- .../docling_v2/unit_test_01.html.json | 86 +- .../docling_v2/unit_test_01.html.md | 12 +- .../docling_v2/wiki_duck.html.itxt | 973 +-- .../docling_v2/wiki_duck.html.json | 5950 +++++++++-------- .../groundtruth/docling_v2/wiki_duck.html.md | 414 +- .../docling_v2/word_sample.docx.json | 2 +- tests/data/html/example_08.html | 21 + tests/data/html/example_09.html | 21 + tests/test_backend_html.py | 4 +- 38 files changed, 4983 insertions(+), 4233 deletions(-) create mode 100644 docs/assets/docx.png create mode 100644 docs/assets/html.png create mode 100644 docs/assets/pdf.png create mode 100644 docs/examples/backend_html.ipynb create mode 100644 tests/data/html/example_08.html create mode 100644 tests/data/html/example_09.html diff --git a/docling/backend/html_backend.py b/docling/backend/html_backend.py index 7c716908..458267e9 100644 --- a/docling/backend/html_backend.py +++ b/docling/backend/html_backend.py @@ -1,22 +1,24 @@ +import base64 import logging -import traceback +import re +from enum import Enum from io import BytesIO from pathlib import Path -from typing import Final, Optional, Union, cast +from typing import Optional, Union -from bs4 import BeautifulSoup, NavigableString, PageElement, Tag -from bs4.element import PreformattedString +import requests +from bs4 import BeautifulSoup, NavigableString, Tag from docling_core.types.doc import ( - DocItem, DocItemLabel, DoclingDocument, DocumentOrigin, - GroupItem, - GroupLabel, + Size, TableCell, TableData, ) -from docling_core.types.doc.document import ContentLayer +from docling_core.types.doc.document import ContentLayer, ImageRef +from PIL import Image, UnidentifiedImageError +from pydantic import AnyUrl, HttpUrl, ValidationError from typing_extensions import override from docling.backend.abstract_backend import DeclarativeDocumentBackend @@ -25,56 +27,38 @@ from docling.datamodel.document import InputDocument _log = logging.getLogger(__name__) -# tags that generate NodeItem elements -TAGS_FOR_NODE_ITEMS: Final = [ - "address", - "details", - "h1", - "h2", - "h3", - "h4", - "h5", - "h6", - "p", - "pre", - "code", - "ul", - "ol", - "li", - "summary", - "table", - "figure", - "img", -] +# Tags that initiate distinct Docling items +_BLOCK_TAGS = {"h1", "h2", "h3", "h4", "h5", "h6", "p", "ul", "ol", "table"} -class HTMLDocumentBackend(DeclarativeDocumentBackend): +class ImageOptions(str, Enum): + """Image options for HTML backend.""" + + NONE = "none" + INLINE = "inline" + REFERENCED = "referenced" + + +class BaseHTMLDocumentBackend(DeclarativeDocumentBackend): @override - def __init__(self, in_doc: "InputDocument", path_or_stream: Union[BytesIO, Path]): + def __init__( + self, + in_doc: InputDocument, + path_or_stream: Union[BytesIO, Path], + image_options: Optional[ImageOptions] = ImageOptions.NONE, + ): super().__init__(in_doc, path_or_stream) + self.image_options = image_options self.soup: Optional[Tag] = None - # HTML file: - self.path_or_stream = path_or_stream - # Initialise the parents for the hierarchy - self.max_levels = 10 - self.level = 0 - self.parents: dict[int, Optional[Union[DocItem, GroupItem]]] = {} - for i in range(self.max_levels): - self.parents[i] = None - try: - if isinstance(self.path_or_stream, BytesIO): - text_stream = self.path_or_stream.getvalue() - self.soup = BeautifulSoup(text_stream, "html.parser") - if isinstance(self.path_or_stream, Path): - with open(self.path_or_stream, "rb") as f: - html_content = f.read() - self.soup = BeautifulSoup(html_content, "html.parser") + raw = ( + path_or_stream.getvalue() + if isinstance(path_or_stream, BytesIO) + else Path(path_or_stream).read_bytes() + ) + self.soup = BeautifulSoup(raw, "html.parser") except Exception as e: - raise RuntimeError( - "Could not initialize HTML backend for file with " - f"hash {self.document_hash}." - ) from e + raise RuntimeError(f"Could not initialize HTML backend: {e}") @override def is_valid(self) -> bool: @@ -89,7 +73,6 @@ class HTMLDocumentBackend(DeclarativeDocumentBackend): def unload(self): if isinstance(self.path_or_stream, BytesIO): self.path_or_stream.close() - self.path_or_stream = None @classmethod @@ -99,490 +82,247 @@ class HTMLDocumentBackend(DeclarativeDocumentBackend): @override def convert(self) -> DoclingDocument: - # access self.path_or_stream to load stuff origin = DocumentOrigin( filename=self.file.name or "file", mimetype="text/html", binary_hash=self.document_hash, ) - doc = DoclingDocument(name=self.file.stem or "file", origin=origin) - _log.debug("Trying to convert HTML...") + _log.debug("Starting HTML conversion...") + if not self.is_valid(): + raise RuntimeError("Invalid HTML document.") + assert self.soup is not None - if self.is_valid(): - assert self.soup is not None - content = self.soup.body or self.soup - # Replace
tags with newline characters - # TODO: remove style to avoid losing text from tags like i, b, span, ... - for br in content("br"): - br.replace_with(NavigableString("\n")) + # Remove all script/style content + for tag in self.soup.find_all(["script", "style"]): + tag.decompose() - headers = content.find(["h1", "h2", "h3", "h4", "h5", "h6"]) - self.content_layer = ( - ContentLayer.BODY if headers is None else ContentLayer.FURNITURE - ) - self.walk(content, doc) - else: - raise RuntimeError( - f"Cannot convert doc with {self.document_hash} because the backend " - "failed to init." - ) + body = self.soup.body or self.soup + # Normalize
tags to newline strings + for br in body.find_all("br"): + br.replace_with(NavigableString("\n")) + + # Decide content layer by presence of headers + headers = body.find(list(_BLOCK_TAGS)) + self.content_layer = ( + ContentLayer.BODY if headers is None else ContentLayer.FURNITURE + ) + + # Walk the body to build the DoclingDocument + self._walk(body, doc, parent=doc.body) return doc - def walk(self, tag: Tag, doc: DoclingDocument) -> None: - # Iterate over elements in the body of the document - text: str = "" - for element in tag.children: - if isinstance(element, Tag): - try: - self.analyze_tag(cast(Tag, element), doc) - except Exception as exc_child: - _log.error( - f"Error processing child from tag {tag.name}:\n{traceback.format_exc()}" - ) - raise exc_child - elif isinstance(element, NavigableString) and not isinstance( - element, PreformattedString - ): - # Floating text outside paragraphs or analyzed tags - text += element - siblings: list[Tag] = [ - item for item in element.next_siblings if isinstance(item, Tag) - ] - if element.next_sibling is None or any( - item.name in TAGS_FOR_NODE_ITEMS for item in siblings - ): - text = text.strip() - if text and tag.name in ["div"]: - doc.add_text( - parent=self.parents[self.level], - label=DocItemLabel.TEXT, - text=text, - content_layer=self.content_layer, - ) - text = "" + def _walk(self, element: Tag, doc: DoclingDocument, parent) -> None: + """ + Recursively walk element.contents, buffering inline text across tags like or , + emitting text nodes only at block boundaries, and extracting images immediately. + """ + buffer: list[str] = [] - return + def flush_buffer(): + if not buffer: + return + text = "".join(buffer).strip() + buffer.clear() + if not text: + return + # Split on newlines for
+ for part in text.split("\n"): + seg = part.strip() + if seg: + doc.add_text(DocItemLabel.TEXT, seg, parent=parent) - def analyze_tag(self, tag: Tag, doc: DoclingDocument) -> None: - if tag.name in ["h1", "h2", "h3", "h4", "h5", "h6"]: - self.handle_header(tag, doc) - elif tag.name in ["p", "address", "summary"]: - self.handle_paragraph(tag, doc) - elif tag.name in ["pre", "code"]: - self.handle_code(tag, doc) - elif tag.name in ["ul", "ol"]: - self.handle_list(tag, doc) - elif tag.name in ["li"]: - self.handle_list_item(tag, doc) - elif tag.name == "table": - self.handle_table(tag, doc) - elif tag.name == "figure": - self.handle_figure(tag, doc) - elif tag.name == "img": - self.handle_image(tag, doc) - elif tag.name == "details": - self.handle_details(tag, doc) - else: - self.walk(tag, doc) - - def get_text(self, item: PageElement) -> str: - """Get the text content of a tag.""" - parts: list[str] = self.extract_text_recursively(item) - - return "".join(parts) + " " - - # Function to recursively extract text from all child nodes - def extract_text_recursively(self, item: PageElement) -> list[str]: - result: list[str] = [] - - if isinstance(item, NavigableString): - return [item] - - tag = cast(Tag, item) - if tag.name not in ["ul", "ol"]: - for child in tag: - # Recursively get the child's text content - result.extend(self.extract_text_recursively(child)) - - return ["".join(result) + " "] - - def handle_details(self, element: Tag, doc: DoclingDocument) -> None: - """Handle details tag (details) and its content.""" - - self.parents[self.level + 1] = doc.add_group( - name="details", - label=GroupLabel.SECTION, - parent=self.parents[self.level], - content_layer=self.content_layer, - ) - - self.level += 1 - self.walk(element, doc) - self.parents[self.level + 1] = None - self.level -= 1 - - def handle_header(self, element: Tag, doc: DoclingDocument) -> None: - """Handles header tags (h1, h2, etc.).""" - hlevel = int(element.name.replace("h", "")) - text = element.text.strip() - - self.content_layer = ContentLayer.BODY - - if hlevel == 1: - for key in self.parents.keys(): - self.parents[key] = None - - self.level = 1 - self.parents[self.level] = doc.add_text( - parent=self.parents[0], - label=DocItemLabel.TITLE, - text=text, - content_layer=self.content_layer, - ) - else: - if hlevel > self.level: - # add invisible group - for i in range(self.level + 1, hlevel): - self.parents[i] = doc.add_group( - name=f"header-{i}", - label=GroupLabel.SECTION, - parent=self.parents[i - 1], - content_layer=self.content_layer, - ) - self.level = hlevel - - elif hlevel < self.level: - # remove the tail - for key in self.parents.keys(): - if key > hlevel: - self.parents[key] = None - self.level = hlevel - - self.parents[hlevel] = doc.add_heading( - parent=self.parents[hlevel - 1], - text=text, - level=hlevel - 1, - content_layer=self.content_layer, - ) - - def handle_code(self, element: Tag, doc: DoclingDocument) -> None: - """Handles monospace code snippets (pre).""" - if element.text is None: - return - text = element.text.strip() - if text: - doc.add_code( - parent=self.parents[self.level], - text=text, - content_layer=self.content_layer, - ) - - def handle_paragraph(self, element: Tag, doc: DoclingDocument) -> None: - """Handles paragraph tags (p) or equivalent ones.""" - if element.text is None: - return - text = element.text.strip() - if text: - doc.add_text( - parent=self.parents[self.level], - label=DocItemLabel.TEXT, - text=text, - content_layer=self.content_layer, - ) - - def handle_list(self, element: Tag, doc: DoclingDocument) -> None: - """Handles list tags (ul, ol) and their list items.""" - - if element.name == "ul": - # create a list group - self.parents[self.level + 1] = doc.add_group( - parent=self.parents[self.level], - name="list", - label=GroupLabel.LIST, - content_layer=self.content_layer, - ) - elif element.name == "ol": - start_attr = element.get("start") - start: int = ( - int(start_attr) - if isinstance(start_attr, str) and start_attr.isnumeric() - else 1 - ) - # create a list group - self.parents[self.level + 1] = doc.add_group( - parent=self.parents[self.level], - name="ordered list" + (f" start {start}" if start != 1 else ""), - label=GroupLabel.ORDERED_LIST, - content_layer=self.content_layer, - ) - self.level += 1 - - self.walk(element, doc) - - self.parents[self.level + 1] = None - self.level -= 1 - - def handle_list_item(self, element: Tag, doc: DoclingDocument) -> None: - """Handles list item tags (li).""" - nested_list = element.find(["ul", "ol"]) - - parent = self.parents[self.level] - if parent is None: - _log.debug(f"list-item has no parent in DoclingDocument: {element}") - return - parent_label: str = parent.label - index_in_list = len(parent.children) + 1 - if ( - parent_label == GroupLabel.ORDERED_LIST - and isinstance(parent, GroupItem) - and parent.name - ): - start_in_list: str = parent.name.split(" ")[-1] - start: int = int(start_in_list) if start_in_list.isnumeric() else 1 - index_in_list += start - 1 - - if nested_list: - # Text in list item can be hidden within hierarchy, hence - # we need to extract it recursively - text: str = self.get_text(element) - # Flatten text, remove break lines: - text = text.replace("\n", "").replace("\r", "") - text = " ".join(text.split()).strip() - - marker = "" - enumerated = False - if parent_label == GroupLabel.ORDERED_LIST: - marker = str(index_in_list) - enumerated = True - - if len(text) > 0: - # create a list-item - self.parents[self.level + 1] = doc.add_list_item( - text=text, - enumerated=enumerated, - marker=marker, - parent=parent, - content_layer=self.content_layer, - ) - self.level += 1 - self.walk(element, doc) - self.parents[self.level + 1] = None - self.level -= 1 - else: - self.walk(element, doc) - - elif element.text.strip(): - text = element.text.strip() - - marker = "" - enumerated = False - if parent_label == GroupLabel.ORDERED_LIST: - marker = f"{index_in_list!s}." - enumerated = True - doc.add_list_item( - text=text, - enumerated=enumerated, - marker=marker, - parent=parent, - content_layer=self.content_layer, - ) - else: - _log.debug(f"list-item has no text: {element}") - - @staticmethod - def parse_table_data(element: Tag) -> Optional[TableData]: # noqa: C901 - nested_tables = element.find("table") - if nested_tables is not None: - _log.debug("Skipping nested table.") - return None - - # Find the number of rows and columns (taking into account spans) - num_rows = 0 - num_cols = 0 - for row in element("tr"): - col_count = 0 - is_row_header = True - if not isinstance(row, Tag): + for node in element.contents: + # Skip scripts/styles + if isinstance(node, Tag) and node.name.lower() in ("script", "style"): continue - for cell in row(["td", "th"]): - if not isinstance(row, Tag): - continue - cell_tag = cast(Tag, cell) - val = cell_tag.get("colspan", "1") - colspan = int(val) if (isinstance(val, str) and val.isnumeric()) else 1 - col_count += colspan - if cell_tag.name == "td" or cell_tag.get("rowspan") is None: - is_row_header = False - num_cols = max(num_cols, col_count) - if not is_row_header: - num_rows += 1 - - _log.debug(f"The table has {num_rows} rows and {num_cols} cols.") - - grid: list = [[None for _ in range(num_cols)] for _ in range(num_rows)] - - data = TableData(num_rows=num_rows, num_cols=num_cols, table_cells=[]) - - # Iterate over the rows in the table - start_row_span = 0 - row_idx = -1 - for row in element("tr"): - if not isinstance(row, Tag): + # Immediate image extraction + if isinstance(node, Tag) and node.name.lower() == "img": + flush_buffer() + self._emit_image(node, doc, parent) continue + # Block-level element triggers flush + handle + if isinstance(node, Tag) and node.name.lower() in _BLOCK_TAGS: + flush_buffer() + self._handle_block(node, doc, parent) + # Inline tag with nested blocks: recurse + elif isinstance(node, Tag) and node.find(list(_BLOCK_TAGS)): + flush_buffer() + self._walk(node, doc, parent) + # Inline text + elif isinstance(node, Tag): + buffer.append(node.get_text()) + elif isinstance(node, NavigableString): + buffer.append(str(node)) - # For each row, find all the column cells (both and ) - cells = row(["td", "th"]) + # Flush any remaining text + flush_buffer() - # Check if cell is in a column header or row header - col_header = True - row_header = True - for html_cell in cells: - if isinstance(html_cell, Tag): - if html_cell.name == "td": - col_header = False - row_header = False - elif html_cell.get("rowspan") is None: - row_header = False - if not row_header: - row_idx += 1 - start_row_span = 0 - else: - start_row_span += 1 - - # Extract the text content of each cell - col_idx = 0 - for html_cell in cells: - if not isinstance(html_cell, Tag): - continue - - # extract inline formulas - for formula in html_cell("inline-formula"): - math_parts = formula.text.split("$$") - if len(math_parts) == 3: - math_formula = f"$${math_parts[1]}$$" - formula.replace_with(NavigableString(math_formula)) - - # TODO: extract content correctly from table-cells with lists - text = html_cell.text - - # label = html_cell.name - col_val = html_cell.get("colspan", "1") - col_span = ( - int(col_val) - if isinstance(col_val, str) and col_val.isnumeric() - else 1 - ) - row_val = html_cell.get("rowspan", "1") - row_span = ( - int(row_val) - if isinstance(row_val, str) and row_val.isnumeric() - else 1 - ) - if row_header: - row_span -= 1 - while ( - col_idx < num_cols - and grid[row_idx + start_row_span][col_idx] is not None - ): - col_idx += 1 - for r in range(start_row_span, start_row_span + row_span): - for c in range(col_span): - if row_idx + r < num_rows and col_idx + c < num_cols: - grid[row_idx + r][col_idx + c] = text - - table_cell = TableCell( - text=text, - row_span=row_span, - col_span=col_span, - start_row_offset_idx=start_row_span + row_idx, - end_row_offset_idx=start_row_span + row_idx + row_span, - start_col_offset_idx=col_idx, - end_col_offset_idx=col_idx + col_span, - column_header=col_header, - row_header=((not col_header) and html_cell.name == "th"), - ) - data.table_cells.append(table_cell) - - return data - - def handle_table(self, element: Tag, doc: DoclingDocument) -> None: - """Handles table tags.""" - - table_data = HTMLDocumentBackend.parse_table_data(element) - - if table_data is not None: - doc.add_table( - data=table_data, - parent=self.parents[self.level], - content_layer=self.content_layer, + def _handle_block(self, tag: Tag, doc: DoclingDocument, parent) -> None: + tag_name = tag.name.lower() + if tag_name == "h1": + text = tag.get_text(strip=True) + if text: + doc.add_title(text, parent=parent) + for img_tag in tag.find_all("img", recursive=True): + self._emit_image(img_tag, doc, parent) + elif tag_name in {"h2", "h3", "h4", "h5", "h6"}: + level = int(tag_name[1]) + text = tag.get_text(strip=True) + if text: + doc.add_heading(text, level=level, parent=parent) + for img_tag in tag.find_all("img", recursive=True): + self._emit_image(img_tag, doc, parent) + elif tag_name == "p": + for part in tag.get_text().split("\n"): + seg = part.strip() + if seg: + doc.add_text(DocItemLabel.TEXT, seg, parent=parent) + for img_tag in tag.find_all("img", recursive=True): + self._emit_image(img_tag, doc, parent) + elif tag_name in {"ul", "ol"}: + is_ordered = tag_name == "ol" + group = ( + doc.add_ordered_list(parent=parent) + if is_ordered + else doc.add_unordered_list(parent=parent) ) - - def get_list_text(self, list_element: Tag, level: int = 0) -> list[str]: - """Recursively extract text from
    or
      with proper indentation.""" - result = [] - bullet_char = "*" # Default bullet character for unordered lists - - if list_element.name == "ol": # For ordered lists, use numbers - for i, li in enumerate(list_element("li", recursive=False), 1): - if not isinstance(li, Tag): - continue - # Add numbering for ordered lists - result.append(f"{' ' * level}{i}. {li.get_text(strip=True)}") - # Handle nested lists - nested_list = li.find(["ul", "ol"]) - if isinstance(nested_list, Tag): - result.extend(self.get_list_text(nested_list, level + 1)) - elif list_element.name == "ul": # For unordered lists, use bullet points - for li in list_element("li", recursive=False): - if not isinstance(li, Tag): - continue - # Add bullet points for unordered lists - result.append( - f"{' ' * level}{bullet_char} {li.get_text(strip=True)}" + for li in tag.find_all("li", recursive=False): + li_text = li.get_text(separator=" ", strip=True) + li_item = doc.add_list_item( + text=li_text, enumerated=is_ordered, parent=group ) - # Handle nested lists - nested_list = li.find(["ul", "ol"]) - if isinstance(nested_list, Tag): - result.extend(self.get_list_text(nested_list, level + 1)) + # Nested lists inside
    1. + for sub in li.find_all(["ul", "ol"], recursive=False): + self._handle_block(sub, doc, parent=group) + for img_tag in li.find_all("img", recursive=True): + self._emit_image(img_tag, doc, li_item) + elif tag_name == "table": + # Add table item and extract nested images + data = self._parse_table(tag, doc, parent) + doc.add_table(data=data, parent=parent) - return result + def _emit_image(self, img_tag: Tag, doc: DoclingDocument, parent) -> None: + """ + Helper to create a PictureItem (with optional CAPTION) for an tag. + """ - def handle_figure(self, element: Tag, doc: DoclingDocument) -> None: - """Handles image tags (img).""" + if ImageOptions.NONE == self.image_options: + return - # Extract the image URI from the tag - # image_uri = root.xpath('//figure//img/@src')[0] + alt = (img_tag.get("alt") or "").strip() + caption_item = None + if alt: + caption_item = doc.add_text(DocItemLabel.CAPTION, alt, parent=parent) - contains_captions = element.find(["figcaption"]) - if not isinstance(contains_captions, Tag): - doc.add_picture( - parent=self.parents[self.level], - caption=None, - content_layer=self.content_layer, - ) - else: - texts = [] - for item in contains_captions: - texts.append(item.text) + src_url = img_tag.get("src") + width = img_tag.get("width", "128") + height = img_tag.get("height", "128") + img_ref = None + if ImageOptions.INLINE == self.image_options: + try: + if src_url.startswith("http"): + img = Image.open(requests.get(src_url, stream=True).raw) + elif src_url.startswith("file:"): + img = Image.open(src_url) + elif src_url.startswith("data:"): + image_data = re.sub("^data:image/.+;base64,", "", src_url) + img = Image.open(BytesIO(base64.b64decode(image_data))) + else: + return + img_ref = ImageRef.from_pil(img, dpi=int(img.info.get("dpi")[0])) + except (FileNotFoundError, UnidentifiedImageError) as ve: + _log.warning(f"Could not load image (src={src_url}): {ve}") + return + elif ImageOptions.REFERENCED == self.image_options: + try: + img_url = AnyUrl(src_url) + img_ref = ImageRef( + uri=img_url, + dpi=72, + mimetype="image/png", + size=Size(width=float(width), height=float(height)), + ) + except ValidationError as ve: + _log.warning(f"Could not load image (src={src_url}): {ve}") + return - fig_caption = doc.add_text( - label=DocItemLabel.CAPTION, - text=("".join(texts)).strip(), - content_layer=self.content_layer, - ) - doc.add_picture( - parent=self.parents[self.level], - caption=fig_caption, - content_layer=self.content_layer, - ) + doc.add_picture(image=img_ref, caption=caption_item, parent=parent) - def handle_image(self, element: Tag, doc: DoclingDocument) -> None: - """Handles image tags (img).""" - _log.debug(f"ignoring tags at the moment: {element}") + def _parse_table(self, table_tag: Tag, doc: DoclingDocument, parent) -> TableData: + """ + Convert an HTML table into TableData, capturing cell spans and text, + and emitting any nested images as PictureItems. + """ + # Build TableData + rows = [] + for sec in ("thead", "tbody", "tfoot"): + section = table_tag.find(sec) + if section: + rows.extend(section.find_all("tr", recursive=False)) + if not rows: + rows = table_tag.find_all("tr", recursive=False) + occupied: dict[tuple[int, int], bool] = {} + cells: list[TableCell] = [] + max_cols = 0 + for r, tr in enumerate(rows): + c = 0 + for cell_tag in tr.find_all(("td", "th"), recursive=False): + while occupied.get((r, c)): + c += 1 + rs = int(cell_tag.get("rowspan", 1) or 1) + cs = int(cell_tag.get("colspan", 1) or 1) + txt = cell_tag.get_text(strip=True) + cell = TableCell( + bbox=None, + row_span=rs, + col_span=cs, + start_row_offset_idx=r, + end_row_offset_idx=r + rs, + start_col_offset_idx=c, + end_col_offset_idx=c + cs, + text=txt, + column_header=(cell_tag.name == "th"), + row_header=False, + row_section=False, + ) + cells.append(cell) + for dr in range(rs): + for dc in range(cs): + occupied[(r + dr, c + dc)] = True + c += cs + max_cols = max(max_cols, c) + # Emit images inside this table + for img_tag in table_tag.find_all("img", recursive=True): + self._emit_image(img_tag, doc, parent) + return TableData(table_cells=cells, num_rows=len(rows), num_cols=max_cols) - doc.add_picture( - parent=self.parents[self.level], - caption=None, - content_layer=self.content_layer, - ) + +class HTMLDocumentBackend(BaseHTMLDocumentBackend): + @override + def __init__( + self, + in_doc: InputDocument, + path_or_stream: Union[BytesIO, Path], + ): + super().__init__(in_doc, path_or_stream, image_options=ImageOptions.NONE) + + +class HTMLDocumentBackendImagesInline(BaseHTMLDocumentBackend): + @override + def __init__( + self, + in_doc: InputDocument, + path_or_stream: Union[BytesIO, Path], + ): + super().__init__(in_doc, path_or_stream, image_options=ImageOptions.INLINE) + + +class HTMLDocumentBackendImagesReferenced(BaseHTMLDocumentBackend): + @override + def __init__( + self, + in_doc: InputDocument, + path_or_stream: Union[BytesIO, Path], + ): + super().__init__(in_doc, path_or_stream, image_options=ImageOptions.REFERENCED) diff --git a/docs/assets/docx.png b/docs/assets/docx.png new file mode 100644 index 0000000000000000000000000000000000000000..2e40201fe69f395d858b991332619c50231a4d4b GIT binary patch literal 2131 zcmbW3c|6mPAIFy?TeVsvm2>9k>x)MDx_!&X9GfFY)UX`st2q;;WGLIu`~C6z{r!79Uhn7gkN2PNKi;n-Cr2CT9=Sar5D1E~ zMZ4^H@?QfM-ytLfX}hDxPWET5wzs#BcyMyEs2y#upFL%yr=@gtwDr8{nxFsN-`6X6 zI|y=U068^|Osvq@Vtccq)$KXr_By|@SFks$lYs5`Oq+uEA_ z_4Ypq+@{XitM~aq#Ik#Nwf>23K>BqcGgjKe4v^(@Vj5F?VxtxWlDddNTb#Y|;7ehU z=ZX>RAC>$e%Vly^=HEq29e00QY-BHPZ(kafJwYv%to)>Vqk9#SXCMka(P^I{a7=9V zt2wVNo4g~l`O>JmfOCfBQc6EQP4iE9({#<&Y%VK@bq=pe4o9Gc(B((L#gh)bMQud~ z*^)H8vN3oQnVqW7{JHnoM{~2v#*-*Ymb}L%`R-CwyL|CUAdIpICaRdIiAcf>{()jw z07VIf5D_LCqIh9G-@G^in58U2@T$>>$P{4$U#IvmP)>;jlX zc$H|iNRp7shZdg$j!|MEcto^DWW2C||7UR&Fi+Wngs8$1%oN+({NqRn@R*_x4ne|I zm=s$wUkP~>2%gFc$@mZQM`m4is$&fFa8gox#C5A*;40B zE7~;T#&=B;$n|AiJUuqKbJt|k+F}oXCiJWn$<2GU4q_@b9U?zho42Us`?5Z+u`JpY zThED2JXN?vfsEdT6edGFlmCbF$6$_$1)?EkvVjuqb3gn@h0dfSzrwqkfH>j zWURtLgu=TOuFH=@ySThTr0;eVNjSOzD))UA!c1 z0cdIt9W$JX*|b0TNnDo$uYLulUgZ=m3W{VTH0`&mTz5-As5ZK9260p9Jh?&eMP09t zuOW4be+BH+N7;N*l_$9$Oz~+vbub}3AC za9Mfl?HPQ?h+0IljK_oix0FD*`_WUk68f38@&1a~ZfB3a_+=lBl<)z~pAsfkr!uu> zpalwOv1;!3caH`=n!;g^`~X7=+^;ZRrybR@$1&$LjwKmUOmdNJ zYV-%YCohXLEa-A9Qi3imv-fE}-dm(@wJ)6mp6;?c*w7qC{v4x8-}87};*M;q$$1mM zW|+6|q$zs3|8x@fs^m>Mo?xyPTF&nqv_s~3cBEcCgt4q+G@en|%65~jl=_NR#Nw`8 z>zg3Bm9#Rv-2BsGZ{k1vX?=YYRyPso2-R@TQ9NMeN6tK*zUm%fSw*aTAbHMt&%PDA z_5@sB70&O7Co1u{N>5={QO;Op;?$+tm9bod;B-|x3T}y6K}T<}x(jht8*xKLx~|HSm-1KM`>FN&DwP(a>pQ!m7|I#pWg%Ue?;~&M>Y8dNZai0z}La9i;_f?~zQ<$(3}UU-{P`$VFzqJnE- zIqdMjX*BNvq?MraVbYqEn28#gi(x+w3>dZX1X0r0DEe9INN7ZNPAoj@o z`AS&-qFr7({#yPudurnvix@WbQ7vs{YqvU%<{(wkRr0-c zoIQdiPLAcgYV}Fj`c=oLi|a!foVH-~*f>Iv9xX!8_x~YIMgM2-$cx9s0n%7)i)(^p ztm~@z!1E1+wq4Vlv-3^kTjo@folU8FNh&ivtSFyLtcx%FVI=BS)7p0cDlTg>H}?IL mSSow97nS?p&)8hGy-PBDW|O_&CS<22fG}2$=%;|soqq!M+yprQ literal 0 HcmV?d00001 diff --git a/docs/assets/html.png b/docs/assets/html.png new file mode 100644 index 0000000000000000000000000000000000000000..3adf3ada7d041f3847d9e388c285a558cccb3184 GIT binary patch literal 2602 zcmV+_3f1+AP)=X40DL(Bb}lrHR{*e0 zu++q~!OFtT)O*I8bH$ae)WcuDgqF>(8HGhVxNY(D^~llK$llR%s)hh_BTl?{+34R) zmuTzr?yAbQV4`^_gi9-tQz@TU7?evMs#l)bvxm~6w&TXz^W~e^u)O8V%g%XC000RY zNklZDZ3m5XWN&sS#0K(mdlXDL9a{p)l618v_Q6@Bf|VSd#5nk{v%uil_g( z#>UpqcPHuWlj!xVtgNi8tgNi8tgNi8tgM8(djGtAU0!L!d+rR|m-DjUztjU5@;NFr zeADkg*8-@9j}X4m;Hb&~Bf|b$<$&*%0TRN#qnhwi86YK89g0`#OvnfohvIW}fQ(Ra zC@OT)m{4sfUaI#}#i6LhhDt+G524CX)I_K-6m=1*3q@^&eN~~Tk5E-8>LXMYiW&(O zg`!Tve)kELgrZhLC84O7P(>(eCR8vg>LzSI6m=7}ABx%uTMtG3gl*@F`U%?(MFR+1 z4n-3P+YLn{2wM$BBM4g!MKcK73`Ii-TMR{02-^!qrG#?8e*Z%k2%Q`owik*j2`}H~ z5w;bIN^STum$0Q!R7#ldrY((%jS}Lb6Y`DNPAE1=hz6TM5o3NNwi1fX5#lv~@V@AS zYXPFkgy3*kugBupnn8xWEJcf}pJCSmwU04Fet$qI;?3Gp2uzPQgC5sye1PNM^u2IXQ^ z8c{DHvEYGlo+b1>a$ti~ye@bsji{9{24o?ro=^Uql0Pdrs!l?57X!|+CPY)> zmLqz=Ux12;8VPY?!5PjEh9YQ7E zi&xbgRTm+?%d?<^b|ehb@mbM|nh5hLJW`Q74|V!Q-h;B}dglSO|z{ z=Jb&Hy$YfZ!rWnk5YkE7mYd6!cT^38MKS2a<2%coY9Xp8EOgNjV@$^iF5{@+sLBaX z0Ce!2PT52RWv!^15ao}96oO_>bKx0Bh~^QFPXKg$dP+9oV2FvMJ`}%*Q%r~+3tjXu z-=SeBYkqmY zazvk;6AYwR*-|%7Wml#UI(Qd1PKGGRoTPv^#lwaA@o-&)h-M@Vcd{pt0xa}V9djBS zBT5{V#;VLds2re{dFd`6QJgtd1=NyTB#40k5$#Flv}^`YPkxB=Vo{noMgOuipr#xj z=Qt|MoJ3Q$@)p$ho<=%ou*}I5gkcpxZSUHov54hUw$wm#I-tJyrLtI*XHFGjP%EJ< z7JWKaaA8=h@Vmx1|YF!g-lfMb#zT+#d1OB=kLb=2TTR2{*5vJ!_C~ zMZ%Dl2{og7gil$%nuNpXU2yIT@zSbC`0=(`LNp1-1aQJ@-V&-s_{8~WO+p84MvK|F zNfXv1{F66fO~S*_(I{U{!oQj)Y+khpU-N(+BmC5P!tUGf@6Ho`?mVH_eZnuDCv@L+ zoe+HOJfZtFYsJnHy6%@OVT0Lg6RJ<>e*OIAU8vVYpT+~TbV2k~gD@*#rrhN}g2%2Cy21CZ6M{w83EkjF*9l=6H$6*2@U8QN zFD#)YG+mbPe@_@CVv;MTjud2a$$7a=&0bLjAzV(Uk5G7BcRioQwP~}tT+?NIn)i^? z?4x_Z`}y`nkE%ro)`!o3Qvo7)@DWBES}n6dST4jWW#Pne{F(519gc1fRVq_j3^obx z>pz}^Sci}oHXR*VmM3J3fJuFZ_se?hwLw{KG>Acmv_JRzl!q^;m-tfXx1_XaZfJlhE;3 zyqxNUF7S?aW=Dr*Cwd9xszw<0FsYqt@W9hYSd_dw1MYq&5vE58x|&@NVa|p!R4cC< zp$n2dmuTwIF&l>G(XDpaQcGQNSX2&GF%F{>qsN!5tJT`m41Hd;30=5d`Gfe)n^r=+ z_ZC@=YK({RFThJ)5Njn2@5;TXuQR6+w^K7AcU4Ph2`!-|w1k$>7(#v^7JRolXTtez zoz*>83vkYahiw-)4HlUzpEaRKta!j+LUHeLG9gQun;|4wDwco8=bKA+xJ36HA^lH+ zWHy|pY6fz5nZQjFE=g+z1p|Q8V(fYAl9~!X8!ax~!G-QA%wKRx2+7xsoL68t>o>LP zY2XxLByiHmO~a@k3z{00!thQSxoLPH8%4?C`Qcu3axbt!k`f)n)pFFViF({$kHj@m z-h97?qUOTc{#sCOad?L~-|xge8vVP`ejncp?)EoA&G|BinsseZNI?!sj)Vs!o+$k% z{Jp|IgyJu4YZEP@`LcwT(0r95C$pi*mQPAkeaOz@u)g#XHC9OkOj+O>6QwPZ#E^`5lw3tgNi8tgNi8tgNi8tjgopv2k`Llnwpv-A|ekD5Bi#y_UP#Ql8^V))BA*g z_sz`wac%xVI{r8?`kifX1Y3j!^ zW{@z$fc4%i3}ucCvq>a{1!ZCZiBWLFBoYAkWdZIFX%yTpyY*?o$7G1f!UEj7_y<%g zKX#=BACjPq`WaASbkj%}%R*uKFi{2*@oC&M%2Oik#R6m=iTdVQg|RfUvw&OC!Ki^o zVItXCKqCsp)T~IHD8(}UC(5gI6%+dx7YQ=5fU2pXI965`AU{(v76p*H!m@jg%m$Q< zELNZZ@}jWJtwsUl_G1=HPyksfEETI!(kwNrQ2^Eg2{*GtDSu`hXE$*MJ@vg#|D4 zqQGeT4@GpUXA)Oo;ayB03ZGQu+e;`vxo#Hvsu2aU%b;LJ`fGMMG|<$?;+&tEMH>oP z&~Tj=628HK=6iDGDsoL_q0uVLD1P{p&&@K{6vzD7ES@eD*hg~7hOC*pR5dN%ke*x> zo@zsxB6&)}*Pykn4@$G(t~QiYBwG*p7pJX<5wSo-18pc{BwPi+6+^*+t{xUdJ&dlk zp>&bloe`qYp)QoAaF(hzlxKuf7eks*U_7*F>|l5n{TRBvgEaXHl(R|ttWt}8g$lqp zD_+^__B%I^puFHP3k$DAN4oYi z7J&l4BUFPhnyS(kzzRWO&O#rEbQNv;84E#SUV>)im1_0+Vo+d(g<~-xqRs1zLE+&z zh*k~hLfbCpVo>-L>mur3x~7hbLSZq?iT0Lj-0)uv3IOtf5?!<3pfHqpx=rJT|AJ7& z_^5T4e90XU0U-RzT3_OZYb5ddWehPRJ>uYm4vg z6_4B^P4y!5 zqs-(5MEl{0qM8mC?I=(@|AV{Yw2);nTHHlDirhpa*Y3lIHMF>kZWKAvt2gy*$iy1* zO5G@8B_f?i!dHs&FMy#NMW*+uJ7MT!4LP!A6e0>!u)Rv9XER2P&9{~WrKb?xa*659Y>c8k7zd7UBi8Q6dapL^Pk`{0*<{)qiDxVJsOYB? zMdrlHoFpW0QmMa&-#dqJaLoszAf(zVNCuD5g0hqO23jYI+>R}ro@0y~9Ds6+QN1#` zWqoYNV<1q}2cS;YO??_ss5q83TN>=m~m6^5&-DI-wq>YH*h_pzi32h zOQTE)@hc6{r$+VpgxN=2gAbJyjkiZCk@Rd1uf?Otq6_qKR(p)hL4(TXa6$Ua9nf&F z4TjLY8l(>e${LoUTaA{3ZO`CA&_FCwt*7sgiCZ1K%+|xSp}^#+Yc@a(yOW)xH|u1W zeP&eKByGp@XW6c(3x&i*EYa)pzlUu&3)m>afN%Ti=SWw?@{9$`G@-!wF|sPN$A>2* zgEb!#F&d7284}`$>ayP1XhDH+UX|_WXX+i0Oou2+Rvw@GJR$I9IiSoN$TXlZkdZ9i zi!!<_hZ!`Gph2TyRo0lMnQzf@M+q$=gV$cmDUkT%wRm4bd;&BqD{+Ca!a$OzVE3Hw zVlT6_yFi2J`3Ma=EGu+WXwF zb0-RKjyIF#4F8oEN?3E8xonr^?5|tqzVs_E6#lSt1QI7-MHhI^2L-n4h^1LQK%(jG z=tPq_ z8Jw)JT#76AT}_7!kvWE^ZjwmMTh+?9SC?@KNVxo>HChCY{qK+sg z>WE^Z@<;Jp*YmvXhdg)3kvxBK7p;`t9;AX|i|Oj1T?1e!IBapz$s`C+~Fi zwm)({DDL@xN;}T}Yu=w+%C;yd;i1;kWm|2hchP)DQYy;XW@9?P+gngVHLot*4^aLy z3FYMKr?&&;CiIr8Z`)A3 zn^tI*C)WxT5XIxSZ79Hf3kTHuFe(_2;yuNq!+R9(?*1hCxYa1)=*dsl29$O){@%Bs zh#uByTY%#I4c)$ZvBN4+0?>(uP_t1)B6EKSwxbBrKPn2p%aJk$#dF0i$dj75s3>=d z(Im>#w?r48V#z-T^V)w!4%WHYfdX#slR;9ZlUK1izdn`3 zqkL0Q5}lowk8*Ox6t}2#w;QGP-YSNnsO^d3(?6}E`pQW&mI)m!;kasD-^e6>x7(`` z?CCPrw?C!3J+lPY{eAQL+g*}9?hMB1amA=$eD-$7b<<{HOlkM-A@T+QV~5CXlX=?` z7hyyzaxg{PtfB@gt5HOf9|bVGQAA?gx`~e4j1moyXTL1DAx`vun&LWi`qp1NrYRI{ zqR2_I-*Ps|QWVc^r=~7}ohWR~Y5)D&jFvC%FE=Mztw9NO)#`{PrOsQD*jR}Y>t0!N zuo~s6bEyvfwxXO}bvkc1>gP;D`4z73>_AagfKGmY{nK{09e*+e1+;Itwy*C*$D-rg zR=dUV{V%$q;}!%Hbwn{yM-&rvL@`lE6ceSO$TueFdpV_E!DmqvaRi3Z51%Q3XM~8T z;71=pAfD3J`5G~ul9k4B9rR>*eoH$TkX4Gh;CrcMehwB)YP!ayx^YR>aSjxzCog?) zt1=vyQAg@v$rlOHkqcb$(!I=OosE(#n(p8gLy3!c=Kekr{ens3eTL$SXy(wNeJHQ8 z?F*Nq{D{d)tu6Bj$rmNCrvC_0VzW5Nt|4C*k7Ay(a3hqs!#QfPKhqV~r;puSpt!yG zZ)yofvqc6Y9FufiiQ=x~zfu%rsHI-EAejVleQpP@-2`QZSZlbu}Bl`G1 zO%r" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.display import Latex, Markdown, display\n", + "\n", + "html_file = \"../../tests/data/html/example_08.html\"\n", + "result = doc_converter.convert(html_file)\n", + "document = result.document\n", + "markdown = document.export_to_markdown()\n", + "display(Markdown(markdown))" + ] + }, + { + "cell_type": "markdown", + "id": "9aa94a8da08cbbf1", + "metadata": {}, + "source": "## HTML with images as references" + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e6c4ea8cf2cdf8c1", + "metadata": { + "ExecuteTime": { + "end_time": "2025-04-17T11:35:09.595771Z", + "start_time": "2025-04-17T11:35:09.592457Z" + } + }, + "outputs": [], + "source": [ + "# Using the HTMLDocumentBackend to convert HTML files. Images will be extracted as references\n", + "doc_converter = (\n", + " DocumentConverter( # all of the below is optional, has internal defaults.\n", + " allowed_formats=[\n", + " InputFormat.HTML,\n", + " ], # whitelist formats, non-matching files are ignored.\n", + " format_options={\n", + " InputFormat.HTML: HTMLFormatOption(\n", + " pipeline_cls=SimplePipeline, backend=HTMLDocumentBackendImagesReferenced\n", + " ),\n", + " InputFormat.PDF: PdfFormatOption(pipeline_options=pdf_pipeline()),\n", + " },\n", + " )\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "4f088a6b02ea54bd", + "metadata": { + "ExecuteTime": { + "end_time": "2025-04-17T11:35:09.650443Z", + "start_time": "2025-04-17T11:35:09.639985Z" + } + }, + "outputs": [ + { + "data": { + "text/markdown": "# Introduction to parsing HTML files withDocling\n\nDocling\n\n![Image](https://docling-project.github.io/docling/assets/logo.png)\n\nDocling simplifies document processing, parsing diverse formats — including HTML — and providing seamless integrations with the gen AI ecosystem.\n\n### Supported file formats\n\nDocling supports multiple file formats..\n\n- Advanced PDF understanding\n- PDF\n\n![Image](../assets/pdf.png)\n- Microsoft Office DOCX\n- DOCX\n\n![Image](../assets/docx.png)\n- HTML files (with optional support for images)\n- HTML\n\n![Image](../assets/html.png)\n\n#### Three backends for handling HTML files\n\nDocling has three backends for parsing HTML files:\n\n1. HTMLDocumentBackend Ignores images\n2. HTMLDocumentBackendImagesInline Extracts images inline\n3. HTMLDocumentBackendImagesReferenced Extracts images as references", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.display import Latex, Markdown, display\n", + "\n", + "html_file = \"../../tests/data/html/example_08.html\"\n", + "result = doc_converter.convert(html_file)\n", + "document = result.document\n", + "markdown = document.export_to_markdown(image_mode=ImageRefMode.REFERENCED)\n", + "# Does not show otherwise. Not sure why\n", + "markdown = markdown.replace(\"file://\", \"\")\n", + "display(Markdown(markdown))" + ] + }, + { + "cell_type": "markdown", + "id": "a6017dc49bf33601", + "metadata": {}, + "source": "## HTML with images inline" + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b1112e9c386805b2", + "metadata": { + "ExecuteTime": { + "end_time": "2025-04-17T11:35:09.691056Z", + "start_time": "2025-04-17T11:35:09.687780Z" + } + }, + "outputs": [], + "source": [ + "# Using the HTMLDocumentBackend to convert HTML files. Images will be extracted as references\n", + "doc_converter = (\n", + " DocumentConverter( # all of the below is optional, has internal defaults.\n", + " allowed_formats=[\n", + " InputFormat.HTML,\n", + " ], # whitelist formats, non-matching files are ignored.\n", + " format_options={\n", + " InputFormat.HTML: HTMLFormatOption(\n", + " pipeline_cls=SimplePipeline, backend=HTMLDocumentBackendImagesInline\n", + " ),\n", + " InputFormat.PDF: PdfFormatOption(pipeline_options=pdf_pipeline()),\n", + " },\n", + " )\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "c37aa8c8afcacd16", + "metadata": { + "ExecuteTime": { + "end_time": "2025-04-17T11:35:11.139730Z", + "start_time": "2025-04-17T11:35:09.734469Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Could not load image (src=https://github.com/docling-project/docling/tree/main/docs/assets/pdf.png): cannot identify image file <_io.BytesIO object at 0x73d26d7658a0>\n", + "Could not load image (src=https://github.com/docling-project/docling/tree/main/docs/assets/docx.png): cannot identify image file <_io.BytesIO object at 0x73d2675e5170>\n", + "Could not load image (src=https://github.com/docling-project/docling/tree/main/docs/assets/html.png): cannot identify image file <_io.BytesIO object at 0x73d2675e4c20>\n" + ] + }, + { + "data": { + "text/markdown": "# Introduction to parsing HTML files withDocling\n\nDocling\n\n![Image](data:image/png;base64,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)\n\nDocling simplifies document processing, parsing diverse formats — including HTML — and providing seamless integrations with the gen AI ecosystem.\n\n### Supported file formats\n\nDocling supports multiple file formats..\n\n- Advanced PDF understanding\n- PDF\n- Microsoft Office DOCX\n- DOCX\n- HTML files (with optional support for images)\n- HTML\n\n#### Three backends for handling HTML files\n\nDocling has three backends for parsing HTML files:\n\n1. HTMLDocumentBackend Ignores images\n2. HTMLDocumentBackendImagesInline Extracts images inline\n3. HTMLDocumentBackendImagesReferenced Extracts images as references", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.display import Latex, Markdown, display\n", + "\n", + "html_file = \"../../tests/data/html/example_09.html\"\n", + "result = doc_converter.convert(html_file)\n", + "document = result.document\n", + "markdown = document.export_to_markdown(image_mode=ImageRefMode.EMBEDDED)\n", + "display(Markdown(markdown))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "94f7cc6d7288c909", + "metadata": { + "ExecuteTime": { + "end_time": "2025-04-17T11:35:11.185013Z", + "start_time": "2025-04-17T11:35:11.182838Z" + } + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tests/data/groundtruth/docling_v2/example_01.html.itxt b/tests/data/groundtruth/docling_v2/example_01.html.itxt index fbd75125..c5dfe067 100644 --- a/tests/data/groundtruth/docling_v2/example_01.html.itxt +++ b/tests/data/groundtruth/docling_v2/example_01.html.itxt @@ -1,12 +1,11 @@ item-0 at level 0: unspecified: group _root_ item-1 at level 1: title: Introduction - item-2 at level 2: text: This is the first paragraph of the introduction. - item-3 at level 2: section_header: Background - item-4 at level 3: text: Some background information here. - item-5 at level 3: picture - item-6 at level 3: list: group list - item-7 at level 4: list_item: First item in unordered list - item-8 at level 4: list_item: Second item in unordered list - item-9 at level 3: ordered_list: group ordered list - item-10 at level 4: list_item: First item in ordered list - item-11 at level 4: list_item: Second item in ordered list \ No newline at end of file + item-2 at level 1: text: This is the first paragraph of the introduction. + item-3 at level 1: section_header: Background + item-4 at level 1: text: Some background information here. + item-5 at level 1: list: group group + item-6 at level 2: list_item: First item in unordered list + item-7 at level 2: list_item: Second item in unordered list + item-8 at level 1: ordered_list: group group + item-9 at level 2: list_item: First item in ordered list + item-10 at level 2: list_item: Second item in ordered list \ No newline at end of file diff --git a/tests/data/groundtruth/docling_v2/example_01.html.json b/tests/data/groundtruth/docling_v2/example_01.html.json index fce02e10..7c1ce1d3 100644 --- a/tests/data/groundtruth/docling_v2/example_01.html.json +++ b/tests/data/groundtruth/docling_v2/example_01.html.json @@ -19,6 +19,21 @@ "children": [ { "$ref": "#/texts/0" + }, + { + "$ref": "#/texts/1" + }, + { + "$ref": "#/texts/2" + }, + { + "$ref": "#/texts/3" + }, + { + "$ref": "#/groups/0" + }, + { + "$ref": "#/groups/1" } ], "content_layer": "body", @@ -29,7 +44,7 @@ { "self_ref": "#/groups/0", "parent": { - "$ref": "#/texts/2" + "$ref": "#/body" }, "children": [ { @@ -40,13 +55,13 @@ } ], "content_layer": "body", - "name": "list", + "name": "group", "label": "list" }, { "self_ref": "#/groups/1", "parent": { - "$ref": "#/texts/2" + "$ref": "#/body" }, "children": [ { @@ -57,7 +72,7 @@ } ], "content_layer": "body", - "name": "ordered list", + "name": "group", "label": "ordered_list" } ], @@ -67,14 +82,7 @@ "parent": { "$ref": "#/body" }, - "children": [ - { - "$ref": "#/texts/1" - }, - { - "$ref": "#/texts/2" - } - ], + "children": [], "content_layer": "body", "label": "title", "prov": [], @@ -84,7 +92,7 @@ { "self_ref": "#/texts/1", "parent": { - "$ref": "#/texts/0" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -96,33 +104,20 @@ { "self_ref": "#/texts/2", "parent": { - "$ref": "#/texts/0" + "$ref": "#/body" }, - "children": [ - { - "$ref": "#/texts/3" - }, - { - "$ref": "#/pictures/0" - }, - { - "$ref": "#/groups/0" - }, - { - "$ref": "#/groups/1" - } - ], + "children": [], "content_layer": "body", "label": "section_header", "prov": [], "orig": "Background", "text": "Background", - "level": 1 + "level": 2 }, { "self_ref": "#/texts/3", "parent": { - "$ref": "#/texts/2" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -171,7 +166,7 @@ "orig": "First item in ordered list", "text": "First item in ordered list", "enumerated": true, - "marker": "1." + "marker": "-" }, { "self_ref": "#/texts/7", @@ -185,25 +180,10 @@ "orig": "Second item in ordered list", "text": "Second item in ordered list", "enumerated": true, - "marker": "2." - } - ], - "pictures": [ - { - "self_ref": "#/pictures/0", - "parent": { - "$ref": "#/texts/2" - }, - "children": [], - "content_layer": "body", - "label": "picture", - "prov": [], - "captions": [], - "references": [], - "footnotes": [], - "annotations": [] + "marker": "-" } ], + "pictures": [], "tables": [], "key_value_items": [], "form_items": [], diff --git a/tests/data/groundtruth/docling_v2/example_01.html.md b/tests/data/groundtruth/docling_v2/example_01.html.md index 73031c09..c4e4940e 100644 --- a/tests/data/groundtruth/docling_v2/example_01.html.md +++ b/tests/data/groundtruth/docling_v2/example_01.html.md @@ -2,12 +2,10 @@ This is the first paragraph of the introduction. -## Background +### Background Some background information here. - - - First item in unordered list - Second item in unordered list diff --git a/tests/data/groundtruth/docling_v2/example_02.html.itxt b/tests/data/groundtruth/docling_v2/example_02.html.itxt index 49ea71e8..c5dfe067 100644 --- a/tests/data/groundtruth/docling_v2/example_02.html.itxt +++ b/tests/data/groundtruth/docling_v2/example_02.html.itxt @@ -1,11 +1,11 @@ item-0 at level 0: unspecified: group _root_ item-1 at level 1: title: Introduction - item-2 at level 2: text: This is the first paragraph of the introduction. - item-3 at level 2: section_header: Background - item-4 at level 3: text: Some background information here. - item-5 at level 3: list: group list - item-6 at level 4: list_item: First item in unordered list - item-7 at level 4: list_item: Second item in unordered list - item-8 at level 3: ordered_list: group ordered list - item-9 at level 4: list_item: First item in ordered list - item-10 at level 4: list_item: Second item in ordered list \ No newline at end of file + item-2 at level 1: text: This is the first paragraph of the introduction. + item-3 at level 1: section_header: Background + item-4 at level 1: text: Some background information here. + item-5 at level 1: list: group group + item-6 at level 2: list_item: First item in unordered list + item-7 at level 2: list_item: Second item in unordered list + item-8 at level 1: ordered_list: group group + item-9 at level 2: list_item: First item in ordered list + item-10 at level 2: list_item: Second item in ordered list \ No newline at end of file diff --git a/tests/data/groundtruth/docling_v2/example_02.html.json b/tests/data/groundtruth/docling_v2/example_02.html.json index cef7b79d..2c769e24 100644 --- a/tests/data/groundtruth/docling_v2/example_02.html.json +++ b/tests/data/groundtruth/docling_v2/example_02.html.json @@ -19,6 +19,21 @@ "children": [ { "$ref": "#/texts/0" + }, + { + "$ref": "#/texts/1" + }, + { + "$ref": "#/texts/2" + }, + { + "$ref": "#/texts/3" + }, + { + "$ref": "#/groups/0" + }, + { + "$ref": "#/groups/1" } ], "content_layer": "body", @@ -29,7 +44,7 @@ { "self_ref": "#/groups/0", "parent": { - "$ref": "#/texts/2" + "$ref": "#/body" }, "children": [ { @@ -40,13 +55,13 @@ } ], "content_layer": "body", - "name": "list", + "name": "group", "label": "list" }, { "self_ref": "#/groups/1", "parent": { - "$ref": "#/texts/2" + "$ref": "#/body" }, "children": [ { @@ -57,7 +72,7 @@ } ], "content_layer": "body", - "name": "ordered list", + "name": "group", "label": "ordered_list" } ], @@ -67,14 +82,7 @@ "parent": { "$ref": "#/body" }, - "children": [ - { - "$ref": "#/texts/1" - }, - { - "$ref": "#/texts/2" - } - ], + "children": [], "content_layer": "body", "label": "title", "prov": [], @@ -84,7 +92,7 @@ { "self_ref": "#/texts/1", "parent": { - "$ref": "#/texts/0" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -96,30 +104,20 @@ { "self_ref": "#/texts/2", "parent": { - "$ref": "#/texts/0" + "$ref": "#/body" }, - "children": [ - { - "$ref": "#/texts/3" - }, - { - "$ref": "#/groups/0" - }, - { - "$ref": "#/groups/1" - } - ], + "children": [], "content_layer": "body", "label": "section_header", "prov": [], "orig": "Background", "text": "Background", - "level": 1 + "level": 2 }, { "self_ref": "#/texts/3", "parent": { - "$ref": "#/texts/2" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -168,7 +166,7 @@ "orig": "First item in ordered list", "text": "First item in ordered list", "enumerated": true, - "marker": "1." + "marker": "-" }, { "self_ref": "#/texts/7", @@ -182,7 +180,7 @@ "orig": "Second item in ordered list", "text": "Second item in ordered list", "enumerated": true, - "marker": "2." + "marker": "-" } ], "pictures": [], diff --git a/tests/data/groundtruth/docling_v2/example_02.html.md b/tests/data/groundtruth/docling_v2/example_02.html.md index 2b0a2ceb..c4e4940e 100644 --- a/tests/data/groundtruth/docling_v2/example_02.html.md +++ b/tests/data/groundtruth/docling_v2/example_02.html.md @@ -2,7 +2,7 @@ This is the first paragraph of the introduction. -## Background +### Background Some background information here. diff --git a/tests/data/groundtruth/docling_v2/example_03.html.itxt b/tests/data/groundtruth/docling_v2/example_03.html.itxt index 5b31bf82..5ca2060f 100644 --- a/tests/data/groundtruth/docling_v2/example_03.html.itxt +++ b/tests/data/groundtruth/docling_v2/example_03.html.itxt @@ -1,20 +1,20 @@ item-0 at level 0: unspecified: group _root_ item-1 at level 1: title: Example Document - item-2 at level 2: section_header: Introduction - item-3 at level 3: text: This is the first paragraph of the introduction. - item-4 at level 2: section_header: Background - item-5 at level 3: text: Some background information here. - item-6 at level 3: list: group list - item-7 at level 4: list_item: First item in unordered list - item-8 at level 5: list: group list - item-9 at level 6: list_item: Nested item 1 - item-10 at level 6: list_item: Nested item 2 - item-11 at level 4: list_item: Second item in unordered list - item-12 at level 3: ordered_list: group ordered list - item-13 at level 4: list_item: First item in ordered list - item-14 at level 5: ordered_list: group ordered list - item-15 at level 6: list_item: Nested ordered item 1 - item-16 at level 6: list_item: Nested ordered item 2 - item-17 at level 4: list_item: Second item in ordered list - item-18 at level 2: section_header: Data Table - item-19 at level 3: table with [4x3] \ No newline at end of file + item-2 at level 1: section_header: Introduction + item-3 at level 1: text: This is the first paragraph of the introduction. + item-4 at level 1: section_header: Background + item-5 at level 1: text: Some background information here. + item-6 at level 1: list: group group + item-7 at level 2: list_item: First item in unordered list Nested item 1 Nested item 2 + item-8 at level 2: list: group group + item-9 at level 3: list_item: Nested item 1 + item-10 at level 3: list_item: Nested item 2 + item-11 at level 2: list_item: Second item in unordered list + item-12 at level 1: ordered_list: group group + item-13 at level 2: list_item: First item in ordered list Nested ordered item 1 Nested ordered item 2 + item-14 at level 2: ordered_list: group group + item-15 at level 3: list_item: Nested ordered item 1 + item-16 at level 3: list_item: Nested ordered item 2 + item-17 at level 2: list_item: Second item in ordered list + item-18 at level 1: section_header: Data Table + item-19 at level 1: table with [4x3] \ No newline at end of file diff --git a/tests/data/groundtruth/docling_v2/example_03.html.json b/tests/data/groundtruth/docling_v2/example_03.html.json index fe2e9c34..4454045c 100644 --- a/tests/data/groundtruth/docling_v2/example_03.html.json +++ b/tests/data/groundtruth/docling_v2/example_03.html.json @@ -19,6 +19,30 @@ "children": [ { "$ref": "#/texts/0" + }, + { + "$ref": "#/texts/1" + }, + { + "$ref": "#/texts/2" + }, + { + "$ref": "#/texts/3" + }, + { + "$ref": "#/texts/4" + }, + { + "$ref": "#/groups/0" + }, + { + "$ref": "#/groups/2" + }, + { + "$ref": "#/texts/13" + }, + { + "$ref": "#/tables/0" } ], "content_layer": "body", @@ -29,24 +53,27 @@ { "self_ref": "#/groups/0", "parent": { - "$ref": "#/texts/3" + "$ref": "#/body" }, "children": [ { "$ref": "#/texts/5" }, + { + "$ref": "#/groups/1" + }, { "$ref": "#/texts/8" } ], "content_layer": "body", - "name": "list", + "name": "group", "label": "list" }, { "self_ref": "#/groups/1", "parent": { - "$ref": "#/texts/5" + "$ref": "#/groups/0" }, "children": [ { @@ -57,30 +84,33 @@ } ], "content_layer": "body", - "name": "list", + "name": "group", "label": "list" }, { "self_ref": "#/groups/2", "parent": { - "$ref": "#/texts/3" + "$ref": "#/body" }, "children": [ { "$ref": "#/texts/9" }, + { + "$ref": "#/groups/3" + }, { "$ref": "#/texts/12" } ], "content_layer": "body", - "name": "ordered list", + "name": "group", "label": "ordered_list" }, { "self_ref": "#/groups/3", "parent": { - "$ref": "#/texts/9" + "$ref": "#/groups/2" }, "children": [ { @@ -91,7 +121,7 @@ } ], "content_layer": "body", - "name": "ordered list", + "name": "group", "label": "ordered_list" } ], @@ -101,17 +131,7 @@ "parent": { "$ref": "#/body" }, - "children": [ - { - "$ref": "#/texts/1" - }, - { - "$ref": "#/texts/3" - }, - { - "$ref": "#/texts/13" - } - ], + "children": [], "content_layer": "body", "label": "title", "prov": [], @@ -121,24 +141,20 @@ { "self_ref": "#/texts/1", "parent": { - "$ref": "#/texts/0" + "$ref": "#/body" }, - "children": [ - { - "$ref": "#/texts/2" - } - ], + "children": [], "content_layer": "body", "label": "section_header", "prov": [], "orig": "Introduction", "text": "Introduction", - "level": 1 + "level": 2 }, { "self_ref": "#/texts/2", "parent": { - "$ref": "#/texts/1" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -150,30 +166,20 @@ { "self_ref": "#/texts/3", "parent": { - "$ref": "#/texts/0" + "$ref": "#/body" }, - "children": [ - { - "$ref": "#/texts/4" - }, - { - "$ref": "#/groups/0" - }, - { - "$ref": "#/groups/2" - } - ], + "children": [], "content_layer": "body", "label": "section_header", "prov": [], "orig": "Background", "text": "Background", - "level": 1 + "level": 2 }, { "self_ref": "#/texts/4", "parent": { - "$ref": "#/texts/3" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -187,16 +193,12 @@ "parent": { "$ref": "#/groups/0" }, - "children": [ - { - "$ref": "#/groups/1" - } - ], + "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "First item in unordered list", - "text": "First item in unordered list", + "orig": "First item in unordered list Nested item 1 Nested item 2", + "text": "First item in unordered list Nested item 1 Nested item 2", "enumerated": false, "marker": "-" }, @@ -247,18 +249,14 @@ "parent": { "$ref": "#/groups/2" }, - "children": [ - { - "$ref": "#/groups/3" - } - ], + "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "First item in ordered list", - "text": "First item in ordered list", + "orig": "First item in ordered list Nested ordered item 1 Nested ordered item 2", + "text": "First item in ordered list Nested ordered item 1 Nested ordered item 2", "enumerated": true, - "marker": "1" + "marker": "-" }, { "self_ref": "#/texts/10", @@ -272,7 +270,7 @@ "orig": "Nested ordered item 1", "text": "Nested ordered item 1", "enumerated": true, - "marker": "1." + "marker": "-" }, { "self_ref": "#/texts/11", @@ -286,7 +284,7 @@ "orig": "Nested ordered item 2", "text": "Nested ordered item 2", "enumerated": true, - "marker": "2." + "marker": "-" }, { "self_ref": "#/texts/12", @@ -300,24 +298,20 @@ "orig": "Second item in ordered list", "text": "Second item in ordered list", "enumerated": true, - "marker": "2." + "marker": "-" }, { "self_ref": "#/texts/13", "parent": { - "$ref": "#/texts/0" + "$ref": "#/body" }, - "children": [ - { - "$ref": "#/tables/0" - } - ], + "children": [], "content_layer": "body", "label": "section_header", "prov": [], "orig": "Data Table", "text": "Data Table", - "level": 1 + "level": 2 } ], "pictures": [], @@ -325,7 +319,7 @@ { "self_ref": "#/tables/0", "parent": { - "$ref": "#/texts/13" + "$ref": "#/body" }, "children": [], "content_layer": "body", diff --git a/tests/data/groundtruth/docling_v2/example_03.html.md b/tests/data/groundtruth/docling_v2/example_03.html.md index 23158ed9..b03dbd4a 100644 --- a/tests/data/groundtruth/docling_v2/example_03.html.md +++ b/tests/data/groundtruth/docling_v2/example_03.html.md @@ -1,24 +1,24 @@ # Example Document -## Introduction +### Introduction This is the first paragraph of the introduction. -## Background +### Background Some background information here. -- First item in unordered list +- First item in unordered list Nested item 1 Nested item 2 - Nested item 1 - Nested item 2 - Second item in unordered list -1. First item in ordered list +1. First item in ordered list Nested ordered item 1 Nested ordered item 2 1. Nested ordered item 1 2. Nested ordered item 2 2. Second item in ordered list -## Data Table +### Data Table | Header 1 | Header 2 | Header 3 | |--------------|--------------|--------------| diff --git a/tests/data/groundtruth/docling_v2/example_04.html.itxt b/tests/data/groundtruth/docling_v2/example_04.html.itxt index 4124360d..b4c5525d 100644 --- a/tests/data/groundtruth/docling_v2/example_04.html.itxt +++ b/tests/data/groundtruth/docling_v2/example_04.html.itxt @@ -1,3 +1,3 @@ item-0 at level 0: unspecified: group _root_ item-1 at level 1: title: Data Table with Rowspan and Colspan - item-2 at level 2: table with [4x3] \ No newline at end of file + item-2 at level 1: table with [4x3] \ No newline at end of file diff --git a/tests/data/groundtruth/docling_v2/example_04.html.json b/tests/data/groundtruth/docling_v2/example_04.html.json index 854ba4c6..0cafcedf 100644 --- a/tests/data/groundtruth/docling_v2/example_04.html.json +++ b/tests/data/groundtruth/docling_v2/example_04.html.json @@ -19,6 +19,9 @@ "children": [ { "$ref": "#/texts/0" + }, + { + "$ref": "#/tables/0" } ], "content_layer": "body", @@ -32,11 +35,7 @@ "parent": { "$ref": "#/body" }, - "children": [ - { - "$ref": "#/tables/0" - } - ], + "children": [], "content_layer": "body", "label": "title", "prov": [], @@ -49,7 +48,7 @@ { "self_ref": "#/tables/0", "parent": { - "$ref": "#/texts/0" + "$ref": "#/body" }, "children": [], "content_layer": "body", diff --git a/tests/data/groundtruth/docling_v2/example_05.html.itxt b/tests/data/groundtruth/docling_v2/example_05.html.itxt index 3fc541a3..1776f641 100644 --- a/tests/data/groundtruth/docling_v2/example_05.html.itxt +++ b/tests/data/groundtruth/docling_v2/example_05.html.itxt @@ -1,3 +1,3 @@ item-0 at level 0: unspecified: group _root_ item-1 at level 1: title: Omitted html and body tags - item-2 at level 2: table with [4x3] \ No newline at end of file + item-2 at level 1: table with [4x3] \ No newline at end of file diff --git a/tests/data/groundtruth/docling_v2/example_05.html.json b/tests/data/groundtruth/docling_v2/example_05.html.json index 3168a637..a1691c4d 100644 --- a/tests/data/groundtruth/docling_v2/example_05.html.json +++ b/tests/data/groundtruth/docling_v2/example_05.html.json @@ -19,6 +19,9 @@ "children": [ { "$ref": "#/texts/0" + }, + { + "$ref": "#/tables/0" } ], "content_layer": "body", @@ -32,11 +35,7 @@ "parent": { "$ref": "#/body" }, - "children": [ - { - "$ref": "#/tables/0" - } - ], + "children": [], "content_layer": "body", "label": "title", "prov": [], @@ -49,7 +48,7 @@ { "self_ref": "#/tables/0", "parent": { - "$ref": "#/texts/0" + "$ref": "#/body" }, "children": [], "content_layer": "body", diff --git a/tests/data/groundtruth/docling_v2/example_06.html.md b/tests/data/groundtruth/docling_v2/example_06.html.md index de672b8e..3c8b55cd 100644 --- a/tests/data/groundtruth/docling_v2/example_06.html.md +++ b/tests/data/groundtruth/docling_v2/example_06.html.md @@ -5,6 +5,7 @@ This is another div with text. This is a regular paragraph. This is a third div + with a new line. Heading for the details element diff --git a/tests/data/groundtruth/docling_v2/example_07.html.itxt b/tests/data/groundtruth/docling_v2/example_07.html.itxt index 675749eb..89ef4e1f 100644 --- a/tests/data/groundtruth/docling_v2/example_07.html.itxt +++ b/tests/data/groundtruth/docling_v2/example_07.html.itxt @@ -1,22 +1,24 @@ item-0 at level 0: unspecified: group _root_ - item-1 at level 1: list: group list - item-2 at level 2: list_item: Asia - item-3 at level 3: list: group list - item-4 at level 4: list_item: China - item-5 at level 4: list_item: Japan - item-6 at level 4: list_item: Thailand - item-7 at level 2: list_item: Europe - item-8 at level 3: list: group list - item-9 at level 4: list_item: UK - item-10 at level 4: list_item: Germany - item-11 at level 4: list_item: Switzerland - item-12 at level 5: list: group list - item-13 at level 6: list: group list - item-14 at level 7: list_item: Bern - item-15 at level 7: list_item: Aargau - item-16 at level 4: list_item: Italy - item-17 at level 5: list: group list - item-18 at level 6: list: group list - item-19 at level 7: list_item: Piedmont - item-20 at level 7: list_item: Liguria - item-21 at level 2: list_item: Africa \ No newline at end of file + item-1 at level 1: list: group group + item-2 at level 2: list_item: Asia China Japan Thailand + item-3 at level 2: list: group group + item-4 at level 3: list_item: China + item-5 at level 3: list_item: Japan + item-6 at level 3: list_item: Thailand + item-7 at level 2: list_item: Europe UK Germany Switzerland Bern Aargau Italy Piedmont Liguria + item-8 at level 2: list: group group + item-9 at level 3: list_item: UK + item-10 at level 3: list_item: Germany + item-11 at level 3: list_item: Switzerland Bern Aargau + item-12 at level 3: list: group group + item-13 at level 4: list_item: Bern Aargau + item-14 at level 4: list: group group + item-15 at level 5: list_item: Bern + item-16 at level 5: list_item: Aargau + item-17 at level 3: list_item: Italy Piedmont Liguria + item-18 at level 3: list: group group + item-19 at level 4: list_item: Piedmont Liguria + item-20 at level 4: list: group group + item-21 at level 5: list_item: Piedmont + item-22 at level 5: list_item: Liguria + item-23 at level 2: list_item: Africa \ No newline at end of file diff --git a/tests/data/groundtruth/docling_v2/example_07.html.json b/tests/data/groundtruth/docling_v2/example_07.html.json index 1fb4f262..1581aed1 100644 --- a/tests/data/groundtruth/docling_v2/example_07.html.json +++ b/tests/data/groundtruth/docling_v2/example_07.html.json @@ -35,21 +35,27 @@ { "$ref": "#/texts/0" }, + { + "$ref": "#/groups/1" + }, { "$ref": "#/texts/4" }, { - "$ref": "#/texts/13" + "$ref": "#/groups/2" + }, + { + "$ref": "#/texts/15" } ], "content_layer": "body", - "name": "list", + "name": "group", "label": "list" }, { "self_ref": "#/groups/1", "parent": { - "$ref": "#/texts/0" + "$ref": "#/groups/0" }, "children": [ { @@ -63,13 +69,13 @@ } ], "content_layer": "body", - "name": "list", + "name": "group", "label": "list" }, { "self_ref": "#/groups/2", "parent": { - "$ref": "#/texts/4" + "$ref": "#/groups/0" }, "children": [ { @@ -82,25 +88,34 @@ "$ref": "#/texts/7" }, { - "$ref": "#/texts/10" + "$ref": "#/groups/3" + }, + { + "$ref": "#/texts/11" + }, + { + "$ref": "#/groups/5" } ], "content_layer": "body", - "name": "list", + "name": "group", "label": "list" }, { "self_ref": "#/groups/3", "parent": { - "$ref": "#/texts/7" + "$ref": "#/groups/2" }, "children": [ + { + "$ref": "#/texts/8" + }, { "$ref": "#/groups/4" } ], "content_layer": "body", - "name": "list", + "name": "group", "label": "list" }, { @@ -110,28 +125,31 @@ }, "children": [ { - "$ref": "#/texts/8" + "$ref": "#/texts/9" }, { - "$ref": "#/texts/9" + "$ref": "#/texts/10" } ], "content_layer": "body", - "name": "list", + "name": "group", "label": "list" }, { "self_ref": "#/groups/5", "parent": { - "$ref": "#/texts/10" + "$ref": "#/groups/2" }, "children": [ + { + "$ref": "#/texts/12" + }, { "$ref": "#/groups/6" } ], "content_layer": "body", - "name": "list", + "name": "group", "label": "list" }, { @@ -141,14 +159,14 @@ }, "children": [ { - "$ref": "#/texts/11" + "$ref": "#/texts/13" }, { - "$ref": "#/texts/12" + "$ref": "#/texts/14" } ], "content_layer": "body", - "name": "list", + "name": "group", "label": "list" } ], @@ -158,16 +176,12 @@ "parent": { "$ref": "#/groups/0" }, - "children": [ - { - "$ref": "#/groups/1" - } - ], + "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "Asia", - "text": "Asia", + "orig": "Asia China Japan Thailand", + "text": "Asia China Japan Thailand", "enumerated": false, "marker": "-" }, @@ -218,16 +232,12 @@ "parent": { "$ref": "#/groups/0" }, - "children": [ - { - "$ref": "#/groups/2" - } - ], + "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "Europe", - "text": "Europe", + "orig": "Europe UK Germany Switzerland Bern Aargau Italy Piedmont Liguria", + "text": "Europe UK Germany Switzerland Bern Aargau Italy Piedmont Liguria", "enumerated": false, "marker": "-" }, @@ -264,21 +274,31 @@ "parent": { "$ref": "#/groups/2" }, - "children": [ - { - "$ref": "#/groups/3" - } - ], + "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "Switzerland", - "text": "Switzerland", + "orig": "Switzerland Bern Aargau", + "text": "Switzerland Bern Aargau", "enumerated": false, "marker": "-" }, { "self_ref": "#/texts/8", + "parent": { + "$ref": "#/groups/3" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Bern Aargau", + "text": "Bern Aargau", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/9", "parent": { "$ref": "#/groups/4" }, @@ -292,7 +312,7 @@ "marker": "-" }, { - "self_ref": "#/texts/9", + "self_ref": "#/texts/10", "parent": { "$ref": "#/groups/4" }, @@ -306,25 +326,35 @@ "marker": "-" }, { - "self_ref": "#/texts/10", + "self_ref": "#/texts/11", "parent": { "$ref": "#/groups/2" }, - "children": [ - { - "$ref": "#/groups/5" - } - ], + "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "Italy", - "text": "Italy", + "orig": "Italy Piedmont Liguria", + "text": "Italy Piedmont Liguria", "enumerated": false, "marker": "-" }, { - "self_ref": "#/texts/11", + "self_ref": "#/texts/12", + "parent": { + "$ref": "#/groups/5" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Piedmont Liguria", + "text": "Piedmont Liguria", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/13", "parent": { "$ref": "#/groups/6" }, @@ -338,7 +368,7 @@ "marker": "-" }, { - "self_ref": "#/texts/12", + "self_ref": "#/texts/14", "parent": { "$ref": "#/groups/6" }, @@ -352,7 +382,7 @@ "marker": "-" }, { - "self_ref": "#/texts/13", + "self_ref": "#/texts/15", "parent": { "$ref": "#/groups/0" }, diff --git a/tests/data/groundtruth/docling_v2/example_07.html.md b/tests/data/groundtruth/docling_v2/example_07.html.md index 0a4b9fac..79ca8e52 100644 --- a/tests/data/groundtruth/docling_v2/example_07.html.md +++ b/tests/data/groundtruth/docling_v2/example_07.html.md @@ -1,14 +1,16 @@ -- Asia +- Asia China Japan Thailand - China - Japan - Thailand -- Europe +- Europe UK Germany Switzerland Bern Aargau Italy Piedmont Liguria - UK - Germany - - Switzerland + - Switzerland Bern Aargau + - Bern Aargau - Bern - Aargau - - Italy + - Italy Piedmont Liguria + - Piedmont Liguria - Piedmont - Liguria - Africa \ No newline at end of file diff --git a/tests/data/groundtruth/docling_v2/mixed.md.md b/tests/data/groundtruth/docling_v2/mixed.md.md index 6cd5d52b..69fad98e 100644 --- a/tests/data/groundtruth/docling_v2/mixed.md.md +++ b/tests/data/groundtruth/docling_v2/mixed.md.md @@ -2,7 +2,7 @@ Some text -## Famous ducks +### Famous ducks Here is a table: diff --git a/tests/data/groundtruth/docling_v2/mixed_without_h1.md.md b/tests/data/groundtruth/docling_v2/mixed_without_h1.md.md index 5f76d50c..6ddaf672 100644 --- a/tests/data/groundtruth/docling_v2/mixed_without_h1.md.md +++ b/tests/data/groundtruth/docling_v2/mixed_without_h1.md.md @@ -1,8 +1,10 @@ -## Some heading +Content before first heading + +### Some heading + +This is HTML - A. first - - subitem - B. second - 1. strange The end! diff --git a/tests/data/groundtruth/docling_v2/nested.md.md b/tests/data/groundtruth/docling_v2/nested.md.md index 6e430e0c..6adac0d3 100644 --- a/tests/data/groundtruth/docling_v2/nested.md.md +++ b/tests/data/groundtruth/docling_v2/nested.md.md @@ -3,29 +3,64 @@ A list featuring nesting: - abc - - abc123 - - abc1234 - - abc12345 - - a. - - b. - - abcd1234: - - abcd12345: - - a. - - b. - def: - - def1234: - - def12345。 - after one empty line - - foo - afer two empty lines - - bar - changing symbol A nested HTML list: - First item -- Second item with subitems: +- Second item with subitems: Subitem 1 Subitem 2 - Subitem 1 - Subitem 2 - Last list item + +Table nesting apparently not yet suported by HTML backend: + +<table> + +<tr> + +<td>Cell</td> + +<td>Nested Table + +<table> + +<tr> + +<td>Cell 1</td> + +<> + +</tr> + +<tr> + +<td>Cell 2</td> + +</tr> + +<tr> + +<td>Cell 3</td> + +</tr> + +<tr> + +<td>Cell 4</td> + +</tr> + +</table> + +</td> + +</tr> + +<tr><td>additional row</td></tr> + +</table> diff --git a/tests/data/groundtruth/docling_v2/powerpoint_with_image.pptx.json b/tests/data/groundtruth/docling_v2/powerpoint_with_image.pptx.json index 192ef753..50b39ab7 100644 --- a/tests/data/groundtruth/docling_v2/powerpoint_with_image.pptx.json +++ b/tests/data/groundtruth/docling_v2/powerpoint_with_image.pptx.json @@ -138,7 +138,7 @@ "width": 268.0, "height": 268.0 }, - "uri": "data:image/png;base64,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" + "uri": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAQwAAAEMCAYAAAAxjIiTAAABeWlDQ1BJQ0MgUHJvZmlsZQAAeJx1kc8rRFEUxz8GkaFRJAuLl4aVEaMmNspMGkrSGOXXZuaaH2pmvN570mSrbBUlNn4t+AvYKmuliJSsZ01s0HOeUTPJnNu553O/957TveeCK5pRWbOmD7I5y4iEg9rs3LxWV8CNh2ba8MaUqY9MTU1Q0d7vqXLirc+pVfncv+ZeSpgKquqFh5VuWMJjwhNrlu7wjnCrSseWhM+Eewy5oPCdo8eLXHA4VeRPh41oJASuZmEtVcbxMlZpIyssL8ebzayq3/s4L2lM5GamJXaKd2ASIUwQjXFGCRGgnyGZA/jw0ysrKuT3/eRPsiK5SmadPAbLpEhj0SPqqlRPSEyKnpCRIe/0/29fzeSAv1i9MQi1z7b92gV12/C1ZdsfR7b9dQzVT3CZK+WvHMLgm+hbJc17AJ4NOL8qafFduNiE9kc9ZsR+pGpxVzIJL6fQNActN9CwUOzZ7z4nDxBdl6+6hr196JbznsVvWF5n3zvQ5ukAAKPUSURBVHic7J13fBtF2se/I8lyb7HjxE7vvXcSSEIIJUDovRy9c0c7Drg7Do5yR29H5+idEAiEmtBCCAkppJDeu+3EjrstS9p5/1hJXq12pV1ZTsK9+X0+suTdaTs785tnnnnmGTiEQziEQziEQziEQziEQziEQziEQziEQzj4IQ50AQ6heZBSCiA18HED7YA6oBxoAGqEEL4DV8JDOIRDOOCQUgop5flSym0yOrxSyusCxHIIh3AI/58gpUyTUn4rpWyIQRR6lEspBx/o8h/C7xuHRp3fEaSUbwKnASlxJlEHjBVCLLWRZwowHpgIdAU6AxmABPyoU58lwCLgByHEzjjLdgiHcAiJgJSyo5Ryk02JwgxLY+TVRUp5p5TyZyllsZTSbyNtJRBnvpTyJimlaz9V0SHsJxySMA5ySCmPB6YRv1RhhFVAEpBs8HEkMJ86YC5wpxBiQQLTPYQDhEOEcRBDSnkc8Bn/G+/pG+A1YAGwXgghD3B5DiEO/C80xP9JSCmHA/MB54EuSwugClgG/AosR9WBLBNCKAe0VIcQE4cI4yCElLIt8AvQ4UCXZT+iDpgNfAUsBX4TQlQd0BIdQgQOEcZBACmlE+gGDAXOB47FomTh8XjYvHkze/bsASAvL4/u3bvjdrtbqrj7C35gFvAG6grMRiGE/8AW6RAO4QBBSpkqpewjpXxASllhd6mjoqJCPv744zInJ0eiLnGGPqmpqfLjjz+WPp/PbrIHMyqklA9JKftJKdMO7Ns7hEPYD5BSpkgpu0opn29Oz1m4cKHMyMiIIAr959prr5V+v51V0SYoiiIVRWlOMVsaL0kpu0nVTuQQDuF/A1I14c6WUj6XiF7y1FNPxSQK7Wf69OlR01MURXq9Xrly5Up5zz33yHHjxslWrVqF4icnJ8v+/fvLyy67TM6YMUM2NDTETUItiDeklHnykPn7IfyeIaW8RkpZIqVMyNzgvffekw6HwxZhFBQUGHZwr9crH3/8cZmdnS3dbrfl9BwOh0xLS5MjRoyQc+bMScRjJQo+KWWplPLq/fqSD+EQmgOpWmV+J6WsSWRvqKyslMnJybbIIvj57bffQumUlZXJ0047Taanp8eVlv6Tl5cnL730UllXV5fIx20uaqRqqdprf7zzQzgEW5BSOqWUF0spf5OqeXRC4fP5ZIcOHWJ23iSnMLz+xRdfSL/fL2+99VaZlZWVEKLQf7KysuQll1wivV5voh+/OVCklCul+m4SacF6CIdgH1LKdCnl3TL2FvNm4ZNPPonaWdvnueSsuzvLs8ZlG95/+OGH5cCBA1uEKPSfNm3ayJdeeqklqyNebJPqKkt2izaKQzgEPaSUbaSUD0sp97R0K6+rq5OZmZmmHXTKsExZ/mYfKT/uLycOSMw0o7kfIYQ8/fTTD9ZVlnIp5WNSNY47BJs4tJvQBqSUhcCtwOVA+v7Ic9WqVVRXVxveO354Jh/d1pEkl7o4kJsevxV5klMwsmcq/Tok07Wtm9wMJ6lJDmo9Cnur/azZ4WHJxnrW7PAgY6QlpWTatGlkZ2fTvXt3+vfvz6BBg+jfvz8DBgygqKgo7nImALnADcBlUsqXgMeFEFsPZIF+Tzi0DGUBUspWwHXAX4D9ajR07LHH8tVXX0Vcb5+fxPInupObkwZeDwD/eKeUf75Xajlth4Dx/dK5aFIOZxyWTWqyA4QIfBwgFVDCt3es2u7h0Rl7eXduJbUN8W39aNOmDUcccQRHHXUUgwcPZsCAAaSmpsaVVgLgAR4DHhFC7D1Qhfi94BBhRIFULQovAh5H3Q6+v/KlpKSExYsXc8IJJxiG+eDWDpw+NhcKOkPJJgAWbqhj5C2bYqYvgBE9Unn6yiKGd08FdypktoLMfPW30DQLxQ+NDVBfDXWVUF8Ffh87yrycfP82Fm+sb/bzCiGYMGECZ5xxBocddhi9e/cmOTm52enahBe4HnhTCFG7vzP/veAQYRhAqo5fJgAfs5+mHj6fj+3btzNnzhweeeQRVqxYYRo2PcVB2Rt9SM5rDTltYdtvAJRX+8m7YHXUfNwuwZ9OyOPBi9qqxNC6M+SaTOelVKWXukqo2qOShgZ+RTLqz5sSQhpaJCcnc95553HRRRfRq1cvCgoKEpp+DNQDZwFfCSEa92fGvwccIgwNpGop2A2YDgxo6fz8fj+lpaX897//5eGHH6aystJSvD8cmcurf2wHhT0gPRs2LArdG3fbJn5aU2cYz+UU/OeKQq48ppU65eg8CNwGltWKD6rLoXSLKmHoUN+oULzPx0Mf7+Wlr/fh9cfSajQPI0eO5IEHHmDIkCFkZ++3RY51wIkc8t0RhkOEEUBAqngZuKCF86GhoYGXXnqJm266CZ/P/gkAT11eyHXH50GXweoUYusKaKgBoKrOT855q5EGTfy+89twx+mt1X/adoNs3cgtJZTtUD8GaPRJbn+jmMc/KUM5QF1owIABvPrqqwwcOBCXa7/o7F8DLhdCePdHZgc7DhmzAFLKKUAFLUwW3377Le3atSMrK4s//vGPcZEFgDspwPOuwDw/p03oXlaakwvG50TEGd0rjdtOC5BFclokWTTUwIaFhmTh8UoufHwHGWev4tEZB44sAFasWMGwYcPIzMzkwgsvpKKioqWz/ANQJaU8r6Uz+j3g/zVhSNVl/zzgU1pIV1FZWcnll19OXl4ekyZNYvfu3XETRRAbdgem1kogncxWYYrKV/7UntbZ4Uus/zirNY5gkNzC8ASLN8LW3wynH0/OLCP/gtW88X0FXt/BI5k3NDTwxhtvUFBQQNeuXXnjjTdaMrsU4HUp5S/y//nW+v+3hCGlvB4oBsbQAvUwf/58xo0bR9u2bXnppZcoLy9PWNofzw84ovIElI0OF7TpFrrvELDyyR7kZaqk0aWNm6MGZQRuOiErIGlICdtXQmUp6KwrqusVJt25mT+9tJuaOJdP9we8Xi+bN2/mwgsvpLCwkBtuuIGGhoaWyMoBjACKpZR/aokMfg/4f0cYUsoMKeV3wBNAZqLTf+eddxg+fDhjx47lp59+apHGu353I4s21EPF7qaLWXmQ3CQktc528cN9XcjPcnLc0AxczoB4EVw2lRJ2rIa6SC94JRU+DvvLRr5d/vtaXSwuLuaJJ56gdevWnHHGGWzevLklsskEHpNS/hSwz/l/hf9XSk8p5dnAM6jWfgmDz+fjlVde4ZFHHmHt2rWJTNoUxw/PZObfOkF+B8hrr170+2Dzr+p3AGt3ethV7mPigACZZOZBUU8o3Qz7iiPS9fslZz2ynYXr6mn0STw+SaNP0uiVLb4akmg4HA5OPvlk7r//fnr1apGNqzXAFUKId1oi8YMR/y8IQ0qZgWrNd1ki0/V6vbz77rv861//YvXq6PYPLYH/XFHItVPy1ClG607gSgJfI2xZDn4TpX5+R3Anw671tvOTUuL1qysxlXUKVXV+9lT52bbHy5bSRtbvamRzSSPLtzTgOYj0HQDnnHMOd9xxB/3792+J5F8Cbv7/4LT4f54wpJR9gbeBQYlKU1EUZs6cye23386qVasSlaxtuJyCN25ox9mH56h2FTltVAWoO03VTXgM7DEKe6hKTtlyegm/IlmyqZ6f19Qzb00dSzc3sGG3B/9BoAq59NJL+dvf/kbnzp0TnfRq4HwhxJJEJ3ww4X+WMAJGWGej2lYkzO/j0qVL+dOf/sScOXMSlWRcEECrTCeFuS6evLyoacoB4HSpFqA15eGkIQRk5KpGWfsZ5dV+Pl9czccLqli6uYHNJY0HbHnW7XZz5513cvXVV9OqVULVEF5UKfaN/1Vjr/9JwpBSJqMqNa9MVJq7d+/mjjvu4NVXX01UkrbgdEDH1m4GdErhxBGZnDAik7Y5iTRcEuGtwcjyK4EoqfTx36/38f5PlWwobox7I1tzkJOTwwsvvMApp5ySaCOw54AbhRAtslxzIPE/RxhSyizUY/mGJyI9n8/HBx98wB/+8Ae83v1r7JeZ6qBtrovLj27FH6fkkey2+bocDnWqIhzqcmpyqvpxuQOfJPVbmKQrpapAVfyqbqSxoenja2zazSqVZhGMlPD2nAr+/eEeNpd69zt5dO/ene+++4727dsnMtnlwAQhxL5EJnqg8T9FGFLKPGADkJOI9EpKSujVq5flPR6JgNMhaJ/v4pkri5gyzMaqb3BLekoGZOZAeo46NdlfaGyA2kqoKgtst5dxk8ibP1Twl9eKKanw49+P85YbbriBBx54IJGHQNUAvYQQuxKV4IHG/wxhSClHA3NIwDZ0RVG49tpreeGFF1CU/TPaCQF/PaM1t5/WmlS3w3TQD4MzCXIKIDtflSAsRdpPkFKVTCpLYV+poRVprOh1HoW73y3loY/3n5sKt9vNggULGDx4cKKS9AHj/ldOrz+IWlj8kFJeBTxNAgzRVq5cyVFHHUVxcaSNQkugXZ6LaX/pyOAuqaQkWXgdma0gtw0kJask8XuB4gefV5VAKksjHPNEQ71HYdmWBi54fEeTWXwLwuFwcOaZZ/L666+TlJQQNygKcIsQ4rFEJHYg8bsmjMBKyBOojk+amxY33XQTzz77LB6Pp/mFi4EhXVP473XtGdg5GacjymsQQrWzyMlXSUL8DxjnSqnqQOqqYF9JyGNYLCiKaoj2t7dL+Gh+VUvrZWnfvj3vv/8+Y8aMSVSSrwKX/Z7PiP3dEkZgJeQt4LTmprVx40ZOPfVUli9f3vyCxcCYXmk8dmlbRvWMsYcpPVudbqSk/74kiXgQ1H/sKw6zUo2GDbsbeeyTvTz/VXmL2ne43W6uuuoqHn/8cURipnwzgdOFEC0/KrUAfpeEIaVMB6ahnnLeLLz88svcfPPNLb5Nunuhm0cvLuSEkZnmlS4ckNMasvKNHds0F40N0FCr2mZ4G1QDr/x2ic8nXkipbrOvKofqMktK0w27G3ni070899U+fC1ouj569Gg++OCDRK2kfA2cJoSoSURi+xO/O8KQ6rkSHwKTmpOO1+vlyiuv5LXXXmtRxWayS3DrqfncfrqqzDSEy61KE1l5iVvZkBLqa9RPQ41KFFrFozMJug5MTF6gSgaN9aqeIjMBxlA+L1Tthcq96vQlBlZv9/CPd0v54KeWW9Fq1aoVL730EqecckoikpsDnCKE2P9WdM3A74owArsDZwDjmpPOjh07mDRpEuvWrUtMwUxwWO80nru6iAGdTKQFp0tVYOYUNOkm/L4mOwefV53fK35o2yV2hn6/6qS3phJq9kU3/27bFTLj3IPn86pSiqdeJSNPnXpNOKCwqzqdShSkVC1TK0qNTd11mLemjlteKebntbHDxgOn08mtt97K/fffn4jkFgEnCCFKEpHY/sDvhjCklLnAbGBoM9Jgzpw5TJo0Cb+/5fROWWkO/nFWATecmI/DSKhwONWl0Px24POpHaG+RnW26zFwqJtXBK0KI68H4amDyjKo3IPer4UhnC7oamNrjeJXy1VXpXZeMyVlfnuVAFsKNfugvDgmcSgSXviqnH+8U0ppZfOcFZlh/PjxfPrpp2RmNttDwjJgkhCiLAHFanH8LggjsNt0DjAk3jR8Ph8vv/wyV16ZMGtxQxzWO43P/t6JHKNDhYSAtCy1YzXWqysEDRZ8TnTur66Q6OGphz3bVLKxg5R06NA7ehhFUctYsUfVJ8RCWia062mvHPGithL27lAlsSjw+iRnPLidmYuqWkQxmp+fz4IFC+jatWtzk1oBjBVCGJ9YdRDhoCcMKaUb+IVm7DZtbGzkpptu4umnn05cwXRIcQuevKyIy482EfMdgelHTbmxFBENPYaF/6/4oWSrOuLGg/QcKOpmfE/xq0rHvTus72gVAjr2bRlFbTRU7oGyXTFXVhasr+PUf21jV3nLSBs//vgjY8eObe4qyipg2MG+/+SgJgypnri9HOgXbxoej4fjjjuO7777LnEF06F9XhKr/tODzNQWspHoPqRJx+Gpgx1rbRk+RSAjBwp1hCGluqxZFocVc2YrazqWlsLeHaqOI8aqyhkPbmP6z1Utskv2zTff5Nxzz20uaWxENSU/aO00DlrCCBhlLQfi9nhSU1PDwIEDW8pVGwAXTsjhlT+1J5rtVbPRsa+6aayqDEq2ND89/ZTE64Ftq22bb4fQrqc6JTGC4ofqfaoy1tPQtM8kCOFUHfokpUBquqowdcWxl0Pxw451MfUb3yyr4bh/bsGb4C4phODee+/ljjvuaG5Sa4C+B+v2+IOSMAJk8R5wRrxp7Nq1i6FDh1JS0jIK6BS34LO/dWLiwIyWr8ScAlXcL92WmPRcbugSOKepcg+UbseSstQwrSToolmeVRQo362Sm+K376gnPRsKOsZHGkiorYZdG4j2POU1fo65a4vqFzWBEEJw+eWX8/zzzzc3qU+Bkw5G0jhYCeNvwD3xxl+/fj1jx45lz549CSxVEwZ3SeHzOztRmLufjlsNHoycSHTq16Q8bA6C05v6GtizXVWUxmOznZQMRd0Towfx+9TnqjJX1jY0Su5+r4R/f5j4jW0nnXQSH3/8cXOT+bcQ4vYEFCehOOgII3BgzJvxxl+6dCmTJk1KqFt/LS6YkM3TV7ZrOX3F/kJSsuU9HFGRmavaYNhdqQlLIw/adEr8btu6Sti5wfS2IuGj+ZWc/sD2xOYLTJkyhZkzZzZXp3GFEOLFRJUpETioCENKeQTwLRDX5olffvmFo446iurqllmduv+CNtxycj5JzoOq2n7fsLLE2xz4vFCyGerM28TijfVM+NtmauoTK8Udc8wxfPHFF80hDQkcLYSYncBiNQsHTcuXUnYHFgBx2RWvWLGC0aNHU1eXeAs/pwPe+3NHThuTlfC0/1/D4YDOA/aPo5/yYijfZTpdKqnwMfa2TWwsTuz2+aOOOoqvv/66OaRRBYwSQqxJYLHixkFBGFLKHOB74rS1WL16NQMHDmz2EYRGyM1w8tO/utKng4Hh1CE0D3rpwteo2qh4A24A/b4mF4BOl2rLkpSkHsaUlKLqO+x0xNpKdZXJxG7D55ccfvsm5q9LrDJ04sSJfP31183xG7oKOPxg2HdywAlDSulEXRGJa5v62rVrGTBgQIv42+yQn8SKJ7uTnfY/vr38QCGvSNWB1FSqJucW9oqEweFUvaBnZKuuCa1IKr5G2LXRNC8pYco9W/hySWI3kp599tnNdcgzE3WzWstYn1nEwUAYdwN3xhN3+/bt9OrVi/r6xI4IAD2L3Cx7ooc1L1iHEB9cbks7US0jK089myWW5CElFG+CmgrTIFPv28qnCxOrC7vxxht58MEHmyNpPCSEuDWRZbKLA9obpJRjUfeI2F5yKC8vp3///uzevTt2YJsY2DmFJY92i+4J6xAOQghIckOrIsiyoArbswMqzO10Tr5/KzN+SSxp3Hfffdx22204DHclxsQBV4IesB4hpUwBtgIFduN6PB5Gjx7N0qVLE16uUT3T+PmBrgeVP91DsABXEhR2h5QYnsz0qNqr7ssxwYn3bmXmosSSxn//+18uueSSeKOXAR2FEC2zfz8GDiRhLCHO3acnnngiM2fOTHCJ4PC+afxwf9cDP087BHvIzFX9e8SLhhrYbnyItpRw+B2b+Gl1YvvnV199xdFHHx1v9BVCiAR6P7KOA2J9JKV8GBgcT9xbbrmlRchiaNcUvr6r8yGy+L0hPRvaNHPjW0oGdOhjeEsImHV3Z/p1TOwq2dSpU5tzgPcAKeWziSyPVez3/iGlLAS2ALY3C7zwwgtcc801CXd+06PQzYKHupGbcWg15HeHLgPV6Ugi4KmD7WsMbTWKK3z0uXY9FbWJa3vt2rXjt99+IycnJ57oPqC3EGJjwgpkAfuVMAJLqNuBKO6jjPHzzz9z1FFHJdwwqzDXxaJHulHUaj/tCzmExCG7tbpRLZHw1ML2dYZ7d1Zu9zDwj+sTuj3+sMMOY+7cufEadu0BivbnUut+m5IEdqA+QxxkUVlZyWmnnZZwsshKczD3310PkcXvFVl5gR9SNfSqqVAtOvfsUA20SraoG+LKi1WjLZ8FW53kdHUTnMH5L/06JPP5nZ0TV35g3rx5XHPNNfFGbw28Euhb+wX7LSMp5QhUz1m2cdhhh/Hzzz8nuESw9LHuDOqyn71EHULikJHbZB1qdTevOwVSM1WySUk3D1ddrhKObnoiJdzzXin/eLc0/nLr4HQ6ee211zjvvPPiTWKsEGJewgoUBfuFMKSUmcAmIN9u3Ntuu40HHngg4WV695YOnDUugd6tD+H3h7RM1blyqonzn4pSVULRweeXHHHHJn5emziDwaysLJYuXUqXLnEpcKuATkKIioQVyAT7izDuAv5hN968efMYP358QveICODq41rxnyuKDtlaHIKKaLqQsl2qQyAdfH5J/gVrqKxLnBK0ffv2bN26NV6jrkeEELckrDAmaHEdhpRyIHGQRXV1NRMmTEj4hrIRPVN5+spDZHEIATic0Y298orUqY8OLqfgq390Tqirgx07dnDZZZch4zs09mYp5bDYwZqHFiUMKWUS8IrdeH6/n6OPPjrhG8ra5yUx/wETb9mH8P8PKemqq8KsGDPltl0MPYGN6pXK6WMT6/Lg1VdfZcmSJfFGfyXgZb/F0NISxgXEcfDQjBkzmD9/fkILkuQS/HBfl0OSxSGo1lj57dWt9VYOuhZCdXRssHLy9k0d6JCfuFU2KSXDhw9n3764jpAYAFyasMIYoMUII3D4kO2DQLZt28ZppzX7QPYI3HBiHl3btij5HsLvAa4k1WmP3RPaXEnQwfigplf+mPgDradMmRLv1OQpKWVe7GDxoSUljH8CttYsFUVhypQpCS/I6F6p/PvCtglP9xB+h/B5YetvsHWlevyBHSSnQ+sOEZcnDczglNGJnZrMnz+fr776Kp6oTuC+hBZGgxYR0KWUfYGlgC1Z7bXXXuOiiy5KaFkyUx2sfaYnhbn7wQ3cIfz+4HCo3rsKOqh7SmJBStV8XOeAp7reT7cr17OnKnFK+rS0NDZt2kSbNrbPq/UBw4UQyxJWmABaSsJ4GJtksXXrVq699tqEF+SJywopzHGpngS0nyAOupMfDmG/QlECe0jWBqSOGF7whIB2PSIuZ6Y6ue98254aoqKuro5bb43LX44LeDChhQkg4YQhpZwAHGM33k033URtrYWDiW3g6MEZ/GFCjjoq6D+KbCILIzI5RCT//9DYAMWbDSWIMDhd0L5XxOWLJ+UyOMGWw6+//jpffvllPFEnSylPTGhhaBkJ4192050+fTrTp09PaCFcTsGjF7VVC6Lv/CFSMCASgkSiIRUz6eQQ/jfRUKseHVm82Xz/SWoGpIVbCrucgrvPSayUAXDttdfGs49K0IzDwMyQUMKQUh4LjLITx+PxcPvtiT/g6Y5T8+nX3q0hA5q+wZwA9OHQkknwkgGRHML/HqrLYftqqKsyvl/ULcLx8Ikjsjiin02vXzGwadMmHnvssXiiDpJSnprIsiRawngMm4rUBx54gHXr1iW0EIW5Lm46oVV4hw6TFnQShUI4CShE/kYbzyANqb9POJkcIpbfJ3xe2Lke9u6M9JMhRMSqiRC0yIrcAw88wK5du+KJ+q9EliNhhCGlnALYOsJq7969PProo4kqQgivXFNIdqrTRKLQdegwstAQANr/CScRw48JIRmlGcQhEvn9YF+xqtvQn2mS2Sri5PoxvdI4aVRil1mrq6u5+eab44naU0p5cqLKkUgJ4xm7Ea688koqKysTWAToVeRmcv8MYxLQkwVEJ4AgjAhASxJGZKKFnlQUqX6CN8IIR0aW7xAODnjq1JUUvV6jTZcIK9B/nNU64dm/9957LF68OJ6o/0lUGRJCGFLK3oAt10c7d+7kk08+SUT2YXj3j0U4BAZSBBppIvAJdlqzqYRCFMkiKL3o0whKEgZxgy4bIsplRBpa6cikfIfIZP/D74MtK8LPU3ElRRxrMLhLKr3bJ9ayWErJ9ddfH0/UdlLKcYkoQ7MJI+Dt51ts6i7OOOOMhO9E7VqQxKCOKeEdVy1keEc27cQGZBIkgwhJQBM/Ik0jMgr8rxhIKUblAk1Yg/KFpkpRCO8QqbQMpITNK9Rl2CBadwxTgAoBr1zfPuFZ//zzz8ydOzeeqB8nwjNXsxOQUrZC9S1omXy2bt1K165dUZTEnpa9+YmudG7tVjtJ8MmC0obRkwqhvnyBcYBotWN6T4Tnqf/WpxFxXURP3+i6Pg1hlqFsKp/2UrT8DiEKBHTq27STtXIPlG4L3fV4JRlnr8LnTyxr9+vXj99++81uNAkUCCH2NifvRExJvrGbzpQpUxJOFj0L3XTMcxvrA8BYIjBbOdEbdxl9jFZSguloR/2QhKItVzCcSfwISUQjQSgyUqpBXz7t8xtINFrJJUyPokvvEGJAqvYajQHPW1n5Ydvgk5MEb96Q+I1pq1atimefiQB+aK6U0azIAemizE6crVu30q1bt4QeFSAEbHikK10LDKzRg9KDVpIIDsCh+2YJR8lQH05qRnQr6YcJAboyxcrf0r0oEpM0uGZYNpNMoklt/x/hcEKHXuqp8lXlULI5dKu6XiHrnFUJz7JTp05s2bIlnqgFQog98ebbXAnjj3YCSyk5/vjjE36uSFaqgy75SeaSQNAvvJEEEDECoxnNDdILSSZGkkggn+B9DOIaXTMqU0j/QWS5DNMwSDNC36Gpi2Ai+rKh+W24PKx5TqNn+/8IxQ87N4Dfq57CppEyMlMdTOgfxdlwnNi+fXu8PmPubk6+cY8RUsosYC82NpmVlpZSVFSUcMJ46dI2XDo+O/JGLG85VkZKI/2C2SXtCG61Zg2lFStlMggYK/9Y+pyYZY0dJKp00kISiZTqSF7fqJCR6iA9+YAc6Keai7froR5psHtT6PL6XR56Xbs+TA+fCHTu3JlNmzbZPdNEAfLidRjcnD3fh2ODLKSUnHXWWQkni5w0B5cekW0ywpm8oWAFB6cRwU5kNI0IS0LzT2iqA3WNCj9vqGfNzkbWFzeya5+P6gaF+kZJWrIgM8VB+7wkerR107edm9E9UnG7tGXQlEuRAWWsUbm1xdCIGmHXdc9mBP2UROov6vMNpmlQHn02WukkLIzQPKsBSVrEzjIvc1bV8ePKWlbv8LB2p4eSCl+Y4ORyQod8N72K3AzonML4fumM65tGdloLn2xXX6MqPQs6gSsZfB4AurVNJtXtoM5jrrczmpHGwrZt29iyZYtdT+MOYBwQ13mjcXG+lNIBLAP6W41TUlJC27aJN5k9d3Qmb13V1toIqUU8OgDN/T1Vfr5aUcsbc6v4dmUtPhs6XLdLcPTAdP5wRDZHD0wnK8VhoUxx6hMiiFAToVm6HO1qjkEBrOo5TFd0mlDdoPDZompemlXON8vj29HsdMBZ47K5cGIOEwdkNBF2SyC/A7hc6ua1AM5+eBvvzTXZk4L69EV5LnaW2TM1GDJkCIsWLbLraXwN0F8IYXv0jpcwegUytYxbb72Vhx56KJ7sTOF0wLZHulCUExCUYk4JAo0zOILbWboMYPNeH/+ZtY8nv96HLwHCksMB/zg1n8sm5lCU4yRi2dNCmdT7JlOAWIQQNV2TssSMGyQTk0q2SFSVdQrvzK3g9jdKE3qmac92yTz0hzYcNzSTpJYgDuFQT0/btT4kVZVW+Ci6ZA3+KAPL2D6p/LTa/lknO3bsoF0726sxg4QQy+1Gipcw/gL822r4iooKcnNz48kqKnq0SWLdvzoTNmJqoW2vhvei6AF0qGpQ+PfMch6YWZ7QszW12T50bmuuOiqH9GQnTcSmm6LEQyahcEGpwtozh8WLxrAxychI4Ba6ME2QwA8razn70R2UVLTcsaGDuqTwwZ870KMosSezA5CUDBk5sK8kdKntRWuiPk9ephOXU9h+5uuvv54nn3zSbgkfEkLY9s5jWzsUODrA1n70H374wW42ljBlYJpmJcFgVQHNb72ZNzSFD61IGKxWSMmqnY20+9Mm/vVpy5BFsJi3vL2HHjdtZs3OBppWY4i0OtU/YzR7kbBMZPiKTtiqTpT4EXF033qblWBeoXSkSd3rPkgaPArnPradiXduaVGyAFi2uYFe167niU/LEv9evZ6IbfF92kcnppoGhaevKLQ9ij/11FNUVFTYjMV1UkrbTBmPOvlwINtqYEVRuPLKK+PIJjqEgL8d30rXCDFuiKaNO9gh9Wk0BX/o8330u2MLNQ2JNTQzw+4KH31u3cJzsyuMO7DRfhgtuWifS/tsRsZe0EQa+qXT0H1dekZpKUSmEfYutGlpwhOeToNHocs163k3ylw/0ZASbvjvbobdtAElOOtJFHl4wqcXN06N7szb45XsrfKTnmK/W8ZhLp6K2pdtIR7COMNO4CVLllBSUhI7oAYOCxQ7uEMy+ekO485h1tFA17ghjFA0FpCKAic/uYtb32+WJW3cuOa1Ei57qVjToTEktbBrYXtPdCQJkR06aJcRUV+yaT9MhO2FDC9TEIYEoknPjLwD92sbFNpeto7iFpYqzLB0cwOFl6yhsVGJJEg9yWLwvwWcOCIr5pLvi7PKuf8C205/ueqqq4jjWIKz7UawRRiB6cj5duK8/vrrtgoEkGmBYcf3TIls4ERrmCaNwKBB+P2SyQ/v4JNfE+tj1A6khJfnVHLqE7siO5yhwZmOWLQEqncQpCcX/QY2PYlod9UGoSWUqOUy+ShN5appUGh7+Toq6/aPFGeG0kof3a9ery5/xnou0P3WfJv0WyGgc5volggrtnoY1jWV7DR7Y/nOnTtZunSprTjA+VJKW+7B7EoYRwIWfLGrqKys5MUXX7SZBUwdGPsZzhyWYdwIo40MRqQSvK+Je+XrpXwbQ1udmprKySefzJ///Gcuv/xyBgwYYO8hLUBK+HhJDX98ozTGaKcb/Y2mF0bxteloyTdEQFriDVzTdPSYBGwm3ShN16pq/XS+dkPUKV9ubi633nor7777LtOnT+fee++lsLDQWiXaxPYyL5Pv2kKj1+D5wtwRaNuO5hmDF03qZHy/6FaffgV8iuToIZa7WQjvvfee3SjJwPF2ItjSr0gpnwGuthp+2rRpnHGGrRkM7XJctEoTrNhlfq5qfoaDkoc6N01dwpT4Oo1+rGVBXbz/fFfJ9W+bT0O6du3Kk08+ycSJE0lLayI2KSVbt27l0Ucf5emnn07o5johYPr1hZw8NIMw+4mYqxsxwmkN2OKxzLSzemIQ1OuTjLtrK79sbMAIhYWFPPfccxx33HEkJYWPzFJK5s2bxyWXXJJwF4+g+oS979w29uraAr5eVssxd2+JmswX/+iE2yWYcs9WGhpNxBUDZGZmUlJSQmpqquU4wOtCiD9YDWxZwpBSOgFbDkVffvllO8EBOKJHSlSyABjZOaXJG3iQ+UP/a0ZDM9E9QmGoXl+wsYGb3zffSzd16lQWLVrE8ccfH0YWAEIIOnfuzJNPPsn06dNJT0/c/gEp4fT/7GbXPp+m3NJ8ShCMpBeTI0ZMk3oJkyoMPtqChaWjjSvDpzZ65asCj39RbkoWgwcPZv78+UydOjWCLECt77Fjx7Jw4UImT54cd92a4f7pe5m9vKZJKo01/YrpwlFN94i+aVFPfJfAT6vqSHU76N3O3iJGdXU1c+bMsfuoxwf6tiXYmZIcBljWxpSUlPD111/bSB5SkgRT+sZmx/Hdk8M7B5g37AgRWXNPE6DRq3D5G3to9Bkzer9+/XjzzTct2ZOcdNJJPPPMMzidiTNF9isw5dFdeH0yvPxmRBC6J8OfO6LT69IJSzcK2errUv87lI4xmW0obuS2d4w3TWZnZzNt2jQ6doztxC0rK4tp06bRp0+fmGHt4orndlFTr5g/Y7Tn1BI2TXFSXCLm4c1f/loDEi6cmGO7zG+//bbdKHnAEVYD2yGME+yUYubMmbb3jfQrTIpqbx/ExF4BUjFsxFrW1zZ0wj+6EeHx2ZWs2NlomB+oZ6dkZmaa3tfjwgsvZNKkSZbDW8Gy7R4+W1Yb3oEj7B8032HPrXlYs0ZtUjemdWhX2QmgSKQCN7xRYmr78MADD9CtWzfL9ZKVlcWDDyb+oK/NpV6e+LzMXAkMTTodMHheaSiZdDFyw6DB4o31+BXJmJ5ptM6yN+i8//77VFdX24oDnGw1oB3CGG+nBB999JGd4ACcMjCNZVE6LYDbKRhU5DZ/SaYN3aB1BsLUNig8NKvCNM8ePXrQo0fk8XixcNddd9mOEwsX/beE2pAWP3AxTJmolwaIbOwQXj/6FY9opALG9axP01AyUYPN31DPZ0uNV6CEEJx22mm26+WEE06I6x3FwkOflKmrN2bTruBDmdU5RBDwwE7RpxqKhPoGNZ1h3WzpI2hoaGD27Nm24gCWRzZLhBHYyj7MaqKVlZW2pyPZKQ6O7JHCgi2eqOH6FSbhdhDeSfQiL02NM4I8DJYDH55Vwd4ac8nmn//8p90txACMGTOGoqIi2/GiobJe4fPldTE6rcS482oJRR9H99tCvUXkZRg/skM98rn5+aVjx44lPz8/rro56aST4ooXDZV1Ck9+EShv1EEpWp2Hhx/fJ7Z+y+NVB4VzxmXb3lf52Wef2YsA/aSUlpadrEoYp2NjK/z06dPxeqMrLvUY1tGNokiW7oguYQxu7yZ6g5eBUVTfuDUNXBNHSnh9QU3UPMePH2/rWbSwMg+3i79OL0PxGzxfxFRC15nDlkR1hIsMD6+vX/RpE16nZvWsi7+9zMeHC83re+DAgXHXi81t3pbx5o+VSNPprskHNO8jPG6/DrG9iXsCy7o927rpFEPnocfMmTPjWaU72Uogq4RhS38Rz+Gxk3qksK9OIZa/1EFFbkJvRN9wTUy8I8M1vby5G+rZtDe6daHbHb+7eP1qSiKwvtTLr9s9kQ3UaCqhn1aYNW6z0VG7SgC6dDXxw/bqaMIomo+E9xdEn183p65drua4dzHHut2NzFtTHzmdM1o5CSJM8YzmHUG31kk4Y5gz7ygLDriSoV3tTUtKSkr48ccfbcXB4gHqVgnDlgr6p59+shOc1CTB+G7JVNXHYAugd4FLY9Ks7wxSJzoT/jHYw/DA15Ux84zziDoA9uyJ231iVMyMUH5irKwEwojAVPIinHT1ZABEkoWWVIJhZWR9a8jok1+jS3PNsanYuXNn3HFj4dUfKtQfeiKI2FejIQ6jelYkAijMja7MXL2jIRTn6AH2B51p06bZjdLPSqCYhCGlTAEsa5OWLFli+8Ud1jkZp4DKhtirKu2zncYvy1CTbdY5mn6vLY09dXrqqadsPU8QVVVVrF69Oq64sfBZUI+B/pn0nRljqSLsoxshjaYsZnGD0BKHyZSnwat6JouGr776Kh4tP6CK4i2FX7d6wjp9JAET3va0nxDxNg1uRTnRpxlrdjSG0hvYKcX2akkc/j67SiljKo+sSBgnAZZL+9Zbb1kNGsKIjqpeoqI+9ryrfXbAV4T2ZUHkyBe6pvto3PQ3eBW2WPBw9Oqrr8bViB977LGEH9YUxOJtHspq/OGEALp6oOmmnlC10B9zEEYE2utG5AtRp4KadOaurccbY0zw+/188803lushiJ9//plff/3VdjyrWLXDE2pyYc9lpBeSukrQ6zwUKIohYazZ7QmlJaTksJ72pIxly5ZRV1dnJ4oDC5vRrBCGrTWun3/+2U5wAEZ2UAlj577orSk71UF2ssNcDAwjC13DRn8P5m1qsORaz+v18vTTT9t6ppqaGp55xvZxs5ahSFhd7I28aEiSENHpw0ZJiCCBCBIyuhaUKozIJJhPU7lWxFBoB3HttddSXm6+kqKHlJJbbrmFOHZrWka9V7Jul0dXf9pCGHxHfJrqqiArur5lb1V4XxjR1Z7Vp9fr5dNPP7UVBwt6DCuE0ddOjmvXrrUTnG55Lgoz1GnGtorohNGtla6SzUZMoxcV5oxGvfbTJmsNGOD222+3fHiMoihMnjyZ0tJSy+nHg42l3vAGDLpRDhNpgSYiidhIZtDpw6Y9mEg1BteC5Ql8r9ltrb537drFOeecQ22ttd3Cl112GfPmzbMUtjlYuKkhsl0ZTQXNfJME647YO7J9irprOhh/aOcU24514ji7uGusAFYIw/K2wKVLl9oaGQCO0DBnVQwnNe1znOY2/VaWuSCswccyEtPj+OOP54knnoi6ZLxhwwaGDx8e75kRtrBjny/6dMBMix9N6alt2BGdQxNXK26bKU51Ss9yG345v/76ayZOnMiiRYtMw2zatIkpU6bEtWcpHmwt84UTsVF9h+7JyDrT1H92auyu17QNQJKb5qBXkb0VpDi2u8c0GooqF0kpCwDLzjjfffddq0FDGNDGFarI2hg787KSo7i7h6YXEroo1W8hQeq2HUrYWxPegJOTk/F4zA3H/H4/N9xwAy+//DKXX345o0ePJj8/n/r6erZs2cKnn37KCy+8kPCjFMxQ3RDomRJMd+fq60rKyB2YMlhPwfui6ZoWWifLEZCR4RCadyKo80R/v3osXLiQ0aNHc9xxx3HKKafQvn17nE4nJSUlfPbZZ3z44YdR31dzoW8P+6oD+qhQx9f5RdUPTHqE/KlimTBSkoRKvALG9khlzS7rg9ymTZvwer2Gm/dMkCOl7CqE2GQWINbC9QnY2AL/7bffWg0aQo+8pFDl1sTYR5KV7AgxbuxiBRIVUhNH+y2o0Ek0Q4cOtaSDWb58Oddff33McC0N1UQ8+J8M+4o8UChYHyKyKoL/BKtVkQZxAjdDhGJSqGC+koDXcEIdxWOysS8a/H4/M2fObNEVEDP06dMnbJSu9cjIOtM+rx56582aMFkpsbuVzy/D0h7Y0Z4eo6GhgR9//JEjjzzSTrTTAdONObFobqqdnOzaK7TPdpKf3lSTNTEkjMxkYSwaR8zBafqYLitKUnQu5keNGmWr/AcabqeIfGbQ/dbVT9Rt2oTbVITF0eYjo0x3iBTbA+8gzd0CLv1bCPn5+RGWozlpDuM2pkVY29PUjc4lQXZq7IVHr0+TvlQNvuwiDsVnVIc6sQjD8kFFPp/PtpLviM5aM29JbWN0CSPTLSJfVKhB6ht9lE4RyC9P5watXbt2tG7d2tYzHEhkJmt9mmqeGRleT/o6i0KigEl9aeLriUnfQQyXGSHdfYCOMIwDffv2jfBp0irdGTlgaQ0FjfRoWmjqzW3BUEG/6pOX4aQwx549RhzK4PbRbsZ6g5b3c//www+2948MKUwKq1hPDJOFVJcIa4ChlwX2OkUgfpdW4ZWfkpLChAkTbD3DgUReuiP82SJ8eEb7ENnxtb9D1wxGyQiFXjCuNE9HkbTN/P0QxpQpUyLM1Hu1NTnwG8LrQF9nBvVm5ndFCwdESCajbe5ejcNKOStmmaLAMmF8/PHHVoOG0NSA1MpIiaFRqQ9qjYOjWRBGqwBNN01H27G6bcYNDQ2cfPLJtp/jQKF7XoDwwkiUcPIwbeCREkCkVac0T0e7HIsMn7YYEgv0bWtfpD5QmDRpEg0N4d7ARnZKjpQkwMAuCIP6JqxeG72xDYBCnVOTxogu9vQYxcXFEZJKDETt86aEETATtUxncezBp22YiAfJMY6ta/BqCCE0/SBiJAPCNjyZNeIjOoePIHv27GHIkCG2n+NAoXteks6CUEeaRmbdeocvYY5taaqvCF1RACGDpeC3Jm10aWvTQzKkQwucMNZC6N69O1VVTeej5GU4aZvlNCZcrUShrTswJe1GCwbADq1CNfBpl2Nvg53P52Px4sV2oiRLKbublilKxIl2cqmsjL2JS4sO2Q4ydDoJS4Sh7yBoXpCeNNBc0/4ONOJ2mU7aZDRVwY4dO+jVqxeDBw+29SwHAkXZTrrnuUwapP75dY1ZLxGEfZt8IjZV0URK+h2teq/agdtD27nVadRBjosvvpicnJwwndyAoiTjejLb9Cc19WFQ/40WTIzVDa3hCbfOsO/2MQ5Te1OLz2hvz5Z/OatWeUGMaOeOqOSUKM5RARqM5n2hUVL7QtBJFMGwus4BdNVYj65cuRKHw8H9999v61kOBI7rnYIII0t9Zzb4BKFt1BHf+satCW9mHAc683PNbw15OAQc0T2lpaokYbjjjjsA1QgviLHdUo3rKfiwpqQrDQmlMSgtR4GRhJGT5oh5GJIecUj/40zLFCXSYVZT9/v9tgljQEGgo2rqLTmGtFXVoBnRInxZ6l4WENlwiehYZw9omnWtXr2ayspKxo8fT1ZWVN3PAcfUvqnxd3w7H9M9JzI8jDZ9fV6aeKcPSrx/kERi4MCBdO3aNcxq2SHginGZMerKhExM9Dl7amIb9zmDhl6aj5AwsL09i8+NGzfaCk8U73rRCMOyb7lffvnFtnVjp2xnU6UGKiM/hvXb9kqfwUuSxi/LbHemJGw0vHx4WsiCtLGxkffee4+0tLS4rFb3F9Lcgoldk8PrAUz0B4FrsdzkxyIV/b2YS9mg7SDBOj+xX6o6FT1IMWPGDBwOR9hmw7HdUuiY69TUk6ZBxaqviHBq29wdY9+UQPUwHpmuZIgFj11a1NRE90FiANNDYA3HdCmlMLtnhHgUnlluEV6hQFFm9PnZtkpdJWvja82dtaNaGDQNNVD5qS7B5O7JfLhS1Yi/9dZbXHHFFRx99NGMHz++xU6ebw7+eFimapOib7hIwsyV9dBVR71PsrLYy4YyH+v3+KhpVPApsKdGIckJTocgJUnQs7WLHvkuehck0SnHFW5kG6xzffpBC9uQpa16P9MtuO7wTP79zf47cNkqbrrpJjp37gwQ5pP2qqB0EUTwuUBjBYvmQCxUAo1yOJR+W4IebbKcTWfvaONK6FdojzBsbnMHSJJSCiGEvgNFJQXLa2DxbGlXjbC0rQ3axVin31HpR1Gk5rDmwP4HJChROoogYI8vafTDj1s9HNHZrR4oIyX/mJDJjNXqVveffvqJdevW0bNnT2bMmEFRUVE8Fd5iEAKuHJUWPpKFlGOBb6G7F3rtgmqPwo+bPby7tJ63l9bit+n6cXQnN5eNymByz+CoGypAJIJl1N2+YkwGD39XZcm1wP5Cjx49ePjhhwHVW9W2bdsA6FmQxNnD0kFCo1/y00YPP2ys564pgS1WegUzWvII3NeeMBcwry+LQRid8wy6ZiBpK/tQtKivr8fv99s5J8eUF6LlbFnCWL58udWggFqX6UnaYUn95Mc4gNbjh/I6JUK8Czn9NZszhra2g9sBG8t8tH2glId/rGVliY9eeU5O7q0q4/x+P1dccQWgHqizYsWKZvmZTDSuHpVO5xyteEz4MwbF/yACU4F9dQovLqih/X27OP7lvbyxxD5ZAMzf2shl75fT6d5d/PGjfWwp9zW9C71uIwidWN2llYvbjjx4dERt2rRh2bJlCCGQUnLjjTeG7t14ZBZLtnm49eNyWv9lG+e+Wsodk7PDp10QIb2F6Xb0K0zA3trold+plc5ITJOHXRN7RVHsuj5MwmQUMOuhlqckUkrb3qgK0h04I/nC0tx2W4UvvFGazR21pELwW31xVwxL5+hubm79uor+T+8h6/4SijXHDPzwww+hpaiuXbsyffp0Ozv+EgaHwxF2eFKyS/DPo7LCn9XMh2RAMexXJB8ur6f9fbu54sN9quI4QXhqbg1d7t/NbTP3UeOR4XUeYeGoKZ8Ct0zIUvcGBdCqVau4jnJoLnJycliwYEHoPNJ77rmHHTt2hO5f/W4ZIx7azUOzK/H5JXP+1DZ8Dw80tS29I6cgeRvockqroksYnYIShvZ9osZNS7K/NL1w4UI7wU1FEbOcU6PcC4OU0rbCs1uuo6kSNCNltgXCWLXHHzmigcmSn+YFEn79ndNyGNVOfSken2TutvBtw2eddVZoa/Pxxx/PvHnzWsQDuBlcLhfnn39+GBlPP68VeakGu01NyLPaIznsmVJOf6uMuhjLeMlJgrQUB+mp6iczTf2kpTiIJck+8H01Xf+1i1Ul3vDyBKHtQFK9kJ0s+PrKpn075eXlnHnmmQk9XjIWioqK2LBhA506dQJg79693HvvvYZhk5yCjy8voEe+K7xN6X1/hBGETsoNdPryWj8l1TGmJK2cTW06iEB66XEIvDYJQwCGm6rMSKGT1ZSllLb9VnbLcYU3qkDltk6LTRir9+hWStRCNH1rNdkhVpc6QlHD/HxpPuM6Gtd+WVkZvXr1Cv0/fPhwtm7dGvchO3aQnp7O66+/zhtvvBG6NrlbMlN6JIc6nOFOSE19/FbspfU9u/llh/n+nuQkweM3tqH2+17Uz+lNzXe9qP5W/VR+o35qvutF4499mP/fzvSLYpa8p0ah38PF3P11JUFJTjuihn0C10Z3SOaOSU1Tk/fff58333yT5OSWtwgdMmQI27ZtIy9PXRCor6+nTZs2hvuhBDDrmgIm9wzYkARJQbfPw3B5Gf1vyfzNsX14tMsKriISUYcuISiIsUCgx4oVK2yFBwwPeTEjjM5WU41HwuiSo9k0pdEvpLsEhTEsAVdo3dIFxNuItCB8ibGpsOEjnZR8d2Eux3YzbqBbt25l8ODBoefLz89nx44d3Hnnnbae1w7+/ve/895773HxxRcT3AOQn+bgswtbGRCl/rfaaB+ZW8vgp0rxmBzyctrETPZ+1ZO6H3rzp7NakZbiQAhMPw4HjOqXym/vdKX6u148fkMb3CZWuXfPrmLyC3sipUDtcqTm2j8nZzM6QNpSSi655BK+++47rr322uZXpgGcTicffvghCxcuDEkz1dXVtG/f3vDwHyHgu+vaML5rgCyiSXXBZ9MSSJgeQw1nhTBSk7SKUhlRl4U2vYhv2bLFVnhM3PUlRMKwe8pSQZojvAEFa1LCsLbRVSe/haYkwejaBonmhQXDaEc6GfGSXQI+PjObP4403jazbNkyhg4dGlopSU5O5u6772bLli1ccMEFtp47Gi6++GK2bt1KRkYGp556amg6lJfmYNNNBSRpjXgizl6RoWq4aFoFt3xRaXgg1OGD09j2SXem/as9edlOHE4ntDkP+r0Lg7+BYT/B8F/Uz7B56rX+H0Lh5eBSJYGMVAd/OrsVJV/24IazW0XkISXM3uCh9yPFeP0yvM4N3oFTSOZc1Tq0ka6+vp4jjzySYcOGsWHDBs4999yE1K/D4eCBBx6gpKSEU089NUQW27Zto2fPnoauJdtlO1l7WyHjuyVHkp+2bekkJ7UitNe1pCFZttMiYWilRh3a2Nz5a3frBjYljI5WU/X7/bYJIz+1yU2eXucwrDA6YWyp9LO7Wol8SUY+KLW2/GhfcnhDTnYIHj86k3dOycbIOn358uV0796d7777LnStU6dOvP7662zdupXHH388bPpiFf379+e///0vu3fv5qGHHuKiiy7itttuo7FR1ad0ynay4pp8MpM09aWFptEqiuSKGRW8tjRyCTjJJXjjriK+/U9HOhQkQUpn6P1fGL4QOv8VMgZCciG4csGZoX5cOeq19D7Q8UYYOk8lj/yTAEFOhpPHbmjDLy93plNhpEJ47R4fI54qpa5R8w70HSDwjpIcgt9uasv4gH/XhoYGLr30Um666SaeeeYZdu7cyfPPP2/7GEUhBEcddRQffvghZWVl3HrrraEpCKjnzfTr14/i4uKIuKcMSGXFnwvpkZ9kvFkvQk+hlQQ0z2egY9sRwzt+tzwXLoeBcyTNp02mvU1oiqJgc9eqodBgKFdKKV8CLrWS6saNG+ne3XRzmyGmn5IVOfUIlGRduZ8/fBZ91eXVEzL5Q/+UpniSwFp3sEJMfFHqYXB9RamPyz6r5pddkXNZh8PBxRdfzH333UebNm3C7kkp2bRpE6tWrWL9+vUsXbqUnTt30tjYSGNjI9nZ2aFT4Hv37s2gQYMoLCzE7/dz99138+STT4aNAqPaJfHpubm0TndGPpeu3BK4ZmYlzy2MJIt2rV189nAHBvVIBmcKdLoVCs4E0QzlYu1q2HIP1CwFoHSfjwvu2sXXCyK3B4zq4Gb2pflNK2BG7yLw6vwSbppZyVPzakJPnJ+fzy233MKf//xnHA4HxcXFLFu2jE2bNrFhwwbWr19PQ0MDbrcbt9tNly5dGDhwIJ06daJ///6GOqdly5bx5z//mVmzZkXcS00SvHRmK84YmKba6aiNy7zcEE6C0dRwAQ7IuX1HVIfXF43M4MrDMqKm+eGyOh7+1rrxW3p6OlVVVTgcliWT94UQZ+kvmhHG28A5VlL99ttvmTTJ1j41ZpySpU5LDEpR3iA5flp08ekP/VN49fjMpriS8Jenfyqh/6FpBAbhGxXJS7/Wc/M3NTQY6HMzMjK48MILuemmm+jWrVvUspqhuLiY5557jmeffTZsV6QAbhydxr+OylSX74ygu/zgT7X8ZVYkyY7pl8JH97ejTSsXuAug7zOQoXOiJqXa8Ru2gbcEGktB8YAjRf24siCtF6T1Bbem80kFdj0PO58B6afBI7nx8WKe+6giohyn9E3hvXNakeQw6Xi653p3WT3XfVJBWV1Tp2rXrh1XXXUVl19+eQRZW8XcuXN56KGH+OyzzyL0bg4Bl4xI58Hjc8jVt02jNqW9Fyp7DONB4IeNHiY8XRK1nK+em0evgujL+D9uauDWTyqihtEiNTWV6upqO6tQnwkhIs5UNiOMj1FPPIuJt99+m/POO89qIQCYeWoWeSbWahI46aMq9tSZM3DffCcrL42cP0fAsmRhbMJbVq9w/7w6Xvy1nmoDf6NCCIYOHcopp5zCkUceSZcuXWjbtq1hltXV1axcuZKFCxfy6aefGo5u/Vq7eOyYTCZ3dZsXXnd52uoGzni/IiLYiF4pzH6kHVnpTkjKhSFvQ1pAj+UpgbIvoXK++qEB01FUi6TWkHME5E6C7NEqoeydAZvuBOnF55dc93AJz3+0LyLqX47I4F9HZ4VbS0exuyip8XPrF1W8tawuzMAsOM044YQTGDZsGH379iU3NzcivsfjYcuWLWzcuJEvv/yS6dOnGx7hmZokOHdwGrdOyKSn3mdmrPowvB9dur3ig3JenG++t8Mh4NtrCkhOEhqiihwNF29v5LoPrR/pkZKSQk1NjR3C+F4IMVF/0YwwZgFHWUn1xRdfDFlGWsVnp2bRKug1OaJC4L8rPLy0vMEoKqBWavE1rWid5tA9QVBqkOaNMcrMJSxMyEM2NCrwzx9r+Xh9I6v3+sLcbeiRkZFBv379yMrKQghBVVUVW7duZffu3aZxuuQ4uWZ4Kn8cmWYsVUSMcuqPX3Z5Gf9qecS2/wFd3Cx4qgOpyQ4QDhj6GuQMh4pFsOs92Pt5YC9EoL4cmncRfHZB9A7jSIbWp0LBOVC3Bjb+BZD4/ZIr/lXMyzMrIqK8eHIOlw3X2bLo359uCrC61Mtfv67ii3UeY/cGqEZfRUVFZGVl4fP5KCsrY9OmTaZzdpcDBhUmMaV3CtcdlklBhomYHmqbsulb7wkcIiUQU6lEMPCR3azYbb7U7XYJvru6gFgzh5XFXi57zzphJCcnU1tba4cwFgohRuovmmlOLFsoxbPPIqweZehPCJM7uXgpirW5IuGlFQ3cHtxTEZ5Y4KdZr9a8TWkia0oIbS6S4BZw7/h07j0infXlfh5dWMfcHT62V/mp1J21UVNTw4IFC8wLH0CyUzC4jYurh6VyXv8UVckVzFtfrOD/SvC6ZHeNn1Pe2xfRiQpbOfn1qQ44nUJVCnS5GJxZsPAcqFoaIIIgIQQVcjQRhNHHSPpQPFDyjvrJPRJyxkPF9zidgudvb8va7R5+WhZ+8PKVMyro0crJ+KA9h5a8Qw8a+A787NPaxfTzWlHtkTz6Uw3TVzawsdwXdoZNeXl51AO0XA7okO2iU66TSd2SuWREOkXaVQajphIqmwxvD0iDOCL8f5OmJ5Fsi6HwHN4+qckPhmF5VOg93sdCHMdIphtdNCMMy6754iIMKYncVdnE3rkWHIR8sr6R20emEVaLQjTtKzEVdzVae6HNVzaloQkWFk1Aj1wnzx6dGepAy0t9TFvr4ctNjZTVS6obJfU+idcv8UtwOQQuB6QlCbLdgi45Ti4fnMJpfXRH3wXLo2uX4fmr9dPgk5zwTiW7qsOnbVmpDtY80wGnRCULAZQvh00vNj1XkChCpIHmuu5jeF0rGQawL/w8GpdTMOfZznQ9dQNbNee/KhJOeruc5de2pmO2M2zgjtQ7iTDyzHQL/jExk39MVOt+9gYP323yMHdrI3vrFLx+8EuJyyFIcgqKMh0c2dXNiPZuJnZL0WxYNKpfg84UUqTrgmilC6m7KbTxAm1cI/H+sLGByhin+50/JD36oBHIyh3xQLFhkzQMhQYzwrDsDScewnAEK1GPwLVMF7RJE5TUmT/g4hIf9V5F9SSuix/4J/CtaeDaFxEWVCeZGDXeYAPQJT+wtYuBBS7+eXh69KmOYYPVtIqgBGEWPxBJkXDaBxUs0R3EnOSE7+5pqx6Qo2ieYW/gyMYgB4ckDGnwWxtG8+wOGX5de89k6uJwwMYPu1Fw3HrKNfsmKhskk18tZ9k1+eqpXkYEKQh/Bhm4KKXaeCQc1S2Zo4wM7rSdVmoS1558p59KGI3mYNxGjdpCEFoCCUoloSJI7viiMjKOBm6nYEjQE11YepHltbubJA4Jw7Bjm+Vreb1G71nZCmSsw3wl/GVEdCHHq8CTixuIWKeOSE/SZJMhm/4P/obIF6RPL7gjNua5rtIg/8AnwpO0DC9fRHyJ0TOdOb2SzzdGHpf32EV5DO3sBp9s+vgl+Al8AuX0m3zC4mh/K+HXg/8rgd/B63qHw4DTKVj+ZtcIq9B1ZT6GP78XaebyL2xfhq4+Is4AkSZxNR1EGy6sDWjjazq3xvo44h2E5WuQljZvXflWl0bfQpGRrCW5sMKH/xt+xRLiIAxDzawZYUSnQg3icWWnaN+w4YNIhrZ2GRpRafHGak/kyzPylK194eiuh22A08WHpgaCLq6Zt3IjQglGDIYLElBYGfUNUfM7QHYXfFLJ9DWRVoJXTMrg2skZuo4twztziAQIJwefnhBoiqPQ9L9P6ohEl3bonhJmidquwMXb90Q6b1tZ6mPIs3t170z37Nr6hnApMVTXUercyOLXrM617y4YV9s7Yx0lEPb+I9/jvK0eKuqjT0cmdUs2eB5NWTUN2Gdi9m+GOHYC2yIMyxJGdna23YKgGHaW8JftdsqmlRQTrC73s6nSH0kIGKRp+iIwbgARo5i+jLo00MfXp4Vu1DNq3NIwLSnh0s+qeWulJ2JkOXZgCk9f2CqiI0u/5L+zq7nn/X0Ul3kDUgFNnVkvfRhKHToJwk9TGsH4gXznLq3jX6+XsXy9J5x8fJLTxmdy24WRXt+WlfgY+vzeyLqLkL5kOHGbmPlHSAJh9ax/p7p7ZmeJ6MksOKiElVFXHoO2cM3HFRHPr4VDwBUj082fK9RO1fv1Fs410aKlCcOyg4v4CEPfaXWVrajTvxuGRN+1qEi4fFZt0wuHyAoOXosY1fWdX9tZDcjAzJV8MK7hdEWXhmn5dHlr0mr0S459v4KXlzdECGPjeyfzwTV5uIKNOPCMq7c30vaKHVz2XBl3vldBt+t28sXiunDJIjiliDZNUdCF0RCIJp2L/lXM4ddv544X9zLk0i0cc/P2pjiB7/suy+e603Ij3uGvu310f2qPeq5uqFPovrWdJdhZ9Z7iDd9NtPrWtz99WlE6bqg96MMatAFFXWpesyf6dKQw09lkDRtNYgo8U4MFr+NaCCHskoYhBxwQCUPqX5T2omb0ntjOFa7UNMAvxf7A/Myk02odzACGDSBENvoGo0kjlL5BXKlLO2y/gT6eLn2zDUsSimsVDn+rgq83R67bj+nm5qNrWpGRJMI6eUO9wvC/FYc5aKnzSO58v0IV7cymLEEJQj810UgRYVOQAOEsWFnP6183NRdFga8X1nHZv0vC8nBIePz6Aq6YGtleNpb76fLEHn7a3qhrB9r60tVTRH1p4umnJBGSokk7CL07XXhtu9TuQNW+T4P3F7z+wsLamCfXjwseqhV6Fh1006Z4CMMmDqIpifblg3GFo7pUH9o6uj64xiv554J6cwkjlLY0+GjiGEoQJuno04soe7T8IbzRRpZLSsmrvzXQ56V9/LI7cmQa3imJGVe3IjdZREgIb/9c27ThS4NlWxsNFJ9EKju1yk2tPkJPHoEpzuK1DUTmBq9+VUl9XbhE4pSS//yxgEumRLaZvXUK414p56avq6n36utJ13HN9FSGegbt+9LXebTfBulqZwFhbUgaDyZSdc504+fRVYJOB1wwODWcKKJNuYBqT4s7RN1jdNGsN5qbJeoQ95QEMGxpQQTu3To0BVeMNaQHFnvwG2jpQ+mYfjQNEZP4RunoTT21xBGWlkkDjJL2vJ0+jptWxcVf1FDhiQx8fL9kZl+fR+tUEdmB/fDaj8Yr4q3SHTppgXDpwodOugBTiSM0XZFqugbwK9DQ4G+KEyCdJAEv3FjAHecZm/Y/tqCOwc+X8cbyerw+TX3p6y/4/sKkCoN3GLU96Dqo9rfZwGKUtjSLJ/l1V2PMQ8a75rrUrRLaMmmfT5tJIN3ianuEEceUZIPRRbOuuMpqqvEQRpXRfNWETQtSBZ1i7P2v90keWtIQTgJh890oZGBGImZLqEYShZZIgs8UlocuvtYDmCKp9Eg+2dDICR9VMfadSr7aYmw6fPHIVD66NIdsN5G6h0AHNvOLevKQVHNdRYTkodNVhJGJErZycvTAVDJSTN6PgkFeqsPI+y7K44UbC3AaRF1X7ufCGVUMeGEvTy+qY2OZL7x+TdpK9IHAgASC7yqadCppSgOD+MHnNIjnV+DSj2MvOJ7eL0XXjszSbsp3dwyfoHrE4fpwvdFFM8Mtw8BGKCwstFsQtlQp9M4JnjxuECDMYAf+0MvNnb9Et/e4/ecGrh2Q3OQ7wsggJ2JuqDUzDH7r42guh5b1ZKTxTyg/YfhMEqj1Sqoa1c8+j2TZHj+fb27kq61eGqO8/wy34OETM7hiTJpqoRwMa2BQdccxGXy+MnzptSDTwV+Py1Q7LIQba4E6bIQZbemNuWTAgCsQQHOvVargnnNyuPGVcNPstGRBuitQVm1aGkOvy4/NYnTvFE6+azebDPZXrC3zc92Xqu6tb76T47snM6lLEvmpTrKSBVluQU6qg2QnTYlq35f2d4RRnAz/X2r+MWo7egTbgJasQnHVdFaWeFkVw/aidbqDE3ulGOenbZpaCNht4eQ0LRwOh10JwxZheFFfdUxaSkpKwul02nLTt7U6MDeOZTUXuDy5vYvnVzrYGcM1+3+We7h9aIrxiwx7ocFrsqlDaAOFvaSgMY0If4H6hhkKL0O/qxslv5T4eX6Fh6+3eqk00C1EgxAwqNDF3KtzSHc7CFk/hpR6QmfBCYd1SuKyMal8uMyDT5F0y3fx0ZW5dMh2qIShtcwMxpUBEgilI8OtOIMEohCeX+D7huOycAm4b3olFXUKBVlOZt3VVjVf1uZpQBoDOrpZ/3InzrqvmI9/rjW1L1i118+qvXU8ND/yXv/WTq4bkcbU7skUZjo0nV+Gv0fDQUTzLCGx37AIhL9w7f/69KQqXcyILV0c3S25qQka9WcTIimxOSVxuVx2CEMCZUY3DFMInHxWD8T0xurz+UhPTw95ibKCKR1d/H2oBUevmgf8aLOXB5fGdm227YJMOmTod7HSZCoc3KMQRahQw5tck0ZhwhujBGZu8XL2F7XUxdCOm2VdmOnguakZnNjXTdj+jWAHDvsfgw6uSSxi34gwjmt2T593WFq6a9o9Dg6TfEEj1TSFKd7n59i/7+K3LY1xnZkCcOuYNO45Ir1p12/UPqJpBGbv2yxaEBJNO21qUN9taeTI16PvJnU54NNzc8lJdjTVhb5RmrTTCa+UxVx50aJv376sXLnSanAf4DY6+SyacsCSyCCEsD0/2latkOLQlCUo5uuhmXOe0tlFJ7NtyBqc/02d8TxUu8QWmpNq8giWA4O42rkluv8lYeUEydlf1DD10xrbZOEQUJAumHF2JjtvzuXEHkkBHYLBcqiR/YShOTe6eyZx9fe0VqGKSZzg/F8b16f7HbYKo38Owv5vm+1k6VMd2PxyJ8b0STHUb8TCgz/XMeil8oBxoDR4V9pPUAKRUZbkTdpBmO4j2KbU34qUXPJJbOliUhe3ShaBIjSNOJrMIpS5knqvYossALuOnkznUdEcA1o6OyAewlhbqVCYJthcLXWiveYfPWlLOL9HEvf9Gl3KmLPLz+ztXo7qEHw0HTWHSQla0tKQhoCmreSaNKKJtIHGc8tP9XywwdzfgRE6ZTu4aWQyFw1KJsMtVF8IPmkuyuvE+jCdQ3B6F9IbyKaRPfhMwWfQp+MQTdMeQbhEZhhehksgfpokhwgpRFdO/Zb6YDgHdMhzMu/BIhq8sHCDh3+9v48vF9cZjilGWFPmZ+Sr5Sy6KLfpvYZtRgtkFqwLTRsLlUPbRrTXwyBCQbTPMG1lA1tiHLYMcHHYUqqung03IqoBam1ObUE9kMsG7BGGEEJKKVuMMLwKZLgEKQ5Jgx+dmC/DXyIQ3Gk4pYOTdzY62FQVXV49c3Y9W8/NCD+wWNs41ILrMgmGCVwLeycxXlCgk9b7JU8sizTfBmiXIZjUwUX/fCe98xx0z3WSmQQ5aYJ0t6NJqg2OhGE6BU1H0yssI/6XBg5xCFdsmnXWoF5J38GD8dGWg9B7CUtL13n0OpZIEtFd15QtxSk4vHcyh/+jLT4F9tUq1NQrVDdI1u7ysmJ9A1/MrmRxuYyo8yUlPmZuaOSEbm7Ne9VCGr/WkIsEzfNoojSFo2nU14Qrq5Nc8VlsM6bT+iTTKVuj+BeRaan3NJUa+BkPYYwaNcpOcK/RdASiSxjbgZh+8IQQ5Ofn23Zjvq9BUpgakDKAUKXoX5AI/lDb3vV9k7hxfnQpY59H8qd5Dbw8XrPj1ehl629INCOqJFwZqyOXMKhpXPRNXcQBw32zBA8MS+LIHm7StF7GggwRIU3oOm0oPJGdy0zqMHKIEyx+kCiF2f/aPGSTHkLR5R08WtyIYLTxg4dkO6IQnZ6cDEjSJaB1hoPWgSX2zM21dK6pZ8rQJCoaJc9s8PPprqbKlxKu+LKandfmBZLVSa/616mVKPWSiNG710sDgdt/+ro6wqmSHg4BF/RPiWzr2u9g2tobgZ+1cRhtjRkzxk7wUrMb0QjjB2CQldQHDhzIxo0b7RSI8gbJgFYOiutUhzMqdOJjaBQj9EJGFzg5up2Tr3dGF/leWetlUpGL87q7iPqytdASiXaUD4toTBpehYipSE4SPDokiWwnrNjcSFqyICfdQZtcJ+7gcbfaJI1GYyGgoCeMvxZSsqGmFKp2QdVuqN8HnqqmT0MVeGt0nZbw3xFLqLq80HRqh9CI9ISTWZBcQxKIA1wpkJQK7gxwZ0JS4Ds5I/A7C1JyILmV+tuVCnuXwIa3oLEsJlF6GxS2L6iifFM9Ps3Ozxy34C99XJQ0+PilvOl6eb2C4pfqrucQcWolC91wLgWq7wX9QEF4uIjbaj19uNbD2ytju3u4dFAKbUJn8+ihSdykuWnPAbYCl8sVOg7SIkxdxkUjjO+AP1pJffLkyXz00Ud2CsS2aoWBuQ6KUgUbq3UVF6aE1P5WcXUfNz8U1+OJMU28fl4Do1un0S3LEd42QiNJ6AfBl67eFxF5NgUzeMlC4PFHisVTihxkJzU9Um2DpLbBz84yPxmpguw0B9lpDjLTA1MSI8kAYPcaeO966DAEOo+GPkdDp5HgNvCiJhXw1YPfB4o38B34rfjU/2Ww4rRztMDvEBE4VRIQDvW3cIAj+J0EzqTwb4eFw6qlAhUboHQBbPoUyn6Ful0m0on63VivUL65gbLN9VQXN5rODp0Cjm7rCCMMn6LubXEGT2qQuk5vNE0Jfmt1N9o42moTTfGqGiU3zKqJqWdJdsIpvZLDswvLQ4a30zCJQ+AQsK3Sng1GWlqaXRuMn81uxJIwLOGYY46xUxgAfir1c0IHJ/lu2O2EuqAuw0QC1KJtClzfJ4mHf4uuXNznkZz/fT3fH59OsnZkDb0EbQPSjjQ6udBowNFCStXtoD7/KCvNNfWSmnqVPBxCPVEsK02QnuIgLUWQ7BaRxLH1V9j2K/z4rNp5C7pD0SBo0wtadVI/uZ0gozUk2WogiYPig/o9UFsK1dvUT9UWqFgP+1aDr5ZQnYb0IoTIwlOnUFvmpabMS+WuRmr3Wlcgl+nm9qrAEpxayqaBAEw6q/aeLoAQ4bZDwQEmQCyXfFbFDgu2EbeNSVP3AEmTRq69rJ+eKJLcNEfEweGxEMch4vYJQwixT0pZhwWHwF27dsXtdtuyxfipxB96h+1SBeurtFMBousZBZzY0cUn23ysq4oWEOaXKlz0Qz3vTEjRxNe87GCepnnJGPfVNFIcglQX1GtUxV/tVjiuUGFEq+jrg4qEqjqFqjoIrmY7HZCeIshIdZCWKkhOcpCUJHAnBVZRFD/sWgu71+r0AKhkkl0IOe0huwjS8yAtF9JaQUoWJKWAKxmcbnC5VelAiIA0IQL1o6h5SJ/6rXjB7wFfg/pprIGGMqgPfBrKoGanShRIzWpJoI5D0y1VklAUSWO9QmO9QkOtQlVpI1UljTRGOV4iGtZVK7yxJXzkdTtEQNUSbFuSyAFJSwAYd1ZtGnopRJE8sbiBD9fGbvv9850c1ckdoZuLgF7yDUifDge0ThWs3GtfwrABH2B6cnOs89ZqsOhBPCMjI6rnZj1+KVPwK6oomecW7HJJaoOdLZrOKXDPLeDfw5M56/sGYvkSeXeTj57Zjdw9JLiFWKdtCntvIuzLlCyC5Qqk5RSCfw1P5gaNQlYB/rTExx+6ODiu0En7VBHpjNYEfgWq6iRVdZGNw+2C1IAkkpriwJ0kcDoFTieBb4nTtwNRviOcSLS6iTA9gV53oJNuzAzBwMAASyABv0f1A+H3S/w+ic8nqa9RqKvwUbPPR4NN02bDOpKws17yTYnCy5v86E0TjmjvCulmIwahCClTRoYJQkCTQ19tGpKFxT5u+yG2C1yHgH9PyGjaSGk23Qm7Gcgw8G9+ioM9MaydjdCnTx87wauEEKaZWCGMAiu52CUMjx921Sl0SFeZvVO6YFWFwdsKvuwwLbb6VZgiuHeIm78sjs3u9y5tZGiug5M6aR9ZGvyM1JkYeiCPmGdKruvn5u5fG9mn0ZJL4NXNCq9uVkhzwug8B8NbCfpkqfqNrCRBmivqDCwCjT5orFGorIFo9nUupyApCVwuQVKSUL+DvwOSisMhEE6hqicE6lxXQx4y8PzaHeB+ReLzSrze4LeCr1ElhcYGhcaGGBN5m5BAjRcqfZJ9HphX5mdtFSzep9Bo0rTTkwTTT8wgzM4h2PlCehpNBsFvoxdhNEUB9tYrTH6/0vS8FC1uG5VGXoqBXiRYNL2uVVswofJyh0wnc3fYs/EBOO644+wEr4x2MxZhbMTk2Hc9CgoK2LZtm9VCqYlXKXRIU93NZzkhPxn2emTki9NLgxqx4/A2TkblO1iwNzrzKhLO+L6BeVNSGZ4ftK4T0XuqhgyiQu1VOIEFU1MZOL1OtS/Roc4P35YqfFsK2o6ekwSj8wRj8h30z3aQ7hKkOMHCaQtR4fNLfH4L5T9IIFEHknq/pNoHi8sVfi5TWFQuqbchkLgc8NrR6aRqncLqDfPCVkvQkIcIv2aigKz3SXq8VBFzCRVUD/jHd3XHJgtT6QbaZTpIcsCKGJ67jHDsscfaCb4l2s1YhPEhMNlKLhMmTGDRokUWy6Ri4V6FCW2ajL46pgn2akcno5cVNveTCCl4aJibo2Y1mI42QXgVGP1ZPStPTqVXlsNEP6HJzEgMNUOgQfbIdLDqtHQGf1RLlcXBoMILXxZLviwOOqFQkeqE4a0EI1o5GNnKQWFgSuMAy1Obgw2ScEvzDTWSX8oUfilXWFEpo54qZwUpLvjypEzGt3dpSEEzrzV7n0Z6Bf0UJiBpevySNs/uMzw+M7I8guknZ+HQHIwVPhjG1qO5ndAuXV2Gnbkh9n4qLdLT0+2ahX8Z7WbUZielzMfE844e8+fPt2scwvgCB98flRxWihIPbNZrm0XoTyQCDcCjwNGzY5MGqJ1t6YkpDMg1sVCNICiDADq9lB6NCty+2MNjv3kTNr47hKrzcQpIc8LgXAcjWjkYngvt0hy2pjX7C15Fsr5GsrhcsrBcYXWVxKvZUpJI2eeagck8enhaYLu7BrEqJtaSo+Z2g0/S45VKdliwhRDAC0dn0D/PGZ6OEWmFtbkgiah6ld6tXOSkCLx+SepjZSEvBVbQuXNnNm/ebD0CDBRCmCo9Y7YxKeUeIN9CODIyMmwdbOQUUHNmKimaF6xIdW7q14pp2lIanVIWwLoqhUt+brRUoS4HfDEphaPaane2ahSeUQkDDYkZiEEagqv2StZXSV7f4OX9zT5217fM9MAhwO0IfgRuB+S6oShFUJgqKEyBwlRB62RBhgsyXJDqEhGP1+BXK9wVIKZgFfuk6g6xxgc1PvW7rFGyux52N0h21UlKPSpRNioy8I0lAm8Obh2azHm93HTJcpDpNpjDaduQti1ZecehNALvslEy5K1KNlZae6ize7n505AUTLchGEEXLDdF0CvXCQJ+LfUx9PWoKoYIjBo1ivnzDXwCGKMOyDAzC4fYUxKAXVggDCEE7dq1Y/16y7538Ev4rUJheKumGnIg6JPp4LcKzUvRaaYjbgQquWem4C99Xdy/MvY8z6fAsbMb+PeQJG7pFzQ6MhAbQyKt7oaEcCMuXR0HRodMFwxtJRg60s1jI91srpF0mxZOqg6HA0VpXs9SJDT4CehO1LLsqoeVldEJKkgMkqaNqXpYnZW1FPLz8+nRowdlZWWsW7cu7N7fhqeoe4aCGlk9wi4FlY6SiFPsog0MUrKjWuHwadVsibGPKYjDCl38cUhKU376woSmOHqdnQgjso7BHdoSlpXaX1maNGmSneA7opEFWCOMdcBAK7l16dLFFmEALN+nMDxsaiBJd0J2ElRGeEbWdNzgJiGdpvvE9k421kje2xq7cv0S/rzEy5oqyfOj3E0mxCFNelOZtOVTiyJ0jUHX4kw6XtuUyOuDBg3i7LPPpqKigoqKCnbt2sXWrVvZsWMHe/fujfkczUFw93k07A+yEEJQVFRE+/bt6dSpE23atCE7O5ucnBySk1XLyM8++yyCMDw+yNTxfWTi6N6V5ncYG+reYeDez7t9nPZ5LbstLmn2buXk/rGpAWO+KCsjUkcguodon+Ek1dkU7vtt9ldITjvtNDvBY3ZeK4TxFXC6ldyOP/54vv76aytBQ5i5y88lXYK2u+oLE6jSwqJyGb4qFsbQGmmgKQBI+FMvFz4FPtxujZH/u8HHlhqFN8e6aZtq41TvMBiMHgbWfKkOQY5bUKFRmO3evZu0tDTS0tIoKiqib9++oXter5d9+/aFPqWlpezevZvdu3dTXl5OHEfgHTC4XC5at25NYWEhhYWF5Ofnk5ubS25uLjk5OTgc0ZeFjAyQGiMUIULXGS1qdgzfKTz3WyM3/1hv2bdJlywHjxyeqtGjmDSiGMklOaEwvalN+yXM3GTPwjMnJ4chQ4bYifJprABWCGMG8BwW3PWdfPLJ/OlPf7KQZBO+2q1Q65Wq/0dkaP7vRNIrU7C2SoaTr+n7b3oDQsLNvZ1IKZm+w9qo8E2xwtDPPbwwKokTipzG+YTIwuCF66epesvAgPgpEHTPFCwqa0qgsrLS1EWA0+kMdTAtpJR4vV7KysooKyujoqKCyspK9u3bR2VlJZWVldTU1FBbW4vXa39ksgOHw0FaWhrp6emkp6eTlZVFTk5OSELIyckJEUPQt6SUMvRtFenpkXtnVMLQ6gakRvLUKA+1iGUijqp7unZOPW+ssd5JC9MFDx+eSiu3MLarCLURaXQxLGjvXKfa4QJBFxX7KLNp39KjRw87e0gU4ONYgWIShhBij5RyE9AjVtiOHTvSpk0bSkpKLJUQVNuEOXsUjmurHV3UislxQZYrMDUxrCsR9hWKGhhkbunjQuLjI4uksbtectIPjdzc28W9g5II6dAipin6Bkj05TFBk2MaJO3TBIs0HhPr6+sRQsQcYYOdLPjb6XTSrl072rVrFzWex+Ohurqa6upq6uvr8Xg8NDY20tjYiMfjwev1hvIP+mYVQpCamhrSr7hcLpKTk3G73bjdbpKTk0lOTiYzM5P09PSwhqktZ7RnsQJtWkbn+NZp24agqaMqYLhRUE1VE0EniQj4fqePi76pZat+U2QUFKU7eOLwFIpSRUh/FRpcghJPcJk+jEw0A0vgWps0hzqAaqSkWVvtk37//v3tBN8hhIjZca1IGAC/YoEwQPUdaIcwILDnoo1WfQ3B3tk7U7B4n1Tn2RHvT6ukFOjFUAH8ubcLgc+ypKFIeGi1j4+2+3njMDej8x2adxpFxNFuAzdEk1TSIS0ykM/nIzU1+on1ajbhpGFllA5Od9q0aRMzfSvQlyER6VhJq6Ag0ui4yiOjTk+1/4YIP9Rhw3Ua5R7J3xZ4eG6Vx7J3L1Ali2fGp9JG+161YnEw3widReRI53JA5wxHeNGEZHYc+oupU6faCb7GSiCrhPEZcKaVgMceeyzfffedxWRVfF2iEJrx6FZBBNA1TbC+RppNM0Nhm35qpifAn3s56ZgmeHK937Jh0IYayZivPVzYxclDg10UJGvnxgarJgbFCLumGe3aGRCG3++P5+yIpiyaqctIhC7EiEjsTjuiwYhQQ2fchJdENz0MfIckQRnWYRsUycebvJw7u962grdTpoMXJqSSZXIejLZIYd+R/yCkZECeCxEaCNU0Kz0K8wxOwIuGtLQ0jj/+eDtRZlkJZJUwPsbisQPnnXcet99+u61lwtXVkg3Vku4ZxpXeKglyk6C8EbMpX3QlkoCz2jvokSG4canPlm3A65v9vL7Zz9ujkzipvZO0oKioFSkjyiN0ugyd4tOgFh0OhylhWBHxg+ESDW3HNypTovLUpmOWbnC1RIs99YpukImiUAyOOIE25FEkc3b7OH1WvUo8NtE7x8ELE9JICvnbIPrybAzkB89YCZNo4Z213pgbLPUYNWoUSUkWfJQEcgLetRLQEmEIIaqklMuAobHCtmvXjj59+thxaQ7A61sV/tnHQbiRS5NComeGYGlFwAdo2FJYeFDDVc7AtaE5ghljXZz0kz3SADh3vheH8PL6KBdndnCRFNylqc83mGFY4wkq5tRARrTgcDhwucJfh7ZTJrJz6tPX/v/bb7+xY8cOhg8fTnZ2Nk6nM6ZuxaysVstsNsURQuD3+/H5fKxfv54lS5ZExL3v10ZW71M4o6uLXtlOkh1SbUIRU9TglFHQ6JN8vMXHJT80UBvnMRAnd3Hx58EpTY6PdNkY/m9EKIEwKU7oliUi95UImL7R3uoIwPjx4+0EXyWE2GEloFUJA1SnGjEJA2DcuHG2CeOT3Qr/7O0gUnZrEjn7ZMDSSonUue2LOJpQG10bDshJEnwzPok//OJlU+xdyWFQJJw/38elv/h4cqiLK7o6DXUnEnW/QbJTaBTy2mlSZCN1Op3NmpKAuYQRq+MG73355Ze89tprALz55pshqadbt24ceeSRjB07NoI8jKQfK9JCLCiKwvvvv88XX3yB3+83lVhXVyjct7SR+5Y24hKQnyp4ckwyZ3TRjq5q/hWNkqt/qufDzT7bI3YQTgFPjU1hSL6TMCfAWqMwtP8TTgAGHgAdAga0ckZIFkFy+2GX/Q1nJ598sp3gc6wGtLzmIqU8GtUmIyY+//xzu/MnBLDiSBf9skQkE2tG8j0eycZoHV3r9t5I2ghAAjN2Kzy0xm/IN1bQL0vw5qgkHlvnY1aJpN4v8SjqvpagriTJoY4emS7BxALBP/sn8XWJn6sXhTeCzz77jNTUVCoqKmxN5xI5JXjhhReYPXu2aZjgyklqaioDBw7k8MMPp2/fvpYkkGj5akmlsbGRBx98kDVr1jRrOTgjSTAw18FbE1P4ZY+fmxd42F0nbe3D0KNThuC5w1PJSbbcbZoQIhWpk6KhZ46gldH5tAKeWdHItT/W28qqQ4cObN261c6S6olCiJlWAtohDBewEwv+MRobG2nVqhW1tfaG8Es6Cv47xGiUDVRwoAK21EmK9b5WYz2JdkNPMLwQbK2T3LjMz+4E+3Awg0OoS8UVur4wZ84c8vLykFLi9/vxer3U1NRQVVUVdgyllJL6+nrbbtfMpgjaazU1Nfztb3+z5aYgKSmJ7Oxs8vLyGDx4MGPGjKFjx45xEdkrr7zCrFmz8Hjs7ciMhYgZYxzxr+qTxDndkkhyalLTSheaLzsJt0kVdMnS+I/UDXSHf1zD3N32TMKvv/56nnzySavB64FcIYSlSrf1iFLK54ErrIQ966yzeP/99+0kT+c02HyUySxJU1JFwspqqPXrZT6Dx4khaQDU+uHdHQovb1Hiljaai8WLF5ORkRH6X6ts9Hq9eL1eduzYwXnnnUdVVRU5OTm0bduW7t27M3LkSAYMGIDT6Wy2vkNRFMrLyykpKWHDhg0sXryY3377zdbZuenp6RQUFFBUVMSQIUMYNmwYubm5puEbGhr4+9//bntbwf7AwFYObh/kVpc6wbgNRWl+YZF09zOTBH1zNWfS6NIo80C7N6piOrvW45tvvuHII4+0GvwDIYSlFVCwTxhTUJdYY2L69Ol27dgBmDvWydjQaSi64mn+bVBgeZXOf4J+pQKISSSaW5vrJE9sUFiwb/9IG1qsW7cuTIdh1PGfffZZHnnkEcP4SUlJdOzYkc6dOzNgwAAGDx5Mfn5+QlZXfD4fO3bsYNu2baxZs4YVK1awdetWW1On1q1bc8EFFzBx4sSQEVhKSgrl5eWce+65VFXFPvxnfyIvGa7v62ZSkROXVolqVp9WepJo+uFywIBWjoCTJGEY/7qfGnh6pT2FZ5s2bdi+fbudFZKzhRDvWQ1slzBSgRIgM1bYuro6CgsLbTeEo1sLvhqlm8+JiB8AVPslK6siLluSKkwyQJEwe4/CfzYp7LGvnI4br732GhMmTADMO/D27ds55phjLLsQKCgooFevXvTu3Zu+ffvSvXv3mA1Jv4xqVpba2lo2bNjA+vXrWbt2LWvXrmXPnuiuU7Kzs1m0aFFI57F9+3amTp1qqY0IAX3bJzOgcwqdC9y4HFDXqLCl1Mv8tfXsKk+M+XuaE87r5uLsri7SXDa6hxGRRGmHfXIcZAdtNyLCqRc6vlPD9hp7g9fNN9/Mww8/bDV4A9BWCFFpNYJt7Y2U8kXgMithr7nmGp599llb6ac7oWSyM7C3xAQaAilvlKzTq0rMniomkTRdrPNL/rBEYUec/iuCx5RaRXZ2Nt9//z2tW7eOGq64uJjZs2ezaNEiVq5cyfr16/H5rGnRk5OTGTRoECNGjKB///707t2b/Px8FEVBURSklKFvI6IQQoRMyLUfl8uF0+lk7969LFq0iIULF7JmzRrWrFkTRgaDBw9mxowZAFRUVHDCCSewffv2qGXuXujmwok5XDwpl/Z5xmQngcUb6nl59j5m/FLFrnL7qwouAed2c3FxdxcpThHHoKODySAH0DVLUJDqiDqNmV/q57BP6mzrXn744QeOOOIIq8HfEkKcbyf9eAjjWOALK2G/++47O3OpEK7vDE/2C9/BaojArZ0Nku16RXLE9MRAnDRJvtoH969X+H6vtdfVOsvJoE4pHDsog1Hdkume76ZNhoOGRoW1Oz3MXlnHp8tqmb/Zo26WMsF1113H3/72N0t5BlFbW8vcuXP59ttvWblyJZs2bbLljLljx45MmjSJcePG0a1bNzp37hwykEqE9ejq1av5/vvv2bdvH5dffjmtW7dGURSuueYaPv3UfHNkqwwnt53WmptPysfOIoxPkXz0cxVPfVbGT6vrLJO2AE7r5OTKXklkuDQjf7QIQcRoplq0S3eojq9D6RgrQIZ9XMuSMnsatfz8fHbu3Inb7bYaxfLqSBDxEEY66rTE4NitcDQ2NtKmTRsqKips5dEqCcomR2klBl631tdKymJJpfpRI0zLrf6zzyu5YpnCjhgn3gkB3du6ueH4Vlx9dB4oEuEHFAXpVwL/S6RfQSgSqSjsLPNz/ut7+GGjsULa7Xazdu1aMjPDZ3x2jaA2bNjAJ598wnfffcfOnTspLi62LIUkJSUxfvx4TjzxRAYNGkTbtm3Jzc1NyN6RYPzZs2dz/vnmA1vfDsl8cWdnOra2PA83RHGFl2ue283sZTVU11vrfMlOeHJkMgNyHIY2hIA9stDca5UMPbKcZhwRQrVXkv9WrW3jwoceeohbbrnFavBGoI0QosJOHvEIW0gp7wEsDYV33nkn99xzj+08PhkqOLGNrngxKvq3GqjxWQtrhGo/XLpMiZRWdMjLdPLCNe04dWSmSgh+oZ7JpwB+BalI8CsIvwRFIgPfwq+GufKDcl5YYLzk/OKLL3LGGWdE3ZhldxWkoaGBzz//nHfffZdVq1axb98+W64UO3TowFlnncWpp55Kfn4+2dnZEVapVuH1ehk5cqTp0u2Ajsn8/GA30o3sEuKEIiVXPrOL93+qpMriQUk39E7itM4BhScQoUS3peRUnRMPCpJQtPgCTvmmno8tOIDSY/369XTv3t1q8GeEENfazSNewugDrLISds2aNXYPUgHUYwcqjrbv2HZJFTRKjI2/wHRe6vHDH5YpbI1CFg4B543P4eXr2uESEvwCqWgIw6eEXGIHpQz8AY+3CgFJA2rq/GTftctwfnrRRRfxn//8Ry2qgZm1lU1qRhKJ/v8NGzbw0ksv8e6771JfX09DQ4NlEhJCMGXKFC677DJGjBgR2vYeqzwA06ZN49JLLzUMl5Ys2PVCT7LTAwe1BFcn4mqlRuWAK57ZyWvfVeC1YBI+tJWDx0a4MXIVqsKERHRtzClgeL7DdIGlKbDE44fMt2ptW6Iedthh/PTTT3aiDBFCLLWXSzNehZRyDdDLSthx48bZfRgEsG2ioH2K9SLW+mFFtYWEDXDRcoW1NdGjzv5nFyYNSA9JESGi8BMgDhn6PzQ18SsIBVX6CBAGPoWT3yznkzWR855hw4aF6krf4U855RRmzZpFx44dueqqq7jooosipi9aWCEOILRfY9q0aTz77LOGezbMIIQI+eW44ooruOiii8jJyTEtz9SpU/n2228N7298vCtd27hVknDQpHMKntSWIPKoaVA46b6tfLsitmFh+zTBm2PdJAfPOLGlDFUDDM8XuPRsYRL33795ud3CwVx6zJ07l7Fjx1oNXgIUxvLfaYTmEIZlU/EFCxYwevRo23kUuGH3kQ7LZ3AsqQxIFzZx93qFL6O4znS7BGue7kmX1i51CiIdAcIgIEEEpQmJlCpxSEVB+AhIHASkDBkikpmrPUx9Z19EXm3atGHHjh0R05GSkhI6dOgQ1tkdDgfp6enk5uZy0kkncfnllxtKc3b1Dh6Ph5qaGjZu3Mhrr73G22+/bdlqVwhBWloamZmZTJ48mSeeeCLkKau0tJROnToZ2m8cMyCNL25pjwiRA4QOYQkRhVCHa2g2eSgS5q+t5ag7t1Afo9G0ThG8NsZNblCIsm5yDUI9F3tYnkZMCdl0hAes9kpy362Ly3y9uro6zPAvBk4XQnxoP5fmEUYOENniDeDxeMjNzaW+3p5NPMCKcYL+mbGLuacRNlqflofw3m7Jk1vND9BJcQu2v9Sb/EynRmIQISKQfgXhkyAV8AmQClJRwOdvkiz8EukHoQT0G4rCrgqF9o9H2i04nc6QBywtPB4PmZmZMfdXZGVl0aZNG4YNG8Z5553H0UcfbceIJwxBCUVRFPbu3UtpaSmzZs3i3XffZdGiRZaIqEOHDmzYsAGXy8UHH3zA2WefHRFGCNj1cGfa5rqaiMAhNL9p+i1EuASinbrEgao6hdvfKOaZL6KvLBWkCN46LMoKSpgH8Miy9MsRZCaZlDEQ9bHVXm5aZN+e5IEHHuDWW2+1E6W1ECIu79LNEvCklP8FLrES9rXXXuOiiy6ynUe3VFgz3kE0GxoFWFRhvGk1GjbUSS5fIWkwiZib7mTdsz3Jz3CoZCFF4AQeVI/Qfon0+0OrIzOW1vD2L7Ug1fMk+rdNYkLnZPq1diKCx30pIH0KNQ0KWQ8bGzqZdcQff/yR559/nk8++YTq6lhzLxUpKSl07tyZXr16ccIJJzB16lRDz1V2UVVVxZYtW1i1ahUzZ87k888/Z98+4/Gjvr6elJQU/vjHP/LUU09F3E92CWqe7ILLpSULdMSgvxe8r5uuxHEknKLAxwsqOe2B6DYhndMFb4xJwmWUR4ypitMhGNYqcJq8AaGUNUqKptXHdY5LeXl5VNN7HaYJIc6wn4uK5hJGIeq5JTFRWVlpOreNhZ9GCw7LNS/q9gbYGWMZ1AinLVHYZbLlplWmkxWP96ColUvVWfgVUFSdhfATmJIEdRYBJadf8u3aOq54dx+bypqWMdtmOJjY1c11w9MY0y4J/ArFVX6K/hM5qjmdzphLoH6/n/Xr1/Pbb7/xww8/8NVXX1neh+FwOELm42PHjuWYY45hwIABdnY2mpZp8+bNrFy5kp9//plZs2ZRXFzMs88+G3IVd8opp/Dxxx9HxB1Q5Gb5X9tFShKm/+slDwOiiUPnsXqHh3G3baI8ysny/bIFL41MwnQZLkp+XTIFbUx0co+s9nHLEvvSxemnn84HH3xgJ0onIYS9Q5A1aC5hCGAhMMxK+PPOO4+3337bdj79MuDXcQ6MJDq/hIWVtpPk2W2S13caj+QpSYKv7urCEX1SA1KBCCyf0rRsGiCOIGEQWDJFSryNcM/XFfz7u6owbbdDwJGd3fzriDSq6mHS+xUReRcUFNj2iQqwa9cuFixYwPz585kzZw4LFy60vGEsPz+fkSNHMnr0aA4//HBGjRplyb+oXUyaNMlQ4XnxqHRePie/6dBYDTlsKvPxwZJavl9bz8Teqdw6JbdJinBoiUKn+9D/b3EptKTCx+G3b2L9bnPF46ntHfy5j5Vl5XCxQwR0GXppubhB0nlGg+1NZk6nk9LSUlq1ahU7sIp1QB8hRNx7LJutc5ZSdgQ2o77iqKirqyM7O9uyEZEWHw8VnKS3yyA+3UWFF6YuUUyXru4/vw1/OSUfhyJBqvoHAkrM0HKp1BhmBSQNqQh16uFXbS8+XVnHpR9Vsle39u90wPA2LhYY+GkcMGAAy5cvt/dABmhoaGDOnDl8//33LFy4kCVLlli2AE1OTmbUqFGMHz+e0aNHM3ToUNq2bdvsMo0ePZoFCxZEXL9jUhb3TckJkxh+2e7h/q8r+XSFah5969HZ/PvUfHNJwkwa0StRLUgdNQ0KY/6ykd+2GoufDgH/GepiSKumU8mAGOmq5NE106H6h9VcvnmJl0fX2O8T/fr1Y8WKFValQwn0F0JYMocwQyIIQ6ASRicr4adOnRrVJNgMbZJh3REOsjTErkhYXIUtrbIi4ayl5pacU0dkMeP2DoFVDdG0TBogChlaJtVIFn5UrXdwqqJI8PlBgYXbGzn+7X3ssWgwdMoppzB9+nTrD2QRUkp+/fVXPvvsM3766SdWr15t2e+FEIJevXpx/PHHM378ePr06UOXLl1sewibOHEi33//fcT1PwxL49UzW4FDUOmR3PFlJc/OrQ71w6vHZfLM2fmRugojnYaePIx0HFpSMZE8yqv9jLhlI5tKjCUNBzBrQlJgg5qh+XATNP+6BAzNbVr5+61SMuAL+/4/XC4Xa9eupWvXrlajxL2UqkWzCQNASnkE8L2V9BobG8nOzqahwb7S4d4egr92b8qiwgtrbLrZW1MDF68w7rw56U7WPt2DgnQR6PgiRAghyUIJEEbIICtodxGURAKE4VdCksa8bY1MervCksj517/+lXvvvdfeQ8WJ0tJS3n//fWbMmMHmzZvZvn07jY3WbABycnI4+eSTOfnkk+nduzcdOnSI6dTn9NNP58MPI1fzhhQmseT6ArZU+hn//B62VTRV1FE9U5h1dYGxDsNotUQ3pQEMyMWEVHTksaWkkWG3bKS82vjFHdvWwZ19neYLNGFb4puIpGeWoFWS6qjxpB8b+XSX/RnC4MGD+fXXX60Gl8AZ8S6lapEQ+1shxBxUb1wx4Xa7mThxYlz5/GODZKtm92g0q0wj+CTcsNr85dx7bmsK0h1IvwhIFQSkDBmaauCXSJ+imnv7Ab8A6dBMR4IEQ8C6E8YWJvHQBGtr5DaPtmsWCgoKuO6665g1axYbNmygtraW6dOnc9JJJ9GpUyfDk8aCqKio4NVXXw0RRlZWFpMnT+att95i06ZNhlvWzVZnVu3xsWWvl/6PlYSRRV6agw/PzwscAKs0ffs10p1PCb/mC14PhtVY2wbT0N736a4rgaVRCZ3buHn+6iKcJr3ky2KFbbVN4SM/gbYa9P0p1ansjlp1N/AXu/xxkYXT6WTatGl2opQkgiwgQRIGgJTyIuAVK2EbGhrIzc2NS8o4oy28P8RBvR+WWVtZDGFVDVxqIl2M65PGj//sFDLIajL5Dpp5KyGdBX6pLqsGJZCAUlS10VBUk3Hd1EXxC7r9tzzq6d9CCHbt2pUQfUGisGLFCp5++mmmTZtGXV2dLRPy22+/nfvuuy80x3799df5wx/+YBhWK9gH8eIpOVw2Ij1cKjBSeBKUGEzu65dchS68ke1HKE/Bza/u5tEZmqPqNGifKnhvtCs0u7GKnlmCkbO9bLTp7wLUIwTmz59vJ8qVQogXbGdkgIQRBoCUcj1gaffLlClT+OILS7vkI/DVCMHATMEWGxKGImHKIoVKE93S3Hs6c1iPtIC9BE2jjaJKFOpUJDhaBUTN0OqJEiAIDVEEdRt+1b+E8Eu+3eZl0kfmLJcohWdLQUpJTU0NzzzzDE888QS7d++OGWfnzp0UFRUB6kpOrGMdg+ia62TjDa3j00sYKj9BJRYTJah2WqJbrfH6JYWXraPMZGry6nAXvcyMC03UGk9v8PPmtvgWKzZs2EC3bt2sBt8ihOgSV0YGSNyWQBV/sRrwgw8+sGPKGobLVkjbdhcrazAli+OHZjCmR0pgpUMJ2wfSJDWo14LSBpr7RtcIphMgGakojC6IbuZ+1lln2Xuo/QwhBJmZmfzlL39h165d1NXVUVpayjvvvGN6DoZWr1FUVETv3r0t5XXL6LTAdCHKFCLWtzaeV+qmJbJpOhP8eBVNnIDi2qeQBLx8daFpWZ/d5NdMOQgXlaTmO/DZXit5Z3t8ZHHcccfZIQsA+1vFoyChhCGEmA5Y2rmUnp7OddddF1c+2xvg7+vtiXKv7zR/QX8/NR8R0DcIv2qJKULzZKnRYRCQPgIfn8LOfV6enV/HxdOrOO39Ci79tIp/z6thWbE3IG0oIV1GqoDzu5ubaR911FG2nulAIzU1ldatW3P22Wfz/fffU1dXx9atW/nmm2+455572LRpU4SxnpFpuBGO6pjURL76jm1GCno9hVdPIrowIULSfysqWXgD/3sVjh+YzthexrYpC8olm2qUMD1FUDo10mvcvdof136RlJQUXn75ZTtRVmNRTWAVCZ2SAEgpjwG+tBLW4/HQt29fNm3aZDsfl4DH+giGZ8d+hGIPnLpEMdxOftygDGbe2g6HQtNUJCARiMCqR1DiECFdBQhFsrfaz3UzK3nvN2NxJztZ0CfXwSW9k7mkVxJ+n0K7t2rYa3CkQYcOHdi0aVOYn4l9+/YxdepU9u3bR5cuXTjppJM4+eSTyc/Pt1ZJByE2btwY02dDm3TBrqta4XDophSB79JayXurPXyz2UNZvSTTLXjzjFxapTuMpy9gMo3R6DKi2nCo3z+srWfCfcbm45d1ElzaKbDMrJ+GaFZdX92m8Pzm+KSLm266ydQJtAkuFEK8EVdmJkg4YQBIKb8DJlgJ++abb3LBBRfElU+BGz4aGns367RiySObjSl9zp0dObxHSrgNhb9pGiGU4MYx2bS86peq5CBVAlmx28e/f6rhnVXm6+ltUgVjCpx8vNV4XvTYY49xww03hF17+OGH+fOf/xx2TQhBp06d6NOnD2PGjOHYY49l2LBhzTpMaH/joosuCp2wZoQpnZP47JTMsM7qR/DGag/PLGlg0W5vqA/2aOXks3Nz6ZGv37iGuZ7CTMkZTTci1AOqut6yhV0Vke+wwA0fjwousRo3yJ0NkvMX+9XjPm2iqKiI1atXk5WVZTXKAmBMc+0u9GgpwhiLevxazFYspWTChAnMmWP5tLYwHJ0vuLuH+WMoEs741XjPSGaKg+Knu5Hq1CyJahzgiND/qqMc/CLgSSsgceBQFaKB7exfb/BywRfV7I3DcbCRt6S3336b8847L2bcrKwshg4dyogRIxg3bhyHH364nc1I+x0rV65kwIABpqstf+jt5tXJaaGOOnuHjxt/qOO3veE97fAOSUw/LZv8dIe5NBGDBGLaZujSeG9hDWc/X2xY7peHOOiTIcKXfDRN84yFfnbY37ANwPPPP88VV1g6EohA7kcIIebGl5s5WoQwAKSULwMXWwk7f/58xo4da+uciyCcAv7dSzDOZHPaqhrJpSuMG+bD57Tm5mNym1zqhVlwBj7BXamKRPhkSAqJ2IwW2EtS0+DnxE9q+GGndVPfo48+mq++inQt0tjYyCOPPMI333zD4sWLbflGHTBgAIcffjhjxoxh2LBh9OzZs9lntyYSt912Gw888IDhvXQXzDs1g245Tm6b38B/lkey/dA2Lr47K4usFEdkJw+THExWTPT3Yxl3Bb53Vflpd+tWw3Jf3klwSQeHYa96ZKPCtF3xDfZjxoxhzpw5dtwivimEiE9sj4GWJIwiVDd+2VbC/+lPf7JzvFsYkgTMGOYg10Cf+MZOyTPbjF/Ujke70S7HESZZNG0kk+B3aMzBJSj+gMFWQNIIxSFEOkHLz2M+rWXWDmuksXDhQoYPHx4z3JIlS/jqq69Cpt1btmyxTLKtWrXiqKOOYvLkyQwcODBkbHWgUF5eTq9evdi719gtQ6cMQX6qg8V7IuX3nGTBlktyyE4RxoSgJ4KIpVbNNCTqsi0RkoYiodPftrGjIrJcQ7Ph6f6RhLGyGq5Yrtg6diIIl8vFwoULGTx4sNUodah7Rjbbzy02WowwAKSUVwGWDiaprKykT58+ltb2jZDnho+GOEjSTYKu/E1huYHpQ2GOk50Pdw0YYAXNvPWkIUIOfIMEEXT62+SSL+B2z99kpyEVUHzQ54Ma1kcx1AJo27Yt27Zti8vJTVlZGZ9++imffvopa9asYdu2bdTUxPAzGIDD4WDkyJGccsopjBs3js6dO9O2bdv9qguJxxObQ8DaczPpnuPUSAVA0MbCyNlONBKIw8bj+XnVXPVupCFXigNmjdbsRhVQ3gjH/xKfkhPgrrvu4h//+IedKHcIIf4Vd4Yx0NKE4QJWAj2thP/hhx+YMGFC3Pmd0kZwS1cRUpxU+iTHLjSm9afOK+C6CZlNXr1DEgMhCaJJaiBAFkHDLQUhJdKHOlsMWoJqt8Erkq+2+zhuVn3Uw2hsHjwTFYqi8PPPP/Pmm2/y/fffU1paaus0+Pz8fM4880zOPPNMunbtSmFhYdzewa3i1ltv5aGHHrIc/qh2LmadkIapZBGXzkJDPFFJRv1/d7Wfon8Y74R4dZCgV4barRoVOHeJws44z5YuKChg06ZNUU30dSgGugshbO6wso4WJQwAKeUI4Ber4S+77DL++9//xp3fI72bnO18uUdy9wbj7rrnsS7kp4mQwhKfbCIMhYBkoSo3HQET8WDYoM/O4KYzEZJQwglDKgojPmtgcblxh01NTaWiosLOwTO2sXfvXl5//XVeffVVtm3bRl1dXUw3f0GMGDGC+fPnt6jU4ff7GTp0qCULV5eAqgsySE3CeAqi7fCGy6UW9BZGcXXxqr2SrL8aE8atXQWntBFIAY9vlry/O/5FikWLFjFsmCVXM0GME0LY87ZtEy0ufwohFgKW14IfffTRZjXQm9dINgX8YyyqNH9ZWW5Cu0lFaG8IOitPcCgi4DAnOHVRAlMQmq4pIuANPGjcpYRc90Vb8v3mm28iyEJKyauvvsp//vMfampqmn1wUH5+PjfddBPLly+noqKChoYGZs+ezQknnIDD4YjqS2HhwoWG29GjIXjMYvDYRUVRqK+vZ/PmzSxevJhffvmFn3/+mXnz5rF69WoqKipYuHChJavf1imCVPRWnRqjq6ChlU9BehWkT1LvUSip0hhs6TetBS08wza2Kbp0NcZgfkl6lJcadJvw3d7mkcX1119vlyxea2mygP0gYQBIKbOBMsCSmn7hwoWMHDky7vxSHOoGtVvXKIbb34/vn8bMa9qEVjZUuwrNWSIKGslCIXiMQK1HYf1eL+vL1ClJURoUpgo6pzkRSsAZcECyEIrk2XU+rllkrPjMzMykoqIighyvvfZannnmGQCEEKSmppKWlsbpp5/O1VdfzcCBA+OuFz38fj/19fWUlpby8ssv89JLL4V5+0pLS6O4uDjqUQZbt25l9uzZzJ49m7lz51JdXR06tsDn8+H3+y2RnpXDmbpmCDZOTTFXcjpg9i4/f13UyOoKBY8iGdDKyYIzMtUdp0FpAaLbZEQz6grc7/tkKatLI9/t0flwchvBdavMHUvHQlpaGuXl5aEjKy1AAnlCiH3x5Wgd+4UwAKSUw1Hd+cWEoihcddVVvPjii3Hn1z4FShsxdKr62TVtOa5PikoOPhASzV4QVYmp11l4vJKbvqnl2WWRVp0uB+S6Ba2SBWd2dHJ73ySSpEK7GR5KPZGtxuFwsGrVKnr1ijzW5cQTT2TmTPPjLtPT08nPz2fgwIFccMEFnHjiiaSkpNiqGzNIKamsrKSsrIytW7fSu3fv0MaxIP7yl7/wwQcfUFVVRU1NDR5PnBP0OCCACQWC2ROT1fNWAx24tBEu+7mRH0oUqrxN9d0pQ7D+rAySnBpyMXKgE0YMQrP5DMymJZfMqOSVXyONKtomQ5UP6uIwzgK1bWzbts3yJr0AJgohvo8vR3vYn4ThAF4FLK0P+3w+2rdvH5d/y2hwCKh/rBNuVD1F8DSyMMOt0LRClTocGo/fP25r5MwvaimuMx8+kh3QJkWwzSTMoEGDWLp0qeG9pUuXcsIJJ7BzpyX3IiQlJdG+fXu6du3KlClTOP300+nYsaOluHbx6KOPcssttzR7mtRcjGglmDPRjVfCeQu8zC5WqNd10PxkwaYz0sh0R1OOGis1zXUiTXGfX1LHVZ/Z9K9gAUYWvzEwBzhSCBEnRdnDfiMMACllElAOWNqmWlxcTLdu3WydAxoLaUmCmofaIxRH2N6R4HGG6g7TpuvB1RAhm6YspdWSc2bV8t0u++8oNTWVdevW0b59e9MwPp+PzZs3s3r1an744Qc+//xz1qxZYzmP4K7QUaNGcdxxxzFmzJiErHakp6cn9F00BwOzBTvrJWUGDsKSHDDn6GRGt3ZEShVG0xC9pBFt2TXw//xdfsa8Vp7QZxo+fDgLF1oSwoOoB/KFEPvtpexXwgCQUg4D5gOWWvA777zD+eefH5cVqBFy0xyU31sUcH5Dk1FWwJoTnd1Fk8QRXBlR7TBqPX5Om93AVzvtkcbVV18d0lHYQUlJCYsXLw4pIufPn2/ZAVFGRgaDBw9m+PDhHHHEERx++OFxbWDLzMy0ZOeRmppKYWEhRUVFtG7dmuzsbDIzM8nIyMDpdIYUrXV1ddTU1FBdXc3u3bvZuXMnO3bsaDYpHV/oYOZ4t056wGTJ1EjyIIIg9Ksta/f56f1S4lQGbdu2Zd26dVH1RTr4gPFCiHkJK4QF7HfCAJBSPg9YNoyP93gCIxzVM4VZV7RuMtAKHWfYZMAVMv/2aTajycAyqr/JsnNfvZ/Bn9azvdaaiN6xY0c2bNgQ90lkWjQ0NLBw4ULmzp3L/PnzWbhwoWWjN4fDQd++fUOm4yNHjqRHjx4xV6e6desWsbN40qRJDB06lJ49e9KrVy969erV7IOStm3bxpo1a1i6dCn//Oc/LR/TCOpWgXVHJ9E106Hr8BgvpxKDMMLCNv2/o1ahwwsVzXrOINLS0vjmm2/sGrG9KISw3IcShQNCGABSyl+BwVbCKorCoEGD+O2335qd773HZvPXiVkBV3waC0+NZKFKE0Ey0XrSarLkDK6qfLfLx6RvY9s1CCF4++23LfuDsAspJevWrePrr79mzpw5/Pbbb6xfv97y2SStW7dm8uTJnHrqqZxyyimG5NG5c2e2bt0adu2XX35hxIgRCXkGI/z000+cdNJJlJUZu8jTo2+mYOVEp06CEKpmWz/FMJMm9K78DFZWKryS3Ocqmv18QggefPBBbrnlFjvR1gghIg/R3Q84kITRGtXBR56V8Lt27WLIkCGUlpY2K99bjsjkwWOzVOtNLVmEvGQRss0gaDbuQ70vRUBRGvSPAQ2NCgUfe6iOsW3EbINZEBs3biQpKYl27dolbJNYTU0NM2fO5JNPPmHlypVs3rzZ0hGL06ZN47TTTou4bqTDWLFiBf37909IeY1QW1vLE088wV//+ldL4Y/KF8wa5WjSS+ilhAgFZwzJwuT/Wj9kvFDZ7Oc7++yzeeedd+xEqQGGCiGsHXWXYBwwJwpCiD2o0xJLO7SKior48MMPm30i1yM/VvP2r7WqkY7WSCvsnJEmfYXUfYQ2jk+SgmRyQfRqTE1N5T//+Y/p/X/84x90796dTp060bZtW2644Qbmz5/P7t27m6W7ycjI4Oyzz+btt99m2bJlVFZWMm/ePK699lr69u1LXp4xV2/fHukkxufzGeoWWmoDm9frZfbs2fTs2dMyWQDU+CTeoOcsJbDqpffS5dUYbYUZcWmMu6K4/fM1Kpz+RfOtr4cOHcqbb75pJ4ofuPFAkQUcQAkjCCnlo8CNVsO/9tprXHLJJc1Wgj44OYubRqTikNo9JNot7UGdRcAPRrDx+RX1kG6fRCiqQdety308vMG8PLFO1+7evTsbN240vJeWlsZll13GVVddRWFhIZmZmQndpl5eXs6LL77Ia6+9RklJCe3atWPu3LkRRFBbWxthjel0OvF4PAktj5SSjRs3MnXqVFavXh1XGmNzYfZIBylaHo+myNSfZRKmswheU683SsExs+r4fnfz2l9BQQGrV6+2c8whwLNCiGualXEzccAJA0BK+SMwzmr4u+++m7vuuqvZ+V41JJVnJms9hRMiBqmZiojQCWhBxagITV88XoVOX/soMbFfGj16ND///HPUcpxzzjm89957luwbkpKSuPTSS7nlllvo1KlT2KpDS6K0tJQ2bdqEXRs4cCDLli1LWB4ej4cJEybYdaFviLwk2H1k5O5loKnVO7W6CRMSCa60CEEjMPYrD4vKmkcW0Qz3ouBnIcRhzco4AThY/LqdiGo6bgl///vfOeecc5qd6XO/1nPCtGoUv2iahgRd8vkFQhGa08/U6zJ4VkmAYP78m2JKFqCexRELb731Fjt27OCuu+6KucLg9Xp57rnn6N69OxkZGbRu3Zorrrgi7tHYKj766KOIa8ccc0xC0lYUhXPOOYeMjIyoZNGnj3U9X5kXsmcrYQdfhSADnwjHvybTFp+kol6hx8f1zSYLUPcQ2SSLKuCEZmecABwUEgaAlLIfsAyL+00aGhqYPHkyc+c23wvZYYUuvjklnWSa7C6avIQrqhdxjUVo0LDrwx2SMxf7Tbev23SrBqidp7KykuLiYqZNm8YLL7zAjh07LMXNzMwkPz+fyZMnc/XVV9txuhIVfr+fvLw8KivDlXyfffYZU6ZMaVa6999/Pw8//LDhSWlB5OTkcMIJJ+ByuXj11Vdt5eES8MoAwfntLDR1jTShVXKur5OM+8FHaQKs4N999914jpMYI4RovtiVABw0hAH2PI6DugowduzYhBz+0yPbwZdT0umaITTLrIERRtF65VJ3p66p9DNirp8aE5XtEUccwaxZs5q9dV1KSWlpKdu2bePzzz/njTfeMNV36DF16lRmzJjRrPxB9Tfas2ekS5PS0lJat25tOz2/388TTzzB448/bqhgDcLpdDJ+/Hh69OiB0+mkoqIibnucqzvCU30doVlITATI4psyyRmLFfZZ8wgQFS+88AKXXXaZ3SnkGUIIW+citiQOKsIAkFJeCTxnNXxVVRWDBw9m8+bNzc47L1nw8uEpTG3vbNrK7lcQfkfAmEudmlR4YNRcP+tMDLZSUlLYvHlzix15uGvXLlatWsUPP/zA9OnTWbVqlWnYysrKZq9kHHfccXz5ZTiPn3HGGbz//vu20vF6vTz22GM888wzEfYcevTo0YMxY8aEKVpXrVple7u9FpPzYNpQB1kWreQf3iy5c72M2KcSDx544AFuueUWu64bbgIeT7Tn7+bgYCQMJ/AwcIPVOFVVVfTq1YviYmNvznbgdsCdg5L4a19X06pJcG+Jovp4OHa+ZNZe83f4448/Mm6cZR1us7F79+6Q1edXX30Vkrguv/xyXniheUdq/vLLL4waNSri+rx58xgzZoylNBobG3niiSd46qmnokoUAHl5eYwZM4YOHTpEjMSffPKJ5emZGfpnwPShDnpEcWLll3DxCsmbO2VUb2lWcfPNN/Pggw/aJYtngD8JIax7k94POOgIA0BK6QZmAMdajVNRUUHv3r0Ttrv1nE5OXh3hwk1QMaaekXrNcoXntpnH+/vf/87dd9+9X1YuzFBSUkJpaSn9+vVrljOi2tpaRo4cGSHB9O7dmxUrVsTc0ObxeHj66ad56KGHYpJ5eno6I0eOpFevXoZl9vl8zSa/IArc8PZgwaS8yHe0swGOX6ywzFylYhlCCK644gqee86ywBzE98AxQgiDrXUHFgclYUDIH+iPgGUD+5KSEkaPHs2WLVsSUoaOaerhNEMyVK9b96/387d15uGHDh3KL7/8clC5828ObrrpJh577LGI6wsWLIjq4Kiqqoo33niDO+64I6oyEyA5OZmBAwcyfPjwqCTbHP2FEdwOeKav4NIOap4S+KREcs6yxExBhBBce+21PPXUU3ajrkC15DyoJIsgDlrCCEJKuRQYZDV8VVUVo0ePTugy4zP9HSDh2pXGxy0CtGvXjm3btv2uTiCLhldeeYVLLrkk4vqkSZOYNWuWYefeuHEjb7zxBvfddx8+X/T2npSURI8ePTj88MNjEqwQgk2bNvHFF1/YewgLuKGzehDW39ZJntqaGFWBw+HghhtusHusIcAaoO/BpLPQ4/dAGAL1fBNrx36jisKHHXYYS5YsabmCaZCZmcmGDRuavUvzYMHnn3/OCSecEGFIlpKSwp49e8IUkV6vl5UrV3LnnXfy6aefxkzb7XbTpUsXxo0bZ+iCLkhEQX+jwc8HH3xg2amQXQhIiK4C1JWd2267jXvvvddu1E1Ar4NVsgiiZX3IJwBCCCmlHAisBbpYiZOcnMwvv/zChAkTEmKnEQ1JSUnMmDHjf4YsZsyYwSmnnBJBFg6Hg3nz5oXIoq6ujrlz53LZZZfFVGSCShR9+/Zl9OjRYVKYlhSEEGFEEfxdU1PTYmQBiSMLl8vF/fffH3EergXsQD186KAmC/gdEAaAEMIrpewPbAAKrcRxOp3MmTOH448/vkVE2UC5eOKJJ5g4cWKLpL8/IaUMueAzwo033siQIUPweDw88sgj3HXXXZaOK3A6nYwdO5b+/fuHEQEQQRBmpLFnz56EPmtLwOl08uGHHzJ16lS7UfeikkWcp67uX/wuCANACFEnpeyJqhTqbDEOn376KX/5y1/imU/GxH333cfVV1+d8HQPBI499lhmzZpleO/000/n2GOPpaioiD179sTUT4A62p5wwgmh7fpBktATRKz/hRAsWrQooc+aaAghWLx4MYMGWVa1BbEL6CeEaP4++f2Eg16HoUfgyIIfgQFW4yiKwnvvvce5556bsHLccccd3HvvvQd0+TQR2LJlC2PGjDFd9hRCkJGRYcmPhhAiNO3IzMy0RAZG17RSSHFxcVTXAAcaWVlZLF++nE6dOtmNugEYLYSwvIfqYMDvsrUHSGMmNna4groceNhhhzV7a/xdd93F3//+99/1ikhDQwMXXHABH330kWWvXGbIzc1l3LhxdOjQgbS0NFMCsEoW2nsfffRRzN2+BwqjR4/ms88+s7tFHWApcNTvjSzgd0oYAFLKTOBdwNbup23btjF69Oi4D32O08T3oIHP5+OJJ57g4YcfbpZlrNvtZuDAgfTr14+CggJDZaVV0gAM41dXV/PPf/7T0hRof0IIwR133MFdd90Vjzf2n4AT98ehQy2B3y1hAEgp04DngfPtxPN4PJx77rlMnz7dVn7PPvssV1555e9yGuL1enn55Zd57LH/a+/sY6q6zzj+OfcC8iqg1taKVuFiCoJJy9Zo0zVdZk3di0bTdi/YLNFu2f5pXdpQ22nIEq1xRmtG6pyJHTbSzhpr58sfpLWaNM7VWFhEXQXfESq0gCJDuN7Ld38cIAhyufdyLvfF80menACXcw7nPL+H38vze77vcO7cuaDOMW7cOAoKCsjNzSUrK4v4+Ph7Nvrh5isCnbvYvXs3X3zxhWXPwAqSkpIoLy/nxRdfDObXPwB+a4RQLDnURJ/nD6I3I7QU+CMB/j1lZWWsWrXKr7L2FRUVls6BjBWtra2Ul5dTVlYWVAZscnJyfzXw7OzsoIcY/gaJvu83Njaydu3aUQ+XrMTlcrFnz55gywZsBN6KhqVTX0R9wOhD0nLgr0BA+8mrqqooLi72KRS0a9cuiouLR3mHoadPAOnixYvU1tZy7NgxPvnkk4DkDB0OB5MnT2batGnMmjWLGTNmDDvc8NWT8DXU8CeYbN682ZIq8VbgcDh46aWX2LZtWzCylB7gdeAvRgRncPpLzAQMAEnzgAP4WYm8j6tXrzJ79uwhIj1Op5OtW7cGXAQnlHR0dNDS0tJvDQ0N1NTUcPz4cU6ePOlXbsRgMjIyeOCBB3j00UfJy8sjMTHRZ16Ev40+kPmMgV8fOXKE9957LwRPL3AmTpzIli1bWLYsoFFvH7eAXxmGMbxYbpQRNXkY/mAYxnFJecAJ/MzVaGtrY+HChUOCRVxcHOvXrw9JsLhz5w7d3d243e67jn3W1dVFU1MTV65cucsuX77MjRs3RnVtp9NJSkoKaWlp5OTkUFRUxPjx4/3Ok/DVswikpwF3Z3n20draaukms9FQVFTE/v37hwhS+8kFTM1TH3ubo4+YChhgyhdIqsePgNHZ2cmTTz45ZDjidDpZvXq13+IyAxt6V1cXt27d4urVq1y+fLnfrly5QkNDA01NTUH1AoLBMAwSEhJITExk2rRpFBYW4nK5+gsH++pFwPCTlqPpSQwMDoPxer2sX7/ebwnIUJGcnMzbb7/Nq6++GsyvC/gUeC4WhiCDibmAIekXwA9G+pzX62XOnDlDyt0ZhkFJSQmlpaVDPu/xePB4PJw/f56DBw9SWVlJVVVVQFJ+ocLhcOBwOHA6ncyYMYNZs2ZRWFhIQkKCX72D4YYJ9/qsv5OXvoLDYCSxdu3aoJe7rcLlclFVVRWIxulAvECpYRjrLL6tiCGm5jAAJLUAI2bSzJw5856rBiUlJWzYsAGA7777jm3btvH+++9TX1+P1+vF6/VaJgw9GlJTU3G5XP0Tk/Hx8TgcDuLi4u7ZkMH/IDFS72NwQBg4xAiWTZs2UV1dPfoHEyROp5NDhw6xYMGCYP8OL/CUESHFekNFTAUMSZ8C8319xuPxkJ+fT13dUPGoxx9/nOnTp3PixAna29v9UioPB4Zh+FWkp8/xR2r8fceEhASSk5PJyMhgwoQJ/TZp0qT+48BzWoEkysvLOXz4sCXnC4bi4mLeffdd0tPTgz3FUWCpEaXJWIEQMwFDUiFQjQ+ZArfbzdNPP82XX345djcWQ/QFlcGWkpLCww8/zNSpU/vNn8bn8XjYtGkTNTU1Y3D3Q3nssceoqKgISO/kHvwa+NAwjLGZmAozMREwemuANgEZw32mu7ubxYsX+xREtrGOuLg4UlJSSE1NJTU1lYyMDLKyssjKyurfc7Jx40ZLqr0HyoMPPsjWrVtZtGhRMKndfdRjTmwOX7LdJjKR9I584PF49MILL/TpXQVsSUlJeuaZZ7Ry5Urt2LFDn3/+uU6cOKGXX3456HPe79a7gjCmNmHCBJWVlenmzZu+3GUk3JL+1JthbBNtSJoy0hs+evSo307lcDg0e/ZsrVixQtu3b1d1dbU8Hs+w5z516pSWLl0a9gZo2/CWlpamdevWjTZQSNJJSd8f4oQ20YOkf4z0lg8ePOjToXJzc7V8+XLt3btXLS0tQXnS8ePHtWjRIjkcjrA3ENtMmzRpkkpKStTR0RHUOx3ATUlvyqwvaxOtSJruz9tuaWlRdnZ2vyMlJydr3rx5WrNmjerq6kbrTHdRX1+vZcuWafz48WFvMPer5ebmasOGDerp6Rnt6+yR9Jmk7JG90SbikfS6v2/+9u3b2rlzpz7++GMrHGlEurq69Nprr2nKlClhb0D3g8XFxamwsFC7d++26hVekLTQb2e0iWwkOSU1WeUdoWTnzp3Kzc1VQkJC2BtWrFl6eroWL16sS5cuWfW6bkp6Q/bwI7aQ5LLKQ8aKjo4OvfLKK0pJSQl7Q4tmczqdyszMVEVFhZW9xTuSDsle/YhNJP3IKk8Za7xerxobGzVv3rywN75osvj4eJWWlqq7u9vqYeVhSfFBuqJNNCDpp1Z6zDD8V9IKSQ9JSpQ0WdI+Ky/Q3t6ur776SkuWLAlLbkKkW1JSklavXq3r16/L7XZb+eglqVJSbChQ2fhG0g+s9h5JlyS9JalAUqaPa0+TtM3qi9+6dUunT5/WmjVrlJmZGfbGGi574okntGvXLl28eFHd3d1WP2ZJ+qekXNnzFAETtQ9M0nigGRgq0Ok/1zErjx/EFMJtDKSGgaRHgN8Bb2Dxs+zbRv/1119z4MAB9u3bR1tbm5WXiBjy8vJYsmQJzz77LPn5+aGSnewBNgN/MwzjfCgucD8QtQEDQNJzQCA6iDeB/cAhTG2IOsMwRr1XXdIU4HngTfyUcgyGCxcucObMGY4dO0ZlZSU1NTURsdU+ENLT05k7dy7z58+nqKioX6YghLRjFon+wDCM5lBe6H4gqgMGgKTvYf6HXwikDPiRF1Nd6j+YWhD/AqqtCBA+7sUAfgL8BlMvJaQz7p2dndTV1VFbW8u5c+c4e/YsZ86c4ezZs2HX8sjMzCQ7O5uCggLmzJlDXl4e+fn5TJ8+3bKt8T7oAY4AO4A9RpRX6o4koj5gDETSQ0Ay0AU0GYYRthr1MrMDfw/8Epg6ltfu6emhtraWa9eu0djYyLVr1/jmm29obm6mubmZb7/9lvb29rtKC7rd7iGK7QNxOp3Ex8eTlpZGZmYmGRkZdx2zsrLIycnB5XKRk5NDZuawU0Ch5BrwEbDdMIzgxFdsfBJTASMS6e11/BhYjintGJGz8pK4ffs2nZ2ddHZ24nA4SExM7LdRbAMPNW3Av4G/A3tD2YO0sQPGmCLJCfwMWAnMAcLybzgGuAmcxtSh+eh+KV4TCdgBI0z09jyeB/4A5ACTgOgUbA09PUArcAnYglnhyu/VLBvrsANGhCBpImbwWI7Z8whYYivGcGOucHwA/NkwjIYw348NdsCISHp7HwXAKuDn+KhTGmN4gV3AO8ApuxcRedgBI8KR5MBc+UkGFmAWnf0h0R9EhLnkXQF8iCkr+D970jKysQNGFCKz6PFEIB2YiSnc9BQwF4jETVR1wGdAJWZGbRtwwzAMd1jvyiZg7IARQ/T2RiZiTqBOxKyi/ghmUJkxwAISq/ZBK9AwwC5hrl40YQaFNqDNXsWIHeyAcR8iaRxmVmwCZo9k8DEe0zc8wJ17HDuAdjuD0sbGxsZmWP4Ps7HMrIFkmyEAAAAASUVORK5CYII=" }, "annotations": [] } diff --git a/tests/data/groundtruth/docling_v2/test-01.xlsx.json b/tests/data/groundtruth/docling_v2/test-01.xlsx.json index 2bdfe509..59613aa7 100644 --- a/tests/data/groundtruth/docling_v2/test-01.xlsx.json +++ b/tests/data/groundtruth/docling_v2/test-01.xlsx.json @@ -123,7 +123,7 @@ "width": 421.0, "height": 430.0 }, - "uri": "data:image/png;base64,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" + "uri": "data:image/png;base64,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" }, "annotations": [] } diff --git a/tests/data/groundtruth/docling_v2/test_emf_docx.docx.json b/tests/data/groundtruth/docling_v2/test_emf_docx.docx.json index bb8807f6..82bbc38a 100644 --- a/tests/data/groundtruth/docling_v2/test_emf_docx.docx.json +++ b/tests/data/groundtruth/docling_v2/test_emf_docx.docx.json @@ -142,7 +142,7 @@ "width": 400.0, "height": 400.0 }, - "uri": "data:image/png;base64,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" + "uri": "data:image/png;base64,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" }, "annotations": [] } diff --git a/tests/data/groundtruth/docling_v2/unit_test_01.html.itxt b/tests/data/groundtruth/docling_v2/unit_test_01.html.itxt index c87bb5ff..0ef0fc50 100644 --- a/tests/data/groundtruth/docling_v2/unit_test_01.html.itxt +++ b/tests/data/groundtruth/docling_v2/unit_test_01.html.itxt @@ -1,9 +1,8 @@ item-0 at level 0: unspecified: group _root_ item-1 at level 1: title: Title - item-2 at level 2: section_header: section-1 - item-3 at level 3: section_header: section-1.1 - item-4 at level 2: section_header: section-2 - item-5 at level 3: section: group header-3 - item-6 at level 4: section_header: section-2.0.1 - item-7 at level 3: section_header: section-2.2 - item-8 at level 3: section_header: section-2.3 \ No newline at end of file + item-2 at level 1: section_header: section-1 + item-3 at level 1: section_header: section-1.1 + item-4 at level 1: section_header: section-2 + item-5 at level 1: section_header: section-2.0.1 + item-6 at level 1: section_header: section-2.2 + item-7 at level 1: section_header: section-2.3 \ No newline at end of file diff --git a/tests/data/groundtruth/docling_v2/unit_test_01.html.json b/tests/data/groundtruth/docling_v2/unit_test_01.html.json index 498db3c0..8df64edc 100644 --- a/tests/data/groundtruth/docling_v2/unit_test_01.html.json +++ b/tests/data/groundtruth/docling_v2/unit_test_01.html.json @@ -19,42 +19,38 @@ "children": [ { "$ref": "#/texts/0" + }, + { + "$ref": "#/texts/1" + }, + { + "$ref": "#/texts/2" + }, + { + "$ref": "#/texts/3" + }, + { + "$ref": "#/texts/4" + }, + { + "$ref": "#/texts/5" + }, + { + "$ref": "#/texts/6" } ], "content_layer": "body", "name": "_root_", "label": "unspecified" }, - "groups": [ - { - "self_ref": "#/groups/0", - "parent": { - "$ref": "#/texts/3" - }, - "children": [ - { - "$ref": "#/texts/4" - } - ], - "content_layer": "body", - "name": "header-3", - "label": "section" - } - ], + "groups": [], "texts": [ { "self_ref": "#/texts/0", "parent": { "$ref": "#/body" }, - "children": [ - { - "$ref": "#/texts/1" - }, - { - "$ref": "#/texts/3" - } - ], + "children": [], "content_layer": "body", "label": "title", "prov": [], @@ -64,24 +60,20 @@ { "self_ref": "#/texts/1", "parent": { - "$ref": "#/texts/0" + "$ref": "#/body" }, - "children": [ - { - "$ref": "#/texts/2" - } - ], + "children": [], "content_layer": "body", "label": "section_header", "prov": [], "orig": "section-1", "text": "section-1", - "level": 1 + "level": 2 }, { "self_ref": "#/texts/2", "parent": { - "$ref": "#/texts/1" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -89,35 +81,25 @@ "prov": [], "orig": "section-1.1", "text": "section-1.1", - "level": 2 + "level": 3 }, { "self_ref": "#/texts/3", "parent": { - "$ref": "#/texts/0" + "$ref": "#/body" }, - "children": [ - { - "$ref": "#/groups/0" - }, - { - "$ref": "#/texts/5" - }, - { - "$ref": "#/texts/6" - } - ], + "children": [], "content_layer": "body", "label": "section_header", "prov": [], "orig": "section-2", "text": "section-2", - "level": 1 + "level": 2 }, { "self_ref": "#/texts/4", "parent": { - "$ref": "#/groups/0" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -125,12 +107,12 @@ "prov": [], "orig": "section-2.0.1", "text": "section-2.0.1", - "level": 3 + "level": 4 }, { "self_ref": "#/texts/5", "parent": { - "$ref": "#/texts/3" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -138,12 +120,12 @@ "prov": [], "orig": "section-2.2", "text": "section-2.2", - "level": 2 + "level": 3 }, { "self_ref": "#/texts/6", "parent": { - "$ref": "#/texts/3" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -151,7 +133,7 @@ "prov": [], "orig": "section-2.3", "text": "section-2.3", - "level": 2 + "level": 3 } ], "pictures": [], diff --git a/tests/data/groundtruth/docling_v2/unit_test_01.html.md b/tests/data/groundtruth/docling_v2/unit_test_01.html.md index 38cbbbcf..63f0c203 100644 --- a/tests/data/groundtruth/docling_v2/unit_test_01.html.md +++ b/tests/data/groundtruth/docling_v2/unit_test_01.html.md @@ -1,13 +1,13 @@ # Title -## section-1 +### section-1 -### section-1.1 +#### section-1.1 -## section-2 +### section-2 -#### section-2.0.1 +##### section-2.0.1 -### section-2.2 +#### section-2.2 -### section-2.3 \ No newline at end of file +#### section-2.3 \ No newline at end of file diff --git a/tests/data/groundtruth/docling_v2/wiki_duck.html.itxt b/tests/data/groundtruth/docling_v2/wiki_duck.html.itxt index c0f5fdc9..13fd3d72 100644 --- a/tests/data/groundtruth/docling_v2/wiki_duck.html.itxt +++ b/tests/data/groundtruth/docling_v2/wiki_duck.html.itxt @@ -1,458 +1,517 @@ item-0 at level 0: unspecified: group _root_ - item-1 at level 1: section: group header-1 - item-2 at level 2: section_header: Contents - item-3 at level 3: list: group list - item-4 at level 4: list_item: (Top) - item-5 at level 4: list_item: 1 Etymology - item-6 at level 5: list: group list - item-7 at level 4: list_item: 2 Taxonomy - item-8 at level 5: list: group list - item-9 at level 4: list_item: 3 Morphology - item-10 at level 5: list: group list - item-11 at level 4: list_item: 4 Distribution and habitat - item-12 at level 5: list: group list - item-13 at level 4: list_item: 5 Behaviour Toggle Behaviour subsection - item-14 at level 5: list: group list - item-15 at level 6: list_item: 5.1 Feeding - item-16 at level 7: list: group list - item-17 at level 6: list_item: 5.2 Breeding - item-18 at level 7: list: group list - item-19 at level 6: list_item: 5.3 Communication - item-20 at level 7: list: group list - item-21 at level 6: list_item: 5.4 Predators - item-22 at level 7: list: group list - item-23 at level 4: list_item: 6 Relationship with humans Toggle Relationship with humans subsection - item-24 at level 5: list: group list - item-25 at level 6: list_item: 6.1 Hunting - item-26 at level 7: list: group list - item-27 at level 6: list_item: 6.2 Domestication - item-28 at level 7: list: group list - item-29 at level 6: list_item: 6.3 Heraldry - item-30 at level 7: list: group list - item-31 at level 6: list_item: 6.4 Cultural references - item-32 at level 7: list: group list - item-33 at level 4: list_item: 7 See also - item-34 at level 5: list: group list - item-35 at level 4: list_item: 8 Notes Toggle Notes subsection - item-36 at level 5: list: group list - item-37 at level 6: list_item: 8.1 Citations - item-38 at level 7: list: group list - item-39 at level 6: list_item: 8.2 Sources - item-40 at level 7: list: group list - item-41 at level 4: list_item: 9 External links - item-42 at level 5: list: group list - item-43 at level 1: title: Duck - item-44 at level 2: list: group list - item-45 at level 3: list_item: Acèh - item-46 at level 3: list_item: Afrikaans - item-47 at level 3: list_item: Alemannisch - item-48 at level 3: list_item: አማርኛ - item-49 at level 3: list_item: Ænglisc - item-50 at level 3: list_item: العربية - item-51 at level 3: list_item: Aragonés - item-52 at level 3: list_item: ܐܪܡܝܐ - item-53 at level 3: list_item: Armãneashti - item-54 at level 3: list_item: Asturianu - item-55 at level 3: list_item: Atikamekw - item-56 at level 3: list_item: Авар - item-57 at level 3: list_item: Aymar aru - item-58 at level 3: list_item: تۆرکجه - item-59 at level 3: list_item: Basa Bali - item-60 at level 3: list_item: বাংলা - item-61 at level 3: list_item: 閩南語 / Bân-lâm-gú - item-62 at level 3: list_item: Беларуская - item-63 at level 3: list_item: Беларуская (тарашкевіца) - item-64 at level 3: list_item: Bikol Central - item-65 at level 3: list_item: Български - item-66 at level 3: list_item: Brezhoneg - item-67 at level 3: list_item: Буряад - item-68 at level 3: list_item: Català - item-69 at level 3: list_item: Чӑвашла - item-70 at level 3: list_item: Čeština - item-71 at level 3: list_item: ChiShona - item-72 at level 3: list_item: Cymraeg - item-73 at level 3: list_item: Dagbanli - item-74 at level 3: list_item: Dansk - item-75 at level 3: list_item: Deitsch - item-76 at level 3: list_item: Deutsch - item-77 at level 3: list_item: डोटेली - item-78 at level 3: list_item: Ελληνικά - item-79 at level 3: list_item: Emiliàn e rumagnòl - item-80 at level 3: list_item: Español - item-81 at level 3: list_item: Esperanto - item-82 at level 3: list_item: Euskara - item-83 at level 3: list_item: فارسی - item-84 at level 3: list_item: Français - item-85 at level 3: list_item: Gaeilge - item-86 at level 3: list_item: Galego - item-87 at level 3: list_item: ГӀалгӀай - item-88 at level 3: list_item: 贛語 - item-89 at level 3: list_item: گیلکی - item-90 at level 3: list_item: 𐌲𐌿𐍄𐌹𐍃𐌺 - item-91 at level 3: list_item: गोंयची कोंकणी / Gõychi Konknni - item-92 at level 3: list_item: 客家語 / Hak-kâ-ngî - item-93 at level 3: list_item: 한국어 - item-94 at level 3: list_item: Hausa - item-95 at level 3: list_item: Հայերեն - item-96 at level 3: list_item: हिन्दी - item-97 at level 3: list_item: Hrvatski - item-98 at level 3: list_item: Ido - item-99 at level 3: list_item: Bahasa Indonesia - item-100 at level 3: list_item: Iñupiatun - item-101 at level 3: list_item: Íslenska - item-102 at level 3: list_item: Italiano - item-103 at level 3: list_item: עברית - item-104 at level 3: list_item: Jawa - item-105 at level 3: list_item: ಕನ್ನಡ - item-106 at level 3: list_item: Kapampangan - item-107 at level 3: list_item: ქართული - item-108 at level 3: list_item: कॉशुर / کٲشُر - item-109 at level 3: list_item: Қазақша - item-110 at level 3: list_item: Ikirundi - item-111 at level 3: list_item: Kongo - item-112 at level 3: list_item: Kreyòl ayisyen - item-113 at level 3: list_item: Кырык мары - item-114 at level 3: list_item: ລາວ - item-115 at level 3: list_item: Latina - item-116 at level 3: list_item: Latviešu - item-117 at level 3: list_item: Lietuvių - item-118 at level 3: list_item: Li Niha - item-119 at level 3: list_item: Ligure - item-120 at level 3: list_item: Limburgs - item-121 at level 3: list_item: Lingála - item-122 at level 3: list_item: Malagasy - item-123 at level 3: list_item: മലയാളം - item-124 at level 3: list_item: मराठी - item-125 at level 3: list_item: مازِرونی - item-126 at level 3: list_item: Bahasa Melayu - item-127 at level 3: list_item: ꯃꯤꯇꯩ ꯂꯣꯟ - item-128 at level 3: list_item: 閩東語 / Mìng-dĕ̤ng-ngṳ̄ - item-129 at level 3: list_item: Мокшень - item-130 at level 3: list_item: Монгол - item-131 at level 3: list_item: မြန်မာဘာသာ - item-132 at level 3: list_item: Nederlands - item-133 at level 3: list_item: Nedersaksies - item-134 at level 3: list_item: नेपाली - item-135 at level 3: list_item: नेपाल भाषा - item-136 at level 3: list_item: 日本語 - item-137 at level 3: list_item: Нохчийн - item-138 at level 3: list_item: Norsk nynorsk - item-139 at level 3: list_item: Occitan - item-140 at level 3: list_item: Oromoo - item-141 at level 3: list_item: ਪੰਜਾਬੀ - item-142 at level 3: list_item: Picard - item-143 at level 3: list_item: Plattdüütsch - item-144 at level 3: list_item: Polski - item-145 at level 3: list_item: Português - item-146 at level 3: list_item: Qırımtatarca - item-147 at level 3: list_item: Română - item-148 at level 3: list_item: Русский - item-149 at level 3: list_item: Саха тыла - item-150 at level 3: list_item: ᱥᱟᱱᱛᱟᱲᱤ - item-151 at level 3: list_item: Sardu - item-152 at level 3: list_item: Scots - item-153 at level 3: list_item: Seeltersk - item-154 at level 3: list_item: Shqip - item-155 at level 3: list_item: Sicilianu - item-156 at level 3: list_item: සිංහල - item-157 at level 3: list_item: Simple English - item-158 at level 3: list_item: سنڌي - item-159 at level 3: list_item: کوردی - item-160 at level 3: list_item: Српски / srpski - item-161 at level 3: list_item: Srpskohrvatski / српскохрватски - item-162 at level 3: list_item: Sunda - item-163 at level 3: list_item: Svenska - item-164 at level 3: list_item: Tagalog - item-165 at level 3: list_item: தமிழ் - item-166 at level 3: list_item: Taqbaylit - item-167 at level 3: list_item: Татарча / tatarça - item-168 at level 3: list_item: ไทย - item-169 at level 3: list_item: Türkçe - item-170 at level 3: list_item: Українська - item-171 at level 3: list_item: ئۇيغۇرچە / Uyghurche - item-172 at level 3: list_item: Vahcuengh - item-173 at level 3: list_item: Tiếng Việt - item-174 at level 3: list_item: Walon - item-175 at level 3: list_item: 文言 - item-176 at level 3: list_item: Winaray - item-177 at level 3: list_item: 吴语 - item-178 at level 3: list_item: 粵語 - item-179 at level 3: list_item: Žemaitėška - item-180 at level 3: list_item: 中文 - item-181 at level 2: list: group list - item-182 at level 3: list_item: Article - item-183 at level 3: list_item: Talk - item-184 at level 2: list: group list - item-185 at level 2: list: group list - item-186 at level 3: list_item: Read - item-187 at level 3: list_item: View source - item-188 at level 3: list_item: View history - item-189 at level 2: text: Tools - item-190 at level 2: text: Actions - item-191 at level 2: list: group list - item-192 at level 3: list_item: Read - item-193 at level 3: list_item: View source - item-194 at level 3: list_item: View history - item-195 at level 2: text: General - item-196 at level 2: list: group list - item-197 at level 3: list_item: What links here - item-198 at level 3: list_item: Related changes - item-199 at level 3: list_item: Upload file - item-200 at level 3: list_item: Special pages - item-201 at level 3: list_item: Permanent link - item-202 at level 3: list_item: Page information - item-203 at level 3: list_item: Cite this page - item-204 at level 3: list_item: Get shortened URL - item-205 at level 3: list_item: Download QR code - item-206 at level 3: list_item: Wikidata item - item-207 at level 2: text: Print/export - item-208 at level 2: list: group list - item-209 at level 3: list_item: Download as PDF - item-210 at level 3: list_item: Printable version - item-211 at level 2: text: In other projects - item-212 at level 2: list: group list - item-213 at level 3: list_item: Wikimedia Commons - item-214 at level 3: list_item: Wikiquote - item-215 at level 2: text: Appearance - item-216 at level 2: picture - item-217 at level 2: text: From Wikipedia, the free encyclopedia - item-218 at level 2: text: Common name for many species of bird - item-219 at level 2: text: This article is about the bird. ... as a food, see . For other uses, see . - item-220 at level 2: text: "Duckling" redirects here. For other uses, see . - item-221 at level 2: table with [13x2] - item-222 at level 2: text: Duck is the common name for nume ... und in both fresh water and sea water. - item-223 at level 2: text: Ducks are sometimes confused wit ... divers, grebes, gallinules and coots. - item-224 at level 2: section_header: Etymology - item-225 at level 3: text: The word duck comes from Old Eng ... h duiken and German tauchen 'to dive'. - item-226 at level 3: picture - item-226 at level 4: caption: Pacific black duck displaying the characteristic upending "duck" - item-227 at level 3: text: This word replaced Old English e ... nskrit ātí 'water bird', among others. - item-228 at level 3: text: A duckling is a young duck in do ... , is sometimes labelled as a duckling. - item-229 at level 3: text: A male is called a drake and the ... a duck, or in ornithology a hen.[3][4] - item-230 at level 3: picture - item-230 at level 4: caption: Male mallard. - item-231 at level 3: picture - item-231 at level 4: caption: Wood ducks. - item-232 at level 2: section_header: Taxonomy - item-233 at level 3: text: All ducks belong to the biologic ... ationships between various species.[9] - item-234 at level 3: picture - item-234 at level 4: caption: Mallard landing in approach - item-235 at level 3: text: In most modern classifications, ... all size and stiff, upright tails.[14] - item-236 at level 3: text: A number of other species called ... shelducks in the tribe Tadornini.[15] - item-237 at level 2: section_header: Morphology - item-238 at level 3: picture - item-238 at level 4: caption: Male Mandarin duck - item-239 at level 3: text: The overall body plan of ducks i ... is moult typically precedes migration. - item-240 at level 3: text: The drakes of northern species o ... rkscrew shaped vagina to prevent rape. - item-241 at level 2: section_header: Distribution and habitat - item-242 at level 3: picture - item-242 at level 4: caption: Flying steamer ducks in Ushuaia, Argentina - item-243 at level 3: text: Ducks have a cosmopolitan distri ... endemic to such far-flung islands.[21] - item-244 at level 3: picture - item-244 at level 4: caption: Female mallard in Cornwall, England - item-245 at level 3: text: Some duck species, mainly those ... t form after localised heavy rain.[23] - item-246 at level 2: section_header: Behaviour - item-247 at level 3: section_header: Feeding - item-248 at level 4: picture - item-248 at level 5: caption: Pecten along the bill - item-249 at level 4: picture - item-249 at level 5: caption: Mallard duckling preening - item-250 at level 4: text: Ducks eat food sources such as g ... amphibians, worms, and small molluscs. - item-251 at level 4: text: Dabbling ducks feed on the surfa ... thers and to hold slippery food items. - item-252 at level 4: text: Diving ducks and sea ducks forag ... ave more difficulty taking off to fly. - item-253 at level 4: text: A few specialized species such a ... apted to catch and swallow large fish. - item-254 at level 4: text: The others have the characterist ... e nostrils come out through hard horn. - item-255 at level 4: text: The Guardian published an articl ... the ducks and pollutes waterways.[25] - item-256 at level 3: section_header: Breeding - item-257 at level 4: picture - item-257 at level 5: caption: A Muscovy duckling - item-258 at level 4: text: Ducks generally only have one pa ... st and led her ducklings to water.[28] - item-259 at level 3: section_header: Communication - item-260 at level 4: text: Female mallard ducks (as well as ... laying calls or quieter contact calls. - item-261 at level 4: text: A common urban legend claims tha ... annel television show MythBusters.[32] - item-262 at level 3: section_header: Predators - item-263 at level 4: picture - item-263 at level 5: caption: Ringed teal - item-264 at level 4: text: Ducks have many predators. Duckl ... or large birds, such as hawks or owls. - item-265 at level 4: text: Adult ducks are fast fliers, but ... its speed and strength to catch ducks. - item-266 at level 2: section_header: Relationship with humans - item-267 at level 3: section_header: Hunting - item-268 at level 4: text: Humans have hunted ducks since p ... evidence of this is uncommon.[35][42] - item-269 at level 4: text: In many areas, wild ducks (inclu ... inated by pollutants such as PCBs.[44] - item-270 at level 3: section_header: Domestication - item-271 at level 4: picture - item-271 at level 5: caption: Indian Runner ducks, a common breed of domestic ducks - item-272 at level 4: text: Ducks have many economic uses, b ... it weighs less than 1 kg (2.2 lb).[48] - item-273 at level 3: section_header: Heraldry - item-274 at level 4: picture - item-274 at level 5: caption: Three black-colored ducks in the coat of arms of Maaninka[49] - item-275 at level 4: text: Ducks appear on several coats of ... the coat of arms of Föglö (Åland).[51] - item-276 at level 3: section_header: Cultural references - item-277 at level 4: text: In 2002, psychologist Richard Wi ... 54] and was made into a movie in 1986. - item-278 at level 4: text: The 1992 Disney film The Mighty ... Ducks minor league baseball team.[55] - item-279 at level 2: section_header: See also - item-280 at level 3: list: group list - item-281 at level 4: list_item: Birds portal - item-282 at level 3: list: group list - item-283 at level 4: list_item: Domestic duck - item-284 at level 4: list_item: Duck as food - item-285 at level 4: list_item: Duck test - item-286 at level 4: list_item: Duck breeds - item-287 at level 4: list_item: Fictional ducks - item-288 at level 4: list_item: Rubber duck - item-289 at level 2: section_header: Notes - item-290 at level 3: section_header: Citations - item-291 at level 4: ordered_list: group ordered list - item-292 at level 5: list_item: ^ "Duckling". The American Herit ... n Company. 2006. Retrieved 2015-05-22. - item-293 at level 5: list_item: ^ "Duckling". Kernerman English ... Ltd. 2000–2006. Retrieved 2015-05-22. - item-294 at level 5: list_item: ^ Dohner, Janet Vorwald (2001). ... University Press. ISBN 978-0300138139. - item-295 at level 5: list_item: ^ Visca, Curt; Visca, Kelley (20 ... Publishing Group. ISBN 9780823961566. - item-296 at level 5: list_item: ^ a b c d Carboneras 1992, p. 536. - item-297 at level 5: list_item: ^ Livezey 1986, pp. 737–738. - item-298 at level 5: list_item: ^ Madsen, McHugh & de Kloet 1988, p. 452. - item-299 at level 5: list_item: ^ Donne-Goussé, Laudet & Hänni 2002, pp. 353–354. - item-300 at level 5: list_item: ^ a b c d e f Carboneras 1992, p. 540. - item-301 at level 5: list_item: ^ Elphick, Dunning & Sibley 2001, p. 191. - item-302 at level 5: list_item: ^ Kear 2005, p. 448. - item-303 at level 5: list_item: ^ Kear 2005, p. 622–623. - item-304 at level 5: list_item: ^ Kear 2005, p. 686. - item-305 at level 5: list_item: ^ Elphick, Dunning & Sibley 2001, p. 193. - item-306 at level 5: list_item: ^ a b c d e f g Carboneras 1992, p. 537. - item-307 at level 5: list_item: ^ American Ornithologists' Union 1998, p. xix. - item-308 at level 5: list_item: ^ American Ornithologists' Union 1998. - item-309 at level 5: list_item: ^ Carboneras 1992, p. 538. - item-310 at level 5: list_item: ^ Christidis & Boles 2008, p. 62. - item-311 at level 5: list_item: ^ Shirihai 2008, pp. 239, 245. - item-312 at level 5: list_item: ^ a b Pratt, Bruner & Berrett 1987, pp. 98–107. - item-313 at level 5: list_item: ^ Fitter, Fitter & Hosking 2000, pp. 52–3. - item-314 at level 5: list_item: ^ "Pacific Black Duck". www.wiresnr.org. Retrieved 2018-04-27. - item-315 at level 5: list_item: ^ Ogden, Evans. "Dabbling Ducks". CWE. Retrieved 2006-11-02. - item-316 at level 5: list_item: ^ Karl Mathiesen (16 March 2015) ... Guardian. Retrieved 13 November 2016. - item-317 at level 5: list_item: ^ Rohwer, Frank C.; Anderson, Mi ... 4615-6787-5_4. ISBN 978-1-4615-6789-9. - item-318 at level 5: list_item: ^ Smith, Cyndi M.; Cooke, Fred; ... 093/condor/102.1.201. hdl:10315/13797. - item-319 at level 5: list_item: ^ "If You Find An Orphaned Duckl ... l on 2018-09-23. Retrieved 2018-12-22. - item-320 at level 5: list_item: ^ Carver, Heather (2011). The Du ...  9780557901562.[self-published source] - item-321 at level 5: list_item: ^ Titlow, Budd (2013-09-03). Bir ... man & Littlefield. ISBN 9780762797707. - item-322 at level 5: list_item: ^ Amos, Jonathan (2003-09-08). " ... kers". BBC News. Retrieved 2006-11-02. - item-323 at level 5: list_item: ^ "Mythbusters Episode 8". 12 December 2003. - item-324 at level 5: list_item: ^ Erlandson 1994, p. 171. - item-325 at level 5: list_item: ^ Jeffries 2008, pp. 168, 243. - item-326 at level 5: list_item: ^ a b Sued-Badillo 2003, p. 65. - item-327 at level 5: list_item: ^ Thorpe 1996, p. 68. - item-328 at level 5: list_item: ^ Maisels 1999, p. 42. - item-329 at level 5: list_item: ^ Rau 1876, p. 133. - item-330 at level 5: list_item: ^ Higman 2012, p. 23. - item-331 at level 5: list_item: ^ Hume 2012, p. 53. - item-332 at level 5: list_item: ^ Hume 2012, p. 52. - item-333 at level 5: list_item: ^ Fieldhouse 2002, p. 167. - item-334 at level 5: list_item: ^ Livingston, A. D. (1998-01-01) ... Editions, Limited. ISBN 9781853263774. - item-335 at level 5: list_item: ^ "Study plan for waterfowl inju ... on 2022-10-09. Retrieved 2 July 2019. - item-336 at level 5: list_item: ^ "FAOSTAT". www.fao.org. Retrieved 2019-10-25. - item-337 at level 5: list_item: ^ "Anas platyrhynchos, Domestic ... . Digimorph.org. Retrieved 2012-12-23. - item-338 at level 5: list_item: ^ Sy Montgomery. "Mallard; Encyc ... Britannica.com. Retrieved 2012-12-23. - item-339 at level 5: list_item: ^ Glenday, Craig (2014). Guinnes ... ited. pp. 135. ISBN 978-1-908843-15-9. - item-340 at level 5: list_item: ^ Suomen kunnallisvaakunat (in F ... tto. 1982. p. 147. ISBN 951-773-085-3. - item-341 at level 5: list_item: ^ "Lubānas simbolika" (in Latvian). Retrieved September 9, 2021. - item-342 at level 5: list_item: ^ "Föglö" (in Swedish). Retrieved September 9, 2021. - item-343 at level 5: list_item: ^ Young, Emma. "World's funniest ... w Scientist. Retrieved 7 January 2019. - item-344 at level 5: list_item: ^ "Howard the Duck (character)". Grand Comics Database. - item-345 at level 5: list_item: ^ Sanderson, Peter; Gilbert, Lau ... luding this bad-tempered talking duck. - item-346 at level 5: list_item: ^ "The Duck". University of Oregon Athletics. Retrieved 2022-01-20. - item-347 at level 3: section_header: Sources - item-348 at level 4: list: group list - item-349 at level 5: list_item: American Ornithologists' Union ( ... (PDF) from the original on 2022-10-09. - item-350 at level 5: list_item: Carboneras, Carlos (1992). del H ... Lynx Edicions. ISBN 978-84-87334-10-8. - item-351 at level 5: list_item: Christidis, Les; Boles, Walter E ... ro Publishing. ISBN 978-0-643-06511-6. - item-352 at level 5: list_item: Donne-Goussé, Carole; Laudet, Vi ... /S1055-7903(02)00019-2. PMID 12099792. - item-353 at level 5: list_item: Elphick, Chris; Dunning, John B. ... istopher Helm. ISBN 978-0-7136-6250-4. - item-354 at level 5: list_item: Erlandson, Jon M. (1994). Early ... usiness Media. ISBN 978-1-4419-3231-0. - item-355 at level 5: list_item: Fieldhouse, Paul (2002). Food, F ... ara: ABC-CLIO. ISBN 978-1-61069-412-4. - item-356 at level 5: list_item: Fitter, Julian; Fitter, Daniel; ... versity Press. ISBN 978-0-691-10295-5. - item-357 at level 5: list_item: Higman, B. W. (2012). How Food M ... Wiley & Sons. ISBN 978-1-4051-8947-7. - item-358 at level 5: list_item: Hume, Julian H. (2012). Extinct ... istopher Helm. ISBN 978-1-4729-3744-5. - item-359 at level 5: list_item: Jeffries, Richard (2008). Holoce ... Alabama Press. ISBN 978-0-8173-1658-7. - item-360 at level 5: list_item: Kear, Janet, ed. (2005). Ducks, ... versity Press. ISBN 978-0-19-861009-0. - item-361 at level 5: list_item: Livezey, Bradley C. (October 198 ... (PDF) from the original on 2022-10-09. - item-362 at level 5: list_item: Madsen, Cort S.; McHugh, Kevin P ... (PDF) from the original on 2022-10-09. - item-363 at level 5: list_item: Maisels, Charles Keith (1999). E ... on: Routledge. ISBN 978-0-415-10975-8. - item-364 at level 5: list_item: Pratt, H. Douglas; Bruner, Phill ... University Press. ISBN 0-691-02399-9. - item-365 at level 5: list_item: Rau, Charles (1876). Early Man i ... ork: Harper & Brothers. LCCN 05040168. - item-366 at level 5: list_item: Shirihai, Hadoram (2008). A Comp ... versity Press. ISBN 978-0-691-13666-0. - item-367 at level 5: list_item: Sued-Badillo, Jalil (2003). Auto ... Paris: UNESCO. ISBN 978-92-3-103832-7. - item-368 at level 5: list_item: Thorpe, I. J. (1996). The Origin ... rk: Routledge. ISBN 978-0-415-08009-5. - item-369 at level 2: section_header: External links - item-370 at level 3: list: group list - item-371 at level 4: list_item: Definitions from Wiktionary - item-372 at level 4: list_item: Media from Commons - item-373 at level 4: list_item: Quotations from Wikiquote - item-374 at level 4: list_item: Recipes from Wikibooks - item-375 at level 4: list_item: Taxa from Wikispecies - item-376 at level 4: list_item: Data from Wikidata - item-377 at level 3: list: group list - item-378 at level 4: list_item: list of books (useful looking abstracts) - item-379 at level 4: list_item: Ducks on postage stamps Archived 2013-05-13 at the Wayback Machine - item-380 at level 4: list_item: Ducks at a Distance, by Rob Hine ... uide to identification of US waterfowl - item-381 at level 3: table with [3x2] - item-382 at level 3: picture - item-383 at level 3: text: Retrieved from "" - item-384 at level 3: text: : - item-385 at level 3: list: group list - item-386 at level 4: list_item: Ducks - item-387 at level 4: list_item: Game birds - item-388 at level 4: list_item: Bird common names - item-389 at level 3: text: Hidden categories: - item-390 at level 3: list: group list - item-391 at level 4: list_item: All accuracy disputes - item-392 at level 4: list_item: Accuracy disputes from February 2020 - item-393 at level 4: list_item: CS1 Finnish-language sources (fi) - item-394 at level 4: list_item: CS1 Latvian-language sources (lv) - item-395 at level 4: list_item: CS1 Swedish-language sources (sv) - item-396 at level 4: list_item: Articles with short description - item-397 at level 4: list_item: Short description is different from Wikidata - item-398 at level 4: list_item: Wikipedia indefinitely move-protected pages - item-399 at level 4: list_item: Wikipedia indefinitely semi-protected pages - item-400 at level 4: list_item: Articles with 'species' microformats - item-401 at level 4: list_item: Articles containing Old English (ca. 450-1100)-language text - item-402 at level 4: list_item: Articles containing Dutch-language text - item-403 at level 4: list_item: Articles containing German-language text - item-404 at level 4: list_item: Articles containing Norwegian-language text - item-405 at level 4: list_item: Articles containing Lithuanian-language text - item-406 at level 4: list_item: Articles containing Ancient Greek (to 1453)-language text - item-407 at level 4: list_item: All articles with self-published sources - item-408 at level 4: list_item: Articles with self-published sources from February 2020 - item-409 at level 4: list_item: All articles with unsourced statements - item-410 at level 4: list_item: Articles with unsourced statements from January 2022 - item-411 at level 4: list_item: CS1: long volume value - item-412 at level 4: list_item: Pages using Sister project links with wikidata mismatch - item-413 at level 4: list_item: Pages using Sister project links with hidden wikidata - item-414 at level 4: list_item: Webarchive template wayback links - item-415 at level 4: list_item: Articles with Project Gutenberg links - item-416 at level 4: list_item: Articles containing video clips - item-417 at level 3: list: group list - item-418 at level 4: list_item: This page was last edited on 21 September 2024, at 12:11 (UTC). - item-419 at level 4: list_item: Text is available under the Crea ... tion, Inc., a non-profit organization. - item-420 at level 3: list: group list - item-421 at level 4: list_item: Privacy policy - item-422 at level 4: list_item: About Wikipedia - item-423 at level 4: list_item: Disclaimers - item-424 at level 4: list_item: Contact Wikipedia - item-425 at level 4: list_item: Code of Conduct - item-426 at level 4: list_item: Developers - item-427 at level 4: list_item: Statistics - item-428 at level 4: list_item: Cookie statement - item-429 at level 4: list_item: Mobile view - item-430 at level 3: list: group list - item-431 at level 3: list: group list - item-432 at level 1: caption: Pacific black duck displaying the characteristic upending "duck" - item-433 at level 1: caption: Male mallard. - item-434 at level 1: caption: Wood ducks. - item-435 at level 1: caption: Mallard landing in approach - item-436 at level 1: caption: Male Mandarin duck - item-437 at level 1: caption: Flying steamer ducks in Ushuaia, Argentina - item-438 at level 1: caption: Female mallard in Cornwall, England - item-439 at level 1: caption: Pecten along the bill - item-440 at level 1: caption: Mallard duckling preening - item-441 at level 1: caption: A Muscovy duckling - item-442 at level 1: caption: Ringed teal - item-443 at level 1: caption: Indian Runner ducks, a common breed of domestic ducks - item-444 at level 1: caption: Three black-colored ducks in the coat of arms of Maaninka[49] \ No newline at end of file + item-1 at level 1: text: Jump to content + item-2 at level 1: text: Main menu + item-3 at level 1: text: Main menu + item-4 at level 1: text: move to sidebar + item-5 at level 1: text: hide + item-6 at level 1: text: Navigation + item-7 at level 1: list: group group + item-8 at level 2: list_item: Main page + item-9 at level 2: list_item: Contents + item-10 at level 2: list_item: Current events + item-11 at level 2: list_item: Random article + item-12 at level 2: list_item: About Wikipedia + item-13 at level 2: list_item: Contact us + item-14 at level 1: text: Contribute + item-15 at level 1: list: group group + item-16 at level 2: list_item: Help + item-17 at level 2: list_item: Learn to edit + item-18 at level 2: list_item: Community portal + item-19 at level 2: list_item: Recent changes + item-20 at level 2: list_item: Upload file + item-21 at level 1: text: Search + item-22 at level 1: text: Search + item-23 at level 1: list: group group + item-24 at level 1: list: group group + item-25 at level 2: list_item: Donate + item-26 at level 1: text: Appearance + item-27 at level 1: list: group group + item-28 at level 1: list: group group + item-29 at level 2: list_item: Create account + item-30 at level 2: list_item: Log in + item-31 at level 1: text: Personal tools + item-32 at level 1: list: group group + item-33 at level 2: list_item: Create account + item-34 at level 2: list_item: Log in + item-35 at level 1: text: Pages for logged out editors learn more + item-36 at level 1: list: group group + item-37 at level 2: list_item: Contributions + item-38 at level 2: list_item: Talk + item-39 at level 1: section_header: Contents + item-40 at level 1: text: move to sidebar + item-41 at level 1: text: hide + item-42 at level 1: list: group group + item-43 at level 2: list_item: (Top) + item-44 at level 2: list_item: 1 Etymology + item-45 at level 2: list: group group + item-46 at level 2: list_item: 2 Taxonomy + item-47 at level 2: list: group group + item-48 at level 2: list_item: 3 Morphology + item-49 at level 2: list: group group + item-50 at level 2: list_item: 4 Distribution and habitat + item-51 at level 2: list: group group + item-52 at level 2: list_item: 5 Behaviour Toggle Behaviour sub ... eeding 5.3 Communication 5.4 Predators + item-53 at level 2: list: group group + item-54 at level 3: list_item: 5.1 Feeding + item-55 at level 3: list: group group + item-56 at level 3: list_item: 5.2 Breeding + item-57 at level 3: list: group group + item-58 at level 3: list_item: 5.3 Communication + item-59 at level 3: list: group group + item-60 at level 3: list_item: 5.4 Predators + item-61 at level 3: list: group group + item-62 at level 2: list_item: 6 Relationship with humans Toggl ... n 6.3 Heraldry 6.4 Cultural references + item-63 at level 2: list: group group + item-64 at level 3: list_item: 6.1 Hunting + item-65 at level 3: list: group group + item-66 at level 3: list_item: 6.2 Domestication + item-67 at level 3: list: group group + item-68 at level 3: list_item: 6.3 Heraldry + item-69 at level 3: list: group group + item-70 at level 3: list_item: 6.4 Cultural references + item-71 at level 3: list: group group + item-72 at level 2: list_item: 7 See also + item-73 at level 2: list: group group + item-74 at level 2: list_item: 8 Notes Toggle Notes subsection 8.1 Citations 8.2 Sources + item-75 at level 2: list: group group + item-76 at level 3: list_item: 8.1 Citations + item-77 at level 3: list: group group + item-78 at level 3: list_item: 8.2 Sources + item-79 at level 3: list: group group + item-80 at level 2: list_item: 9 External links + item-81 at level 2: list: group group + item-82 at level 1: text: Toggle the table of contents + item-83 at level 1: title: Duck + item-84 at level 1: text: 136 languages + item-85 at level 1: list: group group + item-86 at level 2: list_item: Acèh + item-87 at level 2: list_item: Afrikaans + item-88 at level 2: list_item: Alemannisch + item-89 at level 2: list_item: አማርኛ + item-90 at level 2: list_item: Ænglisc + item-91 at level 2: list_item: العربية + item-92 at level 2: list_item: Aragonés + item-93 at level 2: list_item: ܐܪܡܝܐ + item-94 at level 2: list_item: Armãneashti + item-95 at level 2: list_item: Asturianu + item-96 at level 2: list_item: Atikamekw + item-97 at level 2: list_item: Авар + item-98 at level 2: list_item: Aymar aru + item-99 at level 2: list_item: تۆرکجه + item-100 at level 2: list_item: Basa Bali + item-101 at level 2: list_item: বাংলা + item-102 at level 2: list_item: 閩南語 / Bân-lâm-gú + item-103 at level 2: list_item: Беларуская + item-104 at level 2: list_item: Беларуская (тарашкевіца) + item-105 at level 2: list_item: Bikol Central + item-106 at level 2: list_item: Български + item-107 at level 2: list_item: Brezhoneg + item-108 at level 2: list_item: Буряад + item-109 at level 2: list_item: Català + item-110 at level 2: list_item: Чӑвашла + item-111 at level 2: list_item: Čeština + item-112 at level 2: list_item: ChiShona + item-113 at level 2: list_item: Cymraeg + item-114 at level 2: list_item: Dagbanli + item-115 at level 2: list_item: Dansk + item-116 at level 2: list_item: Deitsch + item-117 at level 2: list_item: Deutsch + item-118 at level 2: list_item: डोटेली + item-119 at level 2: list_item: Ελληνικά + item-120 at level 2: list_item: Emiliàn e rumagnòl + item-121 at level 2: list_item: Español + item-122 at level 2: list_item: Esperanto + item-123 at level 2: list_item: Euskara + item-124 at level 2: list_item: فارسی + item-125 at level 2: list_item: Français + item-126 at level 2: list_item: Gaeilge + item-127 at level 2: list_item: Galego + item-128 at level 2: list_item: ГӀалгӀай + item-129 at level 2: list_item: 贛語 + item-130 at level 2: list_item: گیلکی + item-131 at level 2: list_item: 𐌲𐌿𐍄𐌹𐍃𐌺 + item-132 at level 2: list_item: गोंयची कोंकणी / Gõychi Konknni + item-133 at level 2: list_item: 客家語 / Hak-kâ-ngî + item-134 at level 2: list_item: 한국어 + item-135 at level 2: list_item: Hausa + item-136 at level 2: list_item: Հայերեն + item-137 at level 2: list_item: हिन्दी + item-138 at level 2: list_item: Hrvatski + item-139 at level 2: list_item: Ido + item-140 at level 2: list_item: Bahasa Indonesia + item-141 at level 2: list_item: Iñupiatun + item-142 at level 2: list_item: Íslenska + item-143 at level 2: list_item: Italiano + item-144 at level 2: list_item: עברית + item-145 at level 2: list_item: Jawa + item-146 at level 2: list_item: ಕನ್ನಡ + item-147 at level 2: list_item: Kapampangan + item-148 at level 2: list_item: ქართული + item-149 at level 2: list_item: कॉशुर / کٲشُر + item-150 at level 2: list_item: Қазақша + item-151 at level 2: list_item: Ikirundi + item-152 at level 2: list_item: Kongo + item-153 at level 2: list_item: Kreyòl ayisyen + item-154 at level 2: list_item: Кырык мары + item-155 at level 2: list_item: ລາວ + item-156 at level 2: list_item: Latina + item-157 at level 2: list_item: Latviešu + item-158 at level 2: list_item: Lietuvių + item-159 at level 2: list_item: Li Niha + item-160 at level 2: list_item: Ligure + item-161 at level 2: list_item: Limburgs + item-162 at level 2: list_item: Lingála + item-163 at level 2: list_item: Malagasy + item-164 at level 2: list_item: മലയാളം + item-165 at level 2: list_item: मराठी + item-166 at level 2: list_item: مازِرونی + item-167 at level 2: list_item: Bahasa Melayu + item-168 at level 2: list_item: ꯃꯤꯇꯩ ꯂꯣꯟ + item-169 at level 2: list_item: 閩東語 / Mìng-dĕ̤ng-ngṳ̄ + item-170 at level 2: list_item: Мокшень + item-171 at level 2: list_item: Монгол + item-172 at level 2: list_item: မြန်မာဘာသာ + item-173 at level 2: list_item: Nederlands + item-174 at level 2: list_item: Nedersaksies + item-175 at level 2: list_item: नेपाली + item-176 at level 2: list_item: नेपाल भाषा + item-177 at level 2: list_item: 日本語 + item-178 at level 2: list_item: Нохчийн + item-179 at level 2: list_item: Norsk nynorsk + item-180 at level 2: list_item: Occitan + item-181 at level 2: list_item: Oromoo + item-182 at level 2: list_item: ਪੰਜਾਬੀ + item-183 at level 2: list_item: Picard + item-184 at level 2: list_item: Plattdüütsch + item-185 at level 2: list_item: Polski + item-186 at level 2: list_item: Português + item-187 at level 2: list_item: Qırımtatarca + item-188 at level 2: list_item: Română + item-189 at level 2: list_item: Русский + item-190 at level 2: list_item: Саха тыла + item-191 at level 2: list_item: ᱥᱟᱱᱛᱟᱲᱤ + item-192 at level 2: list_item: Sardu + item-193 at level 2: list_item: Scots + item-194 at level 2: list_item: Seeltersk + item-195 at level 2: list_item: Shqip + item-196 at level 2: list_item: Sicilianu + item-197 at level 2: list_item: සිංහල + item-198 at level 2: list_item: Simple English + item-199 at level 2: list_item: سنڌي + item-200 at level 2: list_item: کوردی + item-201 at level 2: list_item: Српски / srpski + item-202 at level 2: list_item: Srpskohrvatski / српскохрватски + item-203 at level 2: list_item: Sunda + item-204 at level 2: list_item: Svenska + item-205 at level 2: list_item: Tagalog + item-206 at level 2: list_item: தமிழ் + item-207 at level 2: list_item: Taqbaylit + item-208 at level 2: list_item: Татарча / tatarça + item-209 at level 2: list_item: ไทย + item-210 at level 2: list_item: Türkçe + item-211 at level 2: list_item: Українська + item-212 at level 2: list_item: ئۇيغۇرچە / Uyghurche + item-213 at level 2: list_item: Vahcuengh + item-214 at level 2: list_item: Tiếng Việt + item-215 at level 2: list_item: Walon + item-216 at level 2: list_item: 文言 + item-217 at level 2: list_item: Winaray + item-218 at level 2: list_item: 吴语 + item-219 at level 2: list_item: 粵語 + item-220 at level 2: list_item: Žemaitėška + item-221 at level 2: list_item: 中文 + item-222 at level 1: text: Edit links + item-223 at level 1: list: group group + item-224 at level 2: list_item: Article + item-225 at level 2: list_item: Talk + item-226 at level 1: text: English + item-227 at level 1: list: group group + item-228 at level 1: list: group group + item-229 at level 2: list_item: Read + item-230 at level 2: list_item: View source + item-231 at level 2: list_item: View history + item-232 at level 1: text: Tools + item-233 at level 1: text: Tools + item-234 at level 1: text: move to sidebar + item-235 at level 1: text: hide + item-236 at level 1: text: Actions + item-237 at level 1: list: group group + item-238 at level 2: list_item: Read + item-239 at level 2: list_item: View source + item-240 at level 2: list_item: View history + item-241 at level 1: text: General + item-242 at level 1: list: group group + item-243 at level 2: list_item: What links here + item-244 at level 2: list_item: Related changes + item-245 at level 2: list_item: Upload file + item-246 at level 2: list_item: Special pages + item-247 at level 2: list_item: Permanent link + item-248 at level 2: list_item: Page information + item-249 at level 2: list_item: Cite this page + item-250 at level 2: list_item: Get shortened URL + item-251 at level 2: list_item: Download QR code + item-252 at level 2: list_item: Wikidata item + item-253 at level 1: text: Print/export + item-254 at level 1: list: group group + item-255 at level 2: list_item: Download as PDF + item-256 at level 2: list_item: Printable version + item-257 at level 1: text: In other projects + item-258 at level 1: list: group group + item-259 at level 2: list_item: Wikimedia Commons + item-260 at level 2: list_item: Wikiquote + item-261 at level 1: text: Appearance + item-262 at level 1: text: move to sidebar + item-263 at level 1: text: hide + item-264 at level 1: text: From Wikipedia, the free encyclopedia + item-265 at level 1: text: (Redirected from Duckling) + item-266 at level 1: text: Common name for many species of bird + item-267 at level 1: text: This article is about the bird. ... other uses, see Duck (disambiguation). + item-268 at level 1: text: "Duckling" redirects here. For other uses, see Duckling (disambiguation). + item-269 at level 1: table with [13x2] + item-270 at level 1: text: Duck is the common name for nume ... und in both fresh water and sea water. + item-271 at level 1: text: Ducks are sometimes confused wit ... divers, grebes, gallinules and coots. + item-272 at level 1: section_header: Etymology + item-273 at level 1: text: The word duck comes from Old Eng ... h duiken and German tauchen 'to dive'. + item-274 at level 1: text: Pacific black duck displaying the characteristic upending "duck" + item-275 at level 1: text: This word replaced Old English e ... nskrit ātí 'water bird', among others. + item-276 at level 1: text: A duckling is a young duck in do ... , is sometimes labelled as a duckling. + item-277 at level 1: text: A male is called a drake and the ... a duck, or in ornithology a hen.[3][4] + item-278 at level 1: text: Male mallard. + item-279 at level 1: text: Wood ducks. + item-280 at level 1: section_header: Taxonomy + item-281 at level 1: text: All ducks belong to the biologic ... ationships between various species.[9] + item-282 at level 1: text: Mallard landing in approach + item-283 at level 1: text: In most modern classifications, ... all size and stiff, upright tails.[14] + item-284 at level 1: text: A number of other species called ... shelducks in the tribe Tadornini.[15] + item-285 at level 1: section_header: Morphology + item-286 at level 1: text: Male Mandarin duck + item-287 at level 1: text: The overall body plan of ducks i ... is moult typically precedes migration. + item-288 at level 1: text: The drakes of northern species o ... rkscrew shaped vagina to prevent rape. + item-289 at level 1: section_header: Distribution and habitat + item-290 at level 1: text: See also: List of Anseriformes by population + item-291 at level 1: text: Flying steamer ducks in Ushuaia, Argentina + item-292 at level 1: text: Ducks have a cosmopolitan distri ... endemic to such far-flung islands.[21] + item-293 at level 1: text: Female mallard in Cornwall, England + item-294 at level 1: text: Some duck species, mainly those ... t form after localised heavy rain.[23] + item-295 at level 1: section_header: Behaviour + item-296 at level 1: section_header: Feeding + item-297 at level 1: text: Pecten along the bill + item-298 at level 1: text: Mallard duckling preening + item-299 at level 1: text: Ducks eat food sources such as g ... amphibians, worms, and small molluscs. + item-300 at level 1: text: Dabbling ducks feed on the surfa ... thers and to hold slippery food items. + item-301 at level 1: text: Diving ducks and sea ducks forag ... ave more difficulty taking off to fly. + item-302 at level 1: text: A few specialized species such a ... apted to catch and swallow large fish. + item-303 at level 1: text: The others have the characterist ... e nostrils come out through hard horn. + item-304 at level 1: text: The Guardian published an articl ... the ducks and pollutes waterways.[25] + item-305 at level 1: section_header: Breeding + item-306 at level 1: text: A Muscovy duckling + item-307 at level 1: text: Ducks generally only have one pa ... st and led her ducklings to water.[28] + item-308 at level 1: section_header: Communication + item-309 at level 1: text: Female mallard ducks (as well as ... laying calls or quieter contact calls. + item-310 at level 1: text: A common urban legend claims tha ... annel television show MythBusters.[32] + item-311 at level 1: section_header: Predators + item-312 at level 1: text: Ringed teal + item-313 at level 1: text: Ducks have many predators. Duckl ... or large birds, such as hawks or owls. + item-314 at level 1: text: Adult ducks are fast fliers, but ... its speed and strength to catch ducks. + item-315 at level 1: section_header: Relationship with humans + item-316 at level 1: section_header: Hunting + item-317 at level 1: text: Main article: Waterfowl hunting + item-318 at level 1: text: Humans have hunted ducks since p ... evidence of this is uncommon.[35][42] + item-319 at level 1: text: In many areas, wild ducks (inclu ... inated by pollutants such as PCBs.[44] + item-320 at level 1: section_header: Domestication + item-321 at level 1: text: Main article: Domestic duck + item-322 at level 1: text: Indian Runner ducks, a common breed of domestic ducks + item-323 at level 1: text: Ducks have many economic uses, b ... it weighs less than 1 kg (2.2 lb).[48] + item-324 at level 1: section_header: Heraldry + item-325 at level 1: text: Three black-colored ducks in the coat of arms of Maaninka[49] + item-326 at level 1: text: Ducks appear on several coats of ... the coat of arms of Föglö (Åland).[51] + item-327 at level 1: section_header: Cultural references + item-328 at level 1: text: In 2002, psychologist Richard Wi ... 54] and was made into a movie in 1986. + item-329 at level 1: text: The 1992 Disney film The Mighty ... Ducks minor league baseball team.[55] + item-330 at level 1: section_header: See also + item-331 at level 1: list: group group + item-332 at level 2: list_item: Birds portal + item-333 at level 1: list: group group + item-334 at level 2: list_item: Domestic duck + item-335 at level 2: list_item: Duck as food + item-336 at level 2: list_item: Duck test + item-337 at level 2: list_item: Duck breeds + item-338 at level 2: list_item: Fictional ducks + item-339 at level 2: list_item: Rubber duck + item-340 at level 1: section_header: Notes + item-341 at level 1: section_header: Citations + item-342 at level 1: ordered_list: group group + item-343 at level 2: list_item: ^ "Duckling" . The American Heri ... Company. 2006 . Retrieved 2015-05-22 . + item-344 at level 2: list_item: ^ "Duckling" . Kernerman English ... td. 2000–2006 . Retrieved 2015-05-22 . + item-345 at level 2: list_item: ^ Dohner, Janet Vorwald (2001). ... niversity Press. ISBN 978-0300138139 . + item-346 at level 2: list_item: ^ Visca, Curt; Visca, Kelley (20 ... Publishing Group. ISBN 9780823961566 . + item-347 at level 2: list_item: ^ a b c d Carboneras 1992 , p. 536. + item-348 at level 2: list_item: ^ Livezey 1986 , pp. 737–738. + item-349 at level 2: list_item: ^ Madsen, McHugh & de Kloet 1988 , p. 452. + item-350 at level 2: list_item: ^ Donne-Goussé, Laudet & Hänni 2002 , pp. 353–354. + item-351 at level 2: list_item: ^ a b c d e f Carboneras 1992 , p. 540. + item-352 at level 2: list_item: ^ Elphick, Dunning & Sibley 2001 , p. 191. + item-353 at level 2: list_item: ^ Kear 2005 , p. 448. + item-354 at level 2: list_item: ^ Kear 2005 , p. 622–623. + item-355 at level 2: list_item: ^ Kear 2005 , p. 686. + item-356 at level 2: list_item: ^ Elphick, Dunning & Sibley 2001 , p. 193. + item-357 at level 2: list_item: ^ a b c d e f g Carboneras 1992 , p. 537. + item-358 at level 2: list_item: ^ American Ornithologists' Union 1998 , p. xix. + item-359 at level 2: list_item: ^ American Ornithologists' Union 1998 . + item-360 at level 2: list_item: ^ Carboneras 1992 , p. 538. + item-361 at level 2: list_item: ^ Christidis & Boles 2008 , p. 62. + item-362 at level 2: list_item: ^ Shirihai 2008 , pp. 239, 245. + item-363 at level 2: list_item: ^ a b Pratt, Bruner & Berrett 1987 , pp. 98–107. + item-364 at level 2: list_item: ^ Fitter, Fitter & Hosking 2000 , pp. 52–3. + item-365 at level 2: list_item: ^ "Pacific Black Duck" . www.wiresnr.org . Retrieved 2018-04-27 . + item-366 at level 2: list_item: ^ Ogden, Evans. "Dabbling Ducks" . CWE . Retrieved 2006-11-02 . + item-367 at level 2: list_item: ^ Karl Mathiesen (16 March 2015) ... uardian . Retrieved 13 November 2016 . + item-368 at level 2: list_item: ^ Rohwer, Frank C.; Anderson, Mi ... 15-6787-5_4 . ISBN 978-1-4615-6789-9 . + item-369 at level 2: list_item: ^ Smith, Cyndi M.; Cooke, Fred; ... condor/102.1.201 . hdl : 10315/13797 . + item-370 at level 2: list_item: ^ "If You Find An Orphaned Duckl ... on 2018-09-23 . Retrieved 2018-12-22 . + item-371 at level 2: list_item: ^ Carver, Heather (2011). The Du ... 0557901562 . [ self-published source ] + item-372 at level 2: list_item: ^ Titlow, Budd (2013-09-03). Bir ... an & Littlefield. ISBN 9780762797707 . + item-373 at level 2: list_item: ^ Amos, Jonathan (2003-09-08). " ... s" . BBC News . Retrieved 2006-11-02 . + item-374 at level 2: list_item: ^ "Mythbusters Episode 8" . 12 December 2003. + item-375 at level 2: list_item: ^ Erlandson 1994 , p. 171. + item-376 at level 2: list_item: ^ Jeffries 2008 , pp. 168, 243. + item-377 at level 2: list_item: ^ a b Sued-Badillo 2003 , p. 65. + item-378 at level 2: list_item: ^ Thorpe 1996 , p. 68. + item-379 at level 2: list_item: ^ Maisels 1999 , p. 42. + item-380 at level 2: list_item: ^ Rau 1876 , p. 133. + item-381 at level 2: list_item: ^ Higman 2012 , p. 23. + item-382 at level 2: list_item: ^ Hume 2012 , p. 53. + item-383 at level 2: list_item: ^ Hume 2012 , p. 52. + item-384 at level 2: list_item: ^ Fieldhouse 2002 , p. 167. + item-385 at level 2: list_item: ^ Livingston, A. D. (1998-01-01) ... ditions, Limited. ISBN 9781853263774 . + item-386 at level 2: list_item: ^ "Study plan for waterfowl inju ... n 2022-10-09 . Retrieved 2 July 2019 . + item-387 at level 2: list_item: ^ "FAOSTAT" . www.fao.org . Retrieved 2019-10-25 . + item-388 at level 2: list_item: ^ "Anas platyrhynchos, Domestic ... Digimorph.org . Retrieved 2012-12-23 . + item-389 at level 2: list_item: ^ Sy Montgomery. "Mallard; Encyc ... ritannica.com . Retrieved 2012-12-23 . + item-390 at level 2: list_item: ^ Glenday, Craig (2014). Guinnes ... ed. pp. 135 . ISBN 978-1-908843-15-9 . + item-391 at level 2: list_item: ^ Suomen kunnallisvaakunat (in F ... to. 1982. p. 147. ISBN 951-773-085-3 . + item-392 at level 2: list_item: ^ "Lubānas simbolika" (in Latvian) . Retrieved September 9, 2021 . + item-393 at level 2: list_item: ^ "Föglö" (in Swedish) . Retrieved September 9, 2021 . + item-394 at level 2: list_item: ^ Young, Emma. "World's funniest ... Scientist . Retrieved 7 January 2019 . + item-395 at level 2: list_item: ^ "Howard the Duck (character)" . Grand Comics Database . + item-396 at level 2: list_item: ^ Sanderson, Peter ; Gilbert, La ... luding this bad-tempered talking duck. + item-397 at level 2: list_item: ^ "The Duck" . University of Oregon Athletics . Retrieved 2022-01-20 . + item-398 at level 1: section_header: Sources + item-399 at level 1: list: group group + item-400 at level 2: list_item: American Ornithologists' Union ( ... (PDF) from the original on 2022-10-09. + item-401 at level 2: list_item: Carboneras, Carlos (1992). del H ... ynx Edicions. ISBN 978-84-87334-10-8 . + item-402 at level 2: list_item: Christidis, Les; Boles, Walter E ... o Publishing. ISBN 978-0-643-06511-6 . + item-403 at level 2: list_item: Donne-Goussé, Carole; Laudet, Vi ... 1055-7903(02)00019-2 . PMID 12099792 . + item-404 at level 2: list_item: Elphick, Chris; Dunning, John B. ... stopher Helm. ISBN 978-0-7136-6250-4 . + item-405 at level 2: list_item: Erlandson, Jon M. (1994). Early ... siness Media. ISBN 978-1-4419-3231-0 . + item-406 at level 2: list_item: Fieldhouse, Paul (2002). Food, F ... ra: ABC-CLIO. ISBN 978-1-61069-412-4 . + item-407 at level 2: list_item: Fitter, Julian; Fitter, Daniel; ... ersity Press. ISBN 978-0-691-10295-5 . + item-408 at level 2: list_item: Higman, B. W. (2012). How Food M ... Wiley & Sons. ISBN 978-1-4051-8947-7 . + item-409 at level 2: list_item: Hume, Julian H. (2012). Extinct ... stopher Helm. ISBN 978-1-4729-3744-5 . + item-410 at level 2: list_item: Jeffries, Richard (2008). Holoce ... labama Press. ISBN 978-0-8173-1658-7 . + item-411 at level 2: list_item: Kear, Janet, ed. (2005). Ducks, ... ersity Press. ISBN 978-0-19-861009-0 . + item-412 at level 2: list_item: Livezey, Bradley C. (October 198 ... (PDF) from the original on 2022-10-09. + item-413 at level 2: list_item: Madsen, Cort S.; McHugh, Kevin P ... (PDF) from the original on 2022-10-09. + item-414 at level 2: list_item: Maisels, Charles Keith (1999). E ... n: Routledge. ISBN 978-0-415-10975-8 . + item-415 at level 2: list_item: Pratt, H. Douglas; Bruner, Phill ... University Press. ISBN 0-691-02399-9 . + item-416 at level 2: list_item: Rau, Charles (1876). Early Man i ... rk: Harper & Brothers. LCCN 05040168 . + item-417 at level 2: list_item: Shirihai, Hadoram (2008). A Comp ... ersity Press. ISBN 978-0-691-13666-0 . + item-418 at level 2: list_item: Sued-Badillo, Jalil (2003). Auto ... aris: UNESCO. ISBN 978-92-3-103832-7 . + item-419 at level 2: list_item: Thorpe, I. J. (1996). The Origin ... k: Routledge. ISBN 978-0-415-08009-5 . + item-420 at level 1: section_header: External links + item-421 at level 1: text: Duck at Wikipedia's sister projects + item-422 at level 1: list: group group + item-423 at level 2: list_item: Definitions from Wiktionary + item-424 at level 2: list_item: Media from Commons + item-425 at level 2: list_item: Quotations from Wikiquote + item-426 at level 2: list_item: Recipes from Wikibooks + item-427 at level 2: list_item: Taxa from Wikispecies + item-428 at level 2: list_item: Data from Wikidata + item-429 at level 1: list: group group + item-430 at level 2: list_item: list of books (useful looking abstracts) + item-431 at level 2: list_item: Ducks on postage stamps Archived 2013-05-13 at the Wayback Machine + item-432 at level 2: list_item: + item-433 at level 2: list_item: Ducks at a Distance, by Rob Hine ... uide to identification of US waterfowl + item-434 at level 1: table with [3x2] + item-435 at level 1: text: NewPP limit report + item-436 at level 1: text: Parsed by mw‐web.codfw.main‐5d5b97b956‐mw5gf + item-437 at level 1: text: Cached time: 20241001035144 + item-438 at level 1: text: Cache expiry: 2592000 + item-439 at level 1: text: Reduced expiry: false + item-440 at level 1: text: Complications: [vary‐revision‐sha1, show‐toc] + item-441 at level 1: text: CPU time usage: 1.191 seconds + item-442 at level 1: text: Real time usage: 1.452 seconds + item-443 at level 1: text: Preprocessor visited node count: 12444/1000000 + item-444 at level 1: text: Post‐expand include size: 122530/2097152 bytes + item-445 at level 1: text: Template argument size: 9168/2097152 bytes + item-446 at level 1: text: Highest expansion depth: 14/100 + item-447 at level 1: text: Expensive parser function count: 14/500 + item-448 at level 1: text: Unstrip recursion depth: 1/20 + item-449 at level 1: text: Unstrip post‐expand size: 165576/5000000 bytes + item-450 at level 1: text: Lua time usage: 0.865/10.000 seconds + item-451 at level 1: text: Lua memory usage: 25093454/52428800 bytes + item-452 at level 1: text: Number of Wikibase entities loaded: 1/400 + item-453 at level 1: text: Transclusion expansion time report (%,ms,calls,template) + item-454 at level 1: text: 100.00% 1311.889 1 -total + item-455 at level 1: text: 22.17% 290.786 1 Template:Automatic_taxobox + item-456 at level 1: text: 16.91% 221.802 1 Template:Reflist + item-457 at level 1: text: 10.86% 142.472 44 Template:Sfn + item-458 at level 1: text: 9.48% 124.344 15 Template:Lang + item-459 at level 1: text: 9.25% 121.312 15 Template:Cite_web + item-460 at level 1: text: 8.03% 105.346 26 Template:Cite_book + item-461 at level 1: text: 5.85% 76.725 1 Template:Short_description + item-462 at level 1: text: 5.74% 75.262 1 Template:Authority_control + item-463 at level 1: text: 4.50% 58.973 1 Template:Sisterlinks + item-464 at level 1: text: Saved in parser cache with key e ... ering was triggered because: page-view + item-465 at level 1: text: esi + item-466 at level 1: text: Retrieved from "https://en.wikip ... index.php?title=Duck&oldid=1246843351" + item-467 at level 1: text: Categories: + item-468 at level 1: list: group group + item-469 at level 2: list_item: Ducks + item-470 at level 2: list_item: Game birds + item-471 at level 2: list_item: Bird common names + item-472 at level 1: text: Hidden categories: + item-473 at level 1: list: group group + item-474 at level 2: list_item: All accuracy disputes + item-475 at level 2: list_item: Accuracy disputes from February 2020 + item-476 at level 2: list_item: CS1 Finnish-language sources (fi) + item-477 at level 2: list_item: CS1 Latvian-language sources (lv) + item-478 at level 2: list_item: CS1 Swedish-language sources (sv) + item-479 at level 2: list_item: Articles with short description + item-480 at level 2: list_item: Short description is different from Wikidata + item-481 at level 2: list_item: Wikipedia indefinitely move-protected pages + item-482 at level 2: list_item: Wikipedia indefinitely semi-protected pages + item-483 at level 2: list_item: Articles with 'species' microformats + item-484 at level 2: list_item: Articles containing Old English (ca. 450-1100)-language text + item-485 at level 2: list_item: Articles containing Dutch-language text + item-486 at level 2: list_item: Articles containing German-language text + item-487 at level 2: list_item: Articles containing Norwegian-language text + item-488 at level 2: list_item: Articles containing Lithuanian-language text + item-489 at level 2: list_item: Articles containing Ancient Greek (to 1453)-language text + item-490 at level 2: list_item: All articles with self-published sources + item-491 at level 2: list_item: Articles with self-published sources from February 2020 + item-492 at level 2: list_item: All articles with unsourced statements + item-493 at level 2: list_item: Articles with unsourced statements from January 2022 + item-494 at level 2: list_item: CS1: long volume value + item-495 at level 2: list_item: Pages using Sister project links with wikidata mismatch + item-496 at level 2: list_item: Pages using Sister project links with hidden wikidata + item-497 at level 2: list_item: Webarchive template wayback links + item-498 at level 2: list_item: Articles with Project Gutenberg links + item-499 at level 2: list_item: Articles containing video clips + item-500 at level 1: list: group group + item-501 at level 2: list_item: This page was last edited on 21 September 2024, at 12:11 (UTC) . + item-502 at level 2: list_item: Text is available under the Crea ... ion, Inc. , a non-profit organization. + item-503 at level 1: list: group group + item-504 at level 2: list_item: Privacy policy + item-505 at level 2: list_item: About Wikipedia + item-506 at level 2: list_item: Disclaimers + item-507 at level 2: list_item: Contact Wikipedia + item-508 at level 2: list_item: Code of Conduct + item-509 at level 2: list_item: Developers + item-510 at level 2: list_item: Statistics + item-511 at level 2: list_item: Cookie statement + item-512 at level 2: list_item: Mobile view + item-513 at level 1: list: group group + item-514 at level 2: list_item: + item-515 at level 2: list_item: + item-516 at level 1: list: group group \ No newline at end of file diff --git a/tests/data/groundtruth/docling_v2/wiki_duck.html.json b/tests/data/groundtruth/docling_v2/wiki_duck.html.json index 1e5afdf3..a7539fac 100644 --- a/tests/data/groundtruth/docling_v2/wiki_duck.html.json +++ b/tests/data/groundtruth/docling_v2/wiki_duck.html.json @@ -23,23 +23,32 @@ { "$ref": "#/texts/1" }, + { + "$ref": "#/texts/2" + }, + { + "$ref": "#/texts/3" + }, + { + "$ref": "#/texts/4" + }, + { + "$ref": "#/texts/5" + }, { "$ref": "#/groups/0" }, { - "$ref": "#/texts/8" + "$ref": "#/texts/12" }, { "$ref": "#/groups/1" }, { - "$ref": "#/pictures/0" + "$ref": "#/texts/18" }, { - "$ref": "#/pictures/1" - }, - { - "$ref": "#/pictures/2" + "$ref": "#/texts/19" }, { "$ref": "#/groups/2" @@ -47,65 +56,467 @@ { "$ref": "#/groups/3" }, + { + "$ref": "#/texts/21" + }, { "$ref": "#/groups/4" }, { "$ref": "#/groups/5" }, + { + "$ref": "#/texts/24" + }, { "$ref": "#/groups/6" }, { - "$ref": "#/texts/19" + "$ref": "#/texts/27" }, { "$ref": "#/groups/7" }, + { + "$ref": "#/texts/30" + }, + { + "$ref": "#/texts/31" + }, + { + "$ref": "#/texts/32" + }, { "$ref": "#/groups/8" }, { - "$ref": "#/texts/43" + "$ref": "#/texts/53" }, { - "$ref": "#/texts/216" + "$ref": "#/texts/54" }, { - "$ref": "#/texts/220" + "$ref": "#/texts/55" + }, + { + "$ref": "#/groups/28" + }, + { + "$ref": "#/texts/192" + }, + { + "$ref": "#/groups/29" + }, + { + "$ref": "#/texts/195" + }, + { + "$ref": "#/groups/30" + }, + { + "$ref": "#/groups/31" + }, + { + "$ref": "#/texts/199" + }, + { + "$ref": "#/texts/200" + }, + { + "$ref": "#/texts/201" + }, + { + "$ref": "#/texts/202" + }, + { + "$ref": "#/texts/203" + }, + { + "$ref": "#/groups/32" + }, + { + "$ref": "#/texts/207" + }, + { + "$ref": "#/groups/33" + }, + { + "$ref": "#/texts/218" + }, + { + "$ref": "#/groups/34" }, { "$ref": "#/texts/221" }, + { + "$ref": "#/groups/35" + }, { "$ref": "#/texts/224" }, + { + "$ref": "#/texts/225" + }, + { + "$ref": "#/texts/226" + }, + { + "$ref": "#/texts/227" + }, { "$ref": "#/texts/228" }, + { + "$ref": "#/texts/229" + }, + { + "$ref": "#/texts/230" + }, + { + "$ref": "#/texts/231" + }, + { + "$ref": "#/tables/0" + }, { "$ref": "#/texts/232" }, + { + "$ref": "#/texts/233" + }, { "$ref": "#/texts/234" }, + { + "$ref": "#/texts/235" + }, + { + "$ref": "#/texts/236" + }, + { + "$ref": "#/texts/237" + }, { "$ref": "#/texts/238" }, { "$ref": "#/texts/239" }, + { + "$ref": "#/texts/240" + }, + { + "$ref": "#/texts/241" + }, + { + "$ref": "#/texts/242" + }, + { + "$ref": "#/texts/243" + }, + { + "$ref": "#/texts/244" + }, + { + "$ref": "#/texts/245" + }, + { + "$ref": "#/texts/246" + }, { "$ref": "#/texts/247" }, + { + "$ref": "#/texts/248" + }, + { + "$ref": "#/texts/249" + }, + { + "$ref": "#/texts/250" + }, + { + "$ref": "#/texts/251" + }, + { + "$ref": "#/texts/252" + }, { "$ref": "#/texts/253" }, + { + "$ref": "#/texts/254" + }, + { + "$ref": "#/texts/255" + }, + { + "$ref": "#/texts/256" + }, + { + "$ref": "#/texts/257" + }, + { + "$ref": "#/texts/258" + }, + { + "$ref": "#/texts/259" + }, + { + "$ref": "#/texts/260" + }, { "$ref": "#/texts/261" }, + { + "$ref": "#/texts/262" + }, + { + "$ref": "#/texts/263" + }, { "$ref": "#/texts/264" + }, + { + "$ref": "#/texts/265" + }, + { + "$ref": "#/texts/266" + }, + { + "$ref": "#/texts/267" + }, + { + "$ref": "#/texts/268" + }, + { + "$ref": "#/texts/269" + }, + { + "$ref": "#/texts/270" + }, + { + "$ref": "#/texts/271" + }, + { + "$ref": "#/texts/272" + }, + { + "$ref": "#/texts/273" + }, + { + "$ref": "#/texts/274" + }, + { + "$ref": "#/texts/275" + }, + { + "$ref": "#/texts/276" + }, + { + "$ref": "#/texts/277" + }, + { + "$ref": "#/texts/278" + }, + { + "$ref": "#/texts/279" + }, + { + "$ref": "#/texts/280" + }, + { + "$ref": "#/texts/281" + }, + { + "$ref": "#/texts/282" + }, + { + "$ref": "#/texts/283" + }, + { + "$ref": "#/texts/284" + }, + { + "$ref": "#/texts/285" + }, + { + "$ref": "#/texts/286" + }, + { + "$ref": "#/texts/287" + }, + { + "$ref": "#/texts/288" + }, + { + "$ref": "#/texts/289" + }, + { + "$ref": "#/texts/290" + }, + { + "$ref": "#/texts/291" + }, + { + "$ref": "#/texts/292" + }, + { + "$ref": "#/groups/36" + }, + { + "$ref": "#/groups/37" + }, + { + "$ref": "#/texts/300" + }, + { + "$ref": "#/texts/301" + }, + { + "$ref": "#/groups/38" + }, + { + "$ref": "#/texts/357" + }, + { + "$ref": "#/groups/39" + }, + { + "$ref": "#/texts/378" + }, + { + "$ref": "#/texts/379" + }, + { + "$ref": "#/groups/40" + }, + { + "$ref": "#/groups/41" + }, + { + "$ref": "#/tables/1" + }, + { + "$ref": "#/texts/390" + }, + { + "$ref": "#/texts/391" + }, + { + "$ref": "#/texts/392" + }, + { + "$ref": "#/texts/393" + }, + { + "$ref": "#/texts/394" + }, + { + "$ref": "#/texts/395" + }, + { + "$ref": "#/texts/396" + }, + { + "$ref": "#/texts/397" + }, + { + "$ref": "#/texts/398" + }, + { + "$ref": "#/texts/399" + }, + { + "$ref": "#/texts/400" + }, + { + "$ref": "#/texts/401" + }, + { + "$ref": "#/texts/402" + }, + { + "$ref": "#/texts/403" + }, + { + "$ref": "#/texts/404" + }, + { + "$ref": "#/texts/405" + }, + { + "$ref": "#/texts/406" + }, + { + "$ref": "#/texts/407" + }, + { + "$ref": "#/texts/408" + }, + { + "$ref": "#/texts/409" + }, + { + "$ref": "#/texts/410" + }, + { + "$ref": "#/texts/411" + }, + { + "$ref": "#/texts/412" + }, + { + "$ref": "#/texts/413" + }, + { + "$ref": "#/texts/414" + }, + { + "$ref": "#/texts/415" + }, + { + "$ref": "#/texts/416" + }, + { + "$ref": "#/texts/417" + }, + { + "$ref": "#/texts/418" + }, + { + "$ref": "#/texts/419" + }, + { + "$ref": "#/texts/420" + }, + { + "$ref": "#/texts/421" + }, + { + "$ref": "#/texts/422" + }, + { + "$ref": "#/groups/42" + }, + { + "$ref": "#/texts/426" + }, + { + "$ref": "#/groups/43" + }, + { + "$ref": "#/groups/44" + }, + { + "$ref": "#/groups/45" + }, + { + "$ref": "#/groups/46" + }, + { + "$ref": "#/groups/47" } ], "content_layer": "body", @@ -119,27 +530,27 @@ "$ref": "#/body" }, "children": [ - { - "$ref": "#/texts/2" - }, - { - "$ref": "#/texts/3" - }, - { - "$ref": "#/texts/4" - }, - { - "$ref": "#/texts/5" - }, { "$ref": "#/texts/6" }, { "$ref": "#/texts/7" + }, + { + "$ref": "#/texts/8" + }, + { + "$ref": "#/texts/9" + }, + { + "$ref": "#/texts/10" + }, + { + "$ref": "#/texts/11" } ], - "content_layer": "furniture", - "name": "list", + "content_layer": "body", + "name": "group", "label": "list" }, { @@ -148,24 +559,24 @@ "$ref": "#/body" }, "children": [ - { - "$ref": "#/texts/9" - }, - { - "$ref": "#/texts/10" - }, - { - "$ref": "#/texts/11" - }, - { - "$ref": "#/texts/12" - }, { "$ref": "#/texts/13" + }, + { + "$ref": "#/texts/14" + }, + { + "$ref": "#/texts/15" + }, + { + "$ref": "#/texts/16" + }, + { + "$ref": "#/texts/17" } ], - "content_layer": "furniture", - "name": "list", + "content_layer": "body", + "name": "group", "label": "list" }, { @@ -174,8 +585,8 @@ "$ref": "#/body" }, "children": [], - "content_layer": "furniture", - "name": "list", + "content_layer": "body", + "name": "group", "label": "list" }, { @@ -185,11 +596,11 @@ }, "children": [ { - "$ref": "#/texts/14" + "$ref": "#/texts/20" } ], - "content_layer": "furniture", - "name": "list", + "content_layer": "body", + "name": "group", "label": "list" }, { @@ -198,8 +609,8 @@ "$ref": "#/body" }, "children": [], - "content_layer": "furniture", - "name": "list", + "content_layer": "body", + "name": "group", "label": "list" }, { @@ -209,14 +620,14 @@ }, "children": [ { - "$ref": "#/texts/15" + "$ref": "#/texts/22" }, { - "$ref": "#/texts/16" + "$ref": "#/texts/23" } ], - "content_layer": "furniture", - "name": "list", + "content_layer": "body", + "name": "group", "label": "list" }, { @@ -226,14 +637,14 @@ }, "children": [ { - "$ref": "#/texts/17" + "$ref": "#/texts/25" }, { - "$ref": "#/texts/18" + "$ref": "#/texts/26" } ], - "content_layer": "furniture", - "name": "list", + "content_layer": "body", + "name": "group", "label": "list" }, { @@ -243,14 +654,14 @@ }, "children": [ { - "$ref": "#/texts/20" + "$ref": "#/texts/28" }, { - "$ref": "#/texts/21" + "$ref": "#/texts/29" } ], - "content_layer": "furniture", - "name": "list", + "content_layer": "body", + "name": "group", "label": "list" }, { @@ -259,320 +670,327 @@ "$ref": "#/body" }, "children": [ - { - "$ref": "#/texts/22" - } - ], - "content_layer": "body", - "name": "header-1", - "label": "section" - }, - { - "self_ref": "#/groups/9", - "parent": { - "$ref": "#/texts/22" - }, - "children": [ - { - "$ref": "#/texts/23" - }, - { - "$ref": "#/texts/24" - }, - { - "$ref": "#/texts/25" - }, - { - "$ref": "#/texts/26" - }, - { - "$ref": "#/texts/27" - }, - { - "$ref": "#/texts/28" - }, { "$ref": "#/texts/33" }, - { - "$ref": "#/texts/38" - }, - { - "$ref": "#/texts/39" - }, - { - "$ref": "#/texts/42" - } - ], - "content_layer": "body", - "name": "list", - "label": "list" - }, - { - "self_ref": "#/groups/10", - "parent": { - "$ref": "#/texts/24" - }, - "children": [], - "content_layer": "body", - "name": "list", - "label": "list" - }, - { - "self_ref": "#/groups/11", - "parent": { - "$ref": "#/texts/25" - }, - "children": [], - "content_layer": "body", - "name": "list", - "label": "list" - }, - { - "self_ref": "#/groups/12", - "parent": { - "$ref": "#/texts/26" - }, - "children": [], - "content_layer": "body", - "name": "list", - "label": "list" - }, - { - "self_ref": "#/groups/13", - "parent": { - "$ref": "#/texts/27" - }, - "children": [], - "content_layer": "body", - "name": "list", - "label": "list" - }, - { - "self_ref": "#/groups/14", - "parent": { - "$ref": "#/texts/28" - }, - "children": [ - { - "$ref": "#/texts/29" - }, - { - "$ref": "#/texts/30" - }, - { - "$ref": "#/texts/31" - }, - { - "$ref": "#/texts/32" - } - ], - "content_layer": "body", - "name": "list", - "label": "list" - }, - { - "self_ref": "#/groups/15", - "parent": { - "$ref": "#/texts/29" - }, - "children": [], - "content_layer": "body", - "name": "list", - "label": "list" - }, - { - "self_ref": "#/groups/16", - "parent": { - "$ref": "#/texts/30" - }, - "children": [], - "content_layer": "body", - "name": "list", - "label": "list" - }, - { - "self_ref": "#/groups/17", - "parent": { - "$ref": "#/texts/31" - }, - "children": [], - "content_layer": "body", - "name": "list", - "label": "list" - }, - { - "self_ref": "#/groups/18", - "parent": { - "$ref": "#/texts/32" - }, - "children": [], - "content_layer": "body", - "name": "list", - "label": "list" - }, - { - "self_ref": "#/groups/19", - "parent": { - "$ref": "#/texts/33" - }, - "children": [ { "$ref": "#/texts/34" }, + { + "$ref": "#/groups/9" + }, { "$ref": "#/texts/35" }, + { + "$ref": "#/groups/10" + }, { "$ref": "#/texts/36" }, + { + "$ref": "#/groups/11" + }, { "$ref": "#/texts/37" + }, + { + "$ref": "#/groups/12" + }, + { + "$ref": "#/texts/38" + }, + { + "$ref": "#/groups/13" + }, + { + "$ref": "#/texts/43" + }, + { + "$ref": "#/groups/18" + }, + { + "$ref": "#/texts/48" + }, + { + "$ref": "#/groups/23" + }, + { + "$ref": "#/texts/49" + }, + { + "$ref": "#/groups/24" + }, + { + "$ref": "#/texts/52" + }, + { + "$ref": "#/groups/27" } ], "content_layer": "body", - "name": "list", + "name": "group", "label": "list" }, { - "self_ref": "#/groups/20", + "self_ref": "#/groups/9", "parent": { - "$ref": "#/texts/34" + "$ref": "#/groups/8" }, "children": [], "content_layer": "body", - "name": "list", + "name": "group", "label": "list" }, { - "self_ref": "#/groups/21", + "self_ref": "#/groups/10", "parent": { - "$ref": "#/texts/35" + "$ref": "#/groups/8" }, "children": [], "content_layer": "body", - "name": "list", + "name": "group", "label": "list" }, { - "self_ref": "#/groups/22", + "self_ref": "#/groups/11", "parent": { - "$ref": "#/texts/36" + "$ref": "#/groups/8" }, "children": [], "content_layer": "body", - "name": "list", + "name": "group", "label": "list" }, { - "self_ref": "#/groups/23", + "self_ref": "#/groups/12", "parent": { - "$ref": "#/texts/37" + "$ref": "#/groups/8" }, "children": [], "content_layer": "body", - "name": "list", + "name": "group", "label": "list" }, { - "self_ref": "#/groups/24", + "self_ref": "#/groups/13", "parent": { - "$ref": "#/texts/38" - }, - "children": [], - "content_layer": "body", - "name": "list", - "label": "list" - }, - { - "self_ref": "#/groups/25", - "parent": { - "$ref": "#/texts/39" + "$ref": "#/groups/8" }, "children": [ + { + "$ref": "#/texts/39" + }, + { + "$ref": "#/groups/14" + }, { "$ref": "#/texts/40" }, + { + "$ref": "#/groups/15" + }, { "$ref": "#/texts/41" + }, + { + "$ref": "#/groups/16" + }, + { + "$ref": "#/texts/42" + }, + { + "$ref": "#/groups/17" } ], "content_layer": "body", - "name": "list", + "name": "group", "label": "list" }, { - "self_ref": "#/groups/26", + "self_ref": "#/groups/14", "parent": { - "$ref": "#/texts/40" + "$ref": "#/groups/13" }, "children": [], "content_layer": "body", - "name": "list", + "name": "group", "label": "list" }, { - "self_ref": "#/groups/27", + "self_ref": "#/groups/15", "parent": { - "$ref": "#/texts/41" + "$ref": "#/groups/13" }, "children": [], "content_layer": "body", - "name": "list", + "name": "group", "label": "list" }, { - "self_ref": "#/groups/28", + "self_ref": "#/groups/16", "parent": { - "$ref": "#/texts/42" + "$ref": "#/groups/13" }, "children": [], "content_layer": "body", - "name": "list", + "name": "group", "label": "list" }, { - "self_ref": "#/groups/29", + "self_ref": "#/groups/17", "parent": { - "$ref": "#/texts/43" + "$ref": "#/groups/13" + }, + "children": [], + "content_layer": "body", + "name": "group", + "label": "list" + }, + { + "self_ref": "#/groups/18", + "parent": { + "$ref": "#/groups/8" }, "children": [ { "$ref": "#/texts/44" }, + { + "$ref": "#/groups/19" + }, { "$ref": "#/texts/45" }, + { + "$ref": "#/groups/20" + }, { "$ref": "#/texts/46" }, + { + "$ref": "#/groups/21" + }, { "$ref": "#/texts/47" }, { - "$ref": "#/texts/48" - }, - { - "$ref": "#/texts/49" - }, + "$ref": "#/groups/22" + } + ], + "content_layer": "body", + "name": "group", + "label": "list" + }, + { + "self_ref": "#/groups/19", + "parent": { + "$ref": "#/groups/18" + }, + "children": [], + "content_layer": "body", + "name": "group", + "label": "list" + }, + { + "self_ref": "#/groups/20", + "parent": { + "$ref": "#/groups/18" + }, + "children": [], + "content_layer": "body", + "name": "group", + "label": "list" + }, + { + "self_ref": "#/groups/21", + "parent": { + "$ref": "#/groups/18" + }, + "children": [], + "content_layer": "body", + "name": "group", + "label": "list" + }, + { + "self_ref": "#/groups/22", + "parent": { + "$ref": "#/groups/18" + }, + "children": [], + "content_layer": "body", + "name": "group", + "label": "list" + }, + { + "self_ref": "#/groups/23", + "parent": { + "$ref": "#/groups/8" + }, + "children": [], + "content_layer": "body", + "name": "group", + "label": "list" + }, + { + "self_ref": "#/groups/24", + "parent": { + "$ref": "#/groups/8" + }, + "children": [ { "$ref": "#/texts/50" }, + { + "$ref": "#/groups/25" + }, { "$ref": "#/texts/51" }, { - "$ref": "#/texts/52" - }, - { - "$ref": "#/texts/53" - }, - { - "$ref": "#/texts/54" - }, - { - "$ref": "#/texts/55" - }, + "$ref": "#/groups/26" + } + ], + "content_layer": "body", + "name": "group", + "label": "list" + }, + { + "self_ref": "#/groups/25", + "parent": { + "$ref": "#/groups/24" + }, + "children": [], + "content_layer": "body", + "name": "group", + "label": "list" + }, + { + "self_ref": "#/groups/26", + "parent": { + "$ref": "#/groups/24" + }, + "children": [], + "content_layer": "body", + "name": "group", + "label": "list" + }, + { + "self_ref": "#/groups/27", + "parent": { + "$ref": "#/groups/8" + }, + "children": [], + "content_layer": "body", + "name": "group", + "label": "list" + }, + { + "self_ref": "#/groups/28", + "parent": { + "$ref": "#/body" + }, + "children": [ { "$ref": "#/texts/56" }, @@ -944,45 +1362,13 @@ }, { "$ref": "#/texts/179" - } - ], - "content_layer": "body", - "name": "list", - "label": "list" - }, - { - "self_ref": "#/groups/30", - "parent": { - "$ref": "#/texts/43" - }, - "children": [ + }, { "$ref": "#/texts/180" }, { "$ref": "#/texts/181" - } - ], - "content_layer": "body", - "name": "list", - "label": "list" - }, - { - "self_ref": "#/groups/31", - "parent": { - "$ref": "#/texts/43" - }, - "children": [], - "content_layer": "body", - "name": "list", - "label": "list" - }, - { - "self_ref": "#/groups/32", - "parent": { - "$ref": "#/texts/43" - }, - "children": [ + }, { "$ref": "#/texts/182" }, @@ -991,18 +1377,13 @@ }, { "$ref": "#/texts/184" - } - ], - "content_layer": "body", - "name": "list", - "label": "list" - }, - { - "self_ref": "#/groups/33", - "parent": { - "$ref": "#/texts/43" - }, - "children": [ + }, + { + "$ref": "#/texts/185" + }, + { + "$ref": "#/texts/186" + }, { "$ref": "#/texts/187" }, @@ -1011,33 +1392,51 @@ }, { "$ref": "#/texts/189" + }, + { + "$ref": "#/texts/190" + }, + { + "$ref": "#/texts/191" } ], "content_layer": "body", - "name": "list", + "name": "group", "label": "list" }, { - "self_ref": "#/groups/34", + "self_ref": "#/groups/29", "parent": { - "$ref": "#/texts/43" + "$ref": "#/body" }, "children": [ - { - "$ref": "#/texts/191" - }, - { - "$ref": "#/texts/192" - }, { "$ref": "#/texts/193" }, { "$ref": "#/texts/194" - }, - { - "$ref": "#/texts/195" - }, + } + ], + "content_layer": "body", + "name": "group", + "label": "list" + }, + { + "self_ref": "#/groups/30", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "name": "group", + "label": "list" + }, + { + "self_ref": "#/groups/31", + "parent": { + "$ref": "#/body" + }, + "children": [ { "$ref": "#/texts/196" }, @@ -1046,41 +1445,21 @@ }, { "$ref": "#/texts/198" - }, - { - "$ref": "#/texts/199" - }, - { - "$ref": "#/texts/200" } ], "content_layer": "body", - "name": "list", + "name": "group", "label": "list" }, { - "self_ref": "#/groups/35", + "self_ref": "#/groups/32", "parent": { - "$ref": "#/texts/43" + "$ref": "#/body" }, "children": [ { - "$ref": "#/texts/202" + "$ref": "#/texts/204" }, - { - "$ref": "#/texts/203" - } - ], - "content_layer": "body", - "name": "list", - "label": "list" - }, - { - "self_ref": "#/groups/36", - "parent": { - "$ref": "#/texts/43" - }, - "children": [ { "$ref": "#/texts/205" }, @@ -1089,103 +1468,104 @@ } ], "content_layer": "body", - "name": "list", + "name": "group", + "label": "list" + }, + { + "self_ref": "#/groups/33", + "parent": { + "$ref": "#/body" + }, + "children": [ + { + "$ref": "#/texts/208" + }, + { + "$ref": "#/texts/209" + }, + { + "$ref": "#/texts/210" + }, + { + "$ref": "#/texts/211" + }, + { + "$ref": "#/texts/212" + }, + { + "$ref": "#/texts/213" + }, + { + "$ref": "#/texts/214" + }, + { + "$ref": "#/texts/215" + }, + { + "$ref": "#/texts/216" + }, + { + "$ref": "#/texts/217" + } + ], + "content_layer": "body", + "name": "group", + "label": "list" + }, + { + "self_ref": "#/groups/34", + "parent": { + "$ref": "#/body" + }, + "children": [ + { + "$ref": "#/texts/219" + }, + { + "$ref": "#/texts/220" + } + ], + "content_layer": "body", + "name": "group", + "label": "list" + }, + { + "self_ref": "#/groups/35", + "parent": { + "$ref": "#/body" + }, + "children": [ + { + "$ref": "#/texts/222" + }, + { + "$ref": "#/texts/223" + } + ], + "content_layer": "body", + "name": "group", + "label": "list" + }, + { + "self_ref": "#/groups/36", + "parent": { + "$ref": "#/body" + }, + "children": [ + { + "$ref": "#/texts/293" + } + ], + "content_layer": "body", + "name": "group", "label": "list" }, { "self_ref": "#/groups/37", "parent": { - "$ref": "#/texts/269" + "$ref": "#/body" }, "children": [ - { - "$ref": "#/texts/270" - } - ], - "content_layer": "body", - "name": "list", - "label": "list" - }, - { - "self_ref": "#/groups/38", - "parent": { - "$ref": "#/texts/269" - }, - "children": [ - { - "$ref": "#/texts/271" - }, - { - "$ref": "#/texts/272" - }, - { - "$ref": "#/texts/273" - }, - { - "$ref": "#/texts/274" - }, - { - "$ref": "#/texts/275" - }, - { - "$ref": "#/texts/276" - } - ], - "content_layer": "body", - "name": "list", - "label": "list" - }, - { - "self_ref": "#/groups/39", - "parent": { - "$ref": "#/texts/278" - }, - "children": [ - { - "$ref": "#/texts/279" - }, - { - "$ref": "#/texts/280" - }, - { - "$ref": "#/texts/281" - }, - { - "$ref": "#/texts/282" - }, - { - "$ref": "#/texts/283" - }, - { - "$ref": "#/texts/284" - }, - { - "$ref": "#/texts/285" - }, - { - "$ref": "#/texts/286" - }, - { - "$ref": "#/texts/287" - }, - { - "$ref": "#/texts/288" - }, - { - "$ref": "#/texts/289" - }, - { - "$ref": "#/texts/290" - }, - { - "$ref": "#/texts/291" - }, - { - "$ref": "#/texts/292" - }, - { - "$ref": "#/texts/293" - }, { "$ref": "#/texts/294" }, @@ -1203,13 +1583,18 @@ }, { "$ref": "#/texts/299" - }, - { - "$ref": "#/texts/300" - }, - { - "$ref": "#/texts/301" - }, + } + ], + "content_layer": "body", + "name": "group", + "label": "list" + }, + { + "self_ref": "#/groups/38", + "parent": { + "$ref": "#/body" + }, + "children": [ { "$ref": "#/texts/302" }, @@ -1305,18 +1690,10 @@ }, { "$ref": "#/texts/333" - } - ], - "content_layer": "body", - "name": "ordered list", - "label": "ordered_list" - }, - { - "self_ref": "#/groups/40", - "parent": { - "$ref": "#/texts/334" - }, - "children": [ + }, + { + "$ref": "#/texts/334" + }, { "$ref": "#/texts/335" }, @@ -1376,24 +1753,24 @@ }, { "$ref": "#/texts/354" + }, + { + "$ref": "#/texts/355" + }, + { + "$ref": "#/texts/356" } ], "content_layer": "body", - "name": "list", - "label": "list" + "name": "group", + "label": "ordered_list" }, { - "self_ref": "#/groups/41", + "self_ref": "#/groups/39", "parent": { - "$ref": "#/texts/355" + "$ref": "#/body" }, "children": [ - { - "$ref": "#/texts/356" - }, - { - "$ref": "#/texts/357" - }, { "$ref": "#/texts/358" }, @@ -1405,18 +1782,7 @@ }, { "$ref": "#/texts/361" - } - ], - "content_layer": "body", - "name": "list", - "label": "list" - }, - { - "self_ref": "#/groups/42", - "parent": { - "$ref": "#/texts/355" - }, - "children": [ + }, { "$ref": "#/texts/362" }, @@ -1425,18 +1791,13 @@ }, { "$ref": "#/texts/364" - } - ], - "content_layer": "body", - "name": "list", - "label": "list" - }, - { - "self_ref": "#/groups/43", - "parent": { - "$ref": "#/texts/355" - }, - "children": [ + }, + { + "$ref": "#/texts/365" + }, + { + "$ref": "#/texts/366" + }, { "$ref": "#/texts/367" }, @@ -1445,18 +1806,10 @@ }, { "$ref": "#/texts/369" - } - ], - "content_layer": "body", - "name": "list", - "label": "list" - }, - { - "self_ref": "#/groups/44", - "parent": { - "$ref": "#/texts/355" - }, - "children": [ + }, + { + "$ref": "#/texts/370" + }, { "$ref": "#/texts/371" }, @@ -1477,13 +1830,18 @@ }, { "$ref": "#/texts/377" - }, - { - "$ref": "#/texts/378" - }, - { - "$ref": "#/texts/379" - }, + } + ], + "content_layer": "body", + "name": "group", + "label": "list" + }, + { + "self_ref": "#/groups/40", + "parent": { + "$ref": "#/body" + }, + "children": [ { "$ref": "#/texts/380" }, @@ -1501,7 +1859,18 @@ }, { "$ref": "#/texts/385" - }, + } + ], + "content_layer": "body", + "name": "group", + "label": "list" + }, + { + "self_ref": "#/groups/41", + "parent": { + "$ref": "#/body" + }, + "children": [ { "$ref": "#/texts/386" }, @@ -1513,106 +1882,201 @@ }, { "$ref": "#/texts/389" - }, - { - "$ref": "#/texts/390" - }, - { - "$ref": "#/texts/391" - }, - { - "$ref": "#/texts/392" - }, - { - "$ref": "#/texts/393" - }, - { - "$ref": "#/texts/394" - }, - { - "$ref": "#/texts/395" - }, - { - "$ref": "#/texts/396" } ], "content_layer": "body", - "name": "list", + "name": "group", + "label": "list" + }, + { + "self_ref": "#/groups/42", + "parent": { + "$ref": "#/body" + }, + "children": [ + { + "$ref": "#/texts/423" + }, + { + "$ref": "#/texts/424" + }, + { + "$ref": "#/texts/425" + } + ], + "content_layer": "body", + "name": "group", + "label": "list" + }, + { + "self_ref": "#/groups/43", + "parent": { + "$ref": "#/body" + }, + "children": [ + { + "$ref": "#/texts/427" + }, + { + "$ref": "#/texts/428" + }, + { + "$ref": "#/texts/429" + }, + { + "$ref": "#/texts/430" + }, + { + "$ref": "#/texts/431" + }, + { + "$ref": "#/texts/432" + }, + { + "$ref": "#/texts/433" + }, + { + "$ref": "#/texts/434" + }, + { + "$ref": "#/texts/435" + }, + { + "$ref": "#/texts/436" + }, + { + "$ref": "#/texts/437" + }, + { + "$ref": "#/texts/438" + }, + { + "$ref": "#/texts/439" + }, + { + "$ref": "#/texts/440" + }, + { + "$ref": "#/texts/441" + }, + { + "$ref": "#/texts/442" + }, + { + "$ref": "#/texts/443" + }, + { + "$ref": "#/texts/444" + }, + { + "$ref": "#/texts/445" + }, + { + "$ref": "#/texts/446" + }, + { + "$ref": "#/texts/447" + }, + { + "$ref": "#/texts/448" + }, + { + "$ref": "#/texts/449" + }, + { + "$ref": "#/texts/450" + }, + { + "$ref": "#/texts/451" + }, + { + "$ref": "#/texts/452" + } + ], + "content_layer": "body", + "name": "group", + "label": "list" + }, + { + "self_ref": "#/groups/44", + "parent": { + "$ref": "#/body" + }, + "children": [ + { + "$ref": "#/texts/453" + }, + { + "$ref": "#/texts/454" + } + ], + "content_layer": "body", + "name": "group", "label": "list" }, { "self_ref": "#/groups/45", "parent": { - "$ref": "#/texts/355" + "$ref": "#/body" }, "children": [ { - "$ref": "#/texts/397" + "$ref": "#/texts/455" }, { - "$ref": "#/texts/398" + "$ref": "#/texts/456" + }, + { + "$ref": "#/texts/457" + }, + { + "$ref": "#/texts/458" + }, + { + "$ref": "#/texts/459" + }, + { + "$ref": "#/texts/460" + }, + { + "$ref": "#/texts/461" + }, + { + "$ref": "#/texts/462" + }, + { + "$ref": "#/texts/463" } ], "content_layer": "body", - "name": "list", + "name": "group", "label": "list" }, { "self_ref": "#/groups/46", "parent": { - "$ref": "#/texts/355" + "$ref": "#/body" }, "children": [ { - "$ref": "#/texts/399" + "$ref": "#/texts/464" }, { - "$ref": "#/texts/400" - }, - { - "$ref": "#/texts/401" - }, - { - "$ref": "#/texts/402" - }, - { - "$ref": "#/texts/403" - }, - { - "$ref": "#/texts/404" - }, - { - "$ref": "#/texts/405" - }, - { - "$ref": "#/texts/406" - }, - { - "$ref": "#/texts/407" + "$ref": "#/texts/465" } ], "content_layer": "body", - "name": "list", + "name": "group", "label": "list" }, { "self_ref": "#/groups/47", "parent": { - "$ref": "#/texts/355" + "$ref": "#/body" }, "children": [], "content_layer": "body", - "name": "list", - "label": "list" - }, - { - "self_ref": "#/groups/48", - "parent": { - "$ref": "#/texts/355" - }, - "children": [], - "content_layer": "body", - "name": "list", + "name": "group", "label": "list" } ], @@ -1623,11 +2087,11 @@ "$ref": "#/body" }, "children": [], - "content_layer": "furniture", + "content_layer": "body", "label": "text", "prov": [], - "orig": "Main menu", - "text": "Main menu" + "orig": "Jump to content", + "text": "Jump to content" }, { "self_ref": "#/texts/1", @@ -1635,67 +2099,59 @@ "$ref": "#/body" }, "children": [], - "content_layer": "furniture", + "content_layer": "body", "label": "text", "prov": [], - "orig": "Navigation", - "text": "Navigation" + "orig": "Main menu", + "text": "Main menu" }, { "self_ref": "#/texts/2", "parent": { - "$ref": "#/groups/0" + "$ref": "#/body" }, "children": [], - "content_layer": "furniture", - "label": "list_item", + "content_layer": "body", + "label": "text", "prov": [], - "orig": "Main page", - "text": "Main page", - "enumerated": false, - "marker": "-" + "orig": "Main menu", + "text": "Main menu" }, { "self_ref": "#/texts/3", "parent": { - "$ref": "#/groups/0" + "$ref": "#/body" }, "children": [], - "content_layer": "furniture", - "label": "list_item", + "content_layer": "body", + "label": "text", "prov": [], - "orig": "Contents", - "text": "Contents", - "enumerated": false, - "marker": "-" + "orig": "move to sidebar", + "text": "move to sidebar" }, { "self_ref": "#/texts/4", "parent": { - "$ref": "#/groups/0" + "$ref": "#/body" }, "children": [], - "content_layer": "furniture", - "label": "list_item", + "content_layer": "body", + "label": "text", "prov": [], - "orig": "Current events", - "text": "Current events", - "enumerated": false, - "marker": "-" + "orig": "hide", + "text": "hide" }, { "self_ref": "#/texts/5", "parent": { - "$ref": "#/groups/0" + "$ref": "#/body" }, "children": [], - "content_layer": "furniture", - "label": "list_item", + "content_layer": "body", + "label": "text", "prov": [], - "orig": "Random article", - "text": "Random article", - "enumerated": false, - "marker": "-" + "orig": "Navigation", + "text": "Navigation" }, { "self_ref": "#/texts/6", @@ -1703,11 +2159,11 @@ "$ref": "#/groups/0" }, "children": [], - "content_layer": "furniture", + "content_layer": "body", "label": "list_item", "prov": [], - "orig": "About Wikipedia", - "text": "About Wikipedia", + "orig": "Main page", + "text": "Main page", "enumerated": false, "marker": "-" }, @@ -1717,7 +2173,63 @@ "$ref": "#/groups/0" }, "children": [], - "content_layer": "furniture", + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Contents", + "text": "Contents", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/8", + "parent": { + "$ref": "#/groups/0" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Current events", + "text": "Current events", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/9", + "parent": { + "$ref": "#/groups/0" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Random article", + "text": "Random article", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/10", + "parent": { + "$ref": "#/groups/0" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "About Wikipedia", + "text": "About Wikipedia", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/11", + "parent": { + "$ref": "#/groups/0" + }, + "children": [], + "content_layer": "body", "label": "list_item", "prov": [], "orig": "Contact us", @@ -1726,24 +2238,24 @@ "marker": "-" }, { - "self_ref": "#/texts/8", + "self_ref": "#/texts/12", "parent": { "$ref": "#/body" }, "children": [], - "content_layer": "furniture", + "content_layer": "body", "label": "text", "prov": [], "orig": "Contribute", "text": "Contribute" }, { - "self_ref": "#/texts/9", + "self_ref": "#/texts/13", "parent": { "$ref": "#/groups/1" }, "children": [], - "content_layer": "furniture", + "content_layer": "body", "label": "list_item", "prov": [], "orig": "Help", @@ -1752,12 +2264,12 @@ "marker": "-" }, { - "self_ref": "#/texts/10", + "self_ref": "#/texts/14", "parent": { "$ref": "#/groups/1" }, "children": [], - "content_layer": "furniture", + "content_layer": "body", "label": "list_item", "prov": [], "orig": "Learn to edit", @@ -1766,12 +2278,12 @@ "marker": "-" }, { - "self_ref": "#/texts/11", + "self_ref": "#/texts/15", "parent": { "$ref": "#/groups/1" }, "children": [], - "content_layer": "furniture", + "content_layer": "body", "label": "list_item", "prov": [], "orig": "Community portal", @@ -1780,12 +2292,12 @@ "marker": "-" }, { - "self_ref": "#/texts/12", + "self_ref": "#/texts/16", "parent": { "$ref": "#/groups/1" }, "children": [], - "content_layer": "furniture", + "content_layer": "body", "label": "list_item", "prov": [], "orig": "Recent changes", @@ -1794,12 +2306,12 @@ "marker": "-" }, { - "self_ref": "#/texts/13", + "self_ref": "#/texts/17", "parent": { "$ref": "#/groups/1" }, "children": [], - "content_layer": "furniture", + "content_layer": "body", "label": "list_item", "prov": [], "orig": "Upload file", @@ -1808,12 +2320,36 @@ "marker": "-" }, { - "self_ref": "#/texts/14", + "self_ref": "#/texts/18", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Search", + "text": "Search" + }, + { + "self_ref": "#/texts/19", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Search", + "text": "Search" + }, + { + "self_ref": "#/texts/20", "parent": { "$ref": "#/groups/3" }, "children": [], - "content_layer": "furniture", + "content_layer": "body", "label": "list_item", "prov": [], "orig": "Donate", @@ -1822,80 +2358,104 @@ "marker": "-" }, { - "self_ref": "#/texts/15", - "parent": { - "$ref": "#/groups/5" - }, - "children": [], - "content_layer": "furniture", - "label": "list_item", - "prov": [], - "orig": "Create account", - "text": "Create account", - "enumerated": false, - "marker": "-" - }, - { - "self_ref": "#/texts/16", - "parent": { - "$ref": "#/groups/5" - }, - "children": [], - "content_layer": "furniture", - "label": "list_item", - "prov": [], - "orig": "Log in", - "text": "Log in", - "enumerated": false, - "marker": "-" - }, - { - "self_ref": "#/texts/17", - "parent": { - "$ref": "#/groups/6" - }, - "children": [], - "content_layer": "furniture", - "label": "list_item", - "prov": [], - "orig": "Create account", - "text": "Create account", - "enumerated": false, - "marker": "-" - }, - { - "self_ref": "#/texts/18", - "parent": { - "$ref": "#/groups/6" - }, - "children": [], - "content_layer": "furniture", - "label": "list_item", - "prov": [], - "orig": "Log in", - "text": "Log in", - "enumerated": false, - "marker": "-" - }, - { - "self_ref": "#/texts/19", + "self_ref": "#/texts/21", "parent": { "$ref": "#/body" }, "children": [], - "content_layer": "furniture", + "content_layer": "body", "label": "text", "prov": [], - "orig": "Pages for logged out editors", - "text": "Pages for logged out editors" + "orig": "Appearance", + "text": "Appearance" }, { - "self_ref": "#/texts/20", + "self_ref": "#/texts/22", + "parent": { + "$ref": "#/groups/5" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Create account", + "text": "Create account", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/23", + "parent": { + "$ref": "#/groups/5" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Log in", + "text": "Log in", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/24", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Personal tools", + "text": "Personal tools" + }, + { + "self_ref": "#/texts/25", + "parent": { + "$ref": "#/groups/6" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Create account", + "text": "Create account", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/26", + "parent": { + "$ref": "#/groups/6" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Log in", + "text": "Log in", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/27", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Pages for logged out editors learn more", + "text": "Pages for logged out editors learn more" + }, + { + "self_ref": "#/texts/28", "parent": { "$ref": "#/groups/7" }, "children": [], - "content_layer": "furniture", + "content_layer": "body", "label": "list_item", "prov": [], "orig": "Contributions", @@ -1904,12 +2464,12 @@ "marker": "-" }, { - "self_ref": "#/texts/21", + "self_ref": "#/texts/29", "parent": { "$ref": "#/groups/7" }, "children": [], - "content_layer": "furniture", + "content_layer": "body", "label": "list_item", "prov": [], "orig": "Talk", @@ -1918,26 +2478,46 @@ "marker": "-" }, { - "self_ref": "#/texts/22", + "self_ref": "#/texts/30", "parent": { - "$ref": "#/groups/8" + "$ref": "#/body" }, - "children": [ - { - "$ref": "#/groups/9" - } - ], + "children": [], "content_layer": "body", "label": "section_header", "prov": [], "orig": "Contents", "text": "Contents", - "level": 1 + "level": 2 }, { - "self_ref": "#/texts/23", + "self_ref": "#/texts/31", "parent": { - "$ref": "#/groups/9" + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "move to sidebar", + "text": "move to sidebar" + }, + { + "self_ref": "#/texts/32", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "hide", + "text": "hide" + }, + { + "self_ref": "#/texts/33", + "parent": { + "$ref": "#/groups/8" }, "children": [], "content_layer": "body", @@ -1949,15 +2529,11 @@ "marker": "-" }, { - "self_ref": "#/texts/24", + "self_ref": "#/texts/34", "parent": { - "$ref": "#/groups/9" + "$ref": "#/groups/8" }, - "children": [ - { - "$ref": "#/groups/10" - } - ], + "children": [], "content_layer": "body", "label": "list_item", "prov": [], @@ -1967,15 +2543,11 @@ "marker": "-" }, { - "self_ref": "#/texts/25", + "self_ref": "#/texts/35", "parent": { - "$ref": "#/groups/9" + "$ref": "#/groups/8" }, - "children": [ - { - "$ref": "#/groups/11" - } - ], + "children": [], "content_layer": "body", "label": "list_item", "prov": [], @@ -1985,15 +2557,11 @@ "marker": "-" }, { - "self_ref": "#/texts/26", + "self_ref": "#/texts/36", "parent": { - "$ref": "#/groups/9" + "$ref": "#/groups/8" }, - "children": [ - { - "$ref": "#/groups/12" - } - ], + "children": [], "content_layer": "body", "label": "list_item", "prov": [], @@ -2003,15 +2571,11 @@ "marker": "-" }, { - "self_ref": "#/texts/27", + "self_ref": "#/texts/37", "parent": { - "$ref": "#/groups/9" + "$ref": "#/groups/8" }, - "children": [ - { - "$ref": "#/groups/13" - } - ], + "children": [], "content_layer": "body", "label": "list_item", "prov": [], @@ -2021,33 +2585,25 @@ "marker": "-" }, { - "self_ref": "#/texts/28", + "self_ref": "#/texts/38", "parent": { - "$ref": "#/groups/9" + "$ref": "#/groups/8" }, - "children": [ - { - "$ref": "#/groups/14" - } - ], + "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "5 Behaviour Toggle Behaviour subsection", - "text": "5 Behaviour Toggle Behaviour subsection", + "orig": "5 Behaviour Toggle Behaviour subsection 5.1 Feeding 5.2 Breeding 5.3 Communication 5.4 Predators", + "text": "5 Behaviour Toggle Behaviour subsection 5.1 Feeding 5.2 Breeding 5.3 Communication 5.4 Predators", "enumerated": false, "marker": "-" }, { - "self_ref": "#/texts/29", + "self_ref": "#/texts/39", "parent": { - "$ref": "#/groups/14" + "$ref": "#/groups/13" }, - "children": [ - { - "$ref": "#/groups/15" - } - ], + "children": [], "content_layer": "body", "label": "list_item", "prov": [], @@ -2057,15 +2613,11 @@ "marker": "-" }, { - "self_ref": "#/texts/30", + "self_ref": "#/texts/40", "parent": { - "$ref": "#/groups/14" + "$ref": "#/groups/13" }, - "children": [ - { - "$ref": "#/groups/16" - } - ], + "children": [], "content_layer": "body", "label": "list_item", "prov": [], @@ -2075,15 +2627,11 @@ "marker": "-" }, { - "self_ref": "#/texts/31", + "self_ref": "#/texts/41", "parent": { - "$ref": "#/groups/14" + "$ref": "#/groups/13" }, - "children": [ - { - "$ref": "#/groups/17" - } - ], + "children": [], "content_layer": "body", "label": "list_item", "prov": [], @@ -2093,15 +2641,11 @@ "marker": "-" }, { - "self_ref": "#/texts/32", + "self_ref": "#/texts/42", "parent": { - "$ref": "#/groups/14" + "$ref": "#/groups/13" }, - "children": [ - { - "$ref": "#/groups/18" - } - ], + "children": [], "content_layer": "body", "label": "list_item", "prov": [], @@ -2111,33 +2655,25 @@ "marker": "-" }, { - "self_ref": "#/texts/33", + "self_ref": "#/texts/43", "parent": { - "$ref": "#/groups/9" + "$ref": "#/groups/8" }, - "children": [ - { - "$ref": "#/groups/19" - } - ], + "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "6 Relationship with humans Toggle Relationship with humans subsection", - "text": "6 Relationship with humans Toggle Relationship with humans subsection", + "orig": "6 Relationship with humans Toggle Relationship with humans subsection 6.1 Hunting 6.2 Domestication 6.3 Heraldry 6.4 Cultural references", + "text": "6 Relationship with humans Toggle Relationship with humans subsection 6.1 Hunting 6.2 Domestication 6.3 Heraldry 6.4 Cultural references", "enumerated": false, "marker": "-" }, { - "self_ref": "#/texts/34", + "self_ref": "#/texts/44", "parent": { - "$ref": "#/groups/19" + "$ref": "#/groups/18" }, - "children": [ - { - "$ref": "#/groups/20" - } - ], + "children": [], "content_layer": "body", "label": "list_item", "prov": [], @@ -2147,15 +2683,11 @@ "marker": "-" }, { - "self_ref": "#/texts/35", + "self_ref": "#/texts/45", "parent": { - "$ref": "#/groups/19" + "$ref": "#/groups/18" }, - "children": [ - { - "$ref": "#/groups/21" - } - ], + "children": [], "content_layer": "body", "label": "list_item", "prov": [], @@ -2165,15 +2697,11 @@ "marker": "-" }, { - "self_ref": "#/texts/36", + "self_ref": "#/texts/46", "parent": { - "$ref": "#/groups/19" + "$ref": "#/groups/18" }, - "children": [ - { - "$ref": "#/groups/22" - } - ], + "children": [], "content_layer": "body", "label": "list_item", "prov": [], @@ -2183,15 +2711,11 @@ "marker": "-" }, { - "self_ref": "#/texts/37", + "self_ref": "#/texts/47", "parent": { - "$ref": "#/groups/19" + "$ref": "#/groups/18" }, - "children": [ - { - "$ref": "#/groups/23" - } - ], + "children": [], "content_layer": "body", "label": "list_item", "prov": [], @@ -2201,15 +2725,11 @@ "marker": "-" }, { - "self_ref": "#/texts/38", + "self_ref": "#/texts/48", "parent": { - "$ref": "#/groups/9" + "$ref": "#/groups/8" }, - "children": [ - { - "$ref": "#/groups/24" - } - ], + "children": [], "content_layer": "body", "label": "list_item", "prov": [], @@ -2219,33 +2739,25 @@ "marker": "-" }, { - "self_ref": "#/texts/39", + "self_ref": "#/texts/49", "parent": { - "$ref": "#/groups/9" + "$ref": "#/groups/8" }, - "children": [ - { - "$ref": "#/groups/25" - } - ], + "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "8 Notes Toggle Notes subsection", - "text": "8 Notes Toggle Notes subsection", + "orig": "8 Notes Toggle Notes subsection 8.1 Citations 8.2 Sources", + "text": "8 Notes Toggle Notes subsection 8.1 Citations 8.2 Sources", "enumerated": false, "marker": "-" }, { - "self_ref": "#/texts/40", + "self_ref": "#/texts/50", "parent": { - "$ref": "#/groups/25" + "$ref": "#/groups/24" }, - "children": [ - { - "$ref": "#/groups/26" - } - ], + "children": [], "content_layer": "body", "label": "list_item", "prov": [], @@ -2255,15 +2767,11 @@ "marker": "-" }, { - "self_ref": "#/texts/41", + "self_ref": "#/texts/51", "parent": { - "$ref": "#/groups/25" + "$ref": "#/groups/24" }, - "children": [ - { - "$ref": "#/groups/27" - } - ], + "children": [], "content_layer": "body", "label": "list_item", "prov": [], @@ -2273,15 +2781,11 @@ "marker": "-" }, { - "self_ref": "#/texts/42", + "self_ref": "#/texts/52", "parent": { - "$ref": "#/groups/9" + "$ref": "#/groups/8" }, - "children": [ - { - "$ref": "#/groups/28" - } - ], + "children": [], "content_layer": "body", "label": "list_item", "prov": [], @@ -2291,105 +2795,23 @@ "marker": "-" }, { - "self_ref": "#/texts/43", + "self_ref": "#/texts/53", "parent": { "$ref": "#/body" }, - "children": [ - { - "$ref": "#/groups/29" - }, - { - "$ref": "#/groups/30" - }, - { - "$ref": "#/groups/31" - }, - { - "$ref": "#/groups/32" - }, - { - "$ref": "#/texts/185" - }, - { - "$ref": "#/texts/186" - }, - { - "$ref": "#/groups/33" - }, - { - "$ref": "#/texts/190" - }, - { - "$ref": "#/groups/34" - }, - { - "$ref": "#/texts/201" - }, - { - "$ref": "#/groups/35" - }, - { - "$ref": "#/texts/204" - }, - { - "$ref": "#/groups/36" - }, - { - "$ref": "#/texts/207" - }, - { - "$ref": "#/pictures/3" - }, - { - "$ref": "#/texts/208" - }, - { - "$ref": "#/texts/209" - }, - { - "$ref": "#/texts/210" - }, - { - "$ref": "#/texts/211" - }, - { - "$ref": "#/tables/0" - }, - { - "$ref": "#/texts/212" - }, - { - "$ref": "#/texts/213" - }, - { - "$ref": "#/texts/214" - }, - { - "$ref": "#/texts/222" - }, - { - "$ref": "#/texts/227" - }, - { - "$ref": "#/texts/231" - }, - { - "$ref": "#/texts/236" - }, - { - "$ref": "#/texts/256" - }, - { - "$ref": "#/texts/269" - }, - { - "$ref": "#/texts/277" - }, - { - "$ref": "#/texts/355" - } - ], + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Toggle the table of contents", + "text": "Toggle the table of contents" + }, + { + "self_ref": "#/texts/54", + "parent": { + "$ref": "#/body" + }, + "children": [], "content_layer": "body", "label": "title", "prov": [], @@ -2397,9 +2819,21 @@ "text": "Duck" }, { - "self_ref": "#/texts/44", + "self_ref": "#/texts/55", "parent": { - "$ref": "#/groups/29" + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "136 languages", + "text": "136 languages" + }, + { + "self_ref": "#/texts/56", + "parent": { + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2411,9 +2845,9 @@ "marker": "-" }, { - "self_ref": "#/texts/45", + "self_ref": "#/texts/57", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2425,9 +2859,9 @@ "marker": "-" }, { - "self_ref": "#/texts/46", + "self_ref": "#/texts/58", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2439,9 +2873,9 @@ "marker": "-" }, { - "self_ref": "#/texts/47", + "self_ref": "#/texts/59", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2453,9 +2887,9 @@ "marker": "-" }, { - "self_ref": "#/texts/48", + "self_ref": "#/texts/60", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2467,9 +2901,9 @@ "marker": "-" }, { - "self_ref": "#/texts/49", + "self_ref": "#/texts/61", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2481,9 +2915,9 @@ "marker": "-" }, { - "self_ref": "#/texts/50", + "self_ref": "#/texts/62", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2495,9 +2929,9 @@ "marker": "-" }, { - "self_ref": "#/texts/51", + "self_ref": "#/texts/63", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2509,9 +2943,9 @@ "marker": "-" }, { - "self_ref": "#/texts/52", + "self_ref": "#/texts/64", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2523,9 +2957,9 @@ "marker": "-" }, { - "self_ref": "#/texts/53", + "self_ref": "#/texts/65", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2537,9 +2971,9 @@ "marker": "-" }, { - "self_ref": "#/texts/54", + "self_ref": "#/texts/66", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2551,9 +2985,9 @@ "marker": "-" }, { - "self_ref": "#/texts/55", + "self_ref": "#/texts/67", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2565,9 +2999,9 @@ "marker": "-" }, { - "self_ref": "#/texts/56", + "self_ref": "#/texts/68", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2579,9 +3013,9 @@ "marker": "-" }, { - "self_ref": "#/texts/57", + "self_ref": "#/texts/69", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2593,9 +3027,9 @@ "marker": "-" }, { - "self_ref": "#/texts/58", + "self_ref": "#/texts/70", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2607,9 +3041,9 @@ "marker": "-" }, { - "self_ref": "#/texts/59", + "self_ref": "#/texts/71", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2621,9 +3055,9 @@ "marker": "-" }, { - "self_ref": "#/texts/60", + "self_ref": "#/texts/72", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2635,9 +3069,9 @@ "marker": "-" }, { - "self_ref": "#/texts/61", + "self_ref": "#/texts/73", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2649,9 +3083,9 @@ "marker": "-" }, { - "self_ref": "#/texts/62", + "self_ref": "#/texts/74", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2663,9 +3097,9 @@ "marker": "-" }, { - "self_ref": "#/texts/63", + "self_ref": "#/texts/75", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2677,9 +3111,9 @@ "marker": "-" }, { - "self_ref": "#/texts/64", + "self_ref": "#/texts/76", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2691,9 +3125,9 @@ "marker": "-" }, { - "self_ref": "#/texts/65", + "self_ref": "#/texts/77", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2705,9 +3139,9 @@ "marker": "-" }, { - "self_ref": "#/texts/66", + "self_ref": "#/texts/78", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2719,9 +3153,9 @@ "marker": "-" }, { - "self_ref": "#/texts/67", + "self_ref": "#/texts/79", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2733,9 +3167,9 @@ "marker": "-" }, { - "self_ref": "#/texts/68", + "self_ref": "#/texts/80", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2747,9 +3181,9 @@ "marker": "-" }, { - "self_ref": "#/texts/69", + "self_ref": "#/texts/81", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2761,9 +3195,9 @@ "marker": "-" }, { - "self_ref": "#/texts/70", + "self_ref": "#/texts/82", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2775,9 +3209,9 @@ "marker": "-" }, { - "self_ref": "#/texts/71", + "self_ref": "#/texts/83", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2789,9 +3223,9 @@ "marker": "-" }, { - "self_ref": "#/texts/72", + "self_ref": "#/texts/84", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2803,9 +3237,9 @@ "marker": "-" }, { - "self_ref": "#/texts/73", + "self_ref": "#/texts/85", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2817,9 +3251,9 @@ "marker": "-" }, { - "self_ref": "#/texts/74", + "self_ref": "#/texts/86", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2831,9 +3265,9 @@ "marker": "-" }, { - "self_ref": "#/texts/75", + "self_ref": "#/texts/87", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2845,9 +3279,9 @@ "marker": "-" }, { - "self_ref": "#/texts/76", + "self_ref": "#/texts/88", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2859,9 +3293,9 @@ "marker": "-" }, { - "self_ref": "#/texts/77", + "self_ref": "#/texts/89", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2873,9 +3307,9 @@ "marker": "-" }, { - "self_ref": "#/texts/78", + "self_ref": "#/texts/90", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2887,9 +3321,9 @@ "marker": "-" }, { - "self_ref": "#/texts/79", + "self_ref": "#/texts/91", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2901,9 +3335,9 @@ "marker": "-" }, { - "self_ref": "#/texts/80", + "self_ref": "#/texts/92", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2915,9 +3349,9 @@ "marker": "-" }, { - "self_ref": "#/texts/81", + "self_ref": "#/texts/93", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2929,9 +3363,9 @@ "marker": "-" }, { - "self_ref": "#/texts/82", + "self_ref": "#/texts/94", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2943,9 +3377,9 @@ "marker": "-" }, { - "self_ref": "#/texts/83", + "self_ref": "#/texts/95", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2957,9 +3391,9 @@ "marker": "-" }, { - "self_ref": "#/texts/84", + "self_ref": "#/texts/96", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2971,9 +3405,9 @@ "marker": "-" }, { - "self_ref": "#/texts/85", + "self_ref": "#/texts/97", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2985,9 +3419,9 @@ "marker": "-" }, { - "self_ref": "#/texts/86", + "self_ref": "#/texts/98", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -2999,9 +3433,9 @@ "marker": "-" }, { - "self_ref": "#/texts/87", + "self_ref": "#/texts/99", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3013,9 +3447,9 @@ "marker": "-" }, { - "self_ref": "#/texts/88", + "self_ref": "#/texts/100", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3027,9 +3461,9 @@ "marker": "-" }, { - "self_ref": "#/texts/89", + "self_ref": "#/texts/101", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3041,9 +3475,9 @@ "marker": "-" }, { - "self_ref": "#/texts/90", + "self_ref": "#/texts/102", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3055,9 +3489,9 @@ "marker": "-" }, { - "self_ref": "#/texts/91", + "self_ref": "#/texts/103", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3069,9 +3503,9 @@ "marker": "-" }, { - "self_ref": "#/texts/92", + "self_ref": "#/texts/104", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3083,9 +3517,9 @@ "marker": "-" }, { - "self_ref": "#/texts/93", + "self_ref": "#/texts/105", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3097,9 +3531,9 @@ "marker": "-" }, { - "self_ref": "#/texts/94", + "self_ref": "#/texts/106", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3111,9 +3545,9 @@ "marker": "-" }, { - "self_ref": "#/texts/95", + "self_ref": "#/texts/107", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3125,9 +3559,9 @@ "marker": "-" }, { - "self_ref": "#/texts/96", + "self_ref": "#/texts/108", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3139,9 +3573,9 @@ "marker": "-" }, { - "self_ref": "#/texts/97", + "self_ref": "#/texts/109", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3153,9 +3587,9 @@ "marker": "-" }, { - "self_ref": "#/texts/98", + "self_ref": "#/texts/110", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3167,9 +3601,9 @@ "marker": "-" }, { - "self_ref": "#/texts/99", + "self_ref": "#/texts/111", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3181,9 +3615,9 @@ "marker": "-" }, { - "self_ref": "#/texts/100", + "self_ref": "#/texts/112", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3195,9 +3629,9 @@ "marker": "-" }, { - "self_ref": "#/texts/101", + "self_ref": "#/texts/113", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3209,9 +3643,9 @@ "marker": "-" }, { - "self_ref": "#/texts/102", + "self_ref": "#/texts/114", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3223,9 +3657,9 @@ "marker": "-" }, { - "self_ref": "#/texts/103", + "self_ref": "#/texts/115", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3237,9 +3671,9 @@ "marker": "-" }, { - "self_ref": "#/texts/104", + "self_ref": "#/texts/116", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3251,9 +3685,9 @@ "marker": "-" }, { - "self_ref": "#/texts/105", + "self_ref": "#/texts/117", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3265,9 +3699,9 @@ "marker": "-" }, { - "self_ref": "#/texts/106", + "self_ref": "#/texts/118", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3279,9 +3713,9 @@ "marker": "-" }, { - "self_ref": "#/texts/107", + "self_ref": "#/texts/119", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3293,9 +3727,9 @@ "marker": "-" }, { - "self_ref": "#/texts/108", + "self_ref": "#/texts/120", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3307,9 +3741,9 @@ "marker": "-" }, { - "self_ref": "#/texts/109", + "self_ref": "#/texts/121", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3321,9 +3755,9 @@ "marker": "-" }, { - "self_ref": "#/texts/110", + "self_ref": "#/texts/122", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3335,9 +3769,9 @@ "marker": "-" }, { - "self_ref": "#/texts/111", + "self_ref": "#/texts/123", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3349,9 +3783,9 @@ "marker": "-" }, { - "self_ref": "#/texts/112", + "self_ref": "#/texts/124", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3363,9 +3797,9 @@ "marker": "-" }, { - "self_ref": "#/texts/113", + "self_ref": "#/texts/125", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3377,9 +3811,9 @@ "marker": "-" }, { - "self_ref": "#/texts/114", + "self_ref": "#/texts/126", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3391,9 +3825,9 @@ "marker": "-" }, { - "self_ref": "#/texts/115", + "self_ref": "#/texts/127", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3405,9 +3839,9 @@ "marker": "-" }, { - "self_ref": "#/texts/116", + "self_ref": "#/texts/128", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3419,9 +3853,9 @@ "marker": "-" }, { - "self_ref": "#/texts/117", + "self_ref": "#/texts/129", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3433,9 +3867,9 @@ "marker": "-" }, { - "self_ref": "#/texts/118", + "self_ref": "#/texts/130", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3447,9 +3881,9 @@ "marker": "-" }, { - "self_ref": "#/texts/119", + "self_ref": "#/texts/131", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3461,9 +3895,9 @@ "marker": "-" }, { - "self_ref": "#/texts/120", + "self_ref": "#/texts/132", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3475,9 +3909,9 @@ "marker": "-" }, { - "self_ref": "#/texts/121", + "self_ref": "#/texts/133", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3489,9 +3923,9 @@ "marker": "-" }, { - "self_ref": "#/texts/122", + "self_ref": "#/texts/134", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3503,9 +3937,9 @@ "marker": "-" }, { - "self_ref": "#/texts/123", + "self_ref": "#/texts/135", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3517,9 +3951,9 @@ "marker": "-" }, { - "self_ref": "#/texts/124", + "self_ref": "#/texts/136", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3531,9 +3965,9 @@ "marker": "-" }, { - "self_ref": "#/texts/125", + "self_ref": "#/texts/137", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3545,9 +3979,9 @@ "marker": "-" }, { - "self_ref": "#/texts/126", + "self_ref": "#/texts/138", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3559,9 +3993,9 @@ "marker": "-" }, { - "self_ref": "#/texts/127", + "self_ref": "#/texts/139", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3573,9 +4007,9 @@ "marker": "-" }, { - "self_ref": "#/texts/128", + "self_ref": "#/texts/140", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3587,9 +4021,9 @@ "marker": "-" }, { - "self_ref": "#/texts/129", + "self_ref": "#/texts/141", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3601,9 +4035,9 @@ "marker": "-" }, { - "self_ref": "#/texts/130", + "self_ref": "#/texts/142", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3615,9 +4049,9 @@ "marker": "-" }, { - "self_ref": "#/texts/131", + "self_ref": "#/texts/143", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3629,9 +4063,9 @@ "marker": "-" }, { - "self_ref": "#/texts/132", + "self_ref": "#/texts/144", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3643,9 +4077,9 @@ "marker": "-" }, { - "self_ref": "#/texts/133", + "self_ref": "#/texts/145", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3657,9 +4091,9 @@ "marker": "-" }, { - "self_ref": "#/texts/134", + "self_ref": "#/texts/146", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3671,9 +4105,9 @@ "marker": "-" }, { - "self_ref": "#/texts/135", + "self_ref": "#/texts/147", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3685,9 +4119,9 @@ "marker": "-" }, { - "self_ref": "#/texts/136", + "self_ref": "#/texts/148", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3699,9 +4133,9 @@ "marker": "-" }, { - "self_ref": "#/texts/137", + "self_ref": "#/texts/149", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3713,9 +4147,9 @@ "marker": "-" }, { - "self_ref": "#/texts/138", + "self_ref": "#/texts/150", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3727,9 +4161,9 @@ "marker": "-" }, { - "self_ref": "#/texts/139", + "self_ref": "#/texts/151", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3741,9 +4175,9 @@ "marker": "-" }, { - "self_ref": "#/texts/140", + "self_ref": "#/texts/152", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3755,9 +4189,9 @@ "marker": "-" }, { - "self_ref": "#/texts/141", + "self_ref": "#/texts/153", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3769,9 +4203,9 @@ "marker": "-" }, { - "self_ref": "#/texts/142", + "self_ref": "#/texts/154", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3783,9 +4217,9 @@ "marker": "-" }, { - "self_ref": "#/texts/143", + "self_ref": "#/texts/155", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3797,9 +4231,9 @@ "marker": "-" }, { - "self_ref": "#/texts/144", + "self_ref": "#/texts/156", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3811,9 +4245,9 @@ "marker": "-" }, { - "self_ref": "#/texts/145", + "self_ref": "#/texts/157", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3825,9 +4259,9 @@ "marker": "-" }, { - "self_ref": "#/texts/146", + "self_ref": "#/texts/158", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3839,9 +4273,9 @@ "marker": "-" }, { - "self_ref": "#/texts/147", + "self_ref": "#/texts/159", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3853,9 +4287,9 @@ "marker": "-" }, { - "self_ref": "#/texts/148", + "self_ref": "#/texts/160", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3867,9 +4301,9 @@ "marker": "-" }, { - "self_ref": "#/texts/149", + "self_ref": "#/texts/161", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3881,9 +4315,9 @@ "marker": "-" }, { - "self_ref": "#/texts/150", + "self_ref": "#/texts/162", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3895,9 +4329,9 @@ "marker": "-" }, { - "self_ref": "#/texts/151", + "self_ref": "#/texts/163", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3909,9 +4343,9 @@ "marker": "-" }, { - "self_ref": "#/texts/152", + "self_ref": "#/texts/164", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3923,9 +4357,9 @@ "marker": "-" }, { - "self_ref": "#/texts/153", + "self_ref": "#/texts/165", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3937,9 +4371,9 @@ "marker": "-" }, { - "self_ref": "#/texts/154", + "self_ref": "#/texts/166", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3951,9 +4385,9 @@ "marker": "-" }, { - "self_ref": "#/texts/155", + "self_ref": "#/texts/167", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3965,9 +4399,9 @@ "marker": "-" }, { - "self_ref": "#/texts/156", + "self_ref": "#/texts/168", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3979,9 +4413,9 @@ "marker": "-" }, { - "self_ref": "#/texts/157", + "self_ref": "#/texts/169", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -3993,9 +4427,9 @@ "marker": "-" }, { - "self_ref": "#/texts/158", + "self_ref": "#/texts/170", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -4007,9 +4441,9 @@ "marker": "-" }, { - "self_ref": "#/texts/159", + "self_ref": "#/texts/171", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -4021,9 +4455,9 @@ "marker": "-" }, { - "self_ref": "#/texts/160", + "self_ref": "#/texts/172", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -4035,9 +4469,9 @@ "marker": "-" }, { - "self_ref": "#/texts/161", + "self_ref": "#/texts/173", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -4049,9 +4483,9 @@ "marker": "-" }, { - "self_ref": "#/texts/162", + "self_ref": "#/texts/174", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -4063,9 +4497,9 @@ "marker": "-" }, { - "self_ref": "#/texts/163", + "self_ref": "#/texts/175", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -4077,9 +4511,9 @@ "marker": "-" }, { - "self_ref": "#/texts/164", + "self_ref": "#/texts/176", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -4091,9 +4525,9 @@ "marker": "-" }, { - "self_ref": "#/texts/165", + "self_ref": "#/texts/177", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -4105,9 +4539,9 @@ "marker": "-" }, { - "self_ref": "#/texts/166", + "self_ref": "#/texts/178", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -4119,9 +4553,9 @@ "marker": "-" }, { - "self_ref": "#/texts/167", + "self_ref": "#/texts/179", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -4133,9 +4567,9 @@ "marker": "-" }, { - "self_ref": "#/texts/168", + "self_ref": "#/texts/180", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -4147,9 +4581,9 @@ "marker": "-" }, { - "self_ref": "#/texts/169", + "self_ref": "#/texts/181", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -4161,9 +4595,9 @@ "marker": "-" }, { - "self_ref": "#/texts/170", + "self_ref": "#/texts/182", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -4175,9 +4609,9 @@ "marker": "-" }, { - "self_ref": "#/texts/171", + "self_ref": "#/texts/183", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -4189,9 +4623,9 @@ "marker": "-" }, { - "self_ref": "#/texts/172", + "self_ref": "#/texts/184", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -4203,9 +4637,9 @@ "marker": "-" }, { - "self_ref": "#/texts/173", + "self_ref": "#/texts/185", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -4217,9 +4651,9 @@ "marker": "-" }, { - "self_ref": "#/texts/174", + "self_ref": "#/texts/186", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -4231,9 +4665,9 @@ "marker": "-" }, { - "self_ref": "#/texts/175", + "self_ref": "#/texts/187", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -4245,9 +4679,9 @@ "marker": "-" }, { - "self_ref": "#/texts/176", + "self_ref": "#/texts/188", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -4259,9 +4693,9 @@ "marker": "-" }, { - "self_ref": "#/texts/177", + "self_ref": "#/texts/189", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -4273,9 +4707,9 @@ "marker": "-" }, { - "self_ref": "#/texts/178", + "self_ref": "#/texts/190", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -4287,9 +4721,9 @@ "marker": "-" }, { - "self_ref": "#/texts/179", + "self_ref": "#/texts/191", "parent": { - "$ref": "#/groups/29" + "$ref": "#/groups/28" }, "children": [], "content_layer": "body", @@ -4301,9 +4735,21 @@ "marker": "-" }, { - "self_ref": "#/texts/180", + "self_ref": "#/texts/192", "parent": { - "$ref": "#/groups/30" + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Edit links", + "text": "Edit links" + }, + { + "self_ref": "#/texts/193", + "parent": { + "$ref": "#/groups/29" }, "children": [], "content_layer": "body", @@ -4315,9 +4761,9 @@ "marker": "-" }, { - "self_ref": "#/texts/181", + "self_ref": "#/texts/194", "parent": { - "$ref": "#/groups/30" + "$ref": "#/groups/29" }, "children": [], "content_layer": "body", @@ -4329,9 +4775,21 @@ "marker": "-" }, { - "self_ref": "#/texts/182", + "self_ref": "#/texts/195", "parent": { - "$ref": "#/groups/32" + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "English", + "text": "English" + }, + { + "self_ref": "#/texts/196", + "parent": { + "$ref": "#/groups/31" }, "children": [], "content_layer": "body", @@ -4343,9 +4801,9 @@ "marker": "-" }, { - "self_ref": "#/texts/183", + "self_ref": "#/texts/197", "parent": { - "$ref": "#/groups/32" + "$ref": "#/groups/31" }, "children": [], "content_layer": "body", @@ -4357,9 +4815,9 @@ "marker": "-" }, { - "self_ref": "#/texts/184", + "self_ref": "#/texts/198", "parent": { - "$ref": "#/groups/32" + "$ref": "#/groups/31" }, "children": [], "content_layer": "body", @@ -4371,9 +4829,9 @@ "marker": "-" }, { - "self_ref": "#/texts/185", + "self_ref": "#/texts/199", "parent": { - "$ref": "#/texts/43" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -4383,9 +4841,45 @@ "text": "Tools" }, { - "self_ref": "#/texts/186", + "self_ref": "#/texts/200", "parent": { - "$ref": "#/texts/43" + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Tools", + "text": "Tools" + }, + { + "self_ref": "#/texts/201", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "move to sidebar", + "text": "move to sidebar" + }, + { + "self_ref": "#/texts/202", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "hide", + "text": "hide" + }, + { + "self_ref": "#/texts/203", + "parent": { + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -4395,9 +4889,9 @@ "text": "Actions" }, { - "self_ref": "#/texts/187", + "self_ref": "#/texts/204", "parent": { - "$ref": "#/groups/33" + "$ref": "#/groups/32" }, "children": [], "content_layer": "body", @@ -4409,9 +4903,9 @@ "marker": "-" }, { - "self_ref": "#/texts/188", + "self_ref": "#/texts/205", "parent": { - "$ref": "#/groups/33" + "$ref": "#/groups/32" }, "children": [], "content_layer": "body", @@ -4423,9 +4917,9 @@ "marker": "-" }, { - "self_ref": "#/texts/189", + "self_ref": "#/texts/206", "parent": { - "$ref": "#/groups/33" + "$ref": "#/groups/32" }, "children": [], "content_layer": "body", @@ -4437,9 +4931,9 @@ "marker": "-" }, { - "self_ref": "#/texts/190", + "self_ref": "#/texts/207", "parent": { - "$ref": "#/texts/43" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -4449,9 +4943,9 @@ "text": "General" }, { - "self_ref": "#/texts/191", + "self_ref": "#/texts/208", "parent": { - "$ref": "#/groups/34" + "$ref": "#/groups/33" }, "children": [], "content_layer": "body", @@ -4463,9 +4957,9 @@ "marker": "-" }, { - "self_ref": "#/texts/192", + "self_ref": "#/texts/209", "parent": { - "$ref": "#/groups/34" + "$ref": "#/groups/33" }, "children": [], "content_layer": "body", @@ -4477,9 +4971,9 @@ "marker": "-" }, { - "self_ref": "#/texts/193", + "self_ref": "#/texts/210", "parent": { - "$ref": "#/groups/34" + "$ref": "#/groups/33" }, "children": [], "content_layer": "body", @@ -4491,9 +4985,9 @@ "marker": "-" }, { - "self_ref": "#/texts/194", + "self_ref": "#/texts/211", "parent": { - "$ref": "#/groups/34" + "$ref": "#/groups/33" }, "children": [], "content_layer": "body", @@ -4505,9 +4999,9 @@ "marker": "-" }, { - "self_ref": "#/texts/195", + "self_ref": "#/texts/212", "parent": { - "$ref": "#/groups/34" + "$ref": "#/groups/33" }, "children": [], "content_layer": "body", @@ -4519,9 +5013,9 @@ "marker": "-" }, { - "self_ref": "#/texts/196", + "self_ref": "#/texts/213", "parent": { - "$ref": "#/groups/34" + "$ref": "#/groups/33" }, "children": [], "content_layer": "body", @@ -4533,9 +5027,9 @@ "marker": "-" }, { - "self_ref": "#/texts/197", + "self_ref": "#/texts/214", "parent": { - "$ref": "#/groups/34" + "$ref": "#/groups/33" }, "children": [], "content_layer": "body", @@ -4547,9 +5041,9 @@ "marker": "-" }, { - "self_ref": "#/texts/198", + "self_ref": "#/texts/215", "parent": { - "$ref": "#/groups/34" + "$ref": "#/groups/33" }, "children": [], "content_layer": "body", @@ -4561,9 +5055,9 @@ "marker": "-" }, { - "self_ref": "#/texts/199", + "self_ref": "#/texts/216", "parent": { - "$ref": "#/groups/34" + "$ref": "#/groups/33" }, "children": [], "content_layer": "body", @@ -4575,9 +5069,9 @@ "marker": "-" }, { - "self_ref": "#/texts/200", + "self_ref": "#/texts/217", "parent": { - "$ref": "#/groups/34" + "$ref": "#/groups/33" }, "children": [], "content_layer": "body", @@ -4589,9 +5083,9 @@ "marker": "-" }, { - "self_ref": "#/texts/201", + "self_ref": "#/texts/218", "parent": { - "$ref": "#/texts/43" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -4601,9 +5095,9 @@ "text": "Print/export" }, { - "self_ref": "#/texts/202", + "self_ref": "#/texts/219", "parent": { - "$ref": "#/groups/35" + "$ref": "#/groups/34" }, "children": [], "content_layer": "body", @@ -4615,9 +5109,9 @@ "marker": "-" }, { - "self_ref": "#/texts/203", + "self_ref": "#/texts/220", "parent": { - "$ref": "#/groups/35" + "$ref": "#/groups/34" }, "children": [], "content_layer": "body", @@ -4629,9 +5123,9 @@ "marker": "-" }, { - "self_ref": "#/texts/204", + "self_ref": "#/texts/221", "parent": { - "$ref": "#/texts/43" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -4641,9 +5135,9 @@ "text": "In other projects" }, { - "self_ref": "#/texts/205", + "self_ref": "#/texts/222", "parent": { - "$ref": "#/groups/36" + "$ref": "#/groups/35" }, "children": [], "content_layer": "body", @@ -4655,9 +5149,9 @@ "marker": "-" }, { - "self_ref": "#/texts/206", + "self_ref": "#/texts/223", "parent": { - "$ref": "#/groups/36" + "$ref": "#/groups/35" }, "children": [], "content_layer": "body", @@ -4669,9 +5163,9 @@ "marker": "-" }, { - "self_ref": "#/texts/207", + "self_ref": "#/texts/224", "parent": { - "$ref": "#/texts/43" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -4681,9 +5175,33 @@ "text": "Appearance" }, { - "self_ref": "#/texts/208", + "self_ref": "#/texts/225", "parent": { - "$ref": "#/texts/43" + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "move to sidebar", + "text": "move to sidebar" + }, + { + "self_ref": "#/texts/226", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "hide", + "text": "hide" + }, + { + "self_ref": "#/texts/227", + "parent": { + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -4693,9 +5211,21 @@ "text": "From Wikipedia, the free encyclopedia" }, { - "self_ref": "#/texts/209", + "self_ref": "#/texts/228", "parent": { - "$ref": "#/texts/43" + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "(Redirected from Duckling)", + "text": "(Redirected from Duckling)" + }, + { + "self_ref": "#/texts/229", + "parent": { + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -4705,33 +5235,33 @@ "text": "Common name for many species of bird" }, { - "self_ref": "#/texts/210", + "self_ref": "#/texts/230", "parent": { - "$ref": "#/texts/43" + "$ref": "#/body" }, "children": [], "content_layer": "body", "label": "text", "prov": [], - "orig": "This article is about the bird. For duck as a food, see . For other uses, see .", - "text": "This article is about the bird. For duck as a food, see . For other uses, see ." + "orig": "This article is about the bird. For duck as a food, see Duck as food. For other uses, see Duck (disambiguation).", + "text": "This article is about the bird. For duck as a food, see Duck as food. For other uses, see Duck (disambiguation)." }, { - "self_ref": "#/texts/211", + "self_ref": "#/texts/231", "parent": { - "$ref": "#/texts/43" + "$ref": "#/body" }, "children": [], "content_layer": "body", "label": "text", "prov": [], - "orig": "\"Duckling\" redirects here. For other uses, see .", - "text": "\"Duckling\" redirects here. For other uses, see ." + "orig": "\"Duckling\" redirects here. For other uses, see Duckling (disambiguation).", + "text": "\"Duckling\" redirects here. For other uses, see Duckling (disambiguation)." }, { - "self_ref": "#/texts/212", + "self_ref": "#/texts/232", "parent": { - "$ref": "#/texts/43" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -4741,9 +5271,9 @@ "text": "Duck is the common name for numerous species of waterfowl in the family Anatidae. Ducks are generally smaller and shorter-necked than swans and geese, which are members of the same family. Divided among several subfamilies, they are a form taxon; they do not represent a monophyletic group (the group of all descendants of a single common ancestral species), since swans and geese are not considered ducks. Ducks are mostly aquatic birds, and may be found in both fresh water and sea water." }, { - "self_ref": "#/texts/213", + "self_ref": "#/texts/233", "parent": { - "$ref": "#/texts/43" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -4753,44 +5283,22 @@ "text": "Ducks are sometimes confused with several types of unrelated water birds with similar forms, such as loons or divers, grebes, gallinules and coots." }, { - "self_ref": "#/texts/214", + "self_ref": "#/texts/234", "parent": { - "$ref": "#/texts/43" + "$ref": "#/body" }, - "children": [ - { - "$ref": "#/texts/215" - }, - { - "$ref": "#/pictures/4" - }, - { - "$ref": "#/texts/217" - }, - { - "$ref": "#/texts/218" - }, - { - "$ref": "#/texts/219" - }, - { - "$ref": "#/pictures/5" - }, - { - "$ref": "#/pictures/6" - } - ], + "children": [], "content_layer": "body", "label": "section_header", "prov": [], "orig": "Etymology", "text": "Etymology", - "level": 1 + "level": 2 }, { - "self_ref": "#/texts/215", + "self_ref": "#/texts/235", "parent": { - "$ref": "#/texts/214" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -4800,21 +5308,21 @@ "text": "The word duck comes from Old English d\u016bce 'diver', a derivative of the verb *d\u016bcan 'to duck, bend down low as if to get under something, or dive', because of the way many species in the dabbling duck group feed by upending; compare with Dutch duiken and German tauchen 'to dive'." }, { - "self_ref": "#/texts/216", + "self_ref": "#/texts/236", "parent": { "$ref": "#/body" }, "children": [], "content_layer": "body", - "label": "caption", + "label": "text", "prov": [], "orig": "Pacific black duck displaying the characteristic upending \"duck\"", "text": "Pacific black duck displaying the characteristic upending \"duck\"" }, { - "self_ref": "#/texts/217", + "self_ref": "#/texts/237", "parent": { - "$ref": "#/texts/214" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -4824,9 +5332,9 @@ "text": "This word replaced Old English ened /\u00e6nid 'duck', possibly to avoid confusion with other words, such as ende 'end' with similar forms. Other Germanic languages still have similar words for duck, for example, Dutch eend, German Ente and Norwegian and. The word ened /\u00e6nid was inherited from Proto-Indo-European; cf. Latin anas \"duck\", Lithuanian \u00e1ntis 'duck', Ancient Greek \u03bd\u1fc6\u03c3\u03c3\u03b1 /\u03bd\u1fc6\u03c4\u03c4\u03b1 (n\u0113ssa /n\u0113tta) 'duck', and Sanskrit \u0101t\u00ed 'water bird', among others." }, { - "self_ref": "#/texts/218", + "self_ref": "#/texts/238", "parent": { - "$ref": "#/texts/214" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -4836,9 +5344,9 @@ "text": "A duckling is a young duck in downy plumage[1] or baby duck,[2] but in the food trade a young domestic duck which has just reached adult size and bulk and its meat is still fully tender, is sometimes labelled as a duckling." }, { - "self_ref": "#/texts/219", + "self_ref": "#/texts/239", "parent": { - "$ref": "#/texts/214" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -4848,59 +5356,46 @@ "text": "A male is called a drake and the female is called a duck, or in ornithology a hen.[3][4]" }, { - "self_ref": "#/texts/220", + "self_ref": "#/texts/240", "parent": { "$ref": "#/body" }, "children": [], "content_layer": "body", - "label": "caption", + "label": "text", "prov": [], "orig": "Male mallard.", "text": "Male mallard." }, { - "self_ref": "#/texts/221", + "self_ref": "#/texts/241", "parent": { "$ref": "#/body" }, "children": [], "content_layer": "body", - "label": "caption", + "label": "text", "prov": [], "orig": "Wood ducks.", "text": "Wood ducks." }, { - "self_ref": "#/texts/222", + "self_ref": "#/texts/242", "parent": { - "$ref": "#/texts/43" + "$ref": "#/body" }, - "children": [ - { - "$ref": "#/texts/223" - }, - { - "$ref": "#/pictures/7" - }, - { - "$ref": "#/texts/225" - }, - { - "$ref": "#/texts/226" - } - ], + "children": [], "content_layer": "body", "label": "section_header", "prov": [], "orig": "Taxonomy", "text": "Taxonomy", - "level": 1 + "level": 2 }, { - "self_ref": "#/texts/223", + "self_ref": "#/texts/243", "parent": { - "$ref": "#/texts/222" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -4910,21 +5405,21 @@ "text": "All ducks belong to the biological order Anseriformes, a group that contains the ducks, geese and swans, as well as the screamers, and the magpie goose.[5] All except the screamers belong to the biological family Anatidae.[5] Within the family, ducks are split into a variety of subfamilies and 'tribes'. The number and composition of these subfamilies and tribes is the cause of considerable disagreement among taxonomists.[5] Some base their decisions on morphological characteristics, others on shared behaviours or genetic studies.[6][7] The number of suggested subfamilies containing ducks ranges from two to five.[8][9] The significant level of hybridisation that occurs among wild ducks complicates efforts to tease apart the relationships between various species.[9]" }, { - "self_ref": "#/texts/224", + "self_ref": "#/texts/244", "parent": { "$ref": "#/body" }, "children": [], "content_layer": "body", - "label": "caption", + "label": "text", "prov": [], "orig": "Mallard landing in approach", "text": "Mallard landing in approach" }, { - "self_ref": "#/texts/225", + "self_ref": "#/texts/245", "parent": { - "$ref": "#/texts/222" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -4934,9 +5429,9 @@ "text": "In most modern classifications, the so-called 'true ducks' belong to the subfamily Anatinae, which is further split into a varying number of tribes.[10] The largest of these, the Anatini, contains the 'dabbling' or 'river' ducks \u2013 named for their method of feeding primarily at the surface of fresh water.[11] The 'diving ducks', also named for their primary feeding method, make up the tribe Aythyini.[12] The 'sea ducks' of the tribe Mergini are diving ducks which specialise on fish and shellfish and spend a majority of their lives in saltwater.[13] The tribe Oxyurini contains the 'stifftails', diving ducks notable for their small size and stiff, upright tails.[14]" }, { - "self_ref": "#/texts/226", + "self_ref": "#/texts/246", "parent": { - "$ref": "#/texts/222" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -4946,44 +5441,34 @@ "text": "A number of other species called ducks are not considered to be 'true ducks', and are typically placed in other subfamilies or tribes. The whistling ducks are assigned either to a tribe (Dendrocygnini) in the subfamily Anatinae or the subfamily Anserinae,[15] or to their own subfamily (Dendrocygninae) or family (Dendrocyganidae).[9][16] The freckled duck of Australia is either the sole member of the tribe Stictonettini in the subfamily Anserinae,[15] or in its own family, the Stictonettinae.[9] The shelducks make up the tribe Tadornini in the family Anserinae in some classifications,[15] and their own subfamily, Tadorninae, in others,[17] while the steamer ducks are either placed in the family Anserinae in the tribe Tachyerini[15] or lumped with the shelducks in the tribe Tadorini.[9] The perching ducks make up in the tribe Cairinini in the subfamily Anserinae in some classifications, while that tribe is eliminated in other classifications and its members assigned to the tribe Anatini.[9] The torrent duck is generally included in the subfamily Anserinae in the monotypic tribe Merganettini,[15] but is sometimes included in the tribe Tadornini.[18] The pink-eared duck is sometimes included as a true duck either in the tribe Anatini[15] or the tribe Malacorhynchini,[19] and other times is included with the shelducks in the tribe Tadornini.[15]" }, { - "self_ref": "#/texts/227", - "parent": { - "$ref": "#/texts/43" - }, - "children": [ - { - "$ref": "#/pictures/8" - }, - { - "$ref": "#/texts/229" - }, - { - "$ref": "#/texts/230" - } - ], - "content_layer": "body", - "label": "section_header", - "prov": [], - "orig": "Morphology", - "text": "Morphology", - "level": 1 - }, - { - "self_ref": "#/texts/228", + "self_ref": "#/texts/247", "parent": { "$ref": "#/body" }, "children": [], "content_layer": "body", - "label": "caption", + "label": "section_header", + "prov": [], + "orig": "Morphology", + "text": "Morphology", + "level": 2 + }, + { + "self_ref": "#/texts/248", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", "prov": [], "orig": "Male Mandarin duck", "text": "Male Mandarin duck" }, { - "self_ref": "#/texts/229", + "self_ref": "#/texts/249", "parent": { - "$ref": "#/texts/227" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -4993,9 +5478,9 @@ "text": "The overall body plan of ducks is elongated and broad, and they are also relatively long-necked, albeit not as long-necked as the geese and swans. The body shape of diving ducks varies somewhat from this in being more rounded. The bill is usually broad and contains serrated pectens, which are particularly well defined in the filter-feeding species. In the case of some fishing species the bill is long and strongly serrated. The scaled legs are strong and well developed, and generally set far back on the body, more so in the highly aquatic species. The wings are very strong and are generally short and pointed, and the flight of ducks requires fast continuous strokes, requiring in turn strong wing muscles. Three species of steamer duck are almost flightless, however. Many species of duck are temporarily flightless while moulting; they seek out protected habitat with good food supplies during this period. This moult typically precedes migration." }, { - "self_ref": "#/texts/230", + "self_ref": "#/texts/250", "parent": { - "$ref": "#/texts/227" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -5005,47 +5490,46 @@ "text": "The drakes of northern species often have extravagant plumage, but that is moulted in summer to give a more female-like appearance, the \"eclipse\" plumage. Southern resident species typically show less sexual dimorphism, although there are exceptions such as the paradise shelduck of New Zealand, which is both strikingly sexually dimorphic and in which the female's plumage is brighter than that of the male. The plumage of juvenile birds generally resembles that of the female. Female ducks have evolved to have a corkscrew shaped vagina to prevent rape." }, { - "self_ref": "#/texts/231", - "parent": { - "$ref": "#/texts/43" - }, - "children": [ - { - "$ref": "#/pictures/9" - }, - { - "$ref": "#/texts/233" - }, - { - "$ref": "#/pictures/10" - }, - { - "$ref": "#/texts/235" - } - ], - "content_layer": "body", - "label": "section_header", - "prov": [], - "orig": "Distribution and habitat", - "text": "Distribution and habitat", - "level": 1 - }, - { - "self_ref": "#/texts/232", + "self_ref": "#/texts/251", "parent": { "$ref": "#/body" }, "children": [], "content_layer": "body", - "label": "caption", + "label": "section_header", + "prov": [], + "orig": "Distribution and habitat", + "text": "Distribution and habitat", + "level": 2 + }, + { + "self_ref": "#/texts/252", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "See also: List of Anseriformes by population", + "text": "See also: List of Anseriformes by population" + }, + { + "self_ref": "#/texts/253", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", "prov": [], "orig": "Flying steamer ducks in Ushuaia, Argentina", "text": "Flying steamer ducks in Ushuaia, Argentina" }, { - "self_ref": "#/texts/233", + "self_ref": "#/texts/254", "parent": { - "$ref": "#/texts/231" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -5055,21 +5539,21 @@ "text": "Ducks have a cosmopolitan distribution, and are found on every continent except Antarctica.[5] Several species manage to live on subantarctic islands, including South Georgia and the Auckland Islands.[20] Ducks have reached a number of isolated oceanic islands, including the Hawaiian Islands, Micronesia and the Gal\u00e1pagos Islands, where they are often vagrants and less often residents.[21][22] A handful are endemic to such far-flung islands.[21]" }, { - "self_ref": "#/texts/234", + "self_ref": "#/texts/255", "parent": { "$ref": "#/body" }, "children": [], "content_layer": "body", - "label": "caption", + "label": "text", "prov": [], "orig": "Female mallard in Cornwall, England", "text": "Female mallard in Cornwall, England" }, { - "self_ref": "#/texts/235", + "self_ref": "#/texts/256", "parent": { - "$ref": "#/texts/231" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -5079,97 +5563,59 @@ "text": "Some duck species, mainly those breeding in the temperate and Arctic Northern Hemisphere, are migratory; those in the tropics are generally not. Some ducks, particularly in Australia where rainfall is erratic, are nomadic, seeking out the temporary lakes and pools that form after localised heavy rain.[23]" }, { - "self_ref": "#/texts/236", + "self_ref": "#/texts/257", "parent": { - "$ref": "#/texts/43" + "$ref": "#/body" }, - "children": [ - { - "$ref": "#/texts/237" - }, - { - "$ref": "#/texts/246" - }, - { - "$ref": "#/texts/249" - }, - { - "$ref": "#/texts/252" - } - ], + "children": [], "content_layer": "body", "label": "section_header", "prov": [], "orig": "Behaviour", "text": "Behaviour", - "level": 1 + "level": 2 }, { - "self_ref": "#/texts/237", + "self_ref": "#/texts/258", "parent": { - "$ref": "#/texts/236" + "$ref": "#/body" }, - "children": [ - { - "$ref": "#/pictures/11" - }, - { - "$ref": "#/pictures/12" - }, - { - "$ref": "#/texts/240" - }, - { - "$ref": "#/texts/241" - }, - { - "$ref": "#/texts/242" - }, - { - "$ref": "#/texts/243" - }, - { - "$ref": "#/texts/244" - }, - { - "$ref": "#/texts/245" - } - ], + "children": [], "content_layer": "body", "label": "section_header", "prov": [], "orig": "Feeding", "text": "Feeding", - "level": 2 + "level": 3 }, { - "self_ref": "#/texts/238", + "self_ref": "#/texts/259", "parent": { "$ref": "#/body" }, "children": [], "content_layer": "body", - "label": "caption", + "label": "text", "prov": [], "orig": "Pecten along the bill", "text": "Pecten along the bill" }, { - "self_ref": "#/texts/239", + "self_ref": "#/texts/260", "parent": { "$ref": "#/body" }, "children": [], "content_layer": "body", - "label": "caption", + "label": "text", "prov": [], "orig": "Mallard duckling preening", "text": "Mallard duckling preening" }, { - "self_ref": "#/texts/240", + "self_ref": "#/texts/261", "parent": { - "$ref": "#/texts/237" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -5179,9 +5625,9 @@ "text": "Ducks eat food sources such as grasses, aquatic plants, fish, insects, small amphibians, worms, and small molluscs." }, { - "self_ref": "#/texts/241", + "self_ref": "#/texts/262", "parent": { - "$ref": "#/texts/237" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -5191,9 +5637,9 @@ "text": "Dabbling ducks feed on the surface of water or on land, or as deep as they can reach by up-ending without completely submerging.[24] Along the edge of the bill, there is a comb-like structure called a pecten. This strains the water squirting from the side of the bill and traps any food. The pecten is also used to preen feathers and to hold slippery food items." }, { - "self_ref": "#/texts/242", + "self_ref": "#/texts/263", "parent": { - "$ref": "#/texts/237" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -5203,9 +5649,9 @@ "text": "Diving ducks and sea ducks forage deep underwater. To be able to submerge more easily, the diving ducks are heavier than dabbling ducks, and therefore have more difficulty taking off to fly." }, { - "self_ref": "#/texts/243", + "self_ref": "#/texts/264", "parent": { - "$ref": "#/texts/237" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -5215,9 +5661,9 @@ "text": "A few specialized species such as the mergansers are adapted to catch and swallow large fish." }, { - "self_ref": "#/texts/244", + "self_ref": "#/texts/265", "parent": { - "$ref": "#/texts/237" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -5227,9 +5673,9 @@ "text": "The others have the characteristic wide flat bill adapted to dredging-type jobs such as pulling up waterweed, pulling worms and small molluscs out of mud, searching for insect larvae, and bulk jobs such as dredging out, holding, turning head first, and swallowing a squirming frog. To avoid injury when digging into sediment it has no cere, but the nostrils come out through hard horn." }, { - "self_ref": "#/texts/245", + "self_ref": "#/texts/266", "parent": { - "$ref": "#/texts/237" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -5239,41 +5685,34 @@ "text": "The Guardian published an article advising that ducks should not be fed with bread because it damages the health of the ducks and pollutes waterways.[25]" }, { - "self_ref": "#/texts/246", - "parent": { - "$ref": "#/texts/236" - }, - "children": [ - { - "$ref": "#/pictures/13" - }, - { - "$ref": "#/texts/248" - } - ], - "content_layer": "body", - "label": "section_header", - "prov": [], - "orig": "Breeding", - "text": "Breeding", - "level": 2 - }, - { - "self_ref": "#/texts/247", + "self_ref": "#/texts/267", "parent": { "$ref": "#/body" }, "children": [], "content_layer": "body", - "label": "caption", + "label": "section_header", + "prov": [], + "orig": "Breeding", + "text": "Breeding", + "level": 3 + }, + { + "self_ref": "#/texts/268", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", "prov": [], "orig": "A Muscovy duckling", "text": "A Muscovy duckling" }, { - "self_ref": "#/texts/248", + "self_ref": "#/texts/269", "parent": { - "$ref": "#/texts/246" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -5283,29 +5722,22 @@ "text": "Ducks generally only have one partner at a time, although the partnership usually only lasts one year.[26] Larger species and the more sedentary species (like fast-river specialists) tend to have pair-bonds that last numerous years.[27] Most duck species breed once a year, choosing to do so in favourable conditions (spring/summer or wet seasons). Ducks also tend to make a nest before breeding, and, after hatching, lead their ducklings to water. Mother ducks are very caring and protective of their young, but may abandon some of their ducklings if they are physically stuck in an area they cannot get out of (such as nesting in an enclosed courtyard) or are not prospering due to genetic defects or sickness brought about by hypothermia, starvation, or disease. Ducklings can also be orphaned by inconsistent late hatching where a few eggs hatch after the mother has abandoned the nest and led her ducklings to water.[28]" }, { - "self_ref": "#/texts/249", + "self_ref": "#/texts/270", "parent": { - "$ref": "#/texts/236" + "$ref": "#/body" }, - "children": [ - { - "$ref": "#/texts/250" - }, - { - "$ref": "#/texts/251" - } - ], + "children": [], "content_layer": "body", "label": "section_header", "prov": [], "orig": "Communication", "text": "Communication", - "level": 2 + "level": 3 }, { - "self_ref": "#/texts/250", + "self_ref": "#/texts/271", "parent": { - "$ref": "#/texts/249" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -5315,9 +5747,9 @@ "text": "Female mallard ducks (as well as several other species in the genus Anas, such as the American and Pacific black ducks, spot-billed duck, northern pintail and common teal) make the classic \"quack\" sound while males make a similar but raspier sound that is sometimes written as \"breeeeze\",[29][self-published source?] but, despite widespread misconceptions, most species of duck do not \"quack\".[30] In general, ducks make a range of calls, including whistles, cooing, yodels and grunts. For example, the scaup \u2013 which are diving ducks \u2013 make a noise like \"scaup\" (hence their name). Calls may be loud displaying calls or quieter contact calls." }, { - "self_ref": "#/texts/251", + "self_ref": "#/texts/272", "parent": { - "$ref": "#/texts/249" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -5327,44 +5759,34 @@ "text": "A common urban legend claims that duck quacks do not echo; however, this has been proven to be false. This myth was first debunked by the Acoustics Research Centre at the University of Salford in 2003 as part of the British Association's Festival of Science.[31] It was also debunked in one of the earlier episodes of the popular Discovery Channel television show MythBusters.[32]" }, { - "self_ref": "#/texts/252", - "parent": { - "$ref": "#/texts/236" - }, - "children": [ - { - "$ref": "#/pictures/14" - }, - { - "$ref": "#/texts/254" - }, - { - "$ref": "#/texts/255" - } - ], - "content_layer": "body", - "label": "section_header", - "prov": [], - "orig": "Predators", - "text": "Predators", - "level": 2 - }, - { - "self_ref": "#/texts/253", + "self_ref": "#/texts/273", "parent": { "$ref": "#/body" }, "children": [], "content_layer": "body", - "label": "caption", + "label": "section_header", + "prov": [], + "orig": "Predators", + "text": "Predators", + "level": 3 + }, + { + "self_ref": "#/texts/274", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", "prov": [], "orig": "Ringed teal", "text": "Ringed teal" }, { - "self_ref": "#/texts/254", + "self_ref": "#/texts/275", "parent": { - "$ref": "#/texts/252" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -5374,9 +5796,9 @@ "text": "Ducks have many predators. Ducklings are particularly vulnerable, since their inability to fly makes them easy prey not only for predatory birds but also for large fish like pike, crocodilians, predatory testudines such as the alligator snapping turtle, and other aquatic hunters, including fish-eating birds such as herons. Ducks' nests are raided by land-based predators, and brooding females may be caught unaware on the nest by mammals, such as foxes, or large birds, such as hawks or owls." }, { - "self_ref": "#/texts/255", + "self_ref": "#/texts/276", "parent": { - "$ref": "#/texts/252" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -5386,55 +5808,47 @@ "text": "Adult ducks are fast fliers, but may be caught on the water by large aquatic predators including big fish such as the North American muskie and the European pike. In flight, ducks are safe from all but a few predators such as humans and the peregrine falcon, which uses its speed and strength to catch ducks." }, { - "self_ref": "#/texts/256", + "self_ref": "#/texts/277", "parent": { - "$ref": "#/texts/43" + "$ref": "#/body" }, - "children": [ - { - "$ref": "#/texts/257" - }, - { - "$ref": "#/texts/260" - }, - { - "$ref": "#/texts/263" - }, - { - "$ref": "#/texts/266" - } - ], + "children": [], "content_layer": "body", "label": "section_header", "prov": [], "orig": "Relationship with humans", "text": "Relationship with humans", - "level": 1 + "level": 2 }, { - "self_ref": "#/texts/257", + "self_ref": "#/texts/278", "parent": { - "$ref": "#/texts/256" + "$ref": "#/body" }, - "children": [ - { - "$ref": "#/texts/258" - }, - { - "$ref": "#/texts/259" - } - ], + "children": [], "content_layer": "body", "label": "section_header", "prov": [], "orig": "Hunting", "text": "Hunting", - "level": 2 + "level": 3 }, { - "self_ref": "#/texts/258", + "self_ref": "#/texts/279", "parent": { - "$ref": "#/texts/257" + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Main article: Waterfowl hunting", + "text": "Main article: Waterfowl hunting" + }, + { + "self_ref": "#/texts/280", + "parent": { + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -5444,9 +5858,9 @@ "text": "Humans have hunted ducks since prehistoric times. Excavations of middens in California dating to 7800 \u2013 6400 BP have turned up bones of ducks, including at least one now-extinct flightless species.[33] Ducks were captured in \"significant numbers\" by Holocene inhabitants of the lower Ohio River valley, suggesting they took advantage of the seasonal bounty provided by migrating waterfowl.[34] Neolithic hunters in locations as far apart as the Caribbean,[35] Scandinavia,[36] Egypt,[37] Switzerland,[38] and China relied on ducks as a source of protein for some or all of the year.[39] Archeological evidence shows that M\u0101ori people in New Zealand hunted the flightless Finsch's duck, possibly to extinction, though rat predation may also have contributed to its fate.[40] A similar end awaited the Chatham duck, a species with reduced flying capabilities which went extinct shortly after its island was colonised by Polynesian settlers.[41] It is probable that duck eggs were gathered by Neolithic hunter-gathers as well, though hard evidence of this is uncommon.[35][42]" }, { - "self_ref": "#/texts/259", + "self_ref": "#/texts/281", "parent": { - "$ref": "#/texts/257" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -5456,41 +5870,46 @@ "text": "In many areas, wild ducks (including ducks farmed and released into the wild) are hunted for food or sport,[43] by shooting, or by being trapped using duck decoys. Because an idle floating duck or a duck squatting on land cannot react to fly or move quickly, \"a sitting duck\" has come to mean \"an easy target\". These ducks may be contaminated by pollutants such as PCBs.[44]" }, { - "self_ref": "#/texts/260", - "parent": { - "$ref": "#/texts/256" - }, - "children": [ - { - "$ref": "#/pictures/15" - }, - { - "$ref": "#/texts/262" - } - ], - "content_layer": "body", - "label": "section_header", - "prov": [], - "orig": "Domestication", - "text": "Domestication", - "level": 2 - }, - { - "self_ref": "#/texts/261", + "self_ref": "#/texts/282", "parent": { "$ref": "#/body" }, "children": [], "content_layer": "body", - "label": "caption", + "label": "section_header", + "prov": [], + "orig": "Domestication", + "text": "Domestication", + "level": 3 + }, + { + "self_ref": "#/texts/283", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Main article: Domestic duck", + "text": "Main article: Domestic duck" + }, + { + "self_ref": "#/texts/284", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", "prov": [], "orig": "Indian Runner ducks, a common breed of domestic ducks", "text": "Indian Runner ducks, a common breed of domestic ducks" }, { - "self_ref": "#/texts/262", + "self_ref": "#/texts/285", "parent": { - "$ref": "#/texts/260" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -5500,41 +5919,34 @@ "text": "Ducks have many economic uses, being farmed for their meat, eggs, and feathers (particularly their down). Approximately 3 billion ducks are slaughtered each year for meat worldwide.[45] They are also kept and bred by aviculturists and often displayed in zoos. Almost all the varieties of domestic ducks are descended from the mallard (Anas platyrhynchos), apart from the Muscovy duck (Cairina moschata).[46][47] The Call duck is another example of a domestic duck breed. Its name comes from its original use established by hunters, as a decoy to attract wild mallards from the sky, into traps set for them on the ground. The call duck is the world's smallest domestic duck breed, as it weighs less than 1\u00a0kg (2.2\u00a0lb).[48]" }, { - "self_ref": "#/texts/263", - "parent": { - "$ref": "#/texts/256" - }, - "children": [ - { - "$ref": "#/pictures/16" - }, - { - "$ref": "#/texts/265" - } - ], - "content_layer": "body", - "label": "section_header", - "prov": [], - "orig": "Heraldry", - "text": "Heraldry", - "level": 2 - }, - { - "self_ref": "#/texts/264", + "self_ref": "#/texts/286", "parent": { "$ref": "#/body" }, "children": [], "content_layer": "body", - "label": "caption", + "label": "section_header", + "prov": [], + "orig": "Heraldry", + "text": "Heraldry", + "level": 3 + }, + { + "self_ref": "#/texts/287", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", "prov": [], "orig": "Three black-colored ducks in the coat of arms of Maaninka[49]", "text": "Three black-colored ducks in the coat of arms of Maaninka[49]" }, { - "self_ref": "#/texts/265", + "self_ref": "#/texts/288", "parent": { - "$ref": "#/texts/263" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -5544,29 +5956,22 @@ "text": "Ducks appear on several coats of arms, including the coat of arms of Lub\u0101na (Latvia)[50] and the coat of arms of F\u00f6gl\u00f6 (\u00c5land).[51]" }, { - "self_ref": "#/texts/266", + "self_ref": "#/texts/289", "parent": { - "$ref": "#/texts/256" + "$ref": "#/body" }, - "children": [ - { - "$ref": "#/texts/267" - }, - { - "$ref": "#/texts/268" - } - ], + "children": [], "content_layer": "body", "label": "section_header", "prov": [], "orig": "Cultural references", "text": "Cultural references", - "level": 2 + "level": 3 }, { - "self_ref": "#/texts/267", + "self_ref": "#/texts/290", "parent": { - "$ref": "#/texts/266" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -5576,9 +5981,9 @@ "text": "In 2002, psychologist Richard Wiseman and colleagues at the University of Hertfordshire, UK, finished a year-long LaughLab experiment, concluding that of all animals, ducks attract the most humor and silliness; he said, \"If you're going to tell a joke involving an animal, make it a duck.\"[52] The word \"duck\" may have become an inherently funny word in many languages, possibly because ducks are seen as silly in their looks or behavior. Of the many ducks in fiction, many are cartoon characters, such as Walt Disney's Donald Duck, and Warner Bros.' Daffy Duck. Howard the Duck started as a comic book character in 1973[53][54] and was made into a movie in 1986." }, { - "self_ref": "#/texts/268", + "self_ref": "#/texts/291", "parent": { - "$ref": "#/texts/266" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -5588,29 +5993,22 @@ "text": "The 1992 Disney film The Mighty Ducks, starring Emilio Estevez, chose the duck as the mascot for the fictional youth hockey team who are protagonists of the movie, based on the duck being described as a fierce fighter. This led to the duck becoming the nickname and mascot for the eventual National Hockey League professional team of the Anaheim Ducks, who were founded with the name the Mighty Ducks of Anaheim.[citation needed] The duck is also the nickname of the University of Oregon sports teams as well as the Long Island Ducks minor league baseball team.[55]" }, { - "self_ref": "#/texts/269", + "self_ref": "#/texts/292", "parent": { - "$ref": "#/texts/43" + "$ref": "#/body" }, - "children": [ - { - "$ref": "#/groups/37" - }, - { - "$ref": "#/groups/38" - } - ], + "children": [], "content_layer": "body", "label": "section_header", "prov": [], "orig": "See also", "text": "See also", - "level": 1 + "level": 2 }, { - "self_ref": "#/texts/270", + "self_ref": "#/texts/293", "parent": { - "$ref": "#/groups/37" + "$ref": "#/groups/36" }, "children": [], "content_layer": "body", @@ -5622,9 +6020,9 @@ "marker": "-" }, { - "self_ref": "#/texts/271", + "self_ref": "#/texts/294", "parent": { - "$ref": "#/groups/38" + "$ref": "#/groups/37" }, "children": [], "content_layer": "body", @@ -5636,9 +6034,9 @@ "marker": "-" }, { - "self_ref": "#/texts/272", + "self_ref": "#/texts/295", "parent": { - "$ref": "#/groups/38" + "$ref": "#/groups/37" }, "children": [], "content_layer": "body", @@ -5650,9 +6048,9 @@ "marker": "-" }, { - "self_ref": "#/texts/273", + "self_ref": "#/texts/296", "parent": { - "$ref": "#/groups/38" + "$ref": "#/groups/37" }, "children": [], "content_layer": "body", @@ -5664,9 +6062,9 @@ "marker": "-" }, { - "self_ref": "#/texts/274", + "self_ref": "#/texts/297", "parent": { - "$ref": "#/groups/38" + "$ref": "#/groups/37" }, "children": [], "content_layer": "body", @@ -5678,9 +6076,9 @@ "marker": "-" }, { - "self_ref": "#/texts/275", + "self_ref": "#/texts/298", "parent": { - "$ref": "#/groups/38" + "$ref": "#/groups/37" }, "children": [], "content_layer": "body", @@ -5692,9 +6090,9 @@ "marker": "-" }, { - "self_ref": "#/texts/276", + "self_ref": "#/texts/299", "parent": { - "$ref": "#/groups/38" + "$ref": "#/groups/37" }, "children": [], "content_layer": "body", @@ -5706,1166 +6104,1123 @@ "marker": "-" }, { - "self_ref": "#/texts/277", + "self_ref": "#/texts/300", "parent": { - "$ref": "#/texts/43" + "$ref": "#/body" }, - "children": [ - { - "$ref": "#/texts/278" - }, - { - "$ref": "#/texts/334" - } - ], + "children": [], "content_layer": "body", "label": "section_header", "prov": [], "orig": "Notes", "text": "Notes", - "level": 1 + "level": 2 }, { - "self_ref": "#/texts/278", + "self_ref": "#/texts/301", "parent": { - "$ref": "#/texts/277" + "$ref": "#/body" }, - "children": [ - { - "$ref": "#/groups/39" - } - ], + "children": [], "content_layer": "body", "label": "section_header", "prov": [], "orig": "Citations", "text": "Citations", - "level": 2 - }, - { - "self_ref": "#/texts/279", - "parent": { - "$ref": "#/groups/39" - }, - "children": [], - "content_layer": "body", - "label": "list_item", - "prov": [], - "orig": "^ \"Duckling\". The American Heritage Dictionary of the English Language, Fourth Edition. Houghton Mifflin Company. 2006. Retrieved 2015-05-22.", - "text": "^ \"Duckling\". The American Heritage Dictionary of the English Language, Fourth Edition. Houghton Mifflin Company. 2006. Retrieved 2015-05-22.", - "enumerated": true, - "marker": "1." - }, - { - "self_ref": "#/texts/280", - "parent": { - "$ref": "#/groups/39" - }, - "children": [], - "content_layer": "body", - "label": "list_item", - "prov": [], - "orig": "^ \"Duckling\". Kernerman English Multilingual Dictionary (Beta Version). K. Dictionaries Ltd. 2000\u20132006. Retrieved 2015-05-22.", - "text": "^ \"Duckling\". Kernerman English Multilingual Dictionary (Beta Version). K. Dictionaries Ltd. 2000\u20132006. Retrieved 2015-05-22.", - "enumerated": true, - "marker": "2." - }, - { - "self_ref": "#/texts/281", - "parent": { - "$ref": "#/groups/39" - }, - "children": [], - "content_layer": "body", - "label": "list_item", - "prov": [], - "orig": "^ Dohner, Janet Vorwald (2001). The Encyclopedia of Historic and Endangered Livestock and Poultry Breeds. Yale University Press. ISBN\u00a0978-0300138139.", - "text": "^ Dohner, Janet Vorwald (2001). The Encyclopedia of Historic and Endangered Livestock and Poultry Breeds. Yale University Press. ISBN\u00a0978-0300138139.", - "enumerated": true, - "marker": "3." - }, - { - "self_ref": "#/texts/282", - "parent": { - "$ref": "#/groups/39" - }, - "children": [], - "content_layer": "body", - "label": "list_item", - "prov": [], - "orig": "^ Visca, Curt; Visca, Kelley (2003). How to Draw Cartoon Birds. The Rosen Publishing Group. ISBN\u00a09780823961566.", - "text": "^ Visca, Curt; Visca, Kelley (2003). How to Draw Cartoon Birds. The Rosen Publishing Group. ISBN\u00a09780823961566.", - "enumerated": true, - "marker": "4." - }, - { - "self_ref": "#/texts/283", - "parent": { - "$ref": "#/groups/39" - }, - "children": [], - "content_layer": "body", - "label": "list_item", - "prov": [], - "orig": "^ a b c d Carboneras 1992, p.\u00a0536.", - "text": "^ a b c d Carboneras 1992, p.\u00a0536.", - "enumerated": true, - "marker": "5." - }, - { - "self_ref": "#/texts/284", - "parent": { - "$ref": "#/groups/39" - }, - "children": [], - "content_layer": "body", - "label": "list_item", - "prov": [], - "orig": "^ Livezey 1986, pp.\u00a0737\u2013738.", - "text": "^ Livezey 1986, pp.\u00a0737\u2013738.", - "enumerated": true, - "marker": "6." - }, - { - "self_ref": "#/texts/285", - "parent": { - "$ref": "#/groups/39" - }, - "children": [], - "content_layer": "body", - "label": "list_item", - "prov": [], - "orig": "^ Madsen, McHugh & de Kloet 1988, p.\u00a0452.", - "text": "^ Madsen, McHugh & de Kloet 1988, p.\u00a0452.", - "enumerated": true, - "marker": "7." - }, - { - "self_ref": "#/texts/286", - "parent": { - "$ref": "#/groups/39" - }, - "children": [], - "content_layer": "body", - "label": "list_item", - "prov": [], - "orig": "^ Donne-Gouss\u00e9, Laudet & H\u00e4nni 2002, pp.\u00a0353\u2013354.", - "text": "^ Donne-Gouss\u00e9, Laudet & H\u00e4nni 2002, pp.\u00a0353\u2013354.", - "enumerated": true, - "marker": "8." - }, - { - "self_ref": "#/texts/287", - "parent": { - "$ref": "#/groups/39" - }, - "children": [], - "content_layer": "body", - "label": "list_item", - "prov": [], - "orig": "^ a b c d e f Carboneras 1992, p.\u00a0540.", - "text": "^ a b c d e f Carboneras 1992, p.\u00a0540.", - "enumerated": true, - "marker": "9." - }, - { - "self_ref": "#/texts/288", - "parent": { - "$ref": "#/groups/39" - }, - "children": [], - "content_layer": "body", - "label": "list_item", - "prov": [], - "orig": "^ Elphick, Dunning & Sibley 2001, p.\u00a0191.", - "text": "^ Elphick, Dunning & Sibley 2001, p.\u00a0191.", - "enumerated": true, - "marker": "10." - }, - { - "self_ref": "#/texts/289", - "parent": { - "$ref": "#/groups/39" - }, - "children": [], - "content_layer": "body", - "label": "list_item", - "prov": [], - "orig": "^ Kear 2005, p.\u00a0448.", - "text": "^ Kear 2005, p.\u00a0448.", - "enumerated": true, - "marker": "11." - }, - { - "self_ref": "#/texts/290", - "parent": { - "$ref": "#/groups/39" - }, - "children": [], - "content_layer": "body", - "label": "list_item", - "prov": [], - "orig": "^ Kear 2005, p.\u00a0622\u2013623.", - "text": "^ Kear 2005, p.\u00a0622\u2013623.", - "enumerated": true, - "marker": "12." - }, - { - "self_ref": "#/texts/291", - "parent": { - "$ref": "#/groups/39" - }, - "children": [], - "content_layer": "body", - "label": "list_item", - "prov": [], - "orig": "^ Kear 2005, p.\u00a0686.", - "text": "^ Kear 2005, p.\u00a0686.", - "enumerated": true, - "marker": "13." - }, - { - "self_ref": "#/texts/292", - "parent": { - "$ref": "#/groups/39" - }, - "children": [], - "content_layer": "body", - "label": "list_item", - "prov": [], - "orig": "^ Elphick, Dunning & Sibley 2001, p.\u00a0193.", - "text": "^ Elphick, Dunning & Sibley 2001, p.\u00a0193.", - "enumerated": true, - "marker": "14." - }, - { - "self_ref": "#/texts/293", - "parent": { - "$ref": "#/groups/39" - }, - "children": [], - "content_layer": "body", - "label": "list_item", - "prov": [], - "orig": "^ a b c d e f g Carboneras 1992, p.\u00a0537.", - "text": "^ a b c d e f g Carboneras 1992, p.\u00a0537.", - "enumerated": true, - "marker": "15." - }, - { - "self_ref": "#/texts/294", - "parent": { - "$ref": "#/groups/39" - }, - "children": [], - "content_layer": "body", - "label": "list_item", - "prov": [], - "orig": "^ American Ornithologists' Union 1998, p.\u00a0xix.", - "text": "^ American Ornithologists' Union 1998, p.\u00a0xix.", - "enumerated": true, - "marker": "16." - }, - { - "self_ref": "#/texts/295", - "parent": { - "$ref": "#/groups/39" - }, - "children": [], - "content_layer": "body", - "label": "list_item", - "prov": [], - "orig": "^ American Ornithologists' Union 1998.", - "text": "^ American Ornithologists' Union 1998.", - "enumerated": true, - "marker": "17." - }, - { - "self_ref": "#/texts/296", - "parent": { - "$ref": "#/groups/39" - }, - "children": [], - "content_layer": "body", - "label": "list_item", - "prov": [], - "orig": "^ Carboneras 1992, p.\u00a0538.", - "text": "^ Carboneras 1992, p.\u00a0538.", - "enumerated": true, - "marker": "18." - }, - { - "self_ref": "#/texts/297", - "parent": { - "$ref": "#/groups/39" - }, - "children": [], - "content_layer": "body", - "label": "list_item", - "prov": [], - "orig": "^ Christidis & Boles 2008, p.\u00a062.", - "text": "^ Christidis & Boles 2008, p.\u00a062.", - "enumerated": true, - "marker": "19." - }, - { - "self_ref": "#/texts/298", - "parent": { - "$ref": "#/groups/39" - }, - "children": [], - "content_layer": "body", - "label": "list_item", - "prov": [], - "orig": "^ Shirihai 2008, pp.\u00a0239, 245.", - "text": "^ Shirihai 2008, pp.\u00a0239, 245.", - "enumerated": true, - "marker": "20." - }, - { - "self_ref": "#/texts/299", - "parent": { - "$ref": "#/groups/39" - }, - "children": [], - "content_layer": "body", - "label": "list_item", - "prov": [], - "orig": "^ a b Pratt, Bruner & Berrett 1987, pp.\u00a098\u2013107.", - "text": "^ a b Pratt, Bruner & Berrett 1987, pp.\u00a098\u2013107.", - "enumerated": true, - "marker": "21." - }, - { - "self_ref": "#/texts/300", - "parent": { - "$ref": "#/groups/39" - }, - "children": [], - "content_layer": "body", - "label": "list_item", - "prov": [], - "orig": "^ Fitter, Fitter & Hosking 2000, pp.\u00a052\u20133.", - "text": "^ Fitter, Fitter & Hosking 2000, pp.\u00a052\u20133.", - "enumerated": true, - "marker": "22." - }, - { - "self_ref": "#/texts/301", - "parent": { - "$ref": "#/groups/39" - }, - "children": [], - "content_layer": "body", - "label": "list_item", - "prov": [], - "orig": "^ \"Pacific Black Duck\". www.wiresnr.org. Retrieved 2018-04-27.", - "text": "^ \"Pacific Black Duck\". www.wiresnr.org. Retrieved 2018-04-27.", - "enumerated": true, - "marker": "23." + "level": 3 }, { "self_ref": "#/texts/302", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ Ogden, Evans. \"Dabbling Ducks\". CWE. Retrieved 2006-11-02.", - "text": "^ Ogden, Evans. \"Dabbling Ducks\". CWE. Retrieved 2006-11-02.", + "orig": "^ \"Duckling\" . The American Heritage Dictionary of the English Language, Fourth Edition . Houghton Mifflin Company. 2006 . Retrieved 2015-05-22 .", + "text": "^ \"Duckling\" . The American Heritage Dictionary of the English Language, Fourth Edition . Houghton Mifflin Company. 2006 . Retrieved 2015-05-22 .", "enumerated": true, - "marker": "24." + "marker": "-" }, { "self_ref": "#/texts/303", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ Karl Mathiesen (16 March 2015). \"Don't feed the ducks bread, say conservationists\". The Guardian. Retrieved 13 November 2016.", - "text": "^ Karl Mathiesen (16 March 2015). \"Don't feed the ducks bread, say conservationists\". The Guardian. Retrieved 13 November 2016.", + "orig": "^ \"Duckling\" . Kernerman English Multilingual Dictionary (Beta Version) . K. Dictionaries Ltd. 2000\u20132006 . Retrieved 2015-05-22 .", + "text": "^ \"Duckling\" . Kernerman English Multilingual Dictionary (Beta Version) . K. Dictionaries Ltd. 2000\u20132006 . Retrieved 2015-05-22 .", "enumerated": true, - "marker": "25." + "marker": "-" }, { "self_ref": "#/texts/304", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ Rohwer, Frank C.; Anderson, Michael G. (1988). \"Female-Biased Philopatry, Monogamy, and the Timing of Pair Formation in Migratory Waterfowl\". Current Ornithology. pp.\u00a0187\u2013221. doi:10.1007/978-1-4615-6787-5_4. ISBN\u00a0978-1-4615-6789-9.", - "text": "^ Rohwer, Frank C.; Anderson, Michael G. (1988). \"Female-Biased Philopatry, Monogamy, and the Timing of Pair Formation in Migratory Waterfowl\". Current Ornithology. pp.\u00a0187\u2013221. doi:10.1007/978-1-4615-6787-5_4. ISBN\u00a0978-1-4615-6789-9.", + "orig": "^ Dohner, Janet Vorwald (2001). The Encyclopedia of Historic and Endangered Livestock and Poultry Breeds . Yale University Press. ISBN 978-0300138139 .", + "text": "^ Dohner, Janet Vorwald (2001). The Encyclopedia of Historic and Endangered Livestock and Poultry Breeds . Yale University Press. ISBN 978-0300138139 .", "enumerated": true, - "marker": "26." + "marker": "-" }, { "self_ref": "#/texts/305", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ Smith, Cyndi M.; Cooke, Fred; Robertson, Gregory J.; Goudie, R. Ian; Boyd, W. Sean (2000). \"Long-Term Pair Bonds in Harlequin Ducks\". The Condor. 102 (1): 201\u2013205. doi:10.1093/condor/102.1.201. hdl:10315/13797.", - "text": "^ Smith, Cyndi M.; Cooke, Fred; Robertson, Gregory J.; Goudie, R. Ian; Boyd, W. Sean (2000). \"Long-Term Pair Bonds in Harlequin Ducks\". The Condor. 102 (1): 201\u2013205. doi:10.1093/condor/102.1.201. hdl:10315/13797.", + "orig": "^ Visca, Curt; Visca, Kelley (2003). How to Draw Cartoon Birds . The Rosen Publishing Group. ISBN 9780823961566 .", + "text": "^ Visca, Curt; Visca, Kelley (2003). How to Draw Cartoon Birds . The Rosen Publishing Group. ISBN 9780823961566 .", "enumerated": true, - "marker": "27." + "marker": "-" }, { "self_ref": "#/texts/306", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ \"If You Find An Orphaned Duckling - Wildlife Rehabber\". wildliferehabber.com. Archived from the original on 2018-09-23. Retrieved 2018-12-22.", - "text": "^ \"If You Find An Orphaned Duckling - Wildlife Rehabber\". wildliferehabber.com. Archived from the original on 2018-09-23. Retrieved 2018-12-22.", + "orig": "^ a b c d Carboneras 1992 , p.\u00a0536.", + "text": "^ a b c d Carboneras 1992 , p.\u00a0536.", "enumerated": true, - "marker": "28." + "marker": "-" }, { "self_ref": "#/texts/307", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ Carver, Heather (2011). The Duck Bible. Lulu.com. ISBN\u00a09780557901562.[self-published source]", - "text": "^ Carver, Heather (2011). The Duck Bible. Lulu.com. ISBN\u00a09780557901562.[self-published source]", + "orig": "^ Livezey 1986 , pp.\u00a0737\u2013738.", + "text": "^ Livezey 1986 , pp.\u00a0737\u2013738.", "enumerated": true, - "marker": "29." + "marker": "-" }, { "self_ref": "#/texts/308", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ Titlow, Budd (2013-09-03). Bird Brains: Inside the Strange Minds of Our Fine Feathered Friends. Rowman & Littlefield. ISBN\u00a09780762797707.", - "text": "^ Titlow, Budd (2013-09-03). Bird Brains: Inside the Strange Minds of Our Fine Feathered Friends. Rowman & Littlefield. ISBN\u00a09780762797707.", + "orig": "^ Madsen, McHugh & de Kloet 1988 , p.\u00a0452.", + "text": "^ Madsen, McHugh & de Kloet 1988 , p.\u00a0452.", "enumerated": true, - "marker": "30." + "marker": "-" }, { "self_ref": "#/texts/309", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ Amos, Jonathan (2003-09-08). \"Sound science is quackers\". BBC News. Retrieved 2006-11-02.", - "text": "^ Amos, Jonathan (2003-09-08). \"Sound science is quackers\". BBC News. Retrieved 2006-11-02.", + "orig": "^ Donne-Gouss\u00e9, Laudet & H\u00e4nni 2002 , pp.\u00a0353\u2013354.", + "text": "^ Donne-Gouss\u00e9, Laudet & H\u00e4nni 2002 , pp.\u00a0353\u2013354.", "enumerated": true, - "marker": "31." + "marker": "-" }, { "self_ref": "#/texts/310", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ \"Mythbusters Episode 8\". 12 December 2003.", - "text": "^ \"Mythbusters Episode 8\". 12 December 2003.", + "orig": "^ a b c d e f Carboneras 1992 , p.\u00a0540.", + "text": "^ a b c d e f Carboneras 1992 , p.\u00a0540.", "enumerated": true, - "marker": "32." + "marker": "-" }, { "self_ref": "#/texts/311", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ Erlandson 1994, p.\u00a0171.", - "text": "^ Erlandson 1994, p.\u00a0171.", + "orig": "^ Elphick, Dunning & Sibley 2001 , p.\u00a0191.", + "text": "^ Elphick, Dunning & Sibley 2001 , p.\u00a0191.", "enumerated": true, - "marker": "33." + "marker": "-" }, { "self_ref": "#/texts/312", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ Jeffries 2008, pp.\u00a0168, 243.", - "text": "^ Jeffries 2008, pp.\u00a0168, 243.", + "orig": "^ Kear 2005 , p.\u00a0448.", + "text": "^ Kear 2005 , p.\u00a0448.", "enumerated": true, - "marker": "34." + "marker": "-" }, { "self_ref": "#/texts/313", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ a b Sued-Badillo 2003, p.\u00a065.", - "text": "^ a b Sued-Badillo 2003, p.\u00a065.", + "orig": "^ Kear 2005 , p.\u00a0622\u2013623.", + "text": "^ Kear 2005 , p.\u00a0622\u2013623.", "enumerated": true, - "marker": "35." + "marker": "-" }, { "self_ref": "#/texts/314", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ Thorpe 1996, p.\u00a068.", - "text": "^ Thorpe 1996, p.\u00a068.", + "orig": "^ Kear 2005 , p.\u00a0686.", + "text": "^ Kear 2005 , p.\u00a0686.", "enumerated": true, - "marker": "36." + "marker": "-" }, { "self_ref": "#/texts/315", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ Maisels 1999, p.\u00a042.", - "text": "^ Maisels 1999, p.\u00a042.", + "orig": "^ Elphick, Dunning & Sibley 2001 , p.\u00a0193.", + "text": "^ Elphick, Dunning & Sibley 2001 , p.\u00a0193.", "enumerated": true, - "marker": "37." + "marker": "-" }, { "self_ref": "#/texts/316", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ Rau 1876, p.\u00a0133.", - "text": "^ Rau 1876, p.\u00a0133.", + "orig": "^ a b c d e f g Carboneras 1992 , p.\u00a0537.", + "text": "^ a b c d e f g Carboneras 1992 , p.\u00a0537.", "enumerated": true, - "marker": "38." + "marker": "-" }, { "self_ref": "#/texts/317", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ Higman 2012, p.\u00a023.", - "text": "^ Higman 2012, p.\u00a023.", + "orig": "^ American Ornithologists' Union 1998 , p.\u00a0xix.", + "text": "^ American Ornithologists' Union 1998 , p.\u00a0xix.", "enumerated": true, - "marker": "39." + "marker": "-" }, { "self_ref": "#/texts/318", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ Hume 2012, p.\u00a053.", - "text": "^ Hume 2012, p.\u00a053.", + "orig": "^ American Ornithologists' Union 1998 .", + "text": "^ American Ornithologists' Union 1998 .", "enumerated": true, - "marker": "40." + "marker": "-" }, { "self_ref": "#/texts/319", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ Hume 2012, p.\u00a052.", - "text": "^ Hume 2012, p.\u00a052.", + "orig": "^ Carboneras 1992 , p.\u00a0538.", + "text": "^ Carboneras 1992 , p.\u00a0538.", "enumerated": true, - "marker": "41." + "marker": "-" }, { "self_ref": "#/texts/320", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ Fieldhouse 2002, p.\u00a0167.", - "text": "^ Fieldhouse 2002, p.\u00a0167.", + "orig": "^ Christidis & Boles 2008 , p.\u00a062.", + "text": "^ Christidis & Boles 2008 , p.\u00a062.", "enumerated": true, - "marker": "42." + "marker": "-" }, { "self_ref": "#/texts/321", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ Livingston, A. D. (1998-01-01). Guide to Edible Plants and Animals. Wordsworth Editions, Limited. ISBN\u00a09781853263774.", - "text": "^ Livingston, A. D. (1998-01-01). Guide to Edible Plants and Animals. Wordsworth Editions, Limited. ISBN\u00a09781853263774.", + "orig": "^ Shirihai 2008 , pp.\u00a0239, 245.", + "text": "^ Shirihai 2008 , pp.\u00a0239, 245.", "enumerated": true, - "marker": "43." + "marker": "-" }, { "self_ref": "#/texts/322", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ \"Study plan for waterfowl injury assessment: Determining PCB concentrations in Hudson river resident waterfowl\" (PDF). New York State Department of Environmental Conservation. US Department of Commerce. December 2008. p.\u00a03. Archived (PDF) from the original on 2022-10-09. Retrieved 2 July 2019.", - "text": "^ \"Study plan for waterfowl injury assessment: Determining PCB concentrations in Hudson river resident waterfowl\" (PDF). New York State Department of Environmental Conservation. US Department of Commerce. December 2008. p.\u00a03. Archived (PDF) from the original on 2022-10-09. Retrieved 2 July 2019.", + "orig": "^ a b Pratt, Bruner & Berrett 1987 , pp.\u00a098\u2013107.", + "text": "^ a b Pratt, Bruner & Berrett 1987 , pp.\u00a098\u2013107.", "enumerated": true, - "marker": "44." + "marker": "-" }, { "self_ref": "#/texts/323", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ \"FAOSTAT\". www.fao.org. Retrieved 2019-10-25.", - "text": "^ \"FAOSTAT\". www.fao.org. Retrieved 2019-10-25.", + "orig": "^ Fitter, Fitter & Hosking 2000 , pp.\u00a052\u20133.", + "text": "^ Fitter, Fitter & Hosking 2000 , pp.\u00a052\u20133.", "enumerated": true, - "marker": "45." + "marker": "-" }, { "self_ref": "#/texts/324", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ \"Anas platyrhynchos, Domestic Duck; DigiMorph Staff - The University of Texas at Austin\". Digimorph.org. Retrieved 2012-12-23.", - "text": "^ \"Anas platyrhynchos, Domestic Duck; DigiMorph Staff - The University of Texas at Austin\". Digimorph.org. Retrieved 2012-12-23.", + "orig": "^ \"Pacific Black Duck\" . www.wiresnr.org . Retrieved 2018-04-27 .", + "text": "^ \"Pacific Black Duck\" . www.wiresnr.org . Retrieved 2018-04-27 .", "enumerated": true, - "marker": "46." + "marker": "-" }, { "self_ref": "#/texts/325", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ Sy Montgomery. \"Mallard; Encyclop\u00e6dia Britannica\". Britannica.com. Retrieved 2012-12-23.", - "text": "^ Sy Montgomery. \"Mallard; Encyclop\u00e6dia Britannica\". Britannica.com. Retrieved 2012-12-23.", + "orig": "^ Ogden, Evans. \"Dabbling Ducks\" . CWE . Retrieved 2006-11-02 .", + "text": "^ Ogden, Evans. \"Dabbling Ducks\" . CWE . Retrieved 2006-11-02 .", "enumerated": true, - "marker": "47." + "marker": "-" }, { "self_ref": "#/texts/326", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ Glenday, Craig (2014). Guinness World Records. Guinness World Records Limited. pp.\u00a0135. ISBN\u00a0978-1-908843-15-9.", - "text": "^ Glenday, Craig (2014). Guinness World Records. Guinness World Records Limited. pp.\u00a0135. ISBN\u00a0978-1-908843-15-9.", + "orig": "^ Karl Mathiesen (16 March 2015). \"Don't feed the ducks bread, say conservationists\" . The Guardian . Retrieved 13 November 2016 .", + "text": "^ Karl Mathiesen (16 March 2015). \"Don't feed the ducks bread, say conservationists\" . The Guardian . Retrieved 13 November 2016 .", "enumerated": true, - "marker": "48." + "marker": "-" }, { "self_ref": "#/texts/327", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ Suomen kunnallisvaakunat (in Finnish). Suomen Kunnallisliitto. 1982. p.\u00a0147. ISBN\u00a0951-773-085-3.", - "text": "^ Suomen kunnallisvaakunat (in Finnish). Suomen Kunnallisliitto. 1982. p.\u00a0147. ISBN\u00a0951-773-085-3.", + "orig": "^ Rohwer, Frank C.; Anderson, Michael G. (1988). \"Female-Biased Philopatry, Monogamy, and the Timing of Pair Formation in Migratory Waterfowl\". Current Ornithology . pp.\u00a0187\u2013221. doi : 10.1007/978-1-4615-6787-5_4 . ISBN 978-1-4615-6789-9 .", + "text": "^ Rohwer, Frank C.; Anderson, Michael G. (1988). \"Female-Biased Philopatry, Monogamy, and the Timing of Pair Formation in Migratory Waterfowl\". Current Ornithology . pp.\u00a0187\u2013221. doi : 10.1007/978-1-4615-6787-5_4 . ISBN 978-1-4615-6789-9 .", "enumerated": true, - "marker": "49." + "marker": "-" }, { "self_ref": "#/texts/328", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ \"Lub\u0101nas simbolika\" (in Latvian). Retrieved September 9, 2021.", - "text": "^ \"Lub\u0101nas simbolika\" (in Latvian). Retrieved September 9, 2021.", + "orig": "^ Smith, Cyndi M.; Cooke, Fred; Robertson, Gregory J.; Goudie, R. Ian; Boyd, W. Sean (2000). \"Long-Term Pair Bonds in Harlequin Ducks\" . The Condor . 102 (1): 201\u2013205. doi : 10.1093/condor/102.1.201 . hdl : 10315/13797 .", + "text": "^ Smith, Cyndi M.; Cooke, Fred; Robertson, Gregory J.; Goudie, R. Ian; Boyd, W. Sean (2000). \"Long-Term Pair Bonds in Harlequin Ducks\" . The Condor . 102 (1): 201\u2013205. doi : 10.1093/condor/102.1.201 . hdl : 10315/13797 .", "enumerated": true, - "marker": "50." + "marker": "-" }, { "self_ref": "#/texts/329", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ \"F\u00f6gl\u00f6\" (in Swedish). Retrieved September 9, 2021.", - "text": "^ \"F\u00f6gl\u00f6\" (in Swedish). Retrieved September 9, 2021.", + "orig": "^ \"If You Find An Orphaned Duckling - Wildlife Rehabber\" . wildliferehabber.com . Archived from the original on 2018-09-23 . Retrieved 2018-12-22 .", + "text": "^ \"If You Find An Orphaned Duckling - Wildlife Rehabber\" . wildliferehabber.com . Archived from the original on 2018-09-23 . Retrieved 2018-12-22 .", "enumerated": true, - "marker": "51." + "marker": "-" }, { "self_ref": "#/texts/330", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ Young, Emma. \"World's funniest joke revealed\". New Scientist. Retrieved 7 January 2019.", - "text": "^ Young, Emma. \"World's funniest joke revealed\". New Scientist. Retrieved 7 January 2019.", + "orig": "^ Carver, Heather (2011). The Duck Bible . Lulu.com. ISBN 9780557901562 . [ self-published source ]", + "text": "^ Carver, Heather (2011). The Duck Bible . Lulu.com. ISBN 9780557901562 . [ self-published source ]", "enumerated": true, - "marker": "52." + "marker": "-" }, { "self_ref": "#/texts/331", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ \"Howard the Duck (character)\". Grand Comics Database.", - "text": "^ \"Howard the Duck (character)\". Grand Comics Database.", + "orig": "^ Titlow, Budd (2013-09-03). Bird Brains: Inside the Strange Minds of Our Fine Feathered Friends . Rowman & Littlefield. ISBN 9780762797707 .", + "text": "^ Titlow, Budd (2013-09-03). Bird Brains: Inside the Strange Minds of Our Fine Feathered Friends . Rowman & Littlefield. ISBN 9780762797707 .", "enumerated": true, - "marker": "53." + "marker": "-" }, { "self_ref": "#/texts/332", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ Sanderson, Peter; Gilbert, Laura (2008). \"1970s\". Marvel Chronicle A Year by Year History. London, United Kingdom: Dorling Kindersley. p.\u00a0161. ISBN\u00a0978-0756641238. December saw the debut of the cigar-smoking Howard the Duck. In this story by writer Steve Gerber and artist Val Mayerik, various beings from different realities had begun turning up in the Man-Thing's Florida swamp, including this bad-tempered talking duck.", - "text": "^ Sanderson, Peter; Gilbert, Laura (2008). \"1970s\". Marvel Chronicle A Year by Year History. London, United Kingdom: Dorling Kindersley. p.\u00a0161. ISBN\u00a0978-0756641238. December saw the debut of the cigar-smoking Howard the Duck. In this story by writer Steve Gerber and artist Val Mayerik, various beings from different realities had begun turning up in the Man-Thing's Florida swamp, including this bad-tempered talking duck.", + "orig": "^ Amos, Jonathan (2003-09-08). \"Sound science is quackers\" . BBC News . Retrieved 2006-11-02 .", + "text": "^ Amos, Jonathan (2003-09-08). \"Sound science is quackers\" . BBC News . Retrieved 2006-11-02 .", "enumerated": true, - "marker": "54." + "marker": "-" }, { "self_ref": "#/texts/333", "parent": { - "$ref": "#/groups/39" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "^ \"The Duck\". University of Oregon Athletics. Retrieved 2022-01-20.", - "text": "^ \"The Duck\". University of Oregon Athletics. Retrieved 2022-01-20.", + "orig": "^ \"Mythbusters Episode 8\" . 12 December 2003.", + "text": "^ \"Mythbusters Episode 8\" . 12 December 2003.", "enumerated": true, - "marker": "55." + "marker": "-" }, { "self_ref": "#/texts/334", "parent": { - "$ref": "#/texts/277" - }, - "children": [ - { - "$ref": "#/groups/40" - } - ], - "content_layer": "body", - "label": "section_header", - "prov": [], - "orig": "Sources", - "text": "Sources", - "level": 2 - }, - { - "self_ref": "#/texts/335", - "parent": { - "$ref": "#/groups/40" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "American Ornithologists' Union (1998). Checklist of North American Birds (PDF). Washington, DC: American Ornithologists' Union. ISBN\u00a0978-1-891276-00-2. Archived (PDF) from the original on 2022-10-09.", - "text": "American Ornithologists' Union (1998). Checklist of North American Birds (PDF). Washington, DC: American Ornithologists' Union. ISBN\u00a0978-1-891276-00-2. Archived (PDF) from the original on 2022-10-09.", - "enumerated": false, + "orig": "^ Erlandson 1994 , p.\u00a0171.", + "text": "^ Erlandson 1994 , p.\u00a0171.", + "enumerated": true, + "marker": "-" + }, + { + "self_ref": "#/texts/335", + "parent": { + "$ref": "#/groups/38" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "^ Jeffries 2008 , pp.\u00a0168, 243.", + "text": "^ Jeffries 2008 , pp.\u00a0168, 243.", + "enumerated": true, "marker": "-" }, { "self_ref": "#/texts/336", "parent": { - "$ref": "#/groups/40" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "Carboneras, Carlos (1992). del Hoyo, Josep; Elliott, Andrew; Sargatal, Jordi (eds.). Handbook of the Birds of the World. Vol.\u00a01: Ostrich to Ducks. Barcelona: Lynx Edicions. ISBN\u00a0978-84-87334-10-8.", - "text": "Carboneras, Carlos (1992). del Hoyo, Josep; Elliott, Andrew; Sargatal, Jordi (eds.). Handbook of the Birds of the World. Vol.\u00a01: Ostrich to Ducks. Barcelona: Lynx Edicions. ISBN\u00a0978-84-87334-10-8.", - "enumerated": false, + "orig": "^ a b Sued-Badillo 2003 , p.\u00a065.", + "text": "^ a b Sued-Badillo 2003 , p.\u00a065.", + "enumerated": true, "marker": "-" }, { "self_ref": "#/texts/337", "parent": { - "$ref": "#/groups/40" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "Christidis, Les; Boles, Walter E., eds. (2008). Systematics and Taxonomy of Australian Birds. Collingwood, VIC: Csiro Publishing. ISBN\u00a0978-0-643-06511-6.", - "text": "Christidis, Les; Boles, Walter E., eds. (2008). Systematics and Taxonomy of Australian Birds. Collingwood, VIC: Csiro Publishing. ISBN\u00a0978-0-643-06511-6.", - "enumerated": false, + "orig": "^ Thorpe 1996 , p.\u00a068.", + "text": "^ Thorpe 1996 , p.\u00a068.", + "enumerated": true, "marker": "-" }, { "self_ref": "#/texts/338", "parent": { - "$ref": "#/groups/40" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "Donne-Gouss\u00e9, Carole; Laudet, Vincent; H\u00e4nni, Catherine (July 2002). \"A molecular phylogeny of Anseriformes based on mitochondrial DNA analysis\". Molecular Phylogenetics and Evolution. 23 (3): 339\u2013356. Bibcode:2002MolPE..23..339D. doi:10.1016/S1055-7903(02)00019-2. PMID\u00a012099792.", - "text": "Donne-Gouss\u00e9, Carole; Laudet, Vincent; H\u00e4nni, Catherine (July 2002). \"A molecular phylogeny of Anseriformes based on mitochondrial DNA analysis\". Molecular Phylogenetics and Evolution. 23 (3): 339\u2013356. Bibcode:2002MolPE..23..339D. doi:10.1016/S1055-7903(02)00019-2. PMID\u00a012099792.", - "enumerated": false, + "orig": "^ Maisels 1999 , p.\u00a042.", + "text": "^ Maisels 1999 , p.\u00a042.", + "enumerated": true, "marker": "-" }, { "self_ref": "#/texts/339", "parent": { - "$ref": "#/groups/40" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "Elphick, Chris; Dunning, John B. Jr.; Sibley, David, eds. (2001). The Sibley Guide to Bird Life and Behaviour. London: Christopher Helm. ISBN\u00a0978-0-7136-6250-4.", - "text": "Elphick, Chris; Dunning, John B. Jr.; Sibley, David, eds. (2001). The Sibley Guide to Bird Life and Behaviour. London: Christopher Helm. ISBN\u00a0978-0-7136-6250-4.", - "enumerated": false, + "orig": "^ Rau 1876 , p.\u00a0133.", + "text": "^ Rau 1876 , p.\u00a0133.", + "enumerated": true, "marker": "-" }, { "self_ref": "#/texts/340", "parent": { - "$ref": "#/groups/40" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "Erlandson, Jon M. (1994). Early Hunter-Gatherers of the California Coast. New York, NY: Springer Science & Business Media. ISBN\u00a0978-1-4419-3231-0.", - "text": "Erlandson, Jon M. (1994). Early Hunter-Gatherers of the California Coast. New York, NY: Springer Science & Business Media. ISBN\u00a0978-1-4419-3231-0.", - "enumerated": false, + "orig": "^ Higman 2012 , p.\u00a023.", + "text": "^ Higman 2012 , p.\u00a023.", + "enumerated": true, "marker": "-" }, { "self_ref": "#/texts/341", "parent": { - "$ref": "#/groups/40" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "Fieldhouse, Paul (2002). Food, Feasts, and Faith: An Encyclopedia of Food Culture in World Religions. Vol.\u00a0I: A\u2013K. Santa Barbara: ABC-CLIO. ISBN\u00a0978-1-61069-412-4.", - "text": "Fieldhouse, Paul (2002). Food, Feasts, and Faith: An Encyclopedia of Food Culture in World Religions. Vol.\u00a0I: A\u2013K. Santa Barbara: ABC-CLIO. ISBN\u00a0978-1-61069-412-4.", - "enumerated": false, + "orig": "^ Hume 2012 , p.\u00a053.", + "text": "^ Hume 2012 , p.\u00a053.", + "enumerated": true, "marker": "-" }, { "self_ref": "#/texts/342", "parent": { - "$ref": "#/groups/40" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "Fitter, Julian; Fitter, Daniel; Hosking, David (2000). Wildlife of the Gal\u00e1pagos. Princeton, NJ: Princeton University Press. ISBN\u00a0978-0-691-10295-5.", - "text": "Fitter, Julian; Fitter, Daniel; Hosking, David (2000). Wildlife of the Gal\u00e1pagos. Princeton, NJ: Princeton University Press. ISBN\u00a0978-0-691-10295-5.", - "enumerated": false, + "orig": "^ Hume 2012 , p.\u00a052.", + "text": "^ Hume 2012 , p.\u00a052.", + "enumerated": true, "marker": "-" }, { "self_ref": "#/texts/343", "parent": { - "$ref": "#/groups/40" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "Higman, B. W. (2012). How Food Made History. Chichester, UK: John Wiley & Sons. ISBN\u00a0978-1-4051-8947-7.", - "text": "Higman, B. W. (2012). How Food Made History. Chichester, UK: John Wiley & Sons. ISBN\u00a0978-1-4051-8947-7.", - "enumerated": false, + "orig": "^ Fieldhouse 2002 , p.\u00a0167.", + "text": "^ Fieldhouse 2002 , p.\u00a0167.", + "enumerated": true, "marker": "-" }, { "self_ref": "#/texts/344", "parent": { - "$ref": "#/groups/40" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "Hume, Julian H. (2012). Extinct Birds. London: Christopher Helm. ISBN\u00a0978-1-4729-3744-5.", - "text": "Hume, Julian H. (2012). Extinct Birds. London: Christopher Helm. ISBN\u00a0978-1-4729-3744-5.", - "enumerated": false, + "orig": "^ Livingston, A. D. (1998-01-01). Guide to Edible Plants and Animals . Wordsworth Editions, Limited. ISBN 9781853263774 .", + "text": "^ Livingston, A. D. (1998-01-01). Guide to Edible Plants and Animals . Wordsworth Editions, Limited. ISBN 9781853263774 .", + "enumerated": true, "marker": "-" }, { "self_ref": "#/texts/345", "parent": { - "$ref": "#/groups/40" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "Jeffries, Richard (2008). Holocene Hunter-Gatherers of the Lower Ohio River Valley. Tuscaloosa: University of Alabama Press. ISBN\u00a0978-0-8173-1658-7.", - "text": "Jeffries, Richard (2008). Holocene Hunter-Gatherers of the Lower Ohio River Valley. Tuscaloosa: University of Alabama Press. ISBN\u00a0978-0-8173-1658-7.", - "enumerated": false, + "orig": "^ \"Study plan for waterfowl injury assessment: Determining PCB concentrations in Hudson river resident waterfowl\" (PDF) . New York State Department of Environmental Conservation . US Department of Commerce. December 2008. p.\u00a03. Archived (PDF) from the original on 2022-10-09 . Retrieved 2 July 2019 .", + "text": "^ \"Study plan for waterfowl injury assessment: Determining PCB concentrations in Hudson river resident waterfowl\" (PDF) . New York State Department of Environmental Conservation . US Department of Commerce. December 2008. p.\u00a03. Archived (PDF) from the original on 2022-10-09 . Retrieved 2 July 2019 .", + "enumerated": true, "marker": "-" }, { "self_ref": "#/texts/346", "parent": { - "$ref": "#/groups/40" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "Kear, Janet, ed. (2005). Ducks, Geese and Swans: Species Accounts (Cairina to Mergus). Bird Families of the World. Oxford: Oxford University Press. ISBN\u00a0978-0-19-861009-0.", - "text": "Kear, Janet, ed. (2005). Ducks, Geese and Swans: Species Accounts (Cairina to Mergus). Bird Families of the World. Oxford: Oxford University Press. ISBN\u00a0978-0-19-861009-0.", - "enumerated": false, + "orig": "^ \"FAOSTAT\" . www.fao.org . Retrieved 2019-10-25 .", + "text": "^ \"FAOSTAT\" . www.fao.org . Retrieved 2019-10-25 .", + "enumerated": true, "marker": "-" }, { "self_ref": "#/texts/347", "parent": { - "$ref": "#/groups/40" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "Livezey, Bradley C. (October 1986). \"A phylogenetic analysis of recent Anseriform genera using morphological characters\" (PDF). The Auk. 103 (4): 737\u2013754. doi:10.1093/auk/103.4.737. Archived (PDF) from the original on 2022-10-09.", - "text": "Livezey, Bradley C. (October 1986). \"A phylogenetic analysis of recent Anseriform genera using morphological characters\" (PDF). The Auk. 103 (4): 737\u2013754. doi:10.1093/auk/103.4.737. Archived (PDF) from the original on 2022-10-09.", - "enumerated": false, + "orig": "^ \"Anas platyrhynchos, Domestic Duck; DigiMorph Staff - The University of Texas at Austin\" . Digimorph.org . Retrieved 2012-12-23 .", + "text": "^ \"Anas platyrhynchos, Domestic Duck; DigiMorph Staff - The University of Texas at Austin\" . Digimorph.org . Retrieved 2012-12-23 .", + "enumerated": true, "marker": "-" }, { "self_ref": "#/texts/348", "parent": { - "$ref": "#/groups/40" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "Madsen, Cort S.; McHugh, Kevin P.; de Kloet, Siwo R. (July 1988). \"A partial classification of waterfowl (Anatidae) based on single-copy DNA\" (PDF). The Auk. 105 (3): 452\u2013459. doi:10.1093/auk/105.3.452. Archived (PDF) from the original on 2022-10-09.", - "text": "Madsen, Cort S.; McHugh, Kevin P.; de Kloet, Siwo R. (July 1988). \"A partial classification of waterfowl (Anatidae) based on single-copy DNA\" (PDF). The Auk. 105 (3): 452\u2013459. doi:10.1093/auk/105.3.452. Archived (PDF) from the original on 2022-10-09.", - "enumerated": false, + "orig": "^ Sy Montgomery. \"Mallard; Encyclop\u00e6dia Britannica\" . Britannica.com . Retrieved 2012-12-23 .", + "text": "^ Sy Montgomery. \"Mallard; Encyclop\u00e6dia Britannica\" . Britannica.com . Retrieved 2012-12-23 .", + "enumerated": true, "marker": "-" }, { "self_ref": "#/texts/349", "parent": { - "$ref": "#/groups/40" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "Maisels, Charles Keith (1999). Early Civilizations of the Old World. London: Routledge. ISBN\u00a0978-0-415-10975-8.", - "text": "Maisels, Charles Keith (1999). Early Civilizations of the Old World. London: Routledge. ISBN\u00a0978-0-415-10975-8.", - "enumerated": false, + "orig": "^ Glenday, Craig (2014). Guinness World Records . Guinness World Records Limited. pp. 135 . ISBN 978-1-908843-15-9 .", + "text": "^ Glenday, Craig (2014). Guinness World Records . Guinness World Records Limited. pp. 135 . ISBN 978-1-908843-15-9 .", + "enumerated": true, "marker": "-" }, { "self_ref": "#/texts/350", "parent": { - "$ref": "#/groups/40" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "Pratt, H. Douglas; Bruner, Phillip L.; Berrett, Delwyn G. (1987). A Field Guide to the Birds of Hawaii and the Tropical Pacific. Princeton, NJ: Princeton University Press. ISBN\u00a00-691-02399-9.", - "text": "Pratt, H. Douglas; Bruner, Phillip L.; Berrett, Delwyn G. (1987). A Field Guide to the Birds of Hawaii and the Tropical Pacific. Princeton, NJ: Princeton University Press. ISBN\u00a00-691-02399-9.", - "enumerated": false, + "orig": "^ Suomen kunnallisvaakunat (in Finnish). Suomen Kunnallisliitto. 1982. p.\u00a0147. ISBN 951-773-085-3 .", + "text": "^ Suomen kunnallisvaakunat (in Finnish). Suomen Kunnallisliitto. 1982. p.\u00a0147. ISBN 951-773-085-3 .", + "enumerated": true, "marker": "-" }, { "self_ref": "#/texts/351", "parent": { - "$ref": "#/groups/40" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "Rau, Charles (1876). Early Man in Europe. New York: Harper & Brothers. LCCN\u00a005040168.", - "text": "Rau, Charles (1876). Early Man in Europe. New York: Harper & Brothers. LCCN\u00a005040168.", - "enumerated": false, + "orig": "^ \"Lub\u0101nas simbolika\" (in Latvian) . Retrieved September 9, 2021 .", + "text": "^ \"Lub\u0101nas simbolika\" (in Latvian) . Retrieved September 9, 2021 .", + "enumerated": true, "marker": "-" }, { "self_ref": "#/texts/352", "parent": { - "$ref": "#/groups/40" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "Shirihai, Hadoram (2008). A Complete Guide to Antarctic Wildlife. Princeton, NJ, US: Princeton University Press. ISBN\u00a0978-0-691-13666-0.", - "text": "Shirihai, Hadoram (2008). A Complete Guide to Antarctic Wildlife. Princeton, NJ, US: Princeton University Press. ISBN\u00a0978-0-691-13666-0.", - "enumerated": false, + "orig": "^ \"F\u00f6gl\u00f6\" (in Swedish) . Retrieved September 9, 2021 .", + "text": "^ \"F\u00f6gl\u00f6\" (in Swedish) . Retrieved September 9, 2021 .", + "enumerated": true, "marker": "-" }, { "self_ref": "#/texts/353", "parent": { - "$ref": "#/groups/40" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "Sued-Badillo, Jalil (2003). Autochthonous Societies. General History of the Caribbean. Paris: UNESCO. ISBN\u00a0978-92-3-103832-7.", - "text": "Sued-Badillo, Jalil (2003). Autochthonous Societies. General History of the Caribbean. Paris: UNESCO. ISBN\u00a0978-92-3-103832-7.", - "enumerated": false, + "orig": "^ Young, Emma. \"World's funniest joke revealed\" . New Scientist . Retrieved 7 January 2019 .", + "text": "^ Young, Emma. \"World's funniest joke revealed\" . New Scientist . Retrieved 7 January 2019 .", + "enumerated": true, "marker": "-" }, { "self_ref": "#/texts/354", "parent": { - "$ref": "#/groups/40" + "$ref": "#/groups/38" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "Thorpe, I. J. (1996). The Origins of Agriculture in Europe. New York: Routledge. ISBN\u00a0978-0-415-08009-5.", - "text": "Thorpe, I. J. (1996). The Origins of Agriculture in Europe. New York: Routledge. ISBN\u00a0978-0-415-08009-5.", - "enumerated": false, + "orig": "^ \"Howard the Duck (character)\" . Grand Comics Database .", + "text": "^ \"Howard the Duck (character)\" . Grand Comics Database .", + "enumerated": true, "marker": "-" }, { "self_ref": "#/texts/355", "parent": { - "$ref": "#/texts/43" + "$ref": "#/groups/38" }, - "children": [ - { - "$ref": "#/groups/41" - }, - { - "$ref": "#/groups/42" - }, - { - "$ref": "#/tables/1" - }, - { - "$ref": "#/pictures/17" - }, - { - "$ref": "#/texts/365" - }, - { - "$ref": "#/texts/366" - }, - { - "$ref": "#/groups/43" - }, - { - "$ref": "#/texts/370" - }, - { - "$ref": "#/groups/44" - }, - { - "$ref": "#/groups/45" - }, - { - "$ref": "#/groups/46" - }, - { - "$ref": "#/groups/47" - }, - { - "$ref": "#/groups/48" - } - ], + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "^ Sanderson, Peter ; Gilbert, Laura (2008). \"1970s\". Marvel Chronicle A Year by Year History . London, United Kingdom: Dorling Kindersley . p.\u00a0161. ISBN 978-0756641238 . December saw the debut of the cigar-smoking Howard the Duck. In this story by writer Steve Gerber and artist Val Mayerik, various beings from different realities had begun turning up in the Man-Thing's Florida swamp, including this bad-tempered talking duck.", + "text": "^ Sanderson, Peter ; Gilbert, Laura (2008). \"1970s\". Marvel Chronicle A Year by Year History . London, United Kingdom: Dorling Kindersley . p.\u00a0161. ISBN 978-0756641238 . December saw the debut of the cigar-smoking Howard the Duck. In this story by writer Steve Gerber and artist Val Mayerik, various beings from different realities had begun turning up in the Man-Thing's Florida swamp, including this bad-tempered talking duck.", + "enumerated": true, + "marker": "-" + }, + { + "self_ref": "#/texts/356", + "parent": { + "$ref": "#/groups/38" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "^ \"The Duck\" . University of Oregon Athletics . Retrieved 2022-01-20 .", + "text": "^ \"The Duck\" . University of Oregon Athletics . Retrieved 2022-01-20 .", + "enumerated": true, + "marker": "-" + }, + { + "self_ref": "#/texts/357", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "section_header", + "prov": [], + "orig": "Sources", + "text": "Sources", + "level": 3 + }, + { + "self_ref": "#/texts/358", + "parent": { + "$ref": "#/groups/39" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "American Ornithologists' Union (1998). Checklist of North American Birds (PDF) . Washington, DC: American Ornithologists' Union. ISBN 978-1-891276-00-2 . Archived (PDF) from the original on 2022-10-09.", + "text": "American Ornithologists' Union (1998). Checklist of North American Birds (PDF) . Washington, DC: American Ornithologists' Union. ISBN 978-1-891276-00-2 . Archived (PDF) from the original on 2022-10-09.", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/359", + "parent": { + "$ref": "#/groups/39" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Carboneras, Carlos (1992). del Hoyo, Josep; Elliott, Andrew; Sargatal, Jordi (eds.). Handbook of the Birds of the World . Vol.\u00a01: Ostrich to Ducks. Barcelona: Lynx Edicions. ISBN 978-84-87334-10-8 .", + "text": "Carboneras, Carlos (1992). del Hoyo, Josep; Elliott, Andrew; Sargatal, Jordi (eds.). Handbook of the Birds of the World . Vol.\u00a01: Ostrich to Ducks. Barcelona: Lynx Edicions. ISBN 978-84-87334-10-8 .", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/360", + "parent": { + "$ref": "#/groups/39" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Christidis, Les; Boles, Walter E., eds. (2008). Systematics and Taxonomy of Australian Birds . Collingwood, VIC: Csiro Publishing. ISBN 978-0-643-06511-6 .", + "text": "Christidis, Les; Boles, Walter E., eds. (2008). Systematics and Taxonomy of Australian Birds . Collingwood, VIC: Csiro Publishing. ISBN 978-0-643-06511-6 .", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/361", + "parent": { + "$ref": "#/groups/39" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Donne-Gouss\u00e9, Carole; Laudet, Vincent; H\u00e4nni, Catherine (July 2002). \"A molecular phylogeny of Anseriformes based on mitochondrial DNA analysis\". Molecular Phylogenetics and Evolution . 23 (3): 339\u2013356. Bibcode : 2002MolPE..23..339D . doi : 10.1016/S1055-7903(02)00019-2 . PMID 12099792 .", + "text": "Donne-Gouss\u00e9, Carole; Laudet, Vincent; H\u00e4nni, Catherine (July 2002). \"A molecular phylogeny of Anseriformes based on mitochondrial DNA analysis\". Molecular Phylogenetics and Evolution . 23 (3): 339\u2013356. Bibcode : 2002MolPE..23..339D . doi : 10.1016/S1055-7903(02)00019-2 . PMID 12099792 .", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/362", + "parent": { + "$ref": "#/groups/39" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Elphick, Chris; Dunning, John B. Jr.; Sibley, David, eds. (2001). The Sibley Guide to Bird Life and Behaviour . London: Christopher Helm. ISBN 978-0-7136-6250-4 .", + "text": "Elphick, Chris; Dunning, John B. Jr.; Sibley, David, eds. (2001). The Sibley Guide to Bird Life and Behaviour . London: Christopher Helm. ISBN 978-0-7136-6250-4 .", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/363", + "parent": { + "$ref": "#/groups/39" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Erlandson, Jon M. (1994). Early Hunter-Gatherers of the California Coast . New York, NY: Springer Science & Business Media. ISBN 978-1-4419-3231-0 .", + "text": "Erlandson, Jon M. (1994). Early Hunter-Gatherers of the California Coast . New York, NY: Springer Science & Business Media. ISBN 978-1-4419-3231-0 .", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/364", + "parent": { + "$ref": "#/groups/39" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Fieldhouse, Paul (2002). Food, Feasts, and Faith: An Encyclopedia of Food Culture in World Religions . Vol.\u00a0I: A\u2013K. Santa Barbara: ABC-CLIO. ISBN 978-1-61069-412-4 .", + "text": "Fieldhouse, Paul (2002). Food, Feasts, and Faith: An Encyclopedia of Food Culture in World Religions . Vol.\u00a0I: A\u2013K. Santa Barbara: ABC-CLIO. ISBN 978-1-61069-412-4 .", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/365", + "parent": { + "$ref": "#/groups/39" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Fitter, Julian; Fitter, Daniel; Hosking, David (2000). Wildlife of the Gal\u00e1pagos . Princeton, NJ: Princeton University Press. ISBN 978-0-691-10295-5 .", + "text": "Fitter, Julian; Fitter, Daniel; Hosking, David (2000). Wildlife of the Gal\u00e1pagos . Princeton, NJ: Princeton University Press. ISBN 978-0-691-10295-5 .", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/366", + "parent": { + "$ref": "#/groups/39" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Higman, B. W. (2012). How Food Made History . Chichester, UK: John Wiley & Sons. ISBN 978-1-4051-8947-7 .", + "text": "Higman, B. W. (2012). How Food Made History . Chichester, UK: John Wiley & Sons. ISBN 978-1-4051-8947-7 .", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/367", + "parent": { + "$ref": "#/groups/39" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Hume, Julian H. (2012). Extinct Birds . London: Christopher Helm. ISBN 978-1-4729-3744-5 .", + "text": "Hume, Julian H. (2012). Extinct Birds . London: Christopher Helm. ISBN 978-1-4729-3744-5 .", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/368", + "parent": { + "$ref": "#/groups/39" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Jeffries, Richard (2008). Holocene Hunter-Gatherers of the Lower Ohio River Valley . Tuscaloosa: University of Alabama Press. ISBN 978-0-8173-1658-7 .", + "text": "Jeffries, Richard (2008). Holocene Hunter-Gatherers of the Lower Ohio River Valley . Tuscaloosa: University of Alabama Press. ISBN 978-0-8173-1658-7 .", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/369", + "parent": { + "$ref": "#/groups/39" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Kear, Janet, ed. (2005). Ducks, Geese and Swans: Species Accounts ( Cairina to Mergus ) . Bird Families of the World. Oxford: Oxford University Press. ISBN 978-0-19-861009-0 .", + "text": "Kear, Janet, ed. (2005). Ducks, Geese and Swans: Species Accounts ( Cairina to Mergus ) . Bird Families of the World. Oxford: Oxford University Press. ISBN 978-0-19-861009-0 .", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/370", + "parent": { + "$ref": "#/groups/39" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Livezey, Bradley C. (October 1986). \"A phylogenetic analysis of recent Anseriform genera using morphological characters\" (PDF) . The Auk . 103 (4): 737\u2013754. doi : 10.1093/auk/103.4.737 . Archived (PDF) from the original on 2022-10-09.", + "text": "Livezey, Bradley C. (October 1986). \"A phylogenetic analysis of recent Anseriform genera using morphological characters\" (PDF) . The Auk . 103 (4): 737\u2013754. doi : 10.1093/auk/103.4.737 . Archived (PDF) from the original on 2022-10-09.", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/371", + "parent": { + "$ref": "#/groups/39" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Madsen, Cort S.; McHugh, Kevin P.; de Kloet, Siwo R. (July 1988). \"A partial classification of waterfowl (Anatidae) based on single-copy DNA\" (PDF) . The Auk . 105 (3): 452\u2013459. doi : 10.1093/auk/105.3.452 . Archived (PDF) from the original on 2022-10-09.", + "text": "Madsen, Cort S.; McHugh, Kevin P.; de Kloet, Siwo R. (July 1988). \"A partial classification of waterfowl (Anatidae) based on single-copy DNA\" (PDF) . The Auk . 105 (3): 452\u2013459. doi : 10.1093/auk/105.3.452 . Archived (PDF) from the original on 2022-10-09.", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/372", + "parent": { + "$ref": "#/groups/39" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Maisels, Charles Keith (1999). Early Civilizations of the Old World . London: Routledge. ISBN 978-0-415-10975-8 .", + "text": "Maisels, Charles Keith (1999). Early Civilizations of the Old World . London: Routledge. ISBN 978-0-415-10975-8 .", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/373", + "parent": { + "$ref": "#/groups/39" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Pratt, H. Douglas; Bruner, Phillip L.; Berrett, Delwyn G. (1987). A Field Guide to the Birds of Hawaii and the Tropical Pacific . Princeton, NJ: Princeton University Press. ISBN 0-691-02399-9 .", + "text": "Pratt, H. Douglas; Bruner, Phillip L.; Berrett, Delwyn G. (1987). A Field Guide to the Birds of Hawaii and the Tropical Pacific . Princeton, NJ: Princeton University Press. ISBN 0-691-02399-9 .", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/374", + "parent": { + "$ref": "#/groups/39" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Rau, Charles (1876). Early Man in Europe . New York: Harper & Brothers. LCCN 05040168 .", + "text": "Rau, Charles (1876). Early Man in Europe . New York: Harper & Brothers. LCCN 05040168 .", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/375", + "parent": { + "$ref": "#/groups/39" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Shirihai, Hadoram (2008). A Complete Guide to Antarctic Wildlife . Princeton, NJ, US: Princeton University Press. ISBN 978-0-691-13666-0 .", + "text": "Shirihai, Hadoram (2008). A Complete Guide to Antarctic Wildlife . Princeton, NJ, US: Princeton University Press. ISBN 978-0-691-13666-0 .", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/376", + "parent": { + "$ref": "#/groups/39" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Sued-Badillo, Jalil (2003). Autochthonous Societies . General History of the Caribbean. Paris: UNESCO. ISBN 978-92-3-103832-7 .", + "text": "Sued-Badillo, Jalil (2003). Autochthonous Societies . General History of the Caribbean. Paris: UNESCO. ISBN 978-92-3-103832-7 .", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/377", + "parent": { + "$ref": "#/groups/39" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "Thorpe, I. J. (1996). The Origins of Agriculture in Europe . New York: Routledge. ISBN 978-0-415-08009-5 .", + "text": "Thorpe, I. J. (1996). The Origins of Agriculture in Europe . New York: Routledge. ISBN 978-0-415-08009-5 .", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/378", + "parent": { + "$ref": "#/body" + }, + "children": [], "content_layer": "body", "label": "section_header", "prov": [], "orig": "External links", "text": "External links", - "level": 1 + "level": 2 }, { - "self_ref": "#/texts/356", + "self_ref": "#/texts/379", "parent": { - "$ref": "#/groups/41" + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Duck at Wikipedia's sister projects", + "text": "Duck at Wikipedia's sister projects" + }, + { + "self_ref": "#/texts/380", + "parent": { + "$ref": "#/groups/40" }, "children": [], "content_layer": "body", @@ -6877,9 +7232,9 @@ "marker": "-" }, { - "self_ref": "#/texts/357", + "self_ref": "#/texts/381", "parent": { - "$ref": "#/groups/41" + "$ref": "#/groups/40" }, "children": [], "content_layer": "body", @@ -6891,9 +7246,9 @@ "marker": "-" }, { - "self_ref": "#/texts/358", + "self_ref": "#/texts/382", "parent": { - "$ref": "#/groups/41" + "$ref": "#/groups/40" }, "children": [], "content_layer": "body", @@ -6905,9 +7260,9 @@ "marker": "-" }, { - "self_ref": "#/texts/359", + "self_ref": "#/texts/383", "parent": { - "$ref": "#/groups/41" + "$ref": "#/groups/40" }, "children": [], "content_layer": "body", @@ -6919,9 +7274,9 @@ "marker": "-" }, { - "self_ref": "#/texts/360", + "self_ref": "#/texts/384", "parent": { - "$ref": "#/groups/41" + "$ref": "#/groups/40" }, "children": [], "content_layer": "body", @@ -6933,9 +7288,9 @@ "marker": "-" }, { - "self_ref": "#/texts/361", + "self_ref": "#/texts/385", "parent": { - "$ref": "#/groups/41" + "$ref": "#/groups/40" }, "children": [], "content_layer": "body", @@ -6947,9 +7302,9 @@ "marker": "-" }, { - "self_ref": "#/texts/362", + "self_ref": "#/texts/386", "parent": { - "$ref": "#/groups/42" + "$ref": "#/groups/41" }, "children": [], "content_layer": "body", @@ -6961,9 +7316,9 @@ "marker": "-" }, { - "self_ref": "#/texts/363", + "self_ref": "#/texts/387", "parent": { - "$ref": "#/groups/42" + "$ref": "#/groups/41" }, "children": [], "content_layer": "body", @@ -6975,9 +7330,23 @@ "marker": "-" }, { - "self_ref": "#/texts/364", + "self_ref": "#/texts/388", "parent": { - "$ref": "#/groups/42" + "$ref": "#/groups/41" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "", + "text": "", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/389", + "parent": { + "$ref": "#/groups/41" }, "children": [], "content_layer": "body", @@ -6989,33 +7358,405 @@ "marker": "-" }, { - "self_ref": "#/texts/365", + "self_ref": "#/texts/390", "parent": { - "$ref": "#/texts/355" + "$ref": "#/body" }, "children": [], "content_layer": "body", "label": "text", "prov": [], - "orig": "Retrieved from \"\"", - "text": "Retrieved from \"\"" + "orig": "NewPP limit report", + "text": "NewPP limit report" }, { - "self_ref": "#/texts/366", + "self_ref": "#/texts/391", "parent": { - "$ref": "#/texts/355" + "$ref": "#/body" }, "children": [], "content_layer": "body", "label": "text", "prov": [], - "orig": ":", - "text": ":" + "orig": "Parsed by mw\u2010web.codfw.main\u20105d5b97b956\u2010mw5gf", + "text": "Parsed by mw\u2010web.codfw.main\u20105d5b97b956\u2010mw5gf" }, { - "self_ref": "#/texts/367", + "self_ref": "#/texts/392", "parent": { - "$ref": "#/groups/43" + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Cached time: 20241001035144", + "text": "Cached time: 20241001035144" + }, + { + "self_ref": "#/texts/393", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Cache expiry: 2592000", + "text": "Cache expiry: 2592000" + }, + { + "self_ref": "#/texts/394", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Reduced expiry: false", + "text": "Reduced expiry: false" + }, + { + "self_ref": "#/texts/395", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Complications: [vary\u2010revision\u2010sha1, show\u2010toc]", + "text": "Complications: [vary\u2010revision\u2010sha1, show\u2010toc]" + }, + { + "self_ref": "#/texts/396", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "CPU time usage: 1.191 seconds", + "text": "CPU time usage: 1.191 seconds" + }, + { + "self_ref": "#/texts/397", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Real time usage: 1.452 seconds", + "text": "Real time usage: 1.452 seconds" + }, + { + "self_ref": "#/texts/398", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Preprocessor visited node count: 12444/1000000", + "text": "Preprocessor visited node count: 12444/1000000" + }, + { + "self_ref": "#/texts/399", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Post\u2010expand include size: 122530/2097152 bytes", + "text": "Post\u2010expand include size: 122530/2097152 bytes" + }, + { + "self_ref": "#/texts/400", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Template argument size: 9168/2097152 bytes", + "text": "Template argument size: 9168/2097152 bytes" + }, + { + "self_ref": "#/texts/401", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Highest expansion depth: 14/100", + "text": "Highest expansion depth: 14/100" + }, + { + "self_ref": "#/texts/402", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Expensive parser function count: 14/500", + "text": "Expensive parser function count: 14/500" + }, + { + "self_ref": "#/texts/403", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Unstrip recursion depth: 1/20", + "text": "Unstrip recursion depth: 1/20" + }, + { + "self_ref": "#/texts/404", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Unstrip post\u2010expand size: 165576/5000000 bytes", + "text": "Unstrip post\u2010expand size: 165576/5000000 bytes" + }, + { + "self_ref": "#/texts/405", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Lua time usage: 0.865/10.000 seconds", + "text": "Lua time usage: 0.865/10.000 seconds" + }, + { + "self_ref": "#/texts/406", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Lua memory usage: 25093454/52428800 bytes", + "text": "Lua memory usage: 25093454/52428800 bytes" + }, + { + "self_ref": "#/texts/407", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Number of Wikibase entities loaded: 1/400", + "text": "Number of Wikibase entities loaded: 1/400" + }, + { + "self_ref": "#/texts/408", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Transclusion expansion time report (%,ms,calls,template)", + "text": "Transclusion expansion time report (%,ms,calls,template)" + }, + { + "self_ref": "#/texts/409", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "100.00% 1311.889 1 -total", + "text": "100.00% 1311.889 1 -total" + }, + { + "self_ref": "#/texts/410", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "22.17% 290.786 1 Template:Automatic_taxobox", + "text": "22.17% 290.786 1 Template:Automatic_taxobox" + }, + { + "self_ref": "#/texts/411", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "16.91% 221.802 1 Template:Reflist", + "text": "16.91% 221.802 1 Template:Reflist" + }, + { + "self_ref": "#/texts/412", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "10.86% 142.472 44 Template:Sfn", + "text": "10.86% 142.472 44 Template:Sfn" + }, + { + "self_ref": "#/texts/413", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "9.48% 124.344 15 Template:Lang", + "text": "9.48% 124.344 15 Template:Lang" + }, + { + "self_ref": "#/texts/414", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "9.25% 121.312 15 Template:Cite_web", + "text": "9.25% 121.312 15 Template:Cite_web" + }, + { + "self_ref": "#/texts/415", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "8.03% 105.346 26 Template:Cite_book", + "text": "8.03% 105.346 26 Template:Cite_book" + }, + { + "self_ref": "#/texts/416", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "5.85% 76.725 1 Template:Short_description", + "text": "5.85% 76.725 1 Template:Short_description" + }, + { + "self_ref": "#/texts/417", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "5.74% 75.262 1 Template:Authority_control", + "text": "5.74% 75.262 1 Template:Authority_control" + }, + { + "self_ref": "#/texts/418", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "4.50% 58.973 1 Template:Sisterlinks", + "text": "4.50% 58.973 1 Template:Sisterlinks" + }, + { + "self_ref": "#/texts/419", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Saved in parser cache with key enwiki:pcache:idhash:37674-0!canonical and timestamp 20241001035144 and revision id 1246843351. Rendering was triggered because: page-view", + "text": "Saved in parser cache with key enwiki:pcache:idhash:37674-0!canonical and timestamp 20241001035144 and revision id 1246843351. Rendering was triggered because: page-view" + }, + { + "self_ref": "#/texts/420", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "esi ", + "text": "esi " + }, + { + "self_ref": "#/texts/421", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Retrieved from \"https://en.wikipedia.org/w/index.php?title=Duck&oldid=1246843351\"", + "text": "Retrieved from \"https://en.wikipedia.org/w/index.php?title=Duck&oldid=1246843351\"" + }, + { + "self_ref": "#/texts/422", + "parent": { + "$ref": "#/body" + }, + "children": [], + "content_layer": "body", + "label": "text", + "prov": [], + "orig": "Categories:", + "text": "Categories:" + }, + { + "self_ref": "#/texts/423", + "parent": { + "$ref": "#/groups/42" }, "children": [], "content_layer": "body", @@ -7027,9 +7768,9 @@ "marker": "-" }, { - "self_ref": "#/texts/368", + "self_ref": "#/texts/424", "parent": { - "$ref": "#/groups/43" + "$ref": "#/groups/42" }, "children": [], "content_layer": "body", @@ -7041,9 +7782,9 @@ "marker": "-" }, { - "self_ref": "#/texts/369", + "self_ref": "#/texts/425", "parent": { - "$ref": "#/groups/43" + "$ref": "#/groups/42" }, "children": [], "content_layer": "body", @@ -7055,9 +7796,9 @@ "marker": "-" }, { - "self_ref": "#/texts/370", + "self_ref": "#/texts/426", "parent": { - "$ref": "#/texts/355" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -7067,9 +7808,9 @@ "text": "Hidden categories:" }, { - "self_ref": "#/texts/371", + "self_ref": "#/texts/427", "parent": { - "$ref": "#/groups/44" + "$ref": "#/groups/43" }, "children": [], "content_layer": "body", @@ -7081,9 +7822,9 @@ "marker": "-" }, { - "self_ref": "#/texts/372", + "self_ref": "#/texts/428", "parent": { - "$ref": "#/groups/44" + "$ref": "#/groups/43" }, "children": [], "content_layer": "body", @@ -7095,9 +7836,9 @@ "marker": "-" }, { - "self_ref": "#/texts/373", + "self_ref": "#/texts/429", "parent": { - "$ref": "#/groups/44" + "$ref": "#/groups/43" }, "children": [], "content_layer": "body", @@ -7109,9 +7850,9 @@ "marker": "-" }, { - "self_ref": "#/texts/374", + "self_ref": "#/texts/430", "parent": { - "$ref": "#/groups/44" + "$ref": "#/groups/43" }, "children": [], "content_layer": "body", @@ -7123,9 +7864,9 @@ "marker": "-" }, { - "self_ref": "#/texts/375", + "self_ref": "#/texts/431", "parent": { - "$ref": "#/groups/44" + "$ref": "#/groups/43" }, "children": [], "content_layer": "body", @@ -7137,9 +7878,9 @@ "marker": "-" }, { - "self_ref": "#/texts/376", + "self_ref": "#/texts/432", "parent": { - "$ref": "#/groups/44" + "$ref": "#/groups/43" }, "children": [], "content_layer": "body", @@ -7151,9 +7892,9 @@ "marker": "-" }, { - "self_ref": "#/texts/377", + "self_ref": "#/texts/433", "parent": { - "$ref": "#/groups/44" + "$ref": "#/groups/43" }, "children": [], "content_layer": "body", @@ -7165,9 +7906,9 @@ "marker": "-" }, { - "self_ref": "#/texts/378", + "self_ref": "#/texts/434", "parent": { - "$ref": "#/groups/44" + "$ref": "#/groups/43" }, "children": [], "content_layer": "body", @@ -7179,9 +7920,9 @@ "marker": "-" }, { - "self_ref": "#/texts/379", + "self_ref": "#/texts/435", "parent": { - "$ref": "#/groups/44" + "$ref": "#/groups/43" }, "children": [], "content_layer": "body", @@ -7193,9 +7934,9 @@ "marker": "-" }, { - "self_ref": "#/texts/380", + "self_ref": "#/texts/436", "parent": { - "$ref": "#/groups/44" + "$ref": "#/groups/43" }, "children": [], "content_layer": "body", @@ -7207,9 +7948,9 @@ "marker": "-" }, { - "self_ref": "#/texts/381", + "self_ref": "#/texts/437", "parent": { - "$ref": "#/groups/44" + "$ref": "#/groups/43" }, "children": [], "content_layer": "body", @@ -7221,9 +7962,9 @@ "marker": "-" }, { - "self_ref": "#/texts/382", + "self_ref": "#/texts/438", "parent": { - "$ref": "#/groups/44" + "$ref": "#/groups/43" }, "children": [], "content_layer": "body", @@ -7235,9 +7976,9 @@ "marker": "-" }, { - "self_ref": "#/texts/383", + "self_ref": "#/texts/439", "parent": { - "$ref": "#/groups/44" + "$ref": "#/groups/43" }, "children": [], "content_layer": "body", @@ -7249,9 +7990,9 @@ "marker": "-" }, { - "self_ref": "#/texts/384", + "self_ref": "#/texts/440", "parent": { - "$ref": "#/groups/44" + "$ref": "#/groups/43" }, "children": [], "content_layer": "body", @@ -7263,9 +8004,9 @@ "marker": "-" }, { - "self_ref": "#/texts/385", + "self_ref": "#/texts/441", "parent": { - "$ref": "#/groups/44" + "$ref": "#/groups/43" }, "children": [], "content_layer": "body", @@ -7277,9 +8018,9 @@ "marker": "-" }, { - "self_ref": "#/texts/386", + "self_ref": "#/texts/442", "parent": { - "$ref": "#/groups/44" + "$ref": "#/groups/43" }, "children": [], "content_layer": "body", @@ -7291,9 +8032,9 @@ "marker": "-" }, { - "self_ref": "#/texts/387", + "self_ref": "#/texts/443", "parent": { - "$ref": "#/groups/44" + "$ref": "#/groups/43" }, "children": [], "content_layer": "body", @@ -7305,9 +8046,9 @@ "marker": "-" }, { - "self_ref": "#/texts/388", + "self_ref": "#/texts/444", "parent": { - "$ref": "#/groups/44" + "$ref": "#/groups/43" }, "children": [], "content_layer": "body", @@ -7319,9 +8060,9 @@ "marker": "-" }, { - "self_ref": "#/texts/389", + "self_ref": "#/texts/445", "parent": { - "$ref": "#/groups/44" + "$ref": "#/groups/43" }, "children": [], "content_layer": "body", @@ -7333,9 +8074,9 @@ "marker": "-" }, { - "self_ref": "#/texts/390", + "self_ref": "#/texts/446", "parent": { - "$ref": "#/groups/44" + "$ref": "#/groups/43" }, "children": [], "content_layer": "body", @@ -7347,9 +8088,9 @@ "marker": "-" }, { - "self_ref": "#/texts/391", + "self_ref": "#/texts/447", "parent": { - "$ref": "#/groups/44" + "$ref": "#/groups/43" }, "children": [], "content_layer": "body", @@ -7361,9 +8102,9 @@ "marker": "-" }, { - "self_ref": "#/texts/392", + "self_ref": "#/texts/448", "parent": { - "$ref": "#/groups/44" + "$ref": "#/groups/43" }, "children": [], "content_layer": "body", @@ -7375,9 +8116,9 @@ "marker": "-" }, { - "self_ref": "#/texts/393", + "self_ref": "#/texts/449", "parent": { - "$ref": "#/groups/44" + "$ref": "#/groups/43" }, "children": [], "content_layer": "body", @@ -7389,9 +8130,9 @@ "marker": "-" }, { - "self_ref": "#/texts/394", + "self_ref": "#/texts/450", "parent": { - "$ref": "#/groups/44" + "$ref": "#/groups/43" }, "children": [], "content_layer": "body", @@ -7403,9 +8144,9 @@ "marker": "-" }, { - "self_ref": "#/texts/395", + "self_ref": "#/texts/451", "parent": { - "$ref": "#/groups/44" + "$ref": "#/groups/43" }, "children": [], "content_layer": "body", @@ -7417,9 +8158,9 @@ "marker": "-" }, { - "self_ref": "#/texts/396", + "self_ref": "#/texts/452", "parent": { - "$ref": "#/groups/44" + "$ref": "#/groups/43" }, "children": [], "content_layer": "body", @@ -7431,37 +8172,37 @@ "marker": "-" }, { - "self_ref": "#/texts/397", + "self_ref": "#/texts/453", "parent": { - "$ref": "#/groups/45" + "$ref": "#/groups/44" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "This page was last edited on 21 September 2024, at 12:11\u00a0(UTC).", - "text": "This page was last edited on 21 September 2024, at 12:11\u00a0(UTC).", + "orig": "This page was last edited on 21 September 2024, at 12:11 (UTC) .", + "text": "This page was last edited on 21 September 2024, at 12:11 (UTC) .", "enumerated": false, "marker": "-" }, { - "self_ref": "#/texts/398", + "self_ref": "#/texts/454", "parent": { - "$ref": "#/groups/45" + "$ref": "#/groups/44" }, "children": [], "content_layer": "body", "label": "list_item", "prov": [], - "orig": "Text is available under the Creative Commons Attribution-ShareAlike License 4.0;\nadditional terms may apply. By using this site, you agree to the Terms of Use and Privacy Policy. Wikipedia\u00ae is a registered trademark of the Wikimedia Foundation, Inc., a non-profit organization.", - "text": "Text is available under the Creative Commons Attribution-ShareAlike License 4.0;\nadditional terms may apply. By using this site, you agree to the Terms of Use and Privacy Policy. Wikipedia\u00ae is a registered trademark of the Wikimedia Foundation, Inc., a non-profit organization.", + "orig": "Text is available under the Creative Commons Attribution-ShareAlike License 4.0 ;\nadditional terms may apply. By using this site, you agree to the Terms of Use and Privacy Policy . Wikipedia\u00ae is a registered trademark of the Wikimedia Foundation, Inc. , a non-profit organization.", + "text": "Text is available under the Creative Commons Attribution-ShareAlike License 4.0 ;\nadditional terms may apply. By using this site, you agree to the Terms of Use and Privacy Policy . Wikipedia\u00ae is a registered trademark of the Wikimedia Foundation, Inc. , a non-profit organization.", "enumerated": false, "marker": "-" }, { - "self_ref": "#/texts/399", + "self_ref": "#/texts/455", "parent": { - "$ref": "#/groups/46" + "$ref": "#/groups/45" }, "children": [], "content_layer": "body", @@ -7473,9 +8214,9 @@ "marker": "-" }, { - "self_ref": "#/texts/400", + "self_ref": "#/texts/456", "parent": { - "$ref": "#/groups/46" + "$ref": "#/groups/45" }, "children": [], "content_layer": "body", @@ -7487,9 +8228,9 @@ "marker": "-" }, { - "self_ref": "#/texts/401", + "self_ref": "#/texts/457", "parent": { - "$ref": "#/groups/46" + "$ref": "#/groups/45" }, "children": [], "content_layer": "body", @@ -7501,9 +8242,9 @@ "marker": "-" }, { - "self_ref": "#/texts/402", + "self_ref": "#/texts/458", "parent": { - "$ref": "#/groups/46" + "$ref": "#/groups/45" }, "children": [], "content_layer": "body", @@ -7515,9 +8256,9 @@ "marker": "-" }, { - "self_ref": "#/texts/403", + "self_ref": "#/texts/459", "parent": { - "$ref": "#/groups/46" + "$ref": "#/groups/45" }, "children": [], "content_layer": "body", @@ -7529,9 +8270,9 @@ "marker": "-" }, { - "self_ref": "#/texts/404", + "self_ref": "#/texts/460", "parent": { - "$ref": "#/groups/46" + "$ref": "#/groups/45" }, "children": [], "content_layer": "body", @@ -7543,9 +8284,9 @@ "marker": "-" }, { - "self_ref": "#/texts/405", + "self_ref": "#/texts/461", "parent": { - "$ref": "#/groups/46" + "$ref": "#/groups/45" }, "children": [], "content_layer": "body", @@ -7557,9 +8298,9 @@ "marker": "-" }, { - "self_ref": "#/texts/406", + "self_ref": "#/texts/462", "parent": { - "$ref": "#/groups/46" + "$ref": "#/groups/45" }, "children": [], "content_layer": "body", @@ -7571,9 +8312,9 @@ "marker": "-" }, { - "self_ref": "#/texts/407", + "self_ref": "#/texts/463", "parent": { - "$ref": "#/groups/46" + "$ref": "#/groups/45" }, "children": [], "content_layer": "body", @@ -7583,319 +8324,42 @@ "text": "Mobile view", "enumerated": false, "marker": "-" + }, + { + "self_ref": "#/texts/464", + "parent": { + "$ref": "#/groups/46" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "", + "text": "", + "enumerated": false, + "marker": "-" + }, + { + "self_ref": "#/texts/465", + "parent": { + "$ref": "#/groups/46" + }, + "children": [], + "content_layer": "body", + "label": "list_item", + "prov": [], + "orig": "", + "text": "", + "enumerated": false, + "marker": "-" } ], - "pictures": [ - { - "self_ref": "#/pictures/0", - "parent": { - "$ref": "#/body" - }, - "children": [], - "content_layer": "furniture", - "label": "picture", - "prov": [], - "captions": [], - "references": [], - "footnotes": [], - "annotations": [] - }, - { - "self_ref": "#/pictures/1", - "parent": { - "$ref": "#/body" - }, - "children": [], - "content_layer": "furniture", - "label": "picture", - "prov": [], - "captions": [], - "references": [], - "footnotes": [], - "annotations": [] - }, - { - "self_ref": "#/pictures/2", - "parent": { - "$ref": "#/body" - }, - "children": [], - "content_layer": "furniture", - "label": "picture", - "prov": [], - "captions": [], - "references": [], - "footnotes": [], - "annotations": [] - }, - { - "self_ref": "#/pictures/3", - "parent": { - "$ref": "#/texts/43" - }, - "children": [], - "content_layer": "body", - "label": "picture", - "prov": [], - "captions": [], - "references": [], - "footnotes": [], - "annotations": [] - }, - { - "self_ref": "#/pictures/4", - "parent": { - "$ref": "#/texts/214" - }, - "children": [], - "content_layer": "body", - "label": "picture", - "prov": [], - "captions": [ - { - "$ref": "#/texts/216" - } - ], - "references": [], - "footnotes": [], - "annotations": [] - }, - { - "self_ref": "#/pictures/5", - "parent": { - "$ref": "#/texts/214" - }, - "children": [], - "content_layer": "body", - "label": "picture", - "prov": [], - "captions": [ - { - "$ref": "#/texts/220" - } - ], - "references": [], - "footnotes": [], - "annotations": [] - }, - { - "self_ref": "#/pictures/6", - "parent": { - "$ref": "#/texts/214" - }, - "children": [], - "content_layer": "body", - "label": "picture", - "prov": [], - "captions": [ - { - "$ref": "#/texts/221" - } - ], - "references": [], - "footnotes": [], - "annotations": [] - }, - { - "self_ref": "#/pictures/7", - "parent": { - "$ref": "#/texts/222" - }, - "children": [], - "content_layer": "body", - "label": "picture", - "prov": [], - "captions": [ - { - "$ref": "#/texts/224" - } - ], - "references": [], - "footnotes": [], - "annotations": [] - }, - { - "self_ref": "#/pictures/8", - "parent": { - "$ref": "#/texts/227" - }, - "children": [], - "content_layer": "body", - "label": "picture", - "prov": [], - "captions": [ - { - "$ref": "#/texts/228" - } - ], - "references": [], - "footnotes": [], - "annotations": [] - }, - { - "self_ref": "#/pictures/9", - "parent": { - "$ref": "#/texts/231" - }, - "children": [], - "content_layer": "body", - "label": "picture", - "prov": [], - "captions": [ - { - "$ref": "#/texts/232" - } - ], - "references": [], - "footnotes": [], - "annotations": [] - }, - { - "self_ref": "#/pictures/10", - "parent": { - "$ref": "#/texts/231" - }, - "children": [], - "content_layer": "body", - "label": "picture", - "prov": [], - "captions": [ - { - "$ref": "#/texts/234" - } - ], - "references": [], - "footnotes": [], - "annotations": [] - }, - { - "self_ref": "#/pictures/11", - "parent": { - "$ref": "#/texts/237" - }, - "children": [], - "content_layer": "body", - "label": "picture", - "prov": [], - "captions": [ - { - "$ref": "#/texts/238" - } - ], - "references": [], - "footnotes": [], - "annotations": [] - }, - { - "self_ref": "#/pictures/12", - "parent": { - "$ref": "#/texts/237" - }, - "children": [], - "content_layer": "body", - "label": "picture", - "prov": [], - "captions": [ - { - "$ref": "#/texts/239" - } - ], - "references": [], - "footnotes": [], - "annotations": [] - }, - { - "self_ref": "#/pictures/13", - "parent": { - "$ref": "#/texts/246" - }, - "children": [], - "content_layer": "body", - "label": "picture", - "prov": [], - "captions": [ - { - "$ref": "#/texts/247" - } - ], - "references": [], - "footnotes": [], - "annotations": [] - }, - { - "self_ref": "#/pictures/14", - "parent": { - "$ref": "#/texts/252" - }, - "children": [], - "content_layer": "body", - "label": "picture", - "prov": [], - "captions": [ - { - "$ref": "#/texts/253" - } - ], - "references": [], - "footnotes": [], - "annotations": [] - }, - { - "self_ref": "#/pictures/15", - "parent": { - "$ref": "#/texts/260" - }, - "children": [], - "content_layer": "body", - "label": "picture", - "prov": [], - "captions": [ - { - "$ref": "#/texts/261" - } - ], - "references": [], - "footnotes": [], - "annotations": [] - }, - { - "self_ref": "#/pictures/16", - "parent": { - "$ref": "#/texts/263" - }, - "children": [], - "content_layer": "body", - "label": "picture", - "prov": [], - "captions": [ - { - "$ref": "#/texts/264" - } - ], - "references": [], - "footnotes": [], - "annotations": [] - }, - { - "self_ref": "#/pictures/17", - "parent": { - "$ref": "#/texts/355" - }, - "children": [], - "content_layer": "body", - "label": "picture", - "prov": [], - "captions": [], - "references": [], - "footnotes": [], - "annotations": [] - } - ], + "pictures": [], "tables": [ { "self_ref": "#/tables/0", "parent": { - "$ref": "#/texts/43" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -7913,7 +8377,7 @@ "end_row_offset_idx": 1, "start_col_offset_idx": 0, "end_col_offset_idx": 2, - "text": "Duck\n", + "text": "Duck", "column_header": true, "row_header": false, "row_section": false @@ -7925,7 +8389,7 @@ "end_row_offset_idx": 2, "start_col_offset_idx": 0, "end_col_offset_idx": 2, - "text": "\n", + "text": "", "column_header": false, "row_header": false, "row_section": false @@ -7937,7 +8401,7 @@ "end_row_offset_idx": 3, "start_col_offset_idx": 0, "end_col_offset_idx": 2, - "text": "Bufflehead\n(Bucephala albeola)\n", + "text": "Bufflehead(Bucephala albeola)", "column_header": false, "row_header": false, "row_section": false @@ -7949,7 +8413,7 @@ "end_row_offset_idx": 4, "start_col_offset_idx": 0, "end_col_offset_idx": 2, - "text": "Scientific classification \n", + "text": "Scientific classification", "column_header": true, "row_header": false, "row_section": false @@ -7961,7 +8425,7 @@ "end_row_offset_idx": 5, "start_col_offset_idx": 0, "end_col_offset_idx": 1, - "text": "Domain:\n", + "text": "Domain:", "column_header": false, "row_header": false, "row_section": false @@ -7973,7 +8437,7 @@ "end_row_offset_idx": 5, "start_col_offset_idx": 1, "end_col_offset_idx": 2, - "text": "Eukaryota\n", + "text": "Eukaryota", "column_header": false, "row_header": false, "row_section": false @@ -7985,7 +8449,7 @@ "end_row_offset_idx": 6, "start_col_offset_idx": 0, "end_col_offset_idx": 1, - "text": "Kingdom:\n", + "text": "Kingdom:", "column_header": false, "row_header": false, "row_section": false @@ -7997,7 +8461,7 @@ "end_row_offset_idx": 6, "start_col_offset_idx": 1, "end_col_offset_idx": 2, - "text": "Animalia\n", + "text": "Animalia", "column_header": false, "row_header": false, "row_section": false @@ -8009,7 +8473,7 @@ "end_row_offset_idx": 7, "start_col_offset_idx": 0, "end_col_offset_idx": 1, - "text": "Phylum:\n", + "text": "Phylum:", "column_header": false, "row_header": false, "row_section": false @@ -8021,7 +8485,7 @@ "end_row_offset_idx": 7, "start_col_offset_idx": 1, "end_col_offset_idx": 2, - "text": "Chordata\n", + "text": "Chordata", "column_header": false, "row_header": false, "row_section": false @@ -8033,7 +8497,7 @@ "end_row_offset_idx": 8, "start_col_offset_idx": 0, "end_col_offset_idx": 1, - "text": "Class:\n", + "text": "Class:", "column_header": false, "row_header": false, "row_section": false @@ -8045,7 +8509,7 @@ "end_row_offset_idx": 8, "start_col_offset_idx": 1, "end_col_offset_idx": 2, - "text": "Aves\n", + "text": "Aves", "column_header": false, "row_header": false, "row_section": false @@ -8057,7 +8521,7 @@ "end_row_offset_idx": 9, "start_col_offset_idx": 0, "end_col_offset_idx": 1, - "text": "Order:\n", + "text": "Order:", "column_header": false, "row_header": false, "row_section": false @@ -8069,7 +8533,7 @@ "end_row_offset_idx": 9, "start_col_offset_idx": 1, "end_col_offset_idx": 2, - "text": "Anseriformes\n", + "text": "Anseriformes", "column_header": false, "row_header": false, "row_section": false @@ -8081,7 +8545,7 @@ "end_row_offset_idx": 10, "start_col_offset_idx": 0, "end_col_offset_idx": 1, - "text": "Superfamily:\n", + "text": "Superfamily:", "column_header": false, "row_header": false, "row_section": false @@ -8093,7 +8557,7 @@ "end_row_offset_idx": 10, "start_col_offset_idx": 1, "end_col_offset_idx": 2, - "text": "Anatoidea\n", + "text": "Anatoidea", "column_header": false, "row_header": false, "row_section": false @@ -8105,7 +8569,7 @@ "end_row_offset_idx": 11, "start_col_offset_idx": 0, "end_col_offset_idx": 1, - "text": "Family:\n", + "text": "Family:", "column_header": false, "row_header": false, "row_section": false @@ -8117,7 +8581,7 @@ "end_row_offset_idx": 11, "start_col_offset_idx": 1, "end_col_offset_idx": 2, - "text": "Anatidae\n", + "text": "Anatidae", "column_header": false, "row_header": false, "row_section": false @@ -8129,7 +8593,7 @@ "end_row_offset_idx": 12, "start_col_offset_idx": 0, "end_col_offset_idx": 2, - "text": "Subfamilies\n", + "text": "Subfamilies", "column_header": true, "row_header": false, "row_section": false @@ -8141,7 +8605,7 @@ "end_row_offset_idx": 13, "start_col_offset_idx": 0, "end_col_offset_idx": 2, - "text": "\nSee text\n\n", + "text": "See text", "column_header": false, "row_header": false, "row_section": false @@ -8158,7 +8622,7 @@ "end_row_offset_idx": 1, "start_col_offset_idx": 0, "end_col_offset_idx": 2, - "text": "Duck\n", + "text": "Duck", "column_header": true, "row_header": false, "row_section": false @@ -8170,7 +8634,7 @@ "end_row_offset_idx": 1, "start_col_offset_idx": 0, "end_col_offset_idx": 2, - "text": "Duck\n", + "text": "Duck", "column_header": true, "row_header": false, "row_section": false @@ -8184,7 +8648,7 @@ "end_row_offset_idx": 2, "start_col_offset_idx": 0, "end_col_offset_idx": 2, - "text": "\n", + "text": "", "column_header": false, "row_header": false, "row_section": false @@ -8196,7 +8660,7 @@ "end_row_offset_idx": 2, "start_col_offset_idx": 0, "end_col_offset_idx": 2, - "text": "\n", + "text": "", "column_header": false, "row_header": false, "row_section": false @@ -8210,7 +8674,7 @@ "end_row_offset_idx": 3, "start_col_offset_idx": 0, "end_col_offset_idx": 2, - "text": "Bufflehead\n(Bucephala albeola)\n", + "text": "Bufflehead(Bucephala albeola)", "column_header": false, "row_header": false, "row_section": false @@ -8222,7 +8686,7 @@ "end_row_offset_idx": 3, "start_col_offset_idx": 0, "end_col_offset_idx": 2, - "text": "Bufflehead\n(Bucephala albeola)\n", + "text": "Bufflehead(Bucephala albeola)", "column_header": false, "row_header": false, "row_section": false @@ -8236,7 +8700,7 @@ "end_row_offset_idx": 4, "start_col_offset_idx": 0, "end_col_offset_idx": 2, - "text": "Scientific classification \n", + "text": "Scientific classification", "column_header": true, "row_header": false, "row_section": false @@ -8248,7 +8712,7 @@ "end_row_offset_idx": 4, "start_col_offset_idx": 0, "end_col_offset_idx": 2, - "text": "Scientific classification \n", + "text": "Scientific classification", "column_header": true, "row_header": false, "row_section": false @@ -8262,7 +8726,7 @@ "end_row_offset_idx": 5, "start_col_offset_idx": 0, "end_col_offset_idx": 1, - "text": "Domain:\n", + "text": "Domain:", "column_header": false, "row_header": false, "row_section": false @@ -8274,7 +8738,7 @@ "end_row_offset_idx": 5, "start_col_offset_idx": 1, "end_col_offset_idx": 2, - "text": "Eukaryota\n", + "text": "Eukaryota", "column_header": false, "row_header": false, "row_section": false @@ -8288,7 +8752,7 @@ "end_row_offset_idx": 6, "start_col_offset_idx": 0, "end_col_offset_idx": 1, - "text": "Kingdom:\n", + "text": "Kingdom:", "column_header": false, "row_header": false, "row_section": false @@ -8300,7 +8764,7 @@ "end_row_offset_idx": 6, "start_col_offset_idx": 1, "end_col_offset_idx": 2, - "text": "Animalia\n", + "text": "Animalia", "column_header": false, "row_header": false, "row_section": false @@ -8314,7 +8778,7 @@ "end_row_offset_idx": 7, "start_col_offset_idx": 0, "end_col_offset_idx": 1, - "text": "Phylum:\n", + "text": "Phylum:", "column_header": false, "row_header": false, "row_section": false @@ -8326,7 +8790,7 @@ "end_row_offset_idx": 7, "start_col_offset_idx": 1, "end_col_offset_idx": 2, - "text": "Chordata\n", + "text": "Chordata", "column_header": false, "row_header": false, "row_section": false @@ -8340,7 +8804,7 @@ "end_row_offset_idx": 8, "start_col_offset_idx": 0, "end_col_offset_idx": 1, - "text": "Class:\n", + "text": "Class:", "column_header": false, "row_header": false, "row_section": false @@ -8352,7 +8816,7 @@ "end_row_offset_idx": 8, "start_col_offset_idx": 1, "end_col_offset_idx": 2, - "text": "Aves\n", + "text": "Aves", "column_header": false, "row_header": false, "row_section": false @@ -8366,7 +8830,7 @@ "end_row_offset_idx": 9, "start_col_offset_idx": 0, "end_col_offset_idx": 1, - "text": "Order:\n", + "text": "Order:", "column_header": false, "row_header": false, "row_section": false @@ -8378,7 +8842,7 @@ "end_row_offset_idx": 9, "start_col_offset_idx": 1, "end_col_offset_idx": 2, - "text": "Anseriformes\n", + "text": "Anseriformes", "column_header": false, "row_header": false, "row_section": false @@ -8392,7 +8856,7 @@ "end_row_offset_idx": 10, "start_col_offset_idx": 0, "end_col_offset_idx": 1, - "text": "Superfamily:\n", + "text": "Superfamily:", "column_header": false, "row_header": false, "row_section": false @@ -8404,7 +8868,7 @@ "end_row_offset_idx": 10, "start_col_offset_idx": 1, "end_col_offset_idx": 2, - "text": "Anatoidea\n", + "text": "Anatoidea", "column_header": false, "row_header": false, "row_section": false @@ -8418,7 +8882,7 @@ "end_row_offset_idx": 11, "start_col_offset_idx": 0, "end_col_offset_idx": 1, - "text": "Family:\n", + "text": "Family:", "column_header": false, "row_header": false, "row_section": false @@ -8430,7 +8894,7 @@ "end_row_offset_idx": 11, "start_col_offset_idx": 1, "end_col_offset_idx": 2, - "text": "Anatidae\n", + "text": "Anatidae", "column_header": false, "row_header": false, "row_section": false @@ -8444,7 +8908,7 @@ "end_row_offset_idx": 12, "start_col_offset_idx": 0, "end_col_offset_idx": 2, - "text": "Subfamilies\n", + "text": "Subfamilies", "column_header": true, "row_header": false, "row_section": false @@ -8456,7 +8920,7 @@ "end_row_offset_idx": 12, "start_col_offset_idx": 0, "end_col_offset_idx": 2, - "text": "Subfamilies\n", + "text": "Subfamilies", "column_header": true, "row_header": false, "row_section": false @@ -8470,7 +8934,7 @@ "end_row_offset_idx": 13, "start_col_offset_idx": 0, "end_col_offset_idx": 2, - "text": "\nSee text\n\n", + "text": "See text", "column_header": false, "row_header": false, "row_section": false @@ -8482,7 +8946,7 @@ "end_row_offset_idx": 13, "start_col_offset_idx": 0, "end_col_offset_idx": 2, - "text": "\nSee text\n\n", + "text": "See text", "column_header": false, "row_header": false, "row_section": false @@ -8494,7 +8958,7 @@ { "self_ref": "#/tables/1", "parent": { - "$ref": "#/texts/355" + "$ref": "#/body" }, "children": [], "content_layer": "body", @@ -8512,7 +8976,7 @@ "end_row_offset_idx": 1, "start_col_offset_idx": 0, "end_col_offset_idx": 2, - "text": "Authority control databases ", + "text": "Authority control databases", "column_header": true, "row_header": false, "row_section": false @@ -8525,8 +8989,8 @@ "start_col_offset_idx": 0, "end_col_offset_idx": 1, "text": "National", - "column_header": false, - "row_header": true, + "column_header": true, + "row_header": false, "row_section": false }, { @@ -8549,8 +9013,8 @@ "start_col_offset_idx": 0, "end_col_offset_idx": 1, "text": "Other", - "column_header": false, - "row_header": true, + "column_header": true, + "row_header": false, "row_section": false }, { @@ -8577,7 +9041,7 @@ "end_row_offset_idx": 1, "start_col_offset_idx": 0, "end_col_offset_idx": 2, - "text": "Authority control databases ", + "text": "Authority control databases", "column_header": true, "row_header": false, "row_section": false @@ -8589,7 +9053,7 @@ "end_row_offset_idx": 1, "start_col_offset_idx": 0, "end_col_offset_idx": 2, - "text": "Authority control databases ", + "text": "Authority control databases", "column_header": true, "row_header": false, "row_section": false @@ -8604,8 +9068,8 @@ "start_col_offset_idx": 0, "end_col_offset_idx": 1, "text": "National", - "column_header": false, - "row_header": true, + "column_header": true, + "row_header": false, "row_section": false }, { @@ -8630,8 +9094,8 @@ "start_col_offset_idx": 0, "end_col_offset_idx": 1, "text": "Other", - "column_header": false, - "row_header": true, + "column_header": true, + "row_header": false, "row_section": false }, { diff --git a/tests/data/groundtruth/docling_v2/wiki_duck.html.md b/tests/data/groundtruth/docling_v2/wiki_duck.html.md index 9467bc4e..8f1fb633 100644 --- a/tests/data/groundtruth/docling_v2/wiki_duck.html.md +++ b/tests/data/groundtruth/docling_v2/wiki_duck.html.md @@ -1,28 +1,84 @@ -## Contents +Jump to content + +Main menu + +Main menu + +move to sidebar + +hide + +Navigation + +- Main page +- Contents +- Current events +- Random article +- About Wikipedia +- Contact us + +Contribute + +- Help +- Learn to edit +- Community portal +- Recent changes +- Upload file + +Search + +Search + +- Donate + +Appearance + +- Create account +- Log in + +Personal tools + +- Create account +- Log in + +Pages for logged out editors learn more + +- Contributions +- Talk + +### Contents + +move to sidebar + +hide - (Top) - 1 Etymology - 2 Taxonomy - 3 Morphology - 4 Distribution and habitat -- 5 Behaviour Toggle Behaviour subsection +- 5 Behaviour Toggle Behaviour subsection 5.1 Feeding 5.2 Breeding 5.3 Communication 5.4 Predators - 5.1 Feeding - 5.2 Breeding - 5.3 Communication - 5.4 Predators -- 6 Relationship with humans Toggle Relationship with humans subsection +- 6 Relationship with humans Toggle Relationship with humans subsection 6.1 Hunting 6.2 Domestication 6.3 Heraldry 6.4 Cultural references - 6.1 Hunting - 6.2 Domestication - 6.3 Heraldry - 6.4 Cultural references - 7 See also -- 8 Notes Toggle Notes subsection +- 8 Notes Toggle Notes subsection 8.1 Citations 8.2 Sources - 8.1 Citations - 8.2 Sources - 9 External links +Toggle the table of contents + # Duck +136 languages + - Acèh - Afrikaans - Alemannisch @@ -160,15 +216,25 @@ - Žemaitėška - 中文 +Edit links + - Article - Talk +English + - Read - View source - View history Tools +Tools + +move to sidebar + +hide + Actions - Read @@ -200,43 +266,45 @@ In other projects Appearance - +move to sidebar + +hide From Wikipedia, the free encyclopedia +(Redirected from Duckling) + Common name for many species of bird -This article is about the bird. For duck as a food, see . For other uses, see . +This article is about the bird. For duck as a food, see Duck as food. For other uses, see Duck (disambiguation). -"Duckling" redirects here. For other uses, see . +"Duckling" redirects here. For other uses, see Duckling (disambiguation). -| Duck | Duck | -|--------------------------------|--------------------------------| -| | | -| Bufflehead (Bucephala albeola) | Bufflehead (Bucephala albeola) | -| Scientific classification | Scientific classification | -| Domain: | Eukaryota | -| Kingdom: | Animalia | -| Phylum: | Chordata | -| Class: | Aves | -| Order: | Anseriformes | -| Superfamily: | Anatoidea | -| Family: | Anatidae | -| Subfamilies | Subfamilies | -| See text | See text | +| Duck | Duck | +|-------------------------------|-------------------------------| +| | | +| Bufflehead(Bucephala albeola) | Bufflehead(Bucephala albeola) | +| Scientific classification | Scientific classification | +| Domain: | Eukaryota | +| Kingdom: | Animalia | +| Phylum: | Chordata | +| Class: | Aves | +| Order: | Anseriformes | +| Superfamily: | Anatoidea | +| Family: | Anatidae | +| Subfamilies | Subfamilies | +| See text | See text | Duck is the common name for numerous species of waterfowl in the family Anatidae. Ducks are generally smaller and shorter-necked than swans and geese, which are members of the same family. Divided among several subfamilies, they are a form taxon; they do not represent a monophyletic group (the group of all descendants of a single common ancestral species), since swans and geese are not considered ducks. Ducks are mostly aquatic birds, and may be found in both fresh water and sea water. Ducks are sometimes confused with several types of unrelated water birds with similar forms, such as loons or divers, grebes, gallinules and coots. -## Etymology +### Etymology The word duck comes from Old English dūce 'diver', a derivative of the verb *dūcan 'to duck, bend down low as if to get under something, or dive', because of the way many species in the dabbling duck group feed by upending; compare with Dutch duiken and German tauchen 'to dive'. Pacific black duck displaying the characteristic upending "duck" - - This word replaced Old English ened /ænid 'duck', possibly to avoid confusion with other words, such as ende 'end' with similar forms. Other Germanic languages still have similar words for duck, for example, Dutch eend, German Ente and Norwegian and. The word ened /ænid was inherited from Proto-Indo-European; cf. Latin anas "duck", Lithuanian ántis 'duck', Ancient Greek νῆσσα /νῆττα (nēssa /nētta) 'duck', and Sanskrit ātí 'water bird', among others. A duckling is a young duck in downy plumage[1] or baby duck,[2] but in the food trade a young domestic duck which has just reached adult size and bulk and its meat is still fully tender, is sometimes labelled as a duckling. @@ -245,60 +313,46 @@ A male is called a drake and the female is called a duck, or in ornithology a he Male mallard. - - Wood ducks. - - -## Taxonomy +### Taxonomy All ducks belong to the biological order Anseriformes, a group that contains the ducks, geese and swans, as well as the screamers, and the magpie goose.[5] All except the screamers belong to the biological family Anatidae.[5] Within the family, ducks are split into a variety of subfamilies and 'tribes'. The number and composition of these subfamilies and tribes is the cause of considerable disagreement among taxonomists.[5] Some base their decisions on morphological characteristics, others on shared behaviours or genetic studies.[6][7] The number of suggested subfamilies containing ducks ranges from two to five.[8][9] The significant level of hybridisation that occurs among wild ducks complicates efforts to tease apart the relationships between various species.[9] Mallard landing in approach - - In most modern classifications, the so-called 'true ducks' belong to the subfamily Anatinae, which is further split into a varying number of tribes.[10] The largest of these, the Anatini, contains the 'dabbling' or 'river' ducks – named for their method of feeding primarily at the surface of fresh water.[11] The 'diving ducks', also named for their primary feeding method, make up the tribe Aythyini.[12] The 'sea ducks' of the tribe Mergini are diving ducks which specialise on fish and shellfish and spend a majority of their lives in saltwater.[13] The tribe Oxyurini contains the 'stifftails', diving ducks notable for their small size and stiff, upright tails.[14] A number of other species called ducks are not considered to be 'true ducks', and are typically placed in other subfamilies or tribes. The whistling ducks are assigned either to a tribe (Dendrocygnini) in the subfamily Anatinae or the subfamily Anserinae,[15] or to their own subfamily (Dendrocygninae) or family (Dendrocyganidae).[9][16] The freckled duck of Australia is either the sole member of the tribe Stictonettini in the subfamily Anserinae,[15] or in its own family, the Stictonettinae.[9] The shelducks make up the tribe Tadornini in the family Anserinae in some classifications,[15] and their own subfamily, Tadorninae, in others,[17] while the steamer ducks are either placed in the family Anserinae in the tribe Tachyerini[15] or lumped with the shelducks in the tribe Tadorini.[9] The perching ducks make up in the tribe Cairinini in the subfamily Anserinae in some classifications, while that tribe is eliminated in other classifications and its members assigned to the tribe Anatini.[9] The torrent duck is generally included in the subfamily Anserinae in the monotypic tribe Merganettini,[15] but is sometimes included in the tribe Tadornini.[18] The pink-eared duck is sometimes included as a true duck either in the tribe Anatini[15] or the tribe Malacorhynchini,[19] and other times is included with the shelducks in the tribe Tadornini.[15] -## Morphology +### Morphology Male Mandarin duck - - The overall body plan of ducks is elongated and broad, and they are also relatively long-necked, albeit not as long-necked as the geese and swans. The body shape of diving ducks varies somewhat from this in being more rounded. The bill is usually broad and contains serrated pectens, which are particularly well defined in the filter-feeding species. In the case of some fishing species the bill is long and strongly serrated. The scaled legs are strong and well developed, and generally set far back on the body, more so in the highly aquatic species. The wings are very strong and are generally short and pointed, and the flight of ducks requires fast continuous strokes, requiring in turn strong wing muscles. Three species of steamer duck are almost flightless, however. Many species of duck are temporarily flightless while moulting; they seek out protected habitat with good food supplies during this period. This moult typically precedes migration. The drakes of northern species often have extravagant plumage, but that is moulted in summer to give a more female-like appearance, the "eclipse" plumage. Southern resident species typically show less sexual dimorphism, although there are exceptions such as the paradise shelduck of New Zealand, which is both strikingly sexually dimorphic and in which the female's plumage is brighter than that of the male. The plumage of juvenile birds generally resembles that of the female. Female ducks have evolved to have a corkscrew shaped vagina to prevent rape. -## Distribution and habitat +### Distribution and habitat + +See also: List of Anseriformes by population Flying steamer ducks in Ushuaia, Argentina - - Ducks have a cosmopolitan distribution, and are found on every continent except Antarctica.[5] Several species manage to live on subantarctic islands, including South Georgia and the Auckland Islands.[20] Ducks have reached a number of isolated oceanic islands, including the Hawaiian Islands, Micronesia and the Galápagos Islands, where they are often vagrants and less often residents.[21][22] A handful are endemic to such far-flung islands.[21] Female mallard in Cornwall, England - - Some duck species, mainly those breeding in the temperate and Arctic Northern Hemisphere, are migratory; those in the tropics are generally not. Some ducks, particularly in Australia where rainfall is erratic, are nomadic, seeking out the temporary lakes and pools that form after localised heavy rain.[23] -## Behaviour +### Behaviour -### Feeding +#### Feeding Pecten along the bill - - Mallard duckling preening - - Ducks eat food sources such as grasses, aquatic plants, fish, insects, small amphibians, worms, and small molluscs. Dabbling ducks feed on the surface of water or on land, or as deep as they can reach by up-ending without completely submerging.[24] Along the edge of the bill, there is a comb-like structure called a pecten. This strains the water squirting from the side of the bill and traps any food. The pecten is also used to preen feathers and to hold slippery food items. @@ -311,61 +365,57 @@ The others have the characteristic wide flat bill adapted to dredging-type jobs The Guardian published an article advising that ducks should not be fed with bread because it damages the health of the ducks and pollutes waterways.[25] -### Breeding +#### Breeding A Muscovy duckling - - Ducks generally only have one partner at a time, although the partnership usually only lasts one year.[26] Larger species and the more sedentary species (like fast-river specialists) tend to have pair-bonds that last numerous years.[27] Most duck species breed once a year, choosing to do so in favourable conditions (spring/summer or wet seasons). Ducks also tend to make a nest before breeding, and, after hatching, lead their ducklings to water. Mother ducks are very caring and protective of their young, but may abandon some of their ducklings if they are physically stuck in an area they cannot get out of (such as nesting in an enclosed courtyard) or are not prospering due to genetic defects or sickness brought about by hypothermia, starvation, or disease. Ducklings can also be orphaned by inconsistent late hatching where a few eggs hatch after the mother has abandoned the nest and led her ducklings to water.[28] -### Communication +#### Communication Female mallard ducks (as well as several other species in the genus Anas, such as the American and Pacific black ducks, spot-billed duck, northern pintail and common teal) make the classic "quack" sound while males make a similar but raspier sound that is sometimes written as "breeeeze",[29][self-published source?] but, despite widespread misconceptions, most species of duck do not "quack".[30] In general, ducks make a range of calls, including whistles, cooing, yodels and grunts. For example, the scaup – which are diving ducks – make a noise like "scaup" (hence their name). Calls may be loud displaying calls or quieter contact calls. A common urban legend claims that duck quacks do not echo; however, this has been proven to be false. This myth was first debunked by the Acoustics Research Centre at the University of Salford in 2003 as part of the British Association's Festival of Science.[31] It was also debunked in one of the earlier episodes of the popular Discovery Channel television show MythBusters.[32] -### Predators +#### Predators Ringed teal - - Ducks have many predators. Ducklings are particularly vulnerable, since their inability to fly makes them easy prey not only for predatory birds but also for large fish like pike, crocodilians, predatory testudines such as the alligator snapping turtle, and other aquatic hunters, including fish-eating birds such as herons. Ducks' nests are raided by land-based predators, and brooding females may be caught unaware on the nest by mammals, such as foxes, or large birds, such as hawks or owls. Adult ducks are fast fliers, but may be caught on the water by large aquatic predators including big fish such as the North American muskie and the European pike. In flight, ducks are safe from all but a few predators such as humans and the peregrine falcon, which uses its speed and strength to catch ducks. -## Relationship with humans +### Relationship with humans -### Hunting +#### Hunting + +Main article: Waterfowl hunting Humans have hunted ducks since prehistoric times. Excavations of middens in California dating to 7800 – 6400 BP have turned up bones of ducks, including at least one now-extinct flightless species.[33] Ducks were captured in "significant numbers" by Holocene inhabitants of the lower Ohio River valley, suggesting they took advantage of the seasonal bounty provided by migrating waterfowl.[34] Neolithic hunters in locations as far apart as the Caribbean,[35] Scandinavia,[36] Egypt,[37] Switzerland,[38] and China relied on ducks as a source of protein for some or all of the year.[39] Archeological evidence shows that Māori people in New Zealand hunted the flightless Finsch's duck, possibly to extinction, though rat predation may also have contributed to its fate.[40] A similar end awaited the Chatham duck, a species with reduced flying capabilities which went extinct shortly after its island was colonised by Polynesian settlers.[41] It is probable that duck eggs were gathered by Neolithic hunter-gathers as well, though hard evidence of this is uncommon.[35][42] In many areas, wild ducks (including ducks farmed and released into the wild) are hunted for food or sport,[43] by shooting, or by being trapped using duck decoys. Because an idle floating duck or a duck squatting on land cannot react to fly or move quickly, "a sitting duck" has come to mean "an easy target". These ducks may be contaminated by pollutants such as PCBs.[44] -### Domestication +#### Domestication + +Main article: Domestic duck Indian Runner ducks, a common breed of domestic ducks - - Ducks have many economic uses, being farmed for their meat, eggs, and feathers (particularly their down). Approximately 3 billion ducks are slaughtered each year for meat worldwide.[45] They are also kept and bred by aviculturists and often displayed in zoos. Almost all the varieties of domestic ducks are descended from the mallard (Anas platyrhynchos), apart from the Muscovy duck (Cairina moschata).[46][47] The Call duck is another example of a domestic duck breed. Its name comes from its original use established by hunters, as a decoy to attract wild mallards from the sky, into traps set for them on the ground. The call duck is the world's smallest domestic duck breed, as it weighs less than 1 kg (2.2 lb).[48] -### Heraldry +#### Heraldry Three black-colored ducks in the coat of arms of Maaninka[49] - - Ducks appear on several coats of arms, including the coat of arms of Lubāna (Latvia)[50] and the coat of arms of Föglö (Åland).[51] -### Cultural references +#### Cultural references In 2002, psychologist Richard Wiseman and colleagues at the University of Hertfordshire, UK, finished a year-long LaughLab experiment, concluding that of all animals, ducks attract the most humor and silliness; he said, "If you're going to tell a joke involving an animal, make it a duck."[52] The word "duck" may have become an inherently funny word in many languages, possibly because ducks are seen as silly in their looks or behavior. Of the many ducks in fiction, many are cartoon characters, such as Walt Disney's Donald Duck, and Warner Bros.' Daffy Duck. Howard the Duck started as a comic book character in 1973[53][54] and was made into a movie in 1986. The 1992 Disney film The Mighty Ducks, starring Emilio Estevez, chose the duck as the mascot for the fictional youth hockey team who are protagonists of the movie, based on the duck being described as a fierce fighter. This led to the duck becoming the nickname and mascot for the eventual National Hockey League professional team of the Anaheim Ducks, who were founded with the name the Mighty Ducks of Anaheim.[citation needed] The duck is also the nickname of the University of Oregon sports teams as well as the Long Island Ducks minor league baseball team.[55] -## See also +### See also - Birds portal @@ -376,90 +426,92 @@ The 1992 Disney film The Mighty Ducks, starring Emilio Estevez, chose the duck a - Fictional ducks - Rubber duck -## Notes +### Notes -### Citations +#### Citations -1. ^ "Duckling". The American Heritage Dictionary of the English Language, Fourth Edition. Houghton Mifflin Company. 2006. Retrieved 2015-05-22. -2. ^ "Duckling". Kernerman English Multilingual Dictionary (Beta Version). K. Dictionaries Ltd. 2000–2006. Retrieved 2015-05-22. -3. ^ Dohner, Janet Vorwald (2001). The Encyclopedia of Historic and Endangered Livestock and Poultry Breeds. Yale University Press. ISBN 978-0300138139. -4. ^ Visca, Curt; Visca, Kelley (2003). How to Draw Cartoon Birds. The Rosen Publishing Group. ISBN 9780823961566. -5. ^ a b c d Carboneras 1992, p. 536. -6. ^ Livezey 1986, pp. 737–738. -7. ^ Madsen, McHugh & de Kloet 1988, p. 452. -8. ^ Donne-Goussé, Laudet & Hänni 2002, pp. 353–354. -9. ^ a b c d e f Carboneras 1992, p. 540. -10. ^ Elphick, Dunning & Sibley 2001, p. 191. -11. ^ Kear 2005, p. 448. -12. ^ Kear 2005, p. 622–623. -13. ^ Kear 2005, p. 686. -14. ^ Elphick, Dunning & Sibley 2001, p. 193. -15. ^ a b c d e f g Carboneras 1992, p. 537. -16. ^ American Ornithologists' Union 1998, p. xix. -17. ^ American Ornithologists' Union 1998. -18. ^ Carboneras 1992, p. 538. -19. ^ Christidis & Boles 2008, p. 62. -20. ^ Shirihai 2008, pp. 239, 245. -21. ^ a b Pratt, Bruner & Berrett 1987, pp. 98–107. -22. ^ Fitter, Fitter & Hosking 2000, pp. 52–3. -23. ^ "Pacific Black Duck". www.wiresnr.org. Retrieved 2018-04-27. -24. ^ Ogden, Evans. "Dabbling Ducks". CWE. Retrieved 2006-11-02. -25. ^ Karl Mathiesen (16 March 2015). "Don't feed the ducks bread, say conservationists". The Guardian. Retrieved 13 November 2016. -26. ^ Rohwer, Frank C.; Anderson, Michael G. (1988). "Female-Biased Philopatry, Monogamy, and the Timing of Pair Formation in Migratory Waterfowl". Current Ornithology. pp. 187–221. doi:10.1007/978-1-4615-6787-5\_4. ISBN 978-1-4615-6789-9. -27. ^ Smith, Cyndi M.; Cooke, Fred; Robertson, Gregory J.; Goudie, R. Ian; Boyd, W. Sean (2000). "Long-Term Pair Bonds in Harlequin Ducks". The Condor. 102 (1): 201–205. doi:10.1093/condor/102.1.201. hdl:10315/13797. -28. ^ "If You Find An Orphaned Duckling - Wildlife Rehabber". wildliferehabber.com. Archived from the original on 2018-09-23. Retrieved 2018-12-22. -29. ^ Carver, Heather (2011). The Duck Bible. Lulu.com. ISBN 9780557901562.[self-published source] -30. ^ Titlow, Budd (2013-09-03). Bird Brains: Inside the Strange Minds of Our Fine Feathered Friends. Rowman & Littlefield. ISBN 9780762797707. -31. ^ Amos, Jonathan (2003-09-08). "Sound science is quackers". BBC News. Retrieved 2006-11-02. -32. ^ "Mythbusters Episode 8". 12 December 2003. -33. ^ Erlandson 1994, p. 171. -34. ^ Jeffries 2008, pp. 168, 243. -35. ^ a b Sued-Badillo 2003, p. 65. -36. ^ Thorpe 1996, p. 68. -37. ^ Maisels 1999, p. 42. -38. ^ Rau 1876, p. 133. -39. ^ Higman 2012, p. 23. -40. ^ Hume 2012, p. 53. -41. ^ Hume 2012, p. 52. -42. ^ Fieldhouse 2002, p. 167. -43. ^ Livingston, A. D. (1998-01-01). Guide to Edible Plants and Animals. Wordsworth Editions, Limited. ISBN 9781853263774. -44. ^ "Study plan for waterfowl injury assessment: Determining PCB concentrations in Hudson river resident waterfowl" (PDF). New York State Department of Environmental Conservation. US Department of Commerce. December 2008. p. 3. Archived (PDF) from the original on 2022-10-09. Retrieved 2 July 2019. -45. ^ "FAOSTAT". www.fao.org. Retrieved 2019-10-25. -46. ^ "Anas platyrhynchos, Domestic Duck; DigiMorph Staff - The University of Texas at Austin". Digimorph.org. Retrieved 2012-12-23. -47. ^ Sy Montgomery. "Mallard; Encyclopædia Britannica". Britannica.com. Retrieved 2012-12-23. -48. ^ Glenday, Craig (2014). Guinness World Records. Guinness World Records Limited. pp. 135. ISBN 978-1-908843-15-9. -49. ^ Suomen kunnallisvaakunat (in Finnish). Suomen Kunnallisliitto. 1982. p. 147. ISBN 951-773-085-3. -50. ^ "Lubānas simbolika" (in Latvian). Retrieved September 9, 2021. -51. ^ "Föglö" (in Swedish). Retrieved September 9, 2021. -52. ^ Young, Emma. "World's funniest joke revealed". New Scientist. Retrieved 7 January 2019. -53. ^ "Howard the Duck (character)". Grand Comics Database. -54. ^ Sanderson, Peter; Gilbert, Laura (2008). "1970s". Marvel Chronicle A Year by Year History. London, United Kingdom: Dorling Kindersley. p. 161. ISBN 978-0756641238. December saw the debut of the cigar-smoking Howard the Duck. In this story by writer Steve Gerber and artist Val Mayerik, various beings from different realities had begun turning up in the Man-Thing's Florida swamp, including this bad-tempered talking duck. -55. ^ "The Duck". University of Oregon Athletics. Retrieved 2022-01-20. +1. ^ "Duckling" . The American Heritage Dictionary of the English Language, Fourth Edition . Houghton Mifflin Company. 2006 . Retrieved 2015-05-22 . +2. ^ "Duckling" . Kernerman English Multilingual Dictionary (Beta Version) . K. Dictionaries Ltd. 2000–2006 . Retrieved 2015-05-22 . +3. ^ Dohner, Janet Vorwald (2001). The Encyclopedia of Historic and Endangered Livestock and Poultry Breeds . Yale University Press. ISBN 978-0300138139 . +4. ^ Visca, Curt; Visca, Kelley (2003). How to Draw Cartoon Birds . The Rosen Publishing Group. ISBN 9780823961566 . +5. ^ a b c d Carboneras 1992 , p. 536. +6. ^ Livezey 1986 , pp. 737–738. +7. ^ Madsen, McHugh & de Kloet 1988 , p. 452. +8. ^ Donne-Goussé, Laudet & Hänni 2002 , pp. 353–354. +9. ^ a b c d e f Carboneras 1992 , p. 540. +10. ^ Elphick, Dunning & Sibley 2001 , p. 191. +11. ^ Kear 2005 , p. 448. +12. ^ Kear 2005 , p. 622–623. +13. ^ Kear 2005 , p. 686. +14. ^ Elphick, Dunning & Sibley 2001 , p. 193. +15. ^ a b c d e f g Carboneras 1992 , p. 537. +16. ^ American Ornithologists' Union 1998 , p. xix. +17. ^ American Ornithologists' Union 1998 . +18. ^ Carboneras 1992 , p. 538. +19. ^ Christidis & Boles 2008 , p. 62. +20. ^ Shirihai 2008 , pp. 239, 245. +21. ^ a b Pratt, Bruner & Berrett 1987 , pp. 98–107. +22. ^ Fitter, Fitter & Hosking 2000 , pp. 52–3. +23. ^ "Pacific Black Duck" . www.wiresnr.org . Retrieved 2018-04-27 . +24. ^ Ogden, Evans. "Dabbling Ducks" . CWE . Retrieved 2006-11-02 . +25. ^ Karl Mathiesen (16 March 2015). "Don't feed the ducks bread, say conservationists" . The Guardian . Retrieved 13 November 2016 . +26. ^ Rohwer, Frank C.; Anderson, Michael G. (1988). "Female-Biased Philopatry, Monogamy, and the Timing of Pair Formation in Migratory Waterfowl". Current Ornithology . pp. 187–221. doi : 10.1007/978-1-4615-6787-5\_4 . ISBN 978-1-4615-6789-9 . +27. ^ Smith, Cyndi M.; Cooke, Fred; Robertson, Gregory J.; Goudie, R. Ian; Boyd, W. Sean (2000). "Long-Term Pair Bonds in Harlequin Ducks" . The Condor . 102 (1): 201–205. doi : 10.1093/condor/102.1.201 . hdl : 10315/13797 . +28. ^ "If You Find An Orphaned Duckling - Wildlife Rehabber" . wildliferehabber.com . Archived from the original on 2018-09-23 . Retrieved 2018-12-22 . +29. ^ Carver, Heather (2011). The Duck Bible . Lulu.com. ISBN 9780557901562 . [ self-published source ] +30. ^ Titlow, Budd (2013-09-03). Bird Brains: Inside the Strange Minds of Our Fine Feathered Friends . Rowman & Littlefield. ISBN 9780762797707 . +31. ^ Amos, Jonathan (2003-09-08). "Sound science is quackers" . BBC News . Retrieved 2006-11-02 . +32. ^ "Mythbusters Episode 8" . 12 December 2003. +33. ^ Erlandson 1994 , p. 171. +34. ^ Jeffries 2008 , pp. 168, 243. +35. ^ a b Sued-Badillo 2003 , p. 65. +36. ^ Thorpe 1996 , p. 68. +37. ^ Maisels 1999 , p. 42. +38. ^ Rau 1876 , p. 133. +39. ^ Higman 2012 , p. 23. +40. ^ Hume 2012 , p. 53. +41. ^ Hume 2012 , p. 52. +42. ^ Fieldhouse 2002 , p. 167. +43. ^ Livingston, A. D. (1998-01-01). Guide to Edible Plants and Animals . Wordsworth Editions, Limited. ISBN 9781853263774 . +44. ^ "Study plan for waterfowl injury assessment: Determining PCB concentrations in Hudson river resident waterfowl" (PDF) . New York State Department of Environmental Conservation . US Department of Commerce. December 2008. p. 3. Archived (PDF) from the original on 2022-10-09 . Retrieved 2 July 2019 . +45. ^ "FAOSTAT" . www.fao.org . Retrieved 2019-10-25 . +46. ^ "Anas platyrhynchos, Domestic Duck; DigiMorph Staff - The University of Texas at Austin" . Digimorph.org . Retrieved 2012-12-23 . +47. ^ Sy Montgomery. "Mallard; Encyclopædia Britannica" . Britannica.com . Retrieved 2012-12-23 . +48. ^ Glenday, Craig (2014). Guinness World Records . Guinness World Records Limited. pp. 135 . ISBN 978-1-908843-15-9 . +49. ^ Suomen kunnallisvaakunat (in Finnish). Suomen Kunnallisliitto. 1982. p. 147. ISBN 951-773-085-3 . +50. ^ "Lubānas simbolika" (in Latvian) . Retrieved September 9, 2021 . +51. ^ "Föglö" (in Swedish) . Retrieved September 9, 2021 . +52. ^ Young, Emma. "World's funniest joke revealed" . New Scientist . Retrieved 7 January 2019 . +53. ^ "Howard the Duck (character)" . Grand Comics Database . +54. ^ Sanderson, Peter ; Gilbert, Laura (2008). "1970s". Marvel Chronicle A Year by Year History . London, United Kingdom: Dorling Kindersley . p. 161. ISBN 978-0756641238 . December saw the debut of the cigar-smoking Howard the Duck. In this story by writer Steve Gerber and artist Val Mayerik, various beings from different realities had begun turning up in the Man-Thing's Florida swamp, including this bad-tempered talking duck. +55. ^ "The Duck" . University of Oregon Athletics . Retrieved 2022-01-20 . -### Sources +#### Sources -- American Ornithologists' Union (1998). Checklist of North American Birds (PDF). Washington, DC: American Ornithologists' Union. ISBN 978-1-891276-00-2. Archived (PDF) from the original on 2022-10-09. -- Carboneras, Carlos (1992). del Hoyo, Josep; Elliott, Andrew; Sargatal, Jordi (eds.). Handbook of the Birds of the World. Vol. 1: Ostrich to Ducks. Barcelona: Lynx Edicions. ISBN 978-84-87334-10-8. -- Christidis, Les; Boles, Walter E., eds. (2008). Systematics and Taxonomy of Australian Birds. Collingwood, VIC: Csiro Publishing. ISBN 978-0-643-06511-6. -- Donne-Goussé, Carole; Laudet, Vincent; Hänni, Catherine (July 2002). "A molecular phylogeny of Anseriformes based on mitochondrial DNA analysis". Molecular Phylogenetics and Evolution. 23 (3): 339–356. Bibcode:2002MolPE..23..339D. doi:10.1016/S1055-7903(02)00019-2. PMID 12099792. -- Elphick, Chris; Dunning, John B. Jr.; Sibley, David, eds. (2001). The Sibley Guide to Bird Life and Behaviour. London: Christopher Helm. ISBN 978-0-7136-6250-4. -- Erlandson, Jon M. (1994). Early Hunter-Gatherers of the California Coast. New York, NY: Springer Science & Business Media. ISBN 978-1-4419-3231-0. -- Fieldhouse, Paul (2002). Food, Feasts, and Faith: An Encyclopedia of Food Culture in World Religions. Vol. I: A–K. Santa Barbara: ABC-CLIO. ISBN 978-1-61069-412-4. -- Fitter, Julian; Fitter, Daniel; Hosking, David (2000). Wildlife of the Galápagos. Princeton, NJ: Princeton University Press. ISBN 978-0-691-10295-5. -- Higman, B. W. (2012). How Food Made History. Chichester, UK: John Wiley & Sons. ISBN 978-1-4051-8947-7. -- Hume, Julian H. (2012). Extinct Birds. London: Christopher Helm. ISBN 978-1-4729-3744-5. -- Jeffries, Richard (2008). Holocene Hunter-Gatherers of the Lower Ohio River Valley. Tuscaloosa: University of Alabama Press. ISBN 978-0-8173-1658-7. -- Kear, Janet, ed. (2005). Ducks, Geese and Swans: Species Accounts (Cairina to Mergus). Bird Families of the World. Oxford: Oxford University Press. ISBN 978-0-19-861009-0. -- Livezey, Bradley C. (October 1986). "A phylogenetic analysis of recent Anseriform genera using morphological characters" (PDF). The Auk. 103 (4): 737–754. doi:10.1093/auk/103.4.737. Archived (PDF) from the original on 2022-10-09. -- Madsen, Cort S.; McHugh, Kevin P.; de Kloet, Siwo R. (July 1988). "A partial classification of waterfowl (Anatidae) based on single-copy DNA" (PDF). The Auk. 105 (3): 452–459. doi:10.1093/auk/105.3.452. Archived (PDF) from the original on 2022-10-09. -- Maisels, Charles Keith (1999). Early Civilizations of the Old World. London: Routledge. ISBN 978-0-415-10975-8. -- Pratt, H. Douglas; Bruner, Phillip L.; Berrett, Delwyn G. (1987). A Field Guide to the Birds of Hawaii and the Tropical Pacific. Princeton, NJ: Princeton University Press. ISBN 0-691-02399-9. -- Rau, Charles (1876). Early Man in Europe. New York: Harper & Brothers. LCCN 05040168. -- Shirihai, Hadoram (2008). A Complete Guide to Antarctic Wildlife. Princeton, NJ, US: Princeton University Press. ISBN 978-0-691-13666-0. -- Sued-Badillo, Jalil (2003). Autochthonous Societies. General History of the Caribbean. Paris: UNESCO. ISBN 978-92-3-103832-7. -- Thorpe, I. J. (1996). The Origins of Agriculture in Europe. New York: Routledge. ISBN 978-0-415-08009-5. +- American Ornithologists' Union (1998). Checklist of North American Birds (PDF) . Washington, DC: American Ornithologists' Union. ISBN 978-1-891276-00-2 . Archived (PDF) from the original on 2022-10-09. +- Carboneras, Carlos (1992). del Hoyo, Josep; Elliott, Andrew; Sargatal, Jordi (eds.). Handbook of the Birds of the World . Vol. 1: Ostrich to Ducks. Barcelona: Lynx Edicions. ISBN 978-84-87334-10-8 . +- Christidis, Les; Boles, Walter E., eds. (2008). Systematics and Taxonomy of Australian Birds . Collingwood, VIC: Csiro Publishing. ISBN 978-0-643-06511-6 . +- Donne-Goussé, Carole; Laudet, Vincent; Hänni, Catherine (July 2002). "A molecular phylogeny of Anseriformes based on mitochondrial DNA analysis". Molecular Phylogenetics and Evolution . 23 (3): 339–356. Bibcode : 2002MolPE..23..339D . doi : 10.1016/S1055-7903(02)00019-2 . PMID 12099792 . +- Elphick, Chris; Dunning, John B. Jr.; Sibley, David, eds. (2001). The Sibley Guide to Bird Life and Behaviour . London: Christopher Helm. ISBN 978-0-7136-6250-4 . +- Erlandson, Jon M. (1994). Early Hunter-Gatherers of the California Coast . New York, NY: Springer Science & Business Media. ISBN 978-1-4419-3231-0 . +- Fieldhouse, Paul (2002). Food, Feasts, and Faith: An Encyclopedia of Food Culture in World Religions . Vol. I: A–K. Santa Barbara: ABC-CLIO. ISBN 978-1-61069-412-4 . +- Fitter, Julian; Fitter, Daniel; Hosking, David (2000). Wildlife of the Galápagos . Princeton, NJ: Princeton University Press. ISBN 978-0-691-10295-5 . +- Higman, B. W. (2012). How Food Made History . Chichester, UK: John Wiley & Sons. ISBN 978-1-4051-8947-7 . +- Hume, Julian H. (2012). Extinct Birds . London: Christopher Helm. ISBN 978-1-4729-3744-5 . +- Jeffries, Richard (2008). Holocene Hunter-Gatherers of the Lower Ohio River Valley . Tuscaloosa: University of Alabama Press. ISBN 978-0-8173-1658-7 . +- Kear, Janet, ed. (2005). Ducks, Geese and Swans: Species Accounts ( Cairina to Mergus ) . Bird Families of the World. Oxford: Oxford University Press. ISBN 978-0-19-861009-0 . +- Livezey, Bradley C. (October 1986). "A phylogenetic analysis of recent Anseriform genera using morphological characters" (PDF) . The Auk . 103 (4): 737–754. doi : 10.1093/auk/103.4.737 . Archived (PDF) from the original on 2022-10-09. +- Madsen, Cort S.; McHugh, Kevin P.; de Kloet, Siwo R. (July 1988). "A partial classification of waterfowl (Anatidae) based on single-copy DNA" (PDF) . The Auk . 105 (3): 452–459. doi : 10.1093/auk/105.3.452 . Archived (PDF) from the original on 2022-10-09. +- Maisels, Charles Keith (1999). Early Civilizations of the Old World . London: Routledge. ISBN 978-0-415-10975-8 . +- Pratt, H. Douglas; Bruner, Phillip L.; Berrett, Delwyn G. (1987). A Field Guide to the Birds of Hawaii and the Tropical Pacific . Princeton, NJ: Princeton University Press. ISBN 0-691-02399-9 . +- Rau, Charles (1876). Early Man in Europe . New York: Harper & Brothers. LCCN 05040168 . +- Shirihai, Hadoram (2008). A Complete Guide to Antarctic Wildlife . Princeton, NJ, US: Princeton University Press. ISBN 978-0-691-13666-0 . +- Sued-Badillo, Jalil (2003). Autochthonous Societies . General History of the Caribbean. Paris: UNESCO. ISBN 978-92-3-103832-7 . +- Thorpe, I. J. (1996). The Origins of Agriculture in Europe . New York: Routledge. ISBN 978-0-415-08009-5 . -## External links +### External links + +Duck at Wikipedia's sister projects - Definitions from Wiktionary - Media from Commons @@ -472,16 +524,76 @@ The 1992 Disney film The Mighty Ducks, starring Emilio Estevez, chose the duck a - Ducks on postage stamps Archived 2013-05-13 at the Wayback Machine - Ducks at a Distance, by Rob Hines at Project Gutenberg - A modern illustrated guide to identification of US waterfowl -| Authority control databases | Authority control databases | -|--------------------------------|----------------------------------------------| -| National | United StatesFranceBnF dataJapanLatviaIsrael | -| Other | IdRef | +| Authority control databases | Authority control databases | +|-------------------------------|----------------------------------------------| +| National | United StatesFranceBnF dataJapanLatviaIsrael | +| Other | IdRef | - +NewPP limit report -Retrieved from "" +Parsed by mw‐web.codfw.main‐5d5b97b956‐mw5gf -: +Cached time: 20241001035144 + +Cache expiry: 2592000 + +Reduced expiry: false + +Complications: [vary‐revision‐sha1, show‐toc] + +CPU time usage: 1.191 seconds + +Real time usage: 1.452 seconds + +Preprocessor visited node count: 12444/1000000 + +Post‐expand include size: 122530/2097152 bytes + +Template argument size: 9168/2097152 bytes + +Highest expansion depth: 14/100 + +Expensive parser function count: 14/500 + +Unstrip recursion depth: 1/20 + +Unstrip post‐expand size: 165576/5000000 bytes + +Lua time usage: 0.865/10.000 seconds + +Lua memory usage: 25093454/52428800 bytes + +Number of Wikibase entities loaded: 1/400 + +Transclusion expansion time report (%,ms,calls,template) + +100.00% 1311.889 1 -total + +22.17% 290.786 1 Template:Automatic\_taxobox + +16.91% 221.802 1 Template:Reflist + +10.86% 142.472 44 Template:Sfn + +9.48% 124.344 15 Template:Lang + +9.25% 121.312 15 Template:Cite\_web + +8.03% 105.346 26 Template:Cite\_book + +5.85% 76.725 1 Template:Short\_description + +5.74% 75.262 1 Template:Authority\_control + +4.50% 58.973 1 Template:Sisterlinks + +Saved in parser cache with key enwiki:pcache:idhash:37674-0!canonical and timestamp 20241001035144 and revision id 1246843351. Rendering was triggered because: page-view + +esi <esi:include src="/esitest-fa8a495983347898/content" /> + +Retrieved from "https://en.wikipedia.org/w/index.php?title=Duck&oldid=1246843351" + +Categories: - Ducks - Game birds @@ -516,9 +628,9 @@ Hidden categories: - Articles with Project Gutenberg links - Articles containing video clips -- This page was last edited on 21 September 2024, at 12:11 (UTC). -- Text is available under the Creative Commons Attribution-ShareAlike License 4.0; -additional terms may apply. By using this site, you agree to the Terms of Use and Privacy Policy. Wikipedia® is a registered trademark of the Wikimedia Foundation, Inc., a non-profit organization. +- This page was last edited on 21 September 2024, at 12:11 (UTC) . +- Text is available under the Creative Commons Attribution-ShareAlike License 4.0 ; +additional terms may apply. By using this site, you agree to the Terms of Use and Privacy Policy . Wikipedia® is a registered trademark of the Wikimedia Foundation, Inc. , a non-profit organization. - Privacy policy - About Wikipedia diff --git a/tests/data/groundtruth/docling_v2/word_sample.docx.json b/tests/data/groundtruth/docling_v2/word_sample.docx.json index 1d305cbc..d2b97398 100644 --- a/tests/data/groundtruth/docling_v2/word_sample.docx.json +++ b/tests/data/groundtruth/docling_v2/word_sample.docx.json @@ -462,7 +462,7 @@ "width": 397.0, "height": 397.0 }, - "uri": "data:image/png;base64,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" + "uri": "data:image/png;base64,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" }, "annotations": [] } diff --git a/tests/data/html/example_08.html b/tests/data/html/example_08.html new file mode 100644 index 00000000..3e963a86 --- /dev/null +++ b/tests/data/html/example_08.html @@ -0,0 +1,21 @@ + + +

      Introduction to parsing HTML files with Docling Docling

      +

      Docling simplifies document processing, parsing diverse formats — including HTML — and providing seamless integrations with the gen AI ecosystem.

      +

      Supported file formats

      +

      Docling supports multiple file formats..

      +
        +
      • PDFAdvanced PDF understanding
      • +
      • DOCXMicrosoft Office DOCX
      • +
      • HTMLHTML files (with optional support for images)
      • +
      +

      Three backends for handling HTML files

      +

      Docling has three backends for parsing HTML files:

      +
        +
      1. HTMLDocumentBackend Ignores images
      2. +
      3. HTMLDocumentBackendImagesInline Extracts images inline
      4. +
      5. HTMLDocumentBackendImagesReferenced Extracts images as references
      6. +
      + + + diff --git a/tests/data/html/example_09.html b/tests/data/html/example_09.html new file mode 100644 index 00000000..087d2b16 --- /dev/null +++ b/tests/data/html/example_09.html @@ -0,0 +1,21 @@ + + +

      Introduction to parsing HTML files with Docling Docling

      +

      Docling simplifies document processing, parsing diverse formats — including HTML — and providing seamless integrations with the gen AI ecosystem.

      +

      Supported file formats

      +

      Docling supports multiple file formats..

      +
        +
      • PDFAdvanced PDF understanding
      • +
      • DOCXMicrosoft Office DOCX
      • +
      • HTMLHTML files (with optional support for images)
      • +
      +

      Three backends for handling HTML files

      +

      Docling has three backends for parsing HTML files:

      +
        +
      1. HTMLDocumentBackend Ignores images
      2. +
      3. HTMLDocumentBackendImagesInline Extracts images inline
      4. +
      5. HTMLDocumentBackendImagesReferenced Extracts images as references
      6. +
      + + + diff --git a/tests/test_backend_html.py b/tests/test_backend_html.py index 18254a78..a5c1edcb 100644 --- a/tests/test_backend_html.py +++ b/tests/test_backend_html.py @@ -37,10 +37,10 @@ def test_heading_levels(): if isinstance(item, SectionHeaderItem): if item.text == "Etymology": found_lvl_1 = True - assert item.level == 1 + assert item.level == 2 elif item.text == "Feeding": found_lvl_2 = True - assert item.level == 2 + assert item.level == 3 assert found_lvl_1 and found_lvl_2