#!/bin/bash
# Local five-second no-audio release. Run only on a chosen dialer, not AMD server.
# Does not change campaigns, firewall, SSH, credentials or provider allowlists.
# Python dependencies (pyst2, six, websocket-client) are embedded at the end of
# this file and installed to $AGI_DIR/amd_pylib: no pip, no internet, no site
# packages touched. Only a missing /usr/bin/python3 is installed, through the
# OS package manager (or the official archive on end-of-life CentOS 7/8).
# Every failure prints what failed, what was found and how to fix it, and is
# also written to /var/log/amd-client-install.log.
# First, before bash reads further: a copy converted to Windows line endings or
# cut short fails here with a clear message. Each line ends in '#' so a stray
# carriage return lands in a comment and these two lines still run.
grep -q $'\r$' "$0" 2>/dev/null && { echo "[amd-install] ERROR: $0 was converted to Windows (CRLF) line endings and cannot run. Fix: copy the zip as a binary file and unzip it on the server; do not open/save the .sh in an editor. Nothing was changed." >&2; exit 1; } #
[[ ! -f "$0" ]] || grep -q "^__AMD_PYLIB_""BUNDLE__\$" "$0" || { echo "[amd-install] ERROR: $0 is incomplete (truncated while copying, $(wc -c < "$0") bytes). Fix: copy the release zip again (binary mode), unzip it, and rerun. Nothing was changed." >&2; exit 1; } #
set -Eeuo pipefail  # -E: the rollback trap also covers failures inside functions
SELF_DIR="$(cd "$(dirname "$0")" && pwd)"
SELF="$SELF_DIR/$(basename "$0")"
AMD_WS_URL="${AMD_WS_URL:-ws://144.76.101.53:2700}"
AGI_DIR="${AGI_DIR:-/var/lib/asterisk/agi-bin}"
EXTCONF="${AMD_EXTCONF:-/etc/asterisk/extensions.conf}"
EXT="${AMD_EXT:-8371}"
CTX="${AMD_CTX:-default}"
PREROLL="${AMD_PREROLL_FILE:-sip-silence}"
PYBIN="${AMD_PYTHON:-/usr/bin/python3}"
AMD_PYLIB_SHA256=ee4c68059abf4dad7e9fd51060be32ba93dbd289b0000992aa8fde620974753e
SCRIPT_ONLY=0
CHECK_ONLY=0
ARGS_GIVEN="$*"
for option in "$@"; do
  case "$option" in
    --script-only) SCRIPT_ONLY=1 ;;
    --check) CHECK_ONLY=1 ;;
    *) echo "Usage: bash install_amd_client.sh [--check] [--script-only]" >&2
       echo "[amd-install] ERROR: unknown option '$option'. Nothing was changed." >&2; exit 2 ;;
  esac
done

# --- logging and error reporting (output only; no effect on what is installed) ---
LOG_FILE=""
STEP="starting the installer"
HINT=""
PY_INSTALLED=0
_record(){ [[ -z "$LOG_FILE" ]] || printf '%s %s\n' "$(date '+%F %T' 2>/dev/null)" "$*" >> "$LOG_FILE" 2>/dev/null || true; }
log(){ echo "[amd-install] $*"; _record "[amd-install] $*"; }
detail(){ echo "[amd-install]   $*" >&2; _record "[amd-install]   $*"; }
context(){
  local os py ast
  os="$( . /etc/os-release 2>/dev/null; echo "${PRETTY_NAME:-unknown OS}" )"
  if [[ -x "$PYBIN" ]]; then py="$("$PYBIN" -V 2>&1 | head -1)"; else py="$PYBIN missing"; fi
  if command -v asterisk >/dev/null 2>&1; then ast="$(asterisk -V 2>/dev/null | head -1)"; else ast="asterisk not in PATH"; fi
  detail "Context: $os $(uname -m 2>/dev/null) | bash $BASH_VERSION | $py | ${ast:-asterisk -V failed} | user $(id -un 2>/dev/null)"
  if [[ -f "$SELF" ]]; then detail "Installer: $SELF (sha256 $(sha256sum "$SELF" 2>/dev/null | cut -c1-16)) args: ${ARGS_GIVEN:-none}"
  else detail "Installer: not run from a file (\$0='$0') args: ${ARGS_GIVEN:-none}"; fi
  detail "Settings: AGI_DIR=$AGI_DIR AMD_EXTCONF=$EXTCONF AMD_EXT=$EXT AMD_CTX=$CTX AMD_PREROLL_FILE=$PREROLL AMD_WS_URL=$(printf '%s' "$AMD_WS_URL" | sed 's#//[^/@]*@#//***@#')"
}
# die "what failed" ["detail" ...]; DIAG=<function> die ... also runs a diagnosis.
die(){
  set +e
  trap - ERR
  local line
  echo "[amd-install] ERROR: $1" >&2; _record "[amd-install] ERROR: $1"
  shift
  for line in "$@"; do detail "$line"; done
  if [[ -n "${DIAG:-}" ]]; then "$DIAG"; fi
  context
  if [[ "$PY_INSTALLED" == 1 ]]; then
    detail "Nothing else was changed (python3 was installed earlier in this run)."
  else
    detail "Nothing was changed on this box."
  fi
  [[ -z "$LOG_FILE" ]] || detail "Full log: $LOG_FILE"
  exit "${DIE_STATUS:-1}"
}
# Exit status meanings for the unexpected-failure report.
status_meaning(){
  case "$1" in
    126) echo "the command exists but could not be executed (permissions or noexec mount)" ;;
    127) echo "command not found" ;;
    *) if (( $1 > 128 )); then echo "killed by signal $(( $1 - 128 ))"; else echo "the command reported failure"; fi ;;
  esac
}
# Report any failure that has no dedicated check, instead of exiting silently.
report_failure(){  # status line command functions
  echo "[amd-install] ERROR: failed while $STEP" >&2; _record "[amd-install] ERROR: failed while $STEP"
  local cmd=${3%%$'\n'*}
  [[ "$cmd" == "$3" ]] || cmd="$cmd ..."
  [[ "$3" == false ]] || detail "Command: $cmd"
  detail "Exit status: $1 ($(status_meaning "$1"))"
  detail "Where: $(basename "$SELF") line $2${4:+ (in ${4// / <- })}"
  [[ -z "$HINT" ]] || detail "Hint: $HINT"
  if [[ -n "${FAIL_DIAG:-}" ]]; then "$FAIL_DIAG"; fi
}
on_unexpected(){
  local status=$1
  # Inside $(...) or a pipeline do nothing: bash behaves as without this trap,
  # and the parent shell reports the failure once.
  [[ "$BASHPID" == "$$" ]] || return 0
  set +e
  trap - ERR
  report_failure "$@"
  context
  if [[ "$PY_INSTALLED" == 1 ]]; then
    detail "Nothing else was changed (python3 was installed earlier in this run)."
  else
    detail "Nothing was changed on this box."
  fi
  [[ -z "$LOG_FILE" ]] || detail "Full log: $LOG_FILE"
  exit "$status"
}
trap 'on_unexpected $? $LINENO "$BASH_COMMAND" "${FUNCNAME[*]:-}"' ERR

# --- diagnoses, run only after a check has already failed ---------------------
same_file(){ [[ -f "$1" && -f "$2" && "$(sha256sum < "$1" 2>/dev/null)" == "$(sha256sum < "$2" 2>/dev/null)" ]]; }
# Value of a [directories] key in asterisk.conf, e.g. astagidir.
asterisk_conf(){ awk -v k="$1" '$0 ~ "^[[:space:]]*"k"[[:space:]]*=>?" {sub(/^[^=]*=>?[[:space:]]*/, ""); sub(/[[:space:]]*;.*/, ""); print; exit}' /etc/asterisk/asterisk.conf 2>/dev/null; }
show_path(){  # permissions of a path and every parent folder
  local p=$1 n=0
  while :; do
    if [[ -e "$p" || -L "$p" ]]; then detail "  $(stat -c '%A %U:%G' "$p" 2>/dev/null) $p"; else detail "  (missing) $p"; fi
    [[ "$p" == / || "$p" == . || -z "$p" ]] && break
    p="$(dirname "$p")"
    (( ++n < 64 )) || break
  done
}
diag_not_root(){ detail "You are $(id -un 2>/dev/null) (uid $(id -u)). Fix: run 'sudo -i' (or 'su -'), then: bash $SELF ${ARGS_GIVEN}"; }
diag_self(){ detail "\$0 is '$0', which is not a file. Fix: unzip the release and run: bash install_amd_client.sh"; }
diag_client_missing(){
  detail "Files next to the installer in $SELF_DIR:"
  local f; for f in "$SELF_DIR"/*; do detail "  $(basename "$f")"; done
  detail "Fix: unzip BOTH files (amd_agi_client.py and install_amd_client.sh) into the same folder and run the installer from there."
}
diag_extconf(){
  local etc; etc="$(asterisk_conf astetcdir)"
  show_path "$EXTCONF"
  [[ -z "$etc" ]] || detail "asterisk.conf says astetcdir => $etc"
  local c; for c in ${etc:+$etc/extensions.conf} /etc/asterisk/extensions.conf /usr/local/etc/asterisk/extensions.conf; do
    if [[ -f "$c" && "$c" != "$EXTCONF" ]]; then detail "Found a dialplan at $c. Fix: AMD_EXTCONF=$c bash $SELF ${ARGS_GIVEN}"; return; fi
  done
  detail "No extensions.conf found. Is Asterisk/VICIdial installed on this server, or is this the database/web server?"
}
diag_agi_dir(){
  local agi; agi="$(asterisk_conf astagidir)"
  show_path "$AGI_DIR"
  [[ -z "$agi" ]] || detail "asterisk.conf says astagidir => $agi"
  local c; for c in ${agi:+$agi} /var/lib/asterisk/agi-bin /usr/share/asterisk/agi-bin /usr/local/share/asterisk/agi-bin; do
    if [[ -d "$c" && "$c" != "$AGI_DIR" ]]; then
      detail "Found an AGI folder at $c$( [[ -e "$c/agi-VDAD_ALL_outbound.agi" ]] && echo ' (it holds the VICIdial AGI scripts)'). Fix: AGI_DIR=$c bash $SELF ${ARGS_GIVEN}"
      return
    fi
  done
  detail "No AGI folder found. Is VICIdial/Asterisk installed on this server?"
}
diag_symlink(){
  local p; for p in "$EXTCONF" "$AGI_DIR/amd_agi_client.py" "$AGI_DIR/amd_pylib"; do
    [[ ! -L "$p" ]] || detail "$p is a symlink to $(readlink -f "$p" 2>/dev/null || echo '?')"
  done
  detail "Fix: point AMD_EXTCONF/AGI_DIR at the real paths above, or replace the symlink with the real file."
}
no_asterisk(){
  local c; for c in /usr/sbin/asterisk /usr/local/sbin/asterisk /usr/bin/asterisk; do
    if [[ -x "$c" ]]; then
      die "The 'asterisk' command is not in PATH." "Asterisk exists at $c but PATH is $PATH (often after 'su' without '-')." \
        "Fix: run 'sudo -i' (a login shell), or: PATH=\$PATH:$(dirname "$c") bash $SELF ${ARGS_GIVEN}"
    fi
  done
  die "Asterisk is not installed (no 'asterisk' command in PATH)." "No asterisk binary found. Run this installer on the dialer (telephony) server, not the database/web server."
}
diag_lock(){
  local inode pid
  inode="$(stat -c %i "$LOCK_DIR/amd-client-install.lock" 2>/dev/null)"
  local holders
  holders="$(awk -v i=":$inode" '$0 ~ i"[[:space:]]" {print $5}' /proc/locks 2>/dev/null | sort -u)"
  if [[ -z "$holders" ]]; then  # /proc/locks can show another inode (overlay filesystems): look for installers
    for pid in $(ls /proc 2>/dev/null | grep -E '^[0-9]+$'); do
      tr '\0' ' ' 2>/dev/null < "/proc/$pid/cmdline" | grep -q 'install_amd_client' && holders="$holders $pid"
    done
  fi
  for pid in $holders; do
    [[ "$pid" != "$$" ]] || continue
    detail "The lock is held by pid $pid: $(tr '\0' ' ' 2>/dev/null < "/proc/$pid/cmdline")"
  done
  detail "Lock file: $LOCK_DIR/amd-client-install.lock. Wait for that run to finish, then retry (the lock frees itself when it exits)."
}
diag_python(){
  if [[ -x "$PYBIN" ]]; then detail "$PYBIN is $("$PYBIN" -V 2>&1 | head -1); 3.4 or newer is required."; else detail "$PYBIN does not exist."; fi
  local other; other="$(ls /usr/bin/python3.* /usr/local/bin/python3* /usr/libexec/platform-python 2>/dev/null | tr '\n' ' ')"
  [[ -z "$other" ]] || detail "Other Pythons on this box (not used; the client runs as #!/usr/bin/python3): $other"
}
diag_python_install(){
  local id ver
  id="$( . /etc/os-release 2>/dev/null; echo "${ID:-?}" )"; ver="$( . /etc/os-release 2>/dev/null; echo "${VERSION_ID:-?}" )"
  detail "OS: $id $ver, package managers: $(for m in dnf yum apt-get zypper; do command -v $m >/dev/null 2>&1 && printf '%s ' $m; done)"
  detail "Proxy settings: http_proxy=${http_proxy:-unset} https_proxy=${https_proxy:-unset}"
  detail "Free space: $(df -hP /usr /var 2>/dev/null | awk 'NR>1 && !seen[$6]++ {printf "%s %s free; ", $6, $4}')"
  local host hosts
  # The hosts the configured repositories use, plus the CentOS archives on CentOS.
  hosts="$(sed -n 's/^[[:space:]]*\(baseurl\|mirrorlist\|metalink\)[[:space:]]*=[[:space:]]*[a-z]*:\/\/\([^/\$]*\).*/\2/p' /etc/yum.repos.d/*.repo 2>/dev/null | sort -u | head -6 | tr '\n' ' ')"
  [[ "$id" != centos ]] || hosts="$hosts vault.centos.org archive.kernel.org mirror.nsc.liu.se"
  for host in ${hosts:-vault.centos.org}; do
    if ! getent hosts "$host" >/dev/null 2>&1; then
      detail "DNS: $host does not resolve (check /etc/resolv.conf)"
    elif command -v curl >/dev/null 2>&1; then
      detail "HTTPS: $host -> $(curl -sS -o /dev/null -w '%{http_code}' --max-time 8 "https://$host/" 2>&1 | tail -1)"
    else
      detail "DNS: $host resolves"
    fi
  done
  detail "The package manager's own error is printed above this report."
  detail "Fix: make a repository with python3 reachable (or install python3 by hand), then rerun this installer."
}
diag_asterisk_process(){
  if command -v systemctl >/dev/null 2>&1; then detail "systemctl is-active asterisk: $(systemctl is-active asterisk 2>&1 | head -1)"; fi
  detail "No process named 'asterisk' is running. Fix: start Asterisk (VICIdial: /usr/share/astguiclient/start_asterisk_boot.pl or 'systemctl start asterisk'), then rerun."
}
diag_user_access(){  # can the Asterisk user reach $DIAG_DIR?
  local dir=$DIAG_DIR
  detail "Permissions along $dir:"
  show_path "$dir"
  if su -s /bin/sh -c "test -r '$dir' && test -x '$dir'" "$AST_USER" 2>/dev/null; then
    detail "User $AST_USER can open $dir."
  else
    detail "User $AST_USER can NOT open $dir: Asterisk runs AGI scripts as this user, so it must be able to read the AGI folder."
  fi
  detail "$PYBIN as $AST_USER: $(su -s /bin/sh -c "cd / && $PYBIN -V" "$AST_USER" 2>&1 | head -1)"
  if command -v getenforce >/dev/null 2>&1; then detail "SELinux: $(getenforce 2>&1)"; fi
}
diag_dialplan(){
  detail "Relevant lines in $EXTCONF:"
  grep -nE "^[[:space:]]*\[$CTX\]|amd-selfhosted|amd_agi_client|self-hosted AMD|^[[:space:]]*exten[[:space:]]*=>[[:space:]]*$EXT[[:space:]]*," "$EXTCONF" 2>/dev/null | head -20 | while IFS= read -r l; do detail "  $l"; done
  detail "The installer only adds its own marked block; it refuses rather than guess around existing routing."
  detail "Options: use another extension (AMD_EXT=...) or context (AMD_CTX=...), or --script-only and add the EAGI line yourself."
}
diag_sounds(){
  detail "Searched $SOUNDS_DIR/$PREROLL.* and $SOUNDS_DIR/*/$PREROLL.*"
  local f similar=""
  for f in "$SOUNDS_DIR"/*silence* "$SOUNDS_DIR"/*/*silence* "$SOUNDS_DIR"/*"${PREROLL##*/}"*; do [[ -f "$f" ]] && similar="$similar ${f#$SOUNDS_DIR/}"; done
  detail "Similar files in $SOUNDS_DIR:${similar:- none}"
  detail "Fix: AST_SOUNDS_DIR=<sounds folder> or AMD_PREROLL_FILE=<sound name without extension>."
}

[[ "$(id -u)" == 0 ]] || DIAG=diag_not_root die "Run as root on the dialer."
for LOG_FILE in /var/log/amd-client-install.log /var/tmp/amd-client-install.log ""; do
  [[ -z "$LOG_FILE" ]] || { [[ ! -L "$LOG_FILE" ]] && ( umask 077; : >> "$LOG_FILE" ); } 2>/dev/null && break
done
_record "=================== $(date '+%F %T %z') run: $SELF ${ARGS_GIVEN}"
STEP="checking the installer files"
[[ -f "$SELF" ]] || DIAG=diag_self die "Run this installer from its file: bash install_amd_client.sh"
# A copy cut short (or converted to Windows line endings) has no end marker:
# say so now, before bash reaches the damaged part and fails with a syntax error.
BUNDLE_MARKER="__AMD_PYLIB_""BUNDLE__"
if ! grep -q "^$BUNDLE_MARKER\$" "$SELF" 2>/dev/null; then
  if grep -q $'\r$' "$SELF" 2>/dev/null; then
    die "The installer file was converted to Windows (CRLF) line endings and cannot run." "Fix: copy the zip to the server as a binary file and unzip it there (do not open/save the .sh in an editor)."
  fi
  die "The installer file is incomplete (truncated while copying): $(wc -c < "$SELF" 2>/dev/null) bytes." "Fix: copy the release zip again (binary mode), unzip it, and rerun."
fi
[[ -f "$SELF_DIR/amd_agi_client.py" ]] || DIAG=diag_client_missing die "amd_agi_client.py must be in the same folder as this installer."
STEP="checking the Asterisk paths"
[[ -f "$EXTCONF" ]] || DIAG=diag_extconf die "Dialplan $EXTCONF not found; set AMD_EXTCONF."
[[ -d "$AGI_DIR" ]] || DIAG=diag_agi_dir die "AGI directory $AGI_DIR not found; set AGI_DIR."
[[ ! -L "$EXTCONF" && ! -L "$AGI_DIR/amd_agi_client.py" && ! -L "$AGI_DIR/amd_pylib" ]] || DIAG=diag_symlink die "Symlink targets require manual review: the installer will not write through a symlink."
command -v asterisk >/dev/null || no_asterisk
command -v flock >/dev/null || die "flock is required to serialize installations." "It is part of util-linux. Fix: yum install util-linux (or dnf/apt-get), then rerun."
LOCK_DIR=/run/lock
[[ -d "$LOCK_DIR" ]] || LOCK_DIR=/var/lock
[[ -d "$LOCK_DIR" ]] || LOCK_DIR=/var/tmp
STEP="taking the install lock $LOCK_DIR/amd-client-install.lock"
{ exec 9>"$LOCK_DIR/amd-client-install.lock"; } 2>/dev/null || die "Cannot create the lock file $LOCK_DIR/amd-client-install.lock." \
  "Folder: $(ls -ld "$LOCK_DIR" 2>&1)" \
  "Fix: mkdir -p /var/tmp && chmod 1777 /var/tmp (or create /run/lock), then rerun."
flock -n 9 || DIAG=diag_lock die "Another AMD client installation is running."
[[ "$PYBIN" =~ ^/[A-Za-z0-9_./-]+$ ]] || die "AMD_PYTHON must be an absolute path without spaces." "Got AMD_PYTHON='$PYBIN'. Fix: unset AMD_PYTHON."
# The client shebang uses /usr/bin/python3; do not silently validate another Python.
[[ "$PYBIN" == /usr/bin/python3 ]] || die "This release's shebang requires /usr/bin/python3." "Got AMD_PYTHON='$PYBIN'. Fix: unset AMD_PYTHON; the installer installs /usr/bin/python3 if it is missing."

python_ok(){ [[ -x "$PYBIN" ]] && "$PYBIN" -c 'import sys; sys.exit(sys.version_info < (3, 4))' 2>/dev/null; }

install_python3(){
  if command -v dnf >/dev/null; then dnf -y install python3
  elif command -v yum >/dev/null; then yum -y install python3
  elif command -v apt-get >/dev/null; then apt-get update && DEBIAN_FRONTEND=noninteractive apt-get -y install python3
  elif command -v zypper >/dev/null; then zypper --non-interactive install python3
  else return 1
  fi
}

# CentOS 7 and 8 are end-of-life and their mirrors are gone; the official
# archive (plus two archive mirrors, tried in order if it refuses) still serves
# the same packages, verified against the CentOS GPG key already on the box.
# The repositories live in a temporary config for this one install only.
VAULTS="https://vault.centos.org https://archive.kernel.org/centos-vault https://mirror.nsc.liu.se/centos-store"
vault_install(){
  local id ver tmp rc=1
  id="$( . /etc/os-release 2>/dev/null; echo "${ID:-}" )"
  ver="$( . /etc/os-release 2>/dev/null; echo "${VERSION_ID:-}" )"
  [[ "$id" == centos && "$(uname -m)" == x86_64 ]] || return 1
  tmp="$(mktemp -d /var/tmp/amd-vault.XXXXXXXX)"
  mkdir "$tmp/repos.d"
  printf '[main]\ncachedir=%s/cache\nreposdir=%s/repos.d\nplugins=0\ngpgcheck=1\n' "$tmp" "$tmp" > "$tmp/yum.conf"
  case "$ver" in
    7*)
      for repo in os updates; do
        printf '[amd-vault-%s]\nname=CentOS 7.9.2009 %s (archive)\ngpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-7\n' "$repo" "$repo" >> "$tmp/yum.conf"
        key=baseurl=  # first URL on the key line (dnf needs it), the rest indented
        for base in $VAULTS; do printf '%s%s/7.9.2009/%s/x86_64/\n' "$key" "$base" "$repo"; key='  '; done >> "$tmp/yum.conf"
      done
      yum -c "$tmp/yum.conf" -y install python3 && rc=0 ;;
    8*)
      for repo in BaseOS AppStream; do
        printf '[amd-vault-%s]\nname=CentOS 8.5.2111 %s (archive)\ngpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-centosofficial\n' "$repo" "$repo" >> "$tmp/yum.conf"
        key=baseurl=  # first URL on the key line (dnf needs it), the rest indented
        for base in $VAULTS; do printf '%s%s/8.5.2111/%s/x86_64/os/\n' "$key" "$base" "$repo"; key='  '; done >> "$tmp/yum.conf"
      done
      dnf -c "$tmp/yum.conf" -y install python3 && rc=0 ;;
  esac
  rm -rf "$tmp"
  return "$rc"
}

STEP="checking $PYBIN"
if ! python_ok; then
  [[ "$CHECK_ONLY" == 0 ]] || DIAG=diag_python die "$PYBIN (Python 3.4+) is missing. Run without --check and the installer will install it."
  log "$PYBIN is missing; installing python3 through the OS package manager."
  STEP="installing python3 with the OS package manager"
  if ! { install_python3 && python_ok; }; then
    [[ "$( . /etc/os-release 2>/dev/null; echo "${ID:-}" )" != centos ]] || log "The configured repositories could not provide python3; trying the official CentOS archives."
    STEP="installing python3 from the CentOS archives"
    { vault_install && python_ok; } \
      || DIAG=diag_python_install die "Could not install python3: no working package repository."
  fi
  PY_INSTALLED=1
fi
log "Python: $("$PYBIN" -V 2>&1) at $PYBIN"

# Effective uid of the running asterisk process, read from /proc (no ps needed).
AST_UID=""
for proc in /proc/[0-9]*; do
  if [[ "$(cat "$proc/comm" 2>/dev/null)" == asterisk ]]; then
    AST_UID="$(awk '/^Uid:/ {print $3; exit}' "$proc/status" 2>/dev/null)" || AST_UID=""
    if [[ -n "$AST_UID" ]]; then break; fi
  fi
done
[[ "$AST_UID" =~ ^[0-9]+$ ]] || DIAG=diag_asterisk_process die "Asterisk is not running; start it and retry."
STEP="looking up the Asterisk user (uid $AST_UID)"
GETENT_STATUS=1
AST_USER="$(getent passwd "$AST_UID" | cut -d: -f1)" || { GETENT_STATUS=$?; AST_USER=""; }
[[ -n "$AST_USER" && "$AST_USER" =~ ^[A-Za-z0-9_.-]+$ ]] || DIE_STATUS=$GETENT_STATUS die "Cannot identify the running Asterisk user (uid $AST_UID)." \
  "No user with uid $AST_UID exists (getent passwd $AST_UID found nothing). The installer tests the libraries as that user, so it needs its name." \
  "Fix: check how Asterisk is started (runuser in /etc/asterisk/asterisk.conf, or -U in its service) and that the user exists."

# Unpack the embedded, checksummed dependencies into $1 and byte-compile them
# for the client's -O shebang. websocket-client 1.8.0 on Python 3.8+, else 0.59.0.
stage_pylib(){
  "$PYBIN" - "$SELF" "$1" "$AMD_PYLIB_SHA256" <<'AMD_UNPACK_PY'
import base64, hashlib, io, os, sys, tarfile
script, dest, expected = sys.argv[1:4]
with open(script, 'rb') as f:
    data = f.read()
marker = b'\n__AMD_PYLIB_' + b'BUNDLE__\n'
at = data.rfind(marker)
if at < 0:
    sys.exit('The installer file is truncated: embedded Python bundle missing. Copy it again.')
try:
    blob = base64.b64decode(b''.join(data[at + len(marker):].split()))
except ValueError:
    blob = b''
if hashlib.sha256(blob).hexdigest() != expected:
    sys.exit('The installer file is damaged: embedded Python bundle checksum mismatch. Copy it again.')
tier = 'ws-1.8.0' if sys.version_info >= (3, 8) else 'ws-0.59.0'
with tarfile.open(fileobj=io.BytesIO(blob), mode='r:gz') as bundle:
    for member in bundle.getmembers():
        top, _, rel = member.name.partition('/')
        if top not in ('common', tier) or not rel or not member.isfile():
            continue
        if rel.startswith('/') or '..' in rel.split('/'):
            sys.exit('Unsafe path in bundle: ' + member.name)
        target = os.path.join(dest, rel)
        if not os.path.isdir(os.path.dirname(target)):
            os.makedirs(os.path.dirname(target))
        with open(target, 'wb') as out:
            out.write(bundle.extractfile(member).read())
AMD_UNPACK_PY
  [[ $? == 0 ]] || return 1
  "$PYBIN" -O -m compileall -q "$1" >/dev/null || return 1
  chmod -R u=rwX,go=rX "$1"
}

# Import exactly what the client imports, as the Asterisk user, from $1 only.
check_pylib(){
  su -s /bin/sh -c "cd / && $PYBIN -O - '$1'" "$AST_USER" <<'AMD_CHECK_PY'
import sys
sys.path.insert(0, sys.argv[1])
from websocket import create_connection, ABNF, WebSocketTimeoutException
from asterisk.agi import AGI
import asterisk, six, websocket
for module in (asterisk, six, websocket):
    assert module.__file__.startswith(sys.argv[1] + '/'), module.__file__
print('websocket-client %s, pyst2 0.5.1, six %s' % (websocket.__version__, six.__version__))
AMD_CHECK_PY
}

STEP="creating a test folder in /var/tmp"
HINT="/var/tmp must exist and be writable by root"
PYLIB_CHECK="$(mktemp -d /var/tmp/amd-pylib-check.XXXXXXXX)"
trap 'rm -rf "$PYLIB_CHECK"' EXIT
chmod 755 "$PYLIB_CHECK"
STEP="unpacking the bundled Python libraries"; HINT=""
diag_unpack(){
  detail "Free space in /var/tmp: $(df -hP /var/tmp 2>/dev/null | awk 'NR>1 {print $4}')"
  detail "If the message above says damaged or truncated: copy the zip again (binary mode, no text conversion) and re-extract."
}
stage_pylib "$PYLIB_CHECK" || DIAG=diag_unpack die "Could not unpack the bundled Python dependencies; nothing installed."
STEP="importing the bundled libraries as the Asterisk user"
DIAG_DIR="$PYLIB_CHECK"
DEPS="$(check_pylib "$PYLIB_CHECK")" || DIAG=diag_user_access die "Bundled dependencies do not import for user $AST_USER with $PYBIN; nothing installed." "The Python error above shows which import failed."
log "Dependencies OK for user $AST_USER: $DEPS"
STEP="checking amd_agi_client.py compiles"
HINT="amd_agi_client.py is damaged or was edited; re-extract it from the release zip"
"$PYBIN" -c 'import sys; compile(open(sys.argv[1], "rb").read(), sys.argv[1], "exec")' "$SELF_DIR/amd_agi_client.py"
HINT=""
if [[ "$SCRIPT_ONLY" == 0 ]]; then
  # Do not fabricate or download a sound asset silently. Use the dialer's asset.
  STEP="asking the running Asterisk for its settings (asterisk -rx 'core show settings')"
  HINT="the asterisk CLI could not talk to the running Asterisk: check that 'asterisk -rx \"core show version\"' works as root (control socket /var/run/asterisk/asterisk.ctl)"
  SETTINGS="$(asterisk -rx 'core show settings')"
  HINT=""
  DATA_DIR="$(printf '%s\n' "$SETTINGS" | sed -n 's/^[[:space:]]*Data directory:[[:space:]]*//p' | head -1)"
  SOUNDS_DIR="${AST_SOUNDS_DIR:-${DATA_DIR:-/var/lib/asterisk}/sounds}"
  STEP="checking the pre-roll sound '$PREROLL'"
  "$PYBIN" - "$SOUNDS_DIR" "$PREROLL" <<'PY' || DIE_STATUS=$? DIAG=diag_sounds die "Pre-roll sound '$PREROLL' not found in $SOUNDS_DIR."
import glob, os, sys
directory, name = sys.argv[1:]
extensions = {'.wav','.WAV','.gsm','.ulaw','.alaw','.sln','.sln16','.g722','.g729'}
paths = glob.glob(os.path.join(directory, name)+'.*') + glob.glob(os.path.join(directory, '*', name)+'.*')
if not any(os.path.isfile(p) and os.path.splitext(p)[1] in extensions for p in paths):
    sys.exit('Required pre-roll sound not found. Set AST_SOUNDS_DIR / AMD_PREROLL_FILE correctly; nothing installed.')
PY
fi
STEP="creating the backup folder in /var/tmp"
BACKUP_DIR="$(mktemp -d /var/tmp/amd-client-backup.XXXXXXXX)"
chmod 700 "$BACKUP_DIR"
mkdir "$BACKUP_DIR/staged"
ARGS=(--source "$SELF_DIR/amd_agi_client.py" --extensions "$EXTCONF" --stage "$BACKUP_DIR/staged"
      --endpoint "$AMD_WS_URL" --extension "$EXT" --context "$CTX" --agi-dir "$AGI_DIR" --preroll "$PREROLL")
[[ "$SCRIPT_ONLY" == 0 ]] || ARGS+=(--script-only)
STEP="validating the settings and the dialplan, and staging the new files"
refused(){
  local kind="" text=""
  if [[ -s "$BACKUP_DIR/refused.txt" ]]; then IFS=$'\t' read -r kind text < "$BACKUP_DIR/refused.txt" || true; fi
  case "$kind" in
    SETTINGS) die "Invalid setting: $text" "Fix: correct or unset that variable and rerun." ;;
    DIALPLAN) DIAG=diag_dialplan die "The installer refused to edit $EXTCONF: $text" ;;
    ENCODING) die "Cannot read a file as UTF-8: $text" "Fix: iconv -f latin1 -t utf-8 <file> > <file>.utf8, check it, move it into place; or remove the non-UTF-8 character." ;;
    CLIENT) die "amd_agi_client.py is not this release's client: $text" "Fix: re-extract amd_agi_client.py from the release zip." ;;
    *) die "Validating and staging the install failed${text:+: $text}." "The Python error above shows the cause." ;;
  esac
}
"$PYBIN" - "${ARGS[@]}" <<'AMD_INSTALL_PY' || DIE_STATUS=$? refused
#!/usr/bin/env python3
"""Validate and stage an install. Python 3.4+; no live configuration writes."""
import argparse
import os
import re
import sys
from urllib.parse import urlsplit

BEGIN = '; --- BEGIN self-hosted AMD (usad2/gru) — managed by install_amd_client.sh, do not edit ---'
END = '; --- END self-hosted AMD ---'


class Refused(ValueError):
    """A reason not to install, with its kind (SETTINGS, DIALPLAN, ENCODING, CLIENT)."""
    def __init__(self, kind, text):
        ValueError.__init__(self, text)
        self.kind = kind


def not_utf8(path):
    """Which line of a file is not UTF-8, for the error report."""
    with open(path, 'rb') as f:
        for number, raw in enumerate(f, 1):
            try:
                raw.decode('utf-8')
            except UnicodeDecodeError as err:
                return '%s line %d is not UTF-8 (byte 0x%02X at column %d): %r' % (
                    path, number, raw[err.start], err.start + 1, raw.rstrip(b'\r\n')[:80])
    return '%s is not valid UTF-8' % path


def validate(endpoint, extension, context, agi_dir, preroll):
    parsed = urlsplit(endpoint)
    if (parsed.scheme not in ('ws', 'wss') or not parsed.hostname or
            parsed.username or parsed.password or parsed.fragment or parsed.query or
            any(c.isspace() for c in endpoint)):
        raise ValueError('AMD_WS_URL must be ws:// or wss:// without credentials/query/fragment, '
                         'e.g. ws://144.76.101.53:2700 (got %r)' % re.sub(r'//[^/@]*@', '//***@', endpoint))
    if not re.match(r'^[0-9]+$', extension):
        raise ValueError('AMD_EXT must contain digits only (got %r)' % extension)
    if not re.match(r'^[A-Za-z0-9_-]+$', context):
        raise ValueError('AMD_CTX must be a simple context name: letters, digits, _ and - (got %r)' % context)
    if context == 'amd-selfhosted':
        raise ValueError('AMD_CTX cannot include itself')
    if not re.match(r'^/[A-Za-z0-9_./-]+$', agi_dir) or '..' in agi_dir.split('/'):
        raise ValueError('AGI_DIR must be an absolute path without spaces or parent traversal (got %r)' % agi_dir)
    if not re.match(r'^[A-Za-z0-9_/-]+$', preroll) or preroll.startswith('/') or '..' in preroll:
        raise ValueError('AMD_PREROLL_FILE must be a relative sound name without an extension, e.g. sip-silence (got %r)' % preroll)


def render_dialplan(original, extension, context, agi_dir, preroll):
    """Replace only our exact managed block; preserve all other lines verbatim."""
    lines = original.splitlines(True)
    starts = [i for i, line in enumerate(lines) if line.rstrip('\r\n') == BEGIN]
    ends = [i for i, line in enumerate(lines) if line.rstrip('\r\n') == END]
    if len(starts) != len(ends) or len(starts) > 1:
        raise ValueError('Malformed/duplicate managed markers; refusing to edit (%d BEGIN at lines %s, %d END at lines %s)'
                         % (len(starts), [i + 1 for i in starts], len(ends), [i + 1 for i in ends]))
    if starts:
        first, last = starts[0], ends[0]
        if last <= first:
            raise ValueError('Managed markers out of order (END at line %d before BEGIN at line %d)' % (last + 1, first + 1))
        block = ''.join(lines[first:last+1])
        old_exts = set(re.findall(r'^exten\s*=>\s*(\d+)\s*,', block, re.M))
        headers = re.findall(r'^\s*\[([^]]+)\]', block, re.M)
        if old_exts != {extension} or headers != ['amd-selfhosted']:
            raise ValueError('Managed block has a different extension/context; review manually (block has extensions %s and contexts %s, '
                             'this run wants %s in [amd-selfhosted])' % (sorted(old_exts), headers, extension))
        outside = ''.join(lines[:first]+lines[last+1:])
    else:
        outside = original
    if re.search(r'^\s*\[amd-selfhosted\]', outside, re.M):
        raise ValueError('Unmanaged amd-selfhosted context exists; use --script-only or review manually')
    if re.search(r'^\s*; --- (?:BEGIN |END )?self-hosted AMD', outside, re.M):
        raise ValueError('Unrecognized legacy managed block; review manually')
    if re.search(r'^[^;\n]*amd_agi_client\.py', outside, re.M):
        raise ValueError('Client is referenced outside our block; use --script-only and update playback manually')
    active = None
    context_count = 0
    include_contexts = []
    for line in outside.splitlines():
        header = re.match(r'^\s*\[([^]]+)\]', line)
        if header:
            active = header.group(1)
            context_count += active == context
        if re.match(r'^\s*include\s*=>\s*amd-selfhosted\s*(?:;.*)?$', line):
            include_contexts.append(active)
        if active == context and re.match(r'^\s*exten\s*=>\s*'+re.escape(extension)+r'\s*,', line):
            raise ValueError('Target extension already exists in parent context: [%s] already has %r' % (context, line.strip()))
    if context_count != 1:
        raise ValueError('Expected exactly one parent context ['+context+'], found %d' % context_count)
    if include_contexts and include_contexts != [context]:
        raise ValueError('Existing includes would change reachability; review manually (include => amd-selfhosted found in contexts %s)'
                         % include_contexts)
    newline = '\r\n' if '\r\n' in original else '\n'
    block_lines = [BEGIN, '[amd-selfhosted]',
        'exten => '+extension+',1,AGI(agi://127.0.0.1:4577/call_log)',
        'exten => '+extension+',n,Answer()',
        'exten => '+extension+',n,Playback('+preroll+')',
        'exten => '+extension+',n,NoOp(AMD pre-roll status: ${PLAYBACKSTATUS})',
        'exten => '+extension+',n,EAGI('+agi_dir+'/amd_agi_client.py)',
        'exten => '+extension+',n,AGI(VD_amd.agi,${EXTEN})',
        'exten => '+extension+',n,AGI(agi-VDAD_ALL_outbound.agi,NORMAL-----LB-----${CONNECTEDLINE(name)})',
        'exten => '+extension+',n,Hangup()', END]
    new_block = newline.join(block_lines)+newline
    if starts:
        # Markers alone do not authorize discarding custom routing inside them.
        # Accept only the published predecessor or this release's exact body.
        existing_body = [line.strip() for line in block.splitlines() if line.strip()]
        legacy_body = [line for line in block_lines
                       if ',n,Playback(' not in line and ',n,NoOp(' not in line]
        if existing_body not in (block_lines, legacy_body):
            diff = [(i + 1, have, want) for i, (have, want) in
                    enumerate(zip(existing_body + [''] * len(block_lines), block_lines + [''] * len(existing_body)))
                    if have != want][:1]
            raise ValueError('Customized managed block; use --script-only or review manually'
                             + (' (block line %d is %r, this release expects %r)' % diff[0] if diff else ''))
        result = ''.join(lines[:first])+new_block+''.join(lines[last+1:])
    else:
        result = original + ('' if original.endswith('\n') else newline) + newline + new_block
    if not include_contexts:
        pattern = r'(^\s*\['+re.escape(context)+r'\][^\r\n]*)(\r?\n|$)'
        result = re.sub(pattern, lambda m: m.group(1)+newline+
                        'include => amd-selfhosted   ; self-hosted AMD (install_amd_client.sh)'+newline,
                        result, count=1, flags=re.M)
    return result


def main():
    p = argparse.ArgumentParser()
    p.add_argument('--source', required=True)
    p.add_argument('--extensions', required=True)
    p.add_argument('--stage', required=True)
    p.add_argument('--endpoint', required=True)
    p.add_argument('--extension', required=True)
    p.add_argument('--context', required=True)
    p.add_argument('--agi-dir', required=True)
    p.add_argument('--preroll', default='sip-silence')
    p.add_argument('--script-only', action='store_true')
    a = p.parse_args()
    try:
        validate(a.endpoint, a.extension, a.context, a.agi_dir, a.preroll)
    except ValueError as err:
        raise Refused('SETTINGS', str(err))
    try:
        with open(a.source, encoding='utf-8') as f:
            source = f.read()
    except UnicodeDecodeError:
        raise Refused('ENCODING', not_utf8(a.source))
    source, n = re.subn(r'^WS_ENDPOINT = .*$',
                        lambda m: 'WS_ENDPOINT = os.environ.get("AMD_WS_URL", '+repr(a.endpoint)+')',
                        source, flags=re.M)
    if n != 1:
        raise Refused('CLIENT', 'Expected exactly one WS_ENDPOINT assignment in %s, found %d' % (a.source, n))
    compile(source, a.source, 'exec')
    try:
        with open(a.extensions, encoding='utf-8', newline='') as f:
            original = f.read()
    except UnicodeDecodeError:
        raise Refused('ENCODING', not_utf8(a.extensions))
    try:
        result = original if a.script_only else render_dialplan(original, a.extension, a.context, a.agi_dir, a.preroll)
    except ValueError as err:
        raise Refused('DIALPLAN', str(err))
    for name, content in [('amd_agi_client.py', source), ('extensions.conf', result)]:
        with open(os.path.join(a.stage, name), 'x', encoding='utf-8', newline='') as f:
            f.write(content)


if __name__ == '__main__':
    try:
        main()
    except ValueError as err:  # a refusal: say why, without a traceback
        with open(os.path.join(os.path.dirname(sys.argv[sys.argv.index('--stage') + 1]), 'refused.txt'), 'w') as f:
            f.write('%s\t%s' % (getattr(err, 'kind', 'OTHER'), err))
        sys.exit(1)
AMD_INSTALL_PY
log "Validated candidate staged at $BACKUP_DIR/staged"
if [[ "$CHECK_ONLY" == 1 ]]; then
  # Report only: a real install would fail its in-place import check and roll back.
  if ! su -s /bin/sh -c "test -x '$AGI_DIR'" "$AST_USER" 2>/dev/null; then
    log "WARNING: user $AST_USER (who runs Asterisk) cannot enter $AGI_DIR; a real install will fail and roll back. Fix: chmod o+x $AGI_DIR"
  fi
  log "CHECK ONLY: no installed client, dependency, dialplan or service was changed."
  exit 0
fi
STEP="backing up the current files to $BACKUP_DIR"
cp -p "$EXTCONF" "$BACKUP_DIR/extensions.conf.before"
HAD_CLIENT=0
if [[ -e "$AGI_DIR/amd_agi_client.py" ]]; then
  cp -p "$AGI_DIR/amd_agi_client.py" "$BACKUP_DIR/amd_agi_client.py.before"
  HAD_CLIENT=1
fi
PYLIB_NEW="$AGI_DIR/.amd_pylib.new.$$"
HAD_PYLIB=0      # 1 once the previous amd_pylib is moved into the backup
PYLIB_SWAPPED=0  # 1 once the new amd_pylib is in place
rollback(){
  local result=$1
  # Inside $(...) or a pipeline do nothing: the parent shell rolls back once.
  [[ "$BASHPID" == "$$" ]] || return 0
  trap - ERR
  set +e
  exec 1>&2  # the failing step may have had stdout silenced; always show the rollback
  report_failure "$@"
  log "Install failed; restoring saved files from $BACKUP_DIR"
  if [[ "$HAD_CLIENT" == 1 ]]; then
    cp -p "$BACKUP_DIR/amd_agi_client.py.before" "$AGI_DIR/amd_agi_client.py"
  elif [[ -f "$AGI_DIR/amd_agi_client.py" ]]; then
    mv "$AGI_DIR/amd_agi_client.py" "$BACKUP_DIR/amd_agi_client.py.failed"
  fi
  # Undo only the steps that ran: an untouched amd_pylib stays where it is.
  rm -rf "$PYLIB_NEW"
  if [[ "$PYLIB_SWAPPED" == 1 ]]; then
    mv "$AGI_DIR/amd_pylib" "$BACKUP_DIR/amd_pylib.failed"
  fi
  if [[ "$HAD_PYLIB" == 1 && ! -e "$AGI_DIR/amd_pylib" ]]; then
    mv "$BACKUP_DIR/amd_pylib.before" "$AGI_DIR/amd_pylib"
  fi
  local reloaded=1
  if [[ "$SCRIPT_ONLY" == 0 ]]; then
    cat "$BACKUP_DIR/extensions.conf.before" > "$EXTCONF"
    asterisk -rx 'dialplan reload' || reloaded=0
  fi
  # Say exactly what the box looks like now.
  if [[ "$HAD_CLIENT" == 1 ]]; then
    if same_file "$BACKUP_DIR/amd_agi_client.py.before" "$AGI_DIR/amd_agi_client.py"; then detail "Restored: previous amd_agi_client.py"; else detail "WARNING: amd_agi_client.py differs from the backup $BACKUP_DIR/amd_agi_client.py.before"; fi
  else
    [[ -e "$AGI_DIR/amd_agi_client.py" ]] && detail "WARNING: $AGI_DIR/amd_agi_client.py still exists" || detail "Restored: no amd_agi_client.py (there was none before)"
  fi
  if [[ "$HAD_PYLIB" == 1 || "$PYLIB_SWAPPED" == 0 ]]; then detail "amd_pylib: as before this run"; else detail "Removed: the new amd_pylib (there was none before)"; fi
  if [[ "$SCRIPT_ONLY" == 0 ]]; then
    if same_file "$BACKUP_DIR/extensions.conf.before" "$EXTCONF"; then detail "Restored: $EXTCONF (identical to before)"; else detail "WARNING: $EXTCONF differs from the backup $BACKUP_DIR/extensions.conf.before"; fi
    if [[ "$reloaded" == 1 ]]; then detail "Dialplan reloaded with the restored file."; else detail "WARNING: 'asterisk -rx \"dialplan reload\"' failed during the rollback: run it by hand once Asterisk answers."; fi
  fi
  context
  [[ -z "$LOG_FILE" ]] || detail "Full log: $LOG_FILE"
  exit "$result"
}
trap 'rollback $? $LINENO "$BASH_COMMAND" "${FUNCNAME[*]:-}"' ERR
# Build the new dependency folder beside the old one, prove it, then swap.
STEP="unpacking the bundled libraries into $PYLIB_NEW"
rm -rf "$PYLIB_NEW"
mkdir -m 0755 "$PYLIB_NEW"
stage_pylib "$PYLIB_NEW"
STEP="importing the new amd_pylib as user $AST_USER"
DIAG_DIR="$AGI_DIR"
FAIL_DIAG=diag_user_access
HINT="user $AST_USER must be able to enter $AGI_DIR (Asterisk runs the client as that user); check: ls -ld $AGI_DIR"
check_pylib "$PYLIB_NEW" >/dev/null
HINT=""
FAIL_DIAG=""
STEP="swapping in the new amd_pylib"
if [[ -d "$AGI_DIR/amd_pylib" ]]; then
  mv "$AGI_DIR/amd_pylib" "$BACKUP_DIR/amd_pylib.before"
  HAD_PYLIB=1
fi
mv "$PYLIB_NEW" "$AGI_DIR/amd_pylib"
PYLIB_SWAPPED=1
STEP="installing $AGI_DIR/amd_agi_client.py"
install -m 0755 "$BACKUP_DIR/staged/amd_agi_client.py" "$AGI_DIR/amd_agi_client.py"
if command -v restorecon >/dev/null; then
  restorecon -R "$AGI_DIR/amd_pylib" "$AGI_DIR/amd_agi_client.py" >/dev/null 2>&1 || true
fi
# Load the installed client the way Asterisk runs it (same user, interpreter
# and -O flag) without starting a call: every import must resolve.
STEP="loading the installed client as user $AST_USER (no call is made)"
HINT="the Python error above names the failing import; user $AST_USER must be able to read $AGI_DIR/amd_agi_client.py and $AGI_DIR/amd_pylib"
su -s /bin/sh -c "cd / && $PYBIN -O -c 'import runpy, sys; runpy.run_path(sys.argv[1], run_name=\"amd_check\")' '$AGI_DIR/amd_agi_client.py'" "$AST_USER"
HINT=""
if [[ "$SCRIPT_ONLY" == 0 ]]; then
  STEP="writing $EXTCONF and reloading the dialplan"
  HINT="'asterisk -rx \"dialplan reload\"' must work as root"
  cat "$BACKUP_DIR/staged/extensions.conf" > "$EXTCONF"
  asterisk -rx 'dialplan reload'
  STEP="checking that Asterisk loaded extension $EXT@$CTX"
  HINT="'asterisk -rx \"dialplan show $EXT@$CTX\"' failed: the Asterisk CLI could not answer"
  DIALPLAN="$(asterisk -rx "dialplan show $EXT@$CTX")"
  HINT=""
  # Show what Asterisk actually loaded before the check fails (output only).
  diag_loaded(){
    detail "Asterisk did not load the new block. 'dialplan show $EXT@$CTX' returned:"
    printf '%s\n' "$DIALPLAN" | head -15 | while IFS= read -r l; do detail "  $l"; done
    detail "Asterisk reads its configuration from: $(asterisk -rx 'core show settings' 2>/dev/null | sed -n 's/^[[:space:]]*Configuration directory:[[:space:]]*//p' | head -1) (the edited file is $EXTCONF)"
    detail "Look for dialplan syntax errors: grep -i 'pbx_config' /var/log/asterisk/messages | tail"
  }
  FAIL_DIAG=diag_loaded
  STEP="checking the loaded dialplan runs amd_agi_client.py at $EXT@$CTX"
  printf '%s\n' "$DIALPLAN" | grep -F 'amd_agi_client.py' >/dev/null
  STEP="checking the loaded dialplan plays $PREROLL before the client"
  printf '%s\n' "$DIALPLAN" | grep -F "Playback($PREROLL)" >/dev/null
  FAIL_DIAG=""
fi
trap - ERR
log "Installed. Backups: $BACKUP_DIR"
log "Dependencies: $AGI_DIR/amd_pylib ($DEPS)"
log "No campaigns were switched. Verify a canary's PLAYBACKSTATUS and AMDSTATUS before routing traffic."
if [[ "$SCRIPT_ONLY" == 1 ]]; then
  log "SCRIPT ONLY: preserve/add Playback($PREROLL) immediately before your existing EAGI call manually."
fi
log "No-audio: MACHINE after 5 seconds of monitoring; server's existing 4-second policy is unchanged."
[[ -z "$LOG_FILE" ]] || log "This run is logged in $LOG_FILE"
exit 0

__AMD_PYLIB_BUNDLE__
H4sIAICivWoC/+y9fX/bNrIwun/zU3Cd25+kVGZsJ2n3+NTd49pO47N+e2ynLzf1o1ISZXMtkVqS
sqPd0+9+5w0gQIKS7Lg93dvknK0pcjAYDAaDATCYGaSTSZq8CPMiyuL89kWvFydx0esF0/mfnurf
Bvz74tUr+gv/qn83vny18afN11uvv3y5tbmF7zdfbr3c+JO/8aff4N8sL8IMSPnTH/Pf2tqaP53n
hb/u7/p5VPjpyI8TEIZROIhyP0yG/jjuZ2EWw68i9cPxOL33p1l6nYWTSZxcYwElPf4oSyeArrhJ
k8DzLm8ixg3gf48GBSAejGdDQJRHd1EWjgXUn6TD2Vjw53mcI6RZh6cruI+LGym17Xnhdezjv3WF
6D4Lp9Mo80dp5sNHBCj6BBBKJXYdiGAY9WfX11BLF1p6G/kDLOMN0mQUX1slEek0zHJstCZI4EYx
0O9NwiS8huorhYif4aDAgtSAAhijMahCmuueB53ieb0e8LrX83f89y2gs9X1W9QcfOBa8UlKt64A
Hniax2lCZVobwetgs+Ut6/9BZfxDFU859FcY/1988fqL6vjf2nr1+tP4/y3+Pfuz/2KWZy/6cfIi
Su5kIHnP/PXn6yDcQ5DZbX9WjNb/gm/g/V082SZFAf+f3++88kdRMtghiG2fJDcIRPi3t2kQwvjb
zudJOoVRt+1f3sS5GhwgxkUYJ7k/miUwPNKEFc5gDCOU1UE8mY4nUVL4u98e+vkgi6dFTsqBdYyP
yL3p/C7zvH/h8OgNYNCAJA9b/jYOjiwPprNiDFgDGF+trucz1E2YJNG45SPU4e4P728F6r/Uw9WL
zc3/KOGB0OhDwfDDaBTOxiWyYYLV4T/4uAkSrb9ECdQziJiYjcD48KGIEhyrrWoRqPt6BiOaikSJ
fj/N4jSLizm939SvM6g8b0nd5dvoH7MoF3JRA+svxXwaaVqh4a1fPO9iGg3iUTwIsQe8dfMfayLo
hDSD3p7n6nEK5CSF+pVFGiS+TsKxR9NAHn/w5fXZjy89b//gze67o8ve5eHxwem7S9BRMNY3fP+Z
v5VHA7+IJ1E6K/xZHg1BOfrCZVKgpXgUN2HhFyGoaYHPNd7zg73T831By3g3EHEWDdJsSPCel0XQ
l8MIoLIoAN03Bb3dzlrt//vT8Hnnp/x5O3jeaXUQ7PauBvTXs69uo/nXP91/3tnBH3fheBZ9/f7/
/pRffU6F/7r9Uxs/DMMi/Bow/dTpPAdsnkcSjTJ88GEQTbEpbf3U2UYhhpklzy3ILEuztlmkAfBd
cpuk90kJjw8NsLvT6QK4ZzgxZTA1wf/UDD2MRyN4ByMQRSfH2f4GRXSa+/cwgMMEOqqAuZ0Lz9E+
oPLDKMviO+hKkgWo7i2VMonhN22DrAaqLw6/ffvurATnp2bgs8OzgxWhz6MchGxF4P1vNPOWUPwu
hyG8Uo8cJiBF8XAPpmHQOm5oX/6VpfgrDk78SyqVv4EuDqfQpLCAvsK5fZbIwPb7UXEfRYm/qwwP
6LtQGU6sWgNCd1hgFw/RIAN0NAUQKnhHOtlAMNQGURblUxigUAY7nPAouEATSw8wsH21ymjn0XjU
9fMCKtkB/RLQE72Asa3ewCO9ApFSr+BRWIT/EAsXhTFLf2ufULXsCN7aR8DGH+HB/ti7ToseaLWb
2RQg3oTjPCoBSNkF/Kctv1hWu1Ka+SgIOqiT+I3PYC5CgntQ81G7tXv+7QXo6M4CmLzI2siPMLu+
6ywCbP2UVBHhXL/j/+uXanOjoscz1127Y/SX+R4hDebf34B69DfLF/hvHCeoZMuOCbIoHOLbdgde
gLC1O1aBeISzhI1E3qPiaWPRjg9y3p+DaG+rCvBPMIxQp7dbYIT8pWWjdfDi4OQ7/+jw5MBirhuW
Kl2Gz+KtkMzUgRXeqrfoWR/m+FsGYaHBcTaswfWBY7fWW5h8uj7OLarh+XQcF+3WdqvzfuMKFgPb
reDvaZy0qx83t686VUyAA/7r7AupAv809RUi+LO7fUq83gPMlaBZJJulUjMlc6Hgs/kRTME2mIRF
WxVbYQyUEv2PWYpDSPQP4Ls2ZJpWxVl6F+NiFVRGHyScCpACZPAumq8wSZJBWrzop+m4/Kh1s/Ar
BiUJCw0wBtuqNBTqmNyTgqiHMgHqLEExGqfhw5DUxlgWFbMsgY5kyXnfWmt1dQPhhyE4ESi/lQsH
NHWoQQmoQNLTLGp1FNayJywlqXoEwGcTaGEWTiK7Y96yBsU1NGtRGUUmxx26+zKbRWWl0JNFjw2Z
qj4DPDShKqMTasrSe8NiQT6C7XMT3kVoXMYRmjmhEFPp9yohFf6FcR7VLJy182gQke0k7WMTSmbT
NYN10YdoMNNSLHN0138OE0JenR7NFndKm6LI5tsODQcKqSf42hW8LgmgQjhHZGRPGfoiIuvVPzwl
swYN+4oMAZOiAIZpkqLCfLnlUJj+N1l6C5bLWTyN/Of+OMJVgn+d1iBNfhpGoMVQfL9mN6Iu2BpZ
yWuLJUsYDkJwAeAgFAJimk2mhKjPO+qppm9LiNZnuf8ZrPU+88seafky9CbhFId71ydKOp0H1AAd
IJ/er29ekVYHVWnzQ2H5nD8uUrP4eu/0+Hj3ZH9b6JXSHZdRJsUWgozGs/zGNEcMSXMakHZXnIPl
QeqCi9CGpW6RPbasrqFl4oZXijqVBqOpxY+wdm+3ULW1OqUZ9SDDx6WQP8LgaeiN84MLXB+zzfNZ
Dv0HfWKbNhNa69LSGMZ+mA1uKrYPUDWpisQw6mqzH8pPgusshXVhxVgQPsJs18ZHQ/WQ4A3JToIl
u40dV/1k7tAaW6weMO9pYR6M4mQIC822qr3jGL3URcoGaRtoDApKDXM4wo2HjNa2uT+bBkGAOh4E
zW+x0mxh9ShFlj1jtIWtph0NX6fJUlHWynPtHVU+o+llOKM5nJU7TEBrDorFBMPqRBhpNUbNpLfr
m8sI0HsBa6yapT7c3J6C6cirxq6fZrLgr5KxWNr2D/cuS2mrGGxMcsc5lfA3w+gwxOT15kbDBFpZ
RmvBaMCzVcEzw/U67rSj1F/9LlcyvMxCqPfbL1lNQzMcnUxtCfAcBBhRX8E8qk2L2vUEbVtCsuqd
lhInnIN43qNPHbdMGJswFTCHJasLmbtprONa7xI2UYcsQDAiZglMQ0DnUCtAa20BS4dBlOe9YXwd
F71xnKt5il6YloJinHxA1iG4TRx/RAZUZ3sp1vFc9pgscQSmJC9M8vsoc5i9ePYjHzv++vrX/kma
lNsdu/TFl61zpDxJCz8co+jM6TCNAWCNUkSBibey8yBGa2v35OL7g3NYnioVdgWr2JLM+xB4BwqD
uSgMlF3fncpmcr0dldJN5aiZBKIRfB8is3ECAl0MdltLyrb8STyGzgExxo0wOmLU3AC4jI1MeLl/
efzGszovAL1IPZPzb/hvCPKkgS71EoN1Maw6FOYRqPQscrIT2KZGsWbq97uHl/6b03N///Dbw8uW
5liFy4b8ERY8MGw1LO4WDJva6sEoOLjJ2jjrA/6Kppc1wXc4WVF7t5steR6IMATDPh/eyqJbmWPw
hjiqbE2srWK048mNEh943AF7rSYuJaACqQ8ANOlzMgGuoZ8TQoY9paUAevk4zQv1E3cOaIzksykd
g0BRY90Fw2US53gIhBYpIgsWyUOEDy94Kl5hcF0cnOz7lwc/oAiY2gDr6TQNORFhPB7LHjrgrLIL
hxsIhi4sK7OcmYiH5KBBhB1V3vI51VyfFEHX9yOLqZPwQzyZTQgCP6MSkBP46YwO/M0hTLbNhnwf
4YZ0FNgdWA7iWkcSr+hYpt57y8bo+cHeweF3B/7e293zxhH6exiiHzcusUPdw7IYDnsTNAZYxvBx
p5WORo6BqUEFKGn9D0PWx+cB0fJiP86Jpsv9fWuUvTB6zBQsx6BTpjEtUdR8l5MIANb1QTjFGlbv
cCTl+HT/oMVtfYQurhntrT2h67PcQZppjYChEIWTHnqoCL/xMQknYNpEORSIeI7Md3Axm4eT6Tjq
AYvzqNjZcGhKA91DEDlmWtojKfUpYuuygxGuQqbjcN4PB7cyzsk9JptNCzC6+vOymD3RwqCO0cKZ
g76waEImhWp7tLW59fLV65ZPUzjaWz4M4rIfEgB/v9nd6r7svuq+vkIwLgiv8ey9tQX/e9miD5P4
AxAE0PjyZbf1qlV2KCwqmQs+cwFpkF1lajevJ8PZMAZVBYoJpCai5nIpjUdK9yNQVRHxBY2srMgN
s0LsCmg8DAlQfFgTmKDRsHlSQdsT6lcCjmWGcQ7jOIlADQ8J+SSa9CMwNBEQ+8fY1xMPBn8yA/6h
/FEnkYPXUK2VlYC4h4rdQTJoXMazBWgau3rzwRpv1tBpXVyeH+we+28Oj3D8NYhsRV47leGsavrd
GVG/loZGh5csHfceqDxu4+kk33m5sbEBgPdDeplF9/R3Gs7yqGZ8fVIGn5TBr6oMWnunJ5fnp0e+
rQdMm1gR1qkrBQOKhbtTKXo/rLwBca+8IcHv/OFVCi2x4kl4XdUkDasxBtVAy9djVODJFmSEDQeV
f0h4kYjcz2/S2XhISES8S+HPg9XW8/GDFvS0kDs83v3WnL0WW5B/fpgFyTsMJo3Ufc6NvvoxPx77
tS2nStwxO/nbyen3J62O2f/hXMaVtRlWn0cc8lAWbSzksi9BN4YiHKwR1cE2DwXaZQ+z8VymCVrJ
aXHCXRyhUWNEz7ZMHSamiakyP7rzl2u+qsp7ApVZF7fdH3nr6KLV0EOdP47GArFLZjjnicTyj1Ul
Voo2Fvq3l1hu2SLBY4hfX2JP3h1/c4B7KU5m/7EkNhxPb0LloaD21FZWs1JapO6hMlvu4T1Ubqtq
8NeU25Iri0SwhPr15Xf36OztbmtBf/2xRHh6A3ZeEQ8eLcUlggcI8pkUgkXnHMl4jFSX5qRLK/9x
pLqyBQMifvb29OTg8nDvk5RrYzgsHVDVicSKtjCXbCqzzLCA0g82KFB0NTa1m4CySg4xkVoY0bJf
NcfPYY3EnprvTg5/8A+m6eDGb/93mPibXX/zP77c8Dc2tun/O7/WnoDbwN295D0AFwf/WEKIh0+P
E0Ip+UghxNJPKYR05PdvJYR4JvpJCLUmXEUQuz47kNHjP2G2XqghFwuoE9cKmlPvZlJpP59Gg1EM
sznUFPl3aTyIJjBJB3hDu2MIeNkrqwr6Qi1r7E8/RtB/nS1YaBRzpebLiZzasTdO6eUDbQjU2wuH
jepU7tE/ziBCh2j0P62d0TQ4YnTRVUKNha3Xr+uDSGN8OK5yEJXbEBd0jlQ53yGXVeU2xR5R1XKV
3VF2wLZ16bcHlygYuy1Hu03aLFnrKldZ5SisJcWr+6PafE75/u7y0zDFrw03dwXPahj+gKfnf+TD
LGwA931VP61w4k3qEkfF6dnl4enJokNv5Xq08I5Xw7naKjUYLuN/2FOvQkWP0LeG6Jfr1KsEVUDG
aC/4rEu+kNsaPsfJjO93z6boJfghJhd+Oksu3fhLKT1J2ZMQv4Ipkot+ANEczgY0NPbTiP2JKMgH
DgYcqSr+hEb0DpgDs/o8nWV+eg96Em96oxNWjodJFKcBvpF9hE57oU8O+or8YCUXxksfD2/ZiVFz
xGKtHqzCXP3bzd4SvASss7jUAL8Nk1WXPiGbdRNWZTQw+eDkggezwRuL2Yo44bX66Wa1BtZgdUar
T7+1MAvDP5bJivxVeIz16xguBu8M2yIt0l6a9LDVtqogW0B3CjvTSHl7AaQEaccUKX0f24pkc+WY
73aM51rBMmTNlbEEl/7bKR9rBXWrryoX1RapOw2xcMRqKIewmU7NaTZ0uzCpJeB1PmnVDLBnrbrN
y0Fmur5ya+yCvEXTnRb+F1cliHkQuUw+k4wqAU3zct3UXlpv3U3iXOLfpCC3ZHXPYJyNyzVtMRkp
E4tNmxyjB+FSEow+tVkdKHNMo8UbZrg1zR7p2O00FGW1Kms+dmSSYXOP4+g2BqsVlr1ECX02FrPM
I6wNcXwlXPgaCUHClHu3EdHH6dONpHnmTcIkLZEF/lfiQsWOVTmhZ2M8HHd9ulcLhojyzeqW3ljl
5n5K9AgeDOmG/uhoSERDpbAibqeyFaFa6STdHD6rNBy79EoeHxmYDXo02tnfi9Cpi+mZulICRlVc
8Mcx2PwmyrJ7c2QNrMIGN0iiyQ9NGK+JyOwlNQqdP6QFQ9nrMC5o2YYLgnGeasYFv9nemcR5WuzH
JeNqkQ+Le8ipIcYDrOuD5t5hu0641GnYVagZnwsNT5fR+WR3XopeOCtSI7oBbZfk7nnaAgWgugLZ
Q/81a0GFugSKAYfltEyUAIzvrxDJ11qSWaWUg3EGPIGx4J+ii+ksA7ygdzCKFMibXH8tJT3BcAH3
0Rj9uNBoYGOgvPa/wUNzoOkr2+KPorCgyZssgiHfCZAzN4yWVD10W2wd7b67PH27e/Ltu7OW8LLk
t8VnwevclxRAA0RDvJVrx6x/OR4bXjesUnmIl+50N6Cs40AkRd7Vd5e5q2YZRe0S2BXaqdsnRcwb
g2BeAZi00b4eTOPffUqgijUVKG9uMA25/5UB+jXHyuRZ6isp9nVQ2x/AaQWDlVXNRKUeaUpY38Ku
l+NTFAq8Ql46yZSlHrLzdPDDAR5nWs0z9ZHQ7HL9tLacGpbA61vLffhKHYENMklRysF41Vm4t0X2
mERPtPydGlaqClSAHHoDBTKSVatAqymxIp4rLwd3j44Ozg/3taeP6bLOqHp4/3SWrzAeKwUMUGoL
BjisyhoNTwJXDakP1oZRqnHJ+RddIWvCWmNPhRKeqfNtQxXulfeUhriGwUk6vAOBRwHRcJtVOJjn
ZjSxRNmdcSF1y4SDGdG/SdPSrnjp7/OM3kaz7x+zGMgBcjscE6cfkfeadcH1lX+EV8HRogQlbp6H
vMa9OBgtZDA5vn+hSxr3Hr/UL/uzfO4UHsd87BzEe6D3Tg7QPXz38t2Fqf4q11V1/B/HoHTAqjHa
QIQVRATsVQkjUh2hYjlU1UVlur8Lsxi7WQ1bWlqQiFSD0hTGnWVVatXB993u+eHuNzWrSywu8xVX
XTmfcBBpU/dtA3XGNq8ZlskcPWy4yuABRYgKrxySJS4cm5aLjvqi7tCR5QfmSDSZFnO14U3rIKzM
3HN+jKx9u4SLLpkz44SsIkskShKCxBaoBxx6EJzdfaPZeOwWNKU4Ufn//7ZHy5ugTbFmnL395t3R
kdHlS3zq7fBljcNLaaiVolitTJtLHH+n8gjWXj/N9fVhWEuG1yCIYzADxzub9ZlewQsk7aAp4KZ7
JV8J8NdqtQ8LmjwFubqLQ0WAqhpDIxfRpBSlrwi7XumTXEoR+uK3N9dfdVbQu98dnH9zelHtHam2
I60wFC0e2fbDPMKAnWq3K5zE43kX4wXVOWPBm5DEFhgtpuGRYai7nAZTAgNE7RfpeLAKmcTGkHNJ
QkrmCMabrJlUGzi0KK6yMWKNu2yb+ntpI+e0ncunx6bKUCM/wbC0QONNlBuGV/SB79+phXk6jLYx
8pRI386m38YgeQqNu3ukOWCer32Wr6GBzW88O7Sm/go/lywjbDcHPMn+ZvfiwIcRWt3eoIoqugD7
6qEn26tcNFexjlt/g/Zgr4zSWUKnn6qXt6XlO5/lJDI7K9waskSsEpxJkbTpPvljFbBCBB+9MqJA
PqK51GGOg+iu6n8JrmeQ2G0KXOUacdOZY8Q5zTBr4GExRwFH/J3hkLbwZtMhRXdecRhW1h1WVTpk
WPCQZa8W0bN3VRG1/X6a5NVtLP6KMlyukjEMyF04YyXBjBpHTqEgCpwyUbNudV8Oo/GDlC7C15Su
1en70Tj62M6u697lndyglPYPjn4XSqns0CExiMM4LtZMVeXj7L4ii6J6Fzq3D2rFKgUWdKbqGDwr
k+QLWAqx8KYXRtOqTixNPf803Xp5fnDw++xa4srH9G+SptOGaGf0ydVTcmx8Y+5ENFtpJ6enZ61K
XN4Hx4qFLs/6cZGFMMqN9EIcppSkAkv67QhHNs7ImBJFxeXvmMQ9o+MzgJ5h6pRyU0lwlV7S0yxC
Q4nybdBX5Hk8iQs89sJj7xZbVvchu4zhhqd/n2a35v3Ca4pM13UHonUGpqtuoGrecHxhz4sxQwAu
QTCVESDv9SZhnPR6IjyYtWkHmy9RCp+Zm82tEdhwuCEFJH0fjQE3CdPfKMr4ZTS4SdJxeh3T1e7L
G4zEjkf75IAQjscYubq1BCstWskhDs1FxV06bsdwDdMIKgFtfY1BD5fhOkNXNrBxsf48xJQLq5XY
YopneQHty/SFdrOwjvWs31geBoY/AfrzWT4FmwoPRtQl6A0DjXEbG4tCyfevuq3Xre4XV24o+Py6
/lGux3LtDd82+COK9Bdf/KUB5sPoNYJgwpdXr5WAlA6srWE0Sddh9XadhUUuNdUY5GypeWZPeXTW
scehsmdvdg+PLgx6jDAplfq6hjNk94vul92/dP+ju9FF74LW89aVq7fRbxNj6SZDgKlS79W2JxrK
RhmuvF2NX7RJWebXkKCulrqW4OvDilVNYRPswLG+SchPOoatOj3QG0mtUZoinf0wM7rmugbS1PAa
ZInoQc1c0jK9tuQaygbVCLIMe7N18Mcib0mBf+oC/1ytQKELFEYBzKVQW+jXme7kSWv/m+92j94d
YKO3ARZQqQisd8tqKFv88TXUbGY3/U6jzKCglAcxNp5I6rUJzhY6ELUNldoyr3XN7y3/myP/X9F/
4gyAi/P/bW1sbmxV8/+9fr35Kf/fb5T/s5qwr+hXUvYdoz8G5kHLohu0Ge7QKA8HEd0v4J0Rcs3A
QXFm5pPKA8874F03lVfO8y5TGChs45epALv+MN32kBLcllvvj9PBLVAj2QiRHkklpwQ1IEK71m8E
s78HXFN7GOcUKUtSOHV9MAGHMaqb1gtQ7S/gZzkEZK5hK9PEF2iT010L/OiqCup4EW3IsUOLdIpm
I/mbSuYtdptT3lSG8V4odsE6BWx1YNJzX+U9xX/r7PcAbyS1FMY9RR1W3aRGVFBWsYLL4kWDDCPj
6w7lu2cCVd5SNxOe4jY4cKFNqfrKhKZAAtPfgWqEwWU1dA5TqQXpRJdccl9A4zcW9xwoGg2KNJsD
JuXKypgk5kjKOZbYVQ7YOIg4Njca4DfpPYkiurrhuToKKaaR8bxv5iqt4IIG43k4bUOHd7gMCuWW
jSIDqHvNdYNw/whLhwkw8z5MyPgPh5j0Q9oeUw/TssK35KSjfJzwMx6ZeyGlomX5kn4E7Ltj4HkC
5tRdhMtawUdn7INwdn1T0LaQnpNonYiEcNZb8hLjvo4LDxkCpbsmOVxR1u40SR/i0EC05PFeroNo
Tfxihjvp7QiDl3f9SNIrREW/4/8d3Qcpk651jscG9qAXJ6MUavQOuTUSkQsT3eHFI1pxV6oVN1J0
8qoi8WgtxkOIrvmEw5DuONF+wd/C9TNE92MUwUKW8voGK6S77KFP3E2acR7dY1BuN9G9fxIPbtJx
niateqbdzWCjZaXJBJB3J/sHbzh971XzhvgzvFaFBIXoYooO8NHYT/uYLRnWwbiXME7TW7AcxF04
oz+gHUHLdHQWwDexCClz2zx+Ye+TxLgoFiV3cZYm2L+B2jXAYO4CyLi3qwv3Fr1vqbrfI/hVtSyR
F4x612OwQl1I+EOrW4W00cF6vz+Lx8CMHNb8CxErOGBzFaWN5aohlZYC6XIc/n/90unUDn5V8xRs
4yWjlkC0uhrWaJn73CJGD8IchCwzaKk4RzRXA7a2q6hnQOPGVtfXAililQ/CBGaovI3h+/EeXINo
XaBzJl68w00T+MQpHWA8y0RPCcJBRNHvkJ2S8KNaLuWUzrUUMx4hBWZziv8Zme9uo/k9rLXpFdIF
lMCUQ5BdOc3DHYpoFH8odxzfX3WlefxfPNctG6q8vwtWUoKLgmV20duoy23BwSEEwWoyiWChHPXo
jWJOJV8DosNtKV3q5OB7Sq7jNafvc5fbPT7g+YXSW3FQQcWJ4Pa+ngkCUwsqttDOWNByJhphhqkD
Vc0Sd/IOxU0lS4rbwjBdutNQOstV6o42d5D/uSprddhK/gr3mIG27GHRfoLOllFvISlSxMRXPXFs
ZqNqx47B7s8RzIZiLu8sPZu05RcKKHEt00aVvcpkedbRZ5bLsKXbMrhpG07y8n7Q63K8in9giBeA
Y8lRMEwHPJ0PI5wq+7RVo/wQlRlUHaRpbg1ZTP5rvcB0yuZvhcd8ieNrAFaYBQlaaorTm/FqOgcS
ebFctyjwWhI32KurbwEn8oI93OO9hEdjwEY86vhvoHaVObnu/I6i17VElbWgi9HAkMldEmhiak3s
+239nbevtVslBWbYIYYEA4o5QY/0JBJ3gxnIdvw13NtQ/1vDEwvM0kiUdbpMDqWoijpYIUjHLt5C
gXomfjogl9AhnwxZiyww3t5i1mbxNdG3d9KRpz2r0OjL/TGQgX3PeU3okgpug3SVfYB3bzJO46zq
Czykg1VpRhFQUet65WWdnHJ7UY/iXlycgAJlSGhY37i2qbSxjGG+rj7mJI9AJitjvICeDKMPnOqL
8JddSVeGdsrIAWkeTMPiJgj7Of6l6x8duv/z15Z1PoHDP9MPt/dKg9ikYxZdmsDanHSyvFWHFvOO
OVox0AXQTIFW/1pNlSfQMQsUwX3u/1TX0lIzr5/LyhcRvKr/mIq5wWfY43DSH4aspECKd5AsGnEB
3cTNomlme2ySyMbXN+MY1xiUJbiME0A36nBWbGPn7bzH/15VbBVdmL7CAMIcbJsr39XWagO7hbJS
ldJCzq9WS+MEr6DUkQk0KvGyalSleCi62PoxvNQwrgCIfMsvsy8yMdjPHduqZMnlORc1fGXuxukM
aMLlMELW8t0pa4QGQr09WBRzYL0e+khGXOce0KqmPwT+nPNuZZLQy5HRi3ljZDnBWWk4m0yp07tq
pOtrdMQja4aOeXZqNJmHNTaoe6pxYkyZqna2lmvCEo9UdUsNGszNSknscVqX5Ybb7CESNRANVnxV
gyVTocTJ66CFKBvQuMwdoxRXwUSo5M1Bq4NJOWvFsI9UV2Ne0B0lm9xFDaN7FfvLxEyEwUxUpjtr
VYaGpkEnZMPyRkU8FRhg9RRuiEdpnnIzA8fcZ7m6xGJNlPQsTbpy2QRiO7BRcCivK3aBkmcS0lgj
tBmirNAqP5WlrGqqOG9bLbHabnbVmr/mP/df2e76wgenUSXakYyJz3UuOOZwx3ijq1ZmhEfuAP30
LuJjazYDdfKiUJJLWbYFGB7XgLk0Ljy2EOJr1LclZdue91mORgL2qRBQ2pQ8DfU0Ra4NIzzw5xzg
b8HY14bsLl054cRqYMsO9OYPYOIveJ0YN/tycy8P2vD28viIrNkyIV8Pszv1ejrwOG2L7WyqfeAd
tse1Oc3mCb+tD9nwOq76upNbQ7nJbO6xyjZPTtF6SjrxXiJKfpSpPVgbmd6gNjdSFTJ4V8El26cj
PffY2OqBAQxs5ZaquZPK26vTSCw2G59piqHngj4+Q3zcW7gTqyIUpbNiOitsFLK9fh2b3YSTqu4m
h6xUOM6bhO0GqTIuaA71lQXcOaz2Hr4jWxD+SGvKTcYFqbJBKaDhj0syhO1avK7d9V2wB0hbpjGa
6bjHmU4i3ga9Ri+k+yw1fJAalYNN0woj8TmS3LHT8ZpiXJvSVa9tE8nkF0tb3td1S8S0ZlBzymwG
Kr/jngIVbu2pj6W7/qtVZiwtkHJ0ixz4nOYXR+OQfm9hza3Kokutuabmmqtl0Vanq0rTSkjdFKvD
hEaz0lquV2Ukmkyt4FbshD3ELbXipkPSyxDB5BavMEzb+Ww0ij/stILiQ0EpALIdg47OciNedAOs
zkbDFKY+qq513+o4IctOa/g+GGOv1D9O8mtJio4DLozlEkBlbqPTJA5MQXmIodUrBX8S7JcZ3uyk
JDzWoSe8Qd9DPCrCO8WwTtbYG4eNt1ToodJHyjySW5P5Wu+UpVRG9UVswCMZmJrlIAa4gdNzuyNK
V/ajypNPmUOXzq3lVhVZZngYZR5iqepodmelZc3vYc7zOzfTfWrVEiJaKrIA3haBLtugnpxNKX4c
zU4SrEM8eYzeRVGS+ZmPAFvcmirKsDyqpEANGIrAxqaCEtXOOgu09/WuG3OgR5aNsFqxUv5qhvKf
xr0AxWn52yV7Bf5n+rlpI2rHrJh5Kush6Qjev9IyYEArQfjTp3//xv+q/j8Ytza+floHoMX+P5tb
G1uvq/4/X758/cn/57f49+zPL2Z59qIfJy+i5E453Dzz7+LJtgRNm8I4L8L+tlf1FWJZqTgLnYUY
1WXXcBcBmFnGTqGk+dSxPeNRgZZyPCUhfzq1ax2OVWi40Mam0VR8i8i96AEuRCX9xtE9/PJkkRUO
SfVPqUXiA6Kq9+wJVr7sVJEHe/Sn3XoRFYNylBk5wxCObSPxT6xiIIZyXFOY/LQxwAb4GrObP6PR
jDsm+D86XogCtqMjclBGGDXla3fnTbPqw9PGeiQVBdhz1EXxOFK1lMjduD1jvYAOT8TOobEmZN/7
IrpO+X6TtFtexeVeKONovf8sv0JzS5UJaB/HWJSYATQERllFlOwZHVhotSXl8YW5hSn1wJO5X4NQ
Ae/V0CNv2HgrOJSYjiGy1VF2avtAb9cwCWJ3MRyGuWizP4h8duxncCfXgrWw2Y7LMOvwQhapkwmf
XZqHkAxLu8ayaczr00P/eoYm032Eu7StgiLwYsAQ2skG69uKnEMV6NxQlShnU0xVqSvhdeF/tqzI
t2NYMxBYx/96x99y2LBCKAG937hSxNYBjWb+pyyJa2YTY9ncvqJrBv9tLsXVrRmSJF5lgOQCqmVL
P4OT5vYG0Cmd1tl23oxBb3Y68KjEzqB3lXJqbaEIpKs9qnJ38NzP8p+K/1Q7qgq0a6GpHJHXauAL
2gtrkRrMos7GMndE0PdkMLZR4heLOl3fx7On9U3ePK3u5yCKoGmMdOor7FpL4EvJHzxDwoO+9y0d
25Jer2/y+yvXpgbfazNGefO2h0pZtnYs/uRSEyA2tZRPW/AxjrQ1h6TLIUJJ3ua2eXBAnYkw241F
rVOLpvvVWlnVG7R2jENHZnPeW1fbQLhpHrF7G3oeqCatGYtVooQUcXnCXB3G8umhI8MtpTiLVEYD
K3f3aDCLaekmlllR0vR9P2xKVRdT89R5AAGUheMEFGqhNymH0YdFOATahCtRTdOpiQeGiRsJwhGE
FSx1kt5FS9sgYFKxDOFD+PXo4asuXD9uKHMg2GI+jmoH9Q1DnF6TKdKuqDw+9tJX4zsrjhj9UR0a
rRawoBxQ7vHD2OwBlFDPrJldTg2pDIPa/o9x0GSqCjUN70C/bNZCEH2H4I5IViZr1QRMOnGHdOIK
KtHWfmoC4JZPSl24tlKYm0foW5RXHew0TtQ5LPNnGsZZvmbvx/IXLRk4MWBjv245REQL49cttkzF
YOJYb/Oxjm2kjtScB49cD9gmNROnKoduAFsWn0Zxok1MzhDN2pMa2DVIWKZVNc7V0JU6R5ZXyyxk
R6ppvRkqTFSPNkAW3vf4JEz7cT/z36ZjSTwNn1Vyi7rZndu+32U5yoURJ+xvVZnp9KLHmOv8pvWo
tbUvu/ThsCoESstp5hBQpetrraWte4tJnQC9Zei7UcWzmpp59nhc9jq0irZ2e/D73fOTw5Nvt+X8
2lydkq2D6zcMEo839MhrKfAv0P0XgZLongD/qmdzTduS1pgmiFPxDijbkXUKy847G57rhMyuoKKy
0Y+n6g7jWKfV/G/SQjy1uR6lq/7T5S+MenCHl5qqjMzRHffJA19/sQwZhx/OICzcp33wQZt0i7E4
HYVoljYb9d7RKO4Dvapw2AzNLRqYiakahudC2AayXROXMJ9spwcR+Ti2r8btT9vif9j9/xE84Znk
Ux4ALN7/33i5sflFZf//5ebGF5/2///39v9rW/0iFpW9/jfwFqPQoGkbD/jimdr597xzjAyMgX8A
C4dIxhAaW+oQNqWA9uyRDtM6EJDOihcwk3u+B3bddJ6R+/HWxuam/93p4d4BLBePjvY8/5v5tv8N
5ksM7+Lc/6ofJf9FeRc314dpsT6Jvn7Ylqw8XqSD26i4QCM98xyXjb1n+rbC7XUPmkW+Ujm8Pvvx
4rL33cE5Zs/BXUnzM4chiXGW7s94mUdMWOuoawYeXyeMc7lOuBFset6zy9P9023/HF39JIo4X2k0
TiAC7+3pxWXXPzs9v8TLBZtbXwYb8H+ba13/FYwlZSJLJ7XNBgacjw97KMoLDm+gto6f+XvocuFL
ujSqmwIAgkWd37DnymuJ78+xpyR1AhDx2uV0tWhJSmfT1SvWJA3sdZKxszW8wXQo9OpevwJZ2SmN
wk4VsfarYJaX4orB0f/1y/a/flkTt6h2ycl6DF50HK0fizQFtLCSNiD/xEdq+8WLf/0CtaLbq1TK
FsU4BjOoFw6H6JQAFo34t3bqhFgdmNOPQLF+FdIuBZZzuqjIFSxXywhbjZpoZTbtUQgqFCs02nlV
zDj8w5xd4Cgr8BgjpsLwYcNeZW/AYfhXcnapEHVQXoZegYjdxJ+pKJG03qiwQfVDNR7VmopHtaZG
DK3t8bTD4srl3hk/tU0B6yo5FIcMZ9E3aXYLLV6KQer/WxRNFaZslhCzOM3P3uX50foeuo9ZWRNz
6Tf808O76FhH55Ph94e3/yZhEl6DZPx29t/rL15vvq7Zf5uf7L/fmf+Hn9/Eo+I+HhY3O6+26yai
SE7VHYQ9XA8x/+worNiI/rGUcTuE6MsIu2eHfHIvWFC9lXFHFDIluo6YMw9wCjGaYZ7bW2ZNL7+Z
FZg9g4IxUpZhKtSpOE2cgxUKEBhykeF9gleRGhXBtovrMzxmH9D8GKIPzD95r49KqozJYlqgB2GV
NIJblS4C044c+KM805Kypk+LIli6jUk2bbpnptXDKds0Nx32n2YAF2q3btK8sByFFQRGH0jarVnO
Ue3A/MyiwnR2pcqz6BpthYwMCLqhRx6YJpBCqECFX60L6aFWt9rHHZzf5XkVTM9LFPSmY5EIS5LB
DWZ1q5B+TakSJAtMFqHgee4svKpeSVtj88DgVzoalfuCVd+iSk+y7dFsPVlOQGphwIFajF5u9Ahy
eAWtQNTurLhZkSRo7jXldUh+XZJWI2flSr36/VUUYk5NTWuIcRQmZeKbqsLwVBprFCi6GIYHW0pW
2HGZ9UZCd7cx0BHfMUHvM4wrBMryBIxwLK7GeyhrPgQGDTjGbVoOEYshqzCK0yiKxrBsiCIV8ggY
PvHI/2TWn8QYzQeEnDz0HrEQT/UTrwjUr+JGdgs8WrHk8QeloM9+fKnfBXgwnasvsLydRQoB6EqC
onuBCuK5vKNcklLtGKxpmEROj/D87qcMlgT6vEnk4DivnDnRhTXFwVhPdhJ6Szl5O06mVGcZi+Rn
+mip7EkQpJC2Q5ha+H6TZjmGNZrAku6meo5Tagv1WLmqhgu/ulcYS1BeufL9zDhxcqPjUxDdFM+K
RCzBcsu1ls7XgZGzbmhHmtLO6wDFbVgXwip6bqBpYT6p6RiwUHgvfUeq1Smvf4T+Twn2lpHA1M4+
+MyfxMMhH72y+2Hgf4+cnEosOiYGBD0Zz/3nKaB47g9nlDEmtLDk/QjDcA01yc/hP8+tKMuURISM
lPX1g5N9f+/0+Hj3ZB/kvkRE9IUFj8l7nZkCWnlAc7Hvn+ItgfuYP4f5bEIJE42kFs9YIkJNFBKr
aMD1NeNkxxuwrPBCH3czuodeBwaiw90fkqjAaYVOJ7WRthm8Cn4wDun8Xb8fFTzNjmlTi5eXaR87
jW9sYo/wLIx9Po6G1xSQwpgHJXA1Rb1SQdbiDM1NGFXRUHuKzaF3PwRgQJasMtBoU+k+jDkneoXb
9K4ltbXM5n6zkWG8FbyHpbQ9S6sRHxvlmvZzVI7XWvpyDFdFndVS8XuskURXR85lYDhBKoecfC2E
NbViETVc+EEh4ElDH+6rUHUVDGV96Pl7HXSxZ6cRklPrVqdLx02Y95i6dkvV5XJyM5vxvqwV7++3
vpVISkP/LQG06kd4rUpXtTRrUD0tq46ZTnWdpHvjWdRa9d7UyhQ7TnmdChvUO7thh3oKMBR/GV6B
lW41qEIZhipKYHwjCW1HJRItbjyW5OMyiPlQOuLULKj9mk6CA1RIKMZtntIc/YkEBuSaPtQUvE+2
r+onhXZwq8argLddig7c/qDdibHFH1SQC+V4tE2OR/VanlFwNG4njEvMSPidzvHDaWMpGOIkVVna
MVCZ7XdlqYq8UDmUzVxBeIeLLxxkc/FOd52rtsz6SVZv3eeswnRT1mhI3Ubzto2k4TZsXVKtUlc7
MDs3BZIo/btcXL8zfL1cHF9WM8fn2HGzuDnChYXyFkfbneMWZqOrmZosTcGXQG44lU9m4yJep0Ek
jh4VG+Vj5ds2mSTOBfy07phrlclq4qae33DvJuJ4uSBxDGsn7ODoDioohckz23OrXk8XvwF3HCn4
zstpA+MN0TFcY+WWyGIYbwt7x3Rlx1hPRTTRdqyjvY+u+v0NB000qkMHyLrrPI7KcnJdOLG6qjEm
gEV+mq6SMvvodQH9ri0JjmsLAoLLu3oVIPaOGApiSCxfNagEcNumqc3aDWcIcS3kpR9Kqi3KKmvd
jsLjlHT5FtTLl8sEBWPJqVbdhdj+qA1D2fvSKfNAHZPyDtXNeK+iPzVuwxphBnVcjrTVFXrdA7R1
mc1l02IA47tQDCIDOkkrBLasZQxuz5QsrfsJihOhotkYpormT7rif1dXLB7GJs94A6QXD1dAQS0v
jeSujycanep2wRL/1KobZg83PsSDUOSPIoXzdogFCowlN2MDFDft+3M55QU2XmcRHaZW6pBdvAgD
E+qtlYD1WMWBtKeOFF2QxiBBInEHtz481Ft0O+djXuCbellHQts2FY/anoytHn0ERPQ3+D/43zrB
othXAqYx3QBprljVdjIHFydF7sRUAtr7KJo0XKsyO9E9GCzTmxTVpHrNo15bMaaGVxsbeTEbjapC
E/1jzHJTdtIRvKi1FwDJF9VETFmSqFjunCt6/NFCfklPbYxdGIlvhoIep+m0Ui3zBmMZ4ObgAnz2
ssJAbmOo3h2yCcUkM/thNIF54DKbRavQUitiDNZhNG4Yq3orVgHrceVIOaafWb1jXDm11FeDEVeE
adGU063UP+X4DeL8IipMEhKwcbGXHRQYehahVOwnCQCq5Kurp24K8U9HdqLiaknQlNwF4YDcvQxx
c6TFNhoA5byFQRxLaa15QNs1Z9E4Cu1ewOAeoshVAjZc5O1gVMPnz2/v60nYrPS/xmZk5SBLgx3i
jiW6ptDmV4iuFTpTMFalw5F0ORGBunWMAFQMg9qXccwj3gjDDXW1QUOpk7hfUHWqhTCjGKXjcXqP
6mKCyaAzwxLk6kH3rHGnrW37a6d8y6SI1hxxQ9bUAg8g36/B0niTV3hrXR9/bcmvq1+Mni/ZS9UZ
ozEIjATfTMG2r+vXX1Sd235ZofvjVuWjtaliLrbrY2IlQ3ENT0B00TVL6Y8w8wBe1YBZCWXGZnLA
uVjbIk+2qmaDkZnkx0Nr0aINBrUjSOgqgWTx1fsS9IrDHa1/tvGXD+U1GTWJyvUYPfSNxf2AxK16
nUSFOjc3ra2NqTLXqSaQb/+16xHyjeiLct8H63Rsb5j37zkgrXsLhb3iKctE+z1Rgq+u3DsW1EAj
HKaKGln3cl/og2/WRrQ5qlutKgvq4PTI+CJaZceH17yTQMAd+6YPBiHSLnFysxsjHs+yWle5ozyR
CSl+blIiAM2eDqN2a1aM/tLqtuLrBNaLrU6nqbQ7SJS/xNfPGmSVc+V2hMWS1I5I0WggqWuuG9a9
RONwy2XskUXeacaJt143OjUFopA8oDFAVmtPO8n6l1E2IRVnR0nlKc+25sioEAOdkxQusBXICdg8
e1MnPqpf3YqRdsXkphDlJCpZwk4G1dfIIHQF7E3C7Jb8PuzvUToepDMKprBhCWs6BQsWg76JMZOj
zlRLBpRdrVvLugjeWlwolV3GMVimzp1bzsYlrUVRCUsxdysg84rVMHKOG88dy3FAph1Fv4zMTRBK
wCJLMQ4MsWzvmNd2tDH0oqX2zHUQhta2fte8i/zM2PJmdLI1pM4pbPuTd0eWbEqrJae5g/+i1WmK
w9FEjri/PwFBClOdpM1VSBqFt/qgXoysRmjrBpbePtz2q2dHfMKyGhr80QxaP2kxDmxHYk0mFNgX
HRZk7Jaba5i2jdIoq62pBlwX5DGlThyxC/oZ5aOQAUwHuuqEvQFHuXwQI5XPtSt6BU9Y0YvkPmpA
Q5TnM3STKvMf06koBXjE3cnycN0837fRSHWVQ0awk1JkD49iH71nhkPHgY+Exo3uWaGwMzUeIUVy
1MTomwYx6w+a5fWIrTCiWaqbVXdDTbksG1fTm6uLmOzkKlZNi7lUh5GX8filsZTzBmRNctGdz5ds
0EO5Gk9zk84IHWMKap0iq0nlhuQiQ/2aRLwOo5xEvJPC7A6auqoldVKSMV5WraBZ9SR6mc2a+6c+
pzaCO3RCQ3NJMrC3JYClHPyiDCg3BZoccozUFDYgsQ6RacotKDJTKXuNx2jLDpbp/vC2Xtos5qMp
6428eeaXqvYN9RC6MgzRrSyiqFTisqGdQKJk+CCtsKiN7ZJEjP9D/c5WilzARr5x+/V5En//aeGw
q5+AG/MV3WuWpra2n0K+nvEuAihStH4iul2DS4rRA7q8hCQ3rVr7qw4dHXX9XDXLkJUabOchzVys
FldToM0c0W64i9khYGShXdDznsy2KyiQh7apwWpvMh4fMgm4J4Dm4/xnMK29UY5xyimz0TzjxWRT
GGfHgUSAXq9Zu8EfpDRtlM3GOhM9QkDv6+MDr3GuXHmBseD8IcDc24Su81A/CAciOopzeUSYa+0G
b6bF7F2VtYspM8JDWb7uEqef7xqosJ2Ny1jxzQ/1SQpn5zOP/PgKgr3HWkKrbFa8ps5J13VB5NkB
yD6fQRutXLrSqS1N8P1IGxwNC+fysFcFkZQtLTQmEm0G5YXtsJuQJzSKH0YWUcSUGz+Myzocch4a
0f6FsPS9sQNVQ6BsBc33xYdR7+k3biLWMJX9O0s+ooff6cJNfRy7OtlE8StwSUKVPSWXzFOuRTs3
GJ0c/ZTToeYCS6IcOBmA6CE9KGZ4CIInt3g7JydXDnZWT0dlFmcKAYQpNnL2u9f6jddc4uPLR6iN
Is7OU6FQwj67VKvtLlIsO/CzdrGMk5/G87eCDYaFeTVkUwkqoQ0A3XLt+15X8As2lFy+ZID6hTYW
FX6nv5gWQFs3XkdF22GgqxnqWlI10K2JWWY6vVCy6TRxzk84e7t9X2U5mhbxaM5hw9BPuHpQXtfo
xtl2w0xj7o4hS/iIqbptumQLproHu7gqtjcczCvvGVhSqM067bdkXMMwHPFcG3HGDlzVBcnVAys7
HS1mMztHKC+tzkrUNZub5C3toqxcbywiztE3irIH2C50wandOsFLSTO0msNCJB0TW+EZiOkw1ll8
tPusXKrh8BC3TRWWoFRKeFHK3vPlMxPDJLHP8h3qmJSroIy1UR+j8y/Wr0qS+U9OHRVVSbqoDuU9
WPVU1I4SR9vuu6vMeI3qxqVqFMquUjQqZofLKTy62/ZWGJnPdNupq6TxFZBRnGEYxVmMl1b5eFv2
ddW8m3N3kuVVy5eppvr2orleIgK+v2reLMUErY0Y6GImlK7xMUnvFWU2ybUMjdqoiZOS7m13EC7+
CnTzyWzDCDUYbjiPKD+5NMekwWlW7LzeePmXioeg86Jt6WpaPSX/mBPy1u4Yh8/c8FOBaqVK21Fy
grvp+SyLiHpWbBwhsUzJmuOpHudbR6AObQkXhm8FXcPDhFxFGx87NmLOIkzSDhCWixa7dZbOcubx
U7O9ofztZLXFf9rya/dN7/Dk4LKrvl6c7v2td3F5frB73Klj0VeZ22XndWrR+c5+fLloNQekMDJs
M0a7aU/SYbTTyu77lFl+NIqQoTsbK6cKakDrbEBlJfmrn/o+qztB0S13VqVNXotoYDb5Kcq3mrlb
NcAXO5BVzdQ6FnNScGFscDOrI8YFJwotxfcOx0bopbpRYPlQOY++S21CXVmfEdVdd5XTQtVlq5LK
NFg6q+WFccBLWYlSI7mfVjWPPtdV6cb4AvtSxNVJFuwbnhBlQWT7jUIbb5F8ZHfV4XHFjRCHEVOV
LKft4pIy05pxKVHKuEDTNUKyZgM0fpt2LamDURXidIOOerhAYjokZVNe0z3lck5WuLKq62Aw+2ax
da2irOZrK2EBB5aMjCoz7O5WW1feM6Vn1FV1M7Ithong2RMPl5RnFEaLsMfAEUJWJB7dHinhszMA
AXGcKvBHIZg41vjQPnfir4Xp4qmK1i9exaHrndBFDl2KyCrQBQe4uCJrEB8b3V8WueLFIw1uXUkw
zinwnIGuXLUWKHSLEW0nymN1a2IV35cp9KdLL7Hn5ZT8RppU0iKOn+GN8F8ewqqlpIoeqhN7RB/K
PQmX1myQCij3MCqXkwnD/Xqmwv4PbtAldGzT+5YgKltxArmUaC5cl+U9Lk9yKrietl0S5MRq106r
ZTftWzN2itokYCcp8aVd2kA+vvlfaGAWcQJBu4lgKuE1xS6uutMsLuY7rc0WvczCXsmGMq1ilSXn
ghZ3YlfsY1XkYUwQkAMklwCI8OrnM2kGQag2mWpK2uH0gN3jb1w9P5tFLaY4ERwghNkIq8jT9meq
HJ0bOrTsMLNz4YdEcqTncDodS8wU+o37I9zdOM9nvXhIv2Bm7IX5PBns0JkgOppn4/kE+hGgR/gK
cQ3Ia48KqFvP+c6/frHlRftny9b9UmnRBZ5UXD5OEhQ/nWWXiqB0gLOwhM6ksgJnFjX6y+3DXX4n
FAa8iaa+9Svl9+EDFbS2RWWbgeTBzS76Kq7jGtSyDpQEucnGL+x3Po9yK6tKKWnuEYefj/Ezd7KG
trjGktng9U7fmFv8bKxFyBYmoUwxK0eckVCDsYC3yiJJZM+7DuV9iWyC0K3baI73Cf5H/rbMdagK
KTdGv5LC3/vuwn97sLtvXGQFeyBByxPWLzjPZHN7haQH2LZqSHl3Htn4P3J7/H1rR54oyijQ0uG4
r5zeotNxeOBr3MoL/6pjJydRVbv4aZFR1l6zzj+GHO9pNekkjMf99EPPMgHkZX3+N5zHZOdRHypL
maUq7ZjhmkwB+UwcFJRP22BxelMTB/+yW3og25TaMXJpo/Yk8k1dS8sH1qX2nYInaY7OcUk9qOZD
exps7kfyVKbM0IJlaUsPFCR2oGNaWmKiLJpbnoQfmMN5WExGVcNgCBNphRFnAIobpwjO3zn08WNM
d8S1f3n85lHz9D7WzTMPPj0tQ8I+xY+KejKjVhkjr6trRIoloMrq2OMYkm9lnuxKaTWtP4Y1i0yC
p1h4KvVHc1+j9lugx/ZoAn1qNbZ8xRZPKdZULSmOa9UlsE+8ZgcSMEocohbG4eMyWg7PVKE6087w
LRmOkeHz/YS0sudMNl+Ja4dnF0aRJ2ZeHH54CDGHuz/8SoRkkc5T1ZXQwLYq8M8JItdJEcjb+zq+
ixIVSniFRS+icIwSKs+DhB6ftGnD/jAaq9Rk4SQeg2GFRtdiVu9/sw8qqUbqG0JApDKuKsDfIv4K
NTx9K4osih7Xkkso+btqDZ6ePLwlYLT8rloxnTlaQXb70qaczZ6qKXrVwVPoXTh+klZaQVXKDemF
GbQbziSrSBYUtXe/FxX8943/TxlS1jeC18FmgOlq1uNklL44Prjc3d+93P1V4/9vfvF641Ul/v+r
jc3Xn+L//xb/jqMixF2l9e/4FuW2vxVseieUPZGEwtMfSDq8ixmsFbP5tr9bj+1fpGX6p7fpJFqf
wlDZ9m+KYppvv3gBK4ibWR9T/73IhtH1dZSz3Hk4wjBs9jksQtHpdZ8+yuv1CM3UbT/7LymECLyj
eBDRfSAh4iIdFfd4Ov0GzN4hba35AuO/8L89eQe/+hlGeAQr4QgzoWRya3Psn83643igwdtH354d
daDUu5Ojw72Dk4sDD3TcfZoNc5U5oAzSEV7HPqhFv4jG0RS+zI0nsO38uzSeerAGK3ADCpiWzL09
VC64iIMW70d3YIFMKb06bzz429v+a3/dP8vA7iC1+OICoyFHVrmD5C7O0oTKQQEKE2y+tICxg5Ih
rBl3Z8OY4gdt65oxYthS2EtoEiqKWSK7ljnADWdo9FmFT6d4CxZ33S6gX6MJkXaBsBG6qlfpgiZe
Z+FkggWO8IQJz222VZc+ABSftoIvHlziyweWePlQ+GDrwSUeXscrq8RlOgVZhg97dodtc99mCSyg
z27QAXnFUpdKnt0F9MAzRRne83DDRLYluWxV5zoz3Po+TDXbFMq9/fXOZvAfAUZmkGxdS/TLzir/
KPNHPEEtVKqheHId5DdxNB7mQZyCCprGL+5YEwX5HXscbYfjQhQgLjMiFXV6m53fS2RYOmClEKTZ
NWNjrbZq3cPJgsr30/uEVjm/RvVFhin0bGXspOIb9Ox0U8A41gcx1W/rdRcJTZPAiyy8fzEhvfoC
PQSL/EWehLfReg522+Am+PuUyGKqLvCLf0FfPA8GCYbXA14NKOKSI9mATjrgIR3EOGwrup2A6hym
A+QHGH44HXoMuO43TEvr/oFrRlr3L+JCZjuo4P7+Pqh8Jv2+7T/Hu8kq0BsmEsO79VH2vEtOD3dg
5z5/fnJ6efD8+TbfDJlK++gE4h49DajEEMP8vckw6k4+SJHKMPBhrkFh5ejlBaZwg8dBOINXh60J
eRLNjFBVf0/7nNMBQ4kftqCRw9SfzKFMXgQe2Lpz8tsCaxB90+jqe3JLvrw2U6gtSOt9ilGrRrMx
PGW3AVWqb7bMcnaVi7yxTMYqSrxqIl50oSy4eUpFVWjnhGLzU3D5m2g85UswsxzDavmjWcanPiP/
EINCBx6W1PDhgBwYpzN0WuOEh3yJZkC58IhdObo04tVxvBV2OPLn6cy/DzkeF24GU/bGSDFNiO36
U+b1MP0ziM7ZLJumuZF0iIfOAJ3NsUrcz6awUPCgvXRzuUisdCXSi5d+sQ6t+NORp6O2k1uDDHi6
YKQ4Kd5cwGVJrpn7u98edv3d48Ouiq9PFyzQqRJI0Bh592SWsc2EfqG5jTkcQ2fEyWA8w6RMw6g/
42QrmIhpHIOM5R5FiPv2MJBETqo3b4Cr/ShKUDpulX8assVvyyjJMWRV8UIKsCp40VEi68UYNYFz
deSly/5E5VcswkFh9ogxmvx2OKIUBZjZDpafYVHgzb28w8w4bCHXbwlRPxOp1Ghm0/UiXcfQXpg6
/gMMjuucy6FnHlJFcjnLKYR4SjWMofHHINATOucEYcFsFbniG14OJJ7NaIgZegojyq9joCbKgwpj
wZPzqwFWkaWzAm+ZdhWC0KejyXwWF5LgheUbv1kiDuSIIOPkjP6QCq/caix5JW27pzv0iisFalhs
Go1X7EAt74rzuEawdKAKwoCR2fkSJQaKgFX8FAfIIYYIG4/r2hmkBgWMvvo//0zj5uefARmmn5nj
IfV2PYUXjqt0LFsf/48/BVtboZDJh0TxngO48QfjbLcSfkbL+qxIJ0AhnpbPgYXegjml8pH8MPUg
pBQioN1kvYAzDJ1HA6+xT5BDKOD8OaerE7joZu0mI2u+jVH9KgnKPAZpq9+dGgRlq61A4TsHpE7P
VYFWecPqJVhb1ArwazDeKI4MzDJ4aTHBMUALH5j1vo9o8uIDrLm/pj/huTgsi1prwC7v559JXMCk
+flnSccxiWAcda1LDlOJ/M4qbXBLV+uwo1USEg9kho6EYP5SFbFSw/VaPsjiaZGrMzW+SndDY0nu
EUdDj52hqCcl3w7GbKQwNFp14nUi8U6FyR8XS/rTMI0w/oYi5D5OhuhZWra6TVOYSpqSoJqiNnQ4
bCCQabTSU61EuSHRgvldUOsqNW6QW0kQWk5GOlWzZF6mixkinP0QLQJMOGTmIO2CjW+4vHPGUBFY
v0wTrmJvMGRc2OlaYbCGY2KdmoKG0SicjQtPr6AVZUiWdDkyjxRZLEF/kui+MmjZfvOwS80s1Jz/
NOesLtDCNzzxpLwwTROODoLxOEVPYqwiDw8UeX5AzTfN2IWaNA22A8wsmLnhCZR9PxyqdNcBsJ6v
7UF7qJcqlGB+I1RTmLWHJoxJBH/mcltcYQQZQF+SwBd1jWaIB2TMKKGIDaRU4izB5Tj7m1MAhCyd
ZjTrULQN/82sQO9x4VfOU4rShozYyCTN0coKlWkaxGcP3RKLvBSfS233/S3McMekGGOH0qVRmbto
KLFX2FiNysAseQw8vonu/ZN4cJOCTZFYBrCeg0XS8RuZhvMIjBZP1YbDlGSLGYyGVIIWMLtn30Rk
L5R+OmRoQTejXWeQ4jBebTriXO7oGfOrV51fcYYBjY4IwWpGeJTKpoXHpREITvMJD5evYdmMt5xh
XYWWthiZuDSZRJzpW5vueerRtYBD/IwWtTZSCY8vkxxdoiXS2jgFwcCMB7NxyFM5O9tjVRirpJy+
cFWS+9dpype7og5UywKjWEP2K21JARW4Cxj/U/Ua15+ztxU08vxgd//4IAAGQ8GxuCsggARh8MI7
eK8ysJjx4MjcTqEZKfynXU6o6CQBPH9OaWCuo6OU7iTj+NcvaOhQd4B25NCsQ8NBOwUOoh0E3M4J
kzV9I7Zdzp2AvdjCtnBOEWuSd1RBuMq8uUyWlUcK2gTNk2tzGOqXB7XqiQBrzlNJ/cR3gWFt4FEY
LRiH+vZByBGzcIbKa6keJXYVLQu9Wq7AgHklv8pYGqij+EIPYhV3d5h+sLtjDDFuxCGVmx03Iad0
gHUjJSjMJHaXEVJ+NA6vKQrwrs9HKSUvJtDiUgvbSQeh2TQXy4LvTiVe09SSDKoyhFnaZb0zaguH
4ZT5DmgkbgyFUpW4DGShYooyjs8oG8KcAFwbzIiTshnWNRhFWNWWBG4LYNfi/VdMYieh4vTopaHL
i2wPh0mXPhkrN5CxnLx7tCtiw2jlzB9vROX4G8FLGKzhhBYdiUpyIckjTdMJ5JM5xjnGPF8tkJgJ
cZ7PojKyHlncAH+S0gICO96IUoETNnc9bY6Fucrkkct2AjMct5hTugMOvwEcljQqoxqXhQr2FAsM
wZ3O9VSuaJQLW8oYRN3Gy2T50jUjWng+6dBSAcBC856WMaTVk/ISHy/v6boJX0SSAUxrUNx4U+1i
ohMNCB02YiZJvELW7sfzi/9zNOyXy3pB6OEZbR5fJ7ykZvQGchriiX2BS11JIlc4OXKkUUm58AhB
eflMrAT7Dn2h4tLSgLwkUw71iqqYUg+oDr8HdWAmAM05DeEBjlUZoyQFKDiS2rMcnTBM0kFMWpcQ
xoW+gyfDk/NgMPW4wESW0IpNLe9V0PRcBVmc+2QZ03ZWGWMdPjE1JWdxZZ6LORST5UAhCnCiHWrj
89imA5bmmMeQVLhP5m46votkBtX9QgMLbGReFMIMqcZXOp2LSUudintXKMBgkH/4oJusVpZtVBUF
JxwcfP55R28n+Go7QUxrXIBj3BaT5yp0EaYqw9u/2NnSBuL0AGYXHA6s1Wh+YvkBPOiom87gXZjf
wtAheBzNplKVSOUwsjWLWJOSZcjMw64yea5sg9vIYi2Xm+BwyCfkc84txRfYTFTn4+gD9raak2RD
gsaRaikv72Oew8koCqvTZjmcqE03ZL9Qy7kPNeuV8cyxC/giKpDD1ZPu4rK6buM2pV76GT77mHUV
uY2RIdAM/Hc+/114/v/924ODo4+vY/H5/8bG5svq+f/LV19ufjr//y3+fX8TRePy8H8z2PAkmDGe
fPRRFnr3COO3wch4GbzqeOdpWqwf5utnYM7AENuGKX0WeZfhNZ4WvVyH6TFaD5P5v/e4+KP8Wzj+
i3TaG+OxblB8KH698b+xuVkZ/69fbX3xafz/Fv/0tvKnofBHHv95/GF9M9j8Mtgwhr94P/3a8//W
xuut6vz/+pP/32/zbw8WMbBGuin89qDjb21sbqxvbWy98r+Jkr+HsG70z6KCFvCed4YLyTyXoy7c
QujDaigLEzDRu2AtR3TEOLhBB5EunWTj6QsVhsWK2lsNed2UjmgHBFZc4j5Ei/JyAWnvutGptN9G
Y3xNORytdaiSYRTiAZ+H37QvkoqDjlu/GSd37spRLNKgPo/jSSw10JYr8gGXEN4Mb1MjnXTzIB7h
34iaNUVfwfymW+4boLMCORCi8yBtLrxIKUoLxvGZxhS906JOjuNT5A3ULyyipcv9jSw5dEtwI3qW
cRQ32WjO064HNf7diP5VZgPTO4b5tkenI2E/vYuoLdzNGENyEMmKGM/qy16VT/lNyOsgObum1OLw
ylPNybDBmO6JghXhNhDtF8h2mSIdN9zfHvgXp28uv989P/APL/yz89PvDvcP9v213Qv4vdb1vz+8
fHv67tIHiPPdk8sf/dM3/u7Jj/7fDk/2u/7BD2fnBxcX/um5d3h8dnR4AO8OT/aO3u0fnnzrfwPl
Tk4v/aPD48NLQHp56mOFgurw4AKRHR+c772Fn7vfHB4dXv7Y9d8cXp4ATu/N6Tm6mO2eXx7uvTva
PffP3p2fnV4cQPX7gPbk8OTNOdRycHxwchlArfDOP/gOfvgXb3ePjqiq3XdA/TnRt3d69uP54bdv
L/23p0f7B/DymwOgbPebowOfqoJG7R3tHh53/f3d491vkbpz/xSwnBOYUAcrLnzlQX278P97l4en
J9iMvdOTy3P42YVWnl/qot8fXhx0/d3zwwtkyJvzU0CP7IQSAHJ4AmSdnBwwFmS1b/UIgODvdxcH
JS37B7tHgOsCW2wCB58MhD/c/P9E7v/L5v+Xm1/W5v8vNr/8NP//b/v/g1B4xs4ASkfp/i/OuVs0
k7ykPEMwk/bJb8WfFcozbPE1gL5YGVMUQH0NoG572DcBVKn/Kh1fy/sAMBc8iYf9Cv7jH+U9/hCn
fHUzgdzpD/1dPO/H1M7b1Fz1+ZH+2e5i73QPamdtbsm2//XOVvBl1//zzkvQFs/5YVM9bAXPVV+s
v4kxg6e6Q7G6KzbIgvJCdjs8k6cz++oh8IvSMRhdyYHbZ/OzQ2eFpsOvgSUnNP1weB29+KucRO+w
p5iTCqTQ9h22aWjlFQMW/l/n8duHEqtwg8kRw3IdOnod88cljaxpGlcv+uO0r1yrVW9oag0B8qlG
z7sAJtIp9MIxLrvrge8f0snTXYzuoTzy50YQXXLkmKQpeSRoj0J9kIE+sP2ouEc3UXwvdSrXlfJo
6joN8XTeU/4mAkinBnQiFOeaQvTKTPw+1FnFF2CCXzoe8CpLDPQBwWMYnPrw+Fe67V5QSwvxqAj5
o51sFY+CL5lLwcvPmSVEjvLUjsVtCw9e5HoLrmnIYTIuyK0LM1OEeTye87JBTj3mGPJRpDTw23Re
om159h3mwS/G+2SGgZjRfYRrDjqed+pyZIgpi9cCgYaGfjO7zhVt5XlvulTi1MEOdg0Wx+NOr4/L
lBmfJeHq4JPt9Xu3/57o+Gf5+c/r11X77+XGp/Of38H5DznjoidW7re/fB18gfezFh7/bJXHP58O
hP7dx/8THf8sP/+p3f9+vfXy0/7vb/IP112fRsGn8Q9G23T+K9WxcPxvbtBmjz3+N169/nT++5v8
e+avfgL0zHvmP+UhEKBTFxOe5BgI8Ikv25McBAE6vobxBEdBgEsfBvkfcRgEeBzHQf5Kx0HYfU98
IlS2atUzISLi6Y6FnvlPdTAEqORoyH+CoyHAVh4O+R9xOASI6sdD/uOPhwCfeUDkf+wBEeArj4i8
tbU1vXFoXQ4qd2nIp5u26My9JQrURg6Xvd6ILi/1evruoYoTyb89T97TFhOuTdQLTF5nveBrX2mm
fudz/YnyKnperxfS1jLUtuOv1VSe/5Vjr/nrNSgm+0lcji1naAFw410e4e13bDzA4GYOJbVT11u0
/25M6ibwzn7cwlBY8zxQKNH2fr9xhakZtuDzy+bPL/HzK+f37a0r/+sdv/2y67/qAMuMpEN8EbXH
mSV38GfX4wSSRXQdZfoD/OYP5NKrX+Nffo8xUuk1Y6F3/TgJs7l6258XkaTnON794eLw/z0QYifh
hzz+Z+SVOYsqVOGdRH7lJq6N1NEtr46DxjYRyZ0c0P72JTx2alRjpBOQTAflOh8Vpp0BgvUtUiPf
9drfw7twzQir9sz/bwkPNL7HCK7knv9yC1AXRirOkhOY4Kq96X/1lf9ys+Ov+5tMoZ3ICVQc3kbS
LvLKwxn5l47axALK3cK/z+a9HB97eF1Kx2Mjp+wf2uwzzpdHjDyX0QiG3TgCaW435CqTUGxCa3Mq
LUDS/qHdqaWPOgXpHMGcdFDPZPwMOLTer2SKWcojd8KrZ/4Xr1bC9cXLCq5hNPZ/UOPkFWMlfcT6
Yhz3A9zaVjoJLz/08HsPg7NEmSnIlU9QLyYPAuVAfA6Hwx5YNZSQtov2jXAbNODusGrwkNu72koP
VPoTfBH0EAupH/irkDN1PQ5Z2cbEMiX2Q6acv3WlR9X9PYmXyTET+Jp8XgDmQlfaU8h7jNczk1Hh
iObYPu/x45UOodc7Cv8534/yQVaRPZY5DCoiQtf1DXJ19h98B02kFDlGOcw8o4oBXhjpU6Ok3Mjd
KZNk4bUOK1sY8LcgkrplPV0pSOnmDpO7FC+U9Ho51hUsylZ7qVN4guj5s2sMuogXoOBHeJfGQ31L
nO0rvlzXn1ewUKJiDTSM+JZ6mgWVsTpWpIMIsNbrGY2ojbzdQmxTx9CjoIX1aIt4PVvHQMSDRo7b
1C47c0kvQqeMYTWQRPc7lDfL6NQZTMltA6lkRww0FrsRrmR5mL8ywrtqNK7qugo/isjU02+lQ/wW
3S9QIgYgNMNoqBKkio4UxlUGn8LSqcgt9p5mFv4wMEnZBZLL4fd3fEHU7qnhTJhqAl7WIpH7a8E1
6a09XKW3efLkHzR7rj5yqZMNXEs6mRur9Zn8FNlWH8zKh3FWn6qwlTj3v1+TErCOgEesCp6vKnCf
AyA+sYahu97wq0x9jEnDh71QDZ78qso4QsNEgQk868stUXX3FM85s5iM3pjHWA0l0nplDzQ9WB84
1lAMaLzxA77Bemj08Xv90z0YdcWPHo9Y88Ix2ZOxt3hcIpQLO/dOE3oAUm1uBlJ0EJSDkMX5j42S
qqp6MxRqgV1ZybhavbxBGqKJq1V6l6oyrX8alVllFCg9NDHGecC6SOuUi/gDehmdhcUN2yBR1RhQ
NsYuXmAMMXDZjRhaaI2k2uiKPwQ4iPgKH9jUuOcgdkfAmPjeLtWrL0yTJ8PB2cuNLcyHPJQLiWyc
BXhSb17UV/4DhI18D/QB/2venBqPMbFhTsta7aWQjgTupW5Q06CFVghbewssngqUDYN3tRP5jGrk
X78YtaGBaXQbbVt1/ecYeQox5UaFqPbUe1R9GsYhq1ad70tSP/fXgjX4ryorIdMNgtBYswhSoPU5
9GE1lXVgv7rr6JI0VTUfDC+z3fVqK8kQS+qqFLNpb9GBCwAnFWCmksvOE1FTWWe0y8poVC+mtLdS
t9SM3eZ+KnulYoD+LZo7TE/OL8n6gD63OVG7rJkoAhDGTKCwBCqav9H5HTNFYzh8eEuecRLvnBPN
SLYBZ1uNxc0DG2nZ16zsxbgxmF+2yJCHOKeYZcmAcj93TTO8sjpntPBfl7lYn3cIUCRGW1uldnG1
VQZ0hS3WGI/znsTtae4BM3nnOeNAz4EuJ6WNaAobqq7m8FQ6iJAqh0HEokj2qVUIj5RizQ3SjBIe
4rCQu/HsPKYLiyJ/GbzCRPMRzgmvXhtbACaB0sibMNd2dEOvkZGJoxuMTEMoERS3lhby47w6Mpk3
5G857LIcKMYiS/SUFg1NYhdQh3JO194laAeOutwcdk4tgb8RW57OsoEsN6g1lAUb1VSY63dGAitK
v24PReyOBj1vjVsACyrjOvoACq46k9kDgMP197StsOO2NtQqwDBKaEAdUuYyY6FiGCT4klQLR+D0
yXpXglVuinDPkynPmZuzW4qEwp0G9TnNft4RtS3+tcEF7XcenuLCxfoRp/hf/abTdZYfxWNoLMGr
jXD8QaEFQZvQhxJGnhbiohySNYT2jwqk+bMBd5xMZwUvzoQ2XquZhGbhfU/D8UMjNgxq7UAHuqyp
zCScLmaTAOCfBhQg/YP7IQKleflffjsrHxcX77vLl0/9BeXTWSH8kfRthAEsYgl30VQ0w2hZS9j/
QQPxQxOqyBjDDpR673RNFo6vaEaiD4ScyjdjH84GLrT64KepZH4zjj70/jFLCyo+jacRMwff4wN/
aihtjrzKKGwogSm99+MBdYb5PEjHYw6YRtWDuqFMlU7wBaiPYLWhYNWziXpBUaZfFS5/rVD8wxMK
yj/jJQNOAPBPM4oeBfXj9i/QSBVI86eJW7a5LDrMlrpgOWgiRlFmJbpHv8/4t7uA5nMv7A8cQmH8
DBBCHTiZx3nqJO9lR8ZPU/eV1U7nWSQ9PZ338NkFN+xPetcJ6yt4xr/wJ8BXTeBJCafA6ZULvjec
TSbzHgfsIejKbxvA2fSvqOX/oVquYF3VoVs6mCTpbRz9Pcy48fgDFRD8wM9B+XkJhpz7Fx8rhfOG
opNxD891CymLL+j3HIwZ/SbQII1ISvF6e3l8dKZ/UfFps6wx8WOM+a4otlrOX1wl6V5VbxKDjYTn
rliEXgXHh8cH31hvECggoCWI6HKLjenQfkWoGGwJrskMxiSGsbTxHddfE84SfAneJE0aUIMZ3ITd
KrSkAjxrthFfWm8IIQG5ECHn315ennE8XixVf0Ndy/FmnTj2vj20C9ReLMNwQasOu4zr3TI8g7N4
cMtmgvE45SdXgX/MohnB/B96cIFk0TQTGcdHJwwHr8xL2o0Yx26tVeonQ1Mt0DvFLRmhCHYpjwvA
esM4HKekm/f1k3wL5Nui4ugEV6LAO3Z1NAbMIlT5IMOJZKjE9EJ+KyFV6Cy4hQhJLkrqWE7q9Flw
ixAWMdlrl/xHFce3C0sVtwQuf1Qp+LmoFIacQwe2nDvS+qlwlC8X9nAyZBzyoHs3GS6hYJxmg5s0
FY1f3O7hmz31pnYCYNBllFxcBfr7Do0e2aM3qo8WVWGUXMj9W1tEi9uPEtJRmogwvtFPgiBNFovj
BHO0X0eY/JuKHfPvb1JLmgyoxc2qSndxa8t3M++WyvssG4Me46kfUKsNC9rzpiOPoAIhJdgeWIQy
wl2ehSgVhELJv5tRLkK28NsCKrO0nxal4VP5KYSZb124PkzG2XRgmED8QiYI/rHIDJLyeWWa++H4
6Pxsr5zoBFE51V2ht+dwqIP868io+myq4kSGvntrAP1ya2274Wz4c7VLVKMSyolp35NHacuV55nn
2DWc4p6kPAfKHTD2EBAfmNKRwN6GZicC9z603oALzNMnLrHGIoB797qWjofuVnwkadARuPbKau88
j88Ad+xNvJrUrXU8N130VRG21jFO4Om4jU/e4FPPHHKP2SWkwxx1ZmkPYDwf9KwKVt8npBXBObnp
yOBYrhTM7Q1YFRSPL87E/iP/mLLjxxQGGFhIZeH1Iwv/PY2TRxY14R9aNkd2P7LsLPmYmmfJo+vW
W2daq69erDcdz/KHl50lj6xUCn5ctb0i7ZGz8gIM+NsgslqwuSOiBM9JHk4bdR+sgrL5I8sWerA8
tOTMmnkfVJQ8yh7RETloXBzeE5m8HyzxiCCJinE6eHRxgAgn+aOLm3318NIZunbGd0uH+5U9zS+c
ROw5f+EM57ACyll6YUn3vL2QLq9hbl4yBy8xiztdp+uWr4yQqg1tvlX8XWoOkHn8ZOYAG9uWOUCv
VjcH3p0fHdgW/NZCY94oihs4jy27l2IAo+IyTS9u1GGyc9RrLG65dbd2Nbmlso+SWyq5UG7ddD1U
bkVYmuTWZvEyudULNReKpXIriYueTHIFny278nJ16YVy6TRK3AKoqmg8+qW0fj1EEGWPQoHHPcOP
QYDn/9i5WwDuFP8l5QFqS+F4TPnrqJhm6Ye4wXJZUvpcPj+m5afEtH1Kk5c+jnmof/Y5Hxzpj7ec
8+TRuM4jztr3sXj42OeMz9Ef2TYo/WH+MYTQXv9HNuQMFAImrj++fhIc38fFjfTXeRSOJ4/CudvP
iywcFN9gRhUM7PexjXwSRNRdT4JJtW8/xiPnp2jg02CiFj4dUR9b/uJjEOCG8keV/zj698LBTfSR
ON4l5D/7sWwkvflxmgqgsgh+RXfRI2cwyjQ2mz6mNE5ec1hBoyffo8rT8oKOvsfxI2cyxnEb/eNu
NRxXnsNR4T3euGZnhc1Xsje6zCoKog8YBLStrb/39sXVuqVftVSaG9mE5E2YDOYPxsQOzx2nBd/U
utVseJ2H9RFWvJRdaMc3UfdQS16bz422fEMHNFnzWWl7udGsYNHn0zR5wr1phbBq0/Pb1Y16YKfy
I3EIl9TRMBihLCWpxJRcj0WA4/Fjyjbb8mXxq4ax0MCrVQcDF3/kaODCS4ZDA4EPHw9K+BYMCJvb
y0eEwNeHhEK0fEyUZ4RPNyyMc0d7ZJQfVh8c51gIDZizhx13NgjcAhJWlLkSw+PEriy/WPIWUPpg
4TN7uVn+6ufFS0XQ7olmdMsEsfH6NEjQHt2ToISGtqTRHZh8Gg5UrJwojyb9seS1VPdXSqiVryHw
XQmMQ7NjHtYaN0ZcO6QSjQQtzBXLqb0ovupB89iKJctZTyI40IBfubDWD1S67KhVEdhdu+SmuVxi
ed+iEq2u36J244M0gx+ZKHou8beuHijs7aUOFUuEmoQVm8N13fEJuB12JEwwetKE8n1qoVTi5XQZ
QBDRFIRO6qAoFjy7VOKPnNMXroYiq9Qrsi7pqUgXVq3lRbkl4S1q9/1QkXFt2KuDotd7/+DrinZl
7bUk5by/iLfrf5at+Z/51OpuB/lhXpbv4W21Ht5cwIBRPXrq9daMbyhk/A2f8Bt/JEg0iTB7NH2X
H7o4Q+D1LP4MT/a3Ie/Z5Pxd/bJhrsdpPxwLiPxAiPIKod2EeEKPrhbAJ3xsaoD529UC/aOpCdaL
hjaYv3HK1vIQDu/Qn6WHdwYwNhhd1/9QeNL9mPnC6H8eNnaJdlzUlUFcBIim3fHwDyCtljJpwASz
eBEEwNTjgvoVCF6ar1ccJvM2djpuhPfW0DS4pbzoSsrpkvct34hPKCIW4YHvkyzlK3GmnKq7i7Ok
j8Haeyr4UFte1AmQD9zZcgWQy8oFzR2Jw3VMP3EurF0ZVLVxCYmNNBjn9drwExc/LDuQjTdDVB/d
ikDEukahgz5nd1SbWsLSf8q4Jp2PYEJDJRztA0t4ZUw0zSdH8C+snKTWEfXLqKqtQoIgrJoOvUZJ
1iGuXD1gzFig9b+NCg5YqXJRYzBOuo8t4c7mqmM0CJRCmaWpnBigUaMgSMA/CkEBIHT5U6utjllK
lFVzCW4lllAVGErMWcxUbNWSrNsWFAOAShlD5TWXU0CVsqUmbC4qMC4NgErrNprnbYwc8fz23qXv
AM8wICCCMOQZv5EXyPLyAubCEJNf3zIEDOUqj1t5y8szlFn+Lo7usVkm71hmKC84TPv4dc2A5kY0
w/N3swRR3VyAPgO8rdCWdwqxIyv75GFdwqXNHnlQh3Bxoz8e1B1c2uiNVTtDQTyoQzTMAzpFg2AZ
reMUw2GxeK4mZF/bFjrbDbWBFNuQoxBj5hz0UDXxMElLMEnbluEiSk1luwhnG8hTAcJgnRhny/FT
Tz0M/3sm/WpBFXVN1G875r88YJe69hp6TCXrm+aibeYsQS8w3OcNGgzwX3ZxlsBCRTYbFCrO6Bb6
83EIUHgbXNCf9trX36x1AlxQe2o5YRTDIltQ1hQf7AJRuBviUZ0Mow/kLWjCAQyCMgRAKwB8NqmM
U/qlriQjRBqoX/TpGyypvsgPTa0U72GYsqzYg0m1OPjHLByjtVx9t2aGPrVOOTav/K92/E3D95vL
nlNkifPoOvpQIjReTtdqJSqwBHUcFoObKK8Bn6RVePXGLmIHPFmRtpVIewBJaxXF3W+WyGf+92l2
G2Zs4mAU7SJMhuEY80T1QdZyMOFulsi2BLFt50EWTcfhIGpnrZ9+anV9/AMPHfJWJZhelA/Cqdon
0cOBH6ryj6/KNoiAt/sOCtJsCO/fb1yZOl/Lers/G3X9uKHYbPQ+vurUhF/f8Ue/PIwp3taXvPHO
6LSLpTvm8LBGgjFIykGhXtqDZsGAoE0HY0A8TNZXlvMHyLjWwf0u2s/YNn9MCndMhrH+PqPveJHP
+i4bQZUWS3iV52F2nfMEjU/SYZVIbwxaY1qnXS1t1WVw59GVGTiW1fZx9axQg+qZR1eiEDjrMSdB
ioJjRPzkPSwVtABvEgOAOf9lEW1WtYupTOldv+hXQ47VtsegSo4t2hhtUIUeLaZGgCmzKCwQ0fEl
Qr2F0ds5gFfRd0STpt00LoQhmspy7aLf8RpAy7B1cYLRjGy8ijwdwEg3ta8jMNtqmTjb5u0y6Bdc
DuU9CZnZG6cD+WGHbDqAQrNCctthFoRyNz4wYzLFI4XRzdFRJnH+YILFfWn63d60G68w7DB4MFJr
tir/mdzmvpPvJR74XUWDNgJ9NqKHLUGt0Qqhxl5qNGgDO/CvzxymQysGU+xljaSFHAusJMCW8LKA
WLCeU0hKORBN2OTE8TU6cXS2HYRhVRRyry11Ufg9tpsbSWPBpB3vEtxNoiXDRKUtsSsQUB0znjeF
ua5YqEEIYo33jzrIFili9TnWz+/bbm0nAwQzjCTR/XpezMcRlyi3d9DC0fE0X1E8za3gtTVwRlMg
lREH03RKoajwRBi7Ki+G6aywAuUBuFM0WffaW12YjCJqY7bjTj2CbVqYtx0RqGskIXCExEcQXiUw
ykp0wUOOaofUYxg5XBjRogUzGvBTpCw3jjMaF0GVqLZB0QgkHJF1kGvOY58a+YK+ucRoGiialLqu
aDw9oHFLOjeECMlZ47dachxReaXcwpi8Gvca5+hZa2I1/lErP4P0rmCwCQAAo7/1p/swwU3JWDbk
3mCgMiOQXlX44E2teag3oqnJsJo0GV0BoGVP1BlQoecym9mzF+nginASytyKHG4PfdwTliMqpFTl
hEVSMVNPKMk21oxAkcmw0vKIQhfUWo6AK7YcQJ+65YRyxZYjpSu0HCrhZrsO/Ax0cQIKNR7iTg56
Q/tQZMbRhTF5E6q5dsdGi7SbjawYAEhOdk02RK12x/Xr7HoRM1dhqPrXz6Lw1iS0mUhQ5JQ6WGdK
aa/9lKzZA439FQwIf21RANISJaJyYgIMjsFWFzcerlTKIaJ1eBZyIcAKghx3VV9ECfRqFhbE8bw+
T8QOQSY1A8TYfOHXgMVQPvQKyOgs8SB9qRxIef7ckZnXW30mNqdR0NkLp9HReJbfVGddfAfwpCBL
UCaovmYxZ2TChlP7aIGSBPVMgG1zM1Usvy67C/AQxHmTjkYlA0rHbbhtlMxT3reSmINCCUcfwkEx
ntOUTAFMKa03/tpG42T75+n85Xa55zCbDvFE7j4Lp9Mo+1nQaTOGUJY5rHQUcE6f8jLY4rDiUcGO
Oz//3BNUw17vZ4VNez8hpp9/VnX9LKeZEuOc6kpahV9yg/xxgAeYWS8dCTasx3C7Qs0EJHGmtp9/
hjVnfA2/ADui/flnbiD9ziKf0r2hN1wi2BQ5Q01OUDrF2Mxpy9+uL0WafFJ8X1GxUzL6+/Pds7OD
897uxcXhtyeYUO2iubwQ7Sj+7mx/9/LgohLaXPnKqXptCawtgV35NVSbKvk1VsyvQiekKfREUpvb
XGkGcqvSrCFxh9ky4YiN6tqFpiMy3Xa2rOv/65eOqaeoZGCILfBEnqu7eAIsDu+WbBhJPZrGVj29
B37IDfIeJTQPERXDs8Decay0Rkv4zlJJr4u8euhq0uQvc50a7WSX9cXcwqAPdVDZpqJtFcymQE4A
bXwCfU0LmtIlSzsi4ntxF6C1SOjronpxJuo04/DUKttRivso03GYUMKqbdJDfbxG5cfDKET9D+bR
JLzFWijYo+DS+Eme0TyjTNOUPFScVSSbpGTlJHdI2t7OMfUDnt7r6N6i/gYY5dqg3HCCKDlRGL6Y
pZ8fZuzotQfjXCVVwQjjFAwR3gzrZoB744CjdH7psM+EeSoLIMyhWYrRbYcYhdx//cWGaqHJXAcW
YneRhf4A9Xb7HnX3BJhN0xlNdnhwMPc5kOlQO5sEjoxuFCx+yI3UTjrymt+2WV5cpmmluMzz9MNt
nQ7ft3q9NIuvuUSv17pSaf5WUI01ausFVVx66Om2TudlFMJ+LLv9v4gzfMJbkYUpyFmI7nVueXD7
yWC1gVmWixkMNBxqAiVwWiy7fquI8BwDUxDSm1bXb3dIL5vem9aApidjNJOkD6NBysevOLDItUgy
7i4e3kr14pRuOx1Rp92FtESHL9qzLMDQsmZWtXHKzioKngxP6HX6AB1uL6EJetVFNAI3rfxUve/p
4aq2yuLqgSBy7scfjlQ6mma0fnWJjucGaCketKpL5BrcPSy2smjkAIUmqvwCJGgAjCcp7OzbqjRU
431vg13pTilfeg7ZZKlhSIbqSjkZjt2yCkte1fTOQhgl5HnKuTLbeVfvae20ZsVo/S8ttRmz0+LN
nJYhn2mE2QSeP8+fP1eOxkbSTUnz8MbYIlQsWPd/ltXlz/7617J79v+x9+5vbVzXwnB/nuf7I6bK
kyIlQuZuh4ScgzGOOSXAAZzL4/KqgzTA1EKjzkhg2tP//Vu3fZ09I2G7OW/7ghOQZvZ9r732ui/K
/PBn6OXPphR+wxL82G9vfbta0m6LdI9Wa/yd2rNeqQPjQWjXTiBap+6t1NHJSBuMHMJyroqAAs8R
XMUYFhqTCGIa06UvyyW0SWYjvk7H3USUXH7cDpZf6bX/39k1rwGzUYj9Kp0YCuYY2Mjb7G9Cq7zG
HJeK+svZVIWjXFJimJ7aMlk+RFbQZv3WYipf4to+0xaTBAwTAFcbbYa1Hi9DU7O+SBFuGz1Qt/mK
YuGRMOeslAOAUzI9/QQIRAyiR704JOovAcDSr/55YPhIxLHAZi4OcAEjmU9AJJwTu7+mhId9kz+t
/d4lTiS/28CjUYjqhaayMeVaVe30CeT7iKLgM1NpZTyj5G1af0RNvrWfrSuBCYL3DYxeZYVDP40J
WYm4accVOYTSj5EodfE+7MqY4JU7CAuaaXHQvoKywk0mJF3KnMnljFIMM2KBACALJwPYknS0xEfT
N+MPSad/QsGAbNp/NuwFYLMxUecpjTMDwGw1s64tGPqXJVQYJLMytcVQsi4y2HanB2DR3Jaah0rB
4z83e76jn1HjlZK8ETvxKLm9HCaURGhbJT/SrcCQBKkKNnEwEDVFedr3coztOk0l/TFGFNXplSQ1
uzBtrOoHnowFhihFzq8kBRVnq0JUNMG8VLOJeiQOptQIkf1WceD+cju9VcV9T9hAtghDBhFzFyKY
4eeNzVWqQZWpknYQw+xMnNgqXt/aiv/zNKUgtcNdEj7gzFB2KjYEsFAkGO5TwjpMeFGlxtW7nk60
2C/TpBjckAEB5Z/Qg5axxf+JRxKBZPhTUmTkEfBFLM5fcCrhtALaDiR6RPo+G5PrY/oQM+BNihzq
35Y92YlkDG3dIEE6Jh4CGiKRBPvwsleZSWFGSwatjSW7Wzrsxe0zAIQJyUsIpqMveGuIUchvUyia
lLD5WkKPA6X9kZzgrC3QGacclYFT3skL/yYt0qVS9zACrhIzSKZluR3vjnlZWgqJtxi+Ul4ohpnb
7PpmajUIZ/kK5sS8HZkP4hpBLzBAQF/3dOjhvNLxNddDB2F1cJMO3uNMrPZ0d5V9sbbF2j/VImDQ
0YgS0kd2Zj00cUrZrVCtFKHaYXZ1BYMcT22sqLTddLuo8h2NMihaciivVyuo2Na+lZxJ0xyPTtUh
0Nmwd5nLOxo9GZnPmk0HmHnNphtd5MppZex0pYRRvHWMMZ5BL3I67BEgD9vaHbQT/e63/rkvl1d6
m9/0Vp7dp5ecKuGZSljamzx8lj5W4GdrY4P+wo//d/X587XfrW6ubT5fX1tdw+er62tbz38Xr/wW
CzADOC5gKL/7f/MHKRK980DE/pxecoKMmAOlx6PsEoVSlulOFO1heiFESHF7rxOvrayuxG+yIn+f
xcc3gBWy9igrMuWFxmk9pRXEtAVcUWV+Nb1PivTb+CGfIaoCrDjMSqURy4iqeiYYClBgdvWAD5kC
xPMFp+W2VHjyh6O38WGKdpXxDxjVBvDryexylA2o+mE2SNGXHP3h8Wl5A5jpknWBr3EwZzIYIPeh
A7rWvo3TDHEdO4eI1Hatt6p6lDZRaBK3gTCAWRRxTkrKDinmRgkiA6nZC6+EmTCp6bDdm3wivv8w
W0KtgOgBh1/NRqxtgNLxzwfnb47fnse7R7/GP++enu4enf/6LeFXdJ/DdI8KJRGtB1MrkvFUKwt/
3D/dewN1dl8eHB6c/4pTeH1wfrR/dha/Pj4FIv1k9/T8YO/t4e5pfPL29OT4bL8Xx2dpqtaaVzW0
3nqtEVpu4SYC1DlNspFKz/wrbLZkW8YrAzZ9kGZ4dScxChMfuZ+Y1Yuvlam1st+K7UWX1e0KITs7
Lcyd2u1ufDAe9LoxUC+vYanej2A3zqZQARp5nV1BB69HOUYafZmXUyz+424cr6ytrq4sr66vrAIX
crYbocFeRCRIr59cjq8U4v9KP5xM1DN9ynYnE/V6gMvl19Gq77LyapRfX5PhlvdcjrJ+DMSi0lQg
sdhidN+KGvA/Dv9zIf+5+H99fW1zy8P/8PkJ//9m+D/Sv55ugqeb4Okm+Cw3geBfXPEH9SUvI9fj
UH/NPkQLoPzZFBZQPSVzRIobML16wSU4R5l1KRzCAbbiTjDL3NO+JZb3FPCwk4eAdJCeK5N0MXmx
0kdzQaeQ6Y6MoO/LZDBA/gnY8TsAAIoWcE+gjML2CSaBioGBJW6YjQXK92zqG1mGlNSFZd6D05Wm
ex/ygirJVH7Jix/ha1pw+h5P1Y8l2/3bbtwfhjW5XnUo2+lJSt021KldhC/sqeKQ9XSJHS/S0QNa
erGczpM1lZZ5VXiAJHdA3EB5VtujdIyD8WbQHwIPG/8fTJrzLou/jDcuIkfl6u+9Nev+sDfN2V2v
yXrTLs2mtGjAByQGhR/RMc+Wdl8evcbAR2L9lM8ot8MtBUOiD/3LGUoClhiXLZ2d756/PesfHZ/+
uHvoPfzh+ODoh/7uz7u/ei9OTo/Pj/eOD/v7p6fHp97Lt0dnb09Ojk/P91/1X+2e7/bPfz3Z98ro
Xs/7uz/tHhzuvjz0i8BEaEz9vUPAfq+8twdHP+0eHrzqn+z+eni86789OT482Pu1/9PB8eHu+cHx
kff6R8Czuz/s98+Pj/svD36oaXr/l/P9o7Nq7bdH+7+c7O/h9PaOj14dBDp4ufuq/8Pu+X515c4P
z/qA+F+dvdn9475evguUi2L8CsQg7KAExNF0xiJQgFFnl2CzV4F8iyq7xC9Wo+Au8cu1qGmXuMx6
1LBLXGQzCu8Sv92KwrvEb59HNbvEr19E4V3it99EdbtE71dXooZd4iJ6faxd4jcbUf0ucYnNKOJu
abqyQPCKA8k6u9S1H5k9ch67O+S8Cu6PU8JbXLdhb2mdl97CBhvVy+oNqrqoTgFrSbuRCdWHSMlE
wXEUU/BGIN6SSyKhg5GFt589E8fjdHrVy4vrZ5iK91lxNdhcW9/gqFLj4ZyiWxubm1+UnLR5ebO3
pvuXy4PDASBxSfoGjpXA4zg+2Tt+tY9zPYdNXvmwYj89hzWip6v205cHR7unv9LzNacNBBh6/MJ+
fAJwQU+/cZ4ey9NEDdLc4KHhxtMZ3remBYJJa/Rde9Bdd6xdZ4gV00proF17fB2zfjSQm9ktsRDJ
kIbJd5Q9qR93T2BUf4+8hnF425gwGj3h/Jc4XHjJaVL9lzx8eM1q3GoBmhC2jWFtq69xStuYCHd8
HXh5zC+BvmVI/YeaL/lEARlwTURvkQIxPRoyvBzuH/1w/qb/nPbueWo/W91CDBJ/9128umU/31pX
z7fW7fiHLAgW1+WrbLyz0o2L8m5V/q7J33X4W9UC8pbsOHuO1M3OapeGv9Nqub6D+vMepllFClnM
2PB89uKTUUp2qqS+OH29p3xo2A+nF2yJ1IMwcDSUzcbuY5wIPMc/lRdr/GKt8mKdX6y7LwT6dmTO
7ksiTndo6jY5RjsYdFQRfzd/GpYbnPuCwlpB6/33KZLhOUZ+BIyU35qtVNyCbGX5PpsQ49CXF3CS
d9jXI7wjP0l94qAMuuwZAvMEc2elqMjTj5b1jxlvoONtehrj09g8De8n+QOpvUOdnd4v68t6SFuu
5RknRT7NB/loXzFa7RbUUVS7JszRVvshnbY6UaVz2W1R1BNwCsJ7bMcH4lUmLX6JUWetLur73tmx
+2UEjpcQjknB/McOZqLpv15r4REwlnN6xEgayKho4O2EvG5HIWtfct71Co+wS9r0EZpar65t1XkB
LjJJwsZmlpW+vhcbEVrQANDqlw4fbub6bm37ovMZBxi5TiWEbNY2t+Kv4j9VLWLRslIFbDEjWtle
vejEX9e9Xt1euwjuEJtYZCXPniLcofUgcgbtGn/Ex06TYUrP8z+x9Wxg2dzQdbTQEIRFVQEaAoQy
SurWgXXBSEZU7Lt4E746gX/ZvCUc+LeFFyEmtC0lqgceto63D1/HLXUBOkXlYAdK85Vol+Uz07Ai
EjmSg0ew0ze3z5f1at31yn4fTPCi8QratCB1o2zRCLhZ2c+SmEdieay0HX+HCv3vqzeb9ChGHWxV
iSiHiMg2RR8isZnntXBwpdAkVLGpXzbzQPcKFcFErIG61b51EaD07thIgcxxlN8sD6UbJ7Npfosr
jmp+Mw4eQHBqLkXciydMraBBjgz2l19+6dlBTILNIK1yNUque4xvp7haQGTxTmtvslhlymy+KsOo
Wi9aJWKAY1DZCRIlthN+iyysLOz5BUvvlNs1Dp9mAX1RdRLbsTrBP1TEnMHkuzhb/k+BspCL1vnE
JNpJJWypPfnXVILBQhwqEexYZGWBmAZ/A5mY1rt2RTHc7gd187dhkKsdIkPRIiZ+p5BB1xAp5uOa
+bjuXw1Vgz7sYgVR1Wqr84kEiN2sQrtc3GpaWInaGxsvRS7yvUCTZh3m9akIXeCMY5TU27cZCwNv
gF9LJTCfxqjIjTyP/6fJutCQgsi5xP9jkYPwYNN6sI4PNhZoTRFe1Xl/50z7eSCej5rH19ZE6EDw
TKShTn3FHb6b2/bDjhuPJziY1a2PGA3yhh89llAvEjARTRPbrd+/AVLWn3BVoLzoSK/+iSP9b2uk
UYj2wbEE5eBuu4ZLa5iwxadVeLf2RmfRXvqqXjpsq+o2AWO9Zo5PFzLDQdtNgiJSOagC3dinPapG
61bZhhvDmqr6WLHNrfgqqTpfo7dAPeXjDdkL6mMjbVTmIB6djY1mKf4vvKGGefxBBAxpMrihGIeP
pXTUEIJ3+QY1ad86Fkkzl0bCpp/xqGuvo0VkCJ9rD/mQecBWbXdhSoLbq8KZp+pT3m9wQuV2qrKS
/QCovVu/QPyxBkjfPFu7YNmX/WyVnr2wH61cRF44p58xqlVqyAS0pQc6ZzTNJigNRZJkVvR6vepE
Ad2wXq0FNP5XcXsjXo7behqopetQhM5yOSkHWebxorhQtCA9pJ1YaSZLPMSl3WnNgH5dX/Oq8dHX
dS+z6T2GDgNwb0PNd3q9Ljq9pCS723A7fOHIUL9X+1DHsUu3RpP4bltqXEQLlG7Amv1bTKmAFFuP
frdbL1sWTvO0oKGyVaBRukxb4ap1BbaS0tUZ9N/s777aP+3/uHv2x/7B0av9X6C7TeeV3Mrq5Vat
RLVIB3f9q3FYHmdjaqJioDAKH7mO+y4oodgJNmsR6y9peqUJ1IwXIkYtEWuCNB4lD/DqMh2naMo8
A+ZjBPMoyTkhucXon7ZNOsVuza/kA9rRKLOOXnUqsrjkP+C+xXSShe1YjA9H+QCFqGjR0LZzJ1BZ
jxGgCpo4cCJCcluK1q2+ElktWzKoTm6Ssq9mIvdwjWjA7lnQsh2ZE2Ydrm4oGb087PvWXjPrcInS
ai7pYCit2l9zDw2VpyC7qzbFTcJwePf990Bc/SE2sm+Rh/OrLf/Vmn616b9a1682nFdaKg4v/wBU
3JWZypqZyuoiU1lTU1mzpoL7IhsGBSrz4W3uA/IrucQfiJKMauCEuU/m2Zhdw6kZNlT11rUb7rhQ
QrjE21ubkuTOgrSkG4quCk/vbJTUq2Khixp45cE2waschzC8hqvLms4dno0JL+o2Bv/I1lS4LinE
miwv4uuc41I97kL2z8YWi3LXwbMUYLHsnq8W6PnFY3r+70DPZSW8md2CNaiajQ7Bnr3NbCMV3ORQ
VRsdVia70dGyCA32HZqDpjh14yydlNZNjCG01tOYfdsjt94QTFWirqj+fGQcigqhh6zKOEUWP+z9
jgvoPmX4mqSovD3zByzHqXHAqoyrTNGgZMDCH8qPtoaxdgi8WU0D4BIVglJ1TopMr+uT5AFd7Jyn
E34Wgp+QJCQzKLQ6ONOWy7F21ZuOPyJ0fpwSc0cZudzQxhVaIxic2cgkFwEUPZBKUz1H+xok1qqc
MA/YPUqyekw8Aqots7/ZzFV5kxfT5JpuXH4JvEY5uyV244MlqPSJMCv01w0GrNUNfR+v+EfzMLvN
prEQb9QHWSnfI/VYkgUnm5BT++xwmNzl2dBrRgmwyY0a7Z3TZAIMNn0GpuUSGteUpLTEAZ5GD15L
aOxBaoQRjowtusWKXUbJsm40wYS1vkNDzPIWGup6DT1ADZwDDmmUFNdqIFhzguL34UgcU6EvjDkD
A6RyXjuXQlZDF+glS36Q4oha3hSzMcAKLPPgBgMUUYKnbFyzOJ50X2UaoZjbeg/bt9m4vbq1/mKj
qzeuE7iMrP1WnofcmFdW7f0yc9uqjC40G2dXGTGXzMG3Wp3eX/JMpMYOVDl0nQbOHR+omnkCN9UF
dj3v0vSaklrv5ExsXzS1/W5bil1oXtA3YvUyqQUtZQp0wB9PucJi/J1XiSxWnCefzvIxysMGRQZT
ZYBw7eAAcI9lhRXy7EioVA2t67VEEUEJG9YYEKAF1mMtFkaj9DqRuPUBPUlgCFVtuTMo1Or4urKu
M0629+p86lCt9JLD+sV0NywA6vodirG+VgH+58igMUrrZ5h0PczYrTeMGQ+nXbRrDd9lCiVvgW/T
sgjEZnBq4RzVrLF92ZLSSZkR+WfPShuB2SqmNe0p2aYzzwXPn5m86FmRNQ6dLB9TJKK/BH6iVter
Kz/CmMUMaA64M+VjoL0CJi0JQcKxbLZjNHOAS7Wwu6iSQO9kUrLMF9Hvnn5+C/9/oA4+o/vnPP/P
jfWt577/58bm5pP/55P/55P/55P/57+2/2c2xghKU+3omY7sbw/aIVS7buoHGRAd6rNKjxV0GLWD
DeDVHwoooA9zF8ODS9Jg7ALgZL7jqfquYg64Hn8tO5pBy7BNr7JyQnnrCtfZxjx3HgfYKLiHumSN
3Jeh+iwThlTYwWLuY7sKJk+wvtoClUQR3ojzuvSA8qjjSnfZzUB/t3oWEYn033ufppM+cPUYEM6j
kgDwunHK5CDG0Oc/VeqorRvDkfR4OB0OAIz/VyZVEZwVwfwhSHE5s2rXpA5xU4KQhbEz+7ZRjJ6d
HdZtrPPq331vFZEve/q/sSNqtjIEX37PCtMqaDn8JT5EURB58gb1Uu9oBS12rA6s24+BW2m80HBl
I5Gwk94boDPgHtBx4ndPDljJPCnyu4yiu2HysWwM9+0VZpKhm+B9Gv9XcpecDYpsYuFBJ61Fy9ZZ
eHA6K0Zd0VRybsCAn9O4D5f1WFIHwjdgQ8vkOjUPKGJnQ3WyZzfFccmsb7n6Fq6LfKDTY7WYDcc7
mBiIrgFtBSJ9DXIg3GrbKGeXExFrlA3DISv2at5E/dne5xhXOgOWkyPyPtb2CrYmaEBlqFgo0fN0
7Nsxpq5GUgcDa7onDHgBuO5EIYyEi2npBqjQ8iZ5n1q24LztwSHgMWU/SbY9ZnkvhTAcYcADIOuw
LkqadR+unJejEqqMM5hBDkP7K283BnX1jYxrKUAiHSUbtGWgAh8fNdZ7jqAo9JmJzFBtnoa5FnLJ
Y6I3jVfL6aKjVlXWxkOnClkOKpcBHut9iuBsrFZ8G251Aj9++tIDtVKZPWfk+S3mrkm00B4TEvn4
KVL1oQTBHo/ZU/mfCZM24qodNt51iwCm9owYBjR5QZi1u6e5rP/fB7iqqfXCbcq4gShPkZUuNUDC
w2DKIWB+jB7U9SEVrP3xe4D5JHgdq/Zemt01dS4pSKmNNygFjLMj7uWi9WeNdUwXlc2mdcFN3jDg
+n/5HrOlKQY2rwp0lUu06+2vpAQDcsz129/ASNcfD0MOKRyCFFqtibq4Y/K7KXMKsUz61+sxbLq1
MzYBsk1YxTN81ViLEixSuhxM3semCFCp7Hq6ABZLaAID6FLTwxKG+x3IxmiZBKbuQT8hW0fGVNA2
bqLnc4nPJWt1FKKKgstCJqhIrprYCVAn1pV6sXDjyjSnwY8dyBlMtFiMaizYlOHhVWxMEFVAZzbO
qZha8qR2ZHaeaZxQOGh6x58qr9XJ27FOZqWQaDTkU+U1X587+iatFGAX0R19x1UKkMPyjqKcq69z
/ToPvHZQyI6PVNzi9ikIpI+t+uLbXz39LfNnAevUpJz2mWtCq+eV0Nu85q0NjsigWV9tfnGsuGPb
Z3THRzM1FDy5y6nV+VyOoT/K+mvf0IMrEgijDY9oKeGVrZ+sWtort0MHCZPnB/l2LuTFeezGNcmv
xGHEOqTWINyzGtTV0TYrpSLz4Lj89sJ3AiYRnoZtT1Nke0SmNanaTFkKujZCecODkHe9lmM7DY8E
EMLJvI3HMB1Bww6FKMQKumo8LEq5XVas/8xK8QCrWUaDZ8gw8LjAdIBkbiQRALzdJYn41Fhq+XIf
ynyBRXr3STZtq3qdkF2me0hRvtHDX1VBUM0sa1NQuktA0whallk5KDU0oGYj/RBuUwlvYW6UvAJz
Q8s6qfh7pEvJxpRSMv77P1o98bNNP3Q6DVIqI3abjftI2t2JgTtL3/LJVAQMZTnSX4Lt0YKqZcfY
MrbwaF49WaWdVitcCOMz9QEdfnjo3+SlGpP1FGXcDZ1QyXHOhau1k9n0pqF2fcSVmt7MENGHJlPi
paGWsDZ1NptMCsCofanK/cQ8UHIbapDQnM7GfAriUZ5PiFgyYjNiH+7z4r0VE4C1WVg2ozz3QFWh
YCflZ2J8B5O+S+WcGTxiR4V8fCwZBq5tK+6UttCm8FmS1UERg1LeJY3lob48qm3hBMg/MOXAMDRo
RUjnIkMNNc/gvl0VNLF6MBnRG8VZ0VjLkTJd5DKmMedobCNOw1uFckC4o7UDF/BdzbGlKLWVnzAB
j+oDJi8ZsE0f3H5ZPozbZCMKSH5YBvCZiknAdxxyQOFgCfbhbRixEubbnVLaLXRIQtLNYu9Yfu7z
mPbxrxLuynT41iUxWF9IGzuhTC01eCJIJmAZPk50UClJZLAFxCnzWsAyRPDwgk67ao1frHhtKuwT
blENpFT2pSppj6RS+WDtTTgO02WejyIfa9UHZuLl8debE9vycJgP6TnpETHwRU0dfl2pZXBeWEZB
clu0RFbhb02wCV+06mHG0JSlRAwwOZlNp0xEOuMyqJK0GBUkpb9P06QY5vehbgglI5gPkhnaT/wx
fbjMofQBHvFiNgEoQEE9RfGgQCxG9ncPtzzRh8N4OCs4uyei2lpi1NGZ2Twhojbn5XcVQtTTtzns
it+0bk7hqcCT71ydXSPVa5lP7lPKOK+t752mXPtPOktyQQQRvmNjrCowxnbL0zOMGfiPBYjX+hlY
N56Q5MhRp0Nr2GwEEGQKPVoaQeOTuEYnKLIC0zbHVaI73qcQfCqBLv4Us8JizYrY2I/cY7VMEX8Q
y91L9qBsfJe/lwRDittHfctIZQ2CN+6WUOCnPWTQEMA4ZZOWsBWe8MsfNV0ttNAsVsSPvazsE4US
0scySwBDblepYKlO9u8BBqWRBZrPIPiskNsDrymyRkrPS2EfzOMqc2htAxuaZu7WkJDITVOrx2F0
z45gBnhH0+MiPFqQ87GL6tPTDi+ILVMxLIb81VwG/6nSx57x7E5QDGQhyWoLQVI+9LBaNR0jpdun
wAEMOjsKy7uojTaCAzLWMMcAj4L42hWTnnanrpac0ZqVtZXdlmhRq4YtmWF1bj5/5X1vrECsl/e9
63FczrfG1ogV8753XQV2RVoWaJAmgSNXHBj/6VbYK+97tSmL8TIfg7H2hp5tjSPk0u+0hTnHfzMv
2q61xSKHGG8hr6QPjTUoEeUeymytt49PahGkU/ScPrWDnOsU/ammvD1GkNNFhqvcaTujMuIci/zv
1KLoYZLekoeMc3d6hdAYeOq7A2qLok6tTU8F2YdlMCoHvLpvvY6YN+xbrhDaygjPLrk1IdYWNySc
SCc0ImljgRCddQNjt4bqto/qW6c4xvXSrCrg8cZaDgCP6+64sTuP4KmTz80bYv4pQ6SA3UhjhK6Y
Ry0VS4vNOLrNKVerfk1d4+HyqAWoV8k2dmqPN9hl1SfJc6AJ+DH5ZBNns+BQleENoLjdtaO2AxpK
juVKQMOF98aesVry8PlsaEotdOwFRfJOKSGwCoYi+8AaFNWuMbR0rrukVCX66YcJhXhxDg76Elc4
DZcFq22YTiIgSiASC3JCT64Aifd1U9qv3T62of6+szibYCeqg2me99H0fuGWvw/YkoaWslozlIV0
3srOq9NeaNXY7Cg88U6nHvQ9LvWcB2cxq9j6MxK+4cCHsctez4dHTZD0tCmubduMD8UK14r6xMqM
th5GNyQUOXsop+nt/ods2iFtx/YiNA7plYFeqJBcVtyy1Gm7unZfIBU3Sa4RpkzB+GpWaPeQyhK7
ck5z6wcWkWJ5OqOpTN5W3VUIP9a31JzzsL00RRddCQo1kB8GBqrGJNgx9JaeqzSnFJ5TUkcrtNhW
o5uuUVF4FZRPZiliCES+nlBA4kxf5sOHyBEEpA9QOyunZZc1FZJ52TE9EMhEGtEYuJXBkX2hWtCV
tQUV8JStfDRsdeO/oK5Blie9nUwfyCbV2YiHsqeyNqKRCuC99no3Xuls1wbo1h1igPR03BbPE+SW
cY3gs8u3d3rEsMe/34nXawO6vbtodiNepPer2Wj0SSOoBDzEjbLC0u3EXrQoJzy6E+28Pg56TQh0
ASPxx13bvlCkgpNd3h+zDYIXVbdW1uThbytok4u1urHxVvjKU8yT0JhfuvMO6pO9ZrkxF10H1cjV
lrQGOeW4vmy4wzGdFZD//R+O5thMIu0EWRXdZlbuk2xk+DovXqWXs+s6z4h+F/+bXuLFDqcExk4n
pIaw165TvUkB29yfXranl50nR+JG/1+W8PwlKT6PF/Cc/N+bq+uV/N9ba0/5X5/8f5/8f5/8f/9V
/X9N0lX2nd1jA1u+ap03KKgWoXqJoCkltcMlZSTih/+VeMFoKw5rvhclIHEkXrLBtB2MOYM20ty3
H3hGPV+AxCitIUJv/KFnD7xt9RMgPT6xSR1VnCIoY45RtjZf6viB3QAYgRa5oxhoVls9AI/bMkRx
DPPbhAKm3iEp227x91aQluF323WSAxLvUxEWM5cIsO1Wr9XAqOvuoRhQrPw1WFpbcqttp/FyBROs
0X9OaqbQ4nYaOumxtUbbXsEGORf0+U7mPcrvMRLjhWdwzkbJ0yeQ/PcCyYbdt2dqYOBawwCq3aph
xcjeKMRw2fYuCpM69h24yjyKrruPKhgiHozgipMZ0w79UROoRK3Ed+l4yKunjhbK5qjujvQM3OVF
gD3j4aqIfKFTWpWptL6F1Sebg6tsBOSFq0sTY9scsxtVtWzvWl+WO1+WrfjLuI2A1yNbSQ4OOdCL
Iu3ajsFlxwHWgQOmbki9TueJxfqX5v+K9DMGgGrm/za2NldW/fhPW6tbT/zfb/FD0pt+/2oGeCXt
9xVNysIS5epLBK2CimhngZ/IcI/MKqqsX0+s5hOr+cRq/lNCTfFx0t8o4nxzeCknmtQXllsGAP9s
lJahCFNfzQ8X1dfBMqpv0Ordfygi4MpzZTHrPy5HgItuJ0n11WwK226e2lGqljSSQWJc9GfGYnXp
ohqJJhyG5jC/lxg0Bm3pmDP2oePW4MNlgqba+dh1T9YuwPGfh0VyNV2+yT5k6TKU0fugSiw/34q/
a0gvv0D97//c56H9nBLmk5krQDVbz+7pYrYC6FDFVzAxFNCZ/CofATGMm5Z+SJCcFtefdHCTCxKX
pfj+++/VhuhO9It7JNNNABSz8h2riLZZbN2XsADYRc/UgUVoOaXJvbL1JoUBdgGB4GzcAhxNnJ4s
OcWWnE7F4DYK+CN5vkgNnuyLeLFrz/Uy5Cus7uCwA7tguqjBHWoxV6igG9THuT4F3Z4e6/LkWel6
DhT4lqLCiyGiTuGGNcQKx3bZNXbXVQNcr2nj4cRxkijvkLg8YwY6meN895l615mmcFOBsEyP8aH0
jZvF8S9gdlznetjgpxh/9VW/RiF/oAI5pYEQW4916xP4Ya+0B4KQQVpMs6tswK7ZcFbNF4aast4N
Gdevzy4c6mPbMxb3ck3p+6tfpOUkH1P0gapPRtCyXYV4RoxFFlQfGSPgC8SzaLHAYex1iq7LWTYa
Ls8mFFIixlwFI5Ul3Asnb+XjUQZ1KqEZm8ngAaoJTR+IWK3sUSvR8KMGAKxr3j5ugSMZ8LfmtTZG
xJIILBANPBnOK1yXa0ft5wJt60L2QUbjrH5TVuJdvDVjLCewi7uq77IuUc8PiODL9K8zTI4BCPPP
uE1/hns2HcwI0sMe9+xZizjLndlDlo6GVrIIZ8QYEag2zXmwDtZoKq/btLM1w8jGeVMtukekmBPY
0MqNKvHW4TqsWdwzdE9WwakAf0vKbHXR9ogRINpH+wuqd3AEkeKf2sG9fkyy8eihy2R+xhfoNC3J
H3AyKyZAHjwateHwArFuvPhcPTroWCqeAhIq41Vz6SYlEZvXoQhCutBtmgBVLhmD8iuzBNWoTNTL
rWWPVE2R7V4S7FlqUobpTrUTcUNECA/x0ULY0l/lvtJwhH7Ay9mhWIP+w4l4ols+x/O8Nh3Hzble
y7Jepe6eM8vbg5AE9/xiQAwoUFbM43OLzyp7aU/VPyF4c/UqsU5Ld9mMfV39KSFZhgzbZwAeDdOL
O3jj38+6QMGVEaNl2xp5kVgj1jK6BoqW7WSRT4AOeWgbSO1ay99xQNnyLZoHzlbRujy/NWRJUBlS
U7YX6qZ6E0ojhqixqnlrYL3x5k7+mfOmbaQEXP6fOne3h0WmTTX8GdNDd7LsIveI2Wqa8sZNcvdP
mLaM7THzlpQpaPwbvrAtI2V9eoiO7p2dHTLlLwskvXtrKE9tY2bh762Au199JWR9XTwiI77AGK/4
Cy8jJ/JrXA5uUpsszoApJBEC6RFRJPEMViqfFQNDn1dphBnlA1uS8SyZ5qwIVS2eVEtiy9It3tVS
ZizBstr7sRtk1kK2WhziC0EeIQh5Foh80+v1rOi3O+9ab8u0WN4FggdQ9o8PJ0V+DVi+oaJe/g/L
PPZtaat1YdHx+hYIxGfw7mlyKbExv4oaQ5heXyE9X82qFpsiFxA1ppvoouSaqZ4WBrsQ1r/v3M2t
x95ssuUBVfjy/GDCflBhFHxKVD67Ti/UeF0IwuZQhFYDdWE2vEFJWAsnSrLVyvxYGY+ImRFaw2D4
EH/hTBgRoU3DbS0QtGWx4C3hRmvjuHxsPBe/m8bQLh8V4iU8EfSFXnQiWNaOkdkTsSCwFNBfMVa5
pzBp4n1eDCuxLENjQZ0bcJXTPqVrbByKyQOpKlF+SRY+14DsnHCcnyEsp90dYbbGjuBcLOsw5+kQ
YThNqnFpFiFrBR+RaciSPF7qhot3qq110eyPrmN1j9BV61RXMcLIot5cwgu5fqrhTfJJe6lUqhYK
JtGZF/khKHHTD21C4yuahE0hVMypkukUvWpQvVkk4+u07YzMhT8Y4Xon7DTZTEti62dvT06OT8/3
X/VP918dnO7vnffPznfP357tn4XtpziA6xxq7d0SpQ1lpVRzdMBQVJDffN8XhoHaUX623a8IXx1f
/5Bh36fEXwkKgqs+gKG4qxKt4LGhV89SDoQtblClvhEfSdnoWGn1mOtERU1rDqoaghDlASfJJWsi
ppqfY+T377NSyDjpsCqIqsRvbRh+7sZx1WFlT0ZpUqakcpNR/fLLLzVhXO000CrUBou8ve3rhEU2
GL2Cy0s4BQcSrLzo1TSS9Zsuov4q31BRaTewCS5nUT9PVqO2uhWv+gprUp2sXcBRIAS6+fGBqBpy
kexWYiig3+Pn7e91nscvkyLY1+oCfT1W7MsqzACwmmj8sn9kJFQZcaOMwFE/B5KPe0LXSp0oGHpB
HPjMYugE9Nrz0h5J2/bfO0enu7Z/rZIrHkedtRKA+qk/ybRGq2O2fdnziFeriqr1xdrX8ZWr2NrO
rTrarnpm8hy9c3qZjZPiwUXcdXoM7Fojh0ACXdO0FZ/YBK5twgATFdjw47F9AABpRVSETBUZ009R
4EGdJQHSc0Vf2ilqfiiy0XYwAOeO+qSM4yvhNuYsIoaYsZcwf+wS5k9LeOwsIan3GiSXp2L9I/c+
TtW+katZLR6jZOFg8NK006wn2XD0nBo/KG3sthdbl52v7UTMOnBS200R7kSQWSyAjJz2xqAxEhOo
rkHKXBJ8y0iitsP5YtylJXdredLiTw53YpGPbMOQOZtOS0jr7VJTjz49TtcBMVJCj9JkTLlIgLMa
knEHpVBJSRkEx0qmKG3F7r2owKmr2HYSFLDpxcLRWqtJyEOhpbUIxCMxyWKuQrM2gbLTXwVWheJw
1q5CaFaHHAAAh9J8AoN5YBCIm/XPhYM6040qXPBGBgMH8jgDUWs4kiqnLgu9X0K29RyunCVllod5
ksY5ilHEMn6JF2MpmhNH6ESkZw3ZKWjuRzDehM3iZJLsjxSIOke41N4RlLu0fZQaorWqtH2nhsE3
3EJPbJTSugB4fnl0pPV5Ap8+t4pnZR8NpNo+u1en0rOqSoibYG/VRVos8p9hU+vEGzKYwJF43ADC
wQGhEjITVny9+Lt4dW2rITYe0XzNAfnqIst9HLASwJ5kbhj6KfCP6AgQdrp08VzTJn/6uh7XrOun
jcG9Q8z1schNkZRypjn++oJ0Yb3tooP5tmn20gGjq7mmM7WNeXyenQ6HZbw7LM3tHx2f/rh7qAL6
7FDcoDawGk28BkdD4iRueZhEXtAcloYSVqyyJNqVcKFoS8btiLZ48ERvIwWKd1PpJXBLVbgjtJ7D
8Yua1hXJ6dq13I2M67t4hTIf8bfvBXIP949+OH/TX90KBU7/CW/JfQ4vpKSH2ZhvCpLltzqPsrRl
kSu5wvQmGARp6fdvltT2dkgGgRPuVrFlTZ6kxQBDG2HtrDcmVPpZ2ysILP8vw0Ywrd9iUNH7CIOw
2XiajXQGz0TOjGfMLKYWbP2uHNQwP1MsqYYWayYkOdPAU9UJfAQEPw6KFwhh0Azfnw3OKw2iTsho
HY0OxDLQbFCEBC3pKqUx2gB1Mic4L9PGVu4Ksv5A4w83MKlp77s4mFqicakfR3F7sOLcz79fOOSy
zRVVsrVWwlQa4SrDVae5URq7NmETwJiNCTRav3/TsjnGdysY9e7dykVji9mV0yichfWVlRXJv2Ce
f7cTb3zzzTfbcxWHQ4rx1uKzqvCYlgpbTXY6jW0RiWSPAHbAwc7zhyLh7D5pKJwJLdh6TTiR5prB
42SfzMYTeDObUqRR0fmcvXl73j999fPpYoFO0JwjEDpet2oHErrMi0Zz7cP8fpm9JZPyYTy4KfJx
DptE9bqAxtG8HZ1ZmL0nh42SfZHRNxrRPHmGjnmLv/oYdL7QuhhSUJepn5RAinbauE2HGTCNdu6r
0Pjmpzqckz5jgdvBzYIYjqSqiePx0NatW0GnqQEtG+6iE1KZ/c3mWCtoVBrVlaRRVdOP8js/s+Xn
09N/zDoG1PiRFXjX0rKSMYWTopA9f/s7eo5Ve1YFHq4dq2BTWsh7jzQUvqG+gutcbCesPoHREN2u
fDDVdWqyNRNRVXquAeKxbJsqkVGbfR2j5R86/LMdABa/HuWX6Ocp5lOqLKExTDVJo2U9ZyBvCSXR
LpUTyYLWuJ/PEleUx+NH6tMtK4jH29submjb7Ia8gM/KPEvcBX0wFrHI9QovYp7LqBWPTjjNG/nT
A+Cz6myKKJfzz9NWIVx4WajiAxZmYh10Ukc/Je/wT+3cZVIV6y2V2jNXBY/AzOoUdiBDa0EUiDtt
mbzjqiJcDT1Y32RAGC+BE5YDKYdNc0JbXlBlZRy0ZVnQ0PhxRsbNBsYNxsXNhsXzjIoXNSh+rDGx
MiSusQVa1I54cRviBeyHF7cd/ii74UVthh9vL7y4rfA/z054eb6XvqYmqCA76VNQBFOjMrEFDY8f
Y3S8bIIu1LTmhDYoK7XF1b2ucjmSmtHH2Dl/qo3z8qJZQpvDHSxuL72ArbQinEwWR9vktCWPgb99
J4HcdfpGtxw9hWJ//0cnFG/CL++9hopWbrYqtPrVqyXcFkLrXBlyoIzbihAlSLvQLdp+bGq8YAgJ
36M/XCsQYaL6qKbu4vn0fLtfmXFA5ERGqIGMpxTwtDZfnmrPMZT2+nTp8+jfMf6fCe30WaIAzon/
vrG54cd/31jZeIr/95vFf3+VXmVjm3k0+/8Ur+8pXt9TvL7PHK+vEmjOmCDoT56cKHA2+ZJ3qSKW
3PrNVy0dqj17/R1c1QWrM6osCY1i5SUXUOTc5AuNjE1UP2lgYhn7WcdVK5RcaIBFeptPU2a+SB45
9AQTpFPMbzEQ3BT4ofesgQBon1BGcCVL+8RJVLK6zR17bVWv9ziZ+qIkSUSPVN4zPlImYOBc6Pzw
8DGDdCv6QyTBELOnvLr5YDArisWW7mUyPCONz8eMq1o5OLZ7okPjy2RYiYQh5pWOQ1IgVpxOF8m1
JG+sfJGXIpFGv7q++Bf6md1vS0y/qKybvozbDc1Z1hezSVq0GybNHoYdLQ1rQz++mbrpiLSU+lvk
hd0yg4dy9tfq1u0Ohyg8ejxKMQROwk2QRAPJDmQeLvG6gqvg8cjlX5D+1/D4W+R/Wt3Y2tyo5n9a
eaL/fyv6/4m0fyLtn0j7zxmK+yYpb2A4+uttMlCf89INuy2Rq3XKPRUs2Uv7tEjU7U+JrR1hHpOk
RJv/NoyrGy+d/Lq+1GFvBvaT4luT6mNE660NVZtd0cgkFA8Zv+SHkTHHrq0oVqV+zYVHFCq34Rbc
2La8O5SiTAYheA66f3N+fnJmAoW5luSVelZpU9JK6QX77zVqhyNvVWMetLqxeYpfGsJLtC6c9UEA
gwqkniwwLfA1rKpyhXSfYmQFKN1zn1pT4Ihc9st2uQrE3FrAgmQV7dHLNTd4POrvKPeMQX8/7Z+e
HRwfQd+r61HUMC8o0TYr1vvx+CcodbJ/+uPu0f7R+eGvXWs9e6+P3x69cp6c7e/3j8/f7J92O9DL
3h7gNLvppo6/djo+Axy79+bg6If+yenx+fHe8eEZNBnp44iNeXnZOpoWrW6tiSRfR8sz8dtVMdO6
tobHz+lm2fU5Ue04loamk/3gb1zXieYXCgmoZ0TOLdIIZ5oq0+kyI6oWumyTQYwVpoMMfpDrHVPk
3wmZeKkIa1UbGD1V9kunnM5m6VRYPVPfb1lL5a3W+mjdvhO3/lT8aSwZknS8OV4DtHnigeoK/Go4
u520WwUG3tWa4pZbzAoMyCyVGrbNklDzncg1JF40WIwcrAAE2d1KRBUJzzgYwFVpAAbHpN2YuDQs
cNeJHtSy9Yetjh4tKZ65QWtMrt+MlSX+QGyaDdH4hpdNlmrR2ajRKJjqo51qX+13W30QuPkiPji5
21Jcmhr60vYSrrIqW1nSpXdLcMbVa/i4dLHkjlJeqTEsAo4+KG57cQ/fGXvAH/bP4y/5Oni22ltF
dzfdlin1dnJdJBjaRKNT5iQv1DTpegGk+4IM09W3jQ0rgTYOjF+EFrITuNusGq0vy+0vh5QcLFSZ
J6zhpYUPW7jusgLiS02f3/HbC1v/ZvUpiEXynrXekMUF+wF6DQSH3FBdTUegEMfpWZ60aEDWsGEt
8Ynu2C9/4eSia6lW6iauaoWnHhr/sVjEeAugGmqKXV7XlCQMCa6JoFyxcSvTQV8DHAXblmJfxLvU
KFD/g2V9ypf/CLX/4D37SZgkwSK3yXgGxM6DCQutDyqPdymwBUuVbvxS71Rta0Pmz6VupSrdqfWH
aiGg454qQ3kXGPdF9Pj5yhIuMufmmUhDajZCfZnjsGTlvQkMS/drp8dRNiK1Y1gyQvPtWPDY0gJH
N9hbpxJ7uPQC4HlXmL5vbcOYBZdL6UfUerW6QjrYjXUsbKJsTM2y+V1ZYKJKX9TE/+DXXTLU64RO
tnOP6JtiW2WAfIcJGS+q7gB2rkaxm5NcjSF/0TsbVTkFLiqrmH6Y4iryV7VT5NzYH7jZUf9LElma
i4e5LVPO2VKhLRV5E1nmiDvVnJcs2X7n9Nx1O7iwds1PHevDxJ7YRDIMqMSwUaiogFvgsUNQWPSt
TVRUiMWuornEzSQtd3zmRQDDJpv6hlVwRPQkIU+GjeSonHm/21qaL6APab3xlRZfDnHtDCvjDssd
tGNKE5oVLFj/zf7uK0Bd/fPj/t6b/b0/wsz+zvL1GaMXPASGUGIyqmXQCL5WJbvRP9QeaOLY3iCH
4VKEnEVS62NhH6vKCKspZAvDiBGMv7dpd4vqLoLeFJJ3xzmThA8+9FBqMml3VE5aGtcHcpTplZNR
Nm0vdZc6Ds65U9s+v69mbGoti8ceDpb1diyriq2aGetWUBkqn/VsZKTvSmd+JQOtGZOXT1ccuRRb
YpVkf64SRUQuTl9w0a0p+2NVZ75EQ8rGFWFDcGc91O5T7QrP4o9Ed8If3BG4twqXqA8q5Tel0lVT
LKMlaZKdAnbiNhI+X8ettc0X+7uvdzeX979Z3VjeeP5qd/mbzb3d5b3N3Zcrr/ZebL5cXW11Km0R
rkxI7L7jyPjaIiftAR5ZbXMe4p7InDodH8RtdpeCmToyKu6gK/PpWCDss7O8tpzdS21mgEwJHQtG
IPWUJtcuADPmt2MeZl72ZvygvbrloD1nJUydjoorpdZPrUP02+n/gHP4zfL/rm1urW1W8v9urj7p
/570f0/6vyf937+i/g8IkXFuafzCGXofwqrABhXfQtq8hRLlYr4UW/f3v6TjszViJgJ5q6vJePxo
szOo+NK+x9ayshyYTMKMHIJCJUjax7IXekm13uye9U9+PTve++OZChluu8azUidUu/0SJuObFWnD
n2rT4qItaiIr4vpc9VAoHw7pc5Cs89lobhjftDp4ult4n7c8+rttqiOhvYRlMDMyrdWG/rRpPt0s
XXTmxewxXevwMPUtkwhMte0H9iHrSW9inoNeiLPQdQOO9iLirmsSX7ecWNO6Jjm41dfE15XB6MrK
Sy/YgHpZqV6To1LmsFI7xrCDuzUGm5KF22ZML+CeECTCPi8yUEkLoPQatao9TBiVDmZFSgFqizJF
BIMtGToc2RzrNCyiXjp5wEelZCPnKIeIs3tK0DIR6OfzTe1uMoU9HJeOKz9qTsjbkWvsxC2GxpZ1
ZquNbdTUpfNUVxM1PNV675ZXL7iuVVGGSRhHe7XphqoO6Lpi290KK0+DOYA7NCz/DWrNdnhYpMDy
XmNr8pr22HuNA97BX/4L5eYpdREW361cmCUg4CTfKzdxsfQqfqF27dUFaquoC+pYqaR8ket92Zf3
O6/2X+++PTzv4+bun/ePT87RKOFrfSzFT46q21y1ALejA3qz+9N+/+zMCy8jG0hXr5wnlvDpLtj1
Tp+lpgNffzKgXzoO2rGz58keudN23YlVilbHz809811ZvM62C8yEl1HZRTIcMZiVr233nDDmr5qN
LIx2ok9HO+JxWrFckbgcTStELrRwXPCG7qM7fTcepzDg6QwWDQYrCJdkuk65tqNYtVvXA9YztLCj
08YC+NGBFVKAWiiSBV6Wuru1rSRghDE6DsLRl4YT1kUBM22XbJO3IN7JMQ8qUYpwkmb1wqeG39UY
kuByu4mjAwez8XB+4gGtjy76MQf1MYc1FKxJYLu6kJUQOHb4mgCwzoVR7mIi9g5caCLAj81ZdGwA
8P3metKOuWMsJK8+K3KlUwXKL9h7ogBQocAQaIE/Hub3Zby60sXxqNlphhgXhVCSytibmEdWYIUv
mD+XTNAp5SRkzxHNkG3Hf+7n4z6HUrZ8AERi4pC94ruOETiSaYIxX7oECSt/tnqEt38G9prbe7eP
XGO8tnYRKwm2Sq78Zy/OiXjEAwsL8GEF6eEhAMeLN1z/7Px0f/fHni94n1TJYwcihACB9q3VbAdj
S9hws6JujJ7VufXssH++dxIUuHs4JSR/r567iVDC/JeiSzC3XcQvXOq4GWIoZJEFNTPyb7rM71Kv
kSD0LAAzXjOfDkBeg4vAwGM32z3sn21nWeZOuMPCaXoAScZrl5RxWnv/Vfx7NDHTdE/p+8lNjg39
+bo9DQjZuO5Gvkpus5EQSERjx0o3pCq8216/8K9RmaWMr6aNjlOrMZTmFVtqkE4sSNgGrgZoT1ai
jQKFMtyaimmySP3IhirWeOhF2DBr4C20ieyJEA0vtxcIh2oHZpDeQvEMw0IghKlwBHweWp07IhJM
VDEQ+xGe99jXs59NOMymGhgwP51ooUif7hlI5w82f1yntfFOU1yi0/SKEN5O3CaZZW9/7/jo6HT/
9duz/VddlmP2fj7btR8HFqIhxOUi3QQtUniqVByZCal3cHR+uh09Ko4qRQi1WwMQt0dVM24Ci1QL
CR/RXXMA+mqT4RpuXNBqmcoATAW3MM8+xFrC4wrXqJWcyRi5+n45zrReU0qRqHiN/Sseyp4oOYgC
xLiw7bVu/Lwbf0Oyx2CB9W68prH2fZFMsBeXHPfJ8G48uEktc1Tt2zBG7TaeA05AvscP2lyfU6Ui
rS9jWOJM5cqoH3mEu7V1y0rIrjdIC7TW+Wsptfb2T8/7R8dH+x0MMus8Mas7SK4Qr+24LSV9bKxc
8qV8g2SSECEdKN3HV0sBGad0AavL1atwASvQQ694nHZ29dBXCUXLNtfd4T9daWCH/3gZjJRziTTY
jZeoSRW8jyfUaejcKdmmdZ8VEwwgfrZ/+tP+aX/37fmbTt3K4wDV7LejYAe0SoObJPOYYW7qnWnm
oht4z129Tx/snuoLKiFVtWRHbGXLNJVPKPjAWJHXwILMLtHX5hmpRI2SfZnVq8/g1W02fXb5zVay
lr64Sp5vbT7fXE9frKVpsrm+mgwvV795vrp1ubk2SNYHyRdcHn9D7eXVlRcr66ub6/ZZ6Mme34pX
tbUWDMzalpy4ZEyMsv/LOdsv9d8cn50f7f64X11w9/ih/YXzwJiWZpMbOGtkjC/hzSptARnRl3Jt
PT6pd9ExTentDbcmu0v2W/xB7ZE/b27kYi4UNTRphpUOhjd94Gjv0rmTNEX1PK3aF67MTlVkhMjI
0CEHDcQNc8s1ATCrkEU7NrzWlFliMtwCX23rXiTX1+mwn+ZXpdNSqECgGbbDVACxozG3Eqcyuq8I
XlB03K9IXbbd4G1oHNvWILyjce/p/n+/PThVNIkMejYh8z6rYWVLCg2cML7Ny146vsuKfMxz/Hn/
pRDPe4cH+0fwZ7f/8u3Rq8P9Jb3zujrZ+pc9xJm9rEQ4aat3nfhPLrMFRa2BhK8DHdd+8bp+VUtq
pwBfdXKBh1WGF2nsXjOZYVZ81Fycy2ruoLi0MzDeIB/JSL2W3vrWReXuZUKEh4SR8nSnS25zCmT1
XR+icWwZ4UdSJgESzBpd3aB8bhFmaCMCSX/9lQPPWq1Wi8c5rK3ToxX4I5kOboyDj8rxMEnTAte7
3bGloHV0YkVm68hrlUspxfpXPNn4WsR8vZ5ofQU39bXBewv5g/09dJna/nKovabIrQ99k0xHwQa+
3om1RxDUD1aTq/r8+NXxtvJZjcVHFsfeU0tMok5cR9FqmQXEB+JxKO9sMk3UWJ6kTVXBIZJIXooZ
2otMI4bSrmMkqCorC0vLRlJsBjvAG05GmGd36U9I7C4tdeyLyV8jYnaXd6HZvMj+JuE9XyZlNoCF
U6tmDahuralokxelW0f7DGhnzOB7VxnxSabvwmWbiDyNMqaQDMDmEXSiibWVlUUbcbU1VwlcGsNY
QfldlkisIpV+4ssCl17STtQdvupkbTcBW+BSWSf9xjgr/v0fsuqUpnl5eTlW7prKEQWeKfVFKGfh
CKMI7nCmBvxsrb/1Gv/Umrh6omos654flyvmsWKpqnk5L2QUSIrEjKiMhI3lW5h3fK0TyqC0g/HU
21ZNOKyVDIyYxs4q0om/j9e2Q1lv3F2wW127aGD23995491uOZnKrWG8v+ugvCTQPbk5KJvu93ch
oQsU0Rb3ZCVhPL4JBda6g4clHlL8nV30omokb5pBReW3pLrk+OM+XMwXsqgurZlgj/XNPValp3Qz
N46rszk1oR9fO19x9ncAI/rfjv8kZoafywR8XvzXtXU//uv6+srzJ/vv38r++ynI65Ml+JMl+D/H
ElxQaRQRUiXeRmFXuPwO6Vl7SZ87INc11UvG1J7F99FsNHpDCZ0LsVGOD+jNvtEXsXWxVbKtepTv
1mWNVGR6m03FzBh2AUVdnqadQmTK+DEojGrW7gLJ4z5dgpKpzpg72zbeHBP+HMuhZTdyC/iXdCL4
AbYElfT0DplG/DDl0vaYWpWEeFjQfvhK1bYfcr8XQj1bY2lTH/i1K/myix21aGekhzfzdINHnlMW
9vGz/IoBVhrKgEh76C2UtUf17OVVOLhS2T9Ya243jCiDR+8FnJTcS85G0At/a3Sviqcxw9AjCOy4
rE2nUgaGeohZ3jSovdp/+fYHJfQjpnCaTXF5VSBRbVboDK3au8gOkB1BspBaQSpRmJFw8Uq00mpr
dWQagwZZs2PAUh6Qqm6eS0GB10BR+41aBh5bpah5LgWZmDQFF10lq4najJHKBlMq2uX05u2fnh6f
hlqiU/WYlhwwqBxFvyUHbH/39PO/Rf+LMcLn8gCdE/91deP5lk//r249+X8+0f9P9P8T/f/v5AkK
RDYmeXe9QR/pAtrk1DmF9bXcOsPuLkCGt13TTW3KCZ/7R8ev9g93f0Xp4oUTglU8Jlpnx/0/7u+f
7B4e/LSv5H7BnlRcHLs3LmDZjpq2sMdOsEccFhY7eHX4+B79+amGuvH6yrz+js5/Ovw8HWJLMMF5
Pe4dnX+W/qAdmB/xZH6uTeUAaHNlwb6QeaKE05woDcW0btIsfHhdfejwaagLYBde0QlwS+MhcWHM
qapOFgiS6uYx61S8IdBYoKJ7dtPFvXN0dGJgEK6jjA9EMeKkEuY3tsOYea3q8QfPX9fbBiKMK0vb
ds2UFXt3Jgl6hc3zU+sCflMZTD89X6xKDRhIGRu30ewlhb6GYoHr858e0DG3U4VE9ZpXIZCVzZ3+
DzAOL60wz/OUTfNDk/R7rZntqcmhXLO49pydlbZHqBgZf/5KXYe5sZ202NtO5FXHn8fTQNSnpGkp
7/8SLkJUCT5I1hnta2TSeS+QwZvMAKhwXe7us7PDn4GMOIWu9qtmytr3vcm6+cMgELlJJQJJPyAj
OO2bh22oUFF2WXWC59f4PtVX/L02LN79YffgCAEj+Pbn47eHr14eAn6s68PsG5Ab3Zi0e3Td9/hP
W3a+043b8r8yuPCSEMooi0V3p6orF2zotI3qvBVPl4rRHPqCxuq2vKId07UEogKeHDqnsqNkN2pP
a4OVzqudduogv5LHyJHuGJjcDziPLNynGz3LyqxTcCD5JZzTEFMSk9GfFGj0120ed4PLr2Pcw8v9
EWjBNTgw5RrwhApMRV1aSMvS5vNARJUvd2nIFmAghgAC9auuGYCiYwauXTNFk88+9C7brT+NfZ2y
0fxbduiXGHWRo0KyFYC6ULVlCTpPGTRr7TG+qI+Phm/R7hCTWAVjo/0mOJvmsSjOpsI03RqE/TNy
QU8Ye3GMjXjawdrNGPt+ob35aHQ9b6+ryESoEYai/zvwdJ0F1mdD1C2NqFv/fET97yr/1TKG3yL/
7/r682r+3/Un+e9T/L8nqe+T1PdfS+prS9VUEBISeZUjyugkXIp8drho65kh1ILh7sqRsQ+BLzpj
mDRe99LpramQ6b6SX6scdeMl42YpWbas15YPZrfigGFRsk0+CxIRq3rxNlcy0b5Co2653g4+d+Ev
hVu6gRCQkIeD91iNwsf03bpzWhSI0UHk/WFGoUINC6H4BwV9bkTDqrXQF2idcfsgVkNwADUnTRG3
YUXGQKcvKwcJcZpC78OeZW2kKrVroyG6hR1YfEwlA5tzauHId6xo5tZ6MKA86f5r6b9ZMfqM4Z/n
6v8311b9+M8bW2tP9N9vqv9/IgSfCMEnQvCzEYJzgz9Pi9lgKgp/FELe5ncppgoYYT4ECmaoCAd4
Rt8jL1yyCngoelgrDps2cXWDIm57ycmxDwwEjSQcrozkhIAVnM4mGGCCwaQ2MF08Uf7DWPtqlFzj
vklERgw/0FlEDQkj2I6Vb6E8iDletKtcw8xL2zpzG1aL6gMRU4BrjGZEzjqKKCqBIMV54Nsd/O25
U5mFGfJ7+syxKbnuDgd/1T7hXLhXda61nJi9MqFcE5XxG+rRngQNz44AbEaAjy06SIKjmXcitbYi
ZjrRcXl25PN1X7a2KzHjnNatHiTWGrmUO204jVi9atJ+kdY3NtYXWi3p+cvSXi70n6TnRmKv1sMJ
mqLBecd+H8wIogu2nrX8Rv86S22hri6M/rH/gabLdrlg5smGAKeRseY5OsactL/8ShQ/YQKM7jKS
gNit1bXnvRX4t6qRQB9aySZ9CRJFwaIEFVSifabTXjbGCJGA3LhgVKMTCOdJqU+jwjGO9XjK2eVY
IlHimLywD864sAxGXp3eJiV6xquy6ug+s6zAlcQ7MGPCUyvxd+zOKc114u/i9TV7jgaqamZo5iDN
A8btQ3P3efG+nU1opErfNMEiHKMLkH1vNsaMmu2l3x8sdavLnU06HeVBPuZYfPa0xxg7jhM7PROn
bim1aAdSnHtRDUjr7ZUPr+Un/u67uL2+BiSgvVCdTvyH2BSywVem+QfT3I4amrVaKqQnsbbWlaJD
fTqmEOqp2YS7atCOlhU8HdWAyvWdnHlbLUdncOfiFyse+p0CpG6r0zwEq1LwMJr8il+Rkrjagn0Y
lJBCI/oFK3jA7R0dO/ji+KH9rgZQzfrzSZT8WvTZHonq0DuvUkn8oLHqML9NoB6mEpCP7lO7QX6K
aayLaYlkW3upt9RxU6zqU56Oh1yGa3WCKi69PoGj+vgQtQSiO5xe0AqLvqK+YRiGHTcSuZqeU4ui
sDtBsLXXEND9QI7CaIsMyHTx/dehten2I8rQErfYsAnl77IhcwsqcLFYQikSrm2mYs/CnkOH65gH
NukXq5DuPCKJgkQVcokFTqErYGQZBxeLcX2LW/q8kAGaJpri73CpvjehIU0ueQoqFBMkuARMpRKO
HchQEy5fKNH/iNtAjXRiINzflwSVRMKVgjooGuDYOMNfplfIrlwBoY1mXyjZw62y0j3wFqrEn/4w
lmMvS0WlBE0dyti7biZYaYOIozltYJlKdY1NgpVVr2UX7TcGN3Aq03K8NMV9l/As4fHgps8bDwOT
BQ5zwKqn7frELsDq2pylYK+Z9pPjlA6brVjljcD4OROAHot9phNDtwSOJbHG7AzByphicR+PuMYs
XMQYYcXLrGjBR4Vo19vuBJrRb3T4XKsT57Dr8DvcG0A3ZqejfOQ2GF80JDhQdYB8KDEUEAzfOTVC
UlMyzPRBzhDVsG5siTTh3doUhaIS05AKezyA3LWaDeMEgZVwOki+8BYq2NLhxVXsNpO+QIOfTicR
uk9MpHKnOW9hgxv8byH/RUeCzycBnqP/f76+6ef/W19Zf5L/Pun/n8S+T2Lff0mvL/LlsoW1R/kh
nCpkS1X2aUCyVy8o9kHV3s17LMaNlssMNxd0mIEzmxbiMRNUjEqxD5ZfTfph0Ocg9PiJrlkJOIDk
b6UVY5HwBYYpuC8xsTGJW3WaEyDhiZBEKzKKdFYAaGbjtMTtUEsQvz1/vfxCBc8lia+wMcT7SLs9
XCipAlAlK/wWHv6kHloTc5a3Db/ImLlKlTn1252eTgquq5CUpF5rTmOP9bjk6YQwJB29FJk2ZowA
rJF42n727PIvOdAfQFmkN0Aaj8e9YfqMzIqfcUS04tnwKnnG8+lDFy/6u3t7+yfnWuDLD0/3/wvD
xu3Eq2tW2VcIak4+EziIWQGEPtBPU3W4prQ/t8mkZENvcma5SRDY4LwRfOHDG8s75gtmVoczlWgi
+1uqm4MDU2Y0TW6ZIk5S6rL4MiOBUGk4iZVu87/5Jf7faWq12/wvjr/pNv/TTT3vNv+bX0I39aL7
orvW8C+O17rN/8wEV7rrNf826He8utrdon+b3RfBf5EH7uyhxfCO+KgKnnS5EvTjnXN7mY3pjNpJ
eZAxxIhsGsaB5M9vUYbKYUD944KnQ2rYkL4Kk4V5wPBXut9sdV9s4BP+b+NF9zkslf7e8J9ZrbUu
N2r/x0/085j79ArxE/3cbrH6n1c93KJXtLlFWAH9W1rUX+oK2S1WC/uLcGFdABJZknYD44oO0wlG
6LWdKDBtBiPMd4Obi8gKkAqFkZsc3JCwe/2qE/8PfKPH330XbxEf2a4EiSS3Axtbd5i7bK98uLqK
v/8eekTp+eAmcmvpUaxtblFuNnz4NZS+qKYIs6bzmNvO6UhGV5nvipMFJiPtqjRVyawmyR+qPhUZ
cvrFsJ1Vg2iqgeM4gtuTVTxFZNw7zn0XcORwxL31KqfGdVISHk2WYCG6Gx01tF4S/GS/5gs0Hbzv
2VIBFmiIaCMbcqNcoavKTGGEvfgYGY37DLkJeX6F8wl7ltbMRMUtCvlOeGZy6E6jHvWS4rqs0Ebu
a6WTCqr1LCfmsA9Qc9eETzFoqfsYw6euzh+W5wtSed9FDVbHkvQ8mfstIv/pM+cvz3voZfSsHBTZ
ZFo+uy8xltcjRUNz7P+2Vtd8+c/zzSf/j6f4P0+SoCdJ0L+8ASDcRWy9J9/xYtRiogdtHTi9QS9g
jBSqHmS3plw5Uh+v/5ZN1Oe/wTyd8EGPMiaUB/rIVx1NcEToVV0rBRFxkNKyk580xjxU2RXlO+eJ
ZVeMh7JXTuEhSrjktWWsIept9aZCArRIVtKqp0dUTRX6G0Z3fLJ3/Gq//2r3fBdpez3f3u7Lo9c9
eYuOFN04/O7lwdHu6a+daP8Ivh4c/SBpb81stVjup13O0672vMffXQHdgKSCInmjYgBOSLFIbPZS
5SLuM7W442XAUsqyMuxDLe924tZqq95vXJdCGx/+UvEaD5lCOXX5Q28Ap2fabt1R9PZVK9wNbzlP
jYLfDFPUT6rubBNVLKTAhtcEc2roZZQ0uCf0pg3NEDkCa7TTMtfUGUnd4ldAoMTneT5S9pJUCaOY
9lU6XTIPbWEs0mlylxQ7rfuSDWmDEeU5qvxoAsX09Yimo7BOvfge03ylg5u8Z4AnL66fNXW+TDFv
l5fFdmlOp6wG1R2KIFGb+W2/WHmx0tjbHfcGN9BlXqJsWRTdaNAyxoXfWfqPJQBBgtUdgeH6UeEm
7rR0a3NGj7p5KUsmwT0rsO1qF6+AewD3Ab1p1bbVMpWA3efQt4TOUUZt24tAF7NR2rgcY16OcY45
blp63kuAz4u0jyzZ0rxJHVyP8UYTQ1N0TaI8Ro3dFtxtkdybPlumz7kLCRXRqX0ya+6m5G7K2SXl
kx3kI3wi2/zV3JlhhCmnblNfOfeVAwGYjVuLNC1FmxpdTvOr5fskm7qASrZUgKzmHlGoSXdnm0WB
QINdIf21tH/8eklTGb3GIUx5XujDuMCsxkiyZdMMY0ZhjcbJwchQy/FxIHBSYOwqaSI28aiau5Qk
EwvtzwC4ISAhVHqO+C2c2qXuEhLMZQrto6bDCxYjvdpoXN+Hp8n9wRgg1rr/AIz7GT5TFyCQLJVI
biRjWndvHQk5w3WlVoNbpspFo7tTVeyO9I2OYgj95fc7is6g5+RvYKQM2HB92JiaPDeq7Y6KJSMd
eBk3P7obv1WfLCIqTu3KAWoIEfzuMAtumY/Sttoolsj1qiVsEoaIadk+K7oO3flM3gGe6nGp1p9W
1tffrf2R/uxb8/0iVHZsFahpan3j9jsKBE4Ber6O5ek3t81Vx9/H4QJXo1l507Zi7iDR6ytPlRAW
aRgDUS1q06hkx9ay6RX92IVzY7ssvlafMh8d/hwNbdsml1TBgewkYB9FjZFwMiTD23FoOJ01Db71
1M3viPMMoWRH4DdZ8MSy0gReVK15ttET2zbMFDDLIg3ZRm9kIkcpiCa9iit2qDxyPFJeW+Sp8fBt
tl2tL9fcBdOwqqBT175kAy04d7Bux36qliqwTkzaOK1SKSuL4rabQhHuO9dVHwqQUN1tWO6F6niX
+A1ldBxl5bR9m0wwbRonXOo6tZUXQ3epI+GT7nF0BipYedw3hry8ueyERSE1d3BGmA1R+neBDiDa
ycaK+Itdwe0DGkrTaAoHcKSBqwnew224jjHf/d60GH29h8ToX2fZtOWcvDkBF68K9g+7Lyn4Xp++
tyt8mFmZajqqoDV8mI3dOzw+2++6Jo/Cb1PHoRBJTV23W0dQNRH1Bs/lyxK9ruizd7XRsx5T+ki6
WFx5cA52+a58Q5zY0OrOTtPM3V5gyTEqVp+CrnkJwYIjcJbtEX2fwK1f6XqSj6/bZk6dRy1A9KiC
OoTffWnDYihkHx9obkbC31kRHnWgrvLaTh9YJds4oeycZUF5CxWsBOTzNZheQD7MxcgFKyRUXYg/
blGrmmjFMT8fPcFv77bXLnCol0tATDz/09rq+tI2Uigoa4O78DobvK8Mp3KYvXG23mHtCyJVcMz4
jajBW0qlzKOomYQ5++EunHh9IeKxeSXnDx0Fi2bo+M0fejdepsc/7v7S//nlwfnZJ81lwS2sBYoi
nRR2dD07CatFhlTrMzC3vsSEm4S6asSDP+6ekO06g3VHyLcF0ghyB+65lZHhq6wk/BuOhKhGLwxf
eP3kyhKyELfLotHiZYt8o9yK27SrlCdm8ZSKbh+cZMYb6EegYBPTk30+SQCONKaShPfO6VMbZgBr
vyNYrGOVBjyX3uZj26tYXtC028bxlxcSOCkLBfIV0NavGjKbVo6MCVeoFoeG2gldMoFwgnyx/zF9
uMyTYkjERjHzjwjjd7/S/vHrgEyWNr0cpemE55PmV30UhYSuFiDy0Zmlj3QemqfCAej3keTv91sB
/1tmBhaJ4ch0EczzSa3+76T/B3p+GX25nu0dn/wK5EzvcP/sbP/0c+n/t9a3NtZ9/f/q8yf/j9/k
p4rtSeVKOxz/sH+0f7p7GJ+8fXl4sBfD//tHZ/t1csSfjHK8G79OL4sZardXv/nmG0CsrqEAPIQy
+KpW786a2OjTNLHxPlz9D3C74k07SYvbbIoqdgrfP3lgAtDYGiCZAH3f4sssBRKLlNCkT2Y98zAf
kFi1S8r3wU0y5tyMU3WRJyPUOw57UfSOVPzik8pG2EU6ShN0QVRWBMqCQPTbJ4e9OD7ARkoc32w8
hSEk3EI5GwygWF44inExIHA17l1jpYAZhoGIiqiGejqe3V5Cd7BLvYuoViZM3ruY+BBzBEYxGdfK
MpSi0y+n2ngjTkjBX2bXY17eafIeHt4nD2QPEaGlxzC/xTflDZVHI3FcP7TwgGm/fMCLdFokqCBU
8/M0/oeq+4R0L1O4WrmzawC0BL6nbHzR0FnkmJwsL0ORWxxpibFJaJ3VhJR5Ck4VdhVGWZLrKtsv
nFtQ0XU2MWgE0Y2TCVpgkKVwmd+mUTlJBxm0+yCrliBY6s4xigMQDCUM8GGSDagc2zRk+JBBIKo7
OcyAoc0K+SrmRQk0TQ4dDbIhac3QMYNW/dd8FqHFDT+AVzlD9j2uyDUMgMxZBHzhJIzfxwPo62qG
A0ou0cbk/iYl6xjnnORsmZMXQMYhgNaYhsjpuEzhUBYRHENYhesHPUKKYECm3NlgNkoK6BuX8pLO
UM6WLemHyShhC+4SGoLTR/vzM8A9zWIC9CUeGWffUdFPQARTAcJLTDgV2LCPcjdiP3sYKizU8axu
a8sK6NsAlUwjXECycCFEYEDTwjuMbirDjNsCuAUCLq1pVpJHPHSNRC02fZ+VN51v2VAIv4uGK5bg
M0SV5wXZVV1j9KmprggnBjbdqopl5Ew6RwFHQU7hGbSNw6RWAJGk9zzgSZFfF8lt+a3EgpL2+Jii
D3g6dHsZ5gAvaZkSTF3LkcqxnWk6EBMquixK2qpxaq0ssKCwbgPecWoVerjMhpFeUAR4XOB0TNgn
5q64PQLNPMYoJfQqx50qUmVMVqYRl+sRxiv97tCZAO256AZJiykGt4ASE3iZUWrWjLEj7bosdHCj
p4ROGX2jzTUX1eZttCKvMbT9hwSNGrqLNtZVBzKGHZlmZSRxPJP4KoVWqBOgeOLrTCAS4CWbILlX
EpqjR7xStLaw+tcAvDgfxhdc3YVxrAU9E/pQ8GdgToAJwTFiPT+aAOBIRohQGFERnIoBlzUZPV4J
eBGhEGKUomcGub4BahoxVnXngtFvzNDEqpC6g++3kd+R6IhhVogL+AzoVnUZgO0iZYc2stNCDLoL
D/UgyZgBOxCQY8tEGgkM4v2Y32YKthlTpSGw56VI4ul9vlxO0wlaqtzkw+24vdrBPRloagovAr1c
OMT2GpXIrwC1CfjbdxXHesDtL3kP0utkFBFpVBJ5ILRR1wY1tsBU4Gktin9y0wQDSZiDSMeXMI06
vhmZg2C42TQpGEMiAKRMQRkLxSu5QwjBqN5gvYE2osNg7wyAOQ0tY2tOvGCR5CO7bxVlgq6Mrg/y
YoGIWxMxvGuYIZwtZB1fZqjDAfwvdJQDYvptxDfuUokyqZm4/5H1JuVygfHAvgymPFBYNaCubuWo
3dJ+XqYRkDZFjr52VIjOB8DK/4cYAbsYPXRtSmFKE5mgli0hYcSUlhvFIFMFwukH2BKkBBF546Vq
o+0eASHeI9Xbi32kJlgFzhBMIUpp/AA+QAEo3Eh9EHHEvlN26zSFS0SUeLSSSOPTO01PsrdnInOJ
b/IRYGNGwAUFYyEoygDFEhUCEMN0wZSNkoXkoD5gyRjbeSS2ghQ6ppeIRqg1bEDjAqRqPCIgJjKN
4Iqscs1BIsD/EUlgJFQNYZGNB6MZ2TwiFBqiDYMMwVLCsLTFcWTIowqtq6iLXojUNDax0QLkprqm
LDrTGhUcjwjaR9UVUDEZIg1cFNqRBUg4hh1YKZf+wz1Q/erOKFZRQRdtLrwY3QBEft0A/EZ2USgz
zsfLDn1hSLtEgxf1On6Pxs2MMisXIboSCQ0Nw5qViLsT5gyGpjSHDtLugNq79T6nLhBLQgNETzIg
c2HsNy/ew0LCAhfZXUKALZU1yjD469xa05rdi6cK7mWVSuT+bvRa5ePRg2DACIMvFe7Ar7AC/j9A
aW2RJYquBLCWAbi8SuR1rzolo+1R8sE0hNuqR+Fe25F/KQBYDJigsOACC7W491YdU3CZDhLmRyKM
SESDJYiRK0bhmqXSUNNwYQehNapAq2KvhZ4oZR4u3T3ETPb5BPEZ9h4hUgOYG94BZkWhLx5jwosp
ZQaswqkiHuEm1LXKKCkUyZWU+Vh5yC/CKBG/DUjPnBDo4k1+D+MsHPZTLbSenukej5+cScV9xoOs
GMxuWdNSVmlOGGSBg84HwHkhAdxl2ISxPNBdFquGhEKP0A5pViTCQdzjEDC6J1AWaLCJ06ULwsUN
D+YqzRA7w8riasE2LF8lAyTRYYDDBKNEIa0BJAbFTEPI6lYXX+N4kcUodtIGUKAjGLyh5l9niPCQ
tWR+lC49bFGRVRQYi4lYVHH/Jb9EoQzODc4hhZTSY7C354AvjIiZVk3jAI8wZdvVa1yBS2Ts4bgx
EnTJHcWURhow8ejTYlmw0yh4oD2FkchphaHAkrnE3owIB4vL1lTVWE8s0ovLFjvoO31NVhqFEidh
TLg0n4xS0+YIGdf4Mh+Sv4lzxHoepFWHpC66PS3lAritbrYaD54O3lJ3FASGN2jTgd4qeKYTWuvy
AW7/2y7tZApoKmGceQe7l4yNCOrZYTaefYh1vYjr0bLujtDL5vpm/i7gvhMaExxmroiIqKYlhcm6
eAAI3KCazV0RxuOzoy4+Pi9lZN9+7I/Ey3UjkkOFJFWY5nuERCyN9qp5XMzGTPmqdumChH40Re1L
K23K/wa3AlCAZnZIYpGPhxkzzEQIADdBTq+aLxAZlRDtEjzwKsfz2sOYgZILL06mSKEJUGDfikAZ
kNDoPkVKIGrhBexKhQSEW+KuzyVolrNSzrIqwrg6IilFQTJIOJYlX2x0oyNJqaghm7ZALM4PcZgF
oZ3oUt3F9o5YB0rTP7DsTNJ/lPT9fP/0x7N49+hVvHd89OoAszWzx5ZoaLrxq4Oz89ODl28p4zcW
/PH41cHrg71dfIBbt9JjylKB6C6cZ4pYYtOOeKg08rHEFYROFFIQllIvXYKsDkqoKMye9q8zLCsT
+NBOZAsps7+lHLcBukweRKwuF43tHld1/GPas/kEtlmoDndCiinirJm3Or1oPyH6ir7TaZU4p+iO
VsYt4JNbfOTjlgat2zQZcwyJ0UjiTWLwc7VaV7OxCI2EeSYbADgsE6I7y5wk+3lMEDO+S8fIkJKY
1yJmcSfkeCiMF7V5uYk7QRaDjiWeFqdHNlCgGwQgGxBtOphR/ItSH9yWnORWlwWnXRaHmo1HojO0
+3iaIh4FIplLPIbBHVJYge7b6jGNDt21ZD9LB4khLzd+sElraoV6iAxEjZL7bYUQSaaXoDCEywpc
qgvWbjlCi07ZuAyQvgxAq4FwrrgPNp7S+6llgUOSXOM4YKlhrYZIno9pERm+R8n4egY0ESxD+w3g
DSD1UNzU1U1wUtaIeUfZfJStE2WgQqtqkI9b9nhaPTJbaJ0ZeW9LeGCaPi/tlBE1SruZRb5V6JwK
ocRShF/uXGEWJOZ6TQ1q9KelcLaUmXqKlBDRfqN0KOycgzetxhZw9Y9mJW1yUpY5EJO4oKjcKa7Q
tWeYXpFzBTE2o1SVpx7YJZ1JME7IPS3ykYSc4qAuZGGGIpHRyGHrbE4F/Z3uWHKbCwCiILzu1nJW
iGTcKBZxWHuDXL5lWRLRbrNpifoX4ueg9VSYMaBwEYfBhcASEu8itmFWpFFKhJIOWeLHXkF0S0V0
aB3uWI1MsY3EGmKCrjF/KKfZlGR8sTmgkdyjquN2BgcOM0/h/SBLKMS8Mz5kzKc57AECFFoLMRrv
9IhtV4vLp7SY4e5ioyXiAyV4040hGUT7p984lI++yO3ytJ+rPZZTIxkxX8nrzWGpjILAnZSOdgWx
heinbtNhNrvtmpDMWuuDizsBojqflSMeBiD0Ip8UCOTwRFzQcfYkN5XRRlYp69aUS1VmMxgl2S2T
hEpk+m38Pk0niHoApPQ55GrC2BAGYGLKuvqJMmQCK7ksRUyIc4tM094i2k7adku2H7bG77QrektI
ncX6CC3kndw8lCiikcPAiFGp5rivLsHCg7Ti+tmLsFvLjhWZzXgz/SBKLUJDEfTLlNeagRMRbFOT
PLEiDB7qQpKLI5KLY3ozI1r3lsdbJUgPbQm9gsrIWlA6ty7ulZs2FOngTGa3GiWXcLw94GPlG9I7
t2lKNgkyC4rHp2hz8UsBIgGxkKb2+dJAFhoQRTq6Ej7fIwPEif+yY1RCLLVhawfiyFSLiJphZ2hb
YIEQhQhQKv8S4X6VgpB2a2g1pViXoYTkInE0lZJxDILjYL7PvueY3hJCb4hQNM65AYZKvLRZZlUw
LYoQEIw0YYBehjDsoFYLwDoZoB7wQd3YehkUBFlElibZmBohyzvybIUuyLKVx4up90ai20A5VJUq
NChRbCBTPY6ufaklJTUgzoFKL3J/I2EiVB0JtI7+rfl7vGUwyrtRc5GKIImv8xxIiQQPe3p1RSEL
cptvZX9DWQYMRTH1R0+cLiVRxxkKxWmtiVmRrjM+gBnUqDBXLlJsFCHgCSzpvkDBmAp6yMNAHcms
IDVJkd4So4IEC0De1Wwke9h2ZBLW9tDFZkll8IqgU/vXGZkR5Dk0D7QwnyjdkbrrWEoLE0RRwzKR
NKRR8O9Urm4WyNWBnM0AOfN41lAT+dcZNKokVuMHv/KyBhsbyhi+iGRSpIp+TRwsh8AXxJqMtpWu
rWnfMhGY8HKwc2iObiV2y7JpoaVDElZp22lWt6yPpsblZnIRFAIyn2/SJkcZriK8p9nJKslJRaUe
VWFKrcrUK9xMFwxqii+ViBZaI7MkpNsKb8ewsLjEMnLB44JS8FvAmndpKYfGxhQMpwiJhEiAtMzZ
aMzME7Ugevj36tRZ9wRpl403rnSNBlRsi0MVIrcCyy11sxj8RsKByhoKB0/xEmuJwK5IYCxqWKFW
akPErurG85hzo37OlYqBxH0sIhI+SRjwEkOJpZooUUoO6qYrl8GMMCiRTfggJZ0yTatIr5EHSzmZ
KRo+3SM5EJFRxTlU7Fr2ehQch2hhjdbVGcNjjkSWZThCZHNJxJ1W1EMxWjKkdqEdc9YviZ74NoZd
ulFSeumKmNQIePKCJWfK5sLmYkKLbWuYkP1lwcOdgr8QxQFzPkDVBV/6GPECDXqur3GVVLOKT6V5
kJo60FBUETC2FXvcQPB08HsS3+Wj2S0rn2P0dyclSuHOj+log1suC8X+WKNjxp+5P4yPFLqL1w1d
B1iMLlo+YH6sqAb9a6Qlt8AfoVuCT+nS9Y1WFGMnXNGhUfTlbOWEOgp9cyYjlBQuTpqjrD8yZixW
mcbRhyxBI3smbi8olyDaZZzem0hVTDHoBtQVtUC3JBXCzBso6bKIB8StrFB/4EmpxtXQLJO2XieO
XzF6ZHJj/KCUGGI1OhYTMllFpumPxwNWDOliqBpgj0N7vxQOyIoipVHgvYFMK42LS5QLr7MjMh2N
gAmHm1r0SsxFEPvkCrFkYHINSa/GuFQ4m6yUmF/mNlCWGgR3dmBntvW7ilyWnCDVUxrwteMQ8xvN
XLN/8JNYy86KyNV8IzXANLNiU9Y6JPtmiy1lkWhEksQ5RfVsThmv0nDWYuJ2QszOQKxUoswy6NCM
/CAv2EiPDDNuUYE4TpfRYYfpBcPni31UpC6zZsFz3QAR50WCzziiRlJkSllIeba0lTEKuixWBo6h
j/TtZVPQjDY1yPISu0mG4QogIrGlsaw9SAwvx1DXQjrrLhkRJeM0QIfcEd4pOomoCE6dU6Jp4VUm
EhiLaMN7zSc+7NWViHSiNrO5LCNIu52kJKW3BqQaceUL9tLQ6m324l0X1LVSYpx79hkWF69QmyZ0
0AQag/JZRr18x/tX4CVqJ8hkUIW5h9NgS/BJTlQqvUNYE3VoNFFnJL2L2KIE86aV+UicIfSh9WXh
7s3DFj3GggTTWJVa9th8cWqDAmXj0TzeynJE7LhPPKZ1uhXOCVnIaJRiWX3oPZPt8WUwna7QVMLT
hgYZueo9ezhsdC7LUyO27UUKdW1xJGIh2TmnnXdAiWv1FSxipdS4fvTkNiHbmpEyguMgCST4iNTK
2UjeocZt3KBkaSzAEQONqBlavPPoijwZ4nqRkdyKQwtKbpGrNT4MeE5IcjWeKn6RdS/ETdknAtUa
zjTY+FnXyEold0pcq6kILRpLVB3G2hSexSNqPGyvT8pocqtgLhsNLJJ7hVxZPD62rYd5G0g6PgYi
tSA55ETnrWNX34gTbM7IIuoBjxPLc8UpR0QQ5S1pOZJBkZfWg2xM4XeMfq6NjMKIsmGgRRViXzSG
ScfX05uOZhwdETsPOKIBI00wtpUAPsvD+8UUjrJcs08fIRik+vYN1Lp6MiRALNginYt3HBW6ZOtW
Zu4R23h3/xbrp6wY1952N6CFrpL3+ndKLdw3yEq3etEu4Py0bspaToCC09BEupFaWehRmEdW7Qh8
D+ESHKAOt3JPMEgziboFl5SgSOVFKxS9piZEqKuF3ewPRmYF6oJ5LG4WCzrK4MEXjD37GkzbrVKB
skqKWlOLzJLzmzwbVITRZjPYsNC1+vC0kEy3EclEFn75PTsnse09UuooDriGhWAyhvBxejm7Jj+8
qhDdqB6004MvhealMgoYR14sE4gsDZxKIsiBic0cDy03AXEWI+AwV0zkMV16XCJGCytV2F1CDSka
zph+IzAmYVxWAlH2UFZURTbjKaplmktFpaTWXc/gNmfO27WPSpj/JIdCBnXFoJNxkgBxzRTYbl+P
Z5jHGEBEqyXYD8ioJHYVQW/2Yg5Zz+GhG0j7yjSNqbaSGCtVAHl/3KOkRG22HoVYX9TyB9REmC3o
kBativ8cYolRCcch8I5wN7AElQkbpMA5C3zEQDtqo0+xZnCodMuxQbXC3jyWA4gN7nRhKf8aC89o
oa0ED9Cz9GwyfB0JCSSmfM9hxKhpng9FsWGbw6FsT/vqcOZX1mqTqEzZDZSiROJdlLDR1s1FqZ7R
sa1kJg3JJokuqrx9Ul8CzoMxFoZ6Ala3vY7Wkb0lc8hylvHsXdPz+DbFSWTlrWNfrZWo1oDJjkY3
Y+rhbT0W7IwOQrTrKFOajSkwhOiWbPSmnZpGCDqom4NjiFLQsW1gLcL6QplLsmg/qVhJmNDwmsYh
wcPUIb21f5KAt1HhIMjAJ3V11hsfaguU7EpruggWxMiDFoJgnDhFsdCrtJaVopsSM5NlwjZTkgLp
Q2bJwaYWGkqEB8dyRv1Yh7ASLRgm1ruromWhCIWPKPqEs79OGj+kCdKSaBys/POI62YEizMRbkFU
p7Z3iqUe2kq6ioZgSyBRbwITjCay6iiN5dSUU7beLZQGm3C3zeY4Os6gCkCQ2TzphM7tFpJQsBa/
UTLB0/ImrxclJKuQoacdDE/AyMvGISSqlDMQDkFfpnK1qE7ywgieyElM1acDRGtHTSdGokfmU2Pn
KFiCE9cgK8TNGkM5+zInyzhUE5OD7pRVo9oyGk3yuekIwyMhSlb41ha94YqRiZfm/umqV4b9mkjt
Rg78Ce9l33/kA0DBUs346F7XpspjTAdNPu9WtTaaaLDhnVxCsFiXLHLFdemYE3mb/IX0Hrdw5xOi
bwt+hlG/T4txOhI+DKmLjmadPKNveCfWi95aALosUXRJjJSIj6QrzZTKMcfoEG5t5jDZYvUGhd8a
cWSlIyHjMAdDYN2UITLRSJHjaIxyP1oStgRKp7gaxj2KWhbtoVrUKHFQkD9rLV2yBsBqF7QPFPE8
CuDwTrvMecWN1bhhI66FuxyHxDyu8pEZnudGsszSQ31ZsDpfT4h8zeNaM9EYRVjLlw/LbEaH4hW0
kBvZ/hIyOIIYpVRk2ZTVGa5ajeCnwvGUas3YqNu42laZHK2SrUWQalaRT0ApSLVHbC9PJqaJyEBH
OoyJ2D1UpOHDXFHV9/kcylobq480STS98VJwEC4l3oPImaBZE1z7jtm7Udeo9SfMr2ek/BoXlLMr
OsjlkI0R0g/1jF1wljIz9C4ydKWSsmVTXxMetOKiyBNEw0rUMOQX0N46kyOjzyMeQmuBbGSv15bm
8sKcFIZRVEMxzd3FqOzaC5QobZxe11Gjpg5gSbAuDNH1gQL3jR4MsKhFdpm0MWARgKxbqKbhzTiE
zx1JVKMwgk7u8kzgleg+Sagobpm4z+i+yPFbJAJDeIj6llJ6A2QC3AQyrHLrYuQDFUOCbjk8GtU2
DROggnRk2hIBcLwaGV0qiqYkpKAGwNZEiI/IgZhYswwd6mhLv+EtVcYn+sZHrdyA9sfT92aowdSk
BSJkUUK4lzSq7EkOgD7u12j2yEjcdaQSfq1+Z1D6Oi0rqkntwJio81aQD9hNdplNtVBVx6QQM5bq
fFwDpssHlv3QgXAE6Z6dc1usLGuvgg6LEuCkIUMmYX+4/0TMV31t/RAD77B2RIXzeYzHEo9YDz/y
FtEzwJAAHqsrvZhcS4gJY/vhJp3qnCk7sQu8IyTQX5LY3PKqZ5W9dkPGNxwBxY/xYB3l2A31oLQ7
cOxJbDDNnfAW7vr1YgeFYSKhkinVq1lBXkMunTP2IjIsxdosRlCkYAOCcViVG3Kg6EXuqZIILKxL
jlMMOjNQejk+jXLTWxpHcVu2tT5IrqyuYooSIYPR+Is0+QPluQqQNo3/MhteEzHHjg2WLQ1HJYiy
8RWyP6kqdCXby3eiOAC3cezk48EIQSIawPHF9DjdyIJK0hXTWhJcICi1lTT68kFGRc5lMHDtyaU8
rBCNd4xClIk/JTJRXXhnpsvibT7bmAAK6UIKBqV4rPq6JsKL0JQ2QaUcn1iHjFTd7WwExzZlM3k2
64YL5lrMoA3KjmyDdbOagPKmfO9b1USLUtlEJFAVcNYcxYRMpnvV+DsqQkWkTtg9BQ8hvROHMyjy
h2Q0fWAfVeusV90nERmyHRCeD7zElGuBWIxoZQKi6LH+Nr0pSFkH8+ApEiYi7ZUEW0NggFGp5SVS
Xsuq7XuPiqH+LIczeVXgJaaN12iTG4aPZmUBHbplPgcfb9LRUOfIwdALYz6YKdug0r6izYYd4cty
SGeEd5mMDEpP7ebtCHBk4cUWnHYpYyYarEBWKWxU5DnCHzgWgsqeN2AiCFszkwubvvGxl2mJNLKw
eLkU/RtZ+k7WhSoglZgWsngoowx91AiRGlzyW7dz5d9LAeutESrnB75TyZXqupAWtYe5CXVg77Hw
x8oaNNJZ7CVcDRs9mRgDSB0MiJj/kUCBPa+JcEFBUHSN1lJwrBnrSC86rhJ60McFWWnZjpMWKxAp
aCfUJaPLWNTMQDGOrUgutomymP6Kv/a3QtTPJtrRhXxOnw3zMa+/BMeDU04mX3F5QyCDxCFd9068
Nj1WNT6DjGSQ7HesPUoFDcptyIiYlGVkkuqeGhtKyfQNB4q9jFTQpHsxC7iEZUjvOPDCZVq9rfhm
LadBY4/VtZ7SK/kebs8oTErVu6u0PM/Q/k5FcaBQlSSXEDnO5UNsAf/lg1FNUUURujKONtRJxUEY
sSJJDFxHrwANT1rSIVB2Y2LLsgFs93WKgrDJDenznSlabpVwr4kOiBGxnko3UkoQp6oTRZQ96th5
g1RmZiEYc8zKiDtIhxwQgk+zBISwxg9Efw4HuGBLExIK6SFiZIKrSEmRRRclQRUC27reI4OX2tiQ
JIYRx7MivcvID4b3fJzeRyL0Lv3YpDVxSYgWQOIWjxWGoI5IyISRAXVLKncpXPQZ4njMWzXJikxH
p1K6BxVYK0L7Kxwnu/vHFLwIc4cS4mbPbOpCx89i22yAR9L4EsltRP1i9pnQTsJWz2DquONuPFSj
ZtX0rgiYSyuclAl24d6lhDEtK1C+cKNWJf9rqxs7ASG1A5vEP1CskKatbSpQjpdya9C6kUIZtDld
OSluo6YUt5W5Wx4ebK8bJ5rocZfCWCkAQlOkvirCXjgLj4LJ742eIh6Voat1Ooh4L6t+p1DKBPIx
0UrY28A5wT5RPQ6ofjD6p5Mxlm8LFTgSiXnDZwuhqO8EfXvaSG9OjuFAgtoomIr4np3+8aiVfDto
AX2p7aI4XmmEV1qpw8/BAQTIH5qxoHDwOieFxhUfweLOiUKDhm8zDn4E9Y2IgKXTMz9oksgxUQqX
a44eVZ0Ub4vsN+RS0VWuGauMlDth3c/RsU5uTDhusxe/3N/b/f/Ze/euNpIkD/T+rU9RI5/ZlrqF
zNPuZls9i0Fus42BAdzuPgxXLkQBWguVRiWBGV9/9xuvfGdJArs9M7vyzGlKVfmMjMyMzIj4xZvj
dnLyqp3s7b442jr6Pdk9VhgZO8nLo3Y7OXiZbL/aOvq53cB0R21MsX9QUWURYoZVAKQ6oN/t307a
+yfJYfvo9e7JCZT24vdk6/AQCt96sQfJt942K+3fttuHJ8nbV+395ABLf7sLzTk+2cL0u/vJ26Pd
Ewwmh+UhKsfR7s+vTpJXB3s77SOC7nh6cFShjBxkuX2cHB4d/Lq74/apunUMra7qQM+67dC3rf3f
K7/s7u80kvYuFdT+7fAIoUN2EujY7mtocBs+7u5v773ZIVSQF1DC/sEJlA4dg2QnB0SZiqRVpWNj
oHw/OjTCiJSFh66Y8NBEQSgE6H20e/xLAj0Quv71zZYuCIgLZbze2t+mccJWWOOI3U1+P3iDWgvo
996OQxQkVDvZab9sb5/s/gqjCymhmuM3r9sVpvfxCRFoby/Zb29DezHXcfvo191tosNR+3Br9ygh
wJSjIyzlYJ+3z2dNHDxguPavyAJv9hGLBdL/9Q30J8IIWMbWz8BsSEzIWlHj/nYXKsew3P7gNygL
fDCD/zuw0UHyeut3Rmn5vcLsAdVqGBeXK4Ckhjm3XhwgDV7gZ2oWNAQIUsEh2tl6vfVz+9hiAqpa
kGUayfFhe3sXH+A7sB6M9R40r7J9AJPor29wFOGFFJJswXBiCciHPGQJTkHktX3FI1C3TEs9nDVT
d8h/yd7BMTEbhWemFsPfF21IXTlq7wO9aDptbW+/OYKphSkwB7Tm+A1Mtt19HhRkAJrMu0c7ej4h
nSsvt3b33hwpHtMUhJoPgIRYJPGaGZDjg5cnMA/a9QbxQLL7snL8ZvuVjB4Wag/cKxiKF21ItrXz
6y7NPK4H5sLxrtAEXmEJFaFj2WIHvaXcEWwfFynoFeLI5skWHWH5nvaExAV4+TsuzPsgG+0pZaFY
vtJFLePasadP4qDGWojQotqVPZZhvopxxUFxU5IbiYMEz0m2MjfotSdAIr2xt0HQeSxTePwMyeti
zCqnbr5DZKBovDDC8wRL3biXePcqAdoM3qU22NVqkDJSaaNMqTQDeK+u8G21B5mqpIHgVKnokI3o
pl26cg9vji4UKkV6iecxlCN07huVmELWYMPIFlF04WTwSzf5kM/CXq0QaNC9qLDhjKGsZFzIBiqK
yhCkWzZYGGurk6xS1XJKlUOK8tl1mNNBjXwfWLWlIFJFu4aewyiZCDv/iINK+W3rlb5C1Ugw2IwU
fQ5seZmALJKyuTLj/hF+x09Ulhsr4ke0ivkJaqAiUBwhaewnrlfgUfUR1eG5/9R+Zw6rsXT+VBzM
Neh2CZNYeKu+lyDbZsmlZOGIulPlvf8UUZ4KuDVhM4xgK3ewINHVXKyLeijoN+OUsHWqcmy8RtcP
BbSoxEL2L2PbLjx5KVEDl0QlbvynNt4XjwG6jibvco26IZ72vtQAXSgTGhIjNBxnGvKPqTr93Eka
CkLqxHNhIRTAVcPm87hBz7zjafsaGcr+p8RMjIjseqSpHD+SSePzIplU0IIWT78CqS/XXIPkmncD
MqlkEHHkvgxdg0f5AIjGCNhDwjfvIdSBRSYyLUeMduKwDIY0v4eENeWJqX3t5Uh1k43qOKKkpy3w
yNfnq/EB4b+TIwiappu7HINVU9UWuLYVnzK9xEXylWBkpqgXH/Zh+rLDLDnLwuRnM4bf8/v84h7N
/JisuDqd3+uKGMfeNICWsYzMpsSOQM2Rdy9H+fk3MMGMyQU28E4gft8P8vOiru33oIr/xjYkR0DQ
/CZ5lXbfZyPivB/Zkg29Q4DFTu5hAcsHPzWSFdijR70+xrlZxn2EPzQwrkrRU7gPvwK/4S1gOv5G
Q/AzGege4U+Vyr9M/Cc5XT24jofHf3q2srG8iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0
iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0
iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0
iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0
iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0
iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP+0iP/07x//
6XX7ZAvlsy8b/2ll/dnqih//aXXt2SL+09f49xpWUDQiXJLoTZu4D1X2gdM3E80RS8wRFZ2GWaNy
PLm5gXmzmbzNzo8pZcIpaSYd3sOWMeAlFOQjkDlAcoHz065sZUXlVX6TLQ3TK6jrejweFptPn15B
6sl5E4TJp371wYsmJK5skTSwCXN4BBIW/1pCm4y+vGsOh/91RUsfFKp0iJvJ3s+He/beW9nJ7wb9
PL1YenO097j2PJUIT0XlcJSjrpyL2pGoUbIZqJKD3qAVKUz+i7xbNHv5U7cQxvdrPK5dlV+ye1jL
LwprTAsZqsohCBO4o2zCafeX/YO3+5Xtfgqy/mUvA7Lu8JmB9MnHdCOUbG4m68lS8gI4x0mqdk74
fnC8i+eTUY67L/wu3XJ1pttV8oUjuaaGY3O7+l3dKf5QtiBcm/cEUhHLZjZ7QFJ8Wn1o+uazB+d4
/sAcaw9N31x/cI6NB+d49uAcD+538/sH5/jByXGgjV2PWf8GaV6n3YNj8/DbzAwgie7OTvW6h96d
IOjhj7c9EAXuCifTST4EtoaPuyh4DLJx/Ks+FdgTbHPTnNutHr9m3EynoF2lJtyaXPRI47epJyss
apUjwYda4jI2k59awMON5E+tNdjTv+WHFfWwqh7Wmt9WdjKG1kQQqW32qVk6uR/CmjnOPoyfwor/
Hno9MFXsgISwCbLfh0rl9E+nuH6d1dQ6ZS9q+ejq6ZAXtSJcpM7Ti6vs6V+K8X0/a13CSlA3pcxa
K+tY8YtJD0RaXqRM1gctlGLv9hQF30vYs4qn51ho8/6mz+1rFrdX9S9fOLUfna+6+a0pXV5gB6+u
56gAOGfQvYYBAmYdPSXtp2n1X8b5+2zQGnZ/u37z17ve3lr90RVRaw/vYSNXe6ZF72E2vG+Os65U
HWaOJRWumFKT7NQmc+/mqllc97L+BXHA8H7Ye3obCLF2bZDCZsEgLXBR5Uko9FT8N3xEmSLyNPG6
x4RgIC8WNCFwhCDW1+hSimYS1qPsLwrV/crp9f15D46FpluItwoUyMaX1LnrMbDqxSi9BJkd3i1R
epgpunC0D8m7eR8KqYsDptUX+NqF731BB5eGaHVgl4KljQmrbzgkzL9rtkjHQ9xVhuB2FB+NELxI
tCJY2tOjl9vJ82c/rE5v9+iyi4nw2u3JE1duEkMJGTs4Kl3YXxVuG91IoWfV6bwrx0PWGGzUtjZl
GVxVQHZCeS8p5Pbi1DZ0YX0bufk/csE47+fnajZvH+wLoPv+z82bC27MrgVtXKm8xDCNDeUK591M
KuS6bg+P0Uu0Wi8l53CIxWEsmkXR/1vnJh13r//Wuc6LMV22WVL8avMD3xwgpe0q7IIdk/sbvHh4
N+wNdXKo8x3ptJ23Thu4CboF70ydeO0sCvB3Q25TkY0nw+bwXhX1DkVIp2yfpO8qpE+mj8LiDEpN
5+2sYLMO0+fndHsiP0He+q6pf1TUDECPQI6QaQXu6hnorOXmynpzWaPKiGNBT8A7Yd4wt7/B+ZOc
9IZFpbJ9nXXfJworw+F04PyXW39lg1JBdQNh2rDa5vysnw2e9ulu/+ll+vcmTsD5J0OYFzjylwH6
67P9anhzpv3C+mmXgEjMqrOd35CHArKxImtNLRl1GoNTEAd7NxizAiObkcmOQ5enku8xXdBFckd4
PORgUoFZEhwV4fuT5JAdJtEQjeArk3cFTARi8OQd2fFB6Z3J+PL7dxK+j00OCKqwwL0AeQAvjdSu
IayO5rJkIvnm5OX3iZSkQeAtgtYkJCHZjabKg5Ms47LBNf69oT1Uz8p3xfvekJrUMcW+M2gnxvRC
Qvbh1aCEZ7VKRxB2Wvf0FEYj08HkRnDD7grc88QZD43eeJ+4YUMNujuUdVx8s5dEtWK7DPFyEviK
nItTPsGhpbdwrGfvu/1c41Nw7Qw3p40lGF6IK2AObfIw7uWDq6U+XRPD2j5gQ7xKhWK7AVv0l2C6
glhpNmpYxsaTVHk53+Z9jGQHhWQjKaari4E6TuztFY7EybvRZNBBhwjgg3eQEfVxrjfMSIyIUKVG
JUlnK6ZgQnbJcbW3XMDIUAkJx8aeBLm7xL4EVk4BmJSmqXFwd1OEsj21lhexgi4eM7lUXrVIvHsn
y3dFOEMXVRmP7jfZMVvxDJZaEUemXXrZHo3ykZOqw8nY2ZsyqOww8JUKSCSwpHdEQKndFQiCSc91
LmY4ArasqXc6Q4YVUXJ6chLzG52UotVAUidNFZmLvlwk8Fg1yeGANjCp8SWwRO3bdHSl3pGzHBp+
k7Ur6kRra9YncllDa7uin2XD2krd+XIHGyksRLXqqww2/+TPF9Xkz0nPpInnhFzcDfNK+iHkVa5Q
uEw2m9W6OM7htyapLjuD7E7GogYdaiS1OvS5d5l0OriVdzpJq5VUOx10l+p0qtwdPfhNjuR0Mkq7
We1kNMkEJaBIWlYieybVqnfIiXB8yJsmBcqS1cZUc6JEDQIULU9zZBAG4TzyY45sxCqciR7nyMLB
j1r6UYAkYISspQPGCWYSL2HH18DukTVMhaDvuYs6ymaTAXtOYSBEnCuqdyq8AJcCMwlhDDlcAS1C
F/kga0YjE5vSByAN3ahIanrEKmhgRotvomNd0PZFCC6FgYAgwEoxvuySxxwsI//81YpsXXVBavFh
yLuOWV8rxLHB6ynMWq/IRDvOGKDyG5q4jeQtbjzf8GRzJ7V8c7KOza8jEgn0RAUST/pjaBWxUNa9
rXkpgW2++XPxDa4TnJbqU8sBsZknFzBEU+8fqGoncsiNfgNlcnoHLxoMVI26M4wvtPlVqFk+v6RV
rVpN0u8eHh4dnBx0TrYPG9KPJjx39g922ntbv9cbdWuObXUxSHA/u2CnroJUdoP3tFH/13mKQf1u
ehcoLyFX/9co7Q+vz7N0QOv4ddYfEvRo74qsWMfWURat9/UBo/IHa/s+T//39lW7vfeIOqbr/5aX
Vzaeefq/jeerywv939f49/Y6y/pG+bfSXJawtGNUqp3j4HfuME1SW26urTdX65WjPB8v7RZLhxN0
xDnfJATGykl6tZkM71eXBrBFLKHvkrxZM28q/8/i37/Yv4fM/3E+7ND9ZXP8YfwF5//yyqo3/58/
21hdzP+vMv769LWYC/9H5/9K83t7+j/tdBDDrtNpDu+/TB0z5v/KxrJv/7O28nyx/3+Vf9VqtWIN
uFF2JUuhisu2kxOzi4ox1l1dXl1PssHVYG1tVFGGNjaez9Yw7drWrb/qK9XlpMax4VVM1v+s3Fsw
Eoyz2GMoRwVsQ56nGt7BQssUb0gdBOScvFRTL1CHWHmO+XCNJ0U8KN7dNVNqJZ0mFA7MU/ErWoKW
VipvGCFMY7lgWC52PSYEz/SOPEIRheGC3dcSCYXY0IbJlTjgkRUv2k5AbrnaFejF1vHucaPieQSJ
w4MVD5g9hBL2EBLNiSABEagA2+8i1HnmVK6sNPURXMUvTa4QNIsBg60APqjQMf6qRdidZgWZjE58
zU56PrhUx71v9cvhUL1z7krh/Gj/ptPlkb4VpdOl+a0K6+YClmHXYLnJ+Z/6OaMH++/do+m3FZgm
ogPAq6ykSstmtfK/cP3HMfpii//M9X9tffmZv/6vbixvLNb/r/FP2BuN+O/VxXleqCeGvde/7ouK
wL8oHZx82QPOkU/3Q+v9NmqnCe/yQALKNZI3A7qcLJ2YesYfpvdoW9LWEJTWJzFi0N9UcQiDqUty
lHAVWoUUby/2ucU+98fsc0aL9QS1qUobiZp/pa1s0EDrmDGjHK1JWOd3gw7maI/dlCJUfgKbMIq+
ERu6JCvLf8YO4OjkqLEkb/aRIG4/0VArvmVRB+up1Y2FkXjgc65Ql0pQ3Ki4QRZDYmogX0nR/IC6
YWi7TL3f8tFr+JmNjqmKilZ1cc34H1RBT7JNXnqa9F8OthH5UE+WfgL+G6N9g7rPpTL4vnqTv8Gu
7NVrVVRvom0TMEXN1GF0XaNsPBkN7DIrpXrHJzZZCPnOHdgyalNmdknsYHsJrwvaDMtqU//+IyiF
Sfuk7oL/RrsPA9sx7yEhvGji+FJDbZI1gh64pZj2hqU4V/NWwm+Tmmri06fJej35zvp6uqnb/+dk
/SysX5cajGbN69b/67Ww3hznVgehiljvUPCDbYyEvlOqorr1Yv+laBqqqE/vDTDId+cSzSjUe/rR
OZ8ghIl6h/AAb447++j4vue9/Plgd//nztbbrd+9D6Sk2D7Y67SPjg6OvI9v9o/fHB4eHJ20dzro
mtM5+f2w7aXRtZ50tn7d2t1DJ3EvCXSI2tTZ3js4bu94X3f3f93a293pHG79vnew5X89PIBd4/fO
r7sHe1u4InufX6P7/c/tzsnBQefF7s8lRRPkwnGY+81++7fD9jZ2Ty/5XpIXWzudn7dO2iHlTvaO
O6+29neOX2390tbkO0MrT1RuUQCREcVGZccGNIMtYKOwRwkGfQWE1EowSvxhpRIdJf64Wpk2Spxm
rTJllDjJRiU+Svz1WSU+Svz1eaVklPjz95X4KPHXHyplo0TfV5YrU0aJk2j6MPpCu3PUhhdHJ/xV
E+jk6PfO1s9bu/sdaF2bybeiSWONMH9Zr5SPMKfYqFS4yUQqIS584jXIGeGG/cqMr/PaHV3nU3Rs
nRTewLgFe8PifPQGJVqoHhKvUeGAOAm84XC+eYPhfLOGolHBtbGLPgkJLoi836AIhH/xjcwuStIU
AOdMiaAl9r8bq2vrjFUN8s30pM/WNzaeCHLa0kZzVdcvu7RAoJPN00WW0JIv7Tg43D7YaSNtkBOX
Pyzbb0+ApvR2xX77YncfgSPw/apTBjIYvf7efn2IeBf49gfn7YG83VKN1LJDtLnJeILSkynB8LDX
jYb/EnsRvOROBK+pD8Fb7EL48kC9rBs6U4OvJzfkaK9C74xHChtbsr7eOoTWf4y1fpP30Wq0F/AR
HU+qJb2BzxwuoBrvF5aNpgzVaAfhKx5Yq9GO4sdcf/ykOkxBFzhcW6LD0jFj7bX3fz551XlOg/y8
bb9beYZLU/Ljj8nKM/v9szX1/tmaJf3JnawZbAxAYFp52RtsojiDFZm3o+J2Jf56Nf56LfKax1N9
iLKTLZVyspWGI25u8jH/FLigweJoA44Vg+wMb86EniSq4ksjqarVg1EgBnz9IPi5uKI0E7G475KF
NJoIkyX06IrsgWR2+yVR8DUgGNQN/3VfI8XgPf4JPqzyh9Xgwxp/WHM/yDxoCQHdj45cbH4Y2fmS
2QqOFC5JFEWJcG6Z8poCFDofrjIRc99n99ieojkZkde64S91N1IjtkpihsGbeKbsQ/6XaR8BhKeO
1q9SHl+A6MXfArs51DEV9asl/c+0P9oQfJvgW8scOj7WQEczrojLpsfS+rHmkneUIt50+eVSrQp5
1GHPAkVtJPcZml0FlQsncDAUZlxZvh9a8a6Cz+US/wxHCbuK8rpbLbte3o5wSyVQP5kPj23MUEvO
zercLeC12KmxLydSzcyuISsDbST9zcCki893fuI+VkmD3k9+gqfVZ5Gcc3eSrTB1L4O6fsK4boqg
EabVH51bSNPX09XNs/oXbKBTkixEqxvP4HCNln6m2uUzPF+771bOopSnBJ1ewb1iY9QOn5VqxH2f
33ybry2G/i+spddltwmzJ5Y3hbYhvvuANWvTvwnggLaDJHImQIidNTjhJT+2ONmPyQb8rNtbMexD
sBMjOagK+BnUcFmFCdX6qKbWJ+mZvOEfn2ipllf4+Kk6rbti9kgjXLM3VdlPoRlnDXu3bthSwQo1
la8qSjZYKl+EdARvQfQulLQaKv4SYTrShSpfST5wLec2QzPDzUyqEx8sREAmcZGl3hp2kC+16k0n
7+6l4hjIYovrGt6ct1i6r+xRNMOwbp2EMLRGAkqcqxzSlIbrltGMiUdO2a783lQ+MugbaATgZiDA
OWWgkHLZT6+avJiSre1yQzghkasmGrIr79Y2sg/G12FNrl5B7juDLjMX8VM9KnfQ4GcDLK1WhVVs
6XtrQXzCd9Yqkg82mtqOhuSYnW6JxZXWmzPYrBp0uYF95P9zmxsgTia8IejZwKBHZhJ6d5x2319S
UieMMfIbDavNW5rpDUuiiXopQdPBfe2D2tVr0FqYYyh+fsDfp2rqN4wAYh5XzeOav+zzmvkrciXd
MteqWMUyrkwrFqEfJ1zYxaqll5NbRctZpnQ3xg2Pk/wkzKTPLrPqVEItnOHJS8reqfiKVCKew+p7
PXKviLXcDmej586X/88S8vDgVPJxFT9ulHxcw4/rsY+e/F7XvI+etoMlb1CEMj86hHnu0sXp6Xfc
Vf9YgJ2EFkgY8Cl1Zv2yWleePbpaPK1OqzRWHB/PmsO0+75W/dMr2MKl8VZTi+xzmvTy85r0V6tJ
lZhwY51jfQHIWh71jIitkf5pTD+Xrpi21OA03+R1D9p8igtOdrX1QOMRK6+j8mQXNZXVlm6sz3wW
VInCM/xZbOVFtRsxodFXQeZGYq0jlThdrbQBWa2Oq8eAoFHtHeaBnk8TrJyGRnrZKLnCOJu18aDq
kSOdGD1u8t8S8PqD3GMQJicW8lBxyrSYtZ14oPVkq3X6RCmbnhhWmkdtfpjpKbe8dAec54riCw+2
mfclBT9EeIkUJrzD2lZLkVqrvqiauVBvJME34m1zB24r/LglnVftrZ32Ech9x790dvd32r9Bezac
T7Jwq4/PZl4AolfwbecSZEdlW3N6ClLkGeI+4H/LL3LK7tx4P4RS8VKLC3e/RU+3rWhNllT4gggB
HHcrVhK4JqP7tA4g1U8Ra/I8G4Bwew1zZtzrU1RgtDVJbzCWhlWcsO+lPKAjvYL3bIZdUcOQ9HsF
HoZOz9w0FEjFcnWll304skJatGWqWQskp9VyZ4R4vN5uahunU7q1x6tOTOxVQtuRlRaHLZrSvmP1
z33mMpXy6bZep0VHkUW2AUtijp2MrQ6oiW2KI1L6xbgE0NKboT3HiFFxvglWFq9YOeXp8pl9BIL3
8PGnn2DD/49kxbnH1p+e+Z9W9acN/9Oa/rTufNJ3s/DxP0CyeGnatmratmLahpSkRbyFKYIG8jB2
zjGOIKX4DxJXKjHGQJUNnQv4SMCnAWyrOe6o2hp2wXV3XGmB0qMgHMEArMBCm1H5RjgzJnrQpa43
jMhu6v7Ayn9qL23NcFU785nKlFbCmtzLeVhT5Nw4a/rFuKwpgzOzI/YafFY2wvhHxjiQ/SURq3xc
Yt/OmBneupBoCXYysMTq27o9bSz536755Rw1f/+Qmv8aqdkX590SrEaVDLzLxOXDbp0G4kPvFhRZ
lB2FS0CI9bo+T+u5VedoqkqE0VXxBZyuy+i6ySsf7TH19uES50nyitjOP1roav2luuxoYa/D7gjO
v7B06u5cqHhNfUnXgDyCsxssM29qg1Ua985fc5vhHL8pKEbPbgKP2bQGWGZ3Eauzls8nfjPE/th5
O+R3MZbyz77ScDUCYUNNWd7xSQzt5Hvdb9dRhpdslxSx68OY5c5wUioRJzwuS4Xzs45uSFBU01Ej
RiXFUNTmBrtzTGjIIi6sz0XvH/advnfiRMgKxuKQpMlSUkxugHrDGlnx+YJg3QI6uZZwCFzET8my
P2n30Mg34YwJlc62sCjCFhy7lMECGEuBACswvrVXjLqkVbGQYNoN4VjHaOY6jhiLs1JS2h1P8LLZ
KwltKuiSXAWLPb9XuAvSSr7PxcCIEvEiKW6goIZX0D0i/CGGKDSpn46uVEMw5xCvmC8wyCAiJSG8
EAfaonReOeci20MVeZeiY0vkTVi9r0eTAfAMh8FiU1rESSohjneDTds2UqRjz7DaTW9QW3m29v16
Qw9cPbKTWQPeTIcIS1fjwry0auyX+MJTpdGJJgMEWcWJeV6tNv8n78mlqM1QrtpTM2TLZyc/o3sY
sWaFVDprr/WKklynasqcTSv7dFOSnelDq2+9uhmeP3lOXsKxDBE4xpIuYdGz/LhZti97BZFNhvPm
8w+fvP7lYvxrnbXwNBg/bCFZYVZwC4qS41mZ8YRQBBfVSK9tedythmYNr6MlOnM0jXqokp7iUfe5
3Ij6YFYTULXhVOkrjxqlX33rsvrntl0TPL24mJfW3uBHNkb1DY57eGXMvXduXcO5BwUHVAoIEyHG
NPnEGoWWU/qUNuOct5M2rOafOWsSvw+sPOK1u+zdg8UA5mQJxctPnvb+TnobZXLjz3BdE8gvGEW4
pCa6RnHdGNS2oAlSKaWTM8kNleRK0D7rA7VclreMZOJLkzJQFYuKmI41SKsLnbp22aldyxHThfq8
M8xzoKtdVjkSMYY7Jh32R9j3R3bJn6qBTkH6KMOzgIn434//ALLTl3T/neH/u/F85dmy7/+79mx9
4f/7Ff1/ewN0gzSevhQ/Kh8ZR2DGiHGAOdG824bajPj/bmFcqJlOwBrJU1zxY1gBuLzGPPz1YtdA
sFrYU1I4cGBz8sm43MeYl3ud14AmbhNgp3E5dtOVvT/h+qzPdY0iUPQ7HGJY1X18vNc+eEnmEdpr
edRXX4fpqMjwhfJXprm4cFdeuCv/Qe7KlnNj1QbbqII4edSGhu+3t8kdpsIAtjbkRk1DFFOwE6U9
8ATzq35+DkK9Loxe2kUHpejj6U6vGCIgfDZ6kSqRXKmk3W+u80/kAAu8sMnrES5QHVkilGrtEgQl
ws4fi2qt7PiKUCUtLMx9bZcJ3+2fpkXyQpncY68xJFNJCxoJGh4iOr7R9UZaZcH5SolGglMF2OpM
TWy/GVSz/orof9NqVU7u6p9au5uIFFcLDj2XVVMvFIey5eieNopB8lGa8Em1JTn9iPcysichujB2
of4pkfMK5KF3Z1WnnnoZQHJAF5ZudU8NG0OLWgZ8mI6CvKr9kt2f5+nogjh0NBkS+kw2jQSX1TcF
TW26sfuYffItgEhWzyKsXnM5u17G9iHLE/ZyicMQbh+b6uaS/1ieQJCxE7KbSUD+NqUp4pOFz2os
RzR3eGc+lheu7h0OpFc9DHNRU3OMWkj/aViFUFDuzlF7a6dezolywasKeg8c0BHE4fAwzhcGTa6i
FkzlyPHdutJxqFYrSUtXmpDyffDVpalFETg64y1wcHDXkLyKZ0CUmJdtnKT/2pzDZhghJ3w2b30l
brrU7KQq/FdlIzX6FvszEjK1erOcxPWHDBdSBV8OGd/a76FcM5xWYoDN7mWjdcMlJiflM7fi6elr
o3qo7JG60SoF9dxqXr0dofrgwkwYdy4Fn+cRPuaUOxooYkqxX1AGcS1VdQ14Geb2gjqgXzUpsm2/
tmo3q5mew0mljmqc97ItcpRd3Bf/VTcju9cE/y6z06msPoWgeClHb20pzknS8BpWnyn5yejPJef5
fTBFUmGmlC8u63m9luqs3GZDsg8Q7px5BWdRjO1C4c/gtEcR0NCKTzCNyBUoYz66TDm+fL/3Pkv+
O71NjykeoXXwZa+O5pR5V8J4cLAmj6SGZ/mk5iNqiJDXu2P73sI2trP8pDl2hKUsMiaZuqlnkjua
XdPwM8qQyA3TS2jgyWdqMRSc4nMLoY1ljkJml4TzKlJQPG0+f1q6yy8nWZjH2fCVQzQeEUwS2yZ/
rjK7ef6+Z1ePnnxBqmJyrmL1FSU6TKdrnq6zvHpeb+3q7XXYTT/D69tB68SZ10v7vX9IPLqHWber
mensz2/1tRd8bgZzlqx78xHNV/yr+uyUsU2xKpShKl6jmMu0a1jVi+v0fRa4GbLFsjSc47Z1pXRZ
fWDXpoBu+BpOeP/DDnAYnkUi4OmQS+l4nN0Mx24duNqx+JFd6A5Qh9B5EW/o4ITZddpOdkF+KeTH
OOlfSGSsy0k/Ic0b3fbkJqwKBcujjQjOzjdDHbdvLKVb2Al6YbucDLqBdmpb9hnlWseWHoYQKUYD
yeg+ysTmqMTC71xDD4G1NHxDSKCVYqy/khcZB6XErcbeAsLl9LEtt28CpjTfhOb60n3Qa9OjekAx
epSFnIUjGIljhA1fjSFnPKLdKssqYhJaWchRh/W2ulHa/N93tjSb0OO7fpdRyDoqJ+g5h2L6Gv3W
CofYCMsm+fhOumHgOMRY0Fl2r8fOrv3BnbV98Tvk+hxkWRvFstwUV83yvfnx9EmVVVOoWWeTI7KU
831HIo34KuTjOSLu79wf4eLSmVJKVu0frlzIlxscQRRnoPrq3pLmlhGpiySjRYrPGQlFyTi9lfO/
5JHd01qkYL56Y9IILCXI7HBqHlNFMNxEGRzm9S+zgn+FUWZ/vfth1gz9+hVMkotZRmE0QTzoEiCP
X/76+HoaF+3O4KJQQA6H2BGkcthU+9mYY831rgYw5Na4uMJ0lPW2jCSmvqtYpYPsjuEIIDcFIyNZ
zBcpj0XetarigNIyPigj3pCOecCoA46NqpLefVl1m977QporxaN852TaIwn20oKBgwyJztFM5OJN
eUE0AyleNPN2oYejbEkL4zCvoKVZepP4skwAkYVq6BZK2iVeTMpN7DIxDmN4gYkNY9+JwM+OadIS
onnuUUEYxuCzkbNajtgVJIxFZwwSifmXPAWf/VCNQQI/MGOQgEwfWur8Gn7O9ec88tlZslr+IuYm
t2edQuiaigFm//QsbOkuTh8Gza1D3H8xLcYdvvW6QbNFvMGqLddjifLpibgQsiSxXSd1LOYTeoq3
osBQVN4dgcnZxsi38YxUaU/UzDOaNuOmtrx849jhzzB7NcALbOunV84oIxxvFYWi5c9z7Q9DrErG
6hEmwAQYsrMzztLRBUbnni9ZR3xhDU19r1iKRsm3ivNAEyWhgeSMqwUCZlG8/0WAh17L1NLYQxLU
sqD4lWTWC59KLZ1p9VAwN85+Th7/PVf0LUMJOnBRPvNLQQmw1nmrBe5iHTUpJ/2LMrRl5QsODXvF
C0pcxC/BMxUttYCqVbed40baR464V8eOqscSHcSPEr7Ax44eihnDjcFPC4x4DmRlb33GoiqFIphF
AF17I8J5X48eDC9eOlHwD0EKnM1FnxQK/fskQ8sq5Tv0aAKFtBGT9a9DHVZCMmG+/fb9HYW/noEI
Svuvub0zB+EpQs3UnVIrbAPfTUMsbqhuYjxVYEPf4ZjY1iY31VvV21bn30X1Tuis1rQD1so3XCcx
b7S1MTp6jVuMGUO8ixnKy2hepNkNOePgdXh5MiKEvXV0dJtnUEaPjt7tI8RX31Ccr4XuLnantQrP
bl6v6KQYOttXSwcJyQ9srf74cbMIoKg7d8+bd2nPVjkqEaauJ7bD5zD1iNFj2m7PE9IsE7Pr0gT0
K0MO2Iy67IYzq4x2ZLCF//FcdqNmGYHN1UV2PrkyMbQJ07kezWJmth4BR2wLc4kNmF7lIrZfJe25
rL5MKcaLQppjmZWtwYya1grrPkVhng9BGCWfmFClU/TpK+kR/I/OIIbi7JmL/vwQ2dfLJQSk7d7C
eVaGvB2QdT/cd67zYqySuIVYidAWWtVO1UZVZJRhkHMeDfZSWmg6QeSVOAWtZLrz+mhB/Y8o0maC
Jlvll/Y6H/WuEAsy9s3o+1u+cnBIJsMdlTteq3TofpjFy7c0Jiyke5o/F6DB3luPJoMkuyXr8zwf
0pWJUc/TbeJdPnpvQYbSRRClRblggHcreEeR8TtxYKaVWBYmKzq8FTvp4YDSzsxxJi3hFBbU9kJf
CUl6955MXmrxPywLO0DIXhmjQ1Oj1a1aLhZQseLtqeudFJj7RDnI16zU1qKv3L/zoSv9eFMdxxRR
x5B93Ss0G9qUVyaGwUfb/Rs0HXfWP1iY7pXhOSxmcITp5RcYXkdZlIQwrQa8dJAzYDSCvCIxOLeP
quouO6UNF08Lp27ca0hdi9cr1pUv29b5987BSuVencnR/cY9K7IfA40v7ZBT1zWnwFcnJ4c8DWkJ
SAbOHWyw4knHp5SC6ejoyhv3uKFI/f1yc9rC6F6CXsPMw7cwmrpZBeMcXOSDb5RvR8aVNqcuk6WD
ZbVam0hdmHPus2UcQtxMgSWSITmuLCFjF80Zq3dZLZjEubSVxR7mH/RnhJ2kiYoYCLA8XUy7Xp2O
o2YnKwemj7PEZEhA+UR3vkhtxjaDWB7+HOQy28SmZR8ua4YLDE4GBYhpoSI4GpBe/344use4vZcU
CQztcDIe82VItIneTuQqoeAtjhEPIrZlkwaebVGLdfU3lYcN9fe6ZCNz722yfnqf6Ds/pSLXan6z
oRyRfBzsJsY4WG7HIpSgfVctRO9ss5h3RkmLs6SbTtApK/AncO+aUJ4WxGEB4DYq5TuYMHQev0gu
JnT/lNIeWn5XZG7Ro9CN9iW7cdKxC3AMIe1L/1REWv3xx1lXB9ZVQXtQTNAA0M7/U7LsYha4F7bR
uvXXHx9Xt87/Uytau20B6maINMG1u/285jhFuQ2jxV8km6ik0kpqYQYWNdz09A7j8nya41akvAeW
qCZ3PqjQyS5sqM3oDbzz+5EGzd6tu/3zUffh3p0R3W+YxRbteSV7jS0ZLOACkaG9ywRbcqb5DflR
4wgNcG3FmhVPHAlE3BIxlxb3oDEhaoGIZ1ZSFszGrOO1LEcGF31W8fUGt/n77CIoRvt2su3HNt5n
44yA4S/ygVFsKwtfFRHGJ4wHDaRpW7dMA3qI7guLIV2aw/52TThMGU8b2ILyyagrsKAIfIU2dRM+
VegekZ/qyLcBeJKc6HIoVCqcWkhLjfFWkVXgqZs1UFuv3V3prIVlo5bELc7AwcV1KuU+I0H6+AVD
JPTJVO52eVcnDe/gIhebU69O57zksa5Q6xFmtcyGGvJK2KdloVfzB7x+DT0LHU52GZtU0o6OLnQT
jN/gWrB47ERDfMhzVRm+bL3ESIX0WpGbrCcwPtA4guFiXHQcfXJjFiXq7tIDUxUXX8dncWakJl8Q
IKlBXebNGr3iejLmCVkpJZ3eEmrxgmz1cyPq6QO7UEv+RhLQLtXiP+FnD6alFdWoW7JDpIKIuN+K
vQyzZgO8l+jcwDGix3Op5dqHM9OVaBdgOJVrRYBfUPNAzqK3oC4ArwKJpKkgVjI164tgXJbiQHrz
VrxHyu9RJ6N+I/qVC2/xn3gStglpWYYiJUW5Z+yW93tmJjwxt7zfUzKpY3PL+TWzFjx7trzfMzPJ
QLfCV/GstsFAK7AoKKmOaFZKKD6vtfhPWa3OQbDl/Y5nMge+lnksKZ9WjlbM8CHMUA8Z1nW8rr71
FYSuFBrVEOk7s3JWj2j04qXGV1nHPn1KLcEuoXNFFBOBimdGWSiTRxoduMaZ5Uk7yYl3m9sI0YyE
C8S80CquAZ1KepRdogcEYaSE6WacnUlbfl+Ms5v2h17kW0kL6iVaHRaEd3qFWgyzhjPC3vbMfBHe
nftK+emOxOKXakThyuyNAOQ5CxFObQg0igQaSYHQGcvYhTj44gM5zwAZEJz5hgH3M7q76lx4Xrkl
tIuNGw6JEZzqD5lQGq7Ba5RQfY5oh7FxpeHwRqJfXioFrK3MOdeHBG0TQ42bWc1BaTWebnuazras
Wfljm0XRmu311HEYmLd+Nnsx9TeSGJ7iZW8wd48c8/RIyUFZcS4T69QIHOVsdtNB3cqiUcaZ2g6R
wpCA8WhFM8kZI2S4yEwpRpPPCxhkTZrwFoY2pCmLbWjLGVndC/Wxk30Y9tiSMi7wWsyOeNOBCcNP
YYUR6SXWAppQMHRwxB0Rtnl6CStnR5de2qRwTsYa9mOy/JCGqEaM8xyaMM4+s/b5yBJj9pm1cg3R
VBQ+Phzc0rS1UtSNeQaoNDM7nMXpGs0Ujkt92oZUCkFXI33uU9KJIg0uEvcOeerECvZOd/lShhn/
C6S+s0ZcFRJcqlioxvH1JmKQ7djFzX31plFhrKbMu4xS3Y0kq1emhLODVbYWUtOiXj3CcpYo6n96
khyO8mF6RcFkJ6PxtRfxQnNrpfQ+anPGme6y+jH7RLBhkiGyQc0vIXpGWqWT97KKXm64/ooftgWc
YpRmjwMrK5/vwYEsANtrqEvAecQK3VniDU3Jqzy/OL/PInSMHToCwiI2PgrTFlhNRBut0Zo5krH5
4NLcBVExqRoGDbOmbpvqp2vGx8hqYXAkUvek0ckV9ocVF6XsaMFATT+5PY6//nUZSx0MIwuGXlLr
c4DhIVdRT/GePB9Y+uwQGi+y1kSxrMoGczOyRImGVV/VoxbddTvl3ZBD28Nct4wy55oiTjw1sw1U
/HDesUng2nrOhxMVNf7QFosuFlxoutgrEJk2tsVZGO871kx08OMaIQSWG4DMbhMQf/cysoIqtSOq
1eKIWh5pg0TiPVC2fNQdjMxQh0wBlpfdqJJElVjlLtSeOLgoqDEvbXlCN+qqpdbidIEClwYD7bTi
RpheKQpOv2BFFWk9u2VaWf58nl/cOxQYI2JlAUXUjl5uP1vf2EiK9N4CdrLkNfHH2JZw7LnwXj3a
1CfJvgDvdpE0okpDdw4gU+brox2l3ZPkAGWKu56YpF3m/X5+RyaFl6R7ZoNLiVuTDhLXe9O+ddPK
YAyehEuHRfAoKB3NGp5xFatBbSa0EJGbzQq8xAng4CokOf4AKY4zx3SAL0LQ/mR1c7qSFFh4deNZ
8i2uBEEJp8tn9eQ7+jRNTdr04x+E24XWwQbZVjfPpoiWnE/C5dZj919SLj9MvXRQQxBRj3LuaXHp
niSv0bwOEcT695geZuOFaO8z4hR/DDp8C0ID8WOyOh830FR2pHCDw9ZIvi3xaRLdHEG+zb7X9Yrn
QiuVRzgoBKIgezzTkqDV2h/V06fNyNZs36xowJbyY7pKIm2Hc8ki4sK/fvwHVsb+Tzr6QlEgpsd/
WF7fWHvuxX9Y29hYXcR/+IrxH1ABLUr4IhbIQQmWEpXA5pBFbIJFbII/KDaBgrnGijPGV/nvdFQS
o67MtRa4VDvGffwUiymGQDBRTMYyz0yd3L1xoGZ2NOaJPaeadh9qpgQ/PicQ8pZO9nZZTcKUKWLQ
0HjWym+QWTdbyS2aWdWq/KI6HXSaE7FzboEzoVZtVqdgT0streSy2vzIPz5Vp5j1lCoN7HGh9nJh
9dLEStyYNz0ZOJXTvv6A2xIhPztf1JwxmeJbCg09FfLCOQWtsc48BByx44uwXxwoYcF0s5huCuGd
Xhn6X2n6ay8dojz8DWI3UorYicC2XhaiuwE+kbbcpEbSIRorVu7BsTWgLvkEteiP6kIQTxi/IRgE
0U8mA+mZKG9Lqjtd2TyLnCWEMSQ6amxehVda1f9MJAqqyza9/ti/ycV/JQaWIEVkF/El4XTKDenH
959aH2+ZGUvGXtFZ5gAQWZrGxzXpc31qXjit3bJ4QLwvgxPNchZq6BolR+l/g+NOXP4fZV8yANyM
+G8rK2tB/LeN1bWF/P8V5X83vhusgZPuw6O9BeHdnlhO3Df5xaSvDhdhbLdGcnyydfLmuLN/cPR6
a68RRCYW8xKJfVwe2q08vmxjDv20KlcDQ+uobW8ODw+OTto7naP2zu5Re/ukww1uHzcMjLTODruw
yql1K2wGi/oQlUzuY1RKUhc1ElHi4g0j9LpXtMnA/OJlPmLVuPPqBFPpYHPihMXFBfbkZLh42yCP
Znah7OTDcXmkOnijI9SNe31N4v0c0cD0UZAWi8UpcHEK/JoR6qqNpCoaNeM9Vz0LI1G4YSj28juJ
QWF4VMecEOe7EwPvitfFacGUxIaZTMroPnl3MUovx0vXvQ+9bAnS6HmgUiw9f5b8KGwyzhHUs5eN
L4lNrsc3/adz5P/pXaciESeTbqoRoJFJyGdNTz3GkBUjycHFU4E/sJDATxwFSvYhReFYIDmy7nUu
M1ZI8dNPP6lJryvRH+5Q1jUY6cYFqG4l0T4k1bsCCIBVNE0eQhApqk4GXKOkiG+iyYHBgF1ymUF7
+TnUcfONXQThm1VfZdBN2FeIJlLHyg9lVTmpndKccEmeR6bniRmi12pZ8PGotZ+FWFsCfzIf9EkU
9uRxUCdRmJP5IU6KZoLLzcutv/KRKoOluS84EZ73l+ed/7JHuv3urcDVYHZqPeYQk1UbBoJU4Vxw
6NnllW1wTsjji/xBFXAlbHLiajoHlMRxKYzEg6Lb2OzXCoN+oAtdDDfKexmlZ2gHV0adID7KQ2CS
vv22I2YIcY33roY1jkQDeigy0Ocj70xjS7/p2h2jww736rGmvB6lQXXfZV1kyw5swLjwZXFEXBfF
NxrSpeKDM4t31OMBhJ/gfoJmBCSUJ7jN0450Pun1L5YmQ4K2TgpYovqZ7/5NldgyvTJ+l598O9ER
kTXCQ/WgO8KxdNvmnh5qHlOXlWjf/EQYPLTmLAPKDRLi91mJQz22XQeL3TPK1onsRQNtleWSPD6t
tlAgSDAdY9PSQOp9t0EyH4VrZfhRnILJOxyZdyBCZN0Jz4Vo0Ww5FwIE3vey/oVqPm3DVosxJkHY
YtvEys8zULizJel1mVYePBQM8mm5aCuTZA6yq5kLcomIe3q9DLp17Gz5LLbqHb+Z4IGDxDoNzqO+
wawb4JjY0Uxew6Gkf9/gc02P9/BxVpC34XAyGubFw0HSsHmevKJMD6yIR002v4FUyRgWpCJZMft+
WpAcfRWLYKAT3WQpyPlAzSs4c8HSoEkQhgygWkjuUONBkk4NLUsSQsz1bt04qIKUbUskGrdsyrLs
rXVECPum2I7fZxnIBVZ5cQb4GWUER04fx2DMUsHFs9C0ZkETOehEM/G4hJSFrp5uVV0cN6Y+f9Bx
peQQSCU+DYbZ7qo/eXCDawaBsAuXoo1kZjTu8pmFhFX98c9DD54Hs2moq4K/X5RyUZKJi53tMjMP
ZLFFX9f00DKEpLhg4/ua4e6GNS51h/0tJ/NpuwjyuZW0DJi6RKyJKlhK0jZj1WQlgLeW7GNl82hg
ffH6ToZns7pt7gs5/R/ad7eGebrNpolej+ml21kJBTd/b7VMKmASf2C3pW0P6Tf2im16/R4FlnaS
17Jl1NOJBPPm8fEeHzd82/hoOSxPVwwShk99eWsDojuhWhFYA05DcswoGYttcw+E8RHxP7j13dlR
E5Oie53ZcncPzrt0F0NaTbzbeaoAlHSaUCKZoBCffCPt+aZpn4FVEIUqd6oqcRklSuK9lIUp4BlO
CXcDN7ChtUzreyX/NumBN0qhArLZbNrAJKfVN0U2WtoCAQuW+9f3h6P8CnaIKRn1AHxY4tZvSlnV
s/pD95lYAMto0ErUIwjCi532sdGIyuAlpTrBbnRibZrb1dJsVkC68kiV6oqFN8jqmyGQ+yKrEltA
nUbjgsqEEuSRCPDi8fwQlHE0TkVpg8YpombzAVLBsSvWkaewLQ8oyGPa/3URAWiumkiEb8jX6aoI
ijbK8nMVtRqi2ek4olz1D8OlRfBovPsfjKfj0loXaV8bj/ZR+LAnj8WH/dpAuKPsogdn3nGHNCYh
yun+5OYcWetSpySEPL7q/7xwZP+kaGQRWVhdupHFkcLFbMST18PSGmjzRztx1K+ZtlynLFtnWzOb
cUM3ZJgPFfRllY8q9TmdE8tu9vRLW/5gYYAabwsFgRUXWRiN0sFVVnNa6DIPtHStXp+GRFgicmLp
U/TgcTsuDio3Q6g7rfbzbioqvFL7rlIswYeOtD/q0w0VNTeUJotzSTkoQDn3NB5gnTgPE83uWRl3
zdGQ4BbZcXiPScefAxjppPDvwD0fcy9CmYZ7f1yQMvhUHpTJhMaE9VtJDg8UB2fD0U8PO9aIRS+X
kGZlAcVI0aH86li6kErCm7YHhzWrqcBjKtZaHJta3dYT1UWbz9f1QhEdwSx+wYRhdOR6n4GUHhKL
bOqozh+KzG/Q1MBjnxUcbEaD544NFrS4NBKY11wmtdx3E8EfMDtE+xOe9AIrjjlMBVQB5QzE2v9q
bAy842TIRXYCR6sUqeb1PcmqOM28yhCuqpEsf+H6XuZ58iIdRetamaOuhyoGpoJJm6jRMopkkRG0
euqtkGMyEZbuX80HeSpR/CwW8a0dRBQDLXL7dHHHyIXVs6jzDbPJGK92Wf3uu2PUKYzSu83k4ygb
jrisAMHATc5urrC+f+TWdTqwCKEuys5noKNDoGhWotESEeyJWrzq6Mlcr0xB+jrtb54FNt5MHn95
6g3S0b2/h7Jv7+yZnyacX8dSqbmLy+N3SWqBiyAi+yTqlLwon/MtgXq/mboK6oBhgUgB4ylez2cU
+ao+hTBDFXbjy8kJNLyKCCpmjR9Q3Jt91lWn7j3ujZtRyrbUU5O3xNBnewYxEbvQJmX+RUiZ/58k
5YFDSlKFe5pJi4gl8bvEMlBkSey1LfGFYekfoorUghYW7RTrXQw6hgJ6/VPmDC75FK6gLGXaCoBk
LTfYhYi+EZDEzWCsOypEVOR0ICvmFMADp4RpuAe03jipp4IfEA5meT0hc5XVUvGQNWOE4XUuQhpe
wGXBjRHDrpETz1bP2AZtZvwEOwGkn1HejxmeEXPT7d50hib2IF7KnTPJg1eISFvciG/0KksHyWU/
vYLNEGOa0f3z3XVGWl9YPaTPUlZEhBL8TL5Xoys7S3U0ZbpV/GlhMDpil6A6DpZLFLYUDs5706ap
U18wD0XYdGgXHN7CJkc4wjltfB2+2EVjNbIG4z3aihxgpl7Km46+bZGwdv9b2SsCjvvH8leZvVjI
b8wg9XB1niHLuwL6UffWFufd40M9hn/i5p1Ltrd8SSNgQ2xJyaCbSQmkypPkG7zwOrkfZt8ok9Tr
FENaJOlYHD5QPYuN+aYyAyw0cI2C3uxD2xT3M625Q59iO5PNFXgrHN4z+htvY2oK3oGmp6EzbmUG
MqpnCdoU284shrQdS4+gAP5J2T+xWsl7RQcNSyXLVDxyP6tgdUVrC2k8H7y4uRUru0CVxkRm9cMa
EEcih0x4vLYxrX5MVlafTUEIonNAGRp4OarlXExdPfRW8XGeJ/08Ghm6d+mtyNPG8vPJd1BCvs9r
g7uLmg20PsfWCGsJT3uOBTmn1F9uze2s0fYNkh+WsuxcXlqYd0vBrC5QCqSnUpf5nkcpo4YZafZ8
+tmSsd2INmJXGBBlTj8D0yjXaMAAxunbCnInkHb/9ttvtv6XGy+K+PAKBA1tBV4NbYyx8WKC4N7r
Y26+255yRSzAetC6H5NlDkhLv34SNt5r7/988qqz8iwWHpB8i8hVtVZVKojegHcWUk5W6w9yRGBF
DrkkN4cIhFb906uqGmsEvFOoc8EKaVtXfQaXNFwLkFayVmaPRSxj4s8Ip//R/PLr1t7uDvdYlLG4
JxM1Av6Zi3EwO/HIQ2xgVGjmyWDc6yuBGb1nDUZiYPDCCA29MQjm/X5yl/bIzwYxV+crxuNZjfOo
OSp2Av16XD7DAKCc778I77vwG933VihNo2m1jNvrD7AmdlJSXCQyiC6PCMJivRVDlmyc0MTJjapg
yvoxKY3aEMVJnP+QYI2/s0n/aS4hyz7A9QaTrKzowHG/NgXphtqqzXRlwCcDa8htmM/N1bP66fLZ
NMgku0Dg57Xl5WWFca3f/9hK1n/44YfyVvHiiRjWl1Wef2pt4sOSVVj0pOTIQ3bNf/KW3elNUHCV
j23COUyS96FgGbFPKM8RnQ72rCqdPSp6ougxj1+9Oekc7bw9mm5HjCZonr+eH4eRQMzO89F4moy3
l98tscN7WtwPutejfJDDAFC+Bqy46MaDfnp8o0COaWJ3h7FUcUUmgIoBD9+3U1V5JavuXLQwMp1O
U94pYQTtnHaTXfTgkNe/b05t3zSXidiBaaq1SckKbpzYLPsTW7dv3czHnM4GF7bhlxUNh8rUV/0N
dLksev/I5rBp15mkUJXTx3ifjY7y5Yx5HkPaiK1PxQJWtwwIJqM+ScpacGsJFBSCOnRauqOhhb1i
G9eyXlZOouadJ93JcaA8g4sboTKxOFiQVb1Cztbb41DJiSwXFZ6bk4BR2BaUuyj82NsrWk4jTAff
mGDyq35+jj7NYsKp0tJyRhea2FrW4EcikWKZGJ2Fq5vTP+DL+QaIacTgwfYi1o3Rwz0A5jf9nw4L
wXy3yX+tVQwhRgjoBbU8Y1zC8HJ3wF1EenrBwZNdvvTDPIjbgf6N1h4xtiPVSzbM802hkQNgeVWu
aYz100MjX7wWj8BNqEywxDbhMJl2aZnAiMc5IsVDse/vEI26WZnp09Cdx58h5ssQ+jHEfBi6cf+F
6e4DxXyuA6H9fHe6y8D0o1Ixw1VgTtdBAz2hz1AEf0/2VjHfgGZlpl9AuU/APP4AgS/ArjqQsWch
tlX5BEzzB3iUL8AMP4CpPgDjx/gAzG3//5m2/zMxSPiQwdAjBANjUnIJ0zwH5vAa+KIAMuk0CJnB
PxVFZopnxKO8Ij4L9aXEnWIOVwolwCjKt0Jrc3gB58nTs7pF0iAdvYVkHz/VYyA7fnrvM2Rk5WwJ
D/vZwxRVO4BkjJZBiyNp3GaIbEBRLXA/rgXgOEH8+ZK48368eR9cZApGTit8NR0pZ0YUei3ACmyO
3dPIzQ0K7ZaUiOszXcQQaHJpAHpVnnKm8JxTK9ZhQ5Iu4jz8G8d/MKCaXwYFdlb8h9XlVT/+w/NF
/Iev848wPJ0BXyB5LpA8/9h4DpqpjKrexBJ072EM/5mAgVSIh47H16V++aFJQFi1V6E4T0WAPo1+
R7CXTIvolgbEW7qVupivaWzY+1ktE3viL9uw0su/uVo4ym7yccbnNrr3u/DuMEjNloMAOcjGcLx6
z5f7yTUh0pvrqs/tRRAOeWbjS7N61cN64Z/hLyYjvkFLL57iPLfxVmdz6If7x7TSzei3kW6R+NDJ
9M273cloNCfxXqQXrGt+TMPCzNHG3ZG4mZynFwF2jphlPhj9Ugx9+ObX06Z3tNti8EWyeSCYaN/Z
Ee/k2CcMnGi9t67hi8kQ4zbo27OaVOCb9ztB/axfFQ/az7SD4uaZn5GE2CqVikI7BmO7dXGBy//D
1x0jFaRcBF2i4O0tbs/nuGlMBo9ZgRYy+L+a/G9Dsfzx8R9W1p89C+T/jbWF/P/15H8He2ch/i/E
/z9E/FehBtPiGthI/7xJu+o5l/AgiLn/bF0hz7OXHNvjpYV85Jec3I62gdftLH9UVOwKHaxQx/Jw
48nNEUskFkMkFHRi0T9QKNQbdknYj8nNUKJ+xAN5oFWAGwYhRP3AeAj6Lf6YAtSCYRLs0CyoCKPw
TMktz8dm5df20THwEFS2slapTClLx3kzhG++PvgVkh62j15v7bf3T/bEsN9K8fLgDfCk//a43e4c
nLxqHwVfTtqvoQFbR7/rBgRJdHVWkjq0fHu7fXxsN3daZ75LanZ7YIZtv9rd/7lzeHRwcrB9sHfc
qON6J4yDhbmshKY5InGVoR0GcQsde9SGggtkHUfD1jTUN2MSpBYePdhwLTJGpUUXCDOGpqn7RD4R
UggjLxXZeIknVRXDhZERhgc5o5FlxA4DD4QD8h2in6xEpP4q7EH5YvBnyLGrjIrSnkbCqAAUCN2k
VTCWqmzBuFGN4Po1ilPdxmlE7x10O/7b6G8DiXqmoRqZemihQ70zGfgTzmPEWvr7JNOK4aqbzELj
pJ4PVdttuZ6K5yKNheq80EtyDR/SrWZXa2NVFZNuF3YEw2rYJu03w6mByg0XfcvWgFXrurWk8OUC
rTa5jhqWg8auGMwaOeMVk01INW9vVGsUN3bQcLKjxrvmcJ8b5e9Jsnt4+0ydaVQ3qptVpLjO55P3
snr6UX38dFZ12iqvVUvinCk5HNZ3Z0s4U4T+ov30/R7NhD+9rP7cPkH7SC7+Ey2TT1eaK7gvCPDi
pln/BXKrd0mVYb9Pv19uJOvra5bvODaJPrdixBU9n+OqY+W4rH6MZfq0+RETSFg/ck+2OAyT2A4a
agmS2IWX37wiKn2UTKec4ezTN9HGeJmrklk18pPiuCeCl6ocLkHmUP6WtK3n/LdQ9lBIrgMyGqno
gAhJQUYEQ2BJ1HFbKYfpqMg6aCAGUij+BYGbbfnH2igAm8MTkxrSEAQ1TFyAwAaU2axqrBeZct7U
dKxebBoia8tbbI5kI3W8JqN8P7P1g16USn8kDsS85mNQiBoNbQUs1G3BEntXFNXpBVdVwURykM6d
8Sr3EJtajl8M5ZRtRGzLiqzb0dODQP41d2xRkclx1l3Si9bSL5D7P7x36mgjI3STDiYgv90bOPrS
8ZOdg4J6VoOKqpTBDN6pSn82hduDUmCsoFuKii4FmRZB8aeRtgiQzAN7IaT5Aj2RkqA3IrDqAY01
yQoUVr6uVLctwFuFUjvHkqI7YYcjM42x90sMmztlM52y5Lm9V+oN6H61IcKKXVQdZ59qgBiq+VWr
YdoswTPh7w3ac+qxWUbnkU0VIfYUA6me1Z2YqmJMJzFVsfxbe205C7qbfRhjd/mnEprI987EOTbi
KXbD7EF8T2HSeQxAQquSfira6ZISA2lMqFsnhOypU3vDreSsPmXEqtti0/iRE2v+9PpaQy+zqhKk
lChhCbm2OBEIiw0lc4knRFaIuRYdd9wTkC832IJUR9fo3o3TlbI5x0YFVJnLQUMcwAOkWj8beBfZ
enbi9yWGoqo6gC5WXt/EneVBdfNNZipk8B561w7GNasc1x69jms7WSZR+CIsTO6JyH6PlSiKGhr7
AffN3qDbn6D7F3Ufc+h7hKlYKG67HRt4T16OqGNcZITqK1+D8pH/flIPaiA/JUvfwf9INtTkd17q
Rn3yoNCFTyLvVOGNoIean8r73qi42KI62kvIlTAFOq/aWzuw0ndODjrbr9rbvwDpPrJOYSJLNSxF
RrLl0u0ledOkbFQ+qVmljzv2lBMJ3FlR/cljjkx6BO2lL2hvGPZ7ZI7oNA/e+zjCspONyuMMNDz2
wSX5QxNvD4e1uoojTu36QJ48So5sVOtndjW3ahLPriu2rW0GKNNe16ogVy3pwVlSGaslPdaloMpY
nnVvpKWnhdO/gpcg0yYvBrryJFPnTispLNF2Rt+XbAq9rd76zVSn2AIF+6nEYON6hxRq4Cl3cAT1
W6Ir4Qe3Be6ezil8FCm/AB+cjBKyjTqd6FB+XN34vr31cmtjqf3DyvrS+vOdraUfNra3lrY3tl4s
72x/v/FiZaUahTnDW2Dy7bGvc2tyN9yExWylRnXVmxe9q6xAU0Sfo41oc5N2m+TOMMo6kpzLb0hn
Qk8rDtioxisi3sWYnheL8kOCc7MwgkU5vxngZTuIIUVzwi9qK8+clc7pv8lT9+HBVO8rX0H/B6ek
rxf/fW1leXU1iP++sbzQ/309/R8P+EL1t1D9/aGqP9h+B7ml7FP6LfZyeKDqr1xtV3MtknyTl4b7
uey9a2GFyqQS9R06yDdEi0fYYHEt3k775dabvZPO8cH2L+2TzsEhjlSD/ar7PTxmkp5P5S36HfbQ
05rNrV/bnePjPQpHpZJRxCf+jidDE4igYe4aXdWhSUIh1Fkyxkf7hIcXO9qdmKpiz6QOeyZ1SI7S
9P62LNn4fpjpVERPxC8rSY3u6U5anpzU7cPfgd/3iXTHKs6A7TUfS2T5Y7NGjgeUJEDf1sn1uLeS
K2PAh+UyV0izMoqy0AxKqZIwFguMEbS0N59/3eE5+8XkbK+EiHe88fqbUjx+rjpg5zo/+duV58TP
QcN0ZuUiGC1AfSzPLo0zik6nEPHeA44k5TkU6cn8T6DccbZJFnBi6knnEnWDaxz5bL8927+Gvfsw
PmRZ40qC24TuhdFeuiOoO6oOR8EdCPcyxNkjv7BivfxLWvppo/zLtffpbLMEmNCamVE4jurBoH9P
23Qj4fbI3w3lcKqvVhG1QtszVCvlAUxKYi077L5cys5xzAKLXeMJAobkAVEnC0a/wUTAXbJ9WGAG
ytOLO+3fRchxMVgK59DDOg2tsnBHMc1IzTUAWQYEERQNeG2l6nEHPDdeZNo3suoHQPK17kYpj6EZ
s+5klBEktuxW2F9ztGMXX59sLc2wVucuBkUAFWGmOHzSG1CTurGu9H3M4LT7FskOCE/j61E+ubrm
3BWtuprRljRsjBMPZ3Zb5qhl43N6vGH3eOP6c3sM8/vxPd7gIb4r9IyhBBI3ohYpo2UeG46SuWU3
E1+Yz8hxLbz4dXoCL61AS8rrW4rBCX66fGaYj2Y8+Ue6ZuDKQdzOtzJHPqRUC/+jPDa1wQwQQdFD
u1r6s0cBmtgdcmP29i7NxHK0OkqA3AyQwVD1iQKnrDisUlD7kTi/6nk8bQktt/SAet11ounZeHCl
tbLVQll2WC6o0VWxIaeJujLveAMNii+sdThb9e+1C3uxnqinDWsiSAnjCdTbl2tGsgSwk5wc7Bxs
UkJHErDT8uSBuQqiOWr8x3B0SkcXiJ1y2c/vYgseyXSoYyCpQ4zvEZogNi3/pDaT4AqrdFsJdpTY
gt1BSb1DqR+0cosLe4BwJMA7tZm1SFFomYOCcQdd8hu0GclgNBLZjEkp5qSrOQtEtBrdhYY1ks7F
q1PiHLsoG5UwyDP6QjTFvoSMhNjURdev9YA+BpID4qTmZj7MBmrcPHroWSqu6/pFAEuGvTLEiy8C
wuVi31ZGOiS7BW4YX3CmLjqfufCU4wI/ZgGatQhFeTOG2yZcH5I2gMCy4asi3OvWL+ZfhsaEIlEi
BQ5pA0yGvHoOZYa4dwOR2WH6oKeFuwXHt1dvV/W/YO3+OyUj23gFDtM/YQexEbAiIfKgD9HgIr8r
kpXlBvZE0Yqu/QjCCkhMUgaPIoVCU6+sILRPGGbnKhsgRH1GiCOs2NVXSJvJu04+4OuNTcuLScX3
xRItOF0E30AckXScInRUgxhs+Z1VI3x9d3Dc5vJO23j/layuniVKAaUQT955wE8C6ZG8zIHbLLQv
bgLsHyhEdY5Pjtpbr5u+4mwYHuUd/hI9OZRvUTM8eflb8bLaW5tW5da7vc7J9mGlPFykzDFvAYtp
1MK5PZQTGf+lTZAvEUfJ98veoX0a+xAQmsVCZJiXnue3mVdIlJXmYCCvmM/nJq/AeRjis0feXUT+
mHFnBRwtUNZiqpuX9piyaZFkpXtv4MyoxcRpW6beKtUWyeVDfb4aX7NJb1AmDVymN72+SJ10NEmU
LlhlON1cO/N3dAWZxO0rKaPu5JoKw4uNhS6R+jt6zxzZkwy2Ug2vFot4aQr+aZ78FZvnWO+pibBu
aOAR2qADI7/DRz/y3n1cdtBHJKnNEw8cdjK8FI+uMTXoLOVpsmd7pzdkfF5VKxwV6/PjE2d4M3yU
XdKy00rKw/OSpqTZ3j7Y3z9qv3xz3N5pzEj79njrIcnb++2TN5B4a/vVvDGHhaRbKtxIO07LWD8j
3QnbEQ3KwMSntOpa0y58WmQI9qiKdB9aFP8WhXSOC5ouQnCYJijKZHATcx9jx2h4HZyQ1fJ2N0qH
nWLQsyXnTXdZaThoabY4373OLFt8Wf7INO4D7RCUzTLK+xC1S5FPnoGfKqEJ8vY2v6jZBaK0L15m
VWphU/lWdU72jjvbe7vt/ZN6vWLfwQ/0PbuqYiDqVW1VzahaCVT6S/v3vYOfX+7utdU9MOpoFcop
bpzvs/t+ftVBdTKj/SmGtkXFl2jvl48yBRIHJWR0ercF1W+1YfpF3kXsHDz7k/J4rfn9U1GYP8VO
Xo9v+n+57l1d91FbjoBi3ApsxBPp1RJLf5bd4BerwR2QpkcBfwT972y/kg1ueyOonIbRIbRrUKtO
QjYXZSO0Wv17IUO+3T466ewf7LfreG3hvPFmUUpKf48n0w4WWEQ1It10mNKRJ5Kjg5/K9ChSFQw7
F7EZXR2QOgi6gjzcu7zvqLD1RY3zt/hPQwpp8Z9IBKXrtEC+q0mhjaRKxSroTu5gfUYjnNQ1mkyT
0RAjfxy3j35tH3W23py8qk8bFWysoki4gOmKiHrd67Q3CLcsLvLUFHfWKEnD1QJz2bVOT6wuWeOp
LY57IjYpyVpzZTkp4GjYvcYVIrK6OOHQDG8mFicetf/6ZveovVOlo0bVXTDlmrtq1b17CWdyYLuL
XkGQ/wx46mU7zzC2RSKcc2NDfTyh5UVN9Ss4107O0aINZvioVxjbrCW2xXkKn25646fnPzxLV7Pv
L9Pnzzaeb6xl369mWbqxtpJenK/88Hzl2fnGajdd66ZPOD3+Fy2sV5a/X15b2Vh7xHRtedPVXE+a
/K42ySWCQmSslMTwUlwXUDyEAFdJLXomXutm7M/RihxC+G03kJQzWzGdmorB3DWz2u0Nr9H8giRv
3r2jtQF3dSRtTc8/yXtWd4vUU7e8VJm5ZPXMD2re6b6c2gWdzbVSTCnWbWLWvbjudCej22yujpvk
uu9WCWeuWkFlZIGJhSXnXGVWlIvcctSEc7ucL1r2YJakUazRCMClO6P06iq76GT5ZeGUFEsQKYYd
TxQLttwLO33a9e5QA0kQdVyduDgoE9D+iEb1Fttuhmz7ycrTnAzJdN6qQ4ZA77kRAeJt+4UcUHlR
7mxvdV682d8BaUJLmWagdEnmiIkuiyAQwbtmr0DuqulEdSeV1a64/KBwewMgJ8X4Kj3GA3ZbQlv5
/M286I0e2kpHZpmzpZzHbW0lss57zBXKAcGyeBrkEQ/Axy6jSgkQO8+oA8yUo0vp+chSZASTQS63
zM066TPIdttOqCyxMPyNdgpE80e6xm42hU9lBehob7jLKh5z29snrP1RTs7aCZuQBWJZv8O8ll+y
yskZHE2jOtmwsTt1oKlGmK78kaVEk22GE18IvoF8s5dhUWB798YqCzVu86Mk+lS1II4p/qmU61iz
q8zKAcAy4Rfj9npzlA37GE61+rcBe8DZh5GAOmQjsLQF5eaj3j8EU/tFWvS6yUerIZ+m0bhqPpYg
Nrh5tAOiBn6IfncVd+K+1IH/lzvPyYWKAcqbetnpQQXiHVRWt/StOrLS6vLyvIVcVi/hcAtnacWy
t71UTKp0mCVxJauWTragd96Mi3sc2leAgbeh/uKgoeC+9KliQvBWl5aWjDOejDC8U02NhRJGS1sa
EbG6tYbD+ox/Sh0wPG0LpnUnjXs3xG3FVKGHE9M45lNH187SEHHXSoA1V+uRxJAObVysnDBFgwMu
Rma1ktSTn5LVyE2oPxR2qatnUyTq97deey2YAq8Z72/p4L/6EP2t0pgph2W3bsQnUb5J72/9OuGz
dhMj8yUDYEMrZSm6TdhASXpqJzsLXbtMEcl35FUMfzgMh89F5VeMqiqr9ViTW4w3HWL//Jkra1OJ
r+8Cj/H/PP6jODh8MRewmfjvz9Z9/MfV1ecL/6+v8U8cLmTIK+StYzHAwiVs4RL2B4HBE5fRiUmx
G+yde/SuZrnw1z1HJM/7an/S7yP8QT8biUdQsktfRDtpueZYSWuqSvltbfQo0WbQenG7AUER76tQ
hA2BkMSHR3qCQHmqfLsuFNI7tEVLQFjjnGQ5ZjFSAeuxTjCxAi/AQ4p6JrWl+gGMg8TX6fCkqn6M
7RKCSLSxDzt2dvuDasyZiPtWE2tG+sB3Ypgm/t3U+U09uMdk4CI0sQbdeV+Tqy+KWMpRxkBc22m/
ePMztMAbBQVQfYJSTT54ml/yXJb29EAIvW/OE57P60Akxhobq9gF45xkSly4gZckzKIz4PTBZwFd
qzrBmWboFkQ4SwhbD9JAU/eQbDU07UHVklC4wdTUSI106B33xn2FO2fjpnsk7l26zQ5bpsID41Hs
I5X6SY5g8ZQBGLr7eZoMy9xHXkI3xVWsuaosnUjlkqkyK5+VTFOLWz09n06kcpFZ1YxMKo3Kw0J8
SaZ5B8JuQxh/GstEDt+0zwO6PVZ6vT62j44OjmIl0nLxmBJpMsdK5BWlpERnNi2k9j9W/pfbmy+G
ADED/311ZeWZL/9D+oX8/xXlf8czHySfrDvOR1EH/fH90BK/KKb1/K74pcFlGtNjsFje96Fj/PHx
Hq1vDXx6mw7GR1l64b55i1FZ2jbC9mSMRj2q9x9wfRmzpS4F4WjY7/TVCJ+O9PRYHI4Wh6M/6HAU
NeLFY0LNNbvWZtjw3Nk/2Gnvbf2Ot65nFcvGSCm+qscHnV/a7cOtvd1f2+pyM1qTwi+0a+MElt23
KQtrrEdrxGZhsl1S7D6wRr9/qqBGsrY8q779k1/3vkyFWBJ0cFaN2/snX6Q+KAf6R2dGP46z6EXC
U2O0QnWWw/I7FMxVfvtRPtWHq7IPqCyxn0lxYoobXMjpkI/Zqr5yuHsVUVjM8S3Lg8g5W5yqMEat
aL9DW3QOYHt6Fho0leRRMW9FnWRg8XVh8uR9Vvn4wf3ojxIJuAGxazpaNG2dp6SApojRrH0/Kznk
HuNBFJ1X+HipKtN2rbkO+D7XiXdqyGplbRsJVZ7U0ECHIS3q0XOvx7R85Ak5WX1mMkUizyIZSkjk
UuZnCztbl4ofjtiFJ9Z/v0ElhOASptHdJoczCHYL1SHGJ41Sn3Zv44YK55PLovcPDlvG5yIEQnLQ
Hlx/Q097Vh7Kr6qgiWBH6qP+9l6i9WmnSJq31DTrbizwa7CUwYy6Kk22fMRZ/vAls8g92izPjQ/d
CJajip8WSnA1yBAoH608CiNF3BC2ft7a3ddOCW8P3uztvNiD5bQMs6RiT35cEZTM3JRo4MfyoubE
fQMqXWFo+5GycNHZ2r9y7JIt2yZwxCU3ORnlwVtSLzyzKls5sNjL4GjeAQuNGGTldSpE9emyp+1G
puw42LshFwQKTp1LmMw2iLBBl0qZO4jwaAF30zQFUXAyrtYjzmVqErvmFkblHRH9a1l97oY4V1yG
/9sRf7a563QBPBXgLl8UkYmy6TFytbrSmwbOML3dU/AdHIB1HsfHLEH2cOVO4NA7IBKkHvsQEVyX
tWwaC46YyYm1WopZh0gIMbuQrhiFyLxccU1ClPDWdVGpcTaco+VSmf2HanhVUMXZCkSJBmJQFKz7
6AGq5APqBA00SwawFWxGIF0xiw/oiu+gVxSLNArm+lX2EOrmvHsIJcYGl20g5iD/z99BoqKlmSX/
blvP26Pdk7a1edx99t5zN9dAP3rjmcU4EdB1wUMhlvzX2BjKjP/+PXeGxX36/4r7f33F+mV0ADPs
f1ZX1wP7n+frK4v7/6+G/+wM+OJWe3Gr/cfcagf3lgocSt8lFn31qA5M9u+Dl/4r507Be29ERb6e
1CKGUmoVfWNVBD+i6iRV53y6JYNFjGhTDk6xa5XEvhwXk5ubezFOAqbUZ0QkvzhLob+mwTmCRorn
h2XWpLLNBU9sdWne9E6vH5LJEGZGLuyXZfNvEZDNpBa79Nfd/zku4ZerY5b+f3V5zY//sPZ8bbH/
f0X9fwDGr36NR5NuVPN/QPM5FSR6YBmM20JYkCrFZPD3ST7mAJb0YY5A265/kijcmR8XcslCLvmj
TJHt+AgKzhTdEV3cxKoygXUgT425nuXjplQ/PCEwSgOexbFmCbMEdOQIffklJSwFvk3IgVrlvuyn
V8gogr6KcAP1eRR+qp0G9RiahMM4uHJ1VRL8WK6oMJt3vfEruh/xrl6l6BMIE0auWRrSdEbcWkOY
C/5OzwxIy3lbNhp/T+h90QzDMVsOx16aWESnoP06u9MJBRytAeBNC8hp2EGXNjWTWFZxMDQd3Ao/
+G11M8BtdEq3ahCIw+kBdO1aHRjuWaWvr6/NRS2p+c+FTa7kz9IiC7Nd6OGA6Gh2btnfo3G3dMLq
06pf6N8nmX1TqBOTd/BfPtqpPlUrsbjcU2DoK8buZv+gc3h08NvvnVcHxye0LiDST1/CaFRXVp83
l+F/K3pJ6EApvWFHUOEIHc4sDMaeNYD3zcbN3gABYMf5gHLF7iU91Do7NFl55DLiAdO4YnI+EKBZ
bGAYEr2kkZgBYZfHN2mBrvoqo5rUTy1Tb3XBGtKC7yKXkx/ZVVWKqyc/JmurdocNv5V013RIioeV
uQPF3eWj97XeUEza4UWsY70hjwsq+1si2zQnAwxNXqv+abfaCIekN6zXlaP8gDEzbWoMUG3jEkJS
PagWycNVqVKkitryh5fyL/nxx6S2tgryj03Eej35j8QkspmeOwyfdXEt1T6LkgqSl3AVXM5AEFL+
uKklvlO02znzScuLjE7txpXcDAFArOgt/ic1+SQkrsYIcIGFEvpcBiRkheK4teJdTm+rlSm6EOjV
qPotXaaHJdhzT0Un1JvMnBm86eMBtdiIqoN7lyZhwJeSiWIWQ14WQujFSw66OcjGdrtjCI2RxSVW
6JkX6BUruMhvUP5FXZg8um/1eEA1/LZJWPYI73Vdqzar9TOH0fTahIEtKA3nqkf1QJrmkQUmBpjt
Tgx3p7ddn6xwSmbOoAJXLjnsVBqFBIUN+wNiZ1jZSVZ0CyibmJFaEFRWe1NJCKAyifUEDlGkjwfh
MLvNBA1ChyIgmYHOcdYNlT2rIP1tD+PFmMDuTTHHUoJvzcISt+jQsLpeb3q0sAVmHbKDWySYUpQh
lwgKBFwCLesxPB855Ixu6HkuAzlnrDXzvNUnUIbBSYjZYpxgfMgKkttNBGIR3f+S1EB8qyf9PJdA
ETQwEv6DVhcgsGHuQTHG6NTQPys2VDXgN7u1JkoFD59prM17yBV45hqMYxkxTdNjN+QyQ5Lr3jjD
NzDiuhbsczqGKTv4Rp2QhZGaAYvToOriKNq2GUFn3JKTqePfTET9rRTzzdgM0DUd0xny3jTNBOmo
RSJNracq5JT6Czxq18jzykCIYjAQFVpIxxW5xlmC1wd36YAcC1EVTRF4BISm0KF4PJJZ57PyLdvs
1uFmwZHsl734zbHQb2YiKyaZpiz2EGWq2+lA3YvQWrHMeOxWRBMdP82SHNVRStfpgBbpLxot3OqY
s5jQMkKpWKoc3GJkXrXsmdllhazgGD3BrFJoIp5wIiU2St43J8MhubGWSC621KKFEapq042TYJ+M
ORCyTxF366/JbZtEOlIzBBriftAIfIFli5sxwCdxAbvr0VFoWocsrs0bjygvLi7h/9Xu/9E36gtq
AGbc/2+sP1vx7/+fr68u7v+/xr9yn77F1fvi6v1rmgRU9/M94CvcH+lqMR1nsBJdfo8vIjZw3mux
rawaPyQuzvZCAmbNRuKGFPE0MgppSf7BcloC9uLQg/REO7IAQpyn3felpRmrAwKJvivSbjejS3Md
hyq5y4iVkW0Jiw/kP+CLjOCpFSWSNycvl75X8Rvp3l6OVTSBpdwm0kuy8GDSfIaXv6qXVgcdKtfg
P2wwLYbHdPlDb/yrHrl4BbmXzzoweE4VtXpTFa1LrdtgkyIFcBmVKQYS1OlEd0jeMgg+sWqGp08+
4cEUlul6/j85MCTIItk1HB0Gg+ZF9pTsnp8yot/o6cVl+pQJ0YEqvu9sbW+3D0/0fT+/PGr/NyIi
tpKVVSvtjrZeUSGlYG70RiDWgqw2VgvJmAb2Jh0WTEJyDbpOkVlhFhB/yiHJKopO3RcTFd4HIwPm
GtFkUPTYVJ5KxnMPR8pMznt0s1eYk8dyY/G4eFw8Lh4Xj/+Mx5V/s8cf/s0eny8e/9DH76OPq4vH
L/S4Yq0Va/8Cj+uzEqxYi8WzWY8bsxjpKzyyWM5++SyX44ErFKNJS0FSOt4D3Jz3Bn78LRDAUwJI
1rJ4OhnnN6i0Z4x9X6xHKV5yRCXyFZsnbMrb1LTS/2C9/349Xk7Z87pFkuerD8v7z3pe/kOLeWDp
q+tfpjVl5Xyp8r9Ue/5Z5fyzyi97tifjPO8fWs6/e3se+3xm3T5JdAVaKSUOC74YqudrA3tiWSmQ
eRqGYOXLmNPu9VnFihgC+UPNWPea7KPWXtaT/w9+UaIff0ye1SnGEC/uf2o5V0F1VnmR6VXyE7Rg
iDZW3euI/ovz6watbjxLvpOX30G+szDGPH6Tzn6h2zinDdKFgCrLTnzfHpn3qlqCoBKqgVioPVLy
ukEGaL1QiSgtaTl3aBE/dsfiptxw8bFEUdpyfX2K+SmpY/RsCoQn+zPf12Xd901bbcl6WtHY9i64
UM7QUGnG0PhmcoD36nc9VGfI+0vsahwWKN5JDXgbc/828eqNZ5UBTCK6WEhJiD6gkjXT0ZU13vp9
x0YBJq9zO0Pk9jbIWW6JauFhxVEWpnWGVoNpnSE5DKOKuK8xvsnKZmmrVbc8//nge4NXIaMB/z+g
/70rECP6q+G/bmysr/r+3yurC//vr/LvyZ+eTorRUzj6PM0Gt6JbWWPtr+aDhf53of/9g1yvREcJ
qy27CMpv3BnU89U/esOK5bStHu+1z+L4GvGHMH6JetG70dn/Afw5xUlR+Saq5JrVQ49xrAQRnEo1
lqLzVQbEBLqEePIcXHAsqdRr2GUVVD/0pVmM4SUqteWzFQ5PLPLUl2BXE1in8h1Y5VRxpKCRB4fb
Bzvtzs7WyRaKzLrbza0X+y+b8vWk/dtJI4l/e7G7v3X0e73S3oefu/s/c3esTmtN/K9bZPlaU4Pc
5N91WzffJTuAmgOp2bCU6ZBttKnZpLmPVqYwJTOThgQbPiuYlySyFZbFNhkJs9zCkpsSeIzNdByE
lEuKgz7Jt1ZSXamWA13pVCg7848A5irm/+Lk5YdmN59AIdVbii+2YlGN+Qlp0WBY0osMDSNVdbb/
IiZi1gzJummc9ChcpB650dUEde6H9KUGhXdHPSJnq2o2hmPSzSc7sHskJyCUK6c6yoTBLLBuKsey
jGSXyxvowW06alXvCnHCvM76w5YJCEMOhUCuZnKHsbKz7nXeNAya3UKhxVPbwDJWa3VpiNNraUm5
oHAlbHmpK5DlXzt7bX6//P3yXH1ZUni5/GsJVsjzvMisl4IF2rJupAY4IK3qX6xUKU2UlkwgO3cx
blXDUrkbGLREvpGHaNOKZLICbHGdw2Y07NIXw69Vk2i1IbFN8AcZuSRmEcAiJ31V61zUGDCxBznG
o4Vn6Va1GOejrINHJj0Eu1cDDJIu7oUIJUFBbGcP6IjrGKV30ysY4U48GQ81NmS8uIKLKybnyiwc
38gQfatLQ1heJ820MnMuMwfBqDdwipBXcxFzKcsvl+7S3ng6N6GxUgsPTx5zYE7aH2t8P15P0ku8
vf6mffDyG4RAzHq3iOHXmEnxMXcHw2tbnRmg5wcINgiWi1/m6xM0CE2apg/d4QgdZSRpYpB3ZzPH
kgQ7dIjeBdEfpAIVuZEs9r9pfINAbEUG5aDJkYdAKaXb66fe5Y7Su90BsJXZ1YDVOj18JTZkwCU3
w7F2xKm6YoGFU8mZOLkLqac3Wzz06h9/aikRgN6T87Y502KhPjakVZkd61SVWA8AI40puHtgnqfw
KPikRVWSqRQZd9FID5ngNtsGwTHvZzVFWb58aoYpLEkChepM6M04mmEwHdopWeKClaDJWap/W15b
O139hf60rR4/iaUdWAlKilpbv/mR4n4SDud3ibz94WZ61sFPSTzBZX9SXNcsaE0UR40to8NH6qoR
BQDDhVUq2thHDixKaiJ/CVq6QIzzk+8LdFEHikK/v5rXWHIeJPhtQSAnxEeBgqS7pJYjG+mQ2vCr
qXZU51rJkjyssGgmvrl4wBmoeVWa5wY6tP09TIK6J7MWp5afCvm8UPDZoQt7UJYeTyuSXrvYqPbw
DrQZ5pet6YylQJXQyWtvgJESnP1Rl2O/VaSK0IllBqdUSlWl0PZw2i6qm3gqbG63j9Bbd78Nm5IX
cH6TL5rdglVk6QjFOMLwGS1fxbh2kw4x2jaH3G04uS3PYrkLv8PWGa5gI82Ocf/jwWWsCwoi0MIe
NZJvv5X6XaYDzt60I6LjaseHFXvu1iMnP5M4sqJajle4p9Zga8ULgO3xqP/dNgp9f5/0xlVnIiJI
d0wZ459yLkeMx3FXEBZ4h37XgoOOIVEY7DnqrRs/hG7vHRy3HT9wOStTtTHHtWkV1y6r+5A3lft9
7spH+vPJ3wPpbZPFaJRFrPN0tP12+ob8wnVySqmt1rReu7UAudGXsKNweGe2wCLZA2o+BOEgqHiY
w3Hf9Kj+oO5XHpRQI3/fFbXIThRD9ua5zcUJJLYFOa/xdosrG4PO4qZZJME7EhK7Ajhu1uOE2i9p
BawnkjCQsqTqWuhvH69D60CI/hjZnd7gr9PN1TPBKV9ee/631ZW1qlNqfRNFHLxjgy3zqtd9H9QZ
THGvH9VTzH1Gsg72CX+RQHlD14rcppJOmhUhXoWD6x2TP6dTenbT8XbQND2aFv9hMr9PjWSJXr/e
+q3z9sXuybHpZLScR/TcZ4iHstgoG45smG2rKFumCfPzdLisfozz/OutQ/J65blR/7SZfMRaPlXn
CGvPRbtzX9qEn3oFrd9xZHXVbjkDxiknO58Im9AHS9JLliwhEJsNVX6K8WS06WHpHG/zgStGZPnG
fxw2gBF46EIbhVR1s908oacaNB4I35I1sG6lhlUyu8kHNvqTfKAe1wxAE5MQDufWwsnbR01/ktSx
BTWYVAarXBGHmlqPbVARLHEWCH7J7s/zdHRB0spo4k8L3h38TArL1E1L4130s2zI/cnyyw5ee8Q2
JjgtoEt9BwVF9EODNaHTwbNDp1ONoCHxqWIeAHcWrKCf/3b63+F9Ey+PLr4S/ic/e/6/G+vPF/rf
f874d1ity6+bqHFcQhQOpe384uO/+mxlxcd/3Xj+bGMx/l/jX6nEo/+5+vlp6S3NfSP573QwQasA
GND10kwzFOy0B520j14fJ1v7O7Ya++XBUfIGT35H7cOjg5032/i6Qal2do9PjnZfvME3VMAK4bTQ
pTSBEUlrtFlBUlyn/T7sYimHeoP954ativB2mXOR/nvC9lzDUX4xcRQyJGsr1bxsBRdYJdsBHPPR
v0hWNLrLD2xygCr9vEu31H678lHQsK42qsjvBhnB9iDE0ZixcvJR7x9Un5QTy0EG71Dp1SgdcNxA
WyGvG5Bdpf2kTUUHjZgMxNuWjOG7VIpqBRrE9xX2Uc62BfippxCBgKDjUd7HS5RM/ehToxtkHjHK
xFAABO0bbYgvCZU1RzqWCpvJS7FKGE5GwxxdajVV9YCrMapKKVXqSpHUenXOihpxOBn2QKQaMxIS
PzfICDAV+CIphT8RBUYgDAxAkiGIdoRknXSvpWENxLyh7sPoU70plW1Thq0DoZRaD1pCw1NcwyEM
SrrsXQI1h9moi0XXNpb/XKfqUDHGhFcFTcZ4GiBjAhimEUaK4hKhyPNsAETooiLGKd1qpxny3/NJ
NakhChU8jap1e9TTAdHktncxwbJGic0fFSWPQWvxdOJagRCf8SSgYQlY7ZgwOKs4vW58ToOT1iWI
gpCdvl4Sxd9jFTf5BdqgsGmJGuDeoNufEClgEtIZguxP2NxGmdgkghcq1wEy92yvD4UKKvP/snc1
GbGHOZoZWcvHwfn/ACuETU8H9/yO/duxQWR9cpN1r9MBtFpNEHJH0fBWSFh609f+7GnC5KHiGm4H
Kwqx0OmmxhDIqXHSzSvgBOgDvHY6bK9e0NNbXr3Jg4Xn7k120UtJkWh1+20+eh8sCggqSC2mdQg5
zUyB3kB1Q08AJp106yaFs5JBQwgMhRq4miIDdlNhpVSvC2p1AzL0uple3phSgkEHy8p4jHsLUUi1
VoqopWgTmpK5AmS0wevYNg3DvvU+wGTq53d1Q4WdbNS7TfFKNUGCFFWfA7COOA2k9xVtiw00UA0/
Twu27MKpeIF1IPcD9/BahVXRcOFcgKNZ99paDGCwxrAHwMwcZbc9GkrkYiCNzBM41Kbn+Uj9giJk
mO3ZVFGHI7znyND2NkXvqLtrONZhcaKqhlrCMQ/XY7VOXTrTv5H45BPqMeo0jR0VL7vGKMNjl5qf
pJpFTkG6UDduslHWv0c14nsi3DlwC/IJAWCpQe/hufIy7dIm0bD2SE3UoFFIHTg7mlHfxqVc9vjo
iPtzQE9Zqz5NQJlwai/V7cDCnDEhHr4QSUSVlDNtKBd8L2t8w5oUY1z1ESiyr5btYnIOa4csHkru
YP8AbHnB0Immeef3MbFCjTJtd1N3C1tQwVWZqkd+P8+AmJcKDD0qvMy32ydV3Sd1GcX7vV6WIRNF
tBvlsBg3yFAm7RMf4ZUO0IiEj8lAQUcWmYZGFFbShEI6jQszWYj+RWPqVqTXLrsO+L9pE14y9DEz
ap/QjMtsWVoUKu6LcXZT2Es47LkTggrp0h4pKXj4cedjaUXLWjbRG9Yy4nCBRW2kG8i43UlBuzzV
eEPrpYiRb2nFM1tT9kERwe2r4ke8Kxr2upN8UsDkvUlH73HpGxnpqKJtnXpXA1r7jdFsCSfiYiUq
HHuuNqvhFPbka91tNQNnijw2AXF9vPEqxVDxkCIbaKMabLRdj5mEBaI/DsZ9rLabA715u0aB15p+
vBCtNpOfUazCao2ZtZKskuMJb67Cq9HDjDXN7FU5g10ysQiU4BICbSYpjuQCtJ5OUcIbZmOgjGI/
WPr6F3e9CwKgHCzRyBfQY/y5hA6yGJFwlN+n/fH90uUoQ9B1EOxuczKODnZzOf8xIA6ftghREFf+
LFzpzHI+nJxDXqAiMOqwnwKj6zfQZt5qC3ojgoV9brPFfL0Wk7Ac1BjZzmlt4QFaswboMMVF93/B
6IhnDBlHjdVkpAYWfCCqY6AKdgfQowfiOhR2nd5mJOWpBtE5Or+8RDkPIVD7/Yb8lw2teWD0OiCC
skiFtMyoniEJeIxUrWRzj1vDoH/PVMa1S5rW7ac9oDentToHVKRCbOrqdXMAs7co0lGPZucl2gyr
E03WU3ufPfFrqI/r54NMdkTLs1z2+t7Iz6A69P+3d/1PbSNL/nf9FXqktoL3LBEIIVm22PdYQjbU
C4QHpLJXXArLlmxUkS2fRoZ4//rrT/d8k+wQYHNbde+sqlSMrZnpmenu6e9j8hUYAQl8EfKawOkh
cEuyPes4xJP2P3DlgvMaOG03pc5HAkIySvAzMzmtuK+7A8vK1lWpVMQLhmlwvDGpePw3500Uya2a
5TWmWmQjOQSS2gLvZIIWV7yLwfGZIIArrWq7fgZuc+ZmWmY/xiypouIzT6uJiUZkMsqophSjaDga
00eekarkdACJYvcMriTKCGycWKiRz66uTkdJhRVsx+FZ5luG4tAkoFjO1uZCxAdzI9s0+NEdUh5v
CcRGGmxGTI7xCBKN3BxnBKGG2ixH+Fc4WdepQrwgDrXGWSa7PCwL0onkfDe8azewelVHZjojTBsB
XoAn+gZtaz6FiVk1RN+y8syECxP1E3Xcjv3Mx6gZs++NKYYbJ0pDj4L+LkadquJyz7SxwBPRHn0/
M1icRWn0CdV9lOk7eNBPc+SBN3KVIbOoa+RmT4Vn7YAgak/OG9gO6BCiCwpzp2NXYzdXH0wzyE1d
T5hgFK0duem5iQliCTxtltqU3IR7mj50UW+pDp1VnECFchdMcVz8rjGTxaO6uWhpB0zL7r9W/LDV
ayfvL44ODtc4gljSu4jsTIE9Erm9cXzq8ljAEkpZWFneL68ro3omHHfIOqafHbZsWcGUEth5vW40
U2POIBPhKXTvs65eN8tXeOm6MrJRH0WWKKhTvpVeN3HUyhWp1a4BMzEwurX2ssx8rFJ3wvCzz8wb
SObTddMApctOC5/BkTlyJ+Bi/2XVXVzlxMh6npVL6wZLVmnYohQWIFDInzeLOqzSCJOc272ZwD5H
CjMEiywhJfRCqvmDBNXiMnv7zcKDqNLWyEc6hFNeIaE0wdG0xRxr3rDN22MjSVN8rqDv+Bjp9WJA
1yt0H0royuor2gh/TqxPwbyRptkknY2N2NrAGMNYRP8z29nmabzAxohBy7CUmKR0fD8TOaCatfFP
FuZrfoulS+S0ChZb2VgvAkDL8OVtBTrR8/BBhkkuh9TakHKXSPDOtLfEZSTdeL6icrgEmq4jmyEr
i/OvqCK+dc6SEveHoT1rngNgwVvVOIWt1C1ptBqPGmYZq6m0NIHGhrxgZUd7AkRXdVIgsi0kXxab
ln1BnmwO9VeXWrIOEmvfmLelSM+Y5Zmxvmq6cpI+RmwbckTU6/vW54eoZuaCXoDpIYx0IaJrmntX
oYThSVmjkfXe8PnSL0UpA9mOWL3DMcKgqRkdBypLM3EEgQy8LdEDiXShc1cypxIh6ZgR32RPs0aW
fckGHotnxmsXpMpGSSV+pbbuoX0BO8QKjQCiwBY9OTotM4niYpHb8whh4c19ICy+GDcG8g49iYaT
F6sb2PT1nwSTxmF9w0gjZdsdDU5NtZnYQ55PosqJq53LqT9wTwMaWmVJZOzrrbBKByy1C/ZZQ01m
3/RpsOQIkJV6GYevc8WqE5y2w/AjyZ+0LnNLBHcmjRsSWJo6bjdM075yoK4DVhgN2iqq/zbMl43N
7SzPK9dqyJ/LLjfKqeSYe2ZSR0EuZbwrRnVZKlaIqkUWS4t5cXTx7rBLq34SHZ28OTs6+e3w+PDk
ohseH54dvCUo9389end08Z+MQm+OLk4OzyV8YF/3cbp/Rhv24d3+WXj64ez0/fmhnLbiLSzgWSD4
pzRozl4H9syIVthEF9q5qpxWOcTzTK70nrGtlPHPcVzPXirWRqVmfJeNIekqV8zZVTnIrZosTF37
Wdka6ztaF5VZwb1XMf1tlhSN3uVJPy/YeX6EkzfkjFmGQ/qgrwo2dhKMpGl7phbjyaqRC++ZDCbZ
qMhJ+hrgthHj7e42TLnW8vNNfF8XQQE2/SLvs0DHwI1gj7B+CzNkjQgE1bmjtAJzz8bxAaOM2bIi
N1mu2HHe2mScjJo2fLQ2IQEuOIALITgjG71OBEWCrbgSIMCITRcOOd2p4dCuZGBSic8cp7g9q/ma
rJaiy6s5szxmJt/kE72ZHl/1LQbrd/rEDVSYdlEKwo7KMr3NC992+JkO5XI6TUZc/Gk8nQHwYZIX
uDuHffLFcDZxwg0fgksiQeAFAPL66yEDZ4oQB3jIFaRahjjdhzWmJ+lNzk7SoQ7fIArQi2CCG3T3
QgE/xeH+gEM0aRUM58XI++6g9ojiIwe8Nsm17Sy8091mpNDBdVmKFZQtnQ1nO9tcSW4bZsxPkPQK
CLlkCU9iKmZQzf3mjHfZeILQEmcQk2UtDOxh2S+0FYrllg2wHUi+4mrBFV1EL1q/ylXD3UMKxtvy
FpqQqJJ2wXg9vY7d/DiiZVJ43hArc2u3CBtx9decimTZKMPLko7zojiO7ixFHhpomzB0pnwo/BkE
L/TOazO0a5NmQ1JXpAVJxukS03lSjZkTGeHarqIj51lVOW+Zthyjbn8F8tFG1O6i3bg/18KGm9Ac
K+DW1Arztx42emKjhUUQ+PDkNc7VZWFw/Pv+6Sm9cvT7LraQrQXEUedLSuvgNwbl1vqSEF53zwZd
HUbRtCYYsbokqqlIDa+NVaPrNPlhnhWpQg0S5CYx0+/DS5kRZq5dflpzSgosE/q0mxtkYq6qtb7G
bXDrr/l6OW208WjUdP63TsjaOqupisQLwgQS8S0cWjvwjm3PNwtaUXPi51+sI5SVegGA+AQ1LBQc
VPK2tpMaLs7vlqYmrL2rzquXwSe4dq32Mxeywh5SA4lCwzUOJc9QyXaUreGsaHo+dfALwCTEy60/
Xq+c8bta84wzciTV4Boea0GGr9Vsclzi0WWbqIs/XbnJ0/DvVbzpgfWb6PXvUcLJt0g+uorTnxe1
XSEn6ut71HJiYenOck6re9z+veP/jw8v9pHd+t3r/73cft6u/7fzbGeV//GXPMe4DTypk0jz711i
4JvBCV99a1EiEpQI7DuMG8H5bAwbyu5iSUBXClAYOQkLpFXeZAVJK0cm0z54W46zaMpFR/l2TmLV
I3p71o/pINhoj77wRUwvB69JRijKJI0+nL17XDcbVQa/SaaCfQ5OwwW3pJbpvyLEHhb6u3g6/ccI
f6Pn4JjOIHb+UBNzWLrvTEOvFgAP9w+uejCJx5kphrirz1I+h06rEk5Ymc7rprfEzG5hIeCuIl6c
lgMV5+VGs5NzHdD8qLUJ/pnNcV2o8iai9C4HBxBu4FulBXiN3S2nLDedE8AzFe7uhtthFP5KGNZ4
1RxD9Pv78yPE2FYloqN2zUIQyDpa2ySd+M1pcqMqGSMBNHxnDi5qq/GNPj1/6Pvxqwe3+OnBLTaf
PbzJ5sObbDWavJ/ChIIG5xwPiJeOk8H7c/fh9282OKVt+vZbxzliRmjn8MdHUsrKW9VodFFOSdag
HznFc5LVy3+1m++j1C7QBmVGYQl0Uz7mUmTNYdD7BJL0/izNYZXC+7ov3PZ9JuKdiqSP3fCXPSDA
ayeaRwdi0Y0u+NZo6A8bMEPTjCaGaKM3JLoSUCJCguLYoBodosDxLvyc3kivc9zNfT4l+fsLDbdD
IvLPUgoZCadP8fLT9tuK346qOo2ItEkN+GVvM968T8sxbUmkS/f9sreF2nVLGrUhLvUl8u3epCJs
xPdXN7oxDRbGN5ccLn+5PW6dqXqhB8dq/E7w6tMguPzbJabwad1wNJ/9QcCfCvtTi+ysn6SjbOPv
qp4X2d6Q1NWO6+VbXLWDgX+d5aRFCoNzTR/EUqXAGQFHSvWQDka10Uen8XxcCHyxuhl1vn/nDD+C
iAfljetdf4EJjq7vMQDR4GRwTeRAZF9tEDuaXjuo/16Xn7PJ3nTw+/WHf93m7553Hj0QQ3s6J2nB
nPDeek8z5ChnAz30YuNlr2qsuGMkHZDvGufjUayu2XwBuKfzab5xsyAp+6PRGz4KLrwrWKR5yFcH
klkZTiOH4hURctQvZm30IKY2kQjxpnLrZAoe8gDR44z3u2G/SAafvzE4tuuHrWfcIuIGkYjrX8fO
qRpu8JudIHiyKDwG7W/kUp47ZMc4PKqdqwpMRamAFO+GNCk2PNuLisPFccxNocpscXB5Pe/n0eZz
N5G6LAuaf1YPeR2vayLHtEqGpP3QdxG/T9zAdm6KV1EnncC4CO1czK/aMaoBsX5RNi5yvLe29bLN
Bzq3VEeI0mzIxjRifrSdnH1Wkch5efbmIHy589PW3XBXwwFeQr7SkydNKTIIGCCNn09VMyIHIRiw
Rg3LGSz4Na3TPbnjQ/gogHJOx8koCE5ZAg+VNlRcDnxf/2iWwxk0yR7LcftF2Tcc6+D9ic4OPvkt
HqcCzBGKqhSFXiCO96N1gJWqN82nHE0LN1K7455YgfhHthI33o6yMO4F7g2JlEkIewdJ0bBcSSVW
3heprQrKwGEn9iEt65CQ8h8xtg8xz+ychL0ecSn6bA3TDNlqJPK4fFvZTg2BmK2kUF1gjT8L5DLM
6HSrYBWMYB024Pd8SaDHVKfr5XLxD5g3e/rol1+TkCRVvCWh92zW65clrOYzrq5y5+Jemml96rXg
cNIBb0A1myApueYVU9rlimWVhUaBYA4mgG/jPuOim4UxRXbrySxFNLsi0eyKRTMGg89ZQ1ftOLf7
jMsyTS8IxAM14SQW2AnRm9nYeTe8JHV1KR30Z33a134539wmiWgEf0+VpezeLdj5k1WdIMcCZcNZ
AYfuRC9Wj5bwirYI+NQThV3fckboAQM3F6+LDZnQVzoXuzEh+rZH+PmmLGsCPoMgT1Krus6KQmk/
SaLCP9R111hY2SYMjFSDZCqU37vUa/yp59ykSsMU9v6rJyztA6PcRT5VQXCAYn/sHOWgbH/hib29
2f+XIKPzrzh+snt//pZNNsCQVb0xTP47Bpe9P8dbbEts558T9m4gaUs5r5y9TMHEouI85ZgRe7Qc
6BpU4FXm9Fg354JUArtEbMKYffi6fFBzXTZ0u8dMwVUk4onIfpw6EmcORTRCCKu3snG/TQ8Vvq/L
lKP9QkUogmo98O0Sb6jrgtAUt+4YHpzmnKeBm8DtReA2sstbrnUJzOE8qzAJfJaTTa7xPybfcW6F
nvqcTxmiK9dtDxGuyRjRHXFwxI678DaRiMFRhsjEGs5vr/euo2d9Bbt4kBeFHXv2CzGDsesm1Af8
sjoAjT1Tw8AmRMdWn0rLWb/QET7EvcUH3l4Y2OrZ4QzZiuh5rpnw5rMfFhmxMAFcH24iWabJHLK2
1A9rRfzqPSUWB0EsDk9m4+lcAK7LoA+HtpqNRnJufWUHwqSA7s+ec0kWvJS8xSc7r14+8ngXGtqg
DjqBCC60nmmewjuIas+CooeS5U0M41iyAqrMZH4rHao7mxinYHBpf2oQzmMIxvTk0cuT8F05GUUF
JwUe2NqgBFrJCQRJEXHSlifWhiqvZ9r5kk9uyuIGB9xklFW6G1dilA7uC18Y3Z9OWyy+KMupYJzl
8xxHWVdzSbrTnQUcex5CxfDldDuS4E8STrKac+q9X0CbmAyK1tWN1HqQ4G5A5yvxc8RuJzXpKQSU
KddNtKzmk0HofiMq/5zxqQNpYs5HWoc7QD7bH1lV0vwMzH5HxOaTOaj2FpEjyF51AHKICpHzeAp0
tc2RyRYEzeVyKghRWkWiNktuDEYkGftevzpDVwVytmJh+wlsJzyJnrsvS3NH+oIvw6KTrTnqjz9a
ltHcJQvrjz9ieZkdsHwTsGNbtVSREUoS04lPLdel5hlE7ku+pHSSJlXqlfbnDlge9TD99jYmhSKS
+gKsZNCf+Lez/eIFY/UTnQMYvYy3480OIfklS7O50oLYKB88krinBPjGq+evnjCVa898tLm19Wr7
xfarrR3UObnOJ5KZk2YDLnwQBwcc4Jn/waFP2XVyk3PFhGziLZfMljTKxnK5QAFiWmnh4gSwU9yi
Zzc1FmXKFJCYYfH/nHxmXLMe8hMN2mD0RamMZxv0elo6X7zFRn9xJef2sgtyCGApme1wc/1WdU1Z
P11dUurZ2ep9pgHjLr/Onxovyzf2VSlNi1f505ViK9qV1CiRr1BO0e9hDbxSh2vQxzXXGXgS9dV8
+z192aBGNPhGeb9vVfBuFXT2uer62q3CJifTPB5lkLl4o2822Vqc1ThEN369OPhw/nqt+41CW3pK
e/r/e7yut2LPfbxHI96SPfPhHg148ffMB1MVUsUeq1p3yLpXQZyxyLn3ooPisrhsoYnQyxG5G74w
lzbbr0Ph4bSJPo8VjJhNsi+kxRL/1mFoNHrMxQKK9a0u/4WCJzUDYepLhrbApG1iYFvvgJDkgD6/
poZLTmjD1/KmdOhKHLAYhMa2LKbOtzBnaj7mujo1AouZI6XlJJPiFpqRdBd7nwzzaqxDjByzCjQj
I3hoPyamLoPE2aV85pIcJonQiQv3gPpFkkmDb7Bxwh0E5hqudvnyIGB6WCxrvnbXbTydQAhU1wRf
75gv+L4QgP30LamJZRfBlEX6NI5jamMqhq75v635TWv31xnL/lBLuK2Oot0LQztm803a1qc/qKdr
4Q864pbHM9WzgQar+I9m/MfHt4eH7/5X6n9uPt9u13/ElZCr+I+/4Pl4nWVF5AV2PAt+k0RKREL0
sf1Xt3gnXH8Wbz+HN+GsLOvoSEWnswox+rt8521wkYzgLHwekUyeRUhmWAWE/VvRP31X4Q4RYqIq
rr/U37H+704r/mvr2daL1f2vf8lzqUt2X0n0g/qkb31tCL36RuBdLsO2opn/n/Rfl9Mr9ro+jPjv
Q/+b7fjPly/ovxX9/xX7bw0FK1pYPatn9aye1bN6Vs/qWT2rZ/WsntWzelbP6lk9q2f1rJ7Vs3pW
z+pZPavn//rzPzeqle4A4AYA