wao 0.41.3 → 0.41.5

package/devnet/app/components/pagination.js

@@ -0,0 +1,144 @@
+/**
+ * Etherscan-style numbered pagination with page-size selector.
+ *
+ * Usage:
+ *   const pg = pagination({ onPage, pageSize })
+ *   el.appendChild(pg.el)
+ *   pg.update(page, hasNext, count)     // after each fetch
+ *   pg.pageSize                          // current page size (read-only)
+ */
+export function pagination({ onPage, pageSize = 25 }) {
+  let current = 1
+  let maxKnown = 1
+  let hasNext = false
+  let knownLast = null
+  let currentSize = pageSize
+  let totalCount = null
+
+  const wrap = document.createElement("div")
+  wrap.className = "pagination"
+
+  function render() {
+    wrap.innerHTML = ""
+
+    // Left side: page size + total count
+    const left = document.createElement("div")
+    left.className = "pg-left"
+
+    const sizeWrap = document.createElement("span")
+    sizeWrap.className = "pg-size"
+    const sizeLabel = document.createElement("span")
+    sizeLabel.textContent = "Show "
+    sizeWrap.appendChild(sizeLabel)
+    const sel = document.createElement("select")
+    sel.className = "pg-select"
+    for (const s of [10, 25, 50, 100]) {
+      const opt = document.createElement("option")
+      opt.value = s
+      opt.textContent = s
+      if (s === currentSize) opt.selected = true
+      sel.appendChild(opt)
+    }
+    sel.addEventListener("change", () => {
+      const newSize = Number(sel.value)
+      if (newSize === currentSize) return
+      currentSize = newSize
+      current = 1
+      maxKnown = 1
+      knownLast = null
+      hasNext = false
+      render()
+      onPage(1, newSize)
+    })
+    sizeWrap.appendChild(sel)
+    sizeWrap.append(" Records")
+    left.appendChild(sizeWrap)
+
+    if (totalCount != null) {
+      const countEl = document.createElement("span")
+      countEl.className = "pg-count"
+      countEl.textContent = `(${totalCount.toLocaleString()} total)`
+      left.appendChild(countEl)
+    }
+
+    wrap.appendChild(left)
+
+    // Right side: navigation buttons
+    const right = document.createElement("div")
+    right.className = "pg-right"
+
+    const prev = btn("\u2039", () => go(current - 1), current === 1)
+    right.appendChild(prev)
+
+    const range = pageRange(current, maxKnown, hasNext)
+    for (const p of range) {
+      if (p === "...") {
+        const dots = document.createElement("span")
+        dots.className = "pg-dots"
+        dots.textContent = "..."
+        right.appendChild(dots)
+      } else {
+        const b = btn(String(p), () => go(p), false)
+        if (p === current) b.classList.add("pg-active")
+        right.appendChild(b)
+      }
+    }
+
+    const next = btn("\u203A", () => go(current + 1), !hasNext)
+    right.appendChild(next)
+
+    wrap.appendChild(right)
+  }
+
+  function btn(label, onclick, disabled) {
+    const b = document.createElement("button")
+    b.className = "pg-btn"
+    b.textContent = label
+    b.disabled = disabled
+    if (!disabled) b.addEventListener("click", onclick)
+    return b
+  }
+
+  function go(page) {
+    if (page < 1 || page === current) return
+    if (page > maxKnown + 1) return
+    current = page
+    render()
+    onPage(page)
+  }
+
+  function update(page, _hasNext, _count) {
+    current = page
+    hasNext = _hasNext
+    if (_count != null) totalCount = _count
+    if (page > maxKnown) maxKnown = page
+    if (_hasNext && page + 1 > maxKnown) maxKnown = page
+    if (!_hasNext && page > 0) knownLast = page
+    render()
+  }
+
+  render()
+  return { el: wrap, update, get pageSize() { return currentSize } }
+}
+
+/** Compute which page numbers to show. */
+function pageRange(current, maxKnown, hasNext) {
+  const last = hasNext ? maxKnown + 1 : maxKnown
+  if (last <= 7) {
+    return Array.from({ length: last }, (_, i) => i + 1)
+  }
+  const pages = new Set([1])
+  for (let i = Math.max(2, current - 1); i <= Math.min(last, current + 1); i++) {
+    pages.add(i)
+  }
+  pages.add(last)
+  const sorted = [...pages].sort((a, b) => a - b)
+  const result = []
+  let prev = 0
+  for (const p of sorted) {
+    if (prev && p - prev > 1) result.push("...")
+    result.push(p)
+    prev = p
+  }
+  return result
+}

package/devnet/app/components/search.js

@@ -0,0 +1,159 @@
+import { navigate } from "../router.js"
+import { queryTxs } from "../api.js"
+import { short, tagsMap, contentTypeLabel, typeBadgeClass } from "../utils.js"
+
+let debounceTimer = null
+
+export function createSearch() {
+  const wrapper = document.createElement("div")
+  wrapper.className = "search-wrapper"
+
+  const form = document.createElement("form")
+  form.className = "search-bar"
+
+  const input = document.createElement("input")
+  input.type = "text"
+  input.placeholder = "Search by ID, address, or height..."
+
+  const btn = document.createElement("button")
+  btn.type = "submit"
+  btn.innerHTML = '<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="11" cy="11" r="8"/><path d="m21 21-4.3-4.3"/></svg>'
+
+  form.appendChild(input)
+  form.appendChild(btn)
+  wrapper.appendChild(form)
+
+  // Dropdown
+  const dropdown = document.createElement("div")
+  dropdown.className = "search-dropdown"
+  dropdown.style.display = "none"
+  wrapper.appendChild(dropdown)
+
+  function hideDropdown() {
+    dropdown.style.display = "none"
+    dropdown.innerHTML = ""
+  }
+
+  form.addEventListener("submit", (e) => {
+    e.preventDefault()
+    const val = input.value.trim()
+    if (val) {
+      hideDropdown()
+      navigate("#/entity/" + val)
+      input.value = ""
+    }
+  })
+
+  input.addEventListener("input", () => {
+    const val = input.value.trim()
+    if (val.length < 2) {
+      hideDropdown()
+      return
+    }
+    if (debounceTimer) clearTimeout(debounceTimer)
+    debounceTimer = setTimeout(() => searchLive(val, dropdown), 250)
+  })
+
+  input.addEventListener("focus", () => {
+    const val = input.value.trim()
+    if (val.length >= 2 && dropdown.children.length) {
+      dropdown.style.display = "block"
+    }
+  })
+
+  document.addEventListener("click", (e) => {
+    if (!wrapper.contains(e.target)) hideDropdown()
+  })
+
+  input.addEventListener("keydown", (e) => {
+    if (e.key === "Escape") {
+      hideDropdown()
+      input.blur()
+    }
+  })
+
+  return wrapper
+}
+
+async function searchLive(query, dropdown) {
+  try {
+    // Search by ID
+    const [byId, byOwner] = await Promise.all([
+      queryTxs({ ids: [query], first: 5 }).catch(() => null),
+      query.length >= 10
+        ? queryTxs({ owners: [query], first: 5, sort: "HEIGHT_DESC" }).catch(() => null)
+        : null,
+    ])
+
+    const results = []
+    const seen = new Set()
+
+    for (const edge of byId?.edges || []) {
+      if (!seen.has(edge.node.id)) {
+        seen.add(edge.node.id)
+        results.push(edge)
+      }
+    }
+    for (const edge of byOwner?.edges || []) {
+      if (!seen.has(edge.node.id)) {
+        seen.add(edge.node.id)
+        results.push(edge)
+      }
+    }
+
+    dropdown.innerHTML = ""
+
+    if (!results.length) {
+      // Show "Go to" option for direct navigation
+      const item = document.createElement("div")
+      item.className = "search-item"
+      item.innerHTML = `<span class="search-item-label">Go to</span><span class="mono">${short(query, 20)}</span>`
+      item.addEventListener("click", () => {
+        dropdown.style.display = "none"
+        navigate("#/entity/" + query)
+        dropdown.parentElement.querySelector("input").value = ""
+      })
+      dropdown.appendChild(item)
+      dropdown.style.display = "block"
+      return
+    }
+
+    for (const edge of results.slice(0, 8)) {
+      const node = edge.node
+      const tags = tagsMap(node.tags)
+      const type = tags["Type"] || contentTypeLabel(node.data?.type || tags["Content-Type"]) || "TX"
+      const name = tags["Name"] || tags["Action"] || ""
+
+      const item = document.createElement("div")
+      item.className = "search-item"
+      item.innerHTML = `
+        <span class="${typeBadgeClass(type)}">${type}</span>
+        <span class="mono search-item-id">${short(node.id)}</span>
+        ${name ? `<span class="search-item-name">${name}</span>` : ""}
+      `
+      item.addEventListener("click", () => {
+        dropdown.style.display = "none"
+        navigate("#/entity/" + node.id)
+        dropdown.parentElement.querySelector("input").value = ""
+      })
+      dropdown.appendChild(item)
+    }
+
+    // Also add "View all" link
+    if (byOwner?.edges?.length) {
+      const viewAll = document.createElement("div")
+      viewAll.className = "search-item search-item-viewall"
+      viewAll.innerHTML = `<span>View address: ${short(query)}</span>`
+      viewAll.addEventListener("click", () => {
+        dropdown.style.display = "none"
+        navigate("#/entity/" + query)
+        dropdown.parentElement.querySelector("input").value = ""
+      })
+      dropdown.appendChild(viewAll)
+    }
+
+    dropdown.style.display = "block"
+  } catch {
+    // silently fail
+  }
+}

package/devnet/app/components/table.js

@@ -0,0 +1,124 @@
+export function table(columns, rows, onClick) {
+  const wrap = document.createElement("div")
+  wrap.className = "table-wrap"
+
+  const t = document.createElement("table")
+  const thead = document.createElement("thead")
+  const hr = document.createElement("tr")
+  for (const col of columns) {
+    const th = document.createElement("th")
+    th.textContent = col.label
+    hr.appendChild(th)
+  }
+  thead.appendChild(hr)
+  t.appendChild(thead)
+
+  const tbody = document.createElement("tbody")
+  for (const row of rows) {
+    const tr = document.createElement("tr")
+    if (onClick) tr.addEventListener("click", (e) => onClick(row, e))
+    for (const col of columns) {
+      const td = document.createElement("td")
+      const val = row[col.key]
+      if (col.render) {
+        const rendered = col.render(val, row)
+        if (typeof rendered === "string") {
+          td.innerHTML = rendered
+        } else if (rendered instanceof Node) {
+          td.appendChild(rendered)
+        }
+      } else {
+        td.textContent = val ?? ""
+      }
+      td.className = col.mono ? "mono" : ""
+      tr.appendChild(td)
+    }
+    tbody.appendChild(tr)
+  }
+  t.appendChild(tbody)
+  wrap.appendChild(t)
+  return wrap
+}
+
+export function replaceRows(tableWrap, columns, rows, onClick) {
+  const tbody = tableWrap.querySelector("tbody")
+  if (!tbody) return
+  tbody.innerHTML = ""
+  for (const row of rows) {
+    const tr = document.createElement("tr")
+    if (onClick) tr.addEventListener("click", (e) => onClick(row, e))
+    for (const col of columns) {
+      const td = document.createElement("td")
+      const val = row[col.key]
+      if (col.render) {
+        const rendered = col.render(val, row)
+        if (typeof rendered === "string") {
+          td.innerHTML = rendered
+        } else if (rendered instanceof Node) {
+          td.appendChild(rendered)
+        }
+      } else {
+        td.textContent = val ?? ""
+      }
+      td.className = col.mono ? "mono" : ""
+      tr.appendChild(td)
+    }
+    tbody.appendChild(tr)
+  }
+}
+
+export function appendRows(tableWrap, columns, rows, onClick) {
+  const tbody = tableWrap.querySelector("tbody")
+  for (const row of rows) {
+    const tr = document.createElement("tr")
+    if (onClick) tr.addEventListener("click", (e) => onClick(row, e))
+    for (const col of columns) {
+      const td = document.createElement("td")
+      const val = row[col.key]
+      if (col.render) {
+        const rendered = col.render(val, row)
+        if (typeof rendered === "string") {
+          td.innerHTML = rendered
+        } else if (rendered instanceof Node) {
+          td.appendChild(rendered)
+        }
+      } else {
+        td.textContent = val ?? ""
+      }
+      td.className = col.mono ? "mono" : ""
+      tr.appendChild(td)
+    }
+    tbody.appendChild(tr)
+  }
+}
+
+export function prependRow(tableWrap, columns, row, onClick, maxRows = 0) {
+  const tbody = tableWrap.querySelector("tbody")
+  if (!tbody) return
+  const tr = document.createElement("tr")
+  tr.className = "new-row"
+  if (onClick) tr.addEventListener("click", (e) => onClick(row, e))
+  for (const col of columns) {
+    const td = document.createElement("td")
+    const val = row[col.key]
+    if (col.render) {
+      const rendered = col.render(val, row)
+      if (typeof rendered === "string") {
+        td.innerHTML = rendered
+      } else if (rendered instanceof Node) {
+        td.appendChild(rendered)
+      }
+    } else {
+      td.textContent = val ?? ""
+    }
+    td.className = col.mono ? "mono" : ""
+    tr.appendChild(td)
+  }
+  tbody.insertBefore(tr, tbody.firstChild)
+  // Trim excess rows
+  if (maxRows > 0) {
+    while (tbody.children.length > maxRows) {
+      tbody.removeChild(tbody.lastChild)
+    }
+  }
+}

package/devnet/app/components/tags.js

@@ -0,0 +1,89 @@
+import { isAddr } from "../utils.js"
+import { navigate } from "../router.js"
+
+const SYSTEM_TAGS = new Set([
+  "Data-Protocol", "Variant", "Type", "Module", "Scheduler", "SDK",
+  "Content-Type", "Module-Format", "Input-Encoding", "Output-Encoding",
+  "Memory-Limit", "Compute-Limit", "Authority", "On-Boot",
+  "Cron-Interval", "Cron-Tag-Action", "From-Process", "From-Module",
+  "Ref_", "Pushed-For", "Epoch", "Nonce", "Hash-Chain", "Timestamp",
+  "Block-Height", "Assignments",
+])
+
+function isSystemTag(name) {
+  if (SYSTEM_TAGS.has(name)) return true
+  if (name.startsWith("Cron-Tag-")) return true
+  if (name.startsWith("Ref_")) return true
+  return false
+}
+
+function renderTagTable(tags) {
+  const wrap = document.createElement("div")
+  wrap.className = "tags-table-wrap"
+  const t = document.createElement("table")
+  t.className = "tags-table"
+  const thead = document.createElement("thead")
+  thead.innerHTML = "<tr><th>Name</th><th>Value</th></tr>"
+  t.appendChild(thead)
+  const tbody = document.createElement("tbody")
+  for (const tag of tags) {
+    const tr = document.createElement("tr")
+    const tdName = document.createElement("td")
+    tdName.className = "tag-key"
+    tdName.textContent = tag.name
+    tr.appendChild(tdName)
+
+    const tdVal = document.createElement("td")
+    tdVal.className = "tag-val mono"
+    if (isAddr(tag.value)) {
+      const link = document.createElement("span")
+      link.className = "link"
+      link.textContent = tag.value
+      link.addEventListener("click", (e) => {
+        e.stopPropagation()
+        navigate("#/entity/" + tag.value)
+      })
+      tdVal.appendChild(link)
+    } else {
+      tdVal.textContent = tag.value
+    }
+    tr.appendChild(tdVal)
+    tbody.appendChild(tr)
+  }
+  t.appendChild(tbody)
+  wrap.appendChild(t)
+  return wrap
+}
+
+export function renderTags(tags) {
+  const container = document.createElement("div")
+  container.className = "tags-container"
+  if (!tags || !tags.length) return container
+
+  const system = tags.filter((t) => isSystemTag(t.name))
+  const regular = tags.filter((t) => !isSystemTag(t.name))
+
+  if (system.length) {
+    const group = document.createElement("div")
+    group.className = "tag-group"
+    const label = document.createElement("div")
+    label.className = "tag-group-label"
+    label.textContent = `System (${system.length})`
+    group.appendChild(label)
+    group.appendChild(renderTagTable(system))
+    container.appendChild(group)
+  }
+
+  if (regular.length) {
+    const group = document.createElement("div")
+    group.className = "tag-group"
+    const label = document.createElement("div")
+    label.className = "tag-group-label"
+    label.textContent = `User (${regular.length})`
+    group.appendChild(label)
+    group.appendChild(renderTagTable(regular))
+    container.appendChild(group)
+  }
+
+  return container
+}

package/devnet/app/index.html

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>WAO SCAN | DEVNET ALPHA</title>
+  <link rel="icon" type="image/png" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAQQAAAEECAYAAADOCEoKAAAACXBIWXMAAC4jAAAuIwF4pT92AAAAAXNSR0IArs4c6QAAIABJREFUeF7sfQmYFNXV9l2qqqtnGBYRQUBFBYzghqMmisZxTTSST2N6jEuMMTh8ajSiJu6h3eISE4zEBWLcl8j8RiNuuESMUb8ohLiAGwoqorLIMjPdXcu993/e8t5J0fRMdw8Ds9bzzDMwXVVddZf3nnvOe95DSe/R2wK9LdDbAroFaG9L9LZAbwv0toBpgV5A6B0LvS3Q2wLNLdALCN14MCilKKVUtfCK+X3f0liQuA/u0cq9unEr9qxX6wWE7t3ffMyYMXzixIncsizb931n2rRp9scff8zw2slkkhx11FFk3333JZZlRWMhm80S27YVfpRSwdtvv61mzJghCSG+/gkIIQZkovsQQvA56QWOrj+YegGha/Yh+i3qu7POOsvOZDKVzz//fN8lS5YMIIREP67rVhBC3FwuV0kIqbAsKymlxE+Cc+CDRT3PoxUVFUQIQfDvRCIBK4AEQaAsyxJSSi8IgoAxBhBoklI2EkIaxowZ08gYW/vuu+82hmG4rrKycmVTU9M6DRgABwBGS5ZJ12zxHvLUvYDQRTp65syZvLa2tj8hZLDrukOCIBimlBpECBlIKR1ICOknpRzAOcc5/cIwBCA4rus6QggWBAF1HIcJISh+GGOEMUbDMIxawLKsCBiUUsRxHOL7PvYb0cpvWZYKgkAyxkLGmBeGYROAgRCyzrKshjAMVzPG1rmuuzaTySxNJBKLPc/7lBDyZSqVWltfXy9SqRTH7y7S3D32MXsBoRN1PUzuvfbay1q6dKnjeZ6dSCQGrFq1atTgwYN3Wbt27U6NjY1DLMvqL6Xsi8lv2zZWf1cpZRNCWBiG1LZtTHLzO1rxMdGbvcj4w9fmfQQCBhBs24ZlED8v+hzn4RzHcQAQsCSiLQX8Cfr/inOO7YWUUgaO4zT4vr+Gc/6VEGKl67ort95662WLFy9eZNv2O/369VsqhMisXr3aU0p5vX6JTjQAjdnZuR6pxzwNJib24E5VVVVlQ0NDP6z2rut+I5fL7cY530kIsQ1jrL/jOFVCiIpkMmmtW7cOqzvlnFPtNCRSymjSY9XH4bouyWQyERhgtcckrqysjPwD5sA1MZCIzjV/M+BgAAP3xWfYUmhAiMADn5vr8BvgIYTAVgHbD+V5nsTWQymVo5Riy7HOtu0vwzD8QAjxluu6b0kpl/u+vwrWBiEkp/0RvduNDpoGvRbC5m94tDlW9iHJZHKwEGK47/sAgHFKqWFSSgBDlW3bfYIgsDH5MRnN5OScR5PfTE6zisf/hlfSW4JodTfnauMgmrhmApvfuCb+uQEBAIqZ/OY3ngefawCIWhDPZZ7TAJR5ZgMweisiGGMZxhj8D9h6LCeE/IcxtlBK+SEhBFuNZXV1dY0zZswITKSkSMRk8/diN/3GXkDYfB0Ls34YIWRnxthYQsgYSulIKSX+NkAphT2/9fW8jMz6kvvGTORSXwUTubXDfF7ufUv9/jyHY0gphemSATgopRZxzheMHj36vd12223hSy+99Ml+++23pr6+nqXTaTVlyhTRu80oo6XLPLXkQVfmfXvy6aZNMevYtttu22/58uXjcrncvpZl7aGUGqGUGkoI6UsISWBxVUpFtn5bJ2K5E7cYILTWeaV8V/z+caujpfsat4beLgRSyqZ+/fp9lclkPhZCLKCUviaEmAfAGD58eG7w4MFhVVWVmjNnDpwjvduLdpxtvYDQjo2JVX369OnWRRddlMxkMgCB/Rhj4wgh35BSboutQiKRiJx/etI0O/jij1Fs0hWacOW8RjmAUOxZCn2v2ZK09Fmxd00mkyqTyZjQZZBIJL7wPO9DzvlbYRi+TAh5/ZVXXlm+7777win5X2dIOY3Qe27BFugFhPYZGEmE+ioqKoZlMpndCCHfppTuBUuAUlrJGHMSiUQU4sM+3Oy/419dziRvbcK1z+ts3F1KAYTWgAbtg7aCX0L7MgAOMpFIZIMgWBEEwfuEkFcIIc8TQj4ihKzWDsmNe/Deq0vfp/a21YYtMHz48OQJJ5ww4Prrr9/Jdd39c7lcjeu6ozzP24JznqSUIv4fXYgJYDzyJhqwMYBgrm3LCr6p+7IUQCjl+eGcNE5U/NYHSFOh53kIbX6klPo/KeWrp5122nvDhg17P51OI5wpe/0MbevlXguhbe3G995776Gvv/76gYyxb9m2vTshBEDQ37IsB5EB3/ej1Q0TFt52hOvwb3j88VncZ9C2R2j5qk0NEm3ZcpRzjTnXRCfApkQYFW1nOBVhGIJejZBmYyKRgNXwge/7z1RUVPwzk8nAggCrste/UObg6gWEEhrMhLzS6TS79tprh+dyuYMdxzmQELI3IWRbpZQbBIGFbQEmPg6AAADBTH6zwmFAtzRhy3UqtjTJClkgJbxmq6fEv6uUyd3aO5biaER7xUOipt2MxVBVVUWampoM7wEkKYQoVxBC3iaEzLUs6/nrr7/+X+eee24unU7TdDrd62soYRD0AkLxRkK40BkyZMiI5cuXf0cpdZTruqOz2exAx3FAC46owFjNsO/FZDExedza/NuQfgxFuNn+LRICLP54G57R3oCQDwClAILZJrW0LWrtvQwHIn4P065mO2KIWAYgcK6UMrIakHcRBMHi/v37v7xmzZqHCCFv6LAmQKEXGFpp/F5AaH3G9bFte3QQBAcnEokJYRiOkVJuAd9AocvMRMmfMPmrZb4DsdQJZr4zThqCBRL3T+CcuNMS9wYhyDjpzEoLgDKfGSvGkJzwmdnq4DqzlzfXmJU7f+JichoqdPydy32/Qm1bzjZIAyImfkYp9QEh5Dkp5WxCyLuaCPVfjnZbELcbX9MLCLHONem7Rx55pFNdXb3tVVdddWgikTjc9/29lVKDbdu2TJQgf0y0ZFIXGsj5W4NyJ0zclAZNOZcD45c0MxLNs5ltC54ZFgwmfpyOrFfV6DNMZEwkAAYmtnmmfIpzfNIbCwjnmvM0G3GDKRN/5rbMp3IAIe9c+BkQhfiQUvqylPLZqqqquQ0NDSvb8hzd/ZpeQNA9jGw8WPjvv//+oMbGxn0+/PDDCYlE4hDkFwghkDYcWQVmVcwf4KVaB7hHIV9BS2HHlsDC0JHjAzS+Yud/juc1+3JDLS4EInET3NwbgIHnMKu/AQLj4DPbovh7FXqfcoEv/m7lAEKB74GPAWmdcDQuSiQSsw488MC/zp49+4NUKiV6szD/29K9gEAI0am5/RKJxF6e5x3FGDuQUjoikUj0yWQyERBgUuAoZCEUAoPWBrDZB8cHfEuAYM6Jfx73V+DzuJWAJCY42/KAAqmIzWAWBw7jiWeM4ZwoMQk/yJpECqMGsMhP0tLqmO8AjG8tTDvELY1yV9lywCAOuPnfozM0QZVeQSmdSyl9OgiC52bOnPlRbW1tb2p2OXz5cjuxi5yPQe4SQkbbtn2KEAJbhBGU0groByCjEIMdE8ysnJiM8XTi+AAstPKX0w6tXR+fFLGJG6UgI+7OOceADoUQAo61IAgE59yTUq5FaI5zDv2CBqVUE6U0I4TwLcvywzDMwTeKe4Yh5A4YrCGQqSogpqITsUCz7mvbdqSzQCnlUkpYVJZt2xwRFlhX+l3RphGQICfD+DMMIBQiZeW3UTFwLLVNC91H+1uUECKwLGs5OAwVFRUPNzY2vkAIwTaiRzsde6qFwEaOHGmPGzdu6JNPPnmA7/snKaX2DsOwL8YwBlJcKwArMMKJ+BsshHJX/40ZwHpimXg6fodSymzfvn2b1q1b15RIJBo8z1vFGFshpfycEIKfLyzLWgnhkkMPPbRh5cqV4X/+8x8ABn6Mp938jvIBDjnkENLQ0EBee+21aOukf5jrujyXy8FKYo7jJH3f78857yeE2IoxNkRKibyMbTjn+H9VEARgbeKnCmBrHLB6ckYAuzHWQqlt2dp5eBa9pYLoS05KuYIx9twuu+xyy6WXXvphfX19Y319vVF+ao+v7DL36FGAEEuh3SKRSOwfhuH3hBAgF43AahhXDcKAMY62+J4733dQrjnbmnMtb++LyY/MPnjE10B9CB5ymLuY8FLKJYSQz/BvQshXoO5WVlbmTjvtNG/VqlVBLpcLxo4dGxaIv+f3eWvknfi55t8GLKJwrLawAAB94G9xHGdLSulQz/NGEUIAFoMppYOVUltCyg0mSOw9O2T8GWCPOVixXVpLCPkXIeRJQsjfCSGITnxNKulBR4d0SAe1L97VPvroo4c+/vjjxxFC/kcI8Q1KKawCjm2AYcbFnWTGOWdM3XyHVRwQihFuinxutuxYmeD8gi7Ae/COE0I+IYR8rP8Gj7k3YMCA3GWXXeavW7cuQEpwniXR7k1cSEDV/O3yyy+nCxYsoAMGDGBDhw7lf/jDHxKe51VmMhlsNbbmnI+A2AshZDtCyA6U0h0IIVvpbM/o0dvzgVvbepnPTB+b35rqnGOMfRYEwYuWZf1FJ1L9V1WmPR+yk96rXTuik76jeSzoDXzLcZwTwzA8HCsX9sCxgd78+IVi6BhIxbzoefv86H7mb/gdFzqBmR7blmC/v1pK+a5Sah5jbJGUEgAAIPhy6NChDTfeeGO4cOHCQit+p212tO2kSZOsGTNmwMcAfwT0HmE1jHAcZ5Tv+7tzzvcQQsCKgLUBpSXm+34kChN3luIl42IwceanaYByrbUCDRclUVFKGxzHeUsIcf+QIUNmffrpp8s6bSO384P1BEBApuF2QRAcK6WsRSoyYww6hAXfvTXeQEvOL0MMilsPZrLnrUiReZ5MJmUmk4E5iq3Af2CiVlZWvjlw4MDPbNte+eGHH2bGjBnjL1iwIOhmSTpoc/gjABBJ13UH5HK5LTnno5VSB0kpQQUfBKtNKYVtCIuHSuOgbPoClpsBh3gi2cbME7Q5BCKxJXNdd3YYhvf1799//ooVKxq7WX9s0EzdGRDwbrAKoEdwMmNsAuccKsU8Hk/f2MhA3AooFH4EMMCDr62DTBiGcPots217XhAEc1zXfbuiomLl2Wef3diT+PYI9Y4dO1ZBBSmVStlz584dsHjx4u0TiUS153l7uq67SxiGO4RhCKsCfovIIWn4FNjimWiPaXcDDvH+bQswmKQ0+HAcx1mTzWbfYozdf9lllz2dTqfRf902RNktAUHzCgZzzg+RUv6YELKPUgr72SjnIK4uXGjAtLTXz99KGMsgfj4GJ/xmmiIMv0BoWdbqMAzhC/iP67r/d8ABB7z17rvvLv/000/XpdPpzJQpUyIV47YM3u50zZgxY5yFCxeinyoty9o+DMP9CCF7IXckl8uNhBMToWADBPnWnOmPjY1ioA9jjEvoMPhCiMWEkMfDMLy/pqZmwZw5c77Wr+9mR3cDBHrEEUc4Tz311MiKioofZrPZY5RSo+EJ1yrFETmn2ApSzDkYHwNxUIhtGWARQGl4GWPsdSHEvy3Leg35+hdffPHauro6fNYd4t20pqYm4h/MmTOnXRKHzFautrbWfvrpp6saGhpg1e1CCDkY1h6lFJqUVVGNOqUiXwOOeBJZW30J+Q5jgALu5XmeSiQSyKZc5fv+C8OGDbt9v/32+7/6+vpu53DsToCAd4Hjau9EIvETz/MOhYe7oqLCgUVg+AOl0Gfzk4NaWwQM0cWcA5KQUuoTxtgjIL0QQhZgi6Cz7bpTUo3xB8AKighSsaM9rR30qVNRUVHl+/6OYRgeQAj5HiFkD8ZYAnqUBkSMqd8WC6HQuMgjo8EJjPcCuev1IAju/cY3vvHEu+++Cwn5bnN0C0CATkE6nYa/4HDO+flCiLGWZfUB88449zBgDeW32IBpLcQY4xGYMCEGQ+SZBhBgsSSEPDF27Ni5rus2zJ07F1TZ9pwgnWHwRSFc+Ghc1+2by+WG2bYtgyAALwITBNlW7fnOhv3It9xyy4psNrtDLpfbWwjxHUrp7oyxbYQQUZQC4jSlgP566JWXgm6AIL4FgbWg/RZ4r8C27cVBECC1+k4dDu4WfoUuDQiaaASPNVhyExhjZ0O5iFJqxbUJ4hl8JrW3pUFTKORoHIdmgGCwa74+7FUQWmAFPKc1/j6sqalZ2V33mDpC0M+yrN10+Hac67rDcrkc9tSLAIaEkKerq6tXzZs3b5NYRFgAXnnlleSLL744xPO8vdD3sBiklCNN+LIc1GzNOjDaEnHqNcAhl8uhvgRIYkitvoEQ8n4qlfK7eqJUVwYEWldXhxj3COQnUUp/zBgbJYTgxVb4YhZCvMCIYSnqParSKcLIHWgSQryXTCb/ns1mH99jjz3e3meffaKsIhQYKWdAdpVztSUGgtHBlNJjLcvam1KKmpIoFQ2eRoZSivj9bWPGjPnLwoULv9aK23QHr6urS7z88stDP/jgg7183z+GEAJH5CBI2UHdGiBumInGQsx/nHIsCrNgGPFXpFYzxmZJKR9Ip9OvoQJVV44WdUlA0AMTlsFujLETKaVYIbaTUuJvzUdLrMJSBkCcFGM0/bQZjPyBD4Ig+KeUEgkx/x4+fPjypUuXdjsHU7wtU6mU89hjj20TBMFJUsr/oZTuBD4HchVMdiPaByXbOOf122233TmLFi1CebZNdhgquo4qVTiOs41S6rAgCCY4jgOAAJ0abOkoumTk7fKdjqWMB2Ml5r8MtkpKqXVBEMwbO3bsn4866qgnr7vuOliNXfLokoCgzda9OOdnSSkPU0pB5TiiH8eTZ4oBQksDI14mDTUKIfDJGAoni5WJROKvnuc9g7qEuVzuy3Q6ne3KK0KJo9axbXtsEAQ/5ZyD8g15+YgbgOvjXA5KKQRJnk0kEpMuvPDCpZuzbfRCAd4CRG/HU0qPUErtCWczQMH4fwoBQDFQyN9KxijPURMkEolcNpudv/vuu98UBMETCxcuBP28yx1dDRAwCOE8rE4kEr+WUu4VhmEfrBTGEdSSZmE5oSg9OExqMfbGyB/4t+M4d2yzzTYvJhKJNZvBHO7wwaQn2FbJZPLb2Wz2VNd1v4U06FwuF42bmIM1elbtY0E2Jvwpp6TT6RWbExBiDcb79+9ftWbNmm9wzn8ihABVfSiiEnq7qKvltWxNxhu/0MKR71vQMnWoOgWZtj8TQu7TSWft6Vzd5GOiqwECCqEeZNv2z4Mg2B/In89vb03V2LRmfCDnMxXxmdYbQIostAPeCcNwVhiGjxNC3ulBBUEAvvAXfI9zfpwQotqyLGglNMf+8/kaOpqyinN+ZxiGaR1q3eSDuJUvwBYSPIbxyWTyR9ls9psmh0XLNax3aSmOZnOBJqBFkSuzFdGWJSpNLfM8D9GHO1Op1GddydHYVQCBHn300f0effTRgwghPyeE7Ms5dy3LimTPjQJQqbn2JTARIRgCDzKEOZEO+3IqlfqiK3VsG2ehGQ9J27bhoD1FSnkEkpESiYTjeaic9nXZ9xb21NguvEkI+TUiDdBuaONztMtl2seAeyEvAhmW3yWE/AC+J7AhY1Gj6J0KAUIhy1IvGtEzGsvU/AYoBEGA6BO4KMiYvKuuru6jruJo7vSAoB1GruM4h/m+f4Zt2+OhcYiRaSisMaffeoVQio2qvAFheAVgpCF89pDjOA/7vr+kh/gJovGNjETLsvYMw/BEpIhD58ACI0dPmEIRmtikaVRK/ZUQcjkhBHoNnYaNWVNTY73++utbNjU1IYEqRQg5klI6ML44tORzKjSOTOTCfIY6ERCYMYAJlxZSqSmlf/F9/8+pVArCK52eq9CpAQGd+MYbb1SuXr16P875BQhzQZEHyG9MNjNQ4+mwcVQvZA3gGvw9lsQSse2klOuUUv8ghMwkhLxQU1OzvBvzCfLHOcBgIOf8CM75j3zf/6bjOP2xRYgLxbQCspj8EBW5HmCK2gjFALkDPsd4h7UA8ZZjKKU/opTuqNPg17MQWvM5YfwYZWrDa8l/FwAGhF2FEEs55w/5vv8HrWbVAa9d+ld2ZkDAs/VNJpMHZ7PZiyil4LFHK1Wxw8iJx2XQsNeLKx/hHnAEAQiCIPAZY+9IKf8ycODAvw0YMGDxokWLeopaDn3hhRf4d77znW+EYXgCUsQZY6hGFanKttTecXVmzjkcsI1hGMI6uBYknc5kHeSPFyw0c+bMQRIVivKeqpQaj2K9CFFiGwrLE+8dDz3HF5D8LMtC49FYn8hZoZSuUko9LIT4vQaFThuB6JSAoPd+6KDDCCG/QLaiZVk2BqEpKtIaKJhBjPONfyGeIQdwQEZiLpfDqoaVbK7jOLduueWWcz777LNV3ZBqXLC5dBQBE2MsY6yOUnq4UipKETdg0NK+Ov53y7JEGIbYZv1WWweddsDHG2LChAkVc+fOHbN69epjQWoCEGoLYr2CM/EcibhFUGxxijNbNaX7HinljHQ6/UEHRV+KraXtK11V9NtKO4GmUqm+9fX1Nclk8iwwz7LZrIs4Mi5vyUQrZLKZNGdj3qFjYTXkcjkkqmAQQ6fwadd170mlUvN23HHHnsApiJqqrq7OnjFjBib/gclk8njP8w7QqsrNuQBmwLc28LUjN6eUmkUIuTqdTr/VWQd7oeEHwlV9ff0QRFMsyzopDMO9XdcF9T2yFIy1iWvzFaOLAUL8+/Qis5RSet+3v/3tGTU1NUsXLFigOptfoTNaCJBFPzCRSPwCg5RzXmlqAhjELdYR+Dye1BTvVN1JoBa/5zjOTN/3H54+ffoHkyZN6pZ04xYmAa+vrx/BGAPj8IeWZe0KDUSjNWBi7PF2Nn4Xc78YyQd7uKWMsd9LKe8Adbc03O88Z1VXV9vz5s0bwjmvEULAmRrxLVC815SyM+9fKGRdxpuAS/2xUuounRQFgdxO5WjsdIBQUVFR7fv+FBRLkVJCyjuKexfxbq/XJyYshN+mhBlO0OpFIM7MJ4TcfvLJJz9x9913f95NtAlKGpcY/G+99Rb0DE8hhBzNGAPl23ZdNwrhFmJ65ocZjVNNr5pQhn7G932EGlFUtSsCq0mdhzALJPZ+5vv+sUi5zmSQnkEjJ7QpdlPMcsonbMVANFLSRhKYZVm3BEFwdzqd7lRKWZ0FEEw67Sjbti+FBzgIAuTBR0c8UpBXdahgjYRCTkVQkIUQDWEYvl5ZWXnNqaee+vq0adO63GpW0qwvcJLeIsAvs5fhcvTp06d/Y2NjVJkKbZxXdyJK81VKIUEJfQGSTzReYqpTSPZCsZOrCSFY9VAMpsseOsSNWhTDc7ncsZTS05VS24KmbTQX4kzYYkSmlsKYSqkIFGzbvnHnnXe+98033+w0EZnOAgjIZUf45zRK6SlKqQH5cd18YMjbn603CI15By9xNhvlHElduOQFy7L+tNVWW726bNmyTJcduWU+eDqddtLpNCTQD6GUHo+SdblcLuJy5FdWMlmdSik0HJiZGCM7acr4euOFMQZdgFc9z4OvByngncr8LbOZotPhaIWk/CuvvNL/s88+S9m2fTpUmlCdKl+huzVAKAIWyH0Ic7ncO1tttdUVf/zjH2fV1tZu6szQkpqjwwFBh4BAkT01mUz+NJvNInEmcmyZlciYYK2YYuu9rFnpEA5DRhLnfKkQ4hHbtu8/8cQTF9x1111fl0vuGQdyP3bG9iCRSHxfF1AB0YvGIzbG52JZlgzDECXNwMcA6/BIbVU0JzOh2bTmIM6bscUWW1z31VdfdStrS0e6BjHGjpFS/gTsRsuyKkxKNdqgmC+r2PBCqT3Lsp4bMWLENQceeOBrQ4cOFR3tkO1oQMD3DwSd1LKsXwghsBLBPGtuy0IgUKjkOAY0DhNDtm0bYACaAZw49xJCkK/+YTqd7lA6bbFB0l6fGxGRv//97+OllOAXIOY+DPwCA7gm6gJg0JZCqJRaSgj5GyHkMe1cO4cQgqpLzWPFcPYJIfMty7okDEOkgXd56yC/7XVYdgtCSA2l9KdKqf0555Ffy2TWmnB23IldyHo1BDrzmV7sMNCRKv0otg9BECzsaB9MRwICvhvip9DH+6UQAimrkQxWSw2a32EYxMbkjRdg1YABjsFyQsi0Aw444M5//OMfX/Yg5yHQEZMYhJvTkR1q2zYGMnK4Iyetsb60dDmAE4Vf39EVi57Vbf0bQgi0KeFniPcLTN5VQoh7wzC8TpeZay8s61T30ZZCX7BkpZTI7QDtGZyYCBQAjgBUTHiTNp/PlM13QsYJc9jOOo7zpZRyZhiGN2rKd4e1QUcBgnEifpNSeqlS6ttIVkJD5isit5SIFLcSDDDoc8E8BBgstSzrvh122OHG999/H6ZtTzlc13WHhmGYQj6CljCPHLTxrZf2moOPgS3COkrpP5VStxNCIAyLSMEPCSGQBoMjcr3Dtm0vDMN/KaXgTISGZKfY/26qDtagYNu2vbNS6nIQuIIgiMYrmI3gu+QXlCn0LAYYzNg1hCchRFQUxrKsGQ888MAttbW1qNXZIUeHAAJCX2+//fYOnuchVPU/lZWVlSi5jiNOiTWDON4yplHjKGusBF1xB7HeJUqp+wkh92jELc537pDmb78v1YMWVsAehBBUqEKW4jaMMcskguWXP7MsC1GEz4QQz1iWdXcYhnAMwtmKzEBEe36kowvrdQHKzgkh7nZd98ZcLocalN2+fXUDwIKFRNtZlNJDEZZsampaL/LSkkybaUAzfvOjZa7rwsmIWp7XjBkzpr6j9DY2OyCYIioYbJzzX6EysLEKChVRKZRkgoFtrombbJzzkDH2ESSy4TNIpVIfdzYmWPtBwNd3AhDU1tayV199td/SpUtRu+B4Qsj+jLGBtm1zmLNoo1zuaz+qXpXgX8Gq/j5j7FEp5f+rq6t7Z8aMGfCvQHbs+4SQKYQQFEfJHyM4581kMnntcccdN6uHOWjRhJWEEOgqnAmVb8uyKsGijTtoW0uMMouc4dXEM3Vt2/aVUq8MHDjwwmnTps2tra3d7H6ZzQ4IYIBxzjHgfi6lrOacW6byMho134nYGiDEUVZHFCCDfseECRPvLIk1AAAgAElEQVTura6u/rijPbbtPfnz7wcwGDVqlLNo0SJUUj7ctu2fBkEAnclKKSW0BJsJXfEaA0EQwAr4v4qKiocymcyLsKJSqVQ4f/58a9GiRQhPnkcIOUGDQ/7X4lpkM/5GKfVhT8n7iK3wMLhAYNpXKXWGVmNCBmU0l5LJZCSY0hrL04TF4wtbLMqDjNuZffv2/cPq1athsW1W62uzAsLMmTOd2tpaKB1dwDk/QAgBmnL0DHGRk7iDsBAgmMY22WgYlJRSEGRuSSaTdx511FHLurtlgDYbOXJkYtGiRTDvsUX4IWNsJ2SEGqq38a1gNQJgBkEQFRphjD3OGLsjDEMwNjHBserjM9CXDxNCXKJ1CaMkp9iBcz7gnF8rhHiwB6lHFcJ2hHP3q6qquqihoaFG59pEDtt4zkN+xMxYCPGoAyxjjHld/xNj+VMhxJ9OP/30W2+++ebNWghmcwICPN8gH53LGItWHzQAHCxwysTzD0zrt2R6xXgGaEhhWdYXqLnXp0+f3zU2NiKy0K0PXQMxMl1d1z0pl8sdwhgbJKWMJnABNieiCFnLsj4KwxDhROj9odZk3BmIawEuqG1xknYmrhdZ0Of/hRByBSHko27dyEVeDtbZfvvt577++uvfFEJczTnfOwxDC/kPZjzrLV3zneIOcuNYjG+TY38LdQjy+pkzZ/61trZ2syl6bxZA0OQjqOGeBqVkzvkQrGJxS6DY4IpvJWKNiPoIXwohHvrOd75z8+zZszHIN6uJVey52/tz3ZbIzoNw6HGUUigA9UNJs/h3xQZfJI2ulPoPY+whKeWz++677yeoVfjCCy9Ee1Rt9sNawz0vsyxrXBiGPB6VQDRCSvmJEOLyoUOHzuxJTM/W+nDy5MnJm266qVYIcTZjbKxt2w7GNnxc8RyIQn1TYAvYvDNBWr5lWc9PnDjxNwcffPC8zeVP2CyAcMQRRySeeuqpg5LJ5JVBEOwJxqwxkeLWQCHzKm5ixfZxkQkMUocQApWCfj9z5sw3NlejtfckL/V+uh2xin+fUoptwjd0/n5zP5rEI5CytKWwglL6EgQ6CCEv1dXVfdmCvt/WcJQxxs6UUvY3MXU8mwbgrOu6L+RyufNqamoW9SAlqVK6Z8tEIlHreR4cjTuhJAD6IT8hr5Rs3VgUAovdyiAI7unTp89vN5flu1kAYa+99tpp/vz5aSEEKuskTEZdSwCQ3wP5jkadwZixLOvJMAynTZ48+fWpU6duNrOqlBGyCc6B9z8KKTLGjiKEDFdKNSccGeA0Kz5jDLUWV9i2/ZcgCAAGcFChjaAEtYEVZVkWfAdppRQ86M2+gz59+pDGxsYoTs4Y+6OU8raamppMLyD8t4c1oxHOWEiyTaSUjjCLnumXYvT7+HiJgTp8Ox+4rnvNhRde+ODmYNluckAYPnz4FmvXrv1ZJpMBG3FLU5Y97lQxyGkaxSBr3IcQAw8MZgzQuV/noqSf2xwNtQkmeKm35EOHDh3w5ZdfHiSE+InjON8KwxDbr/Uo3jFAgGUA4hC2Tw8lEomZnuehCCuch+jv9UJZOgw8AFEf27Z/EQQB6jZGJq/ZmlmWlWOMzfF9/0JCyFudWR6t1EZt7/PS6bSVTqdHM8YmgSqOsK/R/oz7DoqFJM1zaaKT4pxnc7ncC3vuuecv//3vfyPZbJMemxQQdJbdt0G2IITs6boui8dry0kOiZVaxoD+EKh52GGH1c+aNau7Zi2ibyywDn3fx/YAJdRGU0qx14+OAum1AEqErVBj8N5x48bNnj9/PorMoM0K+lZqamrcOXPmwA/xO0LIOBMGNmGwZDKpstksytnfpEU9IE/fexRuARCXIOA6iRACSyEBSwGnxrcPpYAC+tbQyoUQYC7+6dBDD536zDPPbFKn+SYDBDi/Bg0aNPrhhx8+nzGWEkJABz8KyxhJs1YG9gbNrQEB2UoYnFDmuUUptbI7xsGN9Lxt26ODIABb8Hg4YqEraYqCFBiPAANIwsGnUo/Eo3Q6vaoYF2PcuHGD5s+fj2y+KX369KlsbGxsrmqkt2bYYrzkuu7VuVzu/3p4qLFVIMTW4dZbb02uWrUKlbFB6/6WZVmuKW6TL8HW0s1Mpi8+1zKA6NuFnPPrhBB/S6fTTcX6ta2IvckAgRCCLLGTGGO/4JyPCIKAGVaWkejK3ze1lBTy9WKo0ChfKaUecRznJs/zFnY3MDCsw/r6+v6cc4SzjoXn33GcoSAaxc34WNth5Uf4ENuC/wcJ+Zqamvewzy82aEAhf/PNNxFR+LVSClTnaDWLATba/UvO+YwwDG8jhEDyq1tHcdo6kWKLGx02bFhy2bJl8Jf90rbtXTD2sV2L0+1bsxLwGeYI+ltfg5yTpjAMUTQI1jb8QZtEmWpTAQKcXVHiEmTUfd9HKCYycQ3XuxSzKWYWR3F0nUgD3X+YxN3KiagdU3DmgXX4XUoptP125ZwPUEpFhWzzsuSiMUgpBSf5DbDbCCEoN/dZGYVlBti2/aMgCH6ZSCRGINffVHLWfh2fUvqyEOK6dDr9Qjqd7tZJTBsLBrHrMa+GEUJ+bNv2pCAIhgNn89P2W5oDOvEsAoXYdgPUUxS/gWMXOTqbhLDU7oCgzV0k1ZyvCS6Q+S4ppTnf+YIGgcmUSCR8z/PmJ5PJ67PZ7GylFITuutVKpSXOtkV5e3irpZQgcdkguhitQ7RPzEpAWGqNEALZhiAavUIIQVYnLKlS2oY5jjPG9/1LGWNIQQfRqbluox7cqxhjd0oppyqloD1Zyn3bcV516VsB3EfDSqCUHgsdhfych1LeLgYa4JMElNJ/CSF+XV1d/fK8efPa3UpoV0AwaaKEkAmMsZsYY0MNwhkHWCmWgQm7hGEYDUDO+TIhxNS6urrbZ8yYAUGJ7nRgGUCKMfQgTtYlxgYZopERfjFEFwi/+L4PJ+FHjLGZUkqEFFETAemiJU/YqqqqgQ0NDbWWZU0G+GBLEuPTR3s0IQR8Blek0+m/91oH5Q+53XbbrXLhwoX7CSHOg6JzGIZOvlJVobsWmSNrlFIPVVZWppuamrCFa9ejXQEBZu999923/aJFiy5njP3IsqwoNBYnIRWS+I6/UWz/hH0TVkREER5wXfeq7pRqq8ETWytsEQ6ilJ7AOY9CivDqxTMU0T66iCgmfE5KuTCZTN6fzWZBQ/48lUp55eRuaCtuV0LIr5BoJoSowHfGk20YY/ieP1dWVl7Z1NQEz3bJYNOuI7QL3wx9/M1vfnOL1157DQxQhGx3MX6a1l6rCCBgMfjAtu0pF1988V/bO+TeroBg5NAopZcxxrYxLxaXUW+BW2D2wzHfjFKu64pcLvcfQshkZOfBsdhdzFZEYV599dXtPc+D4/BoSulYpRSy6CIOgDkABNq5JD3Pg3X0qiYbQdVoRTqdVsWch/mDb/DgwZVffvnlMZZlXRSGIfQWm6s66/6RyGTknIM7girO8B30AkIbwEnzE4a4rntaGIbnh2HYnBnZ0u1aqothzrdtOxMEAfrlYl02r936pt0AQTvFxsHERMZcS7UBTepnSxwEzehSyWRSZLNZmEQokgklnzVt6I/OeAn2luASYH95AqX0B47jDPc8D7UUo/4wrLZYrnwUUmSMPQGpLZCylFJr2gKOup9GMsbOkVKejFRps63Dby0zDi7DUyijV1NTs6qXlbhxw0hTzsEy/Q3n/EDo/rZ2x3gULl9+TV8H63lZGIbpVCp1ZznWYbE3aTdA0HvSkyml53POtzaxVzPAzSAvhYyEGgqe561zXffRXC6HeO5inaJb7H06++cYCAMSicR+nued7DjOfkEQbIUoQkz1KQKEWC1KCJ9+aFnWA2EYIqwIBmKbC9HqQi3H+L6fBu/esqwonGn6CSQmSukHUkoUbX1gU4W3OntHtefzaRBGavmxQohf6cWgRVAoZiHoHJWc67p/mzBhwpT6+nooLbXL0S6AoM0iJC1N4ZwfKoRwWpv4+bkJ8TfRn8FERWjxqpqamhfnzJnTHWTT4S/YVkuhHwdZb9u2k3AyQT6ugJI0rAIkFL2Ty+VuIYQ8O2bMmOUbKa2F/kYS02WQvYeorUmVRrsjJycMQ+glPCmlvApkmN6tQrvMs+gm1dXVW8+bNw81LP4XC0NLd27JhxB3zINBmsvlPpdS/i6dTqOAbLsU2G0XQNAKv6dyzs8WQmDArZeKm//iRQABE+FjSum0gw466J7nn39+k8Rb26+bW78THEvbbLONu3z58h00BRmElVHJZDKRzWajQilw5iG8amTR4eAPw3A5pfRFKeVDqVTqhbFjxzaU6yvIf7JUKpWsr6+HQM1U27bHBEEQ9X9Mhg6hzMVKqd/ie7vRNm1zdXer34PQ8h133DE+DEPs/Wvi1bDyF8XWbmRozUop5Jg8+b3vfe/yPffc8+0pU6YgNLlR/oSNBgRtDu0J6qvrut/N5XJfF0gocsRVag3Pu7KyUjU1NcEaePzQQw+98tlnn13QVaXT0S6zZs3i8+bNAw8DBKMThRDfIYQM5pzbAAqjrqOVcqKtQgBaG2MfSylBMkJIEcVSNroICp7n3nvvHbZ48eKJUspzKyoq+qCqlSGLaTUlkL1mo4qzTmLqJSIVG8jlfw55fAjQnIc8lVwux+IiKaWE5WNbCmhUIOQMsh58S+i/jao7stGAoGW8fuq67qW5XA68g6L3NNJnpi3jtQIppe8ppX5zxhlnPHLLLbe0ixlUfp+1yxXwJiO7ExWFIWl+AKW0XyR0qBOTzGSMaUlCMXqhUgq5Gs9B67C9SFhnnXVWYtq0aVAMvjyRSIz3PC96jnjbu677WS6XQxLTn5VSqzd2tWmXVux+N4HvYAzCkAj5Msb6GOsQ20aI4RYDBbN1cBzszFVTEATIXwH9/ION7bOik7dIf1DHcXbxff9qxhhirZHWgU7IKNqVcSquZVnYvzZxzu864IADLpszZ06XjSpoVaMRjuP8yPf9HyaTydFhGLow0eMy8zG/gbJte10QBP9CVhsh5PlUKrWuvbzHsEYGDRo0ZOXKlRN1oddB8F3AcRlzXnqc87+HYQjfAfw3G7XSFO38HnzC8OHDk59//vkhQghkmI4ylbQMQOfXJslvKmMh6L7DNm+JEOL6J5988q4jjzyyzQ5nfM9GAYJOnf0pwimEEOTob6Ca3Fq/G4eWXqUwAN+wLOvCMAyxOnbJQ5N+kAJbRwhJUUrhU4kIWuZ9TSHbr4V1lJBSIjEJ5dPqBwwY8Nahhx7a2F5goBvRtSxrvzAML6OUwoeAWg1RSi4ACmDsed7n4MkTQm7t9R1s+qGXSqWGPPzww7+QUp6DjMg4CJRiIZiFpaKiAszVbBiGL1ZVVZ3b0NDw7sY8/cYAAq5FLcYb+vTp890gCDg49/kCnyUAgnGCrHRd97atttpq6ieffIIc/q540MrKyq2amppOsm37bNd1hzU0NEThpfwoglYi8hzHedf3faQrP6KFSwsqGrW1MWAdVFZWbp3JZE5xHOcM3/eHglNvBG7xOwzDwLKsl7bbbrtfb7PNNv+C1uLGmp5tfd6ech18Or/73e++2djYeKtSCrT1aPuGo5iFYBilsbkGR/wy27ZvCIJg2sYI2LQZEOA7+OSTT470ff9m8A6MhlyhjLxCnRx7GXhGfcdxXvY8D/LfMFfxgl3xQMm0/RKJxOWe52G/HvELzOTDC2kqt5JSQnhgnlLqPtd1n83lctAy2BSMQIyy3W3b/lUQBBMgsGKsA9PAlNJVtm3fusUWW9z0xRdfIKrTVdu/S42ZHXbYod9HH330S+hYcs77mahPMQvBqI7HsyFd1w1yudzs8ePHT3r55ZehGdKmo62AgOu2Y4xdxBg7WUrpGpO4HCVlvBhjDCYPuPI3VlVV/amhoaGrhhnhpNtSpxNflkwmt4QXP+5ARRGPbDYLiwgWEKinD1ZWVs5tamqCIs6m8uijoC4qOl0mhIBeYrMAipa+ByC/GwTBz0GLrqmpCXqZiW2aS225iLmu+22UNFRKHaDL7m0gztrSjY1zEWMMiYBhGC7u16/fryZPnvxIW0PUZQOCqSGoC3pcYVnWzuDfwztq2HalsBHxkjBLEUtFzn1VVdVl69at67LWQUxocxLnHBV9quJistpyCm3bXqZFT1HfwNRS3KjYcZGRiGgHRFlRq3FXkythRFCklNgeLLJt+zLf95/XIc5eh2JbpnfbrhnCGPuZlPLnjLHBYPgWsxD03ImsTWPtgUsipUSOwx2pVOrq+vr6NmVClg0IeuAjvHgupfRnKM1WDi05/jJQBpZSwpk1bfr06bdNmjSpS6c2Dx8+fNgXX3wxSSn1C9u2+2KrgJCidgBFgplCCEw60ILnbaItQv6wRN7EoY7jXOL7/t6QCDeDSG9lIqcUpRRJUzf7vv93DQqbEqTaNnW651UOSs1rxWtUgIKnueR5mQceAPdXKaXpSy+9FII2ZW/9Sv7iWF9gn/wtEJEopRBQbeZkl2oZGD8D5zxA5eHRo0dffsIJJ8xrywt0pjGy//77D/jnP/8JQVRUNtpKb4kiJNfEHwha/NtxnN/6vo8tA4gkm3riWbZtj4MqkmVZRymlkmZbB4tOV86C9gE4Hy85jvNn3/df0JGGTf1snan7OuRZsMC+9NJLg55//vnTLMs6IwzDwUaYtZwH0sCA/vpSSnnT/vvvf9s///nPsp3zZQPCGWec0eeWW275KaX0AkJIMxGpVDDIe8kvE4nEDWedddatN9xww9f14Lvwgay2Z5999pu2bV+TzWb3Nd58vBL2eb7vwyKCj+Qh13V/n8vlPt7UDjy9xduKMXYsY+ysMAxHua7LYR3EeQg6oWwtpfQVpdSfwYVAIZwu3B1d5tF1LtC3OOe/EULsi/qcpTx8vuiQBoWcUuqJ6urq9Ny5c98u5T7xc8oFBDpu3Lht33jjjcuUUqBfJgpIgW8gD17ooTT3AIo80DoAIafLr0Z6OwXewelIL0ZqsRGIMdsqzrkvhHhDczfAMGt3GawC7Q2lnlG+75/MOT9FCDEILpyYHyHai8LBK4RosCzrFc75rfvuu++TvQ7GcqdUm88fBkFiKeXplFIU5WnxiOcCGT+C2YpTSsF2fQds3+eee+7Rgw46qKzEwHIBASEshK6uJIREwhptsQx0jLuJUnrPwQcffPFzzz3XnVYiaPPvmUgkrvA87yDUOcDWwcingwREKV0jpXxUCHFlTU3Np5t60sFK2H777RMrVqwY1dTUBJm2iZZl9YOoKgaXCWMZLQq9lZmPFeuQQw558Zlnnuny1lubp+lmuhBWwlVXXbWfZVm3eJ4HanOLc9P4DeJzD3/TP4g2fJVIJO7+4x//eP1pp52GcHbJR1mAsO222w5YunTpZKUUVvVmFGsDKMDZ8V4ikZjsed4z3cE6iLU42rS/ZVkTwzBEO6GewnqVkHThFOgaXDFmzJj6jUxpLrmzUTjnhhtuGN3Y2PjzioqKY3K53JbQUjSqTNhCxKwG5Nu/mMvlbj/hhBOev//++9skyFLyw/WeSA477LChzz777MWUUrBcv2YpFTgKZQsbQNCWQhiG4b8tyzo3DMNXy9mWlgMIOBdWwQ2UUmTtrZfiXAYowNueEUI8duaZZ5518803d1XeQYtDWCd87e267kW+7x8qpYTVEE8kwsRDG0DwBGSspZtrPiDJ6bbbbts9CIJTk8nk97PZ7GCTcAW/gkl20vRqZFm+xjm/87jjjnvqgQceKNtJtbneqzt8j1ZWOpJSCgo5KnwXlBHItwzW8wFoXYsgCDCmrhw5cuQ9ixYtKjm/oWRASKVSzl//+tfDhRAQ62jWSyw35Ai0Yox9IqW8Bll92PN0h86Mv4N25KFDTyCEnGVZ1rbGPMd5mnoKGax3wjCckkqlHquvr99UxKQNmjedTrvpdBop6yik8wMp5VZIdoonpenQpHIcp9H3/X/Bp3D44Yc/99RTT210KnZ36+/2eh/tg9qJUopiLBNKAYSWvjuRSCAL8lEp5Xm6oldJj1kSIGje9RZNTU2nSSkhvRWtePnIpM2V5qQZ/N+YoRhgWkocA/9lpdRFmqbc5Z2JLbQ0wrO7UkphAh6plML/mw8NCms5538ZOHDgb7/88suPNmf+wO9///vkJZdcsms2m0UZN2g79jfy98ZS0BwK0KwbNLV8xsiRI58qZ8UpaRT2ntTcAkOHDq1YtmzZmYyxCyzL2sL3/UhEBwf6pSVxIeNXMByTZDIps9kstDROLycdoCRAgIPDcZydfd+fxjlHFeINrosTJAyNGX8DIBg+P7L7LMta6XkewlrIuwcpqVse2kqATFat4zi/UkqhnN167eY4jvR9H3p4N5x//vkPbe7Qqy7GO0r7OyCpVhWXY4ezEcDleR4qSmeklBhgvyWEGJ5Ct+y7Dn4pjJHDoG+AvBjwyOJO6ZaeLQ4IRoKgoqLii0wmg0xklOErKZpVFBD0wAbb7TDHcab7vj8kf/LnP2Rcp0/z5Y11AMHQ/3DOp+yxxx7PborKMx3cmet9PQRN582btzNj7EIp5Q9QbgEnxOofwDpqIIQ8atv27y+55JIF7a2zX6w9sBV87LHHIAd/NmMMpKqB4E8YUMc2wvQ3Ywwh05c557dNmDDhmUceeQS8he5q4RVruk35+TYQUEkkEhPjatzw78RrnLRmoes5mOWc3w9h11L1NYoCArYLN9xww8BMJoPtwgWO4/SF6d+CPHTzMxp9wHj592QyiYKVD++5555X/etf//pgU7ZoZ7l3dXV1v3nz5v0AhTWCIECptijUZ9iClmXBI/wBYww1+5DfAMfdZp1kY8aMcRYuXFitOQrfh8yb8SmgnzWpKjJZGWONUkrknPw5lUo9XV9fj8Ss3qN9W6APSvpJKaG9uE1FRQXNZFCv6OvFpFACYdxCMNsGXSD5Zdu2zxk/fvybpYS3iwKCFvxAZuNvlFLHKKUipV4cGCwtRRdMGCTmuY5oldB/q6mp+dOcOXO6sjxayd0PQH3ooYfGvPfee5dIKbECR40Xax+Y402WZc32fR/OJJjlJZl3JT9EaScijIxqTj+GXDildBAcoXmqzFFWneM4Db7vR6Bw9NFHP/3oo492WXWr0ppm856l63zunUgk4K87yPM8a8CAAWT16paDPIW2DNhqSCmXSikvS6VS95YiulMUEAghFTp34VpKaTVqDpqsRgMK+c0VJ07g34a2K4T4T2Vl5SVNTU3gHpSdeLF5u6V9vg2AOnv27H7r1q37H8bYFVLK4UYsxbRNNptFitsnSqmbBgwYcMcvfvGLjVZYbsvTw9F47rnnotwY/AnHMcZQeToCffS5ATEhBLJUAeivO45zm+/7EHdBibHNatm05R27yjXnnHPO1jfeeOP5lFL0RT9s3ePM0pbmnLEOTL6Q4zjw/dx66qmnXllKXdRSAKE/Y+wkpdQFjDHQK9crNdaShYD9jqHt6nNyjuM8eNxxx6XvvffeT7pKx7TXcw4ePHiHFStWXE4prRVC2LZtR+2ItqmsrCRNTU1+IpF4zfM8VM1+vaMAE9uHL774YtRXX331Y8jAQbgDxVwM09K0h+u6qAuA+PZbSNY65JBDZveGJNtrtBByzz33VJ588slgBU+BMhkAAQSy/H4w35gfZTDqS0EQhJzzx1ExWitpt/qQpQACEphAnkF4CtVnmgUcCuUxGHPYrCw4Hz9aBOWaVCp1y+aMubdfF23cnVBPceXKlSkhxLmMsbHIaNPtEt1YT7DVjLHpKL+uS7t3yIoLq+bpp58e2dDQ8L+62tAwbHUg8GJ0L/DMOoLkSSmRkzLje9/73lOPP/54L6Nx44ZKdPX06dPtSZMmVSPnhVIKxW6r1LCjceTDIWzbNizxt4IguDSdTj9ZLKO4VUDQWVjQe8Pe9hAMiniEoaX3NkARk1NDrcY3+vXrd+7nn38+pyd6puFLuOaaa0Z5nncWpRSJYf0KcNIDpRR0ErDne6GUPV87jL2Ct9B9D/GbH4dh+CNCyDBYCuZkbCF0BAI8hQzn/DXG2J1BEDybTqdXbu5oyaZqh466r47uwXd3ga7BWWHqlxR6pnwLAedo/w8UvZdDlVlKOYMQ0qrvrpiFYNR2poCHAP9BMQFI87AwWRBhQAad67phJpOZdcghh5zx/PPPl5Vs0VEdsom+F/4YyNVfQilFYdxISyIGstibr1BK3QjRmGKdt4mesfm2mqcwFj4F27ZTqEMZlwwH4OOQUkYakYSQ+Yyx+6WUUJDuLSG/8R2EIj+1ruten8vlotJv+TVNCm0ZjK8B40qzTxts274nCILfKqU+aW1BbhUQbr755j5nnXUW9pEXBEEwyOT3F7MSYCEYTjzISEKI1ZZl3bj//vtfU0roY+PbsdPegWuCF7JFjwTjM56Uop8a6ar3SikvV0ot62hravLkycmpU6fuhugDYwyWwkAMSuxlDfsUz63rakDw5S0QYQYNGvT/zjzzzEwxE7XT9lTneDAg7l6I5iQSiZ0hr9ZSzZNCFoLuF/ipIFP4TCKRmNLY2PhGmwGhsrJySC6Xu1wIcSr2MIW4BYXazVBgscfU6b6LgiA4lxDyZEc5yzpB/0ZZkIQQCJ7CcYiOjuoj5AEsVto/SymvU0p90dGAoNsNmXcjCSE/015v0JyjkGS82hAqCXmeh9yUdwghv6+qqnrivPPO+6oXFNo++lzX3V5XQD/OdV0Gq7vQ1iEOCCYqFPNRwY+APoGo0bOtCfq2ZiFE8t2c8yuVUt+N1yEsZiGYAqaalISQ2utKKTgl3+/BoSmg/S6O45zj+z4KvkY04byhAifiR0qpq4cPH/6XpUuXYsXtLAeefwdCyBmc81qlFARBmY6QRM9oTFXbtoMwDOcJIUCZfUIptaqTAFtnacuSnkMnO/VPJBI/8TzvOkopaoIWvLaQhaB5CLDWYaV/Tim9OgiC+1qrFdoiIOgUXuPRzGwAACAASURBVDgSwYWOCkmYsEcxQDAPramWORQuraqqOr2hoWFlSS3RDU8aPXr0lu+//z5iyj+nlEZe+/zXRB1HQghSoqHJ+FFnA0/jaCSEoJZnbS6Xiyp9xytYa0cyRi3ADA7SOydMmDBr1qxZPbbvN2Y4m3nIGLtbSjnQaGvk37MQMSk+Z8GAtSzr9gkTJtzwyCOPwL9TGFha+kA/CLLgoBAMTb4ozIRJXsyxaKILWBUYYyvDMJw2aNCgqStWrOgR7MT8NkUI6dxzzz2wqanpSs55tZRyA/ELpRRM7YVaLh0CrB3BViw6duFovPrqq3cOguAnrusen8vloKcQ5T6YcBfGCTQafd/PKKXmW5Z1x8EHH/y32bNn99Kci7bwBidg0UaqOqytPTnnrBTqMu5irHrdH1nf95/Yd999z3/llVeg5VkeIIBz4LruOblc7teU0sj5ZTq9mIWAb9Jab5AL+0hKef4LL7zw+EEHHdTttA+K9S/Mvuuuu25YNps927btM4IgQOQmf7eAFfULpdTthJCby8lfL/b9m+JzTa1FGT/I8J9s2/YWZl+rB58h0Bjp+Tc45zdDECadTge9PoXyemXEiBEjlixZgtD/cS1Jq+VvGUzOQ6xCGpik0C5FOjTo8WUBAlBpMOc8LYQ4DSSauKOwGCCYh0EhU8uy5oZh+L+EkP+U1wxd/2y9B0Qhjh9KKeFU3RbprJg08NRjEkGeXSkF0ZFHHce51vd9JH2h8zrtod8LGbDbEkJOZIxNlFIOhjmrHcnNFcB1lClgjL0DwtWECROe6N0+lNe1KPn2ySefnB+GIdjCdkt8hCLzEuMMPjxIIM6mlBZMHWjNqfgNQshUSunhtm038w8MW6rYK2kAgck4C1mShJAWzZRi9+qqn0OubNq0aePBO7Asa/8wDFGUI9p6GU+wlNLv06fPv7PZ7O+FEE8RQiBo2iEMxVLbGRGGyy+/nM6ZM4e9+uqr23meh2pVJ3DOh/i+H9WzNNET/FsLrUAYB47G24855pjHd999d5CXekQ+S6nt2tJ5oJO/9957P6aU/iYMw60KnVdskdbXfAY15pkzZ95eW1tbUKGrRUCwLGt8GIZ3w7NsHBmmk4vpJ+rBjkGNPeMMTcVdsbEN05Wur6mpsV599dUdMVkSicSPPc8bmEgkqOGigwYM4RFkozHGbpdS3lNXV/fZjBkzOqXvoKW219mw0NrEgEU2J3L5UX0ouiQWqoY4DmoG/JsQckcymZzV2NjYo8bERoxfENi+qzOOdy1U2alEQIB+xd0TJ068aMaMGQWLBLUECEik+J7neQ/G1ZVNBxcDBJ1xhTTZz3RK771aCGQj2qTLXQok/wE0FZGcYlkWhzPWZDpiW2VZVjYIgsehL0kIQVGNLgUGsR6BX2QnxtgJUsrjLcsaZpwkINLEK31blpUJwxDbR6hmgdHY62gsPrQRkdoH0SdK6aEbAQiwCp6YMGHCTx577DE4+DewRFsCBCj7nKATbewCnPtWX0GzFGUymfwwm81CO/FxQkjJyq/F26dzn6HVc9GBFyaTyUOy2Sw0JCIpLJjPAAXQfcMwfA/qUUceeeTjs2bN+loBowseGKDTpk1zzj777NHIfaCU/kTTnKO3MSIrAAekTnPOc0IIACAEe2duppJ2XbBl13vkHTFWhBAnGp9e/NMSLQRs0eYopSD+W5Ba3hIgDES8nHP+ayFEFC+PoXxJDdu3b99w3bp18yzL+lUQBC/1FGKKqQLNOT+Pc36y7/tVaDBdCj7icvi+H+UsVFRUQKPytu7C5ps5cyY/7bTTtlu7du1xUOlBhSikeZttkhm0OoSNStgoQ39TRUXF45lMBnL8m015uqRB3LlOQi7DeZTSc7RGSTR3jbVeIiDAIpinlDqNEILqYSVZCPii4YwxpDzXgT+NLzZhx5YknOJtp3kIHuf8aeRhK6Xe6imAMHLkyL6LFi06VvMJtofpDBBA2rA+TCjuJULIxdXV1W91J21J7VOAHwE5MCcKIUDCipK40A6wEmKs14BSOl/XknwilUp90ZEZnp1r/m/wNH0rKyt/ls1mf6mUgsR/i4CgQ/6FXgcAAKv0nDAMCxZI2sBC0CvcKELIdYQQ6Ou1qtTSUiNyzpuUUg/q+guLewIgaDIXSCSXc84PRIGWmKBqRO1FxWvf99/inE8TQjyCkGN3axsNChhDJ3HOkRA1QgiBSvRRhCUWM4dTNcc5f0MIcQ9Cr+l0+sve6EPBWVUJnxRk/Qkho+NM13wAKGI1fKqUuowQgvYubiFoQABV+TZKKfbBJRVvzXsFMBRRv/C2ysrKPzQ1NXX7lGetsAwR1VOllP8LTX20CRyJcaeabdsrgiC4kxByKyHk0+6a7KUFPjBwj+ec/1gpBaszYtnFBzD2TpTSnG3bb/q+fxch5K9aHKY3JLn+pIJf72BKKbJgkRi33mIe3zIUAYTVlNLrpJTXlwQIGt33JYTcRyndri2AgBUPe2RCCGjPf1JKobBrp46tb4y5GKvBcBSIH4wxFGiJQm9wsGIPDUciBr7neX+H0OzMmTNfbSkWvDHP0pmu1YxGZEmeYFnWT6WUw+KkGgAlfiDcqp3OC2zbvnn8+PEPzpkzp6yqxZ3pvTfFs8A/U1tbCwUlzKmaYoDQik/Bo5TepolyG4DuBlsG6PTX19ejUMRdlNIt2wIIQB6IhjLGLhVCzFRKYa/YbQEBoVnLsvYRQiCtGSieMCgd04YA+xCUUSAzoi49Iq8DltNHH3209erVq4+HU6yyshIFZil8Kvnha9u2wyAIUAT4Zs/zZmlPeK+j8WsrHe6okVjdlVL/k58cV6JTEdMZ2cf1Usqf6ujOevi1ASDU1dVVzJgxA76DmymlkdlbjHeQj4iMMdRvfDcMQ+x3MPg7NRV3YxAdHeW67g4odIKVkHM+EJWtjPYk2i6ZTCLRZ4UQ4k96q4CKVT3JJKb9+/ffds2aNWdgC0EIgU5n5GiMt5N2XIOL8WafPn3uamxsnFVXV7esq5G1NmY8tXQtxllFRcXwbDYL0dUTIZ4UP7cMQID1/oTWSN2AA7IBIJx44ol977//fiRRQHa9TYCAwc45B00VgPB8Z6fibkwH6lp8KYhPUEp3As0bZrHJCO3Xrx9Zu3YtzN/nt95661/vv//+b/RET7ouBjOaMXYc5xyggNJ2ESjEtDcBEMjdR3u9rVN+kQ7e7X1QJY7BwdiSEkKQG9SvjYCA9n42CIKJhJAN1M83AITJkydvMXXqVOTtX0opjb60XAsBFgGl9B+WZV0cBAEUebvrgTTmsY7jQHjiYMdxXCMtFmszWEuLpZRXHH744Q8/88wzyFXocYfOf7DT6TREVo6nlMLZuEMYhuuBAlY6qGwFQQBQeMu27T8HQVCvK1r1uHYzL6y3DIMsyzotDENwEaLtvDnKsBDgt3lJCAFQQbp961uGiRMnDr799ttBtz2bUhqRasoFBM55KKV8UikFLgMYad3u0GIhoCcDaVFyu8p13WhvbKIK0ASglK7J5XIPuK7721wuB0Tuzr6Uov2MdrvmmmtGeJ73o2QyWReG4XAUwc0PScKu1Y7Gd2zbnh4EwQPa79Ij208DAupu/liXeMe2q3lBLxUQdNLh60KIn+uq0K0DAuS2QbmFKg6lFLHPsgEBnHzbth8KguAypdTH3dShCOvpCErplbZtj9QK01HjxsrXIYHkRUIIZOj+r6WU06KzqPudQIcOHbrNsmXLTtbm79aQeMc2K05805mhKBD8oa4WDpozGI09EhS23HLLqpUrV0J+71KtcVkWIMQW9jcty5ochiEiXkUBAaHGy7UYw3qOizLGpc85v0sIcXk6nf6iuxFNEIl5/PHH98xms+dblnVkGIbJmMp0BKBSSojBoIjrjVLKhwgha8tov25/qvYpYKydgu2D1oqIEsBM7dBYiNKnlL5hWdafgiD4G0La3XSRabXfdak9ZD1eoZQag0hDmdRlc/+FjuP8yvM8OBeLAgL2eMi+Oxoy4W0ZmZRSkPXhUU+n0+lupboL4ta11167XS6Xm4jYehiGEY00Ty8/Ko4RBAGyRW9Op9MfdTdQbMu4yL8mzlNgjB0vpRxhskJxLqwFXUcUiWDwKbxp2/ZdRxxxxCOPPfZYj3M03nTTTYnJkycfDEVuCPZi3LUFELRQCnYBqMlZEiDgCxHr3ED7r8SBgNgxpMCQx9CtSEmHH3545TPPPDNBJy/t4ft+VK3E5HrAzOWc+57nvaA5B68QQnpJNi0MHIDCXXfdtaPv+z+klJ7iOM72UHOGdRDXDkToNpvNZimlCyzLuieZTD6wbt26HpU6rQvnfJtS+vs4IJTqPzBdYNv2Et/3EQHEglUSIIA8Ay5CWwHBQ2GWMAynKKVg7nWLPZ927OzKOf8lAFMI0QdpzYaNqFc1hM2W6FyQmel0em2vddD6MqIdtLAOTgrDsI4Q0py8Y/Qj0MYYR/7X2v6LILyTSqXurq+v7zFbMU0H35dS+kcDCCUu0OudxhhbJoSAHwJU8fXmZqH0ZySl/A4OM4SI2/KFWBEty/ptGIZXdSOWItpqkBap/F9K6WBQx7QYjFEchmmLAfpgMpm8+oILLvi8FwyKjyAA7V577WUtXrx4yFdffXWibdsIiSH6wLEV0zoKzQ5HpETAPwPh1iAIHu5BCVEI0SJ5DjUady9Q16PVxo45FT/nnF8mhLijFECAmi7qCqLCUBQjLvdgjKEmPTjX10JevDtYCNXV1RXz5s07JJFIXC6l3NWAJcxa4/xKJBLIVXjFsqyrjznmmBd7IgGp3LESP18XxIXs3AnJZBIS7zsqpSxYCWhnkymJgW1Zlh+GIcrGofDIX9Pp9NIeAL7QJtlDA8Ke5QBCnDrAOQdrFoxHSLsXtRAACDBJDmorIFiW1RSG4dXabO7yFF3tEYduILYK2Os25yrAZ6CtBCmEWKzDY4gq9Din18aAgbkWbb1o0SL4FI51HOfHvu/vGHc0GlYjyEuWZXlCCIisPHDiiSc+eP/99y9tj2forPcAYF599dW7B0EAh30zIBRTNMvnEXHO1wghUAwIRYU3PSAwxpqklFfpzKzO2r4lPZf2GwxjjJ0ipUQZs62NYjI6QhffjAhISqmHHceZ6vs+5K57XA2Kkhq0hJN09GGEzns4yXGcHaSUUUgShyF+6QKz8Cm8hwK5xx9//F0PPvhgt60QFZMmQP2OccZCKBcQGGNrpZQoOAznZGmAQCmNLIRyWYq6vxsZY1dLKX/b1RObQAZZvXr1QUII5Crswzm34iIfOn0XepEvV1RU3JDJZKCE1CMyGUuY220+JcZohPrU6clkclsEGbTjNto+mLJxlNLAsizUxLx9yJAhdy5durS7Rh+whUcl7tsppeNaKtrSUqObucw5X60thD9sFkCglDZC/50QAkDoyiulY9v2bkEQgDsOXkZlzGQ1CUzIVfjItu2bLrroonvT6fSaNs+C3gvXawFtKaB+JJLHTk8kEtsFQRA5ug0b1Phw4GiUUqL2x3Q4ddPp9Gfd0KfA9XjcABBK4SPEpPFXSSlBPoRroKiFgAItt1BKD4wzocoZq4yxrJYWx7ahS4Yc9VYBfHGo3E5SSo2oqqpiSF4yMXLNt4c1NFNK+buZM2e+X1tb221TvcsZA+1xru4DrIpgNKLmw0mEkFGmehHAGYfZSliWhRyad6WU96dSqYfGjh37aTqd7soL0nrNiFofc+bMQXQBPoQ9sGWI626Yk+NbiEJKSoQQiBeldSr+pgcEzjmcPbAO0kopCDJ0OVAYPnx4cunSpYcTQs5PJBIQP3HiRW7BokPZ81wuh7qFV+yxxx7Pz5s3r8tKqbfHBN6E94B8GHJsjrVt+6dBEECarVm4FVYC+gbjDCxZKeV7lmU9EIYhnLuwGrrc+CvUlpqvsRcUj7B1MICQv603JDncowVptS8opWkpJcKXRQEBjT2NUopS8G3yIWjdfXAZkNTTJYlJiURiVBAE8BukhBBVjuNEdRWyWeQrRQ0NgdDPEALaZZddZrz99tvdLaoQ56h0+ITCZJg6dSok3lOc859ZlgVRmqhEQFxPAQM8kUgEnueBvHR3VVXVnxsaGpAQ1eUPDQjfpJSingVk+pqrbrf2cvlOR8uyloZhCAuhJB4CNPBuoJR+D23dFqcipTSrlILDAsSkTFeyEODJ/cMf/gBHItSCr+CcIwc9qi1g1H10vn4TY+wpzvnV48ePXzBnzpzOYJqy6upqvmrVKr5kyRJMltZqdxYaQzgf+St98btPnz5rGhsbod8A6nWHboX09iHhuu6QXC73A875GZTS7cMwjEABfaP5CVEBXcix2ba9uKmpafoxxxxz9yOPPNLlQUEDAmqFQs0MyU3rSbG3BAoFrISPddGXDZSXCw0YhHuuppT+EIOijYDgKaVg1lwBJ1tXcu5Mnjw5OXXq1P1h3TDG9oH+ny67FomlAgxQUCQMw/mEkN+MGDHi2VNOOcXvyHfU4SiY1VDUGat/oHKMv31NpyQkqswcPxAhASUY5nbss/62bW8dBAGuhbn9HCHk2enTp388adKkDi81h0lx/fXXD8pkMt9HCq9lWeAsWHjF+Ptps1k4jgPePsrGwdEI8lJnAO42WSs6l+FQzSTeyYQdi83RAoCwyHGci33fh/DMekchQECRDaglwYFTUezLCr0Zag9onX3oIWC/0uEmZ7EewKS66667nNGjR4987rnnIB4BpeAqXbk4GmyaVw+fCOpMRAVaCSHQR+zQ99P1ILa3LOuHYRgexRjbzrKspO/7kZUQ1xiIaxjG20RLl0H6jgshXM45JNOzyWRyUTabfWjixIn3Dh8+fFlHAh+eF5bCpEmTrHvvvXerbDYbqTmHYQhHY+RhxHjVqkvRv4MgAAAsYozdJ6X8Szqd/njKlClQ9OrQPis2Hgt9rtOfkWME0t8OhQAh7j/IdzKa9mGMLZRSQhAY1caLAgI861AAOg2KSW0BBAikJJPJh3fdddeLX3vtNbD3usKBATXUsqxapdQkNHi+sq2e+E1CiEdt254aBMGCjq5Zqc1I5J+cDF0BSunWUkrU49ygso8ZLGbS4P+FSC2IopgYP94PhVRAYhFCzO4sug7aKtrecZzjfN8/RfcXx/volOkIEHQkKAIFkJf0z4qu6NsaP3581csvv1xLKUWhlW3bsmXARLRte77v+78ghIAz0zogHH744Vs988wzkFA7ayM0FUPLsp485ZRTLrz99tvf6QpoAGsokUgc6HneuYwxbBkic9s8uwZGUxvvNxMmTJjd0QVaIXGeyWSGvvPOO1Aegg7mNnGab7zdC4WiSgF713XhPF3j+/7fqqqqrmloaAALE+3S4SusNqF3ZIwdLaVE6jSUq5jxJ8TeD8+K7c4HSqm7NSisSqfToqMtnnLmRv/+/fuvWbMGSmag0G9Qzq3QvQqlRkO9ixByJiHk30UB4cwzzxx48803oxjkRZRSOJfKllCzLEtAnmnSpEkXT58+fW45L90R58Lk/uSTT3ZQSp0RBAF4B/0NGMRMMFN8Bvzv6UopVMDp6EmBorzHJpPJM3K53FhKqYXVvdDKn28d5PerGTgmezPuuXccB6Sfj8IwROTorpqaGtEZnKja0VhBCAF5aQJ0QLFyokJUfnxe9xUS7T6WUqJyFoABFZA73C9SxpiHsCq2s1iwI0V0HPmTPg70LWglvOA4Tp2OxLRuIdTV1fWbMWMGdN/hWMTEKBsQ4JF2HGfuwQcffMnTTz8NGfZOfQwYMKDf6tWrf0IIgRk1AuW2CzR0Rin1lFLq4nQ6vagTrCxJ13XH53K5cy3LOjgMw0QxTns5nWCStnSuBgZd4LruP7PZ7M9ramre7wyAoEEbfAT8bGnbdm0Yhqj9AMc4QuYb+Miga8kY+0QIAS0AEJgWd6GsVDiNf6WFfaPFuiVAaAEI9HSO6jKgUMsGeR8tFWoBTRdchDbVZbBtW6ACj+M4v/Y876+dYCUtOBcwYEaNGuUsWbJkL2g3EEL2s23bwSSIr7Igw6GCtVIKzpwnU6mUP3PmzA4jXOG5E4nEzr7vn+E4zvG+7w8ATwLPbfwDeu8MC6a5end88Oj9tVldoi2AuQYrrKn6DUcqrA4pJT5eqZT64z777HPvoEGD1jzxxAaSfOVgTvzcuKXVWqg0Oq9fv3507dpmXRRzLa+oqBiRyWR+yDlPgVmqlIrIS/krplJKgG5OCHkArEZCyJIukqY/TIcL4fBPtgQIRToBHfnwiBEjTl6yZMkGSl6FAMGeMWPGQZRSOGAgM162hQCLzbbtT8MwvOKAAw64u5OsJhu0k+bKb8cYO11KWZdMJvsY4lFs8iB9+wulFMxM6EQYVMVA7JDU7jFjxvRZsmTJiZlMBnvJ7XVEIAohYvLqyZ5TSiEa8iEcaHrP3+Jk0ysKwneov4iCM5VQg0KoFYe2GPC+C4MgeMqyrC/DMKTJZDL6TpyHfxuLorVBGa/v2Mp5LW7HtNMT0RPleR4KC0uUms9msxWMMUyafZRSuyil3PjWIbZqwi8CPxe2QZB3x/YBJLNOG5LU26MdEeomhEB5uVm8qBVroFDzeo7j3Pf9739/UiHLqNAAwd/2ppSiofAAbQIESulKIQS0GVHluFNSeocPH77F559/fqwQ4jzXdUfncrnmEmyxlgTJCrqI4FXMixN0jLBqdXU1WbBgQVSTAUf1+GqVXZ0lCz9aSHcYuoPaeoetycJ5C8nq1atJdE0RiUWXuMTcC/fDNTjwt+23354uX778G01NTfDxjEf2JXgEmIwxMIsUhVBolxDyDx0JMSSEZqsh9o5mHICU9C1K6RlKqZ3jBWuNReE4DjgYa0AR1qBJfR+aupFoiTFhi/pWCpnzrYFIzMrEZDbK1hFj1LIsGQSBdF2X+77vMMaSSilEyJpDkXHrSEveYdFCjfr3fd+/WUoJoZV1bTVxNvV1KPZ64oknjguCAALIEC+KtrXx9yrlGZB4KKXEnLygkGO4JUCAgwoX7deWBCedr77WsqxbtSOqM+aoYw/+rVwudwml9ACllGMmuJEB12Y0uMqoC/AeGJiG6AMT3fNQSJealZliYsLEzvk+6VvVh6xraCSMU+VYNon4DLYGddn6fKGERhWRtVJQtBXAvznnEpWOUJXb9/1xtm27JtvPOA0dx4Hu4ErG2F0ocOJ5HkRD8IUABPPFEVHJ/IwcOZIuWrTIjIVttMX0U855/1iacfSemPnx+gloK7O90vkEGzi58gdqsehGsRXP6FEAgNCueCbjBOWcU2OB5INO3MdinlsIAf3Pf4RheF46nV7QCXxDBef1zJkzndra2oM551cKIVAFuqyaDDHgQGr49SWXg9dfBMvgGsbYMRCmME+YxxlvFZCSyWST53nIAsTeHPu1TnNo8wtx3LMdx/mJ7/tbYGYjXGUGdexhYSbDlIxWWFyLQVeAFvzfECXduJBcK7GLaEILIWDaY6sfsQ8N8UiDAajGz1mW9bswDF8vkydBR44cCZ/KvmEYXsk5308IwdDvmIT4LiNOEq+dYP6GZzPMx/jqFfdXxCe7mbj5ZClDLEJfmMlvfCO4L64zoUX8O847MG0RrwSFa83/Y0BguBbSsv5/e28CZldRrQ3v2uMZOp2BzAQIGRiaQbDDEEA9kTECjt8J/B8OqBgc4YIDGIccVBQUQcALEq+CeBVvWlBBggK/NBFEgQAGEgiEEKDJSEhI9+lz9lBV3/NuavWt7JyphySd0Od5+umkzx5XVa1aw7veZa+IoujiXC53/2B1b5EWR2zEMAxwIQIjU5FBTZdTFUWMDQIEq9vBlmOlUWWVTrQs6+uWZX2OGnJqwapGFzZ8lfuklN8MwxDAlsH08WzbzoFoMgzDY6H0aFLT5Kz0sLSz1d3BeltBkLhZvWQmPQctBCxYFQiF4vq3aZrXcs7v7AeIaKxpmp8QQoC7f6SOdkxuCrTASH5JeLT+asnUpm7u0vwipUzn4f84j66rT/ikHPQ5qlkM8aWI1AbPqaFO4WrxUqmE6siLTjjhhL8NYoWATmEgn0XcCOnmipZYHYWADQXsUkjPIvu3XQys2tQdaZrmXCEEouox+ouET7TY9VZ3NpuNfN9/IooipEngx9b1K+tdcwC/H5HJZM5SQbkYAqq/X6XAWD0zd5tn66dCqCepJDxVgyYjMIa4wc35fP61vqbTJk+enFq9evWhnudd7vv+LM/zHAou4j11KLRuCdBiJkVVSRnQ32hnp2vpgUbMMSo115UBvbd+/yQykXAUsFR0Alw6jiwqjCcyJ5ZlFVOp1MPFYvGSXC43WIrUKk11AJGwSX8Wpfi63PWDG1AIqMH5mGEYz/VGIcA8OYtzjkCam/S9Go0Su667inN+qdqt4iDUIPkAX3G253lfDcMQjUHi3goQZgWXoddB1V7XGG5n29WWEvns+jiYpgkegD+joCyfzz/b1tbWZ3krWDB2JCAgY2yG4zixmtOVJRY+WVS6O5FUWLSb6Ts6Aah0RatbZ0kFTJYInVdpDtI81a0M/Bs/b7VziF2aUDWXjWs1HMd5GnU3Qojf53K5zYPYQkDmZ34Yhmf1NaCIdKuCK6N13rpKs6zaXgbY7smO49zKOR8J4SPgBqHSgNSastDwmDi2ba8NggBNX1Bt1jlIlAEeAznc93ie9w3f948F3BdKgXzT5GRLTs56LsOOfs+kqay4GYDV/8qkSZPu6+joeIu0of8flMJ/wzTNs4QQKcQsKB6gelnGwUpFqhtnL7R4Ql2LUC3y+Jpkpemyp12eMhikjPR7vGXcvXUr9ffYt1ZxIvyGWQwwEvLvqGH4F3AH0A2e523yfR9Q7KcUixBQi3Wfu/9i7d0V1LsgwP9dxliuCuCq7kWllJgXfzQMA+AtADm2e9eKCgE7xJVXXnlUqVQCuyvKaWNykFrauZLZIqXc6jjOb8Iw9HHLwQAAIABJREFUBMMrqgIHyweB0kmgR7Nt+5woihCkgRm2DYgHD9srV2HnvN021YsqiIe8399TqdR5hxxyyGtLliwZKDhu2nXd9wdB8E3XdQ8JgqBnviizHRNqped51/q+T1ySlNaEOb5NSTJNQPwdHxUXoEmJ39tM0EquCWVeOOcU3O25h3Z8z7XS6bRQ6VhkE16PomiNYRhYGN7YsWP9lpaW4oYNG4Lly5cPSmWgphSKUD/sed4Puru7t3Fxaco1sklJKcEJAasfWAbIoDGFgJtMmTLlgFWrVv3Ydd3TYWLRwlAtumtOfTLZmpqaYMbe193dDbMTmYbBpH2BgYcpfJIQArwHwMPbesQ8oQwq5e93jgp4C5qL4B4guWkQtiQoyRFM/GdTU9PnZs+eDXdhoMhMAI893TTNbwghYkIOWnRqHmDn/SfnHIVViF/EOvRjH4OLuv0H/RmrCWzJkiUGfup9gPnADz5gYU5ec/Xq1ezee+/tuc+5554risUi6+joMA477LBowYIFUaFQYGvWrLEmTpy4WxQ3oYhtyZIl52Ehp9Pp4cDLVNqo6igFWFIYo8vnzp37iwULFlTcNKqGv8aPHz9m3bp137Zt+wtApOlBmXraiBYVzDXbtpdEUYRijEcHk0KA2bVgwQL7pz/9adPTTz+NqC1g2gAK0O6SnLx9VWb9DTECgALrBQsSRWeg4caO0RN9V3JeGUXRpa2trX8eIAsB90XTni+AG8M0zeEVMgiAMd5rGAbKxeGT9lVG9fTA2/r7cePGZdevX/910zQvEULEZDDVFEK17xSmBmC1r0gpFzHGKm4atSYr4HFYyDD3EVMwMpmM0d3dXRV4oj8koKSAlXqe95Lv+2gb9bvBCg2Fcmhvb9+ubd3GjRt3yQSfM2cOjQt+ExXavpZl/QfnHDj2YXr6T5GbbE2lUj875JBDfrBkyZJ+N0CdOXNm+tFHHwWKE4jIg6SUcVmxphQgm/Wmaf58/PjxV6xZs2ZQolH3BE0yYcKE/davX/8jIQRYzOp2cNM25Pj1VWYQUO1/RVEEax1lzxXndi2FYDuOcw7nHFWPE+Gz0cVr4dUraK7Nruv+/Kabbpr/yU9+cqgtet9mKGTfZFkWFug3ACnX3QY14ND49zY1NX2lq6tred9u89ZZKsuAuMqPTNOcLaWMW9fp6cBUKuX7vv8vzjnaij/cn/sNnVtTAnCLgKj9lWVZ08har3UGxoqyK3AtkV51XbcrCAIEFEGuCtKiXisE7JgnW5Z1mW3bcNosykXXcxliR1LKODMhhAgZY/f6vg9WG8Amd0lB0B4w6eA2HG0YBqyt99i27WC3hpw11CBAJ/NbW1vv6KvboJQB3Ke8aZpXmKbZjHvoiEg1hq+YpnmTEAKB58EITd8Dhtww8vm829bWdoZqaov4UTJQu9176mlXygalUqmN5XIZjVkQVERfhoqfWhYCTNWWVCr1bbDcEkBJD7rVk7iyFqCJnmlubv7MxRdf/NhgxYrXe5dd/b1aqKgzAGDss6ZpAm7dMznwbzTxBHlLFEXXSCk39LHsHIpnhm3b34qi6BTgowkJqXAC6H0AGrn70un0VWecccbj/cE87Gq5Dvb7H3DAAaOff/75z1mW9W3ED2oBj+hdCI2J33FtTbmMNfhKNpv9drFY/H2tYsN6Aa8xCEKApcVxHETlCSJb28ZRvHYqEi6HDRu2VgjxzWKxiBLigfjguR0UAipyDAQDYXnAjwUCBf/eJf7/QLxcjWtkVaUbKt5a4DZAEWiY/1AI8TfEfXK53L96C7JRSgfZlk+jdRpoupJgIXCwMsaej6IIpeBg7UUqa0+Uda+GErKjEwqFgp5K7dV1EgdjniOwe6Vpmqej3EbvK1rtwqQQ6PtUKgXU8JNSSkDR22tZ6fUUwjDHcc5Fo1MhBMhXt8vTV3oo0mIEI7Usq5tz/p8oqgANdl+sBLSx6uzsdIUQ2RUrVuzn+/4RjuNM5pyjBt6DnxSGIQo3ADx5tlAovL47U25XGWy4caDfvkxKCfZdl0qOFRQX4JvVpmkiAPU7KeWbvbAS2KRJk1IdHR3vZYzNk1IeBbdEkaPocGUAzNDl+sfz5s17bg+UcaMLmNYONiU0N8IPslXYjLqAeTBN89V99933tRdeeKGzF+PQc/98Pm/dddddYMUCsA8FhwxuuA4jr7b+EgVjJcbY3Y7jXBYEwTO1XrCeQsDLooMTeskfCaSa6nZcs8RVD2oA3YimGalU6v7Ozs7Pgwa7twrhgQcesGfNmoVWXse6rnsayC8cx9m7u7t7OLSmxhZUZIy9ZlnWM2EY3jlmzJgHcrncxgHMyzc6WXbYcfl8fvjtt99+nhDi28g2EDpQg5dvhTLwPO8q3/eB/WgIk6CsA0y6i1Ub9mZCD2JyKWCaEEI8gnw45/zB3a0Jz0AMCjWMUSSniOnMtizrUMMwxgghAPlHeTi6UXdFUbTBtu3Hoyj6y/Dhwx/bsmULeCQatqa+9rWvDfvhD38I8Nz3oiiKC5rwqRfD0zFDCsa5RW3IaJ5UM95TTyHADDqIMXa553lnlMvlHpaWWg+mBzUI4SiEeNF13UuDIPhDo5MU94Bl8I9//OMgIcTZlmV9IAgCkKGmSTlBOAomTQUxELjved4q3/fbRowYccsf/vCHjlmzZg1aNpxeTlS4Su8yTfMnpmkeiqhz4nwEcZdIKRF8hHlYt6ZBTfImwzD+j2maXxFCHEQsTLi2BlN+wzTNn+61114/27hxI1rXNTy5e/mOg/nwZtu2QbmHFOB7Pc/b2/d9uHLx7k3ENlgDwIcIIbZmMpll5XK5DfUS+XweG1TdMYEATjvttMn33XffZZxzUK+nEA+AdVBPIZDLQKl/oIRN0/zOkUce+ct6weZ6CgHPBZ/ya47jfCoMw3hHSo5WvQdUygN1+j9FV+hCodDZiJUAirN77713akdHBwJpZ9m2PQ7l2EkfSS++ImCG67pREARwIRYcfPDBv12+fPkrvdHOg3FGat2Q91dt5lAfH/uV9AF9nRAC8FxElG9TLEDk3+oLWP937IoojDv4NGOFi2tq3AO+EOKftm3PO/nkk5fcc889b3Gr9fLTCFNSI/Op1m311HdfrkUuL13nsssuY4UCsnVxDQxcqrmmaR5rmuZI8DYqd62HKEYfD1gMyLTBlUun07+YMmXKHfPnz3+pXpdwRe93jGVZP+KcH23btolYUaVK0qQsKEUM6xyksoZhPCalRNOk++utgboKIZ/PN7W1tZ3tOA54DQCO2a4lWCNCB2uvlPJuKSXy6OjVUHN3Uf7TPuVy+WO2bX8uiiIwzprQetRNCQJSu1csE51GTKVnOMhRDcO4rqWlpW358uVdvZy/fT1cl2tvdlE6j2DSZj6fN8jlUQoBixuQ4rmojQcRLioRsXApiMsYA95jKWMM5j0UMYBlFGjVkZjxFqa+h5KZiS7LUAbY4WB5KTASjlnjuu7Pmpubr3v99ddrFqpRgA3w4M2bN2ceeeSRpo6ODgJY1Z1zfRW6dh7ukbyPPg69ega180OGBwO5yzmfCZo2QggRpZtehUrKhBClURRBaz8PPsMDDzzwdwcddNDLtVzZc845p/m22277/xAIlFLup7tv9aqNyULX6lz+R2ULUdRV81NXMMq3xES52nXdGao92DYXbUQhYEIyxp5ljH2Tc35XLbdBTXzkwmd7nve1KIoOgQlLrMKVGHoqQTlxnGmapSiKAJwBT8ALugKpJ5wK39eVV5Vr9kYp4BLYfYHZ2KyhO/VYgJXNZnPFYhEo0mOQGqTdXO0gcVt0xhiyLrg3cQv2FP2o56RKQZyPlBZlbXqYkZS8cB1AlC/P5XJPNZC9wPUwfjNt2z4hiiKkS21SMoSb0GWlWw6Vvq8xVtvJVjFGVx2regVrmM9EWEt0cUII0NyjKxboBVO0+EnueiCdLFi6D8H+QXYrhHjGsqwb0P1LZWgqvtr++++/30svvQR6P5QqZ0k+VElcz0LS1gh4Iq9GpkI17e2fQsDZn//85/e54YYbCoyxs0zTzCYx7Q0qBExSTPLrhBDIOCBdhUHbbkBVEPEw0zQvNU3zzCiKYMLGJhmZZ0prx+cqGC9ramoyisVifBwRcCD74HleOYoiMCcXGynfJolVmDgNZVkqSHybd6wyIfVjomw2+2axWERZLphtUPUDMAl2aiw2/IbF9G3G2KdN04yzAbqpC9MwOS74Xs9j664WnpkmHclZTSrc60XF5Yf4T00rS20gsGA+iLbtnHO0LceErtRRqQ86uf4p9RZ8PYVTbQemXZosA11++uLX558uc1DcCSG6TNP8m+/731+4cOGSCq4De/zxx+0ZM2aA+fw7yPY4jgPuBmLTrhtDUGMZ/7IsC2P3zXnz5rU14qY3tON95StfyV511VVnI7hoWdY4qrSjoWlQIeBFQA3+V9u2kf54qpo/M3fu3Mwtt9zyfmAXOOcHYwdMdvZ1HCcIwxD17ZtBGc45H4+afTIVsRth4KnHAmU++qkQ6s/GBo6oN2GVkkTjVQCAXjJN87eu6y6cMmXKGlT3LVmyBMoDJiyCTZdIKZHy6sG465MzsQtXteySfrfiIoiVeBRFqENBxypkLWoiTVVlHgqwfpBKpU7wfT8FvATGQVlsdSXUgHwqXqPaecm/17t+kvsjudgrXA/jAbkAo4FKRMRkQLoTu14UaPxfQ04A5Xm1EAKtDrCDbyPTK664Yvill14KMNKXOed7EQ8FKZp6601zXZCGfhB7eqFQeH7AFIIC/xyTSqVuQsuwpH9W7wG10aPOyd+9//77/yeXy4G2uJI5DUDU5y3L+iLnfDRZB8R8o9iBnsEiCYIADVfHmKZ5ciqVOqm7uxvtrmJFp5fqUkCGTLy6s3KQHOB5XuD7PmIuPz/yyCMXTps27Y22tra46Ml13YOCIECPvo/ARKeJU8+cbOTVVH0EXBdUqV6l2sLXLWCaPXu2d++9954shLiOMTYZ5jsWmMLUN0Sw08jz1bDi6p5eb77qCoD8cS1blmyQi/kLaxfz8BWlFCaAxt40zQkOuN4534YSznGcbtM07y6XyyA7RQWivgYQJ5vm+z5ibec4jmPptUONQJfV8+Oa5ZEjR/7qhBNOQJsBv5H0e0MWglpgYM+5wnGcD4Zh2IPKgvSTAiaTs5LpzBjrRLecU0899bsvvvjiGytXrkxGqzGBJoOUQwjxf4FGTBJ72raNuu5royiChu0855xzrPb29imvvfYaulYDgw+gUs/tiQmYBrqeyaiZXHUn1444gNJL6toY2KJt2/+QUv6Ec45UIpF5IOp9tGmaoDqDRRX3pNQj0ZUi7pV2SBpD/Fa+fhwEAz8jWp4VCoV1jewwCnt/ImPsZ5Zl7UuUdHRPYkGqJbdGF2xvlEI9qyD5POSD01zWKz1JvuqaCLACDoyMDlirfMdxJoRheDrwHIyx6ahVJ5cO7x8EAU+n0/8Ow/CCKIrQ80NXCIj3zM5kMt/t7u4+HNYVPTu5y/XkoywJuAtYJ7Cyb83n8+ZAKgRDtaIGnBWw2b4qBMg9Mk1ziWmaF4ZhiDJM4AN6BKICijCBAYb6MBqRkLugcrvww5aOGzfu/HXr1j2q1YI6lmX9XyHEFVJKWBhEpdUz1oTqS7o8O2JRD8Q1NbQZLKvXGWO/E0JcYxgG0qkUZEQOHPICcvHjtm3vzTkHVqEiiUal5yITU000yTkP0f9QCLHAMIw/5HK51Q0EEuNLI4Zw+eWXvyOKoh9JKeMu2sSQpE/s/shHXxD6Qu+Lq1TPmqLNSFcMFBdQ9GwgKwWLMTI61CHLdBynhXP+NSHER2zb9vRCNLA4FYtF+PYXcc7v0V2GyZMnj+jo6Pgy+kTYto2+Gz3jqOZ/QyxeiiPjsSiKPpHP51c2ogzizb0XA4Njc6Zp/kIIAeaeiniEStYBBbLUxEPrrQ1Syquvvvrqay+44AISYvwoSiEcZBjGZWhZVSE6DYUA+CXw9v/O5/N81apV5pIlS7AI5liW9QMhBAJuxNUXC1CZfLHiAbIRfh2ZXxRq1zMQurtB5yPdmTTZ6Jx6qSBdzsRcrWdLKGWq5Bfv8oQKVYoMHbVXWpZ1BeccNQRkWVGgEe+MXQnIUlhzCOxtx/FQY7whG7gE613XfTIIggez2exjX/3qVzc2Yhlo18W8gKVyEmPsM1LKd9q2nYmiCIskzhTp1khycdNi02NA+u6sj1E1xdCLOV31UC1diM0vTpnqlqpyYyMhxGIpJdiM4C5QuhjXBWbnM5ZlgZAEKMaegDTcZNd1XyqXy7BoQZcfm7OY+5MnTz7i5ZdfvoExBhTkNhtvb96LMfamilF8vV4gWL9urxSC53kH+L4PCwHlmFiA23xop6kUxNF3IcuyEBB80HXdz/m+j65IPcog1lKMTXMcB7RdZ3PO4x1G19RRFG30PO9K3/fRwRdkIJj4ezuOAxblT9i2nYYVQOeohQcy0G6ARJCYSKVSElVgeC4QvxSLxR4rpVLvAZqouimpITJZJpORII9Rz19z7HAt+NXkG6rYSDyZsJvATcICoouoyQe9hQj/XbZtXxEEAcx51IVIVUyD48GUjH6cgLkiwJpMM9Ilq+XoYXXABAYKEX5xn8BHarMAoO1I13WPALqUMTZcShnPGdVdO8YKkPtGCwbPjLGhtnTULxKAK8gJf1eKQMca9BCt9mLRVEsFx/EZmpJKllCwSKPGctPmB6xbWAbAhNA8JsstVggKKzKGMjh4X4CVwjB8adiwYV/u7OzsUQjvf//7h915550gwPkRUo31XIMa74pgIpDB3zzuuOPuaNS6i8emFwI0RowYMWLLli1wG9AsYmTSGqj2AmQh0GJxHAdm6WtNTU3f3LJly63guFO7EBY2BIrd7j8UNRd6RMSPSbuw6i4Nfnn0n0QwB34XNCraj01CtyEcDxCTyiMDX77JcZyHDMN41fd9cCdGiNiTIqCdB5HhMAzR9w9CBW4HfSmABkS7sLiNGT5E2453hp+HiZrNZmNoKVKdtWSL99CDVGqSxBM8DMPpjLETkKojJUoBUby37/sgt7h+9OjRNycAQpBhPJ6KLxC8gRUn/cSJE3vGXT9m4sSJctmyZfKQQw6BkukXb0WhULDb29tT7e3tsFSa0XYOCw2y1eYc/o3xJtBSjw7E3zAG6vjke5AyoN/0fW/xHhWnf3Nzs7V169aYrdl13WlBEJxnWdZ7qfyYTsJ8QBZISold+N6WlpZuRdaKgC9IaVFd+EHGWNypmTZKxXCFYOJFhmH8ldy/KVOmTF+1ahU2XNAN9DXFjfuUPc9r930fPVEAzGv40yuF0NLS4q5YseIkzvlljLEZdJdk4EpXAMknoYCH53l+GIb/LYT4Wi6X63zggQeQsqEBRan1BzzP+5bv+wel02k0FI0VAgUIhRAI3mwQQgBfgJr9iUEQYHfsaSyDe2EnLpVKcEtQBYnijmc9z8PCinsdKry3vnOi1Tq6ClNsA8oGP3R8T0dkUjqq+qzWZNS/w/VjxYHf6oNrxua9mkhAIKKD8TYmo1JaJcuy2mGKBkFQF/HZ8EzYQQcqXALtupAj3gmy1ZGTZJaTEqL/x/sALZhcLgdMTCzL5cuX15y7LS0tdZVDtWtMmDCBrV27Nj7/Bz/4ASprv2gYxrnglYQlo7s8WHxSSozHLdOnT3/ywAMPLLW3t48rl8tnB0FwtpRygg4cwzWRRXdd94lyuQw6dMTRxEUXXZS+5ppr3mdZ1g9Vq7aeEemlpYDnfkNKCeIaxJtg7TX86ZVCUKY5eiJewhgDA1I8o3ujEHA8KQUU4Xied0m5XP67Mm/j7Re7S6FQOAwRUtd13xeGYdzWW/e5oZ2xEyvoLa4JRdDTW4ECkdlsFlp8Eyio0un0taVSaS12v/nz5xuXXYYwhWHg32qUk+aigDmOzs4q1acLlkz1+Hx89OvVGgEcR+fQcbNmzTIVr+MIuFJCCMC14+Co7jerXQkxmB+PHDlywebNm/vNn9jwbOn7gZArFcZBsWLewK1BBStci7g4SLkrryJoms/nt7S1tcG9I/Ba3QXe98ereebIbDb7wWKxiN32ALg7evEeXBlkgYQQyDC8YJomIPpjkXZUFZFx7U0ioAo4+R2ZTOaS7u5utCdgEydO3GfNmjWoYEVmLbYoenYL1qtlGkkpgYZEURQClr1y+3p1J/WAqIo7kzE2nzF2APlGeoS3WrSXXpDSak1NTZ1dXV2o9f7xwoUL1yZQW8ir523b/ip8UFgJMMsp8q6USrzL4n7UmUePBsMs930fuP72VCr1o1tvvfWhOXPmVKo0w+6MXQk+LqwTBMXGq2AYgCPQsmAjwrWoapLAKP0yrRNTkRTSMYyxr6LUG8Aech20bkcinU7/vVQqfb1QKICFaneo5ISM05lM5sByuXyqlBJIPHBsoIQdygLvAHpvgLHg/8LkfUDl6RGcGUg5N6w71OZ0ZDabLRSLxZMUA/Y2WASMj1IMUHao9YktO2wytLtTDEpB+F+xbfuqMAzRcLU4evTo7Ouvv46A8LcdxzkwmdanTbSBh8ac7DRNs62pqenyN998E+5lrz59UQgY2KmMsR8yxvASMa1Trdx28om0Y3k2m11aLBa/XygU7iwUCvpihVBB9ImADTIKWKSx9UU+OKVy6PqJYCDiADwMw6WO49wYhuEdQDWSW6KyGRLl1blcrqlQKIAL4B34SafTU0ulEoKUdhiGaGiBXQsNa5+aPn36M0ccccTatrY2aF7IYqCaouhiwu4JmPhFQoiYGEPHsCv5bTBN8z9PP/30G+66665BzVqkCtUmlcvl05AeNU3zCMMwACCL06OJnRBWny+lhBJ+3LKs2znnqKNAXccuUQrKmkELta9YlhVn2JLwfd161QPoWooSrxlbEypugI5myJYF55133vj/+q//ujSVSn28XC5jw624LhtwHXD9V6SUV33sYx+7+de//jXu1atPXxQCzgF6EAg5+ECjsbjqKYSk1aCsBLzAm5Zl/fepp5561aJFi17Wnx4xi+XLl7e4rntBEASzGWPjtBZdPbUNSkPrHX6R2ozCMIQZdyMYflTfgJ4JBd92v/32c6+44ooDVqxYcTJj7BQp5YG2bY+IoshNpVIuGmIo/Dk6I3UxxjagUMqyrD9zzhFd3gL3o78BuOSIofT15ptvPjQMw4tt2/5QFEVZchu0dCR4D/4ppfxea2vrA/Xq3Hs1KwboYIzV+eefb99///0TVq1ahd4O56DZjIKYb5dS03dTeH+AbkdR9G/Lsm7inN+trLSd7jpgHq5cuZJQoehCE5v0uuVG/9fdiaQYGWNQdKhLAf3cX5TFCTkAr3GZaZpx3KjSWmrQfYCVdb+U8rJcLvd4b7ILPdfv49gjYvxex3F+GIZhi14SnUzZVTN38NJqkmOHXQpzyTCM+/QdVwWkYMKj7BQpyA9IKfeFiUnxgsTzI42I7EAXWJNUvj7m/SsUCqG+cBctWuRdfPHFrc8///zHpZQwYcebpuliQMgdURkEagILJYNrw3V4kjH2RyEEJilAQjvCZEcK8QzlC8JS6umbqPLyWBibTNO85dBDD7126dKleI5B9VHKe7zjOHPCMDwfqD2t8rLqs5LyU9H4bsbYE1LK66ZMmXLfqlWrdnrMRM1DxDnewRj7hpQSG0gcvCa+CL3ZLb2YTpiCea3eA8E+zBswF2FznWzb9twoihCT2yuZudOFVMlC0NPgIGOxbfuaKIquKxQKW/viSvbFQiDeftTPf9OyLCzUlDaI29FEV3oR0qTwvTKZzJaurq5bm5qavt/V1bVBFwJ1WLrgggv2i6LoBM75KaAhR74dTVoxaXzfp8KSkpQSBTiLLcv6O+ccmQUEEfHMsXWAwb3jjjvSnZ2dh7z00kvoOHSmaZow0WPNrA8yVUzSYOM7pB+h2RljKxljtwghfqtYcBqiKmt0xcLMbmtrAwLxYnROQsktJhiwDgTUYYzB534apDMTJ068e82aNYhxNLqDNnpco4+8zdzFf0aNGjXsjTfewHh9OZPJvLNcLkPh9hyn/5vQjATxxUEKwAX8AfAj/7+UElFzpI53hAKu+Z5KKWAjRNPVL5immXNdt9n3/Z4dXXcbdDCV67oham4sy7qac35/onL1Q2ozRBDSqrShVrMOaL7ivkjlR1G0IooiUODBSsDc6PUY90khqAdMe553ou/71zLG9sfC1YVQS7PpO7CqHUe+9zk0Idlnn33+snr16u0auuD6+++/v7d169YxW7duRQxjShiGiFDDfENb7y1hGMLvRCAFjEEA2MD/32ah4jqu674jDMMLbdtGie5wNDGlZ8Jzk3IbNmyY0dnZuU12A0FMTNowDDEpEVW+ccqUKb9auXIlgo8D+hkzZkzTxo0bMQHRnPNIKC0NXRkrL9u2i2EYog08fFLqrxgbZknrqd7DAUeB8vEB+sAUhkL7Epq9gFAEdG9UqIZ76Itfx5pU4KxAehidmv9HVV3CtdwRsZu6rw734ZVXXpna1dV1qkLSHiyEABkx+swDfwDsS8ySZJom6nZAX/awEOIOpL5zuVx3LpeLs1fA24DKvlQqoWrVqeUqxAOqsg26W6JZi0hH/xZw6UKh8GZf3dj+KAQE1Pa3LOvrnPNzGGPQ/tvwytXSbDq7kfo3UHi3jx079pINGzZUzZ3iHjNmzLAnTpzovPrqq253dzc6TIlly5Zh4Ye5XC7QBF5JQ45UDEwoL53AOY/z/zRRMShJM5DcG0VJRU1ocO2gXC4/Zdv2/JNPPrm9r7Ri1WahRov+Rdd1v4hYAiH6NOUrHMfZGIbhEsdxXkdj3nrFW0miEjJT8d56d6Zqz6UAYrFsk6AxbZdEem485/xw13VHE7EOFCosLqUMwGiFcYfyRqYBgWNP70qlvSdqYBAgvsz3ffjfDfES1l3hfThAWW+jU6nUweX0UjMhAAAgAElEQVRyGaXeR6KQi3OOgCCC2aUwDGHpwir4N+ccwUMEprGJQFHyadOmIS4BmPlN6ESeQNVWfCo9xkLzVVmvXAjxnOu684MgAPKxz8qyzwpBCQX+PTINP06lUgBjVMTOJ10GZRX07LwqOAMr4cVyufztfD7f1mgxhiY5ql2oaiapBXYsYwzQ0KNd10UWIbYIABTSq9hgbhFdGxZhhYpLQkFiMv+Kc44dGn68Sbz86nevzTbKgODdsCOtWrXq3eVyGWCHY7BwiKgD3+O5EDcJ38JBR3UYoWi84abFMGCUTFPEnGos6qwR4PDjQ6ikWVeomi8NZCfmA8Vlkh2rsaBXmaYJpN5KMBYj+2BZ1glhGE4CYpT6TWi7IDYKgMtQdAWynV32wfw/5JBDrGuvvTa9efNmZEyGK8g8XFNYuMVsNru1+JbJBUsVyiDGVCBovHjx4v2fe+65L3ue98kwDGOCG33BV3ox/ftEHU7RcZzfh2H4rdbW1vX9CTD3WSGoB4b5jbzp5VLKM13XjV+sHoEKmTwVJm/Zdd0/HXvssV9fvHhxr3OotWYHFtnIkSOHb9myBVHi78JVoIVAwR9UqUopYeoFoNBWtQ8ABwHH7mAh6iavek9Ew5/gnP/0oIMOemTTpk1y48aNMapRPQ9+A5/PPvjBD8ZkGU899ZSxevXqGEWpyDNi/D4W9vHHH98ZRVExYeXANULL9c85jjMRz0G7LLk6ejq2kUKrZHk4TUjdjK8mT920JQi3PubqWbZBZ+JapHBU4Bf8fiCC/ZPKHmDnnIhSbiHEZ+CfE7aEqvyEEFssy/oN5xwKnYqJdplSoBtjo1HgNdoQCaOCGguMa3JTGO153hzf9wFdngqlTOPRSAyB5K/FWF7mnH/n5ptvvu3cc8+txjHSkJz6rRBUVdcnFMU6gCbbfZIWAqEOyXTFiylFAsG91tzcfMWnP/3pX15zzTXQrAPyURYNiqa+GUURcvyx8sLkJcGq/DfKWWGSPmrb9tYoivBO74YfnMlkJnR1dcVZCG1RYMdEeuxFxthazjkUBHzI+Nr0f6V8eiaGNvAImgFNie+ww3eEYYjAGerksQuGoJQ7+eSTj0HDHCklgnTYoreB0CqIdkOlsWSG626bFqhs6BrJUnJKh+pUbhg4yKnCBoDMwSIp5SUq3hMrTTXQiJlgwaOfaPyOZFFi17Us6240IFY5/F2FS+jPnITSAAr3O5ZlneR5XhrWaRLXUGsdQfaqMA4bSdn3fQQR57e0tCxbvnx5v1yp/ioEPDfAJUiLfYsxNse2bZjh21w3qRBogiTzuMq/hOn7cBRFhXw+/1AfXIeKgwUz7Ze//OXxaEGGfgbJAiP4pIwx0FVj1wIQZovS7lh8+xiGcTaKUcByrBWpxCY7BnT48OFy69attJh6uBi0WgmY0ORm9EwA6nmgdkEgsWFuPm1Z1s2cc/iDMJMhz5Hom2Db9n+AMo3ov2nRkdmu/7/WDp9Mb1GKtVZnb7qeHk3XfVl8T9fFu1I8Br/JGlIyQFejnwkhiPiTeCJhWQH7/x0hxLlwOfRiMshGCPEQ8uyGYfxzV2Qb+qMJlMuK9Pbn0Z+zqalpVLFYjF3dJIlPgy4DLNpXLcu6nHN+Wz6fL/V3vQyEQsA1UOoJLgJo/KnUOl5/qQZQVnR4zOOH/LrqH4hgTL93AlU8Mhs+KCoi9YWjFji66tysCEiQpaB74v2o8/JVjuOgSUdduSWBWJWg3VUmF6HZwIyEnRAUZvgbgm7TTdP8BJh4hRB7E3EpdpdqPAF9mcB6xkU3YRuMMcS3VKmwWPHRotautRXwWiEESHDizAgqS2fNmgXmq2mWZX2Pcw7CF5De9ADOXNct+b4PuYBtGnIZ0FRvX2TVy3OALQGGATwIKA7cpvERXUtfK5UyD/gbAHNBECAgixjMD/P5/BP9VQaxQu/lC1U8XHVXOjgIAvDAYSC3Kc6gnaPReyGHaprmMiEEIJh/uPXWW2Fi9jo4p9+vtbU18/TTT58RBME1lmVNTOTDcW0QtiJgdYPiWNjGB06lUvuXy2VMxLMASqn1Lvq1awFNql0DKEtF1/2d22677W6qv5g5c2b6kUceaQFNXCaT+Uh3d/d+Wu5a5xbQL62/R6MyRBA1TiNTH0E1SWN/uEZ6LJ5POECVkce6QVck+DcYmTjnKFsHVyPScSW4dM8888zYZ599Fnn5ryFqDzMrEZsAKOl2IcSPC4UC+kr2e6NodE729zhlHbzDNE1YeChvpoKu7S5dL7hIrqhhGM85jnN1GIa397KPZ9XXGRCFoK4Ok/bDpmnOE0IAtFTTbaglYNUfr9u27b9EUQQq6qf7qxBQtGRZ1umcc7RAi2MdehxASgl/HfTwgJVWqg0Ahv1yoO6iKKqo2XtMHAW+SaYyG1SMWE8oBV8mpfzuokWL/vy+970vrlhDfGrWrFlee3s7nn+WaZozhBAIeMYfIEbJTE/Itye7UEHu280BtZOrZMZbbFNkFemcEBXuQddCHAUp0gOA/Udql0A0Kn4Ut5QXQvxLSgkuwmdBDBNF0bGWZX2Yc34EXE+4deTaxULhfKNt2//ped6CYrG4rr+LdGeef+CBBw5bsWIFgsIgDoaFWpXiTt9EdMuSFIWiAUBqE1yOsCJBltOosq/52gOpEOAHApo6T/nbb+Wm1KcXLgOlXwAV3iiEuHn69OmXr1ixoma3oHqD+6Uvfcm7/vrrEZD7KWMMJdw9HyV0VNQB5oz0YcxGpA7A4ke5LshMrxJCHKEYf6resh7ApM6zYmBhUt+LnfCBBx5YkuxLCcUwduzY7MaNG0c0NzenEbsYNmwY6+zsjLkWEu9GY9yrsUaEf6+99pKbNm2Kg66YwBT1r6FU4nsoiwA5+Q8xxj4lpexhwqZzYfKGYQhFtwbjjApBy7L2tiwLDNoO8V8oRQfFAMwC+B+wANDoZ8AQVPXmTn++h2Vwyy23uOvXr38nMlFBEKBPRc0NhRRC0tKkmBvQvapO51v5fP7Otra2AQu+92qS1BMMFt2NN96Yi6IIO22Mv++LQqCoMqwC27ZfHDFixDfuueeeP8yYMaPPgItCoeAWCoWZ6XT6ulKpBDBJ8gPzE6ksdHiCYlgzbdq06KMf/ahXKBQOtSzrPM553rKspgoRYSxi+LOxCVvJTdDNwCrKMc4yQBk4jvNIEAQ3T5s2bfHKlSuhCAdE+9cbv35+j7Fm+XyeuCMc27Zncs7nSymPT6VSJorF9PlAE55Sl2QRUNyAWKVgHViWhXQsUpTwl58dCH+5n+/b0OmU3ULTISHER1FBW4nkt1LcoIpCgKUEZO7/gEukq6sLNREDNj8GVCFAQmPHjh23YcMGUEqhbLknltBbC4Fw+yCccBznr77vI+vwVF8ngvLhwI0HLnxgEXo+2rNhQa6WUt5rWdYSzjlSOGBhQjUa0mHYvcxEnh+DAd8Wuxe6K0EhxMGuXsYScA4Kp0CtBRadf0spwbQ8YIPd0AwemIMwrxBnGee67qeDIJiLuA2VDWPBU1whiXvQMxhEgQdla1nWUsR/DMNAC7R+WYsD84qNXSWXy41+5JFHzomi6D/gPhHYqsr8i/9M8yZpaSoLAXP0GSHEZfl8/q6+rodqTz/gCgEBxvb29nehh4PKJccBuN4oBMpdU3pSCIE01S9aW1tR/792/vz5Ot1aYyODh2ltHb5kyRLUtSPdNaLCM8WAEiklJtwWZFCFEPCFh1uWlRJCoJAlKTMoDeAGUGaNwip8TxRh8fhWecAYtaZ912MhTJw48c25c+eWd6egWZV3xIZwhEqzgVRnuIYpiE8h6DN+085JpjF+A8ehYL8/T6fTt15yySWv7UZySVuWdRrnHFmFowDvr7QOarmYiU2Fgt83ZLPZnxWLxV7RozWyUAZcIaibonoQXAkgSo2DXr1RCBrwwkC/xq6uLm7b9vOMsZ+GYbgwn89v7otmVMoKUforGWMnJ2nKNbM+Rpip1uowCuIAEAGqEhYCBgWBSJS1IjAZE8Y2wumXHKDly5fL+fPnV0K2NTKWg+4Yrc9jK/o8CiE+LKWMQVWUJq2WhVFjAeW83rbtX0VR9KtcLreyLzX+u0Iwaq4d4TgOaNjfJ6Vs0npDbmMF0Nyi50yuFaUUoAwQc0HaFVQB6PvZZxd6p1kIuJGaCJgE4HUD7VScT06ah9WURDKyqsxmvDzMeKT+0K+ubluxSi+tKgg/atv2xZxzsBH1lK+S76qbrXp1IYGMVKkufDmAiO4D3fW8efOW7UY7105bI4qCDJYCynvhRp7mOM7YMAxRux4DuGAZ6BwI4MqUUmJ8QW1+u+d5t02dOvWV/qLwdtpLG4aZSqX2KZfL59u2/ckoisaSq0ldpau5Bfoz0jxUFnPEOYcFis3nN+Dl2BHu5I6yENikSZNGrl279gNCCORdDzFNM25nRYisaoNTLbKq0tvgO0BdPAAt8LH7UvONisz9yuUy2HtASjEZzWAq4f/1XhCqBRcVZEFbd1qW9Tjn/Jpp06bdV6El3U6cf4P7ViqwZrmuOyUIAsRjTkqlUuBHAFAnjRQjXIO3QK4hlCzASg97nrfI9/3HleW128RSJk2aNKqjo+NcxthFYANHjw1yf6kuQ48V6P8mi0m3oNTcR3wpLv9euHDhygpdowdkEuwohUAdmPaxbfuzjLHPhmEInEJN16GSL0X+pBIado7NlmX9nnN+RT6ff6UvroNKIyIL8mHbts/inB9EkGu6HymI5P8ty0Kp6aZ0Ov1wd3f3b3O53P3t7e0YrKFPbQmw1tZWe8mSJaiQRaAWXAlTPc+b6vs+5obvuu7GKIqQhnwuiiIUt4GRGCm13UIZIL50wgknND322GOnBEHwfbwb+nqo3iCxJVTFHdhOcmSZ4nikXB3HeTgMw+/lcrm/o8R/R1mjO0whqDcEwwwgmqBTn4UUNV5Qx8vXM50qCBDE+K9JKa+fNGnSLzo6OvpaBouJCRrwnMqXg+l4JEqdyXVQqLqYJQlZD9/34bY8J6UEvfUiUL8NFELs7aRN4FLeeOON6WKxmO3q6gJiD+AJBA+x+EuTJk0qXn311cGO2gV3lKwPP/zw7NKlS5GNugjdyFFeT3gKHYKdtA6qPQ+V3ysU7Y8RpyoUCpt3lDKIN+wdJRx1XWov9kHDML6H0l0oA53Ao55CSFoVCjcbd88tlUo/HDdu3N3r16/vNUiFCEBvu+225s7OTuxW7wXfgGmaYMAZY9v2MKDzXNftDsPwdSklzFgwLz+s2neBms3fkYOzg8dml18eY3DZZZf1zEEEVNV47xYWgS7A1tZWZ+nSpYeqjAKYpVHfE1sFOolMtSCqfi0co7EiQUmCa/Trs2fPfnHRokUowtth8tnRCsFQ/uMk1ZTiM57nWaAsqzQb9WBiMpZAx+PvqrCjrMwo1B/8ra9BRqUUgRyDP4vagGmmacJSwK4FTD4oygBlxk/HmDFjNn7hC1/oHlIEu1yfDKYHwMYHaPsFpml+jCxNgmuT+V+Pp4KsYUrNuq7L0Z3L87xv+L5/Xz6fD/roIjcsqx2uEPAkSinMYIyBSOVdyMdWe0JK7empmGppGLSDi6IIVW9Xcc7R1AOWQp+1J7S8MvMIgguyEzFp0iQ+ZswY2dbWRu3HGhbw0IF7tgQUu9U+rusig4KMAshsetLU2Okpk1JLEjTHVcwADYiE7/uwSsEO9dN8Pt+5o5XBznAZemSAdN8bb7zxEc45GsUiBRUTjVT6kFmlWwz6cUR1hvQUYwzpqXYpJSCtD+8Moe3ZU3zo7XohAUzgsa7rno+GsK7r7g3uSOKCIHeXGgrVwVzoAUcQ7IC09w7XdX/4gQ984IWdNa93ioWgBIx7gWgEgKVPg/ocJbYIukCAWOREYlrLesB3Ok5A0ZNtBrkkyqUVhFhn4OnF+A4dOiSB+hKg2Mdtt92WXbFiBUrRv10qlfYBlo1wBriKbuXqLrA+f6EkdPSmagkHIhhYvtfk8/l7B7J4qd7b7UyFgGdBzvlozvmFaI6CkmSFRIyfU8/711IKGqKQzuOc8/VSyl+PGTPmv4YPH/7qypUrAR/e3Qg06o3X0PeDQAJQCFOnTm3evHnzbND5d3V1HQXUK2WlSBkklYL+6HoTF7gVCuyGTREpxhfCMAQ8eSH6lOzIIGJSnDtVISh/C2WxAKfMd133qKSJVS/wQkJOKAWCGa/xPO8O3/dvWrhw4YrdLW01COb60CM0IAGQ9W7duvV0x3EuKJfLR9q27RLWoBFlAIuA4PnU+FjdFpYt0ugL0un0DWeccQZ6iO7UTW2nKgRN1lAKHzBN80ohBFiEYyAT+Vz1xqRSNkKldpCVRIUg6LkQjFkOvLdOa17v2kPfD0mghgQwRwGiOtO27S+itVsURQ5B2vX+m42k0/XGRp7noQNZ3JsE6H8FyuoXYWpfRnJXKQSWyWTGd3d3f96yrPM556OIULORIijdH9OFqoI5yASADu1PYNeZN2/eM+3t7ebuUhTTl0EcOmfnSACWQVdX14eam5s/t2nTpiM8z3OJYk4nSSXcQbUqRnIRgMmBRQwK/nK5jOD4o9ls9vKvfvWrD+yqtPYuUQgqDYncPwBBXwEPYzqdHu77fsxPX08p6ILWSUA1yjLg4tGpGZbC9a2trav707xi50y3obsMYgmwY445ZtiaNWtOX79+/aVBECBLhhR1HAgny5ZShrUUAh1D7wpKOtD/CyHQlernYRj+QWFedok4dolCoJbugDKDVSeKIrA1z3IcxyNYcy2loJchUwpSxy8olJdIp9PAxv9+5MiRP9+wYQNQhkOfIQn0VgJYI8MdxzlTCPEFznlrKpXqgSQrSHucUUA3LDTjrbeh4QGoyAlNa6Io6nBd94YgCH6lSHZ2atxAF8guUQjaA8BKyGYymXcHQXBpFEVHe55nJ5h+txtACD9pGRAZJ5FsoHFpd3c3YgooPEL7bbApg4koJiwd+gxJoAEJYH7u7Xle3vf9T2QymQN833eBK0iW8zdSq5BAIsYAOsuy1qAbFfpUlMtlUPjtMmUQWzoNCGVHHgIOPjObzQ675ZZb8mhCEkXRQURiStBPchFgotVqJJLUzOr/cZ8DIcTDimYdBBMDRkq5I4UzdO1dJgGsCyiDqa7rfgpcmrZtA3SEv/XQ3euBw0rxgkokMLpbK4R4E1mxk08++coZM2a8WCggltj/HiT9kdquVgjxsyOm8OSTT05YuXLlWZ7nfUlKuR+BlCBAavlWDbm4jcmj0I8J5QBLoUtKuVhKuWDy5MmLV69ePVSy3J+Zs2efiyrdlkwm8ykhxEfK5fJY27ZjIp3kJlUpm0DAI0ImJtvkqd4W3ZZlPYi2dLlc7tHBEvQeFAoBcwslsVdeeeWEUqn0WcMwzjcMY3Qmk2HwyWJTpgrMudK8JA4D/Tt0BkIBlJRyuZTyF5MnT77zpZdeWr8zQR979hra7d+O5XI5dI5CWfyRqEtIp9NnlMvlkUAgEugoaQnUUggkEVIQmptbsm37n1EU/aRQKNxbKBRACjMoPoNGISj3BUVPkz3Pu8D3/XMYY80IQOr+Gv27nvQqKRBVOh1ZlvWCEOLXY8eO/d26devgt+02HYDqvffQ932WAJXqn5JKpT4RBMFxUsp4/hGQCFYrBbETm03Vm+owZdWLIjBN8zFQoXHO0VQYNQuD5jOYFAKEYi9cuFDOmTPnINM0wVQLRqNmNI8laGcjXXLJrKsmZbR8dxznVSHE3zjnvwDRST/KpwfNYA49SJ8lAGUA3kM0050bRdGB6EaX7D6NeZWkAKyGNSB3QStoQiFeJKVcls1m0T3s7nHjxnUONuq9waYQaERhKYCk9ULLsoAXHwZCTr1qrNLQVxscOpasBqDCyuWycBznTcbYv4IguHXvvfe+j9iXhtyIPi+s3e1EKAIvm81OLxaLn7Jt+yOMMZD4gBO1pzhJd0Hx70Y2JX3OqQKmKIqiZ03TvOHCCy9ceM011/SV6WuHyniwKoQ496v6OqCs9P1CiAxSisj1lkrbJwkaVQaQJo5FWrJUKgEUUk6lUi9KKW/1ff/Piul3p0NGd+goD118GwlQtWKhUBhtWda7pJRnWZZ1UhiGmHMxIWqSwwD+P/5WK8uVjBmQIgEnommaq1GNO23atNtfeOGFQduAZ7AqhDjImM1m0zfeeOPBq1atmmdZ1qlCiLQGauoZ5HrKAAfqWh6YBYr8qt+ojFxnmub9pmn+Loqifyrfrs9kK0NrcNBKAFaBc8opp+y/ePFidJr+UBiG6NWR4Zz38Gni6SnDBYsAcyZRdl83buA4DjYcwTl/1TCMm4GFKRQKb+wqWHIjIzJoFQI9vGp4gerIC7PZ7CmlUgkl1D08CtQPEMcTUqzai1cKNGqKglKTz0gp21Kp1B0f//jH1yxYsGDAm2E0MjBDx+wQCWC+e7Zto4vS+YyxdxuGMZ5zDhr+mOWo2hwhy5I2H50nkZQHflO1LjqYw/qUUr6MTUYI8VtlfQ7qAPagVwhqWiAv/E7DML7Y1NR0eqlUimMKiPqSeZdsFFppOlVLXZJSIAJX27ZBqroYNemjR49+4otf/GJxMGv1HbJ09rCLomHME088sdf9999/ZhAEnzIM4zCgZGFx6kQmZE3qVmeSfyPZjk7PglEQET0moih62vO8m1Op1N1vvvkmrATqKD5opbu7KAQ2e/Zsd8WKFYevWrXqglQqdSbnvBlKoVz+3xSuHgiqpRBo0GhHSCoKpeVB4vok53yhEGLRl770pZf32muvcNmyZehuvEvhpYN2Ng3CB8OCv+aaa0ZefPHFR2Wz2bOLxeJJjuNMQL+ESoqAXqEaCE4HJ5Ei0Dk84CZIKVGstFwIgU7idyxcuHDT7sLNsbsohHic8vm8+8c//vHIMAw/ZxjGGYwxlE0zvSCqVjyBFr6uEJLxBfwfBSu4pmWBIDpYK4R4yHXdO03TfPTMM898dUghDMKVX+GRZs+e7e27774H3XTTTWe4rnsG5/xQz/OyYP3WXU09vpREIlaaM7rbQFBkchfQqt0wDHSb+k/DMP4+e/bsTTuaOn0gR2O3UggKvJRyXXd6EASfNAxjDrQ9cAoUP9BLUpOCalQhUMs5KAXbtlGNBrjk6nQ6/ZdZs2b95qmnnnr++OOP94cUw0BOxf5fCxB4XGXjxo1s2rRp42+//fb3dHd3z2GMHSuEGBkEQVyyTC3ZdSsgaTXS01SaM0R/lth8EICOlYFlWQu+9a1v/aG9vT144IEH+tSpvP/S6NsVdjeFQG8J0Mi+pmmio/DHVf88NFWJB7saDVulwU3+TfchtX58oGiDYnhDSrnENM2/wo04/PDDXxs1apQ/WHDofZsCe9RZmBdokPIe0zTPTKfTM4vFIvoloMcGQ6q5WCxuFzisZDHqAUbdpdRdBq1mQVqWFdfKRFF003XXXffgBRdcMKgQiI2O8u6qEPB+cWmqaZofZ4x9AgoC0WK0bq+nEKrFF2iwCXOeLLFW7eHR2/EN13WfCoIAZBZ/aWlpWbMbdSZudG7sNseh1mDWrFmZ9vb2w9Lp9NmmaZ5WLBb3VRmFuMM0xpbSzckei8lYgv7iSXdCtxwUSIl4EP8MHsRsNvvsfvvtV95dCXl2Z4VgqJQkGoeiDdu5juMcF4YhMhIV36tWlgEDrU8MmkS6C0LYBaUoAH9eI4T4FwJHJ5544qPnnXfexnw+XxxCOu40XQIXYYTjONMYY+8D1yHnfDrnPAs2b8QKiOYfY6vzGGiZpW0sShr3SkqB5gdxKDLGuGVZa6Mo+nVTU9NvPvnJT668/vrrd2u+jd1aIahBI+LLYxljn4e/KKUchQwE7QQYSH0xE/Q0qSAaATglMhPAp5cYY6/ClZBSPmRZ1r8uvPDCFVdddVWv+03utGW0m99o4cKF1kUXXTTitddee6dt28czxnK2bbeUSiWMexxH0D/1xrXS91D6sChorug1DLAUOecoUlohhECL9v82DGN9oVAId/f09J6gEGL3Ye7cue5vf/vbGV1dXaiSPF1KOT6dTluAOSMIRF14KUag/6bJU2/ikBWhxx3UuehIXZJSgtx1WSqVejCVSt1z7LHHvnDPPffs1jvGYNIdc+fOdRYvXrz3yy+/PKNUKh2XzWaPF0JMLZfLzYppK65MbGQcaykM/XxyG9PpdJx5iqIoJtxhjGEDuNUwjL9Omzbt9cFWpNTXcdsjFIJGs47W4lOQkkyn058olUrTwb6EAaaBJQ68/iiE5LlKQVC3qEgIsTmVSj0RBMEje++994MjRox4+umnn97c10F6m59ntrS0AEl44HPPPTcrlUodVS6XW23b3sc0zVQQBBaCBNjBqTy5nnVQzzKEUoGriM0kgUhEcPlNIcRf0ZrdMIzHpJRx8HBPcRP3CIWQWDAwGUe6rvuuIAg+Z5rmsZZlNQGnjsFNBpT0IFEldBpZBdWsiEpxCcBWoygSnud1CyFAoIny6j+7rrt48+bNrwOxhhLsPWUSDaTCamlpcZcvX26OGTPGLhaLw8BwLIR4l+d5J3HOp3LO0QIQ6J84PhCbh7Ydjys+jfBlJLMG1VwMHKc2EMCQETPqCMPwN67r/m7evHnPFwqFQY887O3Y7IkKIVbYEydOTG/cuLHFNM3P+r5/muu648IwtPqShdAVRSVztFogSh0rbdsOOOevW5a1zDTNfwRBgL59Kw3D2GAYRnlP8D17O/EqHT9z5sz0I488MiaVSu1fLpcPdxxnpmVZhxuGAawJmI/Ncrm8zZylXorw9XXqsv48D3VVGj58uLF161ZYfp1SSoCNfmMYxqLJkydvWb169aBhOerPuybP3VMVQtwJijGG/PNk27bfH0VRHjx56C8Z56EqfKplIchKaNQ3JQVBABb4n7Aaurq6QsuyOoUQazKZzNPFYnGJ6i61yjCMNf1tZz+QE2MnXSsm2Z0+ffroB5+0R3EAAA3ESURBVB988ICHH35433Q6fYzv+8cxxvbhnKNmJUWsWfDhyZynmJBegUikprrV15f3wDira8ECWGtZ1gOc89/l8/m/t7W1oa6F7e7Bw2py2WMVgvbCAKuMtSzr3ZZl/Z8gCBCVHg3rMolX74tCoHOSykLfraAY4I+q3SyONXDOy7ZtdzHGQMP9fLlcftZ13WdPPfXUZxhjr9x5551AR+LYQV0d1+iCIxRhW1ubgBJoa2vbyzCM6Z7nHRqG4aGWZb0zlUrt3dnZiVZp2VQqZaFOhdyBJFEp7gsZkxtIz9FIw+B6zwxXDsVJYRj+23Xd23zfv88wjFVSSmSU9uiS+LeDQoi5FQqFAvpJTjUM4zTG2LlSymmYU/pu0luFUM8X1avgKI2lg6YU+66wLAs7UZlzvjGTyazq7u5+0fO8Z3zff2Ly5MnPrV69GoGr3bXFPWSMuI7ruu7kpqamFtu2D96yZcs0KSVQhPuFYTjKdd04QJjEkOj9EjFWJD/IEx+KCVFQsdYYxr6kAinVUAooTuo0DOMBwzB+edxxx/3zlFNOeX1PtQjeNi5DtQE/4YQTRj700EMnGoZxjmEYMz3PG+X7fsy3j3N0n5RASZh88FExmSq1mktaB/UmZbU4BC160zSBf8ek3Ij8NmPsJdM0nzYMA1wNr5imWbRtu9TV1dVdKBT8+fPn71K8vGrUy+bMmWMfffTRzk9+8pNUV1dXc7FYHC+lnGpZ1qGq3Hg/FKRFUQRmIhcIQ8idSpAHwtSnRU9jQOOlVybqVoTWOwFcJkgnrgQfhmEYdyl3bo+w0OpZRT2yb/TAPem4XC6Xam9vP8Q0zZOEEKiafIdpmhnP88zu7u5YMVA+m/gW4L/S7lJpwVfLUFSSW7VYRKXrKhMVGQlYCVtM0+zCxE2lUiuKxeIzruu+7Hnehs7OTnQOhptR+tCHPtT94osvlpcuXQrLA6XaZF2QudsbszeWB/zmlpYWtm7dOnvUqFHen/70p0xbW1uT4zhNYRhmbNsexmw2ISyH+2UymSlhGE7jnI/B303TbIqiKB1FUQwaojZmFJvRfzcyz+pZcqQUaAwTVlmMUxg2bJjR2QmdG8sGMnrZMIz7LMu6i3OOtn/IBr3tMCRvC5eh0iQDyOWZZ54Z+eijj6Kl9wfAniOlnA78O1CO2EWIgIVSWlTqWg3p2MhkTh7Tm0Cl5r8K0zThYsQKACauZVmbPc97vVwuYyJvNE1zcxRFRcdxsOt1B0FQSqVSxXK5DJ4H+Mcil8uJd77znbK5uTlWEMuWLTP/+Mc/miAZRUQfAb0oijLI96MqnEuekobZZDI2XIhojBDGxHQ6PbZU6h5lSNmUbWpKdXd3p5g0UkIIlzEwkr0FHCSCXMrr91UZ0GKvJeskgQkpEOq6rHVs5mEYguz0maamptu7urruP/zwwzs+/OEP+4VCgRRpX4Z1tz3nbasQaMQmTZqU7ujomGAYxrsYYx+yLOuEKIoQ2AJuIS6UooBWJU695G7VgI+63WRpRCno6Ejdj1YVmai2wwQGsy+XUka2bXN8TNMMpZRQHlAIaFRTZoyFYJ0G+zTKu5EB8X0fP2YmkzENZjAuhB0EYdZ1nEzEw5Rl2V7g+7aFC0eRhd/pTNru2trpuJ5nOY7Dil1dEJphMTN2rchcp/cjjkJSsCSIRt5fF1qjLhmO01qn9cCQoVg9z4NufA5IQ/w0Nzcvvfjii7fuavdrV2uSt71CUAMAXxYoxwPgRoBMo1wuH+W6rleJpq2ar1st45Ac5ORxjSyIJFya0JdEAKo/U8J9waJXG7IEYApoOyzW+O9U9EM7dxy155GRSqdZuVRi8JOw2MMgMNKZDCt1d6MP+ls4/ygyLBVfMeRbXgi+i4Kwp+WZ/q7JrE5vXYVqcq9kdSWtOShO9Y5RGIZrTdO8izH2V7gHCxcuXDtnzpwhpu1B0Ox1VyvEbe6PbMS11147bPPmzYA/n8IY+7SUcoJlWWDkNTG5dVRcXx++khXRiFIgcxnH6tYK/q27OPpxeg8BStPpfyPrB6lR7NyIlaSzGQMLX/+k0mmjXCoZrufFrhQpAE+dR/56hFiLVmyKd6X3xXNTcVhfZdfIefr91PEApfhSyk2GYaA6FYSnixGTUTyHvYmpNPIIu+0xQxbC9kMHth23XC6P7ujoONzzvNMMw3i37/tTGGOwIrarphuo0a+nFPTdFtFx/D9JCKMfo/vOWLBY7HQPPZ1HCxXvQZmV5A5LCoh+Q4FAmYBwRD+PYgZ0TVIApBhwbDW+ikblWE+paJZIjBIFfJxzDhDYvZ7n/f0973nPa8cdd1zp7ZJKbFSu8UbSm4PfTseCpRc/hmGMUSmzWY7jvDsMQ2Qk0Fkqll29RdwXmVWLQ+gLnHgkaYePzXXH6aEHI389yTdJOzmlUEkBUOQfi5Uam+qlv3qDEv2epDhwf1I6ZKGQGwIZJSP9SbnocYF6Mq3keujXQ4wAtQeMsQ4p5cPAFLiu+68jjzyyY/bs2V1DiqD6rBxSCPVXbMzlbxgGau1ncM5PMQzjeNM0pwohsshIgNOfIttYlPhQmjKZD6fFUkmZ1FoI9QJp9V/jf4/oL25C3+2T9623mBt5TlJWpGTI2iA8iC47ncDGcRxkDYDJWCelREPVexTAaGNra+tuy2LUiMwG6pghhdC4JCGrtIJBH2xZ1juCIJht2zaUBPD2MeqRdk8w9nR1dcW+PaXcKnH6Jc3f3mAUGn/0bY8cCIWgKza6Ol233g5e77nJQiILA/Kr5OJotQvIsqCC9GUhxIOGYTwMCv2f/exnL37qU58CPHwoRlBP6Or7IYXQoKC0SY/aKLgSUA6TDMM4wbKs93POD7IsayysBiDvUqlUXJ5LLcBol9P5GJILiXbeSj72YLMQaoktkeXoObTRLAxlUHTGK1K2kI1qqANl60dRtDmTyXSUy+V7J06cCHThCx0dHQhsvO1ARb2cyhUPH1IIfZSiqo+Qo0aNGvbGG2/sbRjGIY7jvCsMw6OB2Q+CIC6gUvTwDDx8UBCVFkvyb5WshMGkEEhkyWdq5LkbwWlQ+TFR68NSQAMU3Bd4CcdxusMwXG0YBhCFDxmGgYDhS8giqPoQKO0hq6APc3tIIfRBaIlTUAoLObp/+tOfRj377LMHlsvlmYZhHM4YQwHV/lLKZiiHdDrNkp2rk7tmvYBi/x93+0BoPWXTSGyjmlXQl+fV06pQDq7ryu7ubuAE1ti2/WIURQAUPZBKpZ4ql8tIJQK2PdRNqy/CTk7mAbjG0CWUBOAqXH/99e73v//95nXr1o2CMjAM4x22bR9nGMbRURSNVejHHkWcdBN2J4VQzUKopWDqpQwhSigBoCfL5TK3bbsziqKltm0vwW/DMKAMOgzDeLNQKHTPnz8fGIMha2CAVuGQhTBAgqxwGfPxxx+3rrzyymFtbW0o8z1IWQ1HOI6DgGTsUuA8ncVpd1EI1RZ9Iwu+hsVBRVjogPScaZoPCSGes2372SiKnoUlkM/nhzpm7bg5O4RD2IGy1S8dE4UuX748O2rUqGy5XB7v+34L5xyWwyGMsX2llCgJRqDyrbzlW59tLImBetaByjJUe546QUVgBPSqS1CRweR/0zCM5w3DeMowjCdc130+CILX8F0ulzOGumMN1OjXvs6QhbBz5BzfBaxBCxcuBGW7MXPmzNTIkSOHL1q0aLxhGAeir0AURS2MscnoK5FKpUaUy+Vhtm3biLYrhGAPzTjhHhLNY3pgwnrNv14GrPcXqLWg9fOppR2OT5KYVgsk6lgCRQ4DRSAcxykhM8AY2ySEQGUmuCWX27a9PIoi0MhtGjVqVPnEE08MDcMIhvpn7sQJOoRU3LnCrnI3uA2wDLKe5zX5vr+3Ihndz/O8fX3fh8JAFmO867rNYRiirNhE+g2dr8EmTYsSIB3Vtbqn2pDuqfMN1gsi6uXDOo6C3Jka58c7vzofRVTgYwCHJEqMN1mWtYZzjl3/JWUNgIPg9cMOO8w/6aSTysOHD0ejE1Rr7jG05oNihvXiIYYshF4Ia0ceqliHjAULFthr1651CoUC4NEZ13VHg3AUisIwDMQd8DMhlUrt5/v+OOVqNNm27WplxfG4gtwVvIS0w1OzEb24qdI70fF6BkQjisWip3mjswkhC4DeE2B52mCaZocQYq1hGOvwN8/zNvm+v/aoo456ffTo0d333HNPUCgU8PO2YiTakXNoIK49pBAGQoo79hqwIPSfrOu6ewVBEJORWpbVbJrmmDAMwekwwXXd8ZzzsUh1CiHSqidFynmLFSWmLGOMYRGSH09zoIdfUkoZk4PAAomiCH+HmwNfvwgyFsYY/P2NjDHQyMP0x6LHD/6OMsmtqVQKZC1bLrroovJ5553HS6WSbG1tBax4SAHs2PnSr6sPKYR+iW+nn0yLtmdRIS7x5JNP2itXrmQjR470xo4dm3UcBy4ISE2dJ554AkHKFPhMoiiCMgHHA5CW+ImZkJTCwVyAIoDvDpQfdnz8+OBvjKIIC708cuRIf9y4cVAOgSopDlzXLY8aNcpvb28nRTOUBtzpU2NgbjikEAZGjoP5KhhjKBJiPyZrgxYv/k+KhtJ++sIW2NnPPPNMXigU+sLJOJhlM/RsCQkMKYS335TQx3xoJ3/7jX/NNx5SCEMTYkgCQxLokcCQQhiaDEMSGJLAkEIYmgNDEhiSwPYS+H8ZcMi09VVinAAAAABJRU5ErkJggg==" />
+  <link rel="stylesheet" href="./style.css" />
+</head>
+<body>
+  <div id="app"></div>
+  <script type="module" src="./main.js"></script>
+</body>
+</html>