diff --git a/CHANGELOG.md b/CHANGELOG.md
index dc2bd029..b0816ef6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,7 +6,7 @@ This is a major release with significant upgrades under the hood of Cheetah. Des
 
 ### 🚨 Breaking Changes
 
-- Cheetah is now vectorised. This means that you can run multiple simulations in parallel by passing a batch of beams and settings, resulting a number of interfaces being changed. For Cheetah developers this means that you now have to account for an arbitrary-dimensional tensor of most of the properties of you element, rather than a single value, vector or whatever else a property was before. (see #116, #157, #170, #172, #173, #198, #208, #215, #218, #229, #233, #258) (@jank324, @cr-xu, @hespe, @roussel-ryan)
+- Cheetah is now vectorised. This means that you can run multiple simulations in parallel by passing a batch of beams and settings, resulting a number of interfaces being changed. For Cheetah developers this means that you now have to account for an arbitrary-dimensional tensor of most of the properties of you element, rather than a single value, vector or whatever else a property was before. (see #116, #157, #170, #172, #173, #198, #208, #213, #215, #218, #229, #233, #258) (@jank324, @cr-xu, @hespe, @roussel-ryan)
 - The fifth particle coordinate `s` is renamed to `tau`. Now Cheetah uses the canonical variables in phase space $(x,px=\frac{P_x}{p_0},y,py, \tau=c\Delta t, \delta=\Delta E/{p_0 c})$. In addition, the trailing "s" was removed from some beam property names (e.g. `beam.xs` becomes `beam.x`). (see #163) (@cr-xu)
 - `Screen` no longer blocks the beam (by default). To return to old behaviour, set `Screen.is_blocking = True`. (see #208) (@jank324, @roussel-ryan)
 
diff --git a/cheetah/accelerator/aperture.py b/cheetah/accelerator/aperture.py
index 2d1d9ad0..411c8552 100644
--- a/cheetah/accelerator/aperture.py
+++ b/cheetah/accelerator/aperture.py
@@ -113,14 +113,16 @@ def split(self, resolution: torch.Tensor) -> list[Element]:
         # TODO: Implement splitting for aperture properly, for now just return self
         return [self]
 
-    def plot(self, ax: plt.Axes, s: float) -> None:
+    def plot(self, ax: plt.Axes, s: float, vector_idx: Optional[tuple] = None) -> None:
+        plot_s = s[vector_idx] if s.dim() > 0 else s
+
         alpha = 1 if self.is_active else 0.2
         height = 0.4
 
         dummy_length = 0.0
 
         patch = Rectangle(
-            (s, 0), dummy_length, height, color="tab:pink", alpha=alpha, zorder=2
+            (plot_s, 0), dummy_length, height, color="tab:pink", alpha=alpha, zorder=2
         )
         ax.add_patch(patch)
 
diff --git a/cheetah/accelerator/bpm.py b/cheetah/accelerator/bpm.py
index 945c9d38..ba46a77a 100644
--- a/cheetah/accelerator/bpm.py
+++ b/cheetah/accelerator/bpm.py
@@ -51,10 +51,12 @@ def track(self, incoming: Beam) -> Beam:
     def split(self, resolution: torch.Tensor) -> list[Element]:
         return [self]
 
-    def plot(self, ax: plt.Axes, s: float) -> None:
+    def plot(self, ax: plt.Axes, s: float, vector_idx: Optional[tuple] = None) -> None:
+        plot_s = s[vector_idx] if s.dim() > 0 else s
+
         alpha = 1 if self.is_active else 0.2
         patch = Rectangle(
-            (s, -0.3), 0, 0.3 * 2, color="darkkhaki", alpha=alpha, zorder=2
+            (plot_s, -0.3), 0, 0.3 * 2, color="darkkhaki", alpha=alpha, zorder=2
         )
         ax.add_patch(patch)
 
diff --git a/cheetah/accelerator/cavity.py b/cheetah/accelerator/cavity.py
index c1b53b17..53182697 100644
--- a/cheetah/accelerator/cavity.py
+++ b/cheetah/accelerator/cavity.py
@@ -341,12 +341,15 @@ def split(self, resolution: torch.Tensor) -> list[Element]:
         # element itself
         return [self]
 
-    def plot(self, ax: plt.Axes, s: float) -> None:
+    def plot(self, ax: plt.Axes, s: float, vector_idx: Optional[tuple] = None) -> None:
+        plot_s = s[vector_idx] if s.dim() > 0 else s
+        plot_length = self.length[vector_idx] if self.length.dim() > 0 else self.length
+
         alpha = 1 if self.is_active else 0.2
         height = 0.4
 
         patch = Rectangle(
-            (s, 0), self.length[0], height, color="gold", alpha=alpha, zorder=2
+            (plot_s, 0), plot_length, height, color="gold", alpha=alpha, zorder=2
         )
         ax.add_patch(patch)
 
diff --git a/cheetah/accelerator/custom_transfer_map.py b/cheetah/accelerator/custom_transfer_map.py
index 2f271af8..6aa65df3 100644
--- a/cheetah/accelerator/custom_transfer_map.py
+++ b/cheetah/accelerator/custom_transfer_map.py
@@ -102,8 +102,11 @@ def defining_features(self) -> list[str]:
     def split(self, resolution: torch.Tensor) -> list[Element]:
         return [self]
 
-    def plot(self, ax: plt.Axes, s: float) -> None:
+    def plot(self, ax: plt.Axes, s: float, vector_idx: Optional[tuple] = None) -> None:
+        plot_s = s[vector_idx] if s.dim() > 0 else s
+        plot_length = self.length[vector_idx] if self.length.dim() > 0 else self.length
+
         height = 0.4
 
-        patch = Rectangle((s, 0), self.length[0], height, color="tab:olive", zorder=2)
+        patch = Rectangle((plot_s, 0), plot_length, height, color="tab:olive", zorder=2)
         ax.add_patch(patch)
diff --git a/cheetah/accelerator/dipole.py b/cheetah/accelerator/dipole.py
index d6aab27c..19d4d3a2 100644
--- a/cheetah/accelerator/dipole.py
+++ b/cheetah/accelerator/dipole.py
@@ -480,11 +480,15 @@ def defining_features(self) -> list[str]:
             "tracking_method",
         ]
 
-    def plot(self, ax: plt.Axes, s: float) -> None:
+    def plot(self, ax: plt.Axes, s: float, vector_idx: Optional[tuple] = None) -> None:
+        plot_s = s[vector_idx] if s.dim() > 0 else s
+        plot_length = self.length[vector_idx] if self.length.dim() > 0 else self.length
+        plot_angle = self.angle[vector_idx] if self.angle.dim() > 0 else self.angle
+
         alpha = 1 if self.is_active else 0.2
-        height = 0.8 * (np.sign(self.angle[0]) if self.is_active else 1)
+        height = 0.8 * (np.sign(plot_angle) if self.is_active else 1)
 
         patch = Rectangle(
-            (s, 0), self.length[0], height, color="tab:green", alpha=alpha, zorder=2
+            (plot_s, 0), plot_length, height, color="tab:green", alpha=alpha, zorder=2
         )
         ax.add_patch(patch)
diff --git a/cheetah/accelerator/drift.py b/cheetah/accelerator/drift.py
index 4438c376..74d8c78b 100644
--- a/cheetah/accelerator/drift.py
+++ b/cheetah/accelerator/drift.py
@@ -136,7 +136,7 @@ def split(self, resolution: torch.Tensor) -> list[Element]:
             for i in range(num_splits)
         ]
 
-    def plot(self, ax: plt.Axes, s: float) -> None:
+    def plot(self, ax: plt.Axes, s: float, vector_idx: Optional[tuple] = None) -> None:
         pass
 
     @property
diff --git a/cheetah/accelerator/element.py b/cheetah/accelerator/element.py
index 6cbf433a..033bbc8d 100644
--- a/cheetah/accelerator/element.py
+++ b/cheetah/accelerator/element.py
@@ -126,12 +126,16 @@ def split(self, resolution: torch.Tensor) -> list["Element"]:
         raise NotImplementedError
 
     @abstractmethod
-    def plot(self, ax: plt.Axes, s: float) -> None:
+    def plot(self, ax: plt.Axes, s: float, vector_idx: Optional[tuple] = None) -> None:
         """
         Plot a representation of this element into a `matplotlib` Axes at position `s`.
 
         :param ax: Axes to plot the representation into.
         :param s: Position of the object along s in meters.
+        :param vector_idx: Index of the vector dimension to plot. If the model has more
+            than one vector dimension, this can be used to select a specific one. In the
+            case of present vector dimension but no index provided, the first one is
+            used by default.
         """
         raise NotImplementedError
 
diff --git a/cheetah/accelerator/horizontal_corrector.py b/cheetah/accelerator/horizontal_corrector.py
index e17837d6..dc0ff783 100644
--- a/cheetah/accelerator/horizontal_corrector.py
+++ b/cheetah/accelerator/horizontal_corrector.py
@@ -80,12 +80,16 @@ def split(self, resolution: torch.Tensor) -> list[Element]:
             for i in range(num_splits)
         ]
 
-    def plot(self, ax: plt.Axes, s: float) -> None:
+    def plot(self, ax: plt.Axes, s: float, vector_idx: Optional[tuple] = None) -> None:
+        plot_s = s[vector_idx] if s.dim() > 0 else s
+        plot_length = self.length[vector_idx] if self.length.dim() > 0 else self.length
+        plot_angle = self.angle[vector_idx] if self.angle.dim() > 0 else self.angle
+
         alpha = 1 if self.is_active else 0.2
-        height = 0.8 * (np.sign(self.angle[0]) if self.is_active else 1)
+        height = 0.8 * (np.sign(plot_angle) if self.is_active else 1)
 
         patch = Rectangle(
-            (s, 0), self.length[0], height, color="tab:blue", alpha=alpha, zorder=2
+            (plot_s, 0), plot_length, height, color="tab:blue", alpha=alpha, zorder=2
         )
         ax.add_patch(patch)
 
diff --git a/cheetah/accelerator/marker.py b/cheetah/accelerator/marker.py
index 643d4f46..e066436a 100644
--- a/cheetah/accelerator/marker.py
+++ b/cheetah/accelerator/marker.py
@@ -37,7 +37,7 @@ def is_skippable(self) -> bool:
     def split(self, resolution: torch.Tensor) -> list[Element]:
         return [self]
 
-    def plot(self, ax: plt.Axes, s: float) -> None:
+    def plot(self, ax: plt.Axes, s: float, vector_idx: Optional[tuple] = None) -> None:
         # Do nothing on purpose. Maybe later we decide markers should be shown, but for
         # now they are invisible.
         pass
diff --git a/cheetah/accelerator/quadrupole.py b/cheetah/accelerator/quadrupole.py
index 4123121c..ea264a69 100644
--- a/cheetah/accelerator/quadrupole.py
+++ b/cheetah/accelerator/quadrupole.py
@@ -217,11 +217,15 @@ def split(self, resolution: torch.Tensor) -> list[Element]:
             for i in range(num_splits)
         ]
 
-    def plot(self, ax: plt.Axes, s: float) -> None:
+    def plot(self, ax: plt.Axes, s: float, vector_idx: Optional[tuple] = None) -> None:
+        plot_k1 = self.k1[vector_idx] if self.k1.dim() > 0 else self.k1
+        plot_s = s[vector_idx] if s.dim() > 0 else s
+        plot_length = self.length[vector_idx] if self.length.dim() > 0 else self.length
+
         alpha = 1 if self.is_active else 0.2
-        height = 0.8 * (np.sign(self.k1[0]) if self.is_active else 1)
+        height = 0.8 * (np.sign(plot_k1) if self.is_active else 1)
         patch = Rectangle(
-            (s, 0), self.length[0], height, color="tab:red", alpha=alpha, zorder=2
+            (plot_s, 0), plot_length, height, color="tab:red", alpha=alpha, zorder=2
         )
         ax.add_patch(patch)
 
diff --git a/cheetah/accelerator/screen.py b/cheetah/accelerator/screen.py
index 81a946eb..af496dff 100644
--- a/cheetah/accelerator/screen.py
+++ b/cheetah/accelerator/screen.py
@@ -297,10 +297,13 @@ def set_read_beam(self, value: Beam) -> None:
     def split(self, resolution: torch.Tensor) -> list[Element]:
         return [self]
 
-    def plot(self, ax: plt.Axes, s: float) -> None:
+    def plot(self, ax: plt.Axes, s: float, vector_idx: Optional[tuple] = None) -> None:
+        plot_s = s[vector_idx] if s.dim() > 0 else s
+
         alpha = 1 if self.is_active else 0.2
+
         patch = Rectangle(
-            (s, -0.6), 0, 0.6 * 2, color="tab:green", alpha=alpha, zorder=2
+            (plot_s, -0.6), 0, 0.6 * 2, color="tab:green", alpha=alpha, zorder=2
         )
         ax.add_patch(patch)
 
diff --git a/cheetah/accelerator/segment.py b/cheetah/accelerator/segment.py
index d9a19389..1fcbcb66 100644
--- a/cheetah/accelerator/segment.py
+++ b/cheetah/accelerator/segment.py
@@ -10,7 +10,7 @@
 
 from ..converters import bmad, elegant, nxtables
 from ..latticejson import load_cheetah_model, save_cheetah_model
-from ..particles import Beam, ParticleBeam
+from ..particles import Beam
 from ..utils import UniqueNameGenerator
 from .custom_transfer_map import CustomTransferMap
 from .drift import Drift
@@ -386,17 +386,26 @@ def split(self, resolution: torch.Tensor) -> list[Element]:
             for split_element in element.split(resolution)
         ]
 
-    def plot(self, ax: plt.Axes, s: float) -> None:
-        element_lengths = [element.length[0] for element in self.elements]
-        element_ss = [0] + [
+    def plot(self, ax: plt.Axes, s: float, vector_idx: Optional[tuple] = None) -> None:
+        element_lengths = [element.length for element in self.elements]
+        element_ss = [torch.tensor(0.0)] + [
             sum(element_lengths[: i + 1]) for i, _ in enumerate(element_lengths)
         ]
         element_ss = [s + element_s for element_s in element_ss]
+        broadcast_ss = torch.broadcast_tensors(*element_ss)
+        stacked_ss = torch.stack(broadcast_ss)
+        dimension_reordered_ss = stacked_ss.movedim(0, -1)  # Place vector dims first
+
+        plot_ss = (
+            dimension_reordered_ss[vector_idx]
+            if stacked_ss.dim() > 1
+            else dimension_reordered_ss
+        )
 
-        ax.plot([0, element_ss[-1]], [0, 0], "--", color="black")
+        ax.plot([0, plot_ss[-1]], [0, 0], "--", color="black")
 
-        for element, s in zip(self.elements, element_ss[:-1]):
-            element.plot(ax, s)
+        for element, s in zip(self.elements, plot_ss[:-1]):
+            element.plot(ax, s, vector_idx)
 
         ax.set_ylim(-1, 1)
         ax.set_xlabel("s (m)")
@@ -406,81 +415,75 @@ def plot_reference_particle_traces(
         self,
         axx: plt.Axes,
         axy: plt.Axes,
-        beam: Optional[Beam] = None,
+        incoming: Beam,
         num_particles: int = 10,
         resolution: float = 0.01,
+        vector_idx: Optional[tuple] = None,
     ) -> None:
         """
         Plot `n` reference particles along the segment view in x- and y-direction.
 
         :param axx: Axes to plot the particle traces into viewed in x-direction.
         :param axy: Axes to plot the particle traces into viewed in y-direction.
-        :param beam: Entering beam from which the reference particles are sampled.
+        :param incoming: Entering beam from which the reference particles are sampled.
         :param num_particles: Number of reference particles to plot. Must not be larger
             than number of particles passed in `beam`.
         :param resolution: Minimum resolution of the tracking of the reference particles
             in the plot.
+        :param vector_idx: Index of the vector dimension to plot. If the model has more
+            than one vector dimension, this can be used to select a specific one. In the
+            case of present vector dimension but no index provided, the first one is
+            used by default.
         """
         reference_segment = deepcopy(self)
         splits = reference_segment.split(resolution=torch.tensor(resolution))
 
-        split_lengths = [split.length[0] for split in splits]
-        ss = [0] + [sum(split_lengths[: i + 1]) for i, _ in enumerate(split_lengths)]
+        split_lengths = [split.length for split in splits]
+        ss = [torch.tensor(0.0)] + [
+            sum(split_lengths[: i + 1]) for i, _ in enumerate(split_lengths)
+        ]
+        broadcast_ss = torch.broadcast_tensors(*ss)
+        stacked_ss = torch.stack(broadcast_ss)
+        dimensions_reordered_ss = stacked_ss.movedim(0, -1)  # Place vector dims first
 
-        references = []
-        if beam is None:
-            initial = ParticleBeam.make_linspaced(
-                num_particles=num_particles, device="cpu"
-            )
-            references.append(initial)
-        else:
-            initial = ParticleBeam.make_linspaced(
-                num_particles=num_particles,
-                mu_x=beam.mu_x,
-                mu_px=beam.mu_px,
-                mu_y=beam.mu_y,
-                mu_py=beam.mu_py,
-                sigma_x=beam.sigma_x,
-                sigma_px=beam.sigma_px,
-                sigma_y=beam.sigma_y,
-                sigma_py=beam.sigma_py,
-                sigma_tau=beam.sigma_tau,
-                sigma_p=beam.sigma_p,
-                energy=beam.energy,
-                dtype=(
-                    beam.particles.dtype
-                    if isinstance(beam, ParticleBeam)
-                    else beam._mu.dtype
-                ),
-                device=(
-                    beam.particles.device
-                    if isinstance(beam, ParticleBeam)
-                    else beam._mu.device
-                ),
-            )
-            references.append(initial)
+        references = [incoming.linspaced(num_particles)]
         for split in splits:
             sample = split(references[-1])
             references.append(sample)
 
-        for particle_index in range(num_particles):
-            xs = [
-                float(reference_beam.x[0, particle_index].cpu())
-                for reference_beam in references
-                if reference_beam is not Beam.empty
-            ]
-            axx.plot(ss[: len(xs)], xs)
+        xs = [reference_beam.x for reference_beam in references]
+        broadcast_xs = torch.broadcast_tensors(*xs)
+        stacked_xs = torch.stack(broadcast_xs)
+        dimension_reordered_xs = stacked_xs.movedim(0, -1)  # Place vector dims first
+
+        ys = [reference_beam.y for reference_beam in references]
+        broadcast_ys = torch.broadcast_tensors(*ys)
+        stacked_ys = torch.stack(broadcast_ys)
+        dimension_reordered_ys = stacked_ys.movedim(0, -1)  # Place vector dims first
+
+        plot_ss = (
+            dimensions_reordered_ss[vector_idx]
+            if stacked_ss.dim() > 1
+            else dimensions_reordered_ss
+        )
+        plot_xs = (
+            dimension_reordered_xs[vector_idx]
+            if stacked_xs.dim() > 2
+            else dimension_reordered_xs
+        )
+        plot_ys = (
+            dimension_reordered_ys[vector_idx]
+            if stacked_ys.dim() > 2
+            else dimension_reordered_ys
+        )
+
+        for particle_idx in range(num_particles):
+            axx.plot(plot_ss, plot_xs[particle_idx])
+            axy.plot(plot_ss, plot_ys[particle_idx])
+
         axx.set_xlabel("s (m)")
         axx.set_ylabel("x (m)")
         axx.grid()
-
-        for particle_index in range(num_particles):
-            ys = [
-                float(reference_beam.ys[0, particle_index].cpu())
-                for reference_beam in references
-                if reference_beam is not Beam.empty
-            ]
-            axy.plot(ss[: len(ys)], ys)
         axx.set_xlabel("s (m)")
         axy.set_ylabel("y (m)")
         axy.grid()
@@ -488,19 +491,24 @@ def plot_reference_particle_traces(
     def plot_overview(
         self,
         fig: Optional[matplotlib.figure.Figure] = None,
-        beam: Optional[Beam] = None,
-        n: int = 10,
+        incoming: Optional[Beam] = None,
+        num_particles: int = 10,
         resolution: float = 0.01,
+        vector_idx: Optional[tuple] = None,
     ) -> None:
         """
         Plot an overview of the segment with the lattice and traced reference particles.
 
         :param fig: Figure to plot the overview into.
-        :param beam: Entering beam from which the reference particles are sampled.
-        :param n: Number of reference particles to plot. Must not be larger than number
-            of particles passed in `beam`.
+        :param incoming: Entering beam from which the reference particles are sampled.
+        :param num_particles: Number of reference particles to plot. Must not be larger
+            than number of particles passed in `beam`.
         :param resolution: Minimum resolution of the tracking of the reference particles
             in the plot.
+        :param vector_idx: Index of the vector dimension to plot. If the model has more
+            than one vector dimension, this can be used to select a specific one. In the
+            case of present vector dimension but no index provided, the first one is
+            used by default.
         """
         if fig is None:
             fig = plt.figure()
@@ -508,18 +516,30 @@ def plot_overview(
         axs = gs.subplots(sharex=True)
 
         axs[0].set_title("Reference Particle Traces")
-        self.plot_reference_particle_traces(axs[0], axs[1], beam, n, resolution)
+        self.plot_reference_particle_traces(
+            axx=axs[0],
+            axy=axs[1],
+            incoming=incoming,
+            num_particles=num_particles,
+            resolution=resolution,
+            vector_idx=vector_idx,
+        )
 
-        self.plot(axs[2], 0)
+        self.plot(ax=axs[2], s=0.0, vector_idx=vector_idx)
 
         plt.tight_layout()
 
-    def plot_twiss(self, beam: Beam, ax: Optional[Any] = None) -> None:
+    def plot_twiss(
+        self,
+        incoming: Beam,
+        ax: Optional[Any] = None,
+        vector_idx: Optional[tuple] = None,
+    ) -> None:
         """Plot twiss parameters along the segment."""
-        longitudinal_beams = [beam]
-        s_positions = [0.0]
+        longitudinal_beams = [incoming]
+        s_positions = [torch.tensor(0.0)]
         for element in self.elements:
-            if element.length == 0:
+            if torch.all(element.length == 0):
                 continue
 
             outgoing = element.track(longitudinal_beams[-1])
@@ -530,6 +550,34 @@ def plot_twiss(self, beam: Beam, ax: Optional[Any] = None) -> None:
         beta_x = [beam.beta_x for beam in longitudinal_beams]
         beta_y = [beam.beta_y for beam in longitudinal_beams]
 
+        # Extraction of the correct vector element for plotting
+        broadcast_s_positions = torch.broadcast_tensors(*s_positions)
+        stacked_s_positions = torch.stack(broadcast_s_positions)
+        dimension_reordered_s_positions = stacked_s_positions.movedim(0, -1)
+        plot_s_positions = (
+            dimension_reordered_s_positions[vector_idx]
+            if stacked_s_positions.dim() > 1
+            else dimension_reordered_s_positions
+        )
+
+        broadcast_beta_x = torch.broadcast_tensors(*beta_x)
+        stacked_beta_x = torch.stack(broadcast_beta_x)
+        dimension_reordered_beta_x = stacked_beta_x.movedim(0, -1)
+        plot_beta_x = (
+            dimension_reordered_beta_x[vector_idx]
+            if stacked_beta_x.dim() > 2
+            else dimension_reordered_beta_x
+        )
+
+        broadcast_beta_y = torch.broadcast_tensors(*beta_y)
+        stacked_beta_y = torch.stack(broadcast_beta_y)
+        dimension_reordered_beta_y = stacked_beta_y.movedim(0, -1)
+        plot_beta_y = (
+            dimension_reordered_beta_y[vector_idx]
+            if stacked_beta_y.dim() > 2
+            else dimension_reordered_beta_y
+        )
+
         if ax is None:
             fig = plt.figure()
             ax = fig.add_subplot(111)
@@ -538,8 +586,8 @@ def plot_twiss(self, beam: Beam, ax: Optional[Any] = None) -> None:
         ax.set_xlabel("s (m)")
         ax.set_ylabel(r"$\beta$ (m)")
 
-        ax.plot(s_positions, beta_x, label=r"$\beta_x$", c="tab:red")
-        ax.plot(s_positions, beta_y, label=r"$\beta_y$", c="tab:green")
+        ax.plot(plot_s_positions, plot_beta_x, label=r"$\beta_x$", c="tab:red")
+        ax.plot(plot_s_positions, plot_beta_y, label=r"$\beta_y$", c="tab:green")
 
         ax.legend()
         plt.tight_layout()
@@ -548,13 +596,13 @@ def plot_twiss(self, beam: Beam, ax: Optional[Any] = None) -> None:
     def defining_features(self) -> list[str]:
         return super().defining_features + ["elements"]
 
-    def plot_twiss_over_lattice(self, beam: Beam, figsize=(8, 4)) -> None:
+    def plot_twiss_over_lattice(self, incoming: Beam, figsize=(8, 4)) -> None:
         """Plot twiss parameters in a plot over a plot of the lattice."""
         fig = plt.figure(figsize=figsize)
         gs = fig.add_gridspec(2, hspace=0, height_ratios=[3, 1])
         axs = gs.subplots(sharex=True)
 
-        self.plot_twiss(beam, ax=axs[0])
+        self.plot_twiss(incoming, ax=axs[0])
         self.plot(axs[1], 0)
 
         plt.tight_layout()
diff --git a/cheetah/accelerator/solenoid.py b/cheetah/accelerator/solenoid.py
index 2d89e208..015f905e 100644
--- a/cheetah/accelerator/solenoid.py
+++ b/cheetah/accelerator/solenoid.py
@@ -116,12 +116,15 @@ def split(self, resolution: torch.Tensor) -> list[Element]:
         # TODO: Implement splitting for solenoid properly, for now just return self
         return [self]
 
-    def plot(self, ax: plt.Axes, s: float) -> None:
+    def plot(self, ax: plt.Axes, s: float, vector_idx: Optional[tuple] = None) -> None:
+        plot_s = s[vector_idx] if s.dim() > 0 else s
+        plot_length = self.length[vector_idx] if self.length.dim() > 0 else self.length
+
         alpha = 1 if self.is_active else 0.2
         height = 0.8
 
         patch = Rectangle(
-            (s, 0), self.length[0], height, color="tab:orange", alpha=alpha, zorder=2
+            (plot_s, 0), plot_length, height, color="tab:orange", alpha=alpha, zorder=2
         )
         ax.add_patch(patch)
 
diff --git a/cheetah/accelerator/space_charge_kick.py b/cheetah/accelerator/space_charge_kick.py
index 51c97465..bac67933 100644
--- a/cheetah/accelerator/space_charge_kick.py
+++ b/cheetah/accelerator/space_charge_kick.py
@@ -642,8 +642,10 @@ def split(self, resolution: torch.Tensor) -> list[Element]:
     def is_skippable(self) -> bool:
         return False
 
-    def plot(self, ax: plt.Axes, s: float) -> None:
-        ax.axvline(s, ymin=0.01, ymax=0.99, color="orange", linestyle="-")
+    def plot(self, ax: plt.Axes, s: float, vector_idx: Optional[tuple] = None) -> None:
+        plot_s = s[vector_idx] if s.dim() > 0 else s
+
+        ax.axvline(plot_s, ymin=0.01, ymax=0.99, color="orange", linestyle="-")
 
     @property
     def defining_features(self) -> list[str]:
diff --git a/cheetah/accelerator/transverse_deflecting_cavity.py b/cheetah/accelerator/transverse_deflecting_cavity.py
index 5ac9d6b3..7a521e1b 100644
--- a/cheetah/accelerator/transverse_deflecting_cavity.py
+++ b/cheetah/accelerator/transverse_deflecting_cavity.py
@@ -218,12 +218,15 @@ def split(self, resolution: torch.Tensor) -> list[Element]:
         # element itself
         return [self]
 
-    def plot(self, ax: plt.Axes, s: float) -> None:
+    def plot(self, ax: plt.Axes, s: float, vector_idx: Optional[tuple] = None) -> None:
+        plot_s = s[vector_idx] if s.dim() > 0 else s
+        plot_length = self.length[vector_idx] if self.length.dim() > 0 else self.length
+
         alpha = 1 if self.is_active else 0.2
         height = 0.4
 
         patch = Rectangle(
-            (s, 0), self.length[0], height, color="olive", alpha=alpha, zorder=2
+            (plot_s, 0), plot_length, height, color="olive", alpha=alpha, zorder=2
         )
         ax.add_patch(patch)
 
diff --git a/cheetah/accelerator/undulator.py b/cheetah/accelerator/undulator.py
index c4c72e2c..77ebea55 100644
--- a/cheetah/accelerator/undulator.py
+++ b/cheetah/accelerator/undulator.py
@@ -64,12 +64,15 @@ def split(self, resolution: torch.Tensor) -> list[Element]:
         # TODO: Implement splitting for undulator properly, for now just return self
         return [self]
 
-    def plot(self, ax: plt.Axes, s: float) -> None:
+    def plot(self, ax: plt.Axes, s: float, vector_idx: Optional[tuple] = None) -> None:
+        plot_s = s[vector_idx] if s.dim() > 0 else s
+        plot_length = self.length[vector_idx] if self.length.dim() > 0 else self.length
+
         alpha = 1 if self.is_active else 0.2
         height = 0.4
 
         patch = Rectangle(
-            (s, 0), self.length[0], height, color="tab:purple", alpha=alpha, zorder=2
+            (plot_s, 0), plot_length, height, color="tab:purple", alpha=alpha, zorder=2
         )
         ax.add_patch(patch)
 
diff --git a/cheetah/accelerator/vertical_corrector.py b/cheetah/accelerator/vertical_corrector.py
index bd78e367..c80e998a 100644
--- a/cheetah/accelerator/vertical_corrector.py
+++ b/cheetah/accelerator/vertical_corrector.py
@@ -83,12 +83,16 @@ def split(self, resolution: torch.Tensor) -> list[Element]:
             for i in range(num_splits)
         ]
 
-    def plot(self, ax: plt.Axes, s: float) -> None:
+    def plot(self, ax: plt.Axes, s: float, vector_idx: Optional[tuple] = None) -> None:
+        plot_s = s[vector_idx] if s.dim() > 0 else s
+        plot_length = self.length[vector_idx] if self.length.dim() > 0 else self.length
+        plot_angle = self.angle[vector_idx] if self.angle.dim() > 0 else self.angle
+
         alpha = 1 if self.is_active else 0.2
-        height = 0.8 * (np.sign(self.angle[0]) if self.is_active else 1)
+        height = 0.8 * (np.sign(plot_angle) if self.is_active else 1)
 
         patch = Rectangle(
-            (s, 0), self.length[0], height, color="tab:cyan", alpha=alpha, zorder=2
+            (plot_s, 0), plot_length, height, color="tab:cyan", alpha=alpha, zorder=2
         )
         ax.add_patch(patch)
 
diff --git a/cheetah/particles/beam.py b/cheetah/particles/beam.py
index 3b1601b7..e3afd359 100644
--- a/cheetah/particles/beam.py
+++ b/cheetah/particles/beam.py
@@ -300,7 +300,7 @@ def p0c(self) -> torch.Tensor:
 
     @property
     def sigma_xpx(self) -> torch.Tensor:
-        # the covariance of (x,px) ~ $\sigma_{xpx}$
+        # The covariance of (x,px) ~ $\sigma_{xpx}$
         raise NotImplementedError
 
     @property
diff --git a/cheetah/particles/parameter_beam.py b/cheetah/particles/parameter_beam.py
index ccebd331..e20ad951 100644
--- a/cheetah/particles/parameter_beam.py
+++ b/cheetah/particles/parameter_beam.py
@@ -4,6 +4,7 @@
 import torch
 
 from .beam import Beam
+from .particle_beam import ParticleBeam
 
 
 class ParameterBeam(Beam):
@@ -340,6 +341,32 @@ def transformed_to(
             dtype=dtype,
         )
 
+    def linspaced(self, num_particles: int) -> ParticleBeam:
+        """
+        Create a `ParticleBeam` beam with the same parameters as this beam and
+        `num_particles` particles evenly distributed in the beam.
+
+        :param num_particles: Number of particles to create.
+        :return: `ParticleBeam` with `num_particles` particles.
+        """
+        return ParticleBeam.make_linspaced(
+            num_particles=num_particles,
+            mu_x=self.mu_x,
+            mu_y=self.mu_y,
+            mu_px=self.mu_px,
+            mu_py=self.mu_py,
+            sigma_x=self.sigma_x,
+            sigma_y=self.sigma_y,
+            sigma_px=self.sigma_px,
+            sigma_py=self.sigma_py,
+            sigma_tau=self.sigma_tau,
+            sigma_p=self.sigma_p,
+            energy=self.energy,
+            total_charge=self.total_charge,
+            device=self._mu.device,
+            dtype=self._mu.dtype,
+        )
+
     @property
     def mu_x(self) -> torch.Tensor:
         return self._mu[..., 0]
diff --git a/cheetah/particles/particle_beam.py b/cheetah/particles/particle_beam.py
index afe24238..98a42677 100644
--- a/cheetah/particles/particle_beam.py
+++ b/cheetah/particles/particle_beam.py
@@ -5,6 +5,7 @@
 from scipy.constants import physical_constants
 from torch.distributions import MultivariateNormal
 
+from ..utils import elementwise_linspace
 from .beam import Beam
 
 speed_of_light = torch.tensor(constants.speed_of_light)  # In m/s
@@ -450,118 +451,55 @@ def make_linspaced(
         :param device: Device to move the beam's particle array to. If set to `"auto"` a
             CUDA GPU is selected if available. The CPU is used otherwise.
         """
-        # Figure out if arguments were passed, figure out their shape
-        not_nones = [
-            argument
-            for argument in [
-                mu_x,
-                mu_px,
-                mu_y,
-                mu_py,
-                sigma_x,
-                sigma_px,
-                sigma_y,
-                sigma_py,
-                sigma_tau,
-                sigma_p,
-                energy,
-                total_charge,
-            ]
-            if argument is not None
-        ]
-        shape = not_nones[0].shape if len(not_nones) > 0 else torch.Size([1])
-        if len(not_nones) > 1:
-            assert all(
-                argument.shape == shape for argument in not_nones
-            ), "Arguments must have the same shape."
 
         # Set default values without function call in function signature
         num_particles = num_particles if num_particles is not None else torch.tensor(10)
-        mu_x = mu_x if mu_x is not None else torch.full(shape, 0.0)
-        mu_px = mu_px if mu_px is not None else torch.full(shape, 0.0)
-        mu_y = mu_y if mu_y is not None else torch.full(shape, 0.0)
-        mu_py = mu_py if mu_py is not None else torch.full(shape, 0.0)
-        sigma_x = sigma_x if sigma_x is not None else torch.full(shape, 175e-9)
-        sigma_px = sigma_px if sigma_px is not None else torch.full(shape, 2e-7)
-        sigma_y = sigma_y if sigma_y is not None else torch.full(shape, 175e-9)
-        sigma_py = sigma_py if sigma_py is not None else torch.full(shape, 2e-7)
-        sigma_tau = sigma_tau if sigma_tau is not None else torch.full(shape, 0.0)
-        sigma_p = sigma_p if sigma_p is not None else torch.full(shape, 0.0)
-        energy = energy if energy is not None else torch.full(shape, 1e8)
-        total_charge = (
-            total_charge if total_charge is not None else torch.full(shape, 0.0)
-        )
-
+        mu_x = mu_x if mu_x is not None else torch.tensor(0.0)
+        mu_px = mu_px if mu_px is not None else torch.tensor(0.0)
+        mu_y = mu_y if mu_y is not None else torch.tensor(0.0)
+        mu_py = mu_py if mu_py is not None else torch.tensor(0.0)
+        sigma_x = sigma_x if sigma_x is not None else torch.tensor(175e-9)
+        sigma_px = sigma_px if sigma_px is not None else torch.tensor(2e-7)
+        sigma_y = sigma_y if sigma_y is not None else torch.tensor(175e-9)
+        sigma_py = sigma_py if sigma_py is not None else torch.tensor(2e-7)
+        sigma_tau = sigma_tau if sigma_tau is not None else torch.tensor(1e-6)
+        sigma_p = sigma_p if sigma_p is not None else torch.tensor(1e-6)
+        energy = energy if energy is not None else torch.tensor(1e8)
+        total_charge = total_charge if total_charge is not None else torch.tensor(0.0)
         particle_charges = (
-            torch.ones((shape[0], num_particles), device=device, dtype=dtype)
-            * total_charge.view(-1, 1)
+            torch.ones((*total_charge.shape, num_particles))
+            * total_charge.unsqueeze(-1)
             / num_particles
         )
 
-        particles = torch.ones((shape[0], num_particles, 7))
+        vector_shape = torch.broadcast_shapes(
+            mu_x.shape,
+            mu_px.shape,
+            mu_y.shape,
+            mu_py.shape,
+            sigma_x.shape,
+            sigma_px.shape,
+            sigma_y.shape,
+            sigma_py.shape,
+            sigma_tau.shape,
+            sigma_p.shape,
+        )
+        particles = torch.ones((*vector_shape, num_particles, 7))
 
-        particles[:, :, 0] = torch.stack(
-            [
-                torch.linspace(
-                    sample_mu_x - sample_sigma_x,
-                    sample_mu_x + sample_sigma_x,
-                    num_particles,
-                )
-                for sample_mu_x, sample_sigma_x in zip(mu_x, sigma_x)
-            ],
-            dim=0,
+        particles[..., 0] = elementwise_linspace(
+            mu_x - sigma_x, mu_x + sigma_x, num_particles
         )
-        particles[:, :, 1] = torch.stack(
-            [
-                torch.linspace(
-                    sample_mu_px - sample_sigma_px,
-                    sample_mu_px + sample_sigma_px,
-                    num_particles,
-                )
-                for sample_mu_px, sample_sigma_px in zip(mu_px, sigma_px)
-            ],
-            dim=0,
+        particles[..., 1] = elementwise_linspace(
+            mu_px - sigma_px, mu_px + sigma_px, num_particles
         )
-        particles[:, :, 2] = torch.stack(
-            [
-                torch.linspace(
-                    sample_mu_y - sample_sigma_y,
-                    sample_mu_y + sample_sigma_y,
-                    num_particles,
-                )
-                for sample_mu_y, sample_sigma_y in zip(mu_y, sigma_y)
-            ],
-            dim=0,
+        particles[..., 2] = elementwise_linspace(
+            mu_y - sigma_y, mu_y + sigma_y, num_particles
         )
-        particles[:, :, 3] = torch.stack(
-            [
-                torch.linspace(
-                    sample_mu_py - sample_sigma_py,
-                    sample_mu_py + sample_sigma_py,
-                    num_particles,
-                )
-                for sample_mu_py, sample_sigma_py in zip(mu_py, sigma_py)
-            ],
-            dim=0,
-        )
-        particles[:, :, 4] = torch.stack(
-            [
-                torch.linspace(
-                    -sample_sigma_tau, sample_sigma_tau, num_particles, device=device
-                )
-                for sample_sigma_tau in sigma_tau
-            ],
-            dim=0,
-        )
-        particles[:, :, 5] = torch.stack(
-            [
-                torch.linspace(
-                    -sample_sigma_p, sample_sigma_p, num_particles, device=device
-                )
-                for sample_sigma_p in sigma_p
-            ],
-            dim=0,
+        particles[..., 3] = elementwise_linspace(
+            mu_py - sigma_py, mu_py + sigma_py, num_particles
         )
+        particles[..., 4] = elementwise_linspace(-sigma_tau, sigma_tau, num_particles)
+        particles[..., 5] = elementwise_linspace(-sigma_p, sigma_p, num_particles)
 
         return cls(
             particles=particles,
@@ -669,7 +607,7 @@ def transformed_to(
         else:
             particle_charges = (
                 torch.ones_like(self.particle_charges, device=device, dtype=dtype)
-                * total_charge.view(-1, 1)
+                * total_charge.unsqueeze(-1)
                 / self.particle_charges.shape[-1]
             )
 
@@ -729,6 +667,32 @@ def transformed_to(
             dtype=dtype,
         )
 
+    def linspaced(self, num_particles: int) -> "ParticleBeam":
+        """
+        Create a new beam with the same parameters as this beam, but with
+        `num_particles` particles evenly distributed in the beam.
+
+        :param num_particles: Number of particles to create.
+        :return: New beam with `num_particles` particles.
+        """
+        return self.make_linspaced(
+            num_particles=num_particles,
+            mu_x=self.mu_x,
+            mu_y=self.mu_y,
+            mu_px=self.mu_px,
+            mu_py=self.mu_py,
+            sigma_x=self.sigma_x,
+            sigma_y=self.sigma_y,
+            sigma_px=self.sigma_px,
+            sigma_py=self.sigma_py,
+            sigma_tau=self.sigma_tau,
+            sigma_p=self.sigma_p,
+            energy=self.energy,
+            total_charge=self.total_charge,
+            device=self.particles.device,
+            dtype=self.particles.dtype,
+        )
+
     @classmethod
     def from_xyz_pxpypz(
         cls,
@@ -917,15 +881,15 @@ def sigma_p(self) -> Optional[torch.Tensor]:
     @property
     def sigma_xpx(self) -> torch.Tensor:
         return torch.mean(
-            (self.x - self.mu_x.view(-1, 1)) * (self.px - self.mu_px.view(-1, 1)),
-            dim=1,
+            (self.x - self.mu_x.unsqueeze(-1)) * (self.px - self.mu_px.unsqueeze(-1)),
+            dim=-1,
         )
 
     @property
     def sigma_ypy(self) -> torch.Tensor:
         return torch.mean(
-            (self.y - self.mu_y.view(-1, 1)) * (self.py - self.mu_py.view(-1, 1)),
-            dim=1,
+            (self.y - self.mu_y.unsqueeze(-1)) * (self.py - self.mu_py.unsqueeze(-1)),
+            dim=-1,
         )
 
     @property
diff --git a/cheetah/utils/__init__.py b/cheetah/utils/__init__.py
index eb472409..a29d9ae9 100644
--- a/cheetah/utils/__init__.py
+++ b/cheetah/utils/__init__.py
@@ -1,5 +1,6 @@
 from . import bmadx  # noqa: F401
 from .device import is_mps_available_and_functional  # noqa: F401
+from .elementwise_linspace import elementwise_linspace  # noqa: F401
 from .kde import kde_histogram_1d, kde_histogram_2d  # noqa: F401
 from .physics import compute_relativistic_factors  # noqa: F401
 from .unique_name_generator import UniqueNameGenerator  # noqa: F401
diff --git a/cheetah/utils/elementwise_linspace.py b/cheetah/utils/elementwise_linspace.py
new file mode 100644
index 00000000..b3ffd7a7
--- /dev/null
+++ b/cheetah/utils/elementwise_linspace.py
@@ -0,0 +1,35 @@
+import torch
+
+
+def elementwise_linspace(
+    start: torch.Tensor, end: torch.Tensor, steps: int
+) -> torch.Tensor:
+    """
+    Generate a tensor of linearly spaced values between two tensors element-wise.
+
+    :param start: Any-dimensional tensor of the starting value for the set of points.
+    :param end: Any-dimensional tensor of the ending value for the set of points.
+    :param steps: Size of the last dimension of the constructed tensor.
+    :return: A tensor of shape `start.shape + (steps,)` containing `steps` linearly
+        spaced values between each pair of elements in `start` and `end`.
+    """
+    # Flatten the tensors
+    a_flat = start.flatten()
+    b_flat = end.flatten()
+
+    # Create a list to store the results
+    result = []
+
+    # Generate linspace for each pair of elements in a and b
+    for i in range(a_flat.shape[0]):
+        result.append(torch.linspace(a_flat[i], b_flat[i], steps))
+
+    # Stack the results along a new dimension (each linspace will become a row)
+    result = torch.stack(result)
+
+    # Reshape back to the original tensor dimensions with one extra dimension for the
+    # steps
+    new_shape = list(start.shape) + [steps]
+    result = result.view(*new_shape)
+
+    return result
diff --git a/docs/examples/simple.ipynb b/docs/examples/simple.ipynb
index dcbc2483..b6aa1203 100644
--- a/docs/examples/simple.ipynb
+++ b/docs/examples/simple.ipynb
@@ -43,15 +43,15 @@
     "segment = Segment(\n",
     "    elements=[\n",
     "        BPM(name=\"BPM1SMATCH\"),\n",
-    "        Drift(length=torch.tensor([1.0])),\n",
+    "        Drift(length=torch.tensor(1.0)),\n",
     "        BPM(name=\"BPM6SMATCH\"),\n",
-    "        Drift(length=torch.tensor([1.0])),\n",
-    "        VerticalCorrector(length=torch.tensor([0.3]), name=\"V7SMATCH\"),\n",
-    "        Drift(length=torch.tensor([0.2])),\n",
-    "        HorizontalCorrector(length=torch.tensor([0.3]), name=\"H10SMATCH\"),\n",
-    "        Drift(length=torch.tensor([7.0])),\n",
-    "        HorizontalCorrector(length=torch.tensor([0.3]), name=\"H12SMATCH\"),\n",
-    "        Drift(length=torch.tensor([0.05])),\n",
+    "        Drift(length=torch.tensor(1.0)),\n",
+    "        VerticalCorrector(length=torch.tensor(0.3), name=\"V7SMATCH\"),\n",
+    "        Drift(length=torch.tensor(0.2)),\n",
+    "        HorizontalCorrector(length=torch.tensor(0.3), name=\"H10SMATCH\"),\n",
+    "        Drift(length=torch.tensor(7.0)),\n",
+    "        HorizontalCorrector(length=torch.tensor(0.3), name=\"H12SMATCH\"),\n",
+    "        Drift(length=torch.tensor(0.05)),\n",
     "        BPM(name=\"BPM13SMATCH\"),\n",
     "    ]\n",
     ")"
@@ -72,7 +72,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "segment.V7SMATCH.angle = torch.tensor([3.142e-3])"
+    "segment.V7SMATCH.angle = torch.tensor(3.142e-3)"
    ]
   },
   {
@@ -119,19 +119,9 @@
    "execution_count": 6,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "ic| self.name: 'H10SMATCH', self.angle: tensor([0.])\n",
-      "ic| self.name: 'H10SMATCH', self.angle: tensor([0.])\n",
-      "ic| self.name: 'H12SMATCH', self.angle: tensor([0.])\n",
-      "ic| self.name: 'H12SMATCH', self.angle: tensor([0.])\n"
-     ]
-    },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAACNX0lEQVR4nO3deVxU5eI/8M+ZlR3cAFFTVFxwl82lshLF9WaapVma2S6V0qbdtPXGN8uy0jK7N/Pem1eze/NXaSrh0kbulohraq4gioCyzsx5fn/ADLOcGQFhBobPu5cxc85znvOch2HmM8/ZJCGEABERERE1eipPN4CIiIiI6gaDHREREZGXYLAjIiIi8hIMdkRERERegsGOiIiIyEsw2BERERF5CQY7IiIiIi/BYEdERETkJRjsiIiIiLwEgx0R1bmjR49i+PDhCA4OhiRJWLt2raeb1KR99tlnkCQJJ0+erNFy999/Pzp06FAvbSKi+sFgR9SEmT/wzf80Gg3atGmD+++/H2fPnq11vdOmTcP+/fvxt7/9Df/6178QGxtbh61uXLZu3WrTx1qtFh07dsTUqVNx/PjxOl3XG2+80SBD9MmTJ236wNW/moZPIrKl8XQDiMjzXn31VURGRqK0tBS//vorPvvsM/z000/IzMyEj49PjeoqKSlBRkYG/vrXvyI5ObmeWtz4PPnkk4iLi4PBYMCePXuwbNkyrFu3Dvv370dERESdrOONN97AnXfeiXHjxtlMv++++zBp0iTo9fo6WU9NtWrVCv/6179spi1cuBBnzpzBu+++61CWiGqPwY6IMHLkSMuo2oMPPoiWLVvizTffxNdff4277rqrRnXl5uYCAEJCQuqsfaWlpdDpdFCpGu9Ohptuugl33nknAGD69Ono0qULnnzySaxYsQJz586tdb1CCJSWlsLX19dpGbVaDbVaXet1XC9/f3/ce++9NtNWrVqFy5cvO0y3Vp1tIyJbjfddkojqzU033QQA+OOPP2ymHzp0CHfeeSeaN28OHx8fxMbG4uuvv7bMf/nll9G+fXsAwLPPPgtJkmyO0Tp79iweeOABhIWFQa/Xo0ePHvj0009t1mHedblq1Sq8+OKLaNOmDfz8/FBYWAgA2L59O0aMGIHg4GD4+flhyJAh+Pnnn23qePnllyFJEo4dO4b7778fISEhCA4OxvTp01FcXOywvf/+978RHx8PPz8/NGvWDDfffDM2bdpkU+a7777DTTfdBH9/fwQGBmL06NE4cOBADXu2ym233QYAOHHiBABg+fLluO222xAaGgq9Xo/o6Gh89NFHDst16NABY8aMwcaNGxEbGwtfX198/PHHkCQJRUVFWLFihWW35v333w/A+TF23333HYYMGYLAwEAEBQUhLi4OK1eudNluWZaxaNEi9OjRAz4+PggLC8MjjzyCy5cv17ovrrVtNemf6m5XdV5HV65cwaxZs9ChQwfo9XqEhoZi2LBh2LNnz3VvK1F94YgdETkwB4BmzZpZph04cACDBw9GmzZtMGfOHPj7++OLL77AuHHj8N///hd33HEHxo8fj5CQEMyePRuTJ0/GqFGjEBAQAADIycnBgAEDIEkSkpOT0apVK3z33XeYMWMGCgsLMWvWLJs2vPbaa9DpdHjmmWdQVlYGnU6HzZs3Y+TIkYiJicFLL70ElUpl+cD/8ccfER8fb1PHXXfdhcjISKSmpmLPnj34+9//jtDQULz55puWMq+88gpefvllDBo0CK+++ip0Oh22b9+OzZs3Y/jw4QCAf/3rX5g2bRqSkpLw5ptvori4GB999BFuvPFG7N27t1YnGJhDc4sWLQAAH330EXr06IG//OUv0Gg0+Oabb/D4449DlmXMnDnTZtnDhw9j8uTJeOSRR/DQQw+ha9eu+Ne//oUHH3wQ8fHxePjhhwEAnTp1crr+zz77DA888AB69OiBuXPnIiQkBHv37sWGDRtwzz33OF3ukUcewWeffYbp06fjySefxIkTJ7B48WLs3bsXP//8M7RabY374lrbVpP+qc52Vfd19Oijj+LLL79EcnIyoqOjcenSJfz00084ePAg+vfvf13bSVRvBBE1WcuXLxcAxPfffy9yc3PF6dOnxZdffilatWol9Hq9OH36tKXs0KFDRa9evURpaallmizLYtCgQSIqKsoy7cSJEwKAeOutt2zWNWPGDNG6dWtx8eJFm+mTJk0SwcHBori4WAghxJYtWwQA0bFjR8s087qioqJEUlKSkGXZMr24uFhERkaKYcOGWaa99NJLAoB44IEHbNZ1xx13iBYtWlieHz16VKhUKnHHHXcIk8lkU9a8jitXroiQkBDx0EMP2czPzs4WwcHBDtPtmbfn008/Fbm5ueLcuXNi3bp1okOHDkKSJLFz507LdthLSkoSHTt2tJnWvn17AUBs2LDBoby/v7+YNm2aw3Tz7/nEiRNCCCHy8/NFYGCgSEhIECUlJYrbLYQQ06ZNE+3bt7c8//HHHwUA8fnnn9sss2HDBsXprowePdqm7mttW3X6pzrbVZPXUXBwsJg5c2a1t4moIeCuWCJCYmIiWrVqhXbt2uHOO++Ev78/vv76a7Rt2xYAkJeXh82bN+Ouu+7ClStXcPHiRVy8eBGXLl1CUlISjh496vIsWiEE/vvf/2Ls2LEQQliWv3jxIpKSklBQUOCwe2vatGk2x1bt27cPR48exT333INLly5Zli8qKsLQoUPxww8/QJZlmzoeffRRm+c33XQTLl26ZNmtu3btWsiyjPnz5zscvydJEgAgLS0N+fn5mDx5sk271Wo1EhISsGXLlmr18QMPPIBWrVohIiICo0ePtuw2NR/baL2tBQUFuHjxIoYMGYLjx4+joKDApq7IyEgkJSVVa71K0tLScOXKFcyZM8fh5BjzditZs2YNgoODMWzYMJu+iImJQUBAQLX7whVn21ad/qnOdtXkdRQSEoLt27fj3Llz171dRO7CXbFEhCVLlqBLly4oKCjAp59+ih9++MHmDMpjx45BCIF58+Zh3rx5inVcuHABbdq0UZyXm5uL/Px8LFu2DMuWLXO6vLXIyEib50ePHgVQEficKSgosNl9fMMNN9jMN8+7fPkygoKC8Mcff0ClUiE6Otppneb1mo+JsxcUFOR0WWvz58/HTTfdBLVajZYtW6J79+7QaKregn/++We89NJLyMjIcDgOsKCgAMHBwZbn9n1TU+bdwD179qzRckePHkVBQQFCQ0MV59v/DmvD2bZVp3+qs101eR0tWLAA06ZNQ7t27RATE4NRo0Zh6tSp6NixY003i8htGOyICPHx8ZaRo3HjxuHGG2/EPffcg8OHDyMgIMAygvHMM884HSnq3Lmz0/rNy997771OP1B79+5t89z+TEhzHW+99Rb69u2rWIf5eD4zZ2eCCiGcttWeeb3/+te/EB4e7jDfOpy50qtXLyQmJirO++OPPzB06FB069YN77zzDtq1awedTof169fj3XffdRiJ9NRZorIsIzQ0FJ9//rni/Lq4VInSttW0f1ypyevorrvuwk033YSvvvoKmzZtwltvvYU333wT//vf/zBy5MiabxyRGzDYEZENtVqN1NRU3HrrrVi8eDHmzJljGaHQarVOw4krrVq1QmBgIEwmU62WB6pOBAgKCqp1HUp1yrKMrKwspx/y5vWGhobW2XrtffPNNygrK8PXX39tM8pY012brnajWjNvU2ZmpstArrTc999/j8GDB7s1XFa3f6qzXTV9HbVu3RqPP/44Hn/8cVy4cAH9+/fH3/72NwY7arB4jB0RObjlllsQHx+PRYsWobS0FKGhobjlllvw8ccf4/z58w7lzdeuc0atVmPChAn473//i8zMzBovDwAxMTHo1KkT3n77bVy9erVWddgbN24cVCoVXn31VYdRH/OoXlJSEoKCgvDGG2/AYDDUyXrtmUcWrUcSCwoKsHz58hrV4+/vj/z8/GuWGz58OAIDA5GamorS0lKbea5GM++66y6YTCa89tprDvOMRmO11l0b1e2f6mxXdV9HJpPJ4djG0NBQREREoKys7Po3iqiecMSOiBQ9++yzmDhxIj777DM8+uijWLJkCW688Ub06tULDz30EDp27IicnBxkZGTgzJkz+O2331zW93//93/YsmULEhIS8NBDDyE6Ohp5eXnYs2cPvv/+e+Tl5blcXqVS4e9//ztGjhyJHj16YPr06WjTpg3Onj2LLVu2ICgoCN98802NtrFz587461//itdeew033XQTxo8fD71ej507dyIiIgKpqakICgrCRx99hPvuuw/9+/fHpEmT0KpVK5w6dQrr1q3D4MGDsXjx4hqt197w4cOh0+kwduxYPPLII7h69So++eQThIaGKgZpZ2JiYvD999/jnXfeQUREBCIjI5GQkOBQLigoCO+++y4efPBBxMXF4Z577kGzZs3w22+/obi4GCtWrFCsf8iQIXjkkUeQmpqKffv2Yfjw4dBqtTh69CjWrFmD9957z3IR5rpU3f6pznZV93V05coVtG3bFnfeeSf69OmDgIAAfP/999i5cycWLlxY59tIVGc8dj4uEXmc+TIY5ktuWDOZTKJTp06iU6dOwmg0CiGE+OOPP8TUqVNFeHi40Gq1ok2bNmLMmDHiyy+/tCzn7HInQgiRk5MjZs6cKdq1aye0Wq0IDw8XQ4cOFcuWLbOUMV8eZM2aNYpt3rt3rxg/frxo0aKF0Ov1on379uKuu+4S6enpljLmy53k5uYqbq/5sh9mn376qejXr5/Q6/WiWbNmYsiQISItLc2mzJYtW0RSUpIIDg4WPj4+olOnTuL+++8Xu3btctK71dses6+//lr07t1b+Pj4iA4dOog333xTfPrppw7tbd++vRg9erRiHYcOHRI333yz8PX1FQAslz5xtt1ff/21GDRokPD19RVBQUEiPj5e/Oc//7HMt7/cidmyZctETEyM8PX1FYGBgaJXr17iueeeE+fOnXO5jdacXe7E2bZVt3+qs11CXPt1VFZWJp599lnRp08fERgYKPz9/UWfPn3Ehx9+WO1tJPIESYgaHEVMRERERA0Wj7EjIiIi8hIMdkRERERegsGOiIiIyEsw2BERERF5CQY7IiIiIi/BYEdERETkJXiB4gZClmWcO3cOgYGB1b4tEBEREXk/IQSuXLmCiIgIqFSux+QY7BqIc+fOoV27dp5uBhERETVQp0+fRtu2bV2WYbBrIAIDAwFU/NKCgoLqvH6DwYBNmzZZbgFE9Y997n7sc89gv7sf+9z9PNnnhYWFaNeunSUruMJg10CYd78GBQXVW7Dz8/NDUFAQ3wTchH3ufuxzz2C/ux/73P0aQp9X51AtnjxBRERE5CUY7IiIiIi8BIMdERERkZfgMXZERETklYyyQJmQYZAFymWBMiFQLssolwXKReU0uXK+ECiTK+dXziuXZZTJAgYhUGI04pA+BL/+cR4mSVIoK5B8Qyhuan7tExzqU6MLdkuWLMFbb72F7Oxs9OnTBx988AHi4+Odll+zZg3mzZuHkydPIioqCm+++SZGjRplmS+EwEsvvYRPPvkE+fn5GDx4MD766CNERUVZyuTl5eGJJ57AN998A5VKhQkTJuC9995DQEAAAGDr1q149913sWPHDhQWFiIqKgrPPvsspkyZUn8dQURE1ECYKkORoTLolFUGnXIhW0JPWWWgMlgFqDIhqkJX5bIGuXK+1bIVdVYuXxnWrOeZw5o5hJkDmVzXG6oPBs7nOZ09PqxZXa+xxhpVsFu9ejVSUlKwdOlSJCQkYNGiRUhKSsLhw4cRGhrqUP6XX37B5MmTkZqaijFjxmDlypUYN24c9uzZg549ewIAFixYgPfffx8rVqxAZGQk5s2bh6SkJGRlZcHHxwcAMGXKFJw/fx5paWkwGAyYPn06Hn74YaxcudKynt69e+P5559HWFgYvv32W0ydOhXBwcEYM2aM+zqIiIi8mlwZioqMJhRKKpwrM0A2yLajUq5CkfWolFUoMgcxg1VZh9BkCV22o1TlQoZJeLpnrk0CoFdJ0EoSdCoV9CoJusrnepUKOpUEnVQxzTJfkqBVVczXCIEzJ0+gW+dO8FFroFNJlXWoLMvFBft7ejMhCSEawa+jQkJCAuLi4rB48WIAFXdraNeuHZ544gnMmTPHofzdd9+NoqIifPvtt5ZpAwYMQN++fbF06VIIIRAREYGnn34azzzzDACgoKAAYWFh+OyzzzBp0iQcPHgQ0dHR2LlzJ2JjYwEAGzZswKhRo3DmzBlEREQotnX06NEICwvDp59+Wq1tKywsRHBwMAoKCurtcifr16/HqFGjeGq8m7DP3Y997hne2O+ysA1F9rvqDJbdepXzhe2olNKuvHInocgy0uQwEmU92iVgEDKMjeQT2z4UVQUmCTrJOlRVPTbPMz/Wq1SVocsqbFXWqVNJ0FuV1VmFNW3lc9uwpoJGqt7lQpzx5Ou8Jhmh0YzYlZeXY/fu3Zg7d65lmkqlQmJiIjIyMhSXycjIQEpKis20pKQkrF27FgBw4sQJZGdnIzEx0TI/ODgYCQkJyMjIwKRJk5CRkYGQkBBLqAOAxMREqFQqbN++HXfccYfiugsKCtC9e/fabi4RUZMghPWxTpWhSXFUSXlXnTkQlVuFoqrQpTwq5RCaFI7BaiwByj4wVY0i2YUm6xBUGYqqAlLlqJPViJVepbIKSFahycVolzl0aSWJt8b0oEYT7C5evAiTyYSwsDCb6WFhYTh06JDiMtnZ2Yrls7OzLfPN01yVsd/Nq9Fo0Lx5c0sZe1988QV27tyJjz/+2On2lJWVoayszPK8sLAQQMU3AoPB4HS52jLXWR91kzL2ufuxz50TomrUyDLyJBRCkXXIMs8X9scvVdVhEAKlRiP+9GmBr7P+hBFS1YiU1aiVJZxZ6qza9dcYaCXJJvjY/lQ5TNNaAlPFfMvIk2QdiKpCl22IkizrM49K2cyXJEgmE7amf4/hw4Y1kFFSAQgBmACjp5tSTzz5/lKTdTaaYNdYbNmyBdOnT8cnn3yCHj16OC2XmpqKV155xWH6pk2b4OfnV2/tS0tLq7e6SRn73P082ecCgAmAERKMklTxExKMEqweSzBAgqlymqFymgkSDIDdcsrLVzy2KutiXeaf9UoXAORdve5qVEJACwGNENBAQANYPTZPh9Vj12W1EFCLivLmetUQ0CrWK6CpLGs9TQ33XBtMACit/FcdEvj+4gme6PPi4uJql200wa5ly5ZQq9XIycmxmZ6Tk4Pw8HDFZcLDw12WN//MyclB69atbcr07dvXUubChQs2dRiNRuTl5Tmsd9u2bRg7dizeffddTJ061eX2zJ0712Y3sfk+cMOHD6+3Y+zS0tIwrMF8u/N+7PP6JYSAUaBql5oQKC43YMtPPyFu4CDIKnXVgd82xzQ521UnHMpZL1u1e9C6jqrdeQarEanGQCOhareaZDtKZL1bzXr3nv2olfkYKI2QcfLYMfTs2gU+Go3j8VCW8tZ1qGyfV5ZTcRdetfD9xf082efmvXrV0WiCnU6nQ0xMDNLT0zFu3DgAFSdPpKenIzk5WXGZgQMHIj09HbNmzbJMS0tLw8CBAwEAkZGRCA8PR3p6uiXIFRYWYvv27XjssccsdeTn52P37t2IiYkBAGzevBmyLCMhIcFS79atWzFmzBi8+eabePjhh6+5PXq9Hnq93mG6Vqut1xdMfddPjryhz43ytY5fquVZd3a76pwdV2Wze9DqGCzFCBXQBtj/p7u7yCm1BNvjm6Sq45esd9VZHytlDkxKZ90pna3n9MB0JweY61QS1HUYoAwGA9Zn7cGodqGN/rXe2HjD+0tj44k+r8n6Gk2wA4CUlBRMmzYNsbGxiI+Px6JFi1BUVITp06cDAKZOnYo2bdogNTUVAPDUU09hyJAhWLhwIUaPHo1Vq1Zh165dWLZsGYCKs2NmzZqF119/HVFRUZbLnURERFjCY/fu3TFixAg89NBDWLp0KQwGA5KTkzFp0iTLGbFbtmzBmDFj8NRTT2HChAmWY+90Oh2aN2/u5l6ixszkItxUHTSucNadeVTpWmfdOVzKwPasu/LKg8jtL5dQ59eCqgcqADqVBJXJCD+druqMOPvQZH3QuJNQZH9WXVUIsx1lqlqH3YHrkgRtZdm6DFBERNfSqILd3XffjdzcXMyfPx/Z2dno27cvNmzYYDn54dSpU1Cpqo6EGDRoEFauXIkXX3wRL7zwAqKiorB27VrLNewA4LnnnkNRUREefvhh5Ofn48Ybb8SGDRss17ADgM8//xzJyckYOnSo5QLF77//vmX+ihUrUFxcjNTUVEuoBIAhQ4Zg69at9dgjVFuydYCyCkE2lxq4ZiiyvyimbLOrrsxowmnfVvg88yQMgMsrn5vb0ZiuBaV01p3ipQbsL0VgF4qqDiJXOZS1GZWyPjjdavehObhpVJJXXnaDiKgmGtV17LyZt17Hzv5aUM531dmPRMlWy1VczbxMYZ6zXXU2Yc1+fiO5mCYAq7PoFC5FYH99J/vQ5GxXnfUxVU521SleuLMyvF3vtaDqE4OdZ7Df3Y997n68jh01GFeNJmRdKcYRtR6B+VdhklQOu+osxz/ZjVophSLrES3b6z85HoPVGK8F5RCaJNtgYxmVsrsUgd4uFKlkGUcOHEBMn97w1WoURqKsR7uqwpu5noYcoIiIqGFisGsCDhaV4i+/nQD8w4FMzx5UXjWKZB+YarqrTmFUyuo6T1r7XXUuRrvq62KaBoMB6/ddxajQEH6jJiIit2CwawL81Sq002tRXlyMZoEB0KtVdqFI4aw7Z7vq7M+6c3EsleNoF69GTkREVJ8Y7JqA6ABf/BLXpeLYgCE8HoOIiKgmhDBBlssAlMJguAxZliCEAbJsgBBGCGGELAzw9WkDrbaZR9vKYEdERET1RghRGX4MkOWKn0IYK0ORAbIwQlQGJFkYIGTzT9tp1mXlyjoqHldjecv6rJaxLqvYNqMlvKHyqpkBgUDGr863NTp6IVqHj3NLvzrDYEdERNSAVYwW2YaOckMJJOkSiouPQ62GYqBRCk9VgUgpPJkDj21Z65BjvZzsNKw5TvdGkqSFSqWFJGkgSRqoJC1UKp2nm8VgR0RE3qtqtKgq5FQ8NkKI8srAYx4NMo8MGSHL5ZWBxzwaZLCUlUW5VTgyQtiVtQ1P5Q5Bynl4sm5b1SgSnFwi3D8A2LXbvf1ZVyRJXRmIKoKROSCpJC0klRYqSQNJVTG/YlpleFLpbIKUdVmVVDnPbjlV5XpsQpiqqqxK0lbO11RO01UuY7ucyQRs2pSOkSPHQKv1abDHjDPYERGRU0LINscS2QSZygBSbiiBSvUnCgp2Q6WSbY45qtpVZhtyHOq0Pl5JaWTJMlpUsX5LOLIKYY671Srq9UaSpIUsS5UBoyrkOIYkhXBkHYisg4yTQFRV1iocWQUiy2PrOm3KVtYpaSrDkxaSpLr2RjYwBoMBgDlYNsxQBzDYERHVG+vRIpvdYg4jRLa7sWwDkdJxRlYhx2G3mLNApHzskPNAVO5ytMienz/w2+/12591R1UZOpSD0LUC0bVHlszTFQKRddBRGi2yKVv12HqaJKlhNBp5gWJSxGBHRA1W1WiR7YHTzo7rMRhKoFYfxqVLvlCphdXuL4XlnR1ErXQQtl1ZmzPhZPvw1DRGi2zDhgalpQb4+wdZdnEphRzl0SLXgcj2scYhEFU91igGIttw1XhHi4iqi8GOyEtVjBaZHEeDbI7lcTyup3oHYSuNBlnvKrM/a83FKJKL0aTqjhZZ8/UDDmTVfX/WHfvRIvvdX1UhR+nYI+cjS+bwpBSOqsKP42iRk0BkFYRsRpsUdkOZb7V0Cy+nRORxDHZETtiOFikFHYUDpi1ly2E0lEGj2Y3s7BKoVMLqgOlyJ+HI7iBsJ8cOWe+CUzwmySqEeSNngcg8/cqVYgQHN4darXMyWmQbcqqCjatApDRaZH/skGMgsh6ZqgpzHC0iovrDYEf1omq0SGnXlcLZZkpnpdnsFrMNRI5ly5UDj0M4qjh2yHnZqhEsIUzX3Q8+vsCRo3XQoXVGVRk6dE7CkcblsUfORpYcR4uUd5VVHZOkHIiUjjmyPgvuWgctm0eObr2FI0dE1DQx2DUBZWW5yM5eB632d5w+cx6SZFK42KP9Qdi2o1AuR4usw5PVZQS8kfPRIrvT8FVaAGpculSAVq3CoVbrqjdaZB2sHMKRbSCyfWwfiDhaRETUFDHYNQGlpWdw7I/XoPcBTpzwZEuURosqrz2kNFqkeGC148iS0in7DoHI5gw25UB0vaNF9syjR716cvSIiIjcg8GuCdBqm6NlyyScP38BbdrcAI1ab3XMke3FGK1Hi6xDl0MgqvEFHjWQJLWnu4KIiMirMdg1AX5+7RHd/T2cPLEe3bpy9IiIiMhb8YAbIiIiIi/BYEdERETkJbgrloiIiBocWZZt/gkhHKYp/auvckajEWfOnMHGjRudti8+Ph7t27f3aL8x2BERETUAFdf/rF7YMBgMKCkpQXZ2NlQqldtDjjvKNVS5ublO50VFRTHYERFR0+Xqg72uQ0RDDTDWZWrq0KFD9fBbadgkSYJKpXL452x6XZUDgBMnTqBz587QarWK5dq0aePh3mmEwW7JkiV46623kJ2djT59+uCDDz5AfHy80/Jr1qzBvHnzcPLkSURFReHNN9/EqFGjLPOFEHjppZfwySefID8/H4MHD8ZHH32EqKgoS5m8vDw88cQT+Oabb6BSqTBhwgS89957CAgIAACUlpbi0Ucfxe7du3Hw4EGMGTMGa9eurbc+IKLGrSGEiLosZzKZcPnyZZw7d67aAeZ6wkxTpBQ0DAYDfHx8oFaraxVc3BGG6qNcTa4nWpcs90S+5ZYGfXWJRhXsVq9ejZSUFCxduhQJCQlYtGgRkpKScPjwYYSGhjqU/+WXXzB58mSkpqZizJgxWLlyJcaNG4c9e/agZ8+eAIAFCxbg/fffx4oVKxAZGYl58+YhKSkJWVlZ8PHxAQBMmTIF58+fR1paGgwGA6ZPn46HH34YK1euBACYTCb4+vriySefxH//+1/3dQhRI1GTXUzXU85gMODixYvYtWsXJElqsKM53qqkpKRO63NngGho4cV+vn2YMYeMUaN4CSuyJYlG9HUpISEBcXFxWLx4MYCKb73t2rXDE088gTlz5jiUv/vuu1FUVIRvv/3WMm3AgAHo27cvli5dCiEEIiIi8PTTT+OZZ54BABQUFCAsLAyfffYZJk2ahIMHDyI6Oho7d+5EbGwsAGDDhg0YNWoUzpw5g4iICJt13n///cjPz6/xiF1hYSGCg4NRUFCAoKCgGi1bHXwTcL/y8nKsX78ew4cPh1qt9vioiifLNaK3GY+y/4BvqEHDvqwQArt370ZCQoLNLqrrXTc5x/d09/Nkn9ckIzSaEbvy8nLs3r0bc+fOtUxTqVRITExERkaG4jIZGRlISUmxmZaUlGQJXSdOnEB2djYSExMt84ODg5GQkICMjAxMmjQJGRkZCAkJsYQ6AEhMTIRKpcL27dtxxx131OFWNn4NIUQ0lFEac5jZt2+fZ38pDVxdhg2g4sDm1q1bO+yeamhhyNn0xshgMODYsWPo2LEjQwaRhzWaYHfx4kWYTCaEhYXZTA8LC3N68Gh2drZi+ezsbMt88zRXZex382o0GjRv3txSpjbKyspQVlZmeV5YWAig4g3SYDDUul4leXl5+PHHH3H27FnLrmJnQeV6psmy9+5iqmvV/bCv7rS6WL62865nvUq7mK6HwWBAWloahg0b1qgCRmP/+zG/Z9X1exc5xz53P0/2eU3W2WiCnbdJTU3FK6+84jB906ZN8PPzq9N1FRUV4ciRIwCAy5cv12ndNWH+ADd/mF/reUMoW1/rcafGHhpqIy0tzdNNaJLY7+7HPnc/T/R5cXFxtcs2mmDXsmVLqNVq5OTk2EzPyclBeHi44jLh4eEuy5t/5uTkoHXr1jZl+vbtaylz4cIFmzqMRiPy8vKcrrc65s6da7ObuLCwEO3atcPw4cPr/Bi7K1euoHXr1jh69Ci6desGjUZTpyM21Rmhaay7mK5HYx09aszY557Bfnc/9rn7ebLPzXv1qqPRBDudToeYmBikp6dj3LhxACpGItLT05GcnKy4zMCBA5Geno5Zs2ZZpqWlpWHgwIEAgMjISISHhyM9Pd0S5AoLC7F9+3Y89thjljry8/Oxe/duxMTEAAA2b94MWZaRkJBQ6+3R6/XQ6/UO07VabZ2/YJo3b44bb7wRhYWFGDhwIN8E3Kw+fqfkGvvcM9jv7sc+dz9P9HlN1tdogh0ApKSkYNq0aYiNjUV8fDwWLVqEoqIiTJ8+HQAwdepUtGnTBqmpqQCAp556CkOGDMHChQsxevRorFq1Crt27cKyZcsAVOwWmzVrFl5//XVERUVZLncSERFhCY/du3fHiBEj8NBDD2Hp0qUwGAxITk7GpEmTbM6IzcrKQnl5OfLy8nDlyhXLAfPmwEhERERU3xpVsLv77ruRm5uL+fPnIzs7G3379sWGDRssJz+cOnXKcmYcAAwaNAgrV67Eiy++iBdeeAFRUVFYu3at5Rp2APDcc8+hqKgIDz/8MPLz83HjjTdiw4YNlmvYAcDnn3+O5ORkDB06FCpVxQWK33//fZu2jRo1Cn/++afleb9+/QCAl3kgIiIit2lUwQ4AkpOTne563bp1q8O0iRMnYuLEiU7rkyQJr776Kl599VWnZZo3b265GLEzJ0+edDmfiIiIqL7xCpBEREREXqLRjdgRERER1RchBCAAWP0UMiCXG6E2SpCLDTCpreaZy8qAyl8Dld6z0YrBjoiIqB7YBATZ/rlVILAOCLJ1mLANGNbPjQYj/K+oUf7nFchqtSV8WMqa65WF7TRZub6qZRTmyY71ObTdqt6KbXPe9qrn1uUV+qKynxTb7qw9spO+dNlW83NzGee/075ohtydu53Ob3Z3V/j3c7x3vTsx2BERNXC2H2K2H8AOH4qykw/Fan7IKn/YwzYg2HxgAiaDES0u6FCy+wLKVCrHtjp8INt9ANe27a623fIh7uQDXWHdyoGgGv3usC3XDgh1oRuCcTnzQP2uhJyTzP8kQJLMPzyOwY6oCXH6Ievqg8r+G7/Tb73WH7gKH8hWH9ZOP2SrPbqg3FbZaELEKV9c2XQKKknltO3XHIGwCwjVGl2oQTiqyegCGslNQzogAIV/HPd0MxonSzio+Cmpqp5LKskhPECSICSgpKQYfv7+kNRWy5rrqVzO9fOq+pTWDZVVfYrtMT+3Lm9Xn9W6nC9v13ZJAlTO2u5kXdbP7bdVad2ulnfSdqPJiO82bMDIUSOh1Wkb7IX3GeyoVqrzIevwQVWbb+iWD2AnH6oKw+guP2Qt5e3arrj7w2rd9mHIvoz9N3whIJtkdDwfgPzLhyveAGo4ulCrcOQQlqwDRb2+JBqM1vBF8dlznm6GZzj9ADZ/YFs9t/rArJhvfgznAcGqjPVzAYHc3Fy0CguFSq2unI9qf8jafuCiqn2Schmb8KEUHqzqcfpcMRC4qM8hEMAxHKns+s4++Ci03VJ/DRkMBqxfvx6jRg3mBYrdRDLIFYFT5f5bQ9YEg10TUH7uKvJWHUL0lWBcPLoPEiQXIxDmMGT/3DZgUPU0gw5leZc93Yyac/YtWelD9Vrf8O0/VO0/6OwDhv2Hqv08xXVVPJeFwMmTJxHZMRIqjcr1h6zNN3RzW52v2+YD3Vk4cniuFChgGwiUts8yWnGN8CHZtdVDDAYDMtafQJdRNzNkEHkYg10TIIwyjBdK4As1TCWl7l15Tb8lO/mG7/At1+WwuXmZa4QH+3UpfQArrauaH7Im2YTMAwfQs3dPaDQa122vaTiyarv98k7b7jAaYX5uXR4N+pvotRgMBpxZn4XeI9szYBBRk8Rg1wRoQ/3QbHp3/Lp9OwYMHACNVuMQfBSPfbAPD9UZnbCa1pgDQl0wGAy4eGkP/GLDGDKIiMgtGOyaAJWPBrqOwbh6yAhdhyCGDCIiIi9Vo2CXn5+Pr776Cj/++CP+/PNPFBcXo1WrVujXrx+SkpIwaNCg+monEREREV1DtW4pdu7cOTz44INo3bo1Xn/9dZSUlKBv374YOnQo2rZtiy1btmDYsGGIjo7G6tWr67vNRERERKSgWiN2/fr1w7Rp07B7925ER0crlikpKcHatWuxaNEinD59Gs8880ydNpSIiIiIXKtWsMvKykKLFi1clvH19cXkyZMxefJkXLp0qU4aR0RERETVV61dsdcKdddbnoiIiIiuX63Oij137hx++uknXLhwAbJse7+bJ598sk4aRkREREQ1U+Ng99lnn+GRRx6BTqdDixYtbK5VJkkSgx0RERGRh9Q42M2bNw/z58/H3LlzoVJVa08uERGRA8u9mFFxv1nL/ZAhzJMr7nkMq9sbwmoZUbmk9TzzMkLhsdU6bddXUY/D+m3aJmzXV7lI1for125pm7BZn/U0x/VbbY/S9lq2o2p9RqMRxdlncWr/PqjVapv1Vy3jenus+7Oqi5S3x6b+6myPZZbt+pW2x+axze/I+e/P4bGz14/S786yjPPtcWizAGRZRu7JE9iaewaSpLKUq2oL0OOWRER06QZPqnGwKy4uxqRJkxjqGhEhyzCWl0M2GWEsLwNkU/XeIJX+eK/5Blm9NxT79ZkXqtEftLlMTT4QLPUqbK+5I6r5Bmm7jOMbpNFoxJU//8CRjB8rbox+rTcUJ29QLt8g7X5/9fcG6azvrr09Sm+QQmGepU7zptTkw7Ry/bIsI/vsWWw4fhCSJNnMc7l+u+2pft8pvb5dv/Zr8rd3rfULSwWu+65qGet22Pad8muxGn1XOc9kNOLDL1dc83dns3103dZuXu/pJjQ5vx/Jcjovomt3jwc7SYia/YU999xzaN68OebMmVNfbWqSCgsLERwcjIKCAgQFBdVp3eeOHMJ/5vHyM0TUhEkSJFQeOmS55aHVvZQrnlXdUrHycdXRRlW3TbSUs9SLqtsqwup2ilbzLOu3zLJdv1LbbJa3qtf8peXKlSsICgqy3IfbXL9lefOi1uu229aKp1a3hFSYp7R+Z22r6ger9V9n31nXp/S7c9p3Ln531vOqu35ZlnHs2DFERXWGSq2x3bbKqjrHDkCr9pGoazXJCDUesUtNTcWYMWOwYcMG9OrVy+H2VO+8805Nq6TG5hpvkFXzavAGaXmzgeMfmd28ar1B2s1z9QZpP68mb5DW22r/BiZkgby8PLRo2aJyhNv2DURp/Tb317V6Q6l131m2x7a+Gn+4SJY11OwNUrFtVsvYPHf24WL/gaHcd0DFrpKDBw8iOjoaao3GYV0OH1hW2+PQt0r9qfhatG+b8mtRaf3WHwiWeVZ1V/WD3e8KdvVb1V3VHa63p/qvRYX127RNgtFoxNatW3HrbbdCq9Eq96eTvz3raXX1t2fdNm+9Z7XBYMD69esxatQo3ibSTQwGAy6vX48BDbzPaxXsNm7ciK5duwKA4xsDNTjhnaLwyLLPkZa2CcOHJ0Gr01b7DVLxA4GqhW+87mcwGHBeaNB3BPvcnQwGA7QBgQhqGcp+J/KwGh8ot3DhQnz66ac4ePAgtm7dii1btlj+bd68uT7aaGPJkiXo0KEDfHx8kJCQgB07drgsv2bNGnTr1g0+Pj7o1asX1q+3PR5BCIH58+ejdevW8PX1RWJiIo4ePWpTJi8vD1OmTEFQUBBCQkIwY8YMXL161abM77//jptuugk+Pj5o164dFixYUDcbXAdUajX0fn5QaXXQ+fpC5+MLrY8PtHofaHV6aHS6in9aLdQaLdQaDVRqNVQqNSSVquIfQx0REVGDV+Ngp9frMXjw4PpoyzWtXr0aKSkpeOmll7Bnzx706dMHSUlJuHDhgmL5X375BZMnT8aMGTOwd+9ejBs3DuPGjUNmZqalzIIFC/D+++9j6dKl2L59O/z9/ZGUlITS0lJLmSlTpuDAgQNIS0vDt99+ix9++AEPP/ywZX5hYSGGDx+O9u3bY/fu3Xjrrbfw8ssvY9myZfXXGURERET2RA298cYb4oknnqjpYnUiPj5ezJw50/LcZDKJiIgIkZqaqlj+rrvuEqNHj7aZlpCQIB555BEhhBCyLIvw8HDx1ltvWebn5+cLvV4v/vOf/wghhMjKyhIAxM6dOy1lvvvuOyFJkjh79qwQQogPP/xQNGvWTJSVlVnKPP/886Jr167V3raCggIBQBQUFFR7mZooLy8Xa9euFeXl5fVSPzlin7sf+9wz2O/uxz53P0/2eU0yQo1H7Hbs2IEVK1agY8eOGDt2LMaPH2/zr76Ul5dj9+7dSExMtExTqVRITExERkaG4jIZGRk25QEgKSnJUv7EiRPIzs62KRMcHIyEhARLmYyMDISEhCA2NtZSJjExESqVCtu3b7eUufnmm6HT6WzWc/jwYVy+fPk6t5yIiIioemp88kRISEi9BjhnLl68CJPJhLCwMJvpYWFhOHTokOIy2dnZiuWzs7Mt883TXJUJDQ21ma/RaNC8eXObMpGRkQ51mOc1a9bMoW1lZWUoKyuzPC8sLARQcRCywWBQ3J7rYa6zPuomZexz92Ofewb73f3Y5+7nyT6vyTprHOyWL19e00VIQWpqKl555RWH6Zs2bYKfn1+9rTctLa3e6iZl7HP3Y597Bvvd/djn7ueJPi8uLq522RoHO09p2bIl1Go1cnJybKbn5OQgPDxccZnw8HCX5c0/c3Jy0Lp1a5syffv2tZSxPznDaDQiLy/Pph6l9Vivw97cuXORkpJieV5YWIh27dph+PDhdX6BYqAi7aelpWHYsGG8HIGbsM/dj33uGex392Ofu58n+9y8V686qhXsRowYgZdffhkDBgxwWe7KlSv48MMPERAQgJkzZ1a7EdWh0+kQExOD9PR0jBs3DkDFxUjT09ORnJysuMzAgQORnp6OWbNmWaalpaVh4MCBAIDIyEiEh4cjPT3dEuQKCwuxfft2PPbYY5Y68vPzsXv3bsTExAAANm/eDFmWkZCQYCnz17/+teJaTpW/7LS0NHTt2lVxNyxQcXaxXq93mK7Vauv1BVPf9ZMj9rn7sc89g/3ufuxz9/NEn9dkfdUKdhMnTsSECRMQHByMsWPHIjY2FhEREfDx8cHly5eRlZWFn376CevXr8fo0aPx1ltv1brxrqSkpGDatGmIjY1FfHw8Fi1ahKKiIkyfPh0AMHXqVLRp0wapqakAgKeeegpDhgzBwoULMXr0aKxatQq7du2yXIZEkiTMmjULr7/+OqKiohAZGYl58+YhIiLCEh67d++OESNG4KGHHsLSpUthMBiQnJyMSZMmISIiAgBwzz334JVXXsGMGTPw/PPPIzMzE++99x7efffdeukHIiIiIiXVCnYzZszAvffeizVr1mD16tVYtmwZCgoKAFSEo+joaCQlJWHnzp3o3r17vTX27rvvRm5uLubPn4/s7Gz07dsXGzZssJyocOrUqcpbN1UYNGgQVq5ciRdffBEvvPACoqKisHbtWvTs2dNS5rnnnkNRUREefvhh5Ofn48Ybb8SGDRvg4+NjKfP5558jOTkZQ4cOhUqlwoQJE/D+++9b5gcHB2PTpk2YOXMmYmJi0LJlS8yfP9/mWneeVF5qRM6fBSi7rEb28UJotXa/dps7TFju8lM12+Y2V9bzrW9fpFyX/fwa12XXGNtbQVWtQ6l+6/n2baqab32LKIW6rBdTqstmvlVdgM1N24mIiNxBErX89CkoKEBJSQlatGjBYeA6UJMb/NZU9okC/PfN3XVaJ9WCixAI+xBqn0OdhNCq+ZJDKLbUVfncdn491WWZL9nPtilvG/atF3RcpiZ1AQKXL+ejWbNmkMzznH2xMNdntX7FdimGf+t7tlr9cNFWZ18UlL6oOK3L2WvERVtt6nL2GlR4DTj9UqOw3bKQcfz4CXTs2BFqtcpu+53UZfclz6FdtXyNKPbRtcpW8zXgtC4nbbW73a7zuiTbvy+lttqXNZqM2LNnD2L694dao7Fpq91Ly6Gt9vPtf6/2bbX9vdks6FjW7r2jJl/07et3+j5UV3U59K9dWbv6jUYDvv8+HYmJQytyj8L2aXVqqLU1vpLcNdUkI9Q62FHdqs9gd/HMFWz4OBNFRUUVZ9xKEmD1a7c8FICAsDx2nC+qJgurInVQl+WHqHpiuy67uuzWb18XERGRuw29vzu6DWh97YI1VJOM0GjOiqXaa9k2EHfPj628If2QJjPCKhRDokIItAuODoHT+ruPfV32QdKqLkN51bc7jUarXJfVyuzrEkJAMRRXThQCdvNtK7CeL+CGuiofiKpqbbdLIcDblFUI8Nbz7fvOoS4BmIxG7N6zB/3794dGrbFpq3C2fQrbZbP5Cm0VVk9syzrWr1iXQ/8p/x4U67JuL2zLK67XSVsr6rLaNqW67FfhpK0m2VQxYhcZCcl8OIyT14xNXUp9Cyi3y1lZc3ml14z133W1fqfmwgp1Xet3Wq26nP3+7cpe67UqACFkXL6cj5CQEMvIk/3foqu6qvX6qE5d1m8HDWzAwOnrQ6kuhdeU0t/FtUjXLlLvGOzIaynuenDjn53GIEGtF/AN1DWZMO1pBoMBWWeNiOzTkn3uRgaDAXnrD2HAqI7sdzcxGAyVX9ZvYZ+7icFgwLp16zFq1EhoNVrFEKhyOF7E/RjsiIiIiKpBkioGDSSV5JEBg+qo+yP8iIiIiMgjahzstmzZ4nTexx9/fF2NISIiIqLaq3GwGzFiBJ599lmbG9JevHgRY8eOxZw5c+q0cURERERUfbUasfvqq68QFxeHrKwsrFu3Dj179kRhYSH27dtXD00kIiIiouqocbAbNGgQ9u3bh549e6J///644447MHv2bGzduhXt27evjzYSERERUTXU6uSJI0eOYNeuXWjbti00Gg0OHz6M4uLium4bEREREdVAjYPd//3f/2HgwIEYNmwYMjMzsWPHDuzduxe9e/dGRkZGfbSRiIiIiKqhxtexe++997B27VqMHDkSANCzZ0/s2LEDL7zwAm655RaUlZXVeSPp+hhzc5H/zTcIOXQI+fkFUGs1FVeHl1SQ1BU/oVJBUkmAebr1Y7Wq8rFUsZwny6hUFRceVqsryjSAi0ESERE1FDUOdvv370fLli1tpmm1Wrz11lsYM2ZMnTWM6o7h3DlcXPAWQgFc/PobTzenbkl2gc8u/FlPg0qCJNk9tisjqSRL0HVaRqm8WmVVd8V0GUDr7Bxkb9kKlVptV0ayhGvbx6qqQOu0jARJrVaeXo9lnAX/a5ax6TO1k+lWj5X6m4iIqqXGwc4+1FkbMmTIdTWG6oc6OBgBI0fi3NmziAgPhwRAyCZAFoAsQwjZ8hhChjA/lmUI80+rMg7lTa7LWB6bTBX3F7TUqfDYZKrZxomKemEy2dzOrwa39qtXgQCu7t/v6WY0ftUJf5UjvR3Ly3Fi4TuQNGrHIG//2D5sO3usUle7jOKXAxdlHMqr1Aph3668QxmF8s7K2I+Im79MVKeMw2h6xWOjSYbm8mUYsrMBnU6xjO2XFttQz9F3orrDW4o1AboOHRC+4E3sWb8e/UeNavD3FXQa/mQBCNkxIJqn2z82ycrTa1mmIuQ6KSMLQDbZlDEZDDiQmYno7t2hliTFMpbHNmHY5GS63WMn4dy2jGzVl9Up4yx4y4DpWmUqQ3Z1ytjcRb0azMtbv06cFNUAMF25UstXH9VWRwB//t+bta+gMug5C3+2I+XVKWMOty7KmA/rcBrY7UKy08Cuqn0Zh1CtVgj7jgHeBIHA33/HFQAardZ2BN08am45tKU6h9pcRxmb4O9stJ6j7+7CYEcNjuXNVq1uYHfgqxmDwYD89esR0gjCtLsJISrCnYtAKcwB0Bw+q1HGWG7ATz/+gMGDBkGjUlsFb+ufwiGo24RbV2UUQr5yUDdVjXxXu4xjeevw7ljG9ai5W0ffZRkmo7HiC8x1jr4Lq+Uaysh7Q9UaQM6q1Z5uRs2orzdsWx0i42p0vCaH2jgZQbc51EalgiyA0DOnkbtnL1QajWN5tQqBI0bAt0cPj3Yxgx0RuZ1UcSftijdY1N0ttA0GA8r+OAaf6GiGaTcyGAxYv349Rtl9iWlwo+8K4b06o+/WI+hVgbk6o+/VHVmv+ei7MJmQeyEXLZs3r/j7qfbIeh2OvpvbVBMN+NCZ6ggBUPDrdqfzdZ06MdgREZF38pbR94bIYDBg3/r16OPhPQL1Nfpu8/ga4bxWo++uwrmTkXWT0Ygjhw8hqnPnysNrHMvoO3X22O/CjMGOiIiIaqW+Rt8bIoPBgLz169GigR9eo/J0A4iIiIiobjDYEREREXkJBjsiIiIiL9Fogl1eXh6mTJmCoKAghISEYMaMGbh69arLZUpLSzFz5ky0aNECAQEBmDBhAnJycmzKnDp1CqNHj4afnx9CQ0Px7LPPwmg02pTZunUr+vfvD71ej86dO+Ozzz6zmf/DDz9g7NixiIiIgCRJWLt2bV1sMhEREVGNNJpgN2XKFBw4cABpaWn49ttv8cMPP+Dhhx92uczs2bPxzTffYM2aNdi2bRvOnTuH8ePHW+abTCaMHj0a5eXl+OWXX7BixQp89tlnmD9/vqXMiRMnMHr0aNx6663Yt28fZs2ahQcffBAbN260lCkqKkKfPn2wZMmSut9wIiIiompqFGfFHjx4EBs2bMDOnTsRGxsLAPjggw8watQovP3224iIiHBYpqCgAP/4xz+wcuVK3HbbbQCA5cuXo3v37vj1118xYMAAbNq0CVlZWfj+++8RFhaGvn374rXXXsPzzz+Pl19+GTqdDkuXLkVkZCQWLlwIAOjevTt++uknvPvuu0hKSgIAjBw5EiNHjnRTb9Tc6cLT+GDvBzhfdB47f90JrUYLtaSGWlJDJamgUWmgklRQS2rLY6Vp5mXUKrXrx1bTzHXZr0sjaaBSOa9fI1VMU0m8WjkREVF1NYpgl5GRgZCQEEuoA4DExESoVCps374dd9xxh8Myu3fvhsFgQGJiomVat27dcMMNNyAjIwMDBgxARkYGevXqhbCwMEuZpKQkPPbYYzhw4AD69euHjIwMmzrMZWbNmlX3G1pP8sry8N3J7wAA+47v82xjaqE2wdHVMvaPzUFTqV6VpLIJmtZlrrUuIQscKD8A39O+0Gv1Nuuqi/rVkpqhl4iIbDSKYJednY3Q0FCbaRqNBs2bN0d2drbTZXQ6HUJCQmymh4WFWZbJzs62CXXm+eZ5rsoUFhaipKQEvr6+tdqmsrIylJWVWZ4XFhYCqLhOjsFgqFWdzrTSt8KsPrNw8PBBdIrqBEiAUTZCFjJMwlTxTzZVPRaminmyCUZhtDy2nmeUjVXlFJY3yVXzlNZlmVdZvyycX73cvBxqeIHzhuI/P/6n3uo2j2pqpKpw6yzEOsyzmu9qdNY6+NrMcxKyLWVcBXCrEVuldbkKvA7lrNYlm2QYhRFl5WXX7jyqM+b3rLp+7yLn2Ofu58k+r8k6PRrs5syZgzffdH3T6IMHD7qpNe6VmpqKV155xWH6pk2b4OfnV+fra4mWuMnnJuB0nVetrIZHbwohIFv9JyAqAp/1f8JqnsI0E0wO9cjCrrzVMk7Xo7Quu/XIkOt0Xc62yTzNGXMoNsLotExT9PKXLwMAVHb/SZJkO0WymgdJeZpkX0vlIQKQFOtRnG+1bjXUivUqrkuya5vCuhy2qXKaZT1OtrM+RnvT0tLqvE5yjX3ufp7o8+Li4mqX9Wiwe/rpp3H//fe7LNOxY0eEh4fjwoULNtONRiPy8vIQHh6uuFx4eDjKy8uRn59vM2qXk5NjWSY8PBw7duywWc581qx1GfszaXNychAUFFTr0ToAmDt3LlJSUizPCwsL0a5dOwwfPhxBQUG1rtcZg8GAtLQ0DBs2rEFfMdub1FWfCyFsRzyvMaKqNLqqNDori4rRLfMIqrO67OdZHivVZ70uF+2o7rrst9m+fqNwHWgdgrH9TSkb000q65j1SO01R2ftRnrtR1FVUCHvUh7CQsOgUWlsRmcdRm6vVb/CyK3NyK7dSLOzUWLrutSS2ukosdI2qaSGf14h39Pdz5N9bt6rVx0eDXatWrVCq1atrllu4MCByM/Px+7duxETEwMA2Lx5M2RZRkJCguIyMTEx0Gq1SE9Px4QJEwAAhw8fxqlTpzBw4EBLvX/7299w4cIFy67etLQ0BAUFITo62lJm/fr1NnWnpaVZ6qgtvV4PvV7vMF2r1dbrC6a+6ydH7PP6ZR30SstLsWHjBtyWeBtUGpVNWHQVUi2B0VlYtj/cQFae5mxdNqFWdh3GXdYl29ahGLjtArUz5jIG1N1upSPnjtRZXZ4kQXJ62IJN+FQ68awahxLU5FhhpRPa1JIaEMDBsoMo+7MMOq3O5Qlt1arfPvi6OKSjqR/b64n39Jqsr1EcY9e9e3eMGDECDz30EJYuXQqDwYDk5GRMmjTJckbs2bNnMXToUPzzn/9EfHw8goODMWPGDKSkpKB58+YICgrCE088gYEDB2LAgAEAgOHDhyM6Ohr33XcfFixYgOzsbLz44ouYOXOmJXQ9+uijWLx4MZ577jk88MAD2Lx5M7744gusW7fO0r6rV6/i2LFjlucnTpzAvn370Lx5c9xwww1u7Cmipsd8nKFWpYVaqOGr8kUzn2YM06gY7XU2smo/CuosRFqPjjoLpOWGcuz9bS969OoBSFAcZb1WSHUZoJ0EamfbUt0w7rTfIGCUjY3iEIevd3zt9nVWJ6Re86oKLk5isz/JTOmENmejydcK0a6O5b3WCW2ySUahXIi80jzoTfoGe0Jbowh2APD5558jOTkZQ4cOhUqlwoQJE/D+++9b5hsMBhw+fNhmP/S7775rKVtWVoakpCR8+OGHlvlqtRrffvstHnvsMQwcOBD+/v6YNm0aXn31VUuZyMhIrFu3DrNnz8Z7772Htm3b4u9//7vlUicAsGvXLtx6662W5+ZdrNOmTXO4mDERkbtIkgSNpIEGGkBdf+sxGAxQHVJhVOeGfXN0a+ZDHKxDp+Juf6WRXVeB1FkwdXECmiX8Vqd+c9A2GXE2+yxatmoJIYnqjUjXYMRYuDhOobGf0Ha9FvxvgdN5rw1+DeM6j3NfYxQ0mmDXvHlzrFy50un8Dh06QAjbF6KPjw+WLFni8sLB7du3d9jVau+WW27B3r17Xc63XzcRETVckiRVjLJADS0aRxi1ZjAYsH79eoy6pX7CtPUhDtajrNU5Ltdl2HVxCIOr+pXW5eyY3modIiFbHe8rX3vE2ByQjbLRZehVS/X4DaqaGk2wIyIiIvewPsSBKpjD9MiRI6HSqBRHQ/21/p5uJoMdERERUXVJkgSNqiI+6dQ6D7fGUcM/p5uIiIiIqoXBjoiIiMhLcFdsU5BzAJovpuLWolJozr0FaHSASguotYBKU/lTC6g1TqZrbR87Xaa2ddg9V6mBBnDKOBERUWPDYNcUlBdBunQMQQBQesbTrakexbCocxEcXQRK83O1rvahVKWpXP81Qql1HTxRmoiI3IzBrilo1Q3G+77G9oyfkRDbHxpJACYDIBsAk7HypwGQjVbTzc/LFeZZL+Oqjsrlr7WMUgKSK8s1YloAf4EE/K67RjisbsCsXL62wbZGdSjUyVFUIqIGj8GuKfAJgrhhEC5m5kN0Ggo0tAuIyiaFQGn1vMaB0lUdrkKqkzpM5dVbRna8Sr0EAZjKKv41dqqGMnLqog4hwb/0PJD/J6DzdVKH568zRURUXxjsyPNU6soPWx9Pt+T6CGET9AxlJUhP24iht9wErSRchMMGMnJqvYzSPUZlY8U/Y4n7+7aatAASAeCgq1JSHY6c1iKU1lkdWo6iEpEDBjuiuiJJVSeJAIDaD2XaECC4XcMbJb0WWbYLgHU9clqLOqoxcipkA4xlJdCoAMlczoE3jqLW9chpNY8jraxDEhJCC36DdNwP0PnU4rhVjqIS1RUGOyJypFIBKj2g0Xu6JTViNN9maVTlbZaEqNjVL1cGw1qHUqNVHbXYnV/bkVPr6Uo3rW8go6gaAAMB4Hhta5DcNHKqUK4uRk45ikoNCIMdEXkvSar88NYAWl9Pt+b6yHLVbvlahdLrGTm1mq4wciqbylGYdxHBgf6QZOM16i5X2DhRGZrLAaVB1sZEUtcsYNZy5FQFFTrlHINqx+mKUdLaHhJgOW7Wbh4vO9VoMdgRETUGKhWg0lVch7KBMRkM2GY9UuqKzShqTUOp9cjpdYy+Xlc4tjo0QGkUVZgAowlAab30tZkaQE8AOLeq/lZyXSOn1dydX2d1OGurtuJvpwlhsCMiIvfxplFUIVyEwdqOnFavDtlQhrOnT6JN61CohKl6o60Oo69W6/HSy04BACRVNUZOtdcMsmpJjb5ns6Fanw5o9cp1dBkBhPXw6OYy2BEREdWGJFWOoLp/FNVkMGDP+vUIHzUKqro4OcvlZaeqO3Jaw9HXuho5vcZlpyBk1MUJUyoA7QEg7wfnhQIjGOyIiIjIw7z0slPX3mVf7jo4Wj03GUpxOOsAukZ1hBqych0tOnm6BxjsmgKTLFBUZoRRBoTgfa6IiMhL2V92qg7JBgOO5q1H1E2joG7Al7BisGsCMs8W4PYlPwPQ4OntadCpVdBpVNCqJeg05scqy3SduvJ55XS9VVnzdHM5nVoFrabqp16tglYjQadWV9VvtYzWah3Wz7VqCTq1ChLPwiIiIqo1BrsmwGCyvYtAuUlGuUnhzgINgDngaTW2QdMhBGrU0FmHTatl9BrbYFpRh2RXh23d1mHWPvia61epGDqJiKhhY7BrAvrf0Ay/zxuKdRs24pbbhkJIapQbZRhMMsoqf1Y8Fyg3mVBulFFuEpYyymVlm3LlJhkG808nZQ0mgTKjjHKjqXJdMkyy7a5hg0nAYDIB5QqXEfAwjcrFCKdGcgiHGhWQm6PCttJM+Og0toFRrbYs42yU1D7MKgdWhk4iIqrCYNcEqFQSfHVq+GmAlgH6a19nyo1MsqgIfg4h0BwOK4Ojs3BpCZgyDMaKYGpeRjmI2i5bsYzCPKMMo13oNMoCxnITimsUOlXYc+lc3XaaArVKshnZVNp9rrUezXQYFXVRVmHk03pXu/OyFT/VDJ1ERG7DYEcepVZJUKvU8NE2vHtFyrKwjECWW4dMJ8HSPpiWlBnwW+YBdIrqBhmSTTi1H+GsGv2sCqbm6WU2QdS8jG3oNMkCJbIJJYaGN9KpkuC42/sau791GrXtKKXC7nnzLnnzMnqNChIEDuVLaHEiD34+OsXd+Hqr0VKNumlduJSIvF+jCXZ5eXl44okn8M0330ClUmHChAl47733EBAQ4HSZ0tJSPP3001i1ahXKysqQlJSEDz/8EGFhYZYyp06dwmOPPYYtW7YgICAA06ZNQ2pqKjSaqq7ZunUrUlJScODAAbRr1w4vvvgi7r//fsv81NRU/O9//8OhQ4fg6+uLQYMG4c0330TXrl3rpS/IPVQqCT7XEToNBgOaXcrEqJsj63yUVAhhCXhKI5LKo5SVI5pGgTLrkGh0FVCFy1FS+7Lm6dZkAZQaZJQa3HVcpxofHdxVrZIqCS5O6FEYzaxJWevd6mrnI5r2JxmZ52tUEk8mIqIaazTBbsqUKTh//jzS0tJgMBgwffp0PPzww1i5cqXTZWbPno1169ZhzZo1CA4ORnJyMsaPH4+ff/4ZAGAymTB69GiEh4fjl19+wfnz5zF16lRotVq88cYbAIATJ05g9OjRePTRR/H5558jPT0dDz74IFq3bo2kpCQAwLZt2zBz5kzExcXBaDTihRdewPDhw5GVlQV/f//67xxqciRJgl6jhl4DQO/p1tgSQlQeK6mwC93JrnbFXeXWo5bWu9rNu8+Vdt8bTLh0uQB6vwAY5Kpd7YbKOsqNjqGzrHJUtKGRKkOn3ubM86pjORV3f9ucrV51LKdeKVg6OTHJoV6FMKtVM3QSNVSSaAQXNjt48CCio6Oxc+dOxMbGAgA2bNiAUaNG4cyZM4iIiHBYpqCgAK1atcLKlStx5513AgAOHTqE7t27IyMjAwMGDMB3332HMWPG4Ny5c5ZRvKVLl+L5559Hbm4udDodnn/+eaxbtw6ZmZmWuidNmoT8/Hxs2LBBsb25ubkIDQ3Ftm3bcPPNN1drGwsLCxEcHIyCggIEBQXVqH+qw2AwYH117+VIdYJ97n7X6nMhBIyycDLCqbCrXfFYTuvnjicZOTuWs8xJaLWuu+G/G1exPRlIBUN5KUIC/SvOWLcLhU4vm+Rk5NPVZZOcHQfa1C6bxPcX9/Nkn9ckIzSKEbuMjAyEhIRYQh0AJCYmQqVSYfv27bjjjjscltm9ezcMBgMSExMt07p164YbbrjBEuwyMjLQq1cvm12zSUlJeOyxx3DgwAH069cPGRkZNnWYy8yaNctpewsKCgAAzZs3r+0mE1E9kCQJWrUErVoFP/ffBeqajCa7gOkqMFZj5FP5bHXbYzkddt8r7J43mITDGeyOl02SkFdW7N4Oc8L+skmOI5xVx3I6u2ySw2WQqnHZpKowWxFKedkk8oRGEeyys7MRGhpqM02j0aB58+bIzs52uoxOp0NISIjN9LCwMMsy2dnZNqHOPN88z1WZwsJClJSUwNfX9ibWsixj1qxZGDx4MHr27Ol0m8rKylBWVnXfusLCQgAV3wgMhrq/6bK5zvqom5Sxz93PG/pcIwEaLeCnVaHi7pQNg8lupNM6GBaXluPnjF/RLyYOsqRyPPZS6XhM+xOHHE4osj95qWKaJXxa1WV/BntjuGySJXwqHGtpf+F2pWM51RJw6rSEk1uOwVevdVqfJbAqjZYydNaIJ99farJOjwa7OXPm4M0333RZ5uDBg25qTd2YOXMmMjMz8dNPP7ksl5qaildeecVh+qZNm+Dn51dfzUNaWlq91U3K2Ofuxz53vw6BwOUjO22mqVBxCKjLw0DN+fU69mzJAjAJwCgDRgGYKn86PBcSjHJVWetlbMtKVsvAyTKSQ/329ZkEYBK2Ycl82aS6ocaGM8frqC5ABQGNClBLsPmpsfpZMU04zFNeRlgt46ysUKjfcZmGlDk98f5SXFz90XCPBrunn37a5uxSJR07dkR4eDguXLhgM91oNCIvLw/h4eGKy4WHh6O8vBz5+fk2o3Y5OTmWZcLDw7Fjxw6b5XJycizzzD/N06zLBAUFOYzWJScn49tvv8UPP/yAtm3butyuuXPnIiUlxfK8sLAQ7dq1w/Dhw+vtGLu0tDQMGzaMx2O4Cfvc/djnnsF+d06WBQyy1YXc7c4iVxqBdDy2076sQGm5ESf+PIXQ1hEwyZLjcZ1Kx3+aHEddbdoKCeXmvesus6f7U5b5skn2I5CuRinNu8UdTwZynOZ43U/Jqo6KnxAmbM/4GbfdcjP8ffSWMmo3nMFu3qtXHR4Ndq1atUKrVq2uWW7gwIHIz8/H7t27ERMTAwDYvHkzZFlGQkKC4jIxMTHQarVIT0/HhAkTAACHDx/GqVOnMHDgQEu9f/vb33DhwgXLrt60tDQEBQUhOjraUmb9+vU2daelpVnqACoOyH7iiSfw1VdfYevWrYiMjLzmNun1euj1jt9jtVptvb4x1nf95Ih97n7sc89gvyurjxPXKw7kP4lRo3rXus+vddkkxUsmGWXXl01ychkklxeXV7hkktIZ7O69bJIzGryy5xebKZIESwh8/Y6euL1vmzpfa01+x43iGLvu3btjxIgReOihh7B06VIYDAYkJydj0qRJljNiz549i6FDh+Kf//wn4uPjERwcjBkzZiAlJQXNmzdHUFAQnnjiCQwcOBADBgwAAAwfPhzR0dG47777sGDBAmRnZ+PFF1/EzJkzLaHr0UcfxeLFi/Hcc8/hgQcewObNm/HFF19g3bp1lvbNnDkTK1euxP/7f/8PgYGBluPzgoODHUb1iIiIGoLGfNkk8+WPyo22x2e6umyS/Vnszi6b5OyC8WVGGaXlBhjtdq8Lq8smNYQz2xtFsAOAzz//HMnJyRg6dKjlAsXvv/++Zb7BYMDhw4dt9kO/++67lrLWFyg2U6vV+Pbbb/HYY49h4MCB8Pf3x7Rp0/Dqq69aykRGRmLdunWYPXs23nvvPbRt2xZ///vfLdewA4CPPvoIAHDLLbfYtHn58uXX3NVMREREtiRJqji7WKOCfwMJnebLnYwcORKSWqM4otkiwPOn2zeaYNe8eXOXFyPu0KED7C/J5+PjgyVLlmDJkiVOl2vfvr3DrlZ7t9xyC/bu3et0fiO4FCARERHVgYrLJqka7GWTGs659ERERER0XRjsiIiIiLwEgx0RERGRl2g0x9h5O5Op4qJBZ86cqZfr2BmNRly8eBFnz56FRsNfuzuwz92Pfe4Z7Hf3Y5+7nyf73HwdO3NWcIWvhgbi2LFjAIAePXp4uCVERETUEB07dgxxcXEuy0iCp3Q2CJcvX0bz5s1x+vTpervzxKZNmzB8+HBeQNRN2Ofuxz73DPa7+7HP3c+TfW6+O1VeXh6aNWvmsixH7BoItVoNAAgKCqq3YOfn54egoCC+CbgJ+9z92OeewX53P/a5+zWEPjdnBVd48gQRERGRl2CwIyIiIvISDHZERERE1+nYxbOQZdnTzWCwIyIiIqqNq+VleOPbf+LWDV/gpt9zsOzLv3u6STx5goiIiKi6hBD4eveP+NfZw9gV0B0l/r0t8/aJqx5sWQUGOyIiIqJrOH7xPNaXnsbLP6TjvLo1EBgLAGghcpGQn4V+B7LRs1/va9RS/xjsiIiIiBSUGMvx4fdf4jsh4YC+K0TojQAAnShDv7L9iDtxFu3zS3HHUy8iYLy/h1tbgcGOiIiIyMqmzO349Njv2BnUHUX6aMv0TqZjSMg5jm5Z2bj53mnoNvJBD7ZSGYMdERERNXmn8y9i4eb/4qfANjijaQsEV9y6K0TkIb7wAGKycqCVBGbMng/9FL2HW+scgx0RERE1SWVGI/6+9St8U16G/T7dYGqWAADQCAP6lGci7s8ziMy+ittTXoD/aD+sX78eKnXDvqAIgx0RERE1KT8d/Q1LM7djR3BXFKqjAN+K6R1MJxCfeww9MnMwaMIE9Box3bKMwWDwUGtrhsGOiIiIvF7OlctY+P0a/OAfhpPa9kBIPAAgSOQj7mom+h/KRlSrVhg99WmoJzfsUTlXGOyIiIjIKxllGZ/98C2+KsrH777dYKgMc2phRC/DAcSdPo3Opy5j1Ky5aPWXlh5ubd1gsCMiIiKvsvPEQSzZ+wO2B0fhsuoGwO8GAEBb+TQSLh5Gz8wLSBg9Ev2Tpnm4pXWPwY6IiIgavcslRXhn4yps9muGP7QdgcoTIfzFVcQV/Y6YI9no6BeA2x96Gpq71R5ubf1hsCMiIqJGySTLWPXrJnxxKRt7/buhPDgGACAJE3oYDyH+zJ/o/EcuRj75DFqPbePh1roHgx0RERE1Kplnj2PRr5vwa0gnXFSFAwHhAIBw+RwS8g6hT2YO+t56MwY9MMXDLXU/BjsiIiJq8K6UleDdjauRrvfHYV0U0HwAAMBHFCO2ZD9ij51HpFBh3ONzoZ+o9XBrPYfBjoiIiBokIQT+t3srVp47gd0B3VEa2BcAIAkZ3UyHEXfuJLoczsXwx5/ADaMjPdvYBoLBjoiIiBqUIzmn8e5P6/BLcAfkqMOBwGYAgFYiBwmXD6JPZg56xvXDLVPnQJIkD7e2YWGwIyIiIo8rNpbjg41fYKNKi4P6KIjKXa06UYr+pfsRd/wcOhSbMP7JF+A7wcfDrW24GOyIiIjII4QQWP/7L1hx8iB2B3ZDkV9Py7wo4xHE5xxHtwO5uPXBGeg8KtqDLW08GOyIiIjIrf68nIuFm/+Hn4Pb4qy6DRAUCwBoLi4hvuAA+mVlo3v3KAyb8jx3tdYQgx0RERHVu1KjAR+n/xfrTCYc8OkKU/OKCwhrRTn6lu1H3Mmz6HixFLenzEXgHYEebm3jxWBHRERE9WZL1m58cmQ3dgZ1wxVdN8v0SNNxxF84hujMC7jpvimIHjnDg630Hgx2REREVKeyr+ThrbQ1+DGwNU5pbgCC4wEAweIy4q5kIuZgNrq0a4uRk56B6h6Vh1vrXRjsiIiI6LoZTDL+se0rfF1SjN99u8FYea9WtTCgT/kBxJ46g47nC3H77LlodnszD7fWezXZmLxkyRJ06NABPj4+SEhIwI4dO5yWPXDgACZMmIAOHTpAkiQsWrTouuskIiLyBhl/ZGLqVx+j59ZteFnqhD1+vWCUtGgn/4k7c77HvM2rkdqqE159+EXc/9ICNAtiqKtPTXLEbvXq1UhJScHSpUuRkJCARYsWISkpCYcPH0ZoaKhD+eLiYnTs2BETJ07E7Nmz66ROIiKixupicSHe3rgaP/i3xHFtJBBSMToXIAoRV7QfMYey0blZc4ydngL1pCY7huQRTTLYvfPOO3jooYcwffp0AMDSpUuxbt06fPrpp5gzZ45D+bi4OMTFxQGA4vza1ElERNSYmGQZ//75O3xZcBH7/LrDEFLxuagSJvQ0ZCHuzCl0+vMyxj75HFqN5YCGpzS5YFdeXo7du3dj7ty5lmkqlQqJiYnIyMhwW51lZWUoKyuzPC8sLAQAGAwGGAyGWrXDFXOd9VE3KWOfux/73DPY7+7nzj7/7cxRfLT3B2QERyFP1QbwbwMAiJDPIOHSYfTMzEFs4jD0nzrJoX3exJOv85qss8kFu4sXL8JkMiEsLMxmelhYGA4dOuS2OlNTU/HKK684TN+0aRP8/Pxq1Y7qSEtLq7e6SRn73P3Y557Bfne/+urzEtmIXSVnsb1FBI7qOgPNKm7v5SeKEFO8H3FHz8H/8hWE97kJmpjOyL5cjPXr19dLWxoaT7zOi4uLq122yQW7hmLu3LlISUmxPC8sLES7du0wfPhwBAUF1fn6DAYD0tLSMGzYMGi12jqvnxyxz92Pfe4Z7Hf3q48+F0Lgfzs3Y3XeOewJjEZZSCcAgCRkdDceQvy5P9H56EUMezQZEUlt62SdjYknX+fmvXrV0eSCXcuWLaFWq5GTk2MzPScnB+Hh4W6rU6/XQ6/XO0zXarX1+oKp7/rJEfvc/djnnsF+d7+66POs8yfwXsZG/BLcEbmqcCCg4nMrVM5GwuWD6JN5AX0GD8BN98+9Rk1Ngyde5zVZX5MLdjqdDjExMUhPT8e4ceMAALIsIz09HcnJyQ2mTiIiovpypawU729aje+1vjik6wxRuavVR5Sgf8l+xP5xDh2NwLiZc+Fzp+MgBDVcTS7YAUBKSgqmTZuG2NhYxMfHY9GiRSgqKrKc0Tp16lS0adMGqampACpOjsjKyrI8Pnv2LPbt24eAgAB07ty5WnUSERF5khAC3+z5Af86cxS7ArujJKCPZV5X42HEnz+BbodzkfjI42g/upMHW0rXo0kGu7vvvhu5ubmYP38+srOz0bdvX2zYsMFy8sOpU6egUlVdd+fcuXPo16+f5fnbb7+Nt99+G0OGDMHWrVurVScREZEnHL94Fgu3fYNfgtvjvLo1EBQLAGghchGfn4X+Wdno0a83br3veUiS5OHW0vVqksEOAJKTk53uJjWHNbMOHTpACHFddRIREblLibEcH25agw2SCgf0XSA3r9jVqhNl6Fe2H7EnziLyigETnnoRvuN9PNxaqktNNtgRERF5m02Zv+LTY/uxK6gbrvr2sEzvZDqG+Jzj6J6Vg9vun47OI3t6sJVUnxjsiIiIGrHT+RfxzuYv8WNgW5zRtAWCK+4IESLyEF94AP0PZqN750gMv+dZ7mptAhjsiIiIGplykxG7r57GR2mrsd+nG0yVZ7VqhAF9yjMR9+cZdMwpxriUFxA0LtDDrSV3YrAjIiJqJH48sg/LDmzH9uBuKIy40TK9vekkEnKPokdmDm6cdBd6jOAVGZoqBjsiIqIGLOfKZSz8/gv84B+Ok9r2QEgCACBQFCD+6n70P3Qe3cIjMHLK01BNVl2jNvJ2DHZEREQNjFGW8dm2r/FVcSF+9+0GQ2WYUwsjehqyEH/6FFofOY8Jz81H2F94WS2qwmBHRETUQOw6kYXFe3/A9uAuuKzqAPhVTG8rn0bCxcPomXkBA24fg563Tcb69evRPLi5R9tLDQ+DHRERkQddLinC2xtXYqtfC/yh7QhUngjhL64itmg/Yo+eR8eAIIybkQL13RW7Wg0GgyebTA0Ygx0REZGbmWQZq37ZiC8uZ2Ovf3eUV16iRBIm9DAeQvyZP9HpxCWMefIZhI1t7eHWUmPCYEdEROQmmWePY9Gvm/BrSCdcVLUGAipCW7h8Hgl5B9EnMwdxQ29D3ANTPNxSaqwY7IiIiOrRlbISvLtxFdJ1ATisjwIqb+/lI4oRW7IfscfOo6OkxbjHnoNuotbDraXGjsGOiIiojgkh8L8dm7Ey50/sDuiO0sB+lnndjQcRf+4koo5cxIiZT6Ht6Bs82FLyNgx2REREdeRIzim8+9N6/BLcATnqcCCwBQCglbiA+MtZ6HsgB30GxuOmqXN4ey+qFwx2RERE16HYWI7FG1dho0qHLH0XiMpdrTpRiv6l+xF3/CwiSwXGP/ECfCboPdxa8nYMdkRERDUkhMD6fb9gxamD2B3YDUV+vS3zOhuPIiHnOLoeuoDhDz2CDqO6eLCl1NQw2BEREVXTyUs5eGfrV/g5uB3OqtsAQbEAgObiEuILDqDfgWz06NUTQ6c8x12t5BEMdkRERC6UGY346PsvsF4WOODTFabKXa1aUY4+ZZmIO3kWnfJKccfsF+B/h7+HW0tNHYMdERGRgs0HduIfR/ZiR3A3XNFHW6ZHmo4j/sIxRB/Iwa1Tp6HLyAc82EoiWwx2RERElbKv5OGtTV/gx6AInNLcAITEAwCCxWXEXclE/4M5iG7fHkmTn+WuVmqQGnywy8/Px1dffYUff/wRf/75J4qLi9GqVSv069cPSUlJGDRokKebSEREjZjBJOPvW/6Hb8pK8LtvNxgrd7WqhQG9y7MQd+o0OmVfxbjZcxF8e7CHW0vkWoMNdufOncP8+fPx+eefIyIiAvHx8ejbty98fX2Rl5eHLVu24O2330b79u3x0ksv4e677/Z0k4mIqBH55Y9MfPzbz/g1uAsK1J0Bv4rp7eQ/kZB7FD0PZOPGOyei54hpnm0oUQ002GDXr18/TJs2Dbt370Z0dLRimZKSEqxduxaLFi3C6dOn8cwzz7i5lURE1JjkXi3Awk2r8UNAKxzXRgLNEgAAAaIQcVczEXP4PKJahmLs1BSoJqk83FqimmuwwS4rKwstWrRwWcbX1xeTJ0/G5MmTcenSJTe1jIiIGhOTLOPfP67Df6/kYZ9fN5Q3qzhuTiVM6GnIQtyZU4g6dRljZs1By7+09HBria5Pgw121wp111ueiIi8276Th/HB7i3ICIlCnqod4N8OANBaPouES4fQO/MCBoweif5J93m4pUR1p8EGO3vnzp3DTz/9hAsXLkCWZZt5Tz75pIdaRUREDUl+aRHe3bAKW3yDcUTXGag8EcJPFCGmeD/ijpxDJ/8g3D5jNjR3qT3cWqK61yiC3WeffYZHHnkEOp0OLVq0sDnFXJIkBjsioiZMCIEvMtKw6tIZ7PXvjtLgGACAJGR0Nx5C3Lk/0eWPSxidnILwMREebi1R/WoUwW7evHmYP38+5s6dC5WKB7MSERFw8PwJvPvLBmSEdEKuKhQICAUAhMrZSLh8EH0yc9B/yE0YdP9cD7eUyH0aRbArLi7GpEmTGOqIiJq4K2Wl+GDTKqRpfXFIFwXRfCAAwEeUoH/JfsT+cQ6dZTXGzZwD3Z1aD7eWyP0aRbCbMWMG1qxZgzlz5ni6KURE5GZCCHyz5wf868xR7ArsjpKAvpZ5XYyHEX/+JLodycWIx55A29HtPddQogagUQS71NRUjBkzBhs2bECvXr2g1dp+C3vnnXc81DIiIqovxy+exTvbvsbPwR1wXt0aCIoFALQQFxGffwD9s86jd0wcbr7vOd7ei6hSowl2GzduRNeuXQHA4eQJIiLyDqXGcize9AU2Smoc0HeBXLmrVSvK0K8sE7HHzyCq2IhxT7wI3/F6D7eWqOFpFMFu4cKF+PTTT3H//fd7uilERFQPNu3PwPI/MrEzqBuu+va0TO9kOob4nD/QPesChj7wIDqN7O7BVhI1fI0i2On1egwePNjTzSAiojp0Jv8i3v7+S/wU3BZnNG2B4DgAQIi4jPjCTPQ7mI2eXbog8R7uaiWqrkYR7J566il88MEHeP/99z3dFCIiug7lJiOWpf8X3xoN2O/TDaYWFRcQ1ggD+pRnIu7PM+h4oRTjU15AwDh/D7eWqPFpFMFux44d2Lx5M7799lv06NHD4eSJ//3vfx5qGRERVcePh/bh44PbsSO4Gwq1XYHKt/H2ppOIzz2KnlkXcPOUKeg+YrpnG0rUyDWKYBcSEoLx48d7uhlERFQDOVcu4+20L/BjQDhOatsDIQkAgEBRgPirmYg5dA7d2tyAEZOehkrN65QS1YVGEeyWL1/u6SYQEVE1GGUZn21bi7VFV/CbX3cYmlWEObUwoqchC/GnTqHz+ULcPvuvCPlLsIdbS+R9GkWwIyKihu18eQEe+uYf2B7cBZdVHYHKw+PayKeRcPEweh3IwY13jEevpKmebSiRl2uwwW7EiBF4+eWXMWDAAJflrly5gg8//BABAQGYOXOmm1pHRESXS4qwcMNKbPVvjmMte1um+4uriC3aj9ij59E5uBn+cn8K1HdzVyuROzTYYDdx4kRMmDABwcHBGDt2LGJjYxEREQEfHx9cvnwZWVlZ+Omnn7B+/XqMHj0ab731lqebTETk9UyyjP/8shFrLmdjr393lIdUXKJEEiZEGw8h/uwpdDl5CWOefB6txrbycGuJmp4GG+xmzJiBe++9F2vWrMHq1auxbNkyFBQUAKi420R0dDSSkpKwc+dOdO/OC1YSEdWnzNN/YNGOTfg1pDMuqloDAa0BAOHyeSTkHUSv/ecQNzwJCdOneLilRE1bgw12QMWFie+9917ce++9AICCggKUlJSgRYsWDpc8ISKiunWlrATvfvcfpPsE4rA+Cqi8vZePKEZsyX7EHjuPzhofjH5gFjbpNqJ/wi2ebTARNexgZy84OBjBwTyLioiovggh8L8dm7Ey50/sDuiO0uD+lnndjIcQf+4Euhy9iNHJs9F6dFsAgMFg8FRzichOowp2RERUP47knMK7P36LjJCOyFaHA4EtAACtxAXEX85C3wM56DtoIG6aNtfDLSUiVxjsiIiaqGJjOd7fsAppah2y9F0gWgwCAOhEKfqXZiL2+Fl0KgfGJ78A/QQe/kLUGDTZ88+XLFmCDh06wMfHBwkJCdixY4fL8mvWrEG3bt3g4+ODXr16Yf369Tbz77//fkiSZPNvxIgR9bkJREQ1JoTAur0/4+7/9wl6/bADi/x744BPNwhJhSjjUUw5uxHzNn+J93sNxYvJL2FyykvQ6xjqiBqLJjlit3r1aqSkpGDp0qVISEjAokWLkJSUhMOHDyM0NNSh/C+//ILJkycjNTUVY8aMwcqVKzFu3Djs2bMHPXv2tJQbMWKEzV0y9Hq9W7aHiOha/ryYjbe3fYVfgm/AWXUbIKjiMiXNxSXEFRxA/6xs9O7bG7dMeQ6SJHm4tURUW40i2E2bNg0zZszAzTffXCf1vfPOO3jooYcwfXrFzaaXLl2KdevW4dNPP8WcOXMcyr/33nsYMWIEnn32WQDAa6+9hrS0NCxevBhLly61lNPr9QgPD6+TNhIRXa8yoxEfpn2BDUIg06crTJVntWpFOfqUZSLu5BlEFZTjjlkvwvcOHw+3lojqQqMIdgUFBUhMTET79u0xffp0TJs2DW3atKlVXeXl5di9ezfmzq06AFilUiExMREZGRmKy2RkZCAlJcVmWlJSEtauXWszbevWrQgNDUWzZs1w22234fXXX0eLFi0U6ywrK0NZWZnleWFhIYCKs8vq4wwzc508e8192Ofuxz6vsO3Qbiw/9jt2BHfDFZ9oy/RI03HEXziG6KwLuOXeqeiYeJ9l3vX0Gfvd/djn7ufJPq/JOiUhhKjHttSZ3Nxc/Otf/8KKFSuQlZWFxMREzJgxA7fffnuNrml37tw5tGnTBr/88gsGDhxomf7cc89h27Zt2L59u8MyOp0OK1aswOTJky3TPvzwQ7zyyivIyckBAKxatQp+fn6IjIzEH3/8gRdeeAEBAQHIyMiAWq12qPPll1/GK6+84jB95cqV8PPzq/b2EBEBQKGpDNtLz2NHq0ic0txgmR4s8hF3JRP9D2bDT5IQ3jUW3NNK1LgUFxfjnnvuQUFBAYKCglyWbRQjdgDQqlUrpKSkICUlBXv27MHy5ctx3333ISAgAPfeey8ef/xxREVFeax9kyZNsjzu1asXevfujU6dOmHr1q0YOnSoQ/m5c+fajAIWFhaiXbt2GD58+DV/abVhMBiQlpaGYcOG8eLObsI+d7+m1ucGWcbybWuxzlCO3wO7wSh1AQCohQG9y7MQd+o0OuVcxdgnnkPgqMD6a0cT6/eGgH3ufp7sc/NevepoNMHO7Pz580hLS0NaWhrUajVGjRqF/fv3Izo6GgsWLMDs2bNdLt+yZUuo1WrLSJtZTk6O0+PjwsPDa1QeADp27IiWLVvi2LFjisFOr9crnlyh1Wrr9QVT3/WTI/a5+3l7n2cc/R1L92dge3AX5Gu7ApWb2k4+hYTcI+h1IBs33T0J0SOmubVd3t7vDRH73P080ec1WV+jCHYGgwFff/01li9fjk2bNqF3796YNWsW7rnnHsvo1ldffYUHHnjgmsFOp9MhJiYG6enpGDduHABAlmWkp6cjOTlZcZmBAwciPT0ds2bNskxLS0uz2ZVr78yZM7h06RJat25ds40lIlKQe7UA72xahW0BoTiujQSaJQAAAkQh4q5mIubIeXQPa42R96RANanJXsmKqMlrFMGudevWkGUZkydPxo4dO9C3b1+HMrfeeitCQkKqVV9KSgqmTZuG2NhYxMfHY9GiRSgqKrKcJTt16lS0adMGqampAICnnnoKQ4YMwcKFCzF69GisWrUKu3btwrJlywAAV69exSuvvIIJEyYgPDwcf/zxB5577jl07twZSUlJddIHRNT0mGQZ//zhG3x1NR/7/LqhvDLMqYQJPQwHEX/mFLqcycdfZs9Fs78083BriaghaBTB7t1338XEiRPh4+P8dPyQkBCcOHGiWvXdfffdyM3Nxfz585GdnY2+fftiw4YNCAsLAwCcOnUKKlXVN95BgwZh5cqVePHFF/HCCy8gKioKa9eutVzDTq1W4/fff8eKFSuQn5+PiIgIDB8+HK+99hqvZUdENbbv5GF8sHszfg2JwiVVe8C/PQCgtXwWCZcOoVdmDm66fSx6J93r4ZYSUUPTKILdfffdd+1CNZScnOx01+vWrVsdpk2cOBETJ05ULO/r64uNGzfWZfOIqInJLy3CO9/9B1v9QnBE1xmovOacnyhCTPF+xB49jy4BIfjLA7Ohvou7WolIWaMIdkRE3kgIgdUZm7D60lns9e+O0pBYAIAkZHQzHkb8uZPoejwPY596Fq3GON4Vh4jIHoMdEZGbHTx3AosyvkNGcCdcUIcBARWHgYTK2Ui4fBB9MnMQN3QoEu6ffI2aiIhsMdgREbnBlbJSvLfxP0jX+eGQLgqi+SAAgF6Uon/JfsT9cRZRkh7jHn0G2jt5+Qoiqh0GOyKieiKEwP/buRWfn/8DuwK7oySwn2VeF+NhxJ8/iW7HcjHq8VmIGN3Wgy0lIm/BYEdEVMdOXDyLt7d9jYzg9jinjgCCKo6dayEuIj4/C/2yzqNfwgDcNPV5D7eUiLwNgx0RUR0oNZZj8cbV2KhS44C+K+TKs1q1ogz9yjIRd/wMokoF7kh+AfrxOg+3loi8FYMdEdF12PRbBpaf2I+dQd1x1a+XZXon0zHE5RxHj0MXMOyhR9BhpOfuZU1ETQeDHRFRDZ3Jv4i3v1+Dn4Pb4rSmHRAcDwAIEZcRX5iJfgfPo3ePaNx2z7OQJMnDrSWipoTBjoioGspNRnz8/ZdYbzLid59uMLWo2NWqEQb0Kc9E3J9n0OlSOcbPngv/cX4ebi0RNVUMdkRELvxwaA+WHdyJHcHdUKjrZpne3nQS8blH0eNgLhLvm4rOI6Z7sJVERBUY7IiI7ORcuYy3N63Gj4HhOKntAIQkAAACRQHir2Yi5tB59GjfAcMnPcNdrUTUoDDYEREBMMoyPtv8FdaWXsVvft1haD4AAKAWRvQ0ZCHu1Gl0zr6C8bNfQNBfgjzcWiIiZQx2RNSk7TiehQ/3bcP24K64rO4E+FdMbyOfRsLFw+h14AJunngneiRN9WxDiYiqgcGOiJqcvOKrWLjhc2wLaIlj2k5As4oTIfzEVcQW7UfskfPo1iIUY+5LgepulYdbS0RUfQx2RNQkmGQZK39ajy8LcrHXvzvKm1UcNycJE6KNhxB/9k90OZWPvzz1PFqMbeHh1hIR1Q6DHRF5td9PHcMHO9OQEdIZF1VtgYCKe7KGyecxIO8g+hzIwaDRo9F3+BQPt5SI6Pox2BGR17lSVoIP1v0Tm32CcFgfBVTe3stHFCOmJBOxR8+hq68/bn/waagnclcrEXkPBjsi8gpCCHy1czNWIxezdmSiJDjGMq+b8RDiz51A12OXMPbJZxA6OtyDLSUiqj8MdkTUqB25cArv/vAtMkI6IlsdDgSFAQBaiguIv3wQ/Q5kI/bmIRg4ba6HW0pEVP8Y7Iio0SkxluO971YiTaNHlr4rRItBAACdKEX/0kzEHj+LLiYNxj3+HHQTtB5uLRGR+zDYEVGjIITAd3t/worTh7ArsDuKAvpa5nU2HkV8znF0P5wLny69MOmRF6DVMtARUdPDYEdEDdqfF8/h7a3/D78E34CzmjZAUBwAoJm4hPiCA+ifdR79YuNw873Pw2AwYP369R5uMRGR5zDYEVGDU2Y04sNNq7EBQKZPV5haVJzVqhXl6FOWibiTZ9DligF3PPUifO7Qe7axREQNCIMdETUYm/fvwD+O7cOO4G644tvDMj3SdBzxF/5A9MELGD59BiJHdvNgK4mIGi4GOyLyqOwreViw8Qv8HByBPzU3ACHxAIBgkY+4K5nofygbvaO6YujkZyBJkodbS0TUsDHYEZHbGWUZn3z/Jb4xlOF3324wthgAAFALA3qXZyH21Gl0uViC8bNegP/t/h5uLRFR48FgR0Ru88uR3/BxZga2B3dFvrYLUHniajv5FBJyj6Bn1gXcds896DJimmcbSkTUSDHYEVG9uni1EG9vXIkfAsNwXBsJNKsYnQsQhYi7mon+R86jZ5v2GDHpae5qJSK6Tgx2RFTnTLKMFdu+xtqiAuzz64by5hVhThIm9DQcRPyZU+hythDjZs9F8F+CPdxaIiLvwWBHRHVmz8lDWLJ7C34NicIlVQeg8vC41vI5JOQdQq/MbAwZNx49k+71aDuJiLwVgx0RXZeC0iIs/G4ltvo1wxFdZ6B5xTXn/EQRYor3I+boeXQPbo6x02ZBNVHl4dYSEXk3BjsiqjEhBFb9shFr8s5hj393lIZU3A1CEjK6GQ8j/txJdDtxGWOfehYtx7TycGuJiJoOBjsiqrassyfwXsZ3yAjphAvqcCAgHAAQKucg4fJB9MnKxoBhwxF7/2QPt5SIqGlisCMil66UleK9DSuxWe+Pg7ooiBaDAAB6UYqYkv2I/eMsumh9ccfDz0J9J3e1EhF5EoMdETkQQuDrnVvx7/N/YFdgd5QE9bfM62I8jPjzJ9D9j4sYMzMFYaMjPNhSIiKyxmBHRBbHc89g4bavkRHSAefUEUBQLACghbiI+PwD6Jd1HrGDb8KgqXM83FIiIlLCYEfUxJUay7F4wypsVGtwQN8VcuWuVq0oQ7+yTMQeP4uu5cAdyXOhG6/1cGuJiMgVBjuiJmrTvl/w6clM7Arqjqv+vS3TO5mOIS7nOHocysWIRx5Hu5GRHmwlERHVBIMdURNy+nIuFqZ/iZ+D2+K0ph0QHA8ACBGXEV+YiX4Hs9Gvd28MuedZ3t6LiKgRYrAj8nLlJiOWblqD74QJv/t0g6lFxQWENcKAPuWZiP3zDKIuG3Dn7L/CZ5zew60lIqLrwWBH5KW2HdyFTw7txo7gbij06W6Z3t50EvG5R9HjYC6GT5uOjiO6u6iFiIgaEwY7Ii+Sc+Uy3t64Cj8GtcZJbQcgJAEAECgKEHc1EzGHzqNXxygMm/QMd7USEXkhBjuiRs4oy/h081f4uvQqfvPrDkPlrlaVMKGX4QDiTp1G1IUi3Dn7r/D/i7+HW0tERPWJwY6okdpx/AA+3PcDtgd3xWV1J6Ays7WRTyPh4mH0ysrFrXdPQrekqZ5tKBERuQ2DHVEjkld8BQs3rMS2gJY4pu0ENKsYnfMTVxFbtB+xR88julVrjJ6SAknF23sRETU1Tfadf8mSJejQoQN8fHyQkJCAHTt2uCy/Zs0adOvWDT4+PujVqxfWr19vM18Igfnz56N169bw9fVFYmIijh49Wp+bQE2ESZbxz21fY9w3y9H31wP4R7MEHNN2giRM6GE4gOkn12Pej9/gk1vuwXMpr2LMfY8x1BERNVFNcsRu9erVSElJwdKlS5GQkIBFixYhKSkJhw8fRmhoqEP5X375BZMnT0ZqairGjBmDlStXYty4cdizZw969uwJAFiwYAHef/99rFixApGRkZg3bx6SkpKQlZUFHx8fd28ieYH9p4/h/R2bkBEShYuqG4CAGwAAYfJ5JFw+hL6Z2bj59r+g5/ApHm4pERE1FE0y2L3zzjt46KGHMH36dADA0qVLsW7dOnz66aeYM8fxHpjvvfceRowYgWeffRYA8NprryEtLQ2LFy/G0qVLIYTAokWL8OKLL+L2228HAPzzn/9EWFgY1q5di0mTJrlv46hRMphknMg/j73HsvDz6aP4LaAljug6QzSvuL2XjyhGTEkm4o6eRTf/EPzlgaegupOjckREZKvJBbvy8nLs3r0bc+fOtUxTqVRITExERkaG4jIZGRlISUmxmZaUlIS1a9cCAE6cOIHs7GwkJiZa5gcHByMhIQEZGRkeD3bfbvgfVpTlARD49/oVgNVVLoTlfwAgQTi5AoaweSY5zlNYTkCyWVJYF7K61IZt3Up1VDwSSisxz3Vx6Q7rOhTbDvNk521yVodD2+23Swcs/n6Nw3qNkgolah8USz4oVvmiGP6QJTWAVkCLVpZy3YyHEHfuJLr9kYfbZz2LlqNbgYiIyJkmF+wuXrwIk8mEsLAwm+lhYWE4dOiQ4jLZ2dmK5bOzsy3zzdOclbFXVlaGsrIyy/PCwkIAgMFggMFgqMEWXduhk4fxY9eRdVon1T21MKCFuIRQ00VE5eegx6GLiBlyC2LvmWApU9evDW9j7h/2k3ux392Pfe5+nuzzmqyzyQW7hiI1NRWvvPKKw/RNmzbBz8+vTtelLSzGmLxtdlOF4kPJxfiZ9ZiTJOxHv4RiOdiVc6xfsqpPeV0OhJN12Y2m2dep2AYhORnDk5wub1+H5DDM6axvq6hNAj5lRviUGuFTYoC+xADN1RKYgn3h1z4KzUI6A30640J+qcOJOnRtaWlpnm5Ck8R+dz/2uft5os+Li4urXbbJBbuWLVtCrVYjJyfHZnpOTg7Cw8MVlwkPD3dZ3vwzJycHrVu3tinTt29fxTrnzp1rs3u3sLAQ7dq1w/DhwxEUFFTj7XJp1CgYDAakpaVh2LBh0Gq1dVs/KWKfux/73DPY7+7HPnc/T/a5ea9edTS5YKfT6RATE4P09HSMGzcOACDLMtLT05GcnKy4zMCBA5Geno5Zs2ZZpqWlpWHgwIpriEVGRiI8PBzp6emWIFdYWIjt27fjscceU6xTr9dDr3e84bpWq63XF0x910+O2Ofuxz73DPa7+7HP3c8TfV6T9TW5YAcAKSkpmDZtGmJjYxEfH49FixahqKjIcpbs1KlT0aZNG6SmpgIAnnrqKQwZMgQLFy7E6NGjsWrVKuzatQvLli0DAEiShFmzZuH1119HVFSU5XInERERlvBIREREVN+aZLC7++67kZubi/nz5yM7Oxt9+/bFhg0bLCc/nDp1CiqrC7wOGjQIK1euxIsvvogXXngBUVFRWLt2reUadgDw3HPPoaioCA8//DDy8/Nx4403YsOGDbyGHREREblNkwx2AJCcnOx01+vWrVsdpk2cOBETJ050Wp8kSXj11Vfx6quv1lUTiYiIiGqkyQa7hsZkMgEAzpw5U/cnTwAwGo24ePEizp49C42Gv3Z3YJ+7H/vcM9jv7sc+dz9P9rn55AlzVnCFr4YG4tixYwCAHj16eLglRERE1BAdO3YMcXFxLstIQri4WBe5zeXLl9G8eXOcPn26XkbsiIiIqHEyXxItLy8PzZo1c1mWI3YNhFqtBgAEBQUx2BEREZEDc1ZwhXcRJyIiIvISDHZEREREXoLBjoiIiMhLMNgREREReQmePEFUj86UliPPYKzxcs21GrT10bksU26UYZJrflK7WiVBp+F3OiIia97ynspgR1RPzpSWY/D2gyirxRuFXiXh54TuTsNduVHGb2fyUVRW89Dor9egT9uQBvVGRETkSd70nspgR1RP8gzGWoU6ACiTBfIMRqfBziQLFJUZoVOroFVX/83EYJJRVGas1bdSIiJv5U3vqQx2RI2YVq2Cj/ba1zWyVm6S66k1RESNmze8pzaMcUMiIiIium4MdkRERERegsGOiIiIyEsw2BERERF5CQY7IiIiIi/BYEdERETkJRjsiIiIiLwEgx0RERGRl2CwIyIiIvISDHZEREREXoLBjoiIiMhLMNgREREReQkGOyIiIiIvwWBHRERE5CUY7IiIiIi8BIMdERERkZdgsGsiZNmEstJ8yLLJ002pkcbabiIiajoa0mcVg10TIYQJZWWFEMLzL7qaaKztJiKipqMhfVYx2BERERF5CQY7IiIiIi/BYEdERETkJRjsiIiIiLwEgx0RERGRl2CwIyIiIvISDHZEREREXkLj6QaQ+5SWlABSEdRqg8M8tVoNHx8fy/OioiKn9ahUKvj6+taqbHFxMYQQimUlSYKfn59NWaOxTLHd9mVLSkogy7LTdvj7+9eqbGlpKUwm59clclW2pKTU6XI1UVZWBqPRaDOtxGBCaWkp1EIDncYXKqniO5rBaHAoa0NV9SdfXl4Og8HxtWDm4+MDtVpd47IGgwHl5eVOy+r1emg0mhqXNRqNKCsrc1pWp9NBq9XWuKzJVNGXzmi1Wuh0uhqXlWUZJSUldVJWo9FAr9cDAIQQKC4urpOyNfm7b6jvEdUt2xDfI+z5+flBkiQAyn/3tS3r6+sLlariPeJaf8s1KetN7xHW76nCpIJWo7XUa5JNTttQZpRhNCq/Bj1GUINQUFAgAIiCgoJ6qd9oLBNRnVsJvV4jADj8GzVqlE15Pz8/xXIAxJAhQ2zKtmzZ0mnZ2NhYm7Lt27d3WjY6OtqmbHR0tNDrNYrtbt++vU3Z2NhYp/W2bNnSpuyQIUOclvXz87MpO2rUKKdl7f987rzzTpt5mqhuImzz3lr/+62wSAghxOOPP+6wXkmjFz6R/YW+XS/x9S+ZYsfxS2LH8Uvi/mdeFbqIbk7//Tttp9hyKEcUlxnFSy+95HLbduzYYdm2BQsWuCy7ZcsWS9nFixe7LPvtt99ayi5fvtxl2S+++MJS9osvvnBZdvny5Zay3377rcuyixcvtpTdsmWLy7ILFiywlN2xY4fLsi+99JKlbGZmpsuyzzzzjKXsiRMnXJZ9/PHHLWUvXLjgsuy0adMsZa9eveqy7J133mnzGnZVtqG+Rzgr2xjeI+z/Xb161VJ22rRpLsteuHDBUlbpPcL634kTJyxln3nmGZdlMzMzLWWb0nuE9XuqLqKbmLPwE8v76sf/TXP6nqpv10vMfH2JuFJcLAry/xRGY5moDzXJCByxI6onckE+RFkZpMrRk5rQSUBzrfM/TyGbIJeXQKXzRbFBRlF5xbd1A9RQ6f2cLmeUBfz1GqhVUo3bRETkrazfUyWNFgZZsryvlprg8n1VK8lQqyQ4H+N1L0kIJ+PY5FaFhYUIDg5GQUEBgoKC6rx+k6kcl3JPwMcvFGq1zmF+Q93NYjSWobT4gkO7G8tulnNlBuQZK6b5+PhYdp2Ul5e7rDciMADtfCsCobPdLOUmGSZZwNfHbteJ0cVuFh9faDVq6DSqJrWbxVVZ7orlrliAu2JrU9bb3iPM76kAoNPavUeUOf+799Hp4KtXoehqNvwDwhU/Y69XTTICg10D4Y5gV58vuvrSWNtNRERNR31/VtUkI/CsWCIiIiIvwWBHRERE5CUY7IiIiIi8BIMdERERkZdgsCMiIiLyEgx2RERERF6CwY6IiIjISzDYEREREXkJBjsiIiIiL8Fg10RIkhp6fRAkSe3pptRIY203ERE1HQ3ps8r5XcbJq6hUauh9QjzdjBprrO0mIqKmoyF9VnHEjoiIiMhLMNgREREReQkGOyIiIiIvwWBHRERE5CUY7IiIiIi8BIMdERERkZdgsCMiIiLyEgx2RERERF6CwY6IiIjISzDYEREREXkJBjsiIiIiL8FgR0REROQlGOyIiIiIvASDHREREZGXYLAjIiIi8hIMdkRERERegsGOiIiIyEsw2BERERF5CQY7IiIiIi/BYEdERETkJRjsiIiIiLwEgx0RERGRl2CwIyIiIvISDHZEREREXkLj6QZQBSEEAKCwsNDDLSEiIqKGxJwNzFnBFQa7BuLKlSsAgHbt2nm4JURERNQQXblyBcHBwS7LSKI68Y/qnSzLOHfuHAIDAyFJUp3XX1hYiHbt2uH06dMICgqq8/rJEfvc/djnnsF+dz/2uft5ss+FELhy5QoiIiKgUrk+io4jdg2ESqVC27Zt6309QUFBfBNwM/a5+7HPPYP97n7sc/fzVJ9fa6TOjCdPEBEREXkJBjsiIiIiL8Fg10To9Xq89NJL0Ov1nm5Kk8E+dz/2uWew392Pfe5+jaXPefIEERERkZfgiB0RERGRl2CwIyIiIvISDHZEREREXoLBrglYsmQJOnToAB8fHyQkJGDHjh2ebpJXS01NRVxcHAIDAxEaGopx48bh8OHDnm5Wk/J///d/kCQJs2bN8nRTvNrZs2dx7733okWLFvD19UWvXr2wa9cuTzfLq5lMJsybNw+RkZHw9fVFp06d8Nprr1XrVlNUPT/88APGjh2LiIgISJKEtWvX2swXQmD+/Plo3bo1fH19kZiYiKNHj3qmsQoY7Lzc6tWrkZKSgpdeegl79uxBnz59kJSUhAsXLni6aV5r27ZtmDlzJn799VekpaXBYDBg+PDhKCoq8nTTmoSdO3fi448/Ru/evT3dFK92+fJlDB48GFqtFt999x2ysrKwcOFCNGvWzNNN82pvvvkmPvroIyxevBgHDx7Em2++iQULFuCDDz7wdNO8RlFREfr06YMlS5Yozl+wYAHef/99LF26FNu3b4e/vz+SkpJQWlrq5pYq41mxXi4hIQFxcXFYvHgxgIpbl7Vr1w5PPPEE5syZ4+HWNQ25ubkIDQ3Ftm3bcPPNN3u6OV7t6tWr6N+/Pz788EO8/vrr6Nu3LxYtWuTpZnmlOXPm4Oeff8aPP/7o6aY0KWPGjEFYWBj+8Y9/WKZNmDABvr6++Pe//+3BlnknSZLw1VdfYdy4cQAqRusiIiLw9NNP45lnngEAFBQUICwsDJ999hkmTZrkwdZW4IidFysvL8fu3buRmJhomaZSqZCYmIiMjAwPtqxpKSgoAAA0b97cwy3xfjNnzsTo0aNtXvNUP77++mvExsZi4sSJCA0NRb9+/fDJJ594ulleb9CgQUhPT8eRI0cAAL/99ht++uknjBw50sMtaxpOnDiB7Oxsm/eY4OBgJCQkNJjPVd4r1otdvHgRJpMJYWFhNtPDwsJw6NAhD7WqaZFlGbNmzcLgwYPRs2dPTzfHq61atQp79uzBzp07Pd2UJuH48eP46KOPkJKSghdeeAE7d+7Ek08+CZ1Oh2nTpnm6eV5rzpw5KCwsRLdu3aBWq2EymfC3v/0NU6ZM8XTTmoTs7GwAUPxcNc/zNAY7ono0c+ZMZGZm4qeffvJ0U7za6dOn8dRTTyEtLQ0+Pj6ebk6TIMsyYmNj8cYbbwAA+vXrh8zMTCxdupTBrh598cUX+Pzzz7Fy5Ur06NED+/btw6xZsxAREcF+JwDcFevVWrZsCbVajZycHJvpOTk5CA8P91Crmo7k5GR8++232LJlC9q2bevp5ni13bt348KFC+jfvz80Gg00Gg22bduG999/HxqNBiaTydNN9DqtW7dGdHS0zbTu3bvj1KlTHmpR0/Dss89izpw5mDRpEnr16oX77rsPs2fPRmpqqqeb1iSYPzsb8ucqg50X0+l0iImJQXp6umWaLMtIT0/HwIEDPdgy7yaEQHJyMr766its3rwZkZGRnm6S1xs6dCj279+Pffv2Wf7FxsZiypQp2LdvH9Rqtaeb6HUGDx7scBmfI0eOoH379h5qUdNQXFwMlcr2o1utVkOWZQ+1qGmJjIxEeHi4zedqYWEhtm/f3mA+V7kr1sulpKRg2rRpiI2NRXx8PBYtWoSioiJMnz7d003zWjNnzsTKlSvx//7f/0NgYKDluIvg4GD4+vp6uHXeKTAw0OEYRn9/f7Ro0YLHNtaT2bNnY9CgQXjjjTdw1113YceOHVi2bBmWLVvm6aZ5tbFjx+Jvf/sbbrjhBvTo0QN79+7FO++8gwceeMDTTfMaV69exbFjxyzPT5w4gX379qF58+a44YYbMGvWLLz++uuIiopCZGQk5s2bh4iICMuZsx4nyOt98MEH4oYbbhA6nU7Ex8eLX3/91dNN8moAFP8tX77c001rUoYMGSKeeuopTzfDq33zzTeiZ8+eQq/Xi27duolly5Z5ukler7CwUDz11FPihhtuED4+PqJjx47ir3/9qygrK/N007zGli1bFN/Dp02bJoQQQpZlMW/ePBEWFib0er0YOnSoOHz4sGcbbYXXsSMiIiLyEjzGjoiIiMhLMNgREREReQkGOyIiIiIvwWBHRERE5CUY7IiIiIi8BIMdERERkZdgsCMiIiLyEgx2RERERF6CwY6IqIGYN28eHn744euqIysrC23btkVRUVEdtYqIGhPeeYKIqAHIzs5Gly5dsH//frRv3/666rrzzjvRp08fzJs3r45aR0SNBUfsiIgagL///e8YNGjQdYc6AJg+fTo++ugjGI3GOmgZETUmDHZERPXgyy+/RK9eveDr64sWLVogMTHR5e7RVatWYezYsTbTbrnlFjzxxBOYNWsWmjVrhrCwMHzyyScoKirC9OnTERgYiM6dO+O7776zWW7YsGHIy8vDtm3b6mXbiKjhYrAjIqpj58+fx+TJk/HAAw/g4MGD2Lp1K8aPHw9nR77k5eUhKysLsbGxDvNWrFiBli1bYseOHXjiiSfw2GOPYeLEiRg0aBD27NmD4cOH47777kNxcbFlGZ1Oh759++LHH3+st20kooaJx9gREdWxPXv2ICYmBidPnqzWrtV9+/ahX79+OHXqFNq1a2eZfsstt8BkMlkCmslkQnBwMMaPH49//vOfACqOzWvdujUyMjIwYMAAy7Ljx49HcHAwli9fXsdbR0QNGUfsiIjqWJ8+fTB06FD06tULEydOxCeffILLly87LV9SUgIA8PHxcZjXu3dvy2O1Wo0WLVqgV69elmlhYWEAgAsXLtgs5+vrazOKR0RNA4MdEVEdU6vVSEtLw3fffYfo6Gh88MEH6Nq1K06cOKFYvmXLlgCgGP60Wq3Nc0mSbKZJkgQAkGXZplxeXh5atWp1XdtBRI0Pgx0RUT2QJAmDBw/GK6+8gr1790Kn0+Grr75SLNupUycEBQUhKyurztafmZmJfv361Vl9RNQ4MNgREdWx7du344033sCuXbtw6tQp/O9//0Nubi66d++uWF6lUiExMRE//fRTnaz/5MmTOHv2LBITE+ukPiJqPBjsiIjqWFBQEH744QeMGjUKXbp0wYsvvoiFCxdi5MiRTpd58MEHsWrVKoddqrXxn//8B8OHD6+Ta+IRUePCs2KJiBoAIQQSEhIwe/ZsTJ48udb1lJeXIyoqCitXrsTgwYPrsIVE1BhwxI6IqAGQJAnLli277rtFnDp1Ci+88AJDHVETxRE7IiIiIi/BETsiIiIiL8FgR0REROQlGOyIiIiIvASDHREREZGXYLAjIiIi8hIMdkRERERegsGOiIiIyEsw2BERERF5CQY7IiIiIi/BYEdERETkJf4/2hS/xs43pMMAAAAASUVORK5CYII=",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 3 Axes>"
       ]
@@ -141,7 +131,7 @@
     }
    ],
    "source": [
-    "segment.plot_overview(beam=incoming_beam)"
+    "segment.plot_overview(incoming=incoming_beam)"
    ]
   },
   {
@@ -168,7 +158,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.18"
+   "version": "3.12.5"
   },
   "orig_nbformat": 4
  },
diff --git a/tests/test_elementwise_linspace.py b/tests/test_elementwise_linspace.py
new file mode 100644
index 00000000..bfbfab88
--- /dev/null
+++ b/tests/test_elementwise_linspace.py
@@ -0,0 +1,27 @@
+import torch
+
+from cheetah.utils import elementwise_linspace
+
+
+def test_example():
+    """ "Tests an example case with two 2D tensors."""
+    start = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
+    end = torch.tensor([[5.0, 6.0, 7.0], [8.0, 9.0, 10.0]])
+    steps = 5
+
+    result = elementwise_linspace(start, end, steps)
+
+    # Check shape
+    assert result.shape == (2, 3, 5)
+
+    # Check that edges are correct
+    assert torch.allclose(result[:, :, 0], start)
+    assert torch.allclose(result[:, :, -1], end)
+
+    # Check that the values are linearly interpolated for each linspace
+    assert torch.allclose(result[0, 0, :], torch.tensor([1.0, 2.0, 3.0, 4.0, 5.0]))
+    assert torch.allclose(result[0, 1, :], torch.tensor([2.0, 3.0, 4.0, 5.0, 6.0]))
+    assert torch.allclose(result[0, 2, :], torch.tensor([3.0, 4.0, 5.0, 6.0, 7.0]))
+    assert torch.allclose(result[1, 0, :], torch.tensor([4.0, 5.0, 6.0, 7.0, 8.0]))
+    assert torch.allclose(result[1, 1, :], torch.tensor([5.0, 6.0, 7.0, 8.0, 9.0]))
+    assert torch.allclose(result[1, 2, :], torch.tensor([6.0, 7.0, 8.0, 9.0, 10.0]))
diff --git a/tests/test_plotting.py b/tests/test_plotting.py
new file mode 100644
index 00000000..c1b3bfe7
--- /dev/null
+++ b/tests/test_plotting.py
@@ -0,0 +1,105 @@
+import torch
+
+import cheetah
+
+from .resources import ARESlatticeStage3v1_9 as ares
+
+
+def test_twiss_plot():
+    """
+    Test that the Twiss plot does not raise an exception using the ARES EA as an
+    example.
+    """
+    cell = cheetah.converters.ocelot.subcell_of_ocelot(
+        ares.cell, "AREASOLA1", "AREABSCR1"
+    )
+    ares.areamqzm1.k1 = 5.0
+    ares.areamqzm2.k1 = -5.0
+    ares.areamcvm1.k1 = 1e-3
+    ares.areamqzm3.k1 = 5.0
+    ares.areamchm1.k1 = -2e-3
+
+    incoming_beam = cheetah.ParticleBeam.from_astra(
+        "tests/resources/ACHIP_EA1_2021.1351.001"
+    )
+    segment = cheetah.Segment.from_ocelot(cell)
+
+    # Run the plotting to see if it raises an exception
+    segment.plot_twiss(incoming_beam)
+
+
+def test_reference_particle_plot():
+    """
+    Test that the reference particle plot does not raise an exception using the example
+    from the `simple.ipynb` example notebook from the documentation.
+    """
+    segment = cheetah.Segment(
+        elements=[
+            cheetah.BPM(name="BPM1SMATCH"),
+            cheetah.Drift(length=torch.tensor(1.0)),
+            cheetah.BPM(name="BPM6SMATCH"),
+            cheetah.Drift(length=torch.tensor(1.0)),
+            cheetah.VerticalCorrector(length=torch.tensor(0.3), name="V7SMATCH"),
+            cheetah.Drift(length=torch.tensor(0.2)),
+            cheetah.HorizontalCorrector(length=torch.tensor(0.3), name="H10SMATCH"),
+            cheetah.Drift(length=torch.tensor(7.0)),
+            cheetah.HorizontalCorrector(length=torch.tensor(0.3), name="H12SMATCH"),
+            cheetah.Drift(length=torch.tensor(0.05)),
+            cheetah.BPM(name="BPM13SMATCH"),
+        ]
+    )
+
+    segment.V7SMATCH.angle = torch.tensor(3.142e-3)
+
+    incoming = cheetah.ParticleBeam.from_astra(
+        "tests/resources/ACHIP_EA1_2021.1351.001"
+    )
+
+    # Run the plotting to see if it raises an exception
+    segment.plot_overview(incoming=incoming)
+
+
+def test_twiss_plot_vectorized_2d():
+    """
+    Test that the Twiss plot does not raise an exception using the ARES EA as an
+    example and when the model has two vector dimensions.
+    """
+    segment = cheetah.Segment.from_ocelot(ares.cell).subcell("AREASOLA1", "AREABSCR1")
+    segment.AREAMQZM1.k1 = torch.tensor(5.0)
+    segment.AREAMQZM2.k1 = torch.tensor([[-5.0, -2.0, -1.0], [1.0, 2.0, 5.0]])
+    segment.AREAMCVM1.k1 = torch.tensor(1e-3)
+    segment.AREAMQZM3.k1 = torch.tensor(5.0)
+    segment.AREAMCHM1.k1 = torch.tensor(-2e-3)
+    segment.Drift_AREAMCHM1.length = (
+        torch.FloatTensor(2, 3).uniform_(0.9, 1.1) * segment.Drift_AREAMCHM1.length
+    )
+
+    incoming = cheetah.ParticleBeam.from_astra(
+        "tests/resources/ACHIP_EA1_2021.1351.001"
+    )
+
+    # Run the plotting to see if it raises an exception
+    segment.plot_twiss(incoming=incoming, vector_idx=(0, 2))
+
+
+def test_reference_particle_plot_vectorized_2d():
+    """
+    Test that the Twiss plot does not raise an exception using the ARES EA as an
+    example and when the model has two vector dimensions.
+    """
+    segment = cheetah.Segment.from_ocelot(ares.cell).subcell("AREASOLA1", "AREABSCR1")
+    segment.AREAMQZM1.k1 = torch.tensor(5.0)
+    segment.AREAMQZM2.k1 = torch.tensor([[-5.0, -2.0, -1.0], [1.0, 2.0, 5.0]])
+    segment.AREAMCVM1.k1 = torch.tensor(1e-3)
+    segment.AREAMQZM3.k1 = torch.tensor(5.0)
+    segment.AREAMCHM1.k1 = torch.tensor(-2e-3)
+    segment.Drift_AREAMCHM1.length = (
+        torch.FloatTensor(2, 3).uniform_(0.9, 1.1) * segment.Drift_AREAMCHM1.length
+    )
+
+    incoming = cheetah.ParticleBeam.from_astra(
+        "tests/resources/ACHIP_EA1_2021.1351.001"
+    )
+
+    # Run the plotting to see if it raises an exception
+    segment.plot_overview(incoming=incoming, resolution=0.1, vector_idx=(0, 2))