diff options
Diffstat (limited to 'modules/by-name')
64 files changed, 5068 insertions, 0 deletions
diff --git a/modules/by-name/ad/adb/module.nix b/modules/by-name/ad/adb/module.nix new file mode 100644 index 00000000..ec5d4be6 --- /dev/null +++ b/modules/by-name/ad/adb/module.nix @@ -0,0 +1,22 @@ +{ + lib, + config, + ... +}: let + cfg = config.soispha.services.adb; +in { + options.soispha.services.adb = { + enable = lib.mkEnableOption "Android adb bridge"; + user = lib.mkOption { + type = lib.types.str; + example = "soispha"; + default = "soispha"; + description = "Username to grant access to adb bridge"; + }; + }; + + config = lib.mkIf cfg.enable { + programs.adb.enable = true; + users.users."${cfg.user}".extraGroups = ["adbusers"]; + }; +} diff --git a/modules/by-name/ba/backup/module.nix b/modules/by-name/ba/backup/module.nix new file mode 100644 index 00000000..92700bf2 --- /dev/null +++ b/modules/by-name/ba/backup/module.nix @@ -0,0 +1,51 @@ +{ + lib, + pkgs, + config, + ... +}: let + backup-script = pkgs.writeShellScriptBin "backsnap" '' + set -xeu; + + ${pkgs.util-linux}/bin/mount --mkdir "/dev/disk/by-uuid/${cfg.backupDiskUuid}" "/run/media/${cfg.backupDiskUuid}"; + ${pkgs.snap-sync-forked}/bin/snap-sync-forked --UUID "${cfg.backupDiskUuid}" --noconfirm; + ${pkgs.util-linux}/bin/umount "/run/media/${cfg.backupDiskUuid}"; + ''; + + cfg = config.soispha.services.backup; +in { + options.soispha.services.backup = { + enable = lib.mkEnableOption "backups with my forked snap-sync"; + backupDiskUuid = lib.mkOption { + type = lib.types.str; + example = lib.literalExpression "d1d20ae7-3d8a-44da-86da-677dbbb10c89"; + description = "The UUID of the backup disk"; + }; + }; + + config = lib.mkIf cfg.enable { + systemd = { + services.backup = { + wantedBy = lib.mkForce []; + unitConfig = { + Description = "Backup the last snapshots of the persitent-storage subvolume."; + }; + serviceConfig = { + Type = "oneshot"; + ExecStart = "${backup-script}/bin/backsnap"; + }; + }; + + timers.backup = { + wantedBy = ["timers.target"]; + unitConfig = { + Description = "Backup 15min after boot and every 8 hours"; + }; + timerConfig = { + OnBootSec = "15min"; + OnUnitActiveSec = "8h"; + }; + }; + }; + }; +} diff --git a/modules/by-name/bl/bluetooth/module.nix b/modules/by-name/bl/bluetooth/module.nix new file mode 100644 index 00000000..bf1c6a90 --- /dev/null +++ b/modules/by-name/bl/bluetooth/module.nix @@ -0,0 +1,20 @@ +{ + config, + lib, + ... +}: let + cfg = config.soispha.bluetooth; +in { + options.soispha.bluetooth = { + enable = lib.mkEnableOption "an integrated bluetooth setup."; + }; + + config = lib.mkIf cfg.enable { + hardware = { + bluetooth = { + enable = true; + powerOnBoot = !config.soispha.laptop.enable; + }; + }; + }; +} diff --git a/modules/by-name/bo/boot/boot_pictures/gnu.png b/modules/by-name/bo/boot/boot_pictures/gnu.png new file mode 100755 index 00000000..d07dee3e --- /dev/null +++ b/modules/by-name/bo/boot/boot_pictures/gnu.png Binary files differdiff --git a/modules/by-name/bo/boot/boot_pictures/gnulin_emb_1.png b/modules/by-name/bo/boot/boot_pictures/gnulin_emb_1.png new file mode 100755 index 00000000..483f2681 --- /dev/null +++ b/modules/by-name/bo/boot/boot_pictures/gnulin_emb_1.png Binary files differdiff --git a/modules/by-name/bo/boot/boot_pictures/gnulin_emb_2.png b/modules/by-name/bo/boot/boot_pictures/gnulin_emb_2.png new file mode 100755 index 00000000..48cd6ad7 --- /dev/null +++ b/modules/by-name/bo/boot/boot_pictures/gnulin_emb_2.png Binary files differdiff --git a/modules/by-name/bo/boot/iso_entry/archlive_iso.nix b/modules/by-name/bo/boot/iso_entry/archlive_iso.nix new file mode 100644 index 00000000..d19a4a87 --- /dev/null +++ b/modules/by-name/bo/boot/iso_entry/archlive_iso.nix @@ -0,0 +1,77 @@ +{pkgs ? (builtins.getFlake "nixpkgs").legacyPackages."x86_64-linux"}: let + signing_key = import ./signing_key.nix {inherit pkgs;}; + + checked_iso = pkgs.stdenv.mkDerivation { + pname = "archlinux-iso"; + version = "2024.05.01"; + + srcs = [ + (pkgs.fetchurl { + url = "https://archlinux.org/iso/2024.05.01/archlinux-2024.05.01-x86_64.iso.sig"; + hash = "sha256-QOGYng6a7zA5EJKGotDccJ7fD2MmPPXQEdVr1kjJvi4="; + }) + (pkgs.fetchurl { + url = "https://mirror.informatik.tu-freiberg.de/arch/iso/latest/archlinux-2024.05.01-x86_64.iso"; + hash = "sha256-G0oE74pzUIUqEwcO5JhEKwh6YHoYhAtN19mYZ+tfakw="; + }) + (pkgs.fetchurl { + url = "https://archlinux.org/iso/2024.05.01/b2sums.txt"; + hash = "sha256-HSMS13hHXFKKQsCA8spa7XtirHCBTmePwhOsStVPbHw="; + }) + ]; + + dontUnpack = true; + + nativeBuildInputs = with pkgs; [ + sequoia-sq + ]; + + buildPhase = + /* + bash + */ + '' + cp -r "${signing_key}" ./release-key.pgp + for src in $srcs; do + cp -r "$src" "$(stripHash "$src")" + done + + sed '2d;3d;4d' b2sums.txt > b2sums_clean.txt + + # As per the directions from: https://archlinux.org/download/ + + # blake hash check + b2sum -c ./b2sums_clean.txt + + # pgp signature check + sq verify --signer-file release-key.pgp --detached archlinux-2024.05.01-x86_64.iso.sig archlinux-2024.05.01-x86_64.iso + ''; + + installPhase = '' + cp archlinux-2024.05.01-x86_64.iso "$out"; + ''; + }; +in + pkgs.stdenv.mkDerivation { + name = "live_iso_boot_entry"; + + src = checked_iso; + + dontUnpack = true; + + nativeBuildInputs = with pkgs; [ + libarchive # for bsdtar + ]; + + buildPhase = '' + mkdir iso + bsdtar -xf "$src" -C iso + ''; + + installPhase = '' + install -D ./iso/arch/boot/x86_64/initramfs-linux.img "$out/live/initramfs-linux.img" + install -D ./iso/arch/boot/x86_64/vmlinuz-linux "$out/live/vmlinuz-linux" + + install -D "$src" "$out/archlinux.iso" + ''; + } diff --git a/modules/by-name/bo/boot/iso_entry/signing_key.nix b/modules/by-name/bo/boot/iso_entry/signing_key.nix new file mode 100644 index 00000000..788447be --- /dev/null +++ b/modules/by-name/bo/boot/iso_entry/signing_key.nix @@ -0,0 +1,18 @@ +{pkgs ? (builtins.getFlake "nixpkgs").legacyPackages."x86_64-linux"}: +pkgs.stdenv.mkDerivation { + name = "archlinux_signing_keys"; + + outputHash = "sha256-evGWzkxMaZw3rlixKsyWCS/ZvNuZ+OfXQb6sgiHz9XY="; + outputHashAlgo = "sha256"; + NIX_SSL_CERT_FILE = "${pkgs.cacert}/etc/ssl/certs/ca-bundle.crt"; + + nativeBuildInputs = with pkgs; [ + sequoia-sq + ]; + + dontUnpack = true; + + buildPhase = '' + sq --verbose --no-cert-store --no-key-store network wkd fetch pierre@archlinux.org --output "$out" + ''; +} diff --git a/modules/by-name/bo/boot/module.nix b/modules/by-name/bo/boot/module.nix new file mode 100644 index 00000000..711e9d23 --- /dev/null +++ b/modules/by-name/bo/boot/module.nix @@ -0,0 +1,130 @@ +{ + config, + lib, + pkgs, + ... +}: let + cfg = config.soispha.boot; +in { + options.soispha.boot = { + enable = lib.mkEnableOption "Bootloader configuration"; + # TODO: Add this option <2024-05-16> + # enableIsoEntry = lib.mkEnableOption "an tails iso boot entry"; + }; + + config = lib.mkIf cfg.enable ( + # let + # cfg = config.boot.loader.systemd-boot; + # inherit (config.boot.loader) efi; + # + # esa = n: lib.strings.escapeShellArg n; + # + # bootMountPoint = + # if cfg.xbootldrMountPoint != null + # then cfg.xbootldrMountPoint + # else efi.efiSysMountPoint; + # + # nixosDir = "/EFI/nixos"; + # + # # FIXME: This system has two big problems: + # # 1. It does not updated files, which still have the same name + # # 2. It forgets about files, which were 'deleted' in this configuration (these just + # # stay on disk forever) <2024-05-11> + # copyExtraFiles = '' + # echo "[systemd-boot] copying files to ${bootMountPoint}" + # empty_file=$(mktemp) + # + # ${lib.concatStrings (lib.mapAttrsToList (n: v: + # /* + # bash + # */ + # '' + # if ! [ -e ${esa "${bootMountPoint}/${n}"} ]; then + # install -Dp "${v}" ${esa "${bootMountPoint}/${n}"} + # install -D "$empty_file" ${esa "${bootMountPoint}/${nixosDir}/.extra-files/${n}"} + # fi + # '') + # cfg.extraFiles)} + # + # ${lib.concatStrings (lib.mapAttrsToList (n: v: + # /* + # bash + # */ + # '' + # # if ! [ -e ${esa "${bootMountPoint}/loader/entries/${n}"} ]; then + # install -Dp "${pkgs.writeText n v}" ${esa "${bootMountPoint}/loader/entries/${n}"} + # install -D "$empty_file" ${esa "${bootMountPoint}/${nixosDir}/.extra-files/loader/entries/${n}"} + # # fi + # '') + # cfg.extraEntries)} + # ''; + # in + { + # FIXME: Reactviate this whole iso thing when a disko redeploy is done. + # (and switch to tails instead of arch) <2024-05-12> + # + # system.activationScripts = { + # copyExtraFilesForBoot = copyExtraFiles; + # }; + + boot = { + initrd = { + kernelModules = ["nvme" "btrfs"]; + }; + + kernelPackages = pkgs.linuxPackages_latest; + + lanzaboote = { + enable = true; + pkiBundle = "/etc/secureboot"; + + settings = { + # Disable editing the kernel command line (which could allow someone to become root) + editor = false; + default = "@saved"; + }; + }; + + loader = { + systemd-boot = { + # Lanzaboote currently replaces the systemd-boot module. + # This setting is usually set to true in configuration.nix + # generated at installation time. So we force it to false + # for now. + enable = false; + + # extraEntries = { + # "live.conf" = '' + # title Archlinux Live ISO + # linux /live/vmlinuz-linux + # initrd /live/initramfs-linux.img + # options img_dev=${config.soispha.disks.disk} img_loop=/archlinux.iso copytoram + # ''; + # }; + # + # extraFiles = let + # iso = import ./archlive_iso.nix {inherit pkgs;}; + # in { + # "archlinux.iso" = "${iso}/archlinux.iso"; + # "live/initramfs-linux.img" = "${iso}/live/initramfs-linux.img"; + # "live/vmlinuz-linux" = "${iso}/live/vmlinuz-linux"; + # }; + }; + + grub = { + enable = false; + # theme = pkgs.nixos-grub2-theme; + splashImage = ./boot_pictures/gnu.png; + efiSupport = true; + device = "nodev"; # only for efi + }; + + efi = { + canTouchEfiVariables = true; + efiSysMountPoint = "/boot"; + }; + }; + }; + } + ); +} diff --git a/modules/by-name/cl/cleanup/module.nix b/modules/by-name/cl/cleanup/module.nix new file mode 100644 index 00000000..f8307b73 --- /dev/null +++ b/modules/by-name/cl/cleanup/module.nix @@ -0,0 +1,19 @@ +{ + config, + lib, + ... +}: let + cfg = config.soispha.cleanup; +in { + # remove all the bloat, which NixOS installs by default + options.soispha.cleanup = { + enable = lib.mkEnableOption "avoiding of nixos' default installed packages"; + }; + + config = lib.mkIf cfg.enable { + programs.nano.enable = false; + environment = { + defaultPackages = lib.mkForce []; + }; + }; +} diff --git a/modules/by-name/dc/dconf/module.nix b/modules/by-name/dc/dconf/module.nix new file mode 100644 index 00000000..e4a1c7a9 --- /dev/null +++ b/modules/by-name/dc/dconf/module.nix @@ -0,0 +1,8 @@ +{...}: { + # needed to make home-manager play nice with some apps. See: + # https://nix-community.github.io/home-manager/index.xhtml#_why_do_i_get_an_error_message_about_literal_ca_desrt_dconf_literal_or_literal_dconf_service_literal + programs.dconf.enable = true; + # FIXME: This should also be parameterized. <2024-05-16> +} +# vim: nolinebreak nowrap textwidth=0 + diff --git a/modules/by-name/di/disks/fstrim.nix b/modules/by-name/di/disks/fstrim.nix new file mode 100644 index 00000000..6daeb65e --- /dev/null +++ b/modules/by-name/di/disks/fstrim.nix @@ -0,0 +1,42 @@ +{ + pkgs, + lib, + cfg, +}: { + timers.fstrim = lib.mkIf cfg.ssd { + wantedBy = ["timers.target"]; + wants = ["fstrim.service"]; + unitConfig = { + Description = "Discard unused blocks once a week"; + Documentation = "man:fstrim"; + ConditionVirtualization = "!container"; + ConditionPathExists = "!/etc/initrd-release"; + }; + timerConfig = { + OnCalendar = "weekly"; + AccuracySec = "1h"; + Persistent = "true"; + RandomizedDelaySec = "6000"; + }; + }; + services.fstrim = lib.mkIf cfg.ssd { + wantedBy = lib.mkForce []; + unitConfig = { + Description = "Discard unused blocks on filesystems from /etc/fstab"; + Documentation = "man:fstrim(8)"; + ConditionVirtualization = "!container"; + }; + serviceConfig = { + Type = "oneshot"; + ExecStart = "${pkgs.util-linux}/bin/fstrim --listed-in /etc/fstab:/proc/self/mountinfo --verbose --quiet-unsupported"; + PrivateDevices = "no"; + PrivateNetwork = "yes"; + PrivateUsers = "no"; + ProtectKernelTunables = "yes"; + ProtectKernelModules = "yes"; + ProtectControlGroups = "yes"; + MemoryDenyWriteExecute = "yes"; + SystemCallFilter = "@default @file-system @basic-io @system-service"; + }; + }; +} diff --git a/modules/by-name/di/disks/hibernate.nix b/modules/by-name/di/disks/hibernate.nix new file mode 100644 index 00000000..a50e5b57 --- /dev/null +++ b/modules/by-name/di/disks/hibernate.nix @@ -0,0 +1,45 @@ +{pkgs}: { + services = { + hibernate-preparation = { + wantedBy = ["systemd-hibernate.service"]; + unitConfig = { + Description = "Enable swap file and disable zram before hibernate"; + Before = "systemd-hibernate.service"; + }; + serviceConfig = { + Type = "oneshot"; + User = "root"; + ExecStart = "${pkgs.bash}/bin/bash -c \"${pkgs.util-linux}/bin/swapon /swap/swapfile && ${pkgs.util-linux}/bin/swapoff /dev/zram0\""; + }; + }; + + hibernate-resume = { + wantedBy = ["systemd-hibernate.service"]; + unitConfig = { + Description = "Disable swap after resuming from hibernation"; + After = "hibernate.target"; + }; + serviceConfig = { + Type = "oneshot"; + User = "root"; + ExecStart = "${pkgs.util-linux}/bin/swapoff /swap/swapfile"; + }; + }; + # swapoff-start = { + # wantedBy = ["multi-user.target"]; + # unitConfig = { + # Description = "Disable hardware swap after booting"; + # }; + # serviceConfig = { + # Type = "oneshot"; + # User = "root"; + # ExecStart = "${pkgs.util-linux}/bin/swapoff /swap/swapfile"; + # }; + # }; + systemd-hibernate.serviceConfig.Environment = "SYSTEMD_BYPASS_HIBERNATION_MEMORY_CHECK=1"; + systemd-logind.serviceConfig.Environment = "SYSTEMD_BYPASS_HIBERNATION_MEMORY_CHECK=1"; + }; + sleep.extraConfig = '' + HibernateDelaySec=5m + ''; +} diff --git a/modules/by-name/di/disks/module.nix b/modules/by-name/di/disks/module.nix new file mode 100644 index 00000000..c0e5bcfd --- /dev/null +++ b/modules/by-name/di/disks/module.nix @@ -0,0 +1,133 @@ +{ + config, + lib, + pkgs, + ... +}: let + # FIXME: The iso redeploy requires a bigger efi partition <2024-05-12> + cfg = config.soispha.disks; + defaultMountOptions = [ + "compress-force=zstd:15" # This saves disk space, at a performance cost + "noatime" # should have some performance upsides, and I don't use it anyways + "lazytime" # make time changes in memory + ]; +in { + options.soispha.disks = { + enable = lib.mkEnableOption "disk setup with disko"; + + disk = lib.mkOption { + type = lib.types.path; + example = lib.literalExpression "/dev/disk/by-uuid/0442cb6d-f13a-4635-b487-fa76189774c5"; + description = "The disk used for installing the OS."; + }; + + ssd = lib.mkEnableOption "ssd specific improvements, like trim"; + + swap = { + uuid = lib.mkOption { + type = lib.types.str; + example = lib.literalExpression "d1d20ae7-3d8a-44da-86da-677dbbb10c89"; + description = "The uuid of the swapfile"; + }; + resumeOffset = lib.mkOption { + type = lib.types.str; + example = lib.literalExpression "134324224"; + description = "The resume offset of the swapfile"; + }; + }; + }; + + config = lib.mkIf cfg.enable { + systemd = lib.recursiveUpdate (import ./hibernate.nix {inherit pkgs;}) (import ./fstrim.nix {inherit pkgs lib cfg;}); + + disko.devices = { + disk = { + main = { + device = cfg.disk; + content = { + type = "gpt"; + partitions = { + root = { + size = "100%"; + name = "root"; + content = { + type = "luks"; + name = "nixos"; + extraOpenArgs = ["--allow-discards"]; + content = { + type = "btrfs"; + extraArgs = ["-f" "--label nixos"]; # Override existing partitions + subvolumes = { + "nix" = { + mountpoint = "/nix"; + mountOptions = defaultMountOptions; + }; + "persistent-storage" = { + mountpoint = "/srv"; + mountOptions = defaultMountOptions; + }; + "persistent-storage@snapshots" = { + mountpoint = "/srv/.snapshots"; + mountOptions = defaultMountOptions; + }; + "swap" = { + mountpoint = "/swap"; + mountOptions = defaultMountOptions; + }; + }; + }; + }; + }; + boot = { + type = "EF00"; + size = "512M"; + name = "boot"; + content = { + type = "filesystem"; + format = "vfat"; + mountpoint = "/boot"; + }; + }; + }; + }; + }; + }; + nodev = { + "/" = { + fsType = "tmpfs"; + mountOptions = ["defaults" "size=4G" "mode=755"]; + }; + "/tmp" = { + fsType = "tmpfs"; + mountOptions = ["defaults" "size=16G" "mode=755"]; + }; + }; + }; + fileSystems = { + "/srv" = { + neededForBoot = true; + }; + "/swap" = { + neededForBoot = true; + }; + }; + swapDevices = [ + #{ + # device = "/swap/swapfile"; + # priority = 1; # lower than zramSwap, just in case + # # size = 2048; # TODO: can nixos create a btrfs swapfile correctly? + #} + ]; + zramSwap = { + enable = true; + priority = 10; # needs to be higher than hardware-swap + }; + boot = { + kernelParams = [ + "resume_offset=${cfg.swap.resumeOffset}" + "zswap.enabled=0" # zswap and zram are not really compatible + ]; + resumeDevice = "/dev/disk/by-uuid/${cfg.swap.uuid}"; + }; + }; +} diff --git a/modules/by-name/do/documentation/module.nix b/modules/by-name/do/documentation/module.nix new file mode 100644 index 00000000..4616a991 --- /dev/null +++ b/modules/by-name/do/documentation/module.nix @@ -0,0 +1,25 @@ +{ + config, + lib, + ... +}: let + cfg = config.soispha.documentation; +in { + options.soispha.documentation = { + enable = lib.mkEnableOption "documentation"; + }; + config = lib.mkIf cfg.enable { + documentation = { + nixos = { + # FIXME: This results in a evaluation failure (with lanzaboote options) <2024-05-23> + includeAllModules = false; + + enable = true; + }; + dev = { + # Add man pages aimed at developers (I guess c library stuff, and the like) + enable = true; + }; + }; + }; +} diff --git a/modules/by-name/fo/fonts/emoji_font.xml b/modules/by-name/fo/fonts/emoji_font.xml new file mode 100644 index 00000000..f3f6bb3e --- /dev/null +++ b/modules/by-name/fo/fonts/emoji_font.xml @@ -0,0 +1,22 @@ +<?xml version="1.0"?> +<!DOCTYPE fontconfig SYSTEM "fonts.dtd"> +<fontconfig> + <alias binding="weak"> + <family>monospace</family> + <prefer> + <family>emoji</family> + </prefer> + </alias> + <alias binding="weak"> + <family>sans-serif</family> + <prefer> + <family>emoji</family> + </prefer> + </alias> + <alias binding="weak"> + <family>serif</family> + <prefer> + <family>emoji</family> + </prefer> + </alias> +</fontconfig> diff --git a/modules/by-name/fo/fonts/module.nix b/modules/by-name/fo/fonts/module.nix new file mode 100644 index 00000000..abd5664b --- /dev/null +++ b/modules/by-name/fo/fonts/module.nix @@ -0,0 +1,55 @@ +{ + config, + lib, + pkgs, + ... +}: let + cfg = config.soispha.fonts; +in { + options.soispha.fonts = { + enable = lib.mkEnableOption "fonts"; + + fonts = lib.mkOption { + type = lib.types.listOf lib.types.str; + example = lib.literalExpression ''["SourceCodePro" "Overpass" "FiraCode"]''; + default = [ + "SourceCodePro" + "Overpass" + ]; + description = "The nerd-fonts to install"; + }; + + enableEmoji = lib.mkEnableOption "emoji font support"; + }; + + config = lib.mkIf cfg.enable { + fonts = { + packages = let + nerdFont = pkgs.nerdfonts.override { + inherit (cfg) fonts; + }; + in + [ + nerdFont + ] + ++ (with pkgs; [liberation_ttf]) + ++ lib.optional cfg.enableEmoji pkgs.noto-fonts-emoji; + + fontconfig = { + # NOTE: This is responsible for color emoji support <2023-08-28> + # WARNING: This could lead to broken font rendering, if the emoji font is used as + # a fallback for normal characters <2024-05-16> + localConf = lib.mkIf cfg.enableEmoji (builtins.readFile ./emoji_font.xml); + + defaultFonts = { + serif = lib.mkForce (["Liberation Serif"] ++ lib.optional cfg.enableEmoji "Noto Color Emoji"); + sansSerif = lib.mkForce (["Overpass Nerd Font Propo"] ++ lib.optional cfg.enableEmoji "Noto Color Emoji"); + monospace = lib.mkForce (["SauceCodePro Nerd Font Mono"] ++ lib.optional cfg.enableEmoji "Noto Color Emoji"); + emoji = lib.mkIf cfg.enableEmoji (lib.mkForce ["Noto Color Emoji"]); + }; + allowType1 = false; + allowBitmaps = false; + }; + }; + }; +} diff --git a/modules/by-name/fw/fwupd/module.nix b/modules/by-name/fw/fwupd/module.nix new file mode 100644 index 00000000..5ad4f467 --- /dev/null +++ b/modules/by-name/fw/fwupd/module.nix @@ -0,0 +1,14 @@ +{ + config, + lib, + ... +}: let + cfg = config.soispha.services.fwupd; +in { + options.soispha.services.fwupd = { + enable = lib.mkEnableOption "fwupd"; + }; + config = lib.mkIf cfg.enable { + services.fwupd.enable = true; + }; +} diff --git a/modules/by-name/ha/hardware/module.nix b/modules/by-name/ha/hardware/module.nix new file mode 100644 index 00000000..850416b7 --- /dev/null +++ b/modules/by-name/ha/hardware/module.nix @@ -0,0 +1,80 @@ +{ + config, + lib, + pkgs, + ... +}: let + cfg = config.soispha.hardware; +in { + options.soispha.hardware = { + enable = lib.mkEnableOption "the various hardware dependend things (and graphics drivers)"; + moonlander = { + enableLiveTraining = lib.mkEnableOption "udev rules for live training"; + enableFlashing = lib.mkEnableOption "udev rules for firmware flashing"; + }; + + cpuType = lib.mkOption { + type = lib.types.enum ["amd" "intel"]; + description = '' + The manuafacturer of the used cpu. + + This is used to enable, for example, the correct microcode updates. + ''; + }; + }; + + config = lib.mkIf cfg.enable { + hardware = { + cpu.amd.updateMicrocode = cfg.cpuType == "amd"; + cpu.intel.updateMicrocode = cfg.cpuType == "intel"; + + # This is enabled manually to support older firmware. + keyboard.zsa.enable = false; + + nitrokey.enable = true; + onlykey.enable = false; + + graphics = { + enable = true; + extraPackages = builtins.attrValues { + inherit + (pkgs) + vaapiVdpau + libvdpau-va-gl + ; + }; + }; + }; + + # TODO: Remove the support for the old keyboards <2024-05-16> + services.udev.extraRules = + lib.strings.optionalString cfg.moonlander.enableLiveTraining '' + # Rules for Oryx web flashing and live training + KERNEL=="hidraw*", ATTRS{idVendor}=="16c0", MODE="0664", GROUP="plugdev" + KERNEL=="hidraw*", ATTRS{idVendor}=="3297", MODE="0664", GROUP="plugdev" + + # Legacy rules for live training over webusb (Not needed for firmware v21+) + # Rule for all ZSA keyboards + SUBSYSTEM=="usb", ATTR{idVendor}=="3297", GROUP="plugdev" + # Rule for the Moonlander + SUBSYSTEM=="usb", ATTR{idVendor}=="3297", ATTR{idProduct}=="1969", GROUP="plugdev" + # Rule for the Ergodox EZ + SUBSYSTEM=="usb", ATTR{idVendor}=="feed", ATTR{idProduct}=="1307", GROUP="plugdev" + # Rule for the Planck EZ + SUBSYSTEM=="usb", ATTR{idVendor}=="feed", ATTR{idProduct}=="6060", GROUP="plugdev" + '' + + lib.strings.optionalString cfg.moonlander.enableFlashing + '' + # Wally Flashing rules for the Ergodox EZ + ATTRS{idVendor}=="16c0", ATTRS{idProduct}=="04[789B]?", ENV{ID_MM_DEVICE_IGNORE}="1" + ATTRS{idVendor}=="16c0", ATTRS{idProduct}=="04[789A]?", ENV{MTP_NO_PROBE}="1" + SUBSYSTEMS=="usb", ATTRS{idVendor}=="16c0", ATTRS{idProduct}=="04[789ABCD]?", MODE:="0666" + KERNEL=="ttyACM*", ATTRS{idVendor}=="16c0", ATTRS{idProduct}=="04[789B]?", MODE:="0666" + + # Wally Flashing rules for the Moonlander and Planck EZ + SUBSYSTEMS=="usb", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="df11", \ + MODE:="0666", \ + SYMLINK+="stm32_dfu" + ''; + }; +} diff --git a/modules/by-name/ho/home-manager/module.nix b/modules/by-name/ho/home-manager/module.nix new file mode 100644 index 00000000..d95bb6ac --- /dev/null +++ b/modules/by-name/ho/home-manager/module.nix @@ -0,0 +1,56 @@ +{ + config, + lib, + pkgsStable, + nixpkgs_open_prs, + sysLib, + # extra information + system, + # bins + # TODO: Integrate these <2024-05-22> + river_init_lesser, + shell_library, + # external deps + user_js, + # modules + impermanence, + nix-index-database, + nixVim, + ... +}: let + cfg = config.soispha.home-manager; +in { + options.soispha.home-manager = { + enable = lib.mkEnableOption "home-manager with custom config."; + }; + + config = lib.mkIf cfg.enable { + home-manager = { + useGlobalPkgs = true; + useUserPackages = true; + users.soispha = import ../../../home.legacy; + extraSpecialArgs = { + inherit + nixpkgs_open_prs + pkgsStable + sysLib + # extra information + + system + # bins + + river_init_lesser + shell_library + # external deps + + user_js + # modules + + impermanence + nixVim + nix-index-database + ; + }; + }; + }; +} diff --git a/modules/by-name/im/impermanence/module.nix b/modules/by-name/im/impermanence/module.nix new file mode 100644 index 00000000..9730dde6 --- /dev/null +++ b/modules/by-name/im/impermanence/module.nix @@ -0,0 +1,57 @@ +{ + config, + lib, + ... +}: let + cfg = config.soispha.impermanence; +in { + options.soispha.impermanence = { + enable = lib.mkEnableOption "persisting directories and files with impermanence"; + + directories = lib.mkOption { + type = lib.types.listOf lib.types.str; + default = + [ + "/etc/nixos" + "/var/log" + "/var/lib/systemd" + "/var/lib/nixos" + ] + ++ lib.optional config.networking.networkmanager.enable "/etc/NetworkManager" + ++ lib.optional config.boot.lanzaboote.enable "/etc/secureboot" + ++ lib.optional config.hardware.bluetooth.enable "/var/lib/bluetooth" + ++ lib.optional config.virtualisation.waydroid.enable "/var/lib/waydroid" + ++ lib.optional config.services.postgresql.enable "/var/lib/postgresql"; + + defaultText = lib.literalExpression '' + [ + "/etc/nixos" + "/var/log" + "/var/lib/systemd" + "/var/lib/nixos" + ] + ++ lib.optional config.networking.networkmanager.enable "/etc/NetworkManager" + ++ lib.optional config.boot.lanzaboote.enable "/etc/secureboot" + ++ lib.optional config.hardware.bluetooth.enable "/var/lib/bluetooth" + ++ lib.optional config.virtualisation.waydroid.enable "/var/lib/waydroid" + ++ lib.optional config.services.postgresql.enable "/var/lib/postgresql" + ''; + description = "The directories to persist"; + }; + }; + + config = lib.mkIf cfg.enable { + # needed for the hm impermanence config + programs.fuse.userAllowOther = true; + + environment.persistence = { + "/srv" = { + hideMounts = true; + inherit (cfg) directories; + files = [ + "/etc/machine-id" + ]; + }; + }; + }; +} diff --git a/modules/by-name/is/issue_file/module.nix b/modules/by-name/is/issue_file/module.nix new file mode 100644 index 00000000..d8b6faa8 --- /dev/null +++ b/modules/by-name/is/issue_file/module.nix @@ -0,0 +1,52 @@ +{ + config, + self, + pkgs, + lib, + ... +}: let + lastModifiedFile = pkgs.runCommandLocal "formatDate" {} '' + date --date='@${builtins.toString self.sourceInfo.lastModified}' +'%F %T' > $out + ''; + lastModified = lib.strings.replaceStrings ["\n"] [""] ( + builtins.readFile lastModifiedFile + ); +in { + environment.etc.issue = { + # Friendly greeting on the virtual consoles. + text = '' + [?25l[?7l[38;2;255;77;77m [39m[49m + [38;2;255;77;77m ▗▄▄▄ ▗▄▄▄▄ ▄▄▄▖ [39m[49m + [38;2;255;77;77m ▜███▙ ▜███▙ ▟███▛ [39m[49m + [38;2;255;77;77m ▜███▙ ▜███▙▟███▛ [39m[49m + [38;2;255;175;77m ▜███▙ ▜██████▛ [39m[49m + [38;2;255;175;77m ▟█████████████████▙ ▜████▛ ▟▙ [39m[49m + [38;2;255;175;77m ▟███████████████████▙ ▜███▙ ▟██▙ [39m[49m + [38;2;255;175;77m ▄▄▄▄▖ ▜███▙ ▟███▛ [39m[49m + [38;2;255;243;77m ▟███▛ ▜██▛ ▟███▛ [39m[49m + [38;2;255;243;77m ▟███▛ ▜▛ ▟███▛ [39m[49m + [38;2;255;243;77m▟███████████▛ ▟██████████▙[39m[49m + [38;2;79;252;121m▜██████████▛ ▟███████████▛[39m[49m + [38;2;79;252;121m ▟███▛ ▟▙ ▟███▛ [39m[49m + [38;2;79;252;121m ▟███▛ ▟██▙ ▟███▛ [39m[49m + [38;2;77;130;255m ▟███▛ ▜███▙ ▝▀▀▀▀ [39m[49m + [38;2;77;130;255m ▜██▛ ▜███▙ ▜██████████████████▛ [39m[49m + [38;2;77;130;255m ▜▛ ▟████▙ ▜████████████████▛ [39m[49m + [38;2;77;130;255m ▟██████▙ ▜███▙ [39m[49m + [38;2;233;77;255m ▟███▛▜███▙ ▜███▙ [39m[49m + [38;2;233;77;255m ▟███▛ ▜███▙ ▜███▙ [39m[49m + [38;2;233;77;255m ▝▀▀▀ ▀▀▀▀▘ ▀▀▀▘ [39m[49m + [38;2;233;77;255m [39m[49m[0m + [17A[9999999D[46C[34m[1m NixOS ${config.system.nixos.label} [0m + [46C[0m --------------[0m + [46C + [46C [34m[1m last update: [0m${lastModified} + [46C [34m[1m date: [0m\d + [46C [34m[1m time: [0m\t + [46C [34m[1m ipv4: [0m\4 + [46C [34m[1m ipv6: [0m\6 + [46C [34m[1m tty: [0m\l + [22B + ''; + }; +} diff --git a/modules/by-name/la/laptop/module.nix b/modules/by-name/la/laptop/module.nix new file mode 100644 index 00000000..f70230ad --- /dev/null +++ b/modules/by-name/la/laptop/module.nix @@ -0,0 +1,17 @@ +{ + lib, + config, + ... +}: let + cfg = config.soispha.laptop; +in { + # TODO: Add an actual config to this module, instead of the implicit one in home manager. <2024-05-22> + options.soispha.laptop = { + enable = lib.mkEnableOption "Laptop improvements"; + backlight = lib.mkOption { + type = lib.types.str; + example = lib.mdDoc "intel_backlight"; + description = lib.mdDoc "Which backlight to query for the screen brightness"; + }; + }; +} diff --git a/modules/by-name/li/libvirtd/module.nix b/modules/by-name/li/libvirtd/module.nix new file mode 100644 index 00000000..5c519550 --- /dev/null +++ b/modules/by-name/li/libvirtd/module.nix @@ -0,0 +1,27 @@ +{pkgs, ...}: { + # virtualisation = { + # spiceUSBRedirection.enable = true; # TODO: this allows usb access to any user, which shouldn't be that bad + # cores = 8; + # diskSize = 25000; + # useEFIBoot = true; + # resolution = { + # x = 1920; + # y = 1080; + # }; + # memorySize = 8024; + # sharedDirectories = {}; # TODO: add some + # libvirtd = { + # enable = true; + # qemu = { + # package = pkgs.qemu_full; + # ovmf = { + # enable = true; + # packages = [pkgs.OVMFFull.fd]; + # }; + # }; + # }; + # }; + # users.users.soispha.extraGroups = [ + # "libvirtd" # to run libvirt stuff as this user + # ]; +} diff --git a/modules/by-name/lo/locale/keymaps/dvorak_modified.xkb b/modules/by-name/lo/locale/keymaps/dvorak_modified.xkb new file mode 100644 index 00000000..63f5d4fb --- /dev/null +++ b/modules/by-name/lo/locale/keymaps/dvorak_modified.xkb @@ -0,0 +1,15 @@ +partial alphanumeric_keys +xkb_symbols "dvorak-modified" { + name[Group1]= "Dvorak English with additional keys"; + + key <AC02> {[ o, O, odiaeresis, Odiaeresis]}; + key <AC04> {[ u, U, udiaeresis, Udiaeresis]}; + key <AC01> {type[Group1]="EIGHT_LEVEL", + [ a, A, adiaeresis, Adiaeresis, aring, Aring]}; + + + include "us(dvorak)" + include "level3(caps_switch)" + include "level5(ralt_switch)" +}; +// vim: ft=xkb diff --git a/modules/by-name/lo/locale/keymaps/us_modified.xkb b/modules/by-name/lo/locale/keymaps/us_modified.xkb new file mode 100644 index 00000000..6299a5e9 --- /dev/null +++ b/modules/by-name/lo/locale/keymaps/us_modified.xkb @@ -0,0 +1,9 @@ +partial alphanumeric_keys +xkb_symbols "us-modified" { + name[Group1]= "US English with caps lock key as compose key"; + + + include "us(basic)" + include "compose(caps)" +}; +// vim: ft=xkb diff --git a/modules/by-name/lo/locale/module.nix b/modules/by-name/lo/locale/module.nix new file mode 100644 index 00000000..10569216 --- /dev/null +++ b/modules/by-name/lo/locale/module.nix @@ -0,0 +1,57 @@ +{ + config, + lib, + ... +}: let + cfg = config.soispha.locale; +in { + options.soispha.locale = { + enable = lib.mkEnableOption "locale setup"; + + keyMap = lib.mkOption { + type = lib.types.str; + example = "us"; + default = "dvorak"; + description = "The console key map language to use"; + }; + + timeZone = lib.mkOption { + type = lib.types.str; + default = "Europe/Berlin"; + description = "The time zone to use"; + }; + }; + + config = lib.mkIf cfg.enable { + time = { + inherit (cfg) timeZone; + }; + + i18n = { + defaultLocale = "en_CA.UTF-8"; + extraLocaleSettings = { + LANGUAGE = "en_CA:en_US:en"; + LC_TIME = "en_DK.UTF-8"; + LC_COLLATE = "C.UTF-8"; + }; + }; + + # Layout + console = { + inherit (cfg) keyMap; + }; + + services.xserver.xkb.extraLayouts = { + "us-modified" = { + description = "standard us with caps as compose key."; + languages = ["eng" "swe" "deu"]; + symbolsFile = ./keymaps/us_modified.xkb; + }; + "dvorak-modified" = { + description = "standard dvorak english with german and swedish extra chars."; + languages = ["eng" "swe" "deu"]; + symbolsFile = ./keymaps/dvorak_modified.xkb; + }; + }; + }; +} diff --git a/modules/by-name/ne/networking/module.nix b/modules/by-name/ne/networking/module.nix new file mode 100644 index 00000000..c5f0e491 --- /dev/null +++ b/modules/by-name/ne/networking/module.nix @@ -0,0 +1,88 @@ +{ + config, + lib, + ... +}: let + cfg = config.soispha.networking; +in { + options.soispha.networking = { + enable = lib.mkEnableOption "networking"; + + mode = lib.mkOption { + type = lib.types.enum ["NetworkManager" "systemd-networkd"]; + example = "systemd-networkd"; + description = "The daemon used to setup networking."; + }; + + userName = lib.mkOption { + type = lib.types.str; + default = "soispha"; + description = '' + The name of the user to allow access to the configured network + ''; + }; + + hostName = lib.mkOption { + type = lib.types.str; + example = "apzu"; + description = "The name of the host"; + }; + }; + + config = { + networking.hostName = cfg.hostName; + + systemd.network = lib.mkIf (cfg.mode == "systemd-networkd") { + networks = { + "tap0" = { + name = "tap0"; + bridge = [ + "virbr0" + ]; + }; + "enp4s0" = { + name = "enp4s0"; + networkConfig = { + DHCP = "yes"; + DNSOverTLS = "yes"; + DNSSEC = "yes"; + }; + bridge = [ + "virbr0" + ]; + }; + }; + + netdevs = { + "tap0" = { + netdevConfig = { + Name = "tap0"; + Kind = "tap"; + }; + tapConfig = { + User = config.users.users."${cfg.userName}".uid; + Group = "libvirtd"; + }; + }; + "virbr0" = { + netdevConfig = { + Name = "br0"; + Kind = "bridge"; + }; + }; + }; + }; + + networking.networkmanager = lib.mkIf (cfg.mode == "NetworkManager") { + enable = true; + dns = "default"; + wifi = { + powersave = true; + }; + }; + + users.users."${cfg.userName}".extraGroups = lib.mkIf (cfg.mode == "NetworkManager") [ + "networkmanager" # allows to configure NetworkManager as this user + ]; + }; +} diff --git a/modules/by-name/ni/nix/module.nix b/modules/by-name/ni/nix/module.nix new file mode 100644 index 00000000..980bbd39 --- /dev/null +++ b/modules/by-name/ni/nix/module.nix @@ -0,0 +1,61 @@ +{ + pkgs, + # flakes + nixpkgs_as_input, + templates, + self, + system, + ... +}: { + nix = { + package = pkgs.nixVersions.latest; + + # Disable nix channels (this is a remnant of old days) + channel.enable = false; + + registry = { + nixpkgs.flake = nixpkgs_as_input; + n.flake = + nixpkgs_as_input + // { + # Otherwise nixpkgs's config and overlays are not available: + + # Both attrs exists, so we just override both and hope + outputs.legacyPackages."${system}" = pkgs; + legacyPackages."${system}" = pkgs; + }; + + t.flake = templates; + + my_flake.flake = self; + m.flake = self; + }; + + gc = { + automatic = true; + dates = "weekly"; + options = "--delete-older-than 7d"; + }; + + settings = { + auto-optimise-store = true; + experimental-features = [ + "nix-command" + "flakes" + #"ca-derivations" + ]; + + use-xdg-base-directories = true; + + #substituters = ["https://cache.ngi0.nixos.org/"]; + #trusted-public-keys = ["cache.ngi0.nixos.org-1:KqH5CBLNSyX184S9BKZJo1LxrxJ9ltnY2uAs5c/f1MA="]; + + fallback = true; # Build from source, if binary can't be substituted + + keep-failed = true; # keep failed tmp build dirs + pure-eval = true; # restrict file system and network access to hash + + sandbox-fallback = false; # Don't disable the sandbox, if the kernel doesn't support it + }; + }; +} diff --git a/modules/by-name/ni/nixpkgs/config.nix b/modules/by-name/ni/nixpkgs/config.nix new file mode 100644 index 00000000..1a24444d --- /dev/null +++ b/modules/by-name/ni/nixpkgs/config.nix @@ -0,0 +1,28 @@ +{ + cfg, + myPkgs, + lib, + ... +}: let + myPkgsOverlay = self: super: myPkgs; +in { + nixpkgs = { + hostPlatform = cfg.systemName; + + overlays = [ + myPkgsOverlay + ]; + + config = { + # TODO: this fails because of the root tempsize, which should be increased + # contentAddressedByDefault = true; + + hostSystem = cfg.systemName; + + allowUnfreePredicate = pkg: + builtins.elem (lib.getName pkg) [ + "pypemicro" # required by pynitrokey + ]; + }; + }; +} diff --git a/modules/by-name/ni/nixpkgs/module.nix b/modules/by-name/ni/nixpkgs/module.nix new file mode 100644 index 00000000..eda3ac89 --- /dev/null +++ b/modules/by-name/ni/nixpkgs/module.nix @@ -0,0 +1,17 @@ +{ + lib, + config, + ... +} @ args: let + cfg = config.soispha.nixpkgs; +in { + options.soispha.nixpkgs = { + enable = lib.mkEnableOption "Nixpkgs config"; + systemName = lib.mkOption { + description = "The name of the system."; + example = "x86_64-linux"; + type = lib.types.str; + }; + }; + config = lib.mkIf cfg.enable (import ./config.nix (args // {inherit cfg;})); +} diff --git a/modules/by-name/op/openssh/module.nix b/modules/by-name/op/openssh/module.nix new file mode 100644 index 00000000..b733dbe7 --- /dev/null +++ b/modules/by-name/op/openssh/module.nix @@ -0,0 +1,15 @@ +{...}: { + services.openssh = { + enable = true; + hostKeys = [ + { + path = "/srv/sshd/ssh_host_ed25519_key"; + rounds = 1000; + type = "ed25519"; + } + ]; + settings = { + PasswordAuthentication = false; + }; + }; +} diff --git a/modules/by-name/pi/printing/module.nix b/modules/by-name/pi/printing/module.nix new file mode 100644 index 00000000..85d15b16 --- /dev/null +++ b/modules/by-name/pi/printing/module.nix @@ -0,0 +1,45 @@ +{ + config, + lib, + ... +}: let + cfg = config.soispha.services.printing; +in { + options.soispha.services.printing = { + enable = lib.mkEnableOption "default printing configuration"; + }; + + config = lib.mkIf cfg.enable { + services.avahi = { + enable = true; + nssmdns4 = true; + nssmdns6 = true; + openFirewall = true; + }; + + services.printing = { + enable = true; + startWhenNeeded = true; + webInterface = true; + + # deletes `/var/cache/cups`, `/var/lib/cups` and `/var/spool/cups` on cups startup + stateless = true; + + drivers = []; + }; + + hardware = { + printers = { + ensurePrinters = [ + { + name = "Brother"; + description = "Brother DCP-9022CDW"; + model = "everywhere"; + deviceUri = "dnssd://Brother%20DCP-9022CDW._ipp._tcp.local/?uuid=e3248000-80ce-11db-8000-30055c773bcf"; + } + ]; + ensureDefaultPrinter = "Brother"; + }; + }; + }; +} diff --git a/modules/by-name/po/polkit/module.nix b/modules/by-name/po/polkit/module.nix new file mode 100644 index 00000000..fb13505b --- /dev/null +++ b/modules/by-name/po/polkit/module.nix @@ -0,0 +1,14 @@ +{ + config, + lib, + ... +}: let + cfg = config.soispha.polkit; +in { + options.soispha.polkit = { + enable = lib.mkEnableOption "polkit"; + }; + config = lib.mkIf cfg.enable { + security.polkit.enable = true; + }; +} diff --git a/modules/by-name/po/postgresql/module.nix b/modules/by-name/po/postgresql/module.nix new file mode 100644 index 00000000..c47a235c --- /dev/null +++ b/modules/by-name/po/postgresql/module.nix @@ -0,0 +1,17 @@ +{ + config, + lib, + ... +}: let + cfg = config.soispha.services.postgresql; +in { + options.soispha.services.postgresql = { + enable = lib.mkEnableOption "postgresql"; + }; + + config = lib.mkIf cfg.enable { + services.postgresql = { + enable = true; + }; + }; +} diff --git a/modules/by-name/po/power/module.nix b/modules/by-name/po/power/module.nix new file mode 100644 index 00000000..13013879 --- /dev/null +++ b/modules/by-name/po/power/module.nix @@ -0,0 +1,33 @@ +{ + config, + lib, + ... +}: let + cfg = config.soispha.power; +in { + options.soispha.power = { + enable = lib.mkEnableOption "power optimizations"; + }; + + config = lib.mkIf cfg.enable { + # see this for reference: https://github.com/NixOS/nixpkgs/issues/211345 + services = { + # conflicts with tlp + power-profiles-daemon.enable = false; + + thermald.enable = true; + + tlp = { + enable = true; + settings = { + CPU_BOOST_ON_AC = 1; + CPU_BOOST_ON_BAT = 0; + CPU_SCALING_GOVERNOR_ON_AC = "performance"; + CPU_SCALING_GOVERNOR_ON_BAT = "powersave"; + SATA_LINKPWR_ON_AC = "max_performance"; + SATA_LINKPWR_ON_BAT = "min_power"; + }; + }; + }; + }; +} diff --git a/modules/by-name/sc/scanning/module.nix b/modules/by-name/sc/scanning/module.nix new file mode 100644 index 00000000..dda507fa --- /dev/null +++ b/modules/by-name/sc/scanning/module.nix @@ -0,0 +1,25 @@ +{ + config, + lib, + pkgs, + ... +}: let + cfg = config.soispha.services.scanning; +in { + options.soispha.services.scanning = { + enable = lib.mkEnableOption "default scanning configuration"; + }; + + config = lib.mkIf cfg.enable { + hardware = { + sane = { + enable = true; + extraBackends = [pkgs.sane-airscan]; + }; + }; + + users.users.soispha.extraGroups = [ + "scanner" # for permission to access the scanner. + ]; + }; +} diff --git a/modules/by-name/se/secrets/lf/cd_paths.age b/modules/by-name/se/secrets/lf/cd_paths.age new file mode 100644 index 00000000..3b018fb7 --- /dev/null +++ b/modules/by-name/se/secrets/lf/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/se/secrets/module.nix b/modules/by-name/se/secrets/module.nix new file mode 100644 index 00000000..8b3188b0 --- /dev/null +++ b/modules/by-name/se/secrets/module.nix @@ -0,0 +1,73 @@ +{ + config, + lib, + ... +}: let + # mkFakeSecret = secretName: { + # name = secretName; + # value = { + # path = "/dev/null"; + # }; + # }; + # fakeSecrets = + # builtins.listToAttrs (lib.debug.traceValSeqN 2 (builtins.map mkFakeSecret + # (lib.debug.traceValSeqN 2 (builtins.attrNames secrets)))); + cfg = config.soispha.secrets; +in { + options.soispha.secrets = { + enable = lib.mkEnableOption "secrets through agenix"; + }; + + config = lib.mkIf cfg.enable { + age = { + secrets = { + lf_cd_paths = { + file = ./lf/cd_paths.age; + mode = "700"; + owner = "soispha"; + group = "users"; + }; + + # FIXME: Reactive when serverphone is merged in tree again <2024-05-11> + # + # serverphoneCa = { + # file = ./serverphone/ca.key; + # mode = "700"; + # owner = "serverphone"; + # group = "serverphone"; + # }; + # serverphoneServer = { + # file = ./serverphone/server.key; + # mode = "700"; + # owner = "serverphone"; + # group = "serverphone"; + # }; + + taskserverPrivate = { + file = ./taskserver/private.key; + mode = "700"; + owner = "soispha"; + group = "users"; + }; + taskserverPublic = { + file = ./taskserver/public.cert; + mode = "700"; + owner = "soispha"; + group = "users"; + }; + taskserverCA = { + file = ./taskserver/ca.cert; + mode = "700"; + owner = "soispha"; + group = "users"; + }; + taskserverCredentials = { + file = ./taskserver/credentials; + mode = "700"; + owner = "soispha"; + group = "users"; + }; + }; + }; + }; +} diff --git a/modules/by-name/se/secrets/secrets.nix b/modules/by-name/se/secrets/secrets.nix new file mode 100644 index 00000000..ff97c0fd --- /dev/null +++ b/modules/by-name/se/secrets/secrets.nix @@ -0,0 +1,16 @@ +let + soispha = "age1mshh4ynzhhzhff25tqwkg4j054g3xwrfznh98ycchludj9wjj48qn2uffn"; + + tiamat = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIMD87QQIUXdEv3TaNRrI9clD9VgpsuVLFg2CrNGa5lVB"; + apzu = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIBivF5b6PyxsR/t+4Qg4IEDXHVXrjmZpslTUNXpvcVbO"; +in { + "lf/cd_paths.age".publicKeys = [soispha tiamat apzu]; + + "serverphone/ca.key".publicKeys = [soispha tiamat apzu]; + "serverphone/server.key".publicKeys = [soispha tiamat apzu]; + + "taskserver/private.key".publicKeys = [soispha tiamat apzu]; + "taskserver/public.cert".publicKeys = [soispha tiamat apzu]; + "taskserver/ca.cert".publicKeys = [soispha tiamat apzu]; + "taskserver/credentials".publicKeys = [soispha tiamat apzu]; +} diff --git a/modules/by-name/se/secrets/serverphone/ca.key b/modules/by-name/se/secrets/serverphone/ca.key new file mode 100644 index 00000000..d49c5395 --- /dev/null +++ b/modules/by-name/se/secrets/serverphone/ca.key @@ -0,0 +1,19 @@ +-----BEGIN AGE ENCRYPTED FILE----- +YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSAyaGJNQkRRVy9MRXZ3b2tJ +Q2R1NUcrYUNGRE5uQkNyUDdkSm5rUWYxaXpjCjduMG1FSG1VamozdnJoVFFZUDYz +T2pyK1k3ekZ4RnFMaDFKdUZPWVNuR3MKLT4gc3NoLWVkMjU1MTkgelpFb25nIEpP +d0xwS3Nia3AwNmppRjZhODdzNXhEcnRsZW5rUzBQcTN6NWhWeTNiQ0EKTkpUZ1Jk +NHE3WVRzVEhpMnJGaVFpdkFBVW5QNThCSUdFSHVQR1RrQUJsZwotPiBzc2gtZWQy +NTUxOSA3SGZGVXcgdjJKUUtlRjE5UFEyR2tBOWhEbHNMVlNSOUMyZ1dkYkhYZWRW +by9QZ2UxTQpVSnhJcFFYay9LSStrSFFJcXJPWUxydXNGbUNXRVpLcHJibjM2TDlw +RnlVCi0+IGNHPjMiSyQtZ3JlYXNlIGcgdWZkbApmY0YzMmhDdzBWT0RKaWlUUmZP +bmRPOExuRVJ3Yk5mMFhYSnhlRENqWXJxK1VWdnBibUxzNWV1NHMyNVNXN054CmR0 +VFAzYUR0RHVaZUpOTlB3USt2TXVDcXdLOGtpZwotLS0gaTliQzBjbjdUYkVidURX +em9wcU04cDhNMHB6KzNBSVMyMmtSRERKS240SQryB70ZEgDQ4eJ/pjIWh6MBEUQr +iAx2i+J+XJu+74bC9DfB5rWpR4/HAdp8EF6wmi05TuEPUpG9brwm/mHi+FB/Drpu +00viGfM3dlCyALz1jB2W/MbruouK85o2L3RWDCgc+eT1gA+u2C7ZxO6iYA3aP4lu +ShDcSHlsKkh9lx4cRsNTua/8N+GQZLciSC7iMDroruxWj1HET9IxeeVN+VSuqcjW +ocX3LU2uU8vP9WT9zT1lbQB5Z0EM7W+ez61SjGpzrpXB2mpmi+SHOIWF3VdG1H8R +18BIyRjKIj5Op+8XD7qAe6nl9SSCnMURH+arc7yjNMgEbzFykfldfug2ibI2G/kW +OxeiEBoSFlC+V8ivS6I= +-----END AGE ENCRYPTED FILE----- diff --git a/modules/by-name/se/secrets/serverphone/server.key b/modules/by-name/se/secrets/serverphone/server.key new file mode 100644 index 00000000..a2720406 --- /dev/null +++ b/modules/by-name/se/secrets/serverphone/server.key @@ -0,0 +1,19 @@ +-----BEGIN AGE ENCRYPTED FILE----- +YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSBJZnBXSzF4K0ljR3B1Rkk1 +M0lSSkVmVlA2Tjcrd0JCRmhHWDY4bzNoYnhjCmsvQjJmYU5vNVh1Umw0dzhCQjNF +WVRhVHpUTUIzRVBxaXhFWHpuenZHN0kKLT4gc3NoLWVkMjU1MTkgelpFb25nIHAz +aG02dkxiNVRreVNadXJjbnc0bXBtSFRSNDhrYjljanUrNldwVFlabXcKU2c2L25r +VlNjeDFENUdQeWllenRGWlRqRW53UU5VNEdCaUZsbHpaL1ZFTQotPiBzc2gtZWQy +NTUxOSA3SGZGVXcgZytvUUhZSXhwQ01mQmtkZmhzdHJUd2tlQS9yYkxCdTBYZ2pJ +UEd4WEF4SQp4WVh2UEJReDVES2tCWlpqQS9aanQzRGRsSTA4S0VXSWZxZ2hoKzZq +YllzCi0+IEc4eC1ncmVhc2UgaGQhIGFydERoaS4gLERUcQprczdDdHhaOXpmN1VU +MDlHNlYzVmMxY09Oa2xzTVN6M0ZyYnpRSzJEMS9nMmlqRVo4Wk1qN1lKZnp0N0RT +UStuCm51L01Rb3ZxNUhEa0c5Z3orYlp0YmlXMkhpeHVJMjNkRFZYWmR3QmV2Zwot +LS0gdWJDeHZvc0xOMU9uUjUyMlRGUnlGSW9PZzVKWWNoa3pWbVM1OE9LdFk2NAo+ +WS82jL1us5iVw+xWVI80luHMs31hxZfQgJDBuFbtpY0nKkM97U7rusl6t8P+s93c +R0IYBEUuz6n33GTeVOLipDqkZftlOOvSZkFneZ766+GpEO01dCjeSW9KViDC1jI/ +721IXq9TQNZw0Ou3Vf5E0nDypsfG0UhEoLCy6QZL9YCIyl5s//kyFFnpQjyaGT/P +pRHGhD0BxZa2ib07WDWzBpsTFtVemwcn9lqAx7DlYV2X3UwCT3qVOVjDuA/j6qUt +8bCDoXs4/dWleHNHzpwRhe+j2W4OWDKp7o0zYqxkUuPpEWXL7+A+B/+/08nAtZQk +ZvJyaZSL5wicIPAjLxrD00z2QcE/ZPyUrXsi0gOovuk= +-----END AGE ENCRYPTED FILE----- diff --git a/modules/by-name/se/secrets/taskserver/ca.cert b/modules/by-name/se/secrets/taskserver/ca.cert new file mode 100644 index 00000000..203d62a8 --- /dev/null +++ b/modules/by-name/se/secrets/taskserver/ca.cert @@ -0,0 +1,92 @@ +-----BEGIN AGE ENCRYPTED FILE----- +YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSB5c0xqVmk5MzZrUmhqTkUv +YUdRamtpQTdvZ2N1QUM4MWNiWWlYbmwvWURvCnhLYzJuSGM5dkhGbmZGaWNpNVhn +L3hSTU9xb0cwc1FSZHJpYUFqTE1NZlUKLT4gc3NoLWVkMjU1MTkgelpFb25nIFhv +N2dOR2xleGVRUWU1cTd5Q1RnQjVtZElJOVdaS2EzTGtVbmswNXdiRWMKa0hubkRD +bFE0NXp6R2QvcHpCUTZjblk1RVpIMmJ1TFhyajM0N1lYRy80UQotPiBzc2gtZWQy +NTUxOSA3SGZGVXcgOFpvTm1tN21pemJFUXVYYzREcE1aZ3dnMU5TLzVxLzFjdWI2 +eENGWXR4QQpwcHFLMS9WNDRiNFZxSThRUk85RVZhS2hyQnptL2FHdHo5OCt3dHF0 +amZZCi0+IGctZ3JlYXNlIDttPFJBT3FfIDZeMT91Ois3IEx0CkFTbFYxZzloWlJZ +WndXZGx3WHI0aXh0U09la3BmblZmcDRIb3RRYjdhL3drQnhQRWNrNUZabzE4R0Q0 +bnpqZGcKVy8xbWV2TXV4blpRNFg3czZHWExOZllLR20yU3hrdlltZwotLS0gUjQv +QXQ1L2NselJ2OVJtUzc0YnIrWlpXK29WNFFVUXEzUTQ4ZG0xRm9zSQqJzYGOwU7Y +Jt/x8jJohpCDiaBjukoqL0WH7ocjgjt084M+on5vp3pBbT9eIgErCJvGc7oDmke0 +Isnb6RvWg6fY66WY4Bsm67VqGiNyV1yQmAXB+zp6gfKjAfvdZk7wUbgll6mUYU8M +IVwvPHS6C3ByIMVU6OaNPXvAMIakDoQUM+HSQpy7Cu3ZuLwZJs7kM9CWGM/GzyNU +fhBiO8L17J5ZtiC5qOZ0DqIUCefdvKINXGLFCV1a/PoZwpbM7Q36R/urEEz77tLm +qzlM1qwq+G4SWjiihYwQ+3rcA2BPzDtYF/F0O9skw2FYFyRZhENqnba3OOewMb6C +CLVtJcCw7doOjHrpxCwYg7bcP1k9V7sR5F7ez80krQ72qHWlGBL7G4v8Mx9o/GQq +cNv8000KWIORBnPl7qyUc+Y5fZBqm8ebkGh9xg5wRflqXXZvOU81av2ayT4hjfgZ +dmSZPtYmX8jaTQwp/WqzpcJq47a9xaLfo4J8UNiG9y9paoN7J5fwn6IALrWnxK9U +u1s20sRohwN8S5kexyZO2m27b59JsvTrnTJ4iV6/oxre7eXdrCLxsagPpZKTSao8 +5aaCO5lyXwbfoJPmH5HG4YcKW02AAlHQHug16lMMlt3jxUuDXqBXbu6r15DJC+vO +6432Iq4SjpZi2nR4tHtVLrnDAFTRMA6GhCGLPXrt2MbWglZGVG+KzUIsv7X+RsQs +quNab0Z+JIazI5MCR7rpgazVs5lY7wWh4ZwrniFVChkv2yM3dDmsg8OGieXtyhGf +2OiEQX7peeZopdo7OIqEN/h9rM82cKqH62COHvQITCrfys1eRFUr0RvUAanKdTS+ +N2BDYEqHdjpv4ED94mxaTlO75kbr+NEbFMEXLcnpNuV9M/SjKuNJxTi/CcPn0whi +YOJblyzTRf2iN5z38oxMTJzfHzXMCoB2KEHR5XgP1ZF3WE6ocz4JB1wpn1qwlZxx +bUKOPs+rRZKKFNrcrpifPLdm3bWIeQ46xn1eks/yqO2Y4On5IwMwhFdbn80EWFMX +DRQeIo8EkH4+a0iNWlMcY3mNtEgyqc0JgL6BFwlmWde9V0DBVIO43sI8oIjOoaSR +lQREW8oPl7NsE6ejmpurtKoizZ/l/4jGdUehMxg7Z5BvsrJMjYhm1s8RCf/r8RgD +jLQkbGRymVNHuLU7G63v0PA+26z6ZCTObNIkdI9skSlSc2gYFbS7p7BxYpkt1Rpw +Olz3Q6Vw29cigHEjpobAADq0ArT6SZJaa+4+2rzeqjiSektP8QcAZyf+9wGj28Q5 +epHuhr/sfzcyuLP3ikHxuF1VStCWZUShSzkaxIsLqVQUmVZyAEWJmZ9Ud/Aczvhp +F5O+Ln9UiIWZOhPvzhIPqjp9W7osJ26XmdnOLhxT6RZKcXbS0lR78rYfk0Ff97eu +xgtnzZ8UdyPNlYaLXukT2HgePktkfgBsR8ROwhHroPUb4+g1macEwI0/OjIjHMuF +cCPod+sdn7CIjc3iH5UTD70ThrBWorkBwzuzpliDHc6fs+ji2gULu5YsBavcbXPr +FU/389I3mmWJ7JBEOsUsgaRoV3ffK8kcNeTshe17Vo4rPvvQm6fR5B6l1EtUMozV +Jtft3GRgQQvV067Z9IYr9nreBNqoZgEapF/54YksZRJm4Rf2lmMXRi+Mo3vkvaUg +SliywNy9X0d/VsZ950g5NhsHh1wu3/sdJ0qV6S1H/2YxDr/NYphUoWxvLp926DCQ +meydAfPYSTZOR7I9oI6DiM580wt6MUGRWYCy/QTVmWvpeA9gapziqX78QzQbFB5c +9tUt+OvxWYTcYZHTlXrHEO9hDMSrmwfIpXoxz8ogCE7LuEgz/x6icrTmNs+1eDR4 +jVuR7E3CA/ZMxrtMJu1aCQkT9Wy1TBiHiSTa5o/Vx1aJq8Xj3TKz6u1SEaMvevfi +iTYK4EbPLlOvw51yLTaYlvZuXry33xy4UNiqwVuhas2DenIfE+qptYoP/zAUGZxq +Axojzzwf2BerpQbRGyo0PSpcU86ywPNIA4mZmlHXwdKKnQ5Dpd2+8w2Kek0r2r94 +UHjFhcz6dyL1+1naKEDQkSHgjWF1poFuLZJ/jfaXHYTAQZ/I7T2FMG7AWoNtyocR +c0IXABjm6scv8U6jlFH/OZNeTS7oCuhUXz0VTdr86rV+ozECzJ6dO2plSIsFIume +XVaT569nkx6Ndg2poFb8dHz0WZ6OU3GZQj4uIKsb4fBmrilapxhX2hpVDZtEirJk +FT4Pvvuj1SmlT+bz9ia0A1/ZncjmHIjHsAsYTpsNs6dvZsYGyZm9zUcdMV8daLBa +g3Nlt4I5lW1/kRTtmuVw4C3UuTuyCl7hIQ+KPq8EDlQbHYjoPbdr9haJhnypgDRw +sgW5hWIIdFOSt1wmU8qtcfRYXH/eLq8VrY7qJX+/vaSfHuSQb9fqRe4PErxrMGiV ++cKPH7uoto/DgyI4kvN1X9LLi3ySLWm2CweRg8SrBX76wMmeyP51/q2tz3DkAbf0 +auhwx8baCWLUhlxcfCWq94sJRobvI5OOF4fyDbjXnO/EzTzH0er13xVfJp09ttf5 +sBJ0ZxHvHM+hNb8O/1GajOhgkvy0R1eB27JYFJR9iVxsInlklbjKCL0HM/RjjMcT +ykYjf8S/wEtUWA8FGnkLJzhEMpv4NMQ4W2tgQs7RAbXQiQfff/avZGjK9sMne6FI +VQTqgQOtOzg19S86M31UrR8OUPqOwAKIUpC0Q9sixV4BkcUrfFonDZ8uRvzzMaUt +efss4HuCC52VojMM3NbkWD7a0e2DMCtVxcjW8XA7gsJDuD4GB8oqkgt8oeIrQ+ah +l0ue20APKGsLRxwwE2ZrIn8isArAEWmU2zfplB/7DXUqhw2epA1c7LLtqBdf5Zmh +eOA3wWZicsoCpnzPmcZXUXGttaazoGTZ0mh0YYBjfg2fbQCjuD51HWjmY+L6wZaY +UlXuHr/ojiOt1+SVaEv8fnmPaereLmsNCp0PmVUEy/G4osXE84KMDaFBKuUyJyoQ +9reyBSCaHjuzSaUDh4wHGso6vScDNIdbxYyRK52yI/4sfthIt5hgPiGb6sb54c8c +PXoNpEok44CxtLZUMrUG5IlTejS3IVosK50WuTPumBLcz/OhpD7Qe4o6vAm2ajLk +O3KF2R7wHMtZQVBVV0vqmh7zhZcDqMqFxAownzBua2IeUDLqmLwr+p9aAhVfUQrX +x1rOZynqha5U2wc6JugCDOPbJ2JdX+OY7ES6e6Otb853nhOAYfM9RfXkkeQa3l7d +OLdPwmyKs9Eoe/MxGk5Nw3RfyXd3wMtJ9OjQMg3PzhFsMT/dw9k9V/mZ7mP13EgE +X1TNAH7QrYeJwE9i5/+K65xTvv4hbQdW84W+sQObdQzfypjdb+M/VU5rbvCmmt0V +7deNfeeUw5q/Y9e4LuSINuF47JjjbZVsbwYB0Bw8ntQtDI1YP3SelbLXu/6AbHdz +eOezxm45FUWc80cLeFPz/x+RTkuotmqZmUrjFmqEM8UY/rEDpWjczBPyeJy449di +CYO4YvXhfs2U/CzSyAMOliB/QAKM13ZMGFYTgIIDxNrELU8lU1lNJFjTIthEwMZP +CKIiZd7iAY+Ey1ZVeqB+hZzr75zJAkfuZuMSVw7QMhAQqaexlgBhA4TNtOicrtHg +dpbQ9tZzyk/oY0MX5TN+f2BPgUkm6Ry08TV5JwWnocz586XQalA+MdQifBxerf/X +xwyZDlWTTNGVTt10IFwd53k3IpNCoczM/MoTu+pczeJnSksGrL5t9mzXYYIkPcRm +FwPbIJmRkravexVEiOR19meba5YRiOFz42+Lm+TNdN/BuBuzdB9RoWHVNXdQOQTW +a8MbfAwXSGf7/xHaMS8NSzdgGRrke3PUggZAl2jvl5yjYguHaR3uI9aT3rce6B0s +oZIqCgOEbAdU/oY8F1S+6+VCjMMkETsx2PdROqT0jWhMCzuNsSkUOCZnOVgBOCX2 +vEGWWY/dtKgeGAiKnH6qsaoRgARZsvMrXUShHgADSQYt4rE2ptkpxW7+iNEYr3lY +ZsmpYZL6gohXrb9nt5l9brRLREMQ8QJXDYycTuwT6sHig177wrfIp123W2UA1wHK +UQPgydPKNG8eoh+4qWMzCHbRyYhdZc1AhLRTWezDye1vRTul9zDPh0Sz+QwttgMz +RoWZTCXYYuVctbWQwe1nuVqg7a6xo8E0vpFCJjMIzs2iSIkF9OgNnoXlpnOvCJ+Z +IxxEge+/aVYYGp0UPwJVAGFTdtWFnj5KOSyINBBESB4hNvN8it6Rf5U/vNnQiNoG +/K6krt3bn6MMTYNd9fS0MDfazF8eapzAjODzhxyFgVTcOcQCeXhgtGwn1aAv3Ef4 +hEV0slVRXC94oaFgGnwxJx3N35y2TRZ/mhrG0lBEnd2aVoRXmm3Wq10uYfTa0/I4 +0y9tKf2GUq3sjNi68NscbiNuw7u+agMWiwmzTRv8EsFuyrQTMvDcMxpKZBOWVQyL +T3TkILYvmxgXyzY2txDqbJBZILsOR0YGzRquqW9XaOLqrrVp8myrR23zgWBs7gZH +sqx8mqy+CsoZZ+3E5RF6ieSZzBY/g9944H6Vu7Gp1O3I2QXWYHYGCbOOBDJq/Zxu +33eVgUDctngmIG59sfUd5u2fQhqxMWQ/FFzkvtgsioYxZhB7umTB/Z1BzOCjHavI +b8OwEof/zUpr9X+VgVFYkIADdNQW6MmKfGw/srZenqh3Wp5ZsY5YvTRLeguLUFEv +v+gqJ/BI5CP8f1FIgr7WdTSihh34qD8QQX0Yn4IAFQMsiKjq36xR5FVfm0uyFeQD +nDyv6vTS7qnV6djxEXUOqqZzzv7J9xQQDHqNTGOwatAysild1Jl+MzgnZqYE6Rqc +3jMRhL/NCWq1XwqvTkKdTI/ckBv1KQbgYkFjFh0EudRDSgWkbAQjFDCEvdADp4MQ +I49ukgPjsSj5hIBiQIoCJQ0lN1Rjd+YJEsDx7jeZnYhUeeCCFSCnDfWM+SwDkeGz +qDMJeG4PHJNp9tkqGfsvZcLo2eFazoFwXlNdr+V2fQn/ldlQ96oJdSmfkQUnOQ== +-----END AGE ENCRYPTED FILE----- diff --git a/modules/by-name/se/secrets/taskserver/credentials b/modules/by-name/se/secrets/taskserver/credentials new file mode 100644 index 00000000..f3aaf502 --- /dev/null +++ b/modules/by-name/se/secrets/taskserver/credentials @@ -0,0 +1,15 @@ +-----BEGIN AGE ENCRYPTED FILE----- +YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSBqdGQ3a0pWb3lvZXFWbTFQ +UG1JbGREZW9SS3ZuWXJhbTdvTTBqZUdhN0Q0CjF1cnJFM1d2ZFNyRW44Rzlvamlz +VWQycXhmWnB4L1hiSE5qbFozWFlGMU0KLT4gc3NoLWVkMjU1MTkgelpFb25nIEFk +bVQ3U3BsU1FkeWxBY0sySTV2UkxocXJpVXMyd1FrMXA3YUR0NWtTR1kKeUtHODVy +aXE3aXh4WkFmYTJtdlZyZ1A1QlhYZGZuTUYxYVVlblRUV1BqOAotPiBzc2gtZWQy +NTUxOSA3SGZGVXcgdGR4cFMya3p6TEx5cnhYcWNXR2FlVEk3UTBEcHQ3Y3RmK0lY +YlpwRXJGcwpwZUVqODB3SUZUdTlQVW4yaWlZaTE0RE9OT1dLanZlSGV6cnlJRElQ +UjBBCi0+ICFALWdyZWFzZSB0MFU2IDZoIEJPWUZIP1sKN1l2dzdWN1JDbEhEeXBq +THV0cWJIV1RLalVsVVp3RCtwbk5NS2pnd3kxS1RhNTNaa3pqWXZFVm9FM2N2cFp5 +TQpYR2MKLS0tIEhLQWdwL0VoT1ZGNU5UUWs0SVVqK0ZQTndkTURPb0VtNEtJN3or +S0Q0K1UKRfhyrcVb0EbsKj9gL5kqaIpfrsWd2cizrVQ67y9ZOwWilWgk/gkoXadf +q7QeYjnWsHeIVtSZIaHSa8+9pvKAwiYW+B6DjRi7EXkCYz8zGeanMuoKA4by5Q9x +VMKJlWk7c0WIzSuviw== +-----END AGE ENCRYPTED FILE----- diff --git a/modules/by-name/se/secrets/taskserver/private.key b/modules/by-name/se/secrets/taskserver/private.key new file mode 100644 index 00000000..5afecdaf --- /dev/null +++ b/modules/by-name/se/secrets/taskserver/private.key @@ -0,0 +1,450 @@ +-----BEGIN AGE ENCRYPTED FILE----- +YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSBtNkZidXVhQ1ExVjdEQWY4 +bUtLR1VCNUl0c2tQUUxCZXFRNE43aDQybFdJCk5qN3FGY2JOV0VjS0R2a1JTR0Fz +NTl1WlV3QVZYdTBvUCt5T2tzV1dWbXcKLT4gc3NoLWVkMjU1MTkgelpFb25nIDBm +MUl6ZDNEL1BVVHNnSlpiRWhDMStBMjYrUEZZZEVnWGh3NjFBYWh0dzQKZjhXbFY4 +NllvbHdwKzFSR2FJUEdHWHdBeVRBRzh2NWU1UUlabnlHQmxkOAotPiBzc2gtZWQy +NTUxOSA3SGZGVXcgd0MwWm1WY2R2NnhaS3dQYWZPcUtCY3BseEtkWUp1eURvKzRu +UXA2OStXMApXdjNEQ01JWlZSb1l3SmxYcDBMMUM4NEtPOVFvL2tHdlMzQ3hMN2t2 +N2w4Ci0+IFciK2Uicy1ncmVhc2UgKildWHNqZSA4QVIgNUE+T2EzdSYKODJIck9K +NzF0RW85RkJVNDBVaWNkTXlkbk03ZnBHNWFxSDN4K3A3THNVNEJLQXJ4MWxENWdq +d2oyL3lQUlVxcwp1VzJxTWpCMU9JRHc2NHZXM0ZvUm1MK1htaGFsTUVKaTZXbEtD +NTZzcy9hSFpGYmRzMzQKLS0tIFFjd25qSEdFT09LYlZCVzNNU04vVEY5RGdIdGs3 +ZkhodEM4SGZ4emlRUmMK3XxmNQwv5++wwwJ3CqpDfqKBLDcwyIfYM7VXqGlxaVR9 +TR9VjtFB6siP6Umo1oewRDt9Gc+MUI+rlc8aUN044ve5g+9im6uni2nQ6hubRZzD +Q3LQCLGGDiFL9+F7xHTLgFH8dIaLs4pnzeSzl+Od0Iybe05HOPGaZDhptqZvGWHr +uGHQz940sUU6k3kbnJ02qpj06AP3Uujl++s/4w5QKvVwx5m9Jio0ZOCaXv/6uUTn +Xq8l0uLMNBLtMhJsd4D5X5XRnvWSEWvUaQf2+nKFdCkxmDqxf8rv8qAE5ryx5SO0 +SnHVFZrSUhUDH4q2lVOPsGExwaExV/N/KB/24foJRoUafvpRb6GfNR8t2SmA82Qd +HVj2aqzuIcPBvefbq19T0WD2vJWHuF2p8NafL9x3KLdRIIm7urG+GLgZtB4am7BS +9B/bZrryjCVJybwy7POlIS1P+1OhuyNSdpv49tTL+v6o5PzGHeJFjykoEKyzTP5e +mqOyixKlbhuza5tU/ILvjwXE5qmeQAZv6tIVBSdD4+IbRZ13wuUHoQ/iqtmDH7e2 +4r4e5X4jyuQYhckJAHlkJ8WwKQ6EtXtZlDFU8XVwQsBeP42B+8W55fW62CCK+gLg +sdT/Y9dwHmwk8LNb8+HGOwlGrQy2fO6dX/rUvGWW28FdlcrDMRAbH9WR3+z29g/b +T//DG8Uu7ICY2HAYHkiFKVEzUNSbf7gWmN9AN8ozJ3hkDhEgbUPrFE2tryiCTS0W +EhdCRZ5pax83fqnx2g2a8K381n26yPEy+jSlCTwGHO3dIawsjdZMWkEKc0hCvjFg +eQTK17Ij4RREKGuMWpcA+7LnP93WdB/6DqpDsnUL8jKAFfbPYEpcjxwn/s7cO3np +uJ0YnkWl2YhFTHnVUtj7M0mjJwWhE7JDS+1TT6N4gnj9VwRuIEThG++kYnXLbsbj +D0VEBB4h3hg1zjgKWeT9CVMqmM8WIpAoO0Fa4N5Aht4GAn2fZYAjml12lLyHZBIK +5CfcEN+SPeNbz0nbcj54wdTUALFLOhOaqt/m5pwsmaijtwUFQ38hGWT41L00scTD +jAF/dJ2FyMMoR/Y9XD+vwdbV1IbLZtUIjBmXUTT8QvlgBqtnhYTckX0pZwVAm5lT +/U1djRHQuGWApDJrJ+T+cgog1fZgqu/0sksjFYIktAkEvOLQqxP86ChFHZOVacoy +bS0C5rpD4hZ4+EQqxlw8Gp1ZTdNFX97EM3x1zTSJXn1G8POCaWDOXOqaqZf0axx/ +ttIf9dEo0Y9cM6AZKmeUnuyJDeYxTP4AktRsLMZVQn9vGpQsS/wgf3832fkK1a/l +vnjiWhHPgusGhXXC8hMqHvlkRo5NaXBcneCRrZNVsIo7w0mWdVZoLiHM5B+8PFgI +3f677wf5pOSR/M3pXrnNeVQYW3rSBWzQk1iL7zGSA8kDAFAxS96Po0k2pTysmYdW +zhJ8eyemLPabpaydFhMyQMhpUX0NnLU+jKUatCuuOHTh+bMz55dysg2PArL6u8sR +9OTMsXrYPfS57/A1C/XPO6Athra8IUI6O2BVjqo6z31fX9m4+1WzBoWsyjEsStmI +eJ2+0lIkpOHQPQf+90B1o/Wwd3xJP0zBhoqwkQwsRZyBt/rGiYyUWw+3F0QLBqZM +8DAsQ78Iy/HbQTstNtrVjU+TwXjclPGDAqD0eH+z+5ABrdbqWrQ9VtiAdlrtWK1E +ZL8aJAmDhpPgbc7fvP0SBYtwKCfcIiv3AtqF5tfd+JjfigbNg7JlJCIeIR4tSe3l +vJ5icv3NhdA17XvR6rE3RXiinH4o0r+RkZGAaMXRZ+ui9arDH/K9xhT/pPOnZgRT +cmIN0pcF7LWit6IWtKbgWHVDV+jbUpnObMVOvYxzlK5D+jwiHzTP3gcFFprmZsNp +lm2cyaTj89Hj49PZ7CIsWoymLoJ7W8s11InYqowK9QBRagJAD/tr0OFzfhCCvAAb +PFTESchlH8NfdKziWDwzIL0RnaO+pTg2H13TXRsMmEubGEb0hvCc7Vah318n2rVw +ZWcayRQvDoVngAWqlupfKaRdLkqxuMXr18bpTKhhwzVVgvgfW1sojmQ2kGIHQjWf +xIW4tEAAaFvqGCTvCF2BjyPKkru4SZB/GhP9y5P2ipJcn//3Bkn5SZrhx6e1aqkz +i9+LHk2W3rrouaavNau7SSAj9EqIvbnN3zlcsMxwNIAkdOhP+T05ycGk+Wd38/iW +jAuVyh2yxO7W4vuIbjaCzfResW+5W3dm7LuxEB5TTiWUvTErmizA7QFvEv1VVZX9 +6m++4NvsoG5BGNMJdlpuO5iTBGFAsYSLEGAaqauySzeNN+L94HeSCdJ2G/hrCBPe +juS60k3y2CKIcm2k8lVhmQ/hi90aD4ZAMtxFEaXPC45N4QBvyPgYUxvoStN5M4S0 +VK2JWND++MTR4O9AAL/Vp+FXzY8SWhno2kdibEMiTKIE2BGAtbJBhEMXvAQOHkUs +RfhoRBunlwub/7vY27Q3xk484JrvubJASO6TA4mGD+2vV51B8hXh0N4nnM3LezWt +lD38JeL6KL+kicaSc+25bU3zYXsay4xCbnr/6ivKeDQJgWssa3PxDfxz9ro61Gxf +cv6X6NWU4R6NxAG2iY6V+X6/VFIv1d098JZrMVPSKWWhykIsuk7L+Q+EarWNCo8H +t+jomyRujJHG/XK7ccNH6J2bQKBqovdGSrows8WZuQxaMSCr4gw+Ae4np+uehIek +QomWmSMrXtHt36IFftNY4awne92jhNl6y7v0KdXqn0vrTeTKxBdd0OHgZ0AcjqcF +8DBoNSxNFthPpLXdPYelBvslWAX1I+c1aTWMYK1LDQ4sqRXT9PKTyyDRSbI4BNOt +mMSqL6tMugQP7E9zbibnhnOEXnsdykrDY46B+buoY3WU4JE1hwFYFN8WAYiLrBge +zoYB5tU0C33p42EVsmLlwyUs1WW0iM/mPHSmVYJ4zdrlxh9ibEv7pto0PYZFrbvY +bg2tF/BMBCA8ex1tssoTsRIYiRpFvXCjDqsUMEuMhNU4m+OAsgVr7l/s03VDrYbz +wIVDGs2294fTbyjFfRg7UMCdAm+Kwjx4TgLttSYqhejy9A7TnOJoqrRJQ/uaoy6s +NTxHoLKKfoyDcjGsdPNiTAVh5To46bGg4+1/MKxue1c7sY5iaaT880L2GLhYDhCT +I20ALkSm1jo7LTHqRxTNhmRmxJFQ5FeODTQ9mHxry12hnyTwqGoFCC2ggxU8iQoY +gT24nhFhxbona5QBHBHp2W50ybAJywT8VJfBmvOra0PXLbIeYH/304JAc5tt2ipe +bNeNX58FUwqHKU0PmwmQj67DnfTvSlDV02sae06Xz7dUUoGzVrEEZROHAA0A0UQS +NS87xqV+SkUpGODzsw4oV2wyCHBDxilxSR876vAnMhz02F0cWtyjcG+dNHoXj5PV +Ku7mBgHnO39Vs7NR+YPbBxqvKr81bSr2ny06u4tCeup+aMrZVwD0TC2HIhgbObkx +JqFrjea9BsZyQ2bWgcR/BCzRF2Dq3Rbo7l3WB2JtZG76QE6jQQRpRt0Bf9bXvqe4 +2nFvH2nBJagxw80iMJwhoyiGFVgOrFypy7Vc8mLa5DzKOKELzHSFIFtUP7c/WlOS +qqZ368Cyktp8y0wuEDcIcUHMGZ8yMunsVNNmYTs9DreUBLgCV3/Qo6yDo2+xduqo +k3nuMv6tmBDPn8p8Zy4LAvD36ENt5vfPlI6gqkv9zhD66swRnaFUEOzvqRUy0D9l +i5DtvUOvwkLlbkPoteHdNxsu8DyIasIXdAtUTDRnGliOf6284IiSLHIC8u+Rq7K9 +bCZtKYxQ9U+in+XyoFLXLouFUr8Cz2H86n6XUcytsnIvk8r/n10xijqPwzXeCwki +hfCHuca06sT89j1Fln3jIcKRTDBOaEbFxcyX9dZu7A/qVWTF1L8LCTuGT4qnjdrX +9KPBQ/QQWdKQNC97wci4gEDUkRWfgolc4kA5JrxWN0KC+BogNCTn/cGqflxR5XVx +J01q4niMVZJy43lI9it3cyQZVuErgmd67WAmXnYjVT1vq5B5afbfCxIIbrEdpLtx +AwFR6uwxjAzq4XbcKngwzA6gn6V715PMrID1t62ghrgLnv5jKpag4Di7ukx44l/z +U2p5bhqcLqvVCKTVRkqWPPkJf/9niC3eBEfrXWkd4SHdC0hvIa6N/jyzO0TbQWfj +4F/qRm14z1/cUSYiRitVRNApxUajPAA7T8jKa9S1xHT50PveursmeHdTA7415HS4 +1hzyiWH89NnHiKd47bZcIxW32usGZ+mkeS7KXeZk2KKVfXdYAj82Swp+jyQN13gr +OOvhfy+SweeulX435A6dLM3Lg0BpY4EPYGbXTIP7UyfVqaL8WzAsdbCt8KfbPJYP +lzW9ql5nIDQ5D3/lPGelL8yKsFX6pjettA2BVL7mR4HIG+YdIY0MefTrMTQim4bg +hsbR672UuAzwHikIMJYj8hiUNeYsiXWxLwq9HkGi7tReTm560MT3avYa3M10zM/A +On3NxpR66Lfh0hPX1chGvVzawzyHpzoRdJxSDZbiEAHdDKDemVdHv55FE4f5ivc8 +SVtB8TFisUY/rmWwM7IHAPYqOY3NEvtSkw4jPukDbAcK+5CRrye6k2bBvUBKSgCB +RnDCxj7uAsvnAA6mJg3ThDc78itPSF26iFHJzS/C6KXwGzlV8zLHEtzK45hKMGil ++jQPokKuSArHNDBi1IKBs7RiqEueRSCyfG1gq411L0C5/q6L5xn3dO7lDDJFxoyr +VNMyY411hyLuRgjqEuEHKg/mi9ql4DGK8r2Q5o0rN0eQF3X0A9EKPNZuG1xPAUXD +VlvNx8E0UnlZq20SY+1fMLGvLRu/F5t3Upm2hLHrduB9jDvqSYS+mZWRs4ZTsreV +D/gt6dRkwWV6bV+/NTj4+LOMIfaeT8RIPIy7QbZUiTuPaaOyHL9KsDqc1MTXd/7q +I/VSw0LPFGtcacr1Tald///jPs2tiVYUXpLVo1h2e6nBsQw1xdyYdsOKahhh/RLT +wEi3YSxBEcBWDjJQTK4nr13toEfFRM7MQNvwIlem4WuKFNa8XebizXSWrEeULa2c +03xj21ff9+oUBBxHfSI/4f5nmHEe3xfPTgLh7NBLLrEu80RZJQCVvC3qXhLiuLuk +0EPHSS4ByssXp4c7ong0qkjsqWQU3BArfvWsgfcUyO5NfB5zNuycr2S/Yocq/qOh +6nKaz3IizXuAGOQtfccT1IZkH/Zbnp+N3sW3aVTIe4XAnzwgEPhAe4u2mPEdvEz/ +aIdemSp6TLy0AtoqjJiv7MQ/cPgFmUlIXkrGSVSP4EGJHGOVY9k4zfWdvOyYJZUd +MELe83Bdqr9WCKfzXGWfYOuKH6AXdIBxyRYQajAq+XBqnS3L6mZapc6N+bVbiwUt +taUqekuHFOAQ5CP6TcF6GEdS/9kQpGRMDy6EqcE/UfoD4uzY/nRgyah5Xt7RWRxb +DAeEa/UtOtwgABzuzCo/9xQyDH22EpCeGpdrmR5OAve+CzZLjzuHXkoODZ32h4qP +r3q9G11CJ8v6krgWXXh5RgpYaSy/fPFyCfZ3NBuMDZbq43+cQ5/scarwOq8/m88b +SMXAGnmDxkf8wiHcrop24ItlQFid9gfjN8qN8wg+zf2NYakceGfpwYOrtz6j8/3R +7iLax2jahObi2VEtk/Z+a1+NWCbgDJ49jCDd42KqfwnGsXjHxMGvnYsWeupIW6/y +1i/Wf7Eq7WdjKxVmdvFnNhIRlWxBo5VQcDBYYKJkApnUh39DqpIYEz9I9+Gu+BPR +86AGNyBPH0eAgAP5o5dhReH/5Uv8Gk1Gqa/Oh+Jcf0neENCMlMA3/a86rcMbmggM +6cgvlmtIxEQGJTduy7WEvObUxg8kg9ZdWvKqHVXTc+0a3mZUYM0kXXF6h2vBIm9I +6vDGKP5WVr2c24X/lM2r8y1rgoBUaYflc7w4OKZYbv3avUFP+aEDF3NhkRmkrYsq +2pq+QOdOJvsiQT/4qZd7nsWLMC238Ta9gs+KX4NFFm7HN46DDU/l02LzyE6LdWdP +BocEObw/CeO5f/ZNB3uVx+ehlS4Z80bTy8D0TpdzVXliNmhBy5iOfaoP4F4SezzD +EkkQ3gMSZHWEd4+cTakg1J4dadm81TrefPT+h3qVrydVigDlD/daWZObUVwJA+7+ +r6FRkesf7/4qtOsgrjWVKDHBlBtFRRi4i4OycKFT6S/Vt3pTbl/6mT6g8Dv3JHUr +/q3SPEdysTd9QhoGQcRgf705qkYdjSzh7fuRPDiEblyQ5kWedWnq4OGGraXP75iA ++gJMSVSD8rbHErSZX/xI3anUz4VA2mUzhnGub5lyILqsRFg+kuYi5VLWqwFaBUc9 +6juSwIwp6V9T9YdetGk2M7g1kHxonfSqLVuFN3xm6zzjIBdvDpRXlGUzvcgdxmPW +FXQV0RbMP7rDe4lLIeHOftm0vLzFU2qW+8tYFWkh131N9Quik7wRGD97fSy4kqYi +XkqNB70zjv9cyZb2IC1/BSSaQUgalfjg02Yk5ML475CVTROVk2t71qU2fR3w2XJV +sLoMUta0wUN1kDSxXlTj7ZJd7NBk+KLLr33srJa5/drZJCB+E8SBniBsZl5eftVV +LvK1GYKLJkSne9WfZ82WL62DyA1RP5CmFYL4WvoWJfgiDIRsR7+pUkO0Xou5op+a +NDcbghyQJC8Oh9EbwpF3EgKz7kh1uLpOaPSnuRk68eE1lxKOB1HgK+vF1tdP0ntY +ljyMHauzDhszV7rThtcsJk4w2Gixj6wToHVZIGsxVNBFWQZQd5NeyKSBhgs/zFie +wyUu3/Xr0VI1cb9WlY2Df7KC1/EVesWzczkYsG+g48GNU5FjsWlUlvu1xdM504Fg +7NydNoOZgYdbv/WyXCFnMCMkcc/86fAYy7lW8mxX2qO4V7OV78sRjb2NrM5LEA69 +E5h0mS70xazckezBOan9GnCfAIEMrt/37cDch7yW4lEeYDggm/G7myse8Yk1FgnR +Jo8MF9Xn5MgNwKoHkVRP4NU7RUyiGwEpNKooSsnfisHqlNw5LTBHIhV1F4wHc76Q +k1zlMhLNeb0TJc62lOCXtzBP637fILa2HQUkGEEscTRfJ3dZhYRqd3C4za1y3QTN +4X7x1TsE4wt0FVMekJFmic4GZHHKazE8dhnjFSlt7JAB7KxbWGua9qPM0nPocDRW +RCnd7xTkgeGkxan0j08Fo8MLy7Z3r+1o4f0ooYUnHsLj7DQoB9d0wLySGhc8jmfx +1BTb1iEHsPSdO6zo9Gsy1WmRJi8gsWX+AX90JbcQy/+cWcxsfMvsePouBRh1+eUu +1fASdn+nrU9HaBVrqi3/Rm1S4VN+33nd1pUczDDfom+Mn6HR8LZ8dO1YQKH/M8ju +XLpvtctlbr5QjSsaOZjbUG1i/y4FcHODOkHYd6gxOgkRQsr4xCzj6fr4mbyzaE+A +h9+hFmM6cygyeu2xY9VXHOgjXcxAcr7gd2V519sOyfyqwGMl3ZhoEhrC/z++QnM/ +XZLOIKtrhNzDGvZkmlMVMIbA/oR49D28tVJeRbzecw6xliaXo/EK1OzAKKLe89kT +knNJEKI9eFHq39jggo2Oo+BakYl1eTtN2zUEOU2CkgCo9zNThdVPDdbTodMP7boO +mzEwOguEKpk/B0hSRrMjAv17gP530wup8PbA4UqvJpxXagFQYfxiERqPITE808uo +NKX7ZObJFScqzjcZsk1jjC2zfLHxYIMsnUjoHqYh3MgaxXlMNABGxhsurgMzztSe +G9NHlMrmloKzwpun5D57WLieN7bjF36rNH3RzTxzNqITAXpjMrEVp+ffmPdFF376 +vxeQ5DplDgYCHrZ/DhkJBzv4rddbIMVcHEngFYv2VN+AndgMQrUjd9qRo9bDovD+ +I+j6CpRPAUsM9J18VMMPPfPR69yuzz3Fao6tTjjtk4yRK1sn79+PgE0E+uFiBn1X +jDk99sWPUv9v2WY5tkELDczjcPUAsEXNHOxTDOtmT1MTpbnc1ckzgEMQ0wqjw8yP +HysBf5oCGJAMJj9F/iNPGPdrL6uPoZXRw8rif0DIjPiD53H2Qk1Dh2sKEHPVNmuS +SqgpaOwIcOYQnIj0sEo2gVzE88nP7S2/hf1SpPwhJAMwsjfRg+zHl7oseP+hrAL/ +ytoAT2b0mIfUdrom+8RVP8lAAWQOlB26bKJp6Ix1pCVf1PpXs1HUo7JbOPG8bMpG +RAbKorl14cbTDXcWZ5R3q3GliI6PDDBANUJDAODv/E/yuelwq1RHrp+4JyQJZeNx +NtM4pMo5xi4L9g5YCYq20k14VvCddYEM49OgUfP1jZ1UxzXh2T/18vHshMDuT1iS +zniYD4xpn1Slev48RtbXYVv65S5VS0YiEjvPuGUTYEEzSaBJfDclZ0Y18j+NQu7Q +LFamwBwtuCLdsmB7g/krq3KrspyrSZQzZiYc6bOH40q33wmE3JUR1qGwsgm7TpCp ++fVKnqRfMFaR3K/in/WvWzbVePpnInX0mkksxyteo92rvJ+WVvC+ucrdGxfTnZnR +ODbR3RGz/3kx+bwjFgP9ceBTkHaKSDjI5YVG4cS9bCh0NYHjUnc5nkypEqSYPayC +wP+nm5WzfSDJcs1oe5SDdwsIxEQSmJhGJdt3qvN6c1orxo+RqTrNPlDAtLG34iRL +DY8zfiJmErmGE+pkj0et4kymy2NFSybAZwrarhxgMDPy3XwnQu0jGaX35EfE4WMj +Os4gY8e6zcg1LcWpF8hK6Ebm+zUFZ549i56hICIne1MJ54KUlHcDjw0Wlm4kBQTV +4g5o6pRyekPQHa6XphQJUnF2viQH2rNflXqZ8lkvoi8EiXXlQi1mHXHUm9y7CTFi +c+1gwx+td42Ev0v1rb5LjJzJTKMeu2u2o8LhdGsPgneTReRVdKhEYxHed6X6omXr +uf2Zb7sVmmbgfNx7/vEwcohTkXfelCpX+2kQqc01Dm35FAlcV5AJzTUTdNu/WFVq +80viEwlx31O+8v/SEh616oop1falyIxeQxws2o9ghCfGBW7+ioAYI6YLArasoyyD +z35mfFF1EgJbKrvb9KKiIOzJQ8uOkxYUe+KN9xsGi0W4Ib/ofuGax+UQWSiFrh8v +OLEnY050ZAkrgzh8PVlG2FGB2JW2HLnMoTubCA5KKvD1eHlRtzcMcXZTaAqA5NSt +0pmsPvXwE+wtyhPe1dkxwb6FV3JKnZ4YjEEU32GiZkK5wZp1kNQBIvyMR+F3e5qE +oL1Lnd93t1OyzV3dZtMsUSzo7Uuoq+r5SW8T1kNVsySpJBm3eDrcfbEbw1a24xf6 +lcfSpAGcS538ui5BitHegNANviyT88wHO8q1i0qJJhUDHxWXJPO8kiKAI/emhJX2 +0YWrHTlmtWLdcp7lDTDB8uKopd2J9lWNvAd+b/2AmV3SXg5vFN6zqzmJiy98jWEj +lQ1BERW9NPdA7/PenE/T3cKHM7GUzHS26iDv52GIFgnigvK5hQtt2NHcydJ75usU +iu4W9P6oKYgA8YIuceEp8XdWUfqXm1/3SS05i0QiRIP6W9vhgat5Ia8sAlAtE3N9 +P8aYsMH9ujI36JFFWkYA7Pahp8V1CkPiMBAe+byuBtLzYBDpljc2KhNh7pFrzr9Q +LWaqhIPXxe9hVhsiLoYhPJ2QSM49Mn+jilu7Km9hQNqL6QKK4zI3x29IOv1drZO1 +R4V8Y3eVAsutu7fazpEMK24arggq8SxmrEK7n52gpHz1CdlmjjCZMyDNQ+/HOjmL +tGDACB4N7AY8le5sXhaiNVnIlqT2PsE4I+Iy8CodDsXCYf29mf8YikhxuDNlD/dt +1UFR7N5PNlxvF5bjYzEg7SX/utwQKCC/pkAgaHDOrd25pzO1dlFNmD0y4spbCDn0 +m42zo5NaN+aeaFWqj7w35nh4HS8vy1AFO8l2EjTMWxaewLWSgea8ORChTaCIILgR +OpRVAWNHuQbwDjcjkYpWH7cExb8QyHM9eZkxUkTT+FkekkSimSRtfGs/ltBKxL3f +WcgDcxMepl3EmLTPYNZO2O5sArNuV36RWyOp/eJqL+qrE+Xk5Svy63/Ze3mFndz5 +uivD6w3IAw8ukq/lLHuhEljH7mUPUlzNQGByUDZ7tiyFtMh7IMQEvhQggW2V0r8I +LA0uxANXHCaohykAOFFg16P/Nu+5id7m7zHD8cxpKOq73q8KKmznsjVv2h3jOkya +G7cGQcDl0VNNiZrS92SqJ5MdPQfr64A+oK2l+RZ3OBF9g91Vdc2PcWlzamS4mG6l +54+VOlQuE3ZVF/8yvc+RxPVQcaFsIynjOjQodhlBl30Jl/ZhIBZnmjBWXILa/eNM +vRU2L4NDnUZ7U75agDpn4NiwBE4bbazYLCazduxe3guXoUpzl1+oMASd7uQ9XFec +7m6ELhV9OCBslZwZo7GZiPzbhkxetG/a+dVP6YmX0ZHVwkv81NbK0CV3nv4uoTZE +94Dalce8cpfnKghEe3bVHxev+UVv5UEzjJ6nylGg0AmTPGHDOqPgV8ZgD0+6yR8U +CIwUxMuFvhTJPhJptbhFIPTU6vhFinKe7qLBCS1loHPuhOQNe2x/YRM5KaOKs2ZF +5m0kKZ3M/Wr/P41vpx1/bQANzKpilaDP3hXL7ZueHEbUxH6pPyxcaefBEUUsZ5hT +gdZAM5LVJzFSimP1rBt+8gi5dutsSMt5G3j08FPqKCh5TcnfJ9Ssfssl2THUSOVw +Hup2IiGgRWUb0XKz+thMDa0hFnO0Pf+5v9fFMtCSVV99MpMgxbOWPOKsurnGaJpo +r1MA1mry8yot7gS5QZKn0vBsbnpqJY77oagfBaAaazGyfiIKj1699v7L8vlJGjbd +c7atVH3zQHvyjm7uhN++pab97bKKpqYypBtRN/U8VFNyymcO9aijsK9cwaqlJ0L9 +sd1breWFD5JZI2eMnHhQeUzQ0ZIIUg1BgrxXEoKtGp4LyOT7eunddhDYklmpWKXN +fOCZ19dhJwqdC2WGpGpPlcKFzRh3cWilDdOdPr4hXHFktYuKs3L+yM7Z1TaGxe4x +w59HVTlPJil5larKV60zHH8DTIw5iaVdNueEo8FkvHZXhr9jC27mV80oiue4jQpc +JE6UJ2R2at//GZ+Ec29puZlZq9KgCYi4WHy0VHc3edB6YHK3CTEdDF/BDkzRdPCW +LOIbLn1mBidaCZQ5xYEYDmDSBWYpN4sl90XCPmo19LCfb7wD31EXMZrqqYaZyklS +Jtn90uP9rFZ8a1stgX3y/00Rv3avTIGBo7MPZLK7ELVgQp6vCDzu89meYVc/nddq +hWbvRoti1C+KD/lXDH93gZ9KenQ6I4UH29IogHaeJbRhdEJgxCo5GIlYm9JlGNfq +OLP8ZVrWGxcWQO/dNB/okH+jLM7G2cUd+KI2csis0HbK9bRAAdUyLSgWKTeTQxU7 +03O0NmKaGdj9pfoHNxwaUaT+nNZ52j6JaqFypWzHwzBmHj+plM+JwDqU6aJqIRVg +J8OOT97qfnkkd/oi6QJpPcQAm5+LfxciF6Y3IhxClcPCv4AfOLlO04E6qfEz+7rS +oRO4h6ShqTvdu3joZNIW+adkA3Jw/zLm2sRJzToOpV4y0aHbqs+HOYUDZjV0U10p +rVIfaH3TKuDDZlEStcnL5Id8qBUwhzE6QA22nq7LOfIyaxY4J6ol27gEmwmxkZxI +S5rG2uy93VNzGre5tz9daCd1JeLZjjgTj4+dR6F0Zg459+ju0BDFo3fDp0YwE25/ +ViHRoKvXNphGI/J2jl0TgBQqyc4cZ9i+SKP+X1XQKDY2kqEfz6rV6Rs7LNHh87q9 +4EtOSkE0vtOGj+Z/nTo43OGlmWrrchad/1yF0uAkfTNTzxLQ6pOjCV81yx/1zka8 +gwV8AwyCzbmn8blUszULeyRKwf5UxiwJeTK3f7k5PLRQ145ijO9ZZdiqjhiPsyNZ +JM5BhzIGXx+mVwqd1RSteyESAC0pKLRmUomjkPKC63lF1oZunJDBAYqV+3tRN2IY +NWqhU8MJg5ttSVk1Ui0vWW1pYpo5kDdOrtj6PEPYFzSP+qgDD+pU6A2PDPi5vaQR +Lsw7GsQ4+BrSOzxYdANKHhdLNiUPSWRAYQ/qqP2VIdXyGrVHGEJYRX9Mo/WQPqY0 +xg07tYWy2P+XgJ+DTZof8zaxADAsvJqBRpqEWKj/3zEtYbsq369BzlhZI7t0Gmby +jAXERxR7yJ96gC6+qL/Hbp8AskEdPi2mAd/1zEuqpHyo3jbOE5CuhSI8xYPUryKZ +ZeXAFHEPu92Uza1r6M3rROnWf3eebju2v5/VDeEfC3+GU8LPCkKsfsey6ZQE2g6j +4TEi4O+abOGuIM+cGoiAASeCfR2Ic67ppb4kWyz+hQpJ9ILSys6zcsq3r9SVYB8w +skCKKUaKzIp7pQ56RY40v0T+tjA35wwmuOyy4nKTUyZ1LYkCtIPEwdN2+HhZQTJz +q5iMQeOSdxDZHJJMA6Rz6XULS0TNtOrUOE/5rzXlx/E1ewvVLcrOt+KtxP+e3LUo +yWFQybXs/5X9YpYALQkL7umS8nQA6PVXsNsy92PQgBpiSZ2Az0q0osIv9wY9En1z ++Wuep7wmGHaWHmCSJFkeBRffl/2G4TLjoxXf8HqAZj4kdrnRKCxPWBvMoPwRmvt/ +9u65HOIrTnsjcqUKWEbVi3p6L4ffWMj050p2SyfKlJ2qZfX/zUDnhNR4hkCe06b1 +oMw2xkk4vXbjqJHbOq04dgrlAL3++RMr9n0c62Of4FpvYWaYKihjSPFZ77F1FNaL +Q3FtgvQ8wOxM81SY43Quf69DsFp/0REP8o6yDP4YP20u4fM+UYrCoVe538FtRYZD +hHl+zyfmV5mzlaOk/jJwO2c5M2+rDisW3oUOqAmQ1p6E8sd/0bdZR0N3Di6EHpyq +QTPpGb+ZAn80PzaudqQB4PwFhEeJB3XF49WGkLwjwxa5+zIMk+WSz88yof9t+ul3 +Dfo17kArov4zw49ukPzi2vYnDu5+/9FmS48VieJxfydIwPeYJTIcdGF8enrfQvA+ +v+5bcdvSxbrdOTj/Uj03ClobCyYl9BXpCkWAByRabpohyf7PuHyklW/KwwKoWy7q +RmPF+ceqjKsdn/MVKcBykk4ls3T9OCGHhR+Ps0VB5JhcJq2d2K28ManNTG7SOBDU +6bKWkMU+CPE/CRu46M6ie34frJA9PArIg9QcUoxYjfyYyOF33H7w9QYsGy/NtPlO +HLWA8p31smJ0lAVDRyVLqSoM1UO6GI+vXimI6LsvU8WXX4hmGimaaZK6xcqWH7KK +TMdhc++bmmeGKa5NXiKxpmxiv/hEaqcGXmWVWYeSF68mONAOYCJg6SuRxLQpv1O8 +nvd68KNBww8s0or1257Wl6so/RoBRCNfVeXdVK9sDslxJqZRAs0HuIZ2UwUPH58Z +VVMrZOeLkJSUEB0JfyJNBpfxp3TGydebYTTRrGBk3npI0g9vxELOqTvcy3jXNJOi +aRL8sJPSleXptMBWAy+NAKgzN9cUJlI/X5xtaqfaYIg5MvRmRuhnsjqQh3wbTsIF +jFJIz5DurqslVXPtrfweGNDIXqNGrn3o4899uQerv1cuHrXyTxaLWj6zF1naUJQv +YlBbsTuqTKHb9btzOr8BEwORJ1RpNy8N3/RynUds4eOcCdWcVse2v9Vr12RvoakD +qzNIvV+wz1ZNO6hm3/Tdx8iuDwsZKGbeQph1hcw05yA+8SzUtmOFzjU4JKupIPHu +v0jzjoZNPYwFgrFXtTxiW9/ThNRTVIxyW6RZC1lI/K2u9gtMui5AMv9t8zf99qIk +4bzWSaRxArfkCqHOjezmgBNdhfk64CbA6qwH7tma6oyafUusiLmD+DKibe4D50AD +no8hmoFBZvoy3gbTvNnh9Mt3zdBVwo2lc5secp+TwFhccby7uEs03M55ZVKRMC7I +1w3yeEwbNuzlid+GevHZJ/A+Q2xkTxuQHBO7G24TbAjn+AgqVA1MKW4eCfy380UK +/VPTRWIcM1RjIMbhh1YgPYmcMhUdhY4SZ7N2YMV3Y9DdXjyXt1djELfOJg/CzxiL +2B+b8Xjxal0PeqS02KtClXvC1KfXMVdO3uJmFMSe0AEX5uXS9kPmCksQaIshuMFL +V11JpOkM3CUDrv7AzjwWEiAafUw/lwSEG2RaPCQcefETNo5oZbobeSmavap2WP+u +Nax3ZTRYlqGo++4L6zN/Go2NXOdPF9tNESIuJ7oDcZJ8rSv2NkjlkmaI0zhIHWFy +UZJTounvsne7IZ/Y/B75o0V0R2mXflnNTW39TepWXAuDOoUrUjFjO4vnYQoApJJN +Rrnmt85R1CdlIgUiJx8L8wumNEuYLe0iiXoH0inAutNFRZiEMizMLG4ZIp/s7hBk +MKTgv/Mmvytl1yCh02r8RF1Xxy3iQSOd4qEnWEBpfiUAec9RpS657GG1nsWAV0E2 +sJClGSfVF4uNILjH91pVslVivd+LN8iGYwSEVloMF7h3Y3H7X8277FF8Hb1/qWM8 +hISbNLLC0xMy3xtR4wK4/n2pS43K4DiGJCr+Xs2OKixjglyB8bhfKy0dDjenTHc9 +tz8y1MrnJvTCQnQVVyrlFbFaDG27mo2M0lk2GaFzT/iEB/NW/HFqMiYItAyVpVhw +XdAur34jAv27tjoJDeSHKAEyJQnXoKkjik89iyDmZYTf4SYt/AfFY9zujdfzhFnD +oiK1paElS6qlTOU0wjL7CblT1yefde8w7wlDPqJjP9e0R/qNF2c3OYF/6BH2gHAC +2pYGje7Ls+YuPY5x9pEBdcuo2p4Rjob5qnCqm72BGEj/wvWxqrDa7NMiiAdRsuu3 +iF60KicP9L6Ul+/pTDtz/7uvXFBHBX+AndqmoUk4A559M7H9tszXSOlauH0ogjcI +h5zQcotRmh/8mGL/vnnkAvPfdC9wvWzdrv7mKO4Qyro9cFAGEJxJjGYDNXZFFMa/ +viX9zYrBwl1QsFOGEBITUGBLitrUPXRKMLeGHvWCVAyQZtf/dFs3W8CV1dVYmtsC +1Gz4EKeA0bgcz6o+aHWNrIqbOU47mAIej1EgF+hFwL4/42JWlBYAMFx4TyoBhE9T +lQOBnnbrjf3vmsu6M7MhOHAKVIPXq0XM+UU2jFnWyfNnV+TljCBesVCtucqUkJb0 +tCb2/bjCl3P1LsGiorDn4E/4Xhl4JamV1utY7t0S9woP6lKMvDGC9Gvmedm8lE5U +Jhbis5X6AgdIZY3OsuM6WBfUcSiov8/iX4dSbIjOZMHM1sSBZyBGqOndM4imUGYQ +AeWaaiUIU3+z0nzNBJ7k5yZaUKMyfquG6qbmdEimXen/Q5/GmeppH3xiYQWqPa2l +b3eDyUfNYwsSaICs4v5Lwa+tcl5vHXTLa7Y/yH6SG7kJyZjvDQY+iX1MBIb4tioQ +70zpDLccjgUIFQOQbCiG6X0u4dXS2t5RupX4Qh5ZxoFIgpw4X9O671aYr0NjH38I +TsoOZRpLOrS4nap/fEVt/o45eSJ/b2Y4hphER9WrRB0JGz2i+5cAvJnQXaDobrHc ++ncgPqZx64qUZbsfD14R+PuOoQzJpWmrX/pn4FWHUZRlqgzrFAdTbyAXLnhyI5qf +5ZGeVstR/JRWKeLE2HErFrq/B3Dm5aOYpFopysoNOwhrymhtU07fZQXRD5FMqbIi +xLQJ6Lk0dV2KVkq4ExzwhozCU/g7f4arIPZj6Sm7tveb73qGxzWEMqvs2VXphka2 +jaPCF13kvg0DLUJrqMSdNZkTZ0nDECK8AfJaZ6KCtKoiIzDGSewoN1J5soCahoFc +Mg2Wi77MEmh1UiXWkhKmpK0yVabGKoPZFH6yuK00xij65gBOJaob8Vpxl7VO9GsP +XJiQGXcOIfMj4nh5+Uu06R6hXAPdq/JLQOUg2v59lz9JJ1XG26+xg8lfNQgw0oEo +sd9cZmyAlAlgtf3qRHU50v0Mr6PjnT1Skpc6ZKCNgRd5u8zs87xLTjhHr2Xmk8Gu +lF93Ba338wy5+hfZAGf85u4zZGqQdvZ6w7gX9cQI7RTU5K+r8+qTjqw8EKkfW9gC +7Qp8PvHcObS3ohBxsUhhPVOtXmb4qUNbS4FNhaqyQYs7u3+EYnwBcb7b00TsrvMh +ltazcaU6IBFLrDEDfohczkif0vmBS1TXbJHZCAHqiu0qnxGEtYRhmLBx5DjElC7m +jlQROQFMazHSW/BonA9VEQjOZvpPKd8c22GOuKsZEaJ/11Bt1IrUUoKTdIN2f4MP +qkGA1jH+hmNAvKc9VfYBL42MTTsRJW6AQxtA2deTYhrZndhiWLzwQZdYlJUHp1Ve +pE01qI0yb6NNyPdP3T50W/k/ptIoFJD+RIyub/rHSDyUvUn/ZdYgww0YIj6n0pvE +Kl6cS7FVOskV1O6lq+BFLF+rgliGPKGF98Mzo/skooRssyLiMXh1HPz9mE6cT+Hs +Hw75RUlhLC2KwpSV5bMFosezzPRxUZ/P2ZbutfIGLow78am6eAI03mfZnU/tJ0TN +Xc0jGm/SgTtjsNeQuoFw/UDR5FJqYazy8ups4Ym+rHbDoQG/9WpeovlS7Rd23uhF +tmIdW9IpKnUhp5J2s8OLSDhrQKj220DVNiDAgokJKx7Uz/tF4Acg2jLkJ7r5sjl6 +iRpxYS4LwfCvoddASe15FfxPLEflGDhDrZpYphGinV8uleSMU4005Vo9InEJhPOF +mWLYh3WJCCs4uJO/9ePENRhRpwjxQova6rPFwmMcXQ3DvYnAqrlCh6d3R0OkEOZ5 +4MFtJAECSQd2mjhXGajZpdlPWuOgNt0zmkiFZ3/gna1k3uRz2ygcrjb9uuzc2N7L +pNWbdQztpdQVGqP3SY6PhD7t0k+Tn3qbDNYrekJBFRwpffAA4a3T04ffh9i1GEbd +9+q4I/oY8yz3mx9yjOyTnUsj9QRbrycxBddmVffRYKVIqLuSmScw914MkhBU3reg +49f7XF6JhRmT+tmd7njiQ44lFPBr45JUR19DIrzVzROEHz47b2Qwo3XCTCSW4Nzg +kSa8Ll35WdKb+1qIVn2OnqB7X0cb/ZC8hhNnG9MOXlgUusOwtwUP0wnecXTN9Z/9 +dZ5iT4gE8fDnGBpUPTFbzIl4+VjCLTAwnvb6vZLKgFFTmgsCJxKd79SHC5nxR7Vp +jTo8SmtfWt0onVDNlA21ctT7MwGVI0sb/TFWedCQsSyFNM4KEbnefVG//xXOyZDN +a36M1ScdVHFOxG6KumOCuode/Mvjw65TevwnyK0Jv0hsKXkT+IOpO1W8KLO0dMrK +wOEsH4ukgQwsjGy9QIa5bSkbGx6+RGpkuOHYIkhLhtW4xELm4hzRjaqWz71KGU3o +16NpRwCZHtDo+95wb77PIbWh3tsjSinb4r4ABsjhWVZ6QUeZEUv82QLdby4N/2t7 +h/bAJkTY/XNB+c264jbkLk7jJUJUdD6hXWbNSFYy2tE8u7VK5SLc/oaNw2Em1bTR +7mUO4aVDEzx4IsVFjij8n6aBPo6h6j2UrpmirMeNmXIjAgJQ1FgcMwcwpWe8PTQb +/IGjrgd/LHBNrbWeSwFWP5OOpilyYvbzjaPxCh/WWPuSUf6myUEmemQC0QUeOa7n +e4LVPV8klgQ2Q3lTEzmOY2StwMiEr6HqBqHIJRj1Q9ErZNCKZ+XwC+OZfI7xFevw +ZC92Ot9SLPaBRxRqv8nYUe80p09xxsoEcOZ+XjpYdzJd4h5DlrtjeJQv8uOHcn5g +ssThm5T6eeRsTIQt+RxAG2pRX6kitRvpMP8Hd8HsTZNCV7T5dkA8iG9wnr4wRQpz +mgwy1tByFdxYnMQEmF6P7G4EqfIEtoKsDRSZCK6BAYBBlPYip8e8nVCIrY92kIWs +V0aWJbbXFP30TpyAAQpH5Z1YKiAeHrR7ojuBHOGk2XtKk4INWq5KzYyIp+bP101O +pdFWURDouVBCiM30ckzymwyC9dgCY//CANIpvc8/YIOvc+/SEujREzj9JIAaPm5v +SUpwML588qo0Juoxm6BRQ3vuD5G3yfWZIdJT8N7MLvsvHJTHE7mBTG1yBzHUEDxp +yJ7kcK0YCrorNbvRfPmWDRJBHwbiP8tBqEUBvp32VXVosNH83m+3V6AmsmISR9xD +TqljkgIju+n3KfrG1nRBHLKa0aONhlv/cPtvGPzaqYpKlWIGQ2htkMxZcg3tQYgS +PpqDVwwcZWG6GJoXfHIYgs0TadbXm889e5ixU5XsD7nA6Ha7+9UYw3jqQHc0MZhS +fq0MqvQcvjQqtxC3e4I2QRnoftDEtB73CT45A5HSDDmphgcSFcP6s1+ss1NDfsgS +ukp4nUK9I1XTJM6PbqOxoIFpCRyT+NfJQtEH1kHfbFVe0URVHhYi8oH4xOsJqbWw +NrdGyhK1vWBIVDJyUmWYltd/ugxmCjyy1P+S9/JTvcLGjYiMXcpc44ppe8y9XYD6 +lrIyUgXYxUArk8vAR+m9F8vY3t6R1EH0m8hEHT4ZDt4hoEkG/Uz+eY/Ws6bXR2Wt +6KFT45gm6Vlcb6zL74IuwTmoqOfH9dsQ8CW1VGMbnCbSseKbfuGEzLwQEqdZ9BZz +Hd8n2khBKkdwhy5hlOBFxAqF93FODcHUvpq/VFYP34f7t/IVqWCakWosKPqwn2jG +Onq5lYdmxOH0NiMSwNB5soRmehOXoVPn2I8iIqX+lzFT+ecnUPXKSpaYk0maVdPp +MDL1HB2uwWngV7tIrk6jRly9ad0RhR8hyJW80B/fPEJxR84jYjK4CxP009c3PGX0 +Cfj1EGFWyOLeMmEj5TEbJLUqy5yk3JEaCEi4KhDfm0Iri2RhDPauvPY9smwnKxVZ +qjHy+PPy45QZogwdy/Wrhvvt1RUzVwDHp/A6U0MqHzTk62qrKfTMv9pK2fY1Mgkn +TONR4Lxeet4xgGCswnX1A+qEbgihJnDkqJJtGb/+6FN8wQLLTEmJ3jtwTlyDRbtN +mE8yoyemMeaflV/cil1zq4Itdq+Mn20cX1EpcgOOS+odLZMvPNojPE5T86BompIR +EfWPNmD4fjtp19NStfUq/uS6gPyN7oD//C+dGi4eXf2muQuPV+QkL0vqGOJHWgHR +DziU0r6zqRbm3xAFZmGSp6yMVwF7IVi06P+YvQbx5wLbdYDOd/N7GsR+Q3DHYZKJ +lJfdDeCHsmtLzM1/RqEK2jCkIP2K6iX2sI8lRl4T59CLZ+f39SFDSxAOBsL2dtG/ +TR5BrZFJFBGFOYwYxy9v3aWfVzlMIPPsp8+WFGgxVGCSNsucSxSgWf4YGfAzs2PB +cC5T/QRRnmjbr8u3eG6L0oXpUQFChlw91zB04SzrvM4q5paKqg+3/X+1t3AY+s8g +3JmmMccq1aCKZC+fC1pRr0gnEPj4uHbqqxAstwFECqYT4kQzwFJvwot1f+Y/LX0R +aA45WFuqWXQ31Woo9dGefcRpiVk/ja+22jQFZNQojyRZFFND1Ho/ZgTZ7gg1lzIS +DzNEdjELwkkaxR1j+yYq+Njdy2GJUD4ZZU07dIY9ACEOA9zlCTRxhzNnJrLagd7w +kTJsZ/GdRx/XV3D2XDuPsfq4ao01KpIxQVnsDf10aDYM/RFtBoCt0TsohgYdQMd8 +Jx/8gDhktN3SvApXK3WRuL0z5HNnz6mSvavjnPp4yq+/pn3MrVtqhdRN/Vg5SLV1 +zbMj1xB7xzs2LRBb/ePJ0/UDY6hvRUwZGwnQ3Bj753nVhwjLkJCIL6Gc6FljevO9 +H5ux7beWG3yS8xg29Kk333oPPcwXupET0YQRTrKGbaoMHv+qlpoOZVDHWJr69/++ +V5cMS88DqQxv6vVqzK0HI22vi9hJm6jjjWgG5C5XQz1ErD+BY/7GblRjlxBDQdxk +rgUFqiadFeShRkugiVdbuL4x/tEyik225PQsFhmvk/GvrPup4v4Ww3A2JaZ87U02 +RpvUsLFEjykNyxOD7XJJw1dHYBY7QB4hfnbvetfFZ7A7Vc+BzMb05VKu1eoJhopq +vlXfym8rSc8RCO+gB7azOpzujqdhowFLl7yMIQJbkezQLrwOgNswplpf8Q/eCaHd +W9pxw6mHXvKfzN6a8IAs/lG70bxT91nOE+4olTjuSynDn1dHt1XzAfjh5X5/qdht ++WHE1ssHE/nPs3m/xxxjUtD02CgkWFX03lhx8flxXv31UyFceZZmaICp+bUsFO8c +dIZ37q2so55B8W0F4Q2b+CH6RtSfDmRr2Mta402qkc+E9AEDRk81Z1sDduLBRvCo +AeXEbWJmIi9Z3vohFT8dEPORoJDTm4tAPAVEzmf6eaKVQC9nQ7xy1NSdAU32eLvA +hBkR/awYGg95q36KR0oPeIqg0Z+BHM9IUxNCXhYdwwTCiCPG1/g7PqxQ8Et2mXYw +hJp7ZdFOIzwsE7nKc+kVlGs29nsiyI3KCeXjN/i4PKldHvKNn/CsD99iOLAA6Qno +fWFsTFwXSH/7P7Q+J85vTf3Kh3qy1lldpdRqAjMBAIZuoJq6DCOmOnu5LMg7sbXd +jFIUpkPBZUepMiQmEuDljbkt6NbOKoDRif/knzz617K3tU5h8PT5VCCrBZOBJ5JY +X9VdgJCCNfgbyzdXsBNvZfQw/+gfJKQvmFY6cu4nlJr3Nb6hI9cbr0FLckH7AO9O +3ltoIb8BYdPdYLUJgnAKaq87sRBEiU2MGUBDPqb8i0kLpcDpkogGdkqoMRgxIW7r +g+kQ/82niUKQdGnICFNWaEtWPOMAMoZNSXoGnfXDfEfg3xpZAJGp4hJgxxAX+y1Y +pQIHVy4/axbaHO+1Vr0FmkSiTe0jus2FmQmTq5QTStVFx0o5NAX5u05jAp9FSXt+ +cIzT6KmzIWqboz5tzUx+ikhHCrWTGEO8r4BNxraSU/M+l2Qo62he8Czna4DJVm3m +jWHqkG+mVU8FVnLI2PN09B9Ylgil1YrJvvhT5yEhJrDg2zME7T2Fg7nuC6unQo5a +U5p4Z/7A9cTIbKoMHiivix6oiySVePTDY7Xx56eS5SkF5yIcYkrM7gNY17okRZ+X +elQbsajwmLrmEkh+xXZZzAmu5kFdU+83Nzxs6onfHsTP4LyaU7PRl2lRyJD5nsNE +i4Ietk2KpIz/UsU2cEbTDcRXU3GoFUgOLyNG93QUFUS2bxRC/SFdvrZVp+NZXlmo ++34L6gb2OrpX0W4Q/XAMkYybnHjIL21t+kZkBTt8QQKb7cNKoMmvmomC6ndIjpdM +AZNbrPzEm8fBm6hrC987dAYt7UlpjlwP9aLKnWzEcMQQ/GaYq/8MvZ+8CQkhy305 +b6EApZ2YyM/PNr19rSkTCUJAEOxSjCR+YmNueOZlwpp/6IzvyRgAf4WW5ElcMAu9 +un9J6aRMZL5f3n2HfZdAREKXJkgaENzOG8101P5G0PVedYJA5lkudrhMfeT4wnjg +XAh2bsXmGVRTkNUtin6I1Hn58DcaRUfEnFz7vZVqxpsKx8AuETRfARCdcha0ZNr2 +akrkMz5iXp3ktvOkbJdhmkESJ8DAN0abgu+0NboPT2YgBDeYGxuJ5j9IaBq3CPF6 +KEMLFHZqSyZFSiILvxJsNpCVXaFq4dIZJUcOfyJ0iDnO9L1fC9yzHgPAMx06vtqQ +E3Rlfrbqvm3tx1ja2wkw7CWALENWaITnfDj+nLxfY5hL//9ZTacgvNUPpLkg92hQ +AS+pAVtUR0YR6HXE9pKhj/J2mW42/y/f0DtJwmd3B9DkQ1FplDv3lEI0GuehtfzX +WfQ+VeHS67fwDFHXVm0BZIzePsWlgDti3O4r5iZRpbXJ51m1GXeICT3eLnMDsh7M +1MbwQQpfTvitNZRe0bh5Wbds5BfHtAzcWEOHKriuLAZJfw2y1+ZOyhzzwlpTKjYS +BT1f1wMUAZTCrfya5szv98FGAAQ8Us8svEogTR3YOEuaqRRmXK0n32XQggjnMmfn +2JklUYRYLZI942kSs85wEb5bRWtI3xoziM/nl+iYZUTARUFcTolEvEQiTrSfxtC3 +oIh8iAIh+HjzrR1zkcjhN7dBn7WwmVmG1aPNvmMJtTnyGGfOg4uupQmDDS0GkIsa +yHHMOTI6ybQW/9i2XWCwwzPMWwdwC4kKuau2y2ZbJ+6TlbK0jwSgsVMRIcyyNV3+ +uMEMU2Rh2w4f8VTvyPu9L4m+pMQncD4BeMVsrjzgWLQ8XHa/0CyTR89xWbJfxT1W +c3w/kfXzep1sjDyCQMbLvDv54PGFyAXvJFO50nn41fVohB7yJDKBEb3UqLvp1WHf +u3uIUVMSbSgEECfptK8MrDnr+xzR8AQSWEzV07FwYI9AaW7ypu3V8k1Ra/IKgkzB +Gl8khKvKMwChfnFxGHk0tR59+GFQtr4Exm8E80QhmgCCJeuLteNoXqo4f2pYVXzM +VXbSYgcEbC0EsdYbqrdS/t2KAxZySPBL8XLK0D4iVs4LG7pg/qgufLb9Ui43shho +5UwYyFJdFhwQ54xSuXCgoTSfDT9C6jl+VSAiVhlJpRSw9kRGp0WbZZhShSo6SxGn +2kNBveqi3jis4Tp1mZEvU77NHpbkuy6maSMwwe9mR6t51k6WO0nIVyhoMWEi6CqH +YvuEO1dugYrIb58UhJb1uOqw05dl0pP6h41fx7CcPG+TUuvGS1k5/D0Q4ObqFYtX +NmJmfcS71pr9qgkrCF0n4tyTMsmpAu24c0S4+qzYcBfTz6SAJ/5fRmfHP56WmGJs +PuPl0nrqDU9WED74EY+SupfZueiGz1/OpybR395j/0Z+UcBjYMSc5izJf8+ESH0G +CqZFfely7BcxKmfWU65CfOjx2vMuo7fZwagVMPQ6ylgsmlW9diz9Q3cHv0UhfhPF +3x0v8DNbltxSfll4A04A+fIgIwywHqqqhEAUPm/9ip+Xo53mcR8QLtH0gDr8dA96 +oPYxpwmS64E/1Vw4Nd7h1qowDE9CEflZG+5kpEcg2Q2gXiSWERLTIlSLa33cg43F +3eC9ouF1zgNLMnkKJXt+Mjipqk4weisGITABI402k1Frj7E21UeJZV57ySgRQs88 +KiM8CMhPaZF0H2u0YwZy808nOm61peMY93Nq+k9NttUirdmHYIqxCVFD0cJ3kRkm +bwPgOfMlSUUcSC4k86xziocjptmWEoDXWCYO3LUFCBYOWjcxQYcyonVagyxAPKts +xUF93YIr9Sf88ati8uX6zLcsp4qr/Yb+/0lW+XkSy91T6GKKG2CEo0rvRTAC0Wqw +/i6C0vCm3WGH6kPOLgGWwx3XWHvL2OJ8odtOwOdvLI2Srr5GePxS71AIZgBnHCUz +xctijTUxrIG57w9ToXnj5bk8hTyHKcFK/1p6OFdcQb0m3wVpoBTZtxBaJvtybebD +90facHudb7hygqVLuwwgfMwDzHViZGtM7mtkaf1oJSLNYI77sjLScvAEJXdkkQjM +JctKP428KHsQdUFtc+2tpsut6f5lsFGKECRhdw4iMNTNl2VMYMES+j52ZleBXXIa +xDeXwD2vVxkUKbnLJpvfVQt22UoWjVqbVmRX5cYAzjbrRu7SY+bRrs28xdo3uLx3 +qsc69DTR0apNHZthVvTtpZ99ZRDi97XuCHPEqbaDbLbAayEuLKI7rZnvFQ1WnlyQ +GWv+cZ+uFzxmW8JBdAdafjOjf+i69u6W1wIrhkpfnTxbkTsZa0dDbpC3LmKL8quY +Z/W/Onv5TRV/l+3dh4SPufGMw5b6CW0elZf1geeTz2fKM/M84xkOnSwk72c1fM2L +15U3MUbeW9kyKxq840CkIRWNuUp4AwtfH9oqdObFpVL4sOTYPHd7zx903tenAsmH +Q+oo/HhxrlDpnVLeHdli2Lffyei3E5TRujQ/XdEvcKylpldMXCUimhiW317SEjip +Tx9OeMUHAjEsGTp9qln4kgA9GTAs+3Zxs0CBJcWeiumd+qhfVyiqxkQ7spy6Yct2 +XuZcFzax/FvcwMZjXBjpgCqeYImG6FH3y3gtkm+ZhbK7qcw/FSR12/xew0SIIVI5 +xU4kvOmZd6nQojefy/S/THwcBbeihstfPpjH0kJ/vOfshfTYawP/Pj4ZqDKv76MJ +i45w8i4UuYCUtEnxo+3KeUMxdofi7lMpW1m4UlRUwHaSlb9blkzYe0OusL5IywP6 +yNqQ4ns1hs+NR9ylsDTMz4DdtgxxOcrdgXT4/zjMQztUe/NwBa6Dyj+zjap28lry +vLHYtpKRtB50JaC2j8RRodM/56YtENOU7HfS7T/FCC2nDCK4Th+saeG1QtQk/2uA +y/ASPmk6UToUYesV0TLCA23JftSZoaVGmfDaM5Zpko8Z9bW2MauRB9cNxm5yE3LL +5TKJJ4R2yNVHAeSNCVtZC0n2UjM/eMwqVQ/pQsWusTgoOeRBMCDc9j+3nIrg6j27 +QYMp3yKZhDgCeCEZrWD66PZeMGm4Q5MVO4g982TqWyDlDe2sragxRyeYwGSRc7VF +87VcMqGO2Kmegzhacew0jR/sbT9yUjAYHbTu81zHjDjCfeFqYbqo9YcTId+pzKzM +nVWu+DQQB9u7G/jIWLb0VR/LcD+Chs/Sd147sCy3aZiWwkgMvN1Atrw1JPjeQoyu +hMKDdiCBiRhY4VDQWtykaQGndrrxkYyS2d8MQfeBzyyJr/v9yhhRB5RnJnhVSKUp +LlN6GvqyUY38NLrNIMUxJ6CR9GvaF5/eIAopCAFN9ViAIAFR92ItHVRby8I0JY3S +wvszNDWPxwao5hQOa4mH4EpCE8x4y88Wo1uVO3OexwnK0ARWKVuv8BgNm/loojxR +GHdPUEuZiS2SsPZ33dqB5oblMRF7eiH/nj/dMhyzUWaE0VDww0Ve7VNptk7yo7DF +sJpaKMIpbpfHqsuI5P+IBcqPvg4QQi16Q4H8BwkmHV3JlQFWeElyAiWD5Kpzg61T +iKTL4Zb2q8p3MqvWe5XqYoq8lji0hNsgLWPBqPobRYlrPHGGKL6yyLA/ddy9z+L2 +3wXPmzEADKzi604M5EZlHZ51+60HSypPA2fqwn0+4EdycUwa5/a8oEEvcYMxCA+q +B7Xc68bYgpM9aO9TONOMWD15uxitj95t71/K+AxGMOr/aU9S/No39VJiCe9YTR5l +3ZamB+FocLtPEH0/MVnMjC4LyXElIB/gjwEbHTADsllErgDQ2TSrkcco6K9HeBHI +VjyXcI7sra2vNiCMfNlvh55XVDh11sFd1dJhInJHMhN2XqxqRqmQ2jHGJP5fhr2q +B6rj0DROBUssMH9umIYhp62ydZyfLQbi8vWjfe8TAPPcolfgBceD8/RmQjWtxGIs +HNg9mQc6+kaBK8QLHaFZs19ag0NWFwSCwNMjVc+uMZizO2ZNWNCEunEAq3R/qivo +fbZEDOoaYi3c1EtZnHS40fJwGoh8R75CW1YgT0zeG7+gB0TxG0XyMa+SrWUgVm0i +aMuD9kgdnqpoI2XwmGJ9vWKdSTZuSyIH1K35HQOw7rfX48pCicv63gYkwjVv4bmW +ldOXdfHOu4D6qa7Jq3g0p02SxgSzpMq1dZSMftMMR/E45YVZrarOn7/cxiFe/IE2 +kpbPi0KnvWH6/CJOiBxH4DEJuDgSCQfX48Fl2yPDYZwoFHZ7SIzdwDOwblz+TuS4 +YCX0/slWc1/Xd7YYPDNnnyQcNIdOi088HCklszmQZwrhJpzzaruXpChSJjbjs/Rj +A4bKNIa4tOepqO379cIh3JUCceLhFGI/6rY71bH0yQ59FtcFUjW0r1onzXKrUuXp +uhqoc8fEeoA8YOk/KtL89Wgq0fb0ON05viG3FVZzrMNQVvLpLhpvvksXHGShPJ/g +xm77d8SEedxEdVH7vsvcaztUvmf8mGfq1eXZPCjGXa6VebhVNB+pheurycqNx7RS +DM1WaD3cE/RtiFw+9u+pZPbIHCuk7N5EtmUZGvJ5CCLvGIwBAv/lb64G9EgKKFz6 +X3xDzXMfoU4MDQfc5bCM4zhkeIV6nuu3gTqK6KLn6DRSgKGga2HcdHu+rnZWdTxQ +oo80TjfwF8TXpmN7sNLDCDK+dnWS75lWZFpsjm/K9EHru/8wPFCjz5nsFR5rjbVm +BVbc4Z6+51pc9mRqqCApKK+ozU7zAtmAD44Hd/cQKdK5aYM4Yt3mLBgpzjw+756l +M/rUStFPt7ZxW9v5kfNDxNtqAFFfWH3X1OURRzDpBA+UfYtn5Mplwy0Gf5Me45sg +8rSnvGlQLNTotL+TX8yPQPkKJATQeZwu8ry5OTybbyPeHzOceIv3l/UjgHlCj6sT +aT2SSJFfi4ic12/zV3FykPr0ZjOqLYvlhMN6ziLAzlp1lCMPzr506k4xN1/zwRpS +YEx4+g2VbQjnVryVm13D2uSIqWFt7cSp+35h4LuAl2NfBSjZDDMy6IyF2xf0gnaf +seqm0yBHNSs0U0MDqLJ150/32sjuWSDm6BzYELXTs0v+8aKXi9cSPcuZrRXgtA/Q +EW67SBaa/dxN8kcydViHufaAbq4BFEz1uc1N+RvHZEPacH4ou01XY/6fsl3yZBeT +jDC5lMW9aSZ45P00CUm0FUtUySEoVztbPrnSi1oGY9Sre95KjQ4WUWulxiuwngqL +zkKw0KHtBE6s7PcFSLePnRO/kKXlPbD85kfRhktfzxf63j3ULrmmPhXBcfDUiOqG +GYmK7dlSFfXlKiOhhIx1zXAxYnD/Q0Jzb0svM3Pp8PfqaaJLmeu8nMUcSN9R5knP +BX3UQAdf7+nKHsRE1up9waB8IEoiR9hfeQ8Wq/3uLY0Z16GppRlIJCCXTtvSrYwO +7BpuFbQzDxPPSM993QblBqzl2SgTV0chHuoegTjXY1Lpt6J88xMnGdfJ9VX+ZZAA +rj9UIu2M8Da+1Jd6f1lud+9ZThbHQZHClgxaM/6GqiYHghGrDfNgeTtWVS8Hl4RL +Vyou/tZEy7k3/mswu9q5wdunJCmkXYIpcXmA18afhdEiRymcnLjy767LioFqIgxp +tIya0OcSFa/yc6gNRFSG2qExPnVPcbGxqbR/N7fHfN/4V+mGQZmDXBlaubWsLiCx +bHF8b2j7Do5b/TjUwct5L7OgHUwSmRlUAF8xMX1kTPkCeTMnMQT0hDHq2B8+Zg+Q +N+GuiY2fr3+i5NKa9oeiv0aZRmaE/nKgPK1UvoXQL8YagmoS3TXSVLOu2JGPyMey +gquVr+UrAOtZp9HWzR/f/jpU0HrqVzMGUOuOK2VfKGBPE+MsNDr7xTgYuw8blYx1 +WXbj8l0whIdmelsr3apmtLGPxc6LjUSnYspaf7m2iqSmioUoZUO59LjxNCe8eYEC +HcxXCJa/wRxWl5IFJzfoUxEGinfrLBFXFtiKewMB/XuNTT8smffvsM7zWz1DC6F0 +WScwAIvwWK8qauLrO2U2qN9d/8dl0G1quDDE3Y27onU67lbemlNahjVmC27WnHHA +fBc+fA3kDnU1zqLFHOonYrVPSWbwaXJwBeJmFzAE5647xgi/l7e2rD8LDoOCjj2a +KVOLPHfvSehX1RbX325lb5VvHjVp1whOQVRF8RgkYg8d/ef9sye6e9Eyz2aVcVPi +0T6jOMZGF2sfeYO2fBLZKF/vezNMUxTWvEOP38Gt6HNMBk76Vhl8v/7ZD7kDs0iB +2NFh3vN6YVCHeNbfAJMESojAlUvhmrOAhvz8uuz9VRVr+66JZkESONHbFfS9r4Z4 +iG8venQ93o2Mq0ccN7+v01eJgyDooJLEAnTNOnq5o0YQrWBgfN2JXGbT9XZKaeDx +CYA5EkLLhdLy6uZa/1UM2fnoZ+zLjQWLVntUwYa88QJbAk3QcD9c/aSEmJqxxI7k +xw2tWebQfQwpz1Ws2U1O8hPL5uJZ7ewuC44H4T7inGUIavWuBLwrkFACk9ASz0Qa +FXtELm3da2+KEVuWvAwgwLm0wpLMktENE3nMsVwFzAk0pM2oPz7paJv7EU5jrTWs +mgDL3ooui5baxSHLCspx04YhBk+VL2BukQVPXfsPN6CL8fRJoE2p9my8MeXlBI5R +7b+Hg4y4ZcH8mURkx3RCVDbH3g== +-----END AGE ENCRYPTED FILE----- diff --git a/modules/by-name/se/secrets/taskserver/public.cert b/modules/by-name/se/secrets/taskserver/public.cert new file mode 100644 index 00000000..1cf9b5f0 --- /dev/null +++ b/modules/by-name/se/secrets/taskserver/public.cert @@ -0,0 +1,83 @@ +-----BEGIN AGE ENCRYPTED FILE----- +YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSB6RnRGSEZSNE0yWWhXODhk +N1FGNkFPSEVIaFJhWm52eEZ3Q3Bwb2I5c25nCkpCU1Zhd3ZhZ1YyOVFmTGxkVnZT +aDhxOHBrWGdhcE00THh2WnFSbUM1bHMKLT4gc3NoLWVkMjU1MTkgelpFb25nIFh2 +WmVLTTc0ZjUxaUFFNVFuNzVjNkhLRzR6VGdJOVRvZGtBT1BrTnJJQnMKOExOck0r +TW9mSVY0d0VTSk9IS0c3NHdscXVyMHhlUnkyNnFJWnFmekJJWQotPiBzc2gtZWQy +NTUxOSA3SGZGVXcgOXFTejhFNWd0TklHcytUMlJQdU1OaUlNVlBSbWZWdnhWbmVp +TlpNekwwcwoyQXpEd3JCVVcrdHR2cDN4LzdmSVhveGNiaThEOVE3TlJEUXdnejdY +R3NjCi0+IFdAQS1ncmVhc2UgWgpRei9tQTFCcjY1bGxEVlhxdWJFVnB1d3B5MWov +amVZbm1EaEovVmVnczA5RWpuSUx0eUFLc0J0aEZqVmpJMmIxCjUwWmJyYTNxT3g3 +Qjl5MGhuWEEKLS0tIHNaMnh1N1JhUkJIdFZ5TnRtR3hDM1kxRlNMU2pWL2VBdkkx +cUw1TWhWa28KwuibZXNGOy/Qqhs17FD2aTdWit9nvgRl/n+F/gKwJXoaEvRM7veM +uTEvmfIRJzLm5ox7ko48f8g+EWQDWvcXsa1KwCDI4DDoP3WxhMOUmNE6SYqDgGpP +ilQLOvX7kKrtY/oB6OQj6QFMEJe8dElNEq8rcapaqiWnRDQsqvDtFm7j0HcGNQ2U +Kg+/c6UQRf4lgZXLs2cGMCjUivEA6eojyLctIcXdswIxWI9TwxBOJ7NTKI7wF4hn +TKqZSlWhLg8xpW7s0ZRpAQaONMVo+Ve9TH3fPaPFsUZUu+x0jfk+NMUWBscYbYUN +JZT9xuMOmEcnXZ+/1DIgl0zw5kG2hQ30lX0QGRqrWaPoOv0KchORWuwsVgkFFMTk +eiYeqf5mkAfswR8iN6Ye1K6gH6WAI666yRbkMmdJTAO5iC2JhQVLgdJuKBWixTE7 +0Y6xdPIRUhDXn2fgeYFxnTwqR7oi7Aa9H6LVtxdFMVvhqJ2l0QKd8UqcwO3RrCRK +VLehYc3prKklzrkevKVr5k+62ateISjMF/NoEpZf4wTzh6wByyk32cNHT5OU1Qr7 +Z3Eef6G0EZ4ifivYd4vFjJHqxKgVMUVywSaUzgjGfQRVO6GDMq8TPJt7XgwwUDDy +6A1SlxSxWHw0xPSGIeYm/Sag4ykrv6qhA5rW/4mlrfozlraXBbDT+JJ8aZ6RGhaC +Bj/qlBZuqy963gJeS5qHbbBOT4Pv5aywGf0VU8G/uNvVeO8wMZQpGiQkmAp+TFo2 +CHIr/wKpd1R4HYtCmGY8w8qK9c8rlx2ezqfmBdoPzRkGb/hgH4aOCBwokOVvvgdr +7OghOd244CC7VF6xi05joFn9RpFpX/Rhj2OKgjezcHAcPTZ4BBJPHYrSrtdDywe2 +zwU+/2kBJpJqIU0AoBYPRp7gmJXLkAa5GUcLL4GLR5QEwevxXAz77I7gyteVDENy +MgVfNLsz9x6DDbROqMBZLAotV4CF1HL4qU4ontgH2l4gpQx9MM/zihw2z1+62jdF +v2mbIaoKtozMkPJkViu3oHoa36dCuZSSIQ93+rcxBHZfcTuHS4LQhjQ4cAoiT/8a +0mq78586cLQDXPb0hJbnxU+YpklIvuZ1N2co7vvcE0wrarvC0NBWBQmwOXAONXgw +G/dC9W+FrYiwAFwPK2WtY6i7rfLNGjgllWc2PjDLGmKwJ7wcLzx2yaSa0b0P0lxi +lq383oW6if5ljSbcetyPCF7CO/LqRXw2M0i//lUfPdUgP3ACrS3cL2QCVBD5bUeo +OilOnjKK6GdN4m2UTfVYrJUhh7YNjBKwfWVnW4UOHNEXCMCT/opmcoC/Re0Mvfcz +o9yeLkgMpCYLahT5be3/yuAOxDLjt5eB4NZV4bCpiU59LD2e8atvVZyoYMmKZbhQ +85SZ512eitdz6W54BlecNWBBV0A1KGISAK+pGu9dCz9HtRmd2NkuMkkC96PfxnFg +bYjWH6csXNcvn5f4h+pgDeoPeKyqxNCkssg01DW/wLCgLVJEWbKophxwWigVq8hC +y5rQP2LccaXLsUOKXtfRUSErM/JpkYLDAVPKLtXiB5Sl3njhWvAtKLGtpUDU9P5x +2UzgsQw2MOpVKLyFJqi9/cclPD39HeFcHq546H9SYgvNgP5rPQYLF5XzzrkQwYOd +wdq54gP0NG8MK/LC4zb0Yvdnk36pO1oR2dPswOuhmnoheT8LjQMxbphGzKVQNcai +Ng1crNNHkEtEV/v3H3eWFwe/kUPx6mZk+b7cWeocatM7PDMJWDwicBZ6mnZj2fjo +SomTr1N2uMiQ4T91P7PqNQFgfH1m2jzuIMs824M495rFBZ6OBWl64SKQ6Uyxj4cq +B4MQnh9LjZDluioEsYDJeuvn4j5Gw+MXdUgImJzz+e+K0MBghAoJNAArT6CEoPIO +PgDxc9opIAo2dra8RMWmDRZYqeZrYLc0khzDeUegEz1PZ5h5ZqYZnYz3uBc0mBlr +dXQZEj7UUVelEocTnEKc6GIBJ0V8hnhnsZRuP5XaPBonqpEkV0k7N91Mpy3+VN4U +g9bSgeJOTYaBaXYHWCbmJPqVY7ifryBNs8x5cGnAtDnJO4JqkKkZu/+/QEyTGwbz +yiHo8djEgT8PFJh39K6dirSWP0pTwHjWBDfTJddmFNrK51N7kVFyh7cSKTTIH9Ky +/kvnGUWi9kxvjYgMhPymFzuvmpDFpL5/Cji5hw9V9UDvLIWkYIV47e4J5zRJYBQo +hsCoUzo7+OHt/EwavA8GiO/pC9ui6scfMmbmR5KxOGyXRjBAe4bhhNzkFDxYFk1q +5EokmYuI4tUu27NLKw73TYj9VmC614FPXJ3cYAFiscAsQMWOx7ZPMVfQev8uA4+U +khtIvseLWsd7+NVxZubrVLNoywKDi11zrVlx+jftvwkzr+Q/MM+KUafMQ8GwejQz +IS5GE21g3JRV2eXMxb682Fz7M8edNekOP22CH0F3AjiOgWtbVAyevy1l4mDHEzK0 +0AnC58oAe5i9BFESdRpIOGkfQc1bbB4gmvJKXPod+126wVQm/yEJtdqLGS0aB8ao +lmBFTr0xfAIP0O1RbEsHQEzQwAPCv7HFfnVLGzlOvluKiKmuBIw62kttVt6qOr8U +UbovaGDkr7Tb8+dkBjua7utJ1oAmwNbPDeG9Gj87vi9CQj9IcUdOnIsYpqvX00yT +qDS0rERg6CJyHlwNGDg2pAPFjDFFhS8eq+bkaMyEtSt1nr/gMpk9MJF6lx4L1kLr +8o/5KlFBc31iQJ4D/djncN9jym/t72N+JJ1afX4YULMbCX6c7HH4G2FkDvGOzoQG +j3wzMMdKXsI+I8hzvTz/1Z/cYDRcep7Dxp9VfgHGRjEkR0L4/jD2K3EcmyAcEmZt +wyEgYqctJRtj0puHD8eJgMxWnVUovJbEkE8QG+xfu//oCMcgjf9y89aC8JWSMvRn +9s5ZsbVAoWWH2FmLX/iirOEqlNg+wFWmaivgY0yEE9AstoSJTGn6Lfiq3rKQq+Wq +1tTxP+eW3qMJKdCwnJLeu9WqVcMRsbehMTLB8UWaTThMFsSCk11kfGBjDtfvVLvQ +Pv+cCArLRidswArNnQrD4iL9anzihJqG9POFMIT+jVd3BHSjPa+Uxd0Wy70ob71e +X+M480oRMrcmclmjaa54fnV3nQ0SK4A34nV1Ti8tnnGX51yGaNBm2DkgU7uQPZGn +rXmPnWPfNUUvgvoZ0JdbPLeOfX1bD6NXqcvBKiiL2j1Ujo+WJzyXsIJmWdZguegU +hRfEtwXd9Qsv1joKz2pj0EL0OXGpDlqO/SnYs6Pjxgu/F823ZRaoVVr9R3wd4Frb +RmiAY6pQIgu2XQ3xMAEKz7A/YRykGKf9uoNbNipA7YHuhzZtkyalZByJWlhf7RTc +yR8/u1deCtEKpva7EO3qOV4kuRWUANk4qQP7C+qDS9FUE+rluMMTJwz5hD6p9g73 +8S1zxm2xTFeyS7gErahoP/ywzMZv6LJY2VilKbVR7VjnJuHH66e4TiSx4pdjj8sj +ECNUGl6y7nuFu3/5jY8wHp/6aokgOHYek4eBqPehjuUfM8cid40pZaObrhVpN8jd +HDZshwJAjZTrCT1FLgBsv7FfrsHCZq0dEgODmknHw4t52Fkb5bVzX0jKRkw7Mb4K +qSz927IgrOLsClp2gGgfamSrvcbtYArxRrvXPC+ju4Hb2TfwNbkklYaEMxR7dKSX +UWDaJzeJeltCeyEYOg4q44V6ZnpGCm8nuHuXFvxjj0ue3GpabDV/kXWn9gNwodRg +9BNaLRxyb8jRFLsma/ZRGhWjRg86IYcmMoj8drnw2F6nrL+bUVE6cwGZRz0bNmtr +6tJjNtbcw/YMAnLrbuwJfIbkSiB+n/6d37i6GXd994SXCl6LGFVWRTeNytKevfIA +dsm+xFJPZcH/PlOlMLXZVBdgubpO+TkmQipq2iobejkAWgyAr34PP3Oeo7ijVetq +nzMCy5c8d3ZUqOkXrDFkOzjTdWDlFfRmOVLC3bl7OzwFByAdeE97JDkugSiNHVav +Y8rjyI0micVCZUijJi2SyK8UXmNUf8047FbbnQhGbMdSi/PpK+XGT+XCJH5uABpN +0QOm1kWX+dP7D57MjTRwlGtmu5hsUy3zogL5QSx7nUdVnIZNzOi3HlPAfUycjn16 +KQSjrc4RiJF0B8H9aUao9QgDn/5rkI2QQ6iaNtmPlBUq2uZ9Zu/TLnrardjYOIWi +p7N1HubYigreVdjtzhpnU8SyX9RlkD0E+QXqq1ZZDLJSLYB9YGrBAyRicSuEJYol +7d1aQd1svir0hmigYB0TOao9uvwoif9ZBXqT6VsYWszFGtCumSPNTh8RxIfnP+oA +o1hmpXYYAm58V/fMBJGWJr269F2odiZbv6IfHHB2OUMvqAt41OHvairpk8Ul7+Or +S4Xgq+UIOJ6nZJ+XOpr4xe4xDHHGIe/VoGNMa97hsNXMzYZrJPP9FTFU9EDpwWT9 +m7vbEx2mecNNVw96F/k= +-----END AGE ENCRYPTED FILE----- diff --git a/modules/by-name/se/secrets/update_secrets.sh b/modules/by-name/se/secrets/update_secrets.sh new file mode 100755 index 00000000..f1c27d77 --- /dev/null +++ b/modules/by-name/se/secrets/update_secrets.sh @@ -0,0 +1,37 @@ +#!/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 + +update_lf_cd_paths() { + echo "Starting to update the lf/cd_paths.age file.." + + cd "$(git rev-parse --show-toplevel)/modules/system/secrets" || { + echo "A secrets dir does not exist! (This is most likely a bug)" + exit 1 + } + + key_file="$(mktemp)" + + nix eval -f ./secrets.nix --json | jq --raw-output '.["lf/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 ./lf/cd_paths.age + + echo "Finished updating the lf/cd_paths.age file.." +} + +main() { + update_lf_cd_paths +} + +main + +# vim: ft=sh diff --git a/modules/by-name/se/serverphone/certificates/ca.crt b/modules/by-name/se/serverphone/certificates/ca.crt new file mode 100644 index 00000000..7a4ae6f9 --- /dev/null +++ b/modules/by-name/se/serverphone/certificates/ca.crt @@ -0,0 +1,10 @@ +-----BEGIN CERTIFICATE----- +MIIBXDCCAQOgAwIBAgIIRQ2wXiaD5pMwCgYIKoZIzj0EAwIwGTEXMBUGA1UEAwwO +U2VydmVycGhvbmUgQ0EwHhcNMjMwNjA2MTIzNzM3WhcNMzMwNjAzMTIzNzM3WjAZ +MRcwFQYDVQQDDA5TZXJ2ZXJwaG9uZSBDQTBZMBMGByqGSM49AgEGCCqGSM49AwEH +A0IABDZMtz3liWniBedisStXDO2sxFCKBH239ezH7uADu8g5peGssmNu1rXEDrg1 +sFwVUjQeJAocYYNoUeHiVpODf1ejNTAzMB0GA1UdDgQWBBST5oMmXrANRbCLIQpN +W7e5uSCL3DASBgNVHRMBAf8ECDAGAQH/AgEBMAoGCCqGSM49BAMCA0cAMEQCIFig +xA3MvRNP4uXaUEWwdP1pYL/R8N46G4NZrPEfiNV4AiA+NJSTFRCOUqEsvSb7PTFx +YuMuJF4XxWnmStz3ym7xXA== +-----END CERTIFICATE----- diff --git a/modules/by-name/se/serverphone/certificates/server.crt b/modules/by-name/se/serverphone/certificates/server.crt new file mode 100644 index 00000000..f994cdc8 --- /dev/null +++ b/modules/by-name/se/serverphone/certificates/server.crt @@ -0,0 +1,10 @@ +-----BEGIN CERTIFICATE----- +MIIBTjCB9KADAgECAgkAhKrdjsoiOrkwCgYIKoZIzj0EAwIwGTEXMBUGA1UEAwwO +U2VydmVycGhvbmUgQ0EwHhcNMjMwNjA2MTIzOTIwWhcNMjQwNjA1MTIzOTIwWjAm +MSQwIgYDVQQDDBtDbGllbnQgcnVubmluZyBvbiBsb2NhbGhvc3QwWTATBgcqhkjO +PQIBBggqhkjOPQMBBwNCAAS1ILQo8ae8ydqFlt5RncUT7joQiozk6Omunb0vxVz5 +toJRDmVqc1s6KhpCTipUV5coTcaK1TBz0+fft+9VH7cwoxgwFjAUBgNVHREEDTAL +gglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAN7ohtsBLrjlgmSe9ngovxZM +z61n0+/7w2mtX/OrLMWIAiEAu+D2S2o0s7E9pp2Rkug8cT5T4GCWgFgEHk5x2L/E +RVI= +-----END CERTIFICATE----- diff --git a/modules/by-name/se/serverphone/keys/key_1 b/modules/by-name/se/serverphone/keys/key_1 new file mode 120000 index 00000000..67720882 --- /dev/null +++ b/modules/by-name/se/serverphone/keys/key_1 @@ -0,0 +1 @@ +../../../../home-manager/soispha/config/gpg/keys/key_1 \ No newline at end of file diff --git a/modules/by-name/se/serverphone/keys/key_2 b/modules/by-name/se/serverphone/keys/key_2 new file mode 120000 index 00000000..24df7207 --- /dev/null +++ b/modules/by-name/se/serverphone/keys/key_2 @@ -0,0 +1 @@ +../../../../home-manager/soispha/config/gpg/keys/key_2 \ No newline at end of file diff --git a/modules/by-name/se/serverphone/module.currently_ignored.nix b/modules/by-name/se/serverphone/module.currently_ignored.nix new file mode 100644 index 00000000..20125a75 --- /dev/null +++ b/modules/by-name/se/serverphone/module.currently_ignored.nix @@ -0,0 +1,49 @@ +{ + config, + serverphone, + system, + lib, + ... +}: { + config = lib.mkIf config.soispha.secrets.enable { + services.serverphone = { + package = "${serverphone.packages.${system}.default}"; + enable = true; + domain = "localhost"; + configureDoas = true; + acceptedSshKeys = [ + "AAAAC3NzaC1lZDI1NTE5AAAAIGBFuTNNn71Rhfnop2cdz3r/RhWWlCePnSBOhTBbu2ME" + ]; + authorized = { + acceptedGpgKeys = [ + { + source = ./keys/key_1; + trust = "ultimate"; + } + { + source = ./keys/key_2; + trust = "ultimate"; + } + ]; + }; + caCertificate = "${./certificates/ca.crt}"; + certificate = "${./certificates/server.crt}"; + privateKey = config.age.secrets.serverphoneServer.path; + certificateRequest = { + acceptedUsers = [ + "soispha $argon2id$v=19$m=19456,t=2,p=1$EvhPENIBqL5b1RO5waNMWA$pJ8vDrCNJKDlqwB5bVDLjHVPEXm9McQhtt9OXSD8Zkc" + ]; + caPrivateKey = config.age.secrets.serverphoneCa.path; + }; + }; + + users.users.serverphone = { + group = "serverphone"; + isSystemUser = true; + home = "/run/serverphone"; + }; + users.groups.serverphone = { + members = ["serverphone"]; + }; + }; +} diff --git a/modules/by-name/sn/snapper/module.nix b/modules/by-name/sn/snapper/module.nix new file mode 100644 index 00000000..bf8201a4 --- /dev/null +++ b/modules/by-name/sn/snapper/module.nix @@ -0,0 +1,53 @@ +{ + config, + lib, + ... +}: let + cfg = config.soispha.services.snapper; +in { + options.soispha.services.snapper = { + enable = lib.mkEnableOption "snapper config"; + }; + + config = lib.mkIf cfg.enable { + services.snapper = { + configs = { + srv = { + SUBVOLUME = "/srv"; + FSTYPE = "btrfs"; + # users and groups allowed to work with config + ALLOW_GROUPS = ["wheel"]; + + # sync users and groups from ALLOW_USERS and ALLOW_GROUPS to .snapshots + # directory + SYNC_ACL = true; + + # run daily number cleanup + NUMBER_CLEANUP = false; + + # limit for number cleanup + NUMBER_MIN_AGE = 1800; + NUMBER_LIMIT = 50; + NUMBER_LIMIT_IMPORTANT = 10; + + # create hourly snapshots + TIMELINE_CREATE = true; + + # cleanup hourly snapshots after some time + TIMELINE_CLEANUP = true; + + # limits for timeline cleanup + TIMELINE_MIN_AGE = 1800; + TIMELINE_LIMIT_HOURLY = 7; + TIMELINE_LIMIT_DAILY = 3; + TIMELINE_LIMIT_WEEKLY = 2; + TIMELINE_LIMIT_MONTHLY = 0; + TIMELINE_LIMIT_YEARLY = 2; + + # cleanup empty pre-post-pairs + EMPTY_PRE_POST_CLEANUP = true; + }; + }; + }; + }; +} diff --git a/modules/by-name/so/sound/module.nix b/modules/by-name/so/sound/module.nix new file mode 100644 index 00000000..f3120a67 --- /dev/null +++ b/modules/by-name/so/sound/module.nix @@ -0,0 +1,37 @@ +{ + config, + lib, + ... +}: let + cfg = config.soispha.sound; +in { + options.soispha.sound = { + enable = lib.mkEnableOption "sound based on pipewire"; + }; + + config = lib.mkIf cfg.enable { + hardware.pulseaudio.enable = false; + security.rtkit.enable = true; + + services.pipewire = { + enable = true; + alsa.enable = true; + alsa.support32Bit = true; + pulse.enable = true; + jack.enable = true; + }; + + # TODO: Find a better way to set the default volume <2024-03-10> + # + # environment.etc.pipewire-pulse-config = { + # target = "pipewire/pipewire-pulse.conf.d/pipewire-pulse-config.conf"; + # text = '' + # # Extra scripts can be started here. Setup in default.pa can be moved in + # # a script or in pulse.cmd below + # context.exec = [ + # { path = "${pkgs.pulseaudio}/bin/pactl" args = "set-sink-volume 0 13%" } + # ] + # ''; + # }; + }; +} diff --git a/modules/by-name/st/steam/module.nix b/modules/by-name/st/steam/module.nix new file mode 100644 index 00000000..49149cd7 --- /dev/null +++ b/modules/by-name/st/steam/module.nix @@ -0,0 +1,23 @@ +{ + lib, + config, + pkgs, + ... +}: let + cfg = config.soispha.services.steam; +in { + options.soispha.services.steam = { + enable = lib.mkEnableOption "Steam"; + }; + + config = lib.mkIf cfg.enable { + programs.steam = { + enable = true; + }; + + environment.systemPackages = [ + # TODO: Why is this package needed? <2024-05-16> + pkgs.wineWowPackages.waylandFull + ]; + }; +} diff --git a/modules/by-name/sw/swaylock/module.nix b/modules/by-name/sw/swaylock/module.nix new file mode 100644 index 00000000..6cbcef28 --- /dev/null +++ b/modules/by-name/sw/swaylock/module.nix @@ -0,0 +1,4 @@ +{...}: { + # otherwise swaylock can't access the user password. + security.pam.services.swaylock = {}; +} diff --git a/modules/by-name/sy/system_diff/module.nix b/modules/by-name/sy/system_diff/module.nix new file mode 100644 index 00000000..052ffae2 --- /dev/null +++ b/modules/by-name/sy/system_diff/module.nix @@ -0,0 +1,26 @@ +{ + config, + lib, + pkgs, + ... +}: let + cfg = config.soispha.services.systemDiff; +in { + options.soispha.services.systemDiff = { + enable = lib.mkEnableOption "nvd run at system activation"; + }; + + config = lib.mkIf cfg.enable { + system.activationScripts.diff = { + supportsDryActivation = true; + text = '' + PATH="${lib.makeBinPath [pkgs.nvd config.nix.package]}:$PATH" + + if [ -e /run/current-system ]; then + # ${lib.getExe config.nix.package} --extra-experimental-features nix-command store diff-closures /run/current-system "$systemConfig" + nvd diff $(ls -dv /nix/var/nix/profiles/system-*-link | tail -2) + fi + ''; + }; + }; +} diff --git a/modules/by-name/te/tempfiles/module.nix b/modules/by-name/te/tempfiles/module.nix new file mode 100644 index 00000000..f8bfd4dc --- /dev/null +++ b/modules/by-name/te/tempfiles/module.nix @@ -0,0 +1,20 @@ +{ + config, + lib, + ... +}: let + cfg = config.soispha.tempfiles; +in { + options.soispha.tempfiles = { + enable = lib.mkEnableOption "systemd tempfiles generation"; + }; + + config = lib.mkIf cfg.enable { + systemd.tmpfiles.rules = [ + # TODO: Find a way to move this file to the lf home manager config. + # + # This file is needed to trash stuff on the root ('/') temp file system. + "d /.Trash 1777 root root" + ]; + }; +} diff --git a/modules/by-name/us/users/module.nix b/modules/by-name/us/users/module.nix new file mode 100644 index 00000000..a44df7e8 --- /dev/null +++ b/modules/by-name/us/users/module.nix @@ -0,0 +1,50 @@ +{ + config, + pkgs, + lib, + ... +}: let + cfg = config.soispha.users; +in { + options.soispha.users = { + enable = lib.mkEnableOption "user set-up for soispha"; + hashedPassword = lib.mkOption { + type = lib.types.str; + example = lib.literalExpression "$y$jFT$ONrCqZIJKB7engmfA4orD/$0GO58/wV5wrYWj0cyONhyujZPjFmbT0XKtx2AvXLG0B"; + description = "The hashed password of the user"; + }; + groups = lib.mkOption { + type = lib.types.listOf lib.types.str; + default = ["wheel"]; + description = "The groups the soispha user should be part of"; + }; + + # Although deprecated, this helps with old udev rules, that still use this group. + # TODO: Try to find a way to remove this option (i.e. set it always to false). + enableDeprecatedPlugdev = lib.mkEnableOption "the deprecated plugdev group for the user"; + }; + + config = lib.mkIf cfg.enable { + # Ensure that the default shell of the user is actually enabled. + programs.zsh.enable = true; + + users = { + mutableUsers = false; + + users.soispha = { + isNormalUser = true; + home = "/home/soispha"; + createHome = true; + shell = pkgs.zsh; + initialHashedPassword = cfg.hashedPassword; + extraGroups = cfg.groups ++ lib.optional cfg.enableDeprecatedPlugdev "plugdev"; + + uid = 1000; + openssh.authorizedKeys.keys = [ + # TODO: This should be parameterized. <2024-05-16> + "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIME4ZVa+IoZf6T3U08JG93i6QIAJ4amm7mkBzO14JSkz" + ]; + }; + }; + }; +} diff --git a/modules/by-name/ve/version/module.nix b/modules/by-name/ve/version/module.nix new file mode 100644 index 00000000..77cada14 --- /dev/null +++ b/modules/by-name/ve/version/module.nix @@ -0,0 +1,19 @@ +{ + config, + lib, + self, + ... +}: let + cfg = config.soispha.version; +in { + options.soispha.version = { + enable = lib.mkEnableOption "storing the git revision in /etc/nixos_git_rev"; + }; + config = lib.mkIf cfg.enable { + environment.etc.nixos_git_rev = { + text = builtins.toString (self.longRev + or self.lastModified + or "unknown"); + }; + }; +} diff --git a/modules/by-name/wa/waydroid/module.nix b/modules/by-name/wa/waydroid/module.nix new file mode 100644 index 00000000..4680db63 --- /dev/null +++ b/modules/by-name/wa/waydroid/module.nix @@ -0,0 +1,5 @@ +{...}: { + # FIXME: Running `waydroid session start` causes all fuse mounts instances to coredump <2023-09-02> + # Thus this setting must be false. + virtualisation.waydroid.enable = false; +} diff --git a/modules/by-name/xd/xdg/module.nix b/modules/by-name/xd/xdg/module.nix new file mode 100644 index 00000000..5140a832 --- /dev/null +++ b/modules/by-name/xd/xdg/module.nix @@ -0,0 +1,58 @@ +{ + pkgs, + nixpkgs_open_prs, + sysLib, + system, + ... +}: let + pkgs_tfc = nixpkgs_open_prs.nixpkgs-tfc.legacyPackages."${system}"; +in { + services.dbus.enable = true; + xdg = { + portal = { + enable = true; + termfilechooser = { + enable = true; + logLevel = "TRACE"; + package = pkgs_tfc.xdg-desktop-portal-termfilechooser; + settings = { + filechooser = { + default_dir = "/tmp"; + cmd = "${sysLib.writeShellScript { + src = ./scripts/lf_wrapper.sh; + name = "lf_wrapper"; + keepPath = true; + dependencies = with pkgs; [ + lf + alacritty + bash + ]; + }}/bin/lf_wrapper"; + }; + }; + }; + wlr = { + enable = true; + }; + config = { + common = { + # NOTE: The next entry is supposedly needed for gtk based apps <2023-08-31> + default = ["wlr" "gtk"]; + "org.freedesktop.impl.portal.FileChooser" = ["termfilechooser"]; + }; + + # TODO: Also activate, when on another wlr-based compositor <2023-11-25> + river = { + default = ["wlr" "gtk"]; + "org.freedesktop.impl.portal.FileChooser" = ["termfilechooser"]; + }; + }; + extraPortals = [ + pkgs.xdg-desktop-portal-gtk + pkgs.xdg-desktop-portal-wlr + pkgs_tfc.xdg-desktop-portal-termfilechooser + ]; + }; + }; + # TODO: mime = {}; +} diff --git a/modules/by-name/xd/xdg/scripts/lf_wrapper.sh b/modules/by-name/xd/xdg/scripts/lf_wrapper.sh new file mode 100755 index 00000000..16603fe4 --- /dev/null +++ b/modules/by-name/xd/xdg/scripts/lf_wrapper.sh @@ -0,0 +1,79 @@ +#!/usr/bin/env dash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH + +# This wrapper script is invoked by xdg-desktop-portal-termfilechooser. +# +# Inputs: +# 1. "1" if multiple files can be chosen, "0" otherwise. +# 2. "1" if a directory should be chosen, "0" otherwise. +# 3. "0" if opening files was requested, "1" if writing to a file was +# requested. For example, when uploading files in Firefox, this will be "0". +# When saving a web page in Firefox, this will be "1". +# 4. If writing to a file, this is recommended path provided by the caller. For +# example, when saving a web page in Firefox, this will be the recommended +# path Firefox provided, such as "~/Downloads/webpage_title.html". +# Note that if the path already exists, we keep appending "_" to it until we +# get a path that does not exist. +# 5. The output path, to which results should be written. +# +# Output: +# The script should print the selected paths to the output path (argument #5), +# one path per line. +# If nothing is printed, then the operation is assumed to have been canceled. + +multiple="$1" +directory="$2" +save="$3" +recommended_path="$4" +out="$5" + +# echo > /tmp/stdout +# echo > /tmp/stderr +# +# exec 1>> /tmp/stdout +# exec 2>> /tmp/stderr + +cmd="$(command -v lf)" +termcmd="${TERMINAL:-$(command -v alacritty)}" + +if [ "$save" = "1" ]; then + set -- -selection-path="$out" -command='set promptfmt "Select the file to write to %S \033[32;1m%u@%h\033[0m:\033[34;1m%d\033[0m\033[1m%f\033[0m"' "$recommended_path" + cat <<EOF >"$recommended_path" +xdg-desktop-portal-termfilechooser saving files tutorial + +!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +!!! === WARNING! === !!! +!!! The contents of *whatever* file you open last in !!! +!!! lf will be *overwritten*! !!! +!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + +Instructions: +1) Move this file wherever you want. +2) Rename the file if needed. +3) Confirm your selection by opening the file, for + example by pressing <Enter>. + +Notes: +1) This file is provided for your convenience. You + could delete it and choose another file to overwrite + that, for example. +2) If you quit lf without opening a file, this file + will be removed and the save operation aborted. +EOF + +elif [ "$directory" = "1" ]; then + set -- -selection-path="$out" -command='set dironly' -command='set promptfmt "Select directory (quit in dir to select it) %S \033[32;1m%u@%h\033[0m:\033[34;1m%d\033[0m\033[1m%f\033[0m"' +elif [ "$multiple" = "1" ]; then + set -- -selection-path="$out" -command='set promptfmt "Select file(s) (open file to select it; <Space> to select multiple) %S \033[32;1m%u@%h\033[0m:\033[34;1m%d\033[0m\033[1m%f\033[0m"' +else + set -- -selection-path="$out" -command='set promptfmt "Select file (open file to select it) %S \033[32;1m%u@%h\033[0m:\033[34;1m%d\033[0m\033[1m%f\033[0m"' +fi + +"$termcmd" --title 'floating please' -e "$cmd" "$@" + +if [ "$save" = "1" ] && [ ! -s "$out" ]; then + rm "$recommended_path" +fi +# vim: ft=sh diff --git a/modules/by-name/xd/xdg/scripts/ranger_wrapper.sh b/modules/by-name/xd/xdg/scripts/ranger_wrapper.sh new file mode 100755 index 00000000..e148bf19 --- /dev/null +++ b/modules/by-name/xd/xdg/scripts/ranger_wrapper.sh @@ -0,0 +1,68 @@ +#!/usr/bin/env dash + +# shellcheck source=/dev/null +SHELL_LIBRARY_VERSION="2.1.2" . %SHELL_LIBRARY_PATH +# This wrapper script is invoked by xdg-desktop-portal-termfilechooser. +# +# Inputs: +# 1. "1" if multiple files can be chosen, "0" otherwise. +# 2. "1" if a directory should be chosen, "0" otherwise. +# 3. "0" if opening files was requested, "1" if writing to a file was +# requested. For example, when uploading files in Firefox, this will be "0". +# When saving a web page in Firefox, this will be "1". +# 4. If writing to a file, this is recommended path provided by the caller. For +# example, when saving a web page in Firefox, this will be the recommended +# path Firefox provided, such as "~/Downloads/webpage_title.html". +# Note that if the path already exists, we keep appending "_" to it until we +# get a path that does not exist. +# 5. The output path, to which results should be written. +# +# Output: +# The script should print the selected paths to the output path (argument #5), +# one path per line. +# If nothing is printed, then the operation is assumed to have been canceled. + +multiple="$1" +directory="$2" +save="$3" +path="$4" +out="$5" + +cmd="$(command -v ranger)" +termcmd="${TERMCMD:-$(command -v kitty)}" + +if [ "$save" = "1" ]; then + set -- --choosefile="$out" --cmd='echo Select save path (see tutorial in preview pane; try pressing zv or zp if no preview)' "$path" + printf '%s' 'xdg-desktop-portal-termfilechooser saving files tutorial + +!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +!!! === WARNING! === !!! +!!! The contents of *whatever* file you open last in !!! +!!! ranger will be *overwritten*! !!! +!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + +Instructions: +1) Move this file wherever you want. +2) Rename the file if needed. +3) Confirm your selection by opening the file, for + example by pressing <Enter>. + +Notes: +1) This file is provided for your convenience. You + could delete it and choose another file to overwrite + that, for example. +2) If you quit ranger without opening a file, this file + will be removed and the save operation aborted. +' >"$path" +elif [ "$directory" = "1" ]; then + set -- --choosedir="$out" --show-only-dirs --cmd="echo Select directory (quit in dir to select it)" +elif [ "$multiple" = "1" ]; then + set -- --choosefiles="$out" --cmd="echo Select file(s) (open file to select it; <Space> to select multiple)" +else + set -- --choosefile="$out" --cmd="echo Select file (open file to select it)" +fi + +"$termcmd" -- "$cmd" "$@" +if [ "$save" = "1" ] && [ ! -s "$out" ]; then + rm "$path" +fi |
