From 746ea42ff4616024ec41b6dcb1d2588dee4b85d1 Mon Sep 17 00:00:00 2001 From: Benedikt Peetz Date: Fri, 18 Oct 2024 21:56:16 +0200 Subject: refactor(modules/legacy/conf/lf): Move to new `by-name` dir This makes it possible to mix and match between `NixOS` and `home-manager` options and thus allows merging the secret handling directly into this module. Furthermore, the `systemd` tempfiles handling was also merged into this module. --- modules/by-name/lf/lf/colors | 184 ++ modules/by-name/lf/lf/commands/default.nix | 227 ++ modules/by-name/lf/lf/commands/scripts/archive.sh | 77 + .../by-name/lf/lf/commands/scripts/broot_jump.sh | 25 + modules/by-name/lf/lf/commands/scripts/chmod.sh | 24 + .../by-name/lf/lf/commands/scripts/clear_trash.sh | 8 + modules/by-name/lf/lf/commands/scripts/cow_cp.sh | 105 + modules/by-name/lf/lf/commands/scripts/dl_file.sh | 43 + modules/by-name/lf/lf/commands/scripts/dragon.sh | 20 + .../lf/lf/commands/scripts/dragon_individual.sh | 20 + .../by-name/lf/lf/commands/scripts/dragon_stay.sh | 20 + modules/by-name/lf/lf/commands/scripts/execute.sh | 19 + .../by-name/lf/lf/commands/scripts/follow_link.sh | 19 + modules/by-name/lf/lf/commands/scripts/fzf_jump.sh | 24 + .../lf/lf/commands/scripts/go_project_root.sh | 22 + modules/by-name/lf/lf/commands/scripts/mk_dir.sh | 32 + modules/by-name/lf/lf/commands/scripts/mk_file.sh | 32 + .../lf/lf/commands/scripts/mk_file_and_edit.sh | 33 + modules/by-name/lf/lf/commands/scripts/mk_ln.sh | 45 + .../lf/lf/commands/scripts/mk_scr_default.sh | 38 + .../by-name/lf/lf/commands/scripts/mk_scr_temp.sh | 38 + .../lf/lf/commands/scripts/restore_trash.sh | 16 + .../lf/lf/commands/scripts/set_wall_paper.sh | 19 + .../by-name/lf/lf/commands/scripts/stripspace.sh | 40 + modules/by-name/lf/lf/commands/scripts/trash.sh | 37 + .../by-name/lf/lf/commands/scripts/unarchive.sh | 36 + .../by-name/lf/lf/commands/scripts/view_file.sh | 26 + modules/by-name/lf/lf/icons | 360 +++ modules/by-name/lf/lf/keybindings/default.nix | 94 + modules/by-name/lf/lf/module.nix | 87 + modules/by-name/lf/lf/secrets/cd_paths.age | 2357 ++++++++++++++++++++ modules/by-name/lf/lf/secrets/update_secret.sh | 31 + 32 files changed, 4158 insertions(+) create mode 100644 modules/by-name/lf/lf/colors create mode 100644 modules/by-name/lf/lf/commands/default.nix create mode 100755 modules/by-name/lf/lf/commands/scripts/archive.sh create mode 100755 modules/by-name/lf/lf/commands/scripts/broot_jump.sh create mode 100755 modules/by-name/lf/lf/commands/scripts/chmod.sh create mode 100755 modules/by-name/lf/lf/commands/scripts/clear_trash.sh create mode 100755 modules/by-name/lf/lf/commands/scripts/cow_cp.sh create mode 100755 modules/by-name/lf/lf/commands/scripts/dl_file.sh create mode 100755 modules/by-name/lf/lf/commands/scripts/dragon.sh create mode 100755 modules/by-name/lf/lf/commands/scripts/dragon_individual.sh create mode 100755 modules/by-name/lf/lf/commands/scripts/dragon_stay.sh create mode 100755 modules/by-name/lf/lf/commands/scripts/execute.sh create mode 100755 modules/by-name/lf/lf/commands/scripts/follow_link.sh create mode 100755 modules/by-name/lf/lf/commands/scripts/fzf_jump.sh create mode 100755 modules/by-name/lf/lf/commands/scripts/go_project_root.sh create mode 100755 modules/by-name/lf/lf/commands/scripts/mk_dir.sh create mode 100755 modules/by-name/lf/lf/commands/scripts/mk_file.sh create mode 100755 modules/by-name/lf/lf/commands/scripts/mk_file_and_edit.sh create mode 100755 modules/by-name/lf/lf/commands/scripts/mk_ln.sh create mode 100755 modules/by-name/lf/lf/commands/scripts/mk_scr_default.sh create mode 100755 modules/by-name/lf/lf/commands/scripts/mk_scr_temp.sh create mode 100755 modules/by-name/lf/lf/commands/scripts/restore_trash.sh create mode 100755 modules/by-name/lf/lf/commands/scripts/set_wall_paper.sh create mode 100755 modules/by-name/lf/lf/commands/scripts/stripspace.sh create mode 100755 modules/by-name/lf/lf/commands/scripts/trash.sh create mode 100755 modules/by-name/lf/lf/commands/scripts/unarchive.sh create mode 100755 modules/by-name/lf/lf/commands/scripts/view_file.sh create mode 100644 modules/by-name/lf/lf/icons create mode 100644 modules/by-name/lf/lf/keybindings/default.nix create mode 100644 modules/by-name/lf/lf/module.nix create mode 100644 modules/by-name/lf/lf/secrets/cd_paths.age create mode 100755 modules/by-name/lf/lf/secrets/update_secret.sh (limited to 'modules/by-name/lf') diff --git a/modules/by-name/lf/lf/colors b/modules/by-name/lf/lf/colors new file mode 100644 index 00000000..1c2853ec --- /dev/null +++ b/modules/by-name/lf/lf/colors @@ -0,0 +1,184 @@ +# vim:ft=dircolors +# (This is not a dircolors file but it helps to highlight colors and comments) + +# default values from dircolors +# (entries with a leading # are not implemented in lf) +# #no 00 # NORMAL +# fi 00 # FILE +# #rs 0 # RESET +# di 01;34 # DIR +# ln 01;36 # LINK +# #mh 00 # MULTIHARDLINK +# pi 40;33 # FIFO +# so 01;35 # SOCK +# #do 01;35 # DOOR +# bd 40;33;01 # BLK +# cd 40;33;01 # CHR +# or 40;31;01 # ORPHAN +# #mi 00 # MISSING +# su 37;41 # SETUID +# sg 30;43 # SETGID +# #ca 30;41 # CAPABILITY +# tw 30;42 # STICKY_OTHER_WRITABLE +# ow 34;42 # OTHER_WRITABLE +# st 37;44 # STICKY +# ex 01;32 # EXEC + +# default values from lf (with matching order) +# ln 01;36 # LINK +# or 31;01 # ORPHAN +# tw 01;34 # STICKY_OTHER_WRITABLE +# ow 01;34 # OTHER_WRITABLE +# st 01;34 # STICKY +# di 01;34 # DIR +# pi 33 # FIFO +# so 01;35 # SOCK +# bd 33;01 # BLK +# cd 33;01 # CHR +# su 01;32 # SETUID +# sg 01;32 # SETGID +# ex 01;32 # EXEC +# fi 00 # FILE + + +# file types (with matching order) +ln 01;93 # LINK +or 01;93;106 # ORPHAN +tw 35 # STICKY_OTHER_WRITABLE +ow 35 # OTHER_WRITABLE +st 01;96 # STICKY +di 01;36 # DIR +pi 33 # FIFO +so 01;35 # SOCK +bd 33;01 # BLK +cd 33;01 # CHR +su 01;32 # SETUID +sg 01;32 # SETGID +ex 03;01;95 # EXEC +fi 00 # FILE + +# links to hide +~/.mozilla 01;08;30 +~/.ssh 01;08;30 +~/.zshenv 01;08;30 + +~/.steampid 01;08;30 +~/.steam 01;08;30 +~/.steampath 01;08;30 + +# archives or compressed (dircolors defaults) +*.tar 01;31 +*.tgz 01;31 +*.arc 01;31 +*.arj 01;31 +*.taz 01;31 +*.lha 01;31 +*.lz4 01;31 +*.lzh 01;31 +*.lzma 01;31 +*.tlz 01;31 +*.txz 01;31 +*.tzo 01;31 +*.t7z 01;31 +*.zip 01;31 +*.z 01;31 +*.dz 01;31 +*.gz 01;31 +*.lrz 01;31 +*.lz 01;31 +*.lzo 01;31 +*.xz 01;31 +*.zst 01;31 +*.tzst 01;31 +*.bz2 01;31 +*.bz 01;31 +*.tbz 01;31 +*.tbz2 01;31 +*.tz 01;31 +*.deb 01;31 +*.rpm 01;31 +*.jar 01;31 +*.war 01;31 +*.ear 01;31 +*.sar 01;31 +*.rar 01;31 +*.alz 01;31 +*.ace 01;31 +*.zoo 01;31 +*.cpio 01;31 +*.7z 01;31 +*.rz 01;31 +*.cab 01;31 +*.wim 01;31 +*.swm 01;31 +*.dwm 01;31 +*.esd 01;31 + +# image formats (dircolors defaults) +*.jpg 01;35 +*.jpeg 01;35 +*.mjpg 01;35 +*.mjpeg 01;35 +*.gif 01;35 +*.bmp 01;35 +*.pbm 01;35 +*.pgm 01;35 +*.ppm 01;35 +*.tga 01;35 +*.xbm 01;35 +*.xpm 01;35 +*.tif 01;35 +*.tiff 01;35 +*.png 01;35 +*.svg 01;35 +*.svgz 01;35 +*.mng 01;35 +*.pcx 01;35 +*.mov 01;35 +*.mpg 01;35 +*.mpeg 01;35 +*.m2v 01;35 +*.mkv 01;35 +*.webm 01;35 +*.ogm 01;35 +*.mp4 01;35 +*.m4v 01;35 +*.mp4v 01;35 +*.vob 01;35 +*.qt 01;35 +*.nuv 01;35 +*.wmv 01;35 +*.asf 01;35 +*.rm 01;35 +*.rmvb 01;35 +*.flc 01;35 +*.avi 01;35 +*.fli 01;35 +*.flv 01;35 +*.gl 01;35 +*.dl 01;35 +*.xcf 01;35 +*.xwd 01;35 +*.yuv 01;35 +*.cgm 01;35 +*.emf 01;35 +*.ogv 01;35 +*.ogx 01;35 + +# audio formats (dircolors defaults) +*.aac 00;36 +*.au 00;36 +*.flac 00;36 +*.m4a 00;36 +*.mid 00;36 +*.midi 00;36 +*.mka 00;36 +*.mp3 00;36 +*.mpc 00;36 +*.ogg 00;36 +*.ra 00;36 +*.wav 00;36 +*.oga 00;36 +*.opus 00;36 +*.spx 00;36 +*.xspf 00;36 diff --git a/modules/by-name/lf/lf/commands/default.nix b/modules/by-name/lf/lf/commands/default.nix new file mode 100644 index 00000000..933769ac --- /dev/null +++ b/modules/by-name/lf/lf/commands/default.nix @@ -0,0 +1,227 @@ +{ + pkgs, + sysLib, + shell_library, + system, + ... +}: let + functionCall = { + name, + dependencies, + replacementStrings, + ... + }: + sysLib.writeShellScript { + inherit name; + src = ./scripts/${name}.sh; + keepPath = true; + dependencies = dependencies ++ (builtins.attrValues {inherit (pkgs) dash coreutils;}); + inherit replacementStrings; + } + + "/bin/${name}"; + + shell = { + name, + dependencies, + replacementStrings ? null, + ... + }: '' + ''${{ + ${functionCall {inherit name dependencies replacementStrings;}} + }} + ''; # closes the lf tui + pipe = { + name, + dependencies, + replacementStrings ? null, + ... + }: '' + %{{ + ${functionCall {inherit name dependencies replacementStrings;}} + }} + ''; # runs the command in the ui/term bar + async = { + name, + dependencies, + replacementStrings ? null, + ... + }: '' + &{{ + ${functionCall {inherit name dependencies replacementStrings;}} + }} + ''; # runs the command in the background + wait = { + name, + dependencies, + replacementStrings ? null, + ... + }: '' + !{{ + ${functionCall {inherit name dependencies replacementStrings;}} + }} + ''; # adds a prompt after the command has run +in { + archive = shell { + name = "archive"; + dependencies = builtins.attrValues { + inherit + (pkgs) + fzf + gnutar + xz + p7zip + zip + ; + }; + }; + broot_jump = shell { + name = "broot_jump"; + dependencies = builtins.attrValues { + inherit (pkgs) broot; + }; + }; + chmod = pipe { + name = "chmod"; + dependencies = []; + }; + clear_trash = shell { + name = "clear_trash"; + dependencies = builtins.attrValues { + inherit + (pkgs) + fzf + trashy + ; + }; + }; + dl_file = pipe { + name = "dl_file"; + dependencies = builtins.attrValues { + inherit + (pkgs) + xdragon + curl + ; + }; + }; + dragon = pipe { + name = "dragon"; + dependencies = builtins.attrValues { + inherit + (pkgs) + xdragon + ; + }; + }; + dragon_individual = pipe { + name = "dragon_individual"; + dependencies = builtins.attrValues { + inherit + (pkgs) + xdragon + ; + }; + }; + dragon_stay = pipe { + name = "dragon_stay"; + dependencies = builtins.attrValues { + inherit + (pkgs) + xdragon + ; + }; + }; + execute = shell { + name = "execute"; + dependencies = []; + }; + follow_link = pipe { + name = "follow_link"; + dependencies = with pkgs; [lf]; + }; + fzf_jump = shell { + name = "fzf_jump"; + dependencies = builtins.attrValues { + inherit (pkgs) fzf lf gnused; + }; + }; + mk_dir = pipe { + name = "mk_dir"; + dependencies = []; + }; + mk_file = shell { + name = "mk_file"; + dependencies = []; + }; + mk_file_and_edit = shell { + name = "mk_file_and_edit"; + dependencies = []; + }; + mk_ln = pipe { + name = "mk_ln"; + dependencies = []; + }; + mk_scr_default = shell { + name = "mk_scr_default"; + dependencies = builtins.attrValues {}; + replacementStrings = { + SHELL_LIBRARY_TEMPLATE = "${shell_library.rawTemplate."${system}"}"; + }; + }; + mk_scr_temp = shell { + name = "mk_scr_temp"; + dependencies = builtins.attrValues {}; + replacementStrings = { + SHELL_LIBRARY_TEMPLATE = "${shell_library.rawTemplate."${system}"}"; + TO_BE_SHELL_LIBRARY_PATH = "%SHELL_LIBRARY_PATH"; # replacement is not recursive + }; + }; + view_file = async { + name = "view_file"; + dependencies = builtins.attrValues {inherit (pkgs) file;}; + }; + go_project_base_directory = async { + name = "go_project_root"; + dependencies = []; + }; + restore_trash = shell { + name = "restore_trash"; + dependencies = builtins.attrValues { + inherit + (pkgs) + fzf + trashy + ; + }; + }; + set_wall_paper = pipe { + name = "set_wall_paper"; + dependencies = []; + }; + stripspace = pipe { + name = "stripspace"; + dependencies = []; + }; + trash = pipe { + name = "trash"; + dependencies = builtins.attrValues { + inherit + (pkgs) + trashy + trash-cli + findutils + ; + }; + }; + unarchive = pipe { + name = "unarchive"; + dependencies = builtins.attrValues { + inherit + (pkgs) + gnutar + unzip + p7zip + ; + }; + }; +} diff --git a/modules/by-name/lf/lf/commands/scripts/archive.sh b/modules/by-name/lf/lf/commands/scripts/archive.sh new file mode 100755 index 00000000..25f40534 --- /dev/null +++ b/modules/by-name/lf/lf/commands/scripts/archive.sh @@ -0,0 +1,77 @@ +#! /usr/bin/env dash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH + +# Option '-f' disables pathname expansion which can be useful when $f, $fs, and +# $fx variables contain names with '*' or '?' characters. However, this option +# is used selectively within individual commands as it can be limiting at +# times. +set -f + +# shellcheck disable=SC2269 +f="$f" +# shellcheck disable=SC2269 +fx="$fx" +# shellcheck disable=SC2269 +fs="$fs" + +archivers="$(tmp echo gzip xz 7z zip)" +archiver="$(awk '{for (i=1; i<=NF; i++) print $i}' "$archivers" | fzf)" + +case "$archiver" in +"gzip") + ext=tar.gz + ;; +"xz") + ext=tar.xz + ;; +"7z") + ext=7z + ;; +"zip") + ext=zip + ;; +esac + +prompt "Archive name: " +name="" +while [ -z "$name" ] || [ -e "$name" ]; do + read -r name_base + name="$name_base.$ext" + if [ -e "$name" ]; then + prompt "Archive already exists, overwrite [y|N]: " + read -r ans + + if [ "$ans" = "y" ]; then + break + else + prompt "Archive name: " + fi + fi +done + +root="$(if [ "$(pwd)" = "/" ]; then pwd; else echo "$(pwd)/"; fi)" + +# fx contains all selected file name separated by a newline +while read -r raw_file; do + file="$(echo "$raw_file" | sed "s|$root||")" + set -- "$@" "$file" +done <"$(tmp echo "$fx")" + +case "$archiver" in +"gzip") + tar --create --gzip -file="$name" "$@" + ;; +"xz") + tar --create --file="$name" "$@" + xz --compress -9 --extreme --threads=0 "$name" + ;; +"7z") + 7z a "$name" "$@" + ;; +"zip") + zip --symlinks -9 -r "$name" "$@" + ;; +esac +# vim: ft=sh diff --git a/modules/by-name/lf/lf/commands/scripts/broot_jump.sh b/modules/by-name/lf/lf/commands/scripts/broot_jump.sh new file mode 100755 index 00000000..8f40ba01 --- /dev/null +++ b/modules/by-name/lf/lf/commands/scripts/broot_jump.sh @@ -0,0 +1,25 @@ +#! /usr/bin/env dash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH + +# shellcheck disable=SC2269 +f="$f" +# shellcheck disable=SC2269 +fx="$fx" +# shellcheck disable=SC2269 +fs="$fs" +# shellcheck disable=SC2269 +id="$id" + +tmp=$(mktmp) +res="$(broot --outcmd "$tmp" && sed 's/cd //' "$tmp")" + +if [ -f "$res" ]; then + cmd="select" +elif [ -d "$res" ]; then + cmd="cd" +fi + +lf -remote "send '$id' '$cmd' '$res'" +# vim: ft=sh diff --git a/modules/by-name/lf/lf/commands/scripts/chmod.sh b/modules/by-name/lf/lf/commands/scripts/chmod.sh new file mode 100755 index 00000000..9859127b --- /dev/null +++ b/modules/by-name/lf/lf/commands/scripts/chmod.sh @@ -0,0 +1,24 @@ +#! /usr/bin/env dash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH + +# shellcheck disable=SC2269 +f="$f" +# shellcheck disable=SC2269 +fx="$fx" +# shellcheck disable=SC2269 +fs="$fs" +# shellcheck disable=SC2269 +id="$id" + +readp "Mode bits: " bits +# shellcheck disable=SC2269 +bits="$bits" + +while read -r file; do + chmod "$bits" "$file" +done <"$(tmp echo "$fx")" + +lf -remote 'send reload' +# vim: ft=sh diff --git a/modules/by-name/lf/lf/commands/scripts/clear_trash.sh b/modules/by-name/lf/lf/commands/scripts/clear_trash.sh new file mode 100755 index 00000000..9052bb5f --- /dev/null +++ b/modules/by-name/lf/lf/commands/scripts/clear_trash.sh @@ -0,0 +1,8 @@ +#! /usr/bin/env dash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH + +# could also use --force, for instand removal +trash list | fzf --multi | awk '{print $NF}' | xargs trash empty --match=exact +# vim: ft=sh diff --git a/modules/by-name/lf/lf/commands/scripts/cow_cp.sh b/modules/by-name/lf/lf/commands/scripts/cow_cp.sh new file mode 100755 index 00000000..98675b9e --- /dev/null +++ b/modules/by-name/lf/lf/commands/scripts/cow_cp.sh @@ -0,0 +1,105 @@ +#!/usr/bin/env bash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH + +# shellcheck disable=SC2269 +f="$f" +# shellcheck disable=SC2269 +fx="$fx" +# shellcheck disable=SC2269 +fs="$fs" +# shellcheck disable=SC2269 +id="$id" + +# source: https://github.com/gokcehan/lf/wiki/Tips#use-copy-on-write-when-possible +# +# # FIXME: Add this. The hardest part is in checking, if a file can be reflinked, as fuse and bind mount are hard to +# backtrack <2023-08-29> + +# # This was very helpful for debugging: +# log_file="$HOME/lf-reflink-log-$(date +'%Y-%m-%d_%H-%M-%S')" +# [ -f "$log_file" ] || touch "$log_file" +# exec 1>> $log_file 2>&1 +# set -x + +# In theory, this may fail, +# but I tested it on selection with 10k files - everything worked (bash) +# FIXME: This will very likely fail on dash, when the file number > 255 <2023-08-29> +set -- "$(cat ~/.local/share/lf/files)" + +mode="$1" +shift + +if [ "$mode" = 'copy' ]; then + # Reflink if all items of selection and the destination are on the + # same mount point and it is CoW fs. + # (to make sure reflink never fails in first place, so we don't have to + # clean up) + + src_targets="$(df --output=target -- "$@" | sed '1d' | sort -u)" + + if [ "$(df --output=target -- "$PWD" | tail -n 1)" = \ + "$(echo "$src_targets" | tail -n 1)" ] && + (("$(echo "$src_targets" | wc -l)" == 1)) && + [[ "$(df --output=fstype -- "$PWD" | tail -n 1)" =~ ^(btrfs|xfs|zfs)$ ]]; then + + echo 'selected copy and cp reflink paste' + + start=$(date '+%s') + + # Handle same names in dst + # TODO parallelism, idk - but exit/return/break won't stop the loop from subshell... + for i in "$@"; do + name="${i##*/}" + original="$name" + + count=0 + while [ -w "$PWD/$name" ]; do + count=$((count + 1)) + name="$original.~$count~" + done + + set +e + cp_out="$(cp -rn --reflink=always -- "$i" "$PWD/$name" 2>&1)" + set -e + + if [ -n "$cp_out" ]; then + lf -remote "send $id echoerr $cp_out" + exit 0 + fi + done + + finish=$(($(date '+%s') - start)) + t='' + if ((finish > 2)); then + t="${finish}s" + fi + + # Or just skip a file when names are the same. + # (A LOT faster if you e.g. pasting selection of 10k files) + # cp -rn --reflink=always -- "$@" . + + lf -remote "send clear" + + green=$'\u001b[32m' + reset=$'\u001b[0m' + lf -remote "send $id echo ${green}reflinked!${reset} $t" + else + echo 'selected copy and lf native paste' + lf -remote "send $id paste" + lf -remote "send clear" + fi + +elif [ "$mode" = 'move' ]; then + echo 'selected move and lf native paste' + lf -remote "send $id paste" + lf -remote "send clear" +fi + +# # for debug +# set +x + +lf -remote "send load" + +# vim: ft=sh diff --git a/modules/by-name/lf/lf/commands/scripts/dl_file.sh b/modules/by-name/lf/lf/commands/scripts/dl_file.sh new file mode 100755 index 00000000..c7e3d8b2 --- /dev/null +++ b/modules/by-name/lf/lf/commands/scripts/dl_file.sh @@ -0,0 +1,43 @@ +#! /usr/bin/env dash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH + +# shellcheck disable=SC2269 +f="$f" +# shellcheck disable=SC2269 +fx="$fx" +# shellcheck disable=SC2269 +fs="$fs" +# shellcheck disable=SC2269 +id="$id" + +# Provides the ability to download a file by dropping it into a window + +url="$(dragon -t -x)" + +if [ -n "$url" ]; then + prompt "File Name: " + name="" + while [ -z "$name" ] || [ -e "$name" ]; do + read -r name + if [ -e "$name" ]; then + prompt "File already exists, overwrite [y|N]: " + read -r ans + + if [ "$ans" = "y" ]; then + break + else + prompt "File Name: " + fi + fi + done + + # Download the file with curl + if [ -n "$name" ]; then + curl -o "$name" "$url" || die "curl failed" + fi +else + die "URL is null!" +fi +# vim: ft=sh diff --git a/modules/by-name/lf/lf/commands/scripts/dragon.sh b/modules/by-name/lf/lf/commands/scripts/dragon.sh new file mode 100755 index 00000000..cf3c3176 --- /dev/null +++ b/modules/by-name/lf/lf/commands/scripts/dragon.sh @@ -0,0 +1,20 @@ +#! /usr/bin/env dash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH + +# shellcheck disable=SC2269 +f="$f" +# shellcheck disable=SC2269 +fx="$fx" +# shellcheck disable=SC2269 +fs="$fs" +# shellcheck disable=SC2269 +id="$id" + +while read -r file; do + set -- "$@" "$file" +done <"$(tmp echo "$fx")" + +dragon -a -x "$@" +# vim: ft=sh diff --git a/modules/by-name/lf/lf/commands/scripts/dragon_individual.sh b/modules/by-name/lf/lf/commands/scripts/dragon_individual.sh new file mode 100755 index 00000000..2465cdfa --- /dev/null +++ b/modules/by-name/lf/lf/commands/scripts/dragon_individual.sh @@ -0,0 +1,20 @@ +#! /usr/bin/env dash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH + +# shellcheck disable=SC2269 +f="$f" +# shellcheck disable=SC2269 +fx="$fx" +# shellcheck disable=SC2269 +fs="$fs" +# shellcheck disable=SC2269 +id="$id" + +while read -r file; do + set -- "$@" "$file" +done <"$(tmp echo "$fx")" + +dragon "$@" +# vim: ft=sh diff --git a/modules/by-name/lf/lf/commands/scripts/dragon_stay.sh b/modules/by-name/lf/lf/commands/scripts/dragon_stay.sh new file mode 100755 index 00000000..066b4c75 --- /dev/null +++ b/modules/by-name/lf/lf/commands/scripts/dragon_stay.sh @@ -0,0 +1,20 @@ +#! /usr/bin/env dash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH + +# shellcheck disable=SC2269 +f="$f" +# shellcheck disable=SC2269 +fx="$fx" +# shellcheck disable=SC2269 +fs="$fs" +# shellcheck disable=SC2269 +id="$id" + +while read -r file; do + set -- "$@" "$file" +done <"$(tmp echo "$fx")" + +dragon -a "$@" +# vim: ft=sh diff --git a/modules/by-name/lf/lf/commands/scripts/execute.sh b/modules/by-name/lf/lf/commands/scripts/execute.sh new file mode 100755 index 00000000..aa97fd7f --- /dev/null +++ b/modules/by-name/lf/lf/commands/scripts/execute.sh @@ -0,0 +1,19 @@ +#!/usr/bin/env dash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH + +# shellcheck disable=SC2269 +f="$f" +# shellcheck disable=SC2269 +fx="$fx" +# shellcheck disable=SC2269 +fs="$fs" +# shellcheck disable=SC2269 +id="$id" + +dir="$(realpath "$f")" + +"$dir" + +# vim: ft=sh diff --git a/modules/by-name/lf/lf/commands/scripts/follow_link.sh b/modules/by-name/lf/lf/commands/scripts/follow_link.sh new file mode 100755 index 00000000..80413990 --- /dev/null +++ b/modules/by-name/lf/lf/commands/scripts/follow_link.sh @@ -0,0 +1,19 @@ +#!/usr/bin/env dash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH + +# shellcheck disable=SC2269 +f="$f" +# shellcheck disable=SC2269 +fx="$fx" +# shellcheck disable=SC2269 +fs="$fs" +# shellcheck disable=SC2269 +id="$id" + +dir="$(realpath "$f")" + +lf -remote "send $id cd \"$dir\"" + +# vim: ft=sh diff --git a/modules/by-name/lf/lf/commands/scripts/fzf_jump.sh b/modules/by-name/lf/lf/commands/scripts/fzf_jump.sh new file mode 100755 index 00000000..ad1633fb --- /dev/null +++ b/modules/by-name/lf/lf/commands/scripts/fzf_jump.sh @@ -0,0 +1,24 @@ +#! /usr/bin/env dash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH + +res="$(fd . --maxdepth 3 | fzf --header='Jump to location')" + +# shellcheck disable=SC2269 +f="$f" +# shellcheck disable=SC2269 +fx="$fx" +# shellcheck disable=SC2269 +fs="$fs" +# shellcheck disable=SC2269 +id="$id" + +if [ -f "$res" ]; then + cmd="select" +elif [ -d "$res" ]; then + cmd="cd" +fi + +lf -remote "send $id $cmd \"$res\"" +# vim: ft=sh diff --git a/modules/by-name/lf/lf/commands/scripts/go_project_root.sh b/modules/by-name/lf/lf/commands/scripts/go_project_root.sh new file mode 100755 index 00000000..5f7746d3 --- /dev/null +++ b/modules/by-name/lf/lf/commands/scripts/go_project_root.sh @@ -0,0 +1,22 @@ +#!/usr/bin/env dash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH + +# shellcheck disable=SC2269 +f="$f" +# shellcheck disable=SC2269 +fx="$fx" +# shellcheck disable=SC2269 +fs="$fs" +# shellcheck disable=SC2269 +id="$id" + +flake_base_dir="$(search_flake_base_dir)" +if [ "$flake_base_dir" ]; then + lf -remote "send $id cd $flake_base_dir" || die "Bug: No base dir ($flake_base_dir)" +else + die "Unable to locate base dir" +fi + +# vim: ft=sh diff --git a/modules/by-name/lf/lf/commands/scripts/mk_dir.sh b/modules/by-name/lf/lf/commands/scripts/mk_dir.sh new file mode 100755 index 00000000..150f7eed --- /dev/null +++ b/modules/by-name/lf/lf/commands/scripts/mk_dir.sh @@ -0,0 +1,32 @@ +#! /usr/bin/env dash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH + +# shellcheck disable=SC2269 +f="$f" +# shellcheck disable=SC2269 +fx="$fx" +# shellcheck disable=SC2269 +fs="$fs" +# shellcheck disable=SC2269 +id="$id" + +prompt "Directory Name: " +name="" +while [ -z "$name" ] || [ -e "$name" ]; do + read -r name + if [ -e "$name" ]; then + prompt "Directory already exists, overwrite [y|N]: " + read -r ans + + if [ "$ans" = "y" ]; then + break + else + prompt "Directory Name: " + fi + fi +done + +mkdir "$name" +# vim: ft=sh diff --git a/modules/by-name/lf/lf/commands/scripts/mk_file.sh b/modules/by-name/lf/lf/commands/scripts/mk_file.sh new file mode 100755 index 00000000..41d5cf1a --- /dev/null +++ b/modules/by-name/lf/lf/commands/scripts/mk_file.sh @@ -0,0 +1,32 @@ +#! /usr/bin/env dash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH + +# shellcheck disable=SC2269 +f="$f" +# shellcheck disable=SC2269 +fx="$fx" +# shellcheck disable=SC2269 +fs="$fs" +# shellcheck disable=SC2269 +id="$id" + +prompt "File name: " +name="" +while [ -z "$name" ] || [ -e "$name" ]; do + read -r name + if [ -e "$name" ]; then + prompt "File already exists, overwrite [y|N]: " + read -r ans + + if [ "$ans" = "y" ]; then + break + else + prompt "File name: " + fi + fi +done + +touch "$name" +# vim: ft=sh diff --git a/modules/by-name/lf/lf/commands/scripts/mk_file_and_edit.sh b/modules/by-name/lf/lf/commands/scripts/mk_file_and_edit.sh new file mode 100755 index 00000000..19fc51db --- /dev/null +++ b/modules/by-name/lf/lf/commands/scripts/mk_file_and_edit.sh @@ -0,0 +1,33 @@ +#! /usr/bin/env dash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH + +# shellcheck disable=SC2269 +f="$f" +# shellcheck disable=SC2269 +fx="$fx" +# shellcheck disable=SC2269 +fs="$fs" +# shellcheck disable=SC2269 +id="$id" + +prompt "File name: " +name="" +while [ -z "$name" ] || [ -e "$name" ]; do + read -r name + if [ -e "$name" ]; then + prompt "File already exists, overwrite [y|N]: " + read -r ans + + if [ "$ans" = "y" ]; then + break + else + prompt "File name: " + fi + fi +done + +touch "$name" +"$EDITOR" "$name" +# vim: ft=sh diff --git a/modules/by-name/lf/lf/commands/scripts/mk_ln.sh b/modules/by-name/lf/lf/commands/scripts/mk_ln.sh new file mode 100755 index 00000000..7fab8e22 --- /dev/null +++ b/modules/by-name/lf/lf/commands/scripts/mk_ln.sh @@ -0,0 +1,45 @@ +#! /usr/bin/env dash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH + +# shellcheck disable=SC2269 +f="$f" +# shellcheck disable=SC2269 +fx="$fx" +# shellcheck disable=SC2269 +fs="$fs" +# shellcheck disable=SC2269 +id="$id" + +while IFS= read -r i; do + set -- "$@" "$i" +done <"$HOME"/.local/share/lf/files + +mode="$1" +shift + +if [ "$#" -eq 0 ]; then + msg "no files to link" + exit 0 +fi + +case "$mode" in +copy) + while [ "$#" -gt 0 ]; do + file="$1" + ans="$(basename "$file")" + + while [ -e "$ans" ]; do + prompt "$ans already exists, new name for link: " + read -r ans + done + + ln --symbolic --relative "$file" "$(pwd)/$ans" + shift + done + ;; +esac +rm ~/.local/share/lf/files +# lf -remote "send clear" +# vim: ft=sh diff --git a/modules/by-name/lf/lf/commands/scripts/mk_scr_default.sh b/modules/by-name/lf/lf/commands/scripts/mk_scr_default.sh new file mode 100755 index 00000000..47d05080 --- /dev/null +++ b/modules/by-name/lf/lf/commands/scripts/mk_scr_default.sh @@ -0,0 +1,38 @@ +#! /usr/bin/env dash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH + +# shellcheck disable=SC2269 +f="$f" +# shellcheck disable=SC2269 +fx="$fx" +# shellcheck disable=SC2269 +fs="$fs" +# shellcheck disable=SC2269 +id="$id" + +prompt "Script name: " +name="" +while [ -z "$name" ] || [ -e "$name" ]; do + read -r name_base + name="$name_base.sh" + if [ -e "$name" ]; then + prompt "Script already exists, overwrite [y|N]: " + read -r ans + + if [ "$ans" = "y" ]; then + break + else + prompt "Script Name: " + fi + fi +done + +script="$(pwd)"/"$name" + +cat "%SHELL_LIBRARY_TEMPLATE" >"$script" +chmod +x "$script" +"$VISUAL" "$script" + +# vim: ft=sh diff --git a/modules/by-name/lf/lf/commands/scripts/mk_scr_temp.sh b/modules/by-name/lf/lf/commands/scripts/mk_scr_temp.sh new file mode 100755 index 00000000..512b5d0b --- /dev/null +++ b/modules/by-name/lf/lf/commands/scripts/mk_scr_temp.sh @@ -0,0 +1,38 @@ +#! /usr/bin/env dash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH + +# shellcheck disable=SC2269 +f="$f" +# shellcheck disable=SC2269 +fx="$fx" +# shellcheck disable=SC2269 +fs="$fs" +# shellcheck disable=SC2269 +id="$id" + +prompt "Script name: " +name="" +while [ -z "$name" ] || [ -e "$name" ]; do + read -r name + if [ -e "$name" ]; then + prompt "Script already exists, overwrite [y|N]: " + read -r ans + + if [ "$ans" = "y" ]; then + break + else + prompt "Script Name: " + fi + fi +done + +script="$(pwd)"/"$name" + +sed 's|%TO_BE_SHELL_LIBRARY_PATH|%SHELL_LIBRARY_PATH|' "%SHELL_LIBRARY_TEMPLATE" >"$script" +sed -i 's|dash|sh|' "$script" +chmod +x "$script" +"$VISUAL" "$script" + +# vim: ft=sh diff --git a/modules/by-name/lf/lf/commands/scripts/restore_trash.sh b/modules/by-name/lf/lf/commands/scripts/restore_trash.sh new file mode 100755 index 00000000..b4ef492f --- /dev/null +++ b/modules/by-name/lf/lf/commands/scripts/restore_trash.sh @@ -0,0 +1,16 @@ +#! /usr/bin/env dash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH + +# shellcheck disable=SC2269 +f="$f" +# shellcheck disable=SC2269 +fx="$fx" +# shellcheck disable=SC2269 +fs="$fs" +# shellcheck disable=SC2269 +id="$id" + +trash list | fzf --multi | awk '{print $NF}' | xargs trash restore --match=exact +# vim: ft=sh diff --git a/modules/by-name/lf/lf/commands/scripts/set_wall_paper.sh b/modules/by-name/lf/lf/commands/scripts/set_wall_paper.sh new file mode 100755 index 00000000..2e607d33 --- /dev/null +++ b/modules/by-name/lf/lf/commands/scripts/set_wall_paper.sh @@ -0,0 +1,19 @@ +#! /usr/bin/env dash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH + +# shellcheck disable=SC2269 +f="$f" +# shellcheck disable=SC2269 +fx="$fx" +# shellcheck disable=SC2269 +fs="$fs" +# shellcheck disable=SC2269 +id="$id" + +die "No yet implemented" # TODO: do what the 'die' says +#sed -i "s,export AWMWALLPAPER='.*',export AWMWALLPAPER='${f}'," ${ZDOTDIR}/.zshenv +#nohub swaybg -i "$f" +#feh --bg-max --no-fehbg "$f" +# vim: ft=sh diff --git a/modules/by-name/lf/lf/commands/scripts/stripspace.sh b/modules/by-name/lf/lf/commands/scripts/stripspace.sh new file mode 100755 index 00000000..33b1cbcf --- /dev/null +++ b/modules/by-name/lf/lf/commands/scripts/stripspace.sh @@ -0,0 +1,40 @@ +#! /usr/bin/env dash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH + +# shellcheck disable=SC2269 +f="$f" +# shellcheck disable=SC2269 +fx="$fx" +# shellcheck disable=SC2269 +fs="$fs" +# shellcheck disable=SC2269 +id="$id" + +files=$(mktmp) +echo "$fx" >"$files" + +awk_source=$(mktmp) +cat <"$awk_source" +BEGIN {FS=" "} +{for (i=1; i != NF + 1; i++) + if (i == NF) { + parts[i]=tolower(\$i); + } else { + parts[i]=tolower(\$i"_"); + } +} +END {for (i in parts) printf parts[i]} +OFT + +while read -r file; do + dirty_name=$(mktmp) + basename "$file" >"$dirty_name" + clean_name=$(awk -f "$awk_source" "$dirty_name") + + [ -e "$clean_name" ] && die "file \"$clean_name\" already exists!" + mv "$(cat "$dirty_name")" "$clean_name" || die "Move failed" + lf -remote 'send reload' +done <"$files" +# vim: ft=sh diff --git a/modules/by-name/lf/lf/commands/scripts/trash.sh b/modules/by-name/lf/lf/commands/scripts/trash.sh new file mode 100755 index 00000000..f4878c49 --- /dev/null +++ b/modules/by-name/lf/lf/commands/scripts/trash.sh @@ -0,0 +1,37 @@ +#! /usr/bin/env dash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH + +# shellcheck disable=SC2269 +f="$f" +# shellcheck disable=SC2269 +fx="$fx" +# shellcheck disable=SC2269 +fs="$fs" +# shellcheck disable=SC2269 +id="$id" + +trash_output=$(mktmp) +expected_error_output=$(mktmp) + +while read -r file; do + set -- "$@" "$file" +done <"$(tmp echo "$fx")" + +# TODO: why are we using trashy at all, when trash-cli can do everything? +# +# try trashy first, through nix because both trashy and trash-cli provide a trash command, which conflicts +nix run nixpkgs#trashy -- put "$@" 2>"$trash_output" + +# FIXME: Find a way, that does not depend on parsing an error message <2023-08-29> +cat <"$expected_error_output" +error: Error during a \`trash\` operation: Unknown { description: "Path: '\"/.Trash-1000\"'. Message: Permission denied (os error 13)" } +EOF + +if [ "$(cat "$expected_error_output")" = "$(cat "$trash_output")" ]; then + warning "Deleting with trash-cli to the /.Trash folder" + # this file could not be trashed because it is on the tempfs volume, trash-cli can do this this + trash-put "$@" +fi +# vim: ft=sh diff --git a/modules/by-name/lf/lf/commands/scripts/unarchive.sh b/modules/by-name/lf/lf/commands/scripts/unarchive.sh new file mode 100755 index 00000000..d4835f6b --- /dev/null +++ b/modules/by-name/lf/lf/commands/scripts/unarchive.sh @@ -0,0 +1,36 @@ +#! /usr/bin/env dash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH + +# shellcheck disable=SC2269 +f="$f" +# shellcheck disable=SC2269 +fx="$fx" +# shellcheck disable=SC2269 +fs="$fs" +# shellcheck disable=SC2269 +id="$id" + +# extract the current file with the right command +# (xkcd link: https://xkcd.com/1168/) +set -f + +unarchive() { + case "$1" in + *.tar.bz | *.tar.bz2 | *.tbz | *.tbz2) tar xjvf "$1" ;; + *.tar.gz | *.tgz) tar xzvf "$1" ;; + *.tar.xz | *.txz) tar xJvf "$1" ;; + *.zip) unzip "$1" ;; + *.rar) + die "rar is a unfree format!" + ;; + *.7z) 7z x "$1" ;; + *) die "Unsupported format" ;; + esac +} + +while read -r file; do + unarchive "$file" +done <"$fx" +# vim: ft=sh diff --git a/modules/by-name/lf/lf/commands/scripts/view_file.sh b/modules/by-name/lf/lf/commands/scripts/view_file.sh new file mode 100755 index 00000000..6258d755 --- /dev/null +++ b/modules/by-name/lf/lf/commands/scripts/view_file.sh @@ -0,0 +1,26 @@ +#!/usr/bin/env dash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH + +# shellcheck disable=SC2269 +f="$f" +# shellcheck disable=SC2269 +fx="$fx" +# shellcheck disable=SC2269 +fs="$fs" + +mime_type="$(file --mime-type --brief --dereference "$f")" +case "$mime_type" in +application/pdf) + "$READER" "$f" + ;; +image/*) + "$IVIEWER" "$f" + ;; +*) + die "Mime-Type: '$mime_type' not supported" + ;; +esac + +# vim: ft=sh diff --git a/modules/by-name/lf/lf/icons b/modules/by-name/lf/lf/icons new file mode 100644 index 00000000..9047fbfb --- /dev/null +++ b/modules/by-name/lf/lf/icons @@ -0,0 +1,360 @@ +# vim:ft=conf + +# These examples require Nerd Fonts or a compatible font to be used. +# See https://www.nerdfonts.com for more information. + +# default values from lf (with matching order) +# ln l # LINK +# or l # ORPHAN +# tw t # STICKY_OTHER_WRITABLE +# ow d # OTHER_WRITABLE +# st t # STICKY +# di d # DIR +# pi p # FIFO +# so s # SOCK +# bd b # BLK +# cd c # CHR +# su u # SETUID +# sg g # SETGID +# ex x # EXEC +# fi - # FILE + +# file types (with matching order) +ln  # LINK +or  # ORPHAN +tw t # STICKY_OTHER_WRITABLE +ow  # OTHER_WRITABLE +st t # STICKY +di  # DIR +pi p # FIFO +so s # SOCK +bd b # BLK +cd c # CHR +su u # SETUID +sg g # SETGID +ex  # EXEC +fi  # FILE + +# file extensions (vim-devicons) +*.styl  +*.sass  +*.scss  +*.htm  +*.html  +*.slim  +*.haml  +*.ejs  +*.css  +*.less  +*.md  +*.mdx  +*.markdown  +*.rmd  +*.json  +*.webmanifest  +*.js  +*.mjs  +*.jsx  +*.rb  +*.gemspec  +*.rake  +*.php  +*.py  +*.pyc  +*.pyo  +*.pyd  +*.coffee  +*.mustache  +*.hbs  +*.conf  +*.ini  +*.yml  +*.yaml  +*.toml  +*.bat  +*.mk  +*.jpg  +*.jpeg  +*.bmp  +*.png  +*.webp  +*.gif  +*.ico  +*.twig  +*.cpp  +*.c++  +*.cxx  +*.cc  +*.cp  +*.c  +*.cs 󰌛 +*.h  +*.hh  +*.hpp  +*.hxx  +*.hs  +*.lhs  +*.nix  +*.lua  +*.java  +*.sh  +*.fish  +*.bash  +*.zsh  +*.ksh  +*.csh  +*.awk  +*.ps1  +*.ml λ +*.mli λ +*.diff  +*.db  +*.sql  +*.sqlite  +*.dump  +*.clj  +*.cljc  +*.cljs  +*.edn  +*.scala  +*.go  +*.dart  +*.xul  +*.sln  +*.suo  +*.pl  +*.pm  +*.t  +*.rss  +'*.f#'  +*.fsscript  +*.fsx  +*.fs  +*.fsi  +*.rs  +*.rlib  +*.d  +*.erl  +*.hrl  +*.ex  +*.exs  +*.eex  +*.leex  +*.heex  +*.vim  +*.ai  +*.psd  +*.psb  +*.ts  +*.tsx  +*.jl  +*.pp  +*.vue 󰡄 +*.elm  +*.swift  +*.xcplayground  +*.tex 󰙩 +*.r 󰟔 +*.rproj 󰗆 +*.sol 󰡪 +*.pem 󰌋 + +# file names (vim-devicons) (case-insensitive not supported in lf) +*gruntfile.coffee  +*gruntfile.js  +*gruntfile.ls  +*gulpfile.coffee  +*gulpfile.js  +*gulpfile.ls  +*mix.lock  +*dropbox  +*.ds_store  +*.gitconfig  +*.gitignore  +*.gitattributes  +*.gitlab-ci.yml  +*.bashrc  +*.zshrc  +*.zshenv  +*.zprofile  +*.vimrc  +*.gvimrc  +*_vimrc  +*_gvimrc  +*.bashprofile  +*favicon.ico  +*license  +*node_modules  +*react.jsx  +*procfile  +*dockerfile  +*docker-compose.yml  +*rakefile  +*config.ru  +*gemfile  +*makefile  +*cmakelists.txt  +*robots.txt 󰚩 + +# file names (case-sensitive adaptations) +*Gruntfile.coffee  +*Gruntfile.js  +*Gruntfile.ls  +*Gulpfile.coffee  +*Gulpfile.js  +*Gulpfile.ls  +*Dropbox  +*.DS_Store  +*LICENSE  +*COPYING  +*COPYING.LESSER  +*React.jsx  +*Procfile  +*Dockerfile  +*Docker-compose.yml  +*Rakefile  +*Gemfile  +*Makefile  +*CMakeLists.txt  + +# file patterns (vim-devicons) (patterns not supported in lf) +# .*jquery.*\.js$  +# .*angular.*\.js$  +# .*backbone.*\.js$  +# .*require.*\.js$  +# .*materialize.*\.js$  +# .*materialize.*\.css$  +# .*mootools.*\.js$  +# .*vimrc.*  +# Vagrantfile$  + +# file patterns (file name adaptations) +*jquery.min.js  +*angular.min.js  +*backbone.min.js  +*require.min.js  +*materialize.min.js  +*materialize.min.css  +*mootools.min.js  +*vimrc  +Vagrantfile  + +# archives or compressed (extensions from dircolors defaults) +*.tar  +*.tgz  +*.arc  +*.arj  +*.taz  +*.lha  +*.lz4  +*.lzh  +*.lzma  +*.tlz  +*.txz  +*.tzo  +*.t7z  +*.zip  +*.z  +*.dz  +*.gz  +*.lrz  +*.lz  +*.lzo  +*.xz  +*.zst  +*.tzst  +*.bz2  +*.bz  +*.tbz  +*.tbz2  +*.tz  +*.deb  +*.rpm  +*.jar  +*.war  +*.ear  +*.sar  +*.rar  +*.alz  +*.ace  +*.zoo  +*.cpio  +*.7z  +*.rz  +*.cab  +*.wim  +*.swm  +*.dwm  +*.esd  + +# image formats (extensions from dircolors defaults) +*.jpg  +*.jpeg  +*.mjpg  +*.mjpeg  +*.gif  +*.bmp  +*.pbm  +*.pgm  +*.ppm  +*.tga  +*.xbm  +*.xpm  +*.tif  +*.tiff  +*.png  +*.svg  +*.svgz  +*.mng  +*.pcx  +*.mov  +*.mpg  +*.mpeg  +*.m2v  +*.mkv  +*.webm  +*.ogm  +*.mp4  +*.m4v  +*.mp4v  +*.vob  +*.qt  +*.nuv  +*.wmv  +*.asf  +*.rm  +*.rmvb  +*.flc  +*.avi  +*.fli  +*.flv  +*.gl  +*.dl  +*.xcf  +*.xwd  +*.yuv  +*.cgm  +*.emf  +*.ogv  +*.ogx  + +# audio formats (extensions from dircolors defaults) +*.aac  +*.au  +*.flac  +*.m4a  +*.mid  +*.midi  +*.mka  +*.mp3  +*.mpc  +*.ogg  +*.ra  +*.wav  +*.oga  +*.opus  +*.spx  +*.xspf  + +# other formats +*.pdf  diff --git a/modules/by-name/lf/lf/keybindings/default.nix b/modules/by-name/lf/lf/keybindings/default.nix new file mode 100644 index 00000000..b6feffe3 --- /dev/null +++ b/modules/by-name/lf/lf/keybindings/default.nix @@ -0,0 +1,94 @@ +{uid}: { + # Remove some defaults + "'\"'" = null; + ";" = null; + "\"'\"" = null; + c = null; + d = null; + e = null; + j = null; + k = null; + m = null; + f = null; + + # Sorting + kn = ":set sortby natural; set info"; + ks = ":set sortby size; set info size"; + kt = ":set sortby time; set info time"; + ka = ":set sortby atime; set info atime"; + kc = ":set sortby ctime; set info ctime"; + ke = ":set sortby ext; set info"; + + # Searching + l = "search-next"; + L = "search-prev"; + + # File Openers + ee = "\$\$EDITOR \"$f\""; + es = "\$ nvim -S \"$f\""; + u = "view_file"; + cc = "\$sudo -e \"$f\""; + fe = "execute"; + fl = "follow_link"; + + # Archive Mappings + au = "unarchive"; + aa = "archive"; + + # Trash Mappings + dd = "trash"; + jc = "clear_trash"; + jr = "restore_trash"; + + # Dragon Mapping + dr = "dragon"; + ds = "dragon-stay"; + di = "dragon-individual"; + #dm = "mvdragon"; + #dc = "cpdragon"; + dl = "dlfile"; + + cs = "stripspace"; + + # Vim keys + h = "updir"; + t = "down"; + n = "up"; + s = "open"; + + # Basic Functions + "." = "set hidden!"; + DD = "delete"; + p = "paste"; + x = "cut"; + y = "copy"; + "" = "open"; + + mk = "mk_ln"; + mf = "mk_file"; + me = "mk_file_and_edit"; + md = "mk_dir"; + ms = "mk_scr_default"; + mt = "mk_scr_temp"; + + ch = "chmod"; + bg = "set_wall_paper"; + r = ":rename; cmd-end"; + H = "go_project_base_directory"; + R = "reload"; + C = "clear"; + U = "unselect"; + + # Movement + gjr = "cd ~/.local/share/Trash/files"; + gus = "cd /run/user/${builtins.toString uid}"; + + gc = "cd ~/.config"; + gl = "cd ~/.local"; + gE = "cd /etc"; + + "gU." = "cd /usr"; + gUs = " cd /usr/share"; + + gt = "cd /tmp"; +} diff --git a/modules/by-name/lf/lf/module.nix b/modules/by-name/lf/lf/module.nix new file mode 100644 index 00000000..ad4173c3 --- /dev/null +++ b/modules/by-name/lf/lf/module.nix @@ -0,0 +1,87 @@ +{ + pkgs, + config, + sysLib, + shell_library, + system, + lib, + ... +}: let + commands = import ./commands {inherit pkgs sysLib shell_library system;}; + keybindings = import ./keybindings {inherit (cfg.keymaps) uid;}; + + cfg = config.soispha.programs.lf; +in { + options.soispha.programs.lf = { + enable = lib.mkEnableOption "lf"; + keymaps.uid = lib.mkOption { + description = '' + The uid to use when constructing the `/run/user/''${uid}` path. + ''; + type = lib.types.ints.unsigned; + default = config.users.users.soispha.uid; + }; + }; + + config = lib.mkIf cfg.enable { + systemd.tmpfiles.rules = [ + # This file is needed to trash stuff on the root ('/') temp file system. + "d /.Trash 1777 root root" + ]; + + age.secrets.lf_cd_paths = { + file = ./secrets/cd_paths.age; + mode = "700"; + owner = "soispha"; + group = "users"; + }; + + home-manager.users.soispha = { + xdg.configFile."lf/icons".source = ./icons; + xdg.configFile."lf/colors".source = ./colors; + + programs.lf = { + enable = true; + + inherit commands keybindings; + + previewer = { + keybinding = "i"; + source = "${pkgs.ctpv}/bin/ctpv"; + }; + settings = { + # close the server, after the last client exits + autoquit = true; + + # disable the cusor in the preview pane + cursorpreviewfmt = ""; + + # preview for directories + # dirpreviews = true; + + # count things in directories + dircounts = true; + + drawbox = true; + + # errorfmt = "\\033[1;91m==> ERROR:\\033[0m\\033[1;93m%s\\033[0m"; + errorfmt = "\\033[1;91m%s\\033[0m"; + hidden = true; # show hidden files + icons = true; + ifs = "\\n"; # internal field separator for shell commands + #info = "size"; # show the size of a directory + shell = "sh"; + shellopts = "-eu"; # e: exit on error; u: error for unset variables + }; + # TODO: remove auto quit, if it has been added + extraConfig = '' + &${pkgs.ctpv}/bin/ctpv -s $id + cmd on-quit %${pkgs.ctpv}/bin/ctpv -e $id + set cleaner ${pkgs.ctpv}/bin/ctpvclear + + source ${config.age.secrets.lf_cd_paths.path} + ''; + }; + }; + }; +} diff --git a/modules/by-name/lf/lf/secrets/cd_paths.age b/modules/by-name/lf/lf/secrets/cd_paths.age new file mode 100644 index 00000000..3b018fb7 --- /dev/null +++ b/modules/by-name/lf/lf/secrets/cd_paths.age @@ -0,0 +1,2357 @@ +-----BEGIN AGE ENCRYPTED FILE----- +YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSBUaUtDc0NHYjY3cWZ0ZHlh +bFkrRXpuYWhveGpGcjVIM3ZUN0Y0Y0ZLdGtJCklucDhCdGkyUDl0dXBHd3BFUEMr +SmpkWHh4b0hSSDJ5N0pTcEJmS241WUUKLT4gc3NoLWVkMjU1MTkgelpFb25nIHB5 +YWZKSFd3eDNYUzJnSDFzUzMydjAvNGo3czM3cDVOYU1NdTEwZjZwUXMKQ2MyQlBO +VEtVY1BGWk9JWGJ6SVBMRy94c1hPUWpsTndBM1FRbldZdGhMRQotPiBzc2gtZWQy +NTUxOSA3SGZGVXcgZXJEMTRKenk2UGNNZjdZMmlVdkJYcFU3cjdXdGhRWXhZd1Z1 +VXlyRmhXUQpKZWZDeWhQcDB4eXhuMTZGM1lQMFhma1FkUmpMMy9DMzBLclF3cDdS +N1VVCi0tLSBaZGJLYmRpd3JRNVBLeU9DNCtJMWxhTU8vVGNtcjhJRHRERFdHSXVK +QVVJCsDf6LK4+HTF7SEzvqcR7MmWCfWEzivFmgZBzv60M8utLu45n92LkOSkPg77 +2L7il4KF3a3Ai1efvNqYCVtf5BXRGgI1jub4yoMaS2gXH8xwMehIpSBoDiId2AFw +YSzzZNmJXWQ+wzc+k/PlKO5UZu2S+QnxbUYNAGHQW134jA7j61lSXGiBHbF7an4/ +YX2ElCfe0N1774rgXMQHW1g4udvAQ8ZpaloSuiupJXB/bEuFhAhT3PAfPdF7vvgl +tVdeuMVITU3oYrn/5Ej1GJm2PILxEim5+Y/aDeVKva+Wn81buombADwpW8csOdOi +UfRZ4m0j0Fdp4T9EAGF5n95id+9FUnBqe4936yPT/hH1mwZbixiePDm6irEB+lsR +1zLmAoTUJsJW94JE7BgucM10YwrMI7clYS0lYLDx/HRuZPVlIcsgaEcaoLgR8M3h +H8S2QDscKnDO6sCp62Wiu30P65LXOTwZrDcD54ddx8+U9uU9muT+ZJtADL4KZUMX +AvgfrH9jKOirBrviwEgF74FcdugTlKHQIGBPfasPS3piFMQcPbCm+GCU2MBAWdoT +5iXDjObmpwNBzUiCeVLeEBYA0CuY8xxAiScvQZG+4gB2jpnnEqDOqGmG8h79JWx5 +AtsuBzIGq/ykgqQDbWAHV8YL3Zq+1f0OaaphuZ3/GsrHBtAvW2ScL3cpab/8kQXB +Xgp7j7DGjoScPFnsLuYwKOFihGI3edP81zHc8Q8YVc0VkfJexJ+8Ll5beevzrN5w +42CWj81j4XzfRnU9SxEVABiocv1oRYwA767kqaWHyKpGEO3z85f2wLQgVGk3yW0T +dXcUX2pTo1mYcZeW+cXhw7f+tQZwBHt5Ky7XRVptwQwpWOxb1XGOBx+PrGZjOzDp +CNbbxyw3VZWNme6MIYyrjgu6E6xY4Yk44pHNYM9tFixPnE81YIsC6ZHRkYCj1E6m +DXquScKGBPwOI/knGkC7K7NsyBG9/HvgWVaJvCmr7DjWIJ9lANzvu9yMv+iNo6q6 +fIi/Exr32dJGt9hVCF7XNiQm1kjU9FjZ/uzsMg+hguBBQE27aIp/PJhr/MI8/PYW +iWhWTHm9nlR0Crzewp/mWUtaOZ/tKxNV8Hm8jk/X7ZLlrbctp1d+SS8AwqKBwNx5 +HK+3AZsg4NYSdhQAuow6vO57xA/CniHk1nsuQc2bIlQ9C1R7j/YPjwjb68PedHlI +bbZHtkF4f+nRiRa8dgy9/m7rhu4a+P4ihBQ3BAfxbZD1g3TgRgS3TZlDagSaJpx2 +V7kYRYReHwCqXxQDpf5CzCSod04cRUiAXP2UaiTZkeX7F2E10M7DQkXh6SSDsdqH +eMo1K3V/r4SkRwNSGSDre4B9WjF97GWh71Co+6nHNo24wexBZJ2mtY6Nz4CPecDN +5zmOUno+gkzN0wWzfhTFp87ilYo6JrBxHprvtw2/yRiK4FhmFlR7WYrVDXDhn/a8 +cVGkvkhPBH8kJvBsBQ33dNY4nsMVs2n8sE9Mz2Rwjh7/FPaoY84f0qtCo+be829W +8HIUZ7CLgqKGNzx5UJ63XzMF/PPfqe7el0tyKnigJNPu0vVeqMCy+e+SS/HQz8PS +Rpw/CYnI7ZqbS61tRGUQptumjo3d3EWch5a+i/XJH5RH0wIhxiNHQ6EBdJzwgKRR +pSpOrubIqb5/HPihE8Ynmz2KvWdX5dSpmGf/rSmdYlBqitHtPOVjJH4vkP/lQzbW +QydFQH3pV7tQWVvz9Z47Kf/nAouX39PAyqfB7zWbUMHym3k8ff7JeFbvzNf6bgiP +vt0fWCcJctU1tfkFNkxHei0Ue0cvqYur6iCuiunk8nhqRZdyRQeNFYfHn+aEN0Sx +lv6Z27e8koPiEyquRpNpPGN5RLMViA0QfSYios4u95LN26yY6I6qzv2UgMJ1rp+n +GoMTa2D7aVVxwyv5f5Kq5k66Mv0fcVOCmYxg7nZ4qC0hxpFcIIgLojSfWvCwelf6 +z0wuLvoyxwsz3O/Sm2PD4QE3hW+9FqJPuhKoVszJbUv0lEs7o6RQNvWVn+M4dGbD +FuB6k6svvrvsD+zblmYJdSUm31TET3Nw1eKgjXxIXm1Sk10s1gpBkfH5OVr0VxS/ +elf4ixKA/+r6buwHdOnOkqm47kJphwl/v0DWsUmCXbAMGPOXhtRJmvNfd0Y+3FQE +G7PDQMUmKXN55KifSpmQf+mXb5N+DM8VnKd2xsvQtjlYF3yzFaECgi04WAV5rr/F +Y3xTSirPvfDnw2XlOUQM+1snebDfN+njNiLu32W6EsDnV41P9LOLEtb+1C40W8uC +ojWLjmMzPENM/EYYaJJ2oxFFd1JA0fb4x/fq4R44GLnZKQjqayEOVT+jkRQ6gPtT +nBdn6/wtl2Zyq5lwukH4YOOm6gbpSe4ggXlXc0ncPHiSIFlMT29ybaw3cD7TKBYv +iMFnH8yZx9mHlvwq1ykzM4XG9eiZEWUebfF33AxS59wzzFrJgDjdEOsY3uT1IMM3 +KSBvS8r8m3fbh/9KuEbXpWRJj+Z+0rt9+eZNpuyVQGEF8irY+84boryqow+k8C2o +eHLMBG5rz2yL3hmWijRnru+PH7WLi1AhnGdKya1NLfvKWzXI5seHaxzXfB+OPkdj +PEZFWOYx0bOcTBEY6tWUoIW/FLRmw4v0aGbs5NmmrPMaiSmPfT/caQHpACj/e9h5 +0JU+oooUMLPAxmLujaHG4jB3II4HfBrcH+9IoEa1DNBAe5iMeJcRMnllAHFCydB1 +bkR1Fgo1bN2UWrcEtFtyhhHf+boSZ4afw2EEZAQ5XsrhRRg8XjluGK2924KU0P7Y +aT/Pi4d0sdUJJ3lqNVUGVl/7paf5CZ7Vvo8emLZzvcRc13dqlR51qzYwn9pAhYcf +b0J/hNKTcc/hoabfHeDhW2m+qv2yKUEP6KQM72UQp2z3njoGcYXcNs6JXXxvXKok +qLpchf1ZENGF6yocfaOBWs7iMR6CplMciGKz2qNeVXNqmrNCOqI7D5v3s0M9SAO0 +SzlUUv6OtyfJ0Ji1Pj8X7VeIl2kYrJRHmsbev4uR2sCzXDapDvbBUT0kEqEsiB4T +onl9tScgWVxW8er7zE61wCcjzioT+X8kiwaGMnQqte0yPxi5tMKR3oAL3M7kgb4Q +JyB+9vFcngdgf+BlW54kCSGCMEOJ1M2X1Fi0iBkJ5/Z4PIpRJQqNdiHEx1KMHIQ4 +tNj4GOee/hhxbD2ojJCqaA2Ng+iZeBcwxTsZOyibYnv3FFU352EPYrSzW0mJMsz3 +iZVlvVsGgEPf2Vs+XrayMOyyrCiV/yTTV9vwxSsyxDFLW40Ng/9UzsNJSTdqINy3 +Y/zH9liHj05dbdKL1ASsAdYo6piWXATyc1kCqHVDQBrI/D6H/equA+VS6ID6Efj0 +hmPPwGa304edBrkbwGX24fPhIIn3gCFewVRKTyD+3UBJAyGm7GNV8XY1mMuZJxbn +u3aa2hxho1DHCd9uP4CptpW3X8OC228AlPxYptSv/tvwCqzjpGgzaueqLT4e8+Ls +N0fIR2H5ro6iFgRenNEDLeZRum5/osP/7JAJCBUtWkILATlUJRqFIWSAjhzamnOe +o3bQ9bmm7nT/2Id65eUIfBDtbiKdLfQ4XktoUirAfpCPrl8MQcw3CK8giF2KgzX4 +h6gHDO4eTXofsXJig4dHHAKShIjtcRRNLZVoKlRqQ2njw92anF7dKTjEN1ypdM2j +I2/I5gVItoSg7gpN/xerhb8paE8l1lhh+J6MqNMkrjrB9fzWYzI7oqqkyz7j7MOl +feBtSwIG8xHD3QsVxgrI7imFOuAuICqC154bHrOTkI2Y0RH+9R0H8laziaN1ai6u +dAkUe2H0lTYEBQRh5PK58oPYh/fS69907JUGGprYhei8WKbTzdMwHLAlv32BNYfu +nwVZzk/v4iV6p387aSNGTSr52TeomIG3sYFipGG0kWkCvkaNFbB5FiTjBM8F6zD0 +0ZNbgrVmPFtcuk1FrGTwfe/RHbeokpHSlpJ6jnn9mkTgsUaYMZ3ZNHAnRq7seawO +n6dIH1wAB28EkzxZmpUMR94k5LHXR/NsmigQf0W6IhtEkSsJnfEH8TfwKEYGr18f +vODPdMQjTtzQwkn1kmVNV+8bymnqrfpyIWrlFrbawGExGr9DQOfwyd1JSWHpKOw8 +TPxumnUNM4CQE3ozgpZHtQ1SvcQwkx4Mop4fw9Bgc2txaJ9lCw/ttrRd+IIyGu4B +nqDuYt0EweSR9fITsF/OOJuiqPL8BZSyK7czXWk/S0RzioI3+N0Ta/0xZaf1pSBv +PWWIgOIlC5a6dtNA4LBJgOT7e+l/e10OHI/rEAjSdTZlYIseUOLU73BBeXe81tCS +DKS1LlGhEGorv0+d77/hvDiV3jzQEu1v2p3Rk7twh4SXXAfIeyyEfpb86HmOe2my +ZsoeIm0joyuBArkdqOaep87kG//hUP8Mn7GwPkqZC8mgn+4/2oyz4a+Y6t6zz//V +389lbFOxK0g0IIlkmdsJ4SaTVh5BkZBBRe3Vw2+lpnKJtOZz4zueRaTfIW+tQKqc +DhQu96478kAOpwm0sFRZBORb1hmCv6mDidK79Y4dqSX91B8V9xIkBDxEfEKMw7v4 +nWNVlwbPeuKOZ5D1n36OMDx0D1Gbz4iKAsqKSoP4ai7985RWsSd9GpP2N3bInRFg +UbfV5UeG9C/1jATxrzBFCFjdHVL1Z47qXSCiqY8QGO7JVoHqgw4bwoACNiKbnl09 +HJBo3pcFfvHTjg+u+XdKLbarD9By0XYCqnFq8bN+HSeDEkurji5/pIo7yDLbLmZY +QCxCfC2D6fGr2U3T0u5Avp3GDSO8UKCBLGYgCz8o1bbPz0xHlvy3SLnERU5sueOT +61THxjAbcoi4fOCBS+u9mD6liwOX18Jkh9q0KubJfeN6tCx7Y9h64ZMABqU0q+Gy +SNPplzdlmzhQEC0ASc15RdxkLZakBb1/Zn0LI+/SRmCTM3xd+ttca1Odkqdb7UAB +25CJbHzYcHysk/IN9uCgxCPlXa284I11FnUW4MwgZ0d0tLkwIaoaXhDuCSJKxLOu +Vt2P4Ahdq/fjO97uMlKGuWePL1A+HLaPBKyIxH1Ic5hQeTkd8zaZQ1dnItKbYdix +DtKNcFP1U474dh70I0TRK34+sM8bFQHyHWQ2OwSrci++FO42K9hyOuIXpBpgUHhk +h/uhK7nIoDzvj1dWfi0yh53vCP5B6o4jf5/tFBQ7EyalgWTHVwADezkhTfY/FOiy +8lqUdeNbUE0grZBQXGDEdE0ned52FKNelrosF7jSQw5AIskJRf7NH01O3nH3A410 +de++2MzKwT/1TwPNghoGGFvQnpz9Qk3fDiYUhr6vSMInCGMS2oNfZWq8PnxZCGSJ +X8MQ2WQ7YN3lKzTfAR9aQ3XyXC8n1W/10vYOkO+mEYK7qqhmbDELaBN8JTAHhQA9 +QwlduYpqIjATHkXK9VgihVDrrBDFKBg9pzgzG4vPAjc9aSMJCRuDGPQTZHDW1Bk4 +0yE2Whing10btUFtlbE9CSK/XbHU4fEEBW+PHudNNx5ZXvdqdOuCNyWlOZT8otAu +0Y9vXKdVMlPOTzSC+HQd5qS1KolUtWGRIoYZMMJngm7B089EV/jq0VE+l7nizkYA +coHNcMxkiMhJ1hFXusEHQ7Vfnjm/ZiKr7oOkLQhpI8mKQdKaRyH4JiTmmyAs7fpq +2RYb5r5m0zVz/7EWdNPmzfix2xIdIWzP9lSmmBIfalrRrwoaB5CLEXHxO9H8niLH +Lo6ysF5MQ48/rY4VEoQek4POQVV8JroGTZ/U+T7/s/pvjTd6cQoCxRWXCp1zP8nk +mUYLZsxs7MxT/akvaFZ1qdivfneg4GMNfc42VOE9vkSQZzGGIhdWsCO1+ZDA2n0O +z4S8lM4RvVAepbVKi4qdKRC48beoYKqrC5flwuKqzRr4KzapJf8wdWjJtxUEjeSs +q50ElglibRbY+5iJ0M/XUTDBrLCu/sVfzVylHPOq2sbZh7cq9Gi1jSJiOJoQCAAd +cPB7GJ8PmWbITJ6aZbjERJBehpFxcTv5Kluq/vKGQdF+rhVCrPh3mzan05GTi+0K +gB7nM7Z92S5QooVHdeAS7CEiNJeEiAhC8QQ/NJfGq7jCbxIPbUc2RFRa7WMyS3C+ +uwGIRMWBcRzod1mYPLt8T55I2xbXwBUmvNojIGfdtzRe2PH/HAgcRIqqPuuJIeiJ +mteF3bdDV3MapKoSMcfnMLg9zW57Vzrrhnf9IAOJfWlIf3NxAx4wBxPMEKgE1dcj +CtWkOJT3lOSiOBT5r+AqlHtMKiHmpy8Rf/B4gDa9CosgTP825YLp+19lALSVz6E0 +bN2uvkYnPWHYpIif860gt+u3c3a1DKsjqIfeS0sUGUH0fqACTstoV/866RJl1WQ4 +3FGyONvAZpmmXlxt6LL62lfw8cygp1hA6ifjpsRLTBLGOl4bB/c4UKl8Q9yqDMM6 +yR3fqjfyBhy4n23UO+ZMOPY10XoVWd51uvC/xjcrKOyKfOg1JRwzdc7ZNbE2AL5Y +5F36YR2Ytf8Hu5KHnZu0FnTqb2yVnN2emrEXOzvLSVhLvecVZ7cgqoKJKsCoNHAf +nZEQL2Dq+YjsNrJqocWqxu+wwl9S+IXfTiVba0I+tykzZWzGClV6o1+pYwH566ak +hKolPBL5Y9ViaXgnpQZp+WioGBysawGUY3xveR7a8+3DQhgWvl7rHeA/7pR+qezL +41M6l3TvlEcSdosmnyzOHzcksiL7+y2/cSjfmSVU+8qqoL9uEywW/AJ0ND4qkNxt +3cNWLPWyyPbmaC5Lu1FdSRJKix+sAMxJG2/Y5W23tCu1j2HjD5t0W7CP7srAVFrr +6KbG4/b/cjzRVfqwhGQE6pw2XmWpXlVbxGNFayr7a77/4LpRJkLvY3/pc+pYqWrh +wQN7TagYinIid0j91BzeRzpTt+udyDyJR2XrSAhOZjNSAZ+OKl1qtq1gMzfSCcYO +uJnRwvAypVstX48F858It1FIZEpkQ1f+/3HKpPElFBWmTiRTk4JbY5jMWUUng5Pm +03+NEnmhkHwY7wBcCSxn7tsMw5d1hVzbcDk8mdphkhklaAHQoSl4ZMqivUThT2cj +Aih5BvulDp2uA2opC4d4mFPdaJkCBZx2R5KQJz1BFuSzkpcA1HNFM08yqouXrTOD +KThC7ch5/x/VhigxlpjzPML23EZAzXR3wP9IGF9Kn1TnNjmWBL0uc35lDpDeH+Hp +1Ly4XUfdimNdJaVdi4Zxq/cL6f/dIHGytUoTCAOgLQWJLlh3zO0L6uBDPE4AmFy1 +/i/8IULFx/xh/iuhceYGDKFZpBXFMzCcD4oBfqQ1L20lkZ7TnrnVWjmvNy0hiSsw +BE4Bgfdt+7UPmsdYGRut5kXKxyfXx8Erc5wqgHdJmayCn+WVoCk+dnc6+60v/DEo +oH8UiLSIwN1kLQMkov9RopwznqzaCqxn+F1wJY6vuxjb7DdNih/6qcnpoOr8FvLo +EfjZAe0+ErTt9eOxrgiavkDChnauheuBlSE+aWl/ZTJa9VzCLrdgWBmJdMbr2wNG +wHHVBnyyMfegPHyF7Wkg4/xE4IbFwr+FdNDDRP2nOONnvIxg6YBm4gq5VYhyshc3 +oGYsNh1oDCjhM/w4TlSzya5FiLZIfmzJfEn80MwEZMg/7O+5FQ2HxNNoP6WEVgt7 +JXor0EaMS8Ccvpw4ayxRdbiplE25AdHaIF3t0u4ZH2mFT7YSLW/z3/Jj+eoep3KN +I76BdB4Hc35GpirHbokBb+RuWVRblxnzCJJHJ5sL3NBJWKbPMsalifEIjOkfvr31 +IHON1wC/fETKI1/sWFE8SVCopQBcKU/8yO1iyWuiYyhNFOBptt8GcQDMuMBs9rDV +CT+dzfxdXGJoxWUhMJfRhMwUKL5xhrypvmt923pCH15ocfAVRVMRhQJ0O3/M37nn +XcGwQqvXpB+1OkFlV9IMP7IJv8k35sXs/PVwSQZDH24q/dVQXBqGaNUc/Y1Gku2O +rO8ztzZjEAeAfU5hios4c7ZsKlcx9yormEEth/FtGsw7ZCuJlUQabIiJ0Rw5JCKd +Pp3PZW1leS96Oe3HYrx5g9tPAxRNmW1xjgD2aRnfi9oAqn5DNJ082AaG4hzUSxaz +XWjS3yWtlDNkHNSuGE993X/rRSNHlE7qtfh40GORMUrvWsw2C66IZsF61ynCV/UD +uJP3hNaBKjtVKDWRf8yQxsfua9VjyGMBNj4ggBo6DWDyXtx4m8vV/y6Y3G0HB5hO +7/fQseV49sKHaiW9Iiv2vQkUlAC45QuknvHLB+LvvvNHxlQ+jDMhkTF5zUsTCj8A +e+EUA+WJmieq+/F/uy6yKl10ish/k7696opAgoki5+xSjzHlckhuXNC+Z21vRXaO +1RNy8USnBGM3/3RvEhxsu4GIS4ZRKZHW5Hte7BCB65mFziTZqr6Y1+F6Uo8oPau9 +//2upqKuGb+4BlQL3sYED89LzAV4fMVsVnHbrL5hRh1zdDIm6JlhLL3uXJH5LnAP +V5P5lSYT89Y5BI1rml2gwxbJxebckJqvO+LenDHu2E9ZraIDaL04rccJyjf0K5cz +BlB1R2z4hGiMHDbaQnIWAVFYDscuxNn590Gp2wZ5DQ57h2oBnt/tmn+1r/mRzXDU +/9W1VXaowoTr6RE2yF/9U/Dq0r1/Mkm33STm3UG3u8S7TOUx0+bbwBeS9ZmhEjQQ +vYuWhZTn9YdKACPHDvKX8Jnj5cOETBss36bbib79hGUsr4ap3EaabaBcwdexLmzR +mm2SsE0Kt2R0sfFmh6USbS86A4ROyrdc/7QWHNIKM5LSFcd8FgTTp3C2s92SfJLw +MpuouwXlRsvvKDej25JqYjFpWdWrjstm1IaF5TGXnfd0oAgv4XIfDJfEXDA6VLAn +CQBDbJ36kpCm14xPMnnq7o2SdxhO1XzVPHiw/0goOJ0UUyNowkMCuBfYOgp9Rq4J +zeaFN/aTSnGeeishTY6ydGJ6t/8L2wpwPsGxUAr8eEoqIYFcaasmMg9T9u756urL +VeOfp+RyY98p+zCaZMiY29ZYVPhyqBH0ttqapiCRhM3UnaYnGWkcvpZcmPUwPuWB +zQ9Ujnbqftoai6FKf8oRRkL4nWk96qWU0EPJttL3bCvEvmnViVh5dBGrdcF0BIqP +l381/hIwCBAkaj3Y17wAYSxTYwTzCqc1fBrAfAf+d1J4C9WRw16367HU/8zCUAZ4 +9dNfRxc6xzK2S2C2IHWjYCkRFTzr1KTHNLxdXWWubnoLmUoNsZnZlKLhGVGuNZDC +lgsCFRmzFhw6Vc6uGX3lSqus1uAi8qmk+Pk0oTRC30c2hkjyfPCM9yQVDXEjbF2o +B81UCy0KD8PiLLpQsr6JEHZhLPfU3h3w+pIJ2yR/mpGK/IeDJc5Xb0jfUdD7mQnt +mBiKUzb0ZbAv0FicX1H7KFvgpX6Lwtbq+7EFMWyIxYYXk5PauGzU2i9JrY5wXG8E +GBOmZ1bZ0IbZJGcxy12Il3XwpXr1TAe1qkpOVa0+S+PPqz4A8DioWo0Il5bik7E3 +ZSKDWzMd1OkkoRgvQS3iQdvhu/U7buOJF6c+BYcmPkrAiVsbWeguXPTzDRw0vRfT +brOeYkinAovXUfy4G444CSNiUuU0WZG2XgL9pVLKdRK4ftIDGKPsT6xmYjZBdsv2 +EL2Iz8nIf+iKKUkNJjiSDgjN/kj0HSc1WHQbzBn0Gn34K00Hxjcg5sQBq3UTJ5iE +Ct0qqiLkwOw7fG81eoPe2NmT9yaWISixG6fg6t6pXU/gohAnBSqYZLbQnym8IEkp +T4KPHYgBsHXROU6iy9az1pJ7irr9sikvR4SpCLLdGqyYdHIA0SnXbZ/kqhdqQzoM +zIwc2kZ5YEo8YXsAwirt80zXymePa7oezfT1YkqS1Rp9S0/7FRToJxze+p0++7L7 +X6E2qpy/sIimXk1uc467FcPdY5DgzCXZltLSPtH8gnG6iGPZ+ydDfunEOqZW7qyT +l5BohxQ96PdmME2EUxmik7Y96G3M+uDqZcz943LYkbC/UmUY+nKVrfgip5Nbm0F8 +9grTDCofAxRS0Ovs9rr62PH3FhSZeQujAFVdxYsgxkR32Z9blJHNz3Y0KE2zhirN +NPYwwl7sPSdqB5jvUWNiGh7stbPuACvMs90cRZ100cgOVwsCPigtNNNV3Yvrfwrf +uKFV67yuEqDgwJzis1ppMOidMC1glHS0kcT5nw2CxcUeYt7dz7nbyLlGpr0q58EA +xqbAn/rbUPOaB0C17MHDAPByVO8PYRKodsSF9GiKHZ58C0g/ebccpiPOolM9reRC +USuvfYuBQBqs+cEy7B7gTtAD3RcT5CGRg3OZn8EClRAHO+UjFgoD8rE+onSxlvfj +oRIEPWC8xRyivVfnnwCnXUeMONgBt1cP56jU0N+vjj0o3Rr8znfVEsq8Y4RhMJjF +JiRNY4uReCyl5sbUeGBIij7kDudpAbd871FPs8tpxPOdWO+4fho6GmUVIKgiVYF1 +uzbAFCX2zfi2mjdnsBTAk5h2s72/nmrfTHO0qpUxPfLeotxPTE28UuwP7EoRemCQ +GkTXQ0BDqw7hL01G0B8hctD/t5o8Cqm4mCmVWyyJpaQ+xxYVfDhgRU/j5MtFR0PY +kiKSLdOVsU6KmWAg0Rp44QcseIw4rMBTgsoSRDNKt6HitR3AxGVYlbMBLMLSAiWW +dPKw1YVlyQ3t44sryocdAmA/HuIyi7ie83JQYPGr6idCBob3y8uEIgVZhCFnRhdg +gwszCfLD8OjflsTyCV+X0Zsm+8ZRe2WgIGTIUEQPI4xxtXyB1BGx5qPm+nWSrVRz +4mLLzrYxvzBfKbonZh5OTg3o3dUYBRyMNo5f/08vpM1/aOrCYnwSQ7gXXOgBnJdy +k5OdihYU/3tusFuF9eurESmwJtJmZqljtKsM10lHYDtm4Uflgfv6ZiX/To8Aa/xR +CwitTnHzzl2utLC+0tLvSj++10uzRRnl00GoAc1DnJ4gwokZAuqOlBLyfSOz5HXU +t41SwGKYsxBu9SuvyOgIV+xwhb6+EOpwzXANyCrm8YdKpecziiJCuB1jpcKrBbAF +aqG/Tg2SicWvbtlN4QjSWRgb1K4lIsvYpNU77KLR9wblEM13+npqHj4HqxT+SRoz +CmoZ9r7y7VQgwdD99tvs+iBYfIKx/VHC/vER5Fv6tGgGRpSy0yDFDfsfj+YUrQDO +qjU2T06xqoDxA6nJEi5rgXSOTezAOgWHr70Q9DPuEvXH/ZRH6cjKhvA8e+71GfpD +FaE8/rv1Yj3PnRhsF9d2m63q1YI74XoxmNlmrfj2AdAbMGnT8xbVrhp9AhsHUfEk +BxyAGH4n+WVvpFLZKF9y11Q1Egxxdm6pGuC+LBiwWNRCW0PXPgcOcm7Mq3ETa0z7 +A9yGpletdDX4iaeq/wmwIICvOZ1GcfFfHX38qttPPsqz1uiCi2ZJjRjbBwmXFKwK +L9F+Nor+z9ieBzOk9ijh86WGLAxC9WoTmU7+LY4AV+ScqfA8MAPeiC0L4dqOUK+y +/OfTUMtBdwaCzLbANr8zDfO2B3RqHrbH9IQHpTv+a9vnpUrvVNdDK22Go1Fp5IXT +RfuaHa687LKUgo+TOIXjjQRydI0ehewAHBs85duHy6GN5TiFh3lDnMcdNqVid5Wy +ImzL9qS4F6GMtKiJqk3XSZjn+j1Ui7+gO8FaMZ2dfT0tXY+cyOSPm2XEML0jSjcH +Djs/32u/hdfD60vsbi9XiaF5sgbXlmHzbnUT5MuGxI5INS4zT/ddYf7YTz1SL8vO +4xRryAqoh3/DSWsFUUp7xUyDPI4a6XbC7agZ3BBa2CtTs3CYAa+9io/K4eEmxLzZ +3FUEtuTHCvIr2qdgYI8v8Y2aHRwA3ID8rlN4fpjtClJMLBS3426Yb50SzDGSiJ9q +DJjSLsPfm9Z18bYHorOGNHJwzx5OppjlVSvqtVMlJctHdZXBx+tfWgJDKDBJIzlV +/ggKhluEE2EtKPWitjHYQn5h4YQ/97Purp9xOzmYIRJNYS63My+Bwi5EXQ7+ugCr +0JvsIqKUrEOuxa8ikCSenwynzpvCBd3wPzYLe30FN4PJRvsyY9wz6+4gpDXZg/Fm +DlfLLOZ5RsiqW9YmnXA59+bIBTOlSY3MKx1MoW7QscMTGlEp6zh+8kKS+e/cfbzw +8qEaV8DHIuPi+HfsF0qyAqkWqr4pybuDcmcnyfLfMUhEUrNWkv0uo5bbxxKfmeNC +EEZTaQ94hFtLxlvO5bNXZoCuJVTmRYAKx4OIgsAbHifoXHkZl+NJF3FhHrsNpeqN +moUZq3N8Ukv+m2ddWiOksU4vDaRU3b71w/P6AR/R1uNLMO1zBFzqfAcosl0kwsP6 +jnLS4l2Do3EbSQAXU8X3xL0LJ7R/v8g/j9UJaH66t/6Q9xpaARwzb2RnMlNE6J4j +eUHewWqAnjaq59SV0d2d1aKGP5cVPc52Ru9NqF/r3ruAAQW61sUakIkBx96y4+hU +Pk08lbC/uR6lzGl4cOYt+azM8EplPnhHdEn/mwkYoKfpFO6Obqr23bsYXvPvm8Ir +TRV+jCHiV++mVW6U6iNJAVPXJTJSWg26Z3RQFBMhK9rLOdnxMaAM6VEy2EKxhkna +YJo904CpKsi2z2gYIrlJ2EF3EwyXt5yzUk4lmL7Nzy3hzfVHJkg529dNXkT9hUz2 +biq/g5gMLzVdKGdGlGcId8iQ9M8V9m4r0evGS5SJd8wi7xfvzKrBGAbcGs7QOmry +yeNN+Li+YZXnTcGhmR86Rfa8JG6v29kPNfSaHREtC+b3FdaD5KOT9EhUJfYDMw56 +Ah5aTJQu5ZTfN/ePi7+DIOFu1JQ7cISvNjs7kLuDUzYJlcDIrxvuxljd7f0Jqvey +qhkK/yc+7Uia0SvTbi++DIblyf+0Z9hp7h1LV1gC0boDCSivg7a6rs8t77VbJe+0 +zer8Jnv28ZL2R4BYXvv4Tj2z9UFBSjFyF1hkC50bGgkgK2rvMXv4LjZChK+o8yJf +hpGyzMS33TLy77WEM8V87uXk2Tom4nph1EqJHlnVSV2O9pMN/i+hWbaEFLmtV5t1 +OBjnQiVXAT7E3zl/8VMmL+EV6178znhgF3t3qdYJL8e1bZr718n/5xcKU3uRQLmg +2SvxfVmfh/ku7mVFkBNxPYfaLzcTUMY8Ltlnv06vUNTOELG1LTnClou75RgvYbxH +S/wnhOe7Uf+5gBb8PtcFSCm+VwURuZOJcjDcd8RTgcKq5B2gXAzDZ2mPawbA7F+V +zzySxhOKnfJyY+mgoayx6DMcM57/STB26NpLfeWOE0Qr8NfgfW2FDWiYfCZ7aJo4 +ZQpqSUMkKDcXU78Qk/ORvyxd/N0yW4vBnDOqcME4xFy/FcrPkBvF9ToQLxo5V9BZ +f2b3gQlfzA4XQPWvzrLXwmLfFLW3LTE9wMb5317eCSb8u2QDE526sRtACdPaYk+s +E50kEWZrigROUEYwWrWv5wtOM/p6QG0gtRTnJtsairijYBorSVyKQp65wqCZxmQI +TiyK6sn150D2lG4cfRfzywhQcZUvf13V7jFdS08s7jP3svuxGQCrQbXf7+L7YqT0 +IhMH4W4/EVZmLPgw8bu99rU1EMPQGG65PMt+Wmo9qtteqLxPn2+nNCC0VTuSdMGW +7PuVqtUlXU3FZuiDEvB9X+c5CV7gs+HlBtsVxolg7K8wivqaLp3EvuzFisKyPnck +B5zLMqXG+olaScjDO7U6xOkXMrGR/LljAYN45WFXi3xmspI9NrbqBdh7g2LNt9cD +27mwOMeoQApfZEoxD8ubWxkaFQ6ITSXjwvRj+o4n9G3yXRACPTKbIlSTSLqJ4W7c +F6jSHzXUHwMNtF6VE3EiRxGFqASA66jUzRA5CeJn5zO7qr9TDhq2te5YJueO9iOy +pdn1VOF0UYxPNmVbfAF+0JZ4qQQ8xGp+tShiX/tHgcA1TDd478ZL4ZugS3sJLOmH +JDU9IzxV6IVktxhYJQJaa5KD5XPeebav247c1esyidQg3uocTekAKgssvnVd2+Pf +WqOV9H2ORcOxkbWfB5DD+eJ3yjWZi4wBt/YgCrX16ZDVRnLOqn8qh4/MhdUUcyVu +yVR3q/KaQXxYtzaWHpyTO+aYokmsrbh5x8/dq/RrqDuVrZbBztk22kydG5amH1lZ +NSTdEBz2RWck0u5kLH7+nDYrjalOiyVCa4vlIu5EqZLXIcffLe+jQB6Xq0vKaFg2 +xkWwn9J5si7Jw3ut9r057KlVXIJhd4Qi/UZam6Xb6udZ9iP4QoFyjeDDKOzZfxar +8uTQs6t2/ar8n+jVIYe+xkCXyLEHent+gj+NF20OGXwQWaGILIC1mcVUoh2Wgugt +u+CGbC2WPH+jrsRHZ59AeokrrUEUEirgfGlEQJB8CrsMkjhnUpy5g8l47APZrOsl +STmBH2GCCIZ230IyE2G7y6Du5bHxoxkCj6S5ATjmNJ+z94vHh2cuCsFqebhCvqH8 +nhWHCF4qDalN/VRWY4gBQbYu3SyOOddzS1Q/AsFj9tMWkQsPBDS2wiz2MskBYv8s +bTvldU2rx5X74n21I1nDhAmNYNaYBy8jyn5CWWZKMiLeeSVNIkEwUK5MPrX/8ixG +xuI8a+R3RyUMbEg2gcP9rBxXNkj9O0MKKquVJVEpjVFosWA/BX1gWg4mdVFIYEGx +lRaJ3g98WcMITtmjYv7EdnFm2ElU3C3oaQSsyd3yI1lmAqQwOrwRwcwPsPVHvig3 +yzvbIRuEAIAvMvF3HGZBLATlG/fn3XhM6zfORNwq5CWZng3jJVH6A5wBe0X/g6WH +G68Nb6SVi8v7ErEC/aOSIomdGnP8aPOq/M4Pvp7Qj5YiF3cVRps1BvY8O/JQhlUU +ld8JZa2p+98PxkJ9QwrM5N1J/LAT9pqMmAw+2l6kx9Rjm4HWBnPapKXuQygWbWpx +e9Qf52wX9pQjysb5lNoJVSfTuqfEkmvqBW1ZSX76DaxtNox2awB6dbknjfK5btmG +4lwIPwHFzu2PXiCy8ciKxjc77KEkZ5Mg9Efz88qF4w8SiMvfN1GN6C9wpAPS3Xo2 +WlwySbDskEz6c385aFUEHYipxzStBxs6F0HDaWa5SoNPGvvIqRT3ZGcBWPi+tzqp +bV3lI89iH5dfxYED5MzDwMyrj31rpyWWwZrxpV4vujSHnB1AR6MVoZRlsV3dmkRS +eQQJEFjzgQ7Y5aZlnjnscZly5Z2Lb4tGx2OZuZakzkAXuk57tge2/hdwxGmB2yN8 ++pjoCAxnNldeF/hZuYPHwa36gX+2gvXoaHT56Y0sYBI3QSvQlloWQkzZkmCs9UYk +rHRzhxnDOSB06IH66ZgilLlaZutWnpWpp8lJK+I00HJFEImEUyVwiw05XjmNoQEn +zQsDd0CTtcJZWaf29WvuuavgEaJn1GnQe6PbMQitKOmZRMQSQ+bieRhHuo3lYBxL +AWBA2+/bm2jQLKPNHS1wGAMe1wWE5980hZ1dBzrL3F4oxI4g0djoV4sUmm0KYsoz +QzE8SmaE4DCah2vYR+CRXXGzrvrp0YVMUmcMqmlc1Qa6LkT+9w7hlO+UqgB4CJIW +CrJm97mk/4UCSehwGi6dF83uRNLo67msUhRGRbG6xW34wH06by+ZDM9TYgjK1Ogn +9O+x60vJWjdTBfAbKVnpP6yE+BL/gHCfXn+ah0l1D74s5pzzr3W4pGthVd3gJVR1 +YNDe4lKdyS4/N4ScuOJjOwa1Xsv2WfQKq6X4dcroGhIdrh63NSy9sMBGNOlWSILF +HF4RlXdhYEhTO8p3TritH2Nq8h7pTsU5b1tMOBS4LjuhP3CjZHBXv8+PmPZAlcAD +7PATaYe3yiuz1zFs3iJQ1Fd2oR3XF6658SQbMPlWzGUpRFlvGRtnxK3UzKYCkIIx +gsPGhJ62MELIDVdh3HbyMvHURMWqUF2Mjk707tWbcpDfXpVmhJD/wxoT88Wt1X70 +WhZiLjvUzYoo7izPEiXy3QSzYIbNDhs/07D9QJ04J7y/S7Mw//LB015bo9DekX69 +W4qHyhVXnn3Rf44Hh8v3EpBrxEQY/uezmvG36YdS78LVubTiMfsxeLB8iKXniwiZ +AjBkB15qaae+VLzXvlr5yzPa+86DBlYlUmIJb6b8NW3ykXcz096WY04gDCNuU07D +FJfc27CUyr6ZB8dshzxtjDmMJsn6i/LGTx7+13wPU2MAeNmsfZWBNr9hydOSbtnx +IlmktBcsPtw4/UtPtn+7gKbeHRIkJd8kRzcWd9EDBlzRW8gat5a+2ccfcJ4NM+3P +TPFXb0kMZTXm0PpXS2S06No+AOI224IB23fXjQsh5U1FhWsRQXu0LhgryXiJS2TF +/mhqhnslFJkU4frE4HMHTtfYPxvSHTZjp9yXEWffPmA/jxojIVg/62dKbkR51zZi +XAVbXt5Ez666DJU3t4/XhMfknsyN6ynerB/qX/Wi8i+nSSPOA6V+Nv7IXDruJWdD +pg/ouow1PXAswkaq5LOSZDrxnyPRidBxSjPrFZuCia8CFzmoRiCWCLF2wuRFupeV +cl3VZPj/0P1D9PTPkRoX/M7Bi0Vn3yAQ8S4VTZpxZ1GQrCPnmowFU4aJ6R7fCPmY +wK4wU3EQMyo4be7mDHR+5qrf+LhkyPIonrSPw+gCUg8x8imlaC7J+h9jRWlWW8Ly +gfdG8Sk20o3ibKgiUEOehZ5JjE8vcyOhbEZ6jnJv0GB24Q7ovFxL/QeY7D6s3lTr +pH3hKNdm2vfFjm5Ns5QT4ORw3xmzMefYZf/85oFNgTs3KM2FKPQHAN3BmIU7BiA8 +mEsti9D0RgLGmc1V+4aXsuynGV2WAqkdyFpeNX6g6QG6JwkEB5bRmcIXGPIS5NGQ +jAX1/skcNkgl8QWmyanYnCdHewyXotRHFQhD+Ylf7DHsYDQwSw9QInmNd027eCTJ +VX19GMV+HI5HscE0TGA0Z5jwFVmAuVtf1X2meGm/CfP0Zy+jPvx4H0zdwvSFncG7 +zoNrU+MMc0eeg1Y/WhgJCMSFyHvrCcZm3UpnwvMMWkwYtkbOgcgeoC5X7NJJm9ra +9j4WkutM3fZsQSxu6DUNhuRncBnWPIo0RkXnzBSVIxiHWrLofN2FM4xgrxXiju9F +IQr2yX9oqlVzk955UzV1tN9FVHlPy6gkbYctOoZHu7dzEmUte2oil/nAn266K5+W +hc6leHQNZbC4ctHodOl/UCMPAQ2lRZ+Zhb1xQW10/mnj5DB3wXg9TziI31OC54mx +xyaueUjAcPG/TGu7FnPPWO6RCIkCjt7JTa/pw//Q9ZvS9FCtfkkWxlfcm84w1mz+ +Yu4JIg9XfeAxFHnonR+A5RgQRZ5EG1K4XRqBwWGEA3O3OCYoPGWsdNG27E0SLaBd +CiFthw6+kJlngcHK/OUhCIdygjgd5QGcAwC2zFXkF+0a7XSyI5yca7Dl+0JGFBQO +L5SxM0Pv2w7WMIOa7aN0Rk4vl/5sNDUtWUGQbVpr2/6v4BCPM2HLY5UZkNTyM0ih +bbyaHzG6yLoln3dEBm4cuwIiyqSNmKptJCWTn+xXGnVPNgc8QU6rtUUNE0t8Hiwr +gHr8Ye/Bph1MLXPCMuiTjg/FFSfpAB1gNE7r6FObkZgfB7AW8XrzJ8d/4sUOJ9NL +NsAHHgewtZ/9phesULrDv4KzOKySLoARPPL+LDj12nXUzcSNua2HN9sIog98zR7q +53NUSgom/gsAnankLDRbsTLG8Wdq3fD5sKwl1d+wcYY9xDluZ4ugcVYPG3gVnqQ+ +u4sWsszmU2czrvA8ejFCOM6z5gfRleBfKMxgz92QFms4U5d/J5lLtG/9Zt6gWcsx +6740DOv+MJp6o6uWcObPQEUKKJolLdY2ijZaY/XDWGK+5mB1iYoQ129Zm2lAA7sl +6MwQuPoPCT1cLc4jxB1Mq2BTp209bOKZEjpVu6r0WRUtSOtuK9Ol89IzzLJZ/UV7 +FIOrxcw6D62wrpxZvrSt/VTFws3vycfqOKKZ/y50d4gufAi9F457U7K0c/KGr5ys +EbHAYiJ+hZc8G8fR5YRpsa/7vKsNgqAx7kKchFcfP/j5gO3ADP5KnPRKwZy6b6hO +IfWkXXdzA3Xe3x+RYvW+DGKLGdgdimvru/X37gJYLya9Kv/71kgoDsUSJv0YAztI +7UAxQuW1E7c/jp5RCTOQ9Bkz+MscWVFCUXoxMKctWC726VSXPbfzZp/7Mp2jOP+L +0kBJX9n8NwoGLC0bvWOCr0Ts2RFx3wgR3cJ7ZKlMy68xCnQQ2nm0osWZlAd1ExNm +IlB5oMStRVdE8jcI3GYmmv5TfnoMPpTmy+h5jyNDN10kV2ZoQb8FyFw8wpBy3aT1 ++2wIy+yiAh7YPIBH+4FQy8IHY53A1XxY1sz5mTIru/KVE5/ErVAnNcNcfOOTHFO0 +4ZNU5b6DyuOjz9UIShSpt5dbkTSOw2FXS8uXaa9JCfuW0EPdiSHkax6lyarpKkQA +gkpRriOxWS5/S8VUNUTFfAIlqE8cSOGYSPznqTBH4CkTVksqkDbfgA6RsG3FvX/R +4L/PPyCWek5jp0Uey2en5KKVu/qjPYafLnA0ol2MlIVTYuTZ9xb/fmBFqzXrgZ2k +jO4s175oqA+/C4Cs1+0T4PABuLJPBXf6rwny7CM7eXbCs/dA70YeOgjCjHf4O8Gz +H7YVwvfvQtqYimYhMBCSwj+B9DFaq23PiY+kAv7NpFw5MB76tCz9bKP5DAwytRbe +fzmks2QGDXi2rYJ3XCbEsKYymte88CpmaoZdsoRqNQJGN0wuvTmkYDC9+vKcfa/v +F1FRZZKd2AeYt5sWTCGlz8Apyv4uGHrYVWnGd2Ba76+zayXimGnooJYW19SDbt62 +hl2JUn1wdV7cLsWor/vUk8aQ4ymA2+FQoAYc3mBy8JQx3Su48QIFCmT+Tex9JBz1 +Vj5IKfYSXMl7PTwmS/lzQmfyKI4vK4x1DD91S9snD/bRvVnP+g4NbzKa0LLbDX+p +WA4Czl19Jt9fcXa7sOcIcHaT5nUGH/KVPKg+kQRzgqQ5l214DwzaCXpGcwDI7LGH +5us6c6uDll+RCRPGX+PHndJK+SE02RVn0P9u37+8d7tcRH5pGnXUuGTIDH8gNg72 +YRxLxPwGEgiHfap8hhkcC8G2gEWcgtrshhLhEmc2teuKxe/y23QtchxYURN/QVk5 +S1wboDdaQWeXa140XPv3gzXFL2UQHck1a83S+jU1FnbvtjmvcIWvT1osAdyqAZM7 +Yi45bu9WRHQBrX1uOHmBsdpLQcFH75jkDmxRVX1+651fShO7K8VxzsY1UyBxpK+I +5K2yIn4ggEZt/IoQv3lW3Te4o70eFykWYEDm22BPSk2Y6pC+jO8ShAXro5zHK2CH +FZqwacX3htrEgcMLd0VKymi3E9VRO8pquv5VLYuWk++brBEe2YIPTazn/r9ZZif0 +mBF2ddjMQ3e2lC9J7rarOcCESNU8rGA/leAlgwU8e//h338d9N+buL8wX/E4wOyZ +W3nirSbCWca9N6gmggltiST6stEkAmhveeXMIhljsi6pfHIVZgC8gyS0RdaoXazh +by/uw0CLJHy23Gb7zJ3SUYnsOZeNtXmj47kqh2jd7alMkA4lfekxPfELlz3Krv7H +jNpeqB+A4D1Ecsg7XKaXjU2k6mUaDETCdSXTwBqNSdpII61qhe5w5+d8A1S+DhE5 +1+Dt9CF6cSySY+YUargAglWLLNPo7wGvMs8hVTNsLzIH37AmQIDeTa4aXTxsb8HG +dbyN0yZu2R2q++g9xHyIhqOAEkDPoBIqPhNqIttHTD4h3by9Y3SRdzrPhR9wsR8U +5SHUJRJH4gsEO6m7q93XZNvM2/isFYUxkUsvmo5frJlTs0oq/xbOspjcYtEKrbID +e0L9S8zYoFlbEF3flkrkrd1ngZjdRLIE/pocIbi4dh91UY6bD1BJqwIctmerATcS ++qtY6pP9YTQg/dES6H8GJJHaBbESnJJFeNh2JZQ8JN0FlzewZuBW1Dh62L6bEwUg +2EnOpdO318DHDOyZoE2XEecZYUDprWno6SPjg7DwhaSwveisRlXerOgW1eA5mSJE +j9LwfDx1S5EPrr6SLQKUWn04TqdtmVFoZB8yVyNI6vHFvO5wdx6g/t+KuaD5tGEP +KjOA/wraKpVY7t8bds3QWj9n45lYvzNvDPW4ly55nMcc2o6oej/S9U9Pe2IIVqLe +1Jgw8Ec0RwExe9YywFanp0k51xX5JLGqxyiY2UiBLfYhm/Jg8fK1q/J8HksBDsHE +U6ZKYy1Gcu0f6qyIlA74c7Vy8HZ9QRN2c185ugLRH48H+cCRCCjK9dJL4JMzBG2B +qdon8hxtJPZ+9WdARBZ8a4s3SzL+nooXEviz6D5NmmlU+c/JMOrMzKxr6DEllrSE +5fRhPNrWszqGbyWAWYVPw18sMThSN7BKQL/ubqERpKGuw6rwENhnvy++S4a13I15 +0n01SMAf5QHrBW2SkMkzkqirvkSuGBE2BRYfDIXAfDVdLQjnuneedsBwQlpsHSo6 +wjrU7bGafm1/DpovaGEp5j8J+8/Egy+gM2akpvaO6rFQs5bMVdOmX7FzHZJ/jGvk +SqrTTMxAIUVZupAGl/HQI9oDHzR2ZuHo3vQ/unHEDSJF2B7xck6r7z6h79mbYQ70 +IKmE62EfXFOb7LU9vzK1/L4aONKgWGizqIbGnyQuhBHLyuJW2Uoj9w1rThMOI/vk +5x8RRlfc5hjCE7Wcsjol2f++lYxHvO8RJ0TxOYTydQLhUte6HSfE1OuHJEFw0wEi +n/LoBr/jtTThLPLXXYGZLs71EgY5s/uolisnsPpGNKrVVZg3klrKx6uVj/jBnGBh +dxsdQp2Q+DxMEpD2mILkNLhEdhAqzmY8CCUiJVJZjLVZDu9f0MSLIhQ7zIJpcka2 +Cgsv8CB7VUU9EgoKy5GzxnZNo2YnoB87caSqBwI2qgrbAmgwGnPddqZqrf9PQns7 +7ZMHCMcan6NqPsqSbsVSyo7N2cWJFqI0WUsQqIbHMgpuD0lDbDxS3b73ImbXJuG4 +qziVHBgwvQyYbMFvP6quF2weOt6IvlRER5r2DvEPYHRY3N8ANkNyW17aqSwyMqJR +oQAeetswCoT+bYO7WcRv4c9Fp3TYVVs2UtD5NlH/SPlnZfYOrVYGr5hdsFbqC1Rs +zRPr6qzFU38ucygu8b9hTT0tUxErPKaDXr4MFhAe5vmP9rxPgmkzeS8hQOQLakNp +khUm9wkE8F85ptkNdp7noV60UmwX1NUAiG0pTr2h1p1F7NSY8BHkEz/TcQv5IOkp +cX2ND86fG2Uitynqt73FSA20s8Kp6FMZocLVwuI7Q1akmGFJKAQzqeyUXMzUMFif +l3Wu+XPAu1mKMC3M6464sZryjlOAjyGe2bSOnf1DFZsYD36prdZY4uNNeNvlUNNq +U4Iv6KtZR82apD16nHhgO7YgC5VRrIozdhfMONYUNNZDeBZoBUCKK03LGWDmf9D3 +F8Ct1GTwu3CM8jVQB0eNypuLdWe3knqADLfp1YRvjBAc7EgQSDJHgPM2FMyrlOet +Y72CVv9J6JC/GhO1mZL+iGUU4cOuJofo2OvBcD2D3ACXMhpSlQgML9ZOq35RGach +w7eQiuedU1rTZqDL7rPDXKeOBxhNWqu1GqDXxZLeWnKZc+05UmfuhSuvQ4UEn16k +fM4fIlSUeB+kMn33TmH3eL+azp4kK5+qMgtYdkRcwr6mzDEh/VrMFES7hJC4MJCI +ktR1vB81Ir4wlZ42kC/4MT0RRKDK5DdkphGwRO45NhfQIDVdmf8pjp+Pm6cFJuwb +OuT2e5JE1+bURCoI8gOalane2TqudvllcuCchUr65z5FNGzTykTLemtwIHEpU8Da ++Uwb/xY5D5Z7J9F1HA2OlfTVJvyiohavWyi+puy0eEz5gHbAHOp5sWR53YBlcvcC +mQDkf+9FBtQMOn3ylxvXhwtpzrBdM7Ujuuv0vruoJj9u4d8oKa7ok0KDl7OUT8+c +BHJmjO1y56GzdvnzK6i0Lc0XWxvhvkHfqlp4Avt5s7/QCmyIRFdrYPNuGYDfB53y +NNz0b4dU884qYKlDeNAI+XLng9Im9pUicrad4tsHzHcUQZwIGXUVCPBAu5cl41fP +1oZrW5e/2QE3bD5kHp1+uB0zKfIs14EU8NFxSPORYlFelIpsLiZTTKbh3k7zRVHY +9vBPjPujqN4PARQXea4y2hNM2Mo3bKXw6RdRMStt/Bxf2Q7lZ4aAGzpntPesxqQc +XDmL5MdjoO/Ex6q5wINcO56RhIppJqP0/ToGDBHSO06XwvdmMQ+OwQkzUj/1njCO +4/dBi87i9fUhvvSI/6X6h04oZ2685LFzMRXjLDYD9r1vL7zTOJ2hNvYeNE91sEhV +ki92azjq3FWkvPXbOnQN4XJMf3NkOM5Q75Rza58FRP1r1HTlffm9h1b5nu14pwHc +fNcmGPDQOVVKQ/8US2K0ez7IB3QCUGbHv1cHGWBjxJbLp1ss7sMnBfO0AHholEIk +LBNFqNeipD7CrIh6LjQ9g5eeGfO33zEVa27RZ6mtDZJfwvB8uEzcWIZwYLQDCBpd +jRh3SUm5zA7z/vw4EL9u+o87FwliaeksJo/gaHwwnxznBKA40kF4m0vn1WoNxOEj +EhSfZncZc+ph3eXKVumF6JLiIIvvtfMd9+FDOVX7AqWdF01kT4guDO7EC+APDBCM +8N1ya9mOCnuh/uEf5OqY1aGg6hBPSk22RYuM12oG/1BW9DelFt1TtdGuafaY7VVB +DIFdzg4xWfKEpPvYINT6TmIDP9Oe9kvh9PRggdpvlBYcQ3e0vUk2SkHSDr4LDjQo +Jtw56P8QwBMhR38axBo8FrCeLlu7DyeUc5O9GzrUzouCkaUKyBGw1/cnGa0GVPn9 +wmcDfb/OfQN8gEvnMa3KtyojuO+HAZ34BdY/7XL2Visl9wnDYi/Gtjzj7oqQMNp2 +xZbsHXwBorrYViuqV19n5Xf3fouFBtVR8ZbQkkLJcQbQ9QnMr/rl+hQQ0H+td7Un +bTXNTF+I/ccEIDw49XYLrTuiqxuSS8WwTeYmM9kuZtc7K0k9Xc4shIL8TMf5Ps43 +Ts528TTiBiIvLmb3KuKzIBy634SyS+bgWwSIIBG9J6sQCtEKxM+HX2q+hMbR2RB5 +2bU/iswdS9Lr2Qq7JHEr7F+Gjygx4TUHRLPprGMVJk7bKXEr2i/bx/7QFFslt1Hf +jznwP47tPHt6wbM4VssDDAT0WgkVxGuD5QP1cqFEaUWlwqD7Qlj+zPlyg0r57n6G +Gsm+d30Av+TKW19kCvGeOY5Yyk/MwMCChzyTvxqb+BBu6sJoY1Ssze1FHsJDdINR +JOP6yo2QP8M6EPJoO8Q/TQLPxfDDYkdvmDjIrYfTPZw5kkSVfz/VFr5r5MmKpoi5 +2YFCfbyLrVa+S/COc3+z8fgqW2Vz1f3AZirrTVPTgPAC7N8nojxorzo9m7nh+JPP +oOOrDPYsVnbNd8hzy7TzMnlXX6iCSyREmi3supRUZbtj2+QMOlC0PUnM/SQD/GQj +E0pbHdTV6xDkElkF+vMtYHM9fs4eB+EQl9sBP2SO/45c16wbm0qg2XzJAonPPFyd +uF6/MTAtyXDAMWg5bJGe5AALWQH0s47OtIoWzjbgYtG3gtjh/FQg6DANoqrXLLrj +PiMPOmE0k/mKlSn0HXgrw1B3tmrV4VrcWED0/Q3siFM69ZyWZN8lXpweXM5x9XJd +A7/72rZTL7n5j8YEviNlFKMjXwb0jRmHrDXDuTeb5LeCYnZ6BvGd2xS5bAA++5Zg +HhBiM++dlZOGaXgDKUd2czmOxS7qcxIxWRngAQI3h5TzlRTfQXrCRRipeOdgqjZ4 +3FlXdpQb7RWfKtnsL37oh+nZyCm1SQha4I1aUARuLnB8bb3mBM472lJWIDH2O33L +1Ol8T8kz72DLzgOXrwNuCz4XV5D8znLtlvnrCRtwWIsGLM08FtQqXhkWvRMWr5Dd +0BYxn3ieiOp06nZQ5kM1J8lwbB9hT7oa1hP1E9glpVk8+dt3R+cjOQJ0TWf+TAxB +1pB8lVapI9QSUa+JTp/0tSFnVaqckDtBr69XnJMytutbkYXhmop0YvBvGwulLvCa +Pa6KBwaLPg9E0SaY1sEasXjfkAuJEJ1j+bGMuEVd/4EBOF0qhTk6VNTsHbGurbaf +f5TNa1qrC1aI3s/eDgG5GsXI9aymgLQtXPk7TSK04TDyK+eOHkZjogTzwFLwPzmL +StA6EFoqFwLoMA7GNvaQvWh9xqkf/j9XUDFAZ60L80BXgPgJ5Tee59wWl6YA1FVa +DYRVoykF4jPMDkfeQmJulX97t/4dTwSxoBILGVLfRi3EeMLpDr6IzG4vYGMoyyvc +gBMo+BZK+4W9ioaOc6evaP1VN7H9d1Cpk1JJFKt3ZR/h1EtedCI6LblUIf8oBkYH +E49pFvzk09JdteuV5pWYEOGIVlrNs+aSamEppFYdWZNp17uWeNyfS9IfulNnBo8G +V3JBiXWwGXFbibpOO8lwEK0FtD7GjUkg8YccboS5KnNv7Vfn7NefGGwk7t+3Ckj3 +sbBAvfAZR5q5t/8SnXhqYiXg+Da71UMEcHjWMZNTcQS5FYQfLmbpPpvdFSbHmxl+ +DFj3imePANjbV1mYn9llyDYCLiXx3GeTC7Fo/aNYpAahJCM+vyfBzfWj/nGn4X95 +YXcZFeky3d3/Ll9c+Kj2rlEi33Nd5+ID6XP7TgKHPPeG1ST8SJNcoFVuyZkwHBy7 +u2FoVtvIKMHszg3h5K0JOPPI1cpcuLFcP3k7bOGxVhT1jMmzxfZOY1xaXg1b2zFs +InbU3w5hz1pV7LuuNflhSIUzlDzUXlEKCtOXFFD+/r5/DznOJAX80o9heJ1pAhTd +8M/sZ7Mg3y8kG1rUgoFVJ0BhQO9vMMbsNP6oLFa3+6JTCHIlZ/6NwWnZNVhEasde +V6W3UnTnFtO0rInFhTPeSxTeCYE99CopfhCbYPT2TuL7jeBPGzCAMn8ISOpHqd2j +zDJATSxfWFF7T1Sku82IDem0QMh6nhTXjD0Zx9oxjQ/ToXzCa+CW1rTi1GlnSBc3 +A30NGgos+lsHiJy4pHRf35g8ol1/RtNZ2jb0TkPFrwQJinamtkwEM5dXXnoEIJml +tJxSJxRm70RFS/4YxKUR+fm6h4BIHHZvbV/3/lyVZyQfGMVvn37Vpbxls2RXIo7T +LWiK7F22NR32pwbHVBdnl7Ud9yzn1xCsYCicd31OXAYIuZIi+tgwxsXNIi8M8Qq3 +CXdXLXbL57SqyIjF5dWB221oxrV8L7quTCp0qD9d47htorCGfHTtu779X/Pt3gL7 +wXN0xbdFQS8xrCmrknGVX7MpIbExmSs9r6bCMC9AfgKj1lcock2Ll1MFyOqqM7Br +Y5j3nbyTH8J1QPg0DXcrn6Z3P65Ijy69UpV8sYU78j63FetZ26RlCQEv/Q0ef9bL +zV/oqoEOuW1oZ8gjo3+L2r7Hv+TOIdX9hrfUOzMxsg0ppvhf46pWQriGaV0tqQ1p +LOZPTfxrkwdKLEomb3UEMzwwa4H/I3NZybea3KvSFT+08IhZDWHxc9sOBy7A/Fun +yjVi81IGujqG0LltbnncVqvdnxJbPU4AnU3uV88AFwxwP1SjZHUcAy6TMKJhVlV1 +AmkPMVGTZxm94+lzNwd0Y3rkf06IORIrDMGVnH3rUv05YsbnzkJLUlGE9yMrhN1c +3JwhZD1SYPNECnFuddUjK15v3Ou8eZ+zcgb5dniWgdIlwRN3Sy3+abX8kEyhPPtO +mUiaj1g23YeGUz8brJJA9w6Pvy8VuFfSsJUWv2KZKFJQZFn2TWPwSIi7uypKFjXa +MyudPaVj+fqDfVYaRHoRwBPz5YXHLfLeStdXmXVA/cHM5ProDOQw+LTpgmQ3BPns +uKzRV/U7cr/S3XiCwBCu/ueAr4XqqpydICQCb/7JpksbpwpoXxBZagQ/X1sI6gSF +oXTnFvY2hqn5//C5kjECy/vP16TijW8sDzQ9f0gQpJ9apgYfyLmQm+zGTa+C6w53 +z4iFgHZM7GCgnwK5ywnTyWiknrmRvN5a98SzFOGdtgOyg/0BdBm5QlyvwyaScZYQ +UA7YnX4daFdtPqokL/z1TrGhWKAZYBxx4jLIQOkFuIyJEa5U1IdlQjncjzvcOPsQ +32/jvkXDXCHvA7DNZgjbz5Gc4YbzfBlCB43Y0BdM6IIY2tqG8rGPDa5Xwq9zk8Uw +fZ1I7BZnXXXhfNMEI4/PZuEBf2BEePxS/Dk22GP5PoC1AOkgoCU+Y79CyQ83Dq0D +ohmcr3yG+4mS4kroCqk3zlcZ323WvQWXeBumiDgOaMj2mgdAgJ+4MsKu8chXjno7 +kfy9je06vb1XT37t2HFwKY4KB9+LUm32kjcnylQDi80dS5QkeNQP3Bl9wNlxmsmP +aDN8lErc92HHjxjfMCEz1Pquk+k3Aj9Zs6YnuFzlilwve2g+olQBtmCl4Bsz6jj8 +NfhySgL23vN+h9p9GyGxrJmX2y2NPkqgPdg3EclG4swfJR129jn0RWYouas3h9Ua +aH5swEsreuU2nVbrmHTtK3x/7ILs+xt6He1cL9BISFmNep92MPj47sSgseE/1Q4F +KAuxsg7Q4R/zOU1eUUrfGTJ9ZuF8m5h3h5yDd4dTGQzKc9bd5UxONCxt4MMyQMhO +BhdbkHhenPUzB+oNydFQaTPYwCw1TKXPQta8VsA6eN3nf5yJg687OYQV6/0n8OMO +uCJiwZPsjg4VPEBlGCsheN/qEORd5VRxdKpIqDfqM1C1FmWHtfkptKcru8fGxsHq +HRrU6Jt5Q7y1Sht5oxQkDfeuqdGfuESTEYO+7fPQtRhJ4B9nW8vv9xgSA8gFsI2x +IQZ1ROQcPtnBhqEvV5QcfqW96beYXqNXGy52vi/X/hB35N8Jm62aiQ4seZ2bNkaF +JcW/495jPv8vJa4gNxJa3wr+AWdL62rHqrPnMhJOVo16MXm1a3gbQ3i94Y9zVavm +apz7XaOVX32wo1BhroJxbsoldDaVIhBb1HYZ08cbUVGqNuwRJFFiuRUMaJSLUJmm +rAgqM9UyUlUZ+Z3SgSMdwQOm/vGdh9G6Gps0IsOI/uPpn2diWoUsppXDBpRlwrUe +iz6a3WtOFZEQSyxDABSJlICxHsKU/gjCVA5xEmArNGHphD0oUKYFNKYO5JfAfd9L +Phz+Svgsj3pfRLthUixPSa8wNYhiou1/aEC33cMjmzWl+gbskLBS3/4S4Po14dR6 +vJ2AoMRXpldl3soXgrR4U8WrVoW2ulFatg7/tT178UysLlytGfWdlPOVxp6w9z9D +YxSaqSwd9G2s0edow7nENEZAAbMTfAuFjj1fgEhoyOmnfEyCZnPfeGqUQKQSXjxs +riyFafXZEl9NC+X3SSl7OrwinpkVfT1+aF95zDR6d3XRZundtzFzI0qgGvd47Itw +9BgaNWoGGyRVW4kSx4qMATHCqpmnW5qCdVa+b1W++OakpMJpMrprXMj/GUN85D7O +1dDs62K0kwWiEjOZ9KZlujX6/NeuGJAWyttsjwq64XcRjcX0AC3O9E3+NP0jtods +/rKoA7KKo/ewtye4LeFb4lspuqzo6nIotDE5FR3jfNeJ+jT3Uhc6JNHK/8RhA8xv +T1ahBVeYsK9oS1S3NGCiUB2sBbCed/zAExXysZxnaoFbaxrJLAfrtbeRft0rmhAC +nrmNptgMW6JOdmN/njBWiibd3ctLbUCnnm+xRVQwcJohNjkl4Sbdp7IG08m2NzEG +Zwh2eITnut8jFEOgGQqdHxRQOJBQh8z6NcJt0ela/X2ltbZQKSthpsT2zhmpPBvY +ot2P/njOFvZX85kCmYdd60a87FnBpqZZJ0H421j8fb5hvGLMqRdn3tDm/5nahKa2 +T+Y+CpA9ylBvqA94NUyMOfYPug7H2f6Oz2w+EDBs9cVoCf9kdXoK+8+XGS5y8OG2 +gsMD9f3AKAq/u4YogrnNH1NY0F8AvG6NY1ANh5armDBEeA+ZjqSY6gGVhjU2eyUT +NWE8dNhtgDSEKOCB3N54uJOgWEpg24yQF4rN1Pll3FmRCYzA6z0dovf/c9ZgCIds +McBkGFm1Ip5x/LZKW1JbJ4SO2UWSB7a0/gl12uYgGqgia8wdVy9Z/WuG9Z3G3yxw +0BgDpkGFxcD9Vl7RaL7vjq/x718Y0hfDBmKSAqMOwtS0q8uKH/rYySBAFqjNivlk +XxnQhW9K+oAfDllZ/HRYMk7e9/DFozfgHJAHNKy5Dc8de/FdJxZoNqg0wgJlXOwT +ZjBTrgOiq1aEDOjQU9E03jqOJh+0fax07PjjlmWp8zjaNRWbFuHrwt2l/6ZZ90iB +efLrEiqvyM95CxjrYN6PhoOSGHNFrHv5jHsFx7gmRnncisJDHRKmeytrwVDmZoK4 +79j7UWMma3qqcFVFBCJHavd9X1B7kaKq9qU58m3/TF0lXhXpz6pS7jqaSzkZ283d +jjXH1CYCaih1xG8HNI+5dYUd0YYje/tzJnKg9QR87Q29kW0g3try9K/Nh/mQSlvF +JmK28jcKTP5wINzoBsLgrguuoljF62CdMQsBNrWzK4weu6jMPrFbc0on22yhF6yj +YskyJ0LNg8KWJ9RWt1wyiGK6HV6GVS9KpeCU22mlX+eWw8DjLrGfY56uuZi4C0Tq +4sUBSA54GfJDbp0YhubXhqA5JrHEWEP+71iuKO4IbV+949AKsCV95I9LLT04HSSI +D6lhUeOAHkINUT0YdkkXNx7VZ/t09wnKn5DEtqM3QGgt6MFZFTc2QX1hNaGlHSGG +7y+AMzcCI2w/pI1jsL7RrN2hdETC/5/+L41hs9kyxMP8lKvx+EcQoGZA9VmEyvcc +duXvMB0nPYCAXT2V7f0bb3MvpaG7cAf5GKoWrayWF3aPmrXZ0x0Dn2VaA/RWNQdZ +yCrIL95l3SdGIqN3M6tn8rOCcAWALO985tASU5sKRg4cCwSKjSksKxbD3WPsaKRt +Ezvwv/kUYtCnaxfgkkXGl3YhaTJnToeyLmJBseywx6eplIkMG9klDTrBY5SgaRsT +ZdDVaLtw6e8A9LssVwdav807u5yHkkCKJYzHy2yjB3FQMknXaED26vSdy6QJSljN +ZbRNUfoPWEmQz+p7Px5IAKEBWyLhHU1+XT+L2y+ihD15gqZqxTi++PATqWTVyRik +9BcLmRVBLgshluR5VLyZJqIx9WhoEOi6ya+XQoWOOzK2SCmCy1H7xLop7Kqt41wL +UEARZ5ujpv5LoH2lerBrYC6wupMUSpuNoetn15MpnHyEC6j130ZWzUOCPalyGYha +UFwLuFIkVBztcPTrkOHkt1nIYPTVSySL6KfnoTrY+6D4KScxi4JLLDgfygcDU6Pf +IYtuBKK0QN8WdH5vvjdCh2dfFmp9X+/KGHaF2NV55BLQInQT7UIZ9YoLOs4UHZ7Z +yuu+XCeMGs5bDkjVDVC6Y5hSCuqnAePYweZm3JN7X+fevl/fUecFC4KN+av/SWEd +YNjOK6+Hk+klRZCQYoWWRz9HBe2QLUg6yIMnqGztYf4rC2tVNDTMO+8hxWdhX1KQ +KPrtHEeXAtzwXQNNuRBIXfgb3B+siI0MuOhv38+mPkFoDHe9J9gvWyiv18a4RdH7 +R2Ql0n5b97K4Qv/NAqArrqHnaP5UPu4TD9VM7DeNx39etYXWeGO2i71t83/k45XS +3PPznvxQ7kKE8WipyxFUlBIAFfgDvsuXjgYF82NdvVusWmkqgk/MUtTl0jExcH0J +bUn8Hv2B52zOsL+EHKJ0BqYOxxncWiYBM93Jh/NpElF+9euQBGNpkFQr7BobQdF7 +NwEg7m+ZTSUinYmmWD1jVLYPd66/1bt109sBQHwgYcRDHj5ZYMBn/oj0uzkb0bXW +lXnKyMXd28HFM2qguHcKwHbXM13H81uFjK75ByDpyfj0znHhLgq98+yBfu+iaKI1 +6FM2W+Xb5GfQ0o/mrVgXFVlAKnG3i8xyJk6evIK5WbxKLNwpeYRCCPiTjI0r+qcs +Wml3MSL/w676MHQTzm9bo94/rjeMFzXQmi1hmazakl5bCUPUunrTTfiATKJER2XJ +qcqxU98gRt26XDqhbH5FViDdFMx31SATdxqMFEQeAyH/d+382o8LiNY6RRj4NrK+ +8r9V62Kn7V6lFJ62CpvPNNJnkHwrDepxf5Wm/dNwsZNcY2gH5LpzYc+3PX0/EvlO +I2MlKvtCcYmM9Ailiiwide4z3RmPUfd6nkRACly2W+mFcixTUYE2lyRL4C3Rlhwg +SrsQa3LqXJ88ohQF750OpAdpgkiDcEQMA8fCCtVl76C1x52FH8Kny7YqC84FZWSp +gCUVukibXeQkV/drp/r4VL65tK1D5B5Mn2SDEXq1bAm5hUtQfyTtlLFo1zzaR3lO +7MOniTI8dfDVWRq8ICrdpPLQ15QdpKW7HUmZiqFtI2sZytX+U843VkZc1AagRCI9 +moHrOFhFTXiHn2XsYVFPKaBXiVBYD5/e+Wdk2f4ehtODTJLMbIF9CaYfqTMDMXw5 +1UJwdFI2shpmlCuVglaDvv+PR5pWCD6rNgHqhnM50g6VunctfjhOOBp/CL0bceb5 +ZjeJVqjR5RJ3pnnjCJ0mN6g0B9+On74VC8plTjkj12OsEE6k52i/NncAwtfrjkbO +OFnJa0Zc8pHWuQMcLK1KCo5il/haGzLVahqZXlNNT6mSHBJBNFQsh0xsht0Qqy2D +FlF/4rexSnKnfh+0muwcwqWibXYbB/bo11HIlDYaOwjJFurn8ETjpz1fV67CQM6a +aSULiUK1SsN9pxl50A3ZwD6HEz7mgP+ftznIdgedAjLxuZ5wMPhZIgzPtl96rsb7 +kjSQaHMxzQOqNCHNa61Le6q9yUBvppu1JOwlF7MHs6cZr1T6bTpGjZOqZkaq6/hK +L5kmtBK3bosZsy9bS0Hd/jGDW4dbdMs4iKhu/P9HkFB2nrqnT7//bRs1FXC59mOk +v+w1/d4MJvYeZdHL91bjdJMRtBhWXOPuvVFL58hVLBqLZNiFCGktuBMWah8ujYqv +LcH7S0JVB+S5x0yfiC0EX1M9Kz9Z9DR5ritLiG5j/KkK9RcriF5h6VS0BCvHQzu1 +jGsIljxMUxaK9AUX5EG3/+dWOYGb2Cs9viutWsP29clvsBleZWiefUAlKOVFANaz +dGdWY1qmc6/hH7hlfU9osiOE3KV2w+IsyZntLHRoL96F5PPFILuXNpVbDqp8Z1v4 +D2OYdQEsDOsBAvt84pnvb1w9QIyE8O23ACKNBEIFfonvhzn3hMIKPLs2rge/qx/+ +skgCFUpcfSWRR6C8dBAdj4tCWpZKK3NpyLmwHNbcupfYlLXsq5OvNSMiWTcepMwi +fKfxFLJ4S1KV7svBE/HM/R93SQ6wOb+C8wVbYepQb6fmtyJksVDOBplqfLRrT5+J +89MeOPbwqoOYCskAmu7C8FyGpLZklNcBWUOvE75VO+EO8rlozCs8wdhxqfxH4NZo +/MzmkrAbWnlO96f7OVNafifYDrOLvC+94r6x2dL8lORkdis5GwzkbHqQ1ufoWhCm +Bc2keGqxQdYU+hW7beWWoeqCmg0aNq/xgaJClNFTiSBN8IZdj0G1T/rrGe2BjeCM +XVeqThLrzxoh6zfcfAUa5ckU6CmW5G0nYnIGR38bGdMaBxHDSAQBqr4fblVWKWKK +MuwsaOKc3irBdVyzfjcs24JpusxqMtCynXnhb5mEL1Rn4ul1wKOXYMTfo06W46sK +jzy1eq7Jy6d9eErjmcijs/0JK7Pr0gHJphSJwowi84FlMrc3yaQ1vq+hhUimZgQn +Dm1vbKXHVImzpzfecUzisXkwCF3U1TyAJjftON+pkL3siLea8eZ4ukhD9Kan/3ck +b6bdIb/dJxyxc2bD0WbR9FuqxmR+s11mFmc6bWRd3EnK+d9uBZRbv+WEm238/y0T +FRQfH8kY2uAtJeFyb9HDaE0KdRa+BnXWDAGUFchp9e+gNB8lJdiITzrRuDH7icwf +uMJQ78hx7KIy6ssimQVaV5FIR9t0sYEcjyd+A4jngFg3zCk4ZYmb2Fr2rqr1Xqlb +cmXyqlhrcsgfQe3a6SCv0irx8zOQxFgCkQylko2pFcuulctMU1Ht/6HaHEKjygXy +8lYfotgyHomBjlXBNc4sXPbh78LrZ+SwlEVDoVzJcGLugh/dhRBXvmO5WWTRQDBR +zPlRH23gVLRZK27qPhavAWg7B86STrZZZ2feRa+oQYhV8/OgPvJlLoR++0wTh6BH +IFjGyf+KB7ywwb/ltvg1vMt2sQyz0PgQUS9J7ZuMShHi46jCQswrousHQXDJHfhS +fXZxJ7g7vlPEmx8IVdQSyjRVHI7mOYw1r9uiaF+867m/KIDHhPz3BtgzRG2w1emR +lAjoQtd6/bhmKM+ek3dSR6VGdwH5sITuZXjjSQj1JzlB3uvwx6y6903VPClcYWnF +InllEW9RDtyGddX8Elm50qIkzrH8ULScbYnL9I63ZCc5mka9XcNv+oTF1NaB8JPp +1sRtyH4sfVVaK1ahNdosEJKewdTGk841aNboWy7C+EOjlS/Q97ghYE4WqfUqBAtp +mLAKj6Xf17m6D1dnRIJvILUSudCvVLiLVX+i89trgOECJD5b0JgDwFDt3MFoP0RG +/cSHB23ROsTWsHhmGAXUZTtdxyaRsfXgZdAKco7CgRzB62rVa5oK+ZQvCgmROh04 +TPW+cnPJwHKVmd9RZRYlfJ0oXFh/c+5MYoTMkH77++CWC3Qi1X3qM/i2tyYpbxVa +uN3ODEn7FO0u5tYur/1uO4g6FRjq4ePeGt8Xf4NvDXev9xcXzlL5BZjMRRn1E7/y +ZsgAZbOmOhyUxx96mBORY/NGIh4uoBwQpVqNE8eFSyFUh8B/ETFj7DgMJs77KcDH +27mj2Y8mwrjSuh+42Sva1As+zSjXLJEp5/aGOrm+rTr4QNo85EiVTNdtN/lNL6BZ +rqroq0Hpfz+YwQa6IqrcqIDJUhzWJYli0dyr7cnc8QW0fzvRQW5mOS0fp2RfvYce +Bh0Ym8aFlftxG41Oai6gU8MjvjoIG/WLQXHEwia9SMPcMPr9l5SCLrteEF2CYCdB +gEYvSPItf7uLjrS401qTW7+1Xca97dDJacZiGjBeJ649MJNo9BzxXKLoKZQ+oRXb +bXNVlcnQ9eQU25+8LD2sxj+FgDmw+iR7ZQat90BSyxui4hDhxAWXO7XTH6ijoOde +V/thV/dEiiKuwCI+yZi1wB0xVVWFhZsADg2HS1J0UCUBbV4T6x7zAZHB6tNl5K9Q +uwr7FeFRSjstITeHOl1d7hNeEVo3fTDDelvdnipVaA1wkM4LphZdGNvjpzuCO//x +JE8SVleI3V3Yq75K6BkexHLS3fzA4bXRsQiDbf7neOrpaRn8tiwe65fql8nivTnC +LTjojC8tDR63eM3PuPeH7N8oO1PaUbVDdg7X0ZhrOaPa3gZn0wZRpacRoi49hn+p +RG3dJMJBFMctFWWRjZoUnPeqI+Unin+hNKdOZ34pnRm5V9Xt4q4T1WusoYWIac0J +uCVHnoh3lysEQefWO0I3MkLdXBC50zscRUDS/GFO8huFz2P07M4crMOjhUYZSpjT +tl9uFumKeaAmO1Sf+61KL5hOu4eB12f2Z686r/qlOr+xvQw/sJJMEGvHWFKS4lcm +KU6EPrhqJim4n2iKJsfeHxOHYAUVzZyLEY6wwWDuJco8HukZi3IBfoKb02XXn5CV +L2fP3dGg8cDANRUklxGNGf7POjuMKxBJoraU/k68KdzfAJPnVqC+bg+/iQS1XD7L +FZYTNfInM6GlxpWsQWhQ/ZODW+GcDXaEP3fUlgkKBPB5dXrpqExPfNFhw3Vb2oqH +t9hE7J+HgxqgOzoUJ/eVXokfROrLydw6PmyCfjs7xNMs1CyHsjAl3eZKHChxoib4 +iKX/Z2QDV412QOzwjfgqVaoBLX8xoP2483ko49pSMhAQqorpoIKdGT9zaVt/m3YM +UbAPX88ay3Zgyg+scChCuaKUF+ym6shv6ZaYMQsYqYdKQcTwkx3hTZXOmaGX607L +GFN4iTSdfHqanEJomq1VLFkFveRgoQy5n1zzjXvPzJIRzWFc/1blrI35yJedpi6A +605chY0OgbYzGRWQoWtUXqv8/zEIDOGvPm+LTAgSIT2tywFJM0e4hoKMka5OsoSD +R0cOsMgOQA1v/n39bymTV5G0YDZANEbgWYKDz8bE9NnGit6a7QVQ7W7XxiINx5jG +z7GSe/sR6wkzSRTcK30CwCQJn2ZmBCUcllzp0bAe0wRElUdv0SGsjY76f3Fy5DZl +snVPo+bCglbCwxHXKi84HsQ64MjrMwb9yflTu5ZwBNV1DO4xsTlwsTdwHJ+k5fTn +Aj5awMSNlNAmYU7pcpCcTA1IAJ99Vmff3/O9la/w2PjSeJiEExZGntBjuLBLMY5R +5g0saX80FgwOnKaXO44QV8sBRQDfUsjvnuqml4rqKQlWPLIftakJqtYMZ3u2xFgw +efitQmiNVMfbN8GHR/1iCkwaopi8ZiaFoVdcA9lhlCy3bbZC8Fv5fi5e153lo5BN +xiznI+alP6BII0gxH+xeQ8m9Ild0qoDrxs6Ci7d69LUTWsbpHHdmTI+gLQg/4jfo +LrLDXUT+2IFlBN0orT8nWUtgRF2ATZQRItq4kxBb0wfvNgQ2GPKq476bb/JeFrje +GXTyr0OenYpMDBYLY5GBqpYl9/Wk8qNPwOtwQe+l1wNPBZBP6j4c1Eo/H77wAb2j +ZC0Qyt0UuKPcUgWxxVGlHt+fPwJYQVR/VPwFCXTaFHBcAPUg56voaHxBkTEK1ED4 +cuFbeL5dZ36NJEidIB4so27DZBdN+KRURPSLzIizwBTu2H9u01dgUFCUVOf4YRda +V0AOlwEvsGSXIfOB9ryx6HlP5IWjex5M22pjt8rOQj8W3Inm7HAfm083aCDcvPJv +ZXSL3tC9bd2zRAhkbzZqztqX6+ZiMEz1V0DGwBpIC32qVFSSsZBIf08/4xhBe+I6 +2BGLAeZHbVnhZjuZqBVVR3GbD/beRIcJM819krmrKItVeeNk2YXP7/KICI/cWRf6 +RoZ5oGo3MNAXHy3TYn898kkjpMr0ULuTE4JnN7oSybSdRKyM8CqznTyF++ocjrkf +Pe8PYGy3Zlo0zNsbZ/oOEeOJOMx4Jj09GPaPsKifrfzQcD2DFR++PpLW068dUL4k +qlxVZkKDYVR036Bo+Eww2iSwntWwjpyd97Un68DQ5GiwP6mtdfsoT+Ep4n01Wqju +FFApEOUBr6FiVa3Gcx8MsvwRLTfzRge2sE0I9fmwyrlElk8k0P+Rg5NJ2rki27QI +VL/pT0FMi6FQYKDgvCspWD9X3KdTTmpmOhArcsdBFRYgwaHkS23rnJfYzubEK2Ax +yX7erXc9NUlZAUzP6CRRwCRj18+OzJ2JFM6QX6CbFtd6ZxvfNzJU9o6xNlJW07+t +x8U746cz7QoOQd58t7fV6aiDR8uJSr3D7MBWcnOdmaUynJHXbI6eAVZloUwNQuHu +0ZURcXiLMu78XdHIwqcRm/hPiws8mqo/+ItmyIfHn4SuD6Dre8Fv1wpOlra44cwM +vFPKqVp+7m3GPUdYpzbMhbu9CCfUn+oC5lR1zfd5E3jY8xCA2+eiSnDnrcz5HcKn +o2KyAKNPIJrIdHWlpRUyFsSTWMlrgSnnXrAFoy+2zvUaFCGz9ZuPO568F3jGLqrK +q9135sfNpbhI34X5fHjf7K9oFtP0bRhkF6O+9YBY5MYjwE2v+vIl4do91jIRZ86I +Npl1xDdDcAVO1utJwGsJuexrRdsFWhKreiwWtoJl7XZ5VZBgg6TIhG6fbF9JNcK5 +NKDz+Kv8ryWxLODLaUZmlVYf119MoLjYe/2uAVj3pk2nHKfLWmiO1a5P3SFhvHic +Wd20Ge3ifCR4uUOiROlZCs7dIzfokHfxrhFHegrng2NoYj1svpH0pXxSCBee5VVj +vLMLAAwoL3gJT2Tflg52JkmVwHHj3gb6dwRelOJy6mgRSJ0YWxhHM/houS6GaAQi +een8QUTzn4aUFDM+ZxG0bZ5yc1hVci/6Wv4OsdsZ27hN6z+DiF7qS4N7OdjOiaT5 +1sUkpKrze0wOxqmDXdjWMJH9ahC9tbILLtYerojBQr7rYnhPXuYbBgWWQRFIfCji +HNZIa0mfPtihRF1pqaH1ZjF+pJQBz0XU9X9ucBbH74I8ttDLdJVlaLZ9SG/cq/ET +n9ptU54qx+b+fhK+tdoZmR7N9yUU4OScmNlNA0CVPN4aoKs85jBMTLGuKmaGjWRL +W775J4hn+bAWIvWmP6qCnGzbKMjTEBhvM7MZr/1/F4uAYdCyZfsvATZ1qn6P7Out +P6uu7KNQLvuWvlPbRc/dbl9/R1BZFLOih1uQHTm+10WCvmvYL89oyPWTfu+W+fuR +ztOpY8Gkq81Z8BtX8yN3RPSCA+SjD9dfCSaeRZa9FveeEQUwaJfRrAfC5J9MJsNu +4yvEvnWEczdLXv3txS/jOKXce1rGx5lCO980Lq7KDt8wtusI/ngu/yJABElk9ooG +Qtw3s93YkCJoeSi3z5JWJs+mmrO0FCV3Sq9NoJMs64tnD2oi7Vx08umxm8+gMV55 +anqNcEx1z8Ja+OD5pnAYHgQVwbcNf/fyiNGOnVWlUDqDsuaBqe0hNmT1O7QITr+R +WXVOY4bUDUOXy2qWvgmpQndEfuDWmvpzUfS+ZBLIj7+/6h3YT4oal7ddzlRpLglF +fdbOsVzN+oDb62CzLAEh9gh3SSbtxale92jn6IKqR+zyWEliMdy57NQ3/NYzGlRR +STTdTV4W+7LxX2yoHe7W9Y7srTZT9L75UqH4lqxuMWPNgfRZWe7/3jwjM21bR6JV +mzM0PAKhKrLxAxXR+KFacteZm+/A36YcIHlOGKWYYCdW/WzZVrJhZ14wEboOaTVD +SElKug4MTXiDgmjfqBWDW5Qsu4lXh6fZrrdbZHUr4/ok0/qkzHUVPgtmRJnNOa0n +HoM/Ufl3irfTAfpA2nS4I5GBPZeqWTXFT3AAnXmRfqzORLLXYU3hQ2vM4lJ1oNQ2 +gLQ2zpXBNOFaaL3OK223xmOybXEAKqqw9hzzrS+6/Nmz21iU2tHnyMd92jZFBfrI +Cs5mNh5wfUgbp0qqAsSJL0PYESGzGf1ABMjsUKLt6TMK7YCC3rRbyn6yMsugmY4V +FA5XeVQFwhz5594iUxeGHuaDOGjACsgNtLIyzk92c1CRBdCCWAcaHYi5oyZnaXjB +m7e+EzB8h8XBlbgeUN641fUUZy5d5/aGhbeMye7mCa+Bh/qxOghCv4noHELvIdWH +9mAuf9OL4n3u4JD8//ML+3nRSsK2GguSfe1QWkdy4T18Q1y11EAwNem9uCdIAlfj +JcYYFocCd3xjRIJNnp8GGZyTjawewDkDylSWUCyXYutjrjs+DdyHfS7WLpzwsFv0 +vYX9015ORSPI7VZz7m3S3pq/vl8xaXNgP7DC42cIAHRBz9zXYVMLLyCirky2DnNm +C0WJPusR6cQQ2t29aTlL6vGFcgTtJZ/Tj4hTy9QvrXvSbH9VdESAN/GHoh+emRte +PNrScsrtgjWEh0iHenwfW4q1vEaIxM9H4VRBmoniUDLwY+G8qXwJ52q7agnTHm3r +iL0CXzs4ekgedBafy2hrHe9Pp+IwnoKYnAisteqX3arfgd4eZjHIsXMci1y/AYgo +GqIkJVopTYCP/LP/BBE/fuDI/nUi1sJnUx5fo8j4KJ425x+VtToyBmnNeupGdfuf +0+obOWNoT3z7NMVTrgiHUOUFr86UHr7Ia0+I7jOJRqKstSK3R6oALhJoMdfT31IS +0+EFAq0tfZc+uSXlBEAVdnV4pB3qF00QqZd5GAMd+mXp1ve8iuAn3Xl/989iBfmW +F7pAnt1w0B9JgEsuiFTyW6PngSpkJwR57NNwhRh5Isq8h8aMRiQaxM7FAt8sJ0h6 +05gGUxy41x51wg6/0kR9CM8w9sifveFJ55Obcqze3iBAvT8saJny8Ok+BnkvWJTC +wXxaAUB7hMb/HNbX9pxwTRqoyw+oNR8USpAYpJ8qqCfEDJsGolDJ4Cpm9L+d9lg1 +5C0vvDerJqv9qjyjtHJdGD2G4kK/KldKDHBkIfGdJJpUx+Cm9h+20yQthz6haX9D +S5GQhVs5Re1+GFqXqf5qg8NU7NKWXW1rSLbjxvuoMmkLidprJ+FWZR1bUuWpAdtI +VqClB9meXSwwKofvSMV5nPJJK0R0bR4BoGSbbRPtAtthy7KqeLxONf3VHFKetfNj +Rus/yddPd6V64wCbsm94lFHxKzEXq9qA1MvSOy7PkDLmYWThHid4LTadZUv6rOmQ +RgyPC0irg9yFo8Y/CsoRBwnNqmLKjUs9exwSVOhs6QkDKY/HOQNIc3sCrpGDa04Y +8JqzO/JFkR2cBuGR7sVHQy+t2hnlIpJeB+IC6xQeUDJSY+b7JOo6LUY9QBHvhtRI +jqdtyVRR2EI08iSRZB83zkKR1sNq+C6KjyVLeZYtGURlJCXTRxeZMxqCLgmNib9B +wZ/+cOC/eAWNWeYoWwgJZgRwRiibFNDe5qHyvB1Kalx4eUEBS0XH/nX0PG/LJXBx +AWOeh1ggvZbrLlpDvFfpfcTRMv9Rernxf696MVq+5b8fH4MMK17WfuJWNDnO4Ywu +AqNOTUQtnZFVIZdy3tLTI5Umw3Y+YaVRrHecUiIpejXTSCvigxifeFuH3JEVs6OH +sqYDfFxYnz4/kg5/jzKnJU7tWoE+mp/MWFvYS9MiPKUwuYW6xywSQmHDTfDPNhs7 +aRzDQn0bM/szrM8Tc/OtkXrN99/D1GIPzxFMdjolrxOz7k3kDwFSZbG9Nd/JrppF +mHoy7y4almOS7diLLIKwDm3ZTFE6WQu5PK/9oeG8pzkbJB4hYWOBk4qXoEuKZReh +TWka5i0mMFjZlPeHuHlyp1tnHj5bGb1TXaCdnaMtRoD0RRaVHrqiWdSEeeBaNNbj +xAyLydFX0oVe3D/NBoBITrfynLENydOYcJ2JPeFlWbwNaVGRpoXVt7oFW9XTyqyg +MoRyR8fnnEUPnAez7y9zljkctbWX5vs/WAbUpfAcqnRreg91hMG2rYfXSasQc8H/ +VaI04T6s1zuUR+xQB5j0e9V2EoC5gkrB/qRfB0J5+bdMbjsF3yuk8zjlXWfipw75 +ZViwue9H3aZ8GKA+cDjdi5g3mpW0ounxT+U8TMynEQvGht2gUW9QcqoncQ/bVMO/ +DBrvPQmqPmJHwG7eR9+R5MGfSfRX/kksuE4Yclbh3ZLpXIz+5Ps6BbayQacBliZ7 +kv0Zxiux4OP58IGWX4w1dMKXBsfoFIvI3GEnPb0Q3luEv1+B58/h4VhtaF3ErP0q +DZn53QVpP5vNnMr/8UFQJubCppOOPu2PCpxNPRrA7jrUSFYWYF+SAk3KkA07Ywb1 +WwA7ziVVAw3ltBjemd6Pg8prXcsJrQk+p33N244mmN4mSJR+1k20PBLEALZ4KMu5 +soxk56n3HCBji52XgutkGKA2rFoAi9fIhwshqbKLOy0gLKJ2BENrkCBDK/AUIgLV +keAtq8SB8h9xmjJNWZQpwzoNuCQHABAw1+Unw+0MAp8AI8H8nItJhG3QL1ezx62h +kYwd7XxuviM+XcRLhynyr3ceCRnMOcca0pmwJRcy36i94KH65qaDFRxsSdEXstvo +fBhqLShc5rLwibIWcxXOW5QV76SHRd9/YibAy7ulJnjIKfZSqwJLLpeEFDeUdaI7 +QuVqijESyk1mcDnnyqLvkXU14Ig8a2bbF40Ho1yH4Bd9cZuHSGYfjOG8YoRrbeYE +j5uU60G6L3fef9IiIVyY3MixK1xZU2k/D2ukwy2njCgR0F4NOPsL5VUhVxnMUkFx +fx4OBRP8Ivetu+DyHY+F0I9EpvZ2Vq9ytXRhLmY6+KDPcnGkP0q0jLWJ8SvPkNhz +1z2LzoDmmAlXLQ3Bdfp3xGVOGUmydL06cIkioRhVyGOzZzlx8WQwf6NOGmSWZF9T +ev/FUHLTaCnayapwCq8Akr9eV5sR8ZCtE70FQ3Bb/kkavtfH9vjhr9gvPlN51kFN +qsxh02mJK1vRikASmIf1Nylm+yxGP/hgBWOuG3C0nReY/HC3x08GK3xwVPbehg1H +RUGr84Cf2zQZetMP7Xn1cULsbuPJlCR3Q2OK2AeT4VmhJzjOhFTdyJP1Y1uKjWI4 +XT/xFMHDkTz2RUjtM8hAD1vsCKM7km2ASgdXUnIHZkgOSQDHneadnPJt2PL3pGSS +w7ApOdOod08fwykRvNd05iqhcVfM1BqRkpOlyI7/kPR2hvrvesuzCPrPkMBohznr +8Pi6fI5MxlLtuJL+ixGTMLPj1tJGyh92mdJsYAukpIUbJzpM3dgxCqXA+RmVfNLt +l3ImeFfmedX6+V/s0AFY+STDCmWk1jrVOeEHZCgSp9vd1b55ddInSfiGG69RlQB3 +tqko7SOnoQBVmrHV7/+LKDyR2qO/MVepQ8U2EjtlA58LzHHbPXuRksoH+O7NT+qk +hHVdRxbg+aDXvgkTHvG0op1V7aNncourKz4l3xkIDET2R/KlKMguXyvzMHUBOP47 ++Kwg7kcm6ZcmrELdpWIhYrnYyFdTP+xb6bdOWFr+nWqKWJxiPkXGxa9nFjxqLqWy +M+AsMyT0MpzgGOTdm4OGqWCmWk8+lO8guP7Q7Gw2NRyAo1QJ3uavkta7Vm0Nd0P7 +EuydQRoyOMRHweSwvePxsw/HpGw7O3mMmRY4e5UkRF+MHR/FX5I2mJdnPijnSYcb +q3+olS40ygxabSFRClKZy7rU5iCqU1U8jdHVLHhst+Zs0an2BA720gSHwA7Hy2tl +G6H/qtqOm0Gugc7ro+CbJaLITXchvPi8qt4dipULEjYETexxlJcwUG2f0fog4bNY +ECu9R3U7x70ekzy+YvdWFRuhDIuK8Ke48r1i21j2XEPPJS/5ZlcjdIT51IL+DydK +ooO07pNveTld04fPHYEuB/C10ljHPtD/lZHeQQh/rB0ZeW+08KuYuIRcCOylKtcY +Jjc4ACxHoXORt678j2PY8tvZWC4AJws9UCzEJY5ULt6n+m2fmhdGxp2mSkb/3Xp6 +2RGuK503KHzNf1qb8PNtxuj2m5kIbNXBrlYJLdQY4QuVHvh1lt5AuSiFqIC0Hdho +Dl67bew4CHiCX5jHR0qO4HGlhsThjdJUxYIpcojAAzMD9M/ZEwVvszAbIQc22rHj +drwWi9wh0CCYYvHbHwETHXugHZe6MYwiU3yj/oKWuNQy67Yr9wnKTi4p4+7S6Ha4 +fsjzb0jk8PL0fGebciH7Y7632tfdVC3Vve6peSmqFMCjOVim3hgtCHGcnWexkjPs +1lDwApsEesDYTuzC9Q0Ls6BmD5wkF8EUaCmkvlWa/Cw0OK3kDy7E8brwrWpb3cFL +FarAlboDkkNarkplFKsRVhbE4/LauVR3973hmhpygstICcMMIztThxtgqCfWJq3l +a31Ef1duh/wijuXvxFGyfCYRJTW6+egre+Q3UtY6v6YkhFhy9oyCM7NTD7f79CPQ +ABsq2JWeXNGz9WrweBq52ds3dzVkops9VPZtfudOhqqvm19R9HqFOSrYLcvmtkUM +6hVPVnnZEVzJe+BXAGYoQWz2XGqQlPKN5uYAEmawRX2qhSHhepH5JMshnp8RWqWo +3Nv4p0Ahr+WHazWAoEshZkaWKP0y+M1kR5IpbxkvtLgrQbtsF6L9Db2nd4Da71el +ddC27R9rR1LJWJ1IZD3em4pxsYzbVOfovRtmAcX3dhTDEnt16xptPYrNR7zbnyi4 +1fPq24ZYBfdKHu94qCiBI0lCykOd9x5EyWO4ai7bdJFqiO/cZDknYnwn3SAJTpDr +rp0qs7r7Bvzort1agdmlrXuKzKJgnIrsxqtPvyWM1TQf2fBb2TJNiRlHNtAss8ZW +NYyzN8KRREjh0x7k0qORpLV+toylmcDAtpRAcnfPLs01DMVa1gamarrnH6Xw0Ojw +Yz91YM6VJC73kviEArNrfYdCpq1yW1Fwgcnk0XLMGGTlH9cKkB4k2V8BBliOa8fk +tYo+VPks9rAP9MPTFfFZGLro49crmOHVZdsEVqMJLEbT2PyM8q70iHvmcRPnRsB1 +COsolZmhAe+gjCMa7oa0v51OyYFVPJWEAvT6h1cNBixKxOdWh8lrL15jU2aVkI/x +bX33R+vEyIwWsB9TZQ6JkQG5u6exmejT1zbIzldSP7zYfZ+YQp5VPY3qTD3fl5Nz +7PNcXzq6jeK+pujCUK99xN8SvTD3+9h5MpjikSUYHWv++t0OGDpnnDnsHh6T7JQ8 +H3oB52ZCcgV2DF9HuWNwRoxwMjGy2zXVIUxr399n7gu6s4sslaWTGRRRL7AgDxXs +UYBm2DVu1HsH5cT1sskjc2Ba6oAsrjcHx+XgGzwbqLXZUIfRpiG4kvSy8F1U1WP0 +6PUdCyw1vhwRK47QSPWGsxBzYSmPPIpDj8W0i2V9EYjxJQIaCA0zlSpUddhfhi4b +kVOprAeWYT4crVojh1eWb8PvLVQNKzlrwBip3OU6GfAUrckjRgMiUvRKWFOe3Xu2 +JntxiE2LAtmr/YItL4JwtQtuNxFfpGkDRel6pIMVOPH1UXALlYEFTkXVgV+NQe0J +Qcib+uf6zTkWk49XQ5J5wQnCIA19/O4QsOOYLWjWejpmHXSN6Jdeidb3UOV4LqRJ +ul+jt+mQKd3zI8xD8gckXj7PDlAWJW+5Zg+643TrMJNaqLVOJ6ZIpvsB7M+Qy9oq +5K1Cg4BMeVNqihGJn+z6KUHec78g/H45BYU4xqRR3BtIRjohPewju8JlnnMmMPMy +tOtqnhkquTlRyy7/+Hi2fd9S+qcEftHNav/dfUvaWNxdOM38aH919LWj5oCifl9t +cM+niYdYo7mXdwYlTaM5TGrHthivSfcv0ZP0xLwNkaknt0fzvu+BsdH+8y/6Yo3p +n6alnLZKGJDMUaS095NoIoYvv31e7622uIa89dKaT14+0dehrki5ou4/85uXPPtq +Fv0Zyght9zT2vW3NQEcB1e0FjdbHhAeQpFuyi25w5tn6Fh215vmFpaldSNU96nRZ +8q2/ZbYbLGgMh52ssQ6uBU24I2NV5tgOa9WrwI+5wSssx9SNdl+znePZw0YJZbLs +QBgtCkaFkC+QzyNi3fsIa48LQJd81gw1HJ7qHYEp6msU2+8I4P4WLlC1uIsNgpU8 +6QTyXFsybXFkzBFElnWk0vx/WnEoC9qAM/kZN4rBGEEvF8ps4XFzmd0s3OAoBJGF +0+IS4rhN1VHBlda9sV3H5QXiQ1kmDcjGYHa18E2Vp5gLxOd89RABCstokkDzBoMX +XxeynJhyNeDRFoqP1WLUWo1j4tfRrIYxWqrJNi+cNjk2JnX/pDJeusyzCD6k5zMu +9aZfN80YzFX1lnQS4sf85H4IcjyiI30shW8uPJO02C2/2Y8yLvJcnfmMpnr43yX9 +toZa8lnXja4uAHymhAoULU/5lpGmrrRh5Ye7ZYZvz940wzBOaEb9+LYqn2TpipRr +1AZH2iMqclvSRf2l4zAYZ9E0IShpk2Njyc96O/JtN724sopjz1SLK1VQ7oz4Y3JR +Rumk8fz+imocHKnQRNbXr7dXORVjzwa4ovE9mRwmgeQ9yXirZvmymzSAS1cqq3xc +t46SnZBxe20BltBC2z6dYP/BNJAr79oHlJJ3nivWdejXeuEP9vuW1gqD8aAZHa4t +PGRBRaNgcJian9VUYRJvcU8LMENqI8Ghvc9CkLLJsI1+WKtgWPmEkaNCA/csKGuF +x5+FZUCk0H0mwtNvZXxm4zyGE9IIPdYz4SfsgdQuzic+LIPdPpen1EvQ9V38pmKO +OW4cGcI1wdWUhbn3W/+2kNCMCDMFJMLiYi1/1qmYf99zHrBu73E8p8sz8N/bN4FL +P6mDWz/+JXO63l/Q9RJC8skQzgjk+XE5XMf2jy8UhCLQcAWuhImXd/+bDMKeYGYj +9s6ZZT66NeV0UDdOB2+aXL00Ozxj34Xm6PXo1akjq3sTCq4gc1RYA5t6KSi11mzd +x/pfyHCXNbBqIURe0x0Ipg95gvxhATgNV/j1nGZIJW10a0kyGZ5goTl6mgje9hLg +wlsbVZQSKyb8T4zQcajNmSE8WPQ5Hq1P3s+Fz/XN8T4pDF1bAKaPVOeA/ae7/sf/ +zKc9t6TV+mg8T/YlZdkRFIKWYwymuP8PDA6tqTfRiawaHsdRsZTxWN6KgMGOb4Hg +zddvr07XBGrVSPvOSpgPVLDH1+o6gWHbv2gq+bbllz5s+saaBPkTjUUUmI7ox4IK +sQ0zpv0zSy+gAHvuwn7pFe36CFeVWt6LVDZ0lovtskGTxxYLgR/EJBkEUkl6LTuc +BGO3HVXY65RKNNS69dUCZY1knG1xC05M9BkWBJz0dG+RQbnP62FaNM0MIo39Kuxl +0l2JnByWHkUzi6BNBszHrbSoSwTCGM0v2V4vpL3qYH0CvnJuBEWcnPb77FznXwb5 +VzCUYjjAtxJtBC7mhibviENh0lx/llIicrsiPuzBm10hQE8RJ0m+7E1N/EBOl1qb +mXhWM8EFME6zdFkM8Xb3DGp7l/ioTpZ6NR2KLCxWoTJhy8tc2HR98uGJmqn+r876 +/Gcoj89tHJr8gLh+HnvUskB0bTV5ITQcOYytXS1lU6tHN75MLxcs85JtQpk/b/k7 +Ayb+I/y1jitgiiD7f3V5uGHz5SQzf4g1ZvRr0BaOvYPG4PP320Gspocn4UsVW8TT +FN9MYjOs42c6gR6bID52ouyxKTtPKqOUiwjIRjsKQNCW5Fq9E4zTWCZp9/c2xkKF +ElztCV2ic5LuEW0aNHY3ZDKOmcKjY6/jcUaUWVQfFEx/epxbzenGC6hWWUpYpcje +ifjLyjw4qpzSUX6jBJVlsCAXd2GCxH9R7PAFMltLGrrJuRrakn7ipuUbZ3IpXtyN +wo2VkUGpi16R27haVLMcH0VdREvk8tkTzyDHFSJv46W6iq06vN16vZuis6Go2sYO +/SjHF0JHKOtkmS1BIHLntxBtpLoTPWZrEAVv0xYLoppqUqEshtj0lgPaxVDrCi2W +37kESQ6ypp17dBbNZnKPq7M9ti52zRK9AulGM8qAFWtuAY9JZnq8qSQnsHF8GdUU +4ntdw+VLLGbbzQ5KFgHPQYkk1qi6LK5du12pS3yOTeuB3jDJ+9i4GVBasq2AUyOt +mqYU1ITN48w9PQ2w2H0Hn8U/O+1QJDqOyKOcO9+6HmfoJ+Sfw0J6PJmSOe4+3Skf +06TJZd+HbHCkvwVktNKSkplRJuGkvocCzxSR+Fh1fe9i62Oab7YDams7+/RxczzD +QRZkwGj3Ww4F3IOiMNyabpI+pn/714XpP1yfPrieK5ei14hMdBLI9tizqsccwgBL +Rkdwuq/q40FkODu6ItYGhycCMI4lZfGEDjFhXNbp/9UH1cIc5kTrfRHy8QNv5Yxx +piGtDajUxJiP6XjaROvvPz7jpszbrwzO7sDS8MksxtcwqrHihZ6dTnvVcCcFuE7h +5jZzO6lNoyKH01Pii4xnnSezP/9hmvFER7/xkX0Ynx6dYfzfBkPQarWuWzZTATXp +APfno3BUfdGDYA1TGg6lo/YwOpFVdrvdwvVCg5SBcw4A+4uiQA4uoYR+jOXRoBoB +KDswqig/PGxeAz0TLSfQZnYQy7NczOHB2Sx1NaJlS5mo+0xx1CSERdkI8HJK3eDv +tJTyVv/diLvTbY9ZHu8MRwsC56qcukFYvUKBls9B7ZsVhY9QTUKhsmmnq4bXlUa8 +kK1rMZEfURhA4KLnkzs3DEWD68xcxV+6llC8RkMGItbcQn9wkX6r9jgRz/t9IWij +0AuvDzvPxeDHbSxraPAAWqS6+4XUYTe4cNgrjgDqDnfL3ItqDSA4BR4RWNM2q9kG +Vf8PEBbLQYlqbVCr6/6+c2ztZ+gIASaHdAQb9cgxUiwf2Wy+IwomYSTaPsyCOGFj +Vb7p7BQGTCPIsKuEwKjI2fUVnkqXYRWiLK+Iuz603L24wcNNvFhcAZD9NTOFDVSN +bNhWVVUC7/2iLyESCoMkDnzx3ND9AjdFk0mUnBfl0bBYuX84sCP88veo4mHTTxRu +6lC700yEN8QoN4wKXxpoYfWViUqIjD1qDkDN8z9QNFhhQ/EyUtknk1XlRLVHghLp +3vaBZnHHj6o13Wo/zI3wo++BTtH0NnMYDEp1LL6HzM1kWgWdur92eiC2EPogRVSN +yiyvRhdL2kChMMB9BdSgzPYuyR+kqVJVD7420ViYOISM1ytZrFNkryCuqRP3yowe ++ZNOt1kfPjQIDmMOJ4pHWQQVvlx57uPfncAkSCb9Ms4SNabqzVRqmCXpel8rRcef +7LR4JqTk5NQfihJdfK/o2IqMqTtSsGQTSiysnbpfFnuYSQ5TFam4FXYV/xaK0SQx +fQOvkncAzEr56DXhQHIW7xPzu5J2gPJTUtTcayeYnulFKSMDMfRZwdlAY1RloAe1 +hQ1WCtMF6Rv+YUBu3RJV8awUZCUTSaUraEumwphOL0GoPElHLnEUXSv4UfjTCQge +288ehZyHZXN6nlMg/xZS4+ExpoEc4qfsuO1JqBF57QNl8Ss/Epo/b8tucjz82y4M +hYC4fc/+PzH7edpFByfEy5dz5Yxb88uSQG3eNnszUhQSCE0ojBk2w/GIw28TMMKi +TvPPL7kaIiZ8MMg94gzfeIuccrg2k3TEZLbMFfqAj++hTUctwg9j7QyjQVFx8rch +GR5PzvTRIiwG/ljz7vuKsbyjFi5AMGcaz4qcArkFvkeJ2GwEcIf5PBXoX4CKiM+4 +tOHSPMNazqv5dh5ba1WsE9C/n5bn6uhp9skvytEuhi/FFzLddurM/qZZ4NHQ3C1w +A+ANcSG8xrqkbSQa0CEWZkx97qpxcJfP9GKUOXtwbFAkIkWToAGgvaFPCWefkHC/ +SfOwPUlPH4mdhA6CHJtswIfnTBbH5TExYzws8W6LrGqew41XsuCL+orOAaBZAqQ8 +zVbPxPlTxC3eUn7QHWI1gohtAxTLiL2oZdcgP3Tah6X7rOAVONamLFVa75MXMhqg +zGIp9aLVNLCSCWUZPywxuir+M+g6a6wgfMbj7Z07rJLjBnBkxShCnyi06rIFGp4L +Kbd3vQ87AmCB8xMbUcs1SUJzqhY7sTJhwXEhRrlj0wsDp6XFH9YeX6ced8L8mOWo +Dhw0hVOV5jk1WvuRntZfN9cQT76Dd8pHEXCTytMMSruydaV6N1gck/ViWV+3Q7Vx +BsLUe+IBdmK7BtRkpqSACpGQQXrhvbGToKLVCNIUjF2SCZuDSRKlXui7Om18PNMD +a3nC6OTTNQ2opRNtITJ4zEeIzQoUIOZzBeB1/JKuJ1PulwecTjVWZLFAcfJA+HdM +za8AnzslsO2/gf2apcib2CG+3R3w/cXFnrk3WR2cdF9t6QzMR2l0yMAwWfs4Qs2i +uyn/P4tvo70sNSfEe3SxCz2K9i9HHe5IG5VvKfGjANsCqAk6dma7CLYHCxsQIirv +ycJxyPq49Sg16zSpb+UEPWE3LTSUm5oOVcFD/dtv8rtEH68rDzUQZBl6MAF61n3L +VNYu/srXjJ+3hJ26H6CB9Sh5NkzY4eKGh/cezM4L4RaJKnHkxMQVmWjTlAy7TK9j +Afgkp5mKZ03P6T7RrtVpHLdjircxR79PjzXbm7++k/J9tIDinv5x7z3rt8T4Hcmc +WBrRsTC1HREhV+oxuxLTbBPZ/nbzPc6eGdH9rAG/CE0p0O9zcHwfRnuvO4XYREyo +Yl5Ip4DiHu3OdX1xLi5p8FGziEQzTqN1juhpFcMjYxdff5oBMD4gT4TfFGBrziRs +blDsUP66qXu2Dh2T/XBpCo5+UlSggNKedEJkVnNjgyJAz9BwjffFJdJSnTq2f9PC +2PBceomaZRRgYD3U+U9+Xc+O9N2f0F9bY6JZO5+78qs/LJEEbp/HZ4ddFNDtHjRi +uiFREkUmlJq4qwAB1JrGuecXvj3j1TdXjw6zqGtoMTrLkC7mMdx72U9OudWJlSIk +nykxEVVrD+KFgHQaZ49ynRPbgUhWbHPGsYnpagUmKqU+aLeEr8DLpelI4/i0y75V +sYe6Ur/qpN9y1E982/gFVPaIS30f50cAyWEikPx65y5j6H8I+Yr3ZRmphpbYnhjv +UrNrtZaR5TYvLKuYBTv3nnP9IAQkah0i9fpYhMxE2jDmrl1dZM2PQ4oB1sxyTk93 +VVgOpR6uxs9v5DYEo5/0M5azSNSWDCRMrWljSasmbMZzHLLXEc6oz8Ol0F+TRDED +U6ynoNQr9gxGtlQyghdLxImXU8H1/SXVztd8iqKWn4jhMgNf/Gxl03vnVDLfrGjm +BMpLsYxMJwYb5sJfD5lFOOPuLSqK8oDEje5XvA3zFYEImCUEQ3xc6zl3Ix0M0JZJ +xxwZtdWo5SRGM/cXaDC4nkYKWYgGbZ6nhr1vOHJK4d1FNHguDIE2uxduakPgWwAC +eMkW7eQDzuHHVQifEu3etH/x61Yu8rKix0o4Z3MH9M7Eokl/Jii9CV3dw3KdgggP +doyIjQYFUJOawdyE6Z105/4FlH8/oH/O/hPjoIbpw/A1fJKstMNUQP4CLOJCuVXS +n/wkP+JCgJYGlw4R2gByE0JJp+Wpj45PVrrIhu8t4FNUGs0mskWJsHdm9g9/VT3Q +iwghhyOreiMj7Ooii9bdVOKZxs1Wr9VSLCNf7aanDywvLKiqPFwNBIXjDaAyIjZh +rhV+tx0vE+kjPAarCDQR/j72tUk2aghFYFHexQfMXGHkc4TjHnkSL4OKDc27/Nuf +6nPpazxZThD+J/VJnb3zdmr/upNsNvthqAX+Rup4DSU04dbYTRzuut2zUE08CeCr +G/7nkdS+ErWej3FTNRmTj8UUI02DYBSsAkbexD2VKTYUjvPXycR7GcNEbKYhUDBI +9ytOkB6/H8oRX+8FWPtQlWlOCcT+AvQ+0dFsUg44ed9c2fQS+QDLOUzfXXVPcReX +UqQYxdEbs4ht80FJ9SMBjIKTX55yo+CJiaRIqCj8x/xuqUrqukkESCaheM0Cx4RT +AMLgI2d/qyvySmwrkFrItOJhw7nKQPd8ZUal72CNLuPa7LQIbmbkXzT1u5y/WSca +Cg7/70uGM0tryU6oamVGrEWiDt8G8F0NEq1EraWDzCsAezcGj/RZK9vzrNOMdV23 +97oezz/2x+VRtjTjAKNtp665qBbPjvNygVm9KYOW972XykvJqydEEuATVmOUZLBB +hXB8qt667nNOtaYBEqSXjOGlELz1Imef9OCGAMkem69pu9HIq1i8TC9+cKlEoPiw +pwwJ+spSPywkWoNl5vDz9BDohc3eTLvIJcYNhPrk7doN6IMeInB2DBsNp3Pv6DOS +drh/C/UO8uI8GyP6uRymFaEaiZSBT1bl8gbrVI098WvuMF5/b/3bA2KFsLtFVSZZ +IdqKJNcByPQHn1ki7HIeL1SlKsUXtmg/AjbsCLraey4lsT6IyxDlWvZun30IZKQ1 +gdLSMo6+PpA+21VzZSc//3pgIJHTFLpLuMLFzeonER30ZfbvHUnlvhtcpXundMC8 +Cl12M/d+qS0xIe2X7cDwDgTvPFiofXaqK5efqZ2Xd8Y8xWeJ/yxyyGL4pJlv1Fae +Dho7FAuu8RfBKV1uJyEqmDPFo/T8plZL1WmWdrNGi0niOu+2jjY1J0EhhSciDwUB +pDstw73I82FVJezAj/sCpwURH2gY20ho7F+2cbYT/ZKmzOdfW3SwqJW4+GO6/wsq +XeD4L4MleKxbBHpvsWeVg3f0pLfssPTo/GZtYHLXuzNVW7rPgftqIrBYpY4jXKz7 +PT9ockRDVkEbEhrzAezMySZdC+mgnQj+Hh97Zf3po+w0YFwMklD5WYVH24xHpdul +C5jq/3EG0FTAedbYOvZJwAjp8I5C4MMxkeKcJatgWbukir2CZbrN2l7WdfaF0LGi +Xd3vTcBKzwYveSIZ8T68MnlDwg46Yl27xap9KFQe8c3BJedDNkIF9dp/XieDKfUE +4fyq92Uls/kLpfIgy5n2a1Ff3GEKidtOuVBE/0d3jNoviNCIplm7ReZqO4jKIfrh +c2nue/5jH89oIremq8Hm4HPp9rvMne5qR1yzBmpDU6Puk0aCqOv2wpK2lSLb4Pcz +jM2hGzyVmlLJtE9+4XaaInnHiKqsfkWkQKE7l+h8AoOYqMg97SBh+RCSgHxgD50W +zhqkuntLqWgYdyZGCLDrXFKrOowARxIjAW/HxfJXBnBFADnzM++4ZZejHx2V25TJ +F6iKAEcIoYAgblb2BbLRR1Wy+AB9JNiHFBbOVg4lGEXvLqdJTwbWswEhSqY1XDbJ +9tUB/mMoKw+guHP4EzGezCoaqwgfZsXzrSyYkdXZ9GbxO2TEDL6HbxmW3BDeWkk/ +Ar6aQRyB8WA5ZkqfEzXPC3SGhKoDwT/YmlQeDEDMzEryrfz5OfRpwFlTyfBWG4S7 +H0q2vYerdZT7IU6cKYXinCzgvkQyfCSyTVQ7N+YNxDWvjgDzckoUNxQq/xsuLG+F +uDBq/Sf+UE0z+aJ5YQN2VxAzXrTJeI4X8eOeKfBRtY+BHZDzgAywSJkGdrFusSxg +eGYwTksedGz6CpEjYXpEeq+7NknLWN657V2a+TL6+DGynWXZ3Ww44vv+TQINBvlx +xiAIamP/QS3oE5bAlTDxtE13h1CIXVJC+f3LxoGSc74mKDYprI09zqRjAZ5jpaOK +HZ7aWiyQkAjiscBReCPgO2aPvGMtBcBnbvypqpzorQ4EvguRYKbS6cZT+4Tbb0XQ +ykDOjfkj3uAM9nW5T1/1LbXiZVrD7SmPx8PC17QkYF4uaKuf5TPGXFIGQbiYiw1P +H5iW35ttXBlTGndqGpVgHQmyeGYY3scYhV04z7v9zw+SSzvxe2ArfWiLKjuX3NtW +2mkzXBeQDRT2v78+JT9MdX6WpeGRs+3FcNOIGjaLIYHxltoMcgAU8hgSg49pA6m8 +/Nz6TNpXv2NCuwgkp9zlOw2FOG2qiItACRmNol6eOOU5CsjFn+oGVs5Xt7y6Z0BL +56bzKeLORXUZ7NlHo6xh87ZnX5kdZ2LbKcRj+puAwkzb/kA7gxHpvMJNy8hIQXi1 +et8zJAmEsiY3ef0p6RSWdyuPqoP22iZzJLYljcxIK2W29aodrSgb1gUaCWXDAM0I +sCUL3CmuPHy9TSyN0j0ttnFbtWLJu9noxunOwpx6o9XetdNrZiFuKkyuN8ymM3ZX +vXoc6S3omMFr3q4o8njHKgBlKkiHwo0GE2nH7nOLf84kV2CoDK9xdzvAMBDH6ELC +hgAGpbjHXWNmTpwApL7wUQDsNk6XXD4Dq/lxu/wA9fHHleJMbhRl3MlRwk8NDNHV +uz79WEa042n9gyxGHn1J2QWL3WCWB/AvXUB0RY0P4N+kXbR511ZSDXqVhSn8WNH2 +ABgPJMG0c2t79feecED8K8kfihUiFbYjgsauKPCW24TEbgrz98oVaQ1iI0OCUmn7 +9EJAlRrtYZPtJY5eT7i01YJte4xzAKbHhwnF09eIfRoncc+m+3mbyQElGePIWqAe +/HXvoOSkHiUBUoz9m8Pb/DNk+ICgccc3GMAgyvWCzneeoG3XSucZGkrzK28lC9v9 +oCbas195Vylkl3TgqkfbF/AoBV8fbSldXlwtkWppLnS5mMsfQ7Mkt11wqUyNAZ6P +lsFHhU7A/biUGdzkDh9a8U068txVzVwYd8+jy5Ak8XpYZ7BQXxXiPdWcI7FgMi89 +EhSQvhjFZ1vIiL3Sy8oqm6dOMRCRTlyZo34xaTitVCTu6qeJ66zX0ryk0H6kAprp +v+Fw8aJIRfjOgzx6mDbFpnCCs2iUXVDMxbSUH/sMIqyVrN5eSlOfBGyhYEVv9KoI +OxJa/3dVYjvHzr4p/wQE9Hf3Nvfq38+oxtx6usLzW+6Ms5hwr/4OiP66G4N/nVyw +ueqFra/cKzx1aMJuOcNf+iKNKPR770EFPejlLIusS1XT1xT7L9ow5EpiV7blKOib +HDYo9A4RM4PGF6NFKzmMecQwYyMfVBuMLG4CkXdjaBtOG3/1U69ynXrLm0E34+ro +zp0D+b6G0loHqbtUgz6glmM2gpgCoR76NKYqdu0RmpUF38qG7ugAnWObW27UKl79 +1BTEQvwy87foySbY3o7d93ylw2rE7RPHFQkkE02FcTlfb1r6aAoz+cRCZtfh/afo +gL6VKu9qS9YKplqjTzPD1CNSHjKCEDzS/SecKgApnJ2+mRRc1ok7DRjWqERs8VKg +iNc/gQX2YsnBF7AQPQiQ/qtWprZbM0eXXVbrNSFRVqJ41OBmS74siYwxwNUDNLHT +Z2/EV9jSeR5qudBi3EwIyD1L7CKosilmLOHZww9cmZBile8SthaKDWwGAWRe0S5t +T+Gdmeb4UEYAHRnHZsESd4sPnJaIhatY+ZJUYT4W0AYizAuZPrg1wdlKhHE4N6wK +xfWpJLGjrak6z81X3+O5Gt9+Hr2GOUUKlE3c6fPc0Z0aMUU4QNYw1sa4l0E+T/qv +80/GCZpyy3iAYOuC8cG8ico6U5Ep/LoQWiDMdoxBJCLE0etbWGR8rHdHKWZGDBQp +79ReBLSFWwy/nMFyg4UakUTo3q2vTeGqtq9JMlUgaKwAoG+bru+FGe0XHPxHZDFn +xxlW15qbTV+JYwrTJ+DrJKBG63Fu/HF/CwnRgiOEXAxKM126ZVpipUqjEdHrC0/b +JBpy8hhVLAsNcV5ing1vcxX6qDhSeexRikGLJBjtK/ETHztE55bgerNth8J/HaAR +q3md5LRqvAZDwRPF/mQLsR68fKULNzN5oCNygx2vhpMzKvnpaDWNbQqES7Mx5nCk +Ly7R+1Ce9C3ASzefXS4KC0iZ3EcqVtaUK63eRb3vfh0pSq5ojNMs+X0WeKmB3erY +gYxa2MUkyad7SoGfhAsPrf1PKzWolfzG0GsgcRD4pKl94WQ7JujqZc2E01RkBMn0 +El+EjWhJTW5PHgVczsCuga00G0Uqe35fE5EJI9u/ZxSv4utcBxeXK0RhO4IhQIVw +eAFGQ+9j/aagiFi9nmDnVWNMqwg8B18JUqNHwREptVzkBjSIxKUCpuiizegUJxVP +Cgr3zmbQMsiTsXtw9hpSLXZX0DUX6T5fJmplLW6VtQXBjN6D1OHs7Y4XlZblTbGH +0YmITD5urImwO1ZJgyG24QztOuwOnMlVN/BYE8Mb8SYeh0NQfAiYLJghC3TnbVVI +Idd6p6dNX7MorsKhVYmiGyX6lhHbPh63aW2Uzv4KcU7mHy3rrCwySLt596Bu+rt8 +TVJLASVuVduUalau5Gegvc+V5IqGIn2qHEHhvgPGENnk5XY0mvpXI8aCY3gFdNBZ +EmUgAQYgwnqh4fmKPPrqDe2vFuFAlMfsFqkb/OKo2tK6LGTQdSBEaj393yKDGR/s +ctu1V781rcnws2YolARoPm3NJUveEzkbqxSN+q2OP0aDOavX0T0tmYO6+AErXYT+ +yZ+gC144in85yt2Hl2icw+2wPRlr58WsDvU/p2SORqXLwge5lPihuMOUGHTvUy55 +AA/jGwJrgrjMecCJ+GLX6zJcXBCqHBBJ1RDJgSH3J1oTYPMhbOKHq9wJF+B5OMRG +t7xAfU26mmT9oLIc0smX2q6QtfMPFjlwbD3cIqdks/LBk+Y72H0OEj8h71hcuSFk +PcIXSNDC/2OoVlYsvkfc2NBmQYYxjOjP1ZQiYBVQRYK9GEu+JuphgTMZgijJ0jL8 +TgH7j99fON4yqtqn6aEfDzdk4LaX6LwtQrHrHUROn5c2uerT6o6qEO62ohgBY6vo +JbSOCmLnK/BfnXIKFLTro4WZ1TXN5wl9zTEP2KUDY5NuIOFKSplql6OKN/fG4Mko +drG+SCWerVqBobyU4HERoHcBwNz1RPIsDQYRBdqxs6PlVXAdmX7/RMd6ws7E0PLj +ywFAgdgxJVXjx9XB+u80WoqHg6XvrCXJHDBtafiv47nftRp7oyMFWhefaQRAfoKF +EXdjhqKtJvxaTZWXrmc9vvVCIlxUDKgu81uImsWWIIlfVbNTiDRJ//qxx8han2AH +tHA30EP7r5gMqjNuXotjv2PhS+NH4FK5xyPFVGodiQqlSOg46fD0Mnxd7ktuflYW +TlIL/AwXXGGtdPoScaZYNELjF3zoUp+7ryatgF9/uqFVWlzPVD1MOnQSFjX+3Am1 +Z4yCER+B6+wgMkBlnJfImBHtdWXYe3hdJJixsYQvihZShv8xqfCgTkTAgLOc+zgW +qcs3KHnU0tOkJ7DAcpyx1SUfwuhwZ/jAwroFSBdj/fk5RJcaMppJc43zorpV2GmW +Ix0m5IYuS0gz3vb4a1uApaWR99kEwz73IyfMVL12+9i7n3V/4QCNCxYLd+yuf+XN +szhWYd0XBU6BxxBPLDKXxbHPCE1VLIJMpyA1/a0X4qwJ+0/Dmhy07TYBniQoGr2T +y7iIQPeIizToJOH4wdYuGhnKP0nHiJgqaWuGlbj7MBbYfPuuKcooBDfOcx+nMg9+ +wirwDsvfEeRQpQhYF0y8lUwndqqJwdvd+WoHGcdptNHJCgDNjY52LXE8xzoifqOh +Z+suk9Lakj+cxbXAkdSYlWb55orDteEJY9UGzfAMmoOkDiLGiAD/piOyOe16BbTT +/6dsRFuY07qc78hqn0Le88na+FAr+xWk9CQI2wfj+Z7ykgODe8+F5kX2hZ2445KT +DAQWXEcDsIOZQR8EOR9oM5eaGtN2Rn3zyKfxdpv4092JZ2O7Pag4rc35Fp5ve7ML +p/nNG2x/x7uYZ4pUSAQzwOZntUDVUki3Te1XjXcMPHTdtJQHg3arRJEvTDfVT+SP +qNrcKUuMyjKmW+3qFqRo9+xSs0+c/aV9iMBVffeZPbidiIctsDJpwNapS49xhvTv +CUIa9i4SWyaJ1U0KaFVfNaJSBm7AGer5XB+06fX6bACPtoNEQmjFqxviNNkkCkKT +vgOigwKP5w8xIcsYP8OnnZ+szMeDaezYCgCanZ0sd2XmSQZAimLjwV2Zj20zrtNl +gT4Gu1HjW4Yt/9Y2yUXvkfk+m5iF8hZ4D0+U6CtOxKzjLKc4hQI0yuCZWbeLoEx5 +D20wYyW1vpijsH5X+j6JxQLED8HZ2gNbCPn0Bj/qJPkiFdvXpa4GP85m1wu1O3a/ +wihjzE3LcHxzummgoDy6DHrLJPVAxGyhigyMzFoODxVgtsKUHPSH/yxaHzFXGFGR +Ffm1DIPwNjl1FPXTyWy95BZonHLuQxE5eEGc8ms2REwbvv8bxMBVb6g6uoX8IzcR +5Xf4yA/+Bc2FJ7joj+VRUW0ghorP39Y8ttSb6quCgaDq6yyuJz68lS1R/o4eiUl3 +skOgIsUVo/Nxk5/JGVKn9ZMcP09lXyhsPW9T1MH68Oc8i8z5uXjEXXXTXUQuIf83 +Q50Ha8llsb8bRYjPqoXs5gbeVINwdtCYRY1v8p7pmMBG/GGQW8ZBI99at8cFBDhp +d0CI++rsFt/m9TTgsHiwdbs6MVtbI8aMXoZe11wHK0iy+0ZSpkXL88bHpC8KBxx2 +8TthZO2q8uQrvIx4TZGRKnSRFs6j+YWiCUGmK3tUpszo92Hrywy2WlTz7XZVhUQa +o0rTxH+HsAqKnrm9AHK5Z+uRvhAbJBh65s1hxnfP6RT0ZyBqdiC60UyuOb5xvULM +yBjy7zOpPbeWOR/ESsMIkOjl8zMQyRiELLX6J9+yjJ9XVWeQj/SKb7jx01v5FITJ +fRRt3mVX49i7frRl6nJIk56F48wdkB9DXHZE1za768JyL7TGhwMCpNnHRVuKZ/Ae +8hsKxcJqC5C2cpe/eOuoQC+UBJ0EcfcvDJqUAXu6aLOrYo4RI/u2IdOeKuBVWdYT +fY5fg+ufnIHKLt8tulyOxkhBmhiFs2FlzZZ0O/b+hik/0Ww7mJf2x4pTudwpNgYG +bGk9QvgTsylKcf2QP91ZzSabtAzjX8qmp9SCqD8/p7X/vHRwkCHy9glinC/UgqrF +Xi8PfI+rmR8GOdM4wi3QWJTrJPtszSg+xeqpuVWzzs2vK88OvHNx5vsKbE/pJ1b3 +PvYEIOUYms+1ooJ860SXwi1uMvDDrTi+w92uFn3H0RM8XZwYurXwCiqD4LwktZME +xT16Mm8jofH3znOErO0Td8A5MtMJXI0SgVA1A9WH3Bi2L7txHEca00PKCgJctORg +y/S0RwiikB4d51JZB47wQrxv6hUGP4JKzFgRJQs+0kiSmjx5Ca/gpglGVv2/MMry +s7I2mN+80oFxcxeEdX8xtKhiiREw6+4FNlhbRVPS57eNW1XpYfeAlBuNR7O0DRk/ +5nFOwKWuNnTfOzTUHXMngEcXKEB/YMuXh9/l2L2B2glwTdqkZiQRcPeTu23bmOQW +69QgHa16ULu0qCHBRx+81HlL6MqrC/+jDAre3Y8f3mIJSLSBwZcHdlfjOVqCKvWX +JE031egxqnxSyiDrtmxbj2eHhoHejzsHchB4GbLDeZWlzwdfr3P9aLGv1uu07Iev ++0f5L3OfhWhTmNcVHMT26o51B6H78f2vuVqY/oGGfaWru7mKBNRsZtwQ0dEgffpO +GThpuixCapbZGU7TiEJ9Z+nHksoEDqtksEDzX9XQETtd9JyYXuUXjYCMuLQRT3zp +s0aKZFTUpuwIlPAQUYRRa2huFuivpLOb5CziI7tpqNT3RcVHRHOFnONLjKF4/oln +3sTMogNRneDuwgfo0vuGlrpj7qfaw6Dob1bT2qBAf/g/tFVR+9+CtunrLKHReM9k +x/eaWRjWWg4ETVKPxgvOXy/TnjmxBVHrO+qDoX66nXnv1z5L42w+C+LSPYi0fWNi +5D6KWd4QoMlbjbTpE/zOhW0vd8HU/405OLQOTjX8HYmR/Kn+ATAWYPF3T75CyDQH +v3uF3QnSarSjdxaHJz7mCl4gMFlfhpvQYAlaS5M8XjfngOiWALX/iyqYhmQ4yUtJ +E5bvfvL6BJgeRnl6SNVHtwlfxviK8aAZg/zOMNHIVyMCXXAz9P/kmtozcEqHQXZg +Pum3BcrdynfqULC+3kDkU6HkvUptaGRCX0cfGngJX9jGhIbXH7dMCc6fhUbtgVFT +koXYU/dUBFgL4bycNW8bb+5EBjH6QHF7w7H9hkvU14v/sYe0aHoQagELdW37Mg1s +EF9Jw98OngBbcBGAtoHRqPzQakAQUpggZ6wsbnh3Yqu0kRUQ49cLxE5sd4PlRDOX +ixPViNehljf28OCzqtmN5Eo6EJSJfopnBAe74d9ymfW/wgw6QGubwtia3sGR339E +zR1TpxVc8yt8yeIZeOap4beay/LCvlU0eVfZmTp06V16z1h+4cvUFpFB7Dw/2mHb +8ZuhMyEur3Hkorrt/qjCsy9Kn0XemdUALYA7jviF/NWg+whpOI/AofKTBBNocfTY +bl1I3alqrnXQfud2uaqvSf75F7cNff/Dcou1fadRS0tDwKuWFyRjqsDZVgtuo9zD +RV+/OK0Gq1EEnTrLwgUJuQkWHbwS0DSbpD7Nxd4pooa0l7RSHIS2gsi+KPiErLPd +8RNDOj1NW3c5AXd1UnpGKFfNAxXl1NGB50whI3snM1G3s4vtcnWmsp9tJljRcYaZ +KQIG4dmEyqOVSXa0M4JvDm6yKiOgST6vf0kSXlaSoIiuxQxSJsI3uTB3ZLOjNmVF +DZJE0nL5Akl3AO+AylhdY7wQjE40MSLS8uEuWWXP/93SN/Wd9NkqT1p1RJfHc+bO +NqA/ncjw2m9Xch5ohSDQCwL6eaq4shza9w9/4riH72uJ7wI/uug9wAmbikAe0Nhi +DA95Rgxa4lmmlSci3HNSmMLV8vUtVYZH/W0jnkSG7H+h8Mrv4vzo+aQxe/OP9beV +MpRkVupBkXMcjGLBjhC7A2KsQEtZUBRYMyxDTTGtM5/0wM9thFjA73ffE3IFkrsG +29RiPuGaCk46eVlnAIYR5ViqxCBAf/Sym7muckeEzvQM37IpITp1Z8wZC3b7Oq2m +pW3HnF7NShPEoU8+rVq22xfeZ5ew6FNL3p+ElicfCE9oU1gdF4jwfWL5bX8B24nV +Jty7qD2ht+EkGh8uIUSwr67YK/IuKh4Zlxd2WvAeue0LvF7nibEnLVZLusIRqkuC +R51k6mym9bVGK+c6zgIxJ2JbhSMIz4jYgwzsWOM1ubwgUHSHjllPqO0VXL5R6iT4 +mHgDEgf/ojImgcO6zRMGscxx5f9qtEzH2GErZ8+FPB1eCT8jaLrOlij8m3901XMO +VAbMgITKY8m9TWettRKcMMou8wAFYEcvA+QdX32HP7G1Fciw15owlNyhGPT7B3ZK +kxeBr8mtj03K+XtzQE5h4GrertQlpFrl4dqSUiq0/mk7uFlXVjrVxdwWOiGKFVkk +E//TleYJQbJWiqisgPKNZvKSkzhYfMi/qXgfP+Pzdb4lppYB5WEQtmGzDr03PuZZ +ThXo+g9nZQzfQ/rAK2wZtlv5aq5iUtWbraXMYSadL7Huhtk5exiVVGoGJTkWBFPe +ynEHYqB9a4KG7VvrwDTTiV4TPv2yW5DNrxDjeSQzYsqgSSvnnkpEXLBU9P88aAA+ +9t5i++vDtI6cPB14XrP5beIuhahPATAJOk5p1FPQTa1mcGFiXOhLfuIveABd3cnm +2/ED2u82ztvBtml92+mrIdua49pAHqiS72Y1xJNL6NRl2zPaWbUhHJOHUkCB97oC +BSFP5kxY+0yknTNXV3uWGo89SkAF59KxHj0GKs9JEwE9dOrT4K1Jmb5eDzIsQQIg +LptcZ/dS3YtS/bf6t0DzyiZFIKm02bcGlTgOq0VXjAikZaRCMgBDezlWNAhqMXb0 +svB41Pa05FAWPKGuXv19COf8IlCEU43WlVgmhGixqQXoqEMYuR3TR44vh+TMv/6R +WuVfIxNPIGaXEQrl5BtMfPCKeh6M/uwu5DlxQYfX07i8hG/Ru6XxjLmGEuEcTByY +w18kxVnmHF1X469m23AT9A0QLk+Ojr9vK3yKYtc5kWVdgqtn44oX20LbXqhUqCRJ +jmGt0yWlwTD5NSSmRhH3ijXWpEdto+xXtOiFJTDcnNwfLGU8+Qqw6Kxo1J9kvbt6 +XDlGw75z7DeNbq4/PdFOOmgWRMJ8JDDpUPKgC1l9D7sXtPA+Pv6vmLBniA20Wgh4 +zteyodehXr4vnqQ63WWKGeIFQTrB7aCoAd0ehmqDmUdnm845ehtpSSBpxkg4+q0+ +wK7T1l6Xkx90Vs8+GNEGjZQXIb5EtFxAS8WJV3/+5X6+ywPPnJJ1uNZIK2UcW2r7 +F0gZxqZHekUt+sGMgUOodEexJYNNJM2rbGltSR5+sO4RNLm/q6QPG2ixboXiNmCR +5S1eySl4AfEaEgp4YWBhLUUdZR2ZLNMYRUOZxffA1G0jAaiT2k8z3RbFykUSaG2W +WRhmsslfVrlBALgvvbZVUPEGpBaeatcWqaOYYc5L+O00YfmzxqtVAyTyUfRoX1Yn +zE8pSDF3CvUscreOQwCeAb4a7SfDNbIWaV9l1EL1Y61w6Ai6PPa9orU9Ik0qX0oJ +9GDy60Ann+7H/hQTq/yKzrbRkzp3uTqeF7ECvtCG5vdxCWkPIxpHuvv1cyEZYg39 +uEmTyzdHsHaZqGMLi4TpjNpyYA4sRgF2kQpzUCQIsDcegBGllFcPlzIOUVB51eTZ +zLzdoByD31XVssVBMacAP4ALQ5osAByUeqvk6k9hK2YF0ghg7zPt93jYX+nJKYGY +2PXUUx4BQ4ods5J3zOfgyBKkSE3GMKsyCCrPuVFblzo3geIciPsoaU0p9rFTEF3H +flRR1gXByu0xBpfTCoh8N/1ECtgf/vP6RmB2q90/sKFEygzPGCA2hkRS1mSxKnX2 +PRu6fIZB3OjV7iQTQ8hUnzeO6hJ3CIEF9QChd5GkCM/vhGWWyTdyJC9CACiRfZDd +3SaYMOsTUDktoXtVlpVCdz3Dqh46gDGYceS1PFUBWi791nzP0+JqwxIZTw74VCIB +bDCFlyEkenU9+L33fj3U6ovczOkL1es1BbedEwCSLxKq2QfOSmah5YaX4qqVAFP4 +Ljqo2nZP0tFAeDOfuXKT0E5ai1oLS6+vYj0Yb3SddpSKmA0iAP61qcxxSgEi0wI1 +SMDzbTMLxzIqaiAaBDqwiVvaobvbwoDF1l3JLuCbW8z3q3fD3Wrl09Bn1MJ2SGRf +rN7xSPG4H4uawOKqllyMZwGXiZnReiZeU7/O9AZbbzEm1aubl777e3XKqcYki7E/ +mzZPC4ATVckZZwuud4SJPgZE3Ao9zILPtjTzFeawiNoHTHX3jXO22olMQTBPJ60s +TIsNa0NnwCHqbZpq732vKrD/dLblpOuVtZAzrF9wHV6yC+HS1mzp4LeeVroFiatk +PQy6pzlBCDUHQjocPGWmRbvv25YkDg1eFL5TL5Dy1eJMJKGpVcXw8qrZnQqd7Z1n +wIC8TZpqvJlvbk3yo90TxkindpMTQVOX13VQh0YP9k26YCbV3jDKGcewUaRDXNCM +WTNkhSG0rnrsZZrNuvtU+WuufytMkzdk0HVikdS1pWvWySxgPI8McMGJRe/AEo+Y +kz7uXBHubJsqYHo23oVgJcMLdarClSneqgp49AdEuBQjjCgWrqElzmfXo9awkDMz +BG5rAdicGnJly3wjBMWqc2FimU8+Kx++jil5nDxgyHlqFiGHdYBhhi+5KG1CXVcZ +jp1C78k8OYXxfK6h2DjmoSkRnFoDmAHrIdmPQqPmyXejFreGDcwO6qJSzvWG/wMw +CRSi+h0D8GEKP5P/AGIZECVunc1+9h9r6u9X6Q40Et7UoRLuwLbTpPh5KP3ut02j +TlBieEBbwu1G//VvZY1bBFLKYFIMox31VjDqaYvqt6H8IUnFOEIG5B61UMklSTYn +HVHhlydmfOnfonTq4Fiq3ZNsPaVWCSbM23rTvYUN2e99suMi7XdM5g2eFWn/+g0K +6JauupICisw5o2INCOsunV3EKvqoivxaUvy694nLlXgLAtkvbA37LdN/nLeA3S7I +bnU1An/9AfQbwbWTDC+4072W1g5dTZBh8Tl971uub3Zy8YwQ0lxHpNYoNFzTMhmP +hYGdVBiNKZj3w9XWb+MIyOBSGLcfar/B8MIRz0ZbybHlx/RKdISUKi/uML1gjtXC +5ZIXWaga95ezTgVfNqYYp18TfZFLXbmjBJ93gQ3LQJmoejlRZv92XkPNHOsOVglG +qzBP78XgLp1CFZkrDA3unA5kBwaetEhdps3OnHx20x73TIM/+FYrQr6hCBzJog+x +HLzrrlXEH+1/BNRKvNJjFkyH1adOltlit21g/7bE15Pq1p132M8e37gUR4KabHsh +ganT3tmV6ki5m7x/GbGV0n/eyTkjzxNGWF6XvnEJc+9rbChf3OLyfoUztvssEQTo +wId3f4+qkqDPqBaiUUogIgykymUasRFAN0/2km6BqLr49hchm5sxMiLVSkNfgsi5 +hhZr9L/n37kr6hjCiKHU3VCpcykgvjTwK4SzQU1Dh0/kkY9seaRH6q1tC+lLGhOn +OpGfMSgF0tcwPeBRNkWOqzffXmxY2kUCmO7YYhO8i5KUO7/EebmVI5fV0XdStoy2 +IRdNhhmiko5FyH6FWjGBOHkxveDqrLJwg5jsAIANSht8oxLih0oVH9HFxQLKjIDB +EdctvLiJI9KulMCSsbCZuZ1nYS9LSncFk0xk59L19hzG4zwNy/7ojpqB9uAHrpVY +ydTBFIBaYj3ukAcsH7Drd/d1+CY6Az4a4xp4vSNNhaEtdHzicZdwZKmorBX9BBqV +/jimgUvckfsSpvxyTjIX/EDJCXD1T+w9vOtfdOyJwuBrKy4fyG0WvfUwP5cRpQjb +ZcargwsU84n8zXbwdZ5GsJP6MdnLUwcR2Mrwoc3+fOpvXgd54y+tT7ikThfBf1Hb +u9VNpF6sIw4U5oPes38oLDDwDoQkWppShb6oG524eGn66aqnc00hYSnjSYm8NaZN +ZgtgVheyYwq+lg828S3G/4CB6azVxG+Of30gW55LHAj+7tSV5iUYK09uVqXPnfpq +SnZZHhe6HytpEAwhBK+z9S+DidW5xcsWZ3MXtk4KSz0XxdCJMWJ4IyqfkcKw5hmz +yAb1DAXZgywYnNSG29ggN0coeuQfE3XgLFdUJlsyfVXhk5jr9lUaokwDz35PdGBU +Y3TopBPRTXc+Ny/YUpVgrRLLT/1+hD4RiBppemc4vPYIPG24RqdBeTvG+V3clHjp +wu/+nw6DRRmiRRpNME5x1gqwQtMqhwMR1aA9NNdddbP959+igNt39jzYgRYhfVvq +ywTXR5PzRofmD9/TrWW1QGl9FyhZAuVIvH+baaqom7FGCgOKNLftXm3oA5IT0bwB +pcRhI+mdRafajVEFfy3YtJE9kDLFtz1mLaqHZcsb+wQLEvauAtWAsk5jb9RfPRbx +aNeC2H/edIoMgEwSKJ49ZJPhzJuglEcAp/ADAiLsH2RuBxFfX2SfvJeUQGrKRl4T +03oQI9OQ32738IWCyWY8yRo73bfzzTVr1w5dMH+4daj20ZpxguRiQC8EEahqxisO +O3VRuFa/JPDCWMPD4t/3KVi7DmLikN7r2s4j1XA9xpeJ7RjIVNsysI90lOEfxomE +hqmGseFeulzRHnhHXFIs5YNrpnNyd/kNDQaw5LBso4wW/+Y7KQgGpXGZtD2QXcj+ +ciMJabqDq/d7NmEJEop1xbtcZj+HRF9C67aSO5kZHLPtu6qTGbpp2yKVh3xndBdg +ztZXhfqtN9utFeMBnL1tCIqZ2uxQLjYf48BgC1Rdf6eUb5jJ0QNuRU3bpsnZN4Q5 +rFNRmka4oUFvbmKxikhkVv6yKWb5a1DyJQV9Kj8zD53JNh/G43UJMoS6GXLjbOJE +akDV8Z7EZU1xWwjgLAZ47Zi2G1fUSFd1YqpaVyj7l7gdgus748c9tPPtnkF90UU8 +cM+2R3h4DEPPAHJIx/gG3GKRrwjYt3nRukdKfIFkh47WiDBXsFzrA7Anunix+QFy +Lu7+aa2J6pAFQHHde2OVGk3RCjgu6mtbBuvnfJstkFf50RRRAoyS0CqvRCsMnVb2 +O8EjScfZb+83l9dIPr/TaEd8BprDrBw/+BsYHE8+0Qmjw1l7Y33oTdMjvVBK2MQx +O243TWhpbw5Qsbv0THsMbwKQ9Rc/yQY0XIE9qZUzz+Si8JuvdnNpImvVyTZodbuw +Kyrxxw2/VaZ0+LSivp4OwSK7z3oj2G0/RW2gMK0eMSEeNGLqX3O4u3xbB78zyTC/ +Wqe9UG72zoanDUnCxkqLlr2ttpAJJDuB2jBUSbhKEpJF8+AYYKkoDR6+qbUZpddp +hZNXAFPChEmhNnjYAZZY2sezONqo0K1Rqg/hN8OHEMVpy3koouzQhOIhIJW59PUy +MCl+6nwhbee1LUbmVKnKccsJjVXGr06d/n1wJfBCyZ5IX5MpWQJwNbxbqUc69N9q +Ryqmmtxia0b81x0VqCb9cF2TgDepFwgtJ35J7Vv8P1YRmMmmPHCjMlqGFKRPSEp0 +IE6p3ADWYQEkFdzWbuYCRIWwT8Vf8VbrrYsPvaMjEZhzH1jav9L2EiqGwV3EHV6y +h6YakgcU66cs7NqzcEiZ1RqZkbvZ30FOoI1WGy2f6RCqAT5QgQATPvSFQ/JIYCof +k6xYnoShEopubLi8f/TreVHCdVsdOhmN7R0d6OuEwYXhz9DK/TR2A8zSd4GiHcvm +eLE1+z2HvOhDHnxoSNQtnQQGvUVGFcRZkL0r2MdrcLWHSiCymDfRF7N7vGPSlNW6 +iIgK07nypi4B84ilDFyfwPYEeV7Aq5oCfd6qQ6ze3Azg4CY6LbrR1ka5r4+vps1C +KYe9BHH1JWnjWkxqMQcfplbQWZl9Grgej3z3bRDbQyHeQDBmSo/tmcklHvA8+nLY +uTLwS3jlzNLwuAhE5is7muNbBRokcYE33aHxndNLkjgOCBX8dDT19ubbDs4/Oqim +iolQnD6iRJuY2qg7w9sKTTPLQQzPgY6kBKoy7Rb6HEIe3JhErbPiOkWeEgcX7cX1 +DGwl2PFZLoSJ7mLxjNt2fTwF1lsQczvWTr6k3YaEgeXJvlxbjIoWYxqWVfnwES0g +lB3LE6Q+GrFp71R//Sly6KZ7dCuTGkM7jsUHnbNLESYche6g6S4DlHOu67AaJkkO +Cd60Xp+BJkmEBOGGwqZ549pahqUM6NQgvmkaAWJStYZbg/sMlrHOxdVJxygkQyu9 +uA+PUbthnEUIKNlD+1A0v9rX+tbW7z2qdUtMJ2uEnzGzbGKOm8P++FfubuTfjdua +k17YFIriUn97ORCSSNjUv9qz9CNEpCFv/EEEIvqMWsDogdScsp4o/d6SJxxWw77L +j2fNdVTe52p45Gszx6pwKl51tOFJRkt9oeF5w1e8n11HYXrjcDqDIeyo9SElAvOB +nD9J/qmLEjyZ8R833XfJWJV9R+yyHBnE2/nETaCt9UMntqItxf7b3tpTWHvud+bs +8YGf8xKcrYEkEx6fMvdgF7tQxmUZ+NYtyEmNgSvRiPvwVWiPvxRd9bu2dSeMjLda +SE11V62LwdvzOTRKSq9euwde3HC7oSd/ss4UXGii/QzwuX2I5lD42EDzYwx5+ps/ +6Lree2B27C17RJwRRZSWT/0d4k9XDxscITpQV8Rr44PjxlCDOopZC/sRxFqXojlP +4znQxRkR1QE+udmrJYmGzcN7enFWbvYgI7Gk87EamuFg3vzALtIjBHwrXcjGO/PZ +wqaGPKa3vPwBKrdJAPPX6NZeYFCXBgoHtoHAGt/mOOcNbTl8znpj6n7nXaxEVNug +PMGqncK9ONKtY0B99dGA8uGK8oL6yoyMMYPEg2DYwjxsLT5C+2LJVfuAS/EyaLlk +35XDViLxQj3OSzlJbJsHA6c/ls2IfY/pcoubFlgMXgXRDrYXxlRtdF5Rh5WOjI/0 +tMIg4qsAsRBQPz2LaWGZeFZ4CTDINYHkJ8fLYYl1sc8+dtQGpdzVe7Vc38qrGuej +VId8nJJiaXGWdlJVePZloU3uROzgHh2mnS7wOtybGvjGZ0DVyt6hdROjKT1cRG2I +jY2K6bvOHykrFUplGUV2EDjsGa+OOxvzUl8ge6Kg4L2LI2lYTFjb5ZSQ9RgMBMmn +a7VbShQqbo25/TfZBiAhWcETLi+0/w+DWeoPIn6c8UjKgmJqUoQqkaQdj66ytzDq +PX/8hVF0dkIEOhB5drzTKPv1vhNMnZWzVHjG48vg5S9z9mH2oeiTUAjFx556+YPw +mKeUsZsBea/eUvjP4AK3yueMKiyf//oSGYKDZmi1H/okVcoFslTgblLKIn6VyOzG +Lup1YvsxOeiEsHcXfitF7qBvZrw7V6Yn9B88hYgb1e4gLXYqJdZbX9NW/NAoRHgE +4ER8U417UzFGEz5xaHP7clOEetLJsjWG1xyH3CeF+ycHvz4fEdMm3B+GmQQ3ugQi +nWupl5cjFDi5GEH97ztTycu4+be7cSKTFFrRqQ4CC9kAXMBFqa8BZ06DSSlF2Xr+ +9oFNr51zjgnB/2K98DaRpKnKhdT36f5ejRhPil3qcukxpre2XcHMq5znGrhaU/wM +fmGM4GgBsuX11FdqxNsVzyonCFom7Q5Ilmd1RJq7yA80GzaOy/bEDjiCz8bvCAUS +V/JnvTUEs5bql1XN/BlrN54K1mXyPgQZjyJX02kaYhN6GHHJ/v7eZJSNRBWCJeht +4SH7Pt/bbI5uqE54HauZFYZ/DJpASQUX9RvUZFWsxgaf+toaUChywgeTG9PZvTyk +rRtBMgNOCe4k/hHlXyr2ci+yprjxAtdOoz5JzT6Idc4smhK7wkC9vo7YwAJ5BiQI +tt6N1SOf4y2d4KXlyvoZxrnfBSRjE6xW5FPuIinTu8UolTOPdI/Ao7IPBnWbLGmy +CLDoU6E02sNgJFOoJ7nyY/AIcHfcd0ux2++NeHVrBG295DYAZYgU1i7hTuOpYm+E +b3D1blNy+0jqhosCxoY6X4v4OUh+pOHFB1Gnri6yoOun8cYU1YSwCpA7e1Q6XJWv +EwtwIiXRl1YXNdvI4J6M3fMJG/2ChMm6GBcIQ5+Q2ckaOcRGNIzFzrOkCPhQlqrg +Gn2Cno/4KFx+nE1dhHQONraz4E4RfTmOFLcRS3xPqH03+EkOOBuUuouC/EhwDAnj +7qG+Xn1oSj1fnXPxZa085YuGX+Stei/Nm4hYSsZmc9LwJF5/mHohOJ9D7xXcHRGc +zaSGHbMEfKi1IOMIu42FK8rfm1heC7Jg9UQTT1VPSdSHA8W9uSQoPYwX6VGvXkVs +3wmWCfwU7v/rso9tLGcFDNyIRhfFTq39HWmIFbgXa1zD3EsIjCkwazumB8kW4/jd +0gkjPWw4ML8TAmux2lvnDPC4f0E6/8nnbHcaVuwZpMsRXvQpUPfmHXOtoxgGQzbV +fY0zh+Wlrcw/G1VbKUsRULFxVnvefx7l6BH5gwLjSxXeRAaqlAS9WQ4/KDSUbMRn +T+s9j9E+6Gp2+cCmV4qtghZ9HgZFqrWEinhYroZ7zYwZwCRZxRXCk9Pf3k/eKHpm ++jVVTiKoxuQEVYYZphNYPYFDnQT2yjdj3WhGyrV82PNHESnlECBRfhWslFnrGM24 +MRtiw3bb37UFtBSbMB3gz/HGOLx7hRZOgf6ZNVv7vaLRThkoucsPlVjRuo5SqBsP +owzIpsLrsztEHcn8O56kTLePsNzoXzPmXqrfuLmTD5gPnf2Yzs4YbyFlewfCgvfL +/OoRzuV407ZW924xm/egjGtII1znC3OPhUvf8oOeqyMYagAYqzGvJl23zit5A3rA +YbAdLYySWBz/hx9ENH7WWC6/96U+AVlx+6r1sacjGTCoCiUcZVP/phW3Bxm0BrWB +wv4u5tePLjroPFglgsFw7iRJFCa4A2iFfvErmYD73xRE4gtS/GyjZhVucuxNrXkN +IjJQEwFKOMhQE20xLMrcUu9a2GPOXk13eoCQo6Q9fQlMsb2uOvNHl0+RT3eEH2XL +jqijuTK0iB5bc5aBHtQuXfseAxibgfvL2YBofGDi8R9k0ZRQZJ4IeWG1VYzvWpMl +u8q9psTE7hjFEDkyAUBzXte0X7nQeUdlwy4UcUq4C2TMsNbaxdkNL5mlCc49byNY +l0FdrGbMlWaCoj9RtvmA2lU7ZldqfUkd4HgDm5iGT1l5YebRAR0Xx/uRl4DPQDE2 +tDIkv5O75uwsDx8an9Z9k6EiUseYETcg+oGztl3nvKSJo7xcriOe2yzo5i6jJAuc +EEWrheQyS0Mx2a2oeALtoOcK8zjTf7twqp/QEBp8HHQ226Qh6+WnTSTNDi9jbsHH +7r9bCULgfIchonSkYWydpClmXrql5YGU8oGLabyE/VyOd2qot2NsHGIriBHKUHm+ +toeLUavQ59cHytArKWMiO7MsV1a/o/YR2Idc0t3xr0vZqHr83HiEeu24ptH6Ldk+ +FYqrOCGG5OL1ZZ9BfDnDm2UuttapS4b156cYCLglwqYxSBAX+/rG4aTgYLQ70Huo +visTmIzh529ySpOicETHwsn18A65obTHVzcBFjR4wK9SGoQht6JdjPi9sS5V+9rB +55f1fpyNGbWiOGqg+RnKOYTeDkJ0z4RDw9mI8ThCwBluog5vpgr+NM89uWJ/DYpM +oBGRtGk6k4fx42N6rjrLwC/amit/GZX7g63xKgm0j33ESLJDkgdFc+GsgHj9fPGC +rFrUwtDq0b1lwzSRVQ0QkBMHlJyZmDcGh/54rCaoB2p+qnKXVrfF4yfE6MM34uXX +FI663KcWHHnNHY412NEMsWawswIX2ZXelpFU2Dd2d1C6DtcsB2kl5yCPNDjebi+H +rx900/RvaZgV9D14+ZrHrMdoWMcRYmhyvFaPUr0FXPsPO2Y+YYrx2uVl/6oE5LHt +BEEkiR94UzEZZDEY7+MYU3C54/IjLWDLSzQ5oHcScevNc5YpeHj8v8u7PxRNzoia +LkHUVEMf0DZu63L3r7de0Y2UVP2rmeY/s4Lwz7aczK00nlYo5uvDZDX9UT8QwntM +zLXmk94du+I35M28WbJqazsxhv4SkzNPl3Fml3G6i1IVRvo919LJ2lpvheN5ZoLI ++8jaAzTnA9B7Y5ZFHXnAhKsvAAZsre5NjPnTtJni0qJatW2avSg5teuf2QV94O4C +dsUVGlDVxr6/wBj6Gat86wa2EN4h1eWXMo9GGn1nQ+CtTUrMr8/eSP3cbrpC1F55 +WGJUXUqCaVa0wyeutFLdjJAcazb2ESHw5y4yIBTHB854l/tIMYwijHC8by/NmX5N +ZUuO3ZOAgkYjI5/QJQgOxm3N1Ggg8gS/lh3oC1ubefrcTVSQL6SRp/f8C9rFPdhN +Ld85THgktzTENuDbzq6GbTxDWUZuABm22lmmc36pkojHMMgkjJwwqtiJBrfHBCU5 +q1sQoh+r3PgnJAsZjVnQQfRkr9y57gmRKN6h8i2c6Q9ePWWpXe9TjWCla0+Wlsit +2g2TEkLpUXIEdmahkHoM76Tn3w/1C3uEjRgFIpsmofXAINDegQ9+xDJgAlGYyvvj +Wfpif0h5Vc8r+t6E1ia0+j13pQJy35NkjUaHDNUvJAsvPDPyHcPv9/lepTp+7jZ6 +eeisr3sPi+m15R6d2HznPameBJow7lWRccsy1OweSqKMU7yNfjuyEGYoOMLVzIFP +UwOfeElCUVLGvyu6NGtiaEfH5XkJ4j+02MvYXN7CcMdZf5UqAz776SnW+iVxZkqP +3lRGFDZ+5pns+NcT1cwKnE5BhBmGD496IUoSJoLHH3NhAj/mB/x3VbJALpjXOsR/ +kFBBt8+gRazpNhuk1RqHkRo1U6ZklpImzvlsr8QJJYR8sttsDkx2O7eoDDDIKMQZ +w3vF2EEFFeCbm562fGTYsCOzoOMW/N7IVC/1T+Hbm3JpeOcyXhHufr+h7e+vSFI7 +rH20viz3z5I9EEUl8vWQpzVdVx6mE0Zqzi768y3jOEAi0halLL25cI53kyk0AEuk +VYeAeY1WIOlChj/AkyI2Z+8bH+AD0T/8NF/aJQzqNlcG6DfiK3rKDEmU23pFz6Ng +goacYKwmqIw8zYQGmegoxRyV6rILM120EyPZPIDQX9R/XQS9YQMSnDQxE3SjhuBM +vtHNnQORPb4ziE+E6tePiTmsMy7ocSfpY1eahAzWLTpXJy2xo6P6XBxQmzuIYVLY +DaqpF1CG+Tawd2UCcBEbjVa7iMbH+Aep5+UAPjB/AerVCyUBTN2QgnGPORs7Knu7 +LDqenWNnvRKYUBNp5G+dDD22BwQ/OMbLDyQq4PnStH+rGwFNAj4HovLiUtiAJGxa +Tvrqo6CATK+lgTBQyq1uuk9039Syd79/qxZv30gkgvjNj0+Ln3ZaaKPyBKcbb7A4 +TuaHyLNyNJft7s+5Yym72Wt7anUXSD1aRj116AEkdSIntVCYETM4AyjyKdJ55TMG +97GT/VyBYg3jyXwlIcnAivoq7ddEH7wtIKJkI0PzP+LREN4kcuKnbWd9ktWfvCgL +xd+DPW65VbPMiTaVmGfl0mt84kZE9KXq1RUZ2T0P5oaVJtGzHmo/FcKcuPtWYQlA +J0gBipB5KBkKaRKak1aP/J2a34/VL2NW8iGbRznif+tJA1CqWZ7wnbF3DLhok5uf +P2bDvP1P/w0oaTnAMiUKZQ9K6DPAlMZttDis3hPoGppzf7DOm35yAPJX6oKhC8pX +DqK4kSEPw6O/94fbeLCaYleXA+rB8C5mi1W/SO9qG5si2qeUtA2X2y6lyopXC2Tn +RGFmpeXiMOVBgan7M/Zm+fyjMKghTfMZSAIA2YsXJUtvFU0aCZ0kuTx/eZ58ik37 +CKH7qcNgED65R34M4dysOBvIS0MSAQuWTg1fWW0rTUsBbD7qbJVCBETvl6AJ7t6k +LrqOky5WFyfDu0VkJkVxY7xyeI7A2NZHMU+KPymigQwQLoLIvJrjf2VpL+yIqaJE +iODoqjRfc1FF+8Fz06PCBwURu+II1mdvsu/Z3NOUTvOPxT/2stBxJ58W1QnkI3w5 +kE7Ht9T5TsVuwtg00y90hdx4NC1iL0I771zOZi/uLwM1FCKJhT0lmmxDXj6esfIs +bU0f34+iyL+vlS2i+V2G6rv/2vOJwkb2+1fW58TyFwbKQdxAUjrZK889HGQiM+QL +qG50awQCSq8Xptdc3xQvVudj+06IroKrPvx2ng+w33GvS9tXA63MulELQY8R5a1d +CncwRpmk+ES9WjBJbluvSvqItZanCsYrXkfSEPcmV2BZAEj7o0kWXuwrBCU8bp7V +ff7LXyXyh4b0qC/CYbsF/Vtv9u5SDHeWayQEigTOz2MUf2vWgTWwpBMsJUpcwKVT +d4SRku8Q3Gpd3Ymvfl8ZxCLLBRhoGE4+l4f2j8k9TDcRFVDjd/4nB4sVKlFCjre6 +LpoO+Oxh56yMkj1QOJGHVJfRDGIxiJhV2gS+9UJV0uGwpz4l38Yubpxq4/2IUWdr +ZGeTdLgPPxnVsCrYbV1JZ+0yigciIUkOL+3+FlAP0tiGM7r6WCJWU5QaeIU0vZov +ZsaIyjzE9AfPXqyXPttne9Eou1h53DNW0YnozuGeItdZ1tkYkmG5qwok7DNshU+w +X+1zmweyqpmx3DCijUzbVsNwqlJY7QoWK47vFrW5tK5zdu3T9eN4HG7JqMra1kGj +vfp0cJFImJgnMecRE9EBKIuBywoeFuz91HVRr+WR4HIDkQ76HRkfGJlolomoO7El +raBQeSHdWro1IoHLcMGk+O5N0p1kUu0sgrJvWtTExJ2iiwMoFwg8CBSWGU7e9KEN +itTr8oyARieOjKTBna5Pbf+ZdOtcPgB5Can2uf72WoyIHpqf7qu/MXEW4uKXpNIz +UkgV2jd4xWb0GWL0LJSpEfeYbgHoHHxxo/igieGuw/WEOACHJDZDdCPeNkjySnni +5FlVP+5uCFbYVaEu3HkCoyBn2VZTpElEq8Pt1NiTi69yjCasMBlhQczIPM0hrgFm +x8JEsCob2Caq60OkduGUcCa9tZSN9HprmX5uotPDhzR+KDrGTBJoUcAEoRCO85b5 +mGmcMeZfb3M+uKkHNuG3s/vNAfW7h9Sm8fnZkhuuHWqZmW8NtEbzcXBgg8MH4tQI +gXyatlQncwrlTr5/mjFOLINtVWr90g4+LhzsLlCFhf7kY5oqasPUD9UMox5m7Uu8 +aLT/GHNevAuAMRGyvrVZzEgziQeChEwZfea2m5IzMWlp7/4ZCsvZAkZmyeOPXzdN +55vmNjQ+9raeF8L7cw21YU9VjZHLrssi+u206GgPN2ZexijSpsLNvoq7f/eqmKt/ +TawhOhFdWPZcJRdlycDRwHTt2tOmcUGeegme3rUCd25bsH2+3mZ2xLXMiCPZXNmI +EO5cdQq5oAb5w+XGWfFT1Jg19kGkwikRlqpknRzkDiAekITxQvD8A+mpg0K1yycG +3JDj0EgjcLcBoPb+ofuj1gUcXC7RxihVjhi6gFgAu+XjgovGcf4QuCmrKFHnfiSx +YUn9eMOyTyGQvZlaLbi5aS1wtLR3e5D6asDAypnMgHy6fce7YNQ1Wcntbvjnl6c1 +CS/olR1v8GmA70EejoV5iBLyQ2pusn8kRpEf0gp/il82eXAarhhotAamlL0PM5FQ +ZtI9mWs/Ki365UZ2iu1PEIRLqlD9zCK689EPiMe7W2QiGYET6Ja01m40IlzoevL1 +UiePVN41H2KW8ZpfW2VEAyQNzto56mYbuWaP0gCPItAH4kS68Z9H+KxN9SVIVVYR +hTtH0q/AKWOHYleXagIV+eKm+mrHRM9iFriHnTqJCn+ZJ7i4ljpVoYp3EZvkKBxg +ml/dJkVSzOTAm1FHG9t4jXssBdB1j4qgZcbh1g2ROjrrDY6sgwqU87FHoZmkaNEY +6NJk3RqjtxM00zzsK2eJLxNpCFGJeFV3cc+h3jYCf7Bulmj1h/PW5MVkA720Xckx +rhb7Xo7JiSNteg5cn96EPWntFHj0Rh0I2busGytI11FrFrSVwNeKYFGDnsFmpYMH +myY/nxsMtkacQLwTjLZculDrhoQvPHhKBX+wMyQ85DxTBDazDH/TL7bt6yWtD2Ob +G6met2wsOI9L4H6v9HT5L74OJAo//u6AjPtLYVD6IPeJnftZemfss96khPa0bPcL +0CRYvd8Fb8+3qkBjsI5B5ChGMJ+hZuejx42tzjxvyZI+tT2U0H82K0Xn51jPE1YI +vCw9UbybyWRgajlQoTXPgVZi3bcXnzPpTABmvFpri9G/54E8y+nYVzqnGxcRphO7 +0Ms0LyqVeB4eFR+FjVGIV5b8Pk/NJVQd9U09o0Youucv24jMMOVEa8TD1H+2KeTd +5wrZIC/yiICuGlroS79FEsdbJSbME1wh+EPGvLQC1abCB28BrB5x5TIkYHhjJP7U +Q+teMEn8coPQWI5OZQKpLXqhHA+pYSzc3jo2r7KkVOUKeprp59ZZqOj91rnmpVej +GZsSJ/mqjN7xK4a/k+6aHOEFK0XZFpJYFfeIhleRP7/ENGZ2kn6XwUTaz+sg+kIF +48RMc1M5M0NoA9e35tRnTgkmKmNJUMIzX0zyagW4HcUI3GmENNS0MudcD6JkBqCU +ocb9VqIsmrp8+eQylzHqCyvTErRmsKDTuw8ag8/2xRMGtmuee5Tty4/aoFVvyuKB +I2VzE1/Cax8YLYxt6L47LmwTHsbnTojLaaxF8RuWqaUdhDOyV0Pc5V4TDfgOWtBg +jv4kocw3hbwmVmyT+xHojXxHnUHKA4FNSk/4zIr/NuCSeWJhpWGy41Htc6q7Xk9c +G3NcooNDh6cb3+0qEawXQ0nVNfzk7hYZ7kBqt/uOr4vIfzMvh/d36y8snnFh5x2H ++ICXVsspEyAltLGetYyww8j4OY/3aiCV17K3cZZ8kP3LMtJ5qqmPcSRQG9FifsD1 +MeByGaamYJb3m8KLQT/S9HWkBUCWemKnOH13p7ngPct5GTY29lGR/rwBqPGCjfyM +H96A6Kv269VAO8eAwtvOnWtACzrn7nFuRSFi4n4EBa3GeoWJoCyC/2XyDLQUD4Em +95M1+qr0v4EW+/LI6JdtWrAu1h/mvJ0VyeyTzD/Z74r6ecczGAZNlQRmvJvUqOGQ +QgYzjcPWEBZ8VX3O1vP11IdycLrejHollXbwg2ifHaMghCJZIA5DAQEGvgWM3l8C +hTN2f2ZkQwuUVZecgawub3Kxy8kILXd9+dvL+gWr35rHmaEdaKyW0Zh4I38DWFzB +dGOviohYMTNwZU2RATb4nKdXEEEY5Y6pavvlM4FwAaWjR5SDybybcK2N5pY3PHnU +RnBhvxT/tlqGCdbORSDaeLHEadf80kS27mrP5IVO/1ATeA0mRJAor2LPh9HCCJes +KApV6+rTRFH8WX3t1mINbbLKkcH0zrcGWLLr0e+0RJe7D0pK1a3vkeIQFh+FRmp5 +YqLEIfmFuK2/nxFFZqgWFbZAlCxd57BhGC6BrFPBDBT5EhNQcWLlNxTxH7RAvVYq +KnKn4smwR6DSFYOws/4pBbF12XRELJyag2SN+OgpxTygRufskXx6mITTqEpoCYav +fhVhgjCsJZCwOSE4KoQIwFn+X0H/WmDXV/libGUMtCCCJAJ3J1f61b1djaBiwU3B +pItwYjyArxAWCfQ++GCTwWqWYHHjLxBt5sM8MrKg97/e4metFcK1irFo5ykb8QoX +m/PRJ/ZarLsDQL5HtrpnpN4z9+m/+5u3vkWdDztoJQ7jpUiWbFdB+wGA8iw+afVO +7ZMg820bWfJH1F11KjASEsHIQ93BLdOrTjYsGUXKRhtky33WfAbCEvjCdMSrrix/ +1cM0yTKLFoBRSdFHhJ6J17bTT5Xt+wFJBohU/ZEVOLNMekizH6mOWusXvFbMOw/9 +qWoQUludgaOtDWoQlVBYtVVGH0Rry4M7zXF6axiRTVcS8iCoAh7zNA8C5ltF03fW +9reMYt0Nyrv3k4Wo40isEYeZIkG5U/QG/VDXd78HpIocnwZLg99rqcteL72/6a4O +Zb9gC6E9T/+30mdFxywQ4FQwO+7fHaAh0lbY0I3fdPJ1mSseQP8e0Kg50Jowpwvu +hND761MASyZPYtq5dOdYRP8ccS+a9UqIdZgyNUcVh+JsYPDsk4J4RxYNTNEMJzqW +PF8kVs32D0V45DGnzcC4jKlhB9DHuCTB6OD/xE0Vbj0e5AcHb5vfUc0/++aJAWY3 +BLhfr+9H/SK2IkMk1EKCFY1Q9z8gpWZxRc6YSwuUV2RKhDlIJfOrAWFi05SpMs8O +ZptQnruQBIHl6E426Plz3EGL6Ctg/TIEQUjJwKDtD7s8pN7kvfAbfzZRU2N1NioO +5zItxTBWUzH8Xy0Bb4cbwcCDG7AaJzRQUKJou7P4QZK0VEBuVW7KVV1+++B7+n2d +X/047CPXk2HJSiKDRbaHEDTlKsUwsZWlhjNKmt7DiM6ZHiPnnx4xvUBc3II40MvD +Jy2uMCyyMrtHnFNMl2JYEZn1AA+Th/1088ke3xtgPhzOzBrGF9JMv6cutt6aJtKn +cRZRivmFDzU5lQyjHLJR5oZcFi2hoQ7pyRjYT3hqoMu3ILKiLr9XiTzdeyKRx9Mz +0UWWd9VJ9BWy3SkhTNg12t0R0eUXwtjUcA8/HOA/M+vkl1dyM0uLuAtGSH6ZKMh8 +RqtDTx7L/n+md7OpFZfeNulFuuFbNIpSGeLd3yjwAILTROdB8qytwi4l99owivt9 +0XnXnv0v+rd+vRWksLZH1QchZS5tJDnf6vSh1Xpj9T6wwfzh+CxL/0rgdN12rpSd +tWertZNDkPlX8smpifdonx6884C4UiaEOB49tVEWMU4cAIbP9tkIBKhp7uyCYMEp +Qh+jnoTENGRMX2rkeZQl0+GTnkq50si6E0Qd0VfE1npZnxZNk8VNXZy93JAjpxsk +qdDk2g52r5V+bvrOyuDMScEK3SOklYZIDcdvAXsMhGp88xaCUS6dW51vBGUbPn8H +A6gFEKG4A4BMFjoPEvrOlkkFbdYjLO5c4aivpSm09sKJCsG5PHNU95o1WTU+41M/ +UqMd7S6uKpqPGiqrcUo3EcE4TwltDVdWpNcdoZSsqMhMX73DBKoAp0mORzsQ6dti +hPmI1SmOvnT/MfOFSxgkLVGlbilk4yQX6CtvoK9VeRlDGmh4tCGQmnjWULkwD5CD +2wwJa3rkriLTAfAzT4ifsaTs1J1sg/ZwUvrPmEm5PNCHe4RCUE6g6s/Cytbpwes9 +9/DcAzW4PYmQ+q0TJ0jk8j0tJV5fDxRqSkaTV2AJxq4kEuU+t+MtXW5LlUBxtxbY +ml1rFfQuabBKehexqIN22pOjBiX1SgMenzfGOlJ0ZERQ+mDkqVXrFVRv046HVnfd +KHp13ut+pAlPiTtttM+rBs2oOEFPcQnGayXxL8yQz1Fep5R/w0vu+/qjw+mRcJ+r +4SXzVDZn3vL6KUEmO12ynUXOHTL1xcWfGkvDo4FpdyvCThNuhYi295fKfEVsAY+E +yfHRzaIY8SOsXVAh0A7+t/HzJnDfHNf1OPzJciomZk0VTolBYYfHe6u3oa+xXSZ8 +7nZ5fOJa1gOmbBY/9g0mnZpCFrYyCBPcbi2o7AP2J1t6xPNI5BIIEURL0ZydpkaA +whci6dHCBpJ9bJhFNtnhuc2cMPjk2nVoivm/mY0VMQosiht9tqEEn2pnCgcfZAfo +tdPDzKGdKnvlwukK3vmliFqWxwabDskzwkCIpU3GL86usrKakSccyqF9SDs/WVp2 +5vL7HvpOGIUgsLi9LeK+4xePxzix+flTu46lUlVpUWWEKx8Nwj61itVmto0loMpM +FFZWSvHmzXtNBZO3R3LVTYi2nZ+y2c3ECe3S1xrIPwKLaxNW/EK6nIJ5KEulNoPj +Bp+knwGWw2G89zHuQIzhcsw7ADA4BpOHyWSAi/DPjdd9AxMQS2GRKBub/xF45kbP +2TvmiimrhVPxH1W8jYuTAjgYv6dd6ADY2ZBKg/j+oCyA8jFNmYDFyQnxoYFKbgHc +ucys2hztAVuLTTYCqUlUuEmA5ypFUmpOYiPd9lctESaD303Hb9DUFnOgJhO0UWQn +ZNWPhXC/fyaDIP9yG8tPLmyBDMj4bE1f0TzNAWzdAescb+cmTt/nD3CU7vUWlQZ6 +9Fauj+RbjmJ31JxfxsE4glCZIBfpsyPzanNIsz1+h7oB8ig2GV/VD9ubTbtmakrX +6QsmT3q0z3tFqkcuUPPvchZpGRyg8WLjoglArJlNqfHQzjIBBqFf8VnasXileZuD +Jqz+ZMxWXUqo3WJbNIEVdERfHa3nUfusN5V/JHOmNnY9eVlF4az0/wK7t92czhph +nrCOGgcn/czeoL+iMKHYi1cRCZ9SlPlX7NclOkt4BSzsjpNeXDgPWkHplIsdJD9u +8VEFLL33Z5U++oHiOaTSng1zsgRjpijW3NRan9Vf4QXOcCxWwWMLF7/pxNWGN2O0 +rsX/QsR86Y4EEZhHEU37KImKUEd6aA0L5TID1H/kPXbtDUPU4dspK6BqsR+ynv68 +6HiEwuFcTCf55AA6gysvqBYSi0kluHP1MWlEtIUH6HeD12Usrsudm9/XJX9orXAO +1NYYhz0CNAIT2x3HqXrRyd7jioeBj+02WlxM1UAkLfF9IYFNNs2ngP9IP0LatFCX +AqLVECA0tUrrpwN3lXtkeAaPapPzZQHYtyCy4iKjtztQ7nqUiRTRJKlfFLIl/4su +cWaHINnWjBQO2CjCmfyzbgwbnRdb9TzhojuogQIRaFwVs+Q+rHfEI1RvKSsKh2Sh +sOaxTlNuDEMDV+1+ZCHsLArhOhv2huC8xPiFcBl2hpTIIhSoPhhkJ9m3OgidJ2mz +AEGCW7YsIyKwdonMz/n4LO32DhH0dZkc7AONoRuacOZPGDb5o5Fzti5E5cc9Ztvt +IqiDhSoPgUkd5nTWVNbDQL4R486QT3nG/L1vVswsx1fJRaWgIMFCV7mYNpRE0tVF +/S+6wvv/MzN5Ce1i8I7uadGMkoIrpP4f3vuw/oJzg1tROew16XBeZCeYExC2fhSe +XCmajnLHIUHME51ps5k+N5JRvgueZmeHHjM3+PIqPG2hVPh39QOoIbiwbiEhEnPR +wo7ebMeSu1gZgmTid98vicvA0ij4GaSk4vr4va6xe3dE9dHrK+grqlGwxCyIpr9U +7ZK280YrIZE0SHjtVrhLdlB8MdQMsqay2a1YtlOQukD/G3aIpjI9TofEyKBBh6tC +U5g7dhsxbHhKUH1sSsinmp18sW7iBa9wx0hDNrcyxpShnH2V+l/mGxA+gScsfZN1 +Ol1KKn5zreDb4Q51et9gvEukI3kJNKT36rHgpd7aMRikXV9gXo4c820ipvuoOChO +ffLEwqpGJdIciTPoZz2nT41YjvmnXy6vYs3gUniODChA4FQXgzdnJkOMqbjH+ht5 ++dMEWzPbPob9vMJQHIVbYJHP+7eEXep6IrBKn6RowuNKwrYwyvzpU8YLrNiYkZ3r +hgIApVZoNcYdZ5ZinGYhuv7Ae7dU2OUjx4HuvZ4W9U1YmcFHI+v13r00IA08105H +rQcl4tVd/c9ZrUMzgfazB2nl9EgFi9Zdktwyh5YU3Ny/gs2dd7tH4Q6tH5XS+VSZ +Zo1CscYE4Qs6+oHW3gqj2Q1mC0BbezhZ9gmV78ZmShndx44Eh0b542HuWU68N7ri +EhqdfpzcTKaYMP0qmVJXPkRcmTVNWl+S3/ol6ElkBDnB25ZGDwwPuuxVgmjLmSLP +3O9Ijr755qSF5YvREd0wa8yVLm0gbvGUxOeLgY8h6DoHmYIwx40wJJQZL0myBEY/ +pekXkSk3WvLcZfrOAHASgzbv4b9lNduUs4bk6LGvT48AKN2wNMi9Iw1nYn5abuBD +zRgPPpa/plqTAlGBpF/boVsOhPEQ6ruXqTQVeSi133X6NI1WWLWtmawVJK1JwozK +eIS9vL8mCKXOomZdB/aSCNphfQL+cngu1VKbkPf8Ixzu3iBiPYaxDwnW/Ljw8c8M +TCYerXDewAQiRcVLkz9IaPeI7EonRKzo7yNu5W3q6QVQgn0sqP7V+Jko8yhPkGfj +7S0A6l+dm1L9no/n9pTCEF4c9CRMyc5B5lrUxFkBKEPJDvrkw3CjoRVw9E82TIuv +6xjMbEAMIenB0d4oqCsR5NYvFn+/Pu77cUBTTPRu+AeUQmxLlV6K6+j/67IUHfQb +di4HIQAgdabImhYsr6LR2s1fhCpXDmb1kp61Vlf5byCybAjOWrkYjDwUzqePc/nj +x/miv8JtewOiZ3Po3d6aLhua4zRiDul5jKvgkdKgePmMZfPziwTAC3ExtDEgPYxP +t38lVvjTjiNzhGuuHqLfg9SRSGCYRBB3JH9ZY2sUNWAzgRKHPKPgDUlP7A3U8/cY +teN0zIr7K1eU4Ybe/9neBXoLcy/adX5Dus+7XLGC3sx4XHvq/i/6vIOX1hYIkjKB +kkpJWzUJmuVtWxOzenypB5LcHfsGdlizBRuhTeshRX2v7/EGk22mSsDGnFasAcfv +/76Bki4Zda1ZUgbn9+Auqe9XSFqfpMvhNpNe69nxb0RDtx32eiWckCZazmYQvDre +MEstIIhL7GM91KZ+o1R9kv+e3y0usBTEptQdyMLpc8EjLUxg126/EAj1KSjUUSOV +YvTG3B/AyaigrZD9mJjGPWEGgWkyQBzkVTIcAVQQLStnpKN6bxDTW0h6aU6/tf7z +0P2AXM5JBF4PVpe7ZMOyiPxTTULtOcffGABuYdj9rbfA/R5ERPFnx3KM7MRDQe/9 +AwC4Miz0VP3GhHoCxLl4gVyx6Sj504n3vWrxp+g86/MqDmWDO4FO/Bv4gZmHtJNJ +FnmwMDACkGFoo0TXZXq55G4612FggCPgUz+/OjBJ4cmmUG21VV6helPadGxr7s+8 +jKp1VamTAedqDUUrrJkzJBg3NgA8wc2OcH5Na3kr65tlk4PVN6Z9y/rvSksvlCGM +/vsYg8ShwlYk6ae1dd2F7h4JRRhLhh3oNdHTKl7dR4T8p9hLHh0xek3b1iyt5Fcm +hqkOjwFPNmjis57EWQvw+RJGH8SEMHYXoskrqLLdCXjFI9V/AArfLreipfATegwJ +yYvuDUTt3upMONKt75YPqg6ZbkN4p7tSzRkLvQtd2U9pVvIdHzdup8xv7oDNQQJa +IBrP411QB1VGCBVH382xIdqCEU+abhPPASN7/GMv99hoXxm8VdvI6yjQgA0lezdH +vqvuQ9UPXjoAjzAq3816z3ApD2yhrDWLuSLZqopS5URGjOytEprlINZTJ09cQWd2 +PmzqQ6drzqftp1SUF/chEUBc4W0vm7rRYhQw6WrKR+RbpM+vzxESrgN9qa4PHzxS +FqJMi1vyVG7OjsBBg+qbpNPyiyUUW9LCwg/YfZ+15zkQEX0rwyKzLPFHTlQV83Hl +wd741/ggO9VC7yQA3ugwQdXD+nlmILSze5IsUakJwL1qRV7rYyqjHaVyhVLh+X/c +9fO3Y9fsW72Yx9LgtG+AKJinAZfUbU8jDERplxKLc8VP5A3d6kE1o45AC+UIvsTA +eOK+ePmKup5IHxcIS2hG3ECEVkOHzl8Z7Gu7Sp6oA82IihW1aO7yc7vfME5iBfcB +iS8TeX40LDuIMB3xTge6tVuUOyAWqdMbKKvAMKRSRBSTUDMljFJIltkRY5yijT3c +Q6GUlEmeApTIqN69W4+XL6fOslQxWixpFyP7YUqlALSJklAnvE4qUhCysY/0Brlr +N9PCVgMKIWYJj8Nzm621eb1uRi8DwxxsDPrI9ga2wMyKOLIgfiFTAAqVznLl2oCE +E44f7SiVdrROMAd946djIHU4CQJIkahJVB3Jf966/k6BFlGRUxEtt9IImJMRJPsX +K9gsGu7kqYHfiCWSuf2z+rm9S8dPS4+7iK6ZeFMeHqPx+fmw4sHc24S8SlEN5dEN +nMQemKhgj441h4NiHbgcP2fygG8mEL9bdphc06WiDaau8KrYTk6mEV0rm0fhXc6p +7MkF/NXC/LsHtTHe0BjnybLBJN8EQLaJlj3mnye1uoEG2VK7AZQk2vGmTOT0OZHF +FWjGuXm6P3a/Ch/SBhG/RnlObe452BSv8AowBHV3NdfZ5HgeCYK4U4+yR8WagWfF +VHrmVCejvpPlwTtUTdjdtYYWgWwCexHl86mbU/Ah1s9YmTms6aTrJeBPeLrJGzHy +kAchYn3vX+TFoTakbahLuT5KwFUVB2CXP3lQwq6XFqot486KWLwtHc0mH9Im9wrz +M7RQZGSkxkWBoiHF3cSz30fzjKx9/uqiDU/hmTTcD4dtWf48rtKQn+6GFqwEMi3w +YB9VRzapVYWP9px+w7rnD+dHQnMKFKAb2uNiBI+LoNCbd0jQWRsQxNBe6cDYcAm5 +Zs0JMN3N1FrodMjkbB1zkL4S6VfrwBh/FQ5O36nLb3tUI2EwmDoa4+4ihjDsbycF +ANSi4nu4rEZtKRhWtVsVB+yelga8+Ljb8vUE+44nr8VLrMmBvYGHCCtYT09HB4FX +r01mCeMCffxQKeHALnnU3J1CUQT0QNxKNa968GdmOJd7mOaVMsufUc4MgYarEYV7 +4qllPrbZ0PRB8Z8bx++crdLjlLeHSWtqCxSBuk1qGnzAl8DJmTeC8x7HUqybCasq +21cLfjHO87yZ24hBqO8MrxHNawrFafMHxenq+XP3WDYc9CwKMA01JDvpjCEdsfIp +iiTDHEil9jlNcmEYH3i5gE6txpsNJwoIw8Rl/34P7e46Jy7GU93A4qaahJy6Kgyj +4S0d0lGyhS59zqAQdeeOC/8eFzDP2F+Cr13eVmYEfXZ29jA48hXQ+qjO1Vy4dTEA +ku0n6Venx2Vv8Nn96sz1qMmjtspQ6ZLMH11AQSE6JtpwiwEPOHxTMrHjDTIib9V2 +MjQlHgDUZbtTxtaK0B/wX33QfwH94AQCZKHZCwKX33GWAqSdkp951iVZvJeBBNAx +VozzKiK492GmbJlWkaxO2EVYqs3FOKU+YiFxVkbRFcQBKmZ/5TfsYWC0tBDFbx5l +4sVm3QGRUSJP9ByoX/N5+tSnrmSNhpd8kSdYDG7yOnRIgraM3xpfwmI0FP3zL1bT +PrCeVOWvzAJ+6lLKA9vohp9+WubASUODiBnR7gW42XbPLK96Rl8xXk8faDiv3VM7 +agMkjyl5WtzRpC2CTr0tTULN0brQeaUKjVqdjwvSISHXxmHabhL4dRlK0quX1+mR +KypKH4dcNZK2zMUR4F2U3tHiA8csqVcwBxevJ1vpAAPoB89seh/tx2T//+9ppFwO +t6yMIzvLf6hdAEYkBVuv0fDLSHD8uziAs6csRCcj7Vd1MIUjI/MHcQwTLobpGdb4 +UHlNVtsL+mJP3IyETWtK+/9azM4wm9Y8cED36bRjcuoh+MPAG+/lt4hUDeyUSa87 +fpdG8DMMnM+tKDTkJsxSzKah3SwWIcEatlJp49ZTG/dLeURTKmQ/Hes67n54cyvm +pBlNG6gdLVsIM8k9jGuunAn+MEO0k8Tfjc6u4n0658bCGnNBFYbRiGXPUSkAHH+u +AYZpiW9Y6s82F6l0W+HUyU1zh5omFeFUJ+9/Dp9dgLrk0lJz4RtUkhubXKuI6LM1 +ludjKdTp7Si7P/Cfnx2wIQ2ZsDcjeenrCtmd6CpOzWbui9VTkjKNkrotV3k6p62n +xo5Pa3UO5ZwnII8cx4B9ADK1MbNsJfelH5rtIetH+7LpY2j5M0jz5OQ1psbXB54s ++Fk+fQW2C5qqVTLKyXsXeFW+SSMm+9jZ60J01wxGFkIjPM4x2Gzti6WkLgtTsKmk +y3+dkaAUlbVOGXVb4MTyR9nsrbRZt/wo1gayPKlIPjvE7UvSqPs2IPyPVb3KrSlI +hKK8wZvMGuwIfpJvcyRtK/ba0fvVbSarBJXaGK7LzN+qknFj4QSmI3OS3pNqQqAO +7UHqdQ/CwXlUr+VwJ+59gIjkDEY6Il1WhblOusogZgGnqfZJyM4ycWQxQ8TCD82o +kTdA+hMkTnbM81gAGMJxYYLt49D+1TSsB0XKq0aOsvvUpZ0gEv5m+eVwwF8Ilz0n +GTAvj9r7P13o8Gqd6/fGNeh7wHtsqYkhuvxZX3EfTnjFTQna1sAGMtQZGiezHRRw +NBzsOdsEN5Zc/GHkE8pftuKFkPiWmEXtd/RmiMwqTcukm4kmFM5TCiusFk1gGJtt +2YCooIy3dX0molZ3+j/Ff+S/kvDZf97rr3EubmQ+v0Yj12Ad4+4FkEnzaETnlLPD +NyXKMQp21iYHYbX8w5TOz4F9tCvzO7EoqSSGEwmY6hS1akduLcijm0x1AF/e2Miy +k4pQyqj6/lQBmbnfyslWF90nILBknszARLM0HSHR7muYJ8yN5yh+i+FYGT+kym9+ +B4B6CcCvBoIagS93wmEAizf2y+dlF2fnFUzpxmtkaTP0Ya1bVL3WH2mdgUHctp3p +rwSmNI2Ljy1Jh7bvaJFe7QolE4WKyWCZMcUcEniCspcVm/u9NVUYS5atV8uqGpjl +iCZ4dAxz6B07lEnuHgPp6ofi6RveZ3nAS/6GcYzj/XY63cfgcfBos+FLGToCpHw6 +3A3xVZ+edlxzWc+38UvBKuZc+a/cwrtgHa6qrn+AakbvoUOmd96NyWA+YeJPBgqT +m9xo5hkkMAo1hreyqFkcKUGbWfcsL5RkHSTbt2heKBl82Y/aDUuyjIzNvtffNkS2 +BL03p1J9eqLRzy02gYL8e7+WpiuppFK/ir+MYvmu+/loxI17l8Uc+Ooi6tw0poNs +a0zSvqfrcbZ3y+rsu8VwXIEl6MU440XtYAcE2F+nUPRLHMBYup2CetwDEdJO5eb0 +r/3iO1DZtMWohB4E5e4Rbs38MWvEXpJdOyfLPTaixV72t1zuzaX8803X03BHsPfE +o9iZQ05ibd3ScQJoZrjaLW9Ojn671la7j3GgSozkUxE6g9GJBTOGevWdLW7VwL+n +ZIja1annSYqqS8GqfMsP11aUPYp86did2SoSMAUaypwV5AhCSjJjJUcGrte6b5Nh +BN99ywJ3feV/ERWloXhWZxccEkfFchrLXpJIqW2v2hwCXPS4+wfc2uu9cpLg2cZL +l8kBzS9Uwzafmx97b2qiTbz/N2sdxIHmMLdkLu7k+ywc38GIvzLnu1eKDculCrRK +cu95TAdrcuW1D3r2HlU0hVtEoz5T3T9CdiS8ydOqR4YOrqncuREUwenf4g7DQoje +Xa2yl6DlnelFLqMCktodD0zeIX2vfcEk08EYTxpalywDMm/n7D1Yzu0ZZRHuLgyx +lzFOb7/U/SuObh6TE2B7IfwVWaFiNDh4h/8PjHE5EH0EvsNxNf/8JnsaaczfK0lB +g6fy4vYhzgHz4Rufd3TgkUL4TL7zqR8HXgjW3BBWeXvjclYemsKN2crvDfY4n8lw +9OohE5CG/8xqVtV/pdLQtdyqZK1CXkjaSffADeEzfK333QkV142iUKyi5XRhIcAm +0S/8Kzngt5YizJTJb0YoEIBuoUvoMeFz7Er6tGuHYouJ63rkcmJR2X+9FEsXNXxY +u0tRWAvonG+a+BrSFiA9yZUrwRoXUUpxz9cB9IhOBu8GtU1LaMZ0n/aHkuXh2rFz +FmjiP0kxId8vbXEQ/JFu3aZ4WcS32WZavpwTVtVQsbxYTXxk5++AxfdTjXTOK3FO +eXX7esfRajqeaBqQx2alzqEkYrDeq06ekyf0LpKbdJPtV9z6EDOpabyFkZ/b5FuO +4wcwCPrY7JhTNyKyWOoRUWUWQjb9y2Q52oHjvUe8ueOO56ChBvSVCtQ2UrAdJ32A +sDAXfzmj+BddabFjI0ZByrMWBKrunScoTxoXFBi81zasctdf29VuLTivlQ2d5cXM +oPhJ5h+cV7+7SswBzvr3a5fwgnfTquGp6uL5nCuA0wBDtlJ6ytQSZG/4jBQZznhd +m2PHjLRq5eJXjAzBe0mFDQC2Et1sjgXnSKpL6VBzCzAH8emC6nJyucX0r6dBzeDT +FqpYjmrtpA1bbLLXTYxMT0klhzyKxJRONnBxqDgIDtDZkIE3kjL914VIqFYJ3J2L +br1gH1mPiG8WqFHpUicg6VoQAzh4V0I8kNjobJKxp54bHEmwkwMImTw+Ij7nAjsS +5Q3PIM0z260e2w3wvyurv+afBCoOLHHRAPFSvSt6/OGkgR+lK4QogS/Dq++xmjGD +k42hUFvbFYSUQfltccQ/xKc4nzuLdRugIDxdaj+bPntFdKRnDRmaOfdPo0QlGjGC +s5rt55dgTFsq5YN1Ptg0w0C7B4epImLCGFyXEcofY6+ZOgG/7jfCG0Oe0Zb4LmAs +UOrw27g4PdjvowdL0X/G60kkDot72+0LRxcQ8y7+eBCErNz6XxqKn9gEs0w2/c7n +g7SWTvNJvjQ+b10/fEZDo7Sq4/JSEc6NAc9tmHDHilVYYOV6PwBT7K8qNMocIL7h +RaCQwFyQwNtffD/gUc7jgGc7Pg/YkRpS+5Zy1hJCkEfns9S4CJjO986kMH5TF/KW +M0mHcgR9L717574z88HGh0Ziky1maKPc8ND2QRJcrXuE2t9oncHU43gVBQA5PbO4 +NnSK2U8GFzTCACx2IQ3oDOgCB4JeyslzV9YMBvT7MY/1vBWpR6/sBzmXWHGFqG6T +942lXhRNJAHKeTO1UhHy3r9LEQN9RGd79GKCsR/Zrbmk/rcCDqNh1wKblfzqIOIM +hcUbRP1crpttPclyOkxL0Ddlt+nPEWvqBYX2PHWqy4Sa8zNisrsXS+BdrToQP8AH +8/jONUjUuvFxmgqC766eJZeaRWvofCzWMDcL8h4pm/LMOnhlt3edTBLYytkdbQh6 +fXfdUGqAEwvsteyOxWM25CVTS7AANL37sjEiBL3UW20Kx80UK7xoQxFdGllIxjZX +XUXzoGQfAsmo709d3b7Am/kFLC6zojCxhfllx6wE1Z5TbVoQaFJa+edBsbrkRgXp +Rj64bQZ/yVZktG+XvETP95rWc/7PqYQ74Wck4y402EsvXk8tGHaQVdS657oOXlkl +/JSfCaN+4X7rQRm7Ui4IH5vQkO8eetPoOGrkIk708+aRHLzqJWjfccmH0RpKWMz6 +L4y9kz89WxgNhRoHOlFRZz9923m/I266a1Deo9yTg/xsm9hy4FWLgpIQhLDW3K8z +2NRwXpxiT4yusPKTcYDkaw9iQPJtXQm+Yw2H+K6VmREBFBSGoXkL8318liuQXCaa +OD8tJBrSyd/ZUmZU+C1aPONT5swdTtGeZNg/xIrLkxRl/iN3G0xwF6JvaR4F8ZMk +3FHsXInNrIn14TWhEEqYZ5NFZK09VPt/rhSKFVfmEtjzP4sU6m71XnycR06TMl1Z +yxLKNrdU2zV1m44SmoOnUkTEjFhSJrfXaOTB+XlaEyK6fcjJIMY9Ydk9kkoxrTqr +8aOp7yOYNZSIvD/BQTuDWNZE0b80H6yDPxD6vtwKTiJ/wqSlAtTNUclpyJ/K6m5t +R5RKoVbfonYYV7x+2RGQOiw3SRAgQr1HQ5c2Ji41GAXmX43GcfH0C8ISYkFyQrzI +L6bQD2aetFkGhOWQqBxMUn5psdhL+bS8Gk6KiZSWoih7sf13EMgykzyG1QYlynun +lGRmOgLi1B3dILWhuccQdiZeYCVOOTDLlwkilr7DJ/3hSum3CmiArwFfA0Qb2Cvh +BE9uTNcWzWL/ai7YhUuPOY/VqBz+Y4zQlt5j9FktOgWrmOHmdKW7OmRf6YKo0yaj +93/2mOEB7nzkRUOaiNQX+mCJIKsNoj7QWLqkEA98Cr9l5eNr2VS/Tw1JxZoVlnrt +XDhIwAmmR5hJuyBVofIVsJh1VphGe5y+/vNuUIeG8FcEUJkOM3wf85me/TmwqoVv +WXM3Ael6ZHR5Q2GU9SRZW/thtjLsD8d6vBJvlVtQ9mY3tXqTejfBWO/HWjeLMCYZ +ohapQC9bFgcLMPs8kVtO/fKGUyfKbt1uj6O765EzbTdR4xfmOgetYSeQYtEmKH0A +Us/SFH9+h/3zRumOEyZGr7cIOt13tXLkxU4rNA199g1oQpWslaRbAPCHEpFcbL/E +IWEeQ3RPVVXSxQvdBaQTYfJu2k2CoToFSaNX4PB3WNaEM8GiviIOC5jTm4tKri82 +ztCTBmlKOZS8OPSKVsyQsF9Pj3qhnMpCEHkwIqFTTzcwgwC6vpYPCl+oRJwSRedL +PCF6AGza8aSH6X/bsXn8UCIDFmf24nyV6hyyFtFzo/H23EYQCL1juZOIPWj3qlWk +kOToQD78vhXlGIRt5+wC+CutDIPU2rJASv5tP+bKK6PTmtQ+/KJOKUMzYjOz4qjP +39tmEI2w0tyyCxaObrsMEZyKJfwZLOLYTIA61rrOF2JLWzWduYhqSpU4FLZxZ1LN +WvYiMae37H1U2WwWTmd8qj0VgOE9RR+q4ZnHZP3tMrSs7CcSi5/QkmFlTyhJGTc/ +q2lwdbWzX3R/n5DO/G5mb+mg0mcLlGR1DxQ05o1DhdOXEbEvNFD2GeD5VOAttSn2 +hocwiWZ347ZzJTorXjiluJRD0nEzGfCyYlbOJVdvpbZzTxiFJNq01uPcWsfCrCNO +Fm00HYGdeQAowj1ZMF21anTQC4Pp+UIdBH3hBcVsrHizKHNVPFwwhvc4bnGPzbjL +//BUmA1DAxgOilZrQGENLoQ3Pwust9/lrjWi+ImEwycaj/aSx12LMwRWYSwb/1mI +kW2UNaVYiRRb/p/eoY2p50569LYoz8P68QW0cgJ/ZyaO6W3pevCD2/NrZsIrPg8O +/9kv3yomOuRV8ZA4Uncwp0AEwYrSA/UDgYWO81cqRL03qgQYcmtr622489i4n0SO +6GiVzsGI8QoFzr2baN1QE7yJCYXdOYB+yht2Fe4y2X5/8tSs89KnF6a2+kKou+PY +LdGjpdWTx08uoyYhy/meTuXFNw9l/VWum3FSJrGQlhnFZjhrdNXHsKy2xKbCs2ce +NvRE9meQeg4DcfVMgyBq3+b44aodPrdloUZWBs005A8Tn9IaIczsZmQF7ZtO6mwy +s19ya35cnn9vePxo3cskBmtR55Nuwm1RUDxkhxYbNbSVaacFJB8sqXnZYyv7VD56 +usTHTgoWrUTaoOeIxRNHZvI6p7jgJyHvQYVG+Mqn6UK6kWOXpDD8FQKyCxjGfWYY +6+teWewDavT01drwICJQldbhFEZ4M4MY/LNMsaF5P3xwTGKgoRVL2LxchHZ37q23 +505bVf7uCL/+sTr+bIPKXeW6VaT3wCTixwBYmP+Wb1wtJKrNqyh3W1Cc19e8xhIZ +RsxIh8IwBLQnDIC6MLHNZ8kAQRU2b9uaZ8sR1EY4Hdyugm9LKTheiC0nQ23ICsA/ +YzsiWsOBijPR/eCwYjASiecndDd6FLVigS7gBYJy6DJcDN/evRYX3k1DfXJdT7b3 +4BbFFcMhxqJo6ssLfE4uwSYYWkvB2ivNUTvSBIhGDbNFjyvNSGn2QnMfylOLBCGx +DUrMM93LtkSWGKEoy4TwciKB2kBtK7go/HwoygArh4VXwvfxJvCCnQ+kUPR6oFqG +OGs5yaMvwCNZ/E9TsidTLHUZP4AucOmq7Me/UanBlxqYB1PYDyu5H4syO+cd7mCt +pEPB+wUT+mqGSU4y1JXdVi6R7m8/4m+cr6dRcdig04Ey7OsgbdREESA1hfeniWJm +pf5JSh3a52DNug/Em30GrI+RGGc68fREGjE2PlybXsbt2rwaMimq1iyBXz6CiRT8 +gUBUruFT9o5XwinHe5NFe1tUw7bQOHHCG8cGyt+4PbgcgMizUNGL5Gjd4pJYA2CQ +Csie+HTI4Fq1THajsvfXx8wUcCbhPIRjDEnmf4Je3tHygmUvObXx1c0jjNdhkLPH +rRivcYgSSQVfp+2UbGm+n8SMu5iQfQ6aRJYHSYUDjaMXJOe+cZIQw/ApdaDKzMxR +RCMeBqcyYx6nXYQBYOVzJ9vfo68b11U0yNUxe/6q6lbl2GDOH8WjFGAGTfiE/vgj +NuKbwNF1TnDesqlVxzxmhoV5rQzODbfSsNTC0roWHJM2HXpQLcOhO0tQXij26e+5 +rTkXdq2a4BfPplyQres0GK4OHahRrUZHwUlG3cdJ6UG8eSzNdIUooKnL2Y03Ll2U +PLbRHnb9lK/R4s3I3utsFC3lwcJqjRuknN3IusAOz6uTRXrXRN/AUtJBrTe275xh +Z0tQuvLGvmgk9RMN8kfg7t5M0X3omnT62Ik4BdeNdl1z7gvE15HrpE2yt77MESIg +/wNDPYeRTdceu6HB9oq0WaSdH+HeJoT93RVcravbC7OS0gGkR6y8NLH5yhwII5k1 +UDPCEjpVnDtXIeDHZBDKbrljqhsryKZ6+Cyq/mErlxHTZ1j/c3ev3Gdi8BXjDvOz +kGZjLygfw5I0Ussw0aNjZcdqHyfkP27DZMlSV2OMr5c6UWtnRid8NRb5R5fFkA9a +SLHh6DXnHjLIgrFM7awF94a0gvB6j20Thm32UQJtAnC8Uh39XyzTDwuCHcbJBIXK +b5+3yXIpdn7bl+CgvunSDvcRVoE26SA20s6bL2Zu2TSbilMpFgXCxENbnK1SPZb+ +Jm16KROs7Mn4XNdEt/oG3xqQJocz67TS1pBiNHjPCJgnku7Mo8q+3w7q/Qqd/hJI +tMlmKaS3gIP48EZeBwc8AC1NwMvZpHdf9HcNlvyIjX9Fq/Z6NDfP9tXrWtMtZt1W ++ds4wJUQE7oEUCwyyw/w3lGLMhH4jw5nW7B7nOzM5+CrtJ5ifz7EBE4dDJZUjBO7 +Z7GNE9Z/YFUAfVTCzbZNNhPkdZ1qfc/42nPXAtpkajhcQMQlk/Ofhyia8G6o3hs9 +6WLNb2gl0jb0ne5+51ObifJkKhcWkQpejz2CzU2EnSO0r9wGlm1/R78YTfMiApQk +2+vXE2a6dVN0herCCATZ5Q9OdQVcDCyIyYaHmq7Q6VKuiTiod2eLeMrBQduRMXwx +3xbd7e+B/iaAw6vwMd8TIrIGoJBqS/I6bhSBZ5m/+R8CGb9QxfvqPpuF0aVaZRyj +6IvL0mu5aj6ulK03BmQ7WonQl2yi5iGcjwQk+j5kVN5sSm2fsQ5Wn34NNE7YaaY3 +X6GyMx3diN9KXpfNwOD9q25xu4hHe3HfNUwjyfcHs1KLFVpKYqd3ENIWjCxis0L+ +nScJLUyQbMxnaujjCalA9Wk0P0hsfubbWJWMAG9i0+CRvdPvTFwghmcvmOj7ocTM +coO6ljlUGufpdUUGuO7z4jo6/vqy2O1x4ynq2OTEpuNNjbn1cJqoOkfvbDmXDSTa +vd5i9rx1EPLQrgQJoDLGTwSswmSt5deAXSKG5+px4zsc8iqW++4JkspblUATMHRW +pImulCM0zzAJ1OlZNP6R+axA7ncraRILWVaINcqIKvyDC96ak3YnZgZP3Ig/FgdP +Co9lKZBa9PkF++MMQkE1rofX+a+O2xYV/M+jNdWAHsg7WgdshDfKGREiKhsdruLk +V0VavuioOQC5L1XybgewRFHNzkxXJKffzDdLV+3rI/GBvXltxsDuwZniUECuvp9F +t6+Zq8/3G6ZbzvljmckFyN0D6vrnthSW984dRWgnnNeYNgDmGyLCtctTaSStaio0 +AXASdDCNXdnj0MFxJVqZK9fhy9Ic7bbl172Nl9m9ljWR/VtYvM9FZopcSUtS82WC +6PK21OSC8+KANKrt1ZsMOvxaZGJxhPCk9w661FbC3VFDqQ2h6ilm06wX3QTVSYhB +VsZlkfUZvGPduWOPkgUt+6W/2XONOo9l0fuynZAGJLPiEuwp1Kaw3M8kbedji3fb +Q7ytecdTwHedtyZH9guH9JP8ni6EAnIqp+Dkr168Z8aSuvgERb8NAI8M8er57nIS +PBjBrTjUYcY/QE1/vzar/vQYqMJ7qxlPdLbDSv1dXpGnZl9lfT2xlJntdTeDhcsg +pqS4ykNG40IDgd/dKUrpSnraGWOFeIfHrrSmxkug2aYLSc1Qqu9DYJDShKyP5KHX +9tI0p4WLmgFDKXSCn8nqmMa3ADdTsJ2y9fKy+091BQ9ftFBKOOnXKiyrTUdrgiY3 +9heNOxO28OOo9v2+AVVd69mzD7ry8/xJ9XC6kw3hO+oGURAWhdsS1u8uvNzfKdH9 +j9trkgOQEjwT5jwczu69P36hrAPQ7H4EqmHtcIjsJUp69SIgWuF3yrJUrDM5br9/ +lOmPXDfWTLGl9Rcxx6iPKVhg3YHIt0mjQDAfrccFq/P8TDMb2y+oqEW+zBs8ZLH6 +5Ld2IUQ3JdnKrycvAsAInEuqYd1uig2haESNfsbY+dr2uxSjfC2PvHr7OwRTrN0q +Xoh3qJvI2x2zzJxgcB4BiqbKSt0XLYAFQ6iQ+8ojOWQGTmJqcETyf0OIMeKE9gJ5 +S46REKvhwqSJVO440soe26zTK3p36aR0rMGlWBmBUMcdCmTyALEstF7Sz5VFjjov +829zWAYsw/SS2M4xn7MXj5Xg04bfNytWjqwbbLyxBIwnhd+KQkZN4v+gliGVUR79 ++Iz8PzaavRUhmikNL01bAsO5Kc84/qv8QFLsPZnEGrYMOPvfOgVG22DCF7Ohswsv +UrjoD0uvQ2bQ5RyLMWG+hnTc9xlCOG7C8tRwxDaBd1U2FrUYll8NdZpMntiEXsXn +5pKw4aOj2fwSuKSMWjByRiRFXvvTWo9ufTF+giuJYXKNhxDnvm670yLsRTNSNZDi +ScuxdYZiJuPJT8EREeunEciAFjtAEcMTiP1/wD6tYhnd4rJdB0qJQeeSPVTOz+rX +WG9dG1MZdtoVsFR/fRklK0dMm/a7ESJfHPYK/92zoGZMMb8KC6Fie+C/6SCJOUMN +w1XDRagOB0UL/xoDb1ALegc1MJUScSUhw17CQC/QgX9wsyq7WmWCcIrnQ8h/AqF1 +BUiBMJL7FlWPNecyS6nVhk/9jwOgp7Yzk3AnF5Zfoey7E0QL0U9+zE1wd8Lt2ID2 ++KWj0Zpvudi7kYgt0PMeszZOFXjmwBBiOdUl43E2qDeTW0LvkFeg0WK7NWPug2mE +dhJ7MuJB0OC6gjXo6vPymxt0cG0bEa37UUAs1mmICgQKclyLXSwy2M6JzxS+OVMq +PJ2WBHfESUlysNvbYaXmTGLUCwm0whTrYr2WHSs8pCGroPCyPyLSakHU1sZxoMF0 +GZluzxe/DPW5fY4dxLOe3rUk4oXwUwrUH6LAAJB4Gpp824aWie6SIuWiPoFobNX6 +JSc/V5Yv08aHz7u0sceGQyil4obozQlhg6iO42qxrQfws6NDLMdqhSl09AVZRATa +sWj5WQkEJa7C5nRlPsf16hX+9yLRoJEpPGKeAQkRTnf35lxuGJq/IPMeAzm7yPzW +RyMewHUqqJpOkz0qq8fXy0oViTcReP1XjwfiW2HQWcjSeakG11CRgigPe1HxQ7eZ +HT/EJK/q740/wZeyjG5E7MD8jOSXo5INpiQziN/nrycmaFZNvMg6c7yoVJ9isWTt +mSoW7wbOkvAAIqZ1qYYKOCK1JreQAjl+dB0IPpkGWRBgHXweFnUBcb21NRafAR9G +5hFoizieyM5VKSYgOClKcQ4FPqqLZJqpYxIXm4ooDIdOsZpHP7D1zFjecFjADVnp +5WyOCeJd87x01iJh6Qy2nJpP4R+SLpsjdQgxx3zOUH9IdeGR2DdzAj+uYMN7dWr4 +/B1lFDQxjckqPdIryLNY2mwxSS/nTgfPxEPcS7HEGKtwwBleDgfqrcPQOIK1QMlq +o2zUCdHdxe9Lbpoj9m0qdL9yS8yLlPjDw7qxOaedw14ej9LdLjhF0Oce60tWY4e+ +R211li2yCxNeicJt3w89+CZJcqzXCNyzZoQFYyVWS48JNJAGqVrLKQjjcZ0PzsTl +kilynOBaXaDdXU6CDlQnQ4NGK4U94qh06ZrMR0fH+1zqxIU4LGdPYXAv+EGky1q9 +6f3t9N5h0Gjg5zlkx2jsOo8skfcKu9pD4lEl8KZJV3YHInzdzOnsgJPZnBjuHjBD +QM2aJ7xOlOXdIiTF93eYrT3uI6b0p7F67p0IBfezEDCwqBbcsiGkfs2jhFKP6Pch +0i9r7275eeeBPabqDW12J62pagt/c01PGKSjjHjl5JqgkZjfE5hZKEYNJC26cEN2 +GnUIfHKWX05IANVNOw8QZXZTjibK0sgKjdIbE/EByoojO+xylTcUw0R7u426orLv +AXipYYYH26I3tiEnNgpfTbkvN4E0UXuwzz5hD0csQdfR9ZoI3nRkgQ+B/wDwikKN +o8/MHUXBem1kgBkzjbx6sHny74wa37lyZbM6zmcnLds6MwFoLKtg1SmX4o17mmwZ +oOlcuzYDChILYFwlW6LLXJ2QkcLiE1G9ZW0pdkRAmjpIiwGJvUGa4npU0zOHjL/S +T143hpWtgGgs9h4fhoAqd03PH24UE1+zzZccbjK1dmq7PLKL0Esaomh5CmTN4AvV +MwBayG4QlU0WjkLimXYLb88dUkRxu4VcibyBVzjGQ77kW6isul4sVxDYYCjjOu+e +VVFfcXbOWeeSeRSgIsZXP/fLQ/Eoo/Jl75ApuaCUxAZUq1PQSqVL7F59XetfHdU7 +fh69pmrM5BxWITM6SooIOKAwMoWrPbN/PhwLPANk6hchAct6wfIVwEEVExobj5Rd +aZ/vu3IHjl7Y7tl6a9h3i7KYTW0pC/5KO26IhapwDd+J6tDGfK2h0JQVORH3xcRQ +NBpEI9+VgYw1mW+Nuae0mP9muf4m1+WfeOlKTsFPCJL7zKnf8y9EbKcOgBNR3D8P +7pQFlipG/L7nKt8+JGYFdU2H4TfC0R2Zkx7Hji5SbG8990DqLGFylaxbHPPpLxkc +so96fH+NurpxrN9U12yte932fK99yAZSMcRLeC3whoNO3b7TTwuOJj2rVbWPV7Wu +NPmgArYmtsekNHvqg8Ddgo1m6zZyNluhy+NCr9bOnRzD1Iso0OeiLxekOigsGOYy +HBtTgFrxVR7hf7QY2c+yq+VTEKrPodS7c4sdd41pA+JaXfXM7C7/J5UenKxMvlc1 +9sOmoe9t6/aZlwHqR47Q0TMjDLrJGVj0My11UHr1eIpwinyu31y99YQkHEcdUqtH +r6F+U2BKQ33+jBGWHY4CMEYpxI20GKg0SpnQZ44+kH181pygC+Mr0x+I0sPWS3cx +dYq5XRA8oMddbei8SGbmE53zoze2Xk5z6PkV7GpOP5weNrPhujtWVlCiOE5txGI8 +DA9a6g5lALdekaTPQaTdRnAtfMPXnZCxUwOK9WRiLANnM051Q9WOQVU1qOQ//MkP +CrPUG7SbKcabMTgsvtTp5UeE5+lXwCXnW8q9+Oddm7VQbYqGAuni7Q7YCoX8ZyR6 +PZu/1rKzwwMS4ZbHKsaHxz1X0/Wyk9spr/v4CDNr6mcN7DAI6lKQzzorWwVKXoSb +hOqXj3zJhtTmZsPoqNQKz/4UXxsyo+n3yXWkI+qjLTAxoUL0sDHIexpt548Esx/b +XoH/Jcf6z2YxZwzLP+Iu88OIE7nImUzHoQc8jq+Gym65p8BHWj9zSUHFz+RfM84E +3Oj/eHURw1B2cB+yWXfqK+eZPu8c5zr9OhH0ai+T83XP9Iv0cmmISekk9Uj939w8 +5GiOdwl4KH3u/OSdufKiG+4tQKW52523Trc73c8GkhBmWrDhxGPo2x+/5koH954u +0noPuCEd3mrpHfNwgzsnmzy7DxaExjYQvOpP4lngg4D7zEIhOiFiSn+cXRGVOe6n +ErpX9Klh31PuTySADEuPhv+h0x8YJ/NfsY2OKl2DeqOk9cq9LehXW+Nhk8JUdILu +t0JsLmd+VAljjBAbbMUUaWRDyu/LM56662viveYf20+eFK2o+ernpVEb5zXcOe0i +fLmz9yf6XKSGZfFEixNwb6Qw2sRpf902isqzhZuxaaBuoerxPunE69cCkn8LvZ2J +2JalQPcSCHF1Zxkkj4axrtEPrNZ9bZwb1nmaoP3QcariwKFiCJeEnkg8o1wSz7fI +gjHkUzNFylc2nvyh/zssT+y4h92A+MeP+1Yo6DB3RalMNd4EEMO/CLBnmKaUOxEo +3yTtp9qM/s7PQbta7qBNEICeoQcD5OZjHGET5yZEzvegasHBxdgGcBEhHaJ7sFfq +zudUk+sb5m/7K71+zq7/c+BCKoOzVHveSVcTJn6uKNa+bmp7mlEliCV9JEFIOQ94 +ghsN2BXhS0UndV6XalVUOtmQLs0XAQ+UtqhlbAvFLsuldOkOhALfGgkrwVJ8mqIV +6YG1+RE4gxcsTkJpCFXU+2US8F6nSc40ZYiznRWK2YV4ojvMAORZXNZK25GmMQ5E +45JNiSg5fhwdIp4AUvbmEGgvs4EWFw4DSB+OeZGR6lGKHYyIO9tpOSRGB/xHCO8+ +r69JYQcibztoE9uetxXV8HgWnbmQiOXniG5bbq3/CIBm5Oq49aLEEgJGaWGWkbAv +JW9ZRNepqymFlbaVX16O8DXmJix9CQV3CPl9uRKwLUmThGXZNaBzTtoIcGzu3D2F +wpRXO9khChf0Nk+MwAUePPr3Mb8/sjE0RQqxL5XQoXk5AW6YaJXXgtvnvkVVBV+Q +UQq2inMbmy37lX1Crn20AtH20fSKc85jg3Wzf4XcrDgTyMemkiOwSCew8EBoQjtp +iFEt9q/h8/lVAlBappkpw9XgqkmQBdKgtxsty8BMVGzm7taoq55XN3GygSAvCEUR +/5Wk7gRHj2QSevCCQ6UwSdT6K0Pugpe2sYN8spICK3/k6kvGPs9syK5NPhnw+NaY +XS0V4DVo08TtaHR3Rg5k3n7sRAiEkNqbcPbA7J/A30pk967yYN6nIR6Z1mRs5iD4 +JZXzSzA/s8fgyObDdI0Y+jxIrq1Io0G00TN7atHjuYAq3GDX8ia6Gxwrg9vnxCJf +3eNliC9e3CGhpf9ihNia2B2Q9U3jcYXSLkkpNQ7roGeLB5c/l1ZUb3r8bf3k1qWr +xPb5b8asZ/3Rh0gNXpuN8n7E9GGWXAji6oDNL1n0ZG/qhJfJZXB/59eQfAfY5nnu +gqGKWivbcSeC2btxvMw20IpkyH3Y4cP/ljSgeebKOeVBpfJaUbL13Qr96giNN5a8 +fLy4zRbrGs8f5Du0d7dj0gvPT8LKX8E6iRQIC3FDCpabKZE12YyH4XYDizL8Mxt8 +8rn9FWmK1B17YMW/Sf/VqSEBStJe5uAoHuDlMM1SCO/RhnYZd/dLR7sIj8K4Nu+K +Cfd1n2LuscJJc1nSeN5VS9W65LwW2t9P4Dg7SOe6eU2uMPjh11cqTb5K5vTIZTki +RPmnVwy2ilnXp6JjQEZ7KROwulZgBnQxTpvuKfGfl8gxlHnQcTXlL/dQ9lXP+uQE +caH60bsLY6uW29MRJCLzLHQH2bMYrxrWlOMW0o8Ssclx4C32vaElAwsbYWg859Y9 +po5gJXcSgXk2eG4LkbPwnR4ANlM/FHBiccbDoivi1jxN5Tz6v+kGFV01nemckcXs +9QtpFuM2ynIryglQX0iTzslq9gEa6T0ujeOP1YJbUOysC7klaSVHAKeB0tpwr3Sl +bzlbJbFqAGJ6+xA3EOGJDsF1Non6PYNvRfiTn0BSHWFdaKAhqTqtHNnlPOHWvQP2 +58LdgwtcDFOCxRzc7ywtVJ6C/9ACH0XvP5OwNGmD/aOruPng2Z0QUH5HMIXBAIIA +6tLkQNs14Dr4NJbUzjAq+PT78bMDC7Y1sjIvyvVKm7cNJzC45V+hyTlTspT+DX8p +OYS3gWC/92/jnKZilR/t8fvK0KLUTcO3lOu/T3px6lUGADB9IkH69H6ZStG44uIL +2WFtDEQDHmg1oDRNs721j93fIZyngtsKdj2+RZx9e7lKRn0in9p5rX3JrvOXKCua +61N/F7c12KrAyf3R/xG67kNOM85WLMCrcwWaUok5hb8hfvvuWikPZjTKeuziRdHf +Bs70gB10D8IHiu04KGbfjz0BWkjmAuEYE15MotFyNwufcCgN75zmaYhFndbPuIqq +R6mHs+p07KAyGVJKj+k7PB0TaGXOEmpNEpbV5lcZxu17XcVBUilmwlCqlBT5PS9K +RQd0zX1KF3VzfU2M5AuZvj1CjGX7Auz2dHwoJDP2yXtnIyrJZ8jxwZtUllUcE/MZ +hPPN+8JKtLe+nrUBkIV9JmnPioPwVVoMpowY28SFemz2t8Cude0Iq6ApKlN/r4wp +HYyDvFCFVKM8fm3aFB7djsN7X35+D83agQkmHMX96iyH6xJ4feNWyGBYeGe5NjcI +1FvwqkjPLId12FNis8MeglsdnejUHyHUMwMZ0RnpC/8h9uVSpWcIf9hPAp4sxnKn +64cxn3GlWlIF6SepiplTSJtP84VypV4Z2XuyCykGwRQY9CBOaRpzMxOu3SGmJ7CT +UZOLYhph/FOXNHbzZAgDc2uMH3ZXvlfuNYwyVmL56LONiYMopy0iECkCcY26J9J7 +2+/pLAHH6U5EuIcmiZWY7yH+ucqb2Dd5SX6bKoQpv82C9riYmGc6fZ71aA4pzTNb +XqTquRRwnpjWv746VfsaA+3NK1f5o8sHIRB/otX0lgSmY1RId6CktSg2ZXl9DnBM +uOrIlerIgvXeBKzUQn3LDglX/L1Y2tMrTmOy/gOzeJV3v7Shd7ZoicKa8+LiV4M/ +e74Psh4EkIATCcZ4bNbOenf450oIxPess5SluENFksFmgH+8fqip25glNQsa3TF+ +djSpjKL2JrYtKP/V9ntXiDJnBxRYxLE2GyHssc5hQGaTyU3kCOBSucjTu4gutIEt +uWETBbBzkp6MqTDuLK0/IkA1cVIOC5dW1D92sPfZlTn1zRobdx2rc4d5Zr6iiNMZ +6zkSu6Z74aijhPEgCLABFhzEUfxSUEdqM4IFbxkCCX9zb/ovzr3Jd+GnI/jnspHG +HLsGguynJsbPQ+a44PifdWStwfFK+5p0lJXnDN0icwGLkdciHwVQv56mrfq0pvMh +LUleyzD15F+iUBoLy3IxoaxzIvJG/CbIqnzKYxY7kL+gi8SeV4vh0votgxI4N8dl +w/G4ER3qmHXuM1EP0rFBnExLfWSa9RLYwdf2e5h+y3ytPmqEza2PPEWY0LKGsz02 +VHP5Fe7JVY9466rLk/c6h9HSFQbfcApeHfZB6I8M35Wa/I0UW/ooap4vePS/YOz/ +qyCHQbrXS8Ah9VUOTvX0+yzwoODiWnCmrg1YMyWsF+6tgYN+OUgNaH4KKODnwNzy ++3BwzJDtC581fS8S3nqIrrm6JtFEWSoXw8X2AAYHmYG1GaEeo88SbMxmvSsv09a6 +xT7+dJdDoVBSLUqw1dYnySzh+XQ7V88fpnMwqc9kza6+66+9QPRBTVcOoYXe0zVR +ZvFKBNTNBeCZWg14hjl+xX/VEZZp0Fu71ZvaGGYNr45wRBTY0vy6zVCfLsrxWHNA +0igx70kOztZ65HQf97lmFmSAvSisiXye/9pK+2vst+bJopEUiouz2KQUnbRsuC/n +x1MzqgJFjX44byGLqc84NMSvNh7dtPsVwQCci/XnHZ0rm1uJVAajz38k4Grg7EWi +mm1UoeFn7Onxpkbny2FG0qBDvaFfthPRkxry3U5QEaLgh/2fQi4ZHoln/HafVCVn +Gpd+/IAPnNJjGnTTCOAyKXiuPWuirNZwEfhVP7bHhZTTA70p0W0L+sDIq/9PIVDt +1kK6X7km76itX1YJDHbVNQcaMVwamLJi3gdQUV3SJz2dt7el6HoHZfbt7cxvkAG+ +uO1CUKR5PVUO3Z7C5SyV159hCb23rmUlGHxDHqmcZMIDLz6Y1MDTAShblo7SE/8e +X0lvGGwcORHjGV0QYqYwhvFcd6o3xuhrThZu7gtQsDlK+4UC5ajIm0Ns8A5AnfvH +DbD6Bz0yP/FoEan3Yz9ZJrovvR1C+MPrSJyeWLTp1qByuaMLw13QqCLsY/IfXSCK +uM1VH6/eT2wOoaeeFILk+CwiK8VPEEYYOZPM+2agjq+6H21syin5uqD/7lwJZpl8 +MwkQP7vxO+qEXGkwZ+V++IX6UlP5ZWCjGNoYdGvn5wy5ATbwWr9ilrVpE+7eef1T +6my1j/1E08KUkFwlm7/bwoPcyYd1kbykzLJJo/yStiAsf7BomIFZWjIvS8xx8x4C +NJdGwC+4DjxDvO3OC/eZ+OAL67zKUcYwMLCqJeUGf6I5jkqrdqMbH6D7GWXU6tnH +TZXxT9ESQFv8VEcLbtkoxbP7UeFX3bPLqggXxQ7FJcpAOHjvKt78kq7h+omJjLqb +662sa+ayMi9is3m7NKnJHzoUrhsLIbxPgU/9xc0YjrNwzmBVtMWzWSCUS0Y67j+x +gEQMpYrB0X4nAU2DD6JiR1N9p3/fCPmjRLc2FWBbZTWbjM3Ah5xO3xNCnkOQtu4Y +S9HaWJBdBpE5dB/Ldh85yNa4WSF9vkgsfHDsC/LKIFyJPVan4jyuKQf2RxkfsUOH +RjnPmwQTcZ4GrdeT3mL4w9o0XqEYifyo4StcjqVQ3nE1Sem01v3YTRNSzkm67djE +k3PY/VZiGLdLsE1GV+BF8/sD3onHwMQE59W9tA7+zq4KJzjTa3/j+F9FyhrQLwLX +Lt6rRwCwWNXaN7bIkSCcJLdNQgyQNSB8YjDXeuw+UmTsHq/tpylb9uSPUTeWxTBI +rEHkIgNhWAGis6p2YpU5ggXBlpeS+Fk4bA1I/aCs8TJs9IXKrE2BPpNon3YE6AgR +MoBFpbnXcD4qm5H9MoJox154TchtQM5VXJaaxXhbUWaPFGcbqJg0HtWNpC3Grdvj +10ctFoFLe+VqPznrAsF5E7oc3S+zjwIQZB2wwLATMP2zLJq5vQg0WerV05oENKrb +PKO7q9cPvqocR0wdN+/27er4o5ciuiGB4P6LjGYgLhR92E8QCB5o6GJ68YFeLzNY +KPU+jktFw21FNN66vpxoXk+tZUFSVyPY5TylifThaw8l8BIyRRzfPXEBimZs2zBV +GeTvQTEMMPkB7uPlDUjaaQpx1LMR+z73d/oH0WNq+a8zrvJ9T2w0lkD4oSHm8a/X +4ysQG7+q6fik0r7AQ8tbOGhD1XpjtRzW7Bq93fB0chzS47XiULU/JVI67N1HLLTq +chP2SNxDy3z63hxsOQ10rcDfihbUinJBhFGHOm1BKoA0lEdyU3vajGBEVyYg6MXe +b1wQqe/4h3VY1WLlRx+2l81myYcOG9XE4javr4UKmyn/irq9pBvbQtPf6x0J51x5 +xXy1f5Qh3WPdkBgHKT4mIfoIprUadsQjEiKmrLs7WIAoQjN//+Kx/WE6vgXR6CY+ +jT1iWXb9UGw35uWxMx+v3IVDXlKlujpV/C46U63nO3k/1nJ07mTmjcyYtMKJrpZu +NmElWvohMZV/PxckbNrJyBppLnzu8IIX/PnTesn7ySHaySwbGl+a2n8wRiTZlEnK +kA6fyIOU+szs+lzVDr9AdhMbXaey3WsW04FJh5lSTwu4U66bVehbVI6DTLfu0341 +6I+DJ5BdXrX8dbVFgnAEoAWyZMtAHkhcnM0X4iABGApQ7FoYtfRDiNDdyBt52fca +ZIxdzZH/3M8n9s2xuGTJcAWMXQECpo7X79f+erjeaECsWGBhTIyyMc3OK/o3DvXG +Z2Rt6kYcUvqyY9OUvxPnKcPi84E4FlGZiSxIvJ2digakgNkWFr1zeWcjOrsimBqR +37s7Yin5fJ5W0CseD6hLEzNMV9gfB2ApBxMxAbYYire7c1zZKkChEVB3wEJY3J+M ++OeCbn8kNHObLzpFnE9/ikq31D8oHiIqx7ehrRsCapakJGL1Pg5VlsJTn44V1VAR +HRPfHfD54uTWl3YWReRpUIdJb8TMeIPBgyA1GyP9L7afjGMzGeiHCKRegAW+1aNd +gLdLGHHszX14vUf9sgFo0J05lP1VwTWhUzzR0xJCKBDiaLKWGyjXzysnga+wWs+B +rWu8VBtRgQUGV0Wvsct3RAlsayysiYSS0iELLwtolJP9NH4eOcCwqP5DzZCS+xll +kcUO1W25DjcOXiCg6xX5ZfSLYvXti5ETO2EyA8FdWShkkUosgNFseO1dBunMHnQ4 +h1Ez1mZ6jJFKmmXjUXnfG/QieDRcDvgxRHCnArjCCEN+RHWC4aGxiyP68xhF87di +znTnLYaYOfggl5p3KfceP6gtURHScH9/0Hll4cfBuWNG+wZ2SoVDBUpbnb6t6Kat +h0dhJ6Jy+hsbsXgKKsvyvz1nucBdcuPRJcjJHttt+g8nhNCRfJLzwfMkNMg2fBXG +Nx41lBWdXJ7FEvJujbNd8bVsMkMYx5lgRdds+Pbd5iVCjBidD93TIPG1WxYxWxzG +pN3T6RAc492DlCcbco/AxepbMkvKnSjgIOUQoUJ7i0jUvVwd7aVzMAs1AbADdz2a +hfxc77SMcnXgg+g1MU2w+gg9fW0KUT/Up1SWmNjljEOftl8fZH0IeBgUqUKDiwDl +QxhEBPjoBBAD8lhF/ObEQq6e7FpapyDwd9mRw4DUzCl2HdrCbQy5nI7VlQlwgHpB +A1Q9Ked5/m/h9boVFYo2XQwBjzerEOuggnutazSrjzu9kUPZApBHIPEpzfmCD2VR +Yx0A7eh+/T5ZBvHr6LAe5bV0jsaUKVruYz7iIiza2u7R/01S9ZBlT3F+ud/eJ1hF +BW+thHscsc1VkDFiw7YJodEfqbX4BcGktljZZjuOMgjunnVVKplgCn7XxvyKnpfQ +VJ4PACCuYUQmQcJhHUrguFWZT46+IYcP2ZDUwb7lvSc7bHwcznybzpgsjhpG+nUM +Fro6xNRhCmC5Rqx9wKYXPeKuHxZpT31csfvrhcCeQXfq4gDIGTVr0ElcGkV0T/Mt +PVKTkwD0B1qj/bqG61lG+C5+lmjt5QV0Qk/mkTqie0uATcK2A6GXzZZSsO5IsbSB +kPPvR9CZF6gD3y6GH2idlEIBvuV4y1SJd2O4oHkC6td3yq4rCD+DWjTqK76vgmSd +EbL/0KOaz6MMtr2ZduGGK5V/YDYswZAYKOraZOoEzik+cj2Y6NaIdt6sFBPruWUv +CHk3zmsbAQwM9KUqScC6ntHSJ/UGjMCcx+MCVzrZ4iCvAKBUGu8AA5s62Y9CJQ20 +2kAEAF49XR3KwC4iXiG7YwyMTUwjcQZJdn6O20TjL1Fn6LOxPtwlzOrwa1qvm5h1 +WMGfVTVaqms+k6H6sdsPyebPLDsxQreKIQKMztKjAx6XWAnJ9R79mk5aekqW7HA/ +NL0C/ItJG/f0tx3ycxa8FCNU3RlJ+7ghZ4qSgmdQXsoKBmMek0Tze7Wq5yZ/nldY +sRp8cgH/1yQ0OYZj/oHJwKQAaR/KqbUAC96ADMDzdwWO/8DOAYqz5XDpEnFZWKlx +927pMNbh7MfRST2Vu9hA/v8iU+F9eWwNN8Al/qxjzw3Qbf2XdD+YmP4PhULPskBC +DUAmmNuv59EuiYczU8M+Gf/Hk4aymvhdmrw7aO590taKTipTdc4I1GQRKDFSkMcw +gZqkWN93ICsKH0lOnBzWFNUr6JqqUoRPk5Qo5dwuniPBq6eJEUnsUrKkxU6lgEpW +nwV5dzWKjeKKoq627PXSX3riLwywdnNAWnCTV1GO4z5ViVo29v/SVuzH3I3Xjwqc +6+LqAdG7xSkxgLiiam1lzWr1YNJejB4sUNgjfEw0DYWK7cFeOq2ZgiewvTeaWDhY +rKlaPTfM3ewRi97axpUEQeqjaIJ1YxGWiJsZ1DF+cYtLIrAO/ZNorZDIQvwd0lFD +QfI6F816+SvexN80kiqJkdpyD5oUgeFX0GJTqKvRxMOr0LEqLyOQTnrZ47fQah3U +nr4VCZqH181juyO+rnZ44c9pATJYMH2Nqh9lN+ZjBaxbVZm8hZlGRMntp90977ue +4D8GElOFx6pij6e4o2xCze4EkYGQC5Z9Sq20wgtJfAVssifiwiVyNVuVaotJOjFH +gt8lzy/nyScz0uUIXuveeoyEhInlNDYNtJfZLNHnO556tVWx7pDSqOYtyHndhFHa +3He7vd1yDsiUB+HWZWhbxmZE/KPtKkxFsF/SZdDKrMadQmE1HmbSj2/Zw5n4DDhg +XIWKKjnQOEOnMVdvzCMcG1DID1qLSe7lyrYoRlwOWFWo/GZ9NHlBiIOnFGz9Z3dm +9fPpA5kuSmwRJGSHG2K8G4NychOgS+CQVQZKHqNjvQsJ5BVUkW2zU5Z+wDAhOD78 +TgZ3nfr0eC+8zWVxQy65cKtnENgwChbm2Fon+IiBW0oDhGQaAZqKfPu/BNos/V1L +Ih/esJdYx62InHezV+pBih29dj8vZrqp1MYXfNHm/k8c3S//qHGIHxeJDMetpCap +EZBS4nVzR88+kpRrO+c8rwT9I2Ns7a2yzy2vJALC9grpWrmx/qwvffn5pbtZnqoh +/PGsQ1zHOjs/i9fSQBdxGBHm4fJL4XL3Xa8W9q4Y+4RHvZKDJoJEjKj7NXR+E9W6 +11sDdPt9YHxTYc44g2wO/PKmqSEU3aTkQurojldInL4gZK0ocNQTOo1Q+06KrKjh +C6NOBHrlbBCnIQvq4msIA2WWa6lwEWCDpCdJSCA1wb8IZnrlZl/xxupLzS3AGHLK +bpmCeINTffM28SwVHtd/ULYKE/O5d+KQz5tm9WJiBNQnSJXMxi/Dmd1F2Ev3XtQE +Bw5/mt3A4m3EUmfL13OKBF9qd4PPfmVkW6X8ZdypIxQL+fLXvosBQcmIC5gfFaVG +9MvVlvNQEPBsZTR/FSUdz4bKrurrvv3ALWsTUuy69qK0PeYvZ5ZkAzpwf9fudfrI +xNe4Jh468K4371SW0VwaMBjIlXHhGXDpP4L5Qv1WBxpvcFoawZyDcmVgG5aNUM29 +4NHKbneABA2ErvqeeK5oAxw1NlujfSS//kyo/FDRfropNGEcns98X6In7u5PfJcG +lff+jmTqZxtyU4X80jpH4PDSBPLHpdAe4iPJo+0hto9Q8h3reBZubFmxxWqj5Dke +OsvOPw38BSu+FtWIsH+XMrofO6cHmTA834AuKlC67sLR9PXtwQQBKfHF6X3Y/D/o +U28MfO2N+3ihl7o9u13GbiYvjy+BQ2zW6kfCEoOA7aayWCYHSZ1B3clKpgazXX/U +WAzfe3JYt0G+H5BT01iOlvicNhDX2hsSr46rh0m3yx07p1Qtvv7YE3vNad5PuAJD +CnpxvAwbrE9zvc/KXOJ+wsQ3GW6xguhxuHleMnGiGzdRpBSQHV8RnORy7rgYycT2 +oAPt1zg6qZVINm7g++Vw5r0A02puDeajY62v4mZrsueAJh0cOs7qtJeKc/9fbvjX +2tLYurGQfb0z96cZ8MGeQK0rBQ1kwuwCOKCbvbVYoPFRbxBXMN10AFdST5kuwhY6 +tjA3JY4nhJz4isu2JM2Jdjens4nArgVlqx1lfBy1kF3BpugHUbfUVjGrTn2i1pud +LP8OnsM+Woce7xpx/nN+5O5L3YoXTQtCrU6uEU4FV2QBzJwc43rtPTLxWITpZ86x +cdEgijB/dBZwriitT1FZ06JJKrnfMPs3lUVMNGEWFPLtIDWGLbvZDwaqeLf48KOK +QDgOTwkTaiYPg0p/BtxO/5jfPCL8OGPFde4arjVmvhTHgBNpyCk5N3JxsJirPXhM +cSf07W5ImsW4ycfWW3lkMCQOf4x+A3xxIg/1bc3uyB/OyyZTkSngo1PIp7Z+ckFA +A0usoZWT5RamDbhgk8JvzKFCrE2sEN58cseB7wzll06QphoUAsAAvKGPoZW9mDtE +EWTM8jQoNpiDZrk3GL1B2YxiekKeeJqCgaNgB49J9ST4eq7DKQhcD5CWCFtjzP4k +MNhtTPabQ/CQ67vppSDHPUomLtZIKmAN8nlfuCukki+q1I9FIZxXBYyYJgw2kHVs +EtcgFHU+8/AgHusM+H2Yp4zwl4Pqqax708z4NUOC38B1l7ybLCoD4bge3Oo/R6c3 +BctjDSKmOx0M0bQQW65T9GzF+T8lhlQbKM10kvWSwlqwIglW6EpfwU4WYBhLfav9 +RVS0WwYbJrrGPnmCwrc8BYodXAf/pgDI7jG3ias8ejy9rADU9C9vM/dOlN3FhkfO +do/q4CyvJ0cP/PGUUbrN88dOwqPGcDHCmMun0LYVNmPXcCDSpaeqIpVYEkBQ1P3s +6tiOJSeZ4vOr1Ik3XgnO/EPxOaHoVCRavYhunDeTnQvWDIkDENcHm/1uBACMdjMN +EKwg6/31oYd6E/GtK6SO447PVnP8tWLeyXMl3P9+Dx0NXqWB14CRm/pKV/x3wlIw +zRH0fudu3/SstntRMBCJATLuLqF9Wd4583XjyitFwoWvn3STgLqejfQ8oNEQ7x23 +tg8PGjmtr6MmUmxPXBHZ/sh2lpGGGcQi8oOKHZTCYMHg7FR+j0cwi9FPAoXrwkzS +G+Ww01jZuTLbwWI36D+1JnO/0IBcfWJTTsN1y1Acs1WidjSuhicZMYrQ/176M8mr +6CC5ZrIUWQ0jYHEwsllX5mxYYZq4N1+8F27++ip1Hll8FVjL1zRV/f197syKass9 +QlkVRiTE3Pdq8oHWQc8fea53J9kttWxxEJ4bIOZLLqgvNwRJysQOM6i90GcW6Fyd +eO/+FLeWGU9SowQP2w81rzGyRP2YGeOddeG4Buoz/PSa6VusqlAip+0LoS78leHh +pVy2tnKw4lVIjYJBQ8GQSvHF0Yc3PaZWdFGgh/NCaOj5oGrHap8jcogyIkCQu+i+ +A1e0Q6gUV6C3IEhZ++AM7RJ16YwHeusHk/Z7tD9iApjZsDojxEiHpYdGm8pQxsAJ +l7TkcyZnYqWHuoBSawd/y8pYW/sORxXNsJwJnE1f/QBnkeDWuTzWi2OIqJJkNsHu +ywoxSt7SwuUwFPd5UhK1uzNMoHTvQAWfyuiLe/a9CPijWFitzFXx+goAIJvIWXIR +uaLN1roh2v/pwiWuAief2iJt8gmzvy0r21i4J6O1oByazmkyP4IwP1njwP/Sq0pU +nl16s/npjZ7xWraSdGH152xfkFWSaUUaHS5msyNVDoVVOOzKKxnpbvjK4U0s5ZGZ +AT5+aQEm8RB+YNJYaGlI8uAaSuzEb7psEHBVR1xjXnYjsOrxIrahaKpLughKAYZk +X1Bu2bMU4XZGCOAzA2LUIgnATzqmw02IejINR2yKpzM9M41hnyQhGqH4wSgUiqYf +ASJO7oRdJeg+UgvZijHkQxaNVg4LK4lgp9aAyLhz2VqjZKjU1jZkEnrJB97Ix8wC +6SPKY/GLBWwQBh4D7a4+PNUTBEZqzbQQ5VBJFPlY6uElhDiZVGA1p9vXKzLbwSFx +r0rzYQFngU6s/0DuIzoF2DnSSTkiVH0z9Ys36MLBdnDShwqLpeO30J7422suQz8K +fZoANuFkeYDjJBddqrkUNjYnMf87j68jLLxsHZkets4Y6WYrBYnji0wUNl8/yfx1 +ZjlmST2Tc6tV0SwIqZRmH+u1Eb3UYZLfW+EZFbVVk+f7Tcc0enMggVeW2vBmhumM +Nt7Etnj23lphFLDkbssB9zujRH5fl3gOU0jGyFBtFRL2NECMMGbvNB2DiSsIYVXH +YdqGyT8bc417ntFKKJtdQRdSSCseS3m50D0AHHQU0vMXqijsJ3q24OxeIlzJ0XH3 +OhfG44Iuq7ttF3P+4GwyuleQiK7gVGHbyoCUPsgI9impGg9zf+7QV06O2mus4vF7 +Oz4CCv2T3cHZCRcos5cyJXLs6ZN+7PWbffwhYeiHi41zRPN05VHizkdPv6MtFzaR +P/P147zHLheBbvjqtdiGDM5badD63yicQY4aP97Y43gXWy8KGYapI0KPfddHrWss +XajQ11j1Pz1IjDizbzr8NzrpE9KnVDYeIEDcyyHy1Oo3JLLoIDT78KDg7e1hnXh7 +tK8+5L0+l0o7sVNV9mmgtSPhr8AsDrwN9qdXR7BMlyVR99yDg88VYC7DWGwdjo7g +innelBaprVIE5Vw6EO4fXutwIWP44ndM6EuYZNX3zaJjFcUpPBC9hd1Xn4ZOINGH +cdo1awc/pw62z98ntMrOTQ1YC8HEPYPbi/re7KETvbwc/xQ5I+a9y0IL6BbvU3cl +QytCnzFi0wDlR+Jj+DTHN+PZoW6Fax0QT6zydbS+UzhWDKtyVbDKfBLuoA7j05CL +HTzF8B1XWDG4+gCmcmOPqg0HgBAkBkhRJCXAqEjz0cZPoV6YDbo7v5tA4IurRDw7 +4EyzhbsSA+KLc5HCtJx4VDxpoYPJStA8BhshX8J+jwilaUeZ2SFPoF7DUwi9xfnL +4p5jRfKWIvlpKBraqd1iXFUDW5gqLKi62QDVkWKOf+GiWZXKnDoM+vt9Ue3O2398 +az/T/+PDClDa0+WPbP4LdoiGkKXczchx5Wimsn9rl8n6EblONGPnMZH5uC6fTE4r +ayLJmQSVgu6Wrc5VTUza8cFKMZl3FacMu+GaJKnIthBEiqkWPxf8xUkYzbIOAz8m +8PJWor6FLEy7uqzxKIiDiQa5ixBG8hL1edDKOnHaGOn8KH8e6QXFPFpKxRrzY5n2 +3STGMmSAeegL81MMZ9kiIeWogZ2q7oAJtb5OAv3jpV+igtrFyKE51D7xgoD3jcJq +uxJ4d/l77bH0Bp0xSlXi3Oy3eGIHsbCdSJmFKSO6Z3HfbwHqklu5Q53utTajWGai +v1iHhdrhHs+nbDwCuc9DBjvg2A2VxAh65Ckt34hTh2/RJXq43SuAXbcrDjjdK4Ay +hoTvmeT/TazN9GEfVkPuiLj2KhNW7Besr+yAXmOJAt35McYmlGOg/zIUTkNvZNB+ +pYZMr6JVhFHtu1I0XyHYw8D38WR/Po9qHoSYALRyVQZ6jzWROKXoxWLCzm3TeG1q +hXbDsqkGj1B3Dxa5zN9gAfEsPUY98wZIZFE4MbDBnsKIhbtFJLWUNVVfhOzqTQFR +FnJ4yXve2wovVuaiI0pFOX1JilJlzu2Th+aHibAwCpyV14OAQQeJu43GUfEbpdbh +KjbuSc0Hu0XQMEgqCBNKdjs4JRfMTEAfz+php3WeCagP4ZPqPrjmPEWxlvRSjN8p +DGLpZJaI7Uv25W4hK87B+mSTHq0aTU3vFB/EgRwjhOfPoFlQv9wKE1H5HQGGT9bZ +5icGXjBjbLuC53fw7ws72UmXpGMgL/pJTAgAjMeovXAost7iZaFrLwHtY10wPlSH +dCIVI1507n9Y6GQ6VFytunbVW2wcm4wsBe3WM/6Awj/yPw3T6IiiJNye2FLo/nQ0 +uCXbtDRqf4/oN7JS8YAs0Ebw4MhJdoj5uBDlz1Q2CkmNCoecKyIfqxnZSLC5HX1D +0E4jGpufORIpSf6OVT1/DtPNV7OtkfIrwGCg3/tl9EtAOMqNuYc1M5lgmRxXyQWN +bVvw/Qrq//dS1xx3idN5K9TpjkaEV8jNgD+82GT+bB9cKnvUf1duSui8Zw8RoqGf +cNOCLy1AAtCTfqGfMlYZcAJlN1VnXRXGjPBEoD2+xKv+zLWWW+Gj02l9SycYsEyZ +x3tBGg3lT0PxiRz/VH8VzuSi7spCkhCsJjefPwWRJf3UFEaUWkvbIG2l9HtOC4Zf +bmMit1DW71cXEH4MV2GFEIVASOfa/oIpLuIQ6sKWpd9OHH5E6TqZsJA++co/eURc +xqOOVO9IvjkdN0/x7FsT/41MSmbfJ/owYCwkBSs8zgkP7KJh7zY6cnQ1UpZuGfhp +bRUN6yu4dgh1NcZVqJ5ZJlUZj4fuSn2cGZ8KvX3phX2n+j3s6NxhEpQLbJYjH/nk +IPrwWbTypmBsHX0es7ds84A4FrUxtAKDL7DYoxydkJr0BI1OMHK7t5FrZSZIeIgK +mvyydhOJ4mSD3RZSFGOz87JlJqPaB0Bri9hQ0Fi/fgNRqSKqIox9RuCLbVRPnlcc +4Mc4qj1YEsEZ/jpNuTP4VPA3CbIhDOgJ/ZIc2wIoX3Llig6NCNhZo0g69jU+XHgy +IxjXgh/Nl4TCLgsWtNokhQ8dKN7bE4NymDVonn2nPJmJqUEbwf/GIDg2OLw2oYkZ +W1KNbAlI0Zpfaz0CZEDxsC7bDZxxvduVmyUxSH5r/5ILQSskl4QGM/85aAdfaF1H +y+jSwBk/App/gpa5rC7nMmYmdVwXIzpYK9Zu8DrZ/w9IZohF9Zz/C5RLX4Ee9Pzs +N8FZzA5K9ZhMnAzhwPASfb5m/N/9hxIf4TXzJBlpS0aIItCV87dEE4ARSNLBt+sV +OyP3Xxv0mmQ6W2MF8J5XLDI/2bBdjqIKrV8l1TAqAyqNoiCxVXvp0o9Lo2e6Ema0 +1uF6FGc+z9Od/aEpDJQkKnSTdOw0Wy1v16UIh9TKSh1E94d0EJnOnK8a2YoaGlxG +y93mC0ayoD7ptOd4FlpAPMOFJOfx6nwtJx16SLKhbi31NbGCTAD/gwKKBY5gRX+s +S2NnjHJMu/BE/3+NSJvJAmv5QBJmFuvtdNffy5O6wbRFNGfW29JTy5CtiuwDXFsQ +8W8nIjFgfUVPRA3ujUCbp07Ui/pNkTzvWp8ttWo4ICDFkvA3hz29tHVYmujIAuXu +kbvzQJfTFp7dS3OKAoEuDeeawaBofUFxVWu8GrJR4Qj5rCsGLeHSXx7XBRLfjWd6 +H/YSlGvB73Qb5ty/jeIF7B6UBTTYcsdCA0QdhKdUSfKQ9PT24ADEUs9gihseaEyZ +CIS7GZOOtHDyrQbecPMmvwQ2iymACSj1YtJh3gl5IVCIaH+ScQsQ2Qh2NKcYoeT5 +zJthJk2I6YJsgF0KPMiHf5YSGEPb7bH8XTLOgxsECxISPpIf2u2agGZuPzD1aG/q +CybkQYnFMynqDatn/TcfgClu2CE4ej590AhMLkCvXqrov3PgIohaflTkiPozgipc +swz56fHuTMB5MeaDoy6aZyFYltwXRJ0xilPFJum/M/6iyZJv8IVj32FEBFcsBS4Q +lVCHngUJoXTvxCFkaTZlegkQpw+/KfjTi0txIbWI/PcEwjGaCwrmAhyPQLgnyoGZ +Wv9kCUqHmhZZP4cK4NsBhUnn/chrj0tyfKzketOuVS4Gp2lOgGCvIim+TB6HPjnJ +56fHD/TAcVeBnWU9tl60R/mrtYJeEX6xgcEZ2x6Nri+f+1wZMbmRGC8RLP5r9KTi +sRsdtl3QdSBZ1zPQMrjDGfV+op4g2jSKbAweSMemhleLbNQNEyV/5ji/xFsUfCd/ +RtCYhgJJrVeU+7U4Q/shec11omKsWcCSWe4rPQqGgnJztE3MaWODetDAwU4Xnckp +5KLUHdNCkH8IGSVKK90sVsC/P86q3P2Z5r0Rudx7fzXjnU5uucqZ01ORLjNNXShL +gu9ao/9tFKTbdlhoh+sQ0tkiZAGUaKtKcfeTMr2wZrt0H5KQT2d34scjd+nwWLWL +MnJN6Q2dhaBfyF16/dpeKq8tYP2nnSsFVNrCH+t2HOZpM0qi3MeHcCEU/1NigNJM +yUx7lBZsfquNrrp67PRSgk1Z1s4wzTwpRV2RXm8sXfg/rCX51My+zGqRJs2xH6aH +tp/GRVXaa4FApeqMpTXxWca5qsVaNqcTuchF5Gp0g9F8MuPJ3a3l9tRf1bNujQw9 +Zkeymr1qMpCnwxSPRAfZY+bb3R7ZRLk7ckvXb/h0+ZBxiuBOHNWPHPqbhL87VuJX +mc6+WYbmmqGEjnbDmjq5h4EswJNdAgHYQEGF6IjZ5SPB8HzGvUY+Kx7hpxSOgwiQ +P+BdCMGj2bM5oWpSLfh3XhD60LGwi/N5w2N/LKIZE1I1P42fL/kQrQgVqwdY4vdN +geGT/t87387lZZmgBmL/wk9xNNSfz+miRER5gLf0ZR7+qR7S4/N7TrwaQFWZGjCW +3KnExAIUsXKXodPeC1a0U8J60Q1kn950nYpxLPQqHgrVZQszfQtscO0U+0yujG1O +DMxJl8qGlHc0WtlA+Wd9/sVTj25xL0f07iXJJhYZm3+h3ZQCz27iheqBWPmZFBoa +ES19vdAihI85K2vOYtN9XQKa8Ce5G+JYpPGLaaM5LlrxGhpgmV9Xon8Jvi+6Sujm +LNoVYO+WynwaBmoCZQW09ZMOl7/332JrDCrlCs/Oa9y1rOUo3dBb5gJ0f92aMVzA +70xIvqCHKSElfNEq7VnGmrzF/oKnbGA5oIeGpP71Fzy1K5AVmK/SNzlMK+HTKW0z +sU2hW8Du9I9te6578qC+irj8i7dGloktuREzNdS2VTa1VcwdGEvgQLc7UbbftKzI +K843YJUYf2gWqpj4koIbIHw/ZejAVi4ZhZx2r0xXsfDKjoqY7YLL6pDvu6554XyI +hJSu8207q936b7uqsssfj/K9PvOoKxvJdSGdvb5iL1IC3AHefH/PULhwtWOuXfBo +tZpRV26aR7bKWwPKRdwaxK94bkFUmedhFEKRP9/vWdTbHc9fzK6LX+5+gUc6jqp/ +4xfEcFStwFhv4RM4XeNw36n41lVFMTg2GGuB/nyhoccKM/Ba/X17A1XIEWPBJ9lJ +oixTg1rASoN7B9hs3aDs6TI1Kx7AWqTqttTLVE+qu4fnMb/ENzGlFmMgMSyktNZI +6x9uFkYi2vs42628zW8paI91Qa+1nHQD2XLXvOv6SKfUsisGR4yKxbnp35biqobA +CVONvy9kluc8Eir5fg+zufwERJTqZjf3edscSeRuZrhfd5TCrdfUjfHjKyGnJn9a +QLDMAnY/sDZscOTv9Cy3Q9j7Jp8X80G1XDwROVOPWVcjutXkTBcYNC36+i2FXxML ++ktlORZLCxfLeu/fLvYNZC61VMBZ46WxHVbqO4tGmTyC3nldk7ANXkm3YLTKYqft +yXoZRFrkqdHXvqfS5BaeP4Dk46dy0I4o6TWZNvVffBJl42dTsrRwD2tjWRpEOUV5 +YIxKzEW4AY+HWkqDh/4vs9kquHIL/fJysk0IVRVzLsFrG1y5tmRDjb8cJY0MAn8C +j8R2Ngws/gFq+Zure+BGPc95zxsmmYTlt4k/IJwxqzgwlauRrDdVZaEXdGHRrzXP +/vggw0uE7cNVZlnXYgpK7BJQQOYi/nmOGkjXCYE42MyPIr2tH6Ve6u6uhsiPhj4U +AHWm769ozOaqt8wrTWuKcOg9Nu+KSUIfuXy8NpkD3EhlzDlPE70zSWu4AuHz1hpW +2mfjWsZRbsU5F+FKkXltV6WqEJ2t9ES6wYkKGqWkMzhMuMIvOstQfFxdCrnofFCu +O6l3slC3s0Mn8VEdpx2RFURAE5yVtXcjaevvqU8EXJzhquvpu2jU7UQE14S8NYED +4s1s4g+cHmL2g34kcjVGOYsXoAnN+iPQNjzP9q08M1oOj53oktE0jJTJ7Bjuzu5X +LHoImKCo+fpuPbqR3cQXW6edfurs26keQnmHDKaPWQNs7FAhC2CqKaav+fhZYQ/5 +EbaRRhCCX9fTOl2wOREKHar+PBRMzE+jBEGgqcAJBbSpSIaEUzeZPiNAskEd2ODm +76h/fUuNVuqQBNuJjDbRZDGW0hZMoUiw36jbA9N32MV7WsS0gMow/OAXHWIhIAuU +iyZKxtTf2FofOJ6sjfTV8eDAyPmXX6nXcO6TUoR/iktOKfWQzGw93Q0DPgFBY2bh +SKa3mdDTeIoyvJEyGnSh5m0hbjeCMLIXhs1BZbb19fTmYDgxiT9S2DHg/Gx5dybo +EHbvKcuJ+cktRWEtY5emEfcpDNo6jg8E7WazroJW+HwdvF1DiLVInkCX2Rlx9aMv +en4sxUp/JLL1jCCJ2cdyo1fczMtb8A1fc353f8TqiygG130/ZYgMuxwyAqWzIK5n +Aps3Jrzo/azmqPxJAoFJKLjgFLyzeLMPQoS5oosFWk/hkjHEpz56tZ6NXzEMayjZ +vCF4hTc5lGbNeysj9/aX6DltZQyLnU276yhCfAuZJOwrOXFuAcbTBMpHcyyosFHx +xMjHA7Bw85tvvZTsGf9YnX2omYei4MY8oXlkA2uu92BGiSjrg/cRI1+3kKWSiMg6 +b6KIR9dof6G+SQ6pzLhdvcp6AtXoURkXFiEOc5Pd/q0TGWF4GB8xTkvfKLl86s9e +QEWzI7NSyWIgDdiWJTbDHC6SBXnzexlArOTv/jpDhXQelzF4OY9UJDexIAgLqcr/ +bAVyTC1Y+h8IqIIXohytizqteZo4zFtAKN4H5drgUnYEgju+QwxN+yJJcU1Yw1r7 +48bXPY4Zg3I7rkQLtuy06AaEgH1fphaCb+1ViXSaPURvdZV4rTObmzTVoxlXxZpU +yxs8SnwBmy51c25lFPWPtyZCzeORzUK7ng/KQmUecFSA4SsX3km3QZfQ2tqkpQxR +XbF5fDIbUif2DRBegrQSJ7+dH6AZwh04slljSgDKxk/VFAUlbNiV2hZDQxS+PnTA +k4EviIsSrOxGgQjlpQo2JJnrT1JO51d1oN+sRzn7qb7JALYT18PGMee2DX1Xv6M6 +Xp3vGgocHJwNeP/IiNCPILpd5HNboUhkU8evletl6aUmiEscnSXyzZt7Pjtf6scJ +hW8JDuJ7rJHUe6YbWhRy38xOpa92NbyI6chYi+LPs2CGTBdBJhzy/MKR7xHRq1eM +BWNAxq9gLVBAfk9DsTEMToQ5KlzjcfiDQu5XTkF+dHpJqj4/7c85e/Mpzv7ESnL5 +/K/cHNmkYHBWY+6asgzfEZ4efdMgSvlL8itty1nTxzVa7s2zIQiH8T0RhSjGnKkc +OrjweaoeMC8+tLR9Hm5j0RRVkYuc1SKS8Za3gKVK9/lNjE1ZpK+AOl6mwAz8a2Z1 +S4dZTS9SyEm8sZcjJrSY3+ZDLTw+ilXEXDVPk7XRc+SLemuA9mcWNMHfskWfF4/o +RTj6BLcqeFo8MwpyD91pyp8Z7n+tBo3MOkqc9WS80oMtNzbUxaRz2a+iUoYIfes6 +VwxLUY5qgk0RKO0mFd7F/GDrBmA1fRzRjn+XTq5Y3T41D8kuLWpvitJlXXg8Ktml +0IC4v03DGbu5ZggkcDzsYEbJyJ0oh6/mq/o6sy87/xYBuUD6gvLrvPGio13EvVjg +yHJdYM1vSZdqBzsRe+owThx5f7XvKX3wtQZtGFMx8ElkH6HZfvuhiull1Xoom/jK +9zSjhhtJiKWEC7z9FngCujV9RzySZltoYLq7pvVx/Q8ZckzktbYj/4n65y1KeM7G +4ep3Yne492a0Xe5hpCJIeGwwV8xsGz+8phjOexg/xSgajqEIa1tzw74s0IFY52Y7 +PxGINxZoetmIbnP04gly4cqJaIBfXK7N+rQ9DQilRMFb0ayzVpqFU1LK3DrZ3j7G +ofCfilyKxXTPx15aBkOs3t5i++yyliZJRBbKtd7B3I0KnclD46a5XgIHkxggLkMr +/ufxqUNx1CcIvnRfjRdgkV5PA8qVGKn0grSliV0w862P0wR7V2Fq/t6c6oJuhNps +oenrXy9meLaD3sMJhj2T/m0FheOsJ6zbKFMA5DVtM6AmvfMhj7M52dY8pRj52AKf +9t9xgla5zxsXVskR2FV6j94sPO3ELXuUINwUjEzlZtajCN4d/pAp1oyOBPGftzgx +7xPAYwlbCgrdtX7lxFn+uaIc1pO+u4j45JXrKoVRjaMXqgsPU5jpUGRhMtlsYqLk +6OrOcFEBkEbW0EIcpbkwps5KjS1e7r6wWLeAUY0oNkpjy9jOhUXOF3sotxFqHjoS ++VdwZnWPnn791BZ9cVIV/VOsPf490NiSQXT8+Q9GVy3ssB+moa1KR3+dN0h8wwLG ++fMPrp5pRcATo4RIgsvnfshytn+Bnne3zKJs3DVmzIH1nxKNyYQsBt3+RwOnR0GK +CyuVAk9mWM3u2TDQF+lR9yTCLHYpPaHjNZ4uzLkVXbmLhw81D4DARZJ7n+vGN8Fz +iEJxB78RaRZ5ik+78SwoBFgoIJONTbSin6iYb/KumFZ+olECnnuTAZ4o145DTtLz +c+Y/j52R/yCuXleuEnDxoJeTV4oEEd5r8MACHTMVXeomzJMG/VrzDDwXzZziDVIG +BIadPomjP3N4EEqk0Py0zKOvInushgZqID/Pk201pa8NK68KC9qXOepK9zlFPkxM +z34iF1R2Ctz0Kq7lqjANblFM4u2rENqcwbqCxbzfuNGlA2HPo6V+AebwIYwHdMnV +7Dgj0IBTux5IFkXwg1V5BtVJG5iAoEsgS90dx1Dhbo0N0iPO9wC/ksz07dPmglaI +/MSxzrRfVZdftd5jupYqlO00XPO7ZlYxeFPbCh73NSH1gKVfPHUbSvRRdHPlWkwF +NcVQD7aK/xoV+zeDCfzZ2+cOWb7q8qT59hEgF20ZH1wnK31hzbrFI8IYfmnvI0WW +kPjBFRPb9CahyevQgnrulaptiiJ/xvMEcVeN0HIPBg0MEdNAUh15OagGhTEoAftB +x/8i9Wus882cG3/nALwqngmyHFOTcoNZ7k/IZ/0RqEr8wYzhTuG5ZcxRdW9GIBET +I7R0m/9DlUXOVvmLPMbFBv0vRk3cfaCGaUk7ogKJcDByYm8OX0lBgNQKDXDMz2Fk +0gDLIA65jagnsEJh5sdIaBVblwQAPRzifPzOqrauDELRNRpMIs1eL0jB2rso25gp +WNf6wowdtW1h4yDfv4ho2ub0x80XGNKKi+QpKyNTa7Kp7UHkzkh77n1lLfVt5pln +L0moNb7z/86A57UZqxiGOvLxeyFxgYzOQlXjRnc85lByzwWgSSopkLh1TG6Jcx8C +ab2Umc0l0V9e/P8/Ngtud/DjiKllRC7C4D+CBN7Xt5fgGl0q77jX/4BIXp/HTVt4 +GfYdZW54CVwYCyza11cK6DxPTKs7QfVE3nN6lFJDYbXdKhjNTb/pQQAAd5UsosiA +SdkCgb3mEEvDDEbJtWXsiXcNBnh/hcyjkrmZGjERp8F9jBn/sHIprDR/1sdLcGs3 +ILUThMBMxYtebY4f/2qY8t26//AEiVVW8RwSz+Avn0COi7o0UnCowWwbom9+n28T +6V3Bij63omKx23jTReCydFMYUISzsn46OSqgs8WFAisfP1PaJAPvRn1UrM54Wftk +BPQPP/GkyQdo6G839Nq/I46VucJL2uSgJEqxZJHwKxJsWAheaAICmZnL2XbOCAOA +/mTrGTpDO0SxZ85JSj1qiEW3PUuyyMJVT+Ky4Q4ehrSYtOifIcPjnN8yY1AlJ4ZH ++ZDOGJE5bz9kEMimezmJ8PWb8JGnqi4taSqVQvVdpOWkvujynW+d8eTL/W45tL/H +jkS9mb0ehNx2zCcQJnoVuE9c9KVNjFCEbNCCEk/vg2rNnoTeLUmeJlVsppTaa1bU +i924zojk6EOCK60DvGHdVZeYgZVKLwmeUhXK/Va3zrna2J+HvvvqNjgL/jOTWaY9 +/DmKRDpSca6Uo3KUqnUBE8r8fglH2RM4jyJp8UozKf6WNVJDDbCTRlctySChPGeJ +8w0N125leQWUvEIJT/AbyvedfQIdxxAGvuPadFQQMG/PKYuQubrUGuvmifhZpNjW +6KyoOshW5hjjeXgLDis1PLxOZHD7ImmpBpQFRZ9vEsl2G7DcQznXpl69BXWRzC5e +dVkxDLwvJU7VZzTwmgrSwvMGVUhi4HaTAdjHVUnMz/ltW2A4VuqJgrrQeVWSNnfv +9/SK2w/OsrAE4Hq8j38YTHGuNjFx6AiqHrxxnnCvsypWbLdHkyB4x9PuHtKGTldm +paz1SeeDydIXHmQIxyObJhuQDsd/quLTd7eqfLieU8x/A2duzpMc0wOnpKa5H2SL +nTheP+cwgt0SWMCCWkCQGf3xAavoIfmZsfRJgZO10cUgxAvjgLdAMXSkEx1IEiLA +ksVqfYBt9JJ1Ki9CQI1pbB94F5bi7twTQoHUTB/qo75ibZR3jEwFn8jmiK34Vh08 +3tcEdjI03CCP9Sj8dwdN13/KCqT7NCXBkyMjc+JOYHUmkSHeAeir3nYqk6UZdvJy ++EwZNr+KALfS9U9nPRARPxhNLtZtEnZ5R+/s146c2/oW8Dzf218ykvIcXiGp1RzJ +IOAkcfPjK7zhUXqjsXmiX+n4ztIXw7GCp126okuH3NdPExkls+p2q9WOThoM5Auh +x78GaM6fjwMplpQ3jVA6yuNo2vCPBIERX2eS677ttfIRF+m+KwMY4uEnwzQjQIl6 +6TCW6X1d29Ynsp3GkL2hLMtWdkOpM0vOE2RubV12RjRgbF9dq4ceEj9pPPhntFU9 +glQQrGFAa3loHTD9ba9Q7SzTEx9y/bb0Yi7TO8aUh45xn7fVKxsx5VM43udnN9Nx +Z22N98RPkLGc+Wr+wVDIPbrpKlqsT2ZpbYmg477Jldmtg+0C7Xy5o7O4/J4xy++v +jFQK5oSXJijpkxdD18AypAO+2B7g7X2HnZgGvZJ0VDAagd4WKlBWQ9LgXDHEvk8A +gOjygQYScNH0Nk8vXX1UBCXX0P22eX8iM3JHIxPn+NcN3wd57S1sUZOAXEv+l/a8 +LgP5Pkbcb2SRt0YPsDQ0ug0MVW/ZE7cqc6+aF7hsV3LB262FPNPFtjak+jA+uPgY +JCDpX0Q/niwyc8OtZxPuAfXN0OV3iyyHXMWIYICeqsPS2FOBeEeZ/e2Wxy04b6uq +f4zLVQvEa6Xa4u0/RKxFntjk9+q6ntQMv0yYNyufnoBlC/puWwlMcgZnoOSD2CmS +YtyknA9lFNFp+2h6E6SvQIhzwInvz2SDkp4h+mNxlxj6kZ4IdjBwtye5mxojrJ2u +r6S1FNQZ2MjvIqerwTIGdjLsju8qVGscThX3dW0WNqS4vJzq088yRJDyFAibRlwN +3cALlRcoeW9jhXxEgq1wvfViq5vOfEzSms602OSuMWlnZRRdmeumbOgR+b6y10XC ++B36t7whfFMhjtSGzP7TKVrj8T5jCmfpw9gAwO37yvBhdefgevbU/RMraXp07NyG +SdnR8geMQ2md2tD3adTfAN8DDL0OGKUB4B+TR5J6/uCnTbszUtWtXIcTtaYQmCqb +fHOGOAQy2fe/SVfVY9FCXgaVoYBWEFsboAej+IA8BpkkKw3788LKy65JrnukUYN3 +hwyhaeJw9+IlxTjEb/SsuVJ192abFdxAulZGOWEnDvLokDPSDg9dB/+ifgH3H4sy +ignPIGb4o/lyQcCmWnu+M7ux5d1rGOfpSxBUBogqclauoI+loQuQLoi+lJWsEAPX ++8o2/DgonTGlNx5OZfPG5HODEjgWx22TCYLNMIw/apynaKUPXU/LJFaUADpNfUPw +5S/fDyt0bk20gaD25LAoWVsU53b/5OqYgl2xYD9dJPBdJpJ8XwAb2/X1gEmKwE/P +nHokkJAppidPEvfC0aFZ2g0CBIiYeMOd/wSc+L6dONZdD7FIANjZ5x7GpmRsjAVo +EclojNJdUOvJPrbFDTVxCN17fClglH+6TqmtO7eX1tKHdUiJgb0vZnoyUBsDxw+2 +3bxwh2iMz53ajhjrvrpz0q0Cko+K0cEB3+ksQ8nHd0xIf2NfRY7OEIvhHAcGXqny +m7UP9KdJcJbSbLgoomVbwYHoNGyFfoQPfagL5/jGLD6OppK03sPjOqCYaAHlqe+0 +e1g1RrG2SB/kkNasmwVSRY1TTwIWXLqTRhfMDX51Wwy1tCw8WTA10qFshRc2F4bG +zSwAMw4fsXL+IiZ9HxNgs/glJbKbuBkxHpBkNgsUsP8FrHvolXy+pQ+SKQBk/Ve5 +LuL/TY5KxCrMaeHGEs739da+HYe/lSvPc8pFRKNWgV+TP1t0Zh3OnZcOYkPYtE+1 +ROISM4XSmC3+1fkEl/dw9IBlOZhCh/cVypIXX1RYsEpActHS9EvZlGToFzidH+yK +3y7nfFApyo2/ab8XNqdGgSpDmmI2cNxJcm6pRWNXqM8/erV5MObNUBzBD5K3j1xY +vaSDR9gZaIIKsGRvgz7kklQU4K4iammeRRgQ/jy0jB+55q+I9IPl0qRHl5Hh/Brj +Fco+/vIUO9zCSaP27gn5tdxCAlU9FccOq2or2NGKfGPh83uBvDuFICTlWY7vGJuK +AVmxV3HQOkqxUH0qm2WVk0+3YT2PjxidISxesrByZ6f3tJoFoVsWOiU5kWiW4i9M +uc+i6p/oK1kQ8Z9qGKT6Fr4RGC0sg3+quRZN0RkP7KOLhEHVqYUEC43odBp9kLcI +fEk3ZI8809Q3OgDEuWqsH6+aj6cBmTZU8Bv2o0Mpn7nOHyd9sbTS/7HQpqqd3dya +jbw2vE1ry65trXAywuw2oLv03siMi6oY4oHQ9t3zXYuNntkO9YNE1nNHIl+kMXFW +bLuJ7t8+djc7EihOvSr2x+lkcNMN7XgRamBWy8/hk7HW9T1spv5MtTfM6z4xs3G2 +BvNp2rZdU69ww/vsohwa5SkZP2BU/1L1G6czi12rTK1JQJJcCPcQirnJCTVMKRLW +QqHy579BPiIBVk2wF3UmIojaW5cjB7uqQM1Ixex8SuxhqJFsmKgtLzuw6S6E4mdO +BbwLLhVM7pJ1u6TlZnh9mDqfHzRW49EWMhQ8OIjeSadCnymeNq3md6zEULm0gN5U +K2pPOZn8bBwADaCIeKc31eOeoIgSvYhcMB0XMGAjDidBMVwjIuE8b1ZVpDOjNQqQ +WPlFFaI+l5wP5DIBD12AYcwhx73zCt0SS7gOoF28VWkYTasf9FkyIN0FNlwBF9JJ +MTsQZ7tPEsuJm9AxKSCYfsEttnFRS/5nFHPYRDyFYK6JqiNClt9rhmiBAgSdbZV9 +JWhDT9wMnXWsfxQdww6EufZXw9fYeXSZLy1nX4ntkS7pKVAtFbQ8+5CDnCXFow5z +xFLBik2/n+neDUnSBVe9ablCsjX/ZqykvxiFfwanbVPLLrF0BaDCJXrJiqtCXVLQ +X6o7YxhwqTIZrlGkJXPhqPmimEq1wWwE4KgOp8vsKXQVPuEshMRWvZrZ7O3QjyVi +QrwJDCNJxpH4DesWBwa2JbIibkwNONVDrCPv+n8z/QHbok/vtH/P/D4xqZXFUd9X +pmqaCxUamKvWUmQpopkgvQIDtB/pJuOsSpLuPizeaX1gd+GVQK3AifV6nW5Tf0iS +/G78YEKoXPu0ezivPh5S1ovdjTsqb0sCu2+/5zodOS4TsYRM6EFBsU684Dj8fKRG +zcWyw2MKymqF5Qn8QnSlWkZvkGZSuRbd/JU+bI6tZxHzEux1/RuIqPVxvoY8WVMg +4icjJ9OXfBb5GrV9sVjonDe1U0s1DYcUSn50SqFJ7nwU5ghWJBSFevJS7EKx/eb5 +qVF/nGwGc/9G/8pJnZFGLQgSwBYg8VaHLwKZSNEe3EPcZmW27YlFeks9xaBXvFGU +SuE+06Kko9tg/aN/zTCwEvSuVUS0MoYawEhGnz/5Q9cELlv9XgYNUbpGsNpiujpG +wKQCNQxwNi50lRPMebU6wTQB0ZDSzXCy/etDKTv3FszR1o7hJMe8Uts5mvGG5uwO +mvWDIm3SnSlPSfPYo1iINs0gne6qGwmIqQpsGdZtlfKjhDsaKjfb7RqEsXUUebVl +59gpW4t75nt0hYXpzjKXBYQTuelvx1nOfc+Z6qrCAm85IL1rzR73i2Mp2yq8UBbr +uc3vTmKlGzrECC+Qh3A0/Pod8aGfZLpItvKMQx6CqDHf9VJipWy/JpoeAk69i7d3 +r240dRwMV8qRNIvwasfhJgms9WzNkbc/krAEjNzpVzAg43+0M3rPTmlTFOAkdDP+ +oX/nchTRMlChicA1659sicOnFlaOJ1NSPr+WBERoaMuK80NjjKNT+NAmx9jeRBdD +QdW37zD0K4GkllV9XsrnWVaIS6Z/cJwBO5tgN6Ag45l9bRTBhEoT/r6+Q0rvt/Xf +IaD1u89sZzYybN7GJfeywNYWt0PPvOnAQJ1rfRdINa5Px5rHJBE6UXj41h57UGWi +K9GCZMzSuNwK2Fpy/91ao/ryXzZeFDHvdJsCfkpPZDhn/gi//Yi9E5QF1GADRhQO +9bo1tctC2tsVlA8CfXJr7JjvZpfjAb1Vl1dAe+VoTQsAsJRTjWGsuEq76L9f/7Ol +Xr4yAzUUP0+yL0olndvm6vyNBmZbSmKrQzkrFYp6Ofpqf2mNGeLkeX2HhnoldsQY +UfE+HJu0s+pWlu+Oo8u8PqYr2A1ixJxSCiOUSGFl2XWkhEB3sczRXNvYGlkSUQEq +xlj0OJWmJDpLhvIxZHbasbuDDLUEybgDlAxktBsK2SyfBYVHkDF8iGb4QDIZ1p5L +fDNS9uenepHMJrbtQ7K77G1uz0rcQ+z/k3JvT7ALWnrBdLNpUdQJ78/GVDgoCOoy +1fvvPn+keVAvc6pX/uFZzZkxP+jQdKcACfVGgNXsmwBPbfABlhgGG9tkWp+EHwc3 +4utLo6T0EbSTpTsfyL1I/CviVpG0VuCbKwCt/lifTW1dfDyIzG2SNJZO3HhGHIJ/ +FKdx9hFFTUcDFJ28O72U6tWPTaW+mMMZW6vrBI0j4aa6kd2f4tajHnf5m6IGDKbf +8J/+ZphRoUWK7kHZ1vRJ3ITykBz1IlezKE4SkSn6sRoyt7U7IOSDQlHUjIHHXrwj +zA2onF2ivQwmjLK/KDo64R/iLLXV8pY7r4MV5c+Cu+omqk3NBS9RYg1tImk9TiEe +tV/ytULdHKza6Y0ajjdMkeTJd44kz7qf5Tw/qq4vVM+85pdugr2mPNY5bvy/QOdi +MLPu4BO/D03SZVX4wegMJiqmTD+zFh3cYUc2C+KVHckz5XhNQ9iBDUmyO13ZTzBl ++IgYbjQuTJ5O2p5+Vci1MlvOU61ufhf5Tnt01mZg22/HNam6zyRGpoe7hWP1kM0v +XhT2Ll6zFrc/cbo0C2RjmVFGlaCdVXhBegX4cXCEiDd8NgRm2GYLmBaTGqbI0u5J +191r3jNsQi5ZmfzYGr5oHfTvmREGxbkeu1X1AfkrtuKCoM18KiGhivrWdkuf6oaH +uc49Ljx+PTQkNykEzfnr3w5Zijd4K+mojmt1ill9rAB+Wn6M2nKAmRaUOCetw4wu +N2fKQoUZNrcP2BaXvzy4RcDhlg82vJWaUc8l0+p+wJToxDAClalRS+K6EtQNe4E1 +twdk1bcsjIuEaFML3bIcSkD2t3zTC3eEefSLxIXZO4liYjRTSfiQVASczzx7SniV +abTGHcD0mfrQKGiWNyvNsnymdhIx/0iK23uXaEr7mOdoupCFcUZ6iPT21ZbHwfYa +6ZzymJCD+9utHcrK2UEUN3Zl1D0l41vLAPhgaKyhlYlR8J0ySQhh998Rmb87pxQP +JQ6eJpi8hVuRXxqODQtAxnRQuCPnQ/4u/p/InJ9oDwmYHLAQkEdAxnw7gUrGJYed +xKi8du0bW0S1Rna+6PVc6cCTB/sz0PuGJrPgLk5X5X+0rIHR7hrz3AxyJLJxVTEN +M1NmlLoVLMZvnzzfJgdmolzII5lc4ywLwHGdFm1GGjBiJcVf+AqU+N9fqbXBkiXm +nUn1YtzXKh+cyH2Hxj/d0GeNP86PlX4zMU1z2l7BAk9kah4DBRBRgLzi5XwfToyp +cls9VuZr3pAHpIBZpOxATBAnQAtfKhLkMF7Pb9QGN3FIchUQMms5+ERLEHomPo0v +WqWM8sK5ul3yDGUl6RenBwfYBTAw4FlaeZWrhkqasimO3Q3QZPhggoknA5Mg8Pvf +ZQFcSrd6a4EMc9T48dz29t5ut7bfgdvJ1doIv8TPgqtYpYOyF2CEVqKs9EWiG1a4 +4f8s2XQySoE3EPv++5lO5aUo8GwKZRfLEkYvXc561FtrKMfKCGTXMBHzTm2Rd8DK +1J9LxI36R+umXJvpYJNwlAaBeCmt5rYpEZeAe699LEwLSs07jN2L3+gSlbkcZaQw +2BWjtSfj4Wp0edEJ9LgR+8qXaCKiT8pJ4K89P/Zml5Ckn/H1A9Sdrsi9SGWK7qk0 +/A+e8aiBClr17218N9Ws23j4KJ5lUIKahx/A0ht/Zf51K0CZcrwb+3n0UiwscXVx +cKD60bEmR+ghSJ9hIRxId5/RaetKzxIAg//Fd3pzU9QJcFUm7fc50eZyC7i1n93q +CmGzcl82iNUuub1c3mmKAqSvo4+hTz2iOz5yY3X10Ep8Sp38eKvVb0xOs/+kqGKM +rgU+bGuouU/XE0tTvGCOvFVAhTorVZIRI3XL48QKl9IG/3nz4VLKSUcsBy5+mQXE +BCsS8MRb60+OZd82fHoHkTccHGs5cYvm8C2gfRZjQjedsYI21w9sH4O4zZg40Top +tPq+fr1QN2qCNJCb/XdCqt2zQAtBUfyhVyLVVqCQeWghsGmdfoHF5zmZH6E52mp3 +l8wD6ZeF7CEsiLRFagfWBjoRxTtkVyAADh2ETILvoX/iY4i/GjN8WsE+91KM8iVE +qnPdkLjvJINKSd2Q8YHoNAev4V9HadNsx8ssuJWZSTT+tEWmkG4RzFkFOzk02HCR +53+BcVJt60Qq7jaD/6V/41n4wmvBLr6Drj6RT+SWgmp865aCQqmATpottwF+WA7/ +lYochr6sh+ry5ZE4HJYLU+IV0EtHCD7QB7jEsJ9D0TGe4/URIIrid92wkuvCVOEI +pOPaWcVibvD7kLhMekTjJAN0oYEZUQYr9rQDUPIjLkV4Lg2tvoMoz+/iX9oOgJuN +psRe1Ktkm8sYxBn7WzzDL8Bq2Li4lkv1HWlgesIDUXMD+pFcqwDVk8UpE2qvEv/X +hq17O6gHsIePPxYGIjNKxqEhcHOv/DjNqGoaIztY9wLk7VD8cZoqtAHKYpc2auEl +cAY6LZgWHwpGB2MXV8nf8yQdOLwFWauvLAu8w8d7zKtjofL2oB1w+hV42zromoNo +dfBI7S3STKg2gM/2j0/EtGYy9w8hyDZEpUxxdZAFkyws5KXIip1k40DRuZDyA+y2 +kVjaUcHDL1DU6F6t7CaX7UmzVcgkBJamhprZcG43h3KWE1Fd8UCyt2khFoEALgRi +9GqVlEpmYBSm+3w08oCRPEKFIuI0YNABPO397hI2dONL/bBV7295t7h6SS6oT0RD +22alVUupyDLj5rY38blOKxVLHvQ0kWZwuX4QGo4Mv7xR+YZ6Vo1sb+zHU+WfaHfI +p3sd1jBbqZhTVTsVl98QhaauX0EuOKhYkKMk/NhAq4x8ivhP8LZkF2Bg6Cc1soi0 +qXmXToO6qCSko9WyS6GJO6adb9KhF0J5uJieVe/AlcZfcnd++MN11Oot/7PPgk0c +/BZSwcopeV5GO4WF6OTHywK385pxikO8DHehpYcZOdyM/N++QpWt25qnpcnWrLeb +PFf2qQvT3cPzyBq2jCUzzktEyD7oxocHnIvmPolhDtOKF6c9LGmWbtXX4ShFtyRO +joDHat8+mTr0EsRCikaStaeBuk6UXc/AD5lM1C04u7dWKqO5x01oWSlkXm6u9xBp +Z9lTChXr5YemjGL+Ph6u8TsOEuNVpIZJEx9wsYhzDzf6LOBoznAOe8sw6WztmmVE +L1BFnDtqqxA0gMDAP7m4Jrw1+3GVSABxH060XjKjLuCwAsmuKqbaHyVjeNkmiM+w +WIjslCRwVqY9h5+MO9bl8qUnIv3EbWaMMZQlPkpVt5SuGzCJBV/xChIMr1PEetXu +xstS4022UEewUJPfYKatRA7t7Ij77Ubc0IAQaG2jj/I/Shd+ifdZiqkAlmipWQ5R +XMN7PMo3VP9kl+g6FjKME8XkDHFPuzSsKTRmJppAtF5hiR78iIrR7YUSUiFqlhOS +tGWmml5APdQkvX9sBLkWdPal77lbeZLjyvj3kRTfHLnKgndLm2/W6srNFf9IJFzy +1YnUYvRCxcB7FsCcoIRfcikfqd12s1Mf8cMUrLQmB8KVPPrGUZKrRpMRM274pB5n +sFfHCUt1LuINAe7DWROM2aXw/6VxKXaLd8JxN6yBp4AMl0jNOnLPzQGSe8pz/eGN +6xw2OB7lKO4odJ6E8JM1tI7nRyH2QDc43iHFsfZ3oye6SJJwJdGs7hY7v0XUVPGk +Zus9okC1k//JRyMBzovSxQkkTYUfwreOy3YYYiNeVCGN6s4ktS9pxjypXvpP4nCA +KIeiMlxCoIbuHdi6+orYbvW7wbgqvizUzjhxe2Ac/zua89ol0YHVtoOE9CubwRmN +HeaIvpCgPMtQXbvXrb183mWso0A96E/HxXkw5aoCGr1T6ta7Q5Vk4TPbLjFtNRjV +qByow671pm7xZ4el77b7tHQP2dGBvtV8pjMrUSkTKYc4kcdFnCR5V66x6PJeYNvz +mFgB/k97e13n6j5V/179jcW/UGThkmfD55H2sw7ON78HGREdQYjJJwSL55sFWim1 +x4H/GDdXzJjs/ZiagO5KEbzBYsx6rBI9l/wVtzJ+wSg1CYBdrpACZ5HcYMVRON/t +7ZJuuar9Ia1Ng1VhA+fW2KrrjGbVD/BQKLkXVGi75FAreOPaTeYh8MrBsCz97MV/ +bDt8Zai0CfzOB7SGc8EPsCUJcb8PUnATNzu4d9z3MjSnf+6Qj5OiaXB4NHf38qrr +6EEWpDtBtQkGW2M59jsgXoZgskFmKw7mihcZd+0yGt4K4+hEwiPBwmnlL3uvrvCC +/Lx4MbE+1qfAz7/qJUWALxQ3t2kTcPapZO2RTkI6w+v1EFtPUUQC5PAhTC9V71Js +ZrOqZU1JXdEyB/sPQOdQKvXpRJHu8oVk0DQjnGChLDEQ0ISXKGFAOu6arh/3IE3v +WKnNmj6i2nBbQ1G+EcVYGDyhrgD3xYFGRLZ/nKYw9Vj7yrWaS+KE2ZcKjNGR1oW7 +/6HIck0wbHBytpx5c0JP8kfnWL9JOPPO3xIpjiS4Lx1z9/Cty5rGGbVKxvrvF9s+ +a6yUWHb9cL5iq/RYpbAURaiL+JJbAt/2RD1JsVsiuWqQ0T9AB/23yD7z5fkV056V +C2X07ZB/srTEgJxmQcae0PlLLiwBeB6BnpIsIeK4pj4LMJjzeTymn6rkdEOc5fuB +yc8AQ+qLj9O+FGXl6Woy5F7TG3jv8OnLhOhu23uyV5ljabOPah+5VOc7QdUCq3/n +64tCgqEInH0r2MTA5RA5iRfXP/7AoBgI2YC4z4veosfVKYn1YpbNyhWNjygjSSeh +2SHA1NfziiOdYyO3QvUUDA3vcBvk1ejksNSBo+oSU5Yv8bCFvEmAjAQ5fgC2ZjtN +4K6f3m9DbBwRzt1fevetgXlnvkmB4z7AoF0Lzxti2z5qKR+VUI16czfe+dpyZ/dw +YDLVab+F5dAjOhEsuMLZxkvNVhuSI4RelKH3mgP8m9IjlsY1oQo+pfhdsDTD6xbf +1ROmnZQOA5wAdi3MdGxkuzmaqSrtGeR8SdSOK2YHn5c4CBj73VJ/o+fe5bsWeOFg +DoovgMfYuYWFTOpdTXz7iVvNIAap+MTi1sF8fooIzZzzHsJrZeozzwg7vtVWkSte +ghb2AbhEx5woqIkWoUl2Qo5Pvftc0OUfoSlBKgu+OtMgG9tdgwCdz9ABav1DCCTB +128bkhzuSxnz+0NZPtChn/vXtb06nWwZyx53LjTF/jne1c5lJ4LAeg4jurCfSHZ5 +7hTOgHtO9oQJjla2g/nn6WhkAayLuXl6vmzg2Gs1QXWR8kP6U4xDVEPPv10rqgpV +ARHZvRFds/p38cVdWGdVVCBWmFq6rEL0rStlouOekWQDLSID3BCdI2fX4hiQdhKh +UY3rfGUNc+eTy9jlB5uHMxpCFIPlS08JKGep8mtCTfsIltj8vntastcdRLgObqxM +j61a6JvDAlYFA3eX28kSvluSqYNhrX7QeybBJa1EH5B8y16PGjIr+sCUPpMcy7iD +ydcoc5BRXjysTJ5FoUhNPW7ZBVLXPPDLh0Vgfaz6uj5MwWroLHA/S8XU+yzFfbC3 +V7VZNbvRp3ZHwAlq6CBTEBz0Pb8G4tUaVgNWYBAA6+2RAEyN3yGU7O1wg4BS/2Xk +dulQM/skQfTmwHkAIakadgowDeFAYsUTZFZqwxHsUZp52qPJ7QJnWrIwNtOflcrG +qX0/RFBmTk2MnKbmaFfuq4SC4Jv4h4QfmJLqWVFuwwPENRxDMFOCvgCckJdDYBmW +TZ+GDkAyndVuEMikDFdZ9F/V0iW7cy1o1iiAq2lALagdWg6VPZ8yPalq90HIxlwA +n4iRzftVwF6j73kZkUYSC54eDxzUkHvWiYQ0tk99oSsiPTuZGEOxtrqJKNw/Yqt+ +zZua/O76hY1EUJRu1WOeTgUeS5ebV8V1s2jhM05Zqq/mDrhSWLL/rxzdO/ot3UI1 +J0AISZOuZepIU4jaNWfoyp8wXSD1wQexoFB7mtKG2sMiJUA5SBY7W2Q1CqIkHWAh +OGmZMAeDQBFHrTn67SwoeKJOgCLjzzKy33u/l317AUI8LmzI/OVILGJQlxUQ262n +DnzIUB9DJhTqq0RFFLBb0rkRVDzbJn4F8MvCvN2CqSOep8C4wwVphdSG0D604sVj +R8BS3R5Ku7/LUMOhTX8S86NEcWmoo38BLz9Mi3PP7krq6mtIO6OFYYHYeO09/V74 +1TqPzVQAmDJ7sxnUgs2r4sr7nVPV8HbcMW3xNf+B9zeq1fMAS3+BWe/WkXa+DziS +xWjiJx9dP2B7Tf37G6fANdf36KNQlmni2t+ORan3bog53/46cS7hMYgjdXTdkepF +GAJxLl/joOQP5tvZZ3qm2ZEjQgCuuv5aZW1S2NpAN6SQDySKUOki7TFU7KEkec+Y +eqwxW2yCQu26TXoSNGFnP8jbmm7yFXdJT/DxwJBpzeuMz3Xcylchl40hQFryTMxZ +3+yl1tY9U3NhxAhEvgx0mEeKTg1KqJgxNNt91sWh3z+b6ZpMvehn6auozUGoHRrn +EhUQZiWkZY2NW3rMYUdhCdskwnN1eioiskuYFdMh2XmVKICsx4h/vLz0Sl4ZFTj1 +KNMnwuwJJsiDKA/1Gp/yy+wxZXtfnZadZHjryx++t4VrOWyjQzcCSpVmtY0LgtrN +0yzxt02hYIgg95Dz6VzZ6z71f7TbmeT4UIrs5QwRjjF9B4LWdPzA263zNmply9/k +CV9LyNlmrE21Gt58phdxuz8zIDobshFAQhQAjIgeNiDC1z+qHCpJbLUjbfcZhAKG +EZ37n7/Eo5ClcGd7OlHP2wG+E627+Qo05ThUdXuDci1OgLXle7UXc54ZiwZI1TW8 +h2COxG5Kzjm+2IrrA8jhg+trKueofnu023PVM54t5Gc4TmeFTGZxLHlLGF3/3DGH +4NDbRx6nUojijtxgK8TR/ibWBRVl8ljcURBw58/Ajdi++cWynexAADShDp0Jzgdl +AdBPPDnt7+2YK+KUk0oeuxzbJ25FRNTQUdVO50hkVjqFvuS8KHbSc2Vyc8W6LYXp +dbJDYeyYiNmxfMOgEs/UljvGFJk/VvLhqLMTe7F6xmAalpbOREEAM7n2foXaKx1X +IdRmKD3GwleLN+lG2qgOM+SK5H+SGQ/xND0I8481Ui3URFLmHKPkXOvvAPayyg9P +2or2hDhxSwoLEaEAL6wuwLCs0J+TA+D8Mwiqcj0fgzwiouyPgOGgvreV8nLat4Uf +ow0ccSRtDhtupty6xtmVcgxljCVP4BJjbQaT1sNRuQpkPaEADvJoRwjC13N29gQ8 +TzGNcG5ES/nxU/55/89rbFIkN0uhBPMylFvsr5/CpwWvQia1CBzi52NffE7UKcuE +ELRf31LLydS4iSjNcv8nF3vfMR1FtpgQY7KTBdv0jKIz4D2BMexzHYpblJL24DHs +QU0lkHjLRlUP4iDHcNkNJnI5vFmN/S3iRANlqBaL+3jTNX2s3Jt3IxnU7TrbFsf8 +FZ6ICGyR6DU/8h0JhR9g43lPtYgK/32DpHHTvrGwhCbqO1PUM70j4K8uWs4jS36+ +hYhuFZqOnXmSTkzQ0W3WAnbtx07HAmIDGLBnAcxl7iubNIrd5zfr3upynG0Am4NW +BMNl4KDh672JabGe7bBLrusEZ2jLrSKuk5qYDrgcQn/jDhXqUzd8dOYL/54etGTN +xaP9221HLP9z0Yg0xCZWZO/Asp6IIwB6KnCOL+PszUr6jaxzv3vj/all08gGPTRf +2xgCFdR5wXJQ0Vhd3qv/ZOIiRywLPXTTxIzqQKSvNs6gxpAGbaZzYMXtGzVUDsO+ +1OMV+SeFZ7j4IWBwsvEr5gl1tqUICt26MZZkhQ5C57AVkZe7JAE/QemNTsLaHh5J +Q9ianvYLsp/7L5d1PKwM0n8V1a9qb/dkhPhMUpBdI5wuV8xg8tk26Br57SUnth4L +DNJSzQ2Uq/BIf8ZKCUVbnEi2H/vQ35PF0M/vQy6w3xuHuyx6xR7LONa31Mk4ZT7I +EeeqzyJThS7ArKQ+KXUkuNFDJJMpXMWauYrreHKreY5jsAAdIGKyeezSlb2DEB/p +OG91Esan40GklHdcLqk5xfz5XNENwarbJwkFoNTLsqhiGF653hO6FwTkeCj8Qeo2 +DVYZyEBu3vHle3vL7IjvsmgFCNWKvP4eEnQYBEcB0K1efhJf4037kH7s4ZtpMNhZ +gj4FX4mfBJBRbOli4B9n84qeWdfUkMsWlcYrY4jpVCng0Wr9tZj0Jq8UvijEqQ7O +YC3N9V84aF5LqKQiP4XwEu5CLUsNfA5zBoIpldf9lN8uCT0PX9CkDOO53a9SnQLH +81SsIzE0U5PZD+5xLOVjxzj2hXvIRrtK+TIdlQ3lQiJsvccibVpT8rUhDR17sSjY +aFudaFtzk69lgDXzXLWvxAii5LstleoV+mlRXd2dEYHfIafAXRcV01zo5yllXtj+ +ie3O+WP8hitQIL2Co/1t3YjCR/ThAzMybx82yiUlYDyqEX4Dk6KbctoEQUc1j8op +1Lfk3Jq5jTnwob/GIuv/pEgE+BzPJbtkbodHvvuBMiwYzN+wcBpuI2mnvLxvYLIk +i9XUweDKABeX/NtX+qKLpWw8DMghnEO/pZQf02dVt7Lky8b16WjdxLxiuBN1eE+Q +5LrMJz1NxrTCIfupQWhCSGEEd61pwnQDv6Ib7TFpdXu6ixTToSfc0xJTeNBLEDQw +FBHmiP8Mz6tewzTJA5hEZij0j2Ibuzq6ZO2WNJfFd3g7FrDPfaVaTit/wSwkY8xO +7AnrzanwMXA3wFzdsRKFyARtbgn45/q/gfwtRhWPUTPNWQIxjLsga8/lMui8/AWZ +9z0Cj6/geSsrxuW50faWiFGwz+6cSlNGw9zo5oYGQ81XIHP6cpltxhFbsJk/+45W +ismHCIlwW7tRpBM6o4R6j4RA6Zf9rStlIQ/My9T/WhJcIUMP/mP52UeU6PP24Vce +FcqIUdVnssLxYsJts697ztLkaL1fPcr0CU7YQ9FOz045s3VntTZpuI2hW1LdLKMD +7gkbIQR/UhcPOHGN305DM5nqehO8ewjXeR1XOc9Xi3DGTi5AJiEAZ0am7WKREIey +yZOFjdn+DH03ikzmx1j/J44oz+jBullhpG9b7WGBIQFk9U49p13j2bMhQ9zT0vgz +wv6Uv8kzHaBDXqyReBdkU25ETu7TgfxtzHO9SBtXWCJ/BaRjrGJaaKRy9uaVlxM+ +AkuqrOatzEJWlHGdVI+iHa3JXpJgx35OBOwZNlADXSPsoy1slnNKgiYaZ8sxVkxJ +Xo1UvCYJtU+kZVk1hMpS4mY1cnqXRaB4QmQ9758p3cTMwjBs/9SvanPc1EL6HPvq +0D+s/wtI7RcKvajt1ms1rJupHXS41FuPnorepD2BK29Zcb2SwWdfnDSdnnBnMnXe +tINitk1tvhnjvNiAkKpI6xxTic8wr3mGgtWmqOxe0HRnWHNgQkRD2HcxqAeV6nnl +FaikZIgBBznear3t5yKTcJIXUQGpLdPeIVsLHbrnXy8OzyKWRufHGSX6rGKs9f5F +sSdUC7VLtTBNRg2UBmhLt09HIK2cXchezfOoTsOALqq0HNqhNy5vDd/u6xZHnQE1 +4w5/ul2NYdfIJPoPq5JSYypJEjVDCDp4UFoglOK4FkzXRBwtl9jDJtJbIxmmhtEw +SEggCUCG8xC449Gi3lV2yJA5gQ5cCsSeib+twaLQXJ7sfkndTsaP5tHc6OMejg7H +Q6+YXV8nuOzPkXPUek9MLDN+Dp/ai1Rxofc7Uuaqvqyco2fmX8oNGLHkwZuQX+e8 +9MWR5f3IaicTcr83yZA3affMKaPr9JUDhPf0vDqWOI5lEYXzc9bHFFsqgEGvw8/W +Jln2eQuPTdELKxAmAEoHx69ejKtmkddkD7vLHfUpcJxlZl0JD+1LHs1HUYVR4Kg5 +40BuZ776ufXwday27Gii+97w3O1Yp6Bc3y6kbbdah8tX4V7RS6h5Ya5bJbbIwyO4 +MvfjuUKABhE5D0H2z4By16PUUO6S6aTywv2lembk6XiNzjpTSJNTBGpkFWWqubKj +34hyHUU2rbcRwr1mdGgxTZ6c7AgYYHoEYxzEJviWOUAZN4cr+NvYgT3tKfiXgGhk +nai/Ffw0xhGL7Rby1muFpmwbdR26/zQK/PEIhR30wMJ0nTYzA0EW1buecIrcCiKf +Uen/aNL1EIQhdIFdBlMmzMF3yvdyZT+Q8ZL1NB1Pt3P3GW1ZFcofLac1JJSVfai0 +HqsocZkOx9yj2aoCi9uI2n1Hm9GHTeW7eU0UqmJeUbsb9TkWHbBRLRVg7exKi00V +ciu2PBrk4yb9D35p6faHyvHS9znGokuQEWyKotuS4Rys9AhMj0tGcH9IoloEGVYi +l8+MWYs3p5WmDORqxiJZBDr9w1lXOqCZmZ8tQHM8zU0c2nCzl3Ha3IIwxmT5HLZT +hiGLYK74LDS8PsS8hzdwExj4a/vDED//gucldfSYVzQmnINNsE2S/v72g/dEeL/p +YPhHBrlPsZqLnNuDbK+gZ24aeGlx0+siOgpZ6GVH+Wb5Rf1lr2FDoIc8npGnnTRy +IQlOtOD0oo/HkQohNBKGusBVVdwFFn2nBItWn5onAyLYehXL1lvJguiCcGE+GM3k +ZAOvitcze1cfMEnn+EkqnpJ6yXWvJHphNrmZEms9AWNXguU6C6tf61UU3VPQ44Fg +X9EW2KxT9vQWPoAVycY3KjfaZmjH688lDtIYRsl0kLgmStaaDwFmfoHEFzYncY6F +z00iFnwZcWzXWBwBwso5xegaUZQbgrmPYBmqYm5GC6gdXGXBEo0xAVKaGVmxACP4 +6RfYLHMZAtIYJg5+DYIz+zkW18KX7OVuNf97hqfDCackjJ1W9dGlzEgS7xxKISrP +GNdJ5nf1JL6r0jYAik0DFSsLes2NfmVQGzmNy7w0C96aHwUyQeCbEmUOaHAqvddz +WAbkxulZcyvtwdPUMCIpFkJz6Ihinb+NTYUAdAMymuoRNubrKYr4/Qw+mVaIPo22 +m49pYbeTiV8K82vMVUp6DtpJxzEX2YzkYWgTuAQImqb9Evc6X8wrlJ/26rGC0MJi +C6UELP1YR77HupVQugVnjN5U2PuZZfrG1fBMijpE863v4M1JORQkk4tSwSIGrxJ7 +9No1j3+lmzqqwzQyh+qEOWhFXFjCFtFx4HnrXkkUt8Bz76OEJd+HO+s5PRyeD3EF +3bVC82UfIQjwzdmY0eJJ9DG3/FHxJxjBVRJ0B5zIhk9g7VuejBexWTG0fA+n7tBj +VvlGNlgspVt9uv5RqguaMO2a8Xxs9PsXuQL5AuaNDN4QmX+WnAwK7P8GoUwR8k5O +46BvlSV/Wy/mcxpG8/+l/i+LYBV7hMs56HowpY9QrgykVcD5cmNkgEdjhe3FpDEW +TIDUE/UIGLRMMCO6qfsXTulxG38tCfsGOH2YXjsXYw4k3y4OBrh69oPpTMpeflpA +RbE6v2wPN6m9Zz/7GDBvKDODwTR0orJ4jG/0XPpUmbcnT4ru55b/w/wMN1eoqkyI +8aKrTGKczT7MfNtlrQoT8PeZGIyHsIGc1nQwpQuWHlBJQNzlHhXuMLyLt7l62UvY +k1+pHe156GC2K0zYDPtoTqIRKeAmvirNEBk7HG0g+eCV4sES0x6fUS0loHGfO1NG +dBRRRxmGd0SQf0OsJZbqc/jSg7TXkrIcv60x/CXNNwaf05kWG5AI7SmBWibpdnKo +hsweGSxWu9KGNFz16ktrbMUFqCuoNF2aaYjdm/43rj6/bkMoXl6IhL0uVcnWnj8A +dgANdFkjkp5hxVflyGaFqslPbW0S0c5Riz2eLya4nJvNI8b9RM5YjAWkfvqz2COD +wS8aNVqfN5RoChG9vBlhp039CFUaB8PJQX5OOIi/ld7NwAILQnrUm9igTKotK7Ya +EGI+9njEQEU7gHHQuISV1xTceUtM9CxpNG1fbiC0nH7P9NiwUHhXU5LniRk1Gp0N +SRzVBgdUHtvyZ4xxnQ6wssyXMAASuXB85VeUfo1wrofaYxNDgj7o0UpZjUaPLyrh +ofH+yGADcfz3go889DkPF5yAUFGOMYPPQLuQxGRbap6u9YzbqRnA/foG+Ys53v0J +XKVFSEQ/wVUjCc3szNpEG2b+h7/ThHg8Tb0kF/rs5rS6qO6T35NYbPHEZzRYqfnX +XAUyB06WnvdFcmZA1iM4MDxi6ixWSluEfrik2GMbE59GKyUc7Yd7fVfNb2xuN40W +p7jYsF+p4O1mqrQITpCjQtOR6ORyuBAt1Xro+N3CSwnpYyWX2fOhqteGa7QeBy3d +xXmcGPHBV7sEi+pnkIh/g+eq43Ix4C2vhAVbNfss9Kdh9+3SKCt7KAzZnIQXfXHl +yNmZdPzyEJpDhKnEZQYdveSCicJiYmWTrWX6S310Tl3Qq1TPihj0+WSrVdlYHuBe +8/mEdUmgwQnD115/xEPA0ZPvmsB7xTeQ4iJVvlluEXZ0KdhLibBrLhz4y5TQzVCL +y493HVig3bvEZARNCbBtOExwHRilKz/wU3xhOT68XndcxXK6su4PBXa+nVXKXNZc +AhopOYhW1jgAfJZ7xAOYWZ7i0ZndGRFsVhfRSCZFiwo7O+OP3/8g8ODZId1TlhR8 +ASudwwnT5HYQLa2vDfUGfAd6UpN+ACEy4MOdWRs3+0HdvUbFI3deMgWSei8IVQDx +XeBLtVMcRxxeHs/A0/PKLZixmY+PzfEpDYDRtq9HLEoeq+4bRNE9olyL6IiFaqsU +6Ft5EvWoR06GYj9Cg6LafkZnRDcogK3xtsc8EGT8dW99R1ujT7U99YExGEalDESO +2jSDsfvOmW6Z7hRy09kgHUPYwJN9FbdrMw01R9NhHMww0uoxjJPuZYeHTEzdJnUn +NVFKj1Zx6jZ6GT0tq3dZ/ND5PHB0O6lf4EEdw1Go3wPJSjRnorXf3G9PRHKJJ+fF +g0dvffRbkn7nxkvQkYvKUchWp2TCNFVmF4CDXCYZhuZUMqq6vywhCx7t0Wb6vk/V +Gr/e+VKVnB/PLTcZLNt1vivEWQ57D6K+8GOfH+KmN/D59xxP+NcFQWtA6wupOB3T +LNsm+KZlwo+MuKNGt0aVWbtLPQhp/dbGwetAeMMdDPz+63s7Rdog82z7TL2kURml +gikHrpOBOaXPkixzSOofiXyBfeo7LDgSPMYF1t/wzgWRcQsmMghiVVugnUDb01+o +aI2EXBu6MnDX70B8Eu/nKvSEfa2ovbZ8/oOus9nxx6U4BvFfnsMbHSxtsuFbQ8fS +DlTXvK1a/Ukbp6iSN2pmjT2NveMAdxBoyW3+TMlGLplooJr++RWdNBVKLafqC0dR +dzLUmAjnrpa7NZSp2rfcUqm2TsKAaU4r49GOHWYyIYb1veBJo2/gU0Pic3j6WQ8W +GJATgEZI+PUBLM9BdGN1bkXe75+Zc3fc0fZtvxZoazWfiVPJ04XeBqDYPuqi2WCC +G1pDjQcg0p9YvYm4uRJDOg5ULitt7fZ/vwicOtv7KIVIgXGK/DZthgJd1nxJOsvI +FOPjlymGUf9X/Bo0wkac8sFxHAdafH/IFxb2zin8xA4FBQvISDqFeKtL1KbKzoTI +VtOzuw/P0hwVpn4rT88g1QKF8k/H5ORvLnUavmEHFKtpj0UtOidJgzP/5MQmTdBd +Pxj5Lf7YQGkpv7tYV6ltea7bKTI3eI4MJThyjcml/5GE24k5KuWE6qFpLUUxF/uV +YZBW7LntWWt6jd5n6YlnCmznHJ1a09jq8FPLN0ixOq3lQtV0Tw47x0nI0yyQ38zt +YlBpxM1D8rBSD7HkH3EbWVzAl/7MqQOy5MII+05u3RH2H37b2aEMukPLx4NsdAxO +2MOxx78UifP2lHH8AgJk1rX07AGSDNa1UI1rzk9DUlZAnaK/iB8HuvujfjNOFonM +5ojW/pQsf+kHj+Safsbz9VqupT69C8jJ7if6nf29EdG6dhJmYkME8wcHEjNz1NOj +OEFnAbZWwrh5TKv/xsdvqiZkofTB03zOoluqx2GpJXLuGk9aVFCwtT1PKX3/V+S5 +G2j9UNtDjISaFLYl+ucmqbLhcMjVCl4QiowxInEvuHTkkaQkKvLoNDVGG7iuqdIz +Z4truVNHTKoSInzxwXm5hPW/kbVch/wZvPldoJb8nJ3Tb5B0fyT0U44cQkLyPxo3 +hzvcVpsGQqmLm3hV8CEbe0a91xmnCKqe2Lk9wk9Ig8ZELEyfNfMRRvnXn1y7z9J+ +pyLkjVFnysmV1jT9BCi1MbWruFj5I3GeXXe5bpqMK6zeQz62coY6twUbsQoR2nnZ +ty2LtxcDDC3AQ1WhBu3TYioqNnV7PvNKiBjsPvCR0z0R8YAHUH4e/Q31RDh53iNY +VLKffZhADV9yRm3ooyu+9ox5vDM6yl02ktMvXn8vhzBjQzLO61U7YeQUUs3yzgUn +4gYtacndolRUXXLmadIZXC2KZYHylk19uaSS6lY1I6DkHyh761c95s83jyBwyO50 +i2AaSYL167njo3LOngBUjZSi1TGylgNat2MrDHy9soc/hBAAikEk0mZu2r2IIa6H +iSndvt8DyO4J6jexxoRdfqv+mbcvjJ2pKx9j/swS/le9sOwdNdB2cy3JE344RYmj +J9Xxv7IL9J/9y6RyuyxbHlAtCKAhNdH9rpYax7fgUBjSztill3XiSIlvCASag+4H +5VBUS+N0uDrVDdybR2FH1G1icvZfdiZS8HTsS0BenETzNZrRPxHNgcR2aXRnjAG4 +TwyYc6ud+OmttN8Jichw6JqdLVbYqMcFuioAJk8+lXqFPtOGcPe0K8xnPF5jdVlZ +A2WJNFg6QfYIDZ80VXrXFFvrtQ7rOjSqbWjCDTDugluNL1gKhDJPXgs5bRpxX+ZM +HkMeS/BaT/pbkl9TS6I9R0GdLhqWJlDFnuKFF/g6jHkP9gfECgji02m1452NdADf +PFSK+yLu5Uq1mAiZw4tmdj8vBYoxQsuxZbcnLfo6nz/muOlluAoIwloaS7jNFyMl +oXDJYxa23jQivWsvipppA8A9Q5Q066anOwUX99vGtMDWIizmNOSdmZkZEBRDgNke +UMbHUkQwqR+1Uuf2oAZozlbmoTu6xFt5ExQv/W+5WV8p08gXrVvkCtgsRJp1x6KR +19eubbkdD1mZoIdN4yufy4JSVRjzBqe6maQLXXjX3hSI6SgTDI9hWeppk6gIw9BW +4qDd1DLMbGY8mBGxwoYHvnk5VTK2KdIQtbIP8ub+2+BpVyaajwF8qfp6Nh4jJpy1 +63rUgqRu8tpFssy+TKECaUQ8NJjNIs0simDS1jBBGf60edZbJR+3OaE0Z2HUBNtW +bbkGBs13jHyX2BgWS9IhMOF7I1dwqvL0eG+a58SXs94Nkb+0kTxYnrO7Z632GhfI +bfHPp8ooxJa0/vgnLreLvA7UCryEbadE494yFGr7LSq3QdVCSKSapY8mr+m/aDWn +HDCWGln6qw1UZ4+Mqkg05Swl/6UtbZYjyPPtq+LvS8mSqe/KnJlI0UHMkhhG6nAv +4lxuputeXBzVHapjZdprIBBhE/1FiPorAYDyXYyo1tnAQQyv/kdFApU3TPwq5Ris +D1V7nZWufw7M7Juuea/y+1M99LMm766dDSazRaFLEJtHhNf3GVAujYZWg2qqFgzK +RZ6ZD4mldxiwPhUWCm7dsNgQS1x80yrpdfrUKjdlpY0oyBvUyWiD95+ebJ7xHcGh +buK0aP2iyotuL3Kb4BWLxmLmuMKeWFlw9XjWfpEchLtutsXjuXNshpAbzwNJHHgX +ljZJ7O+PmE1KZFcl5GvSySVolNG0s5qIU5WkU9lxEfzHxT6UlcqSYAnnAJlPL1tW +l9lqu6+zDbuNGXrtbF6ciHejUcZW6+nxRm0wYSqIWFDwFfMbzMPqutZQCMX035OJ +XGJCV1vxGcf/2zTtFtwAxJkQYPfEDXsZ+Bp8Gz7lLlNlcRA4L+4earSLDFJR0KDM +ZOpqEd6p00deTXDajDGKRkD3oCpkSpxOCSMPUGRQxtveuZ3sGX7qgJHJSzLsmN5P +F2IEJ2K19lLC6unsMwf6s3RIQxEimgqn2BP4Eif+5f3zBlX/15Rl9HGcLCuU78pu +3M/zkLUyu5S7khYeWmBM3EWLhVMunseDH/WsBGDgf222OcKG7UGxru3mavm7M+Wa +e1Av9sKYJeanFVsFSlBaDd9PT8M1jGivKtlH0QDvN0t1Fh+eLxUuYYy0EWWGYilp +1FyTZpirQW6/5ZOL5k58w4lgtrymQk+a7T2VdvhDdCwsnaViWZgZn65yufTbzWk/ +ExXgKGWHvddH5qEz5nidZ/Ky8AXIsvFEzGH4sdsko3/fRWK6yTZEdlFn8cJ8OzGc +7bfD9J9ZUd0ctbZ1YX3sAfoLp0RwvzMF/6Ki8n+hPToPKkFCEX1sNg/CYvUO2PYT +eeN1AZGFT8y26+8OPd55gxw/Gu+jAOcJwQmWqkydR3LKNB/uT5O+oaU3SrCNKvR6 +KE5VDwUyo509nAkEAP/+/9Jt1N2uPnKoXB/YXEUuFRCkyxiqg5zwIGtKC+It+oqg +IACQ932eWk83M8Nzc43lTrJ2Pz6+WOnX7DTS8sfuWpf7rMr4/oVLuscl6J1KSSUY +SMVxzyNFZ1jxHhtP3iuTDdjZhuX3x8J0+FGoCXSwHBIfAY0W3N+Dh7Zmpg+JxKBK +qigv2jwlSIpx6bbh84oj8F4cCWjV4vqlf6+QxP+EKoWDPwtKBrFDvEsPDGlHO4bC +oqCrXaPQqasI5wXPdgZGvAmSt16+z3/tF7w1MZPy4HH4AqP6zDcNhmsWjuPIQN+A +homRYcZuaa8/rm93ahUwIh9qeAMsapn91i8YIeoOtmBjzqi2zmQ9XVQey7ZzExen +51IxWp1NcnEFV/P3cxLcCJH2jWVx/HFqyw5BvkmcOMUfClHYR9A/l+4voZODg6dd +Uu+Ri3Q0oR66dhKJhm4AIwUBlb82x1PLiksCcN86lbrj49bvhN+QPv0l1a4odpfO +n5rRoZ9rqo7XgeneCTMXVA4xN7XRLPw2476TT4jx1KJSg0ar3ixqoD3c2elBnt9j +A36MLN14bpHZOmgbLn5UXSaC4TZNne0rXvrX3oZ5m0yGJmm0PtfBfUfrUai79C92 +1lx5jAKv+zi4twHd1Kn0PTkb6RL4ymBpVxqy8HhhRns/lO/69pDKNwyqbKBUBUq3 +ZxHAsAXYAvA0k8eFEj0EUMPYkvqsN18/Rc00O0rf956Fn9wriZFeRsFWf9Dmfgjo +1UN7QOWSaOYdsu7Ljbbs8z69culVvHUzj6KjVVqlvz/UpicHYZB1nUxbOeyJPbz9 +j1DsgPE0YilN3br1Soo6ACMo6pnBUZ+H2vgccUs6V+gq5Skz03k+T/a8tCY3rGPx +AWz/+i4DLgyHvT+Os4Es6uHV6I62mHHWNA0sTxrMaMxPNI/0NoZPUPa4kEV7D1O9 +VoNpJ2LUjjuImLus2efnwLrs9pbo1aExvM3jej7AJUjfPz+VhWfT/EbxeULh8Hvf +KeOvxJPnjMUxj3anAyT9XDrpUxqAOI2++1/16ADpp8iDwYykwSdavH4K6pP3klSY +sAVLtCOlHU3D+4U21rWFWawbeZWbfsWYr2hpHoPuSVGiMrz0r0xJKMJTlH5KfP3g +0jkvMyJ5ANy32nNKlvF2SBI7gBYVte9tIcqd8RxiLJCO7J0GAT4QPcDXiIGge92G +dF+NKUEuaWv1HJ7y++vIiMVwq/JmdH6I0W60BG3qyaHD/kEgjsKlP8ed8s9dE60R +6hSIVAbk/6WCFAh1d/wf9qj5lMNWgsnXqIfE29PRSck4HlN+QLE7B79LZ5ViEOHH +clKbgt0EGinbIZiAVYvIqgUd1FwX4dEUzmkn0HriCSArsinN1yv5xkxVwtd2JMuJ +KpmhXsFGreTuhdfkpD0rqxmLHWMGCE7fkj6wsXLk56hw0ZYum44MWKbbRgLbrDzC +DMeBBkiLD/8KPcaVSAGP54SuI2D5I2mtneWOOTIJT7TraGaz5N6zCX+AAdC1FlUG +T/7mF8JzQW2Lc/UJIcXiH/5WcB+QO9B+mFWWS41NOsmMTe8BQal4OsqIpR1FGXAB +fnqfzkhQ6P2KGA/DM3SmO4xZBGj/KE6CDmzI9bnXqrRrlixZrwvo32OvceHWQj+t +MDnPv3MwTBaKQwxJjMlLiZKZOQBagg8vOMJWlRu1CG8FShQBEizN3yhKkBou6jk2 +Mvbf7oRcwoApLgr2OMqI8RBffLOZmmDb+p63rFWrwgPJ9KgJ9LucdSNsZppChicm +njn27icbAAad7UaCTGdS+W2TCgOZ2ueaZv67NVdmew6p7Jkq9DSoOWxLyYsuEu+t +y2v09pUnEBnDoMbxhAc6FJIg1TkdlxV0MDKj1YxQpCm23nhURv2FGxLRerKMdCbN +7s0RIBoLxyTbKsHqG3MRmm7GqfyYg+/q+Zattv8VMmsfwU5fnmomaYMFmpDOp5+X +GBvO8jpYgCNjkGG1Nd67b6TOsZBYm/DFeqZ2787xwvHajD2aDoC//Y59667bFe/H +wDTLn9KVjjsPpJyiZMPJsbpoWaPRH/Y/k7/qDDIHqyP+hB6g4WrKsKs1HGcC8Fye +GNBVgAY73hvDRCe8imSjlzis1yMD21OwLJyMjkF/lvyJoHeimcSHoOEokeDp3lUo +VjN48XwcZL3FBZWOwClNX3iSFs9YrZttOtEikA6Yg3ebatOfGCJW5GrWAWYWj8uR +7DqVOBGSSEbHVMfYEZaeMaKuEycv4+PGxyoinS9GkXi42AiX3DQtT9YlQx25i/Bv +gjtUyqEkGKdq3qyOPCsVz+5XN8q0+A8dKQowsMltqnjfxOnS8hcV4AKkNXlfkRGn +DGVP2FQESFVU8DNuGtRQGax3Uf7iGvO/OfyifoN4XxVCxnUvVdYoBjsA4gALzIVO +u5ROU5uaCJOatMpFX65IFXF6IUqJ/Asakx8n85bz/XHbuvUfxPehTX6wFvd4ML9g +A+9elKixG24Hx5y1WY93bt1JotRVFAHNZ91WccHXhRglYzzC/Vw9RYdc+qefuH22 +SSGABm7r7pYcokz2Ku9PtEINaaebnugHMst0Tiytfo8oFJT3FGQ6WMjBuwr7yuC2 +GlRsovxbKR4+Uyf0d9Uu85QFKgOewj12K6B6Yift9wmSMgmZCH1m5vS5XYWsfe/P +XuQpyqdqKgeOvYodGiU6R0ngqy/+2bsHmvDZRhW6nZp5Oo4wszc7htqBGdh22lJo +slOe9034+1YkJSuzXwQ3ydOhi7M0zsJ/YjBRoQYYQ/fklXa7taSXncTY977Oju0/ +I4/XvTeiPu2OUHTdM2bv7cXnw3zAH0zRxFAe/0uT3hzfJ0p8MY8DaqtjAHdm3mpM +FjM06SkoTPnH69bDUTy3h0ziplvqraH5Yh+GhgHOomNqJPnqBBLAhuZdiqfciuEI ++Natp05PoUs+lO0B11/8RXmv8b56Vqimk2K1VMrmAoFdraGV4cJj9S1gMmphN1mZ +IYjYyfjKmNPNOK3A5vyHlBKoM8GRcLuOgPBnypnc2Ny/Xz6Aw22Ncq2hexAZlrSw +LHv5mdUgLxNisDjFiDzv1Faoxo4TmD6Juqc4N1KX1VC8n4M5NB4cwgRMzZQG9LH5 +Gz7jgzaYZx5ScWjPXs7Fxe/sKx6QNCiv9QicF+uECgCsXXYDICZbFj5dkKbF+M6a +U7cLtvP3P0uNa84Vsqsq0gTi/hPYnA0wMrIWNJVZRP81rkV12jBeIsDmQ8aTUc5W +qOn0x81MzXwUL4yPGWsMvWOYxE+6z+Qo3hai/2wU0U3G+J5AWb++Ip20du/SmNsU +f9R5ogFSOvSq1p+Fy3kW7Zhkb0Yy0VVOt2IMkbRo8MfSlvr9TUn0yipvHzwRzwTf +YhBr0POEUkOMYl6rrmpd7P4Y1oEnx3IcC2hdhpxSzIYW7eiRdYfmwdk3okph5qDd +FOydCTyANJnTlUBkVgGmk12DqMgoCcZpCJfHnmrXE60dQcjfDuoOoN3OT8nEW+tH +xbWnt6hOYPZVWMN4gw20wGBqTKue11jhk7e+L8ZMCMZMdAn9aCS36KvQyZDuUzDg +tYTa5Y8QsvaKi8EuoVIKSMXuBnzQYyTWsiwjtvAE9KhrQ+kFT4VTnSkBytApBjre +EJWabaclg16M+RQQ4FlOCm5etFIPoQEyCwYKD1ecdMe8poQ9x2es8DKphvpLVmeV +oX0YbWbMbr+DwlReHhBxAzHQQn2CcJwNM7yVU5sWiwI0WcHv9RCFELVreppKwfBk +PO7K/LaFAv9XXRq4naaqakFcF8/64z33Ehjumgajk5Ln+DwyJDXT6DUgSMIkwKK3 +OeqCRgYnwgwOi73SVa8gNJkTmdAnaAr5W4Z3omDAGq/QhMtKQ0lm2yPvDx42F4Ck +csdoKA+S/cUDy8baMyI34HVM8QpY40PpzQjMGUP46+/jwqzLSQO5NojmYiaeRCgz +og14ADvHTymfYM9N5lspMHpJu0uLNAr0mNfVIFZ+vCPy5hagaJiCfWkT6Zle3yr/ +5QA4byt9TIJHF6M3qLayKRi0SWwdiGaSLgM4HeXDSvK6FwTl+9kcro3WZJ6xDmPb +TxkqNsjpKVi7/r6H8yPY7PK+a8Ku2yt4KXvT4OhW9adQoCMHOvjvJlNV/Pk/TUhG +VcY6bxpDn/h2EZODK28LktzV3GTc1ISHmon49qJpjdCZaYXlEJDVnSR9UDJFRTjs +In36siHYVIxcSllhzKvU/XA6HveCq09eDIm+ZtbnixJLEqZPPP0EcE2ZtG1drOd3 +XARhZ+xgdROA0hZxyZVPa2bQsBQHiEFqZzrR4PfhznxL4XIRJmaLNFtCMewp/5By +7f9y3IVjG65JZ9pVHGpyWtOve7GagE0L4Eohe6kSxwix+3j5M0F0b9dKJnmziTAn +OdOr+xQZyUtWAWxWzTWykWEHIhaQ5lL2rjC5tDSnYHODSV7nkYB+sAWuTqtXoHuy +4EiVhuTq9zJmQMZq25Ussy7zt0PwNDPjpnC8kXcEiMLnaalq2tbVE38PFl2Q9Byw +IytNYkhpHOMwHnWVTww2IB7i3r8y33uUNRejpPoFboZa0uMB+BNKesodxxTG4rOX +5tXu/XLeq8/Ej7vlA2wxZtufyAaHIzRAgsiVP8pQ+qcUbrV5nJuwwAhfhWZIvJ/m +zsjEE/h69IQZX8WrwPk3V1eEB82IH9dcJdLz7rGH4tCBKWZdTJ0+EPubgJc6AFkp +9mR9eUtEK6lDIm0b04yILLjSpHEHfwxtXiYXaz7Ipo/TjdwXCmQuYrVRmtWQmVIN +eh+wR9LxDAXfzHP1GC1AkO6t3gNZziQrnze0F2Ot0dmOvywfbErXPn+wSNUC0VZQ +FaczBcRhZAGA2qB+FIMZexQzTMWcxu01LwfjeqNycuBpA44gKXwaVgwEuvcFJkyr +RaeqiMoLNTjEFC9Jr9WSIrTCn8tICMR6NQTYoh66r+exiQqi0IbXCjy3paGSYt3+ +VQTdpZ/q6+b5QBF52Lh99W5Pxo942oBfvYFf6miN+h/F6xzEdm7xZsN6oQdwtEA1 +3rcBWodmmR0/0DM0vVtJCkafsBR0jZHkIQ6ULm4iopPGhTAHYddEt9WPED/erbPK +s+/p+zt/Zxr3/5I+Klpld4RgAkS2c8xKNLgJPNEHjpUIEXc0A6kCuNPIiBJ0sHfw +pzmNUFii1p8mXyuWz6PBPLqCba/bmLMnOnBdIDhe8pMPP+fsK5AmFL0YT7ZAZWHN +qmcZne8KHWW0/QsKyClVurQvizw7VbnyleQnpQHhQEwazVcDt9FjjNRjf7fAQ5cU +Nl+X43ydslELGIMMX46uisYvGGw15BWm2LNc/QI5IEgEgju1KqAenFubcZmRV3Bw +nPV9UMnQAReWPmmHL35Oee4bcfNawtI/oxZ7tPw5FtLd12gxPuoTbrktfgRgcbYu +ShUnvtOAh90aUyCAsTGTed0Wf2qFX+Y8Ng4ArXOJ2asYiNcVKLnCPCew80Vb/QRI +c853QS0GneHTcOfrwO9W0HWciHqUQ4YfNzZfbABQGDhmAJWsuYGlSrHteH6swAff +RisAchzSb5VY1ZGsn35eTMvXUV6/YQTHnFWi6rASFIgUBL+Py7hPzfsTQwOS989Y +R1/a4p+I25zTDnuvbTMnVh3sR/j9Bg6pSjs6GPfadpLbH2vqb8NEZhyc9R4apWgq +tI4umRR9Eb8ZTm253GJivQ3KxyjdaZ91mIE9Gn0QuTZ+JqjeNvLcCAfhaGsEWnlV +Vx1/hhwniRmd0tTJPwr8+QRYrQunb14njvbgRDfGiuviSyXMzndx2GGTfwz392fn +HMIciHc+Chkq/1TLNssQfsKoEQVmM3HRg+tauMCDybeO1WQICldVNDGxr5kwdMvf +3aZmI/cZELnamNmyCEm3opaMZ4sxFKN/Hlq6IAGaJZ2BUJ88oHjj9ga9DwLx1KiN +BudUjrSK1v+5tylYQm45WrX+/nJaxe4zB80L/Ux41iP/635IHtNBijESDRvgvsG3 +AOz+sPwoB3eGi1+HqSO5Mmcax6YBGyK2hNvkt/sBOpZWAt2q+DZnaSokoFmTLun/ +15vZddb5IfjG4OjPxxGSf309nQlLn6bNfbtKWxVjD/5xx7LEQceWdx+3L3wp8UHl +iUl5LI3qbQBwL1sHNGB09EiH8lx4Tvnj3qt/HyjWDZzy2MgXakkKyVQxD2YVUMzi +whlUw2VtU4PnOymmCU+nBXAwnt3rfSfcLhaHi0/off8I7V1AN+VsX6X95M7UU0/0 +FQeksjP32zXcWnYhloqvwBjbwS5sNzNtsQqJUoBwzg5tzre8gdGeR23tCx05ay7m +lQz0m6XmVaDODmwkmWQh849Y/89pthF9Hq/QPqqTjCEjY/nBcm8GupZbQ1fOGgA5 +W+9W3f5Iw8dBUfzSbgyQjWJEg8v2eSy5P/ZKOvd+qw6spod6XUc5nLWyJRNzXEMB +4AZsa3ti38Tm1p2ANwYL99HdW/Bojh9LWHmo+Rwgq8Bo4Tbxbdzdh/BNLHxbymA8 +ZiaUQwQ6XxN0dmdb/l7ZciFSzl5GqhKRI1EoxzwqasA9P/gSqV8b4niTkPnV4oo0 +Z2Pt4TZU4tlhYW99arq3xQuZgMIfG2rMDTrkZkuYSIgx+B/w51jJwB1cfs4ZmupA +ChWxZx1e6gAEthBK4QZHaCgFDM3d9od1V/zqCK8PUZQXm3qeB4n2s0mM5an5y6yR +PHMEMc45r/i+4y/xU+x98GxY581FKGk06/xKhGUEXMt5TPhc1N89QEXD75cX/UE2 +l8RMUT482MWkWNODZFqr3OqS2ZPTPufRt7z8kRtp1srP/QP/ix1YqYuAvKNaxZL/ +LRrhrLVil4FynQ32lczSJgYc3sN8WjUFi+zQhgB8es2a+UZcOETT7GJWcKvQJ4tx +fJ5NW7DnXU9sIxFN6dQT7xVp2YHteM/aTTM3GpLwnK6C4sZXrvSnfEOVdvGDD/tD +Gut9oCQjCRHob79Up3qB3oUQOYJEj5meTD1lO86Y0nkv2y8M7itpieOh4P++AKNP +QhvqDVbI7FamabdKUYfAiZ6SD24SZlVyCckcxJfuf+G6jui94BH74k7S2NM/C66D +6naoLCumSlzgO6OHQNDq6wp0R7ggwLEyvCLtWO36NGdNsCfNzaTjvqX2jbqWawGP +gjf8jSvHo/4hMCAgk2/rCLwwN3U1GNvrCx1xNg96kebpdbqBkbEMxE8aSo/Ju4G4 +0xfgisN2B0/xaR5gmXk01+y3c6OjlgGL5kMbivv4c3H7yQoLKbd0mVMSs3FmCg5v +oGZ+PbGZuNRwUYjfYX0Yo6VswKkli5/+G3c4KcYGLX6CavgLzEj4tBdZyVxP3YAU +wBtXE55edGzfllq1Slhz+Bez0aQnCKMayVfVNLI1PENm3SHC/9xlSfdD/SLRezju +dvGvIoq7+67kIB+A/5it9hAoyrT3jXEVHlj3HDeKuj7fwUrq//cdIA85ltgrQbBT +euw/0MI+fXWqNM5ZTeforczmfTOiDnOZUNoOh8dF54f8BMoHiak9F5XCNRGJj4gI +cELzGWAWFvfVoojEiBCvEynKM2QPj67EvNRnJiv2elcpoJr3FbydcMU/6hkA8v19 +DG/p9kEC3up/vLtigNixIj6eMfOvum02eCtLbj1uhABvHt4NEjhn+vzwIO2gfyYN +ypCMDl9PpjrKb9EF/KC8dP/7gK0Zc0aDdUjOD6+l3euzv6x+gHX+KQxT+aqoE48E +PdqQzWUzrE7bL9YhsELuDdHomHSq6WD+qLbypB0ZZ3TY8J7NvCvckbDRIDuREetW +y8djsBRbh4DZfkqZBy4DFnXKqfVt0h/29/VYRwfCdxC1l9fHKnYGsV4KQCBsEVbF +nX5N6dMwzPwbzWh+5NBizDKCIfDooxBluss1WgngF0rwb5AGjv91ICDlaSHubu9K +wds92GhYqpULbycM1no+mcJ3zYHBUj2imM18e3VUiuP78Msb4Jo4VOFwb6DHZ3dk +L32j0ooImAOAesS9lvwIj9WvrnFg7NgX3+h6GYHw+/PFHrHMwXZmMAQQcfJGkmP/ +JhzsbX9QBGBOIYr+Ct3A51pw0UAIm3b0K0JsTz00PyqZpMVrVPGDezBUFk1r1Q+1 +wCJzB08/zl6E/uj88MqvrEVYz5nTXPjXExpfS6gmbpsCzE4YEPoNWMW23Jp/jTbY +vm7ZceydmWiV2+PfI/sRZn7NWZeQF8lyDGaXAXNPoR6B+biNiOjNFHazaknfpFXI +0V7PXJ0wCDX7axDYHoOogMvUR4PC7W7P4AYjUPh9Zld0sP4+mGBbcT9luRf56IPB +fACPSAg3VcRMIPkWwLLoVkYbEadPAsNgi2gnpN7TK9yUwnGjI3v7S5yux+HJ9D39 +jvJPEA4kiiS/ndxST2e0d63EjnZu2X1ZSXI+RftUpejzh/wqYq/3qxNk9JfAxjJ1 +Q4WhyYzltewiaqh4vT55d1R4v8JpQoN/BQ+HBZ05ifighoF+YLpy/mo3ZBi7RccX +FDNlP3ENNjmpwbuUvNAOHsv1bxSZYrEEU+wyfVTilXO2cSbFAD+iSMdBNiec+Iys +EIFBUSWLm5v9JaswtA7XODhL2uOTnOYIFHUmaGeHHbmHgsyhFHw928IhgBDSQN6e +BlqTM+vycRC4CDdlzaXdgu7u4qTLw649yVqgPsX8je4z+3D7PMTkfhGCa+6xHJOo +qfCAFpI2n4/8cFxaom6D4yPRa6d6QgzayudXkmSp7E4ibYRENrgBL/TAS9XRTXOG +fbctoMyDZU1cTMnjvdBfsyn4rMCiJ9bmxNGne+xLOvqbPAL1sV2n1NS1DEs1YCDY +EdHdgQhBscQio4yUhSsAHqPc6fadwokDbiGD2C85YZ3C+bR6FlGM+Jbl+TvvKuuS +UMP+7I81DVd2VNss9KZOOaA144e+HkfLZj0yE0cjyQpp8NtIyg4feGC++X1KduZ4 +Wqv7gPskq+Puwve05numuIU6mzqqjgIr9zK2b7uYgbbJjk0JabfTG3Ee0AEPtc+p +uDgLwjK7D1PQ0QjhjBRGR5V165UoX7RWcvl+dOPdLG/8DfOyN4A3o0FpR5TCKIbW +tYXJsbVaMo7myMCCxM9comN1WrHNZo0hA5tcXi4Fofy1xvWKlmK8xFmnNLkkUBwH +qIOSRnoP73wjlIvx5IBfBCAZz5isRmyB/1PzChYVyny3u2v7FSBoimu/hKhZTsbc +FyXD55HD2YkXyoKeH/4ThyH0zTvT1vUXqZ4h2LpOp1Z8FkyIi5pB/pWp2mNzHrIr +aIoUwvH/urYRyjd7R5/9a0d6oHTacUuJEfk0iOovX4XYiClH9khe6MqHlLVO+Eah +AXoOPYP4XsAopdXS9IsiMd69qD8JMQfrf8L9MQGjc/7aiCTJAMmPU4GN9Y9h21t2 +JX0gjquWT8Wu+qkMO+XAAlsENmBZlwz1HOFadLPim+CbHWZlX88+rqgOiAl8UxBq +2ZkdVW8BIqvFVH2db2C8UT40B12W/QAhkWbtl+l8FioR6tuWuCAgQI+n9i4Zej64 +CssVZtk1y4UCka/aMzRB74xxTQKtjgb+ULO8Lk3OLopOMhH2zLoz0zIiPl6lqVw4 +M310GuUViPCQcAVlzbYoMCQiKIBFoeOV0mm7Z1MmpCoopyHAAZgP17k41P+Gx3j4 +yYg06GDtdxCd5gYocBGSTnUOLg9zd3CnEZxlSgUntoLoNlcCRwS/yNAxKA6R3Vf2 +T/KUXLolNNe35RSxMhIL6EFtSZc1e3G/15wqrSRdQj9DbKoXetRQcKI3zqv3WQDi +THa0zVc7Ki1GeBn0aRkAlNRU9emTYDaImRk2MlGrWGTRaj3Gw3xJxDoV8dP4Nlka +ntwJ4WIlSo+l7+C4cj/uloWs4ppTXSnEwZ/aseIqwG4jgGxMj2oN8nijqa0itZti +rH3irhVT91ZtK1s2iY5SVDd76wgeX1BknyMBm2WsWHDO+K7l5LmeKLXiKmkPW1x6 +3O8FvOIqIyc15HB1ZpQsZfdMRKypbdo28s2NGZQSTCzfElJboAoJcMIXKlL4pOGt +yxtLOjZ1oE+yH1yIOX38vHc0Pt3MWxpYWp35MoFCG39rPrfJ1vjP5MudOQvvBw9q +uNaL7pndIKpZ2dHiKFJjTgs/RQJH5w5/fFa5OIircQc9OO0tnN1cpXMWUpdkmjZZ +x3fZnHMd/0uq1kVUFubkwZpszpdmS1JxiePY3LfArbQaVDVSgidPYlYqq5g40GJa +BSDFrbTT/62qt41EZzW9DR1rO5WV9gkaFscN3pLFUEjJYHkvacizh4SXKtaL57n7 +rwFoQfYZ7uDH1R+uGaqEepeGRLa4cyQ0A6lhKCrZgww9wKW24Ra66Trm/Yy4F4UW +2SUCChxuNFcNSbKgTod82LfIWaCISIq8n6Ykn7GZYWuQK03IiCAAnXv7I79/mIPb +zpivvMYkfn1WAgpc6nR8sTK7wHvet3J+m2/oxqIfm0tOvxYMwMlnE7DFvB5man2W +Dlh8uzxEFj+z7b0TVY/3gnSFFD1a4bhhen3h91qEWRdCRLbyYD+qzDqr9vGCnj5h +toaXixOxt35H1489ymdrXiqi4zqwN994yJqecVt2Quu1/Ay/eC7fzKLcCEZDsMdb +1SFDbfLhxuunbSIkNKBOh+FyCCkB+LnpSgrZK0aYE7/RX4gOmtyle4QrSXvZzm7Y +FFMdWYGVud4Oko/5LySG52qWbaKTnRkmhk0hRx6qLIYK6rTa8zcS4L/pEH1yoDP2 +HR8ChrRH0oXAISyByQXbaYxjzTLg4b2fczVMBCJ8+8Blxn3jqaqSlENGqhphs04R +UwHR9QSTYNdkIOBvp8dJquM0P88E5hm6rrYtY/4+bMRwi+tc8qLx1xhcqazRViU8 +fXWckMFnN+V5k/kGSNafU625auB409ysOMMDL04P1xu+FAWHUup5oFf0TBDWdIGT +qjskL51MUQwiIHu4Kt6MGBVfpd046SiY0xO0kgIiI9InncXHEG0ld1+Mu/ecPXmA +hGnb+lgl8S3/ILrCmbRJ+qO8abVJuayP35E4E6MN+c1AcOFFBgrq6DVKDv3mtb2o +cQdSpb7sQeFevQ7QFE5AOsRPgR1emRRLzxRa7m6+Q68eSk17lpfCOWCMqpg1d8Ys +G/j9Flt+D/xf+bEeMKzfQ0JAfKDG7T+7Up2+vTuRb9vnDrPgixxc2DIkBXyChVFZ +7Fwed0MCqDicxBGcZT4ztyZXn7PdKPiDfWHJAwGd58/uINj6jzNy6BONx49+2Gjt +Vt37qaPnPFLAqdneK719ZExJzg6OeXAkaCkF8dsn3j/K6stsOT1N2d3TF78VA+hw +wZhJzd0VkqtDzFR6/X19Z82BIBoPhYFAVTrL61/PJbChT4ol54hHHwEcOUq3XbnZ +c2GRxh3P3DF1uJdn0YDU864mSvNQ7X7+bCfIeBM6bqk+a8o2DKkpv1yvBqu7Ibn0 +ii1nGNCCx2b7I8YBGb4blDeLnbjXvhbIjwDi69zXThB9JcVXNqk8+t3I6eFr0lKf +E2Ru0VCqaP+7GJAtc1gM3BRJfl2OqNgJXOkW9FjGaWZQUSfrQSU/4CyxoIQJgKIV +kBB68gW5/R52wYGolj5hIaKd4A9l8++oUY+DoozvdDt7TnO/iWVAbaooOux8s1EQ +u2n8uX38IOgRV9ULzOtYC7ZvsDmcGja3GsFHc72jKygsaX77ovQlYx7c6yyxf2LK +ck1Nlxpmyc09OKojoJuKvf4HNg60wrJ4z0fYrdLGbMyt4eiAaaybJIceZmGHp+Pu +gUezQpHthMzi33Zdb+zx0Tj1J4M2dcoDSAZlV0ZM47IGqiLS8vyg0XC+HmWN19B5 +CIGtLmNXQawTYbuAoxJNUOyJrEgQLATr9uxtKasx6hUIBLVcEVMX9ExYOxrZ1X1T +Kfo56Kngk7yNfbqWDeQyFIFpg11MQPGGQHiMzLKW5w2M4nVllIRDO1XbeIZKDEF3 +YyjlpBByacTyfOyx3HdFTPa4KJ6aJZckuBMUY1jPX1viv0ddP71N2vU38sbcbmvA +RG1jhxWHg/qFT48cJtAAeyhIWwZpe3zddClztlSgL3lEjiWiG693+n0PImgrvEuZ +e9me12FpptWdLXaSrhyYWQd6h1tsLTuUmTGJfpx7WACJrnjYtP8/nN5+VdxThogJ +6HRWebK87IFCisdbGBYtxrfDyE+bqqx18ILIr22+cKFh2+u1FK3begaSkvWIxHfK +l+itux2ZBYPqpArQEmu2/oKTDFbb+VMyRuMBMOMaZIyDoFiKbtiJ7sSYzLH61B8i +S1exd8BosnURyypkqxcESntsD23dSJ92WKv5xMBGmxb/0794oc8ns/TpXbEQ15+7 +bPpL7YiDm/MXlDsnhw+ryaP8I5eFQ52L5MbyVZCZiuek6h4mOuYUrRYzkDJyNNdb +MmBkFozVobbyc6idhDsSo3UHEA6f915gBNZcBziQ5SQKojun9Uk76sCG/6mFQhLy +naFkse5K1V1hUpxXzcaFQMlgaFTPsiiLb/d5BGksG8hThAh0B/z9NjV3Ik8TGe1l +G52gRt/E9XlHkI7s74r2LfDpiHC4BCx02K7hmaXvhGoBTL5J5cG1/DauBvgg5AD2 +2x/dUZTTWoJGTEvQwXbw96+JGDGiWSie4wn9/sYpGntU2x5NvM6ZnyO1fsdXlsHh +ZCgIzz+iTleAaSy4/4P+L+CJIJstgYYMldmD+MmdZRob+LJl0Vxk6NlP2ee6DzpG ++3E73tJv10o4EbwP83alqYT080lg94bKdyo5/5oWTxvQaWMHg7b8SHvsRQwiRf18 +3q2imGO66ifm8aTbQIt6SFJcNQf6BSaiFHVUM82Vl1QtPofNt4I+mJaPo7+k+Hwg +8hRMS/xaMwwYuWP1c/c67yyL0FugbRDKHWLF4fpROv+odnQPLgenp829iSAPceRL +URw2RrFeqyTs8bH76a9c9JDgCViAV+Su2kiina+sIgVpeTvR1lMI+fUmjXoplDsj +ozyBma+puh7QR1D4lW6Ml6+bzwwc8zgcVVHPyPrX6ZS93UOpONPlErfWYRNKaGQd +CfUzXWvhMXw0cvNBJud0xv0aPdUEvs7Oy4/xqkcOCtlmg5+uTka/znUFQ7XidB22 +uHlAKBtxRG2uJHPSiL696EL78yYd9cyl9zxQNp+M9yQlCV8hA/qEkdaI6rmTpwcR +r6G+nteO0huPI+EN9HaNGZn705pVj8+PB5m2zJraWrFJiyLXSdBx8xX19eAYozV3 +p7XYRuu13OdumdiJiVLaK9sFSD4ZD3/Gu5AdnB/eXpYWuaX9YWtzH6SeSnotp1zv +YDVQa272w6XN7X3rKQoVPdjjOu3KwOwmH+mzpOLlZql7Stm0sH/UU+08oB1GgV7Y +n4kVzrnjlHA2Oo46s4bDRuF110IOVpiQZQ7aCWFWEzHVSeS8WQ/eUKUiUu44m4Zx +jkFeMxPXbMIcJLgeqj/7ehammNirxTkYMJedzkELiWEwWlCSgRVHheH1RXyiMKBL +qcfpFCNi1qCBf0JZahlZS96+/yMeYBw77mTpMOGOhexHhOeZAggNZQzKqwfFr9gg +cOeSnu9IoASkfK3nw1VWWQg1AvIVn8Xhws+SUKfZNTVs8FsPslMYdL3jeZNmpkMM +cuVVBG1T+4tru6MbulwbFZXNIoLQuKcDOy11qzwpYC6sStvM2j1iNkDiJjjIxfYs +TimCDtw/R/6WuQShzcNKRE3uCoV6y+AVyptZSvNRxwJFalXjyoLeq0lpZ1Ack3nT +ZsTOebrGi8U5q8Sgu88RxbS0V0guI0ql7XA/8spdY+LEthwWzbwrV3QDPT4wSIJh +zp9WSKNLnp4JbgYYZFgoo0RuNHbhZuVYLSVsWbVrjzt9qfuJmVrBpvujMUH5YrBI +9ZvxbKxoX4E5JlzgDnZ9PEgpSayMpt3opjqyBMqF19rA2n99bgvWOjuUTGgmfPfJ +onMWEun9xCewimhYsRVeGykYjmJfl6s/17kSO4IfQTUXMeeKCzO6Buk/Vx1pWTl+ +l0KWHzqhlj59FjrSlGL7dNWuVi0FZZKBBJrz7CX3CX0n66YGbs93pocCrDAbrsc6 +9UrYCzZQwdGrYUHokExQQ3bNPf+MRArzLTfbMz3HdUdIpYHldNjAg9H6FN8SC1X+ +4hAIo//cP8JShYtNJTxeVKySh77gKmDL +-----END AGE ENCRYPTED FILE----- diff --git a/modules/by-name/lf/lf/secrets/update_secret.sh b/modules/by-name/lf/lf/secrets/update_secret.sh new file mode 100755 index 00000000..b29fdb86 --- /dev/null +++ b/modules/by-name/lf/lf/secrets/update_secret.sh @@ -0,0 +1,31 @@ +#!/usr/bin/env nix +#! nix shell nixpkgs#age nixpkgs#jq nixpkgs#dash --command dash +# shellcheck shell=dash + +cleanup() { + [ "$key_file" ] && rm "$key_file" +} +trap cleanup EXIT + +root="$(git rev-parse --show-toplevel)" +output_file="$(dirname "$0")/cd_paths.age" + +update_lf_cd_paths() { + echo "Starting to update the lf/cd_paths.age file.." + + key_file="$(mktemp)" + + nix eval -f "$root/secrets.nix" --json | jq --raw-output '.["modules/by-name/lf/lf/secrets/cd_paths.age"].publicKeys | join("\n")' >"$key_file" + + # `lf-make-map` is provided by the dev shell + { + lf-make-map --quiet --depth 4 visualize ~/media ~/repos ~/school | sed 's|\(.*\)|# \1|' + lf-make-map --quiet --depth 4 generate ~/media ~/repos ~/school + } | age --recipients-file "$key_file" --encrypt --armor --output "$output_file" + + echo "Finished updating the lf/cd_paths.age file.." +} + +update_lf_cd_paths + +# vim: ft=sh -- cgit 1.4.1