From e07fdf2e9157aa96f8f28bc4945df462eeafd43d Mon Sep 17 00:00:00 2001
From: Jakub Trllo <jakub.trllo@gmail.com>
Date: Tue, 30 Aug 2022 17:48:46 +0200
Subject: [PATCH 01/15] added settings for nuke

---
 openpype/settings/defaults/project_settings/maya.json         | 2 +-
 openpype/settings/defaults/project_settings/nuke.json         | 3 +++
 .../entities/schemas/projects_schema/schema_project_nuke.json | 4 ++++
 .../schemas/schema_templated_workfile_build.json              | 2 +-
 4 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/openpype/settings/defaults/project_settings/maya.json b/openpype/settings/defaults/project_settings/maya.json
index 28f6d23e4d7..38063bc2c13 100644
--- a/openpype/settings/defaults/project_settings/maya.json
+++ b/openpype/settings/defaults/project_settings/maya.json
@@ -980,4 +980,4 @@
             "ValidateNoAnimation": false
         }
     }
-}
+}
\ No newline at end of file
diff --git a/openpype/settings/defaults/project_settings/nuke.json b/openpype/settings/defaults/project_settings/nuke.json
index f40ec1fe9e3..c3eda2cbb42 100644
--- a/openpype/settings/defaults/project_settings/nuke.json
+++ b/openpype/settings/defaults/project_settings/nuke.json
@@ -325,5 +325,8 @@
             }
         ]
     },
+    "templated_workfile_build": {
+        "profiles": []
+    },
     "filters": {}
 }
\ No newline at end of file
diff --git a/openpype/settings/entities/schemas/projects_schema/schema_project_nuke.json b/openpype/settings/entities/schemas/projects_schema/schema_project_nuke.json
index 03d67a57ba1..7cf82b9e69a 100644
--- a/openpype/settings/entities/schemas/projects_schema/schema_project_nuke.json
+++ b/openpype/settings/entities/schemas/projects_schema/schema_project_nuke.json
@@ -308,6 +308,10 @@
             "type": "schema_template",
             "name": "template_workfile_options"
         },
+        {
+            "type": "schema",
+            "name": "schema_templated_workfile_build"
+        },
         {
             "type": "schema",
             "name": "schema_publish_gui_filter"
diff --git a/openpype/settings/entities/schemas/projects_schema/schemas/schema_templated_workfile_build.json b/openpype/settings/entities/schemas/projects_schema/schemas/schema_templated_workfile_build.json
index a591facf988..99a29beb27c 100644
--- a/openpype/settings/entities/schemas/projects_schema/schemas/schema_templated_workfile_build.json
+++ b/openpype/settings/entities/schemas/projects_schema/schemas/schema_templated_workfile_build.json
@@ -17,7 +17,7 @@
                         "type": "task-types-enum"
                     },
                     {
-                        "key": "tasks",
+                        "key": "task_names",
                         "label": "Task names",
                         "type": "list",
                         "object_type": "text"

From 2397577dbdaf386c55d58ba5167aba70d08c24cb Mon Sep 17 00:00:00 2001
From: Jakub Trllo <jakub.trllo@gmail.com>
Date: Wed, 31 Aug 2022 10:48:40 +0200
Subject: [PATCH 02/15] node temp file can create more then one tempfile at
 once

---
 openpype/hosts/nuke/api/lib.py | 19 ++++++-------------
 1 file changed, 6 insertions(+), 13 deletions(-)

diff --git a/openpype/hosts/nuke/api/lib.py b/openpype/hosts/nuke/api/lib.py
index b14f1a1eb15..e51f1f75863 100644
--- a/openpype/hosts/nuke/api/lib.py
+++ b/openpype/hosts/nuke/api/lib.py
@@ -2708,26 +2708,19 @@ def _duplicate_node_temp():
     This is to avoid using clipboard for node duplication.
     """
 
-    duplicate_node_temp_path = os.path.join(
-        tempfile.gettempdir(),
-        "openpype_nuke_duplicate_temp_{}".format(os.getpid())
+    tmp_file = tempfile.NamedTemporaryFile(
+        mode="w", prefix="openpype_nuke_temp_", suffix=".nk", delete=False
     )
-
-    # This can happen only if 'duplicate_node' would be
-    if os.path.exists(duplicate_node_temp_path):
-        log.warning((
-            "Temp file for node duplication already exists."
-            " Trying to remove {}"
-        ).format(duplicate_node_temp_path))
-        os.remove(duplicate_node_temp_path)
+    tmp_file.close()
+    node_tempfile_path = tmp_file.name
 
     try:
         # Yield the path where node can be copied
-        yield duplicate_node_temp_path
+        yield node_tempfile_path
 
     finally:
         # Remove the file at the end
-        os.remove(duplicate_node_temp_path)
+        os.remove(node_tempfile_path)
 
 
 def duplicate_node(node):

From c2fdf6d1d0ec9764717a962c291353a3c3634539 Mon Sep 17 00:00:00 2001
From: Jakub Trllo <jakub.trllo@gmail.com>
Date: Wed, 31 Aug 2022 10:49:04 +0200
Subject: [PATCH 03/15] _duplicate_node_temp is public and renamed to
 node_tempfile

---
 openpype/hosts/nuke/api/lib.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/openpype/hosts/nuke/api/lib.py b/openpype/hosts/nuke/api/lib.py
index e51f1f75863..6675e3ca5ee 100644
--- a/openpype/hosts/nuke/api/lib.py
+++ b/openpype/hosts/nuke/api/lib.py
@@ -2702,7 +2702,7 @@ def sync_module(cls):
 
 
 @contextlib.contextmanager
-def _duplicate_node_temp():
+def node_tempfile():
     """Create a temp file where node is pasted during duplication.
 
     This is to avoid using clipboard for node duplication.
@@ -2729,7 +2729,7 @@ def duplicate_node(node):
     # select required node for duplication
     node.setSelected(True)
 
-    with _duplicate_node_temp() as filepath:
+    with node_tempfile() as filepath:
         # copy selected to temp filepath
         nuke.nodeCopy(filepath)
 

From 4cbc82778ea0aaa9fbeb333d4047b59544d68577 Mon Sep 17 00:00:00 2001
From: Jakub Trllo <jakub.trllo@gmail.com>
Date: Wed, 31 Aug 2022 10:49:32 +0200
Subject: [PATCH 04/15] moved 'get_main_window' to nuke lib

---
 openpype/hosts/nuke/api/lib.py      | 17 +++++++++++++++++
 openpype/hosts/nuke/api/pipeline.py | 20 ++------------------
 2 files changed, 19 insertions(+), 18 deletions(-)

diff --git a/openpype/hosts/nuke/api/lib.py b/openpype/hosts/nuke/api/lib.py
index 6675e3ca5ee..9f28194a933 100644
--- a/openpype/hosts/nuke/api/lib.py
+++ b/openpype/hosts/nuke/api/lib.py
@@ -76,6 +76,23 @@ class Context:
     _project_doc = None
 
 
+def get_main_window():
+    """Acquire Nuke's main window"""
+    if Context.main_window is None:
+        from Qt import QtWidgets
+
+        top_widgets = QtWidgets.QApplication.topLevelWidgets()
+        name = "Foundry::UI::DockMainWindow"
+        for widget in top_widgets:
+            if (
+                widget.inherits("QMainWindow")
+                and widget.metaObject().className() == name
+            ):
+                Context.main_window = widget
+                break
+    return Context.main_window
+
+
 class Knobby(object):
     """For creating knob which it's type isn't mapped in `create_knobs`
 
diff --git a/openpype/hosts/nuke/api/pipeline.py b/openpype/hosts/nuke/api/pipeline.py
index c1cd8f771a7..c680cd91199 100644
--- a/openpype/hosts/nuke/api/pipeline.py
+++ b/openpype/hosts/nuke/api/pipeline.py
@@ -26,6 +26,8 @@
 
 from .command import viewer_update_and_undo_stop
 from .lib import (
+    Context,
+    get_main_window,
     add_publish_knob,
     WorkfileSettings,
     process_workfile_builder,
@@ -33,7 +35,6 @@
     check_inventory_versions,
     set_avalon_knob_data,
     read_avalon_data,
-    Context
 )
 
 log = Logger.get_logger(__name__)
@@ -53,23 +54,6 @@
     pyblish.api.register_gui(os.getenv("PYBLISH_GUI", None))
 
 
-def get_main_window():
-    """Acquire Nuke's main window"""
-    if Context.main_window is None:
-        from Qt import QtWidgets
-
-        top_widgets = QtWidgets.QApplication.topLevelWidgets()
-        name = "Foundry::UI::DockMainWindow"
-        for widget in top_widgets:
-            if (
-                widget.inherits("QMainWindow")
-                and widget.metaObject().className() == name
-            ):
-                Context.main_window = widget
-                break
-    return Context.main_window
-
-
 def reload_config():
     """Attempt to reload pipeline at run-time.
 

From d31d004f67c62918ea48a66e982a1489d0ca49cb Mon Sep 17 00:00:00 2001
From: Jakub Trllo <jakub.trllo@gmail.com>
Date: Wed, 31 Aug 2022 10:50:04 +0200
Subject: [PATCH 05/15] added few helper functions to lib

---
 openpype/hosts/nuke/api/lib.py | 97 ++++++++++++++++++++++++++++++++++
 1 file changed, 97 insertions(+)

diff --git a/openpype/hosts/nuke/api/lib.py b/openpype/hosts/nuke/api/lib.py
index 9f28194a933..b8fbecd8747 100644
--- a/openpype/hosts/nuke/api/lib.py
+++ b/openpype/hosts/nuke/api/lib.py
@@ -2817,3 +2817,100 @@ def ls_img_sequence(path):
         }
 
     return False
+
+
+def get_group_io_nodes(nodes):
+    """Get the input and the output of a group of nodes."""
+
+    if not nodes:
+        raise ValueError("there is no nodes in the list")
+
+    input_node = None
+    output_node = None
+
+    if len(nodes) == 1:
+        input_node = output_node = nodes[0]
+
+    else:
+        for node in nodes:
+            if "Input" in node.name():
+                input_node = node
+
+            if "Output" in node.name():
+                output_node = node
+
+            if input_node is not None and output_node is not None:
+                break
+
+        if input_node is None:
+            raise ValueError("No Input found")
+
+        if output_node is None:
+            raise ValueError("No Output found")
+    return input_node, output_node
+
+
+def get_extreme_positions(nodes):
+    """Get the 4 numbers that represent the box of a group of nodes."""
+
+    if not nodes:
+        raise ValueError("there is no nodes in the list")
+
+    nodes_xpos = [n.xpos() for n in nodes] + \
+        [n.xpos() + n.screenWidth() for n in nodes]
+
+    nodes_ypos = [n.ypos() for n in nodes] + \
+        [n.ypos() + n.screenHeight() for n in nodes]
+
+    min_x, min_y = (min(nodes_xpos), min(nodes_ypos))
+    max_x, max_y = (max(nodes_xpos), max(nodes_ypos))
+    return min_x, min_y, max_x, max_y
+
+
+def refresh_node(node):
+    """Correct a bug caused by the multi-threading of nuke.
+
+    Refresh the node to make sure that it takes the desired attributes.
+    """
+
+    x = node.xpos()
+    y = node.ypos()
+    nuke.autoplaceSnap(node)
+    node.setXYpos(x, y)
+
+
+def refresh_nodes(nodes):
+    for node in nodes:
+        refresh_node(node)
+
+
+def get_names_from_nodes(nodes):
+    """Get list of nodes names.
+
+    Args:
+        nodes(List[nuke.Node]): List of nodes to convert into names.
+
+    Returns:
+        List[str]: Name of passed nodes.
+    """
+
+    return [
+        node.name()
+        for node in nodes
+    ]
+
+
+def get_nodes_by_names(names):
+    """Get list of nuke nodes based on their names.
+
+    Args:
+        names (List[str]): List of node names to be found.
+
+    Returns:
+        List[nuke.Node]: List of nodes found by name.
+    """
+
+    return [
+        nuke.toNode(name)
+        for name in names
+    ]

From f339eba67036260c819c364b844552ee32df220f Mon Sep 17 00:00:00 2001
From: Jakub Trllo <jakub.trllo@gmail.com>
Date: Wed, 31 Aug 2022 11:39:22 +0200
Subject: [PATCH 06/15] copied template build logic from
 https://github.com/pypeclub/OpenPype/pull/3681

---
 .../hosts/nuke/api/lib_template_builder.py    | 206 +++++++
 openpype/hosts/nuke/api/template_loader.py    | 534 ++++++++++++++++++
 2 files changed, 740 insertions(+)
 create mode 100644 openpype/hosts/nuke/api/lib_template_builder.py
 create mode 100644 openpype/hosts/nuke/api/template_loader.py

diff --git a/openpype/hosts/nuke/api/lib_template_builder.py b/openpype/hosts/nuke/api/lib_template_builder.py
new file mode 100644
index 00000000000..b95a6edf7b5
--- /dev/null
+++ b/openpype/hosts/nuke/api/lib_template_builder.py
@@ -0,0 +1,206 @@
+from collections import OrderedDict
+
+from openpype.vendor.python.common import qargparse
+from openpype.tools.utils.widgets import OptionDialog
+from openpype.hosts.nuke.api.lib import imprint
+import nuke
+
+
+# To change as enum
+build_types = ["context_asset", "linked_asset", "all_assets"]
+
+
+def get_placeholder_attributes(node, enumerate=False):
+    list_atts = ['builder_type', 'family', 'representation', 'loader',
+                 'loader_args', 'order', 'asset', 'subset',
+                 'hierarchy', 'siblings', 'last_loaded']
+    attributes = {}
+    for attr in node.knobs().keys():
+        if attr in list_atts:
+            if enumerate:
+                try:
+                    attributes[attr] = node.knob(attr).values()
+                except AttributeError:
+                    attributes[attr] = node.knob(attr).getValue()
+            else:
+                attributes[attr] = node.knob(attr).getValue()
+
+    return attributes
+
+
+def delete_placeholder_attributes(node):
+    '''
+    function to delete all extra placeholder attributes
+    '''
+    extra_attributes = get_placeholder_attributes(node)
+    for attribute in extra_attributes.keys():
+        try:
+            node.removeKnob(node.knob(attribute))
+        except ValueError:
+            continue
+
+
+def hide_placeholder_attributes(node):
+    '''
+    function to hide all extra placeholder attributes
+    '''
+    extra_attributes = get_placeholder_attributes(node)
+    for attribute in extra_attributes.keys():
+        try:
+            node.knob(attribute).setVisible(False)
+        except ValueError:
+            continue
+
+
+def create_placeholder():
+
+    args = placeholder_window()
+
+    if not args:
+        return  # operation canceled, no locator created
+
+    placeholder = nuke.nodes.NoOp()
+    placeholder.setName('PLACEHOLDER')
+    placeholder.knob('tile_color').setValue(4278190335)
+
+    # custom arg parse to force empty data query
+    # and still imprint them on placeholder
+    # and getting items when arg is of type Enumerator
+    options = OrderedDict()
+    for arg in args:
+        if not type(arg) == qargparse.Separator:
+            options[str(arg)] = arg._data.get("items") or arg.read()
+    imprint(placeholder, options)
+    imprint(placeholder, {'is_placeholder': True})
+    placeholder.knob('is_placeholder').setVisible(False)
+
+
+def update_placeholder():
+    placeholder = nuke.selectedNodes()
+    if not placeholder:
+        raise ValueError("No node selected")
+    if len(placeholder) > 1:
+        raise ValueError("Too many selected nodes")
+    placeholder = placeholder[0]
+
+    args = placeholder_window(get_placeholder_attributes(placeholder))
+    if not args:
+        return  # operation canceled
+    # delete placeholder attributes
+    delete_placeholder_attributes(placeholder)
+
+    options = OrderedDict()
+    for arg in args:
+        if not type(arg) == qargparse.Separator:
+            options[str(arg)] = arg._data.get("items") or arg.read()
+    imprint(placeholder, options)
+
+
+def imprint_enum(placeholder, args):
+    """
+    Imprint method doesn't act properly with enums.
+    Replacing the functionnality with this for now
+    """
+    enum_values = {str(arg): arg.read()
+                   for arg in args if arg._data.get("items")}
+    string_to_value_enum_table = {
+        build: i for i, build
+        in enumerate(build_types)}
+    attrs = {}
+    for key, value in enum_values.items():
+        attrs[key] = string_to_value_enum_table[value]
+
+
+def placeholder_window(options=None):
+    from openpype.hosts.nuke.api.pipeline import get_main_window
+    options = options or dict()
+    dialog = OptionDialog(parent=get_main_window())
+    dialog.setWindowTitle("Create Placeholder")
+
+    args = [
+        qargparse.Separator("Main attributes"),
+        qargparse.Enum(
+            "builder_type",
+            label="Asset Builder Type",
+            default=options.get("builder_type", 0),
+            items=build_types,
+            help="""Asset Builder Type
+Builder type describe what template loader will look for.
+
+context_asset : Template loader will look for subsets of
+current context asset (Asset bob will find asset)
+
+linked_asset : Template loader will look for assets linked
+to current context asset.
+Linked asset are looked in avalon database under field "inputLinks"
+"""
+        ),
+        qargparse.String(
+            "family",
+            default=options.get("family", ""),
+            label="OpenPype Family",
+            placeholder="ex: model, look ..."),
+        qargparse.String(
+            "representation",
+            default=options.get("representation", ""),
+            label="OpenPype Representation",
+            placeholder="ex: ma, abc ..."),
+        qargparse.String(
+            "loader",
+            default=options.get("loader", ""),
+            label="Loader",
+            placeholder="ex: ReferenceLoader, LightLoader ...",
+            help="""Loader
+
+Defines what openpype loader will be used to load assets.
+Useable loader depends on current host's loader list.
+Field is case sensitive.
+"""),
+        qargparse.String(
+            "loader_args",
+            default=options.get("loader_args", ""),
+            label="Loader Arguments",
+            placeholder='ex: {"camera":"persp", "lights":True}',
+            help="""Loader
+
+Defines a dictionnary of arguments used to load assets.
+Useable arguments depend on current placeholder Loader.
+Field should be a valid python dict. Anything else will be ignored.
+"""),
+        qargparse.Integer(
+            "order",
+            default=options.get("order", 0),
+            min=0,
+            max=999,
+            label="Order",
+            placeholder="ex: 0, 100 ... (smallest order loaded first)",
+            help="""Order
+
+Order defines asset loading priority (0 to 999)
+Priority rule is : "lowest is first to load"."""),
+        qargparse.Separator(
+            "Optional attributes "),
+        qargparse.String(
+            "asset",
+            default=options.get("asset", ""),
+            label="Asset filter",
+            placeholder="regex filtering by asset name",
+            help="Filtering assets by matching field regex to asset's name"),
+        qargparse.String(
+            "subset",
+            default=options.get("subset", ""),
+            label="Subset filter",
+            placeholder="regex filtering by subset name",
+            help="Filtering assets by matching field regex to subset's name"),
+        qargparse.String(
+            "hierarchy",
+            default=options.get("hierarchy", ""),
+            label="Hierarchy filter",
+            placeholder="regex filtering by asset's hierarchy",
+            help="Filtering assets by matching field asset's hierarchy")
+    ]
+    dialog.create(args)
+    if not dialog.exec_():
+        return None
+
+    return args
diff --git a/openpype/hosts/nuke/api/template_loader.py b/openpype/hosts/nuke/api/template_loader.py
new file mode 100644
index 00000000000..861498d2e59
--- /dev/null
+++ b/openpype/hosts/nuke/api/template_loader.py
@@ -0,0 +1,534 @@
+from openpype.hosts.nuke.api.lib_template_builder import (
+    delete_placeholder_attributes, get_placeholder_attributes,
+    hide_placeholder_attributes)
+from openpype.lib.abstract_template_loader import (
+    AbstractPlaceholder,
+    AbstractTemplateLoader)
+import nuke
+from collections import defaultdict
+from openpype.hosts.nuke.api.lib import (
+    find_free_space_to_paste_nodes, get_extremes, get_io, imprint,
+    refresh_node, refresh_nodes, reset_selection,
+    get_names_from_nodes, get_nodes_from_names, select_nodes)
+PLACEHOLDER_SET = 'PLACEHOLDERS_SET'
+
+
+class NukeTemplateLoader(AbstractTemplateLoader):
+    """Concrete implementation of AbstractTemplateLoader for Nuke
+
+    """
+
+    def import_template(self, path):
+        """Import template into current scene.
+        Block if a template is already loaded.
+
+        Args:
+            path (str): A path to current template (usually given by
+            get_template_path implementation)
+
+        Returns:
+            bool: Wether the template was succesfully imported or not
+        """
+
+        # TODO check if the template is already imported
+
+        nuke.nodePaste(path)
+        reset_selection()
+
+        return True
+
+    def preload(self, placeholder, loaders_by_name, last_representation):
+        placeholder.data["nodes_init"] = nuke.allNodes()
+        placeholder.data["_id"] = last_representation['_id']
+
+    def populate_template(self, ignored_ids=None):
+        place_holders = self.get_template_nodes()
+        while len(place_holders) > 0:
+            super().populate_template(ignored_ids)
+            place_holders = self.get_template_nodes()
+
+    @staticmethod
+    def get_template_nodes():
+        placeholders = []
+        allGroups = [nuke.thisGroup()]
+        while len(allGroups) > 0:
+            group = allGroups.pop(0)
+            for node in group.nodes():
+                if "builder_type" in node.knobs().keys() and (
+                   'is_placeholder' in node.knobs().keys()
+                        and node.knob('is_placeholder').value()):
+                    if 'empty' in node.knobs().keys()\
+                            and node.knob('empty').value():
+                        continue
+                    placeholders += [node]
+                if isinstance(node, nuke.Group):
+                    allGroups.append(node)
+
+        return placeholders
+
+    def update_missing_containers(self):
+        nodes_byId = {}
+        nodes_byId = defaultdict(lambda: [], nodes_byId)
+
+        for n in nuke.allNodes():
+            if 'id_rep' in n.knobs().keys():
+                nodes_byId[n.knob('id_rep').getValue()] += [n.name()]
+            if 'empty' in n.knobs().keys():
+                n.removeKnob(n.knob('empty'))
+                imprint(n, {"empty": False})
+        for s in nodes_byId.values():
+            n = None
+            for name in s:
+                n = nuke.toNode(name)
+                if 'builder_type' in n.knobs().keys():
+                    break
+            if n is not None and 'builder_type' in n.knobs().keys():
+
+                placeholder = nuke.nodes.NoOp()
+                placeholder.setName('PLACEHOLDER')
+                placeholder.knob('tile_color').setValue(4278190335)
+                attributes = get_placeholder_attributes(n, enumerate=True)
+                imprint(placeholder, attributes)
+                x = int(n.knob('x').getValue())
+                y = int(n.knob('y').getValue())
+                placeholder.setXYpos(x, y)
+                imprint(placeholder, {'nb_children': 1})
+                refresh_node(placeholder)
+
+        self.populate_template(self.get_loaded_containers_by_id())
+
+    def get_loaded_containers_by_id(self):
+        ids = []
+        for n in nuke.allNodes():
+            if 'id_rep' in n.knobs():
+                ids.append(n.knob('id_rep').getValue())
+
+        # Removes duplicates in the list
+        ids = list(set(ids))
+        return ids
+
+    def get_placeholders(self):
+        placeholders = super().get_placeholders()
+        return placeholders
+
+    def delete_placeholder(self, placeholder):
+        node = placeholder.data['node']
+        lastLoaded = placeholder.data['last_loaded']
+        if not placeholder.data['delete']:
+            if 'empty' in node.knobs().keys():
+                node.removeKnob(node.knob('empty'))
+            imprint(node, {"empty": True})
+        else:
+            if lastLoaded:
+                if 'last_loaded' in node.knobs().keys():
+                    for s in node.knob('last_loaded').values():
+                        n = nuke.toNode(s)
+                        try:
+                            delete_placeholder_attributes(n)
+                        except Exception:
+                            pass
+
+                lastLoaded_names = []
+                for loadedNode in lastLoaded:
+                    lastLoaded_names.append(loadedNode.name())
+                imprint(node, {'last_loaded': lastLoaded_names})
+
+                for n in lastLoaded:
+                    refresh_node(n)
+                    refresh_node(node)
+                    if 'builder_type' not in n.knobs().keys():
+                        attributes = get_placeholder_attributes(node, True)
+                        imprint(n, attributes)
+                        imprint(n, {'is_placeholder': False})
+                        hide_placeholder_attributes(n)
+                        n.knob('is_placeholder').setVisible(False)
+                        imprint(n, {'x': node.xpos(), 'y': node.ypos()})
+                        n.knob('x').setVisible(False)
+                        n.knob('y').setVisible(False)
+            nuke.delete(node)
+
+
+class NukePlaceholder(AbstractPlaceholder):
+    """Concrete implementation of AbstractPlaceholder for Nuke
+
+    """
+
+    optional_attributes = {'asset', 'subset', 'hierarchy'}
+
+    def get_data(self, node):
+        user_data = dict()
+        dictKnobs = node.knobs()
+        for attr in self.attributes.union(self.optional_attributes):
+            if attr in dictKnobs.keys():
+                user_data[attr] = dictKnobs[attr].getValue()
+        user_data['node'] = node
+
+        if 'nb_children' in dictKnobs.keys():
+            user_data['nb_children'] = int(dictKnobs['nb_children'].getValue())
+        else:
+            user_data['nb_children'] = 0
+        if 'siblings' in dictKnobs.keys():
+            user_data['siblings'] = dictKnobs['siblings'].values()
+        else:
+            user_data['siblings'] = []
+
+        fullName = node.fullName()
+        user_data['group_name'] = fullName.rpartition('.')[0]
+        user_data['last_loaded'] = []
+        user_data['delete'] = False
+        self.data = user_data
+
+    def parent_in_hierarchy(self, containers):
+        return
+
+    def create_sib_copies(self):
+        """ creating copies of the palce_holder siblings (the ones who were
+        loaded with it) for the new nodes added
+
+        Returns :
+            copies (dict) : with copied nodes names and their copies
+        """
+
+        copies = {}
+        siblings = get_nodes_from_names(self.data['siblings'])
+        for n in siblings:
+            reset_selection()
+            n.setSelected(True)
+            nuke.nodeCopy("%clipboard%")
+            reset_selection()
+            nuke.nodePaste("%clipboard%")
+            new_node = nuke.selectedNodes()[0]
+            x_init = int(new_node.knob('x_init').getValue())
+            y_init = int(new_node.knob('y_init').getValue())
+            new_node.setXYpos(x_init, y_init)
+            if isinstance(new_node, nuke.BackdropNode):
+                w_init = new_node.knob('w_init').getValue()
+                h_init = new_node.knob('h_init').getValue()
+                new_node.knob('bdwidth').setValue(w_init)
+                new_node.knob('bdheight').setValue(h_init)
+                refresh_node(n)
+
+            if 'id_rep' in n.knobs().keys():
+                n.removeKnob(n.knob('id_rep'))
+            copies[n.name()] = new_node
+        return copies
+
+    def fix_z_order(self):
+        """
+        fix the problem of z_order when a backdrop is loaded
+        """
+        orders_bd = []
+        nodes_loaded = self.data['last_loaded']
+        for n in nodes_loaded:
+            if isinstance(n, nuke.BackdropNode):
+                orders_bd.append(n.knob("z_order").getValue())
+
+        if orders_bd:
+
+            min_order = min(orders_bd)
+            siblings = self.data["siblings"]
+
+            orders_sib = []
+            for s in siblings:
+                n = nuke.toNode(s)
+                if isinstance(n, nuke.BackdropNode):
+                    orders_sib.append(n.knob("z_order").getValue())
+            if orders_sib:
+                max_order = max(orders_sib)
+                for n in nodes_loaded:
+                    if isinstance(n, nuke.BackdropNode):
+                        z_order = n.knob("z_order").getValue()
+                        n.knob("z_order").setValue(
+                            z_order + max_order - min_order + 1)
+
+    def update_nodes(self, nodes, considered_nodes, offset_y=None):
+        """ Adjust backdrop nodes dimensions and positions considering some nodes
+            sizes
+
+        Arguments:
+            nodes (list): list of nodes to update
+            considered_nodes (list) : list of nodes to consider while updating
+                                      positions and dimensions
+            offset (int) : distance between copies
+        """
+        node = self.data['node']
+
+        min_x, min_y, max_x, max_y = get_extremes(considered_nodes)
+
+        diff_x = diff_y = 0
+        contained_nodes = []  # for backdrops
+
+        if offset_y is None:
+            width_ph = node.screenWidth()
+            height_ph = node.screenHeight()
+            diff_y = max_y - min_y - height_ph
+            diff_x = max_x - min_x - width_ph
+            contained_nodes = [node]
+            min_x = node.xpos()
+            min_y = node.ypos()
+        else:
+            siblings = get_nodes_from_names(self.data['siblings'])
+            minX, _, maxX, _ = get_extremes(siblings)
+            diff_y = max_y - min_y + 20
+            diff_x = abs(max_x - min_x - maxX + minX)
+            contained_nodes = considered_nodes
+
+        if diff_y > 0 or diff_x > 0:
+            for n in nodes:
+                refresh_node(n)
+                if n != node and n not in considered_nodes:
+
+                    if not isinstance(n, nuke.BackdropNode)\
+                            or isinstance(n, nuke.BackdropNode)\
+                            and not set(contained_nodes) <= set(n.getNodes()):
+                        if offset_y is None and n.xpos() >= min_x:
+                            n.setXpos(n.xpos() + diff_x)
+
+                        if n.ypos() >= min_y:
+                            n.setYpos(n.ypos() + diff_y)
+
+                    else:
+                        width = n.screenWidth()
+                        height = n.screenHeight()
+                        n.knob("bdwidth").setValue(width + diff_x)
+                        n.knob("bdheight").setValue(height + diff_y)
+
+                    refresh_node(n)
+
+    def imprint_inits(self):
+        """
+        add initial positions and dimensions to the attributes
+        """
+        for n in nuke.allNodes():
+            refresh_node(n)
+            imprint(n, {'x_init': n.xpos(), 'y_init': n.ypos()})
+            n.knob('x_init').setVisible(False)
+            n.knob('y_init').setVisible(False)
+            width = n.screenWidth()
+            height = n.screenHeight()
+            if 'bdwidth' in n.knobs().keys():
+                imprint(n, {'w_init': width, 'h_init': height})
+                n.knob('w_init').setVisible(False)
+                n.knob('h_init').setVisible(False)
+            refresh_node(n)
+
+    def imprint_siblings(self):
+        """
+        - add siblings names to placeholder attributes (nodes loaded with it)
+        - add Id to the attributes of all the other nodes
+        """
+
+        nodes_loaded = self.data['last_loaded']
+        d = {"id_rep": str(self.data['_id'])}
+
+        for n in nodes_loaded:
+            if "builder_type" in n.knobs().keys()\
+                    and ('is_placeholder' not in n.knobs().keys()
+                         or 'is_placeholder' in n.knobs().keys()
+                         and n.knob('is_placeholder').value()):
+
+                siblings = list(set(nodes_loaded) - set([n]))
+                siblings_name = get_names_from_nodes(siblings)
+                siblings = {"siblings": siblings_name}
+                imprint(n, siblings)
+
+            elif 'builder_type' not in n.knobs().keys():
+                # save the id of representation for all imported nodes
+                imprint(n, d)
+                n.knob('id_rep').setVisible(False)
+                refresh_node(n)
+
+    def set_loaded_connections(self):
+        """
+        set inputs and outputs of loaded nodes"""
+
+        node = self.data['node']
+        input, output = get_io(self.data['last_loaded'])
+        for n in node.dependent():
+            for i in range(n.inputs()):
+                if n.input(i) == node:
+                    n.setInput(i, output)
+
+        for n in node.dependencies():
+            for i in range(node.inputs()):
+                if node.input(i) == n:
+                    input.setInput(0, n)
+
+    def set_copies_connections(self, copies):
+        """
+        set inputs and outputs of the copies
+
+        Arguments :
+            copies (dict) : with copied nodes names and their copies
+        """
+        input, output = get_io(self.data['last_loaded'])
+        siblings = get_nodes_from_names(self.data['siblings'])
+        inp, out = get_io(siblings)
+        inp_copy, out_copy = (copies[inp.name()], copies[out.name()])
+
+        for node_init in siblings:
+            if node_init != out:
+                node_copy = copies[node_init.name()]
+                for n in node_init.dependent():
+                    for i in range(n.inputs()):
+                        if n.input(i) == node_init:
+                            if n in siblings:
+                                copies[n.name()].setInput(i, node_copy)
+                            else:
+                                input.setInput(0, node_copy)
+
+                for n in node_init.dependencies():
+                    for i in range(node_init.inputs()):
+                        if node_init.input(i) == n:
+                            if node_init == inp:
+                                inp_copy.setInput(i, n)
+                            elif n in siblings:
+                                node_copy.setInput(i, copies[n.name()])
+                            else:
+                                node_copy.setInput(i, output)
+
+        inp.setInput(0, out_copy)
+
+    def move_to_placeholder_group(self, nodes_loaded):
+        """
+        opening the placeholder's group and copying loaded nodes in it.
+
+        Returns :
+            nodes_loaded (list): the new list of pasted nodes
+        """
+
+        groups_name = self.data['group_name']
+        reset_selection()
+        select_nodes(nodes_loaded)
+        if groups_name:
+            nuke.nodeCopy("%clipboard%")
+            for n in nuke.selectedNodes():
+                nuke.delete(n)
+            group = nuke.toNode(groups_name)
+            group.begin()
+            nuke.nodePaste("%clipboard%")
+            nodes_loaded = nuke.selectedNodes()
+        return nodes_loaded
+
+    def clean(self):
+        print("cleaaaaar")
+        # deselect all selected nodes
+        node = self.data['node']
+
+        # getting the latest nodes added
+        nodes_init = self.data["nodes_init"]
+        nodes_loaded = list(set(nuke.allNodes()) - set(nodes_init))
+        print(nodes_loaded)
+        if nodes_loaded:
+            self.data['delete'] = True
+        else:
+            return
+        nodes_loaded = self.move_to_placeholder_group(nodes_loaded)
+        self.data['last_loaded'] = nodes_loaded
+        refresh_nodes(nodes_loaded)
+
+        # positioning of the loaded nodes
+        min_x, min_y, _, _ = get_extremes(nodes_loaded)
+        for n in nodes_loaded:
+            xpos = (n.xpos() - min_x) + node.xpos()
+            ypos = (n.ypos() - min_y) + node.ypos()
+            n.setXYpos(xpos, ypos)
+        refresh_nodes(nodes_loaded)
+
+        self.fix_z_order()  # fix the problem of z_order for backdrops
+        self.imprint_siblings()
+
+        if self.data['nb_children'] == 0:
+            # save initial nodes postions and dimensions, update them
+            # and set inputs and outputs of loaded nodes
+
+            self.imprint_inits()
+            self.update_nodes(nuke.allNodes(), nodes_loaded)
+            self.set_loaded_connections()
+
+        elif self.data['siblings']:
+            # create copies of placeholder siblings for the new loaded nodes,
+            # set their inputs and outpus and update all nodes positions and
+            # dimensions and siblings names
+
+            siblings = get_nodes_from_names(self.data['siblings'])
+            refresh_nodes(siblings)
+            copies = self.create_sib_copies()
+            new_nodes = list(copies.values())  # copies nodes
+            self.update_nodes(new_nodes, nodes_loaded)
+            node.removeKnob(node.knob('siblings'))
+            new_nodes_name = get_names_from_nodes(new_nodes)
+            imprint(node, {'siblings': new_nodes_name})
+            self.set_copies_connections(copies)
+
+            self.update_nodes(nuke.allNodes(),
+                              new_nodes + nodes_loaded, 20)
+
+            new_siblings = get_names_from_nodes(new_nodes)
+            self.data['siblings'] = new_siblings
+
+        else:
+            # if the placeholder doesn't have siblings, the loaded
+            # nodes will be placed in a free space
+
+            xpointer, ypointer = find_free_space_to_paste_nodes(
+                nodes_loaded, direction="bottom", offset=200
+            )
+            n = nuke.createNode("NoOp")
+            reset_selection()
+            nuke.delete(n)
+            for n in nodes_loaded:
+                xpos = (n.xpos() - min_x) + xpointer
+                ypos = (n.ypos() - min_y) + ypointer
+                n.setXYpos(xpos, ypos)
+
+        self.data['nb_children'] += 1
+        reset_selection()
+        # go back to root group
+        nuke.root().begin()
+
+    def convert_to_db_filters(self, current_asset, linked_asset):
+        if self.data['builder_type'] == "context_asset":
+            return [{
+                "type": "representation",
+                "context.asset": {
+                    "$eq": current_asset, "$regex": self.data['asset']},
+                "context.subset": {"$regex": self.data['subset']},
+                "context.hierarchy": {"$regex": self.data['hierarchy']},
+                "context.representation": self.data['representation'],
+                "context.family": self.data['family'],
+            }]
+
+        elif self.data['builder_type'] == "linked_asset":
+            return [{
+                "type": "representation",
+                "context.asset": {
+                    "$eq": asset_name, "$regex": self.data['asset']},
+                "context.subset": {"$regex": self.data['subset']},
+                "context.hierarchy": {"$regex": self.data['hierarchy']},
+                "context.representation": self.data['representation'],
+                "context.family": self.data['family'],
+            } for asset_name in linked_asset]
+
+        else:
+            return [{
+                "type": "representation",
+                "context.asset": {"$regex": self.data['asset']},
+                "context.subset": {"$regex": self.data['subset']},
+                "context.hierarchy": {"$regex": self.data['hierarchy']},
+                "context.representation": self.data['representation'],
+                "context.family": self.data['family'],
+            }]
+
+    def err_message(self):
+        return (
+            "Error while trying to load a representation.\n"
+            "Either the subset wasn't published or the template is malformed."
+            "\n\n"
+            "Builder was looking for:\n{attributes}".format(
+                attributes="\n".join([
+                    "{}: {}".format(key.title(), value)
+                    for key, value in self.data.items()]
+                )
+            )
+        )

From cf2adc4e0172e1478cc64dda27a75ce31f225f2a Mon Sep 17 00:00:00 2001
From: Jakub Trllo <jakub.trllo@gmail.com>
Date: Wed, 31 Aug 2022 11:40:41 +0200
Subject: [PATCH 07/15] small tweaks of template builder lib

---
 .../hosts/nuke/api/lib_template_builder.py    | 62 ++++++++++++-------
 1 file changed, 38 insertions(+), 24 deletions(-)

diff --git a/openpype/hosts/nuke/api/lib_template_builder.py b/openpype/hosts/nuke/api/lib_template_builder.py
index b95a6edf7b5..555d942cea7 100644
--- a/openpype/hosts/nuke/api/lib_template_builder.py
+++ b/openpype/hosts/nuke/api/lib_template_builder.py
@@ -1,19 +1,32 @@
 from collections import OrderedDict
 
-from openpype.vendor.python.common import qargparse
-from openpype.tools.utils.widgets import OptionDialog
-from openpype.hosts.nuke.api.lib import imprint
+import qargparse
+
 import nuke
 
+from openpype.tools.utils.widgets import OptionDialog
+
+from .lib import imprint, get_main_window
+
 
 # To change as enum
 build_types = ["context_asset", "linked_asset", "all_assets"]
 
 
 def get_placeholder_attributes(node, enumerate=False):
-    list_atts = ['builder_type', 'family', 'representation', 'loader',
-                 'loader_args', 'order', 'asset', 'subset',
-                 'hierarchy', 'siblings', 'last_loaded']
+    list_atts = {
+        "builder_type",
+        "family",
+        "representation",
+        "loader",
+        "loader_args",
+        "order",
+        "asset",
+        "subset",
+        "hierarchy",
+        "siblings",
+        "last_loaded"
+    }
     attributes = {}
     for attr in node.knobs().keys():
         if attr in list_atts:
@@ -29,9 +42,8 @@ def get_placeholder_attributes(node, enumerate=False):
 
 
 def delete_placeholder_attributes(node):
-    '''
-    function to delete all extra placeholder attributes
-    '''
+    """Delete all extra placeholder attributes."""
+
     extra_attributes = get_placeholder_attributes(node)
     for attribute in extra_attributes.keys():
         try:
@@ -41,9 +53,8 @@ def delete_placeholder_attributes(node):
 
 
 def hide_placeholder_attributes(node):
-    '''
-    function to hide all extra placeholder attributes
-    '''
+    """Hide all extra placeholder attributes."""
+
     extra_attributes = get_placeholder_attributes(node)
     for attribute in extra_attributes.keys():
         try:
@@ -53,15 +64,14 @@ def hide_placeholder_attributes(node):
 
 
 def create_placeholder():
-
     args = placeholder_window()
-
     if not args:
-        return  # operation canceled, no locator created
+        # operation canceled, no locator created
+        return
 
     placeholder = nuke.nodes.NoOp()
-    placeholder.setName('PLACEHOLDER')
-    placeholder.knob('tile_color').setValue(4278190335)
+    placeholder.setName("PLACEHOLDER")
+    placeholder.knob("tile_color").setValue(4278190335)
 
     # custom arg parse to force empty data query
     # and still imprint them on placeholder
@@ -71,8 +81,8 @@ def create_placeholder():
         if not type(arg) == qargparse.Separator:
             options[str(arg)] = arg._data.get("items") or arg.read()
     imprint(placeholder, options)
-    imprint(placeholder, {'is_placeholder': True})
-    placeholder.knob('is_placeholder').setVisible(False)
+    imprint(placeholder, {"is_placeholder": True})
+    placeholder.knob("is_placeholder").setVisible(False)
 
 
 def update_placeholder():
@@ -101,18 +111,22 @@ def imprint_enum(placeholder, args):
     Imprint method doesn't act properly with enums.
     Replacing the functionnality with this for now
     """
-    enum_values = {str(arg): arg.read()
-                   for arg in args if arg._data.get("items")}
+
+    enum_values = {
+        str(arg): arg.read()
+        for arg in args
+        if arg._data.get("items")
+    }
     string_to_value_enum_table = {
-        build: i for i, build
-        in enumerate(build_types)}
+        build: idx
+        for idx, build in enumerate(build_types)
+    }
     attrs = {}
     for key, value in enum_values.items():
         attrs[key] = string_to_value_enum_table[value]
 
 
 def placeholder_window(options=None):
-    from openpype.hosts.nuke.api.pipeline import get_main_window
     options = options or dict()
     dialog = OptionDialog(parent=get_main_window())
     dialog.setWindowTitle("Create Placeholder")

From aae4854e12774c94a77ab6b6c6beb92dcee300bd Mon Sep 17 00:00:00 2001
From: Jakub Trllo <jakub.trllo@gmail.com>
Date: Wed, 31 Aug 2022 11:42:23 +0200
Subject: [PATCH 08/15] safer template population

---
 openpype/hosts/nuke/api/template_loader.py | 31 +++++++++++++++++++---
 1 file changed, 27 insertions(+), 4 deletions(-)

diff --git a/openpype/hosts/nuke/api/template_loader.py b/openpype/hosts/nuke/api/template_loader.py
index 861498d2e59..dbdeb921341 100644
--- a/openpype/hosts/nuke/api/template_loader.py
+++ b/openpype/hosts/nuke/api/template_loader.py
@@ -42,10 +42,33 @@ def preload(self, placeholder, loaders_by_name, last_representation):
         placeholder.data["_id"] = last_representation['_id']
 
     def populate_template(self, ignored_ids=None):
-        place_holders = self.get_template_nodes()
-        while len(place_holders) > 0:
-            super().populate_template(ignored_ids)
-            place_holders = self.get_template_nodes()
+        processed_key = "_node_processed"
+
+        processed_nodes = []
+        nodes = self.get_template_nodes()
+        while nodes:
+            # Mark nodes as processed so they're not re-executed
+            # - that can happen if processing of placeholder node fails
+            for node in nodes:
+                imprint(node, {processed_key: True})
+                processed_nodes.append(node)
+
+            super(NukeTemplateLoader, self).populate_template(ignored_ids)
+
+            # Recollect nodes to repopulate
+            nodes = []
+            for node in self.get_template_nodes():
+                # Skip already processed nodes
+                if (
+                    processed_key in node.knobs()
+                    and node.knob(processed_key).value()
+                ):
+                    continue
+                nodes.append(node)
+
+        for node in processed_nodes:
+            if processed_key in node.knobs():
+                nuke.removeKnob(node, processed_key)
 
     @staticmethod
     def get_template_nodes():

From d912431833d3f6799583658014b70e621019dd3d Mon Sep 17 00:00:00 2001
From: Jakub Trllo <jakub.trllo@gmail.com>
Date: Wed, 31 Aug 2022 11:44:18 +0200
Subject: [PATCH 09/15] tweak template loader and use new abstractions

---
 openpype/hosts/nuke/api/template_loader.py | 739 ++++++++++++---------
 1 file changed, 410 insertions(+), 329 deletions(-)

diff --git a/openpype/hosts/nuke/api/template_loader.py b/openpype/hosts/nuke/api/template_loader.py
index dbdeb921341..d4a8560c4aa 100644
--- a/openpype/hosts/nuke/api/template_loader.py
+++ b/openpype/hosts/nuke/api/template_loader.py
@@ -1,16 +1,37 @@
-from openpype.hosts.nuke.api.lib_template_builder import (
-    delete_placeholder_attributes, get_placeholder_attributes,
-    hide_placeholder_attributes)
-from openpype.lib.abstract_template_loader import (
-    AbstractPlaceholder,
-    AbstractTemplateLoader)
+import re
+import collections
+
 import nuke
-from collections import defaultdict
-from openpype.hosts.nuke.api.lib import (
-    find_free_space_to_paste_nodes, get_extremes, get_io, imprint,
-    refresh_node, refresh_nodes, reset_selection,
-    get_names_from_nodes, get_nodes_from_names, select_nodes)
-PLACEHOLDER_SET = 'PLACEHOLDERS_SET'
+
+from openpype.client import get_representations
+from openpype.pipeline import legacy_io
+from openpype.pipeline.workfile.abstract_template_loader import (
+    AbstractPlaceholder,
+    AbstractTemplateLoader,
+)
+
+from .lib import (
+    find_free_space_to_paste_nodes,
+    get_extreme_positions,
+    get_group_io_nodes,
+    imprint,
+    refresh_node,
+    refresh_nodes,
+    reset_selection,
+    get_names_from_nodes,
+    get_nodes_by_names,
+    select_nodes,
+    duplicate_node,
+    node_tempfile,
+)
+
+from .lib_template_builder import (
+    delete_placeholder_attributes,
+    get_placeholder_attributes,
+    hide_placeholder_attributes
+)
+
+PLACEHOLDER_SET = "PLACEHOLDERS_SET"
 
 
 class NukeTemplateLoader(AbstractTemplateLoader):
@@ -39,7 +60,7 @@ def import_template(self, path):
 
     def preload(self, placeholder, loaders_by_name, last_representation):
         placeholder.data["nodes_init"] = nuke.allNodes()
-        placeholder.data["_id"] = last_representation['_id']
+        placeholder.data["last_repre_id"] = str(last_representation["_id"])
 
     def populate_template(self, ignored_ids=None):
         processed_key = "_node_processed"
@@ -73,132 +94,150 @@ def populate_template(self, ignored_ids=None):
     @staticmethod
     def get_template_nodes():
         placeholders = []
-        allGroups = [nuke.thisGroup()]
-        while len(allGroups) > 0:
-            group = allGroups.pop(0)
+        all_groups = collections.deque()
+        all_groups.append(nuke.thisGroup())
+        while all_groups:
+            group = all_groups.popleft()
             for node in group.nodes():
-                if "builder_type" in node.knobs().keys() and (
-                   'is_placeholder' in node.knobs().keys()
-                        and node.knob('is_placeholder').value()):
-                    if 'empty' in node.knobs().keys()\
-                            and node.knob('empty').value():
-                        continue
-                    placeholders += [node]
                 if isinstance(node, nuke.Group):
-                    allGroups.append(node)
+                    all_groups.append(node)
+
+                node_knobs = node.knobs()
+                if (
+                    "builder_type" not in node_knobs
+                    or "is_placeholder" not in node_knobs
+                    or not node.knob("is_placeholder").value()
+                ):
+                    continue
+
+                if "empty" in node_knobs and node.knob("empty").value():
+                    continue
+
+                placeholders.append(node)
 
         return placeholders
 
     def update_missing_containers(self):
-        nodes_byId = {}
-        nodes_byId = defaultdict(lambda: [], nodes_byId)
-
-        for n in nuke.allNodes():
-            if 'id_rep' in n.knobs().keys():
-                nodes_byId[n.knob('id_rep').getValue()] += [n.name()]
-            if 'empty' in n.knobs().keys():
-                n.removeKnob(n.knob('empty'))
-                imprint(n, {"empty": False})
-        for s in nodes_byId.values():
-            n = None
-            for name in s:
-                n = nuke.toNode(name)
-                if 'builder_type' in n.knobs().keys():
+        nodes_by_id = collections.defaultdict(list)
+
+        for node in nuke.allNodes():
+            node_knobs = node.knobs().keys()
+            if "repre_id" in node_knobs:
+                repre_id = node.knob("repre_id").getValue()
+                nodes_by_id[repre_id].append(node.name())
+
+            if "empty" in node_knobs:
+                node.removeKnob(node.knob("empty"))
+                imprint(node, {"empty": False})
+
+        for node_names in nodes_by_id.values():
+            node = None
+            for node_name in node_names:
+                node_by_name = nuke.toNode(node_name)
+                if "builder_type" in node_by_name.knobs().keys():
+                    node = node_by_name
                     break
-            if n is not None and 'builder_type' in n.knobs().keys():
-
-                placeholder = nuke.nodes.NoOp()
-                placeholder.setName('PLACEHOLDER')
-                placeholder.knob('tile_color').setValue(4278190335)
-                attributes = get_placeholder_attributes(n, enumerate=True)
-                imprint(placeholder, attributes)
-                x = int(n.knob('x').getValue())
-                y = int(n.knob('y').getValue())
-                placeholder.setXYpos(x, y)
-                imprint(placeholder, {'nb_children': 1})
-                refresh_node(placeholder)
+
+            if node is None:
+                continue
+
+            placeholder = nuke.nodes.NoOp()
+            placeholder.setName("PLACEHOLDER")
+            placeholder.knob("tile_color").setValue(4278190335)
+            attributes = get_placeholder_attributes(node, enumerate=True)
+            imprint(placeholder, attributes)
+            pos_x = int(node.knob("x").getValue())
+            pos_y = int(node.knob("y").getValue())
+            placeholder.setXYpos(pos_x, pos_y)
+            imprint(placeholder, {"nb_children": 1})
+            refresh_node(placeholder)
 
         self.populate_template(self.get_loaded_containers_by_id())
 
     def get_loaded_containers_by_id(self):
-        ids = []
-        for n in nuke.allNodes():
-            if 'id_rep' in n.knobs():
-                ids.append(n.knob('id_rep').getValue())
+        repre_ids = set()
+        for node in nuke.allNodes():
+            if "repre_id" in node.knobs():
+                repre_ids.add(node.knob("repre_id").getValue())
 
         # Removes duplicates in the list
-        ids = list(set(ids))
-        return ids
-
-    def get_placeholders(self):
-        placeholders = super().get_placeholders()
-        return placeholders
+        return list(repre_ids)
 
     def delete_placeholder(self, placeholder):
-        node = placeholder.data['node']
-        lastLoaded = placeholder.data['last_loaded']
-        if not placeholder.data['delete']:
-            if 'empty' in node.knobs().keys():
-                node.removeKnob(node.knob('empty'))
-            imprint(node, {"empty": True})
-        else:
-            if lastLoaded:
-                if 'last_loaded' in node.knobs().keys():
-                    for s in node.knob('last_loaded').values():
-                        n = nuke.toNode(s)
-                        try:
-                            delete_placeholder_attributes(n)
-                        except Exception:
-                            pass
-
-                lastLoaded_names = []
-                for loadedNode in lastLoaded:
-                    lastLoaded_names.append(loadedNode.name())
-                imprint(node, {'last_loaded': lastLoaded_names})
-
-                for n in lastLoaded:
-                    refresh_node(n)
-                    refresh_node(node)
-                    if 'builder_type' not in n.knobs().keys():
-                        attributes = get_placeholder_attributes(node, True)
-                        imprint(n, attributes)
-                        imprint(n, {'is_placeholder': False})
-                        hide_placeholder_attributes(n)
-                        n.knob('is_placeholder').setVisible(False)
-                        imprint(n, {'x': node.xpos(), 'y': node.ypos()})
-                        n.knob('x').setVisible(False)
-                        n.knob('y').setVisible(False)
-            nuke.delete(node)
+        placeholder_node = placeholder.data["node"]
+        last_loaded = placeholder.data["last_loaded"]
+        if not placeholder.data["delete"]:
+            if "empty" in placeholder_node.knobs().keys():
+                placeholder_node.removeKnob(placeholder_node.knob("empty"))
+            imprint(placeholder_node, {"empty": True})
+            return
 
+        if not last_loaded:
+            nuke.delete(placeholder_node)
+            return
 
-class NukePlaceholder(AbstractPlaceholder):
-    """Concrete implementation of AbstractPlaceholder for Nuke
+        if "last_loaded" in placeholder_node.knobs().keys():
+            for node_name in placeholder_node.knob("last_loaded").values():
+                node = nuke.toNode(node_name)
+                try:
+                    delete_placeholder_attributes(node)
+                except Exception:
+                    pass
+
+        last_loaded_names = [
+            loaded_node.name()
+            for loaded_node in last_loaded
+        ]
+        imprint(placeholder_node, {"last_loaded": last_loaded_names})
+
+        for node in last_loaded:
+            refresh_node(node)
+            refresh_node(placeholder_node)
+            if "builder_type" not in node.knobs().keys():
+                attributes = get_placeholder_attributes(placeholder_node, True)
+                imprint(node, attributes)
+                imprint(node, {"is_placeholder": False})
+                hide_placeholder_attributes(node)
+                node.knob("is_placeholder").setVisible(False)
+                imprint(
+                    node,
+                    {
+                        "x": placeholder_node.xpos(),
+                        "y": placeholder_node.ypos()
+                    }
+                )
+                node.knob("x").setVisible(False)
+                node.knob("y").setVisible(False)
+        nuke.delete(placeholder_node)
 
-    """
 
-    optional_attributes = {'asset', 'subset', 'hierarchy'}
+class NukePlaceholder(AbstractPlaceholder):
+    """Concrete implementation of AbstractPlaceholder for Nuke"""
+
+    optional_keys = {"asset", "subset", "hierarchy"}
 
     def get_data(self, node):
         user_data = dict()
-        dictKnobs = node.knobs()
-        for attr in self.attributes.union(self.optional_attributes):
-            if attr in dictKnobs.keys():
-                user_data[attr] = dictKnobs[attr].getValue()
-        user_data['node'] = node
-
-        if 'nb_children' in dictKnobs.keys():
-            user_data['nb_children'] = int(dictKnobs['nb_children'].getValue())
-        else:
-            user_data['nb_children'] = 0
-        if 'siblings' in dictKnobs.keys():
-            user_data['siblings'] = dictKnobs['siblings'].values()
-        else:
-            user_data['siblings'] = []
-
-        fullName = node.fullName()
-        user_data['group_name'] = fullName.rpartition('.')[0]
-        user_data['last_loaded'] = []
-        user_data['delete'] = False
+        node_knobs = node.knobs()
+        for attr in self.required_keys.union(self.optional_keys):
+            if attr in node_knobs:
+                user_data[attr] = node_knobs[attr].getValue()
+        user_data["node"] = node
+
+        nb_children = 0
+        if "nb_children" in node_knobs:
+            nb_children = int(node_knobs["nb_children"].getValue())
+        user_data["nb_children"] = nb_children
+
+        siblings = []
+        if "siblings" in node_knobs:
+            siblings = node_knobs["siblings"].values()
+        user_data["siblings"] = siblings
+
+        node_full_name = node.fullName()
+        user_data["group_name"] = node_full_name.rpartition(".")[0]
+        user_data["last_loaded"] = []
+        user_data["delete"] = False
         self.data = user_data
 
     def parent_in_hierarchy(self, containers):
@@ -213,127 +252,137 @@ def create_sib_copies(self):
         """
 
         copies = {}
-        siblings = get_nodes_from_names(self.data['siblings'])
-        for n in siblings:
-            reset_selection()
-            n.setSelected(True)
-            nuke.nodeCopy("%clipboard%")
-            reset_selection()
-            nuke.nodePaste("%clipboard%")
-            new_node = nuke.selectedNodes()[0]
-            x_init = int(new_node.knob('x_init').getValue())
-            y_init = int(new_node.knob('y_init').getValue())
+        siblings = get_nodes_by_names(self.data["siblings"])
+        for node in siblings:
+            new_node = duplicate_node(node)
+
+            x_init = int(new_node.knob("x_init").getValue())
+            y_init = int(new_node.knob("y_init").getValue())
             new_node.setXYpos(x_init, y_init)
             if isinstance(new_node, nuke.BackdropNode):
-                w_init = new_node.knob('w_init').getValue()
-                h_init = new_node.knob('h_init').getValue()
-                new_node.knob('bdwidth').setValue(w_init)
-                new_node.knob('bdheight').setValue(h_init)
-                refresh_node(n)
-
-            if 'id_rep' in n.knobs().keys():
-                n.removeKnob(n.knob('id_rep'))
-            copies[n.name()] = new_node
+                w_init = new_node.knob("w_init").getValue()
+                h_init = new_node.knob("h_init").getValue()
+                new_node.knob("bdwidth").setValue(w_init)
+                new_node.knob("bdheight").setValue(h_init)
+                refresh_node(node)
+
+            if "repre_id" in node.knobs().keys():
+                node.removeKnob(node.knob("repre_id"))
+            copies[node.name()] = new_node
         return copies
 
     def fix_z_order(self):
-        """
-        fix the problem of z_order when a backdrop is loaded
-        """
-        orders_bd = []
-        nodes_loaded = self.data['last_loaded']
-        for n in nodes_loaded:
-            if isinstance(n, nuke.BackdropNode):
-                orders_bd.append(n.knob("z_order").getValue())
-
-        if orders_bd:
-
-            min_order = min(orders_bd)
-            siblings = self.data["siblings"]
-
-            orders_sib = []
-            for s in siblings:
-                n = nuke.toNode(s)
-                if isinstance(n, nuke.BackdropNode):
-                    orders_sib.append(n.knob("z_order").getValue())
-            if orders_sib:
-                max_order = max(orders_sib)
-                for n in nodes_loaded:
-                    if isinstance(n, nuke.BackdropNode):
-                        z_order = n.knob("z_order").getValue()
-                        n.knob("z_order").setValue(
-                            z_order + max_order - min_order + 1)
+        """Fix the problem of z_order when a backdrop is loaded."""
+
+        nodes_loaded = self.data["last_loaded"]
+        loaded_backdrops = []
+        bd_orders = set()
+        for node in nodes_loaded:
+            if isinstance(node, nuke.BackdropNode):
+                loaded_backdrops.append(node)
+                bd_orders.add(node.knob("z_order").getValue())
+
+        if not bd_orders:
+            return
+
+        sib_orders = set()
+        for node_name in self.data["siblings"]:
+            node = nuke.toNode(node_name)
+            if isinstance(node, nuke.BackdropNode):
+                sib_orders.add(node.knob("z_order").getValue())
+
+        if not sib_orders:
+            return
+
+        min_order = min(bd_orders)
+        max_order = max(sib_orders)
+        for backdrop_node in loaded_backdrops:
+            z_order = backdrop_node.knob("z_order").getValue()
+            backdrop_node.knob("z_order").setValue(
+                z_order + max_order - min_order + 1)
 
     def update_nodes(self, nodes, considered_nodes, offset_y=None):
-        """ Adjust backdrop nodes dimensions and positions considering some nodes
-            sizes
+        """Adjust backdrop nodes dimensions and positions.
 
-        Arguments:
+        Considering some nodes sizes.
+
+        Args:
             nodes (list): list of nodes to update
-            considered_nodes (list) : list of nodes to consider while updating
-                                      positions and dimensions
-            offset (int) : distance between copies
+            considered_nodes (list): list of nodes to consider while updating
+                positions and dimensions
+            offset (int): distance between copies
         """
-        node = self.data['node']
 
-        min_x, min_y, max_x, max_y = get_extremes(considered_nodes)
+        placeholder_node = self.data["node"]
+
+        min_x, min_y, max_x, max_y = get_extreme_positions(considered_nodes)
 
         diff_x = diff_y = 0
         contained_nodes = []  # for backdrops
 
         if offset_y is None:
-            width_ph = node.screenWidth()
-            height_ph = node.screenHeight()
+            width_ph = placeholder_node.screenWidth()
+            height_ph = placeholder_node.screenHeight()
             diff_y = max_y - min_y - height_ph
             diff_x = max_x - min_x - width_ph
-            contained_nodes = [node]
-            min_x = node.xpos()
-            min_y = node.ypos()
+            contained_nodes = [placeholder_node]
+            min_x = placeholder_node.xpos()
+            min_y = placeholder_node.ypos()
         else:
-            siblings = get_nodes_from_names(self.data['siblings'])
-            minX, _, maxX, _ = get_extremes(siblings)
+            siblings = get_nodes_by_names(self.data["siblings"])
+            minX, _, maxX, _ = get_extreme_positions(siblings)
             diff_y = max_y - min_y + 20
             diff_x = abs(max_x - min_x - maxX + minX)
             contained_nodes = considered_nodes
 
-        if diff_y > 0 or diff_x > 0:
-            for n in nodes:
-                refresh_node(n)
-                if n != node and n not in considered_nodes:
+        if diff_y <= 0 and diff_x <= 0:
+            return
 
-                    if not isinstance(n, nuke.BackdropNode)\
-                            or isinstance(n, nuke.BackdropNode)\
-                            and not set(contained_nodes) <= set(n.getNodes()):
-                        if offset_y is None and n.xpos() >= min_x:
-                            n.setXpos(n.xpos() + diff_x)
+        for node in nodes:
+            refresh_node(node)
 
-                        if n.ypos() >= min_y:
-                            n.setYpos(n.ypos() + diff_y)
+            if (
+                node == placeholder_node
+                or node in considered_nodes
+            ):
+                continue
 
-                    else:
-                        width = n.screenWidth()
-                        height = n.screenHeight()
-                        n.knob("bdwidth").setValue(width + diff_x)
-                        n.knob("bdheight").setValue(height + diff_y)
+            if (
+                not isinstance(node, nuke.BackdropNode)
+                or (
+                    isinstance(node, nuke.BackdropNode)
+                    and not set(contained_nodes) <= set(node.getNodes())
+                )
+            ):
+                if offset_y is None and node.xpos() >= min_x:
+                    node.setXpos(node.xpos() + diff_x)
 
-                    refresh_node(n)
+                if node.ypos() >= min_y:
+                    node.setYpos(node.ypos() + diff_y)
+
+            else:
+                width = node.screenWidth()
+                height = node.screenHeight()
+                node.knob("bdwidth").setValue(width + diff_x)
+                node.knob("bdheight").setValue(height + diff_y)
+
+            refresh_node(node)
 
     def imprint_inits(self):
-        """
-        add initial positions and dimensions to the attributes
-        """
-        for n in nuke.allNodes():
-            refresh_node(n)
-            imprint(n, {'x_init': n.xpos(), 'y_init': n.ypos()})
-            n.knob('x_init').setVisible(False)
-            n.knob('y_init').setVisible(False)
-            width = n.screenWidth()
-            height = n.screenHeight()
-            if 'bdwidth' in n.knobs().keys():
-                imprint(n, {'w_init': width, 'h_init': height})
-                n.knob('w_init').setVisible(False)
-                n.knob('h_init').setVisible(False)
-            refresh_node(n)
+        """Add initial positions and dimensions to the attributes"""
+
+        for node in nuke.allNodes():
+            refresh_node(node)
+            imprint(node, {"x_init": node.xpos(), "y_init": node.ypos()})
+            node.knob("x_init").setVisible(False)
+            node.knob("y_init").setVisible(False)
+            width = node.screenWidth()
+            height = node.screenHeight()
+            if "bdwidth" in node.knobs():
+                imprint(node, {"w_init": width, "h_init": height})
+                node.knob("w_init").setVisible(False)
+                node.knob("h_init").setVisible(False)
+            refresh_node(node)
 
     def imprint_siblings(self):
         """
@@ -341,76 +390,88 @@ def imprint_siblings(self):
         - add Id to the attributes of all the other nodes
         """
 
-        nodes_loaded = self.data['last_loaded']
-        d = {"id_rep": str(self.data['_id'])}
-
-        for n in nodes_loaded:
-            if "builder_type" in n.knobs().keys()\
-                    and ('is_placeholder' not in n.knobs().keys()
-                         or 'is_placeholder' in n.knobs().keys()
-                         and n.knob('is_placeholder').value()):
+        loaded_nodes = self.data["last_loaded"]
+        loaded_nodes_set = set(loaded_nodes)
+        data = {"repre_id": str(self.data["last_repre_id"])}
 
-                siblings = list(set(nodes_loaded) - set([n]))
+        for node in loaded_nodes:
+            node_knobs = node.knobs()
+            if "builder_type" not in node_knobs:
+                # save the id of representation for all imported nodes
+                imprint(node, data)
+                node.knob("repre_id").setVisible(False)
+                refresh_node(node)
+                continue
+
+            if (
+                "is_placeholder" not in node_knobs
+                or (
+                    "is_placeholder" in node_knobs
+                    and node.knob("is_placeholder").value()
+                )
+            ):
+                siblings = list(loaded_nodes_set - {node})
                 siblings_name = get_names_from_nodes(siblings)
                 siblings = {"siblings": siblings_name}
-                imprint(n, siblings)
-
-            elif 'builder_type' not in n.knobs().keys():
-                # save the id of representation for all imported nodes
-                imprint(n, d)
-                n.knob('id_rep').setVisible(False)
-                refresh_node(n)
+                imprint(node, siblings)
 
     def set_loaded_connections(self):
         """
         set inputs and outputs of loaded nodes"""
 
-        node = self.data['node']
-        input, output = get_io(self.data['last_loaded'])
-        for n in node.dependent():
-            for i in range(n.inputs()):
-                if n.input(i) == node:
-                    n.setInput(i, output)
+        placeholder_node = self.data["node"]
+        input_node, output_node = get_group_io_nodes(self.data["last_loaded"])
+        for node in placeholder_node.dependent():
+            for idx in range(node.inputs()):
+                if node.input(idx) == placeholder_node:
+                    node.setInput(idx, output_node)
 
-        for n in node.dependencies():
-            for i in range(node.inputs()):
-                if node.input(i) == n:
-                    input.setInput(0, n)
+        for node in placeholder_node.dependencies():
+            for idx in range(placeholder_node.inputs()):
+                if placeholder_node.input(idx) == node:
+                    input_node.setInput(0, node)
 
     def set_copies_connections(self, copies):
-        """
-        set inputs and outputs of the copies
+        """Set inputs and outputs of the copies.
 
-        Arguments :
-            copies (dict) : with copied nodes names and their copies
+        Args:
+            copies (dict): Copied nodes by their names.
         """
-        input, output = get_io(self.data['last_loaded'])
-        siblings = get_nodes_from_names(self.data['siblings'])
-        inp, out = get_io(siblings)
-        inp_copy, out_copy = (copies[inp.name()], copies[out.name()])
+
+        last_input, last_output = get_group_io_nodes(self.data["last_loaded"])
+        siblings = get_nodes_by_names(self.data["siblings"])
+        siblings_input, siblings_output = get_group_io_nodes(siblings)
+        copy_input = copies[siblings_input.name()]
+        copy_output = copies[siblings_output.name()]
 
         for node_init in siblings:
-            if node_init != out:
-                node_copy = copies[node_init.name()]
-                for n in node_init.dependent():
-                    for i in range(n.inputs()):
-                        if n.input(i) == node_init:
-                            if n in siblings:
-                                copies[n.name()].setInput(i, node_copy)
-                            else:
-                                input.setInput(0, node_copy)
-
-                for n in node_init.dependencies():
-                    for i in range(node_init.inputs()):
-                        if node_init.input(i) == n:
-                            if node_init == inp:
-                                inp_copy.setInput(i, n)
-                            elif n in siblings:
-                                node_copy.setInput(i, copies[n.name()])
-                            else:
-                                node_copy.setInput(i, output)
-
-        inp.setInput(0, out_copy)
+            if node_init == siblings_output:
+                continue
+
+            node_copy = copies[node_init.name()]
+            for node in node_init.dependent():
+                for idx in range(node.inputs()):
+                    if node.input(idx) != node_init:
+                        continue
+
+                    if node in siblings:
+                        copies[node.name()].setInput(idx, node_copy)
+                    else:
+                        last_input.setInput(0, node_copy)
+
+            for node in node_init.dependencies():
+                for idx in range(node_init.inputs()):
+                    if node_init.input(idx) != node:
+                        continue
+
+                    if node_init == siblings_input:
+                        copy_input.setInput(idx, node)
+                    elif node in siblings:
+                        node_copy.setInput(idx, copies[node.name()])
+                    else:
+                        node_copy.setInput(idx, last_output)
+
+        siblings_input.setInput(0, copy_output)
 
     def move_to_placeholder_group(self, nodes_loaded):
         """
@@ -420,48 +481,49 @@ def move_to_placeholder_group(self, nodes_loaded):
             nodes_loaded (list): the new list of pasted nodes
         """
 
-        groups_name = self.data['group_name']
+        groups_name = self.data["group_name"]
         reset_selection()
         select_nodes(nodes_loaded)
         if groups_name:
-            nuke.nodeCopy("%clipboard%")
-            for n in nuke.selectedNodes():
-                nuke.delete(n)
-            group = nuke.toNode(groups_name)
-            group.begin()
-            nuke.nodePaste("%clipboard%")
-            nodes_loaded = nuke.selectedNodes()
+            with node_tempfile() as filepath:
+                nuke.nodeCopy(filepath)
+                for node in nuke.selectedNodes():
+                    nuke.delete(node)
+                group = nuke.toNode(groups_name)
+                group.begin()
+                nuke.nodePaste(filepath)
+                nodes_loaded = nuke.selectedNodes()
         return nodes_loaded
 
     def clean(self):
-        print("cleaaaaar")
         # deselect all selected nodes
-        node = self.data['node']
+        placeholder_node = self.data["node"]
 
         # getting the latest nodes added
         nodes_init = self.data["nodes_init"]
         nodes_loaded = list(set(nuke.allNodes()) - set(nodes_init))
-        print(nodes_loaded)
-        if nodes_loaded:
-            self.data['delete'] = True
-        else:
+        self.log.debug("Loaded nodes: {}".format(nodes_loaded))
+        if not nodes_loaded:
             return
+
+        self.data["delete"] = True
+
         nodes_loaded = self.move_to_placeholder_group(nodes_loaded)
-        self.data['last_loaded'] = nodes_loaded
+        self.data["last_loaded"] = nodes_loaded
         refresh_nodes(nodes_loaded)
 
         # positioning of the loaded nodes
-        min_x, min_y, _, _ = get_extremes(nodes_loaded)
-        for n in nodes_loaded:
-            xpos = (n.xpos() - min_x) + node.xpos()
-            ypos = (n.ypos() - min_y) + node.ypos()
-            n.setXYpos(xpos, ypos)
+        min_x, min_y, _, _ = get_extreme_positions(nodes_loaded)
+        for node in nodes_loaded:
+            xpos = (node.xpos() - min_x) + placeholder_node.xpos()
+            ypos = (node.ypos() - min_y) + placeholder_node.ypos()
+            node.setXYpos(xpos, ypos)
         refresh_nodes(nodes_loaded)
 
         self.fix_z_order()  # fix the problem of z_order for backdrops
         self.imprint_siblings()
 
-        if self.data['nb_children'] == 0:
+        if self.data["nb_children"] == 0:
             # save initial nodes postions and dimensions, update them
             # and set inputs and outputs of loaded nodes
 
@@ -469,26 +531,29 @@ def clean(self):
             self.update_nodes(nuke.allNodes(), nodes_loaded)
             self.set_loaded_connections()
 
-        elif self.data['siblings']:
+        elif self.data["siblings"]:
             # create copies of placeholder siblings for the new loaded nodes,
             # set their inputs and outpus and update all nodes positions and
             # dimensions and siblings names
 
-            siblings = get_nodes_from_names(self.data['siblings'])
+            siblings = get_nodes_by_names(self.data["siblings"])
             refresh_nodes(siblings)
             copies = self.create_sib_copies()
             new_nodes = list(copies.values())  # copies nodes
             self.update_nodes(new_nodes, nodes_loaded)
-            node.removeKnob(node.knob('siblings'))
+            placeholder_node.removeKnob(placeholder_node.knob("siblings"))
             new_nodes_name = get_names_from_nodes(new_nodes)
-            imprint(node, {'siblings': new_nodes_name})
+            imprint(placeholder_node, {"siblings": new_nodes_name})
             self.set_copies_connections(copies)
 
-            self.update_nodes(nuke.allNodes(),
-                              new_nodes + nodes_loaded, 20)
+            self.update_nodes(
+                nuke.allNodes(),
+                new_nodes + nodes_loaded,
+                20
+            )
 
             new_siblings = get_names_from_nodes(new_nodes)
-            self.data['siblings'] = new_siblings
+            self.data["siblings"] = new_siblings
 
         else:
             # if the placeholder doesn't have siblings, the loaded
@@ -497,51 +562,67 @@ def clean(self):
             xpointer, ypointer = find_free_space_to_paste_nodes(
                 nodes_loaded, direction="bottom", offset=200
             )
-            n = nuke.createNode("NoOp")
+            node = nuke.createNode("NoOp")
             reset_selection()
-            nuke.delete(n)
-            for n in nodes_loaded:
-                xpos = (n.xpos() - min_x) + xpointer
-                ypos = (n.ypos() - min_y) + ypointer
-                n.setXYpos(xpos, ypos)
+            nuke.delete(node)
+            for node in nodes_loaded:
+                xpos = (node.xpos() - min_x) + xpointer
+                ypos = (node.ypos() - min_y) + ypointer
+                node.setXYpos(xpos, ypos)
 
-        self.data['nb_children'] += 1
+        self.data["nb_children"] += 1
         reset_selection()
         # go back to root group
         nuke.root().begin()
 
-    def convert_to_db_filters(self, current_asset, linked_asset):
-        if self.data['builder_type'] == "context_asset":
-            return [{
-                "type": "representation",
-                "context.asset": {
-                    "$eq": current_asset, "$regex": self.data['asset']},
-                "context.subset": {"$regex": self.data['subset']},
-                "context.hierarchy": {"$regex": self.data['hierarchy']},
-                "context.representation": self.data['representation'],
-                "context.family": self.data['family'],
-            }]
-
-        elif self.data['builder_type'] == "linked_asset":
-            return [{
-                "type": "representation",
-                "context.asset": {
-                    "$eq": asset_name, "$regex": self.data['asset']},
-                "context.subset": {"$regex": self.data['subset']},
-                "context.hierarchy": {"$regex": self.data['hierarchy']},
-                "context.representation": self.data['representation'],
-                "context.family": self.data['family'],
-            } for asset_name in linked_asset]
+    def get_representations(self, current_asset_doc, linked_asset_docs):
+        project_name = legacy_io.active_project()
+
+        builder_type = self.data["builder_type"]
+        if builder_type == "context_asset":
+            context_filters = {
+                "asset": [re.compile(self.data["asset"])],
+                "subset": [re.compile(self.data["subset"])],
+                "hierarchy": [re.compile(self.data["hierarchy"])],
+                "representations": [self.data["representation"]],
+                "family": [self.data["family"]]
+            }
+
+        elif builder_type != "linked_asset":
+            context_filters = {
+                "asset": [
+                    current_asset_doc["name"],
+                    re.compile(self.data["asset"])
+                ],
+                "subset": [re.compile(self.data["subset"])],
+                "hierarchy": [re.compile(self.data["hierarchy"])],
+                "representation": [self.data["representation"]],
+                "family": [self.data["family"]]
+            }
 
         else:
-            return [{
-                "type": "representation",
-                "context.asset": {"$regex": self.data['asset']},
-                "context.subset": {"$regex": self.data['subset']},
-                "context.hierarchy": {"$regex": self.data['hierarchy']},
-                "context.representation": self.data['representation'],
-                "context.family": self.data['family'],
-            }]
+            asset_regex = re.compile(self.data["asset"])
+            linked_asset_names = []
+            for asset_doc in linked_asset_docs:
+                asset_name = asset_doc["name"]
+                if asset_regex.match(asset_name):
+                    linked_asset_names.append(asset_name)
+
+            if not linked_asset_names:
+                return []
+
+            context_filters = {
+                "asset": linked_asset_names,
+                "subset": [re.compile(self.data["subset"])],
+                "hierarchy": [re.compile(self.data["hierarchy"])],
+                "representation": [self.data["representation"]],
+                "family": [self.data["family"]],
+            }
+
+        return list(get_representations(
+            project_name,
+            context_filters=context_filters
+        ))
 
     def err_message(self):
         return (

From ebcd34a29b84986d660c99aae0ad463b27cf7a54 Mon Sep 17 00:00:00 2001
From: Jakub Trllo <jakub.trllo@gmail.com>
Date: Wed, 31 Aug 2022 11:44:26 +0200
Subject: [PATCH 10/15] add menu options

---
 openpype/hosts/nuke/api/pipeline.py | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/openpype/hosts/nuke/api/pipeline.py b/openpype/hosts/nuke/api/pipeline.py
index c680cd91199..bac42128cc4 100644
--- a/openpype/hosts/nuke/api/pipeline.py
+++ b/openpype/hosts/nuke/api/pipeline.py
@@ -22,6 +22,10 @@
     AVALON_CONTAINER_ID,
 )
 from openpype.pipeline.workfile import BuildWorkfile
+from openpype.pipeline.workfile.build_template import (
+    build_workfile_template,
+    update_workfile_template
+)
 from openpype.tools.utils import host_tools
 
 from .command import viewer_update_and_undo_stop
@@ -36,6 +40,9 @@
     set_avalon_knob_data,
     read_avalon_data,
 )
+from .lib_template_builder import (
+    create_placeholder, update_placeholder
+)
 
 log = Logger.get_logger(__name__)
 
@@ -203,6 +210,24 @@ def _install_menu():
         lambda: BuildWorkfile().process()
     )
 
+    menu_template = menu.addMenu("Template Builder")  # creating template menu
+    menu_template.addCommand(
+        "Build Workfile from template",
+        lambda: build_workfile_template()
+    )
+    menu_template.addCommand(
+        "Update Workfile",
+        lambda: update_workfile_template()
+    )
+    menu_template.addSeparator()
+    menu_template.addCommand(
+        "Create Place Holder",
+        lambda: create_placeholder()
+    )
+    menu_template.addCommand(
+        "Update Place Holder",
+        lambda: update_placeholder()
+    )
     menu.addSeparator()
     menu.addCommand(
         "Experimental tools...",

From d5f5fedfda0c40e27c4d43591a31d7b94a5b4c79 Mon Sep 17 00:00:00 2001
From: Jakub Trllo <jakub.trllo@gmail.com>
Date: Wed, 31 Aug 2022 11:44:53 +0200
Subject: [PATCH 11/15] fix host name getter

---
 openpype/pipeline/workfile/build_template.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/openpype/pipeline/workfile/build_template.py b/openpype/pipeline/workfile/build_template.py
index e6396578c5c..3328dfbc9e3 100644
--- a/openpype/pipeline/workfile/build_template.py
+++ b/openpype/pipeline/workfile/build_template.py
@@ -1,3 +1,4 @@
+import os
 from importlib import import_module
 from openpype.lib import classes_from_module
 from openpype.host import HostBase
@@ -30,7 +31,7 @@ def build_workfile_template(*args):
         template_loader.populate_template()
 
 
-def update_workfile_template(args):
+def update_workfile_template(*args):
     template_loader = build_template_loader()
     template_loader.update_missing_containers()
 
@@ -42,7 +43,10 @@ def build_template_loader():
     if isinstance(host, HostBase):
         host_name = host.name
     else:
-        host_name = host.__name__.partition('.')[2]
+        host_name = os.environ.get("AVALON_APP")
+        if not host_name:
+            host_name = host.__name__.split(".")[-2]
+
     module_path = _module_path_format.format(host=host_name)
     module = import_module(module_path)
     if not module:

From 4ac4c672bfec28c3f886afb84dd10b55001a02dd Mon Sep 17 00:00:00 2001
From: Jakub Trllo <jakub.trllo@gmail.com>
Date: Wed, 31 Aug 2022 11:45:09 +0200
Subject: [PATCH 12/15] use 'task_names' instead of 'tasks'

---
 openpype/pipeline/workfile/abstract_template_loader.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/openpype/pipeline/workfile/abstract_template_loader.py b/openpype/pipeline/workfile/abstract_template_loader.py
index 05a98a1ddca..370dcef20aa 100644
--- a/openpype/pipeline/workfile/abstract_template_loader.py
+++ b/openpype/pipeline/workfile/abstract_template_loader.py
@@ -177,7 +177,7 @@ def template_path(self):
             build_info["profiles"],
             {
                 "task_types": task_type,
-                "tasks": task_name
+                "task_names": task_name
             }
         )
 

From 400ff1d3aedf656818fb0e92e110d560e5c17333 Mon Sep 17 00:00:00 2001
From: Jakub Trllo <jakub.trllo@gmail.com>
Date: Wed, 31 Aug 2022 11:53:26 +0200
Subject: [PATCH 13/15] added build documentation from
 https://github.com/pypeclub/OpenPype/pull/3544

---
 website/docs/artist_hosts_hiero.md            |  64 ++++++++++++++++++
 website/docs/assets/nuke_addProfile.png       | Bin 0 -> 24604 bytes
 .../assets/nuke_buildWorfileFromTemplate.png  | Bin 0 -> 29798 bytes
 website/docs/assets/nuke_buildworkfile.png    | Bin 0 -> 36149 bytes
 .../docs/assets/nuke_createPlaceHolder.png    | Bin 0 -> 30703 bytes
 .../assets/nuke_fillingExtraAttributes.png    | Bin 0 -> 30953 bytes
 website/docs/assets/nuke_placeHolderNode.png  | Bin 0 -> 4010 bytes
 website/docs/assets/nuke_placeholder.png      | Bin 0 -> 12169 bytes
 .../docs/assets/nuke_publishedinstance.png    | Bin 0 -> 20541 bytes
 .../docs/assets/nuke_updatePlaceHolder.png    | Bin 0 -> 30608 bytes
 website/docs/assets/nuke_updateWorkfile.png   | Bin 0 -> 30968 bytes
 11 files changed, 64 insertions(+)
 create mode 100644 website/docs/assets/nuke_addProfile.png
 create mode 100644 website/docs/assets/nuke_buildWorfileFromTemplate.png
 create mode 100644 website/docs/assets/nuke_buildworkfile.png
 create mode 100644 website/docs/assets/nuke_createPlaceHolder.png
 create mode 100644 website/docs/assets/nuke_fillingExtraAttributes.png
 create mode 100644 website/docs/assets/nuke_placeHolderNode.png
 create mode 100644 website/docs/assets/nuke_placeholder.png
 create mode 100644 website/docs/assets/nuke_publishedinstance.png
 create mode 100644 website/docs/assets/nuke_updatePlaceHolder.png
 create mode 100644 website/docs/assets/nuke_updateWorkfile.png

diff --git a/website/docs/artist_hosts_hiero.md b/website/docs/artist_hosts_hiero.md
index dc6f1696e7c..d14dcd1c015 100644
--- a/website/docs/artist_hosts_hiero.md
+++ b/website/docs/artist_hosts_hiero.md
@@ -202,3 +202,67 @@ This video shows a way to publish shot look as effect from Hiero to Nuke.
 ### Assembling edit from published shot versions
 
 <iframe width="512px" height="288px" src="https://www.youtube.com/embed/5Wd6X-71vbg" frameborder="0" modestbranding="1" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen="1"></iframe>
+
+
+# Nuke Build Workfile
+This is a tool of Node Graph initialisation using a pre-created template.
+
+### Add a profile
+The path to the template that will be used in the initialisation must be added as a profile on Project Settings.
+
+![Create menu](assets/nuke_addProfile.png)
+
+### Create Place Holder
+
+![Create menu](assets/nuke_createPlaceHolder.png)
+
+This tool creates a Place Holder, which is a node that will be replaced by published instances.
+
+![Create menu](assets/nuke_placeHolderNode.png)
+#### Result
+- Create a red node called `PLACEHOLDER` which can be manipulated as wanted by using it in Node Graph.
+
+![Create menu](assets/nuke_placeholder.png)
+
+:::note
+All published instances that will replace the place holder must contain unique input and output nodes in case they will not be imported as a single node. 
+:::
+
+![Create menu](assets/nuke_publishedinstance.png)
+
+
+The informations about these objects are given by the user by filling the extra attributes of the Place Holder
+
+![Create menu](assets/nuke_fillingExtraAttributes.png)
+
+
+
+### Update Place Holder
+This tool alows the user to change the information provided in the extra attributes of the selected Place Holder.
+
+![Create menu](assets/nuke_updatePlaceHolder.png)
+
+
+
+### Build Workfile from template
+This tool imports the template used and replaces the existed PlaceHolders with the corresponding published objects (which can contain Place Holders too). In case there is no published items with the description given, the place holder will remain in the node graph.
+
+![Create menu](assets/nuke_buildWorfileFromTemplate.png)
+
+#### Result
+- Replace `PLACEHOLDER` node in the template with the published instance corresponding to the informations provided in extra attributes of the Place Holder
+
+![Create menu](assets/nuke_buildworkfile.png)
+
+:::note
+In case the instance that will replace the Place holder **A** contains another Place Holder **B** that points to many published elements, all the nodes that were imported with **A** except **B** will be duplicated for each element that will replace **B**
+:::
+
+### Update Workfile
+This tool can be used to check if some instances were published after the last build, so they will be imported.
+
+![Create menu](assets/nuke_updateWorkfile.png)
+
+:::note
+Imported instances must not be deleted because they contain extra attributes that will be used to update the workfile since the place holder is been deleted.
+:::
\ No newline at end of file
diff --git a/website/docs/assets/nuke_addProfile.png b/website/docs/assets/nuke_addProfile.png
new file mode 100644
index 0000000000000000000000000000000000000000..37578df7f52ee4b61e3ba0725d999fc4940288ea
GIT binary patch
literal 24604
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

literal 0
HcmV?d00001

diff --git a/website/docs/assets/nuke_buildWorfileFromTemplate.png b/website/docs/assets/nuke_buildWorfileFromTemplate.png
new file mode 100644
index 0000000000000000000000000000000000000000..77d2de2ff85841cf7910dc714c60e531002b2344
GIT binary patch
literal 29798
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

literal 0
HcmV?d00001

diff --git a/website/docs/assets/nuke_buildworkfile.png b/website/docs/assets/nuke_buildworkfile.png
new file mode 100644
index 0000000000000000000000000000000000000000..e3d8d07f7c959324c1224f88079084813ad7c101
GIT binary patch
literal 36149
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
DVlFeL

literal 0
HcmV?d00001

diff --git a/website/docs/assets/nuke_createPlaceHolder.png b/website/docs/assets/nuke_createPlaceHolder.png
new file mode 100644
index 0000000000000000000000000000000000000000..93fb4de9d01adc65bff170cdaaeaa576074a956f
GIT binary patch
literal 30703
zcma%?byQYeyY3OByF@w#Y3Y>i?vn2A?hZjhLb_8a>F(|nM7p~>&-DHFclO@roIS?*
z!{rz_eAasAyzlG&UDsShD9DK;Bj6!GKtLc%N{A>yKtR5SfOr)J2MK=ShcH$T0YQdp
zAuOz5VPpgWVZL0JYNmiaT7T?ix`Twz&SlM<mhLphC5?i?&SmzRf;K$&YhL(Q5d{GO
zENBryQNh>PDzCAzne<;{i!z+Nd{o_;Df8lA{N7wx_>fZ6q+YRie^n17K*7fRf##Lz
zD-s%RrscuK@Z;k($$mO0I(;at4%qxhC``kG+-{}L7dCd{SG!rha@Seft1t9$f+N8K
z5G04?$0$)><QHdyni<*NF}bRDySe#XcPPAM>pXd@5BHqBfrALVjUhg*D16Biex9Xy
z*>%UE+R(9i1(EUgoZq?QWg;NwOc5fy;V>HKsXp}OwO-dT<p47|c}i8eR2BRg>8psd
z07rv>fR{W|-&lxrf36RZRsQf~Zp7Q=j?hxgHjv@4q$Cg&$JYS@D8WZ{0jn=g6wJz)
zFMD5%45!z-g@iEoq!2!TXLg=ms@fZiV49R^GDct_A*G8e5k-}iiJJZTEe0jh6oyH7
zJ!K>q!qiyiv$noWLJNBa?iTTz6495PFwEx^^HV>({@A?c;Lvvy^k2U0{XAppG-w_^
z^c4$*X3oP*7QD>gB{Ah)%CaRGzm!LkHl6xnl$&dqi@6&b5piblN;1NLX|if8=lM*g
zd!Q1IQb$uRppA-~os!SNt!lJgbNA~DR%+!Zi&Z}p_(zTiZ5i+IM?d;R65?3Ov{lCT
zGy%S^xa-8YZ!vp}2cD{NUhE&*FOtzpOD~BL$?#tJYc2e~qlAGdMDjl};^Apeb9Jqg
zKRU03>oC9c8;{|F_wVZ~_d9I=I4K74{tg0Z@z#zp8^J#k_SLE<K{8g>V@3aY)+_{4
zEClof1e84lDx5#uKyy(9bmeg-jjI3@fj^=>6j4XBSJ!KQl58ka5=fDNw`j0m{a@w#
zUouEL3J|?NR4PDH@uyLM#S_3Ze`S-6c<ImgVSa1;Z8F5P4hFsdyGls*jyLnKyjB~e
zi&*SmdHLhp!xD91x<e7KB0l=RFr);Kz`Z_U#%mfj?O|wEB*E+PZ_v@jbS;sEp(er3
z4{(ls#oXx|i|i=CFaQO;3c(47Ac+1RCae=(0WvyZBO5Cr06_u%y8v4;v`aP-tG}2%
z25W$FHg1i-+62skAS@>$w;&EDYLg)9F0@ZJF_M4eDn<iRXb1KOB(aY74KRHj$RAKB
zJ7n$gWdeCt8IoacI*=Mrw>zLt(ME!xPv7#sid@CjfE@2cJjG~%tmwo)eN!6XwhDC%
z#}_cZig*jt79@KL_4xYJD#tvGUnk0I!4JW~3TQB0Lhj)ZaU{$l0UD$<Jt&hTa^Z;U
z0q&%}5@@-?U9oT!FcHFE(V)JD8k2HKyiy8IAjOtIp7LiUwUL0G3PK_g9(c<fGD3nl
zfKU}`P3kr9$}vzo`(rHr<|_}O<ygiVobxb9Qc5hy5TP{%3M}Ma0S5)hgxBwcOD6c<
zLoJ}12y!V9sX!10f6f-3FerY_4U;IerSMJ#dRD+i0cr-0O|U5EO))YzR7MDQj*|k%
z4C0j_)C7q$ZWAQ3aNfjQXQ)(vTfz7V9do?Y0Mi`U33BsSo{;oH(i4d0(4NR;LRJ%A
zyX2Sf_mDn8?AcipZ!Tf)5ux6O#(jY4>wKO3T3MfF1jVUC`vd9-Dq@#VB^(`$beB>k
z5*;jU*H9%*=_{*F?n)wSIQ;IyN@#27KONVV<cCPjUB{JFhfoil&-Q2pNMMicu?P_R
zyCv-r(qYUx9@YprQTZTnx_VF1Z{KPosCTH^(`%!0bjjMYEFxqDjCbv<+TKDgqM~*Q
zpQ^fJ5e4<HeLAJ!g<c6VTMIkoeSGZ;!`RKZrhZEEi1G~K7ueo~e~RjkxE$(+_5m`a
zgX|OzBM`bXG@G;mtp)DYYeLdMH1Q8;%y3-6WJ1t6(Gx<uWS8h-aLU2ZU3dmz_96`=
z+UP`ZcEQAC5S=2yWMpWQ;hZ95WY9lR<01ycHpvjsLc$G2;MX~G2^7B+3#SXPlBS~D
zgrkVy<l;NLV)AbYZU}rU7)9ELUXSjEeuGvW9u^MWquj&1{%)OZoqqkJA>kSJ&w$&A
z+b_3~!Ex^?-be~4#i~#s4~A?CBanr}8A`w?!BEGjh<ztzi))gA%4eD)un4IU<tEdK
zwUuDZXJm#L6bU6Gk7F8mZOqJ!oDwl2woQ&o78&<$K*<=o3Pv-AH-h(zwXiG6IH_0c
z(}3V6_9ompw<9E1M7r3rIG+du2~OO29PNPWCeJ4KIjtkq9b)4b$oCWok!0EL-?L-E
zeujPLk0BP3^Y*=F0+|$aLBNzCZg!O7_Is;@k3;ZVpU*|^av>Eui$ADf(V!#-O9`9g
zIx5^13(XkJFsX2T$5V~rj<6J~&Er<wQN&TeQ4}slpK+Oyogtk0I747bbcIzLr6pLF
zyPU_D)0XF(`<(p>FQP9u!u$;@Pb%VQ*c+k999(nF8Zs^HvWQ>8_&K8!YUVsOEDOj-
zA=kpNxx$liyBf}9+{hUbV}dx@s5#OT1-mrPgiYv6QMTf4xn2`byVAP`mv22GePDf1
zpCDTObw%0*+Qr(1EArZN{j&XxAYdXo4J6*ughF*kqW6RwQZQA$6^+6ZL(Gd|>eJA-
zW{Q5R9!1rMiWv^yD`K$zVKCWQ<_#sWaxhmQb+3xS{s$^1`ec@5r)0$B$Yk1Nt7P~Q
zify9pSKCb6xZCecu`ga-KvxI+?mE<u(;!F+E->W!>8(Lp%BhA&8>8B3X?RuHr-4{X
z{|o*g^s4XPDCj5pyoNP~D=|A_S`2+xlKybz>^#gNwKaYn=AR(K4ip3NpBwX%haV52
z4vh|(ud!W`o1>pXpCXp}NbNNU;Kh3#)^8oUIN{Tg<j{+vr#o@iN9@@-#nWlW5O-n_
z`$SjQ?FSp2wNZ{C%HO&Xs7L(hW?R#8Fmw3W@M;lzk!|tyF~c#REm3{ASH!1YpB|sy
zryiRP1Kv0CUDa!iXOQlSyiklW>YY|=S7(Lpv@KA}*e4-3{jeM4XJ@xq-jsZ(df|+n
z-!`mHzudm@hHb;=_iqnu4{eXg>Kb3eIhDRuzjeEnzeRqugB0mN3x7=$5J@6{_D%wQ
z6aM>an?TaebbV=iN_VtJIKg0hAv)5OSiymJSQt`pTftggl0vjO@e|T-DUdL2(J0|r
zg2jVHyQI7D)-Vl%PSfDfnM5$+z6{9bWA;Wci@eK)QH(K{s-fh@SPJLsAu;4+N=lXi
zn}Z%1E*_EC<GD_4$aBW~GmBG%fP9%u4wD!o3qucW1!FD(zh{LaJosIlBr67^WH^Q7
zSMrjtHIiZ!h+jWipbn;C2_TU7#(tH=&F57@-+No~bw<FF(k0eY0!Okt-(iYyif)g|
zBIPplGT`z{jc6#4`V<-Ri?1PrNL9R=UrMFfNk7FA4jvoxJAUB$nl7*`K1Pc3ReAt>
z)AQWI5w<amSAvK#CjR8>&Vc*?<AB{@)<D{(4Z>HUYz68?EN;<2GI7O%U4<xWH7xPZ
zJiRd(G7-5HN>kL031mY|QfvirQ&M}mmx`h9jS?h>e1;%RQqDuq<EjMjx&!q)s}(dG
zG<WGR=+5aZ>6+*$>DcMU=rZYE(HYSFq${D*q=VIv(xB16(@51EtJ2nQ9AWNrOfv~J
z2{1`9Ni@kYi8o2Z?v*k&G21f1Hb^v7HJmkOGp^Nl(RVSrGD0@^Vk&DoYD};Hu}f=A
zYkXnEGwBNQ0PW!I0mT8`fzdCVQmfJ|O+Teq*wO_GTqS`j@ZSkkzkC;G%Ue*qQSd32
zvBYAFNR=EdA}UN$J}4QTk+USeLb!stVz_#BMeP!DpLze~J`K53Oy9_8!vxbH-c;Fi
z+LXnh+Q7-+!W7Xk(pcJfSbx}zXGCr6SI4ieU%kJ^T@!86Z9X5N|H1f!U*}RMTSw@M
z#1oPcpE1TTSl&_IX**y$csy`CNYp_zmf4Xxmf7!{+?w8+*&5Os>ErK{>=XDz^uYVz
zbX|X_H}5w|f|n^)a5g1k&diFP$}pN>D(;kbHz{QCvxZd*<p`}TN=@9V&}Hi0qPqru
z;o}125tq%E>%_X=fK?L5N~cq&aHj#MVyCzE8jhR}?vAe=MI0#{4tF>^91`+U^CI$s
zHX!@a`jMllqs0k^3GBGq?5!QhI3v;z(;w5<)6diK(nHhL(#O)5(`ClY$FRn%$H>N%
z#yrQ~j5(#_aEWu-IgL5;ZF%?J#a+PStadplHo7;8G;TJ`G$J+7HKsSTG$w0LYEx@-
zX@@loHS9NPHI6wUJAQFkTJ!9v?WrBQO0kN>@08u#UVXD^YESE6<&@_5$D!Hj!Aabn
z%JF1}Z@?$LIjK3NIr4$*=KT%D4Z#h|F~?$7W4${XF9i__5qAt$408-a3~mfm43#{I
zJeE9yJjys}reh{1uMO`<USZx1-f3P$UPceTQ|r^i({=aX?sp#V+_Bwj-DTa6+?PC{
z+{r!S-K*Ur-G|-r-T%0Ixre#;dz_r{ZR@N(4Lk&)u9Kfm-oCzj>pkS%<h|`3?XBxA
z)27kp<9+A-&U@Co=$88q=C=H7Y0Yb(ex$zdCgX&WKPhWyyq~eNVxVHwZs?@rWRSRr
zxI3#at6#56Z`AK|d*ln*3)^$^W6Z7IY5UF!8U&>Kt5pAN{{;Wf{+a#-{?+~!0>uJ>
z0)+xO0x1GP0?h&y9jXCokkycpkUt>xpr7FkUzY@W2Vw+D1#$;&2g(I52a*P!1>y$6
zLQ6yAzy9;u3%UYf86zFroAOreG;LLnJ84V|Cz}O~E1xFprI2HB)FP_M>b>4eDNoGS
zc;7fav8-Ii3H9BBOFbb8($8oyvB|N4v30R2v3are3gHSZ6TUfQIgUAEIVd^4If^;W
zLKi}eA$$l=SYimu!5+cA!Pvnr!J{D=!9F3~!I&Y{!I2@fA!)(Q!LT6}h%1=BWRGIE
zk*CDyrEqEC+2IM{-@|jlzl1kSWJ^R1@Wnxq^^4+(EQsEVh>0AB^I~{VS23JRW4#+9
z8=|72{!aIu(UN|j29E@fK9y37#8bOQw??N%-dW@_dbefw^KR2_(p#-48cLErG-YfS
ztZM8FG^5YGpH0HCKPN_JU>#uLV>Oeqlh?hkqq&x~7EdP`qh=suU@WJ%WjLlgrXnKE
zB+F#<m1)s!(P@$QR(UMH4ZNj28(;r}!3m!l92;C3To{}Z93NaE(jZbLlG&pe!5zUK
z!55(z(ToxEPFLDHZa%3;+EL=O#E`V5w3bAZ#BpNOSDAQT5=|Npq4UyB(LwyLEMLbd
z<|sIDKLmBHnn*CKybVSA6iP)N9M>^mN?<zkK?}Dv3cXLK4|0QT1977QOYpO_l!}z1
zl>Cs?kSvV^jU0{geymEOO0`PNjB1HwiARaLl3xC^)J6eUfoK7C!Bu`)!BRoW)Y+8g
zR9Jyk{-=De0`dG4DgGp1@+VoCucX7LLlQ&9LvIJ?huw#R2PuX(2MOZ2NS)M76->2F
z)l4<F^G1^B#FBK>B-C`(#D6LMQe~H5mve2m{%QTi`o|&kZ>y^5DtVJRV~(v@$5KZ~
zM`p)V$8ARj$7e?-M_k9S&F`C9o1R-@TZNmML#>H_62u3phY$yb2doCuhEL*9V`CCm
z81?A%$X6&=sQ4-Q$zNoiTOS#rYap8gD+5~s%L8iz!-T?xa)rvfm_jfSG7!FD+0yW;
zXei$1R^~}4Z7L?Hs3@~4Ix8*ycw3g7<1X=2>!<2Zc?TH>F$c-Bp!FmSwFqHJ6-miK
zfkC;!Pt@AfvU}M|AyXCwL<Q&t)L@z1r1%pjhYmqqeIB|WsvBA!S{o`Ef=!@Jkf*(Q
zA44Ng%Sh9%{#+2KxTb)vs;I`K@>BgxH9|#Fom#0x%|dlgy|JA6$GP@a{7@Z@Vxo9r
z&i8W5!u?#lV!VpfGEbFS!CGY(iL1K(!2R$0p?FGPWMw5}1!eU{<wifz3)y68#c3sK
z{m^P(K(6Jg#j(tqb)6a9f81x@U)WFDKi((ZAKZuD-`X#l^_s0H882r1QSrmh3XRR3
zEuWQ@jgEDZHIVHq>p9yHtDME9x%PDOq{c6ex%podmgkmIR+bi8mQ7Zn=7r`&6QvW@
zzYeEc%DH~r30*|KnaDMVw;Z(Cv;1x8VI^u_U`06feU>|qt=L7{O4mx&N*TXQcKXe<
z+9dm=>o1g<=((|3zVfB~rLvFTKjyWTK1n`QplFH<h^vXK_p9}PqEey~F48EH+bJD0
z$&k#T;y!Wq-CK8Vbir*(ZF<vm+?3N)(iGA(+ho&(<6^fzc2K_mJkh=DurIk=a*%S+
zxEHcpuuC}eW6El}x!6tFPS;NLBn)VfvYwEh&WiSmEWZf9YP&+aR=bX$!b{S#(G%N~
z9t<axEfh5rJrpgJd=OlabC6+>XOLVFEsQeEI1(S;BO3)i!rLMIef$OdW40)^5hh++
z_o2$U)26lbHQMeIvG?SuaSd^)agA|lip7fG72_1k6vHNCCkgXJ^J2vQ^cfoo8hIE&
z8HpSDZMbjnZa8k3ZuoA%Z+L8|Ze&q%ViI9mVA^2fV-m-k$J50dQOZ)bQW{Y@QC7&X
z%S;xg7k({FEmSMiEsQHnDSTJ>rEsZmPR2}DU8X%PXM}T<Vw82Xbfjg3Y?OI4IyHm!
zfC--^jm68P&LWy=huJLID(z45L$Y|9SsF11zsa&0pY8L&W7!=eVheOuNNGr0NKi<-
zXrO4DXn|;2@4HCJNYTicH#|vnNnJ@pNrg$}NjXUmbdmJ<bmN-Q0EfyoY&CMq8cOp^
zYs#$49!u9t9m|Hww8|K?mg+n$uO=<~Q+u`MwR#su7M8e2xR>t3UGiLFu3Qene*O5>
zZhgw`&F;t!!!E}z$Uev(!d}as!QRcz!p>;Z_9xe-(Wb!0#pcN7$p+IJ(fWt=_`L4V
zj5;6NhglShevAIf>ALFLi|WYw;rbsnJVqSG947VFH?u?*;|AlEb9MFAD^|pIdir`M
zD+YeOz6;MGPaLo{P~U=Tg35z}g#CrTb_<4Sg)xMohiQhXqwo_rM0-b{M~6l;M3Y8a
zM28XL6M7NYagOnnb3Hrca>DbJaHjBhaEo%8@Fa5Aaw2mtIcPcFuSYp=+naJ8aQ@+e
z<)q@m;hy8la%$Ut?C_ZN7!KJKa#M6=ayqk*a2|A|cCm24b#C0K+B|nbwM3mG+WY9~
zMR4=sCjXdv*~w6TJoD@$qSx}t-GP(~w$rSAt?QN37dLwQGKV8)LWc||pN*z1F~_{-
zl7^IKk4DkvttQom42R}*_Kmvr>u$mmhSl<2+x_EXqP@%`-R<RV-`_q9PX!O5uwy|h
z!kyhc-Am+M<imL*d7~Ru{Wbm4F|zXMRP9B%MI}XHX8C4yW{qaeJJ{p6<La6Gt#G=5
zx<k6#y1Kedx*oc!x@N6nE!!<>t-fB$Eut;6t!1q@o>ZPVo^xJqUMr`%r_ZZUcN5-k
z`I`8m`DC(u_}=jqdBb=g-_kvJU-aIe-_hKr-g@4O-EH5i-MijK-;Ujt-#?!jonc-~
zUshiro=Tt5Ui0kD?YR9pNm-d|-ED30+PX<SbXmc#<#4mxTCVmIzvi27u5<g7wa>U#
zadfgeez~%vx9+##H{mz*67pgSLF!MGji-;hiXV%n@OA=i0^gox)uLlZK!rp;+dEq_
zTU_5+Ul&ll`l`mN_i7l)`*3mz?g0{Wc?EX`H3d-x@d=5EpzPZ0b{Tfcppt%P(@<uX
z6q6CxZPjhM3wkG>WIQ_bQv5?K0*rKAZM?-d-fZsdw>GD)aBL#XA{;$j6s*R65}E@k
zv1_rgq*kOnIfpq)IrlkULfyjE!nDHUp}L4ZSofqzC>u!e$Sf#MsF5hcs6XI&h}ns*
zSr45!xzic7sTau>sd!0S-nTHd@Ov{qdfb}6W)k8QBJW}#dvB=M^E3QcI4ycLx*hqm
zSe3XGpqVByF|lniHSx^I7W6xcb0;kB&x}%BL(D^rfM__sQ(Jzp<la}EQDe2L5vj4Q
zadLKdc6By!R=>R3?Vrptnqcx~8e&Rf@-q5rgwmfL-H644c|mE)lSHpZ^NZvcJv$9M
ze;s=r)wSuN(%}uKP`Z7(Sh|n4y|$RPrndN^`J(rtCogj*hc5Lp*)k&^*RzDT)8p3d
z!<pTN8wMwaF-8<7FXlQ10wx|N3`QY_?mO#uRg_Yc`&3PoV(+%8e!aV<T$c0Byd{rF
zr^w7t+x&_Zmyo6sKa=6iVnJ=el9E7|TAFc~K#-Xpubtt|cV~L8bS{R#B+4qv(@Xu1
z_Z?LMcLC3q>5$TpDGjwMohsGrJ2o;lj#~Cwsw>z1i<vBo1l9=FR@S+i-I~Cf(3-ZI
zW(!)2_M4wa@e5`(<4$^uZMi<O4=^{QhhAwYQ(V(q)1%W*Q}NT%Q=g{8rilwG%(9tp
zSyWi8S(0&6aItZ9a5r!xaaUL(QgTzcQy5a>Qtnc&QhZXBQz}^MZ>Fz@k2#i3s`)Km
z;-2Uq!fyB%+A~AOFb0&ytHu!qhlain?T<AjUhy8Nvs<x~|M~ETg@^A!;d<{d=MeTc
zv12UPBiDB>SFTPjO)gcgC9Zl$-Ob0Lf^DfSydBRi%59=Cn?b@cpM(c$)Ohjn=@F+9
z#PQ+bAHxU3X+vHaHyl|kdZa64EBt<XzM8&f&tD$R?$V$WAO|74A;$x61J?n?|A3A`
z;3MoHLgUVM>9`Zv3<!jxLeb{^;G};<;vIXFJtX)ih!nOO^%ue6NB5o8A3=XY(nAnJ
zl0sgE?1f;5>>${^;bUB+F{J%U%}jevD@D((>s+@hHmNijBTN^TkAh2l&XwT3yPLxj
z)`vn*wD7(VOZp8ywih-P_BX70oEU6=`ejZTK01&2-O9PO{BCj7dSW7;7I*gzxGlJi
z@JaL&@<H)vLN2Gx`#3Xk--OB}iEqgXw@LX)2}#aLG6}qlzqyB8Rj!Ng6kqc8#A%~5
z`8^+YhbE7V()+PuG>MIfhPl<eN>Ao5f7bV}ZFu+3M)MHFaO&E(oZS{|IQ7p-|19VN
zRbyM=P|#aYR*+X9FV+4{ap<iHrAeDfiHV7cj!FHHZqgI=4xKt(JvA!BICTXr@%t=l
zKfQqO+3M!%hb7@<oGOz_Oj>98hIwC=s8ubr0I^k6<yJL2R-L<G7q6Eol{prFF6LI4
zRbf-PD&Ci7`>B<?P`psYUC>n1^y6ObO6qC_?-(x;?;-UxH83@vO_(jlvTX*#>Ye2m
zOCPIg%VDeWIk{hL<xno(F8eNWE{ZN8E~75wF7o^A`<e$P`=bX?2RCzbGdFYNGwpUA
ztZ*E=?Cz`->;zVve?Cl}RvA3JzJX7~M4=*+Bj9z|?>UX2qGHF>#5cjC$AiMJ#yh}+
z#WTa7lV6wnoWaVw=fiwud^dO;?<QByPMZ2UttM4FZ9PpYl{=L(RhQK!Yn`vabLdQE
zrX*LHzNkFI({+E&V!@(!x~`~O4kz7~+vn<XV;X<7bhK(TX>?>eeH(N1TN*K&pABif
zL~U~Y>pJ7wnOdYeUh}&}DQlCO)VllnW4kgNLh}r(rx`Kxcxx7mKYx;bt4*^{u>ZL(
z$(UgHZ98?mlKETr58nje-18pN8PZ17UWz}<!}v@FF7L(a$Tt+nFqJS5aRqT#apC^0
z=(}h;GtIG~%vx@INA{D$!D{t!KCXwn_*Uhd={lB{3w<-Eo!YU2u@xO{o$oqwI!roY
z&1258&SmLPJGbK&8BRRk+{-T)@0{Gm%QD2XaJcO3mv6l9@AfaAc6P@6jwxNFT|POp
zG&?opH&?jw?>$cnA1LlS>_+T!%}g(|ELTq<dO~~FdVTba_Zs%{@;tfnZSZd=ap=4h
z>IgYRq+&qQarZW;j%k%I8E<3!UeQp|YL|PW%D>1sU-9Q;HtUz(@0B_JKQA8syd*68
zTxiS+AM8C>7dp;6u0@w4Q*o9UD0S$X=bg@$dt-uv1^cq^NSr>{Ra)2^pZ;DwkzV}9
z%Fw7Q)uQ5A@-TH-5c3WG8}7GJMp(VEcJKZ3-L0+RKf*1-TEfS|gTmOtIHAX=K5as6
zWL~}ZQn!g+v}Njj6{XrC6;l=adRL994z<Vo1wRngIl?Tuhq~pu9lFKC#*yWb+lf14
zK8THo2Z|$zrHc27=|%-Ab}F_io=jd&E=)@2A?ERyPnMTxJGH&>JG!kswz?@Vi;3$q
z?knx@>i^ug&~F>v+8Eu$;JI|`*>RPAKvfZ=tJn5?1M`BMfv?LkWjC|j;B2(k7vnJI
zP<!@qLvmwl1E<fdzg@0U?!64BOpgpf1}6s-+u0fAS>cH6K^i&->e69@$HVpl{UQC}
zr|o(nTf&A}PpijY2Y-tH<krjD!Y++9``lk&{b8h9lU$SRmV6mZA1oZ49Ncm1AiO6G
z;_-E>I%ZwQZLIb-+bLhwd1`KRyIJ|@;C6dFwbZT*sqCrTru<MOCxa|cFZ-17CjD2|
zb=p{}Z8}kkZsu~Mc)OXs-AU`A7uAVQ^Nk@)DtanYDtz)_1{a%?kLecQdfTo~{KLot
z^v$PZ`9(jL$dtrnwk+ff`t*-1US8Kr1io^fW2Ov_#{=4Pi<gV{P(x55uqdeOL<xMm
zJ|AvYAB3;NzN6|87xI>Ra^9Yvb(e|r#?%md@DF)AuTKu-ZFziPWVK@@=FH+>VdiIQ
zZ}QjCr_-Ppp(D`U)k@aAy-eQvxo%X{4<9p3e8ca1dAoyoOr<5?l4;D#b!NOdcu_Q=
zyjDahpCXUSYvbqnu-7cwm3x@GWH_>Z*1Oyb8;L*8nQ6g$;hywd`uzK}dh4CJr2C+8
zM5D8PiI0WjUN^Iartfb9F5gD)Mn4bVyE&)K9qw_TEVGYxp1x0a2ROSpUl~hvMcO#e
z*B>Jv7~5L&TUGq_&Ky^U@4t03W>s|1=F*zd=Fo<zajO@q^R?%;DS2$&(_E<@{h+N#
z(iN@{)lF+d@zA-vKRhUz%UV%bDQ<D_iN7v99-ZYF{&D(!_xo?ldCN1)x&4v-x%xx9
z*%i+gSwFA!quoD=Y%{5wsk2%$3zN0WwXjzF%MR_+9y<>VJ31H55pGr|@F!c#JZ<vs
zdUwxL54|^j{BS-W?$91{c7=DsyolR;jbDnNCohb)`{Ri#{JdMEb-wA=e~S6UsMp@`
zZ0z%Z`4oRvv??!}#m&F;aCyaYRNZG*G5)~M;Y0NDc#XIgxro!x7@_yQ9mz-Y9>E9u
z$?}YC-D+?yvjVmK`LXXo_T^JYeW0CL+tSnZ9nT-P+LO!`mUa%G_OquW7z1J7ZVPgc
zJkyQ+z6;sS!k)q_(-G6X?T+n@(Ia9Zei`53XU@mGhyKMFVtx<5{U@Ybk5#k&@x3fP
z-$`GK=kvS7iyvEaM|#9{8g(jli}lQPa<)tJo)2lapVsP!Pi9uG+Qt3a?}MJmFZ$Qy
zr?OJ{)n8iX#cWvWZ0a}aY3mv77@tC3q#kRZ@h|EhPgYlY2`kC#j2ba(m77>9FPzPG
zR=nOd2iz8MeMI$_hJj#LhM1XwBq4%?=zZ{erJI~#&Pu#51>O*Wx0ld#f`CB8`1|M8
z)RONb_#vLBiiWd+i?g|%BLoE8oYROjotnM0%;3l?2#g<4!E3VXGY}9Y5RxK-D((x1
z8Sok^;!V%;(^bRKB4~uKa73aI8nP#UI3RN8_0TcAos+a>7P6Ia_FiX}ggfTQR`0<d
z<$T`I#*8mU7mw%@j4$Sl_*`r}FJk{1ThmxP;P^%Qo72>u?Sk4X(G@*+ZkK%(AJv_7
z?v+m~TsGgxNJs?8g3*MuB3;WS#8g#PKk>_MZEYPN9}_SHqfM~~!(Q%A=E-IiDi_H)
zl%feqRO|OC3&4>EcM1Rd!V25ovVqI%ZZ9Ap;O*Vg>6j-TQ&(TV(&}{+#Id)xcXwDl
z&dtqDgY{YZ8v`MqcSBRtedlQI#jdf5NkK}=?^>(5>ys5dW#w)}8934y?H(w3db?s3
znj=|4JUl$2#YADdLYb8FCAXE<t6!hi*4Ch*p&45*F&1o+f(8c${6_}{2EKp){`~Zi
z*WJ<)jCQ^&#@lXOYsKNP-gCUvOq)0~{EhKsv9Y?mTy7a317oVu$!s$@E$zqbe*5!P
z#ZA7La43?btnAZvnjPBB{O{ixd_LUo-w*u$-B?rOJYQ)b|M3cI29nT!tNrQ7uHJS@
zh*&I|;CF#E4tjsKp^wiK%Q)|JjxcOOO<i56Y>$B>>YsYMn68kJkXt%x>WJv*=V85P
zC0$*HK=!wfYhlC+OFf~Sd~l@scOg`ilrZIQsHLTcBXJnXm`q3Ba<1R3_z^FA-(T)^
zhoSO&-&VR3x*xrhPU>)wPi3_@od2ok_f#vC^Wo=54vzXDSX8p(fPH;T-<SKV1N$2V
zPHS#1E>TfYQV2YLU+;F`C%JUaS8)PnYNZ+hB->lx^p0nL%r!dgC`>Ic`_6t>-R+LT
zWm#NWa&mIoqRbBe=y~ZcsKVuSO&3*^pFcl8fBW#z9Syf9V?A)W0m{Vi`)SMFc3M}f
zkUk6wL3q!!JU{Zs-Ct$+ui@ng_y~zKo5w;Baco!Gkmp`5#`(uHKR$rJaN@$Kv*~wn
zjRkmM<HF$5rlzOYZYEg`qv0_r1*Xv41$CYe+MkEJx*&TQbedFDRD!>zq@>Kw&Mq%6
z7sHW?V1<lie)JOJny@KG=^~+}{lQ{3)^a{XD;`5c_(2~6<@MbMTTkKeADkj!QBy)-
zYwT8tsKdjQO0c9Vop$7o?%D>vby8Xm-l1VkhrphFiHV7UD}xY$JR1UQ&G<>oY@$2`
z#vE!&&-+YNODh#_7%eZnjs&Bwu5KRjOR$On+`Cbp%tTuCF1Yib^+x^C*x1;h1ksYS
zv$HGO?h#TP$7QX<L2Ixe#`ylayVya0O~Q#bHrLtt${@fs0MzBl?`qicmlU&1!Cia#
zqjywP<0&k#T|w@U48AkPiW5<Oj~m2fb*DEsVeH|Q!JL51LxO`7zI_wcLF?4Fb8z@c
zKr?7c%1=hRd}dznzCTm4H(f+-E-du?JI%}T@12Jc#yf*xv%HQQdn0j#-)1v_B60Ec
zZF3FC@_W9!X@6-=OT+K_M#$p|>OO5**TQ1YEX#-8aZ|z^B7vNPgM*#@O%<u`ow2ED
zXh?{Gx}+pLov<jVodEr<FC5DP`H-ZK4=XRxaNC*Dr$dRfS65dn-WSMILe?^N15;C9
zg@J;k;)uo&eeB6&xBnD0Us_TU*G?1K0K2dB=@Vi|GOq{o>y2T?b`d-jymbm94_u49
z@86|%>K9_6CNakQC$#&c3D=I%`AK1as${@$KFMWpQzuHXs%U7uZ%YXc&Gg)-E}r><
z&oRM0H6UUhc>VzryQH*qCc^#j=m_12UZWD?$=TIaZ0sW&MVRbkoPrRXMP|6T8lirU
z;2ZpmZv<*;YL0lG7bFz|*{?uVh4Rdl6B@6oFBDHg<S;QWR6OZuYm0Pg2D$z;=nlO)
zS$Ubr5su|1tfplDr>4j=A2edbgZT=<4);uBEjY+H1&|ch)L^j_5)z&?lZx>It+YlT
z_nDbQ@k#xbbbDWw7OG|rwkDkVR9pz2G?@1seY_Qjz*xu((9N36(*ZpV^Xb#9tJtvc
zM`S!9BG@(b6^m^f;ekBfJ&TNogxG#5cQ{g1$P?vr&Q3-gG$FX0(|=z`v517=NU<`L
z`se1{HV5J`DP<<^G}#H8Tn>H-9faZ4N9ll07C_DNx&Dn#E|y(y7?AaAr*S6}GZNLp
zO=FBA7!4t&L>tJ%<K0DVZ7l->gV=M3!p-s0)=HACZqz5=`@JIY&6Jgu8MPZ?Gc%)!
z3@>u%a(vD=CDql{S<99TxZ;Jg(9SE(z2aA<rj*<-V36H<rbkNcR@#pK)T{rP1u_Xf
zBg^ypFk%FBz)G7Bei|4Ep*tb<WhEtCZpQ@7S3h=lI+$6ZNF(9Uv&n#HaVH%d9MnFT
zg5%+}HB#TgS0So2*v3k9_^;ehl_j#tf~&uOM=<G&A<jxk**iXtrkr2`rF%y1Xf~D(
zssRg{LAS-+#s+zqi;K%plrLeD$)xfENF<-<<@+wiBa}!PEKJ#rnryG%zkhc*f{JtS
z=llse*?het0ICJdGptN8=Vw_cA!1J327PauL@6_~ov0`zJ3G5u<=0{;C@2$1x3-5N
zkvA6?L6LJ6WWO$cjg=G^3*15?SI$7J_&nY^5Dve4_wIbX=&R`wu{r*C92^{B7mCrT
z;#jozCV%BPiw_yuzX|E>ht>I?MnW|cKNAwLoUK<o0>b0ZFE0Ep(pG@v3b%^9x`bUI
z=T^|s`Qmyd3%<{uGZA4t>w$=XP7MzobA@i}=itUh4>h$n!LVT-7u&MV4f0uhXjGg0
zS2N0J?3Ypr6v44nI_}Q?W?}s&K%iT$LHBG*z{%;s34deI>6zj=9X{O-N4or>p{cpI
zNmA+Gj0y)={NqOux;L5S-CX-~fsJN6%jsM(t%^8I7X)sQa2N?GMqo`x0vxkGY>2^|
zbN|=t*!iRoyA(YT&_hE*6J{#n#jx)>3friS@pz$_VR*E4by0@H2eS>rk1BEK*JBOd
z*mN@6p$bVzpK^NtKo;yn<$r|WSomqwzt$aQG*r=wL-f19e`hDluWzv(h-(JS6AjE4
z5=>GQ8Zu@9Uea7#@{fWpaLJvu9i$Sm40n?RhvAHb9ZTJ%8e`aLXhfu_=jsp&=qY4h
z_6O!TLLkM)1eC*f9Nqc?QgBDsF_W%bBGH82^R`2_5$WPDK*afvi)ug+Bec^!G8(U5
zAN@%lFnVKWW(HgFx%FPPw5-g<@xzliC0UFi@_eLzu5QrbZ**yk7bG1Q7q<1cyXhM5
zP<vzRDl5@s|IE*mR6FgA!D-fHG%MiM!aU^(3y@nZ6Gc?Q@8{Yfh!^?67$Yta{+c7=
z`mzxs5qV<e?&*2HOcGp!W^<yLmX$?JK&x#7`meRM6_uC|$wr`XKJDALFil?5W3c(4
znNQEprR3zqBm%lJxLv-Nm0?T!9H<9y++1DFjs*zw``kNc@%gN-#KGglWW(Z7e&Taj
z4-O0KpZ%f!Q`+~)`T9^(1()0Ty*D?VK-k1Az@?cPl^Qt0z^%(m=Y$y#0y7GR0Jity
zT3UFU`Bha)D+y&~WzV>=^yY5!62iqHl%6-o$iusJV>gsw#x^P>H@v?Jf{6Lm(k}NU
zf=lSlt>LZh?N(Qp5U1N&E1Tqnw~Y5Yr2RnfS}0ltCnskI&JWgb9Ey8YBs@U_R;ou%
zZze;W-&MDT%-a0U&|eFegy+!(QMLLRl7)ooV)(*2INp=AcZg#WayvKpJ~f$R5i-!w
z0HWbdKnf9cQsA77ZKDp#IGO)Rj+AS0q<l7`EFU3rbb=E8br&i%l+X-Wfo_uc+#bC<
zaVJ2*ov84XSExunrz1y@RBNCOEi*7M@D~>W63k!qK%r(~QJ(U?3E+Sa2}45|j~Au&
zE5coiK6QYL*sP3FaEG%HyFH+e;Vye*w4h-<t-%!1LV1>WPYN^?_1~8%x|(YqqO*<U
zV6=_-g@tnp@NafhK%++?h-=aRL%Kb@EvS5(OGV@SAXCsB{c5^=q~OT^5%Ry6{{qy!
z3|%Y+UBQ)=AL6brE+S)MzReAJKV8j*A>*6oW;8T#9u-X0Xx3WJ?t|?$Pv&x>bo^EJ
ziOLsWLk>)cM!SXi3S~1B6WJ_2oqVs$-MF;0KR|kE)yv;wArKR1Ej7EX=vc4~cj7Wu
z8+60WCvX@U8Erv}{hd;pUGeep8=IS(tE&oXYA}Ob_NyIW6vhy6O_eAY-QVAXEk=iz
zO=XoVQ2{gcc>brbF<H;=c0c~Eyu(B5gm0qe08h5JxBZ?D^ziZUQY~4TnH?u{MHloC
zZqCmUkdbSvssclgmYO*}er(lgc7=-p^cm-Lu{|oA#_nK^E;O(~!mIENI0Zq+u`GT&
zBcu4Fr0XeZM$$#WOLDc5n(FGbk6x}aG9$n?gd*WG+by>MH2d5HWH%xrqKX<3F_Oz^
zdvj-pih^RdhS~4gJ4aa0_s+!9^81*smDK@QRS{7%esS@BXv8-nqN3of!<?<*Z;_A$
z8o)Xv!=d_jbPR(br`O`HSf(bdk9I8JP9i%0r`Af{9G*E&PEIb9*#zMdKICT!IjJ3R
zB!lr(fP22L^z?nfuO+VCTiw_&va{oNJJ!}j%*e<<L_px><t>y=3q96pun&L&5=2D1
zmcr-bDJv_hrk0fNaR4<N@b++_7BMZ{H(P9BYfCochP86K+3jSbKW1)rc1am_Ld3wp
zz}mW0j&D5^pz!tnEG;W5D>rv)`yB9MFcw~VMPs9*qQR5xetx99V7vkE5azzv;2=EJ
z^7<UKxSN|eHz(&UD45vyL9T7j_Xl8wN3-}}blZzVDHj(PAD^Cj3+wAS_y`FINF>6W
zTu+wEfCW1|jNJo6d3V?RgCHDfl=}kGI$O+-A65Vm*%|fPkct@j#eS5QF4o!nN#}A}
zeWInIsk2?O?3oFGg3Z=IM@Pr!u(g)Tx-9wr{c}uAR%z$RNNIMqKG<%+qTXk{IM{e-
zqJXD!C=e(pDGT%Scd0nf;Yj7_KKuLoC)wsTG|cz*hU}!GEei%qJZ?e$#h(9H%YZfo
z)hktV-M#^CwJu4uS^huv;XfSp|NNLucv0#%2iA&~mX_Am)~T{Iqa%PeUWRBZqVU)(
zZ%^02?t{gpN!)Kk4h;?lZL&+3EUR_ziOY3#@T-gm@U*aSki+n=U%!ZbF5|%AE3gy3
zI+%=B`ueLa9v2h!lX>E9M+>T@lK>2EMmbh?XA<dQp`ml6?Cno~SDPsgC#VtGPq3d5
ziVO%B9hC`i8}%W1c|CwyS5pBntP%B=scUMgs;y1;fwG;7FffeU`}Q<Q0;e(Nz~r=s
z!{rDRTAkT==E8#3(FoWB(1}7^u15<6A0eW&)d+de{3|OffokZr`x44}d3fM*#R8WH
z{3`j`2+KHdmmBN7k(70YL)q_wyDoOu*VhB@wx<fD9iWUbqgR0v7~+_gJlvezTweBQ
zW3VW5#!XBp(9+U!h5&^rEGo(yDb=h-Tcb`K0{`_d3972frgNgFfl5fO>Fe+Ja(CaI
zBOCQ?b(Z6S#5uAmvMc&jZ+o<`7p>Yu&>$903T&*~{tWez4)?X)Qj^I9N)N<xI{<A9
zZHJt9kja1jo>&)f_2|DzsQ#rae@%I_^WORSFyqe7&Pt2Nbb?wGk`@^BHvVH7Ji;tP
z!^6nO^wiXnGBQ}G1|Q;=Dh-4+HB<8PHUgm$b8~a;yNxWhH8mq3jryW+d0goV3*h15
zL53kV*woZiXz7r^`fxSHcf>t6Ch|eFvbwr^q@%CTbRd?LyDQIbh2$Hf-q_I4{b@HU
z3wR($N5IZhclECwmefl%CV^<4p4yZ0LL!j@<;~!6+uqtT`1^pUe;+W08v$AN2<QMd
zd;^S(>CRXNEj!Z>7gyId*CQ=}%&^FKuMv}ylJ29kOSA~y(L1*y>GIfYk7qG13xalT
zc{pxfSCw*hcDAvh@1f-4!sROF1o4hGwS>BI-<SE{RVI<Z_ZeaZ%Wm|25iXp_jHi-c
z$233=Bm#baW6H1vds-e6P_H<;jN+Oh2`bD^jH7elLkrMIc6K$dilQQ_+;ldpUmeu|
zO38O8Z@%8wN(}2T2F=N(0i68YQ)M!2uOm`}kRY`M5SoeQEw6j!yvSdimc_Ljiq2N(
zj=-d<oSU1wx!ju`NJtbbPy){Wa%;R$i|L61?L2s*uT2hEFYoP<loS@Tb@sl(kPv9o
zlKXb|jQIE<3%VImYfmpP=~Uvrz6{3g>VSX%$F<Z{JfP!+majO;#l^*g;2l@yr1_3+
z1OWh%V1pb*_q)N<{Z(gYC%0k<^>q$xLqcxuj~}#TiD0k2_9Ljvk~z)c4SFtit9%}=
z&o=sj#X-B!mXT)SPt@BV63|)S*r2lNaIXEAPJ!pOe+5FP`A=XT7Lg-Ry?ZArCf21Q
zBNOFIkJVvnXlN)U_1QNNYPYT8+qFfzdRi>*(Kl`n4-aHyWB_g;oQh?sJv#6vluHAi
z+ZEIpG9Cs7Mo$|4G}BLPWf*!=d6d6ur<Q!()X;FMjoHN$juz3b{og~je+2HI%YVU+
ze*i>i4N%CxF7JU21!V;;aDZjNWhWD0LSj+TPSBr-$jFT?yD#XbrtE+%ii?YPcXvVj
z@p8A5Wj9yuz!V)D8(a8B19W3XLBW;|{ijc#Du7B1B~Zg0;Qd^|=#D_^3J>F@8A)d9
z9v-$jTBrpRMCYfWsH$or9g<Xml3oE4UJAQSYGPud+%~8HP-0L}P$6IU^e5T`d4glr
z3YU!Rk$io9<0)kWzX89t_|r(-z<`w5Y%~?*jnO0jQjEwD@rUc9$gdJbMMW12^^m}u
z3JMCwrhop7AX(jZl_MM$o6PAz#vm&q60B7g9TW4in->G}!<Yeb9-fDRIP!Z}V1o-Q
z7(fAd-5e9LS*ifvRWlbdUC&t2WIBNYNXy9%q<o{9A9*M#w-;)yK>U}&VYdu&jktEJ
zIfkFRPsvP1ebI!?X5&N&NQj8tGY??414Urp;zIHe;C4GkT4Q8noEwyvkmz^^0zzRO
zos0qMe-wswsVXcCmf<}m8aq3C!|`8<$O5}#!QSM0l$w==Ix7eQIuEd_ry?NWg0qD|
z#>-cDPe)H5vT<>K4x}n*pTq~~FrbQy^LkbU<iZ3QS=rg~bbdd+E;R}Q0)l0q8=YWA
z2~hfTzkUf>+c(AqeFotyP>oP$Hj~A0LS1rD12-EB!NhT$K$8E}!YZn&cYk{ry%}Vx
z&KUWkjox?66rIb<y8OG7Yry>6r+`t76=5=*)Z5qh8STyc#33+0e$CCH67gzSlQ{s3
zS{TJ)5{7oJV15yk2851;#gGr5fWZ4|e-^YPs26wcGhM0=9~2mVgM_t5Sc3oQa=Hpy
zPfzckHa+*p!okVnaxw+IK0#!y1%??u2Z}nZg*GK<=LeQQMe<o)U0oo+Vw|n?ee%@y
z%$V30Jj4`wd$x;#j!qgzH#s@^r_Lsg#SEpe6)*!RRZ&w@Q%Y@JcX!U3qS8{Ncw1w`
z%!ghay_T~+d=Mzi|4=Fk4gpIEa@K#b1s_p5m`dOj!FR1Iq(Q*N#Rc5;O~rlu*RN#c
z<Z+mom`)Y!q$~@JF6ZaxABa2wJ;%k7npytgc$Sbg<5X2wzxa+mmHQqN5>m@x;b48e
z%SjgQghYtqndg6F$v=SdUvU0ETlfF$-~Y39iMXYHewB?>QdTBc>$G^IR;I<~xH<4L
z0b&3h1%(Nf!G?wgyS6(qvy=vq^bm46=I7)H$|Y;WE$+<pjaWb4o>hQcv{*4O6qWdR
zb2A|$qfDtpNJt257E-1$`8P3qu+lMn_XC}sr1bQ%?d9kXHyr6iWTRfN=;sp_@dszt
z3pIP74*;0^JRH@7fp*-~R3K<*WQ1JqDVh2Wm&J7c&z}mN=DOTmuvdmX;pkvIfiw^;
z6cFd|53)g;f_U;|cAEu2sm@8WxSaO-wzjr_e#&*4^%aUf3qHUcu@2jl1uu4c*BrSL
z%E1!#%+6v*BeCcmxr@pfl|PN~oILKy`|Yo^x654(3`pE|0(=<-lXLLvyOXwuV|=?7
z(v#jx@3Zw@MMXs*^c(LR?X<PEfv4kpx>PQX&evSI2cQCuGBBy+RA>?bdNd$3csCeN
zM5yceU>k%9@+>vEbSF*?BB7v&>3iOtn><<N8?7`DW~}x65Q8Jnq}-eRfs>F|Svetr
z+kjz?vA9C~a@!B;a$nxm>-x~b#H7~y&QbDWS8OaSQX5EMkz7VscQ;78hXWk_oR1e9
z8yYlTYJdTWBKqjr9f}Ofj11)I6iiH$&cj4RM6Rx`;9LX<1W=wy-PoDzCsSNGkk_cY
zgW0|^F+uXCsT`!6nN$0*>FIP9Z|qx~_rBKG*S7^@VPSQI0H;LH!gA3Sg6Q}Riu)`D
z=!zyYFtba3=r&k*GSn%lsg|cgk#4advVxQBMN9+yK0-yp-q0{0*b9(^n}<iZDGDjM
z@NgHEN|z1D1<ZVd!v^qCo3e>g@4V^@iSk)REi5clRIt{GWZZ>?h1a5NmzqMnH7)cP
zN1|4qn&lY){YzHX*S8-;Vg{Z3vCk1T1ibO{=g%sd|64j<kwf)m69$19GBw4E!hlT{
zQ1T-_9&_sX`FWxF17i}a9bQXI3n<ge149I)Np8RAN5FV%?T3elsg}KfA3*Et2eLvN
zj)LfaB%KR$AxIV&J%^3H-wO*;sdknY{C`@gz?q4%hDL+?*?IxquL?b40)kRZt&ib8
zLSRpuFaFBH^@0_L?c%`r_}uSW{Z2^trg8q4#nt>~5b86w-R8QJIfEVom{6Ds5^KkQ
zkM`~XI6%liGakW`=Nu%HrSth{^(072N&;~h0Isv~e;oQ>zM!4kE53gHx~8iJhY5C^
zjkF~QF79?1`rm{4zfSAFBl|x?-v8OA1pkMk9H*%MP%G2;DWscD4?-3`zUSX&SzEQ<
zBI3y@zk}g1!57KR%L6n12}EkTbiZ)G+1Ct$7jP;pRo_daYHP0mZ5PR;7*+xyAdmwe
zdz=EsED-ECB3}1X;EFv+i8W0}lGnDjYX6!D>2F=VfanLivQ@yT^-y-4#dM)2h!2fX
z2sl50`up%<VzsIo<_N#0drd@wcA63=P+Cr|Z{!l(-xVBVR93!!{~qnG+H};>%`L2%
znt@@t&4<UEfO%tm9gLtIfLYtyuBWS=)n?=Ds#Sh3&+QLOC!p|Lz}8MoOaPQN?y?|5
zwkuF7xjtS>%gh`TG~#X$_zMUGoNoV>59ECR;RCVYvq^E{qm}lR>1me#&IfOy8p!g*
zzU<FcWL-De-(UAmIm!OEu;fGs?a&TE%mmDwm6g?P<ln;?ohE1WyJpv;@1><8hJb)T
zy)0Fm#SAdg(FJdEa&ggXHz>fx_)7BdG=ugk*KKXe&o>6*Xt@7{66hqm^*l&Zws&_M
z^g9EKi{HD;N8@AeEjF^`>-Zhb1qTNMTe#8lYj!q*ApN?hM`W7bh%!Jr)WiSFm(f^K
zVdr4+m1iF$kSB%g;C%S<(P?|c{}mJ@6x7Q@`^%?mEP%0utmd&oIh8dvGp??nZ*Kum
zh^`vi+M<}{>tV#n+S)QKW+g+mKb{Xu+}_>-4Ij_oQJ*iVsBrtoY~b~Oi3n%wmHn$6
z-?O+tX!5#H0+iHWhtY8SpRAD*8}vDuX|*Zb$_$O%HR_*762CcvTaPI%r8`SN0;wjM
zt7f$+vLnb7(1!*>NZ(c&k|r=IDXrL%X?_0kWlNxu{~zV>cRzsr$o)2o9Q5ORjNv5u
zZdEiv8U>m}C|Hyp6T<)QBjVOX;4HWn_UB4+U;!LX`*IptSs|WK62KOgi|ymlMc5Zv
z&6OLPc#RZ_n###V1JlzZ`PVo^23J&6<mKgczMd>>Xn5P%Gm^rR^KrhWvhpp5Ex{Q7
z6dM~GFzYvFbs#-|3-RB~L(c5S-*d!r!DwQ<Ft^~?wuXa+g=K9U2z}0ba6*@C&Y?P~
zFDWqzJf`S2IQ3hri;Zyh_I@-*hD$_1Kw!69j`Ftdk}UWq)5v$8Z}WM$J=?%x&<=0N
zFE2j^hG<>YPf1D1*qGw4(j3oH8jC&jl&)9)`(1znIq*_4kY123F*7r7%Gf-t$1QwB
zrUJ)(IdE`r<{=gp;S@v;ABb^Ky<xzKg84)?$OfZP&%<9w+pMFIZJx!rr)Ge3{d#X&
zJV$|K;`dJ@Sb30>d{`$9Mn@&JA$nHB|967<KU<0aL7{5UfcAiBX=Y6GAItC#!@<G9
zaM1E^LX-K1f}Q=>>V0BUm}MZPVm*kA3p@ytM8l(^v}?@cG<5%>3W%|4YHOG3?XonI
zkPRllArU%-iJ2KOm!t8oQcdszf>c3OLxVfmZ$m<*BjyPraNa%6_keT<0PbZv>$%4I
zH?u+dUza2PZDC>IFV^(-ZpDCh1qeAjJRGN~q(oL>*#atKXh@0z_%0UL!+CJmaPP*y
z+UIrB8s?ph$L+ieTDF+`uZObuy18jAS?xOrl&+<<6%6#qQIL~23jE89{|Bhk!EZ8y
zx+!LJKV3a(fAIwdKszkqukpHxdW0F6p2k!hOJ%bH8T;QRxZM5r3LI4XT+OOWOH12<
zOzvobEgAzHP>K=NyX^r2=q!qijQsXZ9Te`EF2HCJuJu+qeSLjpF%ouAXv&2$cgM{q
zn==0fX|TdE9zB@o=#zjHrod$6_QIjlfC#vIycn;|%7<rWVF4f54eIn`>>F@`RhY`@
z`*@4U*kXUY$i-!LzBvd+7H})~@F?U$a7=`v;Jpp$`pGxyQCaLZTHu#`z)>>S-~5Rl
zgl@dH=<<<<W@b0nf9%vj;Je(KW)_47nEbCBjIBd{$>ICIOK9ra{K&30!mmXVjw!mV
zj9wlx=k(MSygx97bgKCOQF56I3(Hk-!0eNfl7a+Fs(_h_$_$Jx+5gqaSx05Lc3WSR
zmJ~#~TM>{D0qJf5MG-^=>5@iDx*G(M?ndd5ln|v6=@g_JrQxhcJZ|6j#COK`&)$1D
zkPXj$-D}M?=Wkun67L|-%LQYy16m&sH}{vpLAvABib+ZVyOqY8QfL*Dfke<RmJ7!@
z9z`IYNhmp(cHo}oX%y8#lmO#=OiWC8)5e}JF4b3j%D2$Mz!?Y8MnW3)>eW3>&5=}>
zuWM4KrYmsHZml3rGp}cD?QM_CG?y*sz+E8RS4loIz4Sn%fQ{`k)9jD#PfJVt#n=}3
z7uT@OBDdo_h$`h6^A{f)4i=6>)fqo?xfMTN4%pw{2Lm1B71(C>D?@i6;wCFCEd?Ff
zBC!6Rju(0%)EL`pd=e5CT1rnlm1l7JKs17mMvv$Mjfo@&DnU>W%4mFa^be>^`g(d`
zMIP<+E92op%kmN><27Zzdez#-M(gckQQ#@W#F_x&34frWVbG%vr#de$k49LAthA@r
z$$p_{Ywoiol57dz;>vJ|?$f8B)OqzjhC!%UpjFl9;EQed!H<F&j~>mc(sEi1Q74+V
zH$=zYKKo3BjEwlG2a6^_Jc81|&!@f=CtzR5>=_2|42e)J3*Gj7H<V42$-3JL7`Hbz
zH+w5oR8(G0>5h~d!IOYuDB?O;sJ*?t?L7y-0*hKExRD~YYd@HShGgaCKQMW47$!o_
zsg^5?co6q8ei=%y*dBggUUoYCX=d8m+8TG?1>7x-LM;qTOnB|S!n=z%2T6w~5#BB}
z$FGRQkeLvtCE1x@j5!MuWz4Z#1*<^`_v!4KD<~y!zJy<h!rR*GZPg+>kIx*uv0hkM
z2)Y@@M@ZiM+~FOTB!L7tJUb@`KlCG(733T6Tlso<QJeLg4@#qn8m@J!P|bm0LYz}s
zS=rv+egzu`r|!iM*0?ZiTK*hFj%X#O$@}arS?em4E4oDKz`u<k7&OC3sHlV=TuAkT
zA*S=qO*$@kJ8#^$^a787;DT(=%`*G-2_S&Tp(&P@s!xhRa*aS$ynP@a5T90g217AO
z0(YFd>go$_k%xiobq=d#gXUwE;YmsC2FCW{vyj!0RzScV%K87}tN$~={^dRW*V)y~
z;(=E~Lqk{?9#}tM^hHMM>M0@-3OH;e%VqR+X@L_ZmSSjVD8hgH_A!t{X5K<+cS@Ow
z91o$kgi;8!hD*c2F2#<Ij|a_kujrA>@qsP$T(DZ`ylDh~zpub&!23$<chb?ZbMfYt
zH@s$IX)ql=DmA>Lsi|pX#DYczC$t|GMic2V>i4`7GvH{`QehI3k{Sb7(*Zs;ZPaUU
zki=5`{LsrZDX6I2ptNL~wzjnVi%vXKsnX+rjBNiK(2K<1dNYO%XDL$&3kypqJuEk^
z0$-;QhuCyk=k(wTmY7fr4YAQ@D88MY*!ZJh>4!r&b~<^yX3rPUpQW4zh0wB}i~+*K
z?qloyt-1XCd`Q7L=;-K}nC7#RTs=wvJCY*y;>*m>@96D)-sph>WA1N5S|5C-kZ{l%
zfzoDYnHKA%v)t?HI=r^5SFeT>bLn>gS+Kh@Ot%HEIl_Z3(h*iaosCq6Nar@#3G<0g
z=5S(A1uWqOIzEA~B(S3vZXIPsXjzdYqU&1d)9)Z<<F{p<5!|r`73<fb(z=6)2b-)<
zshvf`+*Ojnd+B)z<CmngwC+r(j3LatsaRsP1_lQBe#Cn4KJtf-cpaf1{9F|<?4g$6
z0+#@&LaUQd;S;~^u`w;bufU0g)!8iefsze_!cb*`My-Jt1XDoTX)zJ+02E?UA^giU
zae#QVA*E_(<J^E`67fqD{QC5iw^g#IoBatuId1>>(ZWsj21d_aGZh>{!P~d-9U+B4
zb&smA7e0?)6{K<zhT6}l>MF=oDj_v?BH0Kt1->HrKDt^^DMOu4@;IP9+;Z@KP@AnR
ze~JAfZZu^bZU<w#r6n^f>!<d1Q7q(1woeYAC?ymXgF!vq9<C@WlbofQC__d?jk}+h
zgR@}$r!tJGJw&$$!*2=VlN}K7Yh`!D(7|yQ5j<Qefd^#R17>R&<og{U#@k8ps9>x&
zop?|3`fQ{`R{=d}Y+|CwnfUtk11&9bN=lsDA}Z$-xH5<^$yQ#9!t7I{*B$|_Fm8fq
z#|UzRRC=3>9xsZ5FNu9j^8}_dIb-yt)8!Idt4Ror{N~*+fI#FnRDti+-5z;iof=`~
zB7?;VrW=*Fn7fDp)D%Hz<Whq1MfeB<I&#Y5PjLOeOrpOi(0{8BVZ36ahv7Z{S_(?Q
zu*#H69Rh7}mvx{h>T3tqz9%ZSSZZCJ5D$+nw79J%6aIWSR}dBhJTxOh1BQsY!@m>*
zX5U}E8!r~jre*YQP;`KQLH~Go=MHpu&Zo`jKvHIUwS9Tp+o6zk86lMXH$=FoFJ)w8
zMCe~$0(~Fg%&cN)m>nH``3B$?FhK$+A>kzfCXsO&zmU))3AQuC8O&|(C7HO(MYt6F
z^w;*zTJ~Ld!_HcE_IP1qEePJTD6FHa>jcq<yW$a863*CrN9+Df#nf|R*WrcG&=^cl
zPY29L4^-jBmdCljMJ<XdBtkG4QyxoO)E_M60cdngH}jYQ#&F8>|Ab1@an@&<5}*11
zqqj3@0OZOw=HlpB74iTkQ7Arb&COahc4m-OLE`$b$|{4!NnTFw5&=Q@0!SB$r%-@o
zOo}S7{YOBC!>}2_AWt1>_yRss74{X<Kcxhwt-}$MBA27hHa=QpWxob2%JBQ>AqaU@
zfO+17?O}OkRTVto0tgJ?-46^2k+OXGrzjwk;9(puVPYTbgRR)v-F@Y5L}Vn`4(D^S
z3k&O(CqQA}$xKde`0(K$SrEpSBw&w|#2g<JGrzj(@^fVv#wQ$7ZuIe&4d@sWClFz#
z@Y4q6<>YMc?%v$=L+}&*q=d$N!2Cie<?P~ukNKDjhLEV27?k8f+Dr@XSR#Ekgk4d!
zR)ngWngPk_kdoHE_yI(MH+g`s69gE9co@*XC2pB~%@<8ZwH58reVb(1+e}C66~-$~
zcF518cR`LWl?d1XG&JATRN7`tKliCNNfKl{TK68&!<?A(2ko06^}wR?`uVsYa8}Mp
z5Wm+%E+G&H5_0mOy$iN;nytH-Jp?;TK;A*Z@6!rNg#Qtw8Z#y0zBuTgAETLxZZ|t6
zG&G0|yTVH;S<%_iA>oEaiI14u9MS*#3Nlp*m;qwq?0};Ni4z2uv9Ylb0^b2|U=?J7
zPNgNyEK&{NXTd$`b#<<1l0j5oQqsFiqZE{A@XBS8TaQ3hY%;IIm>MP?UZk4SLsU9j
z(k<jUo6O(LE+|Moq6Qflg(OLO?-TVaIt+Udxq?Of>t_>0{pE>Q2Q%5V?14>vbJ96-
zvXl|ru3n#CSyuX8qc*i3D}a)==@BaE|6rH@r8fQ^PmOqh%^HNR_Uu#CVP2j2I6u7g
zhvqVcg%*%LST6QuP&sdi+Sru7cg+?B_qzj>LVxCN@UP?Ac9u*{&jHY}yTA>ilaPq0
z98!<n38!^sw}XEBNf!exhuId{vVQ0&Te+D)h1~CBbW4E1)nR?2_RKPxgqcx7UrTEY
z>KQ;D;Lk&X0K<ITC&J`v;B7$Q`PjfmPjeX>6v6UcGK*{$s8xVcz!1pLd0_EtkbwC<
zB_-u)_|5zB%F0QgNun5OX~lp#8JYzr!5L(Is$^gf_Kx$}1h7DlGYuM@W8k-<7;-w;
zF&e_c#r37_ioexAK2FgJG)$FIKVygyjKx{6-Py}aN<0tC-@PNbq32gl3BPL713EWw
z(l-vF9V<Tb0E?WO8w!Q8nb|6s=1-)hZG*V=!T^{DfXD@G4-yg*kin4Ts6ozGR>sqm
zj7`QH6&-zxpa1&(x74hxtTZ%FU`60#eqNq<OE{hMCnK{SYZ;vLIndz69C}{=iyt<#
zs0HH(jS+nR7;aqDTgezSp+Z2wk#SQ)dc7$M-~|FsT<Y}znr^zJx|*Mzy?b<YRE81M
zxBE>hK?e@Oy|+(3)SaF<^^@H|mopzOo=XcA^0)^>6`OYT7cg_$+R(y##;UCGKf$|*
zM$@ak`Y}BtW14`5Fui4Lj69s6i4Md>FDIhroI8KZY@`(4wd=NW(4hN|&aCSu7jcee
z#!F~8<YBu@^zcl{A;=xj(D62?2h9U822juF-lTX+Q29C_+y>P$6cij>8|o>!T%6uM
zDb$0MAdT)_nWa&Lc)*Ae{W*-i@cvSRk$FM5?r)1)g}Hg+&-;%99(a%*=6??Uy{EJ<
zH+`@?R8ZyUKEd7uoIyf>WhB9Cb#rsOBZX6iXVI?QTG}rqQrQoL5>O@h!Tt)R9z@+q
z!u3wO=Gkcp2^4MI;P)t7pI<LJE@WV5FM=Nl90_=`5#OUvz|uA|GZQ{s;o8>@X;gR(
z#iD+r>Eg`u_(g1<7I^yw0E<Ay1_he!{adb-{i|F7nZ(J-IbuZD+Pe=*+{f1!JYrEJ
zYK@Nwo&=_m?4Fmp?q8lO5QtGeCqzO*VjGtNGdMP@f*Cp}<XM?rPB@;gM-<-h7Nn=o
zPBnU(%@{ub*~0!1mzd*mPqHW<f5;S*``0Q@#50<KidlR7a};uBD4^z7U10V%h3p@1
zjCuj#aQU($+^u;NuMM!ku5VO~KyUbWg;FkU;+9tcOcGN<Sj|%tlh2VN%!2O|;48T=
zIDe5sbdx{pE&uj+e-|ZXvL~=U0q6L1$`co6UqFzD3lrYC1%L+u^+<lzi<f_SSRs~!
z=Grxd^y8x=pbBo^zTNVDxu{;qbcln%3B82>>Rn)e;0&39<^kE?TC+nO!okHAKLj4J
zR?+Wt{z}X>diwO7AMX_fx!`!ixSe$4SwLg8)XL;81Zjd*_}u{gK=r!qz=?~CyJthk
z06bsIC!@@;=;#5M@Wa=@UN$!`98zZ{6cQ3@9i)s-$ZtF{NOaVP1_QoGVQy}9*7e({
z{~qn5biG6*`+dy>d}bru&?FKNNYM-_3Mwk8`bE#5*dv@SV3)^v^9t6h8ACIdBCW$x
zT1~K@2-gjPIfou1ReXc7YFqijfeMRB*+|C5<BY7VW#W$Z_UCZWL0n(G>N!geA>l$#
zigXD1;+GsX7Z;Z&Pg4B6R47&fFcg!QV2m662QPG4fG_Fn?CiY<b>flh{@l^gk+Sfy
zdcFL{XE@fDeyq{PP^1qiOlqJBHAIVBL4|sY(Q?~n0q+tNyXIR#ets%>1Af<p4;JW-
z39=PIYwip%@bM96nZPav<ca-{va}}aoXfFCdJ*m~X6W_P{iIV221`3TC3$%Px0Cma
zmw}6e5tZYx4$1*IE4JSU-#RY#G05PUjtmVo?8&p&dRe0ND(mZKW(z@L2)!6wNNgy=
z6Ym{idL^_yQ(@24h=_;~qkA7cJ^kbU(NQOm@<5KDCS6I92NUPz$e%L1^bW%xzyk<6
zfvPTy4DI*W4oxe}%j0r5zmAzopoQbdT}W8y9kQ`7YT*xdxub{I{I^iyI;%NM5C6&2
zlidyWN!P;y|I7Ff8xF;7!-T*Koo$b_#T0o=Eg1Xr(R&B{$Y<zSO%&*%8`7ZDykAih
zES_014a@$wtN@=ZPpFu9u?&9+ibt(U3^XX{Xb5I0kV-JwaE4PPr7<dkpGk!S;sbC&
z=<$3YuC1x0{U<)afcU`g+VehYZAFrsPv=E_2xw+8E>R*emcX|G1>=#WlA~Vi$#vpd
z3Bfi~3Y{Q~%tbjlaGgK|w}neGe~%CRXc#wHonHmL&ml-_P=aTT2=fO?ZkobJ32u<k
zs}IXyXoVp&=ehQzc{Wm8fFPxP2VQY}D%im9a@1L&tfM0WuD?hnCAAO!uI^z(8Q5+K
zBcK<$yVoHaYchHKb7^+gtF*q}P3<lmSa<+I94N5X;Hp_K0+|Z=v(uAf?+rZz1Aw;4
zTP4H1mJ$;apRNI=0aV0YnW#pe->Bu2RF^>ugT_qQz8N#Huvl+1a=82#4I#UYYz5Bn
z%#}~imq6UCcOwc~^4C9kL?t<Y%0TVNAmv#ckr+??$UV(nX=SuRS<e+H%A(qzq=dA>
z!u2@;u}i5#kdfa}S4U3r<CD#L>CpLYX^Ay)^l{VL)D*Qair5dc(eh4cjcO|a0RaUM
zD@YgV8K+e8!3}Y&HVXsW`qxl8b$AwH9PtIe{Rf%gGvcH9Ux^94H^y$;Dx-A{>2}J9
zxYz2xK_#q^{;OsD7r;cxut&GyRf-f480dKEBVCK9b4xvs7t^i_ldS3{KRzVvE;=*y
z-)KVn6|#A}q;2y&2K`|N>MCY;k=y-9L?Dor;q5#B`q!U@#zE47m}|k`r^GDSTzA0R
z;Qp*rD|ZmOhkArPJ~UNPE}H&fH#_cg-QF_QsETb~d+jFEmmk=S!=g;mrpClIRZnJ5
zdEYyU*yc^7OJSE!IGKrWQ_`JMde^_mNbqNP69ZN>n@-)4C$5lRNJ!!>>&#7Wf<XYX
zzeYt6j5N2j7+EO&?|tBN-@o;N^iaF;@3$kt{^mb6B?_X_xX5#GUrMmkdYPG?W${NV
zSK?jz&WW5$MmZ>T?~^0GC`uZgzR8cH(9<{iWZY$J^le+e&b)6G)u<I`;KVJL@rQZw
zNI8o>(drtv@mpK9kawaCEc>_~qd3v4PBZ<5J6T^XUckf(CaU}FHCU!{-G|p)F&Z=t
zPbFWzXmN3IrgGBtJ_OFz*||DVD?qCHtCv6nt~-<%>QHctzP9lXK)O4^kWg)Jw(!V%
zeq;IruK9egMO5g>nwJW{ez$h?(|V1&13Xfe7T9W7CyHr->ttyG#JPKn;@Y+k4>oR<
ztY6O!oqKwo#f7`KWAwo#lt&cl%*-)`Q8_vo>OqTzVFE$*4E{?iPkEa1m3{_fKgX0d
zG5Wx1tL?dSSfp<F?3-T63hjm9C33zKYC&7poZ4r))zwO*Ki;w4Itmd=zK~;aGczSk
zdXl4r^EBh0YWa&}Tw`wj>_D;Obx*S;j#Cbaa7S^>1$u83X8Jy<m-E?{SWQ{l?aH_r
z7v!*k*^<!>sD0WJU_ap~9dZkt`fy0KB=V`huGMfE9{x<=Hc|!j<i(5XkjD6UawaAw
z7#53*Z^(2(>-52)cmeBLu-rB<ICzDKC_n~%px6A_Glm@zz0|7X!(BSTPhDM7jt|H(
zl@g52%|pto|A4J-uugTL4QBCghF)Nz#=gj|?UBPY%4#(~HqXFo81<ktHz77z4tEwk
zpZ0Wtw1Dwnv0M;54)x!SZxv|tokL3vHD=3=Dbc_EiPdcweXl{~E>+di3R>dB1xsu?
z+*WM-s44BF#k7TO@mPH6)J3$n@g8e_)T4ccTKf>aj9WLHt}cGoAav_~b@KLMnVrYX
z>U6-V0G*jojwXp!o2dQssPDMppG+>Zn``V^$7q?Y+YpyuIr5z~9KUZm%CgukoU3xv
z*--c3TRY}wJ45wx^|TwOWg5>?q6+WHblXIqd^ikwkU&72Rkll{A-hhYdTJYYe*Dla
zi|j7iYbl)maite#DuMCFeSJ5js&w%#tv=LnI@uOJC6GJk7W3+r-N}(-|J9M<VOYm4
z(60G;2J(G%{7y%-;XT`s861oqRKL?Fzft1n3c;D=k2BY#VHM|p?$(;nt!3gErtR0p
zAWX`dWB_Bv#t1kc6#*dKnk~VwwUQ|Xk`Vdfi0zzDkPYfnERr>dNnqv|-k&9CHl~vf
zabByM2Wp<NA~0kcD|sBWJ)KKs9!oYwGe(vPOlatz0S267>~UnKy>td9uK-h}U>eob
zPm3R#d&l0D^GyW%cy`1|<!M*BqyS63!d721H%(n|%M0OwJ**{?qSn&-8XM~4nCcI;
zWc}#UDvTK-qywulvEM9Tm7XRUm)>=GX!UMCBVfoRy;p})O+kHUg?c>K;#&DClhM5%
z3c3*{iMD*1c($;kqzFL@(*DTfjL^Co`9M17J?s!(;!VTv%BpEUu?#g5EbgfF7%RGg
zKLjO2lw%WiMJYp8MlI@j-qAk2=wO+R(+5)Xji6((5)wL=7up1o5MdK$Qivs56Wwe9
zXrrD>oWsgzs}<yh=vA{Q-%<YAt#~nbT~y<b)<C{1z}+iq{!zxj^=MPt8S+71Zf>ng
zOC%%oB`}lM(s1p0Y$54PQRaKsGYBM!F<J~bjUHBXlmkTRhXR&RN4K*Tc}J7Yv9yF7
zdqv(5=?7zUe7Y8GUmRAbajaTVIIUFth`}R7AiDozMuD)bTLR;)`?77<Wk;1vD7-Uc
z!==h9!abAGw(K~>Z*!@rPVDD;Yxdhj;wyji-naLS4iI=PrCF+e<BL%se(3l5R%x@W
zj=b&QM-4=d9sv)y-ak@N!Sj;NP;G1+e~u|tZ+;FfH?jvm5te!fzkGqEc-goLAr*>B
zW}=dVbLTG0AnpZ_QJ5gZ6;J6Q$=S;6Qm3$kbu7fTp-tc3od!k^pP`}q1fiOU&qN}P
zkI8Cz=-F&^UAWNLK$L3E7g=<KB|Zm+cV=$xr^!hw(e4YBdvuZ}?}Lb}_w|n=CpZ1-
zvjpT$t67dM7rPjnP*xXGHrFTdBb0=OtW!9j?`KB6xV!Z2<nzQEo`}E#y(~x0ZAB?v
zmpdr$?hLc(2A}k`yH%Wbm+gwI=HtnvVJau;8`x^yvA<RA9umK?&U{>=QvF~wR>*2o
z>H9ctq?_5YvbFuttN7yUC%q2sud4SuJ3z)4>eOF9(ls+HK!9PE){1xA+uIS04DE&V
zB-aC@<MXj2x)bAnFStC%r%&NO%BiUl=mXdnW^Hc?64M13u%z@rgC5nmT43{zkB!X=
z(HU}VZYZuRs3pG#>)vw*35$ZCFbS5+M7S{otm?p|OC^UR3W0Oy=tAUXw&DOS>a&tn
zw)EIZxl?Pcfa4TS%f;`s1th2PvMoiQC-K<^*tyz=1u}{?7staRA_v$R4xMBu?Ns*$
zBRn%^N9s0j2M_TSB<(C|1dDbsv2zb+cf4_8ur3i0+d4=VAR@wwnb?2xW%$n0+E!j7
zHBCi`)SYWLM3?l~t48JZ16n(3C>f1(kwWE)S^Bb-@@``LhB%<8=`S>c2`cgZ3WR^)
z#){Iw!swe^Sl{%2YVm$k3aSoF)hG6O%_fxKIY&fXGJRC%JlxnQ>RRo+1co01oYmhw
z17~^q+5xl?c?YRAulbl^I<c1ZFLWiW?<|6RV|8gQhYM8}(01r<Ob`pN72(nnYl4la
z_Z>`ue%C~wSX=`>Fa^=>gDH5+qE(8D|14bm*6@Wa^m`-jL^j`vPn?b@BQ8pGRqX@q
zDi#JbGwyFiYQnET6xG5#0%n^vy?8CsE)Tq<_iJw+WKNCZZ>dyjceRLpjBF=3erSen
zPcJ)T;wbh}T=Ynn1+$yr$|mSL$7|lcpI|<p#c_V81pj&$=#Xo{1yBoKUqI9Lm`=wW
z`-Hz6t|U5VSCQL?`dB8I|KpYs{J~apqx~O7{=WlTkfEGxZf-smy&|fm6%XVPi|w7h
zj}wq-(#dDE|259{kbqbGZvSAp2$zhvqxpiUflVAtFq-A2!{FJOnwcR4AkkJh0m4ae
z9DBL3ke^}{25BEeH-R>Q^jKM2w`7W?K=cK7SX9<@8;eaOI(~l*Yf<@tkLBjF!Ul$c
ztlE}LZ(-*T2k;t*)3%ChVEVrz&&*2~%kX5v1`PM_wQRs=8|qDCA4{!kW(@EvCnDpC
zKYo7;{Qv4|Mg|7JkElyvD;ojbUxgnzMjld#&tMhaP}9<S?{a9jk^sIVFCBtj;PD{F
z#SJ}U8-gYvC^a7J{69?UJ<M3YC-v$Iw^LUyX;_hBW)JLvNgcm61sB*k$Njk&$oLUF
zI1s%FH4Si+Th4WS%urd=p|{h(8?#+H7x(&!R(Z1x2CEh9SvjeOA7+bv^gMT^-eOXS
zjO-1>-&!!DvR(qS7Dz-u)d8*5#NmPeMv)cy2gy?w6FZMN)e2@L<fu|?=`?I1At4uu
zuK5K7L|8DtlVG8rhbC;u%*M8w5%Z`?{SsnGXT<y;)&V5PBO)Sz$E&LN&pAEWR<`8l
zHXvUB>+ghqc8CEa&(+e}+G)9<f<rYhAYdw=lWC;*nY<bopC<uTLVJ{;wwTb`2e25U
z+Byn>GK&qIW^{KMyDXKTLd58@K+JCmySWMb)ZY#H38aoa`*Of2N)txo=Hq;Ctvy=y
z2DUpjMcd4O`?|KY<7UtEf19JEYh<qEo@f|gXF`0=>$s(N2kQygWuBIF_cb+*i@siK
zxL;OL0ZB?>K6fQr%Q5ZC1`&szfF9lzvC0e6?u1WZ^Fup@A=TN+YAcFGEm@g4NYN3)
z3~B8E7KH#^-YJxJ8HDH5J&u31HE;*^z@{yMMF@V~JE-FpeE0;&f5pxz4hj?FnKZ7~
z5siL207JvJMb83LlCy^o+>)|CX5Eb#H$QS?u8LVfnD;AQ?oGrcjptaZ$kT3_BJcUw
zjJE?Jv{fZQ)tuwsM3{=ZVfok$Ja0usY~JT4BErpv$XoKHw`e8}t<G<AVT}Og@wjPr
zeLa*jzaJUv=}}v2EAIdrdN(k2z3xCF%5Hx}%e`RM;6jtToSpW!Q*hn<D&1I_JS5rn
zQ1`O8vsdAi*45Ry?R}t{@@t`ZW{K)sQ<&o)+NCG=y^YGP*#O3T^Y<68T&H${U;*g@
zDshq&q>0ldu#+}12}$;RD~HgNFKuVP2N<K&vvIs;q~=P!W@5;vNAtqcLByM29XF=X
zA=QVbT(!f7)<ckqL%~lSby|OVC@dkkRrvz6y(9^sUs#&>nP{k}pY)$kJ_+zlNrWA!
z`&4oCsFZ60vxfHP><QMQfRh8DcXtRf$5ukj%aVrPO_0-xymf_#F*Wtr*?6*d<Z-G$
z3$?x%`a*F1m-i;W&S(QNwkuJEucxP{Qk`AX$L6dYv^p^^OSDfj?xS}FS9qT))<w=W
z-LOyKAdN3t>_!S!!1Df1b0jv_4+bHiw?L4)j=w|~Iz8HsdGuoOcz3c5&*R}KFh_IR
z#Pfc=G;DC$#Ov5gF5pJ|(~TU){c^DS0P7`g@cThSlWKm(JDL+HoWL=MEvu<EazltF
z`R&p4Er7cLm|^HWET))0bo}nSVRDvIHQt7N_nqzXJ-RllsRpD{Vtjn}_U!Pd3%Q$!
zvw3`OGN94xA-XtTV;FJI0T-VHTPNRURhChdAeE_clVN&5<E`XPf10&fpag;3(S0!r
z*^z*N06MORn1l>0{(Mp1P;#*1nCS$Ytlkaw9!75EkV+g_xE;QUofIM7S*H9#-Nqe8
zMdxzA-nF)TMD$(h?n%CA7G`?a)b|R~um(M)iNmiCEf(q5Mi|7Vt1hZs+4tX0Iz2KV
zBO?P-2Es}@<6&?>A(h~4YF<%rLmdnvNOFpkYTp)>kU?b%lFFU3+?jvb%H;EBEjENo
zIE3Wtjo$9&=4J?wkCE4r#bok+fuD=KQwDS1Q<{;#b2c4mMzaK8TQvMWG2Mv&4BK{z
zsor#nKS5;R=YtU2vA=w5!Mf6KEY#`PPd3nAp&Ow<pBjzbfW4gUV*D+c@gpz6E_~d2
z3_0|9Gp|y+W^q_1x0<w%pg*zZ-jbOntaNV@|M)F%=^l#mdB+{g<PG4aFhhGKZP1OZ
z;oCdzfbH@U@&76C1KS0G4FD$y&dw}nh(lbzrl;IURKDEagJ7>JRnl?oO`Y!8*H_mk
zr!w_^n0OM(5xAnvz1~B$=4uyXN!g(Ci9IflIsY1InKa~B)JV5iP}-Lf<a)=TA`P#!
z%h+4jh}Uk?-i=MDZ+@Px`&_&jMQ#h5H;Eg5S+}AM+HWqUvKqD7a2b&0lq((76WX@0
zm8JbCijs9?ug~~V-<~@xs{aa8jb43ZPf%Ty-~Mjgk1Au8D_mE|I+5g-^aGc^1S6&X
zBvH!?P7v`_d}GzL{^J@xq>yIv4so68uCJqF3x#&#NTN{n*+yioQJEzOTy)jlh*Lkl
zr$MoaXgW{W<1@5=_pWVl{ruinj+UuOZlZ?~*<IJ~4d$hvxfaC3mI~T~)W;`RF9(>#
zo4(T4OMcb$ZmPRJP0xfz`+9VIzFYg3n>byw@|=@-xfb%6-aBph0ixPi_6qeFY(_?7
zg0J#UlBh_71s+^I;g;GY%hI{5^yyyFY04d!CpyRL1m<sP5=xpIWv6M<&2#~eF!`#L
zQ9Q15vejPjuuRkXr@mTZQjt96&xn$;Cy{G*eI}ly1aoCeySO>0yC{-q4|CqCzL?|s
zF>x#6u7FXan@q^p;0e34iG6~y5S?ly_QavMsW`#wWBcO*9W?r2MW%UK9$VEbZ35#e
zH=j1_b!xKQ5Uq8MNG)<oBUT?bFV-D7dQu_hYUNOn+UxK<dS?ykM>z|og@I8wiqZ6>
zx_|-mtaV`R*^HkWn6`7Obd%SsBjBN`8g{#Zzs><1xW4Zgn51yY%l5ZWChw)8k@6&g
z-MijmDXiLkL5-2si+ILf-3i((`+dQzi=l_>QR0uiRN6m3;E!imJ<THJL>9xl@<wOH
zuQDY^v;H0mk2;cjSMDaJQ=R~kgssargKY+?D>=$-0xfv-6g4)xj5CQEJ1dq<6kGFB
zwlcM>G+B9SX$k(d8JA`II!Q4K0yDdbWKNW26LEqU+fVwWC&%aR&z4AlvMe=&-Iaq~
z+)9_jdvc$Q!XZ9=9b=zkqOq<Y|KPA%7G+NLPR2+}k43O1>pJ&9vJ@Y!%hpWM)94*B
zqh;kjoh(_Ld%@@5u9kj{(jh1&&d=!ItyEc@%-zTvK@HCPp%B~WrFoo3?x=R8T(BQ$
z;(uDEHX+M=+5Sc_H+>R=)#S!1F-<74%ONUr^eWKf0LC&HWM*iGUGUJ~x2}k6wTXE}
zVI1ET=&ND5o552bAh@w>BfY3|GlS~-_^^b+OJxa+u&V-}TX$}fY?(Oc)MlvL<+W>$
zxEYJL(T?yKlB2Q{$+M6O*kT7iTPwp@oGgmEVJ`DPGI;U!6?&@q)+t$YQm4}g%;WiH
z3RG1NOeHx!al2Nfi^5>UmYPM$WhCiX(D(JbeeJ5ZVadwO)Evkc#;Z1s+G!8%%TG|P
zl`A$r;<x>lWq3YmW<c8MBFp!RzEkp;r*4MVzIIA#ay?pFr*RyToz{`Zc@<&ev}oLt
zpxJ*QTjV;h$FQjUh(kpltxT>@n0%I)JH$Mng1yCgk~vHtb1`AM?_9T&`T1T9Q>oza
zSCppe>;@(*FUHtW!Wt$}K4g4E&WWs@HJ=;`Gpx?>fk(MU26*(j?(;ObF_gERlbp<*
zB_&&QPKqTB2D!SibXKYYv-|{&gHGRH0HR@pqkdme!<mRst9LT`m7VB-zk#3NJw#>P
zvss$;?*^k|ah;WoZMw!3;dgU0ef`S&^XE?)!pq|v_h0HvFhBv5vF@uoPAK99D}b9u
zP@Qt?eq)gu!PW*HWq5W$!Q3!4qL{OVs5;K0J%UwEETZhXPCs8n(e3mlUw~=Q_*CLe
zhqW80{qyJ3{<NVuEiEm$H|Y1XgTs7-j*Q#-`T`6*1u+mm)JM2t42(#+>8YuP5>Ys`
zVMO3cXxH3(*{r5qwQY)sI@5V7tui)mUgWo1`Kb2mYrax*af#Cju0a+lNQRhhjGmiM
zT&uO3D+X8%1{+6S#PV?;X?kYnO#k3uk>o=__~6R5!H_&aDak1)6mtS2q<+Hv2_k%o
z?@EjZa$(WPZKDxwy>@p33>=B?z!by&%9~}5UN2YzeosO{ar|cTC^H92J+JHAS)^$&
z|7XLeW?J%_nwFJs5A^nzTue>k9dtwQhKq#mW)@JC{-(NDM}7bt-u3Y#GdsIQ9+y2A
z*WK;wF%t0Emof?;ZHxmH5BC;sXz1KVo^B*Rh3L7fs|$1paCm^=s(!1^c41PCgWcKa
z#Kh|{unPaGrlv+U=i1rg(oeV`?bp=?#$}}V(Z0UYXJA?U7R*j%%f^v!-hiYF{9fuU
zJ;`^&#o0O0?ZlDT>lkrooF?EG&*TXB0W6!geEhz+7;zmHSd=49*p&H=K9+@ujpk(5
zvyCP4YB(1oto!>KA(Y28Wo5w`8PSbN9EL_ye!Huq2D-W>00Tl+)b!c+Z<F&?QaWsD
zUkoAhhi&E{5Eg)5K#b1}{DcqKjbK`S5v%^2G6jY5)uIr56qt7SCv+w&3kp_EAX?gN
zqne+cO~wU?Gn1PW(!G5qzvdE&{{b=6qICL!`&CB#3``|2Mf~i7^IaL`*)HGY591M7
z7r5w<a>6}qvES&Bq=PzOok}rL@IeUH**0`C(t&b2Uc&D!B~#czrVHqMU@Vg@2Jar+
zbmQG&=u5%h+8YVdR19v{s&~x&#evnE5FmD#byQ=x*Bv$x_evfeIp4W<wr?GFpFE#@
zc!4TETo-?R7I8$au1q051X%53cg;deymI}K-SJj;^wOz$PW;Bsjs$hFerFsE;^^mQ
zE+sHN#uHV58(6~44f8yB?Rm^!5TKeYE);fUo-~pgeSC~1t>86jOgGy;1G;bC51(#I
zHC&4J>Q(up$GF6B@sf~$&BDt?w-6u1l@#$|`yiYHZ$RdcF43G9gMhuRMJYHxz$t^P
zSg6TpsWt-^UAUmi!de6KO6=>`DILc=?wWYK_Peb~zUZ*GN|;f5E~3%XB}^A?WkIL0
z--G23ofnH4h}$DaF3cZ7NcpKoopk{4j#D=$`yf&pJRhVT9Lkn7WcJ4_ep8b9%}t+_
z?ypbX-Z^(q^Zuw_vE49UQ$#HCL>}^UDYQ*pS2S$ppLOfqHwIVjJ{Oy651Ng3%{|-}
z^j#I~78hJOq?GJ+T;U6O_JFeO&fUBH-0b!=Os}39js6Ur|M}$G6M@n&`u2SvH)0>7
zxWolog_Y_;`F`$>`7YMUn%dASWYw+*ntP@{N!s4sd0D@5f^k4~$|j~gD0$~Tc?ZgF
zx+>YZ7**p76SI!yc$GdRxaU03&NW^*H`ydWxrbJ6#)XbfIYoOVKf~uLOBoWi!#O;`
nbASI6of7dUfB*BSSVKCKluGwb?*+J#^_;Avl0>1{V~_s;3wvgU

literal 0
HcmV?d00001

diff --git a/website/docs/assets/nuke_fillingExtraAttributes.png b/website/docs/assets/nuke_fillingExtraAttributes.png
new file mode 100644
index 0000000000000000000000000000000000000000..146c4d9db61284233c486a83708a8473969f7e44
GIT binary patch
literal 30953
zcmd43bySsW*EfoVh$x^)my(hSO1Gr6l(f>_APovggMffYgLHR;5+V)K-MMI_>&)fz
zy!q`j&iCipW9+fPz1F?feP8pM^H-Ptax!9f&<W8|P*Cnjhzq|$LAfFZ|Hh)B!k?&=
zz2b-eT(=dHP(*`&T+#IWP*BKGB!mSO9ply~U0iVnCy#b|I@ft?Vg)L12nnJ2CE?$=
z{Rp!qDdnj~?n#p8)w!|(lPsgeSHVWKv`I#>LM;ecbY-l^q5`=oDOaze)1tRv-ShsW
z*QOsaxo&a5(!f6_Q=(@(dym{^%I$3lH|w&ip~GR#a%W6Dg{H%(zDdzM{<WK0-DSgC
zUgT)}9?vb<iytL!Jn5FW;^Dbfe|nch!1pdm<y!Xa(fRull4x=?L(iV&7a7Cx@ETRT
zgN?xa5$m8?6-^)hUOS!7lq>i-^C_PlzByREP5C^gM&^CCvM+kp{7D73XX*vtOS*IK
z0oGEy59D!$V`FN~Vx`7ho)(kUvjzL?)!|(XtU3ZT;kh@DZ4l#n9@gGozURaYcT--n
z@Ny$oVohe&t~gkTOQwzt`^wfwXW0ctWs=7Q*78|u28tPdzWZILXa-YQHiWlkjNtsX
z4@n~PV$433;*FYZ-LMA*1-R~9`b7;mI$VcuWkpylm(6CQlBb`{;;HOTB`^`w;@*0N
z)&0Dztc*5bMVVdXrrfxAPLYZZgD&&o?xD)m%<Ct?hQ%4ZA`KBOlI(jr`Jn<U4bwao
z=W8aS8Rx%}>2K~Xw<Ida6^9WO)O~qpdiqI)n2Um&0!^sn$n_B?o7hb(zuzW7C2N&C
z=)BDJ2XyJ)eVtXD*lvUBGly0^_^f=EcM9BRD83C*iPxokID8`Uw1wddZcjwP=iR}4
zA(oS&-B%L#m>O0)H)F`rf_G0%Z(YYQ<PNg^diVQQs8mSt_2D}&b%uu`iEn?~S&pqq
zF3`AUf+qKLg_5-TIjPdJ?x3O8M1mTI^DUvWqz_$`Vb3`eXr{KU<jHO~RWFB~CQfDg
zN#49Zt09NTX?bJh8kd}xotM`#zw?GI_9;FFqZY2TX2nV6!k3XB!dnNv$6eYaogE1Q
zQ^(Yqf@_$TkHedrE=_e$268^>U3-;;64xrABzU7nLg!U=b1^3Uk-4a6u+!jY7sia*
zy~fc#R;rkq3@L+Sb<2|F)2$vyC+WOP57u<sBXR6Y$Gtp-5QOV&PF~9lf6>B<Lse#O
zCJK4JCbv%RP(*&i_RJ65yy&>_-*YVIWo4C<Of0M{uP-l9?VNd|zThWqR(HQ4|GqyQ
zthaHp-`xDVk3E7swVarFE4p!*Te)xRx81!zHQy0g>PaS-S*H!3LcgZ;eA!pKMS*&_
zP~9<}d_824Q9<d1hR6}oFBIa$y!cy&%8cXF$Q%i;c5`cmq2kZ|KjJc?1q!rWYMs;C
z?vZjUorxJ6zpGd=`TwAxWM{upQtC?YX?W9*7klga2NdGRkJD1J(Q`&!U)skT!HpJV
z(`^!B@{=+qOZpyU;0zx(ZXMp|c#rrxX@U1cz_Wp;0qfII6WOIWITktf(!xDGa{M>_
ztz_&~-OT;{va~<f)=cti4%9a55ls1YON68+=Uca~Bc|9*p8RSw#QPK%7u2KDag)s5
zZ<2Ie&&j@Rr}9dSWQ1#{y4!UsKA&Li&q+hd#vPR8KWY1(4hg*cfL$=$ddh8be02Kg
zp0o5q@fVLhb1j04H<}c`7qj2CUa2h9eZIAEe*Ao1)~8KxZus4_Pr*>Df^1JlqiV}a
zP#8{R6t-m`XPP9V85_~4?3w@JP+gBN5x;RC+bsLsxapK`OT*M+*tCqUodK%0YZc?1
zG$F?I*xEk`;WZOuC+Yml{zH3O9InO6ZoINGch|Cd+&py!g%`B=Gt9RWGgJx`Q4-?$
z6K`f*hNv}=1uizbcr!{kU-3w4d3u#Lpz-8znuc``H9R81>Ful#>CuK4%EH+`GbIg`
zyyFTMVoE!-&&Z^Fy?ViM!c!_JKm3~5+4|%TRnD-l+~DOw2G#eZ=t5OHp3~M?0^)`k
zF-w2lzK>YbI0NBvIy!5&7mt)EQ0hHD<mLF9=HGtqT-AHLwj0Pq!8X*b9bMb_gUsVw
zT~~YcK9MK+<Hr&_f4*Cm+D|*5l5jP*vaamDrw!=Lx2&H{q@RA6ENOUg^s5P_QiG{{
zW8_D+$0EylML!C@ebatW^{lgj0dL#js><^bzN3D2`T@6C-xf99C+7njR@Ejeid$uf
zs9ql$gNtOr_;AXnCm#`2I@{zr8x98>m+#|Rn0IrYrlt<4s|-_M4z;MR+U@R|TFS}2
z{w1v|wiEb1I<^0?Yl9`3W&Z25JWO(ldl8movX_C(LK!(k)=C~HTPvMGsP<{;e`b<z
zrW=o6+AfZ}9<)R$xa^E^G&Gb8hCU?>ZH4uC)2D4)+KkqlqeADQdc@Q3ev0x#0Hy!d
z0c9g&wcv~Vpla9gsIKcDe&Dve)_(HMX8OE=dYRcH8J1AX-T2nM-Yf;0-QBy}u{X(t
zqx2OC559yR_NVcbiU0PvDfyvHi&*BCM7SJI+FKMl#cCzegiAi=F2b%26_556#K~L#
zof(GA?|1{)a)|Z_%I%Y@&G<??d(HFBEkn-{p;4c8*zo0E(9sEYI$wML26|Nqqjvb-
z?;H#wn;R8VHurlj?6LVtIolhnWUZ5CuwvQVx(7}@0!z|A&c5*7o^gA(w~9CZh4oSu
zw==$rU%9r6y9$B7)A3d#o{wkk;I}N}z<1e(@M`^aS_{$$iM0MUBFp@w=Gi2}LkqQu
zV;|p?p_uT2U_^f1$KmM92zxSDVRHP1v7C=$c@^I(@jXNN&V$nEr<S&Qx^%Z^1WPTa
z6R=e@TlNB@<hJME;_C6gpMTBiQhzFwa~U8QZ9AG~%y2e7&G|~B^DH9)MM-}o^2OI&
zdRK;XcYfuPTM=5*C(OH??JDYlSvT_5cXeAGHzHM52I(Woc6V1MbMQP54omiyZHFfh
zd$Vk#?`QL$>EmIbii@w{7Ok)JQH&Me-?;UwSSpXd`Me?KXNP1|F9j!o=Z8k2&C9N5
zpY;AXzX)s}yiz$~AtgHRk$A_^xXm(<E}m)AWtUg0y?v&!w{<2ftxhEEo#BYOhKKY6
zAv$-D4gdA!9<8jVD+0?QBpe#AJ*O|Hy+~yg$LmiBALFFR_Eh5?&rV-d+!&yE98*Vf
zXg#g@F8tFc&)JOW_Mc^eX|<ind4|7NSNcoD1~#S--Teer4sYOFj5gFQ@kTYA-<5l}
z_(7t80_Vi?c8R(W-exRUnqd5`TlQq1f@A9im?fL>gZ`|A;gn6i@V$Gb5HZf{IPn~I
z8-qcK^3Ma!ny?S<boBJAQ@mm3+FJwVvMUp}JV|OAMDC(mRZXB!+RK_1=WiDUJty$o
zJ3U`1$ZJs<Kf5@+cE!ZRWTec69aH*}H__q@&9i2!E)?0M6MKC5v5e$Zu@^4}OyDhd
z%FRtwC68SB%$`2Q=IqjYrqfH5=}<#K_(3{LGGvem=eU7USXFrihhBckyxw!S-Nc~b
z<hkUf<&$vT`{>*2INXQK*0!0oOlT#Xs1*f5rNp5n`yCr+ChJBP1l$2He0;YD2CSO)
zhj$OSO-rx%$%%^yr6p~Pp(MC2an>Jia&IWM4)|Au#SO&s^Mpw!PSwRYpPIuW2Ul!L
z>zAnA`Y42hLmE(B_eesV|D0s|lKsk>{;j&R{#bFPGDnn;cL|8gy1j1L+n@D3@H$#A
z>Df8G7Chu4(Qv!$JObf%-}jJpBc-0><x784yw>u9clUDH1?-Q+`(*Y1w5V!*93;G7
zWUgQ@k$HsJ=s0fQI;>df_@T$fy1!X-<q_(wP)_0r_f|@jT!+(J9(~t6obP;i|HjKa
zR&9tlaoD$uut`!<>ziaW6ETMsijvamU=AKLqf;1n#*|1|4x#S(&o>lyC|Ze_EsKqB
za=BX<cH1>ZG-pqBln^%0(@Hxf1pLJ=`zNWxxz~;minlTAm0!G#>0~}>mY?B}+Hg9P
zCXvo-h*B*{TspW_vD4fs_LLx)n1SJ2`Vg7*TX%B&nWj+wbld1|9=l6TwRdNi=enG+
z6=wR|i`N{N+FB{v9h5motIfG%C<+!&a{6QJ4&CG{v`;TkO+1`?hWTlTF>c5s;+J#C
zdhpci^?JX5w0HlrN?mQY+I%_1@zEt?;zxx`z2O1tUdoWV+-v+Ik6Gb^zI16yDu=~-
zZkp8L$LmLHrWeQE4dN1Or1Cv2=O??{*A7jWiLbC(j0x)uGj$C;P*m?_Jc-FMf7^jA
z(Rk8d#K7+$<-&!9@w;A=dt=AHe7kX(_}UM0vA_UA&1K>CJ2$*&i#z8U7JKtdRqhgV
zd|%+scqDPJpy32PD=UlPLj7)qY{G}udBG5y_CmhL4~uHX%3L&uTi-l+(~F2X$hmE_
zeDY<wc0o}2D?f98ox0(a$6Fkn{7j;hi#Ee)mzb(o`c4P-u9e2zmhR@JJ0S_$ltKX*
zzdh7VY@T@1wPgl;z(IfHBV@lpuPT~1+#W3?NU22ijdtKp^!XpxCw|{PqCKuoOo;k)
z^<rgwxWP>P!>1I>BOc+O{o?VN4?jInRLxdT|G1VA`ihwj`xNi@s(_M*nzmr1zJLgN
zmU!};rupQ&`*-C;&{5SChmZ3sGtpwtoB2W?EH2jWjG1O;O4ZxaZHy(J=_@Si>#t9b
z|Jl#O`?Dc-dUS*vy}IvMxiMsYHk}%3GxPllwRF|}&;kqLF*BB(pQZ)jU%$3bWF*e!
zMbgKT2nQTl>zkW10xhULRORcDt@d=+d{<oX%_q$1<)eEP1Ddf8`;mD4T68mYnu2jk
zO2K9fXpJ!oHcIyuW!EJi;lHXn9#Vf_z3GtF@AP}WX40aXii*7^A=mVHtKr2Dtd6J#
ziM)cScNhE28k>Y036V-lgA+WP$`;i-qRRPd0JK6YVw8;sz8;e08??@boKaJJ^qt<8
zCo)MtzBN-YK$?^N(#ihQFn{#X-XBFav*Rz1GLFJ($m8g7;_oVcT8Pq?%wb>YBa-Ps
zYv5(tEd8vIn4*xme|qe3`TC<whH!H>`^t`E-586=u$|1cl*<uLER3+dO>CyxBzD<}
z1mU>6<A~_}NEKg4J=Hr62`s1{s}5Sn8hsXW578P&Glq%Ke1ydLOD-P=+)eHCOIeXI
zQZ2oF&XumIxb$|2Uy@*Cvc>jLTcDyl_;P?c*_K=25tet?DG$%Cf#)gpv`~OMneA{T
z=h8j)I4o~l|30(q8Xn2;<_6J=$80X^4C-conpIv=6>ZUKOt-dmt@3WS?ci`~IJ$*J
zFI@K$?5sv9xUBI`)#&^)UhrL`E<Qs!s^rvfMdo&6m1xw1tM2?sk2=u9Dg8ZKFLU_S
zCcns(V<~(*s<QA5Mh`z)67yla%u4=AByh*4@O7ug6ivvLEL1LW-=o8WrrJ^oTt-nr
z4&NJBukcvl6{ozwX2oXfO<6!Am!z8<_o+N-B=>S@`?HqPs*`#8FqoM<Ooe!^qZZ}z
zLTj!ST{TV@$D55D3vDLLI(0aZXqvR3rA;2oJCWu&PNR~hTX_@5vfup=AFL80^kRPg
zB<VJs69)DzgoDi}Hn_~GZjA;6nUykCwUqdVAXW-Cy!ZM;^sv9bVEzB=7o+`!qd)z!
ztcKmhddCe)cL-R#MFMf3>NNWqRCrt*FFz#=rqL)EHCyt*)0!Dlw=^$gprD|5lrT@m
zjwdD~BU6G9>koInF37<i7ba_>uTLc*Au%>jpI`Z*u~7&{@Ak2)v_*~8tk6qINqMDx
z?=|9QMp!p)+`zzp;yE@p=BH0UKyY+^AxbukCu7jsDzB>QB((EPC6pX(8MnnCG+sY2
zIL`$KBklk_ziNqa%Hz@v^)B(R5EAZ{fvo!tM=i`8b}Lv)N=i65I99`&@4~{uer(S+
zRjs51j?}y>h!Re4-Id@wU1wEPqN1Vkee>iOv&XSye$6J=gavy`ON%^$gx{U#@?^Nd
zFEq3jv2U|J@)YG~5W$PBsk+t48g>;eC#qYwZv9yslys@JU6#>uoV@{;;^if&nUoO}
z6ci?ApRl@y!aiwte^|?f5&1>%@N}OM#;{wGlDTfb$AxEf7crD)D!0`g&n@xt<y<%S
z79}rleDVw5SIWvii*#FiSM8)?SbT^qD&JooCtfCdTwbh?6wQ}5uzesGrdj>7(k(19
z?S9G#4{F7Z>mvq1V-%zM%1~bH5S@CN$pb1XD%eXbtgI5UvNY`McoN|#RyC7q(QN$u
ziO)@ku!x8xm6dVFD=ftdhQ$Vk%S=^(=5fE<Y&IziPe|zAoU8$Pp!RgLM#Hx2d1nl(
znCXr5j0`azR1VjpCpjtw)c6=F{i}q{v-{35ye@1TV`aKSxvJ~q6`^vp*9Xez=I7>0
zi|Od-2nS4yUVnM=_G%CRB@aB==9ZSHrb7(H#l<WA8JN@&{xPhE_b^b4UNbn>Y2_-L
zn%45b{aK5K>(b)PAqpA{dXoe(h&euumKd_SpE;U4si_fqq23XS(hm})h>VPccXb-r
zdKEitO$EzjG%fGFWsBVb)D}J;siM`k)D?TnM`(St#P`;H>Nh2$gm$xe$~jS<p&qqv
zrw)3mKlNBdCNpIDj;~9EZ#&l!^EiHLZWcyIM_04s$yKI5KRu*jV~fgC$Vj1uj)RSM
zz3?>yF{h2UxA%2w*@Vs?UN_-;VFsj>W||3N$%L|o6JIGe8*QWr<!SV|*dv4cFICok
z_39plSO_IIcWgia`tRSre|2_J;$w(1(qN$(Nhl~O>8Xk;DKTa}4rojg^x8f>*RXDR
zARg{5lcBrPo9uct>&r-rl?9@WLCNzfnaT%`CGHh7%paaogqv5k5Cl_7eE$6TQ+zy0
z*b!79HTB1g1m}Qn-zedO@VOlrN(_4}tTq*~yoYRmhU-d5+%g@?HSR?Z@b^#7&JHLp
zW?6UOZu)rVh5Tpgn{U==lIHifrW1evenslC{?xoKf!Aes#tXC9{oENIH)*KvmoNC{
zvGZgV-xB`(u|sa4x%qk6+OuiVTA+8#?>qa4hSK0;*zC06iJ2)hB%GbOa@nsndtSNr
ztEXppuCu2H9w=_Xu%wn2sgsivtSpv9_@nyk*9DC<4H-DEy22ZeT<iVv*XrF)tvHC!
zW-&d!FYnFTarxiD#ESQR_~PUCVzhP&ZNShjJv}`I4tf|2_Sq)i(MoFyRaI4}`2?5E
zD%4PQ6WFe=^OU2QwezVCAJ8j5aXYbV@95yPSrBhNX&o+c+|fa9Xfrd0fD}1J#pV=|
zz?I)=w<{)WZp*Q&)jRDOKx--*HG9N~-bnC>iqb))#-X65Q*_@+E$v=Lzkip3X>Xc+
z%_M9-cr+Fj>ZSy3#Zu&0z2WN6?uv?v#KVO}L~g*w=x@(#VCY=5NghTJX^^QZDfzVM
z2xj!d&MC7nIdauIZ-qL>-WLv}aP5Y2kfOei>U9OBVLB9GoIDPW$dCCQBYhHW%P08F
z^E*k|blKTZjmkNZ0^|bH(!t6VKi(MqIm;kN%ZS!{R$<X$-IpSgr+VgOI96(G$PF#n
zvedbwC?#dCG}?)eyZ$*nTI1^Q8lxB%nSmhI81>EzZ9yz=T45WU>w<nllw$ukzsv<q
zISOIPRDjkyVNv0b`gV4Ls)Oa})2Cy+Xx;Yk#LT~rZ~U~V=uZ_3MP=v3?Iv+=Nc`~O
zYIb(^n3N69q)D>$Z6BdWPs^`3*CmkhI+teQ)*HdQ5@a&CXGb6Vuoh%-&nE_sDVKi0
z@(~XbGKJ}Av<F{N%}YE)D3&HXwU@A4+~!$q7ti^hezU3Cn2IUqoWZrWU%%c!G0V%I
z@WG!$EnIz%5|C2pap?|aAVZF2R6ens=%E!mpMEjj+R@fF`~D^=$Lf*3s=>kf=-4z{
z?46AMTLOZDS0tktI9H2(6l@nGRf_EqLkgsF9GZ)9Ov`FK%i*xgZ{8skhL>GK#dx#&
zJ1vjxb0Q2Fm#w<t72=+~<(`bfLaaKip8K*qf|nQPqgA$sC5ucNm7ic=!FH2lrwQpZ
z3gQ|a+_9Z_CKjc?5ln#Y^M%uvS|%d`+7GG6nYH^lLfh1K%X>K*`%%1q)O>I9i?*(=
zG|d`^jAw15t8~kDoWpaR(Q#o59D2X7rrb}>^Xm@OV9&#Nv(#MVB8i}ue)RC+dpTNR
zsK!7%W{W>go}WMCSk&%_LV+dA`N0q<w4COHJ>Zo>E0xGcA|n5~)JT3{D1OkSMW^V^
z6a38l{Gp|c1XjblnEYpj<yz;;Gk;e5ouDBRb*7OdD2#15lvqyJ`{@U_5HPtwp;J;*
zhet=Zwvu@e7nz%x<+AlBQA&)N1*vGeJ&)(IpX*|u9yp+)rw>HFBC!WK1BuwolH5)Y
z>{fc;2NSWIv^8Woj#V4A6}cR42H`&ys%c(s!sP#!l;jDW2<B1<rGz67=}>{TtdkQb
zipSYJ*)gD$)sZ5KjqwV@y``?RW&X>zN87WYAZoswgpKyLCE$VG`bZeGD-6_Y+1a~o
zG>KNA)QnYF_B8w7SFN^t47(45gzGa5;yswc!i*V3RlmeSNu^suNW%09GWy$KVKb!1
z*h~g!xg6HTX>l4CZHjbS0z?yU!n{=<cr8nraKeCl`^86$zNOHDp81_Z{f;QVw%M_4
zW!Vr|GU(hz01{xJtgf!EPt_55{SZjxb9)ja)fvYb@#cwNi_Q<kK8xe_OlHqJ_^$r<
zX^H_F1q25A2L>X?s-C|7&SuS)P1p0`CxFN{nsmz4DC+NI$R^6r;-tXyb3L4Vw?0wD
zsw3La-u`k9W^e1h`g@BCZXLE4v0XpmMq{|&G5PrT=ouK8F!Gd)P8h|_j@%{V>s%Ym
zxrORAh7r^?TI<9r%d>O6Bbr$(obuycl6HVow2vS6-7|txr&rGXZpIc7AD>6{eQD0P
zBV_t!$!MoE`(!i!#SUh<`8cX)n_i0PaDEU0>qk6o*D%Za<BxBfJ|dA9eL-ys$t64p
zc{w@H7M<BJG19l=<>s!i78s;FQ20wwZ7^A-zCQDZT8XT!<<ZgAje!lpT)TZ$UthoW
z^5RraPp{CppZer*tEbj!FEcaKNbatHjg5_$DrYiN%+_=RSz=G?{;;-egZuf>ZU^(~
zXbFvIYFKVAgDW2yZs3iE=^j69iWI)-3|TT37M7Hs&X0BmmK|!4w+$=zL#N27XLw-X
z%<LXT-1`Mb<i>{?Ae4;da<Klk(fihzVy1|Q2qh)u6Q^ChyQDn7pdw3;V^et(zkUsv
zv@l#7$f6DSKq+zk>J_L3rfA8Wy`yjV<*<(Ew{HVn=Gp#!4W53naesQmSOIKB_+w7T
zZE}a2c&J?@w(-Pmsrrjb_>xzZc}X#A95#M0Es?UB;rH;JGN5`1j!%<tI~Zj=xJ$w%
ze7HH;w`wQ-bI%qb15<y_isR^PuLqE1qfQab2oM7R7HkiyX!n&E%7&2gzO1mAgol;{
zS_}%5V603$7xw-8Ua%S?MY<y!4tWozQ^hcy4>yAcO%_!eP99K4NN~IJC1OG!yEs3U
zkdZNfhrpm(><v8~$TT{Zyo^F?oopiCgk8V%ui~H|Z<12L;F@v?b=VlgCL`-P+L?b$
zPe1?t{WaLK#COF8mha!c9~)GbwnNMuht_m!cR30_IWi(Og%*SG85%6l0~L+;loCiV
z3$^D<<}ME7Q<irh2k?a&o;`HvU_NGvdjM?p3=PHNR1}pWzkK<E+oD&dCXeG&=W=K>
zsvo`c<0hGrWq4tfR_@y2DLkQH#l(G!77}r@n`izf3lXxF0BN(bvm0lv<mBYAtVvmj
zWsfXDo>nSrb0p*z8&@Wtwt*|drtC9nHe)mGXxdBmUB<`c-`a63eP0DLS4v7sIA;GQ
zePa(9w?okS`nn%8d&9IWpge<;7%)BM6%@RN5mcZSszy<?n`O65LH|eMbK4$XF?o6H
zXbqcN!`dFaS_OE}TL5-I<!gXtt6@K=1kd+d-*RkV8P(1+>WL4ve|}4jmYELs&^;BR
zzjTE`cJVnXYBzTJ?Bh)`*H6<I2Nh?>Jst+o@Q%*iVb6r=$H3-M&QnV(Gg)_V8Cb?7
z<`Bq`iN}BP1_h>DY?mm&XNMZ-_1lg-j4#8B8Tt#f`Cq<#39u8cP^-nfv$KPu0Vu31
zDl9P(ZYo@Pnkri3UQuoqN0Ur?i?W7BQ2(kPl!Dnr<=-2Wl9j!gq}v+u?c29c(b2=}
z)}{zWrQoB(`B47faO1BO6y%j2NQ6VPJ3E>Wwc8kr%-5_*$)=0ea(;Z**X!$7LPk#F
z%S*Xv;ySH@sAnE$J7Rz-tIl>ipysGKIb(nl{mxNghVD%v8kAI8`q^o3>8XA@jyboI
z5=Fc5dLs0l?Ch7O#~B$Jsly1s`vCjwxJZC>nT-@)QH|nsSjWc=q*~j9{wMu&EZp(y
z3GDmhxj<%MM2u<;jK+gex|OFHfGJ;sl>9GD`BF*><1ZGBE@ZQuk}@`ajAWHZ)0gMd
zs6FFmY`Dx?onM~n`UM9MR?h_DG74q%7g^7X0<S?s_2N04uyw4P@^d70J9^b`_#at-
zKk^@bkQXy3$jN;lw`|Cx^8KH%wB!_*Z}z-q`aA@90zlO=+>hfM7A)NgWzdK$s#mFj
zTKrB@Ck3qVR2P*kHW;Riyt4AgNejzC$L{iZe!J(-pP%g|Ug}L$T92J>o*zyx!|tnv
zsWxFhtofzO0EoBa`Tj6;BkbkTlrmxH3GJ{>FjZ?WP7n;*^>IN#7-MCozA_o9-@bXX
zPdR#(mOg_e1d?`Fs~{SPlDGBz&mz0kS2!ZZax$e?J^`v@sz1^(===hES5Za9w7}NY
zl?V9F^))^s=wK;uoj|5)Kj5*+KlThts`_4c8Q2ESacWE4@}C^cpG15e&hD`tqqnNk
zSlK^8y>=JYZLDqLq|4gt2aJ?QSZKm-q-)iDq@iM`Y}p?Efy0PFt(k2<%hyL=e>{no
z@omxR8v@2R=J%$OijeeER&FjOPz+!d7k4YT^i@Tp^lP;W%B2;o%NN2E-#ihwx3_O5
z$NmoO$(n;WSFP+Nk>C4j`E7{^>bFnuVIQc`Q@R${0S?Iqc673jz_X8Ooll0kgPuSs
zVYfL!5ZLko;O(rHQ7f{Yjy(k|LFRVyr*G>1>ERYQn_8gGtEv*nWZahs7nhOw3H-&1
zqm-$t&*+<ag#~yQ#CLt!DuL4=zw6`2;EoY~?jJ!Bhvx9(4VH*JP=BDc;o;#>pRnIe
z5Tj;nTmX?)_GWdl8Hcu?no00vG#yTR6zunQ>xcJEoV3YvxB-7}xIEvouF~jC<WEG3
zC{el`oF5BXdB~nc68qSO0(8!iSBeCqnNlKvi_RkjFS)`Vrt6=L@k29T>&8w4R)Eo_
zUdwyCyU1bEBP4A2bE?i|T*}7mlqRm5b@ocm&p28Cr@49YE56kV63h)}EHD%AM71<G
z_X1xl!HSeiL;`fYi#k_ziVhZke}DPtvKH^@xOtDa4*B=rUBw%FrW*B_iOIs2taeZO
z3I4ar%1Wi1E;8(WHaKIYz%D_50bXdxjgw3;d#ij5)G;5nt~XCgV{XNIm#1x%T7z=d
zP5%F`nLSlwEOi1zH^<e=M(*0bSZ-sh|MwcJb}7RM3X5UpxY#pyewmDtADZdiN=UAv
zMvlc%uqiYUwYu+Y&Qek?Kq;2obsz8j?L0x`Po{zF@mSq%I;Cp=rPdkkTa*Dm|FhDk
z;eNabOix<+4q~`qIj5lBWY9U${lpk{`g;LSIojrGd&Ee+n@i4+YJ-JDcxi{^!Nzzi
zk!7v*SUXZkJ8mMofaFc!kvfOdZCr+#J~6W3FCX`%hIn;<2C-@t^p*mKoc|e|3h;^N
zU_@6@S@|~%YS?dr<XCS21>~t6o*nN!2G;`$5BUn$(~XKd29#!uw#(gVNl5}V>5>`!
z@#W*s8UMvV%s&sU+UYza9PixM{m_eBYGM-vC==or(9gV}IDnx%c<^9hX(>D=rVYL<
z=s*h#3x#i+P@&FcAvH7tR2!6{>*Q2aK5!%05pBY>I67TlpM&~?nHeib$Ic!NJ^nY?
z!fa+E-{HqcI)!R^9K?5Fz5s6pI2euu+e@*QCLJZk#g1n?tvkoAG$fMG*kT!V3g7H5
zv;odaqD6<|WYDa}sTe0IV!n3sZnGW>vh@H2M1s6el>RV7{O9I$P|{@+yMZSVThH!2
zAJ%vQ1CMaBV6WxFjoYsq+<8H$Lo$F+z7szHrKqWWzkrzi08NWxh_}9lx`Ty%+LaZE
zC=`Dn&@a(oLZ3b(VI`%Ze9aDkKC!vCXBuxaQ?jz&SB<i+natIwy64+;WuR->z3C3S
zoPt7X<b$ZVIN~zCc$rr7ib>IECQZ=K6_u2B0ESj9CG%{Rnb@q4mC-LQE^-iu_|ebb
zMn@NylA;9tCmP%roI;%zbl7~OqoZoSV>qlI-Ns{reetETlEa|utBA64lmpQ*2q{1W
zka7j69A?w?Bz0P3*kaT5ZqUq;NN?0IF)Tj5Yj?3DjM5)QX0dMTU6|{o#xk;OQ74VI
zdLY2JN79ehxv=Lb=OMc?v_b;|YG5R=)F!PhvsRxXBU@nBH<lXrzb@9h)e*(0+w6y}
z;kG|myYrJstr)}(?EXo2P-r^8KF{ep=SozIgb9v(uJBb!omU<*zI_f(lNA)80w^j_
z`A=fIf{55dkbEFJn+^bq)Ao;>PD?R{rK=vPgZgD^$lK-Q<b*qT;<){0vvU3}$Tyt8
zl%VA2k=in#QzS4Nn=FdWW`6$sK}1_KEGr6OrwUV?d)`-KDhVMaC3BhO`9aHL&_`dK
z&X950`GI_C%Fq6l%bqSE1%eUp1yG=8cPw5-ZWsWVzz7UV2pXmfs9LQ)*i>mCVJ%d?
zdE?%{^(7XwktYdm2dWsTUQq%v)KT*hNYX*ez%W3n&VY-Q)<CW<W&lMOT6i;JUxzLB
zef4#k4wkgEG;g7YFsOw9KLCl;2MG_5fN0GUX=ujiIhVF~LnmO2r!i71c8o5uvaxKz
z=HunYC71gveb;IxyGh<nfCGkh-7he(f5|sQS;fW%*<#`OpcI;qvsu(18$hMBwY3q$
zT>|R5QfQA*1`gkE<_4ce1&m+aqRIy_;KAmk3!SgH(R*d-5V!!6V2_N9_zfxbB=A0_
zqx(&b?^|taGkZO|f3>t(?bRzG2L}h?LnvBCB!gkB^1g3fnSXNYWjLjdjt*=!<mj*2
zs*i<bB))qSlzQxl@kA+xzWlNhwY;%C==4FvoZ;*1W}tbBOG;9(va-(I21!u2WE3_7
zV9TUUl^e5d%dtcZMivd-c>B{Tv%2rjEDKWWwD`}quK|hG2SFS@n^FS6`F2Ia`G)rz
z`sL)8lcIsknyQlorzHZQCtWx2G`?rbr+(r0xNx#>Uyw2#lyrj69I3Xa2h<fhbO$Z5
z38a!>M=#K;uk{w`ioJUE>Q_exl8D%?4fum-143}&sM)u)w6_)G6y@gG`amK4gM(Wv
zDoh#Mp`XOb(A=k%dIKf+tJrl+#~2Vl2B4D9k&$o9)Cho&1*AMX!Wx{8o<Gc~B3S)8
zUa+T1js-HMaRZ_bEC#~d5{C^n;CEF(hhTrg76<*t*UzcQ1tx}>Cg4yz#85DkW;Mza
zqh500`8$q0IJmgsU%q6zB@c(DW}P%<q}88pa!<J(YT}4+GB+G`e^VyQ)2gze0=*yE
z<$-av&c7YZRx%qam2mMwfvQ7dur34L(PDk%H?0^~t#y0~L*yZ#ArX06IyxN?1{pW$
zo*RHpf+THbqs3`Ij$?=X^g*P8?z~Y<l+m9RKhG2Yb*x}-5|n`|fR2EkUk@CoT;V&K
zxdww1ga$HD$7VrYe+xGQY#$X6w(}p_f`$v{h<yMzU_&4U2jE@+2TPz|n~x$d1-uLB
zU}|lx1_FCvVBndW_HuVT0Vverln*8D0WM0*&0Q}gC3_hD`O}Ez#u)D{l)+`=$d`&r
zEr@*+nj$KRMm-i|ucy#0Kqt5b;Bb0NOli<>5jJ;dt5<fm+A!5wo+@Cdr(tgT`e|$^
z0I(>k%lCuH_(^@6eq<}<JPIGkYJR1y3ysV|QAs46Qcsl{3k_)ttV@E9QeCYU$cT?I
z=TKAD@osI)@VtR&ydW_LP#|<Nhw>&YwUu9C6wR%zkfZ%dMbKrqR52J%34Q~GT0q|y
zsr1Y|l6aX6s!#KSvOxmP8=q3BZi4o*<#Fk<F<y7!x0Ur1KHEPl%ajDM70A$mtxp?p
z&-yUt<dgspZ+Pzf-t}btZt;#Hsu0U7<<v?_S^4>*;gn#Bc-gubvPAV~Rh^%3-eYVn
z7bzu{ZH$qE|M}br^LzOh{N!Wgn-`mdX|98<h}25^|2Xpk88GC=NWKA}U*?!Df;DSH
zm<~;T#EcD8SWp5u#*@*yj8@+)Re|W6EFD3)T3e|n!LcV?@!xRHKe>|sfw1mu4%5cD
zG_nU-(DR!<Kz=Cf8|OOGz!sbG7ua8C4^OSR;<4GKIivj-XiJUX3kaMg)CTt=_CH5Q
z!xL1KLV~N?)20eoGBikpCM$L0VJRwH9Ste^hI}ALlP`6yP|N6l>ioxuso~6qQX(Zi
z{o_7jcn@TaGLt%4{_|%)-h2W|4)9~L+8(B2of0BQnf*K9U`unRg>vvDz3vdPJ>wQJ
zE45FAhGA|~RHFam!wsI3l~l$6Z7elj&JdVSpjhmT=!SyJC=p7^i)2@T-6m_^RhUfv
zOU?bHRp*R+#m+{>^xVF)dRg~8VzV#xCQ_b2nr0ggiRHWcs(kZgyTG8PKrqCOpXYX;
z^tp}qN=<DnJ>T|zw<Sy~aK-R>9G|cnbS70-6M|O=5=T{46;c-h<p(G(R5y^;_W-;4
zlV99qvzYh=Na>0=I4nPjECK&uqx-xrF}QPjuyJk80KF3=VUXOAZ4GX-5PtN-huL}8
z_gcYlAm}*l^abAl1=b!f#g6TQ5{6WkUHPUZTJM3%lLm4Pux}VAgM)*=iYM0jo-2ER
zBnwvo@gfXn2;argylBU7Fd{*i1Ir7<FhJG}TD3>tLRaA_$>I2{_GhHhq67b(D<8L@
zc=+%NbQ*ekT@b}9CpR+@GKqZgpyYf3tO1A(=|=^m%-B@Du6N~xNy+Fg9b5e7$5o`B
zD<pIk#I1$YP`<fX%X<IUAd4f19n`U9-F{T1r-om)QiSeszUE_Q=GIv&;Zl5X>HZl+
zjrrQoHTyFF+J#;YTIiSOrnmr_#;zY8A0OwcmV6u;c?~=rP&v1A9p9r6U@icMA3uIP
zThhZv0XE%YM>K`RJ&2p>g9Hqt*XZyD&*<wExK~WrRM4p5<uLG!%j1mpU3lyx5=r=6
zzYON6+y@_Xd?Pq&5F|zr*}*&qpHHXgH8_g^KzF`{tilBC0EF5U$7x%-k5ui!V*>dV
z)*r-e84C-G0edB-mJJ8w;-^c+Gy>=V-^>v79i$grWxH&W*BMotE)C4p^-rG|n5jFx
zFEB+Y#k_uehtiaR?uT@htz#OGGn67yDJ3$q0~k7f*)$a;o=lH$JFNHe5d(rx0eO9_
zCpcXuJ|Kk_*b59V2-(|Ip^N}L<chxw8MslipIe8fWZ%Td+>pe#V^OCqoJy_39994W
z!T>=1!a?2LfjpVc6a3NzH<lveX(i-$D&x%4cHI#H{u7Y$>Fd|Abv}_C{<x$H%jpn?
zjxSQwCs5l)s$wC;4*{&SMbOxS7!TTB|J+F|SGp%#3DQbz2P5>8K0#`qIG7h&1?)QL
zQ`^<E^AX|UjbQb)b#yd=qHa3O1dr&R_4?PG2F_VsB~?}bHa(DGjF&w!q+@@AB<+s7
z?CCQ!nB7*Cndt|jDVW|webs9q3<Dw>Bf?!nwP?Jh2=DMO13ZjW^7b^cvrYE+Z(hB!
z(S$G4JX;M0ve?_V59OjWb^jR#z0Mm_2v|JYvzo0gsGLLJtXd|8SeEDbhG_UVgTu#a
z=d;Y=V3Tbq?{!7)4=Binef}&A8XQ13eYk7J?1n5|!l*A_e!*mE>+Vj6Jqd~n*!JoJ
zB1%dRMC2c>VS+r*Czf+5Jm8`2gFxp$1g6tlVX0kiF-cgIKu%ns#Jrf5nfV45egY&$
zc*IGYFP?*0VPk7c!AA@L9|cK&KylvP-Q}>FK>;g9=ey?>m;@jh7#kapY#jKR$8!C!
z{7)2=7y5sqAkO+t&{%iD!+8Q0DzpOFOkGj;^Da&rPsbHiLBobE3!m`1%p`K?B~PU8
z8VIJ>3Gd&30rvq!4n(<+cZfcw(5l_bYp`&GciU}E#RK0$L29FYsbWM@;e%>kY|wtv
z3JX6$3&l(A8=<pD<HyY7Q>(LCd<m+(<9bmm6h>%k6O8kbQey?-LwX!^Ksgw2D?nIM
zb8|5OMbEVa60jOzfC)<*AOw2?`V-fpY9|PJe;o@zD5cGlYDGYNb~E_T{b8icJJiI2
z@pBS7tf;D4Z8saGZgFJ|mHgk*A6x9kw?kdPgJ8s9W1y;5T0Ok$`=W-Yb=6L^bMckO
z<Z^<GjLX!b&CUs;!1nU|Q1`EUwgj`EyO<%dNPZoY?+6^-9=F5E)^IAx?vV!=LgW87
zm1VCA{PmQ9FFMx^3=It_(MiA}nm?h2WXgZ4QkmI=MLdu^+HsUqQbJJs)cgRFUTQil
zlLG)H96B1nW}x+DYN_SxKSRkvn`YktIK(DfQ}9o#pGVyNOGp6}hUr)J*?i5pJUTb0
zOBW!=>U+eBk1>Y#qm8uxq#(7+AT>Q5RY@s~QewQos^ap<zUh`?IOUmp1KTf3iF>$#
zB5>AX&2n9a304#^EaMu>?1b&YFKm!(dmQk)!h@Dr_r^^??v3rjW^6H%qE_%yCVs}7
zHoxPaa^XummTL#P<@Dvn;lF_5kkRm(o=(=*QMJBmh+kfn4dLH!mYusz{^}Wxi&SVR
zz1nb9kv$?BlwBecJ>zV5K@Nq#C@H1PPc1Mz8!#q?L^#`5=W-qYC9~n_C{Vq|AE|}V
z%t}#TlL-G>dvj(~M#`|pT@dTv_~_oh@R6HWho`r#g0ytkV{LsK>auw88xPSzActy&
zfBp(kj3k{rDt<`t5>6>nM+XUy$Q9+=5Knm+o{Efhfq3+P{34p;!&XpS{7TBc7uDMX
zF|E9W_4fn+0UMbwi9Y(b{$#ZKZnv@OMZvIwmX>>YlhIQoAYyhckQC&I2itqBHmWm~
z5sl_$(0~8<yaZyT(qx`qHS{SWqTfXSHoqlENWB;CV63&Zx6jFXoZJuPzu=f}4dq`P
zH)VWXm?YBQJ`_4{=M1lid8#Ygoc7o91BHY}L)o;&k%^mvQ7pP+Fnc&Teq|$D#*S2P
z_G}wq#5VY<F))81*!^8UTGK&!o|9xt0USU`cF4SVwwzePMvk-+euj_)rqCi67Yuh0
z%~2v~WU2orEU-W^|KMCP-UVa#QM=UtLN>wW5FYzq5QMd+Nhk;D@dB>#gd9(Ank1f{
zDza5V#wKyhB?D}c39F_%z$%aqiD-uc&JD0$EK<f5t6-`Jk@6BkiZMGIIr_=mj|9h+
z|2ww8JwMqueHL=#HZD@)s&?3T=?=D++W`TdmgB>im>3{h;~NHx?U7>_Os@+e@PFd>
zZ-Xl%(Y+m{qtwU>h{xmu{eeFpOnU!Yu}YdGXJJ7Pgru~MEs)bk8$9^A;zPzQYLJ}I
zsKmS;+zmz->>fcwD$X%8wtt-Tkn#8jp+=`-94VO~rM<#JIhVJ|n?yGM2zG?`d@;!k
z_SXg>1!2b(|7GCZa4v*<vv=vIR*6AyRO#>jeuAeu*8zM&WBwUT)Owq__B+JR;7DK&
zVQJ@P?Vb#TCy=f>MBZGXrHvK;Y!CMLp9PD20q{2{izx7rr&LhA-h-JDpOW$jyzt=^
z4&dTPhYgo^JO@qm;hTYUDEI1B<IE2)iUYjwvsQ)htN?O`^6aAB#3cO&DA*G$1fakK
zEP7}F(W^kIUu1ibI%;MBE=KLqTp(x?*hEAfUYLBpSbKP0n3&LkHHr8j7Ry`0$VuN;
z1iA+?;4i?dFayAG&}sktcx)G@DC!-;Z*_g3wm@G6vM>Mo^)Co)0YU?!5Wh3udJW*o
zKRLIzJ>j+~I&5M+`n<(q82m6}o8NI<nQq_*4H8bcAVnccIGDr<5kmlo*N~GJcrbNJ
z9Ay21!TLxVM#MZbzNeyTA34-ylsy5%6u_!y^>JI%p7k}Ue``MeSya}LOcOih29paO
zAE<RGBjx5qP*Nr34JgxYha@PFxB?g&79M`D&sn3wf&|IF!8tdTuaa&V0T~#y+IJJy
zzRJpQsEmmz1ZmB}24$?65Q2OafIRbqGVbX3$OT$xkzuaqrUL-Wz)t<&QjG%Q9w;>6
znH4jL+1&@8^=~-D0=eZS<@~%nbA<|HJQ*qQiz-jna**>6fH3$5(byECMjeO-?XO%n
zHxEybA*4{bUfgj6PG2lz#pC}W?7YWqkylqI+TobkGnP6(tVyB0GsF+V0eB|M(G6$%
zfgR=yq7vcA(AS2gM_~0Na<!rOs%Adi#(!>t15B)SdG9&FWz|}4kkrERa(|u6J98YD
zU!NWl^E!V9Dg#PYCWNB^1LO?0!)`9c<AJmzWZ@V`HEr6cu=O4OLI0WJF<%th66$z>
zhX<<+UM$p`@iICBGxJ}HjNhmk>P$)?lSwI$Y7|g_P=|}WEE`a8S0Hb}>-?v;Jnxcw
z3ryNqP+xV2Q-OU(Jjoo5*6;qC!ej2ygo;UuApp)8@*QeL`+3?83ECIC(PIVvU+F5c
z@R8T+O-8C<g9*2{T#nN3A=e)c>M{kSyeU(QooKKfB{1f^0RNFJSx(%A$K}9G%j4XB
zv*FS`FK`z&9Eobw@vJY||H#ahaSCZL;X!m`=3T=n35+$M-lmJylNSHwUW&-$1Ox;i
zlRvRvcceJ1!O*%v&deOTyKA#qcc=y8ffZN$81W2KbRaMsTPQ#U$c^qy-Kqi116C)n
z2f)YReOQ)Hz!GS=Y&?e<kaOqy1w#8W0RPi5#0SAtn|L?vhBUWFIo51JZ&fc3f{+UY
zNRb(%19k=+bR>^?TlD&Ml}*~vVnG2kcMz1+OnKRqEEHO^f%ik?)(21`P-lES)uolb
zRHS7IZd?pBEjR%YP6;SMxxKwz?LsI)_nUX~rpfT81WG2KENf08G352Kv$6BofN?`Y
zul@>%Ns#x*<Ea?WGY6jvv<bw$)4%?AF$4UrRiNTh^05Od0a5MSP=}0h?t3Tt{-+Ye
zVT#M}`a5vdF})AG(a1pP(a})}iD(IB>Tzc&F;OguOu;Z9mQ<$O@8Z>qH7k!XrDZQ^
z?*VFHq&kWH(EG9L%hP!?-|Z4Ace+RarFZ<r8o){C4BZ>6a?;b&r8PN!J3M;eO$)6J
z6i6D^J?z;|Q<K6!8kCTMOP2^ASQ*6nU`6+TE!yO9iG^7?g9N@&Zeac%>D4XSarGhg
zu@B{Nx~1J4$TIpRG&Ckg@1}_$aYv~Dx#y$>|M*)pMrdk4z2V2wFMln*`kFHGI2j~<
z(K<JNa(&hgJ9QAL*}y%(4T<E?w8DH;i`6fD4kIA0ycn83GR*@f3&NOw&kUk^Mo(00
ztxUjOMz(%lmxF->Nyrks0kUhp>sUc~QC=TPg9uvB>R2=xMD)u1aZn1b`wrRP6o`X?
ziu>#fcO}($q9o7)C@?rPofrvQ-C=V=!rlD>c>`mOr++jYhEVmu#BBv1K_2HubVmy~
zB##*xZ~TMFbVuM{#0>cN-&`Au!mC%6;Cz%lW*N>^P0fplh-iXoE&<LBY!Coem4Z@`
z9GV5<y)<T8K*h)y3=GMnBgNbUk|;>k3Va4_xBUm;qf=n=Y@=k0#$fzM76772kbBzR
zZo(8ZyZn9))5v3aX^F*ZMgW8Z*n?>RWd0zAF(twsSJR?t!7%OPTU=WD4LNOOo)(zY
zNSP@fsJoC51@|i?g%;^ys9V-W{tunTuI}^lXE0|#IM16@v<ICRq+!VYG(m>88yGUA
zK)$7?18YF~LY{2w&I%<*K88PXnR(vUA>~!2B#TECx0xyhh-i@}HyBudwx-E)1_S=)
z@PNRky1fqu-5+4pd-!0OAdr?y26792!xc}kER7T2|2%lA(f$6~O|SqJ6&0<Z%~2zQ
zaW8jTAB}M>dzFL}o3jxqq)WY>s&#^<&gyz(g~US>Rko1oQOZ%42XEpDKDciY5a9z#
z3-enljw1}PC^TGfu+k4UjM!rT(Kb8yK>DA;49L;=!J>@m;700{jE+><(tr~QSA^U+
ziFJ(lIgEVE9&qn|!bpaUFdB?;81=}V@BbSaG-h(l<A0vpG)oTgMM<VAZ-{Xf>9yTM
ziro+^Lrz7f`CxXq$F5BU0FaQf2HiahG`Dig>F)m~`^YIp0yOzw>X5l}<Gv9*Jb<F}
zU?Dd`ik&3}X)%G4a>Jq`7INsePzD#52b(<A*}EENNAI>+7dm6m9zOKO2*O3Xiuy3+
zj*^L|&Y*I^n;d(m@q8Oo(-s?qC#^UQb0cHRLB3YBin{vF9Lg9|jbf<@#&!4$CEkC!
z?(N+<PY}*}e({U<G&&*<1H*UW`<`l`NO8~9*6C)vTf$!b)|4SX)J#}Zl&FM+fB6Og
z9U~JH0CxAWJ3;~jAvezVqXa5!-2+0606LHfh_W&eE=tK&m6g+j#fwWyK-fSwY&BJg
zkN_4!=1D-3yLp#5DK|F=fEaRPL9^hR;rl3R2)7G-#dPtmqUF|s7#D8XP!%zTq*W*I
znSm??7+|^;<D8&kz(A=uaE4C=B_T8WrG^GEBO@au&5$C8_1tw3D#6kKd97+bgxhoT
zm>ets-optmnT!|mIDZp?J|Q7@QQ!p-Pl{+8$dE=Vz2LeEkbeiS2B}aw)M%a#tk<0{
zv_(K-4B|rdNc;+6;`;LqOUz?@q}m0atf@%?YB96}{G7p;kOKg3Z0zE0xh%k2;ez4*
z(NTZU(h&O})AH`@lY@0wiO8?X%*|Z@ODK9_gBgTG<e3PNFwBuAk{$~(7m}6r@bP1R
zI9mYm{e(iT8JKY=f6!kbpJiKHa&fUu?^!R9Hja21HFfnXFoxBt0Q*tH`ID8+`2B?H
zTfw+OPE$mLgr(Cj$SS=yC<M&S&0kk}4UUfsw9eVEF#M30#{n$J70<LT4MDlK&Q3jW
zhjP^`LY9^ckSb2Gp8rAC%Dywq29O@uLbGVm;j|pQfGM~0&6CW<@0)9D0Y_gP;$_63
z++ks%ZV4f}g4hSQYx`i_(zLFBY8-^LJVxFdSKk+Ig^ISvLgXE`FL-?BexQ()&flZc
zEp*#Gc2%3&1dTB}+wCJ?S63I$PV;?GL{0kd0jwbVBYiIrKn%#m*xEqsV!J*LBkmAA
zM;Y^#ri4Wv7#w{1ZgZlLbaWJ;4<rMjX@7wD9b^-7b8`#rh2FDcp?Tk!1*yX!<W6a*
zz{s=*?fwB<Z&76&Mn{l22=Jim^ylmJ#IlD1fPs&K#!z0)Mo2^i>3@dTg#xkHKwcwf
zWmUM1!OPD}Pe+H(>-?<5psUfM0&1}=L8a&Wy;aGr{tVfS{QQtedKDYMZaa|c_(YTF
z8V;+S-y;&-djRtrCZUn75ER<*5O5MGR$viVzOb3AHP82!FxHJf7@M}8qybPul5uq8
zsHl`yTN?+B$+WIl()=PbE$v2Ni_puL0p+=d=sutf_4V}$0>@U!kQwAt6hhqjb8eQ=
zPrxQjnt6vURytM&DjRGvt%8i497%3C)bTr|IJ7Qavd)X-_R8juk3-O42L=>3cpyhl
zNkw%>tw;QwymQFq#nvV1fkY(`HKZ3`51AtHxs5F?mysYcI~#cxY7K!<t#f`JA0J;@
zUT)%X23rZH$<I)aGu^MTvBoAQzuWD(;(7KuS&>i=?gg3~xD00C()0!)bK1K9GUD?L
z!IVb+jTjIaf!o+0P0z~<Za7<H<~f@2s+_by#`p^v9D(x8Uz~1bWM%ooQ%>x+=1z2T
z1}LfuRtTIdi06J+Y&Oc0blRn+p&<qP(V>RdAmI}W4wNOdPFCaJlyF)H!!D5(dQLBs
z1xWfcho{I`Akv6|WEWUSGBVwswjmF_NDAbL;KjMY*C8D(Woyd{z!&x*oNQSIfw<p=
zciJszL1T@iz33P0#QORK5I6wGBGdcGv|CP2ATWP;)H-V}17Wnr1oIzO=UJ|xIaH^<
zk}$fPw(P%X#Q}%kDkmo)oA3d$YkV<a8kS41(7mO#@^Ll*{*p}xS+|;AY&uZpOkNE1
z`uHZ`2|FWJR=&S^@`uwJl3l=3AS=f=P82N4#l;0f92p`3BL(6%N&AG5vVr3$v3!so
z8$00bK)-&qw4%b4?CM{1m&GeLYj%*8mgWPi@~^WcFAPgYb4d_#;}l(WKfnI`DGC7I
zMSiV%>8mLR1e7;6Ht^EwCHsK;lwl8wr#Hti%UIPaGHO<Th9Q`oO$VnIkSEk;p*=@W
zD9wbe>!7wmU4aTI`{Kom&Its^Z*i;IAXrXwJ~4TmT;-ezR~Kx}&KcTnZH60SPINs^
zEU{g0@1F|!NqX5?dt*JidMo5nIswMV!kX*NzZPw(Q0qE$DE;H3(6Qf7T4dzqZRC>i
zJ!0a62+WQoK1JkpG3<UE5rS=Mqlev*7&$(FFCc`5{r<YxLvKHU52;u}!sI{X(H=hf
zG(+o+h5aj!=h2eAgTvh6>Eh}j#TTstI0WaLMnbSk$r12n2s(BO?b!Teb4wri)C;<s
zRvZu)fM?i0G=$6AgB3YLtD{Cc8dG_+ySL|CYXKewh?-GRQD54$arS32hY`nP!}UMG
z<B|J|I3cFX4yMOD<;6cz=5)e-7-_z;-<}aA-=uZnNhn+dYYGOe4{x*6w?JpB+KuvY
zu(cK-BcBY51ONikygoh4{WhqF-?B{_2&Pb-!{1R}i=<*Q2b`$C)ENVNcLx~>2J$m&
z@tZ2+(4_;M^5by6<An&mE5-1*Qpz@j{7kH*#KqriPE<kWG2r090b(4`Y~j>E1eIiz
zoEmu8MtUHjBh5m{+RJHabpuu^WpI+oP>|FiV|kr&I;HR5(PNnC_7hB@=EM5Kx><{M
zsvN_fK0OxX{9^3-1?T`u=1n3Bfn*9Haese5w1SlSdhp+|qpFxGD6S>;WN6j_g2gGQ
zKgnkEErsNhJBWC;bIrG+7*tbuH6dDy`E{k<P}RBaBJLi6{|Gg2%L;;kcz%Aqtah9?
zdcRX0#}uypVwL}ef1xuX=3RAZDUOm7Bx<A*cw+9;$jE^a)HI9S*4&$w*E}aCCIs(K
z9x_OxVUzIsLK7Nn8VO&4r;(eVZ!nN44}QL{TRT#wg2urXGc`E);2@VB{8Ok3rNKgS
zuFt}UbshJFG#q)S`>n05K}j-BZ306RMm_Yuroq}h+(FA<&)C^v@-#MFAR0{SD!~Mf
zV$y5}@Ag#VHzvsl1bV^KDSN|?9P{ye5_Zhql~z~Zdmi+F*EcmKBPxmtxeh2X@FALp
z{GZD=sGUQ244I;WvxFbAvtjcffh3%@2z9@&U~gxKOar;Y`Ir8Q2`L4I2nVYkn!Y-$
zxyDsDdRe#;$es$EHqhh@5-O<VGQTt#f)f@|Z?xobK#?C&@qaX#4jm0rCu4DGt@C|D
zoUy`(bH8DyJ({}i-Y?Dm)OJY<v?ZqK+hAHiLYNPOvGy4}I^?K*SfH(`84PiMa0<MB
zV6{YP;)hqLHP`muw8))!?V6RDlS8!owBj`b1dgFQL9X}d&K-g_bw-^82*8$<M5L!v
zAD4HEunj!40X+zUSV~H|kDh!Kx59ZUyQ%x2kG#hgN5~J2k^}vr@b!Dd|DW3#-uO>1
z7aZ_P)hbwql;IMb`O$-OVLZFPC_3TT#;<X_2M>G}6Gy>7QY3r!MD7@p`(3f@wh&yy
z9P6HHz*HUvV2`TFAD%ow;mzS9@1Zj3FmC=WBV+FuMQ9;-QSPVX(>5K96%cu6|F#hr
z5C9(U*cLL80P$k%`vKatd3kx*9X&lg8F0)J=9F;{_Ig2loyXQ=oKEL0NlD2L)e8G0
zXK$=!8N+wY1!b+R?=F`b3VWI)#l>fk8Y>9yoNx^|n!!Vg2}7vBeLn{o<p%B!@v;w)
zJ_W+0;c>nXFrqt-v#D6W;|nOmumSWg&W_io8xoP$E%;8JaJm_eR{Q{MsspLBAv1*{
zB0dL>2aM|FFbAs+#!QdbR2l;MR|j5+O+iu|=fMN(N&DfQG-fydCSOd`D@zbQSO{jH
z5-1oxY<pqbO7d<S2yYntom7yFPENj(B+K3Z`!}5O6?$F64rzJF^}-1_-zGsYQ;<Bl
zoEc7_q0WG*Hv5stA_-<Zc;i@jc&%_#^cNS04W=6-#rn5B;LsZdX<}!m)c;f3nTKPY
z@Bd$;J*_iSYC?^QrqIYJ36)5DriFy0DM~0rSzC~zv}&=1R)rRnBq@zbp$v*d%ATbx
zh1B=)u5-TUoZofMxqjF6{bR0cuF2@W@6UUAzMk8Ct0}Z$5#t@fqrH3gs;Q~LJ_rYq
zurw8zI`#zx2wr+fbAwX)=^0Oc(qHhh24@-=#24Zilp#17`~(|uyI+OYk8$}?sylX+
zfMLJw5iYisoi#>c80B4V0!K7qnm2VjxfU=8>okQ7gwP5|>*2^?E<Br<IGBBaaEAl%
z4{S@4W6I|&T$o{Z?JCm%)C`6$qQe8Co=9H~<=<DO>Xx_{=7ieFtHrl&nR*ef51muk
zNe{@+ihrTOpn|{Edd+W>CVe<xV0rnHdz*v0ZQ)-EXFo7&aFR`J&e4UCB}W7jn5#6>
zyXPd!_sbfJla2bUS6CP({QbPanQp~vuSO{D8GM_$K!Y=t@tox%T0x3kN@SLOhV2Hv
zJ2^XJPXupDOLYg?<0oLQ#};9|ZXL<e=HSLY7AzR@>DUfMYM%TT@9e{Dt)c6!PL=e?
zJllz%B|@<`Tr}A-*cLd}nrrh@YD2X>#78yI(UmaU38vcm8@0;N?eOA@=4l;S?&oit
z{wAhh`MG|b7Zv9iHwKJ4Y<!_I_yxX#a{6?XN_}=TL(43Ww-%;_sH7y3UEvl`wJ<|1
z!SD)@5z)atk%D_tR4j#Pk$vCoK*XEeel0)$sK@HMX>M<PNk;K*nT1A5_?EI>9J06r
zUY`lJvt*X`s94}Lpjdz2%Nj}tB!mqRh5hEu;SwP1^0@l*kc^}mNT_wWEh1&-&!?3;
z_{0>rof|%<|8vZenCb8eRXN@0qS8o0GW5ocDa&F_9|#e*zt=}y(IFrz18ifjxM+6R
ze3+*DA?H{8{`vc+D@v}$xG9l)W`3WdGgexX<;@G`%)zKis^j@BkL3KT0Tn(<BQ2l%
zJy;>rvn!JMkHo-qI;$6|sjCy^+VT%<D^iiQE>2F3X#4Lv8@%K&MYy?XrgjuJELytx
zwuDo2mEpgj@j-GoM&t#Oks(8Ahw_u(WV2xdR^$D_!I=cv+vBgMI`?0THjMsnj!~md
zdP7m--j0UUaL#4?Ix>l#4X*8()mjj(x8Ciwmnb&M^!N8af8oMiyKDWo-1NR~y4UY!
z-ipKxuZl`OtLsM%B+WfRTFNb@GLeb7k2MaT7FT@ICP~P}wFg?WRu(gP*j74C5kbSo
zJZzHN<0@T8%E-t_OZjSln3kB30Q1Y_=uwCTdT6T~r(?K#p;qmBJG=Y}eK)zCIi9{}
z29h*hwyeRm)6*+G<fV4F%0(+%wP78hUw$Za7~H}Ox@MPhvV3<{ds=_b2`}aku$<}V
zy3xD-Ww4)2id*6g(|w00J2qDiFMmA7+fVQPY14m;4FBU*V*lNcp9@V)OuBpA43+kT
zqJ0}tARj7#Cj&SRdE@axuk7|ndl%H6PDuFe?e13j<Khn?8v5;8eLZ-jFW5Z?H2LDO
zv?}1X!bi4tOuEmgG{f|%4}9b!r^hbq^Y_bchyS4AkJnBNo@8Ia7#+A?i_^Mu?ROzW
za1b9A>0bDAeF8DUF-qmrv%`D*qU(3{2<!|;C36+PM4WjxLr1xN4har+Gp{tuzM?F;
zJIq=ecKTlt7AR<KDi|)FJM*0qM&K)5TAj(2HWK(~f{k3fc=282KpuDQm4<}GM7kMz
zj9)$CXvc1~L3_PZXM<Ew=``fLKK;sc#h~N&;g1Rk-o<SZ9&h7JH`O~i&-!HIrq~fy
zGO4k!vI@<yloC>T4Gmlyj02K69*e6uo*v`TNMgb`#vy`GRp+8H&DmMKq%F&ZGgbtC
znL~yR8)lriVW_y$Ae=<1g=x-4Av5OM%ZDV9k+_A{2Y7ym-qb|$Z-7+yBnVr<#9c2B
zT5(Km-S5Uj(QpUW?yOI@z$?f(0PJNFH`MTq^dcYoc3BvoO_%-0kMDkB{a5{kU|tUN
zlNBc{kV|Ro3gkvn_5r1-7gum7JUkn|s!Mxu*7^ihug~r^H8l)#-?9?31;tXt>^N`E
zoZg&^9Px{cj52VmPu}`|6ciB|0j!tzA3q)qw<8)Fa&yJ5dbP2+sKTJ*+0_@k5-KJ{
zJ%oZn4-jZ>^>8OIw}+1(ce5aHhxg=3Uf$^=o3smyidL6}Ezz_0`<zz;hY3=HcFS0M
z^=}d<mSeE+P^|L0{k6PH8Zt0<z1wn3)5R{m96|h|@#P)RZ6~;c_oEg<X^S};b66?v
z6)SL(iG7Z^SbB5yDPV^K@dt6a*43QJt(M9hbDd;?-St=9W2F4=-GNOPC@Q>t#^#VI
zoA+>B|44Cxd0fMx&_$;1jG=CKYg=4naYiu#&9bsmpz(u~UAw(X9!h|b|MaO-U0E1k
zdEC9*6CJ073Neqo88s*(tO$|gQAo;7AA=x@HvB+LNvkZuOC}>c?sG>BkiJx()59~{
zBOtxp0S6~0FiVCUj5N6PI*LmS*n^PLh`1A7>P=xMqNcq6X<el3@XGA)g_}10%7Z~-
zz04J?WV>$j=HD<xiL@L!8;7c#kxB&)r^*q@;Sz<lOKEIMcI92m%Q;V;MC1+ay+`YO
z^q%NwJYXY>+gDwEE*3LSUNYZ^aVk3cV3||b>gPM>A{Zdf;z+X2L{lGgs24;b$X7P7
z$2L+2xbUV_IWt7VK9Tu4Mw^Owy_Lxuqhix)>Qe#_c<WE%XH(1rqoY|=&B>_;yd6&A
zVdm&Tj2IsOa_;OUJEInymDkaciz~=Po!=X&2zQ6*yah<R&d#o4w?Y^U)*&uf5hTQL
zS<>L3XLv3qW({CzRTpJ^iU}qvTRL|AzS79(Xi$SmfK-IJ2e!Y+`1ts2*PWpgJ8gRu
zSNc9)%k$J<6F*^5agK{z4>yldk5d0UaZdI!?7(7HI}wv4RLhUlcHBR-Q2PO&<Sy7a
zZEe}5OOcPPFs_<3Ji@<e>iOy8CjCI!#~`gsMRnj7un7#FNn}S;--BA2IFzL?-P&*5
z_H$?XKQUk9KYyusw!*}OpJco^>DJp?v8ao%r@}zN<sP51IeOWjN$&yUc@=3j+D4Lf
z_M@1rrhO<L!-Fw7Q4SEZeYwc+2T16I58Iw^7&CTk_06IwgJvdFPPTtJ^;?ZhuB#ES
z6P{A&4JI+}uYW3$xS{hLmjWC1b@YYUGUn~I;pJS~R$*Ix$zc+Bj_aF-KE8*MgX3)t
zaVQWR2Htah<+Ah}RJ%tn3~>KfK5E*mSv>>^4rc_)o`|ALP|<n&noD&+6`^>u_W2#8
z@CkTKR8&$LJ)mdEV$Fpilcz(uesd^)Sn;7v+S;o_tZl$5J0!p2Cr1Z|b8&H%U`d9B
zwOJt#804#JY6#jK=V=~m@3-0OaD2d~wB}96CAw-B54pL6Pfx15Zg|A36)S>Ut6w`L
z#g}ujA9~<TGVS{C8w%JYCUJa1($cZB_G*`6$MF$5k;QiXYx8_!5Bs=!0BISdqZH>n
z%TCEej_b@Xc=2L<QqnHN)vM(>Jhdw8AOxKc$Rm<*VhK7V;>4sfsSlsSz>ZAc{>w^|
zelL6Ur2oDdGjrRzXW;X(zH7v4rm#b{HNyS;(E853r%M%A>uy>;PDSPH&71DmgEu`f
zwd-)xelsZOpBWy@6KNLLPgV9*8LfPD+?o3Ke*Ykj<|p@97+}ivedgALkzBrNdWOpP
z`#zn~Jm&8D{{jf!tWWUU%3D0BGrBwbiZJ`5sbvdyMER}bI0D2RyFb?<smV3PWI?zw
zL{qw2c=nJWi@5=&-FJ>W6V{|CuKB1ZlR+gzrYYWi^?d4t$%lvhGOThN7@^7c;Dq@B
z?hNeAOGxX3{e8r!2l2cO)}QNFgWH47s4fjRoBHw4;n`0hz3+pf?zIob%n0@rO$upT
z%%)sqLtEQV%|684H)v(sLnE;e#Dc{><5zg-(P)Nh{Q&eD&(^Eq2aX?~4Obv!*>Lyw
zy|lvvA@nv?hPoU)a)j8~-~q*kx_>n|hHxSYzmBkyiI5|#@X)8u0KlY^)uR}F+m-AY
zK!v6LqIt?NtQTkI2gip@((;l$CpEAr%(dqHs*WOU%&(ORop1?Rs{^$L=YQrF5cYPk
zfo4^!$W})lG;cK(u5Cg@>uqe71B#IqM{=uTCu6~6fL`z9>lApe)g71@h8_23j13mR
zeDDmH6(}LS+Ns}IpY@7I-uQ?{ACXObcL<CT`>L%nyfSy8PB)S1K`~gj`5MS($dE}E
zLnRHD{ub>ub0l}F@a*7A?o!I<Rr9?;`&A4DN)azMj#E^W$f+3Qc0$KX8;F(b*-%yG
zSJN3|*mvJor+p@8AEyL+jgLVWAqtjAnD~3hZke{i3rg)%QEF#!YX{cZN2Ct<Q9-%^
zWpD_zwO&h|&o#$`4GJ18GENc<b8Qrl?faU2ZWM-6{FTrV6#EGhd=^1-Uf2{(%`Vql
z@>ihTya6U!F{pfc7wGjyL8q-3TJyAL+XI*AySlojx6kN!4+nDaz=7#>rod6}sfZZ-
zrSkmQurhnE4&nbLx!(xm&<IN+W^x|SpWucc66^8U-bplCdIVV+A>sC1m6VylKUl}n
zTxYNf81)~p?s{D8V*w6BfbP0<DMR*6+--jq6i61gy%?fm9*|l7^kMIzI-c(7?YQ~B
zyjS^hhwMO4Sm}g>ce`{xO)s(|lZNyw-X|9zvjk2)>o^tS=+KIkSwK@F33#PdJAK!<
zQ|{BY3|Y5;tgNgqAF3_4&_>hYQ75AA{F7>JyL<h{scaa0S*v+g0!zTXaWf?7^mh8t
z&+X+8g%k76lbmARP*-z>oYubK8Z+=50!((vy3#`tNE^%Rcl+_0@A+}umiFqi==4&E
zZ5PdwgG6Z#@JE>a;M%86knVc>-yo$JBi6!Q-(dn$!FS|5gs&Ij`uV}?E$3C1h=sgm
z{>R;GB_yQX#did><QWlQhtVH6(JAS#yn+H~o(2KU0zI3fMy4k1)t7g9xm5xF?Ndvf
z*S!tujzzZD-gT6G3F8nDWeMWO<pVn36904Fnyb%^FI#qFdqyNC1|gHbkFodgXN*Ml
zz7DzkjJ}h;efzq%Wv<Nky(^h_G&tD*!5>e3OC!|ojl|V!>QcO!s}*Ydd9sU&(8ll?
zwG<?LFvI6VGF9*&Lz+LD^^EwCWiTMG6jtGDhM8d*koqW8^C&R(vS(-e$j!S-+#0l$
z0-Yepxq}5h{1=j708{>p7p4Gmf_wdm9nebA=59QGFsxy`s_yj53QLzJbe#58{Uh=D
z1~GqQvguMgPDx2`X`Z&i6~EX;4Jl}1haRZCnbq{Aw1<ub>qzvaNdT2e+<(l!cI$M^
z>!vmX1A~*Xv9TpLgd_pPL&%)w5?4=cA)lpaURe+}bvC1k1Q#xP)rOpQY)^z3x%NMH
zhg88{IQe27_aFYhjTFPE!j5`21($et%V6t^i<^*|wc68{FFluKWLGxzt(Fdp6ZX-!
zukHn_+m?m8yzI5Y3b%w<LRh>mV-!7?P#$R-Q(sk88vf;zLb6MPfM^z<KE4}HNM^i2
zi_3SrTvxz+ME}CW`kNvu%9TXp4t^G-J5mKWE{6;*-H}$hzhY8${-T;%G}-eRcUJ!5
zdh5W>Gz;UOJN6sM?GSr`b{e62HMNo1X>WHG^kvvmvxxAH+^b3))E93FGn(*KAS;TD
z_1FHXT-_WQ?}p?C?R`Y()TjK!D-&0W*b}r2%nO}zgnUz2p0?S=(q~Pb1f3oNH11T?
z#w;60@KHsATWk7~%J)&OTa}r3#x6c%z1^0KF8l8Hl`8`?%kNNZ*6S8wjeM&P!O)<F
ziVOszCti|&Qa=-!$R=W^fw}Z4wu78HboA)1yRW9vq2`>Nt!dCYJ}NTO@^<?S%ksIc
zN2ky%Wo30%-KPou@_hCbGT&nq7KD^itf9=wET&(=5uonqnD1}+{4s(*v*1+$vAS2?
za&WJBG?Wek{^JPb3W}1>%1Gu7akaQBbPu2y-3-q*BqBW2*0#Za{3*Qbm&#!}lFRyt
zwbAcJfBESgC%6FEMKE}R!TM>E-6*1HNc8X7*)umw%eI8QzT?wJ<SW_vfIQ*lgB(I}
z{(sn*O&xe(7%jFCyIu#8gQ3x$wKwg<Mw%0j!ALRuWlwFA;+l~MWh2M4z~MreR-15R
zURnEi7^zKO0NrsREw`GLSD$Q8zu#1IA?|%>gZnOD-|o>DF386=2?rr)3spx83FEWB
zP=PCKR(1^I7n9%+%^?gx-7lVvirOiNDu&4KQp^`ZMFAgnv=#zO9>Ors1@6tCKi{Mw
zquilo#Y(1U(SgZ2R_x8@g57F8pUex-zJkB-#EBCh>s?a)88Q+QmIfEd?G^(aa~|Q_
zQgRvV!V3`Fjgy^i|8l!J$K=oJ7VX#THJ|JZt?y$_`N8dShjn**U^Kaqm(zKw-?bw8
zA9G!|MCh2J+M+6arKO0>tx_9CyTGdI$$Ryq)Z;3f+R#NYMcWz-X!nLZFPw=V5*(Xw
z?b_<g#_{GW=g#fJs6aNe)v-bKlc!f|OUupcqavd&Up@dJ>*q2teE`g-$xlkH`Olu+
zXW&T~_mo8Js#kY>0@x=@mug@?5k6!N$}K78C*4fSU^zR3w#EtuYG>4dC!^ASO_cg!
zcyMqqwU?~BwFX1<DS)@i3W0z$Yh2(r$SNqVKR~TJPOIGNQ()cuMc(zQySod-H!#gw
zZQr?!><2@9zDXnBq*8xJ%Qr;Xf8DGw>uvlJzn-iMpcArGf0xDSBbr@3=6Q^rAt39X
zNN<ngd47HLeDnUBMw+*NU=xH_<cYa6O{HB^%-xzz#v`9vn%LNkqo2_Kp6ZMF19u{O
z-~jMFtvB?6&`v9w+LVob=L|H%6^?!JmEE8FXCv#_kJ7q0&2)<R375pJ=|0lElT4Hl
zV!zRC%;H|}{8#QjaA08K2JU6?DOP38)qL@w{@RA;k)xOC7&%rvdPOtF8vN`G+m||P
z+8hlHpKL7{Z8;0@#9n(8JgGkrh5oNNt;7qJ*^KO!o6VcY*UrG&`ecn)nEBxpU|W@=
zoQd^wkl=hXv*P8aji(mr6fVlQU$;)<f~s3GP;m>D9HQY42hJ+)zEvH0g@tpFGtQke
znA^`uUHQZJEv5n9tAl7YV=&30$SwfNk87<=>p0oX$|auGavkH0LXuadju1hhCaisE
zEW!bWA9e~L1Ah^<rdcQf+v;By1EB<^#w9~Rgnx4V4S#+Y%n0M>&Bi-@OjMf;YB2^n
zG(DcQTJ<<apHB^6KC5s|OAy06W)qh(7?y`ZjXN0ZK0Y+MbqAkS8)}BsHtu6)P=U%<
zJ@|_Z<ubVOq|Vl&<(DkFd@as<u+THI&gee65og*9uP>cKS+Xmh<LcVJyzZ*>Gn%O;
zdw!aXw2dW5+>l~tDlGWRbs3KPyr(C4zN(wbW^%gV1!n}Go!RlC#2NDpc<GW=wk)S8
zPXU&hvNY-ZAfkS+H%>mLx~4aV0?}S@A@;@|aZQYmslrW0F%AD81fB>>s0YWCsLv|Q
z2rE}Mi5E2o1ebu#C^m~$tkA6b+!}P~kS>K=tTN7#n1IZCdcF3EQ%Upyg}zI%|Bhi3
zszelPgb|SuxSUr{v`oz9CJnV%6>ehL<KP97{yT-oL`$n+AxfOMG-x8ATjFZ=q963;
zR`$+${`|p--)yjsNFlC`z?Xz{(j>CMIK&8Tuo&MKCm-c@R$4mlHgk)3_Ox@HrlTs^
zwFY2#M#}l^v$VdGUfjmU$s+~vke10}YVy6AeOIg7z&?C*8G&*=ZloTe3f4%}Gy?b0
zg#gJ-Y=a2=CRAH+prZW=T{*RST9HQR0&3nKGGGw17h^V1TDy)gE~(t@@C%q1^6lLM
zWi<7f>|k6W6Qqn?s_rIMYU`Id@MSy~IV;h3O_{wQ5IgJbM==m$%jKJbM0p?}+{C0T
zGmTF=wLLEmkDYgG2l2>+nH3}dL6EU@;s2Z3K)g;)P7=kskgW+PgN_~*F0trnX0BPB
zudrF%tX7>s0{T<#Vw2kOcx|rs0p00Ua$i37h>nI=7T%cm>*OYH-1avuLs+i8K4o}W
zK<kApA*Xpf$JfDz9@f?E&DA26pQr7g*7Eih@PfZ4gL5^04c!2c7-XGeV)_PVNKWH!
zgmaW}(!}PBeoqtvJvf**X`0iuX=h%so1FYQYio%cjtQ`q)ai~K8Bx-?_YGw8G?x)}
zwzdSL-(9KEGLK)Czzg1?ueiVY)c+de#$V@JQEIV-Kx;kLf(2l(l8Gomv9_}tgJBq#
zg?Hc8Zn6D~6^<=9+b8&Xzit|F1s7s|>e&@jDB~27#|&|WLJhXGh^dxqU-|y88buz1
zb#vW57ea56CAUgR``xwmnvBzzI+RDkvA?9WZLjgY)iL>5t^BIbzvTxUlV4_Nn8raM
zT$Yr*B^NKiCfRS7{P>ODJC;{1PQ842AjJd_(`<Z?1$%PZNd};8Ph>ZbaJW@upc?=+
zoKsl%5O#MfQWOQ<H|?f4Bk81AC1;nt_0j(h8oBVwA`>5mR#9g4)L`L4xu?z&w2nps
z5KvA9zB;lg7DlTzLd&?ga{bB9y`!9t;)NWet!<u}dq{L$95wq!#5w*&wdCQ$PA_d`
zdii$lnCF*U{pPq;*ea?l1grElCa@NbaG<^6WD+BMIxr0<va%MyfcBWWoornyF16)&
zHaULyBr{b~FPeRlHh|t09d3vf@3!{0$CYPBhtAHD1}lzss|4Q3))e#BhLUW-mrUKN
zn&WXcopThbtc<d7R>n_Y2s5)#^{KMf$>e7Vbm`HcjN^<WNjP4ZD?8>5>6=HE0a=wk
z=SyrX&suFcXh*M#tWf_ni&B15q5EnOA+I`Q>efM&1hGeH^&4VlW(LuJh>vh_Nko0%
z!JuE2k7+A^zs=&T<}XLYt=jj3n~Kf4bx)KxBA0R|{GEZz^}Wn)WS#pSsr#y`Q9KzP
z&Cl3M4_nt6RxZhj!i68c*)6de{pBPsHC%-KrMDFo6@fSkJps&>*+|QpPe2Ktsb4O(
zF8}1kl@lPN*&1@KpxUW$$vo~=(N<b?tzpJ*_UW*1S|06cxKD?~+;Tkq)dLo=6#g^(
z(;EeLdLy^niP%`>qzS5bLhLt&Ojxx;-Mz&%#hv@~sFUp5S1(ug+IJKJ5%Drvy^Bhd
zmwaYh_gR}Z-TQsx;oULQ75Ds{-RFlgRW(bYgryt&ELgOiX&Yx}4>X@+s%$i`*k_=o
z(vLrX$6|(~bnYJ}o%9vcL`?sNX-xP3bjqh{{(r?Z|3TgRPd2gt!;c$2UQwKv=aXBF
z@H+GAuz`0O5Z5OlNXXw(uG}wu-=Z?R4GR+TEW!d^1aKZtF3w3G!Ft0o0dDIId*RS;
z_h+f{Pa1NDGRyGMYMj?gh2h05CfVA%eE6Wwp%2>}wId51yP}+S-I-=>ByV}xT<7Ch
z#mfCv*^9Em9hEiLkNzU3asFQ0K}Q3r9)E*e*@gjI_|>oADgXX2@5cW~`3%|?EE8#;
zAt|3Zyto+A$%drVzj8PqqRaQ6(OO6|6qYuu5U@UN89JZ0mo%iFvlUF8FaXXrGAhuE
znG`frYqI&AAM{qyKaE|R(Ebb?8=EC@L3*loFD5TpT8{CV5z61>+GHJUA&8mp$;C6?
ztmI@DW&qYUa=;IIN$2X?P$gM&)0dV%)gATJacUoK8g|Bekw$IsXmAtF?rcm6t{r?A
zxPPf&z;aebJI&CIZNlxs^@#N!LaC8)|5a0)qN1V&MQ3c5I`tr;cHbjnu^+o|fStt;
zK!BrP<;WyOWgkaH?oIK91){$KX&fm4GX-MftFI|Bcf2YJqepimEM{w4jyL9ZowH=)
z)$q;$dilb6O<cdkHqH=6tNMJ~^!mmKXO${~lJj}KoF1e%v5Oc?kbc97A4Ra}qFI_n
z<H5<do{UI)H~vj|IkAU3Kqg*0XM|11B*aFTp5@e;eKQ5!xN+k;)1$odN=`j|Xrk(p
zI#H2eI6QXoN19Hz)lbS54b;@cy(_yXex<4DBkKI{vAz*??bd2I4X`W7X5AgM`RE-D
z5_EHzoP@uG0ye<l*9wOT%*rP<&&fcfao&phXd&i(lSw2?=~NQ;)Meu>^m>UZd~ov%
zd{Kgm`~x;df*?C0&wMiYqQe%L%X!{J)ax>pmUvL&oo8=+8!mNW*L};&6Ch#){)E^i
z);v~xZvwDY@Zo3yjkw{6=V3A0p?>zSlJ}grxHsFL1bTYY)kbcb>K4J^z~4d>s;;`z
zRd}Ls>};t^DBzmobqpFb2+y8OMbyt(%c|^U9w3h-ArdcI`Xdj5H*SCPU3UUCT}sKS
zip(&x*F8(zP1|{2i&w797LBxP*N)-!aEjU4DFci_@2IS&`aajx)GRO3*BzymG4h1E
z?J$Tf%vV2PzK)KDA2Z)t{v+`x2}*%$?{#DJR91M3`X<7j1dWd;nt%2EQ!Ky&D-4N@
zRHU^7GuFP!^5)%MW8YeVR7eSk>bMR>!iRWOL<JvoplIw9EO%f=R7?Y)%Oqx%u-pU5
zAv&NR>V9K+T3cJ7@$muJdT_i5p|zvjNj6le*FIggXNKJ8#va<A8g*@tiCJaB=9(qq
zlVgJ?;nfnKo<OKE%R&}ZZp(!17p@^|HA~gwSYl1GH?hY}R7wemzoAc40yxSd-9ESS
zS-*<kpJg*Q(7KT>jAu~DJ{hmmEGF#dn9=#twvYr2#~c@;=nNAL$<k6?i3#*i5Bnl1
z{_E+vM-ReG@|~n#%}V5eRgCHCW)O@>Ns+0#l`HJVtLhGxKGPYxtp9XwE3STU2i}EU
zdF#80E@H^3_u%(^BC_4qRCyKK9_Iwtu&C9QRK}ZUMXVb=htJDCwNo8ud3TXW(QLSR
zh$)N!z*bHr<_;*i01>Sc0Z2G%QH%3xs#@82QHy7~wfu;v-QY1JG>hCg&xKqDX#P($
zm!8wy+}w-<<8+9%h_*s9;C+*e``zZ(-NQ*BMzwit4jwPB12=(~KNAk@lRowh4a6n~
z%e-}3nRAEclD4NuZ#hlR9IlKJOXb$b9c%$#C3_niVVvSuaq=NfMny$Q>KW1=w;D=I
zQaLUz?rchmS@8G0=bv&*F&7JwH%s#{OWxIW3aJ*pgh2N8>5bDX=)S3SkyAeH*z<<l
zdN@ap+4YOZ)9+^(rH{PAyJA|hE&Q|2Sumy&qC1>}Cf<?SuCH0n=wEn?qUog9ZyW-w
z7yt`iNd70z5tbvK;^ybtL4BP*hm0GYHN3NQ3!{x`j;cxzvC~mTvFll1>uvT>`^%@M
zE<2+_bS+0nhU!$#**!5c<h4OF(ns#IXFcz~lho*Lx#fPy>z+T>>aH1S8QMJjo}U7j
zYCpsN`?SLsCb#JMz4U#5yPL+YnO>1?xA&bhKlA(2BOqGSW`%uz&xG@zRkY1$?mu6m
zQpJs?faJ&PXG--so&Ppa{OvpW+vTIvo>;5tk6sgb-Tl7CDBrmoN;=1S4=@Cu{I8w-
z|9}(zKisWVY-hPCp|Yd1roN~f2>mm?o3+ilkt5El_zd`N+qRNG?afP66Z-DGZWjB>
zE^xq%0BKh}Lj##37nRt!1HZ^sC2Y^H>vTL-;xnLZgW{g24Gjl8W#4`=$owq#yZyA4
VDq4MW`0iqf*?J3R#?G+V@jnmA5kmj~

literal 0
HcmV?d00001

diff --git a/website/docs/assets/nuke_placeHolderNode.png b/website/docs/assets/nuke_placeHolderNode.png
new file mode 100644
index 0000000000000000000000000000000000000000..ac9e83b9d67c5c976c99bb9016a47a9836eadb39
GIT binary patch
literal 4010
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

literal 0
HcmV?d00001

diff --git a/website/docs/assets/nuke_placeholder.png b/website/docs/assets/nuke_placeholder.png
new file mode 100644
index 0000000000000000000000000000000000000000..d899ff742ce32a76317645bcf60fdf256f98b0c8
GIT binary patch
literal 12169
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

literal 0
HcmV?d00001

diff --git a/website/docs/assets/nuke_publishedinstance.png b/website/docs/assets/nuke_publishedinstance.png
new file mode 100644
index 0000000000000000000000000000000000000000..494b9e40a469e2c12b737daf9c65cf5f6b001d63
GIT binary patch
literal 20541
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

literal 0
HcmV?d00001

diff --git a/website/docs/assets/nuke_updatePlaceHolder.png b/website/docs/assets/nuke_updatePlaceHolder.png
new file mode 100644
index 0000000000000000000000000000000000000000..58fac2a7e4c9cbd482c9de7374b0b31661116602
GIT binary patch
literal 30608
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
XvZ_}FZZN?sQ_soEs7Mz|8a@3#;PNPY

literal 0
HcmV?d00001

diff --git a/website/docs/assets/nuke_updateWorkfile.png b/website/docs/assets/nuke_updateWorkfile.png
new file mode 100644
index 0000000000000000000000000000000000000000..aeeebb123f0971938f79f7b086eb291eb99158fa
GIT binary patch
literal 30968
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%0A68dafrch8
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
CMAer7

literal 0
HcmV?d00001


From eebfd22e275bea13b7aa81e5fa0bf0ad89881326 Mon Sep 17 00:00:00 2001
From: Jakub Trllo <jakub.trllo@gmail.com>
Date: Wed, 31 Aug 2022 11:56:24 +0200
Subject: [PATCH 14/15] added nuke specific placeholders

---
 openpype/hosts/nuke/api/lib_template_builder.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/openpype/hosts/nuke/api/lib_template_builder.py b/openpype/hosts/nuke/api/lib_template_builder.py
index 555d942cea7..61baa239285 100644
--- a/openpype/hosts/nuke/api/lib_template_builder.py
+++ b/openpype/hosts/nuke/api/lib_template_builder.py
@@ -146,24 +146,24 @@ def placeholder_window(options=None):
 
 linked_asset : Template loader will look for assets linked
 to current context asset.
-Linked asset are looked in avalon database under field "inputLinks"
+Linked asset are looked in OpenPype database under field "inputLinks"
 """
         ),
         qargparse.String(
             "family",
             default=options.get("family", ""),
             label="OpenPype Family",
-            placeholder="ex: model, look ..."),
+            placeholder="ex: image, plate ..."),
         qargparse.String(
             "representation",
             default=options.get("representation", ""),
             label="OpenPype Representation",
-            placeholder="ex: ma, abc ..."),
+            placeholder="ex: mov, png ..."),
         qargparse.String(
             "loader",
             default=options.get("loader", ""),
             label="Loader",
-            placeholder="ex: ReferenceLoader, LightLoader ...",
+            placeholder="ex: LoadClip, LoadImage ...",
             help="""Loader
 
 Defines what openpype loader will be used to load assets.

From 5d6b672c9b6ec4a0c9bc0f7069041b7d7c06bfa5 Mon Sep 17 00:00:00 2001
From: Jakub Trllo <jakub.trllo@gmail.com>
Date: Wed, 31 Aug 2022 12:08:09 +0200
Subject: [PATCH 15/15] fix knob removement

---
 openpype/hosts/nuke/api/template_loader.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/openpype/hosts/nuke/api/template_loader.py b/openpype/hosts/nuke/api/template_loader.py
index d4a8560c4aa..5ff4b8fc415 100644
--- a/openpype/hosts/nuke/api/template_loader.py
+++ b/openpype/hosts/nuke/api/template_loader.py
@@ -88,8 +88,9 @@ def populate_template(self, ignored_ids=None):
                 nodes.append(node)
 
         for node in processed_nodes:
-            if processed_key in node.knobs():
-                nuke.removeKnob(node, processed_key)
+            knob = node.knob(processed_key)
+            if knob is not None:
+                node.removeKnob(knob)
 
     @staticmethod
     def get_template_nodes():