From unknown Thu Jun 19 13:55:21 2025 Content-Disposition: inline Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 X-Mailer: MIME-tools 5.509 (Entity 5.509) Content-Type: text/plain; charset=utf-8 From: bug#43117 <43117@debbugs.gnu.org> To: bug#43117 <43117@debbugs.gnu.org> Subject: Status: [PATCH] Add .git-blame-ignore-revs file Reply-To: bug#43117 <43117@debbugs.gnu.org> Date: Thu, 19 Jun 2025 20:55:21 +0000 retitle 43117 [PATCH] Add .git-blame-ignore-revs file reassign 43117 emacs submitter 43117 Brian Leung severity 43117 normal tag 43117 patch wontfix thanks From debbugs-submit-bounces@debbugs.gnu.org Sun Aug 30 13:46:47 2020 Received: (at submit) by debbugs.gnu.org; 30 Aug 2020 17:46:47 +0000 Received: from localhost ([127.0.0.1]:50701 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kCRPj-0000Zb-Hq for submit@debbugs.gnu.org; Sun, 30 Aug 2020 13:46:47 -0400 Received: from lists.gnu.org ([209.51.188.17]:55782) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kCRPi-0000ZU-6Q for submit@debbugs.gnu.org; Sun, 30 Aug 2020 13:46:46 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:49662) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kCRPh-0007E0-St for bug-gnu-emacs@gnu.org; Sun, 30 Aug 2020 13:46:46 -0400 Received: from wilbur.contactoffice.com ([212.3.242.68]:46824) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kCRPc-0003NJ-1b for bug-gnu-emacs@gnu.org; Sun, 30 Aug 2020 13:46:45 -0400 Received: from ichabod.co-bxl (ichabod.co-bxl [10.2.0.36]) by wilbur.contactoffice.com (Postfix) with ESMTP id 2972BB06 for ; Sun, 30 Aug 2020 19:46:35 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=mailfence.com; s=20160819-nLV10XS2; t=1598809595; bh=94bo33zKjnCAkGIF3xQL4eYDS5UgcojHgXN94xcvKUQ=; h=Date:Subject:Reply-To:From:To:From; b=SPtbjZdqkPHwoOlFl8aA0JaLtuZITLOqaLhPHOLSiwLE0AI+Smtt78IE2TjZ6zj17 NgvrGQHe8Fg2yLn+8+Je8z5iWS0t9nRyk9SNSi8QJcPPoVEzAgUNnIrBiI6xENLfCv OT3eNjmR3GnvWAJfi7j0nckoPvA0hWpj41eCYwujqXBETxxRk2d8LyLgCJXp6uWyxs nExGuKl7OOMA+bs5E+ItWNkAW2NPvw9Gr/O/371DBMIieBmvs95CDcGdH0+sPfb+q4 SQ0CwW7fZcPFiv8fYZcxuWr+rX1aG+Z2NrKbaeAu03/FueeU4sb007b64c09BBzXUT oLpRA2Yq//CHw== Date: Sun, 30 Aug 2020 19:46:31 +0200 (CEST) Message-ID: <197409406.192953.1598809591346@ichabod.co-bxl> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="----=_Part_192799_133127925.1598809356621" Subject: [PATCH] Add .git-blame-ignore-revs file X-Priority: 3 From: Brian Leung To: bug-gnu-emacs@gnu.org X-Mailer: ContactOffice Mail X-ContactOffice-Account: com:225491745 Received-SPF: pass client-ip=212.3.242.68; envelope-from=leungbk@mailfence.com; helo=wilbur.contactoffice.com X-detected-operating-system: by eggs.gnu.org: First seen = 2020/08/30 13:46:35 X-ACL-Warn: Detected OS = Linux 2.2.x-3.x [generic] X-Spam_score_int: -27 X-Spam_score: -2.8 X-Spam_bar: -- X-Spam_report: (-2.8 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_LOW=-0.7, RCVD_IN_MSPIKE_H4=-0.01, RCVD_IN_MSPIKE_WL=-0.01, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-Debbugs-Envelope-To: submit X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: Brian Leung Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" ------=_Part_192799_133127925.1598809356621 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable I made some style changes to em-hist.el and registered that commit in the n= ew .git-blame-ignore-revs file to preserve blame data of other commits. The= single-clause if statements frequently throw me off, so I think it's worth= removing them now that there's a way to do so without ruining git blame se= ssions. I signed an FSF copyright assignment about a year ago when I submitted some= thing to the Emacs package Ivy. Attached are the files they sent me confirm= ing successful registration. If I need to send something else instead, plea= se let me know. Thanks,=20 Brian --=C2=A0 Sent with https://mailfence.com Secure and private email ------=_Part_192799_133127925.1598809356621 Content-Type: text/x-diff; charset=us-ascii; name=0001-eshell-em-hist-Style-and-indentation-cleanup.patch Content-Transfer-Encoding: 7bit Content-Description: File Attachment: 0001-eshell-em-hist-Style-and-indentation-cleanup.patch Content-Disposition: attachment; filename=0001-eshell-em-hist-Style-and-indentation-cleanup.patch >From faccfdb5aa35595ef5746ff98fe254f8ab32288e Mon Sep 17 00:00:00 2001 From: Brian Leung Date: Sun, 30 Aug 2020 10:25:16 -0700 Subject: [PATCH 1/2] eshell/em-hist: Style and indentation cleanup * lisp/eshell/em-hist.el: Use spaces over tabs, when over single-clause if, and more consistent indentation. --- lisp/eshell/em-hist.el | 728 ++++++++++++++++++++--------------------- 1 file changed, 364 insertions(+), 364 deletions(-) diff --git a/lisp/eshell/em-hist.el b/lisp/eshell/em-hist.el index 5cee1bad36..99a1229295 100644 --- a/lisp/eshell/em-hist.el +++ b/lisp/eshell/em-hist.el @@ -65,10 +65,10 @@ ;;;###autoload (progn -(defgroup eshell-hist nil - "This module provides command history management." - :tag "History list management" - :group 'eshell-module)) + (defgroup eshell-hist nil + "This module provides command history management." + :tag "History list management" + :group 'eshell-module)) ;;; User Variables: @@ -93,13 +93,13 @@ eshell-history-file-name See also `eshell-read-history' and `eshell-write-history'. If it is nil, Eshell will use the value of HISTFILE." :type '(choice (const :tag "Use HISTFILE" nil) - file) + file) :group 'eshell-hist) (defcustom eshell-history-size 128 "Size of the input history ring. If nil, use envvar HISTSIZE." :type '(choice (const :tag "Use HISTSIZE" nil) - integer) + integer) :group 'eshell-hist) (defcustom eshell-hist-ignoredups nil @@ -117,8 +117,8 @@ eshell-save-history-on-exit If set to `ask', ask if any Eshell buffers are open at exit time. If set to t, history will always be saved, silently." :type '(choice (const :tag "Never" nil) - (const :tag "Ask" ask) - (const :tag "Always save" t)) + (const :tag "Ask" ask) + (const :tag "Always save" t)) :group 'eshell-hist) (defcustom eshell-input-filter 'eshell-input-filter-default @@ -179,8 +179,8 @@ eshell-hist-rebind-keys-alist ([down] . eshell-next-matching-input-from-input)) "History keys to bind differently if point is in input text." :type '(repeat (cons (vector :tag "Keys to bind" - (repeat :inline t sexp)) - (function :tag "Command"))) + (repeat :inline t sexp)) + (function :tag "Command"))) :group 'eshell-hist) ;;; Internal Variables: @@ -215,11 +215,11 @@ eshell-hist-mode-map ;; FIXME: Relies on `eshell-hist-match-partial' being set _before_ ;; em-hist is loaded and won't respect changes. (if eshell-hist-match-partial - (progn - (define-key map [(meta ?p)] 'eshell-previous-matching-input-from-input) - (define-key map [(meta ?n)] 'eshell-next-matching-input-from-input) - (define-key map (kbd "C-c M-p") #'eshell-previous-input) - (define-key map (kbd "C-c M-n") #'eshell-next-input)) + (progn + (define-key map [(meta ?p)] 'eshell-previous-matching-input-from-input) + (define-key map [(meta ?n)] 'eshell-next-matching-input-from-input) + (define-key map (kbd "C-c M-p") #'eshell-previous-input) + (define-key map (kbd "C-c M-n") #'eshell-next-input)) (define-key map [(meta ?p)] #'eshell-previous-input) (define-key map [(meta ?n)] #'eshell-next-input) (define-key map (kbd "C-c M-p") #'eshell-previous-matching-input-from-input) @@ -252,27 +252,27 @@ eshell-hist-initialize "Initialize the history management code for one Eshell buffer." (when (eshell-using-module 'eshell-cmpl) (add-hook 'pcomplete-try-first-hook - #'eshell-complete-history-reference nil t)) + #'eshell-complete-history-reference nil t)) (if (and (eshell-using-module 'eshell-rebind) - (not eshell-non-interactive-p)) + (not eshell-non-interactive-p)) (let ((rebind-alist eshell-rebind-keys-alist)) - (make-local-variable 'eshell-rebind-keys-alist) - (setq eshell-rebind-keys-alist - (append rebind-alist eshell-hist-rebind-keys-alist)) - (set (make-local-variable 'search-invisible) t) - (set (make-local-variable 'search-exit-option) t) - (add-hook 'isearch-mode-hook - (function - (lambda () - (if (>= (point) eshell-last-output-end) - (setq overriding-terminal-local-map - eshell-isearch-map)))) + (make-local-variable 'eshell-rebind-keys-alist) + (setq eshell-rebind-keys-alist + (append rebind-alist eshell-hist-rebind-keys-alist)) + (set (make-local-variable 'search-invisible) t) + (set (make-local-variable 'search-exit-option) t) + (add-hook 'isearch-mode-hook + (function + (lambda () + (when (>= (point) eshell-last-output-end) + (setq overriding-terminal-local-map + eshell-isearch-map)))) nil t) - (add-hook 'isearch-mode-end-hook - (function - (lambda () - (setq overriding-terminal-local-map nil))) + (add-hook 'isearch-mode-end-hook + (function + (lambda () + (setq overriding-terminal-local-map nil))) nil t)) (eshell-hist-mode)) @@ -280,11 +280,11 @@ eshell-hist-initialize (or eshell-history-size (let ((hsize (getenv "HISTSIZE"))) (setq eshell-history-size - (if (and (stringp hsize) - (integerp (setq hsize (string-to-number hsize))) - (> hsize 0)) - hsize - 128)))) + (if (and (stringp hsize) + (integerp (setq hsize (string-to-number hsize))) + (> hsize 0)) + hsize + 128)))) (make-local-variable 'eshell-history-file-name) (or eshell-history-file-name @@ -296,8 +296,8 @@ eshell-hist-initialize (if (minibuffer-window-active-p (selected-window)) (set (make-local-variable 'eshell-save-history-on-exit) nil) (set (make-local-variable 'eshell-history-ring) nil) - (if eshell-history-file-name - (eshell-read-history nil t)) + (when eshell-history-file-name + (eshell-read-history nil t)) (add-hook 'eshell-exit-hook #'eshell-write-history nil t)) @@ -314,17 +314,17 @@ eshell-hist-initialize (defun eshell-save-some-history () "Save the history for any open Eshell buffers." (dolist (buf (buffer-list)) - (if (buffer-live-p buf) - (with-current-buffer buf - (if (and eshell-mode - eshell-history-file-name - eshell-save-history-on-exit - (or (eq eshell-save-history-on-exit t) - (y-or-n-p - (format-message - "Save input history for Eshell buffer `%s'? " - (buffer-name buf))))) - (eshell-write-history)))))) + (when (buffer-live-p buf) + (with-current-buffer buf + (when (and eshell-mode + eshell-history-file-name + eshell-save-history-on-exit + (or (eq eshell-save-history-on-exit t) + (y-or-n-p + (format-message + "Save input history for Eshell buffer `%s'? " + (buffer-name buf))))) + (eshell-write-history)))))) (defun eshell/history (&rest args) "List in help buffer the buffer's input history." @@ -332,44 +332,44 @@ eshell/history (eshell-eval-using-options "history" args '((?r "read" nil read-history - "read from history file to current history list") + "read from history file to current history list") (?w "write" nil write-history - "write current history list to history file") + "write current history list to history file") (?a "append" nil append-history - "append current history list to history file") + "append current history list to history file") (?h "help" nil nil "display this usage message") :usage "[n] [-rwa [filename]]" :post-usage -"When Eshell is started, history is read from `eshell-history-file-name'. + "When Eshell is started, history is read from `eshell-history-file-name'. This is also the location where history info will be saved by this command, unless a different file is specified on the command line.") (and (or (not (ring-p eshell-history-ring)) - (ring-empty-p eshell-history-ring)) - (error "No history")) + (ring-empty-p eshell-history-ring)) + (error "No history")) (let (length file) (when (and args (string-match "^[0-9]+$" (car args))) (setq length (min (eshell-convert (car args)) - (ring-length eshell-history-ring)) - args (cdr args))) + (ring-length eshell-history-ring)) + args (cdr args))) (and length - (or read-history write-history append-history) - (error "history: extra arguments")) + (or read-history write-history append-history) + (error "history: extra arguments")) (when (and args (stringp (car args))) (setq file (car args) - args (cdr args))) + args (cdr args))) (cond (read-history (eshell-read-history file)) (write-history (eshell-write-history file)) (append-history (eshell-write-history file t)) (t (let* ((index (1- (or length (ring-length eshell-history-ring)))) - (ref (- (ring-length eshell-history-ring) index))) - ;; We have to build up a list ourselves from the ring vector. - (while (>= index 0) - (eshell-buffered-print - (format "%5d %s\n" ref (eshell-get-history index))) - (setq index (1- index) - ref (1+ ref))))))) + (ref (- (ring-length eshell-history-ring) index))) + ;; We have to build up a list ourselves from the ring vector. + (while (>= index 0) + (eshell-buffered-print + (format "%5d %s\n" ref (eshell-get-history index))) + (setq index (1- index) + ref (1+ ref))))))) (eshell-flush) nil)) @@ -389,12 +389,12 @@ eshell-add-input-to-history Input is entered into the input history ring, if the value of variable `eshell-input-filter' returns non-nil when called on the input." - (if (and (funcall eshell-input-filter input) - (or (null eshell-hist-ignoredups) - (not (ring-p eshell-history-ring)) - (ring-empty-p eshell-history-ring) - (not (string-equal (eshell-get-history 0) input)))) - (eshell-put-history input)) + (when (and (funcall eshell-input-filter input) + (or (null eshell-hist-ignoredups) + (not (ring-p eshell-history-ring)) + (ring-empty-p eshell-history-ring) + (not (string-equal (eshell-get-history 0) input)))) + (eshell-put-history input)) (setq eshell-save-history-index eshell-history-index) (setq eshell-history-index nil)) @@ -416,7 +416,7 @@ eshell-add-to-history command." (when (> (1- eshell-last-input-end) eshell-last-input-start) (let ((input (buffer-substring eshell-last-input-start - (1- eshell-last-input-end)))) + (1- eshell-last-input-end)))) (eshell-add-input-to-history input)))) (defun eshell-read-history (&optional filename silent) @@ -437,32 +437,32 @@ eshell-read-history (let ((file (or filename eshell-history-file-name))) (cond ((or (null file) - (equal file "")) + (equal file "")) nil) ((not (file-readable-p file)) (or silent - (message "Cannot read history file %s" file))) + (message "Cannot read history file %s" file))) (t (let* ((count 0) - (size eshell-history-size) - (ring (make-ring size)) - (ignore-dups eshell-hist-ignoredups)) - (with-temp-buffer - (insert-file-contents file) - ;; Watch for those date stamps in history files! - (goto-char (point-max)) - (while (and (< count size) - (re-search-backward "^[ \t]*\\([^#\n].*\\)[ \t]*$" - nil t)) - (let ((history (match-string 1))) - (if (or (null ignore-dups) - (ring-empty-p ring) - (not (string-equal (ring-ref ring 0) history))) - (ring-insert-at-beginning - ring (subst-char-in-string ?\177 ?\n history)))) - (setq count (1+ count)))) - (setq eshell-history-ring ring - eshell-history-index nil)))))) + (size eshell-history-size) + (ring (make-ring size)) + (ignore-dups eshell-hist-ignoredups)) + (with-temp-buffer + (insert-file-contents file) + ;; Watch for those date stamps in history files! + (goto-char (point-max)) + (while (and (< count size) + (re-search-backward "^[ \t]*\\([^#\n].*\\)[ \t]*$" + nil t)) + (let ((history (match-string 1))) + (when (or (null ignore-dups) + (ring-empty-p ring) + (not (string-equal (ring-ref ring 0) history))) + (ring-insert-at-beginning + ring (subst-char-in-string ?\177 ?\n history)))) + (setq count (1+ count)))) + (setq eshell-history-ring ring + eshell-history-index nil)))))) (defun eshell-write-history (&optional filename append) "Writes the buffer's `eshell-history-ring' to a history file. @@ -475,70 +475,70 @@ eshell-write-history See also `eshell-read-history'." (let* ((file (or filename eshell-history-file-name)) - (resolved-file (if (stringp file) (file-truename file)))) + (resolved-file (when (stringp file) (file-truename file)))) (cond ((or (null file) - (equal file "") - (null eshell-history-ring) - (ring-empty-p eshell-history-ring)) + (equal file "") + (null eshell-history-ring) + (ring-empty-p eshell-history-ring)) nil) ((not (file-writable-p resolved-file)) (message "Cannot write history file %s" resolved-file)) (t (let* ((ring eshell-history-ring) - (index (ring-length ring))) - ;; Write it all out into a buffer first. Much faster, but - ;; messier, than writing it one line at a time. - (with-temp-buffer - (while (> index 0) - (setq index (1- index)) - (let ((start (point))) + (index (ring-length ring))) + ;; Write it all out into a buffer first. Much faster, but + ;; messier, than writing it one line at a time. + (with-temp-buffer + (while (> index 0) + (setq index (1- index)) + (let ((start (point))) ;; Remove properties before inserting, to avoid trouble ;; with read-only strings (Bug#28700). (insert (substring-no-properties (ring-ref ring index)) ?\n) - (subst-char-in-region start (1- (point)) ?\n ?\177))) - (eshell-with-private-file-modes - (write-region (point-min) (point-max) resolved-file append - 'no-message)))))))) + (subst-char-in-region start (1- (point)) ?\n ?\177))) + (eshell-with-private-file-modes + (write-region (point-min) (point-max) resolved-file append + 'no-message)))))))) (defun eshell-list-history () "List in help buffer the buffer's input history." (interactive) (let (prefix prelen) (save-excursion - (if (re-search-backward "!\\(.+\\)" (line-beginning-position) t) - (setq prefix (match-string 1) - prelen (length prefix)))) + (when (re-search-backward "!\\(.+\\)" (line-beginning-position) t) + (setq prefix (match-string 1) + prelen (length prefix)))) (if (or (not (ring-p eshell-history-ring)) - (ring-empty-p eshell-history-ring)) - (message "No history") + (ring-empty-p eshell-history-ring)) + (message "No history") (let ((history nil) - (history-buffer " *Input History*") - (index (1- (ring-length eshell-history-ring))) - (conf (current-window-configuration))) - ;; We have to build up a list ourselves from the ring vector. - (while (>= index 0) - (let ((hist (eshell-get-history index))) - (if (or (not prefix) - (and (>= (length hist) prelen) - (string= (substring hist 0 prelen) prefix))) - (setq history (cons hist history)))) - (setq index (1- index))) - ;; Change "completion" to "history reference" - ;; to make the display accurate. - (with-output-to-temp-buffer history-buffer - (display-completion-list - (completion-hilit-commonality history (length prefix))) - (set-buffer history-buffer) - (forward-line 3) - (while (search-backward "completion" nil 'move) - (replace-match "history reference"))) - (eshell-redisplay) - (message "Hit space to flush") - (let ((ch (read-event))) - (if (eq ch ?\ ) - (set-window-configuration conf) - (push ch unread-command-events))))))) + (history-buffer " *Input History*") + (index (1- (ring-length eshell-history-ring))) + (conf (current-window-configuration))) + ;; We have to build up a list ourselves from the ring vector. + (while (>= index 0) + (let ((hist (eshell-get-history index))) + (when (or (not prefix) + (and (>= (length hist) prelen) + (string= (substring hist 0 prelen) prefix))) + (setq history (cons hist history)))) + (setq index (1- index))) + ;; Change "completion" to "history reference" + ;; to make the display accurate. + (with-output-to-temp-buffer history-buffer + (display-completion-list + (completion-hilit-commonality history (length prefix))) + (set-buffer history-buffer) + (forward-line 3) + (while (search-backward "completion" nil 'move) + (replace-match "history reference"))) + (eshell-redisplay) + (message "Hit space to flush") + (let ((ch (read-event))) + (if (eq ch ?\ ) + (set-window-configuration conf) + (push ch unread-command-events))))))) (defun eshell-hist-word-reference (ref) "Return the word designator index referred to by REF." @@ -553,37 +553,37 @@ eshell-hist-word-reference (defun eshell-hist-parse-arguments (&optional b e) "Parse current command arguments in a history-code-friendly way." (let ((end (or e (point))) - (begin (or b (save-excursion (eshell-bol) (point)))) - (posb (list t)) - (pose (list t)) - (textargs (list t)) - hist args) + (begin (or b (save-excursion (eshell-bol) (point)))) + (posb (list t)) + (pose (list t)) + (textargs (list t)) + hist args) (unless (catch 'eshell-incomplete - (ignore - (setq args (eshell-parse-arguments begin end)))) + (ignore + (setq args (eshell-parse-arguments begin end)))) (save-excursion - (goto-char begin) - (while (< (point) end) - (if (get-text-property (point) 'arg-begin) - (nconc posb (list (point)))) - (if (get-text-property (point) 'arg-end) - (nconc pose - (list (if (= (1+ (point)) end) - (1+ (point)) - (point))))) - (forward-char)) - (setq posb (cdr posb) - pose (cdr pose)) - (cl-assert (= (length posb) (length args))) - (cl-assert (<= (length posb) (length pose)))) + (goto-char begin) + (while (< (point) end) + (when (get-text-property (point) 'arg-begin) + (nconc posb (list (point)))) + (when (get-text-property (point) 'arg-end) + (nconc pose + (list (if (= (1+ (point)) end) + (1+ (point)) + (point))))) + (forward-char)) + (setq posb (cdr posb) + pose (cdr pose)) + (cl-assert (= (length posb) (length args))) + (cl-assert (<= (length posb) (length pose)))) (setq hist (buffer-substring-no-properties begin end)) (let ((b posb) (e pose)) - (while b - (nconc textargs - (list (substring hist (- (car b) begin) - (- (car e) begin)))) - (setq b (cdr b) - e (cdr e)))) + (while b + (nconc textargs + (list (substring hist (- (car b) begin) + (- (car e) begin)))) + (setq b (cdr b) + e (cdr e)))) (setq textargs (cdr textargs)) (cl-assert (= (length textargs) (length args))) (list textargs posb pose)))) @@ -591,29 +591,29 @@ eshell-hist-parse-arguments (defun eshell-expand-history-references (beg end) "Parse and expand any history references in current input." (let ((result (eshell-hist-parse-arguments beg end)) - (full-line (buffer-substring-no-properties beg end))) + (full-line (buffer-substring-no-properties beg end))) (when result (let ((textargs (nreverse (nth 0 result))) - (posb (nreverse (nth 1 result))) - (pose (nreverse (nth 2 result))) - (full-line-subst (eshell-history-substitution full-line))) - (save-excursion - (if full-line-subst - ;; Found a ^foo^bar substitution - (progn - (goto-char beg) - (insert-and-inherit full-line-subst) - (delete-char (- end beg))) - ;; Try to expand other substitutions - (while textargs - (let ((str (eshell-history-reference (car textargs)))) - (unless (eq str (car textargs)) - (goto-char (car posb)) - (insert-and-inherit str) - (delete-char (- (car pose) (car posb))))) - (setq textargs (cdr textargs) - posb (cdr posb) - pose (cdr pose))))))))) + (posb (nreverse (nth 1 result))) + (pose (nreverse (nth 2 result))) + (full-line-subst (eshell-history-substitution full-line))) + (save-excursion + (if full-line-subst + ;; Found a ^foo^bar substitution + (progn + (goto-char beg) + (insert-and-inherit full-line-subst) + (delete-char (- end beg))) + ;; Try to expand other substitutions + (while textargs + (let ((str (eshell-history-reference (car textargs)))) + (unless (eq str (car textargs)) + (goto-char (car posb)) + (insert-and-inherit str) + (delete-char (- (car pose) (car posb))))) + (setq textargs (cdr textargs) + posb (cdr posb) + pose (cdr pose))))))))) (defvar pcomplete-stub) (defvar pcomplete-last-completion-raw) @@ -624,29 +624,29 @@ eshell-complete-history-reference (let ((arg (pcomplete-actual-arg))) (when (string-match "\\`![^:^$*%]*\\'" arg) (setq pcomplete-stub (substring arg 1) - pcomplete-last-completion-raw t) + pcomplete-last-completion-raw t) (throw 'pcomplete-completions - (let ((history nil) - (index (1- (ring-length eshell-history-ring))) - (stublen (length pcomplete-stub))) - ;; We have to build up a list ourselves from the ring - ;; vector. - (while (>= index 0) - (let ((hist (eshell-get-history index))) - (if (and (>= (length hist) stublen) - (string= (substring hist 0 stublen) - pcomplete-stub) - (string-match "^\\([^:^$*% \t\n]+\\)" hist)) - (setq history (cons (match-string 1 hist) - history)))) - (setq index (1- index))) - (let ((fhist (list t))) - ;; uniquify the list, but preserve the order - (while history - (unless (member (car history) fhist) - (nconc fhist (list (car history)))) - (setq history (cdr history))) - (cdr fhist))))))) + (let ((history nil) + (index (1- (ring-length eshell-history-ring))) + (stublen (length pcomplete-stub))) + ;; We have to build up a list ourselves from the ring + ;; vector. + (while (>= index 0) + (let ((hist (eshell-get-history index))) + (when (and (>= (length hist) stublen) + (string= (substring hist 0 stublen) + pcomplete-stub) + (string-match "^\\([^:^$*% \t\n]+\\)" hist)) + (setq history (cons (match-string 1 hist) + history)))) + (setq index (1- index))) + (let ((fhist (list t))) + ;; uniquify the list, but preserve the order + (while history + (unless (member (car history) fhist) + (nconc fhist (list (car history)))) + (setq history (cdr history))) + (cdr fhist))))))) (defun eshell-history-substitution (line) "Expand quick hist substitutions formatted as ^foo^bar^. @@ -656,16 +656,16 @@ eshell-history-substitution ;; Quick Substitution. Repeat the last command, replacing ;; STRING1 with STRING2. Equivalent to `!!:s/string1/string2/' (when (and (eshell-using-module 'eshell-pred) - (string-match - "^\\^\\([^^]+\\)\\^\\([^^]+\\)\\(?:\\^\\(.*\\)\\)?$" - line)) + (string-match + "^\\^\\([^^]+\\)\\^\\([^^]+\\)\\(?:\\^\\(.*\\)\\)?$" + line)) ;; Save trailing match as `eshell-history-reference' runs string-match. (let ((matched-end (match-string 3 line))) (concat (eshell-history-reference - (format "!!:s/%s/%s/" - (match-string 1 line) - (match-string 2 line))) + (format "!!:s/%s/%s/" + (match-string 1 line) + (match-string 2 line))) matched-end)))) (defun eshell-history-reference (reference) @@ -681,102 +681,102 @@ eshell-history-reference (setq eshell-history-index nil) (let ((event (eshell-hist-parse-event-designator reference))) (unless event - (error "Could not find history event `%s'" reference)) + (error "Could not find history event `%s'" reference)) (setq eshell-history-index (car event) - reference (substring reference (cdr event)) - event (eshell-get-history eshell-history-index)) + reference (substring reference (cdr event)) + event (eshell-get-history eshell-history-index)) (if (not (string-match "^[:^$*%]" reference)) - event - (let ((word (eshell-hist-parse-word-designator - event reference))) - (unless word - (error "Unable to honor word designator `%s'" reference)) - (unless (string-match "^[:^$*%][[$^*%0-9-]" reference) - (setcdr word 0)) - (setq event (car word) - reference (substring reference (cdr word))) - (if (not (and (eshell-using-module 'eshell-pred) - (string-match "^:" reference))) - event - (eshell-hist-parse-modifier event reference))))))) + event + (let ((word (eshell-hist-parse-word-designator + event reference))) + (unless word + (error "Unable to honor word designator `%s'" reference)) + (unless (string-match "^[:^$*%][[$^*%0-9-]" reference) + (setcdr word 0)) + (setq event (car word) + reference (substring reference (cdr word))) + (if (not (and (eshell-using-module 'eshell-pred) + (string-match "^:" reference))) + event + (eshell-hist-parse-modifier event reference))))))) (defun eshell-hist-parse-event-designator (reference) "Parse a history event designator beginning in REFERENCE." (let* ((index (string-match eshell-hist-event-designator reference)) - (end (and index (match-end 0)))) + (end (and index (match-end 0)))) (unless index (error "Invalid history event designator `%s'" reference)) (let* ((event (match-string 1 reference)) - (pos - (cond - ((string= event "!") (ring-length eshell-history-ring)) - ((string= event "#") (error "!# not yet implemented")) - ((string-match "^-?[0-9]+$" event) - (let ((num (string-to-number event))) - (if (>= num 0) - (- (ring-length eshell-history-ring) num) - (1- (abs num))))) - ((string-match "^\\(\\??\\)\\([^?]+\\)\\??$" event) - (let ((pref (if (> (length (match-string 1 event)) 0) - "" "^")) - (str (match-string 2 event))) - (save-match-data - (eshell-previous-matching-input-string-position - (concat pref (regexp-quote str)) 1)))) - (t - (error "Failed to parse event designator `%s'" event))))) + (pos + (cond + ((string= event "!") (ring-length eshell-history-ring)) + ((string= event "#") (error "!# not yet implemented")) + ((string-match "^-?[0-9]+$" event) + (let ((num (string-to-number event))) + (if (>= num 0) + (- (ring-length eshell-history-ring) num) + (1- (abs num))))) + ((string-match "^\\(\\??\\)\\([^?]+\\)\\??$" event) + (let ((pref (if (> (length (match-string 1 event)) 0) + "" "^")) + (str (match-string 2 event))) + (save-match-data + (eshell-previous-matching-input-string-position + (concat pref (regexp-quote str)) 1)))) + (t + (error "Failed to parse event designator `%s'" event))))) (and pos (cons pos end))))) (defun eshell-hist-parse-word-designator (hist reference) "Parse a history word designator beginning for HIST in REFERENCE." (let* ((index (string-match eshell-hist-word-designator reference)) - (end (and index (match-end 0)))) + (end (and index (match-end 0)))) (unless (memq (aref reference 0) '(?: ?^ ?$ ?* ?%)) (error "Invalid history word designator `%s'" reference)) (let ((nth (match-string 1 reference)) - (mth (match-string 2 reference)) - (here (point)) - textargs) + (mth (match-string 2 reference)) + (here (point)) + textargs) (insert hist) (setq textargs (car (eshell-hist-parse-arguments here (point)))) (delete-region here (point)) - (if (string= nth "*") - (if mth - (error "Invalid history word designator `%s'" - reference) - (setq nth 1 mth "-$"))) + (when (string= nth "*") + (if mth + (error "Invalid history word designator `%s'" + reference) + (setq nth 1 mth "-$"))) (if (not mth) - (if nth - (setq mth nth) - (setq nth 0 mth "$")) - (if (string= mth "-") - (setq mth (- (length textargs) 2)) - (if (string= mth "*") - (setq mth "$") - (if (not (and (> (length mth) 1) - (eq (aref mth 0) ?-))) - (error "Invalid history word designator `%s'" - reference) - (setq mth (substring mth 1)))))) + (if nth + (setq mth nth) + (setq nth 0 mth "$")) + (if (string= mth "-") + (setq mth (- (length textargs) 2)) + (if (string= mth "*") + (setq mth "$") + (if (not (and (> (length mth) 1) + (eq (aref mth 0) ?-))) + (error "Invalid history word designator `%s'" + reference) + (setq mth (substring mth 1)))))) (unless (numberp nth) - (setq nth (eshell-hist-word-reference nth))) + (setq nth (eshell-hist-word-reference nth))) (unless (numberp mth) - (setq mth (eshell-hist-word-reference mth))) + (setq mth (eshell-hist-word-reference mth))) (cons (mapconcat #'identity (eshell-sublist textargs nth mth) " ") - end)))) + end)))) (defun eshell-hist-parse-modifier (hist reference) "Parse a history modifier beginning for HIST in REFERENCE." (let ((here (point))) (insert reference) (prog1 - (save-restriction - (narrow-to-region here (point)) - (goto-char (point-min)) - (let ((modifiers (cdr (eshell-parse-modifiers)))) - (dolist (mod modifiers) - (setq hist (car (funcall mod (list hist))))) - hist)) + (save-restriction + (narrow-to-region here (point)) + (goto-char (point-min)) + (let ((modifiers (cdr (eshell-parse-modifiers)))) + (dolist (mod modifiers) + (setq hist (car (funcall mod (list hist))))) + hist)) (delete-region here (point))))) (defun eshell-get-next-from-history () @@ -786,36 +786,36 @@ eshell-get-next-from-history (interactive) (if eshell-save-history-index (progn - (setq eshell-history-index (1+ eshell-save-history-index)) - (eshell-next-input 1)) + (setq eshell-history-index (1+ eshell-save-history-index)) + (eshell-next-input 1)) (message "No previous history command"))) (defun eshell-search-arg (arg) ;; First make sure there is a ring and that we are after the process ;; mark - (if (and eshell-hist-move-to-end - (< (point) eshell-last-output-end)) - (goto-char eshell-last-output-end)) + (when (and eshell-hist-move-to-end + (< (point) eshell-last-output-end)) + (goto-char eshell-last-output-end)) (cond ((or (null eshell-history-ring) - (ring-empty-p eshell-history-ring)) - (error "Empty input ring")) - ((zerop arg) - ;; arg of zero resets search from beginning, and uses arg of - ;; 1 - (setq eshell-history-index nil) - 1) - (t - arg))) + (ring-empty-p eshell-history-ring)) + (error "Empty input ring")) + ((zerop arg) + ;; arg of zero resets search from beginning, and uses arg of + ;; 1 + (setq eshell-history-index nil) + 1) + (t + arg))) (defun eshell-search-start (arg) "Index to start a directional search, starting at `eshell-history-index'." (if eshell-history-index ;; If a search is running, offset by 1 in direction of arg (mod (+ eshell-history-index (if (> arg 0) 1 -1)) - (ring-length eshell-history-ring)) + (ring-length eshell-history-ring)) ;; For a new search, start from beginning or end, as appropriate (if (>= arg 0) - 0 ; First elt for forward search + 0 ; First elt for forward search ;; Last elt for backward search (1- (ring-length eshell-history-ring))))) @@ -823,9 +823,9 @@ eshell-previous-input-string "Return the string ARG places along the input ring. Moves relative to `eshell-history-index'." (eshell-get-history (if eshell-history-index - (mod (+ arg eshell-history-index) - (ring-length eshell-history-ring)) - arg))) + (mod (+ arg eshell-history-index) + (ring-length eshell-history-ring)) + arg))) (defun eshell-previous-input (arg) "Cycle backwards through input history." @@ -841,37 +841,37 @@ eshell-previous-matching-input-string "Return the string matching REGEXP ARG places along the input ring. Moves relative to `eshell-history-index'." (let* ((pos (eshell-previous-matching-input-string-position regexp arg))) - (if pos (eshell-get-history pos)))) + (when pos (eshell-get-history pos)))) (defun eshell-previous-matching-input-string-position - (regexp arg &optional start) + (regexp arg &optional start) "Return the index matching REGEXP ARG places along the input ring. Moves relative to START, or `eshell-history-index'." - (if (or (not (ring-p eshell-history-ring)) - (ring-empty-p eshell-history-ring)) - (error "No history")) + (when (or (not (ring-p eshell-history-ring)) + (ring-empty-p eshell-history-ring)) + (error "No history")) (let* ((len (ring-length eshell-history-ring)) - (motion (if (> arg 0) 1 -1)) - (n (mod (- (or start (eshell-search-start arg)) motion) len)) - (tried-each-ring-item nil) - (case-fold-search (eshell-under-windows-p)) - (prev nil)) + (motion (if (> arg 0) 1 -1)) + (n (mod (- (or start (eshell-search-start arg)) motion) len)) + (tried-each-ring-item nil) + (case-fold-search (eshell-under-windows-p)) + (prev nil)) ;; Do the whole search as many times as the argument says. (while (and (/= arg 0) (not tried-each-ring-item)) ;; Step once. (setq prev n - n (mod (+ n motion) len)) + n (mod (+ n motion) len)) ;; If we haven't reached a match, step some more. (while (and (not tried-each-ring-item) - (not (string-match regexp (eshell-get-history n)))) - (setq n (mod (+ n motion) len) - ;; If we have gone all the way around in this search. - tried-each-ring-item (= n prev))) + (not (string-match regexp (eshell-get-history n)))) + (setq n (mod (+ n motion) len) + ;; If we have gone all the way around in this search. + tried-each-ring-item (= n prev))) (setq arg (if (> arg 0) (1- arg) (1+ arg)))) ;; Now that we know which ring element to use, if we found it, ;; return that. - (if (string-match regexp (eshell-get-history n)) - n))) + (when (string-match regexp (eshell-get-history n)) + n))) (defun eshell-previous-matching-input (regexp arg) "Search backwards through input history for match for REGEXP. @@ -880,15 +880,15 @@ eshell-previous-matching-input If N is negative, find the next or Nth next match." (interactive (eshell-regexp-arg "Previous input matching (regexp): ")) (setq arg (eshell-search-arg arg)) - (if (> eshell-last-output-end (point)) - (error "Point not located after prompt")) + (when (> eshell-last-output-end (point)) + (error "Point not located after prompt")) (let ((pos (eshell-previous-matching-input-string-position regexp arg))) ;; Has a match been found? (if (null pos) - (error "Not found") + (error "Not found") (setq eshell-history-index pos) (unless (minibuffer-window-active-p (selected-window)) - (message "History item: %d" (- (ring-length eshell-history-ring) pos))) + (message "History item: %d" (- (ring-length eshell-history-ring) pos))) ;; Can't use kill-region as it sets this-command (delete-region eshell-last-output-end (point)) (insert-and-inherit (eshell-get-history pos))))) @@ -907,13 +907,13 @@ eshell-previous-matching-input-from-input With prefix argument N, search for Nth previous match. If N is negative, search forwards for the -Nth following match." (interactive "p") - (if (not (memq last-command '(eshell-previous-matching-input-from-input - eshell-next-matching-input-from-input))) - ;; Starting a new search - (setq eshell-matching-input-from-input-string - (buffer-substring (save-excursion (eshell-bol) (point)) - (point)) - eshell-history-index nil)) + (when (not (memq last-command '(eshell-previous-matching-input-from-input + eshell-next-matching-input-from-input))) + ;; Starting a new search + (setq eshell-matching-input-from-input-string + (buffer-substring (save-excursion (eshell-bol) (point)) + (point)) + eshell-history-index nil)) (eshell-previous-matching-input (concat "^" (regexp-quote eshell-matching-input-from-input-string)) arg)) @@ -933,42 +933,42 @@ eshell-test-imatch (let ((before (point))) (eshell-bol) (if (and (not (bolp)) - (<= (point) before)) - t - (if isearch-forward - (progn - (end-of-line) - (forward-char)) - (beginning-of-line) - (backward-char)))))) + (<= (point) before)) + t + (if isearch-forward + (progn + (end-of-line) + (forward-char)) + (beginning-of-line) + (backward-char)))))) (defun eshell-return-to-prompt () "Once a search string matches, insert it at the end and go there." (setq isearch-other-end nil) (let ((found (eshell-test-imatch)) before) (while (and (not found) - (setq before - (funcall (if isearch-forward - 're-search-forward - 're-search-backward) - isearch-string nil t))) + (setq before + (funcall (if isearch-forward + 're-search-forward + 're-search-backward) + isearch-string nil t))) (setq found (eshell-test-imatch))) (if (not found) - (progn - (goto-char eshell-last-output-end) - (delete-region (point) (point-max))) + (progn + (goto-char eshell-last-output-end) + (delete-region (point) (point-max))) (setq before (point)) (let ((text (buffer-substring-no-properties - (point) (line-end-position))) - (orig (marker-position eshell-last-output-end))) - (goto-char eshell-last-output-end) - (delete-region (point) (point-max)) - (when (and text (> (length text) 0)) - (insert text) - (put-text-property (1- (point)) (point) - 'last-search-pos before) - (set-marker eshell-last-output-end orig) - (goto-char eshell-last-output-end)))))) + (point) (line-end-position))) + (orig (marker-position eshell-last-output-end))) + (goto-char eshell-last-output-end) + (delete-region (point) (point-max)) + (when (and text (> (length text) 0)) + (insert text) + (put-text-property (1- (point)) (point) + 'last-search-pos before) + (set-marker eshell-last-output-end orig) + (goto-char eshell-last-output-end)))))) (defun eshell-prepare-for-search () "Make sure the old history file is at the beginning of the buffer." @@ -976,9 +976,9 @@ eshell-prepare-for-search (save-excursion (goto-char (point-min)) (let ((end (copy-marker (point) t))) - (insert-file-contents eshell-history-file-name) - (set-text-properties (point-min) end - '(history t invisible t)))))) + (insert-file-contents eshell-history-file-name) + (set-text-properties (point-min) end + '(history t invisible t)))))) (defun eshell-isearch-backward (&optional invert) "Do incremental regexp search backward through past commands." @@ -994,12 +994,12 @@ eshell-isearch-repeat-backward "Do incremental regexp search backward through past commands." (interactive) (let ((old-pos (get-text-property (1- (point-max)) - 'last-search-pos))) + 'last-search-pos))) (when old-pos (goto-char old-pos) (if invert - (end-of-line) - (backward-char))) + (end-of-line) + (backward-char))) (setq isearch-forward invert) (isearch-search-and-update))) @@ -1028,7 +1028,7 @@ eshell-isearch-abort (defun eshell-isearch-delete-char () (interactive) (save-excursion - (isearch-delete-char))) + (isearch-delete-char))) (defun eshell-isearch-return () (interactive) -- 2.28.0 ------=_Part_192799_133127925.1598809356621 Content-Type: text/x-diff; charset=us-ascii; name=0002-Add-.git-blame-ignore-revs.patch Content-Transfer-Encoding: 7bit Content-Description: File Attachment: 0002-Add-.git-blame-ignore-revs.patch Content-Disposition: attachment; filename=0002-Add-.git-blame-ignore-revs.patch >From 82823e208b9a922a129e2e7c2a70497e6325ab56 Mon Sep 17 00:00:00 2001 From: Brian Leung Date: Sun, 30 Aug 2020 10:29:41 -0700 Subject: [PATCH 2/2] Add .git-blame-ignore-revs Git 2.23 introduced the ability to ignore certain revisions during git blame. We can thus freely make changes to style and indentation while preserving blame data. --- .git-blame-ignore-revs | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 .git-blame-ignore-revs diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs new file mode 100644 index 0000000000..f259eeba66 --- /dev/null +++ b/.git-blame-ignore-revs @@ -0,0 +1,9 @@ +# Configure git to ignore commits listed in this file with: +# +# git config blame.ignoreRevsFile .git-blame-ignore-revs + +# eshell/em-hist: Style and indentation cleanup +faccfdb5aa35595ef5746ff98fe254f8ab32288e + +# ; tiny indentation fix to lisp/progmodes/elisp-mode.el +bf018eefa2a9c33f9f80e977ee085e89df526992 -- 2.28.0 ------=_Part_192799_133127925.1598809356621 Content-Type: text/plain; charset=us-ascii; name=Hsieh.pdf.asc Content-Transfer-Encoding: 7bit Content-Description: File Attachment: Hsieh.pdf.asc Content-Disposition: attachment; filename=Hsieh.pdf.asc -----BEGIN PGP SIGNATURE----- Version: GnuPG v1 iQIcBAABAgAGBQJctjg6AAoJEGG4Juh6gMjWmGMP/R6As9UGMJb7w6YfQPB/9Dv6 FbFq4+5V/OyhUxtJTV/1k/+5KKa/YliRaEjDC4LEgPMPL3UnDobl+f9t3OngU6aA yy3AgFgztdVhe7x0kcrX8+vO3oghl4qahXJWmHgxqTvnEs0AjBbKM6TSxEOS9KrM EoiZ5DlbTY0eHjCuQgL4x6rfR/+8H1CQ1PRRzuvXbHmhQyehvKs0xqqvpllDV9dm nc0CmOHbPDkcUgFwHHL0CMOey+3nJzKLbRggYMNTx5ONgwYYDHuPG01pvMUY1NuM nJXFjocfSvucOiACjp4mVSY8o4dHNyzWs77Twyt9tTOvgy1YhAG5bwwr30juq5qt Vd8ESnTpN/t77l4OINQcgMKD74aL+6dliYrF6KDlVQzSj265mqW1mZ7ZX+84A7Cn rJs7EgEgcCrTiuXWSpnBswcmcEvFtysjI5d0MI+RhSQxpUyWgiVv2SHZ1aWUSaGz FbjyTK141fLu50XWBa1HfGjVuX5eruOvhfCFu7G6zqeYfafbKUohXrLa/06ksVqE OZi+gzTQ2fFSqzcHWIE7fZZLpIbTMR9e9ezpQhF4JNYWiiNTBl/7A8BILHCbHEnE IUAxzOvPZ7FJSSc3RAU3kR4fWaHl3+TLa/7Buqmsh9QzLnoe1WprV0dOY/y1GtgO PmltCtEMW78/RYy4VIod =Pv9O -----END PGP SIGNATURE----- ------=_Part_192799_133127925.1598809356621 Content-Type: application/pdf; name=Leung.pdf Content-Transfer-Encoding: base64 Content-Description: File Attachment: Leung.pdf Content-Disposition: attachment; filename=Leung.pdf JVBERi0xLjQKJcOkw7zDtsOfCjIgMCBvYmoKPDwvTGVuZ3RoIDMgMCBSL0ZpbHRlci9GbGF0ZURl Y29kZT4+CnN0cmVhbQp4nJ1cSY/juhG+96/wOUB3uImSgIaB6bYFJLcHDJBDkFO200vw3iV/P9yq 6iuSlnsGA3hsiSoWa9/U5s1e/vfy28Wkf9G6y7q7y+//fPnLHy7/aVfN5fd/v3x8f1mMTWvjFt/i 5fs/Ln887MWay/d//fXdmfwvuOure1/d1b/H/fpq36O9hvd4v77uaUX4vKYrS7qyLvEe1+vfvv/5 5f795Zdhl+Vtv8Q1DLssBf4Srta++295A2e89d7H9G/3q3cPYfq3cIkupk8NMthrguivMX+8+vew J+TDmi6Ge/64hSVhnb6/rmXjtOOHlfvLkm+ks5VVtwTNpju+oOlPkVl28+Z6ZGLCIx6JgK8xAS1k C97Wb42WMVRqpmWhkHirJIVn4hqP9C9Mn1tjvfCZH06MKD9c+Vm487pk4D5fPeJ99Y2RAXYpz7Td 692DeFx5X6BUGPmpuihtXH40PApqMa2ujxzxVjBIpIyZDwioIVUZlFaWp8r2a2ZERadi1pZWGIlE WdDCFF/3yeSpR74TRd0tbx0LVnlFQaVcXNv5Dka+Ha0+V+FV0pWFqyFmzlGoD+QDFd4BQ08lZ90G yVl9exj2ydTOckLgw63eTXpSuV4w3dYl/V74sfbpM30KKok6xAxiZaJVoRpwQgnht2/pRxHmplSF Hd/2b3uG+shKjBbCfTZZZxnv0BD5VpgQyoRJyEpaQTQh/Kw8SAyS1YSf0qi63CWbaOpGK14v69IR rXlv9xPhTJOdtgltlUV19clsnfJ2CcnCat4mA3B3WwaZN3D56FtVdbvu+XCOzlbIMZyvHgWfmfA1 nTCv2WXNyWl3w8sazY/6Sz1cBK0yas2sGqEXo8TPpdtJVw/ZZjNyY5CAOcJne85RrbJZPED+ajfP myJpz8RmQLaZALPuKOVr0rWMwmZl5X7dihgrIlS9JBKtzNVhHyKiOxpe5/5vCb3ZqKe682ZiwMqN G2t28gTNLqRzVwwWpGio6Ae+ViVs4as+aTTYynw3LASn2qgQeTXZ2Xr4+sMyRhqJ+FFMd/EEd8Sk CUSSX0OXtONeVr7O7hu89+vi6X5Vv4fWkHddiHziYtsnub7lCaEWI97vKOqnju5yeJLNosBhk+zR rQe+vCrsKp+z7vQXvTjto9HZ8HKAdiph3vQSljXaV4s+itODSMJV1LxyskDIzFRveI3YEnkwC1wS I0OeGPcoNGlL3Q/soS9ViVsUo71loPRAMHQJGe4XtbBSqGrYIk5NQTxVirbMs/FpAZu7l4sNRAlg yZRWt5WRcYt+WEwPr5RTzIzOq498mywKhp7aokxMikfwoGJIp9Erk/adSqRdUzLRyeS5iu46FMtB 1LJKUBc/ko8/3zTs/m3rM6RiQlxx37a5YsWSdHnhyxNnNqqPs7K+WFAGbPeqvBwI3etFWp5CCh1Q OHmQMoKD44kJZlmzPkGlWKKc4ZUJx626W9i5JzudgTAOFMp622FUg4WmtuVyifkWUhuWGdvkucAs SiqMy4CNQKhUg8N/OZqCZ1hW2JghYySTQhvESLM3ZBpbVkNUIVFFdQCmzKk4bnYQx5/w/KwVh9KP mpuZFD+h16Kcp7mtJ/qyrG/rVF88CSjltpzZcb5rO1fKF02TieIEvI7VywpJjYpBJSA7WSVYyVys tBDbK4Y7e2XLmW3SvcbQXghhVclOomM+NywlRa5I3iVjxpMy/N465UQGcQFmNn+eQxwjqFJIwI88 xHiUdcuIQk6GUDbOhBDnjoOTh9F+wU59wCOZtvaKmJaq45aNWZ6Y26fyGZahFiUVET8vcAzFDUoR 0ek4I4Qg+yfxCmbv1ZqKwv2gR3L2bZlqWMjqtTdGmL1P262pQfB+nhE2VdkxJ9h3BqoC2apExspd B/WID/XgAG3/so2ucXIGovCvbgSuqpRTzjGvAjw7VdkTl9xLoedGGcO6iaFtoTr5+CY+HYAmQCkC h6pdNUK7FKp6nvQnr54SBa87CoX6rdin76VAGumPBcXJSU/F0OyDGEI01nshjM6gTlksSayWJHbG qt4P9ZqULnH5kJJvhffrJK2NnCO1KhnCEYWUi71aMthISeRe/WGLzjOjZJMvS3atOQjoh3E7LJnF 7TFyDjiP22v59VFAoJCnAmq0QCF2VpGT/dMMd7U9ecmWrzOwIcvxmcD5fR1K/uehD2fY+zuU9L4a FxZL7dE4UjkQwj7/UY17H3GkpTOLYop95OT8I11QNqvUHhPxr+kbP4LB+a2PO0uBHKx8LAJF1Xtd rap4dT2EFFqlsCWnj7iPr67pCZQSMVkuB0kxpUu9yPItGciUWOyPoFMwFdUnzjGlWW9+6hyXefgp 1ULPAczGGb/VkRUbMUcBzDxcnVMNwdVsJQp0efpJyVGCNCqUSSajIyEJwawycRK4TTJTYp+EnIKO RGWjRHxCuJcLhC5+E95RZN2T7XgSDXciGVgUpOAhZJvoWx+N9LHvAQSiIPBheRhyFH9lEBA8E+1O 5TPaQT4hS2ePr2qC23lJUNUht7FeO3JssfDEa1/2JaNaWx8tHmnUR7izzc6FV/Ydyq1U5JWwBW4U bVni+c4So3OrMUDRum825jYSx+jdyR6km4s5wahIb7GjnHTC+mrfRIHYq8zKaFkA5lX48PNc5d5g gn4qoWEfWpJJ7jblGVgPoeaoqzsOFatRBDPuCsypsgkXCIHBArzFY0LDj2p27H66PZLPnZloZ/X2 B4N2nHiXDT46UENdykuxwfXFAKBLqQbIFhML6GZRqBvrtwoM8Blp89yUyqZTwIWP23M2AmUwumt5 86fCVUJ71qBT2fTr2C6fk+2siCWcVhUEyx4RWaja8SXovgmw5iWK30T63dr1wJlaiyAn8toHFdhx AF6DAIZuNzyEbkNgbMZZpeaqg2rRD1RNndDs6H6zaYeTMkHaXejTTDSDPY+XoiPc7yI357ttbE0m EGJXha2g18F64a+oXAmSO906lVK3DI3/qjoSPrck7yj+BXw5V5va8Yf2RTW5VEuLWqHr9Et1dCW1 +ILhlRGWJ5G1GYYZXOlFtJ5U/v/LJffWH7Ze2QAoEoQW5gZ0mLoFCEtaX7L5pmZx+WBDpW7dix4S 4oFt8Y8fhWcGmq/PjzI/ybCx7+xbpCXgSwgs8ixY3rB3RGqG9C5TBFGiU9sadx3JsgWotgeqqD34 ZgSAIMPEj6KY77xVa+1ZDgAfTTy03qMN+7SIcSZ/bht6fz8z8VBSMCInKM8Go2zjEBqFtRGUr6vv 7220qKUX29h+GDsP7Ed064HLFZKml89Nut/H0NuseNbCJLL6rgvuOGGhc6GWFT8elBFWFsu0w5Si 9B3aPCO18nrnKbaubf4onaQ8mRIvyH8wT7hpCj8zzW6NQwv5BAUxpXTAUtoHA+xp/nDspuTHoFwj sEsVqFrz5s+VXJGFpz7BpEX3uCxDCH+RjZW05GpGpTe9GzpGhzQkS9oLTYo98w4cVcW+VOdxixv6 oN73w3XNzXjVm/c8IjH2pfoeeJAREU92hh1JkEGNqnZRhmUxIA6yYa6MkLnxMhlzOlij8QC7EGRC ps7Gsm6i0n1Q59/P0RAow/jKuHF3SYdbAMl1Gyp/BC6h80lAkuKR5PckCfbFPKgCsoyveEyCASxa DQOh+UB3YS5scSqRwYydeYj9w1WynK5g9zB19QlHKK1youSgCAiFREy52PU4o/d4XmQF6NN8fmgy q656NTfVFfTNB4qi+7SqEwPY69G0cHaTSKhrUQIpOqIxkfOISKgkDNCaFtu39xFXGHEDWIUbkgoB 3i0oPXDQ2aEA3kkldAGh5y+qrmwM6Z2O+E4l1m3DqMYkI6fWSS/AXGSFIXjxEhQxefZ5HO8Z9ZxI X/aLNPsTdHnCmVoGJcU9uvGK3gzAZPEzR2LGd1NgvstxVj16EPfE8Eqs043dcYIsg4s4MODUneTV Ng4UuaMFI4/DjFeYrZB41gn2I7MpdBtnFQs9i3pB/ZkV22HtrukYnG6swal5KsGcmuNdMN8NFmIt hNzbgIHuOk3RYSPpdU3tybQejIaeeu4nomd3N74WBTOEplklIyJzqn5XnhMoj1TLYdQ4iGp4UcfL 6LTTCoyvTM2rLSDjoYkrA/SWZokdb04fnbCj1NgHYjuBeMoU3HlaeYAFNYxBPvAo8knkgDk20BLC XFAorEcg86hKpqk7TCUy63AOqYdVk3slGr29PBXTzYyDHk8i1meSv4xv7/kAA85+kNbAA/wPwhiw sdAiIootEqtPg/jwxfo2KJvv+lND5NkFq8OY16cKmUumKwmLeo9C4n6IisM42yd32jgiNrL7KJvL XvMo28t7DJOZxBnyfmiHdXDMybQI8GGSaDyZaNGHepw6nMpkCINMzlg2adiQkKkOEsQBJJ5SzU9Z uExcwECIbp+o4ALDytGdPhpsPeDFgz6cdEOZDyrp06K+5IVDVjGkrBjDduhzDOtBe3Nw3OofHZnH zBsyFNcRYd5Uk7Dw1p3AjbYCyNXKaXoGx3Me0qDzFJ7torK+NQdlY/oeWkQ11qjPpdW7YY4AwfeD Qm2SC18boraVjHPVwJob3rozseA7RtQs55ek2nwIjJBhh3zRMisP9wYMhvQ4jJSN52XbpX+m3+Oh CMiYYOU9O/bqkNWJiZuw25epxZLeKkPDa8QKX3l7uWvuCKNOiNuazcjVB+fXR2R6n0qdM6PUQS38 i41+mbFk4enqbsCZOjU9laMHc6MP5Cj27BxUIJL9aGR5OPdIb13fxhM9pPYdMdBvb30NghprHW3i ansBkitQfxt4Y6VQAuOeU00DCkLQV786VcH+CQ6WOUQ9aHIqimZ8c34uTXmDrlbZLlEVvvwIOLtz LsBD3eFwd2fmb+QR/IdyUe/mAtbA0pKKwB8zMH2ZR41d1rI7/QmEKYOw5j/5SwW1t0CM0AaIT7Fx q4hqFkRO6ZFIZ+fBtLvRjacu1ufGAyJ4QBeGy2jAP0in/JNQb4+j6Miwm7y7DDE3zNideFldHwuT 8SscWOvflB6zhkmIP33pWNXfw8SdTebJDj1l1p9d7CaswTeKmwAv1OfG5jtb+v4cetQHQHcSIK9r DzzpAtFhxm4IRHFqL8NaNH9n86+kwvK2eaS3+/txxV465K+YaI5I8Vor3JPkexv/hoSeBVBG4Ucn PkzLeLuu5jh/o4we9wQbjKH5OxRjy1IJgYYJDSwX/HL57ZKO7i5x295iHjvJn3lqVv6QUb64FlKl G0GWr5e///ryxz/9Gi63/14yqP8DRBCywwplbmRzdHJlYW0KZW5kb2JqCgozIDAgb2JqCjM5NDQK ZW5kb2JqCgo0IDAgb2JqCjw8L1R5cGUvWE9iamVjdC9TdWJ0eXBlL0ltYWdlL1dpZHRoIDExMjkg L0hlaWdodCAxMzEgL0JpdHNQZXJDb21wb25lbnQgOCAvQ29sb3JTcGFjZS9EZXZpY2VSR0IvRmls dGVyL0RDVERlY29kZS9MZW5ndGggMzY5MTU+PgpzdHJlYW0K/9j/4AAQSkZJRgABAQEJ7AnsAAD/ 2wBDAAMCAgMCAgMDAwMEAwMEBQgFBQQEBQoHBwYIDAoMDAsKCwsNDhIQDQ4RDgsLEBYQERMUFRUV DA8XGBYUGBIUFRT/2wBDAQMEBAUEBQkFBQkUDQsNFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQU FBQUFBQUFBQUFBQUFBQUFBQUFBQUFBT/wgARCACDBGkDASIAAhEBAxEB/8QAHQABAAIDAQEBAQAA AAAAAAAAAAcIAQUGBAMCCf/EABsBAAEFAQEAAAAAAAAAAAAAAAACAwQFBgEH/9oADAMBAAIQAxAA AAG1AAcvxfUK1zeib0ocr84AAGcAOShdqxsrq6i9c3YS5ze07JUeI/jPfo6mvvynflUvRb9Oq8KJ mo++89PUaT0bT5jeOH6zaCu/2uMyc4HeAAAAKu2io5G0W9d5N7c+qi1eFRaq2M3+zcgxPDMgRYxf 7Naouuqz0c2V7TMsj01Dr4PUkNw93Mbx9D71qsuVtVFq8BViyuz0C4ldMRjfGPoquLVZdqKqLVZD ne983pk54FMoe6qlsXSdrpbddmmRRL23g1PU15s7GnSu1n2rxFE7sXkP/C8npVGpVM0iVMTJu59K pWsk5uK4NlCDImo6NarLlfVRarIQnprG/hcWp61REqqrwdyzecqtVl6jizXTfEK46bqP3gEj4yKK v2thTyVvpH9D2u2Nj5wiqVagtW8lznE8sdY0FWO1gKNp7gSdS66L9AD9NA8Y77TwN38VqsOVdXOs lqtKJ1t9zS+6EnPV/jnZouo1i1WXKqqi1QK22v024eqQdrlMLn1RjaGGN9oZMhbfm3e5cgcBiQAR 9iQ+Z4vQ/nSWQ4qHrCyx+5uM+P2xDblbMUeV5lFm50PlsVuetV27mUMriaDefo5X4ZdSAAAAAAAA AKOXjo5F1E0z1W2aFwuqcqdq+qaLe9arzGcmRnB3V0mMz8GjjtKsM3ET/wBDKl26asa5R9IMVtWt 4UZpuOkxGbhJnC7zRnKSf0N/nlcOLrZSRml5OTEZ7cT2oXEAIqqpfamkLY3F2FCZmcg2QR93r9F9 KkW2oFH0HdXEg2clxAfpHLdS4v8AnbdOq0vwN3s4Sm2Cjl6s8pmdieqcrgOrfn9KYAKY9/wHf1+9 seLDBOe6Fxf87b6U5niDtZsi6UapSc7yXK2N4aJrpMmSoNvpWU8dDLTQ21bWx+nohmTmq02ThC68 XUfztvJVrsES7SCwwVV/B7/BX7224sMEhOUKkR77mr8Vosvx2pnr8msYvbjIzTMZJiMwSY1W2XEw inDcyV448HHpl1wufTCxsXVWIRRmbipWRTgJQo7LsfxtLOEuYzLyjGdV1mtPX6WWImp7b712idyJ cvU0Ywzbf0J9n89Jycr7Moy556pm5U+Y0vSajIqNJqMgSajIEmoyBJqMpLUx+gpkAUcvHRyLqM9T 389JeqLm3JcGAZ+HqqvNerCxpB22n/N6j1P/ADxmvpoLYvb2fbVbWx87rlCs1R9X77rFoknN1exa IHAfXuuFXCpJOEIf0MibGsq0SRm6u9nN7rQP1AA+f0BEcTW1M3H8/vvfOHY99460/D8MXls5irvY ifgQeqx+ApTIUM2JrvQPzXCx8JHOpzblIoKjYt0Dyesk0AHKY9/wHf1+9seLDBAFauZnWoEDdX+o Ramv6o1uOGlbySsxQK/tArUxNbF8j1rvP1ja0ls9SY7bCZKb/frMxVZ76MmL7+g3vgmdrDA1XiGX vBB3PG/O9h6k/nbY7R8KxeXaz5/RZed1M4rtfXXehfZaJJzFXVogcl12Mv0/86RUevAAcAAzjoli J89j/wBE81G7+wwE9IX79cDVchNoXEPS9yE6bUdgUxTmMP6C0Dgb3zBi/AAAAAADP9DP56f0Ll4/ 0CbjQBRy8dHIuommeoFnpysB6qAK8xnJkZwN5dIT8H+agXB1bVlUi49D5ejaL0x9IMNpmXxV2Ssv YlXYFieFjDredqP/AEM/nlYiNpbGq7JWZsSrsCxKMpNcrQUzjMMxCxdXEQD0yo8sIpjXi4m2Xlur E1lK7x1T5ZTF4kKbaVlZVh/i4WZu/Jezh5UVFgmEpthJi7vFksMGAAABTHv+A7+v3tjxYYIA+FAv 6CVFi6fj5zrHfRqz34n4Wo3D2SqTW+jSRcyCJflZetO7gu9LNx9G7TcbpIEstoG51N7y/wA8bkx9 BD3g9/gRLtuLDBeelN3uZZt69Wr/AJ9WSZuY/wDX5OUasrvK7JeVsSrsCxKu2OEuuuw7Xclx0v8A DIk0itRVi4sTY9E63M7C8i67Ack60ETRBbg3YUQnudCZASKBjIDOA+X8/bJ1egbpZCErPJeqtcin t93a/is9ok5ji8dqDinag4rPaA4rs/061jIpszgEZyYS9y3U5x1Az1GGQcjppGIkjK42AHKcfLZE viOalxzsRpdcciJLuAiPsesKaiJLhLsRpcBEWZcyHFdpnC4YKb8PCyQS/BGlsibsK3dXM2ROv92T tXiP5Bccrz47JGrOE5U3GXIX5yyuJy3NyYRKGVxcMgwzgACOtr2BEoFxTIMcj1zjkWykzxeGSmPD F8ukSdV4+hypqM5LOKYyUyARpueyIlcP8u9AC4pnAcTz8rG5nBc/Lo7EWZczxcQpdBEf5l7Jxgdg Z4jtuKRJpBcOnlwIW2lTOFhgM4zgABnGQwAGAy46GWrGxFeIT1kTWfv8eqxzVt9Y3t/TqTmI5kmN JBjaf1PJlUL1PK6ep5ccPXJkUye5Bn4T8OAZwAAZwi1L8pZigmRK6NZJVGBTLOADn+K6HEJ5bsJr aHfOV+WHU5wBljjOOdm1+wEDheOd1nBTWcADAZRnJaXsml63u3P9AGB1IBnHL8iiXK2Yq6AO0z+f 0uJgAzjIGAZxxO8S/ugpgAGl4rdooImysikErZ0m6XCyY6kAZ4vo0u7AKaAAA+cZpflBBXWIkyS/ P6dr84zgAA8fFJekHOCmTmtklzZ5xlTeADiu14tEij9vahW6hbiWhYefmNdzuycNyiJkx5rbwzdj cbh6ceFm2sJE3l7RuyidZOSOtVBmKyf7kUOg37MjPYiyU4sRMq3fahN92L0JeUAADGQAAAAABSO7 lHYmmt45s9WdV0HO9EuCCmgDhIE9M6RNTvvzvUrNVGsJ44Zi6W04l5YAVdtFV2PeTj2PHdi7VYqN bmo7NzbjJJz4A/H7/Afz/sVwv5rvQLaxb6vNMyesmSG5lEYDtcAQB7/B1UTT9LG88H6apFt6b2iZ tumErNjIY8/ohREqEO3kmC4Wxuc1G3n4YOpeP2Od5mJLAws1baKYI1nAV4/YO05nHeAFXZvhCb4u l7MSs0AMZ5PjldJphK3cbR+OK5gP0NWrS0wt4zc7NnEnOgHM0dvFBcTVyNKlNbPLgRp3fCd2K7wz IocAGt2Tnai7e0eGL2uWvs863UzFtHHav7SxjrUF9DKWVRuQ6L2lwwU0AADOAIslOLG51W770Ivu xehLygAAAAAAAAApBd+lcXS2fdqfo9NuRTAdSAVSnTEBxNTbZo/xKzfOQ1rbBxdJ2wl5YAVdtFCb Nv3XZV7nXrHvqLPcRN2dnBJzgA/H7/AVQtJVu2UbQUyleT6YNWtkplhqZJObB2uAIA6rlfdE084u TjV+mi61UB2Zaswk55nAPzSKxmgi6Tyx7bf5qjwDYmlFzRfqEigAELTTCzVl8Jwg+cBQO1ecAAFX ZvhCb4ul7MSs0AOT6zHF1Et5UiaI2kk94YtfoYPt7W20rNznBJzoBzMJzZCce/nOp9z4+61HEmU5 uM1Zd5nCZk2AM4AzgDIBgAAZAxkDGQMAMgADEaiJlbrtjFyySs0wAAMgYyBgBkBjIGKpjNzawPU2 QGMgAGOXOO0n+5V+o3Y6ItPLA6gAYArjXorfRpatoSst9ckiiAH4ArjZAatULHWdxKR1DAuGyBC8 DkPY7yyQuB2OSTnMZDuMgVwsAM23vD1TAndjF53+R+jAMRUIm/KWjgyOQgDGQK9y0MXXVYH6XOAG QPlV8YuYQsYRNXYb9Fl52AAGgigZtp2wPVNdJbGLvsQ/Sf/EADIQAAEDBAECBQIGAgMBAQAAAAUD BAYAAQIHFyA2EBQVFjUwMxESEyExQDI0IjdgJCb/2gAIAQEAAQUC/ouSbRnTifg29LbVFp3y2yle /KK6lckkKvssjXJxC1W2g7rk9zWOy3WVW2I+vWE+f53tMC2dONqu0nAt96kP+lI52XHHOSDlckHK 5IOVyQcrkg5ULKuDIHYUiex/Dkg5XJByuSDlY7KN40w2u7TuDkTKQN62DJHwC/JByuSDlckHK5IO VyQcrDY5u+cjILDo5yQcrkg5XJByuSDlckHK5IOVCizg0C6JPsRuHVeTs2+yyyMPqsoXZUjMTbW8 d2IUck6MHWYJuW2k9cXUPmimVrGGlM5ybYZANmtnuWOVs8a2AeeAGPJByuSDlckHK5IOVyQcqETE mbOSSdFxp3kg5XJByuSDlckHK5IOVyQcrX8ofn3U6k5ePl9fy52ddeM2nD4Uais+IPTnjPpKvH2c BkRWQvaOlMQwnkg5UEkqkhHeM9lZECT5IOVyQcrkg5WGyzeNDtrq45Ci7Uy1qdy4kCM8kHK5IOVy Qcrkg5XJByg8/MPC3RJTNwIfltao4WucDfQLyoYEsT2urnWJGSSjMfqp4vTPWwZrZCOi22KbZJG1 OCDZpTicBG1LbQDp1jszFaveJhavW5OpbzMwUry8xXutDzhGg2uhgpX6cx7o1cwbPGPoY6vQx1eh jq9DHUg3Sap7c+3BkE3Mo9DHV6EOp1Dgzu02hFo/jHi6gQva/wCNtt/zA0E3Mp9DHV6GOr0MdXoY 6vQx1Tf9onSAQd+j6GOr0MdXoY6vQx1INkmqfjMymQiOtW+b52AijEAh4OxLJ/b2ALSISE4jHxhM o5MvYlrlO6Ldqi0ToxFxxxOUxZeMu4DMchjits/FxNLBeSehjq9DHV6GOr0MdSAxo1zUEMV1PQx1 ehjqnaCbaT6sZN3inoY6vQx1Nh7ZnfajD9cRDSPpkk8FlcUESLzIg/RVyQWHPcSLHw2SS89Itajf Ix2tqmfzKfo5/owMx6TIfHa3zWtmyTuQ+hjquCG3p3CQrzGYxLKMuYGYUFSCtp9x6xaIPDPoY6vQ x1ehjq9DHVgGYJ59ExLvVDNNj5Fkh7oL17oL17nLV7mLV7lLV7kLV7kK1eQlMrA4mSkOQXW40bZN LBHCssrYWJz4ONu92m8c5WYzKQU01RlndnrkK1pqCHMqta1rf0Zj3RqX4/p259vX/dnjsLLDGKY4 3zzSt+VLbf8AOvO7umcdqU3+x9DZbbNxGBTz04mxfIEm3Rssxd8c14EsWO9ElDYHQ+WN8MoOWuXj u2fi4d3R9DYXdeo/ueMgH+qBf3wyBP8A1QRWxifp8chYbE2fIs8hz/WBPzQOnjrBk0tZUyUaNsGb Vwvg1QMEcy5ROIfmgP743ihj1sF4bW+a1d3L47Wyx9CAp3WN1tPuPVHzn0ZtEHrZeg8AImx3FZau Ky1cVlq4qLVxUVo9C3Udaoo5uFYtrXFCsMLJ41e/5bSDZLMbf9aQThcPqtulTAOyF4/1pj3RrMuy GsvdQivdQivdQimhxg/Wrbn29f8Adng9JNRyc6mOMgzgMWULEK23/MOJICZDyMCrkYFXIwKuRgVB zbQ63nHalJbEBYpcjAq5GBVyMCoVMBZp30OmybxvKYg6ji4k6+CKjdsZ2ofPAxGsFMVcaLuLuiup 21sBHTLG3k5JqRz/AMds/FxZdNrIvdQivdQivdQivdQiscrZ4+Owu69R/c6JeO9LkWrCH64WtolP NGtVC/0h+0BnlTetSXkZFWyyXko7rUb52RVs4z5IRCQ3rR+pyH9HkGrTPliPhtb5rV3cvgRNsRKc ylN5K/1tFlMnNbT7jgBtoCKcjAq5GBVyMCrkYFQwm3MNOjYVv/yVa97S6F1sGyMlPKyIrBYhiEa+ F/2qVyx1JX0d1ikjZBum1Sp2XZMK92BvxbPEHmH9SY90AYm+kSXGBmuMDNcYGahcKIgTVbc+21yX wX80cq7g3lSv5/1IHERptBFHBBOtt/yDEZnSfE76uJ31cTvq4nfVDY6rGh047UrDVL7PHid9XE76 uJ31ROBOo+Y6VE8VcC+tRhC5DWBVrT0Y7G5DTT4QpGtkJkLurfg51Zf8Y50zq/4yzUlv/s2z8WPY qEnvGBmuMDNcYGa4wM00Tui28dhd16j+50bYH/lc6zI+TkSyuKCJJ5mVJgh9hQjZIzz0dZus2Lto 4xeNdokvMm9WjfKhampj1qQaxEeSDVssN6gFYPMx71g8wIM62t80yzdJreaOVmsaUtf8fxg8NFPW VrWxtW0+443HFZK74nfVxO+rid9XE76osGUAhq5MCVyYErkwJUsnIsuBqIzgWHAcmBK5MCVyYErk wJUvnrEmE1+KxKSPxKoqORmtnA4Xm+nQVjRLbH7k5gWK1e/5r02dLM1Y3s1VG/IoOjuyGeA5ns0p d3yKDrkUHXIoOuRQdcig65FB1yKDrkUHXIoOuRQdY5fmx6Zj3RqX4/p259vX/dnhseJeYwAHF4+R FkkC7Gtt/wA687u6Zx2pTf7H1FUU18JHrdm+SzwyTzrUz+35OjLK2GJh56gV1QyukM2z8XDu6Pob C7r1H9zon471GMsHeTB9PTOLaKwUZ6pJKdN8XbZ61zYu9dF8V4y+cqGSwpjiMHTUz6KApvsMw1Q5 LN0tsUw4RrVhn9dhW1vmtXdy+GxYn5JaJSdSNkG7hN0hW0+49UfOf0dbFEx5/oOwoafVtqkbSOrw ydNYSEaWsHYWohEhJLCYQpSOX+rb+W/2OmY90al+P6dufb1/3Z4XtbK07itwL6FSvKOvcM8VMNt/ zrzu7pnHalN/sfQ/HqO54qGvbq2UbjpnMAWZvESDbx2HJsRY5m0VfugovAML2z8XDu6PobC7r1H9 zoWSxXSIs8h78sdzKDtVC/0WHhswZ5KQCzagtnr8b6jJa2cZ86Y1jHknWHog+vRB9eiD62dHkmlo oX9EO2v+NtrfN6u7l8HCCbpCWRtSNk9fy/0tetp9x6o+c/pBtkkhiWG2ml8UNqC86DyYcd637JMi zco+WcfUt/Lf7HTMe6NS/H9O3Pt6/wC7PEmNQLMToVcCS13L/wBDLbf8x0v6EX5ctXLlq5ctXLlq 5ctRcv67r6k9s2ww5ctXLlq5ctXLlqicz90OPHaK2aAYdsYwws02y3ythswLlWeywmFSDZyj5AEB dSB6wEN2AqWwNwGzj0sfRzNltQcthnssJjYxtXNTBNJ6dfwyF4R5Ots/Fw7uj6Gwu69R/c6dmDvJ yLG18sgI2wkP4bNGecAVqkb+kwMEsBAzPNUi8BC8QwnxPC8TIlRPJFSBGfV4/tb5vV3cvjIQSMhG v2Kwx5ryX+fT2n3HE5J7ZfcuWrly1cuWrly1cuWrl21e0g1e0w1e0g1S+OC2kbqCx8a/jXtINXtI NXtINXtMNXtMNXtINRfW4shT/WRZrdaMlkM4BDFhSnUpnZJN8v5p7Uujo8fEQyWDgt7MCV7MCV7M CV7MCV7MCV7MCV7MCV7MCV7MCV7MCVa35bdJDXwok9AxxpHUuk/GWcjsKgYwO+6DsaYyLC2sQ1rl 4iyOJcYBq4wDVxgGrjANXGAauMA1YRppgC4wDVxgGrjANXGAauMA1cYBqAxJjHVfF2yQfou9eg3d L6nZ5Xy1GpWOo1PxYauGNsmbFuOQ8CsFEFbuNSYXvbUan4stVjkMhwhmJS8DsdayJEfr4UNe/QKw QYZfAYsyjl+k9GGUjpprkQzdeLxom/a8YBqGDURDE2EQPNB2vhIx70kdfCSb0DFWcczOQ9hIXISF jwDzoORAdIVkdbimypqFjzzrjANXGAauMA1cYBq4wDVxgGri8L0TftWtcdqf0NjSrBq0qOj7lDey e1QHzf8A7aa9q1rbtX6zx+3HoybZmS2OWd88q1pGs2aUxlJB47bOM2rjko5XJRyuSjlclHK5KOVy Ucrko5XJRyoFLSJ8p/62adrVrTtb6hSXChFF9qrKU/Juii1NmyrxaJ64s2yqYRoi0fIIZuV+PD1c eHq48PVx4erjw9XHh6uPD1ceHq1/FyQMt9HPZIVPPkwJXJgSmWwBBB31FTzALg42qNwu22qNUuLO MTKfUblg+PrsHqZFn4MpmNflOm9/wsjsMMs58CxZuEZBjbU816TkjZx7DkwJWOygd6YzEORv/P0D UwGgXIgw2Ns+kuXbhGXJgSuTAlcmBK5MCUILtzbLpNywfH1x75Ikz6lFMUsCGxgzHK22GX5huwA5 LO17ZW6XbrBk1GToSWeeBuQNI8kNIIlWXTM+161n2v8AQzUxSxfTkKwolti9E5YVLeI8GQKXEaqV UoSCZBEfDZXaoD5v+kAQTcy/20Kr20KpKPjUFemXyS0bFxSMrTF8yCsRyb4GwJJyiOuIWRiUixkY vp2x8vD+2PCK/wDYnTn/AIWaKulteTDzeFbJ7V1b2907b/1NfBWD2OKxAMtUh1k2VQh0vcAn3U4X waoKovJmX1ca8qQ6XTRF6l7aFVskQyYBdaCWT8V7aFU1aIskunbHy0N7X6b/ALVK5I5lRWPQMeHR uzQywlGvmhJvApWsMfdMl7fRbr3Sg0tsfZ1tn42DdqdMy7XrWPbHh+NLkmjWzibBG1OdpCUqdbaU vTzYZt3Tsi6fZY43zprGyj27XWZlxTHUyWND4SGG3xwthj0bK7VAfN/0gz1IdKeRAdciA6Dn2R7H p2m6uqehLXFrF/Cet8XEV1U7uma6dsfLw/tjwiv/AGH05/4a4t+Mrm8Vzjr6FyvCRstk9q6t7e6d t/6mtO1vDYrTBrKIy5ydgOnZ5ryYvXAT00JKhykXk4gimWG9W1fgdUfDde2Plob2v0ytzkzjmsm1 l5N4z1t5GVi3F3Q3okvb+rG6bux4O7g5yNSFGRjts/GwbtTpJMUybElrQs0UCqSuPs8n06WvmPnD mrwiUOax1aYypPUz29kdSU31OxwujrUGlZCIhm90GTdt9LZXaoD5v+kCapPZb7MCV7MCUODsxOPT tRpdI7CXWLqL+E9cYt4rqppdQz07Y+Xh/bHhFP32H05/4a27ses0iDUmPewI/KTjeQQTVvb3Ttv/ AFNadreGxHOLuUgmVxwfoyythjIDeBuR47XZ4YzGWs5O31Wa/wCPVtX4HVHw3Xtj5aG9r9Mra5PI 5rJzZCTeM8c+elYxC7Qb0SXt/Uf3jYZA6PaOX0AkOyCCBQBBu1P7eyu1QHzf9KMd6/Ql8btJBcVk q0NeszjB+k9PDxyUnkTiakIlHcY4L6dmglCDCBTVogPxfts7SKYMQrPWIdZcn05/4a27sqQgkZCN foPAa2rO3unbf+pr42PYxxSWB0sT+zWySMJhbh296diGvSwWsQVm439BOs2qSmDtJWFytq5weNun avwOqPhuvbHy0N7X6b/vUrjTqKlY9PR5hHzze1pPsJmNQgcTWJPumS9v6k+9Uxi2EkYLqOm6cG7U /t7CxtnGgjZOxj+lH2aOEq+ieCsSrUghgisKbJuFw4ZkJb9ewALBnlf+YMGZkyKSWCCfTn/jBGiS Mk8NkMG66OvEcUAnTspDBdv6c3oSFZuXImMCh2PVsNHFybYJYN2Xhsligs6g3/GO9OxUcFw+uUcE BfXsdsmuTi2Fk491KJ4q4T4EwGubW/eAR8e7xtb8LdJ7G2YXWrdNBXw2GNbZF4hhZOOeH//EAEMR AAEDAgIDCwoDCAIDAAAAAAECAwQAEQUSEBMhFBUgMUFSU2FxkaEiMjM0UVSBwdHwNUKxBiMkJTBi guFyokODkv/aAAgBAwEBPwGkIU4oITxmpECRFTndTYcGPh8mTtQnZSsMZj+svAdQ20ThyOIKV4Vu mGOJj/saQ4055kW/xNam4vuP/tai20ONhI/9n+6yxuYj/wCzSVYc2CVpBPsGb9TRsTs4OCMtvPKD ib7KkyoUZ1TRYBt2VvjB93HhUyXGfbytNZTUBiPuDXONgkXrfGD7uPCmHcNmK1Rayk/fJWJwdxOD L5pqCxHEAPuNgkA1vjB93HhW+MH3ceFOPx5TzQaby7dvXU8w4OW7IN63xg+7jwrfGD7uPCnlJW4p SBYaMKw9uQC+95opWLsMm0dkWrfppfpWB9/CpimJTidyItfk66EGJhresleUqt+0J2IZFvvqpowM U8goyLqbDXCcyK+FYaxHMLWuIBIvW+MH3ceFb4wfdx4UJsXXlzU+TbirfGD7uPCnExG4u6tSOTxr fGD7uPCozsd6eDqwEnZasYjJjyPIFgdCcMY3PqykZrcfXRBSbGsKjiRJAULgbaxAt7pWGhYDZWEw Gtz6x5IJV7axWKI0jyR5J26I7MZEAPrbBsK3xg+7jwqOvDZ6tVq8p+/ZWIwtxO5BxHiplqM1AS+t sHZW+MH3ceFb4wfdx4VNfZfUCyjLowVbSXzrPh21IcZbTd+1uut1Yd7U1uvDvamkSIDisiLE9lSn osNOZwCpWLyJGxPkp6qZjuyVZWxejAixPW3NvsFHEGWvVmQOs7TTmJS3ONfdspSlL2qP9HAPTr7K xNlxUtZCTWoe5h7qUlSDZQtUP8JPYr56MMiuPyEqA2A3vWPPpccS0n8tQwVYVlHHZXzrcUroz3Vu KV0Z7qYSpElCVCxuP1rHGXXg3q0k8fyrcUroz3UqJIQMymzbs04LJbLaorlScEfbN2fKHjTjLjJs 4m1YC0FvqcPIP1rGHi7LUOROzQhZbUFp4xWLJEiEHvZY99YcL4YQP7q1D3MPdWoe5h7tMr8J+Cfl oQooUFDkrGUiRERIT93rC2NfKSOQbaanZ8QUxyW8RWLs6mUr2HbWFDcsR2Ufu3+6jsqlPJb9tYvK 3Optlr8u36VibYmwg+jk2/XQn8I/x0YRFcckJct5IrHH0uvhCfy0EqXhQSkXNq3FK6M91bildGe6 lJKTlVW4ZXRnuqJCkpkNqLZ4xyVjTTj0cJbFzf61uGV0Z7q3DK6M91YZH3EyuU+mxH340++uQ4XH OOki5tUpx9j+EhoIA5RxmmcFlO7XPJ7aT+z7dvKcNScDdaGZk5v1pECUtQTqz3U9hcpkgZb9m2tx SejPdW4pPRnurcUnoz3VuKT0Z7qcYdZ9IkjTgHp19lTsWkR5CmkWsK38l9XdUmS5LXrHOOsOXqsN z24r/Ot+x0I+/hWuViMPNGVlV97KUCCQrjqCst4XnTxgH51vzM53hW/MzneFNOqelpcXxkisXmPR AjVHjv8AKt+ZnO8KcxWU6goUdh4DGLS2Nma466Zxtl/93JRbxFR4TUZaltcSqxRBRMcvpxD9zhuR XsArDFFGHZxyXrfyX1d1b+S+ruom+3RK/Cfgn5acP/jMOUyeMXH0rB0COw5KX92pmQpt8P8ALe9Y 6zrGkPp5PnWJ/wAJBbijjP3+tYDG86QewVJwmXIeU6SNvXWHRnY7JZftapbBjPKaPJUZ3U4aHLXs K38HQj7+FPLXPh54qrH72UeukOqZwsOI4wK35mc7wrfmZzvCnFl1ZWrjPCkMiQ0po8tO4PLbNgm9 Ow5DIutBApudJaTkQs2pc2SvznD30l5xBulRrCJypaChzzk8P9of/F8flpwD06+ysV9cc++TTD/C T2K+eiBMVCdzcnLWKwUyEbrY+PX11CQXMLyJ4yFfOt6JvM8RW9E3meIpEGRGdbW6mwzCsZiPSgjU i9r/ACreibzPEVvRN5niKeZXHXq3BY6I+FOymNc0fhS8Nlo42zTWFynVWyW7an4gIIQ2jaeXsqZF bxVsPxj5VHD5aTbVmoGErSrXStgFYtPEpQbb80eNYf8Ahh/y4Mr8J+CflpwF7K8pr2/KsZWmPGDK PzH/AH+ujDFplQ0pXtts7uKsXcMiZkTybKxFW4ISIyOM/ZrWr51Qpa476Vk7Kx6PcJkJ7PpSfwj/ AB0YbOMN3b5p46xeAFDdbHx+tIbU9hYQjjIreibzPEVvRN5niK3pm8zxFa93nnvqM+6X0XUeMctY 4pSIwKTbb9a17vPPfWvd557617vPPfTGKymNma466k4w9Ja1VrX4GBRlNtqeV+asQfIlsNJPLWOu uNuIyKI2Vul/nnvrdL/PPfW6X+ee+t0v8899LcW556r6WnnGDdtVqWtTisyzc6UyXko1QUculuW+ 0nIhZApEyQ2MqFkCt8JXSGt8JXSGly33LZ1k2rfCV0hrfCV0hrfCV0hpxxbqsyzc6G33WfRqIpOL TE/n/Sl4rMcFiuiSTc0264yczZtQxeaBbP4Cnpb8j0q76EynkI1aVG3BMp5SNUVHL7NKHFNKzoNj Tr7j5u4q+hqS8wLNqtQcWF6y+2nXnHzdxV9KpT6katSzat1PZNVmOX2aUzJCE5ErNqRNkoTlSs2r fCV0hrfCV0hrd8rpDojenR2isd9VHb9eGxh8mT5idlQ8EaZOd7yj4VKmMw03WfhWHSES5inX7X5P 9VJEQkbpt8ay4X/Z4Vlwv+zwrLhf9nhU4Yfudeqy5uq3BaYde9Gm9bgldGe6nWXGTZxNtKUKWcqR c1vbLtfVmlJUg5VCx0ttrdVlQLmiCDY0hpbgJQL24DjLjPpE2pKSs5U8dKSpByqG3S3EfdTmQgkU qHIQLqbPdwSw6lAcKfJ0pSVnKnjrcEroz3VuCV0Z7qUkoOVXHpLLiUBwjYeA0w6+bNpvS8PlNi6m zwEMuOJK0JuBoLSwjWEbNMb06O0Vjvqvx0AE8VIhSXPNbNN4JLX5wtTWAIG15fdSG8Ohey/eadxy K35nlU/jkhzY35NKUpZzKNzUH1pvtFftB6RHZ/Rwa5Q/l47fWtTO5qvGndYFZXb369I/l8AON+ev l6q1q82bNtpX8ww8vL89HLpwX1xPxqR6Zfaawz0Mn/j9eBLLUpzcTuw2uk9dRmVsTkNrG0EViPrb nbpUpScJQUnl+tNTpDKsyVmsVaQttuWgWzcemMwZLyWhy1rm5pdgDiA8n4UpJSSk6ASNorDnXDLb BUeOsSdcTLcAUaJJ2nTL/DGPv26W0axYQOWsUdMXLDY2JA29dMyXY6s7aqxZpBDcpAtn04W/uaI6 7a9iKxCIlNpMf0avCnfwtv8A5fXSCUm4pWMOuIyPICqGJ5fNZR3Vv3JHmgD4UcYmH83gKViMtfG4 aU64vzlX4MH1pvtFftB6RHZ/Rwg2bfI9n1rdL/PPfSlFRuo6R/MMPDTfno5OqtU5my5dtK/l+Hll fnr5NOEuJalpKqmx3GX1Zhy1BSWIj7rmwEWHAxkkSwR7BURaMTyLVsdRb4isR9bc7dKkqXhKAkX2 /WmoUh5WVKDWKPICG4rZvk49OHlMKOqY4OPYKZmxWHA4hk3H91YuyA4JDfmr04b62321ifrjnAl/ hjH37dLa9WsLHJWKNGVlmMbUkbeqmYzshWRtNYs6gBuK2b5NMb8Of7RWHTEs3Ye2tqrEo+5YSGwb jN9f60P1lvtFY2brR/Rw8kIdt7PrwWlKQsFJtRJ1F6WorUSo34GELUuMCo3rGFqMnKTs4GJEl/b7 KgkpkJIqYbyF6cOWoRk2NYm87sTmNuBKJ3MyNDqicPQD7frphm0hFqmm8hd+BIJ3E2OBhK1JkgA1 jC1IjnKbcBgncbo7NEhSjBbBP3t0f//EAC4RAAIBAgUDBAEEAgMAAAAAAAECAAMREBITMVEgITIi M0FSBCMwQmEUQ2KRof/aAAgBAgEBPwGE27xait2HS1RV3mqW8RP1DMr/AGhBG7TN/wA5c/b/AMnq 5P8A1P1Dt1ViQO0VHYXzTTf7REZT3MctqWBmm/2jCone8pPnEctqWBmm/wBppv8AaBWVTcxM7/M0 3+003+0HYd8KtQr2E0WPkZokbNEzKDnmd6hss0D8mHUpd7xHDi8qM2ewM03+003+0yNlteab/aDO Wy3mm/2jBlp7yi2Ze+Gq2a+FVsqynfL3lWoc1hKTZlwYsamUGab/AGjCpT73lN84jFi+UGab/aab /aIpXc4V727RQT4zLUmWpCrjuYoZ9otFVjMF3moz+AmmT5GCkg+P2vyNpSIyCZhg/u4VWAW0oLYX j+7M68zOvMbuplAgXvM68zOvONZTfMItcHeAg7Sue1pRFkwIv2lL0vaVPcmYTMMU93DeUfS2WVTl WFP080pG6yr6nCxjlF5RXNcmUjkexw/3YVmAW0oLZZtVmdeZnXnDUTmM6lT3lEgN3monM1E5lRs5 CrFUKLDBQp9bmGso2n+QeItcHeGoo+YKqmZ15mdeZnXmZ15gIO2P5G0SkrLczQWKoQWEqC9S00P7 ltN/Vg4vVtNBJoJCMqECUkD3vNBIKKg36DSUw0SO6xnLbyl4DGn3qXlX3JoLNBcU93Gp6Kl5W9TB RCt1yygbG0pety0rt/GLWRRaVGDG6xGzC8YXqWmh/cAFN7PgRerYzQSaCQC3bqU5TeCshgdTsYaa nvaBFHxLAyqmQ9uv8f5x/I2EpeAxf3cKiZxKT5TkaP2q3msnM1k5hdWBAlFwt7zWTmaycwEMLjBq oVrGaqcw1VHzKdPPcxGNI5WmonMqVvhZSp5e5lT3OlPdxrjteURma5wqDK8pDKl5T9b5jLCOmZbS g38Z/uwqJnEo1P4mE2q3M1k5msnM1k5mUcRlGUyiLtMo4mUcTKOI1JWi0Qpv0V2ubRF9DGUACDeZ V4mVeJlXiZV4gAG2JUNvALdhjlW97YlFO4hRTuJppxNNOIEUbCaacTTTiaacQADsMCoO80k4gpIP jAgHeaKcQIq7YFFJvbpyLe9sSL9jAoXbAqG3EsLWgULtjkUG9plW97YlFPe0KKfiaacTTTiaacYP 4mUPLraoq7x6xO0VC+0qLlSyxc38Z+p/c/U/ufqf3Ez5hfpLBd5qJzAwbbHaaiczfEkDfAkDfoBB 2m0vfEuo3MzqfnpzC9sdpqJzNROZvjcXt0Fgu8FRT89BIGFxe2L+JlDzxLqPmGukP5B+BCajwUGM Wgo3m0qeBn4+x/ZrbrL04LfGPuVLHYSwnt1LDY41/CL4iVfJehLqM4jEMhIlPwGI94worfEpEglD izZReWKWqdFQDIZTAyDoT3WxJsLykM3raFQ3YykT3U/GNVczgSm/8W3g909GiB3Bml/Zmgs0Ummg +JYDbpqeBn4+x/ZrbrMq8TbH26lzsZcT3KlxsMaoukRgVEfu6gdFHxjA0rj4Mp+AxHvGF1XcykD3 c/ONT1tkEKMRYmUT2yn4xqeBlLwHQnutiRcWlI5fQ0LBd5SB7sfnFvcWVEv6hvKbZnv+8/iZQ2P7 NTcdJ2lvVB0VQM0oj09FPaP4xPHGoBmlNR0L5HAe4cX8YniOhfM9FUemUQM3QfMYKPWcP//EAE8Q AAECAwEIDAoIBQQCAwEAAAECAwAEERIFEyAhMTRBkxAiNVFhcXORscHR4RQjMDIzQkRygYJDUmKS oaOywiRAU2N0BhWD8GCiNlTS8f/aAAgBAQAGPwL+R8fNMte+sCM9vnJpKoIQzMucNkDrjxdzHVcb ndHi7kLPzHsjcRf/ALdkbjH/ANuyMdyPxV2RjuQfvHsjcdf3j2RiuI6eInsj/wCPzJ5+yMX+nZv8 f/zG1/03NfFXdCkf7c2iyaFKlmsMTV6WxfU2r2vKPJzssy8hLTbllILYjOG9WIzhvViM4b1YjOG9 WIzhvViGpqaUFvKUoEgU0xImTWlF9K7VU1yUjOG9WIzhvViM4b1Yj0rSuNqAJuUaeTpLW1MXyVcq R5zasSk7El4G4lF8tWqprvRnDerEZw3qxGcN6sRnDerEZw3qxAHhDeX+mImptlQS8hsKBpxRnDer EZw3qxGcN6sRnDerEZw3qxGcN6sQiZmlBbpWoVAppwVS0okTU0nEo12iO2D/ABimQfVYFnvi0ROP 8NFGLX8YzTTRQjFdF/8A5Da6YlJSYDLyHXEtlVmisZ2L7NuhH1UjzlcQhSZBpMq3oUrbL7IIM3NP 19VFegRfAmca+1ZUIzxToHqPi1CWboI8EcORwY0HsgKSag6RsSrsmsIUtyyapripGcN6sRnDerEZ w3qxGcN6sRnDerEeDTTqVtXtSqBAETssw8hLTa6JBQIzhvViM4b1YjOG9WIzhvViM4b1YjOG9WIm 0TjiVpbQCmiaaYS3LupTLuNhSaoB44mpedWla0pC0UTTj6sAyki4lCW0C3VIO2iWl551CmHTYxIA x6MCX8FUEzDq8pFdqMsTBmnUql2UaEAbY5OvYmZtX0adqN86IzhvViHfCVAzTKqKpiqNBwGWZNxK EKatGqK46xnDerEZw3qxGcN6sRjcZXxtQkT0mlSdKmDQ8xgTEo6HGzzjj2ES8o6lDZZC6FAOOpjO G9WIzhvViM4b1YjOG9WIzhvViJJhx9BbceQhQvYyE4L06Gr8UFO0JplNI3NRrj2RLzqmw0Xa7QGt KGnkT4TMpvg+iRtl80FMhKJbH9R7GeaLLbky+P7W0QObFFqdmkMcCNuqE223JlQ0ur6hFluQl0jk wYo20hHuppsePmGmffWBG2ug2rk6q6INkTDnEjvirNyZx0aCIF4/03Mmulw06o2lwG0+/MCM0ue1 7yj2xjm5GWH2U2uqFJnbvqvZ9VpNIS65anHRkvvmj4eUulyxieL8u08Q4KFxAOiMwltUmMwltUmM wltUmMwltUmL2y2hpH1UCgi5fG5+2JNt1CXEG1VKxUZDGYS2qTGYS2qEKt3PZBOlAsn8IE3KqUuU UqyUqyoPZEvNIVQBVFjfTp2Lm/P1RJtutpdQbdUrFR5pjMJbVJjMJbVJjMJbVJjMJbVJjMJbVJi6 PJ9Y2G/4GW80fRCMwltUmMwltUmMwltUmMwltUmLDLaGkfVQKDAmnmzZdIvaDwmGmG8bjqgkcZhA baSt/wBZ9Q2xPVsnwiVZer9dAhicl0rlnGnA5ZQqqTTghyadxnIhH1lb0LmZlZcdV+HAIRN3VSSp WNMtve92RYZaQ0j6qBTYImZdNv8AqoxLHxgIWb5Lr9G7v8HHCLnza6ybhohSvoz2bEjyx/TFz23E BaFOiqVCoMZhLapMZhLapMZhLapMZhLapMW2ZVlpf1kIAMFbkmwtasqlNgkxmEtqkxmEtqkxNoab S0gWdqgUGSLpX9ht6yG6XxINMsZhLapMZhLapMEsS7TJOW9oArEvNAY2HKHiP/REk6fMUq9q4lYt lbizRCBaJ4ImJlfnOrK4Q4jEtBChDEyjzXUBeypkHaSyQ38cphLyhRcyoufDINiXuahWJPjXeqL7 YN6tWbeiu9DNo0Zf8Sv45PxwJbkOuFIeaQ8i8KNlaajRGYS2qTGYS2qEEKkG0E+s1tTCChZdlHfM Uco4DEukHxMwoNOJ48h2G/8AHT0qiYS+yh5IYrRxNdIjMJbVJjMJbVJjMJbVJjMJbVJgKTJS6VJN QQ0MWDdKUVNOqlg8Reira7CWWJ19ppORCF0AjdKZ1hjdKZ1pjdKa1pjdKa1pjdKa1pjdKa1xjdKb 1yoobozRHLKi0y3ZZrjfdxJ74CpkeHPf3PM5oCG0BCBkSkUGxUmg3zCk+EeEuD1WBa/HJF7kJJLZ OQr26uaKuOPS7R+uq9DmGOLU9dCp3mk9ZjbMrmD/AHVxViRl2zvhsVigxfyV0uWMT/Kp6MK5fG5+ 2JH5v0nAnLemyBx1gJGMk0EIBygRc35+qJL5/wBJwro8n1jYb90eRWpP0TiXDxZOuJWapavLiV04 jCJiXcDrS8YUMHwRJ8VKizT7WmA46m0xLC+Eb50YL8qobcirZ3laIKTiIyxLuLNp1vxSzwjuiR5Y /pi5vLDyM58vRF1OJv8AdgTkrpcbNOPRG8oRKTWUuNgnj07DjYPjJk3ocWmGWXE2mEgrc4omJZfn NLKIXKqNVyy6D3Tj7dh6Yc8xpBWfhG+9Mu/iTDTDYohtIQPhDjzhstoFpR4ImJteV1dabw0CPArH 8UpPhH/Jl7o3iIlpg+kpYc94bMtyHXCuQV0jAlk+sZgU+6YkEJyl9HTsN/46elUTP+P+4eSuhdZS 2fBlO2rIUbWM8Ww1OMOS6WnK0C1GuWm9HppT76uyPTSn31dkemlPvq7I9NKffV2R6eU+8rsgPTUz LbY0ShCjaV+EJbbSXHFGgSnKYTM3Vo4vKJYZB72/ASkBKRkA2KnEIUzJDw18etXaD46YKQXHm9IG 1aTAXdF8vq/pNYk88UlJVtj3U4/5e6XLGJ1M1NNsKU4CAtVK4o3Rl/vxujL/AH43Rl/vxepecaec pWyhVTsXL43P2xI/N+k7JXMzDbKftqhEtK1Em2a2j65hudeRSSYVaqfXVvDYub8/VEtNTK7DKLVT SvqmM7VqldkZ2rVK7IztWqV2RnatUrshT0m4XG0qsklJGOLo8n1jYQDNKqAPoldkZ2rVK7IztWqV 2RnatUrsgS0o+XHiCaFsjBcYdTbbcTZUOCFKsl2SJ2jw6DFuTmFNVypypPwgJn5MK+2wafgYATN3 lZ9V8WYCkKCknIQdiceVlW6o/jE2/pW9Z5h34V0WxkvxVz4+uLose4vpESXLH9MSDrqw22h0FSlZ BG6Mv9+N0Zf78boy/wB+N0Zf78BQNQcYOBOfL0RdTib/AHYM6yBRFu2jiOOHpUnbMOVHEe+uw3KJ O1lkY/ePdSJmeUMbyrCeId/RCJoDaTKP/YYuyEsk7SZTe/jlGwWQaLmVhv4ZTAeI2ksm+fHINhMk hXjZo4/cGWGEKFWWvGucQ2HwkUZe8aj498PSCzREwLSPeHd0bMtyHXCuQV0jZK5qZba4CcZ+EAtg olGcTaTlPCYTdaYRYaR6EH1j9bYb/wAdPSqH3pxwttqZsghJOOojO1apXZGdq1SuyM7VqldkZ2rV K7ITMyq7bKshpTBnfk/UNiR+f9RwVuuGy2gFSjvCFzCqhvzWm/qpgTcygGedGrG9gf7bcy2ZYmxR vK8eyEvXVN+c/oIO1HGdMJbZQlttORKRQDY/iJtln31gRunLawRaYeQ8nfQqv8rdLljDrkperLZs m+KpHs2s7o9m1ndHs2s7oE1M3m9XtSdoup2Ll8bn7YSZcuB7QWq2vwj010PvLjG7dA/FcG+Wrem3 ljwqYfU+ttVFSwxAb1d+EttpCEJFAlIxDYub8/VDUk2tLa3K7ZWTEKxnsvzKjPZfmVGey/MqM9l+ ZUOy7zqHVKct1RxRdHk+sbAV4bL4xXIqM9l+ZUZ7L8yoz2X5lQmbdmWXEBBTZQDXHhFK0haTlBGI wVy9qRc/t4080Ey5am0/ZNk/jFmalnWD/cTSLUpMuM8AOI/CEyt0Uhh9WJLyfMUeHeh0fbPTDg3p hXQMK6PvD9Ii6PuI6TElyx/TDMqzS+uqsptHFHs2s7o9m1ndHs2s7o9m1ndDSFZUoAOBOfL0RdTi b/dgyU6BiWktKPFjEXknazKCj45RC3FmiEC0TExM0qt9wqA6IlJUfRtgHj0wp0Dxksq+fDTDMw35 7SwsfCGn0eY4gLHxhuUSdrLIx+8cfZDk0obaZXi90f8ATsPuJNWW/FN8QhU4oeMmji90ZOvY8KQK uyhtfLphiZb89pYWIZmWvRupCxsS3IdcVlFOpdplZrWnwj010PvLiinJ9Q4SuMeXhhm6Djnhq9LR xJQreI0xQYhsN/46elUOS7LqGlIRbquM9l+ZUZ7L8yoz2X5lRnsvzKhqTdWlxaCTaRky7HpHtUY9 I9qjHpHtUYmZSXW6XV0pabpp2JaUmFuB5Fqtluukx6R7VGPSPaox6R7VGPSPaow7KyK3C66QFVRZ 2umGrYq2wL8Rv0yfjgTbTRo6tpSU8dInROuIlp8Ks+PNmid6KKnUuq3mdvBTIyXzvnqEEPTi0tn6 NrapipNTsBxh1bLg9ZBoYDN1fGt//YSNsOMaYzlWrMKNzH7c3UUC2zSmmGfCFMhi0LZDWiM5VqzG cq1ZjOVasxnKtWYzlWrMZyrVmM5VqzGcq1ZjOVasxnKtWYBGQ4V0uWMT/Kp6MK5fG5+2JH5v0nZV dWVT4xI8egesPrQiaYx6Fo0LTvQ1NS6rTbgrxcGxc35+qJL5/wBJwro8n1jYb90eVKHEJcQfVUKi Fu3PT4JM5bA8xXZCkqFlSTQjYnpMnHUOpH4HqwSpRoBjJibmdDrqlDirE1Mkelcsj4f/ANiS5Y/p i5vLDyM58vRF1OJv92DM0FVs+OHwy/hDEyjzmlhcKLSsc5RCCN44z+ESySKtteOV8O+mw6yvzXEl B+MPS7nntLKD8IKXDTwMlKvdyw89lcmHcQ4ziiWlU5GkBMPuJNHnPFN8Z2G2W3GUttpCUi9jJHpW dWIW0txkoWkpIvYybD1z1nbMG2j3T39OxLch1wrkFdI2VXUlU+IcPjUj1Fb/ABGLeNUq5idb6+OE PNLDjaxaSoaRsN/46elUTP8Aj/uH8le3VBKZhF7Cjv6MG/PIU2/pcaNCeOM5mecdkbbwh73nOyBZ kG1Hfc23TGZS+qTFl2SaB+s2LB/CA+yovSSjS0cqDvHywhv3RhXS5YxP8qnowrl8bn7Ykfm/Sdmh xiPCGE/wL52v2D9WL26ayLx24+qfrQFJIUlQqCNMXN+fqiS+f9Jwro8n1jYb90eXn1oNUF9ZB+aP 92RVSA6UKG8N/nhmbSKhOJad9OmG5hhYcaWKpUMBUkyv+LmBQ09RGkw1LsptuuKspES8mjGGk0J3 zpMSPLH9MXN5YeRnPl6IupxN/uwVtrFULBSRwRMSysrSyiLmSqq0lGyjjNeykTM8oY3lWE8Q79m/ pFETKLfzZD1RdCXR5s21ezwY+yvPDBIq2x45XwyfjsIk0GrcqMfvnLEzPzLKXUeibCxUcJjMZbVC MxltUIzGW1QiWn5ZlLSPROJbTQcBiWmSfF1sOe6diW5DrhXIK6RsradSFtrFlSTpgt4zLL2zK+De 44Fz5tX8I4doo/Rq7Nhv/HT0qiZ/x/3D+TS0+lM62nELZovnjbyDwP2VAx4xmYa+UGKSkyFuZS2r Ermw3pZ5Npt1NkiHWjjLainm8qIb90YV0uWMT/Kp6MK5fG5+2JH5v0nAdlZhNppwUPBww5KvDJjS vQpO/CLlTi/FnEws6D9WLm/P1QzO3q/Xuu0rStRSNzPzu6NzPzu6NzPzu6NzPzu6NzPzu6JudvV5 vjfmVrTbbCU/7bkFPTd0bmfnd0bmfnd0bmfnd0bmfnd0Pt+C+D3pIVW3argSq21qbWJgUUk0OQwE rcRNoH9ZOPngeEyLjZ321WoxreRxtRiceX7rULl7nsmXSoUU6vzvhvQliWRi9dw+agcMN3PSm2wl FghXrb8LmJNKn5HLixqb44N4UFsHzmXPNPZH8Sy9Lr4BbEYnXVcAaMFFzpa9H+q9jPwEGyHJuadN TpJjwiYo5PLGUZGxvDYkeWP6Yubyw8jOfL0RdTib/dhX4DazKAv45DAAymJSU/pooePTs+EAbeWX a+BxHYmp1QxvKsJ4hExNryNIrxnQIKj4x95fOomJaTT9GnGd86cCZlD9IjaneOiFIWKKSaEQ1bNX pfxS/hkPNEtyHXCuQV0jAXKu4jlQv6qt+HZaYRYdbNCIFzZtf8SgeKWfXG9xw3/jp6VQ7MXjwi23 Ys2rOmNzPzu6NzPzu6NzPzu6NzPzu6NzPzu6NzPzu6NzJXViNzJXViNzJXViJ55mQYadQiqVpRQj HsS70xIsPOkqqtaKnLG5krqxG5krqxG5krqxG5krqxG5krqxG5krqxFqXSZF3fa83mg3i9TaN9Kr J5jASu50zU7zZMf7hPJvb5TZba+qN84alqNEpFTEw9occUrnOwmYZk22pjxVVjLwxJtuJtIW6kEH SKxuaxzRuaxzRuaxzRuaxzRuaxzRuaxzRuaxzRuaxzRuaxzRuaxzRQZMJ6aev99dVaVZcxQ63KW7 LhtG2quEyJu+eKrZvaqZYbm2L9fW8lpdRgtpm0Kq2dqtBoY9p1vdEsibW+54OKJVbxnjj2jW90e0 a3uj2jW90e0a3uj2jW90e0a3ug3JF88FIp522y1yx7Rre6PaNb3R7RrO6PaNb3R7RrO6PaNb3Q65 KX204LJtqrgXqYZQ+39VYqIzW8HfZWRBvU683vBSQYxXTT8We+NtdNNOBnvi1MOOzfATZH4QGZZl DLQ9VA2VLVL3h0/SMmzHiLokco1XrjHdJPwZ74rMPvTP2fNEXuUl0MJ02Rl2W2pu3ZbVaFhVIZmm b/fWlWk2nMXkXJuYv19XlsroIeMpfPG0tW1VyYTPhYX4qtkoVSGn0h5Sm1BYCnMWA7LvC006myoR 7Rre6GpSXBDTYxVjwaZU4GrVqjaqVhqaaDynGjaTbXUVwnZp0PJcdNpVhdBWHVSinvGiigtdRCH5 q+20psiwukeEyt9vlko266imCh2aQsOpFLTaqVHDCHWlzTbiDVKku4weaEzE0Xi4EBG1XTFHtGt7 o9o1vdHtGt7o9o1vdHtGt7o9o1ndHtGs7sC6PJ9exLe8vp/kV3Mll1mHcTpHqJ3vjsScsBUKcFri ymHuUR0xIcujp/8AN7pcl17DHvr6fLl2ZeQw2PWWaQqXuVVtOQzKsvywVKJUo5SdhV0plFlx0WWk nQnf+MT9zXFpMqh8gAIx4jixw282aLbUFJ449M1qhHpmtUI9M1qhHpmtUI9M1qhHpmtUI9M1qhHp mtUIfYnHEKbSzbFlFMdR/wCXXS5LYa5RfT5Uh+bQVj6NvbKgoudLBn+69jPNF9m31vr31nJsJaYb U64rIlAqYRN3UAW6MaZfQn3t/Yn7oOsWZRb5IXaGk4oQ02LTizZSOGMz/NT2xmf5qe2Mz/NT2xmf 5qe2Mz/NT2xmf5qe2Mz/ADU9sZn+anth96cl702pmyDbBx1HklJLj1Umh8VHpHtVHpHtVDUs0t0u uqspq3pw7U5Moa3k5VH4RRmXmHvgExR6XmGeGgVFqTmUPb6R5w+GG21NqWFrTaFlFcUNTLNS06m0 mo2f9vaU4Zm0pNCjFiy9GGli/LSpSrNVooNlU1MlQaSQDZFYMxKFRbCrO2TTHhNKnFLAcJCbKax6 R7VR6Z0f8RgBqebCj6rm0P4+RSxNOKDpTaohNcUCZlV22iaYxQg4RmpkqDQIG1FY9I9qo9I9qo9I 9qo9I9qoTNSxUWiSNsKZMJtqbUsLWm0LKKw1NM1LTotJqKYZUtQSkYyScQgpS6uaUP6CajnjHJP2 d+ogIv5llnQ+LP45IqMYwnX3a3ttNpVN6ESzLyg6vzb4mzXZbcmyoJcNkWU1hqaYJLTgqmophXS5 I7COVX5G0tQQnfUaQbU6l1Q9VnbwUyEnT+4+eoQQ/OLsH6NG1T+Gz/Cyjr32gnFzwF3RmA0P6TOM 88XuTYS1vq9Y8Z2XuUR0xIcujp/k5dp1AcbVMEFKshyxudL6sRudL6sQlxuRYQ4k1CgjGMIupoqZ c2rSTv78Oz10HVqlwrbr0uK3oCJeUaaA3k4+eCiYlGnAdJTj54ZnZB1YYUdovSg/VMJexJfRtXUD QcKS5D90XM5EbI5d7oVhHiiYvKC5ewpxVNCRphNy5xfj0jxKz643uPYf99HTDnLnoGFc7lF9Aht1 +UZecLi9stFTljbXOY+CaQp25dWXhjvKjVKuyEyU4pRkyqwUrytHDcecNlttJUo8EXQmmk1KUqep vJGRMO3PcNETG2R7w7ujCLT7SXm/qrFRG50vqxDK5eVaYXfgLSE00GJlczKtPqD1AVprojc6X1Yi 9S7SWW8tlAoMKS5Hri5vIjDFz5IkytuwhCfpDvmEqeaTNzVNs44KgcQiwWWynesikLdkW0ys4MYC MSV8FITcudUfB1qsIt5Wlb3FhXQ5BXRC5htKrDJFpafV3ovEwqk8yNt9sfW2JHlj0Rc/3D0nCuly J2Byy8Cr0yy0PtrAg2roNqI0I20eLbmH+JFOmP4a56U8Lq69EYpkS43mUUiszMOvn+4smNqCeKPE yEwrhsUH4wLaWZcf3F9kAzc8pf2WU0/GApuTS4seu9t4oAAN4YL3KI6YkOXR0/ybMy+qy02+So88 Z0dWYzo6sw4qTcvgbNFbWmEyxXatMjFwn/oi54HrN3w/HHsz1r1AFjjBiZl8dl1mvxB78KS5D90X N5BOyOXe6FYR4odBxi9OdIgT8lVMotdRZ+iVFhwhM80PGJ+t9oQ/76OmHOXPQMK53KL6BDfKL6dl +wKB1KXDxxc91fnKZTXCRIIV42ZNVe4I8IcT46b2/wAuiCtjaJtCYZPxiXm2/NdTXiOkYbHLjoMT XL9XkJLkeuLm8iMK6DqPODJA+OKAsit6aUoceTrwJso2tujopwjtiVeV5zjSVHmwbocgroi6rLyA 40tCUqSdIxw2/LLN7raYd/aYTMN7VwYnG/qqiR5Y9EXP9w9Jwn5V2th1JSaQfBwica0FKqHmMGUl rmEt2iqq269cYmC3wBtEG048K6A8lMG+qV/yTNeuMa5VPGs9kbedYTxAmPG3S+413x46cfc90BMb Zl13hW6eqAUXOYqNKk1jxLDbXuIA8k9yiOmJDl0dP8mww+gONLmCFJOnLG5rPNG5rPNCxJy6JcLx qsacJl+m1dZGPhH/AERc8p9Vu9n4YtmeteuAgcZMTMxjstM2a8JPdhSXIfui5vIjZHLPdCsI8UOc k50iHJd9AW04KKTCHGVGzW005oWneMOTLBpt0BaNKDXJDnLnoGFc7lF9AhvlV9Oy+GzavaUt/GJO WPnNtJScEkmgGUwuadClSoWEhKctgQEpue8EjEBaEMWJRxl9pWJaiMmkQ/cxw/3WusYbHLjoMTXL 9XkJLkeuLm8iMK6DSPOLRI+GOAhRpfmlJHHl6sCbCNtYo0KcA7YlWVec20lJ5sG6HIK6Iul7qOuH JR8YlZFaUnfhSVioGJadDqN8Rcyal122nHCQfhFz/cPSf5x7lEdMSHLo6f5OU/yT1+RvSSEzDe2a Ud/eh6Rug0sMFW2TpbO/Acl5tlxPAuC5MTjLY97GfhDMlIMrLCTtEaVn6xgM1Cn1m26saThMzrCb a5attIy2T2Q3c6ecDCm8Tbi/NI6oqmYaI3wsQ4Q+29NU2jKDU14Yduo6k3pKSlKj6yjhHihzknOk bC5V3EcqHPqKiaue9VupFtGhVMhhzlz0DCudyi+gQ21MTrDDl8XtXFgHLFTdKWpwLrCmrlgvvKxB 5QolPbCbqXSSpKAq+IQ55zit84SmUGj814scA0n/ALvw5PuoquYxIqMiBHo080FKm0lJFCKRtK0Y ctI+0g90NPtG024kKSeDCY5cdBia5fq8hJcj1xc3kRhi6EkD4LbtoWn6M7xhKX3Eyc3pbcNAeIxW /tU98QtqRcTNTZFAUY0I4awi6k6kiXQq2m3ldVv8WFdDkFdEXS91HXsbWiZxrG0vqMKkHipCW3Kl pXqqyRc/3D0n+cdByXxHTEltfpk6eH+TllhO2v508fklmalkPKQnaqOUfGKIFBAS4morAEpLIZtD GRlPx8g28xLJaW5UqsYq/DYQmZYDybNaEmEobSEITiCUjEMIwtSU0N7Xp4dmUeW2C7aKLWmlIWEC gvxwpG2K7dXRHmfiYCXGbQ94wlyXkm0ufXO2P44bYcqoJZFBXJjMMNtpsoSgAD4bMk4pFV2VJrXR DCcdEqUBU6K4TIWKi/DoMTIQKC+9XkJUrTXxW/wxIJTiAaGGUrSFJOIg6YSZaXSzaTUhJNNh15+V Q64gizbx0+EYsWFOg5C0qJ6wmlQnTx7LLt6FtxvbEHLjiSSnEAnr2f/EACoQAQABAgMIAgMBAQEA AAAAAAERACExQVEQIGFxgZGh8LHBMNHx4UBQ/9oACAEBAAE/If8Agmj2wkwp2mnwQvegqKn4QT3l SCByQPhV9zb4o/taBZXNomWAoZ0cqR+upefM1wnkq4Ip6aE31DESvYo3JLUzzB/FdpCZkBDnvZhh 55kxDGIIlilhoI08HHm7icebUp9C+qzDRT22SmVs8Y+J94bLfTtc4sx57yeeYYaagQVrSMcgZydd 9MMPMNNpp8YggWN1tqSLjRTFwK0uESPJPtRcaeP+KGgjmQaSXmgeBaZ0oY1ibMeNkf66pNMysLrh 9bR5pApmkfBTDA7vzUUZjHwC97+aPnbLlcc/hR4DSJImxSP1KcrnvJx5h5gLuREkRcpyt2JCDPfz DTTDDL6nHFUOFGrs4xlBL7ek1hJWzGDnuJRdmVV/AlL1NgFmbnuG7+gUAyPFKKmSSYTNyNiPOVUc ew7xsTvwdSSbwdzpuRibRYwz3Eww8DDhfVYdT9UMDzVhwjkugydikqSmQZ8jeTDzDDOtYAkI7oYg ljYcUcdli7lbBScXTZNTuzXWNGdGHWK0qgviW81N3W53BgOtJ33iXmsU0X2Uw9gr2NuxKjwdC+Gy TshKfOtWtVy+qaWDZgmD3oVJGBEew1JhGBJ709wRzKL8G4Ck7Kj2abOguY147SUUV/UZNT95oIPx Oyh130ENElerfVerfVejfVe7fVGAtUKXQr3WlGltBE4TXo31SpHr8qGBGLY5NMR2xXYXzVMCCyTt j0oCS4141BUqgqcJr1b6r3b6r3b6r0b6oD0vFEAWAVNKZZzNPlXo31Xq31Xo31Xu31RY7VBzPA3I frAblmTkS9KOC+vNIoa7LW5qNHAqKihCMQqHvjUZd6QlMSw6VZTsfdsPWVMDHocgyKNWg5gGTxf1 QAywGfFRUk1wAZrDHrVyhUyDiaCrxECx8OrxRXutVAI6iBfEr0b6r2b6r0b6r2b6q39os1zCmGdL McWK9G+q9G+qs1qFC3Irj5YqZxNerfVerfVBfWEiOMFX05sGB/soSGPTDVNs+SdECWlyVdOUtjtS rSJMkZKa8TEcTDbfSORr/bHSl9QMvKeuzQGI1wPaXqV21LJm7WK4lSYErukNzx3zqzSCU03Q16t9 ULD7/Cr+hLhdqn7DHumPG450pW+Szg6D97XzHMAhHGhr0b6r3b6r0b6r0b6oFzB1WoxuOFH2KMgD a3DZNDSYkMttuwnqH3Xqf3T7P817L916h908TCEb3mpXU/bGPRTXjxRAeH7zRuNiAOmxaY7qQFT5 WbjnpnTayxi3RB80YaKWJ9ElGm5059+FXaNRLpzgilADI+cRNQogZFqj83TY7tKemzpXutKeRuD/ ABMrFGrDAZtPhIj2rxqPB3n4Kpr1Gn4RdWOnMqGlErruUJqpXw6PDb02Jk8sLuvg6UUyS2Etve/T c6UAh1NPF9daBmXA0av42rFwXrCvVaq9Jxo5V0rpXSum54Xx17DXcWKkqZlv5BXHtzyShGex3HlO yy0Hyn2I61Ei5ZILHVSjqhdxhxq9iIPJedi0hyAE0ZCcr9WNE8HJoIoYbacgS1irY9B0CKP5K7IH ak2cu5I0TKTE0sPfHrt8d890aZSDAzgl+SsGTDt2vvLbh03WlPoCwSC1meuyyFFe1XQtN7jx4kUq HFzlM4HJQb5HSmhSRcek89m4Yc6CiEAgDYaIASrRk7JEH9MO9Xm58v5fLWc3vDuJ8VG5akLm41H/ ACueyk7DFQU/j6/j6/j6v5dCwGez3WlPI2gezJkCeRnWFXOw4cxkGVPIthwsNQHHZ41Cbjx3CQLH F3Vy5cuyZyIIcHnXgqmiSwnl7hcuXCBi2mY3TdA0o3NENYJS1MGWi/NKsYvMVZonWCa9uNNCRCY+ +HmrxRJYetOFNhL9661BbyP991ocBBQYFZHIiPX9Fe21U46goC+Nfw9fx9fw9P8An6MEKBmbcq8L 469hruGruvCyw0d06VjHMOvsLgtpyx2jOkv3+6osfCVDivFLIS1y/pTrsyCwNP6Q61euX1f2L02W UoBMvsMHerjs4GQdWCsqedTw4VzpKoJ7hdrrtPHfPcGmzQzvKF2iUw56Y8ZpuQGPChHQGGu18vZU wZWXLdXLly5zjEVyhhs7s3M30mZ1McglauLSQzoHNxanENvefJx17VGxQVYCngw0XOP16tZvEPuR 0W50VVIO6DYFN7j/AHKGhTCGQmEfH/I57KWcDzWk6Nep09Tp6nTm0hBiLRs91pQR6xgHLFs1OgjR rttq5l3GaTd0RqYh4RVj3xAaBs8aixLDLCTJyr3b6r3b6r3b6r3b6p4iyaAQIvyrwVTQmhD0Fe7f Ve7fVe7fVfMkRibwZLiWDiVLBL5nr+kqCVYHhbPNc+hIetGr8l76wNZL7KyEM3jlSPYg+VCJiB3V onGnQkuUVHttVWMIsEuLXqdPU6ep09zpDdbbUA25V4Xx17DXdYUYAzVzovaoCN0r/QnWpAgqyAlp mIES92z4KEKHjGMrvNXLxFzy+LPSmIiAXNTTyyo8BNSwJYTbFeKSmGNck8tGxV884ltTqy0MJz5Z Wu5l22QN6CC67dtnpSYx0xcKT6eTKYbPHfOrqWEo1tUbNVqpiNKac1zZqUG+BhscQjjbhRgACAMt r6ShmKiSEW517t9V7t9V7t9V7t9UwnEDKZZ7oQQVjwegsXHpssktUF2L9d0IIYZmk0wJT3QHWnEn lEiwO4em5OmK4XIKCBwwQMQuc49KkQRiJXi3mhuIy993r/Dgitj1p0kGKsuxQgSLLtQvsEHZ15F6 9/8AqiFan41cKAEmNRO8X0r3v6r3/wCq97+q97+q9/8Aqvf/AKr3/wCq9/8Aqve/qhn3+1BeQSbr n+AlPutKeRUjnUVcXthg5OJnw5UuEC5eIVWQ+NVmuJs8ajwd5+Cqa9Bp+XHZgJOjRpgEY/pH0twp EyiMRMTZhDt1AMAaRgFXmWQmbrPEUN4DXNDfzT02qvScfwZV4Xx17DXdZADZn0TTqIOjgzVkKOMS k9Z1faN0yw0FEdPLkRQtRaCLqKlKmj0XtJ0qKi88aAfFQF3+ZoXerNWbfxc56EuzBNAWBBsaaU4r yIdmpPFupc6bDx3z2DY51HOnyx/xPZx50XuQ1xp4KJUdORM9r7y3/EN1PtATEdYjtu2OtA3WhHnj Q8XpMy+BEeBQAeZuvyoWAzT/ACpetYR3k0hw+Fwn7fzedXoNN1/ASn3WlPI2hwAhCOdThSWGGO8m n+VPQQeOfepRryJSBwSvGo8HefgqmvQafhQWnHeH0HGCSvQOQVzRjlwUp53G2D3MoyZs4Nwei8ld MTRcDrTtwg6tNr5A3UZr1WqvScaPweF8dew13RPGSzRDQIo+nOGz2qGA8nlHsHRrOUu9fy8bcCrW aP8AV1qaRs5xZvBS3WWT0xGzClSLZgewg71KmkPmxieh3r1v6r1v6r1v6pQ1sAHGI6narDHxg9rP SgBGRzrxXz3Bqr3gyByrGGqc9bgp+prx9vD12vvLfnI2kjJZoRnSMB8+o0Q1uDeYr0yPBqWJCCTO bHpvlwVdxz6Y076R3WUfX5fOr0Gm6/gpT7rSnkbgsJ4M1kOJUy5cI4IVjocn1nByrxqhb7mzivrX FU8VTxVPFU8VTEFy4MTHpTUpLFLkrxVPFU8VTxVJhviRGNDcTOImGklW7YRN2IaNJRcY8xUP1K+q 84h901LzcxdBbmpcDKy5hfWdCphjmDiectOUTgciMzj3oIdZuuIauJWVHSF0Eh8VJ0+KeakzFrQc m3ftQJP0xGq5HipkR1ufINXZ7rVXpONH4PC+OvYa7yYjWoZf0D1oU5SA1aBBc7OLv5LtiJwrPYwe mxYkC3f8vimHJhH0FgqayTYx/dNR4tss267ruQHywmTddwqc7zskYSov1dMPJDtXivnujTl0/fK/ bhX+oR8cGln67NzzcHk2PgdvGVWMzDpXFU8VTxVPFU8VTxm4hRBCigDRDBrOi1PgJDi++EEFBEEe 8whc39RT9B3PUnBaFowoDuU3mIlu2PEyjfngA2gXozZgM6I1jhjR8CAbcxQQmG+QSV/Qfuv6D91/ Qfuv6D91/Qfuv6D91/Qfuv6D91/QfuoP2P3RiEAgN64wFglwIqwhebQi1t6y6b4GmbcCsT/a8Iwj juuaIYPnEnShSIS4lEh4bXNF1F22/wA5znOXJlc4DoNd/nPc9yxwdnwM6bjRUvH81TCNf8Dc8Uvl OQPxUhteJWI4hJU7Bvdp81hiliGxJrE5tlF4mD2oRD6B8BWVfiVIxng8V/NIl/iuZxeu3WszsxGl WECvEuJH4cIi6MIwirzsni6Itxd464Yjb4jbhU865SRkkjcn/hMiR2cbm4LlZZVdZaDwCVxGE2qA SE4YYjegMlOOGIqzaEmowcMca04TrEzpS295yEZRw3cc4PuhZeKOgSKgzKSNjMRCumN38fOc5z1h PuwVnTn0r/wRUfgjS6V/q+Gx/CSGRZOw0QMsU/UaPyH4M/8Axc/+A3s//Iv9GCs6U/nrjFCGP9ol 22CGcGXNvTcQlUq7Hex63zfTA40ZOhhCoBAokmAyfhKbLLLLLLYgoBdllzdp+DPcy/8ABz3X8ZvZ /wDkeQ+SnGlPD/JJrWzKvcjDrQJBgdzDY6zWhDpPQYHTZixeVOhUWpD3b5OGHOgihOSF8mUmaiXn JiVYrgaXA0uBpcDS4GlwNLgaXA0jlJ3rlxZ4P4WpmyXmIxX95X95RmwEgS47Mt2UhSVegF2ncEcU D5oLIXAA7M1b0CURzVc377fXG6KXcA0TDw2h3iSSU8XVvSC5UfoYtFmLuVDOxwzBKlYLU6ljZsP7 vTbHLvCX5r+spWHi36qeLUCKeFCCRk/BcTS2OSaT8hhAxE3mVOWVKwWr+8r+8r+4r+8oAT1lSobb 19PrjExSOyEmRy3wmPYwcWnaFD8gg7VZR8/7Vh60Rz5eVGEEJEcd5sgphLDG1WZ2hQtJc9r3+y18 TUpaxMiYw6b3rtSnGnPD+Q/C9CMYjvUTyqleLeabBaJXtzrUqy+L7bRQe/1VqexsvlVY81BCPG5p d3C/UaP+Jo1V7SE4qNmmkS/WxNTeKBDL9S4H6q9MkPKXIP5QQoiTlzxNADyIIOQuVjoe/wB0E73p Oi2Wapwcd7zny/Fur5Ki5YDnF+iayuU/Bz8GWpy/EpUAGzISIFl69ZDlUSzvRWLdeKv/ANm3USaE 4lDJvTgwXIEtSStHwRcYwooFF9wLDrvC8qi3gYW2aPPjRpMKo3BDoI2vs0Pgqi8HG2953516TjvI ErAa1Hwt7P7WnCmNfEC0a0ccatAmJ+JFBvFC5tgOZSjPEAx1G0ZO/Uj9rKuLhcxqITgjhvv/AH8L NL3nCml0fo2TTAlsVxk1861G9SGXYoW9cA+VW/iZ8QVbNKjyZa4mo+RpaFdBNBCUJE+9AqaMicV7 BqYbtJTylNYZmkV5t4oIZ4BAbxfqNH/E0lA/SYJyUeu/Feu/VOfMRUVwx2Zbk+E4aFV8HZRNkzBm v9tsdLu9AVJiUjNoV+y3vOfL8XOvkqIwISOdAaGHxY8ctO1QhCAtD4HPR/GpUAfRSlHY4iH4rE67 sj63rTVkZJfuwdGocBE5xMv5etXiwlgF0dESlTtY+hDJ+A16XD+Dyvzr2nHecyEQYjM8104b1n2b XCraAtMQXwWk2lG4oXeqHYOciYKARn1hnxMnUqCnG+/6nJ/BzSVoPauTnV9dWaPj9E1BVFkBcbnB UoJch+anQeIF2GoFEcbJ7KvMIvigSW0/XU8YT6Y0sB9P3dABE9CFZCGSfmkW54/Un4y/UaP+JrAE umJof7r91/dfumyEAMRhsy3MDzDiUfDRmhYicF/p52z4ub1BUPZSxaFbst7znyp7fvJcn3jyWxhL +bMykuilnFfEnWpyhaupL8VQB1NXeyY0lzuxUht0NYvumGNKNgppzDXNgTm3etF50BGFGT8VQsyO MNHi0Wb20e/4DXpcP4PO/Ovacd4NpLAmXA8V1ZI1g+W1wq3ALXEB8ko5oBuIB3qvQ60zuUfJinjt j4zD5DRolWelwuifhpRUf8hfqNH/ABNeh1ofgaIbLtS4P6rDq++VmYn7pMK0BOY3OtFAJgl5Au0x Bdv6oR2vTvyODROBhvPBgA3Z3Ueak+uldswuYnO1AWO4gPmpdYhLZLMCiwBX45ORPfe81tYacvi+ Q/uluiGVqT4aP4CgASBRipss00eGm+xRjOkPEA3VRfzFqInKb8d4cuRt/wBNagxlx4wx6vwV/A0k 3SDccak8gm7brIrjQAREm+a9rh/B53517TjvCEJJVoZTM+eVpwqJbImFq1nljTOC1MHzSH3JSdWB 5FR5AoxM9BvObv1ex12INFFGevCfDToL6Uy/JSndndmp3hdmjRyCZrR+ad2E2HmevFRU7J3lZAbD lC9crUmfmpPGCJTPhUepE885Xd9vU9nikLqigCsVPKC3JOA0RXrIDQN7w2rQtJk5NpmREqYqLcau TJiVyKndH45HdMle391TTlwj+6xEvhR5Mo3poY7m0JSYUJw/8gFTsAOrChQiFubRhVG6MZF96EvN EpRODpt1ya7Jqd2XVGFxUAIQHffCY8HINEqUm15HKYKJJBjU+RQ0WamPFAQABAGydwh5CTpTrjXc +W1iBNcJiBY4UfkrBPFt/9oADAMBAAIAAwAAABDymDxjQTZ+JS8XzJH/AMU88H62g871T+73iW77 e8LWdMRk9kf76i/x7YK58D0/568c/OoY7+WsDZoEVO9itrZr4MMMcEMsFahv8cMy5Qq/sQU8Mbhy bs8ZWp5V0IrcaeDQLVDkHsWA3oASCS3ku5lM86jV9esO++++bw8FFrc62dWv2a+w2n84hAePb8kv 7nX8oL88TmFJqa3pJd+SAa2yA99Df1a0LgyukVVV999iAsRXss8Uhz8cs6Occ/IANvfGzJWp0c8I jUcxCsbxM5qzWMJECcMaEDlIkMlAMcEq35iaym/sEdlIAPYMtvCGBOOiHMssLe/P4wsIAEMMMAco gaZtcMtOMEeWq+bcIDsU8A887/HrYbxXn08c8YgN8s3d/McN+yEc4/8AgePGLQNKDGPPOgMLhJL/ ADzzjfxTxuTeiz0FC8+WPOsys3swwywQywxNUczyb0Lyw8fvTwldFsgxpksRgooYx7ki7QS2wxhD sCQyit1jitXBkF8IADyzGvDDDRDDjBELrDybSrzjXdhTyFN6eDCbb5CRvfnDSKDBwDnjDWSOhjD3 B+RxxwBzwCCDwAD36BzyCDwCCHwCACCGEAACKOAAH2IByAD6GCCED6ADx+CCCJxyCP8AgAACcjc/ /8QAKBEBAAECAwgDAQEBAAAAAAAAAREAITFBURBhcYGRodHxILHwweEw/9oACAEDAQE/EKJuUA4t igMoYxG93JdPjAL3mx1ceU0JfNCXntVn48g7XpzXx8FfXJfooEiBvX2iu5YKOcHN+prJ5L7SB2pp TBNjGN3xBcSVycynKmaNA6V6rwoQeYZIwhtYoBIjZCWFz5V6rwo8DAWiXQVjxoTOZUnEjE5SUhBF kJYXPlXqvCvVeFGVATBYpjBx60C75wAiI3b69V4V6rwqVKKhoabMd0gMJQlXcUpiGdieQfbQmGHJ 7P8AVAcyxhGLdait8wMSdAz3rbhTYdpk/kKndIRBPBLPBKS3xutTzqVdNRcJYnOvVeFeq8KC0yAW WZxwjdXqvCj6QhRBODON9eq8KzFDAQYs6YneiSQxAsCWfPOgVgoxwpsJkYzxpwUJao3yUOGh3SmE VQAgtZ7zSA8JIDBlE649KZkVloanJ7JsZ+yNiW+teq8KgibhaJ4Kx41cySlZxo7yljoFsS869V4V 6rwoVJC4RfpsJmSgS3iI30FcStiJv/Jr1x4r0R4ogjMAHir1JwAJeHnCkF9xi5uPSCpu1nu4uBzo CZ+Peb641Z/0Ju6tWlw08EUpIXez/wAf07ymvhS4OhXuHipQlvIr8bXYWcGWSzMTq4Utksp3LFuN u9LxlEBis0928V7t4p3QTDZLKtjN0CxyV7t4pSCMVUHba3EKqbxITj53Uu3DlzDZ5PKpoHvEoQNL j/getJFwB0l77G5hBOJR1LwOEBO50pAkqf1XuHivcPFYbMH9X2MVNCcS9ZIEPIeYqbjMcsO8VcfK Oo/aPCpcGS5495osVsh9OqjlRExd3divSWmTxZ0WH32op5RDg4OWLw2YvF97A6i6uW4NfFLzMIXe tzlbnSskMBdb17t4r3bxScISyOI179QIgMsrElKJIsBNop79Xv1S2CYEhgMuK3LfTZSu243FAaYF x0pCMRILIYyZb/otSNoOqXoT3Sg3B3AeaaxBlEcmT97qEASxKgOLFimQ56HqtXv3ivfvFe/eK9+8 VEX3CRJ67f07yrlgIkvgOtfh/qrZbAsRhULeg41hUUF5KSGqAyTGWQ5JGW8o+YDecZzmpdQicRRW 7dHit26PFJpKT1KdYsSw4WY8a3bo8Ue9CGxg7RRkoAELK7vj3qIAHP7Bud6JGILZEThxnDpQBmZ6 g7MascTqiPDTrFDOUtfh/qvw/wBUiVnswf1faZcXkFyk6UDmEhwuerbiUhmyTfe/W9BfMo5YO/3S MiE8rvdV4P4lfo61fxWqxkYZFT1JMQzZxGxn91muLcG52qTriw4N2gLnUpOtmBi6yxHTCeDQRTFT aQFOtbt0eK3bo8Us8orxfkkMBidNHk0lhdRPph7UsOM4t1LUMCGBp1qwpOL+UEIdRau2wX1HDnr8 8G1fp3ld0fTb+drsGTd2GprxMumdEb7EwyaN5nu4VBWQg3rCvx8lfj5KldA4jedy6UG5ouGNmKaV +Pkr8fJSyE5Wcb5TsCAbpK2Gjh9UlCOF/qaLTDNsDrfpSbQpDcM9FyoxqCOJo6Jl4hqcZtxJ1LUL iv4UvGuQFP3Ofq14GXOu3/r44P6vtTY2MnH/AAvSibiRjdMu42GhdlzD2RSq/YTfn3Y5UKOLCmhd c3s1vXVpT7KGVwbPTHlQ5eu4Yr7OZWLxfezMW2P6bzucqjRI3BmaP711ob5DBz31+Pkr8fJUX6fd e8eaIVGs1N9KCUcGMqe8ea94817x5o+G5Xd8e9PITiSbml8DX4CjFkcDPnNuE02kkKDEigTrg0Qg KwUz3V7t5r3bzXu3mvdvNQ0kMJV+9qxzbWYp8xMVx2w9riJtDj12jBDIbUNCMhte9e2r21R6QCS4 Jg17avbV7alTkzcdnblUoOCfEX2VMCG4DuA0qWVqclbmK/ITpViQaTboW2Nhr7Da+PX4zVoBdaDD ptKKDBMaCKZhLOxAsuMMVCCvmc5140Mcy12dsriIQtoMKBitIutG0mUbRNqBHDAGxXtq9tXvtn62 pXbfr5oxU1NjvjymgSw5ZPPO26sd7IYvLTfhV4ciLFmbEs+HGsQHK3DdNfg1/Br+DUTYK2JMmEX+ KKNHGCYr26hzm4SRtJqTIJa005T0madqDJIdop6ZF2mRQmNJNBlgwNX4Pg08JImgoSrAZtO3AxHE 2hHDMFKiwmsvHxYsLBizz2hQlWAza9ur26koQLI5O1kZhMWeD8JgnuJ66Vakbr/U/BYGIQkOOwIm bAxZdJ2/jalYPD9OxWDLWLDkndrCQ73xNXUu4R3Z+irsJGancl6VMEluIOrH00SiHdd6tu1O1Jit 2v1tSu/ff/EFyyYxmIRXraSlgylJ12vBy8Rc25HVnIrNW9LPWnBZWNSWb8nqb3b2H0r8DVrvv1tG JTy4DmFv2JvioF32X05V3ja7AZ4MZ0LWTJVHiNTThs3xM/Y67c6FfcZvIoPAEOLF0Y5TQMwjCbzY iJCUqAOpoSQHJdCkVJXb320mJEHVip0RDCynV78+FEUCb7PEzKsNiU3wM978NuHJINzA9mj7q5bN puPptpXftow8JcoETNRx1sx2rIz931CjgX+qw8nDwV9QmPqKxm4lfv4/rald2+/+LPIT+ae7eaTM Vzbu04kXibi3J6kZlZi3IZ6UZLDzqC2PI6u52qbAyTvS3e1FLgpGLIsiNDBiZaVEt1Pw7TEpkIT+ 1JPEp3D+4O5rvG1SCngTnQ9xREDitqhjBcYTEeZ4xltkmKjmF1Ry47mhiMyT/L1h3M88+pDxn4N3 n8Ph3W0mJEPRmoUxBC6jU/YbyiqFd1ji5VDQCFNYCO1+Mbf2NSlMiEclz89cSjhYSO5Edv8As4g/ TTSnJ+/+Iuon+fiUMhxGGsU3jHOnqJcVl+DIlvZ+6ZIQEE2OBtManSmz+09sN8ODSIWWdoYgXz3t SrkxJY6TRtcltDbLLYkCh/W0yFDNMpSz/D4Kc2Hz8EnAzILDxpGZbmMzT4CI2X7Gx1CDrsf/xAAo EQEAAgEDAgYDAQEBAAAAAAABABEhEDFhQfAgUXGRocGBsdEw4fH/2gAIAQIBAT8QgBWxEbc+HBrM N1sDeQ+Zfv8AAnQn8Eaf8Q6Ki/8AkfcR6SetfUNs+E2qswqd3rO9csl5Lxht9TvXBt4785bXuRyY bTvXO9cRb8Q20yp3rneuFAVujBvsA3HvX9gtFx2pJZlb75hwLEqCEvDad653rjW3b3neuLJ//J3r jjqOsTIyaKUuL2g2WRlpyw0qtZmmgj5tzRQgzO9cC3Dvzmbd4pQZneud64Ul2gZ90SrdONnEwLJU epMzDlgdqpwjzYZb/jE2CADY/wAdn1ggWcpBHJP2n1oqTljI+sQXfM+pxvecb3jFHkzKlbTje8Ea BqYSKrFmVVxwjrBB89ACo38sn7z6nKTlNf2v3ogEY1V3UtecSkdV/DK/jExnvsgv5JS6vH9iN1sf zR/bRRfLEZesUtfOcb3nG94Ilk4vvDgG0VKrE4vvOL7y/WO/1AUFoudZXl5TH5RTYRijUCWC7uvW cb3nG95xvecb3m6r12fWGLrZ6umCx81fUt3/AOytRs7zBEshWOqfU4PlnB8w9gAzjmcHywsDJz4M /Vekz5f7gYdMV6mzeawXR61PVnrzbT9r964P5/2J7lcJOEtX1+pkvfZNsesI540fUc2dqtlu/wD2 VAs7zoXSFnB8zg+YAB08SgekAy1FagnbKbMIkpIYOx8f0a/K8A/afWgU9ekfsCMsdE+p2hnaGKz0 Zk2rqdoZ2hnTBpTqCQXeURpg+4oDEGLpATfWMeozb9T68P7X71vPljeTf+aMydc+8Kx1zBftHZOC EgMypV6x/bTbNyUPt/yB0i52hnaGdoZwoWgNmEonScKcKcKZaq9Jmi/AJHpCUnSUgucT2nE9pxPa cT2myK1Io3ANFGq1uWqNgsWsFnFnFlpRmcWcWcWC0UabGuLQpcABRBaFzsXNo1pYGXhApy1A0WTF GtM9dLMGIRRrUoAucy1WsLi1oucWcWcXT4DP0+Pd0w+J8xqoYrq6/wDZyvxcvuZfcy+5j3yvz4d6 1OBMw71UFrM1QILNQbVEESyKAt/Buq4oLYAWbao0AwVQPCLQ51UFs4E4MEFmoyDk8BVuotR4CgLl 0uyZ1+Az9GihvN2EBtmMx708w+pvWJkMoAKCfBf8hXJ5/wAnMfEuL26uSBgqsQwaxufifEJ8n+eA dN9SbJFT4moEHy/kMpjpgak76Sq27v8AmCJZol4YZAjkSBWDXsfjUEXSZeRh1EMqvVyWMZ8p8z43 81QSmCLRG2/vTzbYF0+WG0ENorw/Bf8AIZ+t/JxPaACjVbIGK7xDBrDMEqR6Rm8hvwG2PnKg/kz4 mqBHy/kMuFoFarE3LH2D6RVbmr4nhHY/GtgusG+Bh1qOdU/ejeVRnR0/n+3wIAo/xA2+fhAoYDCo AAPATAgFg8BDGEUMFANXJSb2jwEH0IIHT+ai0MNAeAA3gBSkRmeAlugCB3jT/8QAJxABAAIBAwMF AQADAQAAAAAAAQARITFBUWFxgRCRocHwsdHh8SD/2gAIAQEAAT8QXEvMvWL6LFl5ly4uJekXMvWX FzKry9Ius3aG7rPgiFfeDjzT8waJofgw8kDN6rPc/ol5H+JU5YRyvTlU9gRS+htT9Vi0efmPiAuT 3G1f0gdcO6h8mOYzU0RUASk0ZQIFFWbPR1HFiNF1FzLl5l4i5gy8RcaQYsML9OzIUKLdZ0L9cT99 9TP+72n476n476jyIqJQaGhMc8w4FXZW1P0X1Pz31Px31O30B+RCphcDNqRq/VHTlp7DQvcYwFWz LgIAzppNmqVbH64n476n476n776n776lssjgU6QyxamSW2HCiC/i8T999T999T8d9T999T9d9THe o4kaGCDmXiXLqIr5QN7mB3wDhbKgxe8KdAH3KEM5RF8rQdkYB/JCodOetR7UHiJsH8EFckg6YQxU eXTOy4Z7sBukRhLDKd2TpXcxuS2pPYaeCNFlpK8tEvlS8EGiip2EUrI3Uaq/ut8kgkfHksiJhHmX rAhV6AABoyGZ+i+p+e+p+O+p+++p+K+omq7urNTdgAzu5SlFuVn476n776n6L6lX4vifvvqfvvqN allIBdWAii3qg0ay2D0BEZ17Ks3dqHmLLxFwQC1qSe4LpS1zcSziEGb0raHmDgxFwS5rfpgSVVNj vaK6aXa0ULoR4OZcd50xv6m/C+JQ/i9piYqELhMGiV1by5cWveHdYunIXowGI/ov5P331P331Hb4 RU+RKwyEh5zaVjYHeJvbHe4tyHD3LJcaY+gMm8tMUq2P1xP331Px31P331P331Ex7KhAIWYXPouN pedpcNN5RkhRVWWm0WcAdYRwI0tISBbz03izVpOyXFxpL0xFzOz4ghRmkEcWe5jrL5QVybkcGyWu pF+NtKNMIndC4dq2mLykG9cvmPCmiV4cB0R7wWON0s92fmFhfQMeATFY+I0VLoAc0DGwHWB8pDyz 4TiC6T7kOJuuBHMAO2AD9cJ7wAUnRRXcshD8mBxBGRcNW/qllf23elBrpKVhh1u1KvuptAIKA0Iu dpfaXmXjaLmD2l42i4294MWHSL9OxLcEM1VE1F8ekXN6lwhW9GDJbUALXLHJMIn4XYsEaQc8QrIF smGOxlgnrEFMOUZDal4xBcjQ3dyyUzMCDbmo4Qdo4YKx5HSfu8yugygdSwRpBzuQq/8ABQoXKgIK NiYJEYBgaBBFsZjHVK4zj9SxepApBQKjIoAWusvMvG0uOGoTFvOQoWYW1oIt7tsOH9pmZJvJdUY1 tzO75j1fM05vVfFynhg6bmQm22jVZFXvHgMMUOaumFXYLKnqwzm9GdAO7arFTcUfzRyrsDk4NN84 3wCd3zKgFenoBezFjpEwPo8mo8gs3MmNGlF3nTC3RsJokSi4ooSOrG1BgmE6MK/UqHDlgQoW87Gp QaeJ15+LARK41fTK1sCWwHcOrQAW5gobSG7CWrouuD0q5oUPHjyGwRWC6M1hOYtM27G+5JnY21eD +UXtUvEvG3vBXJ9oknsMvxsC6M2cFA6EYLqahkPISz5GrCpfBs8RcEWvaMOkNNah3sWOPEuEi3d0 1B5EOgZeNpT8gIbxX2VfUhj6dttewNyuIrycKqAL+xnwsGXFx5imJR4AUBlBLLc9fSLeEIlNfa9u RZ7VUYR1SM1RwgRAFLwIzlawKWjS3G+EbwcRxik1XnvQEGlL6/8AjqFysylfop1sBYRyJLekdHE3 0iyxFx9pE0mmkCdpnaas1w0UBotV7sWc/v6xX9vzFZa6YTLKTSkqj2SQBMiSTpOQ2b0hXoHrUrGM 6LGi0nf2QqkAQTYABNNoQqaQDlXBFZcNCm2mCvT1oWEEF45axU43QhKTEgNkjUuN3dtSMqFV1YnZ xgUUAenvPeGh4QNDwTJ094HSHabmLh2m+k20jrpF6TfSXjSPbxB6TbSLiDtNDiW/ToThf9kNsTdx LgekGOF6IkNDE8TxAwisKXnjezGh6gJGgPKQ6HI3IBn7vPpjGmke08TjEHXE49QLWzg3/jw00niH aHaX03m7ibaVPEFmmi1F7sVXoRWQ4NJBB4GHXXYDOxqGisiS8aTxLha2jshaHCle6sHp2gYFA3gn Nyij7wK23m+kO0WF8gcFGpXVW5ciI8lFrkGk8IxdVpF0gvVG9bnEk/u8Ro3S4uLyRcGmk20i4cbe rPZ4m+k8QyTkuAF9dGQRtaBwXfSS3qCoKAGjTHCXjSCWHYci9pdbkyyeXjgyNbL2uMMtxyw6hKb3 uPeTIt6zxR0AI6aRALS2FpQXu1R1YHWjBa38Dw6OkNYulAUfyYiQ8DSexAlQn52B2R4gHAQWe+PH zeWAqrgI0T8IwpvObLfYdseI6aerH5fSPaD0qMiCrlYDt8hEjRtNmfOPWxd8TxHbEWN9J4iNaym9 YFHMd510F1oWEXw59MAuIK4oIy99KmaNzRpLpCN+pSVJz4s5JQyqgY3Qj3xEt4AMrDzgLWuQ0OOG 7ogzhFxjABgOhN4lsSYAGVXYjD4fHmZfTGFdDVafjs8qY1gphpIk4tGPXScUnpxgrLlpuzlA6wGt YjzDXWZtzKb13lPMzes87ym9ZTzEb1lPM31lNax11gPMprWI1rDvLVlPyeCGenEQxQdS4Yoeb0Os 87B3QqGxZC+ZzolmSDg19pff2jptJzTqWugMN9s2V6LsiWjlVUMUHAIqD7vGAF6FVq4ChzP3eZH1 A96JKuAwQqhH1yZMiITvUCCkXAzL68BZe8NqFaCAYK/QmQmQKkEKsVTN+ZnmbuZTWs8zRQGu0HTD rL5KDYZ0OnpbiljtGxSLJ5O7lXwzSQpvxlyGmwYliAsp2vb8Uh2fARnRA0x0lSjW+IPQHChv6Kg1 WvZoIFeYVmZ5mb1iPMsbyu4AaCgAOgDxGMN8XgQn8TCc062oEZLYhX6nHmAtIMzD29CxCxHhGGms prWI2zt6s9m3mZvWU4zA1zLi26FUu4BscqEANky6643wy6kcGsuqOpWlOLkovr0lVQZxkzM6UIJv UkCZa8rUpevtVGQ9wdTNQzGVhgpf8CkdsE6ZrqnB0nPcCBVZgZ88MqH8JIRSterTiv8AzllO7Ost CRWUHV9g1xUDK52AHkebyIZ3jprv6oflvX2iy6M4B0V5sbEa4itIitdFABsAa3BhxtJiBzEW5s0u Vj00XWQOrQoqYWfWJkZE0oRa3/tNgRKTiU8xMMrMrWVThPaO8zLh9MmZUqaCtKEkdgZRuNGG6R3g 1XoQ5UDWxrLtGJc7MDZhKgmgLVaAi7YIKjShpwVFHQCr23M4wqTpTqgYviYGwMEupxgqrfFNpQN5 uge91C38NeOjkwbNZ5mkvMrPmVKzP8ysysRMxJWZWImYErETGsCDEW/ToQD7WqrgoLiiacXP6Lpj BGX9LHGHeB6ZGRM3AU3fgvTa5+/+47Y9Vx8LEVbkODu3B7xfRAtZaJoCzBhG6YLdxwnQGAlfyfu8 yVL0dWpYFyM8+nB9ODDHIJLmRS2qN2/eGphqc7wLAQOIQf6hT6Q4E4PvTCJADYCioGJWWViV6KPA eY1EwnRi2rqxY8rj+yCXFNul407Vx7osvOg7GIp02YuRotdLXvSrJCobrCFBG2d7Uw4lqHlAg+B1 ct/4/E3lSsxIMOY8IhichvyRmxM7tX8fRyP6EslusDRh2h66aaNL0Mmoci2WSniyBiViJl29Wezb zKzK0iR666jyLlp90M+zxQavb7LcQ5jMKFkV6DLeMANmheQwEHkhjc4LVwJ0TWhYu1FOniOsW1Fh BfWq8wfpWblH9lfIBLR4NLKr6ptFWHqCa+vy2zUqKxWg3YGSIiydE9/tJM/5YUrQ/wCgPCX1j20u Yow00p21HK1kdUm3RLHos16Mi0E26jY9RjpLSFxds0fUvpL20n7/AO4IRqVXhY+WVEnLe7j5UwLT UHAarCOEM+IOgGgBoSvTw3sQSlVVbsvj04Y5BxyGnIBHDABgBRwMqYf2e8y/s94/jv7C9Pffd2mj Cl58xVU7U+g04E/Ofcbf3e8/NfcPzH9hzIZB1DroHClj85Ygb8DINEt/Et/EW4Sjo4va1C9rlqJQ kGlQy0u2tkTIUu/FmAqd2Ut65PA57yH68rYuRVHcy0urtx6rll3pT2gaxLQOqJuj2UbYAOgdD6Vj ukm71TgdGYcftrFXpe8o3df/ANapevVqz6Vq2aeCBYtRNvQtWolkF/EvEVr/AFBixH7PBPyuUNsf E3cfE8fE8Qf1eiRO9CMD7Me/3YjePmkFBcNHIDutjuh4pPhWOyDBEC+CB2axOkufu8+mMaR9OIbx 3MNTPz+MNN/Qh2ly8svEuXhgtn+PR00hhgolOoJNCZ8yLu3N0HBi4NrB9LUhsiJFVbyu8VWGPWRF TnJF/wBl5lxX8R/BkaAWq8ALDPyLQITfSjxKTovyf2WezM5z+7xBppPHxPHxHXT4g1t8QcS8RW3b j1Z7NpeZbj/EWPsd24u4cfBj9yOttaC+QTzBQbQogJiqpBkSQWCgl7oeZoleRY81/DGEWXyItXDV 9mGPVGFVVZ0Fc/xDSQqUtInZFQbVTSgjF3HmVxagUBQep94Iob+7CTUCooNeAn6L7levDpoNeFmx m+0p0a9kNUd57dEvHqxOfi2P4ZSDs41GgNEc8LwSyCpulwPVU5LNyqdVCmWCXj/zIOu0ZeZfpvH1 ZvN9fVjpFFAWi6WQ6o3l3mX1l9Y5uGK2EwNAITkYYupojcBx1O4vzL5lKOTN+6Qaa4BCMnKF6ul8 2O8r+Jlc2GEdjQ1SDV7S/TeX1ly+rL6svqy8ay86xerL6sftP7F+/bB6y8axcawYsOZ+zwRfq3Qd JeWX1g9YPWLe9ESDglxDIg7A6ibkU4ILk2jjUviyMwWSvaD5NB8gQXyGhVoMIiIz93n0xhxrF6y+ svTMHXMd54Gpir9+MHGsuDB6y+u8vLLxrLiAgOg3YMuXiXF0iMF9tSgeHXzNNRP3B5RbtjrGuPE1 p+/WToRhXw2Js8JojkRGXBizbHBCShob7i2gSmf1TfgC1dgWE3NCVaqO6o4T+7xCxrL6y+svJmX1 g4l41i4c7erPZcvMvrF6wew2WNA9xZXWqNIc8lHzLqqplIga2M38kSszXF5lGNFDH8zSORGHS74o H9RpL3cO0ggAQbiZy99tDxhMCXQKOv8AD0g0QAdPJA+wOk90zUuuRWQFmJr1f3eebYk+uGpABcrW 3KOkYhdDn3uYwTCsDhOfUj8vrFlMXgiqUQxi+QZsp1aeSneaQ3vw/RdnS9smjA2esi7cvrF0zF6y 8y+sp4+JTenxKePiU8elXtKb0lN6fE7PiU8fER4iEiDYmEgg2BkaFbw5Z1jDRdVvRs+ISX/UEVuS mBTSILLbBzNv9T9pP2kNf9T9pNv9QayI7DA4VQdkGDXFcqytrrl6VW3xN5TxKeJTxKeJTxKa0lPE p4lPELpbP7Pz+MP2Jt/qOn+ofsTQ/wCJ+TwT8rlDb/E3f8T9pD9iH7HrkSGh/iftJv8A6hCH6Fax OyUjyRW10gU++MJsibRT83T51nce1xolL9m8u4INewLSs9Npi+vH/Lx/y8f8vBdz9MGmHKdhIu8t JqY/34ZLoF+yf8vH/Jx/ycVf48ZfrPgKsVVdw1m3+vRBDSlK1AjCSJTGcYvTu31uYJ1V95ovxma8 4zZDpkwpuauvsiFRFqtwmYJuVzgHMoiAtZWeZwMrSNT+RFyjorR7xXvEILWkWOx22ao4l3jN6Ufd MWNQIiCwF3sUHUQQzF4R8D5j3rqUTZwDvaYeqIFuaowHLQDYJu0c5NX3XlqjGp+x6Cf3eIGP9T9p OP8AE3P8T9pDT/U2/wBR08cerPZtN/8AU4/xH9iJ+qADaeho/VypUCYfVGg94SYbQGo8bsn7SftI Cthtvh6bL0rel5QWu0FR0a7+sC87LT3F8ksvuQXQBvmFzgAn+d/iTf8A1Db/ABP8cQHyRInxn4lx p2u6cR2RIwTqNUAu7mXK9SPz9pH9iV+qBSXHww0dM0N09I0hx+SzRNwpHcSI/qL4PWdRNXQ5G54V AK1qd2G2q3n/ACcf8vH/AC8f8vGb6foe/MfUz/o9o/mP5K1/ArdhphSP9Qwkb7FZGwBPzH1H8x/J +Y+p+6+o/uP5MJ+jxEcQ0L3VUba4c0BFIHNWXjuIg1wKq2tFD3jmAKEkxcDLGwW8tG2s8zzDXWPe bGYK5c9AWfYiwqktNAvwkBwCrQNVh8mCmpsrvbc0b3XAJ0Rmfrek6V1KE6E6Y5RnRnTPKCrCSQJh QNACgh3m2s21h3iXeZpr0i7V5NGNLj/6zdgLUophtmbuZ5h3h3iyYomQOova8zObHTyLum8LeHee Z5nmUsTMMbJt4UTUGIHYACJojuiFQWAwHVamaN51faj8xD/xo/MR+Ygs19qE5wyXMq+hpFHX2o/M Rh/xx1fajqe3By+1CD4G+AKKU3N9Z5nmLqO1sc1u6xB6rfERonaM4WBvvSzB3S2ATXchNVsUY10u EBaEInImQ8JnmIXfutary2zczACOSGVQ2rNxtr1WzzEDc7n3/kjRTvm215g4uBorRzeaOlJViGmT NF7Xqn05zG+uaKy3baymO9iQVbrBszzKo1nmeZuZnmGms21lXvHapGvghVtYDeacxGwT0Fb3ibTf WeY955gFf0FSSxazBrmAjsEbYDZYYvMNdZ5nmNUN+wVNOzuPJKAtfVEXzGI5MAtIr1grsP0Ro7WC 3XNO0EwQYYGym6uzOtQKNZvrOMznMS5UhQR0AFtLVudVhFANlqpFKFi70WM7XVGWyLZtczJJBTcp 0M4ZueY94d5trGiqOZ1iWorrctl96KFLEMEh+rpyIUvqufiYP8UfiI/ERofVFO/tRk19uP1MOk3n M5TRZurvO0jlxN9ZXWeY6TjMTMbXMekqpWs3ldd4GdZ5i0awagep7K06RW1r1JtEDThz7cpAYAED Yp6ErzrvL6y86y+u8vOsvGsXOsU5g51m2sdZ3TaJjWE5zAzN9YbTdK1zN9YHWViGsfv03m+sSVjx EhNo6R39A1lSp53hpOIbwJU3ZtNpswNJUTETWVN4w75m8qVmJRE6+nMSVp3h3ldYGmZWmZXWaJt6 Grmcx08+gNMx9EmxmBpmM319HQ9KjDvvN4bZnnabk5j9widZWPHpWdZt4hCbw09XWJpn0qOk3nMH korl3lR4H5embmZmOkziN3M5majrM5m8b+ZdMDXKojoXldC14l23dUcNul+oGsbeJm9lVcq8sIbz FIY245FAF8myE3lpl0RlqjvAXMEASI4cmn/tUxxxxx9HHA4r+xOrklYpnMdZabRuoTOYa+Jm4bTd M5mbhfoNY/fpvM3G5t4jCbR0jv6F5mYzPzDScQ3hMzdm02mzC8ejpOY3N4w3mb+m5LVG/TmM47wu ZheJnEzNE29C7ZzHTz6C8R9GZoheIzN+joemYwv5m8LxM/E3JzHTzCNzNePTNzbxCE3hp6usbx6u m833nOsN9/lqd4AuDHE33nvPeOm841jrvOdZ7x1mIgvOnWAXFDha8N9rKyOsc0VQKNshd3lHWQbA B20noAmIvHq7cuSuuhF3wqDMijAccN3RAIBQYohJQoxG1ULs1MbzHsHFqBbgtTWULz/+gYMGDBjJ 6YMGkb1hJRkw16YnOsdYeZtvGq3hOdZvvFULcDBSws3yMy/h95+R+4kufeSi04OsPM8oax+/RSAr qgh5vd4KlnTCtHJaa7gzC+igXLRTsLERMKTHpvMQm28dN57z3mzrFDZJBbmmjY4jfbmPpWtHpNt5 ekEnEpOfDVUO+IQ8z3m7Nt4VyoK9iDr+h3RfgXu4N4AEbOj6MLIttodYxTaFALh2oZj5jrN4+Y6x CiwwisDTAlX5/mCwHKn9RiaEydA2hgCFiNiejONdYabz3nGsU6wfcheZRU0WmjgjJo9yGk8jo9RH ebbz3hq6+m3mJPGdtodZ+R+5+X+5R+v5n5H7jdxHb4HWG2sZvvPebEQlgEBWSaNmkATVwrurWjiM PM33htrPfT0VLkcRqpgOrNJ+gF76+TFZFaEpzl9w4oaUzTBcl7hhGxWYDojueh5m2+kIeY+VsJDd NzW0uqsJOWHBbY30MwR9p7x6eW4myw0KiLGNlCVrTKm8946Os33jvrDet1oaneUHhw9467z3nv5j pvNjWOu8XqzS3WA90hCFSReUaSzV6Ij2dksSXqIbc+MpR4bNKqmqzyi25cu8qu0V0QWw3otROqyr KygfoL2D7SiHAExd7XYuuCBWzPefncfQlWd9ZXeJk1gY3lZ3lY3iZ3iHWVnee8fMPM23jpvDzOdZ vvNmupC44Lumg6lhFfm+J+m+oegQ/eiBYkPM23h5nvrPeNReQqrY9zym6jeZJARHZ4Sq00EKbVy+ Ew6g+RZdOQ7CgeBIi5NdhFq6XFXoA6Ni1HpALOl4cZNptvHzPecazZ19Ff4fDNt47a6kEAPOkPM9 9Zu6zbedb/oYHEgLcjG5QtbZ2mRrVSBrbiZbFa5Hmfq8fT57x13m+8dd4+fTlRXylgCi6CUA+mxf +xHFIKN5nNgZdA1rLcO0W7HIYadWlJkgRsciaMfM41m2/ie894HlgtDSewxVl6nQ9Q0BujBM2xUZ QdfmHSDjeHmHme894SdSaJaVixn6b6jvzhtRSGSwx0mVjuT2iMFq1P031AerDJLQMWuYbaz3m+89 46bwQ7rP9sPmbbzfeG2s510ikAFVUB1ll4GjSY9bWhwC9YPriWyZwQbIVV2aCVfseRxoVCy1YcZp ZXQAzViR0pmToTLTIbgShYabw8zbfSHmHmdX/vR207KvtyZstbEOSU41AtiwBzoE0W9MB7zr/wDf nVyN957xupm5nML+HWNT3l5cP+/uLNWGCyUarghtaaAy+CMB/bb9AsPvAAxHJbui+wwrVDqw20D3 Zbo9lrR9s5Ejpuo/iEk6+ib+IY1uHDmr5ILos2HRVGU9BVQd7Ke4E3kNgbsQaW9wMIWNAA6BglYh cLqNz8zj6Es3MzNz/MzczG7mZvM1HWFzNRuoTOZm5bHciui8uuumXKaQHpatQb11RRgXgdIXMwXc b+Yx7JVHCJ8ggF4YlLyXloHglMz8QVu3OIx9lOyy1MhOyCOaHmZqN1MzMzT6K/xOGZqN49EBfxC5 mbszU/U4Ye8Q7AgiOpEnIOlmlzRpb27CzNIJhoBeAHsJP1ePp8bjrM3G4+vIxuNiVKIwovKd271W I2KIbobQ3M47wupmZqCgVC8nNuPOHVlmjUWGU+Nxp6ZgeUqKWj0xxXM7rpvSTqPgmYXbMzbzM3M1 49ZtbczULxG5m5mbHpK/J5hhczcLxM/EfZaCHShNEz8QbxZui1tdo1RiEDaCRB01aDu+QgYTSKt4 91hczXiFwufn8pcYlUgqjuG2Lp7VA0bg74uGIzlK05dbcOoz8fnLTjeZi42l52l66SgwdYho6jT4 iUkdc9l4p7hMUFA/mBRMNRiIJVQTzd+YztEhugaiIh1oXOn8EpV11+2YmPtaf5qE2DgvJKHadE8p NQksOvcR+IIpoB5m9x0Y1LDvRKx/uBNOPeDnb3l9peNoPaDjaL2n5nH0JXnzL7S8y/7LztL7Rc7S +0vMvG0XMHtLxtFxt7wZeukvO0WncluCLs8prawivTFhNoxAIibXQX3g9veX0Qcxf7GJBF9cJT4R 5h5RDsvIetBroi9veX/JjKNyWDK7AvYZVyQDLQJ5seGXiLjaX2l9peGDJLJr4/7LxtF07x83Acf7 YP8AIPaX2l5ZeNp+pw+nppitJTc4RpHZBjEVAXWimFp8IakFMBclP2B3EfT4vb3i5l5i9ovryIXt 7xhWjXURUh28oZgXM6wlD2VPEWXpprBo2l9veJfvUhFqroBbDaZNKNsgTJvJJIhRFAdAAmRJYrsA vQXZ5jgxeLUaC7NJ1kYOXSXNvMvMvG2nMz9La1l4294OmnvFl52l9peD0FL9O8LB7S87QdNJfbSO iuxFSg3XE7w6hFug0vaN4gxZaQ1qG50g7ngIYI8mw+eBg9veXjbSDB7T8/l6IcCvrRGPfjtuKOsA 8BdGrQ77moI7kMUdcDMQ3FiOiPo4vMvtHRx8TfT4jvj4m2nx6I4+JQdPiJnSV0h2jpOMR10+J4+J 4+JvNtPiePiePiGunxPHxNtPiHb4hpp8Tx8Rfu2xRLfTfiePibmPiHab6fE20+I66fEe3xN9Jtp8 R7Q7fE20+I6afEO05x8TfT4mzubdfQT2fE8fEO3xDt8TbT4h2+J434niMcPiTSuicLs22l1tL2KV sqywcgBdyy0OpZo4ToBjImJV7ZinQGNz6KisI6FahcFLbRvNgKChnNeHOXebafEe3xPHxOMfEN8f ETud00SmsuQnCdoqJ6scDToQNEBm4dDQDHIkJgLLCUrGtbVSwotjLTC5ZddTJeSczxDt8TxvxN3E 20+J+JwxyrfT4h4japIYeTYbinEDNk1uQRqtQ2U5PRZ4+I66TfT4jrp8RjmQprqmwrBpN4N6LTxy 1fBGxlcu4DwF4ECzN6NylCLTXOBWrKrFan7Ee3xOMfE20+I9viOfWjVRv9OeiVmrgbApfXe0v2/1 KrdmRqDjcWXwUpjXHkL1HiBBHXNFob0w7fE8fHpvp8TbT4jqWqLe3xDt8Q2x8Tx8TfT4nj4m2kUO 4X/SGbafE30+IbY+JzjbiCgEKRLEg1l7ztiaWu2iq1hCIBeDMMC6JBpTVxudlpYObgOUDkCqWU1G cmUipIOKCFHqWwoxc2/1Dt8TbTbiHb4h2+J+fy9cNZBV6L5V09eB5EiEt1XZp0UKaw0MX+OhvpPH xFaZbcVlqRYrLzFbloKxWpbRFbioKy8stqWy0FcVltEFgtS1l8SsLTZxGjIx0HvS8veWxUSDiC3L aisVl5lsXeCktqWqDFcy24t13+4oEku54WkTLQWCltEFlsuXcPfHS+rpISzS6iPP3Jb+UwFLMLog cojbNyMG8x7SwaZbUVlty3EtzAFEE4ZTyePhd0pbzgLhiUC7Qu9pE6qsAnRw7kH+soTgBgO0tuC1 FfmXlgrMg2+piVnUsZtwqQW5cEXiYrL1FhkXpbWrGnqhZnVXiWqLLbIrcuMUaDEvjTidXNQAwX/A ZWtwEA8teCSqgsVluJaEtjvC0oJaJQQZot6HE0RW+mA/7LfEvBGNjEwxYun3oiCUBJoFLRbRtBZb Llty2MoERmdJOY/SjHMq3MtYKCxLZbFZeI5B6YRbhJmkAC0XucxZbUttlsttisQ5se5hRhHhla8O CuZMR0AI3kEDiWcXk5Ddht5tVQ7pAKANAOIsEy2vEFtgsytNRLF3ki0Ge9immp5lsWyAAK0wkIFA F60HEoPjsNddzLzLZ//ZCmVuZHN0cmVhbQplbmRvYmoKCjYgMCBvYmoKPDwvTGVuZ3RoIDcgMCBS L0ZpbHRlci9GbGF0ZURlY29kZT4+CnN0cmVhbQp4nL1bS4/rug3en1+RdYFMradtIAgwZyZZdHeB AboouusD6KJA76Z/v5IokR8lxckdtMUAmcS2RIqiyI8PL2/m9O8f/zot6S8ae1p3e/r1rz/++LvT P+vV5fTr33/8/PoR3Js/xX17W09ffzn9/m5OZjl9/e1PFxfs7XreL3a5ns1+8fEaL8Fdzy5/PRvX bkRz9Ze4rvbqLjFczyF/+suaHrVLeWi/rD49eolbeTb/sKbeodG3dS9z1SnXhWa7t2nLQ58w7P09 X7E8w+oK0ehxmjQeV5DobpmHxKMJ7WJY87A7kfm5uvf9fe/miPlWpNUlSolovPTUeIn38RJSLGsL 0caPcmsvnw4ZijbL4onYd2L5bCIP29PiiKCSfN2d8jWQqPkhs8gqYTYWaRIqMbjGW7ezMjQ9RNta l5Q/jSxGrb0IM0vvgTT//PWHH7evH79MVXSLb7FT0cpe2uRAAota6DG0q0SxbnNSpNXwHeIp8u/P Mr6syOWPrVEpXNrPzDAqe3nS07+2r4p2ktB9DTTEVSkia4XKPU1R5v8oF9s9XiBcqwQ93SStpufu +klRydCNLucNpryD1OqmxEeiI91Zl0cCzGrqssrG+vV9zwPiohe8pXF31rBbXK3i3W9Xm6mu+V9h KrIOF1a0oLpjEp2WYMdAxD30/XY1qR1q4+pHbVTrKsphF7Z4bPDwoNZLVQNua6xntEqFfsgjdU5U 8ULjU56uWpHI0i0yX5WOZ2m0ZZIQaIhNSurBLCWG6jjQgHrl6JBkwp/p0eNDUhmuRjFzVE9Jtge4 WjwfItJEyZOZBF6a5Ww8FSEQGyuMpv9R+yuwUO7ZVo26W6e7l8XYY9WJ9i1MVee+LrDxieTteCK3 pc/OaUcr1jD9835yfqqRyuS6455GNLWC42HBWgR0+Gy6m1uoViFMPH40+kjmQxg6qvUQ0m8zzEle KohlYv1bTXKqe1XoxlV36DexHaiUed8qs23dA4liLsHFNHjSvsCmeTl95Z4eWTSqueBezsnhKjnZ Tea+kYaUjUtL9aB6H7jfZC+bY6AduNO5hg34EJfxKQeeeedliB1QREQoh+pp46CeK9pDxCOhQgbH WMRXaON3OR3rjvJe4zaMrWIBAr1808N7N71PSwQ5JKkOMrhlCJUptEEK27nA13s8mSWXr8M4BqEe hi3ZdT1AveaiZnEd9ZenQUG102XCIher89kAmDNiqXAXmCC78JQtx0KpxnEimHHb3QyVHKqb8W+u N6ttQXUx6EmbaB+hYoRPh4A+yTwqkWf7o7eujac1xqPZ0lll7ICQ+VG01D8Bp94xoGT+XbId5MFw gqT/17Tql84AD5qeNDG95XrDPGCVhihhzxMX+mpIFzlUsZASjiEXXwkZF8C510tSM3YgSrxjF6KQ g1Exa5b4oS4udtDFRq9IegZKJzHXqKBgiJs7sTUwuaGPnkRBoUHz7BCKmGaWfmLns8jnMwcJYtZ2 1sCptahQPA8HvxvEvsLfVE/Ab1kgGvZLF0R7FhWdYtaXITi8K5cZ4KQo2erY8hjUPExZ1EiT4Ysg LT1EWw3QjRc2wl8Y/BypZdiXN9ubSDwtNEkcFKPEJedq0F3bJ+3kqil3hxjEG36oIqhdzNqHjMiX HU9IgquewXX73k749gy/1Pk6311dt6/G0Zbj+S7wjE9/Zd2r4Kdyq22gi/xkMc3yG5y/CPNl+CEL eAFGmmIQZEjwV8NhWtYuv0zFqY5Rt+sMe2ObBu0GyFcd460QAPHlU3yopus2qqllSXixoCSXsIO8 b/h7YqvC3NKqKAYOXg0HRb/7MMRPsycS2IjLdUIiZ4QYDAFFYfmuSU4W8luAK/D+EkD+UEI1g1gk KzOY6cmAyca8GJa6i45mByUOslPapwStxLD5aJ5vYMM95IoOtTPGN9Nr5y0vkLjeVKTWlKxmdhoY Y+s3sXwldzJLUancR/paiFI+kmiOiF3A1qVPUBbEcLhQ3x9Ct6qKAMWnedoSUXEqGje321hM4Um6 OanTea1qYylxxN5wmq7ugd9BnvxR5SEnpzssJtUKALJLdXOz1DojBKkW1IxEcxzNR6qyRDOPm2BC qBm4zu9ocMaTODuQtcUyq+qGyHRyHfhs6Wk2HwYHKAAyVjdmkhVUbTAHO2yhfjDbRcmgC/Wj+P9Q hd3Sn9SNKQDwqXnSEkQpW26XPp6va+hTtukkY3SCmGzIrF/o7BY1sE2/bEv93QYWKEVVc7OcIqV7 OuDRC6hSb0ZjqNDNwosnJmEJb3snUbICNpuAlQ709roJ2GjEephU3Jf2kJz7deeBsKN8fRsMwura jaaxEB+KTcy+GSmS7CtMTw/vhu94gOu6ynZeAxMTUhoyFb8s3GaA3GLgzcjVrJUi1pxXhLkt+Acj NmfTE+spAIJugeVaLBIkLTsXSYB8E5mz5RNCLT6f2y15LjkR5TdABUZWlSIfqqbf3dvWqaY3eVkv 6b3Ob+50FjiuBvwEfrkoRJDwbkgV80XfF68GVFILXRg+l8IqLX3puNsGBKcTL1GYgtyKXAXItyAS hbSsVyRLpk+k8GpVAfL74kAgnFZ8B4ZB2wzeB1Q72JBW04JNbioYu9Dbx36mF0d3FgME2QzSoWpu ZlRNbZ0cRmvu0H6ChlBhVQK5doybRsyPsQTqsCkQbCt7qq4/M5sQUt67Fof1QbIJ5s/BTDP5QWYC Be6yB9n3qbwDeweH1yYRNySrvEKbH4rItFPDyTSE93VSeV00pxxwudZJ0sxsywtgNh7WPXEvXThe ltavtgGHQ4WM+9DtM83MBQ5VhjPaoAWDlkE/DGGRzKNdhqaAJ0jD+zDU18lvuOo3JP7+jdYIAz0M IG8UxwcJB0clbqZRRea0C8okQR458BkD+6lPv3faTNJhEc0BtrSfATZc3kBExznjJgvkKhrEgpw/ i7jkqOxkc1/aL4kehmfVuYA2mH2cH11cl2OpzQiyG9PcMGxWBeQ9wowqIfjkXDg3KN0kmYmprk6v 6076ia/yqBhO9GKSp/G7ApSjMnida1HK0DKZDQrCnA8VIPTzgbp6DFinkhdfCuiqtbDEWgP3KLKJ 8vsd2kyaBjJDM7LFVN1LMq1zG8JUxKnmaV+RyiAWP2aGkAR4JlDT+UHUCehHAPM544fqa83YWAIH mA/dlasjLZCdKQXLo2HkpYsoW6jZnLHu13lUrb8UVzEE4RQWS3ZrdBhAHrz62KhS4u+598yiaCm4 CqMf9lXUp6zEZaYF7u37YRkC0wGc1NWctwV/Nj0BUbc+pL61ki/NY4pD/Vj2UT8ewIzC3DtLZZ3W ynU6sm67g7ucVAFcoTDgHBY+wQZuC0NjCWEDn4GBZVj1ahaiAjGrSjvxJ5uVimttPfP5C+NcUQ7Q R+ChgsRV4yg96b1jAjRqRdGxTlVLYl+N3OX513qKRgrTap4zzPK3KnIgR/aWVgj34f/Zici4k/HA fl2m+1F0Un6rmGmeet47Xl/qfkp7PLYAvBCf4anxnz4ZH3MJeQUX78pn7ostiQ1/Sx+lIkI/6aE9 TekTvxt9LffDLplGmrhYVHmgTJVpkcEl58yP3TOdMnu6ZMpUpeelfKcbNEuhXbgMIU/40Xhro6k9 qdxMl9barkQECBBkHux+fRofOL8PNUK3SXliUiuCbvdX86FGj7hJ84kZkIl0rkhqWKzMPhZnOp7A 8nCn67W+DBGqgU+n1My4w+RyhDZE6IzBXliVW/eSbG1eX/fZHDLX10CS0f2U+iomJbnNAmvmBIyG NzT+73uGiPlQ7dw6lqaHUoBun/PDdu9UAxdUrxqrnm7Iw/3o+5+kKcy1JHFbvepKMwN785Yy7JRS 3UOP+9WiZL63uR+YjZKghotNquMEeK+oAwPUUVzD+cCXbESJ1XLr/q31JrzZEdTi4MWI7p0mwZp9 j4sr9f1DRbNhrDLTPgE47Hem3xV/USCs1qclTT/0+1fQO8z/nVJSxs7Jnf2WUv+hRJZeHm7P9l7q qoPFt4IXXmTbMqKZvNYE9c3SiGbFCq5VBVv+6yYrlZKpVTYJLrIBadiZAyoab8V+sbnt55QWE2iz 9b3XaXZ/jutQmKhaMgiAVhnfSbmommEgC8GOyKp4/5Ye6GIlWSjBgRE/Nkvab20n0illgibcMvPZ lB66WfpujCfuwG59NVTBS/Mtbwi7PWko0TDdDitushJsXiDdTJLZZKw1IQDy5Ddc+mYaakxp5qT8 UOpwtitgFgj9oe+6JvtU6cDecNFUtOsPHTM2R/oQHRgsb2FeZ2yLMn2sccdr6p3IpmgPS7mwazo6 au+QglI8jGwMGoNmCjgekcpqpyZ3CHGU8h/q7hqHWv5BRXlaZNA+deiV4/BqQ1AqA6Wjk16R7NOh UByiZI26pARlMJjSghoLRFzshDINxuDTdw+cspjSMQzTjy4DCGCEXFML3XxYWrJDxapzMH0pgt/H mG4UTj0x4QELdxHlMJ/jyIYDfffQfh8qZvSjYkqeqWuO+ZZR10E2WmiPBvrKedLeSguYevhaljAq y08R8IFfY2MMHUZoh30z2myHXX0dud/TRFwb4EPje7gZfhlq1w1n1T35majt+fjyS5BDJxKmmtG0 Hb56ao4ZM3GoYRZP1zf1evdOon80XTp6Sd9m85ErqsiKw/ZFKXyDuT0Up9yJauD0vP9186ocuhQe zBCfvKtxJCCz266YdQn37/wlyX3947Hg/mt09N8DmrS0bRkS2ZT+Qp0i9UxyzGko2rpQ/MqhHkzn fk/S3spcW7GYmI7dsjWAIGfhTj0OflqLCXtK6JG6P3lnw3jfJbu/Kd7jTRypJF39X2+jG9+SIoFN UgvHm/baTA/mMGF5y8PGtw4oG7pwZpIymvkjbW3JWgbKwZ63LK+SBN1aKjU9cuNc7We7lEe1gtY4 4JPuS2Y39/JdaheqPOlvcDlI4hfSsIX0Wh8b6PjGGN0C0fxy+g/j0CU0CmVuZHN0cmVhbQplbmRv YmoKCjcgMCBvYmoKMzcxOAplbmRvYmoKCjkgMCBvYmoKPDwvTGVuZ3RoIDEwIDAgUi9GaWx0ZXIv RmxhdGVEZWNvZGUvTGVuZ3RoMSAxMzA3IC9MZW5ndGgyIDk5NTAyIC9MZW5ndGgzIDU0ND4+CnN0 cmVhbQp4nJy7Y5AuXbMt2rbt1bZt27Zt27Zt27Zt21ht2933/TbvvmefPzeeiKdq5sjMmTlq1IyK qFkkBPJKNALGdoYmona2zjQMtPSc+LIWNoYuTop2NrJ2HNI0iiZmLvj/2FmhSEiULZytTf43BygS VRNHJws7W87/dBVyNDFw/scgbOD8T4SyuQu+gIsZPj4jPgMTJwMzJzMHPiM9Pdt/Oto5cuKbOtoZ QpEI2dl7OFqYmTtz4v/XKT65iqIaBRUV9X9bGDg4OPANPf4TwRc2cbIws8Un/R8J/rG6mljb2duY 2Dpz4Qv9Y7a2tjDCN7P2sDd3wjcwNjYx/lcOVQNrEyt8UQtrC3t7O1d8ciGK/5nln0IZaP75Y4Ei wRczsTVx/Kelfwv8F2Wido5mJv/WCz0bIxM+ubmzsz0nHZ3pP5DpvyBaJ1NaWxNnun9ykojYGgvZ 2fyrGicoqH8FC1s4mhj907wH3f/CuZWtnZut1/+GmFrYGv9rAnxjF3s6FVsLBxcTCeH/8P/HBPXf NjMTZ3wWekZ6DiYGfBMHfBN3I3O6f02s7GFv8m/gv5kNbI19vOzt7PFNDaydTHwsTE3+OUB5ORm4 muA7O7qY+Hj9v4H/OYJiYMA3tjByxjc0MbOwhfrv7P+YTUz/fSxj4Oxo4Y6vRU/7D5P49P/6/deZ zj+X39jO1trjv91lDWxM8P+3vv/LQ1DQzh3fi4aBlR2fhpGdAZ+B/p/+OBiZ8X3+Z7b/4uE/Ofg3 q7yBxX/USP/fKSVsTe3wOf69lX84/I928Olc/13X+OT/0jUF/v/I/0+Rds4WRib/SOa/hKlNz0L/ jyb/OTD8r4L9H/h/yfb/n1L/lUvoX5n+W6L/R4WiLtbW/0Yo+b8Tiv8Powa2+P+Qii+N/y9WrQ0c /88gAxsLa4//W9j/4a5m8u936f8tnYSzwT/dCNiaWf8n5fh0Fk6iFu4mxvIWzkbm/667/wBUbI1N HK0tbE3k7Zws/rWC4NMw0NP/f0FlcwsjK1sTJ6d/Lu2/YSa2xv9zWjoRWyM7YwtbM3wl538EbuBo /F+Gf8FGLo6O/5D9b9f7n9j/HJta/FOjiYm7iRGUM18w8qORdblm3s+nfHMXGT2lhso20f4jhxPA +FcJ5rF1PHVTK/pDmVKUzaBJ2Rz+Cm+TLRsTP4js0hABVbAB40EqZMAigPXMWfh3qsPM2jWyYqik lFF/qk8jIl3BREiIyfjn/M58lFrb1yUPcbutVBwzLy66b55ozxNXBrqBiibVPIQPOlaMLDjIWppt vx8g/jOApEoIHo8fNgLOzDZfHBA4ELq7rw6PQwTF6knHvQ99gW9r9cGb1gF2UUi4TA4A9uNv9mxu wV19lbPMCql83swLf0XYABuhNRMiaqbB0mPe2wbfhQWL6mR4lcvhhUjZc+Co/4KDHf+8Rtak+24y cKH7BjsFtBbszk742ODhAc1qhSMCOPwqy5pxNEAayVjs9R/th4mhjFuDaa1jE3IFCmicDBeNWb46 iBzXootcX6wK4j0A2z6ivEJ283RB2HEIqesqNjq7mDfL/vG/8s5H+bKgH4+NppLggMkMhQegH0jQ 5aF8jeZnxsx9a5iaAR3eICvsSr6TliOPqi3d6RnvG+6/Kks2RU7HMhIuPNe3Z8CLJ+2KXbKgWDw8 z2TJf+4co3YvNLbb8jOMlcRR7AfzwsQ7lHwtTML6UX6eNoqTHOCFTXpoCBFh/GdgHPIvOAruWqcF v3MiNdhW6kE3fj3nfVeq9yZ3yUd6pLMChXXwGom5otJ1IPlG5TkANPBxkqjBIL/iqgVyPkqrUFm7 7361RpLdxcBbZYS5ilL9ET00UqSLr0nIsoWBlJeNaz4N7LYVPxhyIIItsRVO2z9jBMla1+gLTrqo lLHrq32dWocN9W3pfMY8pzudllUhbMJ45u350uWyjh+vPVwpmNm+kwsWg1HsvKbxJ/8cBKPzZ8Bm Na1i7Y0KgTzhnjgDmgGEMgjJ8Cu3DdPvNq5piQc004/6tFk0O+uWCDLNfKsCdFGm4mcGfYMM8EgW 15LtbviQJL18l7yIIV55kmdUp/fEhHuUObYTqMsOW4LG+DaVYU49vIoO0Y/1f8K2vLmIaLgg70BG KcIcHZSzSX4pIRZxiPO9j/fudOYbVBLpVExu4oj6FFYKaQffRaBUTCtu1mORwio/0G8eN3x8TxN2 PepUEnBtsD01l0h0mccqV4tUt7CuYzxVoZlecr3w7CPm1D+z4WI94re09dT7gPNRW+6JOBcP0AjT 5i8gEwpNKcXlgz14uyHpWoeHGWQfChXqraTf7A3meE1A1HKbA/p3JkM+IroGrIQ9jfAiNC9s1FLR WjTIKi9Zz8lCtP4Bj6i4LeHFnWVGnw/C7Q+wBgxWqNBvuLWQoW48UU4my/FhUP2xuIfUdIlnwIi2 BT/3FFYfvxRn+QEBRglz/qQyw3S2VdFNwd9xfNTYOtS8Koy2Cq0R0Vep6pxCLlrb8Rbg2pyajmLb /USmF4jY8wkbTeqAYlvkfilrjTQbvy7LQzvDNBof1LJojHKW9yjPX5Ne8jVMfteDLLnRRqmJYSR8 ns235i67njoOjL72+zgcCvVbxl2eA7h7w7Fr0A1LL0sru+3W13V4cJiQ4x9Q+D3Lb2UMR9jjrGd6 Rr8wWdM3e6mcL6nXc4S2IfVPfnDmoA5vJgBNofrA4nExWO0cDtunpmVYTJZJiwet/ysc98swk9jx NzWYTbUeAmSbIYKX2pUorR/rJSP8cmrGQ1/Y9w7oACXqezEZXD138r2FN598ZOmnpFWV+UAg9Q6N a0Wx/pQzPRpwTV8BsI0seuthILPjsFVaQTM1DG8yRX2ihk5cSYBQtGkQL85X8Jq6FD6sHBG+Uwa8 rlTz6YtUrWbnL3NCYCZ5lzPMNF7jX2FT3k+ni8MLgjrg9IIOCy+OS+4r6payJFOX5O5iM+AbWCce UijSCEyQqjPb7YMx3S2G0F2P5y9pCB53k8SLc0zfnQnPMSphJZ1KYkCJeUvnKfEAduJbEY17vXPO 30UrlUfsiblaLhrr2G0SXFTlbwfxC3RlRucn8J/51yKqEfGz2S/OAB6jqMwnJxzBhtrcmezfJYzA mGZd0G+K828zLxwja8BOiiN2nFbf4OawEYs6IQmX9yHqV7ytVrGNap17u9ILrWICWFBWgWNOmx3A m6ZF8DkWOAY/r8475juVlhswjVfaCKauv+tUVUeYHNv7Su/hbjZtQ2scxuVI3wvY82SXO9rVW8hq i2xv+K5kfOPR3XXp4SqffCEdSO6gPgMfVoK/wR0PZhihDPmXXsKqJqz4qAimlFWXUj3lAreOmwUA KfJFceBuK0ia7QxJpSQNxRKQBOopIOpz6+lX0j/8A+t5/qjL6OGgQ7MQ1Fsg6Jh2Z8PCnHUB1Gui O1RuotI+vfSptqzDSMbj44DVw7+4AXE+Bj+XjPQAo3XfmqQ5yPqaHdGOhW5QxqYxVHUPhleIA6RG k65qO8Iw4doCYSqyDnlXYDQfS8TftjcKIbyRHHp7CbW0Ca5ZG5ar6SPV6geKuC4YfSC70yEGcWcu peawkTkMBfwTgBJvtphftVMHf77yQE9GiOJw72E8aFnPkkK5ayHN1X8wRG/XQIyT/VL1EyYDmiuU srGXVizx/cZg2bA9mrqxZAqHTUwAKZ7dzvec3l9rrebkShf8RTSSGR0J79hTZWssOQR9YPl/h61t ahgDIalIBfe+xJFU7b2KABrpLrojHvPg+uU+o5pPDgXSpck1XDC6pNsI/CeEwazuDA04+32nJ8/N GUObHTI9EdRtcoeSz1G91zI1KLXoFfajSATbRpGOugLQV7uRn5v8PlqnvSlHg76HQZlcVshrNsNj V5OPxG7SvtK2UZDCa2qsCQIR6aIvVTsNspvm4x3VruTjAwyscZuPUIN+UfEkaVemtfSMh4RgFbss 0fGADbOIV65ZweECr3TG2oCu6h3cTifVyx67broSs2bO9G4jF7ZiMl6OFTK0tdGNpr4x3KMECGng k0pv//Y/fxVqePBrqrFB+bg4qFqIKunZCV6SCv8ckIzlCX3XCPPKPGurhEX1mkzPCfii03bZcQ0G HS2SYsgmtFf/UVZx+xgFzOEQAEliJS1qsDZ9VU9CQUdRln2FlRRD0gxawZrC5Rg3GUh8RnbLsJdq 42Yff0bALTIT6RvSHviEW2z49qQ6xpcFTDWbKWZfa0eDBz9KkyDr2amA8eSTVYcOx8yf58Ol0qC5 UaoV5MN85Y6e9NJUaG5NkU66+MBecukI23Vt476tc6Ob7lcCCn2yCrn/a9PJ6XrIDXyUngnXt1O5 WX3eTLpVUjO9SAb2xy0CL2XHybHlYF/zu3G+UZeHV/sK59c0WgknRbKh/RIhidq/5wN1T3a/FjYB 0WlY8CjsXExToimOssBH15/0HM0W/PYxFi+N4gS9qy5Rb0Or4WWRTwz+/qj4WyqhktZg0wB9Bdyu hwr1/leSdSE/ph0pf4eFEaCSa/C+LreaRp+BFKTuFf3QWntL9dDv9TFbK7RgTvFEsIZN7KLG5bXx KPuttPIxN+9aAvJtGai4e8XkNG7McfYpXavRRkBabFNd4iarboBM6ABtSrpnzjqGgd5LdMD5gkz9 ojg3oetUCsCUVXGatqFjwR0+c6sxEjhmF28vgXmoFTVc7pXca9mC9Lw62zf8asHArqzPtrmfOmlz NKoA94bU6Y/EB0FTvbUL02r6j8Hf3/tZKND16GXpthG1Ag3K0zSjnHCdlBBEr7GXn2m50J0FxJ9R e+otbgBCh/eBoQ7MyPIQe7+7trv2Mksry+N1fX7XbSQz34ilsoUgfpHAm4Zv78Ry15r6i+SA3OMT M4siiYBa163Q49jRex6mE39+LCvsco4dt3RJZIyXsXrPJmKHsxXcNsShZ8g0zJAUthgMBmPQ9Vff EzFkrkxgoL4sueNybpKrg8uIR35j3RapmhM78fswqz1kjLbXDDZwCA3XyZXCB4kGFCT9FIP5GVay HssTENhI1NJOxlVMuMje4wi0tsCRtsgTcpb7w0sVaWctQqOHQy4SLHE2ZikT4CdO1uB4OXaTHwv4 pEBEfsIaVD4PHAX/9JFjZX406VPSeBifsyS4b7j1otnBqG6KsrGk7WEGgCGjsgJV15E3qA+XPycw OjTIUnwAOscjKf5sDx1mPlhIgc7vQ5QhoJgKAZxAQvyl3gLGdPTGz8rSEzShpQL9LrGvb+Wmmxlz mNBhqF2r+otIvbnIUiWrqqE6kustIs08NEAJMVh27LZEoKoVDHg5OYmaYq0Qm10kjjYIQDK1dwbv LG54V5xLYNiePfMC/okRfwkZvXUvOAAWIB07oPjphhE+qNmuT37k/RUtlN1EYrHIjAGOE9nstX27 nabCTC1SmDK/PCYywSyINAtb1lptNhvbL+chZZ0eo1ig+OJdFXHys2rSAjnBD7fq4KGl/5BvDgv8 IkO/7g3IYjxmi1wbAkOs/z5GhWTEkoNjYdxrypGsOyvOYwPrtH5F08vfzo02iPOs3vrGL0dWlIrW D5w5oMbFDImtdRDzHF7JfOy40iJ+vA47EwLd51x96YFm2JmpcslcBtF1bqaPDI2b91xBiQxoRwhE KTv9ZVr+BshTegmxbFpfb90Cgp9zde3rabN3tpkeLcWpZvQuotEaxcGILx7PNMdLBb3wCFDWNnQ0 DY6Uhte+W97gNb+lLRumEwj7c1vydw6yT6Ciw3kMT1xbshKt5ojOgV+sFUwh80ZYNvgjGLAowWgj jjqAgptJzp9y7AhCoK05B4ywjgInOfJQA10h7sERj7qshO7hcaiJnzhsJOn6FIJT4PP3JOgFvRDU rjzTXUMIIYbwK/AMxBpnmtth02fIEnio1wD7Tw4w/HIRe35OvinrZ3V+wc3Dd8JXKyQwjomaiOiT rDg/yCHtDC7+Hm6H1/19Ho3DQfBpfHwPqtEMLDqRDD9VmVzcodZ6obnuczhgdSLIy55FPRkvK1Ja 5es0nXCwYYpVBzT5izYm8kIfE2/a0Cm0yh6FiuPO68dl5TIl8rrMOcjPnW54DaZi0DuIl+Ay5TZk uKU9bsdJESp1yZ+rwsR07fNNP1HG3rBXuEQqshDe0Ve+riS6qTYOgUWhCXFd56+T6kXAqHLdbxYP 6CUFhYiVTxraY0x3PmpUwNfwGyrHcCfYBn2DhCQb/aeOrOYvc0CbR8cjoh3y2M8bKP+8yc2mc/U/ kRAwwavG2WA+mPs+JdaJSZ6Y94HpXSCrFB2eVFFlFH/aQEeu64jmgGphZMp9Pp7vX88KUttHInVA nsIcMlgbTVqAYaaTtSH8lo2Dh/O2ZRaCM8Mpxo8lTub7FiGtkUYILnQV5mEO2/oKnHR8DRGEfgiy EmaFLcaxDQyV05a0Sk6kEzX35PnyF6khDpDEh6KL97e2eE7PbCN0D9lmDZWSWsLgI6hjWtk9KmQR n23BAdDGF8/ovHksDREk1kgt38UhRvzZMiHNWcKVuFOTZZLmVz/73mI76yVYMFZFCA85kGVnA1LC GozShFOhdHrNrTUMrcgGn2SLLL2yLJeJL6ZcO6Hpf+o2bwULJSy+6Ht77wdWo7DlZmjW33zp1Uqj ipWrbvjeHzVTk0+S2fMVqPYh3M2TKNLi06cJhKWguvAugtt4+3g4afvKc6gNUaTdNBEV3CqXDfST /TVDahpZ5O4B74QMQrSl16r7w5fvQsr5fgyMQO1l2K50DdWO2hZK3R4HOBfpP4AwLoddSex1lkHr WUMCpZqG6sMAQWtmMcWtiXiHipXdu0iIGge7o4LBuGLJ4MCF5bIRwN4HTadig4Z7CXxVGe2GFwjL 7T3I81dnU6FgKX0gExgAjcJdX21xQcBM/MjENB0EPitRgUU/T+9zDkB+TZeqvKJ1lFmGsSPfvLTX O6I5BiGYeAH9VSLQZUXgeyjN8HtUeS25TeS5URxDlCPAhcv3z3RY0WxZww/2i8Ax8LVW8vLYC2If oRQm+2XZz8LqDSUt5MyAuxP0lvvFi6PdxT3LqBIPprySE4LklY9fL99pSUTFnfxP9tI028IwQue0 dCURVUpkEqz5J0CHBRVNWpaDj7KLjrxrrC4P47J32xj7tE2rIKGVHp27Vz5iUtWlFFiBaO5RwRyI tBj6BI2yzedpAthhn798DQfVXSLFPXIzJfs4WK3/arS+nzcxY/ulyrYy9ZRIqnSJIQtz2NQ26dO2 qcYI14XX3UAc09pVHUpQ8OUME6XF63gEXEmfx7/SkdyrWjtHYKkibXqEQhOvSiCr8nuUjZc4Dme6 gTGLJa7OAc9jlqa+vEZAVlPNmf14X2lUfUdT5A0eEWaZtmewN8TxMgdnv01Kpa5sqvZblHwov5j6 VNf1fNfnlNmDS+hQPnqtCidAeH6EsdRfgmajX1leImjiLDVXl7FEQdoQLXf+qaYTOjUkHS0Ja1+f cCT6RdlH2Je1sVdpQa1wgVKkKSM64eKjVZip+zFT6SSGSUQ2/hxDKtnN4WFN464KqGPS1q4ZHF4b 1tKRH0tms8hp7g3MIocMyN3R1b5pZ+HF7Ob5MunEyecrSm//qt3zKwfdylwu7m2TeU5Bb/zm8zIY PfT9cG5MHwhOxm685jdNFooYZniLs1hIfr2+cGqH5i2i9pUlBWezGVCgkZzhzql1c+wdD76A+ZqO zd4zjxBSMnTOvfULN0sVWjDOCbQ7XrILZP/TEtrupSC38vVsDHPsIxFma1hQx4+LSQKoUTiSh2Ud lOnIe31tfPgezX2u48+o7o4+5NQwJJrBdxTyRgfMtfZO4bBCeSHFUDDuAnmzNYwvKYIWKqEyjEjH OGltpM0Rod8SnC6Cfb63Ma8erRxJshGD1CsVMGLq770pljMNF62M877mVWnNVvgHBqG5ZM6OSGb6 RApVg1lK3CgRWoAFpdx/btCOD8tnTvteJ2QtHR7VLsTTacwjYGOLu0F3cbAq10rt0q81G16wZ1BG Klso6Uv5qOEghnzGBSUoLqfRfoZOouv4BOblpn2qbr5MSpyONTnUB7iiHaLNe4k7Xb9X4AfBK3+R VSRY14EVg8NQAqqzM/IlZLBVEdDgjC95QX8yRXaqCYudyudl6yIjQTS1mkSRzrgFh5H95voLE55F pImHYIgl4iJ+2nB2uvgmdBR49OjaNcXa817EaVMFbh7Pm9o3cX6oajlwZhxrUKK+sLUKHAm5y0pr P2vqRfFBou+ULmmwHmMb7rzVrTfKQ8zf+1SGdt8RFn5TwbTiN3J28/vMZtiEmtHzdyfwAheRxUmg caz7OxNd27KDqqcvgwHN2EwA8W8TTpeEOY1ujn39s5WVH1u3M+W5jn3E6J4MzVqhQHgProxWvD32 rsyK0B14rxZnRrclFv+9KdsKYr3bRhJYcEVfbWQmOBApTGSJqimtnI/WZ4/KigZxVvM6heGBcSWG ApwOIcNjRMkwgdS6jr4LzTM4lWGpTvdckfhgFwqbzleD5AntFBQSLw8AHIrq5Sdlvt/rEqe5td7Z CVsq85Cd7jn7MAyEU5Jnba3NAPAZomoINs1ZdfmLosxhcHc7n6BgI1947lnTQh8Ft8A9jm5aLbU4 bYQw9DmOQL67navf0hYDL+E7hLOPDIqrNmgrFkGqzndhxPHT3Q9agW3J4BcdWo9zua4fFkfzi0VC p5Y7cfNVhL4gJ7C4tWHxtt2rONVoLgV3lojGzBcUvdrIeN1STEFsQ88PdoPtg7DQLybMHhIPEyDv AxqudcNW96e8yb1iF+86ZAyz0Ur7TVWkn9yoZv0AL1Rf3tgIRXgBqZljL2H5BIoBbkZ+5PA60XBN j91pk7ZNOkPVh75QsxZZK4FPClr0obl3RyOX3SgvZUjMETRckUA5gtCaeazq0Bp3z0q/bDSWLzZq uKqpKdEKVTsNT2ETZaIAo1IVPFBTJiSZSXkN7FQuQAGraY5FMEmIvmpBO9/OuMoYMG1o6Bb8EmDC BCnbBqRPTjOIpuryXpJrhUSUMM+dwpWdpNtNn+6iAMkLBOMYh1jonO2gd4/zh9h96RpNzSdXCUm5 029sl/UtH8QUwcelFBVNiDKpyYdHJoqtoGMrmDYXUHrYqDCJNzD7/Rc+kGEl9aUPX+R0Jb6dmVgw vHJM8AnPWejA6vdQWb9xUJkQbPSXWAr48x7DJNTTqokvaFOfz20UqAV33GnP9bEbiCEmTVoDuUKu 9NQbyh9S1jXy6sN8LjQU7PNmj1th/kPDVi32eJLdMCCfepm9kibTlMu84DDD+Tags2QK6LIYNXWl eRoLFPOiWhLo7FGKW3ZYPl70ENTjoI97Q0WDGp/wylbhoU8EJDjXIYf3j00gwifmQG/dThz6RL4J ALXkeikWTOl1LFiZ0k5TgWfLLHNSZB6RkD6gtK6NPx5LE3N4ymEC2fbKJSsgymZeWWnGnksHPr/G +C0Dix6pkd8F1pHj0RTUK6ABuv6yZMfXd82lynzAnlBvDMovmDXyLPcqFwDNMAyPth7WNBtuYJED oRMyFl5BvtLKmPttBBrK0IJDCkrIZClnE9FVQPzuBELnKkRyVdzwB7ozZRSU8HRdkqaB3Vi96q8g OZdscANVHFC3O5w2fMcB3+vUfR0PGt97lAlUU/e+YZBbb7HwAGdYYkUzsRPQ11wmvY6c6LS1UZNv uH07861KXXKYjEWaKW8xMQ+3gZgEdbi9o2EhYcCIztNsxZw//qHzWoB24GinrMYdmIXJLAUs8hje ndHXVDWN0AqQazGjailMPkt5I8EQ9N6bYTkgOfqboU/g8gDRy5X8wfJA+Ef1Snu/StymuuAHz6EM 67eU9bl8b2tKQIT+RxQNesekd6OU3GZQu0zF5QUzcuup/u8WKnKSFdtxleJODDtj2L48HGLZxa4g uvzxM3N1JMeXRHQ5ZJr1lAO6nUJcbH4yR6WxS1P2zm6WQ1ZC33do5yShe7H0fCwIB4iWiyuJ9o53 o0k+t3AachkYntPw5lCmFXs9oHhbjm3JmEOgkGcAMuHUgM9+vNplHXBzLaPUgu31TUIeeKQSOuzd lA200YHkOPzF3JRcAL1pT8yPMNzHQ3AR0n0JrzCvgWaAG8Fu+KUBAGQkl4jZhF+GedujVbA1g8Uz 0nGIG7UclmBGkAFPT20UoPAGBAvZu8zy7U6OV/eiSC72ezCK9YjELKvc/fYmIqZ7sARTSL31XrfJ 0SwTqxNF2Wl7dRK5sJI1azDtIuPcMETiCitMvm6P55qNbewiM5k+/iM5JHfxI16LYtlMvpuzG3kW TQFAuTxb1zqkFrljJJ6o+5pH1Xe6SeYP2xyXG2bC63YleT2VONM51IVaSsZ0CKsQLF/YOYh/fG5M SmF9Dl03tZw01Ut2sNuyDhmX/my+SCcoauP2kwtVYfgeiu5/OKE3dqlZM3g+D/Z5oBvlccodwPsa AhNkAFd2oF0s1c7dMWhvjot9u/Ir7O0k3sN78fsaAxS3AIjTlfJ8V4S+kY7hRaxAXYFWD1d2FhKW /fT4dWUE5nwjgKxUuhOABUcJFa829DLvyWDlxo3Crr1CspOaEyYJWhFS8fUhbX2XEM/qzm33w6Fz 4UiRjdvnbkKfINxTlYeo9SWskoOQZ4AIkDpXI2KwFwb5/sndiEMmm695tyq6QJy4mdSDfK1+CWhR m0BafLUKtMOdvOUpR+qFXSw5caen5Bb3nMzLM91Nd8piBY4/r4PlvfTetiO9d24YvKvrBDz0TxEF ZLUCF/Tqjgtcvyy1Klb26U01WFVSJVMq4cHOEQBayyqlmEKCWnel+MUdYoUQrkFqeGuI270F0VM4 sYF3bVvRb4u9H0//kwBoihLFsP+s9IMr3FLDP3fgftPCXPGOly4Y+qnaRZ+eHY9vdhUgPZvQPa31 VgaJwO28Cj5IpXhCCmMI5E/5hG+oNLipiMbqSRlOt8qjymfxkaeFjAG3MdPKLW3uSzwHYV+/TfJw JAHjEHJet8HGjwhSJgB5AUFZG9ZcHoQ6moAshVvaIB0KKBZHTPRmRgsH1r56+r0p2Nj8FwXqWls8 av14z2q45g2ZJiVMAigTGU4CxETdg8c5nabd+NJmWcY8In0n+VpTZzpaXw78PmNzahtd4bNrO0WK 7UzxipjEfjtQRJyaruxh0Eh2ACXvogp17/RdhMoUixJy+kB9DcZfNRjzj4lwfvB22S96MQ3t22ap XAb6b3xM2jKfVzG/r8phwqog8LxxCQ0uQbhn14lK005D6wrSK2APxzOLc8aD4zEDQ/+RUNctIsSU wYv4arttF8UNQJ74/EGebSSVz+eoLCubRu4ozeTfM0WjkFtwaAbGHnHioeEKgX7Ve70iXzfLm7tG lihG6Q/AemjyMU7vlVgbwC6a6A0SFqvTjK5jWdYGjEXxP3cUq4gj2zrXyiI75vwJDooS3c0bJbLx cr7OVABtE3SYvAfNF0PIFx1mO8Ch7Fs7FNlLdJfQ5hp+GQ0FH1U0NRsgu1YtaSwkVvVHXo0YaO8l KLeBLfmE2A464x8jtWTwDMUQa9Iyhr052kETsmzzSZ7zPamobXqx1NxWgavCas6xsJN+3UnA89CT hK380X71Np9VKWO5Tvs+SXZDQTiblx1l3orl26Triw2MRnAZ+LM9IGUErQtq91HvcU7Xf2nGFnKV 2kYnUpboj10vVZbSHPMtgSfIJph1QVoRePRsdNhujxSRvE7MoG7VpESPeI2gfbXl+cj1ADNEDaxT fgkDTjrmREpsXdGeIGZ9ToAux57pYuo8T17EGtUTqrQquLAdETo012+oB6lA6YeDPiIjidJ7k7tU +xQ/UHssB75sup2ADUAaKJxrCQol8yx4jgYFkxk3FJ3Wc0WIWyF5SADrFyfO7Ja2WWS5knvj5UgI OcJCeHXoMiF/3Vj4rA5k9dC+HCDBgprymbfkM8yAlQBQhvnTTAHA7Eo0W9mu4qr1mxpZ1mUe+SaD weT5r40AgNBF4qpawmKy3WMccvzs9i59/uSfiyra6FIvsdGV24N4tLZIGPBWFKCA1ofxyCY0wRU/ bWR9qo8qcwoQWTwrZx4LJL4xX83FDDTuuUg5cJqfMu0OZbAsXFBxMqSbCIqdDh5HdCzndygdRXf5 W5U9QdzLEW+DG1iuB4VD0LZt2+LqPLBizxEOxk+rgxtLvR63ePETtxMUq2j9yh/xWDLZmWx0hH0i jxN+PEu8mWBO35ZszxXr1f+wzb7LdWm/DbZWryB6ZLV/Ti1tkkvA76pCGkCHQePvlJosG5KSjSn3 +AxIO4GZNIPmh3DEOwhuqLzeE1SmZcgVmRqGFx51208ZGIuXoZ3t4/jmS6WcGPqwYBInCa+yFbve 5mirPTWI9yHldJRRi0Jgvp3km6acY8H7+4HNlNu6VG7Zkn14uDtPLYqXmYKBi97HWNggTvSi87yi lR9fBRdtgOq9wYtEDxIq3sGQMuJuqxqrIM5qsX0qwSiJXdSbGm24JmfKWl96eCHcFN5noEeYPcU7 ryeYougK27sNWjHJMtdF2KOgLisoWq8yvhAAJHFaiRsGqw9hU7Ibuq0PgPglGacCn6ch5zeHxIxQ a0YmihzeIV19ojab8KlUPGQKHR32zb/Vi0eoTAaJmUJzV86BQ0o+TVJ3/w6KAymCvv/lu/P5g7Rt ZuB5d15f0vbLDu7yhjdNvqVSkknplI1E4tXD3WOG5R2aOIh77sJErD0qXUqQcBV/K428nC3Egm5Z 9gEMnE+aBf0kp5+lfXwsqCWar+rPjF3PoaMSNxr5cIhoeySsqMA0Vw0cDQheDX8QpnaJr3nLWs5f 3MooHl2tGFubv73Rmca9OQ86ODXWBPfY/yKJSvTU5KfEuIqE5/vuH4qy8cM7KxYwwv/tggOSoRnH DMvzGyDK/rUKt0yACZyMzcrpEy5fqVSS5ZvwMvvcPG0Tyc9PDLmlAHMUvUy5MKbKiv366qyR93I+ j1bvD9gUsl6sGBoWG/8B87QPq+rfZjPD7ymGbuTdoUHBU537VqGxueqPPYFGuZ7Wn0aA6Flh0sQ2 vNX2ZUjFqxhumPPXV/HINLPTWLvAIDdIIqYBd500n7fNun+QcrR2SVzN5W8VVY8ROvyBsWNqfc09 rk7qp5Z4cRQRmYrCFh4/R4PJxomo8fOhxkS9JS2fLL5njdJxiD6vD6iWN5c6NuCKSE1EBXjrfOS6 eq8KK7aU6xkDyFPX1mBBi6d1SafgH46nqTuxVMvubbM6LnhQSycRP0sV9sFxcssPdnBBQm3f0X/d 3GV841Qr3Ybs4XLBhmL5+25dKNzcfx/kDIdXDxTaTBbk0+QSJ94qLGOxjIskgj1bUS6XblPvtpid QFV/DmbW7cI7Mjj15lR27MKxktWi+aP3TejF/MwTwS5NBxk8AjW1SCWQnhSjPD03uq/z790cfJQ7 8tFr1dlj9AkXH45itc7wDwVMcXMzW8y2mnNTx5H969RP7whE7v22NrPIEjaBodNHeTdsX+YUMFf3 YCemvNqPzS3GaUieRMZsKRwMnsh/oZrdy2iEv7S1PRWGyqLsr8OUQoUAUMR9zepYIZTt174QymD0 mfN2iq8MzG05gw4Wk9osHIPfdwBdMYCKbkP28LuhPAiMhkuKqi5KRxUxbCwcd7Lss4N6N0cWHdRn HdFp5frzwkZGz5WjHbmJc4lBEUEuxDc/uI45DIHnPB5Tgnx75/h3lBX3ktzJIU/XwglsQ+5U0b5S ogwnGfF2kv+qRFYSyFOOT3mE4ycVAA+P0DklfWtkq2rXFgfFH1xC6YNGAoeZoBZmY3yfC3O2/4Jw DFuz89Im8pMWBc6OvC6cmervUkq5aCgZHMEJLXvWE7Qep+U9lUebIJ6Zr32tkniAkVKHx26ePkT5 qGH49UFeiEdKxeKa7z8cLMX+pkQe+EY7fIAbavG2rB4xI4X+sWikt9LuEB/F+wFzYDQww2DZudcX lKRGWm2KCmmxmrh7sNlLEWrOhmtySVQo4FV1nSk9+aoqUn2Orln0AOPGWc/jK4+9cJfckIo+paWF WCL3YG7T/kMl7M8QqeomhrHOqDeE1XUnnas8wBJRwBc6R3snK0TRbmD9OZ6BR693kUdfRfJI3hJo lU/d2im+1erPR+fBO1vNC407r7p5mYhpnGt641/OSVigYnT1K3di8K2l1AEb3QZi713D7BZxmPIO DEmLuuXdu+DaO4ZbRJnav3cd84Wilub4c59SxYP74D7s3kS2r0VTbkqZiGnivaOAmhEuYcrd3/Fo r5+jH9cPNMjTkidlQpIE6JQo3zZ280G8nm/DuFWO39tvimkThW+7aDqYv5e0XxW3i7CY36NL0lDM 9dUcsrfI8qCIDCgV1xLYYMWSdlar0gJDZlbWGRtcxfcMN1o9mHGqeEqtAfrj+7cFT3dd9zMhrC/H kvLJ8kXx2gmdHbPzrUc9oKsx5J+FkIyehYVRDpnIfQdp4zT5mYP92NBPqs4A6C6xiX6UW4QzzS8+ mhUCm/POLLaedkDUuccjyWn6IyD2mffsrxO9UW0PYiNSBP/NNzEGEnBdQ6NGWUNOf3p7U/9JGblw 9fyJkBGEo8Yr2UJGfVS8mQVGeQxgUZni5xsMQE51DCYCM6kd7DBbnM6wDEqyMnXRzQ2ZZeBmVGEy ckJAvGkvUw/cD04C8OdeNmNic3hykOnKrTCYiYRoqxeWFR0N/nGvpfF4jKdBkWVMndmUsSVTJCHH gzf4NtgAhPHz55EgLGgEuYdwVX0FHVwu1V/RTZGgAmtutS3tGxVtlaHzsv1Hw12oZ40IUw0PZk6o 6ypQV8Abd1BQbrhOZs0qv8V7AmAvRDSOWShKySNNRvQkNtp96ZZIZs7pWLKgdLMvuJIQ3sPkh641 +JKDLfPK80WrX+nPWgv/NT2O6KZBoBS9ww55A2jZF5dusKQi4pU+/OUxdkXQCo2hvLcwzCFBwZRa i9C8YBsaBtrGP3hkbtKDsLDIylu4q3XpqatEGI68P8Ku3gpujOauqMtpcXqYryUpAKITw+Vzb4yz lDFAjgc9aTc2HWW+39r2Ybjp60gbK1Z8jqaM926GMjj0hGOg3vHgSGXX29T2Z8QqsGhTMsaXdtv1 LVnCXGUWbL9GTBrs5suRpxfYfdRxEr/l+wVZl47dM06E53vK1KKE6isTzKCG4vcKGk4XAPrhQTrd 1Zu6GyMHdX8jjUiGHnYRqmG69asafMjTbq83ku595MYQ7uMVGAW1GLeAtEdNhawnOFYApTiEKTc8 LEbRUYyY0l9kX9CizXybFa9djjOpNxDVCzsx5aar/AYlpN8GsaXIpseC0Ji6WQWvsr16fscKEdju X1CSNh5N2pI0XsdVBl38W+1mkOmlq+2PMEkpX4rxJBO/z1AMalavmBvt40vbbV1YNndU004ymqG4 y/9kxEHivFgZl92+6x0kwbO6DY6g6xXoL9to8VFsHeBrgXvTURvbndUolS1IigdYGJ9ANKtKrQ3r idTbwv1oq13dvJZbKrj79EZLHSO8vNYjIfpWoOq9nJK41BztEGaceL3fWg8mv7i0v2HL6+Xz9ho3 1DkAUx5gPavgrMMZBjbyfrBeCn6b8BoovUl3HUqzA04K9XvGU3z17P6phIFycB9vWmtXBR7Pf/RV 8DtINFtEcn0XK+IesBFVVjvD2xma9dqfjm8P5qI5gUeqiNivXCosa54dGGSxEeQh4QB/j3FhASFE +QEGSMKnH/aGzgxl0SuXAUSnaKYkwbtDsKzjZEhj+cYtIm98Fc9rSkLYlkOvKI2ygOjrxohvOd23 oSs6aojQ7GwIlQmpvE7HfpgHYfZg3Ghy7dTsnLfZqtmnxYPJ/6vm9MtUXMLMCw9NVKG5NpkVreve NUHZjLT/RBeRzQ5q64P5JvWRPOc2mcYqV3LNXOE22wi41CD15KZGJ36JZyUMUZUy3T/wroR9tP4M CkUfi1m1cddFyNhJkjcBLdXUMYqqV1vk0dE9VN14JWj0B9tZMT054izpTgKC60XLJkR5NB1YO7Ed rPeswf2VljuCvWHf6hZv+fTDBQ1t30vni+QFknYBbLsQp1cjMj9YHWDIydsqSJUUjBRoYt2DvU33 voK9hRSK8fVlQjwqMWeRTE0y0Y2ASS3nrPIMYjwNzBQblKl6kT5Au5lTHcWgMChN7xcjU/QCjj5t anx2jfz50kIrHs5RSLExN6ohBQd1sZILQUyW3hjQNkS5o3VgHhQJOcSRg1HWbwObBD3DjXJF6KQu ekGefIXf3+6i1y3YK5Cqf7Iy3SQtRUysO2O/zDtP9phOCqhkUF5SN3VT+gHq6R2fq2IAT/SptqTc ufdPs3R31/wAHXDWSsCGVaNmlqmNvuaK+9cnF7u4G2I3RUe2cQNegTvOXYadHxZTZ+rO4GNKgrtD ODFFP62FVzaO/Chmsv/IBcYHVPEfiFpYLVaVZzJ569f5WRjCWnDZj8Lr193WwInbphWuVjyoDxR3 lh/ouRHtUyxUYFQiSYz0A4oYc19YlI/UW8eCQZysDs88ytO+1PzS55M+6yKnuxU88jYUQ2dZFdqA VP15iaGE0KbemJmS2frjw5atotQ/R9wDDNqkVsZYTH87M1TPp6g7Po2SR4tkawJ6xgzSdho90eYY NoHezybnTWWNwc3Otzb2L6l6k3ENa4FXlMNQQoBxTv/IY8dJVxVTIrTOQ6edrIktmnmuGcXulA2Q Q4E2nPS1pyk+jC4fgxPxo016EzWyJyUOrp4rPoivCXC1S1wSo2U2XmKo2il5CcMgIMUNwqUxPLVV ROJC+eiPT4lRNpx8hhEAdnm3U7/K/LUmwRaL5TzbDHgcxizAG9AIDXj0t1/8jNdg6PqkDKfktZtC JIgHn70OD2C4ACsP3QAKqO0YJA8ynrZSjf5jILqPozLZbZpoBcnVoc5/60VypTqDAlFNrJ6my9cT eod/6CePCuQb2EVLkCQHpuKXAQzkozBlmlff1gU5iLfaDymF82NffeuMbMub6jK97rHwFYdmB0wp KG+Tvrl29iHDCjTsY67JvU3Pl+uKJ8mKiNmOY5Bw2O0TrEBp5a5FnSLP/0lUhRRe2tP6KcDYg+xg s84y0QFjc/bjkf2LMcueW+5jan6iod99HheWUsYMmHWsEj0j7TwQP9wCZPqL2DBDQh3Olaprvr9c S8oOIcsVhfGpsDt3tMNEllW+xEdbsflo4so73Mq1qPvcw6LR9zhPzVDj5Mb9MjfDlEwJxJzspXf/ 8Ml8ViNe+LdTO6ZtNUKzNyU3x2j5taAqEjQW+PzYtUgwIo463N+J6bPIBy4jhdMCvkrkYgl4+jqc 4MMjxnpVki5js4bjPjhQpRGVsqJCVv/Ui5wV/au0Fc8EkSnocNqEz6L4fLNW2OE4mRTPh0i9YRu5 Nu06rNMZ/zihnWDKdtUKnBivZ3JlEt8QI4URCuUfsfUvfJatpXJf4D/lPHaxOt89hs2E5D/nYTTC JzfYcuX8bd4wH0HIu2N9e76tTYt4nc50Tscj8A1RTLzL/+3CK6QhjMz1NAFhryOFEislv0c4sD+z c04FK1E/3tuXtB0IWJp0mnnB0YwLw9vEwXIODMWe9pXHXnpiKK7XRcZMj63E0MlCiwmbVRso1p7u Tc8j4c74WS2CyhBTPxS8T5eXl8J9QVzbEWLCHyS4zTYSyfRJkw4ZlGJvaIZVuvrSwViP1BfFyGLI bbGthO0r1m3xJyFBJBWBnVFM7fWa5CqH5Ax4v2fKaQzYXO45niJ1YNNKQjSp/YDf8+AVtTMgH4SU xZbMCQ+ZIdoc0UXgElESLa1mibuBGa/kRDA7e56rcdIE9j+DToHh6/eJp0lM7RfuZTE2Tsrf7eml RHsddDsuLkLo9QlxWGfPCSuMs8kyp3+Q8eYxkiIZnGvCrShtBPY7QqpvqE5g9Rtl0wl/Rkw8/t3K VgvDhB3xxOi6fvxypvssQH4vJUWJ/lUPfM1n+zsijjTUG0WD5e/GitcsBY6H14knQMWBayADvni7 uQeorHjDkGWpIsB7srnNwrv5J4Uk3rQN+9JJlrjEJ+ug4zVpYuK7Mi7EVBnTPHA0augrM+NXLIfq VQMtAxV/syTdJ7QDH4apTQMtXGh7lV9MbBJHcqXEN0rdNkoDOi1GwkHYMH8rA9cuWbAjJ9ybSJiD r/pUF3y+FvS8sBi1tg+Nww/EfXW/iPQNtWHr0YfHUK0B8hrFzSHZSybc88OSyCyDUSAqdoHZlApb D9yBieoO+eS5Scgfv5JfqAgKlfOTBlERaBTMDDMJOSnoD27dUNXLCN2MGsFUIScZwJRnFV11ERJ9 rjefRyTjjrjU4x+ys6n7L2RIwpVQcXBiJsIA5xbbEcB2euRpt2OSwAW0tlNigF48b27oRx6HZgY2 Q2OI9XwXp9S4DROVzu/ownG7glPe7MHE14R8pSR7LyPoGXVvyDkUEALx3C31aWAZO5uzyOyeSlG5 LYQIW953amcGUOd+8kMQHbXkS1U9TsVYFptcvoiqxxggAntqaBoUOhPJrFjDGex0nVVwnnFVmRYu gWrGJ+Sla8VAMRd7o8NfDX2/GDERo/ZGsAXUK4a3DG1cw0J7kMf4itPuBBvSZpPRTwmsGeiBnasG Bc5kEIp5y28GqUCcqItFLqmBHuAJnzR9JBMl1q4+onUtIiJKiELaIacwz5M7oUunk3yFP7gOpUX8 lYEfaRH3E411ikW/iz9c9sE2EPfT5gVtkAIQHDpe6R+lzThHvKJ+VmU49AgmTvlBSh4BhMRzn7bT +TkGam9yw6SmohbWGDy2XakBsZJIzXmXoMj6fKwvkbe34ZvtCViLztyKOlbQz9g44NR0wt/ayfwx TotUMwTngbM4j/x9EEB/hn8i0b63AhMfMBhrwLEaq4ChRJQ1/R9NCwn2LjxIVnINuDIgqaMhzJU/ Cx+ZBsbU+YeHf8K9Gfl4fXd6VNmkZGs3SijhYtnH1YVsda7uA0YSfMuD1rTAq2iiwfg2o2UGzT6V A08hQxbEd1hLtJ4BhNTN1JUN1e2owFbFpC47YRJkFdoXoLfgI8CPNsbaLwiUenMxNaYqC6g0HcI+ 7OccNoXi0PwNvXQCciH3rPYyiIoITNQSUUAWoVsnNB2z2BZRTsZGsvECQ2744Ni6QOEFvHfuAZmi 4FyXnxHaYoJhlQRlYZhwKsucK+ktEi69UHNA7YBbcEfRnzmdD5dG65XhW5BS0KN9lI4UTDcWYV5h k+fDhKMvBOnV8pAvwIoscj7zgBd0QT+DUoD6sQFW0WWH7PVwJrWNeZXOG+qMyN3WIns+5KFIq5TW 7cKwSISUy7o5lLmwu9dq63jHaORzBsJDLEiSbkElrv6IYr5scC2WbNOSfq8XKzZuGSGho+CFub41 RJ4+FS2aVYxcWqK6n/HaNKV4hL9MWnnGV2Eri7dRv9pdMgGFIVGipBJDrIDulPNcSCfwf2BRFf41 ywqPArxCz7FYZhNtdBrWg0KbxqKp9rXC1X//QzpCG00yglRZI4BGUf5VdOsSdwpGQiBr8vhUIZwI Q8VHjeoQ4DqZ6lJ74vq7/ElKpTgGe4AEDvb29AL4J2l5pZTbspOPecFUJu/l7JbLDjAeOa7ulfnh qA2+WYv5GmY1WOwBEhpFkXsvof775jMuD2HcsmS3PWQpbZw/hu1c/wsdLfDMsrk4jKvV7Cy9oS4E dfoiHo612kJ89VeK5SRwghQZUdhxBPlM8K/XoGAD7wHPPT5cfRkWe2igSsBRiqbu0hsr1Xk0Gh1u FM1gk9CuQlfZxEXxMIck0hq3L8O5xw8aBRt2bKC1TGcH/BGdwx9q1Tjk9IVd/qa8W5MUwM6LRqOP d9K4SpSSSRTVDPfRmHXgkUkmzZggm7eSxIlNvjK6ew6fkZqUE92cPj58ar9HlhqAd0A6PM2y/jAa av84Hz1mOBr2Hf/HRSCSIdnXFZJLA/WyB0H+RjO8PsIh3zkiw/LQT6aAz9s0w2HKv4/m0KYT0A1o zpiJmf7e5rqZi8UBUP6DdnRtHYA3a0XNFFIANu4wTnNObGCA3qVUMEFQGor5Z2MW2yWOcdbp1CyI P0erkbAQoVWxg70MdfBOdCrbmuebkXuF3ZhauiwxXWbOlQA8tXmJKyPKWRJ6BJEqNCqbdiQ0yT9A y4u0MOlkaJ0LkC1U9klrIU+8JHWc3VzfH+A/YBcJ+MIyH2eG0yeLQjn9jlsbYJ9TllbIviMOgUCa iZuojcB/tOY9CYxM75YoApWnPm+ldGpy4uf231JO+qPJ72+OX31n1dPTiWUD8ko9cAeMTITvMi24 AF1UqWlFoLNeFrYiu3pr8DnAWnWx5/tn7dDU7kRlWJdsw61tc3MIZF8lLwQGKnet1cs/wnQUkO6e kX55RyRJ4y7Ory7bUanihZZMFzUsZ4eiuRpjntUaQDl6gXosRX1yCnb0KlI2Qw5YbdxwOKfWAdNd iWZyB+G93cxFuww8I+QMwodSXwoDCkYzQmgPMofpCgP4t2ZmxDXnTZcOI0izM4C1foddke5bpw9c PkCrQkYxQRDrHnQ74+y0JJS6zOJ7nfeJKUa6M10Wl6IyEkRFpF5FTYvUHwNuKtMu4Ne0n8EUYe2y cRov4Wm+yDsLTNhWLFi9+Sd3jTD4EFSOXacnbzT/7G4sGquChOK3yWoAczCBPmQD5hd3dEpHwxz5 FrUmNkD4mtHNkAufGQy5PQdRqo6P1DqALxPS1DOAS2f417T95g/W9sX4J0WcpmBn9jkeXcXoBxbP PK8oN0yZVJe0tFQerKsMzRlNvvnNPkWs1VHH0kKprYQl6IDa67G74oGVq8c+/esNJJdXqm6sZ+9f yKzbV4kX6hcs70055k5xwBSwm/4Cn7ZA0zUxrAWymZIssRdmdERIMgmnPoOWquR8f3vSoZ4XPEV9 /eFQ95ZPuodZyhtvGmWmVe6WILZPdudAu5OfmVO0j6+1nr+pkRSKsWSFfdpsBVX4+wmBjpRkocvV OCNt3kGgjFdjysHqzSvVgs0E8x7ZS9bmxCheqv2JaiZHPakJWOJ4lqb0x4uQDPtSI1DNoYahqN3z mVESlx8UWcMN/oOoYDGdAG9q6DZvg+nGhtiNBWfOE0yJ7f3N9VVjs4nQC/khjAs4DMDBZBQBqTXz Vb4jmVQlAS7X7SI0D1d6t+xlWWvQq31GVc8da5755KT1J0hKbzvPiqk5ClEKaRy9SWTChU4xmbCA sbETmqFltaPnPb8UUeIA9yo5qGa8MvZvNs3QdIASrDBSuDE6ob5nb2DSEVWfKUFJftBnzZh+kJz8 bXXYxFGGPKEZ3iwWLeQ3BOTnkZ3VZm3z+cws1NYqUWX5Mqx5Iwl4dE0jlMBZqVL7MekFGvhWNk3e QSM0W0E6J1p/K5Zn8PTJhJPwAIzV5d1fXk+DKPofZtJ6Qc7GiAc4ixlHNMlCOzTp3CAq37nmWFF/ HVzM/vzSKqDIgVfRQvWbv2mkmL7gKq2FOrSdDhkLEvkeHk1E7hWTtpInHU9KFuZ/nwoWMTT7iW64 XTwK/DzNpe0faGmQ2+uayl4inOg9O/7NOKiFwaVXrCZ6ajIWpA9rT51CXmZYRFt8XIe9oGFEg1ZA wOQrmKcHugU/yEK9cVhDKxQGCPInG8a8rn+G4MQ0/+3pspF01LSB8wCd3UKJJhSBzLZ1cYtkzT5S AWTfACwPO8rhlFY3orGvxVznnQNPoVmn9XecNLeWZj/C9OH/9opDVVxp/1lAVoFoYzG3u2tbeLsw GEE4r37a4o29bj3aH+NJ5noRMGnsi+tNosPrM75uw/GJK4On5dWchOiY32+oX+7SUevRfXEJs02s /iUYtA4XGFFzNhGeWpV7ukm9ej/zPyuxj3UO1afMIiDXvlOWPf2bJSOBJ0VKbSPQLrtK2NeCtPUI zz+7MfvBCxv7574iZ4v2z4+noa+4x1U4nEIOPY/PzIbnJhqo8iMHb6wxP6vvPo5/KMi8XlU7g4HS +xGOw9Kt4P5366iYirkj+stjGjFk5BThTb45883BMETufO3TaIYqe2nyBctSVzb2VJr6wTjB9fek elebm05sEAVU9PN5Mis8eNjRPXGxTH9FJhWCfcs95Oa2Cu5wEXNcLoVLS4cHaPji7TyIl1BG2mwu fdQB+1RbqKH9ynaZc7sAExQdXQXjk0Ei3SgJJL6x0U4++5AE3qPbfTkFzY8kl8bD4gWcj9pvB0mX m9o5LRpX/yeoKiA6ZNjCDbY1smLyLr2cGGBiH6N10k3rtJ+bgyNh2HYHwEEK3UZbx8MpkaSSB43I kMqt2EAqFCFX8qPXrsZIev1PDzQpiqmpKKoA1VHZxEHCkBYGkihlazddXgv70jbD/TtaaEB/bJCh 5RFtm4uLtOh3kcITiXi4SghZSCLktQbAWXGWogvY5N8XmFa05tr30nsKgR+Fzd9MuLMb14gu7yRt YXsy51zjK4r8/oZMeZ1IloqK4k092M1a+mw1dh4/ks9R4Qh6OQtpalSr6dSyzUpMXorzTDd14W3S zHhi1tcoOekHm7VuORmcHtDuo+kV8Y6laHnXUKpfcrR7qSVoqR+exa/ByJUU/0QwWEOMxS6eISXG vZ/gkDrWN5bnrffVjGEnCEP5d9BcB4ZNUvOP6+2huydkKP66mAezrwvb5mkWQy+gu41hlGMseX28 5vQitSCAq2c7ewo65IdkSQ2YpcxBZjOeOC6l94bxn5Q1eLlfOZ6EMcHpwC1PaAEYAGg7AmGObn3u 9Y3SHlNFijvH4ieTyf3Y9WspvtHbSVbtVro1ptdkXeg7gEkKT8FWSrA9luszAGQete2uWGQQtJNc Ez63v6Nd4KZCApldL4518pQqNHcThb08awQgSgIQvf78fgKk7yhbR/YiZh/68EBLr1B/NX4Q4KTI WWI9M3FcNtztWiikA5MxanA0gbR4QITcMfPoUzNPUh64tWP5LE8KqHCez/iuhdAbCA+WNswPWOm6 +lF0NbSu1/Ca/TICgIoTGxVTzHLOD5Y8X69w93rrDoJHena1KM1P9cI7gcFH3vvrOQD8W3dBdQaj sfnMjcr4XcGuj0fYYC5ZlEuqpQHqnufQlCNiw3npm5ayRRztgHhLiOkvNH1H4V8nLRxvGk22UjT2 XTMBZWug6Ne59CB/Jt4mXd/MJT7znTnlKfCPukVMOP/qgduJLY60Twqu/oyiWSaCNO8DVSQeKig0 RyH/AYOKnxZMX83b5M8qanA/efmxfX7UtPQ0cq2TMTaPYZ60xPE+rZPpPp9zg4roPeW6r1MxYjTt j5i4n0490RZ2qzNTh4PCxzRfz3xFQmRenE3KxauQ4ZxoOyZw8tgSkH3kEC6GnsUd93OEePyzw3aD PTijVdUaGr9hfrfToG7riJE7iIQvm7rzstSqkFRgU+cMUrfkKUwTiybmFLOrHRkzI7Bae+5V9HfE nFksx3XVL9VuqGHlCbyU4zC3EWUnfTU5YvKaPhpdWMAJbsM6OQkS2WD+WE+8ccSBUlRtad6V/1XP hCuPhRIJ/o7uWRrXBH0OvhZJ68GR1yz5yAiPU4t2UKgda2akXiQ9HDUaRQv8WiBs7B2M4itaLAXl kKiC2qMxOrSk4dtt+i9NigYtEQn6gOJg6Y+WT3GhUQCXGqHzcmwLpniA2apzKLWp1O7IfJ5ADRJ8 ZM2RN+oQ9y/iH388hq+Dt7vj8bRGvu9O8AQBC+FPT2AKI3V9QJrh1UFur8TN0wE6qtnWH+2Omdr3 NXlEEB8MByaZmFKQY+FTBMB6tWLP8eO2DlQHWuKdxjxQEn9TlQ3enjr+L1ObQEwt5p6V6hyit8ef JqKkRYrWx+OAJQBjR8oOssclKg9XpIqVgUrGuEesD0j0wb6/h3POPamF3xpOM9HPGh2hOeYm6U4X eov0b70THf4T/juz3QLaiHXbreFY72gXtYwC9QlUvnkGXwqCZJ6yt5VTqSxZprhwRhkMQx4CO6+7 +I41Na9lKnTCfx6RrEi/y/q4rSdC9euzZq2YTCY0amNZolGKBU9TD5CoxqmHueGkjCzuXjFAp24b 0rLpz6HnAaHv+sP2NSrH2pEf8kTAkSAatH+ukBusksKQFdy6BzbUYXcMqHuVZa+33xTRddcAgMTr T7NP2ZUICI1LdHq0diH4Aa4uR4E3czMSn+inVAaciBIImTc5zgA1m+IitCNY+Uj85DmLwExA5oky Q5dr8BhEi1si2R/JK/34vwMplrlQwaBgKUyMkvEGPCYZSy6YgZZpbTaONjiT/2hZNIMWkW5cHXGW chUjLR40yE1mtM24P+664LyRI3vba/pQc+nNHzPfbhg3dmW1ISPDJ3YoPkp5qjc8bQVxCSvuQFRo jzqqYBwFLb4NGzUITmYahIIuGa+qMaH4jZMC8YJd0HdpT2QF8V6XA5f4TW29Q7K9EYHJ0yfUiZPo /BHacCGzWo1SkqJifU8UVFT04Sx1oxh9YdvNhuoDS8QgH1iq68F31aL32eYtTgj7cXxPdDXOEnku GobBghKHBdNu0C+aAKrnUNPjZpiXMiqBsONv6UC44bHOaRkQCny3VzqT2qu3UBIYDnVlpsbxQ7MF LFz/8oi4sZv5eSWRzlCXkSi4tzQnFpJoGqLjmGps4cLY8xoH0Ag+Tp8YkpUfW8RWakpWobv0guOB cuRQhpMydsuHjqvlmi6kQWrK38uryd/DAcAo2n9J50FWyvaO2fJqTq474/TjlLUNSJgDwLjhpSxU gqXN6d7a6vlqPdasB03p6ZEhk1um8Mg/FBAwU4GmA0ubihRwAr3nlsaGqWtyk0Px7vg2Ygpsqm6Z ChGsNamAB1IxbFFCWdAmFSxr33tTmX4LW9AAvZ1NkRIw+nRYW4LN+Q7Ve/aMR8iOS9LCH/T30tDn spXtLyywwvhGrWdIEZwWJvuWgiBCBDpE3x4Bcses8QR9qfK64nBU+/IyETzPeI/2QDLu1B6uH36A MmmjlmhtK6HYxLC05CG1DmmfmWDAVz6BeMhgv0FMzFoE5/gb+gdP/GqpXC5jU3VF91pn1a7Qi+aq pLzg+9aAsdwZhktbgOypv7bNdAmRwH9N22u9JyIvQX7Du6eMdeScQbv4DVNM/3osrq06l6pnOcmY X1S8kIJoAEuo5PyoRxWYQ/88W0HqXeev9mK2xZlAWZpGXEd7QMxrUoPNtqBE0I2DgNdIaGf39+Md nCpASEJ+Hos9/XiFBTTo9hcvyvzmisyQYjDrGY4oeaboDDvP25No00y2oJUnqODrrV+jIWu6wd6B OS911xvAtgrA0cl0v161DhLbWB7Y5lKIGZHZ8s9zqlQuHOEjery8jSmV519vRI9VOCscGGPOFa98 7saqLGD/Pb4o4Ulvlso/fosAPLLGVVNTItRylq6LRh2Bmz/cyGB1ICb+8y2YRFHRU4oYBGkMeI2F r0wLvFTVGwIJfqlHxpxYVRJr+89FudikpWSzpcEZj0CXzfKgw+ogeV5G/hp+y5ConRbTn9LafxOR vHruab1T7FV39x5x8tilDiAF4IRbORzhn8xU0twQekhb+k/uJJAyztS8liS0SUBRniTgR5zIA8uC OOJ6zknRoVXrffYs5gRoNT8LZW+ZWdTTo6sPMO5gN4vqEzWrYV/X+NUQ/vjopx7hzgvAdy0DTSAK Au4jVu0oxcTg/I3gh6bgCGuA5pVa+TuctfguUGoQY48PnuSt5PQ86OCRHRHBWMtbYHw1e+NTbF+C 1s/9G28ZBQpKxOGA4rcE91CpvsmGcn0O8+bl4q1gO8ucbNAJx8NTZ8ZorpPvJUxvz1OuedXtk9w/ fqyc8hltzI0JDs1RrYqL6J29fCiCgreeVIx3bJC5CfGcRgZ5teNtQefMrpBZefPKt8elN2t4mt/b E47FySjWH8VRwtsg7wsIAvBHt6C/83AZFbnpklxRVYq7ECtsxdYQvG1evO5U+TdQrMyto/ULSb8f cHIMYtSl0kVkssNIJbCCcu6TjXlASwgLWzvP/GoSl4HQSZEip4Dnx5xffGIuKrv1oh8KSlNtoS7Z aiBmcEiXOOwIGNr38vIlzeeDGUx6dnm1rCCIK0KY+NzI84h5ZXA/X4UM/PoetoGYNYn3aUxeyDNV PxqxC34dNed8VzGLYoDQsdi9T6dUqqN7yqaV1RIINnQEohAxoEBGm87Q54l7gSumo3nRNO3btk3u y4LvkRNFsFQJImILb2/EvpZ0pDGRrjuNTUJ1JaCT/3ScHFGJw+HskIe2jwXxp/ZIVJQLfpsUQQMu VVJO6k3N1k8Vt8TQnNkve2Sw0JspR0RtUtaBJr1316NJ2/V3HgChn+6xHNkF6y4SeyDjw5stHw2y 7uq+4Oe5AEYevKaX8S8p7gquiDAcq/oER0Bn2ny9YLHRlWxwx2yOH1Q9V/EBLLBYdV1XYjFHNhki wzyM/avzcAQOb8Heg4lrEF13MSFENoeAJNER3SipKD8AAb7sRvEiNOL5EXY2hhP3p1j3M6KGM9Uz mx6Ow+lf2WFINgKO9CmKaBXCzTnSzZEiYk2dQkbNFweK4/NRQAdH7Ie8oZ9sbIGW3WobGBORYTZe rNVBOn/912gRembKaNe/ingvvFA34MESEyznEM3zLiGNsU0zjUcEz6g+0TPtaqg42iagu1OV84n5 Els90K8//NC4F90CStO6ZSNKebwMksRbYH2MGRPaNPJ/Irk9uf/jLR8nN6uqX2TyIyH8CxcJbVsB LqBADeFxH74DB+8uWvEaXWFdbIRacIok7YICC7Z4RD/snDb0PDtT8uMoL2i89qRCozFw4X48ze7L yBiEp/+1CwwnYYfNvQwUPfzEJsoviQ0AeG8OsDswJ+3H+LBJipDfN8u02bILLU+XWJ/rNQWYxWBN jML542R/VQRXZlhRNGqzADgk9KMkRtIIMT5oa67KyAn5F9Ki0gU7ZNpc94oDToE5zAToARMwXste hGQ6F3MAr6KS/zXrTvWtoCIGuZHdcgkNaPLmn+Pi+E1RfK08FBY8EOhbEszBKEWxwPOjflT8561J X1RAcDtPx8IMkdgrkYdsyvuUrQkiF7h7cZzOTee+msxbEq8g1uZBiKAQKOaxI1Q/cWltRDXxSpzF 5JSvJkR9sMyZ8822fs88pZPfaIdNb19O2ft5Ymgbf1DCv0U8uvrBy/EG5+Z6f8/8q95pfCTb4UIA opzDqxQmwT4ao4Q/vemqJ3I52v0h3RnrZ1dOAk4XrcTyl4sCAHpPBCM6qGAoTRDeJt/a/2boXu4z KH6bfFcKp4rtSdl42HMXXmRV+Roz65Q3A6lL4b+THqryH9blEgHGTn1SywcAy97bUP2MPCCR8+PB N/RZ4spEhoMNMbhDvilgrqYMU4kAMjLcyaTAd0F7h8wfaPv3+q2fmr4B34/vq/YP7moik+jT8ULE 7Dc6zz1yqXa3EVGriXhbDU3VYwjDeuIcRo9Ge0t0jvu0+8k1Tkj8rild0ZDZV5zxfAJ5wxN8nU8K xYNXVpS5DCVPjIO9iDky1kQhfm7W0enV6D4oaMNWsFLXEOLaBoZmwVi5tWSsj4oKLoGjoMGTYJWT /i1YctaKrjHKIY9VM1s1Gx02Pk96O7Yj3SuNtH7bEoxQ/1MNfQnJ3+CvsqAh0riPvk7DHK/FGesT DTYlQEmSm1YPfPkzPSC4CJf+csNITUDJnlML66s4EsOhIJv1LC6HWlFS1g1MZOAkvzemJ1wZNx15 e6v3REmPHrl8/fDqb8Y7XjNneL60bcdZkBs8Cgp/FYgDuPBJRwtLFM5ZUYsIliBd+NcEcFHZ3usz 1DHCz3WfNIVDAijSyv2oAQifGgiR8Fxgxl+wyZVKblIDVBMoztlBHbFtkoVUBjmiT0frikBvNb2V nNhUpsAl0ttrxRkpJ3vrsvyTVxl0i7aFosVBgejyHXLIjUok9kAKVsaLlFe2UTuD21qSn7qTNKew FWW+R0U7sJzVNkHNypYJKMV6qvWv9y0caF2wSl3Y3wuctvfuU8AYnU9Z+oV5sUMtif96RjgiCTYm n7Yt7xmuXQzpVyrfrxNEoD4B6T+frUavGlMvKGaCWZ6MqdSS9CcHm0nNikQGm62o23dTFUwbl7nD D3srP9e7NGdjtNSS0mm0WWn8wA/zIgWr0GhVx7EE0MKxb8YoBrmYtUB7y0tN/PzD7oZDRoKlAhTg DT1C8VJTm1Ar63P2sUP92+mAwieZhTx+u2fgr2/r8URnsSKd4AfEhZjoIwvQ7EH6sgU2+YwHKlIE 7gJMip45VKqJ9oFKit+K5GMK//yc2eyghmr9wag1BLgyWsmbmEsfYqyFBeJfyOgz1F3Ys6+aXDC2 NMV3mCzNiTp/Ylrjz1y4OsYN344EKTcOJg0dgsBjeR5KWrelih3UVBGJaQCINe7or37Hjs2jLk4J MxGdTJMe2lvVy6zMQVKWuhINeji9TK6rwLifGzg5EBGbBiikTp1mvyH6JJUWKz8VdTdKMY3V9IVj INLXMn0GfJ1nM0dbMnTnm5RAUYrlT3t21bzCV2SUjeG9ihM5tdK6rznir9RlTAl/A7ZQQdNl4v5I Ye3ENyaeCQsWxi2B+Tssj8CmGGotlIil7fQbwwXcvm86Z/lyxh8JA2e6sQRljoO5/To9ohyS9Poi coW3q2ijqHcsJoKYsB7LZLI6cK8bDrlEdbFueqm9cucRxDaX0kOKi0ejeKYob5wkqc+7lywEXpoH EdgwgMVRYq7iZ34dEkMmJJ/qR89ahv8xZRSOIFSEXBiZ2XpR7i/AW3vg4WH/DSTrOFtrP3U5DN8a G3WxZ783f/FHZ4n6BINTwnMTeVcK8zsbnvp+FcypfI2q10I4oY2NrPlPLhUszuGQg5rgeiOtYzGq D4OJmMCdQXc4Pji4SBCZceObbjc+xIGyV7JTUmNaD5kzYyTgppWwIkWTHv+sSJYaddq5nd/7lG7F ihTYU2q2b/n3yIaBCVyIdUZhqf9XBEY7mAH0Q5tkcyGN7ucbyd/DJm31kTWmudZMbdRdRr4O/Aw/ fHKtLkpoN1W/sdVRfjNywILJRZUl2kGbQ/kB9sYJGYwHsNSF32OuRBPAZoS/QomiEMCccO1+RwaS Hw+yX92G7Tt3qcaNKe/6EVvHm4SLrDwXo2R18+0HTiObrZLwPJ2AVtA5ZWBb9KA1x89KVLQfmBqG dW3ePjbataSGV0IWPqs1iodHFOkBKVpbUEvfV8/fGBbI1llpjA0vAbWulOO+hqsZFku6SNr11NrU Q8q3stiiTh7FC7b+3m/GUUZHzVvu0kSFGdk6kXT3UQn56cHDXkg4dRxKNXeyMcXSJKKspMYxC/eJ CK9F9f3Wf1mnIHizOo6i8nAoZaEJZkxI7r/vhY2GqMdA+jrLQNQTR0PWVw2dI03/OKJp1RdLDKEn 0RvQv75KJWO70T1Tr1VdTGEOFKb0dPlslhVVFZt/cNQn7afIDzmGhNzcumna0vNa6BHW8lur9vIw m8qzhxhIzBj854eInNDzf0V/qDLw2W9YRwO0fvCBy1l7SJNMWM6CQXMWmn32B7jLIIyQ4WfuHdsR WUVj41WYxz24PSmN2pSF8PtUuS8pOqjS+IYdn7Kk6qAzF3yd5ovfL/sqf9umhcZ87yhlAKKd+5c8 G6c8q65qGXEsY3dILqnl8bzyre3fQ/PMvHyjQNNxQIeAU3boQYYl2bwXpSXS1bpWb8UaZyGONfzH UD9jlLVIReiy3KjXxsrdTSAGkKLJe7hYGe8vbOR6XQhVrT65A5IBWnkU6WQT6tX2ITiYdB36XwMC t6xO8hsnTWCqNXcQqniAns/dk8297f1HY1vkN40kwBMK/zbg266+jtUJeUUuPzz9ottpGSiUmGcY sYqbbpm1d88Zei7s9fxhU1Gfj4+GLfmFJwWrtScsYlCnOGHJrAw5VRIaw8hfH76PPL+eeEbrzKJS L6p2IvmtuQ8PVoNZh27Ny1nn0qurAxRSQ5jT0mHQ5JvVWFsP/4X1jMRfNRUSHyuv6TnlZMDihRJc qiqyeh2Vcd9swlw2dduFOK4bPpEVoU+L6L7cDF6uvcBFI4E+Pf4ElY1QLAiuneAEr4GgoHRnPvA5 1wdgp7hlM7Bd6NZLeaYlEmo3EBmi/YYqQFz9OonG3Hp7T6JIuwt4Zy6PIzzyIEEerB2dFnqwtvkm uFjz4qEr8AMbn2OT4H/Jv/A+CwrNFHb/Gc/iMJT+cY3B+xIjx0h/FOYy/tGgrU3B8JTZcDAxy15w 7RwFrvVijzt/0zdNatTXHz3nrpU4byhLeczjCc5F+qGss8Is0416sCOftSEo51Dny5sZaplm0kdd XJc+/uwUBUZj8yYpJZTeqsMJAhL3ELJX8OWw2VrSUjgYkWTLKdPq2C3X942+IgaMtHnOvylvNyk+ mY0eqFGo3sGctVkiBVa1Tf/STeDKKoK1on64plmkh6oa/jbEXGYog1f04X2Cr6FOwcZlGEkKall/ eI5nxPPtP+kR1n1JNu4OWbomAF6vtgV2kjmbaIp9doEftII3zYjGgVHdYqdrEhuKNFtaqZqyNxQP M/qu9+AY9rO25Yn/VFAjpzslcyIF0etRZ6El9BbaEUSRVS2DhP6ruwO01KenTNNNKm2AFx2+plgq zAf7DvKrFYOFqc0rVG3gQGGS43QXuRPhey12k1MLkgD6ZquiJY5aaR28C8mM1gnPhPRLJ7Ytks4p aeNvjlI6pEu7WGRm73NzTvMm/Zzq5+1gLeN3CAsHsCExbCv0992rj5afSH5dWhZm7pArEb9U468Y +jNnSTOmFpoKGDK/mAISz5GoksUjXYDTznYBsrJ5a1xPp9FgNqc+v0g+eUxAm+aKr74hsgMS+pX5 1Z5KH3kblmj5R3W1fPNs9MYm3iHA6tjBQ4Do9B42BpLErmBApPrbWhFTiL6CKpy6ay2d+l/cuKoD YbO6eyGVYF166mmToV29WqaF2bFE5YeDqIE/lTyBIhfODwdka3WfcZ6jj4Dex042YbZBlnguxDDc Hz+TAyaVUqp6zgNx9mx6TOYKYQlpK1ewwf29Dv7xbVN3mQKHHDHJl3LxeSfEfZb2t/2fD9Hr35y1 Ck/rYrPKLzjv23O6Cz96tYToRcduquGI1HAxCcdMALXlXOYBFp+86ZDe8KmFxU7ZslzJQu9MVU4a ERv92m9XhY2hzrBN1Umw0RNXdEOKGUBDwmsM7sTgiaC38uVMcicyKuZi3dHscL0kZaocOcapZcvU C5LQEuGbRFcoUKLDWkjuR43MnUNsN0EIFbHMj5Ci2aWU7fTpKZV81hhZCOD3dtfzGfmZJ8XByfO5 5E4gZBaqe1bRniUjlIBHCFboLS7EL+v7cMOGS3sxPcLHS6xNCoPmWtX5JheLg7VVOWv33yAxSklY R1eSCFR9IRon0PSD+IW7Q62iu1cyOryV5dwrGZHZUTz45u9NyV9/dkFFu4H7Ni5QCqo0oH1FcW9V TBRe8XgXwxindrJoXemhrSfsY/9c3Vp6IRuHOeb0/K0I0bfvQFN0oUCgJbaCGEJYz4s2masBTymU ULmZ/cNqx8xmzZbNaZklzUMfSUu9rBO/R9t6V41KWAwsqJWN4O225cdKnxpi9dcc2XZszpC0yJVA Ge1130PZxWR0VkmPPulzNVasFV+ktkVi8EhAyKiRQx/IMYwEIHpZDobuOSFznDWJv0YgQybMNFxz S1/vV+6FahOtkceHrZgWz4ERs7YQ46QygXLIekEvYGpC281ArdFYIkMbhu0BWi/sc4FM9y5eYdlk fE2sASnhw0AldkjDv29ZItK+ITvjadbufYPETKmAYQEVl/6OL3x1x4e2dlslzW5HT1zyj2AhxbXE RsBxt0y7gplsSJu6/K3l7vKjUUvjS/aSajc2uZIYildAkWLVWZv11/b8NNrGxOpW4gOjLYDVs1RI e1ydTSuqa7Hb1ifo7ihGaY+tqHOd6MoiAkLwwcJAPqsaJLFOBR7OmFR/GTOxWEdeOFEkJpXIQqny Grjb6XrDZV39VdaHYUqO/buhwC0arNCr6G4WmQ8TEnEyq69Dcg1u7dv6EMLIm+69mZLTG/uChelz xrTQdTQT5xh9Fv7VJzbzM5TOZ923yZdXkgN/yl6hWH2fetn1lOad7f5MGlJ323AZ0fjax2JU3B16 M5Fw0VU0u1/hD9aWSQqtpty4+2nx+mIbtfRJQDQaoULuzhJkV91z0tKQonDwmol+2RmT02u0SQlQ SEl4Ii9I9riU+8WUKSoErNS1/iyQZ+jcpmRdKj3VLNz2a7XMJI/7SuWCXlXepK6ehHwhm0g87F39 QAiMi9r10M8ZSUOqoy74YdvGSb46ccGnk9tB0RlFMP7II5Ai4B74ZxI/0SOZVGF9kjUg3091Tae9 UWhdMy1iQffFUJsd/1K0+B0Vx9Pfpg1BNmI+mL2ATMSwcGAf7Rd/2i2WXM4kttu5yQGII1HfQzXD 4lOfK4bSwWccHzcmytRKBX2/GOcLENxeMrAODxt1k5NQ7QixlIk8hc1lKuOCqLeuwTHsON0t5BoF RL6IQjfDzkK3XbA6739ts8Z3xzgZn4s/arSttDBPLR66ISlZ4hp7Sne9VdcxyZADW3vwy1oCJQr9 Mj+cwEyLJsaABOVLyVdO4yhtcBRM3jmuSThwy9QYAA+1LMQomKri6tbSulR8T1V9gFOIKkfvdfMa CD8G7fLM7RFQDUOSMG6rcjJq4J4gGEmOaSnrNFqGJRphOLOx/WcBiO0rSaFglZdSfUfxUICCrED3 EttNMbqNQr06h28RXamc4K2v18zDK4YLqgYnmmZSgFaIHboa1PlMLFo+gGXCGHX+8vOoBzlqofOO jUtMT5XfXfShctkQnr+u5wA7trd86EV7mWPx7ixtT96sLU64rsw2LOyGERFp2p7PS2/aXdmvo9Xl f7Wfg1JkjTv7OeRH0PZqgQYEdDT6aLdGS69sWN9u1FuXRnVdWDRhek2sy95rFid2p3tNMsGsSMVv dIELkAhZkMh8y+lC1TCS/diu6vXCoY+flcNMd3z6vCLtWpgggbsXhWITawfoNuPfKfjUOs6jy+QH WPWCcwCY9F7LMowbsVTZPz70bgt076jYzan1UuvCzmmVCRxxknVu6ll4/j6RAkgazoW7lJHFXU0o +JD8UnpWs928VO7+W/csCxVuQicGStIafeSOTcruCv/gPRQxEhyPMFt9OOgqUxlVcBDBKwOdMOcz 0NbgMXpZAXXE8acsXZODCAQ8J4ewNkf/cCzQst+NVLS8y7UdfYipdYaRDPGPmLQpj0iuvXuYgK5R Dc91wHJihUcWUcsfDNE5fbmjKONlYfmI2vTicUkvDUfx9EOXy40r44J13uL6OmrLAkpG0Y6WCwRb vg/vZclt47Zekh4pv9lnmdjsJz6iL+mHCkAN0fPGFjx2j9/nhsfDo5zpHIQDnbWl+mFnvTWZtNdL xAInHhpCxiLjqNoGRETYGfnZcn/sPuYFaDTiTy2hVScReqBAzwR8sWePEU3N5XI5mViR998D6DhE T4+9yzJRVoBPGFkCb1i7wX3ynQ3U4jePD1hFkPBtWRkzchng+ZcXhSu9HeiWuiY87r/5cKG7iC+n nD0Ct8mxoxQqDXvcnR1Gy10WdVGy6CFelZboPsXTVFo8QgiCtyPOpziPtKu4GdstEmW+GAHGSrrw D/JUgx/0kf4g1KVBDUT58jHhrSSRZKfW6dtXeVfNOWXde2PhG91NZ6HVNw1/ZsEfdvp3JRNQLYvx sePmNP5Q9b1Kz+rmOFcjMW4gghuawMwPoXVAeR+Fkt5VqDdINa0FoqKyq5Oo2pclP4wJ6/592MpP 1zZotcgYXioLqO9elKSwp4MujGu8/wZ0VEagjTuSBOVQGfZwHnoswVK0vAJZAIYkkdXyakVnMxo8 2RmoXwY/0W77TlCJPvVdiHTIg3cOZhQRACz5wx5tbU7KwyROHu0WBy+xPOl1Py/oR2gMqqDyCmxB 8RNY4it20Fj9wIHlUOPxaOWe7PdRYU+r9fdcOWLdwMlcVPauylqVZA5p0R0TaIUJpnSkCY9W+6GR 20rxJqn+r5880jKUM7LdSv7Ip/gMB1PpD2FuVCnwKxqkMSQLUxb6BANU8TZ13yx4QEIuMAZyYMNW he+NqSiNRF9vnr1uaTD/NqR7YhnIhC8y0UvtDuwG0B32hEiNkLCGit5hCbCMtvJ7QBjGoyY+wG0m MwTzaWfZ6W+puRZA+CnQZS4yzeF3DGLF+GXL+65fPfzya/3+FHkZdlGWztQYQNyLj+1iQB/5M6DS q+Lu30w+q6BJ9P0BBH2jlArmOkFppf3cFOp8eaOpKy29iewJz28DQwqgyER4q2zx+/HnufoS7Nrp EBeXyqjTN8ccISuTdmjOduscZz+SrwvR5ggDQOTMbGKtOaZfQJIngVBGBhYKi5QZ4PQhXcX2N1rN 9+CdmNA8QQgBTkz7K15mmigXLWKBUvEiYBFW31mLm12S/JHoLAYfhFhtyQJlGtq9JCJPEEecnn8e Mw0g3UT3T9avW3sXpS+UH+pmgCzqV+yTr6mFVLNUWpawr5rv4v0WS/VO8iED8lPRFS0ESNCsxvPs nFa3TtkhyLWHQWsxhpzlhyImHrxS/eF+YCQG4zQVMh/JIQmmTsOogUV4y7W9zlUkwlCKsf2Wcbq2 qV4wBqxSdSvdpE8diUxUe296exbto0jukPimez5kJXRhfQCNFK0iyWhvDy64Tu56iQOvNli2cp0H z2WjNJZ9lE9pRV6SIlF+nueB5sk0xwSGe3rlvznyiSsX8bnBeizUrkyCpMqCLxsV8SLWq0hRao93 jfPdZh6Q3JCut4WPs2IutjZVaL+ueVhO5JYnBXNFDfk13t9lQsewfmbvi8s5vHp7HTg/894IHdSw fDDtSWB3E79nswD7xhA4+ltyEDwGRtJApoZet5BjNVm0tkp29P+6Dnc9WPnZ2NdLJP8w/t1nFNsE EorgwK3zcENjjzQ66h9l9BhhUsXMptQ6NBDWRfpC0QjofZVVwDi9qwPGc8TO+A72LVrfpnx5qUYG vIAls9oYfouIDVuNho7OfhwCSBGLWF8rESmucR6xhGaPd7CNhaTC1mAJOiPLCq0px0BhojKkbdIy tW5hq8ueUFBctkMySC502/tN8SL6KSPZGVYq6JfNtIBhsVVcsQTea99Dm9bP5kEw3BV2jl0o3D/7 q1/m0IEb5Cictw1pFNLUT+lXrJxULmR0a+9+ZOc8T08e70aqFBOSZTYsJjDvpBC9BWp+wlRHR+Zn h+8elTbBE9DiasZH8bhSLoQTnu+SridXP+dABxCLErjI2bvJCcYmxzmgiZS5AJbHETdnXnYLh5JN OT18uvWFilT9gD0/BO4sm+Se+SUXFUGUa/jKHW16/x4OooUu7HKpTS85Mbswo8ve5EUcjgXCsf2B gbvCMQUWU1BVwVNZmdjbBvOY2FladeY2rIL5Yio0EO+939Ui7NO/re8UDlLLkJauUd1NwuBH/Mho MN45uUZ1Ojba0hlXT+c+VYpvGa/bQafORaZmAYFv30DCIzIg87M/jw5a9HI97VJnIeuqmtgQ+Adh r5uTJ4j7gyBd3kL2cGbaGkaftUHR1jMjApMiwMBg6c/+45dYyV79xBf7MuuiJqt7UZVx0GYpB73b VEzE67tV0tkIjVgvsjFQIrPf3ekMj6ACNBqEOgh3PlZRNYF3jesN7SW27KgNg2Sm5K+4mKSny1wh F7qk33B2jquEoFK+CihFjOTB7++9gTs4aExdVngamWOtzVlPGqsLuSy6yEiOpLkyMDEtefoOubnn MTfelLgQQ+E0TV6JAj95l8pOhzR17owPC+wKwBVGR0hYGKCYEHEvvSb2uqnQaVf3LX1cFsjfNuWx K1i0ujvRMEHffJ3V3Id/353c4kF3A+SnGcEftXAgfc5pc84l7JcrORlxpKP1VM7aBHV1BRtUSqmQ dukcR2Xv7CDuxfSIwI1YlPcHBMplfIHETSPIOQAgZSOUcNMl7rVhXj6J3qK7ZS4LSqA+wowzRxtq MXE3O9ucTBVYujB4nte5AIybnShOKwCXSOB2I37MeCICbDqHzliGaUgORdF//GOG4zgfsegWnTDz k7arP4fSEPeEcqTIrnwDIbvSr6fEerFbUmcHLgaHlJq2ASy0GlCqS2fgj4hTMBKtTbn8/We++HLn Bp+Xb5jTNNMM97mzgBqRZgJPQQsuEQ4dZEgBGQynptfo9XOeGq/viYXDCPs77ipq8AbgXEL9Jp8X OZQ9FejThsNRGJybKqjWCtrB4MGlWHL1OtFkJPI4cXUHwBatGyN8Y1brfW6Ayncbe4U4AcagTBBy IPEpjEj8fLJe/98vVDWmewC55uxd739taVNKRTapBuwiIpEeIhlqlnCnQt6aDdqo6mZhm+3AfIpU Il8Eg7V4jFcREaEuHJb8zcKz6fEIwVuVfdSPGb9LgPwIJ7/Nf5Uq93Pp6iRahgOMmHIcozRebe0J v76O2sJ/C5uvR66+mygls+ihMnSBQeOZnpSwB5d705I728bdHj4l8bGs4eIGPdr3PwwUtTKOxcoU jYgZ2A2htZrPQ2c6A2t2jDoFcW5uj3PKfihoDurOaB5t5uhZxEHLnXU5Tcex+ooYWaHFFgc+iPOn gb3YawDWpZdF7kEf5tcq7wzJDSIrjS0EA6wjaxgkzK1xthgjGF0gfx93Bwg+ePkl3ShZWBqlkI1Z dazv53lL7NJ8sRSUiuRoqC+wY/W49ZSrTSXaePKc+v0L7VCu0AQTmBoFbAZ2UykXTmrcYohWu5O2 vr1pixZVeZ/5pW0V2ZQz6PIW1awgfs5HH7UQqurc7nTlus6cbAVTIaJt3g25UbLNyjmi5yGVYkj9 HtDUJn02ujMaSRqVygdwnb6AGn0Jf/ENr818ZF4PVTRupsJQGx4MU+mMu8qCqMf5ekE9e+WQ9etK UUgHSoYq6oK7/EkMf3hck0NeG1htBaXn6dxo7MrbyNbo5OVriNn4jeNIOJNsXYmJm2rby6oIlTdb LQSlXNkwRIqJa65Cx7DRABZ0vFpVqNeKP4XPzMaBsw7IXnZWF+V+c8GCwFkfSCfbppidAEC37a43 C1kCiaSoO4OAat0p5IO7WMnJazVj1LPjqOibk/ou3aWi1gI/NpWl68nvaJIRmh9Q3ebBgJJl/cE9 FFfXL0O8YwhJrZOtU8DaDTxaXgFU/nJQ/oKHEuy0hpgFVBuPkBgSCjhjHfYngCnNMHR58yfdHbww DWH6hrSyh/SSZktiiwV6ruHEV+NCTZmnzZt8NY1Nlfm+xid4/nkJwF5b6aHHhESFWvIujk+y9LKF +H5JZ6kpPzVd4/3e1nyw0/dd9sdtYIvT6lqtF4w63cpKDVODyCuri1PjdcG3X9rqQLWzCUu3eLYu +sMu/Js24BgdosdlWqLAu8r+4tHmnJub6ersrpHlPcvuuf1H/HHfHYFrF5motMr23mKZGO3OQMBc KPeL9lybR3R6oWucnxAWKK3gJ4QqWQthUTenmoOjsNSS4ekqB4Mv9EaqXwS/UoTZPvRIBKN4psh6 nNEDj4/6zhx2zGVKLz5SE7Nkb+FZdCk2qttp1U6lpOwDp5lI9o2+NOhDgGujyJ9mNWDEpAvgui/M /E4nT7+CyHiYqADEeMYlx67Rqspr7LXPyxlLSATZJq6D4yKis3fFbr0FAI6DatlYgvye2XlfrtY0 ViQiFT8Qh6M61QvoOicEXqlIkSqVznXlL+knIRYH2P1fwoaBvolNJTxw92rXjB4cB2Vh4RblN9l+ yFvx02PrglfqPOvleIoA6QZmBPQxUuiS0t6DXwsy3tSKIpcxhdvwq64DIoRKSE+ABh6v+OJ3XWVQ Zz9MA4UAR67Wu0qPFlJO0jzNt2KN2xWEM6l9g7m/2NanDANCgeXedA2/gWNMR3K+Q4zUTOyKgRYu gM7SqyzyYRtKi0EqeYd/M9BwvWYpAAhdRACd2pRN4EJKxzDkUfg26oU2hHryGV9Oy90wlhOWCWOU M8wmXJfmx6Uq4OXPOt+FdLsyq4/yW31hbTWcSY+9q3ab9B8eWQ6r1NjtPUJFYwwkkoJHLAuLcxCL lAM8DY+gaGT9f2sB13NQBdNSUx4pg6k/dmd/jC1S81UtbHjflqQvVy5VDZwtcLpZYI4afNfA5ETY Tmxv8yIwd3XO1vnt8JjXYJ+HiHdbTETV2o81cD6TKcaIfbCdbTdozqzxQNe50QITkH70/B1Iame+ qLDwDST4FHPJ8RvwgFWweDxz1qhZ90Ko7NHVuE+XjV8XUCDxCP5A+QoM6lR/RMnlS4YCNdEOLFQ6 LbjBPDsENH6d/omViLnCkSbj+EtEAf/mPqu19vOuTn20UfR3ZQ8MsHgV2caEfBHnjpKGOwJ31y9x 4615FqV/9xovN1bRcOqC3FSDuh4aUMiE8ziexTxt/ncYg2xt1VE73CsZBflEv6BqqiPI5DXaKiEE JeOI9xTt1w7AxlL6wNrjsePG6w+qM3lt80H1rOXrdJr5K6lojh/O2ZMquZ0bfdpSqQ4LtAGZpUTP lZRWhm4sQfyfQBUT0inV82akMgq65YR8OZ0dAjV7scrAKik8X9Ro85NOjkV046pL9PHlOOhZYD8S bKEXodZ2pmK4Q+/qecRLIJEoRAegNM09zygW08xyVoxgyek7wA+9M/f7vEXkg1H1pwoNkfSNQO7f uiRVflomzaUemDUMfIpF+abixuWVz4/LJke2aWRvP3IBseK6uEDsz/yPH9wFu6J9RjSzNBNYQTh/ xJNWSYlaEaP6pseWj+KfCd7ghh6DEVIxbUbc1XC2JOtu4Wxtbu0ksYPR55pG8eDcBMfy/pvjCRAf txvsICDZBGP6Fwu3jYaap8XL7NpguDxDjj+kFy8YkW7te+B7goTSU1UX3Bsfzvv4X0ZP0sSvxmI4 hUyN4olGii38Wgk9tslmWps/MI5s19nNeC3xNGjHklb2w2mwr7DpaK0gZ8XDEAGBll6Qf1SQLBuc coZplkLbpMdC01DJBIkUwR9alKNyDaeV5bN/Jwer4lDcFYqRUdiT/tTtzMXTDHpDakgnea5ogedc b4fHxmYM5nCIK01QwiU3NsRk0spvwFMH/GoGLBQspjWbGfGGqw/xayeWkZ/79OhmJ0x2i5JkmGAR yORt8g0nKPeG7IhJvKzjcQXmIF0ZaRm8j3M8LT/7RkFzEFkVkwrJJX676JOuRzgbwHaLfCZfcS+h fUV5N6WDSnwAgXP1V7HN5PYoWcWXIvEbTOpiEX5ec1R0K3SQ0udv9YWM0DS44FAAxDgKCVTbWv0C oF4we8CdDsEghHAX9MUb+7NuS9bNp2maebyWv/+GYvM5+FEfHdVfNlxSh/Kw6QZQRLdz7BWjr5Re hNSEnFAOvrhdrU2N2sHnMJmZM8EkFvrQr++rtRTBu2JCeULsSwl3ehIq5vCsa3BIuj0MIaZ4wUsE Q8iMkE4tAsZ1dx4kDgEa2sgfX4ZJYH0Fh5CVrh8f+8+8aVJ3TT9DvXiKzoe7JFtKQ6qW0C8iOzxd SYftYHqgjc4tHYZNJDs8yRzNVl02r6dOglridQSC3IPjQtDcZgrUlX0Tjr8r+ezTL4zCBkCfsM4g G8JrF0tTa1zuXn9jufgfP0Bo0mVMtsRbuWJrlANrHo0D7dV/fccM8DyXgXVb2PpqAGuV02XTxnBG RJMMyWww3DfIwT274QXSfpjy04HcklkXvd8mDXW3SvzJbW9IbFiw+Y7EsHm2dz24qF0gDxCz37Et EL4pdXq8gD5zh2ikRD1FcvAHFK+TnqI3YbbKqArVw87cfya0pw0oN43iAT6JkabZ9I9ho2b3BGJR 8Zmtv3MYQmHWLmBB7fxao8guam/ivquKmOdA9mVxu3Xd+4NriYg/aiKoQ2shHsqj2VO59q1GHl44 lI1bVks/AQqbpUN3fm0q/U7njM1nAtlTGXAwqbRP/rzD+MWholIeoi+tO1ulZUtYpIS81HhlxGpL sBBRB4fwO38bAxAMq8oGKW2beUP7Ey0eenJhZ3PL4wJqIRnsodWj7EsGvp6OCLtXAcBTrAdJAAOZ vH26ypKp7o0BcbOCu6fSpy/VKSIkmfhdWyT0PWgJbFzBLnwOzKjYIguAUZl6H2Eq4kEgB/NbmgCs nPApK/lhdSWacFAh+Y27hGXwxDlEm44zvdsnYtc3hJrZescAfpK4rUUjwqACh3SbeYa2fTgHapK2 7ZCkSnPY2TkvlUEfwN7MuDZU6d6P4q+LROGdvsrZO0T1MUjyQsp4Sd9zVFWtK5ver8lmq4LIE8RO bCKlEXna/HNpdcHeiq+Dw1hP056SWJT86weWkAeN5XKxAzt1EDIcsundJPJ+g9Dy1wY3YLRdw5gE eE+OujT4RYgMyVWFrwCLt5G4ati7La8K31etk7kQOc5yjNPPDR/FPFcxmaY3645KbG8jypDxU6yP mx3Z88zR75eEIcHD49h8S0h/H99pAbZY0ntxE+P3cCHlOgALFWwdKk1XAMUdc6FSES1JPiQ/ioVc D5VHBWfGiQSY8pUeyyf21lOGhlbmAx8LXUyvsP7qwhkHfBGzKXG7Tew4CKGrKNuII6g766AiOzPp mtYwgtinRCenvd8P+FVXSdh2sxFZtI7ujHmSyH/BfXtBawHVFoU8GZmaO1bF7GHRGOewzjuceInc kW78+O2xWmz/g6Q/fHWQcuttNO5Y5yqj9VbO4VNkYEb8ajQ+/PcQUNKfp0/EXwcjUJxTeLjvK0H4 G1oCIbDUzmJFbpivCNyK1Pm4kIOKoVGhIHwxLteFHQIXCrwp7pBZdBGvWLy8MZFvcABT9PGOTKH+ X7sGGQKb5r+uIEm/ADkh6sYbo+a/loDL4gjX4TZxCJMvJr36yK/Xu945HX/+hJH5wlTPS6v0lHuV kfAUxfmnDkqgvGenHeQQ9YXw45c/ogTYkmdyqLeoXXENSN/EomLsMjvYrHQOh+r4WinO8SfzO4Vd yop2jlavzIzBYcf2McuVt8nwh4NTcueyCmHUhuENSd2FfD7Dm2YwE8RQu+DxcUCbPphKVk9AKMPk WfNyI4/PY2g6jKgg55WAWuEYtQ/vM/OWFlqDV6FDHhR9SOMi1fi1QH2cPb/KHEFPxKYxZcRXjAAf MjcINQJKikIOznBrRxbwgF/vs/vFGel4M6RWDMurH2U1P3KX3Dt8AQDtYU093lKlGOFtLsaycQUF 5nCp4++4V+L/4Rqt7fahRsJ+eid8rFc4fYLjJHMINjvcQYocDtKIYCN7fT1KJYycKrbDpkcSqana 1f9S0r7hxlwjFMuiOJddrNeUYXQovPwcp9r2+Z2B6SI50D/R8Zm5DY8BRF6TXpWrzknMELqb44wn C+SCuI+Io/9MCWc0Wjcu+qhwdc3frddimJpgP9U9SXzWARnwDVjs3tFGsbzb+xlubYaPqr/tlb4l CQxq66Ufu3G7mFANjsy5BFb8yuklTP5N4PCwXLMjyKPiqSvu2u8dkFakpjFSKQi5fExXicznQbKu HgorPWT88aFQpeKCFR85yv0AUbBAwrldZISYUNml6CDqhB855QOLOSBhDfiRo99OdIMpEguZXd4H ddIMghKytAC78B5b4pSg6Vr22q8aUzl5Mj5kB0o2DEAi3sRcvHB2y6cMmYg+UioDfU/R52Epz/EG P77s+aY1b75qCcAmXmwLrwexiF326SvsOc3Wd25T9rfI8z2hWiT8CBpQ2rHU7v6WZuLyx5VHxUba dhl9G1Gajvu+Q1gn2dLzDLt+DuHJ4AtNnd6gtLIs7soiI67E1yRP5C15ZR9f/w69CDSGbvAhxpZ4 fszRI38/5Ud11OQ0WMqPNry7Tz1U/cDiWtIT6qYtePC3aipXWyQD8XsmTmLe8m/YFZziUd2Zp+8e A+H/Emv5JLYozvyAUZZBo8y1FuqD1lJfz2wekjDAX77uK1Tjq+3tbZkqzmztModmiwzcoqVY6Nmr clPRud1vVTQRcQ0Ni2CHHSAbKHwgS5IroSOV166Wd8hri+p4AK0ZWyDGHT11oDb8q9icWftJF3Kx obmR1sw73XNDMj8kts9FDOkjR4NFZHZMiQy/Q3vUQiqUv8tryN2Q/NKAkBGrW5ZlbRMLDdcphYMl PfUDZyr2nPqqXs51dtJ0zTvnv7AGHNAcTsO6NPBjavPVrQDxXn0wDuBw38MkY8WsYTHvTNewNjox 7RPq23dkf6XqfLcmqMEsEjePb2y5aJTyXnK3jq4jbw8vR9tbrUvlMz5RlOsaq+J6CpLavHVPJ8e0 btOKiRs6iYfxfZkI6x0O8gbLValRbJ4H1ByHlWybTZlleFY+RfGyrFlSjuKEbC8b0Fqtr59vlqQb VDYnz1cKQ8MhSdoCH3XsvJ2bf1S0I4/6qW+T4ZBKAREiq3emU9FxroNV3BpOu15Z6uH4tHnldezQ z3xfDBSLFqzm/yxN0kMuI+70UfnH+pI/lpHUD0bD70qB7KiCK83Q2r7BEpQ55WEWuC2jMwc08ahT m+82s4JRrzJsLhTp7RNl9KFu7On3LhrtlG+HOz7ykRXvb0fEUj51Dob+5Pl9zkx6ivZi5NDETnPq x6V/USX5dfGNZmhdu3arFJOYRj7flN9tAkSoGtAvtZIWNIdbNk3x1ooA1fxonXXLMw0SZpS8qp81 2gf/1jfBuZi6cZVtUdCH8wKp0cku/rShi86vkaCTpVO9hkU75PUbH/tQrdj0Qi8g3EmnXsiTvxnY BGRP4uhHNfK7FR5sIM8Z21oLJYFd87xwPArEOYjJHem1Mjg/yKkm8kG7sAthiLqkC19jYb91iRzk +zjtEED0/BwBHhlNSWMf2MnWOPEo+TzQ7h7dCzNtPupJXtoBqlZTp315GG6LzqpFa1ySIHLdRocV 11Kl6nlPZ0iwNJ4ADWjkjBWuo9mn9K3u49mkzXnrJH31Exlskdk0WIs6luxtc8lMuz79POBYXWUM JeXh+7t3zxQf/61zdgcNBKa29uXtSG/enRHdiCOAiZDnVFN65mXQR84pOeBeIzoY/EMIFyX1L6o6 Psdsl12ryclPzLJRwlaeFu7KUDBorV0ODiNI43bvV+AByI2aQpWETgdCz5uNOZwbx8vU6RF6BPpt sJW21eMat2+6f1x8r+adFQ7CKmI4sVm8AeJMlPwyUw+x9OG6/b7HCUGfgJKNk8NMaGpEsXhGE2On 8Eg+lpgvFXC8VZg2sfsdaKSS15ZhrFWcZ3F1u7sipdwJBtH6WgfmrV3drevkE9zyx3qT8vo1qOCk /3HZGQtmWwWTenKJzaqOwk9ZCjWinBV8G7G86vYa3wSwU2bbrP0YDGNrjcDKL7Cq1XTi4pJCU1Pe 46CvePPMykME7InJqBT3bVNNtoZu8suobRtRsWQtoNXgsixXqThdbG2cY2uKDQydcuofuHiydHhv MlN2ghwoMhKd6ymV6UUYuckH7wD2UnE4ouAAAa7dGGDyGaYEKYsvZeBn5KQLIoVQAETSS35BcH1L hEstzDNyH7WqT07pPCBRIi4G4StQKQ7yNenIdJ+yxVENStQy06lNAPZe9Aa/9sxCnwXXCQaRfXep IGqMARZafWBI+WZlf7PeBummSjxm6OvGqrl+G79MwWP4tdp55Zsz30WAafsgT1Uw1H4wueq2rZuI XCyNa4ZI7wbDUJ+0TOhqbNoIMNEqgClIeqcQQfK8LPRmjMW4oqa1/QmAhLbA3PBXtu4Qp1u4L8Uw TUbe/I+pgAIsq2KgH20fKatsIz7Fwyv2IHoJdm4UC3j2ufPun/gAJn9KGXmtDCiMN9TQCmmwEOgh 0Tghtq3xKR+Roh0dfF3fWijyie2VzvI9da+ofPcypQIi1t2DXd3wKd3Sp9f4yapUlZJWM1RhN3E2 dxxjBanzWX9SO2OYFL3soWh6pm3h4w/+Z4vMbioQ4XXgDJXxc3aH5MHGodu6FrNNkA6l5M2xbVUQ PxbTzmf6LhZziCUesubUXg9k54Zez98m+Quwi7zhcNWMv12uZim1aMTL2KMgGm60SH1YWN3+DdCr hurS91ZzIzJMGqlimJanTEM8Wy8mZcYHTvuNf9FcnrOmsDPRgXidty1y1D2HMPuzjObdkvZMPPUx tnHlsljsv9qPCgAfNzgL20CPmkswD8CP64M2OlhlPEfoYXdGyLjoQsmrXpiNFvUM9/p32SP4uqj3 jljhLjtdP4DYrLvVuLlbEBqBDC151mTijYn15hfBU1nuadLUaP8fAB2A4n/LRNcKC/ZeqJ/m019F PpidsbpxEiyXk0c0sCdeBz1mHFhWUm6HcA/5EGb9de4ebqnTnfV2WqN0oH/qUAgrlW8UUAFSy9xq fCRtR9N7Qos98eppm8AaYP3+qb96LtOh3ywrej1GEbsj3toXNx1VM8wsn9kWSutoGiwtRI9jF92H /oWT8X1PMQb6ZquTpNKgUet9REB46+1E0rBDoS62asKY5mcAmC3Sjm1E8cyPzoXUiewkEqowIYuN u+wxcrwmYHk/r1KZPfyVUWNho1tyeo7qoyTAbfCoGl102HTt7+h82ut8hXugC4G9itUkXFwKKIxa d0CpbuaXOmHn5IwIpfNgLlgRC2+1cFH+EmD60IeiB/Ej8vDBsRV1G+t3GWK59F4kM5vBQSZ1rm5p 5643YU9vR8dp7m0JtskUsNB/f2KKEVH6TzkYB8c6wKz7XunquDr3CqeKJy7N7BxXTuaNc92lWBu7 6RvFAcMDRk+8eJrWiDXM62cbhFFIiQ3Ge6BRpJIJILiXDaBVpyiKRV/x75Emahtoq39ax6P5/Ksv 30LhhLzCTkD1fvrNjzjNKHTd8h3ah0jZkiy/tt794n5Kc+vwzXxRhnO12F11FsfWsv9PRVmWnUDY moTpJnHOqKJBLPU8aIZFLhCANGfBvF/DoZLJC8OwHlu3iLKHPCWHCL17XVlMenJY/BqPMvb0DurK toFOSV7TF6RgbbIWFReKeLkApv2whQzLoEmF+6/Anw840yzQr8SIdv1xjy4ReDboap5A0sRf/CpK H8uE/H+6drzbZD0cFGs4Gf6je9qviEOvr6+cVwJ36uANAGHSaaPPeohUMkTsPgiuv5NwLkou9V96 1qL/HqX+Nz/R91G5hXI1g8LyODDwgUcylsXTd8p01z4gYVZ1ykY0ntNNe8VIvwooMBtGOlvyHVxo 8RZ5yzpt86wcOocJ2iOCV4ypOZHSRCX0kKAQDdOaNcqzI3W0plUXybWPtr3nrtM9db/5lwk/9+LR xMWaWOlTjjxhq8VWk8EYawd3XcI6tfEv9HDDOtLD2kBTjVYZNY7b75+K6c3WqJdPF1vydf+pgAJX 2wAjCPGTCb2C/IxE7u3n5wuPjDbK6IryfnBt1UjK8X5RvNIsfgYwvk9YhXiReBVoNa2gPS7/gNRk V/acyd9QXlVeCg10pkQhyhv2L6r1qkgMYDWrhtpPFY5iTCQ3spmHj2UeFqgZ7ip4CDYPMOoKFhHL /rL+Cbzle7Ns1o+nZYA8kUdUfG8hB7+rV4qvAOyNyPZ/HNWsa2oqP6N6civSygRrVXAAruJephTX 0k04Wl5JqGkoTZAR1MczT4DYGno3XtrUBs2+xqJFaaHfOafe5mIsmar5dB0OXUW5Tk/IrwmkAOjc 0wGAJbjeWwRLqGtle9sunHe0IuKK+jSZtsRkjiM4TdWh0BKm+fh3Rm6caQYRGsB49FZIPVDVSiq0 te+6zdTkA2uC5h91L1we+ajjXodUN4gzdfCGcymog5IFKKCRX0dTqeRH6XOjr1o80nbTBamZ6Uqi pvkRaGXuvZGdDMMLoaYJWyTHWYHewYMUsLSGE5ND5qjH4qZvllBl2XpQkCV2GDbxt9aBCoVxGy72 LL7xJRsFFv826zEjQIm5jxn8X9uQtPlR7DCBysfhQWWDfXlZA6PzaxUfBPeCXajeoVH2Mzxij60X P/1tgQskQEoaO06z7L9V+ufW8DccODVfZtZE+AgMXXB6inUUt/XLq/FlTalBGxQPchg8WlU9NPsH QfztSIS/YkJOr1RoA/yDNqN+pQ8OXC4HSmpvpC8wFw+p1c1WBoD2XfcHph4jy1TuVI1gzzj4+5kd NDai7d5BKA7TU5r0yZB7P9m12bpbLYyH0HFKceGkx8bsy2YWYKP6Irl5vBgokWQFwQ/e9pqtCIMn ideouWNMVrn4vDSyEwdxca42S1CPovwDlMFIB8RLWpO5ug6+wxUr/E0jQ9URrl1BvdEwrRQMUTwv HozgIdH7X3FcSAVwhzWuPHZIdfaE3O5wJVP2ekY27fsu2ni/rkEOrQtmeiHy9GoudIE6a6pe//1I uU8WatJq4gHNkjOrgFwLgyt/qTIsotDHxRx7B9HaRDTcIAo+iUPxvUwGYY6YhKyCavn+YWu0nylp gAW1u4tAr01lTWsQ7295JfxRYzf8604hHa7KoyJ7Sh/ohTrj/u9aPJpkNN6l0I5dsRXFfV7UE7aQ 14jZ9RI2t6hzllSEIs7z2u0fdywPa8RmVTCCQGCEiCUaxy/vG5BS93+JWHmwwIW3D2/xzv0QwNqE 6M+P3ViHBWvna5PmQRAe4HDheImBHTIbd7wYvLCMPRVCZaIs174FPhOcMVQwV9ew5kePxF8PBRiq pjQEIdkUjiA4A5x1SKz/Y4/UNXcHWz4qeQEzFc11J7bdIN3K5k/G6XXfmOjgpLG9+rfqVXqVXUOj G8jHRx5b8jOE1mGjdrAFodPNlLA0R8H2kYYWzkdsFcpY4cmiRX8bQjLlXLCFPXz6wRX60mGJFbSP Da+rWgBUXaqbx2T8aqizXZo/m5K8zGUNBQyW7UIVRzOBdVGSsjO4RsltMKO3JIgVbqEdajZGvjhp XWm5Qfo/RHa0zt/5ZwKbHy6VHCmvufvIRmSV/Lp7syCgOuUN6hRF2eTLyKy8lRWbrXUN2MwYQHP+ ztf2v6M6OSiWpeWfiOLWZZlT6wSi3HVQFX2DJg5/q3UY7GfHrxR/pj/Io4btpPTFmkWj7XeN6+lH xzJG74AyzkK7r8xmtrA+Z5eTSL2metrWaPSOpGLpyK3kVI6YqgJlRh2uAtUJvy0tY+WfxA4lBI3b 5xRckFwh9CKpiKdZWAsGm8qgYhfO03884K6XYZXdWpsMRjhY1FYWUJ1npkLxyDASew4Xl4wPgZjK S9CY0n0ZRl99F/d1m382FOkH3soBgbKQly95X+KNe0A6kwD+/nII9fjGr1Mnfp2r1002rLOvHvpJ DJ6hkqkTmbZUSHIz5H7wFHZqMeVnD5Gb+rDSYOh9DEDxpJqtwXXpt6hWB3SxZYC/c60JJ69Q15EE /0m1UVk9m45wCbt3FhiNIPZGS9cEwDRJPxbc9E7a5DUOt3y0jW7PNQwTI9xzh0RvrWVI0PL0jRJ7 eTW3y8J04SzQguTkTzbAE3oY0lwAuyHjo0Bs7g4cevPdGYluT1d7OsQbM/CwxYGotoOVSOiQm29u WOXVh3mxiuuzshv+v0oci7NvX3WgXzJy9xmLi5uPOKQNZxXZdcT9wzt9oVV9vWQymt5+gbsSVmJu Z3fNhhaHcI/sqHfgfDN5tKISFU2HeY3QEl3bDtIPynh4+pJJVobjiDyZQpTz7qlyhMxV82+G1a2c xISwd9QEeDRS2Wm+6+UNYbgDRts7rNPkZdCUtkyQdf1bDAhrTTqxDMjJ4fNBw+BGEaXw4J7PtkL1 euqG4QaZGalow+PF6JnGuorwDTXECAYcAOSm5UROXpf/8ePtJdbUZ5CF4TIHPVY9kBj3xVAUZBme U69f4ceh8soOSCxQ9cRfelZ0jY3jmYJuzGubWv5notzKmZ3bof0rULIiu4Czbefzaqz9viYSD4gc Ls4hDMmKhPw6zSlWjb+GEiSZUP8WPCw92cdNKdsl9CXdAxILmv2OyJxYM9JzVGHQBQ5/ToEMjdv6 71BmX8YtfqaLGqKjiOPEQ3s2AgZXt/cd+4MzMCq9+yi0QB3Uz1TrhFURXa3vMH0t9KM8R6I8Fdpm 0ydAQxu7iLzRrz80NLlqY9w6CVzMvCS0wJgEFl2gNyfj++bBS13kTFpwKi3qVhq59+sDMBrlghuR DSHIwiZ7D098yM8kd06XyrAXyKu2vYatIiTTh2ghGyTc8BztZAIECxzguG1U+i+iNhf/yq+/W2m3 iBsloZZHIvnSQjlXYis9vhMl5p9Yz6IFwthWNXjoW+95soLAU7w2gWBhlu+jnVKUJqhv4AYWBKsg duusrYiBs1HcSDre6EWUAdK37a+6pI7oDnesdsAp359S4iMGlpKYtc0Lik+NtByuE0sV697ZE/qb mA9fPbkGVkbdH07zWUvWg4ZtPrGIuDTIRy9cotlQpUVIC8xES1opBQhkuVkSedvoLmFe8Yv2cGzK 5DEV5omuWUnZyh84/PP3XD+R2uxbP13ItjZpinhp90FbbSq/liGtD/VquTOOjxGlAP3xOLJEZETc 1T231z6uNzxdBrvnpbtfpsT7Q6nWDniviSxotiSJcMS3q+GweKNMSMgP/u28dwh/oRDY6TbLyKNT LtKRLrPvPQ5wntqB6TUbu5sZHZttjpmo3ljXBs0qwxi9vNvNRxafiWFj0OtUMkkS47y8eIu4rxkZ xOZUCOqvG/JcMGpv4pa70VSd9xh1L76gjVnlVZYJ+xNyV2ipd8dmgWHSWwyICziAgMhpMIHfD/UL IM+thdwTEvx2PnYG2yZAyUuOlH8BJnj3m29UGYh9lMMz3jt7r0jgzDK1Y5yp+aBSz6Q91PIf6+5W jY9nuzUzZTaDTiTHU7k5qdP7qaw8PQ97xTkMDHY+B2Qk+2sgLLNEQmKkOaPqEjl3r0DqX64cHunW FgM6iYsSwrKlUjd3mxZZYWklrLXcc8TojvfNRPkk218bBEYet4HFdim9wzXhsT5BdPJ/WsG3Q5S6 9auOY15XVK+mi+beA4pp63VA16/IHcX/d2RSS1KRRLOUpFR8TydlZlI3QxQRJ+sPasn/8BwJPucg 4NVeeOz3DumAjNV0gykU7OLEiIgzUOt/TTCK8obLIiRD3TLbC8KAztwXcwrnF0KCQN0+JOLZ1250 rzRMlPJKIdc1xOH4dgBf0TuVGqacUpI5AZrA17lBwQKf/jHXwJ+bd2LoqFBC+AJMKKCeP2iu0LsT atRONBPimIZGdYxuAJpPDULqgjy6T3KAQNKgmKwVl01mud0nZ1T38wiM38K3Xon7t2eyeUiW3jtx 156PFsNNWcD6U1Reis82xC2bKXiOONtT3R2BfEwUvL3VmfFYCOA+1MNNmiu8kt3mzzJeXKAfyF5T ERH47Cy0Bh1ofHZnl92Zu1tRB774hEbyMbmlzRlklaDICPWfgw2HCVKwwDW60dmGrUacFNjlZFBN FEF3ATsJDgYobQmzrmLNls64UEH13mO4f9JEQTb7F6/ZVNy+glNJ5ZYIN/jEKidj0MmSJkDl+utJ Yr5d0q3HW9tawwa16CL1bbSGUEdTioOaSe5FHcjoDsG/62sQXMi5QwF0vicGn+eBO4aC8pnUgNUg 9ZQll5eqASemsfJSDneP/4QnUhkWNWXvQO6llpp5zpSc7bZbF4v/fkmvgqm91AV6z3dlXdhq9V7O cXq7JV35RENRiyQc/yACNP2XWn0cbJdS54TKUBn9yg8h1LGkbNcOvZTUbenQI51QxkFRK6fJUOWT TSvHTlOhvRr9JHQ0KwtwnBXlguStyN5d+Rc037qOOpHQc0Ihu+jdpoFKT3uxGy1uwYoDnFLGaNjh +iUmmLe94q7ou92Qq4UgM07sI29cHf8s87ci9rFzaiEFmAuG/5RaNTh+MhDPGiR7SD3Nz9+WtIrh FrouSyphkpUzniyaAO81v9/kSM9yMl/ggTgNguz/7zkSMwCRmR00sfSKPiP8S017wk7lmBDnkAFM xDhcxzmk3maga79mFZ4bp3CN31PdsUtECNsxIR5fvsG43xoMNMubxmFfZZUDK32k+tx+2JQR0QrK NunH9ear2yb7HXWG/JqToHcVuqg68LbhswwAKdlDrQr1sWSHioikweEihjjfKrrh5G6xDoOtpa4M 991E1I40WcXzpG9DEmFOuvK91zYR/pKAmL6CnkG7qSbMAnI/GMpcfsrLZ4oRrqQfeixQsSzRS2+v dKMo0+7xubg/PNZOcUmML4OUxvJ6uvM8tgkMZteYrDrLFUJyhnxsNOO/d5ek7PT9x+5Fuu5yDLlV Goup/nKkAunw5j1qI4Zud1iFJQQGKiT6s0mphWeDSlT5YCPCgPg5xYppydFkYKeh39/AU6g1JnBL jBgyFYO03+qjurXJVkPCVbAbfzGv7cseegjFoQ4Ni4/B+SulU2IFQoeqX2I+jZvyziRODj8wLG6A vgwDACH4kpd9FHBk3AYELa2EX0XaPgj8uGq5jmzu1c0v04CR1P5MKyUqGiavgTBbEd+Wtzx6Ibyg hkubL98ybrrXMN9IqD/90H9OFDqY08mBeqM5im4pSUND+/R/TAZBBWMXA1h4lBSa1yGRzdaGr8sn oiFDpVu0dOJKFDbu7rJ0vZmrWDHHIKbNT5V65xIBjxZ9MCJT93nm5YxEkMJ0L0oYsHFM+a1jyDmo lqz9o6bxmZsk5BxuDCyAHm4041DjA2KsEukl6XcVSSf5dijQf37BDDJNIo4rwlN1MiHIhFqGKaC7 XPlS4nyM08ODyB29g4YMwj5lTWMUhb1a0Bjb8yr5Me2OZMilmATVapuM6MO7Y8C7lNlJ0/q+0+NW p5o4RHzMSdaZ+GJPjjkTas9afeB3fB+kF7h5PbTcEYPaonkcijPKjurROq+wjsRkv1T9VXyYFtEP MaMlNFkJ8btZUdXjZ2h4mTTZ2UKL/6cpqJzCcrGcD8H9g6bWdLei0garNcC9ryMLdkPYSfk4r3aa 6taZxFaqosiBsVXpd5YplAUKwY4cB9XKAzrla0/vPFRnXORyXaOz1wk0D+8xlsfqy6lYwYTsgy7N TJMq5oVuevet/Xs6AFEn5VKUG1NziJnRilrl/dwl3yDrHt81rkTjeDaJWgDRSVvZFKN6sNc+SWZO gBR7yx8416KKDG4jpTRV9TisMv1aDIPWJRCQlW8L09C35ejpcBLeOh0y81KeyfyUMJZuNp+TjeeD fCCJnuiP7nKyrvqRLZSTbeOlo54g3t7san+M3rERtUOdWJ5AWfmC/UuFOezYQY9PsKwPiiS74azu JBkCQCQj1ronLmn9XuwNxgyzigRP2p+qwVOHdtrE9Cpck9vj3HilMWHLEHvNg7RRIagKaMkBMwh5 fGV+1aZfoHjCGV+6LbWvF9C/7uhsNbcaLZaVEw37RFLUacAUuGo29GY+JQFE850MZU0VxcB8TuL+ ZUn3EPOFAQ6XDChIyRkp2DdihxbqnSJtD/Sj3x3L8arVahhSpd9rxM80Ywl8x1tjzU635FhBerCn n4jjGpaTW0ShEEPbzp8PDebz3sbJ3gMaVwXKAjJbiqhY+gFobBI8/9EuBYMmXejskIGkhqQNzHT1 okVqh4mZEP3JITcheRCmWTwUrfcw+doCb7fBqou4iSD0fqMX++hCNegmn7dREP1t73nJfVp9T4bN YAWFDqZ2+G7pEV662yCZm/MZx6/0qY4kpTc8MLXmWeiJ8P2A1+B0wlEi+5D1/xGVR0rZyYXV3ZmK /OVYfRBiCWlGSG6EgtZqgYDRCju1yAaq8zM7j+uFu5jGcRc/IQUStoeWDZZPkts3PZLZfCvm0zo/ 7MT0ZfXt07zD5+5S7JW36dfuUxII4qwLa7g6dyF9J5yvAGy3sABisdOdsoXX7hpIKmaRV43OAW8X r12CMMTlNIpKn10GXPIaZyTEHQq2dOhSejLu8Mq7hgh/Ka/Jkd86xDvxeWCc/7lGrZu/mQCsuCgr 2G3QwDESCxMXv7cROOzKuzn2Ia8O7xNR0K4D1lYzu85CLXh+/VlBpZea1uMpqrUUezUgaMyCC6qC DcYp4RVFboxbYYMbn8B5K7Kue3rRzyc/YfifjPXhxijveCzl9RMIXE9oMCTY2iAkh+1jEjDNBcVP HgUUn7BqF12mLuOmPw0Y97zBxr/nPWN3HhSflHgKeuQpmDBE0vF2LPatvK+zykhOnS9XncmqeTiM kL9qmKATEjWPNF6lcME+hKUGjs9j/ynw8CKCQ9BvOBWFn5u38RuMc2Y8d2cR3fJQ7SEfTa3Dmez6 tsO/p8yqfhx/yFhUg1lf27D/cOnlANsJ3+bRob04YBfiedjeTkFUWnM79TIrDmNRaXBWcFYACkG9 2p9DmyKBiUI11+ydMEknxy0wNCZB87BZUtY467WC7+GT6SzkgS17/glg/WKbMtfab37XWZqpXDH3 Ca0bwb1jwUNmzb88gfAO2pxqq9rTGKhv420iF/d8UVH7qWnlMz76rfKyEJ/ltiJdlB6sEOgWeONu 1xetnCAE+8VqfcCOQTyfl2bpLpN+A3RHMuP8KthtRIv+HWuhW9SgT/uSBw+Ki7C1+cvWKar9UUYl 6T8ceZKLojn18YnTyJ4EDa7nBhGRygVEmm38/M/3wrr2646XSNGpQvC97/MLsPGkYWOTIBtFlNeI q2m6doMQ9TfVoQuqiX6Sne/PX2VZXXFQ87nnt7gNdr0U8QAuLErz+/hwJCpUuCG3frOApzGpMcyn p+fjHEU8Hcz0I+K85cCaHiDECdro+N7wMvvXDDKtDUYTuNm35RkCvQP4snyNKqr4xyZZW6gXnFRZ lrcyZvXyi7gyoUOWVlZ2arcJXc6o8ejUFt88OG0Cie7jFFBkPYOSFzL/EN4c+qabLn8xWwdHU7F5 CDVYkgDxPfo0MZuGN8DHZlrF9xoxHdeWQ8uzkHAGDvW5nKc42vmi6AVuuziCyXPyP4VKfOjWR/uT ZcjIO7nkKW1Wy22s01SX9X0wPJah0wDqFiQsLMa/zTZSZnE5nIqduQfjQ/c8LfGBCcDVnMu/QART KmZtUKzLPYsLQ8HsLVAxm/tmFGdmtlr7T5fhKQ+XbbzjY8KofAAebjop3bZiX3jGl6VeGngqqmKL GSUgJl3OQo+hOMMLXuOPG7CQuCVNNkmfssF24fba0keQm/zYsIFjLmoTyvR5rWNNNwlCdyrzJdPf NTzKDSX7oQ0Kme3ens5VgAM7DH/SCXmrbhkwuQ5bx94p4Gl9eo7f1XsYBrt7VmVnSbFyi/hpbyUi PE+zNXqQU/YmgYWxV/hpkNlDFboebm5vD8dOGs36TCABjKb551/v3ovvrHgYG3Nhyg4+ME2WgWUM dNP9KwqNjAJvS+vNrlwakIq7evrTaF0yJSO4+7rvIt5g3dOLXMEdBXwqKKvAZ4hbXOxjIyfCpvK0 bDCjE65qojOwRaFD9uQr4t0Oh4m28NucJpReg35pcKkaLFYaCxbrNByotVHDyCa5jBs96CaBmltZ Edl56VtdXVJhfUKUmUxDqyjhzs1cnycnBB44/OgaayB+kbY/Jrekh6RIZx2HeJq2Nz2uQeSE9kTv Bjxenlo11UOpdjibmo0FHY4yUR9HbCXsGEtv51NZPNZivKJoAodLr2XA1HDnGrTvwYaCo1MqEXQP swl//e1RnDECgM8GajeN85REzPAqPwxWLzPWrhvL8DJTTgKSQ0As0jpTJ4uCeaUm7NOWDMCKLYrO N5YQPNsMJuo9j9uSdvSFx/E0DdMbgg59KckvtcJuBoRILSKlZYsD27pIbIIqmAz1WvvmjqK5sZCn s4iu3Bthvpp6isWoLRdU+UQjLM2q0viJrxN1dFt4fK6pFc4VqRdxTj6Nw0lxD3YVQJbCWImxDRpY NCaJVgkuXq+bE+ds4hP4LJFni2m6Rx0MuYNC+DAfwl7RrObpH+rEusiKRqM36lPghxMjMO93ommk 6UV5k2NcCF5fBcV0p6rlnIQtU4qZ77Lh97JTPyf1n+8xCH50K0F954djwv7x7kySKtOWSz9NpiQb UA1mrmhWdShi9FUpEV3CDj1xhEzqBwbtB6pSo3XKmDbyB60n7uALnmavNQxSQ509Y20gC0NY6Tnm cHuWxcW2pTiTM6mewvFjMVaDD+EsgTYDzrVPE1L3LDM8blMruSffQ1aFg29tIXXiMK8EwwXYSFtr kZ8kFrhaToQ4z125qLAlu7SWMfKed4MFD8vy8yJfkt+5XEWNGFEYE09gUB4o9zGdXoF0h+l0sx3L 8/iNqFIaCFnn7Cy5zWVXPon+Oo5ShHs048FlCSLyAYap5+RaGGJg4xgTS+P/cEkMf4iM6/LQ9/us 2nzTCXIBpYJZiUH6FFIJ9Q8Z9/DCCxH9sPSiyI6RWehUHm3CCPKsXkc6r9TZ8H8h0zbDnlYzfDxc Ol4pCy48dcXOP/wxK/1Y/NU9ef41FVMrIlWwX6dLujCpiqk/nYg6qr0ouns+ftn+f9tkdD1+eof8 oD3Z7R3C+NpzJf9S/nmCWHWBHHfTaiDuabbMRSr/PMiG4v9svZf2PT2UZw0cLB6smN0gLoGmtCiz apO0dqdykd6RhugRMxK8WgnEHNCguO9fsZ3c6dbnuNSaUjh1iwueVwIMtRygut9xetPSBrJhd7v4 dG3IFPDvx1creHd+dgyEDB7nQrYefYZocdqVGRkM/SaUUn8UywK1jq4ZIbzByKTOSCsIj4eq2XtN QBEFHc25mq0dfkcojuSXXqiIYHz6IBGI+fjXEjhVD+P6kqD2oAxD2N1x4aAZfwkpDXgBseOV21cN JjH3Wydo8w3q2MNWqMja0vViwSWtaDcjIo2fNH6HF8S9nkBa/+M6puQupqNhFv+ZtNGHkstigbkc rsR5kqI1ho7AnGTy4M6gwEC/I/dKJVj39z8+yHYsKskX8r5dYz5J5tEKcNu+rxM8ygVrwbru2Z2+ 0LUut2KUG1iNUii6WfIMl84nvw3cVRFnujhv6/TmuJiCD5bue63ocSRkzot0mVg7Ryzvo2NwqLzv 88y1Bz8JHcLu2PAOxNpLS/8IAYe7t0crAFHC/qQDZW/CgIjQc7PYeCKb40dngKWsE+a0yTQMMVIt 0enZl2+2AYJ0wGdUj463grYePu9e3d86q2tsF1yKiBvnIUASghJR3QAgPbZXjI1fJmBVnFjQHo5t lkzMtw5xy6odLnZ4f3pnBTf4XqfOWdNZH2dsXLDzadJU7waOUs1G16eNCB2hM+No+/YvD9QYpvVI cH8YDZ1ofkyt4ZKqBl55qnnqwsVXKJQ/7/2hxE0izegACgt8Y6QeVC01wNJPCFfSyJ1VHexQWxkg 5bCJSYaa8nD7sS/QRotVc54O8Y899wXF77KFQ/hZ5ITG4kxgx13AKIO3375Q7JVT694h4BIVkpdj 9mEi5wLNkqvCMTyp34OLLvslrLoLpxVkPO94tjcf4c2w0D9fwf1/C5GwIm38/rwcd5WPpKG8pnc4 XDQDCdFd40yZNNxx1BAyaQnpu1zC82ffj5xTZxKlQ7R2vlKMBZnb/phuqo3+shsqOKvwDW9Bmq4R cNtqZ4fBaoLDSMXB54rKmSyA+eDr5LKFcp+NGvRvMb8lFWRq/HhGAuwJZOHiivUoDVcayF3hdF49 jLGVYW1luRGjfPUOGd20Eq9DsTy2cyQF6b3/JNRAHhEiWTf/UHA11tC6XoOguwdDzgvZ+qs3WP3T UWe3jj+Vo6sZS8FuPaL/5dfjBaAcYgLTpX/l9aEZRd0oRm78zGmp/JOfnEFQ5iRRYB/YmDBMbq72 er5M7aaxFu24Q9KBeFLKZRSpreFkA7Am649+hUPnQCBmUPIzj/jCclLjFBJ49SyDa5hcx4B0F/sq WiCMYimU2DH/sszgPN8CbAXzXR+Zd8MukcXvPklGSL9dOTh8gRLibxwRjfTKExZLD+J6PdVJuGpI 2guHoOICOxESujeFDSrkCtIlRWMcwS3V+K0+hwDVkZdelvtkD4jN+V3IQqTxs3XewOAgGjGvaUOE SRxmZ2OZTRSCuuE2vTCZ/hKaWcCGGgiXH8RP/uYCkfLoRJfYR32ubZhOck+xjHdIrgBVurqzE0X0 X84kJtzqcz3kXVMTqv8cBT9u3+xmIhfhvJd6HZxRHiVGXFcKnlDRxzsM8seFqG8HF5Q9lBmwAk6F +Nv0g9iaI+7NI+DKSmcbbX/9adtZZWaRn2RRTi/aLkeq3LMtVLVpoyYXWfTxGYJDgR5qELL/p0Xr hW+o/wFvetPonxkigeE1XcwYqxd6F/GEaq3Mm/PmwQjDoccf3Iwjl4LCpz5jvpq631AeAA7zQh0X DSB7o4nJBvQ6o6BuvEpQeTzEQxEpCxFaEX+UB28W8oUB4EPsOcYuKIoUJTF+tFpQFLypNjVPhijZ tgn0WMERJ6qZxWu+vlPsB9f+963wAztl4J5ftXa3wdkbDPXt52C76iEAd84rC6ylhObQE09sOnhP j7FD7ehdahT3q9+bWSjgDX/1SdEX68vuiQNg6YBVgRNe0DdHmdt5xnsuzikzQm91je4Nq8LhL8Of MgcHKkgOE+HcHFgiHdDC9L/YJdZtUSOxUsK8bqfxwFCIGtZlZfJ+ON6T9inc5hreVDpkuoNe2Kh4 c1sOcAQYfo5FBq+ywbbq0e86j4AXDDuHJj8HHUu8gqFzkLBD8WjAvTb4SZv2LZQ4mRSfxeCB0/zC AH/6hRQwy7FdHZ9Yxj5JjmZNqBpWT3qPtSFflIdSVulx/P7tuGa6qzu5ixNgiptJTrp8QEKAk33c AJrZR5j/D3zmbmRWcCyWkNjPkMlOFvUL9rYx9C2ePNmiajzyKhko794k1d6ShA0KPfKEhgdjfaMl O+c/7objnRWR6CF2ZdQXJWv7ezwoTyQzJSC5acOiSqc/LGl/NzWzP3svfuYmkPzBm7M/kxQmpjnp sgAD7AiAnbd+/UdLge8RUqzDr4/4+2kgI/shxLcvGAMP5ZsvtKlRBL05rjU8v8KqTJsnO9CYJQQg qshRwKVRrzyC7A1PvR+ryud/XFO77b9uwdAHOAYWZ31z264tqKZK/35iHi+RIE4K9Gm3YxPKwE81 wrqxjuQ+Qo/DXEOtkIOGi4WNlbLsmtDj5popgnskBPSS4NRPqtzGONfo5eR/eAn8xpyQO9zIjkel rww35SAsCB4WmfbMvnKEcwmMhwc9/BGggl9KwoN8LhTFxwsN1CaY1Q20A8bP8L8bGHsgTOLFbZ4j +S9aaVK1gM5UhsTttpWrCq4GQCSbkrDyDBeG7/OEsWPKmqb8U05pTetoxQo+3c5JfVv0XwEwTFZM ZUyB/z4cFa9OXDQutWmAE8H2elSQ1CVsW4Ky8xEDbdXYvAtnl90H76+5wCKbVivIZTarkVQNcCKa jzkcBFVjbAEAjbTvyGXrLP/TOvaMm634EEHP3ro/IXKYWisveAd0skDHcqrHUZx3zncK+FvY7z2L +V+9qP6FdpX/9HTRg6yLfJaPapahES8uEKEUecAspGa08w7xhC7bRvWt4QFs7uyv10WK4Y7MwtXg WelsXV9fZqYWS/MdaH8ICWGnuPNlbt02gAR8B+doieU7zmekqhkLI3P5l6yT9qwBrR5rnGXoMDl2 Csttj1/jj/q6GwYOQKTb0DJgwS8N5Lu1VUmgNu8SWuYvObNcVL+QlgbY71rNVdZ96YRpaw1f+3+8 h5DOvFR4mL/pCecs8dAlc9/gRa2/OQAXhJa8wiwj6fI0rzwaAHGPYZsPSofY1CtRmqJMvTs6ASnU nsoytTZOkKwJa+uCBJhybwK0YzTpGYYEPS/lI6VwhINSnc2RaqswE9gd0cmRJMJkKkyJZ8R8FaCb NC1byN0+mUOPX/UWdQCG1aAIMcatmgzuWFiUVG1HUTPohg9HOqT4rNjNdUVI+0ScsNplTFDg7GOk Pf2tr2T0IzWYb5DlSznRZEQ2EArvF2NET8PXn0s6Kw/LaMoKUgVPdmwYnJO7jFXZWqUbW/4WKzPU YHvUA3akcr8ALAdjK1GT35nOmgedsgkFLLspwE9Fq66EWyQzMG73plZ3LqbAj4aJi7JaIi7qGvl6 K8S//1U6U0S6aRKcdkLJKb3IVigvIkqnExlhUYEZVFOdGEvF18YlIlp1DgV3OPYOdZd18j3fqAZp KFuA8pd1JBIJG9in6UA3j7zzLSAOD697icHAYV6AMPLn+hRRMeCNP0/yVQg4cRWN5/3eWdgoRE/W 2eQn5ahCUEuVXYRXYwKzkmjsx8Tgf8nkGQQjP3Zu+BhFnYwP1NCfpgWS+r7kNGUc95jvIt06ro0a Me7Yh1D7ujgXzjUCC9FvUae9sxSDoge+faCDdrvnV6OCzsX30ehmZv2ODdzQ5qjVlGAbiYsg4wrB imLaJ0HfVrW7VgQOBezmUkmdyk6s2R1GQw7QalzLWCQhtmyDpqk9oTYSN1l42Bari1Su6GlrehcV wwgVoc/cxL8OQkJznEdJ3cjUwDrNy/WE5PM0iV/g5SoX6OIK37i9U8HTQgMS1MQNIewAJDTe8eaj Z1gRp+IyF3AP3GDkSqHgcod1rI0phauk707ZWjEsvQBpU3vksRcq3k+PBuprJWlJQzLbTJrX1ECF lsyfmdn1eSiTnQLtH26LwRhWLOfSHmhtEvwia/RCycxbsF6ZKbJHA/0Uau1J89vzfT1iV7EJ5Nt9 LRU//MIZ38yKfqlH+e+uYwSAHDzhdEm5y6AbuLGFXBGl0U1eT0zA8lRNfn3jtY4Qjc20XAc71axj yYmhr0eRsxxIxsnCc0S3q9ZPCTaG2AHlTsXs4nH+EKQ5qCCKcgY9iCTT9WFDDQig+j3OVeSZpKJY /kQBgRDzxyqyecV1WJDfkyEtWPxUQuvRCJsoxP65JICeE6kkCYKaBFrJblBKxyRoJUpO9YgUnITP Kv/fh2QMDvcYKGsfE7qtY26Hq0uw6PcSZ2uBXhyeHMWpXYbma72sCGinrUysvsW5g6RIOh0ZRh4e m41F4PKQok8GH23o9xIlSFDBimk9u1cGMjuT0zEohu9IC0ITwPAoKhJKWeV9pCbLFHARXafE5Lz3 gau4iOJxIxrQbczoIN5slbhfAvMPpDhlFwupmsOwk/jwbfz49HEaAiXMx8p7BvXqSA7ih588hF9Y lRt5fGmL7GnM6rk43LuY6BNl7yx7WsF9030tGoHrSk7JtKbTDt6K8X/kvRn26bbwR+d2Q30YJ+2Z R4/JdqIpS4YdN2aiQUAOpmNSPyIxdWQrNBtbMLmp3yuIq33lDOduuC8Vvw1j5X5g4YuCMzh7aC8n /TTdtQyK2dyimbXJ1NfyiY1tZlEw3cCd1r+GBHa9NjDRoid2X7rlhXM76R7Vpw2sjfywnJsvBce5 PtvcL2m6Mc93mPzbIOm1FpfHGxkp8Yfnih8671YrUgqEhheKMp1WlwXyZRWJwrMW36AKRoN3KCGD /BgYVRtFbguwPzJ+beFP36u8ffYBltkfihfR8tHQavQq1Umo8xRSfD/bs3nTrTm1pnQTQxioiUY9 jD5QUTp1VFV9yZR/gYwZVTloWZLC1vYCL1/KgrVH6tEfQHGH5XkXu3mjHZAiBA69y/eI1NNFECxU Egl7jhC9+G6ZLJkvFg0OOossc5+cqOPkmZYUpkv/f4eJPS6zgb/OsRmBRWVe9FuHAyi3/F3ACJFh EEC9+x5E182jgrBCD1sOUA+K3EU/50deyjbAv7uzBo0OAWPXpQKv9h78bVV4MUASM6CMJsIcLWVy duUOq450P/XLb84cg1/0DDuYMdlVhzJ36d1xSNL1CyA4ECuFt9VC9z6b0wqu/CN7ciBzhSMtXb7b +tJxCYnOfg7pB1cwj2lwwxEdV3wymEczV0u/RgirJwvNiayYXjQRWnVUbGbtmsuB+AkKuXERZWX6 FT3024L3blgvU/zCtOyADe+Nju3sYWdbjV0/ODRW0Q6y4dl7471K596aaiCgH4neG60ruut5vo3m VVcL7dX7ORYM+rQeO3ig3rkCPEwRxDdbhgGPR8+enuvAgT0Pezs0gjZwZLTt5xTnM4ni4ghR6JIA BcHCReIoLQVjropGIyo5OIbvanqHURXgJMkohU+gDwxoodqoZpD0OaCw+dnn33rhiLYQV78kODhg X/43rKcSbAcaOAXioIra2rm1yVysiUUf5+agQz2shmdiXHZNUetXgJtQkexxcdyXkmJY7YXsqPEL +Z5t7bTaGsicfuB4YSjJ6RFFY7ak7cI7HcC3aRQRZMA7IcHzjQxNpa5hJF1RNgA1UQV5Ym+0GFev c7D9auzRkOb4SCwZd1DoYSpPLUywY3oaHOkyZbSih9fkXM5P4wXLrLoT/p/TPcWJYwcUu3IAIbp2 KbEnInO9vwJ7Tt9UsaMDgvK0PDKtmBJ8H13rOeBdzIvmPaOpEjBbyQ/tTzU7HOw6d0hkQVUCYo3P +LlddL3xcqog6q82Ynf7kvn2SPn5KsZo1QhOx1+/spUWNezaCpF4zfjyQYztqjTibt3OuGyHXAcS 2Y+R6XLP0imnqfXKgNO3pv66fowViAXCx+TPt8ZzK7jZp2Bzaq1ZAAUdcBAzaRfp3ZylKYTdD0Ea /07fNbYKVpSKyQkBe9MPVAozFtuE2BudyQbqUQfVsbS/TS6+AAD7vInQWfKktTF7g2LbxLtMa8Ik FN+W0YGMBnqG9JWyC5Z1/Wj492URs/f37gZ35/xm9Viy6tsg89dGcviK5E/PD9WEujlGA2BTvv2Q T9YaMCGprrHtO6QnCDY10fJrT91uKgSTujYNB5zoYpjTTdD9FNnQHRKbSiNl6ecDqtLGUVOvSmN6 kPKpjHCqREMq5vevH7ihj4QNop1ULAciIVfjzhSPlRbkSDhNbgrj7DXNMGIv4lvu+ufGDqu5qn7i BQpI+FdiFzj2MFg1E7Hb3UtsXqLwMjZEOEnzKvnbnikrjK+fjpVUvEI6fBSHrgPNCd5KzB+GLrRu Hf+8wJKXPLZCV11C5jnBPFLQ9XmaPK1cJ8KrzNqFfzJD4Az6rhk4F70KP3jiyeL42WOxrmam2lCp qxoGyNjpV2m2tmS7VQGCpKRHLlX+x61+LBzIPc2kIL9hmWFa65F6v1QXnPM4NiLgYSSjPgCCerJh 2xShrU08hViop+HVF59itdOFSgo+iBi2stPcuFZPCWu3xbl0L7PV/+XLdorR+o6kGy1Zr6lPsvhg QdxIrN4VHymx2r98nHCsNZZI6CzXOCrhTCUkJGlb8lIuvgMjHM86Vi7zu2Bas4ZWEfOYCYr3uso6 L6kltmyAqWt99g9SG3tCuac7lChPpYoajG4LofdNnFmOfOC5RMTNlh1xpiQSAP8LrX9sxtxIAr+a 3+QkIerJ/V9xjFhKlaiQH1fxIOeoRe0Ru78gNkM5dZK/D8kL7y3zPRxHHZDBFtVyXw0tFgHsP5JF wIwnDaAwLmyZEHo9ZoF9H7IdW13+EZhME8tFDndudokiA9r4kvsyeuopV02kBVCkzfIUbAfOvY3J j21oK+K3AEvM6N3PqKUOxFDSKtNnLGrvQh6w6PPIjV/2BcCsTQXbWhu3T8uzjDtQBNjRAGW4zPZs i0BJ40BIQJWlq/6nyD0cN9aeJrzRL6GISebva7r3FokR8SxfijdJ2dpwOSOGc9bRjvb5t8tAV/0O FGmQwWGKvTHImvjBAdxdP4rAB3OYrbro2Pzp2L6YkyDot0anejH5TMlfjxWsPj+BQ6+4P+1cc0YD EUe3A+tfjRUVoVTOqu4tD+C4nQitIV/COFU9vtMplr7lJBYvsOQ9ramh4ZHMER9hkUD9eXxYaWFC L6HU9VzCUl66KaqHyKKEfmkfgv4FvSeHrUdNA3JMmuK2tuFTDITrPy3SfCsF3frFSY7vKhovbFtg 17B3gR/u8LbKFrJjB2XgV5lnxJSlK+jqG9D1yDTgqErT26JOU8qryu25VxnnibKVSN7CD6sGdIic x8ZxAnGrpa/0+AOFfE2lQ5+vyxD19i6WUJ4wBB8Fmk0/keW2P90j1vjiekUmB7m5388yluTKTwy1 9XTxQr9MqVu8g0C8l0QTxUV5IXY1TWDwDqBskJ15pDWdRRXGgJTkKgZbE6K2g1EkfrCU7oYuQyQ6 4OXPeTi2yE01ZdGY0pJI3ncJxSd8hdOo7OK3izkEK62W2UiouHPGcfCKgdrNbroQfwplJnxrlr3x 08C669g2PGZVLGkZ+9KsXQhtb5x0ktySexkFszduz8BhrMyWDV35NKmwrx/jjtqD+2VJQcBfrvpw 0epokIkOnzgXQZHOnJzwupWyaxiqIlwAN7//jT63VV7cvruMc1NqfONrVQqu6nBODO7uTxJJOPTH cC8treHQrmBdL/9GhE3upJjvljKkU1WjW6OqqOQTWO0ZzyO1KWN9MkDR7WKVKXAJ+n2XnMyEnNyb NAFDVxF/xPEqY1OhKbMYN8vQ6nUku7jmiaTLfPVTaNkDTlEYLOxancmw/j/++4vGbGtOUamLeYrx 8DcpyueaIFckz0XOagxbuhc96BZxT3AEz3N1KGCz5VdVjLiGkoqRBteRB+Ml6Uw2LqyPbpQpMGOS QeWyDl3d0qaLK/tnW2F12DDCiZc6R8FZbb/F6vw8MFPTcdrsJR2j9xo5Mu59SMhiyPmTv+VBmPJH Kxi1N6Cumlyr4G0DpdQ7SDfwofLhzf+//zPbjmu4BdmNaiNGwBTwhrgHvfkj9HXNSUZwchjQVvtl WqqwCCCPZPomXgyt8ZHNbeMXAfASuZs4Nw8gdf+wX/JIobcsbzQ4nyII/ONkV8fR6c/z31emP8OR fIGHpG8violbCd/Kng9QkzVpED9eqtp6YE0MIDkC1UuNvFqPRGfwVi6PcNOSQhPg7Ug6LByiAYO/ dnZYq24+HC+KcVl9bnH2uwBH6xrNxWJAyoUvOrQQgiv0Is7+s1gZ1r9yoYGU+shr71K+C4zbnNZX /7/slnm6e21jkahzavt2HHd/IPatfOD+HlHFf1JXdEt52vUzht/nJ8ZzKd1meKVAeiwdbBivQvf1 VfkvQZv/g5JbbwukBoQI3tJUDSVZq2NP6dhj6vPRKMC/BBLYmH3ojIm5mw5GGgNXMrWgAxMrH9Zu ZDTZrlKDtidk1ECGW1cK0dfDTY81mLjvSYpipHZUewxPXn0HUb9USPWvy9jXF5SY4gcmsfYH/KBn vVkVdkCJoN6+1UgCykjpaEy2pb8wYBQDuv41UhjVBkbQvefnj3Ax53bEn9FbXpVvBYT8XPjml+fo XwdcNmKfuYGNtX2KRJdbeoMAR4HvuxnoJ2z97kxvAX81Xu/wzzLs+b2gmFTTJ8drTlOZ3iL2S2wd aM5x+xfemDAxqgdTGBwicL/fhZTDHIbyPLEoxQKj7x3EWpMbGcsallVGvc5DPxluRuchzfmcLIkw CflOwSEJkFNKwzqFcs0t1/2IyyWLxqNE++qn4spcaLWu/UKPEqA9KSQ671lcMxc1X1mf7VH5c2O+ EkO974VUXe1CNCBiBnGRNJtvWbNwkHzsGKLXMz7tLWwZCJqw3lwssTSetWhSJILrsJDwRW/+Bby5 MU0AfMLbCPH25pUT9uM7OLtwZbTS9QRki+/9lsflUS46i1v/MGSdpggkdR5qcBI5d76H1xARe6hw 3ghTRMK4DPy1Cdt3N3x3eCbcNZdYYWRCAQetSlJrmQnzM1Qb9IS2rf7BcX9Kj8z8UBRz8MphT6fF H+9/yuUvU10JXNTm7itRDZF2rOFbZB8SQcbcrrxQXYCT26bcWp3HjHhaKxqfEqqc8O/H/JxDtvgJ mZTF+lnfMnwpHSBKiN6WVJzeflzaOqTv+EqJ4ZCbz2hc0dW3mgn7sjmLS74yID9uA+LqT81Rl0RL ER//EAacmtD1GhpK1vx1Elg1ASz9m/qIysfU5nzhrTnDV5xaDMfjIXB/5orwIAQk1A+U0u7H603D SALOoBJG5kfp6XmYntoO4DmfrAPugHTvNR4pEivDCQCcVYJ8lagHy8WPc2R9xPPaPAjNhmFB4OLA XFScDRBpXSAK1+uCfhKFdCzZJBpOhkx9JsjnR3laMbgzV7Y4tgi1V/oFEvkeohhAB0BtJwnobwfE Q3G5kMYTnqqs6AzN7iI4jK8FMACEeIwF37vtUJceKJviClKRn3F8I8Y4iqn8OJv4t2ctZ6fWb13q 6PfqOBzyJ6kdq4GHvEHrt6TPo4QRIqZEXu92HA94OnLAG3+KU9RuUBXf0OSBTEic3q9W9IukDGSb 0aDG06smHMLF1tIc33zVEYbLQ0xNEtaV8PjlAJfV4yU9IOrqykz7VY+GD+FlNRucaujLLnXfVpNx rptzKnIzjV1jfmus6mlWhqjHjRxomXyEJyFGODvFBFPI9Mcch5tYp39RxFQRSd8NnIdEXAv0eKsA jwort8k2EacXXvnwrZ7J8ugZvOKM07X/wat+RtUIe22jaspP9v15OZQtsyJmPQDVNU6BlcwEsFTO KcOp8Pt+KxjQgheokaEsVQtKBL+yzfuE/fRo6TWaajye3cevm+ktCS6RZexfvphcPISdQQfCisHg JC+XoWeepoyMxAUtuNfT6PaBwNJSLNGZYhwYJv+MlW0/Awo39Wimc4pCI7Km2HxaWxK+dQPuEyDn urW1aZf8R/eeTOo7R5PAcDoVEvU+0AGBKpzM2ugC6GAax6IT20hdT2iikUuufHxhD0tQ1A/lV6+B DJIXoHmPMJXKc5ryL/38VQ2J9qqKRqxXGTSRPJQVvBfkfNULVabxZmm2wDDl51JEW5zR6PY+tf15 0icZn+kIRppFBvZXYChuloedAD4i04uv2CmXl0jzye+6iyut2g109NTr9soAzIvUIe6aIvsUKWJN ukMlJPFUdIfMem5Vn+KkQ5TpLL9HRBfrjGAC72lukT0v19MPZYCwwcADD8G2eVWNNEpkqwQq3Kp8 kSP+tlyBK7inSlhZeCJAQpGFy6OWXel8zCN4t929N9MRliPmCXXKKMTVC4+iPwZb2PQbDD3A1/vG kXj1zcBNRxfldq1+AE9HkUrRIYYiQ1bUtEllM05XQXM9DEXWQbcop8YYXV9zP1EnnhOouvajCRCT nBckRdc8TehQco7k11znvgllCQ4RwSZDTg2zqr+nGPPj1/dQrs7QVDTEt8urrXjC++xoQ0P4ou9V YQUI40adlIkOePsayR9YgBfNp4J6WVBe3VzWCGScE5bxV4qR+qVypKB6XupYF0c/KVkpdUvnIOxg tHeM5u7NwklZDHeqrrSwvrsJOgME7B1IgG/cd2Ocge6ALQeD1zwrltTdCRDKdEFKFtDaQrJf2Nmm OjY+1F9HM+X5YAygVlmVGdqnjHVXkn5BQqHTX+yVp4c/Z4oVRP4Wk3sIbCeofOiXPdzB+7iCSIXV Rj1woqn/F4n0M2wuG3b52T8c5b5NtxpiSSRC5Dliw43fKsCLykoWH6UE7jr6FpKY1JnFvbTPo19f FkhoHwTNt0eyPwjcE36WDvZrr69ZbU27GWxgwR317Gqjffdb6mnabgMFZ1iAfD+65/v/2nymDTYj Dj+j6LpO9wEIFC8NK+PuUWt8zE8MU0KuBIBttii0SjyIu0dQgldGXxjajSceDB6b12/WVy6oFCLk 3utwKqGj7gkYcSzXNXmokRKGeMieKBjyukzJH1Xtc0gMq6ZflP8SkoP5JI06tQQneGVnudywM3On rrk+J3aE9ADKNvCu+t2rhGIDaVeWRfNmGvDSiQgtqgEcwCd3rSjza6uOjM0aw+xOFVZgFpXHEsxl I3aJZjkGK7Bj7QoHiaImgqVaduQn/gwEGCUxFxXyOAJ6l7IX9j3cvSbpuNJJ19chM4hTWSPbyZAV aGi1+gOBaH6xYCTqnm08QjjgjhjpOj7cgLFTeYBojlTltlvOOD62UVxcMmeq8RSl6Hbi7mDol+S/ 52+3vi9vnk9QA3U1bETZDYJEC0YQ/bH/Ftifjihp+DWZQmYiyQ6XqYP1NSgiQaYHnbEe66GIA2hD g1fsf01GWtyBAyI5RRUbQhI8IYWmkS4pdQMPu/wEydl4OcivpvVrRyGdxN8CoHtX7y9dUd9pCO9Z Vn12Xw8TMdlaZfGHdvr0Rb9VNmlG1HcFtqPxROMjcvY8JnzXSs8SOiziHoYN7lJZDQGOGurls1iB hGQkJ3030EjxpgWS9rxXwTLZrM1t8s5UjlG3v6KlxR45uOXivJmKLXDLFqWHdIiOIP4kk3TXREoS 3tv7VwFQlWlcPWoQjFtvv4CNRsQgVceb7lSnqxSSSKkiM5hBbcnbIWJotQcUxhoQAvChcmV0Z+Wm qHZD/fnjDsSR4VkfG9wGWFUe0z9P4RzHj0WKtynuocich4HDgh1Kn/2sTB63K3Ebbzyw6guAey1B xUxQTyngnzILNN3tXpUGe21XLtsHvFdJcvu4aK9FVvASKdwvflX8vjRMamYOF9MSGNFmRi7Pjzr4 0y7kIm2h3sUuXQSz77uM0fBSt0DnyzRRnznd9xaUopCcQGMZtzFL50xBFjzCmedZGB50QgBNeMVy lT9P/F7WClyo/yMpDMtTMj5+24u/z7qR3lcGOu6kezcZLxVa85aDD2cbvM99q8tMlNUF8LN6HlnM A5RfmIC2D5EFyHuqluJYxLf2pqRqWU0nHpvhX8kmQxZtKyZ93XDTGZn4zm5YR/Fw2/WWReTGztFB 9CrEOTAJE2wYURdZeiGlEBtg4gLZouyH5hIlPItTtcIlRCCMlB862R2Rjpk0AsZQt2UWUbdJypXy CfFQoiMbEg3FaWVnY0JUHtHbmmP6dcGvxVLlcWf8GPRO7PDxJKnP4z4ygcJrWJaEJEBs0Hajrs6b RZgcWeJQm+PYMwl0Ckkw7/U4XOx7rTGRFZlUTDH7FTvdC7KcU6nQCOXc3L/pCJLVJtMMXK0aFz+/ SPbvCu+PY4xf2DlcpjUeM+KsF5tUs3at+s992Q7Z2QBzGMKTh4ao1Q/ge2XwrET4rqDDVKa8pClF LsJn+Lw7a13BcYQcWaL9xZo7ArWt2GQ/pxbStxtV/U72Q7uAfr4nRP/oJN3xkXIXDRAmVtuGCoH4 Ses0RTsnf0KQOsANyosdvL74vsltghgdFuIaSHwCRS6s1lSKGjn3JD1yviUrxc2/j78aO8hh2Hm2 1ekYB6ljw//6QtYgXPb4qmdR/czfzfGfoZi0ZY27mj2aF+BjcFplH5P2kG5HQoRhupqr0UVbVqcJ FVagzn1P5QZRlLG/UTuJhG68eWFyg1iYEDZyIOYG1kDbMUc7Pdru5gMBIgDaB7KysmjrVnHZG2kP GE2FrwIMClAvEYBjBqLaKUpevUBYXDYlczG/PSReaYYGFf3k0O7oFiGxLTzbXz+c1masYxpi+YI0 B9js+5zKFS3uyb/Ar6JIm+FvxnrDvOMuBOx9932UmUhgtZfFwAM76GWhls/WgVxLixbjpuEW6paL Hf3E3juTghD6BxguVbjXSca61rqXSbycZ+CajX+vsp7TV/xxPnzfeLsarePOqt7aGtykz+1/+VhZ Kzqd4gPFeFn0ZcHpIKTDpZygGn757PVANNC3fF6WJQEex39uQUSVuNly/Z2PgvPUqYq9rbJ8wGHJ 8O6YJxznMIVra235YDijB3oKMLgQQAFGmiK7PzSjVnk/YHXU7hm6HIi33wnf5tHrppA1j4M0fZQD wUAG6DfkxvAfaxfyNFgi7twTzcv8XJGuY7asasemusHFVe3ePact5q0ASyLmzuPUcdMXIUFJ5ePE 7KrcVa0xe2lkU2XQQwnt9w6gyGo+f9rc1VlMJCWJH2BMPq66CZTtq1X2jymarFgt7+5AXEDZU04C xAYN1+wWSh70w4jMwtLea/iKfFtnbA0Ru+SYN+i0B46SbNZTomqRAHZSXOJV1cs16Pf3sMVFC1yC Bn7L56IkEeLr18t6MsbY7BgdM225e6OTD3JmkalYmjPSwPiE/m3lkJUEBEbuGhtZoREEP2RWZ/HB S4UP/S9+dPM7GzZUZ9XqrLjKvFgSS9sXfr5vyVZn4SML0TaGcrrkWkFug3ABvQXdSo8Pu0TOgazd CfwP9NSQ/E1bTMxmEYFzOQqM7MgytED6PLApD9aCTfMsz9UHnb9VawHBpIFIzC6b+2X61TKYSWdY jQyMGGkp+5m8YRO/K2BJ0FMgfOfsWwaPB169+asqq9d6xnUm4hD/yONGHLoqEMj1vy8RRAU5zBIt XFpFjd/yoBnokeh+4h50Du/OJdA8gUuHIVLrkPdBw1C3e6jlFVP4pUbGKI+8AI6wXClUGwFoFQ4Y ojXH12TDigL1kbHOvBbU2d5Xg7yBIBdk9Dcj/Ca07i1cFYo5JiZlbakRJ9TeSDToSxnoUm2dIusG 9wC3iIMn0r2zf7wEVAuKye+b/qamDZbTb3zuX5SqH2aHnYUTUkvzO/9xZi740sMkEB9KzBv70FeQ Ye9zfPd5OItIP52RoO6fUIDr475gD6eNaOJlbe2u2kH2eCLaxCDk+kIYwB4ish1zklI8UIYbxSwb OfJnByOksaMJsF2XsHclY9gRjjuGbUSjC/1r0v4NWxIs/NnD8yAlIVNzOjYOwf38pcwZ0M4UAxJB 8fnA3qxwsHeIx/cLzegDeXaFC/8KHfBtydq1lYuXn1q6lVqCcHtIpK/CGqP8AN9ByU+QmlRcWUY1 eVinHYGVqEnyuPMdCI7z8mINDn2yNW0oFlb8zFCRfhGBBTUn3lQeRSk5GFgqDZ315MRLnARWRCgz +s6ud/GFuQUad9A/0tjVdpB7ooJq7wJIuxx/hY3vMQl2efLM+3eJEUfXnV2FtAqomB4c09hmV/Iq rERl1hUwCVGa2fRzMWrTz1Qsjd2QZi0UuxePVdtFZ0aRAziZgRE7QokdzWMtN8IMMc5BNt1HXEgt xWUi3mDeMhiekq7PdGBM95PY/L2kAMrH6HLO4Svo3wgMAdEsnUVqjV6DEoyFSyjdh4hRFoTEJbA3 bduXykWbRQywGoRtxhW/i+ER6+WKL8ZLvk+WCXiI12N1O7fTCWOk4aEbywhKZ6j9RIf/MF1qVXUo UYNZiZeOKhrj7gipn5faqzIkIm8tqBiScHH6FgTFExFozkpgjFXfoy4A/0cU36SguMAxnzRP/U8k +ndUc0x4/p4MvtbiE63wCvMrUFeuAohthaetmpPg0pO5Qs3CNMmD2qNL+lNNkNlQyp9hWWOd8tAu LFZxVqNXj3KUBcwUvNBjPNAneKzKt+ZcsdBqAV9qkQjEaDCNZVCQkQ/IkbDnuvqJRsRzuZYLpcLd UVriXVgOjzuUzON2kXsg10MZANpRkvfOuW5RomuTokoL7bTfHz3kAuZ0EOMokID3eLupe7GA8WDM qr3Ew7k1PQYcka/ZPcSjpo0wrMP2oEha6SzrnSwbA/yChTI5QyHJmRidFL5wkB+7VvZdQ3OtnJyC oapM+vjOMwYAmxAp1QvYi6VgvQZCe8JV09l59iFGh8CYKB96MCrIP7eCwpEj+vqQRGp/IoA6q6Rp PfBg03bhPAAXjpNzzsAQAMD5qnhSkTkq9y3gqtHEZa6mZEyLiI6ZOZxNePDk2GPidBmpB0Bjctub ZVGJQ9aB2jh4Ni+tVzBqjgzkglZ6SWJC7xCyC+/XWAbt44csP5YgmyJjWJYIV7tx8ndQGjg2YdxV R1oDNuNRJZ/QSGSwHuIuq00HPVnqwojotTG2v7ToEJ2MeUifWrxFyt9B6GswfXaU7TXRgoDISZj4 HY0ImjDyCC0qnkgedhER5Mi7wYy9/02QE+nGtbpRZ+BH/Xhgc/8r1iXrMwi3fTFDn5w+QX9eag3O wd/r9AhUFdHtbN5ytQ+1xTb2Xymd2tQsVSkLY8CjraiJVFhpCmf7ggw7XGi7qIj8CvgxtKn7KE9P pm+SJRtilSxqdKWjCoCca3yyAzHhXAFauDZYPNr1NwKWbZw7fAUIdAzHSCP824CS7fPHSgmZTgJ9 1BOjnGNUHcdBl+CnTaXlh46LF4ikkeAr6s5aH7dWrHmlcGfD4yRb1u3d5o6BTFmqf8cLPAXxaPvQ nIZQSuT+oRAnvqqTx3W5FgpF3T4ZufDRURLqn5/rKrXFOls07gZSTI6MUDvmSiTENeBGtgZl1saW njiangW+Kv2Y5gQ2ZUSQsIVDv7tySE1Ju6R7DSXzzPhLChLKvtsvS85f/ujWRJZgbGV95YUZ9II1 3gZfv+gqfTiFR9OoWnP08vCDH8AdcMXR0A644Qz+Lq+LAVwvLI6hWf/5W7tGC7P6k/6m/75wroZZ WsF5yVwn+u9Vvr9ycHguyUDFyDYOtNKLJZxeLmn8Ihok9tr7zCdZM5qPaxf/Q9vkyJB7ATU7YaZF pj7laVNtS2rczb+WOUfhjgTA5fzSylzbLeE/b5x+763MjfZ1YC25v+ncK2oFeLxQiJHcbgnblNIG fjDP7/NgqheXJLN/I67/IPT0BpoGmMLonkApOL2mZPq0278qh1xEr87wIbo1SvTbg3P8ZbiZ95nB NA5b/JxYc/yaenHgGQlULp+JEphaS5xj3R4BkkHhQa1nmV5B8Lrq9V7KOopafg2BUMOSlAoMsG4O M0py+xuMPB6RAf2gMreEvS70704rewt9pKFdRcYO2xUuUio5qa6tmGIG/xvJ1C/Wyle0612Xjd4A MWzTE9gsr5CvfSHLI2Flv471rBU+YWsBq2kvU1xPBBfh5BdoDpD2VAdfsaGOdVvw2lBpXTlF7Cju xfy0LGCCWb5TIV+0NEhDAvVbqyJDDVYjbObqi+en0He5uH9DdNnFyzpwQmSEFcIg7OJHGDnhfojK 0lfXN8OQDPueS2c2hZ0onf33XUhR8KYKSvszG/+JMaj+2TOEaQvo3cSq4e/hcfwqtsB6JyDwwMw2 jIsSXcPNC9NgVni6dK7Xf9b/fO1b60qgoytx0Lt2E9rs8qPymdO6dItnWrjjLs3bPzdCGy4JFI+f JibVFX4TxlfksLzciSiGch6swq1tsBcVSNAOVZRuyxMEsB/g0FPN70jqC13VlriajgSmVJOJ1cgN gX/umKJa4f2ajI384n6rTn60JfXCKdzPRY32GoROjNKxdzk9IutDGdzkTlzZtcMvuGmhJ+lgNhZt jKOS5PsjZSHdCvJN+/KTWs0Mv+6TWim/MXsmzH11xTvhCI0JuAmhUGomxi3jVFzVGRhZYiLTmLyG toa5Gd5SszgUyM7S57X3Zi2yOZrjf8wRFXQOemzgquaeHnYWyj1bKX5iI1USEgpk0xz706YHiTQc LsDOxzqyRDN6y9jT+VTvIHi4pGkCfb6qtpzmhWAT4NA74HwsNn9gyuxRQuT73Stc7awpuRMqDZci pViknGBHXtSCXtYU7uMV5lVHpjdRG+hUhvRIfKMRNBOnptmCqCHU3OoxZo//gUAFqSi7OW/6cFZN x4t0cj19CZFDFeQp0LEbQBJyApERQRdf+RtB4RpYSCz+neHq6docZe1h1f2YnRpt8BTTGEsuYaim fF6AjHTk0boOpuxwS2upTgNprCuU+lFP55UvmnzlxjJuXjPiP1bvkrJdIBkjS3CvXHiEOyubQrHb mTg0m+3ZjYjKCCYoX9gvf1hREZWnkO68shoG6XwK9ynWV4N6KptHW9m84QorUBOjnkKJb2jsxmEB I19ouYwQ+X2qbraqo1LUhfQNEmP9FdDZhQnrt1PjA7HCF+4g9OrE/vsGDnV9YG1GSLMfeHOOlGve 5EB8fCuRKEKAQJgK0Rmna4KdLe5KSwsJJb5qArM47bev3sIBJapepk0CniTWLkn69ZTe1M/yW05g h30F/RDMVhmcE2+VtaecTCSc6pPa9sqcBo7jCzhN8m4pPxO47S+pBcS0t857xEetXSuL9uMWWQya 3bYKIM/YphhiIxxVpqnpb8my+nVFyLaJwMt2bFdiyZVARQy4hvnOun0P60Iw3NvxFTK2enq8iLWF B3OcRk3cRg3jwELBBZLFrgGEnSfszLGq6KhxiqWIh52smMj8t74S6MqpcziLBd/rt/yH/VLnzdME 1T7gn1eUIpZmidyXrws86UrvhAVlQHJDL2c9o7r1uT+Wr19AK3AExdEwKNRtdhROkkIGMjx5olwa ube/P46ozAGR58bObBinn15UdyI7XKfZj2uYq7h0rjUEVKThd6igjGipS8MV8yr3eeA0h8wnDfe1 /0A8DUm5J1QMkksan6Nnp4Yc+B/8zJoze6v/L5AzP7u5AhQbEH9b2FWJBPH7FJpA9+VmmkoW2w26 1415/3K9GYCmVBNXZw/nsjFWiGpxwzYx121j8Wnv+ZLKDodsHeewL+ld4kZwyfoovLxP2IMmT7kj JlEikiN7mSlxwMOD/3Zz1hoQWtiVcohEfMiQVz2X7N8voI1aWGISzqhE1Fl1HWeUu/SoUhELiTmP sVscYQGz0+W10i1mR2DvKkEypahsnOguLgRQ8eZB2lyDjxPECflH0YbrOkdW3wc84RUchl+Egotc yjmM/LZal/EbxRfWzlUSmcxPJJIPAbiwRCQWXB3ho2GNu7pVCgTgzPYZme8SLYaY3DDt2JpHQcsG rqYuLEhPTR4FWmzGJDELtVIscZb4UNuN3QXFFC+7LaEyb2p/s4DtK9IqiFkctVBJ1H4x7I67eMau m/SzLKS67mHPzYAm8XE7wYB1EALIjgWvjEN9tanTpgMB+TF+naqH4SgEYl4iE1Z+uwlhpmjutB8B PGAsHZp7eyzuvPYGQ8A6Bl6z09PHvCOa6rmQ/hq9Dslh9jYeaHUjp87mQWuWSdSdB4GB7391gFuZ e3ON1pPQC6fGVYcvwNSrD3JCSvbrG57jq6AVlPn4S1XxV/Kjgdyn+SYXK/ubN0FZ4GFB26YOcK4o B/fIpV0mq+olYfYKsk3HokOA4XmbFu3g+VABFJas5gwxFK28YrGAI7EyaywSVXtuLwrvytrzMWhY 4jodRRG3HKEBo/6cGCkHy+gieIGYNvr4FM+4DrKSSEVEe3MvIFFwgQG6LFE/1jq/wQug8O6hcOq4 llbGFMlxbshlBWkcmwlcXYKYuSD5X/F/a5UOnt+IsSjfdIErXkNyNqliiJgOL/hd06egwVNW39il Vz3E3lUAlZGnk5i/qUDFkHngL5iln0ZusBFJL/Y3l/Ok705G03FnO40rp6I+27BHn90udfok6zKy kfPltDbT+TQ09ZvJBtgUAf335qnhgeAWq1wOkuObM95HBvNB+q78B5NXxcjGGfZ4kup6IyaIqXgz RC9q1ysKNbA+4OW5e8yEbj1UBRLyMBP1DP4XHL5t61S4qeBLd3Ua+W/IRI5Hyb7PQpwebJzqSYhD xMkair6T+SvpN355DsZ4IqqZvxnPSvk3hyQvdtEn4fbDktf5M/8SZPaFA1rhmNgk7K6XjiMcZOjs a53DOYsci+LBZa4gZSBzJ7Fe92ErD3/n29l55UsyxLjlXDdvOvfvRyZtu2KFP6CCRea/hdMq0KhA m8lyEkLm/WWUdr18T5xLZmtvfGncHtJgSO5PbTeuSXJudf5ChSSyvHwK95jVcLf4HhLo6TMqW19q 2Givph8ukp9Sh9kuhtCyJTiz4dt0UHu2zGdWS+jQ+H+DcB/Am9p3+yU8VwRwS0DwqmFIKTRjBXRm 5FfAezmc1RQ1vNdotqR8wNzsj55DF0UEqiiQY5IzaFk53/+mJtbpM+G5Hv71/6B3RCdrt7m5vz5i dEzLCQCU8x62FY6ramQc87xQDa06bWdUxjycRv+GUaZJTECx20xeh2Rqd7Nki5eisBGSJNltBF91 bf0oXH/Zt71ZycUcmrdjG4RHhDsyuLUIbOcnGqOq5gq5zNDiLuyg+YCWrixEwWPT3mXpBACfmoQw sIt9fK1mVAj0+0evnT1x+L+8OohQqImdEe10Ne200PcLIzKNYfPz/J/QsCcKFbAHNAxex9p3vrUA DO9bhx5qoicrRQ6Qn29gpU6mJhPeqT68CdO/bQHY7fuoHSDLeOpVOf1Rg7xU1Cg/bj/OtObSFNIP wcSTrmCZgmPkRfQ2tZyFyYkkFOFcbVCf3WuqqOC62NzftXfAYjQz984FmOmf3miJpehx0I5UtuSM c1owLqUcXx4cEm0uzimswURbJT13jDEhgShz2T2OgGdSEFvJd5AKHN2X37qPFji8bJ57iL1JNB1m O7DSXymWWOZ4j2MiTzCHmCxrPfTuHuTnFb2PWY5Z9OUcZ7C/tSSgF+IYolSstxycXpTeZyc8otes 43c4WZ7Rtlb3fxjT7zHr4aWI2XWN1I38aX/4Zk/PIfCW9lKU83QfXb9H5Y75mcgI/WA0F400KEdy 6lrB+2BaWyrfr5xKs3DAOim3nU2zj04c4yFh4mJMyWOkb4hOgEOqlpt0MH8YoH9chvu0hPQZfEUN m5ojq5GYndCZTqXw1TL4a7m9vuOAaNaGyH8eGblPYrIM6klPAGJbXGIwXJOOh3IEa1xBdRtOPxqP B26BJHUWuXp8dD+NCN33Vumv936C7eXpxOmnNOhUh9EW30ExFVwsDW2kg8zTmcnTGmxATp6L69Ny 2wym8TaB2MB/qtKgM7sWO88NmKimZqBvAt+S8Xm5IKNSMh2XGUrp2csOusHxUA/fqo8nJHBuCTlO QI+T5KLrAhbz7bMm/hksKDyURuj4fZ21IozSmz6enlIdUN3N9Lr/osakGulv3+V6zfDaLj5f7G5Q xKZxuxs3tih8SYNxuvwD/KxlAMiURWzdEYQns6jZ+S1e4nzbXU0fS2o2DH3YA01S9j/OmeLPgCPx RPM40wZTM7IhpUNnQu4KJDA258lHnUCFNsuo1lHoEk15igALmViM45EoIKznmz6qTT0Qbu3HYj1p 6ORrMZYQc+jW617vD9fiexqrxARPPRSVr1WaAfwrcAv5xD3jARU+vyz1uWb7A8bqC4mWdFzLwLNf GxV/RAmZfOfs+FPnZvFk28DubaSbHKNxckc6ArWbbaZ+36ZDNOPpaBDrIgrrhPfb5dwYXKJnfsKO UA8MKx0i7IkESAV1uhFw18PwEgP/4vmCf9wA7HVUCv6EUFHP28Yt/agnmxxrWft42lK+r9dhw0uS rEHDOmO98YHvgwa7WML5nqL+99BYq8Id2F1fMcF6Tjp0eFSgYSYVtk19/4dtmZImQQKLKEuXM6tH 1L/X867qpacP32TyyS3X8gDUNY/+qL6wQI1yBPSqIREeSi1l1VAHpW0i9SFetA6f9+mQALTnfFhY itkBotNgTewbmtvi+uQ+3jxW0xjfd+9tSIS4NzyCaVXgDErjGroHiCemWBNmOxlMsfwCJEq/pAMN 3VpWTg5bHZBI3hptgCiXPBdQaXFMM4pQ3g/I9gTatY8ra/ww/gziZArCU+081OCoBoYuC31t7/ch w8bZoZFcxvcVAAOLTKutTpubmbPX7ssRK94mMPYNV7hqPu2fzHZdfNKQHswMSS3DCGyyq5dazdte ZNGQKCMZ5Mrv/0e4E4449YoJdfc4nC3t8jq/Wk60ZockzKhRYkyCglK7XJKo1tTeox++KWNfdTKs PUSbr2xCV7yJlMqLOEhOr94tvzkqGLZTTKHH2INa9pxOqw8khFCLfTbum1WGXlo8sEGFGtJKeWPY gO4xMuTM+qWDajMGMJOoVwyK1FJmU1wgH13pkbPvZ64AjN1qOh6N0B2l3n9WzU6aCrrCMWVW0c5Q WjUyaZy6sh9R8aKBRNgok94dPZdFzYr2icFhliUyL04IEP+yA3KioGr7RnysDV7fzZJbmMwrcPzX boA4MLOiCNiv8YcSjGu+2frCHr/6/dP/pnSVooWYUm7rD49XhjvaRcxrJmmCkPlL1a/a9nXc4E5P nl6HTzvqlTLqZBZQ9s22Xo0u6TABJTzGG3GSkf2rFnRTeQQp+6ztl3juxfA1sq5VJ//ECzdQbUEe WyXrJXVTSSRE3aEIyJpCSr9e6Nq3IdanargrgurzVkHgdttr9kMsaV1gtykuF7ExdN2qSnPGSZUZ ZePfr+DN5/7nDhCz8/M4cGSZh8Fk2iL9vUbmCfXROt4f0lD8uGo8NsEms9U5U9XRUIjICuIcp9vU sA2s91CyfJPg8EbSjEhivlvbSRNedxJf1PZyprK7oIX/zUSyVZhAqzYdLo+xTB6G5vbwcqGa9erl ksop6WWKiE6M9J/Nk0E/4r3SmbdBE9QvmMsIeqJRXyrEzt6crNMw5T9dXTPzJUPE5J+Wd6zZ7Pwe 2Yyg9fLaLZIPtxQ66MR7IRaVdrWQRV3e/TkK3QP45Uau+BK3LQoQMD11WmTLihKhRZkDfF6wQwFM 6/gy6ZobPJLNQKw/fClxk6ezSvikVh9f/X/gzpwqBSCN68SufjCO4BlwMQ0jwHetfCKRKfukZVoA Qi1rPFT4B4cOcMiZW+HwoniV+1nFFem/j+M8Qo54LqNNb378A1FJw/WX4csYq7M9wprzVICwCfVi GZwrR37mrEMOE5DP4ecvA/PmCWtij09ozswUGEjte1fOZOFHA267FE+cFaWAMjQJk/xU7ZZB6A4E tFTJtZ0tsoaBaIq9f3sMi1ZgER5sttL0V359Z0U8aMa81NvrfoEjaDWpawYQuur82BF3tkElycFo TWvWnU5VtVT8GElkYeiCwgUWsS0s0O9T7cTqT+r+tSi6EXcIMCBIWmfXF1jC8BeK5cWucYVftKgN 9mBmBGgUIrQppLO3+9RLwBUh1ttwVgFbuYO8WqG7XvyCBn5Srh8/knx5LFsbx/YYW0fQsvKhkJzc 5X+e2pw/iuyxBbJYsVKgk1JXh0DC9uvKZM4kMHAlend/M9jChLVp/cRbssmWrJq+cr2BsIENjZr4 6/OxttfKuaoHHtRVeYeuCsDNU2mqkxdw+551fEIKBbAYRDU7VsSoTgAlUQeVlZZEocSG7O8bVcn8 zsnL4Cn8zDnoDH3MEAde6B9t73irjn0vHzgOzgaXNOl1qsg7dmdX5rSIyHcOey/KVGOIauz+DX7t 2j2phOjW2cxOQ0LHvCcooGvUFZjzxQAxEA4u4/ThwGdAEvhzMudaAv3kJcE5wWcbVxSyr+qwrlzH jhei751s4WZuxcixQ+9QM4tyKGOJ1qYd2EykjqhCjNhyMNek5uXNOchVI7hkq1lWjNcuIe3aoXNm 7CH/Xx7MF4jONwnSh8AxNjhmVms3T44X7hKVScW2k8v5mPQnePI7zzvBWRD1Yyr5l01Xh4uoPbKd g0TBE2CHy0neYgL07jRnVlyJ+g4shXdXN7vkfS3tfxiCnqln6UlgaC0EsxtOTGhOSUb1AkgndLhM kD5bqETxX4Y6oBcLepZ/kHCwSG4TEffRftxh3TTlukopqTRQappbmxlg508hhvQ8iei4vZiZ2OYs Ag0Yzs6lTEWF9P+X5Tfp0B7fEaJsho5zAh3bIhC2eN3Ct7hQ0CHB3K8wsDKgdjsZ0B8j3mk6KE/5 zHAAQb7gqDyVuj5/qqKT9LTqcRIGZBTvrMrQBqKMHvXf/6nyHYekUNhmY5htVQ/mNOHbwuqyAgoh hoxUzuoqHUi0RKdVMvkLUrqsmaeRBdOGkO4x7Pw5YPn0fdfwQul9FglE38n1/aQX5yYbUonhMwlR RjZotqWxXz3rkvhS7mlEGec06PMhqUn0Xu9x5tvuVu27qaWC9Xv5VL58iKAknSn2oN3UNAMlXUKg zJDRODrY33CISzpzBLJj4pBljcwe0tIqSxElhEQjhcGrXD97R0bYLfs3yYCWOqx5NkVK2zaBXduK VXMq4JCdvpSpmG7M+epi6bhhOn7jlYeTBwhwZ346gP+P82Uul0f37R6aqQ9mpZ9yphhcZ5R7Nwo0 sQx0iHOVyw/QGMPgM1cZUwD/0lZHwsyrzkRtM4XCsmqOa4zWNmVmHabV2rmtGeG8OJaltMtmriUH T6WM6mwEfK6ymC4KLnmZmL4CIYTvcnzy0UB796QTCwslwroLsTjaFJb42hqVldmix57/0qt4KN9v KzsDPmguEuECnLgsbaNk70N0Tot2kK2zRwGcnmG4ZX1aMrNrDAzRufLnMy8GtLJ/1OrUIaDQekzI /3B90UTGXfvIh2qPrVkW7m6I9Zc+wVPZyNfnOepgdkZufNOi5vif7qZyJL2E4nTCARxBc/llZEa+ PvWeU+SARKtTYbfuqDFSeNN0dBI40Ygo9rY42rDp0e3qI4xuJh7MCcyqz4MTuoBlgblCiYuw6coI Xl/Bk/MsGD5EAlNIcdyHoIkgsRw8TTmNhOqLlhmmeauZvddYoFTW/e0brXWdNICW3fUaFF5bDPtY ZPV6bgj3nM72jo+usgDLhwzGTgj0hEelhFWJ5L389sTac0JVeHhILl3OPtghOWW1ZEoGaSc9GjAJ byXeKHLt7NgH+6YR3cxepv8V2b1mGzFdBScpfs6LyBQP7OXpwg+KN2IuNzKfa8XdHNB5br80g1KY h2B5WbgWMaa/bo34SY0LPOZdWYY1AdipO90VdEPQz1D6LdpE5Kew2piZCJXCT9IU5XZt/7wAsDG/ Nz9bIUe4l/ab8SwAaybtnxCgNt9vm9xe/U54YkGE9Bb3Nml7xrhx1n7RPnNzw6Wy952lVApo+xOf qXvsOMaTzuchKEQ3DGlWYGmPS0wECj3240p5yzd/M7IPU/R9phxO/BIwqxvBX0uTevgtjYd1xzFj z7XLhcVreALbO0IeUUbFOmD9oXmC5t7bxF5D1fy4gigXq5h3+IqYG5WID+kMgZZ7tDUZuhztwIqa 9w/PyxbqhxRduHyJC4tJlyVLArRbmX4Ovzp155Gj3WSVJEbBe0EgeXB3t43RSIfqC++dPUa+Oz1F CMkBP34SDfKtib2y5gBNr8L2+/vpP8VBnojAxUmch9+jx7/apl8jE4ctQpSDisTGZyfXWH4572po 4+2zFnxd5PEKyEouuku0J0Lj8mo9aQd2164hzxGhrAktR53igOJQO8GHG/oFTieAQ6KxPqp8wVJ0 NlN18rS5gP/tCcYD6yw9gcilhCtKuEaMJclQ3irNciedt8h6w4FQJ+PrPPyAqX5gDyNYSIIvR4Kc cP6q3oYcA6KJwCXRQ4EkqmvWbqo5pwX9aHOmureQZiyFdyzfPSRa325Gvz3W6bqZCqmQQOr0sYju lAC19qltTCy7c0RjwP9hkxMDHWHCs34k/D7fSUGIIgObunt4n1+08sd9GUODpeS2pYeMLMg8mgIq VpCrZEwg0KPX1NQs07VlCC5Inb13dj2ugQFedGiGcD19Z1rY7Ccki2w6MJDX3jKkT8AsWFFRipCg TyeQznWO/oWR/uigrXcxpaCqSMTSRZh1sbKfbVp85haX5YdEh0oTHmh7oAk8cWWmnJ+q9mKdOTL2 wogsHmPGWVN4SOqGnrc1PkHvE1wkh37eBUSKrIoDvzMDioKyUJurBkknC4+wZO5YhvPTT1pp5sBk I+WOiR+D8a8ymN1+DCbH90JWxm2iwsb+aIft45OCOtdzV82aDXGP3S4ApGt8jmXSg1veDSnDB9ri woBWME7Bd2Uk3bNjbTUQ91S2ll0Ut/vdsHLCozrgOHREygv1LK4mo/QncO+HbDJZ2y1nKwldSMNb LzMShSZg1IjuqlK2hDgnpvDnDuAmosk4Vj1na/tjgSZ89xvTMprJSpbt7D+cRg4s3hbHHDat06y1 r2WL2Esf4o269LYhAJC5gfFP4QxaN73eRZW2fhIgYsMx/jx5EmR+Jw0+yKHo4kL8X90VYTcz6fJW yv1rIimjVf+zqvhhWB1MXpNci6BOzKMGTPvo6eIEODfa5cv5RKguGDf80YIoih1zbMz7TFzpTFC1 /NCcmNYg+BHTJYzsGb44w7vIfc3FyfaWeA5CDtjH/J5vljT+eAEkemH4OMOlMcKUfB4dT1VEpliI wSabIYbDem1PLHIK29uNHeqGdTMIFULk/5fjkGquWFk8uJQXybwydYNhuxRL7Xray1T8zA6LreNY OogVcR36a3AvAPVGBwipFnII47Nd2ChqIM+X81yQQ2gC2cd0SvHfdMtNjaU+XzmGqRXaeV3sMj7G ZQ1XZ6dAIZWaUAqT2PcB0BnRhu+fjxgArbhhMBzaYFW8YSDO1yRBi3nJ/l0x6yA4pRELNrXTMKw9 HaUxVc8wwrqvtAgaSaHpsZUkqwa/cWyBE1nWq6StS7IfF6zVDG3J1WSDQDJtOmpax1oO0PvGYEsR TD/9663OebNWdhwfjbdDpirpZTdpfkvtJz5uJAKXfJqyC/MCU67EyO/xw/uLznaMit2aenr4HaLw 5kEJ9TdpqY1D28FxludnYQUB/RrWVUztUXlzmPavQwg3rQfSeorfuFtQ02VUM1nIXsEd0DEoaq78 ksVYs++G1rjbrLOmbFzwhgLPkCKTEjqldGCJ3LKM2u1uG0vRmiRjdVQwQj+tWsS/M6a5BWotZb+6 4RJWCOH9TZaB5dtAZXzchU0+bzvywfcHnKY4s8uZc+Ik6m8q90DOKqOVWAfiKsLwWNxCzqs37g7w ribXqv9lZ6oGlZufUM3O3NG0fuaZfJZY/91Mv6HKcjgxxIkS+NCy4bu2R9IVLACQHdCBRhw4FYJv MfEQMyy8M2zmM+I9R3yN5vYqQOni/N3WiFVOnYeRKh5SgOTUDJ5/IWqzHyoyeT/NgEP4SCCHeBrM 9HNja20VEZfnJR9HvK2wtnYVR5o/HY/omYzlutEzgHMKGAUqiBarI1Az4kIo5Zg76+EP/BqNdrkx Dm0RobMikW+fNyKnLNBNXez+aMpN5COgwusAChfwMFAB6XyXQ1NWmOE+VDZTWFVY8QDsDKJhcWvm 4tAaPhy0C4u8ZY00G/X5HDjWs0l9sVRLMu520x2KsBmUAQrUM0iiNS3uQ45XqtR6le/pj+45xuib 2brxSh332in2wuxPJDuoW7IshaQWAQGaEqVkv+h7FXhVJMFlENNKpFBb3WGSIFU3sCBuqOnhGT1D ZWKYHH4bkaKPfvtaigBFhVvr1okxqaYglN1ZESEuD3eDPFx/G8bUaCJLbaWJigmXK2MwLFoLyz7G qd3mZeYXxq9KgMXzSE3hBOu1iGg91PvlqUdDnmWMNHjY7Ag37g6u4ar64vF12lmMdOOvFYOS6c5C y/49OykHOVAS5zYoe3AUDtXPPfGOr1u88uQD7ynD+tHpCoaejqg+OJMh58GUEOR/GIJjt5jo/wkI aRbGPVgAoiszcTylCu2jZrq2duSo/Cz3e4eZK43qN/rYuuV+Gj+sk8UjZk/JWsmjT4s18XOtv00B 5GcfaJP7Mxl+YnoOBoxm+BGuBVLCKCDUHtzQJMYWzaSgC5QC3D28T6zj7N0+kQUE/ESoLKP8mbvD T9JKxdPaxXsPnunoURXIVvnLEVhf2jgf8Qlt4SjuoGAEGZcMzAsXFAXkIWNuf6USXzZC3t/i1Ni+ TCY0+BjB5yacEyW6+8jGsLuhVVD4aYzkAPXgqPtrT8s+Z+RSpX9j3QrJHduqsDmkNOkFQoIlwIQ/ Pgz9kAxZqMQ7XywcFX25jBpn4//rOOvlbTCOG++gTMrItxGbMfxInAZULorajMLxc4t3cUJT2v0K EIL+IO/M9SiX+EP1AV8lYMom2ZmjKg9kF0KZtMXobLBjOSO1+1aw9onxtm8xSb047ATfrYw+YHUx 0HSyJJmoj3nobUSJjwIZWgLVqkvOjV+lF9iCCsYMyUxn41f/b5s+TTe1vvsMm/Zo6cHr5d9+iEaT i0UieSzEU+dZw4xbtaDoHK7z6ayda9QcqUHXZx21gX31t5o9ZajOGQYM4fb8uBEYuh7ZSoEW7ZXp UlTJQq2ux0wXG+vcvX1K1mp5cpB+xd3rtmjj7qABATf36mP9+RT+0bb3szTpJNq9rhqniL+bl1QA Vm5KTvGT+q2gm+/WXj/NTmKbrwNOwCKqPqPqN887trhZt4P83G5S+yI2ZNjdu7KELY4Mc7w70v4B tOFaLbfw6c2suNv7nvoRgDqB7nG9zj2xhstf9Fy1nhs4+bmUGK3eWkY5cV8Fl56aJvN6wa6RGvpW NmPkybYf88zvsVm7U8vlJdcz0dNlkCIk9lvO6v4DSVtxmoMjnwk0WfWiicX3mnnaZJhmoXqEbOdO QjgeJwZrs1+kczVdLklyXe/yRHZARDfaNHQZxi/DZns65egNrlqlwJU80siuJmi9mxUAnKDlKswP 2IglGelxrYHa0bBaiEZmoRjbjDNeOYvXm0GOi2ZPWZ3bthPIDhLiYcVRbwEmzCwOHD+wct2INIjT HFNRN+TmRGkXg8GcVtaZzzLDAoSBn9xMJoh2BmFKFS2Iabe8rJgKMiimvjBQ68KhrkpE5xmEB6zc aYbK72TC8jW5I+7ei7AZO7jCjrEkgDSNfnBrKO1D1o8RrB4piFjwfF7zNh7TquAWrQQFyo6yULuN R6kAZkaDll09aI/wv+zTraVcbcCNWTtErhWeNx8V9ZHAyTy2eBKpFl9vGrDCKa2fRwWq5V+kNVG2 uwwsNx78ZkUu3+TgiFh/t4r6Mxa9akqiaGDjZCnbpmEvMTmGIPT3uneduK7ePnY+q9GlnAG99QEz sITvwpUeB60beNnX2/4D0gL0sZLPQYalnz35YeK4oA2+pT8a/99fdYw+u/a8DWn0o8MoUgIogyU3 xn+MqmQHQTm9hLgz98BtxwTPJoImAmm5DwTclYI6xie7bo0t73/bDKYgyZfSTLjgTLo3ujE8PlXJ C+IgOJLN7rAZ7nPaUW+s1Gl99WtqENdHB+dCpjB77PrNNaLg8YJHnytuZcXrKPBxUCZL8q8SJsLy v+Ovlv9aczMvysBdEB+F8fDTenjmlyhXofHsemtE8OaYlT64BOTouvhl4bX4rBMKSY2LcLD9gW/x nUgXrn8dZEVNaCDwfz7u0XA0WWlhAHlz6RMAkbJknpgqtbJMOH0z06zgjooapilAkUdM6cizQQdK lYSKPLSPsDlW+ZhCE0qF7QFo0uDlhlaz3A7mwQW3jgXxT7sa4rZwdAqP0evQdUIoX1v9vi3dPqJ0 Axt6SclGzFyqQobkfYy6Bvn3NPMmN+YOpd3qOVhB2gTt0cKU8SJBc3TZ59jR/OM6NSiEa7O+CzPJ SqqnAv2DbulyppL8CeDv1sfUqG37u7LaEdH0w0ugK/I9Jg/RZrcMcGKpORRBogsdXtHIpXNQdnez zozgZtc2FdQiXUJFV0iDQJtqQVRNkEgSYZEZ5VJ0XWCvEmLUce8icAmX9TLyQcfxoYIAkbUn1cq1 VqBX3IDEQPkqdFPMzXT9weVRcriGHxh60HgHrM131oySJom1W9y7B9O2W9IE2eBlAi3omj13V/rV ktuvq3m68Qtvf+lgicYQC9Vrss22XNB176kdpuwjHkHb1L1ugPQR2gbs17WuliJuaRecKsUJH24n E2mNF2MvA+MEfsnhf9aqCH8LGVOxi9AxKdgPJkicjBrWvWERIPdX0LXaNNEvo46j6Oybo8HAT0j6 nHejH+1vh2otrnwX6IT+WlHn9ReifEGSrRQ2i+hoHzw3kR45Te2ovZJdKBTAjmS4B1hSC5lLhEqI PYWyOM26eXvMvsAuGu0qQV9jKtkedfRG46tqHIdU5XuuR9xvbeNI4a9OW7P4/b0tbiTFxRlcREBS aE+aeJuO+vXHR8YMYy/g+B/0jaPpD01heG0F/R/BopdHSJJaGRd7kaElslGRsEu403qnCGlODCKx wJfleUl8XgVJQMrF3IBJplYQYK9UcfW3maQGOgnwXOoXZQeFo3TFBjYwXx2fDTuha2fah+di20KH NTRCOq3U4pOqgBYTKA6873lZdLhldApkd5+ujthtHQUOXSpWV/k2GIIEB0qUtH5RLhnBAkkAlJfL Sg/0dTPaGpVoeso1zhDCauutJuuRKzPTauDjYdZaHIbbMPPieLsPIh4XXxs1YiUvrN7jgzTzh7R/ hGSAf0nTZa1GoofA1VPwUP5GVSg6yC69evg4ooaF7KTyqXTA0XavER38ubUtc/LLwSckCX63AUza 0OVO+2k3Sk83noEx8ZNv3WrucaFo03T3omN+6o1HFRZ1qIO0H6YRsKI7gmCG1k9UuKxhVco/SQnL Kx30wJhjVswMJ+pgkTU/kdqsKRsMKcTIbJbkodFafzgLCC0R/QOZealhcapVg9gfrlvIpA9zjiL7 JUd6N1mqm3VFfyp3fqFTiKBk4KwheMWmwt5OeLDCNH08JJUSbTlEfQoy7VEg+tKob/sl1vEtFtOw Sy9uoy5NmArQhYCHR18es5TEp6ecCNhfSZSgzrsidjl2qScAXNaB8OgrB8Og+5Sph6LgwU0UyuTW U20EKlQPSQ15qcqyovxBdFFODe4QQ+7WB9SbZu1UyY7Tybc1cauWnB9ZJZB2w+yJIGacFvWE8u4e hCG3dDbEcmxv6bIBQ35gZhsO1/n+H5xJauE486bVpHZ8i4S9MFYAFKsFxqj58z9IZ+QxMB2Mcr9p 0Oij5cWiJbJ3B76y0LocAAY1GQZOhM9PIEOVDZ9Oda8ZN8N1bYZ9D2s3sw3fUpuwdZ/rlXAe75SE NpFY8eXvu95LDL3d6Qu47IuGk0dLHBFzWWgeNkq90YrFg7LytEEz/T1hNes1WHuWaA6GyF0Q6Zeg inPKICpfKbF2NCUMphpr96vtbxVZHBj7MM28hQorKpHsSRiht1PgyNYo2JcQ3KAYnkH7hcRji2Tg PzHIC5WGBkJ4SbsJzLf5tfY0h3pEnLfzg0d2vfjpLQKK9861fENZSGe67AtX3UCc6y1f94/AD/Wg wO+C9CLzQnppAqaM/j4dmZp+YXZq5/crUtGiWVkYDYX12bU0PPJJdksEaMFb+Z20+HloHypJ7UkJ bZhKTLhWEyzKg0wHSkFV73YgF4fL/4zfLDNGAucsq9UelLMjnqA4qnrtTj7bWI4D9y467dsPOFnl un///zfy/4gWTzJ2uCMzPnwAgEgpfRNsZMJ46kGirM1/nPVHNCfnq4ZxfCE+DAcEIvZPMkPuYLYb ernfxg0RQnVst+viKZT9Y8wIQ8e4XA0zYLgHslXoNHruGaY/LQx0T9keI68JqwR5REeB06EWzhtW N7uyEWdIwiv9pv/BttBMCiOC5Z7ZQdjFqcNaTEuXV+OkZ4lgMaSblDlApRBkQm96D1hgeAMRg/2k lXOoEJwI6NjIUAxbDhLL7JzEAITiOFk745vtQ7GiTFJyVuhd/J5H6GRwEKwLoeG8coGl/lgS9JdO jJZkJxIl+Xp4hZS1I1gOuKa1YKXwstX8kEv5pWizmYo9u1UbJNyApUEooKAieApitX52F9f/+SPa qqZfBJjL3bJKoDrk238ZO7q2R773iAdx66h+yCj9byR+cehFKc71ttOb3InbD9KX1JTTR15GtYW7 no70j5QSAHlL8TPW4wCqWBPSjsF2BvNQn+qHNpVAaRC+cH6s6hcA1tlHO8PLsiqmw0GwQehxmqcb nBczqgEQftLiugNdKFaGZ/zGKSv0OZnfO85LRfab5+fEXd1f9KIWj1lwbIBn4+OI6b9lfJ6Gu73o q7ocYz1cJhELApXQb29wL+ZKT26HSfxRygIt0vyWoqxk1/L6tkKLkX/JIqKcQxCewcWa8kUrl5hf 39WI67cWlqqIALbj2nAImKI+5AbHPTdmxI4UGUzYcH7zt228w4OccLmQXB/MBls15wu2s6jBx1Qn Vgr6wYNH1T5z6GWOWuE2yNgaCaipuUFNoxcFYJiXGTBa7SKEWiHFSY0QeN79IKY+GoX3F16QXeDJ yauaBQ4XbpQaUdxb4EC9KGnSJmSu6qLnC/U2dx7ftFrR9uqnUPhofF7gAhKsTC8YrQR2QgpsjiqL BBup8aIkENtQeAo/ThJ7ycNt5b9+NHJFnfwfbi0DC+lxaRHjEClxdG35SjN24Ln1Gr8HXuBHuL6Z 2RMmh7j+Iy1e2dLxcJ6jJsJ2/BzGTGGjPBGSep3deZ6tBQcyJaVf7DN3BtUCLSFKMX2WlEHNDr8J f84HZ0YktT3RSsQ4l+ZPWNW67J1WwjZazXsqcEMPMWDsNyKirSwXOe/vGxGRcM//RVseo2tVCbDO WE0g0wVDdHSg2IpARaHqaVJMxoUx06S4T5/ej2s7RFN759RpXGB68ga7XePWFhymL3k6CnlAP8Lp 9I9xiR+Lt/lOSh8tHPUPH4i6kTdZxXNA64G7zJ8cz4M6kilxcBerAMHTL/5MYCwn+PHFHMQ0FdkC i7CY8XBRH8/D84mT+Ro+fhKDKK9WxI3t/Yv1LvGRx+92Qg0ss4UcnPuibBD0+2hhw5hvbYUXIxLB xs1Un8x+JIW4NjWT72lh0ssvynEJFgCEJNn7LseHwCk71CzCYPpIuvRqBeWmw0GC70pUHoRE5PI0 cCeMyfaC7l31pukDxTJR2lhBn+4uCFJaEMXW0N9kHXeSk0LEHd+QANGVCb7lCidBNJHDABhHh3kr lTnCktMupYyhKAzf59Br7xZmFVK6CWcip4Whas6pigop+3LULa4Op+v4XY9C1fdfseiQaR2GVZc/ YNr3lik636Hpy4ajFWLnnWurlozbrkvECRwG+j160vbhhZY0309f3q9WaPN77LbFWtT3QqvjK5pv 01WTNiO1wqb6WRYN/rg6RTbPe6rDZ09lprF3gM24dd2u97osS6s44O4hnyv9K/Qu8ZK3L5nTdZq8 wdU//12uKafX4AT8NJTNP8YJzpkTPt4er0CrcSnaLILjuoI7S5n0pixRpyZFur549oQWgNCN0GX6 eu0LYePjU2Ry1HHEgPfKqC+3xSBixtKe9RKJX7UtlhPDJvjXCq3mQup2OUcln+l0bUqBFay6ytf5 7qu5q5scVa9GWUSUX5laAxk3v6rt14zZeze37LqQR14gpPGCDUswhig6/xJ96EYhUpKSnOmXcAYN 752jK8+X2+xOaagod0bYBtezNRjltbgJZxxc/L4dSKoR/+JiCT/DAN67MNZCTLAzErqFg9hHTAXs wv6rv0E+WGnL3NP0kkkR4jmATrgOOh53D1ipMd8C1xBAlgc3eVxsmoUzD2t4eGTv2YDcjA05p0JH ZNkCZHTxfOc6xGkFDii5kyMawpHEVOu5oqpCC9hKE1fB9qBKcszJ0br7e4wJ9scCMfCx1ZDB0imn dV0eOnoeubIQAYA1c4Jjlq/XdW4PDWyv35zp5yIv8O0VsLpJyRB83M/oC5vnskLjZUvHW4wq2jWz 0WSakkCnfdxqF+YqfTKf8HdXXRWl3d3kaGo3lWKJNatNgNvcCpNKE4LHVUoE/3pie6C8tyEC3Y0D bdrulN7gcdRX7t0e5OcAZQmOGh+iT/y3afYQIU5r5PZLviJpDb1y1LJ1yZAke6VjvEgzJ3xfQWvb vCcEOkDyC2fyVK+cOdZMTmgd5Qf6ptHMWC0bPI2oyuBR4sqHsq4EIxDJTdNquxafLWlq+TQ0i1Uk FqvybMJHEJDleh/mZjabCdjjldH0UM4G+dHs/LPJ6+6ZTkwtICE2dGBVjU2YyqkMnO9L2p/QzHvg X4J3vHbeGWVt6cNjAjUnoAa5seXsAw1NF0t7hQoQR/TCemxsDZdWXwzllo7EuQuLpTYmCCigdLWq G+JZIMv2ZFH4Nzsrt/cr2c1VmeQ2i4ex01oiYJ6AkwP0JfvknESEKrBg3WqDOWkOM3Pe/wvlNqlI 0IfnjPAPm9NNRJRVBHgRXgjRC6NbYKswg6+RaRrD5PMy/DnP4NwQNVSCQf1J1JvPQJKGY++9IeO5 TVmcQaqtHn8My/awp7pzIMcDicgDtzq8kfr+xzqHIr+pceh6kiFYC8zgfMCaSngHBNe8LUbd66BA pqaPtMA+RZ8bRXRmwaEB1u8AOJ6islQkODnDQams7kGL9fwVoH75laAPo2ccFrbfvp59ve1CleBr UBLvRWwO/0lLjfBb1srBGcUTU8o/Kwd7yIcWrca71gukSsbG9JoE8vZ2xTR2IvYfulJ/GRT1OSaQ sQZ8+k6zfYa8a/snsP8ZOMgpIDWtsacFnhg0RvG4jha6QpdZk+a78Pz9Ukkg0uPnsL63nKnt77gC 9KOazLdPpVBNe/5881rfrxJQjtVkCytThwtKjZOmdBA+/Sh/I7WPrq+J0hhHXBncKt/XdWfFfdhJ MHgWXsMQlJCo9YSk8zYiMr6J+bZ/Xx7iI0skCrGE4OrVcbKLwUa6WP2JU3BPdMSLhRxD6KXwouUC /QWMTlpL+WpAAB6A4X8xNt/EBrQeFV6ENl0+kyfxgK/nh0PJffPjnXCHCIaVwoa+fMXbHZmjwAOw 8lFreEjg+coLjriq9fDzWPmKjwtkT5EC+VumKnwYadILQjmM575MgvRi2GSm6jQHbVL9VW9EfYI2 9FuaRs0S9WrnQzhG41wdnNAK+ByD03Ear0pOiToIPNH0Qpe2wzHvF6SWUjTuR1PhaL49EGR+fHr2 rp21v0igPtzbegD/hvth+B3DRHJeHTMWnwxDYQjwoUKOWYlYLzLkyf4p1m3TCfLOGVc37AIzvR/o WRkzxzYfDTWE+wOAmUjZS7texKsGt5M9w8P7xtexpbRkHHQm3v3o0Lw0DvhkWnLs/uCZN1Z0FXco 8a4qyODY5hk0yFprCvO9eO/UdOHneRC5SiQcxWje5dI8YCnkNcdwwNSJ/a+5xjX/jRVFwkkaHH7U nkje4AUqnojYUhh2y9zeSCL7PZvKRC4lG+Ca94C2O/uTRv3FdD++g6x/xVTsPxQB0yj0EzBASAem gU1B7rP7lxRQHMafCRx4ZWB1G6zt5A2w+xbsZd2DHdtTHpAgFfyEVSV+qTQf33trdVvZYQDrM/r+ Aqas4TR1NfASPqjIyO0NfEODmu0f9z7uIPEDkzjvLlHkZaUuR9LpmkZyXwc/7952XEd0PAvPEURz fQYxrU7rRfHFmUpqxhXc+LBF5Ke3HpJgMc4k6n7bHr93NB291dkuh72ZvsfNgIyrEPfNyZXcGhfg 0bHfB5EbIJX20r7m1Jr6c+6w3teu4QBldNUEsnwcdE7w2D9V0sMqOsov2zj4viEyLUfXECY6m56K cChnN4v4OcQzG1I/dv3k1LgRWdF6oNFS57VsiKkC9M779G8STOyPTgCRN2gsWX5+6sILzi65/E3Q jIJVQK8UIwL67JmAc82Gi4XG9WRB2HQctkJ0VpZXzAY7psapt8M7PQEPB2MdgnpTNxaVKImWoavZ dpZUTk1F/8JLJTPGDy+jZfUMFSiJcJ3S+6/qvplvjJrm2laywPFOWcFMy9RVSkcAp7Wki/Z7553O IcthK6AcpOfIPbhCp2eDAUeu7dLHd/Mv2PMrC16YBnpiAzW5ao1qm+LuPzoVyYFSq6GQBedLmti6 17uRRsmmmwBdtsoTIdzCBdCwNvXZsRQ+iFvq0bHGoGvyEbUfui9OrrPAqQyhO5P49S3BI60iSsYK rVlru0iSJmPKhjhUeQwBJkRopK3i17whI0hW8P2H3xChgZFsHXLotYkKM7rPNMHJs6hRIUptFKnc 24HEMysbKH+ZvkwV9Wp+5+lGSwJ+M+atLCmbx7sHygE4TJzTcLz54QKXWwiHsbqagzAvsPB6hk/I xFIWmrcjP4Qod3JhHIjYeJCaV9LSejKaqpL3MFNtraoKKVlR4F3md4lbxo5d3GCJnbK3T+FTMbH3 zDNRCOlxf73NVXe48u+YcEv/lPfVSXOXXKqMvHU7SrnkVBFY4JmQe9FMg316DeHzQPLGn7EiQ+/x gFpQam+bxxkTPcX4DKY5IhS04ZASobFpTHWNyvAkFuKSBZfjeCQiWIE4YwWcGnCyR2uYkzmq/kWc aSE33Nf704Cg3Rb54YpCxSTjexyu5ebLep2s9U3o6+kAJMMV0Yil2Mwc6IlyZBAzcod74/sweyyb jc5flR+Fhzp5S+LiXTpSnpX9g1D4iUQzU9zhvfH3aLqAWUD62urTykl+TUhk6q54ZU18AHF8PHXq SN6YzFp6j71bIbFc3PChq2SYpMYSgV5NIdv6ijzX5OI0/tUfr3ZgkMKaTWMkCNEqJ5wueWDeqw7T CoKZRiW3VAR68TCPrvKb5/OSik1NQIUSTwnTc2DR/f/536WaYNbqEv5ZsyMzOD9fzh4bw/orIbS/ cvzFAIap4KiYgxWrvI3383y8dqtZbTnnwBmt23+Xn+GLLYXAwvGHsUcEdU/K+6KIZTUMZrGZSsoi g11umUkAt1ZRcJ9GCoOVK40qRpTIS7ce1Ejxz5oAqe0/tCJ1wyffvrl/cFraOQW+JhoVgQUqrMdF 9OE6E/EJ17CcE2zeYeTQPKCOj0ICNEV0XtVL//ymm6xMza8atG+unvwxM/zD4Ok1gBXYTkT+gYOa NkBMyaBBGG0UZw/xVdC2jYcELILbC1+zdP07A3jj/ENRUGF4vlrdrrq0xhj/pOWXQpHLtHQhCgyD zseoLjGLpuOHa9x9fiP8hs4mjUMhSpgHCyss+xmD2bn2jCK9CXRj/xDidegmuIBZceNUSXl8V3Sh gNgGRXcBgnm12S0pJNKhnrDQ1M8ukS02DGOxEYF9xswdfRER7Mtvhmzn3KmudeJflDAs7YKLzep9 nIbUh7RgAK11fLZPKp5zA1ZJpkbsDZWn1PpoLb4iXS1ZL6IREzP1hSYywmzggXz7bjzKQfmRLNjn 5KyOp3JNdLvFT4pCpCYSzElPxL7U48RdrYFtJBa0nrO1FfLKWZjSiUk3iym7rQnJpnXUeQvR05p7 vpSOju9XYZu/Jv/G1BExyKe47L3V97HP3uCEDL2yrPvTmfo9JUl0LubAO3G0pAUOw/y8OnI0orTu o4/wrVAwDqufJ6Wt80R9SNzuN2LVEy0MEYGNiQ7KA4FudzGU7QIqj9chii3vaG1goFTOv4UGFpQ/ qfE3MOtbR1SGFmmo7OZbE+kmxhUnGHU3QQVkg/M7v20gQ/yhavpfpHXYTOEg8Y/979iWkV41vtJQ qPGGHfeRdCaid5jDlg/SStFtP4fxJc17Tcidr4ximoKedgSUbfvfc0usVUqnB+pf/RMO9ATGj2Uh Xx0zDYiBirn8HqQ5+YeAKi7M5uVspXSvm+iU9+ZwbfILUETHmOhOcgI8/QRAwwIN7FAK1ggB/qlJ nvdnZDEXtOcexGUvcJThXkor91sAg/mzYBHZ0NZ6o0k7mXe8RKugEbt6j2fmc6riARu1R9pjxBwN ooRtdQFTKLqVY/LVUN8VPAO5sW9mjZCPDXbyjeHxyw5q0gUAa93qY0gbnMuRl/k/wRHGpYURS5JE CTCOvwXgXL3wO9KZn4lGAnp1hBj7OdvBqHponw83/i8m53ROulzv0jC17nldPoznh/OS89vtjgC2 4hQgF8E8sDeSyBl2Jxbtccms9+fpUjJznk7KXI5wGxHen9ciCIN6NHyVaom9y16CWRgk2bD/0aM+ JQPlURj0jQNXn+W82SqSW6HbmxD1rJNkUn3OQEDmaU+ff3ZsDrDO0mV7NPytrT+jWAnw4+oXWnS3 r950K6aDuax6hnrl2e9fEUBHgV5gOYt2kgsn9XPUQTZpBl0zrvLOzP0kQTV23A7o5XX4XaJKvavw n99hQ+p1PGxU6C4WvKw2t8jypUfgvw+ccms33N8jQrqdP4bj7NUZLzsKgJUD0e9MIafDNcgfC4cQ vjFPMzhAe58WwGHvpXOfagFoM0pi5Ls8CisKrKhO9FnTxgLTUmwjMnavxa4o9eblqCgogF9knx4c ngilwMBJXWFnmJejcAmRA7HCTU75AYAIEUJH93ECHrKEVZKq2xQg7a0gaCYPI+GF5YP9GCygW6x4 CtUbhZkKeS95cmBZKGS/nm0Qmy/QYs8G1/NGB6ox6MipiOLbJpyDni0PvdM0ioXcrSp3DFKpvKR8 Qwom7AFJ9CE1SnL2MGeCC53zShHkVW4yDv/PLeOoEVlUJVDF70cyFgVi5P9UbOGIuUZgEkgd8XIJ dK0ovKNraUhgxSnip/yFFHKe2t8TP+wWmm7FhL3qQhn45Gy+ArzVajM0m7RgkTx/RsS2LRrFwart h3GdQZWI8uTpMeiT2Mar1bYQ5pOrGvGGL1V61pSDGN1Ram0el1UnC9PDlQvee1qYh+pjlydAJc/n T7OeOGwTNBdaYekkvHaMHsCMmQU68RsfzcAz8bcenT6eP3t2tPe3lsfBiVL1bbAby4a6zXICcY4s /7KLpkI2UVz9sttPqVNnUDzk13BdFUzwKKWsUPbMJDJJpl43S4SxhULoqGqlqTOOjwK0CDcjptYO lD8RVWTbWt4necsCdoBwkiFITRr60ESgnSvnrJjcBYG8HkIw2TxYiFOCs5WMkz7/nVcdSxoAo1Bb RPatdGBq7pXuQwu3mTgO+xHaP46HeugbxWmnMhT0ouoOB5+3c2adSmYr3mAiPRLClbyUdumdn70D sLq2Wh/eCcWo2hnJHY82KJiholnGS3GjA1Zw42ldhaFvfWfl+xH9ivuN8/H9N1JnrCI2gwsJKJkS NQf7qEa18/o23s4WfvmM8xbw3QnlJ6y61A6xNmaGWw5DgJpxoj6SbJncMnw1Mtxou/9I1odCZZBm HBav/8OTTu0mzQIcTCJfZsI9OL7wLU9KzFrPqw8k7g0c59q2xPuSQv0gO4D90NPIa+0aiT+93uTy eGZ1oKc/EH0zlSv3yj7tV2aOB2nX2LBnWYHANPlbQp9GJu+i4DGx9zQEaMh45UxvnW9Jlw7DrWu3 sJIvKF58A1GGJHhgfl4MwZ8MBHgwdqGcMvEDlVcpMX9OtYgMdytnS9mjVQcJOsw5pEZF8RttbdmA 9IP1eXJaqSyvb7fYdAj+Dw4ORnjsYVtkmyM+yG5EQWlggiUbZMLw5zeRi/rtytRXaZ6J2vhSs/cD zta1jEIVVJ1kXdwSSi+oNoPznv0NythO/Z6z71OCVxXDiU7uI+48nawfmNHV43TeK/Ic17zTDEZm EY+lzZmvMJBKi5nfk35qGdDV0yxSimJtXbwUW2Awz6RerNkM8huaYnNi6hQzo1Bi3xYkeM1DDOgd LiUR0JuiMXFVfpesF6vtE07QBlTD3rXXslowEHb71P+H4BBGv3ZrplSqQVs6XcZPmw2Dfip0q4XB L3rRCSVefzuLPuwtro0HPIEHlyF6+fnK8qejVMPrQyIxvdtr2QP/fHjI9PGGelYvlEUlp/C10Tqn JqDjQXrMdkNwOHdyF8+WefMUlcP8vsSZCg4vvlLqUb+jBiDUI4R5gqbS0ToCFDUHNggmcEkNElyy wGU2P+wbkn++yVLWzHjQkONcWfUEI+lwLSzAbsL2femNPwcF1F8CqdcXHx9qGTJubrNon3nB4U2j JIzwqONVP3YeXYA1OLoArQlrQhg/IMxmgGKu9NfNlR/1EIYHZ2QdhmRS4LDhuZwOagDqAGZ/+WPi Rt6ogTCOWRUf1EQc0MnwfzdrVklDvE5KUXD20qnRzC2txlj5gDc0WiQGqLHVAJnUD+RwE4H/KevM XLvjctz1xJsBn5/Ha8qZvbvc47f+mbUCJ06fJOOARaqiXew1xGFuFQJT0S9+RUmkWz8XzapfYbmS 71oKC8KD22JdKtigy2276XYpPg5vuBmGsnF38JANRKg+BRB4w8im8o5NBbeWbWgQo+Fr9vjF06ac nxkA502KtQTohBeMHLEV7bF03l3LFcbRzL1m98U0zZhb3Q7Mxf5oXNo5jUnreV+pXsege8DAGtXI esEBTSrWZCXQ6zbgDTpVoPW7uISFoqBUioH0z74A8m/SWJE/JeconBRk5OU/xMmv4pfN7RxrL7XE s14yD80MAsb7rUnkybH5Q1nYtGgJKpVC/Ok08dsg01Ab0G9R+BwsjeYILA6vF+iTXqdK3yTF6N27 qJLsoPUpNzXAhunZhELtgS5LRkuRi7UbyH6lyusLfiiKwDsQmQo/AQ6dElHgg5dfoiuIablqR7R5 aLiu1tpWW5vzFXO3cCH2skZQEgr3/giUKVHXoIYkmT7pic21klden1nrdIkuuQ5DBDbmmxERuXHV kFYH6QxhFGjTCrgwTqPf4pP1qgNzYKiO8QP0GmNE9+xXA2SxfQkoIlLH2OTGdv9A4s3gml1LnhGq dOQxZFld9a+Wcc9uCbouijA8BNwMwbdvRghi6yogwVyhWQoNu0ajGlp0kFpZRb1BAuKP4XbBbZd2 zp2kpZTIIMeH9Vuz9gvUCo/OcGC6+ShwLlHuws3DHhv+mKiKzSstPrypzy/DA0uUZ+48sE2Nsypv XDzKjrmGy1jzVsvedbR4xOHfbsM3MFQ3tLaQyd4m0chRJg8LuTfbDBECcr0a/QV1/W0e8nipXov9 isOAH6S3WHTv9JswHIzLNjMqSB1QygPd0aX7eW0Edoyw8HtQR/GCToNTedo/5CZLu4eNldAwtD4G ITh48jxi3oGlc8go0uum3V4XCfbQTCionJvvOVoUomqPLmyZXSsZXTM7W8irso6IsK+dT6N8LccE sAMc7yx+/myhPi2XqCrIMoTe87WEvGIVvGKGXYY7inXoOwsoRru1xyGB3DwDwrwoN+GMTGk0HdH7 SLGFyq8QsSEVGMJpC0rzM/DaibUU6w/tNT+dnIyOtWULu0E9xbHrOo4C+9JCMpp4Hqn1dV5EdGnJ Wd6C53Qy8vyHJWGVRpH5iG4ZPq/cis+zH6WikiUIRM582WVo3B/PaCm6j3Sp2ClkJcDAyL8jvsaE oRiU5csWGbVyJthx2fWCjiRga98ux+EAI6UP+1FEAsgN3MQ7+IhBIyVrA23d7X5g17bQsSp/p6qI +GFLh7ilNawkIOoRFgZg9BqXTHC31LxfiI8FThvOXh9nGnJCNXJrA74fJfuR9kSXtwqGUSui4nDi r+uJJsvu0YIoFtDuOkAo9aagBBxfvRo+esqIJafi6PzZBhMi1QTtsMgb1uAI1KhtQv+lN7B9K/T4 nTYDzMDbq/4J91eqyyRh0B3AGwqgdysKZ8TdKbqcRaux4FkMUOT2bSeKazABdzoO+4vXUDx/48ch Rql6MN2gy/u2BJNGS35naDHnvHDw11VOzGvX1yUCz1pj3/bu+ndg09+m3degItLSJ/Uv5KhgDSYg 4yA7QSBgW+wghwhmvX3sYBc140IAWcpey8id13dxaM+f8GSRRB1f7Jn4q2y682CnUWdpDueXnG/z rwvc9xAS4L5yEFeQVdFD0SKLGJwXgYgUggvGFUBJ2lR/w3yjCLLSJhTOB4pk+gP1rP1AEdPnQ2Ul /bskinFOncUeH0G4Eqrz6NWDUN90r3TV6MYH8ACPl4N5055uauo5BkuW2Wvfz/tA9p043jA91jEC LER6eZktyqEhcbKPsTMY1olcZXd1QySxH8mDzSg+sLDSDZ1URpQiqP9PcNmEvHDCB12tExIXpwpW XD9AzMzU1Fzz7D7bP1ZIe1j5T6EvzUoQ/H6/dc7vGHmQjgcHCXN4zqR2NAPNpai96wUYgmHzaTOf 3OiKrJCFNUSnwfKeN1aWXOtwUTkg59nCW1sa9TP3wA7fz3E1yoIuwTzp+V++qw+87AyFcoNjzAc2 jVRsbzXAWFgJN1n7BFvg1u5fvaeSUWe4hGjm08lpmEEo+BVsXElUykhGUY1PFFxWnBzk+VnKKRW/ LpThyMrsj9rLdwU7M4AmuBdvd/AF2NjqJQwa/nK5e8DqifXC21K1x9W9K4CwSFPBipgPTugZidca H8q95QMz9QXquwtcTjnw5bIFJpT2Hpeznr4Slbm9ohYZtQlJMcsE70MENaAnACu9wZ+K4Jm8B1UO 8gQs0L+VYxPHDFmB/94NGjpT6HkD6AWiQHM5k4IUyrTcSch8qam1XJJJfJZQEqsGbx6f47nHQ6F5 IWlk4wjF+k8zNkU5wC5Sy2pvO9runAOmXiIv8hAgJxw33c55eG2ePcR3gNmGNi0g5O5PGwnjb41u jyBlmd6g6+hdosRHm99WbKRPT4Aggmez987BxdrhawGKjKFnaebt2rQ8TRlf8ZhqmjiNykpdwLeF SQvD585genx7cwif640B/z9wSOwDvmTPJ1Y/x9tO1DL1k4Rh6fWkwWrzeH/C//bc+mib2zUajFhN mQkGJ8Wsk+mXw9XsNKn8u/QI2X1q8jswi+RBTYc5ADf24trHLhWzbvY3gKyjTMNzk2i1oPHh8qCu tqWFJy5fBFHqDBZ2jqGzx8PG5fSt15kMxROTpthwAW0i8JyBeUzZ2OloKDU9H8J23kbyR8Piygn8 AY6mRY10EfM4SBOOpewULmkPzMfUlVet5BcrK5li0Yu1ETjEOCPBK9J1Zmerm11sDk22kPsubXmh yTmcZPTdxmJyhFnHhPVYvU7aSUp49ieggyqIscO8jSn9JMKX7iMlEUmSTh6pzQMFqAIxG3EWoOrx HLwKEgekiHc63qL3alQc0mf0LXCYG2dbOugn/SNoIx68yt8CE5JSZ4AoXQi030qZuh8JFLR3NSgq pyT8lman8uVvPJUFHQoDcqilQ+qM/cLbMEBpXwNXLVGoLLBhyV6OymjnyuwXlWU76cuPGdVMRHpZ ucGBe26byroftlZ4rbOHp20MK9Jkl6I1mOXWTZccnAUpLG2dpq0IJUXo9ILB1Uaqsy14O/mrX7Av OgRe7wZeEo5I4Zw6omtHaAzohc8SZ5sfidR2gg947C4CJAjBNYkUBTYPvLoVxNgTygYRT9wpNOVK x2lGTFFfta+PCnFEmrx5hWkpNcvSsc4StOqhIdv+qeIGB9nx/XuLDZOvlScrl4Xc0XqBr9Q5XH16 Yov+HVBS4wp7RCeKpONwI8zJ4/V5IOvubl0K8sk/SJTH77oW/H3Kj6iFzvwfn319eCTCjPuZ88Pd hi+U6/XPv/Xkeh3u6bXT4eXvKPkVs8Tja3GbfesTXfwiQP3q/7q2c55CAiHahHftLVgLlknINz76 79CYN5b0eXmgbVsYLBL+AwnMAbng0OkW0f0z5dk35FazCcmRXx7HLLk+xfA5dZdOkEmsNKjqwf78 k5esCImwFZFmvxKrvCIZIXgpqp477JkcmIHcE2z8jzzraTafR8lDmCM2g0bxwBjqALvTIQygH+kf qZ78JsegdqIPZmV1deJu8FMKfe/y2uVWOEaOtOyB62Y7kJNVfgC7o5lx7XyMiKPWafLIOeg/MSjs +3OkxM9NFbxcYEYt5r4CfAI5DrVdUKhvYVAU+ev1c8se6rFCCz2YbO6L07FGR/aM5GgrPKTw6Zj3 qDtfeDYdg0GrPosR6dMtp+p2ciNRzeqjkV2YU0aLde7jPNSBNwDpy+lRdpvaGa44lp/FgjTCClLM hoQ3lA5Jw/2ZGiXIe6Zq4MatuBuylbZVnRNb/aUUxv7ox73mCMAFnrv003VZPaB1U5mBqfmeto+l dBpPXBFrza2DD4SfwkjbGsSHwK24crT6pK/NM2hI/p8aed4cNPVJ2/3LJP9pqMvUYzeCQd6m0Mst mVwpyyoFL6qcHLYY/ryCYaKPmwsTY0EKPN09sKP/qakc74nBIrF8Z1ZCKMaen90DRZLY5C1V4gu5 pIVdHM/HDAjduXFNVVwErN6PFZ3mkVq+bwQo3YXihlE+sPiwsbwkqvvdRA3DR5i89oqveNfDUcg2 Abw+eTT6iXkzFZ+BKW9bGRl6lQgsV6JewiuK9y1B8VW5fv4SMDDWJ+wY+Z6oZ5YyLF/C/dyHlijj eQErH7xbc57FAI53zaQWCSKC2fteEHR7mbMpc7y1BNa3TlKRxWX7NUtd+rs3HgCzl7kgVHTSUIOb bzsqBF4pv9NlwA25YBsM5eBRCZkvOC4+9tJ7GEjC8rveS8YjGkRc8YdNQfgiTROddYuuPHeU13RW eSbx9Cx8nCK9yRqJFqW4u9r8bp7JzzKnGrwaZB3vtGE6eB70lOLsVy5KhHGEyFF47223Ai4UDNeh keVhVRHTvN9Ui+e7bj2xnY9dOiYzt7fioVmsU0JShnxwc3ydaAKNnRC5/0ACIKPEbF2CzwliSV0/ NlyDUUNCZLxFFln3LTb+R2wT5P4HzCpe1ys8gdFbWeNo2hy18yj7Ruik9ptjeNoxCBJJp30pnl9g Duju/enago+TQSKAhs3jmKF/Aq8BwgEguZZeBlUjKVAxqx5nFYUUUttpybwiQgBgcTdtUeWECl4i TmA6ImicsWvvKUb5SKWpXBJjVvj52sJQoUSJ4JyCYOPEuRdh3ZiLknjowrhjEvQKqIMDRDPXM/Lq wsseq9qOVHEiZmK/Wg0Yjmx7IBAcyWs9Flq8k5k4GBavvxja1Ld9cOOb60igVU3GtdHXQ8+J5Myz 209KbRp1Z89kxuwjmpjmbn6TkUQ3SJJh7N97ofq2qycTQ5ngsSafxOoH8k02zHn4WCCz4eFl5xhy ueppjCBEn4iOzEl0PlW9lJqRHGPnRlapZ0+fUVRqSM4zUODN6PNA6o4AiAyXjOOpGsEQ8pxtqjvc /fwyyGaWE9XVi0zKehtPYRMTWb8omjl33ISoxc/g6XuA0ODnPKzt6Xh3WjYvkJCRYzymx45PWhKo 570iXfJosmNPf3QMVzXVmXE74JGR/m05lSAdVOn5VGGfoFJGWrLKUNgPCzg3eXAGN4Rgcairr5Lg bPn4WjkraOEjukXp8Si7CZGvvGiYrugWnHW0Fkbi9A+i0qPKoioIzCSTH7kndx1AKNLHkKkB9DzB o7dFXiymhBAC3MKLHqO/zcflwistnyYj5h0HSLpF/s8B7hAWHEFdUFplcgIlMcxuBawl9RE35Yag YroXcAudk5N9ta8G+UEb/qYex/K4NVc7g+VHQWQ7Jy7Yb/Zb+N4srtGBsDp5597dVqAe1Vyabb9O KeInjlnHfXDQJDzY3IUh5D+Nc8aZEMVfia2keM0SBjlK+KVd1N68LfjQUzr11ZMQd7uK4J82UPEd jv0XWlL5KLmkzgPcxllAiqfAxe6gQ3oo+FYCZkjv6V1+oiv68eeyjjP6T/FmUjJydpudNrpppFtv djBcco/zeU1w8vgfrja4ea+ohX2zzcDdUk+Vtdb1yHZMvIYmDrCAm8qfKjqSFCa5QhtlD2cyZv3z dFHmcnajv+TqYxdZoxiG8ImbYstp9XhhqBCX75K+uZUrPfPJhYeVGxkc4DNTdgyXKrCNiN9NJfCT pdSAm7hUvOyVPbZwLC07X2Yc5QblExwYoWPogmzlqksOOjfqwl/0xUJAlDaaXtU+lzK35gVyLp8R S3x+cAVL1u5H4ELynNdLUQVI3qxs7UMTL4LsLncO3ENTxbFHQFIURma7fVE/WQ2mDcBl3GWaYmeu rlLFJ1WFd4e+N1WcGQ6FRzST4udxIKBwDroS4SaQOvR8EM2sTsBfScigbu5GXg4zz16+OkMN9DJ/ 2ya6KPku4S4CIQFHOFCBacq50mxVkPrfVUw61YgFFOiTsBs4MUsEN4gsrQ/slYo/25nKt6bxh282 7V6gosCdug9nqx4z8RqR9kaDAjaAtkWfDaSxt+X0uGW4OO3HStZZXjCHKSAiSAPA3uh15evz/5nM sFq5sqe8/aPa+f3fhTqf4QoOxedmd54hShhaD+vqbw5TG2jrn/2RbU8Z78R3ZHJu4JYGLXr8wNty rNg/9EbJ+h8LcueLe/GnejesIK+kPe9nTlp01LBfLP4TIuUj7TW1DtveIMN8peXCGJGO/p/ei+n8 dNDOBAwRrrgPMjJAmCLwdDzShco2/DVw9AJFT+4QGmmxIPYMU4rZK1v0mzrVkup2dWwv2WdrvVji Pt5NEqWaxR/hbOdliJMwapQYuE3VZ3CTcPCF0aXnXTHMdyOxAv1o5gSlUBi4t7goza/Dz1ToeBmr pjoOojxG7Ce2OARZEXqHglvybI7wxE6TuBPZ5X+Kr3wso1qoW2LMEG87EYOQA8zP/pAgdmr22Ooa DYb+re3eSRiK4mw8bwChMWWD91Ob/3ix6d/27QwzVrn09XA7Uf64RSJqc2ifbi7tgnCmKVuLOj1w yx+fHQ24YLBCWAN2nZrzc2+AVqBI7T9cl/6W5gARKlq46CyMwmvF3i/7aM+X79/AQWU/kvYNURa7 nnSx22zrLWv7U01rNpu9cIDw2hq7BrrPFyETzSlqnyksr36QRvvcETOXWogpXrriKXuvPfyC29d0 M2WIhN/s8knj1fV2ALMod+L5JmrExQSrB+0uN5kvmHihGOmWLILrjRPAsQuonSRi232Ium+CNkly UwzNOcTkhAR2Z81Wq/xDIBbWL5z3t3E85S8MsofwB+K+Wn9svlas0xPhzUpHCfitqebvgemRAPGk UShU5Q1oUshnbIjNpkWaIPXW7EkYtPVZoLjcWg+Y9IrdSH3J+I+Uw8FpGIbHPjSyZ0TtGRQ8L6na F4ethtXD6ElCXZZ4VEf6dicUD11vWaFQDUtdF1rHI7i1WHoC2V7S8K5+2bTNeL++zEnY3L2vnbwO DUvaMXfk3pwChcX6wjf1tZlSbNBAFruRNqT/HGUEmFx/Du0Za3gIhPQsNJw4G7S/TxN+lRrMJcWH +coHhBNLo+etaqJoVFKeQl08YINbYA5p2HSiDMV6iqt7fMB89QfdAtTto/AQf/6e/B2ofLvgkBuJ 78yfTI1zCbmNSJww6S4g6MpybtDXeI84Ia/OX6wW7mN/mMjJb6R7RKO6G9bPCSU0gNcNUTAmn22Q bs6whnf76a7ozxXXMxtzarFSad5wn9s/e9xwH5KEPlTxEvMEqhosFyDlD9H5Bwh06wwIVP+atv8V TIGAF3VEEIRvsFDE2eUiqQSoY/99Qi+Bm0+3XQSJXtKMCoZX1tiDRH6O3/2LymSk9XIJ4CfiRhuR s6r33bnAoDps/92PncDuPOKnbkoYHlyxZhCv8nmf/Kw+a53fDbG97uxkJzPwVPS8dzxDBFoK/boy vZ6F40gTKSS6q4vdEow8XwyKvpXTC01j6h7j/6kYs7CYEO5wvmqjVDVmlwTfF8XYNe6QY1C/LIV2 0X2fOFPg8h1BSg3mSUqfDiejN4zpurwPNgzjYzrABXkfXmAiPC7wREw1H1TENLqJ7Xo4FqcIqhtQ vm+/4s0UJkUbVEr6S/JjhwrZrqtwFvbnuaeCwZR8jAMPg3qMQLaoGm7cWQQQ7sPGASmB/VUgMkSV TLyDLatIfVejCbUdDFVIRS7s080c4tSrFogMn0bLvLta9xWczh646Br0UlIJs2gBcY7e7ELpesGR X4zawSbuQwGbwWJcS6vckhQxuGdMFfvp8dATRGAUQtRa5cCke6ozmKxB0lS3MA8ctEL1GVnOrzDg W5pG5vHzH3wpH6CJhIP90w+O5A+6WZiq5nSxTKmRDCf0AvLZtSwAjicrGg4E5DH3rP0MzRN+O2Yb wI/7P3FsbzaTIjuEqq8zCElvYNhsMcbjJIvebSkSgBWeElV2+Hwm3gQG5r/ONL8AOJyCbyFMvcs9 O7d4U9Se7wFzlBAEKuLpOdmCwtZuN1yWgTEecNS0TFNCda/8eZNgJ5MVKuxPWcZUmF9ZP5WoNZel 9HsvOpOLQtbA0RwzmTpOLpA4D2e/FnLAg11tMoYj72imwCmZc7Igo3Rgtkl2lk3lY64Ah/v1ZK9U OzTxa4H5SFQyBoBr41W49i//a+V+kIU5n7oLaRcHcXYogqRF+rKykPgjCyqhFmdJMWs7LuJWrzpy FW9cB7ZwN2kHxUzqGkUswNWRq6KHcc8eoVQtkbSInkghsn+hcsQMBGUr9csm1jGpFhMiCiPNGnAS /CE7WU3n1zcXxPGu0I7xZXGd6CL8/AnWHo0CDeWI/wWj4ENpr+vBo4b3vdc1lTtFgQXRxIeTfwop ebtzv+rd/by+fO/Gwz1S1/AcT2jqCFCTA75Ta+Omigqb4M5p1R3S1bjCZxDCXPXPDbv/OFJTb2jd hGnQZT934bVGfDW3izdKzyrvlQtjpYrVid1QU3GuWJM1o3lXfoJbrDDoe5R5HxS0+yD5vZVf4KOs 5/NpXFkGNGkRvOfPLDCUR/eOLHmI5w9VWwpOi+O6NXR8tNbYfbnQGF/6Th29MtSeBqtzgIECUqTX Qs8P/eppjXl5OJKXvHRghnfwPEnkb3gJaPLTMBgwYb1nAJG5ss80aRWRKES0Jt9hc8ssS6JiEBzu Z7i6d/T7N+A4978TnlqA43uTAGR3cdw7z4q0MmrfiZhV9KEBqaa09exd+W5Z9OzJRSjcMtNCzGqg /siaTiEWBx0c8ODgCa6xToqXS/tuWTiMBRKJALNwmGD9AGd76a/eh4LcCMAbhi1HYKxk7R7PIgRy W1EcLpjEbtAAbRaSNKVmbcmjjVWyC/TYs3bvuelgUTv6Ddq333FBug564PLBLiygPJ054SUuRavU 8BoO02zzK3CTMAnMaUksGLvNWUIospaFgcCEJD4Xd1anGyEUbrMo69iaZ8aJRxnmWH9dChJxZqCb 9TH/vQX4dB+X3fs0JScDqDJFcJxnGax+36N4IRIxEf4ob8GBxfxMN9kGgkSaNzQK7qhOcNh8l9MU Fg3nNSrDg1AUq0WEDEuoB4Me/+N5dN0rSuoaeeVO8D4Of169Y2iKhvr3rhiSPdDbiI/WvAgmqTL+ PHeJNKqG1Ifffer1+9rRb6jYL205Tdx4h419mBOl1jrk2RCIw2WlajUDts1+PkanklMOywbBtpXI boBU/cDxZeJ6c8mgQt45g/KTDpwac2N04cHmcU2Z6jBfm8k7GooYmr0nxBrMFN0Gbd/QkZT1Nese lFxSePwOd21bATOsjD+roLJRyQuC5w0Z3Ky5+qRTLdVfhB3JNMglsPl/N+mAhiAK5f/QVqV4QQ38 t+bg/yZvEpFkXsfMVFtPHqKzkVkrPX7M5bCGCDCMQXZb74imptrbw4IfJd7wDGKODlDhLvWeGMr3 QrWnWVTGSsR/TDKdowQ9vzhA7Wsrzkoon9KMwCyICLphjyADH7UAwIg+pUr5ydlRLXZ+RaD2De4t kWi67WwJjY1u2d0ZyxFVk4hNBLZ5LPLKBeDsCbFc8KMTUTZz81uIBlGLVpthL72rq4R7/jzoWoR9 Ow9nLA80WrTWhvc4isDnimvak4h0QlUUkJPjfRzbaSX62FQFlXPl7qUBB5hythojF+kySEPEIXuO fB7ctKVOeLVBFtAfnUQYczhqFRMtpxw10eI2etr32/hF9atbnWL1zw/mAoOSeGfMJG1msWo9VD61 IiFew3SYa7tk6fTco8seYQK/9PomZn7Yw28pKsCs/nKwMImblUlvCg1f5zy5oED13xhhE2dLE+M7 VEfXPHqFPRvB64NY5me2OrwELZ+RE36rr6G9vFcJHSFzB9YMmjZAMDDpuznNXgyGJsP9h0iof0LN arAzw2B8MDY48J6pedDA4hvvEVE7dwxX614TaW1suPEwq5DNHfJ3iTYw+k7t7JgEjIDSaJJJ3GOS 3DHV8RXLs110iwNvM1S4TfHXNImrFgOzvERA9RlbOYjO+3qXa/MnkiDX4Z1BmKQGmdJ6xiYodt/s AfdOR0/iDidCnKVZ7fQ6FcBo37Gc/Tg2VvJi7U9qfLQ3DhtGs7cIGCelz0BFoDhjvoMKrAwmXUmp cZnJiqY6eEucYXRd/IR6CrItO5tUex145Ik+HmRHtcomRMib0lGAwoxGkHI7e8L1GcWaXaF4TMLU CH/VL19SUfyrC9jA0c5dxpuEllDK6mOqO5TaEZKr9KqxqnF/BLLaNQA/vISWDBnqd4EfqyyqR5+j vPmfpk5NaI77BS9WRx8/a5wZh1m90PUsj/CI1HRSV+XTVT4UG6ccsAdNFHLTW+QI4J1LlN2JYI6V WrC93F0UM57bAp8kNBlqDBeOXEv4tZEVcmchxK5c6k28q5hQiwAD4k7i1FtA4GEv5epU2T6me3mb 8dhnaGlws6OTNAErusq04YZDHVBtUvcgghKB9Ye2lbIZXzOEF1FnbJT7xs7MRkFVXcolwQnE0HVL Ili3TXQEyaVpy7LY3JJTY6NHhCPPEjw1Kgzh90vJRIdRCGAmJsxDqcXBRzk63zg29pMGEqRALpFJ 2E/B5lxqjeubEETjd5pYrtIFDY4SXd4wAOq2MdH3mIl0Js+4dWr+95jjQBOn4PbdDn9gyLTsafSa BcMazQsRLitR2JNA0Zkj/AiRUGonx+NGbty9bMvPl/2qPnpk1OIzRdRbkCPNcDRAJXkA6AXOqNQ8 LwxD0UIx9B33fm8M1/QBJWMzxtw+pZPMNm5YwGgs02zaiMaoYKNG431momKMlOJawlvU2SAvLIRm IIVHHBP0DT8kHHT47azbDAPr56bQZu10zIcXka//qHed24dLwJID1XOAP1qSGKlhyBB7NH+wKd9C VYj+/nDTyzJk6WHWIPlx8qINu0AJ/uX2NFw7nMVenQFJLXvYDQNigYBDFZa/eW9V8YPAYrEfoUhG D2JrUyQjPGb9QLnInO8v+1ElnxLNIgUAAUPcXlTDpgU4ihSSPYPeen9FN4TvJvzCsG7lQ+b0qWLV NZZLsgz8XxmQjT3rNRN1lLnEhINchFYnSyszxNaen3o1nz/9eKrDmKxEi7l/vvAPrUJxXWs1TNmr E7JBV6x5oFtB7O2bBoEoz54yeYP0zFkG1rDDuSHTg3UKNfShKmi4zGIoAPNwW9SZg0RNYOfpCZs3 cnkr+GRyIc4hMvrzfSgVSTyQ2R/mfZtMySl8e9c9BKK7gy7jX+l42jPOtEP1E6jLZ/EAwpWLQrET YV4gAEhhx2WHYAZjaU0jjJBYOURcgbugqyY1pZe+vy/fiJCoGwLh6qd/9XvxAU5EQe6z+9Tw8Qbf SAHe05dz97CHa3vqgmSO0Fvr5u+dn8RiOddl4SzMTSDHJActEYhCAkdrJYWKSOREbYYgfH7Qp+AX eQ4wCN3iXUJpHJ0JUYdDS+Kff7LTC+rx6M/KiVD92R3FfiuP1I306FTu18J8tfPBif8dRfg5QXLZ qF9DFQrPkWEOapVNGz+e2a90C59VxyqIpLqFE25Buw/UUGsTSYqB5MnWEC/3RMQ1Ul/+iNmMydjs J52/Lyja9kfqPiKdMtlpoZVSdUpYPXkNX0iAMM5ONAuWdEWkAYPdo4COJOMb1YOPhkq486aGXjlg qtQY/q3AHyRJDF1s/S8k3MiiQwvg8CHVz6xsSdaQYIs6wSsLTf+6OwCVCXQSGf4A+45fWKyg3RUL qWLLCrbzq+k3L09X01lXd5KyxIChg6EdGoGHZOtuts53fW5TAGj2fuVpV0f20rF8lc/Jrktxoogc 2H2vu33igGoJxe+ZHCQmXkFzy7s2c4u5DENDdRiSEXnOOdossuDECTDlVBuc9TX7KQNpg9ztevOp nNg3W1gy9m77s7g91qIm3u+SMUsCyhs0rq0JwfGGs2suQl8UF+JQFjuhOhqnpLgulPpfsEq/w+ci 2zSf/C2DeuV8hXbYRyrUOsypFM94NKZaYwWnTLyeVn6/0m7+xEEZ3VMHe+ktpdrdEkRBtMIorlVZ +VbK9XtlBZ85oQquDUf5Ms9Z0e4yW3YcuNsxEYh85qhYOOGlxQUwkE9iZOc0SK+e3crFPpsWlFNz ZTr6UezePyuOWlNE6IzH4i4NbPtWWWzOM+V11RxAAsP85Ml4v0xx9K/MfeOYJDn9S/CvvheOri3T 04JEeCZDp/Oehsk/rgsA3f0bItTggFdFbwt7isd2KlEA9nlto4WA2jwhoI35HnwxbiVZ5MItWYph aAtPNIPfXMcx23jDv5HU1u0ljWhMzRFppaGWl8p69m/AMEnwW8XSoCYqv58J0/ln+yxYJn4rK+dj oz4RyU7fAcMfBsZRBu/5kT3OPaDSjPJQDUSlk+mfvC4Vn8sURBBUkJZY0HjFc16sGBtTUutFGT7N 0qMzNvgyJYRFxUTy0hI6ZxYNExKgJWiCz/jZ5pfpPxpNKMCl4l1lK4l8GtneFv9pmWypI27LFEyl 9WyPpwG65bS/8uMw3OWfO3TDXratepcXVgFxQKCN+ZG6AtIJJgaudsLeGgB0ETLDa5CMiY3t81s8 x+XuGcjXGr1kPAhrDhDXhqXzloa6Wu2fDc4k4lqs/55S9VTQhGavQzVsK4wY0RfRfV/9Z4JIoGxs Qtfdui/iEy32A9kxqhigEsIdosnPF69DOmgKipzK2Eegg+Kcmowt9stdiTUU+BregOsGdzu+g5Wk hx4OhI6vRaPYiE6OszbvjcVT7Lmoe1xwBantejrvkteP1ZKv7baVCXnuSeVVJmMEBfGeMvkrvjFf ywly3GHzpZkmU3s4ObWvLzpqomeYgCRTulw1ZZDlXGgaJxIM00MAMrGd/huSDv20NpZoq0+lT2+Y CYl1C8h6smmz9JXNl2Fs1MDDrwk08ffkly/wuTuLSTtAwLH1x1uMF0YVquqgRHQSjnG84Qt/Zk// a8oMqjG0BD/G9RzfLFSN9daLQnfejveR0Ftn/6jdC7LjE8jAUTw4YiG5BbgtCmhzY4G8Sdp7eM4R +jSevGXIiyVPF8qOSkTa3uBzvOk2r3YUF2/4lD8Bs6NS0wSAilsQALWYwqcm2b28bewBhDReXrZb +unkqDAwgiC+0awZGbtqlT2a1EQZctbujg3SIEUrdlS8xNZdgag13Xh2PMbALRgYXxgxFxI/X7MQ 2nt9o+Zd0c7+SF6Hylkxv0UHFFWQA9dKEnmg00XAJyNQXcCfgvsksCJnlN+yOewqHBW85BNk0sRV n7kGdOPQEMyN3YZSw/JN+7fs+pzYsQ0EA5ZmzMVpSoFqB+vYiss9p523hQ8TqC6J/xtj5ApvknYR 823jG+Pu9nwBri3iNDPMjBkko7kADuQCIYzQbX/cE15SImiL5E1C/mJ8d5YkthwCYh8deX8O5+5F Aw1FgcVzOBw52Z2dvGVL8VYodH2kexi3tyQWifDV1D2aHGFfzj4XaM2f53cgdVZ3l6ztvaAyAlGm PCvTc2HRLegdYJXOdnM9gVL9cC6hPq7qC9nOjlqUvpe4vCQXCEl6bb8lNLMA9/UdGPRQJdodyJ7D JTPVB9vQlxBGEVDkqJaVnBdBtoAbNCUIzuxUZzaarc6R4/UoV3sXiodpFCSP5dyTWqqa5r8LdqVn mhZTdiQMZzM0NivQ6mJBd+By/7WqBVIUxT/DWMeBco3d4mkNVplxNNXUWnztfq3GQOlFN48AvVZD HAGfAcSv3PcwP3UKfqpo/+JG2hVj7cFUb7vs+IHcB1w6pCaEpEiTzvdUGh3Md0cgnIIXUf5L39AQ wwTgj6N8oB7ZJKGQ2Dt7xaTelwC56DNwpTQ/qPJW4AznEXcn5ZvpAYoU/K2ohb/Sz65wDSIaRdMM u3EHhJeNNHs55hW8GS0Adm36WzpuACeYKkE9wo7kO9wSPNB7I1FbnRelXndJmzSatpTxBrj1xSHH bPOsg9D+VYo+4LRWFPMpe7Vd3AvNitySgCFoo5Q3KXjX0LGrM8JYHO68YzLxNCu3wSPEwws7vj4B wntimk5/iItQ9bStFGhHO8pNTdLTfTsz7bonePQKV7mrxi7MhEFjlIE8j22BnDP3vFPhbbjBFpLV 7cA4yb2GTvF7xZEIJJqjS/quOFV5P1h4jgcEFFw2pz/cTird4Gh0tWWSjcTJJMD3rz1X39X8EoD4 Z+Fo/AVWEHjrTNUdjOkgWiD+QIrfY0V9KrzN0n5ArLoJzt/QsaEPxa3Ab+iiUkZaGFt5w+ulnoM6 jHGZZT608Kdp6TRChgO1ekfC2VwODNM55AfZefCYMZInujE7xfsOoeLE1ciI2YJkZ8gFpeBQNTEQ 2A9PTSS5AszzTkks9q41aE1z2cIWNgiv2kKHEZVgkcJ7uL7KtuMHV1GA75W9w//o2+pL4dBhOzn6 +NlAbNpGYWIY7wKgQtk9Mu4+/hqPC+qWlcDa7RXKrRiO2qrbdnz0wt/MrvGLyi0GYvuFiy4NUSNz 5ye8wGM/U8385TyzgEgW2dUelbdIWMWw/FE7KTas/mmOFrlj6ZJhUFeVtqNA6W2I6BZEbRaHuSLw rnIL5FbnEPGfXXYplDR7o9g43sxKokkb65Oi+IcTPQ92M29yavTWj6jxSxfYMKuMeTcnjADYEN1F aJ/t5DWoaY9Vfn9dzqwbZFTtl0DRjkdbj5C+bvlqhjTuVypyq1ka4SM6yM/XfhQKUbwjACQa9tvK SJSToDE3HJHl19LNJmn0Hp6J7Pz1OtxnxtvgTyoorQsBrIf8TuucBIVO9a69WLgqdT0WHzVfdU/I 2LzsfLsjSJGMbV9xu8D12E9N5R7reFtzWtDR9gzZoKAjjqQ/xjOdqanvf0o0aAdFsHjfgVWoyPYX tlNEiIo/z4/1+08hm2oUefV/ryDkHqMBEB/reEKd9KvAVVxa2fdpdr5xhaY1w5J0fZFURzgnHYQ7 /6EDi5lUCI/OO67Vg1JlkKemcVmra70GwI6mafhqi5QFcJRZ6K94ISaL3vqOEqlZ0jiVHFrnmGaF YM0O4H8LrWOMsVeXQGrCsp6ONLypoTsugYr8hAvSOlmhTCcF2/bWjuFcXshECejzY31xOeLLt3mu AdW7rruCtBcMXzEbsQVnDuclQYQvbXl0WkGuSbZCB592Vt0zV3T6RKlCAQJsSEQWla7EAQ53aoHR cmVOWLjUrm3dXwv9o/Ww4qfRL4xGQ6STmFYNHLSfoBt4C9XUDqRrgX4IaoDeUrgDSXQqBan+6vQI 4IAYhUW8sb8YsPnwy7T9L6PnQSap5fVabR1JZrPMtOH4R2SULwrrJmkc5+IOe1ziTyUTaz8ZzDrI Ko7E+L3N+Lrg4/CBPIuEpIiyTpZ+Jw7JQSLfrGHVraZui1Syalp/l6BIbufChTfyi9hnsjO92Bh0 ttOO2jMcAXdQGNwNlJxbv+meUFcxm67/SOH4eQ27SeslGmOnUQRry7qW2rV3tpCTzsW50fs2XN5z tHLKgPZw74LSh/Iu9ISqHRE5enu8yxrX83V+6tABzEENa0SmdqmBF9ZjGAWUpntpU1SzFZMKjZJw 3+uTh3asPTsyFgAEvXkfHWSdRnmNTi/BL4u97ordd0YBhu4l2rQURQm/XRzrP6oTKiL1iulFn9zB BNlRHEiRrOAqqcVYyLJhyYs2VK6W+HmczY4/eYDeggBWQYmoAmtFpTjv9hT8XdmyZRA/nQCJ6XLb JO5sJ7yTSCu20qwgDoXAOllcLCOiFgBdk9f3Tw+0DARmJVQiHYiSpToS/7QKY9y53JQfObvUyzbv sHiIGCvpbrszU9NvlGjlz2rNCW+YVbfVYfUPpd+UYqbaYxaVh7eyqAognzIdQ2v2slqZ1Nxx9aqW KtIDhJQNylr08dFyUSkSa/HdglfrWSwYIOg8ywCHS+9I247ESpXRtBV4MmfsULwJeNgmRJzW0s5v +zfv0zkBznW+mC0DJ+VYsijVOQkFLQQTSvADJFBgFSXiiyFU/WGoiQphIO64N3Hk9t42qei2lQP7 gxiBg7fQuiKr2geku4FzZBeZ4PDBWnUrDvpxsMxx2zSimyVNhemh8ptRW2TwgHcTHqAtonwCjaM0 cMgk2TssaHQccFi6OWC1q6Rt+zoBkz3ss9ZLkTNCje5O9nCVofX6ATbJnMPbMiVUwyo3ENJ8nLXB /uYhvu/DIkwPgtp6/sRDQdbHrVs0hLJmrjEnNAtkn/4aKxYb/SJF9t3KHrGVXYgHJvtLAIBlYK8c WgJbJ/UlpZa7vCJgCgHNTwsmb+Lk1HrzTT+0h2RKJtG3nvM7BJ4/jsCD7S9uW1TIuFAsRQHo9WKo 9YNVlFC+zg9tah6x7np78qNsNT9uxB8p1V86LuTfUGB9hBtwwJLmGM/Acz7WJC3awc8caxq1hMTu Vsu1+/0gR0UrPXIQXkrVbGyR3XgxfWP0jPPC4gzmW0X/qt+AfPjbxfpXnUnnJpcyD60TA4avkMjv tY9yODakmJl2DPJSYHj+smypvHXYlNfYfM78FlgMeUab1kz8dRRhssnMmBLKKk/UQF8bxWMoc+YA vTrNwvHUpf6NrIf6mX5UhhvRN+nXPF4NVcR0ND3ABs9ZSVE0E0QxVILOpb99UAZ30lflVlSVMhEd 0J2WIs6AnERArf0wcKLF5aAph/ksC9hQfge1NZwlbGZqrpDfhpucILS4Ky/xzJVJ0kGhw6IT8o3/ ReQf4rJT1UejMgVi4oZ2+03uhiH5PfutwFM7IDUUf9Yei2Vh3suPl8hlLe+fGst0kfjnMwz5PC0Q xjTx/DOasguK+ZgExLKYDNuhow40gXT+UgZ9l4+0+uEnhu0WsbN5iU9NEurSwFy5c4OtLNDK8VWD KETci/87++hm42hM+t699d2LpU+y3nDu2xq798Yd71kUsVmPnIVaDgFhU9eUczBt4vpDlhRZTQWl COvjojePAPzrRTffao7pzCS5nUv5ISNPm9NriPESKjyF7oxCwwpYDMvsmsvVA0lylENN+rbPiSxF /5Z3WRmEzz8FdCJBV1hsjw8A3W+1Pb68I/fMaRpgDDcP+YkMXMTbUM8BnNytt1gqiBluKpZt98Ts mQFhCBwj0iGR9l5lgsVqcwgj7av5J98wBZGuRtzz1kCgHWXuJUQjyU2fC3/EYavqqrJbWaHgRbG8 JIB2UbuNOkR4ZasMpLh2tg1+1x0XjtDiz1NHrxX5ds5U3vUDKKKMgQAMGyW3PSXjbbDOViTXI7yI gnz3mX1WO2Weq8PNemwy0eZBJkea6WhFPe4KvD79rfHmIruwaQdW7z2NnztlGpfBJ1uEpfczMssS 99ebw8JsnSsIiRHs5kOCa/Boy+CixXX+RRbhjoVlUmcj6j5NEmAu4bF6bdi1pJC5Bkr2IqcZzGJ9 PxFfnY8Rp6bE/BowqVieHNjYHnsonLTuLibbvzs27RBHWh8mGiQ+F923X+0PhVF099vUsHf5EEIG VRy/HNL1fb9nvAttwwh26v/kh+wohg3Jtmx65SKU/KY5Js54aP27h2PycD8VBfn5bnAkxI/NN9jz PFHEfRrLMeP0Bb+q7l0tkVFzVzx9t/dAbWpyU3IpA9G18AcWK7ocvG4E+c2o2gyvs4+8hu99mUC2 DwSfIx4H9VKLPaXWcoWBOFlBhGBy+G24oiWZRoEK1IsbmoTWNacCMWc1Xomfe3IksiSQqX6AH68p cffG4WXFh4QK18hZN/BjMxnLi9/9RkkElIpARkoEqvw1vtQdL3f9zjaAo+V3FeLmVePC4Z+ZdTzD u6mjcCOszgpCJ+49RJjqkud5hXg4/n20Au3U9d1m4R1n9tvi7W7eJJU59nnb+NJ+vOy9eACL9BuV WpDzVDPAAuNU1V++JNhBWmlBTpLoe67DEwLbEzkkzgkMTRLqtXrwRqyRjg9bNl1llY+8xT4qLLEp XT+Z3yI0Ssh9u3Se3RNkwt+mu8y8N8UH0UmGC17JRz871hjGUfHQDX4ridMMcbrW9EV20WKWp+s1 YpyiuBUkIjN1S37vHDh4/0q+XShf0MpcBJgofE9MNIERjUqfJBjMRpBYodLIon7e43UpmDjra+5q 3rBgI7fCoJQndpdEr/8y2K/tXiko8rB+WTgxJBllZeCABgF2q+tjuZzaAhQy7xLFPIvsvG5Dh3vV e7eoYSxGEB5bnCmf0fdk+lH29RiokW/3D91RNL7pyk/3e66K/tmwWKc836tsLf4hxBVZ7Uk61hf0 ru3poVft4DsLJfaE3rwjhxCOBLqgtL+ATi3X2EwPqwPka+2jN2qLrsdszqpwV/4UJlUVPul5Ps/n NIEliq1Kp63RC5MU9pyqxJntaZOyeU6BaotD8jDYrDYEeljjobtrbSiK5HtENY5PKLZRG4wanNd/ jtQodQp+QkhEq1Yau1oAmhgL+41A+rU2lSxiOKSo9ZoXJfkm/ZRSAY/+SF5LiuQ/N7704pOEoIz8 fGVye+rht7ieN4+A2g5ehUVtKT//j4IaDMlz/O6bsCe30J++LA6RhxBhshsq8n0LwkAKyF2nm0gJ 3z7SpDw5A5cyIm1x0WkQbHPgxT02dZ2ln8N+X54KNPGoGtvfHHloKlntCOmSgIgK5AMDVMr7vqHU IlhPfyYe4Dk66lzX4dzv07MzRHjcvOnKPLhT9PlrS856GwXpZedYYyH1ExCOLQxXz7fs3w+ZaYPH cnUGcbJW4oEVbxbIpWx51+fSkaHE9gPiBq1bmkmoNwBCiMdbATmXxbc0mPbhmYhG2DlO4TYARAwS QnQFlFuPEptf16jeGkw4a1HRcLRG0TKS7m7yBF/KhQjwvjM6aVNSPlJplCY7e6WU0v+CcQE1S3uO JpZ8j2oyxmhx9h3Rn2iL7HcFjnmq1N4hg1NhBRc1PUOGRz9G6wco9q3rPeS3vQO/lsmSg3DysR7K 4s0blXGzT0TgmGScjweJGy7GNZiSvgSfQEcoesQtCPXrQ6+LMz+QjJQCSWeatntc3PtjcBpzUq+r xJbwaIJj5nvCaDyEzs0wfZhXIHMFpLghfQeuvk2stMhwl1yZHaeU3fjf4z8s6guoNQKtqKuhkkxg e9iLPwBG3iaDUEydICRowZdvGZK3ItzSch8alJNLsGypy8ve7rB9BxlpzooWzu4XK+WgKJffRaEw fj3cEc9pqffCqYJX8zs3svD+Ni8q6AFtbKBcIz/vcbahJXyijcxiQSQcpjCt9T3o2OMY2tsBT1M4 G9gv4R99oo45Bk4u9ebTkXOuQVK70RCour7HDnM1tyVIE13hVhWpS2+xZntuvN65XubrmpQ/bQhe p4ZUnTr83m6tGlpx6M50KrZghc8Jnmlxoi6vF0qaaDcVtsy8dnWa+C88arUDOLhfFhInmLd7hEHo gJAgnLb5L+t0yDKkj8ZCW0FHZeLueyg3D72UaB6nzK20CqCMsOi9MXJsaBrcazF+7vIaaskz36pr uNkPzc4NFQNJFziwVPTv8vaiTfKKQd9UVBQGadahXiV//TY5buqKK/4IY60yRvw9/KXm/ssrApRf 9Gue2ozYOAd9cQZnvxpEGEkVG9w2IWIUwPdIbofaSRWj0V3npJRXseXN7HxEU7pu/JW3p3sokspx gP3uPhxyiXZIhJN1+XnrZexxxy+PK1NvneWTWFzyXneLBeKTtxxiJKa7DgNaN9/BXX0q0ojNWgV9 gbWyefPML8TITHOQlJTBB9YXayneNwdhkkfFYIq0G8cfYmOdh2gX/igIx5RUX+WRk28u7aZ6F2QR j8a8+Ll4r8oTqoI0OHVfEztC9TZYXfGxrB2v1hNEXLADy9Yv3d5ZrCXR/HRp6cBQOBR0XcCOA6wD aSgCcck2O7z/++n5gqjmaoWHWp9ROuYIu2r9vPwlWzRX9smVhFgHJnPsNGvSsuroiRrkCxnlmgS3 cKVcENQZoaivO7uKceHzLnpXiqtpIoaNkDK3t+3skaL3Sg7H1DAu9i8FS8sox/n0rT1hOoenbKWf 1ASrahUZgXjQOjK/6sdy1kKIC1FrjSNIQ41XPcwO1WB/8vy7aL+zQRVsZet4e/WuE6bG6AX1ZWzf ZnIgvL6FsTbWLucxXcH03e3BJexm/ApxZzd42bAcr3ZUukz2JpZVn92JXIzSay7A2XVcaFha46Lb dFz2UPaulx3MkxcdE31FBblZ545LsK3j+3isiOMTNidrSJTa+3fsW6ebBZIpP/eWxkJaam2U6O5Z tvu3yAcT72x8jaWu6r0G/xmVbvnhm8/dQ1vTGkYwnU9SQdadSiBpiyDFUCOEwMZ151NsYq7Mvody iL7GNIV/lHWrQ3s+HuT+d8Bbql2eLGbqcnLlhO0uggGzEvtwn3gaP0jqmUGI9VfNemOfubeZIE8r l4uWuLsKrjwI+3ULXvGOYuV2SEG3VP0vFjgUmwuoYjObUC3OMtR+pYlFSD7FzTHMLL0yR0Jr4MtN RZJ2MY2mMbl+wgA1FdyEBfVjcpYdsK1jpUmqWRw1R3nU+pqd6Wjokh7Xdg8shjLtGOuT17ECnLaW Qf9s9aY9siEMVZ3xgv021XysiYvrlL8xVZb8ByJzow0owApQFFNz26Pl5M/dewM6ClA9GGCM6VJ0 IAamXQ89wAMyctmnd+JOMQyoIu1Xgk9kG+/uCBfL/nu0cISDVOOmeQMPpRkv8S3Lh2hKvJlNDZNU QlDS/m10yFGHvqul6Q1PmVdFrkeh7P22ZoO1GR27R1JpE9yQAU8uq2C4nOS5yxWJDGAZwx63DQAT 9JAXAKYtpX+znJ19PVPk1cyES/j1qOJKj7VGicRBqwFMfXf/rF7ViYPwLRvKwceKoQ/L8R2Ro4bQ lwGHgnrTyxepmjVWsnrpjcCy6mCFser7HO4u8iCmkCVlyAV2DxLaq6OthomcMbC58xvlBgpAYfx6 47HBRpqlQFhHwEOJthgyrhqUxeBhFZ6TOYjxJ0XDPde/GPRhBOcCl00EJ4hdmkS+M/xLuo7HElNH 6RuqzJXg4CJxBBKVHFJY/RIQlgjawGiXjQW/H/26oOU152NwetxzcEOUyGFS3i40/X2gQ9blit9+ 7ra9baFyVQKlUxGiCaNM2juOvc6DSFSmAJYdAvI5mM8OJ86Wk5Uz/KuWEWJV2ej6EL1/NIjFcxWH iOVHPykX6vMUP2jBBN1dfvHVzWYbeZHD8IoD3ybFUL9Ur8sGcLk+OmnFdbykzfN/eFZzaxCO8zXB fQIAINdKDKJ1oDL2ZDT+dNbCrQXKUtKwQ7X7GzOi6ix0vZL1KlblHqLr+hhgU/3u59xI7ydFLOJL LmUHVHda1k77VAnE8BfOtkVUAYFFdvNGVlZEXCd/YWuG5WbAI3/J6kydI1E31Yd+A3RrsNblWgdb fYPzgfWwLKyhxD8w7CQa6Fe02C0+U9zpaJddcp1F5PVjYltxqF6MhM/D+ZqK/uQ8DSB3Y93neVn7 44YJEWMIgCzpgJ1cGOuC9A38aK03eXWskV2l1fZeQV62jzTp+RbWgL0hvtXM0fbNQCp1Pw1kGBul 7arVwoYlwEGFK4qzdsWew8HlxhQ9ePSNx9WOp/kmURElmFvhrzDaaEaqM1VG0xAVhw8rVwLhlJvV wUNL9oPSwdFK8XJeLhqQTYOjheLqXoNkldUffazREItOtJeVNibQA8qH4+4sROUjck1dXeZWL54s waziUuXBxpGpe+LYFj/ODB8qR+nx2y9SFeo/OvuFnhMnw38G/sz9Ip2TYP+qllGKk53bJxmU34kL qKp5jx7ykM8DZ632pi7/aHMMrpChLs344N4CF7Li6GOdUjgKC/oHfayG4IoArQb7xLp9AUnKcW5K 6CEUGki30sbQDpSDgHg2SkUlmLrYGWU4qwB/uIQBa469vJcGJzS611pILzdoctIFEu/44fG1Acrb Z+Ge/UZBgfFhMaq1rILVLoj95R6tuSMTpK0yf/lQ/HMc58HjZBNFIK6ipTXTh2DdPfUPpUKroTMZ iSFn4vuaVNm0XAFcaVreU21cTxZcFUioF3V3XWv7NKTVwMx3Chu84rYFEF4KgmNCq1A8tg0mTL7a peO9myn1RCnYUKXUjVGo0s3XnhYXlS3yMkqncxlWbUgTYhBMQCCdwkSCGJAkplFfmAZD4MqOSw8o Iw2cNyz0i01VWwbwGDWm5f53qEvBr4v4Rdu5VbYkLSaZeO2QjnubNA9r1OOvKwqIqsoOXJylAxdl cYgELVDcKgJOwsM6MsY7VAcAi5xivTQGjLXNfxgDRO1LOp7zzWZbzpp6+fLioOYC3p71/h1prqR0 iTt4vqlLbsMlO/qq8bu4zArqbk1Ng3Gj3fyprqgIAba7acm0TLlERyl5pDqdnmL0/n0thQCRI9+M s9ndFweLSU345Li2OFQLKL7fac3p1fpkIGFxgBAxg0ogADyqpu4XSRuGPQ3N9iFxt259zcTz9wqA ynybrlbKrIF7p61S4C3MHXYnjw5RyDaTQkcjqw0xcvllaDxMBzfr7MxEzQF/YprJaZuTObOfmyBG 7vZA94P7JoMP5fOvrLZjcG9Y6QvIEjjO/0Hh5GZL5C/QA7teE27RDJqN33+k601YGGk8PSVT4EOI PPzQibBOHqaAAr+00jqhgO0iwsgu4h35B+znfFEu5gwMq81u3F1HSBdp873GljztrzphGvA5/aEE JxmgzWfcr9YNpsyNb+XsvAhIVsaQ/hPHHcbLELwYFcXfR1fZMuJGUvBxzJba2M+tVxHROQnrg6oC HwvRntWLIJwXJLszI+UoVK9AX+RjbhgUfzgYlR9wspeX/eHna+su85HYbbEK1X0Px4KXJIQd5jUO hWHAYFuj8hwGxqJkWH2WLfyMhevz+cW6mSoUdWQNKV21d/eidau/viW0CYXAFbcu3E/d5YAUTnwr w18FkBGtTE9gZfmi9ols48Nber8biO9bTyy51PzcRZ1goSIiWyUH83OzqPKTI3x63MFwqoYB6c4u pOHMW/V2FVaFDocW2eddkrlONVU0oT0Ci/oi5yTPFuxO3DB4L3haI1wJ1gMVlSEF/496ONbXO6qY iDdjHqodPwryZJ/yo9IYGGY5U6+roetCm6p/QmM/PlsOAJdlleBMrb86iouUNVlkVFItoB36F2VI +yIMvA9a5pum3TH50zz1ukJduFvi7a9u2b83uFb365F36E4m7I0BAScV0Z+d1pkAVwTGa6/BWeH6 zv7mYMPRIf6NuqtxTeWku8bBW1CayqTe7FmeakCRT5AdJ3F+VMyodo2kuIrZpobgukoaey/TH+4/ Alfb1MzEViLnL94KuWhpdiaD4GrmbQKcfdX+NxpQng17Z6WDRgSPBKrr/OBXWuexgR/opiqB6PA1 rf664Ra1BK9LOrRu1PCm8uQwmwkT1P9s1YNAFoiG9vhTA+PYTGQfhEA3a7XGH75w3loch5QHUnQo tDzps1qcSrDW0XADK/rqcntIUBYwOuwpaNq+p/eTZQQsOK7seUuhEk9pAwhnGQeZu/BG3a79txEs a4HVgjZnjufHHeCDIfx7lZNOH9bCVqq0DTsh4s+oFBmyhqouA2cVaqLRfJfwCRTeIdp+J4BhC5Qy uVAmxwCQ1aqyLtoeKnO0dHCpPUx7QhYTgko417sR+DP5/w3FkkHSf1Zn8OI3eKN7aa6szbWL+L+V VONTJByt8RRmMAnkTBhpgZIhNOeGxIyocSS1jo/NdwgbRT2psdHCW6AUb050EJrf22eyVUfvb80D VvZFjcs+guHn1mGt5LlY7wFvfEOX4dYQHBD3SSdZC5M+eWHwma7VntmRZPqqV/W4MYWwYkVBK5Rh 1FHRMG4fSKhvPYLm7npU9DQoX8AlsNeh0uxvdWV5ZG8jxzVVOpT0ACuje7EvG5W7HvSUdKsMqnFH FyfWq7XARU8Z7GXs3Y/OmBGz4Ek3W8Cw1NdQQFDir6b1x8DmrK880x/m22bJ6uXmRLYRxmvi2mNx fc2EuOoyBRoOuhpzd3dx3WIxQC+quYZhbIIUH7/kkk6sDGk3kNhHHyI2kjsJxk9I4vWxTw4ldMXS w46YPxIt0MSW2QzRvYocFGYzC3+Z5QPSSKKNQik1AdkHK9zJ3LXBhkrqY8oFAsb9ULsMyrwObj3b 3TV5iXeSmGvI7lKrS8f1A29GyQ48ZnAM83idD6uMA1XTL7VH6nNUWWIhon7yZ0E2RxTvkQeYnBrr ne1Ekn6gaf6K8FtELfnSTxPoHrgo9orY6Gk1bV9PzTl0dOmWybpKrV0zY2oeDhk4h+BAogzkuacF tig1Ym968Pj9W8+azVfzgbhkwlIEE+5PTU1zPMH+TSbKjoWt2zdHPGsuroVoq/GIN06m+R8VtniY eNuta902aGhJaABZfaXGl1YSwLXCNed/+v8VOK2VBb5RPqKnUaEonwiPkGe7wsxgGVehlmknS0Id 23b/tvijVS42Wsm5gS1L5YRFFdgAwQJ0Swbttw0ytOoI6UCju7MRPbaRmfq2ghPIUSa+2j6n2azd R0GWT7PMXooO5P3sThbZstwVokhnnW6toBJcr4teKmOF40ljl+ROYqFNZBFcsa1an8ezHqrJSIjb 7TRsrpKUiRjgGj0+e1h0WUs0R8WEzLV/MjEHmo5z7b9w27maKNRzpg525bsZfEaB2iEWRIsnH1yP 2qKdauMn7vg6TgNy9NplLLPmEjZm97CNGrO33uaHXPpSnKqGTTYE6wZeS63tzBzLHDA6heQlPIPm VPDa8uPVHqBS8hSjQJVxuBhhnHpefkVwi0d8BnXkyYgqBH9tk0y0795BCWma4w+G2oiKPBajOjKH 3G6HrkLcnJintcq6Grq7m02nBfDb2NmLaksM2wJt6fJgQlJKlNruBC9JbeX5Qjz7pkL3zKJUIPid 3JLop5Y/lhD5eP5lY58FA+NVNPWG9K2ABz6doVXyRFh7XtagNqtOrM1T2DOYe74wWPliZ7KzOzBJ e5+kmz/lhxXHFV6jshTAKtK/6gqn/8p2K7W8lsqoW99Ul/N9Sx3esvh3Ak0yltRwrCpknH5Dn9Ff E1rsZCOavyNlcvv/CI04ggxWCgjpClXsCQ5ntpRT71L1wSEK1xUwfAxA9JOc1WwZcrGVJ40ejCUa noeHLONQtTF38y+cC+I/IdrGeBF4EPaka3j+7zKzS1a+4zBU4RtsQxG9EwHxtieaXRDO8UsmRVzk tEVtPN9Gn8kYDXXeyCE5l1mi7OkOssHyzO2SbwJTJBeLrf6sGs93Fw40ZFhfz2/XCltMXbkmVfjK CW17IuKhu9zCyFFiLAoGMjFrRZp8aW//uQivsEYYngiwHOSJyOMWCLO6s5Mfrx/Ns82u5dryd49q c8GY/sKZKf5Hxtt3b+wjs7Rit1EDaCfoOU3Ph/KmBOGobeOlS1L5cMk1l74XyKQMN7LOw2SvGIfC Np1GH9hFcYBrXEY31WR8v5msYA17uLkuqu9C5Kb6R8K6IhOF8j28+Lq0j1NFVuKu4kwoXLl8T83R yQQ3Ai8TG0OA65qfdUcM0lfGteo1h//k3ivjWLMJM+3E9KQR+Tjv1D/MaYVtkN182zHVtQEqcJHc evG93M4LuEfwWPqpZbWCFt1mth+SlhMscIQJT8LAoEMO3caQ7co8BsyUPwHbnPGU/uQKfl7mA1Sr gAMHjfG4uMUSHz2yyNkUT43XR6g8FE4R3/8QXxLcZiAym86jzkt9Xwi370bS2UBCD/JytUX3cB3Z paKd78YsDw6A0Nn9dJ/IDv2oOPKXZ+6KYszgM8Xoy0QLXl/iywKGU9Qlm86aL8/y4ZpOOZMPe8NK NubzeAzAXvr8DSZgEvSDdthcmgxv57EJV3iaPmq9mHREFZH5N8Z+CeaJfmVPGH8q0MN5QxJkJMC5 EtkLgs1JZ61GF20rerVPr2PzRJ1Kxj5hKEYdMRwj8LqIZs3xq23akjJ+NSXI+MqtNvaOShWGP8oa UL+YOxlxjkQoe+iwdVoE8db8+JPR2cYlxgrcEQG/jVo5AHhRv5wIspk8A2XvpJM0iaobcDQL+uIy h8JP+EGuC7K7048fm97pri2X3xWqzZ+mSB8IPVyK7tV2yt1VRSQ0y0U58PqdQVjH4HiWCaEMlDVx sYmzozsuXFPFiV5nRv14bdXGeElcyYanM/qsjn5J1GfJX/ELrXK4qp2nPoLZsX58dO+pHabQJE8S 6ifSV2zoKT5ltn3MYivH9nXjBhfIPO++GGs3KPqNzrHk1n3H3xOXn7IwHFSKbdIs5mcBvSAE4syM cCvzkm6IlyVPssx4jETzo+w95bQSY1TeAUnh6i2HwvjVFWZjIDi1+uAXZYCIxLXko2d6EEuaNawi U9BfKK5WHkEZoSWieX7yjeDgvSAXN/Xua42EMi7oHD0zuGDxzmaqZ60Eu3EIsg5HIk7UWozmBEDS fnGKcJQWeeX1vlSG0PGwcxFz9E9hNKOtLTFo5EnnjF5ZVgTVWDMDYhSFq8GJj/Q75AhVDBpafaVK EBaP/RI/gtXAAaMTVdO8lt4Rv0Bl763Km2AxbZ62A/mFsFOy0CQhFHlZhK6c9WRATJjC6A4nIm8n 8rFoOQRZacmJBPB6UBWtXTC0qsdq89LznJQpnITYaqrGhJVtTBJsko2gamE1BZJsp/NWLJ/RYjs7 vtYRVLHf0ChuJ0riS4NfGPLz9P6SC9C4UTr7jcLQzDR60BSwauZRqF/wj2+1NdoHJeprrbnAOSS9 xpgMwjjaOAZX1dzB8U9PyA6xo/njmPmCj8VEQLxBor8Kv8zz7IsymXLNFUzfBfrdSWC5EoQ/wvp4 1Y/A+feCsya7y+mwi1RzMH0taNXB4DS8h8XRAdHYqeHv3hEsy/3fDNlMjjQYmpk0asbE+pxJyBsE ta+dds3S8p8V0X8f4g36QSJoRDKQcvG1j5ifakdoJeUHZOdNsLm+SuTxV13Ryif7TyESUj6saG9j RnUb4VmqeEBTDi0pEPHM7gAzhMweJsjFS2KGy5H9jxz7xW4MsDl+Re7SC73c/x0CHHU1C/eTcbeJ kJ1ttXlxAwos4aTzZYuVIk/eLHnBauTLdngu4RnxBp1bLb42V1x3hEoT6iFBLEdtc2BYw8krvhWE /1xZs3NLFgkGVU/6bi9ERe43kS9Bv0ZE7Vqz8Mpv1zhHuDTrf2vaV1qX5akbR+Km09gMtXRKTG7s nFvbX8cHeu4vc61kVNOF7IZbEPNg+MPer//MNpQbgScFjdpHfIBveX6JwcYcCzwQVsN/UalfwjE9 i5yy8Y/7F/CBVf+zHaZ/ZAgfsrReY6tVnuA3xxJWBTdyxGmM/3ZcONwwiHg1MyAuuEQ7G/qal/bD sUOC30m8Kbp4VJfKbHnq9UfvKIG4ItZAl6L1ShtP1vce+jMAMeqwAAu5zGmdqaKAX4UmX/zNI/N+ GiKWUDtiOPGhJtDCm8WbiBvU0F/LNWz8EbEH2Mw5oUIUlPdU4vKezfUSQpn4CcxV84e94MfqNAtO GgX/XX3wRbAN+d9IEt6IHY1/1zYjc2f5oe79Z4jTLoVd7yBDu7F8G2hS1C+Sqp8zjY2ZHgRC/8pn tFnh5TUukwD+tRqdGVt9bT9H7NEvYKEBzKg/ukqA+RG3MayFL0gmfqc+6MG7BmM4A98AUpy7aaN8 AI7i90y2leLzSliU78eyaZslTzbOUDAcb68wrSOrF7quIRK9MA82e500pK/5BjSN1568hcijGJik M0VlvXmQ3wAlKctfvsiYAYeALoDMHsyKaMq1InX3KIQ8vup7GgfxIZCDFabV5QFcK/8wEkNpUpYR zti3MLhKc3Sln1MwAeIBFYxZrRoBn0AbiPXJnz6PesKLrQ5VJLS2tn7PdVfeCJZ7EvaCqUByL9DK OecCDeOudgJTfGNaBUHIJXRBelBtQ+kfPSmtlwCdN8Nn/6GO16fvwzhALIU7mqlzsYCApmMeNUKN j3nWfyndch2iEqZQLssfLxPpqZmFb7ZaW0EW1y0Rypc6MmX6VdtNXWsm5/GS3L+R36F0COsY+2uc OBclriMCo+ayKKS1WgcsJfQYoCQJAHow0Grwsw/sbC4tRNOn9yFhP23vJZgoD65d13xhZbbGMCa2 1Z26sgqjUdfRL5r05SsB+wis4UXiqJBhB7pZWy6ZXIovPz4m5woHkFjcpV1to8sIpONNcYdUJnRy h2COHgQhkylFyCABcOfRvPygt7hKSeMzeYc14CflC3RdyDdEh0oJ8pyYZYPKaCSAv4TBVVwwTzjA sSgyEyKpEXtKMxMiOvJ0XcbCtaGMtAlvEMe9czmhLqpljK7nY3KfNq88a9N97r+WZjdCPchYffKX IJHief1VF0OfOdbaqiANpuXKbUIe7Zj21hehhPfEmu/dTXvNMblAO8QSccQQ+gzQo/V1UuQRLCDO 69p3afJ05/p3QWhPlbwVsrSFJ8aphOvAMGz0P78dzEnyBxie7IRYyzy7AsVVhGVw5+blkaUMOxQm E5YGPT0TCh0wpcha/H0Re+7UzX9jV7qu9zbpeM9UsojbVcWMK8mrP9AuAvzC9t5k/O8H71MurORd Hns78n5xYaWT5zev41XiBydmuMQx4W+OH3J0P7dFl7UbPpDyfVnYIITRQOnoffaYwNyPkPKRiRUy eSumTYnixatXhXEvOKdw/x/uTVqOzVBraHthA9kxeSZ0/J7Z8tVNb/OsFbI88S/Hf9ZhP4j8yq91 3YfTFmr7liyo3OVAL0cbd59NYS2N6EdrRH2k8KkBg4OfZlpiWQbRAotsAol/dC8JAxmx2GqmAej0 CFKflGhD5THixvGxU0DW8sF+ZX0Na84NugBdj5DdZF5Ui5K0D1fA5648g7Kxm9BLpY3RwGlUzJiH iHchdUDCcDKE90HSZo618oTcdEZJWl5p/5ce4KP51jXQgXNEaety/ySb2DBiNsv8fgd4js+3Ll/P ltL1FoXccrJgd1n5O5vnpLLlu+QdEYiHRTPzF/mesuuadscGu9Mnn+O1fj+XDJVGaHuJdOvflqDa 9g0+TsBesotK4C3bnVvmYjPC4Mkn6Vtm2mNCbLmGSAYoeZI7PTn/l6W4SfNkr/ZriBWJJ1I2Ipxk 3nEc7nQHv5wF/SyRjt+iXU32Vj670UDed4ZNMK7o5+NeRmDnRtWy5kwoKKyxklOixe/CFHmncPrT rcuSNY8Sm+15MZFwxnsElHV468hPnf6Fjie+NyvWuiHtgwwfY7SO6A1+RYDX/k+iixRh9mJdwTNM UWDJG0Llvn+/3WgLDbh4B2RjZQs3vCOqCCxDjSFBor9GJlXsIM2BzgvgPaGk0gj09SIr2Oi1ETe8 uXrVvaQKuX1EsjYg+T/XYs3hQ2YG+v5WnuSdrG8TShnLmf+A+JstEgMan0XawzTGdWzyGr/Lf/ud HFlPmBlSlbQVG7J2VE7ofvX6wc7zF2cv4u+Qnse/ohwtO2eU1SxXpE0c3LbefErNgOfYvBUH1Ev9 Rr4plyQbHU5cJgGnXrsICqVDMXPgCdNUxsTl8r8yLPW6VSfrXM/prJjS7cQ7P+HzXrLS2S18vIjJ JJhMXHyh3b/1eowalCVh7T14zznaroIDWoY3vOMozOWxIqoTxS90Xg1hf+WzS8E77yI3xd9uLkUl Z+yiF2kTAUDfQLmfhpi/BLQ6vylb0tCFpQ3KLh3HM+J1P0O4uYLkKXRPc9LzjMpKuv55PgaxVnEv x5PbhTmCW4okcbdRSYJmrzyjPkCyGTKdFNQ+W+wL72WpLN2K32ndxWgn3HxJkKokkqHZK5r7Y0nk RRKUdNJp0nQcNpvkuN9FHDM73bQ21Q6vcUlrm67NI65aPKo6xN7p1wtKB+JgZKwWKruB9jwvbuQi bkHtwBKVCf9dqdMI5FjEpk1ZB1McGgtnwaP1gj1xQNzVxfuqRTO2TCsU1cWWqUPlfWICLRc3USzs HbdU+mzxlqj+pjo9YJvGBO4duYdhmdDnZcaO49x3sI2l6HMNC64vuaATkrlFwCHcXbB82FYa3Mta M5i9TQPnVR7UDcttAJT2ED6sKGErkVrqCm26Zido365n+luKnNPWl2vRxd548WAx4xzDl5Y392C0 5aMZ8jzLIPSBYxuDtCQojB+ti2MCAS7mlD0aH4VBZtBYo6qXLn5x7gj027OHQTh6aTWd67Wda7WJ UnYCjtwl3q8NvNdzlzRfC4g7PLUk4iETd8l1nsfGJsq8ZoFE2vWM/BuylKqBgdpmSz62sNBQVm9O kiLW9RjhkaeVNnsKBx0sIptXJg+Q8LDGp7T7JlJUYchjXAJ9oMV0YbDAnZ1qKZtI6NR501csqlp7 Ra+ekE8WtXBrAy5dMz81zWtdrIKHQRflbLOkIUJkK4qCeZbXrE7DAo9ENLYPMtC8edLlCOOZmNPz WJ9MSTnF4zDGiIgIwoxD6JakOxvH1nYQnBH5vT9/du77xltf4Oe63iKQrDy4+YLHBzg2PAPkXLVm 8mpxGDvt4ukMgsJQ5UN9Qvni6lXA0rVOozWryG1dr+v0q5aSGBC0GPLaUIHLdcF8GN2C1WiuCaxQ dIR4cV/IRexOulVLix2h7+QNj0blVPlrky6+sQm+S2nZIFSLTw7d7hwt2BFFxOJ6BMJApySAuWOA 78p40Ksv7qc2icwZcED/xlZiY6H0ghhSTWe1ZWFGjWK9xzGtViZDHc2hiF8IqYoFPrwvwuUShnkx 85UBF5vfY7rYhD1L+/+q3zLFPbFSIm+MBoccITMn9oNDeEicyGUKrPFmfxTe99XNG8Ao7qV1PK9a 84NaXOuFHFNioE3qGWkACqv6A+WV6Cg3Zy38cyXls2zf0DGBOk8sDicSDoihY1QImVquskf2mSY+ 4wQw4xpDNJSdkGEfefZzU7B4BZbN/VXiH8ILKReaIJok1jzSOqS/CrdGRFErFQDTQiRzaNfk7g36 yOPzLLpHNdQKyr8DhmDN/gMWfZT6DnQDs8NXY15OFpDcxeHhMAruKt9rKX2TI6245G1uS0q0BN3E D05Fg6jznSB2UzX6FAzkxwQvsrFeYjdpkpt0uig+n0hNh6Df7OYa/OSRxfsEJINXW6ZzIxI4kCMh wOc4B3rLCDKTEdWp+uJM1mvauEAZ0kssRQlNg3/yklyS/Z9uLsDAtbWAngHHL5Jl7kmtDGHhs+JO w9t8vOcehfZdJcqnL1kymR6395uMpChqsN+oBQW6PirKEBHAPeI7BnXM59J+ebttQQJ1r3rYwghb o5YjmcefufoGbI5A297D9ezpeOJj3RWWPLx0HSKp4k+29qZJSiYlZF0qFwhoJVUYhlW+4q/cqibu Qn8MU9RnyENcU7cf4kb/g4JUo2taFVs4PCyUOP7TqgyDYJ6+tgSJplIYO5/2mBhivWQ+gZXQLWyG m6+N9AYu4o3hLMRba6GWGUMPCZ5ua75wFu41Ut09f1w+5d7lXoNiSOofNP3N56eJMyeuvBZLMkEa wOQ6NhpRP919UxPPhPoUMXI+a2arZCd9xCOYXZ7HxT7i4MaKfrcFBfwV8s+PZaVueKpmWtHCb1in T8xzbXKNAVS+GwZTVpo973tBt6M3KtZzwnBxQZXtadzS0YxHtjRuJHX/x1JO5XYgIJq6/67EjSqq aF1e/KKmdCpPBRNUslIGNrae00A5TIK/FvGSlz5h0uuB+TZqlmajEoO3qjuYgyX5q6GHGrgKBuEp gsfMCU1j0wHd+KZuGt5QFv5DAtrDERR/w1cWetTvUZNpJK/cvEGhAAzXocnFPDXmabIk6zASEgQ+ 1DsSIBBdL0cj8itWslJQa5WpSVm4SByqcLNVtnHu/na7Ob+q15q4s265T49Wq1Gt45Ely41NqIUf tXPfGRtVVUttlopM5BvFf/yRcaOX0qwrC+6fn1VfCHoCxSzmbPb1a0kWkmFNoj7D0xU5REiSK19x H00eiP0LOuXDKwUTO/4go2lCiR3bg4qsr/2vogBiA19lyrLkl9RHVJkXAXX+wzr+aU5W03C0pluv sU3r68/J+tVuwyjzQm04Do+8swVhSeqxRUiN0dIJ8taRul59A8hJbEfEm3L1RBfPBbxaxHSM/VLX EkcHKZW4sYk5pmjd/UYFMhh1y+fu6r06C+p4wScaMmpVk9VY7cTRTM99+M9tTYwIsHIR/tFk1i6C 2bDPW2TcgAYHhgVxJPsDha0uTSz+/DDKAigTw9ChPc9NuH0oQ/ecyLWhUwESgtn+DHxiRKFLvzZB 5USMe3WXjSZw+ATxWGe+8KHRaX3bIXFbnIVJ3UblYqboTx0Ryv45zbgeBsBw5vdatrqmzqyEw/5+ 3qY/YZWiACeenCFbYfahsxhq3FBmB3Ht9q2xcOolAcL6d/T0tpzFoHJVzcbsLDWiElN71xmvzA8v VKqS1Qp8FRRCQ9XJjNVeKPpNO//ADkPczmu/6g5zZUQLoGRy4l7aKEZz6hxW7TOf1pAoToKkcMO0 EWyPRUzhqlBFLxsqGCFwxesXHM0iRjykgMmIk/xZCCOI2d+nOneXvByq1m6SBkRRLbahVXbm6/Yg d6dzDK6IYyG6iV+z/PApzyJb7H9adzrhnXBXVhRfwK4JO3QDT1RxujWPvu5X0F8l7ysfO242u1no mbwdOkQTi7EnGBvaC0YAUMIR2z7AQvlfPzyuSjrVlUkaB2QHOzCCrCGW7KTj4NJyLWPee2QL8jzy ygtB8nsLmxEwY1wlp6UYcDkE6a+qnxDFOAr7GDsBrihg4WRBToZ55hWv8CqHMCG7gwZa4OID4+11 ZbzofnjRcoT0KNiJjCoY9abky3mTgJA4TYjRJOZ0B8fTovQjmsKdrPBlEAq7+M7iJdUeC3uCp93v RvlYnIDj2bjwHxKb0/KvUUaLcpEYVr57ecvziVpNHvpnDSb08+4u1d7OTU2o174gy3oruT3XO5ZM XS3Z86TSeQ7s7rI8gQJnRsS+ATd0K71padmAZ27/VORXjfJilfw8BMbPtrtGq6NqCVNZnsWDwA4N OLFjqUjumQw5MKrX5DSwnASyUrCY6V1frYfkcUVwqJxVJsnY8jyhL489fvgQWOJ0mtkEVpD7ptfT 819kj4o21PduSEQ2dI0i32tYKNYBod8dA3ue07iMMpmpEFUXqsdkX/ih70B1KSB4VzBBG59Sfkv0 14FIjVM1gVLqEvnjD0n1JiGy44e18ji97CdWStYk1DdRyoOZizOZohuV0MOyT8Nqs9z0Ok01onst CuYPf/qwUaQM5MN7NKwM3v0w2XhFmZ1agUKwilSysRVz3MIIcn653ywK68NC7NL/T2Tu7dWaWgBY KHAZKYoCsigqIh2Z+QUVBZD5cK0sQpWyw88jK7qosBYsuwtb0iMRpSqEuz/Hcdeq3vcW2OWFN/O2 UKV3sKMeJoSbF8JCCaiX2U5VLhMk71SNqLarI6wwflaQO83i7mMZslHtR3iTsicKH05B3BHjzclk xBdcCXYWX4zGQ8Iq9K5wFv7gNM6PCqoCCt+ZYAbHzaTx57Sq3aTYnPPzhsvAdSO2BE6AgNw6RKxj o8bKTOTkFkYzHAkZhR+TfBNhoUh8UyyzAFt3GoCObyafU0wjFewl/Fb+HHeVXRz6NYVwKjNb0oT5 w5WYI3GfKt+Kuu7pUTd6cAp3LUqPr6fzEhhTHrGWCPzJq1+iuMSaGpI4KxACmyJdChRltphHguWZ mDEvTuNgI+w9oMpHAQb2KUSljwnFCWi30sIs0cXbwUzOMK0TjNV5rXSGI6/aWoV85ZuiBPTbfqvG CWZNH7JKn0ufwU7/jwc2IOyp7N6+GGJUDEvIn1253tyEWSnad9I/WxE08o+pSfOmPkcp7r6Lnkom ZH397RbcjMXT8n4Z2DCgJLRO65CDv7TIY65wVnHtK+tDE3BwR775iPPfZfWc9Zw2R8ws9mb6OHqP lAjUN7tTW6JTNTBjrZvUcS+UXzm5AWrzv7cVDtwl1xUWrXRRUwaFk9/uGkzwFWJrwtJ44mWk7TNT 8FhHuFSkSkCP8KtItCuGxleZ7ee0dXDo82CVSV2xDD5XKuzVE7QkRlpsRQFmZwlz9OscpSp8Anod ujc++SGeScKpxf+rOw24YRRvDMGlZTUETUIrDE34oUYXy0I28AR8Zu1i7g0Mmn3NzK2aXqdBvpKV y+KmfVZujtiG9BouGgO5vBZqjSrApQMtO53ZJvop0fOJQaFaNyo4EOmxHDUxn3uHzxdvOmc3zy5M 5Tf7LukI8bKvEoNFkWOJ0IsafXRJ2dgqSQ34pL6g8QZPV8vtxY8nYXNc2GzwXM1MoTb+HdITRilw ba3YLICVureiGsBQFObhDrhFnZBXMGSkcV0m/2QeHVY23y5j+cJ/fhtMBrTz8EPfGiio7k3rYiMD 8p1FbtG7UMVWvSHAyJHRtQwNxw1qRsfpqAJKJMcAB7XAY3U/hDS3W/Ym5Yc6MZMfJk/T9ij4GXlE fkXcAMW++bfQU0ailuc9UhfLyWSjWR3QFPtmR7gQG6TNp7MPiwTAO1yf3XVK7yxKhD8TE4dO3g8i pYvxD7F7wPTOJbUJ+HYYTjEI68j0RPyV90zdtqfWd5+jujcS/TqPze6VK4aV9CQpRJ14ClWvInEJ 79f7NI36UythOsfeSw3/GfdR9geMKgN5GKAQ55Y1IY39wzwL7/6o6HwfwoP9ixU2XKBVK+Gsrluu ZR0SVo3pBvx27dwXAHvITCtdrAYplhD5eP5lY58FA+TmurD/b/YWkz8sh8SbWJE6r0/yOVQ6MUc0 cd4uzHTJ0YKC60Uc5ofhSNSf14usoaoKbs0fUNFVNy+YxPEQgWOqEVjipxEdbhFjXb6oEX9YE4wS UJyLYXnaR7p4qi4Ed8jnpH2s08/Hnp1ccpdmYKSBhI+B8UAcekpu7rRhJ76oBnOHiq1OnxbUQetH vVBMiDaQuklRa+0M+ga6K+T/pQrSS+vI7VSeRPgueZ7Vv32HwBgXxJxpw/WE5PPkMe1KESSO8A9k zT2yDfN2j5ahdDUhKKs61itPdmw8phh/aWhe/SD+aixR/Fm6H5Hu7t7ixD8ZYeWhuhIUwTfd69zH Yta8R8gJUJ2YnU3lb9Hp71Rv43e/ZHnn6xHA47ec8zbqcxNcD9SFi1I71QFY2rv7//XlGB32wRqh XNBzt3498MhURI7dGUNDxLPaYLnOGw6f1KxctxKNEIuB8PGZAAdfk3///KcOma8CAiTC9TkIaq7b ol9dTJMF+ZCSpjiQ4czmGxxosrtCStbbbrz7WM9qWZeUAzjSNunYi+2pWQfzWnTbdAe0zG6E7VXo qFBH2Mp6FRtB/SvaVKZNMaVlrOV4ozRBilyI2ocyOw8DoVezUvh91yHUBckw4GVoG3lYGM1iS8/U bJ135glsDhgAEV8lTDs46gY4agEE3wRR/Gct7dcLWKwcjEGVSvJk1NfDflBspSs0+PA356kwjfJo 2LDh0FFAczzrCM3atn1ai1CA5RDxoLWYBoIZyGPXP9eHzliqTnvSvghv58D5O8vZzUAZ6lt25R4I yimP9zOadUUZetjsPkLUP3RfjdENvDmZR7RIfK7WsvGBavPoTw5IZ+Qd7CzbGVskA6RCQ+agsBD1 SrP2608cUF9H51VWJ551g8fZL3sjSx3R6bl/mZgRcch+fEjrOODkcHoy3jirSAU4Kk2JnPsAknfH 3rofDuUKF0UYqpRwxyAhfaExe7kdjF9aA5psyOuhwYo7dae3BSv6LGZvoOQtHkHPW0hNpdcYD8zd 5ex08io5vBbCXhyS0YmnFRhhj5YZi9tgQj4vQ/Yw3vfwaZpOy63+yqDixENIjrR/li85ZlYuigjO yfOUNiGcdvPRQIMg8Mkhd7F5jzuvbRckab7ktUgrt11ZQXzlwEQhFGp7kfhF2ddaUTUfu7YUESd2 Z+rmv3V4lHmWI9pejrS5UasBCzGqQeSY2P9QFuInNFKJxVVdG6UGh3j9J6yhwj655pLudOqAM1nq eS63rDTW5x3mzdVPkwDfgK6G1/FokraYYXAoQViefKepzrG/W4KQEM5QD6droHbhfawWV4wo4XT5 P/5CBr7moNPc9SflcYFN5LH9Rb2OUenmLkX2k2ekq75WDF8Vi5AKlGjFOkRCAryqT17b8M3Ma1UD /LD10nwNrHUJ/cV4VPV0Vx93IReQQlEFRZZOWpiqOVB27e5zAbO5QcUkdsmufz+3FC1+ofI6ikwz NPqxj+wwPaenDw1Q+ENWOR20Sdh74z2Ot9N/GEK0DksgedGyVHC7fo3LcCDnf+l220Q17azwMklh i6FF22blwI6E7o45ki12i/JJx+ttxLtSE5AKdkRvF5LMzs/36+04AHQ3fbKzVUDocNy4RUjVjv1b 77SStMjOeLesriM3Cj7mDSYy3vdW9Z+cNspunebAGK1O1tr+//GBFvqwgtuFNlv+jPVUb76kdJyu 46VW+I4hWwqyXXe8raA/FHIFJAFUXbXWEo9usO/sxDk/kMYYtE/1UdpP51UZrQCnWTM0V/MW7QKd G294yjLuvUrCQN4XoLcblt0aCIdf/doBzk9lEQL89UuKwuX90tW2fn5Zh/YUkirTfSuBqxpyhmyl gpB6q7AJOqzOrT4yeRPhCK4QR23A+sCECgu/lMAp2+T9sSyDrFIPjn4HlpaVDb85ZSiMCnTN4DPO V1qfq0lEyhMkaERw4+tZR8Md0cIUxioH63EXvv7u5tRuEjdUvsVRQVSXRlqzK57UdVwSN2DkcN8k Efvy8BNTZFPFS/RCmUtlJDzM3xWaZpy8E5STcILp2PgGYWcjYXUuwcQO6DbdGgqIFIEeP+HMFGNR HvntITvk+ePAZBX19Ohp1PXgDSFTHL34SUH6afk33sNd1wBLuL4xfGJplGWmBDm7OoUeMilcKQ4x p+OoGpqGNDY/Z6iPWmeam3KoJ+IeCzYCJ0JUzLA/qdVfnclEWzItOD+xGaAlXwjtL+q+MSXeMvfD yTvMxuRgolENx0kbCf20iRwjx4C1GUZCClAgiNL1VXeOWWT5Pi0StWUFiJHMxEDO5bN145rfA4D9 XlSurhj/xRVOIPTFJsVcbPA2Ht1cUFDU4mbO5XpngZjaPkKvweAhiy9/UD443e0jGlDrVqGPE9er uxOCS5jp+ddE3NsZm/EjtopfykJRwgTuEVoBbEpoCqqEl21P/icB0jXihod7sDGUVyj4rgqXPaAc 5qQIJu+NElqzTnSBycEF95wEseEjirsyqURhPRISQiic9XhpbgJnkTr2xIGe9jWhw9W7za+qlz0f puhhOvQrajmFgVEcPVxdPLfC0d5YLAvMBspVCeBi70lFONK+nip9u1JylroudVKTSCPsJgSDUj0g l0PwoXoEoZC1WwWTdbDq38T5jt/rIrncLJdZTn5fVSdvW2edprTPSxTVVwRTzh8YkjWzGfBMNTGc pf3CN9nwEnm2D3f6QwDb+kuOOgBYFONDFiCXJHqFFr792A7g0rJSqu17zD0u1eykqkuaFyKy8d5e B9ANPOW9Rwntr+iUOzAcefhxGqDGl7YJuNBiOfB9qsxjhesbIHKfR7XUZvRD51XmoxSWMGWNsvgx Tdufg+HvDBmzv2lnwupG9S+ZpIt5iMvl3X62iV1cAZoTPJpelILrjcGsgvobQ6+KHUm/BShUvFU8 kLTG0HmhleMOatY+VrtIWWXbKzOvgh7hTONeil+LBV1jlnZSCgYWlo+J49KRoNTybJ3e/3shkX2y 5q814mWcOHL/TucmsLM6fK4d23K3lL25PlW73eFhqnAv91PUJAy1tG8+clAkx+6yVW9pY9XDz9/r WemM8pNlu+qHfY6xB8hpMfEyNKYHT60uxRY+k/qmtTnpJUkTORvE+VpYkDyCUcugIIBvbi0CCppF M5Y/rS0Cg2Jt708hzZjYUI07Gm8zOl2pdZK2ZfU6I98SXN8daLFfYMoXGUQQTFlGuwYi+lH9SAMS zVfZr7AJSB4zGyeWrO1AEbfYo4M5qVeyXGhBDrqqe0bxwVG5mzUdN/IpsGu9qw0F+l6fF/UjsKfH idUXOuhNpXzlBRVIMCkEFdzNZDgmChQ3dMmYHtWdRttA5LgeUcYP3HVYpghxPgDPz4+FEewDq1kc mn1XnaAFWscNmSg59qOo/HxakCoaA+0X2MP0eksFo+Jp32iwbxTbsr7lSKjJSDbtLREvPh1Oqcc9 +7hgMC1oePWTspYtI7nfQldOvsHw2pHesRcaioovAvrEiXqofknTe4luxV3qNPV1tQ9T2Lh+eKq0 owD/0aGJ2jWWOodJIOKaj9FSUwLOCUNL0NkE1lgH4qAYqKTnaX8hY4t6nTIfdgIjySvXWMyPDuGw p9f+bP+IwSuSYiqh5yO9G0AEOChFJBBJGc0WwDigOO89Ea0KX3woIAA2LI12elQS78rpmzJ5YWLO M96vPOW7WMuJxRJopeIBrZ64Z9TY3ZwARCedQ+0NjjLlv9x2Mwy/2un3NzHhtjkqzB7jPA/ao9L/ fMxgOaJBBoQ7GZKjNPQSrZlpcsR8nGG5W14xlnDUpZ2eCTq4W+yHEYtxgJp1C5DJmuLExlGXNJNh VZ7wFOHfoU81V2xJbvJd42p8D1jPHF2DLzc3iiWRtpFn59eKcEq/lIDukbqnOkHcqzYhNP+lDXQj OarNw99s5y9t2wqCbaelHSfM+gWtxYpVqygFjwY5j93MrwMHiYEaFzutDJtBSaYegFaGbaFStVvm w1ZHDJ2KI8voB77CittXAm9hsdxXKZr1v3XO+/HzYOGFfXNfjO3V+T8TjAPA8REP1uY+m1wvTC0Z cySSniUizTON5pxym6OxOfYo8qQ85mqOFnLGHG1IT+WIeXI8LcezxorNMa2k0VLocT7f/+H72/f1 /fwB718/kqumhmf0H8pZCkFP5Hjl9fXVGMOLXz/Qlx9JZg6tR+Io31w96TPff+0NwP3T6/b7Y849 ydDOVGGS/B4PzYI4mV32uW1nOj1S+ipASDFTGRWiGPnhgxa9fg7MOHVfNCwWm2CsN+8LyvtjMKNq 3NbjrQlfjggpi+gcm+3ECEpSJ5rY9z1+3Qqj1hr8mZ9WQfvHAGFtz7fC1wpTkO/SRtK9z4q3uoOu y24ALlrXtJRco8FFSBNArjLK50Oii26SvaFo0eI+HboetKJZ2pBYlgqdKQVkUy8pLPcByLQ63h71 SDpDyQs3yVZ5MHyWjPTJz2p4W9nBApFubmWAmeqOKXfjnSsKBnp2DXVWLYFSsmaYKukIimDmXITt CV6E96AC/2ByMQeefHnFLVkLS3iR5Qjy69FxuOfOx8hJIzWo5wf7LCe1mYsJilXa64gZzkNE+PVl F7LRnfoWJMEHvem9BU+El2P4uxPJ33MhoMCL9UWyqQAcKTgFve6cdr883O586La7Qhj/WXe5nbfM 3sa24n+G9EnHLpo+vkihbqzJ/BXXrxMqbau2BKNMloIQoyM3yD++h3PKTm9YDrW34JEZTdp/Cun7 Rfx7NDKPenE7da59FKhwqT9Wg+MNAT/ztFrsD+L+zBslNuf55L3/JHHABspjT7r5ZGV35oNuBpbl chrWQr1kZpHVijutdDTKZTMjxPrAo+dQPahRzBgCmNX+utFcVbxGtbviry8hTlo9Pr3p+qksRckf AJ98qlFhZnUsBzXdJVgWdyVzZeDYEMeZx1SqCUJa60Nh3+47esOZIkIDbWGkIHk9Hw7ed8HFsX4B //XlRY15nVYvg9IlcaXMXscJMhdVuOIDnVGzMZd5KL4mD5eoD/JZ+caWq32I/HgjwZiu+sUW/8aJ 8PaELmk4C47nY14begxF/ahfe3TCcKWZ8VRgbdJ2RVolpPAV7CgjJnaAc/B5h+AX1PPApzo/5JAQ SUn2IDayFaxRqk3aFoxJtchU4yuklg5plzHiTr44yb0UBE53dw+yGR4Bzp1ml5C5f4i/a49Wcoey +b0QxLwNNLITudbi31axjt2jBWh5SJSnXmIMYfY2lopLk+y74jIQjvPO5djYfPzL4MeS0ogul2qn t7hb4+YPmo+/72Ch96WUlA4Eib4KNLoc6gJ8QotjxKrQ/UN+ohw2Qay7j2jlPx4ANbXOCpr8m628 ttlP0s57sG0tsPWJAjEJ7hS6+wQ6AWgqtVbYH59LsEY48QKCfxuqRxXUzmyEflYzn8TeliECn2LK Y95EnB5H66/XFVlsnx4oLuPi3eVgoz1j/IqnEv3UEWKjxOhNlnWgzet2ZauNglju3aOEIyJW2JaJ Foln4UvUP/b+p67qz7rdBpGhHQYb6lszdZjXqbKETrVx99oa35/zYrhskzY9PyerC14D5EbW0TQF GOTklfs1/rUpw4flKnkJN+0/Tv3NkSde9YwoKgScmUM0HoBmOzP7+26zaXxuSe+tMJ0CdW8+I26z eQcXtbk1pyrJuyZHdOo7nGMubO9JKmekY7fEs0L19Xz7Bia10c2+cf+7slwN+NUm0KDjIf0Z8MKU E8hcaYpe9PJc5V0VNYOsyvo4I5Xoc8MBE9EpWs51tPj1cl+J9t4eN9oeqObC1PPPwfh/qlpCe+26 8ehnM5h2B+W3NItfrlaj5zJZmVPNkdpFYtj5G8G70fGF0w1Ou7OKD5i6NZ4GKKeF6fDcfXrUMn+f MlRgpkUn/ViuV8j0uybCPjkZPWF5JODKR39XZB53wiFmt7mFZU121j1Fgd7foq/yXqJuYFrcAfZR IQVZ3wKntYrjoIxnCwU57u5+/Y7aS7Ac09EqyINUdPeg2EyKAgudS/uEJ9xkmqfpy3D0S9x+r5QK 0hDU7qKMIKt1qLZ5jXad+WBSVEo62vNZi366tuiSIf2bMfC6UAMheSW1UtXWkdeEYvDzsH4Brl+Y 8UE9l/lq0gTcVyH+eTDGol0T7E269STKzUQ5Ninp4GpNWxHuzdn5uw6KA5FAebs7qyFCzGHTOx2y jhDACc/e7qha2gUROInd4CCK7M8/5bJAEtkQz/uslBl/llckTzmy9paN38Tpq7bCdiiPcrcVPyyO vfiCP3WrlqynB/3p+FrN8cnGBVPq0mbmHIT/oNXAYjjHeNjdr7nFQRQXnP0CBoQH9rVpulzJmUkk GgPAfZUwQGLijtrVcYw5cydY3ayBg4FoxkYH1PTnsQZJNCD8v+z/wP8GcBUfFkJIio8NIcQAyYSw xKR4Qlh6VDjwX+P76hUKZW5kc3RyZWFtCmVuZG9iagoKMTAgMCBvYmoKMTAwNDQzCmVuZG9iagoK MTEgMCBvYmoKPDwvVHlwZS9Gb250RGVzY3JpcHRvci9Gb250TmFtZS9OaW1idXNSb21ObzlMLVJl Z3UKL0ZsYWdzIDQKL0ZvbnRCQm94Wy0xNjggLTI4MSAxMDMwIDkyNF0vSXRhbGljQW5nbGUgMAov QXNjZW50IDkyNAovRGVzY2VudCAtMjgxCi9DYXBIZWlnaHQgOTI0Ci9TdGVtViA4MAovRm9udEZp bGUgOSAwIFIKPj4KZW5kb2JqCgoxMiAwIG9iago8PC9MZW5ndGggODc1L0ZpbHRlci9GbGF0ZURl Y29kZT4+CnN0cmVhbQp4nF3WzW7bOBQF4L2fQst2UVgS708MGAZIWQKymOmgaR/AsZnUQCMbirPI 21eHR53OdJH4iJKuPlI06XV3v78fz7f1P9Pl+JBv1dN5PE359fI2HXP1mJ/P46ppq9P5eFuOyv/j y+G6Ws/3Pry/3vLL/fh02W5X6y/zudfb9F59iKfLY/64Wn+eTnk6j8/Vh2/dw3z88Ha9/sgvebxV 9Wq3q075aa7z1+H69+Elr8tdn+5P8+nz7f3TfMvvC76+X3PVluOGlOPllF+vh2OeDuNzXm3reldt h2G3yuPpj3NNXfOex6fj98O02ra4tq5jvZtzU/L8MeeWuUUOzAFZmAVZmRXZmA3Z59zWzQb5ju13 yBvm0h6ZI3JiTsgdc4e8p22P3LO9Rx6Y5x5uA/0B/kB/gD/QH+AP9Af4A/0B/kB/gD/QH+APzuzI 9Af4A/0B/kB/gD/QH+AP9Af4A/0B/kB/gD/QH+AX+gV+oV/gF/oFfqFf4Bf6BX6hX+AX+gV+oV/g F/oFfqFf4Bf6BX6hX+AX+gV+oV/gF/oFfqFf4Ff6FX6lX+FX+hV+pV/hV/oVfqVf4Vf6FX6lX+FX +hV+pV/hV/oVfqVf4Vf6FX6lX+FX+hV+pV/ht5pzFfWNfoPf6Df4jX6D3+g3+I1+g9/oN/iNfoPf 6LdSn36D3+g3+I1+g9/oN/iNfoPf6Df4jX6D3zn+jvF3+h1+p9/hd/odfqff4Xf6HX6n3+F3+h1+ p9/hd/odfqff4Xf6HX6n3+F3+h1+p9/hj3RGOCOdEc5IZ4Qzwtm2DWyRzvkDK9qycsnm/wtZLB1o NqUQOxDRgcgORHQ4LgtQaY988YBGdiCiA7Er7eVLHvfM6GREB4ZUF/TAjGelhnWATm3JLV5GCsy4 Pi2dQc3EgU4Y6MSFsiyy6Y518Ky0YcZgpcWJQUx0JjgTnWXBTYuzPJeTI2FydMuERnvHgU4Yh64M dNvh3q5MiHaPceiU7XB2xna8+M6ZS/synqU9sh3mbrGV9j3bYe56Zpi7gfUx/vvliwdPT2fx9Msk QM2+PKspC2LPd1c8fXluUxaXfnkurh9Yp0edofSlKZvBsNTB9QPrDKgzLHXw7gbW2Q//nWTYQLHD /9qYq+PbNM2bcvkZUHZj7MPnMf/7S+F6ueKu8vcTcNfYDAplbmRzdHJlYW0KZW5kb2JqCgoxMyAw IG9iago8PC9UeXBlL0ZvbnQvU3VidHlwZS9UeXBlMS9CYXNlRm9udC9OaW1idXNSb21ObzlMLVJl Z3UKL1RvVW5pY29kZSAxMiAwIFIKL0ZpcnN0Q2hhciAwIC9MYXN0Q2hhciAyNTUKL1dpZHRoc1sw IDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwCjAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAg MCAwIDAKMjUwIDMzMyA0MDggNTAwIDUwMCA4MzMgNzc4IDMzMyAzMzMgMzMzIDUwMCA1NjQgMjUw IDMzMyAyNTAgMjc4CjUwMCA1MDAgNTAwIDUwMCA1MDAgNTAwIDUwMCA1MDAgNTAwIDUwMCAyNzgg Mjc4IDU2NCA1NjQgNTY0IDQ0NAo5MjEgNzIyIDY2NyA2NjcgNzIyIDYxMSA1NTYgNzIyIDcyMiAz MzMgMzg5IDcyMiA2MTEgODg5IDcyMiA3MjIKNTU2IDcyMiA2NjcgNTU2IDYxMSA3MjIgNzIyIDk0 NCA3MjIgNzIyIDYxMSAzMzMgMjc4IDMzMyA0NjkgNTAwCjMzMyA0NDQgNTAwIDQ0NCA1MDAgNDQ0 IDMzMyA1MDAgNTAwIDI3OCAyNzggNTAwIDI3OCA3NzggNTAwIDUwMAo1MDAgNTAwIDMzMyAzODkg Mjc4IDUwMCA1MDAgNzIyIDUwMCA1MDAgNDQ0IDQ4MCAyMDAgNDgwIDU0MSAwCjAgMCAwIDAgMCAw IDAgMCAwIDAgMCAwIDAgMCAwIDAKMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMAowIDMz MyA1MDAgNTAwIDE2NyA1MDAgNTAwIDUwMCA1MDAgMTgwIDQ0NCA1MDAgMzMzIDMzMyA1NTYgNTU2 CjAgNTAwIDUwMCA1MDAgMjUwIDAgNDUzIDM1MCAzMzMgNDQ0IDQ0NCA1MDAgMTAwMCAxMDAwIDAg NDQ0CjAgMzMzIDMzMyAzMzMgMzMzIDMzMyAzMzMgMzMzIDMzMyAwIDMzMyAzMzMgMCAzMzMgMzMz IDMzMwoxMDAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwCjAgODg5IDAgMjc2IDAgMCAw IDAgNjExIDcyMiA4ODkgMzEwIDAgMCAwIDAKMCA2NjcgMCAwIDAgMjc4IDAgMCAyNzggNTAwIDcy MiA1MDAgMCAwIDAgMApdCi9Gb250RGVzY3JpcHRvciAxMSAwIFI+PgplbmRvYmoKCjE0IDAgb2Jq Cjw8L0YxIDEzIDAgUgo+PgplbmRvYmoKCjE1IDAgb2JqCjw8L0ZvbnQgMTQgMCBSCi9YT2JqZWN0 PDwvSW00IDQgMCBSPj4KL1Byb2NTZXRbL1BERi9UZXh0L0ltYWdlQy9JbWFnZUkvSW1hZ2VCXQo+ PgplbmRvYmoKCjEgMCBvYmoKPDwvVHlwZS9QYWdlL1BhcmVudCA4IDAgUi9SZXNvdXJjZXMgMTUg MCBSL01lZGlhQm94WzAgMCA2MTIgNzkyXS9Hcm91cDw8L1MvVHJhbnNwYXJlbmN5L0NTL0Rldmlj ZVJHQi9JIHRydWU+Pi9Db250ZW50cyAyIDAgUj4+CmVuZG9iagoKNSAwIG9iago8PC9UeXBlL1Bh Z2UvUGFyZW50IDggMCBSL1Jlc291cmNlcyAxNSAwIFIvTWVkaWFCb3hbMCAwIDYxMiA3OTJdL0dy b3VwPDwvUy9UcmFuc3BhcmVuY3kvQ1MvRGV2aWNlUkdCL0kgdHJ1ZT4+L0NvbnRlbnRzIDYgMCBS Pj4KZW5kb2JqCgo4IDAgb2JqCjw8L1R5cGUvUGFnZXMKL1Jlc291cmNlcyAxNSAwIFIKL01lZGlh Qm94WyAwIDAgNjEyIDc5MiBdCi9LaWRzWyAxIDAgUiA1IDAgUiBdCi9Db3VudCAyPj4KZW5kb2Jq CgoxNiAwIG9iago8PC9UeXBlL0NhdGFsb2cvUGFnZXMgOCAwIFIKL09wZW5BY3Rpb25bMSAwIFIg L1hZWiBudWxsIG51bGwgMF0KL0xhbmcoZW4tVVMpCj4+CmVuZG9iagoKMTcgMCBvYmoKPDwvQXV0 aG9yPEZFRkYwMDQxMDA2MTAwNzIwMDZGMDA2RT4KL0NyZWF0b3I8RkVGRjAwNTcwMDcyMDA2OTAw NzQwMDY1MDA3Mj4KL1Byb2R1Y2VyPEZFRkYwMDRDMDA2OTAwNjIwMDcyMDA2NTAwNEYwMDY2MDA2 NjAwNjkwMDYzMDA2NTAwMjAwMDM1MDAyRTAwMzE+Ci9DcmVhdGlvbkRhdGUoRDoyMDE5MDMwODEw MjEyNS0wNScwMCcpPj4KZW5kb2JqCgp4cmVmCjAgMTgKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAw MTQ3NzU0IDAwMDAwIG4gCjAwMDAwMDAwMTkgMDAwMDAgbiAKMDAwMDAwNDAzNCAwMDAwMCBuIAow MDAwMDA0MDU1IDAwMDAwIG4gCjAwMDAxNDc4OTcgMDAwMDAgbiAKMDAwMDA0MTEzMSAwMDAwMCBu IAowMDAwMDQ0OTIwIDAwMDAwIG4gCjAwMDAxNDgwNDAgMDAwMDAgbiAKMDAwMDA0NDk0MSAwMDAw MCBuIAowMDAwMTQ1NDk3IDAwMDAwIG4gCjAwMDAxNDU1MjEgMDAwMDAgbiAKMDAwMDE0NTcxMiAw MDAwMCBuIAowMDAwMTQ2NjU3IDAwMDAwIG4gCjAwMDAxNDc2MjIgMDAwMDAgbiAKMDAwMDE0NzY1 NSAwMDAwMCBuIAowMDAwMTQ4MTQ1IDAwMDAwIG4gCjAwMDAxNDgyNDIgMDAwMDAgbiAKdHJhaWxl cgo8PC9TaXplIDE4L1Jvb3QgMTYgMCBSCi9JbmZvIDE3IDAgUgovSUQgWyA8MUE3RjE0RTE3Q0VD MTU4QTI2OUQwOUQ0RERERkEwRTM+CjwxQTdGMTRFMTdDRUMxNThBMjY5RDA5RDRERERGQTBFMz4g XQovRG9jQ2hlY2tzdW0gL0RBMDc5OTA1QzRBMUQzNDg4RDMyQTQ0QjMxMTdDM0I5Cj4+CnN0YXJ0 eHJlZgoxNDg0NTEKJSVFT0YK ------=_Part_192799_133127925.1598809356621 Content-Type: text/plain; charset=us-ascii; name=Leung.pdf.asc Content-Transfer-Encoding: 7bit Content-Description: File Attachment: Leung.pdf.asc Content-Disposition: attachment; filename=Leung.pdf.asc -----BEGIN PGP SIGNATURE----- iQIzBAABCAAdFiEERsXEEHUY1fR9w4GRPWmEBlIIm7oFAlyvps4ACgkQPWmEBlII m7pJYQ/+IfWSHl6xBRy+/ZksrezBun5k41ltzzxD00FPLhLg9L/t33c9zBPc4iF4 E6X5iwRdTej/QRFQ0CbmrRuluiEydrgafHCNkxe/ordZj7OqE4336JqufnL4Y0kp i2N2N1eC42IE9Y64qHe0uyp5BxhZyLW9cQsBABuHAaCG6X80m9ATeE4ZYc7DeLgu vxksM+GUTLoLX0zw0n0YnDzZ/E0it8FGKaQHWQ93sj9MD6y9EIz6GHhIQqK9/G4n QBpjk0U26dPvN2wjnwgxbo5KctNnJxvfTrGGqK+ZC1ugDJDdmaah3ZFPYKiHWuch iAwaWmCp8Ob+sL3uDmmD3VIwLFcNyMQoRtJ8ock8R10wjjay1IS9AinB1L40OZXq oBUNxx+OQXNNDtBpFWvu0pML5qqie5eT0SFUlVRy7MKXhQ7uM87T7FVvABFsRCsm pq7WERB6DoWU0qqueMQbApoLR9cRV1da4hm7MhT+stwvQgk7HLnQjuTd1oy37gi2 XbEUWe34l6nDhbPjue7EO4FdrXQaSgXReo2r1vVOCH2Z00sSidK7SHKOJDz2DbVZ NVSiNjB962MfsZwtMH+/Urp366/TmclG1HeXLxl4HIVSrIt6yYIx1tMkOQh4I5Ad BqtoQmFyU0v+dibT+dC7Qe3dCBfe4OeemauxF0HOdPrHI/D9AYw= =unJO -----END PGP SIGNATURE----- ------=_Part_192799_133127925.1598809356621-- From debbugs-submit-bounces@debbugs.gnu.org Mon Aug 31 06:16:42 2020 Received: (at 43117) by debbugs.gnu.org; 31 Aug 2020 10:16:42 +0000 Received: from localhost ([127.0.0.1]:51614 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kCgri-0005p8-5B for submit@debbugs.gnu.org; Mon, 31 Aug 2020 06:16:42 -0400 Received: from mail-wr1-f45.google.com ([209.85.221.45]:35508) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kCgrg-0005ov-G8 for 43117@debbugs.gnu.org; Mon, 31 Aug 2020 06:16:41 -0400 Received: by mail-wr1-f45.google.com with SMTP id e16so5365464wrm.2 for <43117@debbugs.gnu.org>; Mon, 31 Aug 2020 03:16:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:references:date:in-reply-to:message-id :mime-version:content-transfer-encoding; bh=FmvQn616TLqGftNb4fZiTlJkWVe4vNFllzbmVzLSBdQ=; b=OeTFwXvOkQDLWoNaRgALWIREI5bLNz9CW6GetPAQ73nvKpGGTpT0YT/aRfll0t83Q3 i+7YMZHLOtLg/L6GeYAKcZW0ejPbe9ttMgBxmfKIA+FLNVrI8zvr6RCSIEbJkmTHCf4Q D26v3XzjvSkt6kPC1vi8LjOF5sFesS0tvGwPppHu5FKMzEYwnXQ3FfjZKCSwu06eJkmx vH6gblrgfE6XnzR3ngRP86gJEc4P8/Dl4PCj+iXEOWsgrxwSCLrqimG0p8M5RFlU1Xl4 +Gh+v88Lk1wdoiIrcJUloI9K8v0acOxBtp6iH4/2RY5e+ShM5DcW2rKVVB4raDVNaBST 37ww== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:references:date:in-reply-to :message-id:mime-version:content-transfer-encoding; bh=FmvQn616TLqGftNb4fZiTlJkWVe4vNFllzbmVzLSBdQ=; b=k0s6FNxuX+RG53VabcBb+dRDC7bSLMld0flzSpXKCVuc8IlBbMYzByc/Oh/0e9ce1t eAsdc9ONvUcnT2qMZvaESD+j7GdieashMFY17Iv00+5WSA94S9Dr5GdeHVd8XklSKBVB myCYOd8qhmnjaMhiV3YC8ndYP+8zbzjkCTmJoECaOvSvHD/HiVjwHi9l6svVKL9Lek/Y SSqE+f0ZG/hV7yi0D8oy5OYIcJRCv2vqLgfxCbPSk/Z4wGTFHJrVtainbGThIOl0wibz zl7mJN/oMqGd3R+fugFs35W0kyplS0wCz1pKz9dGyhcSDQJY0MEmR2NYsZ8UisDaFuRK WO2g== X-Gm-Message-State: AOAM533SEsP3BUM56z0BjtTiSz7rS7Q2IAbs/brMpC5zUjzUkp9DAhzE sDl9VPUjOMDFG0B7TdCDuv9ogekB0Rc= X-Google-Smtp-Source: ABdhPJwgq7aMMScODlZh1B8PvHEaZsBfFNCMh/RP2MzK1JucCewyBXklDNTeDr4pZj4bNoCBqcG1mA== X-Received: by 2002:adf:c3cc:: with SMTP id d12mr952846wrg.399.1598868994899; Mon, 31 Aug 2020 03:16:34 -0700 (PDT) Received: from rpluim-mac ([2a01:e34:ecfc:a860:4833:59bb:ac1c:3d8d]) by smtp.gmail.com with ESMTPSA id g9sm11715724wrw.63.2020.08.31.03.16.34 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 31 Aug 2020 03:16:34 -0700 (PDT) From: Robert Pluim To: 43117@debbugs.gnu.org Subject: Re: bug#43117: [PATCH] Add .git-blame-ignore-revs file References: <197409406.192953.1598809591346@ichabod.co-bxl> Date: Mon, 31 Aug 2020 12:16:33 +0200 In-Reply-To: <197409406.192953.1598809591346@ichabod.co-bxl> (Brian Leung via's message of "Sun, 30 Aug 2020 19:46:31 +0200 (CEST)") Message-ID: MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 43117 Cc: Brian Leung X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) >>>>> On Sun, 30 Aug 2020 19:46:31 +0200 (CEST), Brian Leung via "Bug repor= ts for GNU Emacs, the Swiss army knife of text editors" said: Brian> I made some style changes to em-hist.el and registered that comm= it in Brian> the new .git-blame-ignore-revs file to preserve blame data of ot= her Brian> commits. The single-clause if statements frequently throw me off= , so I Brian> think it's worth removing them now that there's a way to do so w= ithout Brian> ruining git blame sessions. Brian> I signed an FSF copyright assignment about a year ago when I sub= mitted Brian> something to the Emacs package Ivy. Attached are the files they = sent Brian> me confirming successful registration. If I need to send somethi= ng Brian> else instead, please let me know. You've configured emacs to replace TAB with SPC. Please don=CA=BCt do that, it makes it very hard to figure out what you've actually changed. Robert From debbugs-submit-bounces@debbugs.gnu.org Mon Aug 31 16:11:55 2020 Received: (at 43117) by debbugs.gnu.org; 31 Aug 2020 20:11:55 +0000 Received: from localhost ([127.0.0.1]:53780 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kCq9j-00029e-2E for submit@debbugs.gnu.org; Mon, 31 Aug 2020 16:11:55 -0400 Received: from mail-lj1-f175.google.com ([209.85.208.175]:46247) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kCq9e-00029F-0j for 43117@debbugs.gnu.org; Mon, 31 Aug 2020 16:11:54 -0400 Received: by mail-lj1-f175.google.com with SMTP id h19so8144014ljg.13 for <43117@debbugs.gnu.org>; Mon, 31 Aug 2020 13:11:49 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=sender:subject:to:cc:references:from:message-id:date:user-agent :mime-version:in-reply-to:content-language:content-transfer-encoding; bh=fVFWZI3crEOfs1izNoEoYvyHBFr8HqTVcE9W4J98+6w=; b=uULOybSZAQXMYjernCYj1wNCnhSnHBYwfNuGk3Ke2KVhBNMj7iPRjpqXPiVW7r/NQV gJK0mrWbrkUIAfFYttwn9I1/oyBClc6gKlTHAVmZYS03zz/iGrJcBDQDuH74v9THJ6Ky s0JvBe/a5IJTyyGL2F67PKUmotoiWDAVdXMgenlSsgqmkhITL7uB69NCvgwTRwMqSrgn /u6/xPy3L4tpkMJEp5F4hOyogfCTANNJT3rHmQ/Dy8T7NQH5XxYZj9pmGC0/xDYdcFXk KM8dI5o4qLEUQV9Glf3CXFQV+b9iXh2GKGtTicnS2yfnGXusEi6GqlheFT3+c10s9vv2 GwcQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:subject:to:cc:references:from:message-id :date:user-agent:mime-version:in-reply-to:content-language :content-transfer-encoding; bh=fVFWZI3crEOfs1izNoEoYvyHBFr8HqTVcE9W4J98+6w=; b=gF922SShhCuvO8OtjrCpWM64OGkK61QGC4zv6HW58Fxo9LtJqXDv11YZgYkgfiRWIj JoDDExF5R4c+25tnC0jQ7OaSTrRun37ujpij9EJkm3AuraBlSAasTXulDoOPfwsTSW3L bPSZHRi9GGP25BTqwce+kYugmpG2F99omVLBtMeJDj7tOPEpV93slPZsXYeb06fM+L4U nEDEUTX8Ia1VI732TPnrnWEIWMv4QK3lnMpzkwLbYRIQIyqX+RYZRMOJcsrAlA/tVul4 RzWAdMZTkOjRgH/yQiE3LG5qJfXgpCi+7C73PNaMIUVwrcxZX3Z/vyuB6EqnHBIPMxhL 9Fzw== X-Gm-Message-State: AOAM531th2ZuaCm788CimgZUTf6SO9dHoC9qjYSu/i2BGKmFBc95Zvuo xdXN2MPE4Gn7tLAr3ZiKcoU= X-Google-Smtp-Source: ABdhPJwn9Cw1Pth22QsiZNxC8FxGuQu2hF4pwxDH+dHsuvnngJeDaRwHASv4F0g9JD0J9hY816ExMw== X-Received: by 2002:a05:651c:1b4:: with SMTP id c20mr1303710ljn.432.1598904703959; Mon, 31 Aug 2020 13:11:43 -0700 (PDT) Received: from [192.168.0.104] ([94.229.108.16]) by smtp.googlemail.com with ESMTPSA id e21sm2209136lfc.97.2020.08.31.13.11.43 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Mon, 31 Aug 2020 13:11:43 -0700 (PDT) Subject: Re: bug#43117: [PATCH] Add .git-blame-ignore-revs file To: Robert Pluim , 43117@debbugs.gnu.org References: <197409406.192953.1598809591346@ichabod.co-bxl> From: Dmitry Gutov Message-ID: <9aa79095-18d6-d0bd-18ad-aa5d90f0bb1d@yandex.ru> Date: Mon, 31 Aug 2020 23:11:37 +0300 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.10.0 MIME-Version: 1.0 In-Reply-To: Content-Type: text/plain; charset=utf-8; format=flowed Content-Language: en-US Content-Transfer-Encoding: 7bit X-Spam-Score: -1.9 (-) X-Debbugs-Envelope-To: 43117 Cc: Brian Leung X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -2.9 (--) On 31.08.2020 13:16, Robert Pluim wrote: > You've configured emacs to replace TAB with SPC. That's what our .dir-locals.el does, doesn't it? From debbugs-submit-bounces@debbugs.gnu.org Mon Aug 31 16:34:54 2020 Received: (at 43117) by debbugs.gnu.org; 31 Aug 2020 20:34:54 +0000 Received: from localhost ([127.0.0.1]:53834 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kCqVy-0002m2-7y for submit@debbugs.gnu.org; Mon, 31 Aug 2020 16:34:54 -0400 Received: from mail-wr1-f50.google.com ([209.85.221.50]:39339) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kCqVv-0002lp-6D for 43117@debbugs.gnu.org; Mon, 31 Aug 2020 16:34:52 -0400 Received: by mail-wr1-f50.google.com with SMTP id a17so6367494wrn.6 for <43117@debbugs.gnu.org>; Mon, 31 Aug 2020 13:34:51 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:references:date:in-reply-to:message-id :mime-version; bh=BZ4gQz0wRI86d0+xUrkbks3QGxWbC/lMx2mT0GKKUos=; b=k9jwV+x8GjswgQPp/8+V8snJqaa3KLwZV3txfdZLiQ/43CqAzru56lgstVfD5DYZTW NglCmHrcG02yqaff04zBmJeCI6JgjlR/d4wy+yLjQvEA6/vXAp/eQAJHrQiHdJlDp5rb Gl2xv7e6CTnm7oEkNa+MMNAcduUa7wj1IU+40NpVzPhAHhsQcVePHN5+HZmmDWKt/u7S glUq4PwHNLps9wr1zuBQzTZg1XY0rtWnNVXyT6W503/+Zh8KY/qEi6NRtAknKgGc23BQ etsmPN3rE9uGkKjEcjxXzcCYDRui5Y1jY613DPEOh4iBzp3jpB5mDcTSTJnodG4+rbTJ pF9A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:references:date:in-reply-to :message-id:mime-version; bh=BZ4gQz0wRI86d0+xUrkbks3QGxWbC/lMx2mT0GKKUos=; b=Rg9loQmmbCrmyjj+HZb8O8tPJqwpv3rD7rkvmiv0S23Zye2miloXfz056chMYGYD1+ b2SaJP7ssPYKM4lwzZahTtCATju9ZgKnj9Dy3ujbr62I6T3GOErjHx169uFoV87SbR5/ TWG9FxtKX7YzEm72w55w6tNYYSyQLAvEfajDSF/Jt/A94B6SnWaKhNoP/TSywQtwShjO tBux0XGxb6GbvaJGhFeLmEej8Wsrjd9J6ILJeEKClyw5meCyuUvu73A78VL5AUsL6G3k l7q4wRN/qwjAdI7rS3eTw3D6a1sxvXLghQ583Zxk13XFHxB5xkvAbPV52XO+2e2g3rpp llmA== X-Gm-Message-State: AOAM532G+zjkbqfq4OLzTM7Nc9ufXQMwsweylFlqGwKxlgjZSFJpunOw yl5idjONJh00GvFAO5l09b8= X-Google-Smtp-Source: ABdhPJyGe7uMg6TeYUXBhsSBlPcEQK4EiJtvcJP+TRiJ6aQ2JtpJcUuHwpDoB8lgeFWSoXp09S1F0Q== X-Received: by 2002:adf:d4c1:: with SMTP id w1mr3153912wrk.108.1598906085186; Mon, 31 Aug 2020 13:34:45 -0700 (PDT) Received: from rpluim-mac ([2a01:e34:ecfc:a860:4833:59bb:ac1c:3d8d]) by smtp.gmail.com with ESMTPSA id u126sm1201165wmu.9.2020.08.31.13.34.43 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 31 Aug 2020 13:34:44 -0700 (PDT) From: Robert Pluim To: Dmitry Gutov Subject: Re: bug#43117: [PATCH] Add .git-blame-ignore-revs file References: <197409406.192953.1598809591346@ichabod.co-bxl> <9aa79095-18d6-d0bd-18ad-aa5d90f0bb1d@yandex.ru> Date: Mon, 31 Aug 2020 22:34:42 +0200 In-Reply-To: <9aa79095-18d6-d0bd-18ad-aa5d90f0bb1d@yandex.ru> (Dmitry Gutov's message of "Mon, 31 Aug 2020 23:11:37 +0300") Message-ID: MIME-Version: 1.0 Content-Type: text/plain X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 43117 Cc: Brian Leung , 43117@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) >>>>> On Mon, 31 Aug 2020 23:11:37 +0300, Dmitry Gutov said: Dmitry> On 31.08.2020 13:16, Robert Pluim wrote: >> You've configured emacs to replace TAB with SPC. Dmitry> That's what our .dir-locals.el does, doesn't it? Only for lines that you change. The patch has wholesale TAB->SPC replacement for lines which haven't otherwise been modified. Robert From debbugs-submit-bounces@debbugs.gnu.org Mon Aug 31 16:46:13 2020 Received: (at 43117) by debbugs.gnu.org; 31 Aug 2020 20:46:14 +0000 Received: from localhost ([127.0.0.1]:53845 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kCqgv-00032n-Ly for submit@debbugs.gnu.org; Mon, 31 Aug 2020 16:46:13 -0400 Received: from mail-lf1-f44.google.com ([209.85.167.44]:32825) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kCqgl-00031h-R8 for 43117@debbugs.gnu.org; Mon, 31 Aug 2020 16:46:08 -0400 Received: by mail-lf1-f44.google.com with SMTP id x77so4289402lfa.0 for <43117@debbugs.gnu.org>; Mon, 31 Aug 2020 13:46:03 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=sender:subject:to:cc:references:from:message-id:date:user-agent :mime-version:in-reply-to:content-language:content-transfer-encoding; bh=M385yrQIozDA+YMvjmdnnuzIQF2KiQP74WQv8RHuyYw=; b=b82UqCelx4GyWeYT8Nnv5dLc0OE1r/kbapzPx0YmQHjrkC5aJnBWHy4KBtH9fN3svg v987+PDCdfJhQy3kmLgryXGCWkNPLfKsGoAXo7uv0vAcewSePVPbtFxt4jcvYQJd5nxr r59Rec/w18D6++Wld1yBYHcHchieHi2bpnMRnB6pvTwYOuPyMT6ibdORq3oQ3JsK8Vq2 WogyFBAtfXrnCFZcgsUnGmnua5Piju5uqOv43XiwDCFfd2DbTQXFekw7pFU5ON/0Qrl3 aLtMJX9qi0XbxWeYhtNXOPD6jx7rJ7OEh0VlmSLbWwsG/MkODi4GA+MTHEFMrrW6i9Z2 L0ng== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:subject:to:cc:references:from:message-id :date:user-agent:mime-version:in-reply-to:content-language :content-transfer-encoding; bh=M385yrQIozDA+YMvjmdnnuzIQF2KiQP74WQv8RHuyYw=; b=EOuWW/9jQp6EHjWXpFar0qbFGbcRund9gX6DenufK+UHk6cVMQ81DqEkovviqn8au0 MA2CYBHDlnx0/7G6euy20SBKx938SsUzllT54LNZdIGY0e7rtqux3NtNaFtRDGTFpDJU MSFjPsBRvfin4g8+Sy6u7vd33F4N40oMCz7m7U6P5KL4fs/88GvbG7Ice1r1Z31jILRs g3PeuYSuQyvmwX0xpMpNTY/NMRFhgZ5Q5hSsH48cYAg1SIEPbMJagSu9hbSBnc5cJbXl sx1KSoqVP4G/luBUIWELYVYdoA7+WkFYgf1C0TC+bf6hjJPJzlTYeLK60A4esELc9TM/ ysXQ== X-Gm-Message-State: AOAM531skHJM2om3I+cSDe8HSW110vRzpr0tOc7QVvypFiJccfwKBu2f kRG33xaAl3RZYNTZXv1wKVT9YUuEx35c/A== X-Google-Smtp-Source: ABdhPJwX/p8LWttimOgXzJfYJXMLD3wkFn25Q/63W/gMH3XcTIrwJtQ8WNggnVHkQhsMKPaNyr+12g== X-Received: by 2002:a19:23c6:: with SMTP id j189mr1460872lfj.79.1598906757375; Mon, 31 Aug 2020 13:45:57 -0700 (PDT) Received: from [192.168.0.104] ([94.229.108.16]) by smtp.googlemail.com with ESMTPSA id n24sm2209647lfe.38.2020.08.31.13.45.55 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Mon, 31 Aug 2020 13:45:56 -0700 (PDT) Subject: Re: bug#43117: [PATCH] Add .git-blame-ignore-revs file To: Robert Pluim References: <197409406.192953.1598809591346@ichabod.co-bxl> <9aa79095-18d6-d0bd-18ad-aa5d90f0bb1d@yandex.ru> From: Dmitry Gutov Message-ID: Date: Mon, 31 Aug 2020 23:45:55 +0300 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.10.0 MIME-Version: 1.0 In-Reply-To: Content-Type: text/plain; charset=utf-8; format=flowed Content-Language: en-US Content-Transfer-Encoding: 7bit X-Spam-Score: -1.9 (-) X-Debbugs-Envelope-To: 43117 Cc: Brian Leung , 43117@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -2.9 (--) On 31.08.2020 23:34, Robert Pluim wrote: > Dmitry> On 31.08.2020 13:16, Robert Pluim wrote: > >> You've configured emacs to replace TAB with SPC. > > Dmitry> That's what our .dir-locals.el does, doesn't it? > > Only for lines that you change. The patch has wholesale TAB->SPC > replacement for lines which haven't otherwise been modified. Right. In that case, we should probably clarify that we don't usually whitespace-only changes far from the code that's being changes. Do we accept reindentation patches, though? Ones where the effective indentation does change. From debbugs-submit-bounces@debbugs.gnu.org Mon Aug 31 16:57:51 2020 Received: (at 43117) by debbugs.gnu.org; 31 Aug 2020 20:57:51 +0000 Received: from localhost ([127.0.0.1]:53900 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kCqsA-0003MI-RM for submit@debbugs.gnu.org; Mon, 31 Aug 2020 16:57:51 -0400 Received: from mail-wm1-f51.google.com ([209.85.128.51]:51054) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kCqs8-0003M2-7z for 43117@debbugs.gnu.org; Mon, 31 Aug 2020 16:57:50 -0400 Received: by mail-wm1-f51.google.com with SMTP id e17so773160wme.0 for <43117@debbugs.gnu.org>; Mon, 31 Aug 2020 13:57:48 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:references:date:in-reply-to:message-id :mime-version:content-transfer-encoding; bh=jXXHKMscQfEROESOQLyf3ZF4AFfrgqDlkKjIJ73Ka9g=; b=Z+rHMmTkWdAoQ9nPsUy4Cm96HpwFOT9mYva9oCk+U/ftgQxmho5FVp8mLKKHCZDuG2 tnYrgHKmb1r044qp2RaE37AflbrmE10Oio0blTkr9uWO2Cl391lHww0MlC6KMGz5AcDk Lv7Q07qm/bZu2DtHOZHWzG+dTS+bzfUzFfNKIgsuKqkSuQs8+9LPQMA3yR4V2FGWpECL oPpshWrvB6IkcQTdBgAc7BjztRKPHXh8/uChBP/waNvCSO6EeOQCjmdGgyJS5XU5E36T GMA/LgXvOh8H2BrH21PAKFZbaYCVo69UIkG69MSdOeJveGK38Ddb+TXmqX6i+S84ngEY uPqQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:references:date:in-reply-to :message-id:mime-version:content-transfer-encoding; bh=jXXHKMscQfEROESOQLyf3ZF4AFfrgqDlkKjIJ73Ka9g=; b=sSonpRO/7zvMlGatbkBH9rwZahw0ZztmHmGNgE0zc/5G61wB30QDLdQjAVMvMON/af +XL8QeIIzo99AVb7C9KX0plEPlI6W4basj0BVvTKOOzh7rWk0vGzU/pm45ZZL+MO+jQy +ZGiNTA2ioOqu/leAnQRmDnWiu/VyPUNl73d7aJh+LH5pZyAaXj4QeBm/fLwJYRV/fgt BV9fZWVK8lhluQVIK02OzRBXW4wbd10a9Knp1nDgiQKh6p/Ak4WQo+Y0e/6flP9V+APY wUEaGzJpcgipD5kxMJpQBvdCFlnO6IHge/vWYnDMhYw3kzFFGfBRsiImtTWFKzulDiqU kbFw== X-Gm-Message-State: AOAM533DuFYph+pEZ8y73UW8wA4Mc3DyOIthI7Uw9LDvp1PZLwlTfNEf lT2O2jpp2U1OB+IvxE78LhMMe0/AV93UUA== X-Google-Smtp-Source: ABdhPJznE8uy5PpVzCp6FZ9Vw8NbSf0TQYG3P2CXBAW3wGfN17lq8vXoIyOxsjGlEDM611PV0xyStQ== X-Received: by 2002:a7b:c00c:: with SMTP id c12mr1107608wmb.54.1598907461897; Mon, 31 Aug 2020 13:57:41 -0700 (PDT) Received: from rpluim-mac ([2a01:e34:ecfc:a860:4833:59bb:ac1c:3d8d]) by smtp.gmail.com with ESMTPSA id t13sm13523032wru.65.2020.08.31.13.57.40 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 31 Aug 2020 13:57:41 -0700 (PDT) From: Robert Pluim To: Dmitry Gutov Subject: Re: bug#43117: [PATCH] Add .git-blame-ignore-revs file References: <197409406.192953.1598809591346@ichabod.co-bxl> <9aa79095-18d6-d0bd-18ad-aa5d90f0bb1d@yandex.ru> Date: Mon, 31 Aug 2020 22:57:40 +0200 In-Reply-To: (Dmitry Gutov's message of "Mon, 31 Aug 2020 23:45:55 +0300") Message-ID: MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 43117 Cc: Brian Leung , 43117@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) >>>>> On Mon, 31 Aug 2020 23:45:55 +0300, Dmitry Gutov s= aid: Dmitry> On 31.08.2020 23:34, Robert Pluim wrote: Dmitry> On 31.08.2020 13:16, Robert Pluim wrote: >> >> You've configured emacs to replace TAB with SPC. Dmitry> That's what our .dir-locals.el does, doesn't it? >> Only for lines that you change. The patch has wholesale TAB->SPC >> replacement for lines which haven't otherwise been modified. Dmitry> Right. Dmitry> In that case, we should probably clarify that we don't usually Dmitry> whitespace-only changes far from the code that's being changes. Dmitry> Do we accept reindentation patches, though? Ones where the effe= ctive Dmitry> indentation does change. Didn=CA=BCt we just have this thread? :-) Pure re-indentation patches I thought were not acceptable unless accompanied by an actual code change near the re-indented lines. Robert From debbugs-submit-bounces@debbugs.gnu.org Mon Aug 31 17:03:33 2020 Received: (at 43117) by debbugs.gnu.org; 31 Aug 2020 21:03:33 +0000 Received: from localhost ([127.0.0.1]:53906 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kCqxh-0005i3-Et for submit@debbugs.gnu.org; Mon, 31 Aug 2020 17:03:33 -0400 Received: from mail-lf1-f53.google.com ([209.85.167.53]:45485) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kCqxe-0005hp-Jh for 43117@debbugs.gnu.org; Mon, 31 Aug 2020 17:03:32 -0400 Received: by mail-lf1-f53.google.com with SMTP id z17so4280997lfi.12 for <43117@debbugs.gnu.org>; Mon, 31 Aug 2020 14:03:30 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=sender:subject:to:cc:references:from:message-id:date:user-agent :mime-version:in-reply-to:content-language:content-transfer-encoding; bh=ZOLxYhS+RFu30L6kXWj91AoIfQv7LcUXzEq9ulpLobc=; b=YRUDtzf6k28JIRxx3SHoVDlSC6Q0V1s1J3PEr7hLpcUAo2oanviH0GPfv5ahUPRYHY 946dKM7GB+lC6p9LFeAODn8gtcPK1L3lJsf1u4pOYRJS1AjqKvNvkGvCerSeNCWG4Jjw 9CkOf9AQdeObF9+wd3Xaat33fsRaIAhKLWlu7Lx/ECkF/06zrPKvGmH2Pdv/s/hgKUi4 48YyGF6BK/bMJzVevlpyd9rjA5COGqr0Woz2qie/TLxRnXFoPm6Jl01FFiJ7YHqr2bWE NK+lXaI6tMJdr0K7UYEnThfyNEj9h2CnzTDJKCvuDjFodzArHXDGxK6Fkp7Xo39BnDEQ fdOA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:subject:to:cc:references:from:message-id :date:user-agent:mime-version:in-reply-to:content-language :content-transfer-encoding; bh=ZOLxYhS+RFu30L6kXWj91AoIfQv7LcUXzEq9ulpLobc=; b=cF2bSqAlkcJR3uMn22Dd8rwUVCtRTfEp0DHbXm3E2+GjHxI02ECop/38XJG7oTXu13 nvZI0iq4HXkiwhr9KaQgG1rj+5cVFVVUEM/5rdGaumWNx8pWtila5W3TPk5Vws0iWcFa XVq0F8o4D7cgm/HxeS52fj+YSPNJmSmwZuU+IUz4v8nfR9u89/ITxM/84xU6apNs6xIi FBoMxqP2U+BI4H2NZflF6l2WLWXqZQ5z+HtGZOcvCnjZQoP6FMp9W8WFnmyjVnlcmpDU nemVoBZ6w7rr0H0POvi24FZUVYfobdN5l39f6HgwGNLuwg9wWqHt8tyfqshaVrLyN/KF SH1g== X-Gm-Message-State: AOAM533ijSwaU/PjkFtt7dyhWuOYM0AVT465MBAzBJAGRfBlWeEPU6fO hs7kk5DHNtwpkMLpbnlWRCWfUt6c5khKcw== X-Google-Smtp-Source: ABdhPJyLNWHIJjMhaVIOObmjbYXQaQo7iG+hp3c2TCbIZoygnT5bVriTBg6Bc+kt5xn442AIat6NPA== X-Received: by 2002:a19:8142:: with SMTP id c63mr173529lfd.175.1598907804313; Mon, 31 Aug 2020 14:03:24 -0700 (PDT) Received: from [192.168.0.104] ([94.229.108.16]) by smtp.googlemail.com with ESMTPSA id v7sm2237564lfg.49.2020.08.31.14.03.23 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Mon, 31 Aug 2020 14:03:23 -0700 (PDT) Subject: Re: bug#43117: [PATCH] Add .git-blame-ignore-revs file To: Robert Pluim References: <197409406.192953.1598809591346@ichabod.co-bxl> <9aa79095-18d6-d0bd-18ad-aa5d90f0bb1d@yandex.ru> From: Dmitry Gutov Message-ID: Date: Tue, 1 Sep 2020 00:03:23 +0300 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.10.0 MIME-Version: 1.0 In-Reply-To: Content-Type: text/plain; charset=utf-8; format=flowed Content-Language: en-US Content-Transfer-Encoding: 8bit X-Spam-Score: -1.9 (-) X-Debbugs-Envelope-To: 43117 Cc: Brian Leung , 43117@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -2.9 (--) On 31.08.2020 23:57, Robert Pluim wrote: > Dmitry> Do we accept reindentation patches, though? Ones where the effective > Dmitry> indentation does change. > > Didnʼt we just have this thread? :-) I might have missed it. :-( > Pure re-indentation patches I thought were not acceptable unless > accompanied by an actual code change near the re-indented lines. Okay. Brian, could you re-submit patches without extra re-indentation? From debbugs-submit-bounces@debbugs.gnu.org Sat Sep 12 20:42:40 2020 Received: (at 43117) by debbugs.gnu.org; 13 Sep 2020 00:42:40 +0000 Received: from localhost ([127.0.0.1]:49193 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kHG6K-00025u-2P for submit@debbugs.gnu.org; Sat, 12 Sep 2020 20:42:40 -0400 Received: from wilbur.contactoffice.com ([212.3.242.68]:33216) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kHG6H-00025f-HX for 43117@debbugs.gnu.org; Sat, 12 Sep 2020 20:42:38 -0400 Received: from ichabod.co-bxl (ichabod.co-bxl [10.2.0.36]) by wilbur.contactoffice.com (Postfix) with ESMTP id C55F67D1; Sun, 13 Sep 2020 02:42:30 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=mailfence.com; s=20160819-nLV10XS2; t=1599957750; bh=hp8hAd6qB+V+TriwzJh69e8jlWyA4JksHuS2YCHMMsg=; h=Date:From:Reply-To:To:Cc:In-Reply-To:References:Subject:From; b=Aq3LwRaDAauBhae9l+PRJdqOinXY86zzMMS4lm/bPs8IrWaf1/sO65e8Vc7GoNTaO G8ll3xnHbQNVn7TPL5EZNfavXyQsrkzY+UwfmYa4tlDfg4fcMeZ88j+ZMOt4NKNASO OfBN2QCDQSQFBJx8M2HXLJpLfjMiLCUQpsOn0jRTDxCzYWdJM2Xbr6IHkOy8ecBzJu x6a5A3a8tPSIC3DPW+tp3t7ATaGzUBM9QRSZI7esjEuo7IfCWCHarRHUo1duio97SD IO0PlzJfK1zLnDr8EXnm1DwhfwjjUABgEf95MQ8CFdZ6T4LKoIix/suGY3fNPD7u+h kZd1cexNHO/og== Date: Sun, 13 Sep 2020 02:42:23 +0200 (CEST) From: Brian Leung To: Dmitry Gutov , Robert Pluim Message-ID: <1898378843.430816.1599957743795@ichabod.co-bxl> In-Reply-To: References: <197409406.192953.1598809591346@ichabod.co-bxl> <9aa79095-18d6-d0bd-18ad-aa5d90f0bb1d@yandex.ru> Subject: Re: bug#43117: [PATCH] Add .git-blame-ignore-revs file MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="----=_Part_430784_1989196481.1599957637078" X-Priority: 3 X-Mailer: ContactOffice Mail X-ContactOffice-Account: com:225491745 X-Debbugs-Envelope-To: 43117 Cc: 43117@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: Brian Leung Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" ------=_Part_430784_1989196481.1599957637078 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable OK, please see attached. Right now there are no extraneous whitespace chang= es, and the only changes I've made change if -> when in the eshell files. > Pure re-indentation patches I thought were not acceptable unless > accompanied by an actual code change near the re-indented lines. With a .git-blame-ignore file of some sort, shouldn't this not be a hindran= ce? > ---------------------------------------- > From: Dmitry Gutov > Sent: Mon Aug 31 23:03:23 CEST 2020 > To: Robert Pluim > Cc: Brian Leung , <43117@debbugs.gnu.org> > Subject: Re: bug#43117: [PATCH] Add .git-blame-ignore-revs file >=20 >=20 > On 31.08.2020 23:57, Robert Pluim wrote: >=20 > > Dmitry> Do we accept reindentation patches, though? Ones where the= effective > > Dmitry> indentation does change. > >=20 > > Didn=CA=BCt we just have this thread? :-) >=20 > I might have missed it. :-( >=20 > > Pure re-indentation patches I thought were not acceptable unless > > accompanied by an actual code change near the re-indented lines. >=20 > Okay. >=20 > Brian, could you re-submit patches without extra re-indentation? --=C2=A0 Sent with https://mailfence.com Secure and private email ------=_Part_430784_1989196481.1599957637078 Content-Type: text/x-diff; charset=us-ascii; name=0001-eshell-Replace-single-clause-if-statements-with-when.patch Content-Transfer-Encoding: 7bit Content-Description: File Attachment: 0001-eshell-Replace-single-clause-if-statements-with-when.patch Content-Disposition: attachment; filename=0001-eshell-Replace-single-clause-if-statements-with-when.patch >From b535e0b426c2cc7b32c98304de76fbc9df0b17cf Mon Sep 17 00:00:00 2001 From: Brian Leung Date: Mon, 31 Aug 2020 20:31:58 -0700 Subject: [PATCH 1/2] eshell: Replace single-clause if statements with whens * lisp/eshell/em-alias.el: if -> when where appropriate. * lisp/eshell/em-basic.el: Same. * lisp/eshell/em-cmpl.el: Same. * lisp/eshell/em-dirs.el: Same. * lisp/eshell/em-glob.el: Same. * lisp/eshell/em-hist.el: Same. * lisp/eshell/em-ls.el: Same. * lisp/eshell/em-pred.el: Same. * lisp/eshell/em-prompt.el: Same. * lisp/eshell/em-rebind.el: Same. * lisp/eshell/em-script.el: Same. * lisp/eshell/em-smart.el: Same. * lisp/eshell/em-term.el: Same. * lisp/eshell/em-tramp.el: Same. * lisp/eshell/em-unix.el: Same. * lisp/eshell/esh-arg.el: Same. * lisp/eshell/esh-cmd.el: Same. * lisp/eshell/eshell.el: Same. * lisp/eshell/esh-ext.el: Same. * lisp/eshell/esh-io.el: Same. * lisp/eshell/esh-mode.el: Same. * lisp/eshell/esh-module.el: Same. * lisp/eshell/esh-opt.el: Same. * lisp/eshell/esh-proc.el: Same. * lisp/eshell/esh-util.el: Same. * lisp/eshell/esh-var.el: Same. --- lisp/eshell/em-alias.el | 46 ++--- lisp/eshell/em-basic.el | 4 +- lisp/eshell/em-cmpl.el | 78 ++++----- lisp/eshell/em-dirs.el | 82 ++++----- lisp/eshell/em-glob.el | 52 +++--- lisp/eshell/em-hist.el | 120 ++++++------- lisp/eshell/em-ls.el | 214 +++++++++++------------ lisp/eshell/em-pred.el | 80 ++++----- lisp/eshell/em-prompt.el | 14 +- lisp/eshell/em-rebind.el | 6 +- lisp/eshell/em-script.el | 4 +- lisp/eshell/em-smart.el | 42 ++--- lisp/eshell/em-term.el | 18 +- lisp/eshell/em-tramp.el | 4 +- lisp/eshell/em-unix.el | 194 ++++++++++----------- lisp/eshell/esh-arg.el | 66 +++---- lisp/eshell/esh-cmd.el | 350 +++++++++++++++++++------------------- lisp/eshell/esh-ext.el | 56 +++--- lisp/eshell/esh-io.el | 82 ++++----- lisp/eshell/esh-mode.el | 175 ++++++++++--------- lisp/eshell/esh-module.el | 10 +- lisp/eshell/esh-opt.el | 14 +- lisp/eshell/esh-proc.el | 76 ++++----- lisp/eshell/esh-util.el | 170 +++++++++--------- lisp/eshell/esh-var.el | 86 +++++----- lisp/eshell/eshell.el | 40 ++--- 26 files changed, 1041 insertions(+), 1042 deletions(-) diff --git a/lisp/eshell/em-alias.el b/lisp/eshell/em-alias.el index 67e0c3fc08..09669477d8 100644 --- a/lisp/eshell/em-alias.el +++ b/lisp/eshell/em-alias.el @@ -167,9 +167,9 @@ eshell/alias (let ((def (assoc alias eshell-command-aliases-list)) (alias-def (list alias (eshell-flatten-and-stringify definition)))) - (if def - (setq eshell-command-aliases-list - (delq def eshell-command-aliases-list))) + (when def + (setq eshell-command-aliases-list + (delq def eshell-command-aliases-list))) (setq eshell-command-aliases-list (cons alias-def eshell-command-aliases-list)))) (eshell-write-aliases-list)) @@ -191,22 +191,22 @@ eshell-read-aliases-list (let (eshell-command-aliases-list) (insert-file-contents file) (while (not (eobp)) - (if (re-search-forward - "^alias\\s-+\\(\\S-+\\)\\s-+\\(.+\\)") - (setq eshell-command-aliases-list - (cons (list (match-string 1) - (match-string 2)) - eshell-command-aliases-list))) + (when (re-search-forward + "^alias\\s-+\\(\\S-+\\)\\s-+\\(.+\\)") + (setq eshell-command-aliases-list + (cons (list (match-string 1) + (match-string 2)) + eshell-command-aliases-list))) (forward-line 1)) eshell-command-aliases-list)))))) (defun eshell-write-aliases-list () "Write out the current aliases into `eshell-aliases-file'." - (if (file-writable-p (file-name-directory eshell-aliases-file)) - (let ((eshell-current-handles - (eshell-create-handles eshell-aliases-file 'overwrite))) - (eshell/alias) - (eshell-close-handles 0)))) + (when (file-writable-p (file-name-directory eshell-aliases-file)) + (let ((eshell-current-handles + (eshell-create-handles eshell-aliases-file 'overwrite))) + (eshell/alias) + (eshell-close-handles 0)))) (defsubst eshell-lookup-alias (name) "Check whether NAME is aliased. Return the alias if there is one." @@ -219,21 +219,21 @@ eshell-maybe-replace-by-alias (unless (and eshell-prevent-alias-expansion (member command eshell-prevent-alias-expansion)) (let ((alias (eshell-lookup-alias command))) - (if alias - (throw 'eshell-replace-command - `(let ((eshell-command-name ',eshell-last-command-name) - (eshell-command-arguments ',eshell-last-arguments) - (eshell-prevent-alias-expansion - ',(cons command eshell-prevent-alias-expansion))) - ,(eshell-parse-command (nth 1 alias)))))))) + (when alias + (throw 'eshell-replace-command + `(let ((eshell-command-name ',eshell-last-command-name) + (eshell-command-arguments ',eshell-last-arguments) + (eshell-prevent-alias-expansion + ',(cons command eshell-prevent-alias-expansion))) + ,(eshell-parse-command (nth 1 alias)))))))) (defun eshell-alias-completions (name) "Find all possible completions for NAME. These are all the command aliases which begin with NAME." (let (completions) (dolist (alias eshell-command-aliases-list) - (if (string-match (concat "^" name) (car alias)) - (setq completions (cons (car alias) completions)))) + (when (string-match (concat "^" name) (car alias)) + (setq completions (cons (car alias) completions)))) completions)) (defun eshell-fix-bad-commands (name) diff --git a/lisp/eshell/em-basic.el b/lisp/eshell/em-basic.el index 6cfc89cce6..d3cbcb183f 100644 --- a/lisp/eshell/em-basic.el +++ b/lisp/eshell/em-basic.el @@ -92,8 +92,8 @@ eshell-echo (mapcar (function (lambda (arg) - (if (stringp arg) - (set-text-properties 0 (length arg) nil arg)) + (when (stringp arg) + (set-text-properties 0 (length arg) nil arg)) arg)) args))))) (if output-newline diff --git a/lisp/eshell/em-cmpl.el b/lisp/eshell/em-cmpl.el index 8a444c9100..69cefdda3a 100644 --- a/lisp/eshell/em-cmpl.el +++ b/lisp/eshell/em-cmpl.el @@ -285,9 +285,9 @@ eshell-cmpl-initialize eshell-cmpl-ignore-case) (set (make-local-variable 'pcomplete-autolist) eshell-cmpl-autolist) - (if (boundp 'pcomplete-suffix-list) - (set (make-local-variable 'pcomplete-suffix-list) - eshell-cmpl-suffix-list)) + (when (boundp 'pcomplete-suffix-list) + (set (make-local-variable 'pcomplete-suffix-list) + eshell-cmpl-suffix-list)) (set (make-local-variable 'pcomplete-recexact) eshell-cmpl-recexact) (set (make-local-variable 'pcomplete-man-function) @@ -348,29 +348,29 @@ eshell-complete-parse-arguments (when (memq this-command '(pcomplete-expand pcomplete-expand-and-complete)) (run-hook-with-args 'eshell-expand-input-functions begin end) - (if (= begin end) - (end-of-line)) + (when (= begin end) + (end-of-line)) (setq end (point-marker))) - (if (setq delim - (catch 'eshell-incomplete - (ignore - (setq args (eshell-parse-arguments begin end))))) - (cond ((memq (car delim) '(?\{ ?\<)) - (setq begin (1+ (cadr delim)) - args (eshell-parse-arguments begin end))) - ((eq (car delim) ?\() - (eshell-complete-lisp-symbol) - (throw 'pcompleted t)) - (t - (insert-and-inherit "\t") - (throw 'pcompleted t)))) + (when (setq delim + (catch 'eshell-incomplete + (ignore + (setq args (eshell-parse-arguments begin end))))) + (cond ((memq (car delim) '(?\{ ?\<)) + (setq begin (1+ (cadr delim)) + args (eshell-parse-arguments begin end))) + ((eq (car delim) ?\() + (eshell-complete-lisp-symbol) + (throw 'pcompleted t)) + (t + (insert-and-inherit "\t") + (throw 'pcompleted t)))) (when (get-text-property (1- end) 'comment) (insert-and-inherit "\t") (throw 'pcompleted t)) (let ((pos begin)) (while (< pos end) - (if (get-text-property pos 'arg-begin) - (nconc posns (list pos))) + (when (get-text-property pos 'arg-begin) + (nconc posns (list pos))) (setq pos (1+ pos)))) (setq posns (cdr posns)) (cl-assert (= (length args) (length posns))) @@ -378,9 +378,9 @@ eshell-complete-parse-arguments (i 0) l) (while a - (if (and (consp (car a)) - (eq (caar a) 'eshell-operator)) - (setq l i)) + (when (and (consp (car a)) + (eq (caar a) 'eshell-operator)) + (setq l i)) (setq a (cdr a) i (1+ i))) (and l (setq args (nthcdr (1+ l) args) @@ -401,8 +401,8 @@ eshell-complete-parse-arguments (cl-assert (eq (car result) 'quote)) (cadr result)) arg))) - (if (numberp val) - (setq val (number-to-string val))) + (when (numberp val) + (setq val (number-to-string val))) (or val "")))) args) posns))) @@ -414,11 +414,11 @@ eshell-complete-commands-list (if eshell-force-execution (pcomplete-dirs-or-entries nil #'file-readable-p) (pcomplete-executables)) - (if (and (> (length filename) 0) - (eq (aref filename 0) eshell-explicit-command-char)) - (setq filename (substring filename 1) - pcomplete-stub filename - glob-name t)) + (when (and (> (length filename) 0) + (eq (aref filename 0) eshell-explicit-command-char)) + (setq filename (substring filename 1) + pcomplete-stub filename + glob-name t)) (let* ((paths (eshell-get-path)) (cwd (file-name-as-directory (expand-file-name default-directory))) @@ -436,13 +436,13 @@ eshell-complete-commands-list (while comps-in-path (setq file (car comps-in-path) filepath (concat path file)) - (if (and (not (member file completions)) ; - (or (string-equal path cwd) - (not (file-directory-p filepath))) - (if eshell-force-execution - (file-readable-p filepath) - (file-executable-p filepath))) - (setq completions (cons file completions))) + (when (and (not (member file completions)) ; + (or (string-equal path cwd) + (not (file-directory-p filepath))) + (if eshell-force-execution + (file-readable-p filepath) + (file-executable-p filepath))) + (setq completions (cons file completions))) (setq comps-in-path (cdr comps-in-path))) (setq paths (cdr paths))) ;; Add aliases which are currently visible, and Lisp functions. @@ -450,8 +450,8 @@ eshell-complete-commands-list (if glob-name completions (setq completions - (append (if (fboundp 'eshell-alias-completions) - (eshell-alias-completions filename)) + (append (when (fboundp 'eshell-alias-completions) + (eshell-alias-completions filename)) (eshell-winnow-list (mapcar (function diff --git a/lisp/eshell/em-dirs.el b/lisp/eshell/em-dirs.el index 51df6fa1d5..d6a964c881 100644 --- a/lisp/eshell/em-dirs.el +++ b/lisp/eshell/em-dirs.el @@ -208,9 +208,9 @@ eshell-dirs-initialize (add-hook 'eshell-parse-argument-hook #'eshell-parse-user-reference nil t) - (if (eshell-under-windows-p) - (add-hook 'eshell-parse-argument-hook - #'eshell-parse-drive-letter nil t)) + (when (eshell-under-windows-p) + (add-hook 'eshell-parse-argument-hook + #'eshell-parse-drive-letter nil t)) (when (eshell-using-module 'eshell-cmpl) (add-hook 'pcomplete-try-first-hook @@ -219,8 +219,8 @@ eshell-dirs-initialize (make-local-variable 'eshell-dirstack) (make-local-variable 'eshell-last-dir-ring) - (if eshell-last-dir-ring-file-name - (eshell-read-last-dir-ring)) + (when eshell-last-dir-ring-file-name + (eshell-read-last-dir-ring)) (unless eshell-last-dir-ring (setq eshell-last-dir-ring (make-ring eshell-last-dir-ring-size))) @@ -231,16 +231,16 @@ eshell-dirs-initialize (defun eshell-save-some-last-dir () "Save the list-dir-ring for any open Eshell buffers." (dolist (buf (buffer-list)) - (if (buffer-live-p buf) - (with-current-buffer buf - (if (and eshell-mode + (when (buffer-live-p buf) + (with-current-buffer buf + (when (and eshell-mode eshell-ask-to-save-last-dir (or (eq eshell-ask-to-save-last-dir 'always) (y-or-n-p - (format-message - "Save last dir ring for Eshell buffer `%s'? " - (buffer-name buf))))) - (eshell-write-last-dir-ring)))))) + (format-message + "Save last dir ring for Eshell buffer `%s'? " + (buffer-name buf))))) + (eshell-write-last-dir-ring)))))) (defun eshell-lone-directory-p (file) "Test whether FILE is just a directory name, and not a command name." @@ -298,11 +298,11 @@ eshell/pwd "Change output from `pwd' to be cleaner." (let* ((path default-directory) (len (length path))) - (if (and (> len 1) - (eq (aref path (1- len)) ?/) - (not (and (eshell-under-windows-p) - (string-match "\\`[A-Za-z]:[\\/]\\'" path)))) - (setq path (substring path 0 (1- (length path))))) + (when (and (> len 1) + (eq (aref path (1- len)) ?/) + (not (and (eshell-under-windows-p) + (string-match "\\`[A-Za-z]:[\\/]\\'" path)))) + (setq path (substring path 0 (1- (length path))))) (funcall (or eshell-pwd-convert-function #'identity) path))) (defun eshell-expand-multiple-dots (filename) @@ -335,13 +335,13 @@ eshell-find-previous-directory (let ((index 0) (len (ring-length eshell-last-dir-ring)) oldpath) - (if (> (length regexp) 0) - (while (< index len) - (setq oldpath (ring-ref eshell-last-dir-ring index)) - (if (string-match regexp oldpath) - (setq index len) - (setq oldpath nil - index (1+ index))))) + (when (> (length regexp) 0) + (while (< index len) + (setq oldpath (ring-ref eshell-last-dir-ring index)) + (if (string-match regexp oldpath) + (setq index len) + (setq oldpath nil + index (1+ index))))) oldpath)) (defun eshell/cd (&rest args) ; all but first ignored @@ -351,10 +351,10 @@ eshell/cd (subpath (car (cdr args))) (case-fold-search (eshell-under-windows-p)) handled) - (if (numberp path) - (setq path (number-to-string path))) - (if (numberp subpath) - (setq subpath (number-to-string subpath))) + (when (numberp path) + (setq path (number-to-string path))) + (when (numberp subpath) + (setq subpath (number-to-string subpath))) (cond (subpath (let ((curdir (eshell/pwd))) @@ -375,8 +375,8 @@ eshell/cd (setq path oldpath) (let ((len (ring-length eshell-last-dir-ring)) (index 0)) - (if (= len 0) - (error "Directory ring empty")) + (when (= len 0) + (error "Directory ring empty")) (eshell-init-print-buffer) (while (< index len) (eshell-buffered-print @@ -408,13 +408,13 @@ eshell-add-to-dir-ring "Add PATH to the last-dir-ring, if applicable." (unless (and (not (ring-empty-p eshell-last-dir-ring)) (equal path (ring-ref eshell-last-dir-ring 0))) - (if eshell-last-dir-unique - (let ((index 0) - (len (ring-length eshell-last-dir-ring))) - (while (< index len) - (if (equal (ring-ref eshell-last-dir-ring index) path) - (ring-remove eshell-last-dir-ring index) - (setq index (1+ index)))))) + (when eshell-last-dir-unique + (let ((index 0) + (len (ring-length eshell-last-dir-ring))) + (while (< index len) + (if (equal (ring-ref eshell-last-dir-ring index) path) + (ring-remove eshell-last-dir-ring index) + (setq index (1+ index)))))) (ring-insert eshell-last-dir-ring path))) ;;; pushd [+n | dir] @@ -459,9 +459,9 @@ eshell/pushd ;; pushd (let ((old-wd (eshell/pwd))) (eshell/cd path) - (if (or (null eshell-pushd-dunique) - (not (member old-wd eshell-dirstack))) - (setq eshell-dirstack (cons old-wd eshell-dirstack))) + (when (or (null eshell-pushd-dunique) + (not (member old-wd eshell-dirstack))) + (setq eshell-dirstack (cons old-wd eshell-dirstack))) (eshell/dirs t))))) nil) @@ -546,7 +546,7 @@ eshell-read-last-dir-ring (defun eshell-write-last-dir-ring () "Write the buffer's `eshell-last-dir-ring' to a history file." (let* ((file eshell-last-dir-ring-file-name) - (resolved-file (if (stringp file) (file-truename file)))) + (resolved-file (when (stringp file) (file-truename file)))) (cond ((or (null file) (equal file "") diff --git a/lisp/eshell/em-glob.el b/lisp/eshell/em-glob.el index a32a6abe29..7d534d85f7 100644 --- a/lisp/eshell/em-glob.el +++ b/lisp/eshell/em-glob.el @@ -257,8 +257,8 @@ eshell-extended-glob (eshell-glob-entries (file-name-as-directory (car paths)) (cdr paths)) (eshell-glob-entries (file-name-as-directory ".") paths)) - (if message-shown - (message nil))) + (when message-shown + (message nil))) (or (and eshell-glob-matches (sort eshell-glob-matches #'string<)) (if eshell-error-if-no-glob (error "No matches found: %s" glob) @@ -286,8 +286,8 @@ eshell-glob-entries globs (cdr globs) glob (car globs) len (length glob))))) - (if (and recurse-p (not glob)) - (error "`**' cannot end a globbing pattern")) + (when (and recurse-p (not glob)) + (error "`**' cannot end a globbing pattern")) (let ((index 1)) (setq incl glob) (while (and (eq incl glob) @@ -300,12 +300,12 @@ eshell-glob-entries ;; can't use `directory-file-name' because it strips away text ;; properties in the string (let ((len (1- (length incl)))) - (if (eq (aref incl len) ?/) - (setq incl (substring incl 0 len))) + (when (eq (aref incl len) ?/) + (setq incl (substring incl 0 len))) (when excl (setq len (1- (length excl))) - (if (eq (aref excl len) ?/) - (setq excl (substring excl 0 len))))) + (when (eq (aref excl len) ?/) + (setq excl (substring excl 0 len))))) (setq incl (eshell-glob-regexp incl) excl (and excl (eshell-glob-regexp excl))) (if (or eshell-glob-include-dot-files @@ -322,28 +322,28 @@ eshell-glob-entries (message "Building file list...%d so far: %s" (length eshell-glob-matches) path) (setq message-shown t)) - (if (equal path "./") (setq path "")) + (when (equal path "./") (setq path "")) (while entries (setq name (car entries) len (length name) isdir (eq (aref name (1- len)) ?/)) - (if (let ((fname (directory-file-name name))) - (and (not (and excl (string-match excl fname))) - (string-match incl fname))) - (if (cdr globs) - (if isdir - (setq dirs (cons (concat path name) dirs))) - (setq eshell-glob-matches - (cons (concat path name) eshell-glob-matches)))) - (if (and recurse-p isdir - (or (> len 3) - (not (or (and (= len 2) (equal name "./")) - (and (= len 3) (equal name "../"))))) - (setq pathname (concat path name)) - (not (and (= recurse-p 2) - (file-symlink-p - (directory-file-name pathname))))) - (setq rdirs (cons pathname rdirs))) + (when (let ((fname (directory-file-name name))) + (and (not (and excl (string-match excl fname))) + (string-match incl fname))) + (if (cdr globs) + (when isdir + (setq dirs (cons (concat path name) dirs))) + (setq eshell-glob-matches + (cons (concat path name) eshell-glob-matches)))) + (when (and recurse-p isdir + (or (> len 3) + (not (or (and (= len 2) (equal name "./")) + (and (= len 3) (equal name "../"))))) + (setq pathname (concat path name)) + (not (and (= recurse-p 2) + (file-symlink-p + (directory-file-name pathname))))) + (setq rdirs (cons pathname rdirs))) (setq entries (cdr entries))) (setq dirs (nreverse dirs) rdirs (nreverse rdirs)) diff --git a/lisp/eshell/em-hist.el b/lisp/eshell/em-hist.el index 5cee1bad36..d089498f33 100644 --- a/lisp/eshell/em-hist.el +++ b/lisp/eshell/em-hist.el @@ -265,9 +265,9 @@ eshell-hist-initialize (add-hook 'isearch-mode-hook (function (lambda () - (if (>= (point) eshell-last-output-end) - (setq overriding-terminal-local-map - eshell-isearch-map)))) + (when (>= (point) eshell-last-output-end) + (setq overriding-terminal-local-map + eshell-isearch-map)))) nil t) (add-hook 'isearch-mode-end-hook (function @@ -296,8 +296,8 @@ eshell-hist-initialize (if (minibuffer-window-active-p (selected-window)) (set (make-local-variable 'eshell-save-history-on-exit) nil) (set (make-local-variable 'eshell-history-ring) nil) - (if eshell-history-file-name - (eshell-read-history nil t)) + (when eshell-history-file-name + (eshell-read-history nil t)) (add-hook 'eshell-exit-hook #'eshell-write-history nil t)) @@ -314,17 +314,17 @@ eshell-hist-initialize (defun eshell-save-some-history () "Save the history for any open Eshell buffers." (dolist (buf (buffer-list)) - (if (buffer-live-p buf) - (with-current-buffer buf - (if (and eshell-mode + (when (buffer-live-p buf) + (with-current-buffer buf + (when (and eshell-mode eshell-history-file-name eshell-save-history-on-exit (or (eq eshell-save-history-on-exit t) (y-or-n-p - (format-message - "Save input history for Eshell buffer `%s'? " - (buffer-name buf))))) - (eshell-write-history)))))) + (format-message + "Save input history for Eshell buffer `%s'? " + (buffer-name buf))))) + (eshell-write-history)))))) (defun eshell/history (&rest args) "List in help buffer the buffer's input history." @@ -389,12 +389,12 @@ eshell-add-input-to-history Input is entered into the input history ring, if the value of variable `eshell-input-filter' returns non-nil when called on the input." - (if (and (funcall eshell-input-filter input) - (or (null eshell-hist-ignoredups) - (not (ring-p eshell-history-ring)) - (ring-empty-p eshell-history-ring) - (not (string-equal (eshell-get-history 0) input)))) - (eshell-put-history input)) + (when (and (funcall eshell-input-filter input) + (or (null eshell-hist-ignoredups) + (not (ring-p eshell-history-ring)) + (ring-empty-p eshell-history-ring) + (not (string-equal (eshell-get-history 0) input)))) + (eshell-put-history input)) (setq eshell-save-history-index eshell-history-index) (setq eshell-history-index nil)) @@ -455,11 +455,11 @@ eshell-read-history (re-search-backward "^[ \t]*\\([^#\n].*\\)[ \t]*$" nil t)) (let ((history (match-string 1))) - (if (or (null ignore-dups) - (ring-empty-p ring) - (not (string-equal (ring-ref ring 0) history))) - (ring-insert-at-beginning - ring (subst-char-in-string ?\177 ?\n history)))) + (when (or (null ignore-dups) + (ring-empty-p ring) + (not (string-equal (ring-ref ring 0) history))) + (ring-insert-at-beginning + ring (subst-char-in-string ?\177 ?\n history)))) (setq count (1+ count)))) (setq eshell-history-ring ring eshell-history-index nil)))))) @@ -475,7 +475,7 @@ eshell-write-history See also `eshell-read-history'." (let* ((file (or filename eshell-history-file-name)) - (resolved-file (if (stringp file) (file-truename file)))) + (resolved-file (when (stringp file) (file-truename file)))) (cond ((or (null file) (equal file "") @@ -506,9 +506,9 @@ eshell-list-history (interactive) (let (prefix prelen) (save-excursion - (if (re-search-backward "!\\(.+\\)" (line-beginning-position) t) - (setq prefix (match-string 1) - prelen (length prefix)))) + (when (re-search-backward "!\\(.+\\)" (line-beginning-position) t) + (setq prefix (match-string 1) + prelen (length prefix)))) (if (or (not (ring-p eshell-history-ring)) (ring-empty-p eshell-history-ring)) (message "No history") @@ -519,10 +519,10 @@ eshell-list-history ;; We have to build up a list ourselves from the ring vector. (while (>= index 0) (let ((hist (eshell-get-history index))) - (if (or (not prefix) - (and (>= (length hist) prelen) - (string= (substring hist 0 prelen) prefix))) - (setq history (cons hist history)))) + (when (or (not prefix) + (and (>= (length hist) prelen) + (string= (substring hist 0 prelen) prefix))) + (setq history (cons hist history)))) (setq index (1- index))) ;; Change "completion" to "history reference" ;; to make the display accurate. @@ -564,13 +564,13 @@ eshell-hist-parse-arguments (save-excursion (goto-char begin) (while (< (point) end) - (if (get-text-property (point) 'arg-begin) - (nconc posb (list (point)))) - (if (get-text-property (point) 'arg-end) - (nconc pose - (list (if (= (1+ (point)) end) - (1+ (point)) - (point))))) + (when (get-text-property (point) 'arg-begin) + (nconc posb (list (point)))) + (when (get-text-property (point) 'arg-end) + (nconc pose + (list (if (= (1+ (point)) end) + (1+ (point)) + (point))))) (forward-char)) (setq posb (cdr posb) pose (cdr pose)) @@ -633,12 +633,12 @@ eshell-complete-history-reference ;; vector. (while (>= index 0) (let ((hist (eshell-get-history index))) - (if (and (>= (length hist) stublen) - (string= (substring hist 0 stublen) - pcomplete-stub) - (string-match "^\\([^:^$*% \t\n]+\\)" hist)) - (setq history (cons (match-string 1 hist) - history)))) + (when (and (>= (length hist) stublen) + (string= (substring hist 0 stublen) + pcomplete-stub) + (string-match "^\\([^:^$*% \t\n]+\\)" hist)) + (setq history (cons (match-string 1 hist) + history)))) (setq index (1- index))) (let ((fhist (list t))) ;; uniquify the list, but preserve the order @@ -740,11 +740,11 @@ eshell-hist-parse-word-designator (insert hist) (setq textargs (car (eshell-hist-parse-arguments here (point)))) (delete-region here (point)) - (if (string= nth "*") - (if mth - (error "Invalid history word designator `%s'" - reference) - (setq nth 1 mth "-$"))) + (when (string= nth "*") + (if mth + (error "Invalid history word designator `%s'" + reference) + (setq nth 1 mth "-$"))) (if (not mth) (if nth (setq mth nth) @@ -793,9 +793,9 @@ eshell-get-next-from-history (defun eshell-search-arg (arg) ;; First make sure there is a ring and that we are after the process ;; mark - (if (and eshell-hist-move-to-end - (< (point) eshell-last-output-end)) - (goto-char eshell-last-output-end)) + (when (and eshell-hist-move-to-end + (< (point) eshell-last-output-end)) + (goto-char eshell-last-output-end)) (cond ((or (null eshell-history-ring) (ring-empty-p eshell-history-ring)) (error "Empty input ring")) @@ -841,15 +841,15 @@ eshell-previous-matching-input-string "Return the string matching REGEXP ARG places along the input ring. Moves relative to `eshell-history-index'." (let* ((pos (eshell-previous-matching-input-string-position regexp arg))) - (if pos (eshell-get-history pos)))) + (when pos (eshell-get-history pos)))) (defun eshell-previous-matching-input-string-position (regexp arg &optional start) "Return the index matching REGEXP ARG places along the input ring. Moves relative to START, or `eshell-history-index'." - (if (or (not (ring-p eshell-history-ring)) - (ring-empty-p eshell-history-ring)) - (error "No history")) + (when (or (not (ring-p eshell-history-ring)) + (ring-empty-p eshell-history-ring)) + (error "No history")) (let* ((len (ring-length eshell-history-ring)) (motion (if (> arg 0) 1 -1)) (n (mod (- (or start (eshell-search-start arg)) motion) len)) @@ -870,8 +870,8 @@ eshell-previous-matching-input-string-position (setq arg (if (> arg 0) (1- arg) (1+ arg)))) ;; Now that we know which ring element to use, if we found it, ;; return that. - (if (string-match regexp (eshell-get-history n)) - n))) + (when (string-match regexp (eshell-get-history n)) + n))) (defun eshell-previous-matching-input (regexp arg) "Search backwards through input history for match for REGEXP. @@ -880,8 +880,8 @@ eshell-previous-matching-input If N is negative, find the next or Nth next match." (interactive (eshell-regexp-arg "Previous input matching (regexp): ")) (setq arg (eshell-search-arg arg)) - (if (> eshell-last-output-end (point)) - (error "Point not located after prompt")) + (when (> eshell-last-output-end (point)) + (error "Point not located after prompt")) (let ((pos (eshell-previous-matching-input-string-position regexp arg))) ;; Has a match been found? (if (null pos) diff --git a/lisp/eshell/em-ls.el b/lisp/eshell/em-ls.el index c1a022ee52..f9d4e91ca1 100644 --- a/lisp/eshell/em-ls.el +++ b/lisp/eshell/em-ls.el @@ -185,8 +185,8 @@ eshell-ls-clutter (defsubst eshell-ls-filetype-p (attrs type) "Test whether ATTRS specifies a file of type TYPE." - (if (file-attribute-modes attrs) - (eq (aref (file-attribute-modes attrs) 0) type))) + (when (file-attribute-modes attrs) + (eq (aref (file-attribute-modes attrs) 0) type))) (defmacro eshell-ls-applicable (attrs index func file) "Test whether, for ATTRS, the user can do what corresponds to INDEX. @@ -264,8 +264,8 @@ eshell-ls--insert-directory (if handler (funcall handler 'insert-directory file switches wildcard full-directory-p) - (if (stringp switches) - (setq switches (split-string switches))) + (when (stringp switches) + (setq switches (split-string switches))) (let (eshell-current-handles eshell-current-subjob-p font-lock-mode) @@ -274,10 +274,10 @@ eshell-ls--insert-directory (featurep 'font-lock)) (font-lock-mode -1) (setq font-lock-defaults nil) - (if (boundp 'font-lock-buffers) - (set 'font-lock-buffers - (delq (current-buffer) - (symbol-value 'font-lock-buffers))))) + (when (boundp 'font-lock-buffers) + (set 'font-lock-buffers + (delq (current-buffer) + (symbol-value 'font-lock-buffers))))) (require 'em-glob) (let* ((insert-func 'insert) (error-func 'insert) @@ -497,8 +497,8 @@ eshell-ls-file (funcall insert-func file "\n")) (let ((line (concat - (if show-size - (concat (eshell-ls-size-string attrs size-width) " ")) + (when show-size + (concat (eshell-ls-size-string attrs size-width) " ")) (format (if numeric-uid-gid "%s%4d %-8s %-8s " @@ -549,14 +549,14 @@ eshell-ls-dir (funcall error-func (format "%s: No such file or directory\n" dir)) (if dir-literal (eshell-ls-file dirinfo size-width) - (if insert-name - (funcall insert-func - (eshell-ls-decorated-name - (cons (concat - (if root-dir - (file-relative-name dir root-dir) - (expand-file-name dir))) - (cdr dirinfo))) ":\n")) + (when insert-name + (funcall insert-func + (eshell-ls-decorated-name + (cons (concat + (if root-dir + (file-relative-name dir root-dir) + (expand-file-name dir))) + (cdr dirinfo))) ":\n")) (let ((entries (eshell-directory-files-and-attributes dir nil (and (not (or show-all show-almost-all)) eshell-ls-exclude-hidden @@ -587,16 +587,16 @@ eshell-ls-dir (let ((total 0.0)) (setq size-width 0) (dolist (e entries) - (if (file-attribute-size (cdr e)) - (setq total (+ total (file-attribute-size (cdr e))) - size-width - (max size-width - (length (eshell-ls-printable-size - (file-attribute-size (cdr e)) - (not - ;; If we are under -l, count length - ;; of sizes in bytes, not in blocks. - (eq listing-style 'long-listing)))))))) + (when (file-attribute-size (cdr e)) + (setq total (+ total (file-attribute-size (cdr e))) + size-width + (max size-width + (length (eshell-ls-printable-size + (file-attribute-size (cdr e)) + (not + ;; If we are under -l, count length + ;; of sizes in bytes, not in blocks. + (eq listing-style 'long-listing)))))))) (funcall insert-func "total " (eshell-ls-printable-size total t) "\n"))) (let ((default-directory (expand-file-name dir))) @@ -677,8 +677,8 @@ eshell-ls-files (not (eq listing-style 'by-lines))) (memq listing-style '(long-listing single-column))) (dolist (file files) - (if file - (eshell-ls-file file size-width copy-fileinfo))) + (when file + (eshell-ls-file file size-width copy-fileinfo))) (let ((f files) last-f display-files @@ -704,8 +704,8 @@ eshell-ls-files (dolist (file files) (let* ((str (eshell-ls-printable-size (file-attribute-size (cdr file)) t)) (len (length str))) - (if (< len size-width) - (setq str (concat (make-string (- size-width len) ? ) str))) + (when (< len size-width) + (setq str (concat (make-string (- size-width len) ? ) str))) (setq file (eshell-ls-annotate file) display-files (cons (cons (concat str " " (car file)) (cdr file)) @@ -741,8 +741,8 @@ eshell-ls-files col-index (1+ col-index)) (funcall insert-func need-return name "\n") (setq col-index 1 need-return nil)))) - (if need-return - (funcall insert-func need-return "\n")))))) + (when need-return + (funcall insert-func need-return "\n")))))) (defun eshell-ls-entries (entries &optional separate root-dir) "Output PATH's directory ENTRIES. @@ -765,17 +765,17 @@ eshell-ls-entries (unless separate (setq files (cons entry files) size-width - (if show-size - (max size-width - (length (eshell-ls-printable-size - (file-attribute-size (cdr entry)) t)))))) + (when show-size + (max size-width + (length (eshell-ls-printable-size + (file-attribute-size (cdr entry)) t)))))) (setq dirs (cons entry dirs))) (setq files (cons entry files) size-width - (if show-size - (max size-width - (length (eshell-ls-printable-size - (file-attribute-size (cdr entry)) t))))))) + (when show-size + (max size-width + (length (eshell-ls-printable-size + (file-attribute-size (cdr entry)) t))))))) (when files (eshell-ls-files (eshell-ls-sort-entries files) size-width show-recursive) @@ -783,8 +783,8 @@ eshell-ls-entries (setq show-names (or show-recursive (> (+ (length files) (length dirs)) 1))) (dolist (dir (eshell-ls-sort-entries dirs)) - (if (and need-return (not dir-literal)) - (funcall insert-func "\n")) + (when (and need-return (not dir-literal)) + (funcall insert-func "\n")) (eshell-ls-dir dir show-names (unless (file-name-absolute-p (car dir)) root-dir) size-width) @@ -821,18 +821,18 @@ eshell-ls-find-column-widths (colw (make-vector numcols 0)) (w widths)) (while w - (if (= i numcols) - (setq i 0)) + (when (= i numcols) + (setq i 0)) (aset colw i (max (aref colw i) (car w))) (setq w (cdr w) i (1+ i))) (setq i 0 width 0) (while (< i numcols) (setq width (+ width (aref colw i)) i (1+ i))) - (if (and (< width max-width) - (> width best-width)) - (setq col-widths colw - best-width width))) + (when (and (< width max-width) + (> width best-width)) + (setq col-widths colw + best-width width))) (setq numcols (1- numcols))) (cons (or col-widths (vector max-width)) files))) @@ -868,8 +868,8 @@ eshell-ls-find-column-lengths (float (1- numcols)))) (setq colw (make-vector numcols 0)) (while (> len 0) - (if (= i numcols) - (setq i 0 index (1+ index))) + (when (= i numcols) + (setq i 0 index (1+ index))) (aset colw i (max (aref colw i) (or (nth (+ (* i rows) index) w) 0))) @@ -880,8 +880,8 @@ eshell-ls-find-column-lengths i (1+ i)))) (if (>= width max-width) (setq numcols nil) - (if colw - (setq col-widths colw)) + (when colw + (setq col-widths colw)) (if (>= numcols (length widths)) (setq numcols nil) (setq numcols (1+ numcols)))))) @@ -897,8 +897,8 @@ eshell-ls-find-column-lengths (i 0) (j 0)) (while (< j len) - (if (= i numcols) - (setq i 0 index (1+ index))) + (when (= i numcols) + (setq i 0 index (1+ index))) (setcar (nthcdr j newfiles) (nth (+ (* i rows) index) files)) (setq j (1+ j) i (1+ i))) @@ -906,57 +906,57 @@ eshell-ls-find-column-lengths (defun eshell-ls-decorated-name (file) "Return FILE, possibly decorated." - (if eshell-ls-use-colors - (let ((face - (cond - ((not (cdr file)) - 'eshell-ls-missing) - - ((stringp (cadr file)) - 'eshell-ls-symlink) - - ((eq (cadr file) t) - 'eshell-ls-directory) - - ((not (eshell-ls-filetype-p (cdr file) ?-)) - 'eshell-ls-special) - - ((and (/= (user-uid) 0) ; root can execute anything - (eshell-ls-applicable (cdr file) 3 - 'file-executable-p (car file))) - 'eshell-ls-executable) - - ((not (eshell-ls-applicable (cdr file) 1 - 'file-readable-p (car file))) - 'eshell-ls-unreadable) - - ((string-match eshell-ls-archive-regexp (car file)) - 'eshell-ls-archive) - - ((string-match eshell-ls-backup-regexp (car file)) - 'eshell-ls-backup) - - ((string-match eshell-ls-product-regexp (car file)) - 'eshell-ls-product) - - ((string-match eshell-ls-clutter-regexp (car file)) - 'eshell-ls-clutter) - - ((not (eshell-ls-applicable (cdr file) 2 - 'file-writable-p (car file))) - 'eshell-ls-readonly) - (eshell-ls-highlight-alist - (let ((tests eshell-ls-highlight-alist) - value) - (while tests - (if (funcall (caar tests) (car file) (cdr file)) - (setq value (cdar tests) tests nil) - (setq tests (cdr tests)))) - value))))) - (if face - (add-text-properties 0 (length (car file)) - (list 'font-lock-face face) - (car file))))) + (when eshell-ls-use-colors + (let ((face + (cond + ((not (cdr file)) + 'eshell-ls-missing) + + ((stringp (cadr file)) + 'eshell-ls-symlink) + + ((eq (cadr file) t) + 'eshell-ls-directory) + + ((not (eshell-ls-filetype-p (cdr file) ?-)) + 'eshell-ls-special) + + ((and (/= (user-uid) 0) ; root can execute anything + (eshell-ls-applicable (cdr file) 3 + 'file-executable-p (car file))) + 'eshell-ls-executable) + + ((not (eshell-ls-applicable (cdr file) 1 + 'file-readable-p (car file))) + 'eshell-ls-unreadable) + + ((string-match eshell-ls-archive-regexp (car file)) + 'eshell-ls-archive) + + ((string-match eshell-ls-backup-regexp (car file)) + 'eshell-ls-backup) + + ((string-match eshell-ls-product-regexp (car file)) + 'eshell-ls-product) + + ((string-match eshell-ls-clutter-regexp (car file)) + 'eshell-ls-clutter) + + ((not (eshell-ls-applicable (cdr file) 2 + 'file-writable-p (car file))) + 'eshell-ls-readonly) + (eshell-ls-highlight-alist + (let ((tests eshell-ls-highlight-alist) + value) + (while tests + (if (funcall (caar tests) (car file) (cdr file)) + (setq value (cdar tests) tests nil) + (setq tests (cdr tests)))) + value))))) + (when face + (add-text-properties 0 (length (car file)) + (list 'font-lock-face face) + (car file))))) (car file)) (defun eshell-ls-unload-function () diff --git a/lisp/eshell/em-pred.el b/lisp/eshell/em-pred.el index c26f654e27..6746c68c99 100644 --- a/lisp/eshell/em-pred.el +++ b/lisp/eshell/em-pred.el @@ -86,9 +86,9 @@ eshell-predicate-alist (?S . (eshell-pred-file-mode 2000)) ; setgid (?t . (eshell-pred-file-mode 1000)) ; sticky bit (?U . #'(lambda (file) ; owned by effective uid - (if (file-exists-p file) - (= (file-attribute-user-id (file-attributes file)) - (user-uid))))) + (when (file-exists-p file) + (= (file-attribute-user-id (file-attributes file)) + (user-uid))))) ;; (?G . #'(lambda (file) ; owned by effective gid ;; (if (file-exists-p file) ;; (= (file-attribute-user-id (file-attributes file)) @@ -266,9 +266,9 @@ eshell-pred-initialize (defun eshell-apply-modifiers (lst predicates modifiers) "Apply to LIST a series of PREDICATES and MODIFIERS." (let (stringified) - (if (stringp lst) - (setq lst (list lst) - stringified t)) + (when (stringp lst) + (setq lst (list lst) + stringified t)) (when (listp lst) (setq lst (eshell-winnow-list lst nil predicates)) (while modifiers @@ -371,12 +371,12 @@ eshell-parse-modifiers (defun eshell-add-pred-func (pred funcs negate follow) "Add the predicate function PRED to FUNCS." - (if negate - (setq pred `(lambda (file) - (not (funcall ,pred file))))) - (if follow - (setq pred `(lambda (file) - (funcall ,pred (file-truename file))))) + (when negate + (setq pred `(lambda (file) + (not (funcall ,pred file))))) + (when follow + (setq pred `(lambda (file) + (funcall ,pred (file-truename file))))) (cons pred funcs)) (defun eshell-pred-user-or-group (mod-char mod-type attr-index get-id-func) @@ -404,8 +404,8 @@ eshell-pred-user-or-group mod-type mod-char)) `(lambda (file) (let ((attrs (file-attributes file))) - (if attrs - (= (nth ,attr-index attrs) ,ugid)))))) + (when attrs + (= (nth ,attr-index attrs) ,ugid)))))) (defun eshell-pred-file-time (mod-char mod-type attr-index) "Return a predicate to test whether a file matches a certain time." @@ -450,11 +450,11 @@ eshell-pred-file-time (goto-char (1+ end))) `(lambda (file) (let ((attrs (file-attributes file))) - (if attrs - (,(cond ((eq qual ?-) #'time-less-p) - ((eq qual ?+) (lambda (a b) (time-less-p b a))) - (#'time-equal-p)) - ,when (nth ,attr-index attrs))))))) + (when attrs + (,(cond ((eq qual ?-) #'time-less-p) + ((eq qual ?+) (lambda (a b) (time-less-p b a))) + (#'time-equal-p)) + ,when (nth ,attr-index attrs))))))) (defun eshell-pred-file-type (type) "Return a test which tests that the file is of a certain TYPE. @@ -467,18 +467,18 @@ eshell-pred-file-type (setq type ?%))) `(lambda (file) (let ((attrs (eshell-file-attributes (directory-file-name file)))) - (if attrs - (memq (aref (file-attribute-modes attrs) 0) - ,(if (eq type ?%) - '(?b ?c) - (list 'quote (list type)))))))) + (when attrs + (memq (aref (file-attribute-modes attrs) 0) + ,(if (eq type ?%) + '(?b ?c) + (list 'quote (list type)))))))) (defsubst eshell-pred-file-mode (mode) "Return a test which tests that MODE pertains to the file." `(lambda (file) (let ((modes (file-modes file 'nofollow))) - (if modes - (logand ,mode modes))))) + (when modes + (logand ,mode modes))))) (defun eshell-pred-file-links () "Return a predicate to test whether a file has a given number of links." @@ -492,13 +492,13 @@ eshell-pred-file-links (goto-char (match-end 0)) `(lambda (file) (let ((attrs (eshell-file-attributes file))) - (if attrs - (,(if (eq qual ?-) - '< - (if (eq qual ?+) - '> - '=)) - (file-attribute-link-number attrs) ,amount)))))) + (when attrs + (,(if (eq qual ?-) + '< + (if (eq qual ?+) + '> + '=)) + (file-attribute-link-number attrs) ,amount)))))) (defun eshell-pred-file-size () "Return a predicate to test whether a file is of a given size." @@ -522,13 +522,13 @@ eshell-pred-file-size (goto-char (match-end 0)) `(lambda (file) (let ((attrs (eshell-file-attributes file))) - (if attrs - (,(if (eq qual ?-) - '< - (if (eq qual ?+) - '> - '=)) - (file-attribute-size attrs) ,amount)))))) + (when attrs + (,(if (eq qual ?-) + '< + (if (eq qual ?+) + '> + '=)) + (file-attribute-size attrs) ,amount)))))) (defun eshell-pred-substitute (&optional repeat) "Return a modifier function that will substitute matches." diff --git a/lisp/eshell/em-prompt.el b/lisp/eshell/em-prompt.el index 9ae5ae1281..37873cefc9 100644 --- a/lisp/eshell/em-prompt.el +++ b/lisp/eshell/em-prompt.el @@ -117,8 +117,8 @@ eshell-prompt-initialize (add-hook 'eshell-post-command-hook 'eshell-emit-prompt nil t) (make-local-variable 'eshell-prompt-regexp) - (if eshell-prompt-regexp - (set (make-local-variable 'paragraph-start) eshell-prompt-regexp)) + (when eshell-prompt-regexp + (set (make-local-variable 'paragraph-start) eshell-prompt-regexp)) (set (make-local-variable 'eshell-skip-prompt-function) 'eshell-skip-prompt) @@ -150,8 +150,8 @@ eshell-backward-matching-input (interactive (eshell-regexp-arg "Backward input matching (regexp): ")) (let* ((re (concat eshell-prompt-regexp ".*" regexp)) (pos (save-excursion (end-of-line (if (> arg 0) 0 1)) - (if (re-search-backward re nil t arg) - (point))))) + (when (re-search-backward re nil t arg) + (point))))) (if (null pos) (progn (message "Not found") (ding)) @@ -194,9 +194,9 @@ eshell-skip-prompt "Skip past the text matching regexp `eshell-prompt-regexp'. If this takes us past the end of the current line, don't skip at all." (let ((eol (line-end-position))) - (if (and (looking-at eshell-prompt-regexp) - (<= (match-end 0) eol)) - (goto-char (match-end 0))))) + (when (and (looking-at eshell-prompt-regexp) + (<= (match-end 0) eol)) + (goto-char (match-end 0))))) (provide 'em-prompt) diff --git a/lisp/eshell/em-rebind.el b/lisp/eshell/em-rebind.el index 7991c63177..3b5604f3d7 100644 --- a/lisp/eshell/em-rebind.el +++ b/lisp/eshell/em-rebind.el @@ -212,9 +212,9 @@ eshell-rebind-input-map (progn (use-local-map eshell-input-keymap) (goto-char begin) - (if (and eshell-error-if-move-away - (not (eq this-command 'kill-region))) - (beep))) + (when (and eshell-error-if-move-away + (not (eq this-command 'kill-region))) + (beep))) (use-local-map eshell-mode-map))))))) (defun eshell-setup-input-keymap () diff --git a/lisp/eshell/em-script.el b/lisp/eshell/em-script.el index 5c2f145f59..113c15971a 100644 --- a/lisp/eshell/em-script.el +++ b/lisp/eshell/em-script.el @@ -106,8 +106,8 @@ eshell-source-file (list 'eshell-command-arguments (list 'quote args))) (let ((cmd (eshell-parse-command (cons here (point))))) - (if subcommand-p - (setq cmd (list 'eshell-as-subcommand cmd))) + (when subcommand-p + (setq cmd (list 'eshell-as-subcommand cmd))) cmd)) (delete-region here (point)) (goto-char orig)))))) diff --git a/lisp/eshell/em-smart.el b/lisp/eshell/em-smart.el index f173c8db9c..226de22204 100644 --- a/lisp/eshell/em-smart.el +++ b/lisp/eshell/em-smart.el @@ -211,14 +211,14 @@ eshell-refresh-windows (function (lambda (wind) (with-current-buffer (window-buffer wind) - (if eshell-mode - (let (window-scroll-functions) ;;FIXME: Why? - (eshell-smart-scroll-window wind (window-start)) - (setq affected t)))))) + (when eshell-mode + (let (window-scroll-functions) ;;FIXME: Why? + (eshell-smart-scroll-window wind (window-start)) + (setq affected t)))))) 0 frame) - (if affected - (let (window-scroll-functions) ;;FIXME: Why? - (eshell-redisplay))))) + (when affected + (let (window-scroll-functions) ;;FIXME: Why? + (eshell-redisplay))))) (defun eshell-smart-display-setup () "Set the point to somewhere in the beginning of the last command." @@ -228,8 +228,8 @@ eshell-smart-display-setup ((eq eshell-where-to-jump 'after) (goto-char (next-single-property-change eshell-last-input-start 'arg-end)) - (if (= (point) (- eshell-last-input-end 2)) - (forward-char))) + (when (= (point) (- eshell-last-input-end 2)) + (forward-char))) ((eq eshell-where-to-jump 'end) (goto-char (1- eshell-last-input-end))) (t @@ -272,14 +272,14 @@ eshell-smart-redisplay (< (point) eshell-last-input-end) (set-window-start (selected-window) (line-beginning-position) t)) - (if (pos-visible-in-window-p (point-max)) - (save-excursion - (goto-char (point-max)) - (recenter -1) - (unless (pos-visible-in-window-p top-point) - (goto-char top-point) - (set-window-start (selected-window) - (line-beginning-position) t))))))) + (when (pos-visible-in-window-p (point-max)) + (save-excursion + (goto-char (point-max)) + (recenter -1) + (unless (pos-visible-in-window-p top-point) + (goto-char top-point) + (set-window-start (selected-window) + (line-beginning-position) t))))))) (defun eshell-smart-goto-end () "Like `end-of-buffer', but do not push a mark." @@ -315,16 +315,16 @@ eshell-smart-display-move (scroll-down)) (eshell-show-output)) (scroll-down) - (if (pos-visible-in-window-p eshell-last-input-end) - (eshell-show-output))))) + (when (pos-visible-in-window-p eshell-last-input-end) + (eshell-show-output))))) ((or (memq this-command eshell-smart-display-navigate-list) (and (eq this-command 'eshell-send-input) (not (and (>= (point) eshell-last-input-start) (< (point) eshell-last-input-end))))) (setq clear t) (goto-char (point-max))))) - (if clear - (remove-hook 'pre-command-hook 'eshell-smart-display-move t)))) + (when clear + (remove-hook 'pre-command-hook 'eshell-smart-display-move t)))) (provide 'em-smart) diff --git a/lisp/eshell/em-term.el b/lisp/eshell/em-term.el index f52b3cda73..d1c4e1af6b 100644 --- a/lisp/eshell/em-term.el +++ b/lisp/eshell/em-term.el @@ -188,8 +188,8 @@ eshell-exec-visual (set-process-sentinel proc #'eshell-term-sentinel) (error "Failed to invoke visual command"))) (term-char-mode) - (if eshell-escape-control-x - (term-set-escape-char ?\C-x)))) + (when eshell-escape-control-x + (term-set-escape-char ?\C-x)))) nil) ;; Process sentinels receive two arguments. @@ -203,13 +203,13 @@ eshell-term-sentinel (when (and proc-buf (buffer-live-p proc-buf) (not (eq 'run (process-status proc))) (= (process-exit-status proc) 0)) - (if (eq (current-buffer) proc-buf) - (let ((buf (and (boundp 'eshell-parent-buffer) - eshell-parent-buffer - (buffer-live-p eshell-parent-buffer) - eshell-parent-buffer))) - (if buf - (switch-to-buffer buf)))) + (when (eq (current-buffer) proc-buf) + (let ((buf (and (boundp 'eshell-parent-buffer) + eshell-parent-buffer + (buffer-live-p eshell-parent-buffer) + eshell-parent-buffer))) + (when buf + (switch-to-buffer buf)))) (kill-buffer proc-buf))))) ;; jww (1999-09-17): The code below will allow Eshell to send input diff --git a/lisp/eshell/em-tramp.el b/lisp/eshell/em-tramp.el index 01f7038e46..a2201ce86c 100644 --- a/lisp/eshell/em-tramp.el +++ b/lisp/eshell/em-tramp.el @@ -80,8 +80,8 @@ eshell/su (dolist (arg args) (if (string-equal arg "-") (setq login t) (setq user arg))) ;; `eshell-eval-using-options' does not handle "-". - (if (member "-" orig-args) (setq login t)) - (if login (setq dir "~/")) + (when (member "-" orig-args) (setq login t)) + (when login (setq dir "~/")) (if (and prefix (or (not (string-equal diff --git a/lisp/eshell/em-unix.el b/lisp/eshell/em-unix.el index fbd3cfbb6f..567ce097d8 100644 --- a/lisp/eshell/em-unix.el +++ b/lisp/eshell/em-unix.el @@ -199,14 +199,14 @@ eshell-remove-entries (while files (if (string-match "\\`\\.\\.?\\'" (file-name-nondirectory (car files))) - (if toplevel - (eshell-error "rm: cannot remove `.' or `..'\n")) + (when toplevel + (eshell-error "rm: cannot remove `.' or `..'\n")) (if (and (file-directory-p (car files)) (not (file-symlink-p (car files)))) (progn - (if em-verbose - (eshell-printn (format-message "rm: removing directory `%s'" - (car files)))) + (when em-verbose + (eshell-printn (format-message "rm: removing directory `%s'" + (car files)))) (unless (or em-preview (and em-interactive @@ -214,9 +214,9 @@ eshell-remove-entries (format-message "rm: remove directory `%s'? " (car files)))))) (eshell-funcalln 'delete-directory (car files) t t))) - (if em-verbose - (eshell-printn (format-message "rm: removing file `%s'" - (car files)))) + (when em-verbose + (eshell-printn (format-message "rm: removing file `%s'" + (car files)))) (unless (or em-preview (and em-interactive (not (y-or-n-p @@ -248,8 +248,8 @@ eshell/rm Remove (unlink) the FILE(s).") (unless em-interactive (setq em-interactive eshell-rm-interactive-query)) - (if (and force-removal em-interactive) - (setq em-interactive nil)) + (when (and force-removal em-interactive) + (setq em-interactive nil)) (while args (let ((entry (if (stringp (car args)) (directory-file-name (car args)) @@ -258,8 +258,8 @@ eshell/rm (car args))))) (cond ((bufferp entry) - (if em-verbose - (eshell-printn (format-message "rm: removing buffer `%s'" entry))) + (when em-verbose + (eshell-printn (format-message "rm: removing buffer `%s'" entry))) (unless (or em-preview (and em-interactive (not (y-or-n-p (format-message @@ -267,8 +267,8 @@ eshell/rm entry))))) (eshell-funcalln 'kill-buffer entry))) ((eshell-processp entry) - (if em-verbose - (eshell-printn (format-message "rm: killing process `%s'" entry))) + (when em-verbose + (eshell-printn (format-message "rm: killing process `%s'" entry))) (unless (or em-preview (and em-interactive (not (y-or-n-p (format-message @@ -276,9 +276,9 @@ eshell/rm entry))))) (eshell-funcalln 'kill-process entry))) ((symbolp entry) - (if em-verbose - (eshell-printn (format-message - "rm: uninterning symbol `%s'" entry))) + (when em-verbose + (eshell-printn (format-message + "rm: uninterning symbol `%s'" entry))) (unless (or em-preview (and em-interactive @@ -294,11 +294,11 @@ eshell/rm (not (file-symlink-p entry))) (if (or em-recursive eshell-rm-removes-directories) - (if (or em-preview - (not em-interactive) - (y-or-n-p - (format-message "rm: descend into directory `%s'? " - entry))) + (when (or em-preview + (not em-interactive) + (y-or-n-p + (format-message "rm: descend into directory `%s'? " + entry))) (eshell-remove-entries (list entry) t)) (eshell-error (format "rm: %s: is a directory\n" entry))) (eshell-remove-entries (list entry) t)))))) @@ -353,18 +353,18 @@ eshell-shuffle-files (is-dir (or (file-directory-p target) (and em-preview (not eshell-warn-dot-directories)))) attr) - (if (and (not em-preview) (not is-dir) - (> (length files) 1)) - (error "%s: when %s multiple files, last argument must be a directory" - command action)) + (when (and (not em-preview) (not is-dir) + (> (length files) 1)) + (error "%s: when %s multiple files, last argument must be a directory" + command action)) (while files (setcar files (directory-file-name (car files))) (cond ((string-match "\\`\\.\\.?\\'" (file-name-nondirectory (car files))) - (if eshell-warn-dot-directories - (eshell-error (format "%s: %s: omitting directory\n" - command (car files))))) + (when eshell-warn-dot-directories + (eshell-error (format "%s: %s: omitting directory\n" + command (car files))))) ((and attr-target (or (not (eshell-under-windows-p)) (eq system-type 'ms-dos)) @@ -410,10 +410,10 @@ eshell-shuffle-files (expand-file-name target))))))) (apply 'eshell-funcalln func source target args) (unless (file-directory-p target) - (if em-verbose - (eshell-printn - (format "%s: making directory %s" - command target))) + (when em-verbose + (eshell-printn + (format "%s: making directory %s" + command target))) (unless em-preview (eshell-funcalln 'make-directory target))) (apply 'eshell-shuffle-files @@ -425,15 +425,15 @@ eshell-shuffle-files (directory-files source)) target func t args) (when (eq func 'rename-file) - (if em-verbose - (eshell-printn - (format "%s: deleting directory %s" - command source))) + (when em-verbose + (eshell-printn + (format "%s: deleting directory %s" + command source))) (unless em-preview (eshell-funcalln 'delete-directory source)))))) - (if em-verbose - (eshell-printn (format "%s: %s -> %s" command - source target))) + (when em-verbose + (eshell-printn (format "%s: %s -> %s" command + source target))) (unless em-preview (if (and no-dereference (setq link (file-symlink-p source))) @@ -459,10 +459,10 @@ eshell-shorthand-tar-command (if (file-exists-p archive) (setq tar-args (concat "u" tar-args)) (setq tar-args (concat "c" tar-args))) - (if em-verbose - (setq tar-args (concat "v" tar-args))) - (if (equal command "mv") - (setq tar-args (concat "--remove-files -" tar-args))) + (when em-verbose + (setq tar-args (concat "v" tar-args))) + (when (equal command "mv") + (setq tar-args (concat "--remove-files -" tar-args))) ;; truncate the archive name from the arguments (setcdr (last args 2) nil) (throw 'eshell-replace-command @@ -473,11 +473,11 @@ eshell-shorthand-tar-command (defmacro eshell-mvcpln-template (command action func query-var force-var &optional preserve) `(let ((len (length args))) - (if (or (= len 0) - (and (= len 1) (null eshell-default-target-is-dot))) - (error "%s: missing destination file or directory" ,command)) - (if (= len 1) - (nconc args '("."))) + (when (or (= len 0) + (and (= len 1) (null eshell-default-target-is-dot))) + (error "%s: missing destination file or directory" ,command)) + (when (= len 1) + (nconc args '("."))) (setq args (eshell-stringify-list (flatten-tree args))) (if (and ,(not (equal command "ln")) (string-match eshell-tar-regexp (car (last args))) @@ -495,8 +495,8 @@ eshell-mvcpln-template ,query-var) (not force)) 1 (or force ,force-var))) - (if preserve - (list preserve))))) + (when preserve + (list preserve))))) nil))) (defun eshell/mv (&rest args) @@ -556,8 +556,8 @@ eshell/cp :usage "[OPTION]... SOURCE DEST or: cp [OPTION]... SOURCE... DIRECTORY Copy SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY.") - (if archive - (setq preserve t no-dereference t em-recursive t)) + (when archive + (setq preserve t no-dereference t em-recursive t)) (eshell-mvcpln-template "cp" "copying" 'copy-file eshell-cp-interactive-query eshell-cp-overwrite-files preserve))) @@ -630,9 +630,9 @@ eshell/cat :usage "[OPTION] FILE... Concatenate FILE(s), or standard input, to standard output.") (dolist (file args) - (if (string= file "-") - (throw 'eshell-external - (eshell-external-command "cat" args)))) + (when (string= file "-") + (throw 'eshell-external + (eshell-external-command "cat" args)))) (let ((curbuf (current-buffer))) (dolist (file args) (with-temp-buffer @@ -705,19 +705,19 @@ eshell-poor-mans-grep (inhibit-redisplay t) string) (when (car args) - (if (get-buffer "*Occur*") - (kill-buffer (get-buffer "*Occur*"))) + (when (get-buffer "*Occur*") + (kill-buffer (get-buffer "*Occur*"))) (setq string nil) (while files (with-current-buffer (find-file-noselect (car files)) (save-excursion (ignore-errors (occur (car args)))) - (if (get-buffer "*Occur*") - (with-current-buffer (get-buffer "*Occur*") - (setq string (buffer-string)) - (kill-buffer (current-buffer))))) - (if string (insert string)) + (when (get-buffer "*Occur*") + (with-current-buffer (get-buffer "*Occur*") + (setq string (buffer-string)) + (kill-buffer (current-buffer))))) + (when string (insert string)) (setq string nil files (cdr files))))) (local-set-key [mouse-2] 'eshell-occur-mode-mouse-goto) @@ -831,8 +831,8 @@ show-all (defsubst eshell-du-size-string (size) (let* ((str (eshell-printable-size size human-readable block-size t)) (len (length str))) - (concat str (if (< len 8) - (make-string (- 8 len) ? ))))) + (concat str (when (< len 8) + (make-string (- 8 len) ? ))))) (defun eshell-du-sum-directory (path depth) "Summarize PATH, and its member directories." @@ -848,8 +848,8 @@ eshell-du-sum-directory (and only-one-filesystem (/= only-one-filesystem (file-attribute-device-number (cdar entries))))) - (if symlink - (setq entry symlink)) + (when symlink + (setq entry symlink)) (setq size (+ size (if (eq t (car (cdar entries))) @@ -857,16 +857,16 @@ eshell-du-sum-directory (let ((file-size (file-attribute-size (cdar entries)))) (prog1 file-size - (if show-all - (eshell-print - (concat (eshell-du-size-string file-size) - entry "\n"))))))))))) + (when show-all + (eshell-print + (concat (eshell-du-size-string file-size) + entry "\n"))))))))))) (setq entries (cdr entries))) - (if (or (not max-depth) - (= depth max-depth) - (= depth 0)) - (eshell-print (concat (eshell-du-size-string size) - (directory-file-name path) "\n"))) + (when (or (not max-depth) + (= depth max-depth) + (= depth 0)) + (eshell-print (concat (eshell-du-size-string size) + (directory-file-name path) "\n"))) size)) (defun eshell/du (&rest args) @@ -878,9 +878,9 @@ eshell/du (if (and ext-du (not (catch 'have-ange-path (dolist (arg args) - (if (string-equal - (file-remote-p (expand-file-name arg) 'method) "ftp") - (throw 'have-ange-path t)))))) + (when (string-equal + (file-remote-p (expand-file-name arg) 'method) "ftp") + (throw 'have-ange-path t)))))) (throw 'eshell-replace-command (eshell-parse-command (eshell-quote-argument ext-du) args)) (eshell-eval-using-options @@ -916,23 +916,23 @@ eshell/du Summarize disk usage of each FILE, recursively for directories.") (unless by-bytes (setq block-size (or block-size 1024))) - (if (and max-depth (stringp max-depth)) - (setq max-depth (string-to-number max-depth))) + (when (and max-depth (stringp max-depth)) + (setq max-depth (string-to-number max-depth))) ;; filesystem support means nothing under Windows - (if (eshell-under-windows-p) - (setq only-one-filesystem nil)) + (when (eshell-under-windows-p) + (setq only-one-filesystem nil)) (let ((size 0.0)) (while args - (if only-one-filesystem - (setq only-one-filesystem - (file-attribute-device-number (eshell-file-attributes - (file-name-as-directory (car args)))))) + (when only-one-filesystem + (setq only-one-filesystem + (file-attribute-device-number (eshell-file-attributes + (file-name-as-directory (car args)))))) (setq size (+ size (eshell-du-sum-directory (directory-file-name (car args)) 0))) (setq args (cdr args))) - (if grand-total - (eshell-print (concat (eshell-du-size-string size) - "total\n")))))))) + (when grand-total + (eshell-print (concat (eshell-du-size-string size) + "total\n")))))))) (put 'eshell/du 'eshell-filename-arguments t) @@ -984,8 +984,8 @@ eshell-diff-window-config (defun eshell-diff-quit () "Restore the window configuration previous to diff'ing." (interactive) - (if eshell-diff-window-config - (set-window-configuration eshell-diff-window-config))) + (when eshell-diff-window-config + (set-window-configuration eshell-diff-window-config))) (defun nil-blank-string (string) "Return STRING, or nil if STRING contains only non-blank characters." @@ -1005,9 +1005,9 @@ eshell/diff (throw 'eshell-replace-command (eshell-parse-command "*diff" orig-args)) (setq args (copy-sequence orig-args)) - (if (< (length args) 2) - (throw 'eshell-replace-command - (eshell-parse-command "*diff" orig-args))) + (when (< (length args) 2) + (throw 'eshell-replace-command + (eshell-parse-command "*diff" orig-args))) (let ((old (car (last args 2))) (new (car (last args))) (config (current-window-configuration))) @@ -1032,8 +1032,8 @@ eshell/diff (set (make-local-variable 'eshell-diff-window-config) ,config) (local-set-key [?q] 'eshell-diff-quit) - (if (fboundp 'turn-on-font-lock-if-enabled) - (turn-on-font-lock-if-enabled)) + (when (fboundp 'turn-on-font-lock-if-enabled) + (turn-on-font-lock-if-enabled)) (goto-char (point-min)))))) (pop-to-buffer (current-buffer)))))) nil) diff --git a/lisp/eshell/esh-arg.el b/lisp/eshell/esh-arg.el index e7b07b4208..190ffd3a31 100644 --- a/lisp/eshell/esh-arg.el +++ b/lisp/eshell/esh-arg.el @@ -93,8 +93,8 @@ eshell-parse-argument-hook (eshell-arg-delimiter (match-end 0))) (goto-char (match-end 0)) (let ((str (match-string 0))) - (if (> (length str) 0) - (add-text-properties 0 (length str) '(number t) str)) + (when (> (length str) 0) + (add-text-properties 0 (length str) '(number t) str)) str)))) ;; parse any non-special characters, based on the current context @@ -113,8 +113,8 @@ eshell-parse-argument-hook eshell-outside-quote-regexp)) (goto-char (match-end 0)) (let ((str (match-string 0))) - (if str - (set-text-properties 0 (length str) nil str)) + (when str + (set-text-properties 0 (length str) nil str)) str)))) ;; whitespace or a comment is an argument delimiter @@ -125,9 +125,9 @@ eshell-parse-argument-hook (and (not eshell-current-argument) (looking-at "#\\([^<'].*\\|$\\)") (setq comment-p t))) - (if comment-p - (add-text-properties (match-beginning 0) (match-end 0) - '(comment t))) + (when comment-p + (add-text-properties (match-beginning 0) (match-end 0) + '(comment t))) (goto-char (match-end 0)) (eshell-finish-arg))))) @@ -181,8 +181,8 @@ eshell-insert-buffer-name (defsubst eshell-escape-arg (string) "Return STRING with the `escaped' property on it." - (if (stringp string) - (add-text-properties 0 (length string) '(escaped t) string)) + (when (stringp string) + (add-text-properties 0 (length string) '(escaped t) string)) string) (defun eshell-resolve-current-argument () @@ -207,8 +207,8 @@ eshell-resolve-current-argument (defun eshell-finish-arg (&optional argument) "Finish the current argument being processed." - (if argument - (setq eshell-current-argument argument)) + (when argument + (setq eshell-current-argument argument)) (throw 'eshell-arg-done t)) (defun eshell-quote-argument (string) @@ -239,19 +239,19 @@ eshell-parse-arguments (with-silent-modifications (remove-text-properties (point-min) (point-max) '(arg-begin nil arg-end nil)) - (if (setq - delim - (catch 'eshell-incomplete - (while (not (eobp)) - (let* ((here (point)) - (arg (eshell-parse-argument))) - (if (= (point) here) + (when (setq + delim + (catch 'eshell-incomplete + (while (not (eobp)) + (let* ((here (point)) + (arg (eshell-parse-argument))) + (when (= (point) here) (error "Failed to parse argument `%s'" (buffer-substring here (point-max)))) - (and arg (nconc args (list arg))))))) - (throw 'eshell-incomplete (if (listp delim) - delim - (list delim (point) (cdr args))))) + (and arg (nconc args (list arg))))))) + (throw 'eshell-incomplete (if (listp delim) + delim + (list delim (point) (cdr args))))) (cdr args)))))) (defun eshell-parse-argument () @@ -304,8 +304,8 @@ eshell-quote-backslash (let ((char (aref string index))) (if (eq char ?\\) (char-to-string char) - (if (memq char eshell-special-chars-outside-quoting) - (string ?\\ char))))) + (when (memq char eshell-special-chars-outside-quoting) + (string ?\\ char))))) (defun eshell-parse-backslash () "Parse a single backslash (\\) character and the character after. @@ -332,15 +332,15 @@ eshell-parse-backslash (defun eshell-parse-literal-quote () "Parse a literally quoted string. Nothing has special meaning!" - (if (eq (char-after) ?\') - (let ((end (eshell-find-delimiter ?\' ?\'))) - (if (not end) - (throw 'eshell-incomplete ?\') - (let ((string (buffer-substring-no-properties (1+ (point)) end))) - (goto-char (1+ end)) - (while (string-match "''" string) - (setq string (replace-match "'" t t string))) - (list 'eshell-escape-arg string)))))) + (when (eq (char-after) ?\') + (let ((end (eshell-find-delimiter ?\' ?\'))) + (if (not end) + (throw 'eshell-incomplete ?\') + (let ((string (buffer-substring-no-properties (1+ (point)) end))) + (goto-char (1+ end)) + (while (string-match "''" string) + (setq string (replace-match "'" t t string))) + (list 'eshell-escape-arg string)))))) (defun eshell-parse-double-quote () "Parse a double quoted string, which allows for variable interpolation." diff --git a/lisp/eshell/esh-cmd.el b/lisp/eshell/esh-cmd.el index e0348ba501..88dd6d768a 100644 --- a/lisp/eshell/esh-cmd.el +++ b/lisp/eshell/esh-cmd.el @@ -370,8 +370,8 @@ eshell-parse-command (eshell-separate-commands terms "[&;]" nil 'eshell--sep-terms)))) (let ((cmd commands)) (while cmd - (if (cdr cmd) - (setcar cmd `(eshell-commands ,(car cmd)))) + (when (cdr cmd) + (setcar cmd `(eshell-commands ,(car cmd)))) (setq cmd (cdr cmd)))) (if toplevel `(eshell-commands (progn @@ -394,38 +394,38 @@ eshell-debug-command (defun eshell-debug-show-parsed-args (terms) "Display parsed arguments in the debug buffer." (ignore - (if eshell-debug-command - (eshell-debug-command "parsed arguments" terms)))) + (when eshell-debug-command + (eshell-debug-command "parsed arguments" terms)))) (defun eshell-no-command-conversion (terms) "Don't convert the command argument." (ignore - (if (and (listp (car terms)) - (eq (caar terms) 'eshell-convert)) - (setcar terms (cadr (car terms)))))) + (when (and (listp (car terms)) + (eq (caar terms) 'eshell-convert)) + (setcar terms (cadr (car terms)))))) (defun eshell-subcommand-arg-values (terms) "Convert subcommand arguments {x} to ${x}, in order to take their values." (setq terms (cdr terms)) ; skip command argument (while terms - (if (and (listp (car terms)) - (eq (caar terms) 'eshell-as-subcommand)) - (setcar terms `(eshell-convert - (eshell-command-to-value ,(car terms))))) + (when (and (listp (car terms)) + (eq (caar terms) 'eshell-as-subcommand)) + (setcar terms `(eshell-convert + (eshell-command-to-value ,(car terms))))) (setq terms (cdr terms)))) (defun eshell-rewrite-sexp-command (terms) "Rewrite a sexp in initial position, such as `(+ 1 2)'." ;; this occurs when a Lisp expression is in first position - (if (and (listp (car terms)) - (eq (caar terms) 'eshell-command-to-value)) - (car (cdar terms)))) + (when (and (listp (car terms)) + (eq (caar terms) 'eshell-command-to-value)) + (car (cdar terms)))) (defun eshell-rewrite-initial-subcommand (terms) "Rewrite a subcommand in initial position, such as `{+ 1 2}'." - (if (and (listp (car terms)) - (eq (caar terms) 'eshell-as-subcommand)) - (car terms))) + (when (and (listp (car terms)) + (eq (caar terms) 'eshell-as-subcommand)) + (car terms))) (defun eshell-rewrite-named-command (terms) "If no other rewriting rule transforms TERMS, assume a named command." @@ -473,32 +473,32 @@ eshell-rewrite-for-command Because the implementation of `for' relies upon conditional evaluation of its argument (i.e., use of a Lisp special form), it must be implemented via rewriting, rather than as a function." - (if (and (equal (car terms) "for") - (equal (nth 2 terms) "in")) - (let ((body (car (last terms)))) - (setcdr (last terms 2) nil) - `(let ((for-items - (copy-tree - (append - ,@(mapcar - (lambda (elem) - (if (listp elem) - elem - `(list ,elem))) - (cdr (cddr terms)))))) - (eshell-command-body '(nil)) - (eshell-test-body '(nil))) - (while (car for-items) - (let ((,(intern (cadr terms)) (car for-items)) - (eshell--local-vars (cons ',(intern (cadr terms)) - eshell--local-vars))) - (eshell-protect - ,(eshell-invokify-arg body t))) - (setcar for-items (cadr for-items)) - (setcdr for-items (cddr for-items))) - (eshell-close-handles - eshell-last-command-status - (list 'quote eshell-last-command-result)))))) + (when (and (equal (car terms) "for") + (equal (nth 2 terms) "in")) + (let ((body (car (last terms)))) + (setcdr (last terms 2) nil) + `(let ((for-items + (copy-tree + (append + ,@(mapcar + (lambda (elem) + (if (listp elem) + elem + `(list ,elem))) + (cdr (cddr terms)))))) + (eshell-command-body '(nil)) + (eshell-test-body '(nil))) + (while (car for-items) + (let ((,(intern (cadr terms)) (car for-items)) + (eshell--local-vars (cons ',(intern (cadr terms)) + eshell--local-vars))) + (eshell-protect + ,(eshell-invokify-arg body t))) + (setcar for-items (cadr for-items)) + (setcdr for-items (cddr for-items))) + (eshell-close-handles + eshell-last-command-status + (list 'quote eshell-last-command-result)))))) (defun eshell-structure-basic-command (func names keyword test body &optional else) @@ -519,10 +519,10 @@ eshell-structure-basic-command ;; Otherwise, it can be a pair of strings; if the keyword ;; we're using matches the second member of that pair (a ;; list), we should reverse it. - (if (or (eq names nil) - (and (listp names) - (string= keyword (cadr names)))) - (setq test `(not ,test))) + (when (or (eq names nil) + (and (listp names) + (string= keyword (cadr names)))) + (setq test `(not ,test))) ;; finally, create the form that represents this structured ;; command @@ -538,30 +538,30 @@ eshell-rewrite-while-command Because the implementation of `while' relies upon conditional evaluation of its argument (i.e., use of a Lisp special form), it must be implemented via rewriting, rather than as a function." - (if (and (stringp (car terms)) - (member (car terms) '("while" "until"))) - (eshell-structure-basic-command - 'while '("while" "until") (car terms) - (eshell-invokify-arg (cadr terms) nil t) - `(eshell-protect - ,(eshell-invokify-arg (car (last terms)) t))))) + (when (and (stringp (car terms)) + (member (car terms) '("while" "until"))) + (eshell-structure-basic-command + 'while '("while" "until") (car terms) + (eshell-invokify-arg (cadr terms) nil t) + `(eshell-protect + ,(eshell-invokify-arg (car (last terms)) t))))) (defun eshell-rewrite-if-command (terms) "Rewrite an `if' command into its equivalent Eshell command form. Because the implementation of `if' relies upon conditional evaluation of its argument (i.e., use of a Lisp special form), it must be implemented via rewriting, rather than as a function." - (if (and (stringp (car terms)) - (member (car terms) '("if" "unless"))) - (eshell-structure-basic-command - 'if '("if" "unless") (car terms) - (eshell-invokify-arg (cadr terms) nil t) - `(eshell-protect - ,(eshell-invokify-arg (car (last terms (if (= (length terms) 4) 2))) - t)) - (if (= (length terms) 4) - `(eshell-protect - ,(eshell-invokify-arg (car (last terms)))) t)))) + (when (and (stringp (car terms)) + (member (car terms) '("if" "unless"))) + (eshell-structure-basic-command + 'if '("if" "unless") (car terms) + (eshell-invokify-arg (cadr terms) nil t) + `(eshell-protect + ,(eshell-invokify-arg (car (last terms (when (= (length terms) 4) 2))) + t)) + (if (= (length terms) 4) + `(eshell-protect + ,(eshell-invokify-arg (car (last terms)))) t)))) (defvar eshell-last-command-result) ;Defined in esh-io.el. @@ -621,35 +621,35 @@ eshell-parse-pipeline (defun eshell-parse-subcommand-argument () "Parse a subcommand argument of the form `{command}'." - (if (and (not eshell-current-argument) - (not eshell-current-quoted) - (eq (char-after) ?\{) - (or (= (point-max) (1+ (point))) - (not (eq (char-after (1+ (point))) ?\})))) - (let ((end (eshell-find-delimiter ?\{ ?\}))) - (if (not end) - (throw 'eshell-incomplete ?\{) - (when (eshell-arg-delimiter (1+ end)) - (prog1 - `(eshell-as-subcommand - ,(eshell-parse-command (cons (1+ (point)) end))) - (goto-char (1+ end)))))))) + (when (and (not eshell-current-argument) + (not eshell-current-quoted) + (eq (char-after) ?\{) + (or (= (point-max) (1+ (point))) + (not (eq (char-after (1+ (point))) ?\})))) + (let ((end (eshell-find-delimiter ?\{ ?\}))) + (if (not end) + (throw 'eshell-incomplete ?\{) + (when (eshell-arg-delimiter (1+ end)) + (prog1 + `(eshell-as-subcommand + ,(eshell-parse-command (cons (1+ (point)) end))) + (goto-char (1+ end)))))))) (defun eshell-parse-lisp-argument () "Parse a Lisp expression which is specified as an argument." - (if (and (not eshell-current-argument) - (not eshell-current-quoted) - (looking-at eshell-lisp-regexp)) - (let* ((here (point)) - (obj - (condition-case nil - (read (current-buffer)) - (end-of-file - (throw 'eshell-incomplete ?\())))) - (if (eshell-arg-delimiter) - `(eshell-command-to-value - (eshell-lisp-command (quote ,obj))) - (ignore (goto-char here)))))) + (when (and (not eshell-current-argument) + (not eshell-current-quoted) + (looking-at eshell-lisp-regexp)) + (let* ((here (point)) + (obj + (condition-case nil + (read (current-buffer)) + (end-of-file + (throw 'eshell-incomplete ?\())))) + (if (eshell-arg-delimiter) + `(eshell-command-to-value + (eshell-lisp-command (quote ,obj))) + (ignore (goto-char here)))))) (defun eshell-separate-commands (terms separator &optional reversed last-terms-sym) @@ -672,15 +672,15 @@ eshell-separate-commands sub-terms (list t))) (nconc sub-terms (list (car terms)))) (setq terms (cdr terms))) - (if (> (length sub-terms) 1) - (setq subchains (cons (cdr sub-terms) subchains))) + (when (> (length sub-terms) 1) + (setq subchains (cons (cdr sub-terms) subchains))) (if reversed (progn - (if last-terms-sym - (set last-terms-sym (reverse (cdr eshell-sep-terms)))) + (when last-terms-sym + (set last-terms-sym (reverse (cdr eshell-sep-terms)))) subchains) ; already reversed - (if last-terms-sym - (set last-terms-sym (cdr eshell-sep-terms))) + (when last-terms-sym + (set last-terms-sym (cdr eshell-sep-terms))) (nreverse subchains)))) ;;_* Command evaluation macros @@ -769,8 +769,8 @@ eshell-do-pipelines 'append nextproc) (setq tailproc (or tailproc nextproc)))) ,(let ((head (car pipeline))) - (if (memq (car head) '(let progn)) - (setq head (car (last head)))) + (when (memq (car head) '(let progn)) + (setq head (car (last head)))) (when (memq (car head) eshell-deferrable-commands) (ignore (setcar head @@ -798,8 +798,8 @@ eshell-do-pipelines-synchronously (eshell-set-output-handle ,eshell-error-handle 'append output-marker))) ,(let ((head (car pipeline))) - (if (memq (car head) '(let progn)) - (setq head (car (last head)))) + (when (memq (car head) '(let progn)) + (setq head (car (last head)))) ;; FIXME: is deferrable significant here? (when (memq (car head) eshell-deferrable-commands) (ignore @@ -879,10 +879,10 @@ eshell/eshell-debug (ignore (cond ((not args) - (if eshell-handle-errors - (eshell-print "errors\n")) - (if eshell-debug-command - (eshell-print "commands\n"))) + (when eshell-handle-errors + (eshell-print "errors\n")) + (when eshell-debug-command + (eshell-print "commands\n"))) ((member (car args) '("-h" "--help")) (eshell-print "usage: eshell-debug [kinds] @@ -908,17 +908,17 @@ pcomplete/eshell-mode/eshell-debug (defun eshell-invoke-directly (command) (let ((base (cadr (nth 2 (nth 2 (cadr command))))) name) - (if (and (eq (car base) 'eshell-trap-errors) - (eq (car (cadr base)) 'eshell-named-command)) - (setq name (cadr (cadr base)))) + (when (and (eq (car base) 'eshell-trap-errors) + (eq (car (cadr base)) 'eshell-named-command)) + (setq name (cadr (cadr base)))) (and name (stringp name) (not (member name eshell-complex-commands)) (catch 'simple (progn (dolist (pred eshell-complex-commands) - (if (and (functionp pred) - (funcall pred name)) - (throw 'simple nil))) + (when (and (functionp pred) + (funcall pred name)) + (throw 'simple nil))) t)) (fboundp (intern-soft (concat "eshell/" name)))))) @@ -931,8 +931,8 @@ eshell-eval-command (list `(let ((here (and (eobp) (point)))) ,(and input `(insert-and-inherit ,(concat input "\n"))) - (if here - (eshell-update-markers here)) + (when here + (eshell-update-markers here)) (eshell-do-eval ',command)))) (and eshell-debug-command (with-current-buffer (get-buffer-create "*eshell last cmd*") @@ -943,10 +943,10 @@ eshell-eval-command (eshell-resume-eval)))) ;; On systems that don't support async subprocesses, eshell-resume ;; can return t. Don't treat that as an error. - (if (listp delim) - (setq delim (car delim))) - (if (and delim (not (eq delim t))) - (error "Unmatched delimiter: %c" delim))))) + (when (listp delim) + (setq delim (car delim))) + (when (and delim (not (eq delim t))) + (error "Unmatched delimiter: %c" delim))))) (defun eshell-resume-command (proc status) "Resume the current command when a process ends." @@ -954,8 +954,8 @@ eshell-resume-command (unless (or (not (stringp status)) (string= "stopped" status) (string-match eshell-reset-signals status)) - (if (eq proc (eshell-interactive-process)) - (eshell-resume-eval))))) + (when (eq proc (eshell-interactive-process)) + (eshell-resume-eval))))) (defun eshell-resume-eval () "Destructively evaluate a form which may need to be deferred." @@ -1002,12 +1002,12 @@ eshell-do-eval (setq form (cadr (cadr form)))) ;; expand any macros directly into the form. This is done so that ;; we can modify any `let' forms to evaluate only once. - (if (macrop (car form)) - (let ((exp (eshell-copy-tree (macroexpand form)))) - (eshell-manipulate (format-message "expanding macro `%s'" - (symbol-name (car form))) - (setcar form (car exp)) - (setcdr form (cdr exp))))) + (when (macrop (car form)) + (let ((exp (eshell-copy-tree (macroexpand form)))) + (eshell-manipulate (format-message "expanding macro `%s'" + (symbol-name (car form))) + (setcar form (car exp)) + (setcdr form (cdr exp))))) (let ((args (cdr form))) (cond ((eq (car form) 'while) @@ -1053,19 +1053,19 @@ eshell-do-eval (setcar (cdr args) (eshell-do-eval (cadr args) synchronous-p)) (eval form)) ((eq (car form) 'let) - (if (not (eq (car (cadr args)) 'eshell-do-eval)) - (eshell-manipulate "evaluating let args" - (dolist (letarg (car args)) - (if (and (listp letarg) - (not (eq (cadr letarg) 'quote))) - (setcdr letarg - (list (eshell-do-eval - (cadr letarg) synchronous-p))))))) + (when (not (eq (car (cadr args)) 'eshell-do-eval)) + (eshell-manipulate "evaluating let args" + (dolist (letarg (car args)) + (when (and (listp letarg) + (not (eq (cadr letarg) 'quote))) + (setcdr letarg + (list (eshell-do-eval + (cadr letarg) synchronous-p))))))) (cl-progv (mapcar (lambda (binding) (if (consp binding) (car binding) binding)) (car args)) ;; These expressions should all be constants now. - (mapcar (lambda (binding) (if (consp binding) (eval (cadr binding)))) + (mapcar (lambda (binding) (when (consp binding) (eval (cadr binding)))) (car args)) (eshell-do-eval (macroexp-progn (cdr args)) synchronous-p))) ((memq (car form) '(catch condition-case unwind-protect)) @@ -1083,18 +1083,18 @@ eshell-do-eval (setcar args `(eshell-do-eval ',(car args) ,synchronous-p)))) (eval form)) ((eq (car form) 'setq) - (if (cddr args) (error "Unsupported form (setq X1 E1 X2 E2..)")) + (when (cddr args) (error "Unsupported form (setq X1 E1 X2 E2..)")) (eshell-manipulate "evaluating arguments to setq" (setcar (cdr args) (eshell-do-eval (cadr args) synchronous-p))) (list 'quote (eval form))) (t - (if (and args (not (memq (car form) '(run-hooks)))) - (eshell-manipulate - (format-message "evaluating arguments to `%s'" - (symbol-name (car form))) - (while args - (setcar args (eshell-do-eval (car args) synchronous-p)) - (setq args (cdr args))))) + (when (and args (not (memq (car form) '(run-hooks)))) + (eshell-manipulate + (format-message "evaluating arguments to `%s'" + (symbol-name (car form))) + (while args + (setcar args (eshell-do-eval (car args) synchronous-p)) + (setq args (cdr args))))) (cond ((eq (car form) 'progn) (car (last form))) @@ -1154,16 +1154,16 @@ eshell/which "Identify the COMMAND, and where it is located." (dolist (name (cons command names)) (let (program alias direct) - (if (eq (aref name 0) eshell-explicit-command-char) - (setq name (substring name 1) - direct t)) - (if (and (not direct) - (fboundp 'eshell-lookup-alias) - (setq alias - (eshell-lookup-alias name))) - (setq program - (concat name " is an alias, defined as \"" - (cadr alias) "\""))) + (when (eq (aref name 0) eshell-explicit-command-char) + (setq name (substring name 1) + direct t)) + (when (and (not direct) + (fboundp 'eshell-lookup-alias) + (setq alias + (eshell-lookup-alias name))) + (setq program + (concat name " is an alias, defined as \"" + (cadr alias) "\""))) (unless program (setq program (let* ((esym (eshell-find-alias-function name)) @@ -1190,12 +1190,12 @@ eshell-named-command eshell-last-command-name (eshell-stringify command)) (run-hook-with-args 'eshell-prepare-command-hook) (cl-assert (stringp eshell-last-command-name)) - (if eshell-last-command-name - (or (run-hook-with-args-until-success - 'eshell-named-command-hook eshell-last-command-name - eshell-last-arguments) - (eshell-plain-command eshell-last-command-name - eshell-last-arguments)))) + (when eshell-last-command-name + (or (run-hook-with-args-until-success + 'eshell-named-command-hook eshell-last-command-name + eshell-last-arguments) + (eshell-plain-command eshell-last-command-name + eshell-last-arguments)))) (defalias 'eshell-named-command* 'eshell-named-command) @@ -1210,14 +1210,14 @@ eshell-find-alias-function (string-match "\\`\\(em\\|esh\\)-\\([[:alnum:]]+\\)\\'" file)) (let ((module-sym (intern (concat "eshell-" (match-string 2 file))))) - (if (and (functionp sym) - (or (null module-sym) - (eshell-using-module module-sym) - (memq module-sym (eshell-subgroups 'eshell)))) - sym)) + (when (and (functionp sym) + (or (null module-sym) + (eshell-using-module module-sym) + (memq module-sym (eshell-subgroups 'eshell)))) + sym)) ;; Otherwise, if it's bound, return it. - (if (functionp sym) - sym)))) + (when (functionp sym) + sym)))) (defun eshell-plain-command (command args) "Insert output from a plain COMMAND, using ARGS. @@ -1247,11 +1247,11 @@ eshell-exec-lisp (error (setq eshell-last-command-status 1) (let ((msg (error-message-string err))) - (if (and (not form-p) - (string-match "^Wrong number of arguments" msg) - (fboundp 'eldoc-get-fnsym-args-string)) - (let ((func-doc (eldoc-get-fnsym-args-string func-or-form))) - (setq msg (format "usage: %s" func-doc)))) + (when (and (not form-p) + (string-match "^Wrong number of arguments" msg) + (fboundp 'eldoc-get-fnsym-args-string)) + (let ((func-doc (eldoc-get-fnsym-args-string func-or-form))) + (setq msg (format "usage: %s" func-doc)))) (funcall errprint msg)) nil))) @@ -1333,11 +1333,11 @@ eshell-lisp-command (setq eshell-last-arguments args eshell-last-command-name "#") (eshell-eval object)))) - (if (and eshell-ensure-newline-p - (save-excursion - (goto-char eshell-last-output-end) - (not (bolp)))) - (eshell-print "\n")) + (when (and eshell-ensure-newline-p + (save-excursion + (goto-char eshell-last-output-end) + (not (bolp)))) + (eshell-print "\n")) (eshell-close-handles 0 (list 'quote result))))) (defalias 'eshell-lisp-command* #'eshell-lisp-command) diff --git a/lisp/eshell/esh-ext.el b/lisp/eshell/esh-ext.el index c88d3c9f59..7fbdefbb23 100644 --- a/lisp/eshell/esh-ext.el +++ b/lisp/eshell/esh-ext.el @@ -81,11 +81,11 @@ eshell-search-path (setq suffixes eshell-binary-suffixes) (while suffixes (setq n2 (concat n1 (car suffixes))) - (if (and (or (file-executable-p n2) - (and eshell-force-execution - (file-readable-p n2))) - (not (file-directory-p n2))) - (setq file n2 suffixes nil list nil)) + (when (and (or (file-executable-p n2) + (and eshell-force-execution + (file-readable-p n2))) + (not (file-directory-p n2))) + (setq file n2 suffixes nil list nil)) (setq suffixes (cdr suffixes))) (setq list (cdr list))) file))) @@ -260,17 +260,17 @@ eshell-script-interpreter (INTERPRETER [ARGS] FILE)" (let ((maxlen eshell-command-interpreter-max-length)) - (if (and (file-readable-p file) - (file-regular-p file)) - (with-temp-buffer - (insert-file-contents-literally file nil 0 maxlen) - (if (looking-at "#![ \t]*\\([^ \r\t\n]+\\)\\([ \t]+\\(.+\\)\\)?") - (if (match-string 3) - (list (match-string 1) - (match-string 3) - file) + (when (and (file-readable-p file) + (file-regular-p file)) + (with-temp-buffer + (insert-file-contents-literally file nil 0 maxlen) + (if (looking-at "#![ \t]*\\([^ \r\t\n]+\\)\\([ \t]+\\(.+\\)\\)?") + (if (match-string 3) (list (match-string 1) - file))))))) + (match-string 3) + file) + (list (match-string 1) + file))))))) (defun eshell-find-interpreter (file args &optional no-examine-p) "Find the command interpreter with which to execute FILE. @@ -302,15 +302,15 @@ eshell-find-interpreter (if (file-name-absolute-p fullname) (concat (file-remote-p default-directory) fullname) (expand-file-name fullname default-directory)))) - (if (and fullname (not (or eshell-force-execution - (file-executable-p fullname)))) - (while suffixes - (let ((try (concat fullname (car suffixes)))) - (if (or (file-executable-p try) - (and eshell-force-execution - (file-readable-p try))) - (setq fullname try suffixes nil) - (setq suffixes (cdr suffixes)))))) + (when (and fullname (not (or eshell-force-execution + (file-executable-p fullname)))) + (while suffixes + (let ((try (concat fullname (car suffixes)))) + (if (or (file-executable-p try) + (and eshell-force-execution + (file-readable-p try))) + (setq fullname try suffixes nil) + (setq suffixes (cdr suffixes)))))) (cond ((not (and fullname (file-exists-p fullname))) (let ((name (or fullname file))) (unless (setq fullname @@ -323,10 +323,10 @@ eshell-find-interpreter (let (interp) (unless no-examine-p (setq interp (eshell-script-interpreter fullname)) - (if interp - (setq interp - (cons (car (eshell-find-interpreter (car interp) args t)) - (cdr interp))))) + (when interp + (setq interp + (cons (car (eshell-find-interpreter (car interp) args t)) + (cdr interp))))) (or interp (list fullname))))))) (provide 'esh-ext) diff --git a/lisp/eshell/esh-io.el b/lisp/eshell/esh-io.el index b415486190..8aaf4edf04 100644 --- a/lisp/eshell/esh-io.el +++ b/lisp/eshell/esh-io.el @@ -118,13 +118,13 @@ eshell-print-queue-size (defcustom eshell-virtual-targets '(("/dev/eshell" eshell-interactive-print nil) ("/dev/kill" (lambda (mode) - (if (eq mode 'overwrite) - (kill-new "")) + (when (eq mode 'overwrite) + (kill-new "")) 'eshell-kill-append) t) ("/dev/clip" (lambda (mode) - (if (eq mode 'overwrite) - (let ((select-enable-clipboard t)) - (kill-new ""))) + (when (eq mode 'overwrite) + (let ((select-enable-clipboard t)) + (kill-new ""))) 'eshell-clipboard-append) t)) "Map virtual devices name to Emacs Lisp functions. If the user specifies any of the filenames above as a redirection @@ -189,8 +189,8 @@ eshell-parse-redirection (oper (match-string 2)) ; (th (match-string 3)) ) - (if (string= oper "<") - (error "Eshell does not support input redirection")) + (when (string= oper "<") + (error "Eshell does not support input redirection")) (eshell-finish-arg (prog1 (list 'eshell-set-output-handle @@ -247,9 +247,9 @@ eshell-protect-handles "Protect the handles in HANDLES from a being closed." (let ((idx 0)) (while (< idx eshell-number-of-handles) - (if (aref handles idx) - (setcdr (aref handles idx) - (1+ (cdr (aref handles idx))))) + (when (aref handles idx) + (setcdr (aref handles idx) + (1+ (cdr (aref handles idx))))) (setq idx (1+ idx)))) handles) @@ -275,8 +275,8 @@ eshell-close-target ;; If we're redirecting to a process (via a pipe, or process ;; redirection), send it EOF so that it knows we're finished. ((eshell-processp target) - (if (eq (process-status target) 'run) - (process-send-eof target))) + (when (eq (process-status target) 'run) + (process-send-eof target))) ;; A plain function redirection needs no additional arguments ;; passed. @@ -317,14 +317,14 @@ eshell-close-handles (defun eshell-kill-append (string) "Call `kill-append' with STRING, if it is indeed a string." - (if (stringp string) - (kill-append string nil))) + (when (stringp string) + (kill-append string nil))) (defun eshell-clipboard-append (string) "Call `kill-append' with STRING, if it is indeed a string." - (if (stringp string) - (let ((select-enable-clipboard t)) - (kill-append string nil)))) + (when (stringp string) + (let ((select-enable-clipboard t)) + (kill-append string nil)))) (defun eshell-get-target (target &optional mode) "Convert TARGET, which is a raw argument, into a valid output target. @@ -341,8 +341,8 @@ eshell-get-target (let* ((exists (get-file-buffer target)) (buf (find-file-noselect target t))) (with-current-buffer buf - (if buffer-file-read-only - (error "Cannot write to read-only file `%s'" target)) + (when buffer-file-read-only + (error "Cannot write to read-only file `%s'" target)) (setq buffer-read-only nil) (set (make-local-variable 'eshell-output-file-buffer) (if (eq exists buf) 0 t)) @@ -364,8 +364,8 @@ eshell-get-target ((functionp target) nil) ((symbolp target) - (if (eq mode 'overwrite) - (set target nil)) + (when (eq mode 'overwrite) + (set target nil)) target) ((or (eshell-processp target) @@ -391,8 +391,8 @@ eshell-set-output-handle (not (member where current))) (setq current (append current (list where))) (setq current (list where))) - (if (not (aref eshell-current-handles index)) - (aset eshell-current-handles index (cons nil 1))) + (when (not (aref eshell-current-handles index)) + (aset eshell-current-handles index (cons nil 1))) (setcar (aref eshell-current-handles index) current))))) (defun eshell-interactive-output-p () @@ -417,8 +417,8 @@ eshell-flush (if reset-p (setq eshell-print-queue nil eshell-print-queue-count reset-p) - (if eshell-print-queue - (eshell-print eshell-print-queue)) + (when eshell-print-queue + (eshell-print eshell-print-queue)) (eshell-flush 0)))) (defun eshell-init-print-buffer () @@ -431,8 +431,8 @@ eshell-buffered-print (progn (eshell-print (apply 'concat strings)) (setq eshell-print-queue-count 0)) - (if (= eshell-print-queue-count eshell-print-queue-size) - (eshell-flush)) + (when (= eshell-print-queue-count eshell-print-queue-size) + (eshell-flush)) (setq eshell-print-queue (concat eshell-print-queue (apply 'concat strings)) eshell-print-queue-count (1+ eshell-print-queue-count)))) @@ -466,23 +466,23 @@ eshell-output-object-to-target (if (not (symbol-value target)) (set target object) (setq object (eshell-stringify object)) - (if (not (stringp (symbol-value target))) - (set target (eshell-stringify - (symbol-value target)))) + (when (not (stringp (symbol-value target))) + (set target (eshell-stringify + (symbol-value target)))) (set target (concat (symbol-value target) object))))) ((markerp target) - (if (buffer-live-p (marker-buffer target)) - (with-current-buffer (marker-buffer target) - (let ((moving (= (point) target))) - (save-excursion - (goto-char target) - (unless (stringp object) - (setq object (eshell-stringify object))) - (insert-and-inherit object) - (set-marker target (point-marker))) - (if moving - (goto-char target)))))) + (when (buffer-live-p (marker-buffer target)) + (with-current-buffer (marker-buffer target) + (let ((moving (= (point) target))) + (save-excursion + (goto-char target) + (unless (stringp object) + (setq object (eshell-stringify object))) + (insert-and-inherit object) + (set-marker target (point-marker))) + (when moving + (goto-char target)))))) ((eshell-processp target) (when (eq (process-status target) 'run) diff --git a/lisp/eshell/esh-mode.el b/lisp/eshell/esh-mode.el index e0e86348bd..e6dc311ced 100644 --- a/lisp/eshell/esh-mode.el +++ b/lisp/eshell/esh-mode.el @@ -309,8 +309,8 @@ eshell-mode (let ((fmt (copy-sequence mode-line-format))) (setq-local mode-line-format fmt)) (let ((mode-line-elt (memq 'mode-line-modified mode-line-format))) - (if mode-line-elt - (setcar mode-line-elt 'eshell-command-running-string)))) + (when mode-line-elt + (setcar mode-line-elt 'eshell-command-running-string)))) (set (make-local-variable 'bookmark-make-record-function) 'eshell-bookmark-make-record) @@ -327,10 +327,10 @@ eshell-mode (setq auto-fill-function nil) ;; always display everything from a return value - (if (boundp 'print-length) - (set (make-local-variable 'print-length) nil)) - (if (boundp 'print-level) - (set (make-local-variable 'print-level) nil)) + (when (boundp 'print-length) + (set (make-local-variable 'print-length) nil)) + (when (boundp 'print-level) + (set (make-local-variable 'print-level) nil)) ;; set require-final-newline to nil; otherwise, all redirected ;; output will end with a newline, whether or not the source @@ -363,9 +363,9 @@ eshell-mode (dolist (module eshell-modules-list) (let ((module-fullname (symbol-name module)) module-shortname) - (if (string-match "^eshell-\\(.*\\)" module-fullname) - (setq module-shortname - (concat "em-" (match-string 1 module-fullname)))) + (when (string-match "^eshell-\\(.*\\)" module-fullname) + (setq module-shortname + (concat "em-" (match-string 1 module-fullname)))) (unless module-shortname (error "Invalid Eshell module name: %s" module-fullname)) (unless (featurep (intern module-shortname)) @@ -379,16 +379,16 @@ eshell-mode (let ((load-hook (intern-soft (format "%s-load-hook" module))) (initfunc (intern-soft (format "%s-initialize" module)))) (when (and load-hook (boundp load-hook)) - (if (memq initfunc (symbol-value load-hook)) (setq initfunc nil)) + (when (memq initfunc (symbol-value load-hook)) (setq initfunc nil)) (run-hooks load-hook)) ;; So we don't need the -initialize functions on the hooks (bug#5375). (and initfunc (fboundp initfunc) (funcall initfunc)))) - (if eshell-send-direct-to-subprocesses - (add-hook 'pre-command-hook #'eshell-intercept-commands t t)) + (when eshell-send-direct-to-subprocesses + (add-hook 'pre-command-hook #'eshell-intercept-commands t t)) - (if eshell-scroll-to-bottom-on-input - (add-hook 'pre-command-hook #'eshell-preinput-scroll-to-bottom t t)) + (when eshell-scroll-to-bottom-on-input + (add-hook 'pre-command-hook #'eshell-preinput-scroll-to-bottom t t)) (when eshell-scroll-show-maximum-output (set (make-local-variable 'scroll-conservatively) 1000)) @@ -399,8 +399,8 @@ eshell-mode (add-hook 'kill-buffer-hook #'eshell-kill-buffer-function t t) - (if eshell-first-time-p - (run-hooks 'eshell-first-time-mode-hook)) + (when eshell-first-time-p + (run-hooks 'eshell-first-time-mode-hook)) (run-hooks 'eshell-post-command-hook)) (put 'eshell-mode 'mode-class 'special) @@ -452,8 +452,8 @@ eshell-intercept-commands (if (> (length (car possible-events)) 1) (setq intercept nil possible-events nil) (setq possible-events (cdr possible-events))))) - (if intercept - (setq this-command 'eshell-self-insert-command))))) + (when intercept + (setq this-command 'eshell-self-insert-command))))) (declare-function find-tag-interactive "etags" (prompt &optional no-default)) @@ -477,15 +477,15 @@ eshell-move-argument (let ((pos (save-excursion (funcall func 1) (while (and (> arg 0) (/= (point) limit)) - (if (get-text-property (point) property) - (setq arg (1- arg))) - (if (> arg 0) - (funcall func 1))) + (when (get-text-property (point) property) + (setq arg (1- arg))) + (when (> arg 0) + (funcall func 1))) (point)))) (goto-char pos) - (if (and (eq func 'forward-char) - (= (1+ pos) limit)) - (forward-char 1)))) + (when (and (eq func 'forward-char) + (= (1+ pos) limit)) + (forward-char 1)))) (defun eshell-forward-argument (&optional arg) "Move forward ARG arguments." @@ -695,21 +695,21 @@ eshell-output-filter (widen) (goto-char eshell-last-output-end) (setq ostart (point)) - (if (<= (point) opoint) - (setq opoint (+ opoint nchars))) - (if (< (point) obeg) - (setq obeg (+ obeg nchars))) - (if (<= (point) oend) - (setq oend (+ oend nchars))) + (when (<= (point) opoint) + (setq opoint (+ opoint nchars))) + (when (< (point) obeg) + (setq obeg (+ obeg nchars))) + (when (<= (point) oend) + (setq oend (+ oend nchars))) ;; Let the ansi-color overlay hooks run. (let ((inhibit-modification-hooks nil)) (insert-before-markers string)) - (if (= (window-start) (point)) - (set-window-start (selected-window) - (- (point) nchars))) - (if (= (point) eshell-last-input-end) - (set-marker eshell-last-input-end - (- eshell-last-input-end nchars))) + (when (= (window-start) (point)) + (set-window-start (selected-window) + (- (point) nchars))) + (when (= (point) eshell-last-input-end) + (set-marker eshell-last-input-end + (- eshell-last-input-end nchars))) (set-marker eshell-last-output-start ostart) (set-marker eshell-last-output-end (point)) (force-mode-line-update)) @@ -734,22 +734,22 @@ eshell-preinput-scroll-to-bottom `eshell-scroll-to-bottom-on-input'. This function should be a pre-command hook." - (if (memq this-command '(self-insert-command yank hilit-yank)) - (let* ((selected (selected-window)) - (current (current-buffer)) - (scroll eshell-scroll-to-bottom-on-input)) - (if (< (point) eshell-last-output-end) - (if (eq scroll 'this) - (goto-char (point-max)) - (walk-windows - (function - (lambda (window) - (when (and (eq (window-buffer window) current) - (or (eq scroll t) (eq scroll 'all))) - (select-window window) - (goto-char (point-max)) - (select-window selected)))) - nil t)))))) + (when (memq this-command '(self-insert-command yank hilit-yank)) + (let* ((selected (selected-window)) + (current (current-buffer)) + (scroll eshell-scroll-to-bottom-on-input)) + (if (< (point) eshell-last-output-end) + (if (eq scroll 'this) + (goto-char (point-max)) + (walk-windows + (function + (lambda (window) + (when (and (eq (window-buffer window) current) + (or (eq scroll t) (eq scroll 'all))) + (select-window window) + (goto-char (point-max)) + (select-window selected)))) + nil t)))))) ;;; jww (1999-10-23): this needs testing (defun eshell-postoutput-scroll-to-bottom () @@ -766,27 +766,26 @@ eshell-postoutput-scroll-to-bottom (walk-windows (function (lambda (window) - (if (eq (window-buffer window) current) - (progn - (select-window window) - (if (and (< (point) eshell-last-output-end) - (or (eq scroll t) (eq scroll 'all) - ;; Maybe user wants point to jump to end. - (and (eq scroll 'this) - (eq selected window)) - (and (eq scroll 'others) - (not (eq selected window))) - ;; If point was at the end, keep it at end. - (>= (point) eshell-last-output-start))) - (goto-char eshell-last-output-end)) - ;; Optionally scroll so that the text - ;; ends at the bottom of the window. - (if (and eshell-scroll-show-maximum-output - (>= (point) eshell-last-output-end)) - (save-excursion - (goto-char (point-max)) - (recenter -1))) - (select-window selected))))) + (when (eq (window-buffer window) current) + (select-window window) + (when (and (< (point) eshell-last-output-end) + (or (eq scroll t) (eq scroll 'all) + ;; Maybe user wants point to jump to end. + (and (eq scroll 'this) + (eq selected window)) + (and (eq scroll 'others) + (not (eq selected window))) + ;; If point was at the end, keep it at end. + (>= (point) eshell-last-output-start))) + (goto-char eshell-last-output-end)) + ;; Optionally scroll so that the text + ;; ends at the bottom of the window. + (when (and eshell-scroll-show-maximum-output + (>= (point) eshell-last-output-end)) + (save-excursion + (goto-char (point-max)) + (recenter -1))) + (select-window selected)))) nil t) (set-buffer current)))) @@ -823,9 +822,9 @@ eshell-show-output (save-excursion (goto-char (eshell-beginning-of-input)) (line-beginning-position))) - (if arg - (narrow-to-region (eshell-beginning-of-output) - (eshell-end-of-output))) + (when arg + (narrow-to-region (eshell-beginning-of-output) + (eshell-end-of-output))) (eshell-end-of-output)) (defun eshell-mark-output (&optional arg) @@ -848,8 +847,8 @@ eshell-show-maximum-output "Put the end of the buffer at the bottom of the window. When run interactively, widen the buffer first." (interactive "p") - (if interactive - (widen)) + (when interactive + (widen)) (goto-char (point-max)) (recenter -1)) @@ -912,13 +911,13 @@ eshell-truncate-buffer (beginning-of-line) (let ((pos (point))) (if (bobp) - (if (called-interactively-p 'interactive) - (message "Buffer too short to truncate")) + (when (called-interactively-p 'interactive) + (message "Buffer too short to truncate")) (delete-region (point-min) (point)) - (if (called-interactively-p 'interactive) - (message "Truncated buffer from %d to %d lines (%.1fk freed)" - lines eshell-buffer-maximum-lines - (/ pos 1024.0)))))))) + (when (called-interactively-p 'interactive) + (message "Truncated buffer from %d to %d lines (%.1fk freed)" + lines eshell-buffer-maximum-lines + (/ pos 1024.0)))))))) (custom-add-option 'eshell-output-filter-functions 'eshell-truncate-buffer) @@ -947,9 +946,9 @@ eshell-watch-for-password-prompt (let ((case-fold-search t)) (goto-char eshell-last-output-block-begin) (beginning-of-line) - (if (re-search-forward eshell-password-prompt-regexp - eshell-last-output-end t) - (eshell-send-invisible)))))) + (when (re-search-forward eshell-password-prompt-regexp + eshell-last-output-end t) + (eshell-send-invisible)))))) (custom-add-option 'eshell-output-filter-functions 'eshell-watch-for-password-prompt) diff --git a/lisp/eshell/esh-module.el b/lisp/eshell/esh-module.el index 45c4c9e13c..59b874933e 100644 --- a/lisp/eshell/esh-module.el +++ b/lisp/eshell/esh-module.el @@ -92,11 +92,11 @@ eshell-using-module (defun eshell-unload-extension-modules () "Unload any memory resident extension modules." (dolist (module (eshell-subgroups 'eshell-module)) - (if (featurep module) - (ignore-errors - (message "Unloading %s..." (symbol-name module)) - (unload-feature module) - (message "Unloading %s...done" (symbol-name module)))))) + (when (featurep module) + (ignore-errors + (message "Unloading %s..." (symbol-name module)) + (unload-feature module) + (message "Unloading %s...done" (symbol-name module)))))) (provide 'esh-module) ;;; esh-module.el ends here diff --git a/lisp/eshell/esh-opt.el b/lisp/eshell/esh-opt.el index dc8918891b..990ca4daba 100644 --- a/lisp/eshell/esh-opt.el +++ b/lisp/eshell/esh-opt.el @@ -181,15 +181,15 @@ eshell-show-usage (nth 4 opt))))) (t (setq had-option nil))))) (setq options (cdr options))) - (if post-usage - (setq usage (concat usage (and had-option "\n") - (cadr post-usage)))) + (when post-usage + (setq usage (concat usage (and had-option "\n") + (cadr post-usage)))) (when extcmd (setq extcmd (eshell-search-path (cadr extcmd))) - (if extcmd - (setq usage - (concat usage - (format-message " + (when extcmd + (setq usage + (concat usage + (format-message " This command is implemented in Lisp. If an unrecognized option is passed to this command, the external version `%s' will be called instead." extcmd))))) diff --git a/lisp/eshell/esh-proc.el b/lisp/eshell/esh-proc.el index db1b258c8f..5d68930f28 100644 --- a/lisp/eshell/esh-proc.el +++ b/lisp/eshell/esh-proc.el @@ -126,8 +126,8 @@ eshell-kill-process-function Runs `eshell-reset-after-proc' and `eshell-kill-hook', passing arguments PROC and STATUS to functions on the latter." ;; Was there till 24.1, but it is not optional. - (if (memq #'eshell-reset-after-proc eshell-kill-hook) - (setq eshell-kill-hook (delq #'eshell-reset-after-proc eshell-kill-hook))) + (when (memq #'eshell-reset-after-proc eshell-kill-hook) + (setq eshell-kill-hook (delq #'eshell-reset-after-proc eshell-kill-hook))) (eshell-reset-after-proc status) (run-hook-with-args 'eshell-kill-hook proc status)) @@ -159,8 +159,8 @@ eshell-wait-for-process (when (eshell-processp proc) ;; NYI: If the process gets stopped here, that's bad. (while (assq proc eshell-process-list) - (if (input-pending-p) - (discard-input)) + (when (input-pending-p) + (discard-input)) (sit-for eshell-process-wait-seconds eshell-process-wait-milliseconds)))) (setq procs (cdr procs)))) @@ -243,11 +243,11 @@ eshell-record-process-object (defun eshell-remove-process-entry (entry) "Record the process ENTRY as fully completed." - (if (and (eshell-processp (car entry)) - (nth 2 entry) - eshell-done-messages-in-minibuffer) - (message "[%s]+ Done %s" (process-name (car entry)) - (process-command (car entry)))) + (when (and (eshell-processp (car entry)) + (nth 2 entry) + eshell-done-messages-in-minibuffer) + (message "[%s]+ Done %s" (process-name (car entry)) + (process-command (car entry)))) (setq eshell-process-list (delq entry eshell-process-list))) @@ -276,10 +276,10 @@ eshell-needs-pipe-p ;; neither 'first nor 'last? See bug#1388 discussion. (catch 'found (dolist (exe eshell-needs-pipe) - (if (string-equal exe (if (string-match "/" exe) - command - (file-name-nondirectory command))) - (throw 'found t)))))) + (when (string-equal exe (if (string-match "/" exe) + command + (file-name-nondirectory command))) + (throw 'found t)))))) (defun eshell-gather-process-output (command args) "Gather the output from COMMAND + ARGS." @@ -318,18 +318,18 @@ eshell-gather-process-output ;; decoding data sent from the process and the coding system ;; doesn't specify EOL conversion, we had better convert CRLF ;; to LF. - (if (vectorp (coding-system-eol-type decoding)) - (setq decoding (coding-system-change-eol-conversion decoding 'dos) - changed t)) + (when (vectorp (coding-system-eol-type decoding)) + (setq decoding (coding-system-change-eol-conversion decoding 'dos) + changed t)) ;; Even if start-process left the coding system for encoding ;; data sent from the process undecided, we had better use the ;; same one as what we use for decoding. But, we should ;; suppress EOL conversion. - (if (and decoding (not encoding)) - (setq encoding (coding-system-change-eol-conversion decoding 'unix) - changed t)) - (if changed - (set-process-coding-system proc decoding encoding)))) + (when (and decoding (not encoding)) + (setq encoding (coding-system-change-eol-conversion decoding 'unix) + changed t)) + (when changed + (set-process-coding-system proc decoding encoding)))) (t ;; No async subprocesses... (let ((oldbuf (current-buffer)) @@ -376,7 +376,7 @@ eshell-gather-process-output (eshell-kill-process-function command exit-status) (or (bound-and-true-p eshell-in-pipeline-p) (setq eshell-last-sync-output-start nil)) - (if (not (numberp exit-status)) + (when (not (numberp exit-status)) (error "%s: external command failed: %s" command exit-status)) (setq proc t)))) proc)) @@ -438,14 +438,14 @@ eshell-process-interact If QUERY is non-nil, query the user with QUERY before calling FUNC." (let (defunct result) (dolist (entry eshell-process-list) - (if (and (memq (process-status (car entry)) - '(run stop open closed)) - (or all - (not (nth 2 entry))) - (or (not query) - (y-or-n-p (format-message query - (process-name (car entry)))))) - (setq result (funcall func (car entry)))) + (when (and (memq (process-status (car entry)) + '(run stop open closed)) + (or all + (not (nth 2 entry))) + (or (not query) + (y-or-n-p (format-message query + (process-name (car entry)))))) + (setq result (funcall func (car entry)))) (unless (memq (process-status (car entry)) '(run stop open closed)) (setq defunct (cons entry defunct)))) @@ -514,15 +514,15 @@ eshell-query-kill-processes eshell-process-list) (save-window-excursion (list-processes) - (if (or (not (eq eshell-kill-processes-on-exit 'ask)) - (y-or-n-p (format-message "Kill processes owned by `%s'? " - (buffer-name)))) - (eshell-round-robin-kill - (if (eq eshell-kill-processes-on-exit 'every) - "Kill Eshell child process `%s'? "))) + (when (or (not (eq eshell-kill-processes-on-exit 'ask)) + (y-or-n-p (format-message "Kill processes owned by `%s'? " + (buffer-name)))) + (eshell-round-robin-kill + (if (eq eshell-kill-processes-on-exit 'every) + "Kill Eshell child process `%s'? "))) (let ((buf (get-buffer "*Process List*"))) - (if (and buf (buffer-live-p buf)) - (kill-buffer buf))) + (when (and buf (buffer-live-p buf)) + (kill-buffer buf))) (message nil)))) (defun eshell-interrupt-process () diff --git a/lisp/eshell/esh-util.el b/lisp/eshell/esh-util.el index ab030ede05..f0affe1381 100644 --- a/lisp/eshell/esh-util.el +++ b/lisp/eshell/esh-util.el @@ -203,8 +203,8 @@ eshell-convert (let ((len (length string))) (if (= len 0) string - (if (eq (aref string (1- len)) ?\n) - (setq string (substring string 0 (1- len)))) + (when (eq (aref string (1- len)) ?\n) + (setq string (substring string 0 (1- len)))) (if (string-match "\n" string) (split-string string "\n") (if (and eshell-convert-numeric-arguments @@ -218,8 +218,8 @@ eshell-sublist "Return from LIST the N to M elements. If N or M is nil, it means the end of the list." (let ((a (copy-sequence l))) - (if (and m (consp (nthcdr m a))) - (setcdr (nthcdr m a) nil)) + (when (and m (consp (nthcdr m a))) + (setcdr (nthcdr m a) nil)) (if n (setq a (nthcdr n a)) (setq n (1- (length a)) @@ -255,30 +255,30 @@ eshell-split-path (let ((len (length path)) (i 0) (li 0) parts) - (if (and (eshell-under-windows-p) - (> len 2) - (eq (aref path 0) ?/) - (eq (aref path 1) ?/)) - (setq i 2)) + (when (and (eshell-under-windows-p) + (> len 2) + (eq (aref path 0) ?/) + (eq (aref path 1) ?/)) + (setq i 2)) (while (< i len) - (if (and (eq (aref path i) ?/) - (not (get-text-property i 'escaped path))) - (setq parts (cons (if (= li i) "/" - (substring path li (1+ i))) parts) - li (1+ i))) + (when (and (eq (aref path i) ?/) + (not (get-text-property i 'escaped path))) + (setq parts (cons (if (= li i) "/" + (substring path li (1+ i))) parts) + li (1+ i))) (setq i (1+ i))) - (if (< li i) - (setq parts (cons (substring path li i) parts))) - (if (and (eshell-under-windows-p) - (string-match "\\`[A-Za-z]:\\'" (car (last parts)))) - (setcar (last parts) (concat (car (last parts)) "/"))) + (when (< li i) + (setq parts (cons (substring path li i) parts))) + (when (and (eshell-under-windows-p) + (string-match "\\`[A-Za-z]:\\'" (car (last parts)))) + (setcar (last parts) (concat (car (last parts)) "/"))) (nreverse parts))) (defun eshell-to-flat-string (value) "Make value a string. If separated by newlines change them to spaces." (let ((text (eshell-stringify value))) - (if (string-match "\n+\\'" text) - (setq text (replace-match "" t t text))) + (when (string-match "\n+\\'" text) + (setq text (replace-match "" t t text))) (while (string-match "\n+" text) (setq text (replace-match " " t t text))) text)) @@ -370,21 +370,21 @@ eshell-printable-size (let ((str (if (<= size 9.94) (format "%.1fM" size) (format "%.0fM" size)))) - (if use-colors - (put-text-property 0 (length str) - 'face 'bold str)) + (when use-colors + (put-text-property 0 (length str) + 'face 'bold str)) str) (setq size (/ size human-readable)) - (if (< size human-readable) - (let ((str (if (<= size 9.94) - (format "%.1fG" size) - (format "%.0fG" size)))) - (if use-colors - (put-text-property 0 (length str) - 'face 'bold-italic str)) - str))))) - (if block-size - (setq size (/ size block-size))) + (when (< size human-readable) + (let ((str (if (<= size 9.94) + (format "%.1fG" size) + (format "%.0fG" size)))) + (when use-colors + (put-text-property 0 (length str) + 'face 'bold-italic str)) + str))))) + (when block-size + (setq size (/ size block-size))) (format "%.0f" size)))) (defun eshell-winnow-list (entries exclude &optional predicates) @@ -433,31 +433,31 @@ eshell-read-passwd-file (split-string (buffer-substring (point) (progn (end-of-line) (point))) ":"))) - (if (and (and fields (nth 0 fields) (nth 2 fields)) - (not (assq (string-to-number (nth 2 fields)) names))) - (setq names (cons (cons (string-to-number (nth 2 fields)) - (nth 0 fields)) - names)))) + (when (and (and fields (nth 0 fields) (nth 2 fields)) + (not (assq (string-to-number (nth 2 fields)) names))) + (setq names (cons (cons (string-to-number (nth 2 fields)) + (nth 0 fields)) + names)))) (forward-line)))) names)) (defun eshell-read-passwd (file result-var timestamp-var) "Read the contents of /etc/passwd for user names." - (if (or (not (symbol-value result-var)) - (not (symbol-value timestamp-var)) - (time-less-p - (symbol-value timestamp-var) - (file-attribute-modification-time (file-attributes file)))) - (progn - (set result-var (eshell-read-passwd-file file)) - (set timestamp-var (current-time)))) + (when (or (not (symbol-value result-var)) + (not (symbol-value timestamp-var)) + (time-less-p + (symbol-value timestamp-var) + (file-attribute-modification-time (file-attributes file)))) + (progn + (set result-var (eshell-read-passwd-file file)) + (set timestamp-var (current-time)))) (symbol-value result-var)) (defun eshell-read-group-names () "Read the contents of /etc/group for group names." - (if eshell-group-file - (eshell-read-passwd eshell-group-file 'eshell-group-names - 'eshell-group-timestamp))) + (when eshell-group-file + (eshell-read-passwd eshell-group-file 'eshell-group-names + 'eshell-group-timestamp))) (defsubst eshell-group-id (name) "Return the user id for user NAME." @@ -469,9 +469,9 @@ eshell-group-name (defun eshell-read-user-names () "Read the contents of /etc/passwd for user names." - (if eshell-passwd-file - (eshell-read-passwd eshell-passwd-file 'eshell-user-names - 'eshell-user-timestamp))) + (when eshell-passwd-file + (eshell-read-passwd eshell-passwd-file 'eshell-user-names + 'eshell-user-timestamp))) (defsubst eshell-user-id (name) "Return the user id for user NAME." @@ -495,21 +495,21 @@ eshell-read-hosts-file (defun eshell-read-hosts (file result-var timestamp-var) "Read the contents of /etc/hosts for host names." - (if (or (not (symbol-value result-var)) - (not (symbol-value timestamp-var)) - (time-less-p - (symbol-value timestamp-var) - (file-attribute-modification-time (file-attributes file)))) - (progn - (set result-var (apply #'nconc (eshell-read-hosts-file file))) - (set timestamp-var (current-time)))) + (when (or (not (symbol-value result-var)) + (not (symbol-value timestamp-var)) + (time-less-p + (symbol-value timestamp-var) + (file-attribute-modification-time (file-attributes file)))) + (progn + (set result-var (apply #'nconc (eshell-read-hosts-file file))) + (set timestamp-var (current-time)))) (symbol-value result-var)) (defun eshell-read-host-names () "Read the contents of /etc/hosts for host names." - (if eshell-hosts-file - (eshell-read-hosts eshell-hosts-file 'eshell-host-names - 'eshell-host-timestamp))) + (when eshell-hosts-file + (eshell-read-hosts eshell-hosts-file 'eshell-host-names + 'eshell-host-timestamp))) (defsubst eshell-copy-environment () "Return an unrelated copy of `process-environment'." @@ -520,8 +520,8 @@ eshell-subgroups (let ((subgroups (get groupsym 'custom-group)) (subg (list t))) (while subgroups - (if (eq (cadr (car subgroups)) 'custom-group) - (nconc subg (list (caar subgroups)))) + (when (eq (cadr (car subgroups)) 'custom-group) + (nconc subg (list (caar subgroups)))) (setq subgroups (cdr subgroups))) (cdr subg))) @@ -558,13 +558,13 @@ eshell-directory-files-and-attributes (directory-files-and-attributes dir full match nosort id-format)))) (defun eshell-current-ange-uids () - (if (string-match "/\\([^@]+\\)@\\([^:]+\\):" default-directory) - (let* ((host (match-string 2 default-directory)) - (user (match-string 1 default-directory)) - (host-users (assoc host eshell-ange-ls-uids))) - (when host-users - (setq host-users (cdr host-users)) - (cdr (assoc user host-users)))))) + (when (string-match "/\\([^@]+\\)@\\([^:]+\\):" default-directory) + (let* ((host (match-string 2 default-directory)) + (user (match-string 1 default-directory)) + (host-users (assoc host eshell-ange-ls-uids))) + (when host-users + (setq host-users (cdr host-users)) + (cdr (assoc user host-users)))))) (autoload 'parse-time-string "parse-time") @@ -595,10 +595,10 @@ eshell-parse-ange-ls (with-temp-buffer (insert (ange-ftp-ls dir "-la" nil)) (goto-char (point-min)) - (if (looking-at "^total [0-9]+$") - (forward-line 1)) + (when (looking-at "^total [0-9]+$") + (forward-line 1)) ;; Some systems put in a blank line here. - (if (eolp) (forward-line 1)) + (when (eolp) (forward-line 1)) (while (looking-at `,(concat "\\([dlscb-][rwxst-]+\\)" "\\s-*" "\\([0-9]+\\)" "\\s-+" @@ -621,9 +621,9 @@ eshell-parse-ange-ls (setf (decoded-time-hour moment) 0)) (encode-time moment))) symlink) - (if (string-match "\\(.+\\) -> \\(.+\\)" name) - (setq symlink (match-string 2 name) - name (match-string 1 name))) + (when (string-match "\\(.+\\) -> \\(.+\\)" name) + (setq symlink (match-string 2 name) + name (match-string 1 name))) (setq entry (cons (cons name @@ -646,14 +646,14 @@ eshell-file-attributes (if (string-equal (file-remote-p file 'method) "ftp") (let ((base (file-name-nondirectory file)) (dir (file-name-directory file))) - (if (string-equal "" base) (setq base ".")) + (when (string-equal "" base) (setq base ".")) (unless entry (setq entry (eshell-parse-ange-ls dir)) - (if entry - (let ((fentry (assoc base (cdr entry)))) - (if fentry - (setq entry (cdr fentry)) - (setq entry nil))))) + (when entry + (let ((fentry (assoc base (cdr entry)))) + (if fentry + (setq entry (cdr fentry)) + (setq entry nil))))) entry) (file-attributes file id-format)))) diff --git a/lisp/eshell/esh-var.el b/lisp/eshell/esh-var.el index 96838d4132..a32861f34f 100644 --- a/lisp/eshell/esh-var.el +++ b/lisp/eshell/esh-var.el @@ -267,25 +267,25 @@ eshell-handle-local-variables ;; setenv immediately before the command is invoked. This means ;; that 'BLAH=x cd blah' won't work exactly as expected, but that ;; is by no means a typical use of local environment variables. - (if (and command (string-match setvar command)) - (throw - 'eshell-replace-command - (list - 'eshell-as-subcommand - (append - (list 'progn) - (let ((l (list t))) - (while (string-match setvar command) - (nconc - l (list - (list 'setenv (match-string 1 command) - (match-string 2 command) - (= (length (match-string 2 command)) 0)))) - (setq command (eshell-stringify (car args)) - args (cdr args))) - (cdr l)) - (list (list 'eshell-named-command - command (list 'quote args))))))))) + (when (and command (string-match setvar command)) + (throw + 'eshell-replace-command + (list + 'eshell-as-subcommand + (append + (list 'progn) + (let ((l (list t))) + (while (string-match setvar command) + (nconc + l (list + (list 'setenv (match-string 1 command) + (match-string 2 command) + (= (length (match-string 2 command)) 0)))) + (setq command (eshell-stringify (car args)) + args (cdr args))) + (cdr l)) + (list (list 'eshell-named-command + command (list 'quote args))))))))) (defun eshell-interpolate-variable () "Parse a variable interpolation. @@ -308,10 +308,10 @@ eshell/define (list 'quote (if (= (length definition) 1) (car definition) definition))))) - (if def - (setq eshell-variable-aliases-list - (delq (assoc var-alias eshell-variable-aliases-list) - eshell-variable-aliases-list))) + (when def + (setq eshell-variable-aliases-list + (delq (assoc var-alias eshell-variable-aliases-list) + eshell-variable-aliases-list))) (setq eshell-variable-aliases-list (cons alias-def eshell-variable-aliases-list)))) @@ -320,10 +320,10 @@ eshell/define (defun eshell/export (&rest sets) "This alias allows the `export' command to act as bash users expect." (while sets - (if (and (stringp (car sets)) - (string-match "^\\([^=]+\\)=\\(.*\\)" (car sets))) - (setenv (match-string 1 (car sets)) - (match-string 2 (car sets)))) + (when (and (stringp (car sets)) + (string-match "^\\([^=]+\\)=\\(.*\\)" (car sets))) + (setenv (match-string 1 (car sets)) + (match-string 2 (car sets)))) (setq sets (cdr sets)))) (defun pcomplete/eshell-mode/export () @@ -336,8 +336,8 @@ pcomplete/eshell-mode/export (defun eshell/unset (&rest args) "Unset an environment variable." (while args - (if (stringp (car args)) - (setenv (car args) nil t)) + (when (stringp (car args)) + (setenv (car args) nil t)) (setq args (cdr args)))) (defun pcomplete/eshell-mode/unset () @@ -393,10 +393,10 @@ eshell-environment-variables environment, as specified in `eshell-variable-aliases-list'." (let ((process-environment (eshell-copy-environment))) (dolist (var-alias eshell-variable-aliases-list) - (if (nth 2 var-alias) - (setenv (car var-alias) - (eshell-stringify - (or (eshell-get-variable (car var-alias)) ""))))) + (when (nth 2 var-alias) + (setenv (car var-alias) + (eshell-stringify + (or (eshell-get-variable (car var-alias)) ""))))) process-environment)) (defun eshell-parse-variable () @@ -548,12 +548,12 @@ eshell-apply-indices (let ((refs (car indices))) (when (stringp value) (let (separator) - (if (not (or (not (stringp (caar indices))) - (string-match - (concat "^" eshell-variable-name-regexp "$") - (caar indices)))) - (setq separator (caar indices) - refs (cdr refs))) + (when (not (or (not (stringp (caar indices))) + (string-match + (concat "^" eshell-variable-name-regexp "$") + (caar indices)))) + (setq separator (caar indices) + refs (cdr refs))) (setq value (mapcar #'eshell-convert (split-string value separator))))) @@ -613,8 +613,8 @@ eshell-variables-list (let ((argname pcomplete-stub) completions) (dolist (alias eshell-variable-aliases-list) - (if (string-match (concat "^" argname) (car alias)) - (setq completions (cons (car alias) completions)))) + (when (string-match (concat "^" argname) (car alias)) + (setq completions (cons (car alias) completions)))) (sort (append (mapcar @@ -636,8 +636,8 @@ eshell-complete-variable-assignment (let ((arg (pcomplete-actual-arg)) pos) (when (string-match (concat "\\`" eshell-variable-name-regexp "=") arg) (setq pos (match-end 0)) - (if (string-match "\\(:\\)[^:]*\\'" arg) - (setq pos (match-end 1))) + (when (string-match "\\(:\\)[^:]*\\'" arg) + (setq pos (match-end 1))) (setq pcomplete-stub (substring arg pos)) (throw 'pcomplete-completions (pcomplete-entries))))) diff --git a/lisp/eshell/eshell.el b/lisp/eshell/eshell.el index 6698ca45de..b5433f25a1 100644 --- a/lisp/eshell/eshell.el +++ b/lisp/eshell/eshell.el @@ -299,8 +299,8 @@ eshell-command (eshell-command-mode +1)) (unless command (setq command (read-from-minibuffer "Emacs shell command: ")) - (if (eshell-using-module 'eshell-hist) - (eshell-add-input-to-history command))))) + (when (eshell-using-module 'eshell-hist) + (eshell-add-input-to-history command))))) (unless command (error "No command specified!")) ;; redirection into the current buffer is achieved by adding an @@ -308,11 +308,11 @@ eshell-command ;; 'COMMAND >>> #'. This will not interfere with ;; other redirections, since multiple redirections merely cause the ;; output to be copied to multiple target locations - (if arg - (setq command - (concat command - (format " >>> #" - (buffer-name (current-buffer)))))) + (when arg + (setq command + (concat command + (format " >>> #" + (buffer-name (current-buffer)))))) (save-excursion (let ((buf (set-buffer (generate-new-buffer " *eshell cmd*"))) (eshell-non-interactive-p t)) @@ -325,15 +325,15 @@ eshell-command "*Eshell Async Command Output*" (setq intr t) "*Eshell Command Output*"))) - (if (buffer-live-p (get-buffer bufname)) - (kill-buffer bufname)) + (when (buffer-live-p (get-buffer bufname)) + (kill-buffer bufname)) (rename-buffer bufname) ;; things get a little coarse here, since the desire is to ;; make the output as attractive as possible, with no ;; extraneous newlines (when intr - (if (eshell-interactive-process) - (eshell-wait-for-process (eshell-interactive-process))) + (when (eshell-interactive-process) + (eshell-wait-for-process (eshell-interactive-process))) (cl-assert (not (eshell-interactive-process))) (goto-char (point-max)) (while (and (bolp) (not (bobp))) @@ -369,8 +369,8 @@ eshell-command-result ;; a null command produces a null, successful result (if (not command) (ignore - (if (and status-var (symbolp status-var)) - (set status-var 0))) + (when (and status-var (symbolp status-var)) + (set status-var 0))) (with-temp-buffer (let ((eshell-non-interactive-p t)) (eshell-mode) @@ -380,8 +380,8 @@ eshell-command-result (eshell-parse-command command))) t))) (cl-assert (eq (car result) 'quote)) - (if (and status-var (symbolp status-var)) - (set status-var eshell-last-command-status)) + (when (and status-var (symbolp status-var)) + (set status-var eshell-last-command-status)) (cadr result)))))) ;;; Code: @@ -400,11 +400,11 @@ eshell-unload-all-modules ;; since other `require' references (such as by customizing ;; `eshell-prefer-to-shell' to a non-nil value) might make it ;; impossible to unload Eshell completely - (if (featurep module) - (ignore-errors - (message "Unloading %s..." (symbol-name module)) - (unload-feature module) - (message "Unloading %s...done" (symbol-name module))))) + (when (featurep module) + (ignore-errors + (message "Unloading %s..." (symbol-name module)) + (unload-feature module) + (message "Unloading %s...done" (symbol-name module))))) (message "Unloading eshell...done"))) (run-hooks 'eshell-load-hook) -- 2.28.0 ------=_Part_430784_1989196481.1599957637078 Content-Type: text/x-diff; charset=us-ascii; name=0002-Add-.git-blame-ignore-revs.patch Content-Transfer-Encoding: 7bit Content-Description: File Attachment: 0002-Add-.git-blame-ignore-revs.patch Content-Disposition: attachment; filename=0002-Add-.git-blame-ignore-revs.patch >From 55caa714c1774e57c3b9716e2b632c4158a7135f Mon Sep 17 00:00:00 2001 From: Brian Leung Date: Mon, 31 Aug 2020 21:30:24 -0700 Subject: [PATCH 2/2] Add .git-blame-ignore-revs Git 2.23 introduced the ability to use an ignore file for git blame, allowing specified commits to be ignored during git-blame sessions. --- .git-blame-ignore-revs | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 .git-blame-ignore-revs diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs new file mode 100644 index 0000000000..60d0b5c9a6 --- /dev/null +++ b/.git-blame-ignore-revs @@ -0,0 +1,30 @@ +# Configure git to ignore commits listed in this file with: +# +# git config blame.ignoreRevsFile .git-blame-ignore-revs + +# eshell: Replace single-clause if statements with whens +b535e0b426c2cc7b32c98304de76fbc9df0b17cf + +# ; tiny indentation fix to lisp/progmodes/elisp-mode.el +bf018eefa2a9c33f9f80e977ee085e89df526992 + +# ; Fix typos +a3ca5318760b350309e50adf38fabc259c48ba06 + +# ; Fix typos in etc/NEWS +a6b45145824043eb0c049270ef37e64f1a677b4e + +# ; * lisp/textmodes/flyspell.el (flyspell-mode-on): Fix typo. +f8082a5ccae11508c7eb80ca4d9fabb341985419 + +# ; * lisp/info.el (Info-up): Fix a typo in a comment. +478c2e23620eeda65030458762a843231f7e9b35 + +# ; Fix typos; change "Emacs-Lisp" to "Emacs Lisp" +abca75d2e9b2a406157383dfb7fe3f185e0b5741 + +# ; * lisp/man.el (Man-mode): Fix formatting. +9b35b0c99ceaeca74a16bea86a665ae5f44430a1 + +# ; Fix typo in last change +60cb56e9999050740f4b987ccb806ee6e8227c07 -- 2.28.0 ------=_Part_430784_1989196481.1599957637078-- From debbugs-submit-bounces@debbugs.gnu.org Sun Sep 13 10:07:13 2020 Received: (at 43117) by debbugs.gnu.org; 13 Sep 2020 14:07:13 +0000 Received: from localhost ([127.0.0.1]:51256 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kHSev-0003WP-44 for submit@debbugs.gnu.org; Sun, 13 Sep 2020 10:07:13 -0400 Received: from eggs.gnu.org ([209.51.188.92]:55936) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kHSeq-0003W9-9X for 43117@debbugs.gnu.org; Sun, 13 Sep 2020 10:07:12 -0400 Received: from fencepost.gnu.org ([2001:470:142:3::e]:58404) by eggs.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kHSek-0002uy-92; Sun, 13 Sep 2020 10:07:02 -0400 Received: from [176.228.60.248] (port=2386 helo=home-c4e4a596f7) by fencepost.gnu.org with esmtpsa (TLS1.2:RSA_AES_256_CBC_SHA1:256) (Exim 4.82) (envelope-from ) id 1kHSej-0007V8-AO; Sun, 13 Sep 2020 10:07:01 -0400 Date: Sun, 13 Sep 2020 17:07:02 +0300 Message-Id: <83bli9db3t.fsf@gnu.org> From: Eli Zaretskii To: Brian Leung , Brian Leung In-Reply-To: <1898378843.430816.1599957743795@ichabod.co-bxl> (bug-gnu-emacs@gnu.org) Subject: Re: bug#43117: [PATCH] Add .git-blame-ignore-revs file References: <197409406.192953.1598809591346@ichabod.co-bxl> <9aa79095-18d6-d0bd-18ad-aa5d90f0bb1d@yandex.ru> <1898378843.430816.1599957743795@ichabod.co-bxl> X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 43117 Cc: rpluim@gmail.com, 43117@debbugs.gnu.org, dgutov@yandex.ru X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) > Cc: 43117@debbugs.gnu.org > Date: Sun, 13 Sep 2020 02:42:23 +0200 (CEST) > From: Brian Leung via "Bug reports for GNU Emacs, > the Swiss army knife of text editors" > > OK, please see attached. Right now there are no extraneous whitespace changes, and the only changes I've made change if -> when in the eshell files. > [...] > Subject: [PATCH 1/2] eshell: Replace single-clause if statements with whens I'm not sure I understand the rationale: why would we want to replace all 'if's with 'when's? Was that discussed, here or elsewhere? if so, could someone point me to that discussion? Thanks. From debbugs-submit-bounces@debbugs.gnu.org Sun Sep 13 13:06:51 2020 Received: (at 43117) by debbugs.gnu.org; 13 Sep 2020 17:06:51 +0000 Received: from localhost ([127.0.0.1]:51565 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kHVSl-000428-BL for submit@debbugs.gnu.org; Sun, 13 Sep 2020 13:06:51 -0400 Received: from wilbur.contactoffice.com ([212.3.242.68]:53698) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kHVSi-00041u-Am for 43117@debbugs.gnu.org; Sun, 13 Sep 2020 13:06:49 -0400 Received: from ichabod.co-bxl (ichabod.co-bxl [10.2.0.36]) by wilbur.contactoffice.com (Postfix) with ESMTP id C11186FD; Sun, 13 Sep 2020 19:06:42 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=mailfence.com; s=20160819-nLV10XS2; t=1600016802; bh=2SjvuamwNG8riWqJEYn+6zPsDDsyBI4EvG6kCtpQLLM=; h=Date:From:Reply-To:To:Cc:In-Reply-To:References:Subject:From; b=uhUV7wfM3EVyt231V8wm0tzAcf9ye9Mii/zc92q2tN2KQDU8hjOd6uGc7+F4U6mtW 3WZrYrpB9rr1OFqkH9nzdGDk9UqIf3P8wG35MX5XC3EOVLkb4/Yj4sGZPme/e9+yt/ EMSXrUiOHoVJY6dUB/F/IYumLcyXtipHBdhnq5Yh1D8LUwkRh4xqSisH9LcEETl+vp CKNQVSCIQC5VHsdFJKEqzcH+x4O0KdJrIX8Q1nuJj3di6DGqF3K/DPIzVhwyLK0pf7 QKEkCDC7+aV4FW6PUK/0mYv3UL7sTk+/bigvcJGgQVw5/g+RUiWgARh+RCaMLD9w9n Cr8CIiXHh8vrA== Date: Sun, 13 Sep 2020 19:06:39 +0200 (CEST) From: Brian Leung To: Eli Zaretskii Message-ID: <1670898213.459425.1600016799389@ichabod.co-bxl> In-Reply-To: <83bli9db3t.fsf@gnu.org> References: <197409406.192953.1598809591346@ichabod.co-bxl> <9aa79095-18d6-d0bd-18ad-aa5d90f0bb1d@yandex.ru> <1898378843.430816.1599957743795@ichabod.co-bxl> <83bli9db3t.fsf@gnu.org> Subject: Re: bug#43117: [PATCH] Add .git-blame-ignore-revs file MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable X-Priority: 3 X-Mailer: ContactOffice Mail X-ContactOffice-Account: com:225491745 X-Spam-Score: -0.7 (/) X-Debbugs-Envelope-To: 43117 Cc: rpluim@gmail.com, 43117@debbugs.gnu.org, dgutov@yandex.ru X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: Brian Leung Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.7 (-) > I'm not sure I understand the rationale: why would we want to replace > all 'if's with 'when's? I expected that people would find it easier to read 'when'/'unless' than si= ngle-clause 'if' statements. The 'when'/'unless', along with the indentatio= n of the corresponding 'then' clause, immediately signal that there is only= one possible non-nil form returned. With single-clause 'if' statements, yo= u would have to continue reading past the 'then' clause to spot what the 'w= hen'/'unless' and its differing indentation immediately tell you. > ---------------------------------------- > From: Eli Zaretskii > Sent: Sun Sep 13 16:07:02 CEST 2020 > To: Brian Leung , Brian Leung > Cc: , , <43117@debbugs.gnu.org> > Subject: Re: bug#43117: [PATCH] Add .git-blame-ignore-revs file >=20 >=20 > > Cc: 43117@debbugs.gnu.org > > Date: Sun, 13 Sep 2020 02:42:23 +0200 (CEST) > > From: Brian Leung via "Bug reports for GNU Emacs, > > the Swiss army knife of text editors" > >=20 > > OK, please see attached. Right now there are no extraneous whitespace c= hanges, and the only changes I've made change if -> when in the eshell file= s. > > [...] > > Subject: [PATCH 1/2] eshell: Replace single-clause if statements with w= hens >=20 > I'm not sure I understand the rationale: why would we want to replace > all 'if's with 'when's? Was that discussed, here or elsewhere? if so, > could someone point me to that discussion? >=20 > Thanks. --=C2=A0 Sent with https://mailfence.com Secure and private email From debbugs-submit-bounces@debbugs.gnu.org Sun Sep 13 13:34:30 2020 Received: (at 43117) by debbugs.gnu.org; 13 Sep 2020 17:34:30 +0000 Received: from localhost ([127.0.0.1]:51636 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kHVtH-0006tB-Ny for submit@debbugs.gnu.org; Sun, 13 Sep 2020 13:34:29 -0400 Received: from eggs.gnu.org ([209.51.188.92]:34962) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kHVtG-0006sz-58 for 43117@debbugs.gnu.org; Sun, 13 Sep 2020 13:34:14 -0400 Received: from fencepost.gnu.org ([2001:470:142:3::e]:33569) by eggs.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kHVtA-0003SR-1i; Sun, 13 Sep 2020 13:34:08 -0400 Received: from [176.228.60.248] (port=3281 helo=home-c4e4a596f7) by fencepost.gnu.org with esmtpsa (TLS1.2:RSA_AES_256_CBC_SHA1:256) (Exim 4.82) (envelope-from ) id 1kHVt9-0001tz-GG; Sun, 13 Sep 2020 13:34:07 -0400 Date: Sun, 13 Sep 2020 20:34:10 +0300 Message-Id: <83h7s1bmy5.fsf@gnu.org> From: Eli Zaretskii To: Brian Leung In-Reply-To: <1670898213.459425.1600016799389@ichabod.co-bxl> (message from Brian Leung on Sun, 13 Sep 2020 19:06:39 +0200 (CEST)) Subject: Re: bug#43117: [PATCH] Add .git-blame-ignore-revs file References: <197409406.192953.1598809591346@ichabod.co-bxl> <9aa79095-18d6-d0bd-18ad-aa5d90f0bb1d@yandex.ru> <1898378843.430816.1599957743795@ichabod.co-bxl> <83bli9db3t.fsf@gnu.org> <1670898213.459425.1600016799389@ichabod.co-bxl> X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 43117 Cc: rpluim@gmail.com, 43117@debbugs.gnu.org, dgutov@yandex.ru X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) > Date: Sun, 13 Sep 2020 19:06:39 +0200 (CEST) > From: Brian Leung > Cc: dgutov@yandex.ru, rpluim@gmail.com, 43117@debbugs.gnu.org > > > I'm not sure I understand the rationale: why would we want to replace > > all 'if's with 'when's? > > I expected that people would find it easier to read 'when'/'unless' than single-clause 'if' statements. The 'when'/'unless', along with the indentation of the corresponding 'then' clause, immediately signal that there is only one possible non-nil form returned. With single-clause 'if' statements, you would have to continue reading past the 'then' clause to spot what the 'when'/'unless' and its differing indentation immediately tell you. To go over two dozen of files and summarily replace 'if' with 'when' for this reason sounds way too radical to me. I have no difficulties understanding the original code, FWIW. Is it just me? do others think such changes are a good idea? From debbugs-submit-bounces@debbugs.gnu.org Sun Sep 13 13:57:43 2020 Received: (at 43117) by debbugs.gnu.org; 13 Sep 2020 17:57:43 +0000 Received: from localhost ([127.0.0.1]:51645 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kHWFz-0007Ow-4H for submit@debbugs.gnu.org; Sun, 13 Sep 2020 13:57:43 -0400 Received: from quimby.gnus.org ([95.216.78.240]:47998) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kHWFu-0007Of-BB for 43117@debbugs.gnu.org; Sun, 13 Sep 2020 13:57:41 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=gnus.org; s=20200322; h=Content-Type:MIME-Version:Message-ID:In-Reply-To:Date: References:Subject:Cc:To:From:Sender:Reply-To:Content-Transfer-Encoding: Content-ID:Content-Description:Resent-Date:Resent-From:Resent-Sender: Resent-To:Resent-Cc:Resent-Message-ID:List-Id:List-Help:List-Unsubscribe: List-Subscribe:List-Post:List-Owner:List-Archive; bh=ASfazLAu8N2AtHi7YIzn/EJzEu6AFHfMmNxPR9+bCkQ=; b=CzfV/MTr0gr23t+ClcYCUdpdRF broi+v4INcnvcwCEpwpdL8T2+jSpokQi3Iao7/vwdy5MCiUjeHg3SwYSwjvYyiP3EJC81mzI53sUn vb1IzUkgWnmI1tcypuyd4pUdH/yH+7dRwsTXU8X3xhK2yi1sVoIP0ssfJQ6APEswOk3M=; Received: from cm-84.212.202.86.getinternet.no ([84.212.202.86] helo=xo) by quimby with esmtpsa (TLS1.3:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1kHWFi-0005su-Dp; Sun, 13 Sep 2020 19:57:31 +0200 From: Lars Ingebrigtsen To: Eli Zaretskii Subject: Re: bug#43117: [PATCH] Add .git-blame-ignore-revs file References: <197409406.192953.1598809591346@ichabod.co-bxl> <9aa79095-18d6-d0bd-18ad-aa5d90f0bb1d@yandex.ru> <1898378843.430816.1599957743795@ichabod.co-bxl> <83bli9db3t.fsf@gnu.org> <1670898213.459425.1600016799389@ichabod.co-bxl> <83h7s1bmy5.fsf@gnu.org> Face: iVBORw0KGgoAAAANSUhEUgAAADAAAAAwBAMAAAClLOS0AAAABGdBTUEAALGPC/xhBQAAACBj SFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAIVBMVEUSDg8uLB9VWBqn pKJbWFdAPjZ+gj7o5+fGx6mosSn///9fndN1AAAAAWJLR0QKaND0VgAAAAd0SU1FB+QJDRE4Ay0J bZ4AAAGsSURBVDjLtVOxTsMwELXTgJrNjqhYqQcktkimuGyFpipjoVQwVizAiFy4MKKAQrdSJOD+ FtdNG7coQgzcZN/z3Xv3bBNig3IT5N+CClYClJFSVgbslAH1Mg7xG1A5WgNOOfGHnLSVXpfL2ckB kgwefrZrSxxkMH5bz1cSiRnA4fAHABbAVmVFoJlQpYcZJO8j1Wg5QPDhgz67ThrXAHDvAJv4BcDo PukaYOS2QvyEyCyqANolCRCxMUt0VeJSEA9xahf8UkYraqtjnFvfl7iidxui+X4P0b0cKpt5a3Hz mj65gFxwGsF3RT6Wcn++9M0gRYWfSpnNS/pmkKLTRtoEsEAllU1ncmrO2cFn7vd6jqoNrZIJMYK9 LHHzhLSq5u6eL3iAMKJccBGGbOFvIh+6r7f4qT1hg+X2fiVNrWCMGNkfxPOKADM9Ax4R3yhnxdfy PiBVWuljxIk3vRJiyc76NaWzEZl65iXXw7qrTL1c5ENTSglbuk8h8u3T9cSuCMXVZFlxkhtMQyF4 WB+S/wxKmLPbigfnnU4n7sRxyHfcY8afmnWJ1wbsTwxFfANzvmocDYhvGgAAACV0RVh0ZGF0ZTpj cmVhdGUAMjAyMC0wOS0xM1QxNzo1NjowMyswMDowMNFspSgAAAAldEVYdGRhdGU6bW9kaWZ5ADIw MjAtMDktMTNUMTc6NTY6MDMrMDA6MDCgMR2UAAAAAElFTkSuQmCC X-Now-Playing: Various's _Additive Noise Function_: "Five Times Of Dust - The Single Off The Album" Date: Sun, 13 Sep 2020 19:57:25 +0200 In-Reply-To: <83h7s1bmy5.fsf@gnu.org> (Eli Zaretskii's message of "Sun, 13 Sep 2020 20:34:10 +0300") Message-ID: <87363lh856.fsf@gnus.org> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/28.0.50 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain X-Spam-Report: Spam detection software, running on the system "quimby.gnus.org", has NOT identified this incoming email as spam. The original message has been attached to this so you can view it or label similar future email. If you have any questions, see @@CONTACT_ADDRESS@@ for details. Content preview: Eli Zaretskii writes: > Is it just me? do others think such changes are a good idea? I hate one-form-`if' more than anybody, but I don't think these purely stylistic rewrites are a good idea, as it means that "git blame" and vc-region-history gets less useful, and applying older patch [...] Content analysis details: (-2.9 points, 5.0 required) pts rule name description ---- ---------------------- -------------------------------------------------- -1.0 ALL_TRUSTED Passed through trusted hosts only via SMTP -1.9 BAYES_00 BODY: Bayes spam probability is 0 to 1% [score: 0.0000] X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 43117 Cc: rpluim@gmail.com, 43117@debbugs.gnu.org, Brian Leung , dgutov@yandex.ru X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) Eli Zaretskii writes: > Is it just me? do others think such changes are a good idea? I hate one-form-`if' more than anybody, but I don't think these purely stylistic rewrites are a good idea, as it means that "git blame" and vc-region-history gets less useful, and applying older patches fails more often. -- (domestic pets only, the antidote for overdose, milk.) bloggy blog: http://lars.ingebrigtsen.no From debbugs-submit-bounces@debbugs.gnu.org Sun Sep 13 14:49:16 2020 Received: (at 43117) by debbugs.gnu.org; 13 Sep 2020 18:49:16 +0000 Received: from localhost ([127.0.0.1]:51691 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kHX3s-0000AA-MC for submit@debbugs.gnu.org; Sun, 13 Sep 2020 14:49:16 -0400 Received: from wilbur.contactoffice.com ([212.3.242.68]:55932) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kHX3q-00009x-Rk for 43117@debbugs.gnu.org; Sun, 13 Sep 2020 14:49:15 -0400 Received: from ichabod.co-bxl (ichabod.co-bxl [10.2.0.36]) by wilbur.contactoffice.com (Postfix) with ESMTP id 5B9B257B; Sun, 13 Sep 2020 20:49:08 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=mailfence.com; s=20160819-nLV10XS2; t=1600022948; bh=nUdLMcrP0E81o9TI+tWzR0FjREYYlQbrrojlQiO9WWg=; h=Date:From:Reply-To:To:Cc:In-Reply-To:References:Subject:From; b=gMe+Bs6mdDWpk5Ov7ueB6s8I+iL0ZBK5CfUWPNFTIxCjipplfg2ZMRGZH+irfGy95 tRB7pIrnCYY+GHwk+9ow9d/bU4tQH7U+OztEEkhqX2m79cz/udn75KIhLV6514j9iA cRVe9iCHdkipLmbAxlLaEP7f3f07TqcJtvKxpafwGwNRAjlWJWWNp0YPdCZDfTbnbf BrW154owqTdxsx1HWaB4hG9QWTsuk4DfEKQbk/nwdIDvMwIa1WQVNqhdOFLo0Xetre K7Hgwb6aS8mNN3Ywan0aRb6N2reuYxcVdLwuw56vtqFFGZcQW9i3SholvGK1+YA6/k Zwbbb1u3MhVOw== Date: Sun, 13 Sep 2020 20:49:06 +0200 (CEST) From: Brian Leung To: Lars Ingebrigtsen , Eli Zaretskii Message-ID: <1357196034.463572.1600022946152@ichabod.co-bxl> In-Reply-To: <87363lh856.fsf@gnus.org> References: <197409406.192953.1598809591346@ichabod.co-bxl> <9aa79095-18d6-d0bd-18ad-aa5d90f0bb1d@yandex.ru> <1898378843.430816.1599957743795@ichabod.co-bxl> <83bli9db3t.fsf@gnu.org> <1670898213.459425.1600016799389@ichabod.co-bxl> <83h7s1bmy5.fsf@gnu.org> <87363lh856.fsf@gnus.org> Subject: Re: bug#43117: [PATCH] Add .git-blame-ignore-revs file MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="----=_Part_463342_410230257.1600022640969" X-Priority: 3 X-Mailer: ContactOffice Mail X-ContactOffice-Account: com:225491745 X-Debbugs-Envelope-To: 43117 Cc: rpluim@gmail.com, 43117@debbugs.gnu.org, dgutov@yandex.ru X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: Brian Leung Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" ------=_Part_463342_410230257.1600022640969 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable > I don't think these purely > stylistic rewrites are a good idea, as it means that "git blame" and > vc-region-history gets less useful, and applying older patches fails > more often. OK, I won't submit that commit then. The other commit I had introduced a .g= it-blame-ignore-revs file, which allows certain commits to be ignored durin= g git-blame sessions. I've modified that commit accordingly and attached. W= ould that be of use? My FSF papers are attached. > ---------------------------------------- > From: Lars Ingebrigtsen > Sent: Sun Sep 13 19:57:25 CEST 2020 > To: Eli Zaretskii > Cc: Brian Leung , , , <43117@debbugs.gnu.org> > Subject: Re: bug#43117: [PATCH] Add .git-blame-ignore-revs file >=20 >=20 > Eli Zaretskii writes: >=20 > > Is it just me? do others think such changes are a good idea? >=20 > I hate one-form-`if' more than anybody, but I don't think these purely > stylistic rewrites are a good idea, as it means that "git blame" and > vc-region-history gets less useful, and applying older patches fails > more often. >=20 > --=20 > (domestic pets only, the antidote for overdose, milk.) > bloggy blog: http://lars.ingebrigtsen.no --=C2=A0 Sent with https://mailfence.com Secure and private email ------=_Part_463342_410230257.1600022640969 Content-Type: text/x-diff; charset=us-ascii; name=0001-Add-.git-blame-ignore-revs-file.patch Content-Transfer-Encoding: 7bit Content-Description: File Attachment: 0001-Add-.git-blame-ignore-revs-file.patch Content-Disposition: attachment; filename=0001-Add-.git-blame-ignore-revs-file.patch >From 46b647d2fea41b3d0d3fcd2fa6f92795da967d75 Mon Sep 17 00:00:00 2001 From: Brian Leung Date: Sun, 13 Sep 2020 11:42:31 -0700 Subject: [PATCH] Add .git-blame-ignore-revs file Git 2.23 introduced the ability to use a file to selectively ignore certain commits during blame sessions. --- .git-blame-ignore-revs | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 .git-blame-ignore-revs diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs new file mode 100644 index 0000000000..52cf967eff --- /dev/null +++ b/.git-blame-ignore-revs @@ -0,0 +1,27 @@ +# Configure git to ignore commits listed in this file with: +# +# git config blame.ignoreRevsFile .git-blame-ignore-revs + +# ; tiny indentation fix to lisp/progmodes/elisp-mode.el +bf018eefa2a9c33f9f80e977ee085e89df526992 + +# ; Fix typos +a3ca5318760b350309e50adf38fabc259c48ba06 + +# ; Fix typos in etc/NEWS +a6b45145824043eb0c049270ef37e64f1a677b4e + +# ; * lisp/textmodes/flyspell.el (flyspell-mode-on): Fix typo. +f8082a5ccae11508c7eb80ca4d9fabb341985419 + +# ; * lisp/info.el (Info-up): Fix a typo in a comment. +478c2e23620eeda65030458762a843231f7e9b35 + +# ; Fix typos; change "Emacs-Lisp" to "Emacs Lisp" +abca75d2e9b2a406157383dfb7fe3f185e0b5741 + +# ; * lisp/man.el (Man-mode): Fix formatting. +9b35b0c99ceaeca74a16bea86a665ae5f44430a1 + +# ; Fix typo in last change +60cb56e9999050740f4b987ccb806ee6e8227c07 -- 2.28.0 ------=_Part_463342_410230257.1600022640969 Content-Type: application/x-gzip; name=leung.tar.gz Content-Transfer-Encoding: base64 Content-Description: File Attachment: leung.tar.gz Content-Disposition: attachment; filename=leung.tar.gz H4sIAKZRv1wAA9T8Y5gmS7MwjN5t27Zt27Y1bRvT7mlO28a0bdu2PW3bmObptdbzPHvv993fda7z 4/txqiKzojIqMyOiIiMj84asqaudOb2DiRng/72D8etgZ2f968rEwcb036+MjKysLIwsjAAmFlY2 NlYm5q8DwMjEzMTCASBk/H+Rp/8crs4uhk6EhABjJ0NLc5f/5+f+v9H///QgUxQVp2OiZ4Um6y/o 7+hv6s+GZiZkJLQ3soLm5WWQNbUzd7EgZPkqUWYQt7RxMXViELcxdDEVNTW2NzHl54d2dnEyNbSF ds/M0pWK2WtD6nqqvuYS/N4SFv8jxP+kCYy0GQI2ViRWpWle5nqTzE/gd9kpTXyyFziIu00YNbr1 1sLhpP7H0+36YIHfbNt4W/v41af3n3EC+k9LjcmDJ79ub28/rUg56z30rd2DVwF6P97zwfTxJ7/3 h420N4aWs3Ivg43F7uH3F6ut/M6QJ/furktLseeOIhqZtjr6G/zls62uzz8HH+8HKYYpB7bdA2yw 7bRgH8hVS12v9h4g5h0Pm8P39k/l3xEMX5odwuiLFOCYV6wDjquZ/Dpenmoo9vvT6UO8PlqCyQyz urqrTPca9n4mvY7H2xfUJ6k1g04W8XTlnCjEabndHXqaGPWR4If9qGYCojOB2Vyyj0pmUrUqMs2N dS8nDTbfxY65Z5DN1jHuvE4jkI+kFND9o9Vy12ayzW/At+vzEBUH5EY13bBxthHoruthkKOK+ae0 jdJW15eVF9qKqbIqBvdGnVGyIDINAbKESA0rUT25eOzR2kxUrNhoKVkdM0xUa6YP1eBpdL9UogtF bIPOHg9G3UNMqFBXd/0PvHgXXiW/xo7aXFJwOZHZlFIJwj4I2iaQiAKZ+Qb4qJaPF+bj6MKUk/B2 f+WmnKdyqz7jxhLZu/5z7eMJiw80dRj3AKyRaZ5aLraDMNROs/2JBNJhkWow3tajvVfIy4h0JHqf D7uWOdbVDOIf9VTEsSCpEWltIVaitwpeSdj4xaDsuZK232QZFqfiNPoMZ3NIlR72Tyg7sglZTVC2 SWKuD6M2WbduUKN9VpvkIA7fdcDTOBz+HOuoubZf/nGInlIfYcqsxgfLTrtmy2KsXjWdHLX83j+O PRnzIsOnC1rJbDVZgZ2LkT8wXbgupYGwasbiZBz7g6vP3GtKqbJOi1fww4pjOoPYcnrATLApDVB/ SXlgPdcY2WdmeuC7EY5JQ6zaSYpcObFoSECcx4Otf/RhD9W5WlLcdmdm1DMWhWPtdgs6SV/grAGL XmBRcgzRpU5ms1POb8m6MubNQQtavFaC6MG2uur5/NLPLI4d9qwk+/0G9PtAAZRovIFISsOevnrX 1CVOx9PZ7omvWvfPpdjveqHeu0brFK1dB1C56CSbV5SnxdGXTu7xk3k9hgnns5UQXR3U59TZ9Zf3 GJ2cF/mzq9dOP9yoDTfvkZPZ1jQi+MPnAyX71BY6nOoERyZU7d2jVpA9GGF0kUlEfmE+UbJaymwg nOcyqIXpoOZ3mubcCzK6QGFdYjTWKJdYrRDLywnxqoU3TdTfWAJltKdEwIlCfRtNVG9OinOM8NWU RahOVJmInCqP8c6ghQ75tZYnKxsucZ1jJFk8S5PwmCVdoKfCPDu63xp+yY06LrRQJ62IIRAfI7DF ev5he8ZSYCSs67jV1Go0GO/isTOOYs5eFlNf16WpCG7zVNaBC7lxJqb9SxgaT5HTI5Y5IHAvDMpM q55fqFAzL3MnCWq4sk1npZWCJ8ufER51zHPdUDUwuKjpwCnsD7oyTjLW+n5rD600deT4jyjBEtXA fj+u9ABzTfWVVCJj0gRhnAHJeg4TbB11EVUiJTFXQNFEKaedG+Jw9vVbBdrPuZj0jDRUgdzlvMzi 1kqKl7oK+zNVA14oyoOmzFXHLmsejTEMuYSwXdCO6MVxaKmocCEyQh4tMs1R3YoGxHWaEB4v0/E0 27nOoRl9SEO1Ufk8Y34OWjKxKslNMuOhBOa3Te4DUXBHIDN2v18iuCQlypI9MbwD7omu46HC8iGK 7FNBiEfRgQk/Z3175X16SNKaHsNTk8v2kqO0fqWuF99iJeeik6EhCTA4wA7CSSPNnnCSBBG+UtxA m10tpof3vedIOD3apllpjpw2coindiqsV5YKXfv+QmJXW2WiWPkOXga8WiY6NKYH8RCK8LANsP2s i6pydALPu662A60qS1SZYqoG5uVRW0VJ+S2TeySO1d8Wlmuby/3nmZwf7we5IBXwzzI9NuF21DLP X/cU1b+Qwap5oINfKleKrwoFsU9iwAZHpRQGZ84DMYVZl7yIIqdy5LVopSqSSd2GyjYRHtIT6R3/ xMbbBz+dkVZGZZI0UmP1IQUnRnRqM69ISu3rvxtGTLHkmyQwyLhVckEe/3TkoU0bvGBygueMWbf+ 86AkmBNbDGzVIEjkph6X8D4P+72Rz2M0uZqlhmj8Jq3njw+e9MdRLoL5yitP4n0XNga6zMUspzIX Yh//p1KUF4FjQSFLhFG4z/7+G4meInv5Aj7KTfUJjkBA75/KGB4Zf9wKb1pgsUUvvcoyd1e+IFTt whqy4piWmOqqE6hEZCYteggppkKZzpFbOqyRRM3zmBwVRrRFiimmQi1731PcFI9nqkXhaaCJIazu xTg0HCYJoAle3SwVuN5FGzJoF48XqVGlAFbqRCnyfBIiqN4KZkfkFjlmFaPsoMyAaFHTfFFv4ZYU mCB6X5RNJZONhAt3ZLjvxFiaqAXbRCYZxzoEUfe1V0CgeYTXhh6YTqh+poiIvCgX8gcsa0L8RDLm MdVWAeseUoqLRM21+jxONrXXA9YGj2T52joEdPiWCxIt9ZNTwRqPeGOVqvtJNWB2qLZau3+mkPOd y5kEZ9vs2Q/ZkYePN0bxCzIiuHpLJO1r8zNd+r7mSVH/lfKJMQstwKHa8/Wd7sHmtwBf6lxDAu14 qUv2AyxNhNzDknIeeLRyJVCWS+iJ0jooDEj/XuCOQWPh/hgrt3PfNr746aw0C/OHR4hAt0z3FDh+ bkURvTGZ2t6HQUCOTCn4CDoKzLGZUgnOWTM07DWW5d3vxLEilZ7gmHVndmBTxjZrj7viPjVhr6Uc ldX7sxX67ISLilCyTHU00HF8JK2StRuy4y6omkOy8C3Rl421h5407QhCits1CLQVR4B+ICDEjoM3 yE7km82QVuFhWaDVLIKqXNbM+bFvveXPBGahNb3jeVnWQL6YlDyS31fEHEfttjZy5IhGGsGVOcu9 njvVJbpQ8Twb3EnKzbBRn2XcyPzNpFeUH2DeXBoZazc/H8XYWlVlIrRzz+5lXF3IGp8DdpKQkini GrFCsHRPxBp+qX58jpM9LRE06a8CKJGD0A/BXVLbwCBltA3q/hSZOf75JlJotxGBj7zrb3sTQxBs Dp5ePR3DLDBaU3t1rlNAti0DSXtLq7lZ813UKuSeXgVUKU9lHfs73mgdWEkTRFkJ37MZ6A/C/oGY vNSrDjXrCy14AIEcb8NmPtxrQ6gjuZ8djqefAMuNojIjMQXlNHi+zR4idnAjUmJ1+dWVbUNJIcb6 ii8mD8K5hMuZ/zhafFHKtFzb1vDMeoX7Uh9p3UsVzCWnYa5zbjKaAH4ikjr6eEN/Yt493hovSeOt 5xFVU5XtB2VWAW8aMsOIH6NCiyW0AMukXZQIzB9QMKZClx7lNQiQc8sPh/Oi/eEcXZIaGbQS7bvD 6STduOBi/t4CsacWWhFIv7iopIZ9K/FCjk4cbvGfrKQyazBy4Xx38Lhqg12qR44ROC85m0/9rpOT 7osZT7zETI+FL/jusUhICm4heFKxQlFlbkohpkyE8HWGVZGxrTfMWM7cmvk3gHZEE+GiqaE6u7w5 H8WjrelZRMr+57EWx+9SP3UAo6441H6g9Ll3UoLxu3H7T6RQj4O8JcB1kdXusgFAtNpwILl/BL8b 0ts4Usf1RmZ5hL73q9VlVn17YnR9gJKgrHTK28+BhAwWlW1deeDMf3LXNwE7nvf2tWAur/Jk41hE u5+ECM97bShDAVk5m21wcEuQLLFWAqbizmOKuwuVLCGFnUlHX29+QtLAdATRDMaJhwbapKPkc5hZ zQVsSpG5AOUeMZRV2cCeZEU/y5Mt2faXDJGSFC9JMfTomgQTud8gozJ5PHrgXmE9ZEoaPEawvqK4 ePSlaYOTDfK13YRvwvaY3LBIGA19V/nWNe6ozueJ+DRwLV0xH7XhGEAbGMHJuL2Qtb/IDo/amg9G EtMfqZFaGeu+BPVIUk/lgmOOBsMX4Sn0noa2bnhRdYKZaVfRW+pB3ZuZvqfHuAWHbkQX9Hv9h/8l t9ysIcmJq9zFaAN+ZMgvz0uKPPPvHF3oYCxBRVpkJMTOZb4av1AoY1THDRc4Q63clYbHjxvmoSOr ZSfL6Qj3csNoQO6TzcLw7OUJsmryF1YgjHj83cdQf3toe/wAY4sU4r+mvJXa/8HFPoPcp6tIWSFB eFciXVTKI0vGfOYAX/pTLcGLDLuzkxdtfjIyEF+BeMk8vjvS/uoPAGTKN3apB+QNoQ+zpnaGmDic DrlcIfD5evCFnTLj6kVFZH8VrLw/dbkYOk2miAYqwjNGeNc3NLyfc53i+xonMXvdK2XGuP4d5fq4 F2xC2gDWra/FT1eHidEGyGvDeAveNIvZn56Z3JljJpCBslOa7JYrsbGl8MgDQKS/lCcVtFpkdXsE Q+2yS7aB+8dms/ixbfi2BwP5M11E0hCoT+bzuvaDRdSZCiow+92OnWHPhLycHX6fEuClDU/gMKMu IxluqibUXC9l9UQ1AY8sjll6gg8748/l3KH+usir62KDMDV+wdcWZVsqmS5cbDeMBvQ+BQrbxsMY 4OQ1JUU6L/ak42y2sdRu84gv0B6lFKx5Q0bGGv70nmWmQXgChw2554xMjDoyXS/0K9ray4UcSf12 wMfzeBq7GBaWUbOeUjoYv0kt0m89AG3g4dVqfQmZLx+6nj45sghxtCxh4pktncWSvyBE9xYR5ZtW a7JzcmrXk8bNxpeUD+Gcj7BP+XiOq0oY/25h4sH5JGmvtzWEwlfwiMc0Y2/vAxeAbY1nu2vlBRRP o+iH425cqAi890tFDgRaeEajm1ut9wMKPplLlM/CiTrczNvZl17OI7BKfZVeCa3rDZKz3Zm+R2Rj x+G7+aH9PtLbTyelq0PgpZ65+PAeAhZGnzSJKL2lOp53qCCqwJpDgT8yYI3NgpEz4KEKtY7loVbo ovIncZLmR70N7bNRxfRLR0MgxO6CGCHjFj0CksVvCYr2MfnHIzUZHe2wTBwTK1nuWnoEMAk3NLia Z1uJ+PUhUqECPieai1v9A1lyh6PwfKZL2Xrn5BW9HOEZAIaFo6FDHp2XD1zPBQjB78iE1dYIvCfA s4ZDdpCijlYM/dqsfuZ31QV9t00eBc2vr46D+tz71akW0ZI32jS/E/a9cD5Dgn6BKYrvSFDwy467 t1cdcvrlR+I/geJE5v7hQTUeV4byD4GCo8V4c/pzER99Se+4vmmEzzOa7WGl/hGr1NWCrlyII5Rc ndL9+XI7LPCOTd/8qc9c8gkiiljXD21qZ/KvJfcX9tcqHZrlX8t1Fi5W1v8Usv7XGl7Vw8GUQVPB yMrU2IVBxdXI5a97KVtDc1MGDUuTr9U9ExMzFyGDpKmluYULIRMLEyGDsKWLs6Kpk4i9rYO9namd CyEnIYOIvY29k4qDobEpg6ipm6WxqbKE8L+3BERFVP/ZEPjPhgE7FxPbf+0OfK58bgMQpcWlxAFA QEBQ51DnAMDnOkAEAAIM/Bd8HaBfAAYJBgYKCgYNAQEOCQsNCwsDDQMDB4+MCAePBA8Dg4iOiISC ioaGBouAgYmOiomMiob6VyNAIF91QMGgwMCgUOFg4FD/fz4++wBIkIBAUEsQIGIAMBIQCBLQ5wAA DwAEAAb5YhfoP3slEJBAYOCgIMBQX2QcIAAQ2H+jfR3AXxKAA0F8rgFgQb7qIoIgAgBAjQAIhsEH 6GWOPHtp3OopAMAcwEWpV45DU17S6eyGfMTRcJ6ET/I87Rtd1PVW7KvGINYtX94Xlh7TdTe/YMmH o5C6yelbb0HTvbbH7Oy/+dUN9UVeflyDzrIHRzN/GZ0+GnrZyuTH5AgTLwuhWKTB+VJJ22n97GTS BQttjJxIdeBC7G++30M39/wPZeNJjUpW12hGY+f3MGF6TJhbmC/ULY1abnlldOoiWVfem2lc2yqU XmWFtS5ZVckbbpZxop3NgSoLyxk82C5VSz7lA0o8tR4IbwwUhUqlqpPEqgOj7dnShdakh7st7IqB xFbcbF99PChZ1SH+Sh/6wEAvrlRCLivv/V3vMVaprp8fwTb/FRGftMVsApHsEYd3WxsqkNkX+Ims XUTFZBKXquc02pNNOfLWLrGiGTf+yLe8BM2SqYq4B7yzImBeNVxz+KGV9Se5Olckl0tT6PhMMrQh Oy9+cK3mnbJFqKVQl+UtAjetvbPvnMa6tcrS+yhF5YZwrGExo29lfG91ggAKAyA9kvKbR8x8uCSL hP+soK19zYh8fq+Fa9Vhkkg6VDI7Ejmo1fnVqNeeJkITlrPpG62xk6L8r3ebnxIdLbYgx7Jom44B U+ZUbPVSFOG1VD5hTi7u8F1DKnK6Nz96roLFEeUTIEKt12Y11CoxB6u+WLkjbtlywoTVIpVJfyfu FO8n4vdLA56+SVnc0oOLCeti4DHXEUBcVupTWkAXNbiimJY2wi5E8L161odarClH6R5vcSDQnGwA 4gS3WXn3E5DVLF8uc83hxSltGxCtX3GblhV2mlkFUu7rJ/0NOPXpDcLPoLN2tx/0qA0D4+2iK/HQ PbAxg/hEvFRq6la3Mmonz7pgND5n/URLAQ+2YWZdfWn45DjE5LBcLiGIvkNP4q7pVq2qF/mCsKZX zQ+iu9egs+mrsaAD6Dj81/RutLzxm7W0s1trzM6WkUkWLHISRqko9VVHxnCH36P6nNeOJym69D6M tbWu6kSoZnbU6mKcUMLR47VvtrQ79MbMt5HmakvWCgaFycRWXvadbmG/w5weWI1h1/2EfbKnpUbH XpkjW4/KzA4UUufu0yPDo8jzCaVKRpCtmEHTIwsamV6gTYAkGPBwI0qmVbampTzzDn+ngANl/ywr n/SsqS3Aa8q+84xR+QTwmnWlwxg9Pvo06ugQ8FQpViwSaFy1DeZJTS6eaxM6EOifBetSS3EKE8yM ZGCPNUhhtbWvTl42ICwA+P0ERR3ZGlkc3z5etzjd+J6iG94EYPV1uMLbV8KeET0rfIETRxQnw6ru ESYdaq/jporZD4gD8o02QEbPSGeAxoy3rvHefR+HI2ARwawOzbX9QVz9SsRKq0+j7DgtdUZpmASr L4AbmdhqvWO0rwQ01+Z0+KSi16HiM95fJgbVvY5HI66OObqgsioY2fSJUjoQv/PaTz3iF3y4rVwQ QA8erE1nz5oeubKEX/i4bgY/apNmDuppEzrpuTG/C9wVqHpeAxwALNFhRhTTxp8A0Tul9ldY0Pvg 14eeRScUC12RuScibluJbyqoh4wfATOcOFuMRm9/WTaIwMz0UfE9vb7ADPmeIKrTzexIW1iRp795 MQ3QaQ70HdZoXCbcwRzKtV+6v4OrrZZqRIzIwfEag6wPYb9lmrfaKg2DkdoKOkVwJPemW/6X+Qv8 UidmTx4qr1M3GyivoZVmTtCtBGOJ7GeCwdBAAtyPxdASpy5HhDXp65SjaElf4akcJA7uCmdYammp E+zumNm9pdT/TEJDhwoqWpGKaB+M7wf/cqOyXh8g3dWbKzeGAYBnRYZjMrGI4r0j7mEf7PqtsGft qP5V6gSd4zmxiQCyP1qe8+0BVzIcBOIXHDgF/rRN/q0Lm7dflmEn6wPKt/30jES/HgGL8Stx49I0 w/PB6hOQrS6VkfoJWN4/wK5rHztPSaqlPodBrlrZoW8759EbdZz7BMCGsYYvqEVEoBjPcv+e6rul bwca5Z4RnQVr4TAUpWidSQMi9o/8MQVy8PZe5+oJfmJCRMObUtY4Uty8sfZBw5cnbxwxbAVPtRYY Pm0BT1P/zr3ETFXPCWpOjvxEt3CEJzitFCI0clJgRBpZxQ5wyvRuEu0iSU/BPRdP0XUilmmBjKk9 g7YilglqRyrsEdVKYcbVsMykx6TqRoAhRX5DKqwjP6f5rsFiIt+9kdDoHrOPgVvNz0NqNYWSxIHl hHFEW0VBNzkaJI2lq8sMy/IDEN3U6Y/s7ygbiBujuxdnUzCNESJt3I8xXiC16P6CW1oyJcNZxKxC iFR0VEesgXB7JQgTbg40cHdb25qJIUAfPaCVwjI4QOWCRHCoPzoE8c089KKlQKoAA/6XLqSOpQqn 5jeWyG0A1pAIAByEnhvLamhAI1RBC0Xr9c2zwll9S3Nza76UK/RQKooUc81PZTRJ+IG36ldxCi6f k4kKRSu4L8r1NlYPAKuPTuY22SjARPp4SUr1mwrtNkj2bhuusIddn7XF9ymNg58qmUDJnFNcq42v QCDBe1lLDipaPSBAieZkhefp+s3tzu+Ab66EWMMMI3m6lanlOfDzAtlzu99AOEcwwR0HrpA/jql+ ABXuNlvkhNXVUYFWZpGfONQZlwLMI47nLnuocgAgR1iFf4TAXEMTSLsFiq3vvoRCIEBNKcDdLpK3 Nklh9xhS3QRwVi1HiIYL2FuhtQW3JAf/zE5ddm6ngBsjNhlOX+/nMHZs8XTcMVvrE93Un22nzDLZ j25UNKOheI0TydmqJ+ELrVOJQGKu3LJC8VnphPIQBMCa/DUswUjaE93I0ze56hezNISm7mUCoC1A gvz5WArk5F/vOqUnVa2h9kKMTmw5U5IBautiGsab8nwxeCvtauFRdlY8HOx7pJnPIDevbxB3H4MO 3elXgk219uWTLBQVaUStieIgjT2IXx5+UXT+vrbj2je9QMfT3iKt6SSoYmXEePo4GIka8WI/lR59 6IgNx+P526m+gHHWoZEMCAybbV4qiVaPRswKj7w53jaYXsYOVBd9Sj1yvSCsecJe0pxlUOVvW4Jo mlSEmcVyGVm6PQ4edkcKbqCJ2fVBsIHFkblCtvpxf+zv3hRuNB0sxD8B2BsJWSXtXhIhDNbJXdPc G7KDDY5r3Q210Y1g98zJajixx52F/WCsAMAUIIKMs7Z10e51JuJy8Fhm7F9zMxXYVqGjS5PPWnb+ vJ0YI54kmHIWE9DAwrpZzA0Nx5SI9joEhtQ6lMc3ML0GxQz292VT/SP92quS+t+iG1mZyM4/EIav rtGE59TaTXGEZAs9+FPZrE2KNK1MEjIgrH8QwpcnPYnOT9HLs/mm0zcq4qVZTZAepfUIsIYPWRCf 8NZeNP8p4wUxshSbxDhFpgQgNszDsJleZxL+6VHk0cgEAGmYPQvbRxSeD1TMgCScMQ0uyHgok4eu SfHtRBjkBl5c2DZU/D4CzTyGYIGajM30+jNV/Pv5tVIC2ZSrZVLre1qfmdwPlq+TGegHAAvkrxPA DABBKglLaruI1K2TnmQEgBAaE34DFzQmNCqN/L3W88D+hQKMUzgvKF6TfPPduInnx0FKAN+g9/TD t8STK3Np6B5GiUOBnoFbVoHKVWldswYKXGFhQkYQO+BFVq5oY1vwoqW4Jkx4Iv11aQGTzR18KsDf jTGyPiSOe5jQIDNuk6Nho4UBQ4LVTjODy2r+L7rb4IJ/1G4iUoWHkNjccO61PFYA4AGUWE1ZNXwq emS1EV0DAlJfMTMzIuArWAcCBgMG/yuy/svKQUDBAUDAEBiE7IioaOhsjCxIyChETILMrMQc30jJ v0JpSKC/Am3gj4h4W6z5sGf2+6ZF9KzbdSr9t7y2pFFS6lfaKCdHGLWmwLb9J7bocdckHSP+TkN+ v6wLRroszrWqOQe6p1KEF2WuVcdhLsIDJ6Gx/cCkUQiaeHhV2vJAQjfUsHM/eEku3VinVsID47qo PVn29oZLeNExwc0m2LhrmNv/qqBBilvBztV+REJYc3xEilv171r/tAlNuz1DH8Y/YIenkVBvXzdO glA2hmEqOSHX2PHdCNVJPhLPDKrVtuBhcIHfoki9NiRxysk2RJDd2rzVOKl+qAno6Afm/+yrRHQg rT5eatax2ON/8P1FqvSj9PVZOJXX5zcwGM/Kct1jz+RHtaLhJ7w/inyR7vDJBBdVF36MThxg/CXJ pShFHY+0ybKqhUj6598NhYxzRMGvne7F5l3INpb+bokl4f1vooxCUPK+9fdtIKtwABMkL5XsWGfC 3cOMhYDW8lVVuYZhkeYzvZTu3k/rgFubkOStG2WYxDVyEq4WcmaC2srYAk6WeFjQyjfJ0at1Ekrt WRiVOzoGvSoROMUDrXMDkl6c8Y8XJ3B4jY+Ny2eGNXKjq0XwJDmkyrycL3pj5Sby/yqDL1bcnrpg D9IWiHRv84dZ+wRENW3dgQhxMGeL4OmHcHfCunpint4zLXK857n8ENrK/+9tsUuV+bIwp0FGN9pn HH0jjhQk2j6XoXh8BDSESsqTEGDK5icwGGkf8ORtlNGh5CM5DqMkDqZEtv+YcMLcbZoeHJjr9aD4 u6V/OiJkytddQBx05fu7z6ycDEv+CpON3V9/E9nxV7Me8xGWkeBITuIVwJIGQSU7RgLv1UbBfvIN RBDAxctMSzaWbJHgVZaZ31G9cH1Ewg4XjHi7NU9am43yxL5gnrYQNRc7xFYzpQ7URbb6pyqqBjRl O56hh/Ky/DeZNMG//fJBQb5SZZGLiTP52Qaz/AWt4xqtERqtMhqtMBqt0Iv7ZMw1nGlU8EKuLbNN crRIfXVjK5qZz5zrnWv2uAdmLFRgrItY5m6e+zTaVpDO1I2V1n7ixhvYKXsvbkfry++rezV1/ZhF nFu8c80HMrafAO679jZzvFK5j+GZVdt6R0zUu/mwWm9/8g0c2sEt3GV/Ws0r0UR2CJGDqOsxeO2D vXbz3Z2N2Xt2DNdTgdY9QoJTfz9vZtBPwCKo+hDFyc2Ipo1cNvE00fSDvwAr/C/u3gQZLRUybPbe DA2Y7UUQUGd6Jc6fhz8+njcpjZd63W3t0xc3xvca64ZnfhS7Ri3NX/Ip3WWL2yJ6rnoiAIhtvqMl V9HQ6aprt5Q0Oipp88G44lmFc7Wo01U6Ctf0je5pdB80BJrU4/gtxcpjIJStF8qC1GHEPBTxzVaM 12GPbwjT/A1UuUMIS5Wtjw+fADd3PtIFJ+fSaGbYbSZTGMTK5rf+MEJykZGe8jh/DRLgKnEwockG 7k3HtcTkAbBw3UjoVkw0J0ZqNEZ0yy2RotEOe6pQ7mh60rPt8Kh1rLWf0yBIFaiDuhbtEW00pes6 QHjMQ5vyUqW4n4BhmzddLZe1kc4F4v9A7djq3l5Ne7XS+1SY+5VMnFUfQRV6U5gCq7UazDvRq6B5 EkellAcWmk2dvjRPpfifVTSbPX5JUVKOSoLSET+JWKt5fs2YkKU/lXq/u0DlapEzx1Q8aN5t0VUo 2BpeowG2OcSZ/2Z4/5sqY4YzHDc7WvdbkvXm3LGeDQ4JGW9FaAU6Uah4F8Z7mQatK5kP3hIViQlO 0SK1m14C9NM3+8H6AXzDd6kYF6CwrjiyIXDrSNhlTKwSXcpQFLVm/nXdlF4/Vqeq7U3V6qN3SVxR ywYkCVCULyUGIqXNecu/tGQ9OPKc7n5fhIsux8bjvJDuV+2axqfw0f2bJLotn3/IraqA5sBQKY7Y CvdNrZIP89xORI4fscDahFz4svKZazHlzTiLpfyDeVLK/mOy/sZ4pUTqChOripFF95tZS88kq/xx 082K3nLJx5H4CsEf3TNmfnnRupacMIq0JHJIn2DIVRLee9eMipV2iz2MKLcwBmZ79ajbXCsr46UC 7AGJeDgdWo4SsG93TFeavD2B3GtbrOMcUpWH0erW2MrLb36YvKwqS+qNtY22/HtRw2jx7V+yDFyV h21poHSV1JgCQqpkoXRTkVsZyWQoiMf9SyK3NR1w/753+ia935PE8KuWHMUgfKAgZqCMmgurMhMe I+NkRp1VxsZ3/xAsfPHqT7VcFu2k5uakGs4tJTdPHdY2169Jqu/e4fCtqHhOlNz7iq4jOWdxQsvE gVViELp/FxunHA4X/fdRvFO7q28MgMCIiUOXAj63/h/jeEENdblPonK1S4aXWYF7YfriDzfz2IqR 4VEJ2iJsVeyXSh0uj19wYNoeCH4fZ0c/YI5DeDD68LFEWFSgmpdJUc176zV5LrPTP8x6a0R2OeXG 96XuMrosTOf9KHqF7Vflot2gq5XlFG80zF421NE5bPzu9GyjmR2vTUahzC7UHrRBpKPQ8iAx5Seh gyrr8RFYk1u82FSKI3l6PTqvKSmeXOOGnodERFqTKpwYbXC6/sf+kduMb7bUV6DYzqfTb+MXRmNd wyWNA0Ouckd+tcM0GuO631TH5WXasJWKX+29AH5+625utV1loh23OSNYWodooD3eT/IBzUNbNN9j yg4QmHUBDPjLmNx/Bllw/KBLaP2I1+2wMyXP1xBDx8dhNI+PhWHPafJ8sy8ZtTbHuitii/Sg0PQk fLkXejgOPDOXiLe0yPUT5bH+YF/b4ihvT+ntg2oT1sJRZlcwGH+n81zzGS7jd34RapIiCjNsSjdA Zc/pOOZNddxsPk8gnhzj1xpeaL7dOneZ8MpXfvOT//3q+Qlo55WKEqxHydUAltEb/1o80zW/Dcu8 IPnqNjodlKfQ6bZaHYwrOX20V5fy1dswHoxr0Gu3Oi2OJ5dkTm/A87qFr+Zgug0x9k2yj3tXhkzA JJnX9Rkqw2Xm7wMBuRJ69oi4ARfWcADVx8gQSLCYNkLQhXjRkrMzNTqrgM55ur4xYwR5cP8PvWSl 8oyO1DbejkCuQyHs1It79KCViX8kgIDWILLwLhJfI3aIQN3wMqAQqyqQqvpjPbh/LP3p/PI5zIiS I+LdRjXD6bcGR/NfmkCJ9zJ9+hezVf9IY6s/B6c/D/eVKz9vN8W1BQwPdUd5SbL9C2T/Bkk2jKXd EZV3E63KpchkEU5QJkNpV6qseLnbD8sLmfz84QERssCAzQko/f9nUG8+aJaC86ZMmGEailtoUxjS GjmnBmfkuQysLWKmpasQ0T7YpY0mGwIqjwTRwASvYoTT/Ybd0sNmiG35g/7fN44/rPYAi0NAJbBS ka4GGDaxvhGdnnAbDKWrB96N2EnR+So3huUh7KMZ6Hux1zRgiOqXbOQYnY3Y2RF06lywPyHNyBhA apfqSCXOdkT034FrhEIMgCKYow0K7g0To9Ot42A33DssMh47vmGHwImKoBgi8s64dSEzXUnheZNm zDCpO05MiaxI6gYFxwDucvYFXYJNXFuKxtKDY3jP/ifXX4zuXnei+C5WOq5lz6zMVWA3lBy/JnLU ealCTH4CLoo6y7XXG33rhy+G88lX0+iitbZ4y7XF680Sh5SF9pqmWKz24qM1yHCrpLl0E51aKQ+c lMb285NGJajB6Ii9iz+aLNcWK3l0TlFToJHEHsvGVG7twunkMqhvLH611NuUGWITz95Cmh348vLp unu2XD847pzu9S8O/yyPQdDAx6/0wyCFbZ6dNglW4P/bQabZAIHiPaDx9tDDs5f8pl+3ilLenWJi zlZq/fb8co5fJJYdSJW6fMBt79c3cs44znVNq9UiLhTVyLtcsB+V6QUvC6V5nvO9iAVx3/7tHUQF KEc3lHFlnT/+YD3IdNSfJgFYgxz0yxULwzSzjxf8rvH2cbyKJ50uFWOSAcbBZMGtbMLyNWwHcNFe eJnapdjVmCyYHEuZ/wLfhyMZhSMMU9dj4V+uNP+KOEXYmGQw5mMrKJNXOlGS0eh2ebGAU5DKkpSD AkyQCOCS1nL47V8EEeUmuteFy9eFSymfF9BOUkbpcDBQIyuZvEdokEa7wHvinULPQrUwEyOwMLuy am+vP1auwz8BK1lcn4DgdOoTWw/GO3f10Qs9nfUNHvt3OW+0wJXdWsC46k8tdjVIl84eig15jN4y 6LxbMwMN7NsCbj1WsVP9NTQdUhFyINecZIVBLws1NosI0ja34XERL4OiT0Cj9H60qZjxDNPObDsr c59SdTqyPXBSBdOTbErzrF3nXKCMjU+WbXZUoFux7Hjjmebj8M89mXiLpSnyXhyVrAIyatemxE7e FbON+Tr6bNNojqn0oTG+dj0z00GmhVFjkR2ikC1cuhA+HJpGQe+t+0A+SZfiOKBlYpCco1X84WLL trbiXDpHa4zrX82DAxpqPG1mf7HW/2rcR/MJMLw/+sDe3Yqsskeb4n7BoOkTHzd5rKq8uMxq/ihq uLCHC58Hrwsdz8z6cbJ62JHa6YAyLyz9kwojIZQ4zbBTR2PbVaLf9SImOeSxW7ZySnYvfbQxJcF9 WscDS7MZw4UjT2b9pbbN7tydp4VrZCEYC/Oi/qbGbuGEdJDZRspaeBIVuqCKf5pivrA69U9/egex 4mHtYhFzwQPL+iqelNwDDy59dCN4UmxoiL0LFoftfZOG1Y8/3SfAVgmr9vXAGvXAitvnA3vzjdh6 JDUpmm0Rzwq6Rps0Zel6Inw8xgc777U7qO+PBPJ+O5XttWesoWzkfOeQbwV7HqAo6o9P8uufABVt t+aQAeeIVklyDVyCfNrKEGYQd5y4vcbVncgh7Sn5LbX0T0CM+uIzntL1hpfxQW5n9TyNdcLIYZ2z CekmyzC/pzoTTAPOLNnFu8RTVIjg8WO0gSApD2EAGECoXeXV659Xko93dk920y4FNmhSLqJfz9n7 oqCAgJv4S3TXSpgMb4iTodgsQDEQEnUxD+TGd51HsghWuH6JaEk3+2/O6woI42KjfAN7rK2mNk/W /U6t94xXhlGTIWRQXtnqJPsM7fA6T1ZCOmnRa8HM9vyEuCfLpL9dkBk6NVU5uK8XW73Blzzbddbe zmwun3RfKbfMl5Rq3t97BHnfeWkr1KRFCUOgaCZcpjHYnyp0qmA2IYvDlJy0OdgtfGz2Da0OBbDL DwkUEphFI1fnudMgV0oSBdBA22QE94eYkHXr9wD3/tL4+NablkAcr0n4xe8eqEU8swJcbG/b8dmA oyCF/JgI2PqLsycyWkYKsTHwT+PFmtnB0SaobxspIaNGAVM5WzfR9+eqDrr8rRKgYA/nbqNV8nTB CTGulL+od/hBe6wzdJ5+SAy3Dy290c154ZhhaDfLgXmzYy6tYoQamuz9IvgcAIggAYD++swSBhoE Ehjkr/0nIGAQUAASGDIiChEqGiGTkLKKoWNcLjEzC6uSqn/v7DWbcC04CSkZo1HAjlOeSGD837sa IEBAAkAFRPKURLxmBYJxaFwbcj/B+QnI5RcoTGlgzQQqOiAU10V3RnahNYLtUo3DYl6xRaK4DsW6 B5aKdl9jPpby1kWigmLesy/rhg5JPgH1Uuq4K2SWoK/g9guztTycnCR0HbeBYV1jCdSo5qqz33Dc 1J97nxx3VMiGfDoq2RIXwEku4ZyjAsTOvL+9tlwX4fWb0ahqjylskRk5fEcJZEi3gkEaALxGBQiy dTH6/Hb/p7a8AL7KJHjGeLO9ngLj9kE74WbzEEJ7DPQWJv8lL9UBmR2VJDo2YwVfK6DrKZ1Ksx02 Q8JEu/mk8EUdYquviCpMnsKJeHn/LBecHHuzTiOxbKuBwggL/fW0KBJWZYRypC0DziFzpDrYsEKC sbGKEJlBZw9iYzjYPpLgOz4q+eByChu/XEv53wwXoyC1tJcrc/Fa/31bMjXs6c5dg+ymXRs6GkMy gg4h7DDEwV9RYNZMoIeobGMNHU0qBSS8bVsh2Nymjo0OYmrIiP37ZTgeSqOpVjOPNYbUg8Iu9HxI FPCyDt73j1DRHeyejdodxVermpF0A5dCA+6lyflsQAyVNf/S5T/cyfmkLMBQjueD6Uh5n/HjNRIN 6chtNbaduRpuLiyd9XeWFkj+2K0jHnhULc7rlzcHlGp2hOGg7BeXpUWfJ5na6EdC1vLZTnb1SiCa VqubwNc3zKcmNnMub9QlFjJYxdw7IMh3jQ2sOiovCctZ4R/inyqrBprCqAr0KRh1eTKOVAkQUYN8 4+g0ni4cRp7zoxMB01RXGjb1PnOUPp52taPSw7osQi6QElaltRPQHsZy3d6sJL15K/+bSk0aBDtm s14vD0NWt5bXquwgsc5hPobPukfPbLNrqwkjZF/aPyKgPYRPP664Lz8JqWUrZLmHFkEqGYT/qPm0 hMsQgijQ1ojgjOD6F2MXzN1QzxQHudCUior7FabEoqKSChtnMMYGVCSxtkXF5gOow2QdYkbnp6Y0 K25LqBy0EqYE7X5t0WOFvMnvjRFjv09tk7vptwqNbMNqAo/31x9msvsEhsWR0IZJycY9iGuH5852 oN4akAt3hKgw2CsHafL5FlsKXczbEuMTktRaTL+wPOH4NLiSJvdhMmM5znuH5MHJj8a/Cc2wVZFP 6lgEjsytCkUDPs/zV1UiwcOcJ8SHi1TDKx/I2JAgiY7p5mCJl8u8v9YUzl/dbjPZKEBcc9MSMh4K BBMbQU+nXfmCx0z8k98zrB2l/lYtH9Zl5SDFX1wU3Ju3ZRou+RBLzv/wdH1UPdcW9YC2RK+pfEtZ 3FA2aaXzHOY8g9cvh5u2o3k78x0W5v9Aq1InQWA1NdXYHFMkjK3iDqjbxMji/UaQZT8x9T3474z1 9FdyCsaQZIW+8Swwm0T0J4B6Ky3zCtoZLfEUGtUNHwSzoYndrOWsyLHJ4P13os6AqrucuHbyMnI5 qpDoMEMx4vsUTpx+Dw2skjheppN+862Bhqv9flfVKfmri/QbxXZ2cqbA8wSX7C8mx/sKPGAeeGmD jdI0aNvrTwDdleYZ91Dsiwe/a9gnAAqsJT/y/aPxx9BdAX6vskOaE75KQVSn609xNx6ylAur5N7I 23TeJKwNeWzcxnMaP4gv+VBvl/nx3ctqX1clqmJP0/r6Q/eAmw/Nefr+zjK1XE2t9nipYMPgqPLH 5bdv19mhOnngRYjPhIAzssgK9oUnS51Nqqccnub0HcFPlCqInQpzcqe5eAXWCN4MCJIzQear62oN dJ2vEmT/GQmEsqoUzk5OSzRgzEhtK88PDwukGIwdYXtEBtybYR3TSDqzHGm7VIgm4q6NbRmwfbWp MdKQCxFfcR71fyMfauB5NoNFhz6r1KUus/qidrBrc66zLmFQLeqQtVv5EhIGsUcVp9QVidmj2Qhg /lF1+GPJvpjuH1RJvSy9AmY0P1AIvn4nEWX4CQghuN0e+0fHYOfVVNX2Y7VJRbzfxgSYPgF+VZFM lklwVPrrNpe7FXr9xGaitzYVYjoByCQkke/pS9VZioVVPCdaPDT4MQ5pUOcvyn6QnwA8TJs9uI0u y70KfYDiho23b0PIwiM6YjQzjSf5Ha+YveimeWjlScbEDVr1919epyyXKbOu+EzjmruJoT0F6/ZL jZd30z7WG0e/Xpbbp/nuh2iootKquE/lGe+TG9UbnzFRTdnXfmkcVgjdktXMKdAZV7Wsh47ksauf +P3yOnPpnuZ7aDP4qrzB8NUM3WDrUdmLtscQ3LpaqbVK+ES9cyGzvjSbkAR98kHXnBORCbToKFxk iRZwc5+GpLU3mUtICt0TXZbJ2n/u/0Ish9FP62l/H9s+ad1bESdEyCocvVO5VwyDhR/Hy02yn0Vm TmYoDh7623wA/0p+i5FuP5Ytjo3SVrXtZf6lzCYmwVAvjasiPRVoLN+1d3hJ/YIdfwc8WbaAq6lf 92q5nOm9MWggXchfYLVQb7WhYLJoxuWTrsIsjBJHw14gFx90ID1Z/m9OrL+PncCHbmbh5dVuqeF1 6+NgeqfxG7mp8iIVyX/vyN9RLmKB49B6VscjQj6kWr7wVXhQFhUWP2keqtvxW93Rcug+v65oMXh0 V935eel6Wnd42gxWhOc1W/TQQvblfbJMh+Qy5RoKobXG4px11umXF9O/nHiS8LCMbeWiqWBrHiQ7 a0jyNhnw4zbneOSL6Fp8fH0Sr0tBKQR1yAbdgM/CoTAUaokTIn3R9HfQmlNFXKpbl0Iyc2r3M4e/ nTzUl5MvJM050MCPHw8TdIj6+WMevstmzV6m/4D9qw4QbMuu9EyGf05DTZQhDuvQ/fEFWvRL9bAg 6I0ykZTzpM28O2njn76FJYB/48GTMk5/rhfDpuVvJxpf8ySFvXjcla0EaeVkZ8rfCwTa9g0aFxAF Eub3DtaJAinRW9oLU4flQ1lLYKZuT2dzAik98BxH1SlljeWTGexrGnewvB3dfLhtDga6CkMFnqaP 6f18sNnP7+7I48qZv+XP2dsU9MRNbeRFrHGE0EJf1rPaVAspoISkDl7mVQqYK0a1KtQK6JoOcnQ4 8FMnsBjIcse1Dw9TvsET8mYHU5GRFhyDRuXVHOkyr4NJRNdS6Mo2A5TypNZcxt+YYrrtkmcrNAUP KpTmMWjZ2UnhOl0mUozLeawqtAoQfxfAmM8Hd7fmcV9UG9EghiauyfqJV0N/v276BBw8zEFJtRQa w7dExhBSh1CkTJriLXY7SaQDnpWGyAkmt6k0IxtvWizlW7q5NLZ7H4pexXxnPEXd/CQg2W1v+bK1 /x4hVGLip9wSX/Kzbv2Kli9b5Mqg12uoPnj2MPX1/MO6Q09WakldWvvb9MEMtxGMLDSm7bBH7CcI FqkMqBeYqDYTb4T6sJJ9aIXE0u+LuYJSd2lgscd3yxJlfHXVnCXKW2Cc8NUueT5OD1nK09TtvRWq tFpNB84QueEndfoReCi4P+XzIS/rPo1hL3uZUH4hTE8Xc2sP1jC4SeFfM07q0EJcc1la5HmwiS1b BPePv9qSY+qG92tQx2Oi3fjZ1FQ2kH+pKWmDE7llcCbykPwqZmx2JnHvcCuM11x/1mspLdwr1Yjs ilFYUilasuUfRCcTCR11hqkdmVlwvm0kmvL4Sg1FFRtPbdgRfNKfnIvFzhbWcTlwyL4tTeHMzMqd 53APcvFyEmJLhF5adIvhCxrwHcX4y4dKxQPYIukko50yHDApHNt4WCWVI9F7Bbxc/L6ibnokADAQ MBgIKBDoP0H3V9QNAEFCREZhUiIkYiZmEVIGJWEUNkQVMYrL/TvABv4rwA5a79AO3/gpo6q2aZV8 g/IAO/YJsBDCaZj8BHA5P34CRk/3PwEL7yLNakaCF2h4wXdyHK+i4iq/h+lKv5llvOdDh23eJhwh jVtpYn0trS2/kgVaktyE7NUd69bFF0AYbkE3Qj+iiMXEpZPazLJQch1+L7GpF3xLdaX63iEBz0DN Yl7DIvcx/wUkpo2HGe85Uzp0X5d8cG2vMbo0r52y1epg9bG6rNunJCvcJeQEM13M2tLEv3qz6Cvk f0rc4ozU7FL84qUo4z2PSm8K7cpuVoifhU4quYB6rzUc6zFCTJ0FbNOK5RmqSCEuIB4hZu0tqpCY GSr128clmiZYQ04TRszlxNnEVMfQZZEiof4d9x1LNeeSincfncP3H4ENVV7aSuiykN2WMnOPSXyj qbL9qE8Om0r3TVqqB5oq93fS4mfUL5m0xon6SrrL5Mpc+MMIT4ZaP3SkYUwz1NKW07I8+pW4Ik9V nxIl4TatKFiUuJJwuKBrVSlreoWzdVKtKdf8Yt0jdPF2SvIPocvMXA/N9f/OvhFexOzbIsfX/Z4E C88FCyphUJ4XeU2e91OHZ1CfFyIPEGbOBVYWfOqYkaQs4ThmTewXjT7DGrencoe1fCr10PidDsOK gfrkWHpc6qGz0CtK4zpOiYMjrd9MR9N8E6GFqq36begMqR5mCKPUMve9B4yjflvsdGUSNB0K0GxX yCW3XRECoVIbkv7r0R/VWwaEukhkvfrmw/EtKqhwm8nvO3RYprRC4r7Fe9mmNQWLFlfwoj+wkkNz x5K8WZ0zECw9o1Wu9pBVMeOi0h3V/LQzUhRJUlGeM7X6s5b0L/1D1SdulY2hlgsPUTPrTGrYairY Ug+FpT+RNdFpyXOBflgf59TkjpQLH+QoVs1fjaePTny1qzRgiiWbRz9PuWuKK5sfupCUNwttP6tX ZYvkA2sKgORI0whLcv87+wHURCZiD2g2jFbrvAgT4wlVkt+1LEaR4/RHtSFPd2SdDyvKFAScM1LD 30lxftlEJCSER16mYHj7NyWpzjYnuisbyW5j4OB14Nxm5L4lf+GLaDHwxzT1pyYy1KcGyuJ/2kq3 HELYNUWgbyop7/AcuECDuaCmV60bnHwzP/VzfhBofcn+Lfsn+EXmy/goGBlta9e+Xr63FIg3FIjv D6E1WwZvmZLfE6e+ns4w63hfqmFDSeviwGgW+tbeq6QwLURo6Ohl9EGueDfQFpNqXSAQ6wtKnt8r FKkNzZEh/Qvcl3/40dqu7n67eYj/QAYvqObXhgxcNNsb8XOYxqgn8ilL6AAzMpkAUOhTJGXlDRUy lEgEu5KHUXLprCJsiAoI4bGCay15323s5JmFKocxFcqGwhCbBos/VfeN7faTgngoXm+6weqXBSlb 5jwng9il/7vHeuob9uH1UufaFJTfpY41QyVtot9UJS5PIcQIMHvmWp6Zs38MeA1hqP0eE3xyvotS 0DFBzEcyMkVZp3oeKvZP7IAQ9qoMw0BPjDYQEe79nuh/OXyE/oSuKvMScpth5vVx95wmYvzKxoFH YWmviocmOEkZoyDGl/88cDOUg1XIhgez74C/M/hm5B4dfMeHJlGkBMIhdIdJ+ZAp8OUDFRD/2moA goSFhgT78oJAf+88AECRkMFQCImYWIUSEInZlAwdneNqe2d3UEkYmVmERZ38A0SUjeJz8+v6SAVV jF3A0QKvv+Wxq87d/Ou7FeACwB8Sw5PMy101JHxdTpbUAYgT45nsgmcxGM54GjhZs7uXwtMTXiSO GJ+AZhO7r/B1vY7pd8ygXlz0PkHHV/nyU4yJUUv0L2Ivkk9AzMQv35HBj6yMN7+3oeV3DrYbDRcq govJvNFc6WRrWDn95MEH9mrrMd7M83oGIjr2g8SAlcidTs3/M4UUFSWi3ybmSKLOI5PLWYrdVy2q 6Cb+9ydipOda1n6QH2B7cMvoqGCMalBLZK7VUvEg64PvKnk3WpVW3ZvDnQ78nwloB+7gIzWstEkV +RYHGjxTKZOjHOl/SYhhaYVgbeq5ilTFYMpzYSgqUgP5enk83z4BmEVCD5roXruzKDHXs+J0fpiT rLPCTHpf6tlnbzNSVv7GfIvnSJeklVebFXG+nkugRjKlgRhMLlQw1pwrvc5QB8nirLC8KOYJagBs jv2qrkrCq5LjGROhmGwXwIvUH9cbBVEHHG8FH1dLfZ7eh9pMm17UUorV71n7fyZ8ONZT9cUL6RxB JB7a/hEZuaowMGCWkAej/y2Rz3LuqifPQFukWwY105+q0O8ZSpUB7YWVeiwWWksLz4rOx5QDxiRb EskaYFwleSySU365QhvOGyMDhvOBDXpVURhPb+P0SsZRwC0XyvQSLQRxjBOqjcxsDcSzSra4STjt 1Ym2oBRZZMvCi6ijIICSTX5LIxZVYue1nP13ljF/m3rbCovep6tmUX+bucNEQY7+icO7F2OIfBtd CJcsfKwIz506hbMY+n+meMPhGR3HfSLhR2aUgPtjqzdFlQbyNDkSZ6UqvjgG7qJ+sbULoEpKy32F oImiZ/4wHNM7IdmgPB2CBS+swwi6Vubnj6VZkAxU7ax0EVzI9TIU22ZyVda2rlx0ndgUyf3ecPY5 pMuiDHx+wyKfB38c65y1Vu7yPLg4xiNknt2K32nD4gGE+gLzzuRtuqynUYU9tvxvPZFzR41XlI9D XK1Yho8q1mWoaetd5asP2nJE9K1WjrPxr4cxPxPbdGvDdt/aFRC3cx0Bx5F9OqqpE2SNUv9BItbp cgt8VKEhW73tfFcSbBfIBnDUpAfFRbCCmkqZUmWsgqg3pk1QCoFH3wjlxkplEpUrEsupEUxkJolU gVQ1t+SzIjLuHkQz7JpSFG0XadDwLf/vPv5G2nizNVfsn7HsWX0Q/xc2YJtC4h4UKRnJf9msukSs IUCFpNrjRJeQOqYK2hZUfgK0HuBq+XQo+si0PLv1gDEzU6QPMi17DhKpS1m3f5JnDTkREWjpzLSm JaXgaez0EKF8VyMt1Zyn67xyEwvRFpF8KUFdITbTY/8ElEXKEGBCanXJVM+2d/cOQ7beWVdkhIQq d0U+2kjeDt8PTtsOgOXKhxcK5wwZ0pXJmiGvFfwHGWwy1bL004IE9OrE29BZjRWyQ/2lo4S/lcUe kiEjie5WgopFfGKwYntG1GaADMf8n7q9tDINo1z2FsC1DKzg7Li5uwL3ognFE8rVVrvqdEkt9aKE 2hQB5OQaR9x1LSKhAw2IubCy+ZOuQF7UJngFdSJ+uEXIt8EYzHlH/YQrKa0l6qTPy555r982K7Wa 89pnJvPFDW5onvffHMha4VuU8S0RiK/zTS1LZv/zHhFLwWcUKpYW+qDR9RK/TyiNccLKFBCgMObM h+2NuOF8re/5qMOCusbwJY0aHNnmSBiTF8lZoGyVjf+NfKNiVj5RlhOCg9XkkFZSkS/T5BU7Lreu SdbM8ilKiIPUA0TNpS1hblBlWUbNpS+lblBV/gdxjJrLWKamtIucxa3Lm6dbNWvZ+o7stU1t4u68 9fuOK4eoAZTQRFoMfFAqZ4ux4FkiqIVPHax6mFR/nzR+lQv68fQwvGVv7oKgqnzmEHN34WGmdNOS z4x9ourLH7o6qpOarvPs1GrmDL4lzR1EKtyWHvf9bc9xf7qlejKbi0ZwXX/ERSYIQUJQIjn7+pbE //kESPX9Y5Ib+GJWCrOcKQjo8i1J6YXl42F6nJHERno9ZzJDqIzeSBSD0hGsr9rfOE9tmWgZguyz MBnGSmxHys09tAkLdkloZVrqLZfelKchL8PwNT9SWztqblmyGUT15Mk/AW6g+1UpOKx7szhjSFRs iS0rFDHy/VGBe+Ryx46WIVqO7KmSNM7h5GQpR6x1obplURq0bQguexcrnobTTAVo2UH2ncxXu7Ks /UahtkQgO/C8O3VrYIX4kKkZ+hoa2vZwwLzQwzfSCkF+oyltHKFhloEnVIbT7jbjTngOVUJ6JMBa /LWpqK9FpIiZhfcu5xwf3J5qKAJ7Hzv7VcFLyqvXpjxWI0qNkTc2bJz98SeWYzN04q2WnfjpKlfl dXysxVsaJp6WCl1VI/dz2T56cScH/LfthHxsLHRNrNKI+ZYGQWRNc7qO4v5UY4YsHOrRDJTJWBCd 3UBUQFRYgJXSASLZUQQ4b8/FNYToVCqw4Yw58MWCHr1Z767qE7Yw3hspKfWVJ5WYP16F45hZsgvz NlTywMCL0rtRsymvN23MnwBfDnGDq8FTfcfizEKbXDUeDIao6XVkAY4THjJnFri67KYS0YZK0Qyz ppgqw9blOClyNKviZfXrldZuAVUZOdmqfspGFemXIpZGq6RVrLVG6fPIC+1CN3G3SuV2IgWpFl1b 6jopKczd41sfY0PAJHUOQp6GibnVIk3df9Xwp6P847gLlWsTiYHpyr7uyK7KSSRdpxdPYXF9zGQn byinQe1U8EZI7itLc1Fj+YwJxPI9KVvtxgw4NqcgMwgvbDgpya7kg4n9I6nTPPX7jh76kMyNBj9/ SxutV8QJEtk4wTwyfFvNuoULGpUWqF1k99b/FL5HkQ0CkxPlP8YEe0aohH6RH7r3s1BqnfFAAumq qt8pjEfLxPgpxpXYzEMEZ6zmF9HWLGQ6iCVzzHsI/YgM6QW5itfzAQ5YrEVrUsgHlixE6JoM+Z+b EXYU0mD31fyY31iGQZRqyR3WmSKG13Hi+jclz0/9czCsoj0NMe7fXf5jSyZVVqZNLVBDvogw3/KU MuUKDnjJUVyLkAwLPBF9jB+a/vEfPzczHZrW0uogpThPSXjUS/XisspVq0amFsv+pVsUFup2m3Ki QkZzX4UFdlJfvwUH9bOQcQswaZ4+DMaykLeljJdSfw7mH+ZZ2LWd/h/rznRpRjZKHdX4IzLLqluZ HwHwC45ZjMmrwjq2XMhxguwCoRmm2T7fxE/GrUG1Dfd5s+6pu8c26DX7q6T1K5psMnZL8ScrLmPM lr5L1Fvz5MjJbtprNFJYtGVFpAwdXQSlOW17CVk1dUPeL4tc0TO1uyAMOtgnV540J/NSGz7wNy2K ycAK2mv4Iq9bQgqLASszwf013Ykoy1XSVY5dJCUgVpjXvY1FPhqkKf0av6NmWfU1Fam74v6pWky3 iKvk4sFfW4O2U/c86PQ3SdyLYaJk2vRPElSGm2kKIqKKKWAZH0l6Dj0hESm0V7ezFEOgOYp3RrbV ylbAZFUgUis92TXwfWCOTlq2ZRrAGdOHQuOijOmjGX/rPYiPd+ziUz8PD3cS7AJLk3+FMEd8/Bp6 wvSXVcGO1cucldVlSKB6sde38WVobfxbCSKS6qo5IP5ct/diC7v2T99G5f3DLOkob4yRPCismQNi opVgHM1CBRtkZWXnyn36criJlVV9cL7h8zEWC97Ej3V5s/azwP25oKX1JiqePeT8UXsTcoDsVjcy fIXrE7s/F7Jm6t45+wmQ778kXUx+U/EWRuPM3SOPZnAxOVu5LoBup7T1bjMMS357TEYnSkvuxCmF wUH+/VNXXUm+cM3UrLG4j49t5nU8nGr0AR65ZTglBKsNnmunfG52IJHGPYpJKNTmbycGL1N3iq2M ZFf+PxT/t3at5BYLB3MSLLGYzz0lGsX5SNby8eMulMLSpFzb9PSoLNssV5ITU3X897Urk88Khgu8 VI3n+MqYTvAXMe9jrCJ5aIibYapi0VS11k5CKsOberqRumWzo0HX5bC5mxITb+YoRM9Ck7Oh6/cm 0yk8KUsX2ioP3a5VSMjuujyDEO9351Zf2JtKwxNUanANF+u2H2ItvrG4elv7vQdF1exhG3OpV/RF Tfj+3hADXmctSjXvQx0xmmkS0Sb5Igw5VWpFHmjXY401mrEkWU2YUy+mTqmVM2WWqxv/i/xDXCTY pdUY5a3Mk7HKACe7idTXfs5NzdVUZQ+Z1xOigr+B2DLSEz0KRv6ejY2+XK6FZrC39v+e71RzB8gG CNSE89AvphUCZA9qeAfdhONzTaVYSYw8ZTNd4Qt8IcpBS8V/GJOTH7pwnyZylqOokHpq0Mb8/ASs xB/EnERkjCOQ/MeIJmbUbJ53rsefRVAo79I1dSkbKpwThSE3Oad3kEeJKxv3kq6vivorqicdySD2 EGRajxrqAq8DUuB4YRPLN8YR+JJGfzrCs4STFarEFYB+Wc7sEa+Kt7lhk45jYtOasDKDMamnuqsR +txvk1xLKuJHZhs+5yW3CRyLJwU/+YFmomXofbQ5djVXMpVdXH42kgX1TwBShPsi9SGFztleEO9c f1SFtnRIXM3W88mJquzXEvH1561GsypyWpB+X/RHJM7diIr9iWO+sPseV9oRXlzT9c/OIx5CrVhb CZ/JZlkz5ZeCwRSTdIgzdlqCPpDzkk7SfBkJavib2z6cJ3G0/yvcWM0dIunDVLhmyKpeEVBnsEsf 6XDbO82uBJIiklIsIZHV3couI+3ym3OoiqFYYsd5kkjJ1oZTNNCCOIx5MlGThE+ktIf7cDezJc7l TM66Pwk5xNR0LAwvFAFSlq1+bvUXUVDClmWjH7Nt260oEO1IZwpJEP4+lYDMW/vO5OxhuG/Orx/a lin3cY7WVKtKixrXi4I8NjY3RnwoXdaQaJMfuVwXx8KbG3WgqYB4tdpdoIRC2XxnwqfkQjZ7ONno xYv5SjMNi0y9js9lAJsd3Uc6Y/W7ZPgqs5ZFgHlMTyLPhlbVIXXCtFGYBctWMXJIR5VY21crsSFG dFdHDgIozDLeW8+G6zIrzE6kCm2EpsCmslgZfW0wifQkYJOFtrOeZntzz9/5cPGN5KdF/r3V+Yr9 m8t9Gbnf8Hv/H9aGFxXuNUcYs4ijqI7AnvckEHymtJAuRaP4BCI7U7py5NaazWQP9gxXdsmf2pzj VlSHt3n/6wvocVM3ZE93ULx26I+vhk2d64SWfyM+kGcYzJSlPRZQp7efXoSd2qxebrugkV5Q5mC5 a893FuBp+x9Inp3bg0cXx6F6w7oNmcBFKxgfh4ud+dF38UPf7/+F8G8FPPOdEKk1W7Ugl9ta2Rp9 U5Ji5YIFrRyQy/HT4vyz7S4bEZX1uGjFVLnv2IiZ6eF7ptjq9Ws0RToY9fTtKuSeLMzE6OE3vxUE LIfzXIYNGTqkRmU3TGqCdHbceAR2xl6gu6IOxJTpNOujxA1tJ30XkI04hZ4GwKJXbCq5k+C0M/IN FIdotLVYTj7euI+ccv92SCmutoOd1MP4xejwtn9kyrsTyZUz431FY5u9nhLmeZ8RMGakrPJikbs3 X78DsD1Isd52xAsrXYS1p+5zD5KVqyaRrMaaISx5Ht404A4Ls2R9x3bMuisGNlN8J2Yvdj8OJjIK l8pFXKzXKHxT/sBCYJX5V3gA5FS1y6XYXVb57KZtiI5nMxOKwW7rN5DjXpita+/Y77dXXKh4PrjX R9dsNFnObfx/Kfy/IWSuRhzMGuokfyEUv8yEQrKEqZMKUUnwB9rnkWl5T6jLlsIza1vj22px0mjK kf5vxEqPXGzjsWPTgiNiYY1jrpwitUf60mVS/s5k+DXo1t4+cdW2uoxjCjs5X7RAdaB/DddR+ogH KtVMrqmIV02d+Xogw458Dv1UCEKyws4ad7a1wln8sHYSJ32Y9X+/FQOXpSj61b2lp1ao5YzK/buw nR5HfK08aCSjy71stbMszbC1iWF56VZbTxzGMkO4bHWtEjyEr1hnA3kkQ+fSnTNPzR5rL8Zi6Umi wdorf42tc/YCe/P4McrexUu8uQ1uFGMajPiX2zqd0/B/0af+Rf+a3fN1NuBbqXwatutsy1owSkMU X/3UjPJYdHq3TE2EOuU7Nq+VhSI15ATQvfZsXeblwb12F/qjJ69RTHwRsZJNYRv4VOGS6JSffirM MdsMh7aROkVpVDFtkL5hXYVP8N9Pr96J6h+QzfS5rGK56VjZbSQvWmiqEaUV2T8tJVmyZw7u62ak dhtoJI8dE+1Red80NNqqjQZNBwc/l61SqhEVz+ErZyhqQjujg9RdwchxZ1Aj/SWclbIu4rwxmnFv keq21WIZe5k6droFbzE2e4KtK1qfm+XMra7LmlrwjDqeat6vm7xwGD1Roj/lFw1FIzVtEkFjW/bJ 0uxnJUXQeOnC/aWoDWulSv2QroWT7LtwygXtkfgWsgOz7i2ISI16TP+rTvnyvyKi2YrLnq8ZUX+g uaMre1/DmSxF66cjt0RJ1lX0QGYNGrSD9u6Y4aUSHhPReH7xJ4CjTTdFvx//5cW71c10n3HlIdkS OqVVzZYLdqzurUY1TzU/MStYjypRy3HWtCALaut54H3S0ZK5xPsHMNMuZ22/PbtF0wLqL877Sasg T7NGYT4W7Vz8tErFGNmlEokia1WSebYypJP0RUifsGHEornJWlPUYaVPQIoevYxhlZIPv+rPwxl1 /qjOupy8Ixlwv7ZHlkmM1eall6clJxuyIhyVKhpiRWpDlO+KYG1MRQbCPhfvYa85Z+im6H+I3EIS whHnjeYj2JU5jVneFh6HzP+UXkRO36msY2UfFjexCEwq2Jj5pf9amfgEsPHVpn1YeRk+FZNdyZVm EK5D4EnEK8vEqJH/HJQo8FL7iqZU2WjnNujbyqnKPR0u5GVzK/cPlJ7FsFJSvbZRUD31DX9hg4mV ciXydcUdIYTg2MqVGlrL5ZqiDcLJ1ivPlzakR2U/PibupDUUzOSj03ZiWhq9NZRK16vlBZqqqJAJ FcTCxWmyIAeL1ZTzmMzjo0hnKvc4xGZQVXzFc0onWQQ3mEClh30xZYczH/xitHKcOSdyZURsg8Bm am5r5KmDkJziViYlrJA4SppfAV3+V3AXI/lY9hUHlsgu1CpZxLP3pTFmWNnKwGjbwlBWsLFOyshH SJUUYSkvIMdFxjtCUsmUpyt+BFhx7eEmPH4/JST+ME124af94CLOx+xzfbL2smVPkjsWrWeg5O5m f85gW7UdrctJgYszZQspSiVt2C6zovqK0UhqotV8xecWELMesIUauVNU+dS/wkQiCoVL/q848W33 nCBffFEgZPq6LrrzMcDR+WthnAqHcMISeTd4KRfU2FWteZOV0irqMvCTPjp7/2DNFWhokVFIug63 tnXupRYni6EcMQUnzhCedIGSBLOPvig8zdlqTv7jjYfPBU+7sK/pbG63OYdYX6nox6Y8vztlaqJl j0vi3lGIuQmepqGERSelgGqf/kDKbKMriFBf/L6Ai+6UqE203mWwIT5lakdOqxe0o+pMXBGK0xHG 3hyv9HQVR8sjwdPsPLzTUY6h7qWSDzCO6x9xfYeWzrpZlWT2Za6YAEtot4PFlBCesSjlqhHZxN1E k7EK1GoaCbjhTHYdWzJpXiQX8nQ5aeXi0o64OMaLaYdZFBwTr/72fMiGVymP7rJapb/FGjs40Db8 vk1HxDpjZOrMXMmf8wCkbZ3HwW2gTvxAP6dlT5cIDUtFL1FFb0/MODgdTzq2XhNEcQL/J6j0MIGD Ta4+Gtp/gLjXtC7rjDi22URHtmJ7CJiJzBs16HfrIgGEdgXxpnpS52CwCxeYi/AhjnQFs1hh8eJm xEBfKe/Iuk/tQ9PX9DmLIfCbjwL6xInim9N4T/k8bQP/Wk+g1TF7HiuJLT5d68/nOPnUD+yjQl76 qk6kcBOZqEMlyYqJ/ursS9rUtQD3/IERWZqQQYg94DWtFILfBiYgHLyF78kqCkPAGQkyEfjt6+45 ALidgCfK6NTYg9n5twwWhrJxuS7pGF5zCXVjbu56eGq58W2bWR1tQ+ZBt0pmJofsF+Ij/zMObwFc L5alTkF0zt6wNG83PbNuRK/rglaEDQyOWPmRg81jdaTdn0JDDPIuoSi3arJ5y0rmx0nouEQskwiY 2ZWPQQJX+UW4B9OCfa2/815AOcYYik1fgf0XCvuHMfgW/4yZsvWJBqDtmcmpXUJe/0TZK3r8BNCH 0hhbZAgbJtyEeTS9LavokxQY1o5HB6LodmvExu977h7ekkAfc8dwMgs+7/6oo/G0lMb14L4mH2Nv Oj4uhrwI00g64pxT9aix+0lYFdpW0fFjT0ZYuSCLBJf9rW7ysin1+2OqbL+XBjgFzktZGL7mvdj0 E4JUn6/a2oorGXmsNy6xYyUYde4hoylZlSHdGnXZerWu0bfmHhxRHHlemhzexN6uUoNb2eUqpio1 Xmu+uOYsQ17B1JtmmUu2LXxuxye+GRQcM73vwXa/SsAwuMKjqOWMB2rW9XcBtwpOoSdh8Hp4AqM1 /cfwrK0BqAnFtHbWvF+z+p3wQGYbWd9N2VAmuUHR4pI4P9InQFT3NlutffXZaPVX49kP/yFZ2Qnj unl26z4FN9QUote8L0WYOE270EDeiGQmZBHjpvgA2XJSFvThmopP2rIeBhe79yfQYtvOoEdRso3+ t6F0oDFf92yz1llI92Ykr/lnsiExE1kqB0uW3nKmUDo4KKiYzh+IqvUKNFJQG3EwTALLp9BIO3S0 QOSJqf99qW0IB7flmIlt/MED6l/DoipQ8i5CNCaEE1Kp8E8hqePBaU8G5LpmvnAmSBOZlkbmupTU YW8bbkAb8YlXydlPMgLMpDht5e87UpolmMlZ8PneYhPpKXpNmQ6xvkjO7/1zfpleiRKykk7HJx/y Km8Jy/v2UkQscBfpSlubPwvsAmVg0WwTCuu7gUY9mnQVgLdbmTjHjTeHfBEnEgNpaEkvkArNzzBh F6geMuwqLDllp2oyrJMrGyKbFEw4nIszYak65Fq6WaNLysywSbxpRYL41+dV15gDVfQx3U65Ezyl pZXzzyh38Cmd450LbOjVfktQ476Eh5X/etApRZ/NVR0xnNK9h6XJGmPIEbGVla/pTxm80NWEoFXd oLJyoK8pqtJk6KgQOoAm46vJKHWJL8ihfg7iOuKsvAsqUrR4W47ABZH6BLRf77+WlB0yEecTg3qy 3glJZ0hJoRLHNVRiOs3xzyG4sL6Kz9uRUlEEQkXrumCmH7x0BKWQLGNwxGEaHUuBbDdd5Fq+sHQY UvkMjE6e2PYLukeqfyzy3cBYiQ1MysUJKkVB7lQQn8oXhLlQr9keuOq8aWqIxGqI6jG44nnhaJM7 VtgylPQV4FML6zgVFnqWjf7tf/4MC416S8hK2fqmcbv7JSRryq99uNz8IUsrNeEtoLDKT/Q2CkVF RN61ogFIyxBliGBhKQyPsN8hj1raqZYNUb+xI6Ylg4zWayMbUtoSQcoTJkaKQPYtJM5sLhf/NFM6 aIJpCqezLCQyBA54cyiwDb9YnMU33/1GNmSL4N6nmxJvS+/j3CQQjWM4VkIWJ6SbOsG4blkXlAPg x2GWp0LTSyJvnIWlwEMuBFLJa5ENDo+4PmZiRqRk6NQXVq1ku9F5YyJM3AXKDVFuCCbdJTwJSrN0 qbdkIyKdN1zOThKpIoxgv5nfwaw1lA+MbSj5VZOuSqGAP06/GdyMs47otBdGWowIdbb6OQCgRgT6 62NmyL//CuufL94gAYiYhJQQCQ0d/eNyr2t7GWdvdgQV//1bfQGiT0CAxWOfLNWa5bXwU05J6bMQ 34EkoZPgs9oT+3P+qzZY0mSe6Y/cLNxSgqrCo4llqP3yAKqTXI4FJuTOcA7SRpYJgkG32LRYxKPO VMOjNCZYI8hkKsOcKF5cj/aw4QzlbOGXin4xviZpU5ubmLCnkHEfHt3dCY8ril+GIen+YNaSw4Tm FHr3/QiM85bFQ4T+xq5NBRFRqIM9lfRIJKP8C7qWex+UFiRp4PH6FvhgRS65UUY2w1FxH20F88w1 bTsPDR4F0GZx1yqw8FeTYliR3sBP3en8buNJwwLB+CCS8eSDJA9UY0cdmR4/U2FakUjFxpyajYRh n+7gWPthu4px1eBRrc73sIQYmguWkNUnvh21JOqlqfkBKz+wA5nZeYVcHaOCkAxSlsZLBU2OrMRw qeF6wd/U8ly7kmb0/j5pxcwQi2T5Lct4zbjjo46nsAiLwGbYx0UfSGEUX1AklE3iwXgHy1L5DQry MoQwmR1Xadg0olUHjAJDLkGlnW2J1Vwcz6ihDGZXZ1Juw+47OEglhc+uvjXqrE9i/wrNynotNS8e zE6d/Ii095l6o25XaWGgGVTgZrAUJhJ+v7IhJrLX/G+kibw3nB8F5yWPlvU5rVHuF2SoGg9YbAIe OYE3PJSuW0JwyBrlPn9Bvo9Gu4/Sj0bhFOHOpURLW1B5FP2oB+m4s9tcf8wmLtYBt0E3jEkVYBjS ixhpYJko9wU06oBiqGr1l2q3v0H8JYePAVUQHUhF2jRzkl/teEvtdOuv/HJLVfNC0ZkXbsS3BifZ ZF9mLhrmbJI4pJ3OzorVgZqaUpgJ+mcXG9b3AjImWm61xHOfdQQtFRD8n4Qj+eqBqeAKGA+CsDVY N0rKcg5A6f34jU7BsoFhOeUDgrXXpzdiXpWqwNyhGANfDFSbvfyTl/tZ1Ov2pZrLMA2G39uXfUG9 djCME01MMrU5in7lwxcI+RgSc/ZqzGeAQ7xSShrPw6nY/KEQhbJ0UptPbOJRriSWjYtPv2HClWXf kty3fq+dS1mA7SiumgQKXQZZ0y90W6gzuzBqSSIHrTqBm8a7K2cNUJGbWS73Uax5faP+CGrRK/Pt xz+JwYl2KbSPn4IPfGq8w+0hwrWwnu0q3+gqn/0LSjAYXbUj7TiVHilHQKwdVllZU2PHbduhTglc T/1cXgUmvRg2PH9u8MoS4Wxaaag8DvGhLsegCrr73onvGQFOai2jTwVV/2i1HBW5rI1jNosSsBrm JVPMkmHbuRxtBevlK9FnbocrgpAcIbFBE5po59+5rFzO/crg1mib+yW+/QlAoUG16gfKUAgKfazG joHweKZOf8D2RXI1LmbOLURuu1RMLzWAj4HrZCdXoKU/2z4RY5YxpOu8mncuBPxUUcBY1gY37Zkt f16rddCvqVYr66TA5tKQPtGjKToKvlmuWXY0KihNs99HG27mjQ8yr/3tIT9OBzHmE3qmRHwQD4On ml+G4fgTuzM0cNRjpeEnIehsbGb1YhRK72hOOKZtMaGMZrnxjAtk/h+aOggrucz2eFbZgoG5/i38 du/v0y6WiYEgnGR/aMBledy6btd/yi0lvgD3EjamndWNKOkvutBxtNzsilHj6h6w+I8KdUlIWyiL DRfcrbYYTgWEChLChYQCUc8m1IkSzMM/eLTefhjQmXN08ITdKLVaCR/ufa0XaX6NyfejgQnEVO+d Pb90pwj3mNdvWCqQWOBPpAF7YC2hOdfsTJhgqYw04dKyAQ2bRwnb8X6HAh7GcHU6GK8zJ4Z08FgO KM2TgTq4xKDXJTRaM+OQm2HNdxZlC1Be6E2OuJOujZhQS6fQJO9smRcWJed/9igfRNb0nA9mR34/ qxSyJ3l/0sYFRcVEixsJfXhHu2hUic7JYYjyQzAYXr6+/wRk54NSYmU4VcPsVRtW7ZS3Xdf1S7ic aA4znp3Tw1iO4+Vzyzy9ltF6k4mE38gQ0Tl9JJ7VE9awfsSeaVQZaDwyyCUr/5Dt6ofwbDnf/lrM 0FB7LFzv6J5QB3gFr5013Gzx9RZNwl5R6uWpwHsaD1m2AsVAI81gWjfePqr2JqXQLY6n0DtHijmF 4PDUO3PMmbkyjZBZ7c6JcENwoBcjrm96Z7peKNUKqQP/gmXV3Xs4XbJHfI2btXNRU4Y/ZgfjaPkE OIUEM4YIGxIQ3HKdF2YisBUcL5fOL5ycuhzOIRrR4fAtJSKdYULQ6rBxQ85WrVsd6g1ZcriIFxHt oBlvIWKDT2NHIPfTko6Oda6f/gd+EY/mIBK/lfeqzqQj3qNd/uV+/oI7UnHya5OWZHgyGdAu8+oT aih1iOD6SedjSc/Z8lv9l54lmfOKIBb3A8lHwj+KYaF4i3mOxcIyiapetmrGkDUyEfrFCirFpfO/ T+CW1hXhWjX+tnDXYEwQNue8xxLIDZp3qKUCSOoRKMtUf+Qnm2dK4Z+RxjQdi+MDurfP9XOpoT90 F+bHqXlBF2rIgtbRduNTjXUTxsUHDXh3dVTK6WAp+LW0L03XTeCOCdsu1s0LyZnmMaAVihOoQv7y LqWGlEuLOGzapaFz6c66q6VCXeA4uMKc68GYAEgQuuqC3NSSeCQ71/+I++Vz+xxBqJK9ckHRYiBy ah1P6kbpFPUiHjYgiULMEmShFFwgtB0pEiVreH4W7Z+E7zhBQ+IyCg7QO8dIx4Eakbk3p+OEjm99 r77eDl95KJYCpx6vFQaNoF9gqBFaXY7zfPoElBFpZ0fpUgKRs6F0GEg/dZf9VfbX5V/Yf0/dZVhP r4r6QuRn2dtk/GfSHmgkWWK6+ivf9nfN+5PoEen1idRinxfNWjJ4rXjxjrbLrGcs/ziu/kjIF08F NX6RmPtNhUIZKTqwGsTjCujBFgfSSDMht6sfUNwE0Z3ZmuRjL7vP9ANX2/F2PWfbMAGsZovOlwTm B7KZUO4hJyy5+uS7jMOBIc2Px6HSieVElJRKp/NhNGRRUzPwWkAMCup9mAVvVixm+GFwHcvUg86g g+JgW8rTjPw0K7ixK5zKQMC7W2HnWnAuHie44cv0mPWKXcZ2p0zC40Lhq+5ofhNx5Z9BQVoiabqI boBbCvLYExk8YWHwR9pWBDq066ZGB2H9BFDrNwZ9T5B0eNaluHjbdPWE4zDokfZZSrxl/wkggjxS CSYLwbwizz5QEIKI9jlVqiZWhgD9t0u+x/ZFRc/8/nPGMUD6Hl5IdzZaF7U4a2iFbyKf3Gb7N37E qB4Tqy58w0UffCV7l+CGuPWiVbXUUEzvP+pAGZJhFREM58/cqV/L/XHrIVHjYs0l0+nHgONAvWTx CdDQThefcjS7Vt4wTZhHqodWjTCDqAnslE4XORyiyN3stD/9BxLZaoCGSErXKphuAtempQHiEtw3 Bny9ZZ3bI7jlmFaZDy1UL+k3j9cPa6/jvk7s8cxauVhzjAT8+aJsLRyp1bIx4IVhkKRTNp72KWB6 w/yp811xG6YEBilT1UJFZ89UCn/PSTW/YJdEwlTodUkC0KJ/Uiw5OFVj59q31oe/LKMp/OuUFXLa HhguZKOiVd6v/leZVMhzHObMb9ldcmwp9YsguZWQKDIMzDs0hIXqsrtQn3nlO2cMITsrXdiK1uCH LOhU41TOX07zifIQxCycTzk/tdp2sVuSkvCIXJAJ0CgUwj1KWdAbcDO+Xwgm3A9YteJTm0joZBMu rl42ahTsSWxfd3E/Yl+Rk2iHGMzwWagk/ljMEXKuj+iOvwjNpOGLxM9AJ4X5/tZF9ZMc6R4dOn2U nel9Xml3nXa96qwV6LbPZOM7dOYVD6khNcPiPAIpj0b4n8soLpf32247tI9cAlxsrZfz33cOHuz8 EPZYapET3Br/kV0BqyUYUTgcMAuLPRWhsk3K2fUsBAYqhH8Hqbu1oHKPN63soI0eSQl/wJEaZrdy wxz1ZxvEAiOf/RtLHls05uw1IY4zKmKqfayUwYzv2QvChp/Qa/WxgOs7xGV3zvvyPUHbR+DTF+kU YeV99muW5KhiRIdyIK4g8mggXtqsO+kCT2sGrhVYu44kiT5LJwo8QnbJlQxqSZR0t3UWW9Br+gRw TTmnkGtwwgfqfTj/fqJ1cPOGPWmZVb55W2SM8uv5fSNzwAVyo4yjT2bEGZTEA/5keadplExUS17L 1aTknspXIsrvf42W5EsmOeTOq3EnmfJcZY5RtWHNUo9UqClYjbwrsdNHfNzHGN5x/os+tBnD/SyE xD50PViB+4DUJJ6D4gOFWMIcJyPgwDRJzzTnGkpXHMXqh6Q8phFHDrNKNGZ4vYVUSW8/rrU8SoXs iYy9x4i4Uv933O3XXNPdaH/inImCqMgB4Tbj7zd3mUd8hvznaFlc99VvSErPJDKFfuU7tW+kIWIJ NbMgtCoP2AJEzyyfgMHpDxAvgbeId0wabpU/Z5GKIQJrZOvfQhxMJzs5EJOk2/HOPbc45kGisLgx hXMQKeO/MfsiZ9DWjdM2EeZgmKZwWD6z/B7/BEDwLd9krH4C9j0Q4jMtFRBupSptxjpH+iuBhfx/ 9xtXLAVxKwj5z5vR6qseq2rHPtknhOAeEwftB9+akluRHZGTaVaBp4DI+Bf2zG1bOrC2YOvCkSRm naWguwsEl2aQHZKgvR/4eYjbgPrT8zBvJAaT6f/QK3aQQEVIhyFyAJxP6syQIU1qcFw1L+PkpTjA oSDA5W6SxqsMLnYStiq9YDZoRbQqTg3D9lKrw6iUGpv1v3ayD9Nfpxx2VxQa7m6V/aITDHdXDBBX 6HVkbeIiT7jFFByQO1Q9SKIBK38d+7jtbqm+ogTiM5UOWV+eP4uUVeYhIpegu059ZHS0XEMVIAxs 1JKYflXHb5Dg11c1BCWVwDscoQqqGVo0cwuGkXJee3ql85aT1h4YSe0veqpaKMZ27v+D0HdPghn9 gDJWqk93mAGWp9HMvVDOEHHRoOj1rlZ6btOlpnmnKMxrZ/ndoVsp/4M8Su2CiLNktSiOYWlgYZMS cfyBHuK0Wjb2NoXwQ1E4NCGFVw7AG0q4T6/Ojf8JcEHpPOGmS7bKxP3ecTR+Y1cdn3fw4wjjOH3s QABCAFw7sxs5CYDDjEyo5fkQe6BEeyVmtOFe/glYbVYiD9pVHO3kZNT1p5OikejFwOwLB8P4DQPf 3ndb0uwf3GRxtyeeAJ3vIJITVV0vsl3GAIFj77GV5SnPM4Jcg73gTXf+sZRJFeUt2GAtgWs1Q06x KwZ+I3y4Am9KOY0I64ojLv8u+V5RHhE8YUXESRLy+gnwg2HtPIK2dPGN+prbbTSw2O4qxR+IUoyC Ox0QknSe027AdFhLbk2ryPP3LS00hFgRE0kVOoGLIsMGvcCLcBoSbxOXsNLFPJrDIc1/CNpjnLL6 DcwpCkgFOCmddaOddaseTYiJOQyb6STscFqoeeMlyiUwmnWv27i0dwIpGymzWGicN/+lJOcvJTES kWQB5f4cjMFtuFAMIqRD8J+WuClVhJiVVlrZJXqukG+v42+uZDMxSbnsnS1xQOIaGP/jubjbpwk2 O4ucxKP5gjj6DOepKxA49na25rjpTIRoxMK7LI+z5JOhS70GPI9oAFawptSS+70MLzAzLOCHuI9h NgqFck4xztVLZnbvJJkFX3lCloGeVv7evZyQqhaQY2uvcoDuz8NioV2wFSswpKHR8/IJ4uccKVsB PQVMhSLWGgKFjRkglJlgE6J4X0v0o5iF7Mi/DaYGtM3Iwq/tffnJoM0mCDBgWE83gcC4q3Q9m45O 7GBwcmTz3NoppPioPJirU7d5l03t5Xurm+1+q4Mp86eeOf64MFNjIMvKKbi8lGFQEUJFw4ucNYWn VhnHhS3iMtVYmh3acoJt0p+r2XPWYwYpGEsATXgimnF2d9bscfbqHx1M/a0DuIIacl0EtMV4tsCD xr7KHjpHoFtprhycUAjPapFKllaJ0XD3i5jI/n1WiyTzwr7j7JBEVb8Rg5LZryWe/k9tAv88HPqF FoGy/vKrpLSw14K+BtBDDu5ZQXIoD+ALJrD1l1y8avm3aDgU/5C73h9wqxsS6QlnhW4T9EbOjUDG LT/+lLqGypjUA0cANPYS4vieOpaWsJ2eu0ReC9uIkkr5sQV+5AARKoVn0M5LhGScK0WeICDCLYq9 DZaEjdkPuzvt234C5KxgTYcjmU7f0N7gSDcIfzuW8gbYrVeE7wmCimYcdlYR9B75ul5wXkEKS6mH qLAcJRVDh9mEBZdrHUSxBCz03kn6jEot+u+regBHyt7jTNm96w/rhbIqiXteZ8Nxw5zIdpNRbWSt lm5imEXhBpg1+FpuBK14/OpQVT3POjAB709k0K2Uyk5PGIJMnA6WKEWZ5tLbsldZ3Y1ty/tBg8ab 00y6zSrmOQIH4tVvNdOQxsWeFodcRE03VCWbmjRSukEQLeEyqr+1oSKvS/JaIdqF6sEcdZIbfTiT mKqYKXALpFIDUg6NSox+OBus1MYU53MsM4mcKA+f4TpaNVq6kaJq6KgIjIj31GfcO8IqnZihL0EV EEaKufAHlVWrNAYVFAAKVPcd0gOKW6WK7fcfWyPQZahQdE6lPzSgN7b//gt6wF8/lUO8TeU1FmL3 JWPAmIj7mnt4r32bAqceFC6fwuxevfqWXAZMHiVeTxluLgJar/kEjqpx304xrw4q4NJBVa+Mmpqs t/thHURo0Ursb/qZD6C7a8F4mVqc7KaxtH+pzYT/ttyeoVPcxx/8sfkDGYpuvz1N9q5k8eEM/vWq yx4BDL2Ze3WxerW6Zs2PMwgixn6U4dL1LaebV95QqrTyhGwrHqiyDmRLxE+9gR62Kk5N7WnLCHhA o24a9acAbn1+pvMtgP1paCKpdHYaMkqCCXrohiW9XrNPFKofG5FLMnZUkKmXeis1fcz+HGlVEvAI 23QdArqXhztOS3c1vQcDCRCBZYSg9C+ydRiXZ5RILj/8TciDeo3Ae3VzZtihka2AexMKdzu58TYM 90qEu/cJ8N8bogORhjWe5gaBCYr/BPDeRb2pDO1vRvCBwUwn854x13sx9tMijsPKKU3c2gvf9g9f KUDpoY8wFckgBYRjDrcSX4A29WOK1JAyh28Yhy/2xhpAAnjrsa/74RD7I5FgKngzpDv29FZURlQ8 3Rkz7GPjOv/0S+b09nDtwZlEhzA+Qew7DgOcewgDewBPx7i3kLzAkN7AAMIQRAAw5TaAwAhoBPCC SRiEkAMyvB0AmekE+Qn4AQB24vjr50GUSP/s1P5no/Y/O7V/b9TO3hDWXvfuMP7n30cQ8+wU4enC QSiNkTp/pyhEAj9l4Ol6yEF5z6T8WjTfG+HRz1we7jXQTTnOkfTv9MlrT4bm6p18SR/d75qDsLKU RTHG3LgBG0ganSimNosCKfSshkb0CJHsw9HMQSYxIQueTvoq4YUFy9MDMx4KmjKVGoiUV1ZGFItN xuBXO+2gWXRXSgJi1CxidDwTbD8CEJO4vTzoo512UKvm5eYWTXyXhCWD0nCUNsJa+SX0OJNqOHr+ CVCFYB5CinAtqbwDQXaBfapsUTFcM/kQLnYJEuJFngYtaB46U5kq1GPDgDJyrlbb0S/vC5gnRNfK dIhaPO2gfBFGFeJkiXr46pxJBAic9iRsM4yUCbgn2fsuRx2aqS8DKi7yphgMyirqVnEnd4MqSA1A 2PjrThIBipDRFKWKjyoNLTmkmKLOxvw8Ksy+8ku8APIdi1/Qw1G6o1RaQ9G3ydxgtQzcf0tBqRrb IvZiQ26SI+MeuiWkK70S1n1rvYxPM4tPGcACwKd+oABAuXv0xRo4RmTESFLbLXm1tOAeQ2XHeHS1 LGbfk19WauuyXotREX2v/wQQzHcUdaG2cKNd4lMrJt/S3DSuaPUmy7CglAfTxY99p9WJap+7SRQ0 qldwu9G/2M2akWWXoV6ZnKF10mh3LySMVBNat3aELu2QlOf/rnzRn8K4un9bmuM1kAsiE/OM3xDn ACHldW5nCLqrtNABj4jSOhdLWvqu0eJe7XCjadP7bmCMxkqB/BAPyvsztbRlwqm/Q214jDtmjZda F4ve/SmdVn3Eh7vkQFRWb2OlWsoyYTALncCnpDhRJDAwmQEutcPAC6SkrdUOzlv5jjF4s5lLJ4uG lBFDZ7ndvdrtRqoPeWSX7WoB8sc4DbJyGHGPXN6vd/135RVy0BAQehqnLbnEqvWoQaAisGFpYSZk GKLINPsXOsk1+FJPlA1KDggHfMsKoUQJcoXNU0TQWmqQCHSq2KPc00avp/CnK7SrTZqtDlWxJyhk z4t3nrHWb8Qy29zLOx9lqzYwSMHCm4FRhkpCHlREZSCkQ1rwUlj2lH9+bDpmHhYuEDuiql/M7jbb xaCmSysoZxkN1OyY8Vq7Hd9IdELafLtANckBgqFp39vMA+B+9LZuhmEGrCJxOmZyK4KbeQbWY9cO nIZez1coTil/dVd+/WW8YVrnX7q0TMGI1S04ETxExqX3bNpVxqqTe+rWmTFgjtbkeZ9jJuKtelLb /iDzjW70QysbEsdC45Nigl0dsDF/0qqi621dKziLgIdbAz5STqhMxWwbR5qH2p4RY1KxBJJvbHdx r1zPH6S9Db/xlYIFp5DDlyMLXlAowl+o2eNsVl5gJPIv1q4p2P2KXPHEypt6fSTgPd+ubQ2KPfRm 79f/rJ1jcbhhp98wn2QhdQ30k0cderWoosUGevZ1E5D58ksnzXBGHTmdCLXm7USlFiU9/6G5uVUe kVd37FKpIcQpqAyJJlBNJAn+KIqQZbGBbz6RaqCC6+fDoGYqIQnLzzPdxc40+y210AgT/oHaYR2L +j7lW+mO5Vy19fK8/VHdyM7O7PgJgJkLa4mLmqffM8x10+1fRS17D9rKduNSzI+AttBz9mLrdLVU qAvRAJ+W9VA8OGsx6poyNbrxOZ/QMX6x58ksY5X8jZUu0Oma2yUCwffwN4eqBsUbXsPpREoVC1vS UBLgzMUdHtXud/o3hzEhB9+9veZH5Ekz0g1ADH7ko0uA8DvbocgVxOYMhIOeBYoS0oCxbOhfHHau T3o1pz/Zs8GRMib5PlY425pR3aGgDdvwVRHbwvO5RSKO2IoIM+PoP1yUr6t6CpK2kMN5WT0uXpSq JHDgZbWq5mxnI/kkMRK1wG+zlppaOakf0tyiFGrGWrIf6xgbfk2Pzw/Pk9pArjn9RXPhsCjYkEWG tOeCdXuwqoTVaVOueyK443pZdS2hwmuwlJiVxGfic6Y4omv+uIzgg3/1c9Xk21TotlWdzqSiYtzF W+RPy2VyN7VejncewkDHsaPxk5hWKwN5+if2AASNwwbbM9sb9gec6AqNkWyq2AdlvgQmOc16iXNG UFxDegJhcsN84n1asRVsPF7erzQMyzhhYylWrG89i8/8cLykYTm51D1m880gSANrSP2Mynl91gwE 6LS0mPXTFopJ31is18vXSykF67h4tLCCBn8h9H37tet5ol5g173whg5OBAXPA0xuA6vlktUdVarJ KyA/+G1cs2Y/a61PpPOGzZV+B2/1hfqc1KzYST+JUcqO8HR4XjQPb9mz6UJ+IbVy7d1W+mrL7wZs nJwpNUijsqAwkEpq2bp3fEB3PW4xM3xSZ25a20FLcyHZfvTU3u2RQPoNTvuqW0ecjLcF3tB+JWM3 R+/RQF5tk70d6BesufCSbJJE6MJ8yOQNyyP3xVSwz5A9cWAP4u7gbLSK4AQJVMdKaGxiCUhpLikE 2UyBatL6li05qdBieBYSLG2xRjc/qhiwff3ARDlcmNw1y+Yb+84o4e+eR4vX8uTJor2TpqStpkhe sjFQ2QXHpQm3isj3LcV8f7+y/tH+XgPF1JfwITsy3w+BylK99asP2luUP8XtHgUTGuyX82EYYS3N FKVYSanNRL8STWruSuhiSMpb14p6RnnmNi7E6KHFaSOIWRmNTAtFm1WuL5ioYoM+FhIGih0+ti+t O2yVod1RshAcRQV3m0qMwYZQkA7dh3RMUksOMVSd9lpzQycS3joNf0/zvsTeZAd+z+7f2fiSS2Q2 PZgJlD5f5RFnjDr4u+bugeIMpIom5IUvU/MjG5VsqATZ9LSuNKem5KWo2yegPlRAjrWY4uqD+JTi z3MiM6449iBHpHNxSQpayvZI8qPvSTwiolw0+Dx2FlX9q4INR3+gZHCyWwihAd+FdCsTWXSC+DJZ A/s4XRjwz4eGEcVJ5sT6N35oZ8O7a6meiYD+obg0O2MWhR+hq75Dw4qBVcP/inGAgUCAwf/r02gA EhEik6HQNaGSY1xur3/tLOPOzX/+AALxB1otUjM/LvYEhw6IB0Ka7ycA2IXiWjz7Bj484hMQ94R0 QlHpI2LzLFdWD521Wd/pNOrBgGn7wLMMvslzl7zciptqy7PMs4xkP8A+T/296nsVKphdJM45iOOV wQodBl4pWZrOVaoDrXQA8vXaX2S2ZnuPzZY6v7ess2ju6FpmZotCegYLdi0sy3E46sa0ogB+20lU wokrXRiHqymzjd1ErKyzrLNgsjVwn1nqDc7VgZ46Vc8EFnhNvLJMkskQnQ8mdkjAyicAL1uTUGtM CDfhMVubWl5z5GUAw3u6dOgp0959EF92LKlhz6sXG7wImbrWTE3XIbpG6G4GON+PNrvjJbPggO29 ejMU1Fjtu/JyprSE2htzd6SsedcIw35iW4efEYcOwSTBuhjGOFJKhfLylGPnEc4mZLI8Qwcn+Kxy OUrEFWfX7btx9wIYWN6Rlr6+CkGiiiFmviJZwOXZ0t8P/53ZlS+bL2G2rZ6eBAxPGihvfALOK8Wn 7kBliDRPs1UCDzIJGB8BLNHmEOMwIBT8sO8aBdMpr/4/ZTVK6z0qMCQqFdQ972wFrJ+qEI7ewy41 oDhlNJZPTTof5WrPII+iCJQms8pW7T4Bj6owPFPBc+gO3lMIqQA8XmmIAhA6MSuodap6yPh4TB4C gtnqsWuENR8L1IcTghoSWheF0jWsNcyKezO58r8wrHnwxFMosE0l7G+v4SCIRidAHEtMpyz2Cy/X H8tXOtPJHAl+h5Gjy/zXFa4TGBd4CQHIIMyF+rXvDescZAjNb/5z9G4hf50OuRZwqdIUUn2ZVH1p VtVS6Qw9pJ7Cyi6JAUcoa458xX9lRSOVkvkOcKhWja1WUQGDFeiO5ujaSmmDmVqDAbPiGdi7M4U9 QKLowVODk/namljugsV0grMmg9jzfC714ESo1so/6J3p1GtaGvOOvqpiKPyYnt/bmEcIu8MuMWpr +wSsjr3pdh0aODO0xnhXT//0XNiW7e9URa9nEwyYFGoURaINB97qbauipPuBblvGCgKmyEs8c6QG Vu/PyShklk+4f41ml7fgDg18MHeetrzNcm+R27ERBL4aOdzJ239qr5kGmwMc4I3xFuzk8QmgYLqh Z7CrksSkroXFHjra9Rb2zj764bKlbBOnsmsFSsCwz5x64l/Kc0LddPkJSCXWytPHNIHcl0QL1B/e UxSbM903XBCh7tRNZsqmuuPnuFNFTiWexbG/UmBfwVBIxhGCy+sQAPsEEGVXvmUqWADy1erAaTpE wGsmkAs8xe2JuoGa+J1yPmSf03Mkxv/AtmiDWdVy0PoEnqDppHdRBLkJYK/Q19j7/9SOdlXYjDpQ ysITyL64JoQWGIDr8kWk/MZYAgDpkYUEC+wRwRSDRQXRICN/jAGCmAmAUDjMm+kXdAdw/EAtEDf/ kXwMDOE+/+VrKBD/9jUgYEAAkP/yNV/rqa/lFOKXq7mund25IfzP114QdWUmOo1eaLU8UujpyU4w mB9SMJjLx+fo691CLuu3QzU24Xnn78DDcp8ZbwUnT+t/f4R5EOyqHgQ5dXKpPoIqv+CoPGg2ePyJ CYVJ+G1rMAehy1PinXrIoiKqCkTFagoMhmY2LaE0GDrrisF8cKhPfAjbITYUa9QPc38+opi3YS78 7ijg88DycWX5fFX6fFVyS5ynaGEh6zzBieamvvCOsfD2tPD2feHiHmJfuAgDhL3A6l1pPvlXv/AT Zo9aPT0wYCpdLr1Qh6CKYq+r+Auu/oLCupFtlQLmwdJ4HcO+UIbdm68u/gK8v3O9B6bN/DBsTMJD fbLxkvA/gpuHEN4gwXU5g1fQLkBPlCJcogY0QquYELfCufO/GvEX8IltCHrBnCS5DWFVPVymxkO8 anAKxJH7qTYSCr8ztdKV8oX8gpw1LaimQ/6jfC2UF54VpFzHoVTW3bZFGiAxHD8SFuSRUgGpdgwA yidKe2Eo/fOXqKWvX3l1SXrVZcXCxg/YywMqsVatf4q/HtHYfc7uevmCKCstSbDFH+F0p4HidSt8 QEhZXtSTGyUeEQxIDoJ0VlKXMIV0zo60u4hm95W5h/CwYr301r6pyGoqxp15bZZuDYptSNuHut+z mLpLu2F2FT8YLMPCg+hRwMP0dMZT0Dt3NoxORvQjwUleGPbfnxa+wO1ZTCGOBjboZ+aaOjuEe8Y6 3iXdiMMTbQq28TFsxriscmXMMsrTlsrNlsrTX6DEdF4iSGSGwR8RVXhk6TDvIS6ppGZaNGsOcA1y IJGRlES/m3evV0+o09W1ZJAVmzh/DkA1i5VA90o9Y0hEG23FxSGrKjCIasiXJf4uvLPWlNpRgLPM kHpdFKaPCyHq1WscNTft5mto6AOCD8Sk+RyFRv8Dd4apBu+bdwFv/Q5nwAn/PmdGFagzgOcbyEOf Vw8YhRja7zrEt1RcISwMOJ2XwqT3Zk9F64JCw586jdSvpQ3A0CDC9G4pa/qmexatgWv67BFRnduD PyW75QeaQVnURBcM8OOcPVMg1e+/jdoKwujWjjKGPetFgFpC8ArXgdUZRg9pUlQIyXKJi1jpM4GN zGz8rlNhAYZrLdmBsNgJqN13yW6fqAqkxJP5qsETW/4JAIPGoAaGZieHQvrxzQJRrDZ1WLWKJWah 1jOWCgw4n/gHetv4RIctPacVCvpdbK4Z+lIA3eU6PMGamUnGqKs4WzNL+yGfAYu8vdqN0y9MbjsT 8nWLRRO1K3wQWMXDqlS1FdrS036uTqwZ+IuyQblBgknc8houTtYtzi1A1hZzDtrJMdj5YHQcI38M ef4I7e/RKGyl71mMzeJ9FnGULXlB0RW2QgGG3IzVCyUOB/7Q6He1pULFYcvZEUDILYv3Y0s9yT3f 4SsB6IfQOJJ2fdpt9C181IfBCPi8Ib1oAceThlwRsuu1XftpK+sagX/ELpRvGHC8enWzLeK9YLtx gI8nM1Hhg761pYeIjMjwi1dQG4BPIzmIVVv0F7Au5W4ORvPKBEV8d1nAF+UG12dPfPsRcmNgaqCM +eK2rt/zu4q4I5M6B+YV67rGdHA4tYgMH6CIJUTbzOdDvIkYJudTbSf2a1EpyFVyUqkPVBC1A3JK vYbKYu63fZA9BNIQFZu+1wyipczZJyA616meyiAvywYsyIm0ucDFkWOOthaDwBJFqiiWwjKrqGIZ DhU8Qu1yMPPjo9Zg/Q4tuc2QeUyOijrGJBZ0JF4+IXa1k0jf/0y5NvK4Nm/u+6NwKUCIHQA6byFc FAuv1ouWAgdtWwR9/5BrCIoRrT0ozyGMnIAMYhIlE7Wxrsycq7YYtjoEhgp0csW3k7sDItLL7PLk P4dXdEiPV/Qi1xDdJnbCMafPGmOP6CnXEBHKIwdP1i0ftOO3ClfL4UgPUYC540ksIoIycAMCWUHl sefFlHsKLP7jNvbYiYMQ67XjxRjbEn9+YA/RdWBvAUaHk+ODl3XO/aeFW8q8R3tYUxKvkFk6ndjl oEYuWuz2nBCE/089NxAe7JDwkfibght69KboEW1cKv3T3pM1cDAQdwoOyvwr4KZN+wIeseBbCDDs pEWdFGKSUbEqoYLrSD31OJeAB/GH1oGE1w7xqLnd3Vux3qIEW+Kdoc2KR/eME14R0v0WIB8XE6TG HAe9+/jNnBJKoHxZh5QowmS8n8SPKToJtL/0OZnZ6h5b+umGabmDip5anhKIN+sH8QAkRXGAhib0 RIx2VddvrvlglW8I8NGxS/SJYASjobHXrL8GoBSzs/xX8QlxQdG99oYnD36UtUDOCkD2ZUzZNK+4 DYeeFJcTpMzx5dyXjARUqYM0j4hG/X/o8gdg4XomWhg8tm3btm3btm3btm3btm0/x7bPvN+tO39N 1czU3js76aQ73StVSVaCLZv5FK+N7iOPuI1o7EseEWtN2WugOOOe64KuhYbow/k8QEdQR0FM70tl FjuLJV1C7FdKKjkfzUkKUxUYuxDvI9IeAFPDc0BrnbBwHHYbwRyiYwyAAReyR9pIBoCpuhHDh49n pi9jqAurlh83T2WsQRmWRHK0GK9LjpKXY1DTadnNKXAFWGvEM6xrZjtT9rKnPDN7xXNH2WvKM2Kv Kc/sa8pa47oGPFPWGrHWcEerKT95EObliDAKrnQYhWcvXPPU4C5U2GhCnzkXaSbBwfqavr/FZUvO cql1DsO+zaZedB1p8U9VGAUHiAq+ewxAL1StDiic+c0z8QV4L5LqgEGoQnydTCYi5E6BoEQHZvpq QNN72Aq1IMCgfiETMoFKEKpRZfYj89TuVFlrnlkUsG7BZbimTwo2zIXLSztK4wYbJZo8uTvVh1kS yn5MJywbjDQCmnLr9VsJNx8QcxFYxiWVYu09eAGHwv68glXr1YJAPUPNzDOz14hnGnvqFsCCAoAL 4AFj2EcPhPyBIWe5tgIxaSPUrxzPgJZgZnh7oREa8RDDsua/2Le5vZo32zOz15RjBtaZjrYLVboD bJwKAdhkuq5i76crcbCmq7hSSzk6Kfp6SVXBHJOZuRSC7JUEMq2nVkqvblRMeAdXZoUZU8Og9O8p cRvkMusqB5ecdyBQNQPzeZgKv0lClFovl6P+AOY05a6vaCFRU3D1DdZRgalzA/DEsyfC3OOy7i7D //X6Fk0Xc4CLejY2Yh1RS0StiwJgA1g7GI4tGYEzop3O0qnxsuiawNVCURmar5GJiSyFaO1/yQYi JUfKMzJMzdSaKoe8xj0xHT5PZiqVBbUUkriBKXYshl3gHqx6IfwTWBtrusFI52ZgM6SCLKBVC4hu g6BiKSwHFcUFqN525hgquZCrwOgjAxsYpCvHoKp9kC0F9uwC712h/WY9Lk4GmzXPLOmZms9Uauaf qZkakRlJzdSIzEBqRMYaCEa0Xy4E+NKqOijoKLIcnT/vMgYx/aFxDPfAy8REZgeU3Q963jq7+z1u 41XHh0ZUO+Hgbgfv0ReB1rTIAprBELsI2h2HXMCA1J/86plUena10kAn5vl08OVgGCdIOhWlrWK3 38PKsHLugQYEjhD8LZQv4UAOvpMhEoANKCowUtPUSD0vHvCMFRlyMdrqajSeOv4iSEfZLj2WWx3v ouk558aIctmMTixal9Z7riahwq4hFMQ291aGI63wFAg+cHXaf/+W/Sc1I8FwykOEkRP2nZiNzN3q jy9O/Ik0adfAYriF12VZLL0wWeFEmybl0QRGakSm26t5vf0fDEskXlcVj3RavgvzzaNg9fZNO8IZ MxSaqOdMewzAZqEnDAiehLFz0OpALrIWGt2KcnnENdqKhqAvVU/gF5qd4q/qEyAtHixN1ZfZohpe QdZXj9usVNSoBbuBSUQ0ucj7NyTzH4ZSC38ABTykL/G2dEYxLEu5rTi1Jq6S7SKN5816MdGCbJds vGJc0hI6us3iK31Jr0v/kfZbCLFS9dD4NBXJae+OD2WgZQUHrBriEOYjuAALwELq5WFvBClVVbvp 4+UwTnCcsJwAcRgAA1AcmMrwV++Z/uY9/rjfoee3fXfLYig9n1FVbuVzlgP5Od+x/d07ftY3+Bl/ w5kwwRWucxxK46c0AvuBCRZpf6T9Ee2Q4uLorRV667QihQRLhWnptjaRCaW70Qyo3E1pr5N7zjvC z8c2OlHFnWnp6na86jTdC3kLrJEWuIrs4k2xDYBzXPhS4y7J7lUOXMxw/LZG9dI7it31P4C1Sq8X q/lSq83yINBoRbZnWq1IE/QHekStPwAFoxG/eZDvOoVtfGR3fOTxkQfwFy8SuWdi4Ovx/t2IPT5L UNBhcQLu2rhzj5J3NW6CQQT6IHCzRi7p/O75MsYSX46wh51hZX7+GJb9hXBLp8fpkU4Pgzb/eHFZ wjAoUq4gWch8Jrqb2QUHo4OtwedWwiYiUdWeugfVMF4TUTkn0T8A01Md9Qf8wcQCtOoBaJjvaIGQ fSkeKbnoR3/TvJk5568ewbLk/9x6wHV5D9b2ERzpEbXdjlfzZkvPtOMf0fjC3Y7ucLw3fiOubS3o E+QZFGyhCMioKsFEEjQoSO/CM4vUE41n/WYM0fSJaHVYfTWMVzFUVc0Fdf4WloRKaYncRAVblaUg Rnc8VUcrUEDBK9+DKOzvhmQFKgrWA/KLvlWvh8uC9dBszL6hXKw3YRX3vFmkx6uR86ONP0wJbo4V C1jEue9BmqCySwdeVU6anSpXhTIN0uN/IrhqMT3VL3t4MXvy9dW4QFFAiy5NuIz9t2f6kr7G2WHU hgwsQMiJYXRpETvguHJLP9NnSnEy+1WCZR0gxOQUennhs3FH/Z6ps2GIGwurBKu39MOevqbTV/O/ p8eanmv0cvpy/Ia/0e+nwWt6rNGxBqPh9L+B1K92wSX9l74Gr8FrtPcsEhykI0wEN3BJdqIcBJ1s caz03sQMmtRb8MGCTyDoExaqBUNE9N968zyGY41e09f0PIPrjHsWWBnV78fgWNPB4DV91dPT9FDT ERBwzm4wnR7p6BIx6NtKgYfrM8uK/Aaeot3GNdbxwFp+tyYXYqgPG9k8ZBEnIqaD0WzjICSFhX1L WyBl/iL7DrS6gYbsLKRaFXcZh/zVIzTW9Dl9RU9m+hIc6bFGh3NzOW86PdPX6DV4zaaxwDuaulax hPOo+ERXVZkSgbUx+51IzayjZ4qxKIw/s8SJGC7dR4G/YknvDrcEASDYkTm9bwuPIQPpAsX1BwAv wSIALk8C38Al7zIrXSdqApqR9eLvnmcbyddhJQA6tbZTXGKELpzvnTHIUAOHnK/ET1+jKaMHUaUI Y/QBZlOuliflniXsff+Dbi69TRYDm9dEt9PX6DKj1/REX1MeHyl78UB5fKQ8Xqq3lL2k7OUjNx8p j4+IR4REsJEhQbCBiYXaw2muMSy6ai82HyHpv4KonZSBskTQtA3ObP/Cb8lvCeu/8lOy/SNYE3HN wKEKboLBOupUU1vX6aVq+8Ce8kB5pDxSHimPlLX0f/4IXdr8zU/vw69k+5dc/hV+I/9NZZEfPMiP ncL2D+z+Iz8l/Eb4jVeJhIW/5DdkfwCXCOHnao3cpMSTqK1LoHzvQzaRLcpPLh9r7njrWKT0mz3d QbDeQEvNy5bRV+PfPf7T/yXozs+DZTjlhkR3tGRl/Pth0gX6Tf+ryPGfHNU/HtOveYdqVNUd1mz/ fBaEpZRagRiSSBlzjF7u9rUzyFV9y6IfM+s5ZhMuk6HsrK5vIlREq3bIDLJT5wBnighoTc0zB6aW WPkV0SkuavEe9R4haC3RuHbbrOJI95i9EN9lNFYgImhA90bBFUGY0UO85zPe60qRzQHuLcOrCLSz igGnBdggu8E5WX3T0yrGym88J3/zCIz/D0mOPwBk52/5LWH5F7Y/AMXlcbyaV1v2PwDl+Af8jcjP AmDLc4sfnUoFMnwVC95DMmwBKx67yS/JLwmoDds+vGx6qb30FLRuQcXFut8Gem5a3tFHafpO0AWw j9A5APKP/SPZP4CV/wwjfzsCPopEPuRHOpZbdzniJhKDXLIK0N2aTr0QP70m/kTqV4GSjg/D4jIL uzzHEo6fNIvsUOKORPwWvfOaK7K6cGLnoQLUWrkbtlX/70wL//HhD4D+vzT74hPve3xl/pO3+CP+ pNYfqN2wDCX+BYbEvlETG0B+xlf8CX/yI77yq77i9/iDIb94RBxhoXdVsa3DWUCUwFlNjzsiWAeq 2loU3uMUoJBkdGAaG7Snxbbm6b+dqvGejRnUv3kBzVeioUpaFuj7BBygWmDV8MmgrGzq3nYWe9cB chEzv/aSC10p5EIu4xRzMZd5CqohSSBDgQWgINzTrdnWcI90zyzrJbrVk8VYOv7P2Q1opSjDNrNb 8wz3cI8mo8gEruitJ+ZsXJ7oLntoD/c888xTpZEZxibbQ5EVjMANACKLuPNQQQMGXLUyiz1X34rv Ef6H4ifEjwia9a2QM5h0pvrCEsX1rfgZMfyHcfWtuPJ2cPpWCD6wd6AoZWff/6zRFbc2ztpdIXjV PiAWucUcGtj30gzu0gbIuhOyaqMY69IhoIUQOZEJD5lnhO53rVVP2+zMAMRJmCpsNTu29arNMwI7 d779SizKfbStZ3B0YFGLs2dxKalGWCaz6K1X+XLO2NdZ1LTb1pRxbySodg0280wVa556ZmfmGZY1 25rqPWyVWB+EamvAnuaM2CAvqL1FtuxrnvKeZYD6CypJozWDdQbEDWIbsGkYPcG65plnrMJ+gcpy c8eTFND6KqLPGHEyQEvUa1A3/CAWtwbtOsstyCAYBjZlVzdzrUCxZl9xzJwx0qmEgrgAaEurnamG KMCmVYlSaHQvGnPrKqZNtNk6M0mCslMuzGF2nvIe7tnWWFRx5hppRV05bfqeF0ojDBJ+djkRSl92 vmfwj+JHxI+Iha+i3N2Iyfp2/MhwyZ4xpyyaXd5xS/wb2dfUNc+44JiRGVtnvKAqtWZPXffAXPOM FmuwAq+8ruUStbVeyRaB5XC+mRIwAAQ2ygup57qjr+m5oq97fPpvpUHnGuUMzjXbGtfcZYuMNeSc gZl9CVt2qXVmXwPX1Ahr/Hres6+R1HhAQra4wP0B1lQqzz0sOcIeSGU3W7ZsBpZUZETWVPYY7jN7 LDUjReT6dEZSyz3cU9fAMlPLTF2zyPbC6swZl+cLWGZ8lmzMwDJj9vXFhZeK4b5jD9vMc8tOzvgZ ItfUeLjQXLM9QsgellfXyDJfKi7ZcwZPivq3p+KBn15mZ2bGJXPE7syZWXHFnNljf6rLwDpVxIWe utB6pNvuKg7bpV+BNbZHZm+qOtXTEPaEEsZ2nCiAPtmE7GmZLmJaxT2gMwggEYeT5X+jjOM4ji+O A0f9hVydpEaZM65p2WJXyJxhfWR22LLLnJkd+glr/HbRMzt2ukcM2eIS9xt6asbMz7DkCHvI/H8i hh4vLjllZ49hz+wvO2kV++GMOe6hM0OPzJGZRbYXuvlfrEEP+GJmEXrEzH5x4WXG0B/ZQw/MD+zk jMszxM6sx8vsbA8Qsofl1TX2eHXZs285V7BvH1buAXQwjux73vMeFz3HGlc9Z5p3uGZE0HO5Bugo HFr3+9bUxDXOogoU24TunuKaYAPgtuQFkBE9Xt1OJ3VdiO5DBTNRDDgOu4sAAQpGEZJCMWKrQtcr Y094g6MVaAetrCn0/L+BwWAwGJMXwWCJvYakmAzrZeRc4xqe2fZYtYeca/Y9qtAODEpDs4/M9Idv +YlfkXS+J0XLwTU88xTW+P2iBNRVEJ69e1BpLkMtTlrWHczQ5wU6LcoNjYgMJeNlTwjZ9rjseU97 NlcobJKgnWWxccS+nfGl1uIl255eguRIyfmwqnDvITzznt1se6hTQb0RXL/hLvqB3h3sASA2558M TbRt4RqjbKEAHW6FGR9xzR4fcY1QNAxRA8tAqh+/Bg04lT9iZCGTC2xhAKERG3kxx7qGZU97jjXK NfhO6JmismhZHMRk8U5Y8sTFK+KebU97WF2ftqckD7lt4Zof+J0f/p3iVx//hRW7I24fuIZtjdn3 n7MipAECapLFZgkgq0Pd1VocMTyzb2Fb8768qHTiiFUZcDVLfgF6nx+MmqiFlHP6DkdhKbMMOukd htioGXARt154ZtsXEJ7xqQ0Ju+ysLV3VkJyGg7axz8wgvuU9Xp52ZNOwUBGNsSmk1jKVPW9xcc2+ x30Ne+1aWLn/wMPhPa563vJ+jcuejP8bbb2apV0D3iWEUEn0FEua1fOIVzdpJL0ibOdjSvGwWarK qnmKtn/TPVU3qIugDXvRilw11dQU+AW9wTcU4QAyujdudB0EajNv+bnjC6nmvqbukckaGHtq7qmx R+Ye4Zqae97jMzyz7XHZwzNnmn1PZl0JHQfdZcGVhqgffeQXfYXnCD/ngUbCM9sennmf8x4rekJV G288ZZfsmSQg4uYhVcuCULY6fchwBR9oupxwQ4EHEtHJuiFaXTqq58DFRiteAjQXHo7Jlm0PT7xn WLO5vqi/+DDbHjd1JQjAcwlPvC/ZXbPtufafGDgS0E6MnUJrm1sm1qoE1nZk2qh14pmfPb583uO6 p1/jusdny6moj2kAReekAJ82+l+IowTFnjkbmC6w1rTDLdqNE4blaimZBGLjRBbjM8eabb/kPW+B /4IWlrxhVNMrF15gAbsYZLZRMQXXT3EJjj08wzPveA/JlSzSUqMxP+0r7uawFSVMGsYlU+NOXiMG rVZ+2FfAq2GSFhitM2xr3rLveI/L7oW75l+HT2179j1sa850iRIAVRVwTdMDiyXjtbVwgF6CryJt MgfBJlR1syDVrz1xLFRoWg3HLE1dAGY1EpcykwuZlgk7kELD/sN625fwFM9c/ffZbbmpvp3MprUR TlKOFWijAZwLZNFeBrzn6g9gP1cn9i3voSuzM2foF9dYeU9Ph//ulmY1DJoUqw7C1rKA6Z0Y8Kft B2j4DgBGnLS76AuGWoWrYVvgzbSLN63FtzmRuOySP0KS65PslzDWDoez+iTovNlwUcWUF1QF97q8 A9kTNrAbwdLegSE0FgAuMEiN0KErdn7m+FyanZnZ+XtmZ8bu1OyJFdfQmRW7QubU7F/jTtR5T9dV mU5ZAl5arWCvqygGeuASOjPojv0p43WqOEQ+QYAeRkpPelrgQcrMt6B2O0eMb8p108qE3ARxFp6Z FbsyMzPLJ/W3HGZW7PEioD9CZ2Y3s/ILh+EdwjUEEVciOcGFWTqLpb3d0MwSZFiAHoA3JL96fPnY cc3s2PHVxNixkUoRQ9Fj7navGrFRhF3Yws4c99ClmVlBgQo9OdvxHK6mWaxomPKxY3mZgadUlBYv 46gzd132klzxQWboNjPbE/N/s+yare3MCj1iZ3ZmNl5SP3mGoTM79Mj8iG9aEC6FLDI/gj2aXbS2 brGKEQJbkAguqwV3nxAYskS1x5uGzqxH6NDZ2WM6RqoEVdxhG13eKrDYwV10GDGn1HK6tsMl88PH tBx75v+5VPG6oGBwjbC4ZHmPlMR13vQo75BRUODPQJFhxYggVUGe3c+YWyTsAisiwrXQufhGSnVd v8nI+NLyzwrZ4KAnKdxykadkhaThekN8D6IswDN7w8VYabgTqfHvQJbjPTiz9/QtPbbgLTi26C0/ dXwm9Xyib+mZ/p2eW/oS/e+TnumxRWfwlh5bdGzvwfS6oOcWLXfSDqKbp6ytIeplNGSLESAiWxf0 PXh9S18EZ/RvjATR1yHlQzzFU4SbnvBasC6it/f0n4wpdtJg6gZ6xVQnAaYF8mw8TI/o2NK39C09 DCZpsj7+nR5bdLnDZwcc/zL4AyB4Td/S0/TY8iuHLy/LqCVl5xBL3ARjRAV0LcrQ8iGsBGVAJ+U3 cEd8fu/tPTrVM3qNvpoIvbnDUIt1RVTC7SnMQGeuIYU3lUc0vShrsNjSt/dIv1NCtKoL0IYtk6XY JpDJniSJUEQBFwAykTTqBugF3TzlYPRoxYJullwTg9Mlne35341MOTO/tLWmx/YeXJb3aHpu6Wt6 8ILSD/fQ4A09t+CypG9LXNS1qBTsOnIPV4h2wdJr7BGMpiWsFXYuwa0HhEE82fBZYPD2nh7bEgze 8tOHF+FAfS1ivB+3HcUVwD26WC3cV1YQd8IorgMzwo5GXMQnR8/0DS6Oj+zze9z7e7blw3kcHym4 fETmkrqEW1xyjLguH3l85PGRPdvykcd7Hh9hXT7y+Mi2fITbe1iWz3/00e+mUaR92e+/Rp3xEW7Z Fw//NeS6eMDbR/Yl2/IRb+H2kW15j8vyEW45w0f25SObO931BXn9TxPh5gFuH9mWj3D7yGM/8ohx +EiWusihm21L15beKLWppsEJQHeaFq40i0MuwJjISPUmo1zA2Pm8ooa4UCt0UNoWezagoDBnPZzT /T+v/+tufOQYH2EfH5E7d1mkrOmEHHKLirwaB5YLgUXA7HBhAcaJhAxoGlJqrLVVaSjamJah03Rd mfQkZ/4/P3jsR3b/iynyPYdxqn35CI/YKgnDkw07yhGYTdZOEKtW2JSTF83jPa7rfyh1+YhxJpR1 lQ01WLIHe9HyOK3ei42p0x3wgB4INLMXO6UQLescqNVUjVr5jXj7yDH+DxDePuJ8LVbF/uW8SM3q wAZKX/eWfvsXqnYzsYJjR9N7pYx1PKEXPAJBXGfRwl6G/xzy8bIv/x/Kl1pFe/v/eQjb+J/sv97z +Mi2ROEO/Zcw2/L/Q5OwjY+cYzuCAoQSaSRY03tuI0vrpqhaQ4gAPZhhoIsES1kdOzctDc4OOAVO oEpTVszJlKgkOApC8VIbitHZ/uV/+LMd4fb9NwR+/vQ6rAmq532qy+uBJxIh7aqb5aJQ1rAw+seF fcnjI2qZtqOmlWjU9IzaaUGNWmmLqB0V1PQ0baVNC+qoaYugQSut6SM1tGyOWEyMC95Lj29poyLB EbTTVtSo6Zk2ugclbaVVMOpM29Gu+7cUSNKdh5bItKBB/ymmTac7vI1LX14Q0ixdEs/vpP0qA0oz dBE4RWyzE4M94S0NlmkratpOO9LOAIoghylPHh+6S2nPAR1GCnQL3VkiV9UAuTjcCv42hRyAAbe0 HbSifqSnQc0E21dGaq40ZjtUgnY6iB4ZNb2gYaKXtlZjeRWauapHWkXTNlE7HaNYMNLHcuTqrAAM +g+YWjsgwNN6kFQFjZp2pIW0cQ8tBWmRgmAW7YUji6h9GvBft4/0IMbGyDAaXbwVEaSAZIHSoi22 oGnTaTttTIGImUtyxi/FOFPtTGtQ0EibNmp6xAlehGiHZJYA0KJ3zmjaStumTdtGjXA23hqKIR6m 1sNBncqIC0DsCQJHmqMnJ+yG7dmqwl0AFMACHNEg09YjaBs0U8uKNLon0YJ5b5Rl5Zk22gQA1DIk BAqg14IjBR83rOvO9Eyb/21CmdqZOLs4mRra/i9nb2QFBcVGwEDwvwwPD72MqZ25iwUB+38SJXox SxsXUyd6MRtDF1MRU2N7E1M+Pqj/q+uR06stHX/VBbuXr5/oGihTW25LAMFgTqbp4h4I2EXRdQV8 XiRwV+bfn0SRiE86OonbMgqQOdImElU0EQ9Pb3/6fIf/x0V7QY/lreXu/flSz//73r3Mf7X67/lq 3//7+xNxJ5t/1NdbW17fn/Pn107OjNP350YeHf36xmuP3q0zb9bv4QGLflB3ns6fF3vdTsT5Jb2j 7vWSjlFnntD/czoLr1Xa06K/ho/XK1Lbk+2voWyvcLHdld55lXI91Ky73XJaOJ/h+odXv5Fn+BJq 8dwxiwVPPeHcLjN8pBjyxkjjqYE78aOz6+3H9+404kOtZJVUKtKi53nFI/LtAUmJxhp6cSzeyZo+ Hw4zim36KHLD3ejDhgh+e/kooiDJZzf3kTWh4oOweYLKkA3NEomKsWNMu72ZiYVXZFsrPYU/lkas theCWfoukOXv+yUcv70ev19G1SXavlF5cUpv60QAKFrrnLGlWqTRzlmpZPUe94jy8W6eqa9m4l98 rSKlztb8DAOVt+fScn9bfZRb0oIvLMuIKiWRdegUr6zi6R8F+javHoFONQjvLklt2dntp6Ti5EIs 3RlsWU/wymXZiHgR8a5mujjQjNVl09TY54vvPPBREXpPqaP7WoO2Tu3Rrr16dmXdh74hVRMculpL QZcxUm6awbjACO/zjxtrJa7V8aW4rcoV1ZQhepuHzf19wZq0KrCddY15i1So3wSxq5zKg9Cxcl6d VuLEEi2TfmqcuWWLaRKCRYSs1OUgDWnYJcdCgNe/8wSTofyLxWNhJcw6MUZnFXnJNvAOLR58oiWR yeRMEL2sfzY8qIQI2NQxZX+KX9QNCrebarFd2uXd6aMbxquRr7Qyqmd9dA0PkSc3HkTtpfNzluLU aww/T35OflWJUyddx3liLK1Bx4aDWiAu7zZd2doVaoQyPH4snxKnwhhcVS8IS/bMM5J6VBGmRj/a sk5V3qrnY6ru5+yNuBUpnvtUzba7wJFGdIOjLB5LfQNlnpy+//LwNFmqOg/05iYPqTg3ZU/7EsNS YqWlXwq88Dv2TeizjQtwO5Y7w2DfEdIfKMHzPM9MI3AVREQowi8tjwvyqLeER4gLhcDGNUbULY7d OXGv4h71jtliao0AgXp9loe92XvlpUE4SSrhmDpMIVIpWwShtjsH1r15MknT64c5wArxwmg3XXkF ek+LzBxxX9LLBQVbl02HiNCrnzYBMpiNKh3QMwi671Nox4UqxxyJMhy3d2FScaqyH+zr2KttBV0Z zyWzLfALjULkwwP4JnmoEs2/itvrYstZx4o3lzRNrwMSPhRbVvgBy/cYC0x+dZtwTwYdgkr+1lsu 0+cA4LPyWBh7/3kN8xikhlEYziOjf1pJoHOqNCYgxRGi60Niog90rksrMbsRSPUYoxclBCsyWqe9 F9LRuS2MitVLeIFJkTOuVxQYRGRzN7IydBbG54kIFgo+XSNEZZil+RmdNU+cMYNDGq25rQ1UtlYo 8MCD92OP9A3tq8gP2GsSYL1Ko4t4o6HmGq2lE3L0UKdjHpRQbF5uPGKs8MhorkgkH0YT0PKKaMMu xKKzDeljfONUmm6ks29nS/DQskjioBSPkJ5ZLehuk9+cVFG6h2OMYPtVEFXozmyFx0yk48pLBFXn Dbp+7cm9v8L0r3xw7evqttePLaYdf9Ddx8j7m+5WH5Q7VdsWRH+bMM4+Yuf0QzyZvhNCewCKZRkh mEjcqw8baq3R9cuMVsYptl/BeBtng92ATajjHtciADz8U/apKLtiq6o0lfRoLCBJbwjusX/3Nqoe 2lmqogCD04MFF+3/YhiRbyZH2oiYdhUiMg/BgAEUNfyok5RDe9QOoL7/RRL4VRBiDdYgoWbOuJgM mBzrwUjrio4zAyeFa1LeKgepHWn4sMizNxjmPYmCa2UeY1+2PqOlT+jYUylZS6kxc8PCML5ib/Qh dWeSVqzcEf/UilDiS7KIi9AdWCuVV0AbcehQ2McXaq+KAhgt99xCUnSkwmJv39aQOZTs4qxc9qy1 MqZ0HNlzyKq7DdwXzPtW/EdIXs5NQ7YKBdAk7ercvMJFDFKJthIj4owzK17VJMIcn20gVIHZMXdn 4TCWzMGd0DrKVH0ZNuHihPtuc2HJhg8GTgHApMZuloSqYssAzm1T6MewLTpZAP1S/P6nELq7lL8S SwlwX+m5hCRCqW2XzpdXb32u3HZBYuwSlGEzUaN/fo3G2iDbbyP9swuGRiGq6tycQ1TqzXWwCF2h ZC9mXLEwOxRNTmYIae9NrtgExJYdkAr3/NoFuWEx4pWhspP+mpDz5XoW2FDs44sNM3S5FVvWiIAf JTvTh0mZdE0tIw9/F3bnEXDVNeWmB4yMrITFhNpPs2MWsGN0MDuxWpNKtJajHtJJ+w5OzGa+jHxF CRBkF/hPiwaJhJYbXTLABzmz+R+yEC1f/jatJx0n4j92AVAxtVQi/Kqy/d3ttcoydk9N+oveOftb FzSOOrBvEL9OCpGEezsJ1CfRffR6MBUlaF0MvvQhKlrfi45tMJByZHrFjKCdKB3QiXYCpNCWGnUS 6TL5knsrVcDHryMBghw1H/AwwW2YPXAV7o0EteUgWTsqjO6F7XG/MnRxdzRgkE2YpUIrOzMVWdtc HDHr2wW/oDAFQ1WgTreYbLGZ+EaQywZKBBtq76o6fuZsBKW9brTwF8EmyNP5QRnmD0EzINDbJvDN t8oeYG/w8HUyRHaS6h6hbPyoiRbl4UmWkDdXJU9dlnIch841yaUZm2loAza8NV5Hel0OvbS1+jbA cOHQmK+FG+bZGVA41TDmrQLQ4DRBfhjDxJli3bCyAHKJ4S+GlfVJ+45LdpLf39g1CGBeGAJ7lHFw SHBxUrsyRdHTFugpEkE8zntM4K9K+X73LZklQ8RZwLaWfEA2nT0BkXHOYzLoEyqskaAc/uiOk4pr E2f9LfpIvDDz1c4AtgzfHHxdnXTjylmIJuzlHQYbNdAT3qEYKsL3Ex0OdopdkszIyjq5+iu5z8j6 xwoMuWejpPKHbqCUYiaPXGvFqQWmTFiooRx4VILnp8AuLxiN8iR0fajzqtaGES3gN4qmyMcv3C2Z LDAmYeamUZVdaaZaZ+whlZHKU0v9xCkCNH6zsAQQDzKF5Q/BFchzcYAnzuPwS+vZDQ0g8Az43dRq YtqEXErQ6WLDk9JoCu2KzZzG23VPldp+FHVGkEMUNGk3axcMAbyez40KpaO7zreZIgvKDqhi/FfV lfKaEdMy0NubL0NMoGXAnJXVnHZQfzZeQMV2vpK+1iT6WeMo4R+NV0V+vIGYoR1uadPctSlXria7 7uDuHBVAnUKGAxw0vkEwO2hhY0hD4PzAQFONFyu0IiDGainuB/Ls1ChrW96nD+hjHUW4BfGDwqAR 1WMK3oteYyAWK9HFRjlVaSP92J1/H+teUWJQy1Z5zDOP7VROBOKvaWoQb4d/m5ETHckPA366ZV+K Lkp+1RmWeV573Hr6l35S3jxtAD0I+YeVD/l8mPjOkJ6g6HdT5rfRtJGw/tL4pURC/BeFvLIXyP3Y vrRvw3SZYlkdGiqeBTKplomDpGcz8bvMuUzeXSZTKqVnpT7l2CzShbodMITy74se1sWVvJU7Mulr W3UiIBAIJnjXfr5Y+Bz98KxC7ZKeRkrUQXZv6k+FYvEdkk+RmAmRLnUSVho1M3xo5lx5A48O5Vet fTCIVYHy5SszHcMnTiFsIucxg3oaqdpvSTa2evpvmzhM6+sCSYs/KZ9UZKSds0DWpyAxYewsv3fe YREfCjc7XGll4UoBdvlPw253KsDoKvVY1Xl2E8M/51/5JZQzrSSO2r2XUszA3k9pTNcpSrvC8V+r RSZ97Z34GbFJBWHRslXHIB71FcDAK4o6wx8D6TYikatOV7+1L2Q9m4grRwejEbe5ZINZvvHR1C8/ wqLNhjVMy3yAHNfuZfuo/ooENWvlpLL8z1/qC9wzf7lKSmNzk7k/aUp/hSJpenh28696l1XBo+1B 6Hom20xFmT1rIC+zSxFmo1B1qqDav1dk1KlJlapskHRNgJYbmcBUWPajfo2dN2cpaMgWzS+965Zu /nFXChkVWkwQAWqY+5KdFVmGBNCDcRNVHn9peOdGpJoUg4GI/GzSW/a25EuUpkFkO0xPmyl4XZqf djHktwN2vqwqg9JPtPYQ3byWFIsMu3DUdk1INnoEuzJJmyY1rIQAjyfsOp9mWFYylqcl3wqXDm3U BmgQP4V3XWRfKhcDew6LKi1X8LjMbOKfCLgYNPaGeuY20Uy+NY7j1pe5E2UW8NKdDdZcXFZ3CUFK PDE2MFjBZlAceIlTVuVk7hCOKY/4l7dY4Vq/gqKeWiYLfK7nqcf3VsIKVMClxcl6idfLhQo4RSax XSUgpgwZS0FY0CI61yFMsGMHy+7wOU0ZS4wwy/F0wBAGITrK0Ls+GlpNwqNVzgy+lEH74xl2KHK8 jIeA0O6I/xjyjyfCgH3fFvzwqcyei42k8iqt4z7SFNcF2bQs4sE+pzyX9qSgM7zetdIYqKblEe8D 9Y2NYXDFLMJ9mbdswnV9cTv3l0V0sA+Ej707MP0wrdZhzVd5PzIrbj7eH6UThMmRyrIWW3D7vKzi MJkdKwzR5NfZX7ze5Ir8WXS5vCT3zZ4SqasmooZfRSl9gjt5Ucp3Iq0Onnv+XJ+qcLpQ8GYQ8nuq HUkImrfrMlwh3+6+SSd9f44bD36tXZ73gbNaWmwxkTZTfoVyiV5knGYsKba6FL6nCvFkzvzkl/am dLQbMzLidptYAwjMD+V44fy0oiG9pc4Tu/g9zYc99km7+yn3jmVxKkl0f/Tti7H3k4gCZZWgx7Nf t2TgTxkMPaeHx9rhKLC7HMySmLI+iG1tJ7XApgbz2mnqk0B2tahYeZ2OdW7Mu1PEW4PWOA6Sb6XN 2N8eda3Qq3gu7B04JY7QlxpCn7Xwsc/fxzB2gRa/nT7hjxdIWf5/kFn2/0tmmdkZOf4fIef/F8Nl ZPj/Q3H/bwNGAkZmBnaC/1tiIuDkZGVg+n8XmQlYWVj+P7lwTrdxAp1uM+1W281qm+32//Nq2G7v vv2w3fWZ5/Oz50WUW51OzGRyWq3ERFVokoA8SrEAjbmFkRW5tc2xwLQ857w3obGF0clFubE1ueEs sUSRmdG9/21oFkpIpNDm1Mr+soNTIKkii5NDc2vP/bmgOrEwOvyOE9gcfMuHNHVC9wVEY/LxEfMB I5MDM5Mzg/MR8/Ju+3NtcTodZXNtYQolQmxuenNoZWRyOx/9rVPydUYVYYGior74a2NwcHDcw/L+ Ig+iszk2MTSPkv/gQ/42dmVpbG9uZ2xwOR9C/xi3tbUxDLE3vzawuw+xM7CxMf6qw6kCWyNT+yhC W0N7e3Or+zgRRv1l/ssXwrT4/TAOJBpEZ25kdfwuL/WH/kY3LXKLMyP7W4PmxSZG5uvsbG7mJcfN veBPuOgn0CJX1tJGNu/yd0qK2MCC3tz8rsYip6jwB4XW5sjC+FnuAd/9G+pMrc3Nrl3/C8vQ2sD6 swbyMUb35kLVhgZHR4Y8/Lv/Gwd52WdjRjb3QfMS84IjA/NBBvdBdid27vKXrbk2tH+0P+jPhLWJ 9e25vrl+kIWtyZXxoZGR/eUU8OTE7Mg64Obuynj3+OkP/OMMMjIYYG9jcBpjZ2Fsbgj9vLv+y5CV +fOlMT64tjiMqxeV/4JPfn/++/xZz5zjT9/fmFvbOu7fNYW1kbn/a+/7mxZWWJjD3Y8OC0zFzQ9L zAXMD/zN/+XAyHzw/TVv+zs65Od8Z6/uCRz1X5H426cktZG9uef87U315/iOd7u/0PnTXX8/+Vti Bf39m/iTT3SbQxMj+5M47Q+plJ0X+osn++Nk+K4P+sF/9598/ctX+kuVPtfP/NUu+hMPLaJbW/sT o/joR476gy8Ga3v/S4iij/2jV6uFxfmbJwDGhraO/9Pe+DusM3u8c7/4o80NaR7k34XYyNL8I//3 7oImV4R2Szb2iDYndvpX1/0HoGITK4tTS2sje3KTQ/PbGnSwzLCw/OcvaOoMTUytjUxe7k93029I 1jb256zFhahNzG0Mrc3sQ3rmD2J3YPGtH+Y/KEYXF/eX8GO//pW/8YeTrfWtXBwZ2R2JmMKsz/BY nOjaabY3X+7jjI7JWxo2xbb4SxyOPPCuDnna6Mrjqkz9KZyplDJbILmJ8wtln0yLjcwfcb2EAKja AHgsSGUyQBTwMqP57l41PLPF2mRUUZKi6F8lT0ykOygiETH5fvY955Oitb1OCu/YXauCw0xP12Wf ZzGPrA7WFRhFtsoTAs+lFkPDMaGVZduPT/DLHFAiBYEXj88GNDfDpo+DwIHQ1V0PFy8MMnopOd4L 7xtob/0ymL0G6KYo0SEDB/B6bP9qYzeo65vaPANV6bM3A+0vugGAXciKTGRVNrhkvLcNth8KGn1p 4pE6fRgqsel8UPEXFIz71yO2VvJlx+RQ+AXGDdqCdj0n975xcAg4axVKDMTxTTWd5cgigDWpcf2C fxMeWRijHWxZa4zsBAplkQODHqvZxxWBs14UraNfA3XEC7DNV9Qj5PbkIrjhCFF5RcXG1Z3BPv37 0P84J/7RVIAfH1uWdBAwCRMKXoAvsfCv0Cf21Hxsxtc6IwsQd4+A+lqqLzmNOL6KdvcC8w77tp9K mk1UbpwJiY5nvd18IJr8Jkq3qUCDh2feZNL/FqfYjZ6lbfuROSZ1RPEa/GlohDvFh1Zm6FPRL48t KhnnIFTWywIC0fDb3ADnkZ4D6larHLTfmYh1Q+1SkN2P98xXveqNzH1S3KukGSjU9R4rsrNoyZXg Q+wfJwDLvWNSxSBB/1EVqBOfVLWCZvedX6tY0u7ogLZpSGeU0g8iL4tSSXS95ERTaGBKeqw1H+x1 Gyo/hhNBEG0jqtw2vzHIpNb6ObRcV0VK41W1b65WOOyL7YXPGE85d26aKqHNkMfpzcfSv6Y4/Hpe HcqMzb5kaLRgxeuesgfyPxyQ4ifzATPWWqObWKhAnsM8DuAswBAmiMl76nbY5Tu2OstIcJbl+M8W TRbuqzQIplmfaiAXxbIjczDfYJh7CbT1pBu79wSSXp/0nghCPc8kc5Xyt5EQ7xTONuSKaTjtoLF3 tlRDOd6eKLjF+Bf/obaezgiLDoI7ATHKIRzclGZJP0pCNMeIp974t1uXU2wVpAsVGbujiE8UNShL 8H3RAhUZars148QhKv4Fezx2Hx95ZDfeSxUkB9sGXtZ0CZfMcSr1aJX2hjpjHtXCTD2n3vtr4tMV /uZDI96j9paXla+AJ0Xt20gOdPgFiOVTegJkKFnK0X/BvB7dhBda4eGYJvhQqJe1JfvXsKcesgIr TtnAn+5kwnxEXWA1Ibyx90Qs9DYrSotaLBNU9Jrzk0Itv4DxFR20h6O5pmL58EM38A1gMGoVC/Yd rQmFdjyKcmTTD4YKP40d4SsukeYDEW2g/G8oavj9KOYfgIBikM6/JUzDLm2qi7KD+44+KxtcKz1U MW1QtYiL6pWXOUJ0WtsPaAdbOVlxRts/ImXoERtPkNiylwFG2id+lNaxLNj9dNPC3MMsWPgrTRYx TmlvFPP6yXqPrDJ+68E0nYtilZGGJD55s+2ndN15XHAxfa9fHDhQL9pjunnAHd7DjdYLsNL00tTd N2vrrh4OGQnH+ArvvNP2pjDiG8c15l5i/Qyay+zelTn0levOIW2EL/J+DqcFcPZkALKFnwNHjowa Nzhw2+VlphoyaZLR4LV/1Dhv0wzJGw/srBmyrXhAJtmEQelbqRS1+FekxN9OVmPC+htvcOcApJfe jJg6vO6PvaHs+T4mF+UlqqkfAgQvcLHWoo2/Kcy8WA6y+oANsTReV4YEzccNqlqCzKww9kyivkVh cjqSAQotlgj0c+r3WV0ofDU4iH3KYD11Kk8X0Sq1Zmf0zkIGZJ7pzDMsesf6hsp78uXRw9BBXAfP QXDQ9HHSt9SXaU0kyuknt0bMB9ga5HhKFEsQMglVzNs3wYy7tGELuvFn9JYQeO7JI9HOMvu5kPOM VIakuVJGApGe0meUDwBuR9qIsd69znP7otSp4teRnVp0WFcbtkg6Kv/swR+gXUzFzsjv8z/WiaoQ H5o36ecA8IorZsjJcQbDtnYyr/dJYwYyzHQX7KOe7JnpcYitB+SiiN1y1PYPThsQo7kIIdPfCC/V e2rVGmOtcr27l6BrjYA0FNQCjeWycQeyy0TvOdE4wPjr57hPuVPTsBli1bcgyur6r1RUxTNwtr+k 7g7t2GyFrXHG/knsQ288maRzb61qT1hF29i/15n4HC/uul4cUuX7EOJK3BbwAeOrBfUP4sKbYRTC fKTrDVWR1bxXQJSlqKYr8f4Dao/LBgWgfBR1PLCjlsi6gZEsJYEdRUoAuaQkuHS+ulBf4v8GvvL8 rZg+PywQbkZY0SY4z3AzHx7KcQVcsS7iVrErWuLrfa5sqxmWGDs+Dlgd7u8AdOQD40+PeQYodt3P KuGc+MzCXYwLtVMYK2NUcYUPU48ALhFLrrPiHmI43AL631G7p7oBC770yH4bOxRhTyKOlzdkawtk nSZ2WvUF8eoleFQHHYYvQfcyIZijOV3paUMiJwzoN3IAkn1bhn6rMrh/36OAvFjEkcOdIY+F5nyS UKc14eyqP4OI/bpATPKP0gsyGXAWdUpTY7oazcPPmMFmA29WV6MJVLisDABl3u7cW86evnXt6YkU +rcoSxImLuTdhrKpNQ0niK/Bh394ra0VBjBhpQToW99IospNbxQA1gVdFzHe08HnP77iLHk40KXS SVYdhq6SbYhv8pDBmlsYWI4v33Ly+VlM4WxcJl7EFVun8KR5xd51JlaK1nPU12IJkG2xxLguoAX1 7sT87G8+rfJeSvHgvnDBTB21CWu2YWP15PgRu6W+pTbFhCFrqxpIIMSLInpVbtim7NNj3NW6k2Ng mBrH7HiFYD/FBxJL9bLW55jwEAPUbprFhwDY5gj1Os3BQ6B6l7GtgLpL3B058tVpvG67LqRms7ln O2L0NiMmvThUppbWxdiyPsadYhAIy4NkKfu/V35/VCuPe+uqRsGPDo4KrQiqi01IvSSoP5yEmH+Q vusQT1M81tUhoi9ZMvOQ70XLbpuOsGC4tElGE2Qt6n+Kao5fGKAzhwgAkkaktFYNbL6q8kKC4opp vqGpKMJLMFqDWUP/MNgxJXzE3KYb0q2OzfD9xQZomZAvsJfw3kO0bd5fS7jG0kFlWLMpzfStxYPB +aWSCa42KwMeTpJVw+HGZ/LPhkuXCjoVq1BPhn3+xeU9L6lY2MkmynW9D+g5XUBsu9oe99U6F2ff qgNB+TZBdf5ZL09eeE3A+qTkQa63K3dq+u7JdKkqMfdKgL2O0wLRm45PNv4z0H/qduxTTA9X/4I6 W2fRgiQXbSr8QSKM3Oo/A3aVd+tHYwNctNS4p7jWkVEuooxrGhBfz3/GmUX7fmVEo489AumtplO0 F64+NE2Uh/n9rXjXpipMWjNYBvAF3akLh3r5VU9yJeQvw6X0Dw9FLEiyvu+ja88Syw9EKblF/VnQ 8pZ+Wbh7YdSmbjGQexBpCJO9Lhr71/pA8VXb8sjIfqcF9GiLWdHhPXrCYjfj+EqpW70oJqBlo6x7 RFZtFyBzDmAr1WU+xxUWuCftMvARJPNTxMFeeKUCNZCi6pjVVmg8iMvnXM2IxGGGbk8f6FmByqpz m7pjvRn03MO1zf5tNThQVzPf1pnPZenMUgXwFrZyET8CLqjc2wq9bPUZP7i//6VJsfBybnrRhtgK BDu1zFKc45CbgiBS35ieb9m5kAs6kq/ofUlrByAU/hZYCDcz8Yjg3d/d1v3KJE09fezq67duS8K8 H1HaFErglziQHWZ/N+K0nvUZfRKwc4zMHE0UGaC1XrtwvLHojVeG7O9HQ33tFIfb7iJpEpPe6DVP ZhTejLrDNlJoPsEyk4DShgEDZrzwor6PzGhSJ2NQ0EfTeexkl1QdPB0h7me8i1aZhcz98MVQzWsS 07YOw+YAAbs+mToEHgmGQvKDEvyBqdaEN42MsCGxsiQ3pirTMbF3DNHSNpDYNoHslPY1LI1qaU4r VBwuTIdE48hmRol8QC63duDB6ZaMD/1eIiDiN4SlwgePA/r3nGhs6sdyobzkgZHfTNJh3/FStDlY YRfV1FhyYwgWQFjcBKS6nsheAZ/OT87AxTKh5APANU5M+WsDj2vGpyEROHcnnEJYkAEFmCMg9F26 BzTm8jw2P7WEzFJYCvRD11hv/68sG9M5Y8GwQrf6M1qit3NCibS6qpAr6YqWaJaHRQCSUcPtuk2k oAoVxoOTMzLLqBYhW5ckjg1CgKnVHeyOxs5DPUfaYCOP9wnoNxLRHxKz15WeAwCNAJe74P0iDJGv YrNO3u/kB5U2ZVfEqHEiBjAOefO61bc7t2xIhlYpg6mfh4xpkCaCBVp7TcuWDXub/ozQNBevWKPg /UgX1fGx2WoJiHMQvv3yoLD0L8EeDvqbSLj/FnbCiMcsWgcbSLjmj08s1GQkKdjYcMd6KrGGm3rO GPiqxU90eXp/LpYt4qlm73OMXlwtJWoNPoezYGwUJrLWFeEJR2/S57pjicivB44bGWj3TMf3ItBs I7PSaVIHbNHVriweJjb7TUcwEsZCHEKEkvvHVOsXbELZC7LRRkvffhcoKN/Z9ebKstm9LROPdrTS 7JmuaBFrdDCCHm+eZVwatPceQmGNzYUFNi4lbL1Pe++Atb+UFrsMGeLLWfvRHa5JvqBo2BNGXke7 Can2NGIuUL8GVYbwSUyD7Z0Yo4Fi0II4jisgKFtyLt/pGkKooJYTPKYhDoic81EBWJfwdhAxvqsm 5PbQsSIyn8OG5OITJUj54OmN5By0F2GljmdZVxiCMOye+h5mBMs8a9tw2XwCyaNiHeBLHo7h2wnR 20+uj/LK3NVvcHbYfUidmoQhLjIr4jy5hoN/gvAGhu4Xzy58/ccXL3ZY8N7Sxwe+ahGGhisRhl81 U2encM2rsPPWmcPAlWhiOk+UF5OeWknr3xVLrkODYZQqOMtHNBvZoxA+sv3WAmXLFF5o1PHc1bjp PybSx64Zzon5XDsP2DKjBe6I9AOmf2wmHaW8duOSiFSuk/nVQyMuN0+y/Ipjew3qHSJUTQh7i+p9 dSRdlWxwgaKFkI66Z/XJl6IDFU679mjw56SgoRGp8lhbxjLufFYqA+v32FTjDuQb/5GEEBLsn/K4 mlN6Z4Fs8XHiItzHjXlsir+eydky5xf+RASGweqxTQO+jC8+0rVIybyMt8ALXYJqFNw8FUVTFP8t AfG6q4jTACtDkylfvrw7/XkopW1xIleBvCEcJg1sWa0Aw7LkVsLvtNjg8Kc2U7Qg5mHKsXhSudMv NMLaRDEIOhfUU0O47U+oHBcfWMQQP4gmJLNQ2rFGWJjU5bQWKbkSZNa3k49H9EpCuISR8KLot/Y2 D7l5G2IX+E0z2NQkraED4gpjrU1eKhPEfNtBwIUx9PnzHk8aWESSNQna/VFCse9NJsJZzaHUDuVk 06RTdf6vPSPuK1INBjVRCHjOBFNzYKUhrJilEOVCF6/ZWlaY2gmwfJNomt4mmvRI+jId7sIL/0s2 e1BoUpq+c2/vO3C14oZ/ZhZr+z4Xq1LFUanVdu97+KzKyfJJm0+oFa+EO7PJFEtHy+WQIaUFXfd0 QdseXx4cll9TzhWwiiW7LIioO1TpsM/JP6zCVliaJ7eAdyEwQi2l61Vfw+l3QlMffjAxAjemG3Uu sKtxW2hSu3jgHOgX/AEMdOG6kteuaYJXmsJApVlhl8MAgtZmjKO1kR7hUam73RIRWODdxUGDHUaT BwOh/5oQB/bAZcuNgsO8IX1UMW/C0CGmb3gnntTNlQsNKH0JkDEAYod09W0dBQdkvidGWHBB+KgV A0X55e+c4QT8ZNOreopcUzTDGon3e1rWuYs4wQgzPAB/VIkWTEUPvClm771VPGk7ZU86FXGEU4gH Qqff5l00Fm00h+FfowcY71vVHh83oI3wC1HIvkw354cuYUlpT2YCupGf075Go4t3R3mnK5Dgy3qS kINOUuP16fctJUVGc7/lX5dYtocYhM5aXEgRVaVMkGo+yAXCQVFltdKC45ui43qsa+jgj5vctzG+ WmSrCQpT8XK71fmMlFZLUTQCLW4VB3EiWjA+QWKbZs8sgTYM8/t9YMFXdYlGeZ2YSb84NGr/rFr6 8tkZjb9Kp9qYXlIkqlwiCaGdN1bYLpbbKscg1kPXdwVwlrdUcaUU7v/BIJeOXnmA6Ejmj/cvJe5U a3GLG1QS2XqFCCHXSxFUP3qnxKZzwJl3BTJGk9bNAc4bp5X19YgJqCnPZv546Fuq+Iorn8DiIZpl tpk3sI88MIGb98tKldbZVL1qp/hQ9Gd8qqy/+KyfpWwGS58r8HnVQpELePiFNK7oB5kV62vqEVkc 0bCqpzeKCG4h0Lr/VpYhc7GS4NJCWuvnO5B8im6Kb6S3NqpbCtY6BCqVUBJzHR4Vq2ZUfjEqX5CE SYqw/eIIU23OHhrKHtdBVRgvrdVh4uhhry0l4kubNU9Y3sLOEIXDTOwurvZZmh+OXp9+MF2MTJ5R /7e7rNp9ogbfndKhu7VN9pQTtP8+fWLC4H3+cbCTwYeQG7PrOWWXRYvCMPOIbtaQ8Ovtc7AKP6Ut ek0lBTVvxlQoSMw5nKt0db7Ghe8L+MiKm91jjkdQYnKZ632BZpdG1WKYg2zh1muCNvlbRtq6LSVo f3yxgXG+JkY0s9ZQGI+PlgSqUORICjfFTbmY8Pa19XnHm/WtO56vuI3jO1lhIMkadEd5FAOfaX2V O2wQ8iQcVWC4BfJsZo2hpwxCoypkipEY57C0LZlFLNxHyqEL8u1rZ6zHq8WRbEIMXqFGZTC6vOul TGOGRa+Neeo7VbWcVXsHByvsNJmLkzD7FIFSDdaU2qFA1AoALd3xt1uIg582l/vSIzehxcVbpRtZ tpwhNjCO7hZ0d2ygWpe6WapnxdZrMFcQo9KmuJD+qDgkCPMZAyWloCtf9AuTK7p6Bzn9V+ZbZdcn I5UTx8q5At5RhFs06x3JrduvfgA+SO2fqEqisR6IGjysAFTVzPxIatKgirhwEEPvKejPJOpWBRmd O3VmekVELMjSmiWSONcBGp74c/oJjZwnWhIZbhBBekTkt+Xg1vVO5oLi8Xy+xTq69aQ3YqkMaoc3 n73F7uhXYcXpYIZjrVDU19AKhQPZOS1lzW99KfogWHSXQmfZgGeMfduzWss+JTyz/6US5raPiOan PNhyxO7k9vQ1Y7YRkrX45E5+D4SeOCpZ4FjzxY2su90UXFVOHww4uyED8GCPLJcewhlrF+f705ya iq/dzvyvM8535DwPZlarUMADvi5GrYf3tW4magHXox7NXKydFO2vl3Ibyqh3WwxJw0FU39aEjAOB UsYksoqyNid+zTx+KgrMUe2JK/Qw0JE0DCgHjnDYWGSSIXClK64PepaZI9WwUu5NJ/HdAB0qe049 +ATyBgUFiR4eACfq8h+5ad/+FVJ5Z+veJqQ21VNC7i3nFwNMiHKSuW3tLMA9ZpEVBNusputHdNGM oYM7d36BAbG+x63mshA+aPsAb5ydFm0rh20IwzNnnEBfd271/hIaMP0hd0hzPExUNZsFNZpg1Zy7 4cjD8i68VqDt5AE6rla8c2cdPpr4U7SoUHkat+OTakgfAXlDR6vhQ9tuNceqBR2oe1rE2Aw6Su/W hMeukoygjfA8vFvwTXDDAj3ZDB4SPDLBHTBWneuw2lt5z2SvEfodlwlM86LUl6xqSf5OhdkPAL2K /t4GhKgHYGWmMb3hB0gUoJ2Y38k916KDbPyuZXKbLJfwanifQjOaJnWgPJTWc2Gnuzhx+i4FvanE DCKLTqIAZ9BClmfN5QKW+7xUvw1LGj2bVUdVJeUi1H8UVd4Q2bQIoFgJlUdBmYwkU9IT9lqFTgCw 2jJOlEEyos9KkHt/rmMKg8HW4hztG8lgCIRyG6xEXo45ouzyUS/JOlQkhWE+dyg1t2RbNv+2CGAS GuQYI1zjPOemwD3+KXzD9wJLdpZcHVKyc9neJv2FFn8EZXC8FAVVNoKpcjJcnCyqtsCYOoMNXcFr o4Ihkp3h6wedL8GQ9KUUXv/EhbQvN1ODocdJ5h5yXvN84PJNQbPfUSETweY5XQPq/QlvmGRluSqS 3kI5f94WpQLUfcdy/qURO4KQTFYLuFOo7nkFewpfaY318XLYh44F5frJLF7b8Fd4WI321SNpl4Eg 3yuzN4lsOWW654Bh+IOtoNkE6rwJg9W11BMLGuWpSAvp/FoxSttNg0/vGWHluCDeW1g0GCv/fkrt sFAehIRjnTD8LV6WYIj8VMB+Vw7nU6QPEqD1xIsSTebClUYjc0lOOdB8msZZyQQvMYGvoKUulh9P GtnZY8oQaPN1ipSaYMpMT9NyLE8anK9/7J0WOBqvMnEfdC3xeBFlhboAsOu3yWR83X22dMpnIE/B HmaKPoP1keaNCh1glgEmvg1vjQXbziARuBCZCU1PsG9pKuPLFgRraiFIGEpqwoTSHHlRVeD7FkTo jErESXXnHryL2RQl5d5FN6kscFej97KegDPdxgFYFUehnTuHzWcccP9qxRcXHmvfOwVSRfmtzzBB 277xHsBcw0iUuRF5YV2HrDcu57ylVTHZvsOX+6lWStcpI0Y0i9KekRG+PTADxLWjt9iQ0HAgYm7Z ZjSH/7fwSSvA7cCivGYMNyN0kgaU5hFjL3dxXYU1dgEqwZqx2IpShk/ak3gQ4Xkv25CTgPMzu1D+ 4BFgcTr1e/BR4F38Rcq7X2qnrOsAfL4Q5qo95aXTx95aSiDkVxwF1mu8xL04ZcdMoVtm9B8os9NV 5e8dGpVTEuq2Y+qRHAy38UYfD47R5mgdQdf3A7OzK8l4uogLp0nWSwpwV66Qjo0fk3hpo7Ty65xd mrCa0L67xRlJoXfjsw8NBHhEWjR15Guce7EkX7sDlhMmRt7y/alCGao3b4GHdpztZIZwQYI5ANPh SsC8X8+WKa6DM23xStDNi6wQnkcJEtf1bgpsy2LgCcf36E6KDkCvpfxMPMPOuLAD4pIvZD1DfaBZ APag3XspIIAJSXrEZoh+mOd2sWoDa/Ao85JjBHYrTpqBWAKgvLwtSsE9GAj0ZvfM441cnPpbkQTd qzdD1EvECE31zs8rGVGZdwOIskTvi1775CINcjWy6KaltytSZ0MSqzXDDdHxDoPIERS1TJ9d/FlW rO01EXMm3y8xJ4n7A7FetNGmTF92M7YnmiygQCeP9jpXCVqnMUlexVeW+Kp7l+Qp/DZOOrbZ0JUb qSdvKscy50qoltSYC0Q1Ao3+BmeEv4+djJShL5wue2sOy6q0W8N2Exxm+q9NnwQ5hdXxazK0quE7 XtStP0chu1ulJrMHH/yrZwH2P8cp3IEvLCBkEwB1twJdmtW5XUYL+7ho3+5H6usbkr1h74cvLGCU doCI5dRHH/WQvsS4Q9EaAd1ANXh1NzSktJ/nd1dTkFMf4oAalS7kAFBxSNR6tmemu0mDf2OxQ3W9 Qk3JWchkkFqISg8vhLa+6Qjzl3O2b8OFzocSibHbZ3ZC+QQ7yqnhFS+kNUnBCeYBEAlc6sRGDehg H7+TuxHCZNn1nu1UXQI5HZkrwT61fpAWitkCWj6tUC3DuT3/KMUvQ3VpOB3Ly0/Q3nJmppl3Zd2n jEDj+OuD//U+77UR97rbYfRUX4HwPMsjgpq0AqE/X8ZB6/TTtFKpvV7IsmqoKpEqUx0OziECaE1T lWYIBWm5l76P4hqFItQJWnlYR2z3gi4qczQGuttqL9pH9+LL/yUDWEQhjTb81TwHU+8oDfO7H/gt D+k8xKXTYXxWbonm5+HG27uhEvBmL/DWvqiBRQ7c9EDxSZR6CEEZQ5zIf4TYV7B0VEaMXUpiyrVP FU+ZPySWh8YAtjMuT9Ha3krzgBvq98s+OpAAHiM46bUPjsVDKJEBeAIKamKv6eCFcGUF0IRqbxHg QlGgics8m4lBg6/1eX32Um5sfKODXmpp81j9eMxbdZzCZpKRygBRIGPKAY2I7AaPc+aW7b4vmWmO 8RD5kn9oKZtzaenDffMZO1th6x42W3OLRt3IPERljPhxK4jkZNVdGy5IuAGQ3hVBud4964ZMoUQj OX0K+MKO6bNiPMVHOvjdu23SezHC3mybVeqAfdr7yGwx5asz9tdPGQ5VEdz3OELC0gl2mK9HSi3L CV9BLVEbwI8zRzuPBR8zAgv/JSqs0xKNpAxGv1t126KPwgrkvX8L5tmSpM6fVdBQZ4vdUsye7DOL FidoO1iAjeE5HhUeQgX6rXr3EumzT2d3i6VRiF3AD3hZPDLK3aVqYA/QZZ3DIqFVL8fUGWuugcWI PvC7o1RHEG9zrU8RcZ9+Q8JFIe3OYpM2PTj1zakA2CK7ZPSAz6ILT6DjmnEPFF5rc6NsSrukL5xi +WHCguKrsrBiE3Sr0VrSkKi9iOvFYljckVK0B9J+hGzAcR3jE7ea3MOMIlgvMYX1cm4JIjfZPEnm PfFWVth6Na7sqAVWD1nNNTYk++1KDjwtJIfUfi/6vbDlq1Iad8p98Um6CQtyZKfjmu5F/dsuuYqG jRFzwHxv5iUwBamFtnpTvHOUW/e3HENzSt0SI1dKO4/XpVdNW8J5og0knyDLcBXUQvR4tnHZsItH SeyRmymwWy0RifeILfBt/fcx8QLALAJbo+wHCSzHdSoiZaO7mEdg5isXQDeed2F0ySOvN4K1ilzV QtXRgIvIxbJuXwFeKXARHsxHRBy55J3crfKFwq/gTQPeZ9OVGwArgEWRYw0JRfpE4xEHBpqMyY6S u+YsGqFN6CkBcIVOPned1qZp0pnkffxPAoJzSMjD9ZyJ0H9X470GzuRloQ+HYDAo6zGz/YR5JiAV QCHsY1kGcOBaikV7s+6o6iUbS3PNFO+DLHjw5KM+FiBgQfSoSmvIqGnXGMfp+/qVzvf3JD+aautc ib5xMXU72KOlTQLjXg2lIGAt/GGCjGUQld/WxLcqnsoZCkGTh9ocD5qkj1F/dhSG5bZTgtMhK5/p Bs60gUZHwZGpJBsiKhcOT9yF5sydAlfU/UM7lVdwZxrRPhhbow48VHihzXb76JKnwWgeEW5MvjoY W7oXr93jAbkdGaXa4mcK/0GDaTPTxiXElyge2Y9HuifTQG4/zWYe9Wr1r2G2b9rVsh+2Ta2ewMuk 1V+O1jZJeuCuSghLIFzw+C4liwY7KSmW8u0dRoI7MJMl+DTcYYQbwq6iZw9Zpcx0AjUTKwwdz3Vb HhMjOr0w9+b4/VS6NAfjs8EAiRyyvgm1e+/UopqXNeKN8J9LimK0kEFf7kl2WY7x4NdX4GzKdpeK 3WaSr0cHtzxtVHpmUGD03rjGBoHcc9FTT1Eqvj4oum3AZe9gtAg8EtXeYALTkV01VjXBnFWjL9Ug RaTuSjaWbQeZ+ZSWvpcH4Q7KnnmBeAbvKHc9eUbROdR2N6wW4yTTuuhGcQEdNYVWPVMfAgCJo1Yk Nlg1vKFyE3ZXLXzAOylmOVB+OeEZe/hIjIK1GFkUzh6hrm8RW/Z9pQqPCRQu7uts/2q0eIUMWGSm kLP6XKCwFJ+skvsfXBQwZVDf37/up4/gFluzA093Pf2l12m428cwdtm+UqUkyYuUWJGj1eFd47B/ uFkcEd63QyI1vFS6UgkOqP7UsT05tCNBdpqvgDA58lmgPyTl+aW+PjQVpFn1l/MxuvOFxUjsWB8O ERbeJDUVAyzqsDiwEHqw/ghlbpH1ntNac/o7UxR4urUY2tn9vYuZY72c8FwcrGsgbxt/RJFSzysn 5SMdUSFnX7f4UU0Pw9zUaAxDfzdBwEmFmOMw00/YBFO/rVDtMgGQOTGzUxfIdPqVKkn/su+ZvnZ4 bJEn5+VhOksBnFF6ZToZyqaifj4vaxLfnPji1e7gN1Ca9GowsNCw/wCfWuCrL/fNmIfvKMPsTnYL BQeVc7/UChs7L+N5A8U689byxQLONQ2XRth6Vl9NJUarMewyntbVHyZYmpc1ugcI2CWIygDdc1ny 22e7/BOcWtwkdWb/2aOqxiNyfQc2Glv5zvLWyV2Wp3k4oiBmRg2h4fGLB0+ORVY8PBWOifSS0ubT 9JnH/reh4auHr0hjT+diO4iSkBUB9bjyOenyqoeibku5wgSeUF5fMxCMLneVLD/Ajyuv5G5Umb61 beai81CQJkfkl0Z9HXR0moZ3cxAUst1f9N/dMfU5VqHeDbs+dBoMM/r4stOl2Nnxxz+BCVeHR9mS QTtZPkEi36OiMW6MiSYJ4tVWpEu3U75ry8gVUPWHM1u7GeJm4ng5VXG7HmpMWi36KH6TPR/9nkEe pJMFx+QBYm2VIE3IQynm4WXvqn+628XxSeF+XLRe3TR+hkTHjzNqnbuHB5VxdGbWnmnLclYeT/y5 WpG/gxC5/Wlja55AYgssXBb3ZLfRP0VhUH8zIC/r2YqfpR2zlMgTGbOhxIHJm/AvzNqdtgjpb2nl RQ2bKrquH04RCgVQGPGdvdQgTLlZ70OYMnjOfHKLqoeZseUMhkNL3qLBCd53B9BlDIiyE3697y7k gYgJk46qopMSR2W0ocFxb7puDvZiF0fDXTHHXbT89/k0JCY2n1qM2xnpHCmIKEg3ws7fEccJE3jG g6cc5ON99u6egvqWtDNJKL8+BGkjfKuy2KdUBEOO+eCW9FclooY0oRwn7xlyTI4KAB+/wEnqa21S bbWOBj6KryN0ESwGFJ5ZgGZm7JMP7dz2F+QAo938tET2mIwGOhfXQ5eTeXmnJNVpQYGJMwhJ672G 3IJX/o83VTybIC+z3rc2ySMgUSl83C6PT+SjwvD9RVAvQlxq9Cjrjh+HZvS3TATvXYzbJwDb6qGt Bo+ROPS30aKkfekWAX/0C9DZgIVh2GCzcx09pURMyzYKyrIxq8O7YVMa0WouzNpJUoXiQNU1l5L3 o4pKyTeuTvMZ4HhMc/6YOr7XIX0nIYqvtDRUg+jNwG75V5j0eh6h8pIsrHGugj1k1ZU8t5pnAElx AJ1L3JucWmTRzuCHMy9QvN49UVxf9FFiD8kiVX53i7Jv9XJe/GyQW3sWOpa7vsszM8Iyx9rrWH9O UqPAyOWF2t3ovrZ0BRB7F8zoTnf4Gs0x4xEORjK6699u98EWd5i2SOZWvzvuU2hR2um7c77SaPDX Ad/1nkhbvaiyndR/xo56iwOyEOkMp3b3Hyzq84vx1+FZJpaTyE2FkkDOUyj22dyeBHvy7Ic7VOP2 t+2jLJFD7bstuDL601v0UdujGzL2i6WXFGZeVnGa2iceCyJgKFDXkTYMRpPc1KqXgITN1NYwsXVG 32DYtXgzHKs8pGoBP4+/2kHl3XXfmAlr6MeTHicfRR+2IHNxm59qxXkLqhlP8kMTYvJCQxXhMid8 wS2PWT4yg382FuSr5gDO6Roj/VK0Q5hn6fmyUIGyn+Zo2vLcBFY6x4knLT+JCV4z367rkXsVbeGN iJVA/mbZGcGQHHSFi8U0heX8vbyV/yQxOx1eviMTEEOKx6g3hcR8VXoyQcU8YQwUM4/OsGEE5Fxh yICYK3GvGbRz5hpgpJqYXBdnYTNND8xUDJmchAR6LOmV4Xfg5YDuz/TYjI2cPZwSLqZqGTIiQyyq 0dNQcWF/HetLHzxiygUTTWVyN1MaSZVJCMeD2d/ZNgBCHp7OEgloLEA6wx1UfUFxdehW9RdlEwuA rO1aaW+wUW1TC5+afsSHdSvMYyGUYeHN5CquqBTUB7DdFRTsOuTMZqn6R72BDOhFWOI0KaQmiWXF nknYtnwv0iTM5i40mgpcmuk7khD2hk/C61jfk4Jpn6aeRKv1L+a1oP9YeePOywQLUHqH4TyBLTbR 0+0aSoiOUvm+/zG6iS5AxRb2tDPMEAoOpmhFL/QYYGOBbY3xe5jYLQU3NExMaXdUu15UVotgxPXw D9XtQdnFnNZVTFs6emXUk1ICFCEP/3O2j2lOYRSIA+e1ZGfDNe3b33o17Li4ksCmVvOJK4t5swtj 4ngOMS7YeziQMF3fXnk1H6FqsFBmGkt3236h1RzSMUWz6ReTwbo+nU4sR9/wXXFE6v/3BaqZHrfL LBdy5j21UhRySY08UxB29AaFJYcO8HkoyLW7mt2FTQzu6k8cKxGG54ZYZdj1Uo3lM7FsV8+edOt7 MoZwe4yKAdqK0R7QIi4bWkPOoQZQyhFCyc5DI7aoGJOxpG+iv1A065ONWq8bx1zJjrAKzc34r6z6 G4y0ZB+ssXSibDxoIaNLE7S+qdfLbxwKceNWXyGJDU92K4lFb1wVTPdb+8Ys4aK0+iaeQZJSP+qB BLl/XgHGSq0+A/vmWHrbVleDzV1lWY4pq7Bj+s9kRPCoRwMzfbfvCpdksLkLNq7gCvWcftviQdEG 98A60HtZEXs7d5UilVYiClwDI1+ApVqqFvYqcmV76MeiWne3J02bquPrWUwal7inZ42Y8FOt4LI3 J6ljBecGwSzHo3dfC56sv6Ol33D66t/TKxb7CieAMp4Bb/VBzTAmGNujX4MelF/2PRZFr6Q7rlQz sBzUi/eYss/L9W9lSKCTA769lrU6KN68/7PqPbcEi7aIky869RFeA6KqGvfwNmbWy1Z+nD38aRFn oHhVxEa9DhWNdR4uhkkj4gnhIYB/vKMhIKHIByCYxFA5/mvYHIzpInU6oEi5RRnJYLdwQ82xiYTx xxgtkb0P6ry1lNBGmnA9RWxTwPnVWIQ95257ITWXVcTCtQ1EKmRlj9y4Xwa44avBjoXTzcp1Tvtm 1Wb5aPDkX/Xp87SKztAMNLysSmEnWyZq7dUeq+BmTMufCHriLJzVVfAH2Usizxlb5hiVutOsziHb NkTHCsHLSZkYuV+kOSmMYirTLv99XYhvyy8MlCh+tGar47roxIZkEjsg7eoKY1SVuvbJ4iKvyq4H qcUz+LYmIy/nEc2FHFDQleg0mYgnC64GdyNuzVvN4E9qGndQr+H+JZr9x/MwKKztvvRZ9Alokhug TTdCuToxE78GrsHE5DaVRCpKDIqF0W5wr+xbX1BvKErUw4upEA8Vo3mijCzTYmyAJO1ZzSOMEQ/s DAp2SqVXIp9Ad6Yy7mgBA4XsHTqx8jNQHJ+tlY9b7PfHkhA13pyiRCMjexUhKLhrYxK0oEzaHsYC m0hnsasBHgok50hisOKaPXA2CO9wrJPoeQmdl2CeT+j+/m3ROu0GdUKVfxPTLgmtqEwNt3H/DLf8 a4YcVIWJgp4Su6vyJ+DlBW5+tRGA/HNlW8lO55t8s4v7+jcArsOa1ECYarFZWmVs32nU1zo5encH thG7qHibI7BeIPecblguPpqy+eXcgbFUULcwB6Mof22oOlvcN4VZ098E6Bi4ygN+hJYGrVqqOZPn 1fqHJsaQlsNm/NDV+u7aQOR2GWqdGk8FPIp7Gv55J+KNMo2KgQqRZMwzcBSGs75GSvyK9niQYE4N 3DzP1HLfyvfSWTLfFVF5NyrPIxuKsLkm6laAyo9nZGHIQtleRmbS5ufxcFpt0Qq/+A4wzFaJ2piG jD83s8p8eQU3X2ySeLSJNZDXGMySGxbv4ikGW+DePNmZrGns4OxcO9srfaVXsiOsdaB6yrCCUICj 3N+E8bikOqoyUcuccHluTSRtlmcd5uhtCmyCcCBbznNrOSVfDB1+MPJDsawXMmsTOSlcXR41X0Q9 pEOrtA5SsSmbnlHFFqUn5DABwSjsUCkjT6uqyJHQx3m8fKQiW45PGCKAm2e7cv/UdyvZIFr0P55t GA+cMZoB7AUIWI/ndv3vmHWD888SmPKT1mwhkgjw/F44eIMOAGr4XQCoihsMEnimvDal2F9jgq74 YqZN2ywL0MnVwjn/K1GnUq5gIEXZmryy6XVkr3D/c/J4qBPsDVHpBBLwsqN0QJiTYgbTLPX9NVDO iPYteMrQJ2N936sYm+nsS6be28Z71HAzcBlKCvvkvk63V8JhKJZr47rJXtn59Kso8smoiM044wSH jRvkGgHLf3WiuUTzf5IqoSh6W8uflAMbwdcGzXNMi4DGzq/HiT/RjNN52rfGVn5Fhfu+eOhpSmMw Ga41SLzENzwI/DtAJp/RGwzCQrhzqVXWff060lNwhNOooQ+VDdzuLcMiaap9I+LajR8WR1PcO1Ot FV87w0WLbxzyswrHJ2M/TOzDKTKQIznXpe5/95M+asR67+3K3GW2rELN7KTs4xYfrQVUSCxo798b rRIMRHFcO/uRF80T4HTEoctAfVInRpAen1w5B8PEY16qSXTGzWHHfBwKpYipTUVCan8r0TmoP9Ut qPMgiZTnDlsh80XvPs1qG4ccmSjz4RK9htidbDdcNcuYfxyFuQZTbqtQORj15k6mSPsIxKGIUP/w G1/ofdJqS530D/j/8bg1cu3zhs2GnPCfGbIMkbNvOP37tt1jwBec6Db29e6rlY32yJ1zkRsnvodV lOmZ/rsZoi4hjJl5YQE0rCcORaIm7RfnaOBvdpYDpVbk39tOb8GF0MhyyfIcXIyBHt4eGXSCgxnN e00d1/MyoqhbFx2Tia8dWZgUiobMVsWmWMu7lZ0nPpx716QNmkJQ5kfpkU9PTx/yFdTZRjQawifp mGVDmnyWTIbDTDGytwhT7fpcGtSIX0EfnTCasG2sDbmhXrN9ICcUJEENzFWUuXnJOqEKP4Hx6Def soTZ0LnlzCNyNViWEmKp/AnYfzpAbWUmwA9JGU2bgYTPJNzCWRQ9QFJEoq01i+wOxKw/EWHg9s6r dlwCeeUPlgs8vHqLLJeUuUG/NWVkk5vav7koFfHGdeGmoxM6f4F01DCfh6SOaZ5kKvdPeDhlTCLC zLEeqqWwBXnlFqqyr5AzeME2XYb0F5Ph+d2dUoMeDsF9GDnv8vt2KvuiEfCjJxWN/FWF95k1/+Im imNZwRYN/nc3FrVOAxoXvh5JLjAaaE0A3OfR3QleUeMxnGBaSTTg3dQ5O9T9QR5KstcC+7UkmdYx Qn5VcMxqaXTUzUQ3ooK5zOPAYnVOzXysThN+qQpMC4zq30yyS94CjB9WKQtMq2PhnaovY4Mk7lQ6 wi61yyYFzEUrNiS4weBPDbxOp9lATL6TLZERXP+pgu7Th/bc04DR2gYfOww/4uvaH/EM22p4tRg+ rlAL+Ig1Oku4KU228zScNEETrEhA5Ra4mQKlDb8TGHkJ93HSKTmB35+kXwEBlfqUDKaIaIEyA8MM yUl5Dm+3q7A6DbEbgzWoQkiOOZBijqrriojkW8eeL05yHNexcozf1Fz5RW8iMZSq4OhgRDYEcIa2 jTjg5nVi2W6cNADa0qZsFKDHY293Lo4XbgbGJmwc8eKDXr7SAYucOnd3PuTYHaS8dz04sh7iU0ri TU98julqP8GJggD0sEP7YmmAyZ3dPHGdJ6XYSRsCob3nbmUOpnDm9yiMgNt6Iq3KKzeqgZat0xdR NY5BAORtZYGFwoU8WaMxjHntkqvqkOeomolGF2g1Rn5Saj0qwIjuXTysD+vbj8GIWPwq1gC6Qh3W DmOrMyzknTD+HrV8C4K9ZJa8KA9Zg3kemFsNBjpnghDlOW0PVimQUxEtSlcZiHcAmc/iS4JMulbH V+RKS0QkFSG0RVjOMJ/MXShdnuwTyt8BVyr6nRqIb4n4hhzrGiXaH82v8zrIhvC2fApqmwCEgMOl d4FfOssh3lPkp2bK8QxBJvchKIUHGDLinN+2/MEJZmXvNFxSVoS2hsHTplsJ2JgkMeuZXjDx6VND n9jefph9A6kRPbcTxaW2ML/BcbDiMrS/NfnNKBetwgxyFtjMEf/tiyDgH+ZPtNjXDoSMz4BhPdCI VR1QKJLC+oMvCw35SscjoeYE28FEUFlMOJPKD42fCTa28hEe7j/Ui/nh4evupbJZYmLNLkVxaLQ5 vhpq41p3CyyG5DMdvNYyUG1RNPjOVmwKNsuXCixPKIw24q4h3ZIHGLIyu5IKu3pTMaA2WkLHbYhk grqFXtB+QDwQzza2RQ+R4uXMyFpGBV3BgjvEd32GwxZ6tPAN2+sC5ET4VvPKFBEFIbOCpCiAVqhN zoLbvIGmKDcm1vQAJGz3frDRJXAI2uN+C5hZdKCTno+4ZRRkmApiapjhQDWdQ31Bi0TXq+AscBOg 7SC+mM+ZC58udpV6qJ2gtFDsmxKHIsOOZqhnmHw2HFJMD3Kx+phAPxBF48T3FIDuIsgfrBTw2Qio tmgafv3iQNYa65k6h30ZM7G7RuTNd1IoUZ2ydjPUIBGSMt3FmdLZ0L1udeUxbnHiDDYkTCORZCdI WvcbYdRn40CbZrOc5FePTs1mh0lYWHwQ2tnHKpLHh0qbpRqjo1XUlf+wxVLqEdIvo+U5pm5IHd2u 2L+lywQYSqhYVIIkXBNwm/KkI0F+72+giPrLOg0VD9QjNN+oYYZs64K1FiyUPVZU+do6tOr/J8wl hC3LFKSiSRwgpvir6nKF5A4lJkRg/fiuQpgDITwqHnuJcMCVeankffTZ/S0pVcoB5h0AAvf6+gz0 Tm7pWZqy3ZQc7zmoQnb37zptGo4Bj7PuNvXjsAK2TzP6A8uMVeMaEAlLNNGbvvD365SZDt5wp8mk ndeE0jaHP+xG5w8al/Z+pqmTI6Z69Zqmt5AOxPWTCC+udUvI50U96h+JQxAKpuKGI8iHzH39eoEB 8B3gPC+fji8mmrdFgdSAYlTZ7RI29aonCxauHcqsQfJCnZD65ojoA0M4yRJWO/1w5zg8Fii2m01B q4w5+Ddi7jC+1SrHyXOo7m9Zj3YyysBctFhxvPtSh1RKkiTKKszbYobrQaIk2WwGQXZ70kikbB9T lzdcfmJWCvJuDh+fj1W/eBpWgLsAF89s0y8DltUfBz6vGQfWK+7fuChBEuHmOmqSNPBLE7jgrxhz D98Q4T4n0fDjgnxZwPw2y7DhVH/86UIZ8gKsxVxGZObv3mlXZvQooMJvsJuLLW4Au7XoLIoSANst g5yznI1BwF6pCoOgAlbUh7kx2jZpnOPaxQpNBL94dWIDQqFqY3AvjOu9nAvVdtZZdqJ36G6GVhcN o67ZXCoAT6tnJDXxlCaSF0giFQtVthsJyyS/wHR0C8OFiUUudAKtyqukNaF8D4lrzq7OPv4BvwE6 5PsQE7552DJ5tBDnT5w2tkG+cpraRB8xXKBAVmR2ReyAf8spL2SMzF0aBVBqOZ99qYuV09HZ676S 3Gfx5J19nL6v+erycqQp8KMUrwN4jEzIHRNtB4CuSqWlaEGzHlobUbeX9T3ngJZr49mX+c3Cyq2I qUa6zXCtrbMzhIk+KT0IGJV77eo0/5ALSsJtXqKfpziJ5DHdXD3dtmLlUWiaDDorjXl4USeWcd4q lgCnV6AXjaivE5TbM5USmzCchu2OA0f5GuCybqSZE/hh7+6MaDcMD/EJzFC4kj4UMJQYs5AFPFP4 BRTwe7uZ2QjrmWw6HLFEM3NAq1+4buKtdjm8Dp9AtZAYoyDCFZ4L9/F1C0lK18yRd+5bJKVYF7Mu WnoRE5KIaImeqGz0Cj6wHdUy3cF6S/4giuFNkyMW/aFl3wQ3tMyGGo1G7we5eyzDO4JKnG45uT3L 37UdDVZ1UMhR+6QVgDNDIJ8J8Cm6u4uU+DDOB1orGZvAe9bibAJ0PiZMJy+4YlVc/ApXAD3y0gpz gLT5+3rLzyn82uvoO7loTpmB+Ssnnu7oOTjaPE89BbtMpkp6S4sKXk01zCymbN/HLJ9ozari+JJQ ZW0I6XnA1lVj91FgavU4388VLEm6epVdjfmd/kTNtnok+iU6zZ0s56mc4wBKQ/YvUH6bwDIrYw1o U2YSTSO6mYuIBBNkOV9wWtWJj7/3UmEeOo+o78+hwluafFe45hS2PZZpmeptGkGbvNuZQHdyfqZy S3x9a15/ZSJKVKNJqO+WDajq+xdkYFyKSeH0Kgex7Z5gQYy68dTg5Sz1atAsyBPepvTa6QiFXtVP pBWZOG8lpMaRR1rZ83h0AsyXErHCbGFYYcXuU6YiUjo+iuYw7G9whQFjLoC91TmbffDFWNhGLKj5 HLJM5M3P7IuqcXPkAvQHYQw0B8zAoAkKYCXrk2ofcaYKKSDd+g0RC7y6V/u1qab1QrWvmOo8rnXe x0nJC7mElD33fFQlJ5QilCVOr6TJUKgcY2ZDQGMjclahaWvxGW8/iuIRwBsVZ4VZD9OrPdvsgksA Ug2DUgcjV2Gfub3BEqJqPqWgpN+C+WyGX0LOt63rxohiGE8h5h4NGu0JO8jJWWLuqpnt08cMzcoa laLpB1ONJzGkh4ssccqAZqXSF+MFKNa7GpvsniAxi7YgF7mWP3Wa+f3zZEjyPUDM6r9dfT35YIpP fLMlL8G5sQhwjmhMcZZJIW6Wix0Cqv3OUw1Ff1ydmd/vJaqCiUD1RaGX7H7Lkoy+A6raUK6WXDhM aKQPPDxZkVvU5LYkclx5KbRT/3woNEaWr0i7Dl0eqG+e2dIbfAvLhO2rrCk9opxzXu7fWY6K0MFS 9RoyLysmtBJ4a/lcIT0zDRFtH53w3gJDkWA1gYET6oxy8C5Q/gmhXkcNYWoUMIhHcuyxnjr/sIMR lr+bi6ZEl5WWwCeA3F2hSDKUwJk2V8dok1k+JUCTfQAaeO6pwxQ19qLG+lGds1xg+ULN8hf3HJb2 NDP+oefDv9coYVUdyz9NAbVAC2PG9m5rbY9uBgxBjnq/raPYXjveLfxjyVMvRAbL6+gr2aLhK+Y+ u+GHSOrg8n+rOSHnGfv2Ffq3S4pXi76OkM2yNb+kGC1w6BiKzmyIeVqp3l2SvV78T/zUjfGucKvl M0QE633Kabw/2aTEgeSiUrbEC3TdUhvrQS0vEPP83Yxfg9DYX2d9RObRr/Px5YX1HeOqHDlCcLzx 8zNhZ2RYFY/E4PY1jPzVd3xx/hQTPXqq3MGBS1+IccNLtQe/7lcVGVGdxJ/TxliMJicoh7J9nE+z gwwitz43yxZhVN6Wj6DTSupsrypZn4Mcgy9vJV7q2dlyNgigKs9PnkzUPB4bi7yOjTL+omSoQb7T vCenbVC3DojOOnSh0tLh4BbvRzc8EekKYls2dL4rgF8q2hWFP1Numc7dAMgouLqgx8mCRLsUkCR9 jYtyfF8JIHvF276coLPxJOljw0egOfFb9uCS6dlbnLRY6n/kFVQEXCYbQ7BtrE1Gj3S9ORgGRvjF rkuyVy352cHEhhtu4AOCULti2uPDlIklSeCxEwlTtRsCVCiE6o/F63VjEl4/8vAslFGVlRRVAKuK myOCQwloYEkUptbsunrQX0tswz/cWhYC/jYJhf8QbbOjo1vO3ROHkCM9OqQgNCWITlrBBjQd04qg N0720TPUWk633pa8oQLxQ2f3ZTqasdcj6O5IbA29mc50jqmjvn/DZDxzJdKioo5keTdmtT5tWN3w +JPmFQ8hvDihLa1Uqi9WmmalZPSinmTYXQ9tl2Y8jNbWKTgvwLNb7Tgxc/AWbosvUB/iSi081xWq 9J1avCtJLSrx80brBydSUf5EGDSEY0bp8ghJx3rzDxK41tjTzmrfVmMMySGEP9wXdMDDZJWe4q9u CrvJTSh+uzLAm+uht08t0YTpC7pjDVOMaTx9e06fiVoJAqrNub2huE7CTSRhM0pnBM2Y8zjoSt/C HvJTWD069TnzQhgHLwZo5S0AMQAsuIEM4+x8b19il/CURaO4x4/Ikyd/Nl6sKfsWtyXVbtS6WMvW TXTPuQMkoeQH1aQaeNOumAFM8Fpv6jRMEFqSdZD52vuLdQ/KhIAydenjXB9TqFjckUN7eaxBCKSA EHp/v/2ASu4otMVficzwP+8FpOsV/Fn9EA5KJjSNeJkdddh2brQoSoCTGa0cWAJbPARCdhifzpWZ 5ZXwOlqNP2jkoSoc8ubf60IXsCHg09hm4DUuuj4VXVhb6tbvs36YgAKikLFRlWec5uDTePTrHd68 ruCCxL3cWilm5V+GuAMHxfe+rjgBvrXdBV3Bihs/ZmKn3nUH6+LFNwzoNFOkq0oBL/POFlKIjYY9 L7LTmkRxbgI8pCMu6Fl8xQ/1yWlx7LFk25RYXnWZAU2tC87XO58J/Mn2yHT3Z0j5nnI5/1Hex3eJ ynD8XQZuR9LGtchD1f3GFGmSBbHcAauS4FFRsIgT/gEGR+WjyejPbp/MU1k58Ht+NPr6rbQ8szjV JjOyxRvmtYw88NUmX/DlOwdHnfP+66pXZjRiuYnP6MiX411Ec6tmVg4PHhpn0Z/3ERUy0cuRnRqt TjjMseAmc3jcQErwPUGgC8sbxX1zDvH4bh52C+blKFZdxcLqN/RrXy6wu4pI5I4Ioc/uempaqUpQ MVA+g1FqP6GUQY4mO0VprsbFZCZu0PK+VX12H8nRpBl3XaVftasw/AfZk3LM0I5oSu7Lymn0mMWH pasxAGk3zMUJibRp8Ksh3+M4EqikYmu5l/qnOh9CHR+KBPkbd6uJtQ7iC9eHJnk1mLhO8zEBEa8c 7aZQgWttVqJHwovDiiUK/a1FYHONG3NErUUD+i+hImirmJGrpeRw2/aTXjYKjBYR8jPgyOAiPk3e sVARIB2r8MnJBrrMI2CzypmitXLldsInTwAWycdkNpH9EuGN/gjfnyesPri9+/ihRazvTu4eBBD6 UF7eAIrY1Vcg63BV0K5+ZHYZkKtqcw3/Ji5z643VUwQBHwacLDNDKcH4UBlkwKvVaP7huA1OBVzr KHeMRwHJXzkVdi+P65deOVtAhvY0L/USp6h9PJ+sqEQ0am38OIAUwFh8Cq5pnJQKXr0kKjVQaqxD vAZe4nmwrz/ceY63MnQfS455cR4Lt5DzlOxCDt0r+tm+Fxn3F/mXu3kXaCvCdbv2UOPOAr01BugF UqXPE0wfKsgkr6k9VbmSRrOsw0EME0YYD4i7vvs9jpW13pTKZcgfL7FGon/6s6OWXOjlqtmsNkOG jMXKWLNIMQpUXhk+oWKsMrzzsCSG5laPUaDcDnup6WK+8Ayw8O5z+JWVanwrEf9RZCCRAKvFvy4B uyZpKAF1pwucbcXQHabCO9W0vn0fZdF1HSBg5Eq+WX4zFQIiVtrFq8WN8B2wjk48kN2ZGSn/vFwF LCcCCSKTnXMOgDX7iKiFWOND4vuEM3pARuA0kkk43foeQyRam2gTf5L6570fmDKtU2GwwIBSJibp AYyHDFOaLiMwzdKWLY6NI/nPQpMlGC3RTgfXMc0JlZgWj2VC1qxltoP/tuugJ5HYe9v6U8H5Yhaf ed8Og93NtJWQeJjcjYJPyrOKnccW1BGS+lZAxSKeq8oAB5S2DxabFULODCskiA6zvoqx8D02Gegh SHfB3VLeBPRBLx04/V3Wtle4qRcxcHKZfCUy+fwbccuBsFkrVimpyMhXHkVF5fmQxrUYw9dwezbs Elh6hABfo+pq0H216G3zlFYO4svRR96FdQ7Jkw4rbDAIKRx02W6BPgug6kxh+dgsI52JKrDh2P5C oOOwcc4SEwHKp12dK3mrul0BCQPO1bRs7EG4GZRG5+8xoqMx+8OTNHFOIT2RoqOdhRwtyQKr6DjD yuZwaOMJC3wBgk8uHyMpFV97RM1KSq2w+znoONDpRCEsmcltOjyu+l8WXYmg1dT+dPXk/jDgAMWW v+SZoNrUa9zmo5VcHffx83FKK6xEBvBAx2EpjUpQ6ezF3tblhxXvWg247MVFImGydtn9BD8KAoNy YBmwdHYUigNQ71naWFiltVOy8MPtO5sRlE2VXSYUYg1rZQC4EqONopDmAhkqjfW+t3KmH7T2AkBv rmwiEsOni4Z20OwH3Kr3a4z4RJz00hD+89vSwllT6g09TcPQu1ituQRiDhrZV1oQgRAIl8g+HqDT eM0DiG/lY9eRg8rXIxMiz7xH/KsA0+0KXh2+XwCTZXGahS114cZIQ8sJYSucZX6mwYA6X6DHhEG/ oMyMFsjZO/YnuPy3VaUOnbGyq+iblvlq3UL0aVVJz8HXWkDjDmaYtHbAdWV/26wLZOKAv+y2dS85 Eb2g33B3eYzrSY5g9zusssyfF01dLVd6lTnnZIa+Sk9CkAWAdMXJd4U4aobwH4+24KXuWf2rUdto poBmlpiOuLfAjLVS8GxbgchCbHDAuoSF+dvbMW4OlYCEkB9eNO+PRygoy/krOv3U92nUTIIRwxVm HIVn2TkM9/x2ssWyTFtBKnnFwVWtfjGhddfgXiAnves69kAb1MDipEu/Xisc0rYG3sapUgRm4ubj vHOVCh3OIbFXT08sZeqZvr1IvCoHNQ6G8Rxqvc/tWBWNwR9vH8WhpH3aFL9fNABP05iqsjLRilNa XbQYbmA2/86EgSsB2e8TbYaI4qJyFAaIJYxHbGi9DHSPyio2EKRfpfhYjoYqkvXXvGjnRkmpSXPp IGa8QPrsY8HwJYGnntgvlt90QkUu2nL+0pY/cmKP161lr/K1qvsbnuPjRikcAehBiDYnzmH+jMrS DoKXhPan/C1JAtPcSk8aSYukgGIeyYF4zgTwdBDHkdec5GKh6pXvK80piAUrP7SpfabmynJxNTzD rQF79CUya7Wh/vr7KsLv+3k53uEc9IA7LbAsARTQLbHaDcXoyMF37EF42QGEdcBpqtYHd07rO52C FYJxPHzeSe3JM8/5QSIu4qDGtLaBD6v3sbKNftDa/A+2PSYolNTIYcBRO8ibQmXfZJiTL9zT6b+j WgPu6RybBcjxYWXzMYu65DtSGft55TrP1ZvkHX6/mpxHTNuZWEi4WcXaqOjz3F4fiqCg9jyVGHeb hE7IhxwxMM/WY1vBs5m6BE3Pp6n28VJ2a4+s/W3kuNFJijX8UcWhbYI7aAige/H2gv4nB0zUzosk HUXVqG4EapvRNYQeW72eW5UPdoWamdriF2jJfnwHJxijldIlUZOmYQnShiCn2+RYTwFpCGht7vlv K6T0wAXJRKLygLPxHH0fIzqq7pcifCgpZdtCuk0rAjMHiXSOawiMrbfHR9LZs2BMGS83z9Yagghq oYz3nYmnCE9TB379UJjvT7y2wAzWyDdLGb0JZlV+rEZoP1zWMx91xmijgIXGjV75cpWqYu+pstRV JAg2F5AiBMYCAbHsuYWzSO9A6rJiz0WWm+022dvpoLtEZNEGFUgiI2h7+5G+NJcSxsQ67lhZIVfS guQ/lxwcxcjhw+uE8LZ40IfyVwmVFGi/bBRBYDpVJblL2dk1edT2kYWcTXpvk4aFbEpxEVultUCy Xvf1YsntF3c8gML820acTdArOiRvguPhbFp82Kbby76Ds04AMbyesvQHespbqLoIBpzqTxBxAfMt n16DxsVUG4dxmzh8FV71B0CaBg1XXXUjRnE2TKJhnpif6icHEDj7wb3gSGsEXXdGQhG28ACSRcRd ikoKfgDAvmuxByKWow9EN7Yw5LdyjTfmojDmVeZsvLjhC/1NQwk2oLhnyigL1KFZzqXZRCIj2Vwh sVl08KjjJ0UBcPHr8J7CfBubwLRdK2wM5ERDNr2aVUEu/591C0QvsymL9f4oD/oeBfaDQSRkmjOE 2Sc6wthGWeZYcZD5Cr5F5hurCo4tsoJu5dSnyA8kbd6Fev7vhQ70XSCp5S5TYinPHpikEW0D3xhM 5C2WR3+iTt7Ov2NafHL26ip9k0diwm9odEhbbUC6AgHYQ0f8PmDwOzqtByxdQ12bEC2HKJKbICDo Ng8R/usctmcebuXHYwp6i57XEqFiRodDP57Z2+kJjJDyv1ZoGHLD8NleGBTe7xGyKfpIWAAPe7gG bgbym/H3BsmohH326ZbNJmha+XSN/CtW0IxRA9mYoY9jE39VEHUzDUUWq2YADpLnYhKxJQhGPgvr uqkJyA/0paIlUG6TLZ23KGC5QM4ZkHNAZAa9ab0QEy50Z4D6oqQ/1iu5l9oCIrDOxF0nSFiLx9P8 46N3WUWfWh4UNB6Ec22kmUEK0caBp2I/le+zWkl9FQEHbvnxIZjEDerEcJupr5RaSCL0Dm/HnDnZ s76sGW2keoK1U8GIAgSK00ZiFX5HS1sR1gepnNGTlHoyEd+Gmcyn2Ta/eZ7S5H2LcFl7fbnNL08j C2x/haF+UZ6uz8HpB7CzUy//+e/qPUsfku1DIYCinOFqFLJBPqziEP7eiypyJ86tH8JdzCtzdTkg OfTakcf0aCAAL3kQYq4KAwpZhD2y/a0/s3O9W2YKv2wfdajyqBvJTY8NZ3Q9E9UPLOarFHbgSunD /mS8qkf8tX9IgGNyvkrT4ADTe9sKPzE8BIlPx4Psz5pHUyJhwbCMHcJ9lAZ1ZTDKkQBMTDuTJQPu gt7hM/gWX2+ftflZfYD78XfVr/C3VkTJ58sPQiPX7FzzvE6Vbu2IitWRHtqwsqvGEMNeRzhi8WLe 0i5xXy1fk6xyEt91lLqLCZvqOQ8+QJ7DyD658lCjwepqKZ0wpPIxwb0RnExrIoR+dmuLF6vnfBQW w2oNSusIR1tgYWaDGp2tJjXxUVB0gcUFg8kGqcm/tBpOa1F1jFOE8arM2qzYuGx88l7cbcS71LEt fttIMQp/yrC+kJP7B/VNBYRLHfF9csM49aOYV8iwbKQCkknZavA+H8y8BB0Q6b9OwxKyApN5ytBX 1RxIw4UE2S80dOFaikprsDImByT97GXkOpjsuJ7e1W8ikvF4nT4/95f2Y9x6zOYefS2245oJ2DxQ UP6oEcAd95Li0NIoc5qK0RBpBLrv6yAOipt7V8wrjEPzrvksocJAFEtTPxWAEPlYEIn3OgZj+g2T qVJ2SsAqyBRzm4K4jbZJoSpgnEXy4ldRAvasvak5GyplA6RL29ajmJTk3ldN38nqmC7RbaFFo4KB 54+4ThOxUiSvAlBqY9Ep6m2K3MHbWkn5Xcks5Q2opn3iotwNOatsgrNTaZAUo15VL/VvtDgWug1S uhv70Dltb7fKAxi58pqfoZ6NwrSRf15iHESQbGT5bbR3mHW6MBfqVPv1yCIFfIAX/Pm1YvVYyvQU ZkGaeTGVK0nP5ODZkrNRImDZtRXb7sqoMtjpncPw3tT8690s5sYtK0lLli2alt8D8E9EoNULFqrj jSALQ432YxRgnRmtAt7T0rLf38O3YcJiQaVAKAewvEIPSsrZCtRXzq+Nwj/bFwFD5JmhPH7d5gf1 9lcPIuaNRLkH4COhGefE0AvXgp9NoGwfMeBUSiC3QDJReZwqVZGvgVJR+1EnxlB/3zmb1wVhVj+D FawgHUxak9kZ0vhGNaGgR/oT58wruhvN9Vk6DG0so+4ZNLORXP5GWsfzOh1cY7D7cSCU7HBksLhB A8aeeFJa7aVRuCsqiJGWABGst+f1fuNxs8V0cpDMiLkyyXhb2qvTNTOCSmldSLBeHL0yddUDHfnY HJwIiNlgFCVyuWb9hJ8kqWjU/Kiu7FKMsavPocYES+tMvmA+uebM4tpMLmfZKQKKUf/kvd1We4bU TVJiD3ujkDlbl7rqOY/qV0xlIP2B2xQEl02PfiUMb0bYyfIgodHGaAM/uGniB8owrGhTIkpvnrGH QXf67LnMP5zG8CGBzbsaQUzjgjt/uHiLcJKeP4mcQturLYor3GnIgjIa8KZNmrgc6rHhOkVcG+28 KnudzhBH2NKXhKOixYs9yijsc0gq57vTaUD0ssARNxgCRhWN6o7M/XCRhMlI8i/F57XC/hhNUeII VEJ0MDI3vRRv6Qe0vQ8ODf9gSa44tK35XTlh9rGwXRvN+9n9H8TNIz9BgpWHnJE91aGeuLHzPv1Q Zyp9YqvWhTgKY2NrPuTpUGnmDhOCsw68iGuNGavggyMzBnIF3Tn4ODokEDIdj7Pt2PlGApvUm5SV jLXgM5mNSQ7KUhuIRJPx/mok0rBctzpz979S7EajUDaUrdrsP94mwgIhdSJcxQwr/9RBxLgzAJ+F s02cCWNvz7D/oyFkti+JrGWdazK2K7pifXDfMPw+TrV0Uhbsqv2Nq4p+zE4DQZOiqaRbgtnCH4Cv Y5CYMeANK6H7xnUiyANmIf1CkUUIAzkON37iYEn48E36u2E33O6VY7GUd5+I2uPZIdE1POjFJq5P N+ByxNm1Sfc8uQFqC5ymBtrPBazj81IqLfgZWGGutnt8bFutJWHqQmh81axR4eIoF4CUWtoK0vvq 8/sYaBNrmpYxsPSArXUpx31h1Zho0l0SWy8rWyvCU+1NG0VyeKPQbb979mOKYuKz2rdLIqGYm1yJ Lm+KkB8Xg8N6EhyuOFKs7k2Mo0skRTUlY4zQb5EQ9aIvP2v+muUEHs1ccUWPDhSmhZBmMhK3/Xeh sWEV4wKfXNMCK8jiwmvqsLnEsn8cRZar6NIwheSL2Av9fVKkxt2LvMr1qroyhnAoZc8uHzZpqKqo 2f4OK+Q35RPwnGEhOztdlltLT1rniGuP2tWvjwzZU83hGBIzGN9n4RE5C0/+ov4VTPeb9hriwC1+ 94HTmt4SyTIac0GCzmhZvq/gHdMEMQmH5re424iaosbHqhnjvB28lLFbKaH3Xyqd9JRcFUvvYbj5 TSWXBczoPrmn0fv0X1T+22WhYz53FKYARblf6TzY5TzVdVaYjjTG7hJ0lf8eeh5rb/aFn2Z6fIoF lh0FwgOU3c4Fw0g3e9BLSZdWu9TsR7HMCeNYv8cV+I1TWiVEz5t2KtbHpnZlCcASiia9OzQw7+ht Trx0IVRr+TqBkwC1PFEuTJAvV18JOTJccD/1gYHaa+QescllDapY3RGqPALy5neTZ3tvfsSNtU/Y Y0kGkKH+2A626/riViE9Ren4eX6Kti0xKVIyzDEao7LtMlvd5zG96K5fvg2VFfPj48NoP0LJQatb yWmMFMo5DCdrYDhVkbCGJ/Tx+/5fAA6A8X+PPL+eeEbrzKJSL6p2IvmtuQ8PVoNZh27Ny1nn0qur AxRSQ5jT0mHQ5JvVWFsP/4X1jMRfNRUSHyuv6TnlZMDihRJcqiqyeh2Vcd9swlw2dduFOK4bPpEV oU+L6L7cDF6uvcBFI4E+Pf4ElY1QLAiuneAEr4GgoHRnPvA51wdgp7hlM7Bd6NZLeaYlEmo3EBmi /YYqQFz9OonG3Hp7T6JIuwt4Zy6PIzzyIEEerB2dFnqwtvkmuFjz4qEr8AMbn2OT4H/Jv/A+CwrN FHb/Gc/iMJT+cY3B+xIjx0h/FOYy/tGgrU3B8JTZcDAxy15w7RwFrvVijzt/0zdNatTXHz3nrpU4 byhLeczjCc5F+qGss8Is0416sCOftSEo51Dny5sZaplm0kddXJc+/uwUBUZj8yYpJZTeqsMJAhL3 ELJX8OWw2VrSUjgYkWTLKdPq2C3X942+IgaMtHnOvylvNyk+mY0eqFGo3sGctVkiBVa1Tf/STeDK KoK1on64plmkh6oa/jbEXGYog1f04X2Cr6FOwcZlGEkKall/eI5nxPPtP+kR1n1JNu4OWbomAF6v tgV2kjmbaIp9doEftII3zYjGgVHdYqdrEhuKNFtaqZqyNxQPM/qu9+AY9rO25Yn/VFAjpzslcyIF 0etRZ6El9BbaEUSRVS2DhP6ruwO01KenTNNNKm2AFx2+plgqzAf7DvKrFYOFqc0rVG3gQGGS43QX uRPhey12k1MLkgD6ZquiJY5aaR28C8mM1gnPhPRLJ7Ytks4paeNvjlI6pEu7WGRm73NzTvMm/Zzq 5+1gLeN3CAsHsCExbCv0992rj5afSH5dWhZm7pArEb9U468Y+jNnSTOmFpoKGDK/mAISz5GoksUj XYDTznYBsrJ5a1xPp9FgNqc+v0g+eUxAm+aKr74hsgMS+pX51Z5KH3kblmj5R3W1fPNs9MYm3iHA 6tjBQ4Do9B42BpLErmBApPrbWhFTiL6CKpy6ay2d+l/cuKoDYbO6eyGVYF166mmToV29WqaF2bFE 5YeDqIE/lTyBIhfODwdka3WfcZ6jj4Dex042YbZBlnguxDDcHz+TAyaVUqp6zgNx9mx6TOYKYQlp K1ewwf29Dv7xbVN3mQKHHDHJl3LxeSfEfZb2t/2fD9Hr35y1Ck/rYrPKLzjv23O6Cz96tYToRcdu quGI1HAxCcdMALXlXOYBFp+86ZDe8KmFxU7ZslzJQu9MVU4aERv92m9XhY2hzrBN1Umw0RNXdEOK GUBDwmsM7sTgiaC38uVMcicyKuZi3dHscL0kZaocOcapZcvUC5LQEuGbRFcoUKLDWkjuR43MnUNs N0EIFbHMj5Ci2aWU7fTpKZV81hhZCOD3dtfzGfmZJ8XByfO55E4gZBaqe1bRniUjlIBHCFboLS7E L+v7cMOGS3sxPcLHS6xNCoPmWtX5JheLg7VVOWv33yAxSklYR1eSCFR9IRon0PSD+IW7Q62iu1cy OryV5dwrGZHZUTz45u9NyV9/dkFFu4H7Ni5QCqo0oH1FcW9VTBRe8XgXwxindrJoXemhrSfsY/9c 3Vp6IRuHOeb0/K0I0bfvQFN0oUCgJbaCGEJYz4s2masBTymUULmZ/cNqx8xmzZbNaZklzUMfSUu9 rBO/R9t6V41KWAwsqJWN4O225cdKnxpi9dcc2XZszpC0yJVAGe1130PZxWR0VkmPPulzNVasFV+k tkVi8EhAyKiRQx/IMYwEIHpZDobuOSFznDWJv0YgQybMNFxzS1/vV+6FahOtkceHrZgWz4ERs7YQ 46QygXLIekEvYGpC281ArdFYIkMbhu0BWi/sc4FM9y5eYdlkfE2sASnhw0AldkjDv29ZItK+ITvj adbufYPETKmAYQEVl/6OL3x1x4e2dlslzW5HT1zyj2AhxbXERsBxt0y7gplsSJu6/K3l7vKjUUvj S/aSajc2uZIYildAkWLVWZv11/b8NNrGxOpW4gOjLYDVs1RIe1ydTSuqa7Hb1ifo7ihGaY+tqHOd 6MoiAkLwwcJAPqsaJLFOBR7OmFR/GTOxWEdeOFEkJpXIQqnyGrjb6XrDZV39VdaHYUqO/buhwC0a rNCr6G4WmQ8TEnEyq69Dcg1u7dv6EMLIm+69mZLTG/uChelzxrTQdTQT5xh9Fv7VJzbzM5TOZ923 yZdXkgN/yl6hWH2fetn1lOad7f5MGlJ323AZ0fjax2JU3B16M5Fw0VU0u1/hD9aWSQqtpty4+2nx +mIbtfRJQDQaoULuzhJkV91z0tKQonDwmol+2RmT02u0SQlQSEl4Ii9I9riU+8WUKSoErNS1/iyQ Z+jcpmRdKj3VLNz2a7XMJI/7SuWCXlXepK6ehHwhm0g87F39QAiMi9r10M8ZSUOqoy74YdvGSb46 ccGnk9tB0RlFMP7II5Ai4B74ZxI/0SOZVGF9kjUg3091Tae9UWhdMy1iQffFUJsd/1K0+B0Vx9Pf pg1BNmI+mL2ATMSwcGAf7Rd/2i2WXM4kttu5yQGII1HfQzXD4lOfK4bSwWccHzcmytRKBX2/GOcL ENxeMrAODxt1k5NQ7QixlIk8hc1lKuOCqLeuwTHsON0t5BoFRL6IQjfDzkK3XbA6739ts8Z3xzgZ n4s/arSttDBPLR66ISlZ4hp7Sne9VdcxyZADW3vwy1oCJQr9Mj+cwEyLJsaABOVLyVdO4yhtcBRM 3jmuSThwy9QYAA+1LMQomKri6tbSulR8T1V9gFOIKkfvdfMaCD8G7fLM7RFQDUOSMG6rcjJq4J4g GEmOaSnrNFqGJRphOLOx/WcBiO0rSaFglZdSfUfxUICCrED3EttNMbqNQr06h28RXamc4K2v18zD K4YLqgYnmmZSgFaIHboa1PlMLFo+gGXCGHX+8vOoBzlqofOOjUtMT5XfXfShctkQnr+u5wA7trd8 6EV7mWPx7ixtT96sLU64rsw2LOyGERFp2p7PS2/aXdmvo9Xlf7Wfg1JkjTv7OeRH0PZqgQYEdDT6 aLdGS69sWN9u1FuXRnVdWDRhek2sy95rFid2p3tNMsGsSMVvdIELkAhZkMh8y+lC1TCS/diu6vXC oY+flcNMd3z6vCLtWpgggbsXhWITawfoNuPfKfjUOs6jy+QHWPWCcwCY9F7LMowbsVTZPz70bgt0 76jYzan1UuvCzmmVCRxxknVu6ll4/j6RAkgazoW7lJHFXU0o+JD8UnpWs928VO7+W/csCxVuQicG StIafeSOTcruCv/gPRQxEhyPMFt9OOgqUxlVcBDBKwOdMOcz0NbgMXpZAXXE8acsXZODCAQ8J4ew Nkf/cCzQst+NVLS8y7UdfYipdYaRDPGPmLQpj0iuvXuYgK5RDc91wHJihUcWUcsfDNE5fbmjKONl YfmI2vTicUkvDUfx9EOXy40r44J13uL6OmrLAkpG0Y6WCwRbvg/vZclt47Zekh4pv9lnmdjsJz6i L+mHCkAN0fPGFjx2j9/nhsfDo5zpHIQDnbWl+mFnvTWZtNdLxAInHhpCxiLjqNoGRETYGfnZcn/s PuYFaDTiTy2hVScReqBAzwR8sWePEU3N5XI5mViR998D6DhET4+9yzJRVoBPGFkCb1i7wX3ynQ3U 4jePD1hFkPBtWRkzchng+ZcXhSu9HeiWuiY87r/5cKG7iC+nnD0Ct8mxoxQqDXvcnR1Gy10WdVGy 6CFelZboPsXTVFo8QgiCtyPOpziPtKu4GdstEmW+GAHGSrrwD/JUgx/0kf4g1KVBDUT58jHhrSSR ZKfW6dtXeVfNOWXde2PhG91NZ6HVNw1/ZsEfdvp3JRNQLYvxsePmNP5Q9b1Kz+rmOFcjMW4gghua wMwPoXVAeR+Fkt5VqDdINa0FoqKyq5Oo2pclP4wJ6/592MpP1zZotcgYXioLqO9elKSwp4MujGu8 /wZ0VEagjTuSBOVQGfZwHnoswVK0vAJZAIYkkdXyakVnMxo82RmoXwY/0W77TlCJPvVdiHTIg3cO ZhQRACz5wx5tbU7KwyROHu0WBy+xPOl1Py/oR2gMqqDyCmxB8RNY4it20Fj9wIHlUOPxaOWe7PdR YU+r9fdcOWLdwMlcVPauylqVZA5p0R0TaIUJpnSkCY9W+6GR20rxJqn+r5880jKUM7LdSv7Ip/gM B1PpD2FuVCnwKxqkMSQLUxb6BANU8TZ13yx4QEIuMAZyYMNWhe+NqSiNRF9vnr1uaTD/NqR7YhnI hC8y0UvtDuwG0B32hEiNkLCGit5hCbCMtvJ7QBjGoyY+wG0mMwTzaWfZ6W+puRZA+CnQZS4yzeF3 DGLF+GXL+65fPfzya/3+FHkZdlGWztQYQNyLj+1iQB/5M6DSq+Lu30w+q6BJ9P0BBH2jlArmOkFp pf3cFOp8eaOpKy29iewJz28DQwqgyER4q2zx+/HnufoS7NrpEBeXyqjTN8ccISuTdmjOduscZz+S rwvR5ggDQOTMbGKtOaZfQJIngVBGBhYKi5QZ4PQhXcX2N1rN9+CdmNA8QQgBTkz7K15mmigXLWKB UvEiYBFW31mLm12S/JHoLAYfhFhtyQJlGtq9JCJPEEecnn8eMw0g3UT3T9avW3sXpS+UH+pmgCzq V+yTr6mFVLNUWpawr5rv4v0WS/VO8iED8lPRFS0ESNCsxvPsnFa3TtkhyLWHQWsxhpzlhyImHrxS /eF+YCQG4zQVMh/JIQmmTsOogUV4y7W9zlUkwlCKsf2Wcbq2qV4wBqxSdSvdpE8diUxUe296exbt o0jukPimez5kJXRhfQCNFK0iyWhvDy64Tu56iQOvNli2cp0Hz2WjNJZ9lE9pRV6SIlF+nueB5sk0 xwSGe3rlvznyiSsX8bnBeizUrkyCpMqCLxsV8SLWq0hRao93jfPdZh6Q3JCut4WPs2IutjZVaL+u eVhO5JYnBXNFDfk13t9lQsewfmbvi8s5vHp7HTg/894IHdSwfDDtSWB3E79nswD7xhA4+ltyEDwG RtJApoZet5BjNVm0tkp29P+6Dnc9WPnZ2NdLJP8w/t1nFNsEEorgwK3zcENjjzQ66h9l9BhhUsXM ptQ6NBDWRfpC0QjofZVVwDi9qwPGc8TO+A72LVrfpnx5qUYGvIAls9oYfouIDVuNho7OfhwCSBGL WF8rESmucR6xhGaPd7CNhaTC1mAJOiPLCq0px0BhojKkbdIytW5hq8ueUFBctkMySC502/tN8SL6 KSPZGVYq6JfNtIBhsVVcsQTea99Dm9bP5kEw3BV2jl0o3D/7q1/m0IEb5Cictw1pFNLUT+lXrJxU LmR0a+9+ZOc8T08e70aqFBOSZTYsJjDvpBC9BWp+wlRHR+Znh+8elTbBE9DiasZH8bhSLoQTnu+S ridXP+dABxCLErjI2bvJCcYmxzmgiZS5AJbHETdnXnYLh5JNOT18uvWFilT9gD0/BO4sm+Se+SUX FUGUa/jKHW16/x4OooUu7HKpTS85Mbswo8ve5EUcjgXCsf2BgbvCMQUWU1BVwVNZmdjbBvOY2Fla deY2rIL5Yio0EO+939Ui7NO/re8UDlLLkJauUd1NwuBH/MhoMN45uUZ1Ojba0hlXT+c+VYpvGa/b QafORaZmAYFv30DCIzIg87M/jw5a9HI97VJnIeuqmtgQ+Adhr5uTJ4j7gyBd3kL2cGbaGkaftUHR 1jMjApMiwMBg6c/+45dYyV79xBf7MuuiJqt7UZVx0GYpB73bVEzE67tV0tkIjVgvsjFQIrPf3ekM j6ACNBqEOgh3PlZRNYF3jesN7SW27KgNg2Sm5K+4mKSny1whF7qk33B2jquEoFK+CihFjOTB7++9 gTs4aExdVngamWOtzVlPGqsLuSy6yEiOpLkyMDEtefoOubnnMTfelLgQQ+E0TV6JAj95l8pOhzR1 7owPC+wKwBVGR0hYGKCYEHEvvSb2uqnQaVf3LX1cFsjfNuWxK1i0ujvRMEHffJ3V3Id/353c4kF3 A+SnGcEftXAgfc5pc84l7JcrORlxpKP1VM7aBHV1BRtUSqmQdukcR2Xv7CDuxfSIwI1YlPcHBMpl fIHETSPIOQAgZSOUcNMl7rVhXj6J3qK7ZS4LSqA+wowzRxtqMXE3O9ucTBVYujB4nte5AIybnShO KwCXSOB2I37MeCICbDqHzliGaUgORdF//GOG4zgfsegWnTDzk7arP4fSEPeEcqTIrnwDIbvSr6fE erFbUmcHLgaHlJq2ASy0GlCqS2fgj4hTMBKtTbn8/We++HLnBp+Xb5jTNNMM97mzgBqRZgJPQQsu EQ4dZEgBGQynptfo9XOeGq/viYXDCPs77ipq8AbgXEL9Jp8XOZQ9FejThsNRGJybKqjWCtrB4MGl WHL1OtFkJPI4cXUHwBatGyN8Y1brfW6Ayncbe4U4AcagTBByIPEpjEj8fLJe/98vVDWmewC55uxd 739taVNKRTapBuwiIpEeIhlqlnCnQt6aDdqo6mZhm+3AfIpUIl8Eg7V4jFcREaEuHJb8zcKz6fEI wVuVfdSPGb9LgPwIJ7/Nf5Uq93Pp6iRahgOMmHIcozRebe0Jv76O2sJ/C5uvR66+mygls+ihMnSB QeOZnpSwB5d705I728bdHj4l8bGs4eIGPdr3PwwUtTKOxcoUjYgZ2A2htZrPQ2c6A2t2jDoFcW5u j3PKfihoDurOaB5t5uhZxEHLnXU5Tcex+ooYWaHFFgc+iPOngb3YawDWpZdF7kEf5tcq7wzJDSIr jS0EA6wjaxgkzK1xthgjGF0gfx93Bwg+ePkl3ShZWBqlkI1Zdazv53lL7NJ8sRSUiuRoqC+wY/W4 9ZSrTSXaePKc+v0L7VCu0AQTmBoFbAZ2UykXTmrcYohWu5O2vr1pixZVeZ/5pW0V2ZQz6PIW1awg fs5HH7UQqurc7nTlus6cbAVTIaJt3g25UbLNyjmi5yGVYkj9HtDUJn02ujMaSRqVygdwnb6AGn0J f/ENr818ZF4PVTRupsJQGx4MU+mMu8qCqMf5ekE9e+WQ9etKUUgHSoYq6oK7/EkMf3hck0NeG1ht BaXn6dxo7MrbyNbo5OVriNn4jeNIOJNsXYmJm2rby6oIlTdbLQSlXNkwRIqJa65Cx7DRABZ0vFpV qNeKP4XPzMaBsw7IXnZWF+V+c8GCwFkfSCfbppidAEC37a43C1kCiaSoO4OAat0p5IO7WMnJazVj 1LPjqOibk/ou3aWi1gI/NpWl68nvaJIRmh9Q3ebBgJJl/cE9FFfXL0O8YwhJrZOtU8DaDTxaXgFU /nJQ/oKHEuy0hpgFVBuPkBgSCjhjHfYngCnNMHR58yfdHbwwDWH6hrSyh/SSZktiiwV6ruHEV+NC TZmnzZt8NY1Nlfm+xid4/nkJwF5b6aHHhESFWvIujk+y9LKF+H5JZ6kpPzVd4/3e1nyw0/dd9sdt YIvT6lqtF4w63cpKDVODyCuri1PjdcG3X9rqQLWzCUu3eLYu+sMu/Js24BgdosdlWqLAu8r+4tHm nJub6ersrpHlPcvuuf1H/HHfHYFrF5motMr23mKZGO3OQMBcKPeL9lybR3R6oWucnxAWKK3gJ4Qq WQthUTenmoOjsNSS4ekqB4Mv9EaqXwS/UoTZPvRIBKN4psh6nNEDj4/6zhx2zGVKLz5SE7Nkb+FZ dCk2qttp1U6lpOwDp5lI9o2+NOhDgGujyJ9mNWDEpAvgui/M/E4nT7+CyHiYqADEeMYlx67Rqspr 7LXPyxlLSATZJq6D4yKis3fFbr0FAI6DatlYgvye2XlfrtY0ViQiFT8Qh6M61QvoOicEXqlIkSqV znXlL+knIRYH2P1fwoaBvolNJTxw92rXjB4cB2Vh4RblN9l+yFvx02PrglfqPOvleIoA6QZmBPQx UuiS0t6DXwsy3tSKIpcxhdvwq64DIoRKSE+ABh6v+OJ3XWVQZz9MA4UAR67Wu0qPFlJO0jzNt2KN 2xWEM6l9g7m/2NanDANCgeXedA2/gWNMR3K+Q4zUTOyKgRYugM7SqyzyYRtKi0EqeYd/M9BwvWYp AAhdRACd2pRN4EJKxzDkUfg26oU2hHryGV9Oy90wlhOWCWOUM8wmXJfmx6Uq4OXPOt+FdLsyq4/y W31hbTWcSY+9q3ab9B8eWQ6r1NjtPUJFYwwkkoJHLAuLcxCLlAM8DY+gaGT9f2sB13NQBdNSUx4p g6k/dmd/jC1S81UtbHjflqQvVy5VDZwtcLpZYI4afNfA5ETYTmxv8yIwd3XO1vnt8JjXYJ+HiHdb TETV2o81cD6TKcaIfbCdbTdozqzxQNe50QITkH70/B1Iame+qLDwDST4FHPJ8RvwgFWweDxz1qhZ 90Ko7NHVuE+XjV8XUCDxCP5A+QoM6lR/RMnlS4YCNdEOLFQ6LbjBPDsENH6d/omViLnCkSbj+EtE Af/mPqu19vOuTn20UfR3ZQ8MsHgV2caEfBHnjpKGOwJ31y9x4615FqV/9xovN1bRcOqC3FSDuh4a UMiE8ziexTxt/ncYg2xt1VE73CsZBflEv6BqqiPI5DXaKiEEJeOI9xTt1w7AxlL6wNrjsePG6w+q M3lt80H1rOXrdJr5K6lojh/O2ZMquZ0bfdpSqQ4LtAGZpUTPlZRWhm4sQfyfQBUT0inV82akMgq6 5YR8OZ0dAjV7scrAKik8X9Ro85NOjkV046pL9PHlOOhZYD8SbKEXodZ2pmK4Q+/qecRLIJEoRAeg NM09zygW08xyVoxgyek7wA+9M/f7vEXkg1H1pwoNkfSNQO7fuiRVflomzaUemDUMfIpF+abixuWV z4/LJke2aWRvP3IBseK6uEDsz/yPH9wFu6J9RjSzNBNYQTh/xJNWSYlaEaP6pseWj+KfCd7ghh6D EVIxbUbc1XC2JOtu4Wxtbu0ksYPR55pG8eDcBMfy/pvjCRAftxvsICDZBGP6Fwu3jYaap8XL7Npg uDxDjj+kFy8YkW7te+B7goTSU1UX3Bsfzvv4X0ZP0sSvxmI4hUyN4olGii38Wgk9tslmWps/MI5s 19nNeC3xNGjHklb2w2mwr7DpaK0gZ8XDEAGBll6Qf1SQLBuccoZplkLbpMdC01DJBIkUwR9alKNy DaeV5bN/Jwer4lDcFYqRUdiT/tTtzMXTDHpDakgnea5ogedcb4fHxmYM5nCIK01QwiU3NsRk0spv wFMH/GoGLBQspjWbGfGGqw/xayeWkZ/79OhmJ0x2i5JkmGARyORt8g0nKPeG7IhJvKzjcQXmIF0Z aRm8j3M8LT/7RkFzEFkVkwrJJX676JOuRzgbwHaLfCZfcS+hfUV5N6WDSnwAgXP1V7HN5PYoWcWX IvEbTOpiEX5ec1R0K3SQ0udv9YWM0DS44FAAxDgKCVTbWv0CoF4we8CdDsEghHAX9MUb+7NuS9bN p2maebyWv/+GYvM5+FEfHdVfNlxSh/Kw6QZQRLdz7BWjr5RehNSEnFAOvrhdrU2N2sHnMJmZM8Ek FvrQr++rtRTBu2JCeULsSwl3ehIq5vCsa3BIuj0MIaZ4wUsEQ8iMkE4tAsZ1dx4kDgEa2sgfX4ZJ YH0Fh5CVrh8f+8+8aVJ3TT9DvXiKzoe7JFtKQ6qW0C8iOzxdSYftYHqgjc4tHYZNJDs8yRzNVl02 r6dOglridQSC3IPjQtDcZgrUlX0Tjr8r+ezTL4zCBkCfsM4gG8JrF0tTa1zuXn9jufgfP0Bo0mVM tsRbuWJrlANrHo0D7dV/fccM8DyXgXVb2PpqAGuV02XTxnBGRJMMyWww3DfIwT274QXSfpjy04Hc klkXvd8mDXW3SvzJbW9IbFiw+Y7EsHm2dz24qF0gDxCz37EtEL4pdXq8gD5zh2ikRD1FcvAHFK+T nqI3YbbKqArVw87cfya0pw0oN43iAT6JkabZ9I9ho2b3BGJR8Zmtv3MYQmHWLmBB7fxao8guam/i vquKmOdA9mVxu3Xd+4NriYg/aiKoQ2shHsqj2VO59q1GHl44lI1bVks/AQqbpUN3fm0q/U7njM1n AtlTGXAwqbRP/rzD+MWholIeoi+tO1ulZUtYpIS81HhlxGpLsBBRB4fwO38bAxAMq8oGKW2beUP7 Ey0eenJhZ3PL4wJqIRnsodWj7EsGvp6OCLtXAcBTrAdJAAOZvH26ypKp7o0BcbOCu6fSpy/VKSIk mfhdWyT0PWgJbFzBLnwOzKjYIguAUZl6H2Eq4kEgB/NbmgCsnPApK/lhdSWacFAh+Y27hGXwxDlE m44zvdsnYtc3hJrZescAfpK4rUUjwqACh3SbeYa2fTgHapK27ZCkSnPY2TkvlUEfwN7MuDZU6d6P 4q+LROGdvsrZO0T1MUjyQsp4Sd9zVFWtK5ver8lmq4LIE8RObCKlEXna/HNpdcHeiq+Dw1hP056S WJT86weWkAeN5XKxAzt1EDIcsundJPJ+g9Dy1wY3YLRdw5gEeE+OujT4RYgMyVWFrwCLt5G4ati7 La8K31etk7kQOc5yjNPPDR/FPFcxmaY3645KbG8jypDxU6yPmx3Z88zR75eEIcHD49h8S0h/H99p AbZY0ntxE+P3cCHlOgALFWwdKk1XAMUdc6FSES1JPiQ/ioVcD5VHBWfGiQSY8pUeyyf21lOGhlbm Ax8LXUyvsP7qwhkHfBGzKXG7Tew4CKGrKNuII6g766AiOzPpmtYwgtinRCenvd8P+FVXSdh2sxFZ tI7ujHmSyH/BfXtBawHVFoU8GZmaO1bF7GHRGOewzjuceInckW78+O2xWmz/g6Q/fHWQcuttNO5Y 5yqj9VbO4VNkYEb8ajQ+/PcQUNKfp0/EXwcjUJxTeLjvK0H4G1oCIbDUzmJFbpivCNyK1Pm4kIOK oVGhIHwxLteFHQIXCrwp7pBZdBGvWLy8MZFvcABT9PGOTKH+X7sGGQKb5r+uIEm/ADkh6sYbo+a/ loDL4gjX4TZxCJMvJr36yK/Xu945HX/+hJH5wlTPS6v0lHuVkfAUxfmnDkqgvGenHeQQ9YXw45c/ ogTYkmdyqLeoXXENSN/EomLsMjvYrHQOh+r4WinO8SfzO4Vdyop2jlavzIzBYcf2McuVt8nwh4NT cueyCmHUhuENSd2FfD7Dm2YwE8RQu+DxcUCbPphKVk9AKMPkWfNyI4/PY2g6jKgg55WAWuEYtQ/v M/OWFlqDV6FDHhR9SOMi1fi1QH2cPb/KHEFPxKYxZcRXjAAfMjcINQJKikIOznBrRxbwgF/vs/vF Gel4M6RWDMurH2U1P3KX3Dt8AQDtYU093lKlGOFtLsaycQUF5nCp4++4V+L/4Rqt7fahRsJ+eid8 rFc4fYLjJHMINjvcQYocDtKIYCN7fT1KJYycKrbDpkcSqana1f9S0r7hxlwjFMuiOJddrNeUYXQo vPwcp9r2+Z2B6SI50D/R8Zm5DY8BRF6TXpWrzknMELqb44wnC+SCuI+Io/9MCWc0Wjcu+qhwdc3f rddimJpgP9U9SXzWARnwDVjs3tFGsbzb+xlubYaPqr/tlb4lCQxq66Ufu3G7mFANjsy5BFb8yukl TP5N4PCwXLMjyKPiqSvu2u8dkFakpjFSKQi5fExXicznQbKuHgorPWT88aFQpeKCFR85yv0AUbBA wrldZISYUNml6CDqhB855QOLOSBhDfiRo99OdIMpEguZXd4HddIMghKytAC78B5b4pSg6Vr22q8a Uzl5Mj5kB0o2DEAi3sRcvHB2y6cMmYg+UioDfU/R52Epz/EGP77s+aY1b75qCcAmXmwLrwexiF32 6SvsOc3Wd25T9rfI8z2hWiT8CBpQ2rHU7v6WZuLyx5VHxUbadhl9G1Gajvu+Q1gn2dLzDLt+DuHJ 4AtNnd6gtLIs7soiI67E1yRP5C15ZR9f/w69CDSGbvAhxpZ4fszRI38/5Ud11OQ0WMqPNry7Tz1U /cDiWtIT6qYtePC3aipXWyQD8XsmTmLe8m/YFZziUd2Zp+8eA+H/Emv5JLYozvyAUZZBo8y1FuqD 1lJfz2wekjDAX77uK1Tjq+3tbZkqzmztModmiwzcoqVY6NmrclPRud1vVTQRcQ0Ni2CHHSAbKHwg S5IroSOV166Wd8hri+p4AK0ZWyDGHT11oDb8q9icWftJF3KxobmR1sw73XNDMj8kts9FDOkjR4NF ZHZMiQy/Q3vUQiqUv8tryN2Q/NKAkBGrW5ZlbRMLDdcphYMlPfUDZyr2nPqqXs51dtJ0zTvnv7AG HNAcTsO6NPBjavPVrQDxXn0wDuBw38MkY8WsYTHvTNewNjox7RPq23dkf6XqfLcmqMEsEjePb2y5 aJTyXnK3jq4jbw8vR9tbrUvlMz5RlOsaq+J6CpLavHVPJ8e0btOKiRs6iYfxfZkI6x0O8gbLValR bJ4H1ByHlWybTZlleFY+RfGyrFlSjuKEbC8b0Fqtr59vlqQbVDYnz1cKQ8MhSdoCH3XsvJ2bf1S0 I4/6qW+T4ZBKAREiq3emU9FxroNV3BpOu15Z6uH4tHnldezQz3xfDBSLFqzm/yxN0kMuI+70UfnH +pI/lpHUD0bD70qB7KiCK83Q2r7BEpQ55WEWuC2jMwc08ahTm+82s4JRrzJsLhTp7RNl9KFu7On3 LhrtlG+HOz7ykRXvb0fEUj51Dob+5Pl9zkx6ivZi5NDETnPqx6V/USX5dfGNZmhdu3arFJOYRj7f lN9tAkSoGtAvtZIWNIdbNk3x1ooA1fxonXXLMw0SZpS8qp812gf/1jfBuZi6cZVtUdCH8wKp0cku /rShi86vkaCTpVO9hkU75PUbH/tQrdj0Qi8g3EmnXsiTvxnYBGRP4uhHNfK7FR5sIM8Z21oLJYFd 87xwPArEOYjJHem1Mjg/yKkm8kG7sAthiLqkC19jYb91iRzk+zjtEED0/BwBHhlNSWMf2MnWOPEo +TzQ7h7dCzNtPupJXtoBqlZTp315GG6LzqpFa1ySIHLdRocV11Kl6nlPZ0iwNJ4ADWjkjBWuo9mn 9K3u49mkzXnrJH31Exlskdk0WIs6luxtc8lMuz79POBYXWUMJeXh+7t3zxQf/61zdgcNBKa29uXt SG/enRHdiCOAiZDnVFN65mXQR84pOeBeIzoY/EMIFyX1L6o6Psdsl12ryclPzLJRwlaeFu7KUDBo rV0ODiNI43bvV+AByI2aQpWETgdCz5uNOZwbx8vU6RF6BPptsJW21eMat2+6f1x8r+adFQ7CKmI4 sVm8AeJMlPwyUw+x9OG6/b7HCUGfgJKNk8NMaGpEsXhGE2On8Eg+lpgvFXC8VZg2sfsdaKSS15Zh rFWcZ3F1u7sipdwJBtH6WgfmrV3drevkE9zyx3qT8vo1qOCk/3HZGQtmWwWTenKJzaqOwk9ZCjWi nBV8G7G86vYa3wSwU2bbrP0YDGNrjcDKL7Cq1XTi4pJCU1Pe46CvePPMykME7InJqBT3bVNNtoZu 8suobRtRsWQtoNXgsixXqThdbG2cY2uKDQydcuofuHiydHhvMlN2ghwoMhKd6ymV6UUYuckH7wD2 UnE4ouAAAa7dGGDyGaYEKYsvZeBn5KQLIoVQAETSS35BcH1LhEstzDNyH7WqT07pPCBRIi4G4StQ KQ7yNenIdJ+yxVENStQy06lNAPZe9Aa/9sxCnwXXCQaRfXepIGqMARZafWBI+WZlf7PeBummSjxm 6OvGqrl+G79MwWP4tdp55Zsz30WAafsgT1Uw1H4wueq2rZuIXCyNa4ZI7wbDUJ+0TOhqbNoIMNEq gClIeqcQQfK8LPRmjMW4oqa1/QmAhLbA3PBXtu4Qp1u4L8UwTUbe/I+pgAIsq2KgH20fKatsIz7F wyv2IHoJdm4UC3j2ufPun/gAJn9KGXmtDCiMN9TQCmmwEOgh0Tghtq3xKR+Roh0dfF3fWijyie2V zvI9da+ofPcypQIi1t2DXd3wKd3Sp9f4yapUlZJWM1RhN3E2dxxjBanzWX9SO2OYFL3soWh6pm3h 4w/+Z4vMbioQ4XXgDJXxc3aH5MHGodu6FrNNkA6l5M2xbVUQPxbTzmf6LhZziCUesubUXg9k54Ze z98m+Quwi7zhcNWMv12uZim1aMTL2KMgGm60SH1YWN3+DdCrhurS91ZzIzJMGqlimJanTEM8Wy8m ZcYHTvuNf9FcnrOmsDPRgXidty1y1D2HMPuzjObdkvZMPPUxtnHlsljsv9qPCgAfNzgL20CPmksw D8CP64M2OlhlPEfoYXdGyLjoQsmrXpiNFvUM9/p32SP4uqj3jljhLjtdP4DYrLvVuLlbEBqBDC15 1mTijYn15hfBU1nuadLUaP8fAB2A4n/LRNcKC/ZeqJ/m019FPpidsbpxEiyXk0c0sCdeBz1mHFhW Um6HcA/5EGb9de4ebqnTnfV2WqN0oH/qUAgrlW8UUAFSy9xqfCRtR9N7Qos98eppm8AaYP3+qb96 LtOh3ywrej1GEbsj3toXNx1VM8wsn9kWSutoGiwtRI9jF92H/oWT8X1PMQb6ZquTpNKgUet9REB4 6+1E0rBDoS62asKY5mcAmC3Sjm1E8cyPzoXUiewkEqowIYuNu+wxcrwmYHk/r1KZPfyVUWNho1ty eo7qoyTAbfCoGl102HTt7+h82ut8hXugC4G9itUkXFwKKIxad0CpbuaXOmHn5IwIpfNgLlgRC2+1 cFH+EmD60IeiB/Ej8vDBsRV1G+t3GWK59F4kM5vBQSZ1rm5p5643YU9vR8dp7m0JtskUsNB/f2KK EVH6TzkYB8c6wKz7XunquDr3CqeKJy7N7BxXTuaNc92lWBu76RvFAcMDRk+8eJrWiDXM62cbhFFI iQ3Ge6BRpJIJILiXDaBVpyiKRV/x75Emahtoq39ax6P5/Ksv30LhhLzCTkD1fvrNjzjNKHTd8h3a h0jZkiy/tt794n5Kc+vwzXxRhnO12F11FsfWsv9PRVmWnUDYmoTpJnHOqKJBLPU8aIZFLhCANGfB vF/DoZLJC8OwHlu3iLKHPCWHCL17XVlMenJY/BqPMvb0DurKtoFOSV7TF6RgbbIWFReKeLkApv2w hQzLoEmF+6/Anw840yzQr8SIdv1xjy4ReDboap5A0sRf/CpKH8uE/H+6drzbZD0cFGs4Gf6je9qv iEOvr6+cVwJ36uANAGHSaaPPeohUMkTsPgiuv5NwLkou9V961qL/HqX+Nz/R91G5hXI1g8LyODDw gUcylsXTd8p01z4gYVZ1ykY0ntNNe8VIvwooMBtGOlvyHVxo8RZ5yzpt86wcOocJ2iOCV4ypOZHS RCX0kKAQDdOaNcqzI3W0plUXybWPtr3nrtM9db/5lwk/9+LRxMWaWOlTjjxhq8VWk8EYawd3XcI6 tfEv9HDDOtLD2kBTjVYZNY7b75+K6c3WqJdPF1vydf+pgAJX2wAjCPGTCb2C/IxE7u3n5wuPjDbK 6IryfnBt1UjK8X5RvNIsfgYwvk9YhXiReBVoNa2gPS7/gNRkV/acyd9QXlVeCg10pkQhyhv2L6r1 qkgMYDWrhtpPFY5iTCQ3spmHj2UeFqgZ7ip4CDYPMOoKFhHL/rL+Cbzle7Ns1o+nZYA8kUdUfG8h B7+rV4qvAOyNyPZ/HNWsa2oqP6N6civSygRrVXAAruJephTX0k04Wl5JqGkoTZAR1MczT4DYGno3 XtrUBs2+xqJFaaHfOafe5mIsmar5dB0OXUW5Tk/IrwmkAOjc0wGAJbjeWwRLqGtle9sunHe0IuKK +jSZtsRkjiM4TdWh0BKm+fh3Rm6caQYRGsB49FZIPVDVSiq0te+6zdTkA2uC5h91L1we+ajjXodU N4gzdfCGcymog5IFKKCRX0dTqeRH6XOjr1o80nbTBamZ6UqipvkRaGXuvZGdDMMLoaYJWyTHWYHe wYMUsLSGE5ND5qjH4qZvllBl2XpQkCV2GDbxt9aBCoVxGy72LL7xJRsFFv826zEjQIm5jxn8X9uQ tPlR7DCBysfhQWWDfXlZA6PzaxUfBPeCXajeoVH2Mzxij60XP/1tgQskQEoaO06z7L9V+ufW8Dcc ODVfZtZE+AgMXXB6inUUt/XLq/FlTalBGxQPchg8WlU9NPsHQfztSIS/YkJOr1RoA/yDNqN+pQ8O XC4HSmpvpC8wFw+p1c1WBoD2XfcHph4jy1TuVI1gzzj4+5kdNDai7d5BKA7TU5r0yZB7P9m12bpb LYyH0HFKceGkx8bsy2YWYKP6Irl5vBgokWQFwQ/e9pqtCIMnideouWNMVrn4vDSyEwdxca42S1CP ovwDlMFIB8RLWpO5ug6+wxUr/E0jQ9URrl1BvdEwrRQMUTwvHozgIdH7X3FcSAVwhzWuPHZIdfaE 3O5wJVP2ekY27fsu2ni/rkEOrQtmeiHy9GoudIE6a6pe//1IuU8WatJq4gHNkjOrgFwLgyt/qTIs otDHxRx7B9HaRDTcIAo+iUPxvUwGYY6YhKyCavn+YWu0nylpgAW1u4tAr01lTWsQ7295JfxRYzf8 604hHa7KoyJ7Sh/ohTrj/u9aPJpkNN6l0I5dsRXFfV7UE7aQ14jZ9RI2t6hzllSEIs7z2u0fdywP a8RmVTCCQGCEiCUaxy/vG5BS93+JWHmwwIW3D2/xzv0QwNqE6M+P3ViHBWvna5PmQRAe4HDheImB HTIbd7wYvLCMPRVCZaIs174FPhOcMVQwV9ew5kePxF8PBRiqpjQEIdkUjiA4A5x1SKz/Y4/UNXcH Wz4qeQEzFc11J7bdIN3K5k/G6XXfmOjgpLG9+rfqVXqVXUOjG8jHRx5b8jOE1mGjdrAFodPNlLA0 R8H2kYYWzkdsFcpY4cmiRX8bQjLlXLCFPXz6wRX60mGJFbSPDa+rWgBUXaqbx2T8aqizXZo/m5K8 zGUNBQyW7UIVRzOBdVGSsjO4RsltMKO3JIgVbqEdajZGvjhpXWm5Qfo/RHa0zt/5ZwKbHy6VHCmv ufvIRmSV/Lp7syCgOuUN6hRF2eTLyKy8lRWbrXUN2MwYQHP+ztf2v6M6OSiWpeWfiOLWZZlT6wSi 3HVQFX2DJg5/q3UY7GfHrxR/pj/Io4btpPTFmkWj7XeN6+lHxzJG74AyzkK7r8xmtrA+Z5eTSL2m etrWaPSOpGLpyK3kVI6YqgJlRh2uAtUJvy0tY+WfxA4lBI3b5xRckFwh9CKpiKdZWAsGm8qgYhfO 03884K6XYZXdWpsMRjhY1FYWUJ1npkLxyDASew4Xl4wPgZjKS9CY0n0ZRl99F/d1m382FOkH3soB gbKQly95X+KNe0A6kwD+/nII9fjGr1Mnfp2r1002rLOvHvpJDJ6hkqkTmbZUSHIz5H7wFHZqMeVn D5Gb+rDSYOh9DEDxpJqtwXXpt6hWB3SxZYC/c60JJ69Q15EE/0m1UVk9m45wCbt3FhiNIPZGS9cE wDRJPxbc9E7a5DUOt3y0jW7PNQwTI9xzh0RvrWVI0PL0jRJ7eTW3y8J04SzQguTkTzbAE3oY0lwA uyHjo0Bs7g4cevPdGYluT1d7OsQbM/CwxYGotoOVSOiQm29uWOXVh3mxiuuzshv+v0oci7NvX3Wg XzJy9xmLi5uPOKQNZxXZdcT9wzt9oVV9vWQymt5+gbsSVmJuZ3fNhhaHcI/sqHfgfDN5tKISFU2H eY3QEl3bDtIPynh4+pJJVobjiDyZQpTz7qlyhMxV82+G1a2cxISwd9QEeDRS2Wm+6+UNYbgDRts7 rNPkZdCUtkyQdf1bDAhrTTqxDMjJ4fNBw+BGEaXw4J7PtkL1euqG4QaZGalow+PF6JnGuorwDTXE CAYcAOSm5UROXpf/8ePtJdbUZ5CF4TIHPVY9kBj3xVAUZBmeU69f4ceh8soOSCxQ9cRfelZ0jY3j mYJuzGubWv5notzKmZ3bof0rULIiu4Czbefzaqz9viYSD4gcLs4hDMmKhPw6zSlWjb+GEiSZUP8W PCw92cdNKdsl9CXdAxILmv2OyJxYM9JzVGHQBQ5/ToEMjdv671BmX8YtfqaLGqKjiOPEQ3s2AgZX t/cd+4MzMCq9+yi0QB3Uz1TrhFURXa3vMH0t9KM8R6I8Fdpm0ydAQxu7iLzRrz80NLlqY9w6CVzM vCS0wJgEFl2gNyfj++bBS13kTFpwKi3qVhq59+sDMBrlghuRDSHIwiZ7D098yM8kd06XyrAXyKu2 vYatIiTTh2ghGyTc8BztZAIECxzguG1U+i+iNhf/yq+/W2m3iBsloZZHIvnSQjlXYis9vhMl5p9Y z6IFwthWNXjoW+95soLAU7w2gWBhlu+jnVKUJqhv4AYWBKsgduusrYiBs1HcSDre6EWUAdK37a+6 pI7oDnesdsAp359S4iMGlpKYtc0Lik+NtByuE0sV697ZE/qbmA9fPbkGVkbdH07zWUvWg4ZtPrGI uDTIRy9cotlQpUVIC8xES1opBQhkuVkSedvoLmFe8Yv2cGzK5DEV5omuWUnZyh84/PP3XD+R2uxb P13ItjZpinhp90FbbSq/liGtD/VquTOOjxGlAP3xOLJEZETc1T231z6uNzxdBrvnpbtfpsT7Q6nW DniviSxotiSJcMS3q+GweKNMSMgP/u28dwh/oRDY6TbLyKNTLtKRLrPvPQ5wntqB6TUbu5sZHZtt jpmo3ljXBs0qwxi9vNvNRxafiWFj0OtUMkkS47y8eIu4rxkZxOZUCOqvG/JcMGpv4pa70VSd9xh1 L76gjVnlVZYJ+xNyV2ipd8dmgWHSWwyICziAgMhpMIHfD/ULIM+thdwTEvx2PnYG2yZAyUuOlH8B Jnj3m29UGYh9lMMz3jt7r0jgzDK1Y5yp+aBSz6Q91PIf6+5WjY9nuzUzZTaDTiTHU7k5qdP7qaw8 PQ97xTkMDHY+B2Qk+2sgLLNEQmKkOaPqEjl3r0DqX64cHunWFgM6iYsSwrKlUjd3mxZZYWklrLXc c8TojvfNRPkk218bBEYet4HFdim9wzXhsT5BdPJ/WsG3Q5S69auOY15XVK+mi+beA4pp63VA16/I HcX/d2RSS1KRRLOUpFR8TydlZlI3QxQRJ+sPasn/8BwJPucg4NVeeOz3DumAjNV0gykU7OLEiIgz UOt/TTCK8obLIiRD3TLbC8KAztwXcwrnF0KCQN0+JOLZ1250rzRMlPJKIdc1xOH4dgBf0TuVGqac UpI5AZrA17lBwQKf/jHXwJ+bd2LoqFBC+AJMKKCeP2iu0LsTatRONBPimIZGdYxuAJpPDULqgjy6 T3KAQNKgmKwVl01mud0nZ1T38wiM38K3Xon7t2eyeUiW3jtx156PFsNNWcD6U1Reis82xC2bKXiO ONtT3R2BfEwUvL3VmfFYCOA+1MNNmiu8kt3mzzJeXKAfyF5TERH47Cy0Bh1ofHZnl92Zu1tRB774 hEbyMbmlzRlklaDICPWfgw2HCVKwwDW60dmGrUacFNjlZFBNFEF3ATsJDgYobQmzrmLNls64UEH1 3mO4f9JEQTb7F6/ZVNy+glNJ5ZYIN/jEKidj0MmSJkDl+utJYr5d0q3HW9tawwa16CL1bbSGUEdT ioOaSe5FHcjoDsG/62sQXMi5QwF0vicGn+eBO4aC8pnUgNUg9ZQll5eqASemsfJSDneP/4QnUhkW NWXvQO6llpp5zpSc7bZbF4v/fkmvgqm91AV6z3dlXdhq9V7OcXq7JV35RENRiyQc/yACNP2XWn0c bJdS54TKUBn9yg8h1LGkbNcOvZTUbenQI51QxkFRK6fJUOWTTSvHTlOhvRr9JHQ0KwtwnBXlguSt yN5d+Rc037qOOpHQc0Ihu+jdpoFKT3uxGy1uwYoDnFLGaNjh+iUmmLe94q7ou92Qq4UgM07sI29c Hf8s87ci9rFzaiEFmAuG/5RaNTh+MhDPGiR7SD3Nz9+WtIrhFrouSyphkpUzniyaAO81v9/kSM9y Ml/ggTgNguz/7zkSMwCRmR00sfSKPiP8S017wk7lmBDnkAFMxDhcxzmk3maga79mFZ4bp3CN31Pd sUtECNsxIR5fvsG43xoMNMubxmFfZZUDK32k+tx+2JQR0QrKNunH9ear2yb7HXWG/JqToHcVuqg6 8LbhswwAKdlDrQr1sWSHioikweEihjjfKrrh5G6xDoOtpa4M991E1I40WcXzpG9DEmFOuvK91zYR /pKAmL6CnkG7qSbMAnI/GMpcfsrLZ4oRrqQfeixQsSzRS2+vdKMo0+7xubg/PNZOcUmML4OUxvJ6 uvM8tgkMZteYrDrLFUJyhnxsNOO/d5ek7PT9x+5Fuu5yDLlVGoup/nKkAunw5j1qI4Zud1iFJQQG KiT6s0mphWeDSlT5YCPCgPg5xYppydFkYKeh39/AU6g1JnBLjBgyFYO03+qjurXJVkPCVbAbfzGv 7cseegjFoQ4Ni4/B+SulU2IFQoeqX2I+jZvyziRODj8wLG6AvgwDACH4kpd9FHBk3AYELa2EX0Xa Pgj8uGq5jmzu1c0v04CR1P5MKyUqGiavgTBbEd+Wtzx6IbyghkubL98ybrrXMN9IqD/90H9OFDqY 08mBeqM5im4pSUND+/R/TAZBBWMXA1h4lBSa1yGRzdaGr8snoiFDpVu0dOJKFDbu7rJ0vZmrWDHH IKbNT5V65xIBjxZ9MCJT93nm5YxEkMJ0L0oYsHFM+a1jyDmolqz9o6bxmZsk5BxuDCyAHm4041Dj A2KsEukl6XcVSSf5dijQf37BDDJNIo4rwlN1MiHIhFqGKaC7XPlS4nyM08ODyB29g4YMwj5lTWMU hb1a0Bjb8yr5Me2OZMilmATVapuM6MO7Y8C7lNlJ0/q+0+NWp5o4RHzMSdaZ+GJPjjkTas9afeB3 fB+kF7h5PbTcEYPaonkcijPKjurROq+wjsRkv1T9VXyYFtEPMaMlNFkJ8btZUdXjZ2h4mTTZ2UKL /6cpqJzCcrGcD8H9g6bWdLei0garNcC9ryMLdkPYSfk4r3aa6taZxFaqosiBsVXpd5YplAUKwY4c B9XKAzrla0/vPFRnXORyXaOz1wk0D+8xlsfqy6lYwYTsgy7NTJMq5oVuevet/Xs6AFEn5VKUG1Nz iJnRilrl/dwl3yDrHt81rkTjeDaJWgDRSVvZFKN6sNc+SWZOgBR7yx8416KKDG4jpTRV9TisMv1a DIPWJRCQlW8L09C35ejpcBLeOh0y81KeyfyUMJZuNp+TjeeDfCCJnuiP7nKyrvqRLZSTbeOlo54g 3t7san+M3rERtUOdWJ5AWfmC/UuFOezYQY9PsKwPiiS74azuJBkCQCQj1ronLmn9XuwNxgyzigRP 2p+qwVOHdtrE9Cpck9vj3HilMWHLEHvNg7RRIagKaMkBMwh5fGV+1aZfoHjCGV+6LbWvF9C/7uhs NbcaLZaVEw37RFLUacAUuGo29GY+JQFE850MZU0VxcB8TuL+ZUn3EPOFAQ6XDChIyRkp2Ddihxbq nSJtD/Sj3x3L8arVahhSpd9rxM80Ywl8x1tjzU635FhBerCnn4jjGpaTW0ShEEPbzp8PDebz3sbJ 3gMaVwXKAjJbiqhY+gFobBI8/9EuBYMmXejskIGkhqQNzHT1okVqh4mZEP3JITcheRCmWTwUrfcw +doCb7fBqou4iSD0fqMX++hCNegmn7dREP1t73nJfVp9T4bNYAWFDqZ2+G7pEV662yCZm/MZx6/0 qY4kpTc8MLXmWeiJ8P2A1+B0wlEi+5D1/xGVR0rZyYXV3ZmK/OVYfRBiCWlGSG6EgtZqgYDRCju1 yAaq8zM7j+uFu5jGcRc/IQUStoeWDZZPkts3PZLZfCvm0zo/7MT0ZfXt07zD5+5S7JW36dfuUxII 4qwLa7g6dyF9J5yvAGy3sABisdOdsoXX7hpIKmaRV43OAW8Xr12CMMTlNIpKn10GXPIaZyTEHQq2 dOhSejLu8Mq7hgh/Ka/Jkd86xDvxeWCc/7lGrZu/mQCsuCgr2G3QwDESCxMXv7cROOzKuzn2Ia8O 7xNR0K4D1lYzu85CLXh+/VlBpZea1uMpqrUUezUgaMyCC6qCDcYp4RVFboxbYYMbn8B5K7Kue3rR zyc/YfifjPXhxijveCzl9RMIXE9oMCTY2iAkh+1jEjDNBcVPHgUUn7BqF12mLuOmPw0Y97zBxr/n PWN3HhSflHgKeuQpmDBE0vF2LPatvK+zykhOnS9XncmqeTiMkL9qmKATEjWPNF6lcME+hKUGjs9j /ynw8CKCQ9BvOBWFn5u38RuMc2Y8d2cR3fJQ7SEfTa3Dmez6tsO/p8yqfhx/yFhUg1lf27D/cOnl ANsJ3+bRob04YBfiedjeTkFUWnM79TIrDmNRaXBWcFYACkG92p9DmyKBiUI11+ydMEknxy0wNCZB 87BZUtY467WC7+GT6SzkgS17/glg/WKbMtfab37XWZqpXDH3Ca0bwb1jwUNmzb88gfAO2pxqq9rT GKhv420iF/d8UVH7qWnlMz76rfKyEJ/ltiJdlB6sEOgWeONu1xetnCAE+8VqfcCOQTyfl2bpLpN+ A3RHMuP8KthtRIv+HWuhW9SgT/uSBw+Ki7C1+cvWKar9UUYl6T8ceZKLojn18YnTyJ4EDa7nBhGR ygVEmm38/M/3wrr2646XSNGpQvC97/MLsPGkYWOTIBtFlNeIq2m6doMQ9TfVoQuqiX6Sne/PX2VZ XXFQ87nnt7gNdr0U8QAuLErz+/hwJCpUuCG3frOApzGpMcynp+fjHEU8Hcz0I+K85cCaHiDECdro +N7wMvvXDDKtDUYTuNm35RkCvQP4snyNKqr4xyZZW6gXnFRZlrcyZvXyi7gyoUOWVlZ2arcJXc6o 8ejUFt88OG0Cie7jFFBkPYOSFzL/EN4c+qabLn8xWwdHU7F5CDVYkgDxPfo0MZuGN8DHZlrF9xox HdeWQ8uzkHAGDvW5nKc42vmi6AVuuziCyXPyP4VKfOjWR/uTZcjIO7nkKW1Wy22s01SX9X0wPJah 0wDqFiQsLMa/zTZSZnE5nIqduQfjQ/c8LfGBCcDVnMu/QARTKmZtUKzLPYsLQ8HsLVAxm/tmFGdm tlr7T5fhKQ+XbbzjY8KofAAebjop3bZiX3jGl6VeGngqqmKLGSUgJl3OQo+hOMMLXuOPG7CQuCVN NkmfssF24fba0keQm/zYsIFjLmoTyvR5rWNNNwlCdyrzJdPfNTzKDSX7oQ0Kme3ens5VgAM7DH/S CXmrbhkwuQ5bx94p4Gl9eo7f1XsYBrt7VmVnSbFyi/hpbyUiPE+zNXqQU/YmgYWxV/hpkNlDFboe bm5vD8dOGs36TCABjKb551/v3ovvrHgYG3Nhyg4+ME2WgWUMdNP9KwqNjAJvS+vNrlwakIq7evrT aF0yJSO4+7rvIt5g3dOLXMEdBXwqKKvAZ4hbXOxjIyfCpvK0bDCjE65qojOwRaFD9uQr4t0Oh4m2 8NucJpReg35pcKkaLFYaCxbrNByotVHDyCa5jBs96CaBmltZEdl56VtdXVJhfUKUmUxDqyjhzs1c nycnBB44/OgaayB+kbY/Jrekh6RIZx2HeJq2Nz2uQeSE9kTvBjxenlo11UOpdjibmo0FHY4yUR9H bCXsGEtv51NZPNZivKJoAodLr2XA1HDnGrTvwYaCo1MqEXQPswl//e1RnDECgM8GajeN85REzPAq PwxWLzPWrhvL8DJTTgKSQ0As0jpTJ4uCeaUm7NOWDMCKLYrON5YQPNsMJuo9j9uSdvSFx/E0DdMb gg59KckvtcJuBoRILSKlZYsD27pIbIIqmAz1WvvmjqK5sZCns4iu3Bthvpp6isWoLRdU+UQjLM2q 0viJrxN1dFt4fK6pFc4VqRdxTj6Nw0lxD3YVQJbCWImxDRpYNCaJVgkuXq+bE+ds4hP4LJFni2m6 Rx0MuYNC+DAfwl7RrObpH+rEusiKRqM36lPghxMjMO93ommk6UV5k2NcCF5fBcV0p6rlnIQtU4qZ 77Lh97JTPyf1n+8xCH50K0F954djwv7x7kySKtOWSz9NpiQbUA1mrmhWdShi9FUpEV3CDj1xhEzq BwbtB6pSo3XKmDbyB60n7uALnmavNQxSQ509Y20gC0NY6TnmcHuWxcW2pTiTM6mewvFjMVaDD+Es gTYDzrVPE1L3LDM8blMruSffQ1aFg29tIXXiMK8EwwXYSFtrkZ8kFrhaToQ4z125qLAlu7SWMfKe d4MFD8vy8yJfkt+5XEWNGFEYE09gUB4o9zGdXoF0h+l0sx3L8/iNqFIaCFnn7Cy5zWVXPon+Oo5S hHs048FlCSLyAYap5+RaGGJg4xgTS+P/cEkMf4iM6/LQ9/us2nzTCXIBpYJZiUH6FFIJ9Q8Z9/DC CxH9sPSiyI6RWehUHm3CCPKsXkc6r9TZ8H8h0zbDnlYzfDxcOl4pCy48dcXOP/wxK/1Y/NU9ef41 FVMrIlWwX6dLujCpiqk/nYg6qr0ouns+ftn+f9tkdD1+eof8oD3Z7R3C+NpzJf9S/nmCWHWBHHfT aiDuabbMRSr/PMiG4v9svZf2PT2UZw0cLB6smN0gLoGmtCizapO0dqdykd6RhugRMxK8WgnEHNCg uO9fsZ3c6dbnuNSaUjh1iwueVwIMtRygut9xetPSBrJhd7v4dG3IFPDvx1creHd+dgyEDB7nQrYe fYZocdqVGRkM/SaUUn8UywK1jq4ZIbzByKTOSCsIj4eq2XtNQBEFHc25mq0dfkcojuSXXqiIYHz6 IBGI+fjXEjhVD+P6kqD2oAxD2N1x4aAZfwkpDXgBseOV21cNJjH3Wydo8w3q2MNWqMja0vViwSWt aDcjIo2fNH6HF8S9nkBa/+M6puQupqNhFv+ZtNGHkstigbkcrsR5kqI1ho7AnGTy4M6gwEC/I/dK JVj39z8+yHYsKskX8r5dYz5J5tEKcNu+rxM8ygVrwbru2Z2+0LUut2KUG1iNUii6WfIMl84nvw3c VRFnujhv6/TmuJiCD5bue63ocSRkzot0mVg7Ryzvo2NwqLzv88y1Bz8JHcLu2PAOxNpLS/8IAYe7 t0crAFHC/qQDZW/CgIjQc7PYeCKb40dngKWsE+a0yTQMMVIt0enZl2+2AYJ0wGdUj463grYePu9e 3d86q2tsF1yKiBvnIUASghJR3QAgPbZXjI1fJmBVnFjQHo5tlkzMtw5xy6odLnZ4f3pnBTf4XqfO WdNZH2dsXLDzadJU7waOUs1G16eNCB2hM+No+/YvD9QYpvVIcH8YDZ1ofkyt4ZKqBl55qnnqwsVX KJQ/7/2hxE0izegACgt8Y6QeVC01wNJPCFfSyJ1VHexQWxkg5bCJSYaa8nD7sS/QRotVc54O8Y89 9wXF77KFQ/hZ5ITG4kxgx13AKIO3375Q7JVT694h4BIVkpdj9mEi5wLNkqvCMTyp34OLLvslrLoL pxVkPO94tjcf4c2w0D9fwf1/C5GwIm38/rwcd5WPpKG8pnc4XDQDCdFd40yZNNxx1BAyaQnpu1zC 82ffj5xTZxKlQ7R2vlKMBZnb/phuqo3+shsqOKvwDW9Bmq4RcNtqZ4fBaoLDSMXB54rKmSyA+eDr 5LKFcp+NGvRvMb8lFWRq/HhGAuwJZOHiivUoDVcayF3hdF49jLGVYW1luRGjfPUOGd20Eq9DsTy2 cyQF6b3/JNRAHhEiWTf/UHA11tC6XoOguwdDzgvZ+qs3WP3TUWe3jj+Vo6sZS8FuPaL/5dfjBaAc YgLTpX/l9aEZRd0oRm78zGmp/JOfnEFQ5iRRYB/YmDBMbq72er5M7aaxFu24Q9KBeFLKZRSpreFk A7Am649+hUPnQCBmUPIzj/jCclLjFBJ49SyDa5hcx4B0F/sqWiCMYimU2DH/sszgPN8CbAXzXR+Z d8MukcXvPklGSL9dOTh8gRLibxwRjfTKExZLD+J6PdVJuGpI2guHoOICOxESujeFDSrkCtIlRWMc wS3V+K0+hwDVkZdelvtkD4jN+V3IQqTxs3XewOAgGjGvaUOESRxmZ2OZTRSCuuE2vTCZ/hKaWcCG GgiXH8RP/uYCkfLoRJfYR32ubZhOck+xjHdIrgBVurqzE0X0X84kJtzqcz3kXVMTqv8cBT9u3+xm IhfhvJd6HZxRHiVGXFcKnlDRxzsM8seFqG8HF5Q9lBmwAk6F+Nv0g9iaI+7NI+DKSmcbbX/9adtZ ZWaRn2RRTi/aLkeq3LMtVLVpoyYXWfTxGYJDgR5qELL/p0XrhW+o/wFvetPonxkigeE1XcwYqxd6 F/GEaq3Mm/PmwQjDoccf3Iwjl4LCpz5jvpq631AeAA7zQh0XDSB7o4nJBvQ6o6BuvEpQeTzEQxEp CxFaEX+UB28W8oUB4EPsOcYuKIoUJTF+tFpQFLypNjVPhijZtgn0WMERJ6qZxWu+vlPsB9f+963w Aztl4J5ftXa3wdkbDPXt52C76iEAd84rC6ylhObQE09sOnhPj7FD7ehdahT3q9+bWSjgDX/1SdEX 68vuiQNg6YBVgRNe0DdHmdt5xnsuzikzQm91je4Nq8LhL8OfMgcHKkgOE+HcHFgiHdDC9L/YJdZt USOxUsK8bqfxwFCIGtZlZfJ+ON6T9inc5hreVDpkuoNe2Kh4c1sOcAQYfo5FBq+ywbbq0e86j4AX DDuHJj8HHUu8gqFzkLBD8WjAvTb4SZv2LZQ4mRSfxeCB0/zCAH/6hRQwy7FdHZ9Yxj5JjmZNqBpW T3qPtSFflIdSVulx/P7tuGa6qzu5ixNgiptJTrp8QEKAk33cAJrZR5j/D3zmbmRWcCyWkNjPkMlO FvUL9rYx9C2ePNmiajzyKhko794k1d6ShA0KPfKEhgdjfaMlO+c/7objnRWR6CF2ZdQXJWv7ezwo TyQzJSC5acOiSqc/LGl/NzWzP3svfuYmkPzBm7M/kxQmpjnpsgAD7AiAnbd+/UdLge8RUqzDr4/4 +2kgI/shxLcvGAMP5ZsvtKlRBL05rjU8v8KqTJsnO9CYJQQgqshRwKVRrzyC7A1PvR+ryud/XFO7 7b9uwdAHOAYWZ31z264tqKZK/35iHi+RIE4K9Gm3YxPKwE81wrqxjuQ+Qo/DXEOtkIOGi4WNlbLs mtDj5popgnskBPSS4NRPqtzGONfo5eR/eAn8xpyQO9zIjkelrww35SAsCB4WmfbMvnKEcwmMhwc9 /BGggl9KwoN8LhTFxwsN1CaY1Q20A8bP8L8bGHsgTOLFbZ4j+S9aaVK1gM5UhsTttpWrCq4GQCSb krDyDBeG7/OEsWPKmqb8U05pTetoxQo+3c5JfVv0XwEwTFZMZUyB/z4cFa9OXDQutWmAE8H2elSQ 1CVsW4Ky8xEDbdXYvAtnl90H76+5wCKbVivIZTarkVQNcCKajzkcBFVjbAEAjbTvyGXrLP/TOvaM m634EEHP3ro/IXKYWisveAd0skDHcqrHUZx3zncK+FvY7z2L+V+9qP6FdpX/9HTRg6yLfJaPapah ES8uEKEUecAspGa08w7xhC7bRvWt4QFs7uyv10WK4Y7MwtXgWelsXV9fZqYWS/MdaH8ICWGnuPNl bt02gAR8B+doieU7zmekqhkLI3P5l6yT9qwBrR5rnGXoMDl2Csttj1/jj/q6GwYOQKTb0DJgwS8N 5Lu1VUmgNu8SWuYvObNcVL+QlgbY71rNVdZ96YRpaw1f+3+8h5DOvFR4mL/pCecs8dAlc9/gRa2/ OQAXhJa8wiwj6fI0rzwaAHGPYZsPSofY1CtRmqJMvTs6ASnUnsoytTZOkKwJa+uCBJhybwK0YzTp GYYEPS/lI6VwhINSnc2RaqswE9gd0cmRJMJkKkyJZ8R8FaCbNC1byN0+mUOPX/UWdQCG1aAIMcat mgzuWFiUVG1HUTPohg9HOqT4rNjNdUVI+0ScsNplTFDg7GOkPf2tr2T0IzWYb5DlSznRZEQ2EArv F2NET8PXn0s6Kw/LaMoKUgVPdmwYnJO7jFXZWqUbW/4WKzPUYHvUA3akcr8ALAdjK1GT35nOmged sgkFLLspwE9Fq66EWyQzMG73plZ3LqbAj4aJi7JaIi7qGvl6K8S//1U6U0S6aRKcdkLJKb3IVigv IkqnExlhUYEZVFOdGEvF18YlIlp1DgV3OPYOdZd18j3fqAZpKFuA8pd1JBIJG9in6UA3j7zzLSAO D697icHAYV6AMPLn+hRRMeCNP0/yVQg4cRWN5/3eWdgoRE/W2eQn5ahCUEuVXYRXYwKzkmjsx8Tg f8nkGQQjP3Zu+BhFnYwP1NCfpgWS+r7kNGUc95jvIt06ro0aMe7Yh1D7ujgXzjUCC9FvUae9sxSD oge+faCDdrvnV6OCzsX30ehmZv2ODdzQ5qjVlGAbiYsg4wrBimLaJ0HfVrW7VgQOBezmUkmdyk6s 2R1GQw7QalzLWCQhtmyDpqk9oTYSN1l42Bari1Su6GlrehcVwwgVoc/cxL8OQkJznEdJ3cjUwDrN y/WE5PM0iV/g5SoX6OIK37i9U8HTQgMS1MQNIewAJDTe8eajZ1gRp+IyF3AP3GDkSqHgcod1rI0p hauk707ZWjEsvQBpU3vksRcq3k+PBuprJWlJQzLbTJrX1ECFlsyfmdn1eSiTnQLtH26LwRhWLOfS HmhtEvwia/RCycxbsF6ZKbJHA/0Uau1J89vzfT1iV7EJ5Nt9LRU//MIZ38yKfqlH+e+uYwSAHDzh dEm5y6AbuLGFXBGl0U1eT0zA8lRNfn3jtY4Qjc20XAc71axjyYmhr0eRsxxIxsnCc0S3q9ZPCTaG 2AHlTsXs4nH+EKQ5qCCKcgY9iCTT9WFDDQig+j3OVeSZpKJY/kQBgRDzxyqyecV1WJDfkyEtWPxU QuvRCJsoxP65JICeE6kkCYKaBFrJblBKxyRoJUpO9YgUnITPKv/fh2QMDvcYKGsfE7qtY26Hq0uw 6PcSZ2uBXhyeHMWpXYbma72sCGinrUysvsW5g6RIOh0ZRh4em41F4PKQok8GH23o9xIlSFDBimk9 u1cGMjuT0zEohu9IC0ITwPAoKhJKWeV9pCbLFHARXafE5Lz3gau4iOJxIxrQbczoIN5slbhfAvMP pDhlFwupmsOwk/jwbfz49HEaAiXMx8p7BvXqSA7ih588hF9YlRt5fGmL7GnM6rk43LuY6BNl7yx7 WsF9030tGoHrSk7JtKbTDt6K8X/kvRn26bbwR+d2Q30YJ+2ZR4/JdqIpS4YdN2aiQUAOpmNSPyIx dWQrNBtbMLmp3yuIq33lDOduuC8Vvw1j5X5g4YuCMzh7aC8n/TTdtQyK2dyimbXJ1NfyiY1tZlEw 3cCd1r+GBHa9NjDRoid2X7rlhXM76R7Vpw2sjfywnJsvBce5PtvcL2m6Mc93mPzbIOm1FpfHGxkp 8Yfnih8671YrUgqEhheKMp1WlwXyZRWJwrMW36AKRoN3KCGD/BgYVRtFbguwPzJ+beFP36u8ffYB ltkfihfR8tHQavQq1Umo8xRSfD/bs3nTrTm1pnQTQxioiUY9jD5QUTp1VFV9yZR/gYwZVTloWZLC 1vYCL1/KgrVH6tEfQHGH5XkXu3mjHZAiBA69y/eI1NNFECxUEgl7jhC9+G6ZLJkvFg0OOossc5+c qOPkmZYUpkv/f4eJPS6zgb/OsRmBRWVe9FuHAyi3/F3ACJFhEEC9+x5E182jgrBCD1sOUA+K3EU/ 50deyjbAv7uzBo0OAWPXpQKv9h78bVV4MUASM6CMJsIcLWVyduUOq450P/XLb84cg1/0DDuYMdlV hzJ36d1xSNL1CyA4ECuFt9VC9z6b0wqu/CN7ciBzhSMtXb7b+tJxCYnOfg7pB1cwj2lwwxEdV3wy mEczV0u/RgirJwvNiayYXjQRWnVUbGbtmsuB+AkKuXERZWX6FT3024L3blgvU/zCtOyADe+Nju3s YWdbjV0/ODRW0Q6y4dl7471K596aaiCgH4neG60ruut5vo3mVVcL7dX7ORYM+rQeO3ig3rkCPEwR xDdbhgGPR8+enuvAgT0Pezs0gjZwZLTt5xTnM4ni4ghR6JIABcHCReIoLQVjropGIyo5OIbvanqH URXgJMkohU+gDwxoodqoZpD0OaCw+dnn33rhiLYQV78kODhgX/43rKcSbAcaOAXioIra2rm1yVys iUUf5+agQz2shmdiXHZNUetXgJtQkexxcdyXkmJY7YXsqPEL+Z5t7bTaGsicfuB4YSjJ6RFFY7ak 7cI7HcC3aRQRZMA7IcHzjQxNpa5hJF1RNgA1UQV5Ym+0GFevc7D9auzRkOb4SCwZd1DoYSpPLUyw Y3oaHOkyZbSih9fkXM5P4wXLrLoT/p/TPcWJYwcUu3IAIbp2KbEnInO9vwJ7Tt9UsaMDgvK0PDKt mBJ8H13rOeBdzIvmPaOpEjBbyQ/tTzU7HOw6d0hkQVUCYo3P+LlddL3xcqog6q82Ynf7kvn2SPn5 KsZo1QhOx1+/spUWNezaCpF4zfjyQYztqjTibt3OuGyHXAcS2Y+R6XLP0imnqfXKgNO3pv66fowV iAXCx+TPt8ZzK7jZp2Bzaq1ZAAUdcBAzaRfp3ZylKYTdD0Ea/07fNbYKVpSKyQkBe9MPVAozFtuE 2BudyQbqUQfVsbS/TS6+AAD7vInQWfKktTF7g2LbxLtMa8IkFN+W0YGMBnqG9JWyC5Z1/Wj492UR s/f37gZ35/xm9Viy6tsg89dGcviK5E/PD9WEujlGA2BTvv2QT9YaMCGprrHtO6QnCDY10fJrT91u KgSTujYNB5zoYpjTTdD9FNnQHRKbSiNl6ecDqtLGUVOvSmN6kPKpjHCqREMq5vevH7ihj4QNop1U LAciIVfjzhSPlRbkSDhNbgrj7DXNMGIv4lvu+ufGDqu5qn7iBQpI+FdiFzj2MFg1E7Hb3UtsXqLw MjZEOEnzKvnbnikrjK+fjpVUvEI6fBSHrgPNCd5KzB+GLrRuHf+8wJKXPLZCV11C5jnBPFLQ9Xma PK1cJ8KrzNqFfzJD4Az6rhk4F70KP3jiyeL42WOxrmam2lCpqxoGyNjpV2m2tmS7VQGCpKRHLlX+ x61+LBzIPc2kIL9hmWFa65F6v1QXnPM4NiLgYSSjPgCCerJh2xShrU08hViop+HVF59itdOFSgo+ iBi2stPcuFZPCWu3xbl0L7PV/+XLdorR+o6kGy1Zr6lPsvhgQdxIrN4VHymx2r98nHCsNZZI6CzX OCrhTCUkJGlb8lIuvgMjHM86Vi7zu2Bas4ZWEfOYCYr3uso6L6kltmyAqWt99g9SG3tCuac7lChP pYoajG4LofdNnFmOfOC5RMTNlh1xpiQSAP8LrX9sxtxIAr+a3+QkIerJ/V9xjFhKlaiQH1fxIOeo Re0Ru78gNkM5dZK/D8kL7y3zPRxHHZDBFtVyXw0tFgHsP5JFwIwnDaAwLmyZEHo9ZoF9H7IdW13+ EZhME8tFDndudokiA9r4kvsyeuopV02kBVCkzfIUbAfOvY3Jj21oK+K3AEvM6N3PqKUOxFDSKtNn LGrvQh6w6PPIjV/2BcCsTQXbWhu3T8uzjDtQBNjRAGW4zPZsi0BJ40BIQJWlq/6nyD0cN9aeJrzR L6GISebva7r3FokR8SxfijdJ2dpwOSOGc9bRjvb5t8tAV/0OFGmQwWGKvTHImvjBAdxdP4rAB3OY rbro2Pzp2L6YkyDot0anejH5TMlfjxWsPj+BQ6+4P+1cc0YDEUe3A+tfjRUVoVTOqu4tD+C4nQit IV/COFU9vtMplr7lJBYvsOQ9ramh4ZHMER9hkUD9eXxYaWFCL6HU9VzCUl66KaqHyKKEfmkfgv4F vSeHrUdNA3JMmuK2tuFTDITrPy3SfCsF3frFSY7vKhovbFtg17B3gR/u8LbKFrJjB2XgV5lnxJSl K+jqG9D1yDTgqErT26JOU8qryu25VxnnibKVSN7CD6sGdIicx8ZxAnGrpa/0+AOFfE2lQ5+vyxD1 9i6WUJ4wBB8Fmk0/keW2P90j1vjiekUmB7m5388yluTKTwy19XTxQr9MqVu8g0C8l0QTxUV5IXY1 TWDwDqBskJ15pDWdRRXGgJTkKgZbE6K2g1EkfrCU7oYuQyQ64OXPeTi2yE01ZdGY0pJI3ncJxSd8 hdOo7OK3izkEK62W2UiouHPGcfCKgdrNbroQfwplJnxrlr3x08C669g2PGZVLGkZ+9KsXQhtb5x0 ktySexkFszduz8BhrMyWDV35NKmwrx/jjtqD+2VJQcBfrvpw0epokIkOnzgXQZHOnJzwupWyaxiq IlwAN7//jT63VV7cvruMc1NqfONrVQqu6nBODO7uTxJJOPTHcC8treHQrmBdL/9GhE3upJjvljKk U1WjW6OqqOQTWO0ZzyO1KWN9MkDR7WKVKXAJ+n2XnMyEnNybNAFDVxF/xPEqY1OhKbMYN8vQ6nUk u7jmiaTLfPVTaNkDTlEYLOxancmw/j/++4vGbGtOUamLeYrx8DcpyueaIFckz0XOagxbuhc96BZx T3AEz3N1KGCz5VdVjLiGkoqRBteRB+Ml6Uw2LqyPbpQpMGOSQeWyDl3d0qaLK/tnW2F12DDCiZc6 R8FZbb/F6vw8MFPTcdrsJR2j9xo5Mu59SMhiyPmTv+VBmPJHKxi1N6Cumlyr4G0DpdQ7SDfwofLh zf+//zPbjmu4BdmNaiNGwBTwhrgHvfkj9HXNSUZwchjQVvtlWqqwCCCPZPomXgyt8ZHNbeMXAfAS uZs4Nw8gdf+wX/JIobcsbzQ4nyII/ONkV8fR6c/z31emP8ORfIGHpG8violbCd/Kng9QkzVpED9e qtp6YE0MIDkC1UuNvFqPRGfwVi6PcNOSQhPg7Ug6LByiAYO/dnZYq24+HC+KcVl9bnH2uwBH6xrN xWJAyoUvOrQQgiv0Is7+s1gZ1r9yoYGU+shr71K+C4zbnNZX/7/slnm6e21jkahzavt2HHd/IPat fOD+HlHFf1JXdEt52vUzht/nJ8ZzKd1meKVAeiwdbBivQvf1VfkvQZv/g5JbbwukBoQI3tJUDSVZ q2NP6dhj6vPRKMC/BBLYmH3ojIm5mw5GGgNXMrWgAxMrH9ZuZDTZrlKDtidk1ECGW1cK0dfDTY81 mLjvSYpipHZUewxPXn0HUb9USPWvy9jXF5SY4gcmsfYH/KBnvVkVdkCJoN6+1UgCykjpaEy2pb8w YBQDuv41UhjVBkbQvefnj3Ax53bEn9FbXpVvBYT8XPjml+foXwdcNmKfuYGNtX2KRJdbeoMAR4Hv uxnoJ2z97kxvAX81Xu/wzzLs+b2gmFTTJ8drTlOZ3iL2S2wdaM5x+xfemDAxqgdTGBwicL/fhZTD HIbyPLEoxQKj7x3EWpMbGcsallVGvc5DPxluRuchzfmcLIkwCflOwSEJkFNKwzqFcs0t1/2IyyWL xqNE++qn4spcaLWu/UKPEqA9KSQ671lcMxc1X1mf7VH5c2O+EkO974VUXe1CNCBiBnGRNJtvWbNw kHzsGKLXMz7tLWwZCJqw3lwssTSetWhSJILrsJDwRW/+Bby5MU0AfMLbCPH25pUT9uM7OLtwZbTS 9QRki+/9lsflUS46i1v/MGSdpggkdR5qcBI5d76H1xARe6hw3ghTRMK4DPy1Cdt3N3x3eCbcNZdY YWRCAQetSlJrmQnzM1Qb9IS2rf7BcX9Kj8z8UBRz8MphT6fFH+9/yuUvU10JXNTm7itRDZF2rOFb ZB8SQcbcrrxQXYCT26bcWp3HjHhaKxqfEqqc8O/H/JxDtvgJmZTF+lnfMnwpHSBKiN6WVJzeflza OqTv+EqJ4ZCbz2hc0dW3mgn7sjmLS74yID9uA+LqT81Rl0RLER//EAacmtD1GhpK1vx1Elg1ASz9 m/qIysfU5nzhrTnDV5xaDMfjIXB/5orwIAQk1A+U0u7H603DSALOoBJG5kfp6XmYntoO4DmfrAPu gHTvNR4pEivDCQCcVYJ8lagHy8WPc2R9xPPaPAjNhmFB4OLAXFScDRBpXSAK1+uCfhKFdCzZJBpO hkx9JsjnR3laMbgzV7Y4tgi1V/oFEvkeohhAB0BtJwnobwfEQ3G5kMYTnqqs6AzN7iI4jK8FMACE eIwF37vtUJceKJviClKRn3F8I8Y4iqn8OJv4t2ctZ6fWb13q6PfqOBzyJ6kdq4GHvEHrt6TPo4QR IqZEXu92HA94OnLAG3+KU9RuUBXf0OSBTEic3q9W9IukDGSb0aDG06smHMLF1tIc33zVEYbLQ0xN EtaV8PjlAJfV4yU9IOrqykz7VY+GD+FlNRucaujLLnXfVpNxrptzKnIzjV1jfmus6mlWhqjHjRxo mXyEJyFGODvFBFPI9Mcch5tYp39RxFQRSd8NnIdEXAv0eKsAjwort8k2EacXXvnwrZ7J8ugZvOKM 07X/wat+RtUIe22jaspP9v15OZQtsyJmPQDVNU6BlcwEsFTOKcOp8Pt+KxjQgheokaEsVQtKBL+y zfuE/fRo6TWaajye3cevm+ktCS6RZexfvphcPISdQQfCisHgJC+XoWeepoyMxAUtuNfT6PaBwNJS LNGZYhwYJv+MlW0/Awo39Wimc4pCI7Km2HxaWxK+dQPuEyDnurW1aZf8R/eeTOo7R5PAcDoVEvU+ 0AGBKpzM2ugC6GAax6IT20hdT2iikUuufHxhD0tQ1A/lV6+BDJIXoHmPMJXKc5ryL/38VQ2J9qqK RqxXGTSRPJQVvBfkfNULVabxZmm2wDDl51JEW5zR6PY+tf150icZn+kIRppFBvZXYChuloedAD4i 04uv2CmXl0jzye+6iyut2g109NTr9soAzIvUIe6aIvsUKWJNukMlJPFUdIfMem5Vn+KkQ5TpLL9H RBfrjGAC72lukT0v19MPZYCwwcADD8G2eVWNNEpkqwQq3Kp8kSP+tlyBK7inSlhZeCJAQpGFy6OW Xel8zCN4t929N9MRliPmCXXKKMTVC4+iPwZb2PQbDD3A1/vGkXj1zcBNRxfldq1+AE9HkUrRIYYi Q1bUtEllM05XQXM9DEXWQbcop8YYXV9zP1EnnhOouvajCRCTnBckRdc8TehQco7k11znvgllCQ4R wSZDTg2zqr+nGPPj1/dQrs7QVDTEt8urrXjC++xoQ0P4ou9VYQUI40adlIkOePsayR9YgBfNp4J6 WVBe3VzWCGScE5bxV4qR+qVypKB6XupYF0c/KVkpdUvnIOxgtHeM5u7NwklZDHeqrrSwvrsJOgME 7B1IgG/cd2Ocge6ALQeD1zwrltTdCRDKdEFKFtDaQrJf2NmmOjY+1F9HM+X5YAygVlmVGdqnjHVX kn5BQqHTX+yVp4c/Z4oVRP4Wk3sIbCeofOiXPdzB+7iCSIXVRj1woqn/F4n0M2wuG3b52T8c5b5N txpiSSRC5Dliw43fKsCLykoWH6UE7jr6FpKY1JnFvbTPo19fFkhoHwTNt0eyPwjcE36WDvZrr69Z bU27GWxgwR317Gqjffdb6mnabgMFZ1iAfD+65/v/2nymDTYjDj+j6LpO9wEIFC8NK+PuUWt8zE8M U0KuBIBttii0SjyIu0dQgldGXxjajSceDB6b12/WVy6oFCLk3utwKqGj7gkYcSzXNXmokRKGeMie KBjyukzJH1Xtc0gMq6ZflP8SkoP5JI06tQQneGVnudywM3Onrrk+J3aE9ADKNvCu+t2rhGIDaVeW RfNmGvDSiQgtqgEcwCd3rSjza6uOjM0aw+xOFVZgFpXHEsxlI3aJZjkGK7Bj7QoHiaImgqVaduQn /gwEGCUxFxXyOAJ6l7IX9j3cvSbpuNJJ19chM4hTWSPbyZAVaGi1+gOBaH6xYCTqnm08Qjjgjhjp Oj7cgLFTeYBojlTltlvOOD62UVxcMmeq8RSl6Hbi7mDol+S/52+3vi9vnk9QA3U1bETZDYJEC0YQ /bH/Ftifjihp+DWZQmYiyQ6XqYP1NSgiQaYHnbEe66GIA2hDg1fsf01GWtyBAyI5RRUbQhI8IYWm kS4pdQMPu/wEydl4OcivpvVrRyGdxN8CoHtX7y9dUd9pCO9ZVn12Xw8TMdlaZfGHdvr0Rb9VNmlG 1HcFtqPxROMjcvY8JnzXSs8SOiziHoYN7lJZDQGOGurls1iBhGQkJ3030EjxpgWS9rxXwTLZrM1t 8s5UjlG3v6KlxR45uOXivJmKLXDLFqWHdIiOIP4kk3TXREoS3tv7VwFQlWlcPWoQjFtvv4CNRsQg Vceb7lSnqxSSSKkiM5hBbcnbIWJotQcUxhoQAvChcmV0Z+WmqHZD/fnjDsSR4VkfG9wGWFUe0z9P 4RzHj0WKtynuocich4HDgh1Kn/2sTB63K3Ebbzyw6guAey1BxUxQTyngnzILNN3tXpUGe21XLtsH vFdJcvu4aK9FVvASKdwvflX8vjRMamYOF9MSGNFmRi7Pjzr40y7kIm2h3sUuXQSz77uM0fBSt0Dn yzRRnznd9xaUopCcQGMZtzFL50xBFjzCmedZGB50QgBNeMVylT9P/F7WClyo/yMpDMtTMj5+24u/ z7qR3lcGOu6kezcZLxVa85aDD2cbvM99q8tMlNUF8LN6HlnMA5RfmIC2D5EFyHuqluJYxLf2pqRq WU0nHpvhX8kmQxZtKyZ93XDTGZn4zm5YR/Fw2/WWReTGztFB9CrEOTAJE2wYURdZeiGlEBtg4gLZ ouyH5hIlPItTtcIlRCCMlB862R2Rjpk0AsZQt2UWUbdJypXyCfFQoiMbEg3FaWVnY0JUHtHbmmP6 dcGvxVLlcWf8GPRO7PDxJKnP4z4ygcJrWJaEJEBs0Hajrs6bRZgcWeJQm+PYMwl0Ckkw7/U4XOx7 rTGRFZlUTDH7FTvdC7KcU6nQCOXc3L/pCJLVJtMMXK0aFz+/SPbvCu+PY4xf2DlcpjUeM+KsF5tU s3at+s992Q7Z2QBzGMKTh4ao1Q/ge2XwrET4rqDDVKa8pClFLsJn+Lw7a13BcYQcWaL9xZo7ArWt 2GQ/pxbStxtV/U72Q7uAfr4nRP/oJN3xkXIXDRAmVtuGCoH4Ses0RTsnf0KQOsANyosdvL74vslt ghgdFuIaSHwCRS6s1lSKGjn3JD1yviUrxc2/j78aO8hh2Hm21ekYB6ljw//6QtYgXPb4qmdR/czf zfGfoZi0ZY27mj2aF+BjcFplH5P2kG5HQoRhupqr0UVbVqcJFVagzn1P5QZRlLG/UTuJhG68eWFy g1iYEDZyIOYG1kDbMUc7Pdru5gMBIgDaB7KysmjrVnHZG2kPGE2FrwIMClAvEYBjBqLaKUpevUBY XDYlczG/PSReaYYGFf3k0O7oFiGxLTzbXz+c1masYxpi+YI0B9js+5zKFS3uyb/Ar6JIm+FvxnrD vOMuBOx9932UmUhgtZfFwAM76GWhls/WgVxLixbjpuEW6paLHf3E3juTghD6BxguVbjXSca61rqX SbycZ+CajX+vsp7TV/xxPnzfeLsarePOqt7aGtykz+1/+VhZKzqd4gPFeFn0ZcHpIKTDpZygGn75 7PVANNC3fF6WJQEex39uQUSVuNly/Z2PgvPUqYq9rbJ8wGHJ8O6YJxznMIVra235YDijB3oKMLgQ QAFGmiK7PzSjVnk/YHXU7hm6HIi33wnf5tHrppA1j4M0fZQDwUAG6DfkxvAfaxfyNFgi7twTzcv8 XJGuY7asasemusHFVe3ePact5q0ASyLmzuPUcdMXIUFJ5ePE7KrcVa0xe2lkU2XQQwnt9w6gyGo+ f9rc1VlMJCWJH2BMPq66CZTtq1X2jymarFgt7+5AXEDZU04CxAYN1+wWSh70w4jMwtLea/iKfFtn bA0Ru+SYN+i0B46SbNZTomqRAHZSXOJV1cs16Pf3sMVFC1yCBn7L56IkEeLr18t6MsbY7BgdM225 e6OTD3JmkalYmjPSwPiE/m3lkJUEBEbuGhtZoREEP2RWZ/HBS4UP/S9+dPM7GzZUZ9XqrLjKvFgS S9sXfr5vyVZn4SML0TaGcrrkWkFug3ABvQXdSo8Pu0TOgazdCfwP9NSQ/E1bTMxmEYFzOQqM7Mgy tED6PLApD9aCTfMsz9UHnb9VawHBpIFIzC6b+2X61TKYSWdYjQyMGGkp+5m8YRO/K2BJ0FMgfOfs WwaPB169+asqq9d6xnUm4hD/yONGHLoqEMj1vy8RRAU5zBItXFpFjd/yoBnokeh+4h50Du/OJdA8 gUuHIVLrkPdBw1C3e6jlFVP4pUbGKI+8AI6wXClUGwFoFQ4YojXH12TDigL1kbHOvBbU2d5Xg7yB IBdk9Dcj/Ca07i1cFYo5JiZlbakRJ9TeSDToSxnoUm2dIusG9wC3iIMn0r2zf7wEVAuKye+b/qam DZbTb3zuX5SqH2aHnYUTUkvzO/9xZi740sMkEB9KzBv70FeQYe9zfPd5OItIP52RoO6fUIDr475g D6eNaOJlbe2u2kH2eCLaxCDk+kIYwB4ish1zklI8UIYbxSwbOfJnByOksaMJsF2XsHclY9gRjjuG bUSjC/1r0v4NWxIs/NnD8yAlIVNzOjYOwf38pcwZ0M4UAxJB8fnA3qxwsHeIx/cLzegDeXaFC/8K HfBtydq1lYuXn1q6lVqCcHtIpK/CGqP8AN9ByU+QmlRcWUY1eVinHYGVqEnyuPMdCI7z8mINDn2y NW0oFlb8zFCRfhGBBTUn3lQeRSk5GFgqDZ315MRLnARWRCgz+s6ud/GFuQUad9A/0tjVdpB7ooJq 7wJIuxx/hY3vMQl2efLM+3eJEUfXnV2FtAqomB4c09hmV/IqrERl1hUwCVGa2fRzMWrTz1Qsjd2Q Zi0UuxePVdtFZ0aRAziZgRE7QokdzWMtN8IMMc5BNt1HXEgtxWUi3mDeMhiekq7PdGBM95PY/L2k AMrH6HLO4Svo3wgMAdEsnUVqjV6DEoyFSyjdh4hRFoTEJbA3bduXykWbRQywGoRtxhW/i+ER6+WK L8ZLvk+WCXiI12N1O7fTCWOk4aEbywhKZ6j9RIf/MF1qVXUoUYNZiZeOKhrj7gipn5faqzIkIm8t qBiScHH6FgTFExFozkpgjFXfoy4A/0cU36SguMAxnzRP/U8k+ndUc0x4/p4MvtbiE63wCvMrUFeu AohthaetmpPg0pO5Qs3CNMmD2qNL+lNNkNlQyp9hWWOd8tAuLFZxVqNXj3KUBcwUvNBjPNAneKzK t+ZcsdBqAV9qkQjEaDCNZVCQkQ/IkbDnuvqJRsRzuZYLpcLdUVriXVgOjzuUzON2kXsg10MZANpR kvfOuW5RomuTokoL7bTfHz3kAuZ0EOMokID3eLupe7GA8WDMqr3Ew7k1PQYcka/ZPcSjpo0wrMP2 oEha6SzrnSwbA/yChTI5QyHJmRidFL5wkB+7VvZdQ3OtnJyCoapM+vjOMwYAmxAp1QvYi6VgvQZC e8JV09l59iFGh8CYKB96MCrIP7eCwpEj+vqQRGp/IoA6q6RpPfBg03bhPAAXjpNzzsAQAMD5qnhS kTkq9y3gqtHEZa6mZEyLiI6ZOZxNePDk2GPidBmpB0BjctubZVGJQ9aB2jh4Ni+tVzBqjgzkglZ6 SWJC7xCyC+/XWAbt44csP5YgmyJjWJYIV7tx8ndQGjg2YdxVR1oDNuNRJZ/QSGSwHuIuq00HPVnq wojotTG2v7ToEJ2MeUifWrxFyt9B6GswfXaU7TXRgoDISZj4HY0ImjDyCC0qnkgedhER5Mi7wYy9 /02QE+nGtbpRZ+BH/Xhgc/8r1iXrMwi3fTFDn5w+QX9eag3Owd/r9AhUFdHtbN5ytQ+1xTb2Xymd 2tQsVSkLY8CjraiJVFhpCmf7ggw7XGi7qIj8CvgxtKn7KE9Ppm+SJRtilSxqdKWjCoCca3yyAzHh XAFauDZYPNr1NwKWbZw7fAUIdAzHSCP824CS7fPHSgmZTgJ91BOjnGNUHcdBl+CnTaXlh46LF4ik keAr6s5aH7dWrHmlcGfD4yRb1u3d5o6BTFmqf8cLPAXxaPvQnIZQSuT+oRAnvqqTx3W5FgpF3T4Z ufDRURLqn5/rKrXFOls07gZSTI6MUDvmSiTENeBGtgZl1saWnjiangW+Kv2Y5gQ2ZUSQsIVDv7ty SE1Ju6R7DSXzzPhLChLKvtsvS85f/ujWRJZgbGV95YUZ9II13gZfv+gqfTiFR9OoWnP08vCDH8Ad cMXR0A644Qz+Lq+LAVwvLI6hWf/5W7tGC7P6k/6m/75wroZZWsF5yVwn+u9Vvr9ycHguyUDFyDYO tNKLJZxeLmn8Ihok9tr7zCdZM5qPaxf/Q9vkyJB7ATU7YaZFpj7laVNtS2rczb+WOUfhjgTA5fzS ylzbLeE/b5x+763MjfZ1YC25v+ncK2oFeLxQiJHcbgnblNIGfjDP7/NgqheXJLN/I67/IPT0BpoG mMLonkApOL2mZPq0278qh1xEr87wIbo1SvTbg3P8ZbiZ95nBNA5b/JxYc/yaenHgGQlULp+JEpha S5xj3R4BkkHhQa1nmV5B8Lrq9V7KOopafg2BUMOSlAoMsG4OM0py+xuMPB6RAf2gMreEvS70704r ewt9pKFdRcYO2xUuUio5qa6tmGIG/xvJ1C/Wyle0612Xjd4AMWzTE9gsr5CvfSHLI2Flv471rBU+ YWsBq2kvU1xPBBfh5BdoDpD2VAdfsaGOdVvw2lBpXTlF7Cjuxfy0LGCCWb5TIV+0NEhDAvVbqyJD DVYjbObqi+en0He5uH9DdNnFyzpwQmSEFcIg7OJHGDnhfojK0lfXN8OQDPueS2c2hZ0onf33XUhR 8KYKSvszG/+JMaj+2TOEaQvo3cSq4e/hcfwqtsB6JyDwwMw2jIsSXcPNC9NgVni6dK7Xf9b/fO1b 60qgoytx0Lt2E9rs8qPymdO6dItnWrjjLs3bPzdCGy4JFI+fJibVFX4TxlfksLzciSiGch6swq1t sBcVSNAOVZRuyxMEsB/g0FPN70jqC13VlriajgSmVJOJ1cgNgX/umKJa4f2ajI384n6rTn60JfXC KdzPRY32GoROjNKxdzk9IutDGdzkTlzZtcMvuGmhJ+lgNhZtjKOS5PsjZSHdCvJN+/KTWs0Mv+6T Wim/MXsmzH11xTvhCI0JuAmhUGomxi3jVFzVGRhZYiLTmLyGtoa5Gd5SszgUyM7S57X3Zi2yOZrj f8wRFXQOemzgquaeHnYWyj1bKX5iI1USEgpk0xz706YHiTQcLsDOxzqyRDN6y9jT+VTvIHi4pGkC fb6qtpzmhWAT4NA74HwsNn9gyuxRQuT73Stc7awpuRMqDZcipViknGBHXtSCXtYU7uMV5lVHpjdR G+hUhvRIfKMRNBOnptmCqCHU3OoxZo//gUAFqSi7OW/6cFZNx4t0cj19CZFDFeQp0LEbQBJyApER QRdf+RtB4RpYSCz+neHq6docZe1h1f2YnRpt8BTTGEsuYaimfF6AjHTk0boOpuxwS2upTgNprCuU +lFP55UvmnzlxjJuXjPiP1bvkrJdIBkjS3CvXHiEOyubQrHbmTg0m+3ZjYjKCCYoX9gvf1hREZWn kO68shoG6XwK9ynWV4N6KptHW9m84QorUBOjnkKJb2jsxmEBI19ouYwQ+X2qbraqo1LUhfQNEmP9 FdDZhQnrt1PjA7HCF+4g9OrE/vsGDnV9YG1GSLMfeHOOlGve5EB8fCuRKEKAQJgK0Rmna4KdLe5K SwsJJb5qArM47bev3sIBJapepk0CniTWLkn69ZTe1M/yW05gh30F/RDMVhmcE2+VtaecTCSc6pPa 9sqcBo7jCzhN8m4pPxO47S+pBcS0t857xEetXSuL9uMWWQya3bYKIM/YphhiIxxVpqnpb8my+nVF yLaJwMt2bFdiyZVARQy4hvnOun0P60Iw3NvxFTK2enq8iLWFB3OcRk3cRg3jwELBBZLFrgGEnSfs zLGq6KhxiqWIh52smMj8t74S6MqpcziLBd/rt/yH/VLnzdME1T7gn1eUIpZmidyXrws86UrvhAVl QHJDL2c9o7r1uT+Wr19AK3AExdEwKNRtdhROkkIGMjx5olwaube/P46ozAGR58bObBinn15UdyI7 XKfZj2uYq7h0rjUEVKThd6igjGipS8MV8yr3eeA0h8wnDfe1/0A8DUm5J1QMkksan6Nnp4Yc+B/8 zJoze6v/L5AzP7u5AhQbEH9b2FWJBPH7FJpA9+VmmkoW2w261415/3K9GYCmVBNXZw/nsjFWiGpx wzYx121j8Wnv+ZLKDodsHeewL+ld4kZwyfoovLxP2IMmT7kjJlEikiN7mSlxwMOD/3Zz1hoQWtiV cohEfMiQVz2X7N8voI1aWGISzqhE1Fl1HWeUu/SoUhELiTmPsVscYQGz0+W10i1mR2DvKkEypahs nOguLgRQ8eZB2lyDjxPECflH0YbrOkdW3wc84RUchl+EgotcyjmM/LZal/EbxRfWzlUSmcxPJJIP AbiwRCQWXB3ho2GNu7pVCgTgzPYZme8SLYaY3DDt2JpHQcsGrqYuLEhPTR4FWmzGJDELtVIscZb4 UNuN3QXFFC+7LaEyb2p/s4DtK9IqiFkctVBJ1H4x7I67eMaum/SzLKS67mHPzYAm8XE7wYB1EALI jgWvjEN9tanTpgMB+TF+naqH4SgEYl4iE1Z+uwlhpmjutB8BPGAsHZp7eyzuvPYGQ8A6Bl6z09PH vCOa6rmQ/hq9Dslh9jYeaHUjp87mQWuWSdSdB4GB7391gFuZe3ON1pPQC6fGVYcvwNSrD3JCSvbr G57jq6AVlPn4S1XxV/Kjgdyn+SYXK/ubN0FZ4GFB26YOcK4oB/fIpV0mq+olYfYKsk3HokOA4Xmb Fu3g+VABFJas5gwxFK28YrGAI7EyaywSVXtuLwrvytrzMWhY4jodRRG3HKEBo/6cGCkHy+gieIGY Nvr4FM+4DrKSSEVEe3MvIFFwgQG6LFE/1jq/wQug8O6hcOq4llbGFMlxbshlBWkcmwlcXYKYuSD5 X/F/a5UOnt+IsSjfdIErXkNyNqliiJgOL/hd06egwVNW39ilVz3E3lUAlZGnk5i/qUDFkHngL5il n0ZusBFJL/Y3l/Ok705G03FnO40rp6I+27BHn90udfok6zKykfPltDbT+TQ09ZvJBtgUAf335qnh geAWq1wOkuObM95HBvNB+q78B5NXxcjGGfZ4kup6IyaIqXgzRC9q1ysKNbA+4OW5e8yEbj1UBRLy MBP1DP4XHL5t61S4qeBLd3Ua+W/IRI5Hyb7PQpwebJzqSYhDxMkair6T+SvpN355DsZ4IqqZvxnP Svk3hyQvdtEn4fbDktf5M/8SZPaFA1rhmNgk7K6XjiMcZOjsa53DOYsci+LBZa4gZSBzJ7Fe92Er D3/n29l55UsyxLjlXDdvOvfvRyZtu2KFP6CCRea/hdMq0KhAm8lyEkLm/WWUdr18T5xLZmtvfGnc HtJgSO5PbTeuSXJudf5ChSSyvHwK95jVcLf4HhLo6TMqW19q2Givph8ukp9Sh9kuhtCyJTiz4dt0 UHu2zGdWS+jQ+H+DcB/Am9p3+yU8VwRwS0DwqmFIKTRjBXRm5FfAezmc1RQ1vNdotqR8wNzsj55D F0UEqiiQY5IzaFk53/+mJtbpM+G5Hv71/6B3RCdrt7m5vz5idEzLCQCU8x62FY6ramQc87xQDa06 bWdUxjycRv+GUaZJTECx20xeh2Rqd7Nki5eisBGSJNltBF91bf0oXH/Zt71ZycUcmrdjG4RHhDsy uLUIbOcnGqOq5gq5zNDiLuyg+YCWrixEwWPT3mXpBACfABiA53+ahDCwi318rWZUCPT7R6+dPXH4 v7w6iFCoiZ0R7XQ17bTQ9wsjMo1h8/P8n9CwJwoVsAc0DF7H2ne+tQAM71uHHmqiJytFDpCfb2Cl TqYmE96pPrwJ079tAdjt+6gdIMt46lU5/VGDvFTUKD9uP8605tIU0g/BxJOuYJmCY+RF9Da1nIXJ iSQU4VxtUJ/da6qo4LrY3N+1d8BiNDP3zgWY6Z/eaIml6HHQjlS25IxzWjAupRxfHhwSbS7OKazB RFslPXeMMSGBKHPZPY6AZ1IQW8l3kAoc3Zffuo8WOLxsnnuIvUk0HWY7sNJfKZZY5niPYyJPMIeY LGs99O4e5OcVvY9Zjln05RxnsL+1JKAX4hiiVKy3HJxelN5nJzyi16zjdzhZntG2Vvd/GNPvMevh pYjZdY3Ujfxpf/hmT88h8Jb2UpTzdB9dv0fljvmZyAj9YDQXjTQoR3LqWsH7YFpbKt+vnEqzcMA6 KbedTbOPThzjIWHiYkzJY6RviE6AQ6qWm3Qwfxigf1yG+7SE9Bl8RQ2bmiOrkZid0JlOpfDVMvhr ub2+44Bo1obIfx4ZuU9isgzqSU8AYltcYjBck46HcgRrXEF1G04/Go8HboEkdRa5enx0P40I3fdW 6a/3foLt5enE6ac06FSH0RbfQTEVXCwNbaSDzNOZydMabEBOnovr03LbDKbxNoHYwH+q0qAzuxY7 zw2YqKZmoG8C35Lxebkgo1IyHZcZSunZyw66wfFQD9+qjyckcG4JOU5Aj5PkousCFvPtsyb+GSwo PJRG6Ph9nbUijNKbPp6eUh1Q3c30uv+ixqQa6W/f5XrN8NouPl/sblDEpnG7Gze2KHxJg3G6/AP8 rGUAyJRFbN0RhCezqNn5LV7ifNtdTR9LajYMfdgDTVL2P86Z4s+AI/FE8zjTBlMzsiGlQ2dC7gok MDbnyUedQIU2y6jWUegSTXmKAAuZWIzjkSggrOebPqpNPRBu7cdiPWno5GsxlhBz6NbrXu8P1+J7 GqvEBE89FJWvVZoB/CtwC/nEPeMBFT6/LPW5ZvsDxuoLiZZ0XMvAs18bFX9ECZl85+z4U+dm8WTb wO5tpJsco3FyRzoCtZttpn7fpkM04+loEOsiCuuE99vl3Bhcomd+wo5QDwwrHSLsiQRIBXW6EXDX w/ASA//i+YJ/3ADsdVQK/oRQUc/bxi39qCebHGtZ+3jaUr6v12HDS5KsQcM6Y73xge+DBrtYwvme ov730Firwh3YXV8xwXpOOnR4VKBhJhW2TX3/h22ZkiZBAosoS5czq0fUv9fzruqlpw/fZPLJLdfy ANQ1j/6ovrBAjXIE9KohER5KLWXVUAelbSL1IV60Dp/36ZAAtOd8WFiK2QGi02BN7Bua2+L65D7e PFbTGN93721IhLg3PIJpVeAMSuMaugeIJ6ZYE2Y7GUyx/AIkSr+kAw3dWlZODlsdkEjeGm2AKJc8 F1BpcUwzilDeD8j2BNq1jytr/DD+DOJkCsJT7TzU4KgGhi4LfW3v9yHDxtmhkVzG9xUAA4tMq61O m5uZs9fuyxEr3iYw9g1XuGo+7Z/Mdl180pAezAxJLcMIbLKrl1rN215k0ZAoIxnkyu//R7gTjjj1 igl19zicLe3yOr9aTrRmhyTMqFFiTIKCUrtckqjW1N6jH74pY191Mqw9RJuvbEJXvImUyos4SE6v 3i2/OSoYtlNMocfYg1r2nE6rDySEUIt9Nu6bVYZeWjywQYUa0kp5Y9iA7jEy5Mz6pYNqMwYwk6hX DIrUUmZTXCAfXemRs+9nrgCM3Wo6Ho3QHaXef1bNTpoKusIxZVbRzlBaNTJpnLqyH1HxooFE2CiT 3h09l0XNivaJwWGWJTIvTggQ/7IDcqKgavtGfKwNXt/NkluYzCtw/NdugDgws6II2K/xhxKMa77Z +sIev/r90/+mdJWihZhSbusPj1eGO9pFzGsmaYKQ+UvVr9r2ddzgTk+eXodPO+qVMupkFlD2zbZe jS7pMAElPMYbcZKR/asWdFN5BCn7rO2XeO7F8DWyrlUn/8QLN1BtQR5bJesldVNJJETdoQjImkJK v17o2rch1qdquCuC6vNWQeB222v2QyxpXWC3KS4XsTF03apKc8ZJlRll49+v4M3n/ucOELPz8zhw ZJmHwWTaIv29RuYJ9dE63h/SUPy4ajw2wSaz1TlT1dFQiMgK4hyn29SwDaz3ULJ8k+DwRtKMSGK+ W9tJE153El/U9nKmsrughf/NRLJVmECrNh0uj7FMHobm9vByoZr16uWSyinpZYqIToz0n82TQT/i vdKZt0ET1C+Yywh6olFfKsTO3pys0zDlP11dM/MlQ8Tkn5Z3rNns/B7ZjKD18totkg+3FDroxHsh FpV2tZBFXd79OQrdA/jlRq74ErctChAwPXVaZMuKEqFFmQN8XrBDAUzr+DLpmhs8ks1ArD98KXGT p7NK+KRWH1/9f+DOnCoFII3rxK5+MI7gGXAxDSPAd618IpEp+6RlWgBCLWs8VPgHhw5wyJlb4fCi eJX7WcUV6b+P4zxCjnguo01vfvwDUUnD9Zfhyxirsz3CmvNUgLAJ9WIZnCtHfuasQw4TkM/h5y8D 8+YJa2KPT2jOzBQYSO17V85k4UcDbrsUT5wVpYAyNAmT/FTtlkHoDgS0VMm1nS2yhoFoir1/ewyL VmARHmy20vRXfn1nRTxoxrzU2+t+gSNoNalrBhC66vzYEXe2QSXJwWhNa9adTlW1VPwYSWRh6ILC BRaxLSzQ71PtxOpP6v61KLoRdwgwIEhaZ9cXWMLwF4rlxa5xhV+0qA32YGYEaBQitCmks7f71EvA FSHW23BWAVu5g7xaobte/IIGflKuHz+SfHksWxvH9hhbR9Cy8qGQnNzlf57anD+K7LEFslixUqCT UleHQML268pkziQwcCV6d38z2MKEtWn9xFuyyZasmr5yvYGwgQ2Nmvjr87G218q5qgce1FV5h64K wM1TaaqTF3D7nnV8QgoFsBhENTtWxKhOACVRB5WVlkShxIbs7xtVyfzOycvgKfzMOegMfcwQB17o H23veKuOfS8fOA7OBpc06XWqyDt2Z1fmtIjIdw57L8pUY4hq7P4Nfu3aPamE6NbZzE5DQse8Jyig a9QVmPPFADEQDi7j9OHAZ0AS+HMy51oC/eQlwTnBZxtXFLKv6rCuXMeOF6LvnWzhZm7FyLFD71Az i3IoY4nWph3YTKSOqEKM2HIw16Tm5c05yFUjuGSrWVaM1y4h7dqhc2bsIf9fHswXiM43CdKHwDE2 OGZWazdPjhfuEpVJxbaTy/mY9Cd48jvPO8FZEPVjKvmXTVeHi6g9sp2DRMETYIfLSd5iAvTuNGdW XIn6DiyFd1c3u+R9Le1/GIKeqWfpSWBoLQSzG05MaE5JRvUCSCd0uEyQPluoRPFfhjqgFwt6ln+Q cLBIbhMR99F+3GHdNOW6SimpNFBqmlubGWDnTyGG9DyJ6Li9mJnY5iwCDRjOzqVMRYX0/5flN+nQ Ht8RomyGjnMCHdsiELZ43cK3uFDQIcHcrzCwMqB2OxnQHyPeaTooT/nMcABBvuCoPJW6Pn+qopP0 tOpxEgZkFO+sytAGoowe9d//qfIdh6RQ2GZjmG1VD+Y04dvC6rICCiGGjFTO6iodSLREp1Uy+QtS uqyZp5EF04aQ7jHs/Dlg+fR91/BC6X0WCUTfyfX9pBfnJhtSieEzCVFGNmi2pbFfPeuS+FLuaUQZ 5zTo8yGpSfRe73Hm2+5W7buppYL1e/lUvnyIoCSdKfag3dQ0AyVdQqDMkNE4OtjfcIhLOnMEsmPi kGWNzB7S0ipLESWERCOFwatcP3tHRtgt+zfJgJY6rHk2RUrbNoFd24pVcyrgkJ2+lKmYbsz56mLp uGE6fuOVh5MHCHBnfjqA/4/zZS6XR/ftHpqpD2aln3KmGFxnlHs3CjSxDHSIc5XLD9AYw+AzVxlT AP/SVkfCzKvORG0zhcKyao5rjNY2ZWYdptXaua0Z4bw4lqW0y2auJQdPpYzqbAR8rrKYLgoueZmY vgIhhO9yfPLRQHv3pBMLCyXCuguxONoUlvjaGpWV2aLHnv/Sq3go328rOwM+aC4S4QKcuCxto2Tv Q3ROi3aQrbNHAZyeYbhlfVoys2sMDNG58uczLwa0sn/U6tQhoNB6TMj/cH3RRMZd+8iHao+tWRbu boj1lz7BU9nI1+c56mB2Rm5806Lm+J/upnIkvYTidMIBHEFz+WVkRr4+9Z5T5IBEq1Nht+6oMVJ4 03R0EjjRiCj2tjjasOnR7eojjG4mHswJzKrPgxO6gGWBuUKJi7DpygheX8GT8ywYPkQCU0hx3Ieg iSCxHDxNOY2E6ouWGaZ5q5m911igVNb97RutdZ00gJbd9RoUXlsM+1hk9XpuCPeczvaOj66yAMuH DMZOCPSER6WEVYnkvfz2xNpzQlV4eEguXc4+2CE5ZbVkSgZpJz0aMAlvJd4ocu3s2Af7phHdzF6m /xXZvWYbMV0FJyl+zovIFA/s5enCD4o3Yi43Mp9rxd0c0HluvzSDUpiHYHlZuBYxpr9ujfhJjQs8 5l1ZhjUB2Kk73RV0Q9DPUPot2kTkp7DamJkIlcJP0hTldm3/vACwMb83P1shR7iX9pvxLABrJu2f EKA232+b3F79TnhiQYT0Fvc2aXvGuHHWftE+c3PDpbL3naVUCmj7E5+pe+w4xpPO5yEoRDcMaVZg aY9LTAQKPfbjSnnLN38zsg9T9H2mHE78EjCrG8FfS5N6+C2Nh3XHMWPPtcuFxWt4Ats7Qh5RRsU6 YP2heYLm3tvEXkPV/LiCKBermHf4ipgblYgP6QyBlnu0NRm6HO3Aipr3D8/LFuqHFF24fIkLi0mX JUsCtFuZfg6/OnXnkaPdZJUkRsF7QSB5cHe3jdFIh+oL7509Rr47PUUIyQE/fhIN8q2JvbLmAE2v wvb7++k/xUGeiMDFSZyH36PHv9qmXyMThy1ClIOKxMZnJ9dYfjnvamjj7bMWfF3k8QrISi66S7Qn QuPyaj1pB3bXriHPEaGsCS1HneKA4lA7wYcb+gVOJ4BDorE+qnzBUnQ2U3XytLmA/+0JxgPrLD2B yKWEK0q4RowlyVDeKs1yJ523yHrDgVAn4+s8/ICpfmAPI1hIgi9Hgpxw/qrehhwDoonAJdFDgSSq a9ZuqjmnBf1oc6a6t5BmLIV3LN89JFrfbka/PdbpupkKqZBA6vSxiO6UALX2qW1MLLtzRGPA/2GT EwMdYcKzfiT8Pt9JQYgiA5u6e3ifX7Tyx30ZQ4Ol5Lalh4wsyDyaAipWkKtkTCDQo9fU1CzTtWUI LkidvXd2Pa6BAV50aIZwPX1nWtjsJySLbDowkNfeMqRPwCxYUVGKkKBPJ5DOdY7+hZH+6KCtdzGl oKpIxNJFmHWxsp9tWnzmFpflh0SHShMeaHugCTxxZaacn6r2Yp05MvbCiCweY8ZZU3hI6oaetzU+ Qe8TXCSHft4FRIqsigO/MwOKgrJQm6sGSScLj7Bk7liG89NPWmnmwGQj5Y6JH4PxrzKY3X4MJsf3 QlbGbaLCxv5oh+3jk4I613NXzZoNcY/dLgCka3yOZdKDW94NKcMH2uLCgFYwTsF3ZSTds2NtNRD3 VLaWXRS3+92wcsKjOuA4dETKC/Usriaj9Cdw74dsMlnbLWcrCV1Iw1svMxKFJmDUiO6qUraEOCem 8OcO4CaiyThWPWdr+2OBJnz3G9MymslKlu3sP5xGDizeFsccNq3TrLWvZYvYSx/ijbr0tiEAkLmB 8U/hDFo3vd5FlbZ+EiBiwzH+PHkSZH4nDT7IoejiQvxf3RVhNzPp8lbK/WsiKaNV/7Oq+GFYHUxe k1yLoE7MowZM++jp4gQ4N9rly/lEqC4YN/zRgiiKHXNszPtMXOlMULX80JyY1iD4EdMljOwZvjjD u8h9zcXJ9pZ4DkIO2Mf8nm+WNP54ASR6Yfg4w6UxwpR8Hh1PVUSmWIjBJpshhsN6bU8scgrb240d 6oZ1MwgVQuT/l+OQaq5YWTy4lBfJvDJ1g2G7FEvtetrLVPzMDout41g6iBVxHfprcC8A9UYHCKkW cgjjs13YKGogz5fzXJBDaALZx3RK8d90y02NpT5fOYapFdp5XewyPsZlDVdnp0AhlZpQCpPY9wHQ GdGG75+PGACtuGEwHNpgVbxhIM7XJEGLecn+XTHrIDilEQs2tdMwrD0dpTFVzzDCuq+0CBpJoemx lSSrBr9xbIETWdarpK1Lsh8XrNUMbcnVZINAMm06alrHWg7Q+8ZgSxFMP/3rrc55s1Z2HB+Nt0Om KullN2l+S+0nPm4kApd8mrIL8wJTrsTI7/HD+4vOdoyK3Zp6evgdovDmQQn1N2mpjUPbwXGW52dh BQH9GtZVTO1ReXOY9q9DCDetB9J6it+4W1DTZVQzWchewR3QMShqrvySxViz74bWuNuss6ZsXPCG As+QIpMSOqV0YIncsoza7W4bS9GaJGN1VDBCP61axL8zprkFai1lv7rhElYI4f1NloHl20BlfNyF TT5vO/LB9wecpjizy5lz4iTqbyr3QM4qo5VYB+IqwvBY3ELOqzfuDvCuJteq/2VnqgaVm59Qzc7c 0bR+5pl8llj/3Uy/ocpyODHEiRL40LLhu7ZH0hUsAJAd0IFGHDgVgm8x8RAzLLwzbOYz4j1HfI3m 9ipA6eL83daIVU6dh5EqHlKA5NQMnn8harMfKjJ5P82AQ/hIIId4Gsz0c2NrbRURl+clH0e8rbC2 dhVHmj8dj+iZjOW60TOAcwoYBSqIFqsjUDPiQijlmDvr4Q/8Go12uTEObRGhsyKRb583Iqcs0E1d 7P5oyk3kI6DC6wAKF/AwUAHpfJdDU1aY4T5UNlNYVVjxAOwMomFxa+bi0Bo+HLQLi7xljTQb9fkc ONazSX2xVEsy7nbTHYqwGZQBCtQzSKI1Le5Djleq1HqV7+mP7jnG6JvZuvFKHffaKfbC7E8kO6hb siyFpBYBAZoSpWS/6HsVeFUkwWUQ00qkUFvdYZIgVTewIG6o6eEZPUNlYpgcfhuRoo9++1qKAEWF W+vWiTGppiCU3VkRIS4Pd4M8XH8bxtRoIkttpYmKCZcrYzAsWgvLPsap3eZl5hfGr0qAxfNITeEE 67WIaD3U++WpR0OeZYw0eNjsCDfuDq7hqvri8XXaWYx0468Vg5LpzkLL/j07KQc5UBLnNih7cBQO 1c898Y6vW7zy5APvKcP60ekKhp6OqD44kyHnwZQQ5H8YgmO3mOj/CQhpFsY9WACiKzNxPKUK7aNm urZ25Kj8LPd7h5krjeo3+ti65X4aP6yTxSNmT8layaNPizXxc62/TQHkZx9ok/szGX5ieg4GjGb4 Ea4FUsIoINQe3NAkxhbNpKALlALcPbxPrOPs3T6RBQT8RKgso/yZu8NP0krF09rFew+e6ehRFchW +csRWF/aOB/xCW3hKO6gYAQZlwzMCxcUBeQhY25/pRJfNkLe3+LU2L5MJjT4GMHnJpwTJbr7yMaw u6FVUPhpjOQA9eCo+2tPyz5n5FKlf2PdCskd26qwOaQ06QVCgiXAhD8+DP2QDFmoxDtfLBwVfbmM Gmfj/+s46+VtMI4b76BMysi3EZsx/EicBlQuitqMwvFzi3dxQlPa/QoQgv4g78z1KJf4Q/UBXyVg yibZmaMqD2QXQpm0xehssGM5I7X7VrD2ifG2bzFJvTjsBN+tjD5gdTHQdLIkmaiPeehtRImPAhla AtWqS86NX6UX2IIKxgzJTGfjV/9vmz5NN7W++wyb9mjpwevl336IRpOLRSJ5LMRT51nDjFu1oOgc rvPprJ1r1BypQddnHbWBffW3mj1lqM4ZBgzh9vy4ERi6HtlKgRbtlelSVMlCra7HTBcb69y9fUrW anlykH7F3eu2aOPuoAEBN/fqY/35FP7RtvezNOkk2r2uGqeIv5uXVABWbkpO8ZP6raCb79ZeP81O YpuvA07AIqo+o+o3zzu2uFm3g/zcblL7IjZk2N27soQtjgxzvDvS/gG04Vott/Dpzay42/ue+hGA OoHucb3OPbGGy1/0XLWeGzj5uZQYrd5aRjlxXwWXnpom83rBrpEa+lY2Y+TJth/zzO+xWbtTy+Ul 1zPR02WQIiT2W87q/gNJW3GagyOfCTRZ9aKJxfeaedpkmGaheoRs505COB4nBmuzX6RzNV0uSXJd 7/JEdkBEN9o0dBnGL8Nmezrl6A2uWqXAlTzSyK4maL2bFQCcoOUqzA/YiCUZ6XGtgdrRsFqIRmah GNuMM145i9ebQY6LZk9Zndu2E8gOEuJhxVFvASbMLA4cP7By3Yg0iNMcU1E35OZEaReDwZxW1pnP MsMChIGf3EwmiHYGYUoVLYhpt7ysmAoyKKa+MFDrwqGuSkTnGYQHrNxphsrvZMLyNbkj7t6LsBk7 uMKOsSSANI1+cGso7UPWjxGsHimIWPB8XvM2HtOq4BatBAXKjrJQu41HqQBmRoOWXT1oj/C/7NOt pVxtwI1ZO0SuFZ43HxX1kcDJPLZ4EqkWX28asMIprZ9HBarlX6Q1Uba7DCw3HvxmRS7f5OCIWH+3 ivozFr1qSqJoYONkKdumYS8xOYYg9Pe6d524rt4+dj6r0aWcAb31ATOwhO/ClR4HrRt42dfb/gPS AvSxks9BhqWfPflh4rigDb6lPxr/3191jD679rwNafSjwyhSAiiDJTfGf4yqZAdBOb2EuDP3wG3H BM8mgiYCabkPBNyVgjrGJ7tujS3vf9sMpiDJl9JMuOBMuje6MTw+VckL4iA4ks3usBnuc9pRb6zU aX31a2oQ10cH50KmMHvs+s01ouDxgkefK25lxeso8HFQJkvyrxImwvK/46+W/1pzMy/KwF0QH4Xx 8NN6eOaXKFeh8ex6a0Tw5piVPrgE5Oi6+GXhtfisEwpJjYtwsP2Bb/GdSBeufx1kRU1oIPB/Pu7R cDRZaWEAeXPpEwCRsmSemCq1skw4fTPTrOCOihqmKUCRR0zpyLNBB0qVhIo8tI+wOVb5mEITSoXt AWjS4OWGVrPcDubBBbeOBfFPuxritnB0Co/R69B1QihfW/2+Ld0+onQDG3pJyUbMXKpChuR9jLoG +fc08yY35g6l3eo5WEHaBO3RwpTxIkFzdNnn2NH84zo1KIRrs74LM8lKqqcC/YNu6XKmkvwJ4O/W x9Sobfu7stoR0fTDS6Ar8j0mD9FmtwxwYqk5FEGiCx1e0cilc1B2d7POjOBm1zYV1CJdQkVXSINA m2pBVE2QSBJhkRnlUnRdYK8SYtRx7yJwCZf1MvJBx/GhggCRtSfVyrVWoFfcgMRA+Sp0U8zNdP3B 5VFyuIYfGHrQeAeszXfWjJImibVb3LsH07Zb0gTZ4GUCLeiaPXdX+tWS26+rebrxC29/6WCJxhAL 1WuyzbZc0HXvqR2m7CMeQdvUvW6A9BHaBuzXta6WIm5pF5wqxQkfbicTaY0XYy8D4wR+yeF/1qoI fwsZU7GL0DEp2A8mSJyMGta9YREg91fQtdo00S+jjqPo7JujwcBPSPqcd6Mf7W+Hai2ufBfohP5a Uef1F6J8QZKtFDaL6GgfPDeRHjlN7ai9kl0oFMCOZLgHWFILmUuESog9hbI4zbp5e8y+wC4a7SpB X2Mq2R519Ebjq2och1Tle65H3G9t40jhr05bs/j9vS1uJMXFGVxEQFJoT5p4m4769cdHxgxjL+D4 H/SNo+kPTWF4bQX9H8Gil0dIkloZF3uRoSWyUZGwS7jTeqcIaU4MIrHAl+V5SXxeBUlAysXcgEmm VhBgr1Rx9beZpAY6CfBc6hdlB4WjdMUGNjBfHZ8NO6FrZ9qH52LbQoc1NEI6rdTik6qAFhMoDrzv eVl0uGV0CmR3n66O2G0dBQ5dKlZX+TYYggQHSpS0flEuGcECSQCUl8tKD/R1M9oalWh6yjXOEMJq 660m65ErM9Nq4ONh1lochtsw8+J4uw8iHhdfGzViJS+s3uODNPOHtH+EZIB/SdNlrUaih8DVU/BQ /kZVKDrILr16+DiihoXspPKpdMDRdq8RHfy5tS1z8svBJyQJfrcBTNrQ5U77aTdKTzeegTHxk2/d au5xoWjTdPeiY37qjUcVFnWog7QfphGwojuCYIbWT1S4rGFVyj9JCcsrHfTAmGNWzAwn6mCRNT+R 2qwpGwwpxMhsluSh0Vp/OAsILRH9A5l5qWFxqlWD2B+uW8ikD3OOIvslR3o3WaqbdUV/Knd+oVOI oGTgrCF4xabC3k54sMI0fTwklRJtOUR9CjLtUSD60qhv+yXW8S0W07BLL26jLk2YCtCFgIdHXx6z lMSnp5wI2F9JlKDOuyJ2OXapJwBc1oHw6CsHw6D7lKmHouDBTRTK5NZTbQQqVA9JDXmpyrKi/EF0 UU4N7hBD7tYH1Jtm7VTJjtPJtzVxq5acH1klkHbD7IkgZpwW9YTy7h6EIbd0NsRybG/psgFDfmBm Gw7X+f4fnElq4TjzptWkdnyLhL0wVgAUqwXGqPnzP0hn5DEwHYxyv2nQ6KPlxaIlsncHvrLQuhwA BjUZBk6Ez08gQ5UNn051rxk3w3Vthn0PazezDd9Sm7B1n+uVcB7vlIQ2kVjx5e+73ksMvd3pC7js i4aTR0scEXNZaB42Sr3RisWDsvK0QTP9PWE16zVYe5ZoDobIXRDpl6CKc8ogKl8psXY0JQymGmv3 q+1vFVkcGPswzbyFCisqkexJGKG3U+DI1ijYlxDcoBieQfuFxGOLZOA/McgLlYYGQnhJuwnMt/m1 9jSHekSct/ODR3a9+OktAor3zrV8Q1lIZ7rsC1fdQJzrLV/3j8AP9aDA74L0IvNCemkCpoz+Ph2Z mn5hdmrn9ytS0aJZWRgNhfXZtTQ88kl2SwRowVv5nbT4eWgfKkntSQltmEpMuFYTLMqDTAdKQVXv diAXh8v/jN8sM0YC5yyr1R6UsyOeoDiqeu1OPttYjgP3Ljrt2w84WeW6f///N/L/iBZPMna4IzM+ fACASCl9E2xkwnjqQaKszX+c9Uc0J+erhnF8IT4MBwQi9k8yQ+5gtht6ud/GDRFCdWy36+IplP1j zAhDx7hcDTNguAeyVeg0eu4Zpj8tDHRP2R4jrwmrBHlER4HToRbOG1Y3u7IRZ0jCK/2m/8G20EwK I4LlntlB2MWpw1pMS5dX46RniWAxpJuUOUClEGRCb3oPWGB4AxGD/aSVc6gQnAjo2MhQDFsOEsvs nMQAhOI4WTvjm+1DsaJMUnJW6F38nkfoZHAQrAuh4bxygaX+WBL0l06MlmQnEiX5eniFlLUjWA64 prVgpfCy1fyQS/mlaLOZij27VRsk3IClQSigoCJ4CmK1fnYX1//5I9qqpl8EmMvdskqgOuTbfxk7 urZHvveIB3HrqH7IKP1vJH5x6EUpzvW205vcidsP0pfUlNNHXka1hbuejvSPlBIAeUvxM9bjAKpY E9KOwXYG81Cf6oc2lUBpEL5wfqzqFwDW2Uc7w8uyKqbDQbBB6HGapxucFzOqARB+0uK6A10oVoZn /MYpK/Q5md87zktF9pvn58Rd3V/0ohaPWXBsgGfj44jpv2V8noa7veiruhxjPVwmEQsCldBvb3Av 5kpPbodJ/FHKAi3S/JairGTX8vq2QouRf8kiopxDEJ7BxZryRSuXmF/f1YjrtxaWqogAtuPacAiY oj7kBsc9N2bEjhQZTNhwfvO3bbzDg5xwuZBcH8wGWzXnC7azqMHHVCdWCvrBg0fVPnPoZY5a4TbI 2BoJqKm5QU2jFwVgmJcZMFrtIoRaIcVJjRB43v0gpj4ahfcXXpBd4MnJq5oFDhdulBpR3FvgQL0o adImZK7qoucL9TZ3Ht+0WtH26qdQ+Gh8XuACEqxMLxitBHZCCmyOKosEG6nxoiQQ21B4Cj9OEnvJ w23lv340ckWd/B9uLQML6XFpEeMQKXF0bflKM3bgufUavwde4Ee4vpnZEyaHuP4jLV7Z0vFwnqMm wnb8HMZMYaM8EZJ6nd15nq0FBzIlpV/sM3cG1QItIUoxfZaUQc0Ovwl/zgdnRiS1PdFKxDiX5k9Y 1brsnVbCNlrNeypwQw8xYOw3IqKtLBc57+8bEZFwz/9FWx6ja1UJsM5YTSDTBUN0dKDYikBFoepp UkzGhTHTpLhPn96PaztEU3vn1GlcYHryBrtd49YWHKYveToKeUA/wun0j3GJH4u3+U5KHy0c9Q8f iLqRN1nFc0DrgbvMnxzPgzqSKXFwF6sAwdMv/kxgLCf48cUcxDQV2QKLsJjxcFEfz8PziZP5Gj5+ EoMor1bEje39i/Uu8ZHH73ZCDSyzhRyc+6JsEPT7aGHDmG9thRcjEsHGzVSfzH4khbg2NZPvaWHS yy/KcQkWAIQk2fsux4fAKTvULMJg+ki69GoF5abDQYLvSlQehETk8jRwJ4zJ9oLuXfWm6QPFMlHa WEGf7i4IUloQxdbQ32Qdd5KTQsQd35AA0ZUJvuUKJ0E0kcMAGEeHeSuVOcKS0y6ljKEoDN/n0Gvv FmYVUroJZyKnhaFqzqmKCin7ctQtrg6n6/hdj0LV91+x6JBpHYZVlz9g2veWKTrfoenLhqMVYued a6uWjNuuS8QJHAb6PXrS9uGFljTfT1/er1Zo83vstsVa1PdCq+Mrmm/TVZM2I7XCpvpZFg3+uDpF Ns97qsNnT2WmsXeAzbh13a73uixLqzjg7iGfK/0r9C7xkrcvmdN1mrzB1T//Xa4pp9fgBPw0lM0/ xgnOmRM+3h6vQKtxKdosguO6gjtLmfSmLFGnJkW6vnj2hBaA0I3QZfp67Qth4+NTZHLUccSA98qo L7fFIGLG0p71EolftS2WE8Mm+NcKreZC6nY5RyWf6XRtSoEVrLrK1/nuq7mrmxxVr0ZZRJRfmVoD GTe/qu3XjNl7N7fsupBHXiCk8YINSzCGKDr/En3oRiFSkpKc6ZdwBg3vnaMrz5fb7E5pqCh3RtgG 17M1GOW1uAlnHFz8vh1IqhH/4mIJP8MA3rsw1kJMsDMSuoWD2EdMBezC/qu/QT5Yacvc0/SSSRHi OYBOuA46HncPWKkx3wLXEECWBzd5XGyahTMPa3h4ZO/ZgNyMDTmnQkdk2QJkdPF85zrEaQUOKLmT IxrCkcRU67miqkIL2EoTV8H2oEpyzMnRuvt7jAn2xwIx8LHVkMHSKad1XR46eh65shABgDVzgmOW r9d1bg8NbK/fnOnnIi/w7RWwuknJEHzcz+gLm+eyQuNlS8dbjCraNbPRZJqSQKd93GoX5ip9Mp/w d1ddFaXd3eRoajeVYok1q02A29wKk0oTgsdVSgT/emJ7oLy3IQLdjQNt2u6U3uBx1Ffu3R7k5wBl CY4aH6JP/Ldp9hAhTmvk9ku+ImkNvXLUsnXJkCR7pWO8SDMnfF9Ba9u8JwQ6QPILZ/JUr5w51kxO aB3lB/qm0cxYLRs8jajK4FHiyoeyrgQjEMlN02q7Fp8taWr5NDSLVSQWq/JswkcQkOV6H+ZmNpsJ 2OOV0fRQzgb50ez8s8nr7plOTC0gITZ0YFWNTZjKqQyc70van9DMe+Bfgne8dt4ZZW3pw2MCNSeg Brmx5ewDDU0XS3uFChBH9MJ6bGwNl1ZfDOWWjsS5C4ulNiYIKKB0taob4lkgy/ZkUfg3Oyu39yvZ zVWZ5DaLh7HTWiJgnoCTA/Ql++ScRIQqsGDdaoM5aQ4zc97/C+U2qUjQh+eM8A+b001ElFUEeBFe CNELo1tgqzCDr5FpGsPk8zL8Oc/g3BA1VIJB/UnUm89AkoZj770h47lNWZxBqq0efwzL9rCnunMg xwOJyAO3OryR+v7HOociv6lx6HqSIVgLzOB8wJpKeAcE17wtRt3roECmpo+0wD5FnxtFdGbBoQHW 7wA4nqKyVCQ4OcNBqazuQYv1/BWgfvmVoA+jZxwWtt++nn297UKV4GtQEu9FbA7/SUuN8FvWysEZ xRNTyj8rB3vIhxatxrvWC6RKxsb0mgTy9nbFNHYi9h+6Un8ZFPU5JpCxBnz6TrN9hrxr+yew/xk4 yCkgNa2xpwWeGDRG8biOFrpCl1mT5rvw/P1SSSDS4+ewvrecqe3vuAL0o5rMt0+lUE17/nzzWt+v ElCO1WQLK1OHC0qNk6Z0ED79KH8jtY+ur4nSGEdcGdwq39d1Z8V92EkweBZewxCUkKj1hKTzNiIy von5tn9fHuIjSyQKsYTg6tVxsovBRrpY/YlTcE90xIuFHEPopfCi5QL9BYxOWkv5akAAHoDhfzE2 38QGtB4VXoQ2XT6TJ/GAr+eHQ8l98+OdcIcIhpXChr58xdsdmaPAA7DyUWt4SOD5yguOuKr18PNY +YqPC2RPkQL5W6YqfBhp0gtCOYznvkyC9GLYZKbqNAdtUv1Vb0R9gjb0W5pGzRL1audDOEbjXB2c 0Ar4HIPTcRqvSk6JOgg80fRCl7bDMe8XpJZSNO5HU+Fovj0QZH58evaunbW/SKA+3Nt6AP+G+2H4 HcNEcl4dMxafDENhCPChQo5ZiVgvMuTJ/inWbdMJ8s4ZVzfsAjO9H+hZGTPHNh8NNYT7A4CZSNlL u17Eqwa3kz3Dw/vG17GltGQcdCbe/ejQvDQO+GRacuz+4Jk3VnQVdyjxrirI4NjmGTTIWmsK8714 79R04ed5ELlKJBzFaN7l0jxgKeQ1x3DA1In9r7nGNf+NFUXCSRocftSeSN7gBSqeiNhSGHbL3N5I Ivs9m8pELiUb4Jr3gLY7+5NG/cV0P76DrH/FVOw/FAHTKPQTMEBIB6aBTUHus/uXFFAcxp8JHHhl YHUbrO3kDbD7Fuxl3YMd21MekCAV/IRVJX6pNB/fe2t1W9lhAOsz+v4CpqzhNHU18BI+qMjI7Q18 Q4Oa7R/3Pu4g8QOTOO8uUeRlpS5H0umaRnJfBz/v3nZcR3Q8C88RRHN9BjGtTutF8cWZSmrGFdz4 sEXkp7cekmAxziTqftsev3c0Hb3V2S6HvZm+x82AjKsQ983JldwaF+DRsd8HkRsglfbSvubUmvpz 7rDe167hAGV01QSyfBx0TvDYP1XSwyo6yi/bOPi+ITItR9cQJjqbnopwKGc3i/g5xDMbUj92/eTU uBFZ0Xqg0VLntWyIqQL0zvv0bxJM7I9OAJE3aCxZfn7qwgvOLrn8TdCMglVArxQjAvrsmYBzzYaL hcb1ZEHYdBy2QnRWllfMBjumxqm3wzs9AQ8HYx2CelM3FpUoiZahq9l2llROTUX/wkslM8YPL6Nl 9QwVKIlwndL7r+q+mW+MmubaVrLA8U5ZwUzL1FVKRwCntaSL9nvnnc4hy2EroByk58g9uEKnZ4MB R67t0sd38y/Y8ysLXpgGemIDNblqjWqb4u4/OhXJgVKroZAF50ua2LrXu5FGyaabAF22yhMh3MIF 0LA29dmxFD6IW+rRscaga/IRtR+6L06us8CpDKE7k/j1LcEjrSJKxgqtWWu7SJImY8qGOFR5DAEm RGikreLXvCEjSFbw/YffEKGBkWwdcui1iQozus80wcmzqFEhSm0UqdzbgcQzKxsof5m+TBX1an7n 6UZLAn4z5q0sKZvHuwfKAThMnNNwvPnhApdbCIexupqDMC+w8HqGT8jEUhaatyM/hCh3cmEciNh4 kJpX0tJ6MpqqkvcwU22tqgopWVHgXeZ3iVvGjl3cYImdsrdP4VMxsffMM1EI6XF/vc1Vd7jy75hw S/+U99VJc5dcqoy8dTtKueRUEVjgmZB70UyDfXoN4fNA8safsSJD7/GAWlBqb5vHGRM9xfgMpjki FLThkBKhsWlMdY3K8CQW4pIFl+N4JCJYgThjBZwacLJHa5iTOar+RZxpITfc1/vTgKDdFvnhikLF JON7HK7l5st6naz1Tejr6QAkwxXRiKXYzBzoiXJkEDNyh3vj+zB7LJuNzl+VH4WHOnlL4uJdOlKe lf2DUPiJRDNT3OG98fdouoBZQPra6tPKSX5NSGTqrnhlTXwAcXw8depI3pjMWnqPvVshsVzc8KGr ZJikxhKBXk0h2/qKPNfk4jT+1R+vdmCQwppNYyQI0SonnC55YN6rDtMKgplGJbdUBHrxMI+u8pvn 85KKTU1AhRJPCdNzYNH9//nfpZpg1uoS/lmzIzM4P1/OHhvD+ishtL9y/MUAhqngqJiDFau8jffz fLx2q1ltOefAGa3bf5ef4YsthcDC8YexRwR1T8r7oohlNQxmsZlKyiKDXW6ZSQC3VlFwn0YKg5Ur jSpGlMhLtx7USPHPmgCp7T+0InXDJ9++uX9wWto5Bb4mGhWBBSqsx0X04ToT8QnXsJwTbN5h5NA8 oI6PQgI0RXRe1Uv//KabrEzNrxq0b66e/DEz/MPg6TWAFdhORP6Bg5o2QEzJoEEYbRRnD/FV0LaN hwQsgtsLX7N0/TsDeOP8Q1FQYXi+Wt2uurTGGP+k5ZdCkcu0dCEKDIPOx6guMYum44dr3H1+I/yG ziaNQyFKmAcLKyz7GYPZufaMIr0JdGP/EOJ16Ca4gFlx41RJeXxXdKGA2AZFdwGCebXZLSkk0qGe sNDUzy6RLTYMY7ERgX3GzB19ERHsy2+GbOfcqa514l+UMCztgovN6n2chtSHtGAArXV8tk8qnnMD VkmmRuwNlafU+mgtviJdLVkvohETM/WFJjLCbOCBfPtuPMpB+ZEs2OfkrI6nck10u8VPikKkJhLM SU/EvtTjxF2tgW0kFrSes7UV8spZmNKJSTeLKbutCcmmddR5C9HTmnu+lI6O71dhm78m/8bUETHI p7jsvdX3sc/e4IQMvbKs+9OZ+j0lSXQu5sA7cbSkBQ7D/Lw6cjSitO6jj/CtUDAOq58npa3zRH1I 3O43YtUTLQwRgY2JDsoDgW53MZTtAiqP1yGKLe9obWCgVM6/hQYWlD+p8Tcw61tHVIYWaajs5lsT 6SbGFScYdTdBBWSD8zu/bSBD/KFq+l+kddhM4SDxj/3v2JaRXjW+0lCo8YYd95F0JqJ3mMOWD9JK 0W0/h/ElzXtNyJ2vjGKagp52BJRt+99zS6xVSqcH6l/9Ew70BMaPZSFfHTMNiIGKufwepDn5h4Aq Lszm5WyldK+b6JT35nBt8gtQRMeY6E5yAjz9BEDDAg3sUArWCAH+qUme92dkMRe05x7EZS9wlOFe Siv3WwCD+bNgEdnQ1nqjSTuZd7xEq6ARu3qPZ+ZzquIBG7VH2mPEHA2ihG11AVMoupVj8tVQ3xU8 A7mxb2aNkI8NdvKN4fHLDmrSBQBr3epjSBucy5GX+T/BEcalhRFLkkQJMI6/BeBcvfA70pmfiUYC enWEGPs528GoemifDzf+LybndE66XO/SMLXueV0+jOeH85Lz2+2OALbiFCAXwTywN5LIGXYnFu1x yaz35+lSMnOeTspcjnAbEd6f1yIIg3o0fJVqib3LXoJZGCTZsP/Roz4lA+VRGPSNA1ef5bzZKpJb odubEPWsk2RSfc5AQOZpT59/dmwOsM7SZXs0/K2tP6NYCfDj6hdadLev3nQrpoO5rHqGeuXZ718R QEeBXmA5i3aSCyf1c9RBNmkGXTOu8s7M/SRBNXbcDujldfhdokq9q/Cf32FD6nU8bFToLha8rDa3 yPKlR+C/D5xyazfc3yNCup0/huPs1RkvOwqAlQPR70whp8M1yB8LhxC+MU8zOEB7nxbAYe+lc59q AWgzSmLkuzwKKwqsqE70WdPGAtNSbCMydq/Frij15uWoKCiAX2SfHhyeCKXAwEldYWeYl6NwCZED scJNTvkBgAgRQkf3cQIesoRVkqrbFCDtrSBoJg8j4YXlg/0YLKBbrHgK1RuFmQp5L3lyYFkoZL+e bRCbL9BizwbX80YHqjHoyKmI4tsmnIOeLQ+90zSKhdytKncMUqm8pHxDCibsAUn0ITVKcvYwZ4IL nfNKEeRVbjIO/88t46gRWVQlUMXvRzIWBWLk/1Rs4Yi5RmASSB3xcgl0rSi8o2tpSGDFKeKn/IUU cp7a3xM/7BaabsWEvepCGfjkbL4CvNVqMzSbtGCRPH9GxLYtGsXBqu2HcZ1BlYjy5Okx6JPYxqvV thDmk6sa8YYvVXrWlIMY3VFqbR6XVScL08OVC957WpiH6mOXJ0Alz+dPs544bBM0F1ph6SS8dowe wIyZBTrxGx/NwDPxtx6dPp4/e3a097eWx8GJUvVtsBvLhrrNcgJxjiz/soumQjZRXP2y20+pU2dQ POTXcF0VTPAopaxQ9swkMkmmXjdLhLGFQuioaqWpM46PArQINyOm1g6UPxFVZNta3id5ywJ2gHCS IUhNGvrQRKCdK+esmNwFgbweQjDZPFiIU4KzlYyTPv+dVx1LGgCjUFtE9q10YGrule5DC7eZOA77 Edo/jod66BvFaacyFPSi6g4Hn7dzZp1KZiveYCI9EsKVvJR26Z2fvQOwurZaH94JxajaGckdjzYo mKGiWcZLcaMDVnDjaV2FoW99Z+X7Ef2K+43z8f03UmesIjaDCwkomRI1B/uoRrXz+jbezhZ++Yzz FvDdCeUnrLrUDrE2ZoZbDkOAmnGiPpJsmdwyfDUy3Gi7/0jWh0JlkGYcFq//w5NO7SbNAhxMIl9m wj04vvAtT0rMWs+rDyTuDRzn2rbE+5JC/SA7gP3Q08hr7RqJP73e5PJ4ZnWgpz8QfTOVK/fKPu1X Zo4HadfYsGdZgcA0+VtCn0Ym76LgMbH3NARoyHjlTG+db0mXDsOta7ewki8oXnwDUYYkeGB+XgzB nwwEeDB2oZwy8QOVVykxf061iAx3K2dL2aNVBwk6zDmkRkXxG21t2YD0g/V5clqpLK9vt9h0CP4P Dg5GeOxhW2SbIz7IbkRBaWCCJRtkwvDnN5GL+u3K1Fdpnona+FKz9wPO1rWMQhVUnWRd3BJKL6g2 g/Oe/Q3K2E79nrPvU4JXFcOJTu4j7jydrB+Y0dXjdN4r8hzXvNMMRmYRj6XNma8wkEqLmd+TfmoZ 0NXTLFKKYm1dvBRbYDDPpF6s2QzyG5pic2LqFDOjUGLfFiR4zUMM6B0uJRHQm6IxcVV+l6wXq+0T TtAGVMPetdeyWjAQdvvU/4fgEEa/dmumVKpBWzpdxk+bDYN+KnSrhcEvetEJJV5/O4s+7C2ujQc8 gQeXIXr5+cryp6NUw+tDIjG922vZA/98eMj08YZ6Vi+URSWn8LXROqcmoONBesx2Q3A4d3IXz5Z5 8xSVw/y+xJkKDi++UupRv6MGINQjhHmCptLROgIUNQc2CCZwSQ0SXLLAZTY/7BuSf77JUtbMeNCQ 41xZ9QQj6XAtLMBuwvZ96Y0/BwXUXwKp1xcfH2oZMm5us2ifecHhTaMkjPCo41U/dh5dgDU4ugCt CWtCGD8gzGaAYq70182VH/UQhgdnZB2GZFLgsOG5nA5qAOoAZn/5Y+JG3qiBMI5ZFR/URBzQyfB/ N2tWSUO8TkpRcPbSqdHMLa3GWPmANzRaJAaosdUAmdQP5HATgf8p68xcu+Ny3PXEmwGfn8drypm9 u9zjt/6ZtQInTp8k44BFqqJd7DXEYW4VAlPRL35FSaRbPxfNql9huZLvWgoLwoPbYl0q2KDLbbvp dik+Dm+4GYaycXfwkA1EqD4FEHjDyKbyjk0Ft5ZtaBCj4Wv2+MXTppyfGQDnTYq1BOiEF4wcsRXt sXTeXcsVxtHMvWb3xTTNmFvdDszF/mhc2jmNSet5X6lex6B7wMAa1ch6wQFNKtZkJdDrNuANOlWg 9bu4hIWioFSKgfTPvgDyb9JYkT8l5yicFGTk5T/Eya/il83tHGsvtcSzXjIPzQwCxvutSeTJsflD Wdi0aAkqlUL86TTx2yDTUBvQb1H4HCyN5ggsDq8X6JNep0rfJMXo3buokuyg9Sk3NcCG6dmEQu2B LktGS5GLtRvIfqXK6wt+KIrAOxCZCj8BDp0SUeCDl1+iK4hpuWpHtHlouK7W2lZbm/MVc7dwIfay RlASCvf+CJQpUdeghiSZPumJzbWSV16fWet0iS65DkMENuabERG5cdWQVgfpDGEUaNMKuDBOo9/i k/WqA3NgqI7xA/QaY0T37FcDZLF9CSgiUsfY5MZ2/0DizeCaXUueEap05DFkWV31r5Zxz24Jui6K MDwE3AzBt29GCGLrKiDBXKFZCg27RqMaWnSQWllFvUEC4o/hdsFtl3bOnaSllMggx4f1W7P2C9QK j85wYLr5KHAuUe7CzcMeG/6YqIrNKy0+vKnPL8MDS5Rn7jywTY2zKm9cPMqOuYbLWPNWy951tHjE 4d9uwzcwVDe0tpDJ3ibRyFEmDwu5N9sMEQJyvRr9BXX9bR7yeKlei/2Kw4AfpLdYdO/0mzAcjMs2 MypIHVDKA93Rpft5bQR2jLDwe1BH8YJOg1N52j/kJku7h42V0DC0PgYhOHjyPGLegaVzyCjS66bd XhcJ9tBMKKicm+85WhSiao8ubJldKxldMztbyKuyjoiwr51Po3wtxwSwAxzvLH7+bKE+LZeoKsgy hN7ztYS8YhW8YoZdhjuKdeg7CyhGu7XHIYHcPAPCvCg34YxMaTQd0ftIsYXKrxCxIRUYwmkLSvMz 8NqJtRTrD+01P52cjI61ZQu7QT3Fses6jgL70kIymngeqfV1XkR0aclZ3oLndDLy/IclYZVGkfmI bhk+r9yKz7MfpaKSJQhEznzZZWjcH89oKbqPdKnYKWQlwMDIvyO+xoShGJTlyxYZtXIm2HHZ9YKO JGBr3y7H4QAjpQ/7UUQCyA3cxDv4iEEjJWsDbd3tfmDXttCxKn+nqoj4YUuHuKU1rCQg6hEWBmD0 GpdMcLfUvF+IjwVOG85eH2cackI1cmsDvh8l+5H2RJe3CoZRK6LicOKv64kmy+7RgigW0O46QCj1 pqAEHF+9Gj56yoglp+Lo/NkGEyLVBO2wyBvW4AjUqG1C/6U3sH0r9PidNgPMwNur/gn3V6rLJGHQ HcAbCqB3KwpnxN0pupxFq7HgWQxQ5PZtJ4prMAF3Og77i9dQPH/jxyFGqXow3aDL+7YEk0ZLfmdo Mee8cPDXVU7Ma9fXJQLPWmPf9u76d2DT36bd16Ai0tIn9S/kqGANJiDjIDtBIGBb7CCHCGa9fexg FzXjQgBZyl7LyJ3Xd3Foz5/wZJFEHV/smfirbLrzYKdRZ2kO55ecb/OvC9z3EBLgvnIQV5BV0UPR IosYnBeBiBSCC8YVQEnaVH/DfKMIstImFM4HimT6A/Ws/UAR0+dDZSX9uySKcU6dxR4fQbgSqvPo 1YNQ33SvdNXoxgfwAI+Xg3nTnm5q6jkGS5bZa9/P+0D2nTjeMD3WMQIsRHp5mS3KoSFxso+xMxjW iVxld3VDJLEfyYPNKD6wsNINnVRGlCKo/09w2YS8cMIHXa0TEhenClZcP0DMzNTUXPPsPts/Vkh7 WPlPoS/NShD8fr91zu8YeZCOBwcJc3jOpHY0A82lqL3rBRiCYfNpM5/c6IqskIU1RKfB8p43VpZc 63BROSDn2cJbWxr1M/fADt/PcTXKgi7BPOn5X76rD7zsDIVyg2PMBzaNVGxvNcBYWAk3WfsEW+DW 7l+9p5JRZ7iEaObTyWmYQSj4FWxcSVTKSEZRjU8UXFacHOT5WcopFb8ulOHIyuyP2st3BTszgCa4 F2938AXY2OolDBr+crl7wOqJ9cLbUrXH1b0rgLBIU8GKmA9O6BmJ1xofyr3lAzP1Beq7C1xOOfDl sgUmlPYel7OevhKVub2iFhm1CUkxywTvQwQ1oCcAK73Bn4rgmbwHVQ7yBCzQv5VjE8cMWYH/3g0a OlPoeQPoBaJAczmTghTKtNxJyHypqbVckkl8llASqwZvHp/jucdDoXkhaWTjCMX6TzM2RTnALlLL am872u6cA6ZeIi/yECAnHDfdznl4bZ49xHeA2YY2LSDk7k8bCeNvjW6PIGWZ3qDr6F2ixEeb31Zs pE9PgCCCZ7P3zsHF2uFrAYqMoWdp5u3atDxNGV/xmGqaOI3KSl3At4VJC8PnzmB6fHtzCJ/rjQH/ P3BI7AO+ZM8nVj/H207UMvWThGHp9aTBavN4f8L/9tz6aJvbNRqMWE2ZCQYnxayT6ZfD1ew0qfy7 9AjZfWryOzCL5EFNhzkAN/bi2scuFbNu9jeArKNMw3OTaLWg8eHyoK62pYUnLl8EUeoMFnaOobPH w8bl9K3XmQzFE5Om2HABbSLwnIF5TNnY6WgoNT0fwnbeRvJHw+LKCfwBjqZFjXQR8zhIE46l7BQu aQ/Mx9SVV63kFysrmWLRi7UROMQ4I8Er0nVmZ6ubXWwOTbaQ+y5teaHJOZxk9N3GYnKEWceE9Vi9 TtpJSnj2J6CDKoixw7yNKf0kwpfuIyURSZJOHqnNAwWoAjEbcRag6vEcvAoSB6SIdzreovdqVBzS Z/QtcJgbZ1s66Cf9I2gjHrzK3wITklJngChdCLTfSpm6HwkUtHc1KCqnJPyWZqfy5W88lQUdCgNy qKVD6oz9wtswQGlfA1ctUagssGHJXo7KaOfK7BeVZTvpy48Z1UxEelm5wYF7bpvKuh+2Vnits4en bQwr0mSXojWY5dZNlxycBSksbZ2mrQglRej0gsHVRqqzLXg7+atfsC86BF7vBl4SjkjhnDqia0do DOiFzxJnmx+J1HaCD3jsLgIkCME1iRQFNg+8uhXE2BPKBhFP3Ck05UrHaUZMUV+1r48KcUSavHmF aSk1y9KxzhK06qEh2/6p4gYH2fH9e4sNk6+VJyuXhdzReoGv1DlcfXpii/4dUFLjCntEJ4qk43Aj zMnj9Xkg6+5uXQryyT9IlMfvuhb8fcqPqIXO/B+ffX14JMKM+5nzw92GL5Tr9c+/9eR6He7ptdPh 5e8o+RWzxONrcZt96xNd/CJA/er/urZznkICIdqEd+0tWAuWScg3Pvrv0Jg3lvR5eaBtWxgsEv4D CcwBueDQ6RbR/TPl2TfkVrMJyZFfHscsuT7F8Dl1l06QSaw0qOrB/vyTl6wIibAVkWa/Equ8Ihkh eCmqnjvsmRyYgdwTbPyPPOtpNp9HyUOYIzaDRvHAGOoAu9MhDKAf6R+pnvwmx6B2og9mZXV14m7w Uwp97/La5VY4Ro607IHrZjuQk1V+ALujmXHtfIyIo9Zp8sg56D8xKOz7c6TEz00VvFxgRi3mvgJ8 AjkOtV1QqG9hUBT56/Vzyx7qsUILPZhs7ovTsUZH9ozkaCs8pPDpmPeoO194Nh2DQas+ixHp0y2n 6nZyI1HN6qORXZhTRot17uM81IE3AOnL6VF2m9oZrjiWn8WCNMIKUsyGhDeUDknD/ZkaJch7pmrg xq24G7KVtlWdE1v9pRTG/ujHveYIwAWeu/TTdVk9oHVTmYGp+Z62j6V0Gk9cEWvNrYMPhJ/CSNsa xIfArbhytPqkr80zaEj+nxp53hw09Unb/csk/2moy9RjN4JB3qbQyy2ZXCnLKgUvqpwcthj+vIJh oo+bCxNjQQo83T2wo/+pqRzvicEisXxnVkIoxp6f3QNFktjkLVXiC7mkhV0cz8cMCN25cU1VXASs 3o8VneaRWr5vBCjdheKGUT6w+LCxvCSq+91EDcNHmLz2iq9418NRyDYBvD55NPqJeTMVn4Epb1sZ GXqVCCxXol7CK4r3LUHxVbl+/hIwMNYn7Bj5nqhnljIsX8L93IeWKON5ASsfvFtznsUAjnfNpBYJ IoLZ+14QdHuZsylzvLUE1rdOUpHFZfs1S136uzceALOXuSBUdNJQg5tvOyoEXim/02XADblgGwzl 4FEJmS84Lj720nsYSMLyu95LxiMaRFzxh01B+CJNE511i648d5TXdFZ5JvH0LHycIr3JGokWpbi7 2vxunsnPMqcavBpkHe+0YTp4HvSU4uxXLkqEcYTIUXjvbbcCLhQM16GR5WFVEdO831SL57tuPbGd j106JjO3t+KhWaxTQlKGfHBzfJ1oAo2dELn/QAIgo8RsXYLPCWJJXT82XINRQ0JkvEUWWfctNv5H bBPk/gfMKl7XKzyB0VtZ42jaHLXzKPtG6KT2m2N42jEIEkmnfSmeX2AO6O796dqCj5NBIoCGzeOY oX8CrwHCASC5ll4GVSMpUDGrHmcVhRRS22nJvCJCAGBxN21R5YQKXiJOYDoiaJyxa+8pRvlIpalc EmNW+PnawlChRIngnIJg48S5F2HdmIuSeOjCuGMS9AqogwNEM9cz8urCyx6r2o5UcSJmYr9aDRiO bHsgEBzJaz0WWryTmTgYFq+/GNrUt31w45vrSKBVTca10ddDz4nkzLPbT0ptGnVnz2TG7COamOZu fpORRDdIkmHs33uh+rarJxNDmeCxJp/E6gfyTTbMefhYILPh4WXnGHK56mmMIESfiI7MSXQ+Vb2U mpEcY+dGVqlnT59RVGpIzjNQ4M3o80DqjgCIDJeM46kawRDynG2qO9z9/DLIZpYT1dWLTMp6G09h ExNZvyiaOXfchKjFz+Dpe4DQ4Oc8rO3peHdaNi+QkJFjPKbHjk9aEqjnvSJd8miyY09/dAxXNdWZ cTvgkZH+bTmVIB1U6flUYZ+gUkZasspQ2A8LODd5cAY3hGBxqKuvkuBs+fhaOSto4SO6RenxKLsJ ka+8aJiu6BacdbQWRuL0D6LSo8qiKgjMJJMfuSd3HUAo0seQqQH0PMGjt0VeLKaEEALcwoseo7/N x+XCKy2fJiPmHQdIukX+zwHuEBYcQV1QWmVyAiUxzG4FrCX1ETflhqBiuhdwC52Tk321rwb5QRv+ ph7H8rg1VzuD5UdBZDsnLthv9lv43iyu0YGwOnnn3t1WoB7VXJptv04p4ieOWcd9cNAkPNjchSHk P41zxpkQxV+JraR4zRIGOUr4pV3U3rwt+NBTOvXVkxB3u4rgnzZQ8R2O/RdaUvkouaTOA9zGWUCK p8DF7qBDeij4VgJmSO/pXX6iK/rx57KOM/pP8WZSMnJ2m502ummkW292MFxyj/N5TXDy+B+uNrh5 r6iFfbPNwN1ST5W11vXIdky8hiYOsICbyp8qOpIUJrlCG2UPZzJm/fN0UeZydqO/5OpjF1mjGIbw iZtiy2n1eGGoEJfvkr65lSs988mFh5UbGRzgM1N2DJcqsI2I300l8JOl1ICbuFS87JU9tnAsLTtf ZhzlBuUTHBihY+iCbOWqSw46N+rCX/TFQkCUNppe1T6XMrfmBXIunxFLfH5wBUvW7kfgQvKc10tR BUjerGztQxMvguwudw7cQ1PFsUdAUhRGZrt9UT9ZDaYNwGXcZZpiZ66uUsUnVYV3h743VZwZDoVH NJPi53EgoHAOuhLhJpA69HwQzaxOwF9JyKBu7kZeDjPPXr46Qw30Mn/bJroo+S7hLgIhAUc4UIFp yrnSbFWQ+t9VTDrViAUU6JOwGzgxSwQ3iCytD+yVij/bmcq3pvGHbzbtXqCiwJ26D2erHjPxGpH2 RoMCNoC2RZ8NpLG35fS4Zbg47cdK1lleMIcpICJIA8De6HXl6/P/mcywWrmyp7z9o9r5/d+FOp/h Cg7F52Z3niFKGFoP6+pvDlMbaOuf/ZFtTxnvxHdkcm7glgYtevzA23Ks2D/0Rsn6Hwty54t78ad6 N6wgr6Q972dOWnTUsF8s/hMi5SPtNbUO294gw3yl5cIYkY7+n96L6fx00M4EDBGuuA8yMkCYIvB0 PNKFyjb8NXD0AkVP7hAaabEg9gxTitkrW/SbOtWS6nZ1bC/ZZ2u9WOI+3k0SpZrFH+Fs52WIkzBq lBi4TdVncJNw8IXRpeddMcx3I7EC/WjmBKVQGLi3uCjNr8PPVOh4GaumOg6iPEbsJ7Y4BFkReoeC W/JsjvDETpO4E9nlf4qvfCyjWqhbYswQbzsRg5ADzM/+kCB2avbY6hoNhv6t7d5JGIribDxvAKEx ZYP3U5v/eLHp3/btDDNWufT1cDtR/rhFImpzaJ9uLu2CcKYpW4s6PXDLH58dDbhgsEJYA3admvNz b4BWoEjtP1yX/pbmABEqWrjoLIzCa8XeL/toz5fv38BBZT+S9g1RFruedLHbbOsta/tTTWs2m71w gPDaGrsGus8XIRPNKWqfKSyvfpBG+9wRM5daiCleuuIpe689/ILb13QzZYiE3+zySePV9XYAsyh3 4vkmasTFBKsH7S43mS+YeKEY6ZYsguuNE8CxC6idJGLbfYi6b4I2SXJTDM05xOSEBHZnzVar/EMg FtYvnPe3cTzlLwyyh/AH4r5af2y+VqzTE+HNSkcJ+K2p5u+B6ZEA8aRRKFTlDWhSyGdsiM2mRZog 9dbsSRi09VmguNxaD5j0it1Ifcn4j5TDwWkYhsc+NLJnRO0ZFDwvqdoXh62G1cPoSUJdlnhUR/p2 JxQPXW9ZoVANS10XWscjuLVYegLZXtLwrn7ZtM14v77MSdjcva+dvA4NS9oxd+TenAKFxfrCN/W1 mVJs0EAWu5E2pP8cZQSYXH8O7RlreAiE9Cw0nDgbtL9PE36VGswlxYf5ygeEE0uj561qomhUUp5C XTxgg1tgDmnYdKIMxXqKq3t8wHz1B90C1O2j8BB//p78Hah8u+CQG4nvzJ9MjXMJuY1InDDpLiDo ynJu0Nd4jzghr85frBbuY3+YyMlvpHtEo7ob1s8JJTSA1w1RMCafbZBuzrCGd/vprujPFdczG3Nq sVJp3nCf2z973HAfkoQ+VPES8wSqGiwXIOUP0fkHCHTrDAhU/5q2/xVMgYAXdUQQhG+wUMTZ5SKp BKhj/31CL4GbT7ddBIle0owKhlfW2INEfo7f/YvKZKT1cgngJ+JGG5GzqvfducCgOmz/3Y+dwO48 4qduShgeXLFmEK/yeZ/8rD5rnd8Nsb3u7GQnM/BU9Lx3PEMEWgr9ujK9noXjSBMpJLqri90SjDxf DIq+ldMLTWPqHuP/qRizsJgQ7nC+aqNUNWaXBN8Xxdg17pBjUL8shXbRfZ84U+DyHUFKDeZJSp8O J6M3jOm6vA82DONjOsAFeR9eYCI8LvBETDUfVMQ0uontejgWpwiqG1C+b7/izRQmRRtUSvpL8mOH Ctmuq3AW9ue5p4LBlHyMAw+DeoxAtqgabtxZBBDuw8YBKYH9VSAyRJVMvIMtq0h9V6MJtR0MVUhF LuzTzRzi1KsWiAyfRsu8u1r3FZzOHrjoGvRSUgmzaAFxjt7sQul6wZFfjNrBJu5DAZvBYlxLq9yS FDG4Z0wV++nx0BNEYBRC1FrlwKR7qjOYrEHSVLcwDxy0QvUZWc6vMOBbmkbm8fMffCkfoImEg/3T D47kD7pZmKrmdLFMqZEMJ/QC8tm1LACOJysaDgTkMfes/QzNE347ZhvAj/s/cWxvNpMiO4SqrzMI SW9g2GwxxuMki95tKRKAFZ4SVXb4fCbeBAbmv840vwA4nIJvIUy9yz07t3hT1J7vAXOUEAQq4uk5 2YLC1m43XJaBMR5w1LRMU0J1r/x5k2AnkxUq7E9ZxlSYX1k/lag1l6X0ey86k4tC1sDRHDOZOk4u kDgPZ78WcsCDXW0yhiPvaKbAKZlzsiCjdGC2SXaWTeVjrgCH+/Vkr1Q7NPFrgflIVDIGgGvjVbj2 L/9r5X6QhTmfugtpFwdxdiiCpEX6srKQ+CMLKqEWZ0kxazsu4lavOnIVb1wHtnA3aQfFTOoaRSzA 1ZGroodxzx6hVC2RtIieSCGyf6FyxAwEZSv1yybWMakWEyIKI80acBL8ITtZTefXNxfE8a7QjvFl cZ3oIvz8CdYejQIN5Yj/BaPgQ2mv68Gjhve91zWVO0WBBdHEh5N/Cil5u3O/6t39vL5878bDPVLX 8BxPaOoIUJMDvlNr46aKCpvgzmnVHdLVuMJnEMJc9c8Nu/84UlNvaN2EadBlP3fhtUZ8NbeLN0rP Ku+VC2OlitWJ3VBTca5YkzWjeVd+glusMOh7lHkfFLT7IPm9lV/go6zn82lcWQY0aRG8588sMJRH 944seYjnD1VbCk6L47o1dHy01th9udAYX/pOHb0y1J4Gq3OAgQJSpNdCzw/96mmNeXk4kpe8dGCG d/A8SeRveAlo8tMwGDBhvWcAkbmyzzRpFZEoRLQm32FzyyxLomIQHO5nuLp39Ps34Dj3vxOeWoDj e5MAZHdx3DvPirQyat+JmFX0oQGpprT17F35bln07MlFKNwy00LMaqD+yJpOIRYHHRzw4OAJrrFO ipdL+25ZOIwFEokAs3CYYP0AZ3vpr96HgtwIwBuGLUdgrGTtHs8iBHJbURwumMRu0ABtFpI0pWZt yaONVbIL9Nizdu+56WBRO/oN2rffcUG6Dnrg8sEuLKA8nTnhJS5Fq9TwGg7TbPMrcJMwCcxpSSwY u81ZQiiyloWBwIQkPhd3VqcbIRRusyjr2JpnxolHGeZYf10KEnFmoJv1Mf+9Bfh0H5fd+zQlJwOo MkVwnGcZrH7fo3ghEjER/ihvwYHF/Ew32QaCRJo3NAruqE5w2HyX0xQWDec1KsODUBSrRYQMS6gH gx7/43l03StK6hp55U7wPg5/Xr1jaIqG+veuGJI90NuIj9a8CCapMv48d4k0qobUh9996vX72tFv qNgvbTlN3HiHjX2YE6XWOuTZEIjDZaVqNQO2zX4+RqeSUw7LBsG2lchugFT9wPFl4npzyaBC3jmD 8pMOnBpzY3ThweZxTZnqMF+byTsaihiavSfEGswU3QZt39CRlPU16x6UXFJ4/A53bVsBM6yMP6ug slHJC4LnDRncrLn6pFMt1V+EHck0yCWw+X836YCGIArl/9BWpXhBDfy35uD/Jm8SkWRex8xUW08e orORWSs9fszlsIYIMIxBdlvviKam2tvDgh8l3vAMYo4OUOEu9Z4YyvdCtadZVMZKxH9MMp2jBD2/ OEDtayvOSiif0ozALIgIumGPIAMftQDAiD6lSvnJ2VEtdn5FoPYN7i2RaLrtbAmNjW7Z3RnLEVWT iE0Etnks8soF4OwJsVzwoxNRNnPzW4gGUYtWm2EvvaurhHv+POhahH07D2csDzRatNaG9ziKwOeK a9qTiHRCVRSQk+N9HNtpJfrYVAWVc+XupQEHmHK2GiMX6TJIQ8Qhe458Hty0pU54tUEW0B+dRBhz OGoVEy2nHDXR4jZ62vfb+EX1q1udYvXPD+YCg5J4Z8wkbWaxaj1UPrUiIV7DdJhru2Tp9Nyjyx5h Ar/0+iZmftjDbykqwKz+crAwiZuVSW8KDV/nPLmgQPXfGGETZ0sT4ztUR9c8eoU9G8Hrg1jmZ7Y6 vAQtn5ETfquvob28VwkdIXMH1gyaNkAwMOm7Oc1eDIYmw/2HSKh/Qs1qsDPDYHwwNjjwnql50MDi G+8RUTt3DFfrXhNpbWy48TCrkM0d8neJNjD6Tu3smASMgNJokkncY5LcMdXxFcuzXXSLA28zVLhN 8dc0iasWA7O8RED1GVs5iM77epdr8yeSINfhnUGYpAaZ0nrGJih23+wB905HT+IOJ0KcpVnt9DoV wGjfsZz9ODZW8mLtT2p8tDcOG0aztwgYJ6XPQEWgOGO+gwqsDCZdSalxmcmKpjp4S5xhdF38hHoK si07m1R7HXjkiT4eZEe1yiZEyJvSUYDCjEaQcjt7wvUZxZpdoXhMwtQIf9UvX1JR/KsL2MDRzl3G m4SWUMrqY6o7lNoRkqv0qrGqcX8Esto1AD+8hJYMGep3gR+rLKpHn6O8+Z+mTk1ojvsFL1ZHHz9r nBmHWb3Q9SyP8IjUdFJX5dNVPhQbpxywB00UctNb5AjgnUuU3YlgjpVasL3cXRQzntsCnyQ0GWoM F45cS/i1kRVyZyHErlzqTbyrmFCLAAPiTuLUW0DgYS/l6lTZPqZ7eZvx2GdoaXCzo5M0ASu6yrTh hkMdUG1S9yCCEoH1h7aVshlfM4QXUWdslPvGzsxGQVVdyiXBCcTQdUsiWLdNdATJpWnLstjcklNj o0eEI88SPDUqDOH3S8lEh1EIYCYmzEOpxcFHOTrfODb2kwYSpEAukUnYT8HmXGqN65sQRON3mliu 0gUNjhJd3jAA6rYx0feYiXQmz7h1av73mONAE6fg9t0Of2DItOxp9JoFwxrNCxEuK1HYk0DRmSP8 CJFQaifH40Zu3L1sy8+X/ao+emTU4jNF1FuQI81wNEAleQDoBc6o1DwvDEPRQjH0Hfd+bwzX9AEl YzPG3D6lk8w2bljAaCzTbNqIxqhgo0bjfWaiYoyU4lrCW9TZIC8shGYghUccE/QNPyQcdPjtrNsM A+vnptBm7XTMhxeRr/+od53bh0vAkgPVc4A/WpIYqWHIEHs0f7Ap30JViP7+cNPLMmTpYdYg+XHy og27QAn+5fY0XDucxV6dAUkte9gNA2KBgEMVlr95b1Xxg8BisR+hSEYPYmtTJCM8Zv1Aucic7y/7 USWfEs0iBQABQ9xeVMOmBTiKFJI9g956f0U3hO8m/MKwbuVD5vSpYtU1lkuyDPxfGZCNPes1E3WU ucSEg1yEVidLKzPE1p6fejWfP/14qsOYrESLuX++8A+tQnFdazVM2asTskFXrHmgW0Hs7ZsGgSjP njJ5g/TMWQbWsMO5IdODdQo19KEqaLjMYigA83Bb1JmDRE1g5+kJmzdyeSv4ZHIhziEy+vN9KBVJ PJDZH+Z9m0zJKXx71z0EoruDLuNf6XjaM860Q/UTqMtn8QDClYtCsRNhXiAASGHHZYdgBmNpTSOM kFg5RFyBu6CrJjWll76/L9+IkKgbAuHqp3/1e/EBTkRB7rP71PDxBt9IAd7Tl3P3sIdre+qCZI7Q W+vm752fxGI512XhLMxNIMckBy0RiEICR2slhYpI5ERthiB8ftCn4Bd5DjAI3eJdQmkcnQlRh0NL 4p9/stML6vHoz8qJUP3ZHcV+K4/UjfToVO7Xwny188GJ/x1F+DlBctmoX0MVCs+RYQ5qlU0bP57Z r3QLn1XHKoikuoUTbkG7D9RQaxNJioHkydYQL/dExDVSX/6I2YzJ2Ownnb8vKNr2R+o+Ip0y2Wmh lVJ1Slg9eQ1fSIAwzk40C5Z0RaQBg92jgI4k4xvVg4+GSrjzpoZeOWCq1Bj+rcAfJEkMXWz9LyTc yKJDC+DwIdXPrGxJ1pBgizrBKwtN/7o7AJUJdBIZ/gD7jl9YrKDdFQupYssKtvOr6TcvT1fTWVd3 krLEgKGDoR0agYdk6262znd9blMAaPZ+5WlXR/bSsXyVz8muS3GiiBzYfa+7feKAagnF75kcJCZe QXPLuzZzi7kMQ0N1GJIRec452iyy4MQJMOVUG5z1NfspA2mD3O1686mc2DdbWDL2bvuzuD3Woibe 75IxSwLKGzSurQnB8Yazay5CXxQX4lAWO6E6GqekuC6U+l+wSr/D5yLbNJ/8LYN65XyFdthHKtQ6 zKkUz3g0plpjBadMvJ5Wfr/Sbv7EQRndUwd76S2l2t0SREG0wiiuVVn5Vsr1e2UFnzmhCq4NR/ky z1nR7jJbdhy42zERiHzmqFg44aXFBTCQT2Jk5zRIr57dysU+mxaUU3NlOvpR7N4/K45aU0TojMfi Lg1s+1ZZbM4z5XXVHEACw/zkyXi/THH0r8x945gkOf1L8K++F46uLdPTgkR4JkOn856GyT+uCwDd /Rsi1OCAV0VvC3uKx3YqUQD2eW2jhYDaPCGgjfkefDFuJVnkwi1ZimFoC080g99cxzHbeMO/kdTW 7SWNaEzNEWmloZaXynr2b8AwSfBbxdKgJiq/nwnT+Wf7LFgmfisr52OjPhHJTt8Bwx8GxlEG7/mR Pc49oNKM8lANRKWT6Z+8LhWfyxREEFSQlljQeMVzXqwYG1NS60UZPs3SozM2+DIlhEXFRPLSEjpn Fg0TEqAlaILP+Nnml+k/Gk0owKXiXWUriXwa2d4W/2mZbKkjbssUTKX1bI+nAbrltL/y4zDc5Z87 dMNetq16lxdWAXFAoI35kboC0gkmBq52wt4aAHQRMsNrkIyJje3zWzzH5e4ZyNcavWQ8CGsOENeG pfOWhrpa7Z8NziTiWqz/nlL1VNCEZq9DNWwrjBjRF9F9X/1ngkigbGxC1926L+ITLfYD2TGqGKAS wh2iyc8Xr0M6aAqKnMrYR6CD4pyajC32y12JNRT4Gt6A6wZ3O76DlaSHHg6Ejq9Fo9iITo6zNu+N xVPsuah7XHAFqe16Ou+S14/Vkq/ttpUJee5J5VUmYwQF8Z4y+Su+MV/LCXLcYfOlmSZTezg5ta8v OmqiZ5iAJFO6XDVlkOVcaBonEgzTQwAysZ3+G5IO/bQ2lmirT6VPb5gJiXULyHqyabP0lc2XYWzU wMOvCTTx9+SXL/C5O4tJO0DAsfXHW4wXRhWq6qBEdBKOcbzhC39mT/9rygyqMbQEP8b1HN8sVI31 1otCd96O95HQW2f/qN0LsuMTyMBRPDhiIbkFuC0KaHNjgbxJ2nt4zhH6NJ68ZciLJU8Xyo5KRNre 4HO86TavdhQXb/iUPwGzo1LTBICKWxAAtZjCpybZvbxt7AGENF5etlv66eSoMDCCIL7RrBkZu2qV PZrURBly1u6ODdIgRSt2VLzE1l2BqDXdeHY8xsAtGBhfGDEXEj9fsxDae32j5l3Rzv5IXofKWTG/ RQcUVZAD10oSeaDTRcAnI1BdwJ+C+ySwImeU37I57CocFbzkE2TSxFWfuQZ049AQzI3dhlLD8k37 t+z6nNixDQQDlmbMxWlKgWoH69iKyz2nnbeFDxOoLon/G2PkCm+SdhHzbeMb4+72fAGuLeI0M8yM GSSjuQAO5AIhjNBtf9wTXlIiaIvkTUL+Ynx3liS2HAJiHx15fw7n7kUDDUWBxXM4HDnZnZ28ZUvx Vih0faR7GLe3JBaJ8NXUPZocYV/OPhdozZ/ndyB1VneXrO29oDICUaY8K9NzYdEt6B1glc52cz2B Uv1wLqE+ruoL2c6OWpS+l7i8JBcISXptvyU0swD39R0Y9FAl2h3InsMlM9UH29CXEEYRUOSolpWc F0G2gBs0JQjO7FRnNpqtzpHj9ShXexeKh2kUJI/l3JNaqprmvwt2pWeaFlN2JAxnMzQ2K9DqYkF3 4HL/taoFUhTFP8NYx4Fyjd3iaQ1WmXE01dRafO1+rcZA6UU3jwC9VkMcAZ8BxK/c9zA/dQp+qmj/ 4kbaFWPtwVRvu+z4gdwHXDqkJoSkSJPO91QaHcx3RyCcghdR/kvf0BDDBOCPo3ygHtkkoZDYO3vF pN6XALnoM3ClND+o8lbgDOcRdyflm+kBihT8raiFv9LPrnANIhpF0wy7cQeEl400eznmFbwZLQB2 bfpbOm4AJ5gqQT3CjuQ73BI80HsjUVudF6Ved0mbNJq2lPEGuPXFIcds86yD0P5Vij7gtFYU8yl7 tV3cC82K3JKAIWijlDcpeNfQsaszwlgc7rxjMvE0K7fBI8TDCzu+PgHCe2KaTn+Ii1D1tK0UaEc7 yk1N0tN9OzPtuid49ApXuavGLsyEQWOUgTyPbYGcM/e8U+FtuMEWktXtwDjJvYZO8XvFkQgkmqNL +q44VXk/WHiOBwQUXDanP9xOKt3gaHS1ZZKNxMkkwPevPVff1fwSgPhn4Wj8BVYQeOtM1R2M6SBa IP5Ait9jRX0qvM3SfkCsugnO39CxoQ/FrcBv6KJSRloYW3nD66WegzqMcZllPrTwp2npNEKGA7V6 R8LZXA4M0znkB9l58Jgxkie6MTvF+w6h4sTVyIjZgmRnyAWl4FA1MRDYD09NJLkCzPNOSSz2rjVo TXPZwhY2CK/aQocRlWCRwnu4vsq24wdXUYDvlb3D/+jb6kvh0GE7Ofr42UBs2kZhYhjvAqBC2T0y 7j7+Go8L6paVwNrtFcqtGI7aqtt2fPTC38yu8YvKLQZi+4WLLg1RI3PnJ7zAYz9TzfzlPLOASBbZ 1R6Vt0hYxbD8UTspNqz+aY4WuWPpkmFQV5W2o0DpbYjoFkRtFoe5IvCucgvkVucQ8Z9ddimUNHuj 2DjezEqiSRvrk6L4hxM9D3Yzb3Jq9NaPqPFLF9gwq4x5NyeMANgQ3UVon+3kNahpj1V+f13OrBtk VO2XQNGOR1uPkL5u+WqGNO5XKnKrWRrhIzrIz9d+FApRvCMAJBr228pIlJOgMTcckeXX0s0mafQe nons/PU63GfG2+BPKiitCwGsh/xO65wEhU71rr1YuCp1PRYfNV91T8jYvOx8uyNIkYxtX3G7wPXY T03lHut4W3Na0NH2DNmgoCOOpD/GM52pqe9/SjRoB0WweN+BVajI9he2U0SIij/Pj/X7TyGbahR5 9X+vIOQeowEQH+t4Qp30q8BVXFrZ92l2vnGFpjXDknR9kVRHOCcdhDv/oQOLmVQIj847rtWDUmWQ p6ZxWatrvQbAjqZp+GqLlAVwlFnor3ghJove+o4SqVnSOJUcWueYZoVgzQ7gfwutY4yxV5dAasKy no40vKmhOy6BivyEC9I6WaFMJwXb9taO4VxeyEQJ6PNjfXE54su3ea4B1buuu4K0FwxfMRuxBWcO 5yVBhC9teXRaQa5JtkIHn3ZW3TNXdPpEqUIBAmxIRBaVrsQBDndqgdFyZU5YuNSubd1fC/2j9bDi p9EvjEZDpJOYVg0ctJ+gG3gL1dQOpGuBfghqgN5SuANJdCoFqf7q9AjggBiFRbyxvxiw+fDLtP0v o+dBJqnl9VptHUlms8y04fhHZJQvCusmaRzn4g57XOJPJRNrPxnMOsgqjsT4vc34uuDj8IE8i4Sk iLJOln4nDslBIt+sYdWtpm6LVLJqWn+XoEhu58KFN/KL2GeyM73YGHS2047aMxwBd1AY3A2UnFu/ 6Z5QVzGbrv9I4fh5DbtJ6yUaY6dRBGvLupbatXe2kJPOxbnR+zZc3nO0csqA9nDvgtKH8i70hKod ETl6e7zLGtfzdX7q0AHMQQ1rRKZ2qYEX1mMYBZSme2lTVLMVkwqNknDf65OHdqw9OzIWAAS9eR8d ZJ1GeY1OL8Evi73uit13RgGG7iXatBRFCb9dHOs/qhMqIvWK6UWf3MEE2VEcSJGs4CqpxVjIsmHJ izZUrpb4eZzNjj95gN6CAFZBiagCa0WlOO/2FPxd2bJlED+dAInpctsk7mwnvJNIK7bSrCAOhcA6 WVwsI6IWAF2T1/dPD7QMBGYlVCIdiJKlOhL/tApj3LnclB85u9TLNu+weIgYK+luuzNT02+UaOXP as0Jb5hVt9Vh9Q+l35RiptpjFpWHt7KoCiCfMh1Da/ayWpnU3HH1qpYq0gOElA3KWvTx0XJRKRJr 8d2CV+tZLBgg6DzLAIdL70jbjsRKldG0FXgyZ+xQvAl42CZEnNbSzm/7N+/TOQHOdb6YLQMn5Viy KNU5CQUtBBNK8AMkUGAVJeKLIVT9YaiJCmEg7rg3ceT23jap6LaVA/uDGIGDt9C6IqvaB6S7gXNk F5ng8MFadSsO+nGwzHHbNKKbJU2F6aHym1FbZPCAdxMeoC2ifAKNozRwyCTZOyxodBxwWLo5YLWr pG37OgGTPeyz1kuRM0KN7k72cJWh9foBNsmcw9syJVTDKjcQ0nyctcH+5iG+78MiTA+C2nr+xENB 1setWzSEsmauMSc0C2Sf/horFhv9IkX23coesZVdiAcm+0sAgGVgrxxaAlsn9SWllru8ImAKAc1P CyZv4uTUevNNP7SHZEom0bee8zsEnj+OwIPtL25bVMi4UCxFAej1Yqj1g1WUUL7OD21qHrHuenvy o2w1P27EHynVXzou5N9QYH2EG3DAkuYYz8BzPtYkLdrBzxxrGrWExO5Wy7X7/SBHRSs9chBeStVs bJHdeDF9Y/SM88LiDOZbRf+q34B8+NvF+ledSecmlzIPrRMDhq+QyO+1j3I4NqSYmXYM8lJgeP6y bKm8ddiU19h8zvwWWAx5RpvWTPx1FGGyycyYEsoqT9RAXxvFYyhz5gC9Os3C8dSl/o2sh/qZflSG G9E36dc8Xg1VxHQ0PcAGz1lJUTQTRDFUgs6lv31QBnfSV+VWVJUyER3QnZYizoCcRECt/TBwosXl oCmH+SwL2FB+B7U1nCVsZmqukN+Gm5wgtLgrL/HMlUnSQaHDohPyjf9F5B/islPVR6MyBWLihnb7 Te6GIfk9+63AUzsgNRR/1h6LZWHey4+XyGUt758ay3SR+OczDPk8LRDGNPH8M5qyC4r5mATEspgM 26GjDjSBdP5SBn2Xj7T64SeG7Raxs3mJT00S6tLAXLlzg60s0MrxVYMoRNyL/zv76GbjaEz63r31 3YulT7LecO7bGrv3xh3vWRSxWY+chVoOAWFT15RzMG3i+kOWFFlNBaUI6+OiN48A/OtFN99qjunM JLmdS/khI0+b02uI8RIqPIXujELDClgMy+yay9UDSXKUQ036ts+JLEX/lndZGYTPPwV0IkFXWGyP DwDdb7U9vrwj98xpGmAMNw/5iQxcxNtQzwGc3K23WCqIGW4qlm33xOyZAWEIHCPSIZH2XmWCxWpz CCPtq/kn3zAFka5G3PPWQKAdZe4lRCPJTZ8Lf8Rhq+qqsltZoeBFsbwkgHZRu406RHhlqwykuHa2 DX7XHReO0OLPU0evFfl2zlTe9QMoooyBAAwbJbc9JeNtsM5WJNcjvIiCfPeZfVY7ZZ6rw816bDLR 5kEmR5rpaEU97gq8Pv2t8eYiu7BpB1bvPY2fO2Ual8EnW4Sl9zMyyxL315vDwmydKwiJEezmQ4Jr 8GjL4KLFdf5FFuGOhWVSZyPqPk0SYC7hsXpt2LWkkLkGSvYipxnMYn0/EV+djxGnpsT8GjCpWJ4c 2NgeeyictO4uJtu/OzbtEEdaHyYaJD4X3bdf7Q+FUXT329Swd/kQQgZVHL8c0vV9v2e8C23DCHbq /+SH7CiGDcm2bHrlIpT8pjkmznho/buHY/JwPxUF+flucCTEj8032PM8UcR9Gssx4/QFv6ruXS2R UXNXPH2390BtanJTcikD0bXwBxYruhy8bgT5zajaDK+zj7yG732ZQLYPBJ8jHgf1Uos9pdZyhYE4 WUGEYHL4bbiiJZlGgQrUixuahNY1pwIxZzVeiZ97ciSyJJCpfoAfrylx98bhZcWHhArXyFk38GMz GcuL3/1GSQSUikBGSgSq/DW+1B0vd/3ONoCj5XcV4uZV48Lhn5l1PMO7qaNwI6zOCkIn7j1EmOqS 53mFeDj+fbQC7dT13WbhHWf22+Ltbt4klTn2edv40n687L14AIv0G5VakPNUM8AC41TVX74k2EFa aUFOkuh7rsMTAtsTOSTOCQxNEuq1evBGrJGOD1s2XWWVj7zFPiossSldP5nfIjRKyH27dJ7dE2TC 36a7zLw3xQfRSYYLXslHPzvWGMZR8dANfiuJ0wxxutb0RXbRYpan6zVinKK4FSQiM3VLfu8cOHj/ Sr5dKF/QylwEmCh8T0w0gRGNSp8kGMxGkFih0siift7jdSmYOOtr7mresGAjt8KglCd2l0Sv/zLY r+1eKSjysH5ZODEkGWVl4IAGAXar62O5nNoCFDLvEsU8i+y8bkOHe9V7t6hhLEYQHlucKZ/R92T6 Ufb1GKiRb/cP3VE0vunKT/d7ror+2bBYpzzfq2wt/iHEFVntSTrWF/Su7emhV+3gOwsl9oTevCOH EI4EuqC0v4BOLdfYTA+rA+Rr7aM3aouux2zOqnBX/hQmVRU+6Xk+z+c0gSWKrUqnrdELkxT2nKrE me1pk7J5ToFqi0PyMNisNgR6WOOhu2ttKIrke0Q1jk8otlEbjBqc13+O1Ch1Cn5CSESrVhq7WgCa GAv7jUD6tTaVLGI4pKj1mhcl+Sb9lFIBj/5IXkuK5D83vvTik4SgjPx8ZXJ76uG3uJ43j4DaDl6F RW0pP/+PghoMyXP87puwJ7fQn74sDpGHEGGyGyryfQvCQArIXaebSAnfPtKkPDkDlzIibXHRaRBs c+DFPTZ1naWfw35fngo08aga298ceWgqWe0I6ZKAiArkAwNUyvu+odQiWE9/Jh7gOTrqXNfh3O/T szNEeNy86co8uFP0+WtLznobBell51hjIfUTEI4tDFfPt+zfD5lpg8dydQZxslbigRVvFsilbHnX 59KRocT2A+IGrVuaSag3AEKIx1sBOZfFtzSY9uGZiEbYOU7hNgBEDBJCdAWUW48Sm1/XqN4aTDhr UdFwtEbRMpLubvIEX8qFCPC+MzppU1I+UmmUJjt7pZTS/4JxATVLe44mlnyPajLGaHH2HdGfaIvs dwWOearU3iGDU2EFFzU9Q4ZHP0brByj2res95Le9A7+WyZKDcPKxHsrizRuVcbNPROCYZJyPB4kb LsY1mJK+BJ9ARyh6xC0I9etDr4szP5CMlAJJZ5q2e1zc+2NwGnNSr6vElvBogmPme8JoPITOzTB9 mFcgcwWkuCF9B66+Tay0yHCXXJkdp5Td+N/jPyzqC6g1Aq2oq6GSTGB72Is/AEbeJoNQTJ0gJGjB l28Zkrci3NJyHxqUk0uwbKnLy97usH0HGWnOihbO7hcr5aAol99FoTB+PdwRz2mp98KpglfzOzey 8P42LyroAW1soFwjP+9xtqElfKKNzGJBJBymMK31PejY4xja2wFPUzgb2C/hH32ijjkGTi715tOR c65BUrvREKi6vscOczW3JUgTXeFWFalLb7Fme2683rle5uualD9tCF6nhlSdOvzebq0aWnHoznQq tmCFzwmeaXGiLq8XSppoNxW2zLx2dZr4LzxqtQM4uF8WEieYt3uEQeiAkCCctvkv63TIMqSPxkJb QUdl4u57KDcPvZRoHqfMrbQKoIyw6L0xcmxoGtxrMX7u8hpqyTPfqmu42Q/Nzg0VA0kXOLBU9O/y 9qJN8opB31RUFAZp1qFeJX/9Njlu6oor/ghjrTJG/D38peb+yysClF/0a57ajNg4B31xBme/GkQY SRUb3DYhYhTA90huh9pJFaPRXeeklFex5c3sfERTum78lbeneyiSynGA/e4+HHKJdkiEk3X5eetl 7HHHL48rU2+d5ZNYXPJed4sF4pO3HGIkprsOA1o338FdfSrSiM1aBX2BtbJ588wvxMhMc5CUlMEH 1hdrKd43B2GSR8VgirQbxx9iY52HaBf+KAjHlFRf5ZGTby7tpnoXZBGPxrz4uXivyhOqgjQ4dV8T O0L1Nlhd8bGsHa/WE0RcsAPL1i/d3lmsJdH8dGnpwFA4FHRdwI4DrANpKAJxyTY7vP/76fmCqOZq hYdan1E65gi7av28/CVbNFf2yZWEWAcmc+w0a9Ky6uiJGuQLGeWaBLdwpVwQ1BmhqK87u4px4fMu eleKq2kiho2QMre37eyRovdKDsfUMC72LwVLyyjH+fStPWE6h6dspZ/UBKtqFRmBeNA6Mr/qx3LW QogLUWuNI0hDjVc9zA7VYH/y/Ltov7NBFWxl63h79a4TpsboBfVlbN9mciC8voWxNtYu5zFdwfTd 7cEl7Gb8CnFnN3jZsByvdlS6TPYmllWf3YlcjNJrLsDZdVxoWFrjott0XPZQ9q6XHcyTFx0TfUUF uVnnjkuwreP7eKyI4xM2J2tIlNr7d+xbp5sFkik/95bGQlpqbZTo7lm2+7fIBxPvbHyNpa7qvQb/ GZVu+eGbz91DW9MaRjCdT1JB1p1KIGmLIMVQI4TAxnXnU2xirsy+h3KIvsY0hX+UdatDez4e5P53 wFuqXZ4sZupycuWE7S6CAbMS+3CfeBo/SOqZQYj1V816Y5+5t5kgTyuXi5a4uwquPAj7dQte8Y5i 5XZIQbdU/S8WOBSbC6hiM5tQLc4y1H6liUVIPsXNMcwsvTJHQmvgy01FknYxjaYxuX7CADUV3IQF 9WNylh2wrWOlSapZHDVHedT6mp3paOiSHtd2DyyGMu0Y65PXsQKctpZB/2z1pj2yIQxVnfGC/TbV fKyJi+uUvzFVlvwHInOjDSjAClAUU3Pbo+Xkz917AzoKUD0YYIzpUnQgBqZdDz3AAzJy2ad34k4x DKgi7VeCT2Qb7+4IF8v+e7RwhINU46Z5Aw+lGS/xLcuHaEq8mU0Nk1RCUNL+bXTIUYe+q6XpDU+Z V0WuR6Hs/bZmg7UZHbtHUmkT3JABTy6rYLic5LnLFYkMYBnDHrcNABP0kBcApi2lf7OcnX09U+TV zIRL+PWo4kqPtUaJxEGrAUx9d/+sXtWJg/AtG8rBx4qhD8vxHZGjhtCXAYeCetPLF6maNVayeumN wLLqYIWx6vsc7i7yIKaQJWXIBXYPEtqro62GiZwxsLnzG+UGCkBh/HrjscFGmqVAWEfAQ4m2GDKu GpTF4GEVnpM5iPEnRcM9178Y9GEE5wKXTQQniF2aRL4z/Eu6jscSU0fpG6rMleDgInEEEpUcUlj9 EhCWCNrAaJeNBb8f/bqg5TXnY3B63HNwQ5TIYVLeLjT9faBD1uWK337utr1toXJVAqVTEaIJo0za O469zoNIVKYAlh0C8jmYzw4nzpaTlTP8q5YRYlXZ6PoQvX80iMVzFYeI5Uc/KRfq8xQ/aMEE3V1+ 8dXNZht5kcPwigPfJsVQv1SvywZwuT46acV1vKTN8394VnNrEI7zNcF9AgAg10oMonWgMvZkNP50 1sKtBcpS0rBDtfsbM6LqLHS9kvUqVuUeouv6GGBT/e7n3EjvJ0Us4ksuZQdUd1rWTvtUCcTwF862 RVQBgUV280ZWVkRcJ39ha4blZsAjf8nqTJ0jUTfVh34DdGuw1uVaB1t9g/OB9bAsrKHEPzDsJBro V7TYLT5T3Olol11ynUXk9WNiW3GoXoyEz8P5mor+5DwNIHdj3ed5WfvjhgkRYwiALOmAnVwY64L0 DfxorTd5dayRXaXV9l5BXraPNOn5FtaAvSG+1czR9s1AKnU/DWQYG6XtqtXChiXAQYUrirN2xZ7D weXGFD149I3H1Y6n+SZRESWYW+GvMNpoRqozVUbTEBWHDytXAuGUm9XBQ0v2g9LB0Urxcl4uGpBN g6OF4upeg2SV1R99rNEQi060l5U2JtADyofj7ixE5SNyTV1d5lYvnizBrOJS5cHGkal74tgWP84M HypH6fHbL1IV6j86+4WeEyfDfwb+zP0inZNg/6qWUYqTndsnGZTfiQuoqnmPHvKQzwNnrfamLv9o cwyukKEuzfjg3gIXsuLoY51SOAoL+gd9rIbgigCtBvvEun0BScpxbkroIRQaSLfSxtAOlIOAeDZK RSWYutgZZTirAH+4hAFrjr28lwYnNLrXWkgvN2hy0gUS7/jh8bUByttn4Z79RkGB8WExqrWsgtUu iP3lHq25IxOkrTJ/+VD8cxznweNkE0UgrqKlNdOHYN099Q+lQquhMxmJIWfi+5pU2bRcAVxpWt5T bVxPFlwVSKgXdXdda/s0pNXAzHcKG7zitgUQXgqCY0KrUDy2DSZMvtql472bKfVEKdhQpdSNUajS zdeeFheVLfIySqdzGVZtSBNiEExAIJ3CRIIYkCSmUV+YBkPgyo5LDygjDZw3LPSLTVVbBvAYNabl /neoS8Gvi/hF27lVtiQtJpl47ZCOe5s0D2vU468rCoiqyg5cnKUDF2VxiAQtUNwqAk7CwzoyxjtU BwCLnGK9NAaMtc1/GANE7Us6nvPNZlvOmnr58uKg5gLenvX+HWmupHSJO3i+qUtuwyU7+qrxu7jM CupuTU2DcaPd/KmuqAgBtrtpybRMuURHKXmkOp2eYvT+fS2FAJEj34yz2d0XB4tJTfjkuLY4VAso vt9pzenV+mQgYXGAEDGDSiAAPKqm7hdJG4Y9Dc32IXG3bn3NxPP3CoDKfJuuVsqsgXunrVLgLcwd diePDlHINpNCRyOrDTFy+WVoPEwHN+vszETNAX9imslpm5M5s5+bIEbu9kD3g/smgw/l86+stmNw b1jpC8gSOM7/QeHkZkvkL9ADu14TbtEMmo3ff6TrTVgYaTw9JVPgQ4g8/NCJsE4epoACv7TSOqGA 7SLCyC7iHfkH7Od8US7mDAyrzW7cXUdIF2nzvcaWPO2vOmEa8Dn9oQQnGaDNZ9yv1g2mzI1v5ey8 CEhWxpD+E8cdxssQvBgVxd9HV9ky4kZS8HHMltrYz61XEdE5CeuDqgIfC9Ge1YsgnBckuzMj5ShU r0Bf5GNuGBR/OBiVH3Cyl5f94edr6y7zkdhtsQrVfQ/HgpckhB3mNQ6FYcBgW6PyHAbGomRYfZYt /IyF6/P5xbqZKhR1ZA0pXbV396J1q7++JbQJhcAVty7cT93lgBROfCvDXwWQEa1MT2Bl+aL2iWzj w1t6vxuI71tPLLnU/NxFnWChIiJbJQfzc7Oo8pMjfHrcwXCqhgHpzi6k4cxb9XYVVoUOhxbZ512S uU41VTShPQKL+iLnJM8W7E7cMHgveFojXAnWAxWVIQX/j3o41tc7qpiIN2Meqh0/CvJkn/Kj0hgY ZjlTr6uh60Kbqn9CYz8+Ww4Al2WV4EytvzqKi5Q1WWRUUi2gHfoXZUj7Igy8D1rmm6bdMfnTPPW6 Ql24W+Ltr27Zvze4VvfrkXfoTibsjQEBJxXRn53WmQBXBMZrr8FZ4frO/uZgw9Eh/o26q3FN5aS7 xsFbUJrKpN7sWZ5qQJFPkB0ncX5UzKh2jaS4itmmhuC6Shp7L9Mf7j8CV9vUzMRWIucv3gq5aGl2 JoPgauZtApx91f43GlCeDXtnpYNGBI8Equv84Fda57GBH+imKoHo8DWt/rrhFrUEr0s6tG7U8Kby 5DCbCRPU/2zVg0AWiIb2+FMD49hMZB+EQDdrtcYfvnDeWhyHlAdSdCi0POmzWpxKsNbRcAMr+upy e0hQFjA67Clo2r6n95NlBCw4rux5S6EST2kDCGcZB5m78Ebdrv23ESxrgdWCNmeO58cd4IMh/HuV k04f1sJWqrQNOyHiz6gUGbKGqi4DZxVqotF8l/AJFN4h2n4ngGELlDK5UCbHAJDVqrIu2h4qc7R0 cKk9THtCFhOCSjjXuxH4M/n/DcWSQdJ/Vmfw4jd4o3tprqzNtYv4v5VU41MkHK3xFGYwCeRMGGmB kiE054bEjKhxJLWOj813CBtFPamx0cJboBRvTnQQmt/bZ7JVR+9vzQNW9kWNyz6C4efWYa3kuVjv AW98Q5fh1hAcEPdJJ1kLkz55YfCZrtWe2ZFk+qpX9bgxhbBiRUErlGHUUdEwbh9IqG89gubuelT0 NChfwCWw16HS7G91ZXlkbyPHNVU6lPQAK6N7sS8blbse9JR0qwyqcUcXJ9artcBFTxnsZezdj86Y EbPgSTdbwLDU11BAUOKvpvXHwOasrzzTH+bbZsnq5eZEthHGa+LaY3F9zYS46jIFGg66GnN3d3Hd YjFAL6q5hmFsghQfv+SSTqwMaTeQ2EcfIjaSOwnGT0ji9bFPDiV0xdLDjpg/Ei3QxJbZDNG9ihwU ZjMLf5nlA9JIoo1CKTUB2Qcr3MnctcGGSupjygUCxv1QuwzKvA5uPdvdNXmJd5KYa8juUqtLx/UD b0bJDjxmcAzzeJ0Pq4wDVdMvtUfqc1RZYiGifvJnQTZHFO+RB5icGuud7USSfqBp/orwW0Qt+dJP E+geuCj2itjoaTVtX0/NOXR06ZbJukqtXTNjah4OGTiH4ECiDOS5pwW2KDVib3rw+P1bz5rNV/OB uGTCUgQT7k9NTXM8wf5NJsqOha3bN0c8ay6uhWir8Yg3Tqb5HxW2eJh4261r3TZoaEloAFl9pe29 d1SUzdIvSg5DUEByFgSUMDMwgSGnIeeccRiGnJkhB0UUBQFFJAkigqLkHBWQnBEEQaJkkRwFFDjg G/a7373Pt89Zd537rXOvP1ZPdVdVV1eHqu5n+YdtSca0jRVN0KWwo1N68YLHxPV6Ms9z9DIFMsji HjjUNfVcZzbJTHTi11BgH/c9rTzIMhKBmXfW3BTWWIhA0o/ivSPAapCsVVGJln8lW5bLqiujka58 mHJUGU7XocdXPyaT8yl/UkU+UaesxzqKev54VZvhU+kE/XNVh3T3gme0lkXR1tfQt+fU0Enz2raZ WnY0liUF5hntZRy5nap3x9cgroXxCfeYPrNIywSZYs00ICqtET0VYaJg0tRYn7UGz/GaVIEhn5fU vgt1zMHKN8e4GZSi+Tkt48aepzvP8a8fSGgTeu+OYYTKFmlh9t+KY1jKqqYWIy2P9NNy72jBiFZI rDUK1nrYutlAErfnr0jdWjTcHNueG+Z4pr99KUvusVc1Eyot0DoU6RmtEkyCm++8e40ozO2RZvnG lDy5U+rchTtjd6OkGLIkRCMn3CMLFSbSknMqumpZauueaOUQb46Pfop21qAcJ3Bb3r6uoK+eMLZO BFRzWzhUkPr+UuFbz3NDroP0ifgvOYmyiRcP/U8w6AxiwjkjyN6d3YIbpDLpmUbbSqZB1h+fwfK0 83sNRsWSg+pBpoe2DqVlkiC1oIzsJ7ILkfTt9NZZpZcarw02fAXknHb5Cla8Sex6ZTFtmLQTosE+ VXrgR6AlmjjkmX/NLi1UMWPAhs581Y4ntYEH4/39lCxGPJzSGEC2DDBaJad2qEww2NDfe8cNGKEH BVPK7T5KG3Zl9i55zB/Dcf8Ky9PISKE53Qqw3w4wjWJWlnuszZ/G/+J+tov/yYZomYZx/RzIcIbV VZHmLR3+ViV/qtXFvi0NPqTlfDnSTWpaOaOTiQo31cGNSDJ7vrpMXfpuu2ct3oPAgJcxuuAkn6Xf j5EaYmdq0+8xArDQtKrhMzroIncLujybWTfR1KFnKwQgEQW7IFODnTxOa8iKipWZnpIVs83f65hj ICurLXvEWcTZW9ZbuDC27Rfn7PMu+aQp5eqJStu4n8cqT1m5bZUeoSP/F4RWf+T2S6KZV25zLzT0 Dz07oUn1jB3ZlPDSvma7IqbIJli6Muco0uuGi6UyfNguuCEl/zpVUHWNSO6GwvzLI5Wm2st0t7el 3xzUlscZII1nC2c1BSxrgnV6BzqJ4ARAOlbFGyupGTgVykGTtoqv0MjT+SnBOdMycrG1lt1smkPx jSHZHqfbbg8mg8fBwxX41zwfTgRuvZ3oo6hW2TQ9eo2pCGeYtK/kjE+kE/KMINdpanymSD3Z9mCt S4qkJ0EWfzxtK+FkHhBqvUhomHeDkDRmq7q6lZZTurTj0yWdmBGVV1KXtGmmTy/a0E7Yc4k+6cvq 0wixIavaUB78JKdwYdu7AvnNk/3Ti+fpG21CF6hvvP90jM3ooD5+Jb6d5LAeZdvzWaz1S7cShbXN bDfBHYOhK0/6UoH92zOp2ohHF4Ka1WGLO/6UjdZHP6j4rtPu3vIdtUyl9FgqITfxT5VxfpuMVaJ/ eAhvCyVfvBeK0WEKu/a+OUCR1o63sYb2E0V4r5pDgTKjm2BghU4RekcpXb1NBiWgzA5m49msvWvf u5XnNhYvGgq90nHQVQDbj1WnvyPbxaLbkCzJ7BWrJBD0pRhnTrT18cfBo4FPbVfaABM0+A0x5gg8 f72GNLLSFClCzEb2I8i9XFZPCMXRrGhkk86BfCFFad2HOM4nU8uFwknT9Lm9GS9VOcmkLaPWh327 Jo2QvJBuJGLzKF3etP2zfyJ5JmUC1KvkXlmWpIilQes9awflY3+34TZ/NcvOOzliR/mxoWpDDp02 WxQF3tW56Tky4Z9KQoOx5/9F03teHdqv/IMmrl+uymAqQ3psBdv3cXMkjB1SG/VMLnCBo5i+kvmP Ie3TdEkZpSA2wyi3QaFFB/y3XESzPfc9BXfi3e8mXdEp7fG/r7STtSq9UE6LNpzCV5v5KhzZdDBM b4/mEq84+syIuXG3pWI+yyHwokYqNP+ywXsbgUJjDnnmzCvPA0K3Yz5/fsvFCN9bd4mJEBX5wiYt Vn19q88+16GAqM6LrJRa5bL2kPn9RSK5wVCvKM8EhoCFvXrDO++3in1ofHZ1UJCsAmGw47za0n1r M2OiYVMxQttLt/Pe3YvblZwnM6JkMQ95oX6RIe6YVjZ8uBE/i87ow5vEKZoGOcxGQdeT62C3p5WE h7eLDUrf83JfCjCLKEzbs5PTTG76Qs1/2YN/u8QRQWTm1HmPaDNQl77AClSe2+68M7iTlnA1LWLU Obct4rGbJq1rfMwzZxSUON41Z8dYKGPAVlKy/iONYcn0ewF3fvVZjVs2TNs7uyfxFO+r9SS+xzS9 74EEvr9U7Lyo98pmM86jAjpGeuWrS0FNI4L3bVsyZZP4mDiJyfDEuy0dnQ7qkqzDueTD8LhWJbk3 8s8bAA09O6vRoinevfSa08RHk2rXa2gjZJuO/IfjGg+/hZfx1XUvF0cb+oBChB2H332GvIlsHcAf GH09szFFI9R9PE35STMWwpSaAnFuazlKU+tgJaooSvftHdzOoB8I45ylOpK/7Kgk+sB7qyIuOcNZ xfHKAqndklZxTb36/JaJ1UAX/3cdblp9mXxHD7QyjnXGLNdfzoBa+OrFrZ51PLGIHg6+jlYN2zvd D4/j2L63ulMWI0KR64MUbydO2QnYcFCKb4+8qu49SHerCPAiBAjNZO9goh9f1pkSCnjnPN/t6y8y w7xFkm4hXA8zsfSLUKf7yi0vpOLmc920uVOwnj7i1NKszEeDgZzESOfIHaiEXIc/BMo3KCutmZdt dnmMiKtUQ1bCXMZMzJMWXrOqzL78MEpZgVXXdF9Nsxi3aScNXAf6FNgZfri9esfi4s71g+apotMe WALrTX7imDGV4BseAaH33rWxUUhdNG4O03tt0wSWjk4r3Yr7zrh50+i0jP1lmB0ZZ2m5NTrP6Oln eDutMTHcu8Xp/qmvpfgE6K4/VIxLpFpJkvUoNWm/uUQxfFrtzdVaf8OkLteAr3sqGwI3qy9/lEt6 vqfOqvPxG8eRGB74azEeRU2PU/rr5zdsbvPZ/Ojl2QlluZyoK2krvpXJ977pSeuTu6xD7226oa4/ aEpIR3sQmQqXEr4Zzm4/7d2jVUg5IO8x2ol8+7n9K4RCm4X41CpkE1lMdTitSjt1lz0mbATG4+Nw mLl+7HD3g8htqw0uxbqSYFZH/SFgfG6GWExMCgeRwmmXQ7nZzAJU5BHeSQVLOrNFiJusyuoA8Hom fs8r2Vr1G4c0VeD820BVvtAcmS/v6kjQ4oTTePppdU5ZwXixs980Kx/P7qibJmy0lzo9uaID69MF sXkUgQp48hhrC7lp34IuwILSIdlFhySQmJGnb253ZDElZ4shMW8DHkzjXbnabVPfkYwfeUPkRg9H T5RjV8Vl3DeBCKn6r0EspFvcD27RvxxewLcUPAXRKjrpJ9L0jVaBqtV9sC8yDED4s/j0980KWPAz 5Fjv7nVmyMQFNkUXUBvxlldWhvbjTKbIEoNo98Nfy3kD33chlgio5gp9CQyC0ebE8h1XsPKBum6K y5zSVwuS8NLhzQ6nmbEjORvN4nJCtyVTX/uU3LjxEs0BVYiJC/gYdnXSm/057UtdkW5OIN3y65Tb HpXmFvIMI8I0XUkSopgjo3EtKxe+pa34iYaH05lYshWm7y5p4oxXCnkIshZLBbIrzEmFruwyPeMl xwsEvXfeLLuw6ioirPQh5xs3StZt40qywIVCq5FgFKayDcRXOZxeWwrI0hsZAKbuLgjifyfLn0HO vnqAIq01sxBJsYwCysrwLQFIH5hOvLByy+omy57T8oo05MN6R16P5SDifnQV2cGF77k08ObHs6pq dbU5sYBI6Gf+BQqsVQdcKVKdfDstGXOry5H3RkPEOyNLkI54Y4mAKN3l1zRB6mJ0lyW2sVZtTRWZ 98vJPS62v/VBZIrkYu4XLqG9M2BFUi4fQtYbEu3hCtIdpiHbSVwPZwOOjRgVMxAfx3K5qF4udLkp cKwl739kzIz41pK6MakV1AuukZNsofVquXhE+T5rD6c/TyPE1bcy5ue0jV068pN31Hn8hr60/DZ/ 2+uIlUaQ665sA3uP2jYp09PVCNNuqTqCVqMIjOfS4sLDF5SSl/joEkmkpekA7KAXHeY/QmiC1od6 w9AmtYXfYMv+/Yald8eNWu8LdubJvhch+NG0P2X3Y4N0w0Akf96KI0hyO9QL9eLRErxozmiWlN++ ugU84xHL6Y2VrUImVbDKPNgOMRvlihiQW/4Ssp/cOBH3YPvhPXrRAMGXWvdmW/NMbnsBxXM8TznX tcxje3VdHINQhJ/AAXzYH08/bQ9reezk05dKbQHbwz6iZO/+6CrCTUZ+YHD+nij0amJBDqjC6peh hRKO+aLiohSSvfka/9atDHtzWzOSAYJoV4J7YVggOSFzyajzS/wvu2T6GQmOigvg2batEgO5j9vv QjEhVC59VLV4VnEPJu2sDaPjyy+YNC4VSt0qLXnyXuNFzECjk2FPcuRdP26cXJOnaMQ3+UH72Irt iAmsspq5tdNpEsfnrMOP0Pc3fZScVrxPeZ+Mgmxh3T9CSf1j+6tEbPoTB/cYbk94l173MzuUfLKU XbpQN89OczcSKbbDePi0dCXVt52k7gN/xlxFqGwS5WNlx6B72JXpxGdj+1Qy2o3WpdHqn4XH0y0W bcWaPnfyL1vYj6EVXGvuqJIIBMRLSiNOk15Uq+3YFe273KW/x68Pu5xmN+XFto4lbUgjPhZ6GDv9 3Epr31imbkBuyu+OFqjwy9KctfL1JeXh0kVNAYH8kniD560bTZcCcjyPPhR0x0PjaJ+sBYAferYF ESXg/Fc6dNJPbsfy18MFP9Zyr92i5ESXx36hCkXeGDnReR59CbVva/VOTFPveierwkJ9WMOkIwVV tT+pHRpDAX/Dk0smpBjDfXaxKvMZrXL13uyj+CydmT1Itrt3WXD0SwUN/E1N4PDbbEBNiFIpjOtQ dsS2d0bRnuToxPjpfHq+B506c3fK6Y2DJ8K0hCwZyLFmSBvOdZuloTvsezqbmU4ys/7jcnrWUl9D 7S+he0fv+nYYHYCzGw+etjc8ZxOWdEgYFjLJ1mKbqJwKVu+9sTT6hp50SONYuf5qEi8ru7YlH36O dR0Z4IUi2Ocz+QfDtpaF7QZRob1aI/4Vy/7l/OTBtRZJ2Zkd69LBT8LBb+528iZrWgZnTjbsBd5n SbiCWpP270eMFYYTmt+Bv5kT6FkouZxL1wrEWlOhwhbKNN5JblyGt067iyCvOKw+Z3Siw5eblqvJ uJPcQFQu0XDVYvD97RdUXSLs7WKzOFnF6prw+atYHZ/Bnftd6rUnATIkJcZewPZH47cR4RZRvF5V emrh9kVSWTJypcyi6ZeGZCxWKTYwr4Umo6adJlsd+SeC1R7k8sZnfhJM/Y5Wm0fSJmAHnQaxbLAn 89XTSDYxycly2DB1kZeay5PCXp5Cc6lciZap5REKddLZ63b5DNfqbu5LAd3nL7vLrzXSPiY/tXr9 gWzetOWllhmpARsLhcO7rL1waS+5ieHW77lIsUpNwUvDrYmvFRdCbAmEGeF6QqvsVYZHrluJr05e Skhff9JGtM5eE4lKeb+EaYudm/ArjnnxxYeKohBY84wuvgbZyD1hVRw8aswy0W0ulvxWi3DJiGOI qtsNL2H/oky+AErwoflXgFutPb/jdKHDkUVU2oePSS4DrVP+W9fBc2zNSYnwb9fLF7KYt6W6uXZv ollvlfMK3OcsiEYT4IssJkizcN6Wt39vmpWbJBLqtU62O14WKS8e6ARNX6lId6m4p+9LEDtxZaqI 6s2ITxLEhuKupFQF7yw3nV8n7ml7G1/XG/ubSmN793+wlibk3rw5Zq8hU1n8XtfYQzv+8sc9ppmH OY9hQQBSdqHLT0z4LjzYLG7LKf/Op2+I6kBbEoQ8a8WiihvT052vPlH9MhTwwUQo1zwIWfT0gQ5D hacLoYiVmCy018UqPzxSnnHBtSybW8FOMCo8IHEkX7uZIE4JUnlB9P2bgMEFsrmU5A87phmaaojW OVDb3btkTfcVvyRmS7K2f/S9mEZz+FY2zHf9e5uFzeel2qnLD/Klqg/D20nFYVKE85YV9tvOXkyS a7PLlOFNuguKIQqHs1+NGgcrtLOgeR1uVkUru3mJ8UwXy5m2x3RvduPeBTNNhg87FpLn62Ij/L1s OpCr2rVGGtHsmRvzVHHKC4aHLo9E6kvI6zWcPnEZRutQT66zCY/SIFtmA4ma5HJ4b9Sgb2x0+b/P A67nwO71MHvKnbYZ26Izd8OZ9LUcKjAo5Rjbt+3gAmM+RfbezLs2ZK+jiGXeAJsWaO8EgHce4zM+ mUbXjkZIa3w/zZ0WbZUu0b/scZ8kko1bjH//lqK/aloHBpC/ZR92aerbcC9ro8D6C5xUkfnOLXPL ldtsBrbPtL4yO+EB8o4IFx5/EYA7CP/wubJQ5jr9HnxTQkeImp+W+m4m2pAsxbywVGU/hU9mjgg0 x6IISUh/gOIM2PcxKPYnTuw9NprlbKK4ypjKlcr7UWpQIrsBUKWspCdIj/dBgdfHcWR+neqoY25H qFYFOgToaiC8c733hJAhJOGIGktY1myCttZmeDDROjMDAqxfm3a5GvKIp6B63s1dQ72caLLlgjby 1quddC5fA+jRJcr5diJgaYm1Ldwp/gm2VkAmQ1Ur8tn06iLLj/mHrd+JeG+ZWLz04aEVf8DD3bgk ThrYTSb6iGb49dGs5keXsWo55kENISS51q2w7XjL+OMMd5HGxoqKG0/x24HxmHW1AkrUTNmsdvN4 8Jsljtv7Vle6coBmoikcVd+e3M8WcC6efkVMXCtzresiTaP0rCQJrmdpMDSgzk2eAFcUONpEZpGV yJPSnlFzROIaKzc+1by3uuw/i56kT5R6g2W//HpWp3L/pZo63xU7q2uMZI5XjJjuGNXPFk3k8q0r hFEaDDl0KFoaVHHOKp/eCjfMcjGntxCXEkoQP/mQS3nr+tP6SqJ7L/WZJDP2k5ls39rJ3Hz8Xtj1 zpOimF0SkdmYGaEWC5fMRGbFC+RP3V3qPRnWofqT0mGWMgtTC9a3bFW/ckKOe5dy7onxF75h0BCV Z2mcl4Cx6MlOhhjQ9UccXQJ7y7jY59nxh7TwJFs9bW+Vmf3cFhVaRUz8g367Pw7zwt0/1958oMnD NEenx8fNOwbfsJ6VxMA4VXojSL4qC37to0+Tp5f84zWnicGB+yqVEHde3Gm7vvaCLxdXau1pYUvM tVxHK+sfz19ir+kQ0xmW6pPAKp9+kENohjcwbMUnyaAGV24ewpwT7bNob1XlSibfunKYlxnJUg0g mbka3t5DroX+gD958NKdZUqX4USRYKyZ5lJYswlD4NCG3iMn3qKJN/KZeJQjmZ2tUtBFp1LeFRAt LZHMkCQt10UroArPtqBxqb6uy+PXambVqmy5nmVGlV7rJ751iIbckdTqMvcanTjjPL2CuYdXumO0 Xt3mrPCZZmY1MtJwS4zSnGdtDfvx0CsraTBfkGI9I8PIhiyQoFVo0XV/z0WNIR6l9Vym+QM9Qkk1 XtDGi1OL4+4xhcRCsyAxneQJV5aTwj328VtR+UXHRc/xbAltMF2l80lDKoYpjPi4k2aJEydt4w+e 5S8tikq0Vlb6O4+G3ZsFdhTcxKnj3pQRo9S+liBVYwYGybc/Pqy1DiHsUHNVaXnivafE2E/8xrwF e/9Yf4RWhfTq4+qSe4iXjpPHysSiTLjupfWvbyUovvq/42cRdTZ6NGy61jKg2R9y0O+mdZ+s2Jvm ZMDuo0j4p+J+C7uJGySkd4i9eL8T3i4Q0RI6+QHqIhCga36fKd2vVR0ioPgtraMi0wCfNvzTCWWw rVKmRgNMfkHpfhAuKYbP84Boy9ShfjNzwClknNvLIu222qTygu3LLzrsNF0niN5qDpJGz8Vv5pW1 L/vyI5pPQqdeyqIeP8fjf5rGbYHazyxjcp7QtSf1WtsvKPH8egW/6chvd7cyrfWZt1Fv26oQ9Dmt QdAIc1HPBaBhbvwwIJj+koLicOf9YWuBIy3J00ZqxYk+l4av1D4YJYpndt6z1mMCyj5f2YzXxDI+ PhDQDs/2bC6ncY1Das7k6iKBrNeYuD1bVxjZei8rS2Xf6Lz76IcZGc/dT9M5En5Jb9hyP7rHkyjp CVdmGvkuruxz+eX4UBbeRXPX3rMp+7F5tf+yxWqYuZ/ETLqnifElm8ZCckksoY6hVy00rn7d5L3N lQ1BTkl3WJ3Zl5Q37BJKdNEl/EysYxTKeLpNNOMyjQqHNrJSheoSw4/VWEjtSCVB4fnciavZc58H vYXRU0F2FNtS210U8ttBFE9oQGjLKzkvmDwRRMtFuRkXW8UB35kk8QsFrs/YyWvfCVikL9q8Fgni rrtFYv55lnBuDYd58yXUf8A7Yldg9N79a0x7L+e7Ax7deCCudXeAdxFL2v7h+S5PalN6/ibmIqDu oG/2yjAHRVB4zuSG8qFp2o25T9WbnLRPPmwX6SlHez9kMq4PCujeuWeuxXHkQMW3u7MuMjzVp6X1 aqSeqztQsEZ6RDJR00r40072YAD16nqp1E0CB+WWenw4VvCtk9OnGw7up4bzJjHbto9/SBG19VfW KedlOZMbmD1tvdVITSVegn6tup5CiQDljsxDitOISvWLk5etbAoi572Qnq/SjPg6R7elMoFx0qEH F01nsamfiIwffH858mHHxi4uCjb0zV1VCYaNuTztYirwET9zmp0w6OmH6vuiKa8vGjHmttvZHGRu yOGucvmbgORZM/RDNXZHbqrGGEBv6n+lPZy7oLbHx106F1mxLf52ld9Y/SPvEFyv61ZKtFjKc9bH 75tLdZqdyyZ2JbSgz4OEAYsXwo6K9bIp55uDIPmUU8egT/7IlHTzmwrFUYalJfQ+E01k3qE100KA lWaF1cFTHbv1teFUczxTAU/mq1EEpQLXLrOnHBLTEz849CwQUnhc2tzPI1j7qphBqI7CYpCH5sW1 iDrZdq+R3KlvDKMLt+E7lbov/IqzOPginjA2KZC/SvqkbSRCx7thGPOqMo8nHxRq/ECyd3YdzVyq t6bi/6iUH8CpLT9BM9fbadfCaEnuy2Bzv02x6dpuoSfDyWdIXxwglwAwnXKdpL03e2upPHcyezRt Z+dOdyOOp5JI+8aNCQmlfHRWW5fm/DyDshgbOfNtzkfBdKhM1WADoTI8Cz+WG7EefBkGmjz0q1d+ GJ+w+T22YjuC3va8JmYxGHHY/DiZxyvj2nRU7fqyHjzQE+AnrB5XlLNDy2TAUZJI9qMzz+Z5dUsq S7y44EWCJ5etAJcwlckq4QspyWCg9tx1nlXpZ10q+CT7V5VexJG3kjtWDTYJDbSOv9PsAxXQ3R8O KMDe4SkaM78dvPDkOdHueGheG7m9FmepeoZGxjvt0zhSGNfq69WpeiZbQ0qNjgyrmqmJCLOrY36D shY0kO2412o7L2VUrq7XRz9V57MLOV5jmLjf+mE7lHkU9Iy3XHvlwa2G8g50oaex15rgiiKdp6dK /eHdnWnMXtpeGkylR2jf/kg8MC6BbAheZ2Dx3AAKQhc8GfICJtggavCddxqq6KknrozQMxRg9QxI bj+aXmfR3KS3dWka9J/FZK+JGWyaqlQbZqvLxW3mqZYL3mkzSVlbKsd5ftm5/ljNqoRSxuTa6jBd Oa+yuSsS396B3Gd3he3FtWCCQPZauMwh91O1ptetp3mSVNWoSx6U715goERaCoKUWgeZyozdCrBN omD7Ndt1KsrUkN6eglTrHPn6+Mfdsy9DjN1jR+/ssoiwENa8YXCOudb4glBYMv0T39HVgZ178pnm 8GviF5dL2KDgjKDIfkYPCQd4v4jmAvy7yDLZVmkR7S3kQ/S999EsIVi1T6PX1KgOsuufbZHomHSv tcbxo3wsR103LXs1M2En7IN0ylc93QpGhW48rq16ztKoe2lxhroamf7ABGSX7WXFd2rHwW4MmxZB HzaFhbJqkpTvbCpOswi8WtdaseUh3E5Hug/U6bYav+Vu7Hg4UEFJ1U7lrNy+/IpAnbcdj7SiEY2T jYBUWezzLURKgB9x8ul82Bc4YA5QCkVO4LXWH1a9N1B+nrgkrc/Y3WmXZcb+/tJ3e5Xqi6zZvTll F6KJGiUtMyZx6htC6hGydHSR2lMXLr+I3rpQEtS423elgvzAl0kbTLbSsav04/E3zcnKnI9+GVm1 cNpjibje9ceCdx7v8l5VSvcHGBVd9iLfGPkOiTkyEERJtE9pUJ0yf9PbJ71/jTCA6dnFpUQod8xx sxTFxsmrL8GcTbeOo+lhls+MBGfyCy0KMey0xjHLJD981yYY8YI6NAWt8kmu/uOfI+cXa4tPPfYZ HskKRbY8MX0oUaSzjTCUAKtAvKZEerCdA+HhK0i2xcgZ1aGMkej8zFyAey+n7oARHJjcsnXxJjqX xnQ2h4bdnQZtVf+KJsyU7j6tblo0KmBMpdY/V4TIr2MpOyT/Q3/703RL7yT769k3I+JubsmxBaq7 r5ej+OtfkfhERhVoZzAMya+ovNXVvAt7UKum57JGeURSKzh/+gIwqLHSsWb4VOlAJODpcENIZCMT Y0uaU/NexPzOPHhNnYY3dvOCXa90KdWOb1xiJhbKLZAn8VFQx9dV6iVTmJOj9THXibOQ3g+zWs6H 6+tTsy2yzKiFzFraS+/gkysT7bYf36h0kOumJ6drLXgMLG8Yesz5NdgFLK3QNM5Vpe3AvvrQWV4Y uh2tLzmMbzpW9/10b4GJff8dS6ble5+qUOnNDkOl2ElmRcWWsrHrNX2s1BlD+ZZVtDEXo29ubqXg kdo8Cjv9kUOdUkRAwNu0hyBzLhx/bmOl+Yj48EH8S/EHMz2LrGyOpXUK6h/H3d98N+13NktKIBQf hC2PRq+9NiPdMceOY0nLe9wj1oy+vNJVGe0KpGeVPxYcM3ypBX6ByV/wz4LIR1neHYsUlbxAmGlS pn8QMsI9RNwJ+oxxZA0wZeq11egfck33WyR3pWbCo7G5oikp/pVE3BmfaJpI74eD8NoIhWk+2335 x+rbdkMjzaG6ri8EIQeb8KXXoJhtx9Himfd6cj5SK2S9Y5Uh5tG6NxYubj2rSCYJZ+5Aj8iORPaZ 5moHDdaTeSw1Hkp2f+qVY/5q4bvAQdZ1Ne6bWCoOyRw4uiqjMCSLtYkZoHqDSFEpVw0u/Fi6ddN5 54sOtarDPPuq0DizBS9htoLi4rPii3vqZfsrOmy6NipLRsb8T3G32j8Bg3g02AeWa8JSkmm8OkKD VVfEP897BopOieepEotf07qX9h0v3q99qpaTegHAiGTKTfBs5+IOyQQH1bDftzEnTHXtWMl8FyWJ y6kiFjwSsvd4Ni/MId9voar1YoTpQs/kwip2+xriDUOTNVv8wL0ceiZUXCJz9Ph1BRmg4j5o6tum U6p2d8FJ17PZFkXV2PKwRCDC3lgkiqyvcycBxp3muzMgd4trs5PbryQgTrLIjZHXqX6+QlWwyspM PnihUYn7knPQwwPkpxFzPShnXeUlGn5fh6+LDTj/hIBEnjHr2PIavTx8CnCu/Hzy6Kkuwyw/RP9e q5EV6wuSSP9j/vzMJpmaxfh17NcbYmZfA0Sq8iEfl9gXe4d1HuFN3yi8M7LlGF+ZjPIUkDd9Gpzz uq+kwSL8wcU+3Qs5Ls98Z0LyGUzuC8xgD2VPFEjqF599mNjjX/C6qTVfcox8G6u3vCiC3H/kkJ1X b0xpQx/9AJDg2CqhpEDwJlfHenyzt8fFiPBH8d5gMFU+jvy41d9wD2vC6cfN+EBBjxiZqG2enIvQ 9V1b98Evq5Fv5fXtLAyTrbokHJq5LRGlKQY5KolbBUnn5Fyg0j1QNEawl6uNBs1Jx1Z9CGNSKKfW 4AoYKDX0rAuN6fbkWgpb9h1Xgq7lb4qqoaIzkeP2C42xEeuxiHhh3+httfYVt5Y6fboHAF8lD8b4 nr7+bytr4nhYeEhpmZHcF8+JaqTqcOyxxUZ5fHlHn39VfiEPHCCzSMUnOvXNeC8jDdblnr7YyFSg /XHs5HTrJsNRcfj4bZjFyf09Q4/6bGxa4dwL44NYbgtAqZXfm4Jnspe8iXnxDa0qPtLGuRdvrLYg ZB+0MZXr7OmN6SwZMRfg5ZiJQUx2GNYI0lk9/LtE19+qN8lNMT6rYk2cZCGLtDkew+/TwdAQ/NjT iGpaOB4crgwNNYvcvxR/7UOI4M08Fu87ri/CHwTmFZNL5PcVyIgG0M2QFV5UcWs8aowAUDQkNF4d nz8uEbqVr38hNpQ0MfExVQMCI3AfgO39LNZnYp6Rp6bURcfrqOQ5t2Km0sw+0HSp7Rrpihdj/cn6 4pA7LdywvlVP3jBJ2bxM8OkQzpIWfn3ec5qX5vv2Jp2BnUGrxq5CigaGV6pnmj7VPu0NXcIjz/Dl 0QMSlAMPCifyroX6C2ySBXD30k0O2ZmeS2g9jsM1bsn5w7lGO/q93S9OQ3ufqbgN2N4eqMkfOR3C p5qtRvA0quvBwbZOCZiXRIg6idscolctr1KDc+ZesaTegcBkHV7FmTukPvF+xT/LQQEj4Fcw7CmW fT1sk96pZCEqLC5bwvzsig3ZGvBrPfjKlOi35k7Jnrb568/1qNrVWMmPy++x8bTfqGBWVgDoct0d 3DPyizWzO5QRpq3AEN992NMi17dQhptLnSa8cWxtWFjIdNpKr82128rXaum6CeOYtNTVHZq171sI dLiZPCajUPTuM3c0MExXRnxyjYdFd8U4M45uJK+OLlwjeflwRGlinPnJFk9llE2Xgl4T0TqNOb6r uiMgNyLJTeeEH38QOnsnMqgYnGAicFAISJJ+xraYTca3EUNrXqaNvdn5jvhbGlHJDE9UnehrJZQ0 La2CQNqev5M7gcNDif2Wm0/3oZnNw3W9RblJ0pwvv6AkdgWdEbdv6rFJW1pJVTUNTJkKUfSQdBmR f7bdUEOKD9Y/vRZSp++dWCuC03+kyrPKR3RLX5orSXEzM5Ao80GFBfEjXPHX6ZbD2OmVyzUTQklm 2qE2RvweFg7pL8v7NS4NmxAZ9HEyxUPLmDc1oeC0F8dN8E+btAGVF/yOFPHGjzRiJfBML80pMnAl 8QbeZqg/HqX+PFiqn7sW1CMtMryanauRyni5dGvKmvQ9ldTCWxXytaIvCZIgtoADL5ZnbUmV5NXv bRGbIbk96NsrrFzeGSoVQ/a7iktGi1mXEkGYmNIDsNZ4xq2ZDUrmsgYnh6avynvAlOzogLvdC5Oh lfesLPFT6aRSrRPCV2Le5YcfsSoWRbGrNRALGL4xknpQ3vY+IPPxHLXzRxnjOlUzzLigWFE4x4zm nHWUTTSxFTrRVx9AwpAYd29u8OGzoW3X9KnTIO6HIaWLRdBZTJq496n2El9xmURwIfu4d1XC2xoZ o7rJGVSuJ/CbwRAvZUW5h4y3Lm/7eqmRhxN6uLl/esVs+f72I0zd18iQ2BLSDifwlijkJalOgUgr g8yjo5cViOUranQI1pZDc9MHUuF63c+4bni4CxMAUpFiibIFwgS3bN02dLh7k0d1YyRZPMQkrF7j 4isxexI807SW0+yOJTbXuxiZlS5qminXkVw+0jtWJaTtNflUVEyuyiHGyp+YvyZHUzWadQvx2qTU 0lGeujY3SHnrnV7NEyg7fPtqscvbPCriI+sMxj2e4pz2e8OMEl+0XgQvENOrgq4S0U/02onzAS7B sZ3JHMPpyuNy89Ucem0XJnCmL8m8ZPD6++Nu06wS5pmxpYaYpD8jNm+nShFA7Ge9+hFs/uAaC+Ea 42jzbqAGcdas07Rjscel8dL6BdVXnaqwNWEaoAy79ut26e/V10HCjv57j0oThXlqphVMtOvfbY49 nCphZImKAhIctdwLfBWq9iHonnur1VfIHq7igsFodah/bnkW3ulA5r0xaKJEpBrXbGrcgL4BQR+5 osb7T0QfTUlnnzG9yl5yCuNGRwemi3L6EvB0Co6Y9sRRzxTnjJy4nt59Jxhvey1ziectqxyRuACS 96Iacy9Do/gz8Q1pmgKATbAAFx5MKMY30JB2o2v5iWgAyrZPbKpIaqHOtPteK63ji1n8gqfVDkOj k2l4SvzpimtUsaILDRO+YpQNY8vf4OCZSsS1Ho45qQtjWYOnwT3XEc/lSSIkmeOzILu0BSlO3i3B aagaC2twoufQi/Sn5BLVFquRNNFeN1JxFA86U2db2vSSII9QRk83L81MZ+pATVzV3Let5pyDL5j2 s1ndAsLhUVceVj50WBqJ8lRvSLix/rA2R0J+Ig/GDTl9QYXlQeT2Nk+7LgHdxgHhbjkv2Pl7jogL WqOM8gSI40gQcZM9RYSk926yMEoWUD6RV3vJccP4jlumfoXFYrOxCmV6FE/3F9L6pqhxEwIPVMmE ydXUvQZc3/etneszt0N8bO6vDR/K0t0nbNyiufBxUeaJJVBTmNmHN/7plcu9YjGLad5PskoQ+wLb 2VKLzrEM3m1sbqo6C3cDvKWE28vaonrBBdkD+l+8ZKZPZ76Pf9s7/oG/YSMbn/fyjsMuZ5cZQF5n 3n9hb2+YqTnaRvZ9EqeaPXWByqzAtKX0sth02BpV4/GHlf3v6D7pzvd9hqj4HxwXesPFU6z2a9wc JKT1j67JqYINmOmfMx3O3GJ4G0rdI46zgQgxPLmeD9+g6PqOBmU5T3ycKyC3iSW7Gv2F7claC5m6 Pn/q6Dfp0ElA1keWHykZxvLf2/FQbv1VTSMAgwcbg8qDb/ujqmpvFXa744mYj5QnWGa9Q6rSyRWK di0pPo92j3+b6TgwK8Ney1H+3GzsgWkiIP0qsZ0B8KrQN/yOcokpjj1VCcVOCnincQAoOPH+bme/ s7/Fp3cED93dMTdSvsZe9ZtLFwSQBPpS4YyFb+qX2idfWyaLur5oGbFGbh3x7RnB6XVvMOnT4IBW YTMKDf+HC2TbKwNe1Ut97R1qPNBXS6TfhfgrUqLJo4zGVu4y9ykqHexhGEsH0o8YeN+Rvl1+S6wT kYQ+qKPrnPbhftYYvYcsfY3HdlWc+O16mm+D1MR68JfKOgWmUzO/mvSqnqm2ytmwO7tq7SKpMvWq me75nT/oR4rorrnlVRJlaSaGX8zigXfI1kf6dGl7mFJXVH1+yKw1FgZY/o78EQQRjQv0ksQVhlx6 5fla1vjWHBW+7E65+eqF2ZMe1iuwpcP5t6e8Xo0kXWid2kM7jN/iLXeSxAVvlo8Kb+3sHw5HSRZg IV0YMZ6Wo8asJV3pV3o9TATJwye1A5ZGb5Qr6maLgNza5tIyb5ePXgshOznxMoJz9VD2OCFS6OQV Uwa/Kz6Yz6MX21PaDXPJFcxXFFHT65KBzSmXFQjdUNlcAdKc1FN+71pLQvHPPrKQMQHpxsBbg1e8 XvRYt5OLMhpVzxKm65WBkwIE6vkuJL26sG122JaYF3L3hz/Pu+TCo1aG07Z7m/sRIk7iFLFLaGvW QErk8SubIGyT54uULcPrboO+SPMr2Zv0qwI8fL43fDYDIj8zDu005kjIzj+4qKa2zwUrpc/Xy9Ua Y7ivVtFhOCeYnUjtlASe1a4X73x7iUjbz+9CKTMHfl+6fdKDmrC7DS5xxt6RpYdvL7a8oYKU0tV8 nJ02LomdzCJ2DFBNyLG2pUTtwxKjNB6t1s2KXozd6VsYHQ3+0f25PX7wrkiSc05VtcXc4oXUuIaN 65nfXiQkUBPdqwdAatm+EgQrRKNbct8fK4Y+Z4PJ59fFOS7IcuBBK/oAqT+eFLyp/KQz2BdU7CZc vHePAEy+fqn2O5EEvuO1CuNRzgyNYmXxLYLwMNZcFfqhPteIUGOxjJapRG6CDNsu9JRSGofKStEI vZlrBoeAyNzs5ML1LGn0j6gc2uMhGtusli9aibhnvSu+mLyYcNP1yawInsvGo4n3GO45zGgMye6f 5BR+7a+dJHmYyU7C+tVCDJc88ro0QrvC69sYy3TGjm216yOYtCx/HoU14bzyxwEIMdP8/OPv0JOK q82RC9cCyOFrstrHvQ/5rffuC1wjSktRhHDcsJcU+/7dvcwp2F1towCUToDzkOFxLwsgZayogeZc 66zjU8F+lUxDi7huqF1zyEZXtZQp7O0Ffyfhqxjorfc6rSu1pDoY5nv/bI77mHmzKYGuw9Ipynp3 23LBih56K7/rSJzn8RefZny6gavmfbjygz1vm3v7UxzwMY5Xi01DO/3vDsJyzRWC1mq3vjiIJfuS LlRBom0KjbOWRM1SDHofjiFtRw9Z39UNbN3+QKVdVxZ1IbkW+pREIOf28uZESOCQaFiGqOH1l0j+ Y9NCk47dOr4mGQSzNCqA93OXSpiJHYdfE7d9Vc1tjJbvR2nkzanp50Xb1s/dr5tP4O/rcRObTRPk VETNPbvvQEGMWF8PPY4d0yhm+zBwreOWIfbbs1HNKAKKdI3vEfwTdqk5y92euxoToUUJgMGLQ+vP 73Pl4V5VBsT4ph9e1zdUlxjbMYsOra38Es99/AS8WatLyB1wpUJ/+OPDkQjbzZ3iUPxCm+Qteemk Q+dBogkT7pMAUNtzK7pVrdo93q5eJQTs6vJnZy0LmvXeT4d11FGED+UC6iTzuBV6UB8k2UtjLzaS 90+tvzIfI6YRvzf5mStqtV92oVSO9tPF/u/5CcxhiSa8OojS/cSY6ZblvMomX4E47yp6WaHYtwfh sri8xPwc0uPlA/Perc42YoOvg/aLbBGnz4YbbcXb/Ucni2pa5S8xph0TkESQ7lc41Vp2pqjxshA2 hjwGydnOxo4Ne91H+PCbTubfvHXTsU2ZdGh3qYREDcL1o2H1tPGUxJOek0FBNSqOirsFrzOiuCXb X8E00FB802bu+1d6AMbdzgfrjUG5ndc8bJ0BADCIC8R1XgODQBCI2D/44N/5UlJAwwBPDFDZwx2r hPFBezt5Yj28fza1UW4YoLaTmy3OR9/DTdsDoSmsj3HAAYDKrigHHy4I4KeWgoKHv4UwGCbOJSwq DuYCg8RAXAhRiBVQDYtydULLuzu4YrhAAKC8Dxrjjj0XAYDnA503znsAgIooT1WMk4Pj70IDLMbN mEsc9Jt5Zaez7ogzZ/UBMjL/cF/0H+5rYtwdsI5c4nAo8EwZi/E+9w+LUcKgPewwZ31+XxH/NKuP ve7j4peIP7/NUOj21TOl3dChZCJRNSMoTV5+5sTZWJIyJMfDGlXWMW4SqZLeh314cDe+UEYfsozz a2jg7K/ak/2wcPDAY/hDgJTW4d42jN1nLzmjfy7XKe/Dob9FbNfpXPdMrXn/N5k3DVPb3ccH2E/u JivAnZqR8V3rkLs53eiTavOwp9oBEnH9w5Eek83BPzZ93550AAPeGO05V+VpHzoV7ozMHH2buVLU bZWxrrOzvLN2/CG4e4Oivt7GZzhx7k7C3EKCTVEk+in1nI+120qgiVskqqprbjnOR8tq52l7zty3 5vKxyurKQvTbJz4G2z/AS4k1SOoefLNkYrMU+k/JVJ+WJj72khzGrvl1sC4OcqTweNtqd7D7RL7J cYubKHurwpG8xOFOeIx/Ihd2Q/Y95+cLu6QHf232rXb8jfPPTcYj4tBMm/99YnJEH/rCZuZ/m1Sl +tDvxYTemv4CP/g3pEo/438mQ5zEbvkdsYfmTM/8r5M4rLI4TzpNn6pDhFjTp0oq14d9h4SCY6Xe nYunFGZC7I6wFxclLw7c7KBWwoqLUOg6xQVv3VD25XpOWCK4tqDB8a3ni50S6R1Dxt3G+w4v7uBu aLt1ClsrA3qqZYTT5XtbbmozfWm5XSpUuhyL28wvR7Vdf9F6T14TyydOl455pxVdJpX0iAflje2O UA5qP1OOLKTEjs9MFWre9Y3z+pKw5unb5vvmoC9F47vo0xfSpeyL7iWP96XHUeuB9sl1N/fAJ98X okl1dBy2drt55XrrpfKuUtj2+5lIhQS4GzAkhQaIFHKa5qikZ+6+uPrkXfHQuz3CFcpXYkK4zXWS j58unKbbjcqVNJ+OJefNjUN6n3gfMuv6olebl8Cn3zVmAmtmC7e/0XmOjFL+uzwk9m/yDdAAZ4s9 b5xzwEAFlA/mJ/vf5RxDDyN3p/OI5voZ+/pn2cHJ2wer6IjyPmsCNVG/10WhUADQxMkO6+hjcZ77 /os/wH+Si0JBXGJiYlwQkDgXFAT6WcTP2nC4+E/+H+WnDAbh+kP/nIrCxQF/9PlP5Uz3Zzm38UeB QCAAhCiYCy4qygWDwX+Wn/WzzA2Fwn7Wz8tPH8QRf8rEf6+fFcAfeud9z+vn8j/6ISCQP+vn/J9+ /z4vCAxx7hfgZ/1M79zHv9I/5/xX33+vw+F/rtWf8//DR9F/yH6O+0f93CZE/Kz/ef2MQiHg/4Xd +c/yv/oJPl+Dv607WPwf8/pzL8/W6awA/rZD0HObEOiZzh9nAgL5s+/Z3fr7z097ANA/nY5/V0D/ pnZWAL8b+a+ndb7F54sN+5P7x8aeS8TAf9U93/rfWueL/wf96wb8oWsF+NsbgOvnG0H/r7cu5B9B rHx21Yv9y7UM/YvCmTGunz3OYtVUx9YZg8aesdXcztbtd7tAXW8PtAEGawHUVVIGGmL8sWdilANG 8Tei9htRsPqnIf6WR3TPNM5+vM+fE+cT1AfqY3w8cN5ojA/XT3f0gVoYOyfU+Svlt6U6O/MIUSug ircHzvPMigHQ0Bvl7uN5bgIdAFQ0OHud+DqhMfoqCkA1Lqw37uwNAVQ8m8zZCD5con9bEuh/rzuw v7kj/m/c8QH8iw+AfzjB9RcvuM7OgIaTnY8F18+d5/qpe85U9MCdzUf0r9sA+9tIiqiz556Hw28j /jZ1AFDHE+Muj8Y6ebhb/GYRaGpmzuWOc3X97Qd0ZlsT5e4ggHEXNjK4+k/7DP/HAPI4rKOHt5Qy Uln57BV7FiOwswI/yxawszYMeXaQFM8uG+yfKlD472LEGYWcUeh5+7fzZodDY/40pfibDkz0d/0z Pci5Sdjv5Vwm9hv/TAwSO6fIMwr+Y8izmSmdvTUFlCREQWDE2dNXHAwSBYtChUFQfhCI/+pfJuTv jbEHnOccAOhPcMGgUDEolz3XTx4YAodDz2Ljp8Sd6089MOLvPAhI7F/0ICAo9J95Z/bEEfC/6UHA YDHw33kQhCjo733Fzyz+qx4E/Hc9KOTvY5zxoKL/qgc/v7j/mQeDQf+lLxwm+i96cNi/zk38zOS/ 8EQhf+mL9UadfTx4n58gA6fAs4eDOFDfw+MsKcF+O51q7vYeXD/P2XlDicuCSwosD1cGQ5BguCJS EQwVlxeFIZRACCWIkpKSsjwIKSYD+M8q5wGj5IFWdMSgXXxwblxAJXkQHIEAQRUh8mAlMYi4uJKY qDwEoiAGPjMipoAA/PxIOXvW/TwiZ7OAQMGAK1eQOsoAvF/4/wU0MTh3BxFPO3sRlA/6/9AY52EB g0HOKRgOBf+V/oweKAiMBxY7i10IWFQUDMMDgUXP8igeF+j/kD//BNx5AHBx4aHPYtYB+z/X+0/y /0shfA4FpIqaNpeuii6XgZqKtryhkT7yJx8AcNJTC1SQl1dQlJe3U3ZCIvV9TJFIVSMzsL0+wg+i oq9r4oZUcFVTc4N7KMu7Bvh6+kDkFR1c9P7gA9zgnupmekBBNXsTA1VXmL+CfoAg0NzFxxsTqIBz h7pAwK7YwEB/JRBIWVfTUdMBoQnEiomhEYEKumiIkzIEgISZQp389O0MMc5APX1lPZCirZu3Ps4V 54QMsPN2QNmrKmq7+GOAHt525s5wHS8kREwMpu6Fs3fXhJiBXDwBTqLaotpgjCJEVA2JMINBvFQx IFyAJ1TB39E8QNMEgdbzUZBXwKnKoxRVYKbiIDeEvCEGCTE3Q8OVMJpnX4C+/i4+WoIqRoaaHpqm oEA/kDvIzF0p0ByIBDlhxZVVNFB6qiZ6CDEfZ4SWEiwAgVQLhKmoOqrpeWkggCoQd4CegqezC8hI FGan66st6ufs7ufgb+sB1UBjtd3V/X3tDb1VVLw0BM0VwTgHJXUlOzcUylHMXFnXTMNJ1QSHdgQ4 yfuhTNwUPcV1bAV9NMVwSm5uSmLGan6aymjtAC09D32surgH2kVcHwzyc3ZGBYDVDBDyTu4KYE0I SMfc1AvgoWCk7e8vqKNnqq2thFXwVDbxxYE8tTShXl5OGCjGEGSgbORqrB8A19IwddSD47TE4YZw ZWNfeQVlH31FHzeApxfcBKmvAFPyMDECeXnhMFp6tvKeHpr6CLS+MdgOBXF0g2s5Ggr6YP189Rxc 4Kqa7nrOOEM7sEeAGNzBSRRgaos0MsGIQVxh7kqOtrrOOAwcqQNRtvM21UMZOJjqYzxEvcG+xjqK qqLmIJCPgZOdBtxAVUNHXSlQVMnW2BygbWzgpO2sgICJatn7mPthtVQFgUbenmIwGNDQDe2qAlbF mGr6u0JU1YwNvNWwsAAzNX8wVstFR88RogaVtwMoeGE99NyUA4xAvoJ2TraGgnaKcD2MmJ2igj0G ooPBuKFw/sogVR07XW9VNaASQt7MTxogjXNX1wH8DAakttK/C5H/7gD+fwhVHyeM439z/ofAxH7m /7PHFujsFXue/2Fw6K/8//8G/uv8b4zx9jn70pDgUnHH6apw+YJ/3gjo8xtB3kFeRUFPHY11doDJ y3uoI1VUIOo4R5iDlrOJm4qWLlAfJu+DMFLRUreF+8HM7PV0FYAIJV8YQNlW2QsiCDUG6gQ4Gvlj 1Q2NgWAXoCBUQwMFNHN10kchnZUUIZpIB10tXU0xI3clD1tXQXsEVkzH3cEIhpIHBASIyTsoOwRi 7YwdMXB/kAva21Rc0FdHzMPB0RXihXI0VTdxU3Xw9zL0dUf6gOSdFWw1tGCGBv5IHQOEhrcWAOnh ZA5VcrU1NANhVJ0VcXoOmhB/mLe9PlBQXBWsqAfW1dcPxPma2qq6OeoFYBx9NXxA/l5evp6urkrG CDs3gDsapOimo2qrq+SCNnJQ9lNV1QQpaulgAgTF3NUDNTRt9R0czLS0Df2hOtoOfmZmSqpnqwcC e/pqnd2c2jgtgLu6qbKzB9rewBeH1nGSV3T2hLgZG5iJe0DsVLUDAk184HBDvwAsAmuo4+sQADZz lFeB2vr5eYuBnHFeUC8swNhOHGngbuipDcTC4a4QHTVtPbSDloYSHILSFITZuTqZeSvDNJRcjfUC DZxFYVA3LxOwmznc3FRQHCIPV3QHeKv7wJEOSAe0orehE87UxMDTXcHHD+2GRvoqYwN8nNWgdiAt NUF9RwM9f0+jABMHJ2NfUQNVczDKxMgApRJ4to3OAYYaYAjYXhMHBZmaKKDAqvYqzsY4UyjGG6fj 62ivqIyDq8ACvTBm9ih7Ww0jD0dTb00UEARz8TH2QgJ0zJ0EHQIN9UTtlQ28AtGqJmpIuL25uaan mq2hlj4Cg8AEeuo5KkPUtc1MnJy0DRVcgXB5cQU1TVVFW1WkOxKgZiTvH6jjq2sOV1Y3MECL6csb ibnoQ+xNUKquYoKGZ0PBFXBebj6OCL1ATXcPDNjE09sYZKdjBgwAq2AddAC6bq5YRSxSywR+9n1m FgAxVvOwA0jr+iL+P53xf+EXfuEXfuEXfuEXfuEXfuEXfuEXfuEXfuEXfuEXfuEXfuEXfuEXfuEX fuEXfuEXfuEXfuEXfuEXfuEXfuH/ZvwPrlZN8ACAAgA= ------=_Part_463342_410230257.1600022640969-- From debbugs-submit-bounces@debbugs.gnu.org Sun Oct 18 13:03:12 2020 Received: (at 43117) by debbugs.gnu.org; 18 Oct 2020 17:03:12 +0000 Received: from localhost ([127.0.0.1]:38983 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kUC5Q-00059w-HJ for submit@debbugs.gnu.org; Sun, 18 Oct 2020 13:03:12 -0400 Received: from mail-ej1-f66.google.com ([209.85.218.66]:36395) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kUC5O-00059h-MM for 43117@debbugs.gnu.org; Sun, 18 Oct 2020 13:03:11 -0400 Received: by mail-ej1-f66.google.com with SMTP id qp15so10603403ejb.3 for <43117@debbugs.gnu.org>; Sun, 18 Oct 2020 10:03:10 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:in-reply-to:references:user-agent :mime-version:date:message-id:subject:to:cc; bh=XzcwjSFKB+Z8uBVV6FvWu8B5rUOiEQyeRzP8YcMeDCs=; b=TFG7j64rOF8YuQU7WxEIFqokIKWWwfoWsi0lk/AoElAR2zMDRzTwLgfrHglzNd2dRG ewCov9nT7da0+6S5s/qpsvl/3LqjySX5eOjAqdZXMPJHAgevOSqGnzFTOLwlv/HWH7y6 JCJ2BHozBeH3pPqMKmNmCt9aiaGRvxOpED6POu/lce6zPlVx1fZTbhPcjGKW4EoZyWbk hVyPAR6H5/8R7/EQp7vW01qduH6ueTVKTkGdC/pPLTLtnUgktGcTnzEAPUtbNRBlzGRa 92i3PcpjEbiSPlpg73Fzq40ZDX4slHF+O3NCozb00oG+LIdYXoBm5qBrgUnY01HtBUCG 9dHA== X-Gm-Message-State: AOAM533ez7eBS+qA1nmynzmByccxT71K1rtKjnYVRMjbdQGIHYCdJFaa 5tT9y4UFx+UrsxLaXd814fawZE1z/8QtofRYXpU= X-Google-Smtp-Source: ABdhPJwxTv+ycKMQ4fTbgy9exdwkpg/PRMR5zvP07bDeePyT0QiMjw0EL+ToN0WPfSXLAR+4zuZPgk72nGVwL90s9Sk= X-Received: by 2002:a17:906:1246:: with SMTP id u6mr13343632eja.432.1603040584911; Sun, 18 Oct 2020 10:03:04 -0700 (PDT) Received: from 753933720722 named unknown by gmailapi.google.com with HTTPREST; Sun, 18 Oct 2020 10:03:04 -0700 From: Stefan Kangas In-Reply-To: <1357196034.463572.1600022946152@ichabod.co-bxl> (Brian Leung's message of "Sun, 13 Sep 2020 20:49:06 +0200 (CEST)") References: <197409406.192953.1598809591346@ichabod.co-bxl> <9aa79095-18d6-d0bd-18ad-aa5d90f0bb1d@yandex.ru> <1898378843.430816.1599957743795@ichabod.co-bxl> <83bli9db3t.fsf@gnu.org> <1670898213.459425.1600016799389@ichabod.co-bxl> <83h7s1bmy5.fsf@gnu.org> <87363lh856.fsf@gnus.org> <1357196034.463572.1600022946152@ichabod.co-bxl> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/28.0.50 (gnu/linux) MIME-Version: 1.0 Date: Sun, 18 Oct 2020 10:03:04 -0700 Message-ID: Subject: Re: bug#43117: [PATCH] Add .git-blame-ignore-revs file To: Brian Leung Content-Type: text/plain; charset="UTF-8" X-Spam-Score: 0.5 (/) X-Debbugs-Envelope-To: 43117 Cc: Lars Ingebrigtsen , 43117@debbugs.gnu.org, dgutov@yandex.ru, Eli Zaretskii , rpluim@gmail.com X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -0.5 (/) Brian Leung writes: >> I don't think these purely >> stylistic rewrites are a good idea, as it means that "git blame" and >> vc-region-history gets less useful, and applying older patches fails >> more often. > > OK, I won't submit that commit then. The other commit I had introduced a > .git-blame-ignore-revs file, which allows certain commits to be ignored during > git-blame sessions. I've modified that commit accordingly and attached. Would > that be of use? I think this sounds very useful. And it works well in practice from my limited testing. Does anyone object to adding this file? From debbugs-submit-bounces@debbugs.gnu.org Sun Oct 18 13:18:40 2020 Received: (at 43117) by debbugs.gnu.org; 18 Oct 2020 17:18:40 +0000 Received: from localhost ([127.0.0.1]:39012 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kUCKN-0005XF-Po for submit@debbugs.gnu.org; Sun, 18 Oct 2020 13:18:40 -0400 Received: from eggs.gnu.org ([209.51.188.92]:59326) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kUCKM-0005X3-Is for 43117@debbugs.gnu.org; Sun, 18 Oct 2020 13:18:38 -0400 Received: from fencepost.gnu.org ([2001:470:142:3::e]:46748) by eggs.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kUCKF-0004rF-OA; Sun, 18 Oct 2020 13:18:31 -0400 Received: from [176.228.60.248] (port=2369 helo=home-c4e4a596f7) by fencepost.gnu.org with esmtpsa (TLS1.2:RSA_AES_256_CBC_SHA1:256) (Exim 4.82) (envelope-from ) id 1kUCKF-0005DH-1j; Sun, 18 Oct 2020 13:18:31 -0400 Date: Sun, 18 Oct 2020 20:18:35 +0300 Message-Id: <83k0vnqwpg.fsf@gnu.org> From: Eli Zaretskii To: Stefan Kangas In-Reply-To: (message from Stefan Kangas on Sun, 18 Oct 2020 10:03:04 -0700) Subject: Re: bug#43117: [PATCH] Add .git-blame-ignore-revs file References: <197409406.192953.1598809591346@ichabod.co-bxl> <9aa79095-18d6-d0bd-18ad-aa5d90f0bb1d@yandex.ru> <1898378843.430816.1599957743795@ichabod.co-bxl> <83bli9db3t.fsf@gnu.org> <1670898213.459425.1600016799389@ichabod.co-bxl> <83h7s1bmy5.fsf@gnu.org> <87363lh856.fsf@gnus.org> <1357196034.463572.1600022946152@ichabod.co-bxl> X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 43117 Cc: larsi@gnus.org, dgutov@yandex.ru, rpluim@gmail.com, leungbk@mailfence.com, 43117@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) > From: Stefan Kangas > Date: Sun, 18 Oct 2020 10:03:04 -0700 > Cc: Lars Ingebrigtsen , Eli Zaretskii , rpluim@gmail.com, > 43117@debbugs.gnu.org, dgutov@yandex.ru > > > OK, I won't submit that commit then. The other commit I had introduced a > > .git-blame-ignore-revs file, which allows certain commits to be ignored during > > git-blame sessions. I've modified that commit accordingly and attached. Would > > that be of use? > > I think this sounds very useful. And it works well in practice from my > limited testing. > > Does anyone object to adding this file? I don't think I understand what does this file mean from the maintenance POV. Who will maintain it, and what are the procedures? And what should be done about it while merging from the release branch to master? From debbugs-submit-bounces@debbugs.gnu.org Sun Oct 18 13:54:11 2020 Received: (at 43117) by debbugs.gnu.org; 18 Oct 2020 17:54:11 +0000 Received: from localhost ([127.0.0.1]:39042 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kUCsl-0006NW-5m for submit@debbugs.gnu.org; Sun, 18 Oct 2020 13:54:11 -0400 Received: from mail-ej1-f65.google.com ([209.85.218.65]:38759) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kUCsj-0006NH-B3 for 43117@debbugs.gnu.org; Sun, 18 Oct 2020 13:54:09 -0400 Received: by mail-ej1-f65.google.com with SMTP id ce10so10721385ejc.5 for <43117@debbugs.gnu.org>; Sun, 18 Oct 2020 10:54:09 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:in-reply-to:references:mime-version:date :message-id:subject:to:cc; bh=9q87hZS9bUM6QEUuQQv0t70CtXqkLbX0kYSQLUSNxjk=; b=X662PhjNKjTwj6yHe3L1Zgy9Lq3bLWsU3FPsO9YQluSCMW95IoUjORX9O9j2ui7ytn kDBvLv0ZTKZQyJiZs7VBtUUh2W1MMZ8jmLv+wtwnOLCHhxhbjWPsoJcV006GLjRBcFce UJBAQG69/4YsRWCnBo4PU0L6RlFCjsjQE60ihTTaVHEN3RBO8+Appxgyy34/oDBYJvVf KMF1RYeA6b0UWA3tnJtAG2KhkI2Lc4r5baPnOekR9sg5N+k8+OgScpgE+37V3UwhB6JP dXOS9ecY049UsAXbKBySRt7klhFh1I+iyYkqZ6o1iwkMrlHFC7g/5QA/ly8sl7ikiJrf /jhA== X-Gm-Message-State: AOAM532WdYldhr71QFm4osPxT12JY9ASPmx/5r31lYfVrCwXESKVRgsE aSQhCD0dQUB9Q0HUwg9us2lkAsaxjfzSWp8LC+Q= X-Google-Smtp-Source: ABdhPJwHOXohRWAqJt2otDkE10Mq5/ePh3PUXMWAUbBm7xjIgITOUb4cmgnZYpaIkslHU8DPRwT35w4iBcZJzHIs3N0= X-Received: by 2002:a17:906:bc91:: with SMTP id lv17mr14140447ejb.249.1603043643576; Sun, 18 Oct 2020 10:54:03 -0700 (PDT) Received: from 753933720722 named unknown by gmailapi.google.com with HTTPREST; Sun, 18 Oct 2020 10:54:02 -0700 From: Stefan Kangas In-Reply-To: <83k0vnqwpg.fsf@gnu.org> References: <197409406.192953.1598809591346@ichabod.co-bxl> <9aa79095-18d6-d0bd-18ad-aa5d90f0bb1d@yandex.ru> <1898378843.430816.1599957743795@ichabod.co-bxl> <83bli9db3t.fsf@gnu.org> <1670898213.459425.1600016799389@ichabod.co-bxl> <83h7s1bmy5.fsf@gnu.org> <87363lh856.fsf@gnus.org> <1357196034.463572.1600022946152@ichabod.co-bxl> <83k0vnqwpg.fsf@gnu.org> MIME-Version: 1.0 Date: Sun, 18 Oct 2020 10:54:02 -0700 Message-ID: Subject: Re: bug#43117: [PATCH] Add .git-blame-ignore-revs file To: Eli Zaretskii Content-Type: text/plain; charset="UTF-8" X-Spam-Score: 0.5 (/) X-Debbugs-Envelope-To: 43117 Cc: larsi@gnus.org, dgutov@yandex.ru, rpluim@gmail.com, leungbk@mailfence.com, 43117@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -0.5 (/) Eli Zaretskii writes: > I don't think I understand what does this file mean from the > maintenance POV. Who will maintain it, and what are the procedures? I would propose that we treat it as an optional feature rather than striving for it to include a complete list of all "uninteresting" commits at all times. Even if it were to include only a proportion of some of the latest "uninteresting" cleanups, that could already be of help. When someone stumbles into a commit that gets in the way of their git blaming they could also consider adding it. > And what should be done about it while merging from the release branch > to master? I don't think anything in particular needs doing, since the sha-1 will stay the same after a merge. Or am I missing something? From debbugs-submit-bounces@debbugs.gnu.org Sun Oct 18 13:59:49 2020 Received: (at 43117) by debbugs.gnu.org; 18 Oct 2020 17:59:49 +0000 Received: from localhost ([127.0.0.1]:39050 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kUCy8-0006Wv-W9 for submit@debbugs.gnu.org; Sun, 18 Oct 2020 13:59:49 -0400 Received: from eggs.gnu.org ([209.51.188.92]:37040) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kUCy8-0006Wh-0P for 43117@debbugs.gnu.org; Sun, 18 Oct 2020 13:59:44 -0400 Received: from fencepost.gnu.org ([2001:470:142:3::e]:47325) by eggs.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kUCy2-0000yV-CD; Sun, 18 Oct 2020 13:59:38 -0400 Received: from [176.228.60.248] (port=1062 helo=home-c4e4a596f7) by fencepost.gnu.org with esmtpsa (TLS1.2:RSA_AES_256_CBC_SHA1:256) (Exim 4.82) (envelope-from ) id 1kUCy1-0001y8-KD; Sun, 18 Oct 2020 13:59:38 -0400 Date: Sun, 18 Oct 2020 20:59:41 +0300 Message-Id: <83d01fqusy.fsf@gnu.org> From: Eli Zaretskii To: Stefan Kangas In-Reply-To: (message from Stefan Kangas on Sun, 18 Oct 2020 10:54:02 -0700) Subject: Re: bug#43117: [PATCH] Add .git-blame-ignore-revs file References: <197409406.192953.1598809591346@ichabod.co-bxl> <9aa79095-18d6-d0bd-18ad-aa5d90f0bb1d@yandex.ru> <1898378843.430816.1599957743795@ichabod.co-bxl> <83bli9db3t.fsf@gnu.org> <1670898213.459425.1600016799389@ichabod.co-bxl> <83h7s1bmy5.fsf@gnu.org> <87363lh856.fsf@gnus.org> <1357196034.463572.1600022946152@ichabod.co-bxl> <83k0vnqwpg.fsf@gnu.org> X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 43117 Cc: larsi@gnus.org, dgutov@yandex.ru, rpluim@gmail.com, leungbk@mailfence.com, 43117@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) > From: Stefan Kangas > Date: Sun, 18 Oct 2020 10:54:02 -0700 > Cc: leungbk@mailfence.com, larsi@gnus.org, rpluim@gmail.com, > 43117@debbugs.gnu.org, dgutov@yandex.ru > > Eli Zaretskii writes: > > > I don't think I understand what does this file mean from the > > maintenance POV. Who will maintain it, and what are the procedures? > > I would propose that we treat it as an optional feature rather than > striving for it to include a complete list of all "uninteresting" > commits at all times. > > Even if it were to include only a proportion of some of the latest > "uninteresting" cleanups, that could already be of help. When someone > stumbles into a commit that gets in the way of their git blaming they > could also consider adding it. We already mark such commits with a leading semi-colon. Will this file simply repeat those commits? > > And what should be done about it while merging from the release branch > > to master? > > I don't think anything in particular needs doing, since the sha-1 will > stay the same after a merge. Or am I missing something? Not all of the commits get merged. Some are skipped. From debbugs-submit-bounces@debbugs.gnu.org Sun Oct 18 14:25:39 2020 Received: (at 43117) by debbugs.gnu.org; 18 Oct 2020 18:25:39 +0000 Received: from localhost ([127.0.0.1]:39065 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kUDND-0007GV-GP for submit@debbugs.gnu.org; Sun, 18 Oct 2020 14:25:39 -0400 Received: from mail-ej1-f66.google.com ([209.85.218.66]:36391) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kUDNC-0007GE-0v for 43117@debbugs.gnu.org; Sun, 18 Oct 2020 14:25:38 -0400 Received: by mail-ej1-f66.google.com with SMTP id qp15so10808852ejb.3 for <43117@debbugs.gnu.org>; Sun, 18 Oct 2020 11:25:37 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:in-reply-to:references:mime-version:date :message-id:subject:to:cc; bh=5h8NpYTsBohqSmgHDh886ZtycPajSJizGR5G+aLD40A=; b=olYC9ZLXCkM3JX/XF//nZ+kZpuKhg22JCkURxNehu4riST3v3isuem1lO48RpUcE11 1mACe6mXEdLPnSpBl9wrMoWvbi5uGpuQQRTg7Ib3zfbaZrusid+nk0af818mnd/0JiV6 D8O/EYkgIsUiQGV5iFI77cBhkCtc95f3+X4Mi4th/yPl20iOZCKFPz7Emf2Gl1TXSevV NIqG8PisoVyx4iLcNcBDCbAAaEhHaA1s8gib9JJXn1pyHlpW0MHZVRZ92f12hshweMN3 S3L4Ylghkoib0ViLnr9KlV5L7oc7DGTy03RB77629vZB01icNcTpUkF4BrM0aohaXcik UB8w== X-Gm-Message-State: AOAM530AX/Z/SQK7ecyA+S2AOOLu9v3ca230BAp3mLczQ/zaN6lIc6qd tEuWPSPm8E314N9fLZMFQgJIon9gr7GNvV/VkeM= X-Google-Smtp-Source: ABdhPJyix/pFRYMDYuAQCTW2v+e1V0LAINyBkKusIEjlpXTHtbzotpWWSGQbUXk7U5+CnoiyXJhPh5700VsOWw9BXHs= X-Received: by 2002:a17:906:bc91:: with SMTP id lv17mr14247824ejb.249.1603045532147; Sun, 18 Oct 2020 11:25:32 -0700 (PDT) Received: from 753933720722 named unknown by gmailapi.google.com with HTTPREST; Sun, 18 Oct 2020 11:25:31 -0700 From: Stefan Kangas In-Reply-To: <83d01fqusy.fsf@gnu.org> References: <197409406.192953.1598809591346@ichabod.co-bxl> <9aa79095-18d6-d0bd-18ad-aa5d90f0bb1d@yandex.ru> <1898378843.430816.1599957743795@ichabod.co-bxl> <83bli9db3t.fsf@gnu.org> <1670898213.459425.1600016799389@ichabod.co-bxl> <83h7s1bmy5.fsf@gnu.org> <87363lh856.fsf@gnus.org> <1357196034.463572.1600022946152@ichabod.co-bxl> <83k0vnqwpg.fsf@gnu.org> <83d01fqusy.fsf@gnu.org> MIME-Version: 1.0 Date: Sun, 18 Oct 2020 11:25:31 -0700 Message-ID: Subject: Re: bug#43117: [PATCH] Add .git-blame-ignore-revs file To: Eli Zaretskii Content-Type: text/plain; charset="UTF-8" X-Spam-Score: 0.5 (/) X-Debbugs-Envelope-To: 43117 Cc: larsi@gnus.org, dgutov@yandex.ru, rpluim@gmail.com, leungbk@mailfence.com, 43117@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -0.5 (/) Eli Zaretskii writes: > We already mark such commits with a leading semi-colon. Will this > file simply repeat those commits? Yes, if we want the commits ignored by "git blame". But of course it could include only some of them, as well as commits not marked with a leading semi-colon. >> > And what should be done about it while merging from the release branch >> > to master? >> >> I don't think anything in particular needs doing, since the sha-1 will >> stay the same after a merge. Or am I missing something? > > Not all of the commits get merged. Some are skipped. Wouldn't having non-existent commit ids in there mostly be an aesthetic problem? From debbugs-submit-bounces@debbugs.gnu.org Sun Oct 18 14:41:33 2020 Received: (at 43117) by debbugs.gnu.org; 18 Oct 2020 18:41:33 +0000 Received: from localhost ([127.0.0.1]:39070 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kUDcW-0007e1-Vd for submit@debbugs.gnu.org; Sun, 18 Oct 2020 14:41:33 -0400 Received: from eggs.gnu.org ([209.51.188.92]:44160) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kUDcW-0007dp-3P for 43117@debbugs.gnu.org; Sun, 18 Oct 2020 14:41:28 -0400 Received: from fencepost.gnu.org ([2001:470:142:3::e]:47799) by eggs.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kUDcQ-0005pX-0K; Sun, 18 Oct 2020 14:41:22 -0400 Received: from [176.228.60.248] (port=3599 helo=home-c4e4a596f7) by fencepost.gnu.org with esmtpsa (TLS1.2:RSA_AES_256_CBC_SHA1:256) (Exim 4.82) (envelope-from ) id 1kUDcP-0006VA-G9; Sun, 18 Oct 2020 14:41:21 -0400 Date: Sun, 18 Oct 2020 21:41:24 +0300 Message-Id: <838sc3qsvf.fsf@gnu.org> From: Eli Zaretskii To: Stefan Kangas In-Reply-To: (message from Stefan Kangas on Sun, 18 Oct 2020 11:25:31 -0700) Subject: Re: bug#43117: [PATCH] Add .git-blame-ignore-revs file References: <197409406.192953.1598809591346@ichabod.co-bxl> <9aa79095-18d6-d0bd-18ad-aa5d90f0bb1d@yandex.ru> <1898378843.430816.1599957743795@ichabod.co-bxl> <83bli9db3t.fsf@gnu.org> <1670898213.459425.1600016799389@ichabod.co-bxl> <83h7s1bmy5.fsf@gnu.org> <87363lh856.fsf@gnus.org> <1357196034.463572.1600022946152@ichabod.co-bxl> <83k0vnqwpg.fsf@gnu.org> <83d01fqusy.fsf@gnu.org> X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 43117 Cc: larsi@gnus.org, dgutov@yandex.ru, rpluim@gmail.com, leungbk@mailfence.com, 43117@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) > From: Stefan Kangas > Date: Sun, 18 Oct 2020 11:25:31 -0700 > Cc: leungbk@mailfence.com, larsi@gnus.org, rpluim@gmail.com, > 43117@debbugs.gnu.org, dgutov@yandex.ru > > Eli Zaretskii writes: > > > We already mark such commits with a leading semi-colon. Will this > > file simply repeat those commits? > > Yes, if we want the commits ignored by "git blame". But of course it > could include only some of them, as well as commits not marked with a > leading semi-colon. Why would someone want to skip commits in "git blame"? We need to have agreed-upon criteria or policy for that, otherwise each one of use will step on the others' toes. "git blame" is an important forensics command, so hiding commits from it might surprise someone, if it's unexpected. > >> > And what should be done about it while merging from the release branch > >> > to master? > >> > >> I don't think anything in particular needs doing, since the sha-1 will > >> stay the same after a merge. Or am I missing something? > > > > Not all of the commits get merged. Some are skipped. > > Wouldn't having non-existent commit ids in there mostly be an aesthetic > problem? I don't know. Will it? I have no experience with this feature. From debbugs-submit-bounces@debbugs.gnu.org Mon Oct 19 12:06:54 2020 Received: (at 43117) by debbugs.gnu.org; 19 Oct 2020 16:06:54 +0000 Received: from localhost ([127.0.0.1]:42124 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kUXgT-0005p8-Rq for submit@debbugs.gnu.org; Mon, 19 Oct 2020 12:06:54 -0400 Received: from mail-ed1-f67.google.com ([209.85.208.67]:44346) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kUXgS-0005oi-4O for 43117@debbugs.gnu.org; Mon, 19 Oct 2020 12:06:52 -0400 Received: by mail-ed1-f67.google.com with SMTP id t20so10788275edr.11 for <43117@debbugs.gnu.org>; Mon, 19 Oct 2020 09:06:52 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:in-reply-to:references:mime-version:date :message-id:subject:to:cc; bh=LVto1GHdxVWUxpPxv9uROMY6CD4RGub6OTpuysz8OAw=; b=FHAOcuLc2GdglR/KqEt/PT2BylDvAySiLAxjPTZN+7SSYT22WIKCUuEj2cx3Uk11bC nOYOCRzCUS2DAjd+LjlcIYllg+EbIaN0VUQdxqJlZIUyOVUBbMJNTaY7uMNNNAVUG4Y0 gx99F1Jth6FMycjHseZNRWXZGdxdlnwh6wZopQ+WoKR9B2KZZmNRTLrjP1uO6yHSB8u6 7trHge04yWqjipdWqStYIfrW7wVqk7npxriy/5HEFuSu/WnrHlhsHXBm7hDc8jg/b4Pm tHTum8skc799ICHOhotdPo2EaPH5b30z8ojRdgn2GCX1ol0J/OX3d9ZMnpHG8L9mYdS0 iWOQ== X-Gm-Message-State: AOAM5321/cF+CkfHnFRNFwIHOrOSN7OOLSERVeJRRq1ljflKXdLIA7W4 sYtscxW22SnCRUAcpEahCZa/1XPYcch+HrMaTnI= X-Google-Smtp-Source: ABdhPJxSh8VGEgsOgkamAq6+H49nQoSRt5rK4Z8t7oz9GabxDcDroB8xsWKn2GJdUzal1+XM3GGnqkuurNoqOP4n/8g= X-Received: by 2002:a05:6402:31b3:: with SMTP id dj19mr549308edb.210.1603123606562; Mon, 19 Oct 2020 09:06:46 -0700 (PDT) Received: from 753933720722 named unknown by gmailapi.google.com with HTTPREST; Mon, 19 Oct 2020 16:06:45 +0000 From: Stefan Kangas In-Reply-To: <838sc3qsvf.fsf@gnu.org> References: <197409406.192953.1598809591346@ichabod.co-bxl> <9aa79095-18d6-d0bd-18ad-aa5d90f0bb1d@yandex.ru> <1898378843.430816.1599957743795@ichabod.co-bxl> <83bli9db3t.fsf@gnu.org> <1670898213.459425.1600016799389@ichabod.co-bxl> <83h7s1bmy5.fsf@gnu.org> <87363lh856.fsf@gnus.org> <1357196034.463572.1600022946152@ichabod.co-bxl> <83k0vnqwpg.fsf@gnu.org> <83d01fqusy.fsf@gnu.org> <838sc3qsvf.fsf@gnu.org> MIME-Version: 1.0 Date: Mon, 19 Oct 2020 16:06:45 +0000 Message-ID: Subject: Re: bug#43117: [PATCH] Add .git-blame-ignore-revs file To: Eli Zaretskii Content-Type: text/plain; charset="UTF-8" X-Spam-Score: 0.5 (/) X-Debbugs-Envelope-To: 43117 Cc: larsi@gnus.org, dgutov@yandex.ru, rpluim@gmail.com, leungbk@mailfence.com, 43117@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -0.5 (/) Eli Zaretskii writes: > Why would someone want to skip commits in "git blame"? We need to > have agreed-upon criteria or policy for that, otherwise each one of > use will step on the others' toes. "git blame" is an important > forensics command, so hiding commits from it might surprise someone, > if it's unexpected. For example, if a commit fixed a typo in a doc string, I'd much rather see the commit that added that text than the one that fixed the typo. >> Wouldn't having non-existent commit ids in there mostly be an aesthetic >> problem? > > I don't know. Will it? I have no experience with this feature. AFAIU, git will just skip over non-existent commits in this case. From debbugs-submit-bounces@debbugs.gnu.org Mon Oct 19 12:40:15 2020 Received: (at 43117) by debbugs.gnu.org; 19 Oct 2020 16:40:15 +0000 Received: from localhost ([127.0.0.1]:42185 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kUYCg-0006gV-KP for submit@debbugs.gnu.org; Mon, 19 Oct 2020 12:40:15 -0400 Received: from eggs.gnu.org ([209.51.188.92]:56502) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kUYCf-0006gG-Fi for 43117@debbugs.gnu.org; Mon, 19 Oct 2020 12:40:09 -0400 Received: from fencepost.gnu.org ([2001:470:142:3::e]:37551) by eggs.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kUYCZ-0006WP-6a; Mon, 19 Oct 2020 12:40:03 -0400 Received: from [176.228.60.248] (port=4432 helo=home-c4e4a596f7) by fencepost.gnu.org with esmtpsa (TLS1.2:RSA_AES_256_CBC_SHA1:256) (Exim 4.82) (envelope-from ) id 1kUYCY-0008Eh-FY; Mon, 19 Oct 2020 12:40:03 -0400 Date: Mon, 19 Oct 2020 19:40:08 +0300 Message-Id: <838sc2p3tj.fsf@gnu.org> From: Eli Zaretskii To: Stefan Kangas In-Reply-To: (message from Stefan Kangas on Mon, 19 Oct 2020 16:06:45 +0000) Subject: Re: bug#43117: [PATCH] Add .git-blame-ignore-revs file References: <197409406.192953.1598809591346@ichabod.co-bxl> <9aa79095-18d6-d0bd-18ad-aa5d90f0bb1d@yandex.ru> <1898378843.430816.1599957743795@ichabod.co-bxl> <83bli9db3t.fsf@gnu.org> <1670898213.459425.1600016799389@ichabod.co-bxl> <83h7s1bmy5.fsf@gnu.org> <87363lh856.fsf@gnus.org> <1357196034.463572.1600022946152@ichabod.co-bxl> <83k0vnqwpg.fsf@gnu.org> <83d01fqusy.fsf@gnu.org> <838sc3qsvf.fsf@gnu.org> X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 43117 Cc: larsi@gnus.org, dgutov@yandex.ru, rpluim@gmail.com, leungbk@mailfence.com, 43117@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) > From: Stefan Kangas > Date: Mon, 19 Oct 2020 16:06:45 +0000 > Cc: leungbk@mailfence.com, larsi@gnus.org, rpluim@gmail.com, > 43117@debbugs.gnu.org, dgutov@yandex.ru > > Eli Zaretskii writes: > > > Why would someone want to skip commits in "git blame"? We need to > > have agreed-upon criteria or policy for that, otherwise each one of > > use will step on the others' toes. "git blame" is an important > > forensics command, so hiding commits from it might surprise someone, > > if it's unexpected. > > For example, if a commit fixed a typo in a doc string, I'd much rather > see the commit that added that text than the one that fixed the typo. But that's your personal preference, isn't it? Do we know for sure no one will ever want to see changes that fixed typos? For example, what about some "typo" that is controversial (like the "parseable" thing we discussed lately), and we want to know who and why "fixed" it? In short, the more I think about this feature, the less it makes sense to me to use it in our project. It's probably fine for a single-developer projects, where the preferences are never in conflict. But ours is a very different project. > >> Wouldn't having non-existent commit ids in there mostly be an aesthetic > >> problem? > > > > I don't know. Will it? I have no experience with this feature. > > AFAIU, git will just skip over non-existent commits in this case. It requires a setting in .git/config, doesn't it? Would older versions of Git warn about the setting they don't know about? Or do we expect users to turn this on in their ~/.gitconfig instead? From debbugs-submit-bounces@debbugs.gnu.org Tue Oct 20 06:38:59 2020 Received: (at 43117) by debbugs.gnu.org; 20 Oct 2020 10:38:59 +0000 Received: from localhost ([127.0.0.1]:43708 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kUp2h-000568-ES for submit@debbugs.gnu.org; Tue, 20 Oct 2020 06:38:59 -0400 Received: from quimby.gnus.org ([95.216.78.240]:44936) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kUp2e-00055t-Q4 for 43117@debbugs.gnu.org; Tue, 20 Oct 2020 06:38:57 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=gnus.org; s=20200322; h=Content-Type:MIME-Version:Message-ID:In-Reply-To:Date: References:Subject:Cc:To:From:Sender:Reply-To:Content-Transfer-Encoding: Content-ID:Content-Description:Resent-Date:Resent-From:Resent-Sender: Resent-To:Resent-Cc:Resent-Message-ID:List-Id:List-Help:List-Unsubscribe: List-Subscribe:List-Post:List-Owner:List-Archive; bh=Ti/Zl7D7KaZeDGCq/2V/Ms1dyU9prXLTwUajtq+tCzo=; b=frUGVbZhq/bctdSLXLylAWgbEM QiMoyYl2VquKykMgSjuzbM4BP6hCHLjyuhG7JfmsxVCfoEJnrEXyN1Fef6wQemJ25ydNPLdmow0OX KVIyrqckxpGUf5rkbccJAnUgC+2HARLdqXBF1GT3CIFFZlk2cQRl2JHXYYGIcoyOwGbc=; Received: from cm-84.212.202.86.getinternet.no ([84.212.202.86] helo=xo) by quimby.gnus.org with esmtpsa (TLS1.3:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1kUp2Q-0006kG-NV; Tue, 20 Oct 2020 12:38:48 +0200 From: Lars Ingebrigtsen To: Eli Zaretskii Subject: Re: bug#43117: [PATCH] Add .git-blame-ignore-revs file References: <197409406.192953.1598809591346@ichabod.co-bxl> <9aa79095-18d6-d0bd-18ad-aa5d90f0bb1d@yandex.ru> <1898378843.430816.1599957743795@ichabod.co-bxl> <83bli9db3t.fsf@gnu.org> <1670898213.459425.1600016799389@ichabod.co-bxl> <83h7s1bmy5.fsf@gnu.org> <87363lh856.fsf@gnus.org> <1357196034.463572.1600022946152@ichabod.co-bxl> <83k0vnqwpg.fsf@gnu.org> <83d01fqusy.fsf@gnu.org> <838sc3qsvf.fsf@gnu.org> <838sc2p3tj.fsf@gnu.org> Face: iVBORw0KGgoAAAANSUhEUgAAADAAAAAwBAMAAAClLOS0AAAABGdBTUEAALGPC/xhBQAAACBj SFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAG1BMVEX8/P3X0uNiJ024 QlTYfnifIWvaWWzioJ/////0RaLlAAAAAWJLR0QIht6VegAAAAd0SU1FB+QKFAoiKTxdcMcAAAGz SURBVDjLlZPBjqMwDIbTNyjdQ+9m2gfAkL0TT7iTzbxAgudcDZq8/jqhtB2JjtRfECF/8W9sglKq Uru92tJuv5drC1SizZxdtntFu+u9oUpt13hR8ES/gPoZaCBf21b9NnijHk5+1fiQgY0E0D+qgNPJ j95R9whGUKtJ/wD+We/V8th9NG24gZSmDMB7pxFAX+2HIaX3Amrf5C5v5ds1o85vAZNGdJI8+Y9r xgj1JMRqPQJ2o/GomUwBZ80BkRmgRiylXCxAM0fmoBtAqMURsRMrF2RvezjzpIMT0MoqUk62B/f3 8PbNIgSNky9AtvPkWhMtFsAhbwgLECtpA3h5BbZy+wwCk2xtgaOUizmMwStdMlg+4llAay+zFOsY 7wA1EUU6AOUcvgLbA+InJUoJ6mOa78CQaWWqsRp6HGYkVjksHjYYiad0qf4MhAYXIIpEBaSLoS/9 rQuQIJGsEiYTMQwm11jic6Icn6XFFgl4BYtLshyHL9RYS4sCrCRI9WyXm27yWMKtwTwGmWmTB2vL dH+e2JP0qcN6RH8cTpc/Xwb+iZ6D6q50vFTVMa/peHz9b/4PDxXyfYPT/14AAAAldEVYdGRhdGU6 Y3JlYXRlADIwMjAtMTAtMjBUMTA6MzQ6NDErMDA6MDCS/O8wAAAAJXRFWHRkYXRlOm1vZGlmeQAy MDIwLTEwLTIwVDEwOjM0OjQxKzAwOjAw46FXjAAAAABJRU5ErkJggg== X-Now-Playing: Talk Talk's _It's My Life_: "Such A Shame" Date: Tue, 20 Oct 2020 12:38:40 +0200 In-Reply-To: <838sc2p3tj.fsf@gnu.org> (Eli Zaretskii's message of "Mon, 19 Oct 2020 19:40:08 +0300") Message-ID: <87v9f5i3m7.fsf@gnus.org> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/28.0.50 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain X-Spam-Report: Spam detection software, running on the system "quimby.gnus.org", has NOT identified this incoming email as spam. The original message has been attached to this so you can view it or label similar future email. If you have any questions, see @@CONTACT_ADDRESS@@ for details. Content preview: Eli Zaretskii writes: >> For example, if a commit fixed a typo in a doc string, I'd much rather >> see the commit that added that text than the one that fixed the typo. I think I'd want commits like that included in git blame... Content analysis details: (-2.9 points, 5.0 required) pts rule name description ---- ---------------------- -------------------------------------------------- -1.0 ALL_TRUSTED Passed through trusted hosts only via SMTP -1.9 BAYES_00 BODY: Bayes spam probability is 0 to 1% [score: 0.0000] X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 43117 Cc: rpluim@gmail.com, dgutov@yandex.ru, Stefan Kangas , leungbk@mailfence.com, 43117@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) Eli Zaretskii writes: >> For example, if a commit fixed a typo in a doc string, I'd much rather >> see the commit that added that text than the one that fixed the typo. I think I'd want commits like that included in git blame... > In short, the more I think about this feature, the less it makes sense > to me to use it in our project. It's probably fine for a > single-developer projects, where the preferences are never in > conflict. But ours is a very different project. If Emacs was a project that did extensive "janitorial" fixups, then it might make more sense. For instance, if we were to fix all whitespace to be consistent, then having a way to ignore that would be nice. But we don't, so I'm not sure adding a .git-blame-ignore-revs file helps us much. The only thing I'd want to use such a file for would be for things that really are 100% non-functional: Whitespace changes and spelling fixes for comments. So I don't think such a file would help the Emacs project. -- (domestic pets only, the antidote for overdose, milk.) bloggy blog: http://lars.ingebrigtsen.no From debbugs-submit-bounces@debbugs.gnu.org Tue Oct 20 08:05:59 2020 Received: (at 43117) by debbugs.gnu.org; 20 Oct 2020 12:05:59 +0000 Received: from localhost ([127.0.0.1]:43841 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kUqOt-0005FZ-5c for submit@debbugs.gnu.org; Tue, 20 Oct 2020 08:05:59 -0400 Received: from mail-ej1-f67.google.com ([209.85.218.67]:46416) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1kUqOs-0005FJ-68 for 43117@debbugs.gnu.org; Tue, 20 Oct 2020 08:05:58 -0400 Received: by mail-ej1-f67.google.com with SMTP id t25so2266113ejd.13 for <43117@debbugs.gnu.org>; Tue, 20 Oct 2020 05:05:58 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:in-reply-to:references:mime-version:date :message-id:subject:to:cc; bh=H1PWVF8I0u9iMvJxnmlL8cS4OpJmtJVRUswR/pRp31M=; b=cFY301HQZRE4EMHvs+AlKVxlUVzEn/STt162drskLUsrbOlG7K/m584grj6fXQ1+Qo F/XOTI2JvssifBQu61viu3DK7pPfyNqOyP+QIswgolFM+552fCWlXrVn2MVxMbnL9p18 hVegyuA9AnLPbHGmljcwNhGWWu9KzpVVFAP1Rpq8sND/c5iYcfT+asp9dzDi7EcDUCBk BZ13LoGqYe//rJbIAfeYinx4j6WMEYvyaLWe6Oyov3kq4H8I5KaMk/1oiNq9ROrULZG8 Aqy0uEAwhzoXhg5HV45HlwWTj0KoanjvJBveV3gj4xqR5t78KVcSZjZfWX7T6DsWwnFj E66A== X-Gm-Message-State: AOAM530Y8JfAdA6F/J+l8B+H4sY8p4mDMC838gXAcJlrEnc58TVUySGL w4OV3xZBCzum1vn4Ijid0PCJZ1xVz23wLkQ2exo= X-Google-Smtp-Source: ABdhPJxcosTLaYCWX6khLnkEaQpWH2y/iaUJ2LS5xE3tGhDpTFQFXRNP/Mhq+64Opna/MizV1SWW0mwLITH9jMSyEyk= X-Received: by 2002:a17:906:bc91:: with SMTP id lv17mr2875884ejb.249.1603195552602; Tue, 20 Oct 2020 05:05:52 -0700 (PDT) Received: from 753933720722 named unknown by gmailapi.google.com with HTTPREST; Tue, 20 Oct 2020 08:05:52 -0400 From: Stefan Kangas In-Reply-To: <87v9f5i3m7.fsf@gnus.org> References: <197409406.192953.1598809591346@ichabod.co-bxl> <9aa79095-18d6-d0bd-18ad-aa5d90f0bb1d@yandex.ru> <1898378843.430816.1599957743795@ichabod.co-bxl> <83bli9db3t.fsf@gnu.org> <1670898213.459425.1600016799389@ichabod.co-bxl> <83h7s1bmy5.fsf@gnu.org> <87363lh856.fsf@gnus.org> <1357196034.463572.1600022946152@ichabod.co-bxl> <83k0vnqwpg.fsf@gnu.org> <83d01fqusy.fsf@gnu.org> <838sc3qsvf.fsf@gnu.org> <838sc2p3tj.fsf@gnu.org> <87v9f5i3m7.fsf@gnus.org> MIME-Version: 1.0 Date: Tue, 20 Oct 2020 08:05:52 -0400 Message-ID: Subject: Re: bug#43117: [PATCH] Add .git-blame-ignore-revs file To: Lars Ingebrigtsen , Eli Zaretskii Content-Type: text/plain; charset="UTF-8" X-Spam-Score: 0.5 (/) X-Debbugs-Envelope-To: 43117 Cc: rpluim@gmail.com, dgutov@yandex.ru, leungbk@mailfence.com, 43117@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -0.5 (/) Lars Ingebrigtsen writes: > Eli Zaretskii writes: > >>> For example, if a commit fixed a typo in a doc string, I'd much rather >>> see the commit that added that text than the one that fixed the typo. > > I think I'd want commits like that included in git blame... > >> In short, the more I think about this feature, the less it makes sense >> to me to use it in our project. It's probably fine for a >> single-developer projects, where the preferences are never in >> conflict. But ours is a very different project. > > If Emacs was a project that did extensive "janitorial" fixups, then it > might make more sense. For instance, if we were to fix all whitespace > to be consistent, then having a way to ignore that would be nice. But > we don't, so I'm not sure adding a .git-blame-ignore-revs file helps us > much. > > The only thing I'd want to use such a file for would be for things that > really are 100% non-functional: Whitespace changes and spelling fixes > for comments. > > So I don't think such a file would help the Emacs project. You both make good points. I guess the logical conclusion here is to close this bug as wontfix. From debbugs-submit-bounces@debbugs.gnu.org Thu Mar 11 20:07:48 2021 Received: (at 43117) by debbugs.gnu.org; 12 Mar 2021 01:07:48 +0000 Received: from localhost ([127.0.0.1]:55520 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1lKWHM-00083u-3j for submit@debbugs.gnu.org; Thu, 11 Mar 2021 20:07:48 -0500 Received: from mail-pj1-f46.google.com ([209.85.216.46]:36749) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1lKWHK-00083T-MP for 43117@debbugs.gnu.org; Thu, 11 Mar 2021 20:07:47 -0500 Received: by mail-pj1-f46.google.com with SMTP id f2-20020a17090a4a82b02900c67bf8dc69so9950669pjh.1 for <43117@debbugs.gnu.org>; Thu, 11 Mar 2021 17:07:46 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:in-reply-to:references:user-agent :mime-version:date:message-id:subject:to:cc; bh=EY1lma0dAQCftfXSfYCAo7buQn9K7sWo3QjeMp9r+OU=; b=ppiFuPHl7WtehrjjmKV2BzNvqqiUq/ROxcabiNtaEgFi9QCHjZsAAkn/Kti69Ct5pa wRiTpjhJ5klnhR2SjZNPrAuNoBWSZlAXE3xtRXlEtYUExRbRi20GFq3KUH6As1cptRpQ vt1GG/BvQp1UMrL7hzHpBgAIqMlmqcwQpbVukOU3KH5UFTN2g2jOwxhIqUEviyyhUqHj +ixnEN0Cvm9FLFgSUvUPoAIWOUOJgNCJDRVPAB0sLXtOn4fhLKTZvn3mAMbbQM3S/lWP 6b3UcETVrFCSN2cdgxW0sDj1Gr3WEP0vLqIeJjiomca5T2kXw2mlHZsq1hLrx/0MNcik waoQ== X-Gm-Message-State: AOAM533THG4uTdLr8MCgMujgK2nOYW6zyiNb8BorCGC4DUTgQLWD6b0J fof877bPWHniUlhaLhSOsUinSDfS/C7399z3CeClLMmULuE= X-Google-Smtp-Source: ABdhPJz1I45AvCFlRXg7YBITZWsKwELbUoWpKnVJa726RnAvioMCpnGvH479g7121ZHessMExCb/EnRqH9UgUnb5jpo= X-Received: by 2002:a17:90a:bd09:: with SMTP id y9mr11354049pjr.179.1615511261177; Thu, 11 Mar 2021 17:07:41 -0800 (PST) Received: from 753933720722 named unknown by gmailapi.google.com with HTTPREST; Thu, 11 Mar 2021 19:07:40 -0600 From: Stefan Kangas In-Reply-To: (Stefan Kangas's message of "Tue, 20 Oct 2020 08:05:52 -0400") References: <197409406.192953.1598809591346@ichabod.co-bxl> <1898378843.430816.1599957743795@ichabod.co-bxl> <83bli9db3t.fsf@gnu.org> <1670898213.459425.1600016799389@ichabod.co-bxl> <83h7s1bmy5.fsf@gnu.org> <87363lh856.fsf@gnus.org> <1357196034.463572.1600022946152@ichabod.co-bxl> <83k0vnqwpg.fsf@gnu.org> <83d01fqusy.fsf@gnu.org> <838sc3qsvf.fsf@gnu.org> <838sc2p3tj.fsf@gnu.org> <87v9f5i3m7.fsf@gnus.org> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/28.0.50 (gnu/linux) MIME-Version: 1.0 Date: Thu, 11 Mar 2021 19:07:40 -0600 Message-ID: Subject: Re: bug#43117: [PATCH] Add .git-blame-ignore-revs file To: Lars Ingebrigtsen Content-Type: text/plain; charset="UTF-8" X-Spam-Score: 0.5 (/) X-Debbugs-Envelope-To: 43117 Cc: Eli Zaretskii , 43117@debbugs.gnu.org, rpluim@gmail.com, leungbk@mailfence.com, dgutov@yandex.ru X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -0.5 (/) tags 43117 + wontfix close 43117 thanks Stefan Kangas writes: > Lars Ingebrigtsen writes: > >> Eli Zaretskii writes: >> >>>> For example, if a commit fixed a typo in a doc string, I'd much rather >>>> see the commit that added that text than the one that fixed the typo. >> >> I think I'd want commits like that included in git blame... >> >>> In short, the more I think about this feature, the less it makes sense >>> to me to use it in our project. It's probably fine for a >>> single-developer projects, where the preferences are never in >>> conflict. But ours is a very different project. >> >> If Emacs was a project that did extensive "janitorial" fixups, then it >> might make more sense. For instance, if we were to fix all whitespace >> to be consistent, then having a way to ignore that would be nice. But >> we don't, so I'm not sure adding a .git-blame-ignore-revs file helps us >> much. >> >> The only thing I'd want to use such a file for would be for things that >> really are 100% non-functional: Whitespace changes and spelling fixes >> for comments. >> >> So I don't think such a file would help the Emacs project. > > You both make good points. > > I guess the logical conclusion here is to close this bug as wontfix. No further comments within 20 weeks, so I'm closing this as wontfix. From unknown Thu Jun 19 13:55:21 2025 Received: (at fakecontrol) by fakecontrolmessage; To: internal_control@debbugs.gnu.org From: Debbugs Internal Request Subject: Internal Control Message-Id: bug archived. Date: Fri, 09 Apr 2021 11:24:05 +0000 User-Agent: Fakemail v42.6.9 # This is a fake control message. # # The action: # bug archived. thanks # This fakemail brought to you by your local debbugs # administrator