@react-pdf-kit/viewer 0.0.0-experimental.0

package/dist/utils/hooks/useScrollToPage.js

@@ -0,0 +1,37 @@
+import "react";
+import "../../contexts/ScrollModeContext.js";
+import { a as G } from "../../PaginationContext-9217cab4.js";
+import "../../contexts/ViewModeContext.js";
+import "../types.js";
+import "../../contexts/VirtualScrollContext.js";
+import "../../contexts/VirtualGridContext.js";
+import "../smoothScrollTo.js";
+import "../../contexts/DimensionPagesContext.js";
+import "../../contexts/SmoothScrollContext.js";
+import "../getScrollDistance.js";
+import "../calculatePage.js";
+import "react/jsx-runtime";
+import "../appConsole.js";
+import "../../contexts/InitialStateContext.js";
+import "../../de_DE-a553b162.js";
+import "../../contexts/RPDocumentContext.js";
+import "./useLoadPdf.js";
+import "pdfjs-dist";
+import "../getThumbnailViewport.js";
+import "../../contexts/ConfigContext.js";
+import "../../contexts/DocumentPasswordContext.js";
+import "./usePdfProperties.js";
+import "../convertPdfDate.js";
+import "../formatFileSize.js";
+import "../../contexts/GlobalCurrentPage.js";
+import "../../contexts/EventCallbackContext.js";
+import "./useDebounce.js";
+import "../../contexts/LayoutContainerContext.js";
+import "../../contexts/ZoomContext.js";
+import "../constants.js";
+import "../getZoomLevel.js";
+import "../../contexts/RotationContext.js";
+import "../../contexts/PagesRotateContext.js";
+export {
+  G as useScrollToPage
+};

package/dist/utils/hooks/useSearch.js

@@ -0,0 +1,162 @@
+import { useState as C, useRef as b, useMemo as H, useCallback as I, useEffect as z } from "react";
+import { ScrollMode as N, ViewMode as rt } from "../types.js";
+import { findMatches as nt } from "../highlight.js";
+import { useVirtualScrollContext as st } from "../../contexts/VirtualScrollContext.js";
+import { useScrollModeContext as ct } from "../../contexts/ScrollModeContext.js";
+import { useDocumentContext as it } from "../../contexts/RPDocumentContext.js";
+import { useZoomContext as at } from "../../contexts/ZoomContext.js";
+import { u as mt } from "../../PaginationContext-9217cab4.js";
+import { useViewModeContext as ut } from "../../contexts/ViewModeContext.js";
+import { useDimensionPagesContext as pt } from "../../contexts/DimensionPagesContext.js";
+import { useLayoutContainer as lt } from "../../contexts/LayoutContainerContext.js";
+import { getScrollDistance as F } from "../getScrollDistance.js";
+import { getWordPositionInPage as ft } from "../getWordPositionInPage.js";
+import { usePagesRotateContext as gt } from "../../contexts/PagesRotateContext.js";
+import "../../de_DE-a553b162.js";
+import "../charators.js";
+import "react/jsx-runtime";
+import "../appConsole.js";
+import "../../contexts/InitialStateContext.js";
+import "./useLoadPdf.js";
+import "pdfjs-dist";
+import "../getThumbnailViewport.js";
+import "../../contexts/ConfigContext.js";
+import "../../contexts/DocumentPasswordContext.js";
+import "./usePdfProperties.js";
+import "../convertPdfDate.js";
+import "../formatFileSize.js";
+import "../constants.js";
+import "../getZoomLevel.js";
+import "../../contexts/RotationContext.js";
+import "../../contexts/GlobalCurrentPage.js";
+import "../../contexts/EventCallbackContext.js";
+import "./useDebounce.js";
+import "../../contexts/VirtualGridContext.js";
+import "../smoothScrollTo.js";
+import "../../contexts/SmoothScrollContext.js";
+import "../calculatePage.js";
+const Yt = (O = {}, U = "") => {
+  const [u, q] = C(U), [B, y] = C(!1), { pdf: _, pages: S } = it(), { widths: f, heights: R } = pt(), w = b(!u), { currentZoom: A } = at(), [s, g] = C([]), { setFocusedPage: D } = mt(), { columnCount: G, viewMode: V } = ut(), { pageRotate: v } = gt(), [c, i] = C(0), { pageScrollElementRef: W, virtualScrollableElementRef: Z } = st(), { scrollMode: h } = ct(), { pagesRef: L } = lt(), J = b({}), m = b(0), K = H(() => c === 0 ? null : s[c - 1], [c, s]), a = H(() => s.length, [s]), p = I(
+    (e) => {
+      if (e === 0)
+        return;
+      const t = s[e - 1];
+      if (!t || !S)
+        return;
+      const o = Z || W;
+      if (!o || !L)
+        return;
+      const r = S.get(t.page);
+      if (h === N.PAGE_SCROLLING && D(t.page), !r)
+        return;
+      let n = 0, l = 0;
+      if (h === N.VERTICAL_SCROLLING) {
+        const d = t.page - 1, M = G;
+        let x, P;
+        if (V === rt.DUAL_PAGE_WITH_COVER)
+          if (t.page === 1)
+            x = 0, P = 0;
+          else {
+            const k = t.page - 2;
+            x = k % 2, P = Math.floor(k / 2) + 1;
+          }
+        else
+          x = d % M, P = Math.floor(d / M);
+        n = F(R, P), l = F(f, x);
+      }
+      h === N.HORIZONTAL_SCROLLING && (l = f.slice(0, t.page - 1).reduce((d, M) => d + M, 0));
+      const E = {
+        height: R[t.page - 1],
+        width: f[t.page - 1]
+      }, T = v[t.page], { leftInPage: Y, topInPage: $ } = ft(
+        E,
+        L,
+        t.rect,
+        A,
+        T
+      ), tt = l + Y, et = n + $, ot = {
+        left: Math.max(tt, 0),
+        top: Math.max(et, 0)
+      };
+      o.scrollTo({
+        ...ot,
+        behavior: "smooth"
+      });
+    },
+    [
+      S,
+      D,
+      f,
+      R,
+      h,
+      V,
+      G,
+      Z,
+      W,
+      L,
+      s,
+      A,
+      v
+    ]
+  );
+  z(() => {
+    c && p(c);
+  }, [c]);
+  const Q = I(() => {
+    i((e) => {
+      let t;
+      return a ? e + 1 > a ? t = 1 : t = e + 1 : t = 0, m.current = t, t;
+    }), m.current === 1 && p(m.current);
+  }, [a, p]), X = I(() => {
+    i((e) => {
+      let t;
+      return a ? e - 1 <= 0 ? t = a : t = e - 1 : t = 0, m.current = t, t;
+    }), m.current === 1 && p(m.current);
+  }, [a, p]), j = I(async (e) => {
+    if (!e)
+      return {};
+    const t = e.numPages, o = {};
+    for (let r = 1; r <= t; r++) {
+      if (w.current)
+        throw "close pop over";
+      const n = await e.getPage(r);
+      o[r.toString()] = await n.getTextContent();
+    }
+    return o;
+  }, []);
+  return z(() => {
+    if (!u) {
+      w.current = !0, g([]), i(0);
+      return;
+    }
+    w.current = !1, y(!0), g([]), i(0), j(_).then((e) => {
+      J.current = e;
+      const o = Object.keys(e).reduce((r, n) => {
+        const l = nt(
+          [u],
+          e[n],
+          Number(n) - 1,
+          O
+        ).map((E, T) => ({ ...E, page: Number(n), pageMatchIdx: T }));
+        return [...r, ...l];
+      }, []);
+      g(o), i(o.length ? 1 : 0);
+    }).catch(() => {
+      g([]), i(0);
+    }).finally(() => y(!1));
+  }, [u, j, _, O]), {
+    search: u,
+    setSearch: q,
+    loading: B,
+    matches: s,
+    totalMatches: a,
+    currentMatchPosition: c,
+    currentMatch: K,
+    nextMatch: Q,
+    prevMatch: X,
+    setCurrentMatchPosition: i
+  };
+};
+export {
+  Yt as useSearch
+};

package/dist/utils/hooks/useTextSelection.js

@@ -0,0 +1,76 @@
+import { useCallback as p, useEffect as b } from "react";
+const D = ({ onTextSelect: s, pagesRef: n }) => {
+  const f = p(() => {
+    const e = n == null ? void 0 : n.querySelectorAll('[data-rp$="-textLayer"]');
+    return e ? Array.from(e) : [];
+  }, [n]), N = p(() => {
+    const e = document.getSelection();
+    if (!e || e.rangeCount === 0 || e.toString().trim() === "")
+      return null;
+    const E = e.toString(), a = /* @__PURE__ */ new Map(), O = f();
+    for (let i = 0; i < e.rangeCount; i++) {
+      const t = e.getRangeAt(i);
+      O.forEach((d) => {
+        if (t.intersectsNode(d)) {
+          const g = d.getAttribute("data-rp"), T = g == null ? void 0 : g.match(/page-(\d+)-textLayer/);
+          if (T) {
+            const h = parseInt(T[1]), C = d.closest('[data-rp*="page-"]');
+            if (!C)
+              return;
+            const c = C.getBoundingClientRect();
+            a.has(h) || a.set(h, {
+              rects: [],
+              pageRect: c
+            });
+            const y = a.get(h), _ = document.createTreeWalker(d, NodeFilter.SHOW_TEXT, null);
+            let u;
+            for (; u = _.nextNode(); )
+              if (t.intersectsNode(u) && u.parentElement) {
+                const o = document.createRange();
+                o.selectNodeContents(u);
+                const A = t.compareBoundaryPoints(Range.START_TO_START, o) > 0 ? t.startContainer : o.startContainer, B = t.compareBoundaryPoints(Range.START_TO_START, o) > 0 ? t.startOffset : o.startOffset, R = t.compareBoundaryPoints(Range.END_TO_END, o) < 0 ? t.endContainer : o.endContainer, S = t.compareBoundaryPoints(Range.END_TO_END, o) < 0 ? t.endOffset : o.endOffset, m = document.createRange();
+                m.setStart(A, B), m.setEnd(R, S);
+                const r = m.getBoundingClientRect();
+                if (r.width === 0 || r.height === 0)
+                  continue;
+                const P = {
+                  left: r.left - c.left,
+                  top: r.top - c.top,
+                  right: r.right - c.left,
+                  bottom: r.bottom - c.top,
+                  width: r.width,
+                  height: r.height
+                };
+                y.rects.push(P);
+              }
+          }
+        }
+      });
+    }
+    const w = Array.from(a.entries()).sort(([i], [t]) => i - t).map(([i, t]) => ({
+      pageNumber: i,
+      pageBasedBoundingRects: t.rects,
+      pageDimension: {
+        width: t.pageRect.width,
+        height: t.pageRect.height
+      },
+      pagePositionInWindow: {
+        x: t.pageRect.left,
+        y: t.pageRect.top
+      }
+    }));
+    return {
+      text: E,
+      pageSelections: w
+    };
+  }, [f]), l = p(() => {
+    const e = N();
+    e && (s == null || s(e));
+  }, [N, s]);
+  b(() => (n == null || n.addEventListener("pointerup", l), () => {
+    n == null || n.removeEventListener("pointerup", l);
+  }), [n, l]);
+};
+export {
+  D as useTextSelection
+};

package/dist/utils/hooks/useThumbnail.js

@@ -0,0 +1,59 @@
+import { useState as f, useMemo as d, useCallback as m, useEffect as b } from "react";
+import { useDocumentContext as h } from "../../contexts/RPDocumentContext.js";
+import { getThumbnailViewport as P } from "../getThumbnailViewport.js";
+import "react/jsx-runtime";
+import "./useLoadPdf.js";
+import "pdfjs-dist";
+import "../types.js";
+import "../../de_DE-a553b162.js";
+import "../../contexts/ConfigContext.js";
+import "../../contexts/DocumentPasswordContext.js";
+import "../appConsole.js";
+import "./usePdfProperties.js";
+import "../convertPdfDate.js";
+import "../formatFileSize.js";
+const D = () => {
+  const [r, s] = f({}), { pages: t } = h(), p = d(() => Object.keys(r).length, [r]), n = m(
+    (a) => {
+      if (!t.size)
+        return;
+      const e = a > t.size ? t.size : a, c = Array.from(t.values()).slice(0, e).map((o) => {
+        const { thumbnailViewport: i, scale: g } = P(o.page, o.defaultRotation);
+        return {
+          scale: g,
+          page: o.page,
+          loading: !0,
+          viewport: i,
+          defaultRotation: o.defaultRotation
+        };
+      }).reduce((o, i) => (o[i.page.pageNumber] = i, o), {});
+      s(c);
+    },
+    [t]
+  );
+  b(() => {
+    n(10);
+  }, [n]);
+  const l = m(
+    (a) => {
+      if (!t)
+        return;
+      const e = t.get(a);
+      e && s((u) => ({
+        ...u,
+        [a]: {
+          loading: !0,
+          page: e.page,
+          viewport: e.thumbnailViewport,
+          scale: e.thumbnailScale,
+          defaultRotation: e.defaultRotation
+        }
+      }));
+    },
+    [t]
+  );
+  return { thumbnailPages: r, addPage: l, addToPage: n, thumbnailLength: p };
+};
+export {
+  D as useThumbnail
+};

package/dist/utils/hooks/useVirtualReactWindow.js

@@ -0,0 +1,96 @@
+import { useMemo as m, useCallback as _, useEffect as R } from "react";
+import { ScrollMode as C, ViewMode as g } from "../types.js";
+import { useScrollModeContext as x } from "../../contexts/ScrollModeContext.js";
+import { useViewModeContext as G } from "../../contexts/ViewModeContext.js";
+import { useVirtualGridContext as H } from "../../contexts/VirtualGridContext.js";
+import { useVirtualScrollContext as M } from "../../contexts/VirtualScrollContext.js";
+import { useDimensionPagesContext as O } from "../../contexts/DimensionPagesContext.js";
+import { getGridDimension as V } from "../calculatePage.js";
+import "../../de_DE-a553b162.js";
+import "react/jsx-runtime";
+import "../appConsole.js";
+import "../../contexts/InitialStateContext.js";
+import "../../contexts/RPDocumentContext.js";
+import "./useLoadPdf.js";
+import "pdfjs-dist";
+import "../getThumbnailViewport.js";
+import "../../contexts/ConfigContext.js";
+import "../../contexts/DocumentPasswordContext.js";
+import "./usePdfProperties.js";
+import "../convertPdfDate.js";
+import "../formatFileSize.js";
+import "../../contexts/ZoomContext.js";
+import "../constants.js";
+import "../getZoomLevel.js";
+import "../../contexts/LayoutContainerContext.js";
+import "../../contexts/RotationContext.js";
+import "../../contexts/GlobalCurrentPage.js";
+import "../../contexts/EventCallbackContext.js";
+import "./useDebounce.js";
+import "../../contexts/PagesRotateContext.js";
+const ct = () => {
+  const { viewMode: n } = G(), { scrollMode: c } = x(), { setColumnCount: f } = H(), { virtualScrollableElementRef: w } = M(), t = O(), l = m(() => t.heights.length, [t.heights]), o = m(() => c === C.HORIZONTAL_SCROLLING ? l : n === g.DUAL_PAGE || n === g.DUAL_PAGE_WITH_COVER ? 2 : 1, [n, c, c, l, w]), d = m(() => {
+    if (n === g.DUAL_PAGE_WITH_COVER && t.widths.length > 0) {
+      const i = [0, 0];
+      return t.widths.forEach((u, a) => {
+        const s = a + 1;
+        if (s === 1)
+          return;
+        const h = s % 2 === 0 ? 0 : 1;
+        i[h] = Math.max(i[h] || 0, u);
+      }), i;
+    }
+    return t.widths.reduce((i, u, a) => {
+      const s = a % o;
+      return (!i[s] || u > i[s]) && (i[s] = u), i;
+    }, []);
+  }, [t.widths, o, n]), I = _(
+    (e) => {
+      const r = e % d.length;
+      return d[r] || 0;
+    },
+    [d]
+  ), P = _(
+    (e) => {
+      if (n === g.DUAL_PAGE_WITH_COVER) {
+        if (e === 0)
+          return t.heights[0] || 0;
+        const u = 1 + (e - 1) * o + 1, s = Array.from({ length: o }, (h, E) => u + E - 1).filter((h) => h < t.heights.length).map((h) => t.heights[h] || 0);
+        return Math.max(...s, 0);
+      }
+      const i = Array.from({ length: o }, (u, a) => {
+        const s = e * o + a;
+        return t.heights[s] || 0;
+      });
+      return Math.max(...i);
+    },
+    [t.heights, o, n]
+  );
+  R(() => {
+    f(o);
+  }, [o, f]);
+  const A = m(() => c === C.HORIZONTAL_SCROLLING || c === C.PAGE_SCROLLING ? 1 : n === g.DUAL_PAGE_WITH_COVER && l > 0 ? 1 + Math.ceil((l - 1) / o) : Math.round(l / o), [o, l, c, n]), L = m(() => t.heights.reduce((e, r) => e + r, 0) / t.heights.length || 0, [t]), D = m(() => t.widths.reduce((e, r) => e + r, 0) / t.widths.length || 0, [t]), p = m(() => {
+    const e = n === g.DUAL_PAGE_WITH_COVER, { rowsHeight: r, columnsWidth: i } = V(t, o, e);
+    return {
+      rowsHeight: r,
+      columnsWidth: i
+    };
+  }, [t, o, n]), W = m(() => ({
+    width: p.columnsWidth.reduce((e, r) => e + r, 0),
+    height: p.rowsHeight.reduce((e, r) => e + r, 0)
+  }), [p]);
+  return {
+    rowCount: A,
+    rowHeight: P,
+    columnCount: o,
+    columnWidth: I,
+    pageDimension: t,
+    estimatedRowHeight: L,
+    estimatedColumnWidth: D,
+    gridDimension: p,
+    totalDimension: W
+  };
+};
+export {
+  ct as useVirtualReactWindow
+};

package/dist/utils/hooks/useWatermark.js

@@ -0,0 +1,94 @@
+import { useRef as s, useEffect as I } from "react";
+import { useLicenseContext as u } from "../../contexts/LicenseContext.js";
+import "react/jsx-runtime";
+import "./useLicense.js";
+import "../appConsole.js";
+const m = "data:image/webp;base64,UklGRrabAABXRUJQVlA4WAoAAAAQAAAAnwUA/wMAQUxQSPFsAAABHAdtGwnS9Pmz/mkytwgigoHbtnG6+9Aqp+snhpfENMrjByY/WiZpg8WhRnsk/aicQR0C9AaZyWUt6EZWgeMV2NtMe0lKfF8A/t4NQDmUegAk+PAzkBDhwN/5BaC9YPmonFNnBkQB0XDAyycRLuOsGocCRQGOAOkOmXs8bKTEKtRuzgHdmgtfgVznAmo0UD3KT1UaCqztwz91HvYZ/kaXTTUwyTPgOhcU2FodDt6fK+A6Cmiv7hYFxgEuSL97BCaiPFqgW/k0I9S6OhgG+uk8mcP7Ja7lGVjL6N32f42Eu/nWan+t3E57plW767AmnDV7FX43nJ2keydgkNkKJwqaIczndGE04x+kHwjm9/08M11EeIJkW5YkSZJYkMTUXYAH+fL+ExYePg9LqwIABbVtkalTPZV6rVR3xeqJGveqWreVSp7fhZlB0cO8/VJE0KJtK2hr6dpt321CfPZwVIQD8ulJkmTZtiVJ6mtXuzoRnY1OpLIR2Jy1vGcJE9G5vYigxEaSI0nqNe7JEXWVldOl+ma+RvNxmftNp6adbo3p/3hgf0JEsl4wlnIYx3DkqWxuUyt+MW/oG2+nBbK3s6GxPw/kTXBKJ4y/THz2/XzhWYWIbA6UlWBCcXSk3J5NbAWZLW+AMalWPEM2BsqeW4VbA+PYSAUkaxSgm+KNWBueI5viRPyCchwZg8ZCPAynbMpijFoLniUbolNVzh+6cVwU2ulwrpjcwEwvITk96C/3nier8bkg5TgqUoEdA2xC9Mz4qHrMtWfKSnzGuuqcDcYxkWgnY7KJ/UfNj6rP3HquYEbcQEXLBeuLV0/ROCIWTSRU5ANmgEW95tKzBTRTEV4wtbDEY3+k/hRbC/wKbeV7PxjTb+48X5i7iBmRvbHyhKKayfWcK0+Yb0NuOfVkX8y4dODGE+aP/upPATcbqyh7gpaouWnBhSdMO/3oP+lZF/RWZFRle9CYsenBe/Ixd2suM62cP5Rla6SCr7AYowmvAWDODBX44iTUZVukAmKNoAtvIWAOlA2l8YvRmC2RCqVBqtGMlyAQh6NBgGmjMuvRuSBrVOMdDLyBGhK5KxVNldGoyFp8rqjKqAuvgKCtCPHfy4Uy4FLTQEdKIV7xfEFVNmN04Q0UrJHaWPdJVfLPWgLVfY/I6olUydKGF2CQBkkIxvNlrq16At3lUm59+BwOzlB5xGSM8jAX1WRvQChjtSAe0jKuq9eX7/tO4k7r1WRfSBiDtSKulaPEom8TqP/xc2fW5WwjTU1P9gSFsM3IduIH7oiTtktz+wd/awy0f6mU3KUp28PCF66JvVMaCou6mtow4sq5S1e2BoYuXlaugXsiRoVlRsqGn1QaqGrLttCwRexTAGJTZexCXmORCokEEFCYLcEhC5RdnWBIxTms07QmlF/tT6ulcqAPnHahMbmGrAeqhQmULSUoHugujyisW+0voaNIfbJhpXl0VxqTa8hapKYWpUPQnINbaXnKyZb0Vf9baChSvlyW2WuNyXWkHJ9rYRduUwsSKRBO1HdSzu22M8bPlPd9Hb5QkWEbXFu1hLO1dalZYNTakX3Elmh3dxPc+3vUSW0ko55RHebQIohic4jJgo8saXeLNj8KcwMC4BzoC3JoCYRyS7SBok/0hx9/hzKxrZX/XksAAXWZaLOxtKJIAdRboDYThALw8Q5dalsrXz6IQd1ffsdvTry/CXMuysgvNAvsA3K6jsjDRscze4cquS2lKE3Yv8XstF36+TvmgXZRf2UnkxNfaPaMIHTXchDxQR3co0lvrqQlX7bpq4tdUMG0rpWcJr3QbAnsIbkJuRn5XYoUV25CB0E4KywjNexkJAAVhHeUNfFIcDC1okdpTtgAWkXIWvKMWFFjkZpoMzdTQ3Zn6TMT7fCwHTVKCyV+AM8sbC0CaTf/uRKpQCxrXUwV0R0mTnpxMC1pUVqgFeuHKgdUBu3YiBSUn9y1HCe505zVXEayTSlR2h9EuWI9bPSnciCoUAhVpJdl1xDccdYGsUeAyTSlQ2sJ8YxIr7OBJOlcMaA6fVA5JHU2ryK385x5DNKLD9OWCrGFYlsX4gdcos46vK//3Ml3YiutXFAnYNEtR+EA701jGtRmaQMYd7Dbkd5epw2sT4mPeAepTST7WwSijWzIN5iUnUFrCvT2oRdnQ+KxxcfrlNkGb3cLoSU3CToxQnZ87fEXnMuWZomWv5Fa3XW6bMf2TC3uIbPmJNH+7p7AXmlBvLsRsoiD9DG7wztU2QPtmVrcRGSluXXfPecj1/F7BnelBcQguIlExNZ7NAFmk5QQbCWx0OzGGqrxN0h6CnM3icNNchNEbShyZ+aDjjZGHZNtJbCxHA+n4Gk4XM/h7SpxwkZQtaIHKdgXkF1N/P5OiLaZvObSc5DnDnIcpiexdpc+84fYXDtqlAZRqlgP0kgtbDtxDSbH0z52Fn4WT/Uszi4TJ7d/akiLF5WoVKyf2XLYDtKazI3Qzx2B6WmM3absQkPjlpRIzZaIiGL8APDLupYRAewhrNHsmJ1vgD2JnsfXddJgByn4x2pa0iG2A3HxrHXqPjbKjbIqLfYRnMXugVpEzvhvwNZ9tk52pR1B2JbFNKVCbY5EwXQbe7mHJogqsE1PizPw6JaLe9Ff0FVqQ6K2BkJ0yzEnnJ1fWxr0dlAX4/gnrdACSSXHxI7ow3swlZykkB1fdvStKZCa1P6JnQ5E4mDa/Cio5ko3d7MdyTjCSpZ/D56aS4KorbXHX2lQchaf9TF2OuAPoiboiK6IbMS4lT7u3oSl1JwfoZgEoqji9p7AXmkQed5aEE/has1Bs3wpo7vjtX9JR6WN5Ho6MBZRz+DuInO0FwCWZlHznKmivPBaDIVG7m7IBEFPYe4mc0J+OJiaI+I7zc9afhJJZ+AwPYe3q8xV2z89gIZvNTv1sTM09po92HAbf0OkXWbtLnVS+6dgHkHC95obUslZ9MITIk1k3ebsMmv1kVo8g4IvoM6qZaZObrLdi6WSrjN2mzcvBv8I5hkE9BdX8Xp5qZWXj8JzFuqbbEgsE919vq6ztuEmj9TiIfCaW3nY2WU6q5kVVMOczREhOeD58yWkY60GtlJbsn2lgRgdn+5e48rbngKuuTBeHf1knSDLSm9/+7aMhjq4im0jkJRm6gC82eDBnIrm1vgE5ogRZqelW3ctHFEtTDX3kYTERh4EDJoET3xAy15if9N9JNXDU3Siym+fBQubAl9sMEsrva1YNbFUmg0R0wrM1hZZDwMFToA3LsAVF0hdHIXG726kgb9B0uMgocPzx8QjytBWjoqNWQ7XCwBOVfDgPPLwmPKzluD11pMr9yO9YTC9AtxE5R6aTxYeVXb28rsdRuhHi7yBWdtLgE1TAoB55eAB0Ful3CxmeLfiJ1uYeDLQxZwbzuVnO9eYSYDllwF+cUqrlZnN7NCRDjluExG6mHfDuDp2RYDyjO8BsKx69fKSWmnztNFcVsq7vz2QvQRdzL1hjFv1UwTJNzpow9rYrpmV1iBS7ClM7Ms0vDD/7oozgyLAqco7NkE4E7YbTporSgf/UHhhDl6mCW6i8o/MJwt+GIkuEScLnvZ0+Mo8vEsV2DSlAJdXDjzxUZ3gZMF/4KW5eJUuqN18Daj8MuCLjfA+78/Hq7qgCug0mQpMnvF54yK97f05edQ8yoK5zEwHIt/o/DHxa+p1jrvs4Vd7UwVCCR7v2Dzy8IvqkkgahO0BQQsa/8h8svAFtPSWPk0YAFLFhXyOKcCdoL1y8AWUjb2zpEkzj9RQXsyNmQbU6ZmbgS+gI5t6d/kwE2ccqWGex/JvAxWYkzM5vuCu1YrrIfb09v7WhcIe5JmmybA4MwhCnJrZ0UXnMZjOYkPKX+OFTMNUmSYJ79AGPbbofPm/7ytwStOgpdMsXYaJQjs1yI+MmYV/k6cjlNyuo1ijlJklC+vSOoO4qDn4V3lUc5x4TvEUXC01mjyT3JplewWJQ1R+GeD2oDzf9jl9kJlL/KTPILtGQQy9gsMiJs/4yD0nwf8su2SiuCwJNKe0gOUDmdVNvYLCIyLf6GQ7iIuQNqN0o2uJxqQGkQydi3xA3uW9gsEkHu/Y6D3mIsRB+F5NqSnJDUzdgiC6c7w+2j8y+97jJ6mGNIdUHWNfaT6UmSnApV9yOahWM5Lj6hrrSvNYa6mnAZVs/nv/9jLJFk2DiTWiNXCDXKDWObaV5sm9LT2YLGrcWvGwgotITsC7mVoTSoOFRBD4dt1kWWmeXaDpQeRR25JP/AguIqTXU+k1oLQJ+bp0k11WbVOEx6RWSstSXINwDjfOyd1hBDtX2oLSunWTVV4t04TGNWDHAEiIU20I65IdK20rhwEPlk4aztRNNpm1SxUWm9qIVeQLdEuyRDvl3KWNd6JFx/YHkURn6h2L3Nr1FjQh8amFeEU+z7YlSbZD1h2Su4j3ZOdn9Y89du1JQP+HRlE4POND7WWuNEg1fsJtSbgzpW1sHryqU5SWf9tD1qQ2I/MwW3JBmiYUTt02F08D9FRyinRHzDucIi40UO0jW5IjupiJwqBdoOaiBSeSqyw9ZUlzP9S/yEKg3YdKDw60t5eT+K6yIzrqX4TZ5x2VJjxXmh39WAPI1OH0lRXdHWbSrHMNoPajMbrwWGlTaUsevcxJOk7rLBtSc8tP/Fml0wFxtrkGMdbw2vBUaRvSdZJcxEa+d5cFpcEuTK9kJ1nmGsRyuqYbD5W28XnwSpa7iI2WqPWXe6X5hMLqO8kuw2rK9qYcz3T0ymKJjXlia8INjx5zrTRPirrDtJFoEUMnWWXYzwVpxyOlCafoZ3EMArMxfeaWcbeiI3+rjzhSi5uJs0kxqKtKGow2PNHSM2bnDddmWl2o11xy7pLwFyo4Ym23xtRpZkxF64U/R5E6PFDTK4PUI89canP2mzvWDTDAxz3+uiRPvouFKNlNKsTHSrPF2MiGDUkcnnz+oJ5zJbWzsphD6opJoHpXMSrxodaAUlS5ru47N1qzNdbSVV4/iednRflIc45JCy609ynPddJRqlmWmqZ8IDqk0oP34ktlsv96irJKFlWxL135sea4NOG10uCTMK0gE0gAga6yQrhsXdryQ6VtW/0NuvBWQc/vVowSLHJxZwlmp3XNboHXpkhtiMpxZKS6Ofu4Wi52M1Mr973tSAajRGxDpDZyuqYbx0Xhnds5eW73p8yUjje9WvmEdEG2Gp8LUo6jItVlQ6uZ4h1UU9loE6zUWGwj5f/YcGdyRivxmeqq82IwjolEKxU2IJDIzgxIFvpPE2IaLzYmh4QZcQMVLcbUuZjROCIWbZRPNSdLJX+riZb53jbEa/lnmSYxgWZkXbK28GrGY3+koNjaW35ufSy/J3OyRYIbJdygmLuIGZG98WiQYp82lYeccFcEfz0ZozzfhNxy6sm+mCW1ZgwKmVDpMPg8ju+8vvmX/jlws7GKsidoY3qTAwoHNO9+KlvxgbsL4z//kR52V2RUZXvU0luEcZD0/DDArbB8znPP2xguM63ZGGXZGinvK7ybkchjHNJDwfWhsEBOG6js4Kwx6rItUh6xRs8iDR+1Lg48C83ziBwpt5MGqgqzJTbXHjlIM7JUDGUiTmNc+e9Lixko2FkAAY1Zj5RnpqUZTSCu3O1v5F7FvpPoH5eV18YCOWHgaBH/H0yNyajIWnyuqErHokmZpl1mHH+RrEwrEM/PkSq2dpDbGhVmY3SkHJ/zgqrcGmMR9T/RKhazANlvZTOY01gFeHkop+vx3212k1oCmjG1Uu7lgp+Mweh5i0QCzpJKPuRYMIZ1neIRbYB3ewJU8XqNLj0BzVSEFy9IcSTdreg29nIpq2wDFypHngdaeZhLalLzgSypIQJbpD+scAu07kn/HVRdCKPC/EniIng1ySANteGQpwNsd3cA677kb+AlaFzIEr76iz3sgo40NT35OfG9bEs+Ip4sFsAdsKIVaIBEcSgs6i7Dj/6TMQBflGQ0pQGM0ljPAhEYt5FQLbeACpeXGz1BGQqLupq7MOLKe1lXEkT0QjymREQ2J3v+myDFy8rNi4vFKSwzUnb6jsWytCUBJksNJ2GlyvxtgCJWqgmdQAxpyZvwpbFITcSrGIUpILj4wNQMnEhNrtIYavV+SZWhsAy71W9Jj5XUgkiWKh2hEOYPkqLPhsBEapMq1g8R6VpkK8/GoqMQiad8afH+SmNyQgmkFx+mKSiR2uSK9SCwZBdRQUOR8qQA7WJjckT2qgm7toQgZYUT9W9iYv6Tss9Yyr6vop9QxRtTTAXJ3wRS8I/FtCUDqwPxI8QPEPf5FbQTqj+0ow/NsReEu5GhVO5qTARYrlQUgpmlvcItdBOrqeJOLIDVF2Pmi983DsjHfJYTzp6+NQk4ie2fxKdU3f0dyIK1XAkgoC7/J8zskurL71bwsMzzhwtQmtT+ibgHvk536FLbUgnAtWkcQOAv/+Y/MVPto1T6eEp3oK80MEL7p//o6QBs1OruUOW2gO/UIvsXr+3SzZPeT02u3DLH34e80rYI0mU2v1qD+cuYezTpzaF4qj7pG2082cdFq6Yf43ZL83+WuxN1pW2lbpfgJuTz9bsUKe7IZhakY8SqsEyrMK69pRhdqbsRV5pcgnIwtaJHaYI/cKSKUN4MWEjsCFWX9IhSapvnkMu7I21n6TOOqh01SvNSxfoZ+So7GPvXP1fK6Wy6nL4huyzskgyVtLuSdpg4qf1TMC1pUZonHmWFKnGo/CUalcisTaeKj3zEpN2ZstOcVXtssU0pURogyhXr4UP9y5yNSFHSu8OUab234vxhiay7E3acNRCDfwTTlA6d8VnEIkWoLGnrvCfeQVHSeyuu0Zl9WbiZ9SWpArrOczakIL04mrZUiC0gHsAHOLTyeGuqkt6ZXKxr4WrjPvmT6yUkS2uZ06sgayDb1xwG4t+ROwFXXtiYBrXZRKJg+oP+8OPVJd3Wh1phzPSFqyneki2ZVkJVYfWhkBJR/76AObJaU6C3hY3UInEXM+lKuikm2WIfhdv5VERUcqOgLRte3vft8RecK+FMiac5yXCHsulcp4ts8Td5Z815mNIqoqk5lEQCvDyBvdK8eHdjIbIGfCyGc4MquiUlH+e4pbyqSCoNwve3L8gi73gGd6V5xCA9oR8RdQs3/zJNpJuKw74yikoLtLwT+HD8JT2FudI8Sp1okTQlc7lJEfHGegkqbUOkWA7Xc3grzcs+JTA1osfjQs9ceo41kmJuBtOTWLtLn7H0Fkczajwy5AwmZ6aDn1l5YlTP4uwya9WRWjSkBYKbVUvNZG7YxfVqCExPY+w2Z/WRWrSkBIF4rPUSM5oZvgWToRA9j6/rpNlvkIJ/HKYlHRDcltm7Ylpm03IIzuLwQC0i6w3Yus9WIjqFt0/l8rwpFWRrV3/sVZOSmi9lKIFtAA3xQm3hHbhKbUjF1uj1Gc35zthiJm1pIFs73cwRJclR8Q9178FUclTcSfpsJI0p4NLQBu2JkOa+879v4A/+Qe/BU3NRELt0a46/o+lwRUd0RfRZNz9Fb8JSauCdLSaBKCsbyBPYO54MZ2R0dwqW8DYbdlTasJd0A2OV9Qju7kGFOyrKC6+1YkOZiWP44wRJD2HuPkQ4JOI7zU9pXrj17Dhcj+HtXjS4pOFbzc5eds6BpLQQk5CijD+ItfuR4JSE7zU3pQmn6AtLc0hcj+LsnhS4peALaDavxcxmcuiyGArVwxi7LwHgBPQXq5eXWtkJ4zz35SFxd76uw0OH11wTygOv7hFtBdWw7MZQery8L5JNvLTLgKiArfvg4ME119xujsa0E2R5pWfTUgVXC6HhQ8NmsKodMcLstDS+XAtHVAtTG4EJBAZNYkV74gNadjChu6ZVw9NKWAphYVNYzb7Y4JYvkRC3lFcRSztBSQTlmMBK9sYFuPICqYqjpZA0QnKN/jXY4eg28YgytBXwGZVIQM7Bj2F55OEx5Wct3BFJlXDcQ58D9snCo8rOXrAz+jLBCAC+RMcrBw+AD6uUm8VQQmvOxdPwsay2EmD5ZYBfPNZamdkMJLTmtjp2RYDyjO8BEF9yULW8rIah1LB5Doog+UYHre/d/Fyt7AYh1a44chUB8o4NWj9fzA0nyyFotUwTHP/IfLLgh5HtAMTapQqMAlxeOfDEx3rz1FqlC4oGVH4Z8MXGfuPkWtUGVUBUYPKMzxsXhKbpNWoaZcHQgThZ+UbnjwlGw0rr8mdR1U7xXluqQCjBm6q8YyPmgdKs1i6J/JGSZUHQgjZR+UfGzAKnUcl1WboAkCp+U6c4TSnARc0BqUnNzWnKzCPVl+fhYKYBFTcDrAYll6fNOFL96hsYqgITOT5ac1JzU+jPTWkP6kzTZFicGQQhYkfHa0xp/odPXKhMw1SZJgkPPTZiU0Kzm/Q0JzrN0mWYKDT8yJgNCc2e5L3HJNYoZWbJwmIQF7UZyp1abHnDmLy+wEwjzyRtZjWqkDhExW2EdIdmcRtOqc5MnkHqrLr1qnBYxERugnZ35OmFe0t+eksCzSH1mvxdlo26F1UoPCJiN4DUp5R122tTAyDRmNQgksr1RHmX9woGk3i8OyfdYy5CvOD+0pSakhwwdQuC6E7x+mj/jqHr4yephjTHqgd1jH2lwSR/MVPgFLvP+Go/tJqRHFfXWFcaxFqwHA0OkXLL9+IF+EtOJtaI1iyAXKDWObYZNQ2j7Q9nEDRurfix3EVkA8hMrQml2RDp/Ax3k2VOTQNj9EsCZU+k6yG4iOSQguk1oDSfkK1LN9ll1TYFiGFopuNTXIPjLmKck7vDCHautIDSunWTVV4t04AlEO26oIVUbkQyF5Em2THjbqV5AEdK1KZussmsXTpgKNr1EL6Wx+clMIl2qrQgHQTGVBouEmsrmbN3LHJr1wTPhhbi7RYnZkFJsh2y7pLYsnwi1pazZv/YY9eeBHSHx2dK0cpnQguB29CScGdKC7VYiJGN3AGM6SFrGhMP/yRPBnIe8DyZkX3x+QNmsdxfuiOpzcRFCMsiNFDtI1vce87aAvUvTxcmaRXvRHNyAIGesqS5nfqX58tKpQcH2vuUkrWusiM66l+eMFSa8Fxqg3cC4l3ovrKiOnKN9kvCQsVcPsbowmOljaXOZvQyCwkg0Fk2pGbD974v0unALwl7xhpeG54qLSBdJ8lFBGJy3WVBaXYTBgLwq8KeJYCWbjxU0UskVe4iApLwtf3lXmkQUVj9r4crfRzqxjMdvbJZYmNTsTUp7EePuebbuXMJH2Jiw28HW5d2PFLSI6xHy9UUuPrMLeOO71YcyRaQbk2ZtY3Nc2KsqwJZtOGJlp4xH37iNlP1mkvOXRJyV4EkRqIzPSUq+lz4cxSpwwM1vUEDJDoxC/abO9YNMDaxWxxfWfL0u3aSnt2kQnysNBt5LCaI4knBaEzPuZIaKUoBaTOk2rsC1buKUYkPtQYMiBVfYfrOjdbsSagEEOgn8eZZUT7S3MCkBRfaW0rrt98PRMZoygeiQyo9eC++WDzN7wdPpCs/1hyXJrxWmg0Rf1bgSIHlf0Pk/KEtP1Ra2Cqc1ujCWz01uEaLIkMi8RF/OdgxlHFW6MuPlBYQleOlht4qNmY4RRHM7wYbEhmMksb8QGmBHAl0452K3omTLzbmOEy/GgZ6MHdGZf6nvq5IN17p6BmgDWECr8lL9asByr+mYx2MSLJjtBKf6YKq9AbjmEi0UvZMLfqV218/NWzxB7Ot7/gYJMro3q2q7jZKZqNxRCzaKL8h31cslfSUqLiIS62Il2kSUznUsXbFIcBfYzz2R8pGIZL4MM9j+T2Ze3JEvJw/QEF39YKayN5Y+WJrfWz1nOCTw5FxkCrP70XuPPVkX8ySOrOnia/0Pnoex3de3/Bz/4E4axVlT9C+THueTHmpbMUVd9fc/vVP9Ky7jaamKdujlsaB8RNa2We88za1l5lW+SBd2RopGCt8mD1TIC9B3ogOODNW4Mrnasu2SEFEX0vsuXKUboMlRzEiR8qtidyG1pctsblU39r+4hgRkTZoG87K967FDJRdSLEnGI1Zj8615jBKEkCmiO8VBDsqzuF73bE2FJbb1EIGyp5Il+qmBKMia/G5oiovVMaAMkXsI0dYh9VZEzFGkn2dHuoGuBmjI+X4Bli0NV2pyhsMyoixQNkZXKReYo50SX7DvAkYKX9xpGA2GKMloBkj6pqxdTEoAcMpnKmTcHnWL8eHDKByA7xQxetjYNUT0ExFePGC9NkREA930B92f9N3woXqD6kfpDzMpV8algxRCFiacYFboMVqzD5C2oohBK8w30xcBP+7ov7MOXDwpN0dwIIVKnXqvcYBBMI//8Vvhl3QB73/+EvD0avsUH5msQDugBWtqfJl0bgQvP/Rfz4Gxl+ENQf528KO0kF9IfKmFIDffQNUuFyla8uobwCBuI8w4sp7+beFPdFLxaBLOV/ngVtughQvm8TmxUHfaOPpoaFyy89P3seaozrJH6RaccptgCIWyDwmCZuwaixSbkdy5Ncd2XnuJpiagRMpD3LHd3F1bipOQ2za9rFailRgAQTqjckVxMrEZyx98JyGwEQqSBXrIaKwRqg8G4uOKoHsmLy90Jicj60QXW3+7JqCEqlAjwIBahw5z1TQUKSgWJq71Jhc4ZaqiqtXJGgLSKRswkrFen/kJX2KuVXRT6i2G6foCqM5D1Lwj8O0BSNWS7Yt3jrV031PDgFX0E6Iqp0v/a+A5MhBnY832DQGIkLVizMLW6Q/sLGxXkU3bYK5AQELYH9FeCwL24BADKZcdHvTmgS4DmJm1rM0vt0dNNNGqBsQ+BUxU7w8W8GLf8CvBuDl6cMiD0IBeLiDXtqKchdKNNtfFKuk7CHsI55VHykrvXgimt1Gre4OWmk7yGdqsZczgV8UkujNi0eQRypEEE7cfohKLtn+GnMPpniB3KBiJNHGfzt0n9P0GTLXcneirrRQWiYK7Z+I2LpXkeIOqfQMIvnN74bmc+0txehK3Y24o7zhJrkJolb0KM3KdYVwBf68JGB+NzS3Oftoc3l3pO0sfcbRAALtqFEaxB9fKUFN9YDywWuOnLfzEOeGfMSM6Q3n70raYdrkGNOLaUmL0iDSivXCLa4rQwHYUD9a3/FVOIu+uOYjJu3OlJ3mrLYdyTalRGk2SvEDWH95fHKSNaWdPhpfencr5tdPXLLuTthx1qiD548J1ZQOrR2ISR5MC4xhGosFVYlz+2x8mUk/vVkqqQK6znMGMUjBP5JpS4XYJsQEX7F+un6FNo3t+PqYC2+5aXKf4uxZKnWVzLWySvsqFgasIHQSXryZxjSozSYSBZPHD9j9DdLsHl9W5ypCUjZcXpL5vBKqUrMnsbXabAUfWa0p0FtgI7VIyJIer5PGuuQR7/L/41wRUck5QaE82/UTecxfcJDNzdHTgY0sYK4TRrX4m/xiIdkmfBwUFdHUHErCssuewF5pMEkv/mZXa/BFduUNssgWS2eM7qOrbM6VVJqd1mUsyCLveAZ3pUHkGcIVYxPO17PZ3CKKclOodtZVVNqU6PGAv0HSU5i7yZvUBXyqFafcJIl2Y70ElRb4DSnL4XoOb1eJA254zME0IsjDQs9cetKn2NhkGAvVk1i7y5wcYtw0I8cDQ05HB753o5DT+/DEqJ7F2WXqeOO3H9OQGAisWmpCoyUowpPnEpiexthtzuojtWhJCgSd1UtMaLSAWwogQCF6Hl/XWVtAHupQS0Ig6KqegbXMpuWkBpbyf4yW7vysN2DrPlsJqIePID3Eu21KBN3jK5zLM2Xlc7CUwq4MixOEsA9AbO0duEptSMzWNmS3IyG/uOy4piTQPb7CODaOZmElyVVG3viT9/1bMJUc0Uy3YyNj0mpMAK/jq54h7oiQ5pasc/AH/6D34Km5H0m0e57m6Lvr+FLgio7o+GRTgT+K3oSl1OzgiEkgysq77Ank3Xl8CXBGRnfJcsN7W/5zFBp9Hr8YGIesR1B39/GF546K8sJrc6Ch0IS7G5wg6SHEVTC+4BwS8Z3mJzTx5rPjcD2GtirGF5pLGr7V7OyldzuMg2Jji2EwPYi0SsYXmFMSvtfcLCZ4t+Iipkn1KMqqGV9Ybin4AtrMazGzmd/N5BPih5kE1cMIq2h8QTkmoL+i9+JlNTs2CtWsB9Ja8XF0VTW+kFzDL3R0ldhp786NVlJbkCxC32krCfEy5F30AmRVNr6AnIMvcnRb/Ifyo5PYNgKVGOLFvAJV1Y0vHHzoBVZsZpMGZaS5dml6Kz0+fC1EDY4vGIHAX4+ckkDKR3TzUhuf0sEtrRqaJscXikLY4zluKWBlo7m0bNnE/68ikkbHF4hE0POhjgmg5SK88gKpiqLZ8YWhEZJreLxMfKMJGh5fkCEsEpBzcMQ8fKfpmR5fiAGsEo57aMwsfKvJGR9fgOErE4wAYNQcfAFdrVJqqh9f84O3tFNxd12SAIubgf7ip1qJcTC+xoeuVYyxKwIUOb4voEuoeKXW4mJ8TQ/c0ob4WnkVQWJHF13XuxnRUpyMr+HnFVLtijODIkD02KLr5sHcUOJmfM3SapkmOPzImFnwQ4ij8TVKrF2qwBjERc2BJzpcja9Jaq3SBbXZOkTFzYAvMpyNr0FyrQpBFdBGaxETOT5vVLgbX3P0GjWOsmA2WY+I2NH5IzK4HY6vMaWNJKBj4e0OUQWyy2sSDz02jzR2Dl2OrymtzYn80TllQZwycomGH5lPEidXnI6voW8hMLlzli6AS65Ka0q7r4vXRxvE5ZUCt+NrRnNzmjLzSuvK46s104DKLwGOx9eI5PK0GVdatzrCVGDyDM/1+JqQmvXeO/EN6kwrrUvPAQhC5Buc8/E1oDS38wkPkWmYVdsU4fEOzf34OldaQL6OOs3yapkmNP6BCRhfx0rb6DSV9ZZRZu1ShUUBLAnj65Rypw5n2KThXC0T5Jnk1ipdSDSAEjG+Dkl3aOPbHl85b+piJs8gu1YNvSocKiDJGF9ntDslPJbrezLtLgk0p7RzvAStzUadLBQ6AAkZX0dKC1iZ1b/3eR6zxSzRmNTCmL1EuWGOf6CpwqAEjpTxdUK9sylCuOCOO6WmNJclCwG0sCRmfB1I7yW+tRZSDWluShNmHymY5OzayBlfz7U3xFf7odWM6Ki6xrrSIGLom309Vpqd1sUJcG/RmVgjYrMS0ZrOsc2oaZhs3+zrqYQOvrfiakU+k6+oNSE1vycyP8P8jkf3WObUtKF39vVQaRvS9ZBcxDbH/+o1oLQhIltDN9ll1bbe2dczpW3FKXzKrSnhlxsmd4cR7FxpPqGwbt1klVfL+scjIR3UzBvCMBdBJdmx0nw2rLSMzn/6+uMms3b1kCdQHBR/fF4Ck2innHs21od0Am+LtZGldyxya5eH/vEAjCPiW7AwCyKS7ZB1LwjF5PMSiLUVdY89du1BKowd5GM4dvehTkaaSjiIWcKdKc3XYiEe/Hotq4OsSe2LFKDx84AO2teHUM3FXDxxMYirWB9XuiOpzVhxDYtUg7OLbHHvMWsj2rpoX7tCRiRfV3eeE+n5UsO+pyxp7ruok/a1I2aBSQ0OdCfcj+4qO6Ir6qZ9bY4alSI8lxq4oUosc4DbV1Z0d3bUvjZGCirmErNU4bHShr2YmOfwmAJgOsuG1Kxfv7+DE+54dNS+NkVqizW8UYanGmrdWnHiLqKIVOLsLQtKs4EZW4QOsyFSWzlV142HSvPI1iS4iECvtPvLvdLgRGH1HWY1UgM9XdONZzpqpdPZmXmGGYUbHj3mWmkQySCH1oOYmOswK/EJ62nHI6V5fgw4eI/Dwv3oLnPLuGOkdxb45CUya0u2o/ZVjE+3Xp3ZaMMTLTWTWXgLqJmp01xy7pQXnc1/xNrS0FX74sxspc8FP1qkDg/U1Eo2Cr5iJuo2d6wbYKwwUouhs/aF3MYLUZwxCvGx1CJf7Cm2U/zK6jhXUvvUArwsiD9dtq8TcVsZlfhQa0AhSnI+6zo3UiM2JgbJC4ixx/b1w//7h4G7XEB9pDkoGozRggvRScvR4+WH/s8PBd7MSH0gOqTSg/fi2xGXX9B/dEmsfqw5Lk14LbVpj/tkZZwUWL67L6F1MaP1Q6X5rf4GXXirNDhZU3IONbpPpw0LVfvSL0uY14+U5hGV46XSICJSDKdsSoQ+mxWpl/S5GxD7gdI8ua7WjXcqeictE6l1zSmbMvTZqECFz+y+/8j+p76uSDde6eiZgTaAWg2j30LQ9lprvLa2ZjY68j/0tVZ1wfxWowxvlPSKEECA0HGRimPjrVmfMYuU5L8KzNZUdxvliza80NIbvCLfZCjdFqlu61l0Z4ya/FzcWLu0GPhkqcPnSrP0uqzaI489Oq3UzutX06Co23prASB749HA2gLTq/ihlBqQSvHag9x447QvZukDpokfSK25vMjdk+4fwP7LV4kLDag9QfsEKDZfWRziyLsbvvZve9jlnP4+ILU9agDVNtLe+8WhsPA2d5eZVlyFWG2NFIwVruLLzeYlyEHiO+DMWDXBGjNa2yIFEX0tMekFd5QXSt8xEEfKhphcDc1rS2zqKt6khvCKc3lJxJSqz0DZtpiRmhINIEBsPTp1lS2pIbvSloXvw7+kDu4SvlNtKCzXqYWsgPHw6bLmwxCtxeeKqryI7kkpU8TqKu4Ci2zt2VgQVyBSoVyhzW1obMWtMUbl+CRbV5Wp1VxjlUNB9MSAZrakUuFnDeAfoKSAH/fXBtewBCmPcTFLunZd1qkutUOYJJ8Vyu70n+NYp+whLoB3BQ6qz40xsGICzVSEV7JTo7nWpvIK9tJ9lDbvEnChsvQCW3eYu4jmYrOp3J4ahKThFmhtBLkBgdB1Z2C/FTnvCQoot4B4yEf2dbgDWLCyf4jKBxAIP/aLfxZ2QR/0So3SfT2v4uXyWFUCFgvgDlixou7BygVrV9xd96P/fgy0n0ru4nRepZFKt2wMsyzEoT9IqJZbQIXrDxsdZ+mpsOA2D2HElXOXRNdV2oZeKgZd+Pn64I25CVLAEnmb5Cla3sxQDdO6Z8uS6bhK2yR/UC1OuQ1QxMiTUtDsco6vdZQ4UrDTBqo1uq3SNvFIEFgE2mbgRGoEueO7OJ3C+XNlax/Ne0MZKU9P+pwSjckPs1YdDXZDYCLlEb9HnldQWKd25bWxMEZqLJZ1LgF0aEx+mrPKZvyYpqBEyvOK9TXGZRStIIwSN6/k1GhMfpw4YbiUbQEJVeJHghWIczjLco1/YK/iC9V2dYDvts86z9kA8rw1tAUjVgti/LD4AWSX2xDiBLEFXazi1WEb9FkDKUsRhLYRCI2BCNafYluwsdIUXhK6EVuAqtfjoIVKG4tf8MQDCIEObSpvawxCuA4s+w98ZEm7PciC5RFjbSv6rdZmAhH1AFswIas5APXmEJOVU/vYg6ut0HbJVAIIdFvJBUlI3N4DyK80K704EJ3ug8Tq9qAK1yjUN2D+Ze21ohOVf/sM8krzEYT2T4movH0rvn8XpnjZUnwmx1/7r9Mqza3xZwVGlPUQ6krzpWWi0P4pyefrOxFF7CgX6Hzn5t90WqWF2pRieEmPIa40L7Ycz2lRNYInZE6oZ+9IzwB9VmkbstVxuB5E21nyM46pGTVIQdx9pQT15ydhxcEE31GFlvwOuHZxf+/5iPlMuytph2mTr7O/jWlIi9KARt0C+RYXUSX3dVOhFc6if8M8j/mISbszZaeJk9o/2aaUKM1GlCvWO7YZh6vmv05qNDl2jhthSmTdnbDjrFluJyThpnRo7eAd5OGPZw9SGUh301W6qNnEFN7ykVRSBXSdJ+0MRkrYtqVCbK7ELd0iH0zLnTwoqLPsUWdDYbJ4PzfJNLdUBVmljeQWNLENxEkI/pF9fVsa5JawZDApfsAN9Exnda4iJOXbTksWTiVUFVYfCin5AGob2dSO4ukbU6C3wBqQnzy0+HgdOcySfxfew7GKiEpukJQNrzxwYXP8BWfp9dqW7W1DJFZ3HTXQ5nlZU0J8HmHJPiqiqTkUxAau+wD2SoNJDCNPNBjYYvEKNxADLZaeiO66VBVJqbkQXEEWecczuCsNIgap/RMR3Z6buVELuOLiqIyi0lxE/g6SoKiHMHeTN6lO0FErTrmJFHJjvQSV5vkNKcsR9BjervImZP6JqRFKHlR65tKTztI2IhjGxPQg1u4SJ7Z/WhrmSSEPKzmh0VN0IPOmc/DEmB7F2WXqeOO3ZBqi4wHQVEtNaFIJii8BBAhcD2PsNmf1kVq0RAa+5FirJSY0sYB7KtX4KFSP4+s6a1NlpBYtUfEAWKqYltm83sJyZ3E4ZhHFq78AW/fZwoG2WIwgdkLcFBHMmnP5RJhVTcpwVg8M3Flk57B6my0iG9srcJXaQG5Bs+g+E/MtqfiApmhg1tymlVW6ckqSIxJCvJQxo70EU8nRsd3TnbaZr6F5/pQgB2q2dkRIc0tWdMvJP+g9eGpul0QfxaA5CtxS4IqO6rKAhII4iV6EpdYAiEkgysq5/wkEOCbAGRndJW7sZfCNr8JRaTbk9KJnHLIeAc75N43njorw5P3xMgyFJtzdCDwxSQ8Bn5mdg3NIxHean9DEm8+Ow/UYaO6huaThW83OXnbSDD6VnkwZiepBwAQAc0rC95qbxeQMvB8tlhhVX2mSH60E2PnZLQVfQKd5LWY2c8NM7GAmUdTF/NqUV9TX5QcrAnR2dkxAf+VT34uX1eyYTbhCG1Iauphjm9vqGJEBOTe7hhed7LDL2B1ejJXUypMGRxBG2xnp8A2G4RV5FmGeT5oAnzo7BxddiDWH/WqcxLYxgvAAjd8e3pJrETozTXCHnt1Diy6UkLX/DkaiK/qwz03Da/ItgyowAoBBk/Av4SO6RJ2sW2LRi3IugS4oEmBhU/BvYaM6yckOy/CqvLuvZ4BIBOWYAFouwptCpWvvvsH3CwyNkFzD42UivbFW8xJ2DAiRgJyDI+bhlxQPHsU24DRdEFTCcQ+NmYVfV1TWhAGQCUYAMGoOvoBuJtbCpMy80tryd9iZSYDFzUB/8VjVotJmXGn96rUbIkCR4/sC+oZlvZYrZfWOaaXFO22dFEFiRxdduzq2FbJ++d6XUUqsfwyTalecGRQBoscWXTvdTK0psd6SfUeZpdUyTXD4kWFTWNVa2R2FNXSUUWLtUgXGIC5qEivakZnbYdJn/aTC1FEmqbVKFxSHqLgprGZXRixlX8FMUmC0Ag2Sa1UTVAGxiImcwEp2ZoGQPwrBELyZQHP0GnUbZcHwiIgd/muwOxukAff+8LhMEo0pzWG5LstG3c1UgTCJxzv4MSytPCJpuCM+kgsbMLBIU1qbibUtJYNOFgSXaPxDnwNWa64wlqWvDEnulKULQHQhXh+tAJhq0pJMZ5nR3JymzLzSwmdx/TyZaYCl3lZml623jEguT5txpYVxbeOdKkBp5fcyD14ygJg/srtMSM0OfhzEAjV1pjk1LO4EQZLK7uzKmrsIYfbC+suA0mBJbOJCu8kwq7YpAqRV/lSK5S4CImkO02POlTYlYcKc+8ksr5ZpgiNWdgormQevYJiLiPTfusyx0gIidphRZu1SBUYtRC80hKEugqrTnFLuVPTWWDJpODfLBHkmubVKFxS56FZ6YR68mLrNIekOsfwBJ5vGzkuydSZ5Btm1qu9VAdGLbuMmzYMXUcc5o90h/pdK7LGJL0sCzfFr9WdynWXBUXtgXrwTOWd1nSOlfdWmNWWRaghJNMawtcetSc8UXEwVCMU2qkpO6Twn1DubIsjCLM6UmtJcliwIkuHGpQcHmpMDCEg1pLkpnV+EAdAM8aDShOfaCyWAgFYzokvnF2nmicbNRRceK836EFyNWCZjUawR3Y2NiTNOtYTks7ThqYQat1ZcrUggcyCm1oTUTu/jMq+8hfwaD3mmydbG2WLg8RCpfk4/rqUpIrueSrcBpYEwFIBepmFPh2dAJb8Dpmtyr6d8inhLB5xw50qDiMI6yDTrCfEIiEYa0n19JDNGYbZQ7phxd+760r0kZwfeZBr1lHgCRRtlj2h5tUSWdKecu2fJJSehizNLKGz+Q51JCDrj8QCMFspPwUc2ayTnBWQ7ZN39Esyxi//JbpwhcMIYhGAJyMdw3Na1MFl0+U9mMBPuTGly9PjihjHDkkBzECxLD8mHKMnBELO/qws/GTPpjqT2RWqLCMtL6Q6qEo2BYFA+gmzDxZ7inYhtrtDFDQgoNeXJ8QFmfRaGA+29xHu/STXk6fFj1NJAPJeaBVvlM25YXqsZv6A2RsoW5KF4rDTYUjaxkZPv7WRijfgVtSlSIYbVA4PxVGZim6dJop2S/6o14ZfUhkgFRDoPVXRoJVVObAym14BfU6uRCrQZMZtnOjqq6IZiYwu3tSzBzv2iWokPXBCcgyrpoIA4Gjy4raVJduxXVTE+/oJWDUbjkFo6JmZ1B7W1LNFO/bLizJiKoq370RiOA6rpqIwUQOCSJNuhX1fIXSxEOZsB2V1qh3Cptokn669Lwp35fdUSdxVDsrPWIBKIcNTikvvI76vv/+//ALhzVpRdRbdRg9OCE7+vmu/8ub8ZeLNGU3YELVFz04MDv67iPs7jiMrT4k9V2Rw0Zmya8Nyvq/TQAq2SP5RlY6Qg1AfYoQuPBdTMUNnRlz2sLpsiBRG3Cqc2PJVQMlJuJ0cCjdkQnS23t9aNhyIKBspurNhTZVbjsyXdeCaogTFQljxmUor/mRqDMVqJz8eGqnyMMjxS1DwQRqoMRelwdY8Zg1QMUFivSs5h2vBEUt088EXKZc3GXGpMjgmyDb8CriwGjpy/1OGBruhC9bn+QKOgkLsRuFQhPlYWW6zIHUjtQS6eevKhtshi5fJipf2+rqvCfPWrxIFVlI/UxdWPQ9tVtkLfpf/a13rW3UKPB6R21BdVtf2p9N7vEX/01Xy5zLC2uAqx2lxhTOVmUe6+PyKuCssM1zIn0tpYY0QFd/Bv/JlWNBYpO+2pOA5em6qMp+JcabToWQsZ+XtoMSM1RhowgNiG2rIimkqbhDh5f+l0n4Ql1ZzEx9RCRirwftPWXA3RanFZGUulhXKKzvb0Jk8pR+1PgRipqVyhLaOzVhY/MSrX92sFSY9iOQe301O4mS9rzjI1ACMFF4ei1HwsQSpWG0epHcKJ+gpld05HjMfsLv058EK13SjixlSoN4pac+VeZGQn6+7mHwQuTOKoZ3QnixhDtZGn/nIszejtLdBi9adSZ7M5nU7AzknMCMot0OoCcAhJ3wEsRpdDBpyIt5YY/tb//64lavrrzdLWMEP+mER+2MwdsKLlKl/OxBsQaP/+//i+YNzUV9ogvfggmo2PRLeAChfkZZJvUn7gNt3acSSnvdICeuk0biwiG5Hd5E2QAlbSsuJBouOtscBOeaWFEuRDTlhI7zZA3ZnwMXcCdZJx09PEGT3dlRbEAu6JqRk4kQLg1hNJFaEBXD+tXAbeNZjxU91h8oxNpOizITCRgihUrAd6B7oe/CNMtwayR4DmThPHo+Ql0xSUDlGCnK2zjeDLdF6dNRF7DCjuOG3Si11bQEJ1YqVivSc/TJdmw7wJGCm/i97OcwYgJ9wWjFoLfGaEEL9H1mCR5JYN8EIVbRe1DWSL7y3p29AYiN5Wcf8TCPED4JbvhAsVoO2jtdIcvxcFUTpbT8VKGoNQbgedvaSNB+GCO6DFyqHtpLTWZkJttoJDtpHmANSby/9p5dTWO4AFy6PtpbPkgqS8EdkRPID8ijuzgdHTATIXYPHeL7Gi9QdtN0vRiSr28QjiKw12kGbHZ2CnA0CG3HELqHBZtP0clQZh31fIXNBDSK80iPwM3abqQ9bfBClghx3AUGlTQvIe/gZJjyG80PjtDT5aB6pGAEVssCP4KS0gWx2H60G0naXPOKZm4ATKnt9CK7dD2BnM7tXSwpaXwzA+VI8i7TBxlfZPDYHpACVoxfqGuAlNOEX/i5h4YlQPo+w0a3IfLQhNQYnUyQK6rNAOM6HREhRe/dYQmB5H2HHKqj0CLKYpIVAdvIM83P1hvIAqXsDdxb+tU0kD6TpP2hYk80u2LRk64yd+w0Z/sMNYIfUaB0koTBbZ9ocvy3iYSNZAspAY2IZ8d1nywrZEqC2Wbi2BBEa04zhBFcY5nRHCmF0q9kV6xcVIqgq7MhTScg43s6d5O0qeaEyC3EI2N1bAYgcywiwvvf11RUQ1JylFGOABvxogNaH9k6NFqXYkH9DG+IqB27fbsosjoSKamkuS6MB1H0BfaHYyQvung8jboWxAK7yg6/ByW8ZBVSSlNvjJUSSRdzyDvMyIkQWp/dOHXpgfywW44jKvjKLSYC8m9gPsRxD1EOpO8lYfqYU35mhGmA+sWoJK43c3ouWJCXoMcUd5E3KXZ7e12uPhQaVnLj/kH4JhjEwPou0sb/KLV2OewMLDSs5gcqIzkD1F5B6DmdujSDtMnNz+6RkcPACaaqmZzA3QIB/RELgeRtlp9owlQ698BgP84s++WmJGU8NqD/wIXqPkgMcRdpw1XxmpxUPwPQCGqn+sWmbTkoAP7u4YmEUU+38Bus6ThpWRWjwFHbRTeVlU/oOVkpontyN5cTcP8WLhJb5WVmlDYrbm2QeYvNtjyXBPwQZtmIOjH62S5OjdSB7iZXyPt1VVHDG5jeb/zYSc4Z6DDNoQt/DhiJDostK4Rf5B70FUct+S6AY8CZdbClzRUR0iMQC3RFKP80VoSs1asrcRZeUM9zBUjglwRkZ4/M9fIuW9Ckml+R3xxzNOWU/D5BqeOyrKC6/1uopCsx8ka+CJSXoe4lzlHJxDIr7TBHUm3nx2HK43wJup3ENzScO3mp659Czui8QTZ0Sqd0CbpwQAc0rC95qcweR4GuQjGpYYVWdJzkZKgOWWgi+gaF+LmsncCAEEKFQ9pCuvtq2ZCFCOCeiPfOprETOaHbOVIKaMkuF6yLB63xsZkFzDi072jCO82gNrKS1kJeBbgD+LI3v/y5geMiwL6iuaADkHF52vlqS8GimtbaXgDKhYiJexmHEPGdJLfzTBwYdm2eZ2/O+gpLmiI7J/mN9oyMNUgREIDJqEfwkhzbE7kW4jn/pOU56lC4pCWNgU/FvoiE5ysm77eqsxj1IGRCIocAL+NWR0l+D95jwqnHXB0AgJHd6/h4ry4j/ApnHudIEQCQge3L+IiN9SQHqY4b1z2n6BoBKOe2jMNPyeGghC58n9AkAmGAHAqEn4AmrEWph6xrzSQvk7vJhJgMVNwRfQssKJRdU3xpXWrS5mEaDICfgCuphpxSq79I5ppfl51gSJHX6hmwsvgs97uGldgyvWQhPrH8NK8/QCTREgevBFbi6MY6OW21lwEt9RZmk1TRIcfugFVgi78FoFFNbQUUaJNUwUGIPAiwtNglZbSe9cD8LUUSapNUsWFIewuwvYFHh16YCyy/6SFBiugwySa1ZQBcQi6OF2xwT4dWcTMiTiIvQw00Hm6DVqGGXB8AjJNfxCe3ZIGnBv5D3MdJExpQ1YuuZhVjc2qkCYBOR8bobvNGg1FhcxVE7omJ/oJFNam8nI5uhJwUXXHhBcwnEPfdDdu7spQhoQNZiuMqS5LF0AomuSBABTTVyM6SszmsM0ZeaVFj6L6+e5MZMAS72pDBKkt4xIjkubcaWF9afnKwKUVm792ReQgVgqXHeXCa2BcyAWqKkzzaldyQgTBEmrQJuSD6KL+GA5wPeXAaXZwOZnuJ8Ms2qbIkBabfzBPoQfyabkT+0w50pzURgGCnSTWV4t0wRHiWd3K4aTNIRhLuKDWJrDdJljpXlE7DCjzNqlCoxWvErXhzSEoS6CqtOcUu5UmsEMPhZMN5nk1ipdULQSatyOZSEwdZtD0h1ifyDgw8a8JG+lhzyD7FrV9aqA6PGICdI8eBF1nDPaHRK7iD+ItcX0mePXmvmUjTpZMLRaUB4LtecZMKvrHDHv/AUEAp8/vCWFxhi29rg16ZmCwVSBkIrFLd3YBnyMtHaeE+qdTRGX5mBRoynNZcmCoNqQSLGnHhxorhJAQKkhzY1pwgCo9mFShOfa8+V+tFYzokuTZp5uVKrwWGpumqDGXqYOR6wR3U2NiTNOq7FCylKGpxJ6fLfiakUCiV+r1oTUbNjj+Fk6OyDPNK02DNXE1OGh0jzS9RBcBNFijFwDSrOLMBAAmYZptZX+ZrXjmYyeSeRHz13EQkvUOsy50iCisA4yzVLoQnMY7XgkpEdOIK7hoB5DuOHRY44Zd+xYfLqRxDeZRik016Ufh0SqyyeEl3hDkUSeZqecu19C/MvXKf1LPYzJBl7UaWZMXXUuxuOAYLRRurtms0aaaoesu2NeNLy35MTE5PkC/FyxvSUgu8NxW2OTvw9eL/lPJqbbGe/u14WRWoQlgdpdrR6/zBBIdobqMmdzRHMrb5RpGWzKHUnti9QWqZwaKD1HF+9qKTeUXSFLmsprinYnYpspcgABpdrfAqKm7IjZS6w1w3CgvXPcQKJU0UKRMbqyOWppIJ5rzdYZ4pYxtUpWrqtnY7RlY6SsQB6Kx0qzISHuTibM87K+iVXMGJttQ182RcpHqCYG46nSINJrtEkijMn2EdXKZf1S5lRCYzZEyiNqx0MVHRui44QxuT5ar1Y2JHKNpTOrkfJIFjbPdHRUaXbFxlahOC29RE2wUhBZ9CylWQnQBcF5pKRjIqa38ZFaCPejJYuV1sVVt2U2WlKMz2brqnIzGk+0dEzM6n6orbH70aKlXm+92Au7L0tN8hA/riubJG6N4XigpiPirmZlf5rk5kKyRXJ48RQ9ewhFgQ6v7OrXZbDx2B2qA7Ec+HmPPOKczAkXiI4a7DDXVlUh7ipmRHbGCiIjVM8EpStkUvEP2vPvf4T4q38VZVfQmLQgEFSGKmRLX6T68md/6ccC8T5mRdkRtESlB++p3/1BRH01zL9tHFF5mpqqbI4alSZUqZypTxWfobA6C7TKTlaWjZGCUCFaozHC55ZsKVHeiFVjGSo7+LKH1WVTpCDiVktMG+JUxlcRKr/R0VMmR0RqWBJmL6kxGyK08qvA6UYbY8uNik/ZabBXhsJi06bgkhwrqcACCKjManzKUdPSjSTbD7cVR5zFzx6RGEwlA+koUguxsDhdaEzOaGVt4nPdUJXDKEPUzeRxpTvLJ+TrYY2poKFWAP47elv3mLfGIBUD1K5XJQ1GG3LwIZ99O7LfDrqk8sBumpLcW5EUXL2efl2iBJpZsUtRpeHMUocYJkjPbkaqEcC00CmnugJdqLYbNbo4UYd4rcBQIT6k+dbW/otaTVqF3XYRtlhFcgdSeZiL2pIxlxykhoinP+Du70EWK1sLILCuq8L8m68S5+2pJymMYwM+/whJ2ztwBQtqdepVDiDQfe2/9qy7t5gxmtIyj2RjCfTjDh4L4A5U7QC2+69yXqCv5uEy98D3ydWVhFmE+8OpfAskPfCxhGq5B1O8EuIq36T8KCwzXCczbQmYQzbcpOaKezlfzwfQXkWCO8TmxWO55NZYqbk1pnyZpi/6ky6ul1qIw/16FOfykrzQEiqKoZoylTbsSI78GgPQLDcnn1tmqxqleeGO819SRWjy015rLPGX//9TpNJ8QrrUuBki/cnX2T9tM1aL0jyJH8DtTljTUHs2lkSlDcWyjmm0psLUGiP9VR7rui0lSvOVivWzEN8l79UagUqzETG6C1tzbc0gUWQMCUF8rA6pHdX4AcuZMK7FadTJk5q/0XkpJvUNXpy3BnuwColV6ldPrHXqKvr+S8Rp7SSdL+mO+BL3jZa0lDhYg9pi6dbSs2R3f480rdnahAafTidgJ8Fzho152Yj4/WMwR+lB+GgFcgv07jN8WNIr3CFMbE7/AALhh//3DwueMYBAZdlsBbus4/nrzSb+0JNsPc0dstT2pyy6BxAIP/R/fiiYaB8iMQrxE9grDYzQ/ukgRndaT95nbhElN5uXIOa2+foE/Q8Lhp26iSq/fQZ3pXn00mW2kJ7/WGPukSS4k9c3YM6m4y2onTDcjhgDI8l6CnOl+XI0kBKWz9fvEqS4QMxM0Bh4UzthLKy8k7FJeg5vZ2njO8xztSJHaRbkOgjRW/q8JMUVrmsgUzthbMLsf3C4nsTaYdqEF9NbHO2I0RnxKSsIM6bH1oqDCdOtQUzshEGOAcvoY7l9zIhUz+LsNG2V9k8tSfGkEGLFeojC8rr6nPAAEzth0FN0dnfKMouhehpjxymrdkJsmhIitZPHD1igWM9M/Esq49FahZfYCYOWoEjV4wlUz+PrPGcWjPDiw7QlQ2KVizMeP8CRY8Doh3IQ2AAusROGWMA9lSCmjKI3YGsgZSfZW+yizTUmwtsq7n9yG3u5kNOugZbaCWMsNuK5s+Dx0uDrLRnPVWlDsbCJuHepjWIsb2tMgtzya79zDtkSjx9wB7D0ThgzoYit6ZuMOvktmBpMcKxlibMVHIovaE2A2MQ7Wx/uY77vAJZqRUcU6vm8CE/JTZIQg82eoD36ijuw7L6NBrIlVncHrGRDLDllWE6qN2EpOkGsv7snkFca7CCO1GKj9uZIX5a3gEq5je2jKb/jXTgqzU7rXqp1zVVZ8xDqSoOIEaT2T/L5+k2Qks6/NwsaKs2lypRieFFPIa40EI8EAZGqEUA9KvyU5utTiuEFPYe2s/QZYGoGTo8LO4PJSesnLwe3tZXpSaQdJq7S/qkhMD0y3ITGTtHp4Gf4/Q6mZ1F2mjix/VNTUEIwvBczo6mRAwjMXE8j7DhlF4Ze2RSQAJBPfS9eZnNjnBBAYKZ6Hl3nSQtBHqlFWzBCkPVmrJQ2kusy7izi4qitlXz/BmQNJAtHdjQIhiecwLQFId0Thg3/UoZ0Mp3UHBGBbAAL+1AG/ZZz/TtQVdiVoZAGITYmmKVYSWMC6J4wmtsUPDHS3FLhI5nhaiGquaR8fTgtY+Rw+pATxtT27ImP6OJXw2kYs0OriKbmplLpBgTuQN4dJgwZvtiobs7uY3x6G+P6XhNJqTXnc0iVW8bHfai7y4ShwhsX4Z0KI6+2QayotOYt2W5pyP4Zit2JuDtNGCL8MVFecXHURlBnxSufm/zACt2NtrtNGBo88vClpmcuOaVrnjOnrDuSdscJQ4JPFr7W5AwmZzpZiA/8YPke0u5K2V0nDAVeOfhiUzOZmzbbyIcl8u5M2J0nDAF+GcgvOdZqiRlNTfb0dUdLpd2drrtPGHie8fWXHGu9tMzm9RZttpbN11AcERWQVcGEAecbXXTlkRaauoe0lNS65A6ppXeO5Mu3U/bCRqugqooJA807tuj6uXU0qJUkV3xjX7JXAVYJUZVMGGD+kUXXx03WOiIkumRjH8OYH1E9NFUzYWApwIVNgSs6qpvnZD07DWNSRSRVNGFAaUAFToAzMrgV1rO4pbyqKKpqwkBSgQkdnjsqwJWXR2UEVTZhAJ9S6UAED84hkbH9mNJT3YSBOySpBA8+NJc0RvajSk6FEwbsjJEWNAKBOSUxrh9XaqqcMFDUYFEIyy2F/cIHwNRUS0ylEwYIqXN5tf0niaDACZxX4Zcca7W0VDthYJDq50HTsEVCh/cA6JaffMWkVDxhQJCKd9rqNAGCBwet/XJtaFdNaauuesJAUGVW/KQJDj40QUDztR9C23TlEwaALsNUgREIzCkLjuhs0dV/W/OUmaULikJYbjlwRWZ7dvCNjdNmlDIgEkE5ZsAZla3Zxbc2TZ1RzVkXDI2QXONzR2RbdvLNDdNn023udIEQCcg5OmZhHIObb28Wo+L7tdDnD8XZ6IKgEo57bMzCOAZH3+AoVm0irVW2BwCZYAQgc0qBq29xErMsZeZVdxvMJODOz24JcPZNDoqOqm+MKw2iL36HZiJQZ2dweLjFnNNd3uW9Y1ppELFy+1kG5tyMDs7hNzomNetDmIZiqjSx/jFMqmHZMyhCfOoMD83ltzqltGFng4xwHWWWVtMk4R16xgfm9JsdUtokPs1JRxkl1jBRaJduCITl9tudUVogrz/oCF6njjJJrVmysCgE5XjCGFFaYGkb2ArAGDvIILlmNaqQSITkesKYYN0dbphzmUU8Q9iM6SBz9BrVj0EVDo2AnE8YA7y7I04NQCKm+teYLjImMXlmLP9jVjc2qlCIhON+wjhXmsPKZACM0qQqd5Iprc2s7VPAOS5yVRhUghEwYRxrba40UwTSKKarDGmOSReC5polCRPGqfT+kC99ZUZzSKXMvtCaL4rr5zmImDAOtefJP3eWEclxabMutOY2j0HQhHGmNBu+9wkqxDLzId1lQmsWwIoFaupsU2rYPL8omjCOlDYl0h5mEF1EIP/dXwak5kkEgR/fT5ZJNeyiacI4UVrgc6Ep/cjuU3WYc6XBLjzOCXSTXVrtUjVhHOjo2fXWS7GZ1TAXsSGW5jBd5lhpEBE7zCqxVumaMJ4rLbBjwIfciKQugqrTnFLu1upgmGLBdpNNam1SNmE81tITvCGMITB1m0PSnf5E23QTircI1NrGYPIskmtV26uaMJ6q6RHjpXnwIuo4Z7Q7I2ywTWyO/y4xffboNWqaZXmop09FwVlMPANmdZ0j4l39U1cxPeKAlmlSoTWlQUy26pM0j42qCeOZ1IZUvvD4aXrMruEJ9e6miCsNVDXaklxS0DVhPJIcFRg9OJAekBr2PWVJc0nKJownmvswKcJz4QnTqtFVdkQX5xdtE8YD1VGpwmOpgR9BQJi2B9NZVnTXqpswPlaaq5CylOGphB7frbhaDqvO6U1v2VCandZ9//alswOqJ4x/U1rAUE1MHR6K6O2eNZ6SixhoWt1lQWlT4gMBUO9fSgvldE07nsnonVhxEY7ep+ow90KzHxTWQbx/Ki1Q89COR0J6JDqhBidEKexHj7km3PHtMGkNCzGyN/Vf7Gu+IPV4IqU3gDZQRSNQcmGfuaXcqYVs9FccZKdstL3Yc+KCKpRFHx6I6QlWke+nsim95pJ0Ay/FdF5212S0xRVOni9AshdsL0shPpbTEzRA4irnwH5zR7trYmDM8GomUL5LJ+nLjwLJzlB9YX5F9FC8EWdYBptyV0rz5Bb0tZFaSMTeVQzKrmDNmWH1dtba3WhtplQCCAjFvo8hasqOoGVhuBCdHEDg6fFFUwNV2Ry1NBDvtfcWNyz//LAn+SBl2RizPBSvleZ3TPsgE8Y45p4hWzYuddkUKdih+gYYbyXUurVi4AiVOJ8dblqLW1CYDZGCiFE5XgrNnshWx4GYPoHw54YvtrEanVmNk3C6phvvZNSuteJYbkEf3NZKu+SL+gmD77A/iGRRmpU4SVfTyvFKSC3ETOsvYuS2RqXdjIdca53raGTKoiXFAM8AsMwkFXZWGRsab6BoI9YQJhoCk3gDnaV0nwUX9nuWmuSBfly+F3VJTgqNF2C0EHc1h6EQPTfg6pE7ewhFQe5iIcrrMth4fI7UR7gu86LRzTnDPTm268M2UBXkLpdyE/kUkNvWdlqqRTyjo4D29clozz//EeKv/lWUzzAr2oz5PVEZqpCJMYK+fPMv/fPAG5hZUfbELFKpBNhX/qscJfRd+vmbYH8ZeiKjKtuDRvWbApHsUGkoLArrYoFW2cnKsjVQNlRI1vyqOOTathviR2MZK3BlD6vLtkDZE7cK5++KIN5FDhU/YfUUKRtiuUzTmC3BuVDf+j/VMDi2GMoKZQsWlL9bFZvGJMdKyifEsqjMeniu9HGoGcYk7F5+bGTc1704jQiVMeHpKFKBxbS80Jic0Vp8Lkg1DEko/mCiu9TXnkSngoaCJNhXmuFaY3JG5fj4uqpo0w6MSGDHgdUJjzhCnEbOMlX00yrC21tfa0xOCTRjKkpwwQJnYzQDZCc8/qRxYf2svuSYC2gnVP5GnXpO1F06G8j7/reDTaWn6EitZpW8xTV0E6uTPA+08kD/+xrm98OG+E36ayHrt7sHWVtBbkAghGD15Sf+NXGzPX9nOPZMUIF/mrd34AoWlEX5AALtf/y5N9i7fBUZ81vjQFoOiHjwWAB3oIqWJTWs5WfC0lfT7ffNPeuS3kru+nUxSvNol2zRbGCLxfXfgylelXH4b4g/CquxC63RmF8XATfpxWsRP1rchShgS/lPsZDFaywjNYQ9Tsb8ugjMH/A0JQd5H56IubwkanSuVMEWq3lxBgo+tIGq8ohO8PDA1A6aSIFwfv6XVBHyzn+wMhSW16mlDNQQkS5VrLaITnoxKfpsSYvSIEoV6zeUVl97NpZGoUHRsfjByCTnAmlJrnad7dpSojSIYvwAMwvxXbLB1ShUWrG1C0Pwb25LvARXrUiwmLZ0SG3FSsV62M6cxDFZY+r0Kc0TXVuJSQ5GaUuSbUyF1lxeJvqCVIkfcIU6qe0kgMD/DCguoheDf5jGNHgcxf2f/Elfvvt7tGktVXqaBghPERvZApHfP7ZmKY6+NQVym+gzQbkPTxruUKaxy/P+iTg/R4BQm61gl918e/z1ZstZHP1M9oO9Q5fYAOUvf8jk2zxPPpJoNcwnsFcbM7CDng44z6zuDlU+qfA7tfBk2HBPFFHFxT+Du9IgeunETUjPH3k/3qNJb4dY38DGcpPy2eH2hD8TI8l6CnOdURtj0LiI0v67S5HgvNTvrP2Q3zw5XpCsp2VvkPQc3koDsQTFcbWiR2jWygO9L5dt1uUtEDPcuXlK9DNbg2FwPYm1w+QZk6jaUSM0ewrxAyDRSzXEioNpptsTIvkdcIw+lupdjJPqWZydpq3S/qklLV4UglSsH7nh8XWR/xTszGzs4hqYxVA9jbHjlNUSnkxTSpS2oVyxHjb6j4cz5ldD8RIUVv1SeMPz+DpPGkhP1BBNWzqkNiEmdrZOk3bek75M/5fAjRdcA8Ti1N+ArYGUbRHECImNqVBY7eLMjUc9fsAvh1McI13h3PrP4sg2/DXmHbgqzUZkpSib1PLpKC9sTIPQxGfBgo0lvcCviEtCvE8RV1K35y2Y2s5rrG3ibAVPZa+1pkBujoX7WHj6q/09QS61+T9s5kV4ak5SwmDzPmuPv+DyyxZalLpEpFb3ayKRVjFui1RvwlJ0kmiAlyewF5r9BuFbskXemPEoGe4XBTJDcEt+x7twlJpb1gmyrVVE3vEM7kKzp2BX5fSviG6PMb8oKk9W+DYMVSYOT3jibxD1FOZCsyf3KvRdYk8fvyz8e/FTGsTqlGJ4Qc/h7SptQu6yzMH8vwE7g8lJn0OeUozA9CTW7tJWHamFvtiHh5vJ9G6H+UsaqLI3UD2Ls8vEie2f9MWeRsG9FzOj2d2taHmg4ZnraYzdZk3+dpimQJSMQXHf78XLbHI3kwNiYrZG9Ty+rpPmgxhi3naXiS2DQXbeb8bKcFbvzXFnkSagtlb20BuwdZ+thWZ8DHInxG2BSLbVS7rfjZPppB4RirPgYR9cyTVvyXiuFpJ9RCCiGd+CWUqGawxCsg3zyRMjzWUJayqW/xZMJSfpjOByhmsOQM8hYPnkiY/oym+HcYsstRfhqTlJNIDAA8jvSQz4YqO6orIRbiN75k1YSm1wQJFVMtwjyHsWPlouwjsX1praVkBHpfVT8vAsmVDsTtRdR8fLRHnFxVEbQ6E1n9mVz01+YIXuRtx9bMQ8fKn5Ca105fO7ZdqsO9K2EBkzC19rdvby+2lkQ7wOuvBbIu2upG3ERc3BF5ubxdx02fP5C4m8O1O2EhU3A/klu2qZ2UxN/vR1szPyaXcnbCcmcnxGIf9b1MvLamKytWz+MmQnJq5wFdC1FBE7uuhC+TSEuldHK6Wd52XXJ6VPsOMlDoVmmWqqIGsrHnps0XXzydEK6aS1LpFUeKoWcdRVQtVaNPzIqDmsaUeMMIu9fxSOqB6i9mIxiAubwnp2xQew0m+D5jxMSRXRtBiJQ1TgBNayMzawFdaz8zLVVEXSZhwWMaHDr2N3XHArL4/KKFqNwiMiePAvwQ6ZeEgJ2o3BJB586ENYyDw8qPQsR+ASjUDgU8DQLDys5Gy3zyYWhbCwOXgAnKqlZr11pZ3Kq+2SRFDgDOBLjrVaYvbbZhRnRtQICR3fA+BS9Y9VC6FlpXXzPL9pAgSPjln4DH5+sFIY7bJq1xhMExx8bB5pjGw/lFBa5dUyUWAEIvPJYlw7IoTTJrN2yYKiEJdXDvuFruggtcitVcKASETll8F5FWdksNpj16qTLhgaMXnGvy7JHZXRTWuNX3uyBa4LhMgmS5yrfKNfNuqQyN4hry2lNVN+hEN87510QVCJN1N5x+aSxtkVYktaa6M+7aJsDwAy0eYp/8ickrg6idmO5rKUmVfdNZ6NVIDLLQXUVkSXps240iD62rzxaEDlmABuG5rLUmdaaRCxlrlUYHINj9yC1JrTS38OpT3oM0yqYdkz9Agi5+DY3SvNBlqesg8dZZZW07oEDz40766V5hLyNXSUUWIN6xQ0AoH5d6s0X9JLMRGmjjJJrVndgkUhLAUuOfekkrd80nAcw3eQQXLNsr2CRCIoDe5Y93wopjkvhyGc1nSQOXqN8hFU4dAISYUr3j0XKa8+56jDkdVDxpRmY7kuY1YXG1UoRALS4UZpA6L8rLxODPjRR6a0NiP94hHLLleFQSUcJe6Re0+5CMFm8uJMVxnSHJMuBNElaXF8zVWWvjIjOipl9pX2UlzKXWumxtG158jMLXSWEdFR9Y11pfXz2nLW49hKs9O6eqiwkZkP6S0TYrMgMZjesa20PnnrvLQ5sobatlaMA4cZkDf9ZUBqbi3Wtnt+vdY/lpXWp1taE+e4SvN8gh6kHwN9WNMOc640+xEe5wS6yS6tlslzVB21UlqjOA9eKf+2NIfpMsdKg2xmHWaVWLsEOqaS2ui0dB68eCkoU585pdytwzu3xYLtJpvUWiXREbXURuzxTC2Bq9ccku7SlzAFjyQjzmSRZ5Fcq8KLQPurqZGMk+bBi6rfnNHujhdblidibUX67NFr1Dj3Au2tp9vvsNw/rDwDFvWcI+Id/rk4RWlAtseYQmtKs5GcAKajbmwE2ldqA2+xZk8Ua8xn9Z0TqUGslJuB1EBVoy3unY22WFzkAu0pOaLKdXXvOdAeCSDQU5Y0lyXR9qJjUoTn2vtDAgh0lR3RpYm0teqoVOGx1OzgbI2FzAFuX1nR3TK/yLSt0oYaWcrwVGl2IQP6syKQMOe33rIhNbd874uXTgeE2lJpHkOFzajDQ6VBZG2eCtIHRGO6y4LSHDO2GHrMeqX5EkBLO57J6ClEwUUMkYR76TD3SgsorJtia5Xm6Q0K7XgkpEfSaMihgB4lhBsePeaacNeO9UOM7E2xcnxOW5d6PJHSGwPr8cEQ+P3oPnNLuVMH2dNfxchO2Wh7MaEKIX7UVeW0+vBATE/winyVTek1l0oL4tmeY4Exwxi3zqQUdQkuxoHRh4/ltLNNj8gDsajf3NHuFrU3VsE+vJppxRxe8YpDlkZ8KLPCn9WeOwu+gZDVc66U5sgt6OpILfR+DPME3FWM0YmPxHZJXIk+3HdutDYTagFeBH/849/8S8D7cFFTPhAdkxpc6I7Pj6bkT98x96S7kaYGqrI5amkg3muvm+dRcp0NqOxJPkhZNsYsD8VrpZ2+GL98D7nChuU1Z7Q+OX+oy6ZIwQ7VN8B4q7Q+u39qLttn0Bwq8GHMWUVhNkQKIkbleAlC68bkp1zSRXOk3I7l0kpnVgNUM67R6MY7pPrkUeGH4jO1mL/UHakFkSxKsxIpiPQ4oByvkEpvG7T2TC10V4ZYPCZT47RaUozPMdRVZWpovEEqvelmvoGXhPBITdk0TnchyxRpSR7ix3Vlk0S8MzmNFziV7/jUxUfkSckOT4tTdMjSE+QuFqJclnh8jtTrnD9vg3YqDbqL6FD5Gx1Sagpyl0u5iXwKyG1ruzXZljALy1ZzrHZSKV55/vGPEPdRlM8wSzdUrD1YqeIe1n0f9KX/pa8F4n3MivIJaADRwsqSjcapu3TznxxHVJ5amqr8HDX94YrCDDTyIZLqq8ECrZK7lOWnSI1rgvZ4HXJt2w3xR2MZKws272J12RapgMPqgSkP2ITSN1fxE1bFJTkiUnait6EVZkukQjGuVbojZouhrCSjTKkSgPbcFFySYyU1kMvq1ajMeniu9HG4SnWk/LeTO0HD72VNpFfaitPUUUWEh0+WC43JdWRtfAGqawPNHaNkiogemLvgK2lYXEFDkQLyLw7slcbkjFj/Pvuqa91Fc6RGdhhYQaruwwZKUkU/oYrkCRqvNSbXEpxaxpkGs050qCbhTH0nO9wtx/GZ3TXXqZ1Q+RtjYNUT7PDCvm40x8qW1opbolYzwU3nqZtYfRA/xigPc+kSmqO1lJ4bwLO0V3cPzQQrVUb1Nnpv9eVHf5a4zZ4E/eFyrDgssKR//C30Eq0yuSvKBxAI/+IXv5l1OY9FxjDUB+wQBrPKYwHcQivhQvkLlObF6mocv3nuWZf0VnKXgPZIibWtky06LWyJ1MO8RRNe2cYOcc9jVFjBLrSyRxVR3k3+M2JCXIlKnilloDcpAmwR+gmn12urxjJSdlr3vIsr6K40LwX5CNXilNv0IAZ5SSNTpYWq1VNi1fAmgK6miupK86J1WK5m1CAFQs76S6oIjcMYUuX5kb/SQBkoOFkAgSqN5i6zVg1o2pAWpCCW+AE8q0jrXHv0CsZAQSRtksNoalw0d5uzSsLONKUEKYj0DG6gP/IlfRlTgzBSG32Extra3ER3nTTx22Ha0gHVgpWK9UDaqsY5O406fJGCy2Ng1dx9yuwoBv+wjanQmsvLRl8QWRAuILZ2hTrr6P4b1dBCxk6+wy1padyYBrUdmPNGPX7AVdqwOhEnLZRa8QwbuT8hzPeJWUp48NYUyG2kZuYO+kP09g5lYNXuZ5Void1Wa0DIEmcr+E/pvaE5/kqrXZxtwmSA3aLLT0Pb/VdZoNdqTlIpZrGPuFZ7xQXEgyiNfyO1ujtUyS3xkVrwSYvqtaIThWfWI7grDaIXp1F2Y/bmz+z679Gkt0NulPrT72daKa3px7h7TkUPYa4zamNechPy+fpdigQ3ik4llELwPqu085Rt4YP9UtRjeCsNxBIUh0jVih7JHeQJKi89L8kfRJXWzdnHYhiCHsTaYfKMOanaUaO0EBdgezyRU4GfWL0P/de//kFTaV3yyIZTcRSWcTA9irPT5JmJBHhpSYvSglixHiLy9bC1Z2ORFFrhLLoraTKLYXoYY8cpqyUcTFNKlPaFcsV62MT4LjUUhVa8BCWW+xMEpsfxdZ40KwX/SKYtHVLz+Xdy/AA7hjCV9C8gaDc3ILgGiEQvwNZAygLfW660lGhMhcJqF2fOn2wwLUJE02voKa2NY+SlcG59n0h+h499ibN1VZrNFkZzQJDuSR3lhY1p8LiM+5/cxpOGO8hp7RKHSFe8niKyEXa8BFPbWY212mwFj8XRt6ZAaGL7J3GkFrjaG6hpLvlTO/EbyW/CU3OSYs4O2c23x19wB6li7ct7I9LQ0zcQE92UbNJ03Fhqb8JSdJLowHWfwF5pk3h3w3pqb/4sPQPcQkt1MWo6W3nHq3CUmptCKe+cKyLveAZ3pYXsVKSBlQjn69lqbiIlvOm9btdQaXYnF2kTf4OopzBXWpC8SsBKccptlKTn34ufzsSbzyO3NUHP4e0qb7OQMO3wsBlCvtXsDGbnJMOr4LYWmJ7E2l32jFlIh4cN0fG95mYyNclRGwNua1TP4uwya7WRWjRFxhfQ+F7MjGZmkAesO3M9jbHbnNVHatEUFfmRT30vXmYTU3vy3JnqeXxdJ20IQm5DHNoi4guo2MCLsTKc1VuMQgwm1qZ4Lk79Ddi6z9ZCHTwG8XFJTFs0RHdeWcNf7oSdTCf1iMBaFQshXvL+eQeuArsyFNIh8QAv1oTytsZIiK5f3VbayzHSXJawxtJ39FswldxAWiWzOIk2qzkKmkt/hXviI7oyyjvvP3kh73gRnpqTRAeu+wACuBnwxUZ1RSQm/JaKM38TllIDsAxRxdU8Ah45Pm9cdCfZet4v78JRaSPpDxwYTtRDwLGj88dEeeLueBuGSgvszgYjgqDHQKPH5pGHLzU/aykqbWA4TA8C5h8ZMwsPKzt76V1vHdp4eE1mSrsrLAW4qDl4YLlZzM2l8MpG0wNLE6uPaUDFzQC+5FirZaaz8gXcyQYEEmkKvRRHSFhSgYkc3wMgTt/18lIrMcVnI5WKU41C/eqflDoQsaMvM7SmvCyWybtmVkh9XeG2m+2UvmskyRc7M4X6ZJFpwkOPvcTQ2mltk7V1c8Kqy7RT4QWBvcXBUAmAwUwUGn7k5RVsaIt2xAiz2Mc1f3z4ioYvgSws0XVx0LnlwBMf0KZkkg3dNVbVAN4nDEl0XRx0jhnwxQa2fD1rutfKhvA6aTgsYnKNzxsX4PpqB/G6pheGwiMi5+j8MfGQmvWR3QJxEIbBJB732Dzy8CThwaPSEzAFYQhcohGAzCcLT5ekVtoe9tnEIgGXVw7r+QFwUitLmnWlNeXVdjATgcovg7XML041YqWJs620MK5duyEDk2f8dfwAWKYavc5m8iwrLYzz/KYJkW/0fSRmzRdB75B2y/f+7aFwYALtsmpVMsA04fGOfY7BL/66Vjuo3c6fybURapVXy0Sh8Y98jY5PDtQO60kcBUoQapNZu2RhUYDLK4f1rFUgfTMuC0njZkItcmuVMCQaUPllsJadmXASKxlLd299pjeB9ti1qtWFQwUmz/jr2J0FVnpQ/MkSg5lCa/za1M+dLhQ6EPlG30dyaIC8FW22XSaNtqQW/y57K4wzXRiU4PGOfY5BK0jFRcgP7ZmfkVNpSWttHG19UlzkuhBoQeMf+RodtYZUKeMe406rHc1lKbMP2kdMAS7lhKf9EGtFdGnarAPV3LriiVjSgEq9U/Lusqm1obksdbaBam6rf42rwKSVW8s8eFX4TF5vvFwLWmu77tSULlDTZ5kmw5a1SxEi567uVgzcRQjVCAS7V1rTp5enfAahdqkyTRIe1wKydRJcBLtPpdi10sI45x+9UKt0GSYKjWrkGHD4QBrCMBexI8a7w2h2y7hr0yTXJmVmycKi0GND4YrIdIpIs+6Sc48OBnS22ci2YmOOWdvUQRa5NapjkEj01srbtdtOad7dse75sdrOeTmotUUwHWSPXaOGH+gVHBq9tPp2wLZTzLwr3j0tYz5stMVDicjVQ9aUdorP5Bq7BYVr5/hndcgni/f8RH+DmXs3SrMRaeXbK1OU1ke2pDbnJQ30qjyC6RUMtg1zOkzCuPYaENW74N5jLkJsoOpNV1mSHFe3ILAu3zg8h/faS+VLX9nRHFPH2KddFonX2gPSAqqzrIiO+peusc67NBbHlpoLwdfYyNTh9JYN1ZFrtM6xzbWXsOJkRuPISoOdnAIMIgOW+LX9ZUFpNvxkG/uWTge6xzLX+nlcMQYex1VR28bkSWJI5HuHuVdakAYC0E12yZY8cV06R9VRs/rWZyQNYZiL8PQ+VZe5FprdETvMKtuSt+0IzzGVxusG/WUNYWbJW/SZW5nxgVnMI50Bz2i7ySbd5nhyVjU8jqilVjKWNIUisLOBXnPJufvX+oCyCYFZ22y6xyLf4olZNZjx2F9NLVSdBy96sdZv7lh3/1JMNrLAEXPJcP1jj3CnDbPoEpG99XT7HcADfRw8A5aytJ5zxbv7V8qbSgV75nJ6yBrjti0tJvvKrBYMcZM7tLTG9J0bpUHMy2kvjdSij2xRbua0p+i2aj3r3nMhPSwBBHrKEudmUNuLjkkR3kvPkgACXWWHdDOprVVHpQqvpQZDFU9aQPWVFdYNqLZVmpVgUoa3SiPdmC4CQmD53rLhd9SWSEEMtV8adXipocd3K56Ww+t1dpcFv6XWA0X8waQd74RmT2nMDowh0oeM6i/3fk+tBYqfrmnHKx09u94aHGkIU5BmU6PHXEsoUCrHJ0Jd6vFGSW94PlILAlefuRVQMkdQKoT4UVeVCPrwQktPSAEECFS95lJCS5yoS3DB9or04XM1PcAbkkdugCXD9ZsgB68kpJi7dGE2gDEa8emWVppHvnixEid8GdNzrvzC+uvEXcQYnfhsO2ttJlAt4m7uOzf0a4BNv/kdwPtwUVM+eRrUnKcGpwYX/Ot4d/08zT3woYGq/HwvNTpqborwXkBfAe5iAyp7kuohyvLTg4jRUWNThdcKCsQZrU82LXX52Tme0Ow3VN+gDG8lhFxq1nXx0TmAbVm72Fy4UFOOlxgUnytLoKw02FJ5qiRm62d+QNmTDOxdN96BsLJlG8ZKm0j80qtBW/vblM+FPg6V4xUKtoKw0kLxCOn2vuFGJJTKFx3y8XXVaWm8wLU28VXamN1B9Hbb0KKEes1OXTWSk0LjBS50pXb1FD0scULuYiHK5WLG43Nk2ErN33geaFLIXS7lJvIpNmS19iHjrVSev/n3iTsU5TN0uIrtrDw+Yf/5+RVe55/7Hy3xPmZF+QQfqmqLlWWZM3h37fRd3z8G1F+DNDVV+TlCTOUW65Nv0/J2a8LIypfcpSw/xYio3lbEZCWXMY/EmdHKPlFdfoYST8GNYhPFMM3zO3Kk3JpKA1WF+QlONCVX2pCvxHxOazfB7gfMQMFOAwiozP9GiqXSYHFsccU3xLV/SyaNc3ltGiADNUSkS5VBR9ZiRVJpUE7RvdgzKRbuKrECMVBQdPgBTIWS4XSkHC2OSoOI9Gwd6Faw5XoyWwUYqe1iGcqcpSWleFEUWf1U/duRxLZjvCWXtGyAFyKx/OzqaA30JI8YQ63ZhOg3pC/3ktlsAxeqjdTZVJ40ZgTVFsrtKZhZ2ivcAy1WJ8oZZvTe6ss/+ZEYNf3lZtmTmweW9O53AQtWzL+vbIVTd2l++lf/qBk3e8EdiCtNP9Fkwi5Ybce4gZek7vJvb/Ftc0/OXWncHbrSnLwoAmy0E61doMJ1IB6Vm5RWX7V2YWeuNIibdBq38naKMGej2QkpXoG0ehKtTmMZPW+lgRQlL1SLU3YDCpjNS3J0E7ZKZz1WT/GzVhotR+EJMzUjByjrhExGqgg5gCkiihluTIOWegD80dll7oxZ6DNyNCQGKHtKFes3lNat5jR11GPA2G3ujCMJNyXFMVAegjaxivV/hWWpu00N9SjwdZ2xekWCtoQgNWGlYr370MOEu+I4+Xoc2LrPmRODfwyNyYAK8vJJcvyAwZH9eQW6volcLWRsQy+9eDGNiQDrQAzgefwA5vyvwtZ3kanUrvxe1CadrYfyttYkoOVot5b+oD/8+FuQVZgBAFZQOCCeLgAAsN0CnQEqoAUABD6RSJxJP7+jIitVWFPwEglpbvx8l57gP8B/gH4C/oX/QNsPwj8D+x36GfxryI2Y4k8E+Bf0s/qd1y6R/Bf4B+BH6Cf+vzifwz8AP0A/gHmAfgB9BX8A/gv8B/An9AtsI///P/6f+aA/C/4F+BX+Z/hH/2v1bCf/+q6/9dzv+fy+gsbH4B/F/4D+AX6p/nPQA/P7v+f6LaK6YdEVakb1NfkiXk3VXgDDn/vpWM4+BukyNAq6YdEVakb1NfmPlEzway1oZKnXVXgDDfM++63TKT164dlsfrtP5KvAGHP/kmeS2O0lqztTzUesSGnw1RjFXE/6Qf4B3O1tN9bPGCIneqXbGilchC4Aw6Iq1QxiD4/RI18V1oiumHRFJHbFwCR9IP8A3WtrMJ5b8q8AYdEUijZK7OwObt7BakQDvbPoipnvCQm0WEygkLJ0q2sq8AYcDs+u88IgTnA2vOkayeb95h18/wEj5nkkw6W7m8XSfGHsEy7qdYLUiAeIQAzKoXSXSy7pbJ216lViZuqvAGBevV2KPYNmMuZjI1SACBzxNwWpEBI7UqzFxqkq6YdEVaBPp1UWpfA3QoPDoirZAnmKEYpDQ0OeQa+5itb9SIB4S5aZlRi8LELjL0+7TNKaa6Yc/sgSzcejOhp6ZDA5nJyfqH7C9Kg/wEgZJSLPiUDLsroilTXjI26uyg3VXcau4vbQD/r08/w56CP1EQN0lXTDogVuYvA7AJjYDTyRVxpOyNsKbqGj8q8ASGdgSRe/+yXYwdn0wiir+16ukhnWsbNpijF7RC/imv3Xlfc/2vV0w3mcSTXd/o17g29Av7a3LUGdlBuqMrRFcTT0mHfpRqpzXKQg2H5vlXgCWkHElZ4bAf9iUszZLRBxcAgYc3+1IP79Cm8VxKItgNPwmO4vpNqwFdS/LwmCCR8wEqIaO1YtWJ/IUCf/NdCep1ZE6JYCJIApO+eq6TBYjm6oRNUFd0IYb051iREx+lDxBEH+jYifrZNW4x9Cm6gcQL/qxNitwER0PpU7DpKRnURRo3GPoU3UDiKPkD/rt7pE1aYOvsPzPojFTikINgNTSH6FN4riURbAafhE42AldEYqcUhBsBqaRAOsaJtuXtsFtZSxIsPFp1cYlNz5p/eDVGnpf9Z5nDn/9S6IxCIWbufQONkH4kCRusTbusq8ARH5LIo0bkZ6u5eUpvi1Yk17OXUiClH+2ECcwEDDrgrDf2QfiQJG6xKNE4dEFO/0QjqW3DEVMGIIjagITlGM8p5mPTbb2CrVcLjMCsfqIgbpKuK3d5J4TlQ2Giuk99gfNdDFIlqcEQf4CR3kYjm6oRNUFdztwwGkJv0Tp+ETh0RV4532JELACC5ID2oS4lHJ2H5qMyporph0lIzqIo0bjH0Kbp8dxpQMWTQVgDb2C1IYcFd95TrbhiKmB051iTX6cOqu/uhS6T5RNmsqrVLgrcqRBCRk+iQskfSCqUTao2E8bqrwBhvn+UWGcD3x29gtSICP8RA5vXjdVeAMZ7ZXRFKmvGRt043DGl6aK6YdEUijZMc4fAIGHVFH8A3sFqQ/ZdVr84fAIGHVAUBypEEJGT6JCyR9IKzibOrTIF5vmt1ph0RV39o/Vw9Qj+Eur7n+16umHRFXdADS/kRV4Aw6JSkvAEhcNXX9AqirwBh0QaExrug/wEj6OFXC4zArH6iIFsUWlI73rB0FqQ/cX0K4bzsEfSD+v+awDtEQ/FHmKvlFhnBbavKoqdEVeAJkVf7zTlpEBI+jfFqxI2/5RaIq1ldS/cptgtSICQefvEbkKZEj6QVnEmXs8X190H+AeIp/g0KX0tvl4AwPuNKBiyaCtDbxJXyiwzgttXlUVOiKu6ALgXfmComvrYdDV0w5/ZB+JE5i9pitfirWV1L9ym2C1IftnS+bxVFLJA9MUMsA88zh0QK3KkQQkY/mLqdyWRSESMfQpuZ5nBL89dMOCyEQ9BsLNA89BerixcThvn+UWGcFtq8qip0RRlaIxKYnATLK6TlinIq7+0fq4fXI8cSRnURRo3GPoVLPrTDn6MTUEWV2fU4/O/0QsZtSalaJxJw6IFblSIISMn0SFjvbPoipWvGRt1dlBONdgOAJHhunvxT8kP3Bmn71Wsq7+7CdsIaaoxCd1Or/jqayNdg7Dok82yulOvY7i4iSAQhicOkpGdRFGjcY+hTdQOIFbmLwOwtbUBfg1dznvBzPQR+oiBukq6SGdaEV5vqMO9/olKS7/igIi5ID2o7Zi5wLoN1VsfNdekA2q1XTDn/9S6IxCIWbufQDxZIr8cempEBH90SwOVwoHx1SujzmsfgJINz1WvxVrK6l/FryuIkd71cSFk6fhE4dEFO/0QsZtSalaJxJmRU961zB0xsBK6IxU4pCDYDUPXTDoirv8mtEYGI/wEj6OG/KLDOC4oKJqJV7BakQUqjVOb4NYlq4gnexmsq8AYz2yuiKVNeMjbq5YDmLwOxOA/7y+3sFqQw4K777NEXJAe0sNu1P0yRl1Ifsuq1+M6yupfuUb4QUozzOHRFWeN32jelASPpB/fvqo33EhIrQMOiKvAETA8kzAz/VV0w6IrDv0o1U6fhkFImVoaumHRFIo2THNy/hJTrKvAGG+TSmvt6J8BQ37TBOJ1kGH+Akd67nyCP/wcx/gJH0ba0k4RKW2maUrsAw6Iq0Cd7GfMmw4irwBhu2tltE3FTZNXOqvAGHQLEcQicOiKvAHzcBFhno2hDoYJ6ZpTtMNV0mRSOqYgC+NdsOiKtAnbOuJK0lhQYvP/5zzOHP0Ym+xP3mnLSICR8wEqPLKhg6cmbYLUiAc6YYWRiPW2rph0RRBJ7oWGL0AB/8q7oAGDGwOzy6azSuumG7ayRX44+Ob1G6z1IMDaIq7+8RSNv0x2/rOYrfKvAEhnY8sqDigFaHRQCnSsNV0w36D3pSN7E3qTB+RFXgDAUP8n7rgIJkF2XBwA2aOKAkK4bzsEdr5+WwTFM+rpOp3V9z/a9XTA+40oHfyIQOwvwIWor+RFWgTvFcSiLYDT8InGhUJOWkQDnTC4XwaTSZRqrHMRj6FNzPM4c+i5weNmsM1Hc/21yznTrb2C1Gw5wcxdIC2upD+Cve4TILooo+QP+skbb2C0YUapzLQB8B4mrcs7ja11C0y0hdARBXruEh1onDfJpTX29E+AocJMro9Wkjl6aK6T39gIJkF1WmlRv6kQEjw3T3qukpTRXTDoEB6ZhzFa2hCAVcx28bqrwIGJ1fBSkzVAL8qEN1WHtBLmB1XY4JaUlOtIhDoirUcBFhnprKdsRPuba0tr8edgaJw6IpYmSrAIg/wEj6Oe5foUbewWpEA9grmL1U7UQf9vYLUiAbx1x1nOis0i4BI+kIHfpDggixnJMU6eEiwiR9IPrYwsbsZtSalaJggC7OrTrh/gJHekyxX99XdNL4Bh0RVqpQ5YOAJH0g/sQk1F9NL2NbwbSHYdEVeBHh8OtE4dEVeAPXCa4uMP710DcXYdEVd/dCl0nyuaX7E4dEUj8SF8vsxm7n1Lvxuqu6AK6sMlF4rBakP1jB/1liea21eVQ5vsq8AYJsc/kPFnDoirv6TlbCFYaoUbQRxxJw6Iq7+rd6piEg/wEg7ntvE8/A8i9AAf/Ku/vPyVh2yOsukmpD9Ywf9ZI2xnMNky7qdYLUh+sYQVbrFClGwU3WM4AkfSCs4kZyTFOnhIg9d1QpaAPgSPpB9GrsQ59ig5cq7oAbNBorkmugzqQYJA6DYRiSXgU8bNYZKLxWCqxasSNLNZalkAUoK7oQw6IFbmhiqLQY6XDxmtjy8AYF69XVBVajyyrxR02wrUiAc6YVxEOODXGC+FUb7CmxI/NrdHjdVbH0XTDmK2/VTXu+IvTlaYdArB9KVPRibIxjRXSdTur7n+16ukhnY8sqGIJLpEm/AhOvx5EVaBO1+4rcDvesHQYBdQ6GrpgmlyOndWMHxa/54yNurdB+ro+kH9/FwQea+K8fOiRFcTT0l4Aw4LI5uMM8q/B97BajV5rbV5VFTdtZYcygo8PG6rDwhqnN8HHvoU3qnsUkKZU2/ftSChCoW3Dn/mUaqfeY8Hmnbf6O/wEj6QYeGQy0AHorekH+AkK4bfW06paW3sFqQy0QhZu580/u9dAwtEicOiKstTxPAT8ul0CvgH/0L0iAk7BaPx9Fzg8bqruc94OauqNuGIqXIecAYdEVdzLZrfjhGLv5FJ32VeAMOiDO8/YFWU5V0w6Iq7qZ9nfDCOyrwBh5jQlgdi7+KwfWVeAMPM6n4XlodZV4Aw3yaU1++SZG2FN3aTm9bIHh0RV3Grsi4kWGL0AB/8q8AYbtrLeeVt+VeAMOiC4LIgGITorI6DdVeAJ3obsOVW3jdVeAMPM6mcJE4dEVeAJe5LIqiLBoz8B+gL+GumMleQgkfRtrSRX448qCK3lPyV5CCR9G2tLfZLDI5q055nDogVuZSTpB4EBz/xhqumG7ay+QwceLlXgDDogAV8muWkQEj6QXdcXrfNdCfHayJzlxuqMrRFcTT0lsfOAYvP/lvgGHAIGjTXwYnmT5oq8ASGdjyyoYkRrwVr4QndTrBakP3F733511rxlKaCPpB/V9yW8M48XKvAGG+5Ertf2BzWqPGbxXWj4XNk5Mcs/v4t+iIvQAH/yrSzZOkW4VnBiqjXbDn6MTPCRCe28bMB6ZhzFa36kP0KbY5MuiImW4kJ6uU8e2HEVdvlJM0EN1/Kg/wDxCy9/C5/5roT47WROcu9/oS1IgHwJdwq8qjQUdrzUZXUDxuqtj5rt8tVgg5jRXSdTur7n+16ukhnWhFeb6iZKkVWq4bQlgcrhQVqMNXYccNvYXSnSsNVxW71UqR9HPgHYOz6ZFbDSkKwAKbewWpDNpi2qCu6aH3B/1kjbewWpDNpREkrwso2pEA9grmFPyWOwytEFeu4R3vWE1VdMZ8dv61Y79pgJUrx8i+RmiumNCoSctGGroB5Mcs/wEhXL53fWCwCkoUyJH0gw8M1KLxYNuQkTh0RV3+TWiOnMFLfiXBakQEhPjgGLz/8GHnviT1+6RIWSPpB/V6hpjQR1G1DwJTT0RV4EFnHilGJI3b8YOIq7+8/IXaZpSsf4CR9IPqrSG3670GV/Hrrf+pEBI+jiUWtvG6q8AYcCr7lGJR3vWDoLUiAkg3Y8TwUpEOLmrph0RaGYpHK4mnpLwBhvuIXe4sHZ9MithpSuwDDoirSzZOkYvcEHmvivH8Dph0RSSEvqRuumHRFXcMUiR6f7nzIzdz6B2VeAMOfoxNuhNaD/ASPpCsdKfb6Qf37ahZ3GmG0eLTq7FFuWl+Zw6IIjagHqTOP49LtfFeP4HTDoArI/ZX6SRxFXgCQzrQivN9Rh3rKd1fc/2vV0w6IoytIFFzxsoN1V4AkM61v2CCHYx1Prphu2skdwkTgxYxYOz6ZFbDSlZQeG9OdYkaWaylibUFr4rx/A6YF6+IyNX2Tiu/YUyHOmB8aTclOtIhBcjNJQV3Qhh0RRlaP/2cpIapzLQB8CR9IKziSN2/F2ooA+BIGSUi0PQkumHA7SHi06uxRblpfyI59pNb1lXda6kxm7n1LvxDFlhzKCjXgtKk4rv2FKUBEFeu4R3vWDoKyPhNUFd0IYdEFvgm1re6ia+th0NXTAvXrQAHHprjPNpAh0Wh6El0w6IPyVYHNao8ZvFdbLW9aETpEVd1rqTGbufUuySrHllQxIicOiD8OpjFZxNtalR+AewVzCn5LHZdvlJM0V0iTfgQnX48iKSLl9p6S8CCz1xFzzfvVv81dMOiD8lWBzWqPGbvOEugiUvG6q7/JroM6kGB6uMLrSEb47ewWpDNpRDKlg3JgHll47BajV5rbV5VFTcK2E8bqrxz3UTX1sOhkRipFXgD1wew4o4QSPpB/ZCt0FOE384+/lMiR9IPuHSg08J43VXgDBiqqnLQ3jdVeAJ1O6vuf7VOiv6yrwBhuDdLh2KsVZANhorph0laOV9ROJ09wCR9IPo1diHPsTzF5/8kH+AkfRs8ZYpQc/3HxKFEcbqrv6gX1oJCp6Iq8AYcCr7zrr6Qf4CSDdjxPBSkQ4uaumHRFoaC81zsUCisFqQugJBGDg3GDs+mRWw0pXYBh0RRlaO96uPsydWW/VvkQSPpBWcTDXKHGi2+XgDDoih7p92h+KIOwWpEBI714sgTIkfSD/Bp/XClBuqtVKJyHTet810J8drInRLRXTAvXvXQMLRI2BNqC18V4/gdMOgFig8s+VHqQf4CP8RJ4N+s9SDA2iKvAGCaWpwfjyIq8AYb9HhNmSsP6/5rAPUUoipWE+dcKvx2EgwHE4btrLDmUFHh42awzUdz/bXMNVxW7wz/TNCl9Lb5eAMBQ7+JnU7q+5/terph0AVqMTrszRLA7F42UG6q7n03Rz4ublaWbJ0i38Th0Qd6rOuFX47CQYDubeXvdoI4tWq6T39gIJkF2XBv0YkZyTFOaMG8sRSxMnzRVoE71OticOBWAKUFd0IYc/RibVZe/Gx4ngJ+YRHG6LNxmiGWtni5tRG1APUmaK6YdArOPA5rVHjN4rrBoxpYdEVbH0XTDmK2/R6uxwS0pKdaRJbpw6BWD6xkMWW2+DRXTBcjNJQV3QhgXr1oADkA8KZUqjVOb4OPgOdMHuordR/EZwEjwmyGL00V0w6IpYrcPFp1drVa3AMOiKtj6LphzFbHbAgFxW4He9YRcASPo57lkugp1nVpvu5IgJCfHAMXn/8oaIiuJp6S8AYbg3S4dirGXNXYr6IpI+kF0gLa6kQEj6OKg6jP4CR9IPuHSjxU7LLgDDoirY+cESSxbXUiAkeDfdX3PvSdcSZUAYdEVh4Q1Tm+DWQm1t43VXcuGA0i274Sk4dEVd0AXfoGjRRu1+N1V4AjzSaH1C3T3W1Rfguw6Iq7+oF9V+k0RV4Aw6IOHaK/kUnfZV4Aw6IAEbQ4IBYE9xvxOHRFHyB/1kjbHq8sJJqQ/bOlsCR/zXQnx2sic6GVdMOfoxIzkmKdPCRJxi20zSnaYarphu2stm1lsFr4jjdVd/Vu7+Gmjxa+K60RXTDoij/9hWaQ8WcOiCI2oB6kzRUrJoM0dMC9fGwRrD8lWBzWqPGbxXWiK6YF69XVBVajyyrxh4ZqO5/trmGq6SGdlYdUxAF8a7YdEVaBO2dcSVpaIQs3c+gdlXgCQzssCflm6QOkhnZYIOsq7rZNBmjit3ow70J7ByKuauSb1vmuhPjtZE5y9odV3BpK0se7/JroM6kGCQOg3QAnyZVKuatOeZwL160ABx8crUUOemaU010w6Aze24590SwOVwoKstNWcwaEFqQzbjFoy59dIkBIWp6Iq2Ej/muhPjtZE5y7iJIFIm6ThwWR3npmlO0w0O5CqeiKWJk+aKtVI2klcCR4N91fc/2vV0wS/Ot6y0GOlw8ZrY1wN7lyCD/ASPDgwpUsYWWVDEiJw6Iq2P6Y8WnV2KLctDNFikCUnDoilibUFr4rx+33ITrKvAE9++/FUDH3+AkeDfdX3P9r1ceIfrnrsq7e/t/Wc6SjVorph0RVsgUjdomiumHRFLF8U/FI8bqrwBPf2AgmQXT4L0xOHRFXda5qw8w5u3sFqQy0QhZu59AV24I4e8AYdJSqerlPHy3thxFXgDApN4BfZ4QSPpB/W9iOQfUSVuu3sFqRASFcRIYHJdMOiKu61zmjLo3VXgDBcjPd8zRDLXUiAj+6JYHMZlmZ6dTWDph0QK3MXgdkQTgqWAYdEUZWkCjtibV5VDgR9IP8A3pI8Edxtk56sFqRASBOOXAc/CV1IgJH0c3XJwJEVeAMOkkAAD3pl0B0jQthCWLWw7G91BQODGjBCRq08t18lUDP0yZsM9N3IH3gAaI6lZL3p8APNpsaLNQvECjwjuNLUgSsC2Z3q1df/yTz8QoUWeM8JcJsxQWp2k20EoY6rnWxUWshtQ2oLx6MWOrAzm5EHpELKXCISBD8852HQQH+QAYM1jZUFOOG10SA8gzcUEWZInZBZl/3KlLE0AetAOlfb2bbKADzmzBVsk2AmXaEXu9QTWx0G31esx0yL6gY/O7tRlJBmH+VQN5nGFrgMfGgKtYWr89md9WgSV2IHjD+oicZTdTUCdnfRKq8crfTIgGDkAZk6QnSZazUsQa9kPVzrtnNMtghTPnZizMuvHTIvqBj87u1GUrEUXmSE64BgrdRvBYEWUNsYTYZiNsIh7SxOzi6Hq1LdIASM76MkGVNlDbVwXgpZecidSdeI9j/YMJjNJbAKfhoZJOD04euT6SI+s2du/i/mmAiT/V8Oe+HUg6y+sL1lsr4N2sIgbplqkhkk4dlXd2oXkTrEops7AjiX4PAVNlImmAdtW6MMMdK+3tRPwAwxcCeNA7KcPh1I8cKI2jn6myAxcPYQnXA0qh/4wx0r7e1E+89VJk9Lh1I48QVEZlJrolfNENWWNlAzQqH9wrxpifQJMT34PaFPOh4gonDoaC4vNeEITx5sSAwTaxY2OcuUIMT6xLkAVrYJ223GzmjpX29qJ95ffs5609ROmyfACZA0Txc8QT/HctYK1Sz1E6PjGkOGOghJq0kXv+yzR66nB8z/+PvgKfKBnCu1MBQvdtrYQ9ooxlPOh4gonDoCKqTJ6XDqfWBbfwYSCDLCbwx1Y5RFcHingiDPIgWMD4jACFExzMBdqDLe5U3yuBMY9oMhSt84/ic+FIE2QBodTiJl+Kw3omQw3zqWHQM7vbVj/cw8ADVygpwwcMIAfvOAOnI1OjedAQsguWXNAk3+IraNxZ6I/5w0QThdQKQoOkcDfo6R3fWVcOhi7j+0UYynnMBFLXOEUtQCmS9TvHO0MPzfy3gHMS3dTxqKItgPUH/6ZyULHDnggIsbu4s8uMYkGC6wKVbUyORyQhccgXDlSIEsj06BoqGcXOpMl6Hv2MQHfVoGACNlAIKqbjTs9WwQZf4mQckRj1D+4XZk2mR3wAx+ZwcaS2zRV0hXp+IsgE9+uv9mlD0QyhVoDFlfGgpetf+UwNmowSCi0lrYoSx1lIz4GioZxc6kyXoe6OPdtrYILQ4UdnJXLcRUJAK8Lv1ZT8mFyOrHKNu6+jaooepGEEOlap//TLYaFzu3OASYBBdqDKu52KRwliTbfFSnqQLr2s+dMBlBRb9HSO75m8QHusciQWntVa6H6RcHpPuqCOe+HUg7+MI9CF0rPTKQR6ss14apyhdBgWii1k1h54AsIwgKF30tQq4OVo2RHwCC7UGW9yp7V6Ql/YjQbfV5rcvN22jPpJhS7j/LvBOvNbzuEZ4uWQy70BNEEc98OpDSuw9+0R/IjDHUj6ivfC3rQFlbBVrYJhMbOV3T44GJhljOd/2gnB/Yf7Qp50Ne47ECLIVtG4s9Ef84YFk4ICKMRlJDwQDpxHJbWj1vAhXz6xLW9JHx0UoApXu21sE70TZrg890XkTrEops7Y28gkr2rMgJjHqKEAGPPaXnInUnXiNc/hXc9wliLCq65Y7AzUSo54YEgsQVhamTfX6+GpKgAvuZITrsiQIfIfpaIwicADqdadkNDm3fWGm8NpRwPhnNZUCT4iUUYYY6V9vaifeHbfuBNUoIxBMosAn6z+xkJXAaItM0y/j4vDBBa/N+GNL5bdOqJN4F2Pc+cUWy+b7TGXD4iNQHjd+Op+XLn6E+QAEkueHHDgmfN4gpUWAA1G8at0LIsePEzOmvEuWHF8j9cYp+aOTcZo4nrsKofpaIntT6E69pUkwQvGKa/Pdxzc+HABQE94b5069pBYG7TX/aEpgIs/TgMNW6O6l39b4QYnQNP87ukj9cYp846/C3Rd4grOaZ1pZTzpgYFBiuQuwC+qMtAvGNjdzzJ5bE7sAvJvhvUNOe0vOROsRWs7a1rRHwJtNZ46iMHCWLG5xg5g3jpgD2T7m+eDbiQG2Gh6rFXpfVSqAh6BNeRjQUufTZNsUNkBOj1aW1sUJY6ykaFBk3MvBBxc0dSPqK+cVyzkDZSO+rQgLIoK6OVAWob/G0GQ8b8nKF2XcBGMP9oU86HiCicOsJ3fOvDvC9k0OZQhEsSWqsKVqgg6Ac1j6Q2RgrD3uwSoSnCtkyrMGLKQbDHT3m1Gs6Wdo1kBxK1rR63gQiz8JA5FojlhhqyxtG97h52McbWwQ3i+/cKk+mzv6hC3j7Ele10VrYIkvwe0KedDxBROHT+2vIKw8TIWS5FiY6MJ/G1nJQMUXydqfml8yZkj7fXU71N9E48BoYMWUg2GOnvNqNZ0trQqlXX7Bd9ZVw6GMEVC9Tsr6xNHMFzsY42tgkqBoni99IofLG1F9jbGh/f6pZukwi/1TpL0TOfAXgj8oHLeF7Ks1aSL3/ZXPkKF7zSc796cPTDeZMyR9vrqd4VH0TjxJTlWuIq5GbuiCvvhTRt3zN4gPhY3SYKqoirQCD330JGMTU/J1Uja3L30ih8sbUS3j+QFlbBVrYPHhc0P9n4CVIjWdNrws+K+OsmtbwfV5NvAZC70IUXYUEwQg1lIzr24yk8Jl7FYQXZeBDXfKUIimAJk5gudjHG1sU6xgLphk9RCt499eF32yEkM6m8xc0o/wmTpJzzSU388hYAgu1Blvcqb4Jt/gIUWrkYjm2Qp6rFlPOkd01rQWz9IXz5aCuoXqbf5FDNsJH+NUFL334UGTLB35LzIC85G4ZzLzLzdv8YgG6AIxG8wRBJzH+voWet4kxFAJ9SG0cUvbZhvGqlAjwiySPLyJ1YcFKNr6xAS0JEegN5UwPSeLXFcElanBkBw/JyMgm/E/9ootZEBDgAx0aCkYKcGTMRt9AbxoKgblMv/dUdOB8OH2EIx6BEuWOUDRwawYoVQsJnS4sTBiykGwx095tRrOltbSwEPPsHda2qUb1Pyhs8EOB081vO4SkzQoBoni99IofLG26e8WQ5PEMzHefVoI4hznMbud2b5TaAsrXtEeNk0bizy4xjfkYMrwvBCYGjhRGz8Zw6y90Q0/8cUS6cjHmKj4NfJ4WFsj6lOmWLZTfROO/LvED0PSu0Kwp5y6RB/8Rwf4aYmzu+5Io4SoxcAvv3C7Mm0yPAwdzvC8ty9QnXAMedMQhARxPeUEv/Mg8r4f3fjpGuHUg2Yz/cMcIcexiPJvNIOn7hC8WQiycLpgycW7ES34I/J/TGvKiIT2riNRotCRHokrsPftEfyIwx1I+or3XgJdphRQljrKjM68nGF8qCP+NSj7oRGtJPHMAvaxWtghxEoowwx0cEIWjNt8ptAWVqNfDP9wxwhx7Fm6Si/hoScFr1BUdmIQWYsJVxxh1oIXpKZYOoKyXUF3AYat5SgybmXgg4uaOpH1Fe47r5nQALHWVH6SATGPUvGGcIuwMv5R31aZ89pecidYitZ22uHzJvlRoDyvWQTrhgrZ08EIIoJbScIh8HjNWzqH+Whk7U/NL5lCwFtyaJcgOe9mdFhU2eeBudjJH3GHO/J+lojCJwAHDtdzCjDTUgsA/P9BXCeEMciAZwi7Ay/lHfVvvVujDDHSDazttcPmRNeGqcoXRusZQxlSNQgSGN5giYPwvFm0IDYg4V9pFs9RywfbYFd1X6VCqAZhb5gg5tn6BDUKMdGjbb68RqBsE7iTJNT4dTP6QXnz3Bjb1i+LUD1h3z98ynlm1RFWgCb36whqIi2gLGffYkeXjtJmSPt9dTvAGgyEwH5s+sAZiNogmOlI0urE2pBtwalwMrBsfoJkz0LX8zFBv4YJIpx+6SEqACRXkuZLXWhS3jwLESsJoDujkRAXxwZ5D2bSL/dgUm9AAHnHyibNcHnui8idYk5Kpfpu7JuIgIgnC6W9mQrni36Okd31lXDoYu5pyx7ip50C12u2bddn5wqpy7uUPgFixucYOYNg5qeQAzfPAaXfVoEXXCSOSUy6AEI7+KbmCsC3SGyfzVy7xBWc0zrSynnTA0IdIuu5ocGWRe3juXz4IDqis2G/NdzFynzjr8LdJT8HtCnnQLXa7cCH8/Nmd7Fb0CRvEtRORgyRRZPo9T3nw30K91SzGUV9pFs9TZgcC0pRfxAHErvA9wLxIP/RIWAtBmiMLJPXTLv6IcaZ9RXvidim1fT4GieLfRpw5mrBh27agVWtihLHWUkCYf7Qp50vpBefpdAtj0Y4D5scbWwQVsdY1/y2JtxmkHG69k5e63fVojvvsSPKre3PQ4mhhxTJ0k55UPwuuNtnGBb9uXogf/PMX6ClVkGZc0Kz6Jx3+GOrHKNu6+jaomFIj98u8E582OspYLx5orYadJeiZz57oh7bCGSxNT8mMeki9/2WaPYZ1Ed4apyhdB08KTWxZSCvtItnqOV84EiaoIPmMVVIlFtnuhEHO9loTqAvAK3EdTxg5d/42DqCr9RFWgDRaEiPU8Boni99IofLG1EUkRR0ju+sq4dDGJWbpMFeytl4BJPHMAvaxWtgkqAQXagy3uVN8mvEp7z4csp+TiCcLppLAeL93fOvFvC9XlPr+uUma6nnTA0IdBQiOrVwzQQAySrQAi67mhtldvbcMY53TIOkt7mLjtop/0pn9sccRw/tmd7Fb1qflDwBBdqDLe5U3w5nUUB5Xj7TvoyqcdOVVKVqgg+YxVUiVxzrrDAxk8idYlFNnePzODjWedUpT6C4RzDBgYAIBS42r8GwAMNGmdn5XDvrC3mXKm+CoR/56S+v8SzKfostwaAKJqgg+M2yt6kfukhUQ/Zw3x9YlGnq1bpDZQMqBbVZt9tDrtuLoquHO4u8TYeN7CA+pWrWrnoV+6o6W3hxK1rR63gQiBgjP73Icemw/H/YBlYNWtCIBgJ1V4JcBKMiiHZ1mjiBXTXBhkpkvs6Ws0AiInwNE8XvpFD5Y23T7NUS04VsmC8SGygHh9kUV/8Te0h++XeCdea3ncIoV8dZNa3g+ryYVvcPOxjja2CAnJ1R/UiG8GvFZ0G+dgUct7LuAH9a8fs4b4+sSZfrCJZohESThREx0pHLyJ1V2pGwZkPaKLWTWHngCwjEIruaGUL4KP2gsPFw29DXa/61iLM4h4HXfM3iA90uQraNxZ6I/5xHgh/N8WuHfVoI4nC6YMnFuaMvFbzYCytRiviMRJ4FbZxdD1He8nd/RUBKbl0aaNsIh7SxOzi6HqyxsqagnXk4ukT+bHxKiJ2T1EeH0Tjv0p+D2hTzn8cMk3HWHSqVdfsF31lXDoYvDwWWtbv/aF/cViuWcgR3x31aGesk8v+eqZcKmjyY/xKe8+HLKfkxM/X9cpM11POmBoQ6ZwlE5NqJE+/cLIdITYEx0pHLyJ1iUU2dhRmNMAxijagVf0Tjv8ee0vOROsRWs7bXD5kWZxDwOu+ZvEB7uICapQVkq+5zKzU3vmsKAp172Ta2CMuWqJ3BF2kWz1NHxpPeGqcoXQnJrv6zbvPTZKJLkjtbn9vbv6KgpTcuuwUADWIuBVcB4WishhpVNXglsEclASRJD6mjJ7S85E6fumtaBUDRDnLe5i5T80cm4zWbON2oxZuECC330JGMTU/Juqx9IbIwVh73YJjBNYaxUaA8r1kE64raF6m3+N0SKJqgg+YxVUiXRFN/1KgKkJjSiHiuFKPSPgAqPonHmglbuP2hLGUYnsDgSFr49D2Iyw0RcZKOUL92fm+LXDvq53UsxlFfaRbPUcr5wEpkep7z4X1wsk9ZOf99qAb27+ioKU3L5YY/mjyg/Ezz85thM2RAbWT4B81bluqau4NTMOIgVc38o81OpjjCK4O6NBSFzQin4JqnsgwjXjWBBxwOEsNnkyXqpuEAhWAqpQEqdd4XjA/UyLyAiCcLpSq9AFfE+EDOLm1FAAVOuSsy+5LgAqgMGzKcjsozr+lKfmjQHGaOJSCykeVWSO/qFAmkwYlwCnIN//9MYzN0P5lgUAZ1DY4QmnSdorQKqxI+zvvlhYOOUzVYVZAfMkvwe0KedL6QXn6XQLhddzQyg+pDXY9VaFmcQ8DrvmbxAe6U7eosnhVb256HEx44VxCHJl3o2EmVxGjP+dlMPjY9hefm+IbaegimLbNvgNMbd83OBWOGDBtRI2ty4Sxy9PsIBpmp+D2hTzpfSC8/S6BaxOxTavj8zATAJ20Q2VTcIYYi05WcOqoCHIfcHffYkeVW9uehxNDDimTmC52+mhOuAaZQxGtHiU2VGgPK9ZBOuAl5BUCuJwWOCJQJ8M7AaZ1SwuDcDqxyjbuvo2qJhOtkyfZZGf97PRK+JhYbnYyR6FyM/3DHCHHsY1BP23aooE582OspLAQqH7NzgRdpFs9RyvnAkTTXbS/6trYIRS16EQgAKmaK6OLSWu499eF3z17PEwO1759nd5/L41AqRV7FOqWE7atNFE1sybTI+DXUAfPjoa9c0HdYFR9E47/HpIvf9lmj2LMNJQDiBOHVUBDkPxCIUXYDBhAy/4RuGVIuwMv5R31aPzCLp0yBnmjqR9RXu2Co0B5XrIJ1wdb81c3RyLheqTgUQLHyBjItyJtMh4bYDQLtV/LbGEtfaZi3+rBhB8PcU5AsLLWt3/tDDqQI1kBxK1rR63gQq+dUf0FcJ6FBYrlnIEd8d9Wq2IxEngVtnF0PVljZTXhqnKF0SYhRa7voFV9qDsWf83IpgbED8u2qyEr+WT3TokHAvGXgD4e4pzNiY0MHxLcb9JxBbboxb/LMyK0ZmhBDAA/tmd7Fb1qflFo/Zw3pk4AHU607IaHNu+sNN4bP//Qhl/JazQGLUP7hVcOdx4lA2nFl/0FvbnL74Fka345WgoOTHT0i6eUMAeBeDP9wxwl9PgzKUpDZUA939p+hRQEwE8FFK/fhQbE382gJ/xPo4zEsgNTGrkXRk4dfApZzY7iu5rXnEYll441CCHaKLWTWHngCwjGbdBR2fZvvzfinxj7/RIN36Gu1/1rEKiHbZNG4s9Ef86zeIS0MoFUCYzFSQoQO9WmzvB4J15redwig05Qz9nDdhjb51VjgFixKPFudoqTwFLhQ4C+/cLsybTI8DBRObwGbSPZbVFxiyaaVYO8na29T2X/SClXQf2YC7UGW9ypwEK7mhlBxEKLrh8Z4bUthwEju+ZvEB7pRjCLp0yBnmjqR7dTUkXYGiBPw6kEysKaIVzkUXcvnaIKF+4XtcKkQe5uKZj383wMxURecDkR+xuWF0l9+D2hTzmAicOgwvTuBNwn+PNE4H/wYrPlNKntro0+xkj0HlphJHaLobTmTHVkxNneDwTrzW87hFL4Tb7OG/XkTrEops/UwdHfBgFa2CAgFPbDxFRubQ/wFZFlfHcaoyMRxU+cv+gt7c4DIDD/aFPOl9ILz9Lnthpw0k4XTL0JpHhvlT7GSPRTL2Jj2O+0i2epo9uGwnJ2wbgCc+bHWUoI0It1NEIXY6FNtKKbPJwi7Ay/lHfVoretwmY8daSnSN3DG3nQFlbBVrYMQBaJAxA4GJzeAzaR7Lap2KWXnInT901rQKgaIHrWWNa6uabIpEKcBwpwrZNvBoeqxWCsPe7BMYJrBpKAcQJw6qgIch+dsXlupKwqXF2IfzfFrh31acbbU+hGXBXUn4MiBeR768LvpXPUWRGQFT5y/2nPovp+6a1oMNtaC0a+PgxuK0x7qaqemBdwGGriwyBd1d36tZEt3gKaw4CR3fM3iA+FjdJe/7kFz9wCZOYLnYxxtbBbGX48jOXBXUn4Mi7B9jfk5Qu1nDqikTtl9wKpGuAD5oUL/SplX+SugWNfAysJYlsaIQTMyCMBxaSJ9BUsfbfQO4QcDChs/LaQdxXdAGwTuJMk1Ph1U39t6gq0+f8jQ4mhzOG+1JeQPH0k4pusLgJRRhhjpBtZ21sRbUcGv+n8akqofwk530Sjo4+SS89Y13ERgPzMO+A4A0PVYrBWjI5+C2Be4px2ByD5lizjICLRtFtSIOwuM/rQZlMCeSapaiGy/FEAAAAA", l = (k) => new Promise((r) => {
+  new MutationObserver((t, d) => {
+    const A = document.querySelectorAll(`#${k} [data-rp="pages"]`);
+    A.length > 0 && (d.disconnect(), r(Array.from(A)));
+  }).observe(document.body, {
+    childList: !0,
+    subtree: !0
+  });
+}), p = /* @__PURE__ */ new Map(), c = (k) => {
+  const { isValid: r } = u(), a = s([]), t = s([]);
+  I(() => {
+    if (r || !k)
+      return;
+    const d = (A, i) => {
+      A.querySelector(`${i}`) || p.has(i) || (p.set(i, A), W(A, i));
+    };
+    return l(k).then((A) => {
+      A.forEach((i) => {
+        a.current.push(i);
+        const o = w();
+        d(i, o);
+        const S = i == null ? void 0 : i.parentElement;
+        if (!S)
+          return;
+        const R = new MutationObserver((U) => {
+          for (const E of U)
+            if (E.type === "childList") {
+              if (i.querySelector(`.${o}`))
+                return;
+              p.delete(o), d(i, o);
+            }
+        });
+        R.observe(S, {
+          childList: !0,
+          subtree: !0
+        }), t.current.push(R);
+      });
+    }), () => {
+      t.current.forEach((A) => {
+        A.disconnect();
+      }), t.current = [], p.forEach((A) => {
+        A.remove();
+      }), p.clear(), a.current = [];
+    };
+  }, [r, k]);
+}, W = (k, r) => {
+  const a = document.createElement("div");
+  a.classList.add(r), a.style.cssText = "display:block!important;visibility:visible!important;transform:none!important;scale:none!important";
+  const t = a.attachShadow({ mode: "closed" });
+  return t.innerHTML = `
+    <style>
+      .${r} {
+        background-image: url(${m});
+        background-size: 150%;
+        position: absolute;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        font-size: 2rem;
+        font-weight: 700;
+        line-height: 1.25;
+        color: rgba(140, 153, 166, 0.6);
+        pointer-events: none;
+        z-index: calc(var(--rp-base-z-index, 1) * 5);
+      }
+      @media only screen and (min-width: 768px) {
+        .${r} {
+          font-size: 3.5rem;
+          background-size: cover;
+        }
+      }
+    </style>
+    <div class="${r}"></div>
+  `, k.appendChild(a), a;
+};
+function w() {
+  const k = "abcdefghijklmnopqrstuvwxyz", r = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let a = k.charAt(Math.floor(Math.random() * k.length));
+  for (let t = 0; t < 7; t++)
+    a += r.charAt(Math.floor(Math.random() * r.length));
+  return a;
+}
+export {
+  c as useWatermark
+};