Repository: WISDEM/ORBIT (language: python)

Issue:
Gbf jacket modules



Discussion / hints:

Fix patch:
diff --git a/.github/workflows/publish-to-pypi.yml b/.github/workflows/publish-to-pypi.yml
index e3f22f15..ee92f5f4 100644
--- a/.github/workflows/publish-to-pypi.yml
+++ b/.github/workflows/publish-to-pypi.yml
@@ -16,7 +16,7 @@ jobs:
         python -m pip install --upgrade pip
         pip install setuptools wheel twine
     - name: Build and publish
-      if: startsWith(github.ref, 'refs/tags')
+      if: startsWith(github.ref, 'refs/tags/v')
       env:
         TWINE_USERNAME: __token__
         TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index d9667610..041152aa 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -12,7 +12,6 @@ repos:
         - id: black
           name: black
           stages: [commit]
-          language_version: python3.7
           exclude: ^ORBIT/api/wisdem
 
 -   repo: https://github.com/pre-commit/pre-commit-hooks
diff --git a/ORBIT/__init__.py b/ORBIT/__init__.py
index c4e8f16a..5d213327 100644
--- a/ORBIT/__init__.py
+++ b/ORBIT/__init__.py
@@ -9,6 +9,7 @@
 from .config import load_config, save_config
 from ._version import get_versions
 from .parametric import ParametricManager
+from .supply_chain import SupplyChainManager
 
 __version__ = get_versions()["version"]
 del get_versions
diff --git a/ORBIT/api/wisdem.py b/ORBIT/api/wisdem.py
index 7689a199..8320e99c 100644
--- a/ORBIT/api/wisdem.py
+++ b/ORBIT/api/wisdem.py
@@ -14,6 +14,8 @@
 class Orbit(om.Group):
     def initialize(self):
         self.options.declare("floating", default=False)
+        self.options.declare("jacket", default=False)
+        self.options.declare("jacket_legs", default=0)
 
     def setup(self):
 
@@ -43,7 +45,15 @@ def setup(self):
         self.set_input_defaults("design_install_plan_cost", 2.5e6, units="USD")
         self.set_input_defaults("boem_review_cost", 0.0, units="USD")
 
-        self.add_subsystem("orbit", OrbitWisdem(floating=self.options["floating"]), promotes=["*"])
+        self.add_subsystem(
+            "orbit",
+            OrbitWisdem(
+                floating=self.options["floating"],
+                jacket=self.options["jacket"],
+                jacket_legs=self.options["jacket_legs"],
+            ),
+            promotes=["*"],
+        )
 
 
 class OrbitWisdem(om.ExplicitComponent):
@@ -51,6 +61,8 @@ class OrbitWisdem(om.ExplicitComponent):
 
     def initialize(self):
         self.options.declare("floating", default=False)
+        self.options.declare("jacket", default=False)
+        self.options.declare("jacket_legs", default=0)
 
     def setup(self):
         """"""
@@ -110,14 +122,14 @@ def setup(self):
         self.add_input("tower_length", 100.0, units="m", desc="Total length of the tower.")
         self.add_input(
             "tower_deck_space",
-            0.0,
+            25.0,
             units="m**2",
             desc="Deck space required to transport the tower. Defaults to 0 in order to not be a constraint on installation.",
         )
         self.add_input("nacelle_mass", 500.0, units="t", desc="mass of the rotor nacelle assembly (RNA).")
         self.add_input(
             "nacelle_deck_space",
-            0.0,
+            25.0,
             units="m**2",
             desc="Deck space required to transport the rotor nacelle assembly (RNA). Defaults to 0 in order to not be a constraint on installation.",
         )
@@ -125,7 +137,7 @@ def setup(self):
         self.add_input("blade_mass", 50.0, units="t", desc="mass of an individual blade.")
         self.add_input(
             "blade_deck_space",
-            0.0,
+            100.0,
             units="m**2",
             desc="Deck space required to transport a blade. Defaults to 0 in order to not be a constraint on installation.",
         )
@@ -158,20 +170,22 @@ def setup(self):
         self.add_input("floating_substructure_cost", 10e6, units="USD", desc="Floating substructure unit cost.")
 
         # Monopile
-        self.add_input("monopile_length", 100.0, units="m", desc="Length of monopile.")
+        self.add_input("monopile_length", 100.0, units="m", desc="Length of monopile (including pile).")
         self.add_input("monopile_diameter", 7.0, units="m", desc="Diameter of monopile.")
         self.add_input("monopile_mass", 900.0, units="t", desc="mass of an individual monopile.")
         self.add_input("monopile_cost", 4e6, units="USD", desc="Monopile unit cost.")
-        self.add_input(
-            "monopile_deck_space",
-            0.0,
-            units="m**2",
-            desc="Deck space required to transport a monopile. Defaults to 0 in order to not be a constraint on installation.",
-        )
+
+        # Jacket
+        self.add_input("jacket_length", 65.0, units="m", desc="Length/height of jacket (including pile/buckets).")
+        self.add_input("jacket_mass", 900.0, units="t", desc="mass of an individual jacket.")
+        self.add_input("jacket_cost", 4e6, units="USD", desc="Jacket unit cost.")
+        self.add_input("jacket_r_foot", 10.0, units="m", desc="Radius of jacket legs at base from centeroid.")
+
+        # Generic fixed-bottom
         self.add_input("transition_piece_mass", 250.0, units="t", desc="mass of an individual transition piece.")
         self.add_input(
             "transition_piece_deck_space",
-            0.0,
+            25.0,
             units="m**2",
             desc="Deck space required to transport a transition piece. Defaults to 0 in order to not be a constraint on installation.",
         )
@@ -213,11 +227,12 @@ def setup(self):
     def compile_orbit_config_file(self, inputs, outputs, discrete_inputs, discrete_outputs):
         """"""
 
-        floating = self.options["floating"]
+        floating_flag = self.options["floating"]
+        jacket_flag = self.options["jacket"]
 
         config = {
             # Vessels
-            "wtiv": "floating_heavy_lift_vessel" if floating else discrete_inputs["wtiv"],
+            "wtiv": "floating_heavy_lift_vessel" if floating_flag else discrete_inputs["wtiv"],
             "array_cable_install_vessel": "example_cable_lay_vessel",
             "array_cable_bury_vessel": "example_cable_lay_vessel",
             "export_cable_install_vessel": "example_cable_lay_vessel",
@@ -281,8 +296,8 @@ def compile_orbit_config_file(self, inputs, outputs, discrete_inputs, discrete_o
             },
             # Phase Specific
             "OffshoreSubstationInstallation": {
-                "oss_install_vessel": "floating_heavy_lift_vessel" if floating else "example_heavy_lift_vessel",
-                "feeder": "floating_barge" if floating else "future_feeder",
+                "oss_install_vessel": "floating_heavy_lift_vessel" if floating_flag else "example_heavy_lift_vessel",
+                "feeder": "floating_barge" if floating_flag else "future_feeder",
                 "num_feeders": int(discrete_inputs["num_feeders"]),
             },
             # Project development costs
@@ -312,7 +327,7 @@ def compile_orbit_config_file(self, inputs, outputs, discrete_inputs, discrete_o
         }
 
         # Unique design phases
-        if floating:
+        if floating_flag:
             config["install_phases"] = {
                 "ExportCableInstallation": 0,
                 "OffshoreSubstationInstallation": 0,
@@ -321,18 +336,25 @@ def compile_orbit_config_file(self, inputs, outputs, discrete_inputs, discrete_o
                 "ArrayCableInstallation": ("MooredSubInstallation", 0.25),
             }
         else:
+            fixedStr = "JacketInstallation" if jacket_flag else "MonopileInstallation"
+
+            if jacket_flag:
+                monopile = config.get("monopile", {})
+                monopile["diameter"] = 10
+                config["monopile"] = monopile
+
             config["design_phases"] += ["ScourProtectionDesign"]
             config["install_phases"] = {
                 "ExportCableInstallation": 0,
                 "OffshoreSubstationInstallation": 0,
                 "ArrayCableInstallation": 0,
-                "MonopileInstallation": 0,
+                fixedStr: 0,
                 "ScourProtectionInstallation": 0,
-                "TurbineInstallation": ("MonopileInstallation", 0.25),
+                "TurbineInstallation": (fixedStr, 0.25),
             }
 
         # Unique vessels
-        if floating:
+        if floating_flag:
             vessels = {
                 "support_vessel": "example_support_vessel",
                 "towing_vessel": "example_towing_vessel",
@@ -351,7 +373,7 @@ def compile_orbit_config_file(self, inputs, outputs, discrete_inputs, discrete_o
         config.update(vessels)
 
         # Unique support structure design/assembly
-        if floating:
+        if floating_flag:
             config["port"] = {
                 "sub_assembly_lines": int(discrete_inputs["num_assembly_lines"]),
                 "turbine_assembly_cranes": int(discrete_inputs["num_port_cranes"]),
@@ -386,19 +408,29 @@ def compile_orbit_config_file(self, inputs, outputs, discrete_inputs, discrete_o
                 "monthly_rate": float(inputs["port_cost_per_month"]),
             }
 
-            config["monopile"] = {
-                "type": "Monopile",
-                "length": float(inputs["monopile_length"]),
-                "diameter": float(inputs["monopile_diameter"]),
-                "deck_space": float(inputs["monopile_deck_space"]),
-                "mass": float(inputs["monopile_mass"]),
-                "unit_cost": float(inputs["monopile_cost"]),
-            }
-
             config["scour_protection_design"] = {
                 "cost_per_tonne": 20,
             }
 
+            if jacket_flag:
+                config["jacket"] = {
+                    "type": "Jacket",
+                    "height": float(inputs["jacket_length"]),
+                    "num_legs": int(self.options["jacket_legs"]),
+                    "deck_space": 4 * float(inputs["jacket_r_foot"]) ** 2,
+                    "mass": float(inputs["jacket_mass"]),
+                    "unit_cost": float(inputs["jacket_cost"]),
+                }
+            else:
+                config["monopile"] = {
+                    "type": "Monopile",
+                    "length": float(inputs["monopile_length"]),
+                    "diameter": float(inputs["monopile_diameter"]),
+                    "deck_space": 0.25*float(inputs["monopile_diameter"]*inputs["monopile_length"]),
+                    "mass": float(inputs["monopile_mass"]),
+                    "unit_cost": float(inputs["monopile_cost"]),
+                }
+
         self._orbit_config = config
         return config
 
diff --git a/ORBIT/core/__init__.py b/ORBIT/core/__init__.py
index 8b6e49c5..2618f713 100644
--- a/ORBIT/core/__init__.py
+++ b/ORBIT/core/__init__.py
@@ -12,3 +12,4 @@
 from .library import loader
 from .components import Crane, JackingSys
 from .environment import OrbitEnvironment as Environment
+from .supply_chain import SubstructureDelivery
diff --git a/ORBIT/core/defaults/process_times.yaml b/ORBIT/core/defaults/process_times.yaml
index 8d3a58e9..1c141c78 100644
--- a/ORBIT/core/defaults/process_times.yaml
+++ b/ORBIT/core/defaults/process_times.yaml
@@ -35,6 +35,18 @@
 "grout_cure_time": 24             # hr
 "grout_pump_time": 2              # hr
 
+# Jackets
+"jacket_fasten_time": 12          # hr
+"jacket_release_time": 6          # hr
+"jacket_lift_time": 4             # hr
+"jacket_lower_time": 8            # hr
+"jacket_grout_time": 8            # hr
+"jacket_pin_template_time": 4     # hr
+"jacket_pile_drive_time": 6       # hr, per leg
+"jacket_position_pile": 6         # hr, per leg
+"jacket_vessel_reposition": 4     # hr, per leg
+"jacket_suction_bucket": 12       # hr, per leg
+
 # Scour Protection
 "drop_rocks_time": 10             # hr
 "load_rocks_time": 4              # hr
diff --git a/ORBIT/core/logic/__init__.py b/ORBIT/core/logic/__init__.py
index 15644401..7c928e57 100644
--- a/ORBIT/core/logic/__init__.py
+++ b/ORBIT/core/logic/__init__.py
@@ -13,4 +13,6 @@
     shuttle_items_to_queue,
     prep_for_site_operations,
     get_list_of_items_from_port,
+    shuttle_items_to_queue_wait,
+    get_list_of_items_from_port_wait,
 )
diff --git a/ORBIT/core/logic/vessel_logic.py b/ORBIT/core/logic/vessel_logic.py
index f86be862..b27a3e78 100644
--- a/ORBIT/core/logic/vessel_logic.py
+++ b/ORBIT/core/logic/vessel_logic.py
@@ -303,3 +303,124 @@ def get_list_of_items_from_port(vessel, port, items, **kwargs):
 
         else:
             raise ItemNotFound(items)
+
+
+@process
+def shuttle_items_to_queue_wait(
+    vessel, port, queue, distance, items, per_trip, assigned, **kwargs
+):
+    """
+    Shuttles a list of items from port to queue.
+
+    Parameters
+    ----------
+    env : Environemt
+    vessel : Vessel
+    port : Port
+    queue : simpy.Resource
+        Queue object to shuttle to.
+    distance : int | float
+        Distance between port and site (km).
+    items : list
+        List of components stored as tuples to shuttle.
+        - ('key', 'value')
+    per_trip : int
+    assigned : int
+    """
+
+    transit_time = vessel.transit_time(distance)
+
+    n = 0
+    while n < assigned:
+
+        vessel.submit_debug_log(message=f"{vessel} is at port.")
+
+        # Get list of items
+        per_trip = max([per_trip, 1])
+        yield get_list_of_items_from_port_wait(
+            vessel, port, items * per_trip, **kwargs
+        )
+
+        # Transit to site
+        vessel.update_trip_data()
+        yield vessel.task(
+            "Transit", transit_time, constraints=vessel.transit_limits
+        )
+        yield stabilize(vessel, **kwargs)
+
+        vessel.submit_debug_log(message=f"{vessel} is at site.")
+
+        # Join queue to be active feeder at site
+        with queue.request() as req:
+            queue_start = vessel.env.now
+            yield req
+
+            queue_time = vessel.env.now - queue_start
+            if queue_time > 0:
+                vessel.submit_action_log("Queue", queue_time, location="Site")
+
+            queue.vessel = vessel
+            active_start = vessel.env.now
+            queue.activate.succeed()
+
+            # Released by WTIV when objects are depleted
+            vessel.release = vessel.env.event()
+            yield vessel.release
+            active_time = vessel.env.now - active_start
+
+            vessel.submit_action_log(
+                "ActiveFeeder", active_time, location="Site"
+            )
+
+            queue.vessel = None
+            queue.activate = vessel.env.event()
+
+            # Transit back to port
+            vessel.at_site = False
+            yield jackdown_if_required(vessel, **kwargs)
+            yield vessel.task(
+                "Transit", transit_time, constraints=vessel.transit_limits
+            )
+
+        n += per_trip
+
+
+@process
+def get_list_of_items_from_port_wait(vessel, port, items, **kwargs):
+    """
+    Retrieves multiples of 'items' from port until full.
+
+    Parameters
+    ----------
+    vessel : Vessel
+    port : Port
+    items : list
+        List of tuples representing items to get from port.
+        - ('key': 'value')
+    port : Port
+        Port object to get items from.
+    """
+
+    with port.crane.request() as req:
+        # Join queue to be active vessel at port
+        queue_start = vessel.env.now
+        yield req
+        queue_time = vessel.env.now - queue_start
+        if queue_time > 0:
+            vessel.submit_action_log("Queue", queue_time)
+
+        for i in items:
+            wait_start = vessel.env.now
+            item = yield port.get(lambda x: x.type == i)
+            wait_time = vessel.env.now - wait_start
+
+            if wait_time > 0:
+                vessel.submit_action_log(f"Wait for {item}", wait_time)
+
+            action, time = item.fasten(**kwargs)
+            vessel.storage.put_item(item)
+
+            if time > 0:
+                yield vessel.task(
+                    action, time, constraints=vessel.transit_limits, **kwargs
+                )
diff --git a/ORBIT/core/supply_chain.py b/ORBIT/core/supply_chain.py
new file mode 100644
index 00000000..0f2f3e1a
--- /dev/null
+++ b/ORBIT/core/supply_chain.py
@@ -0,0 +1,57 @@
+"""Supply chain related infrastructure."""
+
+__author__ = "Jake Nunemaker"
+__copyright__ = "Copyright 2022, National Renewable Energy Laboratory"
+__maintainer__ = "Jake Nunemaker"
+__email__ = "jake.nunemaker@nrel.gov"
+
+from marmot import Agent, process
+
+
+class SubstructureDelivery(Agent):
+    """"""
+
+    def __init__(
+        self, component, num, deilvery_time, port, items, num_parallel=1
+    ):
+        """
+        Creates an instance of `SupplyChain`.
+
+        Parameters
+        ----------
+        component : str
+            Component to be delivered.
+        num : int
+            Number of component sets to be delivered.
+        deilvery_time : int | float
+            Time to between deliveries.
+        num_parallel : int (optional)
+            Number of parallel assembly lines.
+            Default: 1
+        """
+
+        super().__init__(f"{component} Supply Chain")
+
+        self.type = component
+        self.num = num
+        self.delivery_time = deilvery_time
+        self.port = port
+        self.items = items
+        self.num_parallel = num_parallel
+
+    @process
+    def start(self):
+
+        n = 0
+        while n < self.num:
+            yield self.task(
+                f"Delivered {self.num_parallel} {self.type}(s)",
+                self.delivery_time,
+                cost=0,
+            )
+
+            for _ in range(self.num_parallel):
+                for item in self.items:
+                    self.port.put(item)
+
+                n += 1
diff --git a/ORBIT/manager.py b/ORBIT/manager.py
index 5881191a..769a7b9a 100644
--- a/ORBIT/manager.py
+++ b/ORBIT/manager.py
@@ -36,6 +36,7 @@
     OffshoreSubstationDesign,
 )
 from ORBIT.phases.install import (
+    JacketInstallation,
     TurbineInstallation,
     MonopileInstallation,
     MooredSubInstallation,
@@ -83,6 +84,7 @@ class ProjectManager:
         MooringSystemInstallation,
         GravityBasedInstallation,
         FloatingSubstationInstallation,
+        JacketInstallation,
     ]
 
     def __init__(self, config, library_path=None, weather=None):
@@ -368,6 +370,12 @@ def merge_dicts(cls, left, right, overwrite=True, add_keys=True):
                 new[k] = cls.merge_dicts(
                     new[k], right[k], overwrite=overwrite, add_keys=add_keys
                 )
+            elif (
+                k in new
+                and isinstance(new[k], list)
+                and isinstance(right[k], list)
+            ):
+                new[k].extend(right[k])
             else:
                 if overwrite or k not in new:
                     new[k] = right[k]
diff --git a/ORBIT/phases/install/__init__.py b/ORBIT/phases/install/__init__.py
index e7dadc7d..46ca4cbf 100644
--- a/ORBIT/phases/install/__init__.py
+++ b/ORBIT/phases/install/__init__.py
@@ -11,6 +11,7 @@
     OffshoreSubstationInstallation,
 )
 from .cable_install import ArrayCableInstallation, ExportCableInstallation
+from .jacket_install import JacketInstallation
 from .mooring_install import MooringSystemInstallation
 from .turbine_install import TurbineInstallation
 from .monopile_install import MonopileInstallation
diff --git a/ORBIT/phases/install/jacket_install/__init__.py b/ORBIT/phases/install/jacket_install/__init__.py
new file mode 100644
index 00000000..a093ed95
--- /dev/null
+++ b/ORBIT/phases/install/jacket_install/__init__.py
@@ -0,0 +1,7 @@
+__author__ = "Jake Nunemaker"
+__copyright__ = "Copyright 2021, National Renewable Energy Laboratory"
+__maintainer__ = "Jake Nunemaker"
+__email__ = "jake.nunemaker@nrel.gov"
+
+
+from .standard import JacketInstallation
diff --git a/ORBIT/phases/install/jacket_install/common.py b/ORBIT/phases/install/jacket_install/common.py
new file mode 100644
index 00000000..4312bfcf
--- /dev/null
+++ b/ORBIT/phases/install/jacket_install/common.py
@@ -0,0 +1,189 @@
+__author__ = "Jake Nunemaker"
+__copyright__ = "Copyright 2021, National Renewable Energy Laboratory"
+__maintainer__ = "Jake Nunemaker"
+__email__ = "jake.nunemaker@nrel.gov"
+
+
+from marmot import false, process
+
+from ORBIT.core import Cargo
+from ORBIT.core.defaults import process_times as pt
+
+
+class Jacket(Cargo):
+    """Jacket Cargo"""
+
+    def __init__(
+        self,
+        height=None,
+        mass=None,
+        deck_space=None,
+        foundation_type="piles",
+        **kwargs,
+    ):
+        """Creats an instance of `Jacket`."""
+
+        self.height = height
+        self.mass = mass
+        self.deck_space = deck_space
+        self.num_legs = kwargs.get("num_legs", 4)
+        self.foundation_type = foundation_type
+
+    @staticmethod
+    def fasten(**kwargs):
+        """Returns time requred to fasten a jacket at port."""
+
+        key = "jacket_fasten_time"
+        time = kwargs.get(key, pt[key])
+
+        return "Fasten Jacket", time
+
+    @staticmethod
+    def release(**kwargs):
+        """Returns time required to release jacket from fastenings."""
+
+        key = "jacket_release_time"
+        time = kwargs.get(key, pt[key])
+
+        return "Release Jacket", time
+
+
+@process
+def install_piles(vessel, jacket, **kwargs):
+    """
+    Process logic for installing piles at site.
+
+    Parameters
+    ----------
+    vessel : Vessel
+    jacket : dict
+    """
+
+    reposition_time = kwargs.get(
+        "jacket_vessel_reposition", pt["jacket_vessel_reposition"]
+    )
+    position_pile_time = kwargs.get(
+        "jacket_position_pile", pt["jacket_position_pile"]
+    )
+    drive_time = kwargs.get(
+        "jacket_pile_drive_time", pt["jacket_pile_drive_time"]
+    )
+    pin_template_time = kwargs.get(
+        "jacket_pin_template_time", pt["jacket_pin_template_time"]
+    )
+
+    num_legs = int(jacket.num_legs)
+
+    yield vessel.task_wrapper(
+        "Lay Pin Template",
+        pin_template_time,
+        constraints=vessel.operational_limits,
+        **kwargs,
+    )
+
+    for i in range(num_legs):
+        yield vessel.task_wrapper(
+            "Position Pile",
+            position_pile_time,
+            constraints={**vessel.operational_limits},
+            **kwargs,
+        )
+
+        yield vessel.task_wrapper(
+            "Drive Pile",
+            drive_time,
+            constraints={**vessel.operational_limits, "night": false()},
+            suspendable=True,
+            **kwargs,
+        )
+
+        if i < (num_legs - 1):
+            yield vessel.task_wrapper(
+                "Move to Next Leg",
+                reposition_time,
+                constraints=vessel.transit_limits,
+                suspendable=True,
+                **kwargs,
+            )
+
+
+@process
+def install_suction_buckets(vessel, jacket, **kwargs):
+    """
+    Process logic for installing suction buckets at site.
+
+    Parameters
+    ----------
+    vessel : Vessel
+    jacket : dict
+    """
+
+    reposition_time = kwargs.get(
+        "jacket_vessel_reposition", pt["jacket_vessel_reposition"]
+    )
+    install_time = kwargs.get(
+        "jacket_suction_bucket", pt["jacket_suction_bucket"]
+    )
+
+    num_legs = int(jacket.num_legs)
+
+    for i in range(num_legs):
+        yield vessel.task_wrapper(
+            "Install Suction Bucket",
+            install_time,
+            constraints={**vessel.operational_limits},
+            **kwargs,
+        )
+
+        if i < (num_legs - 1):
+            yield vessel.task_wrapper(
+                "Move to Next Leg",
+                reposition_time,
+                constraints=vessel.transit_limits,
+                suspendable=True,
+                **kwargs,
+            )
+
+
+@process
+def install_jacket(vessel, jacket, **kwargs):
+    """
+    Process logic for installing a jacket at site.
+
+    Parameters
+    ----------
+    vessel : Vessel
+    jacket : dict
+    """
+
+    if jacket.foundation_type == "piles":
+        yield install_piles(vessel, jacket, **kwargs)
+
+    elif jacket.foundation_type == "suction":
+        yield install_suction_buckets(vessel, jacket, **kwargs)
+
+    else:
+        return ValueError(
+            "Input 'jacket.foundation_type' must be 'piles' or 'suction'."
+        )
+
+    lift_time = kwargs.get("jacket_lift_time", pt["jacket_lift_time"])
+    yield vessel.task_wrapper(
+        "Lift Jacket",
+        lift_time,
+        constraints=vessel.operational_limits,
+        **kwargs,
+    )
+
+    lower_time = kwargs.get("jacket_lower_time", pt["jacket_lower_time"])
+    yield vessel.task_wrapper(
+        "Lower and Position Jacket",
+        lower_time,
+        constraints=vessel.operational_limits,
+        **kwargs,
+    )
+
+    grout_time = kwargs.get("jacket_grout_time", pt["jacket_grout_time"])
+    yield vessel.task_wrapper(
+        "Grout Jacket", grout_time, constraints=vessel.transit_limits, **kwargs
+    )
diff --git a/ORBIT/phases/install/jacket_install/standard.py b/ORBIT/phases/install/jacket_install/standard.py
new file mode 100644
index 00000000..2f8f0c55
--- /dev/null
+++ b/ORBIT/phases/install/jacket_install/standard.py
@@ -0,0 +1,490 @@
+__author__ = "Jake Nunemaker"
+__copyright__ = "Copyright 2021, National Renewable Energy Laboratory"
+__maintainer__ = "Jake Nunemaker"
+__email__ = "jake.nunemaker@nrel.gov"
+
+
+import numpy as np
+import simpy
+from marmot import process
+
+from ORBIT.core import SubstructureDelivery
+from ORBIT.core.logic import (
+    prep_for_site_operations,
+    shuttle_items_to_queue_wait,
+    get_list_of_items_from_port_wait,
+)
+from ORBIT.phases.install import InstallPhase
+from ORBIT.core.exceptions import ItemNotFound
+from ORBIT.phases.install.monopile_install.common import (
+    TransitionPiece,
+    install_transition_piece,
+)
+
+from .common import Jacket, install_jacket
+
+
+class JacketInstallation(InstallPhase):
+    """
+    Standard jacket installation module using a Wind Turbine Installation
+    Vessel (WTIV). If input `feeder` and `num_feeders` are not supplied, the
+    WTIV will perform all transport and installation tasks. If the above inputs
+    are defined, feeder barges will transport completed jackets from port to
+    site vertically.
+    """
+
+    phase = "Jacket Installation"
+    capex_category = "Substructure"
+
+    #:
+    expected_config = {
+        "wtiv": "dict | str",
+        "feeder": "dict | str (optional)",
+        "num_feeders": "int (optional)",
+        "site": {"depth": "m", "distance": "km"},
+        "plant": {"num_turbines": "int"},
+        "turbine": {"hub_height": "m"},
+        "port": {
+            "num_cranes": "int (optional, default: 1)",
+            "monthly_rate": "USD/mo (optional)",
+            "name": "str (optional)",
+        },
+        "jacket": {
+            "height": "m",
+            "deck_space": "m2",
+            "mass": "t",
+            "unit_cost": "USD",
+            "num_legs": "N (optional, default: 4)",
+            "foundation_type": "str (optional, 'piles' | 'suction', default: 'piles')",
+        },
+        "transition_piece": {
+            "deck_space": "m2 (optional)",
+            "mass": "t (optional)",
+            "unit_cost": "USD (optional)",
+        },
+        "jacket_supply_chain": {
+            "enabled": "(optional, default: False)",
+            "substructure_delivery_time": "h (optional, default: 168)",
+            "num_substructures_delivered": "int (optional: default: 1)",
+            "substructure_storage": "int (optional, default: inf)",
+        },
+    }
+
+    def __init__(self, config, weather=None, **kwargs):
+        """
+        Creates an instance of JacketInstallation.
+
+        Parameters
+        ----------
+        config : dict
+            Simulation specific configuration.
+        weather : pd.DataFrame (optional)
+            Weather profile at site.
+            Expects columns 'waveheight' and 'windspeed'.
+        """
+
+        super().__init__(weather, **kwargs)
+
+        config = self.initialize_library(config, **kwargs)
+        self.config = self.validate_config(config)
+
+        self.initialize_port()
+        self.initialize_substructure_delivery()
+        self.initialize_wtiv()
+        # self.initialize_jackets()
+        self.setup_simulation(**kwargs)
+
+    @property
+    def system_capex(self):
+        """Returns procurement cost of the substructures."""
+
+        jacket_unit_cost = self.config["jacket"]["unit_cost"]
+
+        if self.tp:
+            tp_unit_cost = self.config["transition_piece"]["unit_cost"]
+
+        else:
+            tp_unit_cost = 0.0
+
+        return (jacket_unit_cost + tp_unit_cost) * self.config["plant"][
+            "num_turbines"
+        ]
+
+    def initialize_substructure_delivery(self):
+        """
+
+        """
+
+        jacket = Jacket(**self.config["jacket"])
+
+        tp_data = self.config.get("transition_piece")
+        if tp_data:
+            self.tp = TransitionPiece(**tp_data)
+            self.set_mass = jacket.mass + self.tp.mass
+            self.set_deck_space = jacket.deck_space + jacket.deck_space
+
+        else:
+            self.tp = None
+            self.set_mass = jacket.mass
+            self.set_deck_space = jacket.deck_space
+
+        self.num_jackets = self.config["plant"]["num_turbines"]
+        self.supply_chain = self.config.get("jacket_supply_chain", {})
+
+        if self.supply_chain.get("enabled", False):
+
+            items = [jacket, self.tp] if self.tp else [jacket]
+            delivery_time = self.supply_chain.get(
+                "substructure_delivery_time", 168
+            )
+            # storage = self.supply_chain.get("substructure_storage", "inf")
+            supply_chain = SubstructureDelivery(
+                "Jacket",
+                self.num_jackets,
+                delivery_time,
+                self.port,
+                items,
+                num_parallel=self.supply_chain.get(
+                    "num_substructures_delivered", 1
+                ),
+            )
+
+            self.env.register(supply_chain)
+            supply_chain.start()
+
+        else:
+            for _ in range(self.num_jackets):
+                self.port.put(jacket)
+
+                if self.tp:
+                    self.port.put(self.tp)
+
+    def setup_simulation(self, **kwargs):
+        """
+        Sets up simulation infrastructure, routing to specific methods dependent
+        on number of feeders.
+        """
+
+        if self.config.get("num_feeders", None):
+            self.initialize_feeders()
+            self.initialize_queue()
+            self.setup_simulation_with_feeders(**kwargs)
+
+        else:
+            self.feeders = None
+            self.setup_simulation_without_feeders(**kwargs)
+
+    def setup_simulation_without_feeders(self, **kwargs):
+        """
+        Sets up infrastructure for turbine installation without feeder barges.
+        """
+
+        site_distance = self.config["site"]["distance"]
+        site_depth = self.config["site"]["depth"]
+        hub_height = self.config["turbine"]["hub_height"]
+
+        component_list = ["Jacket"]
+        if self.tp:
+            component_list.append("TransitionPiece")
+
+        self.sets_per_trip = int(
+            min(
+                np.floor(self.wtiv.storage.max_cargo_mass / self.set_mass),
+                np.floor(
+                    self.wtiv.storage.max_deck_space / self.set_deck_space
+                ),
+            )
+        )
+
+        solo_install_jackets(
+            self.wtiv,
+            port=self.port,
+            distance=site_distance,
+            jackets=self.num_jackets,
+            site_depth=site_depth,
+            hub_height=hub_height,
+            component_list=component_list,
+            per_trip=self.sets_per_trip,
+            **kwargs,
+        )
+
+    def setup_simulation_with_feeders(self, **kwargs):
+        """
+        Sets up infrastructure for turbine installation using feeder barges.
+        """
+
+        site_distance = self.config["site"]["distance"]
+        site_depth = self.config["site"]["depth"]
+
+        component_list = ["Jacket"]
+        if self.tp:
+            component_list.append("TransitionPiece")
+
+        self.sets_per_trip = int(
+            min(
+                np.floor(
+                    self.feeders[0].storage.max_cargo_mass / self.set_mass
+                ),
+                np.floor(
+                    self.feeders[0].storage.max_deck_space
+                    / self.set_deck_space
+                ),
+            )
+        )
+
+        install_jackets_from_queue(
+            self.wtiv,
+            queue=self.active_feeder,
+            jackets=self.num_jackets,
+            distance=site_distance,
+            site_depth=site_depth,
+            component_list=component_list,
+            **kwargs,
+        )
+
+        assignments = [
+            self.num_jackets // len(self.feeders)
+            + (1 if x < self.num_jackets % len(self.feeders) else 0)
+            for x in range(len(self.feeders))
+        ]
+
+        for assigned, feeder in zip(assignments, self.feeders):
+            shuttle_items_to_queue_wait(
+                feeder,
+                port=self.port,
+                queue=self.active_feeder,
+                distance=site_distance,
+                items=component_list,
+                per_trip=self.sets_per_trip,
+                assigned=assigned,
+                **kwargs,
+            )
+
+    def initialize_wtiv(self):
+        """
+        Initializes the WTIV simulation object and the onboard vessel storage.
+        """
+
+        wtiv_specs = self.config.get("wtiv", None)
+        name = wtiv_specs.get("name", "WTIV")
+
+        wtiv = self.initialize_vessel(name, wtiv_specs)
+        self.env.register(wtiv)
+
+        wtiv.initialize()
+        wtiv.at_port = True
+        wtiv.at_site = False
+        self.wtiv = wtiv
+
+    def initialize_feeders(self):
+        """
+        Initializes feeder barge objects.
+        """
+
+        number = self.config.get("num_feeders", None)
+        feeder_specs = self.config.get("feeder", None)
+
+        self.feeders = []
+        for n in range(number):
+            name = "Feeder {}".format(n)
+
+            feeder = self.initialize_vessel(name, feeder_specs)
+            self.env.register(feeder)
+
+            feeder.initialize()
+            feeder.at_port = True
+            feeder.at_site = False
+            self.feeders.append(feeder)
+
+    def initialize_queue(self):
+        """
+        Initializes the queue, modeled as a ``SimPy.Resource`` that feeders
+        join at site. This limits the simulation to one active feeder at a time.
+        """
+
+        self.active_feeder = simpy.Resource(self.env, capacity=1)
+        self.active_feeder.vessel = None
+        self.active_feeder.activate = self.env.event()
+
+    @property
+    def detailed_output(self):
+        """Returns detailed outputs of the jacket installation."""
+
+        if self.feeders:
+            transport_vessels = [*self.feeders]
+
+        else:
+            transport_vessels = [self.wtiv]
+
+        outputs = {
+            self.phase: {
+                **self.agent_efficiencies,
+                **self.get_max_cargo_mass_utilzations(transport_vessels),
+                **self.get_max_deck_space_utilzations(transport_vessels),
+            }
+        }
+
+        return outputs
+
+
+@process
+def solo_install_jackets(
+    vessel, port, distance, jackets, component_list, **kwargs
+):
+    """
+    Logic that a Wind Turbine Installation Vessel (WTIV) uses during a single
+    jacket installation process.
+
+    Parameters
+    ----------
+    vessel : vessels.Vessel
+        Vessel object that represents the WTIV.
+    port : Port
+    distance : int | float
+        Distance between port and site (km).
+    jackets : int
+        Total number of jackets to install.
+    component_list : list
+        List of components to pick up at port.
+    """
+
+    n = 0
+    while n < jackets:
+        if vessel.at_port:
+            try:
+                # Get substructure + transition piece from port
+                yield get_list_of_items_from_port_wait(
+                    vessel, port, component_list, **kwargs
+                )
+
+            except ItemNotFound:
+                # If no items are at port and vessel.storage.items is empty,
+                # the job is done
+                if not vessel.storage.items:
+                    vessel.submit_debug_log(
+                        message="Item not found. Shutting down."
+                    )
+                    break
+
+            # Transit to site
+            vessel.update_trip_data()
+            vessel.at_port = False
+            yield vessel.transit(distance)
+            vessel.at_site = True
+
+        if vessel.at_site:
+
+            if vessel.storage.items:
+                # Prep for jacket install
+                yield prep_for_site_operations(
+                    vessel, survey_required=True, **kwargs
+                )
+
+                # Get jacket from internal storage
+                jacket = yield vessel.get_item_from_storage("Jacket", **kwargs)
+                yield install_jacket(vessel, jacket, **kwargs)
+
+                # Get transition piece from internal storage if needed
+                if "TransitionPiece" in component_list:
+                    tp = yield vessel.get_item_from_storage(
+                        "TransitionPiece", **kwargs
+                    )
+
+                    yield install_transition_piece(vessel, tp, **kwargs)
+
+                # Submit progress log
+                vessel.submit_debug_log(progress="Substructure")
+                n += 1
+
+            else:
+                # Transit to port
+                vessel.at_site = False
+                yield vessel.transit(distance)
+                vessel.at_port = True
+
+    vessel.submit_debug_log(message="Jacket installation complete!")
+
+
+@process
+def install_jackets_from_queue(
+    wtiv, queue, jackets, distance, component_list, **kwargs
+):
+    """
+    Logic that a Wind Turbine Installation Vessel (WTIV) uses to install
+    jackets and transition pieces from queue of feeder barges.
+
+    Parameters
+    ----------
+    env : simulation.Environment
+        SimPy environment that the simulation runs in.
+    wtiv : vessels.Vessel
+        Vessel object that represents the WTIV.
+    queue : simpy.Resource
+        Queue object to interact with active feeder barge.
+    number : int
+        Total number of jackets to install.
+    distance : int | float
+        Distance from site to port (km).
+    component_list : list
+        List of components to pick up at port.
+    """
+
+    n = 0
+    while n < jackets:
+        if wtiv.at_port:
+            # Transit to site
+            wtiv.at_port = False
+            yield wtiv.transit(distance)
+            wtiv.at_site = True
+
+        if wtiv.at_site:
+
+            if queue.vessel:
+
+                # Prep for jacket install
+                yield prep_for_site_operations(
+                    wtiv, survey_required=True, **kwargs
+                )
+
+                # Get jacket and tp
+                if "TransitionPiece" in component_list:
+                    jacket = yield wtiv.get_item_from_storage(
+                        "Jacket", vessel=queue.vessel, **kwargs
+                    )
+
+                    yield install_jacket(wtiv, jacket, **kwargs)
+
+                    # Get transition piece from active feeder
+                    tp = yield wtiv.get_item_from_storage(
+                        "TransitionPiece",
+                        vessel=queue.vessel,
+                        release=True,
+                        **kwargs,
+                    )
+
+                    # Install transition piece
+                    yield install_transition_piece(wtiv, tp, **kwargs)
+
+                else:
+                    jacket = yield wtiv.get_item_from_storage(
+                        "Jacket", vessel=queue.vessel, release=True, **kwargs
+                    )
+
+                    yield install_jacket(wtiv, jacket, **kwargs)
+
+                # Submit progress log
+                wtiv.submit_debug_log(progress="Substructure")
+                n += 1
+
+            else:
+                start = wtiv.env.now
+                yield queue.activate
+                delay_time = wtiv.env.now - start
+                wtiv.submit_action_log("Delay", delay_time, location="Site")
+
+    # Transit to port
+    wtiv.at_site = False
+    yield wtiv.transit(distance)
+    wtiv.at_port = True
+
+    wtiv.submit_debug_log(message="Jacket installation complete!")
diff --git a/ORBIT/phases/install/monopile_install/common.py b/ORBIT/phases/install/monopile_install/common.py
index 60bec171..04af017a 100644
--- a/ORBIT/phases/install/monopile_install/common.py
+++ b/ORBIT/phases/install/monopile_install/common.py
@@ -6,7 +6,7 @@
 __email__ = "jake.nunemaker@nrel.gov"
 
 
-from marmot import process
+from marmot import false, process
 
 from ORBIT.core import Cargo
 from ORBIT.core.logic import jackdown_if_required
@@ -39,7 +39,7 @@ def fasten(**kwargs):
 
     @staticmethod
     def release(**kwargs):
-        """Returns time required to release tmonopile from fastenings."""
+        """Returns time required to release monopile from fastenings."""
 
         key = "mono_release_time"
         time = kwargs.get(key, pt[key])
@@ -162,11 +162,10 @@ def drive_monopile(vessel, **kwargs):
 
     drive_time = mono_embed_len / mono_drive_rate
 
+    constraints = {**vessel.operational_limits, "whales": false()}
+
     yield vessel.task_wrapper(
-        "Drive Monopile",
-        drive_time,
-        constraints=vessel.operational_limits,
-        **kwargs,
+        "Drive Monopile", drive_time, constraints=constraints, **kwargs
     )
 
 
diff --git a/ORBIT/phases/install/monopile_install/standard.py b/ORBIT/phases/install/monopile_install/standard.py
index 3ed5712e..5a204709 100644
--- a/ORBIT/phases/install/monopile_install/standard.py
+++ b/ORBIT/phases/install/monopile_install/standard.py
@@ -6,14 +6,15 @@
 __email__ = "jake.nunemaker@nrel.gov"
 
 
+import numpy as np
 import simpy
 from marmot import process
 
-from ORBIT.core import Vessel
+from ORBIT.core import SubstructureDelivery
 from ORBIT.core.logic import (
-    shuttle_items_to_queue,
     prep_for_site_operations,
-    get_list_of_items_from_port,
+    shuttle_items_to_queue_wait,
+    get_list_of_items_from_port_wait,
 )
 from ORBIT.phases.install import InstallPhase
 from ORBIT.core.exceptions import ItemNotFound
@@ -64,6 +65,12 @@ class MonopileInstallation(InstallPhase):
             "mass": "t",
             "unit_cost": "USD",
         },
+        "monopile_supply_chain": {
+            "enabled": "(optional, default: False)",
+            "substructure_delivery_time": "h (optional, default: 168)",
+            "num_substructures_delivered": "int (optional: default: 1)",
+            "substructure_storage": "int (optional, default: inf)",
+        },
     }
 
     def __init__(self, config, weather=None, **kwargs):
@@ -76,7 +83,7 @@ def __init__(self, config, weather=None, **kwargs):
             Simulation specific configuration.
         weather : pd.DataFrame (optional)
             Weather profile at site.
-            Expects columns 'max_waveheight' and 'max_windspeed'.
+            Expects columns 'waveheight' and 'windspeed'.
         """
 
         super().__init__(weather, **kwargs)
@@ -85,8 +92,8 @@ def __init__(self, config, weather=None, **kwargs):
         self.config = self.validate_config(config)
 
         self.initialize_port()
+        self.initialize_substructure_delivery()
         self.initialize_wtiv()
-        self.initialize_monopiles()
         self.setup_simulation(**kwargs)
 
     @property
@@ -98,6 +105,44 @@ def system_capex(self):
             + self.config["transition_piece"]["unit_cost"]
         ) * self.config["plant"]["num_turbines"]
 
+    def initialize_substructure_delivery(self):
+        """
+
+        """
+
+        monopile = Monopile(**self.config["monopile"])
+        tp = TransitionPiece(**self.config["transition_piece"])
+        self.set_mass = monopile.mass + tp.mass
+        self.set_deck_space = monopile.deck_space + tp.deck_space
+
+        self.num_monopiles = self.config["plant"]["num_turbines"]
+        self.supply_chain = self.config.get("monopile_supply_chain", {})
+
+        if self.supply_chain.get("enabled", False):
+
+            delivery_time = self.supply_chain.get(
+                "substructure_delivery_time", 168
+            )
+            # storage = self.supply_chain.get("substructure_storage", "inf")
+            supply_chain = SubstructureDelivery(
+                "Monopile",
+                self.num_monopiles,
+                delivery_time,
+                self.port,
+                [monopile, tp],
+                num_parallel=self.supply_chain.get(
+                    "num_substructures_delivered", 1
+                ),
+            )
+
+            self.env.register(supply_chain)
+            supply_chain.start()
+
+        else:
+            for _ in range(self.num_monopiles):
+                self.port.put(monopile)
+                self.port.put(tp)
+
     def setup_simulation(self, **kwargs):
         """
         Sets up simulation infrastructure, routing to specific methods dependent
@@ -122,6 +167,15 @@ def setup_simulation_without_feeders(self, **kwargs):
         site_depth = self.config["site"]["depth"]
         hub_height = self.config["turbine"]["hub_height"]
 
+        self.sets_per_trip = int(
+            min(
+                np.floor(self.wtiv.storage.max_cargo_mass / self.set_mass),
+                np.floor(
+                    self.wtiv.storage.max_deck_space / self.set_deck_space
+                ),
+            )
+        )
+
         solo_install_monopiles(
             self.wtiv,
             port=self.port,
@@ -129,6 +183,7 @@ def setup_simulation_without_feeders(self, **kwargs):
             monopiles=self.num_monopiles,
             site_depth=site_depth,
             hub_height=hub_height,
+            per_trip=self.sets_per_trip,
             **kwargs,
         )
 
@@ -141,6 +196,18 @@ def setup_simulation_with_feeders(self, **kwargs):
         site_depth = self.config["site"]["depth"]
         component_list = ["Monopile", "TransitionPiece"]
 
+        self.sets_per_trip = int(
+            min(
+                np.floor(
+                    self.feeders[0].storage.max_cargo_mass / self.set_mass
+                ),
+                np.floor(
+                    self.feeders[0].storage.max_deck_space
+                    / self.set_deck_space
+                ),
+            )
+        )
+
         install_monopiles_from_queue(
             self.wtiv,
             queue=self.active_feeder,
@@ -150,13 +217,21 @@ def setup_simulation_with_feeders(self, **kwargs):
             **kwargs,
         )
 
-        for feeder in self.feeders:
-            shuttle_items_to_queue(
+        assignments = [
+            self.num_monopiles // len(self.feeders)
+            + (1 if x < self.num_monopiles % len(self.feeders) else 0)
+            for x in range(len(self.feeders))
+        ]
+
+        for assigned, feeder in zip(assignments, self.feeders):
+            shuttle_items_to_queue_wait(
                 feeder,
                 port=self.port,
                 queue=self.active_feeder,
                 distance=site_distance,
                 items=component_list,
+                per_trip=self.sets_per_trip,
+                assigned=assigned,
                 **kwargs,
             )
 
@@ -186,7 +261,6 @@ def initialize_feeders(self):
 
         self.feeders = []
         for n in range(number):
-            # TODO: Add in option for named feeders.
             name = "Feeder {}".format(n)
 
             feeder = self.initialize_vessel(name, feeder_specs)
@@ -197,19 +271,6 @@ def initialize_feeders(self):
             feeder.at_site = False
             self.feeders.append(feeder)
 
-    def initialize_monopiles(self):
-        """
-        Initializes monopile and transition piece objects at port.
-        """
-
-        monopile = Monopile(**self.config["monopile"])
-        tp = TransitionPiece(**self.config["transition_piece"])
-        self.num_monopiles = self.config["plant"]["num_turbines"]
-
-        for _ in range(self.num_monopiles):
-            self.port.put(monopile)
-            self.port.put(tp)
-
     def initialize_queue(self):
         """
         Initializes the queue, modeled as a ``SimPy.Resource`` that feeders
@@ -244,7 +305,6 @@ def detailed_output(self):
 @process
 def solo_install_monopiles(vessel, port, distance, monopiles, **kwargs):
     """
-    TODO:
     Logic that a Wind Turbine Installation Vessel (WTIV) uses during a single
     monopile installation process.
 
@@ -266,7 +326,7 @@ def solo_install_monopiles(vessel, port, distance, monopiles, **kwargs):
         if vessel.at_port:
             try:
                 # Get substructure + transition piece from port
-                yield get_list_of_items_from_port(
+                yield get_list_of_items_from_port_wait(
                     vessel, port, component_list, **kwargs
                 )
 
diff --git a/ORBIT/supply_chain.py b/ORBIT/supply_chain.py
new file mode 100644
index 00000000..b17e2ae8
--- /dev/null
+++ b/ORBIT/supply_chain.py
@@ -0,0 +1,343 @@
+__author__ = ["Jake Nunemaker"]
+__copyright__ = "Copyright 2022, National Renewable Energy Laboratory"
+__maintainer__ = "Jake Nunemaker"
+__email__ = ["jake.nunemaker@nrel.gov"]
+
+
+from copy import deepcopy
+from benedict import benedict
+from ORBIT import ProjectManager
+
+
+
+DEFAULT_MULTIPLIERS = {
+        "blades": {
+            "domestic": .026,
+            "imported": .30
+        },
+        "nacelle": {
+            "domestic": .025,
+            "imported": .10
+        },
+        "tower": {
+            "domestic": .04,
+            "imported": .20,
+            "tariffs": .25,
+        },
+        "monopile": {
+            "domestic": .085,
+            "imported": .28,
+            "tariffs": .25,
+        },
+        "transition_piece": {
+            "domestic": .169,
+            "imported": .17,
+            "tariffs": .25,
+        },
+        "array_cable": {
+            "domestic": .19,
+            "imported": 0.
+        },
+        "export_cable": {
+            "domestic": .231,
+            "imported": 0.
+        },
+        "oss_topside": {
+            "domestic": 0.,
+            "imported": 0.
+        },
+        "oss_substructure": {
+            "domestic": 0.,
+            "imported": 0.
+        },
+    }
+
+
+TURBINE_CAPEX_SPLIT = {
+    "blades": 0.135,
+    "nacelle": 0.274,
+    "tower": 0.162
+}
+
+
+LABOR_SPLIT = {
+    "tower": 0.5,
+    "monopile": 0.5,
+    "transition_piece": 0.5,
+    "oss_topside": 0.5
+}
+
+
+class SupplyChainManager:
+
+    def __init__(self, supply_chain_configuration, **kwargs):
+        """
+        Creates an instance of `SupplyChainManager`.
+
+        Parameters
+        ----------
+        configuration : dict
+        """
+
+        self.sc_config = supply_chain_configuration
+        self.multipliers = kwargs.get("multipliers", DEFAULT_MULTIPLIERS)
+        self.labor_split = kwargs.get("labor_split", LABOR_SPLIT)
+        self.turbine_split = kwargs.get("turbine_split", TURBINE_CAPEX_SPLIT)
+
+    def run_project(self, config, weather=None, **kwargs):
+        """
+        Runs an ORBIT configuration, performing any supply chain related pre
+        and post processing steps on either side of the ORBIT run.
+
+        Parameters
+        ----------
+        config : dict
+            ORBIT Configuration
+        weather : pd.DataFrame | None
+            Weather data to use for the ORBIT simulation.
+        """
+
+        config = benedict(deepcopy(config))
+        config = self.pre_process(config)
+
+        project = ProjectManager(config, weather=weather, **kwargs)
+        project.run()
+
+        project = self.post_process(project)
+
+        return project
+
+    def pre_process(self, config):
+        """"""
+
+        # Save original plant design
+        plant = deepcopy(config['plant'])
+
+        # Run ProjectManager without install phases to generate design results
+        install_phases = config['install_phases']
+        config['install_phases'] = []
+        project = ProjectManager(config)
+        project.run()
+        config = deepcopy(project.config)
+
+        # Replace calculated plant design with original
+        config['plant'] = plant
+
+        # Run pre ORBIT supply chain adjustments
+        config = self.process_turbine_capex(config)
+        config = self.process_monopile_capex(config)
+        config = self.process_transition_piece_capex(config)
+        config = self.process_offshore_substation_topside_capex(config)
+
+        # Add install phases back in
+        config['install_phases'] = install_phases
+        config['design_phases'] = []
+
+        return config
+
+    def post_process(self, project):
+        """"""
+
+        project = self.process_array_cable_capex(project)
+        project = self.process_export_cable_capex(project)
+
+        return project
+
+    # Pre Processing Methods
+    def process_turbine_capex(self, config):
+        """
+        Add blade, nacelle and tower cost adders to input `turbine_capex`.
+
+        Parameters
+        ----------
+        config : dict
+            ORBIT configuration.
+        """
+
+        blade_scenario = self.sc_config['blades']
+        nacelle_scenario = self.sc_config['nacelle']
+        tower_scenario = self.sc_config['blades']
+
+        blade_mult = self.multipliers["blades"].get(blade_scenario, None)
+        if blade_mult == None:
+            print(f"Warning: scenario '{blade_scenario}' not found for category 'blades'.")
+            blade_mult = 0.
+
+        nacelle_mult = self.multipliers["nacelle"].get(nacelle_scenario, None)
+        if nacelle_mult == None:
+            print(f"Warning: scenario '{nacelle_scenario}' not found for category 'nacelle'.")
+            nacelle_mult = 0.
+
+        raw_cost = config.get('project_parameters.turbine_capex', 1300)
+        blade_adder = raw_cost * self.turbine_split['blades'] * blade_mult
+        nacelle_adder = raw_cost * self.turbine_split['nacelle'] * nacelle_mult
+
+        if tower_scenario == "domestic, imported steel":
+            tower_adder = self.multipliers["tower"]["domestic"] * raw_cost
+            tower_tariffs = raw_cost * self.turbine_split['tower'] *\
+                (1 - self.labor_split['tower']) * self.multipliers["tower"]['tariffs']
+
+        else:
+            tower_tariffs = 0.
+            tower_mult = self.multipliers["tower"].get(tower_scenario, None)
+            if tower_mult == None:
+                print(f"Warning: scenario '{tower_scenario}' not found for category 'tower'.")
+                tower_mult = 0.
+
+            tower_adder = raw_cost * self.turbine_split['tower'] * tower_mult
+
+        config['project_parameters.turbine_capex'] = sum([
+            raw_cost,
+            blade_adder,
+            nacelle_adder,
+            tower_adder,
+            tower_tariffs
+        ])
+
+        return config
+
+    def process_monopile_capex(self, config):
+        """
+        Add monopile cost adder and potential tariffs to `monopile.unit_cost`.
+
+        Parameters
+        ----------
+        config : dict
+            ORBIT configuration.
+        """
+
+        raw_cost = config['monopile.unit_cost']
+        scenario = self.sc_config['monopile']
+
+        if scenario == "domestic, imported steel":
+            adder = self.multipliers['monopile']['domestic'] * raw_cost
+            tariffs = raw_cost * (1 - self.labor_split['monopile']) *\
+                self.multipliers["monopile"]['tariffs']
+
+        else:
+            tariffs = 0.
+            mult = self.multipliers["monopile"].get(scenario, None)
+            if mult == None:
+                print(f"Warning: scenario '{scenario}' not found for category 'monopile'.")
+                mult = 0.
+
+            adder = raw_cost * mult
+
+        config['monopile.unit_cost'] = sum([
+            raw_cost,
+            adder,
+            tariffs
+        ])
+
+        return config
+
+    def process_transition_piece_capex(self, config):
+        """
+        Add transition piece cost adder and potential tariffs to
+        `transition_piece.unit_cost`.
+
+        Parameters
+        ----------
+        config : dict
+            ORBIT configuration.
+        """
+
+        raw_cost = config['transition_piece.unit_cost']
+        scenario = self.sc_config['transition_piece']
+
+        if scenario == "domestic, imported steel":
+            adder = self.multipliers['transition_piece']['domestic'] * raw_cost
+            tariffs = raw_cost * (1 - self.labor_split['transition_piece']) *\
+                self.multipliers["transition_piece"]['tariffs']
+
+        else:
+            tariffs = 0.
+            mult = self.multipliers["transition_piece"].get(scenario, None)
+            if mult == None:
+                print(f"Warning: scenario '{scenario}' not found for category 'transition_piece'.")
+                mult = 0.
+
+            adder = raw_cost * mult
+
+        config['transition_piece.unit_cost'] = sum([
+            raw_cost,
+            adder,
+            tariffs
+        ])
+
+        return config
+
+    def process_offshore_substation_topside_capex(self, config):
+        """
+        Add OSS topside cost adder and potential tariffs to
+        `offshore_substation_topside.unit_cost`.
+
+        Parameters
+        ----------
+        config : dict
+            ORBIT configuration.
+        """
+
+        raw_cost = config['offshore_substation_topside.unit_cost']
+        scenario = self.sc_config['oss_topside']
+
+        if scenario == "domestic, imported steel":
+            adder = self.multipliers['oss_topside']['domestic'] * raw_cost
+            tariffs = raw_cost * (1 - self.labor_split['oss_topside']) *\
+                self.multipliers["oss_topside"]['tariffs']
+
+        else:
+            tariffs = 0.
+            mult = self.multipliers["oss_topside"].get(scenario, None)
+            if mult == None:
+                print(f"Warning: scenario '{scenario}' not found for category 'oss_topside'.")
+                mult = 0.
+
+            adder = raw_cost * mult
+
+        config['offshore_substation_topside.unit_cost'] = sum([
+            raw_cost,
+            adder,
+            tariffs
+        ])
+
+        return config
+
+    # Post Processing Methods
+    def process_array_cable_capex(self, project):
+        """
+        Add array cable cost adder.
+
+        Parameters
+        ----------
+        project : ProjectManager
+        """
+
+        scenario = self.sc_config['array_cable']
+        mult = self.multipliers["array_cable"].get(scenario, None)
+        if mult == None:
+            print(f"Warning: scenario '{scenario}' not found for category 'array_cable'.")
+            mult = 0.
+
+        project.system_costs['ArrayCableInstallation'] *= (1 + mult)
+
+        return project
+
+    def process_export_cable_capex(self, project):
+        """
+        Add export cable cost adder.
+
+        Parameters
+        ----------
+        project : ProjectManager
+        """
+
+        scenario = self.sc_config['export_cable']
+        mult = self.multipliers["export_cable"].get(scenario, None)
+        if mult == None:
+            print(f"Warning: scenario '{scenario}' not found for category 'export_cable'.")
+            mult = 0.
+
+        project.system_costs['ExportCableInstallation'] *= (1 + mult)
+
+        return project
diff --git a/README.rst b/README.rst
index b93e376f..db11c217 100644
--- a/README.rst
+++ b/README.rst
@@ -4,7 +4,7 @@ ORBIT
 Offshore Renewables Balance of system and Installation Tool
 
 
-:Version: 1.0.3
+:Version: 1.0.7
 :Authors: `Jake Nunemaker <https://www.linkedin.com/in/jake-nunemaker/>`_, `Matt Shields <https://www.linkedin.com/in/matt-shields-834a6b66/>`_, `Rob Hammond <https://www.linkedin.com/in/rob-hammond-33583756/>`_
 :Documentation: `ORBIT Docs <https://wisdem.github.io/ORBIT/>`_
 
diff --git a/docs/source/api_DesignPhase.rst b/docs/source/api_DesignPhase.rst
index 63f1f5d3..6768743e 100644
--- a/docs/source/api_DesignPhase.rst
+++ b/docs/source/api_DesignPhase.rst
@@ -18,5 +18,3 @@ trends but are not intended to be used for actual designs.
    phases/design/api_SemiSubmersibleDesign
    phases/design/api_SparDesign
    phases/design/api_MooringSystemDesign
-
-..    phases/design/api_JacketDesign
diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst
index 20164d8a..54f02f91 100644
--- a/docs/source/changelog.rst
+++ b/docs/source/changelog.rst
@@ -3,6 +3,21 @@
 ORBIT Changelog
 ===============
 
+1.0.7
+-----
+
+- Added ``SupplyChainManager``.
+- Added ``JacketInstallation`` module.
+- Added option to use dynamic supply chain in ``MonopileInstallation`` module.
+
+1.0.6
+-----
+
+- Expanded tutorial and examples.
+- Added templates for design and install modules.
+- Added ports to library pathing.
+- Misc. bugfixes.
+
 1.0.5
 -----
 
diff --git a/docs/source/doc_DesignPhase.rst b/docs/source/doc_DesignPhase.rst
index f4121504..f258bfa7 100644
--- a/docs/source/doc_DesignPhase.rst
+++ b/docs/source/doc_DesignPhase.rst
@@ -17,5 +17,3 @@ the model.
    phases/design/doc_SemiSubmersibleDesign
    phases/design/doc_SparDesign
    phases/design/doc_MooringSystemDesign
-
-..    phases/design/doc_JacketDesign
diff --git a/docs/source/phases/design/api_JacketDesign.rst b/docs/source/phases/design/api_JacketDesign.rst
deleted file mode 100644
index 9b53b41a..00000000
--- a/docs/source/phases/design/api_JacketDesign.rst
+++ /dev/null
@@ -1,9 +0,0 @@
-Jacket Design API
-=================
-
-For detailed methodology, please see :doc:`Jacket Design <doc_JacketDesign>`.
-
-Coming soon!
-
-.. .. autoclass:: ORBIT.phases.design.JacketDesign
-..    :members:
diff --git a/docs/source/phases/design/doc_JacketDesign.rst b/docs/source/phases/design/doc_JacketDesign.rst
deleted file mode 100644
index 6bf987fd..00000000
--- a/docs/source/phases/design/doc_JacketDesign.rst
+++ /dev/null
@@ -1,10 +0,0 @@
-Jacket Design Methodology
-=========================
-
-For details of the code implementation, please see
-:doc:`Jacket Design API <api_JacketDesign>`.
-
-Overview
---------
-
-Coming soon!
diff --git a/examples/configs/example_fixed_project.yaml b/examples/configs/example_fixed_project.yaml
index 2e8ee389..953d66b8 100644
--- a/examples/configs/example_fixed_project.yaml
+++ b/examples/configs/example_fixed_project.yaml
@@ -45,14 +45,10 @@ design_phases:
 install_phases:
   ArrayCableInstallation: 0
   ExportCableInstallation: 2000
-  MonopileInstallation: !!python/tuple
-  - ScourProtectionInstallation
-  - 0.5
+  MonopileInstallation: 0
   OffshoreSubstationInstallation: 0
   ScourProtectionInstallation: 0
-  TurbineInstallation: !!python/tuple
-  - MonopileInstallation
-  - 0.1
+  TurbineInstallation: 0
 # Project Inputs
 project_parameters:
   turbine_capex: 1500
diff --git a/examples/supply_chain_dev.ipynb b/examples/supply_chain_dev.ipynb
new file mode 100644
index 00000000..8c41411f
--- /dev/null
+++ b/examples/supply_chain_dev.ipynb
@@ -0,0 +1,441 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "ad19946b-c043-4e6a-a62c-c5ba4c94389d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import pandas as pd\n",
+    "from copy import deepcopy\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from ORBIT import ProjectManager, load_config\n",
+    "from ORBIT.phases.install import MonopileInstallation, JacketInstallation\n",
+    "\n",
+    "weather = pd.read_csv(\"data/example_weather.csv\", parse_dates=[\"datetime\"])\\\n",
+    "            .set_index(\"datetime\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "718a655b-1104-4c5d-a8e4-1e74f6353c3c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fixed_config = load_config(\"configs/example_fixed_project.yaml\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "bc5d3a88-d57d-4d1a-b394-726991a9d07b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fixed_config[\"jacket\"] = {\n",
+    "    \"diameter\": 10,\n",
+    "    \"height\": 100,\n",
+    "    \"length\": 100,\n",
+    "    \"mass\": 100,\n",
+    "    \"deck_space\": 100,\n",
+    "    \"unit_cost\": 1e6\n",
+    "}\n",
+    "\n",
+    "# fixed_config[\"feeder\"] = \"example_feeder\"\n",
+    "# fixed_config[\"num_feeders\"] = 2\n",
+    "\n",
+    "# fixed_config[\"transition_piece\"] = {\n",
+    "#     \"mass\": 1000,\n",
+    "#     \"deck_space\": 1000,\n",
+    "#     \"unit_cost\": 1e6\n",
+    "# }\n",
+    "\n",
+    "# fixed_config[\"jacket_supply_chain\"] = {\n",
+    "#     \"enabled\": True,\n",
+    "#     \"substructure_delivery_time\": 100,\n",
+    "#     \"num_substructures_delivered\": 2,\n",
+    "# }"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1bc285b7-68a6-4498-b026-59f9d1b33c5c",
+   "metadata": {},
+   "source": [
+    "### Jacket Installation w/ Unlimited Storage at Port"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "8f86edb1-74fb-43b5-97b5-0a815a1a0693",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Installation Time: 7720h\n"
+     ]
+    }
+   ],
+   "source": [
+    "project = JacketInstallation(fixed_config, weather=weather)\n",
+    "project.run()\n",
+    "\n",
+    "df = pd.DataFrame(project.env.actions)\n",
+    "\n",
+    "print(f\"Installation Time: {project.total_phase_time:.0f}h\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a78686b8-3cc9-4ab2-a732-45afb3167017",
+   "metadata": {},
+   "source": [
+    "### Insufficient Substructure Fabrication"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "id": "e03c5be5-8636-4b11-a731-70dd19b0797c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Installation Time: 12981h\n"
+     ]
+    }
+   ],
+   "source": [
+    "config = deepcopy(fixed_config)\n",
+    "\n",
+    "config[\"jacket_supply_chain\"] = {\n",
+    "    \"enabled\": True,\n",
+    "    \"substructure_delivery_time\": 500,\n",
+    "    \"num_substructures_delivered\": 2,\n",
+    "}\n",
+    "\n",
+    "project = JacketInstallation(config, weather=weather)\n",
+    "project.run()\n",
+    "\n",
+    "df = pd.DataFrame(project.env.actions)\n",
+    "print(f\"Installation Time: {project.total_phase_time:.0f}h\")\n",
+    "\n",
+    "# Insufficient fabrication caused a ~5k hour delay"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "e7cab6f9-cddd-4eb6-a613-4e42728799c2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x127519220>"
+      ]
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "deliveries = df.loc[df['action'].str.contains('Delivered')][['action', 'time']]\n",
+    "deliveries['number'] = deliveries['action'].apply(lambda x: int(x.split(\" \")[1]))\n",
+    "# deliveries\n",
+    "\n",
+    "installs = df.loc[df['action'].str.contains('Grout Jacket')][['action', 'time']]\n",
+    "installs['number'] = 1\n",
+    "\n",
+    "fig = plt.figure(figsize=(6,3), dpi=200)\n",
+    "ax = fig.add_subplot(111)\n",
+    "\n",
+    "ax.scatter(deliveries['time'], deliveries['number'], s=10, label=\"Substructure(s) Delivered\")\n",
+    "ax.scatter(installs['time'], installs['number'], s=10, label=\"Completed Installation\")\n",
+    "\n",
+    "ax.set_xlim(0, ax.get_xlim()[1])\n",
+    "ax.set_ylim(0, 5)\n",
+    "\n",
+    "ax.set_xlabel(\"Simulation Time\")\n",
+    "ax.set_ylabel(\"Substructures\")\n",
+    "\n",
+    "ax.legend()\n",
+    "\n",
+    "# Note period of bad weather at ~10k hours"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "id": "fe12d4b3-1c9a-420a-b3fb-d6fba538822d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "installs_neg = installs.copy()\n",
+    "installs_neg[\"number\"] *= -1\n",
+    "\n",
+    "total = pd.concat([deliveries, installs_neg]).sort_values('time')\n",
+    "total['storage'] = total['number'].cumsum()\n",
+    "# total"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "id": "ea3f0a81-5894-42a5-b2f4-f6dcea1b5465",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x126f5e4c0>"
+      ]
+     },
+     "execution_count": 43,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig = plt.figure(figsize=(6,3), dpi=200)\n",
+    "ax = fig.add_subplot(111)\n",
+    "\n",
+    "ax.plot(total['time'], total['storage'], label=\"Storage Required\")\n",
+    "\n",
+    "ax.set_xlim(0, ax.get_xlim()[1])\n",
+    "# ax.set_ylim(0, 5)\n",
+    "\n",
+    "ax.axhline(4, ls=\"--\", lw=0.5, c='k')\n",
+    "\n",
+    "ax.set_xlabel(\"Simulation Time (h)\")\n",
+    "ax.set_ylabel(\"Substructures\")\n",
+    "\n",
+    "ax.legend()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2fe95e59-8405-4493-a117-bf147eb2af99",
+   "metadata": {},
+   "source": [
+    "### Increased Substructure Fabrication"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "id": "685864c6-b73d-4344-9700-8c9f7daecddd",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Installation Time: 7850h\n"
+     ]
+    }
+   ],
+   "source": [
+    "config = deepcopy(fixed_config)\n",
+    "\n",
+    "config[\"jacket_supply_chain\"] = {\n",
+    "    \"enabled\": True,\n",
+    "    \"substructure_delivery_time\": 250,\n",
+    "    \"num_substructures_delivered\": 2,\n",
+    "}\n",
+    "\n",
+    "project = JacketInstallation(config, weather=weather)\n",
+    "project.run()\n",
+    "\n",
+    "df = pd.DataFrame(project.env.actions)\n",
+    "print(f\"Installation Time: {project.total_phase_time:.0f}h\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "id": "e01ca9cc-9603-4d89-b781-4e646246263d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x127b0f670>"
+      ]
+     },
+     "execution_count": 51,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "deliveries = df.loc[df['action'].str.contains('Delivered')][['action', 'time']]\n",
+    "deliveries['number'] = deliveries['action'].apply(lambda x: int(x.split(\" \")[1]))\n",
+    "# deliveries\n",
+    "\n",
+    "installs = df.loc[df['action'].str.contains('Grout Jacket')][['action', 'time']]\n",
+    "installs['number'] = 1\n",
+    "\n",
+    "fig = plt.figure(figsize=(6,3), dpi=200)\n",
+    "ax = fig.add_subplot(111)\n",
+    "\n",
+    "ax.scatter(deliveries['time'], deliveries['number'], s=10, label=\"Substructure(s) Delivered\")\n",
+    "ax.scatter(installs['time'], installs['number'], s=10, label=\"Completed Installation\")\n",
+    "\n",
+    "ax.set_xlim(0, ax.get_xlim()[1])\n",
+    "ax.set_ylim(0, 5)\n",
+    "\n",
+    "ax.set_xlabel(\"Simulation Time\")\n",
+    "ax.set_ylabel(\"Substructures\")\n",
+    "\n",
+    "ax.legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "id": "cd4e31d9-bbda-4f7d-8df8-33f447231a78",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x127b52610>"
+      ]
+     },
+     "execution_count": 52,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "installs_neg = installs.copy()\n",
+    "installs_neg[\"number\"] *= -1\n",
+    "\n",
+    "total = pd.concat([deliveries, installs_neg]).sort_values('time')\n",
+    "total['storage'] = total['number'].cumsum()\n",
+    "\n",
+    "fig = plt.figure(figsize=(6,3), dpi=200)\n",
+    "ax = fig.add_subplot(111)\n",
+    "\n",
+    "ax.plot(total['time'], total['storage'], label=\"Storage Required\")\n",
+    "\n",
+    "ax.set_xlim(0, ax.get_xlim()[1])\n",
+    "# ax.set_ylim(0, 5)\n",
+    "\n",
+    "ax.axhline(4, ls=\"--\", lw=0.5, c='k')\n",
+    "\n",
+    "ax.set_xlabel(\"Simulation Time (h)\")\n",
+    "ax.set_ylabel(\"Substructures\")\n",
+    "\n",
+    "ax.legend()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ea782cce-81ae-426f-ba5c-8d375e6f0abb",
+   "metadata": {},
+   "source": [
+    "### Questions\n",
+    "\n",
+    "- Is this approach and the results valuable to Equinor?\n",
+    "- How to quantify the project cost associated with increased storage required?\n",
+    "  - $/substructure/day\n",
+    "\n",
+    "  - $/laydown space/day\n",
+    "\n",
+    "- How to quantify the delivery costs associated with substructure delivery?\n",
+    "  - $/substructure\n",
+    "\n",
+    "  - $/substructure/km\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ee9c8a0b-2003-4424-a551-8cff89241249",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/library/ports/__init__.py b/library/ports/__init__.py
new file mode 100644
index 00000000..62fe1c84
--- /dev/null
+++ b/library/ports/__init__.py
@@ -0,0 +1,5 @@
+__author__ = ["Rob Hammond", "Jake Nunemaker"]
+__copyright__ = "Copyright 2020, National Renewable Energy Laboratory"
+__maintainer__ = "Jake Nunemaker"
+__email__ = ["jake.nunemaker@nrel.gov", "robert.hammond@nrel.gov"]
+__status__ = "Development"
diff --git a/library/turbines/15MW_generic.yaml b/library/turbines/15MW_generic.yaml
new file mode 100644
index 00000000..50478a79
--- /dev/null
+++ b/library/turbines/15MW_generic.yaml
@@ -0,0 +1,20 @@
+blade:
+  deck_space: 480     # m^2
+  length: 120          # m
+  type: Blade
+  mass: 72            # t
+hub_height: 150       # m
+nacelle:
+  deck_space: 242     # m^2
+  type: Nacelle
+  mass: 797         # t
+name: 15MW Generic Turbine
+rated_windspeed: 11   # m/s
+rotor_diameter: 240   # m
+tower:
+  deck_space: 78.5      # m^2
+  sections: 2         # n
+  type: Tower
+  length: 150
+  mass: 480         # t
+turbine_rating: 15     # MW
\ No newline at end of file
diff --git a/library/vessels/example_scour_protection_vessel.yaml b/library/vessels/example_scour_protection_vessel.yaml
index ba498eab..e6ce52cd 100644
--- a/library/vessels/example_scour_protection_vessel.yaml
+++ b/library/vessels/example_scour_protection_vessel.yaml
@@ -1,5 +1,5 @@
 storage_specs:
-  max_cargo: 6000       # t
+  max_cargo: 10000       # t
   max_deck_load: 8      # t/m^2
   max_deck_space: 600   # m^2
 transport_specs:
diff --git a/misc/supply_chain.ipynb b/misc/supply_chain.ipynb
new file mode 100644
index 00000000..e6d2faa8
--- /dev/null
+++ b/misc/supply_chain.ipynb
@@ -0,0 +1,624 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "4936af57-5491-46f1-9718-3d31026e017e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pprint\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib as mpl\n",
+    "import matplotlib.pyplot as plt\n",
+    "from ORBIT import ProjectManager, SupplyChainManager, load_config\n",
+    "from ORBIT.supply_chain import DEFAULT_MULTIPLIERS, LABOR_SPLIT, TURBINE_CAPEX_SPLIT\n",
+    "from supply_chain_plots import waterfall_plot, area_time_plot\n",
+    "\n",
+    "pp = pprint.PrettyPrinter(indent=4)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "942d274e-07f6-4775-86c4-3dca4d15da94",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{   'array_cable': {'domestic': 0.19, 'imported': 0.0},\n",
+      "    'blades': {'domestic': 0.026, 'imported': 0.3},\n",
+      "    'export_cable': {'domestic': 0.231, 'imported': 0.0},\n",
+      "    'monopile': {'domestic': 0.085, 'imported': 0.28, 'tariffs': 0.25},\n",
+      "    'nacelle': {'domestic': 0.025, 'imported': 0.1},\n",
+      "    'oss_substructure': {'domestic': 0.0, 'imported': 0.0},\n",
+      "    'oss_topside': {'domestic': 0.0, 'imported': 0.0},\n",
+      "    'tower': {'domestic': 0.04, 'imported': 0.2, 'tariffs': 0.25},\n",
+      "    'transition_piece': {'domestic': 0.169, 'imported': 0.17, 'tariffs': 0.25}}\n"
+     ]
+    }
+   ],
+   "source": [
+    "# These are from the spreadsheet on teams\n",
+    "# They can be overridden in ORBIT/supply_chain.py or passed as a new dict\n",
+    "# into the manager class like SupplyChainManager(supply_chain, multipliers={different multipliers})\n",
+    "pp.pprint(DEFAULT_MULTIPLIERS)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "2af71bf7-6656-4119-95b1-47fd02378533",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'monopile': 0.5, 'oss_topside': 0.5, 'tower': 0.5, 'transition_piece': 0.5}\n"
+     ]
+    }
+   ],
+   "source": [
+    "# These are used for the tariff calculations: tariffs = (1 - labor_split) * total_cost * tariff_rate\n",
+    "# % of cost that is labor vs material\n",
+    "pp.pprint(LABOR_SPLIT)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "be736b6d-6be0-4cb2-8645-8e5b6d4af668",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load Sample Config\n",
+    "config = load_config(\"supply_chain_project.yaml\")  \n",
+    "capacity = config['plant']['num_turbines'] * int(config['turbine'].split('M')[0]) * 1000\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "b1831455-d242-457f-b9f9-9b6f831bf0bc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ORBIT library intialized at '/Users/jnunemak/repos/external/ORBIT/library'\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Define supply chain scenario to use\n",
+    "# Options are imported, domestic or domestic, imported steel\n",
+    "supply_chain_scenarios = {\n",
+    "    2023: {\n",
+    "    \"blades\": \"imported\",\n",
+    "    \"nacelle\": \"imported\",\n",
+    "    \"tower\": \"imported\",\n",
+    "    \"monopile\": \"imported\",\n",
+    "    \"transition_piece\": \"imported\",\n",
+    "    \"array_cable\": \"imported\",\n",
+    "    \"export_cable\": \"imported\",\n",
+    "    \"oss_topside\": \"imported\"\n",
+    "},\n",
+    "    2025: {\n",
+    "    \"blades\": \"domestic\",\n",
+    "    \"nacelle\": \"imported\",\n",
+    "    \"tower\": \"domestic, imported steel\",\n",
+    "    \"monopile\": \"domestic, imported steel\",\n",
+    "    \"transition_piece\": \"domestic, imported steel\",\n",
+    "    \"array_cable\": \"imported\",\n",
+    "    \"export_cable\": \"imported\",\n",
+    "    \"oss_topside\": \"domestic\"       \n",
+    "    },\n",
+    "    2027: {\n",
+    "    \"blades\": \"domestic\",\n",
+    "    \"nacelle\": \"domestic\",\n",
+    "    \"tower\": \"domestic, imported steel\",\n",
+    "    \"monopile\": \"domestic\",\n",
+    "    \"transition_piece\": \"domestic, imported steel\",\n",
+    "    \"array_cable\": \"domestic\",\n",
+    "    \"export_cable\": \"domestic\",\n",
+    "    \"oss_topside\": \"domestic\"       \n",
+    "    },\n",
+    "    2030: {\n",
+    "    \"blades\": \"domestic\",\n",
+    "    \"nacelle\": \"domestic\",\n",
+    "    \"tower\": \"domestic\",\n",
+    "    \"monopile\": \"domestic\",\n",
+    "    \"transition_piece\": \"domestic\",\n",
+    "    \"array_cable\": \"domestic\",\n",
+    "    \"export_cable\": \"domestic\",\n",
+    "    \"oss_topside\": \"domestic\"      \n",
+    "    },\n",
+    "}\n",
+    "\n",
+    "a = 'test'\n",
+    "years = []\n",
+    "scenarios = []\n",
+    "cost_breakdown = {\n",
+    "    'Wind turbine': [],\n",
+    "    'Substructure': [],\n",
+    "    'Electrical infrastructure': [],\n",
+    "}\n",
+    "total_capex = []\n",
+    "\n",
+    "opex = 110\n",
+    "fcr = .058\n",
+    "ncf = .489\n",
+    "lcoe = []\n",
+    "\n",
+    "for k,v in supply_chain_scenarios.items():\n",
+    "    years.append(k)  # list of ints\n",
+    "    _v = SupplyChainManager(v)\n",
+    "    _sc_project= _v.run_project(config)\n",
+    "    cost_breakdown['Wind turbine'].append(_sc_project.capex_breakdown['Turbine'] / capacity) # Nacelle, blades, tower\n",
+    "    cost_breakdown['Substructure'].append(_sc_project.capex_breakdown['Substructure']/ capacity)  # Monopile, TP\n",
+    "    cost_breakdown['Electrical infrastructure'].append(_sc_project.capex_breakdown['Array System'] / capacity +\n",
+    "                                                       _sc_project.capex_breakdown['Export System'] / capacity +\n",
+    "                                                       _sc_project.capex_breakdown['Offshore Substation'] / capacity\n",
+    "                                                      )  # Array cables, export cables, OSS\n",
+    "    total_capex.append(_sc_project.total_capex / capacity)\n",
+    "    lcoe.append(1000* (fcr * _sc_project.total_capex_per_kw + opex) / (8760 * ncf) )\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "22c5257d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'Wind turbine': [0.0, -5.71753158229571, -7.585204035263082, -7.585204035263082], 'Substructure': [0.0, 0.22892079711949176, -6.073632329891055, -9.862292156751318], 'Electrical infrastructure': [0.0, 0.0, 11.239304468294996, 11.239304468294996]}\n",
+      "[3525.171189529579, 3444.7533606745355, 3419.073942596618, 3395.439070922778]\n",
+      "[0.0, -1.4832522822647354, -1.9568917228414917, -2.3928208924097305]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create some summary statistics\n",
+    "cost_breakdown_perc = {\n",
+    "    'Wind turbine': [],\n",
+    "    'Substructure': [],\n",
+    "    'Electrical infrastructure': [],\n",
+    "}\n",
+    "for k, v in cost_breakdown.items():\n",
+    "    perc = [100*(i/v[0] -1) for n,i in enumerate(v)]\n",
+    "    cost_breakdown_perc[k] = perc \n",
+    "print(cost_breakdown_perc)\n",
+    "\n",
+    "total_capex_perc = [100*(i/total_capex[0] - 1) for n,i in enumerate(total_capex)] \n",
+    "print(total_capex)\n",
+    "\n",
+    "lcoe_perc = [100*(i/lcoe[0] - 1) for n,i in enumerate(lcoe)] \n",
+    "print(lcoe_perc)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "1646cfef",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2163.834546663371\n"
+     ]
+    }
+   ],
+   "source": [
+    "#Calculte baseline costs with no premiums\n",
+    "base_project = ProjectManager(config)\n",
+    "base_project.run()\n",
+    "base_capex = (base_project.capex_breakdown['Turbine'] + \n",
+    "              base_project.capex_breakdown['Substructure'] + \n",
+    "              base_project.capex_breakdown['Array System'] +            \n",
+    "              base_project.capex_breakdown['Export System']+\n",
+    "              base_project.capex_breakdown['Offshore Substation'] ) / capacity\n",
+    "print(base_capex)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "600b1ed7",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "FileNotFoundError",
+     "evalue": "[Errno 2] No such file or directory: 'C:/Users/mshields/Documents/Projects/Supply Chain Roadmap/Analysis repos/LCOE/results/capex_barchart.png'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
+      "Input \u001b[0;32mIn [8]\u001b[0m, in \u001b[0;36m<cell line: 22>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     20\u001b[0m fig_dir \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mC:/Users/mshields/Documents/Projects/Supply Chain Roadmap/Analysis repos/LCOE/results\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m     21\u001b[0m fname_bar \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m/capex_barchart.png\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[0;32m---> 22\u001b[0m \u001b[43mfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msavefig\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfig_dir\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43mfname_bar\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdpi\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m300\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbbox_inches\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mtight\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/opt/miniconda3/envs/orbit-dev/lib/python3.9/site-packages/matplotlib/figure.py:3046\u001b[0m, in \u001b[0;36mFigure.savefig\u001b[0;34m(self, fname, transparent, **kwargs)\u001b[0m\n\u001b[1;32m   3042\u001b[0m     \u001b[38;5;28;01mfor\u001b[39;00m ax \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39maxes:\n\u001b[1;32m   3043\u001b[0m         stack\u001b[38;5;241m.\u001b[39menter_context(\n\u001b[1;32m   3044\u001b[0m             ax\u001b[38;5;241m.\u001b[39mpatch\u001b[38;5;241m.\u001b[39m_cm_set(facecolor\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mnone\u001b[39m\u001b[38;5;124m'\u001b[39m, edgecolor\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mnone\u001b[39m\u001b[38;5;124m'\u001b[39m))\n\u001b[0;32m-> 3046\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcanvas\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mprint_figure\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/opt/miniconda3/envs/orbit-dev/lib/python3.9/site-packages/matplotlib/backend_bases.py:2319\u001b[0m, in \u001b[0;36mFigureCanvasBase.print_figure\u001b[0;34m(self, filename, dpi, facecolor, edgecolor, orientation, format, bbox_inches, pad_inches, bbox_extra_artists, backend, **kwargs)\u001b[0m\n\u001b[1;32m   2315\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m   2316\u001b[0m     \u001b[38;5;66;03m# _get_renderer may change the figure dpi (as vector formats\u001b[39;00m\n\u001b[1;32m   2317\u001b[0m     \u001b[38;5;66;03m# force the figure dpi to 72), so we need to set it again here.\u001b[39;00m\n\u001b[1;32m   2318\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m cbook\u001b[38;5;241m.\u001b[39m_setattr_cm(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfigure, dpi\u001b[38;5;241m=\u001b[39mdpi):\n\u001b[0;32m-> 2319\u001b[0m         result \u001b[38;5;241m=\u001b[39m \u001b[43mprint_method\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m   2320\u001b[0m \u001b[43m            \u001b[49m\u001b[43mfilename\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2321\u001b[0m \u001b[43m            \u001b[49m\u001b[43mfacecolor\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfacecolor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2322\u001b[0m \u001b[43m            \u001b[49m\u001b[43medgecolor\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43medgecolor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2323\u001b[0m \u001b[43m            \u001b[49m\u001b[43morientation\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43morientation\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2324\u001b[0m \u001b[43m            \u001b[49m\u001b[43mbbox_inches_restore\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m_bbox_inches_restore\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2325\u001b[0m \u001b[43m            \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   2326\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m   2327\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m bbox_inches \u001b[38;5;129;01mand\u001b[39;00m restore_bbox:\n",
+      "File \u001b[0;32m~/opt/miniconda3/envs/orbit-dev/lib/python3.9/site-packages/matplotlib/backend_bases.py:1648\u001b[0m, in \u001b[0;36m_check_savefig_extra_args.<locals>.wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m   1640\u001b[0m     _api\u001b[38;5;241m.\u001b[39mwarn_deprecated(\n\u001b[1;32m   1641\u001b[0m         \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m3.3\u001b[39m\u001b[38;5;124m'\u001b[39m, name\u001b[38;5;241m=\u001b[39mname, removal\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m3.6\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[1;32m   1642\u001b[0m         message\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m%(name)s\u001b[39;00m\u001b[38;5;124m() got unexpected keyword argument \u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m   1643\u001b[0m                 \u001b[38;5;241m+\u001b[39m arg \u001b[38;5;241m+\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m which is no longer supported as of \u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m   1644\u001b[0m                 \u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m%(since)s\u001b[39;00m\u001b[38;5;124m and will become an error \u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m   1645\u001b[0m                 \u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m%(removal)s\u001b[39;00m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m   1646\u001b[0m     kwargs\u001b[38;5;241m.\u001b[39mpop(arg)\n\u001b[0;32m-> 1648\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/opt/miniconda3/envs/orbit-dev/lib/python3.9/site-packages/matplotlib/_api/deprecation.py:415\u001b[0m, in \u001b[0;36mdelete_parameter.<locals>.wrapper\u001b[0;34m(*inner_args, **inner_kwargs)\u001b[0m\n\u001b[1;32m    405\u001b[0m     deprecation_addendum \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m    406\u001b[0m         \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mIf any parameter follows \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mname\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[38;5;124m, they should be passed as \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    407\u001b[0m         \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mkeyword, not positionally.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m    408\u001b[0m     warn_deprecated(\n\u001b[1;32m    409\u001b[0m         since,\n\u001b[1;32m    410\u001b[0m         name\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mrepr\u001b[39m(name),\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    413\u001b[0m                  \u001b[38;5;28;01melse\u001b[39;00m deprecation_addendum,\n\u001b[1;32m    414\u001b[0m         \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m--> 415\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43minner_args\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43minner_kwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/opt/miniconda3/envs/orbit-dev/lib/python3.9/site-packages/matplotlib/backends/backend_agg.py:541\u001b[0m, in \u001b[0;36mFigureCanvasAgg.print_png\u001b[0;34m(self, filename_or_obj, metadata, pil_kwargs, *args)\u001b[0m\n\u001b[1;32m    494\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    495\u001b[0m \u001b[38;5;124;03mWrite the figure to a PNG file.\u001b[39;00m\n\u001b[1;32m    496\u001b[0m \n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    538\u001b[0m \u001b[38;5;124;03m    *metadata*, including the default 'Software' key.\u001b[39;00m\n\u001b[1;32m    539\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    540\u001b[0m FigureCanvasAgg\u001b[38;5;241m.\u001b[39mdraw(\u001b[38;5;28mself\u001b[39m)\n\u001b[0;32m--> 541\u001b[0m \u001b[43mmpl\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mimage\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mimsave\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    542\u001b[0m \u001b[43m    \u001b[49m\u001b[43mfilename_or_obj\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbuffer_rgba\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mformat\u001b[39;49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mpng\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43morigin\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mupper\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m    543\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdpi\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfigure\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdpi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmetadata\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmetadata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpil_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpil_kwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/opt/miniconda3/envs/orbit-dev/lib/python3.9/site-packages/matplotlib/image.py:1675\u001b[0m, in \u001b[0;36mimsave\u001b[0;34m(fname, arr, vmin, vmax, cmap, format, origin, dpi, metadata, pil_kwargs)\u001b[0m\n\u001b[1;32m   1673\u001b[0m pil_kwargs\u001b[38;5;241m.\u001b[39msetdefault(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mformat\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28mformat\u001b[39m)\n\u001b[1;32m   1674\u001b[0m pil_kwargs\u001b[38;5;241m.\u001b[39msetdefault(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdpi\u001b[39m\u001b[38;5;124m\"\u001b[39m, (dpi, dpi))\n\u001b[0;32m-> 1675\u001b[0m \u001b[43mimage\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msave\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mpil_kwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/opt/miniconda3/envs/orbit-dev/lib/python3.9/site-packages/PIL/Image.py:2297\u001b[0m, in \u001b[0;36mImage.save\u001b[0;34m(self, fp, format, **params)\u001b[0m\n\u001b[1;32m   2295\u001b[0m         fp \u001b[38;5;241m=\u001b[39m builtins\u001b[38;5;241m.\u001b[39mopen(filename, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mr+b\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m   2296\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 2297\u001b[0m         fp \u001b[38;5;241m=\u001b[39m \u001b[43mbuiltins\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mopen\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilename\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mw+b\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m   2299\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m   2300\u001b[0m     save_handler(\u001b[38;5;28mself\u001b[39m, fp, filename)\n",
+      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'C:/Users/mshields/Documents/Projects/Supply Chain Roadmap/Analysis repos/LCOE/results/capex_barchart.png'"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "years[0] = str(years[0]) + ' \\n(Fully imported)'\n",
+    "years[-1] = str(years[-1]) + '\\n(Fully domestic)'\n",
+    "\n",
+    "fig = plt.figure()\n",
+    "ax = fig.add_subplot()\n",
+    "df = pd.DataFrame(cost_breakdown, index=years)\n",
+    "df.plot.bar(stacked=True, rot=45, ax=ax)\n",
+    "\n",
+    "ax.plot([-5,5], [base_capex, base_capex], 'k--', label='Baseline (wind turbine + substructure + electrical)')\n",
+    "\n",
+    "# Formatting\n",
+    "ax.set_ylim([0,4000])\n",
+    "ax.set_ylabel('Component capex, $/kW')\n",
+    "# ax.set_xlabel('Commercial operation date')\n",
+    "ax.get_yaxis().set_major_formatter(\n",
+    "            mpl.ticker.FuncFormatter(lambda x, p: format(int(x), ',')))\n",
+    "ax.legend(loc='upper left')\n",
+    "\n",
+    "# SAve fig\n",
+    "fig_dir = 'C:/Users/mshields/Documents/Projects/Supply Chain Roadmap/Analysis repos/LCOE/results'\n",
+    "fname_bar = '/capex_barchart.png'\n",
+    "fig.savefig(fig_dir+fname_bar, dpi=300, bbox_inches='tight')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "6143f120",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "dict_lcoe = {'LCOE': lcoe}\n",
+    "# for y, l in zip(years, lcoe):\n",
+    "#     print(y,l)\n",
+    "#     dict_lcoe[y] = l\n",
+    "\n",
+    "df_lcoe = pd.DataFrame(dict_lcoe, index=years)\n",
+    "fig = plt.figure()\n",
+    "ax = fig.add_subplot()\n",
+    "df_lcoe.plot.bar(rot=45, ax=ax)\n",
+    "\n",
+    "# Formatting\n",
+    "ax.get_legend().remove()\n",
+    "ax.set_ylabel('Levelized cost of energy, $/MWh')\n",
+    "\n",
+    "# SAve fig\n",
+    "fig_dir = 'C:/Users/mshields/Documents/Projects/Supply Chain Roadmap/Analysis repos/LCOE/results'\n",
+    "fname_lcoe = '/lcoe_barchart.png'\n",
+    "fig.savefig(fig_dir+fname_lcoe, dpi=300, bbox_inches='tight')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "d2c0f18e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlkAAAH4CAYAAAB5UPiRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAACRRUlEQVR4nOzdd3zM9x/A8ddl70UiQUhir9h7RIyiKNWh2lpVGqsobVGU2h1+rdasmtXSgdauFXvvPRLECEFkz7v7/v44OYKQI5e7JO/n45EH9/mu993n5PP2+X6+n49KURQFIYQQQgiRoyxMHYAQQgghRH4kSZYQQgghhBFIkiWEEEIIYQSSZAkhhBBCGIEkWUIIIYQQRiBJlhBCCCGEEUiSJYQQQghhBJJkCSGEEEIYgSRZQgghhBBGIEmWEEIIIYQR5Kkka8eOHbRv356iRYuiUqlYtWpVpu09evRApVJl+mndurVpghVCCCFEgZankqzExESqVq3KjBkzstyndevWREZG6n9+//33XIxQCCGEEELHytQBGKJNmza0adPmmfvY2tri7e2dSxEJIYQQQjxdnkqysiM0NBQvLy/c3d1p1qwZEyZMoFChQlnun5qaSmpqqv61VqslOjqaQoUKoVKpciNkIYQQQrwkRVGIj4+naNGiWFiYx426fJVktW7dmk6dOuHv709YWBgjR46kTZs27N27F0tLy6ceM3nyZMaNG5fLkQohhBDCGK5du0bx4sVNHQYAKkVRFFMH8SJUKhUrV66kY8eOWe4THh5OqVKl2Lx5M82bN3/qPo/3ZMXGxlKiRAmuXbuGi4tLTocthBBCCCOIi4vD19eXmJgYXF1dTR0OkM96sh4XEBBA4cKFuXTpUpZJlq2tLba2tk+Uu7i4SJIlhBBC5DHmNNTHPG5aGsn169e5d+8ePj4+pg5FCCGEEAVMnurJSkhI4NKlS/rXly9f5tixY3h4eODh4cG4ceN444038Pb2JiwsjM8++4zSpUvTqlUrE0YthBBCiIIoTyVZhw4dIjg4WP/6k08+AaB79+7MmjWLEydOsGjRImJiYihatCivvPIK48ePf+rtQCGEEEIIY8qzA9+NJS4uDldXV2JjY7Mck6XRaEhPT8/lyITIX6ytrbN86lcIIQyVnfY7t+WpnixTUxSFW7duERMTY+pQhMgX3Nzc8Pb2NquBqkIIkVMkyTJARoLl5eWFg4ODNAxCvCBFUUhKSiIqKgpAHk4RQuRLkmRlk0aj0SdYz5pBXgiRPfb29gBERUXh5eUltw6FEPlOvp7CISdljMFycHAwcSRC5B8Z/55kjKMQIj+SJMtAcotQiJwj/56EEPmZJFlCCCGEEEYgSZZ4qtDQUFQq1Us/SdmjR49nri+Z0xYuXIibm9sz9xk7dizVqlXLlXiEEEIUXJJk5XOzZ8/G2dkZtVqtL0tISMDa2pqmTZtm2jcjsQoLC6NBgwZERkYafZHN7CRFOW3YsGFs2bIlV68phBCi4JEkK58LDg4mISGBQ4cO6ct27tyJt7c3+/fvJyUlRV++bds2SpQoQalSpbCxsclz8xdld/C0k5OTPCEqhBDC6CTJyufKlSuHj48PoaGh+rLQ0FA6dOiAv78/+/bty1SesWzR47cLM3qcNm7cSIUKFXBycqJ169ZERkbqj9doNHzyySe4ublRqFAhPvvsM561oEBoaCg9e/YkNjYWlUqFSqVi7NixgG5A9KpVqzLt7+bmxsKFCwG4cuUKKpWK5cuXExQUhJ2dHUuXLtXvu2rVKsqUKYOdnR2tWrXi2rVr+m2P3y7MuKX57bff4uPjQ6FChejfv3+mpC01NZVhw4ZRrFgxHB0dqVu3bqbPVAghhHicJFkvQVEUktLUJvkxZDWk4OBgtm3bpn+9bds2mjZtSlBQkL48OTmZ/fv3Z1ob8nFJSUl8++23LFmyhB07dhAREcGwYcP027/77jsWLlzI/Pnz2bVrF9HR0axcuTLL8zVo0IDvv/8eFxcXIiMjiYyMzHS+7Bg+fDiDBg3i7Nmz+oXAk5KSmDhxIosXL2b37t3ExMTwzjvvPPM827ZtIywsjG3btrFo0SIWLlyoT+gABgwYwN69e1m2bBknTpzgrbfeonXr1ly8eNGgeIUQQhQcMhnpS0hO11BxzEaTXPvMV61wsMle9QUHBzN48GDUajXJyckcPXqUoKAg0tPTmT17NgB79+4lNTX1mUlWxv6lSpUCdInHV199pd/+/fffM2LECDp16gToxoNt3Jj152NjY4OrqysqlQpvb+9svZfHDR48WH+9R+P86aefqFu3LgCLFi2iQoUKHDhwgDp16jz1PO7u7vz0009YWlpSvnx52rZty5YtW+jduzcREREsWLCAiIgIihYtCujGdW3YsIEFCxYwadKkF4pdCCFE/iZJVgHQtGlTEhMTOXjwIPfv36ds2bJ4enoSFBREz549SUlJITQ0lICAAEqUKJHleRwcHPQJFuiWQslYFiU2NpbIyEh9YgNgZWVFrVq1DOp1M1StWrWeKLOysqJ27dr61+XLl8fNzY2zZ89mmWRVqlQp04zjPj4+nDx5EoCTJ0+i0WgoW7ZspmNSU1NlbJcQQogsSZL1EuytLTnzVSuTXTu7SpcuTfHixdm2bRv3798nKCgIgKJFi+Lr68uePXvYtm0bzZo1e+Z5rK2tM71WqVRGS6Cedu6nDWx3dHTMkes97b1ptVpA9zSmpaUlhw8ffmLpFycnpxy5vhBCiPxHkqyXoFKpsn3LztSCg4MJDQ3l/v37fPrpp/ryJk2asH79eg4cOEDfvn1f+Pyurq74+Piwf/9+mjRpAoBarebw4cPUqFEjy+NsbGzQaDRPlHt6emYaVH/x4kWSkpKyFYtarebQoUP6Xqvz588TExNDhQoVDHlLetWrV0ej0RAVFUXjxo1f6BxCCCEKHhn4XkAEBweza9cujh07pu/JAggKCmLOnDmkpaU9czxWdgwaNIgpU6awatUqzp07R79+/Z47mamfnx8JCQls2bKFu3fv6hOpZs2a8dNPP3H06FEOHTpESEjIE71NWbG2tmbgwIHs37+fw4cP06NHD+rVq5flrcLnKVu2LO+99x7dunVjxYoVXL58mQMHDjB58mTWrl37QucUQgiR/0mSVUAEBweTnJxM6dKlKVKkiL48KCiI+Ph4/VQPL2Po0KF07dqV7t27U79+fZydnXn99defeUyDBg0ICQmhc+fOeHp68vXXXwO6JxV9fX1p3Lgx7777LsOGDcv24twODg58/vnnvPvuuzRs2BAnJyeWL1/+Uu9twYIFdOvWjaFDh1KuXDk6duzIwYMHnzmGTQghRMGmUow5KjkPiouLw9XVldjYWFxcXPTlKSkpXL58GX9/f+zs7EwYoRD5h/y7EkLklKzab1OSniwhhBBCCCOQJEsIIYQQwggkyRJCCCGEMAJJsoQQQgghjECSLCGEEEIII5AkSwghhBDCCCTJEkIIIYQwAkmyhBBCCCGMQJIsIYQQQggjkCRLZEtoaCgqleq5axEKIYQQQkeSrALizp079O3blxIlSmBra4u3tzetWrVi9+7duXL93E7SevToQceOHXPlWkIIIcTTWJk6AJE73njjDdLS0li0aBEBAQHcvn2bLVu2cO/ePVOHlklaWho2NjamDkNPo9GgUqmwsJD/jwghhDCMtBwFQExMDDt37mTq1KkEBwdTsmRJ6tSpw4gRI3jttde4cuUKKpWKY8eOZTpGpVIRGhqa6Vy7d+8mMDAQOzs76tWrx6lTp/Tbrl69Svv27XF3d8fR0ZFKlSqxbt06rly5QnBwMADu7u6oVCp69OgBQNOmTRkwYACDBw+mcOHCtGrVKtvxnD59mnbt2uHi4oKzszONGzcmLCyMsWPHsmjRIv755x9UKpX+uKf1ph07dgyVSsWVK1cAWLhwIW5ubvz7779UrFgRW1tbIiIiSE1NZdiwYRQrVgxHR0fq1q37xGcjhBBCPEp6sl6GokB6kmmube0AKlW2dnVycsLJyYlVq1ZRr149bG1tX/iyn376KT/88APe3t6MHDmS9u3bc+HCBaytrenfvz9paWns2LEDR0dHzpw5g5OTE76+vvz999+88cYbnD9/HhcXF+zt7fXnXLRoEX379jXo1uWNGzdo0qQJTZs2ZevWrbi4uLB7927UajXDhg3j7NmzxMXFsWDBAgA8PDzYs2dPts6dlJTE1KlTmTdvHoUKFcLLy4sBAwZw5swZli1bRtGiRVm5ciWtW7fm5MmTlClTxrAPUQghRIEgSdbLSE+CSUVNc+2RN8HGMVu7WllZsXDhQnr37s3s2bOpUaMGQUFBvPPOOwQGBhp02S+//JKWLVsCuuSoePHirFy5krfffpuIiAjeeOMNqlSpAkBAQID+OA8PDwC8vLxwc3PLdM4yZcrw9ddf619n9Co9y4wZM3B1dWXZsmVYW1sDULZsWf12e3t7UlNT8fb2Nuj9AaSnpzNz5kyqVq0KQEREBAsWLCAiIoKiRXX1PWzYMDZs2MCCBQuYNGmSwdcQQgiR/8ntwgLijTfe4ObNm/z777+0bt2a0NBQatSowcKFCw06T/369fV/9/DwoFy5cpw9exaAjz/+mAkTJtCwYUO+/PJLTpw4ka1z1qxZ06AYQHebr3HjxvoEKyfZ2NhkSj5PnjyJRqOhbNmy+l5BJycntm/fTlhYWI5fXwghRP4gPVkvw9pB16NkqmsbyM7OjpYtW9KyZUtGjx7Nhx9+yJdffsnOnTsBUBRFv296errB5//www9p1aoVa9eu5b///mPy5Ml89913DBw48JnHOTpm7pHLGGT+rHgevd2YXdk5b8a5VY/cik1ISMDS0pLDhw9jaWmZaV8nJyeD4xBCCFEwSE/Wy1CpdLfsTPGTzfFYz1KxYkUSExPx9PQEIDIyUr/t0UHnj9q3b5/+7/fv3+fChQtUqFBBX+br60tISAgrVqxg6NCh/PzzzwD6JwY1Gs1z48pOPIGBgezcuTPLZNDGxuaJaxnyPh9VvXp1NBoNUVFRlC5dOtPPi9yOFEIIUTBIklUA3Lt3j2bNmvHrr79y4sQJLl++zJ9//snXX39Nhw4dsLe3p169ekyZMoWzZ8+yfft2Ro0a9dRzffXVV2zZsoVTp07Ro0cPChcurJ+PavDgwWzcuJHLly9z5MgRtm3bpk/ASpYsiUqlYs2aNdy5c4eEhIQs481OPAMGDCAuLo533nmHQ4cOcfHiRZYsWcL58+cB8PPz48SJE5w/f567d++Snp5O6dKl8fX1ZezYsVy8eJG1a9fy3XffPffzK1u2LO+99x7dunVjxYoVXL58mQMHDjB58mTWrl2bnSoQQghRECkik9jYWAVQYmNjM5UnJycrZ86cUZKTk00U2YtLSUlRhg8frtSoUUNxdXVVHBwclHLlyimjRo1SkpKSFEVRlDNnzij169dX7O3tlWrVqin//fefAijbtm1TFEVRtm3bpgDK6tWrlUqVKik2NjZKnTp1lOPHj+uvM2DAAKVUqVKKra2t4unpqXTt2lW5e/eufvtXX32leHt7KyqVSunevbuiKIoSFBSkDBo06ImYnxePoijK8ePHlVdeeUVxcHBQnJ2dlcaNGythYWGKoihKVFSU0rJlS8XJySnTcbt27VKqVKmi2NnZKY0bN1b+/PNPBVAuX76sKIqiLFiwQHF1dX0inrS0NGXMmDGKn5+fYm1trfj4+Civv/66cuLEiRerFKEoSt7+dyWEMC9Ztd+mpFKURwaoCOLi4nB1dSU2NhYXFxd9eUpKCpcvX8bf3x87OzsTRihE/iH/rszTrcRbzDo+i3vJ5jVZscg//hf8P6wtcvbBpazab1OSge9CCCH0wmPD+WjTR9xKvGXqUER+VkC6dyTJEkIIAcDpu6fpu7kv91Pv4+fiR8/KPVHx8g/ZCPE4C1XBGBIuSZYQQggORB5g4NaBJKmTqFSoEjNbzMTDzsPUYQmRpxWMVFIIIUSWNl/dTMjmEJLUSdT1rssvrX6RBEuIHCBJlhBCFGArLq5g6PahpGvTaVGiBTNbzMTROntLdgkhnk1uFwohRAE1/9R8/nf4fwC8UeYNRtcbjaWF5XOOEkJklyRZQghRwCiKwrTD01h4eiEAvSr3YlCNQZmWkxJCvDxJsoQQogBRa9WM2zuOVZdWATCs1jC6V+pu2qCEyKckyRJCiAIiVZPKp9s/Zdu1bViqLBnbYCwdS3c0dVhC5Fsy8F0AoFKpWLVqlUmu3bRpUwYPHpxj5+vRo4d+PcWnWbhwIW5ubgadU1EU+vTpg4eHByqVKlsLSwthTuLT4gnZFMK2a9uwsbBhWtNpkmAJYWSSZBUAPXr0QKVSPfHTunVro13TkKRtxYoVjB8/3mixPK5z585cuHDBoGM2bNjAwoULWbNmDZGRkVSuXNkosYWGhqJSqYiJiTHK+R/3vIRU5A/3ku/Ra2MvDt0+hKO1I7NbzqZZiWamDkuIfE9uFxYQrVu3ZsGCBZnKbG1tTRSNTlpaGjY2Nnh45O58PPb29tjb2xt0TFhYGD4+PjRo0CDLfTLeT27IzWtlh0ajQaVSYWEh/28zNzcTbtJnUx+uxl3Fw86D2S1mU6FQBVOHJUSBkKd+I+7YsYP27dtTtGjRp/aUKIrCmDFj8PHxwd7enhYtWnDx4kXTBGtmbG1t8fb2zvTj7u6e5f7Xrl3j7bffxs3NDQ8PDzp06MCVK1cy7TN//nwqVaqEra0tPj4+DBgwAAA/Pz8AXn/9dVQqlf712LFjqVatGvPmzcu0IPDjtwtTU1P5/PPP8fX1xdbWltKlS/PLL78Ausa8V69e+Pv7Y29vT7ly5fjhhx8M+iwev12YEdeSJUvw8/PD1dWVd955h/j4eEDX2zNw4EAiIiIyvZ+mTZsyYMAABg8eTOHChWnVqhUA06ZNo0qVKjg6OuLr60u/fv1ISEjQX+/q1au0b98ed3d3HB0dqVSpEuvWrePKlSsEBwcD4O7ujkqlokePHlle68qVK0/cuoyJiUGlUhEaGqovO336NO3atcPFxQVnZ2caN25MWFgYY8eOZdGiRfzzzz/63s3Q0NCn9qYdO3YMlUql/w5kfIb//vsvFStWxNbWloiICFJTUxk2bBjFihXD0dGRunXrZopF5K5L9y/RdX1XrsZdpahjURa3WSwJlhC5KE/1ZCUmJlK1alU++OADOnXq9MT2r7/+munTp7No0SL8/f0ZPXo0rVq14syZM/oGPScpikKyOjnHz5sd9lb2RnvcOj09nVatWlG/fn127tyJlZUVEyZMoHXr1pw4cQIbGxtmzZrFJ598wpQpU2jTpg2xsbHs3r0bgIMHD+Ll5cWCBQto3bo1lpYP5925dOkSf//9NytWrMhU/qhu3bqxd+9epk+fTtWqVbl8+TJ3794FQKvVUrx4cf78808KFSrEnj176NOnDz4+Prz99tsv/J7DwsJYtWoVa9as4f79+7z99ttMmTKFiRMn8sMPP1CqVCnmzp3LwYMHM8W9aNEi+vbtq3/vABYWFkyfPh1/f3/Cw8Pp168fn332GTNnzgSgf//+pKWlsWPHDhwdHTlz5gxOTk74+vry999/88Ybb3D+/HlcXFwy9bg97VrPc+PGDZo0aULTpk3ZunUrLi4u7N69G7VazbBhwzh79ixxcXH6Xk4PDw/27NmTrXMnJSUxdepU5s2bR6FChfDy8mLAgAGcOXOGZcuWUbRoUVauXEnr1q05efIkZcqUyXbc4uUdv3Ocfpv7EZcWR2m30sxuMZsijkVMHZYQBUqeSrLatGlDmzZtnrpNURS+//57Ro0aRYcOHQBYvHgxRYoUYdWqVbzzzjs5Hk+yOpm6v9XN8fNmx/539+Ng7ZDt/desWYOTk1OmspEjRzJy5Mgn9l2+fDlarZZ58+bpE7kFCxbg5uZGaGgor7zyChMmTGDo0KEMGjRIf1zt2rUB8PT0BMDNzQ1vb+9M505LS2Px4sX6fR534cIF/vjjDzZt2kSLFi0ACAgI0G+3trZm3Lhx+tf+/v7s3buXP/7446WSLK1Wy8KFC3F2dgaga9eubNmyhYkTJ+Lq6oqzszOWlpZPvJ8yZcrw9ddfZyp7tFfOz8+PCRMmEBISok+yIiIieOONN6hSpcoT7y/j1qmXl9cTg/Mfv9bjPYtPM2PGDFxdXVm2bBnW1tYAlC1bVr/d3t6e1NTUJ95XdqSnpzNz5kyqVq2qf18LFiwgIiKCokWLAjBs2DA2bNjAggULmDRpksHXEC9m943dDAkdQrI6mUDPQGY2n4mrraupwxKiwMlTSdazXL58mVu3bukbZgBXV1fq1q3L3r17s0yyUlNTSU1N1b+Oi4szeqymEBwczKxZszKVZTUW6vjx41y6dEmfcGRISUkhLCyMqKgobt68SfPmzQ2Oo2TJklkmWKC7LWVpaUlQUFCW+8yYMYP58+cTERFBcnIyaWlpVKtWzeBYHuXn55fp/fr4+BAVFfXc42rWrPlE2ebNm5k8eTLnzp0jLi4OtVpNSkoKSUlJODg48PHHH9O3b1/+++8/WrRowRtvvEFgYOALXet5jh07RuPGjfUJVk6ysbHJFPfJkyfRaDSZkjjQ/RsrVKhQjl9fPN2GyxsYsWsEaq2ahkUbMq3pNIP+QyaEyDn5Jsm6desWAEWKZO4OL1KkiH7b00yePDlTz4gh7K3s2f/u/hc69mXZWxk2cNvR0ZHSpUtna9+EhARq1qzJ0qVLn9jm6en5UoObHR2fvSba8wakL1u2jGHDhvHdd99Rv359nJ2d+eabb9i//+Xq4fEkRKVSodVqn3vc4+/nypUrtGvXjr59+zJx4kQ8PDzYtWsXvXr1Ii0tDQcHBz788ENatWrF2rVr+e+//5g8eTLfffcdAwcONOhaGfWgKIq+LD09PdM+hg7wz+55M8796C3rhIQELC0tOXz48BO3gh/vRRXGsfzccibun4iCQmu/1kxqNAlry5xPsIUQ2ZNvkqwXNWLECD755BP967i4OHx9fbN1rEqlypf/Q6xRowbLly/Hy8sLFxeXp+7j5+fHli1b9AO1H2dtbY1GozH42lWqVEGr1bJ9+/ZMvZIZdu/eTYMGDejXr5++LCwszODrGMvhw4fRarV89913+mTljz/+eGI/X19fQkJCCAkJYcSIEfz8888MHDhQ/8Rgdj67jB7ByMhIqlevDvDE/F2BgYEsWrSI9PT0p/Zm2djYPHGtR8+b8XBEduYFq169OhqNhqioKBo3bvzc/UXOURSFOSfmMOPYDAA6l+vMiDojZB1CIUwsTz1d+CwZY0pu376dqfz27dvPHG9ia2uLi4tLpp/8KDU1lVu3bmX6yRhM/rj33nuPwoUL06FDB3bu3Mnly5cJDQ3l448/5vr164DuibzvvvuO6dOnc/HiRY4cOcKPP/6oP0dGEnbr1i3u37+f7Tj9/Pzo3r07H3zwAatWrdJfOyNRKVOmDIcOHWLjxo1cuHCB0aNHc/DgwZf4ZHJW6dKlSU9P58cffyQ8PJwlS5Ywe/bsTPsMHjyYjRs3cvnyZY4cOcK2bduoUEH3xFfJkiVRqVSsWbOGO3fuZHoq8XH29vbUq1ePKVOmcPbsWbZv386oUaMy7TNgwADi4uJ45513OHToEBcvXmTJkiWcP38e0H3eJ06c4Pz589y9e5f09HRKly6Nr68vY8eO5eLFi6xdu5bvvvvuue+9bNmyvPfee3Tr1o0VK1Zw+fJlDhw4wOTJk1m7dq2hH6XIJq2iZerBqfoEK6RqCF/U/UISLCHMQL5Jsvz9/fH29mbLli36sri4OPbv30/9+vVNGJl52LBhAz4+Ppl+GjVq9NR9HRwc2LFjByVKlKBTp05UqFCBXr16kZKSok9Cu3fvzvfff8/MmTOpVKkS7dq1yzRdxnfffcemTZvw9fXV97Jk16xZs3jzzTfp168f5cuXp3fv3iQmJgLw0Ucf0alTJzp37kzdunW5d+9epl4tU6tatSrTpk1j6tSpVK5cmaVLlzJ58uRM+2g0Gvr370+FChVo3bo1ZcuW1Q+KL1asGOPGjWP48OEUKVJEPy1GVubPn49araZmzZoMHjyYCRMmZNpeqFAhtm7dSkJCAkFBQdSsWZOff/5Z36vVu3dvypUrR61atfD09GT37t1YW1vz+++/c+7cOQIDA5k6deoT583KggUL6NatG0OHDqVcuXJ07NiRgwcPUqJEiex+hMIA6dp0Ru4aydKzulv7w+sMp3+1/rLQsxBmQqU8OvDCzCUkJHDp0iVAd2ti2rRpBAcH4+HhQYkSJZg6dSpTpkzJNIXDiRMnDJrCIS4uDldXV2JjYzP1aqWkpHD58uVM8zsJIV6O/Lt6ccnqZIZtH8aO6zuwUlkxvtF42gW0M3VYQphMVu23KeWpMVmHDh3KNAYoYyxV9+7dWbhwIZ999hmJiYn06dOHmJgYGjVqxIYNG+SXtxAiX4lLi2PAlgEcjTqKnaUd3zX9jibFm5g6LCHEY/JUT1ZukJ4sIXKP/Lsy3J2kO4RsDuHC/Qs42zgzo/kMqnsZdkteiPxIerKEEEK8sGtx1+izqQ/XE65T2L4ws1vMppxHOVOHJYTIgiRZQgiRB5yPPs9Hmz7iXso9ijsVZ+4rc/F1zt50M0II05Aky0Byd1WInCP/nrLnyO0jDNgygPj0eMq5l2N2y9kUti9s6rCEEM+Rb6ZwMLaMR96TkpJMHIkQ+UfGvydjLPuTX+y4voM+m/oQnx5PDa8azG89XxIsIfII6cnKJktLS9zc3PTr2Tk4OMhcNEK8IEVRSEpKIioqCjc3tyeW4RE6q8NWM3r3aDSKhqDiQXwT9I3BS2oJIUxHkiwDZMwcn52Fg4UQz+fm5vbMFRkKsqVnlzLlwBQA2ge0Z1zDcVhbSI+fEHmJJFkGUKlU+Pj44OXl9dQFc4UQ2WdtbS09WE+hKAozjs1gzok5ALxf4X0+rf0pFioZ3SFEXiNJ1guwtLSUxkEIkeM0Wg2T9k/ijwu6tToHVh9I7yq9ZWiCEHmUJFlCCGEG0jXpjNg1go1XNqJCxah6o3i73NumDksI8RIkyRJCCBNLSk9iSOgQ9tzcg5WFFZMbT6a1X2tThyWEeEmSZAkhhAnFpMTQf0t/Ttw9gb2VPd8Hf0+Dog1MHZYQIgdIkiWEECZyK/EWH236iPDYcFxtXZnZfCaBnoGmDksIkUMkyRJCCBO4EnuFPpv6EJkYiZeDF3NbzqWUWylThyWEyEGSZAkhRC47c+8MfTf3JTolGj8XP+a0nENRp6KmDksIkcMkyRJCiFx08NZBBm4dSGJ6IhU8KjC75Ww87DxMHZYQwghkdjshhMglWyK2ELIphMT0RGp712Z+q/mSYAmRj0mSJYQQuWDlxZV8EvoJado0mvk2Y1aLWTjZOJk6LCGEEcntQiGEMLIFpxYw7fA0AF4v/Tpj6o/BykJ+/QqR38m/ciGEMBJFUfjfkf+x4NQCAHpW7smQGkNkmRwhCghJsoQQwgjUWjXj941nxcUVAHxS8xN6Vu5p4qiEELlJkiwhhMhhqZpUPt/xOVsitmChsmBs/bG8XuZ1U4clhMhlkmQJIUQOSkhLYNC2QRy4dQAbCxu+Dvqa5iWamzosIYQJSJIlhBA5JDolmr6b+3Lm3hkcrR2ZHjydOj51TB2WEMJEJMkSQogcEJkQSZ9NfbgSdwV3W3dmtZxFpUKVTB2WEMKEJMkSQoiXFBYTRp9NfYhKisLH0Yc5Lefg7+pv6rCEECYmSZYQQryEE3dO0G9LP2JTYwlwDWBOyzl4O3qbOiwhhBmQGd+FEOIF7bm5hw//+5DY1FgCCweyqPUiSbCEEHqSZAkhxAvYeGUj/bf0J1mdTH2f+vz8ys+42bmZOiwhhBmRJEsIIQz0x/k/+HT7p6i1alr5teKn5j/hYO1g6rCEEGZGxmQJIUQ2KYrCzyd/5sejPwLwdtm3GVl3JJYWliaOTAhhjiTJEkKIbNAqWr45+A2/nv0VgD6BfRhQbYCsQyiEyJLBtwtTUlKy3BYZGflSwQghhDlK16YzatcofYL1We3PGFh9oCRYQohnMjjJqlGjBseOHXui/O+//yYwMDAnYhJCCLORok5hyLYhrA5fjaXKkkmNJtG1YldThyWEyAMMTrKaNm1KvXr1mDp1KgCJiYn06NGDrl27MnLkyBwPUAghTCUuLY6PNn3E9uvbsbW05YfgH2hfqr2pwxJC5BEGj8maOXMmbdu25cMPP2TNmjVERkbi5OTEgQMHqFy5sjFiFEKIXHc3+S4hm0I4f/88ztbO/Nj8R2oWqWnqsIQQecgLDXxv06YNnTp1YtasWVhZWbF69WpJsIQQ+ca1+Gt8tOkjrsVfo5BdIea0nEM5j3KmDksIkccYfLswLCyM+vXrs2bNGjZu3Mhnn33Ga6+9xmeffUZ6eroxYhRCiFxzPvo83dZ341r8NYo5FWNJmyWSYAkhXojBSVa1atXw9/fn+PHjtGzZkgkTJrBt2zZWrFhBnTp1jBGjEELkiqNRR+m5sSd3k+9Sxr0MS9oswdfF19RhCSHyKIOTrJkzZ7Js2TLc3Nz0ZQ0aNODo0aPUqFEjJ2MTQohcs+P6Dvr814f4tHiqe1VnQasFeDp4mjosIUQeplIURXmRA9PS0rh8+TKlSpXCyir/zGkaFxeHq6srsbGxuLi4mDocIUQuWBu+llG7RqFW1DQq1ohpTadhb2Vv6rCEEAYwx/bb4J6s5ORkevXqhYODA5UqVSIiIgKAgQMH6qd1EEKIvGLp2aUM3zkctaKmbUBbpjebLgmWECJHGJxkDR8+nOPHjxMaGoqdnZ2+vEWLFixbtixHgxNCCGNRFIUZx2Yw5cAUAN4t/y6TGk3C2sLaxJEJIfILg+/zrVq1iuXLl1OvXr1MS0pUqlSJsLCwHA1OCCGMQatombR/EsvPLwegf7X+fBT4kSyTI4TIUQYnWXfu3MHLy+uJ8sTERPkFJYQwe+madL7Y9QXrr6xHhYov6n5B5/KdTR2WECIfMvh2Ya1atVi7dq3+dUZiNW/ePOrXr59zkQkhRA5LSk9i4NaBrL+yHisLK75u8rUkWEIIozG4J2vSpEm0adOGM2fOoFar+eGHHzhz5gx79uxh+/btxohRCCFeWmxqLP229OPEnRPYW9nzv6b/o2GxhqYOSwiRjxnck9WoUSOOHTuGWq2mSpUq/Pfff3h5ebF3715q1pR1vYQQ5ud24m16bOjBiTsncLFx4edXfpYESwhhdC88T1Z+ZY7zbAghXtzVuKv0+a8PNxNv4mXvxZyWcyjtXtrUYQkhcpg5tt8vNIuoRqNh5cqVnD17FoCKFSvSoUOHfDUpqRAi7zt77ywhm0OITommhHMJ5r4yl2JOxUwdlhCigDA4Kzp9+jSvvfYat27dolw53aKpU6dOxdPTk9WrV1O5cuUcD1IIIQx18NZBPt76MQnpCVTwqMDMFjMpbF/Y1GEJIQoQg8dkffjhh1SqVInr169z5MgRjhw5wrVr1wgMDKRPnz7GiDHbxo4di0qlyvRTvnx5k8YkhMh92yK2EbIphIT0BGoVqcUvrX6RBEsIkesM7sk6duwYhw4dwt3dXV/m7u7OxIkTqV27do4G9yIqVarE5s2b9a/lFqYQBcuqS6sYu2csGkVDsG8w3wR9g62lranDEkIUQAZnIGXLluX27dtUqlQpU3lUVBSlS5t+MKmVlRXe3t6mDkMIYQKLTi/i20PfAtChVAfGNhiLlYX8R0sIYRoG3y6cPHkyH3/8MX/99RfXr1/n+vXr/PXXXwwePJipU6cSFxen/zGFixcvUrRoUQICAnjvvff0C1hnJTU1NVPMpopbCPHiFEXh+8Pf6xOsHpV6ML7heEmwhBAmZfAUDhYWD/OyjNneM07x6GuVSoVGo8mpOLNl/fr1JCQkUK5cOSIjIxk3bhw3btzg1KlTODs7P/WYsWPHMm7cuCfKzekRUCFE1jRaDeP3jefvi38DMLjGYHpV6WXiqIQQuc0cp3AwOMkyZFb3oKAggwPKSTExMZQsWZJp06bRq9fTf+mmpqaSmpqqfx0XF4evr69ZVZIQ4unSNGl8vuNzNkdsxkJlweh6o3mz7JumDksIYQLmmGQZ3Jdu6sTJEG5ubpQtW5ZLly5luY+trS22tjIoVoi8JjE9kUHbBrE/cj/WFtZMbTKVliVbmjosIYTQe+EBC0lJSURERJCWlpapPDAw8KWDyikJCQmEhYXRtWtXU4cihMhB91Pu03dzX07fO42DlQPTm02nrk9dU4clhBCZGJxk3blzh549e7J+/fqnbs/tcViPGjZsGO3bt6dkyZLcvHmTL7/8EktLS7p06WKymIQQOSsyIZI+m/pwJe4K7rbuzGoxi0qFKz3/QCGEyGUGP104ePBgYmJi2L9/P/b29mzYsIFFixZRpkwZ/v33X2PEmG3Xr1+nS5culCtXjrfffptChQqxb98+PD09TRqXECJnhMeE03V9V67EXcHb0ZuFbRZKgiWEMFsG92Rt3bqVf/75h1q1amFhYUHJkiVp2bIlLi4uTJ48mbZt2xojzmxZtmyZya4thDCuU3dP0XdzX2JSY/B39Wduy7l4O8qceEII82VwT1ZiYiJeXl6Abqb3O3fuAFClShWOHDmSs9EJIQSw9+ZePtj4ATGpMVQuVJlFrRdJgiWEMHsGJ1nlypXj/PnzAFStWpU5c+Zw48YNZs+ejY+PT44HKIQo2P678h/9t/QnWZ1MXZ+6zGs1D3c79+cfKIQQJmbw7cJBgwYRGRkJwJdffknr1q1ZunQpNjY2LFy4MKfjE0IUYH9e+JPxe8ejoNCyZEumNJ6CjaWNqcMSQohsMXgy0sclJSVx7tw5SpQoQeHCeX+Ve3OczEyIgkZRFH459Qs/HPkBgDfLvsmouqOwtLA0cWRCCHNlju23QT1ZcXFxODk5ZVpax8HBgWrVqpGQkJDjwQkhCh6touW7Q9+x+MxiAHpX6c3A6gP1y3YJIUReke0xWStXrqRWrVqkpKQ8sS05OZnatWuzevXqHA1OCFGwqLVqRu8erU+whtUaxsc1PpYESwiRJ2U7yZo1axafffYZDg4OT2xzdHTk888/56effsrR4IQQBUeKOoUhoUP4N+xfLFWWTGw0ke6Vups6LCGEeGHZTrJOnTpF06ZNs9zepEkTTp48mRMxCSEKmPi0eEI2hxB6LRRbS1u+D/6e10q9ZuqwhBDipWR7TNb9+/dRq9VZbk9PT+f+/fs5EpQQouC4m3yXvpv7ci76HE7WTvzY7EdqedcydVhCCPHSst2T5efnx6FDh7LcfujQIUqWLJkjQQkhCobr8dfpvr4756LP4WHnwYLWCyTBEkLkG9lOsjp16sQXX3zB7du3n9h269YtRo0axRtvvJGjwQkh8q+L9y/SbX03IuIjKOZUjMVtFlPeo7ypwxJCiByT7Xmy4uPjqV+/PhEREbz//vuUK1cOgHPnzrF06VJ8fX3Zt28fzs7ORg3Y2Mxxng0h8ptjUcfot6Uf8WnxlHYrzZyWc/By8DJ1WEKIPMwc2+9sj8lydnZm9+7djBgxguXLl+vHX7m5ufH+++8zceLEPJ9gCSGMb9eNXXwS+gnJ6mSqelZlRvMZuNq6mjosIYTIcS8047uiKNy9exdFUfD09MxXc9iYYyYsRH6xLnwdX+z6ArWipmGxhkwLmoaD9ZPTwgghhKHMsf02eO1CAJVKhaenZ07HIoTIx34/9zuT909GQaGNfxsmNpyItaW1qcMSQgijeaEkSwghsktRFGYfn83M4zMB6FK+C8PrDMdCle3nboQQIk+SJEsIYTRaRcuUA1P4/dzvAPSr2o+QqiH5aoiBEEJkRZIsIYRRpGvS+WL3F6y/vB6AEXVG8G6Fd00clRBC5B5JsoQQOS4pPYlPtn/C7hu7sVJZMaHRBNoGtDV1WEIIkateKMnasmULW7ZsISoqCq1Wm2nb/PnzcyQwIUTeFJsaS/8t/Tl+5zh2lnZMazqNxsUbmzosIYTIdQYnWePGjeOrr76iVq1a+Pj4yNgKIYReVFIUH236iEsxl3C2cWZm85lU86pm6rCEEMIkDE6yZs+ezcKFC+natasx4hFC5FERcRH02dSHGwk38LT3ZHbL2ZR1L2vqsIQQwmQMTrLS0tJo0KCBMWIRQuRR56LPEbIphHsp9/B19mVuy7kUdy5u6rCEEMKkDJ6o5sMPP+S3334zRixCiDzo0K1D9NzQk3sp9yjnXo7FbRZLgiWEELxAT1ZKSgpz585l8+bNBAYGYm2decbmadOm5VhwQgjzFnotlGHbh5GqSaVmkZr82OxHnG1kDVMhhIAXSLJOnDhBtWrVADh16lSmbTIIXoiC49+wfxmzewwaRUPT4k35Jugb7KzsTB2WEEKYDYOTrG3bthkjDiFEHrL49GK+OfQNAK+Veo2xDcZibSHrEAohxKNkMlIhRLYpisKPR3/k55M/A9C1YleG1Rom6xAKIcRTZCvJ6tSpEwsXLsTFxYVOnTo9c98VK1bkSGBCCPOi0WqYsH8Cf134C4BBNQbRq3IvGSYghBBZyFaS5erqqv9F6urqatSAhBDmJ02TxvCdw9l0dRMqVIyuP5q3yr5l6rCEEMKsqRRFUUwdhDmJi4vD1dWV2NhYXFxcTB2OECaXlJ7EoG2D2Be5D2sLa6Y0nsIrfq+YOiwhhMjEHNtvGZMlhMjS/ZT79N/Sn5N3T2JvZc8PwT9Qv2h9U4clhBB5giRZQoinupV4iz6b+nA59jJutm7MbD6TKp5VTB2WEELkGZJkCSGeEB4bzkebPuJW4i2KOBRhbsu5BLgFmDosIYTIUyTJEkJkcvruafpu7sv91Pv4ufgxt+VcfJx8TB2WEELkOS81uU1KSkpOxSGEMAP7I/fzwcYPuJ96n4qFKrKozSJJsIQQ4gUZnGRptVrGjx9PsWLFcHJyIjw8HIDRo0fzyy+/5HiAQojcsfnqZvpu7kuSOom63nWZ32o+HnYepg5LCCHyLIOTrAkTJrBw4UK+/vprbGxs9OWVK1dm3rx5ORqcECJ3/H3hb4ZuH0q6Np0WJVowo8UMHK0dTR2WEELkaQYnWYsXL2bu3Lm89957WFpa6surVq3KuXPncjQ4IYTxzT81n7F7x6JVtLxR5g2+DfoWW0tbU4clhBB5nsED32/cuEHp0qWfKNdqtaSnp+dIUEII41MUhWmHp7Hw9EIAelXuxaAag2SZHCGEyCEG92RVrFiRnTt3PlH+119/Ub169RwJSghhXGqtmjF7xugTrGG1hjG45mBJsIQQIgcZ3JM1ZswYunfvzo0bN9BqtaxYsYLz58+zePFi1qxZY4wYhRA5KFWTyqfbP2XbtW1YqCwYW38sr5d53dRhCSFEvmNwT1aHDh1YvXo1mzdvxtHRkTFjxnD27FlWr15Ny5YtjRGjECKHxKfFE7IphG3XtmFjYcO0ptMkwRJCCCORBaIfY44LTAqRE+4l36Pv5r6cjT6Lo7UjPzb7kdretU0dlhBC5AhzbL9lxnchCoAbCTf4aNNHXI27ioedB7NazKJioYqmDksIIfI1g5Msd3f3pw6OValU2NnZUbp0aXr06EHPnj1zJEAhxMu5dP8SH236iKjkKIo6FmVOyzn4ufqZOiwhhMj3Xmjg+8SJE2nTpg116tQB4MCBA2zYsIH+/ftz+fJl+vbti1qtpnfv3jkesBAi+47fOU6/zf2IS4ujlGsp5rScQxHHIqYOSwghCgSDk6xdu3YxYcIEQkJCMpXPmTOH//77j7///pvAwECmT58uSZYQJrT7xm6GhA4hWZ1MoGcgM5vPxNXW1dRhCSFEgWHw04UbN26kRYsWT5Q3b96cjRs3AvDqq6/q1zQUQuS+DZc3MGDrAJLVyTQs2pCfW/4sCZYQQuQyg5MsDw8PVq9e/UT56tWr8fDQLSabmJiIs7Pzy0cnhDDY8nPL+WzHZ6i1alr7tebHZj/iYO1g6rCEEKLAMfh24ejRo+nbty/btm3Tj8k6ePAg69atY/bs2QBs2rSJoKCgnI1UCPGQooBWDZp0sLACKxsURWHOiTnMODYDgM7lOjOizggsLSyfczIhhBDG8ELzZO3evZuffvqJ8+fPA1CuXDkGDhxIgwYNcjzAFzFjxgy++eYbbt26RdWqVfnxxx/1CeHzmOM8G+IlabW6hESbrktKMpITfdmj2zSP/D1jW1bHqh/Z7/FjH9mmVT92jcePVWex34NzPm0/rfrh+7OwRlu1C197uLA0/F8AQqqG0K9qP1kmRwhRYJhj+53vJiNdvnw53bp1Y/bs2dStW5fvv/+eP//8k/Pnz+Pl5fXc482xknLVo426QcnB44mF5rEEJItjn5vYPO/62dhP0Zr6UzWqdGC0ZyHWOjkCMDywP+9VD3n2QUIIkc+YY/v9QkmWVqvl0qVLREVFodVmbsCaNGmSY8G9iLp161K7dm1++uknQBerr68vAwcOZPjw4c893liVtGzzHDzsVXg6WOkSAEXzILlQZ/5TUYPmwZ9ata4XRnmQ7GTa9ujxTzuf5pFy9WP7ah+e7/EYyFc5d9ZUFqCyAksrUFmChaXutpuF1YO/Wz4ot3pk24MySyvdsRnlKkuwtHzkfFZgYZH5fKqnnN/iade2yHwey8eO1V9fd5xiYcm8ozPYGX0KK0Vh/J17tEtVoG4faDgYHDxM/UkLIUSuMMcky+AxWfv27ePdd9/l6tWrPJ6fqVQqNBpNjgVnqLS0NA4fPsyIESP0ZRYWFrRo0YK9e/c+9ZjU1FRSU1P1r+Pi4nI8rpR0Dd9c+5E0i1y8dWPBMx5rUAHWD37EkzQPfp6x2czYWdrxXfkeNDm6Am4cgt0/wMH5UL8f1O8PdvJkoRBC5DaDk6yQkBBq1arF2rVr8fHxMasxH3fv3kWj0VCkSObJFosUKcK5c+eeeszkyZMZN26cUeOKS07HR6MiXa2gAAoqLFQqLC1VWKgsQP8ZqnT5D6oHf3+0/Cl/Vz3YLzt/z3TeF/m7MFeutq4MqzWM6l7VoWY/uPgfbB0Pt07C9qmwfw40HAR1PwIbR1OHK4QQBYbBtwsdHR05fvw4pUuXNlZML+zmzZsUK1aMPXv2UL9+fX35Z599xvbt29m/f/8TxzytJ8vX19co3Y0Xbscze3sY/xy7iUar+9irFHOlb9NStKrkjWVu9nSJ/E2rhbP/wrZJcFf3gAqOntDoE6j1AVjbmTY+IYTIYeZ4u9DgebLq1q3LpUuXjBHLSytcuDCWlpbcvn07U/nt27fx9vZ+6jG2tra4uLhk+jGWskWcmfZ2NbZ/2pQeDfyws7bg5I1Y+i09Qotp21l2IIJUtRneixJ5j4UFVOoI/fbC63PB3Q8S78DGETC9OhyaD+o0U0cphBD5msE9WStXrmTUqFF8+umnVKlSBWvrzON6AgMDczRAQ9WtW5c6derw448/ArqB7yVKlGDAgAEmHfj+NNGJaSzcc4VFe64Qm5wOgJezLR829qdLnRI428mYKZFDNOlwbCls/xribujK3EpC0xEQ+LZu8L0QQuRh5tiTZXCSZWHxZOeXSqVCURSTD3wH3RQO3bt3Z86cOdSpU4fvv/+eP/74g3Pnzj0xVutpTFFJialqfj8Qwbydl7kVlwKAi50V3er70aOhH4WdbHMlDlEApKfAkUWw41tIjNKVFS6rS7YqdtT1gAkhRB6UL5Ksq1evPnN7yZIlXyqgnPDTTz/pJyOtVq0a06dPp27dutk61pSVlKbWsurYDWZvDyP8TiIAtlYWdK7tS+/GAfh6yNIoIoekJcKBn2H395B8X1dWpAo0+wLKtn7kQQshhMgb8kWSld+ZQyVptQr/nbnNrNBLHL8eC4ClhYr2gT6ENC1FeW/z+PKIfCAlDvbNgr0/QeqD6UuK1YRmoyAgWJItIUSeYQ7t9+NeOMk6c+YMERERpKVlHjz72muv5UhgpmJOlaQoCnvD7zErNIydF+/qy5uV96Jv01LU9pOJJkUOSYqGPdN10z2kJ+nKSjbUJVslzWO5LCGEeBZzar8zGJxkhYeH8/rrr3Py5En9WCxAP1+WqcdkvSxzrCSAUzdimbU9jPUnI3kw+wO1SrrTt2kpgst5YSHTP4ickBAFu/4HB38BzYOpTUo1191GLFbTtLEJIcQzmGP7bXCS1b59eywtLZk3bx7+/v4cOHCAe/fuMXToUL799lsaN25srFhzhTlW0qMu301k7o5w/j58nTSNbkmjckWcCWkaQLvAolhbysBlkQNir+sGxx9d8nAx6nJtIXgkeFc2bWxCCPEU5th+G5xkFS5cmK1btxIYGIirqysHDhygXLlybN26laFDh3L06FFjxZorzLGSniYqLoVfdl9m6b4IElJ1jWAxN3v6NAng7Vq+2NvII/kiB0Rf1k37cGLZg4W2VVC5k+5pxMJlTB2dEELomWP7bXC3h0ajwdnZGdAlXDdv3gR0TxWeP38+Z6MTWfJysWNEmwrsHt6MT1uVo7CTDTdikvny39M0nLqV6VsuEpMkk02Kl+ThD6/Pgn77odLrgAKn/oYZdWBVP7h/xdQRCiGE2TK4J6tx48YMHTqUjh078u6773L//n1GjRrF3LlzOXz4MKdOnTJWrLnCHDPh7EhJ1/Dn4evM3RHGtehkABxsLHm3Tgl6NfbHx9XexBGKfOHWSd1SPefX6V5bWEONbtBkGLgUNW1sQogCzRzbb4OTrI0bN5KYmEinTp24dOkS7dq148KFCxQqVIjly5fTrFkzY8WaK8yxkgyh1mhZezKSWaFhnLsVD4C1pYrXqxfjo6BSlPJ0MnGEIl+4fli3CHX4Nt1rS1uo/SE0GgJOnqaNTQhRIJlj+50j82RFR0fj7u6uf8IwLzPHSnoRiqIQeuEOs0LDOHA5GtBNedSqojd9m5aiqq+baQMU+cOVXbB1AkTs1b22doR6IdBgINi7mzY2IUSBYo7tt0xG+hhzrKSXdfhqNLNCw9l89uHC2Q1KFaJv01I0Kl04XyTHwoQUBcK26JKtmw8efLF1hQYDoF5fsHU2bXxCiALBHNtvg5OsxMREpkyZwpYtW4iKikKr1WbaHh4enqMB5jZzrKSccvF2PLO3h/PPsRuoH0y2VbmYC32DStO6sjeWMteWeBmKohurtXUiRJ3Wldl76G4h1v4QbGRZKCGE8Zhj+21wktWlSxe2b99O165d8fHxeaIXZNCgQTkaYG4zx0rKaTdikpm3M5xlB66RnK6bPNavkAMfBZWiU41i2FrJ9A/iJWi1cHoFhE6Ge5d0ZU5FoPEwqNkdrGTBcyFEzjPH9tvgJMvNzY21a9fSsGFDY8VkUuZYScYSnZjGoj1XWLjnCrHJ6QB4OdvSq5E/79YtgbOdtYkjFHmaRg0nlsP2KRAToStz9YWgz6BqF7CU75cQIueYY/ttcJLl7+/PunXrqFChgrFiMilzrCRjS0xVs+zgNebtDCcyNgUAZzsrutUvSY8G/ng6S8+DeAnqNN3M8Tu+gfhIXZlHgG5C08pvgIX0nAohXp45tt8GJ1m//vor//zzD4sWLcLBIf+NsTDHSsotaWot/xy7weztYYTdSQTA1sqCt2v50qdJAL4e+a++RS5KT4ZD82HnNEh6sOC5ZwXdUj0V2usefxVCiBdkju13tpKs6tWrZxp7denSJRRFwc/PD2vrzF3+R44cyfkoc5E5VlJu02oVNp29zczQMI5fiwHA0kJFu0AfQoJKUcGnYH4uIoekJsCBObD7B0iJ1ZX5VIXgUVCmpSRbQogXYo7td7aSrHHjxmX7hF9++eVLBWRq5lhJpqIoCvvCo5m1PYwdF+7oy4PLedK3aWlq++WPudGEiSTHwN4ZsG8mpCXoynzrQrNR4N/EpKEJIfIec2y/ZZ6sx5hjJZmDUzdimb09jHUnI3kw+wM1S7rTN6gUzcp7YSHTP4gXlXgPdn8PB34GtW5JKPybQLPR4FvHpKEJIfIOc2y/DU6yDh48iFarpW7dupnK9+/fj6WlJbVq1crRAHObOVaSOblyN5G5O8P569B10jS6OdLKFnEiJKgU7asWxdrS4DXHhdCJvwU7v4NDC0Cre9qVMq2g2Re624lCCPEM5th+G9wi9u/fn2vXrj1RfuPGDfr3758jQQnz5VfYkUmvV2HX58GEBJXCydaKC7cT+OSP4zT9JpQFuy+TlKY2dZgiL3L2hle/gY+P6BadVlnCxY0wpwks7wpRZ00doRBCGMTgniwnJydOnDhBQEBApvLLly8TGBhIfHx8jgaY28wxEzZnscnpLN1/lfm7LnM3IQ0AdwdrejTwp3uDkrg52Jg4QpFn3QuD0Clw8k9AAVRQ5S1oOhwKlTJ1dEIIM2OO7bfBPVm2trbcvn37ifLIyEisrKxyJCiRd7jaW9OvaWl2fd6MCR0rU8LDgftJ6fxv8wUaTNnK+DVniIxNNnWYIi8qVAre+Bn67YUKrwEKnPwDfqoN/w6EmCd71IUQwpy80LI6kZGR/PPPP7i6ugIQExNDx44d8fLy4o8//jBKoLnFHDPhvESt0bLu1C1mhYZxNjIOAGtLFR2rFeOjoFKU9nIycYQiz7p5FLZNgov/6V5b2kDNHtB4qO5WoxCiQDPH9tvgJOvGjRs0adKEe/fuUb16dQCOHTtGkSJF2LRpE76+vkYJNLeYYyXlRYqisP3CHWaFhrH/cjSgm/7olYpF6Nu0NNV83UwboMi7IvbD1vFwZafutZU91OkNDQeDYyGThiaEMB1zbL9faAqHxMREli5dyvHjx7G3tycwMJAuXbo8MTFpXmSOlZTXHb56n9nbw9h05uFt5voBhejbtBSNyxSWubbEiwnfDlsnwPUDutc2zlC/H9TvD3aupo1NCJHrzLH9lnmyHmOOlZRfXLwdz+zt4fxz7AbqB5NtVSrqQt+mpWhT2QdLmWtLGEpR4OImXc/WrRO6Mjs3aPgx1PkIbOX2tBAFhTm235JkPcYcKym/uRGTzLyd4Sw7cI3kdA0AfoUc6NOkFJ1qFMPOWhYMFgbSauHcat2YrTvndGWOntDoE6j1AVjbmTY+IYTRmWP7LUnWY8yxkvKr+4lpLNxzhUV7rxCTpJt80tPZll6N/Hmvbgmc7fL+7WeRy7QaOPW3Ltm6f1lX5lwUmgyD6l3BSqYUESK/Msf2W5Ksx5hjJeV3ialqlh28xryd4UTGpgDgbGdF13ol6dnQH09nWxNHKPIcTToc+w22fw1x13VlbiV1c2xVeRssZboZIfIbc2y/Jcl6jDlWUkGRptbyz7EbzN4eRtidRABsrCx4u1Zx+jQuRYlCDiaOUOQ56lQ4vAh2fgsJDx68KFQGgkdAxdfBQpaBEiK/MMf22+AkKyAggIMHD1KoUOZHpWNiYqhRowbh4eE5GmBuM8dKKmi0WoVNZ28zKzSMY9diALBQQbvAooQElaJiUakXYaC0JDj4M+z6HpJ1U4pQpDIEfwHl2ujmFxFC5Gnm2H4bnGRZWFhw69YtvLy8MpXfvn2bEiVKkJqamqMB5jZzrKSCSlEU9l+OZlZoGNsv3NGXNy3nSd+gUtTx95DpH4RhUuJg/2zY8yOk6ibLpWgNaDYKSjWTZEuIPMwc2+9sJ1n//vsvAB07dmTRokX62d4BNBoNW7ZsYdOmTZw/f944keYSc6wkAaduxDJnRzhrT9zkwewP1CjhRt+mpWle3gsLmf5BGCIpWpdo7Z8N6Um6shINoPloKNnAtLEJIV6IObbf2U6yLB6MXVCpVDx+iLW1NX5+fnz33Xe0a9cu56PMReZYSeKhq/cSmbsjnD8PXydNrQWgjJcTIUGleK1aUawtZYyNMEDCHdj1Pzg4DzQPeuFLNYPgUVC8pmljE0IYxBzbb4NvF/r7+3Pw4EEKFy5srJhMyhwrSTwpKj6FBbuv8Oveq8SnqgEo6mrHh40DeKeOLw428vSYMEDcTdjxDRxZDFrd94lyr+rGbHlXNm1sQohsMcf2W54ufIw5VpLIWlxKOkv3RfDLrsvcTdD1RLg7WNO9gR/d6/vh7ijzIgkD3L+im/bh+O+g6HpKqdQJmo4Az7ImDU0I8Wzm2H6/UJK1ZcsWtmzZQlRUFFqtNtO2+fPn51hwpmCOlSSeLyVdw99HrjNnezgR0boxNvbWlnSpU4IPG/tT1M3exBGKPOXuRQidrJvYFEBlAYHvQNPPwd3PpKEJIZ7OHNtvg5OscePG8dVXX1GrVi18fHyeeLpr5cqVORpgbjPHShLZp9ZoWX/qFrNCwzgTqXt6zMpCRcfqxQgJCqC0l7OJIxR5yq1Tutnjz6/VvbawghrdoPEwcC1m2tiEEJmYY/ttcJLl4+PD119/TdeuXY0Vk0mZYyUJwymKwo6Ld5kVeol94dH68lcqFqFv01JUL+FuwuhEnnP9MGybCGFbdK8tbaH2h9BoCDh5mjY2IQRgnu23wUlWoUKFOHDgAKVKlTJWTCZljpUkXs6RiPvMDg3jvzO39WX1Ajzo27Q0TcoUlrm2RPZd2Q1bJ0DEHt1raweoGwINBoKDh2ljE6KAM8f22+Ak6/PPP8fJyYnRo0cbKyaTMsdKEjnjUlQ8s7eHs+roDdQPJtuq6ONC36aleLWKD5Yy15bIDkWB8G26ZOvGYV2ZrYsu0aobAnbye0MIUzDH9tvgJGvQoEEsXryYwMBAAgMDsba2zrR92rRpORpgbjPHShI562ZMMvN2Xub3AxEkp2sAKFnIgT5NAnijRnHsrC1NHKHIExQFzq/X3Ua8fUpXZu8BjQZD7d5gI2ttCpGbzLH9NjjJCg4OzvpkKhVbt2596aBMyRwrSRjH/cQ0Fu29wsI9V4hJSgegsJMtvRr58169ErjYWT/nDEIAWi2cWaUbIH/voq7MqYhucHzN7mBla9LwhCgozLH9lnmyHmOOlSSMKylNzbID15i3M5ybsSkAONta8X79kvRs6IeXs52JIxR5gkYNJ/+A0CkQc1VX5lIcgj6Dau+CpSTtQhiTObbfL5xkXbp0ibCwMJo0aYK9vT2KouSLAcTmWEkid6Sptfx7/Cazt4dxKSoBABsrC96qWZw+TQIoWcjRxBGKPEGdBsd+he3fQPxNXZlHgG5C08pvgIXcjhbCGMyx/TY4ybp37x5vv/0227ZtQ6VScfHiRQICAvjggw9wd3fnu+++M1asucIcK0nkLq1WYfPZ28wMDePYtRgALFTQNrAoIUEBVCrq+uwTCAGQngKH5sOuaZB4R1fmWR6CR0L59mAh62wKkZPMsf02+F/5kCFDsLa2JiIiAgeHhwM7O3fuzIYNG3I0OCFMwcJCxSuVvFnZrwHL+tQjqKwnWgVWH79J2+m76D7/APvC7z2xULoQmVjbQf1+8PExaP4l2LnBnXPwRzeYGwQX/tMNnhdC5FsG92R5e3uzceNGqlatirOzM8ePHycgIIDw8HACAwNJSEgwVqy5whwzYWF6p2/GMnt7OGtP3OTB7A9UL+FG36BStKhQBAuZ/kE8T0os7J0Be2dCWryurHgdaDYKAoJMG5sQ+YA5tt8G92QlJiZm6sHKEB0dja2tPEUj8qdKRV35sUt1tg1ryvv1SmBjZcHRiBj6LDnMK9/v4K/D10lTa59/IlFw2bnqbhUOOg4NB4GVPVw/AItfg0XtIWK/qSMUQuQwg3uyXn31VWrWrMn48eNxdnbmxIkTlCxZknfeeQetVstff/1lrFhzhTlmwsL8RMWnsGD3FX7de5X4VDUARV3t6NU4gHdq++Joa2XiCIXZi78FO6fB4QWgSdOVlXkFgr+AotVMGpoQeZE5tt8GJ1mnTp2iefPm1KhRg61bt/Laa69x+vRpoqOj2b17d55fbsccK0mYr7iUdJbui+CXXZe5m5AKgJuDNd3r+9GjgR/ujjYmjlCYvZhrsOMbOPorKLrJcanQXpdseVUwbWxC5CHm2H6/0BQOsbGx/PTTTxw/fpyEhARq1KhB//798fHxMUaM2ebn58fVq1czlU2ePJnhw4dn+xzmWEnC/KWka/j7yHXm7gjn6r0kAOytLXmnji+9GwdQ1M3exBEKs3cvDLZPhRN/AAqggipvQdPhUChv/+dViNxgju13vpqM1M/Pj169etG7d299mbOzM46O2Z/fyBwrSeQdGq3C+lORzAoN4/TNOACsLFR0rF6MkKAASns5mzhCYfaizkHoJDjzj+61ylI3mWnQ5+Dma9rYhDBj5th+G5xkLViwACcnJ956661M5X/++SdJSUl07949RwM0hJ+fH4MHD2bw4MEvfA5zrCSR9yiKws6Ld5kVGsbe8Hv68pYVi9C3aSlqlHA3YXQiT4g8DlsnwsWNuteWNlCzBzQeCs7eJg1NCHNkju23wUlW2bJlmTNnzhNrGG7fvp0+ffpw/vz5HA3QEH5+fqSkpJCenk6JEiV49913GTJkCFZWWQ9CTk1NJTU1Vf86Li4OX19fs6okkbcdjbjP7O1hbDx9W19W19+Dvk1LEVTWM1+slCCM6NoB2DoBLm/Xvbaygzq9oeEQcCxk2tiEMCP5Ismys7Pj3Llz+Pn5ZSq/cuUKFSpUIDk5OSfjM8i0adOoUaMGHh4e7NmzhxEjRtCzZ0+mTZuW5TFjx45l3LhxT5SbUyWJ/OFSVDxztoez8ugN1A8m26rg40LfpqV4tbI3VpYyA7h4hss7dMnWtQdTPdg4Qb1+UL8/2LuZNDQhzEG+SLJKlCjBTz/9xGuvvZap/J9//qF///5cv349RwMcPnw4U6dOfeY+Z8+epXz58k+Uz58/n48++oiEhIQs5/CSniyR227GJPPLrsv8fiCCpDTd02QlPBzo0ySAN2sWx85a1rYTWVAUuLQZto7X3U4E3fxbDT6GuiFg62Ta+IQwoXyRZH3++ecsX76cBQsW0KRJE0B3q/CDDz7gzTff5Ntvv83RAO/cucO9e/eeuU9AQAA2Nk8+Kn/69GkqV67MuXPnKFeuXLauZ46VJPKn+4lpLN57lYV7LnM/KR2Awk62fNDIj/frlcTFztrEEQqzpShwbo1uzNads7oyh8LQ+BOo9QFYy9OsouAxx/bb4CQrLS2Nrl278ueff+rHOmm1Wrp168bs2bOfmuyYytKlS+nWrRt3797F3T17A43NsZJE/paUpmb5wWv8vCOcm7EpADjbWvFevZJ80MgPL2c7E0cozJZWA6dW6J5GjA7XlTn7QJNhUL0bWJnP72MhjM0c22+DkixFUbh27Rqenp5cv36dY8eOYW9vT5UqVShZsqQx43yuvXv3sn//foKDg3F2dmbv3r0MGTKENm3asGjRomyfxxwrSRQM6Rot/x67yeztYVyM0q0BamNlwZs1i9OncQB+hbM/FYkoYDRqOP67bp6t2Gu6MrcSEDQcAjuDpaxAIPI/c2y/DUqytFotdnZ2nD59mjJlyhgzLoMdOXKEfv36ce7cOVJTU/H396dr16588sknBq2paI6VJAoWrVZhy7koZoZe4mhEDAAWKni1ig8hQaWoXMzVtAEK86VOhSOLdTPIJzx4mrVQaWg6Aip1Agt5uELkX+bYfht8u7BSpUr88ssv1KtXz1gxmZQ5VpIomBRF4cDlaGZtDyP0/B19eZOynvQNKkW9AA+Z/kE8XVoSHPoFdv0Pkh6MafWqBM2+gHKvgnxvRD5kju23wUnW6tWr+frrr5k1axaVK1c2VlwmY46VJMSZm3HM3h7GmhM3eTD7A9V83ejbtBQtKxTBwkIaTfEUqfGwbzbs+RFSY3VlRatDs1FQqrkkWyJfMcf22+Aky93dnaSkJNRqNTY2NtjbZ36KJTo6OkcDzG3mWElCZIi4l8TcnWH8ceg6aWotAH6FHKhewp2Awo4EeDpRyssRv0KOMhWEeCj5Puz5CfbNgvREXVmJBrpky6+haWMTIoeYY/ttcJL1vEHkplxWJyeYYyUJ8bg78aks2H2ZJXuvEp+qfmK7SgXF3OwJ8HQioLAjpbycKPUgCSviYiu3GQuqxLu6W4gHfgbNg/kBA4J1yVbxWqaNTYiXZI7td75aIDonmGMlCZGV+JR0dl+6S9idRMLuJBD+4M/4lCcTrwyONpb4ezpSytOJgMJOBHg66n4KO2FvI71fBULcTdj5HRxeBFrdHG2UbaMbs+VdxbSxCfGCzLH9fqEkKywsjAULFhAWFsYPP/yAl5cX69evp0SJElSqVMkYceYac6wkIQyhKAp3E9IIv5NA+N1Ewu8kEHZH9+e1+8lotFn/k9f1fjnqbz0GPEjGvF3sZNxXfnT/Kmz/Go7/Boru9jOVXoemI8GzrGljE8JA5th+G5xkbd++nTZt2tCwYUN27NjB2bNnCQgIYMqUKRw6dIi//vrLWLHmCnOsJCFySppaS0R0Yqaer4xkLObBrPNPY29tiX/hBz1enk6UepB8+Rd2xNFW5mDK8+5egtDJcOpvQAGVhW5+rbofgU81GSAv8gRzbL8NTrLq16/PW2+9xSeffIKzszPHjx8nICCAAwcO0KlTpxxfuzC3mWMlCZEbohPTHiReGbcdEwm/m0DEvST9gtZP4+1ip+/xykjCAgo7UszNXnq/8prbp2HbJN2SPRlcikO5NlC+Lfg1AktZ7kmYJ3Nsvw1OspycnDh58iT+/v6ZkqwrV65Qvnx5UlJSjBVrrjDHShLClNI1WiKikx72ej1IvsLuJBKdmJblcbZWFvgXfjT5ctSPAXOWdRnN240jsPsHuLjp4dOIALauUPYV3VxbpVuAnfyOFObDHNtvg/v53dzciIyMxN/fP1P50aNHKVasWI4FJoQwD9aWFpTydKKUpxNQJNO2mKQ0/Xiv8LuJhEXp/rx6L5FUtZZzt+I5dyv+iXN6Odtm6vXSPf3oRDF3eyyl98v0itWAtxdBegpc3q7r2Tq/HhLvwMk/dT+WNuDfRNfDVe5VcPY2ddRCmB2De7KGDRvG/v37+fPPPylbtixHjhzh9u3bdOvWjW7duvHll18aK9ZcYY6ZsBB5jVqj5fr9ZF2PV9TDnq/wO4ncTUjN8jgbKwv8CjkQUFg339fDpx+dcLWX3i+T0mrg+iE4vxbOrYV7lzJvL1YLyr8K5dtB4bIyjkvkOnNsvw1OstLS0ujfvz8LFy5Eo9FgZWWFRqPh3XffZeHChVha5u1HwM2xkoTIT2KT07ms7/XKGHyfyOV7ifoJVp+msJPNU5MvX3d7rCxlTb5cd+fCgx6udXD9YOZtHqV0PVzl20Lx2mCRt9sFkTeYY/v9wvNkXbt2jZMnT5KQkED16tXNbsHoF2WOlSREQaDRKty4n0zY3YQnxn/djsu698vaUkXJQo9PO6FLxNwdbXLxHRRg8bd0txPPrdXdXtQ8MlbP0RPKttb1cAUEgbV91ucR4iWYY/ud7SRLq9XyzTff8O+//5KWlkbz5s358ssvn1hWJ68zx0oSoqCLT9H1fmUkX2EPesIu39WN/cqKh6PNg+Qr8/ivEh4OWEvvl3GkxsOlzXBuHVzY+HDNRABrByjdHMq1hbKtwMHDdHGKfMcc2+9sJ1njx49n7NixtGjRAnt7ezZu3EiXLl2YP3++sWPMVeZYSUKIp9NqFW7GJj9Mvh70fIXfSSQyNusnna0sVJTwcMg071dGEubhaCPLDuUUTTpc3a3r4Tq3DuIemeJHZQklGzwcOO9e0nRxinzBHNvvbCdZZcqUYdiwYXz00UcAbN68mbZt25KcnIyFRf75H6E5VpIQwnCJqWrd2C/9bceHtyCT0zVZHudqb5153q/CuiSsZCFHbKzyz++6XKcoEHlcN4br3Fq4fSrz9iJVHgycbwvegTJwXhjMHNvvbCdZtra2XLp0CV9fX32ZnZ0dly5donjx4kYLMLeZYyUJIXKOoijcikvRP/UY/sjs9zdikrM8zkLFg94vpyeWHSrsJL1fBrt/Rde7dX6drrdLeeS2r6uvrner/KtQsqFMgCqyxRzb72wnWZaWlty6dQtPT099mbOzMydOnHhizqy8zBwrSQiRO5LTNLqxX3czLzkUFpVAYlrWvV/Odla6244Pxn/pesGcKFnIATtrebLuuZKideO3zq2BsK2QnvRwm50rlGml6+Eq3RxsnU0XpzBr5th+ZzvJsrCwoE2bNtja2urLVq9eTbNmzXB0dNSXrVixIuejzEXmWElCCNNSFIWo+NRH1nt80Pt1N4Hr95PJ6reoSgXF3e0f3HJ8OPN9KU8nvJxtpffradKTITxUd0vx/HpIuvtwm6UNBDTV9XKVexWci2R1FlEAmWP7ne0kq2fPntk64YIFC14qIFMzx0oSQpivlHQNV+8lPRh4/+D244PxX/Ep6iyPc7K1ejDm6+Gtx4DCukW37W2k9wt4MAHqQV0P17m1EB3+yEYVFK/1YOB8W/Asa7IwhXkwx/b7hefJyq/MsZKEEHmPoijcTUh7+NTjg1uP4XcSiIhOIqs1t1UqKOpq/+Tgey9HvF3sCm7vl6LAnfMPZ5y/cTjz9kJlHs44X6wW5KMHskT2mGP7LUnWY8yxkoQQ+UuqWkPEvaRMU05kJGOxyelZHudgY4l/4cxzfmXMA+ZgY/BStHlbXKRu0Pz5dRC+HbSPfG6OXlCuja6Xyz8IrO1MF6fINebYfkuS9RhzrCQhRMGgKArRiWmZppvI6AWLiE5CnVX3F+Djavew9+uRW5BFXe2xyO+LbqfEPZgAdS1c3PTYBKiOugHz5dtB2VfA3t10cQqjMsf2W5Ksx5hjJQkhRLpGS0R00iO9Xg/n/4pOTMvyODtrC/wK6Xq9Sj06/svTCSfbfNj7pU6Dq7seTg8Rd+PhNpUl+DXUjeEq/yq4lTBdnCLHmWP7LUnWY8yxkoQQ4lliktIIe2S+r4zxX1fvJZKuyfpXfBEX20yLbQd4OlLa04mibvZY5ofeL0WByGMPZ5yPOp15u3cVXQ9XuVd1fy+o493yCXNsvyXJeow5VpIQQrwItUbL9fvJj/R6ZQzCT+RuQtaLbttYWeBXyCHfjfMqoomkTuo+6qbtpUL6GSx5OAFqlIUX+23rsd+mPmesK6NVyROexvRnSP0cXz/UHNtvSbIeY46VJIQQOS02OV0/7uvRme+v3E0iTZP1otv5hTtxNLc8SkuLwzSxOIG96uEt1xjFkS3a6mzS1GKHNpAkZOB8TrswoU2OL1Nlju23JFmPMcdKEkKI3KLRKty4n8yVe4mkqfN/sgVgoU7G4/YevG5spnDkVmxS7+u3aSxsiC7SgDvFWnC3aDPS7AqbMNL8o1l5rxx/IMMc229Jsh5jjpUkhBAil2g1cG3/g3Fca+H+5Uc2qsC3zoN1FdtB4dImC1M8yRzbb0myHmOOlSSEEMIEFAXunHsw4/w6uHkk8/bCZR/OOF+spkyAamLm2H5LkvUYc6wkIYQQZiDupm5aiHNr4fLOzBOgOhV5MAFqO/BvAla2WZ9HGIU5tt+SZD3GHCtJCCGEmUmJ1U18en7dgwlQ4x5us3GC0i10vVxlWsoEqLnEHNtvSbIeY46VJIQQwoyp0+DKTl0P1/n1EH/z4TYLKyjZ8MF8XG3Azdd0ceZz5th+S5L1GHOsJCGEEHmEVguRR3VjuM6thTtnM2/3qfpgxvm2UKSSTICag8yx/ZYk6zHmWElCCCHyqHthD8ZxrYNr+0B5ZFoMtxIPZ5wvUR8s89fkr7nNHNtvSbIeY46VJIQQIh9IvAsXNuh6uMK2gjrl4TZ7dyjbWtfDVaoZ2DiaLs48yhzbb0myHmOOlSSEECKfSUuEsG26Xq7z6yE5+uE2KzsICNYtYl22DTh5mi7OPMQc229Jsh5jjpUkhBAiH9OoH06Aen4t3L/yyEYV+NbV9XCVbwuFSpkqSrNnju23JFmPMcdKEkIIUUAoCkSdfTDj/BqIPJZ5u2f5hzPOF60uE6A+whzbb0myHmOOlSSEEKKAir2uu514bq1umgit+uE2J2/dLcVybcG/cYGfANUc229Jsh5jjpUkhBBCkBwDlzbrerguboa0+IfbbJyhTAtdwlWmJdi7mSpKkzHH9luSrMeYYyUJIYQQmahTdUv7nF+rmx4i4dbDbRZW4Nfo4QSorsVNF2cuMsf2W5Ksx5hjJQkhhBBZ0mrh5lFdD9f5dbpFrR/lU02XcJV/Fbwq5tsJUM2x/ZYk6zHmWElCCCFEtt0LezBwfq3uqUUeaebd/R7MOP8q+NbLVxOgmmP7LUnWY8yxkoQQQogXknAHLqzX3VIM3/bYBKgeutuJ5V59MAGqg+nizAHm2H5LkvUYc6wkIYQQ4qWlJepmmj+3VjfzfPL9h9us7KFUsG4urrKtwbGw6eJ8QebYfkuS9RhzrCQhhBAiR2nUELH3wbqKayAm4uE2lYXuVmL5V3W9XHlkAlRzbL8lyXqMOVaSEEIIYTSKArdPP5xxPvJ45u2eFR7MOP8q+JjvBKjm2H5LkvUYc6wkIYQQItfEXHswAeoauLo78wSozkV147jKvwp+TcDKxnRxPsYc229Jsh5jjpUkhBBCmETyfd3Ep+fW6CZCTUt4uM3WBUq30PVylWkJdq6mixPzbL8lyXqMOVaSEEIIYXLqVLi848F8XOsh4fbDbRbWuqV9yrfVjeNyKZrr4Zlj+y1J1mPMsZKEEEIIs6LVwo3DD2acXwt3L2TeXrTGw3UVvSrkygSo5th+m+fotaeYOHEiDRo0wMHBATc3t6fuExERQdu2bXFwcMDLy4tPP/0UtVr91H2FEEII8YIsLMC3NrQYCwMOwoDD0PIr8K0LqODmEdg6AWbVh+nVYeMXcHUPaDWmjjxX5ZmpXtPS0njrrbeoX78+v/zyyxPbNRoNbdu2xdvbmz179hAZGUm3bt2wtrZm0qRJJohYCCGEKCAKl4bCg6DhIEiIejBwfi2Eh8L9y7D3J92PQyEo2waajwZnb1NHbXR57nbhwoULGTx4MDExMZnK169fT7t27bh58yZFihQBYPbs2Xz++efcuXMHG5vsPQFhjt2NQgghRJ6UmgBhW3Qzzl/YACkxYGkLn4WDrVOOXsoc2+8805P1PHv37qVKlSr6BAugVatW9O3bl9OnT1O9evWnHpeamkpqaqr+dVxcnNFjFUIIIQoEWyeo2EH3o0nXTYB671KOJ1jmKs+MyXqeW7duZUqwAP3rW7duZXnc5MmTcXV11f/4+voaNU4hhBCiQLK0Bv8mUOsDU0eSa0yaZA0fPhyVSvXMn3Pnzhk1hhEjRhAbG6v/uXbtmlGvJ4QQQoiCwaS3C4cOHUqPHj2euU9AQEC2zuXt7c2BAwcyld2+fVu/LSu2trbY2tpm6xpCCCGEENll0iTL09MTT0/PHDlX/fr1mThxIlFRUXh5eQGwadMmXFxcqFixYo5cQwghhBAiu/LMwPeIiAiio6OJiIhAo9Fw7NgxAEqXLo2TkxOvvPIKFStWpGvXrnz99dfcunWLUaNG0b9/f+mpEkIIIUSuyzNTOPTo0YNFixY9Ub5t2zaaNm0KwNWrV+nbty+hoaE4OjrSvXt3pkyZgpVV9nNJc3wEVAghhBDPZo7td55JsnKLOVaSEEIIIZ7NHNvvfDOFgxBCCCGEOZEkSwghhBDCCCTJEkIIIYQwAkmyhBBCCCGMQJIsIYQQQggjkCRLCCGEEMIIJMkSQgghhDACSbKEEEIIIYxAkiwhhBBCCCOQJEsIIYQQwggkyRJCCCGEMAJJsoQQQgghjECSLCGEEEIII5AkSwghhBDCCCTJEkIIIYQwAkmyhBBCCCGMQJIsIYQQQggjkCRLCCGEEMIIJMkSQgghhDACSbKEEEIIIYxAkiwhhBBCCCOQJEsIIYQQwggkyRJCCCGEMAJJsoQQQgghjECSLCGEEEIII5AkSwghhBDCCCTJEkIIIYQwAkmyhBBCCCGMQJIsIYQQQggjkCRLCCGEEMIIJMkSQgghhDACSbKEEEIIIYxAkiwhhBBCCCOQJEsIIYQQwggkyRJCCCGEMAJJsoQQQgghjECSLCGEEEIII5AkSwghhBDCCCTJEkIIIYQwAkmyhBBCCCGMQJIsIYQQQggjkCRLCCGEEMIIJMkSQgghhDACSbKEEEIIIYxAkiwhhBBCCCOQJEsIIYQQwggkyRJCCCGEMAJJsoQQQgghjECSLCGEEEIII5AkSwghhBDCCCTJEkIIIYQwgjyTZE2cOJEGDRrg4OCAm5vbU/dRqVRP/Cxbtix3AxVCCCGEAKxMHUB2paWl8dZbb1G/fn1++eWXLPdbsGABrVu31r/OKiETQgghhDCmPJNkjRs3DoCFCxc+cz83Nze8vb1zISIhhBBCiKzlmSQru/r378+HH35IQEAAISEh9OzZE5VKleX+qamppKam6l/HxsYCEBcXZ/RYhRBCCJEzMtptRVFMHMlD+SrJ+uqrr2jWrBkODg78999/9OvXj4SEBD7++OMsj5k8ebK+l+xRvr6+xgxVCCGEEEYQHx+Pq6urqcMAQKWYMOUbPnw4U6dOfeY+Z8+epXz58vrXCxcuZPDgwcTExDz3/GPGjGHBggVcu3Yty30e78nSarVER0dTqFChZ/aAGSouLg5fX1+uXbuGi4tLjp03P5LPKvvkszKMfF7ZJ59V9slnlX3G/KwURSE+Pp6iRYtiYWEez/WZtCdr6NCh9OjR45n7BAQEvPD569aty/jx40lNTcXW1vap+9ja2j6xzZiD5V1cXOQfYTbJZ5V98lkZRj6v7JPPKvvks8o+Y31W5tKDlcGkSZanpyeenp5GO/+xY8dwd3fPMsESQgghhDCWPDMmKyIigujoaCIiItBoNBw7dgyA0qVL4+TkxOrVq7l9+zb16tXDzs6OTZs2MWnSJIYNG2bawIUQQghRIOWZJGvMmDEsWrRI/7p69eoAbNu2jaZNm2Jtbc2MGTMYMmQIiqJQunRppk2bRu/evU0Vcia2trZ8+eWX0quWDfJZZZ98VoaRzyv75LPKPvmssq+gfVYmHfguhBBCCJFfmcfweyGEEEKIfEaSLCGEEEIII5AkSwghhBDCCCTJEkIIIYQwAkmyhMjn5NkWkdMeXSVDCJE1SbKEyKfCwsK4f/9+ji4PJcT58+dp2bIlly5dMnUoQpg9SbKEyIeOHz9OmTJlWLlypalDEfnIsWPHqFevHrt27eLEiROAbr1XIcTTyTxZQuQzx48fp2HDhgwYMIApU6aYOhyRTxw/fpz69evzxRdfcOLECcLCwjh06JCpwxLCrElPlhD5yLlz56hVqxaff/45U6ZMQavVsnXrVubOncuePXu4ceOGqUMUedCxY8eoU6cOgwYN4osvviAkJIS7d++yfPlyU4cmhFnLM8vqCCGeTavV8scff6DRaHjzzTcBaNmyJffu3ePKlSsULlwYPz8/pk2bRmBgoImjFXlFdHQ0vXv35pNPPmHy5MkAVKlSBQ8PD9auXUvnzp1NHKEQ5ktuFwqRj9y+fVu/zmeZMmUoW7YsY8aMoWLFiqxZs4bZs2fj6urK/PnzcXJyMnW4Io84ePAgtWvXBkCj0WBpacnKlSt599132bBhA0FBQSaOUAjzJLcLhchHihQpwoQJE+jVqxd2dnZMmDCBqlWrYm1tzeuvv06bNm3YuXMnsbGxpg5V5CG1a9fWTwViaWkJQPXq1alUqRJbtmwBZAC8EE8jtwuFyMNu3rzJkSNHSEtLo0SJEtSqVQtPT09GjRrF1atXKVWqFPCw96F06dK4u7tjY2Nj4siFOXv0e+Xn50eNGjVQqVQoiqKfEsTPz4/WrVszc+ZMBgwYgJeXl4mjFsL8yO1CIfKokydP0rFjRwoXLkx4eDh+fn589tlnvPXWWwCZGsQMgwcP5syZM6xcuRJHR0dThC3M3NO+V59//rl+nB/oeq0sLCy4fv067du3p2PHjowePRoLC7k5IsSj5F+EEHlQWFgYr776Km+++Sb//fcfGzZsoFKlSmzYsAGNRvNEghUREcGnn37KkiVL+O677yTBEk+V1fdq/fr1+u8VoE+mihYtipeXF6GhoajValOGLoRZkp4sIfKYtLQ0RowYwfXr11myZIn+1t/8+fP57LPPOH/+PIUKFdLvf+DAAebMmcOePXv4/fffqVatmokiF+bM0O9VRiJ/7do1kpOTKVu2rKlCFyLHPe1OwIuQMVkF3LRp0yhVqhSNGjXK9AtUmC+tVkvx4sWpUKECNjY2+l8GDRo0wMnJifT09Ez716lTh/j4eL766iuKFStmoqiFuTP0e6VSqUhPT8fX19dEEQuRc4YNG0blypWpXr06VatWzbHlyCTJKsBOnz7NnTt3mD59OtWrV6dkyZJ8//33pg5LPIednR0dO3bE398/U7mbmxvW1taZGsPDhw9Ts2ZNmjdvntthijzGkO/V0aNHqV69OtbW1rkdphA57u7du/j4+PDLL79gYWGBt7c306ZNw8vL66W/4zImqwCrVKkSkydPZuvWrXTq1Il//vmHatWqsWXLFlJTU00dnnhEZGQkBw4cYMOGDWi1Wn1DqNFo9P/jio2N5f79+/pjxowZo5+MVEYFiKd50e9V8+bN5Xsl8o3ChQszdOhQVqxYwaRJkzh79iytW7dm0aJFLz/djSIKnO7duyvvv//+E+VJSUlKs2bNlAoVKijLly9X0tLSTBCdeNzx48eVkiVLKmXLllVcXV2V8uXLK7/99pty7949RVEURavVKoqiKOfPn1c8PT2V6OhoZfz48Yq9vb1y6NAhU4YuzJh8r4RQFI1G89Ty7t27KzVq1FCmTJmixMXFvfD5pSergElOTqZq1ar8999/DB48WF+elpaGvb09W7ZsoXz58owePZpz584ByP9WTejOnTt07tyZ9957j/Xr13PmzBmqVq3K+PHjmT59Onfu3NH3OLi5uVG8eHH69u3L+PHj2blzJzVr1jTxOxDmSL5XQjycigR0vbqPPiG7cOFCGjduzPLly9m6deuLX+SF0zORZ8XHxytz585VihYtqgwaNEhfnpycrP97rVq1lODgYBNEJx51+vRpxc/P74meg88//1ypUqWK8vXXXyuJiYmKoijKmTNnFJVKpdjb2ytHjx41QbQir5DvlSjoHu3B+uqrr5QePXooW7ZsUbRaraJWq/XbXnvtNaVatWovfB3pySpANBoNAE5OTvj5+dGlSxemT5/OqFGjAN3A15SUFAB+++03bty4wZw5c0wWr4D09HTUajVJSUmAricSYMqUKQQHBzNr1iwuXboEgLu7O/369ePIkSMyTYN4JvleiYIuowdrxIgRTJ8+nbZt21KpUiVUKhWWlpb69nL58uXEx8czevToF7qOzJNVAH366ads2bKFwMBA9u/fz+XLlwkJCdE/WajRaEhPT2f06NGo1Wr+97//mTbgAq5OnTo4OTnpu6xTU1OxtbUFdGvKlS5dmt9//x2AlJQU7OzsTBaryDvkeyUKun379vH++++zYMECGjdu/MT2jNuJs2fPZt++fSxcuNDga0hPVgGzYcMGfv75Z3788UcWLlxIaGgoEyZMYMmSJXzyySeAbgFYOzs72rVrx9KlS/X/oxXGl5iYSHx8PHFxcfqyOXPmcPr0ad59910AbG1t9WMHmjRpQmJion5faQjF08j3ShR0X3zxBadOncpUlpCQgFqtpkSJEk/sn9HbC7r/kKxZs4bjx48bfF1JsgqYGzdu4OXlRZ06dQAoUqQIPXr00PdkjR07Vr9vUFAQU6ZMwcHBwUTRFixnzpyhU6dOBAUFUaFCBZYuXQpAhQoV+OGHH9i0aRNvvfUW6enp+q7uqKgoHB0dUavV8oCCeCr5XomC7uzZs5w4cYLy5ctnKr9//z63b9/Wr27w6Fxwu3bt0i8XVaNGDWbPnv1CbaHcLixgdu3aRefOnfntt98ICgrSlx88eJDmzZuTkJDAN998w9ChQwG4efMmRYsWNVW4BcaZM2do0qQJ3bp1o1atWhw+fJgff/yR/fv3U716dZKSktiyZQv9+vXDycmJ8uXLY2Njw9q1a9m3bx+VK1c29VsQZki+V6KgUx6sXJDx519//YWPjw8NGzYkNTWVxo0b4+joyL///ouzszOgG6PYsWNHmjRpwhdffAFAdHQ0Hh4eBl9fkqx86tFHU0E3zsrS0pLIyEjefPNNypYty+DBg6latSoA586dY+zYsbz//vu0adMGS0tLU4Ve4ERHR9OlSxfKly/PDz/8oC8PDg6mSpUqTJ8+XV8WHx/PhAkTiI6Oxs7Ojr59+1KxYkVThC3MnHyvREGnKAoajQYrK93iNnfv3qVcuXI0adKEkSNHUrt2bVatWsXkyZNJTU1lwoQJ3Llzhz/++IObN29y+PBh/bEvSpbVyYceTbC+//57Tp06xYkTJ+jTpw/t27dn6tSp9O7dmwkTJtC8eXOqVq3K2LFjcXR0pG3btqhUKn1SJowvPT2dmJgY3nzzTeBh/fn7+xMdHQ3oflkoioKzszNTp07NtJ8QTyPfK1HQ3b59G29vbwCWLVvGq6++ysaNG+natSuTJ0/myy+/pGPHjhQtWpRJkybRp08ffHx88Pf359ChQ1hZWb10Wyg9WfnY8OHDmT9/PiNGjODu3bv8/vvvVK9enb///puNGzeyZMkS1q5di4+PD25ubmzfvh1ra+scW31cZN/FixcpU6YMoGscra2tGT16NFevXmXx4sX6/eLi4nBxcQFybpV4kX/J90oUVPv376dp06bs2bOHZcuWsWjRIvbt24efnx+HDh2iS5cuVK5cmTFjxlC9enUAIiIi8PDwwNHREZVKhVqtfumeLPnvSj61Z88eVq5cydq1axkyZAitW7fm2rVrdOjQAYBWrVrx66+/cvbsWf7991927dqFtbU1arVafsGaQEZDqNVq9QuSKopCVFSUfp/Jkyczb948/RMvUk/ieeR7JQoqDw8P3n//fYKCgpg7dy5Hjx7Fz8+P9PR0atWqxW+//capU6eYOHEi+/btA6BEiRI4OTmhUqnQarUvnWCBJFn5RsbEaRlSUlJwcnKidu3a/PHHH7Rt25bp06fTrVs3EhIS2LRpE3FxcXh7e1O6dGksLCxy7EslXpyFhUWmp7kybtuMGTOGL774gubNm0sdCYPJ90oUFBnf8zJlylCqVCkSEhJQFIWIiAhA991Xq9XUrl2b33//ndOnTzNixAjOnj2b6Tw5dctckqx8IuOe8f79+0lPTyctLQ2NRsOqVavo06cPkydPpm/fvgDs3LmT3377TT8uI4OMwzAPGb8krKys8PX15dtvv+Xrr7/m0KFD+gcVhDCUfK+EuXh8lFJOjVrSarX6ntj4+Hjatm1LaGgonTt3pk2bNmzduhVLS0v99WrVqsWvv/5KkSJFKFeuXI7E8Dj5r0set2bNGubOncu///7LkCFDOHToEOvXr6d169Z89dVXdOrUiTlz5tC7d29A18M1Y8YMHB0dKVmypImjF0+TkexaW1vz888/4+Liwq5du6hRo4aJIxN5mXyvhDk4f/48S5cuJSIigkaNGtGoUSPKly//0g9cPHr8lClTiI2N5cMPP6RKlSoUKVKEtLQ03nzzTVatWkWTJk0A+OGHH+jWrRvLli174hw5RQa+G9m1a9fYsWMHqamplCtXjoYNG+bYuTUaDStWrGDw4MG4u7tz/fp1Dh48qB+HsWfPHkJCQrC0tGTMmDHcu3ePP//8k5s3b3L06FGsrKzkSSIzdujQIerUqcOpU6fkcXqRY+R7JUzlzJkzNGjQgBYtWhAZGYlGo+HGjRssXLiQ5s2b58hDF5999hlLlixh4sSJtGnTBh8fHwAuXbrE+PHj+fvvv5k4cSJr1qzh1q1bHDt2zLhP0r/w0tLiuY4fP674+voqTZo0Uby9vZXg4GBlz549OXLujFXCNRqN8vrrrysqlUpp2bJlpn3S0tKUw4cPK23atFFKly6tNGjQQOnWrZuSlpaW6RzCfCUkJJg6BJEPyfdK5Da1Wq28//77ynvvvacvO3r0qNKrVy/F0tJSWbNmjaIoujbtRS1btkwpUqSIcvz4cX1ZbGyscv36dUWtVisxMTHKJ598olSsWFHp2LGjvi18mWs+j/RkGcm5c+cIDg6mZ8+efPnll5w9e5bXXnuN6dOn07Fjxxy7zt9//83NmzdJS0tj1qxZVK1alb///hsg0/we0dHR2Nra4uDgkGOPpgohhBDZkZ6eTsuWLalfvz6TJ0/Wl9+5c4cvv/ySBQsWsG3bNurVq/fC15g1axbr1q1j9erVnD17lrVr1zJr1iycnZ1p0KAB//vf/7C1tSU6Ohp3d/dcaQslyTKCpKQk+vbti42NDXPmzNHfjnvjjTeoWrUqzs7O+Pj48M477xh87scnGh05ciTHjx/Hx8eH9evX8+mnn1KzZk19ogWwZcsWGjVqhK2tLSDz4AghhMh9AwYM4MiRI6xduxZ3d3d9+bVr1xgyZAjJycn8/vvv+jnbnuVp7diMGTMYMmQIPXv2ZPPmzdSpU4eaNWuSkpLCkiVLWL16NWXLltXvnxvDZaQrwwgsLCx477338PT01FfgpEmTWLlyJVqtlri4OM6cOcOJEyeYNGmSwecGOHz4MCkpKcyfP18/Bqt9+/aoVCo+/fRT2rdvz08//UTv3r2xt7enWbNm+nNIgiWEECK3NWnShD179rBgwQJ69+6tXyvQ19eX9u3bM3LkSGJjY5+bZD2aHN26dYv4+HjKlClD//790Wg07N+/ny+++IJmzZrh5+fHhQsX+Ouvv/RzwWXIjfHI0pNlJImJiTg6OgKwb98+WrZsyW+//Ub79u1JSUlh6tSprFq1irVr1xq8APPRo0epWbMmAPPmzeODDz7Qb0tJSWHz5s0MGjQIjUaDt7c3O3fulJnchRBC5JorV66wcuVKEhISKFOmjP7OTf/+/dm6dSsff/wxnTt31i+6fObMGTp06MA///zzzAcyHm3Hxo4dy5o1a7h+/ToBAQH06NGDHj16YGVlpZ8bLiUlhTfffJO0tDQ2btyY6w96yWNlOSQuLo7r169z7do1tFotjo6O+rk46tWrx6lTp2jfvj0AdnZ2uLu7o9FocHV1Nfha1atXZ+HChdjY2HDw4EGSk5P12+zs7GjXrh1Hjx5l6dKl7NmzR2ZyF0IIkWtOnDhBw4YNWbt2LevWrWPIkCEsXboU0N3Sq1OnDrNmzWL8+PGEhYVx9+5dFi1ahIWFBUWKFHnmuTPasQkTJjBr1ixGjx7NpUuXAPjmm2+4cOECFhYWJCcnM2nSJDp06MDNmzdZt26dftLt3CS3C3PAqVOnGDBgADdu3MDe3p7GjRvzww8/ZFpcskSJEpmOCQ8Pp3Llys/NqrO6Z9ytWzeSk5Pp168fvr6+jBgxQv/lUxQFFxcX/XQRj65CLoQQQhjLhQsXePXVV+nWrRsTJkzg5s2b9OrVi5SUFP0+ixYtYty4cWzevJkyZcpQo0YNbty4wbp16yhUqNAzz68oCtHR0WzcuJHp06fToUMHtm7dysmTJ5k2bRqVK1dGrVZjb29P4cKFKVOmDOvWrcPKysokD3zJ7cKXdO7cORo1akSPHj1o0aIFR48e5Z9//mHQoEF06dLlif0TEhKYMmUKc+fOZdu2bVSqVCnLcz+aYP3yyy+cO3eO2NhY2rVrR1BQEK6ursycOZOBAwcyYcIEhg8fLr1VQgghTCI9PZ2QkBDUajW//PKLPqF5++23sbe3x93dnWLFivHpp58CuicLjxw5gpOTEyVLlqR48eLZus69e/do0aIF27dvZ/fu3bz99tt88803hISEkJyczG+//UaLFi0yTbj96NP2ucpok0MUADExMUq7du2U/v3768vS0tKU4OBgpWfPnk/sv27dOqVPnz5K8eLFlSNHjmT7OsOGDVM8PDyUHj16KIGBgUpgYKDSpUsX5e7du4qiKMqsWbMUa2trZcSIEYpWq335NyaEEEK8gNOnTys7d+7Uv540aZKiUqmU9957T+nTp49iZWWlfPjhh9k+39PaNK1Wq1StWlVp06aN4urqqsydO1e/LSwsTAkKClJWrFjxcm8kh8iYrJcQFxeHl5cXLVq0AHSZsrW1Na+//jr379/Xl2Xw9fWlcuXKhIaGUr169WxdY/v27fz555+sXbuWBQsWcPz4cfr378/NmzcZPnw4ycnJhISEMHXqVHbu3Jnzb1IIIYTIpgoVKtCoUSMAjh8/zurVq1mzZg2//vorc+bM4bfffmPZsmWcOnXquWsWProW4fXr1/WLPatUKkaOHMmJEydo0KCBftm4pKQkBg4ciJWVFa+99ppx32g2yUCdl+Dh4cH7779PcHAwkPlx0JiYmExlWq2WypUrU758eYPuCUdHR5Oenp5pTFePHj2IjY1l8eLF3L9/H3t7e4YMGcLgwYNRqVTyFKEQQohcERkZybVr17h//z4tWrTIdEuuatWq/PXXX5meoNdqtfj7+1O0aNHntlMZ7eeoUaNYs2YNMTExDB48mNdff53XXnuNM2fO8OOPP/LKK69QqFAhbt68yf379zl8+DCWlpamu0X46Hsw6dXzoISEBFJTU4mJicHR0VGfYD369J5arSY1NRXQPQkxatQo3n33XYBsV3hGD5izszMODg5cv34d0H1BbWxs+PDDD7lw4QK7d+/WHyMJlhBCiNxy4sQJ6tevT9euXencuTOVK1fm999/Jzo6Wr9PxtqBGQ4fPkzJkiWxtrbO1jX++OMPFi9ezPDhw2nXrh1z585l0qRJ3Lp1i1GjRvHnn3/i6uqKu7s7rVu35siRI/on6k2dYAEyJssQJ06cUBo2bKjUqFFDKVmypPL9998rYWFh+u0Z6x8tWrRICQ4OVhRFUUaMGKHY29srBw8efOa5s1o7KSEhQSlXrpzSsmVL5ebNm/ryiIgIJTAwUNm2bdtLvishhBDCMFFRUUr58uWVkSNHKmFhYcqNGzeUzp07KxUqVFC+/PJLJSoqKtP+kZGRyhdffKG4ubkpJ06cyPK8j7eFy5YtU7755hv963nz5inVq1dXPvzwQ+Xs2bNPPYc5rcsrtwuz6cqVKwQHB/P+++9TvXp1IiIiGDduHAcOHOCjjz6iSZMm+q5NjUaDo6MjY8aMYdq0aezevVs/eejTKIqiP3bGjBkcPXoUKysrWrRowZtvvsmGDRto0KABnTt3pkuXLpQoUYIff/wRKysrGjdunCvvXwghhMhw584dUlJS6NSpEwEBAQAsW7aM4cOHs2LFChwdHenfvz8ODg7s27ePX375hc2bN7Nt2zaqVKny1HM+2hb+8ssvXL58mYsXL+qnIwLo1asXKpWKGTNm8P333/PRRx/pxzgrD+7kmEUPVgYTJ3l5xqxZs5S6detmKtuwYYNSs2ZN5Y033lD279+vL58+fbqiUqkUZ2dn5dChQ88876NZ+8iRIxVXV1fljTfeUF599VVFpVIpgwYNUhRFUW7cuKG88sorSsWKFZVKlSopr776qn4FcXPK2oUQQuR/x44dU4oXL67s2LFDURRFSUpK0m/7+OOPFX9/f+X48eOKoihKeHi4snLlSiU8PDzL8z3aFo4YMUJxdnZWGjVqpNjb2ysVKlR4oi2dP3++Urx4cWXKlCk5+bZynCRZ2TR79mylQoUKSnR0tKLVavVfiM2bNyvly5dXBgwYoKSmpiqKoij//fefUqdOHeXUqVPZPv+pU6eUPn36KHv37tWXrVixQrG2tlZGjhypKIqipKSkKHfv3lWuXbumf6w1PT09p96iEEIIkW21a9fWD41RFF0blaFWrVpK586d9a+zO73Q6dOnlYEDByoHDhxQFEVR/vrrLyU4OFjp0KHDE1MfrVmzxuw7GSTJyqYNGzYo1tbWyqZNmxRFUfS9SIqiKH/++adiYWGhnxskPj5euXPnTrbP/ffffyvFihVTAgIClAsXLiiK8jCrX7x4sWJnZ5eppyxDVuO4hBBCiJyUkJCgxMXFKbGxsfqyI0eOKF5eXkqXLl30ZRn/8f/kk0+U9u3bG3SNjLawWrVqSmRkpL78jz/+UJo3b6689tprytGjR584zpwTLXm6MJtatWpFt27dePvttzl79izW1takpaUB8Oabb1K5cmV27doFgJOTE4ULF872uW1tbalZsybXrl3j5s2bAPr1lYKCgihSpAiRkZFPHJfbC10KIYQoeM6cOUOnTp0ICgqiQoUK+nUIK1SowA8//MCmTZt46623SE9P17dLUVFRODo6olarnzsfVgZbW1tq1KjBhQsX9E/UA7z11luEhISQkpLCgAEDuHjxYqbjzGoM1mNk4PtTXLp0iTlz5nDlyhUqVqxIv379KFKkCMOHDycyMpKgoCA2bdpE1apVAd1Adzs7O9zc3J577qetRdi2bVscHBxISEigd+/e/Prrr9SpUwfQJWyAfkoIIYQQIrecOXOGJk2a0K1bN2rVqsXhw4fp2bMnFStWpHr16rz22ms4OjrSr18/AgMDKV++PDY2Nqxdu5Z9+/ZlOS9kVm2hs7MziYmJ9OrVi19++YVatWoBus6M5ORkDh06RKlSpYz+vnOKrF34mFOnTtGyZUvq16+Po6Mj//zzD+3ateO3337Tbx8zZgxr165l/PjxuLu7c/HiRebNm8eBAwcoXbp0ludWHpnD6s8//yQtLQ17e3s6deoEwJYtW/jf//7HoUOHGDNmDNbW1qxevZqwsDBOnDhh1tm6EEKI/CU6OpouXbpQvnx5fvjhB315cHAwVapUYfr06fqy+Ph4JkyYQHR0NHZ2dvTt25eKFSs+9byPJlibN28mKSmJ1NRU3nrrLQB2797N1KlTuXHjBnPnzn3q0/lPS9LMkmnvVpqX69evK1WqVFGGDh2qLzt+/Lji6OiobN26VV+WkJCgTJ48WalWrZpSpUoVpXHjxk+9T5yV4cOHKy4uLkrFihUVV1dXJSQkRL9t69atSrNmzRRbW1vl1VdfVebMmaMfTGjO952FEELkL7du3VLq1Kmjf4IwYxxwz549lffee09RFCXTg2AZsjteeOjQoYqPj49StmxZxcnJSWnQoIGye/duRVEUZfv27UqHDh2U2rVrK3v27Mmpt5Tr5HbhIzZv3oyXlxdDhgwBdDO3lyxZkhIlSujHXwE4OjoyfPhwevXqhZOTE2q1Gmdn5yzPm5FxK4pCdHQ0R44cYceOHRQqVIh9+/bxwQcfkJyczMKFCwkODkar1TJ79myuXr1KjRo1sLW1JTU1FVtbW6N/BkIIIQRAkSJF+PXXXylTpgygGxpjYWFBsWLFuHr1KqBbaUSlUhEXF4eLi4u+7HkWLFjA4sWL2bhxIz4+Pmg0Gjp06MDHH3/MwoULadKkCWlpaYwbN4558+ZRv359471RI5Ik6xFNmjQhLCyMYsWKAbrBdK6urjg4OHD79u0n9vf09HzuOR/t0rx9+za3bt3C29ubEiVK4O7uzuuvv46NjQ3vv/8+KpWKBQsW0Lx5c7RaLTNmzKB///58//33efYLJoQQIu/KSLC0Wq1+KRxFUYiKitLvM3nyZGxtbfn444+xsrJ6Islau3YtdevWzfRA2Pnz52nYsCHVq1fXrzG4Y8cOatasyahRo1i1ahUtWrTAw8ODatWqGf+NGkkeuKGZe/z9/fnqq68AnlgDMDExUf/35cuXc/DgwWydMyPBGjlyJE2bNqVr167s2LFDv7aTpaUlbdu2ZenSpfzzzz906NABgJYtWzJ48GAcHR0ZOXIkqamp2X5CQwghhMhJGXdjHn0NMGbMGL744guaN2/+1EHuCxYs4K233uK3337LtKZhZGQk9+7dA3TtYHJyMg4ODnzzzTfs37+f8PBwAGrUqIGFhYX+ifu8RpKsLKhUKtRqNQD29va4uroCutXAu3TpQqFChZ55fMYCzwBLlizh999/5+OPP6Zr167ExsYyYsQI4uPjAd0X7NVXX2X27NkkJyfrr9u0aVPGjRvHkiVLsLW1lYWfhRBCmExGkmVlZYWvry/ffvstX3/9NYcOHdI/bf+4nj170rdvX3744Qd+/fVX7ty5A0CPHj04cuQIP/74I6BrZ0E3TKdw4cL6W48Z8sQg96eQ24XPkJHUaLVabG1tmTRpEv/73/84cOCAfq2mxyUlJeHg4KB/EnDdunVERETwxRf/b+/+Y6qq/ziOP68XCC6MWjjSzc2glTAtp2a5wFiMMTFqkAxoUWvDlJhthWzFvkjcVjOaJhVlEBCN0VYzYjRbNSJRuswU44dEhuRYoz9y/BghQy9yvn8YJzFEZ1xu9/J6/AXnnnt37t1ne7/2OZ/P+/yPrVu3AhAdHc3DDz/Mtm3bKC0tJTg4GKvVSkpKCqmpqQA4nU58fX31bEIREflPmAo6vr6+fPDBBwQHB9Pc3MzatWtnPH9qLfHevXtxOp3s378fgCeffJKoqCief/553nzzTcbHx9m+fTvDw8NUVFSwbNmya05keAq1cLgOcXFxdHd3MzAwQHNzs9m340ppaWmkpqayZcsWJicnGRwcJDQ0FIBdu3Zht9vNcx0OB4mJiWzevJl3333XnCkTERH5Lzt+/Dj33XcfJ0+evGqbhsuX3FRUVHD27FnsdjuBgYEUFBSwbds2RkZGKC8vZ/fu3QQFBREUFMQtt9yCw+HA19fXc9o0zEIhaxaGYXD+/HkeeOAB2tra6OzsZOXKlVc93263k5eXh5+fH+Pj4/j7+3P69GliYmJYvnw5H374IStWrDDPb2lpISoqioKCAgoLC+fhG4mIiPx7586dIzAw8Jrn2e12iouLKS0t5eLFi9TX1/PNN9/w8ssv88wzzxAQEMBvv/1Ga2srwcHBxMTEYLVamZiYuGojU0+ikHUduru7MQzjuhqrAbz33ns4nU4yMjIICQnh559/ZsOGDTz44IPs27dvWrfakydPEhER4RWDSUREBC5NUgwPD/PQQw+RmZnJc889Z76WnZ1NdXU1r732Gunp6eYdnylTuw29gWfPw82TyMjIqwYs+OeCvKamJoqLi6mtrWVgYICIiAhaWlo4fPgwL7zwAr29vea5q1atwsfHx1zsLiIi4uksFgu+vr4YhmEGpvHxceDSRMSaNWt45513KC8vZ2RkZNp7vSVggULWnJqaFPzkk0+Ij4/njTfe4MCBAwwMDBAZGUlLSwvff/89Tz31FP39/dPeq5ksERHxJkFBQYSFhVFZWQmAv78/TqcTgOXLl3P+/Hk6Oztnbebt6RSy5pDFYjFbN5SWlhITE8OePXs4cOAAg4ODREZGcujQIYKCgli6dKmbr1ZERMQ1pvpaFRUVMTAwQEJCAvD3nR+n00lNTQ01NTVYLBav7QOpNVk36Mp1WJffQ778761bt3LkyBFyc3NJSkqa1iXeG3ZOiIjIwjVbLZz6/9tvvyU7OxvDMIiMjOT3339ndHSU7u5urFarV9dC7/xW82BqQFRXVzMxMTFtUFmtVnNGq7y8nJiYGHJzc3E4HMDftxW9dVCJiMjCMFsthEv1MD4+nqNHj/L4449z1113ERcXx08//WTWSm+uhVoI9C+cOXOG/Px8Lly4QGZm5rS+IFODx2q1UlZWRnh4OImJicD1PTxTRETEE8xWC6eEhITw6quvTjvmLW0aZuO98XEeLFmyhHvuuYfvvvsO+Gd4unxG66WXXpr2v4iIiDe4Vi0EZlxz5e0BCxSyrothGDOGo4CAAPLz8/niiy+or6+f8b0zTZ2KiIh4mn9TCxfqHRyFrGvo6+vDYrGY94wbGxvNB1wCREREsGnTJjPBa6ZKRES8jWrhjVHImkVRURFhYWF0dHRgsVjo7OwkLi6OtLQ0srKyGBwc5OabbyYtLY2ysjL6+vo0UyUiIl5FtfDGKWTNIjY2lqSkJDZv3kxHRwd33303XV1dbNmyhWPHjnHvvffy7LPPsnjxYmJjY3n77bfVuV1ERLyKauGNU5+sGVRVVfH0008D0N7eTmFhIUePHuXgwYOsWbPG7Omxf/9+WltbqaqqIiAggDvuuAOHw4HNZptxd4WIiIinUC2cA4ZM09TUZFgsFmPnzp3msba2NiMpKclYunSp0dbW9o/3HD582MjNzTUWL15s2O32+bxcERGROadaODcUsq7gdDqN6upqIyAgwMjJyTGPXz642tvbDcMwjImJCWNyctIwDMMYHR017Ha7kZiYaJw7d848LiIi4mlUC+eG1mRdwcfHh/T0dEpLSykpKWHnzp0ArF69msLCQu6//342bdpER0eH2ffKMAwCAwOJiori+PHjDA0NLezpURER8WiqhXNDIesvxmVL03x8fMjIyKC8vHzGwbVhwwYSExNpbW3Fx8fHHESdnZ0A+Pr6zv8XEBER+ZdUC+eWQtZfpgbHW2+9RWNjIxaLhYyMDCoqKigpKSEnJwf4e3CFh4fzyiuvAJcekDk2NkZ/fz9fffUVoaGhbvseIiIiN0q1cG5pd+EVoqOjOXXqFJ9//jnR0dEYhkFNTQ2ZmZns2LGDvXv3AnD69GnCw8NZtGiRuXviyqePi4iIeCLVwrmxoEPW1QbCo48+yrFjx/j000/ZuHGjObi2b99Oeno6FRUV5rlTW1hFREQ8kWqh6yzYX8QwDHNQDQ0NmccA6uvrWbduHampqRw5cgSLxcITTzzBvn376O3tZXJy0vwcDSoREfFUqoWutSBnsj7++GP6+vrIy8ujsrKS/Px8mpqauPPOO6c1TouPj6e3t5ePPvqI6OjoaZ+h1C4iIp5MtdD1FtwvU1paSkZGBuvWrQMgMTGR2267jZSUFHp6erBYLGY6z83N5cyZMyQkJNDe3j7tczSoRETEU6kWzo8F9euUlZWxY8cOPvvsM+Lj4wEIDQ2loaGBm266ieTkZHp6esxB4+fnx4svvkh2djarVq1y56WLiIjMCdXC+bNgQlZVVRVZWVnU1taSnJxsHn///ffx9/fnyy+/xGaz8cgjj3Dw4EE6OzspLi7mwoULFBUVmc3WREREPJVq4fxaEGuyJiYmSE9Pp66ujq6uLlasWAFAcnIyJ06c4MSJE4SEhDA2NkZSUhKtra3YbDaWLFmCw+FQQzUREfF4qoXzz6tDVmNjI7GxsQCMjo6SmppKV1cXDQ0N5Ofnc+rUKerq6rj99tunLfJzOBwsWrSI9evXY7VamZiYwMfHx51fRURE5IaoFrqP14as5uZmkpKSaGtrY9myZQBmOm9oaCA8PJxDhw6Zr8HMvULUVE1ERDyVaqF7ee2arLVr17Jx40Z++eUXAJxOJzabjdraWlJTU/nzzz8ZHh6e9p6ZBpAGlYiIeCrVQvfy2pBls9kIDg4mLy8PuPSgyosXLxIUFERlZSWrV68mISGBH3/80c1XKiIi4hqqhe7llSFr6g7o7t27GRsbY9euXQDmrgibzUZdXR0rV67kscce44cffnDn5YqIiMw51UL388qQNbVo79ZbbyUlJYWmpiYqKyuB6YOrtraWkJAQXn/9dXderoiIyJxTLXQ/r134PqW/v5+cnBz++OMP0tLSyMrKAjB3SYyPj+Pn56eutSIi4rVUC93D60MWQF9fHwUFBfT09BAREUF5ebk5kKa2q2rnhIiIeDPVwvm3IEIWwNmzZ/n666/Zs2cPFouFhIQEkpOTWb9+vbsvTUREZF6oFs6vBROyLldSUsKvv/7K0NAQBQUFhIWFufuSRERE5pVqoestqJB1eSdbgJGREYKDg914RSIiIvNLtXD+LKiQdTVXDjgREZGFRrVw7ilkiYiIiLiA9mqKiIiIuIBCloiIiIgLKGSJiIiIuIBCloiIiIgLKGSJiIiIuIBCloiIiIgLKGSJiIiIuIBCloiIiIgLKGSJiIiIuIBCloiIiIgL/B9/gzvzDoxM4gAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "df_perc = pd.DataFrame(cost_breakdown_perc, index=years)\n",
+    "\n",
+    "fig = plt.figure()\n",
+    "ax = fig.add_subplot()\n",
+    "df_perc.plot(rot=45, ax=ax)\n",
+    "\n",
+    "# Formatting\n",
+    "ax.set_ylim([-15, 15])\n",
+    "ax.set_ylabel('Percent change in Capex')\n",
+    "# ax.set_xlabel('Commercial operation date')\n",
+    "ax.legend(loc='upper left')\n",
+    "\n",
+    "#\n",
+    "fname_perc = '/percent_change.png'\n",
+    "fig.savefig(fig_dir+fname_perc, dpi=300, bbox_inches='tight')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2f485fd4",
+   "metadata": {},
+   "source": [
+    "## Taking a crack at a waterfall"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "db937086",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Turbine ['blades', 'nacelle', 'tower']\n",
+      "Substructure ['monopile', 'transition_piece']\n",
+      "Array System ['array_cable']\n",
+      "Export System ['export_cable']\n",
+      "1301.0 {'Turbine': 130.49030000000002, 'Substructure': 226.62796945399697, 'Array System': 0.0, 'Export System': 0.0} {'Turbine': 21.90884, 'Substructure': 127.91889831403384, 'Array System': 19.955383985464, 'Export System': 20.41809} 357.11826945399696 190.20121229949785\n"
+     ]
+    }
+   ],
+   "source": [
+    "european_cost = base_capex \n",
+    "multiplier_structure = {'Turbine': ['blades', 'nacelle', 'tower'],\n",
+    "                       'Substructure': ['monopile', 'transition_piece'],\n",
+    "                       'Array System': ['array_cable'],\n",
+    "                       'Export System': ['export_cable'],}\n",
+    "\n",
+    "transit_cost = {}\n",
+    "factory_cost = {}\n",
+    "total_transit_cost = 0\n",
+    "total_factory_cost = 0\n",
+    "\n",
+    "for k,v in multiplier_structure.items():\n",
+    "    print(k,v)\n",
+    "    transit_cost[k] = 0\n",
+    "    factory_cost[k] = 0\n",
+    "    for vi in v:\n",
+    "        if k == 'Turbine':\n",
+    "            split =  TURBINE_CAPEX_SPLIT[vi]\n",
+    "        else:\n",
+    "            split = 1\n",
+    "        _transit = base_project.capex_breakdown_per_kw[k] * split * DEFAULT_MULTIPLIERS[vi]['imported']\n",
+    "        _factory = base_project.capex_breakdown_per_kw[k] * split * DEFAULT_MULTIPLIERS[vi]['domestic']\n",
+    "        transit_cost[k] += _transit\n",
+    "        factory_cost[k] += _factory\n",
+    "        total_transit_cost += _transit\n",
+    "        total_factory_cost += _factory\n",
+    "\n",
+    "print(base_project.capex_breakdown_per_kw['Turbine'], transit_cost, factory_cost, total_transit_cost, total_factory_cost)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "7d021e44",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plot waterfall\n",
+    "european = base_capex + total_transit_cost\n",
+    "\n",
+    "slack =   total_transit_cost - total_factory_cost\n",
+    "\n",
+    "domestic = european\n",
+    "\n",
+    "transit_perc = '-' + str(round(100*total_transit_cost / base_capex, 2)) + '%'\n",
+    "factory_perc = str(round(100*total_factory_cost / base_capex, 2) ) + '%'\n",
+    "slack_perc = str(round(100*slack / base_capex, 2)) + '%'\n",
+    "\n",
+    "x = ['Imported', 'Transit', 'Factory', 'Margin', 'Domestic']\n",
+    "y = [european, total_transit_cost, total_factory_cost, slack,  domestic]\n",
+    "bottom = [0, european-total_transit_cost, european-total_transit_cost, european-total_transit_cost + total_factory_cost, 0]\n",
+    "color = ['#5E6A71', '#8CC63F', '#933C06', '#FFC423', '#5E6A71']\n",
+    "bar_text = {'transit': transit_perc, 'factory': factory_perc, 'margin': slack_perc}\n",
+    "\n",
+    "fdir = 'C:/Users/mshields/Documents/Projects/Supply Chain Roadmap/Analysis repos/LCOE/results/'\n",
+    "fname = 'lcoe_waterfall'\n",
+    "\n",
+    "fnamedir = fdir + fname\n",
+    "\n",
+    "waterfall_plot(x, y, bottom, color, bar_text, fname=fnamedir)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e1d1f713",
+   "metadata": {},
+   "source": [
+    "### Plot an area chart over time"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "e640e06a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "UserWarning: C:\\Users\\mshields\\Documents\\Analysis tools\\ORBIT\\supply_chain_plots.py:182\n",
+      "FixedFormatter should only be used together with FixedLocator"
+     ]
+    }
+   ],
+   "source": [
+    "x = [2023, 2025, 2027, 2030]\n",
+    "color_list = {'Wind turbine': '#5E6A71', 'Substructure': '#D9531E', 'Electrical infrastructure': '#5D9732', 'Cost margin': '#00A4E4'}\n",
+    "\n",
+    "fdir = 'C:/Users/mshields/Documents/Projects/Supply Chain Roadmap/Analysis repos/LCOE/results/'\n",
+    "fname = 'capex_area'\n",
+    "\n",
+    "fnamedir = fdir + fname\n",
+    "\n",
+    "area_time_plot(x, cost_breakdown, color_list, fname=fnamedir)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f147a0d1",
+   "metadata": {},
+   "source": [
+    "### Old methods below"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bffa864a",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "f13a8bfb-edff-4889-b12e-6f0d4a4416ec",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'sc_manager' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[1;32m~\\AppData\\Local\\Temp\\1\\ipykernel_12020\\3653473131.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# Run a project through this method\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;31m# It will perform the supply chain adjustments and return a project instance with the adjusted values\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0msc_project\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msc_manager\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrun_project\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[1;31mNameError\u001b[0m: name 'sc_manager' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "# Run a project through this method\n",
+    "# It will perform the supply chain adjustments and return a project instance with the adjusted values\n",
+    "sc_project = sc_manager.run_project(config)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "02b0cfa6-8045-461f-9dfc-ff6019ce4e79",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# This is just for comparison\n",
+    "project = ProjectManager(config)\n",
+    "project.run()\n",
+    "print(project.capex_breakdown_per_kw)\n",
+    "print('blades', .135 * project.capex_breakdown_per_kw['Turbine'])\n",
+    "print('nacelle', .274 * project.capex_breakdown_per_kw['Turbine'])\n",
+    "print('tower', .162 * project.capex_breakdown_per_kw['Turbine'])\n",
+    "\n",
+    "install_costs = 0\n",
+    "for c,v in project.capex_breakdown_per_kw.items():\n",
+    "    if 'Installation' in c:\n",
+    "        install_costs += v\n",
+    "    else:\n",
+    "        pass\n",
+    "# print(project.capex_breakdown_per_kw)\n",
+    "print(install_costs)\n",
+    "print(project.total_capex_per_kw)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "455cdef8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "3274 - (175.6+356.5+210.8+503.6+88.4+105+165+313.5+252.1+543.1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d4f63ada-549e-4414-b5f8-6b0722b91b9a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Comparing the values from SupplyChainManager vs. ProjectManager\n",
+    "df = pd.concat([\n",
+    "    pd.Series(project.capex_breakdown, name=\"ORBIT\"),\n",
+    "    pd.Series(sc_project.capex_breakdown, name=\"SupplyChain\")\n",
+    "], axis=1)\n",
+    "\n",
+    "df[\"Ratio\"] = df[\"SupplyChain\"] / df[\"ORBIT\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6eaf7126-844e-48a1-8b5d-23752129f23b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "10d77f74-a300-464b-9df0-783541cad297",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/misc/supply_chain_plots.py b/misc/supply_chain_plots.py
new file mode 100644
index 00000000..75b6fd5c
--- /dev/null
+++ b/misc/supply_chain_plots.py
@@ -0,0 +1,191 @@
+import pandas as pd
+import math
+import numpy as np
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+import matplotlib.text as txt
+import os
+
+def mysave(fig, froot, mode='png'):
+    assert mode in ['png', 'eps', 'pdf', 'all']
+    fileName, fileExtension = os.path.splitext(froot)
+    padding = 0.1
+    dpiVal = 200
+    legs = []
+    for a in fig.get_axes():
+        addLeg = a.get_legend()
+        if not addLeg is None: legs.append(a.get_legend())
+    ext = []
+    if mode == 'png' or mode == 'all':
+        ext.append('png')
+    if mode == 'eps':  # or mode == 'all':
+        ext.append('eps')
+    if mode == 'pdf' or mode == 'all':
+        ext.append('pdf')
+
+    for sfx in ext:
+        fig.savefig(fileName + '.' + sfx, format=sfx, pad_inches=padding, bbox_inches='tight',
+                    dpi=dpiVal, bbox_extra_artists=legs)
+
+
+titleSize = 24  # 40 #38
+axLabelSize = 20  # 38 #36
+tickLabelSize = 18  # 30 #28
+ganttTick = 18
+legendSize = tickLabelSize + 2
+textSize = legendSize - 2
+deltaShow = 4
+linewidth = 3
+
+
+def myformat(ax, linewidth=linewidth, xticklabel=tickLabelSize, yticklabel=tickLabelSize, mode='save'):
+    assert type(mode) == type('')
+    assert mode.lower() in ['save', 'show'], 'Unknown mode'
+
+    def myformat(myax, linewidth=linewidth, xticklabel=xticklabel, yticklabel=yticklabel):
+        if mode.lower() == 'show':
+            for i in myax.get_children():  # Gets EVERYTHING!
+                if isinstance(i, txt.Text):
+                    i.set_size(textSize + 3 * deltaShow)
+
+            for i in myax.get_lines():
+                if i.get_marker() == 'D': continue  # Don't modify baseline diamond
+                i.set_linewidth(linewidth)
+                # i.set_markeredgewidth(4)
+                i.set_markersize(10)
+
+            leg = myax.get_legend()
+            if not leg is None:
+                for t in leg.get_texts(): t.set_fontsize(legendSize + deltaShow + 6)
+                th = leg.get_title()
+                if not th is None:
+                    th.set_fontsize(legendSize + deltaShow + 6)
+
+            myax.set_title(myax.get_title(), size=titleSize + deltaShow, weight='bold')
+            myax.set_xlabel(myax.get_xlabel(), size=axLabelSize + deltaShow, weight='bold')
+            myax.set_ylabel(myax.get_ylabel(), size=axLabelSize + deltaShow, weight='bold')
+            myax.tick_params(labelsize=tickLabelSize + deltaShow)
+            myax.patch.set_linewidth(3)
+            for i in myax.get_xticklabels():
+                i.set_size(tickLabelSize + deltaShow)
+            for i in myax.get_xticklines():
+                i.set_linewidth(3)
+            for i in myax.get_yticklabels():
+                i.set_size(yticklabel + deltaShow)
+            for i in myax.get_yticklines():
+                i.set_linewidth(3)
+
+        elif mode.lower() == 'save':
+            for i in myax.get_children():  # Gets EVERYTHING!
+                if isinstance(i, txt.Text):
+                    i.set_size(textSize)
+
+            for i in myax.get_lines():
+                if i.get_marker() == 'D': continue  # Don't modify baseline diamond
+                i.set_linewidth(linewidth)
+                # i.set_markeredgewidth(4)
+                i.set_markersize(10)
+
+            leg = myax.get_legend()
+            if not leg is None:
+                for t in leg.get_texts(): t.set_fontsize(legendSize)
+                th = leg.get_title()
+                if not th is None:
+                    th.set_fontsize(legendSize)
+
+            myax.set_title(myax.get_title(), size=titleSize, weight='bold')
+            myax.set_xlabel(myax.get_xlabel(), size=axLabelSize, weight='bold')
+            myax.set_ylabel(myax.get_ylabel(), size=axLabelSize, weight='bold')
+            myax.tick_params(labelsize=tickLabelSize)
+            myax.patch.set_linewidth(3)
+            for i in myax.get_xticklabels():
+                i.set_size(xticklabel)
+            for i in myax.get_xticklines():
+                i.set_linewidth(3)
+            for i in myax.get_yticklabels():
+                i.set_size(yticklabel)
+            for i in myax.get_yticklines():
+                i.set_linewidth(3)
+
+    if type(ax) == type([]):
+        for i in ax: myformat(i)
+    else:
+        myformat(ax)
+
+def initFigAxis(figx=12, figy=9):
+    fig = plt.figure(figsize=(figx, figy))
+    ax = fig.add_subplot(111)
+    return fig, ax
+
+def waterfall_plot(x, y, bottom, color, bar_text, fname=None):
+    """ Waterfall plot comparing European andUS manufactining costs"""
+
+    fig, ax = initFigAxis()
+
+    h = ax.bar(x, y,bottom=bottom, color=color, edgecolor='k')
+
+    ax.get_yaxis().set_major_formatter(
+        mpl.ticker.FuncFormatter(lambda x, p: format(int(x), ',')))
+    ax.set_ylabel('Capital Expenditures, $/kW')
+    ax.set_title('Comparison of different cost premiums between \nimported and domestically manufactured components')
+
+    h[3].set_linestyle('--')
+    h[3].set_linewidth(1.75)
+    h[3].set_edgecolor('k')
+
+    ax.text(x[1], 2000, bar_text['transit'], horizontalalignment='center',)
+    ax.text(x[2], 2000, bar_text['factory'], horizontalalignment='center',)
+    ax.text(x[3], 2000, bar_text['margin'], horizontalalignment='center',)
+
+    if fname is not None:
+        myformat(ax)
+        mysave(fig, fname)
+        plt.close()
+
+def area_time_plot(x, y, color, fname=None):
+    """Area plot showing changin component cost over time"""
+
+    fig, ax = initFigAxis()
+
+    y0 = np.zeros(len(x))
+
+    y_init = 0
+    y_init = np.sum([v[0] for k,v in y.items()])
+
+    for k,v in y.items():
+        y1 = [yi+vi for yi, vi in zip(y0,v)]
+        ax.fill_between(x, y0 / y_init, y1 / y_init, color=color[k], label=k)
+        ax.plot(x, y1 / y_init, 'w')
+        y0 = y1
+
+    # Define margin
+    ax.fill_between(x, y1 / y_init, np.ones(len(x)), color=color['Cost margin'], label='Margin')
+
+    final_margin = round( 100* (1 - y1[-1] / y_init), 1)
+
+    y_margin = ((1 + y1[-1] / y_init) /2)
+
+    margin_text = '   ' + str(final_margin) + '% CapEx margin relative to \n   European imports can cover \n   local differences in wages, \n   taxes, financing, etc'
+
+    right_bound = 2030.5
+    right_spline_corr = 0.2
+
+    ax.plot([2030, right_bound], [y_margin, y_margin], 'k')
+    ax.text(right_bound, y_margin, margin_text, verticalalignment='center')
+    ax.spines["right"].set_position(("data", right_bound-right_spline_corr))
+    ax.spines["top"].set_bounds(2022.65, right_bound-right_spline_corr)
+    ax.spines["bottom"].set_bounds(2022.65, right_bound-right_spline_corr)
+
+    ax.text(2023, -0.215, '(Fully \nimported)', horizontalalignment='center')
+    ax.text(2030, -0.215, '(Fully \ndomestic)', horizontalalignment='center')
+
+    ax.set_yticklabels([-20, 0, 20, 40, 60, 80 ,100])
+
+    ax.legend(loc=(1, 0.05))
+
+    ax.set_ylabel('CapEx breakdown relative to \ncomponents imported from Europe, %')
+
+    if fname is not None:
+        myformat(ax)
+        mysave(fig, fname)
+        plt.close()
diff --git a/misc/supply_chain_project.yaml b/misc/supply_chain_project.yaml
new file mode 100644
index 00000000..a964d89b
--- /dev/null
+++ b/misc/supply_chain_project.yaml
@@ -0,0 +1,60 @@
+# Site + Plant Parameters
+site:
+  depth: 34
+  distance: 50
+  distance_to_landfall: 50
+  mean_windspeed: 9
+plant:
+  layout: grid
+  num_turbines: 40
+  row_spacing: 7
+  substation_distance: 1
+  turbine_spacing: 7
+landfall:
+  interconnection_distance: 3
+  trench_length: 2
+turbine: 15MW_generic
+# Vessels
+array_cable_install_vessel: example_cable_lay_vessel
+export_cable_install_vessel: example_cable_lay_vessel
+export_cable_bury_vessel: example_cable_lay_vessel
+oss_install_vessel: example_heavy_lift_vessel
+spi_vessel: example_scour_protection_vessel
+wtiv: example_wtiv
+# Module Specific
+OffshoreSubstationInstallation:
+  feeder: example_heavy_feeder
+  num_feeders: 1
+array_system_design:
+  cables:
+  - XLPE_630mm_33kV
+  - XLPE_400mm_33kV
+export_system_design:
+  cables: XLPE_500mm_132kV
+  percent_added_length: 0.0
+scour_protection_design:
+  cost_per_tonne: 40
+  scour_protection_depth: .1
+# Configured Phases
+design_phases:
+- MonopileDesign
+- ScourProtectionDesign
+- ArraySystemDesign
+- ExportSystemDesign
+- OffshoreSubstationDesign
+install_phases:
+  ArrayCableInstallation: 0
+  ExportCableInstallation: 2000
+  MonopileInstallation: !!python/tuple
+  - ScourProtectionInstallation
+  - 0.5
+  OffshoreSubstationInstallation: 0
+  ScourProtectionInstallation: 0
+  TurbineInstallation: !!python/tuple
+  - MonopileInstallation
+  - 0.1
+# Project Inputs
+project_parameters:
+  turbine_capex: 1301
+  commissioning: 0.01
+  decommissioning: 0.15


Test patch:
diff --git a/pytest.ini b/pytest.ini
deleted file mode 100644
index bd076341..00000000
--- a/pytest.ini
+++ /dev/null
@@ -1,2 +0,0 @@
-[pytest]
-adodopts = --ignore=setup.py
diff --git a/tests/api/test_wisdem_api.py b/tests/api/test_wisdem_api.py
index 188f9500..e15c8156 100644
--- a/tests/api/test_wisdem_api.py
+++ b/tests/api/test_wisdem_api.py
@@ -7,14 +7,25 @@
 
 
 import openmdao.api as om
-
 from ORBIT.api.wisdem import Orbit
 
 
 def test_wisdem_monopile_api_default():
 
-    prob = om.Problem()
-    prob.model = Orbit(floating=False)
+    prob = om.Problem(reports=False)
+    prob.model = Orbit(floating=False, jacket=False, jacket_legs=0)
+    prob.setup()
+
+    prob.run_model()
+
+    prob.model.list_inputs()
+    prob.model.list_outputs()
+
+
+def test_wisdem_jacket_api_default():
+
+    prob = om.Problem(reports=False)
+    prob.model = Orbit(floating=False, jacket=True, jacket_legs=3)
     prob.setup()
 
     prob.run_model()
@@ -25,8 +36,8 @@ def test_wisdem_monopile_api_default():
 
 def test_wisdem_floating_api_default():
 
-    prob = om.Problem()
-    prob.model = Orbit(floating=True)
+    prob = om.Problem(reports=False)
+    prob.model = Orbit(floating=True, jacket=False, jacket_legs=0)
     prob.setup()
 
     prob.run_model()
diff --git a/tests/data/library/project/config/feeder_jacket_install.yaml b/tests/data/library/project/config/feeder_jacket_install.yaml
new file mode 100644
index 00000000..7fd1083b
--- /dev/null
+++ b/tests/data/library/project/config/feeder_jacket_install.yaml
@@ -0,0 +1,25 @@
+feeder: test_feeder
+jacket:
+  height: 100
+  deck_space: 500
+  diameter: 10
+  length: 50
+  mass: 350
+  unit_cost: 5e6
+num_feeders: 1
+plant:
+  num_turbines: 20
+port:
+  monthly_rate: 100000
+  name: Test Port
+  num_cranes: 1
+site:
+  depth: 40
+  distance: 50
+transition_piece:
+  deck_space: 250
+  mass: 350
+  unit_cost: 3e6
+turbine:
+  hub_height: 100
+wtiv: test_wtiv
diff --git a/tests/data/library/project/config/single_wtiv_jacket_install.yaml b/tests/data/library/project/config/single_wtiv_jacket_install.yaml
new file mode 100644
index 00000000..61f84558
--- /dev/null
+++ b/tests/data/library/project/config/single_wtiv_jacket_install.yaml
@@ -0,0 +1,22 @@
+jacket:
+  height: 100
+  deck_space: 500
+  diameter: 10
+  length: 50
+  mass: 350
+  unit_cost: 5e6
+plant:
+  num_turbines: 20
+port:
+  monthly_rate: 100000
+  num_cranes: 1
+site:
+  depth: 40
+  distance: 50
+transition_piece:
+  deck_space: 250
+  mass: 350
+  unit_cost: 3e6
+turbine:
+  hub_height: 100
+wtiv: test_wtiv
diff --git a/tests/phases/install/jacket_install/test_jacket_install.py b/tests/phases/install/jacket_install/test_jacket_install.py
new file mode 100644
index 00000000..6811e631
--- /dev/null
+++ b/tests/phases/install/jacket_install/test_jacket_install.py
@@ -0,0 +1,218 @@
+"""Tests for the `JacketInstallation` class."""
+
+__author__ = "Jake Nunemaker"
+__copyright__ = "Copyright 2022, National Renewable Energy Laboratory"
+__maintainer__ = "Jake Nunemaker"
+__email__ = "jake.nunemaker@nrel.gov"
+
+
+from copy import deepcopy
+
+import pandas as pd
+import pytest
+
+from ORBIT import ProjectManager
+from tests.data import test_weather
+from ORBIT.core.library import extract_library_specs
+from ORBIT.core.defaults import process_times as pt
+from ORBIT.phases.install import JacketInstallation
+
+config_wtiv = extract_library_specs("config", "single_wtiv_jacket_install")
+config_feeder = extract_library_specs("config", "feeder_jacket_install")
+config_multi_feeder = deepcopy(config_feeder)
+config_multi_feeder["num_feeders"] = 2
+
+
+@pytest.mark.parametrize(
+    "config",
+    (config_wtiv, config_feeder, config_multi_feeder),
+    ids=["wtiv_only", "single_feeder", "multi_feeder"],
+)
+def test_simulation_setup(config):
+
+    sim = JacketInstallation(config)
+    assert sim.config == config
+    assert sim.env
+    assert sim.port
+    assert sim.port.crane.capacity == config["port"]["num_cranes"]
+    assert sim.num_jackets == config["plant"]["num_turbines"]
+
+    ja = len([i for i in sim.port.items if i.type == "Jacket"])
+    assert ja == sim.num_jackets
+
+    tp = len([i for i in sim.port.items if i.type == "TransitionPiece"])
+    assert tp == sim.num_jackets
+
+
+@pytest.mark.parametrize(
+    "config",
+    (config_wtiv, config_feeder, config_multi_feeder),
+    ids=["wtiv_only", "single_feeder", "multi_feeder"],
+)
+def test_vessel_initialization(config):
+
+    sim = JacketInstallation(config)
+    assert sim.wtiv
+    assert sim.wtiv.jacksys
+    assert sim.wtiv.crane
+    assert sim.wtiv.storage
+
+    if config.get("feeder", None) is not None:
+        assert len(sim.feeders) == config["num_feeders"]
+
+        for feeder in sim.feeders:
+            assert feeder.jacksys
+            assert feeder.storage
+
+
+@pytest.mark.parametrize(
+    "config",
+    (config_wtiv, config_feeder, config_multi_feeder),
+    ids=["wtiv_only", "single_feeder", "multi_feeder"],
+)
+@pytest.mark.parametrize(
+    "weather", (None, test_weather), ids=["no_weather", "test_weather"]
+)
+def test_for_complete_logging(weather, config):
+
+    sim = JacketInstallation(config, weather=weather)
+    sim.run()
+
+    df = pd.DataFrame(sim.env.actions)
+    df = df.assign(shift=(df["time"] - df["time"].shift(1)))
+
+    for vessel in df["agent"].unique():
+        _df = df[df["agent"] == vessel].copy()
+        _df = _df.assign(shift=(_df["time"] - _df["time"].shift(1)))
+        assert (_df["shift"] - _df["duration"]).abs().max() < 1e-9
+
+    assert ~df["cost"].isnull().any()
+    _ = sim.agent_efficiencies
+    _ = sim.detailed_output
+
+
+@pytest.mark.parametrize(
+    "config",
+    (config_wtiv, config_feeder, config_multi_feeder),
+    ids=["wtiv_only", "single_feeder", "multi_feeder"],
+)
+def test_num_legs(config):
+
+    base = JacketInstallation(config)
+    base.run()
+
+    new_config = deepcopy(config)
+    new_config["jacket"]["num_legs"] = 6
+
+    sim = JacketInstallation(new_config)
+    sim.run()
+
+    assert sim.total_phase_time > base.total_phase_time
+
+
+@pytest.mark.parametrize(
+    "config",
+    (config_wtiv, config_feeder, config_multi_feeder),
+    ids=["wtiv_only", "single_feeder", "multi_feeder"],
+)
+def test_foundation_type(config):
+
+    base = JacketInstallation(config)
+    base.run()
+
+    base_actions = [a["action"] for a in base.env.actions]
+    assert "Drive Pile" in base_actions
+
+    new_config = deepcopy(config)
+    new_config["jacket"]["foundation_type"] = "suction"
+
+    sim = JacketInstallation(new_config)
+    sim.run()
+
+    actions = [a["action"] for a in sim.env.actions]
+    assert "Install Suction Bucket" in actions
+
+
+def test_kwargs_piles():
+
+    sim = JacketInstallation(config_wtiv)
+    sim.run()
+    baseline = sim.total_phase_time
+
+    keywords = [
+        "jacket_fasten_time",
+        "jacket_release_time",
+        "jacket_lift_time",
+        "jacket_lower_time",
+        "jacket_grout_time",
+        "jacket_pin_template_time",
+        "jacket_pile_drive_time",
+        "jacket_position_pile",
+        "jacket_vessel_reposition",
+    ]
+
+    failed = []
+
+    for kw in keywords:
+
+        default = pt[kw]
+        kwargs = {kw: default + 2}
+
+        new_sim = JacketInstallation(config_wtiv, **kwargs)
+        new_sim.run()
+        new_time = new_sim.total_phase_time
+
+        if new_time > baseline:
+            pass
+
+        else:
+            failed.append(kw)
+
+    if failed:
+        raise Exception(f"'{failed}' not affecting results.")
+
+    else:
+        assert True
+
+
+def test_kwargs_suction():
+
+    config_wtiv_suction = deepcopy(config_wtiv)
+    config_wtiv_suction["jacket"]["foundation_type"] = "suction"
+
+    sim = JacketInstallation(config_wtiv_suction)
+    sim.run()
+    baseline = sim.total_phase_time
+
+    keywords = [
+        "jacket_fasten_time",
+        "jacket_release_time",
+        "jacket_lift_time",
+        "jacket_lower_time",
+        "jacket_grout_time",
+        "jacket_vessel_reposition",
+        "jacket_suction_bucket",
+    ]
+
+    failed = []
+
+    for kw in keywords:
+
+        default = pt[kw]
+        kwargs = {kw: default + 2}
+
+        new_sim = JacketInstallation(config_wtiv_suction, **kwargs)
+        new_sim.run()
+        new_time = new_sim.total_phase_time
+
+        if new_time > baseline:
+            pass
+
+        else:
+            failed.append(kw)
+
+    if failed:
+        raise Exception(f"'{failed}' not affecting results.")
+
+    else:
+        assert True