From 005cf1790526bc501c40c7e170e334e348604544 Mon Sep 17 00:00:00 2001
From: Raymond Toy <toy.raymond@gmail.com>
Date: Wed, 11 Jan 2017 21:55:53 -0800
Subject: [PATCH] Update asdf to version 3.2.0.

---
 src/contrib/asdf/asdf.lisp       | 8978 +++++++++++++++++-------------
 src/contrib/asdf/doc/asdf.html   |  263 +-
 src/contrib/asdf/doc/asdf.info   |  582 +-
 src/contrib/asdf/doc/asdf.pdf    |  Bin 501619 -> 507142 bytes
 src/general-info/release-21c.txt |    1 +
 5 files changed, 5586 insertions(+), 4238 deletions(-)

diff --git a/src/contrib/asdf/asdf.lisp b/src/contrib/asdf/asdf.lisp
index 687e6ec55..56a97941a 100644
--- a/src/contrib/asdf/asdf.lisp
+++ b/src/contrib/asdf/asdf.lisp
@@ -1,5 +1,5 @@
 ;;; -*- mode: Lisp; Base: 10 ; Syntax: ANSI-Common-Lisp ; buffer-read-only: t; -*-
-;;; This is ASDF 3.1.7: Another System Definition Facility.
+;;; This is ASDF 3.2.0: Another System Definition Facility.
 ;;;
 ;;; Feedback, bug reports, and patches are all welcome:
 ;;; please mail to <asdf-devel@common-lisp.net>.
@@ -19,7 +19,7 @@
 ;;;  http://www.opensource.org/licenses/mit-license.html on or about
 ;;;  Monday; July 13, 2009)
 ;;;
-;;; Copyright (c) 2001-2015 Daniel Barlow and contributors
+;;; Copyright (c) 2001-2016 Daniel Barlow and contributors
 ;;;
 ;;; Permission is hereby granted, free of charge, to any person obtaining
 ;;; a copy of this software and associated documentation files (the
@@ -45,7 +45,6 @@
 ;;; The problem with writing a defsystem replacement is bootstrapping:
 ;;; we can't use defsystem to compile it.  Hence, all in one file.
 
-#+xcvb (module ())
 ;;;; ---------------------------------------------------------------------------
 ;;;; Handle ASDF package upgrade, including implementation-dependent magic.
 ;;
@@ -816,10 +815,11 @@ UNINTERN -- Remove symbols here from PACKAGE."
 
 ;;;; Early meta-level tweaks
 
-#+(or allegro clasp clisp cmucl ecl mkcl mkcl sbcl)
+#+(or allegro clasp clisp clozure cmucl ecl mkcl sbcl)
 (eval-when (:load-toplevel :compile-toplevel :execute)
   (when (and #+allegro (member :ics *features*)
              #+(or clasp clisp cmucl ecl mkcl) (member :unicode *features*)
+             #+clozure (member :openmcl-unicode-strings *features*)
              #+sbcl (member :sb-unicode *features*))
     ;; Check for unicode at runtime, so that a hypothetical FASL compiled with unicode
     ;; but loaded in a non-unicode setting (e.g. on Allegro) won't tell a lie.
@@ -876,7 +876,7 @@ UNINTERN -- Remove symbols here from PACKAGE."
     (setf p (pathname p))
     (format nil "~@[~A~]~@[.~A~]" (pathname-name p) (pathname-type p))))
 
-#+(and ecl (not clasp))
+#+ecl
 (eval-when (:load-toplevel :compile-toplevel :execute)
   (setf *load-verbose* nil)
   (defun use-ecl-byte-compiler-p () (and (member :ecl-bytecmp *features*) t))
@@ -915,6 +915,17 @@ UNINTERN -- Remove symbols here from PACKAGE."
       (scl:send stream :string-out sequence start end)
       sequence)))
 
+#+lispworks
+(eval-when (:load-toplevel :compile-toplevel :execute)
+  ;; lispworks 3 and earlier cannot be checked for so we always assume
+  ;; at least version 4
+  (unless (member :lispworks4 *features*)
+    (pushnew :lispworks5+ *features*)
+    (unless (member :lispworks5 *features*)
+      (pushnew :lispworks6+ *features*)
+      (unless (member :lispworks6 *features*)
+        (pushnew :lispworks7+ *features*)))))
+
 #.(or #+mcl ;; the #$ doesn't work on other lisps, even protected by #+mcl, so we use this trick
       (read-from-string
        "(eval-when (:load-toplevel :compile-toplevel :execute)
@@ -1006,8 +1017,9 @@ Return a string made of the parts not omitted or emitted by FROB."
    ;; magic helper to define debugging functions:
    #:uiop-debug #:load-uiop-debug-utility #:*uiop-debug-utility*
    #:with-upgradability ;; (un)defining functions in an upgrade-friendly way
-   #:undefine-function #:undefine-functions #:defun* #:defgeneric*
+   #:defun* #:defgeneric*
    #:nest #:if-let ;; basic flow control
+   #:parse-body ;; macro definition helper
    #:while-collecting #:appendf #:length=n-p #:ensure-list ;; lists
    #:remove-plist-keys #:remove-plist-key ;; plists
    #:emptyp ;; sequences
@@ -1016,7 +1028,7 @@ Return a string made of the parts not omitted or emitted by FROB."
    #:base-string-p #:strings-common-element-type #:reduce/strcat #:strcat ;; strings
    #:first-char #:last-char #:split-string #:stripln #:+cr+ #:+lf+ #:+crlf+
    #:string-prefix-p #:string-enclosed-p #:string-suffix-p
-   #:standard-case-symbol-name #:find-standard-case-symbol
+   #:standard-case-symbol-name #:find-standard-case-symbol ;; symbols
    #:coerce-class ;; CLOS
    #:stamp< #:stamps< #:stamp*< #:stamp<= ;; stamps
    #:earlier-stamp #:stamps-earliest #:earliest-stamp
@@ -1024,10 +1036,11 @@ Return a string made of the parts not omitted or emitted by FROB."
    #:list-to-hash-set #:ensure-gethash ;; hash-table
    #:ensure-function #:access-at #:access-at-count ;; functions
    #:call-function #:call-functions #:register-hook-function
+   #:lexicographic< #:lexicographic<= ;; version
+   #:simple-style-warning #:style-warn ;; simple style warnings
    #:match-condition-p #:match-any-condition-p ;; conditions
    #:call-with-muffled-conditions #:with-muffled-conditions
-   #:lexicographic< #:lexicographic<=
-   #:parse-version #:unparse-version #:version< #:version<= #:version-compatible-p)) ;; version
+   #:not-implemented-error #:parameter-error))
 (in-package :uiop/utility)
 
 ;;;; Defining functions in a way compatible with hot-upgrade:
@@ -1036,24 +1049,6 @@ Return a string made of the parts not omitted or emitted by FROB."
 ;; even if the signature and/or generic-ness of the function has changed.
 ;; For a generic function, this invalidates any previous DEFMETHOD.
 (eval-when (:load-toplevel :compile-toplevel :execute)
-  (defun undefine-function (function-spec)
-    (cond
-      ((symbolp function-spec)
-       ;; undefining the previous function is the portable way
-       ;; of overriding any incompatible previous gf,
-       ;; but CLISP needs extra help with getting rid of previous methods.
-       #+clisp
-       (let ((f (and (fboundp function-spec) (fdefinition function-spec))))
-         (when (typep f 'clos:standard-generic-function)
-           (loop :for m :in (clos:generic-function-methods f)
-                 :do (remove-method f m))))
-       (fmakunbound function-spec))
-      ((and (consp function-spec) (eq (car function-spec) 'setf)
-            (consp (cdr function-spec)) (null (cddr function-spec)))
-       (fmakunbound function-spec))
-      (t (error "bad function spec ~S" function-spec))))
-  (defun undefine-functions (function-spec-list)
-    (map () 'undefine-function function-spec-list))
   (macrolet
       ((defdef (def* def)
          `(defmacro ,def* (name formals &rest rest)
@@ -1065,8 +1060,8 @@ Return a string made of the parts not omitted or emitted by FROB."
               `(progn
                  ;; We usually try to do it only for the functions that need it,
                  ;; which happens in asdf/upgrade - however, for ECL, we need this hammer.
-                 ,@(when (or supersede #+(or clasp ecl) t)
-                     `((undefine-function ',name)))
+                 ,@(when supersede
+                     `((fmakunbound ',name)))
                  ,@(when (and #+(or clasp ecl) (symbolp name)) ; fails for setf functions on ecl
                      `((declaim (notinline ,name))))
                  (,',def ,name ,formals ,@rest))))))
@@ -1093,7 +1088,7 @@ to supersede any previous definition."
   (defvar *uiop-debug-utility*
     '(or (ignore-errors
           (symbol-call :asdf :system-relative-pathname :uiop "contrib/debug.lisp"))
-      (symbol-call :uiop/pathname :subpathname (user-homedir-pathname) "cl/asdf/uiop/contrib/debug.lisp"))
+      (symbol-call :uiop/pathname :subpathname (user-homedir-pathname) "common-lisp/asdf/uiop/contrib/debug.lisp"))
     "form that evaluates to the pathname to your favorite debugging utilities")
 
   (defmacro uiop-debug (&rest keys)
@@ -1128,6 +1123,30 @@ to supersede any previous definition."
              ,then-form
              ,else-form)))))
 
+;;; Macro definition helper
+(with-upgradability ()
+  (defun parse-body (body &key documentation whole) ;; from alexandria
+    "Parses BODY into (values remaining-forms declarations doc-string).
+Documentation strings are recognized only if DOCUMENTATION is true.
+Syntax errors in body are signalled and WHOLE is used in the signal
+arguments when given."
+    (let ((doc nil)
+          (decls nil)
+          (current nil))
+      (tagbody
+       :declarations
+         (setf current (car body))
+         (when (and documentation (stringp current) (cdr body))
+           (if doc
+               (error "Too many documentation strings in ~S." (or whole body))
+               (setf doc (pop body)))
+           (go :declarations))
+         (when (and (listp current) (eql (first current) 'declare))
+           (push (pop body) decls)
+           (go :declarations)))
+      (values body (nreverse decls) doc))))
+
+
 ;;; List manipulation
 (with-upgradability ()
   (defmacro while-collecting ((&rest collectors) &body body)
@@ -1164,7 +1183,7 @@ Returns two values: \(A B C\) and \(1 2 3\)."
     (if (listp x) x (list x))))
 
 
-;;; remove a key from a plist, i.e. for keyword argument cleanup
+;;; Remove a key from a plist, i.e. for keyword argument cleanup
 (with-upgradability ()
   (defun remove-plist-key (key plist)
     "Remove a single key from a plist"
@@ -1198,8 +1217,7 @@ Returns two values: \(A B C\) and \(1 2 3\)."
                        #-scl base-char
                        ;; LW6 has BASE-CHAR < SIMPLE-CHAR < CHARACTER
                        ;; LW7 has BASE-CHAR < BMP-CHAR < SIMPLE-CHAR = CHARACTER
-                       #+(and lispworks (not (or lispworks4 lispworks5 lispworks6)))
-                       lw:bmp-char
+                       #+lispworks7+ lw:bmp-char
                        #+lispworks lw:simple-char
                        character)
                      :unless (and next (subtypep next type))
@@ -1473,18 +1491,24 @@ A class object designates itself.
 NIL designates itself (no class).
 A symbol otherwise designates a class by name."
     (let* ((normalized
-             (typecase class
+            (typecase class
               (keyword (or (find-symbol* class package nil)
                            (find-symbol* class *package* nil)))
               (string (symbol-call :uiop :safe-read-from-string class :package package))
               (t class)))
            (found
-             (etypecase normalized
-               ((or standard-class built-in-class) normalized)
-               ((or null keyword) nil)
-               (symbol (find-class normalized nil nil)))))
+            (etypecase normalized
+              ((or standard-class built-in-class) normalized)
+              ((or null keyword) nil)
+              (symbol (find-class normalized nil nil))))
+           (super-class
+            (etypecase super
+              ((or standard-class built-in-class) super)
+              ((or null keyword) nil)
+              (symbol (find-class super nil nil)))))
+      #+allegro (when found (mop:finalize-inheritance found))
       (or (and found
-               (or (eq super t) (#-cormanlisp subtypep #+cormanlisp cl::subclassp found super))
+               (or (eq super t) (#-cormanlisp subtypep #+cormanlisp cl::subclassp found super-class))
                found)
           (call-function error "Can't coerce ~S to a ~:[class~;subclass of ~:*~S~]" class super)))))
 
@@ -1509,64 +1533,34 @@ up to the given equality TEST"
     (dolist (x list h) (setf (gethash x h) t))))
 
 
-;;; Version handling
+;;; Lexicographic comparison of lists of numbers
 (with-upgradability ()
-  (defun unparse-version (version-list)
-    (format nil "~{~D~^.~}" version-list))
-
-  (defun parse-version (version-string &optional on-error)
-    "Parse a VERSION-STRING as a series of natural integers separated by dots.
-Return a (non-null) list of integers if the string is valid;
-otherwise return NIL.
-
-When invalid, ON-ERROR is called as per CALL-FUNCTION before to return NIL,
-with format arguments explaining why the version is invalid.
-ON-ERROR is also called if the version is not canonical
-in that it doesn't print back to itself, but the list is returned anyway."
-    (block nil
-      (unless (stringp version-string)
-        (call-function on-error "~S: ~S is not a string" 'parse-version version-string)
-        (return))
-      (unless (loop :for prev = nil :then c :for c :across version-string
-                    :always (or (digit-char-p c)
-                                (and (eql c #\.) prev (not (eql prev #\.))))
-                    :finally (return (and c (digit-char-p c))))
-        (call-function on-error "~S: ~S doesn't follow asdf version numbering convention"
-                       'parse-version version-string)
-        (return))
-      (let* ((version-list
-               (mapcar #'parse-integer (split-string version-string :separator ".")))
-             (normalized-version (unparse-version version-list)))
-        (unless (equal version-string normalized-version)
-          (call-function on-error "~S: ~S contains leading zeros" 'parse-version version-string))
-        version-list)))
-
-  (defun lexicographic< (< x y)
+  (defun lexicographic< (element< x y)
+    "Lexicographically compare two lists of using the function element< to compare elements.
+element< is a strict total order; the resulting order on X and Y will also be strict."
     (cond ((null y) nil)
           ((null x) t)
-          ((funcall < (car x) (car y)) t)
-          ((funcall < (car y) (car x)) nil)
-          (t (lexicographic< < (cdr x) (cdr y)))))
+          ((funcall element< (car x) (car y)) t)
+          ((funcall element< (car y) (car x)) nil)
+          (t (lexicographic< element< (cdr x) (cdr y)))))
 
-  (defun lexicographic<= (< x y)
-    (not (lexicographic< < y x)))
+  (defun lexicographic<= (element< x y)
+    "Lexicographically compare two lists of using the function element< to compare elements.
+element< is a strict total order; the resulting order on X and Y will be a non-strict total order."
+    (not (lexicographic< element< y x))))
 
-  (defun version< (version1 version2)
-    (let ((v1 (parse-version version1 nil))
-          (v2 (parse-version version2 nil)))
-      (lexicographic< '< v1 v2)))
 
-  (defun version<= (version1 version2)
-    (not (version< version2 version1)))
+;;; Simple style warnings
+(with-upgradability ()
+  (define-condition simple-style-warning
+      #+sbcl (sb-int:simple-style-warning) #-sbcl (simple-condition style-warning)
+    ())
 
-  (defun version-compatible-p (provided-version required-version)
-    "Is the provided version a compatible substitution for the required-version?
-If major versions differ, it's not compatible.
-If they are equal, then any later version is compatible,
-with later being determined by a lexicographical comparison of minor numbers."
-    (let ((x (parse-version provided-version nil))
-          (y (parse-version required-version nil)))
-      (and x y (= (car x) (car y)) (lexicographic<= '< (cdr y) (cdr x))))))
+  (defun style-warn (datum &rest arguments)
+    (etypecase datum
+      (string (warn (make-condition 'simple-style-warning :format-control datum :format-arguments arguments)))
+      (symbol (assert (subtypep datum 'style-warning)) (apply 'warn datum arguments))
+      (style-warning (apply 'warn datum arguments)))))
 
 
 ;;; Condition control
@@ -1575,10 +1569,10 @@ with later being determined by a lexicographical comparison of minor numbers."
   (defparameter +simple-condition-format-control-slot+
     #+abcl 'system::format-control
     #+allegro 'excl::format-control
+    #+(or clasp ecl mkcl) 'si::format-control
     #+clisp 'system::$format-control
     #+clozure 'ccl::format-control
     #+(or cmucl scl) 'conditions::format-control
-    #+(or clasp ecl mkcl) 'si::format-control
     #+(or gcl lispworks) 'conditions::format-string
     #+sbcl 'sb-kernel:format-control
     #-(or abcl allegro clasp clisp clozure cmucl ecl gcl lispworks mkcl sbcl scl) nil
@@ -1614,6 +1608,232 @@ or a string describing the format-control of a simple-condition."
     "Shorthand syntax for CALL-WITH-MUFFLED-CONDITIONS"
     `(call-with-muffled-conditions #'(lambda () ,@body) ,conditions)))
 
+;;; Conditions
+
+(with-upgradability ()
+  (define-condition not-implemented-error (error)
+    ((functionality :initarg :functionality)
+     (format-control :initarg :format-control)
+     (format-arguments :initarg :format-arguments))
+    (:report (lambda (condition stream)
+               (format stream "Not implemented: ~s~@[ ~?~]"
+                       (slot-value condition 'functionality)
+                       (slot-value condition 'format-control)
+                       (slot-value condition 'format-arguments)))))
+
+  (defun not-implemented-error (functionality &optional format-control &rest format-arguments)
+    "Signal an error because some FUNCTIONALITY is not implemented in the current version
+of the software on the current platform; it may or may not be implemented in different combinations
+of version of the software and of the underlying platform. Optionally, report a formatted error
+message."
+    (error 'not-implemented-error
+           :functionality functionality
+           :format-control format-control
+           :format-arguments format-arguments))
+
+  (define-condition parameter-error (error)
+    ((functionality :initarg :functionality)
+     (format-control :initarg :format-control)
+     (format-arguments :initarg :format-arguments))
+    (:report (lambda (condition stream)
+               (apply 'format stream
+                       (slot-value condition 'format-control)
+                       (slot-value condition 'functionality)
+                       (slot-value condition 'format-arguments)))))
+
+  ;; Note that functionality MUST be passed as the second argument to parameter-error, just after
+  ;; the format-control. If you want it to not appear in first position in actual message, use
+  ;; ~* and ~:* to adjust parameter order.
+  (defun parameter-error (format-control functionality &rest format-arguments)
+    "Signal an error because some FUNCTIONALITY or its specific implementation on a given underlying
+platform does not accept a given parameter or combination of parameters. Report a formatted error
+message, that takes the functionality as its first argument (that can be skipped with ~*)."
+    (error 'parameter-error
+           :functionality functionality
+           :format-control format-control
+           :format-arguments format-arguments)))
+
+(uiop/package:define-package :uiop/version
+  (:recycle :uiop/version :uiop/utility :asdf)
+  (:use :uiop/common-lisp :uiop/package :uiop/utility)
+  (:export
+   #:*uiop-version*
+   #:parse-version #:unparse-version #:version< #:version<= ;; version support, moved from uiop/utility
+   #:next-version
+   #:deprecated-function-condition #:deprecated-function-name ;; deprecation control
+   #:deprecated-function-style-warning #:deprecated-function-warning
+   #:deprecated-function-error #:deprecated-function-should-be-deleted
+   #:version-deprecation #:with-deprecation))
+(in-package :uiop/version)
+
+(with-upgradability ()
+  (defparameter *uiop-version* "3.2.0")
+
+  (defun unparse-version (version-list)
+    "From a parsed version (a list of natural numbers), compute the version string"
+    (format nil "~{~D~^.~}" version-list))
+
+  (defun parse-version (version-string &optional on-error)
+    "Parse a VERSION-STRING as a series of natural numbers separated by dots.
+Return a (non-null) list of integers if the string is valid;
+otherwise return NIL.
+
+When invalid, ON-ERROR is called as per CALL-FUNCTION before to return NIL,
+with format arguments explaining why the version is invalid.
+ON-ERROR is also called if the version is not canonical
+in that it doesn't print back to itself, but the list is returned anyway."
+    (block nil
+      (unless (stringp version-string)
+        (call-function on-error "~S: ~S is not a string" 'parse-version version-string)
+        (return))
+      (unless (loop :for prev = nil :then c :for c :across version-string
+                    :always (or (digit-char-p c)
+                                (and (eql c #\.) prev (not (eql prev #\.))))
+                    :finally (return (and c (digit-char-p c))))
+        (call-function on-error "~S: ~S doesn't follow asdf version numbering convention"
+                       'parse-version version-string)
+        (return))
+      (let* ((version-list
+               (mapcar #'parse-integer (split-string version-string :separator ".")))
+             (normalized-version (unparse-version version-list)))
+        (unless (equal version-string normalized-version)
+          (call-function on-error "~S: ~S contains leading zeros" 'parse-version version-string))
+        version-list)))
+
+  (defun next-version (version)
+    "When VERSION is not nil, it is a string, then parse it as a version, compute the next version
+and return it as a string."
+    (when version
+      (let ((version-list (parse-version version)))
+        (incf (car (last version-list)))
+        (unparse-version version-list))))
+
+  (defun version< (version1 version2)
+    "Given two version strings, return T if the second is strictly newer"
+    (let ((v1 (parse-version version1 nil))
+          (v2 (parse-version version2 nil)))
+      (lexicographic< '< v1 v2)))
+
+  (defun version<= (version1 version2)
+    "Given two version strings, return T if the second is newer or the same"
+    (not (version< version2 version1))))
+
+
+(with-upgradability ()
+  (define-condition deprecated-function-condition (condition)
+    ((name :initarg :name :reader deprecated-function-name)))
+  (define-condition deprecated-function-style-warning (deprecated-function-condition style-warning) ())
+  (define-condition deprecated-function-warning (deprecated-function-condition warning) ())
+  (define-condition deprecated-function-error (deprecated-function-condition error) ())
+  (define-condition deprecated-function-should-be-deleted (deprecated-function-condition error) ())
+
+  (defun deprecated-function-condition-kind (type)
+    (ecase type
+      ((deprecated-function-style-warning) :style-warning)
+      ((deprecated-function-warning) :warning)
+      ((deprecated-function-error) :error)
+      ((deprecated-function-should-be-deleted) :delete)))
+
+  (defmethod print-object ((c deprecated-function-condition) stream)
+    (let ((name (deprecated-function-name c)))
+      (cond
+        (*print-readably*
+         (let ((fmt "#.(make-condition '~S :name ~S)")
+               (args (list (type-of c) name)))
+           (if *read-eval*
+               (apply 'format stream fmt args)
+               (error "Can't print ~?" fmt args))))
+        (*print-escape*
+         (print-unreadable-object (c stream :type t) (format stream ":name ~S" name)))
+        (t
+         (let ((*package* (find-package :cl))
+               (type (type-of c)))
+           (format stream
+                   (if (eq type 'deprecated-function-should-be-deleted)
+                       "~A: Still defining deprecated function~:P ~{~S~^ ~} that promised to delete"
+                       "~A: Using deprecated function ~S -- please update your code to use a newer API.~
+~@[~%The docstring for this function says:~%~A~%~]")
+                   type name (when (symbolp name) (documentation name 'function))))))))
+
+  (defun notify-deprecated-function (status name)
+    (ecase status
+      ((nil) nil)
+      ((:style-warning) (style-warn 'deprecated-function-style-warning :name name))
+      ((:warning) (warn 'deprecated-function-warning :name name))
+      ((:error) (cerror "USE FUNCTION ANYWAY" 'deprecated-function-error :name name))))
+
+  (defun version-deprecation (version &key (style-warning nil)
+                                        (warning (next-version style-warning))
+                                        (error (next-version warning))
+                                        (delete (next-version error)))
+    "Given a VERSION string, and the starting versions for notifying the programmer of
+various levels of deprecation, return the current level of deprecation as per WITH-DEPRECATION
+that is the highest level that has a declared version older than the specified version.
+Each start version for a level of deprecation can be specified by a keyword argument, or
+if left unspecified, will be the NEXT-VERSION of the immediate lower level of deprecation."
+    (cond
+      ((and delete (version<= delete version)) :delete)
+      ((and error (version<= error version)) :error)
+      ((and warning (version<= warning version)) :warning)
+      ((and style-warning (version<= style-warning version)) :style-warning)))
+
+  (defmacro with-deprecation ((level) &body definitions)
+    "Given a deprecation LEVEL (a form to be EVAL'ed at macro-expansion time), instrument the
+DEFUN and DEFMETHOD forms in DEFINITIONS to notify the programmer of the deprecation of the function
+when it is compiled or called.
+
+Increasing levels (as result from evaluating LEVEL) are: NIL (not deprecated yet),
+:STYLE-WARNING (a style warning is issued when used), :WARNING (a full warning is issued when used),
+:ERROR (a continuable error instead), and :DELETE (it's an error if the code is still there while
+at that level).
+
+Forms other than DEFUN and DEFMETHOD are not instrumented, and you can protect a DEFUN or DEFMETHOD
+from instrumentation by enclosing it in a PROGN."
+    (let ((level (eval level)))
+      (check-type level (member nil :style-warning :warning :error :delete))
+      (when (eq level :delete)
+        (error 'deprecated-function-should-be-deleted :name
+               (mapcar 'second
+                       (remove-if-not #'(lambda (x) (member x '(defun defmethod)))
+                                      definitions :key 'first))))
+      (labels ((instrument (name head body whole)
+                 (if level
+                     (let ((notifiedp
+                            (intern (format nil "*~A-~A-~A-~A*"
+                                            :deprecated-function level name :notified-p))))
+                       (multiple-value-bind (remaining-forms declarations doc-string)
+                           (parse-body body :documentation t :whole whole)
+                         `(progn
+                            (defparameter ,notifiedp nil)
+                            ;; tell some implementations to use the compiler-macro
+                            (declaim (inline ,name))
+                            (define-compiler-macro ,name (&whole form &rest args)
+                              (declare (ignore args))
+                              (notify-deprecated-function ,level ',name)
+                              form)
+                            (,@head ,@(when doc-string (list doc-string)) ,@declarations
+                                    (unless ,notifiedp
+                                      (setf ,notifiedp t)
+                                      (notify-deprecated-function ,level ',name))
+                                    ,@remaining-forms))))
+                     `(progn
+                        (eval-when (:compile-toplevel :load-toplevel :execute)
+                          (setf (compiler-macro-function ',name) nil))
+                        (declaim (notinline ,name))
+                        (,@head ,@body)))))
+        `(progn
+           ,@(loop :for form :in definitions :collect
+               (cond
+                 ((and (consp form) (eq (car form) 'defun))
+                  (instrument (second form) (subseq form 0 3) (subseq form 3) form))
+                 ((and (consp form) (eq (car form) 'defmethod))
+                  (let ((body-start (if (listp (third form)) 3 4)))
+                    (instrument (second form)
+                                (subseq form 0 body-start)
+                                (subseq form body-start)
+                                form)))
+                 (t
+                  form))))))))
 ;;;; ---------------------------------------------------------------------------
 ;;;; Access to the Operating System
 
@@ -1671,13 +1891,18 @@ keywords explicitly."
     "Is the underlying operating system an (emulated?) MacOS 9 or earlier?"
     (featurep :mcl))
 
+  (defun os-haiku-p ()
+    "Is the underlying operating system Haiku?"
+    (featurep :haiku))
+
   (defun detect-os ()
     "Detects the current operating system. Only needs be run at compile-time,
 except on ABCL where it might change between FASL compilation and runtime."
     (loop* :with o
            :for (feature . detect) :in '((:os-unix . os-unix-p) (:os-macosx . os-macosx-p)
                                          (:os-windows . os-windows-p)
-                                         (:genera . os-genera-p) (:os-oldmac . os-oldmac-p))
+                                         (:genera . os-genera-p) (:os-oldmac . os-oldmac-p)
+                                         (:haiku . os-haiku-p))
            :when (and (or (not o) (eq feature :os-macosx)) (funcall detect))
            :do (setf o feature) (pushnew feature *features*)
            :else :do (setf *features* (remove feature *features*))
@@ -1832,16 +2057,20 @@ then returning the non-empty string value of the variable"
         #+scl (format nil "~A~A" s
                       ;; ANSI upper case vs lower case.
                       (ecase ext:*case-mode* (:upper "") (:lower "l")))
-        #+clasp (format nil "~A-~A"
-                        s (core:lisp-implementation-id))
-        #+(and ecl (not clasp)) (format nil "~A~@[-~A~]" s
-                                       (let ((vcs-id (ext:lisp-implementation-vcs-id)))
-                                         (subseq vcs-id 0 (min (length vcs-id) 8))))
+        #+ecl (format nil "~A~@[-~A~]" s
+                      (let ((vcs-id (ext:lisp-implementation-vcs-id)))
+                        (subseq vcs-id 0 (min (length vcs-id) 8))))
         #+gcl (subseq s (1+ (position #\space s)))
         #+genera
         (multiple-value-bind (major minor) (sct:get-system-version "System")
           (format nil "~D.~D" major minor))
         #+mcl (subseq s 8) ; strip the leading "Version "
+        ;; seems like there should be a shorter way to do this, like ACALL.
+        #+mkcl (or
+                (let ((fname (find-symbol* '#:git-describe-this-mkcl :mkcl nil)))
+                  (when (and fname (fboundp fname))
+                    (funcall fname)))
+                s)
         s))))
 
   (defun implementation-identifier ()
@@ -1851,7 +2080,7 @@ suitable for use as a directory name to segregate Lisp FASLs, C dynamic librarie
      #\_ #'(lambda (x) (find x " /:;&^\\|?<>(){}[]$#`'\""))
      (format nil "~(~a~@{~@[-~a~]~}~)"
              (or (implementation-type) (lisp-implementation-type))
-             (or (lisp-version-string) (lisp-implementation-version))
+             (lisp-version-string)
              (or (operating-system) (software-type))
              (or (architecture) (machine-type))))))
 
@@ -2021,7 +2250,6 @@ the number having BYTES octets (defaulting to 4)."
    #:pathname-directory-pathname #:pathname-parent-directory-pathname
    #:directory-pathname-p #:ensure-directory-pathname
    ;; Parsing filenames
-   #:component-name-to-pathname-components
    #:split-name-type #:parse-unix-namestring #:unix-namestring
    #:split-unix-namestring-directory-components
    ;; Absolute and relative pathnames
@@ -2032,7 +2260,8 @@ the number having BYTES octets (defaulting to 4)."
    ;; Checking constraints
    #:ensure-pathname ;; implemented in filesystem.lisp to accommodate for existence constraints
    ;; Wildcard pathnames
-   #:*wild* #:*wild-file* #:*wild-directory* #:*wild-inferiors* #:*wild-path* #:wilden
+   #:*wild* #:*wild-file* #:*wild-file-for-directory* #:*wild-directory*
+   #:*wild-inferiors* #:*wild-path* #:wilden
    ;; Translate a pathname
    #:relativize-directory-component #:relativize-pathname-directory
    #:directory-separator-for-host #:directorize-pathname-host-device
@@ -2186,8 +2415,8 @@ when merging, making or parsing pathnames"
     ;; MCL has issues with make-pathname, nil and defaulting
     (declare (ignorable defaults))
     #.`(make-pathname :directory nil :name nil :type nil :version nil
-                      :device (or #+(and mkcl unix) :unspecific)
-                      :host (or #+cmucl lisp::*unix-host* #+(and mkcl unix) "localhost")
+                      :device (or #+(and mkcl os-unix) :unspecific)
+                      :host (or #+cmucl lisp::*unix-host* #+(and mkcl os-unix) "localhost")
                       #+scl ,@'(:scheme nil :scheme-specific-part nil
                                 :username nil :password nil :parameters nil :query nil :fragment nil)
                       ;; the default shouldn't matter, but we really want something physical
@@ -2225,7 +2454,7 @@ on ABCL, Genera and XCL, where it remains unchanged for it doubles as current-di
         (or (and (null p1) (null p2))
             (and (pathnamep p1) (pathnamep p2)
                  (and (=? pathname-host)
-                      #-(and mkcl unix) (=? pathname-device)
+                      #-(and mkcl os-unix) (=? pathname-device)
                       (=? normalize-pathname-directory-component pathname-directory)
                       (=? pathname-name)
                       (=? pathname-type)
@@ -2326,15 +2555,19 @@ actually-existing directory."
       ((directory-pathname-p pathspec)
        pathspec)
       (t
-       (make-pathname :directory (append (or (normalize-pathname-directory-component
-                                              (pathname-directory pathspec))
-                                             (list :relative))
-                                         (list (file-namestring pathspec)))
-                      :name nil :type nil :version nil :defaults pathspec)))))
+       (handler-case
+           (make-pathname :directory (append (or (normalize-pathname-directory-component
+                                                  (pathname-directory pathspec))
+                                                 (list :relative))
+                                             (list (file-namestring pathspec)))
+                          :name nil :type nil :version nil :defaults pathspec)
+         (error (c) (call-function on-error (compatfmt "~@<error while trying to create a directory pathname for ~S: ~A~@:>") pathspec c)))))))
 
 
 ;;; Parsing filenames
 (with-upgradability ()
+  (declaim (ftype function ensure-pathname)) ; forward reference
+
   (defun split-unix-namestring-directory-components
       (unix-namestring &key ensure-directory dot-dot)
     "Splits the path string UNIX-NAMESTRING, returning four values:
@@ -2609,7 +2842,11 @@ given DEFAULTS-PATHNAME as a base pathname."
   (defparameter *wild-file*
     (make-pathname :directory nil :name *wild* :type *wild*
                    :version (or #-(or allegro abcl xcl) *wild*))
-    "A pathname object with wildcards for matching any file in a given directory")
+    "A pathname object with wildcards for matching any file with TRANSLATE-PATHNAME")
+  (defparameter *wild-file-for-directory*
+    (make-pathname :directory nil :name *wild* :type (or #-(or clisp gcl) *wild*)
+                   :version (or #-(or allegro abcl clisp gcl xcl) *wild*))
+    "A pathname object with wildcards for matching any file with DIRECTORY")
   (defparameter *wild-directory*
     (make-pathname :directory `(:relative ,*wild-directory-component*)
                    :name nil :type nil :version nil)
@@ -2730,7 +2967,6 @@ whether their inputs were translated or not,
 which they will be if we are composing operations. e.g. if some
 create-lisp-op creates a lisp file from some higher-level input,
 you need to still be able to use compile-op on that lisp file."))
-
 ;;;; -------------------------------------------------------------------------
 ;;;; Portability layer around Common Lisp filesystem access
 
@@ -2804,7 +3040,7 @@ a CL pathname satisfying all the specified constraints as per ENSURE-PATHNAME"
        (or (ignore-errors (truename p))
            ;; this is here because trying to find the truename of a directory pathname WITHOUT supplying
            ;; a trailing directory separator, causes an error on some lisps.
-           #+(or clisp gcl) (if-let (d (ensure-directory-pathname p)) (ignore-errors (truename d)))))))
+           #+(or clisp gcl) (if-let (d (ensure-directory-pathname p nil)) (ignore-errors (truename d)))))))
 
   (defun safe-file-write-date (pathname)
     "Safe variant of FILE-WRITE-DATE that may return NIL rather than raise an error."
@@ -2823,7 +3059,7 @@ a CL pathname satisfying all the specified constraints as per ENSURE-PATHNAME"
   (defun probe-file* (p &key truename)
     "when given a pathname P (designated by a string as per PARSE-NAMESTRING),
 probes the filesystem for a file or directory with given pathname.
-If it exists, return its truename is ENSURE-PATHNAME is true,
+If it exists, return its truename if TRUENAME is true,
 or the original (parsed) pathname if it is false (the default)."
     (values
      (ignore-errors
@@ -2869,9 +3105,9 @@ or the original (parsed) pathname if it is false (the default)."
             (probe-file p)
             (and
              #+(or cmucl scl) (unix:unix-stat (ext:unix-namestring p))
-             #+(and lispworks unix) (system:get-file-stat p)
+             #+(and lispworks os-unix) (system:get-file-stat p)
              #+sbcl (sb-unix:unix-stat (sb-ext:native-namestring p))
-             #-(or cmucl (and lispworks unix) sbcl scl) (file-write-date p)
+             #-(or cmucl (and lispworks os-unix) sbcl scl) (file-write-date p)
              p))))))
 
   (defun directory-exists-p (x)
@@ -2904,11 +3140,14 @@ Try to override the defaults to not resolving symlinks, if implementation allows
                                         '(:resolve-symlinks nil))))))
 
   (defun filter-logical-directory-results (directory entries merger)
-    "Given ENTRIES in a DIRECTORY, remove if the directory is logical
-the entries which are physical yet when transformed by MERGER have a different TRUENAME.
-This function is used as a helper to DIRECTORY-FILES to avoid invalid entries when using logical-pathnames."
-    (remove-duplicates ;; on CLISP, querying ~/ will return duplicates
-     (if (logical-pathname-p directory)
+    "If DIRECTORY isn't a logical pathname, return ENTRIES. If it is,
+given ENTRIES in the DIRECTORY, remove the entries which are physical yet
+when transformed by MERGER have a different TRUENAME.
+Also remove duplicates as may appear with some translation rules.
+This function is used as a helper to DIRECTORY-FILES to avoid invalid entries
+when using logical-pathnames."
+    (if (logical-pathname-p directory)
+        (remove-duplicates ;; on CLISP, querying ~/ will return duplicates
          ;; Try hard to not resolve logical-pathname into physical pathnames;
          ;; otherwise logical-pathname users/lovers will be disappointed.
          ;; If directory* could use some implementation-dependent magic,
@@ -2922,12 +3161,11 @@ This function is used as a helper to DIRECTORY-FILES to avoid invalid entries wh
                               ;; At this point f should already be a truename,
                               ;; but isn't quite in CLISP, for it doesn't have :version :newest
                               (and u (equal (truename* u) (truename* f)) u)))
-               :when p :collect p)
-         entries)
-     :test 'pathname-equal))
-
+           :when p :collect p)
+         :test 'pathname-equal)
+        entries))
 
-  (defun directory-files (directory &optional (pattern *wild-file*))
+  (defun directory-files (directory &optional (pattern *wild-file-for-directory*))
     "Return a list of the files in a directory according to the PATTERN.
 Subdirectories should NOT be returned.
   PATTERN defaults to a pattern carefully chosen based on the implementation;
@@ -2945,10 +3183,7 @@ but the behavior in presence of symlinks is not portable. Use IOlib to handle su
           (error "Invalid file pattern ~S for logical directory ~S" pattern directory))
         (setf pattern (make-pathname-logical pattern (pathname-host dir))))
       (let* ((pat (merge-pathnames* pattern dir))
-             (entries (append (ignore-errors (directory* pat))
-                              #+(or clisp gcl)
-                              (when (equal :wild (pathname-type pattern))
-                                (ignore-errors (directory* (make-pathname :type nil :defaults pat)))))))
+             (entries (ignore-errors (directory* pat))))
         (remove-if 'directory-pathname-p
                    (filter-logical-directory-results
                     directory entries
@@ -2983,7 +3218,7 @@ The behavior in presence of symlinks is not portable. Use IOlib to handle such s
                        #+(or cmucl sbcl scl) (directory-pathname-p x)
                        #+genera (getf (cdr x) :directory)
                        #+lispworks (lw:file-directory-p x)
-                       :when d :collect #+(or abcl allegro xcl) d
+                       :when d :collect #+(or abcl allegro xcl) (ensure-directory-pathname d)
                          #+genera (ensure-directory-pathname (first x))
                        #+(or cmucl lispworks sbcl scl) x)))
       (filter-logical-directory-results
@@ -3280,7 +3515,7 @@ NILs."
     (let ((dir
             #+abcl extensions:*lisp-home*
             #+(or allegro clasp ecl mkcl) #p"SYS:"
-            ;;#+clisp custom:*lib-directory* ; causes failure in asdf-pathname-test(!)
+            #+clisp custom:*lib-directory*
             #+clozure #p"ccl:"
             #+cmucl (ignore-errors (pathname-parent-directory-pathname (truename #p"modules:")))
             #+gcl system::*system-directory*
@@ -3322,13 +3557,16 @@ NILs."
   (defun rename-file-overwriting-target (source target)
     "Rename a file, overwriting any previous file with the TARGET name,
 in an atomic way if the implementation allows."
-    #+clisp ;; in recent enough versions of CLISP, :if-exists :overwrite would make it atomic
-    (progn (funcall 'require "syscalls")
-           (symbol-call :posix :copy-file source target :method :rename))
-    #+(and sbcl os-windows) (delete-file-if-exists target) ;; not atomic
-    #-clisp
-    (rename-file source target
-                 #+(or clasp clozure ecl) :if-exists #+clozure :rename-and-delete #+(or clasp ecl) t))
+    (let ((source (ensure-pathname source :namestring :lisp :ensure-physical t :want-file t))
+          (target (ensure-pathname target :namestring :lisp :ensure-physical t :want-file t)))
+      #+clisp ;; in recent enough versions of CLISP, :if-exists :overwrite would make it atomic
+      (progn (funcall 'require "syscalls")
+             (symbol-call :posix :copy-file source target :method :rename))
+      #+(and sbcl os-windows) (delete-file-if-exists target) ;; not atomic
+      #-clisp
+      (rename-file source target
+                   #+(or clasp clozure ecl) :if-exists
+                   #+clozure :rename-and-delete #+(or clasp ecl) t)))
 
   (defun delete-empty-directory (directory-pathname)
     "Delete an empty directory"
@@ -3353,7 +3591,7 @@ in an atomic way if the implementation allows."
                `(progn (require :sb-posix) (symbol-call :sb-posix :rmdir directory-pathname)))
     #+xcl (symbol-call :uiop :run-program `("rmdir" ,(native-namestring directory-pathname)))
     #-(or abcl allegro clasp clisp clozure cmucl cormanlisp digitool ecl gcl genera lispworks mkcl sbcl scl xcl)
-    (error "~S not implemented on ~S" 'delete-empty-directory (implementation-type))) ; genera
+    (not-implemented-error 'delete-empty-directory "(on your platform)")) ; genera
 
   (defun delete-directory-tree (directory-pathname &key (validate nil validatep) (if-does-not-exist :error))
     "Delete a directory including all its recursive contents, aka rm -rf.
@@ -3433,6 +3671,7 @@ If you're suicidal or extremely confident, just use :VALIDATE T."
    #:read-file-forms #:read-file-form #:safe-read-file-form
    #:eval-input #:eval-thunk #:standard-eval-thunk
    #:println #:writeln
+   #:file-stream-p #:file-or-synonym-stream-p
    ;; Temporary files
    #:*temporary-directory* #:temporary-directory #:default-temporary-directory
    #:setup-temporary-directory
@@ -3780,6 +4019,11 @@ Otherwise, using WRITE-SEQUENCE using a buffer of size BUFFER-SIZE."
   (defun copy-file (input output)
     "Copy contents of the INPUT file to the OUTPUT file"
     ;; Not available on LW personal edition or LW 6.0 on Mac: (lispworks:copy-file i f)
+    #+allegro
+    (excl.osi:copy-file input output)
+    #+ecl
+    (ext:copy-file input output)
+    #-(or allegro ecl)
     (concatenate-files (list input) output))
 
   (defun slurp-stream-string (input &key (element-type 'character) stripped)
@@ -3901,7 +4145,7 @@ within an WITH-SAFE-IO-SYNTAX using the specified PACKAGE."
             :for form = (read input nil eof)
             :until (eq form eof)
             :do (setf results (multiple-value-list (eval form)))
-            :finally (return (apply 'values results)))))
+            :finally (return (values-list results)))))
 
   (defun eval-thunk (thunk)
     "Evaluate a THUNK of code:
@@ -3965,7 +4209,7 @@ If a string, repeatedly read and evaluate from it, returning the last values."
     "Call a THUNK with stream and/or pathname arguments identifying a temporary file.
 
 The temporary file's pathname will be based on concatenating
-PREFIX (defaults to \"uiop\"), a random alphanumeric string,
+PREFIX (or \"tmp\" if it's NIL), a random alphanumeric string,
 and optional SUFFIX (defaults to \"-tmp\" if a type was provided)
 and TYPE (defaults to \"tmp\", using a dot as separator if not NIL),
 within DIRECTORY (defaulting to the TEMPORARY-DIRECTORY) if the PREFIX isn't absolute.
@@ -3987,7 +4231,11 @@ Finally, the file will be deleted, unless the KEEP argument when CALL-FUNCTION'e
     (loop
       :with prefix-pn = (ensure-absolute-pathname
                          (or prefix "tmp")
-                         (or (ensure-pathname directory :namestring :native :ensure-directory t)
+                         (or (ensure-pathname
+                              directory
+                              :namestring :native
+                              :ensure-directory t
+                              :ensure-physical t)
                              #'temporary-directory))
       :with prefix-nns = (native-namestring prefix-pn)
       :with results = (progn (ensure-directories-exist prefix-pn)
@@ -4023,7 +4271,7 @@ Finally, the file will be deleted, unless the KEEP argument when CALL-FUNCTION'e
                  ((not okp) nil)
                  (after (return (call-function after okp)))
                  ((and want-pathname-p (not want-stream-p)) (return (call-function thunk okp)))
-                 (t (return (apply 'values results)))))
+                 (t (return (values-list results)))))
           (when (and okp (not (call-function keep)))
             (ignore-errors (delete-file-if-exists okp))))))
 
@@ -4087,9 +4335,9 @@ Further KEYS can be passed to MAKE-PATHNAME."
     "Return a new pathname modified from X by adding a trivial random suffix.
 A new empty file with said temporary pathname is created, to ensure there is no
 clash with any concurrent process attempting the same thing."
-    (let* ((px (ensure-pathname x))
+    (let* ((px (ensure-pathname x :ensure-physical t))
            (prefix (if-let (n (pathname-name px)) (strcat n "-tmp") "tmp"))
-           (directory (translate-logical-pathname (pathname-directory-pathname px))))
+           (directory (pathname-directory-pathname px)))
       (get-temporary-file :directory directory :prefix prefix :type (pathname-type px))))
 
   (defun call-with-staging-pathname (pathname fun)
@@ -4108,6 +4356,15 @@ For the latter case, we ought pick a random suffix and atomically open it."
   (defmacro with-staging-pathname ((pathname-var &optional (pathname-value pathname-var)) &body body)
     "Trivial syntax wrapper for CALL-WITH-STAGING-PATHNAME"
     `(call-with-staging-pathname ,pathname-value #'(lambda (,pathname-var) ,@body))))
+
+(with-upgradability ()
+  (defun file-stream-p (stream)
+    (typep stream 'file-stream))
+  (defun file-or-synonym-stream-p (stream)
+    (or (file-stream-p stream)
+        (and (typep stream 'synonym-stream)
+             (file-or-synonym-stream-p
+              (symbol-value (synonym-stream-symbol stream)))))))
 ;;;; -------------------------------------------------------------------------
 ;;;; Starting, Stopping, Dumping a Lisp image
 
@@ -4117,7 +4374,8 @@ For the latter case, we ought pick a random suffix and atomically open it."
    #:*image-dumped-p* #:raw-command-line-arguments #:*command-line-arguments*
    #:command-line-arguments #:raw-command-line-arguments #:setup-command-line-arguments #:argv0
    #:*lisp-interaction*
-   #:*fatal-conditions* #:fatal-condition-p #:handle-fatal-condition
+   #:fatal-condition #:fatal-condition-p
+   #:handle-fatal-condition
    #:call-with-fatal-condition-handler #:with-fatal-condition-handler
    #:*image-restore-hook* #:*image-prelude* #:*image-entry-point*
    #:*image-postlude* #:*image-dump-hook*
@@ -4159,10 +4417,8 @@ before the image dump hooks are called and before the image is dumped.")
   (defvar *image-dump-hook* nil
     "Functions to call (in order) when before an image is dumped")
 
-  (defvar *fatal-conditions* '(error)
-    "conditions that cause the Lisp image to enter the debugger if interactive,
-or to die if not interactive"))
-
+  (deftype fatal-condition ()
+    `(and serious-condition #+clozure (not ccl:process-reset))))
 
 ;;; Exiting properly or im-
 (with-upgradability ()
@@ -4279,8 +4535,8 @@ This is designed to abstract away the implementation specific quit forms."
                     condition)))
 
   (defun fatal-condition-p (condition)
-    "Is the CONDITION fatal? It is if it matches any in *FATAL-CONDITIONS*"
-    (match-any-condition-p condition *fatal-conditions*))
+    "Is the CONDITION fatal?"
+    (typep condition 'fatal-condition))
 
   (defun handle-fatal-condition (condition)
     "Handle a fatal CONDITION:
@@ -4295,7 +4551,7 @@ depending on whether *LISP-INTERACTION* is set, enter debugger or die"
 
   (defun call-with-fatal-condition-handler (thunk)
     "Call THUNK in a context where fatal conditions are appropriately handled"
-    (handler-bind (((satisfies fatal-condition-p) #'handle-fatal-condition))
+    (handler-bind ((fatal-condition #'handle-fatal-condition))
       (funcall thunk)))
 
   (defmacro with-fatal-condition-handler ((&optional) &body body)
@@ -4343,7 +4599,7 @@ depending on whether *LISP-INTERACTION* is set, enter debugger or die"
     #+sbcl sb-ext:*posix-argv*
     #+xcl system:*argv*
     #-(or abcl allegro clasp clisp clozure cmucl ecl gcl genera lispworks mcl mkcl sbcl scl xcl)
-    (error "raw-command-line-arguments not implemented yet"))
+    (not-implemented-error 'raw-command-line-arguments))
 
   (defun command-line-arguments (&optional (arguments (raw-command-line-arguments)))
     "Extract user arguments from command-line invocation of current process.
@@ -4429,7 +4685,7 @@ of the function will be returned rather than interpreted as a boolean designatin
                           (call-function entry-point)
                           t))))
         (if lisp-interaction
-            (apply 'values results)
+            (values-list results)
             (shell-boolean-exit (first results)))))))
 
 
@@ -4461,7 +4717,7 @@ or COMPRESSION on SBCL, and APPLICATION-TYPE on SBCL/Windows."
     (setf *image-dump-hook* dump-hook)
     (call-image-dump-hook)
     (setf *image-restored-p* nil)
-    #-(or clisp clozure cmucl lispworks sbcl scl)
+    #-(or clisp clozure (and cmucl executable) lispworks sbcl scl)
     (when executable
       (error "Dumping an executable is not supported on this implementation! Aborting."))
     #+allegro
@@ -4495,8 +4751,10 @@ or COMPRESSION on SBCL, and APPLICATION-TYPE on SBCL/Windows."
       (setf ext:*batch-mode* nil)
       (setf ext::*gc-run-time* 0)
       (apply 'ext:save-lisp filename
-             #+cmucl :executable #+cmucl t
-             (when executable '(:init-function restore-image :process-command-line nil))))
+             :allow-other-keys t ;; hush SCL and old versions of CMUCL
+             #+(and cmucl executable) :executable #+(and cmucl executable) t
+             (when executable '(:init-function restore-image :process-command-line nil
+                                :quiet t :load-init-file nil :site-init nil))))
     #+gcl
     (progn
       (si::set-hole-size 500) (si::gbc nil) (si::sgc-on t)
@@ -4533,7 +4791,7 @@ or COMPRESSION on SBCL, and APPLICATION-TYPE on SBCL/Windows."
     ;; Is it meaningful to run these in the current environment?
     ;; only if we also track the object files that constitute the "current" image,
     ;; and otherwise simulate dump-image, including quitting at the end.
-    #-(or clasp ecl mkcl) (error "~S not implemented for your implementation (yet)" 'create-image)
+    #-(or clasp ecl mkcl) (not-implemented-error 'create-image)
     #+(or clasp ecl mkcl)
     (let ((epilogue-code
            (if no-uiop
@@ -4556,7 +4814,7 @@ or COMPRESSION on SBCL, and APPLICATION-TYPE on SBCL/Windows."
                  (when forms `(progn ,@forms))))))
       #+(or clasp ecl) (check-type kind (member :dll :lib :static-library :program :object :fasl))
       (apply #+clasp 'cmp:builder #+clasp kind
-             #+(and ecl (not clasp)) 'c::builder #+(and ecl (not clasp)) kind
+             #+ecl 'c::builder #+ecl kind
              #+mkcl (ecase kind
                       ((:dll) 'compiler::build-shared-library)
                       ((:lib :static-library) 'compiler::build-static-library)
@@ -4579,1712 +4837,2032 @@ or COMPRESSION on SBCL, and APPLICATION-TYPE on SBCL/Windows."
          setup-command-line-arguments setup-temporary-directory
          #+abcl detect-os)))
 ;;;; -------------------------------------------------------------------------
-;;;; run-program initially from xcvb-driver.
+;;;; Support to build (compile and load) Lisp files
 
-(uiop/package:define-package :uiop/run-program
-  (:nicknames :asdf/run-program) ; OBSOLETE. Used by cl-sane, printv.
+(uiop/package:define-package :uiop/lisp-build
+  (:nicknames :asdf/lisp-build) ;; OBSOLETE, used by slime/contrib/swank-asdf.lisp
   (:use :uiop/common-lisp :uiop/package :uiop/utility
-   :uiop/pathname :uiop/os :uiop/filesystem :uiop/stream)
+   :uiop/os :uiop/pathname :uiop/filesystem :uiop/stream :uiop/image)
   (:export
-   ;;; Escaping the command invocation madness
-   #:easy-sh-character-p #:escape-sh-token #:escape-sh-command
-   #:escape-windows-token #:escape-windows-command
-   #:escape-token #:escape-command
-
-   ;;; run-program
-   #:slurp-input-stream #:vomit-output-stream
-   #:run-program
-   #:subprocess-error
-   #:subprocess-error-code #:subprocess-error-command #:subprocess-error-process
-   ))
-(in-package :uiop/run-program)
-
-;;;; ----- Escaping strings for the shell -----
+   ;; Variables
+   #:*compile-file-warnings-behaviour* #:*compile-file-failure-behaviour*
+   #:*output-translation-function*
+   #:*optimization-settings* #:*previous-optimization-settings*
+   #:*base-build-directory*
+   #:compile-condition #:compile-file-error #:compile-warned-error #:compile-failed-error
+   #:compile-warned-warning #:compile-failed-warning
+   #:check-lisp-compile-results #:check-lisp-compile-warnings
+   #:*uninteresting-conditions* #:*usual-uninteresting-conditions*
+   #:*uninteresting-compiler-conditions* #:*uninteresting-loader-conditions*
+   ;; Types
+   #+sbcl #:sb-grovel-unknown-constant-condition
+   ;; Functions & Macros
+   #:get-optimization-settings #:proclaim-optimization-settings #:with-optimization-settings
+   #:call-with-muffled-compiler-conditions #:with-muffled-compiler-conditions
+   #:call-with-muffled-loader-conditions #:with-muffled-loader-conditions
+   #:reify-simple-sexp #:unreify-simple-sexp
+   #:reify-deferred-warnings #:unreify-deferred-warnings
+   #:reset-deferred-warnings #:save-deferred-warnings #:check-deferred-warnings
+   #:with-saved-deferred-warnings #:warnings-file-p #:warnings-file-type #:*warnings-file-type*
+   #:enable-deferred-warnings-check #:disable-deferred-warnings-check
+   #:current-lisp-file-pathname #:load-pathname
+   #:lispize-pathname #:compile-file-type #:call-around-hook
+   #:compile-file* #:compile-file-pathname* #:*compile-check*
+   #:load* #:load-from-string #:combine-fasls)
+  (:intern #:defaults #:failure-p #:warnings-p #:s #:y #:body))
+(in-package :uiop/lisp-build)
 
 (with-upgradability ()
-  (defun requires-escaping-p (token &key good-chars bad-chars)
-    "Does this token require escaping, given the specification of
-either good chars that don't need escaping or bad chars that do need escaping,
-as either a recognizing function or a sequence of characters."
-    (some
-     (cond
-       ((and good-chars bad-chars)
-        (error "only one of good-chars and bad-chars can be provided"))
-       ((typep good-chars 'function)
-        (complement good-chars))
-       ((typep bad-chars 'function)
-        bad-chars)
-       ((and good-chars (typep good-chars 'sequence))
-        #'(lambda (c) (not (find c good-chars))))
-       ((and bad-chars (typep bad-chars 'sequence))
-        #'(lambda (c) (find c bad-chars)))
-       (t (error "requires-escaping-p: no good-char criterion")))
-     token))
-
-  (defun escape-token (token &key stream quote good-chars bad-chars escaper)
-    "Call the ESCAPER function on TOKEN string if it needs escaping as per
-REQUIRES-ESCAPING-P using GOOD-CHARS and BAD-CHARS, otherwise output TOKEN,
-using STREAM as output (or returning result as a string if NIL)"
-    (if (requires-escaping-p token :good-chars good-chars :bad-chars bad-chars)
-        (with-output (stream)
-          (apply escaper token stream (when quote `(:quote ,quote))))
-        (output-string token stream)))
-
-  (defun escape-windows-token-within-double-quotes (x &optional s)
-    "Escape a string token X within double-quotes
-for use within a MS Windows command-line, outputing to S."
-    (labels ((issue (c) (princ c s))
-             (issue-backslash (n) (loop :repeat n :do (issue #\\))))
-      (loop
-        :initially (issue #\") :finally (issue #\")
-        :with l = (length x) :with i = 0
-        :for i+1 = (1+ i) :while (< i l) :do
-          (case (char x i)
-            ((#\") (issue-backslash 1) (issue #\") (setf i i+1))
-            ((#\\)
-             (let* ((j (and (< i+1 l) (position-if-not
-                                       #'(lambda (c) (eql c #\\)) x :start i+1)))
-                    (n (- (or j l) i)))
-               (cond
-                 ((null j)
-                  (issue-backslash (* 2 n)) (setf i l))
-                 ((and (< j l) (eql (char x j) #\"))
-                  (issue-backslash (1+ (* 2 n))) (issue #\") (setf i (1+ j)))
-                 (t
-                  (issue-backslash n) (setf i j)))))
-            (otherwise
-             (issue (char x i)) (setf i i+1))))))
-
-  (defun easy-windows-character-p (x)
-    "Is X an \"easy\" character that does not require quoting by the shell?"
-    (or (alphanumericp x) (find x "+-_.,@:/=")))
-
-  (defun escape-windows-token (token &optional s)
-    "Escape a string TOKEN within double-quotes if needed
-for use within a MS Windows command-line, outputing to S."
-    (escape-token token :stream s :good-chars #'easy-windows-character-p :quote nil
-                        :escaper 'escape-windows-token-within-double-quotes))
-
-  (defun escape-sh-token-within-double-quotes (x s &key (quote t))
-    "Escape a string TOKEN within double-quotes
-for use within a POSIX Bourne shell, outputing to S;
-omit the outer double-quotes if key argument :QUOTE is NIL"
-    (when quote (princ #\" s))
-    (loop :for c :across x :do
-      (when (find c "$`\\\"") (princ #\\ s))
-      (princ c s))
-    (when quote (princ #\" s)))
+  (defvar *compile-file-warnings-behaviour*
+    (or #+clisp :ignore :warn)
+    "How should ASDF react if it encounters a warning when compiling a file?
+Valid values are :error, :warn, and :ignore.")
 
-  (defun easy-sh-character-p (x)
-    "Is X an \"easy\" character that does not require quoting by the shell?"
-    (or (alphanumericp x) (find x "+-_.,%@:/=")))
+  (defvar *compile-file-failure-behaviour*
+    (or #+(or mkcl sbcl) :error #+clisp :ignore :warn)
+    "How should ASDF react if it encounters a failure (per the ANSI spec of COMPILE-FILE)
+when compiling a file, which includes any non-style-warning warning.
+Valid values are :error, :warn, and :ignore.
+Note that ASDF ALWAYS raises an error if it fails to create an output file when compiling.")
 
-  (defun escape-sh-token (token &optional s)
-    "Escape a string TOKEN within double-quotes if needed
-for use within a POSIX Bourne shell, outputing to S."
-    (escape-token token :stream s :quote #\" :good-chars #'easy-sh-character-p
-                        :escaper 'escape-sh-token-within-double-quotes))
+  (defvar *base-build-directory* nil
+    "When set to a non-null value, it should be an absolute directory pathname,
+which will serve as the *DEFAULT-PATHNAME-DEFAULTS* around a COMPILE-FILE,
+what more while the input-file is shortened if possible to ENOUGH-PATHNAME relative to it.
+This can help you produce more deterministic output for FASLs."))
 
-  (defun escape-shell-token (token &optional s)
-    "Escape a token for the current operating system shell"
-    (os-cond
-      ((os-unix-p) (escape-sh-token token s))
-      ((os-windows-p) (escape-windows-token token s))))
-
-  (defun escape-command (command &optional s
-                                  (escaper 'escape-shell-token))
-    "Given a COMMAND as a list of tokens, return a string of the
-spaced, escaped tokens, using ESCAPER to escape."
-    (etypecase command
-      (string (output-string command s))
-      (list (with-output (s)
-              (loop :for first = t :then nil :for token :in command :do
-                (unless first (princ #\space s))
-                (funcall escaper token s))))))
+;;; Optimization settings
+(with-upgradability ()
+  (defvar *optimization-settings* nil
+    "Optimization settings to be used by PROCLAIM-OPTIMIZATION-SETTINGS")
+  (defvar *previous-optimization-settings* nil
+    "Optimization settings saved by PROCLAIM-OPTIMIZATION-SETTINGS")
+  (defparameter +optimization-variables+
+    ;; TODO: allegro genera corman mcl
+    (or #+(or abcl xcl) '(system::*speed* system::*space* system::*safety* system::*debug*)
+        #+clisp '() ;; system::*optimize* is a constant hash-table! (with non-constant contents)
+        #+clozure '(ccl::*nx-speed* ccl::*nx-space* ccl::*nx-safety*
+                    ccl::*nx-debug* ccl::*nx-cspeed*)
+        #+(or cmucl scl) '(c::*default-cookie*)
+        #+clasp '()
+        #+ecl (unless (use-ecl-byte-compiler-p) '(c::*speed* c::*space* c::*safety* c::*debug*))
+        #+gcl '(compiler::*speed* compiler::*space* compiler::*compiler-new-safety* compiler::*debug*)
+        #+lispworks '(compiler::*optimization-level*)
+        #+mkcl '(si::*speed* si::*space* si::*safety* si::*debug*)
+        #+sbcl '(sb-c::*policy*)))
+  (defun get-optimization-settings ()
+    "Get current compiler optimization settings, ready to PROCLAIM again"
+    #-(or abcl allegro clasp clisp clozure cmucl ecl lispworks mkcl sbcl scl xcl)
+    (warn "~S does not support ~S. Please help me fix that."
+          'get-optimization-settings (implementation-type))
+    #+(or abcl allegro clasp clisp clozure cmucl ecl lispworks mkcl sbcl scl xcl)
+    (let ((settings '(speed space safety debug compilation-speed #+(or cmucl scl) c::brevity)))
+      #.`(loop #+(or allegro clozure)
+               ,@'(:with info = #+allegro (sys:declaration-information 'optimize)
+                   #+clozure (ccl:declaration-information 'optimize nil))
+               :for x :in settings
+               ,@(or #+(or abcl clasp ecl gcl mkcl xcl) '(:for v :in +optimization-variables+))
+               :for y = (or #+(or allegro clozure) (second (assoc x info)) ; normalize order
+                            #+clisp (gethash x system::*optimize* 1)
+                            #+(or abcl clasp ecl mkcl xcl) (symbol-value v)
+                            #+(or cmucl scl) (slot-value c::*default-cookie*
+                                                       (case x (compilation-speed 'c::cspeed)
+                                                             (otherwise x)))
+                            #+lispworks (slot-value compiler::*optimization-level* x)
+                            #+sbcl (sb-c::policy-quality sb-c::*policy* x))
+               :when y :collect (list x y))))
+  (defun proclaim-optimization-settings ()
+    "Proclaim the optimization settings in *OPTIMIZATION-SETTINGS*"
+    (proclaim `(optimize ,@*optimization-settings*))
+    (let ((settings (get-optimization-settings)))
+      (unless (equal *previous-optimization-settings* settings)
+        (setf *previous-optimization-settings* settings))))
+  (defmacro with-optimization-settings ((&optional (settings *optimization-settings*)) &body body)
+    #+(or allegro clisp)
+    (let ((previous-settings (gensym "PREVIOUS-SETTINGS")))
+      `(let ((,previous-settings (get-optimization-settings)))
+         ,@(when settings `((proclaim `(optimize ,@,settings))))
+         (unwind-protect (progn ,@body)
+           (proclaim `(optimize ,@,previous-settings)))))
+    #-(or allegro clisp)
+    `(let ,(loop :for v :in +optimization-variables+ :collect `(,v ,v))
+       ,@(when settings `((proclaim `(optimize ,@,settings))))
+       ,@body)))
 
-  (defun escape-windows-command (command &optional s)
-    "Escape a list of command-line arguments into a string suitable for parsing
-by CommandLineToArgv in MS Windows"
-    ;; http://msdn.microsoft.com/en-us/library/bb776391(v=vs.85).aspx
-    ;; http://msdn.microsoft.com/en-us/library/17w5ykft(v=vs.85).aspx
-    (escape-command command s 'escape-windows-token))
 
-  (defun escape-sh-command (command &optional s)
-    "Escape a list of command-line arguments into a string suitable for parsing
-by /bin/sh in POSIX"
-    (escape-command command s 'escape-sh-token))
+;;; Condition control
+(with-upgradability ()
+  #+sbcl
+  (progn
+    (defun sb-grovel-unknown-constant-condition-p (c)
+      "Detect SB-GROVEL unknown-constant conditions on older versions of SBCL"
+      (and (typep c 'sb-int:simple-style-warning)
+           (string-enclosed-p
+            "Couldn't grovel for "
+            (simple-condition-format-control c)
+            " (unknown to the C compiler).")))
+    (deftype sb-grovel-unknown-constant-condition ()
+      '(and style-warning (satisfies sb-grovel-unknown-constant-condition-p))))
 
-  (defun escape-shell-command (command &optional stream)
-    "Escape a command for the current operating system's shell"
-    (escape-command command stream 'escape-shell-token)))
+  (defvar *usual-uninteresting-conditions*
+    (append
+     ;;#+clozure '(ccl:compiler-warning)
+     #+cmucl '("Deleting unreachable code.")
+     #+lispworks '("~S being redefined in ~A (previously in ~A)."
+                   "~S defined more than once in ~A.") ;; lispworks gets confused by eval-when.
+     #+sbcl
+     '(sb-c::simple-compiler-note
+       "&OPTIONAL and &KEY found in the same lambda list: ~S"
+       #+sb-eval sb-kernel:lexical-environment-too-complex
+       sb-kernel:undefined-alien-style-warning
+       sb-grovel-unknown-constant-condition ; defined above.
+       sb-ext:implicit-generic-function-warning ;; Controversial.
+       sb-int:package-at-variance
+       sb-kernel:uninteresting-redefinition
+       ;; BEWARE: the below four are controversial to include here.
+       sb-kernel:redefinition-with-defun
+       sb-kernel:redefinition-with-defgeneric
+       sb-kernel:redefinition-with-defmethod
+       sb-kernel::redefinition-with-defmacro) ; not exported by old SBCLs
+     '("No generic function ~S present when encountering macroexpansion of defmethod. Assuming it will be an instance of standard-generic-function.")) ;; from closer2mop
+    "A suggested value to which to set or bind *uninteresting-conditions*.")
 
+  (defvar *uninteresting-conditions* '()
+    "Conditions that may be skipped while compiling or loading Lisp code.")
+  (defvar *uninteresting-compiler-conditions* '()
+    "Additional conditions that may be skipped while compiling Lisp code.")
+  (defvar *uninteresting-loader-conditions*
+    (append
+     '("Overwriting already existing readtable ~S." ;; from named-readtables
+       #(#:finalizers-off-warning :asdf-finalizers)) ;; from asdf-finalizers
+     #+clisp '(clos::simple-gf-replacing-method-warning))
+    "Additional conditions that may be skipped while loading Lisp code."))
 
-;;;; Slurping a stream, typically the output of another program
+;;;; ----- Filtering conditions while building -----
 (with-upgradability ()
-  (defun call-stream-processor (fun processor stream)
-    "Given FUN (typically SLURP-INPUT-STREAM or VOMIT-OUTPUT-STREAM,
-a PROCESSOR specification which is either an atom or a list specifying
-a processor an keyword arguments, call the specified processor with
-the given STREAM as input"
-    (if (consp processor)
-        (apply fun (first processor) stream (rest processor))
-        (funcall fun processor stream)))
-
-  (defgeneric slurp-input-stream (processor input-stream &key)
-    (:documentation
-     "SLURP-INPUT-STREAM is a generic function with two positional arguments
-PROCESSOR and INPUT-STREAM and additional keyword arguments, that consumes (slurps)
-the contents of the INPUT-STREAM and processes them according to a method
-specified by PROCESSOR.
+  (defun call-with-muffled-compiler-conditions (thunk)
+    "Call given THUNK in a context where uninteresting conditions and compiler conditions are muffled"
+    (call-with-muffled-conditions
+     thunk (append *uninteresting-conditions* *uninteresting-compiler-conditions*)))
+  (defmacro with-muffled-compiler-conditions ((&optional) &body body)
+    "Trivial syntax for CALL-WITH-MUFFLED-COMPILER-CONDITIONS"
+    `(call-with-muffled-compiler-conditions #'(lambda () ,@body)))
+  (defun call-with-muffled-loader-conditions (thunk)
+    "Call given THUNK in a context where uninteresting conditions and loader conditions are muffled"
+    (call-with-muffled-conditions
+     thunk (append *uninteresting-conditions* *uninteresting-loader-conditions*)))
+  (defmacro with-muffled-loader-conditions ((&optional) &body body)
+    "Trivial syntax for CALL-WITH-MUFFLED-LOADER-CONDITIONS"
+    `(call-with-muffled-loader-conditions #'(lambda () ,@body))))
 
-Built-in methods include the following:
-* if PROCESSOR is a function, it is called with the INPUT-STREAM as its argument
-* if PROCESSOR is a list, its first element should be a function.  It will be applied to a cons of the
-  INPUT-STREAM and the rest of the list.  That is (x . y) will be treated as
-    \(APPLY x <stream> y\)
-* if PROCESSOR is an output-stream, the contents of INPUT-STREAM is copied to the output-stream,
-  per copy-stream-to-stream, with appropriate keyword arguments.
-* if PROCESSOR is the symbol CL:STRING or the keyword :STRING, then the contents of INPUT-STREAM
-  are returned as a string, as per SLURP-STREAM-STRING.
-* if PROCESSOR is the keyword :LINES then the INPUT-STREAM will be handled by SLURP-STREAM-LINES.
-* if PROCESSOR is the keyword :LINE then the INPUT-STREAM will be handled by SLURP-STREAM-LINE.
-* if PROCESSOR is the keyword :FORMS then the INPUT-STREAM will be handled by SLURP-STREAM-FORMS.
-* if PROCESSOR is the keyword :FORM then the INPUT-STREAM will be handled by SLURP-STREAM-FORM.
-* if PROCESSOR is T, it is treated the same as *standard-output*. If it is NIL, NIL is returned.
 
-Programmers are encouraged to define their own methods for this generic function."))
+;;;; Handle warnings and failures
+(with-upgradability ()
+  (define-condition compile-condition (condition)
+    ((context-format
+      :initform nil :reader compile-condition-context-format :initarg :context-format)
+     (context-arguments
+      :initform nil :reader compile-condition-context-arguments :initarg :context-arguments)
+     (description
+      :initform nil :reader compile-condition-description :initarg :description))
+    (:report (lambda (c s)
+               (format s (compatfmt "~@<~A~@[ while ~?~]~@:>")
+                       (or (compile-condition-description c) (type-of c))
+                       (compile-condition-context-format c)
+                       (compile-condition-context-arguments c)))))
+  (define-condition compile-file-error (compile-condition error) ())
+  (define-condition compile-warned-warning (compile-condition warning) ())
+  (define-condition compile-warned-error (compile-condition error) ())
+  (define-condition compile-failed-warning (compile-condition warning) ())
+  (define-condition compile-failed-error (compile-condition error) ())
 
-  #-genera
-  (defmethod slurp-input-stream ((function function) input-stream &key)
-    (funcall function input-stream))
+  (defun check-lisp-compile-warnings (warnings-p failure-p
+                                                  &optional context-format context-arguments)
+    "Given the warnings or failures as resulted from COMPILE-FILE or checking deferred warnings,
+raise an error or warning as appropriate"
+    (when failure-p
+      (case *compile-file-failure-behaviour*
+        (:warn (warn 'compile-failed-warning
+                     :description "Lisp compilation failed"
+                     :context-format context-format
+                     :context-arguments context-arguments))
+        (:error (error 'compile-failed-error
+                       :description "Lisp compilation failed"
+                       :context-format context-format
+                       :context-arguments context-arguments))
+        (:ignore nil)))
+    (when warnings-p
+      (case *compile-file-warnings-behaviour*
+        (:warn (warn 'compile-warned-warning
+                     :description "Lisp compilation had style-warnings"
+                     :context-format context-format
+                     :context-arguments context-arguments))
+        (:error (error 'compile-warned-error
+                       :description "Lisp compilation had style-warnings"
+                       :context-format context-format
+                       :context-arguments context-arguments))
+        (:ignore nil))))
 
-  (defmethod slurp-input-stream ((list cons) input-stream &key)
-    (apply (first list) input-stream (rest list)))
+  (defun check-lisp-compile-results (output warnings-p failure-p
+                                             &optional context-format context-arguments)
+    "Given the results of COMPILE-FILE, raise an error or warning as appropriate"
+    (unless output
+      (error 'compile-file-error :context-format context-format :context-arguments context-arguments))
+    (check-lisp-compile-warnings warnings-p failure-p context-format context-arguments)))
 
-  #-genera
-  (defmethod slurp-input-stream ((output-stream stream) input-stream
-                                 &key linewise prefix (element-type 'character) buffer-size)
-    (copy-stream-to-stream
-     input-stream output-stream
-     :linewise linewise :prefix prefix :element-type element-type :buffer-size buffer-size))
 
-  (defmethod slurp-input-stream ((x (eql 'string)) stream &key stripped)
-    (slurp-stream-string stream :stripped stripped))
+;;;; Deferred-warnings treatment, originally implemented by Douglas Katzman.
+;;;
+;;; To support an implementation, three functions must be implemented:
+;;; reify-deferred-warnings unreify-deferred-warnings reset-deferred-warnings
+;;; See their respective docstrings.
+(with-upgradability ()
+  (defun reify-simple-sexp (sexp)
+    "Given a simple SEXP, return a representation of it as a portable SEXP.
+Simple means made of symbols, numbers, characters, simple-strings, pathnames, cons cells."
+    (etypecase sexp
+      (symbol (reify-symbol sexp))
+      ((or number character simple-string pathname) sexp)
+      (cons (cons (reify-simple-sexp (car sexp)) (reify-simple-sexp (cdr sexp))))
+      (simple-vector (vector (mapcar 'reify-simple-sexp (coerce sexp 'list))))))
 
-  (defmethod slurp-input-stream ((x (eql :string)) stream &key stripped)
-    (slurp-stream-string stream :stripped stripped))
+  (defun unreify-simple-sexp (sexp)
+    "Given the portable output of REIFY-SIMPLE-SEXP, return the simple SEXP it represents"
+    (etypecase sexp
+      ((or symbol number character simple-string pathname) sexp)
+      (cons (cons (unreify-simple-sexp (car sexp)) (unreify-simple-sexp (cdr sexp))))
+      ((simple-vector 2) (unreify-symbol sexp))
+      ((simple-vector 1) (coerce (mapcar 'unreify-simple-sexp (aref sexp 0)) 'vector))))
 
-  (defmethod slurp-input-stream ((x (eql :lines)) stream &key count)
-    (slurp-stream-lines stream :count count))
+  #+clozure
+  (progn
+    (defun reify-source-note (source-note)
+      (when source-note
+        (with-accessors ((source ccl::source-note-source) (filename ccl:source-note-filename)
+                         (start-pos ccl:source-note-start-pos) (end-pos ccl:source-note-end-pos)) source-note
+          (declare (ignorable source))
+          (list :filename filename :start-pos start-pos :end-pos end-pos
+                #|:source (reify-source-note source)|#))))
+    (defun unreify-source-note (source-note)
+      (when source-note
+        (destructuring-bind (&key filename start-pos end-pos source) source-note
+          (ccl::make-source-note :filename filename :start-pos start-pos :end-pos end-pos
+                                 :source (unreify-source-note source)))))
+    (defun unsymbolify-function-name (name)
+      (if-let (setfed (gethash name ccl::%setf-function-name-inverses%))
+        `(setf ,setfed)
+        name))
+    (defun symbolify-function-name (name)
+      (if (and (consp name) (eq (first name) 'setf))
+          (let ((setfed (second name)))
+            (gethash setfed ccl::%setf-function-names%))
+          name))
+    (defun reify-function-name (function-name)
+      (let ((name (or (first function-name) ;; defun: extract the name
+                      (let ((sec (second function-name)))
+                        (or (and (atom sec) sec) ; scoped method: drop scope
+                            (first sec)))))) ; method: keep gf name, drop method specializers
+        (list name)))
+    (defun unreify-function-name (function-name)
+      function-name)
+    (defun nullify-non-literals (sexp)
+      (typecase sexp
+        ((or number character simple-string symbol pathname) sexp)
+        (cons (cons (nullify-non-literals (car sexp))
+                    (nullify-non-literals (cdr sexp))))
+        (t nil)))
+    (defun reify-deferred-warning (deferred-warning)
+      (with-accessors ((warning-type ccl::compiler-warning-warning-type)
+                       (args ccl::compiler-warning-args)
+                       (source-note ccl:compiler-warning-source-note)
+                       (function-name ccl:compiler-warning-function-name)) deferred-warning
+        (list :warning-type warning-type :function-name (reify-function-name function-name)
+              :source-note (reify-source-note source-note)
+              :args (destructuring-bind (fun &rest more)
+                        args
+                      (cons (unsymbolify-function-name fun)
+                            (nullify-non-literals more))))))
+    (defun unreify-deferred-warning (reified-deferred-warning)
+      (destructuring-bind (&key warning-type function-name source-note args)
+          reified-deferred-warning
+        (make-condition (or (cdr (ccl::assq warning-type ccl::*compiler-whining-conditions*))
+                            'ccl::compiler-warning)
+                        :function-name (unreify-function-name function-name)
+                        :source-note (unreify-source-note source-note)
+                        :warning-type warning-type
+                        :args (destructuring-bind (fun . more) args
+                                (cons (symbolify-function-name fun) more))))))
+  #+(or cmucl scl)
+  (defun reify-undefined-warning (warning)
+    ;; Extracting undefined-warnings from the compilation-unit
+    ;; To be passed through the above reify/unreify link, it must be a "simple-sexp"
+    (list*
+     (c::undefined-warning-kind warning)
+     (c::undefined-warning-name warning)
+     (c::undefined-warning-count warning)
+     (mapcar
+      #'(lambda (frob)
+          ;; the lexenv slot can be ignored for reporting purposes
+          `(:enclosing-source ,(c::compiler-error-context-enclosing-source frob)
+            :source ,(c::compiler-error-context-source frob)
+            :original-source ,(c::compiler-error-context-original-source frob)
+            :context ,(c::compiler-error-context-context frob)
+            :file-name ,(c::compiler-error-context-file-name frob) ; a pathname
+            :file-position ,(c::compiler-error-context-file-position frob) ; an integer
+            :original-source-path ,(c::compiler-error-context-original-source-path frob)))
+      (c::undefined-warning-warnings warning))))
 
-  (defmethod slurp-input-stream ((x (eql :line)) stream &key (at 0))
-    (slurp-stream-line stream :at at))
+  #+sbcl
+  (defun reify-undefined-warning (warning)
+    ;; Extracting undefined-warnings from the compilation-unit
+    ;; To be passed through the above reify/unreify link, it must be a "simple-sexp"
+    (list*
+     (sb-c::undefined-warning-kind warning)
+     (sb-c::undefined-warning-name warning)
+     (sb-c::undefined-warning-count warning)
+     (mapcar
+      #'(lambda (frob)
+          ;; the lexenv slot can be ignored for reporting purposes
+          `(:enclosing-source ,(sb-c::compiler-error-context-enclosing-source frob)
+            :source ,(sb-c::compiler-error-context-source frob)
+            :original-source ,(sb-c::compiler-error-context-original-source frob)
+            :context ,(sb-c::compiler-error-context-context frob)
+            :file-name ,(sb-c::compiler-error-context-file-name frob) ; a pathname
+            :file-position ,(sb-c::compiler-error-context-file-position frob) ; an integer
+            :original-source-path ,(sb-c::compiler-error-context-original-source-path frob)))
+      (sb-c::undefined-warning-warnings warning))))
 
-  (defmethod slurp-input-stream ((x (eql :forms)) stream &key count)
-    (slurp-stream-forms stream :count count))
+  (defun reify-deferred-warnings ()
+    "return a portable S-expression, portably readable and writeable in any Common Lisp implementation
+using READ within a WITH-SAFE-IO-SYNTAX, that represents the warnings currently deferred by
+WITH-COMPILATION-UNIT. One of three functions required for deferred-warnings support in ASDF."
+    #+allegro
+    (list :functions-defined excl::.functions-defined.
+          :functions-called excl::.functions-called.)
+    #+clozure
+    (mapcar 'reify-deferred-warning
+            (if-let (dw ccl::*outstanding-deferred-warnings*)
+              (let ((mdw (ccl::ensure-merged-deferred-warnings dw)))
+                (ccl::deferred-warnings.warnings mdw))))
+    #+(or cmucl scl)
+    (when lisp::*in-compilation-unit*
+      ;; Try to send nothing through the pipe if nothing needs to be accumulated
+      `(,@(when c::*undefined-warnings*
+            `((c::*undefined-warnings*
+               ,@(mapcar #'reify-undefined-warning c::*undefined-warnings*))))
+        ,@(loop :for what :in '(c::*compiler-error-count*
+                                c::*compiler-warning-count*
+                                c::*compiler-note-count*)
+                :for value = (symbol-value what)
+                :when (plusp value)
+                  :collect `(,what . ,value))))
+    #+sbcl
+    (when sb-c::*in-compilation-unit*
+      ;; Try to send nothing through the pipe if nothing needs to be accumulated
+      `(,@(when sb-c::*undefined-warnings*
+            `((sb-c::*undefined-warnings*
+               ,@(mapcar #'reify-undefined-warning sb-c::*undefined-warnings*))))
+        ,@(loop :for what :in '(sb-c::*aborted-compilation-unit-count*
+                                sb-c::*compiler-error-count*
+                                sb-c::*compiler-warning-count*
+                                sb-c::*compiler-style-warning-count*
+                                sb-c::*compiler-note-count*)
+                :for value = (symbol-value what)
+                :when (plusp value)
+                  :collect `(,what . ,value)))))
 
-  (defmethod slurp-input-stream ((x (eql :form)) stream &key (at 0))
-    (slurp-stream-form stream :at at))
+  (defun unreify-deferred-warnings (reified-deferred-warnings)
+    "given a S-expression created by REIFY-DEFERRED-WARNINGS, reinstantiate the corresponding
+deferred warnings as to be handled at the end of the current WITH-COMPILATION-UNIT.
+Handle any warning that has been resolved already,
+such as an undefined function that has been defined since.
+One of three functions required for deferred-warnings support in ASDF."
+    (declare (ignorable reified-deferred-warnings))
+    #+allegro
+    (destructuring-bind (&key functions-defined functions-called)
+        reified-deferred-warnings
+      (setf excl::.functions-defined.
+            (append functions-defined excl::.functions-defined.)
+            excl::.functions-called.
+            (append functions-called excl::.functions-called.)))
+    #+clozure
+    (let ((dw (or ccl::*outstanding-deferred-warnings*
+                  (setf ccl::*outstanding-deferred-warnings* (ccl::%defer-warnings t)))))
+      (appendf (ccl::deferred-warnings.warnings dw)
+               (mapcar 'unreify-deferred-warning reified-deferred-warnings)))
+    #+(or cmucl scl)
+    (dolist (item reified-deferred-warnings)
+      ;; Each item is (symbol . adjustment) where the adjustment depends on the symbol.
+      ;; For *undefined-warnings*, the adjustment is a list of initargs.
+      ;; For everything else, it's an integer.
+      (destructuring-bind (symbol . adjustment) item
+        (case symbol
+          ((c::*undefined-warnings*)
+           (setf c::*undefined-warnings*
+                 (nconc (mapcan
+                         #'(lambda (stuff)
+                             (destructuring-bind (kind name count . rest) stuff
+                               (unless (case kind (:function (fboundp name)))
+                                 (list
+                                  (c::make-undefined-warning
+                                   :name name
+                                   :kind kind
+                                   :count count
+                                   :warnings
+                                   (mapcar #'(lambda (x)
+                                               (apply #'c::make-compiler-error-context x))
+                                           rest))))))
+                         adjustment)
+                        c::*undefined-warnings*)))
+          (otherwise
+           (set symbol (+ (symbol-value symbol) adjustment))))))
+    #+sbcl
+    (dolist (item reified-deferred-warnings)
+      ;; Each item is (symbol . adjustment) where the adjustment depends on the symbol.
+      ;; For *undefined-warnings*, the adjustment is a list of initargs.
+      ;; For everything else, it's an integer.
+      (destructuring-bind (symbol . adjustment) item
+        (case symbol
+          ((sb-c::*undefined-warnings*)
+           (setf sb-c::*undefined-warnings*
+                 (nconc (mapcan
+                         #'(lambda (stuff)
+                             (destructuring-bind (kind name count . rest) stuff
+                               (unless (case kind (:function (fboundp name)))
+                                 (list
+                                  (sb-c::make-undefined-warning
+                                   :name name
+                                   :kind kind
+                                   :count count
+                                   :warnings
+                                   (mapcar #'(lambda (x)
+                                               (apply #'sb-c::make-compiler-error-context x))
+                                           rest))))))
+                         adjustment)
+                        sb-c::*undefined-warnings*)))
+          (otherwise
+           (set symbol (+ (symbol-value symbol) adjustment)))))))
 
-  (defmethod slurp-input-stream ((x (eql t)) stream &rest keys &key &allow-other-keys)
-    (apply 'slurp-input-stream *standard-output* stream keys))
+  (defun reset-deferred-warnings ()
+    "Reset the set of deferred warnings to be handled at the end of the current WITH-COMPILATION-UNIT.
+One of three functions required for deferred-warnings support in ASDF."
+    #+allegro
+    (setf excl::.functions-defined. nil
+          excl::.functions-called. nil)
+    #+clozure
+    (if-let (dw ccl::*outstanding-deferred-warnings*)
+      (let ((mdw (ccl::ensure-merged-deferred-warnings dw)))
+        (setf (ccl::deferred-warnings.warnings mdw) nil)))
+    #+(or cmucl scl)
+    (when lisp::*in-compilation-unit*
+      (setf c::*undefined-warnings* nil
+            c::*compiler-error-count* 0
+            c::*compiler-warning-count* 0
+            c::*compiler-note-count* 0))
+    #+sbcl
+    (when sb-c::*in-compilation-unit*
+      (setf sb-c::*undefined-warnings* nil
+            sb-c::*aborted-compilation-unit-count* 0
+            sb-c::*compiler-error-count* 0
+            sb-c::*compiler-warning-count* 0
+            sb-c::*compiler-style-warning-count* 0
+            sb-c::*compiler-note-count* 0)))
 
-  (defmethod slurp-input-stream ((x null) (stream t) &key)
-    nil)
+  (defun save-deferred-warnings (warnings-file)
+    "Save forward reference conditions so they may be issued at a latter time,
+possibly in a different process."
+    (with-open-file (s warnings-file :direction :output :if-exists :supersede
+                       :element-type *default-stream-element-type*
+                       :external-format *utf-8-external-format*)
+      (with-safe-io-syntax ()
+        (write (reify-deferred-warnings) :stream s :pretty t :readably t)
+        (terpri s))))
 
-  (defmethod slurp-input-stream ((pathname pathname) input
-                                 &key
-                                   (element-type *default-stream-element-type*)
-                                   (external-format *utf-8-external-format*)
-                                   (if-exists :rename-and-delete)
-                                   (if-does-not-exist :create)
-                                   buffer-size
-                                   linewise)
-    (with-output-file (output pathname
-                              :element-type element-type
-                              :external-format external-format
-                              :if-exists if-exists
-                              :if-does-not-exist if-does-not-exist)
-      (copy-stream-to-stream
-       input output
-       :element-type element-type :buffer-size buffer-size :linewise linewise)))
+  (defun warnings-file-type (&optional implementation-type)
+    "The pathname type for warnings files on given IMPLEMENTATION-TYPE,
+where NIL designates the current one"
+    (case (or implementation-type *implementation-type*)
+      ((:acl :allegro) "allegro-warnings")
+      ;;((:clisp) "clisp-warnings")
+      ((:cmu :cmucl) "cmucl-warnings")
+      ((:sbcl) "sbcl-warnings")
+      ((:clozure :ccl) "ccl-warnings")
+      ((:scl) "scl-warnings")))
 
-  (defmethod slurp-input-stream (x stream
-                                 &key linewise prefix (element-type 'character) buffer-size)
-    (declare (ignorable stream linewise prefix element-type buffer-size))
-    (cond
-      #+genera
-      ((functionp x) (funcall x stream))
-      #+genera
-      ((output-stream-p x)
-       (copy-stream-to-stream
-        stream x
-        :linewise linewise :prefix prefix :element-type element-type :buffer-size buffer-size))
-      (t
-       (error "Invalid ~S destination ~S" 'slurp-input-stream x)))))
+  (defvar *warnings-file-type* nil
+    "Pathname type for warnings files, or NIL if disabled")
+
+  (defun enable-deferred-warnings-check ()
+    "Enable the saving of deferred warnings"
+    (setf *warnings-file-type* (warnings-file-type)))
+
+  (defun disable-deferred-warnings-check ()
+    "Disable the saving of deferred warnings"
+    (setf *warnings-file-type* nil))
+
+  (defun warnings-file-p (file &optional implementation-type)
+    "Is FILE a saved warnings file for the given IMPLEMENTATION-TYPE?
+If that given type is NIL, use the currently configured *WARNINGS-FILE-TYPE* instead."
+    (if-let (type (if implementation-type
+                      (warnings-file-type implementation-type)
+                      *warnings-file-type*))
+      (equal (pathname-type file) type)))
+
+  (defun check-deferred-warnings (files &optional context-format context-arguments)
+    "Given a list of FILES containing deferred warnings saved by CALL-WITH-SAVED-DEFERRED-WARNINGS,
+re-intern and raise any warnings that are still meaningful."
+    (let ((file-errors nil)
+          (failure-p nil)
+          (warnings-p nil))
+      (handler-bind
+          ((warning #'(lambda (c)
+                        (setf warnings-p t)
+                        (unless (typep c 'style-warning)
+                          (setf failure-p t)))))
+        (with-compilation-unit (:override t)
+          (reset-deferred-warnings)
+          (dolist (file files)
+            (unreify-deferred-warnings
+             (handler-case (safe-read-file-form file)
+               (error (c)
+                 ;;(delete-file-if-exists file) ;; deleting forces rebuild but prevents debugging
+                 (push c file-errors)
+                 nil))))))
+      (dolist (error file-errors) (error error))
+      (check-lisp-compile-warnings
+       (or failure-p warnings-p) failure-p context-format context-arguments)))
 
+  #|
+  Mini-guide to adding support for deferred warnings on an implementation.
 
-(with-upgradability ()
-  (defgeneric vomit-output-stream (processor output-stream &key)
-    (:documentation
-     "VOMIT-OUTPUT-STREAM is a generic function with two positional arguments
-PROCESSOR and OUTPUT-STREAM and additional keyword arguments, that produces (vomits)
-some content onto the OUTPUT-STREAM, according to a method specified by PROCESSOR.
+  First, look at what such a warning looks like:
 
-Built-in methods include the following:
-* if PROCESSOR is a function, it is called with the OUTPUT-STREAM as its argument
-* if PROCESSOR is a list, its first element should be a function.
-  It will be applied to a cons of the OUTPUT-STREAM and the rest of the list.
-  That is (x . y) will be treated as \(APPLY x <stream> y\)
-* if PROCESSOR is an input-stream, its contents will be copied the OUTPUT-STREAM,
-  per copy-stream-to-stream, with appropriate keyword arguments.
-* if PROCESSOR is a string, its contents will be printed to the OUTPUT-STREAM.
-* if PROCESSOR is T, it is treated the same as *standard-input*. If it is NIL, nothing is done.
+  (describe
+  (handler-case
+  (and (eval '(lambda () (some-undefined-function))) nil)
+  (t (c) c)))
 
-Programmers are encouraged to define their own methods for this generic function."))
+  Then you can grep for the condition type in your compiler sources
+  and see how to catch those that have been deferred,
+  and/or read, clear and restore the deferred list.
 
-  #-genera
-  (defmethod vomit-output-stream ((function function) output-stream &key)
-    (funcall function output-stream))
+  Also look at
+  (macroexpand-1 '(with-compilation-unit () foo))
+  |#
 
-  (defmethod vomit-output-stream ((list cons) output-stream &key)
-    (apply (first list) output-stream (rest list)))
+  (defun call-with-saved-deferred-warnings (thunk warnings-file &key source-namestring)
+    "If WARNINGS-FILE is not nil, record the deferred-warnings around a call to THUNK
+and save those warnings to the given file for latter use,
+possibly in a different process. Otherwise just call THUNK."
+    (declare (ignorable source-namestring))
+    (if warnings-file
+        (with-compilation-unit (:override t #+sbcl :source-namestring #+sbcl source-namestring)
+          (unwind-protect
+               (let (#+sbcl (sb-c::*undefined-warnings* nil))
+                 (multiple-value-prog1
+                     (funcall thunk)
+                   (save-deferred-warnings warnings-file)))
+            (reset-deferred-warnings)))
+        (funcall thunk)))
 
-  #-genera
-  (defmethod vomit-output-stream ((input-stream stream) output-stream
-                                 &key linewise prefix (element-type 'character) buffer-size)
-    (copy-stream-to-stream
-     input-stream output-stream
-     :linewise linewise :prefix prefix :element-type element-type :buffer-size buffer-size))
+  (defmacro with-saved-deferred-warnings ((warnings-file &key source-namestring) &body body)
+    "Trivial syntax for CALL-WITH-SAVED-DEFERRED-WARNINGS"
+    `(call-with-saved-deferred-warnings
+      #'(lambda () ,@body) ,warnings-file :source-namestring ,source-namestring)))
 
-  (defmethod vomit-output-stream ((x string) stream &key fresh-line terpri)
-    (princ x stream)
-    (when fresh-line (fresh-line stream))
-    (when terpri (terpri stream))
-    (values))
 
-  (defmethod vomit-output-stream ((x (eql t)) stream &rest keys &key &allow-other-keys)
-    (apply 'vomit-output-stream *standard-input* stream keys))
+;;; from ASDF
+(with-upgradability ()
+  (defun current-lisp-file-pathname ()
+    "Portably return the PATHNAME of the current Lisp source file being compiled or loaded"
+    (or *compile-file-pathname* *load-pathname*))
 
-  (defmethod vomit-output-stream ((x null) (stream t) &key)
-    (values))
+  (defun load-pathname ()
+    "Portably return the LOAD-PATHNAME of the current source file or fasl"
+    *load-pathname*) ;; magic no longer needed for GCL.
 
-  (defmethod vomit-output-stream ((pathname pathname) input
-                                 &key
-                                   (element-type *default-stream-element-type*)
-                                   (external-format *utf-8-external-format*)
-                                   (if-exists :rename-and-delete)
-                                   (if-does-not-exist :create)
-                                   buffer-size
-                                   linewise)
-    (with-output-file (output pathname
-                              :element-type element-type
-                              :external-format external-format
-                              :if-exists if-exists
-                              :if-does-not-exist if-does-not-exist)
-      (copy-stream-to-stream
-       input output
-       :element-type element-type :buffer-size buffer-size :linewise linewise)))
+  (defun lispize-pathname (input-file)
+    "From a INPUT-FILE pathname, return a corresponding .lisp source pathname"
+    (make-pathname :type "lisp" :defaults input-file))
 
-  (defmethod vomit-output-stream (x stream
-                                 &key linewise prefix (element-type 'character) buffer-size)
-    (declare (ignorable stream linewise prefix element-type buffer-size))
-    (cond
-      #+genera
-      ((functionp x) (funcall x stream))
-      #+genera
-      ((input-stream-p x)
-       (copy-stream-to-stream
-        x stream
-        :linewise linewise :prefix prefix :element-type element-type :buffer-size buffer-size))
-      (t
-       (error "Invalid ~S source ~S" 'vomit-output-stream x)))))
+  (defun compile-file-type (&rest keys)
+    "pathname TYPE for lisp FASt Loading files"
+    (declare (ignorable keys))
+    #-(or clasp ecl mkcl) (load-time-value (pathname-type (compile-file-pathname "foo.lisp")))
+    #+(or clasp ecl mkcl) (pathname-type (apply 'compile-file-pathname "foo" keys)))
 
+  (defun call-around-hook (hook function)
+    "Call a HOOK around the execution of FUNCTION"
+    (call-function (or hook 'funcall) function))
 
-;;;; ----- Running an external program -----
-;;; Simple variant of run-program with no input, and capturing output
-;;; On some implementations, may output to a temporary file...
-(with-upgradability ()
-  (define-condition subprocess-error (error)
-    ((code :initform nil :initarg :code :reader subprocess-error-code)
-     (command :initform nil :initarg :command :reader subprocess-error-command)
-     (process :initform nil :initarg :process :reader subprocess-error-process))
-    (:report (lambda (condition stream)
-               (format stream "Subprocess ~@[~S~% ~]~@[with command ~S~% ~]exited with error~@[ code ~D~]"
-                       (subprocess-error-process condition)
-                       (subprocess-error-command condition)
-                       (subprocess-error-code condition)))))
+  (defun compile-file-pathname* (input-file &rest keys &key output-file &allow-other-keys)
+    "Variant of COMPILE-FILE-PATHNAME that works well with COMPILE-FILE*"
+    (let* ((keys
+             (remove-plist-keys `(#+(or (and allegro (not (version>= 8 2)))) :external-format
+                                    ,@(unless output-file '(:output-file))) keys)))
+      (if (absolute-pathname-p output-file)
+          ;; what cfp should be doing, w/ mp* instead of mp
+          (let* ((type (pathname-type (apply 'compile-file-type keys)))
+                 (defaults (make-pathname
+                            :type type :defaults (merge-pathnames* input-file))))
+            (merge-pathnames* output-file defaults))
+          (funcall *output-translation-function*
+                   (apply 'compile-file-pathname input-file keys)))))
 
-  ;;; find CMD.exe on windows
-  (defun %cmd-shell-pathname ()
-    (os-cond
-     ((os-windows-p)
-      (strcat (native-namestring (getenv-absolute-directory "WINDIR"))
-              "System32\\cmd.exe"))
-     (t
-      (error "CMD.EXE is not the command shell for this OS."))))
+  (defvar *compile-check* nil
+    "A hook for user-defined compile-time invariants")
 
-  ;;; Internal helpers for run-program
-  (defun %normalize-command (command)
-    "Given a COMMAND as a list or string, transform it in a format suitable
-for the implementation's underlying run-program function"
-    (etypecase command
-      #+os-unix (string `("/bin/sh" "-c" ,command))
-      #+os-unix (list command)
-      #+os-windows
-      (string
-       #+mkcl (list "cmd" "/c" command)
-       ;; NB: We do NOT add cmd /c here. You might want to.
-       #+(or allegro clisp) command
-       ;; On ClozureCL for Windows, we assume you are using
-       ;; r15398 or later in 1.9 or later,
-       ;; so that bug 858 is fixed http://trac.clozure.com/ccl/ticket/858
-       #+clozure (cons "cmd" (strcat "/c " command))
-       #+sbcl (list (%cmd-shell-pathname) "/c" command)
-       ;; NB: On other Windows implementations, this is utterly bogus
-       ;; except in the most trivial cases where no quoting is needed.
-       ;; Use at your own risk.
-       #-(or allegro clisp clozure mkcl sbcl) (list "cmd" "/c" command))
-      #+os-windows
-      (list
-       #+allegro (escape-windows-command command)
-       #-allegro command)))
+  (defun* (compile-file*) (input-file &rest keys
+                                      &key (compile-check *compile-check*) output-file warnings-file
+                                      #+clisp lib-file #+(or clasp ecl mkcl) object-file #+sbcl emit-cfasl
+                                      &allow-other-keys)
+    "This function provides a portable wrapper around COMPILE-FILE.
+It ensures that the OUTPUT-FILE value is only returned and
+the file only actually created if the compilation was successful,
+even though your implementation may not do that. It also checks an optional
+user-provided consistency function COMPILE-CHECK to determine success;
+it will call this function if not NIL at the end of the compilation
+with the arguments sent to COMPILE-FILE*, except with :OUTPUT-FILE TMP-FILE
+where TMP-FILE is the name of a temporary output-file.
+It also checks two flags (with legacy british spelling from ASDF1),
+*COMPILE-FILE-FAILURE-BEHAVIOUR* and *COMPILE-FILE-WARNINGS-BEHAVIOUR*
+with appropriate implementation-dependent defaults,
+and if a failure (respectively warnings) are reported by COMPILE-FILE,
+it will consider that an error unless the respective behaviour flag
+is one of :SUCCESS :WARN :IGNORE.
+If WARNINGS-FILE is defined, deferred warnings are saved to that file.
+On ECL or MKCL, it creates both the linkable object and loadable fasl files.
+On implementations that erroneously do not recognize standard keyword arguments,
+it will filter them appropriately."
+    #+(or clasp ecl)
+    (when (and object-file (equal (compile-file-type) (pathname object-file)))
+      (format t "Whoa, some funky ASDF upgrade switched ~S calling convention for ~S and ~S~%"
+              'compile-file* output-file object-file)
+      (rotatef output-file object-file))
+    (let* ((keywords (remove-plist-keys
+                      `(:output-file :compile-check :warnings-file
+                                     #+clisp :lib-file #+(or clasp ecl mkcl) :object-file) keys))
+           (output-file
+             (or output-file
+                 (apply 'compile-file-pathname* input-file :output-file output-file keywords)))
+           (physical-output-file (physicalize-pathname output-file))
+           #+(or clasp ecl)
+           (object-file
+             (unless (use-ecl-byte-compiler-p)
+               (or object-file
+                   #+ecl (compile-file-pathname output-file :type :object)
+                   #+clasp (compile-file-pathname output-file :output-type :object))))
+           #+mkcl
+           (object-file
+             (or object-file
+                 (compile-file-pathname output-file :fasl-p nil)))
+           (tmp-file (tmpize-pathname physical-output-file))
+           #+sbcl
+           (cfasl-file (etypecase emit-cfasl
+                         (null nil)
+                         ((eql t) (make-pathname :type "cfasl" :defaults physical-output-file))
+                         (string (parse-namestring emit-cfasl))
+                         (pathname emit-cfasl)))
+           #+sbcl
+           (tmp-cfasl (when cfasl-file (make-pathname :type "cfasl" :defaults tmp-file)))
+           #+clisp
+           (tmp-lib (make-pathname :type "lib" :defaults tmp-file)))
+      (multiple-value-bind (output-truename warnings-p failure-p)
+          (with-enough-pathname (input-file :defaults *base-build-directory*)
+            (with-saved-deferred-warnings (warnings-file :source-namestring (namestring input-file))
+              (with-muffled-compiler-conditions ()
+                (or #-(or clasp ecl mkcl)
+                    (apply 'compile-file input-file :output-file tmp-file
+                           #+sbcl (if emit-cfasl (list* :emit-cfasl tmp-cfasl keywords) keywords)
+                           #-sbcl keywords)
+                    #+ecl (apply 'compile-file input-file :output-file
+                                (if object-file
+                                    (list* object-file :system-p t keywords)
+                                    (list* tmp-file keywords)))
+                    #+clasp (apply 'compile-file input-file :output-file
+                                  (if object-file
+                                      (list* object-file :output-type :object #|:system-p t|# keywords)
+                                      (list* tmp-file keywords)))
+                    #+mkcl (apply 'compile-file input-file
+                                  :output-file object-file :fasl-p nil keywords)))))
+        (cond
+          ((and output-truename
+                (flet ((check-flag (flag behaviour)
+                         (or (not flag) (member behaviour '(:success :warn :ignore)))))
+                  (and (check-flag failure-p *compile-file-failure-behaviour*)
+                       (check-flag warnings-p *compile-file-warnings-behaviour*)))
+                (progn
+                  #+(or clasp ecl mkcl)
+                  (when (and #+(or clasp ecl) object-file)
+                    (setf output-truename
+                          (compiler::build-fasl tmp-file
+                           #+(or clasp ecl) :lisp-files #+mkcl :lisp-object-files (list object-file))))
+                  (or (not compile-check)
+                      (apply compile-check input-file
+                             :output-file output-truename
+                             keywords))))
+           (delete-file-if-exists physical-output-file)
+           (when output-truename
+             #+clasp (when output-truename (rename-file-overwriting-target tmp-file output-truename))
+             ;; see CLISP bug 677
+             #+clisp
+             (progn
+               (setf tmp-lib (make-pathname :type "lib" :defaults output-truename))
+               (unless lib-file (setf lib-file (make-pathname :type "lib" :defaults physical-output-file)))
+               (rename-file-overwriting-target tmp-lib lib-file))
+             #+sbcl (when cfasl-file (rename-file-overwriting-target tmp-cfasl cfasl-file))
+             (rename-file-overwriting-target output-truename physical-output-file)
+             (setf output-truename (truename physical-output-file)))
+           #+clasp (delete-file-if-exists tmp-file)
+           #+clisp (progn (delete-file-if-exists tmp-file) ;; this one works around clisp BUG 677
+                          (delete-file-if-exists tmp-lib))) ;; this one is "normal" defensive cleanup
+          (t ;; error or failed check
+           (delete-file-if-exists output-truename)
+           #+clisp (delete-file-if-exists tmp-lib)
+           #+sbcl (delete-file-if-exists tmp-cfasl)
+           (setf output-truename nil)))
+        (values output-truename warnings-p failure-p))))
 
-  (defun %active-io-specifier-p (specifier)
-    "Determines whether a run-program I/O specifier requires Lisp-side processing
-via SLURP-INPUT-STREAM or VOMIT-OUTPUT-STREAM (return T),
-or whether it's already taken care of by the implementation's underlying run-program."
-    (not (typep specifier '(or null string pathname (member :interactive :output)
-                            #+(or cmu (and sbcl os-unix) scl) (or stream (eql t))
-                            #+lispworks file-stream)))) ;; not a type!? comm:socket-stream
+  (defun load* (x &rest keys &key &allow-other-keys)
+    "Portable wrapper around LOAD that properly handles loading from a stream."
+    (with-muffled-loader-conditions ()
+      (etypecase x
+        ((or pathname string #-(or allegro clozure genera) stream #+clozure file-stream)
+         (apply 'load x keys))
+        ;; Genera can't load from a string-input-stream
+        ;; ClozureCL 1.6 can only load from file input stream
+        ;; Allegro 5, I don't remember but it must have been broken when I tested.
+        #+(or allegro clozure genera)
+        (stream ;; make do this way
+         (let ((*package* *package*)
+               (*readtable* *readtable*)
+               (*load-pathname* nil)
+               (*load-truename* nil))
+           (eval-input x))))))
 
-  (defun %normalize-io-specifier (specifier &optional role)
-    "Normalizes a portable I/O specifier for %RUN-PROGRAM into an implementation-dependent
-argument to pass to the internal RUN-PROGRAM"
-    (declare (ignorable role))
-    (etypecase specifier
-      (null (or #+(or allegro lispworks) (null-device-pathname)))
-      (string (parse-native-namestring specifier))
-      (pathname specifier)
-      (stream specifier)
-      ((eql :stream) :stream)
-      ((eql :interactive)
-       #+allegro nil
-       #+clisp :terminal
-       #+(or clasp clozure cmu ecl mkcl sbcl scl) t)
-      #+(or allegro clasp clozure cmu ecl lispworks mkcl sbcl scl)
-      ((eql :output)
-       (if (eq role :error-output)
-           :output
-           (error "Wrong specifier ~S for role ~S" specifier role)))))
+  (defun load-from-string (string)
+    "Portably read and evaluate forms from a STRING."
+    (with-input-from-string (s string) (load* s))))
 
-  (defun %interactivep (input output error-output)
-    (member :interactive (list input output error-output)))
+;;; Links FASLs together
+(with-upgradability ()
+  (defun combine-fasls (inputs output)
+    "Combine a list of FASLs INPUTS into a single FASL OUTPUT"
+    #-(or abcl allegro clisp clozure cmucl lispworks sbcl scl xcl)
+    (error "~A does not support ~S~%inputs ~S~%output  ~S"
+           (implementation-type) 'combine-fasls inputs output)
+    #+abcl (funcall 'sys::concatenate-fasls inputs output) ; requires ABCL 1.2.0
+    #+(or allegro clisp cmucl sbcl scl xcl) (concatenate-files inputs output)
+    #+clozure (ccl:fasl-concatenate output inputs :if-exists :supersede)
+    #+lispworks
+    (let (fasls)
+      (unwind-protect
+           (progn
+             (loop :for i :in inputs
+                   :for n :from 1
+                   :for f = (add-pathname-suffix
+                             output (format nil "-FASL~D" n))
+                   :do (copy-file i f)
+                       (push f fasls))
+             (ignore-errors (lispworks:delete-system :fasls-to-concatenate))
+             (eval `(scm:defsystem :fasls-to-concatenate
+                      (:default-pathname ,(pathname-directory-pathname output))
+                      :members
+                      ,(loop :for f :in (reverse fasls)
+                             :collect `(,(namestring f) :load-only t))))
+             (scm:concatenate-system output :fasls-to-concatenate :force t))
+        (loop :for f :in fasls :do (ignore-errors (delete-file f)))
+        (ignore-errors (lispworks:delete-system :fasls-to-concatenate))))))
+;;;; -------------------------------------------------------------------------
+;;;; launch-program - semi-portably spawn asynchronous subprocesses
 
-  #+clisp
-  (defun clisp-exit-code (raw-exit-code)
-    (typecase raw-exit-code
-      (null 0) ; no error
-      (integer raw-exit-code) ; negative: signal
-      (t -1)))
-
-  (defun %run-program (command
-                       &rest keys
-                       &key input (if-input-does-not-exist :error)
-                         output (if-output-exists :overwrite)
-                         error-output (if-error-output-exists :overwrite)
-                         directory wait
-                         #+allegro separate-streams
-                         &allow-other-keys)
-    "A portable abstraction of a low-level call to the implementation's run-program or equivalent.
-It spawns a subprocess that runs the specified COMMAND (a list of program and arguments).
-INPUT, OUTPUT and ERROR-OUTPUT specify a portable IO specifer,
-to be normalized by %NORMALIZE-IO-SPECIFIER.
-It returns a process-info plist with possible keys:
-     PROCESS, EXIT-CODE, INPUT-STREAM, OUTPUT-STREAM, BIDIR-STREAM, ERROR-STREAM."
-    ;; NB: these implementations have Unix vs Windows set at compile-time.
-    (declare (ignorable directory if-input-does-not-exist if-output-exists if-error-output-exists))
-    (assert (not (and wait (member :stream (list input output error-output)))))
-    #-(or allegro clasp clisp clozure cmu ecl (and lispworks os-unix) mkcl sbcl scl)
-    (progn command keys directory
-           (error "run-program not available"))
-    #+(or allegro clasp clisp clozure cmu ecl (and lispworks os-unix) mkcl sbcl scl)
-    (let* ((%command (%normalize-command command))
-           (%input (%normalize-io-specifier input :input))
-           (%output (%normalize-io-specifier output :output))
-           (%error-output (%normalize-io-specifier error-output :error-output))
-           #+(and allegro os-windows)
-           (interactive (%interactivep input output error-output))
-           (process*
-             (nest
-              #+clisp (progn
-                        ;; clisp cannot redirect stderr, so check we don't.
-                        ;; Also, since we now always return a code, we cannot use this code path
-                        ;; if any of the input, output or error-output is :stream.
-                        (assert (eq %error-output :terminal)))
-              #-(or allegro mkcl sbcl) (with-current-directory (directory))
-              #+(or allegro clasp clisp ecl lispworks mkcl) (multiple-value-list)
-              (apply
-               #+allegro 'excl:run-shell-command
-               #+(and allegro os-unix) (coerce (cons (first %command) %command) 'vector)
-               #+(and allegro os-windows) %command
-               #+clisp
-               (etypecase %command
-                 #+os-windows
-                 (string (lambda (&rest keys) (apply 'ext:run-shell-command %command keys)))
-                 (list (lambda (&rest keys)
-                         (apply 'ext:run-program (car %command) :arguments (cdr %command) keys))))
-               #+clozure 'ccl:run-program
-               #+(or cmu ecl scl) 'ext:run-program
-               #+lispworks 'system:run-shell-command
-               #+lispworks (cons "/usr/bin/env" %command) ; LW wants a full path
-               #+mkcl 'mk-ext:run-program
-               #+sbcl 'sb-ext:run-program
-               (append
-                #+(or clozure cmu ecl mkcl sbcl scl) `(,(car %command) ,(cdr %command))
-                `(:input ,%input :output ,%output :wait ,wait :allow-other-keys t)
-                #-clisp `(#+(or allegro lispworks) :error-output #-(or allegro lispworks) :error
-                            ,%error-output)
-                #+(and allegro os-windows) `(:show-window ,(if interactive nil :hide))
-                #+(or clozure cmu ecl lispworks mkcl sbcl scl)
-                `(:if-input-does-not-exist ,if-input-does-not-exist
-                  :if-output-exists ,if-output-exists
-                  #-lispworks :if-error-exists #+lispworks :if-error-output-exists
-                  ,if-error-output-exists)
-                #+lispworks `(:save-exit-status t)
-                #+sbcl `(:search t
-                         :if-output-does-not-exist :create
-                         :if-error-does-not-exist :create)
-                #+mkcl `(:directory ,(native-namestring directory))
-                #-sbcl keys
-                #+sbcl (if directory keys (remove-plist-key :directory keys))))))
-           (process-info-r ()))
-      (flet ((prop (key value) (push key process-info-r) (push value process-info-r)))
-        #+allegro
-        (cond
-          (wait (prop :exit-code (first process*)))
-          (separate-streams
-           (destructuring-bind (in out err pid) process*
-             (prop :process pid)
-             (when (eq input :stream) (prop :input-stream in))
-             (when (eq output :stream) (prop :output-stream out))
-             (when (eq error-output :stream) (prop :error-stream err))))
-          (t
-           (prop :process (third process*))
-           (let ((x (first process*)))
-             (ecase (+ (if (eq input :stream) 1 0) (if (eq output :stream) 2 0))
-               (0)
-               (1 (prop :input-stream x))
-               (2 (prop :output-stream x))
-               (3 (prop :bidir-stream x))))
-           (when (eq error-output :stream)
-             (prop :error-stream (second process*)))))
-        #+clisp
-        (cond
-          (wait (prop :exit-code (clisp-exit-code (first process*))))
-          (t
-           (ecase (+ (if (eq input :stream) 1 0) (if (eq output :stream) 2 0))
-             (0)
-             (1 (prop :input-stream (first process*)))
-             (2 (prop :output-stream (first process*)))
-             (3 (prop :bidir-stream (pop process*))
-              (prop :input-stream (pop process*))
-              (prop :output-stream (pop process*))))))
-        #+(or clozure cmu sbcl scl)
-        (progn
-          (prop :process process*)
-          (when (eq input :stream)
-            (prop :input-stream
-                  #+clozure (ccl:external-process-input-stream process*)
-                  #+(or cmu scl) (ext:process-input process*)
-                  #+sbcl (sb-ext:process-input process*)))
-          (when (eq output :stream)
-            (prop :output-stream
-                  #+clozure (ccl:external-process-output-stream process*)
-                  #+(or cmu scl) (ext:process-output process*)
-                  #+sbcl (sb-ext:process-output process*)))
-          (when (eq error-output :stream)
-            (prop :error-output-stream
-                  #+clozure (ccl:external-process-error-stream process*)
-                  #+(or cmu scl) (ext:process-error process*)
-                  #+sbcl (sb-ext:process-error process*))))
-        #+(or clasp ecl mkcl)
-        (destructuring-bind #+(or clasp ecl) (stream code process) #+mkcl (stream process code) process*
-          (let ((mode (+ (if (eq input :stream) 1 0) (if (eq output :stream) 2 0))))
-            (cond
-              ((zerop mode))
-              ((null process*) (prop :exit-code -1))
-              (t (prop (case mode (1 :input-stream) (2 :output-stream) (3 :bidir-stream)) stream))))
-          (when code (prop :exit-code code))
-          (when process (prop :process process)))
-        #+lispworks
-        (if wait
-            (prop :exit-code (first process*))
-            (let ((mode (+ (if (eq input :stream) 1 0) (if (eq output :stream) 2 0))))
-              (if (zerop mode)
-                  (prop :process (first process*))
-                  (destructuring-bind (x err pid) process*
-                    (prop :process pid)
-                    (prop (ecase mode (1 :input-stream) (2 :output-stream) (3 :bidir-stream)) x)
-                    (when (eq error-output :stream) (prop :error-stream err))))))
-        (nreverse process-info-r))))
-
-  (defun %process-info-pid (process-info)
-    (let ((process (getf process-info :process)))
-      (declare (ignorable process))
-      #+(or allegro lispworks) process
-      #+clozure (ccl::external-process-pid process)
-      #+(or clasp ecl) (si:external-process-pid process)
-      #+(or cmu scl) (ext:process-pid process)
-      #+mkcl (mkcl:process-id process)
-      #+sbcl (sb-ext:process-pid process)
-      #-(or allegro cmu mkcl sbcl scl) (error "~S not implemented" '%process-info-pid)))
-
-  (defun %wait-process-result (process-info)
-    (or (getf process-info :exit-code)
-        (let ((process (getf process-info :process)))
-          (when process
-            ;; 1- wait
-            #+clozure (ccl::external-process-wait process)
-            #+(or cmu scl) (ext:process-wait process)
-            #+sbcl (sb-ext:process-wait process)
-            ;; 2- extract result
-            #+allegro (sys:reap-os-subprocess :pid process :wait t)
-            #+clozure (nth-value 1 (ccl:external-process-status process))
-            #+(or cmu scl) (ext:process-exit-code process)
-            #+(or clasp ecl) (nth-value 1 (ext:external-process-wait process t))
-            #+lispworks
-            (if-let ((stream (or (getf process-info :input-stream)
-                                 (getf process-info :output-stream)
-                                 (getf process-info :bidir-stream)
-                                 (getf process-info :error-stream))))
-              (system:pipe-exit-status stream :wait t)
-              (if-let ((f (find-symbol* :pid-exit-status :system nil)))
-                (funcall f process :wait t)))
-            #+sbcl (sb-ext:process-exit-code process)
-            #+mkcl (mkcl:join-process process)))))
+(uiop/package:define-package :uiop/launch-program
+  (:use :uiop/common-lisp :uiop/package :uiop/utility
+   :uiop/pathname :uiop/os :uiop/filesystem :uiop/stream)
+  (:export
+   ;;; Escaping the command invocation madness
+   #:easy-sh-character-p #:escape-sh-token #:escape-sh-command
+   #:escape-windows-token #:escape-windows-command
+   #:escape-shell-token #:escape-shell-command
+   #:escape-token #:escape-command
 
-  (defun %check-result (exit-code &key command process ignore-error-status)
-    (unless ignore-error-status
-      (unless (eql exit-code 0)
-        (cerror "IGNORE-ERROR-STATUS"
-                'subprocess-error :command command :code exit-code :process process)))
-    exit-code)
+   ;;; launch-program
+   #:launch-program
+   #:close-streams #:process-alive-p #:terminate-process #:wait-process
+   #:process-info-error-output #:process-info-input #:process-info-output #:process-info-pid))
+(in-package :uiop/launch-program)
 
-  (defun %call-with-program-io (gf tval stream-easy-p fun direction spec activep returner
-                                &key element-type external-format &allow-other-keys)
-    ;; handle redirection for run-program and system
-    ;; SPEC is the specification for the subprocess's input or output or error-output
-    ;; TVAL is the value used if the spec is T
-    ;; GF is the generic function to call to handle arbitrary values of SPEC
-    ;; STREAM-EASY-P is T if we're going to use a RUN-PROGRAM that copies streams in the background
-    ;; (it's only meaningful on CMUCL, SBCL, SCL that actually do it)
-    ;; DIRECTION is :INPUT, :OUTPUT or :ERROR-OUTPUT for the direction of this io argument
-    ;; FUN is a function of the new reduced spec and an activity function to call with a stream
-    ;; when the subprocess is active and communicating through that stream.
-    ;; ACTIVEP is a boolean true if we will get to run code while the process is running
-    ;; ELEMENT-TYPE and EXTERNAL-FORMAT control what kind of temporary file we may open.
-    ;; RETURNER is a function called with the value of the activity.
-    ;; --- TODO (fare@tunes.org): handle if-output-exists and such when doing it the hard way.
-    (declare (ignorable stream-easy-p))
-    (let* ((actual-spec (if (eq spec t) tval spec))
-           (activity-spec (if (eq actual-spec :output)
-                              (ecase direction
-                                ((:input :output)
-                                 (error "~S not allowed as a ~S ~S spec"
-                                        :output 'run-program direction))
-                                ((:error-output)
-                                 nil))
-                              actual-spec)))
-      (labels ((activity (stream)
-                 (call-function returner (call-stream-processor gf activity-spec stream)))
-               (easy-case ()
-                 (funcall fun actual-spec nil))
-               (hard-case ()
-                 (if activep
-                     (funcall fun :stream #'activity)
-                     (with-temporary-file (:pathname tmp)
-                       (ecase direction
-                         (:input
-                          (with-output-file (s tmp :if-exists :overwrite
-                                               :external-format external-format
-                                               :element-type element-type)
-                            (activity s))
-                          (funcall fun tmp nil))
-                         ((:output :error-output)
-                          (multiple-value-prog1 (funcall fun tmp nil)
-                            (with-input-file (s tmp
-                                               :external-format external-format
-                                               :element-type element-type)
-                              (activity s)))))))))
-        (typecase activity-spec
-          ((or null string pathname (eql :interactive))
-           (easy-case))
-          #+(or cmu (and sbcl os-unix) scl) ;; streams are only easy on implementations that try very hard
-          (stream
-           (if stream-easy-p (easy-case) (hard-case)))
-          (t
-           (hard-case))))))
+;;;; ----- Escaping strings for the shell -----
+(with-upgradability ()
+  (defun requires-escaping-p (token &key good-chars bad-chars)
+    "Does this token require escaping, given the specification of
+either good chars that don't need escaping or bad chars that do need escaping,
+as either a recognizing function or a sequence of characters."
+    (some
+     (cond
+       ((and good-chars bad-chars)
+        (error "only one of good-chars and bad-chars can be provided"))
+       ((typep good-chars 'function)
+        (complement good-chars))
+       ((typep bad-chars 'function)
+        bad-chars)
+       ((and good-chars (typep good-chars 'sequence))
+        #'(lambda (c) (not (find c good-chars))))
+       ((and bad-chars (typep bad-chars 'sequence))
+        #'(lambda (c) (find c bad-chars)))
+       (t (error "requires-escaping-p: no good-char criterion")))
+     token))
 
-  (defmacro place-setter (place)
-    (when place
-      (let ((value (gensym)))
-        `#'(lambda (,value) (setf ,place ,value)))))
+  (defun escape-token (token &key stream quote good-chars bad-chars escaper)
+    "Call the ESCAPER function on TOKEN string if it needs escaping as per
+REQUIRES-ESCAPING-P using GOOD-CHARS and BAD-CHARS, otherwise output TOKEN,
+using STREAM as output (or returning result as a string if NIL)"
+    (if (requires-escaping-p token :good-chars good-chars :bad-chars bad-chars)
+        (with-output (stream)
+          (apply escaper token stream (when quote `(:quote ,quote))))
+        (output-string token stream)))
 
-  (defmacro with-program-input (((reduced-input-var
-                                  &optional (input-activity-var (gensym) iavp))
-                                 input-form &key setf stream-easy-p active keys) &body body)
-    `(apply '%call-with-program-io 'vomit-output-stream *standard-input* ,stream-easy-p
-            #'(lambda (,reduced-input-var ,input-activity-var)
-                ,@(unless iavp `((declare (ignore ,input-activity-var))))
-                ,@body)
-            :input ,input-form ,active (place-setter ,setf) ,keys))
+  (defun escape-windows-token-within-double-quotes (x &optional s)
+    "Escape a string token X within double-quotes
+for use within a MS Windows command-line, outputing to S."
+    (labels ((issue (c) (princ c s))
+             (issue-backslash (n) (loop :repeat n :do (issue #\\))))
+      (loop
+        :initially (issue #\") :finally (issue #\")
+        :with l = (length x) :with i = 0
+        :for i+1 = (1+ i) :while (< i l) :do
+          (case (char x i)
+            ((#\") (issue-backslash 1) (issue #\") (setf i i+1))
+            ((#\\)
+             (let* ((j (and (< i+1 l) (position-if-not
+                                       #'(lambda (c) (eql c #\\)) x :start i+1)))
+                    (n (- (or j l) i)))
+               (cond
+                 ((null j)
+                  (issue-backslash (* 2 n)) (setf i l))
+                 ((and (< j l) (eql (char x j) #\"))
+                  (issue-backslash (1+ (* 2 n))) (issue #\") (setf i (1+ j)))
+                 (t
+                  (issue-backslash n) (setf i j)))))
+            (otherwise
+             (issue (char x i)) (setf i i+1))))))
 
-  (defmacro with-program-output (((reduced-output-var
-                                  &optional (output-activity-var (gensym) oavp))
-                                  output-form &key setf stream-easy-p active keys) &body body)
-    `(apply '%call-with-program-io 'slurp-input-stream *standard-output* ,stream-easy-p
-            #'(lambda (,reduced-output-var ,output-activity-var)
-                ,@(unless oavp `((declare (ignore ,output-activity-var))))
-                ,@body)
-            :output ,output-form ,active (place-setter ,setf) ,keys))
+  (defun easy-windows-character-p (x)
+    "Is X an \"easy\" character that does not require quoting by the shell?"
+    (or (alphanumericp x) (find x "+-_.,@:/=")))
 
-  (defmacro with-program-error-output (((reduced-error-output-var
-                                         &optional (error-output-activity-var (gensym) eoavp))
-                                        error-output-form &key setf stream-easy-p active keys)
-                                       &body body)
-    `(apply '%call-with-program-io 'slurp-input-stream *error-output* ,stream-easy-p
-            #'(lambda (,reduced-error-output-var ,error-output-activity-var)
-                ,@(unless eoavp `((declare (ignore ,error-output-activity-var))))
-                ,@body)
-            :error-output ,error-output-form ,active (place-setter ,setf) ,keys))
+  (defun escape-windows-token (token &optional s)
+    "Escape a string TOKEN within double-quotes if needed
+for use within a MS Windows command-line, outputing to S."
+    (escape-token token :stream s :good-chars #'easy-windows-character-p :quote nil
+                        :escaper 'escape-windows-token-within-double-quotes))
 
-  (defun %use-run-program (command &rest keys
-                           &key input output error-output ignore-error-status &allow-other-keys)
-    ;; helper for RUN-PROGRAM when using %run-program
-    #+(or abcl cormanlisp gcl (and lispworks os-windows) mcl xcl)
-    (progn
-      command keys input output error-output ignore-error-status ;; ignore
-      (error "Not implemented on this platform"))
-    (assert (not (member :stream (list input output error-output))))
-    (let* ((active-input-p (%active-io-specifier-p input))
-           (active-output-p (%active-io-specifier-p output))
-           (active-error-output-p (%active-io-specifier-p error-output))
-           (activity
-             (cond
-               (active-output-p :output)
-               (active-input-p :input)
-               (active-error-output-p :error-output)
-               (t nil)))
-           (wait (not activity))
-           output-result error-output-result exit-code)
-      (with-program-output ((reduced-output output-activity)
-                            output :keys keys :setf output-result
-                            :stream-easy-p t :active (eq activity :output))
-        (with-program-error-output ((reduced-error-output error-output-activity)
-                                    error-output :keys keys :setf error-output-result
-                                    :stream-easy-p t :active (eq activity :error-output))
-          (with-program-input ((reduced-input input-activity)
-                               input :keys keys
-                               :stream-easy-p t :active (eq activity :input))
-            (let ((process-info
-                    (apply '%run-program command
-                           :wait wait :input reduced-input :output reduced-output
-                           :error-output (if (eq error-output :output) :output reduced-error-output)
-                           keys)))
-              (labels ((get-stream (stream-name &optional fallbackp)
-                         (or (getf process-info stream-name)
-                             (when fallbackp
-                               (getf process-info :bidir-stream))))
-                       (run-activity (activity stream-name &optional fallbackp)
-                         (if-let (stream (get-stream stream-name fallbackp))
-                           (funcall activity stream)
-                           (error 'subprocess-error
-                                  :code `(:missing ,stream-name)
-                                  :command command :process process-info))))
-                (unwind-protect
-                     (ecase activity
-                       ((nil))
-                       (:input (run-activity input-activity :input-stream t))
-                       (:output (run-activity output-activity :output-stream t))
-                       (:error-output (run-activity error-output-activity :error-output-stream)))
-                  (loop :for (() val) :on process-info :by #'cddr
-                        :when (streamp val) :do (ignore-errors (close val)))
-                  (setf exit-code
-                        (%check-result (%wait-process-result process-info)
-                                       :command command :process process-info
-                                       :ignore-error-status ignore-error-status))))))))
-      (values output-result error-output-result exit-code)))
+  (defun escape-sh-token-within-double-quotes (x s &key (quote t))
+    "Escape a string TOKEN within double-quotes
+for use within a POSIX Bourne shell, outputing to S;
+omit the outer double-quotes if key argument :QUOTE is NIL"
+    (when quote (princ #\" s))
+    (loop :for c :across x :do
+      (when (find c "$`\\\"") (princ #\\ s))
+      (princ c s))
+    (when quote (princ #\" s)))
 
-  (defun %normalize-system-command (command) ;; helper for %USE-SYSTEM
+  (defun easy-sh-character-p (x)
+    "Is X an \"easy\" character that does not require quoting by the shell?"
+    (or (alphanumericp x) (find x "+-_.,%@:/=")))
+
+  (defun escape-sh-token (token &optional s)
+    "Escape a string TOKEN within double-quotes if needed
+for use within a POSIX Bourne shell, outputing to S."
+    (escape-token token :stream s :quote #\" :good-chars #'easy-sh-character-p
+                        :escaper 'escape-sh-token-within-double-quotes))
+
+  (defun escape-shell-token (token &optional s)
+    "Escape a token for the current operating system shell"
+    (os-cond
+      ((os-unix-p) (escape-sh-token token s))
+      ((os-windows-p) (escape-windows-token token s))))
+
+  (defun escape-command (command &optional s
+                                  (escaper 'escape-shell-token))
+    "Given a COMMAND as a list of tokens, return a string of the
+spaced, escaped tokens, using ESCAPER to escape."
     (etypecase command
-      (string
-       (os-cond
-        ((os-windows-p)
-         #+(or allegro clisp)
-         (strcat (%cmd-shell-pathname) " /c " command)
-         #-(or allegro clisp) command)
-        (t command)))
-      (list (escape-shell-command
-             (os-cond
-              ((os-unix-p) (cons "exec" command))
-              ((os-windows-p)
-               #+(or allegro sbcl clisp)
-               (cons (%cmd-shell-pathname) (cons "/c" command))
-               #-(or allegro sbcl clisp) command)
-              (t command))))))
+      (string (output-string command s))
+      (list (with-output (s)
+              (loop :for first = t :then nil :for token :in command :do
+                (unless first (princ #\space s))
+                (funcall escaper token s))))))
 
-  (defun %redirected-system-command (command in out err directory) ;; helper for %USE-SYSTEM
-    (flet ((redirect (spec operator)
-             (let ((pathname
-                     (typecase spec
-                       (null (null-device-pathname))
-                       (string (parse-native-namestring spec))
-                       (pathname spec)
-                       ((eql :output)
-                        (assert (equal operator " 2>"))
-                        (return-from redirect '(" 2>&1"))))))
-               (when pathname
-                 (list operator " "
-                       (escape-shell-token (native-namestring pathname)))))))
-      (let* ((redirections (append (redirect in " <") (redirect out " >") (redirect err " 2>")))
-             (normalized (%normalize-system-command command))
-             (directory (or directory #+(or abcl xcl) (getcwd)))
-             (chdir (when directory
-                      (let ((dir-arg (escape-shell-token (native-namestring directory))))
-                        (os-cond
-                         ((os-unix-p) `("cd " ,dir-arg " ; "))
-                         ((os-windows-p) `("cd /d " ,dir-arg " & ")))))))
-        (reduce/strcat
-         (os-cond
-          ((os-unix-p) `(,@(when redirections `("exec " ,@redirections " ; ")) ,@chdir ,normalized))
-          ((os-windows-p) `(,@chdir ,@redirections " " ,normalized)))))))
+  (defun escape-windows-command (command &optional s)
+    "Escape a list of command-line arguments into a string suitable for parsing
+by CommandLineToArgv in MS Windows"
+    ;; http://msdn.microsoft.com/en-us/library/bb776391(v=vs.85).aspx
+    ;; http://msdn.microsoft.com/en-us/library/17w5ykft(v=vs.85).aspx
+    (escape-command command s 'escape-windows-token))
 
-  (defun %system (command &rest keys
-                  &key input output error-output directory &allow-other-keys)
-    "A portable abstraction of a low-level call to libc's system()."
-    (declare (ignorable input output error-output directory keys))
-    #+(or allegro clozure cmu (and lispworks os-unix) sbcl scl)
-    (%wait-process-result
-     (apply '%run-program (%normalize-system-command command) :wait t keys))
-    #+(or abcl clasp clisp cormanlisp ecl gcl genera (and lispworks os-windows) mkcl xcl)
-    (let ((%command (%redirected-system-command command input output error-output directory)))
-      #+(and lispworks os-windows)
-      (system:call-system %command :current-directory directory :wait t)
-      #+clisp
-      (%wait-process-result
-       (apply '%run-program %command :wait t
-              :input :interactive :output :interactive :error-output :interactive keys))
-      #-(or clisp (and lispworks os-windows))
-      (with-current-directory ((os-cond ((not (os-unix-p)) directory)))
-        #+abcl (ext:run-shell-command %command)
-        #+cormanlisp (win32:system %command)
-        #+(or clasp ecl) (let ((*standard-input* *stdin*)
-                    (*standard-output* *stdout*)
-                    (*error-output* *stderr*))
-                (ext:system %command))
-        #+gcl (system:system %command)
-        #+genera (error "~S not supported on Genera, cannot run ~S"
-                        '%system %command)
-        #+mcl (ccl::with-cstrs ((%%command %command)) (_system %%command))
-        #+mkcl (mkcl:system %command)
-        #+xcl (system:%run-shell-command %command))))
+  (defun escape-sh-command (command &optional s)
+    "Escape a list of command-line arguments into a string suitable for parsing
+by /bin/sh in POSIX"
+    (escape-command command s 'escape-sh-token))
 
-  (defun %use-system (command &rest keys
-                      &key input output error-output ignore-error-status &allow-other-keys)
-    ;; helper for RUN-PROGRAM when using %system
-    (let (output-result error-output-result exit-code)
-      (with-program-output ((reduced-output)
-                            output :keys keys :setf output-result)
-        (with-program-error-output ((reduced-error-output)
-                                    error-output :keys keys :setf error-output-result)
-          (with-program-input ((reduced-input) input :keys keys)
-            (setf exit-code
-                  (%check-result (apply '%system command
-                                        :input reduced-input :output reduced-output
-                                        :error-output reduced-error-output keys)
-                                 :command command
-                                 :ignore-error-status ignore-error-status)))))
-      (values output-result error-output-result exit-code)))
+  (defun escape-shell-command (command &optional stream)
+    "Escape a command for the current operating system's shell"
+    (escape-command command stream 'escape-shell-token)))
 
-  (defun run-program (command &rest keys
-                       &key ignore-error-status (force-shell nil force-shell-suppliedp)
-                         (input nil inputp) (if-input-does-not-exist :error)
-                         output (if-output-exists :overwrite)
-                         (error-output nil error-output-p) (if-error-output-exists :overwrite)
-                         (element-type #-clozure *default-stream-element-type* #+clozure 'character)
-                         (external-format *utf-8-external-format*)
-                      &allow-other-keys)
-    "Run program specified by COMMAND,
-either a list of strings specifying a program and list of arguments,
-or a string specifying a shell command (/bin/sh on Unix, CMD.EXE on Windows);
-_synchronously_ process its output as specified and return the processing results
-when the program and its output processing are complete.
 
-Always call a shell (rather than directly execute the command when possible)
-if FORCE-SHELL is specified.  Similarly, never call a shell if FORCE-SHELL is
-specified to be NIL.
+(with-upgradability ()
+  ;;; Internal helpers for run-program
+  (defun %normalize-io-specifier (specifier &optional role)
+    "Normalizes a portable I/O specifier for LAUNCH-PROGRAM into an implementation-dependent
+argument to pass to the internal RUN-PROGRAM"
+    (declare (ignorable role))
+    (typecase specifier
+      (null (or #+(or allegro lispworks) (null-device-pathname)))
+      (string (parse-native-namestring specifier))
+      (pathname specifier)
+      (stream specifier)
+      ((eql :stream) :stream)
+      ((eql :interactive)
+       #+(or allegro lispworks) nil
+       #+clisp :terminal
+       #+(or abcl clozure cmucl ecl mkcl sbcl scl) t
+       #-(or abcl clozure cmucl ecl mkcl sbcl scl allegro lispworks clisp)
+       (not-implemented-error :interactive-output
+                              "On this lisp implementation, cannot interpret ~a value of ~a"
+                              specifier role))
+      ((eql :output)
+       (cond ((eq role :error-output)
+              #+(or abcl allegro clozure cmucl ecl lispworks mkcl sbcl scl)
+              :output
+              #-(or abcl allegro clozure cmucl ecl lispworks mkcl sbcl scl)
+              (not-implemented-error :error-output-redirect
+                                     "Can't send ~a to ~a on this lisp implementation."
+                                     role specifier))
+             (t (parameter-error "~S IO specifier invalid for ~S" specifier role))))
+      (otherwise
+       (parameter-error "Incorrect I/O specifier ~S for ~S"
+                        specifier role))))
 
-Signal a continuable SUBPROCESS-ERROR if the process wasn't successful (exit-code 0),
-unless IGNORE-ERROR-STATUS is specified.
+  (defun %interactivep (input output error-output)
+    (member :interactive (list input output error-output)))
 
-If OUTPUT is a pathname, a string designating a pathname, or NIL designating the null device,
-the file at that path is used as output.
-If it's :INTERACTIVE, output is inherited from the current process;
-beware that this may be different from your *STANDARD-OUTPUT*,
-and under SLIME will be on your *inferior-lisp* buffer.
-If it's T, output goes to your current *STANDARD-OUTPUT* stream.
-Otherwise, OUTPUT should be a value that is a suitable first argument to
-SLURP-INPUT-STREAM (qv.), or a list of such a value and keyword arguments.
-In this case, RUN-PROGRAM will create a temporary stream for the program output;
-the program output, in that stream, will be processed by a call to SLURP-INPUT-STREAM,
-using OUTPUT as the first argument (or the first element of OUTPUT, and the rest as keywords).
-The primary value resulting from that call (or NIL if no call was needed)
-will be the first value returned by RUN-PROGRAM.
-E.g., using :OUTPUT :STRING will have it return the entire output stream as a string.
-And using :OUTPUT '(:STRING :STRIPPED T) will have it return the same string
-stripped of any ending newline.
+  (defun %signal-to-exit-code (signum)
+    (+ 128 signum))
+
+  #+mkcl
+  (defun %mkcl-signal-to-number (signal)
+    (require :mk-unix)
+    (symbol-value (find-symbol signal :mk-unix)))
+
+  (defclass process-info ()
+    ((process :initform nil)
+     (input-stream :initform nil)
+     (output-stream :initform nil)
+     (bidir-stream :initform nil)
+     (error-output-stream :initform nil)
+     ;; For backward-compatibility, to maintain the property (zerop
+     ;; exit-code) <-> success, an exit in response to a signal is
+     ;; encoded as 128+signum.
+     (exit-code :initform nil)
+     ;; If the platform allows it, distinguish exiting with a code
+     ;; >128 from exiting in response to a signal by setting this code
+     (signal-code :initform nil)))
 
-ERROR-OUTPUT is similar to OUTPUT, except that the resulting value is returned
-as the second value of RUN-PROGRAM. T designates the *ERROR-OUTPUT*.
-Also :OUTPUT means redirecting the error output to the output stream,
-in which case NIL is returned.
+;;;---------------------------------------------------------------------------
+;;; The following two helper functions take care of handling the IF-EXISTS and
+;;; IF-DOES-NOT-EXIST arguments for RUN-PROGRAM. In particular, they process the
+;;; :ERROR, :APPEND, and :SUPERSEDE arguments *here*, allowing the master
+;;; function to treat input and output files unconditionally for reading and
+;;; writing.
+;;;---------------------------------------------------------------------------
 
-INPUT is similar to OUTPUT, except that VOMIT-OUTPUT-STREAM is used,
-no value is returned, and T designates the *STANDARD-INPUT*.
+  (defun %handle-if-exists (file if-exists)
+    (when (or (stringp file) (pathnamep file))
+      (ecase if-exists
+        ((:append :supersede :error)
+         (with-open-file (dummy file :direction :output :if-exists if-exists)
+           (declare (ignorable dummy)))))))
+
+  (defun %handle-if-does-not-exist (file if-does-not-exist)
+    (when (or (stringp file) (pathnamep file))
+      (ecase if-does-not-exist
+        ((:create :error)
+         (with-open-file (dummy file :direction :probe
+                                :if-does-not-exist if-does-not-exist)
+           (declare (ignorable dummy)))))))
+
+  (defun process-info-error-output (process-info)
+    (slot-value process-info 'error-output-stream))
+  (defun process-info-input (process-info)
+    (or (slot-value process-info 'bidir-stream)
+        (slot-value process-info 'input-stream)))
+  (defun process-info-output (process-info)
+    (or (slot-value process-info 'bidir-stream)
+        (slot-value process-info 'output-stream)))
+
+  (defun process-info-pid (process-info)
+    (let ((process (slot-value process-info 'process)))
+      (declare (ignorable process))
+      #+abcl (symbol-call :sys :process-pid process)
+      #+allegro process
+      #+clozure (ccl:external-process-id process)
+      #+ecl (ext:external-process-pid process)
+      #+(or cmucl scl) (ext:process-pid process)
+      #+lispworks7+ (sys:pipe-pid process)
+      #+(and lispworks (not lispworks7+)) process
+      #+mkcl (mkcl:process-id process)
+      #+sbcl (sb-ext:process-pid process)
+      #-(or abcl allegro clozure cmucl ecl mkcl lispworks sbcl scl)
+      (not-implemented-error 'process-info-pid)))
+
+  (defun %process-status (process-info)
+    (if-let (exit-code (slot-value process-info 'exit-code))
+      (return-from %process-status
+        (if-let (signal-code (slot-value process-info 'signal-code))
+          (values :signaled signal-code)
+          (values :exited exit-code))))
+    #-(or allegro clozure cmucl ecl lispworks mkcl sbcl scl)
+    (not-implemented-error '%process-status)
+    (if-let (process (slot-value process-info 'process))
+      (multiple-value-bind (status code)
+          (progn
+            #+allegro (multiple-value-bind (exit-code pid signal)
+                          (sys:reap-os-subprocess :pid process :wait nil)
+                        (assert pid)
+                        (cond ((null exit-code) :running)
+                              ((null signal) (values :exited exit-code))
+                              (t (values :signaled signal))))
+            #+clozure (ccl:external-process-status process)
+            #+(or cmucl scl) (let ((status (ext:process-status process)))
+                               (values status (if (member status '(:exited :signaled))
+                                                  (ext:process-exit-code process))))
+            #+ecl (ext:external-process-status process)
+            #+lispworks
+            ;; a signal is only returned on LispWorks 7+
+            (multiple-value-bind (exit-code signal)
+                (funcall #+lispworks7+ #'sys:pipe-exit-status
+                         #-lispworks7+ #'sys:pid-exit-status
+                         process :wait nil)
+              (cond ((null exit-code) :running)
+                    ((null signal) (values :exited exit-code))
+                    (t (values :signaled signal))))
+            #+mkcl (let ((status (mk-ext:process-status process))
+                         (code (mk-ext:process-exit-code process)))
+                     (if (stringp code)
+                         (values :signaled (%mkcl-signal-to-number code))
+                         (values status code)))
+            #+sbcl (let ((status (sb-ext:process-status process)))
+                     (values status (if (member status '(:exited :signaled))
+                                        (sb-ext:process-exit-code process)))))
+        (case status
+          (:exited (setf (slot-value process-info 'exit-code) code))
+          (:signaled (let ((%code (%signal-to-exit-code code)))
+                       (setf (slot-value process-info 'exit-code) %code
+                             (slot-value process-info 'signal-code) code))))
+        (values status code))))
+
+  (defun process-alive-p (process-info)
+    "Check if a process has yet to exit."
+    (unless (slot-value process-info 'exit-code)
+      #+abcl (sys:process-alive-p (slot-value process-info 'process))
+      #+(or cmucl scl) (ext:process-alive-p (slot-value process-info 'process))
+      #+sbcl (sb-ext:process-alive-p (slot-value process-info 'process))
+      #-(or abcl cmucl sbcl scl) (member (%process-status process-info)
+                                         '(:running :sleeping))))
+
+  (defun wait-process (process-info)
+    "Wait for the process to terminate, if it is still running.
+Otherwise, return immediately. An exit code (a number) will be
+returned, with 0 indicating success, and anything else indicating
+failure. If the process exits after receiving a signal, the exit code
+will be the sum of 128 and the (positive) numeric signal code. A second
+value may be returned in this case: the numeric signal code itself.
+Any asynchronously spawned process requires this function to be run
+before it is garbage-collected in order to free up resources that
+might otherwise be irrevocably lost."
+    (if-let (exit-code (slot-value process-info 'exit-code))
+      (if-let (signal-code (slot-value process-info 'signal-code))
+        (values exit-code signal-code)
+        exit-code)
+      (let ((process (slot-value process-info 'process)))
+        #-(or abcl allegro clozure cmucl ecl lispworks mkcl sbcl scl)
+        (not-implemented-error 'wait-process)
+        (when process
+          ;; 1- wait
+          #+clozure (ccl::external-process-wait process)
+          #+(or cmucl scl) (ext:process-wait process)
+          #+sbcl (sb-ext:process-wait process)
+          ;; 2- extract result
+          (multiple-value-bind (exit-code signal-code)
+              (progn
+                #+abcl (sys:process-wait process)
+                #+allegro (multiple-value-bind (exit-code pid signal)
+                              (sys:reap-os-subprocess :pid process :wait t)
+                            (assert pid)
+                            (values exit-code signal))
+                #+clozure (multiple-value-bind (status code)
+                              (ccl:external-process-status process)
+                            (if (eq status :signaled)
+                                (values nil code)
+                                code))
+                #+(or cmucl scl) (let ((status (ext:process-status process))
+                                       (code (ext:process-exit-code process)))
+                                   (if (eq status :signaled)
+                                       (values nil code)
+                                       code))
+                #+ecl (multiple-value-bind (status code)
+                          (ext:external-process-wait process t)
+                        (if (eq status :signaled)
+                            (values nil code)
+                            code))
+                #+lispworks (funcall #+lispworks7+ #'sys:pipe-exit-status
+                                     #-lispworks7+ #'sys:pid-exit-status
+                                     process :wait t)
+                #+mkcl (let ((code (mkcl:join-process process)))
+                         (if (stringp code)
+                             (values nil (%mkcl-signal-to-number code))
+                             code))
+                #+sbcl (let ((status (sb-ext:process-status process))
+                             (code (sb-ext:process-exit-code process)))
+                         (if (eq status :signaled)
+                             (values nil code)
+                             code)))
+            (if signal-code
+                (let ((%exit-code (%signal-to-exit-code signal-code)))
+                  (setf (slot-value process-info 'exit-code) %exit-code
+                        (slot-value process-info 'signal-code) signal-code)
+                  (values %exit-code signal-code))
+                (progn (setf (slot-value process-info 'exit-code) exit-code)
+                       exit-code)))))))
+
+  ;; WARNING: For signals other than SIGTERM and SIGKILL this may not
+  ;; do what you expect it to. Sending SIGSTOP to a process spawned
+  ;; via LAUNCH-PROGRAM, e.g., will stop the shell /bin/sh that is used
+  ;; to run the command (via `sh -c command`) but not the actual
+  ;; command.
+  #+os-unix
+  (defun %posix-send-signal (process-info signal)
+    #+allegro (excl.osi:kill (slot-value process-info 'process) signal)
+    #+clozure (ccl:signal-external-process (slot-value process-info 'process)
+                                           signal :error-if-exited nil)
+    #+(or cmucl scl) (ext:process-kill (slot-value process-info 'process) signal)
+    #+sbcl (sb-ext:process-kill (slot-value process-info 'process) signal)
+    #-(or allegro clozure cmucl sbcl scl)
+    (if-let (pid (process-info-pid process-info))
+      (symbol-call :uiop :run-program
+                   (format nil "kill -~a ~a" signal pid) :ignore-error-status t)))
+
+  ;;; this function never gets called on Windows, but the compiler cannot tell
+  ;;; that. [2016/09/25:rpg]
+  #+os-windows
+  (defun %posix-send-signal (process-info signal)
+    (declare (ignore process-info signal))
+    (values))
 
-Use ELEMENT-TYPE and EXTERNAL-FORMAT are passed on
-to your Lisp implementation, when applicable, for creation of the output stream.
+  (defun terminate-process (process-info &key urgent)
+    "Cause the process to exit. To that end, the process may or may
+not be sent a signal, which it will find harder (or even impossible)
+to ignore if URGENT is T. On some platforms, it may also be subject to
+race conditions."
+    (declare (ignorable urgent))
+    #+abcl (sys:process-kill (slot-value process-info 'process))
+    ;; On ECL, this will only work on versions later than 2016-09-06,
+    ;; but we still want to compile on earlier versions, so we use symbol-call
+    #+ecl (symbol-call :ext :terminate-process (slot-value process-info 'process) urgent)
+    #+lispworks7+ (sys:pipe-kill-process (slot-value process-info 'process))
+    #+mkcl (mk-ext:terminate-process (slot-value process-info 'process)
+                                     :force urgent)
+    #-(or abcl ecl lispworks7+ mkcl)
+    (os-cond
+     ((os-unix-p) (%posix-send-signal process-info (if urgent 9 15)))
+     ((os-windows-p) (if-let (pid (process-info-pid process-info))
+                       (symbol-call :uiop :run-program
+                                    (format nil "taskkill ~:[~;/f ~]/pid ~a" urgent pid)
+                                    :ignore-error-status t)))
+     (t (not-implemented-error 'terminate-process))))
+
+  (defun close-streams (process-info)
+    "Close any stream that the process might own. Needs to be run
+whenever streams were requested by passing :stream to :input, :output,
+or :error-output."
+    (dolist (stream
+              (cons (slot-value process-info 'error-output-stream)
+                    (if-let (bidir-stream (slot-value process-info 'bidir-stream))
+                      (list bidir-stream)
+                      (list (slot-value process-info 'input-stream)
+                            (slot-value process-info 'output-stream)))))
+      (when stream (close stream))))
+
+  (defun launch-program (command &rest keys
+                         &key
+                           input (if-input-does-not-exist :error)
+                           output (if-output-exists :supersede)
+                           error-output (if-error-output-exists :supersede)
+                           (element-type #-clozure *default-stream-element-type*
+                                         #+clozure 'character)
+                           (external-format *utf-8-external-format*)
+                           directory
+                           #+allegro separate-streams
+                           &allow-other-keys)
+    "Launch program specified by COMMAND,
+either a list of strings specifying a program and list of arguments,
+or a string specifying a shell command (/bin/sh on Unix, CMD.EXE on
+Windows) _asynchronously_.
 
-One and only one of the stream slurping or vomiting may or may not happen
-in parallel in parallel with the subprocess,
-depending on options and implementation,
-and with priority being given to output processing.
-Other streams are completely produced or consumed
-before or after the subprocess is spawned, using temporary files.
+If OUTPUT is a pathname, a string designating a pathname, or NIL (the
+default) designating the null device, the file at that path is used as
+output.
+If it's :INTERACTIVE, output is inherited from the current process;
+beware that this may be different from your *STANDARD-OUTPUT*, and
+under SLIME will be on your *inferior-lisp* buffer.  If it's T, output
+goes to your current *STANDARD-OUTPUT* stream.  If it's :STREAM, a new
+stream will be made available that can be accessed via
+PROCESS-INFO-OUTPUT and read from. Otherwise, OUTPUT should be a value
+that the underlying lisp implementation knows how to handle.
+
+IF-OUTPUT-EXISTS, which is only meaningful if OUTPUT is a string or a
+pathname, can take the values :ERROR, :APPEND, and :SUPERSEDE (the
+default). The meaning of these values and their effect on the case
+where OUTPUT does not exist, is analogous to the IF-EXISTS parameter
+to OPEN with :DIRECTION :OUTPUT.
+
+ERROR-OUTPUT is similar to OUTPUT. T designates the *ERROR-OUTPUT*,
+:OUTPUT means redirecting the error output to the output stream,
+and :STREAM causes a stream to be made available via
+PROCESS-INFO-ERROR-OUTPUT.
+
+IF-ERROR-OUTPUT-EXISTS is similar to IF-OUTPUT-EXIST, except that it
+affects ERROR-OUTPUT rather than OUTPUT.
+
+INPUT is similar to OUTPUT, except that T designates the
+*STANDARD-INPUT* and a stream requested through the :STREAM keyword
+would be available through PROCESS-INFO-INPUT.
+
+IF-INPUT-DOES-NOT-EXIST, which is only meaningful if INPUT is a string
+or a pathname, can take the values :CREATE and :ERROR (the
+default). The meaning of these values is analogous to the
+IF-DOES-NOT-EXIST parameter to OPEN with :DIRECTION :INPUT.
+
+ELEMENT-TYPE and EXTERNAL-FORMAT are passed on to your Lisp
+implementation, when applicable, for creation of the output stream.
+
+LAUNCH-PROGRAM returns a PROCESS-INFO object."
+    #-(or abcl allegro clozure cmucl ecl (and lispworks os-unix) mkcl sbcl scl)
+    (progn command keys input output error-output directory element-type external-format
+           if-input-does-not-exist if-output-exists if-error-output-exists ;; ignore
+           (not-implemented-error 'launch-program))
+    #+allegro
+    (when (some #'(lambda (stream)
+                    (and (streamp stream)
+                         (not (file-stream-p stream))))
+                (list input output error-output))
+      (parameter-error "~S: Streams passed as I/O parameters need to be file streams on this lisp"
+                       'launch-program))
+    #+(or abcl clisp lispworks)
+    (when (some #'streamp (list input output error-output))
+      (parameter-error "~S: I/O parameters cannot be foreign streams on this lisp"
+                       'launch-program))
+    #+clisp
+    (unless (eq error-output :interactive)
+      (parameter-error "~S: The only admissible value for ~S is ~S on this lisp"
+                       'launch-program :error-output :interactive))
+    #+ecl
+    (when (some #'(lambda (stream)
+                    (and (streamp stream)
+                         (not (file-or-synonym-stream-p stream))))
+                (list input output error-output))
+      (parameter-error "~S: Streams passed as I/O parameters need to be (synonymous with) file streams on this lisp"
+                       'launch-program))
+    #+(or abcl allegro clozure cmucl ecl (and lispworks os-unix) mkcl sbcl scl)
+    (nest
+     (progn ;; see comments for these functions
+       (%handle-if-does-not-exist input if-input-does-not-exist)
+       (%handle-if-exists output if-output-exists)
+       (%handle-if-exists error-output if-error-output-exists))
+     (let ((process-info (make-instance 'process-info))
+           (input (%normalize-io-specifier input :input))
+           (output (%normalize-io-specifier output :output))
+           (error-output (%normalize-io-specifier error-output :error-output))
+           #+(and allegro os-windows) (interactive (%interactivep input output error-output))
+           (command
+            (etypecase command
+              #+os-unix (string `("/bin/sh" "-c" ,command))
+              #+os-unix (list command)
+              #+os-windows
+              (string
+               ;; NB: We add cmd /c here. Behavior without going through cmd is not well specified
+               ;; when the command contains spaces or special characters:
+               ;; IIUC, the system will use space as a separator,
+               ;; but the C++ argv-decoding libraries won't, and
+               ;; you're supposed to use an extra argument to CreateProcess to bridge the gap,
+               ;; yet neither allegro nor clisp provide access to that argument.
+               #+(or allegro clisp) (strcat "cmd /c " command)
+               ;; On ClozureCL for Windows, we assume you are using
+               ;; r15398 or later in 1.9 or later,
+               ;; so that bug 858 is fixed http://trac.clozure.com/ccl/ticket/858
+               ;; On SBCL, we assume the patch from fcae0fd (to be part of SBCL 1.3.13)
+               #+(or clozure sbcl) (cons "cmd" (strcat "/c " command))
+               ;; NB: On other Windows implementations, this is utterly bogus
+               ;; except in the most trivial cases where no quoting is needed.
+               ;; Use at your own risk.
+               #-(or allegro clisp clozure sbcl)
+               (parameter-error "~S doesn't support string commands on Windows on this lisp: ~S"
+                                'launch-program command))
+              #+os-windows
+              (list
+               #+allegro (escape-windows-command command)
+               #-allegro command)))))
+     #+(or abcl (and allegro os-unix) clozure cmucl ecl mkcl sbcl)
+     (let ((program (car command))
+           #-allegro (arguments (cdr command))))
+     #+(and sbcl os-windows)
+     (multiple-value-bind (arguments escape-arguments)
+         (if (listp arguments)
+             (values arguments t)
+             (values (list arguments) nil)))
+     #-(or allegro mkcl sbcl) (with-current-directory (directory))
+     (multiple-value-bind
+       #+(or abcl clozure cmucl sbcl scl) (process)
+       #+allegro (in-or-io out-or-err err-or-pid pid-or-nil)
+       #+ecl (stream code process)
+       #+lispworks (io-or-pid err-or-nil #-lispworks7+ pid-or-nil)
+       #+mkcl (stream process code)
+       #.`(apply
+           #+abcl 'sys:run-program
+           #+allegro ,@'('excl:run-shell-command
+                         #+os-unix (coerce (cons program command) 'vector)
+                         #+os-windows command)
+           #+clozure 'ccl:run-program
+           #+(or cmucl ecl scl) 'ext:run-program
+           #+lispworks ,@'('system:run-shell-command `("/usr/bin/env" ,@command)) ; full path needed
+           #+mkcl 'mk-ext:run-program
+           #+sbcl 'sb-ext:run-program
+           #+(or abcl clozure cmucl ecl mkcl sbcl) ,@'(program arguments)
+           #+(and sbcl os-windows) ,@'(:escape-arguments escape-arguments)
+           :input input :if-input-does-not-exist :error
+           :output output :if-output-exists :append
+           ,(or #+(or allegro lispworks) :error-output :error) error-output
+           ,(or #+(or allegro lispworks) :if-error-output-exists :if-error-exists) :append
+           :wait nil :element-type element-type :external-format external-format
+           :allow-other-keys t
+           #+allegro ,@`(:directory directory
+                         #+os-windows ,@'(:show-window (if interactive nil :hide)))
+           #+lispworks ,@'(:save-exit-status t)
+           #+mkcl ,@'(:directory (native-namestring directory))
+           #-sbcl keys ;; on SBCL, don't pass :directory nil but remove it from the keys
+           #+sbcl ,@'(:search t (if directory keys (remove-plist-key :directory keys)))))
+     (labels ((prop (key value) (setf (slot-value process-info key) value)))
+       #+allegro
+       (cond
+         (separate-streams
+          (prop 'process pid-or-nil)
+          (when (eq input :stream) (prop 'input-stream in-or-io))
+          (when (eq output :stream) (prop 'output-stream out-or-err))
+          (when (eq error-output :stream) (prop 'error-stream err-or-pid)))
+         (t
+          (prop 'process err-or-pid)
+          (ecase (+ (if (eq input :stream) 1 0) (if (eq output :stream) 2 0))
+            (0)
+            (1 (prop 'input-stream in-or-io))
+            (2 (prop 'output-stream in-or-io))
+            (3 (prop 'bidir-stream in-or-io)))
+          (when (eq error-output :stream)
+            (prop 'error-stream out-or-err))))
+       #+(or abcl clozure cmucl sbcl scl)
+       (progn
+         (prop 'process process)
+         (when (eq input :stream)
+           (nest
+            (prop 'input-stream)
+            #+abcl (symbol-call :sys :process-input)
+            #+clozure (ccl:external-process-input-stream)
+            #+(or cmucl scl) (ext:process-input)
+            #+sbcl (sb-ext:process-input)
+            process))
+         (when (eq output :stream)
+           (nest
+            (prop 'output-stream)
+            #+abcl (symbol-call :sys :process-output)
+            #+clozure (ccl:external-process-output-stream)
+            #+(or cmucl scl) (ext:process-output)
+            #+sbcl (sb-ext:process-output)
+            process))
+         (when (eq error-output :stream)
+           (nest
+            (prop 'error-output-stream)
+            #+abcl (symbol-call :sys :process-error)
+            #+clozure (ccl:external-process-error-stream)
+            #+(or cmucl scl) (ext:process-error)
+            #+sbcl (sb-ext:process-error)
+            process)))
+       #+(or ecl mkcl)
+       (let ((mode (+ (if (eq input :stream) 1 0) (if (eq output :stream) 2 0))))
+         code ;; ignore
+         (unless (zerop mode)
+           (prop (case mode (1 'input-stream) (2 'output-stream) (3 'bidir-stream)) stream))
+         (prop 'process process))
+       #+lispworks
+       (let ((mode (+ (if (eq input :stream) 1 0) (if (eq output :stream) 2 0))))
+         (cond
+           ((or (plusp mode) (eq error-output :stream))
+            (prop 'process #+lispworks7+ io-or-pid #-lispworks7+ pid-or-nil)
+            (when (plusp mode)
+              (prop (ecase mode
+                      (1 'input-stream)
+                      (2 'output-stream)
+                      (3 'bidir-stream)) io-or-pid))
+            (when (eq error-output :stream)
+              (prop 'error-stream err-or-nil)))
+           ;; lispworks6 returns (pid), lispworks7 returns (io err pid) of which we keep io
+           (t (prop 'process io-or-pid)))))
+     process-info)))
 
-RUN-PROGRAM returns 3 values:
-0- the result of the OUTPUT slurping if any, or NIL
-1- the result of the ERROR-OUTPUT slurping if any, or NIL
-2- either 0 if the subprocess exited with success status,
-or an indication of failure via the EXIT-CODE of the process"
-    (declare (ignorable ignore-error-status))
-    #-(or abcl allegro clasp clisp clozure cmu cormanlisp ecl gcl lispworks mcl mkcl sbcl scl xcl)
-    (error "RUN-PROGRAM not implemented for this Lisp")
-    ;; per doc string, set FORCE-SHELL to T if we get command as a string.  But
-    ;; don't override user's specified preference. [2015/06/29:rpg]
-    (when (stringp command)
-      (unless force-shell-suppliedp
-        #-(and sbcl os-windows) ;; force-shell t isn't working properly on windows as of sbcl 1.2.16
-        (setf force-shell t)))
-    (flet ((default (x xp output) (cond (xp x) ((eq output :interactive) :interactive))))
-      (apply (if (or force-shell
-                     #+(or clasp clisp) (or (not ignore-error-status) t)
-                     #+clisp (member error-output '(:interactive :output))
-                     ;; A race condition in ECL <= 16.0.0 prevents using ext:run-program
-                     #+ecl #.(if-let (ver (parse-version (lisp-implementation-version)))
-                               (lexicographic<= '< ver '(16 0 1)))
-                     #+(and lispworks os-unix) (%interactivep input output error-output)
-                     #+(or abcl cormanlisp gcl (and lispworks os-windows) mcl xcl) t)
-                 '%use-system '%use-run-program)
-             command
-             :input (default input inputp output)
-             :error-output (default error-output error-output-p output)
-             :if-input-does-not-exist if-input-does-not-exist
-             :if-output-exists if-output-exists
-             :if-error-output-exists if-error-output-exists
-             :element-type element-type :external-format external-format
-             keys))))
 ;;;; -------------------------------------------------------------------------
-;;;; Support to build (compile and load) Lisp files
+;;;; run-program initially from xcvb-driver.
 
-(uiop/package:define-package :uiop/lisp-build
-  (:nicknames :asdf/lisp-build) ;; OBSOLETE, used by slime/contrib/swank-asdf.lisp
-  (:use :uiop/common-lisp :uiop/package :uiop/utility
-   :uiop/os :uiop/pathname :uiop/filesystem :uiop/stream :uiop/image)
+(uiop/package:define-package :uiop/run-program
+  (:nicknames :asdf/run-program) ; OBSOLETE. Used by cl-sane, printv.
+  (:use :uiop/common-lisp :uiop/package :uiop/utility :uiop/version
+   :uiop/pathname :uiop/os :uiop/filesystem :uiop/stream :uiop/launch-program)
   (:export
-   ;; Variables
-   #:*compile-file-warnings-behaviour* #:*compile-file-failure-behaviour*
-   #:*output-translation-function*
-   #:*optimization-settings* #:*previous-optimization-settings*
-   #:*base-build-directory*
-   #:compile-condition #:compile-file-error #:compile-warned-error #:compile-failed-error
-   #:compile-warned-warning #:compile-failed-warning
-   #:check-lisp-compile-results #:check-lisp-compile-warnings
-   #:*uninteresting-conditions* #:*usual-uninteresting-conditions*
-   #:*uninteresting-compiler-conditions* #:*uninteresting-loader-conditions*
-   ;; Types
-   #+sbcl #:sb-grovel-unknown-constant-condition
-   ;; Functions & Macros
-   #:get-optimization-settings #:proclaim-optimization-settings #:with-optimization-settings
-   #:call-with-muffled-compiler-conditions #:with-muffled-compiler-conditions
-   #:call-with-muffled-loader-conditions #:with-muffled-loader-conditions
-   #:reify-simple-sexp #:unreify-simple-sexp
-   #:reify-deferred-warnings #:unreify-deferred-warnings
-   #:reset-deferred-warnings #:save-deferred-warnings #:check-deferred-warnings
-   #:with-saved-deferred-warnings #:warnings-file-p #:warnings-file-type #:*warnings-file-type*
-   #:enable-deferred-warnings-check #:disable-deferred-warnings-check
-   #:current-lisp-file-pathname #:load-pathname
-   #:lispize-pathname #:compile-file-type #:call-around-hook
-   #:compile-file* #:compile-file-pathname* #:*compile-check*
-   #:load* #:load-from-string #:combine-fasls)
-  (:intern #:defaults #:failure-p #:warnings-p #:s #:y #:body))
-(in-package :uiop/lisp-build)
+   #:run-program
+   #:slurp-input-stream #:vomit-output-stream
+   #:subprocess-error
+   #:subprocess-error-code #:subprocess-error-command #:subprocess-error-process)
+  (:import-from :uiop/launch-program
+   #:%handle-if-does-not-exist #:%handle-if-exists #:%interactivep
+   #:input-stream #:output-stream #:error-output-stream))
+(in-package :uiop/run-program)
 
+;;;; Slurping a stream, typically the output of another program
 (with-upgradability ()
-  (defvar *compile-file-warnings-behaviour*
-    (or #+clisp :ignore :warn)
-    "How should ASDF react if it encounters a warning when compiling a file?
-Valid values are :error, :warn, and :ignore.")
+  (defun call-stream-processor (fun processor stream)
+    "Given FUN (typically SLURP-INPUT-STREAM or VOMIT-OUTPUT-STREAM,
+a PROCESSOR specification which is either an atom or a list specifying
+a processor an keyword arguments, call the specified processor with
+the given STREAM as input"
+    (if (consp processor)
+        (apply fun (first processor) stream (rest processor))
+        (funcall fun processor stream)))
 
-  (defvar *compile-file-failure-behaviour*
-    (or #+(or mkcl sbcl) :error #+clisp :ignore :warn)
-    "How should ASDF react if it encounters a failure (per the ANSI spec of COMPILE-FILE)
-when compiling a file, which includes any non-style-warning warning.
-Valid values are :error, :warn, and :ignore.
-Note that ASDF ALWAYS raises an error if it fails to create an output file when compiling.")
+  (defgeneric slurp-input-stream (processor input-stream &key)
+    (:documentation
+     "SLURP-INPUT-STREAM is a generic function with two positional arguments
+PROCESSOR and INPUT-STREAM and additional keyword arguments, that consumes (slurps)
+the contents of the INPUT-STREAM and processes them according to a method
+specified by PROCESSOR.
+
+Built-in methods include the following:
+* if PROCESSOR is a function, it is called with the INPUT-STREAM as its argument
+* if PROCESSOR is a list, its first element should be a function.  It will be applied to a cons of the
+  INPUT-STREAM and the rest of the list.  That is (x . y) will be treated as
+    \(APPLY x <stream> y\)
+* if PROCESSOR is an output-stream, the contents of INPUT-STREAM is copied to the output-stream,
+  per copy-stream-to-stream, with appropriate keyword arguments.
+* if PROCESSOR is the symbol CL:STRING or the keyword :STRING, then the contents of INPUT-STREAM
+  are returned as a string, as per SLURP-STREAM-STRING.
+* if PROCESSOR is the keyword :LINES then the INPUT-STREAM will be handled by SLURP-STREAM-LINES.
+* if PROCESSOR is the keyword :LINE then the INPUT-STREAM will be handled by SLURP-STREAM-LINE.
+* if PROCESSOR is the keyword :FORMS then the INPUT-STREAM will be handled by SLURP-STREAM-FORMS.
+* if PROCESSOR is the keyword :FORM then the INPUT-STREAM will be handled by SLURP-STREAM-FORM.
+* if PROCESSOR is T, it is treated the same as *standard-output*. If it is NIL, NIL is returned.
+
+Programmers are encouraged to define their own methods for this generic function."))
+
+  #-genera
+  (defmethod slurp-input-stream ((function function) input-stream &key)
+    (funcall function input-stream))
 
-  (defvar *base-build-directory* nil
-    "When set to a non-null value, it should be an absolute directory pathname,
-which will serve as the *DEFAULT-PATHNAME-DEFAULTS* around a COMPILE-FILE,
-what more while the input-file is shortened if possible to ENOUGH-PATHNAME relative to it.
-This can help you produce more deterministic output for FASLs."))
+  (defmethod slurp-input-stream ((list cons) input-stream &key)
+    (apply (first list) input-stream (rest list)))
 
-;;; Optimization settings
-(with-upgradability ()
-  (defvar *optimization-settings* nil
-    "Optimization settings to be used by PROCLAIM-OPTIMIZATION-SETTINGS")
-  (defvar *previous-optimization-settings* nil
-    "Optimization settings saved by PROCLAIM-OPTIMIZATION-SETTINGS")
-  (defparameter +optimization-variables+
-    ;; TODO: allegro genera corman mcl
-    (or #+(or abcl xcl) '(system::*speed* system::*space* system::*safety* system::*debug*)
-        #+clisp '() ;; system::*optimize* is a constant hash-table! (with non-constant contents)
-        #+clozure '(ccl::*nx-speed* ccl::*nx-space* ccl::*nx-safety*
-                    ccl::*nx-debug* ccl::*nx-cspeed*)
-        #+(or cmucl scl) '(c::*default-cookie*)
-        #+(and ecl (not clasp)) (unless (use-ecl-byte-compiler-p) '(c::*speed* c::*space* c::*safety* c::*debug*))
-        #+clasp '()
-        #+gcl '(compiler::*speed* compiler::*space* compiler::*compiler-new-safety* compiler::*debug*)
-        #+lispworks '(compiler::*optimization-level*)
-        #+mkcl '(si::*speed* si::*space* si::*safety* si::*debug*)
-        #+sbcl '(sb-c::*policy*)))
-  (defun get-optimization-settings ()
-    "Get current compiler optimization settings, ready to PROCLAIM again"
-    #-(or abcl allegro clasp clisp clozure cmucl ecl lispworks mkcl sbcl scl xcl)
-    (warn "~S does not support ~S. Please help me fix that."
-          'get-optimization-settings (implementation-type))
-    #+(or abcl allegro clasp clisp clozure cmucl ecl lispworks mkcl sbcl scl xcl)
-    (let ((settings '(speed space safety debug compilation-speed #+(or cmucl scl) c::brevity)))
-      #.`(loop #+(or allegro clozure)
-               ,@'(:with info = #+allegro (sys:declaration-information 'optimize)
-                   #+clozure (ccl:declaration-information 'optimize nil))
-               :for x :in settings
-               ,@(or #+(or abcl clasp ecl gcl mkcl xcl) '(:for v :in +optimization-variables+))
-               :for y = (or #+(or allegro clozure) (second (assoc x info)) ; normalize order
-                            #+clisp (gethash x system::*optimize* 1)
-                            #+(or abcl clasp ecl mkcl xcl) (symbol-value v)
-                            #+(or cmucl scl) (slot-value c::*default-cookie*
-                                                       (case x (compilation-speed 'c::cspeed)
-                                                             (otherwise x)))
-                            #+lispworks (slot-value compiler::*optimization-level* x)
-                            #+sbcl (sb-c::policy-quality sb-c::*policy* x))
-               :when y :collect (list x y))))
-  (defun proclaim-optimization-settings ()
-    "Proclaim the optimization settings in *OPTIMIZATION-SETTINGS*"
-    (proclaim `(optimize ,@*optimization-settings*))
-    (let ((settings (get-optimization-settings)))
-      (unless (equal *previous-optimization-settings* settings)
-        (setf *previous-optimization-settings* settings))))
-  (defmacro with-optimization-settings ((&optional (settings *optimization-settings*)) &body body)
-    #+(or allegro clisp)
-    (let ((previous-settings (gensym "PREVIOUS-SETTINGS")))
-      `(let ((,previous-settings (get-optimization-settings)))
-         ,@(when settings `((proclaim `(optimize ,@,settings))))
-         (unwind-protect (progn ,@body)
-           (proclaim `(optimize ,@,previous-settings)))))
-    #-(or allegro clisp)
-    `(let ,(loop :for v :in +optimization-variables+ :collect `(,v ,v))
-       ,@(when settings `((proclaim `(optimize ,@,settings))))
-       ,@body)))
+  #-genera
+  (defmethod slurp-input-stream ((output-stream stream) input-stream
+                                 &key linewise prefix (element-type 'character) buffer-size)
+    (copy-stream-to-stream
+     input-stream output-stream
+     :linewise linewise :prefix prefix :element-type element-type :buffer-size buffer-size))
 
+  (defmethod slurp-input-stream ((x (eql 'string)) stream &key stripped)
+    (slurp-stream-string stream :stripped stripped))
 
-;;; Condition control
-(with-upgradability ()
-  #+sbcl
-  (progn
-    (defun sb-grovel-unknown-constant-condition-p (c)
-      "Detect SB-GROVEL unknown-constant conditions on older versions of SBCL"
-      (and (typep c 'sb-int:simple-style-warning)
-           (string-enclosed-p
-            "Couldn't grovel for "
-            (simple-condition-format-control c)
-            " (unknown to the C compiler).")))
-    (deftype sb-grovel-unknown-constant-condition ()
-      '(and style-warning (satisfies sb-grovel-unknown-constant-condition-p))))
+  (defmethod slurp-input-stream ((x (eql :string)) stream &key stripped)
+    (slurp-stream-string stream :stripped stripped))
 
-  (defvar *usual-uninteresting-conditions*
-    (append
-     ;;#+clozure '(ccl:compiler-warning)
-     #+cmucl '("Deleting unreachable code.")
-     #+lispworks '("~S being redefined in ~A (previously in ~A)."
-                   "~S defined more than once in ~A.") ;; lispworks gets confused by eval-when.
-     #+sbcl
-     '(sb-c::simple-compiler-note
-       "&OPTIONAL and &KEY found in the same lambda list: ~S"
-       #+sb-eval sb-kernel:lexical-environment-too-complex
-       sb-kernel:undefined-alien-style-warning
-       sb-grovel-unknown-constant-condition ; defined above.
-       sb-ext:implicit-generic-function-warning ;; Controversial.
-       sb-int:package-at-variance
-       sb-kernel:uninteresting-redefinition
-       ;; BEWARE: the below four are controversial to include here.
-       sb-kernel:redefinition-with-defun
-       sb-kernel:redefinition-with-defgeneric
-       sb-kernel:redefinition-with-defmethod
-       sb-kernel::redefinition-with-defmacro) ; not exported by old SBCLs
-     '("No generic function ~S present when encountering macroexpansion of defmethod. Assuming it will be an instance of standard-generic-function.")) ;; from closer2mop
-    "A suggested value to which to set or bind *uninteresting-conditions*.")
+  (defmethod slurp-input-stream ((x (eql :lines)) stream &key count)
+    (slurp-stream-lines stream :count count))
 
-  (defvar *uninteresting-conditions* '()
-    "Conditions that may be skipped while compiling or loading Lisp code.")
-  (defvar *uninteresting-compiler-conditions* '()
-    "Additional conditions that may be skipped while compiling Lisp code.")
-  (defvar *uninteresting-loader-conditions*
-    (append
-     '("Overwriting already existing readtable ~S." ;; from named-readtables
-       #(#:finalizers-off-warning :asdf-finalizers)) ;; from asdf-finalizers
-     #+clisp '(clos::simple-gf-replacing-method-warning))
-    "Additional conditions that may be skipped while loading Lisp code."))
+  (defmethod slurp-input-stream ((x (eql :line)) stream &key (at 0))
+    (slurp-stream-line stream :at at))
 
-;;;; ----- Filtering conditions while building -----
-(with-upgradability ()
-  (defun call-with-muffled-compiler-conditions (thunk)
-    "Call given THUNK in a context where uninteresting conditions and compiler conditions are muffled"
-    (call-with-muffled-conditions
-     thunk (append *uninteresting-conditions* *uninteresting-compiler-conditions*)))
-  (defmacro with-muffled-compiler-conditions ((&optional) &body body)
-    "Trivial syntax for CALL-WITH-MUFFLED-COMPILER-CONDITIONS"
-    `(call-with-muffled-compiler-conditions #'(lambda () ,@body)))
-  (defun call-with-muffled-loader-conditions (thunk)
-    "Call given THUNK in a context where uninteresting conditions and loader conditions are muffled"
-    (call-with-muffled-conditions
-     thunk (append *uninteresting-conditions* *uninteresting-loader-conditions*)))
-  (defmacro with-muffled-loader-conditions ((&optional) &body body)
-    "Trivial syntax for CALL-WITH-MUFFLED-LOADER-CONDITIONS"
-    `(call-with-muffled-loader-conditions #'(lambda () ,@body))))
+  (defmethod slurp-input-stream ((x (eql :forms)) stream &key count)
+    (slurp-stream-forms stream :count count))
 
+  (defmethod slurp-input-stream ((x (eql :form)) stream &key (at 0))
+    (slurp-stream-form stream :at at))
 
-;;;; Handle warnings and failures
-(with-upgradability ()
-  (define-condition compile-condition (condition)
-    ((context-format
-      :initform nil :reader compile-condition-context-format :initarg :context-format)
-     (context-arguments
-      :initform nil :reader compile-condition-context-arguments :initarg :context-arguments)
-     (description
-      :initform nil :reader compile-condition-description :initarg :description))
-    (:report (lambda (c s)
-               (format s (compatfmt "~@<~A~@[ while ~?~]~@:>")
-                       (or (compile-condition-description c) (type-of c))
-                       (compile-condition-context-format c)
-                       (compile-condition-context-arguments c)))))
-  (define-condition compile-file-error (compile-condition error) ())
-  (define-condition compile-warned-warning (compile-condition warning) ())
-  (define-condition compile-warned-error (compile-condition error) ())
-  (define-condition compile-failed-warning (compile-condition warning) ())
-  (define-condition compile-failed-error (compile-condition error) ())
+  (defmethod slurp-input-stream ((x (eql t)) stream &rest keys &key &allow-other-keys)
+    (apply 'slurp-input-stream *standard-output* stream keys))
 
-  (defun check-lisp-compile-warnings (warnings-p failure-p
-                                                  &optional context-format context-arguments)
-    "Given the warnings or failures as resulted from COMPILE-FILE or checking deferred warnings,
-raise an error or warning as appropriate"
-    (when failure-p
-      (case *compile-file-failure-behaviour*
-        (:warn (warn 'compile-failed-warning
-                     :description "Lisp compilation failed"
-                     :context-format context-format
-                     :context-arguments context-arguments))
-        (:error (error 'compile-failed-error
-                       :description "Lisp compilation failed"
-                       :context-format context-format
-                       :context-arguments context-arguments))
-        (:ignore nil)))
-    (when warnings-p
-      (case *compile-file-warnings-behaviour*
-        (:warn (warn 'compile-warned-warning
-                     :description "Lisp compilation had style-warnings"
-                     :context-format context-format
-                     :context-arguments context-arguments))
-        (:error (error 'compile-warned-error
-                       :description "Lisp compilation had style-warnings"
-                       :context-format context-format
-                       :context-arguments context-arguments))
-        (:ignore nil))))
+  (defmethod slurp-input-stream ((x null) (stream t) &key)
+    nil)
 
-  (defun check-lisp-compile-results (output warnings-p failure-p
-                                             &optional context-format context-arguments)
-    "Given the results of COMPILE-FILE, raise an error or warning as appropriate"
-    (unless output
-      (error 'compile-file-error :context-format context-format :context-arguments context-arguments))
-    (check-lisp-compile-warnings warnings-p failure-p context-format context-arguments)))
+  (defmethod slurp-input-stream ((pathname pathname) input
+                                 &key
+                                   (element-type *default-stream-element-type*)
+                                   (external-format *utf-8-external-format*)
+                                   (if-exists :rename-and-delete)
+                                   (if-does-not-exist :create)
+                                   buffer-size
+                                   linewise)
+    (with-output-file (output pathname
+                              :element-type element-type
+                              :external-format external-format
+                              :if-exists if-exists
+                              :if-does-not-exist if-does-not-exist)
+      (copy-stream-to-stream
+       input output
+       :element-type element-type :buffer-size buffer-size :linewise linewise)))
 
+  (defmethod slurp-input-stream (x stream
+                                 &key linewise prefix (element-type 'character) buffer-size)
+    (declare (ignorable stream linewise prefix element-type buffer-size))
+    (cond
+      #+genera
+      ((functionp x) (funcall x stream))
+      #+genera
+      ((output-stream-p x)
+       (copy-stream-to-stream
+        stream x
+        :linewise linewise :prefix prefix :element-type element-type :buffer-size buffer-size))
+      (t
+       (error "Invalid ~S destination ~S" 'slurp-input-stream x)))))
 
-;;;; Deferred-warnings treatment, originally implemented by Douglas Katzman.
-;;;
-;;; To support an implementation, three functions must be implemented:
-;;; reify-deferred-warnings unreify-deferred-warnings reset-deferred-warnings
-;;; See their respective docstrings.
+;;;; Vomiting a stream, typically into the input of another program.
 (with-upgradability ()
-  (defun reify-simple-sexp (sexp)
-    "Given a simple SEXP, return a representation of it as a portable SEXP.
-Simple means made of symbols, numbers, characters, simple-strings, pathnames, cons cells."
-    (etypecase sexp
-      (symbol (reify-symbol sexp))
-      ((or number character simple-string pathname) sexp)
-      (cons (cons (reify-simple-sexp (car sexp)) (reify-simple-sexp (cdr sexp))))
-      (simple-vector (vector (mapcar 'reify-simple-sexp (coerce sexp 'list))))))
+  (defgeneric vomit-output-stream (processor output-stream &key)
+    (:documentation
+     "VOMIT-OUTPUT-STREAM is a generic function with two positional arguments
+PROCESSOR and OUTPUT-STREAM and additional keyword arguments, that produces (vomits)
+some content onto the OUTPUT-STREAM, according to a method specified by PROCESSOR.
+
+Built-in methods include the following:
+* if PROCESSOR is a function, it is called with the OUTPUT-STREAM as its argument
+* if PROCESSOR is a list, its first element should be a function.
+  It will be applied to a cons of the OUTPUT-STREAM and the rest of the list.
+  That is (x . y) will be treated as \(APPLY x <stream> y\)
+* if PROCESSOR is an input-stream, its contents will be copied the OUTPUT-STREAM,
+  per copy-stream-to-stream, with appropriate keyword arguments.
+* if PROCESSOR is a string, its contents will be printed to the OUTPUT-STREAM.
+* if PROCESSOR is T, it is treated the same as *standard-input*. If it is NIL, nothing is done.
 
-  (defun unreify-simple-sexp (sexp)
-    "Given the portable output of REIFY-SIMPLE-SEXP, return the simple SEXP it represents"
-    (etypecase sexp
-      ((or symbol number character simple-string pathname) sexp)
-      (cons (cons (unreify-simple-sexp (car sexp)) (unreify-simple-sexp (cdr sexp))))
-      ((simple-vector 2) (unreify-symbol sexp))
-      ((simple-vector 1) (coerce (mapcar 'unreify-simple-sexp (aref sexp 0)) 'vector))))
+Programmers are encouraged to define their own methods for this generic function."))
 
-  #+clozure
-  (progn
-    (defun reify-source-note (source-note)
-      (when source-note
-        (with-accessors ((source ccl::source-note-source) (filename ccl:source-note-filename)
-                         (start-pos ccl:source-note-start-pos) (end-pos ccl:source-note-end-pos)) source-note
-          (declare (ignorable source))
-          (list :filename filename :start-pos start-pos :end-pos end-pos
-                #|:source (reify-source-note source)|#))))
-    (defun unreify-source-note (source-note)
-      (when source-note
-        (destructuring-bind (&key filename start-pos end-pos source) source-note
-          (ccl::make-source-note :filename filename :start-pos start-pos :end-pos end-pos
-                                 :source (unreify-source-note source)))))
-    (defun unsymbolify-function-name (name)
-      (if-let (setfed (gethash name ccl::%setf-function-name-inverses%))
-        `(setf ,setfed)
-        name))
-    (defun symbolify-function-name (name)
-      (if (and (consp name) (eq (first name) 'setf))
-          (let ((setfed (second name)))
-            (gethash setfed ccl::%setf-function-names%))
-          name))
-    (defun reify-function-name (function-name)
-      (let ((name (or (first function-name) ;; defun: extract the name
-                      (let ((sec (second function-name)))
-                        (or (and (atom sec) sec) ; scoped method: drop scope
-                            (first sec)))))) ; method: keep gf name, drop method specializers
-        (list name)))
-    (defun unreify-function-name (function-name)
-      function-name)
-    (defun nullify-non-literals (sexp)
-      (typecase sexp
-        ((or number character simple-string symbol pathname) sexp)
-        (cons (cons (nullify-non-literals (car sexp))
-                    (nullify-non-literals (cdr sexp))))
-        (t nil)))
-    (defun reify-deferred-warning (deferred-warning)
-      (with-accessors ((warning-type ccl::compiler-warning-warning-type)
-                       (args ccl::compiler-warning-args)
-                       (source-note ccl:compiler-warning-source-note)
-                       (function-name ccl:compiler-warning-function-name)) deferred-warning
-        (list :warning-type warning-type :function-name (reify-function-name function-name)
-              :source-note (reify-source-note source-note)
-              :args (destructuring-bind (fun &rest more)
-                        args
-                      (cons (unsymbolify-function-name fun)
-                            (nullify-non-literals more))))))
-    (defun unreify-deferred-warning (reified-deferred-warning)
-      (destructuring-bind (&key warning-type function-name source-note args)
-          reified-deferred-warning
-        (make-condition (or (cdr (ccl::assq warning-type ccl::*compiler-whining-conditions*))
-                            'ccl::compiler-warning)
-                        :function-name (unreify-function-name function-name)
-                        :source-note (unreify-source-note source-note)
-                        :warning-type warning-type
-                        :args (destructuring-bind (fun . more) args
-                                (cons (symbolify-function-name fun) more))))))
-  #+(or cmucl scl)
-  (defun reify-undefined-warning (warning)
-    ;; Extracting undefined-warnings from the compilation-unit
-    ;; To be passed through the above reify/unreify link, it must be a "simple-sexp"
-    (list*
-     (c::undefined-warning-kind warning)
-     (c::undefined-warning-name warning)
-     (c::undefined-warning-count warning)
-     (mapcar
-      #'(lambda (frob)
-          ;; the lexenv slot can be ignored for reporting purposes
-          `(:enclosing-source ,(c::compiler-error-context-enclosing-source frob)
-            :source ,(c::compiler-error-context-source frob)
-            :original-source ,(c::compiler-error-context-original-source frob)
-            :context ,(c::compiler-error-context-context frob)
-            :file-name ,(c::compiler-error-context-file-name frob) ; a pathname
-            :file-position ,(c::compiler-error-context-file-position frob) ; an integer
-            :original-source-path ,(c::compiler-error-context-original-source-path frob)))
-      (c::undefined-warning-warnings warning))))
+  #-genera
+  (defmethod vomit-output-stream ((function function) output-stream &key)
+    (funcall function output-stream))
 
-  #+sbcl
-  (defun reify-undefined-warning (warning)
-    ;; Extracting undefined-warnings from the compilation-unit
-    ;; To be passed through the above reify/unreify link, it must be a "simple-sexp"
-    (list*
-     (sb-c::undefined-warning-kind warning)
-     (sb-c::undefined-warning-name warning)
-     (sb-c::undefined-warning-count warning)
-     (mapcar
-      #'(lambda (frob)
-          ;; the lexenv slot can be ignored for reporting purposes
-          `(:enclosing-source ,(sb-c::compiler-error-context-enclosing-source frob)
-            :source ,(sb-c::compiler-error-context-source frob)
-            :original-source ,(sb-c::compiler-error-context-original-source frob)
-            :context ,(sb-c::compiler-error-context-context frob)
-            :file-name ,(sb-c::compiler-error-context-file-name frob) ; a pathname
-            :file-position ,(sb-c::compiler-error-context-file-position frob) ; an integer
-            :original-source-path ,(sb-c::compiler-error-context-original-source-path frob)))
-      (sb-c::undefined-warning-warnings warning))))
+  (defmethod vomit-output-stream ((list cons) output-stream &key)
+    (apply (first list) output-stream (rest list)))
 
-  (defun reify-deferred-warnings ()
-    "return a portable S-expression, portably readable and writeable in any Common Lisp implementation
-using READ within a WITH-SAFE-IO-SYNTAX, that represents the warnings currently deferred by
-WITH-COMPILATION-UNIT. One of three functions required for deferred-warnings support in ASDF."
-    #+allegro
-    (list :functions-defined excl::.functions-defined.
-          :functions-called excl::.functions-called.)
-    #+clozure
-    (mapcar 'reify-deferred-warning
-            (if-let (dw ccl::*outstanding-deferred-warnings*)
-              (let ((mdw (ccl::ensure-merged-deferred-warnings dw)))
-                (ccl::deferred-warnings.warnings mdw))))
-    #+(or cmucl scl)
-    (when lisp::*in-compilation-unit*
-      ;; Try to send nothing through the pipe if nothing needs to be accumulated
-      `(,@(when c::*undefined-warnings*
-            `((c::*undefined-warnings*
-               ,@(mapcar #'reify-undefined-warning c::*undefined-warnings*))))
-        ,@(loop :for what :in '(c::*compiler-error-count*
-                                c::*compiler-warning-count*
-                                c::*compiler-note-count*)
-                :for value = (symbol-value what)
-                :when (plusp value)
-                  :collect `(,what . ,value))))
-    #+sbcl
-    (when sb-c::*in-compilation-unit*
-      ;; Try to send nothing through the pipe if nothing needs to be accumulated
-      `(,@(when sb-c::*undefined-warnings*
-            `((sb-c::*undefined-warnings*
-               ,@(mapcar #'reify-undefined-warning sb-c::*undefined-warnings*))))
-        ,@(loop :for what :in '(sb-c::*aborted-compilation-unit-count*
-                                sb-c::*compiler-error-count*
-                                sb-c::*compiler-warning-count*
-                                sb-c::*compiler-style-warning-count*
-                                sb-c::*compiler-note-count*)
-                :for value = (symbol-value what)
-                :when (plusp value)
-                  :collect `(,what . ,value)))))
+  #-genera
+  (defmethod vomit-output-stream ((input-stream stream) output-stream
+                                 &key linewise prefix (element-type 'character) buffer-size)
+    (copy-stream-to-stream
+     input-stream output-stream
+     :linewise linewise :prefix prefix :element-type element-type :buffer-size buffer-size))
 
-  (defun unreify-deferred-warnings (reified-deferred-warnings)
-    "given a S-expression created by REIFY-DEFERRED-WARNINGS, reinstantiate the corresponding
-deferred warnings as to be handled at the end of the current WITH-COMPILATION-UNIT.
-Handle any warning that has been resolved already,
-such as an undefined function that has been defined since.
-One of three functions required for deferred-warnings support in ASDF."
-    (declare (ignorable reified-deferred-warnings))
-    #+allegro
-    (destructuring-bind (&key functions-defined functions-called)
-        reified-deferred-warnings
-      (setf excl::.functions-defined.
-            (append functions-defined excl::.functions-defined.)
-            excl::.functions-called.
-            (append functions-called excl::.functions-called.)))
-    #+clozure
-    (let ((dw (or ccl::*outstanding-deferred-warnings*
-                  (setf ccl::*outstanding-deferred-warnings* (ccl::%defer-warnings t)))))
-      (appendf (ccl::deferred-warnings.warnings dw)
-               (mapcar 'unreify-deferred-warning reified-deferred-warnings)))
-    #+(or cmucl scl)
-    (dolist (item reified-deferred-warnings)
-      ;; Each item is (symbol . adjustment) where the adjustment depends on the symbol.
-      ;; For *undefined-warnings*, the adjustment is a list of initargs.
-      ;; For everything else, it's an integer.
-      (destructuring-bind (symbol . adjustment) item
-        (case symbol
-          ((c::*undefined-warnings*)
-           (setf c::*undefined-warnings*
-                 (nconc (mapcan
-                         #'(lambda (stuff)
-                             (destructuring-bind (kind name count . rest) stuff
-                               (unless (case kind (:function (fboundp name)))
-                                 (list
-                                  (c::make-undefined-warning
-                                   :name name
-                                   :kind kind
-                                   :count count
-                                   :warnings
-                                   (mapcar #'(lambda (x)
-                                               (apply #'c::make-compiler-error-context x))
-                                           rest))))))
-                         adjustment)
-                        c::*undefined-warnings*)))
-          (otherwise
-           (set symbol (+ (symbol-value symbol) adjustment))))))
-    #+sbcl
-    (dolist (item reified-deferred-warnings)
-      ;; Each item is (symbol . adjustment) where the adjustment depends on the symbol.
-      ;; For *undefined-warnings*, the adjustment is a list of initargs.
-      ;; For everything else, it's an integer.
-      (destructuring-bind (symbol . adjustment) item
-        (case symbol
-          ((sb-c::*undefined-warnings*)
-           (setf sb-c::*undefined-warnings*
-                 (nconc (mapcan
-                         #'(lambda (stuff)
-                             (destructuring-bind (kind name count . rest) stuff
-                               (unless (case kind (:function (fboundp name)))
-                                 (list
-                                  (sb-c::make-undefined-warning
-                                   :name name
-                                   :kind kind
-                                   :count count
-                                   :warnings
-                                   (mapcar #'(lambda (x)
-                                               (apply #'sb-c::make-compiler-error-context x))
-                                           rest))))))
-                         adjustment)
-                        sb-c::*undefined-warnings*)))
-          (otherwise
-           (set symbol (+ (symbol-value symbol) adjustment)))))))
+  (defmethod vomit-output-stream ((x string) stream &key fresh-line terpri)
+    (princ x stream)
+    (when fresh-line (fresh-line stream))
+    (when terpri (terpri stream))
+    (values))
 
-  (defun reset-deferred-warnings ()
-    "Reset the set of deferred warnings to be handled at the end of the current WITH-COMPILATION-UNIT.
-One of three functions required for deferred-warnings support in ASDF."
-    #+allegro
-    (setf excl::.functions-defined. nil
-          excl::.functions-called. nil)
-    #+clozure
-    (if-let (dw ccl::*outstanding-deferred-warnings*)
-      (let ((mdw (ccl::ensure-merged-deferred-warnings dw)))
-        (setf (ccl::deferred-warnings.warnings mdw) nil)))
-    #+(or cmucl scl)
-    (when lisp::*in-compilation-unit*
-      (setf c::*undefined-warnings* nil
-            c::*compiler-error-count* 0
-            c::*compiler-warning-count* 0
-            c::*compiler-note-count* 0))
-    #+sbcl
-    (when sb-c::*in-compilation-unit*
-      (setf sb-c::*undefined-warnings* nil
-            sb-c::*aborted-compilation-unit-count* 0
-            sb-c::*compiler-error-count* 0
-            sb-c::*compiler-warning-count* 0
-            sb-c::*compiler-style-warning-count* 0
-            sb-c::*compiler-note-count* 0)))
+  (defmethod vomit-output-stream ((x (eql t)) stream &rest keys &key &allow-other-keys)
+    (apply 'vomit-output-stream *standard-input* stream keys))
 
-  (defun save-deferred-warnings (warnings-file)
-    "Save forward reference conditions so they may be issued at a latter time,
-possibly in a different process."
-    (with-open-file (s warnings-file :direction :output :if-exists :supersede
-                       :element-type *default-stream-element-type*
-                       :external-format *utf-8-external-format*)
-      (with-safe-io-syntax ()
-        (write (reify-deferred-warnings) :stream s :pretty t :readably t)
-        (terpri s))))
+  (defmethod vomit-output-stream ((x null) (stream t) &key)
+    (values))
 
-  (defun warnings-file-type (&optional implementation-type)
-    "The pathname type for warnings files on given IMPLEMENTATION-TYPE,
-where NIL designates the current one"
-    (case (or implementation-type *implementation-type*)
-      ((:acl :allegro) "allegro-warnings")
-      ;;((:clisp) "clisp-warnings")
-      ((:cmu :cmucl) "cmucl-warnings")
-      ((:sbcl) "sbcl-warnings")
-      ((:clozure :ccl) "ccl-warnings")
-      ((:scl) "scl-warnings")))
+  (defmethod vomit-output-stream ((pathname pathname) input
+                                 &key
+                                   (element-type *default-stream-element-type*)
+                                   (external-format *utf-8-external-format*)
+                                   (if-exists :rename-and-delete)
+                                   (if-does-not-exist :create)
+                                   buffer-size
+                                   linewise)
+    (with-output-file (output pathname
+                              :element-type element-type
+                              :external-format external-format
+                              :if-exists if-exists
+                              :if-does-not-exist if-does-not-exist)
+      (copy-stream-to-stream
+       input output
+       :element-type element-type :buffer-size buffer-size :linewise linewise)))
 
-  (defvar *warnings-file-type* nil
-    "Pathname type for warnings files, or NIL if disabled")
+  (defmethod vomit-output-stream (x stream
+                                 &key linewise prefix (element-type 'character) buffer-size)
+    (declare (ignorable stream linewise prefix element-type buffer-size))
+    (cond
+      #+genera
+      ((functionp x) (funcall x stream))
+      #+genera
+      ((input-stream-p x)
+       (copy-stream-to-stream
+        x stream
+        :linewise linewise :prefix prefix :element-type element-type :buffer-size buffer-size))
+      (t
+       (error "Invalid ~S source ~S" 'vomit-output-stream x)))))
 
-  (defun enable-deferred-warnings-check ()
-    "Enable the saving of deferred warnings"
-    (setf *warnings-file-type* (warnings-file-type)))
 
-  (defun disable-deferred-warnings-check ()
-    "Disable the saving of deferred warnings"
-    (setf *warnings-file-type* nil))
+;;;; Run-program: synchronously run a program in a subprocess, handling input, output and error-output.
+(with-upgradability ()
+  (define-condition subprocess-error (error)
+    ((code :initform nil :initarg :code :reader subprocess-error-code)
+     (command :initform nil :initarg :command :reader subprocess-error-command)
+     (process :initform nil :initarg :process :reader subprocess-error-process))
+    (:report (lambda (condition stream)
+               (format stream "Subprocess ~@[~S~% ~]~@[with command ~S~% ~]exited with error~@[ code ~D~]"
+                       (subprocess-error-process condition)
+                       (subprocess-error-command condition)
+                       (subprocess-error-code condition)))))
 
-  (defun warnings-file-p (file &optional implementation-type)
-    "Is FILE a saved warnings file for the given IMPLEMENTATION-TYPE?
-If that given type is NIL, use the currently configured *WARNINGS-FILE-TYPE* instead."
-    (if-let (type (if implementation-type
-                      (warnings-file-type implementation-type)
-                      *warnings-file-type*))
-      (equal (pathname-type file) type)))
+  (defun %check-result (exit-code &key command process ignore-error-status)
+    (unless ignore-error-status
+      (unless (eql exit-code 0)
+        (cerror "IGNORE-ERROR-STATUS"
+                'subprocess-error :command command :code exit-code :process process)))
+    exit-code)
 
-  (defun check-deferred-warnings (files &optional context-format context-arguments)
-    "Given a list of FILES containing deferred warnings saved by CALL-WITH-SAVED-DEFERRED-WARNINGS,
-re-intern and raise any warnings that are still meaningful."
-    (let ((file-errors nil)
-          (failure-p nil)
-          (warnings-p nil))
-      (handler-bind
-          ((warning #'(lambda (c)
-                        (setf warnings-p t)
-                        (unless (typep c 'style-warning)
-                          (setf failure-p t)))))
-        (with-compilation-unit (:override t)
-          (reset-deferred-warnings)
-          (dolist (file files)
-            (unreify-deferred-warnings
-             (handler-case (safe-read-file-form file)
-               (error (c)
-                 ;;(delete-file-if-exists file) ;; deleting forces rebuild but prevents debugging
-                 (push c file-errors)
-                 nil))))))
-      (dolist (error file-errors) (error error))
-      (check-lisp-compile-warnings
-       (or failure-p warnings-p) failure-p context-format context-arguments)))
+  (defun %active-io-specifier-p (specifier)
+    "Determines whether a run-program I/O specifier requires Lisp-side processing
+via SLURP-INPUT-STREAM or VOMIT-OUTPUT-STREAM (return T),
+or whether it's already taken care of by the implementation's underlying run-program."
+    (not (typep specifier '(or null string pathname (member :interactive :output)
+                            #+(or cmucl (and sbcl os-unix) scl) (or stream (eql t))
+                            #+lispworks file-stream))))
 
-  #|
-  Mini-guide to adding support for deferred warnings on an implementation.
+  (defun %run-program (command &rest keys &key &allow-other-keys)
+    "DEPRECATED. Use LAUNCH-PROGRAM instead."
+    (apply 'launch-program command keys))
 
-  First, look at what such a warning looks like:
+  (defun %call-with-program-io (gf tval stream-easy-p fun direction spec activep returner
+                                &key
+                                  (element-type #-clozure *default-stream-element-type* #+clozure 'character)
+                                  (external-format *utf-8-external-format*) &allow-other-keys)
+    ;; handle redirection for run-program and system
+    ;; SPEC is the specification for the subprocess's input or output or error-output
+    ;; TVAL is the value used if the spec is T
+    ;; GF is the generic function to call to handle arbitrary values of SPEC
+    ;; STREAM-EASY-P is T if we're going to use a RUN-PROGRAM that copies streams in the background
+    ;; (it's only meaningful on CMUCL, SBCL, SCL that actually do it)
+    ;; DIRECTION is :INPUT, :OUTPUT or :ERROR-OUTPUT for the direction of this io argument
+    ;; FUN is a function of the new reduced spec and an activity function to call with a stream
+    ;; when the subprocess is active and communicating through that stream.
+    ;; ACTIVEP is a boolean true if we will get to run code while the process is running
+    ;; ELEMENT-TYPE and EXTERNAL-FORMAT control what kind of temporary file we may open.
+    ;; RETURNER is a function called with the value of the activity.
+    ;; --- TODO (fare@tunes.org): handle if-output-exists and such when doing it the hard way.
+    (declare (ignorable stream-easy-p))
+    (let* ((actual-spec (if (eq spec t) tval spec))
+           (activity-spec (if (eq actual-spec :output)
+                              (ecase direction
+                                ((:input :output)
+                                 (error "~S not allowed as a ~S ~S spec"
+                                        :output 'run-program direction))
+                                ((:error-output)
+                                 nil))
+                              actual-spec)))
+      (labels ((activity (stream)
+                 (call-function returner (call-stream-processor gf activity-spec stream)))
+               (easy-case ()
+                 (funcall fun actual-spec nil))
+               (hard-case ()
+                 (if activep
+                     (funcall fun :stream #'activity)
+                     (with-temporary-file (:pathname tmp)
+                       (ecase direction
+                         (:input
+                          (with-output-file (s tmp :if-exists :overwrite
+                                               :external-format external-format
+                                               :element-type element-type)
+                            (activity s))
+                          (funcall fun tmp nil))
+                         ((:output :error-output)
+                          (multiple-value-prog1 (funcall fun tmp nil)
+                            (with-input-file (s tmp
+                                               :external-format external-format
+                                               :element-type element-type)
+                              (activity s)))))))))
+        (typecase activity-spec
+          ((or null string pathname (eql :interactive))
+           (easy-case))
+          #+(or cmucl (and sbcl os-unix) scl) ;; streams are only easy on implementations that try very hard
+          (stream
+           (if stream-easy-p (easy-case) (hard-case)))
+          (t
+           (hard-case))))))
 
-  (describe
-  (handler-case
-  (and (eval '(lambda () (some-undefined-function))) nil)
-  (t (c) c)))
+  (defmacro place-setter (place)
+    (when place
+      (let ((value (gensym)))
+        `#'(lambda (,value) (setf ,place ,value)))))
 
-  Then you can grep for the condition type in your compiler sources
-  and see how to catch those that have been deferred,
-  and/or read, clear and restore the deferred list.
+  (defmacro with-program-input (((reduced-input-var
+                                  &optional (input-activity-var (gensym) iavp))
+                                 input-form &key setf stream-easy-p active keys) &body body)
+    `(apply '%call-with-program-io 'vomit-output-stream *standard-input* ,stream-easy-p
+            #'(lambda (,reduced-input-var ,input-activity-var)
+                ,@(unless iavp `((declare (ignore ,input-activity-var))))
+                ,@body)
+            :input ,input-form ,active (place-setter ,setf) ,keys))
 
-  Also look at
-  (macroexpand-1 '(with-compilation-unit () foo))
-  |#
+  (defmacro with-program-output (((reduced-output-var
+                                  &optional (output-activity-var (gensym) oavp))
+                                  output-form &key setf stream-easy-p active keys) &body body)
+    `(apply '%call-with-program-io 'slurp-input-stream *standard-output* ,stream-easy-p
+            #'(lambda (,reduced-output-var ,output-activity-var)
+                ,@(unless oavp `((declare (ignore ,output-activity-var))))
+                ,@body)
+            :output ,output-form ,active (place-setter ,setf) ,keys))
 
-  (defun call-with-saved-deferred-warnings (thunk warnings-file &key source-namestring)
-    "If WARNINGS-FILE is not nil, record the deferred-warnings around a call to THUNK
-and save those warnings to the given file for latter use,
-possibly in a different process. Otherwise just call THUNK."
-    (declare (ignorable source-namestring))
-    (if warnings-file
-        (with-compilation-unit (:override t #+sbcl :source-namestring #+sbcl source-namestring)
-          (unwind-protect
-               (let (#+sbcl (sb-c::*undefined-warnings* nil))
-                 (multiple-value-prog1
-                     (funcall thunk)
-                   (save-deferred-warnings warnings-file)))
-            (reset-deferred-warnings)))
-        (funcall thunk)))
+  (defmacro with-program-error-output (((reduced-error-output-var
+                                         &optional (error-output-activity-var (gensym) eoavp))
+                                        error-output-form &key setf stream-easy-p active keys)
+                                       &body body)
+    `(apply '%call-with-program-io 'slurp-input-stream *error-output* ,stream-easy-p
+            #'(lambda (,reduced-error-output-var ,error-output-activity-var)
+                ,@(unless eoavp `((declare (ignore ,error-output-activity-var))))
+                ,@body)
+            :error-output ,error-output-form ,active (place-setter ,setf) ,keys))
+
+  (defun %use-launch-program (command &rest keys
+                           &key input output error-output ignore-error-status &allow-other-keys)
+    ;; helper for RUN-PROGRAM when using LAUNCH-PROGRAM
+    #+(or cormanlisp gcl (and lispworks os-windows) mcl xcl)
+    (progn
+      command keys input output error-output ignore-error-status ;; ignore
+      (not-implemented-error '%use-launch-program))
+    (when (member :stream (list input output error-output))
+      (parameter-error "~S: ~S is not allowed as synchronous I/O redirection argument"
+                       'run-program :stream))
+    (let* ((active-input-p (%active-io-specifier-p input))
+           (active-output-p (%active-io-specifier-p output))
+           (active-error-output-p (%active-io-specifier-p error-output))
+           (activity
+             (cond
+               (active-output-p :output)
+               (active-input-p :input)
+               (active-error-output-p :error-output)
+               (t nil)))
+           output-result error-output-result exit-code process-info)
+      (with-program-output ((reduced-output output-activity)
+                            output :keys keys :setf output-result
+                            :stream-easy-p t :active (eq activity :output))
+        (with-program-error-output ((reduced-error-output error-output-activity)
+                                    error-output :keys keys :setf error-output-result
+                                    :stream-easy-p t :active (eq activity :error-output))
+          (with-program-input ((reduced-input input-activity)
+                               input :keys keys
+                               :stream-easy-p t :active (eq activity :input))
+            (setf process-info
+                  (apply 'launch-program command
+                         :input reduced-input :output reduced-output
+                         :error-output (if (eq error-output :output) :output reduced-error-output)
+                         keys))
+            (labels ((get-stream (stream-name &optional fallbackp)
+                       (or (slot-value process-info stream-name)
+                           (when fallbackp
+                             (slot-value process-info 'bidir-stream))))
+                     (run-activity (activity stream-name &optional fallbackp)
+                       (if-let (stream (get-stream stream-name fallbackp))
+                         (funcall activity stream)
+                         (error 'subprocess-error
+                                :code `(:missing ,stream-name)
+                                :command command :process process-info))))
+              (unwind-protect
+                   (ecase activity
+                     ((nil))
+                     (:input (run-activity input-activity 'input-stream t))
+                     (:output (run-activity output-activity 'output-stream t))
+                     (:error-output (run-activity error-output-activity 'error-output-stream)))
+                (close-streams process-info)
+                (setf exit-code (wait-process process-info)))))))
+      (%check-result exit-code
+                     :command command :process process-info
+                     :ignore-error-status ignore-error-status)
+      (values output-result error-output-result exit-code)))
+
+  (defun %normalize-system-command (command) ;; helper for %USE-SYSTEM
+    (etypecase command
+      (string
+       (os-cond
+        ((os-windows-p)
+         #+(or allegro clisp ecl)
+         (strcat "cmd" " /c " command)
+         #-(or allegro clisp ecl) command)
+        (t command)))
+      (list (escape-shell-command
+             (os-cond
+              ((os-unix-p) (cons "exec" command))
+              ((os-windows-p)
+               #+(or allegro clisp ecl sbcl)
+               (list* "cmd" "/c" command)
+               #-(or allegro clisp ecl sbcl) command)
+              (t command))))))
+
+  (defun %redirected-system-command (command in out err directory) ;; helper for %USE-SYSTEM
+    (flet ((redirect (spec operator)
+             (let ((pathname
+                     (typecase spec
+                       (null (null-device-pathname))
+                       (string (parse-native-namestring spec))
+                       (pathname spec)
+                       ((eql :output)
+                        (unless (equal operator " 2>>")
+                          (parameter-error "~S: only the ~S argument can be ~S"
+                                           'run-program :error-output :output))
+                        (return-from redirect '(" 2>&1"))))))
+               (when pathname
+                 (list operator " "
+                       (escape-shell-token (native-namestring pathname)))))))
+      (let* ((redirections (append (redirect in " <") (redirect out " >>") (redirect err " 2>>")))
+             (normalized (%normalize-system-command command))
+             (directory (or directory #+(or abcl xcl) (getcwd)))
+             (chdir (when directory
+                      (let ((dir-arg (escape-shell-token (native-namestring directory))))
+                        (os-cond
+                         ((os-unix-p) `("cd " ,dir-arg " ; "))
+                         ((os-windows-p) `("cd /d " ,dir-arg " & ")))))))
+        (reduce/strcat
+         (os-cond
+          ((os-unix-p) `(,@(when redirections `("exec " ,@redirections " ; ")) ,@chdir ,normalized))
+          ((os-windows-p) `(,@chdir ,@redirections " " ,normalized)))))))
 
-  (defmacro with-saved-deferred-warnings ((warnings-file &key source-namestring) &body body)
-    "Trivial syntax for CALL-WITH-SAVED-DEFERRED-WARNINGS"
-    `(call-with-saved-deferred-warnings
-      #'(lambda () ,@body) ,warnings-file :source-namestring ,source-namestring)))
+  (defun %system (command &rest keys &key directory
+                                       input (if-input-does-not-exist :error)
+                                       output (if-output-exists :supersede)
+                                       error-output (if-error-output-exists :supersede)
+                                       &allow-other-keys)
+    "A portable abstraction of a low-level call to libc's system()."
+    (declare (ignorable keys directory input if-input-does-not-exist output
+                        if-output-exists error-output if-error-output-exists))
+    #+(or abcl allegro clozure cmucl ecl (and lispworks os-unix) mkcl sbcl scl)
+    (let (#+(or abcl ecl mkcl)
+            (version (parse-version
+                      #-abcl
+                      (lisp-implementation-version)
+                      #+abcl
+                      (second (split-string (implementation-identifier) :separator '(#\-))))))
+      (nest
+       #+abcl (unless (lexicographic< '< version '(1 4 0)))
+       #+ecl (unless (lexicographic<= '< version '(16 0 0)))
+       #+mkcl (unless (lexicographic<= '< version '(1 1 9)))
+       (return-from %system
+         (wait-process
+          (apply 'launch-program (%normalize-system-command command) keys)))))
+    #+(or abcl clasp clisp cormanlisp ecl gcl genera (and lispworks os-windows) mkcl xcl)
+    (let ((%command (%redirected-system-command command input output error-output directory)))
+      ;; see comments for these functions
+      (%handle-if-does-not-exist input if-input-does-not-exist)
+      (%handle-if-exists output if-output-exists)
+      (%handle-if-exists error-output if-error-output-exists)
+      #+abcl (ext:run-shell-command %command)
+      #+(or clasp ecl) (let ((*standard-input* *stdin*)
+                             (*standard-output* *stdout*)
+                             (*error-output* *stderr*))
+                         (ext:system %command))
+      #+clisp
+      (let ((raw-exit-code
+             (or
+              #.`(#+os-windows ,@'(ext:run-shell-command %command)
+                  #+os-unix ,@'(ext:run-program "/bin/sh" :arguments `("-c" ,%command))
+                  :wait t :input :terminal :output :terminal)
+              0)))
+        (if (minusp raw-exit-code)
+            (- 128 raw-exit-code)
+            raw-exit-code))
+      #+cormanlisp (win32:system %command)
+      #+gcl (system:system %command)
+      #+genera (not-implemented-error '%system)
+      #+(and lispworks os-windows)
+      (system:call-system %command :current-directory directory :wait t)
+      #+mcl (ccl::with-cstrs ((%%command %command)) (_system %%command))
+      #+mkcl (mkcl:system %command)
+      #+xcl (system:%run-shell-command %command)))
 
+  (defun %use-system (command &rest keys
+                      &key input output error-output ignore-error-status &allow-other-keys)
+    ;; helper for RUN-PROGRAM when using %system
+    (let (output-result error-output-result exit-code)
+      (with-program-output ((reduced-output)
+                            output :keys keys :setf output-result)
+        (with-program-error-output ((reduced-error-output)
+                                    error-output :keys keys :setf error-output-result)
+          (with-program-input ((reduced-input) input :keys keys)
+            (setf exit-code (apply '%system command
+                                   :input reduced-input :output reduced-output
+                                   :error-output reduced-error-output keys)))))
+      (%check-result exit-code
+                     :command command
+                     :ignore-error-status ignore-error-status)
+      (values output-result error-output-result exit-code)))
 
-;;; from ASDF
-(with-upgradability ()
-  (defun current-lisp-file-pathname ()
-    "Portably return the PATHNAME of the current Lisp source file being compiled or loaded"
-    (or *compile-file-pathname* *load-pathname*))
+  (defun run-program (command &rest keys
+                       &key ignore-error-status (force-shell nil force-shell-suppliedp)
+                         input (if-input-does-not-exist :error)
+                         output (if-output-exists :supersede)
+                         error-output (if-error-output-exists :supersede)
+                         (element-type #-clozure *default-stream-element-type* #+clozure 'character)
+                         (external-format *utf-8-external-format*)
+                       &allow-other-keys)
+    "Run program specified by COMMAND,
+either a list of strings specifying a program and list of arguments,
+or a string specifying a shell command (/bin/sh on Unix, CMD.EXE on Windows);
+_synchronously_ process its output as specified and return the processing results
+when the program and its output processing are complete.
 
-  (defun load-pathname ()
-    "Portably return the LOAD-PATHNAME of the current source file or fasl"
-    *load-pathname*) ;; magic no longer needed for GCL.
+Always call a shell (rather than directly execute the command when possible)
+if FORCE-SHELL is specified.  Similarly, never call a shell if FORCE-SHELL is
+specified to be NIL.
 
-  (defun lispize-pathname (input-file)
-    "From a INPUT-FILE pathname, return a corresponding .lisp source pathname"
-    (make-pathname :type "lisp" :defaults input-file))
+Signal a continuable SUBPROCESS-ERROR if the process wasn't successful (exit-code 0),
+unless IGNORE-ERROR-STATUS is specified.
 
-  (defun compile-file-type (&rest keys)
-    "pathname TYPE for lisp FASt Loading files"
-    (declare (ignorable keys))
-    #-(or clasp ecl mkcl) (load-time-value (pathname-type (compile-file-pathname "foo.lisp")))
-    #+(or clasp ecl mkcl) (pathname-type (apply 'compile-file-pathname "foo" keys)))
+If OUTPUT is a pathname, a string designating a pathname, or NIL (the default)
+designating the null device, the file at that path is used as output.
+If it's :INTERACTIVE, output is inherited from the current process;
+beware that this may be different from your *STANDARD-OUTPUT*,
+and under SLIME will be on your *inferior-lisp* buffer.
+If it's T, output goes to your current *STANDARD-OUTPUT* stream.
+Otherwise, OUTPUT should be a value that is a suitable first argument to
+SLURP-INPUT-STREAM (qv.), or a list of such a value and keyword arguments.
+In this case, RUN-PROGRAM will create a temporary stream for the program output;
+the program output, in that stream, will be processed by a call to SLURP-INPUT-STREAM,
+using OUTPUT as the first argument (or the first element of OUTPUT, and the rest as keywords).
+The primary value resulting from that call (or NIL if no call was needed)
+will be the first value returned by RUN-PROGRAM.
+E.g., using :OUTPUT :STRING will have it return the entire output stream as a string.
+And using :OUTPUT '(:STRING :STRIPPED T) will have it return the same string
+stripped of any ending newline.
 
-  (defun call-around-hook (hook function)
-    "Call a HOOK around the execution of FUNCTION"
-    (call-function (or hook 'funcall) function))
+IF-OUTPUT-EXISTS, which is only meaningful if OUTPUT is a string or a
+pathname, can take the values :ERROR, :APPEND, and :SUPERSEDE (the
+default). The meaning of these values and their effect on the case
+where OUTPUT does not exist, is analogous to the IF-EXISTS parameter
+to OPEN with :DIRECTION :OUTPUT.
 
-  (defun compile-file-pathname* (input-file &rest keys &key output-file &allow-other-keys)
-    "Variant of COMPILE-FILE-PATHNAME that works well with COMPILE-FILE*"
-    (let* ((keys
-             (remove-plist-keys `(#+(or (and allegro (not (version>= 8 2)))) :external-format
-                                    ,@(unless output-file '(:output-file))) keys)))
-      (if (absolute-pathname-p output-file)
-          ;; what cfp should be doing, w/ mp* instead of mp
-          (let* ((type (pathname-type (apply 'compile-file-type keys)))
-                 (defaults (make-pathname
-                            :type type :defaults (merge-pathnames* input-file))))
-            (merge-pathnames* output-file defaults))
-          (funcall *output-translation-function*
-                   (apply 'compile-file-pathname input-file keys)))))
+ERROR-OUTPUT is similar to OUTPUT, except that the resulting value is returned
+as the second value of RUN-PROGRAM. T designates the *ERROR-OUTPUT*.
+Also :OUTPUT means redirecting the error output to the output stream,
+in which case NIL is returned.
 
-  (defvar *compile-check* nil
-    "A hook for user-defined compile-time invariants")
+IF-ERROR-OUTPUT-EXISTS is similar to IF-OUTPUT-EXIST, except that it
+affects ERROR-OUTPUT rather than OUTPUT.
 
-  (defun* (compile-file*) (input-file &rest keys
-                                      &key (compile-check *compile-check*) output-file warnings-file
-                                      #+clisp lib-file #+(or clasp ecl mkcl) object-file #+sbcl emit-cfasl
-                                      &allow-other-keys)
-    "This function provides a portable wrapper around COMPILE-FILE.
-It ensures that the OUTPUT-FILE value is only returned and
-the file only actually created if the compilation was successful,
-even though your implementation may not do that. It also checks an optional
-user-provided consistency function COMPILE-CHECK to determine success;
-it will call this function if not NIL at the end of the compilation
-with the arguments sent to COMPILE-FILE*, except with :OUTPUT-FILE TMP-FILE
-where TMP-FILE is the name of a temporary output-file.
-It also checks two flags (with legacy british spelling from ASDF1),
-*COMPILE-FILE-FAILURE-BEHAVIOUR* and *COMPILE-FILE-WARNINGS-BEHAVIOUR*
-with appropriate implementation-dependent defaults,
-and if a failure (respectively warnings) are reported by COMPILE-FILE,
-it will consider that an error unless the respective behaviour flag
-is one of :SUCCESS :WARN :IGNORE.
-If WARNINGS-FILE is defined, deferred warnings are saved to that file.
-On ECL or MKCL, it creates both the linkable object and loadable fasl files.
-On implementations that erroneously do not recognize standard keyword arguments,
-it will filter them appropriately."
-    #+(or clasp ecl)
-    (when (and object-file (equal (compile-file-type) (pathname object-file)))
-      (format t "Whoa, some funky ASDF upgrade switched ~S calling convention for ~S and ~S~%"
-              'compile-file* output-file object-file)
-      (rotatef output-file object-file))
-    (let* ((keywords (remove-plist-keys
-                      `(:output-file :compile-check :warnings-file
-                                     #+clisp :lib-file #+(or clasp ecl mkcl) :object-file) keys))
-           (output-file
-             (or output-file
-                 (apply 'compile-file-pathname* input-file :output-file output-file keywords)))
-           #+(or clasp ecl)
-           (object-file
-             (unless (use-ecl-byte-compiler-p)
-               (or object-file
-                   #+ecl (compile-file-pathname output-file :type :object)
-                   #+clasp (compile-file-pathname output-file :output-type :object))))
-           #+mkcl
-           (object-file
-             (or object-file
-                 (compile-file-pathname output-file :fasl-p nil)))
-           (tmp-file (tmpize-pathname output-file))
-           #+sbcl
-           (cfasl-file (etypecase emit-cfasl
-                         (null nil)
-                         ((eql t) (make-pathname :type "cfasl" :defaults output-file))
-                         (string (parse-namestring emit-cfasl))
-                         (pathname emit-cfasl)))
-           #+sbcl
-           (tmp-cfasl (when cfasl-file (make-pathname :type "cfasl" :defaults tmp-file)))
-           #+clisp
-           (tmp-lib (make-pathname :type "lib" :defaults tmp-file)))
-      (multiple-value-bind (output-truename warnings-p failure-p)
-          (with-enough-pathname (input-file :defaults *base-build-directory*)
-            (with-saved-deferred-warnings (warnings-file :source-namestring (namestring input-file))
-              (with-muffled-compiler-conditions ()
-                (or #-(or clasp ecl mkcl)
-                    (apply 'compile-file input-file :output-file tmp-file
-                           #+sbcl (if emit-cfasl (list* :emit-cfasl tmp-cfasl keywords) keywords)
-                           #-sbcl keywords)
-                    #+ecl (apply 'compile-file input-file :output-file
-                                (if object-file
-                                    (list* object-file :system-p t keywords)
-                                    (list* tmp-file keywords)))
-                    #+clasp (apply 'compile-file input-file :output-file
-                                  (if object-file
-                                      (list* object-file :output-type :object #|:system-p t|# keywords)
-                                      (list* tmp-file keywords)))
-                    #+mkcl (apply 'compile-file input-file
-                                  :output-file object-file :fasl-p nil keywords)))))
-        (cond
-          ((and output-truename
-                (flet ((check-flag (flag behaviour)
-                         (or (not flag) (member behaviour '(:success :warn :ignore)))))
-                  (and (check-flag failure-p *compile-file-failure-behaviour*)
-                       (check-flag warnings-p *compile-file-warnings-behaviour*)))
-                (progn
-                  #+(or clasp ecl mkcl)
-                  (when (and #+(or clasp ecl) object-file)
-                    (setf output-truename
-                          (compiler::build-fasl tmp-file
-                           #+(or clasp ecl) :lisp-files #+mkcl :lisp-object-files (list object-file))))
-                  (or (not compile-check)
-                      (apply compile-check input-file
-                             :output-file #-(or clasp ecl) output-file #+(or clasp ecl) tmp-file
-                             keywords))))
-           (delete-file-if-exists output-file)
-           (when output-truename
-             #+clasp (when output-truename (rename-file-overwriting-target tmp-file output-truename))
-             #+clisp (when lib-file (rename-file-overwriting-target tmp-lib lib-file))
-             #+sbcl (when cfasl-file (rename-file-overwriting-target tmp-cfasl cfasl-file))
-             (rename-file-overwriting-target output-truename output-file)
-             (setf output-truename (truename output-file)))
-           #+clasp (delete-file-if-exists tmp-file)
-           #+clisp (delete-file-if-exists tmp-lib))
-          (t ;; error or failed check
-           (delete-file-if-exists output-truename)
-           #+clisp (delete-file-if-exists tmp-lib)
-           #+sbcl (delete-file-if-exists tmp-cfasl)
-           (setf output-truename nil)))
-        (values output-truename warnings-p failure-p))))
+INPUT is similar to OUTPUT, except that VOMIT-OUTPUT-STREAM is used,
+no value is returned, and T designates the *STANDARD-INPUT*.
 
-  (defun load* (x &rest keys &key &allow-other-keys)
-    "Portable wrapper around LOAD that properly handles loading from a stream."
-    (with-muffled-loader-conditions ()
-      (etypecase x
-        ((or pathname string #-(or allegro clozure genera) stream #+clozure file-stream)
-         (apply 'load x keys))
-        ;; Genera can't load from a string-input-stream
-        ;; ClozureCL 1.6 can only load from file input stream
-        ;; Allegro 5, I don't remember but it must have been broken when I tested.
-        #+(or allegro clozure genera)
-        (stream ;; make do this way
-         (let ((*package* *package*)
-               (*readtable* *readtable*)
-               (*load-pathname* nil)
-               (*load-truename* nil))
-           (eval-input x))))))
+IF-INPUT-DOES-NOT-EXIST, which is only meaningful if INPUT is a string
+or a pathname, can take the values :CREATE and :ERROR (the
+default). The meaning of these values is analogous to the
+IF-DOES-NOT-EXIST parameter to OPEN with :DIRECTION :INPUT.
 
-  (defun load-from-string (string)
-    "Portably read and evaluate forms from a STRING."
-    (with-input-from-string (s string) (load* s))))
+ELEMENT-TYPE and EXTERNAL-FORMAT are passed on
+to your Lisp implementation, when applicable, for creation of the output stream.
+
+One and only one of the stream slurping or vomiting may or may not happen
+in parallel in parallel with the subprocess,
+depending on options and implementation,
+and with priority being given to output processing.
+Other streams are completely produced or consumed
+before or after the subprocess is spawned, using temporary files.
+
+RUN-PROGRAM returns 3 values:
+0- the result of the OUTPUT slurping if any, or NIL
+1- the result of the ERROR-OUTPUT slurping if any, or NIL
+2- either 0 if the subprocess exited with success status,
+or an indication of failure via the EXIT-CODE of the process"
+    (declare (ignorable input output error-output if-input-does-not-exist if-output-exists
+                        if-error-output-exists element-type external-format ignore-error-status))
+    #-(or abcl allegro clasp clisp clozure cmucl cormanlisp ecl gcl lispworks mcl mkcl sbcl scl xcl)
+    (not-implemented-error 'run-program)
+    (apply (if (or force-shell
+                   ;; Per doc string, set FORCE-SHELL to T if we get command as a string.
+                   ;; But don't override user's specified preference. [2015/06/29:rpg]
+                   (and (stringp command)
+                        (or (not force-shell-suppliedp)
+                            #-(or allegro clisp clozure sbcl) (os-cond ((os-windows-p) t))))
+                   #+(or clasp clisp cormanlisp gcl (and lispworks os-windows) mcl xcl) t
+                   ;; A race condition in ECL <= 16.0.0 prevents using ext:run-program
+                   #+ecl #.(if-let (ver (parse-version (lisp-implementation-version)))
+                                   (lexicographic<= '< ver '(16 0 0)))
+                   #+(and lispworks os-unix) (%interactivep input output error-output))
+               '%use-system '%use-launch-program)
+           command keys)))
 
-;;; Links FASLs together
-(with-upgradability ()
-  (defun combine-fasls (inputs output)
-    "Combine a list of FASLs INPUTS into a single FASL OUTPUT"
-    #-(or abcl allegro clisp clozure cmu lispworks sbcl scl xcl)
-    (error "~A does not support ~S~%inputs ~S~%output  ~S"
-           (implementation-type) 'combine-fasls inputs output)
-    #+abcl (funcall 'sys::concatenate-fasls inputs output) ; requires ABCL 1.2.0
-    #+(or allegro clisp cmu sbcl scl xcl) (concatenate-files inputs output)
-    #+clozure (ccl:fasl-concatenate output inputs :if-exists :supersede)
-    #+lispworks
-    (let (fasls)
-      (unwind-protect
-           (progn
-             (loop :for i :in inputs
-                   :for n :from 1
-                   :for f = (add-pathname-suffix
-                             output (format nil "-FASL~D" n))
-                   :do (copy-file i f)
-                       (push f fasls))
-             (ignore-errors (lispworks:delete-system :fasls-to-concatenate))
-             (eval `(scm:defsystem :fasls-to-concatenate
-                      (:default-pathname ,(pathname-directory-pathname output))
-                      :members
-                      ,(loop :for f :in (reverse fasls)
-                             :collect `(,(namestring f) :load-only t))))
-             (scm:concatenate-system output :fasls-to-concatenate :force t))
-        (loop :for f :in fasls :do (ignore-errors (delete-file f)))
-        (ignore-errors (lispworks:delete-system :fasls-to-concatenate))))))
 ;;;; ---------------------------------------------------------------------------
 ;;;; Generic support for configuration files
 
@@ -6563,7 +7141,7 @@ directive.")
 this function tries to locate the Windows FOLDER for one of
 :LOCAL-APPDATA, :APPDATA or :COMMON-APPDATA.
      Returns NIL when the folder is not defined (e.g., not on Windows)."
-    (or #+(and lispworks mswindows) (sys:get-folder-path folder)
+    (or #+(and lispworks os-windows) (sys:get-folder-path folder)
         ;; read-windows-registry HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders\AppData
         (ecase folder
           (:local-appdata (or (getenv-absolute-directory "LOCALAPPDATA")
@@ -6698,46 +7276,48 @@ or just the first one (for direction :output or :io).
 objects. Side-effects for cached file location computation."
     (setf *user-cache* (xdg-cache-home "common-lisp" :implementation)))
   (register-image-restore-hook 'compute-user-cache))
-;;;; -------------------------------------------------------------------------
-;;; Hacks for backward-compatibility of the driver
+;;; -------------------------------------------------------------------------
+;;; Hacks for backward-compatibility with older versions of UIOP
 
 (uiop/package:define-package :uiop/backward-driver
-  (:use :uiop/common-lisp :uiop/package :uiop/utility
+  (:recycle :uiop/backward-driver :asdf/backward-driver :uiop)
+  (:use :uiop/common-lisp :uiop/package :uiop/utility :uiop/version
    :uiop/pathname :uiop/stream :uiop/os :uiop/image
    :uiop/run-program :uiop/lisp-build :uiop/configuration)
   (:export
    #:coerce-pathname
    #:user-configuration-directories #:system-configuration-directories
    #:in-first-directory #:in-user-configuration-directory #:in-system-configuration-directory
-   ))
+   #:version-compatible-p))
 (in-package :uiop/backward-driver)
 
-;;;; Backward compatibility with various pathname functions.
+(eval-when (:compile-toplevel :load-toplevel :execute)
+(with-deprecation ((version-deprecation *uiop-version* :style-warning "3.2.0" :warning "3.2.1"))
+  ;; Backward compatibility with ASDF 2.000 to 2.26
 
-(with-upgradability ()
+  ;; For backward-compatibility only, for people using internals
+  ;; Reported users in quicklisp 2015-11: hu.dwim.asdf (removed in next release)
+  ;; Will be removed after 2015-12.
   (defun coerce-pathname (name &key type defaults)
-    ;; For backward-compatibility only, for people using internals
-    ;; Reported users in quicklisp 2015-11: hu.dwim.asdf (removed in next release)
-    ;; Will be removed after 2015-12.
-    ;;(warn "Please don't use ASDF::COERCE-PATHNAME. Use ASDF/PATHNAME:PARSE-UNIX-NAMESTRING.")
+    "DEPRECATED. Please use UIOP:PARSE-UNIX-NAMESTRING instead."
     (parse-unix-namestring name :type type :defaults defaults))
 
   ;; Backward compatibility for ASDF 2.27 to 3.1.4
   (defun user-configuration-directories ()
     "Return the current user's list of user configuration directories
 for configuring common-lisp.
-    DEPRECATED. Use uiop:xdg-config-pathnames instead."
+DEPRECATED. Use UIOP:XDG-CONFIG-PATHNAMES instead."
     (xdg-config-pathnames "common-lisp"))
   (defun system-configuration-directories ()
     "Return the list of system configuration directories for common-lisp.
-    DEPRECATED. Use uiop:config-system-pathnames instead."
+DEPRECATED. Use UIOP:CONFIG-SYSTEM-PATHNAMES instead."
     (system-config-pathnames "common-lisp"))
   (defun in-first-directory (dirs x &key (direction :input))
     "Finds the first appropriate file named X in the list of DIRS for I/O
 in DIRECTION \(which may be :INPUT, :OUTPUT, :IO, or :PROBE).
-   If direction is :INPUT or :PROBE, will return the first extant file named
+If direction is :INPUT or :PROBE, will return the first extant file named
 X in one of the DIRS.
-   If direction is :OUTPUT or :IO, will simply return the file named X in the
+If direction is :OUTPUT or :IO, will simply return the file named X in the
 first element of DIRS that exists. DEPRECATED."
     (find-preferred-file
      (mapcar #'(lambda (dir) (subpathname (ensure-directory-pathname dir) x)) dirs)
@@ -6749,7 +7329,21 @@ DEPRECATED."
   (defun in-system-configuration-directory (x &key (direction :input))
     "Return the pathname for the file named X under the system configuration directory
 for common-lisp. DEPRECATED."
-    (find-preferred-file (system-config-pathnames "common-lisp" x) :direction direction)))
+    (find-preferred-file (system-config-pathnames "common-lisp" x) :direction direction))
+
+
+  ;; Backward compatibility with ASDF 1 to ASDF 2.32
+
+  (defun version-compatible-p (provided-version required-version)
+    "Is the provided version a compatible substitution for the required-version?
+If major versions differ, it's not compatible.
+If they are equal, then any later version is compatible,
+with later being determined by a lexicographical comparison of minor numbers.
+DEPRECATED."
+    (let ((x (parse-version provided-version nil))
+          (y (parse-version required-version nil)))
+      (and x y (= (car x) (car y)) (lexicographic<= '< (cdr y) (cdr x)))))))
+
 ;;;; ---------------------------------------------------------------------------
 ;;;; Re-export all the functionality in UIOP
 
@@ -6762,9 +7356,10 @@ for common-lisp. DEPRECATED."
    ;; that could cause potential conflicts for packages that would :use (cl uiop)
    ;; or :use (closer-common-lisp uiop), etc.
   (:use-reexport
-   :uiop/package :uiop/utility
+   :uiop/package :uiop/utility :uiop/version
    :uiop/os :uiop/pathname :uiop/filesystem :uiop/stream :uiop/image
-   :uiop/run-program :uiop/lisp-build :uiop/configuration :uiop/backward-driver))
+   :uiop/launch-program :uiop/run-program
+   :uiop/lisp-build :uiop/configuration :uiop/backward-driver))
 
 ;; Provide both lowercase and uppercase, to satisfy more people.
 (provide "uiop") (provide "UIOP")
@@ -6779,8 +7374,9 @@ for common-lisp. DEPRECATED."
    #:asdf-version #:*previous-asdf-versions* #:*asdf-version*
    #:asdf-message #:*verbose-out*
    #:upgrading-p #:when-upgrading #:upgrade-asdf #:defparameter*
-   #:*post-upgrade-cleanup-hook* #:*post-upgrade-restart-hook* #:cleanup-upgraded-asdf
+   #:*post-upgrade-cleanup-hook* #:cleanup-upgraded-asdf
    ;; There will be no symbol left behind!
+   #:with-asdf-deprecation
    #:intern*)
   (:import-from :uiop/package #:intern* #:find-symbol*))
 (in-package :asdf/upgrade)
@@ -6799,28 +7395,40 @@ You can compare this string with e.g.: (ASDF:VERSION-SATISFIES (ASDF:ASDF-VERSIO
               (string rev)
               (cons (format nil "~{~D~^.~}" rev))
               (null "1.0"))))))
-  ;; Important: define *p-a-v* /before/ *a-v* so that it initializes correctly.
+  ;; This (private) variable contains a list of versions of previously loaded variants of ASDF,
+  ;; from which ASDF was upgraded.
+  ;; Important: define *p-a-v* /before/ *a-v* so that they initialize correctly.
   (defvar *previous-asdf-versions*
     (let ((previous (asdf-version)))
       (when previous
-        ;; Punt on hard package upgrade: from ASDF1 or ASDF2
+        ;; Punt on upgrade from ASDF1 or ASDF2, by renaming (or deleting) the package.
         (when (version< previous "2.27") ;; 2.27 is the first to have the :asdf3 feature.
           (let ((away (format nil "~A-~A" :asdf previous)))
             (rename-package :asdf away)
             (when *load-verbose*
-              (format t "~&; Renamed old ~A package away to ~A~%" :asdf away)))))
-        (list previous)))
+              (format t "~&; Renamed old ~A package away to ~A~%" :asdf away))))
+        (list previous))))
+  ;; This public variable will be bound shortly to the currently loaded version of ASDF.
   (defvar *asdf-version* nil)
-  ;; We need to clear systems from versions yet older than the below:
-  (defparameter *oldest-forward-compatible-asdf-version* "2.33") ;; 2.32.13 renames a slot in component.
+  ;; We need to clear systems from versions older than the one in this (private) parameter.
+  ;; The latest incompatible defclass is 2.32.13 renaming a slot in component;
+  ;; the latest incompatible gf change is in 3.1.7.20 (see redefined-functions below).
+  (defparameter *oldest-forward-compatible-asdf-version* "3.1.7.20")
+  ;; Semi-private variable: a designator for a stream on which to output ASDF progress messages
   (defvar *verbose-out* nil)
+  ;; Private function by which ASDF outputs progress messages and warning messages:
   (defun asdf-message (format-string &rest format-args)
     (when *verbose-out* (apply 'format *verbose-out* format-string format-args)))
+  ;; Private hook for functions to run after ASDF has upgraded itself from an older variant:
   (defvar *post-upgrade-cleanup-hook* ())
-  (defvar *post-upgrade-restart-hook* ())
+  ;; Private function to detect whether the current upgrade counts as an incompatible
+  ;; data schema upgrade implying the need to drop data.
   (defun upgrading-p (&optional (oldest-compatible-version *oldest-forward-compatible-asdf-version*))
     (and *previous-asdf-versions*
          (version< (first *previous-asdf-versions*) oldest-compatible-version)))
+  ;; Private variant of defparameter that works in presence of incompatible upgrades:
+  ;; behaves like defvar in a compatible upgrade (e.g. reloading system after simple code change),
+  ;; but behaves like defparameter if in presence of an incompatible upgrade.
   (defmacro defparameter* (var value &optional docstring (version *oldest-forward-compatible-asdf-version*))
     (let* ((name (string-trim "*" var))
            (valfun (intern (format nil "%~A-~A-~A" :compute name :value))))
@@ -6829,6 +7437,9 @@ You can compare this string with e.g.: (ASDF:VERSION-SATISFIES (ASDF:ASDF-VERSIO
          (defvar ,var (,valfun) ,@(ensure-list docstring))
          (when (upgrading-p ,version)
            (setf ,var (,valfun))))))
+  ;; Private macro to declare sections of code that are only compiled and run when upgrading.
+  ;; The use of eval portably ensures that the code will not have adverse compile-time side-effects,
+  ;; whereas the use of handler-bind portably ensures that it will not issue warnings when it runs.
   (defmacro when-upgrading ((&key (version *oldest-forward-compatible-asdf-version*)
                                (upgrading-p `(upgrading-p ,version)) when) &body body)
     "A wrapper macro for code that should only be run when upgrading a
@@ -6837,6 +7448,7 @@ previously-loaded version of ASDF."
        (when (and ,upgrading-p ,@(when when `(,when)))
          (handler-bind ((style-warning #'muffle-warning))
            (eval '(progn ,@body))))))
+  ;; Only now can we safely update the version.
   (let* (;; For bug reporting sanity, please always bump this version when you modify this file.
          ;; Please also modify asdf.asd to reflect this change. make bump-version v=3.4.5.67.8
          ;; can help you do these changes in synch (look at the source for documentation).
@@ -6846,7 +7458,7 @@ previously-loaded version of ASDF."
          ;; "3.4.5.67" would be a development version in the official branch, on top of 3.4.5.
          ;; "3.4.5.0.8" would be your eighth local modification of official release 3.4.5
          ;; "3.4.5.67.8" would be your eighth local modification of development version 3.4.5.67
-         (asdf-version "3.1.7")
+         (asdf-version "3.2.0")
          (existing-version (asdf-version)))
     (setf *asdf-version* asdf-version)
     (when (and existing-version (not (equal asdf-version existing-version)))
@@ -6856,21 +7468,31 @@ previously-loaded version of ASDF."
                 (compatfmt "~&~@<; ~@;Upgrading ASDF ~@[from version ~A ~]to version ~A~@:>~%")
                 existing-version asdf-version)))))
 
+;;; Upon upgrade, specially frob some functions and classes that are being incompatibly redefined
 (when-upgrading ()
-  (let ((redefined-functions ;; gf signature and/or semantics changed incompatibly. Oops.
-          ;; NB: it's too late to do anything about functions in UIOP!
-          ;; If you introduce some critically incompatibility there, you must change name.
-          '()) ;; empty now that we don't unintern, but wholly punt on ASDF 2.26 or earlier.
+  (let ((redefined-functions ;; List of functions that changes incompatibly since 2.27:
+         ;; gf signature changed (should NOT happen), defun that became a generic function,
+         ;; method removed that will mess up with new ones (especially :around :before :after,
+         ;; more specific or call-next-method'ed method) and/or semantics otherwise modified. Oops.
+         ;; NB: it's too late to do anything about functions in UIOP!
+         ;; If you introduce some critical incompatibility there, you must change the function name.
+         ;; Note that we don't need do anything about functions that changed incompatibly
+         ;; from ASDF 2.26 or earlier: we wholly punt on the entire ASDF package in such an upgrade.
+         ;; Also note that we don't include the defgeneric=>defun, because they are
+         ;; done directly with defun* and need not trigger a punt on data.
+         ;; See discussion at https://gitlab.common-lisp.net/asdf/asdf/merge_requests/36
+         '(#:component-depends-on #:input-files ;; methods removed before 3.1.2
+           #:find-component ;; gf modified in 3.1.7.20
+           ))
         (redefined-classes
-          ;; redefining the classes causes interim circularities
-          ;; with the old ASDF during upgrade, and many implementations bork
-          '((#:compile-concatenated-source-op (#:operation) ()))))
+         ;; redefining the classes causes interim circularities
+         ;; with the old ASDF during upgrade, and many implementations bork
+         '((#:compile-concatenated-source-op (#:operation) ()))))
     (loop :for name :in redefined-functions
-          :for sym = (find-symbol* name :asdf nil) :do
-            (when sym
-              ;; On CLISP we seem to be unable to fmakunbound and define a function in the same fasl. Sigh.
-              #-clisp (fmakunbound sym)))
-    (labels ((asym (x) (multiple-value-bind (s p) (if (consp x) (values (car x) (cadr x)) (values x :asdf))
+      :for sym = (find-symbol* name :asdf nil)
+      :do (when sym (fmakunbound sym)))
+    (labels ((asym (x) (multiple-value-bind (s p)
+                           (if (consp x) (values (car x) (cadr x)) (values x :asdf))
                          (find-symbol* s p nil)))
              (asyms (l) (mapcar #'asym l)))
       (loop* :for (name superclasses slots) :in redefined-classes
@@ -6880,8 +7502,9 @@ previously-loaded version of ASDF."
 
 
 ;;; Self-upgrade functions
-
 (with-upgradability ()
+  ;; This private function is called at the end of asdf/footer and ensures that,
+  ;; *if* this loading of ASDF was an upgrade, then all registered cleanup functions will be called.
   (defun cleanup-upgraded-asdf (&optional (old-version (first *previous-asdf-versions*)))
     (let ((new-version (asdf-version)))
       (unless (equal old-version new-version)
@@ -6908,7 +7531,117 @@ previously-loaded version of ASDF."
       (handler-bind (((or style-warning) #'muffle-warning))
         (symbol-call :asdf :load-system :asdf :verbose nil))))
 
-  (register-hook-function '*post-upgrade-cleanup-hook* 'upgrade-configuration))
+  (defmacro with-asdf-deprecation ((&rest keys &key &allow-other-keys) &body body)
+    `(with-upgradability ()
+       (with-deprecation ((version-deprecation *asdf-version* ,@keys))
+         ,@body))))
+;;;; -------------------------------------------------------------------------
+;;;; Session cache
+
+(uiop/package:define-package :asdf/cache
+  (:use :uiop/common-lisp :uiop :asdf/upgrade)
+  (:export #:get-file-stamp #:compute-file-stamp #:register-file-stamp
+           #:set-asdf-cache-entry #:unset-asdf-cache-entry #:consult-asdf-cache
+           #:do-asdf-cache #:normalize-namestring
+           #:call-with-asdf-cache #:with-asdf-cache #:*asdf-cache*
+           #:clear-configuration-and-retry #:retry))
+(in-package :asdf/cache)
+
+;;; The ASDF session cache is used to memoize some computations. It is instrumental in achieving:
+;; * Consistency in the view of the world relied on by ASDF within a given session.
+;;   Inconsistencies in file stamps, system definitions, etc., could cause infinite loops
+;;   (a.k.a. stack overflows) and other erratic behavior.
+;; * Speed and reliability of ASDF, with fewer side-effects from access to the filesystem, and
+;;   no expensive recomputations of transitive dependencies for some input-files or output-files.
+;; * Testability of ASDF with the ability to fake timestamps without actually touching files.
+
+(with-upgradability ()
+  ;; The session cache variable.
+  ;; NIL when outside a session, an equal hash-table when inside a session.
+  (defvar *asdf-cache* nil)
+
+  ;; Set a session cache entry for KEY to a list of values VALUE-LIST, when inside a session.
+  ;; Return those values.
+  (defun set-asdf-cache-entry (key value-list)
+    (values-list (if *asdf-cache*
+                     (setf (gethash key *asdf-cache*) value-list)
+                     value-list)))
+
+  ;; Unset the session cache entry for KEY, when inside a session.
+  (defun unset-asdf-cache-entry (key)
+    (when *asdf-cache*
+      (remhash key *asdf-cache*)))
+
+  ;; Consult the session cache entry for KEY if present and in a session;
+  ;; if not present, compute it by calling the THUNK,
+  ;; and set the session cache entry accordingly, if in a session.
+  ;; Return the values from the cache and/or the thunk computation.
+  (defun consult-asdf-cache (key &optional thunk)
+    (if *asdf-cache*
+        (multiple-value-bind (results foundp) (gethash key *asdf-cache*)
+          (if foundp
+              (values-list results)
+              (set-asdf-cache-entry key (multiple-value-list (call-function thunk)))))
+        (call-function thunk)))
+
+  ;; Syntactic sugar for consult-asdf-cache
+  (defmacro do-asdf-cache (key &body body)
+    `(consult-asdf-cache ,key #'(lambda () ,@body)))
+
+  ;; Compute inside a ASDF session with a cache.
+  ;; First, make sure an ASDF session is underway, by binding the session cache variable
+  ;; to a new hash-table if it's currently null (or even if it isn't, if OVERRIDE is true).
+  ;; Second, if a new session was started, establish restarts for retrying the overall computation.
+  ;; Finally, consult the cache if a KEY was specified with the THUNK as a fallback when the cache
+  ;; entry isn't found, or just call the THUNK if no KEY was specified.
+  (defun call-with-asdf-cache (thunk &key override key)
+    (let ((fun (if key #'(lambda () (consult-asdf-cache key thunk)) thunk)))
+      (if (and *asdf-cache* (not override))
+          (funcall fun)
+          (loop
+            (restart-case
+                (let ((*asdf-cache* (make-hash-table :test 'equal)))
+                  (return (funcall fun)))
+              (retry ()
+                :report (lambda (s)
+                          (format s (compatfmt "~@<Retry ASDF operation.~@:>"))))
+              (clear-configuration-and-retry ()
+                :report (lambda (s)
+                          (format s (compatfmt "~@<Retry ASDF operation after resetting the configuration.~@:>")))
+                (clear-configuration)))))))
+
+  ;; Syntactic sugar for call-with-asdf-cache
+  (defmacro with-asdf-cache ((&key key override) &body body)
+    `(call-with-asdf-cache #'(lambda () ,@body) :override ,override :key ,key))
+
+
+  ;;; Define specific accessor for file (date) stamp.
+
+  ;; Normalize a namestring for use as a key in the session cache.
+  (defun normalize-namestring (pathname)
+    (let ((resolved (resolve-symlinks*
+                     (ensure-absolute-pathname
+                      (physicalize-pathname pathname)
+                      'get-pathname-defaults))))
+      (with-pathname-defaults () (namestring resolved))))
+
+  ;; Compute the file stamp for a normalized namestring
+  (defun compute-file-stamp (normalized-namestring)
+    (with-pathname-defaults ()
+      (safe-file-write-date normalized-namestring)))
+
+  ;; Override the time STAMP associated to a given FILE in the session cache.
+  ;; If no STAMP is specified, recompute a new one from the filesystem.
+  (defun register-file-stamp (file &optional (stamp nil stampp))
+    (let* ((namestring (normalize-namestring file))
+           (stamp (if stampp stamp (compute-file-stamp namestring))))
+      (set-asdf-cache-entry `(get-file-stamp ,namestring) (list stamp))))
+
+  ;; Get or compute a memoized stamp for given FILE from the session cache.
+  (defun get-file-stamp (file)
+    (when file
+      (let ((namestring (normalize-namestring file)))
+        (do-asdf-cache `(get-file-stamp ,namestring) (compute-file-stamp namestring))))))
 
 ;;;; -------------------------------------------------------------------------
 ;;;; Components
@@ -6958,26 +7691,40 @@ previously-loaded version of ASDF."
   (defgeneric component-name (component)
     (:documentation "Name of the COMPONENT, unique relative to its parent"))
   (defgeneric component-system (component)
-    (:documentation "Find the top-level system containing COMPONENT"))
+    (:documentation "Top-level system containing the COMPONENT"))
   (defgeneric component-pathname (component)
-    (:documentation "Extracts the pathname applicable for a particular component."))
-  (defgeneric (component-relative-pathname) (component)
-    (:documentation "Returns a pathname for the component argument intended to be
-interpreted relative to the pathname of that component's parent.
-Despite the function's name, the return value may be an absolute
-pathname, because an absolute pathname may be interpreted relative to
-another pathname in a degenerate way."))
-  (defgeneric component-external-format (component))
-  (defgeneric component-encoding (component))
-  (defgeneric version-satisfies (component version))
-  (defgeneric component-version (component))
-  (defgeneric (setf component-version) (new-version component))
-  (defgeneric component-parent (component))
+    (:documentation "Pathname of the COMPONENT if any, or NIL."))
+  (defgeneric component-relative-pathname (component)
+    ;; in ASDF4, rename that to component-specified-pathname ?
+    (:documentation "Specified pathname of the COMPONENT,
+intended to be merged with the pathname of that component's parent if any, using merged-pathnames*.
+Despite the function's name, the return value can be an absolute pathname, in which case the merge
+will leave it unmodified."))
+  (defgeneric component-external-format (component)
+    (:documentation "The external-format of the COMPONENT.
+By default, deduced from the COMPONENT-ENCODING."))
+  (defgeneric component-encoding (component)
+    (:documentation "The encoding of the COMPONENT. By default, only :utf-8 is supported.
+Use asdf-encodings to support more encodings."))
+  (defgeneric version-satisfies (component version)
+    (:documentation "Check whether a COMPONENT satisfies the constraint of being at least as recent
+as the specified VERSION, which must be a string of dot-separated natural numbers, or NIL."))
+  (defgeneric component-version (component)
+    (:documentation "Return the version of a COMPONENT, which must be a string of dot-separated
+natural numbers, or NIL."))
+  (defgeneric (setf component-version) (new-version component)
+    (:documentation "Updates the version of a COMPONENT, which must be a string of dot-separated
+natural numbers, or NIL."))
+  (defgeneric component-parent (component)
+    (:documentation "The parent of a child COMPONENT,
+or NIL for top-level components (a.k.a. systems)"))
+  ;; NIL is a designator for the absence of a component, in which case the parent is also absent.
   (defmethod component-parent ((component null)) nil)
 
-  ;; Backward compatible way of computing the FILE-TYPE of a component.
+  ;; Deprecated: Backward compatible way of computing the FILE-TYPE of a component.
   ;; TODO: find users, have them stop using that, remove it for ASDF4.
-  (defgeneric (source-file-type) (component system))
+  (defgeneric source-file-type (component system)
+    (:documentation "DEPRECATED. Use the FILE-TYPE of a COMPONENT instead."))
 
   (define-condition system-definition-error (error) ()
     ;; [this use of :report should be redundant, but unfortunately it's not.
@@ -7045,7 +7792,8 @@ another pathname in a degenerate way."))
      ;; For backward-compatibility, this slot is part of component rather than of child-component. ASDF4: stop it.
      (parent :initarg :parent :initform nil :reader component-parent)
      (build-operation
-      :initarg :build-operation :initform nil :reader component-build-operation)))
+      :initarg :build-operation :initform nil :reader component-build-operation))
+    (:documentation "Base class for all components of a build"))
 
   (defun component-find-path (component)
     "Return a path from a root system to the COMPONENT.
@@ -7069,11 +7817,12 @@ The return value is a list of component NAMES; a list of strings."
 ;; The tree typically but not necessarily follows the filesystem hierarchy.
 (with-upgradability ()
   (defclass child-component (component) ()
-    (:documentation "A CHILD-COMPONENT is a component that may be part of
+    (:documentation "A CHILD-COMPONENT is a COMPONENT that may be part of
 a PARENT-COMPONENT."))
 
   (defclass file-component (child-component)
-    ((type :accessor file-type :initarg :type))) ; no default
+    ((type :accessor file-type :initarg :type)) ; no default
+    (:documentation "a COMPONENT that represents a file"))
   (defclass source-file (file-component)
     ((type :accessor source-file-explicit-type ;; backward-compatibility
            :initform nil))) ;; NB: many systems have come to rely on this default.
@@ -7082,7 +7831,8 @@ a PARENT-COMPONENT."))
   (defclass java-source-file (source-file)
     ((type :initform "java")))
   (defclass static-file (source-file)
-    ((type :initform nil)))
+    ((type :initform nil))
+    (:documentation "Component for a file to be included as is in the build output"))
   (defclass doc-file (static-file) ())
   (defclass html-file (doc-file)
     ((type :initform "html")))
@@ -7100,10 +7850,13 @@ a PARENT-COMPONENT."))
       :initform nil
       :initarg :default-component-class
       :accessor module-default-component-class))
-  (:documentation "A PARENT-COMPONENT is a component that may have
-children.")))
+  (:documentation "A PARENT-COMPONENT is a component that may have children.")))
 
 (with-upgradability ()
+  ;; (Private) Function that given a PARENT component,
+  ;; the list of children of which has been initialized,
+  ;; compute the hash-table in slot children-by-name that allows to retrieve its children by name.
+  ;; If ONLY-IF-NEEDED-P is defined, skip any (re)computation if the slot is already populated.
   (defun compute-children-by-name (parent &key only-if-needed-p)
     (unless (and only-if-needed-p (slot-boundp parent 'children-by-name))
       (let ((hash (make-hash-table :test 'equal)))
@@ -7117,15 +7870,22 @@ children.")))
 
 (with-upgradability ()
   (defclass module (child-component parent-component)
-    (#+clisp (components)))) ;; backward compatibility during upgrade only
+    (#+clisp (components)) ;; backward compatibility during upgrade only
+    (:documentation "A module is a intermediate component with both a parent and children,
+typically but not necessarily representing the files in a subdirectory of the build source.")))
 
 
 ;;;; component pathnames
 (with-upgradability ()
-  (defgeneric* (component-parent-pathname) (component))
+  (defgeneric component-parent-pathname (component)
+    (:documentation "The pathname of the COMPONENT's parent, if any, or NIL"))
   (defmethod component-parent-pathname (component)
     (component-pathname (component-parent component)))
 
+  ;; The default method for component-pathname tries to extract a cached precomputed
+  ;; absolute-pathname from the relevant slot, and if not, computes it by merging the
+  ;; component-relative-pathname (which should be component-specified-pathname, it can be absolute)
+  ;; with the directory of the component-parent-pathname.
   (defmethod component-pathname ((component component))
     (if (slot-boundp component 'absolute-pathname)
         (slot-value component 'absolute-pathname)
@@ -7139,6 +7899,9 @@ children.")))
           (setf (slot-value component 'absolute-pathname) pathname)
           pathname)))
 
+  ;; Default method for component-relative-pathname:
+  ;; combine the contents of slot relative-pathname (from specified initarg :pathname)
+  ;; with the appropriate source-file-type, which defaults to the file-type of the component.
   (defmethod component-relative-pathname ((component component))
     ;; SOURCE-FILE-TYPE below is strictly for backward-compatibility with ASDF1.
     ;; We ought to be able to extract this from the component alone with FILE-TYPE.
@@ -7172,7 +7935,11 @@ children.")))
 
 ;;;; around-compile-hook
 (with-upgradability ()
-  (defgeneric around-compile-hook (component))
+  (defgeneric around-compile-hook (component)
+    (:documentation "An optional hook function that will be called with one argument, a thunk.
+The hook function must call the thunk, that will compile code from the component, and may or may not
+also evaluate the compiled results. The hook function may establish dynamic variable bindings around
+this compilation, or check its results, etc."))
   (defmethod around-compile-hook ((c component))
     (cond
       ((slot-boundp c 'around-compile)
@@ -7201,6 +7968,7 @@ children.")))
 ;;; all sub-components (of a given type)
 (with-upgradability ()
   (defun sub-components (component &key (type t))
+    "Compute the transitive sub-components of given COMPONENT that are of given TYPE"
     (while-collecting (c)
       (labels ((recurse (x)
                  (when (if-let (it (component-if-feature x)) (featurep it) t)
@@ -7234,12 +8002,33 @@ children.")))
 (in-package :asdf/system)
 
 (with-upgradability ()
-  (defgeneric* (find-system) (system &optional error-p))
-  (defgeneric* (system-source-file :supersede #-clisp t #+clisp nil) (system)
+  ;; The method is actually defined in asdf/find-system,
+  ;; but we declare the function here to avoid a forward reference.
+  (defgeneric find-system (system &optional error-p)
+    (:documentation "Given a system designator, find the actual corresponding system object.
+If no system is found, then signal an error if ERROR-P is true (the default), or else return NIL.
+A system designator is usually a string (conventionally all lowercase) or a symbol, designating
+the same system as its downcased name; it can also be a system object (designating itself)."))
+  (defgeneric system-source-file (system)
     (:documentation "Return the source file in which system is defined."))
-  (defgeneric component-build-pathname (component))
-
-  (defgeneric component-entry-point (component))
+  ;; This is bad design, but was the easiest kluge I found to let the user specify that
+  ;; some special actions create outputs at locations controled by the user that are not affected
+  ;; by the usual output-translations.
+  ;; TODO: Fix operate to stop passing flags to operation (which in the current design shouldn't
+  ;; have any flags, since the stamp cache, etc., can't distinguish them), and instead insert
+  ;; *there* the ability of specifying special output paths, not in the system definition.
+  (defgeneric component-build-pathname (component)
+    (:documentation "The COMPONENT-BUILD-PATHNAME, when defined and not null, specifies the
+output pathname for the action using the COMPONENT-BUILD-OPERATION.
+
+NB: This interface is subject to change. Please contact ASDF maintainers if you use it."))
+
+  ;; TODO: Should this have been made a SYSTEM-ENTRY-POINT instead?
+  (defgeneric component-entry-point (component)
+    (:documentation "The COMPONENT-ENTRY-POINT, when defined, specifies what function to call
+(with no argument) when running an image dumped from the COMPONENT.
+
+NB: This interface is subject to change. Please contact ASDF maintainers if you use it."))
   (defmethod component-entry-point ((c component))
     nil))
 
@@ -7250,7 +8039,9 @@ children.")))
   (defclass proto-system () ; slots to keep when resetting a system
     ;; To preserve identity for all objects, we'd need keep the components slots
     ;; but also to modify parse-component-form to reset the recycled objects.
-    ((name) (source-file) #|(children) (children-by-names)|#))
+    ((name) (source-file) #|(children) (children-by-names)|#)
+    (:documentation "PROTO-SYSTEM defines the elements of identity that are preserved when
+a SYSTEM is redefined and its class is modified."))
 
   (defclass system (module proto-system)
     ;; Backward-compatibility: inherit from module. ASDF4: only inherit from parent-component.
@@ -7278,9 +8069,14 @@ children.")))
                            :initform nil)
      ;; these two are specially set in parse-component-form, so have no :INITARGs.
      (depends-on :reader system-depends-on :initform nil)
-     (weakly-depends-on :reader system-weakly-depends-on :initform nil)))
+     (weakly-depends-on :reader system-weakly-depends-on :initform nil))
+    (:documentation "SYSTEM is the base class for top-level components that users may request
+ASDF to build."))
+
 
   (defun reset-system (system &rest keys &key &allow-other-keys)
+    "Erase any data from a SYSTEM except its basic identity, then reinitialize it
+based on supplied KEYS."
     (change-class (change-class system 'proto-system) 'system)
     (apply 'reinitialize-instance system keys)))
 
@@ -7288,26 +8084,37 @@ children.")))
 ;;;; Pathnames
 
 (with-upgradability ()
+  ;; Resolve a system designator to a system before extracting its system-source-file
   (defmethod system-source-file ((system-name string))
     (system-source-file (find-system system-name)))
   (defmethod system-source-file ((system-name symbol))
-    (system-source-file (find-system system-name)))
+    (when system-name
+      (system-source-file (find-system system-name))))
 
   (defun system-source-directory (system-designator)
     "Return a pathname object corresponding to the directory
 in which the system specification (.asd file) is located."
     (pathname-directory-pathname (system-source-file system-designator)))
 
-  (defun (system-relative-pathname) (system name &key type)
+  (defun* (system-relative-pathname) (system name &key type)
+    "Given a SYSTEM, and a (Unix-style relative path) NAME of a file (or directory) of given TYPE,
+return the absolute pathname of a corresponding file under that system's source code pathname."
     (subpathname (system-source-directory system) name :type type))
 
   (defmethod component-pathname ((system system))
+    "Given a SYSTEM, and a (Unix-style relative path) NAME of a file (or directory) of given TYPE,
+return the absolute pathname of a corresponding file under that system's source code pathname."
     (let ((pathname (or (call-next-method) (system-source-directory system))))
       (unless (and (slot-boundp system 'relative-pathname) ;; backward-compatibility with ASDF1-age
                    (slot-value system 'relative-pathname)) ;; systems that directly access this slot.
         (setf (slot-value system 'relative-pathname) pathname))
       pathname))
 
+  ;; The default method of component-relative-pathname for a system:
+  ;; if a pathname was specified in the .asd file, it must be relative to the .asd file
+  ;; (actually, to its truename* if *resolve-symlinks* it true, the default).
+  ;; The method will return an *absolute* pathname, once again showing that the historical name
+  ;; component-relative-pathname is misleading and should have been component-specified-pathname.
   (defmethod component-relative-pathname ((system system))
     (parse-unix-namestring
      (and (slot-boundp system 'relative-pathname)
@@ -7317,93 +8124,16 @@ in which the system specification (.asd file) is located."
      :ensure-absolute t
      :defaults (system-source-directory system)))
 
+  ;; A system has no parent; if some method wants to make a path "relative to its parent",
+  ;; it will instead be relative to the system itself.
   (defmethod component-parent-pathname ((system system))
     (system-source-directory system))
 
+  ;; Most components don't have a specified component-build-pathname, and therefore
+  ;; no magic redirection of their output that disregards the output-translations.
   (defmethod component-build-pathname ((c component))
     nil))
 
-;;;; -------------------------------------------------------------------------
-;;;; Stamp cache
-
-(uiop/package:define-package :asdf/cache
-  (:use :uiop/common-lisp :uiop :asdf/upgrade)
-  (:export #:get-file-stamp #:compute-file-stamp #:register-file-stamp
-           #:set-asdf-cache-entry #:unset-asdf-cache-entry #:consult-asdf-cache
-           #:do-asdf-cache #:normalize-namestring
-           #:call-with-asdf-cache #:with-asdf-cache #:*asdf-cache*
-           #:clear-configuration-and-retry #:retry))
-(in-package :asdf/cache)
-
-;;; This stamp cache is useful for:
-;; * consistency of stamps used within a single run
-;; * fewer accesses to the filesystem
-;; * the ability to test with fake timestamps, without touching files
-
-(with-upgradability ()
-  (defvar *asdf-cache* nil)
-
-  (defun set-asdf-cache-entry (key value-list)
-    (apply 'values
-           (if *asdf-cache*
-               (setf (gethash key *asdf-cache*) value-list)
-               value-list)))
-
-  (defun unset-asdf-cache-entry (key)
-    (when *asdf-cache*
-      (remhash key *asdf-cache*)))
-
-  (defun consult-asdf-cache (key &optional thunk)
-    (if *asdf-cache*
-        (multiple-value-bind (results foundp) (gethash key *asdf-cache*)
-          (if foundp
-              (apply 'values results)
-              (set-asdf-cache-entry key (multiple-value-list (call-function thunk)))))
-        (call-function thunk)))
-
-  (defmacro do-asdf-cache (key &body body)
-    `(consult-asdf-cache ,key #'(lambda () ,@body)))
-
-  (defun call-with-asdf-cache (thunk &key override key)
-    (let ((fun (if key #'(lambda () (consult-asdf-cache key thunk)) thunk)))
-      (if (and *asdf-cache* (not override))
-          (funcall fun)
-          (loop
-            (restart-case
-                (let ((*asdf-cache* (make-hash-table :test 'equal)))
-                  (return (funcall fun)))
-              (retry ()
-                :report (lambda (s)
-                          (format s (compatfmt "~@<Retry ASDF operation.~@:>"))))
-              (clear-configuration-and-retry ()
-                :report (lambda (s)
-                          (format s (compatfmt "~@<Retry ASDF operation after resetting the configuration.~@:>")))
-                (clear-configuration)))))))
-
-  (defmacro with-asdf-cache ((&key key override) &body body)
-    `(call-with-asdf-cache #'(lambda () ,@body) :override ,override :key ,key))
-
-  (defun normalize-namestring (pathname)
-    (let ((resolved (resolve-symlinks*
-                     (ensure-absolute-pathname
-                      (physicalize-pathname pathname)
-                      'get-pathname-defaults))))
-      (with-pathname-defaults () (namestring resolved))))
-
-  (defun compute-file-stamp (normalized-namestring)
-    (with-pathname-defaults ()
-      (safe-file-write-date normalized-namestring)))
-
-  (defun register-file-stamp (file &optional (stamp nil stampp))
-    (let* ((namestring (normalize-namestring file))
-           (stamp (if stampp stamp (compute-file-stamp namestring))))
-      (set-asdf-cache-entry `(get-file-stamp ,namestring) (list stamp))))
-
-  (defun get-file-stamp (file)
-    (when file
-      (let ((namestring (normalize-namestring file)))
-        (do-asdf-cache `(get-file-stamp ,namestring) (compute-file-stamp namestring))))))
-
 ;;;; -------------------------------------------------------------------------
 ;;;; Finding systems
 
@@ -7415,7 +8145,8 @@ in which the system specification (.asd file) is located."
    #:remove-entry-from-registry #:coerce-entry-to-directory
    #:coerce-name #:primary-system-name #:coerce-filename
    #:find-system #:locate-system #:load-asd
-   #:system-registered-p #:register-system #:registered-systems* #:registered-systems
+   #:system-registered-p #:registered-system #:register-system
+   #:registered-systems* #:registered-systems
    #:clear-system #:map-systems
    #:missing-component #:missing-requires #:missing-parent
    #:formatted-system-definition-error #:format-control #:format-arguments #:sysdef-error
@@ -7425,6 +8156,7 @@ in which the system specification (.asd file) is located."
    #:find-system-if-being-defined
    #:contrib-sysdef-search #:sysdef-find-asdf ;; backward compatibility symbols, functions removed
    #:sysdef-preloaded-system-search #:register-preloaded-system #:*preloaded-systems*
+   #:mark-component-preloaded ;; forward reference to asdf/operate
    #:sysdef-immutable-system-search #:register-immutable-system #:*immutable-systems*
    #:*defined-systems* #:clear-defined-systems
    ;; defined in source-registry, but specially mentioned here:
@@ -7456,163 +8188,239 @@ in which the system specification (.asd file) is located."
     (error 'formatted-system-definition-error :format-control
            format :format-arguments arguments))
 
+
+  ;;; Canonicalizing system names
+
   (defun coerce-name (name)
+    "Given a designator for a component NAME, return the name as a string.
+The designator can be a COMPONENT (designing its name; note that a SYSTEM is a component),
+a SYMBOL (designing its name, downcased), or a STRING (designing itself)."
     (typecase name
       (component (component-name name))
-      (symbol (string-downcase (symbol-name name)))
+      (symbol (string-downcase name))
       (string name)
       (t (sysdef-error (compatfmt "~@<Invalid component designator: ~3i~_~A~@:>") name))))
 
   (defun primary-system-name (name)
-    ;; When a system name has slashes, the file with defsystem is named by
-    ;; the first of the slash-separated components.
+    "Given a system designator NAME, return the name of the corresponding primary system,
+after which the .asd file is named. That's the first component when dividing the name
+as a string by / slashes."
     (first (split-string (coerce-name name) :separator "/")))
 
   (defun coerce-filename (name)
+    "Coerce a system designator NAME into a string suitable as a filename component.
+The (current) transformation is to replace characters /:\\ each by --,
+the former being forbidden in a filename component.
+NB: The onus is unhappily on the user to avoid clashes."
     (frob-substrings (coerce-name name) '("/" ":" "\\") "--"))
 
+
+  ;;; Registry of Defined Systems
+
   (defvar *defined-systems* (make-hash-table :test 'equal)
-    "This is a hash table whose keys are strings, being the
-names of the systems, and whose values are pairs, the first
+    "This is a hash table whose keys are strings -- the
+names of systems -- and whose values are pairs, the first
 element of which is a universal-time indicating when the
 system definition was last updated, and the second element
-of which is a system object.")
+of which is a system object.
+  A system is referred to as \"registered\" if it is present
+in this table.")
 
   (defun system-registered-p (name)
+    "Return a generalized boolean that is true if a system of given NAME was registered already.
+NAME is a system designator, to be normalized by COERCE-NAME.
+The value returned if true is a pair of a timestamp and a system object."
     (gethash (coerce-name name) *defined-systems*))
 
+  (defun registered-system (name)
+    "Return a system of given NAME that was registered already,
+if such a system exists.  NAME is a system designator, to be
+normalized by COERCE-NAME. The value returned is a system object,
+or NIL if not found."
+    (cdr (system-registered-p name)))
+
   (defun registered-systems* ()
+    "Return a list containing every registered system (as a system object)."
     (loop :for registered :being :the :hash-values :of *defined-systems*
           :collect (cdr registered)))
 
   (defun registered-systems ()
+    "Return a list of the names of every registered system."
     (mapcar 'coerce-name (registered-systems*)))
 
   (defun register-system (system)
+    "Given a SYSTEM object, register it."
     (check-type system system)
     (let ((name (component-name system)))
       (check-type name string)
       (asdf-message (compatfmt "~&~@<; ~@;Registering ~3i~_~A~@:>~%") system)
-      (unless (eq system (cdr (gethash name *defined-systems*)))
+      (unless (eq system (registered-system name))
         (setf (gethash name *defined-systems*)
-              (cons (if-let (file (ignore-errors (system-source-file system)))
-                      (get-file-stamp file))
+              (cons (ignore-errors (get-file-stamp (system-source-file system)))
                     system)))))
 
-  (defvar *preloaded-systems* (make-hash-table :test 'equal))
+  (defun map-systems (fn)
+    "Apply FN to each defined system.
+
+FN should be a function of one argument. It will be
+called with an object of type asdf:system."
+    (loop :for registered :being :the :hash-values :of *defined-systems*
+          :do (funcall fn (cdr registered))))
+
+
+  ;;; Preloaded systems: in the image even if you can't find source files backing them.
+
+  (defvar *preloaded-systems* (make-hash-table :test 'equal)
+    "Registration table for preloaded systems.")
+
+  (declaim (ftype (function (t) t) mark-component-preloaded)) ; defined in asdf/operate
 
   (defun make-preloaded-system (name keys)
-    (apply 'make-instance (getf keys :class 'system)
-           :name name :source-file (getf keys :source-file)
-           (remove-plist-keys '(:class :name :source-file) keys)))
+    "Make a preloaded system of given NAME with build information from KEYS"
+    (let ((system (apply 'make-instance (getf keys :class 'system)
+                         :name name :source-file (getf keys :source-file)
+                         (remove-plist-keys '(:class :name :source-file) keys))))
+      (mark-component-preloaded system)
+      system))
 
   (defun sysdef-preloaded-system-search (requested)
+    "If REQUESTED names a system registered as preloaded, return a new system
+with its registration information."
     (let ((name (coerce-name requested)))
       (multiple-value-bind (keys foundp) (gethash name *preloaded-systems*)
         (when foundp
           (make-preloaded-system name keys)))))
 
-  (defun register-preloaded-system (system-name &rest keys)
-    (setf (gethash (coerce-name system-name) *preloaded-systems*) keys))
+  (defun ensure-preloaded-system-registered (name)
+    "If there isn't a registered _defined_ system of given NAME,
+and a there is a registered _preloaded_ system of given NAME,
+then define and register said preloaded system."
+    (if-let (system (and (not (registered-system name)) (sysdef-preloaded-system-search name)))
+      (register-system system)))
+
+  (defun register-preloaded-system (system-name &rest keys &key (version t) &allow-other-keys)
+    "Register a system as being preloaded. If the system has not been loaded from the filesystem
+yet, or if its build information is later cleared with CLEAR-SYSTEM, a dummy system will be
+registered without backing filesystem information, based on KEYS (e.g. to provide a VERSION).
+If VERSION is the default T, and a system was already loaded, then its version will be preserved."
+    (let ((name (coerce-name system-name)))
+      (when (eql version t)
+        (if-let (system (registered-system name))
+          (setf (getf keys :version) (component-version system))))
+      (setf (gethash name *preloaded-systems*) keys)
+      (ensure-preloaded-system-registered system-name)))
+
 
-  (dolist (s '("asdf" "uiop" "asdf-driver" "asdf-defsystem" "asdf-package-system"))
-    ;; don't bother with these, no one relies on them: "asdf-utils" "asdf-bundle"
-    (register-preloaded-system s :version *asdf-version*))
+  ;;; Immutable systems: in the image and can't be reloaded from source.
 
   (defvar *immutable-systems* nil
-    "An hash-set (equal hash-table mapping keys to T) of systems that are immutable,
+    "A hash-set (equal hash-table mapping keys to T) of systems that are immutable,
 i.e. already loaded in memory and not to be refreshed from the filesystem.
 They will be treated specially by find-system, and passed as :force-not argument to make-plan.
 
-If you deliver an image with many systems precompiled, *and* do not want to check the filesystem
-for them every time a user loads an extension, what more risk a problematic upgrade or catastrophic
-downgrade, before you dump an image, use:
-   (setf asdf::*immutable-systems* (uiop:list-to-hash-set (asdf:already-loaded-systems)))")
+For instance, to can deliver an image with many systems precompiled, that *will not* check the
+filesystem for them every time a user loads an extension, what more risk a problematic upgrade
+ or catastrophic downgrade, before you dump an image, you may use:
+   (map () 'asdf:register-immutable-system (asdf:already-loaded-systems))
+
+Note that direct access to this variable from outside ASDF is not supported.
+Please call REGISTER-IMMUTABLE-SYSTEM to add new immutable systems, and
+contact maintainers if you need a stable API to do more than that.")
 
   (defun sysdef-immutable-system-search (requested)
     (let ((name (coerce-name requested)))
       (when (and *immutable-systems* (gethash name *immutable-systems*))
-        (or (cdr (system-registered-p requested))
-            (sysdef-preloaded-system-search name)
+        (or (registered-system requested)
             (error 'formatted-system-definition-error
-                   :format-control "Requested system ~A is in the *immutable-systems* set, ~
-but not loaded in memory"
+                   :format-control "Requested system ~A registered as an immutable-system, ~
+but not even registered as defined"
                    :format-arguments (list name))))))
 
-  (defun register-immutable-system (system-name &key (version t))
-    (let* ((system-name (coerce-name system-name))
-           (registered-system (cdr (system-registered-p system-name)))
-           (default-version? (eql version t))
-           (version (cond ((and default-version? registered-system)
-                           (component-version registered-system))
-                          (default-version? nil)
-                          (t version))))
-      (unless registered-system
-        (register-system (make-preloaded-system system-name (list :version version))))
-      (register-preloaded-system system-name :version version)
+  (defun register-immutable-system (system-name &rest keys)
+    "Register SYSTEM-NAME as preloaded and immutable.
+It will automatically be considered as passed to FORCE-NOT in a plan."
+    (let ((system-name (coerce-name system-name)))
+      (apply 'register-preloaded-system system-name keys)
       (unless *immutable-systems*
         (setf *immutable-systems* (list-to-hash-set nil)))
-      (setf (gethash (coerce-name system-name) *immutable-systems*) t)))
+      (setf (gethash system-name *immutable-systems*) t)))
+
+
+  ;;; Making systems undefined.
 
   (defun clear-system (system)
-    "Clear the entry for a SYSTEM in the database of systems previously loaded,
-unless the system appears in the table of *IMMUTABLE-SYSTEMS*.
-Note that this does NOT in any way cause the code of the system to be unloaded.
-Returns T if cleared or already cleared,
-NIL if not cleared because the system was found to be immutable."
+    "Clear the entry for a SYSTEM in the database of systems previously defined.
+However if the system was registered as PRELOADED (which it is if it is IMMUTABLE),
+then a new system with the same name will be defined and registered in its place
+from which build details will have been cleared.
+Note that this does NOT in any way cause any of the code of the system to be unloaded.
+Returns T if system was or is now undefined, NIL if a new preloaded system was redefined."
     ;; There is no "unload" operation in Common Lisp, and
     ;; a general such operation cannot be portably written,
     ;; considering how much CL relies on side-effects to global data structures.
     (let ((name (coerce-name system)))
-      (unless (and *immutable-systems* (gethash name *immutable-systems*))
-        (remhash (coerce-name name) *defined-systems*)
-        (unset-asdf-cache-entry `(locate-system ,name))
-        (unset-asdf-cache-entry `(find-system ,name))
-        t)))
+      (remhash name *defined-systems*)
+      (unset-asdf-cache-entry `(find-system ,name))
+      (not (ensure-preloaded-system-registered name))))
 
   (defun clear-defined-systems ()
-    ;; Invalidate all systems but ASDF itself, if registered.
+    "Clear all currently registered defined systems.
+Preloaded systems (including immutable ones) will be reset, other systems will be de-registered."
     (loop :for name :being :the :hash-keys :of *defined-systems*
-          :unless (equal name "asdf") :do (clear-system name)))
+          :unless (member name '("asdf" "uiop") :test 'equal) :do (clear-system name)))
 
-  (register-hook-function '*post-upgrade-cleanup-hook* 'clear-defined-systems nil)
 
-  (defun map-systems (fn)
-    "Apply FN to each defined system.
-
-FN should be a function of one argument. It will be
-called with an object of type asdf:system."
-    (loop :for registered :being :the :hash-values :of *defined-systems*
-          :do (funcall fn (cdr registered)))))
+  ;;; Searching for system definitions
 
-;;; for the sake of keeping things reasonably neat, we adopt a
-;;; convention that functions in this list are prefixed SYSDEF-
-(with-upgradability ()
-  (defvar *system-definition-search-functions* '())
+  ;; For the sake of keeping things reasonably neat, we adopt a convention that
+  ;; only symbols are to be pushed to this list (rather than e.g. function objects),
+  ;; which makes upgrade easier. Also, the name of these symbols shall start with SYSDEF-
+  (defvar *system-definition-search-functions* '()
+    "A list that controls the ways that ASDF looks for system definitions.
+It contains symbols to be funcalled in order, with a requested system name as argument,
+until one returns a non-NIL result (if any), which must then be a fully initialized system object
+with that name.")
 
+  ;; Initialize and/or upgrade the *system-definition-search-functions*
+  ;; so it doesn't contain obsolete symbols, and does contain the current ones.
   (defun cleanup-system-definition-search-functions ()
     (setf *system-definition-search-functions*
           (append
            ;; Remove known-incompatible sysdef functions from old versions of asdf.
-           (remove-if #'(lambda (x) (member x '(contrib-sysdef-search sysdef-find-asdf sysdef-preloaded-system-search)))
-                      *system-definition-search-functions*)
+           ;; Order matters, so we can't just use set-difference.
+           (let ((obsolete
+                  '(contrib-sysdef-search sysdef-find-asdf sysdef-preloaded-system-search)))
+             (remove-if #'(lambda (x) (member x obsolete)) *system-definition-search-functions*))
            ;; Tuck our defaults at the end of the list if they were absent.
            ;; This is imperfect, in case they were removed on purpose,
-           ;; but then it will be the responsibility of whoever does that
+           ;; but then it will be the responsibility of whoever removes these symmbols
            ;; to upgrade asdf before he does such a thing rather than after.
            (remove-if #'(lambda (x) (member x *system-definition-search-functions*))
                       '(sysdef-central-registry-search
                         sysdef-source-registry-search)))))
   (cleanup-system-definition-search-functions)
 
+  ;; This (private) function does the search for a system definition using *s-d-s-f*;
+  ;; it is to be called by locate-system.
   (defun search-for-system-definition (system)
+    ;; Search for valid definitions of the system available in the current session.
+    ;; Previous definitions as registered in *defined-systems* MUST NOT be considered;
+    ;; they will be reconciled by locate-system then find-system.
+    ;; There are two special treatments: first, specially search for objects being defined
+    ;; in the current session, to avoid definition races between several files;
+    ;; second, specially search for immutable systems, so they cannot be redefined.
+    ;; Finally, use the search functions specified in *system-definition-search-functions*.
     (let ((name (coerce-name system)))
       (flet ((try (f) (if-let ((x (funcall f name))) (return-from search-for-system-definition x))))
         (try 'find-system-if-being-defined)
         (try 'sysdef-immutable-system-search)
-        (map () #'try *system-definition-search-functions*)
-        (try 'sysdef-preloaded-system-search))))
+        (map () #'try *system-definition-search-functions*))))
+
 
+  ;;; The legacy way of finding a system: the *central-registry*
+
+  ;; This variable contains a list of directories to be lazily searched for the requested asd
+  ;; by sysdef-central-registry-search.
   (defvar *central-registry* nil
     "A list of 'system directory designators' ASDF uses to find systems.
 
@@ -7624,10 +8432,13 @@ which evaluates to a pathname. For example:
                 #p\"/home/me/cl/systems/\"
                 #p\"/usr/share/common-lisp/systems/\"))
 
-This is for backward compatibility.
-Going forward, we recommend new users should be using the source-registry.
-")
+This variable is for backward compatibility.
+Going forward, we recommend new users should be using the source-registry.")
 
+  ;; Function to look for an asd file of given NAME under a directory provided by DEFAULTS.
+  ;; Return the truename of that file if it is found and TRUENAME is true.
+  ;; Return NIL if the file is not found.
+  ;; On Windows, follow shortcuts to .asd files.
   (defun probe-asd (name defaults &key truename)
     (block nil
       (when (directory-pathname-p defaults)
@@ -7650,6 +8461,7 @@ Going forward, we recommend new users should be using the source-registry.
               (when (probe-file* shortcut)
                 (ensure-pathname (parse-windows-shortcut shortcut) :namestring :native)))))))))
 
+  ;; Function to push onto *s-d-s-f* to use the *central-registry*
   (defun sysdef-central-registry-search (system)
     (let ((name (primary-system-name system))
           (to-remove nil)
@@ -7697,22 +8509,35 @@ Going forward, we recommend new users should be using the source-registry.
                             (list new)
                             (subseq *central-registry* (1+ position))))))))))
 
+
+  ;;; Methods for find-system
+
+  ;; Reject NIL as a system designator.
   (defmethod find-system ((name null) &optional (error-p t))
     (when error-p
       (sysdef-error (compatfmt "~@<NIL is not a valid system name~@:>"))))
 
+  ;; Default method for find-system: resolve the argument using COERCE-NAME.
   (defmethod find-system (name &optional (error-p t))
     (find-system (coerce-name name) error-p))
 
   (defun find-system-if-being-defined (name)
-    ;; NB: this depends on a corresponding side-effect in parse-defsystem;
-    ;; this protocol may change somewhat in the future.
+    ;; This function finds systems being defined *in the current ASDF session*, as embodied by
+    ;; its session cache, even before they are fully defined and registered in *defined-systems*.
+    ;; The purpose of this function is to prevent races between two files that might otherwise
+    ;; try overwrite each other's system objects, resulting in infinite loops and stack overflow.
+    ;; This function explicitly MUST NOT find definitions merely registered in previous sessions.
+    ;; NB: this function depends on a corresponding side-effect in parse-defsystem;
+    ;; the precise protocol between the two functions may change in the future (or not).
     (first (gethash `(find-system ,(coerce-name name)) *asdf-cache*)))
 
   (defun load-asd (pathname
                    &key name (external-format (encoding-external-format (detect-encoding pathname)))
                    &aux (readtable *readtable*) (print-pprint-dispatch *print-pprint-dispatch*))
-    ;; Tries to load system definition with canonical NAME from PATHNAME.
+    "Load system definitions from PATHNAME.
+NAME if supplied is the name of a system expected to be defined in that file.
+
+Do NOT try to load a .asd file directly with CL:LOAD. Always use ASDF:LOAD-ASD."
     (with-asdf-cache ()
       (with-standard-io-syntax
         (let ((*package* (find-package :asdf-user))
@@ -7737,6 +8562,9 @@ Going forward, we recommend new users should be using the source-registry.
 
   (defvar *old-asdf-systems* (make-hash-table :test 'equal))
 
+  ;; (Private) function to check that a system that was found isn't an asdf downgrade.
+  ;; Returns T if everything went right, NIL if the system was an ASDF of the same or older version,
+  ;; that shall not be loaded. Also issue a warning if it was a strictly older version of ASDF.
   (defun check-not-old-asdf-system (name pathname)
     (or (not (equal name "asdf"))
         (null pathname)
@@ -7751,9 +8579,7 @@ Going forward, we recommend new users should be using the source-registry.
              (ensure-gethash
               (list (namestring pathname) version) *old-asdf-systems*
               #'(lambda ()
-                 (let ((old-pathname
-                         (if-let (pair (system-registered-p "asdf"))
-                           (system-source-file (cdr pair)))))
+                 (let ((old-pathname (system-source-file (registered-system "asdf"))))
                    (warn "~@<~
         You are using ASDF version ~A ~:[(probably from (require \"asdf\") ~
         or loaded by quicklisp)~;from ~:*~S~] and have an older version of ASDF ~
@@ -7789,41 +8615,43 @@ PATHNAME when not null is a path from which to load the system,
 either associated with FOUND-SYSTEM, or with the PREVIOUS system.
 PREVIOUS when not null is a previously loaded SYSTEM object of same name.
 PREVIOUS-TIME when not null is the time at which the PREVIOUS system was loaded."
-    (let* ((name (coerce-name name))
-           (in-memory (system-registered-p name)) ; load from disk if absent or newer on disk
-           (previous (cdr in-memory))
-           (previous (and (typep previous 'system) previous))
-           (previous-time (car in-memory))
-           (found (search-for-system-definition name))
-           (found-system (and (typep found 'system) found))
-           (pathname (ensure-pathname
-                      (or (and (typep found '(or pathname string)) (pathname found))
-                          (and found-system (system-source-file found-system))
-                          (and previous (system-source-file previous)))
-                      :want-absolute t :resolve-symlinks *resolve-symlinks*))
-           (foundp (and (or found-system pathname previous) t)))
-      (check-type found (or null pathname system))
-      (unless (check-not-old-asdf-system name pathname)
-        (cond
-          (previous (setf found nil pathname nil))
-          (t
-           (setf found (sysdef-preloaded-system-search "asdf"))
-           (assert (typep found 'system))
-           (setf found-system found pathname nil))))
-      (values foundp found-system pathname previous previous-time)))
-
+    (with-asdf-cache () ;; NB: We don't cache the results. We once used to, but it wasn't useful,
+      ;; and keeping a negative cache was a bug (see lp#1335323), which required
+      ;; explicit invalidation in clear-system and find-system (when unsucccessful).
+      (let* ((name (coerce-name name))
+             (in-memory (system-registered-p name)) ; load from disk if absent or newer on disk
+             (previous (cdr in-memory))
+             (previous (and (typep previous 'system) previous))
+             (previous-time (car in-memory))
+             (found (search-for-system-definition name))
+             (found-system (and (typep found 'system) found))
+             (pathname (ensure-pathname
+                        (or (and (typep found '(or pathname string)) (pathname found))
+                            (system-source-file found-system)
+                            (system-source-file previous))
+                        :want-absolute t :resolve-symlinks *resolve-symlinks*))
+             (foundp (and (or found-system pathname previous) t)))
+        (check-type found (or null pathname system))
+        (unless (check-not-old-asdf-system name pathname)
+          (check-type previous system) ;; asdf is preloaded, so there should be a previous one.
+          (setf found-system nil pathname nil))
+        (values foundp found-system pathname previous previous-time))))
+
+  ;; Main method for find-system: first, make sure the computation is memoized in a session cache.
+  ;; unless the system is immutable, use locate-system to find the primary system;
+  ;; reconcile the finding (if any) with any previous definition (in a previous session,
+  ;; preloaded, with a previous configuration, or before filesystem changes), and
+  ;; load a found .asd if appropriate. Finally, update registration table and return results.
   (defmethod find-system ((name string) &optional (error-p t))
     (with-asdf-cache (:key `(find-system ,name))
       (let ((primary-name (primary-system-name name)))
         (unless (equal name primary-name)
           (find-system primary-name nil)))
-      (or (and *immutable-systems* (gethash name *immutable-systems*)
-               (or (cdr (system-registered-p name))
-                   (sysdef-preloaded-system-search name)))
+      (or (and *immutable-systems* (gethash name *immutable-systems*) (registered-system name))
           (multiple-value-bind (foundp found-system pathname previous previous-time)
               (locate-system name)
             (assert (eq foundp (and (or found-system pathname previous) t)))
-            (let ((previous-pathname (and previous (system-source-file previous)))
+            (let ((previous-pathname (system-source-file previous))
                   (system (or previous found-system)))
               (when (and found-system (not previous))
                 (register-system found-system))
@@ -7839,9 +8667,10 @@ PREVIOUS-TIME when not null is the time at which the PREVIOUS system was loaded.
                                                     (physicalize-pathname pathname)
                                                     (physicalize-pathname previous-pathname))))
                                           (stamp<= stamp previous-time))))))
-                ;; only load when it's a pathname that is different or has newer content, and not an old asdf
+                ;; Only load when it's a pathname that is different or has newer content.
                 (load-asd pathname :name name)))
-            (let ((in-memory (system-registered-p name))) ; try again after loading from disk if needed
+            ;; Try again after having loaded from disk if needed
+            (let ((in-memory (system-registered-p name)))
               (cond
                 (in-memory
                  (when pathname
@@ -7849,8 +8678,7 @@ PREVIOUS-TIME when not null is the time at which the PREVIOUS system was loaded.
                  (cdr in-memory))
                 (error-p
                  (error 'missing-component :requires name))
-                (t ;; not found: don't keep negative cache, see lp#1335323
-                 (unset-asdf-cache-entry `(locate-system ,name))
+                (t
                  (return-from find-system nil)))))))))
 ;;;; -------------------------------------------------------------------------
 ;;;; Finding components
@@ -7904,38 +8732,58 @@ PREVIOUS-TIME when not null is the time at which the PREVIOUS system was loaded.
 ;;;; Finding components
 
 (with-upgradability ()
-  (defgeneric* (find-component) (base path)
-    (:documentation "Find a component by resolving the PATH starting from BASE parent"))
-  (defgeneric resolve-dependency-combination (component combinator arguments))
+  (defgeneric find-component (base path &key registered)
+    (:documentation "Find a component by resolving the PATH starting from BASE parent.
+If REGISTERED is true, only search currently registered systems."))
+  (defgeneric resolve-dependency-combination (component combinator arguments)
+    (:documentation "Return a component satisfying the dependency specification (COMBINATOR . ARGUMENTS)
+in the context of COMPONENT"))
+
+  ;; Methods for find-component
 
-  (defmethod find-component ((base string) path)
-    (let ((s (find-system base nil)))
-      (and s (find-component s path))))
+  ;; If the base component is a string, resolve it as a system, then if not nil follow the path.
+  (defmethod find-component ((base string) path &key registered)
+    (if-let ((s (if registered
+                    (registered-system base)
+                    (find-system base nil))))
+      (find-component s path :registered registered)))
 
-  (defmethod find-component ((base symbol) path)
+  ;; If the base component is a symbol, coerce it to a name if not nil, and resolve that.
+  ;; If nil, use the path as base if not nil, or else return nil.
+  (defmethod find-component ((base symbol) path &key registered)
     (cond
-      (base (find-component (coerce-name base) path))
-      (path (find-component path nil))
+      (base (find-component (coerce-name base) path :registered registered))
+      (path (find-component path nil :registered registered))
       (t    nil)))
 
-  (defmethod find-component ((base cons) path)
-    (find-component (car base) (cons (cdr base) path)))
+  ;; If the base component is a cons cell, resolve its car, and add its cdr to the path.
+  (defmethod find-component ((base cons) path &key registered)
+    (find-component (car base) (cons (cdr base) path) :registered registered))
 
-  (defmethod find-component ((parent parent-component) (name string))
-    (compute-children-by-name parent :only-if-needed-p t) ;; SBCL may miss the u-i-f-r-c method!!!
+  ;; If the base component is a parent-component and the path a string, find the named child.
+  (defmethod find-component ((parent parent-component) (name string) &key registered)
+    (declare (ignorable registered))
+    (compute-children-by-name parent :only-if-needed-p t)
     (values (gethash name (component-children-by-name parent))))
 
-  (defmethod find-component (base (name symbol))
+  ;; If the path is a symbol, coerce it to a name if non-nil, or else just return the base.
+  (defmethod find-component (base (name symbol) &key registered)
     (if name
-        (find-component base (coerce-name name))
+        (find-component base (coerce-name name) :registered registered)
         base))
 
-  (defmethod find-component ((c component) (name cons))
-    (find-component (find-component c (car name)) (cdr name)))
+  ;; If the path is a cons, first resolve its car as path, then its cdr.
+  (defmethod find-component ((c component) (name cons) &key registered)
+    (find-component (find-component c (car name) :registered registered)
+                    (cdr name) :registered registered))
 
-  (defmethod find-component ((base t) (actual component))
+  ;; If the path is a component, return it, disregarding the base.
+  (defmethod find-component ((base t) (actual component) &key registered)
+    (declare (ignorable registered))
     actual)
 
+  ;; Resolve dependency NAME in the context of a COMPONENT, with given optional VERSION constraint.
+  ;; This (private) function is used below by RESOLVE-DEPENDENCY-SPEC and by the :VERSION spec.
   (defun resolve-dependency-name (component name &optional version)
     (loop
       (restart-case
@@ -7963,19 +8811,21 @@ PREVIOUS-TIME when not null is the time at which the PREVIOUS system was loaded.
                      (equal (missing-requires c) name))))
           (unless (component-parent component)
             (let ((name (coerce-name name)))
-              (unset-asdf-cache-entry `(find-system ,name))
-              (unset-asdf-cache-entry `(locate-system ,name))))))))
-
+              (unset-asdf-cache-entry `(find-system ,name))))))))
 
+  ;; Resolve dependency specification DEP-SPEC in the context of COMPONENT.
+  ;; This is notably used by MAP-DIRECT-DEPENDENCIES to process the results of COMPONENT-DEPENDS-ON
+  ;; and by PARSE-DEFSYSTEM to process DEFSYSTEM-DEPENDS-ON.
   (defun resolve-dependency-spec (component dep-spec)
     (let ((component (find-component () component)))
       (if (atom dep-spec)
           (resolve-dependency-name component dep-spec)
           (resolve-dependency-combination component (car dep-spec) (cdr dep-spec)))))
 
+  ;; Methods for RESOLVE-DEPENDENCY-COMBINATION to parse lists as dependency specifications.
   (defmethod resolve-dependency-combination (component combinator arguments)
-    (error (compatfmt "~@<Bad dependency ~S for ~S~@:>")
-           (cons combinator arguments) component))
+    (parameter-error (compatfmt "~@<In ~S, bad dependency ~S for ~S~@:>")
+                     'resolve-dependency-combination (cons combinator arguments) component))
 
   (defmethod resolve-dependency-combination (component (combinator (eql :feature)) arguments)
     (when (featurep (first arguments))
@@ -7992,59 +8842,71 @@ PREVIOUS-TIME when not null is the time at which the PREVIOUS system was loaded.
   (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/find-system)
   (:export
    #:operation
-   #:operation-original-initargs #:original-initargs ;; backward-compatibility only. DO NOT USE.
    #:*operations* #:make-operation #:find-operation
    #:feature)) ;; TODO: stop exporting the deprecated FEATURE feature.
 (in-package :asdf/operation)
 
 ;;; Operation Classes
-
-(when-upgrading (:when (find-class 'operation nil))
+(when-upgrading (:version "2.27" :when (find-class 'operation nil))
   ;; override any obsolete shared-initialize method when upgrading from ASDF2.
   (defmethod shared-initialize :after ((o operation) (slot-names t) &key)
     (values)))
 
 (with-upgradability ()
   (defclass operation ()
-    ((original-initargs ;; for backward-compat -- used by GBBopen and swank (via operation-forced)
-      :initform nil :initarg :original-initargs :accessor operation-original-initargs)))
+    ()
+    (:documentation "The base class for all ASDF operations.
+
+ASDF does NOT and never did distinguish between multiple operations of the same class.
+Therefore, all slots of all operations MUST have :allocation :class and no initargs. No exceptions.
+"))
 
-  ;; Cache a copy of the INITARGS in the ORIGINAL-INITARGS slot, if that slot is not
-  ;; already bound.
-  (defmethod initialize-instance :after ((o operation) &rest initargs
-                                         &key force force-not system verbose &allow-other-keys)
-    (declare (ignore force force-not system verbose))
-    (unless (slot-boundp o 'original-initargs)
-      (setf (operation-original-initargs o) initargs)))
+  (defvar *in-make-operation* nil)
+
+  (defun check-operation-constructor ()
+    "Enforce that OPERATION instances must be created with MAKE-OPERATION."
+    (unless *in-make-operation*
+      (sysdef-error "OPERATION instances must only be created through MAKE-OPERATION.")))
 
   (defmethod print-object ((o operation) stream)
-    (print-unreadable-object (o stream :type t :identity nil)
-      (ignore-errors
-       (format stream "~{~S~^ ~}" (operation-original-initargs o))))))
+    (print-unreadable-object (o stream :type t :identity nil)))
+
+  ;;; Override previous methods (from 3.1.7 and earlier) and add proper error checking.
+  (defmethod initialize-instance :after ((o operation) &rest initargs &key &allow-other-keys)
+    (unless (null initargs)
+      (parameter-error "~S does not accept initargs" 'operation))))
+
 
 ;;; make-operation, find-operation
 
 (with-upgradability ()
+  ;; A table to memoize instances of a given operation. There shall be only one.
   (defparameter* *operations* (make-hash-table :test 'equal))
 
-  (defun make-operation (operation-class &rest initargs)
-    (let ((class (coerce-class operation-class
-                               :package :asdf/interface :super 'operation :error 'sysdef-error)))
-      (ensure-gethash (cons class initargs) *operations*
-                      (list* 'make-instance class initargs))))
+  ;; A memoizing way of creating instances of operation.
+  (defun make-operation (operation-class)
+    "This function creates and memoizes an instance of OPERATION-CLASS.
+All operation instances MUST be created through this function.
 
+Use of INITARGS is not supported at this time."
+    (let ((class (coerce-class operation-class
+                               :package :asdf/interface :super 'operation :error 'sysdef-error))
+          (*in-make-operation* t))
+      (ensure-gethash class *operations* `(make-instance ,class))))
+
+  ;; This function is mostly for backward and forward compatibility:
+  ;; operations used to preserve the operation-original-initargs of the context,
+  ;; and may in the future preserve some operation-canonical-initargs.
+  ;; Still, the treatment of NIL as a disabling context is useful in some cases.
   (defgeneric find-operation (context spec)
     (:documentation "Find an operation by resolving the SPEC in the CONTEXT"))
   (defmethod find-operation ((context t) (spec operation))
     spec)
-  (defmethod find-operation (context (spec symbol))
+  (defmethod find-operation ((context t) (spec symbol))
     (when spec ;; NIL designates itself, i.e. absence of operation
-      (apply 'make-operation spec (operation-original-initargs context))))
-  (defmethod find-operation (context (spec string))
-    (apply 'make-operation spec (operation-original-initargs context)))
-  (defmethod operation-original-initargs ((context symbol))
-    (declare (ignorable context))
-    nil))
+      (make-operation spec))) ;; TODO: preserve the (operation-canonical-initargs context)
+  (defmethod find-operation ((context t) (spec string))
+    (make-operation spec))) ;; TODO: preserve the (operation-canonical-initargs context)
 
 ;;;; -------------------------------------------------------------------------
 ;;;; Actions
@@ -8054,47 +8916,69 @@ PREVIOUS-TIME when not null is the time at which the PREVIOUS system was loaded.
   (:recycle :asdf/action :asdf)
   (:use :uiop/common-lisp :uiop :asdf/upgrade
    :asdf/component :asdf/system #:asdf/cache :asdf/find-system :asdf/find-component :asdf/operation)
+  (:import-from :asdf/operation #:check-operation-constructor)
   (:export
    #:action #:define-convenience-action-methods
-   #:explain #:action-description
+   #:action-description
    #:downward-operation #:upward-operation #:sideway-operation #:selfward-operation #:non-propagating-operation
    #:component-depends-on
    #:input-files #:output-files #:output-file #:operation-done-p
    #:action-status #:action-stamp #:action-done-p
+   #:action-operation #:action-component #:make-action
    #:component-operation-time #:mark-operation-done #:compute-action-stamp
    #:perform #:perform-with-restarts #:retry #:accept
-   #:traverse-actions #:traverse-sub-actions #:required-components ;; in plan
    #:action-path #:find-action #:stamp #:done-p
    #:operation-definition-warning #:operation-definition-error ;; condition
    ))
 (in-package :asdf/action)
 
 (eval-when (#-lispworks :compile-toplevel :load-toplevel :execute) ;; LispWorks issues spurious warning
-  (deftype action () '(cons operation component)) ;; a step to be performed while building
+
+  (deftype action ()
+    "A pair of operation and component uniquely identifies a node in the dependency graph
+of steps to be performed while building a system."
+    '(cons operation component))
 
   (deftype operation-designator ()
-    ;; an operation designates itself,
-    ;; nil designates a context-dependent current operation, and
-    ;; class-name or class designates an instance of the designated class.
+    "An operation designates itself. NIL designates a context-dependent current operation,
+and a class-name or class designates the canonical instance of the designated class."
     '(or operation null symbol class)))
 
+;;; these are pseudo accessors -- let us abstract away the CONS cell representation of plan
+;;; actions.
 (with-upgradability ()
-  (defgeneric traverse-actions (actions &key &allow-other-keys))
-  (defgeneric traverse-sub-actions (operation component &key &allow-other-keys))
-  (defgeneric required-components (component &key &allow-other-keys)))
+  (defun make-action (operation component)
+    (cons operation component))
+  (defun action-operation (action)
+    (car action))
+  (defun action-component (action)
+    (cdr action)))
 
-;;;; Reified representation for storage or debugging. Note: dropping original-initargs
+;;;; Reified representation for storage or debugging. Note: an action is identified by its class.
 (with-upgradability ()
   (defun action-path (action)
-    (destructuring-bind (o . c) action (cons (type-of o) (component-find-path c))))
+    "A readable data structure that identifies the action."
+    (let ((o (action-operation action))
+          (c (action-component action)))
+      (cons (type-of o) (component-find-path c))))
   (defun find-action (path)
-    (destructuring-bind (o . c) path (cons (make-operation o) (find-component () c)))))
-
+    "Reconstitute an action from its action-path"
+    (destructuring-bind (o . c) path (make-action (make-operation o) (find-component () c)))))
 
 ;;;; Convenience methods
 (with-upgradability ()
+  ;; A macro that defines convenience methods for a generic function (gf) that
+  ;; dispatches on operation and component.  The convenience methods allow users
+  ;; to call the gf with operation and/or component designators, that the
+  ;; methods will resolve into actual operation and component objects, so that
+  ;; the users can interact using readable designators, but developers only have
+  ;; to write methods that handle operation and component objects.
+  ;; FUNCTION is the generic function name
+  ;; FORMALS is its list of arguments, which must include OPERATION and COMPONENT.
+  ;; IF-NO-OPERATION is a form (defaults to NIL) describing what to do if no operation is found.
+  ;; IF-NO-COMPONENT is a form (defaults to NIL) describing what to do if no component is found.
   (defmacro define-convenience-action-methods
-      (function formals &key if-no-operation if-no-component operation-initargs)
+      (function formals &key if-no-operation if-no-component)
     (let* ((rest (gensym "REST"))
            (found (gensym "FOUND"))
            (keyp (equal (last formals) '(&key)))
@@ -8119,15 +9003,13 @@ PREVIOUS-TIME when not null is the time at which the PREVIOUS system was loaded.
            (defmethod ,function (,@prefix (,operation symbol) ,component ,@suffix ,@more-args)
              (if ,operation
                  ,(next-method
-                   (if operation-initargs ;backward-compatibility with ASDF1's operate. Yuck.
-                       `(apply 'make-operation ,operation :original-initargs ,rest ,rest)
-                       `(make-operation ,operation))
+                   `(make-operation ,operation)
                    `(or (find-component () ,component) ,if-no-component))
                  ,if-no-operation))
            (defmethod ,function (,@prefix (,operation operation) ,component ,@suffix ,@more-args)
              (if (typep ,component 'component)
                  (error "No defined method for ~S on ~/asdf-action:format-action/"
-                        ',function (cons ,operation ,component))
+                        ',function (make-action ,operation ,component))
                  (if-let (,found (find-component () ,component))
                     ,(next-method operation found)
                     ,if-no-component))))))))
@@ -8141,13 +9023,11 @@ on this component, e.g. \"loading /a/b/c\".
 You can put together sentences using this phrase."))
   (defmethod action-description (operation component)
     (format nil (compatfmt "~@<~A on ~A~@:>")
-            (type-of operation) component))
-  (defgeneric* (explain) (operation component))
-  (defmethod explain ((o operation) (c component))
-    (asdf-message (compatfmt "~&~@<; ~@;~A~:>~%") (action-description o c)))
-  (define-convenience-action-methods explain (operation component))
+            operation component))
 
   (defun format-action (stream action &optional colon-p at-sign-p)
+    "FORMAT helper to display an action's action-description.
+Use it in FORMAT control strings as ~/asdf-action:format-action/"
     (assert (null colon-p)) (assert (null at-sign-p))
     (destructuring-bind (operation . component) action
       (princ (action-description operation component) stream))))
@@ -8155,7 +9035,7 @@ You can put together sentences using this phrase."))
 
 ;;;; Dependencies
 (with-upgradability ()
-  (defgeneric* (component-depends-on) (operation component) ;; ASDF4: rename to component-dependencies
+  (defgeneric component-depends-on (operation component) ;; ASDF4: rename to component-dependencies
     (:documentation
      "Returns a list of dependencies needed by the component to perform
     the operation.  A dependency has one of the following forms:
@@ -8270,6 +9150,7 @@ dependencies.")))
     (:documentation "Error condition related to definition of incorrect OPERATION objects."))
 
   (defmethod initialize-instance :before ((o operation) &key)
+    (check-operation-constructor)
     (unless (typep o '(or downward-operation upward-operation sideway-operation
                           selfward-operation non-propagating-operation))
       (warn 'operation-definition-warning
@@ -8287,15 +9168,25 @@ The class needs to be updated for ASDF 3.1 and specify appropriate propagation m
              :format-arguments
              (list (type-of o)))))
 
+  (defun backward-compatible-depends-on (o c)
+    "DEPRECATED: all subclasses of OPERATION used in ASDF should inherit from one of
+ DOWNWARD-OPERATION UPWARD-OPERATION SIDEWAY-OPERATION SELFWARD-OPERATION NON-PROPAGATING-OPERATION.
+ The function BACKWARD-COMPATIBLE-DEPENDS-ON temporarily provides ASDF2 behaviour for those that
+ don't. In the future this functionality will be removed, and the default will be no propagation."
+    (uiop/version::notify-deprecated-function
+     (version-deprecation *asdf-version* :style-warning "3.2")
+     'backward-compatible-depends-on)
+    `(,@(sideway-operation-depends-on o c)
+      ,@(when (typep c 'parent-component) (downward-operation-depends-on o c))))
+
   (defmethod component-depends-on ((o operation) (c component))
     `(;; Normal behavior, to allow user-specified in-order-to dependencies
       ,@(cdr (assoc (type-of o) (component-in-order-to c)))
-      ;; For backward-compatibility with ASDF2, any operation that doesn't specify propagation
-      ;; or non-propagation through an appropriate mixin will be downward and sideway.
-      ,@(unless (typep o '(or downward-operation upward-operation sideway-operation
-                              selfward-operation non-propagating-operation))
-          `(,@(sideway-operation-depends-on o c)
-            ,@(when (typep c 'parent-component) (downward-operation-depends-on o c))))))
+        ;; For backward-compatibility with ASDF2, any operation that doesn't specify propagation
+        ;; or non-propagation through an appropriate mixin will be downward and sideway.
+        ,@(unless (typep o '(or downward-operation upward-operation sideway-operation
+                             selfward-operation non-propagating-operation))
+            (backward-compatible-depends-on o c))))
 
   (defmethod downward-operation ((o operation)) nil)
   (defmethod sideway-operation ((o operation)) nil))
@@ -8308,10 +9199,22 @@ The class needs to be updated for ASDF 3.1 and specify appropriate propagation m
 
 ;;;; Inputs, Outputs, and invisible dependencies
 (with-upgradability ()
-  (defgeneric* (output-files) (operation component))
-  (defgeneric* (input-files) (operation component))
-  (defgeneric* (operation-done-p) (operation component)
-    (:documentation "Returns a boolean, which is NIL if the action is forced to be performed again"))
+  (defgeneric output-files (operation component)
+    (:documentation "Methods for this function return two values: a list of output files
+corresponding to this action, and a boolean indicating if they have already been subjected
+to relevant output translations and should not be further translated.
+
+Methods on PERFORM *must* call this function to determine where their outputs are to be located.
+They may rely on the order of the files to discriminate between outputs.
+"))
+  (defgeneric input-files (operation component)
+    (:documentation "A list of input files corresponding to this action.
+
+Methods on PERFORM *must* call this function to determine where their inputs are located.
+They may rely on the order of the files to discriminate between inputs.
+"))
+  (defgeneric operation-done-p (operation component)
+    (:documentation "Returns a boolean which is NIL if the action must be performed (again)."))
   (define-convenience-action-methods output-files (operation component))
   (define-convenience-action-methods input-files (operation component))
   (define-convenience-action-methods operation-done-p (operation component))
@@ -8319,9 +9222,8 @@ The class needs to be updated for ASDF 3.1 and specify appropriate propagation m
   (defmethod operation-done-p ((o operation) (c component))
     t)
 
-  (defmethod output-files :around (operation component)
-    "Translate output files, unless asked not to. Memoize the result."
-    operation component ;; hush genera, not convinced by declare ignorable(!)
+  ;; Translate output files, unless asked not to. Memoize the result.
+  (defmethod output-files :around ((operation t) (component t))
     (do-asdf-cache `(output-files ,operation ,component)
       (values
        (multiple-value-bind (pathnames fixedp) (call-next-method)
@@ -8345,14 +9247,19 @@ The class needs to be updated for ASDF 3.1 and specify appropriate propagation m
       (assert (length=n-p files 1))
       (first files)))
 
+  ;; Memoize input files.
   (defmethod input-files :around (operation component)
-    "memoize input files."
     (do-asdf-cache `(input-files ,operation ,component)
       (call-next-method)))
 
+  ;; By default an action has no input-files.
   (defmethod input-files ((o operation) (c component))
     nil)
 
+  ;; An action with a selfward-operation by default gets its input-files from the output-files of
+  ;; the actions using selfward-operations it depends on (and the same component),
+  ;; or if there are none, on the component-pathname of the component if it's a file
+  ;; -- and then on the results of the next-method.
   (defmethod input-files ((o selfward-operation) (c component))
     `(,@(or (loop :for dep-o :in (ensure-list (selfward-operation o))
                   :append (or (output-files dep-o c) (input-files dep-o c)))
@@ -8363,23 +9270,32 @@ The class needs to be updated for ASDF 3.1 and specify appropriate propagation m
 
 ;;;; Done performing
 (with-upgradability ()
-  (defgeneric component-operation-time (operation component)) ;; ASDF4: hide it behind plan-action-stamp
-  (defgeneric (setf component-operation-time) (time operation component))
+  ;; ASDF4: hide it behind plan-action-stamp
+  (defgeneric component-operation-time (operation component)
+    (:documentation "Return the timestamp for when an action was last performed"))
+  (defgeneric (setf component-operation-time) (time operation component)
+    (:documentation "Update the timestamp for when an action was last performed"))
   (define-convenience-action-methods component-operation-time (operation component))
 
-  (defgeneric mark-operation-done (operation component)) ;; ASDF4: hide it behind (setf plan-action-stamp)
+  ;; ASDF4: hide it behind (setf plan-action-stamp)
+  (defgeneric mark-operation-done (operation component)
+    (:documentation "Mark a action as having been just done.
+
+Updates the action's COMPONENT-OPERATION-TIME to match the COMPUTE-ACTION-STAMP
+using the JUST-DONE flag."))
   (defgeneric compute-action-stamp (plan operation component &key just-done)
     (:documentation "Has this action been successfully done already,
 and at what known timestamp has it been done at or will it be done at?
-Takes two keywords JUST-DONE and PLAN:
-JUST-DONE is a boolean that is true if the action was just successfully performed,
-at which point we want compute the actual stamp and warn if files are missing;
-otherwise we are making plans, anticipating the effects of the action.
-PLAN is a plan object modelling future effects of actions,
-or NIL to denote what actually happened.
+* PLAN is a plan object modelling future effects of actions,
+  or NIL to denote what actually happened.
+* OPERATION and COMPONENT denote the action.
+Takes keyword JUST-DONE:
+* JUST-DONE is a boolean that is true if the action was just successfully performed,
+  at which point we want compute the actual stamp and warn if files are missing;
+  otherwise we are making plans, anticipating the effects of the action.
 Returns two values:
 * a STAMP saying when it was done or will be done,
-  or T if the action has involves files that need to be recomputed.
+  or T if the action involves files that need to be recomputed.
 * a boolean DONE-P that indicates whether the action has actually been done,
   and both its output-files and its in-image side-effects are up to date."))
 
@@ -8399,10 +9315,10 @@ in some previous image, or T if it needs to be done.")
         (format stream "~@{~S~^ ~}" :stamp stamp :done-p done-p))))
 
   (defmethod component-operation-time ((o operation) (c component))
-    (gethash (type-of o) (component-operation-times c)))
+    (gethash o (component-operation-times c)))
 
   (defmethod (setf component-operation-time) (stamp (o operation) (c component))
-    (setf (gethash (type-of o) (component-operation-times c)) stamp))
+    (setf (gethash o (component-operation-times c)) stamp))
 
   (defmethod mark-operation-done ((o operation) (c component))
     (setf (component-operation-time o c) (compute-action-stamp nil o c :just-done t))))
@@ -8410,8 +9326,8 @@ in some previous image, or T if it needs to be done.")
 
 ;;;; Perform
 (with-upgradability ()
-  (defgeneric* (perform-with-restarts) (operation component))
-  (defgeneric* (perform) (operation component))
+  (defgeneric perform (operation component)
+    (:documentation "PERFORM an action, consuming its input-files and building its output-files"))
   (define-convenience-action-methods perform (operation component))
 
   (defmethod perform :before ((o operation) (c component))
@@ -8426,12 +9342,14 @@ in some previous image, or T if it needs to be done.")
                      selfward-operation non-propagating-operation))
       (sysdef-error
        (compatfmt "~@<Required method ~S not implemented for ~/asdf-action:format-action/~@:>")
-       'perform (cons o c))))
+       'perform (make-action o c))))
 
+  ;; The restarts of the perform-with-restarts variant matter in an interactive context.
+  ;; The retry strategies of p-w-r itself, and/or the background workers of a multiprocess build
+  ;; may call perform directly rather than call p-w-r.
+  (defgeneric perform-with-restarts (operation component)
+    (:documentation "PERFORM an action in a context where suitable restarts are in place."))
   (defmethod perform-with-restarts (operation component)
-    ;; TOO verbose, especially as the default. Add your own :before method
-    ;; to perform-with-restart or perform if you want that:
-    #|(explain operation component)|#
     (perform operation component))
   (defmethod perform-with-restarts :around (operation component)
     (loop
@@ -8454,60 +9372,70 @@ in some previous image, or T if it needs to be done.")
 
 (uiop/package:define-package :asdf/lisp-action
   (:recycle :asdf/lisp-action :asdf)
-  (:intern #:proclamations #:flags)
   (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/cache
    :asdf/component :asdf/system :asdf/find-component :asdf/find-system
    :asdf/operation :asdf/action)
   (:export
    #:try-recompiling
    #:cl-source-file #:cl-source-file.cl #:cl-source-file.lsp
-   #:basic-load-op #:basic-compile-op #:compile-op-flags #:compile-op-proclamations
+   #:basic-load-op #:basic-compile-op
    #:load-op #:prepare-op #:compile-op #:test-op #:load-source-op #:prepare-source-op
    #:call-with-around-compile-hook
    #:perform-lisp-compilation #:perform-lisp-load-fasl #:perform-lisp-load-source
-   #:lisp-compilation-output-files #:flags))
+   #:lisp-compilation-output-files))
 (in-package :asdf/lisp-action)
 
 
 ;;;; Component classes
 (with-upgradability ()
   (defclass cl-source-file (source-file)
-    ((type :initform "lisp")))
+    ((type :initform "lisp"))
+    (:documentation "Component class for a Common Lisp source file (using type \"lisp\")"))
   (defclass cl-source-file.cl (cl-source-file)
-    ((type :initform "cl")))
+    ((type :initform "cl"))
+    (:documentation "Component class for a Common Lisp source file using type \"cl\""))
   (defclass cl-source-file.lsp (cl-source-file)
-    ((type :initform "lsp"))))
+    ((type :initform "lsp"))
+    (:documentation "Component class for a Common Lisp source file using type \"lsp\"")))
 
 
 ;;;; Operation classes
 (with-upgradability ()
-  (defclass basic-load-op (operation) ())
-  (defclass basic-compile-op (operation)
-    ((proclamations :initarg :proclamations :accessor compile-op-proclamations :initform nil)
-     (flags :initarg :flags :accessor compile-op-flags :initform nil))))
+  (defclass basic-load-op (operation) ()
+    (:documentation "Base class for operations that apply the load-time effects of a file"))
+  (defclass basic-compile-op (operation) ()
+    (:documentation "Base class for operations that apply the compile-time effects of a file")))
+
 
 ;;; Our default operations: loading into the current lisp image
 (with-upgradability ()
   (defclass prepare-op (upward-operation sideway-operation)
     ((sideway-operation :initform 'load-op :allocation :class))
-    (:documentation "Load dependencies necessary for COMPILE-OP or LOAD-OP of a given COMPONENT."))
+    (:documentation "Load the dependencies for the COMPILE-OP or LOAD-OP of a given COMPONENT."))
   (defclass load-op (basic-load-op downward-operation selfward-operation)
     ;; NB: even though compile-op depends on prepare-op it is not needed-in-image-p,
     ;; so we need to directly depend on prepare-op for its side-effects in the current image.
-    ((selfward-operation :initform '(prepare-op compile-op) :allocation :class)))
+    ((selfward-operation :initform '(prepare-op compile-op) :allocation :class))
+    (:documentation "Operation for loading the compiled FASL for a Lisp file"))
   (defclass compile-op (basic-compile-op downward-operation selfward-operation)
-    ((selfward-operation :initform 'prepare-op :allocation :class)))
+    ((selfward-operation :initform 'prepare-op :allocation :class))
+    (:documentation "Operation for compiling a Lisp file to a FASL"))
+
 
   (defclass prepare-source-op (upward-operation sideway-operation)
-    ((sideway-operation :initform 'load-source-op :allocation :class)))
+    ((sideway-operation :initform 'load-source-op :allocation :class))
+    (:documentation "Operation for loading the dependencies of a Lisp file as source."))
   (defclass load-source-op (basic-load-op downward-operation selfward-operation)
-    ((selfward-operation :initform 'prepare-source-op :allocation :class)))
+    ((selfward-operation :initform 'prepare-source-op :allocation :class))
+    (:documentation "Operation for loading a Lisp file as source."))
 
   (defclass test-op (selfward-operation)
-    ((selfward-operation :initform 'load-op :allocation :class))))
+    ((selfward-operation :initform 'load-op :allocation :class))
+    (:documentation "Operation for running the tests for system.
+If the tests fail, an error will be signaled.")))
 
 
-;;;; prepare-op, compile-op and load-op
+;;;; Methods for prepare-op, compile-op and load-op
 
 ;;; prepare-op
 (with-upgradability ()
@@ -8524,14 +9452,19 @@ in some previous image, or T if it needs to be done.")
     (format nil (compatfmt "~@<compiling ~3i~_~A~@:>") c))
   (defmethod action-description ((o compile-op) (c parent-component))
     (format nil (compatfmt "~@<completing compilation for ~3i~_~A~@:>") c))
-  (defgeneric call-with-around-compile-hook (component thunk))
+  (defgeneric call-with-around-compile-hook (component thunk)
+    (:documentation "A method to be called around the PERFORM'ing of actions that apply the
+compile-time side-effects of file (i.e., COMPILE-OP or LOAD-SOURCE-OP). This method can be used
+to setup readtables and other variables that control reading, macroexpanding, and compiling, etc.
+Note that it will NOT be called around the performing of LOAD-OP."))
   (defmethod call-with-around-compile-hook ((c component) function)
     (call-around-hook (around-compile-hook c) function))
   (defun perform-lisp-compilation (o c)
+    "Perform the compilation of the Lisp file associated to the specified action (O . C)."
     (let (;; Before 2.26.53, that was unfortunately component-pathname. Now,
           ;; we consult input-files, the first of which should be the one to compile-file
           (input-file (first (input-files o c)))
-          ;; on some implementations, there are more than one output-file,
+          ;; On some implementations, there are more than one output-file,
           ;; but the first one should always be the primary fasl that gets loaded.
           (outputs (output-files o c)))
       (multiple-value-bind (output warnings-p failure-p)
@@ -8556,13 +9489,14 @@ in some previous image, or T if it needs to be done.")
                           (append
                            #+clisp (list :lib-file lib-file)
                            #+(or clasp ecl mkcl) (list :object-file object-file)
-                           flags (compile-op-flags o))))))
+                           flags)))))
         (check-lisp-compile-results output warnings-p failure-p
                                     "~/asdf-action::format-action/" (list (cons o c))))))
-
   (defun report-file-p (f)
+    "Is F a build report file containing, e.g., warnings to check?"
     (equalp (pathname-type f) "build-report"))
   (defun perform-lisp-warnings-check (o c)
+    "Check the warnings associated with the dependencies of an action."
     (let* ((expected-warnings-files (remove-if-not #'warnings-file-p (input-files o c)))
            (actual-warnings-files (loop :for w :in expected-warnings-files
                                         :when (get-file-stamp w)
@@ -8578,6 +9512,8 @@ in some previous image, or T if it needs to be done.")
   (defmethod perform ((o compile-op) (c cl-source-file))
     (perform-lisp-compilation o c))
   (defun lisp-compilation-output-files (o c)
+    "Compute the output-files for compiling the Lisp file for the specified action (O . C),
+an OPERATION and a COMPONENT."
     (let* ((i (first (input-files o c)))
            (f (compile-file-pathname
                i #+clasp :output-type #+ecl :type #+(or clasp ecl) :fasl
@@ -8599,6 +9535,8 @@ in some previous image, or T if it needs to be done.")
     (lisp-compilation-output-files o c))
   (defmethod perform ((o compile-op) (c static-file))
     nil)
+
+  ;; Performing compile-op on a system will check the deferred warnings for the system
   (defmethod perform ((o compile-op) (c system))
     (when (and *warnings-file-type* (not (builtin-system-p c)))
       (perform-lisp-warnings-check o c)))
@@ -8632,6 +9570,8 @@ in some previous image, or T if it needs to be done.")
                             (component-name c)))
           (perform (find-operation o 'compile-op) c)))))
   (defun perform-lisp-load-fasl (o c)
+    "Perform the loading of a FASL associated to specified action (O . C),
+an OPERATION and a COMPONENT."
     (if-let (fasl (first (input-files o c)))
       (load* fasl)))
   (defmethod perform ((o load-op) (c cl-source-file))
@@ -8658,6 +9598,7 @@ in some previous image, or T if it needs to be done.")
   (defmethod action-description ((o load-source-op) (c parent-component))
     (format nil (compatfmt "~@<Loaded source of ~3i~_~A~@:>") c))
   (defun perform-lisp-load-source (o c)
+    "Perform the loading of a Lisp file as associated to specified action (O . C)"
     (call-with-around-compile-hook
      c #'(lambda ()
            (load* (first (input-files o c))
@@ -8676,7 +9617,6 @@ in some previous image, or T if it needs to be done.")
   (defmethod operation-done-p ((o test-op) (c system))
     "Testing a system is _never_ done."
     nil))
-
 ;;;; -------------------------------------------------------------------------
 ;;;; Plan
 
@@ -8687,11 +9627,11 @@ in some previous image, or T if it needs to be done.")
    :asdf/cache :asdf/find-system :asdf/find-component
    :asdf/operation :asdf/action :asdf/lisp-action)
   (:export
-   #:component-operation-time #:mark-operation-done
+   #:component-operation-time
    #:plan #:plan-traversal #:sequential-plan #:*default-plan-class*
    #:planned-action-status #:plan-action-status #:action-already-done-p
    #:circular-dependency #:circular-dependency-actions
-   #:node-for #:needed-in-image-p
+   #:needed-in-image-p
    #:action-index #:action-planned-p #:action-valid-p
    #:plan-record-dependency
    #:normalize-forced-systems #:action-forced-p #:action-forced-not-p
@@ -8711,17 +9651,28 @@ in some previous image, or T if it needs to be done.")
 
 ;;;; Generic plan traversal class
 (with-upgradability ()
-  (defclass plan () ())
+  (defclass plan () ()
+    (:documentation "Base class for a plan based on which ASDF can build a system"))
   (defclass plan-traversal (plan)
-    ((system :initform nil :initarg :system :accessor plan-system)
+    (;; The system for which the plan is computed
+     (system :initform nil :initarg :system :accessor plan-system)
+     ;; Table of systems specified via :force arguments
      (forced :initform nil :initarg :force :accessor plan-forced)
+     ;; Table of systems specified via :force-not argument (and/or immutable)
      (forced-not :initform nil :initarg :force-not :accessor plan-forced-not)
+     ;; Counts of total actions in plan
      (total-action-count :initform 0 :accessor plan-total-action-count)
+     ;; Count of actions that need to be performed
      (planned-action-count :initform 0 :accessor plan-planned-action-count)
+     ;; Count of actions that need to be performed that have a non-empty list of output-files.
      (planned-output-action-count :initform 0 :accessor plan-planned-output-action-count)
+     ;; Table that to actions already visited while walking the dependencies associates status
      (visited-actions :initform (make-hash-table :test 'equal) :accessor plan-visited-actions)
-     (visiting-action-set :initform (make-hash-table :test 'equal) :accessor plan-visiting-action-set)
-     (visiting-action-list :initform () :accessor plan-visiting-action-list))))
+     ;; Actions that depend on those being currently walked through, to detect circularities
+     (visiting-action-set ;; as a set
+      :initform (make-hash-table :test 'equal) :accessor plan-visiting-action-set)
+     (visiting-action-list :initform () :accessor plan-visiting-action-list)) ;; as a list
+    (:documentation "Base class for plans that simply traverse dependencies")))
 
 
 ;;;; Planned action status
@@ -8751,12 +9702,8 @@ the action of OPERATION on COMPONENT in the PLAN"))
   (defmethod action-planned-p ((action-status t))
     t) ; default method for non planned-action-status objects
 
-  ;; TODO: eliminate NODE-FOR, use CONS.
-  ;; Supposes cleaner protocol for operation initargs passed to MAKE-OPERATION.
-  ;; However, see also component-operation-time and mark-operation-done
-  (defun node-for (o c) (cons (type-of o) c))
-
   (defun action-already-done-p (plan operation component)
+    "According to this plan, is this action already done and up to date?"
     (action-done-p (plan-action-status plan operation component)))
 
   (defmethod plan-action-status ((plan null) (o operation) (c component))
@@ -8764,38 +9711,50 @@ the action of OPERATION on COMPONENT in the PLAN"))
       (make-instance 'action-status :stamp stamp :done-p done-p)))
 
   (defmethod (setf plan-action-status) (new-status (plan null) (o operation) (c component))
-    (let ((to (type-of o))
-          (times (component-operation-times c)))
+    (let ((times (component-operation-times c)))
       (if (action-done-p new-status)
-          (remhash to times)
-          (setf (gethash to times) (action-stamp new-status))))
+          (remhash o times)
+          (setf (gethash o times) (action-stamp new-status))))
     new-status))
 
 
 ;;;; forcing
 (with-upgradability ()
-  (defgeneric action-forced-p (plan operation component))
-  (defgeneric action-forced-not-p (plan operation component))
-
-  (defun normalize-forced-systems (x system)
-    (etypecase x
-      ((or (member nil :all) hash-table function) x)
-      (cons (list-to-hash-set (mapcar #'coerce-name x)))
+  (defgeneric action-forced-p (plan operation component)
+    (:documentation "Is this action forced to happen in this plan?"))
+  (defgeneric action-forced-not-p (plan operation component)
+    (:documentation "Is this action forced to not happen in this plan?
+Takes precedence over action-forced-p."))
+
+  (defun normalize-forced-systems (force system)
+    "Given a SYSTEM on which operate is called and the specified FORCE argument,
+extract a hash-set of systems that are forced, or a predicate on system names,
+or NIL if none are forced, or :ALL if all are."
+    (etypecase force
+      ((or (member nil :all) hash-table function) force)
+      (cons (list-to-hash-set (mapcar #'coerce-name force)))
       ((eql t) (when system (list-to-hash-set (list (coerce-name system)))))))
 
-  (defun normalize-forced-not-systems (x system)
+  (defun normalize-forced-not-systems (force-not system)
+    "Given a SYSTEM on which operate is called, the specified FORCE-NOT argument,
+and the set of IMMUTABLE systems, extract a hash-set of systems that are effectively forced-not,
+or predicate on system names, or NIL if none are forced, or :ALL if all are."
     (let ((requested
-            (etypecase x
-              ((or (member nil :all) hash-table function) x)
-              (cons (list-to-hash-set (mapcar #'coerce-name x)))
+            (etypecase force-not
+              ((or (member nil :all) hash-table function) force-not)
+              (cons (list-to-hash-set (mapcar #'coerce-name force-not)))
               ((eql t) (if system (let ((name (coerce-name system)))
                                     #'(lambda (x) (not (equal x name))))
-                           t)))))
+                           :all)))))
       (if (and *immutable-systems* requested)
-          #'(lambda (x) (or (call-function requested x) (call-function *immutable-systems* x)))
+          #'(lambda (x) (or (call-function requested x)
+                            (call-function *immutable-systems* x)))
           (or *immutable-systems* requested))))
 
+  ;; TODO: shouldn't we be looking up the primary system name, rather than the system name?
   (defun action-override-p (plan operation component override-accessor)
+    "Given a plan, an action, and a function that given the plan accesses a set of overrides
+(i.e. force or force-not), see if the override applies to the current action."
     (declare (ignore operation))
     (call-function (funcall override-accessor plan)
                    (coerce-name (component-system (find-component () component)))))
@@ -8805,7 +9764,7 @@ the action of OPERATION on COMPONENT in the PLAN"))
      ;; Did the user ask us to re-perform the action?
      (action-override-p plan operation component 'plan-forced)
      ;; You really can't force a builtin system and :all doesn't apply to it,
-     ;; except it it's the specifically the system currently being built.
+     ;; except if it's the specifically the system currently being built.
      (not (let ((system (component-system component)))
             (and (builtin-system-p system)
                  (not (eq system (plan-system plan))))))))
@@ -8826,17 +9785,21 @@ the action of OPERATION on COMPONENT in the PLAN"))
 (with-upgradability ()
   (defgeneric action-valid-p (plan operation component)
     (:documentation "Is this action valid to include amongst dependencies?"))
+  ;; :if-feature will invalidate actions on components for which the features don't apply.
   (defmethod action-valid-p ((plan t) (o operation) (c component))
     (if-let (it (component-if-feature c)) (featurep it) t))
+  ;; If either the operation or component was resolved to nil, the action is invalid.
   (defmethod action-valid-p ((plan t) (o null) (c t)) nil)
   (defmethod action-valid-p ((plan t) (o t) (c null)) nil)
+  ;; If the plan is null, i.e., we're looking at reality,
+  ;; then any action with actual operation and component objects is valid.
   (defmethod action-valid-p ((plan null) (o operation) (c component)) t))
 
 ;;;; Is the action needed in this image?
 (with-upgradability ()
   (defgeneric needed-in-image-p (operation component)
-    (:documentation "Is the action of OPERATION on COMPONENT needed in the current image to be meaningful,
-    or could it just as well have been done in another Lisp image?"))
+    (:documentation "Is the action of OPERATION on COMPONENT needed in the current image
+to be meaningful, or could it just as well have been done in another Lisp image?"))
 
   (defmethod needed-in-image-p ((o operation) (c component))
     ;; We presume that actions that modify the filesystem don't need be run
@@ -8848,7 +9811,8 @@ the action of OPERATION on COMPONENT in the PLAN"))
 
 ;;;; Visiting dependencies of an action and computing action stamps
 (with-upgradability ()
-  (defun (map-direct-dependencies) (plan operation component fun)
+  (defun* (map-direct-dependencies) (plan operation component fun)
+    "Call FUN on all the valid dependencies of the given action in the given plan"
     (loop* :for (dep-o-spec . dep-c-specs) :in (component-depends-on operation component)
            :for dep-o = (find-operation operation dep-o-spec)
            :when dep-o
@@ -8857,15 +9821,19 @@ the action of OPERATION on COMPONENT in the PLAN"))
                      :when (and dep-c (action-valid-p plan dep-o dep-c))
                        :do (funcall fun dep-o dep-c))))
 
-  (defun (reduce-direct-dependencies) (plan operation component combinator seed)
+  (defun* (reduce-direct-dependencies) (plan operation component combinator seed)
+    "Reduce the direct dependencies to a value computed by iteratively calling COMBINATOR
+for each dependency action on the dependency's operation and component and an accumulator
+initialized with SEED."
     (map-direct-dependencies
      plan operation component
      #'(lambda (dep-o dep-c)
          (setf seed (funcall combinator dep-o dep-c seed))))
     seed)
 
-  (defun (direct-dependencies) (plan operation component)
-    (reduce-direct-dependencies plan operation component #'acons nil))
+  (defun* (direct-dependencies) (plan operation component)
+    "Compute a list of the direct dependencies of the action within the plan"
+    (reverse (reduce-direct-dependencies plan operation component #'acons nil)))
 
   ;; In a distant future, get-file-stamp, component-operation-time and latest-stamp
   ;; shall also be parametrized by the plan, or by a second model object,
@@ -8883,7 +9851,8 @@ the action of OPERATION on COMPONENT in the PLAN"))
     ;;   in the current image, or NIL if it hasn't.
     ;; Note that if e.g. LOAD-OP only depends on up-to-date files, but
     ;; hasn't been done in the current image yet, then it can have a non-T timestamp,
-    ;; yet a NIL done-in-image-p flag.
+    ;; yet a NIL done-in-image-p flag: we can predict what timestamp it will have once loaded,
+    ;; i.e. that of the input-files.
     (nest
      (block ())
      (let ((dep-stamp ; collect timestamp from dependencies (or T if forced or out-of-date)
@@ -8944,11 +9913,6 @@ the action of OPERATION on COMPONENT in the PLAN"))
 
 ;;;; Generic support for plan-traversal
 (with-upgradability ()
-  (defgeneric plan-record-dependency (plan operation component))
-
-  (defgeneric call-while-visiting-action (plan operation component function)
-    (:documentation "Detect circular dependencies"))
-
   (defmethod initialize-instance :after ((plan plan-traversal)
                                          &key force force-not system
                                          &allow-other-keys)
@@ -8956,20 +9920,40 @@ the action of OPERATION on COMPONENT in the PLAN"))
       (setf forced (normalize-forced-systems force system))
       (setf forced-not (normalize-forced-not-systems force-not system))))
 
-  (defmethod (setf plan-action-status) (new-status (plan plan-traversal) (o operation) (c component))
-    (setf (gethash (node-for o c) (plan-visited-actions plan)) new-status))
+  (defgeneric plan-actions (plan)
+    (:documentation "Extract from a plan a list of actions to perform in sequence"))
+  (defmethod plan-actions ((plan list))
+    plan)
+
+  (defmethod (setf plan-action-status) (new-status (p plan-traversal) (o operation) (c component))
+    (setf (gethash (cons o c) (plan-visited-actions p)) new-status))
+
+  (defmethod plan-action-status ((p plan-traversal) (o operation) (c component))
+    (or (and (action-forced-not-p p o c) (plan-action-status nil o c))
+        (values (gethash (cons o c) (plan-visited-actions p)))))
 
-  (defmethod plan-action-status ((plan plan-traversal) (o operation) (c component))
-    (or (and (action-forced-not-p plan o c) (plan-action-status nil o c))
-        (values (gethash (node-for o c) (plan-visited-actions plan)))))
+  (defmethod action-valid-p ((p plan-traversal) (o operation) (s system))
+    (and (not (action-forced-not-p p o s)) (call-next-method)))
+
+  (defgeneric plan-record-dependency (plan operation component)
+    (:documentation "Record an action as a dependency in the current plan")))
+
+
+;;;; Detection of circular dependencies
+(with-upgradability ()
+  (define-condition circular-dependency (system-definition-error)
+    ((actions :initarg :actions :reader circular-dependency-actions))
+    (:report (lambda (c s)
+               (format s (compatfmt "~@<Circular dependency: ~3i~_~S~@:>")
+                       (circular-dependency-actions c)))))
 
-  (defmethod action-valid-p ((plan plan-traversal) (o operation) (s system))
-    (and (not (action-forced-not-p plan o s)) (call-next-method)))
+  (defgeneric call-while-visiting-action (plan operation component function)
+    (:documentation "Detect circular dependencies"))
 
   (defmethod call-while-visiting-action ((plan plan-traversal) operation component fun)
     (with-accessors ((action-set plan-visiting-action-set)
                      (action-list plan-visiting-action-list)) plan
-      (let ((action (cons operation component)))
+      (let ((action (make-action operation component)))
         (when (gethash action action-set)
           (error 'circular-dependency :actions
                  (member action (reverse action-list) :test 'equal)))
@@ -8978,20 +9962,15 @@ the action of OPERATION on COMPONENT in the PLAN"))
         (unwind-protect
              (funcall fun)
           (pop action-list)
-          (setf (gethash action action-set) nil))))))
+          (setf (gethash action action-set) nil)))))
+
+  ;; Syntactic sugar for call-while-visiting-action
+  (defmacro while-visiting-action ((p o c) &body body)
+    `(call-while-visiting-action ,p ,o ,c #'(lambda () ,@body))))
 
 
 ;;;; Actual traversal: traverse-action
 (with-upgradability ()
-  (define-condition circular-dependency (system-definition-error)
-    ((actions :initarg :actions :reader circular-dependency-actions))
-    (:report (lambda (c s)
-               (format s (compatfmt "~@<Circular dependency: ~3i~_~S~@:>")
-                       (circular-dependency-actions c)))))
-
-  (defmacro while-visiting-action ((p o c) &body body)
-    `(call-while-visiting-action ,p ,o ,c #'(lambda () ,@body)))
-
   (defgeneric traverse-action (plan operation component needed-in-image-p))
 
   ;; TRAVERSE-ACTION, in the context of a given PLAN object that accumulates dependency data,
@@ -9058,33 +10037,35 @@ the action of OPERATION on COMPONENT in the PLAN"))
 ;;;; Sequential plans (the default)
 (with-upgradability ()
   (defclass sequential-plan (plan-traversal)
-    ((actions-r :initform nil :accessor plan-actions-r)))
+    ((actions-r :initform nil :accessor plan-actions-r))
+    (:documentation "Simplest, default plan class, accumulating a sequence of actions"))
 
-  (defgeneric plan-actions (plan))
-  (defmethod plan-actions ((plan list))
-    plan)
   (defmethod plan-actions ((plan sequential-plan))
     (reverse (plan-actions-r plan)))
 
+  ;; No need to record a dependency to build a full graph, just accumulate nodes in order.
   (defmethod plan-record-dependency ((plan sequential-plan) (o operation) (c component))
     (values))
 
   (defmethod (setf plan-action-status) :after
       (new-status (p sequential-plan) (o operation) (c component))
     (when (action-planned-p new-status)
-      (push (cons o c) (plan-actions-r p)))))
+      (push (make-action o c) (plan-actions-r p)))))
+
 
 ;;;; High-level interface: traverse, perform-plan, plan-operates-on-p
 (with-upgradability ()
   (defgeneric make-plan (plan-class operation component &key &allow-other-keys)
-    (:documentation
-     "Generate and return a plan for performing OPERATION on COMPONENT."))
+    (:documentation "Generate and return a plan for performing OPERATION on COMPONENT."))
   (define-convenience-action-methods make-plan (plan-class operation component &key))
 
-  (defgeneric perform-plan (plan &key))
-  (defgeneric plan-operates-on-p (plan component))
+  (defgeneric perform-plan (plan &key)
+    (:documentation "Actually perform a plan and build the requested actions"))
+  (defgeneric plan-operates-on-p (plan component)
+    (:documentation "Does this PLAN include any operation on given COMPONENT?"))
 
-  (defvar *default-plan-class* 'sequential-plan)
+  (defvar *default-plan-class* 'sequential-plan
+    "The default plan class to use when building with ASDF")
 
   (defmethod make-plan (plan-class (o operation) (c component) &rest keys &key &allow-other-keys)
     (let ((plan (apply 'make-instance (or plan-class *default-plan-class*)
@@ -9103,7 +10084,9 @@ the action of OPERATION on COMPONENT in the PLAN"))
     (apply 'perform-plan (plan-actions plan) keys))
 
   (defmethod perform-plan ((steps list) &key force &allow-other-keys)
-    (loop* :for (o . c) :in steps
+    (loop* :for action :in steps
+           :as o = (action-operation action)
+           :as c = (action-component action)
            :when (or force (not (nth-value 1 (compute-action-stamp nil o c))))
            :do (perform-with-restarts o c)))
 
@@ -9111,7 +10094,7 @@ the action of OPERATION on COMPONENT in the PLAN"))
     (plan-operates-on-p (plan-actions plan) component-path))
 
   (defmethod plan-operates-on-p ((plan list) (component-path list))
-    (find component-path (mapcar 'cdr plan)
+    (find component-path (mapcar 'action-component plan)
           :test 'equal :key 'component-find-path)))
 
 
@@ -9124,12 +10107,16 @@ the action of OPERATION on COMPONENT in the PLAN"))
     ((action-filter :initform t :initarg :action-filter :reader plan-action-filter)
      (component-type :initform t :initarg :component-type :reader plan-component-type)
      (keep-operation :initform t :initarg :keep-operation :reader plan-keep-operation)
-     (keep-component :initform t :initarg :keep-component :reader plan-keep-component)))
+     (keep-component :initform t :initarg :keep-component :reader plan-keep-component))
+    (:documentation "A variant of SEQUENTIAL-PLAN that only records a subset of actions."))
 
   (defmethod initialize-instance :after ((plan filtered-sequential-plan)
                                          &key force force-not
-                                           other-systems)
+                                         other-systems)
     (declare (ignore force force-not))
+    ;; Ignore force and force-not, rely on other-systems:
+    ;; force traversal of what we're interested in, i.e. current system or also others;
+    ;; force-not traversal of what we're not interested in, i.e. other systems unless other-systems.
     (with-slots (forced forced-not action-filter system) plan
       (setf forced (normalize-forced-systems (if other-systems :all t) system))
       (setf forced-not (normalize-forced-not-systems (if other-systems nil t) system))
@@ -9140,11 +10127,16 @@ the action of OPERATION on COMPONENT in the PLAN"))
          (typep c (plan-component-type plan))
          (call-next-method)))
 
-  (defmethod traverse-actions (actions &rest keys &key plan-class &allow-other-keys)
+  (defun* (traverse-actions) (actions &rest keys &key plan-class &allow-other-keys)
+    "Given a list of actions, build a plan with these actions as roots."
     (let ((plan (apply 'make-instance (or plan-class 'filtered-sequential-plan) keys)))
-      (loop* :for (o . c) :in actions :do (traverse-action plan o c t))
+      (loop* :for action :in actions
+             :as o = (action-operation action)
+             :as c = (action-component action)
+             :do (traverse-action plan o c t))
       plan))
 
+  (defgeneric traverse-sub-actions (operation component &key &allow-other-keys))
   (define-convenience-action-methods traverse-sub-actions (operation component &key))
   (defmethod traverse-sub-actions ((operation operation) (component component)
                                    &rest keys &key &allow-other-keys)
@@ -9153,15 +10145,20 @@ the action of OPERATION on COMPONENT in the PLAN"))
 
   (defmethod plan-actions ((plan filtered-sequential-plan))
     (with-slots (keep-operation keep-component) plan
-      (loop* :for (o . c) :in (call-next-method)
+      (loop* :for action :in (call-next-method)
+             :as o = (action-operation action)
+             :as c = (action-component action)
              :when (and (typep o keep-operation) (typep c keep-component))
-             :collect (cons o c))))
+             :collect (make-action o c))))
 
-  (defmethod required-components (system &rest keys &key (goal-operation 'load-op) &allow-other-keys)
+  (defun* (required-components) (system &rest keys &key (goal-operation 'load-op) &allow-other-keys)
+    "Given a SYSTEM and a GOAL-OPERATION (default LOAD-OP), traverse the dependencies and
+return a list of the components involved in building the desired action."
     (remove-duplicates
-     (mapcar 'cdr (plan-actions
-                   (apply 'traverse-sub-actions goal-operation system
-                          (remove-plist-key :goal-operation keys))))
+     (mapcar 'action-component
+             (plan-actions
+              (apply 'traverse-sub-actions goal-operation system
+                     (remove-plist-key :goal-operation keys))))
      :from-end t)))
 
 ;;;; -------------------------------------------------------------------------
@@ -9174,7 +10171,6 @@ the action of OPERATION on COMPONENT in the PLAN"))
    :asdf/find-system :asdf/find-component :asdf/lisp-action :asdf/plan)
   (:export
    #:operate #:oos
-   #:*systems-being-operated*
    #:build-op #:make
    #:load-system #:load-systems #:load-systems*
    #:compile-system #:test-system #:require-system
@@ -9183,72 +10179,75 @@ the action of OPERATION on COMPONENT in the PLAN"))
 (in-package :asdf/operate)
 
 (with-upgradability ()
-  (defgeneric* (operate) (operation component &key &allow-other-keys)
+  (defgeneric operate (operation component &key &allow-other-keys)
     (:documentation
-     "Operate does three things:
+     "Operate does mainly four things for the user:
 
-1. It creates an instance of OPERATION-CLASS using any keyword parameters as initargs.
-2. It finds the  asdf-system specified by SYSTEM (possibly loading it from disk).
-3. It then calls MAKE-PLAN with the operation and system as arguments
+1. Resolves the OPERATION designator into an operation object.
+   OPERATION is typically a symbol denoting an operation class, instantiated with MAKE-OPERATION.
+2. Resolves the COMPONENT designator into a component object.
+   COMPONENT is typically a string or symbol naming a system, loaded from disk using FIND-SYSTEM.
+3. It then calls MAKE-PLAN with the operation and system as arguments.
+4. Finally calls PERFORM-PLAN on the resulting plan to actually build the system.
 
-The operation of making a plan is wrapped in WITH-COMPILATION-UNIT and error
-handling code.  If a VERSION argument is supplied, then operate also ensures
-that the system found satisfies it using the VERSION-SATISFIES method.
-
-Note that dependencies may cause the operation to invoke other operations on the system
-or its components: the new operations will be created with the same initargs as the original one.
+The entire computation is wrapped in WITH-COMPILATION-UNIT and error handling code.
+If a VERSION argument is supplied, then operate also ensures that the system found satisfies it
+using the VERSION-SATISFIES method.
+If a PLAN-CLASS argument is supplied, that class is used for the plan.
 
 The :FORCE or :FORCE-NOT argument to OPERATE can be:
   T to force the inside of the specified system to be rebuilt (resp. not),
     without recursively forcing the other systems we depend on.
   :ALL to force all systems including other systems we depend on to be rebuilt (resp. not).
   (SYSTEM1 SYSTEM2 ... SYSTEMN) to force systems named in a given list
-:FORCE has precedence over :FORCE-NOT; builtin systems cannot be forced."))
+:FORCE-NOT has precedence over :FORCE; builtin systems cannot be forced.
+
+For backward compatibility, all keyword arguments are passed to MAKE-OPERATION
+when instantiating a new operation, that will in turn be inherited by new operations.
+But do NOT depend on it, for this is deprecated behavior."))
 
-  (define-convenience-action-methods
-      operate (operation component &key)
-      ;; I'd like to at least remove-plist-keys :force :force-not :verbose,
-      ;; but swank.asd relies on :force (!).
-      :operation-initargs t ;; backward-compatibility with ASDF1. Yuck.
-      :if-no-component (error 'missing-component :requires component))
+  (define-convenience-action-methods operate (operation component &key)
+    :if-no-component (error 'missing-component :requires component))
 
-  (defvar *systems-being-operated* nil
-    "A boolean indicating that some systems are being operated on")
+  (defvar *in-operate* nil
+    "Are we in operate?")
 
+  ;; This method ensures that an ASDF upgrade is attempted as the very first thing,
+  ;; with suitable state preservation in case in case it actually happens,
+  ;; and that a few suitable dynamic bindings are established.
   (defmethod operate :around (operation component &rest keys
                               &key verbose
                                 (on-warnings *compile-file-warnings-behaviour*)
                                 (on-failure *compile-file-failure-behaviour*) &allow-other-keys)
-    (let* ((systems-being-operated *systems-being-operated*)
-           (*systems-being-operated* (or systems-being-operated (make-hash-table :test 'equal)))
+    (nest
+     (with-asdf-cache ())
+     (let ((in-operate *in-operate*)
+           (*in-operate* t)
            (operation-remaker ;; how to remake the operation after ASDF was upgraded (if it was)
-             (etypecase operation
-               (operation (let ((name (type-of operation))
-                                (initargs (operation-original-initargs operation)))
-                            #'(lambda () (apply 'make-operation name :original-initargs initargs initargs))))
-               ((or symbol string) (constantly operation))))
+            (etypecase operation
+              (operation (let ((name (type-of operation)))
+                           #'(lambda () (make-operation name))))
+              ((or symbol string) (constantly operation))))
            (component-path (typecase component ;; to remake the component after ASDF upgrade
                              (component (component-find-path component))
-                             (t component))))
-      ;; Before we operate on any system, make sure ASDF is up-to-date,
-      ;; for if an upgrade is ever attempted at any later time, there may be BIG trouble.
-      (unless systems-being-operated
-        (when (upgrade-asdf)
-          ;; If we were upgraded, restart OPERATE the hardest of ways, for
-          ;; its function may have been redefined, its symbol uninterned, its package deleted.
-          (return-from operate
-            (apply 'operate (funcall operation-remaker) component-path keys))))
+                             (t component)))))
+     ;; Before we operate on any system, make sure ASDF is up-to-date,
+     ;; for if an upgrade is ever attempted at any later time, there may be BIG trouble.
+     (progn
+       (unless in-operate
+         (when (upgrade-asdf)
+           ;; If we were upgraded, restart OPERATE the hardest of ways, for
+           ;; its function may have been redefined.
+           (return-from operate
+             (apply 'operate (funcall operation-remaker) component-path keys)))))
       ;; Setup proper bindings around any operate call.
-      (with-asdf-cache ()
-        (let* ((*verbose-out* (and verbose *standard-output*))
-               (*compile-file-warnings-behaviour* on-warnings)
-               (*compile-file-failure-behaviour* on-failure))
-          (call-next-method)))))
+     (let* ((*verbose-out* (and verbose *standard-output*))
+            (*compile-file-warnings-behaviour* on-warnings)
+            (*compile-file-failure-behaviour* on-failure))
+       (call-next-method))))
 
   (defmethod operate :before ((operation operation) (component component)
                               &key version &allow-other-keys)
-    (let ((system (component-system component)))
-      (setf (gethash (coerce-name system) *systems-being-operated*) system))
     (unless (version-satisfies component version)
       (error 'missing-component-of-version :requires component :version version)))
 
@@ -9270,15 +10269,16 @@ The :FORCE or :FORCE-NOT argument to OPERATE can be:
 (with-upgradability ()
   (defvar *load-system-operation* 'load-op
     "Operation used by ASDF:LOAD-SYSTEM. By default, ASDF:LOAD-OP.
-You may override it with e.g. ASDF:LOAD-FASL-OP from asdf-bundle
+You may override it with e.g. ASDF:LOAD-BUNDLE-OP from asdf/bundle
 or ASDF:LOAD-SOURCE-OP if your fasl loading is somehow broken.
 
 The default operation may change in the future if we implement a
 component-directed strategy for how to load or compile systems.")
 
+  ;; In prepare-op for a system, propagate *load-system-operation* rather than load-op
   (defmethod component-depends-on ((o prepare-op) (s system))
-    (loop :for (o . cs) :in (call-next-method)
-          :collect (cons (if (eq o 'load-op) *load-system-operation* o) cs)))
+    (loop :for (do . dc) :in (call-next-method)
+          :collect (cons (if (eq do 'load-op) *load-system-operation* do) dc)))
 
   (defclass build-op (non-propagating-operation) ()
     (:documentation "Since ASDF3, BUILD-OP is the recommended 'master' operation,
@@ -9331,21 +10331,26 @@ to load it in current image."
 ;; only tries to load its specified target if it's not loaded yet.
 (with-upgradability ()
   (defun component-loaded-p (component)
-    "has given COMPONENT been successfully loaded in the current image (yet)?"
-    (action-already-done-p nil (make-instance 'load-op) (find-component component ())))
+    "Has the given COMPONENT been successfully loaded in the current image (yet)?
+Note that this returns true even if the component is not up to date."
+    (if-let ((component (find-component component () :registered t)))
+      (action-already-done-p nil (make-operation 'load-op) component)))
 
   (defun already-loaded-systems ()
     "return a list of the names of the systems that have been successfully loaded so far"
     (mapcar 'coerce-name (remove-if-not 'component-loaded-p (registered-systems*))))
 
   (defun require-system (system &rest keys &key &allow-other-keys)
-    "Ensure the specified SYSTEM is loaded, passing the KEYS to OPERATE, but skip any update to the
+    "Ensure the specified SYSTEM is loaded, passing the KEYS to OPERATE, but do not update the
 system or its dependencies if they have already been loaded."
-    (apply 'load-system system :force-not (already-loaded-systems) keys)))
+    (unless (component-loaded-p system)
+      (apply 'load-system system :force-not (already-loaded-systems) keys))))
 
 
 ;;;; Define the class REQUIRE-SYSTEM, to be hooked into CL:REQUIRE when possible,
 ;; i.e. for ABCL, CLISP, ClozureCL, CMUCL, ECL, MKCL and SBCL
+;; Note that despite the two being homonyms, the _function_ require-system
+;; and the _class_ require-system are quite distinct entities, fulfilling independent purposes.
 (with-upgradability ()
   (defvar *modules-being-required* nil)
 
@@ -9361,24 +10366,36 @@ the implementation's REQUIRE rather than by internal ASDF mechanisms."))
     (let* ((module (or (required-module s) (coerce-name s)))
            (*modules-being-required* (cons module *modules-being-required*)))
       (assert (null (component-children s)))
-      (require module)))
+      ;; CMUCL likes its module names to be all upcase.
+      (require (nest #+cmucl (string-upcase) module))))
 
   (defmethod resolve-dependency-combination (component (combinator (eql :require)) arguments)
-    (unless (length=n-p arguments 1)
-      (error (compatfmt "~@<Bad dependency ~S for ~S. ~S takes only one argument~@:>")
-             (cons combinator arguments) component combinator))
-    (let* ((module (car arguments))
+    (unless (and (length=n-p arguments 1)
+                 (typep (car arguments) '(or string (and symbol (not null)))))
+      (parameter-error (compatfmt "~@<In ~S, bad dependency ~S for ~S. ~S takes one argument, a string or non-null symbol~@:>")
+                       'resolve-dependency-combination
+                       (cons combinator arguments) component combinator))
+    ;; :require must be prepared for some implementations providing modules using ASDF,
+    ;; as SBCL used to do, and others may might do. Thus, the system provided in the end
+    ;; would be a downcased name as per module-provide-asdf above. For the same reason,
+    ;; we cannot assume that the system in the end will be of type require-system,
+    ;; but must check whether we can use find-system and short-circuit cl:require.
+    ;; Otherwise, calling cl:require could result in nasty reentrant calls between
+    ;; cl:require and asdf:operate that could potentially blow up the stack,
+    ;; all the while defeating the consistency of the dependency graph.
+    (let* ((module (car arguments)) ;; NB: we already checked that it was not null
            (name (string-downcase module))
            (system (find-system name nil)))
-      (assert module)
-      ;;(unless (typep system '(or null require-system))
-      ;;  (warn "~S depends on ~S but ~S is registered as a ~S"
-      ;;        component (cons combinator arguments) module (type-of system)))
       (or system (let ((system (make-instance 'require-system :name name)))
                    (register-system system)
                    system))))
 
   (defun module-provide-asdf (name)
+    ;; We must use string-downcase, because modules are traditionally specified as symbols,
+    ;; that implementations traditionally normalize as uppercase, for which we seek a system
+    ;; with a name that is traditionally in lowercase. Case is lost along the way. That's fine.
+    ;; We could make complex, non-portable rules to try to preserve case, and just documenting
+    ;; them would be a hell that it would be a disservice to inflict on users.
     (let ((module (string-downcase name)))
       (unless (member module *modules-being-required* :test 'equal)
         (let ((*modules-being-required* (cons module *modules-being-required*))
@@ -9386,9 +10403,10 @@ the implementation's REQUIRE rather than by internal ASDF mechanisms."))
           (handler-bind
               ((style-warning #'muffle-warning)
                (missing-component (constantly nil))
-               (error #'(lambda (e)
-                          (format *error-output* (compatfmt "~@<ASDF could not load ~(~A~) because ~A.~@:>~%")
-                                  name e))))
+               (fatal-condition
+                #'(lambda (e)
+                    (format *error-output* (compatfmt "~@<ASDF could not load ~(~A~) because ~A.~@:>~%")
+                            name e))))
             (let ((*verbose-out* (make-broadcast-stream)))
               (let ((system (find-system module nil)))
                 (when system
@@ -9400,1653 +10418,1741 @@ the implementation's REQUIRE rather than by internal ASDF mechanisms."))
 (with-upgradability ()
   (defun restart-upgraded-asdf ()
     ;; If we're in the middle of something, restart it.
-    (when *asdf-cache*
-      (let ((l (loop :for k :being :the hash-keys :of *asdf-cache*
-                     :when (eq (first k) 'find-system) :collect (second k))))
-        (clrhash *asdf-cache*)
-        (dolist (s l) (find-system s nil)))))
-  (register-hook-function '*post-upgrade-restart-hook* 'restart-upgraded-asdf))
+    (let ((systems-being-defined
+           (when *asdf-cache*
+             (prog1
+                 (loop :for k :being :the hash-keys :of *asdf-cache*
+                   :when (eq (first k) 'find-system) :collect (second k))
+               (clrhash *asdf-cache*)))))
+      ;; Regardless, clear defined systems, since they might be invalid
+      ;; after an incompatible ASDF upgrade.
+      (clear-defined-systems)
+      ;; The configuration also may have to be upgraded.
+      (upgrade-configuration)
+      ;; If we were in the middle of an operation, be sure to restore the system being defined.
+      (dolist (s systems-being-defined) (find-system s nil))))
+  (register-hook-function '*post-upgrade-cleanup-hook* 'restart-upgraded-asdf)
+
+  ;; The following function's symbol is from asdf/find-system.
+  ;; It is defined here to resolve what would otherwise be forward package references.
+  (defun mark-component-preloaded (component)
+    "Mark a component as preloaded."
+    (let ((component (find-component component nil :registered t)))
+      ;; Recurse to children, so asdf/plan will hopefully be happy.
+      (map () 'mark-component-preloaded (component-children component))
+      ;; Mark the timestamps of the common lisp-action operations as 0.
+      (let ((times (component-operation-times component)))
+        (dolist (o '(load-op compile-op prepare-op))
+          (setf (gethash (make-operation o) times) 0))))))
 
+;;;; -------------------------------------------------------------------------
+;;;; Defsystem
 
-;;;; ---------------------------------------------------------------------------
-;;;; asdf-output-translations
-
-(uiop/package:define-package :asdf/output-translations
-  (:recycle :asdf/output-translations :asdf)
-  (:use :uiop/common-lisp :uiop :asdf/upgrade)
+(uiop/package:define-package :asdf/parse-defsystem
+  (:recycle :asdf/parse-defsystem :asdf/defsystem :asdf)
+  (:nicknames :asdf/defsystem) ;; previous name, to be compatible with, in case anyone cares
+  (:use :uiop/common-lisp :asdf/driver :asdf/upgrade
+   :asdf/cache :asdf/component :asdf/system
+   :asdf/find-system :asdf/find-component :asdf/action :asdf/lisp-action :asdf/operate)
+  (:import-from :asdf/system #:depends-on #:weakly-depends-on)
   (:export
-   #:*output-translations* #:*output-translations-parameter*
-   #:invalid-output-translation
-   #:output-translations #:output-translations-initialized-p
-   #:initialize-output-translations #:clear-output-translations
-   #:disable-output-translations #:ensure-output-translations
-   #:apply-output-translations
-   #:validate-output-translations-directive #:validate-output-translations-form
-   #:validate-output-translations-file #:validate-output-translations-directory
-   #:parse-output-translations-string #:wrapping-output-translations
-   #:user-output-translations-pathname #:system-output-translations-pathname
-   #:user-output-translations-directory-pathname #:system-output-translations-directory-pathname
-   #:environment-output-translations #:process-output-translations
-   #:compute-output-translations
-   #+abcl #:translate-jar-pathname
-   ))
-(in-package :asdf/output-translations)
+   #:defsystem #:register-system-definition
+   #:class-for-type #:*default-component-class*
+   #:determine-system-directory #:parse-component-form
+   #:non-toplevel-system #:non-system-system #:bad-system-name
+   #:sysdef-error-component #:check-component-input))
+(in-package :asdf/parse-defsystem)
+
+;;; Pathname
+(with-upgradability ()
+  (defun determine-system-directory (pathname)
+    ;; The defsystem macro calls this function to determine the pathname of a system as follows:
+    ;; 1. If the pathname argument is an pathname object (NOT a namestring),
+    ;;    that is already an absolute pathname, return it.
+    ;; 2. Otherwise, the directory containing the LOAD-PATHNAME
+    ;;    is considered (as deduced from e.g. *LOAD-PATHNAME*), and
+    ;;    if it is indeed available and an absolute pathname, then
+    ;;    the PATHNAME argument is normalized to a relative pathname
+    ;;    as per PARSE-UNIX-NAMESTRING (with ENSURE-DIRECTORY T)
+    ;;    and merged into that DIRECTORY as per SUBPATHNAME.
+    ;;    Note: avoid *COMPILE-FILE-PATHNAME* because the .asd is loaded as source,
+    ;;    but may be from within the EVAL-WHEN of a file compilation.
+    ;; If no absolute pathname was found, we return NIL.
+    (check-type pathname (or null string pathname))
+    (pathname-directory-pathname
+     (resolve-symlinks*
+      (ensure-absolute-pathname
+       (parse-unix-namestring pathname :type :directory)
+       #'(lambda () (ensure-absolute-pathname
+                     (load-pathname) 'get-pathname-defaults nil))
+       nil)))))
 
-(when-upgrading () (undefine-function '(setf output-translations)))
 
+;;; Component class
 (with-upgradability ()
-  (define-condition invalid-output-translation (invalid-configuration warning)
-    ((format :initform (compatfmt "~@<Invalid asdf output-translation ~S~@[ in ~S~]~@{ ~@?~}~@:>"))))
+  ;; What :file gets interpreted as, unless overridden by a :default-component-class
+  (defvar *default-component-class* 'cl-source-file)
 
-  (defvar *output-translations* ()
-    "Either NIL (for uninitialized), or a list of one element,
-said element itself being a sorted list of mappings.
-Each mapping is a pair of a source pathname and destination pathname,
-and the order is by decreasing length of namestring of the source pathname.")
+  (defun class-for-type (parent type)
+      (or (coerce-class type :package :asdf/interface :super 'component :error nil)
+          (and (eq type :file)
+               (coerce-class
+                (or (loop :for p = parent :then (component-parent p) :while p
+                      :thereis (module-default-component-class p))
+                    *default-component-class*)
+                :package :asdf/interface :super 'component :error nil))
+          (sysdef-error "don't recognize component type ~S" type))))
 
-  (defun output-translations ()
-    (car *output-translations*))
 
-  (defun set-output-translations (new-value)
-    (setf *output-translations*
-          (list
-           (stable-sort (copy-list new-value) #'>
-                        :key #'(lambda (x)
-                                 (etypecase (car x)
-                                   ((eql t) -1)
-                                   (pathname
-                                    (let ((directory (pathname-directory (car x))))
-                                      (if (listp directory) (length directory) 0))))))))
-    new-value)
-  (defun* ((setf output-translations)) (new-value) (set-output-translations new-value))
+;;; Check inputs
+(with-upgradability ()
+  (define-condition non-system-system (system-definition-error)
+    ((name :initarg :name :reader non-system-system-name)
+     (class-name :initarg :class-name :reader non-system-system-class-name))
+    (:report (lambda (c s)
+               (format s (compatfmt "~@<Error while defining system ~S: class ~S isn't a subclass of ~S~@:>")
+                       (non-system-system-name c) (non-system-system-class-name c) 'system))))
 
-  (defun output-translations-initialized-p ()
-    (and *output-translations* t))
+  (define-condition non-toplevel-system (system-definition-error)
+    ((parent :initarg :parent :reader non-toplevel-system-parent)
+     (name :initarg :name :reader non-toplevel-system-name))
+    (:report (lambda (c s)
+               (format s (compatfmt "~@<Error while defining system: component ~S claims to have a system ~S as a child~@:>")
+                       (non-toplevel-system-parent c) (non-toplevel-system-name c)))))
 
-  (defun clear-output-translations ()
-    "Undoes any initialization of the output translations."
-    (setf *output-translations* '())
-    (values))
-  (register-clear-configuration-hook 'clear-output-translations)
+  (define-condition bad-system-name (warning)
+    ((name :initarg :name :reader component-name)
+     (source-file :initarg :source-file :reader system-source-file))
+    (:report (lambda (c s)
+               (let* ((file (system-source-file c))
+                      (name (component-name c))
+                      (asd (pathname-name file)))
+                 (format s (compatfmt "~@<System definition file ~S contains definition for system ~S. ~
+Please only define ~S and secondary systems with a name starting with ~S (e.g. ~S) in that file.~@:>")
+                       file name asd (strcat asd "/") (strcat asd "/test"))))))
 
-  (defun validate-output-translations-directive (directive)
-    (or (member directive '(:enable-user-cache :disable-cache nil))
-        (and (consp directive)
-             (or (and (length=n-p directive 2)
-                      (or (and (eq (first directive) :include)
-                               (typep (second directive) '(or string pathname null)))
-                          (and (location-designator-p (first directive))
-                               (or (location-designator-p (second directive))
-                                   (location-function-p (second directive))))))
-                 (and (length=n-p directive 1)
-                      (location-designator-p (first directive)))))))
+  (defun sysdef-error-component (msg type name value)
+    (sysdef-error (strcat msg (compatfmt "~&~@<The value specified for ~(~A~) ~A is ~S~@:>"))
+                  type name value))
 
-  (defun validate-output-translations-form (form &key location)
-    (validate-configuration-form
-     form
-     :output-translations
-     'validate-output-translations-directive
-     :location location :invalid-form-reporter 'invalid-output-translation))
+  (defun check-component-input (type name weakly-depends-on
+                                depends-on components)
+    "A partial test of the values of a component."
+    (unless (listp depends-on)
+      (sysdef-error-component ":depends-on must be a list."
+                              type name depends-on))
+    (unless (listp weakly-depends-on)
+      (sysdef-error-component ":weakly-depends-on must be a list."
+                              type name weakly-depends-on))
+    (unless (listp components)
+      (sysdef-error-component ":components must be NIL or a list of components."
+                              type name components)))
 
-  (defun validate-output-translations-file (file)
-    (validate-configuration-file
-     file 'validate-output-translations-form :description "output translations"))
+  ;; Given a form used as :version specification, in the context of a system definition
+  ;; in a file at PATHNAME, for given COMPONENT with given PARENT, normalize the form
+  ;; to an acceptable ASDF-format version.
+  (defun* (normalize-version) (form &key pathname component parent)
+    (labels ((invalid (&optional (continuation "using NIL instead"))
+               (warn (compatfmt "~@<Invalid :version specifier ~S~@[ for component ~S~]~@[ in ~S~]~@[ from file ~S~]~@[, ~A~]~@:>")
+                     form component parent pathname continuation))
+             (invalid-parse (control &rest args)
+               (unless (if-let (target (find-component parent component)) (builtin-system-p target))
+                 (apply 'warn control args)
+                 (invalid))))
+      (if-let (v (typecase form
+                   ((or string null) form)
+                   (real
+                    (invalid "Substituting a string")
+                    (format nil "~D" form)) ;; 1.0 becomes "1.0"
+                   (cons
+                    (case (first form)
+                      ((:read-file-form)
+                       (destructuring-bind (subpath &key (at 0)) (rest form)
+                         (safe-read-file-form (subpathname pathname subpath)
+                                              :at at :package :asdf-user)))
+                      ((:read-file-line)
+                       (destructuring-bind (subpath &key (at 0)) (rest form)
+                         (safe-read-file-line (subpathname pathname subpath)
+                                              :at at)))
+                      (otherwise
+                       (invalid))))
+                   (t
+                    (invalid))))
+        (if-let (pv (parse-version v #'invalid-parse))
+          (unparse-version pv)
+          (invalid))))))
 
-  (defun validate-output-translations-directory (directory)
-    (validate-configuration-directory
-     directory :output-translations 'validate-output-translations-directive
-               :invalid-form-reporter 'invalid-output-translation))
 
-  (defun parse-output-translations-string (string &key location)
-    (cond
-      ((or (null string) (equal string ""))
-       '(:output-translations :inherit-configuration))
-      ((not (stringp string))
-       (error (compatfmt "~@<Environment string isn't: ~3i~_~S~@:>") string))
-      ((eql (char string 0) #\")
-       (parse-output-translations-string (read-from-string string) :location location))
-      ((eql (char string 0) #\()
-       (validate-output-translations-form (read-from-string string) :location location))
-      (t
-       (loop
-         :with inherit = nil
-         :with directives = ()
-         :with start = 0
-         :with end = (length string)
-         :with source = nil
-         :with separator = (inter-directory-separator)
-         :for i = (or (position separator string :start start) end) :do
-           (let ((s (subseq string start i)))
-             (cond
-               (source
-                (push (list source (if (equal "" s) nil s)) directives)
-                (setf source nil))
-               ((equal "" s)
-                (when inherit
-                  (error (compatfmt "~@<Only one inherited configuration allowed: ~3i~_~S~@:>")
-                         string))
-                (setf inherit t)
-                (push :inherit-configuration directives))
-               (t
-                (setf source s)))
-             (setf start (1+ i))
-             (when (> start end)
-               (when source
-                 (error (compatfmt "~@<Uneven number of components in source to destination mapping: ~3i~_~S~@:>")
-                        string))
-               (unless inherit
-                 (push :ignore-inherited-configuration directives))
-               (return `(:output-translations ,@(nreverse directives)))))))))
+;;; "inline methods"
+(with-upgradability ()
+  (defparameter* +asdf-methods+
+    '(perform-with-restarts perform explain output-files operation-done-p))
+
+  (defun %remove-component-inline-methods (component)
+    (dolist (name +asdf-methods+)
+      (map ()
+           ;; this is inefficient as most of the stored
+           ;; methods will not be for this particular gf
+           ;; But this is hardly performance-critical
+           #'(lambda (m)
+               (remove-method (symbol-function name) m))
+           (component-inline-methods component)))
+    (component-inline-methods component) nil)
+
+  (defun %define-component-inline-methods (ret rest)
+    (loop* :for (key value) :on rest :by #'cddr
+           :for name = (and (keywordp key) (find key +asdf-methods+ :test 'string=))
+           :when name :do
+           (destructuring-bind (op &rest body) value
+             (loop :for arg = (pop body)
+                   :while (atom arg)
+                   :collect arg :into qualifiers
+                   :finally
+                      (destructuring-bind (o c) arg
+                        (pushnew
+                         (eval `(defmethod ,name ,@qualifiers ((,o ,op) (,c (eql ,ret))) ,@body))
+                         (component-inline-methods ret)))))))
 
-  (defparameter* *default-output-translations*
-    '(environment-output-translations
-      user-output-translations-pathname
-      user-output-translations-directory-pathname
-      system-output-translations-pathname
-      system-output-translations-directory-pathname))
+  (defun %refresh-component-inline-methods (component rest)
+    ;; clear methods, then add the new ones
+    (%remove-component-inline-methods component)
+    (%define-component-inline-methods component rest)))
 
-  (defun wrapping-output-translations ()
-    `(:output-translations
-    ;; Some implementations have precompiled ASDF systems,
-    ;; so we must disable translations for implementation paths.
-      #+(or clasp #|clozure|# ecl mkcl sbcl)
-      ,@(let ((h (resolve-symlinks* (lisp-implementation-directory))))
-          (when h `(((,h ,*wild-path*) ()))))
-      #+mkcl (,(translate-logical-pathname "CONTRIB:") ())
-      ;; All-import, here is where we want user stuff to be:
-      :inherit-configuration
-      ;; These are for convenience, and can be overridden by the user:
-      #+abcl (#p"/___jar___file___root___/**/*.*" (:user-cache #p"**/*.*"))
-      #+abcl (#p"jar:file:/**/*.jar!/**/*.*" (:function translate-jar-pathname))
-      ;; We enable the user cache by default, and here is the place we do:
-      :enable-user-cache))
 
-  (defparameter *output-translations-file* (parse-unix-namestring "common-lisp/asdf-output-translations.conf"))
-  (defparameter *output-translations-directory* (parse-unix-namestring "common-lisp/asdf-output-translations.conf.d/"))
+;;; Main parsing function
+(with-upgradability ()
+  (defun parse-dependency-def (dd)
+    (if (listp dd)
+        (case (first dd)
+          (:feature
+           (unless (= (length dd) 3)
+             (sysdef-error "Ill-formed feature dependency: ~s" dd))
+           (let ((embedded (parse-dependency-def (third dd))))
+             `(:feature ,(second dd) ,embedded)))
+          (feature
+           (sysdef-error "`feature' has been removed from the dependency spec language of ASDF. Use :feature instead in ~s." dd))
+          (:require
+           (unless (= (length dd) 2)
+             (sysdef-error "Ill-formed require dependency: ~s" dd))
+           dd)
+          (:version
+           (unless (= (length dd) 3)
+             (sysdef-error "Ill-formed version dependency: ~s" dd))
+           `(:version ,(coerce-name (second dd)) ,(third dd)))
+          (otherwise (sysdef-error "Ill-formed dependency: ~s" dd)))
+      (coerce-name dd)))
 
-  (defun user-output-translations-pathname (&key (direction :input))
-    (xdg-config-pathname *output-translations-file* direction))
-  (defun system-output-translations-pathname (&key (direction :input))
-    (find-preferred-file (system-config-pathnames *output-translations-file*)
-                         :direction direction))
-  (defun user-output-translations-directory-pathname (&key (direction :input))
-    (xdg-config-pathname *output-translations-directory* direction))
-  (defun system-output-translations-directory-pathname (&key (direction :input))
-    (find-preferred-file (system-config-pathnames *output-translations-directory*)
-                         :direction direction))
-  (defun environment-output-translations ()
-    (getenv "ASDF_OUTPUT_TRANSLATIONS"))
+  (defun parse-dependency-defs (dd-list)
+    "Parse the dependency defs in DD-LIST into canonical form by translating all
+system names contained using COERCE-NAME. Return the result."
+    (mapcar 'parse-dependency-def dd-list))
 
-  (defgeneric process-output-translations (spec &key inherit collect))
+  (defun* (parse-component-form) (parent options &key previous-serial-component)
+    (destructuring-bind
+        (type name &rest rest &key
+                                (builtin-system-p () bspp)
+                                ;; the following list of keywords is reproduced below in the
+                                ;; remove-plist-keys form.  important to keep them in sync
+                                components pathname perform explain output-files operation-done-p
+                                weakly-depends-on depends-on serial
+                                do-first if-component-dep-fails version
+                                ;; list ends
+         &allow-other-keys) options
+      (declare (ignore perform explain output-files operation-done-p builtin-system-p))
+      (check-component-input type name weakly-depends-on depends-on components)
+      (when (and parent
+                 (find-component parent name)
+                 (not ;; ignore the same object when rereading the defsystem
+                  (typep (find-component parent name)
+                         (class-for-type parent type))))
+        (error 'duplicate-names :name name))
+      (when do-first (error "DO-FIRST is not supported anymore as of ASDF 3"))
+      (let* ((name (coerce-name name))
+             (args `(:name ,name
+                     :pathname ,pathname
+                     ,@(when parent `(:parent ,parent))
+                     ,@(remove-plist-keys
+                        '(:components :pathname :if-component-dep-fails :version
+                          :perform :explain :output-files :operation-done-p
+                          :weakly-depends-on :depends-on :serial)
+                        rest)))
+             (component (find-component parent name))
+             (class (class-for-type parent type)))
+        (when (and parent (subtypep class 'system))
+          (error 'non-toplevel-system :parent parent :name name))
+        (if component ; preserve identity
+            (apply 'reinitialize-instance component args)
+            (setf component (apply 'make-instance class args)))
+        (component-pathname component) ; eagerly compute the absolute pathname
+        (when (typep component 'system)
+          ;; cache information for introspection
+          (setf (slot-value component 'depends-on)
+                (parse-dependency-defs depends-on)
+                (slot-value component 'weakly-depends-on)
+                ;; these must be a list of systems, cannot be features or versioned systems
+                (mapcar 'coerce-name weakly-depends-on)))
+        (let ((sysfile (system-source-file (component-system component)))) ;; requires the previous
+          (when (and (typep component 'system) (not bspp))
+            (setf (builtin-system-p component) (lisp-implementation-pathname-p sysfile)))
+          (setf version (normalize-version version :component name :parent parent :pathname sysfile)))
+        ;; Don't use the accessor: kluge to avoid upgrade issue on CCL 1.8.
+        ;; A better fix is required.
+        (setf (slot-value component 'version) version)
+        (when (typep component 'parent-component)
+          (setf (component-children component)
+                (loop
+                  :with previous-component = nil
+                  :for c-form :in components
+                  :for c = (parse-component-form component c-form
+                                                 :previous-serial-component previous-component)
+                  :for name = (component-name c)
+                  :collect c
+                  :when serial :do (setf previous-component name)))
+          (compute-children-by-name component))
+        (when previous-serial-component
+          (push previous-serial-component depends-on))
+        (when weakly-depends-on
+          ;; ASDF4: deprecate this feature and remove it.
+          (appendf depends-on
+                   (remove-if (complement #'(lambda (x) (find-system x nil))) weakly-depends-on)))
+        ;; Used by POIU. ASDF4: rename to component-depends-on?
+        (setf (component-sideway-dependencies component) depends-on)
+        (%refresh-component-inline-methods component rest)
+        (when if-component-dep-fails
+          (error "The system definition for ~S uses deprecated ~
+            ASDF option :IF-COMPONENT-DEP-FAILS. ~
+            Starting with ASDF 3, please use :IF-FEATURE instead"
+           (coerce-name (component-system component))))
+        component)))
 
-  (defun inherit-output-translations (inherit &key collect)
-    (when inherit
-      (process-output-translations (first inherit) :collect collect :inherit (rest inherit))))
+  (defun register-system-definition
+      (name &rest options &key pathname (class 'system) (source-file () sfp)
+                            defsystem-depends-on &allow-other-keys)
+    ;; The system must be registered before we parse the body,
+    ;; otherwise we recur when trying to find an existing system
+    ;; of the same name to reuse options (e.g. pathname) from.
+    ;; To avoid infinite recursion in cases where you defsystem a system
+    ;; that is registered to a different location to find-system,
+    ;; we also need to remember it in the asdf-cache.
+    (nest
+     (with-asdf-cache ())
+     (let* ((name (coerce-name name))
+            (source-file (if sfp source-file (resolve-symlinks* (load-pathname))))
+            (asd-name (and source-file
+                           (equalp "asd" (pathname-type source-file))
+                           (pathname-name source-file)))
+            (primary-name (primary-system-name name)))
+       (when (and asd-name (not (equal asd-name primary-name)))
+         (warn (make-condition 'bad-system-name :source-file source-file :name name))))
+     (let* (;; NB: handle defsystem-depends-on BEFORE to create the system object,
+            ;; so that in case it fails, there is no incomplete object polluting the build.
+            (checked-defsystem-depends-on
+             (let* ((dep-forms (parse-dependency-defs defsystem-depends-on))
+                    (deps (loop :for spec :in dep-forms
+                            :when (resolve-dependency-spec nil spec)
+                            :collect :it)))
+               (load-systems* deps)
+               dep-forms))
+            (registered (system-registered-p name))
+            (registered! (if registered
+                             (rplaca registered (get-file-stamp source-file))
+                             (register-system
+                              (make-instance 'system :name name :source-file source-file))))
+            (system (reset-system (cdr registered!)
+                                  :name name :source-file source-file))
+            (component-options
+             (append
+              (remove-plist-keys '(:defsystem-depends-on :class) options)
+              ;; cache defsystem-depends-on in canonical form
+              (when checked-defsystem-depends-on
+                `(:defsystem-depends-on ,checked-defsystem-depends-on))))
+            (directory (determine-system-directory pathname)))
+       ;; This works hand in hand with asdf/find-system:find-system-if-being-defined:
+       (set-asdf-cache-entry `(find-system ,name) (list system)))
+     ;; We change-class AFTER we loaded the defsystem-depends-on
+     ;; since the class might be defined as part of those.
+     (let ((class (class-for-type nil class)))
+       (unless (subtypep class 'system)
+         (error 'non-system-system :name name :class-name (class-name class)))
+       (unless (eq (type-of system) class)
+         (change-class system class)))
+     (parse-component-form nil (list* :module name :pathname directory component-options))))
 
-  (defun* (process-output-translations-directive) (directive &key inherit collect)
-    (if (atom directive)
-        (ecase directive
-          ((:enable-user-cache)
-           (process-output-translations-directive '(t :user-cache) :collect collect))
-          ((:disable-cache)
-           (process-output-translations-directive '(t t) :collect collect))
-          ((:inherit-configuration)
-           (inherit-output-translations inherit :collect collect))
-          ((:ignore-inherited-configuration :ignore-invalid-entries nil)
-           nil))
-        (let ((src (first directive))
-              (dst (second directive)))
-          (if (eq src :include)
-              (when dst
-                (process-output-translations (pathname dst) :inherit nil :collect collect))
-              (when src
-                (let ((trusrc (or (eql src t)
-                                  (let ((loc (resolve-location src :ensure-directory t :wilden t)))
-                                    (if (absolute-pathname-p loc) (resolve-symlinks* loc) loc)))))
-                  (cond
-                    ((location-function-p dst)
-                     (funcall collect
-                              (list trusrc (ensure-function (second dst)))))
-                    ((typep dst 'boolean)
-                     (funcall collect (list trusrc t)))
-                    (t
-                     (let* ((trudst (resolve-location dst :ensure-directory t :wilden t)))
-                       (funcall collect (list trudst t))
-                       (funcall collect (list trusrc trudst)))))))))))
+  (defmacro defsystem (name &body options)
+    `(apply 'register-system-definition ',name ',options)))
+;;;; -------------------------------------------------------------------------
+;;;; ASDF-Bundle
 
-  (defmethod process-output-translations ((x symbol) &key
-                                                       (inherit *default-output-translations*)
-                                                       collect)
-    (process-output-translations (funcall x) :inherit inherit :collect collect))
-  (defmethod process-output-translations ((pathname pathname) &key inherit collect)
-    (cond
-      ((directory-pathname-p pathname)
-       (process-output-translations (validate-output-translations-directory pathname)
-                                    :inherit inherit :collect collect))
-      ((probe-file* pathname :truename *resolve-symlinks*)
-       (process-output-translations (validate-output-translations-file pathname)
-                                    :inherit inherit :collect collect))
-      (t
-       (inherit-output-translations inherit :collect collect))))
-  (defmethod process-output-translations ((string string) &key inherit collect)
-    (process-output-translations (parse-output-translations-string string)
-                                 :inherit inherit :collect collect))
-  (defmethod process-output-translations ((x null) &key inherit collect)
-    (inherit-output-translations inherit :collect collect))
-  (defmethod process-output-translations ((form cons) &key inherit collect)
-    (dolist (directive (cdr (validate-output-translations-form form)))
-      (process-output-translations-directive directive :inherit inherit :collect collect)))
+(uiop/package:define-package :asdf/bundle
+  (:recycle :asdf/bundle :asdf)
+  (:use :uiop/common-lisp :uiop :asdf/upgrade
+   :asdf/component :asdf/system :asdf/find-system :asdf/find-component :asdf/operation
+   :asdf/action :asdf/lisp-action :asdf/plan :asdf/operate :asdf/defsystem)
+  (:export
+   #:bundle-op #:bundle-type #:program-system
+   #:bundle-system #:bundle-pathname-type #:direct-dependency-files
+   #:monolithic-op #:monolithic-bundle-op #:operation-monolithic-p
+   #:basic-compile-bundle-op #:prepare-bundle-op
+   #:compile-bundle-op #:load-bundle-op #:monolithic-compile-bundle-op #:monolithic-load-bundle-op
+   #:lib-op #:monolithic-lib-op
+   #:dll-op #:monolithic-dll-op
+   #:deliver-asd-op #:monolithic-deliver-asd-op
+   #:program-op #:image-op #:compiled-file #:precompiled-system #:prebuilt-system
+   #:user-system-p #:user-system #:trivial-system-p
+   #:prologue-code #:epilogue-code #:static-library))
+(in-package :asdf/bundle)
+
+(with-upgradability ()
+  (defclass bundle-op (basic-compile-op)
+    ;; NB: use of instance-allocated slots for operations is DEPRECATED
+    ;; and only supported in a temporary fashion for backward compatibility.
+    ;; Supported replacement: Define slots on program-system instead.
+    ((bundle-type :initform :no-output-file :reader bundle-type :allocation :class))
+    (:documentation "base class for operations that bundle outputs from multiple components"))
+
+  (defclass monolithic-op (operation) ()
+    (:documentation "A MONOLITHIC operation operates on a system *and all of its
+dependencies*.  So, for example, a monolithic concatenate operation will
+concatenate together a system's components and all of its dependencies, but a
+simple concatenate operation will concatenate only the components of the system
+itself."))
+
+  (defclass monolithic-bundle-op (bundle-op monolithic-op)
+    ;; Old style way of specifying prologue and epilogue on ECL: in the monolithic operation.
+    ;; DEPRECATED. Supported replacement: Define slots on program-system instead.
+    ((prologue-code :initform nil :accessor prologue-code)
+     (epilogue-code :initform nil :accessor epilogue-code))
+    (:documentation "operations that are both monolithic-op and bundle-op"))
+
+  (defclass program-system (system)
+    ;; New style (ASDF3.1) way of specifying prologue and epilogue on ECL: in the system
+    ((prologue-code :initform nil :initarg :prologue-code :reader prologue-code)
+     (epilogue-code :initform nil :initarg :epilogue-code :reader epilogue-code)
+     (no-uiop :initform nil :initarg :no-uiop :reader no-uiop)
+     (prefix-lisp-object-files :initarg :prefix-lisp-object-files
+                               :initform nil :accessor prefix-lisp-object-files)
+     (postfix-lisp-object-files :initarg :postfix-lisp-object-files
+                                :initform nil :accessor postfix-lisp-object-files)
+     (extra-object-files :initarg :extra-object-files
+                         :initform nil :accessor extra-object-files)
+     (extra-build-args :initarg :extra-build-args
+                       :initform nil :accessor extra-build-args)))
 
-  (defun compute-output-translations (&optional parameter)
-    "read the configuration, return it"
-    (remove-duplicates
-     (while-collecting (c)
-       (inherit-output-translations
-        `(wrapping-output-translations ,parameter ,@*default-output-translations*) :collect #'c))
-     :test 'equal :from-end t))
+  (defmethod prologue-code ((x system)) nil)
+  (defmethod epilogue-code ((x system)) nil)
+  (defmethod no-uiop ((x system)) nil)
+  (defmethod prefix-lisp-object-files ((x system)) nil)
+  (defmethod postfix-lisp-object-files ((x system)) nil)
+  (defmethod extra-object-files ((x system)) nil)
+  (defmethod extra-build-args ((x system)) nil)
 
-  (defvar *output-translations-parameter* nil)
+  (defclass link-op (bundle-op) ()
+    (:documentation "Abstract operation for linking files together"))
 
-  (defun initialize-output-translations (&optional (parameter *output-translations-parameter*))
-    "read the configuration, initialize the internal configuration variable,
-return the configuration"
-    (setf *output-translations-parameter* parameter
-          (output-translations) (compute-output-translations parameter)))
+  (defclass gather-operation (bundle-op)
+    ((gather-operation :initform nil :allocation :class :reader gather-operation)
+     (gather-type :initform :no-output-file :allocation :class :reader gather-type))
+    (:documentation "Abstract operation for gathering many input files from a system"))
 
-  (defun disable-output-translations ()
-    "Initialize output translations in a way that maps every file to itself,
-effectively disabling the output translation facility."
-    (initialize-output-translations
-     '(:output-translations :disable-cache :ignore-inherited-configuration)))
+  (defun operation-monolithic-p (op)
+    (typep op 'monolithic-op))
 
-  ;; checks an initial variable to see whether the state is initialized
-  ;; or cleared. In the former case, return current configuration; in
-  ;; the latter, initialize.  ASDF will call this function at the start
-  ;; of (asdf:find-system).
-  (defun ensure-output-translations ()
-    (if (output-translations-initialized-p)
-        (output-translations)
-        (initialize-output-translations)))
+  ;; Dependencies of a gather-op are the actions of the dependent operation
+  ;; for all the (sorted) required components for loading the system.
+  ;; Monolithic operations typically use lib-op as the dependent operation,
+  ;; and all system-level dependencies as required components.
+  ;; Non-monolithic operations typically use compile-op as the dependent operation,
+  ;; and all transitive sub-components as required components (excluding other systems).
+  (defmethod component-depends-on ((o gather-operation) (s system))
+    (let* ((mono (operation-monolithic-p o))
+           (go (make-operation (or (gather-operation o) 'compile-op)))
+           (bundle-p (typep go 'bundle-op))
+           ;; In a non-mono operation, don't recurse to other systems.
+           ;; In a mono operation gathering bundles, don't recurse inside systems.
+           (component-type (if mono (if bundle-p 'system t) '(not system)))
+           ;; In the end, only keep system bundles or non-system bundles, depending.
+           (keep-component (if bundle-p 'system '(not system)))
+           (deps
+            ;; Required-components only looks at the dependencies of an action, excluding the action
+            ;; itself, so it may be safely used by an action recursing on its dependencies (which
+            ;; may or may not be an overdesigned API, since in practice we never use it that way).
+            ;; Therefore, if we use :goal-operation 'load-op :keep-operation 'load-op, which looks
+            ;; cleaner, we will miss the load-op on the requested system itself, which doesn't
+            ;; matter for a regular system, but matters, a lot, for a package-inferred-system.
+            ;; Using load-op as the goal operation and basic-compile-op as the keep-operation works
+            ;; for our needs of gathering all the files we want to include in a bundle.
+            ;; Note that we use basic-compile-op rather than compile-op so it will still work on
+            ;; systems when *load-system-operation* is load-bundle-op.
+            (required-components
+             s :other-systems mono :component-type component-type :keep-component keep-component
+             :goal-operation 'load-op :keep-operation 'basic-compile-op)))
+      `((,go ,@deps) ,@(call-next-method))))
+
+  ;; Create a single fasl for the entire library
+  (defclass basic-compile-bundle-op (bundle-op)
+    ((gather-type :initform #-(or clasp ecl mkcl) :fasl #+(or clasp ecl mkcl) :object
+                  :allocation :class)
+     (bundle-type :initform :fasl :allocation :class))
+    (:documentation "Base class for compiling into a bundle"))
 
-  (defun* (apply-output-translations) (path)
-    (etypecase path
-      (logical-pathname
-       path)
-      ((or pathname string)
-       (ensure-output-translations)
-       (loop* :with p = (resolve-symlinks* path)
-              :for (source destination) :in (car *output-translations*)
-              :for root = (when (or (eq source t)
-                                    (and (pathnamep source)
-                                         (not (absolute-pathname-p source))))
-                            (pathname-root p))
-              :for absolute-source = (cond
-                                       ((eq source t) (wilden root))
-                                       (root (merge-pathnames* source root))
-                                       (t source))
-              :when (or (eq source t) (pathname-match-p p absolute-source))
-              :return (translate-pathname* p absolute-source destination root source)
-              :finally (return p)))))
+  ;; Analog to prepare-op, for load-bundle-op and compile-bundle-op
+  (defclass prepare-bundle-op (sideway-operation)
+    ((sideway-operation
+      :initform #+(or clasp ecl mkcl) 'load-bundle-op #-(or clasp ecl mkcl) 'load-op
+      :allocation :class))
+    (:documentation "Operation class for loading the bundles of a system's dependencies"))
 
-  ;; Hook into uiop's output-translation mechanism
-  #-cormanlisp
-  (setf *output-translation-function* 'apply-output-translations)
+  (defclass lib-op (link-op gather-operation non-propagating-operation)
+    ((gather-type :initform :object :allocation :class)
+     (bundle-type :initform :lib :allocation :class))
+    (:documentation "Compile the system and produce a linkable static library (.a/.lib)
+for all the linkable object files associated with the system. Compare with DLL-OP.
 
-  #+abcl
-  (defun translate-jar-pathname (source wildcard)
-    (declare (ignore wildcard))
-    (flet ((normalize-device (pathname)
-             (if (find :windows *features*)
-                 pathname
-                 (make-pathname :defaults pathname :device :unspecific))))
-      (let* ((jar
-               (pathname (first (pathname-device source))))
-             (target-root-directory-namestring
-               (format nil "/___jar___file___root___/~@[~A/~]"
-                       (and (find :windows *features*)
-                            (pathname-device jar))))
-             (relative-source
-               (relativize-pathname-directory source))
-             (relative-jar
-               (relativize-pathname-directory (ensure-directory-pathname jar)))
-             (target-root-directory
-               (normalize-device
-                (pathname-directory-pathname
-                 (parse-namestring target-root-directory-namestring))))
-             (target-root
-               (merge-pathnames* relative-jar target-root-directory))
-             (target
-               (merge-pathnames* relative-source target-root)))
-        (normalize-device (apply-output-translations target))))))
+On most implementations, these object files only include extensions to the runtime
+written in C or another language with a compiler producing linkable object files.
+On CLASP, ECL, MKCL, these object files _also_ include the contents of Lisp files
+themselves. In any case, this operation will produce what you need to further build
+a static runtime for your system, or a dynamic library to load in an existing runtime."))
 
-;;;; -----------------------------------------------------------------
-;;;; Source Registry Configuration, by Francois-Rene Rideau
-;;;; See the Manual and https://bugs.launchpad.net/asdf/+bug/485918
+  ;; What works: on ECL, CLASP(?), MKCL, we link the many .o files from the system into the .so;
+  ;; on other implementations, we combine (usually concatenate) the .fasl files into one.
+  (defclass compile-bundle-op (basic-compile-bundle-op selfward-operation gather-operation
+                                                       #+(or clasp ecl mkcl) link-op)
+    ((selfward-operation :initform '(prepare-bundle-op) :allocation :class))
+    (:documentation "This operator is an alternative to COMPILE-OP. Build a system
+and all of its dependencies, but build only a single (\"monolithic\") FASL, instead
+of one per source file, which may be more resource efficient.  That monolithic
+FASL should be loaded with LOAD-BUNDLE-OP, rather than LOAD-OP."))
 
-(uiop/package:define-package :asdf/source-registry
-  (:recycle :asdf/source-registry :asdf)
-  (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/find-system)
-  (:export
-   #:*source-registry-parameter* #:*default-source-registries*
-   #:invalid-source-registry
-   #:source-registry-initialized-p
-   #:initialize-source-registry #:clear-source-registry #:*source-registry*
-   #:ensure-source-registry #:*source-registry-parameter*
-   #:*default-source-registry-exclusions* #:*source-registry-exclusions*
-   #:*wild-asd* #:directory-asd-files #:register-asd-directory
-   #:*recurse-beyond-asds* #:collect-asds-in-directory #:collect-sub*directories-asd-files
-   #:validate-source-registry-directive #:validate-source-registry-form
-   #:validate-source-registry-file #:validate-source-registry-directory
-   #:parse-source-registry-string #:wrapping-source-registry
-   #:default-user-source-registry #:default-system-source-registry
-   #:user-source-registry #:system-source-registry
-   #:user-source-registry-directory #:system-source-registry-directory
-   #:environment-source-registry #:process-source-registry #:inherit-source-registry
-   #:compute-source-registry #:flatten-source-registry
-   #:sysdef-source-registry-search))
-(in-package :asdf/source-registry)
+  (defclass load-bundle-op (basic-load-op selfward-operation)
+    ((selfward-operation :initform '(prepare-bundle-op compile-bundle-op) :allocation :class))
+    (:documentation "This operator is an alternative to LOAD-OP. Build a system
+and all of its dependencies, using COMPILE-BUNDLE-OP. The difference with
+respect to LOAD-OP is that it builds only a single FASL, which may be
+faster and more resource efficient."))
 
-(with-upgradability ()
-  (define-condition invalid-source-registry (invalid-configuration warning)
-    ((format :initform (compatfmt "~@<Invalid source registry ~S~@[ in ~S~]~@{ ~@?~}~@:>"))))
+  ;; NB: since the monolithic-op's can't be sideway-operation's,
+  ;; if we wanted lib-op, dll-op, deliver-asd-op to be sideway-operation's,
+  ;; we'd have to have the monolithic-op not inherit from the main op,
+  ;; but instead inherit from a basic-FOO-op as with basic-compile-bundle-op above.
 
-  ;; Using ack 1.2 exclusions
-  (defvar *default-source-registry-exclusions*
-    '(".bzr" ".cdv"
-      ;; "~.dep" "~.dot" "~.nib" "~.plst" ; we don't support ack wildcards
-      ".git" ".hg" ".pc" ".svn" "CVS" "RCS" "SCCS" "_darcs"
-      "_sgbak" "autom4te.cache" "cover_db" "_build"
-      "debian")) ;; debian often builds stuff under the debian directory... BAD.
+  (defclass dll-op (link-op gather-operation non-propagating-operation)
+    ((gather-type :initform :object :allocation :class)
+     (bundle-type :initform :dll :allocation :class))
+    (:documentation "Compile the system and produce a dynamic loadable library (.so/.dll)
+for all the linkable object files associated with the system. Compare with LIB-OP."))
 
-  (defvar *source-registry-exclusions* *default-source-registry-exclusions*)
+  (defclass deliver-asd-op (basic-compile-op selfward-operation)
+    ((selfward-operation
+      ;; TODO: implement link-op on all implementations, and make that
+      ;; '(compile-bundle-op lib-op #-(or clasp ecl mkcl) dll-op)
+      :initform '(compile-bundle-op #+(or clasp ecl mkcl) lib-op)
+      :allocation :class))
+    (:documentation "produce an asd file for delivering the system as a single fasl"))
 
-  (defvar *source-registry* nil
-    "Either NIL (for uninitialized), or an equal hash-table, mapping
-system names to pathnames of .asd files")
 
-  (defvar *source-registry-parameter* nil)
+  (defclass monolithic-deliver-asd-op (deliver-asd-op monolithic-bundle-op)
+    ((selfward-operation
+      ;; TODO: implement link-op on all implementations, and make that
+      ;; '(monolithic-compile-bundle-op monolithic-lib-op #-(or clasp ecl mkcl) monolithic-dll-op)
+      :initform '(monolithic-compile-bundle-op #+(or clasp ecl mkcl) monolithic-lib-op)
+      :allocation :class))
+    (:documentation "produce fasl and asd files for combined system and dependencies."))
 
-  (defun source-registry-initialized-p ()
-    (typep *source-registry* 'hash-table))
+  (defclass monolithic-compile-bundle-op
+      (basic-compile-bundle-op monolithic-bundle-op
+       #+(or clasp ecl mkcl) link-op gather-operation non-propagating-operation)
+    ()
+    (:documentation "Create a single fasl for the system and its dependencies."))
 
-  (defun clear-source-registry ()
-    "Undoes any initialization of the source registry."
-    (setf *source-registry* nil)
-    (values))
-  (register-clear-configuration-hook 'clear-source-registry)
+  (defclass monolithic-load-bundle-op (load-bundle-op monolithic-bundle-op)
+    ((selfward-operation :initform 'monolithic-compile-bundle-op :allocation :class))
+    (:documentation "Load a single fasl for the system and its dependencies."))
 
-  (defparameter *wild-asd*
-    (make-pathname :directory nil :name *wild* :type "asd" :version :newest))
+  (defclass monolithic-lib-op (lib-op monolithic-bundle-op non-propagating-operation)
+    ((gather-type :initform :object :allocation :class))
+    (:documentation "Compile the system and produce a linkable static library (.a/.lib)
+for all the linkable object files associated with the system or its dependencies. See LIB-OP."))
 
-  (defun directory-asd-files (directory)
-    (directory-files directory *wild-asd*))
+  (defclass monolithic-dll-op (dll-op monolithic-bundle-op non-propagating-operation)
+    ((gather-type :initform :object :allocation :class))
+    (:documentation "Compile the system and produce a dynamic loadable library (.so/.dll)
+for all the linkable object files associated with the system or its dependencies. See LIB-OP"))
 
-  (defun collect-asds-in-directory (directory collect)
-    (let ((asds (directory-asd-files directory)))
-      (map () collect asds)
-      asds))
+  (defclass image-op (monolithic-bundle-op selfward-operation
+                      #+(or clasp ecl mkcl) link-op #+(or clasp ecl mkcl) gather-operation)
+    ((bundle-type :initform :image :allocation :class)
+     (gather-operation :initform 'lib-op :allocation :class)
+     #+(or clasp ecl mkcl) (gather-type :initform :static-library :allocation :class)
+     (selfward-operation :initform '(#-(or clasp ecl mkcl) load-op) :allocation :class))
+    (:documentation "create an image file from the system and its dependencies"))
 
-  (defvar *recurse-beyond-asds* t
-    "Should :tree entries of the source-registry recurse in subdirectories
-after having found a .asd file? True by default.")
+  (defclass program-op (image-op)
+    ((bundle-type :initform :program :allocation :class))
+    (:documentation "create an executable file from the system and its dependencies"))
 
-  (defun process-source-registry-cache (directory collect)
-    (let ((cache (ignore-errors
-                  (safe-read-file-form (subpathname directory ".cl-source-registry.cache")))))
-      (when (and (listp cache) (eq :source-registry-cache (first cache)))
-        (loop :for s :in (rest cache) :do (funcall collect (subpathname directory s)))
-        t)))
+  ;; From the ASDF-internal bundle-type identifier, get a filesystem-usable pathname type.
+  (defun bundle-pathname-type (bundle-type)
+    (etypecase bundle-type
+      ((or null string) ;; pass through nil or string literal
+       bundle-type)
+      ((eql :no-output-file) ;; marker for a bundle-type that has NO output file
+       (error "No output file, therefore no pathname type"))
+      ((eql :fasl) ;; the type of a fasl
+       #-(or clasp ecl mkcl) (compile-file-type) ; on image-based platforms, used as input and output
+       #+(or clasp ecl mkcl) "fasb") ; on C-linking platforms, only used as output for system bundles
+      ((member :image)
+       #+allegro "dxl"
+       #+(and clisp os-windows) "exe"
+       #-(or allegro (and clisp os-windows)) "image")
+      ;; NB: on CLASP and ECL these implementations, we better agree with
+      ;; (compile-file-type :type bundle-type))
+      ((eql :object) ;; the type of a linkable object file
+       (os-cond ((os-unix-p) "o")
+                ((os-windows-p) (if (featurep '(:or :mingw32 :mingw64)) "o" "obj"))))
+      ((member :lib :static-library) ;; the type of a linkable library
+       (os-cond ((os-unix-p) "a")
+                ((os-windows-p) (if (featurep '(:or :mingw32 :mingw64)) "a" "lib"))))
+      ((member :dll :shared-library) ;; the type of a shared library
+       (os-cond ((os-macosx-p) "dylib") ((os-unix-p) "so") ((os-windows-p) "dll")))
+      ((eql :program) ;; the type of an executable program
+       (os-cond ((os-unix-p) nil) ((os-windows-p) "exe")))))
+
+  ;; Compute the output-files for a given bundle action
+  (defun bundle-output-files (o c)
+    (let ((bundle-type (bundle-type o)))
+      (unless (or (eq bundle-type :no-output-file) ;; NIL already means something regarding type.
+                  (and (null (input-files o c)) (not (member bundle-type '(:image :program)))))
+        (let ((name (or (component-build-pathname c)
+                        (let ((suffix
+                               (unless (typep o 'program-op)
+                                 ;; "." is no good separator for Logical Pathnames, so we use "--"
+                                 (if (operation-monolithic-p o)
+                                     "--all-systems"
+                                     ;; These use a different type .fasb or .a instead of .fasl
+                                     #-(or clasp ecl mkcl) "--system"))))
+                          (format nil "~A~@[~A~]" (component-name c) suffix))))
+              (type (bundle-pathname-type bundle-type)))
+          (values (list (subpathname (component-pathname c) name :type type))
+                  (eq (class-of o) (coerce-class (component-build-operation c)
+                                                 :package :asdf/interface
+                                                 :super 'operation
+                                                 :error nil)))))))
+
+  (defmethod output-files ((o bundle-op) (c system))
+    (bundle-output-files o c))
+
+  #-(or clasp ecl mkcl)
+  (progn
+    (defmethod perform ((o image-op) (c system))
+      (dump-image (output-file o c) :executable (typep o 'program-op)))
+    (defmethod perform :before ((o program-op) (c system))
+      (setf *image-entry-point* (ensure-function (component-entry-point c)))))
+
+  (defclass compiled-file (file-component)
+    ((type :initform #-(or clasp ecl mkcl) (compile-file-type) #+(or clasp ecl mkcl) "fasb"))
+    (:documentation "Class for a file that is already compiled,
+e.g. as part of the implementation, of an outer build system that calls into ASDF,
+or of opaque libraries shipped along the source code."))
 
-  (defun collect-sub*directories-asd-files
-      (directory &key (exclude *default-source-registry-exclusions*) collect
-                   (recurse-beyond-asds *recurse-beyond-asds*) ignore-cache)
-    (let ((visited (make-hash-table :test 'equalp)))
-      (collect-sub*directories
-       directory
-       #'(lambda (dir)
-           (unless (and (not ignore-cache) (process-source-registry-cache directory collect))
-             (let ((asds (collect-asds-in-directory dir collect)))
-               (or recurse-beyond-asds (not asds)))))
-       #'(lambda (x)                    ; x will be a directory pathname
-           (and
-            (not (member (car (last (pathname-directory x))) exclude :test #'equal))
-            (flet ((pathname-key (x)
-                     (namestring (truename* x))))
-              (let ((visitedp (gethash (pathname-key x) visited)))
-                (if visitedp nil
-                    (setf (gethash (pathname-key x) visited) t))))))
-       (constantly nil))))
+  (defclass precompiled-system (system)
+    ((build-pathname :initarg :fasl))
+    (:documentation "Class For a system that is delivered as a precompiled fasl"))
 
-  (defun validate-source-registry-directive (directive)
-    (or (member directive '(:default-registry))
-        (and (consp directive)
-             (let ((rest (rest directive)))
-               (case (first directive)
-                 ((:include :directory :tree)
-                  (and (length=n-p rest 1)
-                       (location-designator-p (first rest))))
-                 ((:exclude :also-exclude)
-                  (every #'stringp rest))
-                 ((:default-registry)
-                  (null rest)))))))
+  (defclass prebuilt-system (system)
+    ((build-pathname :initarg :static-library :initarg :lib
+                     :accessor prebuilt-system-static-library))
+    (:documentation "Class for a system delivered with a linkable static library (.a/.lib)")))
 
-  (defun validate-source-registry-form (form &key location)
-    (validate-configuration-form
-     form :source-registry 'validate-source-registry-directive
-          :location location :invalid-form-reporter 'invalid-source-registry))
 
-  (defun validate-source-registry-file (file)
-    (validate-configuration-file
-     file 'validate-source-registry-form :description "a source registry"))
+;;;
+;;; BUNDLE-OP
+;;;
+;;; This operation takes all components from one or more systems and
+;;; creates a single output file, which may be
+;;; a FASL, a statically linked library, a shared library, etc.
+;;; The different targets are defined by specialization.
+;;;
+(when-upgrading (:version "3.2.0")
+  ;; Cancel any previously defined method
+  (defmethod initialize-instance :after ((instance bundle-op) &rest initargs &key &allow-other-keys)
+    (declare (ignore initargs))))
 
-  (defun validate-source-registry-directory (directory)
-    (validate-configuration-directory
-     directory :source-registry 'validate-source-registry-directive
-               :invalid-form-reporter 'invalid-source-registry))
+(with-upgradability ()
+  (defgeneric trivial-system-p (component))
 
-  (defun parse-source-registry-string (string &key location)
-    (cond
-      ((or (null string) (equal string ""))
-       '(:source-registry :inherit-configuration))
-      ((not (stringp string))
-       (error (compatfmt "~@<Environment string isn't: ~3i~_~S~@:>") string))
-      ((find (char string 0) "\"(")
-       (validate-source-registry-form (read-from-string string) :location location))
-      (t
-       (loop
-         :with inherit = nil
-         :with directives = ()
-         :with start = 0
-         :with end = (length string)
-         :with separator = (inter-directory-separator)
-         :for pos = (position separator string :start start) :do
-           (let ((s (subseq string start (or pos end))))
-             (flet ((check (dir)
-                      (unless (absolute-pathname-p dir)
-                        (error (compatfmt "~@<source-registry string must specify absolute pathnames: ~3i~_~S~@:>") string))
-                      dir))
-               (cond
-                 ((equal "" s) ; empty element: inherit
-                  (when inherit
-                    (error (compatfmt "~@<Only one inherited configuration allowed: ~3i~_~S~@:>")
-                           string))
-                  (setf inherit t)
-                  (push ':inherit-configuration directives))
-                 ((string-suffix-p s "//") ;; TODO: allow for doubling of separator even outside Unix?
-                  (push `(:tree ,(check (subseq s 0 (- (length s) 2)))) directives))
-                 (t
-                  (push `(:directory ,(check s)) directives))))
-             (cond
-               (pos
-                (setf start (1+ pos)))
-               (t
-                (unless inherit
-                  (push '(:ignore-inherited-configuration) directives))
-                (return `(:source-registry ,@(nreverse directives))))))))))
+  (defun user-system-p (s)
+    (and (typep s 'system)
+         (not (builtin-system-p s))
+         (not (trivial-system-p s)))))
 
-  (defun register-asd-directory (directory &key recurse exclude collect)
-    (if (not recurse)
-        (collect-asds-in-directory directory collect)
-        (collect-sub*directories-asd-files
-         directory :exclude exclude :collect collect)))
+(eval-when (#-lispworks :compile-toplevel :load-toplevel :execute)
+  (deftype user-system () '(and system (satisfies user-system-p))))
 
-  (defparameter* *default-source-registries*
-    '(environment-source-registry
-      user-source-registry
-      user-source-registry-directory
-      default-user-source-registry
-      system-source-registry
-      system-source-registry-directory
-      default-system-source-registry)
-    "List of default source registries" "3.1.0.102")
+;;;
+;;; First we handle monolithic bundles.
+;;; These are standalone systems which contain everything,
+;;; including other ASDF systems required by the current one.
+;;; A PROGRAM is always monolithic.
+;;;
+;;; MONOLITHIC SHARED LIBRARIES, PROGRAMS, FASL
+;;;
+(with-upgradability ()
+  (defun direct-dependency-files (o c &key (test 'identity) (key 'output-files) &allow-other-keys)
+    ;; This function selects output files from direct dependencies;
+    ;; your component-depends-on method must gather the correct dependencies in the correct order.
+    (while-collecting (collect)
+      (map-direct-dependencies
+       t o c #'(lambda (sub-o sub-c)
+                 (loop :for f :in (funcall key sub-o sub-c)
+                       :when (funcall test f) :do (collect f))))))
 
-  (defparameter *source-registry-file* (parse-unix-namestring "common-lisp/source-registry.conf"))
-  (defparameter *source-registry-directory* (parse-unix-namestring "common-lisp/source-registry.conf.d/"))
+  (defun pathname-type-equal-function (type)
+    #'(lambda (p) (equalp (pathname-type p) type)))
 
-  (defun wrapping-source-registry ()
-    `(:source-registry
-      #+(or clasp ecl sbcl) (:tree ,(resolve-symlinks* (lisp-implementation-directory)))
-      :inherit-configuration
-      #+mkcl (:tree ,(translate-logical-pathname "CONTRIB:"))
-      #+cmucl (:tree #p"modules:")
-      #+scl (:tree #p"file://modules/")))
-  (defun default-user-source-registry ()
-    `(:source-registry
-      (:tree (:home "common-lisp/"))
-      #+sbcl (:directory (:home ".sbcl/systems/"))
-      (:directory ,(xdg-data-home "common-lisp/systems/"))
-      (:tree ,(xdg-data-home "common-lisp/source/"))
-      :inherit-configuration))
-  (defun default-system-source-registry ()
-    `(:source-registry
-      ,@(loop :for dir :in (xdg-data-dirs "common-lisp/")
-              :collect `(:directory (,dir "systems/"))
-              :collect `(:tree (,dir "source/")))
-      :inherit-configuration))
-  (defun user-source-registry (&key (direction :input))
-    (xdg-config-pathname *source-registry-file* direction))
-  (defun system-source-registry (&key (direction :input))
-    (find-preferred-file (system-config-pathnames *source-registry-file*)
-                         :direction direction))
-  (defun user-source-registry-directory (&key (direction :input))
-    (xdg-config-pathname *source-registry-directory* direction))
-  (defun system-source-registry-directory (&key (direction :input))
-    (find-preferred-file (system-config-pathnames *source-registry-directory*)
-                         :direction direction))
-  (defun environment-source-registry ()
-    (getenv "CL_SOURCE_REGISTRY"))
+  (defmethod input-files ((o gather-operation) (c system))
+    (unless (eq (bundle-type o) :no-output-file)
+      (direct-dependency-files
+       o c :key 'output-files
+           :test (pathname-type-equal-function (bundle-pathname-type (gather-type o))))))
 
-  (defgeneric* (process-source-registry) (spec &key inherit register))
+  ;; Find the operation that produces a given bundle-type
+  (defun select-bundle-operation (type &optional monolithic)
+    (ecase type
+      ((:dll :shared-library)
+       (if monolithic 'monolithic-dll-op 'dll-op))
+      ((:lib :static-library)
+       (if monolithic 'monolithic-lib-op 'lib-op))
+      ((:fasl)
+       (if monolithic 'monolithic-compile-bundle-op 'compile-bundle-op))
+      ((:image)
+       'image-op)
+      ((:program)
+       'program-op))))
 
-  (defun* (inherit-source-registry) (inherit &key register)
-    (when inherit
-      (process-source-registry (first inherit) :register register :inherit (rest inherit))))
+;;;
+;;; LOAD-BUNDLE-OP
+;;;
+;;; This is like ASDF's LOAD-OP, but using bundle fasl files.
+;;;
+(with-upgradability ()
+  (defmethod component-depends-on ((o load-bundle-op) (c system))
+    `((,o ,@(component-sideway-dependencies c))
+      (,(if (user-system-p c) 'compile-bundle-op 'load-op) ,c)
+      ,@(call-next-method)))
 
-  (defun* (process-source-registry-directive) (directive &key inherit register)
-    (destructuring-bind (kw &rest rest) (if (consp directive) directive (list directive))
-      (ecase kw
-        ((:include)
-         (destructuring-bind (pathname) rest
-           (process-source-registry (resolve-location pathname) :inherit nil :register register)))
-        ((:directory)
-         (destructuring-bind (pathname) rest
-           (when pathname
-             (funcall register (resolve-location pathname :ensure-directory t)))))
-        ((:tree)
-         (destructuring-bind (pathname) rest
-           (when pathname
-             (funcall register (resolve-location pathname :ensure-directory t)
-                      :recurse t :exclude *source-registry-exclusions*))))
-        ((:exclude)
-         (setf *source-registry-exclusions* rest))
-        ((:also-exclude)
-         (appendf *source-registry-exclusions* rest))
-        ((:default-registry)
-         (inherit-source-registry
-          '(default-user-source-registry default-system-source-registry) :register register))
-        ((:inherit-configuration)
-         (inherit-source-registry inherit :register register))
-        ((:ignore-inherited-configuration)
-         nil)))
-    nil)
+  (defmethod input-files ((o load-bundle-op) (c system))
+    (when (user-system-p c)
+      (output-files (find-operation o 'compile-bundle-op) c)))
 
-  (defmethod process-source-registry ((x symbol) &key inherit register)
-    (process-source-registry (funcall x) :inherit inherit :register register))
-  (defmethod process-source-registry ((pathname pathname) &key inherit register)
-    (cond
-      ((directory-pathname-p pathname)
-       (let ((*here-directory* (resolve-symlinks* pathname)))
-         (process-source-registry (validate-source-registry-directory pathname)
-                                  :inherit inherit :register register)))
-      ((probe-file* pathname :truename *resolve-symlinks*)
-       (let ((*here-directory* (pathname-directory-pathname pathname)))
-         (process-source-registry (validate-source-registry-file pathname)
-                                  :inherit inherit :register register)))
-      (t
-       (inherit-source-registry inherit :register register))))
-  (defmethod process-source-registry ((string string) &key inherit register)
-    (process-source-registry (parse-source-registry-string string)
-                             :inherit inherit :register register))
-  (defmethod process-source-registry ((x null) &key inherit register)
-    (inherit-source-registry inherit :register register))
-  (defmethod process-source-registry ((form cons) &key inherit register)
-    (let ((*source-registry-exclusions* *default-source-registry-exclusions*))
-      (dolist (directive (cdr (validate-source-registry-form form)))
-        (process-source-registry-directive directive :inherit inherit :register register))))
+  (defmethod perform ((o load-bundle-op) (c system))
+    (when (input-files o c)
+      (perform-lisp-load-fasl o c)))
 
-  (defun flatten-source-registry (&optional (parameter *source-registry-parameter*))
-    (remove-duplicates
-     (while-collecting (collect)
-       (with-pathname-defaults () ;; be location-independent
-         (inherit-source-registry
-          `(wrapping-source-registry
-            ,parameter
-            ,@*default-source-registries*)
-          :register #'(lambda (directory &key recurse exclude)
-                        (collect (list directory :recurse recurse :exclude exclude))))))
-     :test 'equal :from-end t))
+  (defmethod mark-operation-done :after ((o load-bundle-op) (c system))
+    (mark-operation-done (find-operation o 'load-op) c)))
+
+;;;
+;;; PRECOMPILED FILES
+;;;
+;;; This component can be used to distribute ASDF systems in precompiled form.
+;;; Only useful when the dependencies have also been precompiled.
+;;;
+(with-upgradability ()
+  (defmethod trivial-system-p ((s system))
+    (every #'(lambda (c) (typep c 'compiled-file)) (component-children s)))
+
+  (defmethod input-files ((o operation) (c compiled-file))
+    (list (component-pathname c)))
+  (defmethod perform ((o load-op) (c compiled-file))
+    (perform-lisp-load-fasl o c))
+  (defmethod perform ((o load-source-op) (c compiled-file))
+    (perform (find-operation o 'load-op) c))
+  (defmethod perform ((o operation) (c compiled-file))
+    nil))
 
-  ;; Will read the configuration and initialize all internal variables.
-  (defun compute-source-registry (&optional (parameter *source-registry-parameter*) (registry *source-registry*))
-    (dolist (entry (flatten-source-registry parameter))
-      (destructuring-bind (directory &key recurse exclude) entry
-        (let* ((h (make-hash-table :test 'equal))) ; table to detect duplicates
-          (register-asd-directory
-           directory :recurse recurse :exclude exclude :collect
-           #'(lambda (asd)
-               (let* ((name (pathname-name asd))
-                      (name (if (typep asd 'logical-pathname)
-                                ;; logical pathnames are upper-case,
-                                ;; at least in the CLHS and on SBCL,
-                                ;; yet (coerce-name :foo) is lower-case.
-                                ;; won't work well with (load-system "Foo")
-                                ;; instead of (load-system 'foo)
-                                (string-downcase name)
-                                name)))
-                 (cond
-                   ((gethash name registry) ; already shadowed by something else
-                    nil)
-                   ((gethash name h) ; conflict at current level
-                    (when *verbose-out*
-                      (warn (compatfmt "~@<In source-registry entry ~A~@[/~*~] ~
-                                found several entries for ~A - picking ~S over ~S~:>")
-                            directory recurse name (gethash name h) asd)))
-                   (t
-                    (setf (gethash name registry) asd)
-                    (setf (gethash name h) asd))))))
-          h)))
-    (values))
+;;;
+;;; Pre-built systems
+;;;
+(with-upgradability ()
+  (defmethod trivial-system-p ((s prebuilt-system))
+    t)
 
-  (defun initialize-source-registry (&optional (parameter *source-registry-parameter*))
-    ;; Record the parameter used to configure the registry
-    (setf *source-registry-parameter* parameter)
-    ;; Clear the previous registry database:
-    (setf *source-registry* (make-hash-table :test 'equal))
-    ;; Do it!
-    (compute-source-registry parameter))
+  (defmethod perform ((o link-op) (c prebuilt-system))
+    nil)
 
-  ;; Checks an initial variable to see whether the state is initialized
-  ;; or cleared. In the former case, return current configuration; in
-  ;; the latter, initialize.  ASDF will call this function at the start
-  ;; of (asdf:find-system) to make sure the source registry is initialized.
-  ;; However, it will do so *without* a parameter, at which point it
-  ;; will be too late to provide a parameter to this function, though
-  ;; you may override the configuration explicitly by calling
-  ;; initialize-source-registry directly with your parameter.
-  (defun ensure-source-registry (&optional parameter)
-    (unless (source-registry-initialized-p)
-      (initialize-source-registry parameter))
-    (values))
+  (defmethod perform ((o basic-compile-bundle-op) (c prebuilt-system))
+    nil)
 
-  (defun sysdef-source-registry-search (system)
-    (ensure-source-registry)
-    (values (gethash (primary-system-name system) *source-registry*))))
+  (defmethod perform ((o lib-op) (c prebuilt-system))
+    nil)
 
+  (defmethod perform ((o dll-op) (c prebuilt-system))
+    nil)
 
-;;;; -------------------------------------------------------------------------
-;;;; Defsystem
+  (defmethod component-depends-on ((o gather-operation) (c prebuilt-system))
+    nil)
 
-(uiop/package:define-package :asdf/parse-defsystem
-  (:recycle :asdf/parse-defsystem :asdf/defsystem :asdf)
-  (:nicknames :asdf/defsystem) ;; previous name, to be compatible with, in case anyone cares
-  (:use :uiop/common-lisp :asdf/driver :asdf/upgrade
-   :asdf/cache :asdf/component :asdf/system
-   :asdf/find-system :asdf/find-component :asdf/action :asdf/lisp-action :asdf/operate)
-  (:import-from :asdf/system #:depends-on #:weakly-depends-on)
-  (:export
-   #:defsystem #:register-system-definition
-   #:class-for-type #:*default-component-class*
-   #:determine-system-directory #:parse-component-form
-   #:non-toplevel-system #:non-system-system
-   #:sysdef-error-component #:check-component-input))
-(in-package :asdf/parse-defsystem)
+  (defmethod output-files ((o lib-op) (c prebuilt-system))
+    (values (list (prebuilt-system-static-library c)) t)))
 
-;;; Pathname
+
+;;;
+;;; PREBUILT SYSTEM CREATOR
+;;;
 (with-upgradability ()
-  (defun determine-system-directory (pathname)
-    ;; The defsystem macro calls this function to determine
-    ;; the pathname of a system as follows:
-    ;; 1. if the pathname argument is an pathname object (NOT a namestring),
-    ;;    that is already an absolute pathname, return it.
-    ;; 2. otherwise, the directory containing the LOAD-PATHNAME
-    ;;    is considered (as deduced from e.g. *LOAD-PATHNAME*), and
-    ;;    if it is indeed available and an absolute pathname, then
-    ;;    the PATHNAME argument is normalized to a relative pathname
-    ;;    as per PARSE-UNIX-NAMESTRING (with ENSURE-DIRECTORY T)
-    ;;    and merged into that DIRECTORY as per SUBPATHNAME.
-    ;;    Note: avoid *COMPILE-FILE-PATHNAME* because .asd is loaded,
-    ;;    and may be from within the EVAL-WHEN of a file compilation.
-    ;; If no absolute pathname was found, we return NIL.
-    (check-type pathname (or null string pathname))
-    (pathname-directory-pathname
-     (resolve-symlinks*
-      (ensure-absolute-pathname
-       (parse-unix-namestring pathname :type :directory)
-       #'(lambda () (ensure-absolute-pathname
-                     (load-pathname) 'get-pathname-defaults nil))
-       nil)))))
+  (defmethod output-files ((o deliver-asd-op) (s system))
+    (list (make-pathname :name (component-name s) :type "asd"
+                         :defaults (component-pathname s))))
+
+  (defmethod perform ((o deliver-asd-op) (s system))
+    (let* ((inputs (input-files o s))
+           (fasl (first inputs))
+           (library (second inputs))
+           (asd (first (output-files o s)))
+           (name (if (and fasl asd) (pathname-name asd) (return-from perform)))
+           (version (component-version s))
+           (dependencies
+             (if (operation-monolithic-p o)
+                 ;; We want only dependencies, and we use basic-load-op rather than load-op so that
+                 ;; this will keep working on systems when *load-system-operation* is load-bundle-op
+                 (remove-if-not 'builtin-system-p
+                                (required-components s :component-type 'system
+                                                       :keep-operation 'basic-load-op))
+                 (while-collecting (x) ;; resolve the sideway-dependencies of s
+                   (map-direct-dependencies
+                    t 'load-op s
+                    #'(lambda (o c)
+                        (when (and (typep o 'load-op) (typep c 'system))
+                          (x c)))))))
+           (depends-on (mapcar 'coerce-name dependencies)))
+      (when (pathname-equal asd (system-source-file s))
+        (cerror "overwrite the asd file"
+                "~/asdf-action:format-action/ is going to overwrite the system definition file ~S ~
+which is probably not what you want; you probably need to tweak your output translations."
+                (cons o s) asd))
+      (with-open-file (s asd :direction :output :if-exists :supersede
+                             :if-does-not-exist :create)
+        (format s ";;; Prebuilt~:[~; monolithic~] ASDF definition for system ~A~%"
+                (operation-monolithic-p o) name)
+        (format s ";;; Built for ~A ~A on a ~A/~A ~A~%"
+                (lisp-implementation-type)
+                (lisp-implementation-version)
+                (software-type)
+                (machine-type)
+                (software-version))
+        (let ((*package* (find-package :asdf-user)))
+          (pprint `(defsystem ,name
+                     :class prebuilt-system
+                     :version ,version
+                     :depends-on ,depends-on
+                     :components ((:compiled-file ,(pathname-name fasl)))
+                     ,@(when library `(:lib ,(file-namestring library))))
+                  s)
+          (terpri s)))))
 
+  #-(or clasp ecl mkcl)
+  (defmethod perform ((o basic-compile-bundle-op) (c system))
+    (let* ((input-files (input-files o c))
+           (fasl-files (remove (compile-file-type) input-files :key #'pathname-type :test-not #'equalp))
+           (non-fasl-files (remove (compile-file-type) input-files :key #'pathname-type :test #'equalp))
+           (output-files (output-files o c))
+           (output-file (first output-files)))
+      (assert (eq (not input-files) (not output-files)))
+      (when input-files
+        (when non-fasl-files
+          (error "On ~A, asdf/bundle can only bundle FASL files, but these were also produced: ~S"
+                 (implementation-type) non-fasl-files))
+        (when (or (prologue-code c) (epilogue-code c))
+          (error "prologue-code and epilogue-code are not supported on ~A"
+                 (implementation-type)))
+        (with-staging-pathname (output-file)
+          (combine-fasls fasl-files output-file)))))
 
-;;; Component class
-(with-upgradability ()
-  (defvar *default-component-class* 'cl-source-file)
+  (defmethod input-files ((o load-op) (s precompiled-system))
+    (bundle-output-files (find-operation o 'compile-bundle-op) s))
 
-  (defun class-for-type (parent type)
-      (or (coerce-class type :package :asdf/interface :super 'component :error nil)
-          (and (eq type :file)
-               (coerce-class
-                (or (loop :for p = parent :then (component-parent p) :while p
-                            :thereis (module-default-component-class p))
-                    *default-component-class*)
-                :package :asdf/interface :super 'component :error nil))
-          (sysdef-error "don't recognize component type ~S" type))))
+  (defmethod perform ((o load-op) (s precompiled-system))
+    (perform-lisp-load-fasl o s))
 
+  (defmethod component-depends-on ((o load-bundle-op) (s precompiled-system))
+    #+xcl (declare (ignorable o))
+    `((load-op ,s) ,@(call-next-method))))
 
-;;; Check inputs
-(with-upgradability ()
-  (define-condition non-system-system (system-definition-error)
-    ((name :initarg :name :reader non-system-system-name)
-     (class-name :initarg :class-name :reader non-system-system-class-name))
-    (:report (lambda (c s)
-               (format s (compatfmt "~@<Error while defining system ~S: class ~S isn't a subclass of ~S~@:>")
-                       (non-system-system-name c) (non-system-system-class-name c) 'system))))
+#| ;; Example use:
+(asdf:defsystem :precompiled-asdf-utils :class asdf::precompiled-system :fasl (asdf:apply-output-translations (asdf:system-relative-pathname :asdf-utils "asdf-utils.system.fasl")))
+(asdf:load-system :precompiled-asdf-utils)
+|#
 
-  (define-condition non-toplevel-system (system-definition-error)
-    ((parent :initarg :parent :reader non-toplevel-system-parent)
-     (name :initarg :name :reader non-toplevel-system-name))
-    (:report (lambda (c s)
-               (format s (compatfmt "~@<Error while defining system: component ~S claims to have a system ~S as a child~@:>")
-                       (non-toplevel-system-parent c) (non-toplevel-system-name c)))))
+#+(or clasp ecl mkcl)
+(with-upgradability ()
 
-  (defun sysdef-error-component (msg type name value)
-    (sysdef-error (strcat msg (compatfmt "~&~@<The value specified for ~(~A~) ~A is ~S~@:>"))
-                  type name value))
+  #+ecl ;; doesn't work on clasp or mkcl (yet?).
+  (unless (use-ecl-byte-compiler-p)
+    (setf *load-system-operation* 'load-bundle-op))
 
-  (defun check-component-input (type name weakly-depends-on
-                                depends-on components)
-    "A partial test of the values of a component."
-    (unless (listp depends-on)
-      (sysdef-error-component ":depends-on must be a list."
-                              type name depends-on))
-    (unless (listp weakly-depends-on)
-      (sysdef-error-component ":weakly-depends-on must be a list."
-                              type name weakly-depends-on))
-    (unless (listp components)
-      (sysdef-error-component ":components must be NIL or a list of components."
-                              type name components)))
+  (defun system-module-pathname (module)
+    (let ((name (coerce-name module)))
+      (some
+       'file-exists-p
+       (list
+        #+clasp (compile-file-pathname (make-pathname :name name :defaults "sys:") :output-type :object)
+        #+ecl (compile-file-pathname (make-pathname :name name :defaults "sys:") :type :lib)
+        #+ecl (compile-file-pathname (make-pathname :name name :defaults "sys:") :type :object)
+        #+mkcl (make-pathname :name name :type (bundle-pathname-type :lib) :defaults #p"sys:")
+        #+mkcl (make-pathname :name name :type (bundle-pathname-type :lib) :defaults #p"sys:contrib;")))))
+
+  (defun make-prebuilt-system (name &optional (pathname (system-module-pathname name)))
+    "Creates a prebuilt-system if PATHNAME isn't NIL."
+    (when pathname
+      (make-instance 'prebuilt-system
+                     :name (coerce-name name)
+                     :static-library (resolve-symlinks* pathname))))
 
-  (defun* (normalize-version) (form &key pathname component parent)
-    (labels ((invalid (&optional (continuation "using NIL instead"))
-               (warn (compatfmt "~@<Invalid :version specifier ~S~@[ for component ~S~]~@[ in ~S~]~@[ from file ~S~]~@[, ~A~]~@:>")
-                     form component parent pathname continuation))
-             (invalid-parse (control &rest args)
-               (unless (if-let (target (find-component parent component)) (builtin-system-p target))
-                 (apply 'warn control args)
-                 (invalid))))
-      (if-let (v (typecase form
-                   ((or string null) form)
-                   (real
-                    (invalid "Substituting a string")
-                    (format nil "~D" form)) ;; 1.0 becomes "1.0"
-                   (cons
-                    (case (first form)
-                      ((:read-file-form)
-                       (destructuring-bind (subpath &key (at 0)) (rest form)
-                         (safe-read-file-form (subpathname pathname subpath)
-                                              :at at :package :asdf-user)))
-                      ((:read-file-line)
-                       (destructuring-bind (subpath &key (at 0)) (rest form)
-                         (safe-read-file-line (subpathname pathname subpath)
-                                              :at at)))
-                      (otherwise
-                       (invalid))))
-                   (t
-                    (invalid))))
-        (if-let (pv (parse-version v #'invalid-parse))
-          (unparse-version pv)
-          (invalid))))))
+  (defmethod component-depends-on :around ((o image-op) (c system))
+    (destructuring-bind ((lib-op . deps)) (call-next-method)
+      (labels ((has-it-p (x) (find x deps :test 'equal :key 'coerce-name))
+               (ensure-linkable-system (x)
+		 (unless (has-it-p x)
+                   (or (if-let (s (find-system x))
+                         (and (system-source-directory x)
+                              (list s)))
+                       (if-let (p (system-module-pathname x))
+                         (list (make-prebuilt-system x p)))))))
+        `((,lib-op
+           ,@(unless (no-uiop c)
+               (append (ensure-linkable-system "cmp")
+                       (or (ensure-linkable-system "uiop")
+                           (ensure-linkable-system "asdf"))))
+           ,@deps)))))
 
+  (defmethod perform ((o link-op) (c system))
+    (let* ((object-files (input-files o c))
+           (output (output-files o c))
+           (bundle (first output))
+           (programp (typep o 'program-op))
+           (kind (bundle-type o)))
+      (when output
+        (apply 'create-image
+               bundle (append
+                       (when programp (prefix-lisp-object-files c))
+                       object-files
+                       (when programp (postfix-lisp-object-files c)))
+               :kind kind
+               :prologue-code (when programp (prologue-code c))
+               :epilogue-code (when programp (epilogue-code c))
+               :build-args (when programp (extra-build-args c))
+               :extra-object-files (when programp (extra-object-files c))
+               :no-uiop (no-uiop c)
+               (when programp `(:entry-point ,(component-entry-point c))))))))
+;;;; -------------------------------------------------------------------------
+;;;; Concatenate-source
 
-;;; "inline methods"
+(uiop/package:define-package :asdf/concatenate-source
+  (:recycle :asdf/concatenate-source :asdf)
+  (:use :uiop/common-lisp :uiop :asdf/upgrade
+   :asdf/component :asdf/operation
+   :asdf/system :asdf/find-system
+   :asdf/action :asdf/lisp-action :asdf/plan :asdf/bundle)
+  (:export
+   #:concatenate-source-op
+   #:load-concatenated-source-op
+   #:compile-concatenated-source-op
+   #:load-compiled-concatenated-source-op
+   #:monolithic-concatenate-source-op
+   #:monolithic-load-concatenated-source-op
+   #:monolithic-compile-concatenated-source-op
+   #:monolithic-load-compiled-concatenated-source-op))
+(in-package :asdf/concatenate-source)
+
+;;;
+;;; Concatenate sources
+;;;
 (with-upgradability ()
-  (defparameter* +asdf-methods+
-    '(perform-with-restarts perform explain output-files operation-done-p))
+  ;; Base classes for both regular and monolithic concatenate-source operations
+  (defclass basic-concatenate-source-op (bundle-op)
+    ((bundle-type :initform "lisp" :allocation :class)))
+  (defclass basic-load-concatenated-source-op (basic-load-op selfward-operation) ())
+  (defclass basic-compile-concatenated-source-op (basic-compile-op selfward-operation) ())
+  (defclass basic-load-compiled-concatenated-source-op (basic-load-op selfward-operation) ())
 
-  (defun %remove-component-inline-methods (component)
-    (dolist (name +asdf-methods+)
-      (map ()
-           ;; this is inefficient as most of the stored
-           ;; methods will not be for this particular gf
-           ;; But this is hardly performance-critical
-           #'(lambda (m)
-               (remove-method (symbol-function name) m))
-           (component-inline-methods component)))
-    (component-inline-methods component) nil)
+  ;; Regular concatenate-source operations
+  (defclass concatenate-source-op (basic-concatenate-source-op non-propagating-operation) ()
+    (:documentation "Operation to concatenate all sources in a system into a single file"))
+  (defclass load-concatenated-source-op (basic-load-concatenated-source-op)
+    ((selfward-operation :initform '(prepare-op concatenate-source-op) :allocation :class))
+    (:documentation "Operation to load the result of concatenate-source-op as source"))
+  (defclass compile-concatenated-source-op (basic-compile-concatenated-source-op)
+    ((selfward-operation :initform '(prepare-op concatenate-source-op) :allocation :class))
+    (:documentation "Operation to compile the result of concatenate-source-op"))
+  (defclass load-compiled-concatenated-source-op (basic-load-compiled-concatenated-source-op)
+    ((selfward-operation :initform '(prepare-op compile-concatenated-source-op) :allocation :class))
+    (:documentation "Operation to load the result of compile-concatenated-source-op"))
 
-  (defun %define-component-inline-methods (ret rest)
-    (loop* :for (key value) :on rest :by #'cddr
-           :for name = (and (keywordp key) (find key +asdf-methods+ :test 'string=))
-           :when name :do
-           (destructuring-bind (op &rest body) value
-             (loop :for arg = (pop body)
-                   :while (atom arg)
-                   :collect arg :into qualifiers
-                   :finally
-                      (destructuring-bind (o c) arg
-                        (pushnew
-                         (eval `(defmethod ,name ,@qualifiers ((,o ,op) (,c (eql ,ret))) ,@body))
-                         (component-inline-methods ret)))))))
+  (defclass monolithic-concatenate-source-op
+      (basic-concatenate-source-op monolithic-bundle-op non-propagating-operation) ()
+    (:documentation "Operation to concatenate all sources in a system and its dependencies
+into a single file"))
+  (defclass monolithic-load-concatenated-source-op (basic-load-concatenated-source-op)
+    ((selfward-operation :initform 'monolithic-concatenate-source-op :allocation :class))
+    (:documentation "Operation to load the result of monolithic-concatenate-source-op as source"))
+  (defclass monolithic-compile-concatenated-source-op (basic-compile-concatenated-source-op)
+    ((selfward-operation :initform 'monolithic-concatenate-source-op :allocation :class))
+    (:documentation "Operation to compile the result of monolithic-concatenate-source-op"))
+  (defclass monolithic-load-compiled-concatenated-source-op
+      (basic-load-compiled-concatenated-source-op)
+    ((selfward-operation :initform 'monolithic-compile-concatenated-source-op :allocation :class))
+    (:documentation "Operation to load the result of monolithic-compile-concatenated-source-op"))
 
-  (defun %refresh-component-inline-methods (component rest)
-    ;; clear methods, then add the new ones
-    (%remove-component-inline-methods component)
-    (%define-component-inline-methods component rest)))
+  (defmethod input-files ((operation basic-concatenate-source-op) (s system))
+    (loop :with encoding = (or (component-encoding s) *default-encoding*)
+          :with other-encodings = '()
+          :with around-compile = (around-compile-hook s)
+          :with other-around-compile = '()
+          :for c :in (required-components  ;; see note about similar call to required-components
+                      s :goal-operation 'load-op ;;  in bundle.lisp
+                        :keep-operation 'basic-compile-op
+                        :other-systems (operation-monolithic-p operation))
+          :append
+          (when (typep c 'cl-source-file)
+            (let ((e (component-encoding c)))
+              (unless (equal e encoding)
+                (let ((a (assoc e other-encodings)))
+                  (if a (push (component-find-path c) (cdr a))
+                      (push (list a (component-find-path c)) other-encodings)))))
+            (unless (equal around-compile (around-compile-hook c))
+              (push (component-find-path c) other-around-compile))
+            (input-files (make-operation 'compile-op) c)) :into inputs
+          :finally
+             (when other-encodings
+               (warn "~S uses encoding ~A but has sources that use these encodings:~{ ~A~}"
+                     operation encoding
+                     (mapcar #'(lambda (x) (cons (car x) (list (reverse (cdr x)))))
+                             other-encodings)))
+             (when other-around-compile
+               (warn "~S uses around-compile hook ~A but has sources that use these hooks: ~A"
+                     operation around-compile other-around-compile))
+             (return inputs)))
+  (defmethod output-files ((o basic-compile-concatenated-source-op) (s system))
+    (lisp-compilation-output-files o s))
+
+  (defmethod perform ((o basic-concatenate-source-op) (s system))
+    (let* ((ins (input-files o s))
+           (out (output-file o s))
+           (tmp (tmpize-pathname out)))
+      (concatenate-files ins tmp)
+      (rename-file-overwriting-target tmp out)))
+  (defmethod perform ((o basic-load-concatenated-source-op) (s system))
+    (perform-lisp-load-source o s))
+  (defmethod perform ((o basic-compile-concatenated-source-op) (s system))
+    (perform-lisp-compilation o s))
+  (defmethod perform ((o basic-load-compiled-concatenated-source-op) (s system))
+    (perform-lisp-load-fasl o s)))
 
+;;;; ---------------------------------------------------------------------------
+;;;; asdf-output-translations
+
+(uiop/package:define-package :asdf/output-translations
+  (:recycle :asdf/output-translations :asdf)
+  (:use :uiop/common-lisp :uiop :asdf/upgrade)
+  (:export
+   #:*output-translations* #:*output-translations-parameter*
+   #:invalid-output-translation
+   #:output-translations #:output-translations-initialized-p
+   #:initialize-output-translations #:clear-output-translations
+   #:disable-output-translations #:ensure-output-translations
+   #:apply-output-translations
+   #:validate-output-translations-directive #:validate-output-translations-form
+   #:validate-output-translations-file #:validate-output-translations-directory
+   #:parse-output-translations-string #:wrapping-output-translations
+   #:user-output-translations-pathname #:system-output-translations-pathname
+   #:user-output-translations-directory-pathname #:system-output-translations-directory-pathname
+   #:environment-output-translations #:process-output-translations
+   #:compute-output-translations
+   #+abcl #:translate-jar-pathname
+   ))
+(in-package :asdf/output-translations)
+
+;; (setf output-translations) between 2.27 and 3.0.3 was using a defsetf macro
+;; for the sake of obsolete versions of GCL 2.6. Make sure it doesn't come to haunt us.
+(when-upgrading (:version "3.1.2") (fmakunbound '(setf output-translations)))
 
-;;; Main parsing function
 (with-upgradability ()
-  (defun parse-dependency-def (dd)
-    (if (listp dd)
-        (case (first dd)
-          (:feature
-           (unless (= (length dd) 3)
-             (sysdef-error "Ill-formed feature dependency: ~s" dd))
-           (let ((embedded (parse-dependency-def (third dd))))
-             `(:feature ,(second dd) ,embedded)))
-          (feature
-           (sysdef-error "`feature' has been removed from the dependency spec language of ASDF. Use :feature instead in ~s." dd))
-          (:require
-           (unless (= (length dd) 2)
-             (sysdef-error "Ill-formed require dependency: ~s" dd))
-           dd)
-          (:version
-           (unless (= (length dd) 3)
-             (sysdef-error "Ill-formed version dependency: ~s" dd))
-           `(:version ,(coerce-name (second dd)) ,(third dd)))
-          (otherwise (sysdef-error "Ill-formed dependency: ~s" dd)))
-      (coerce-name dd)))
+  (define-condition invalid-output-translation (invalid-configuration warning)
+    ((format :initform (compatfmt "~@<Invalid asdf output-translation ~S~@[ in ~S~]~@{ ~@?~}~@:>"))))
 
-  (defun parse-dependency-defs (dd-list)
-    "Parse the dependency defs in DD-LIST into canonical form by translating all
-system names contained using COERCE-NAME. Return the result."
-    (mapcar 'parse-dependency-def dd-list))
+  (defvar *output-translations* ()
+    "Either NIL (for uninitialized), or a list of one element,
+said element itself being a sorted list of mappings.
+Each mapping is a pair of a source pathname and destination pathname,
+and the order is by decreasing length of namestring of the source pathname.")
 
-  (defun (parse-component-form) (parent options &key previous-serial-component)
-    (destructuring-bind
-        (type name &rest rest &key
-                                (builtin-system-p () bspp)
-                                ;; the following list of keywords is reproduced below in the
-                                ;; remove-plist-keys form.  important to keep them in sync
-                                components pathname perform explain output-files operation-done-p
-                                weakly-depends-on depends-on serial
-                                do-first if-component-dep-fails version
-                                ;; list ends
-         &allow-other-keys) options
-      (declare (ignore perform explain output-files operation-done-p builtin-system-p))
-      (check-component-input type name weakly-depends-on depends-on components)
-      (when (and parent
-                 (find-component parent name)
-                 (not ;; ignore the same object when rereading the defsystem
-                  (typep (find-component parent name)
-                         (class-for-type parent type))))
-        (error 'duplicate-names :name name))
-      (when do-first (error "DO-FIRST is not supported anymore as of ASDF 3"))
-      (let* ((name (coerce-name name))
-             (args `(:name ,name
-                     :pathname ,pathname
-                     ,@(when parent `(:parent ,parent))
-                     ,@(remove-plist-keys
-                        '(:components :pathname :if-component-dep-fails :version
-                          :perform :explain :output-files :operation-done-p
-                          :weakly-depends-on :depends-on :serial)
-                        rest)))
-             (component (find-component parent name))
-             (class (class-for-type parent type)))
-        (when (and parent (subtypep class 'system))
-          (error 'non-toplevel-system :parent parent :name name))
-        (if component ; preserve identity
-            (apply 'reinitialize-instance component args)
-            (setf component (apply 'make-instance class args)))
-        (component-pathname component) ; eagerly compute the absolute pathname
-        (when (typep component 'system)
-          ;; cache information for introspection
-          (setf (slot-value component 'depends-on)
-                (parse-dependency-defs depends-on)
-                (slot-value component 'weakly-depends-on)
-                ;; these must be a list of systems, cannot be features or versioned systems
-                (mapcar 'coerce-name weakly-depends-on)))
-        (let ((sysfile (system-source-file (component-system component)))) ;; requires the previous
-          (when (and (typep component 'system) (not bspp))
-            (setf (builtin-system-p component) (lisp-implementation-pathname-p sysfile)))
-          (setf version (normalize-version version :component name :parent parent :pathname sysfile)))
-        ;; Don't use the accessor: kluge to avoid upgrade issue on CCL 1.8.
-        ;; A better fix is required.
-        (setf (slot-value component 'version) version)
-        (when (typep component 'parent-component)
-          (setf (component-children component)
-                (loop
-                  :with previous-component = nil
-                  :for c-form :in components
-                  :for c = (parse-component-form component c-form
-                                                 :previous-serial-component previous-component)
-                  :for name = (component-name c)
-                  :collect c
-                  :when serial :do (setf previous-component name)))
-          (compute-children-by-name component))
-        (when previous-serial-component
-          (push previous-serial-component depends-on))
-        (when weakly-depends-on
-          ;; ASDF4: deprecate this feature and remove it.
-          (appendf depends-on
-                   (remove-if (complement #'(lambda (x) (find-system x nil))) weakly-depends-on)))
-        ;; Used by POIU. ASDF4: rename to component-depends-on?
-        (setf (component-sideway-dependencies component) depends-on)
-        (%refresh-component-inline-methods component rest)
-        (when if-component-dep-fails
-          (error "The system definition for ~S uses deprecated ~
-            ASDF option :IF-COMPONENT-DEP-FAILS. ~
-            Starting with ASDF 3, please use :IF-FEATURE instead"
-           (coerce-name (component-system component))))
-        component)))
+  (defun output-translations ()
+    "Return the configured output-translations, if any"
+    (car *output-translations*))
+
+  ;; Set the output-translations, by sorting the provided new-value.
+  (defun set-output-translations (new-value)
+    (setf *output-translations*
+          (list
+           (stable-sort (copy-list new-value) #'>
+                        :key #'(lambda (x)
+                                 (etypecase (car x)
+                                   ((eql t) -1)
+                                   (pathname
+                                    (let ((directory
+                                           (normalize-pathname-directory-component
+                                            (pathname-directory (car x)))))
+                                      (if (listp directory) (length directory) 0))))))))
+    new-value)
+  (defun (setf output-translations) (new-value) (set-output-translations new-value))
 
-  (defun register-system-definition
-      (name &rest options &key pathname (class 'system) (source-file () sfp)
-                            defsystem-depends-on &allow-other-keys)
-    ;; The system must be registered before we parse the body,
-    ;; otherwise we recur when trying to find an existing system
-    ;; of the same name to reuse options (e.g. pathname) from.
-    ;; To avoid infinite recursion in cases where you defsystem a system
-    ;; that is registered to a different location to find-system,
-    ;; we also need to remember it in the asdf-cache.
-    (with-asdf-cache ()
-      (let* ((name (coerce-name name))
-             (source-file (if sfp source-file (resolve-symlinks* (load-pathname))))
-             ;; NB: handle defsystem-depends-on BEFORE to create the system object,
-             ;; so that in case it fails, there is no incomplete object polluting the build.
-             (checked-defsystem-depends-on
-               (let* ((dep-forms (parse-dependency-defs defsystem-depends-on))
-                      (deps (loop :for spec :in dep-forms
-                                  :when (resolve-dependency-spec nil spec)
-                                    :collect :it)))
-                 (load-systems* deps)
-                 dep-forms))
-             (registered (system-registered-p name))
-             (registered! (if registered
-                              (rplaca registered (get-file-stamp source-file))
-                              (register-system
-                               (make-instance 'system :name name :source-file source-file))))
-             (system (reset-system (cdr registered!)
-                                   :name name :source-file source-file))
-             (component-options
-              (append
-               (remove-plist-keys '(:defsystem-depends-on :class) options)
-               ;; cache defsystem-depends-on in canonical form
-               (when checked-defsystem-depends-on
-                 `(:defsystem-depends-on ,checked-defsystem-depends-on)))))
-        (set-asdf-cache-entry `(find-system ,name) (list system))
-        ;; We change-class AFTER we loaded the defsystem-depends-on
-        ;; since the class might be defined as part of those.
-        (let ((class (class-for-type nil class)))
-          (unless (subtypep class 'system)
-            (error 'non-system-system :name name :class-name (class-name class)))
-          (unless (eq (type-of system) class)
-            (change-class system class)))
-        (parse-component-form
-         nil (list*
-              :module name
-              :pathname (determine-system-directory pathname)
-              component-options)))))
+  (defun output-translations-initialized-p ()
+    "Have the output-translations been initialized yet?"
+    (and *output-translations* t))
 
-  (defmacro defsystem (name &body options)
-    `(apply 'register-system-definition ',name ',options)))
-;;;; -------------------------------------------------------------------------
-;;;; ASDF-Bundle
+  (defun clear-output-translations ()
+    "Undoes any initialization of the output translations."
+    (setf *output-translations* '())
+    (values))
+  (register-clear-configuration-hook 'clear-output-translations)
 
-(uiop/package:define-package :asdf/bundle
-  (:recycle :asdf/bundle :asdf)
-  (:use :uiop/common-lisp :uiop :asdf/upgrade
-   :asdf/component :asdf/system :asdf/find-system :asdf/find-component :asdf/operation
-   :asdf/action :asdf/lisp-action :asdf/plan :asdf/operate :asdf/defsystem)
-  (:export
-   #:bundle-op #:bundle-type #:program-system
-   #:bundle-system #:bundle-pathname-type #:direct-dependency-files
-   #:monolithic-op #:monolithic-bundle-op #:operation-monolithic-p
-   #:basic-compile-bundle-op #:prepare-bundle-op
-   #:compile-bundle-op #:load-bundle-op #:monolithic-compile-bundle-op #:monolithic-load-bundle-op
-   #:lib-op #:monolithic-lib-op
-   #:dll-op #:monolithic-dll-op
-   #:deliver-asd-op #:monolithic-deliver-asd-op
-   #:program-op #:image-op #:compiled-file #:precompiled-system #:prebuilt-system
-   #:user-system-p #:user-system #:trivial-system-p
-   #:make-build
-   #:build-args #:name-suffix #:prologue-code #:epilogue-code #:static-library))
-(in-package :asdf/bundle)
 
-(with-upgradability ()
-  (defclass bundle-op (basic-compile-op)
-    ((build-args :initarg :args :initform nil :accessor extra-build-args)
-     (name-suffix :initarg :name-suffix :initform nil)
-     (bundle-type :initform :no-output-file :reader bundle-type)
-     #+(or clasp ecl) (lisp-files :initform nil :accessor extra-object-files)))
+  ;;; Validation of the configuration directives...
 
-  (defclass monolithic-op (operation) ()
-    (:documentation "A MONOLITHIC operation operates on a system *and all of its
-dependencies*.  So, for example, a monolithic concatenate operation will
-concatenate together a system's components and all of its dependencies, but a
-simple concatenate operation will concatenate only the components of the system
-itself.")) ;; operation on a system and its dependencies
+  (defun validate-output-translations-directive (directive)
+    (or (member directive '(:enable-user-cache :disable-cache nil))
+        (and (consp directive)
+             (or (and (length=n-p directive 2)
+                      (or (and (eq (first directive) :include)
+                               (typep (second directive) '(or string pathname null)))
+                          (and (location-designator-p (first directive))
+                               (or (location-designator-p (second directive))
+                                   (location-function-p (second directive))))))
+                 (and (length=n-p directive 1)
+                      (location-designator-p (first directive)))))))
 
-  (defclass monolithic-bundle-op (monolithic-op bundle-op)
-    ;; Old style way of specifying prologue and epilogue on ECL: in the monolithic operation
-    ((prologue-code :initform nil :accessor prologue-code)
-     (epilogue-code :initform nil :accessor epilogue-code)))
+  (defun validate-output-translations-form (form &key location)
+    (validate-configuration-form
+     form
+     :output-translations
+     'validate-output-translations-directive
+     :location location :invalid-form-reporter 'invalid-output-translation))
 
-  (defclass program-system (system)
-    ;; New style (ASDF3.1) way of specifying prologue and epilogue on ECL: in the system
-    ((prologue-code :initform nil :initarg :prologue-code :reader prologue-code)
-     (epilogue-code :initform nil :initarg :epilogue-code :reader epilogue-code)
-     (no-uiop :initform nil :initarg :no-uiop :reader no-uiop)
-     (prefix-lisp-object-files :initarg :prefix-lisp-object-files
-                               :initform nil :accessor prefix-lisp-object-files)
-     (postfix-lisp-object-files :initarg :postfix-lisp-object-files
-                                :initform nil :accessor postfix-lisp-object-files)
-     (extra-object-files :initarg :extra-object-files
-                         :initform nil :accessor extra-object-files)
-     (extra-build-args :initarg :extra-build-args
-                       :initform nil :accessor extra-build-args)))
+  (defun validate-output-translations-file (file)
+    (validate-configuration-file
+     file 'validate-output-translations-form :description "output translations"))
 
-  (defmethod prologue-code ((x t)) nil)
-  (defmethod epilogue-code ((x t)) nil)
-  (defmethod no-uiop ((x t)) nil)
-  (defmethod prefix-lisp-object-files ((x t)) nil)
-  (defmethod postfix-lisp-object-files ((x t)) nil)
-  (defmethod extra-object-files ((x t)) nil)
-  (defmethod extra-build-args ((x t)) nil)
+  (defun validate-output-translations-directory (directory)
+    (validate-configuration-directory
+     directory :output-translations 'validate-output-translations-directive
+               :invalid-form-reporter 'invalid-output-translation))
 
-  (defclass link-op (bundle-op) ()
-    (:documentation "Abstract operation for linking files together"))
 
-  (defclass gather-op (bundle-op)
-    ((gather-op :initform nil :allocation :class :reader gather-op)
-     (gather-type :initform :no-output-file :allocation :class :reader gather-type))
-    (:documentation "Abstract operation for gathering many input files from a system"))
+  ;;; Parse the ASDF_OUTPUT_TRANSLATIONS environment variable and/or some file contents
+  (defun parse-output-translations-string (string &key location)
+    (cond
+      ((or (null string) (equal string ""))
+       '(:output-translations :inherit-configuration))
+      ((not (stringp string))
+       (error (compatfmt "~@<Environment string isn't: ~3i~_~S~@:>") string))
+      ((eql (char string 0) #\")
+       (parse-output-translations-string (read-from-string string) :location location))
+      ((eql (char string 0) #\()
+       (validate-output-translations-form (read-from-string string) :location location))
+      (t
+       (loop
+         :with inherit = nil
+         :with directives = ()
+         :with start = 0
+         :with end = (length string)
+         :with source = nil
+         :with separator = (inter-directory-separator)
+         :for i = (or (position separator string :start start) end) :do
+           (let ((s (subseq string start i)))
+             (cond
+               (source
+                (push (list source (if (equal "" s) nil s)) directives)
+                (setf source nil))
+               ((equal "" s)
+                (when inherit
+                  (error (compatfmt "~@<Only one inherited configuration allowed: ~3i~_~S~@:>")
+                         string))
+                (setf inherit t)
+                (push :inherit-configuration directives))
+               (t
+                (setf source s)))
+             (setf start (1+ i))
+             (when (> start end)
+               (when source
+                 (error (compatfmt "~@<Uneven number of components in source to destination mapping: ~3i~_~S~@:>")
+                        string))
+               (unless inherit
+                 (push :ignore-inherited-configuration directives))
+               (return `(:output-translations ,@(nreverse directives)))))))))
 
-  (defun operation-monolithic-p (op)
-    (typep op 'monolithic-op))
 
-  (defmethod component-depends-on ((o gather-op) (s system))
-    (let* ((mono (operation-monolithic-p o))
-           (deps
-             (required-components
-              s :other-systems mono :component-type (if mono 'system '(not system))
-                :goal-operation (find-operation o 'load-op)
-                :keep-operation 'compile-op)))
-      ;; NB: the explicit make-operation on ECL and MKCL
-      ;; ensures that we drop the original-initargs and its magic flags when recursing.
-      `((,(make-operation (or (gather-op o) (if mono 'lib-op 'compile-op))) ,@deps)
-        ,@(call-next-method))))
-
-  ;; create a single fasl for the entire library
-  (defclass basic-compile-bundle-op (bundle-op)
-    ((gather-type :initform #-(or clasp ecl mkcl) :fasl #+(or clasp ecl mkcl) :object
-                  :allocation :class)
-     (bundle-type :initform :fasl :allocation :class)))
+  ;; The default sources of configuration for output-translations
+  (defparameter* *default-output-translations*
+    '(environment-output-translations
+      user-output-translations-pathname
+      user-output-translations-directory-pathname
+      system-output-translations-pathname
+      system-output-translations-directory-pathname))
 
-  (defclass prepare-bundle-op (sideway-operation)
-    ((sideway-operation
-      :initform #+(or clasp ecl mkcl) 'load-bundle-op #-(or clasp ecl mkcl) 'load-op
-      :allocation :class)))
+  ;; Compulsory implementation-dependent wrapping for the translations:
+  ;; handle implementation-provided systems.
+  (defun wrapping-output-translations ()
+    `(:output-translations
+    ;; Some implementations have precompiled ASDF systems,
+    ;; so we must disable translations for implementation paths.
+      #+(or clasp #|clozure|# ecl mkcl sbcl)
+      ,@(let ((h (resolve-symlinks* (lisp-implementation-directory))))
+          (when h `(((,h ,*wild-path*) ()))))
+      #+mkcl (,(translate-logical-pathname "CONTRIB:") ())
+      ;; All-import, here is where we want user stuff to be:
+      :inherit-configuration
+      ;; These are for convenience, and can be overridden by the user:
+      #+abcl (#p"/___jar___file___root___/**/*.*" (:user-cache #p"**/*.*"))
+      #+abcl (#p"jar:file:/**/*.jar!/**/*.*" (:function translate-jar-pathname))
+      ;; We enable the user cache by default, and here is the place we do:
+      :enable-user-cache))
 
-  (defclass lib-op (link-op gather-op non-propagating-operation)
-    ((gather-type :initform :object :allocation :class)
-     (bundle-type :initform :lib :allocation :class))
-    (:documentation "Compile the system and produce a linkable static library (.a/.lib)
-for all the linkable object files associated with the system. Compare with DLL-OP.
+  ;; Relative pathnames of output-translations configuration to XDG configuration directory
+  (defparameter *output-translations-file* (parse-unix-namestring "common-lisp/asdf-output-translations.conf"))
+  (defparameter *output-translations-directory* (parse-unix-namestring "common-lisp/asdf-output-translations.conf.d/"))
 
-On most implementations, these object files only include extensions to the runtime
-written in C or another language with a compiler producing linkable object files.
-On CLASP, ECL, MKCL, these object files also include the contents of Lisp files
-themselves. In any case, this operation will produce what you need to further build
-a static runtime for your system, or a dynamic library to load in an existing runtime."))
+  ;; Locating various configuration pathnames, depending on input or output intent.
+  (defun user-output-translations-pathname (&key (direction :input))
+    (xdg-config-pathname *output-translations-file* direction))
+  (defun system-output-translations-pathname (&key (direction :input))
+    (find-preferred-file (system-config-pathnames *output-translations-file*)
+                         :direction direction))
+  (defun user-output-translations-directory-pathname (&key (direction :input))
+    (xdg-config-pathname *output-translations-directory* direction))
+  (defun system-output-translations-directory-pathname (&key (direction :input))
+    (find-preferred-file (system-config-pathnames *output-translations-directory*)
+                         :direction direction))
+  (defun environment-output-translations ()
+    (getenv "ASDF_OUTPUT_TRANSLATIONS"))
 
-  (defclass compile-bundle-op (basic-compile-bundle-op selfward-operation
-                               #+(or clasp ecl mkcl) link-op #-(or clasp ecl) gather-op)
-    ((selfward-operation :initform '(prepare-bundle-op #+(or clasp ecl) lib-op)
-                         :allocation :class))
-    (:documentation "This operator is an alternative to COMPILE-OP. Build a system
-and all of its dependencies, but build only a single (\"monolithic\") FASL, instead
-of one per source file, which may be more resource efficient.  That monolithic
-FASL should be loaded with LOAD-BUNDLE-OP, rather than LOAD-OP."))
 
-  (defclass load-bundle-op (basic-load-op selfward-operation)
-    ((selfward-operation :initform '(prepare-bundle-op compile-bundle-op) :allocation :class))
-    (:documentation "This operator is an alternative to LOAD-OP. Build a system
-and all of its dependencies, using COMPILE-BUNDLE-OP. The difference with
-respect to LOAD-OP is that it builds only a single FASL, which may be
-faster and more resource efficient."))
+  ;;; Processing the configuration.
 
-  ;; NB: since the monolithic-op's can't be sideway-operation's,
-  ;; if we wanted lib-op, dll-op, deliver-asd-op to be sideway-operation's,
-  ;; we'd have to have the monolithic-op not inherit from the main op,
-  ;; but instead inherit from a basic-FOO-op as with basic-compile-bundle-op above.
+  (defgeneric process-output-translations (spec &key inherit collect))
 
-  (defclass dll-op (link-op gather-op non-propagating-operation)
-    ((gather-type :initform :object :allocation :class)
-     (bundle-type :initform :dll :allocation :class))
-    (:documentation "Compile the system and produce a dynamic loadable library (.so/.dll)
-for all the linkable object files associated with the system. Compare with LIB-OP."))
+  (defun inherit-output-translations (inherit &key collect)
+    (when inherit
+      (process-output-translations (first inherit) :collect collect :inherit (rest inherit))))
 
-  (defclass deliver-asd-op (basic-compile-op selfward-operation)
-    ((selfward-operation
-      ;; TODO: implement link-op on all implementations, and make that
-      ;; '(compile-bundle-op lib-op #-(or clasp ecl mkcl) dll-op)
-      :initform '(compile-bundle-op #+(or clasp ecl mkcl) lib-op)
-      :allocation :class))
-    (:documentation "produce an asd file for delivering the system as a single fasl"))
+  (defun* (process-output-translations-directive) (directive &key inherit collect)
+    (if (atom directive)
+        (ecase directive
+          ((:enable-user-cache)
+           (process-output-translations-directive '(t :user-cache) :collect collect))
+          ((:disable-cache)
+           (process-output-translations-directive '(t t) :collect collect))
+          ((:inherit-configuration)
+           (inherit-output-translations inherit :collect collect))
+          ((:ignore-inherited-configuration :ignore-invalid-entries nil)
+           nil))
+        (let ((src (first directive))
+              (dst (second directive)))
+          (if (eq src :include)
+              (when dst
+                (process-output-translations (pathname dst) :inherit nil :collect collect))
+              (when src
+                (let ((trusrc (or (eql src t)
+                                  (let ((loc (resolve-location src :ensure-directory t :wilden t)))
+                                    (if (absolute-pathname-p loc) (resolve-symlinks* loc) loc)))))
+                  (cond
+                    ((location-function-p dst)
+                     (funcall collect
+                              (list trusrc (ensure-function (second dst)))))
+                    ((typep dst 'boolean)
+                     (funcall collect (list trusrc t)))
+                    (t
+                     (let* ((trudst (resolve-location dst :ensure-directory t :wilden t)))
+                       (funcall collect (list trudst t))
+                       (funcall collect (list trusrc trudst)))))))))))
 
+  (defmethod process-output-translations ((x symbol) &key
+                                                       (inherit *default-output-translations*)
+                                                       collect)
+    (process-output-translations (funcall x) :inherit inherit :collect collect))
+  (defmethod process-output-translations ((pathname pathname) &key inherit collect)
+    (cond
+      ((directory-pathname-p pathname)
+       (process-output-translations (validate-output-translations-directory pathname)
+                                    :inherit inherit :collect collect))
+      ((probe-file* pathname :truename *resolve-symlinks*)
+       (process-output-translations (validate-output-translations-file pathname)
+                                    :inherit inherit :collect collect))
+      (t
+       (inherit-output-translations inherit :collect collect))))
+  (defmethod process-output-translations ((string string) &key inherit collect)
+    (process-output-translations (parse-output-translations-string string)
+                                 :inherit inherit :collect collect))
+  (defmethod process-output-translations ((x null) &key inherit collect)
+    (inherit-output-translations inherit :collect collect))
+  (defmethod process-output-translations ((form cons) &key inherit collect)
+    (dolist (directive (cdr (validate-output-translations-form form)))
+      (process-output-translations-directive directive :inherit inherit :collect collect)))
 
-  (defclass monolithic-deliver-asd-op (monolithic-bundle-op deliver-asd-op)
-    ((selfward-operation
-      ;; TODO: implement link-op on all implementations, and make that
-      ;; '(monolithic-compile-bundle-op monolithic-lib-op #-(or clasp ecl mkcl) monolithic-dll-op)
-      :initform '(monolithic-compile-bundle-op #+(or clasp ecl mkcl) monolithic-lib-op)
-      :allocation :class))
-    (:documentation "produce fasl and asd files for combined system and dependencies."))
 
-  (defclass monolithic-compile-bundle-op
-      (monolithic-bundle-op basic-compile-bundle-op
-       #+(or clasp ecl mkcl) link-op gather-op non-propagating-operation)
-    ((gather-op :initform #-(or clasp ecl mkcl) 'compile-bundle-op #+(or clasp ecl mkcl) 'lib-op
-                :allocation :class)
-     (gather-type :initform #-(or clasp ecl mkcl) :fasl #+(or clasp ecl mkcl) :static-library
-                  :allocation :class))
-    (:documentation "Create a single fasl for the system and its dependencies."))
+  ;;; Top-level entry-points to configure output-translations
 
-  (defclass monolithic-load-bundle-op (monolithic-bundle-op load-bundle-op)
-    ((selfward-operation :initform 'monolithic-compile-bundle-op :allocation :class))
-    (:documentation "Load a single fasl for the system and its dependencies."))
+  (defun compute-output-translations (&optional parameter)
+    "read the configuration, return it"
+    (remove-duplicates
+     (while-collecting (c)
+       (inherit-output-translations
+        `(wrapping-output-translations ,parameter ,@*default-output-translations*) :collect #'c))
+     :test 'equal :from-end t))
 
-  (defclass monolithic-lib-op (monolithic-bundle-op lib-op non-propagating-operation)
-    ((gather-type :initform :static-library :allocation :class))
-    (:documentation "Compile the system and produce a linkable static library (.a/.lib)
-for all the linkable object files associated with the system or its dependencies. See LIB-OP."))
+  ;; Saving the user-provided parameter to output-translations, if any,
+  ;; so we can recompute the translations after code upgrade.
+  (defvar *output-translations-parameter* nil)
 
-  (defclass monolithic-dll-op (monolithic-bundle-op dll-op non-propagating-operation)
-    ((gather-type :initform :static-library :allocation :class))
-    (:documentation "Compile the system and produce a dynamic loadable library (.so/.dll)
-for all the linkable object files associated with the system or its dependencies. See LIB-OP"))
+  ;; Main entry-point for users.
+  (defun initialize-output-translations (&optional (parameter *output-translations-parameter*))
+    "read the configuration, initialize the internal configuration variable,
+return the configuration"
+    (setf *output-translations-parameter* parameter
+          (output-translations) (compute-output-translations parameter)))
 
-  (defclass image-op (monolithic-bundle-op selfward-operation
-                      #+(or clasp ecl mkcl) link-op #+(or clasp ecl mkcl) gather-op)
-    ((bundle-type :initform :image)
-     #+(or clasp ecl mkcl) (gather-type :initform :static-library :allocation :class)
-     (selfward-operation :initform '(#-(or clasp ecl mkcl) load-op) :allocation :class))
-    (:documentation "create an image file from the system and its dependencies"))
+  (defun disable-output-translations ()
+    "Initialize output translations in a way that maps every file to itself,
+effectively disabling the output translation facility."
+    (initialize-output-translations
+     '(:output-translations :disable-cache :ignore-inherited-configuration)))
 
-  (defclass program-op (image-op)
-    ((bundle-type :initform :program))
-    (:documentation "create an executable file from the system and its dependencies"))
+  ;; checks an initial variable to see whether the state is initialized
+  ;; or cleared. In the former case, return current configuration; in
+  ;; the latter, initialize.  ASDF will call this function at the start
+  ;; of (asdf:find-system).
+  (defun ensure-output-translations ()
+    (if (output-translations-initialized-p)
+        (output-translations)
+        (initialize-output-translations)))
 
-  (defun bundle-pathname-type (bundle-type)
-    (etypecase bundle-type
-      ((or null string) ;; pass through nil or string literal
-       bundle-type)
-      ((eql :no-output-file) ;; marker for a bundle-type that has NO output file
-       (error "No output file, therefore no pathname type"))
-      ((eql :fasl) ;; the type of a fasl
-       #-(or clasp ecl mkcl) (compile-file-type) ; on image-based platforms, used as input and output
-       #+(or clasp ecl mkcl) "fasb") ; on C-linking platforms, only used as output for system bundles
-      ((member :image)
-       #+allegro "dxl"
-       #+(and clisp os-windows) "exe"
-       #-(or allegro (and clisp os-windows)) "image")
-      ;; NB: on CLASP and ECL these implementations, we better agree with
-      ;; (compile-file-type :type bundle-type))
-      ((eql :object) ;; the type of a linkable object file
-       (os-cond ((os-unix-p) "o")
-                ((os-windows-p) (if (featurep '(:or :mingw32 :mingw64)) "o" "obj"))))
-      ((member :lib :static-library) ;; the type of a linkable library
-       (os-cond ((os-unix-p) "a")
-                ((os-windows-p) (if (featurep '(:or :mingw32 :mingw64)) "a" "lib"))))
-      ((member :dll :shared-library) ;; the type of a shared library
-       (os-cond ((os-macosx-p) "dylib") ((os-unix-p) "so") ((os-windows-p) "dll")))
-      ((eql :program) ;; the type of an executable program
-       (os-cond ((os-unix-p) nil) ((os-windows-p) "exe")))))
 
-  (defun bundle-output-files (o c)
-    (let ((bundle-type (bundle-type o)))
-      (unless (or (eq bundle-type :no-output-file) ;; NIL already means something regarding type.
-                  (and (null (input-files o c)) (not (member bundle-type '(:image :program)))))
-        (let ((name (or (component-build-pathname c)
-                        (format nil "~A~@[~A~]" (component-name c) (slot-value o 'name-suffix))))
-              (type (bundle-pathname-type bundle-type)))
-          (values (list (subpathname (component-pathname c) name :type type))
-                  (eq (class-of o) (coerce-class (component-build-operation c)
-                                                 :package :asdf/interface
-                                                 :super 'operation
-                                                 :error nil)))))))
+  ;; Top-level entry-point to _use_ output-translations
+  (defun* (apply-output-translations) (path)
+    (etypecase path
+      (logical-pathname
+       path)
+      ((or pathname string)
+       (ensure-output-translations)
+       (loop* :with p = (resolve-symlinks* path)
+              :for (source destination) :in (car *output-translations*)
+              :for root = (when (or (eq source t)
+                                    (and (pathnamep source)
+                                         (not (absolute-pathname-p source))))
+                            (pathname-root p))
+              :for absolute-source = (cond
+                                       ((eq source t) (wilden root))
+                                       (root (merge-pathnames* source root))
+                                       (t source))
+              :when (or (eq source t) (pathname-match-p p absolute-source))
+              :return (translate-pathname* p absolute-source destination root source)
+              :finally (return p)))))
 
-  (defmethod output-files ((o bundle-op) (c system))
-    (bundle-output-files o c))
 
-  #-(or clasp ecl mkcl)
-  (progn
-    (defmethod perform ((o image-op) (c system))
-      (dump-image (output-file o c) :executable (typep o 'program-op)))
-    (defmethod perform :before ((o program-op) (c system))
-      (setf *image-entry-point* (ensure-function (component-entry-point c)))))
+  ;; Hook into uiop's output-translation mechanism
+  #-cormanlisp
+  (setf *output-translation-function* 'apply-output-translations)
 
-  (defclass compiled-file (file-component)
-    ((type :initform #-(or clasp ecl mkcl) (compile-file-type) #+(or clasp ecl mkcl) "fasb")))
 
-  (defclass precompiled-system (system)
-    ((build-pathname :initarg :fasl)))
+  ;;; Implementation-dependent hacks
+  #+abcl ;; ABCL: make it possible to use systems provided in the ABCL jar.
+  (defun translate-jar-pathname (source wildcard)
+    (declare (ignore wildcard))
+    (flet ((normalize-device (pathname)
+             (if (find :windows *features*)
+                 pathname
+                 (make-pathname :defaults pathname :device :unspecific))))
+      (let* ((jar
+               (pathname (first (pathname-device source))))
+             (target-root-directory-namestring
+               (format nil "/___jar___file___root___/~@[~A/~]"
+                       (and (find :windows *features*)
+                            (pathname-device jar))))
+             (relative-source
+               (relativize-pathname-directory source))
+             (relative-jar
+               (relativize-pathname-directory (ensure-directory-pathname jar)))
+             (target-root-directory
+               (normalize-device
+                (pathname-directory-pathname
+                 (parse-namestring target-root-directory-namestring))))
+             (target-root
+               (merge-pathnames* relative-jar target-root-directory))
+             (target
+               (merge-pathnames* relative-source target-root)))
+        (normalize-device (apply-output-translations target))))))
 
-  (defclass prebuilt-system (system)
-    ((build-pathname :initarg :static-library :initarg :lib
-                     :accessor prebuilt-system-static-library))))
+;;;; -----------------------------------------------------------------
+;;;; Source Registry Configuration, by Francois-Rene Rideau
+;;;; See the Manual and https://bugs.launchpad.net/asdf/+bug/485918
 
+(uiop/package:define-package :asdf/source-registry
+  (:recycle :asdf/source-registry :asdf)
+  (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/find-system)
+  (:export
+   #:*source-registry-parameter* #:*default-source-registries*
+   #:invalid-source-registry
+   #:source-registry-initialized-p
+   #:initialize-source-registry #:clear-source-registry #:*source-registry*
+   #:ensure-source-registry #:*source-registry-parameter*
+   #:*default-source-registry-exclusions* #:*source-registry-exclusions*
+   #:*wild-asd* #:directory-asd-files #:register-asd-directory
+   #:*recurse-beyond-asds* #:collect-asds-in-directory #:collect-sub*directories-asd-files
+   #:validate-source-registry-directive #:validate-source-registry-form
+   #:validate-source-registry-file #:validate-source-registry-directory
+   #:parse-source-registry-string #:wrapping-source-registry
+   #:default-user-source-registry #:default-system-source-registry
+   #:user-source-registry #:system-source-registry
+   #:user-source-registry-directory #:system-source-registry-directory
+   #:environment-source-registry #:process-source-registry #:inherit-source-registry
+   #:compute-source-registry #:flatten-source-registry
+   #:sysdef-source-registry-search))
+(in-package :asdf/source-registry)
 
-;;;
-;;; BUNDLE-OP
-;;;
-;;; This operation takes all components from one or more systems and
-;;; creates a single output file, which may be
-;;; a FASL, a statically linked library, a shared library, etc.
-;;; The different targets are defined by specialization.
-;;;
 (with-upgradability ()
-  (defmethod initialize-instance :after ((instance bundle-op) &rest initargs
-                                         &key (name-suffix nil name-suffix-p)
-                                         &allow-other-keys)
-    (declare (ignore initargs name-suffix))
-    (unless name-suffix-p
-      (setf (slot-value instance 'name-suffix)
-            (unless (typep instance 'program-op)
-              ;; "." is no good separator for Logical Pathnames, so we use "--"
-              (if (operation-monolithic-p instance) "--all-systems" #-(or clasp ecl mkcl) "--system"))))
-    (when (typep instance 'monolithic-bundle-op)
-      (destructuring-bind (&key lisp-files prologue-code epilogue-code
-                           &allow-other-keys)
-          (operation-original-initargs instance)
-        (setf (prologue-code instance) prologue-code
-              (epilogue-code instance) epilogue-code)
-        #-(or clasp ecl) (assert (null (or lisp-files #-mkcl epilogue-code #-mkcl prologue-code)))
-        #+(or clasp ecl) (setf (extra-object-files instance) lisp-files)))
-    (setf (extra-build-args instance)
-          (remove-plist-keys
-           '(:type :monolithic :name-suffix :epilogue-code :prologue-code :lisp-files
-             :force :force-not :plan-class) ;; TODO: refactor so we don't mix plan and operation arguments
-           (operation-original-initargs instance))))
-
-  (defgeneric* (trivial-system-p) (component))
-
-  (defun user-system-p (s)
-    (and (typep s 'system)
-         (not (builtin-system-p s))
-         (not (trivial-system-p s)))))
+  (define-condition invalid-source-registry (invalid-configuration warning)
+    ((format :initform (compatfmt "~@<Invalid source registry ~S~@[ in ~S~]~@{ ~@?~}~@:>"))))
 
-(eval-when (#-lispworks :compile-toplevel :load-toplevel :execute)
-  (deftype user-system () '(and system (satisfies user-system-p))))
+  ;; Default list of directories under which the source-registry tree search won't recurse
+  (defvar *default-source-registry-exclusions*
+    '(;;-- Using ack 1.2 exclusions
+      ".bzr" ".cdv"
+      ;; "~.dep" "~.dot" "~.nib" "~.plst" ; we don't support ack wildcards
+      ".git" ".hg" ".pc" ".svn" "CVS" "RCS" "SCCS" "_darcs"
+      "_sgbak" "autom4te.cache" "cover_db" "_build"
+      ;;-- debian often builds stuff under the debian directory... BAD.
+      "debian"))
 
-;;;
-;;; First we handle monolithic bundles.
-;;; These are standalone systems which contain everything,
-;;; including other ASDF systems required by the current one.
-;;; A PROGRAM is always monolithic.
-;;;
-;;; MONOLITHIC SHARED LIBRARIES, PROGRAMS, FASL
-;;;
-(with-upgradability ()
-  (defun direct-dependency-files (o c &key (test 'identity) (key 'output-files) &allow-other-keys)
-    ;; This file selects output files from direct dependencies;
-    ;; your component-depends-on method better gathered the correct dependencies in the correct order.
-    (while-collecting (collect)
-      (map-direct-dependencies
-       t o c #'(lambda (sub-o sub-c)
-                 (loop :for f :in (funcall key sub-o sub-c)
-                       :when (funcall test f) :do (collect f))))))
+  ;; Actual list of directories under which the source-registry tree search won't recurse
+  (defvar *source-registry-exclusions* *default-source-registry-exclusions*)
 
-  (defun pathname-type-equal-function (type)
-    #'(lambda (p) (equal (pathname-type p) type)))
+  ;; The state of the source-registry after search in configured locations
+  (defvar *source-registry* nil
+    "Either NIL (for uninitialized), or an equal hash-table, mapping
+system names to pathnames of .asd files")
 
-  (defmethod input-files ((o gather-op) (c system))
-    (unless (eq (bundle-type o) :no-output-file)
-      (direct-dependency-files
-       o c :key 'output-files
-           :test (pathname-type-equal-function (bundle-pathname-type (gather-type o))))))
+  ;; Saving the user-provided parameter to the source-registry, if any,
+  ;; so we can recompute the source-registry after code upgrade.
+  (defvar *source-registry-parameter* nil)
 
-  (defun select-bundle-operation (type &optional monolithic)
-    (ecase type
-      ((:dll :shared-library)
-       (if monolithic 'monolithic-dll-op 'dll-op))
-      ((:lib :static-library)
-       (if monolithic 'monolithic-lib-op 'lib-op))
-      ((:fasl)
-       (if monolithic 'monolithic-compile-bundle-op 'compile-bundle-op))
-      ((:image)
-       'image-op)
-      ((:program)
-       'program-op)))
-
-  ;; DEPRECATED. This is originally from asdf-ecl.lisp. Does anyone use it?
-  (defun make-build (system &rest args &key (monolithic nil) (type :fasl)
-                             (move-here nil move-here-p)
-                             &allow-other-keys)
-    (let* ((operation-name (select-bundle-operation type monolithic))
-           (move-here-path (if (and move-here
-                                    (typep move-here '(or pathname string)))
-                               (ensure-pathname move-here :namestring :lisp :ensure-directory t)
-                               (system-relative-pathname system "asdf-output/")))
-           (operation (apply #'operate operation-name
-                             system
-                             (remove-plist-keys '(:monolithic :type :move-here) args)))
-           (system (find-system system))
-           (files (and system (output-files operation system))))
-      (if (or move-here (and (null move-here-p)
-                             (member operation-name '(:program :image))))
-          (loop :with dest-path = (resolve-symlinks* (ensure-directories-exist move-here-path))
-                :for f :in files
-                :for new-f = (make-pathname :name (pathname-name f)
-                                            :type (pathname-type f)
-                                            :defaults dest-path)
-                :do (rename-file-overwriting-target f new-f)
-                :collect new-f)
-          files)))
-
-  ;; DEPRECATED. Does anyone use this?
-  (defun bundle-system (system &rest args &key force (verbose t) version &allow-other-keys)
-    (declare (ignore force verbose version))
-    (apply #'operate 'deliver-asd-op system args)))
+  (defun source-registry-initialized-p ()
+    (typep *source-registry* 'hash-table))
 
-;;;
-;;; LOAD-BUNDLE-OP
-;;;
-;;; This is like ASDF's LOAD-OP, but using bundle fasl files.
-;;;
-(with-upgradability ()
-  (defmethod component-depends-on ((o load-bundle-op) (c system))
-    `((,o ,@(component-sideway-dependencies c))
-      (,(if (user-system-p c) 'compile-bundle-op 'load-op) ,c)
-      ,@(call-next-method)))
+  (defun clear-source-registry ()
+    "Undoes any initialization of the source registry."
+    (setf *source-registry* nil)
+    (values))
+  (register-clear-configuration-hook 'clear-source-registry)
 
-  (defmethod input-files ((o load-bundle-op) (c system))
-    (when (user-system-p c)
-      (output-files (find-operation o 'compile-bundle-op) c)))
+  (defparameter *wild-asd*
+    (make-pathname :directory nil :name *wild* :type "asd" :version :newest))
 
-  (defmethod perform ((o load-bundle-op) (c system))
-    (when (input-files o c)
-      (perform-lisp-load-fasl o c)))
+  (defun directory-asd-files (directory)
+    (directory-files directory *wild-asd*))
 
-  (defmethod mark-operation-done :after ((o load-bundle-op) (c system))
-    (mark-operation-done (find-operation o 'load-op) c)))
+  (defun collect-asds-in-directory (directory collect)
+    (let ((asds (directory-asd-files directory)))
+      (map () collect asds)
+      asds))
 
-;;;
-;;; PRECOMPILED FILES
-;;;
-;;; This component can be used to distribute ASDF systems in precompiled form.
-;;; Only useful when the dependencies have also been precompiled.
-;;;
-(with-upgradability ()
-  (defmethod trivial-system-p ((s system))
-    (every #'(lambda (c) (typep c 'compiled-file)) (component-children s)))
+  (defvar *recurse-beyond-asds* t
+    "Should :tree entries of the source-registry recurse in subdirectories
+after having found a .asd file? True by default.")
 
-  (defmethod input-files ((o operation) (c compiled-file))
-    (list (component-pathname c)))
-  (defmethod perform ((o load-op) (c compiled-file))
-    (perform-lisp-load-fasl o c))
-  (defmethod perform ((o load-source-op) (c compiled-file))
-    (perform (find-operation o 'load-op) c))
-  (defmethod perform ((o operation) (c compiled-file))
-    nil))
+  ;; When walking down a filesystem tree, if in a directory there is a .cl-source-registry.cache,
+  ;; read its contents instead of further recursively querying the filesystem.
+  (defun process-source-registry-cache (directory collect)
+    (let ((cache (ignore-errors
+                  (safe-read-file-form (subpathname directory ".cl-source-registry.cache")))))
+      (when (and (listp cache) (eq :source-registry-cache (first cache)))
+        (loop :for s :in (rest cache) :do (funcall collect (subpathname directory s)))
+        t)))
 
-;;;
-;;; Pre-built systems
-;;;
-(with-upgradability ()
-  (defmethod trivial-system-p ((s prebuilt-system))
-    t)
+  (defun collect-sub*directories-asd-files
+      (directory &key (exclude *default-source-registry-exclusions*) collect
+                   (recurse-beyond-asds *recurse-beyond-asds*) ignore-cache)
+    (let ((visited (make-hash-table :test 'equalp)))
+      (flet ((collectp (dir)
+               (unless (and (not ignore-cache) (process-source-registry-cache directory collect))
+                 (let ((asds (collect-asds-in-directory dir collect)))
+                   (or recurse-beyond-asds (not asds)))))
+             (recursep (x)                    ; x will be a directory pathname
+               (and
+                (not (member (car (last (pathname-directory x))) exclude :test #'equal))
+                (flet ((pathname-key (x)
+                         (namestring (truename* x))))
+                  (let ((visitedp (gethash (pathname-key x) visited)))
+                    (if visitedp nil
+                        (setf (gethash (pathname-key x) visited) t)))))))
+      (collect-sub*directories directory #'collectp #'recursep (constantly nil)))))
+
+
+  ;;; Validate the configuration forms
 
-  (defmethod perform ((o link-op) (c prebuilt-system))
-    nil)
+  (defun validate-source-registry-directive (directive)
+    (or (member directive '(:default-registry))
+        (and (consp directive)
+             (let ((rest (rest directive)))
+               (case (first directive)
+                 ((:include :directory :tree)
+                  (and (length=n-p rest 1)
+                       (location-designator-p (first rest))))
+                 ((:exclude :also-exclude)
+                  (every #'stringp rest))
+                 ((:default-registry)
+                  (null rest)))))))
 
-  (defmethod perform ((o basic-compile-bundle-op) (c prebuilt-system))
-    nil)
+  (defun validate-source-registry-form (form &key location)
+    (validate-configuration-form
+     form :source-registry 'validate-source-registry-directive
+          :location location :invalid-form-reporter 'invalid-source-registry))
 
-  (defmethod perform ((o lib-op) (c prebuilt-system))
-    nil)
+  (defun validate-source-registry-file (file)
+    (validate-configuration-file
+     file 'validate-source-registry-form :description "a source registry"))
 
-  (defmethod perform ((o dll-op) (c prebuilt-system))
-    nil)
+  (defun validate-source-registry-directory (directory)
+    (validate-configuration-directory
+     directory :source-registry 'validate-source-registry-directive
+               :invalid-form-reporter 'invalid-source-registry))
 
-  (defmethod component-depends-on ((o gather-op) (c prebuilt-system))
-    nil)
 
-  (defmethod output-files ((o lib-op) (c prebuilt-system))
-    (values (list (prebuilt-system-static-library c)) t)))
+  ;;; Parse the configuration string
 
+  (defun parse-source-registry-string (string &key location)
+    (cond
+      ((or (null string) (equal string ""))
+       '(:source-registry :inherit-configuration))
+      ((not (stringp string))
+       (error (compatfmt "~@<Environment string isn't: ~3i~_~S~@:>") string))
+      ((find (char string 0) "\"(")
+       (validate-source-registry-form (read-from-string string) :location location))
+      (t
+       (loop
+         :with inherit = nil
+         :with directives = ()
+         :with start = 0
+         :with end = (length string)
+         :with separator = (inter-directory-separator)
+         :for pos = (position separator string :start start) :do
+           (let ((s (subseq string start (or pos end))))
+             (flet ((check (dir)
+                      (unless (absolute-pathname-p dir)
+                        (error (compatfmt "~@<source-registry string must specify absolute pathnames: ~3i~_~S~@:>") string))
+                      dir))
+               (cond
+                 ((equal "" s) ; empty element: inherit
+                  (when inherit
+                    (error (compatfmt "~@<Only one inherited configuration allowed: ~3i~_~S~@:>")
+                           string))
+                  (setf inherit t)
+                  (push ':inherit-configuration directives))
+                 ((string-suffix-p s "//") ;; TODO: allow for doubling of separator even outside Unix?
+                  (push `(:tree ,(check (subseq s 0 (- (length s) 2)))) directives))
+                 (t
+                  (push `(:directory ,(check s)) directives))))
+             (cond
+               (pos
+                (setf start (1+ pos)))
+               (t
+                (unless inherit
+                  (push '(:ignore-inherited-configuration) directives))
+                (return `(:source-registry ,@(nreverse directives))))))))))
 
-;;;
-;;; PREBUILT SYSTEM CREATOR
-;;;
-(with-upgradability ()
-  (defmethod output-files ((o deliver-asd-op) (s system))
-    (list (make-pathname :name (component-name s) :type "asd"
-                         :defaults (component-pathname s))))
+  (defun register-asd-directory (directory &key recurse exclude collect)
+    (if (not recurse)
+        (collect-asds-in-directory directory collect)
+        (collect-sub*directories-asd-files
+         directory :exclude exclude :collect collect)))
 
-  (defmethod perform ((o deliver-asd-op) (s system))
-    (let* ((inputs (input-files o s))
-           (fasl (first inputs))
-           (library (second inputs))
-           (asd (first (output-files o s)))
-           (name (if (and fasl asd) (pathname-name asd) (return-from perform)))
-           (version (component-version s))
-           (dependencies
-             (if (operation-monolithic-p o)
-                 (remove-if-not 'builtin-system-p
-                                (required-components s :component-type 'system
-                                                       :keep-operation 'load-op))
-                 (while-collecting (x) ;; resolve the sideway-dependencies of s
-                   (map-direct-dependencies
-                    t 'load-op s
-                    #'(lambda (o c)
-                        (when (and (typep o 'load-op) (typep c 'system))
-                          (x c)))))))
-           (depends-on (mapcar 'coerce-name dependencies)))
-      (when (pathname-equal asd (system-source-file s))
-        (cerror "overwrite the asd file"
-                "~/asdf-action:format-action/ is going to overwrite the system definition file ~S which is probably not what you want; you probably need to tweak your output translations."
-                (cons o s) asd))
-      (with-open-file (s asd :direction :output :if-exists :supersede
-                             :if-does-not-exist :create)
-        (format s ";;; Prebuilt~:[~; monolithic~] ASDF definition for system ~A~%"
-                (operation-monolithic-p o) name)
-        (format s ";;; Built for ~A ~A on a ~A/~A ~A~%"
-                (lisp-implementation-type)
-                (lisp-implementation-version)
-                (software-type)
-                (machine-type)
-                (software-version))
-        (let ((*package* (find-package :asdf-user)))
-          (pprint `(defsystem ,name
-                     :class prebuilt-system
-                     :version ,version
-                     :depends-on ,depends-on
-                     :components ((:compiled-file ,(pathname-name fasl)))
-                     ,@(when library `(:lib ,(file-namestring library))))
-                  s)
-          (terpri s)))))
+  (defparameter* *default-source-registries*
+    '(environment-source-registry
+      user-source-registry
+      user-source-registry-directory
+      default-user-source-registry
+      system-source-registry
+      system-source-registry-directory
+      default-system-source-registry)
+    "List of default source registries" "3.1.0.102")
 
-  #-(or clasp ecl mkcl)
-  (defmethod perform ((o basic-compile-bundle-op) (c system))
-    (let* ((input-files (input-files o c))
-           (fasl-files (remove (compile-file-type) input-files :key #'pathname-type :test-not #'equalp))
-           (non-fasl-files (remove (compile-file-type) input-files :key #'pathname-type :test #'equalp))
-           (output-files (output-files o c))
-           (output-file (first output-files)))
-      (assert (eq (not input-files) (not output-files)))
-      (when input-files
-        (when non-fasl-files
-          (error "On ~A, asdf/bundle can only bundle FASL files, but these were also produced: ~S"
-                 (implementation-type) non-fasl-files))
-        (when (or (prologue-code o) (epilogue-code o)
-                  (prologue-code c) (epilogue-code c))
-          (error "prologue-code and epilogue-code are not supported on ~A"
-                 (implementation-type)))
-        (with-staging-pathname (output-file)
-          (combine-fasls fasl-files output-file)))))
+  (defparameter *source-registry-file* (parse-unix-namestring "common-lisp/source-registry.conf"))
+  (defparameter *source-registry-directory* (parse-unix-namestring "common-lisp/source-registry.conf.d/"))
 
-  (defmethod input-files ((o load-op) (s precompiled-system))
-    (bundle-output-files (find-operation o 'compile-bundle-op) s))
+  (defun wrapping-source-registry ()
+    `(:source-registry
+      #+(or clasp ecl sbcl) (:tree ,(resolve-symlinks* (lisp-implementation-directory)))
+      :inherit-configuration
+      #+mkcl (:tree ,(translate-logical-pathname "SYS:"))
+      #+cmucl (:tree #p"modules:")
+      #+scl (:tree #p"file://modules/")))
+  (defun default-user-source-registry ()
+    `(:source-registry
+      (:tree (:home "common-lisp/"))
+      #+sbcl (:directory (:home ".sbcl/systems/"))
+      (:directory ,(xdg-data-home "common-lisp/systems/"))
+      (:tree ,(xdg-data-home "common-lisp/source/"))
+      :inherit-configuration))
+  (defun default-system-source-registry ()
+    `(:source-registry
+      ,@(loop :for dir :in (xdg-data-dirs "common-lisp/")
+              :collect `(:directory (,dir "systems/"))
+              :collect `(:tree (,dir "source/")))
+      :inherit-configuration))
+  (defun user-source-registry (&key (direction :input))
+    (xdg-config-pathname *source-registry-file* direction))
+  (defun system-source-registry (&key (direction :input))
+    (find-preferred-file (system-config-pathnames *source-registry-file*)
+                         :direction direction))
+  (defun user-source-registry-directory (&key (direction :input))
+    (xdg-config-pathname *source-registry-directory* direction))
+  (defun system-source-registry-directory (&key (direction :input))
+    (find-preferred-file (system-config-pathnames *source-registry-directory*)
+                         :direction direction))
+  (defun environment-source-registry ()
+    (getenv "CL_SOURCE_REGISTRY"))
 
-  (defmethod perform ((o load-op) (s precompiled-system))
-    (perform-lisp-load-fasl o s))
 
-  (defmethod component-depends-on ((o load-bundle-op) (s precompiled-system))
-    #+xcl (declare (ignorable o))
-    `((load-op ,s) ,@(call-next-method))))
+  ;;; Process the source-registry configuration
 
-#| ;; Example use:
-(asdf:defsystem :precompiled-asdf-utils :class asdf::precompiled-system :fasl (asdf:apply-output-translations (asdf:system-relative-pathname :asdf-utils "asdf-utils.system.fasl")))
-(asdf:load-system :precompiled-asdf-utils)
-|#
+  (defgeneric process-source-registry (spec &key inherit register))
 
-#+(or clasp ecl mkcl)
-(with-upgradability ()
-  ;; I think that Juanjo intended for this to be, but it was disabled before 3.1
-  ;; due to implementation bugs in ECL and MKCL that seem to have been fixed since
-  ;; -- see for ECL test-xach-update-bug.script and test-bundle.script,
-  ;; and for MKCL test-logical-pathname.script.
-  ;; We should probably reenable these after consulting with ECL and MKCL maintainers.
-  ;;(unless (or #+(or clasp ecl) (use-ecl-byte-compiler-p))
-  ;;  (setf *load-system-operation* 'load-bundle-op))
-
-  (defun uiop-library-pathname ()
-    #+clasp (probe-file* (compile-file-pathname "sys:uiop" :output-type :object))
-    #+ecl (or (probe-file* (compile-file-pathname "sys:uiop" :type :lib)) ;; new style
-              (probe-file* (compile-file-pathname "sys:uiop" :type :object))) ;; old style
-    #+mkcl (make-pathname :type (bundle-pathname-type :lib) :defaults #p"sys:contrib;uiop"))
-
-  (defun asdf-library-pathname ()
-    #+clasp (probe-file* (compile-file-pathname "sys:asdf" :output-type :object))
-    #+ecl (or (probe-file* (compile-file-pathname "sys:asdf" :type :lib)) ;; new style
-              (probe-file* (compile-file-pathname "sys:asdf" :type :object))) ;; old style
-    #+mkcl (make-pathname :type (bundle-pathname-type :lib) :defaults #p"sys:contrib;asdf"))
-
-  (defun compiler-library-pathname ()
-    #+clasp (compile-file-pathname "sys:cmp" :output-type :lib)
-    #+ecl (compile-file-pathname "sys:cmp" :type :lib)
-    #+mkcl (make-pathname :type (bundle-pathname-type :lib) :defaults #p"sys:cmp"))
-
-  (defun make-library-system (name pathname)
-    (make-instance 'prebuilt-system
-                   :name (coerce-name name) :static-library (resolve-symlinks* pathname)))
+  (defun* (inherit-source-registry) (inherit &key register)
+    (when inherit
+      (process-source-registry (first inherit) :register register :inherit (rest inherit))))
+
+  (defun* (process-source-registry-directive) (directive &key inherit register)
+    (destructuring-bind (kw &rest rest) (if (consp directive) directive (list directive))
+      (ecase kw
+        ((:include)
+         (destructuring-bind (pathname) rest
+           (process-source-registry (resolve-location pathname) :inherit nil :register register)))
+        ((:directory)
+         (destructuring-bind (pathname) rest
+           (when pathname
+             (funcall register (resolve-location pathname :ensure-directory t)))))
+        ((:tree)
+         (destructuring-bind (pathname) rest
+           (when pathname
+             (funcall register (resolve-location pathname :ensure-directory t)
+                      :recurse t :exclude *source-registry-exclusions*))))
+        ((:exclude)
+         (setf *source-registry-exclusions* rest))
+        ((:also-exclude)
+         (appendf *source-registry-exclusions* rest))
+        ((:default-registry)
+         (inherit-source-registry
+          '(default-user-source-registry default-system-source-registry) :register register))
+        ((:inherit-configuration)
+         (inherit-source-registry inherit :register register))
+        ((:ignore-inherited-configuration)
+         nil)))
+    nil)
 
-  (defmethod component-depends-on :around ((o image-op) (c system))
-    (destructuring-bind ((lib-op . deps)) (call-next-method)
-      (flet ((has-it-p (x) (find x deps :test 'equal :key 'coerce-name)))
-        `((,lib-op
-           ,@(unless (or (no-uiop c) (has-it-p "cmp"))
-               `(,(make-library-system
-                   "cmp" (compiler-library-pathname))))
-           ,@(unless (or (no-uiop c) (has-it-p "uiop") (has-it-p "asdf"))
-               (cond
-                 ((system-source-directory :uiop) `(,(find-system :uiop)))
-                 ((system-source-directory :asdf) `(,(find-system :asdf)))
-                 (t `(,@(if-let (uiop (uiop-library-pathname))
-                          `(,(make-library-system "uiop" uiop)))
-                      ,(make-library-system "asdf" (asdf-library-pathname))))))
-           ,@deps)))))
+  (defmethod process-source-registry ((x symbol) &key inherit register)
+    (process-source-registry (funcall x) :inherit inherit :register register))
+  (defmethod process-source-registry ((pathname pathname) &key inherit register)
+    (cond
+      ((directory-pathname-p pathname)
+       (let ((*here-directory* (resolve-symlinks* pathname)))
+         (process-source-registry (validate-source-registry-directory pathname)
+                                  :inherit inherit :register register)))
+      ((probe-file* pathname :truename *resolve-symlinks*)
+       (let ((*here-directory* (pathname-directory-pathname pathname)))
+         (process-source-registry (validate-source-registry-file pathname)
+                                  :inherit inherit :register register)))
+      (t
+       (inherit-source-registry inherit :register register))))
+  (defmethod process-source-registry ((string string) &key inherit register)
+    (process-source-registry (parse-source-registry-string string)
+                             :inherit inherit :register register))
+  (defmethod process-source-registry ((x null) &key inherit register)
+    (inherit-source-registry inherit :register register))
+  (defmethod process-source-registry ((form cons) &key inherit register)
+    (let ((*source-registry-exclusions* *default-source-registry-exclusions*))
+      (dolist (directive (cdr (validate-source-registry-form form)))
+        (process-source-registry-directive directive :inherit inherit :register register))))
 
-  (defmethod perform ((o link-op) (c system))
-    (let* ((object-files (input-files o c))
-           (output (output-files o c))
-           (bundle (first output))
-           (programp (typep o 'program-op))
-           (kind (bundle-type o)))
-      (when output
-        (apply 'create-image
-               bundle (append
-                       (when programp (prefix-lisp-object-files c))
-                       object-files
-                       (when programp (postfix-lisp-object-files c)))
-               :kind kind
-               :prologue-code (or (prologue-code o) (when programp (prologue-code c)))
-               :epilogue-code (or (epilogue-code o) (when programp (epilogue-code c)))
-               :build-args (or (extra-build-args o) (when programp (extra-build-args c)))
-               :extra-object-files (or (extra-object-files o) (when programp (extra-object-files c)))
-               :no-uiop (no-uiop c)
-               (when programp `(:entry-point ,(component-entry-point c))))))))
-;;;; -------------------------------------------------------------------------
-;;;; Concatenate-source
 
-(uiop/package:define-package :asdf/concatenate-source
-  (:recycle :asdf/concatenate-source :asdf)
-  (:use :uiop/common-lisp :uiop :asdf/upgrade
-   :asdf/component :asdf/operation
-   :asdf/system :asdf/find-system
-   :asdf/action :asdf/lisp-action :asdf/bundle)
-  (:export
-   #:concatenate-source-op
-   #:load-concatenated-source-op
-   #:compile-concatenated-source-op
-   #:load-compiled-concatenated-source-op
-   #:monolithic-concatenate-source-op
-   #:monolithic-load-concatenated-source-op
-   #:monolithic-compile-concatenated-source-op
-   #:monolithic-load-compiled-concatenated-source-op))
-(in-package :asdf/concatenate-source)
+  ;; Flatten the user-provided configuration into an ordered list of directories and trees
+  (defun flatten-source-registry (&optional (parameter *source-registry-parameter*))
+    (remove-duplicates
+     (while-collecting (collect)
+       (with-pathname-defaults () ;; be location-independent
+         (inherit-source-registry
+          `(wrapping-source-registry
+            ,parameter
+            ,@*default-source-registries*)
+          :register #'(lambda (directory &key recurse exclude)
+                        (collect (list directory :recurse recurse :exclude exclude))))))
+     :test 'equal :from-end t))
 
-;;;
-;;; Concatenate sources
-;;;
-(with-upgradability ()
-  (defclass basic-concatenate-source-op (bundle-op)
-    ((bundle-type :initform "lisp")))
-  (defclass basic-load-concatenated-source-op (basic-load-op selfward-operation) ())
-  (defclass basic-compile-concatenated-source-op (basic-compile-op selfward-operation) ())
-  (defclass basic-load-compiled-concatenated-source-op (basic-load-op selfward-operation) ())
+  ;; Will read the configuration and initialize all internal variables.
+  (defun compute-source-registry (&optional (parameter *source-registry-parameter*)
+                                    (registry *source-registry*))
+    (dolist (entry (flatten-source-registry parameter))
+      (destructuring-bind (directory &key recurse exclude) entry
+        (let* ((h (make-hash-table :test 'equal))) ; table to detect duplicates
+          (register-asd-directory
+           directory :recurse recurse :exclude exclude :collect
+           #'(lambda (asd)
+               (let* ((name (pathname-name asd))
+                      (name (if (typep asd 'logical-pathname)
+                                ;; logical pathnames are upper-case,
+                                ;; at least in the CLHS and on SBCL,
+                                ;; yet (coerce-name :foo) is lower-case.
+                                ;; won't work well with (load-system "Foo")
+                                ;; instead of (load-system 'foo)
+                                (string-downcase name)
+                                name)))
+                 (cond
+                   ((gethash name registry) ; already shadowed by something else
+                    nil)
+                   ((gethash name h) ; conflict at current level
+                    (when *verbose-out*
+                      (warn (compatfmt "~@<In source-registry entry ~A~@[/~*~] ~
+                                found several entries for ~A - picking ~S over ~S~:>")
+                            directory recurse name (gethash name h) asd)))
+                   (t
+                    (setf (gethash name registry) asd)
+                    (setf (gethash name h) asd))))))
+          h)))
+    (values))
 
-  (defclass concatenate-source-op (basic-concatenate-source-op non-propagating-operation) ())
-  (defclass load-concatenated-source-op (basic-load-concatenated-source-op)
-    ((selfward-operation :initform '(prepare-op concatenate-source-op) :allocation :class)))
-  (defclass compile-concatenated-source-op (basic-compile-concatenated-source-op)
-    ((selfward-operation :initform '(prepare-op concatenate-source-op) :allocation :class)))
-  (defclass load-compiled-concatenated-source-op (basic-load-compiled-concatenated-source-op)
-    ((selfward-operation :initform '(prepare-op compile-concatenated-source-op) :allocation :class)))
+  (defun initialize-source-registry (&optional (parameter *source-registry-parameter*))
+    ;; Record the parameter used to configure the registry
+    (setf *source-registry-parameter* parameter)
+    ;; Clear the previous registry database:
+    (setf *source-registry* (make-hash-table :test 'equal))
+    ;; Do it!
+    (compute-source-registry parameter))
 
-  (defclass monolithic-concatenate-source-op (basic-concatenate-source-op monolithic-bundle-op non-propagating-operation) ())
-  (defclass monolithic-load-concatenated-source-op (basic-load-concatenated-source-op)
-    ((selfward-operation :initform 'monolithic-concatenate-source-op :allocation :class)))
-  (defclass monolithic-compile-concatenated-source-op (basic-compile-concatenated-source-op)
-    ((selfward-operation :initform 'monolithic-concatenate-source-op :allocation :class)))
-  (defclass monolithic-load-compiled-concatenated-source-op (basic-load-compiled-concatenated-source-op)
-    ((selfward-operation :initform 'monolithic-compile-concatenated-source-op :allocation :class)))
+  ;; Checks an initial variable to see whether the state is initialized
+  ;; or cleared. In the former case, return current configuration; in
+  ;; the latter, initialize.  ASDF will call this function at the start
+  ;; of (asdf:find-system) to make sure the source registry is initialized.
+  ;; However, it will do so *without* a parameter, at which point it
+  ;; will be too late to provide a parameter to this function, though
+  ;; you may override the configuration explicitly by calling
+  ;; initialize-source-registry directly with your parameter.
+  (defun ensure-source-registry (&optional parameter)
+    (unless (source-registry-initialized-p)
+      (initialize-source-registry parameter))
+    (values))
 
-  (defmethod input-files ((operation basic-concatenate-source-op) (s system))
-    (loop :with encoding = (or (component-encoding s) *default-encoding*)
-          :with other-encodings = '()
-          :with around-compile = (around-compile-hook s)
-          :with other-around-compile = '()
-          :for c :in (required-components
-                      s :goal-operation 'compile-op
-                        :keep-operation 'compile-op
-                        :other-systems (operation-monolithic-p operation))
-          :append
-          (when (typep c 'cl-source-file)
-            (let ((e (component-encoding c)))
-              (unless (equal e encoding)
-                (let ((a (assoc e other-encodings)))
-                  (if a (push (component-find-path c) (cdr a))
-                      (push (list a (component-find-path c)) other-encodings)))))
-            (unless (equal around-compile (around-compile-hook c))
-              (push (component-find-path c) other-around-compile))
-            (input-files (make-operation 'compile-op) c)) :into inputs
-          :finally
-             (when other-encodings
-               (warn "~S uses encoding ~A but has sources that use these encodings:~{ ~A~}"
-                     operation encoding
-                     (mapcar #'(lambda (x) (cons (car x) (list (reverse (cdr x)))))
-                             other-encodings)))
-             (when other-around-compile
-               (warn "~S uses around-compile hook ~A but has sources that use these hooks: ~A"
-                     operation around-compile other-around-compile))
-             (return inputs)))
-  (defmethod output-files ((o basic-compile-concatenated-source-op) (s system))
-    (lisp-compilation-output-files o s))
+  (defun sysdef-source-registry-search (system)
+    (ensure-source-registry)
+    (values (gethash (primary-system-name system) *source-registry*))))
 
-  (defmethod perform ((o basic-concatenate-source-op) (s system))
-    (let* ((ins (input-files o s))
-           (out (output-file o s))
-           (tmp (tmpize-pathname out)))
-      (concatenate-files ins tmp)
-      (rename-file-overwriting-target tmp out)))
-  (defmethod perform ((o basic-load-concatenated-source-op) (s system))
-    (perform-lisp-load-source o s))
-  (defmethod perform ((o basic-compile-concatenated-source-op) (s system))
-    (perform-lisp-compilation o s))
-  (defmethod perform ((o basic-load-compiled-concatenated-source-op) (s system))
-    (perform-lisp-load-fasl o s)))
 
 ;;;; -------------------------------------------------------------------------
 ;;;; Package systems in the style of quick-build or faslpath
@@ -11064,27 +12170,36 @@ for all the linkable object files associated with the system or its dependencies
 (in-package :asdf/package-inferred-system)
 
 (with-upgradability ()
+  ;; The names of the recognized defpackage forms.
   (defparameter *defpackage-forms* '(defpackage define-package))
 
   (defun initial-package-inferred-systems-table ()
+    ;; Mark all existing packages are preloaded.
     (let ((h (make-hash-table :test 'equal)))
       (dolist (p (list-all-packages))
         (dolist (n (package-names p))
           (setf (gethash n h) t)))
       h))
 
+  ;; Mapping from package names to systems that provide them.
   (defvar *package-inferred-systems* (initial-package-inferred-systems-table))
 
   (defclass package-inferred-system (system)
-    ())
+    ()
+    (:documentation "Class for primary systems for which secondary systems are automatically
+in the one-file, one-file, one-system style: system names are mapped to files under the primary
+system's system-source-directory, dependencies are inferred from the first defpackage form in
+every such file"))
 
-  ;; For backward compatibility only. To be removed in an upcoming release:
+  ;; DEPRECATED. For backward compatibility only. To be removed in an upcoming release:
   (defclass package-system (package-inferred-system) ())
 
+  ;; Is a given form recognizable as a defpackage form?
   (defun defpackage-form-p (form)
     (and (consp form)
          (member (car form) *defpackage-forms*)))
 
+  ;; Find the first defpackage form in a stream, if any
   (defun stream-defpackage-form (stream)
     (loop :for form = (read stream nil nil) :while form
           :when (defpackage-form-p form) :return form))
@@ -11119,6 +12234,7 @@ the DEFPACKAGE-FORM uses it or imports a symbol from it."
      :from-end t :test 'equal))
 
   (defun package-designator-name (package)
+    "Normalize a package designator to a string"
     (etypecase package
       (package (package-name package))
       (string package)
@@ -11134,15 +12250,17 @@ the DEFPACKAGE-FORM uses it or imports a symbol from it."
     "Return the name of the SYSTEM providing PACKAGE-NAME, if such exists,
 otherwise return a default system name computed from PACKAGE-NAME."
     (check-type package-name string)
-    (if-let ((system-name (gethash package-name *package-inferred-systems*)))
-      system-name
-      (string-downcase package-name)))
+    (or (gethash package-name *package-inferred-systems*)
+        (string-downcase package-name)))
 
+  ;; Given a file in package-inferred-system style, find its dependencies
   (defun package-inferred-system-file-dependencies (file &optional system)
     (if-let (defpackage-form (file-defpackage-form file))
       (remove t (mapcar 'package-name-system (package-dependencies defpackage-form)))
       (error 'package-inferred-system-missing-package-error :system system :pathname file)))
 
+  ;; Given package-inferred-system object, check whether its specification matches
+  ;; the provided parameters
   (defun same-package-inferred-system-p (system name directory subpath around-compile dependencies)
     (and (eq (type-of system) 'package-inferred-system)
          (equal (component-name system) name)
@@ -11157,6 +12275,7 @@ otherwise return a default system name computed from PACKAGE-NAME."
                        (and (slot-boundp child 'relative-pathname)
                             (equal (slot-value child 'relative-pathname) subpath))))))))
 
+  ;; sysdef search function to push into *system-definition-search-functions*
   (defun sysdef-package-inferred-system-search (system)
     (let ((primary (primary-system-name system)))
       (unless (equal primary system)
@@ -11168,7 +12287,7 @@ otherwise return a default system name computed from PACKAGE-NAME."
                                      :truename *resolve-symlinks*)))
                 (when (file-pathname-p f)
                   (let ((dependencies (package-inferred-system-file-dependencies f system))
-                        (previous (cdr (system-registered-p system)))
+                        (previous (registered-system system))
                         (around-compile (around-compile-hook top)))
                     (if (same-package-inferred-system-p previous system dir sub around-compile dependencies)
                         previous
@@ -11186,20 +12305,6 @@ otherwise return a default system name computed from PACKAGE-NAME."
         (remove (find-symbol* :sysdef-package-system-search :asdf/package-system nil)
                 *system-definition-search-functions*)))
 ;;;; -------------------------------------------------------------------------
-;;; Internal hacks for backward-compatibility
-
-(uiop/package:define-package :asdf/backward-internals
-  (:recycle :asdf/backward-internals :asdf)
-  (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/find-system)
-  (:export #:load-sysdef))
-(in-package :asdf/backward-internals)
-
-(with-upgradability ()
-  (defun load-sysdef (name pathname)
-    (declare (ignore name pathname))
-    ;; Needed for backward compatibility with swank-asdf from SLIME 2015-12-01 or older.
-    (error "Use asdf:load-asd instead of asdf::load-sysdef")))
-;;;; -------------------------------------------------------------------------
 ;;; Backward-compatible interfaces
 
 (uiop/package:define-package :asdf/backward-interface
@@ -11213,116 +12318,143 @@ otherwise return a default system name computed from PACKAGE-NAME."
    #:error-component #:error-operation #:traverse
    #:component-load-dependencies
    #:enable-asdf-binary-locations-compatibility
-   #:operation-forced
    #:operation-on-failure #:operation-on-warnings #:on-failure #:on-warnings
    #:component-property
    #:run-shell-command
-   #:system-definition-pathname))
+   #:system-definition-pathname
+   #:explain))
 (in-package :asdf/backward-interface)
 
-(with-upgradability ()
-  (define-condition operation-error (error) ;; Bad, backward-compatible name
-    ;; Used by SBCL, cffi-tests, clsql-mysql, clsql-uffi, qt, elephant, uffi-tests, sb-grovel
-    ((component :reader error-component :initarg :component)
-     (operation :reader error-operation :initarg :operation))
-    (:report (lambda (c s)
-               (format s (compatfmt "~@<~A while invoking ~A on ~A~@:>")
-                       (type-of c) (error-operation c) (error-component c)))))
-  (define-condition compile-error (operation-error) ())
-  (define-condition compile-failed (compile-error) ())
-  (define-condition compile-warned (compile-error) ())
+;; NB: the warning status of these functions may have to be distinguished later,
+;; as some get removed faster than the others in client code.
+(with-asdf-deprecation (:style-warning "3.2")
 
-  (defun component-load-dependencies (component)
+  ;; These conditions from ASDF 1 and 2 are used by many packages in Quicklisp;
+  ;; but ASDF3 replaced them with somewhat different variants of uiop:compile-condition
+  ;; that do not involve ASDF actions.
+  ;; TODO: find the offenders and stop them.
+  (progn
+    (define-condition operation-error (error) ;; Bad, backward-compatible name
+      ;; Used by SBCL, cffi-tests, clsql-mysql, clsql-uffi, qt, elephant, uffi-tests, sb-grovel
+      ((component :reader error-component :initarg :component)
+       (operation :reader error-operation :initarg :operation))
+      (:report (lambda (c s)
+                 (format s (compatfmt "~@<~A while invoking ~A on ~A~@:>")
+                         (type-of c) (error-operation c) (error-component c)))))
+    (define-condition compile-error (operation-error) ())
+    (define-condition compile-failed (compile-error) ())
+    (define-condition compile-warned (compile-error) ()))
+
+  ;; In Quicklisp 2015-05, still used by lisp-executable, staple, repl-utilities, cffi
+  (defun component-load-dependencies (component) ;; from ASDF 2.000 to 2.26
+    "DEPRECATED. Please use COMPONENT-SIDEWAY-DEPENDENCIES instead; or better,
+define your operations with proper use of SIDEWAY-OPERATION, SELFWARD-OPERATION,
+or define methods on PREPARE-OP, etc."
     ;; Old deprecated name for the same thing. Please update your software.
     (component-sideway-dependencies component))
 
-  (defgeneric operation-forced (operation)) ;; Used by swank.asd for swank-loader.
-  (defmethod operation-forced ((o operation)) (getf (operation-original-initargs o) :force))
-
-  (defgeneric operation-on-warnings (operation))
-  (defgeneric operation-on-failure (operation))
-  (defgeneric (setf operation-on-warnings) (x operation))
-  (defgeneric (setf operation-on-failure) (x operation))
-  (defmethod operation-on-warnings ((o operation))
-    *compile-file-warnings-behaviour*)
-  (defmethod operation-on-failure ((o operation))
-    *compile-file-failure-behaviour*)
-  (defmethod (setf operation-on-warnings) (x (o operation))
-    (setf *compile-file-warnings-behaviour* x))
-  (defmethod (setf operation-on-failure) (x (o operation))
-    (setf *compile-file-failure-behaviour* x))
-
+  ;; These old interfaces from ASDF1 have never been very meaningful
+  ;; but are still used in obscure places.
+  ;; In Quicklisp 2015-05, still used by cl-protobufs and clx.
+  (defgeneric operation-on-warnings (operation)
+    (:documentation "DEPRECATED. Please use UIOP:*COMPILE-FILE-WARNINGS-BEHAVIOUR* instead."))
+  (defgeneric operation-on-failure (operation)
+    (:documentation "DEPRECATED. Please use UIOP:*COMPILE-FILE-FAILURE-BEHAVIOUR* instead."))
+  (defgeneric (setf operation-on-warnings) (x operation)
+    (:documentation "DEPRECATED. Please SETF UIOP:*COMPILE-FILE-WARNINGS-BEHAVIOUR* instead."))
+  (defgeneric (setf operation-on-failure) (x operation)
+    (:documentation "DEPRECATED. Please SETF UIOP:*COMPILE-FILE-FAILURE-BEHAVIOUR* instead."))
+  (progn
+    (defmethod operation-on-warnings ((o operation))
+      *compile-file-warnings-behaviour*)
+    (defmethod operation-on-failure ((o operation))
+      *compile-file-failure-behaviour*)
+    (defmethod (setf operation-on-warnings) (x (o operation))
+      (setf *compile-file-warnings-behaviour* x))
+    (defmethod (setf operation-on-failure) (x (o operation))
+      (setf *compile-file-failure-behaviour* x)))
+
+  ;; Quicklisp 2015-05: Still used by SLIME's swank-asdf (!), common-lisp-stat,
+  ;; js-parser, osicat, babel, staple, weblocks, cl-png, plain-odbc, autoproject,
+  ;; cl-blapack, com.informatimago, cells-gtk3, asdf-dependency-grovel,
+  ;; cl-glfw, cffi, jwacs, montezuma
   (defun system-definition-pathname (x)
     ;; As of 2.014.8, we mean to make this function obsolete,
     ;; but that won't happen until all clients have been updated.
-    ;;(cerror "Use ASDF:SYSTEM-SOURCE-FILE instead"
-    "Function ASDF:SYSTEM-DEFINITION-PATHNAME is obsolete.
-It used to expose ASDF internals with subtle differences with respect to
-user expectations, that have been refactored away since.
-We recommend you use ASDF:SYSTEM-SOURCE-FILE instead
-for a mostly compatible replacement that we're supporting,
-or even ASDF:SYSTEM-SOURCE-DIRECTORY or ASDF:SYSTEM-RELATIVE-PATHNAME
+    "DEPRECATED. This function used to expose ASDF internals with subtle
+differences with respect to user expectations, that have been refactored
+away since. We recommend you use ASDF:SYSTEM-SOURCE-FILE instead for a
+mostly compatible replacement that we're supporting, or even
+ASDF:SYSTEM-SOURCE-DIRECTORY or ASDF:SYSTEM-RELATIVE-PATHNAME
 if that's whay you mean." ;;)
     (system-source-file x))
 
-  (defgeneric* (traverse) (operation component &key &allow-other-keys)
+  ;; TRAVERSE is the function used to compute a plan in ASDF 1 and 2.
+  ;; It was never officially exposed but some people still used it.
+  (defgeneric traverse (operation component &key &allow-other-keys)
     (:documentation
-     "Generate and return a plan for performing OPERATION on COMPONENT.
+     "DEPRECATED. Use MAKE-PLAN and PLAN-ACTIONS, or REQUIRED-COMPONENTS,
+or some other supported interface instead.
+
+Generate and return a plan for performing OPERATION on COMPONENT.
 
 The plan returned is a list of dotted-pairs. Each pair is the CONS
 of ASDF operation object and a COMPONENT object. The pairs will be
 processed in order by OPERATE."))
-  (define-convenience-action-methods traverse (operation component &key))
-
+  (progn
+    (define-convenience-action-methods traverse (operation component &key)))
   (defmethod traverse ((o operation) (c component) &rest keys &key plan-class &allow-other-keys)
-    (plan-actions (apply 'make-plan plan-class o c keys))))
+    (plan-actions (apply 'make-plan plan-class o c keys)))
 
 
-;;;; ASDF-Binary-Locations compatibility
-;; This remains supported for legacy user, but not recommended for new users.
-(with-upgradability ()
+  ;; ASDF-Binary-Locations compatibility
+  ;; This remains supported for legacy user, but not recommended for new users.
+  ;; We suspect there are no more legacy users in 2016.
   (defun enable-asdf-binary-locations-compatibility
       (&key
-       (centralize-lisp-binaries nil)
-       (default-toplevel-directory
-        (subpathname (user-homedir-pathname) ".fasls/")) ;; Use ".cache/common-lisp/" instead ???
-       (include-per-user-information nil)
-       (map-all-source-files (or #+(or clasp clisp ecl mkcl) t nil))
-       (source-to-target-mappings nil)
-       (file-types `(,(compile-file-type)
-                     "build-report"
-                     #+(or clasp ecl) (compile-file-type :type :object)
-                     #+mkcl (compile-file-type :fasl-p nil)
-                     #+clisp "lib" #+sbcl "cfasl"
-                     #+sbcl "sbcl-warnings" #+clozure "ccl-warnings")))
+         (centralize-lisp-binaries nil)
+         (default-toplevel-directory
+             ;; Use ".cache/common-lisp/" instead ???
+             (subpathname (user-homedir-pathname) ".fasls/"))
+         (include-per-user-information nil)
+         (map-all-source-files (or #+(or clasp clisp ecl mkcl) t nil))
+         (source-to-target-mappings nil)
+         (file-types `(,(compile-file-type)
+                        "build-report"
+                        #+clasp (compile-file-type :output-type :object)
+                        #+ecl (compile-file-type :type :object)
+                        #+mkcl (compile-file-type :fasl-p nil)
+                        #+clisp "lib" #+sbcl "cfasl"
+                        #+sbcl "sbcl-warnings" #+clozure "ccl-warnings")))
+    "DEPRECATED. Use asdf-output-translations instead."
     #+(or clasp clisp ecl mkcl)
     (when (null map-all-source-files)
       (error "asdf:enable-asdf-binary-locations-compatibility doesn't support :map-all-source-files nil on CLISP, ECL and MKCL"))
     (let* ((patterns (if map-all-source-files (list *wild-file*)
                          (loop :for type :in file-types
-                               :collect (make-pathname :type type :defaults *wild-file*))))
+                           :collect (make-pathname :type type :defaults *wild-file*))))
            (destination-directory
-             (if centralize-lisp-binaries
-                 `(,default-toplevel-directory
-                   ,@(when include-per-user-information
-                       (cdr (pathname-directory (user-homedir-pathname))))
-                   :implementation ,*wild-inferiors*)
-                 `(:root ,*wild-inferiors* :implementation))))
+            (if centralize-lisp-binaries
+                `(,default-toplevel-directory
+                     ,@(when include-per-user-information
+                             (cdr (pathname-directory (user-homedir-pathname))))
+                     :implementation ,*wild-inferiors*)
+                `(:root ,*wild-inferiors* :implementation))))
       (initialize-output-translations
        `(:output-translations
          ,@source-to-target-mappings
          #+abcl (#p"jar:file:/**/*.jar!/**/*.*" (:function translate-jar-pathname))
          #+abcl (#p"/___jar___file___root___/**/*.*" (,@destination-directory))
          ,@(loop :for pattern :in patterns
-                 :collect `((:root ,*wild-inferiors* ,pattern)
-                            (,@destination-directory ,pattern)))
+             :collect `((:root ,*wild-inferiors* ,pattern)
+                        (,@destination-directory ,pattern)))
          (t t)
          :ignore-inherited-configuration))))
-
-  (defmethod operate :before (operation-class system &rest args &key &allow-other-keys)
-    (declare (ignore operation-class system args))
-    (when (find-symbol* '#:output-files-for-system-and-operation :asdf nil)
-      (error "ASDF 2 is not compatible with ASDF-BINARY-LOCATIONS, which you are using.
+  (progn
+    (defmethod operate :before (operation-class system &rest args &key &allow-other-keys)
+      (declare (ignore operation-class system args))
+      (when (find-symbol* '#:output-files-for-system-and-operation :asdf nil)
+        (error "ASDF 2 is not compatible with ASDF-BINARY-LOCATIONS, which you are using.
 ASDF 2 now achieves the same purpose with its builtin ASDF-OUTPUT-TRANSLATIONS,
 which should be easier to configure. Please stop using ASDF-BINARY-LOCATIONS,
 and instead use ASDF-OUTPUT-TRANSLATIONS. See the ASDF manual for details.
@@ -11332,33 +12464,32 @@ ASDF:ENABLE-ASDF-BINARY-LOCATIONS-COMPATIBILITY as documented in the manual;
 call that function where you would otherwise have loaded and configured A-B-L."))))
 
 
-;;; run-shell-command
-;; WARNING! The function below is not just deprecated but also dysfunctional.
-;; Please use asdf/run-program:run-program instead.
-(with-upgradability ()
+  ;; run-shell-command from ASDF 2, lightly fixed from ASDF 1, copied from MK-DEFSYSTEM. Die!
   (defun run-shell-command (control-string &rest args)
-    "Interpolate ARGS into CONTROL-STRING as if by FORMAT, and
-synchronously execute the result using a Bourne-compatible shell, with
-output to *VERBOSE-OUT*.  Returns the shell's exit code.
-
-PLEASE DO NOT USE.
-Deprecated function, for backward-compatibility only.
+    "PLEASE DO NOT USE. This function is not just DEPRECATED, but also dysfunctional.
 Please use UIOP:RUN-PROGRAM instead."
+    #-(and ecl os-windows)
     (let ((command (apply 'format nil control-string args)))
       (asdf-message "; $ ~A~%" command)
       (let ((exit-code
-              (ignore-errors
+             (ignore-errors
                (nth-value 2 (run-program command :force-shell t :ignore-error-status t
-                                                 :output *verbose-out*)))))
+                                         :output *verbose-out*)))))
         (typecase exit-code
           ((integer 0 255) exit-code)
-          (t 255))))))
+          (t 255))))
+    #+(and ecl os-windows)
+    (not-implemented-error "run-shell-command" "for ECL on Windows."))
 
-(with-upgradability ()
-  (defvar *asdf-verbose* nil)) ;; backward-compatibility with ASDF2 only. Unused.
+  ;; HOW do we get rid of variables??? With a symbol-macro that issues a warning?
+  ;; In Quicklisp 2015-05, cl-protobufs still uses it, but that should be fixed in next version.
+  (progn
+    (defvar *asdf-verbose* nil)) ;; backward-compatibility with ASDF2 only. Unused.
 
-;; backward-compatibility methods. Do NOT use in new code. NOT SUPPORTED.
-(with-upgradability ()
+  ;; Do NOT use in new code. NOT SUPPORTED.
+  ;; NB: When this goes away, remove the slot PROPERTY in COMPONENT.
+  ;; In Quicklisp 2014-05, it's still used by yaclml, amazon-ecs, blackthorn-engine, cl-tidy.
+  ;; See TODO for further cleanups required before to get rid of it.
   (defgeneric component-property (component property))
   (defgeneric (setf component-property) (new-value component property))
 
@@ -11371,7 +12502,32 @@ Please use UIOP:RUN-PROGRAM instead."
           (setf (cdr a) new-value)
           (setf (slot-value c 'properties)
                 (acons property new-value (slot-value c 'properties)))))
-    new-value))
+    new-value)
+
+
+  ;; This method survives from ASDF 1, but really it is superseded by action-description.
+  (defgeneric explain (operation component)
+    (:documentation "Display a message describing an action.
+
+DEPRECATED. Use ASDF:ACTION-DESCRIPTION and/or ASDF::FORMAT-ACTION instead."))
+  (progn
+    (define-convenience-action-methods explain (operation component)))
+  (defmethod explain ((o operation) (c component))
+    (asdf-message (compatfmt "~&~@<; ~@;~A~:>~%") (action-description o c))))
+;;;; -------------------------------------------------------------------------
+;;; Internal hacks for backward-compatibility
+
+(uiop/package:define-package :asdf/backward-internals
+  (:recycle :asdf/backward-internals :asdf)
+  (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/find-system)
+  (:export #:load-sysdef))
+(in-package :asdf/backward-internals)
+
+(with-asdf-deprecation (:style-warning "3.2")
+  (defun load-sysdef (name pathname)
+    (declare (ignore name pathname))
+    ;; Needed for backward compatibility with swank-asdf from SLIME 2015-12-01 or older.
+    (error "Use asdf:load-asd instead of asdf::load-sysdef")))
 ;;;; ---------------------------------------------------------------------------
 ;;;; Handle ASDF package upgrade, including implementation-dependent magic.
 
@@ -11409,7 +12565,7 @@ Please use UIOP:RUN-PROGRAM instead."
    #:needed-in-image-p
    #:component-load-dependencies #:run-shell-command ; deprecated, do not use
    #:bundle-op #:monolithic-bundle-op #:precompiled-system #:compiled-file #:bundle-system
-   #:program-system #:make-build
+   #:program-system
    #:basic-compile-bundle-op #:prepare-bundle-op
    #:compile-bundle-op #:load-bundle-op #:monolithic-compile-bundle-op #:monolithic-load-bundle-op
    #:lib-op #:dll-op #:deliver-asd-op #:program-op #:image-op
@@ -11498,7 +12654,7 @@ Please use UIOP:RUN-PROGRAM instead."
    #:missing-dependency
    #:missing-dependency-of-version
    #:circular-dependency        ; errors
-   #:duplicate-names #:non-toplevel-system #:non-system-system
+   #:duplicate-names #:non-toplevel-system #:non-system-system #:bad-system-name
    #:package-inferred-system-missing-package-error
    #:operation-definition-warning #:operation-definition-error
 
@@ -11564,57 +12720,75 @@ Please use UIOP:RUN-PROGRAM instead."
 (uiop/package:define-package :asdf/footer
   (:recycle :asdf/footer :asdf)
   (:use :uiop/common-lisp :uiop
-        :asdf/upgrade :asdf/find-system :asdf/operate :asdf/bundle))
+        :asdf/upgrade :asdf/find-system :asdf/operate :asdf/bundle)
+  ;; Happily, all those implementations all have the same module-provider hook interface.
+  #+(or abcl clasp cmucl clozure ecl mkcl sbcl)
+  (:import-from #+abcl :sys #+(or clasp cmucl ecl) :ext #+clozure :ccl #+mkcl :mk-ext #+sbcl sb-ext
+		#:*module-provider-functions*
+		#+ecl #:*load-hooks*)
+  #+(or clasp mkcl) (:import-from :si #:*load-hooks*))
+
 (in-package :asdf/footer)
 
+;;;; Register ASDF itself and all its subsystems as preloaded.
+(with-upgradability ()
+  (dolist (s '("asdf" "uiop" "asdf-package-system"))
+    ;; Don't bother with these system names, no one relies on them anymore:
+    ;; "asdf-utils" "asdf-bundle" "asdf-driver" "asdf-defsystem"
+    (register-preloaded-system s :version *asdf-version*)))
+
+
 ;;;; Hook ASDF into the implementation's REQUIRE and other entry points.
 #+(or abcl clasp clisp clozure cmucl ecl mkcl sbcl)
 (with-upgradability ()
-  (if-let (x (and #+clisp (find-symbol* '#:*module-provider-functions* :custom nil)))
-    (eval `(pushnew 'module-provide-asdf
-                    #+abcl sys::*module-provider-functions*
-                    #+(or clasp cmucl ecl) ext:*module-provider-functions*
-                    #+clisp ,x
-                    #+clozure ccl:*module-provider-functions*
-                    #+mkcl mk-ext:*module-provider-functions*
-                    #+sbcl sb-ext:*module-provider-functions*)))
+  ;; Hook into CL:REQUIRE.
+  #-clisp (pushnew 'module-provide-asdf *module-provider-functions*)
+  #+clisp (if-let (x (find-symbol* '#:*module-provider-functions* :custom nil))
+            (eval `(pushnew 'module-provide-asdf ,x)))
 
   #+(or clasp ecl mkcl)
   (progn
-    (pushnew '("fasb" . si::load-binary) si::*load-hooks* :test 'equal :key 'car)
-
-    #+(or (and clasp windows) (and ecl win32) (and mkcl windows))
-    (unless (assoc "asd" #+(or clasp ecl) ext:*load-hooks* #+mkcl si::*load-hooks* :test 'equal)
-      (appendf #+(or clasp ecl) ext:*load-hooks* #+mkcl si::*load-hooks* '(("asd" . si::load-source))))
-
-    (setf #+(or clasp ecl) ext:*module-provider-functions* #+mkcl mk-ext::*module-provider-functions*
-          (loop :for f :in #+(or clasp ecl) ext:*module-provider-functions*
-                #+mkcl mk-ext::*module-provider-functions*
-                :collect
-                (if (eq f 'module-provide-asdf) f
-                    #'(lambda (name)
-                        (let ((l (multiple-value-list (funcall f name))))
-                          (and (first l) (register-preloaded-system (coerce-name name)))
-                          (values-list l))))))))
+    (pushnew '("fasb" . si::load-binary) *load-hooks* :test 'equal :key 'car)
+
+    #+os-windows
+    (unless (assoc "asd" *load-hooks* :test 'equal)
+      (appendf *load-hooks* '(("asd" . si::load-source))))
+
+    ;; Wrap module provider functions in an idempotent, upgrade friendly way
+    (defvar *wrapped-module-provider* (make-hash-table))
+    (setf (gethash 'module-provide-asdf *wrapped-module-provider*) 'module-provide-asdf)
+    (defun wrap-module-provider (provider name)
+      (let ((results (multiple-value-list (funcall provider name))))
+	(when (first results) (register-preloaded-system (coerce-name name)))
+	(values-list results)))
+    (defun wrap-module-provider-function (provider)
+      (ensure-gethash provider *wrapped-module-provider*
+		      (constantly
+		       #'(lambda (module-name)
+			   (wrap-module-provider provider module-name)))))
+    (setf *module-provider-functions*
+	  (mapcar #'wrap-module-provider-function *module-provider-functions*))))
 
 #+cmucl ;; Hook into the CMUCL herald.
 (with-upgradability ()
   (defun herald-asdf (stream)
     (format stream "    ASDF ~A" (asdf-version)))
-  (setf (getf ext:*herald-items* :asdf) `(herald-asdf)))
+  (setf (getf ext:*herald-items* :asdf) '(herald-asdf)))
 
 
 ;;;; Done!
 (with-upgradability ()
-  #+allegro
+  #+allegro ;; restore *w-o-n-r-c* setting as saved in uiop/common-lisp
   (when (boundp 'excl:*warn-on-nested-reader-conditionals*)
     (setf excl:*warn-on-nested-reader-conditionals* uiop/common-lisp::*acl-warn-save*))
 
-  (dolist (f '(:asdf :asdf2 :asdf3 :asdf3.1 :asdf-package-system)) (pushnew f *features*))
+  ;; Advertise the features we provide.
+  (dolist (f '(:asdf :asdf2 :asdf3 :asdf3.1 :asdf3.2 :asdf-package-system)) (pushnew f *features*))
 
   ;; Provide both lowercase and uppercase, to satisfy more people, especially LispWorks users.
   (provide "asdf") (provide "ASDF")
 
+  ;; Finally, call a function that will cleanup in case this is an upgrade of an older ASDF.
   (cleanup-upgraded-asdf))
 
 (when *load-verbose*
diff --git a/src/contrib/asdf/doc/asdf.html b/src/contrib/asdf/doc/asdf.html
index 74031fa0e..eb82eeb63 100644
--- a/src/contrib/asdf/doc/asdf.html
+++ b/src/contrib/asdf/doc/asdf.html
@@ -6,11 +6,11 @@ for Common Lisp programs and libraries.
 You can find the latest version of this manual at
 https://common-lisp.net/project/asdf/asdf.html.
 
-ASDF Copyright (C) 2001-2015 Daniel Barlow and contributors.
+ASDF Copyright (C) 2001-2016 Daniel Barlow and contributors.
 
-This manual Copyright (C) 2001-2015 Daniel Barlow and contributors.
+This manual Copyright (C) 2001-2016 Daniel Barlow and contributors.
 
-This manual revised (C) 2009-2015 Robert P. Goldman and Francois-Rene Rideau.
+This manual revised (C) 2009-2016 Robert P. Goldman and Francois-Rene Rideau.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -127,11 +127,11 @@ ul.no-bullet {list-style: none}
       <li><a name="toc-Pathname-specifiers" href="#Pathname-specifiers">6.3.7 Pathname specifiers</a></li>
       <li><a name="toc-Version-specifiers" href="#Version-specifiers">6.3.8 Version specifiers</a></li>
       <li><a name="toc-Require" href="#Require">6.3.9 Require</a></li>
-      <li><a name="toc-Using-logical-pathnames" href="#Using-logical-pathnames">6.3.10 Using logical pathnames</a></li>
-      <li><a name="toc-Serial-dependencies" href="#Serial-dependencies">6.3.11 Serial dependencies</a></li>
-      <li><a name="toc-Source-location-_0028_003apathname_0029" href="#Source-location-_0028_003apathname_0029">6.3.12 Source location (<code>:pathname</code>)</a></li>
-      <li><a name="toc-if_002dfeature-option" href="#if_002dfeature-option">6.3.13 if-feature option</a></li>
-      <li><a name="toc-if_002dcomponent_002ddep_002dfails-option" href="#if_002dcomponent_002ddep_002dfails-option">6.3.14 if-component-dep-fails option</a></li>
+      <li><a name="toc-Feature-dependencies" href="#Feature-dependencies">6.3.10 Feature dependencies</a></li>
+      <li><a name="toc-Using-logical-pathnames" href="#Using-logical-pathnames">6.3.11 Using logical pathnames</a></li>
+      <li><a name="toc-Serial-dependencies" href="#Serial-dependencies">6.3.12 Serial dependencies</a></li>
+      <li><a name="toc-Source-location-_0028_003apathname_0029" href="#Source-location-_0028_003apathname_0029">6.3.13 Source location (<code>:pathname</code>)</a></li>
+      <li><a name="toc-if_002dfeature-option" href="#if_002dfeature-option">6.3.14 if-feature option</a></li>
       <li><a name="toc-feature-requirement" href="#feature-requirement">6.3.15 feature requirement</a></li>
     </ul></li>
     <li><a name="toc-Other-code-in-_002easd-files-1" href="#Other-code-in-_002easd-files">6.4 Other code in .asd files</a></li>
@@ -255,6 +255,7 @@ ul.no-bullet {list-style: none}
         <li><a name="toc-How-should-my-library-make-a-readtable-available-to-other-systems_003f" href="#How-should-my-library-make-a-readtable-available-to-other-systems_003f">13.6.7.2 How should my library make a readtable available to other systems?</a></li>
       </ul></li>
       <li><a name="toc-How-can-I-capture-ASDF_0027s-output_003f-1" href="#How-can-I-capture-ASDF_0027s-output_003f">13.6.8 How can I capture ASDF&rsquo;s output?</a></li>
+      <li><a name="toc-_002aLOAD_002dPATHNAME_002a-and-_002aLOAD_002dTRUENAME_002a-have-weird-values_002c-help_0021" href="#LOAD_002dPATHNAME-has-a-weird-value">13.6.9 *LOAD-PATHNAME* and *LOAD-TRUENAME* have weird values, help!</a></li>
     </ul></li>
     <li><a name="toc-ASDF-development-FAQs-1" href="#ASDF-development-FAQs">13.7 ASDF development FAQs</a>
     <ul class="no-bullet">
@@ -275,7 +276,7 @@ ul.no-bullet {list-style: none}
 <a name="Top"></a>
 <a name="ASDF_003a-Another-System-Definition-Facility"></a>
 <h1 class="top">ASDF: Another System Definition Facility</h1>
-<p>Manual for Version 3.1.6.14
+<p>Manual for Version 3.2.0
 </p>
 
 <p>This manual describes ASDF, a system definition facility
@@ -284,11 +285,11 @@ for Common Lisp programs and libraries.
 <p>You can find the latest version of this manual at
 <a href="https://common-lisp.net/project/asdf/asdf.html">https://common-lisp.net/project/asdf/asdf.html</a>.
 </p>
-<p>ASDF Copyright &copy; 2001-2015 Daniel Barlow and contributors.
+<p>ASDF Copyright &copy; 2001-2016 Daniel Barlow and contributors.
 </p>
-<p>This manual Copyright &copy; 2001-2015 Daniel Barlow and contributors.
+<p>This manual Copyright &copy; 2001-2016 Daniel Barlow and contributors.
 </p>
-<p>This manual revised &copy; 2009-2015 Robert P. Goldman and Francois-Rene Rideau.
+<p>This manual revised &copy; 2009-2016 Robert P. Goldman and Francois-Rene Rideau.
 </p>
 <p>Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -679,7 +680,8 @@ may already have configured system-managed libraries for you.
 
 
 
-
+<p>Novices may skip this section.
+</p>
 <p>The old way to configure ASDF to find your systems is by
 <code>push</code>ing directory pathnames onto the variable
 <code>asdf:*central-registry*</code>.
@@ -697,7 +699,7 @@ When used, it takes precedence over the above source-registry.<a name="DOCF5" hr
 </p>
 <p>For example, let&rsquo;s say you want ASDF to find the <samp>.asd</samp> file
 <samp>/home/me/src/foo/foo.asd</samp>.
-In your lisp initialization file, you could have the following:
+In your Lisp initialization file, you could have the following:
 </p>
 <div class="lisp">
 <pre class="lisp">(require &quot;asdf&quot;)
@@ -1291,6 +1293,7 @@ other-component-type := symbol-by-name
 # which is used in :in-order-to
 dependency-def := simple-component-name
                | ( :feature <var>feature-expression</var> dependency-def )
+                 # (see <a href="#The-defsystem-grammar">Feature dependencies</a>)
                | ( :version simple-component-name version-specifier )
                | ( :require module-name )
 
@@ -1309,8 +1312,6 @@ pathname-specifier := pathname | string | symbol
 method-form := (operation-name qual lambda-list &amp;rest body)
 qual := method qualifier?
 
-component-dep-fail-option := :fail | :try-next | :ignore
-
 feature-expression := keyword
                       | (:and <var>feature-expression</var>*)
                       | (:or <var>feature-expression</var>*)
@@ -1537,9 +1538,29 @@ rather than <code>#+<em>implementation-name</em></code>
 to only depend on the specified module on the specific implementation that provides it.
 See <a href="#if_002dfeature_002doption">if-feature-option</a>.
 </p>
+<a name="Feature-dependencies"></a>
+<h4 class="subsection">6.3.10 Feature dependencies</h4>
+<a name="index-_003afeature-dependencies"></a>
 
+<p>A feature dependency is of the form
+<code>(:feature <var>feature-expression</var> <var>dependency</var>)</code>
+If the <var>feature-expression</var> is satisfied by the running lisp at the
+time the system definition is parsed, then the <var>dependency</var> will be
+added to the system&rsquo;s dependencies.  If the <var>feature-expression</var> is
+<em>not</em> satisfied, then the feature dependency form is ignored.
+</p>
+<p>Note that this means that <code>:feature</code> <strong>cannot</strong> be used to
+enforce a feature dependency for the system in question.  I.e., it
+cannot be used to require that a feature hold in order for the system
+definition to be loaded.  E.g., one cannot use <code>(:feature :sbcl)</code>
+to require that a system only be used on SBCL.
+</p>
+<p>Feature dependencies are not to be confused with the obsolete
+feature requirement (see <a href="#The-defsystem-grammar">feature requirement</a>), or
+with <code>if-feature</code>.
+</p>
 <a name="Using-logical-pathnames"></a>
-<h4 class="subsection">6.3.10 Using logical pathnames</h4>
+<h4 class="subsection">6.3.11 Using logical pathnames</h4>
 <a name="index-logical-pathnames"></a>
 
 <p>We do not generally recommend the use of logical pathnames,
@@ -1595,7 +1616,7 @@ underscores, dots or CamelCase in pathnames.
 </p>
 
 <a name="Serial-dependencies"></a>
-<h4 class="subsection">6.3.11 Serial dependencies</h4>
+<h4 class="subsection">6.3.12 Serial dependencies</h4>
 <a name="index-serial-dependencies"></a>
 
 <p>If the <code>:serial t</code> option is specified for a module,
@@ -1618,7 +1639,7 @@ This is done as if by <code>:depends-on</code>.
 
 
 <a name="Source-location-_0028_003apathname_0029"></a>
-<h4 class="subsection">6.3.12 Source location (<code>:pathname</code>)</h4>
+<h4 class="subsection">6.3.13 Source location (<code>:pathname</code>)</h4>
 
 <p>The <code>:pathname</code> option is optional in all cases for systems
 defined via <code>defsystem</code>, and generally is unnecessary.  In the
@@ -1664,7 +1685,7 @@ from within an editor without clobbering its source location)
 </li></ul>
 
 <a name="if_002dfeature-option"></a>
-<h4 class="subsection">6.3.13 if-feature option</h4>
+<h4 class="subsection">6.3.14 if-feature option</h4>
 <a name="index-_003aif_002dfeature-component-option"></a>
 <a name="if_002dfeature_002doption"></a>
 <p>This option allows you to specify a feature expression to be evaluated
@@ -1689,14 +1710,6 @@ been performed.
 <p>This option was added in ASDF 3.  For more information,
 See <a href="#required_002dfeatures">Required features</a>.
 </p>
-<a name="if_002dcomponent_002ddep_002dfails-option"></a>
-<h4 class="subsection">6.3.14 if-component-dep-fails option</h4>
-<a name="index-_003aif_002dcomponent_002ddep_002dfails-component-option"></a>
-<p>This option was removed in ASDF 3.
-Its semantics was limited in purpose and dubious to explain,
-and its implementation was breaking a hole into the ASDF object model.
-Please use the <code>if-feature</code> option instead.
-</p>
 <a name="feature-requirement"></a>
 <h4 class="subsection">6.3.15 feature requirement</h4>
 <p>This requirement was removed in ASDF 3.1.  Please do not use it.  In
@@ -1854,7 +1867,7 @@ where the <samp>.asd</samp> file resides.
 
 <p>ASDF is designed in an object-oriented way from the ground up.
 Both a system&rsquo;s structure and the operations that can be performed on systems
-follow a extensible protocol, allowing programmers to add new behaviours to ASDF.
+follow an extensible protocol, allowing programmers to add new behaviours to ASDF.
 For example, <code>cffi</code> adds support for special FFI description files
 that interface with C libraries and for wrapper files that embed C code in Lisp.
 <code>asdf-jar</code> supports creating Java JAR archives in ABCL.
@@ -1926,20 +1939,21 @@ discuss these in turn below.
 <dd><p><code>operate</code> invokes <var>operation</var> on <var>system</var>.
 <code>oos</code> is a synonym for <code>operate</code> (it stands for operate-on-system).
 </p>
-<p><var>operation</var> is a symbol that is passed,
-along with the supplied <var>initargs</var>,
-to <code>make-operation</code> (which will call <code>make-instance</code>)
+<p><var>operation</var> is an operation designator:
+it can be an operation object itself, or, typically,
+a symbol that is passed to <code>make-operation</code> (which will call <code>make-instance</code>),
 to create the operation object.
-<var>component</var> is a component designator,
-usually a string or symbol that designates a system,
-sometimes a list of strings or symbols that designate a subcomponent of a system.
+<var>component</var> is a component designator:
+it can be a component object itself, or, typically,
+a string or symbol (to be <code>string-downcase</code>d) that names a system,
+more rarely a list of strings or symbols that designate a subcomponent of a system.
 </p>
-<p>The <var>initargs</var> are passed to the <code>make-instance</code> call
-when creating the operation object.
+<p>The ability to pass <var>initargs</var> to <code>make-operation</code> is now deprecated, and will be removed.
+For more details, see <a href="#make_002doperation">make-operation</a>.
 Note that dependencies may cause the operation
 to invoke other operations on the system or its components:
-the new operations will be created
-with the same <var>initargs</var> as the original one.
+the new operations may or may not be created
+with the same <var>initargs</var> as the original one (for the moment).
 </p>
 <p>If <var>force</var> is <code>:all</code>, then all systems
 are forced to be recompiled even if not modified since last compilation.
@@ -1973,6 +1987,20 @@ See <a href="#Miscellaneous-Functions">Miscellaneous Functions</a>.
 
 </dd></dl>
 
+<dl>
+<dt><a name="index-make_002doperation"></a>Function: <strong><code>make-operation</code></strong> <em><var>operation-class</var> &amp;rest <var>initargs</var></em></dt>
+<dd><a name="make_002doperation"></a>
+<p>The <var>initargs</var> are passed to <code>make-instance</code> call
+when creating the operation object.
+</p>
+<p><strong>Note:</strong><var>initargs</var> for <code>operation</code>s are now deprecated,
+and will be removed from ASDF in the near future.
+</p>
+<p><strong>Note:</strong> <code>operation</code> instances must <strong>never</strong> be created
+using <code>make-instance</code> directly: only through
+<code>make-operation</code>. Attempts to directly make <code>operation</code>
+instances will cause a run-time error.
+</p></dd></dl>
 
 
 <hr>
@@ -2490,8 +2518,8 @@ time when the <var>previous</var> system definition was loaded.
 but system <code>foo</code> was previously loaded from <samp>/previous/path/to/foo.asd</samp>
 then <var>locate-system</var> will return the following values:
 </p><ol>
-<li> <var>foundp</var> will be <code>T</code>,
-</li><li> <var>found-system</var> will be <code>NIL</code>,
+<li> <var>foundp</var> will be <code>t</code>,
+</li><li> <var>found-system</var> will be <code>nil</code>,
 </li><li> <var>pathname</var> will be <code>#p&quot;/current/path/to/foo.asd&quot;</code>,
 </li><li> <var>previous</var> will be an object of type <code>SYSTEM</code> with
 <code>system-source-file</code> slot value of
@@ -3972,28 +4000,37 @@ or namestring in an <code>:include</code> directive, e.g.:
 <a name="Shell_002dfriendly-syntax-for-configuration-2"></a>
 <h3 class="section">9.5 Shell-friendly syntax for configuration</h3>
 
-<p>When considering environment variable <code>ASDF_OUTPUT_TRANSLATIONS</code>
-ASDF will skip to the next configuration if it&rsquo;s an empty string.
-It will <code>READ</code> the string as an SEXP in the DSL
-if it begins with a paren <code>(</code>
-and it will be interpreted as a list of directories.
-Directories should come by pairs, indicating a mapping directive.
+<p>When processing the environment variable
+<code>ASDF_OUTPUT_TRANSLATIONS</code>:
+</p><ul>
+<li> ASDF will skip to the next configuration if it&rsquo;s an empty string.
+</li><li> ASDF will <code>READ</code> the string as an SEXP in the DSL, if it
+begins with a parenthesis <code>(</code>.
+</li><li> Otherwise ASDF will interpret the value as a list of directories
+(see below).
+</li></ul>
+
+<p>In the directory list format,
+directories should come in pairs, each pair indicating a mapping directive.
 Entries are separated
-by a <code>:</code> (colon) on Unix platforms (including cygwin),
+by a <code>:</code> (colon) on Unix platforms (including Mac and cygwin), and
 by a <code>;</code> (semicolon) on other platforms (mainly, Windows).
 </p>
 <p>The magic empty entry,
 if it comes in what would otherwise be the first entry in a pair,
-indicates the splicing of inherited configuration.
-If it comes as the second entry in a pair,
-it indicates that the directory specified first is to be left untranslated
+indicates the splicing of inherited configuration;
+the next entry (if any) then starts a new pair.
+If the second entry in a pair is empty,
+it indicates that the directory in the first entry is to be left untranslated
 (which has the same effect as if the directory had been repeated).
-Thus <code>&quot;/foo:/bar::/baz:&quot;</code> means that
-things under directory <samp>/foo/</samp>
-are translated to be under <samp>/bar/</samp>,
-then include the inherited configuration,
-then specify that things under directory <samp>/baz/</samp> are not translated.
 </p>
+<p>For example, <code>&quot;/foo:/bar::/baz:&quot;</code> means:
+specify that outputs for things under directory <samp>/foo/</samp>
+are translated to be under <samp>/bar/</samp>;
+then include the inherited configuration;
+then specify that outputs for things under directory <samp>/baz/</samp> are not translated.
+</p>
+
 <hr>
 <a name="Semantics-of-Output-Translations"></a>
 <a name="Semantics-of-Output-Translations-1"></a>
@@ -4292,7 +4329,7 @@ to protect any <code>:encoding <em>encoding</em></code> statement, as in
 <code>#+asdf-unicode :encoding #+asdf-unicode :utf-8</code>.
 We recommend that you avoid using unprotected <code>:encoding</code> specifications
 until after ASDF 2.21 or later becomes widespread.
-As of May 2015, all maintained implementations provide ASDF 3,
+As of May 2016, all maintained implementations provide ASDF 3.1,
 so you may prudently start using this and other features without such protection.
 </p>
 <p>While it offers plenty of hooks for extension,
@@ -4442,12 +4479,16 @@ from what it does in <samp>header.lisp</samp> and <samp>upgrade.lisp</samp>.
 </p></dd></dl>
 
 <dl>
-<dt><a name="index-register_002dpreloaded_002dsystem"></a>Function: <strong>register-preloaded-system</strong> <em>name &amp;rest keys</em></dt>
+<dt><a name="index-register_002dpreloaded_002dsystem"></a>Function: <strong>register-preloaded-system</strong> <em>name &amp;rest keys &amp;key version &amp;allow-other-keys</em></dt>
 <dd><p>A system with name <var>name</var>,
 created by <code>make-instance</code> with extra keys <var>keys</var>
 (e.g. <code>:version</code>),
 is registered as <em>preloaded</em>.
-That is, its code has already been loaded into the current image,
+If <var>version</var> is <code>t</code> (default), then the version is copied from the defined system
+of the same name (if registered) or else is <code>nil</code>
+(this automatic copy of version is only available starting since ASDF 3.1.8).
+</p>
+<p>A preloaded system is considered as having already been loaded into the current image,
 and if at some point some other system <code>:depends-on</code> it yet no source code is found,
 it is considered as already provided,
 and ASDF will not raise a <code>missing-component</code> error.
@@ -4456,25 +4497,35 @@ and ASDF will not raise a <code>missing-component</code> error.
 as fasls with either <code>compile-bundle-op</code> or <code>monolithic-compile-bundle-op</code>,
 and want to register systems so that dependencies will work uniformly
 whether you&rsquo;re using your software from source or from fasl.
+</p>
+<p>Note that if the system was already defined or loaded from source code,
+its build information will remain active until you call <code>clear-system</code> on it,
+at which point a system without build information will be registered in its place.
 </p></dd></dl>
 
 <dl>
 <dt><a name="index-register_002dimmutable_002dsystem-1"></a>Function: <strong>register-immutable-system</strong> <em>name &amp;rest keys</em></dt>
-<dd><p>A system with name <var>name</var>,
-created by <code>make-instance</code> with extra keys <var>keys</var>
-(e.g. <code>:version</code>),
-is registered as <em>immutable</em>.
-That is, its code has already been loaded into the current image,
-and if at some point some other system <code>:depends-on</code> it,
-it is considered as already provided, and
-no attempt will be made to search for an updated version from the source-registry
-or any other method.
-There will be no search for an <samp>.asd</samp> file, and no <code>missing-component</code> error.
-</p>
-<p>This function (available since ASDF 3.1.5) is particularly useful if
-you distribute a large body of code as a precompiled image,
+<dd><p>A system with name <var>name</var> is registered as preloaded,
+and additionally is marked as <em>immutable</em>:
+that is, attempts to compile or load it will be succeed
+without actually reading, creating or loading any file,
+as if the system was passed as a <code>force-not</code> argument
+to all calls to <code>plan</code> or <code>operate</code>.
+There will be no search for an updated <samp>.asd</samp> file
+to override the loaded version,
+whether from the source-register or any other method.
+</p>
+<p>If a <var>version</var> keyword argument is specified as <code>t</code> or left unspecified,
+then the version is copied from the defined system
+of the same name (if registered) or else is <code>nil</code>.
+This automatic copy of version is available starting
+since immutable systems have been available in ASDF 3.1.5.
+</p>
+<p>This function, available since ASDF 3.1.5, is particularly useful
+if you distribute a large body of code as a precompiled image,
 and want to allow users to extend the image with further extension systems,
-but without making thousands of filesystem requests looking for inexistent (or worse, out of date) source code
+but without making thousands of filesystem requests looking for inexistent
+(or worse, out of date) source code
 for all the systems that came bundled with the image but aren&rsquo;t
 distributed as source code to regular users.
 <a name="index-immutable-systems-1"></a>
@@ -4508,15 +4559,15 @@ while others (like SBCL) will make an attempt at invoking a POSIX shell
 <h3 class="section">11.4 Some Utility Functions</h3>
 
 <p>The below functions are not exported by ASDF itself, but by UIOP, available since ASDF 3.
-Some of them have precursors in ASDF 2, but we recommend
-you rely on ASDF 3 for active developments.
+Some of them have precursors in ASDF 2, but we recommend that for active developments,
+you should rely on the package UIOP as included in ASDF 3.
 UIOP provides many, many more utility functions, and we recommend
-you read its README and sources for more information.
+you read its <samp>README.md</samp> and sources for more information.
 </p>
 
 <dl>
 <dt><a name="index-parse_002dunix_002dnamestring"></a>Function: <strong>parse-unix-namestring</strong> <em>name &amp;key type defaults dot-dot ensure-directory &amp;allow-other-keys</em></dt>
-<dd><p>Coerce NAME into a PATHNAME using standard Unix syntax.
+<dd><p>Coerce <var>name</var> into a <var>pathname</var> using standard Unix syntax.
 </p>
 <p>Unix syntax is used whether or not the underlying system is Unix;
 on non-Unix systems it is only usable for relative pathnames.
@@ -4707,7 +4758,7 @@ which defaults to <code>0</code>, extracting the first line.
 A number will extract the corresponding line.
 See the documentation for <code>uiop:access-at</code>.
 
-</li><li> If the object is <code>:forms</code>, the content is captured as a list of S-expressions,
+</li><li> If the object is <code>:forms</code>, the content is captured as a list of s-expressions,
 as read by the Lisp reader.
 If the <var>count</var> argument is provided,
 it is a maximum count of lines to be read.
@@ -5256,7 +5307,7 @@ should load, configure and upgrade ASDF among the very first things they do,
 and ensure that ASDF 3 or later is present indeed,
 before they start using ASDF to load anything else.
 
-</li><li> Now that all implementations provide ASDF 3 or later (since May 2015),
+</li><li> Now that all implementations provide ASDF 3.1 or later (since May 2016),
 the simple solution is just to use code as below in your setup,
 and when it fails, upgrade your implementation or replace its ASDF.
 (see <a href="#Replacing-your-implementation_0027s-ASDF">Replacing your implementation's ASDF</a>):
@@ -5309,14 +5360,14 @@ and lose configuration as they do.
 <p><code>asdf-ecl</code> and its short-lived successor <code>asdf-bundle</code> are no more,
 having been replaced by code now built into ASDF 3.
 Moreover, the name of the bundle operations has changed since ASDF 3.1.3.
+Starting with ASDF 3.2.0, <code>load-system</code>
+will once again use <code>load-bundle-op</code> instead of <code>load-op</code> on ECL,
+as originally intended by <code>asdf-ecl</code> authors, but disabled for a long time
+due to bugs in both ECL and ASDF.
 </p>
-<p>And yet, the feature is not enabled to be used by <code>load-system</code> by default on ECL as originally intended,
-because of a bug in ECL itself found during testing.
-</p>
-
-<p>Some of the bundle operations were renamed after ASDF 3.1.3, and the old
-names have been removed.  Old bundle operations, and their modern
-equivalents are:
+<p>Note that some of the bundle operations were renamed after ASDF 3.1.3,
+and the old names have been removed.
+Old bundle operations, and their modern equivalents are:
 </p>
 <ul>
 <li> <code>fasl-op</code> is now <code>compile-bundle-op</code>
@@ -5769,7 +5820,36 @@ to eschew using such an important library anymore.
 <code>*standard-output*</code>, so rebinding that stream around calls to
 <code>asdf:operate</code> should redirect all output from ASDF operations.
 </p>
+<hr>
+<a name="LOAD_002dPATHNAME-has-a-weird-value"></a>
+<a name="g_t_002aLOAD_002dPATHNAME_002a-and-_002aLOAD_002dTRUENAME_002a-have-weird-values_002c-help_0021"></a>
+<h4 class="subsection">13.6.9 *LOAD-PATHNAME* and *LOAD-TRUENAME* have weird values, help!</h4>
+<a name="index-_002aLOAD_002dPATHNAME_002a"></a>
+<a name="index-_002aLOAD_002dTRUENAME_002a"></a>
+
+<p>Conventional Common Lisp code may use <code>*LOAD-TRUENAME*</code> or <code>*LOAD-PATHNAME*</code> to find
+files adjacent to source files.  This will generally <em>not</em> work in
+ASDF-loaded systems.  Recall that ASDF relocates the FASL files it
+builds, typically to a special cache directory.  Thus the value of
+<code>*LOAD-PATHNAME*</code> and <code>*LOAD-TRUENAME*</code>  at load time, when ASDF is loading your system,
+will typically be a pathname in that cache directory, and useless to you
+for finding other system components.
+</p>
+<p>There are two ways to work around this problem:
+</p><ol>
+<li> <a name="index-system_002drelative_002dpathname-1"></a>
+Use the <code>system-relative-pathname</code> function.  This can readily be
+used from outside the system, but it is probably not good software
+engineering to require a source file <em>of</em> a system to know what
+system it is going to be part of.  Contained objects should not have to
+know their containers.
+</li><li> Store the pathname at compile time, so that you get the pathname of the
+source file, which is presumably what you want.  To do this, you can
+capture the value of <code>(or *compile-file-pathname* *load-truename*)</code>
+(or <code>*LOAD-PATHNAME*</code>, if you prefer)
+in a macro expansion or other compile-time evaluated context.
 
+</li></ol>
 
 <hr>
 <a name="ASDF-development-FAQs"></a>
@@ -5857,7 +5937,8 @@ see the <samp>TODO</samp> file in the source repository.
   <a href="http://xach.livejournal.com/">http://xach.livejournal.com/</a>
 </li><li> Francois-Rene Rideau and Robert Goldman:
   &ldquo;Evolving ASDF: More Cooperation, Less Coordination&rdquo;, 2010.
-  This article describes the main issues solved by ASDF 2.
+  This article describes the main issues solved by ASDF 2,
+  and exposes its design principles.
   <a href="https://common-lisp.net/project/asdf/doc/ilc2010draft.pdf">https://common-lisp.net/project/asdf/doc/ilc2010draft.pdf</a>
   <a href="https://gitlab.common-lisp.org/asdf/ilc2010">https://gitlab.common-lisp.org/asdf/ilc2010</a>
 </li><li> Francois-Rene Rideau and Spencer Brody:
@@ -5957,7 +6038,7 @@ see the <samp>TODO</samp> file in the source repository.
 <tr><td></td><td valign="top"><a href="#index-_003adefsystem_002ddepends_002don">:defsystem-depends-on</a>:</td><td>&nbsp;</td><td valign="top"><a href="#The-defsystem-grammar">The defsystem grammar</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-_003adirectory-source-config-directive">:directory source config directive</a>:</td><td>&nbsp;</td><td valign="top"><a href="#Configuration-DSL">Configuration DSL</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-_003aexclude-source-config-directive">:exclude source config directive</a>:</td><td>&nbsp;</td><td valign="top"><a href="#Configuration-DSL">Configuration DSL</a></td></tr>
-<tr><td></td><td valign="top"><a href="#index-_003aif_002dcomponent_002ddep_002dfails-component-option">:if-component-dep-fails component option</a>:</td><td>&nbsp;</td><td valign="top"><a href="#The-defsystem-grammar">The defsystem grammar</a></td></tr>
+<tr><td></td><td valign="top"><a href="#index-_003afeature-dependencies">:feature dependencies</a>:</td><td>&nbsp;</td><td valign="top"><a href="#The-defsystem-grammar">The defsystem grammar</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-_003aif_002dfeature-component-option">:if-feature component option</a>:</td><td>&nbsp;</td><td valign="top"><a href="#The-defsystem-grammar">The defsystem grammar</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-_003aignore_002dinvalid_002dentries-source-config-directive">:ignore-invalid-entries source config directive</a>:</td><td>&nbsp;</td><td valign="top"><a href="#Configuration-DSL">Configuration DSL</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-_003ainclude-source-config-directive">:include source config directive</a>:</td><td>&nbsp;</td><td valign="top"><a href="#Configuration-DSL">Configuration DSL</a></td></tr>
@@ -6173,6 +6254,7 @@ see the <samp>TODO</samp> file in the source repository.
 <tr><td colspan="4"> <hr></td></tr>
 <tr><th><a name="Function-and-Class-Index_fn_letter-M">M</a></th><td></td><td></td></tr>
 <tr><td></td><td valign="top"><a href="#index-make"><code>make</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Convenience-Functions">Convenience Functions</a></td></tr>
+<tr><td></td><td valign="top"><a href="#index-make_002doperation"><code><code>make-operation</code></code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Operations">Operations</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-merge_002dpathnames_002a"><code>merge-pathnames*</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Some-Utility-Functions">Some Utility Functions</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-module"><code>module</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Pre_002ddefined-subclasses-of-component">Pre-defined subclasses of component</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-monolithic_002dbinary_002dop-_0028obsolete_0029"><code>monolithic-binary-op (obsolete)</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#What-happened-to-the-bundle-operations">What happened to the bundle operations</a></td></tr>
@@ -6218,6 +6300,7 @@ see the <samp>TODO</samp> file in the source repository.
 <tr><td></td><td valign="top"><a href="#index-system_002ddefsystem_002ddepends_002don"><code>system-defsystem-depends-on</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Information-about-system-dependencies">Information about system dependencies</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-system_002ddepends_002don"><code>system-depends-on</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Information-about-system-dependencies">Information about system dependencies</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-system_002drelative_002dpathname"><code>system-relative-pathname</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Miscellaneous-Functions">Miscellaneous Functions</a></td></tr>
+<tr><td></td><td valign="top"><a href="#index-system_002drelative_002dpathname-1"><code>system-relative-pathname</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#LOAD_002dPATHNAME-has-a-weird-value">LOAD-PATHNAME has a weird value</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-system_002dsource_002ddirectory"><code>system-source-directory</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Miscellaneous-Functions">Miscellaneous Functions</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-system_002dweakly_002ddepends_002don"><code>system-weakly-depends-on</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Information-about-system-dependencies">Information about system dependencies</a></td></tr>
 <tr><td colspan="4"> <hr></td></tr>
@@ -6283,7 +6366,9 @@ see the <samp>TODO</samp> file in the source repository.
 <tr><td></td><td valign="top"><a href="#index-_002adefault_002dsource_002dregistry_002dexclusions_002a"><code>*default-source-registry-exclusions*</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Search-Algorithm">Search Algorithm</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-_002afeatures_002a-1"><code>*features*</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Introduction">Introduction</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-_002aimage_002ddump_002dhook_002a"><code>*image-dump-hook*</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Resetting-the-ASDF-configuration">Resetting the ASDF configuration</a></td></tr>
+<tr><td></td><td valign="top"><a href="#index-_002aLOAD_002dPATHNAME_002a"><code>*LOAD-PATHNAME*</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#LOAD_002dPATHNAME-has-a-weird-value">LOAD-PATHNAME has a weird value</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-_002aload_002dsystem_002doperation_002a"><code>*load-system-operation*</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Convenience-Functions">Convenience Functions</a></td></tr>
+<tr><td></td><td valign="top"><a href="#index-_002aLOAD_002dTRUENAME_002a"><code>*LOAD-TRUENAME*</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#LOAD_002dPATHNAME-has-a-weird-value">LOAD-PATHNAME has a weird value</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-_002anil_002dpathname_002a"><code>*nil-pathname*</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Some-Utility-Functions">Some Utility Functions</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-_002aoldest_002dforward_002dcompatible_002dasdf_002dversion_002a"><code>*oldest-forward-compatible-asdf-version*</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Pitfalls-of-the-upgrade-to-ASDF-3">Pitfalls of the upgrade to ASDF 3</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-_002asource_002dregistry_002dparameter_002a"><code>*source-registry-parameter*</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#g_t_002asource_002dregistry_002dparameter_002a-variable">*source-registry-parameter* variable</a></td></tr>
@@ -6361,7 +6446,7 @@ on the value of shell variables or the identity of the user.
 &ldquo;system directory designators&rdquo;.
 A <em>system directory designator</em> is a form
 which will be evaluated whenever a system is to be found,
-and must evaluate to a directory to look in (or <code>NIL</code>).
+and must evaluate to a directory to look in (or <code>nil</code>).
 By &ldquo;directory&rdquo;, we mean
 &ldquo;designator for a pathname with a non-empty DIRECTORY component&rdquo;.
 </p>
diff --git a/src/contrib/asdf/doc/asdf.info b/src/contrib/asdf/doc/asdf.info
index c44135637..115c20a48 100644
--- a/src/contrib/asdf/doc/asdf.info
+++ b/src/contrib/asdf/doc/asdf.info
@@ -6,11 +6,11 @@ programs and libraries.
    You can find the latest version of this manual at
 <https://common-lisp.net/project/asdf/asdf.html>.
 
-   ASDF Copyright (C) 2001-2015 Daniel Barlow and contributors.
+   ASDF Copyright (C) 2001-2016 Daniel Barlow and contributors.
 
-   This manual Copyright (C) 2001-2015 Daniel Barlow and contributors.
+   This manual Copyright (C) 2001-2016 Daniel Barlow and contributors.
 
-   This manual revised (C) 2009-2015 Robert P. Goldman and Francois-Rene
+   This manual revised (C) 2009-2016 Robert P. Goldman and Francois-Rene
 Rideau.
 
    Permission is hereby granted, free of charge, to any person obtaining
@@ -43,7 +43,7 @@ File: asdf.info,  Node: Top,  Next: Introduction,  Prev: (dir),  Up: (dir)
 ASDF: Another System Definition Facility
 ****************************************
 
-Manual for Version 3.1.6.14
+Manual for Version 3.2.0
 
    This manual describes ASDF, a system definition facility for Common
 Lisp programs and libraries.
@@ -51,11 +51,11 @@ Lisp programs and libraries.
    You can find the latest version of this manual at
 <https://common-lisp.net/project/asdf/asdf.html>.
 
-   ASDF Copyright (C) 2001-2015 Daniel Barlow and contributors.
+   ASDF Copyright (C) 2001-2016 Daniel Barlow and contributors.
 
-   This manual Copyright (C) 2001-2015 Daniel Barlow and contributors.
+   This manual Copyright (C) 2001-2016 Daniel Barlow and contributors.
 
-   This manual revised (C) 2009-2015 Robert P. Goldman and Francois-Rene
+   This manual revised (C) 2009-2016 Robert P. Goldman and Francois-Rene
 Rideau.
 
    Permission is hereby granted, free of charge, to any person obtaining
@@ -244,6 +244,7 @@ Issues with using and extending ASDF to define systems
 * How do I mark a source file to be loaded only and not compiled?::
 * How do I work with readtables?::
 * How can I capture ASDF's output?::
+* LOAD-PATHNAME has a weird value::
 
 ASDF development FAQs
 
@@ -611,7 +612,9 @@ File: asdf.info,  Node: Configuring ASDF to find your systems --- old style,  Ne
 4.2 Configuring ASDF to find your systems -- old style
 ======================================================
 
-The old way to configure ASDF to find your systems is by 'push'ing
+Novices may skip this section.
+
+   The old way to configure ASDF to find your systems is by 'push'ing
 directory pathnames onto the variable 'asdf:*central-registry*'.
 
    You must configure this variable between the time you load ASDF and
@@ -625,7 +628,7 @@ used to put it in their '~/.sbclrc'.)
 takes precedence over the above source-registry.(1)
 
    For example, let's say you want ASDF to find the '.asd' file
-'/home/me/src/foo/foo.asd'.  In your lisp initialization file, you could
+'/home/me/src/foo/foo.asd'.  In your Lisp initialization file, you could
 have the following:
 
      (require "asdf")
@@ -678,7 +681,7 @@ shell variables or the identity of the user.
    The variable 'asdf:*central-registry*' is thus a list of "system
 directory designators".  A "system directory designator" is a form which
 will be evaluated whenever a system is to be found, and must evaluate to
-a directory to look in (or 'NIL').  By "directory", we mean "designator
+a directory to look in (or 'nil').  By "directory", we mean "designator
 for a pathname with a non-empty DIRECTORY component".
 
    (3) On Windows, you can use Windows shortcuts instead of POSIX
@@ -1195,6 +1198,7 @@ File: asdf.info,  Node: The defsystem grammar,  Next: Other code in .asd files,
      # which is used in :in-order-to
      dependency-def := simple-component-name
                     | ( :feature FEATURE-EXPRESSION dependency-def )
+                      # (*note Feature dependencies: The defsystem grammar.)
                     | ( :version simple-component-name version-specifier )
                     | ( :require module-name )
 
@@ -1213,8 +1217,6 @@ File: asdf.info,  Node: The defsystem grammar,  Next: Other code in .asd files,
      method-form := (operation-name qual lambda-list &rest body)
      qual := method qualifier?
 
-     component-dep-fail-option := :fail | :try-next | :ignore
-
      feature-expression := keyword
                            | (:and FEATURE-EXPRESSION*)
                            | (:or FEATURE-EXPRESSION*)
@@ -1407,7 +1409,26 @@ than '#+_implementation-name_' to only depend on the specified module on
 the specific implementation that provides it.  *Note
 if-feature-option::.
 
-6.3.10 Using logical pathnames
+6.3.10 Feature dependencies
+---------------------------
+
+A feature dependency is of the form '(:feature FEATURE-EXPRESSION
+DEPENDENCY)' If the FEATURE-EXPRESSION is satisfied by the running lisp
+at the time the system definition is parsed, then the DEPENDENCY will be
+added to the system's dependencies.  If the FEATURE-EXPRESSION is _not_
+satisfied, then the feature dependency form is ignored.
+
+   Note that this means that ':feature' *cannot* be used to enforce a
+feature dependency for the system in question.  I.e., it cannot be used
+to require that a feature hold in order for the system definition to be
+loaded.  E.g., one cannot use '(:feature :sbcl)' to require that a
+system only be used on SBCL.
+
+   Feature dependencies are not to be confused with the obsolete feature
+requirement (*note feature requirement: The defsystem grammar.), or with
+'if-feature'.
+
+6.3.11 Using logical pathnames
 ------------------------------
 
 We do not generally recommend the use of logical pathnames, especially
@@ -1453,7 +1474,7 @@ are shared with software written in different programming languages
 where conventions include the use of underscores, dots or CamelCase in
 pathnames.
 
-6.3.11 Serial dependencies
+6.3.12 Serial dependencies
 --------------------------
 
 If the ':serial t' option is specified for a module, ASDF will add
@@ -1469,7 +1490,7 @@ preceding it.  This is done as if by ':depends-on'.
                   (:file "b" :depends-on ("a"))
                   (:file "c" :depends-on ("a" "b")))
 
-6.3.12 Source location (':pathname')
+6.3.13 Source location (':pathname')
 ------------------------------------
 
 The ':pathname' option is optional in all cases for systems defined via
@@ -1508,7 +1529,7 @@ pathname will be set to:
      that a developer can evaluate a 'defsystem' form from within an
      editor without clobbering its source location)
 
-6.3.13 if-feature option
+6.3.14 if-feature option
 ------------------------
 
 This option allows you to specify a feature expression to be evaluated
@@ -1531,13 +1552,6 @@ before any build operations have been performed.
    This option was added in ASDF 3.  For more information, *Note
 Required features: required-features.
 
-6.3.14 if-component-dep-fails option
-------------------------------------
-
-This option was removed in ASDF 3.  Its semantics was limited in purpose
-and dubious to explain, and its implementation was breaking a hole into
-the ASDF object model.  Please use the 'if-feature' option instead.
-
 6.3.15 feature requirement
 --------------------------
 
@@ -1677,11 +1691,12 @@ File: asdf.info,  Node: The object model of ASDF,  Next: Controlling where ASDF
 
 ASDF is designed in an object-oriented way from the ground up.  Both a
 system's structure and the operations that can be performed on systems
-follow a extensible protocol, allowing programmers to add new behaviours
-to ASDF. For example, 'cffi' adds support for special FFI description
-files that interface with C libraries and for wrapper files that embed C
-code in Lisp.  'asdf-jar' supports creating Java JAR archives in ABCL.
-'poiu' supports compiling code in parallel using background processes.
+follow an extensible protocol, allowing programmers to add new
+behaviours to ASDF. For example, 'cffi' adds support for special FFI
+description files that interface with C libraries and for wrapper files
+that embed C code in Lisp.  'asdf-jar' supports creating Java JAR
+archives in ABCL. 'poiu' supports compiling code in parallel using
+background processes.
 
    The key classes in ASDF are 'component' and 'operation'.  A
 'component' represents an individual source file or a group of source
@@ -1769,18 +1784,20 @@ in turn below.
      'operate' invokes OPERATION on SYSTEM.  'oos' is a synonym for
      'operate' (it stands for operate-on-system).
 
-     OPERATION is a symbol that is passed, along with the supplied
-     INITARGS, to 'make-operation' (which will call 'make-instance') to
-     create the operation object.  COMPONENT is a component designator,
-     usually a string or symbol that designates a system, sometimes a
-     list of strings or symbols that designate a subcomponent of a
-     system.
-
-     The INITARGS are passed to the 'make-instance' call when creating
-     the operation object.  Note that dependencies may cause the
-     operation to invoke other operations on the system or its
-     components: the new operations will be created with the same
-     INITARGS as the original one.
+     OPERATION is an operation designator: it can be an operation object
+     itself, or, typically, a symbol that is passed to 'make-operation'
+     (which will call 'make-instance'), to create the operation object.
+     COMPONENT is a component designator: it can be a component object
+     itself, or, typically, a string or symbol (to be
+     'string-downcase'd) that names a system, more rarely a list of
+     strings or symbols that designate a subcomponent of a system.
+
+     The ability to pass INITARGS to 'make-operation' is now deprecated,
+     and will be removed.  For more details, *note make-operation::.
+     Note that dependencies may cause the operation to invoke other
+     operations on the system or its components: the new operations may
+     or may not be created with the same INITARGS as the original one
+     (for the moment).
 
      If FORCE is ':all', then all systems are forced to be recompiled
      even if not modified since last compilation.  If FORCE is 't', then
@@ -1807,6 +1824,18 @@ in turn below.
      To see what 'operate' would do, you can use:
           (asdf:traverse operation-class system-name)
 
+ -- Function: 'make-operation' OPERATION-CLASS &rest INITARGS
+
+     The INITARGS are passed to 'make-instance' call when creating the
+     operation object.
+
+     *Note:*INITARGS for 'operation's are now deprecated, and will be
+     removed from ASDF in the near future.
+
+     *Note:* 'operation' instances must *never* be created using
+     'make-instance' directly: only through 'make-operation'.  Attempts
+     to directly make 'operation' instances will cause a run-time error.
+
 
 File: asdf.info,  Node: Predefined operations of ASDF,  Next: Creating new operations,  Prev: Operations,  Up: Operations
 
@@ -2237,8 +2266,8 @@ component itself, or a string or symbol, or a list of designators.
      '/current/path/to/foo.asd', but system 'foo' was previously loaded
      from '/previous/path/to/foo.asd' then LOCATE-SYSTEM will return the
      following values:
-       1. FOUNDP will be 'T',
-       2. FOUND-SYSTEM will be 'NIL',
+       1. FOUNDP will be 't',
+       2. FOUND-SYSTEM will be 'nil',
        3. PATHNAME will be '#p"/current/path/to/foo.asd"',
        4. PREVIOUS will be an object of type 'SYSTEM' with
           'system-source-file' slot value of
@@ -3637,23 +3666,29 @@ File: asdf.info,  Node: Output Shell-friendly syntax for configuration,  Next: S
 9.5 Shell-friendly syntax for configuration
 ===========================================
 
-When considering environment variable 'ASDF_OUTPUT_TRANSLATIONS' ASDF
-will skip to the next configuration if it's an empty string.  It will
-'READ' the string as an SEXP in the DSL if it begins with a paren '('
-and it will be interpreted as a list of directories.  Directories should
-come by pairs, indicating a mapping directive.  Entries are separated by
-a ':' (colon) on Unix platforms (including cygwin), by a ';' (semicolon)
-on other platforms (mainly, Windows).
+When processing the environment variable 'ASDF_OUTPUT_TRANSLATIONS':
+   * ASDF will skip to the next configuration if it's an empty string.
+   * ASDF will 'READ' the string as an SEXP in the DSL, if it begins
+     with a parenthesis '('.
+   * Otherwise ASDF will interpret the value as a list of directories
+     (see below).
+
+   In the directory list format, directories should come in pairs, each
+pair indicating a mapping directive.  Entries are separated by a ':'
+(colon) on Unix platforms (including Mac and cygwin), and by a ';'
+(semicolon) on other platforms (mainly, Windows).
 
    The magic empty entry, if it comes in what would otherwise be the
 first entry in a pair, indicates the splicing of inherited
-configuration.  If it comes as the second entry in a pair, it indicates
-that the directory specified first is to be left untranslated (which has
-the same effect as if the directory had been repeated).  Thus
-'"/foo:/bar::/baz:"' means that things under directory '/foo/' are
-translated to be under '/bar/', then include the inherited
-configuration, then specify that things under directory '/baz/' are not
-translated.
+configuration; the next entry (if any) then starts a new pair.  If the
+second entry in a pair is empty, it indicates that the directory in the
+first entry is to be left untranslated (which has the same effect as if
+the directory had been repeated).
+
+   For example, '"/foo:/bar::/baz:"' means: specify that outputs for
+things under directory '/foo/' are translated to be under '/bar/'; then
+include the inherited configuration; then specify that outputs for
+things under directory '/baz/' are not translated.
 
 
 File: asdf.info,  Node: Semantics of Output Translations,  Next: Output Caching Results,  Prev: Output Shell-friendly syntax for configuration,  Up: Controlling where ASDF saves compiled files
@@ -3909,8 +3944,8 @@ implementations that support Unicode, and you can use
 reader-conditionalization to protect any ':encoding _encoding_'
 statement, as in '#+asdf-unicode :encoding #+asdf-unicode :utf-8'.  We
 recommend that you avoid using unprotected ':encoding' specifications
-until after ASDF 2.21 or later becomes widespread.  As of May 2015, all
-maintained implementations provide ASDF 3, so you may prudently start
+until after ASDF 2.21 or later becomes widespread.  As of May 2016, all
+maintained implementations provide ASDF 3.1, so you may prudently start
 using this and other features without such protection.
 
    While it offers plenty of hooks for extension, and one such extension
@@ -4038,13 +4073,20 @@ These functions are exported by ASDF for your convenience.
      inspiration (or disinspiration) from what it does in 'header.lisp'
      and 'upgrade.lisp'.
 
- -- Function: register-preloaded-system name &rest keys
+ -- Function: register-preloaded-system name &rest keys &key version
+          &allow-other-keys
      A system with name NAME, created by 'make-instance' with extra keys
-     KEYS (e.g.  ':version'), is registered as _preloaded_.  That is,
-     its code has already been loaded into the current image, and if at
-     some point some other system ':depends-on' it yet no source code is
-     found, it is considered as already provided, and ASDF will not
-     raise a 'missing-component' error.
+     KEYS (e.g.  ':version'), is registered as _preloaded_.  If VERSION
+     is 't' (default), then the version is copied from the defined
+     system of the same name (if registered) or else is 'nil' (this
+     automatic copy of version is only available starting since ASDF
+     3.1.8).
+
+     A preloaded system is considered as having already been loaded into
+     the current image, and if at some point some other system
+     ':depends-on' it yet no source code is found, it is considered as
+     already provided, and ASDF will not raise a 'missing-component'
+     error.
 
      This function is particularly useful if you distribute your code as
      fasls with either 'compile-bundle-op' or
@@ -4052,17 +4094,27 @@ These functions are exported by ASDF for your convenience.
      that dependencies will work uniformly whether you're using your
      software from source or from fasl.
 
+     Note that if the system was already defined or loaded from source
+     code, its build information will remain active until you call
+     'clear-system' on it, at which point a system without build
+     information will be registered in its place.
+
  -- Function: register-immutable-system name &rest keys
-     A system with name NAME, created by 'make-instance' with extra keys
-     KEYS (e.g.  ':version'), is registered as _immutable_.  That is,
-     its code has already been loaded into the current image, and if at
-     some point some other system ':depends-on' it, it is considered as
-     already provided, and no attempt will be made to search for an
-     updated version from the source-registry or any other method.
-     There will be no search for an '.asd' file, and no
-     'missing-component' error.
-
-     This function (available since ASDF 3.1.5) is particularly useful
+     A system with name NAME is registered as preloaded, and
+     additionally is marked as _immutable_: that is, attempts to compile
+     or load it will be succeed without actually reading, creating or
+     loading any file, as if the system was passed as a 'force-not'
+     argument to all calls to 'plan' or 'operate'.  There will be no
+     search for an updated '.asd' file to override the loaded version,
+     whether from the source-register or any other method.
+
+     If a VERSION keyword argument is specified as 't' or left
+     unspecified, then the version is copied from the defined system of
+     the same name (if registered) or else is 'nil'.  This automatic
+     copy of version is available starting since immutable systems have
+     been available in ASDF 3.1.5.
+
+     This function, available since ASDF 3.1.5, is particularly useful
      if you distribute a large body of code as a precompiled image, and
      want to allow users to extend the image with further extension
      systems, but without making thousands of filesystem requests
@@ -4104,9 +4156,10 @@ File: asdf.info,  Node: Some Utility Functions,  Prev: Miscellaneous Functions,
 
 The below functions are not exported by ASDF itself, but by UIOP,
 available since ASDF 3.  Some of them have precursors in ASDF 2, but we
-recommend you rely on ASDF 3 for active developments.  UIOP provides
-many, many more utility functions, and we recommend you read its README
-and sources for more information.
+recommend that for active developments, you should rely on the package
+UIOP as included in ASDF 3.  UIOP provides many, many more utility
+functions, and we recommend you read its 'README.md' and sources for
+more information.
 
  -- Function: parse-unix-namestring name &key type defaults dot-dot
           ensure-directory &allow-other-keys
@@ -4293,7 +4346,7 @@ and sources for more information.
           documentation for 'uiop:access-at'.
 
         * If the object is ':forms', the content is captured as a list
-          of S-expressions, as read by the Lisp reader.  If the COUNT
+          of s-expressions, as read by the Lisp reader.  If the COUNT
           argument is provided, it is a maximum count of lines to be
           read.  We recommend you control the syntax with such macro as
           'uiop:with-safe-io-syntax'.
@@ -4812,8 +4865,8 @@ when upgrading from ASDF 2, due to limitations in ASDF 2.
      ensure that ASDF 3 or later is present indeed, before they start
      using ASDF to load anything else.
 
-   * Now that all implementations provide ASDF 3 or later (since May
-     2015), the simple solution is just to use code as below in your
+   * Now that all implementations provide ASDF 3.1 or later (since May
+     2016), the simple solution is just to use code as below in your
      setup, and when it fails, upgrade your implementation or replace
      its ASDF. (*note Replacing your implementation's ASDF::):
           (require "asdf")
@@ -4852,15 +4905,14 @@ File: asdf.info,  Node: What happened to the bundle operations,  Prev: Pitfalls
 
 'asdf-ecl' and its short-lived successor 'asdf-bundle' are no more,
 having been replaced by code now built into ASDF 3.  Moreover, the name
-of the bundle operations has changed since ASDF 3.1.3.
-
-   And yet, the feature is not enabled to be used by 'load-system' by
-default on ECL as originally intended, because of a bug in ECL itself
-found during testing.
+of the bundle operations has changed since ASDF 3.1.3.  Starting with
+ASDF 3.2.0, 'load-system' will once again use 'load-bundle-op' instead
+of 'load-op' on ECL, as originally intended by 'asdf-ecl' authors, but
+disabled for a long time due to bugs in both ECL and ASDF.
 
-   Some of the bundle operations were renamed after ASDF 3.1.3, and the
-old names have been removed.  Old bundle operations, and their modern
-equivalents are:
+   Note that some of the bundle operations were renamed after ASDF
+3.1.3, and the old names have been removed.  Old bundle operations, and
+their modern equivalents are:
 
    * 'fasl-op' is now 'compile-bundle-op'
    * 'load-fasl-op' is now 'load-bundle-op'
@@ -5044,6 +5096,7 @@ File: asdf.info,  Node: Issues with using and extending ASDF to define systems,
 * How do I mark a source file to be loaded only and not compiled?::
 * How do I work with readtables?::
 * How can I capture ASDF's output?::
+* LOAD-PATHNAME has a weird value::
 
 
 File: asdf.info,  Node: How can I cater for unit-testing in my system?,  Next: How can I cater for documentation generation in my system?,  Prev: Issues with using and extending ASDF to define systems,  Up: Issues with using and extending ASDF to define systems
@@ -5277,7 +5330,7 @@ Use from the 'named-readtables' system the macro
 'named-readtables:defreadtable'.
 
 
-File: asdf.info,  Node: How can I capture ASDF's output?,  Prev: How do I work with readtables?,  Up: Issues with using and extending ASDF to define systems
+File: asdf.info,  Node: How can I capture ASDF's output?,  Next: LOAD-PATHNAME has a weird value,  Prev: How do I work with readtables?,  Up: Issues with using and extending ASDF to define systems
 
 13.6.8 How can I capture ASDF's output?
 ---------------------------------------
@@ -5286,6 +5339,32 @@ Output from ASDF and ASDF extensions are sent to the CL stream
 '*standard-output*', so rebinding that stream around calls to
 'asdf:operate' should redirect all output from ASDF operations.
 
+
+File: asdf.info,  Node: LOAD-PATHNAME has a weird value,  Prev: How can I capture ASDF's output?,  Up: Issues with using and extending ASDF to define systems
+
+13.6.9 *LOAD-PATHNAME* and *LOAD-TRUENAME* have weird values, help!
+-------------------------------------------------------------------
+
+Conventional Common Lisp code may use '*LOAD-TRUENAME*' or
+'*LOAD-PATHNAME*' to find files adjacent to source files.  This will
+generally _not_ work in ASDF-loaded systems.  Recall that ASDF relocates
+the FASL files it builds, typically to a special cache directory.  Thus
+the value of '*LOAD-PATHNAME*' and '*LOAD-TRUENAME*' at load time, when
+ASDF is loading your system, will typically be a pathname in that cache
+directory, and useless to you for finding other system components.
+
+   There are two ways to work around this problem:
+  1. Use the 'system-relative-pathname' function.  This can readily be
+     used from outside the system, but it is probably not good software
+     engineering to require a source file _of_ a system to know what
+     system it is going to be part of.  Contained objects should not
+     have to know their containers.
+  2. Store the pathname at compile time, so that you get the pathname of
+     the source file, which is presumably what you want.  To do this,
+     you can capture the value of '(or *compile-file-pathname*
+     *load-truename*)' (or '*LOAD-PATHNAME*', if you prefer) in a macro
+     expansion or other compile-time evaluated context.
+
 
 File: asdf.info,  Node: ASDF development FAQs,  Prev: Issues with using and extending ASDF to define systems,  Up: FAQ
 
@@ -5371,7 +5450,7 @@ Bibliography
      <http://blog.quicklisp.org/> <http://xach.livejournal.com/>
    * Francois-Rene Rideau and Robert Goldman: "Evolving ASDF: More
      Cooperation, Less Coordination", 2010.  This article describes the
-     main issues solved by ASDF 2.
+     main issues solved by ASDF 2, and exposes its design principles.
      <https://common-lisp.net/project/asdf/doc/ilc2010draft.pdf>
      <https://gitlab.common-lisp.org/asdf/ilc2010>
    * Francois-Rene Rideau and Spencer Brody: "XCVB: an eXtensible
@@ -5426,34 +5505,34 @@ Concept Index
 * :asdf2:                                Introduction.        (line   6)
 * :asdf3:                                Introduction.        (line   6)
 * :build-operation:                      The defsystem grammar.
-                                                              (line 129)
+                                                              (line 128)
 * :compile-check:                        Controlling file compilation.
                                                               (line   6)
 * :default-registry source config directive: Configuration DSL.
                                                               (line   6)
 * :defsystem-depends-on:                 The defsystem grammar.
-                                                              (line 121)
+                                                              (line 120)
 * :directory source config directive:    Configuration DSL.   (line   6)
 * :exclude source config directive:      Configuration DSL.   (line   6)
-* :if-component-dep-fails component option: The defsystem grammar.
-                                                              (line 395)
+* :feature dependencies:                 The defsystem grammar.
+                                                              (line 270)
 * :if-feature component option:          The defsystem grammar.
-                                                              (line 372)
+                                                              (line 390)
 * :ignore-invalid-entries source config directive: Configuration DSL.
                                                               (line   6)
 * :include source config directive:      Configuration DSL.   (line   6)
 * :inherit-configuration source config directive: Configuration DSL.
                                                               (line   6)
 * :require dependencies:                 The defsystem grammar.
-                                                              (line 261)
+                                                              (line 260)
 * :tree source config directive:         Configuration DSL.   (line   6)
 * :version:                              The defsystem form.  (line  68)
 * :version <1>:                          The defsystem grammar.
-                                                              (line 230)
+                                                              (line 229)
 * :version <2>:                          Common attributes of components.
                                                               (line  23)
 * :weakly-depends-on:                    The defsystem grammar.
-                                                              (line 141)
+                                                              (line 140)
 * also-exclude source config directive:  Configuration DSL.   (line   6)
 * around-compile keyword:                Controlling file compilation.
                                                               (line   6)
@@ -5485,32 +5564,32 @@ Concept Index
 * exclude source config directive:       Configuration DSL.   (line   6)
 * ignore-invalid-entries source config directive: Configuration DSL.
                                                               (line   6)
-* immutable systems:                     Operations.          (line  65)
+* immutable systems:                     Operations.          (line  67)
 * immutable systems <1>:                 Miscellaneous Functions.
-                                                              (line  91)
+                                                              (line 108)
 * include source config directive:       Configuration DSL.   (line   6)
 * inherit-configuration source config directive: Configuration DSL.
                                                               (line   6)
 * launchpad:                             Where do I report a bug?.
                                                               (line   6)
 * logical pathnames:                     The defsystem grammar.
-                                                              (line 271)
+                                                              (line 289)
 * mailing list:                          Mailing list.        (line   6)
 * operation:                             Operations.          (line   6)
 * pathname specifiers:                   The defsystem grammar.
-                                                              (line 163)
+                                                              (line 162)
 * Primary system name:                   Components.          (line  70)
 * readtables:                            How do I work with readtables?.
                                                               (line   6)
 * serial dependencies:                   The defsystem grammar.
-                                                              (line 317)
+                                                              (line 335)
 * system:                                Components.          (line   6)
 * system designator:                     Components.          (line   6)
 * System names:                          Components.          (line  70)
 * Testing for ASDF:                      Introduction.        (line   6)
 * tree source config directive:          Configuration DSL.   (line   6)
 * version specifiers:                    The defsystem grammar.
-                                                              (line 230)
+                                                              (line 229)
 
 
 File: asdf.info,  Node: Function and Class Index,  Next: Variable Index,  Prev: Concept Index,  Up: Top
@@ -5599,8 +5678,9 @@ Function and Class Index
 * locate-system:                         Components.          (line  97)
 * make:                                  Convenience Functions.
                                                               (line  54)
+* make-operation:                        Operations.          (line  78)
 * merge-pathnames*:                      Some Utility Functions.
-                                                              (line  62)
+                                                              (line  63)
 * module:                                Pre-defined subclasses of component.
                                                               (line  23)
 * monolithic-binary-op (obsolete):       What happened to the bundle operations.
@@ -5629,34 +5709,34 @@ Function and Class Index
 * output-files:                          Creating new operations.
                                                               (line  33)
 * parse-unix-namestring:                 Some Utility Functions.
-                                                              (line  12)
+                                                              (line  13)
 * perform:                               Creating new operations.
                                                               (line  19)
 * prepare-op:                            Predefined operations of ASDF.
                                                               (line  38)
 * primary-system-name:                   Components.          (line  70)
 * primary-system-name <1>:               Components.          (line  91)
-* register-immutable-system:             Operations.          (line  65)
+* register-immutable-system:             Operations.          (line  67)
 * register-immutable-system <1>:         Miscellaneous Functions.
-                                                              (line  75)
+                                                              (line  87)
 * register-preloaded-system:             Miscellaneous Functions.
                                                               (line  61)
 * require-system:                        Convenience Functions.
                                                               (line  65)
 * run-program:                           Some Utility Functions.
-                                                              (line  89)
+                                                              (line  90)
 * run-shell-command:                     Miscellaneous Functions.
-                                                              (line  93)
+                                                              (line 110)
 * slurp-input-stream:                    Some Utility Functions.
-                                                              (line 161)
+                                                              (line 162)
 * source-file:                           Pre-defined subclasses of component.
                                                               (line   6)
 * source-file-type:                      Pitfalls of the transition to ASDF 2.
                                                               (line  77)
 * subpathname:                           Some Utility Functions.
-                                                              (line  71)
+                                                              (line  72)
 * subpathname*:                          Some Utility Functions.
-                                                              (line  84)
+                                                              (line  85)
 * system:                                Pre-defined subclasses of component.
                                                               (line  51)
 * SYSTEM-DEFINITION-ERROR:               Error handling.      (line   6)
@@ -5666,6 +5746,8 @@ Function and Class Index
                                                               (line  12)
 * system-relative-pathname:              Miscellaneous Functions.
                                                               (line   8)
+* system-relative-pathname <1>:          LOAD-PATHNAME has a weird value.
+                                                              (line  15)
 * system-source-directory:               Miscellaneous Functions.
                                                               (line  25)
 * system-weakly-depends-on:              Information about system dependencies.
@@ -5674,7 +5756,7 @@ Function and Class Index
                                                               (line  52)
 * test-system:                           Convenience Functions.
                                                               (line  49)
-* traverse:                              Operations.          (line  73)
+* traverse:                              Operations.          (line  75)
 * version-satisfies:                     Common attributes of components.
                                                               (line  23)
 * version-satisfies <1>:                 Functions.           (line   6)
@@ -5694,10 +5776,14 @@ Variable Index
 * *features*:                            Introduction.        (line   6)
 * *image-dump-hook*:                     Resetting the ASDF configuration.
                                                               (line  14)
+* *LOAD-PATHNAME*:                       LOAD-PATHNAME has a weird value.
+                                                              (line   6)
 * *load-system-operation*:               Convenience Functions.
                                                               (line  29)
+* *LOAD-TRUENAME*:                       LOAD-PATHNAME has a weird value.
+                                                              (line   6)
 * *nil-pathname*:                        Some Utility Functions.
-                                                              (line  43)
+                                                              (line  44)
 * *oldest-forward-compatible-asdf-version*: Pitfalls of the upgrade to ASDF 3.
                                                               (line  83)
 * *source-registry-parameter*:           *source-registry-parameter* variable.
@@ -5714,137 +5800,139 @@ Variable Index
 
 Tag Table:
 Node: Top1684
-Node: Introduction7673
-Node: Quick start summary9976
-Node: Loading ASDF11683
-Node: Loading a pre-installed ASDF11985
-Ref: Loading a pre-installed ASDF-Footnote-113798
-Node: Checking whether ASDF is loaded13980
-Node: Upgrading ASDF14894
-Node: Replacing your implementation's ASDF15882
-Node: Loading ASDF from source17305
-Node: Configuring ASDF18406
-Node: Configuring ASDF to find your systems19179
-Ref: Configuring ASDF to find your systems-Footnote-122484
-Ref: Configuring ASDF to find your systems-Footnote-222731
-Ref: Configuring ASDF to find your systems-Footnote-323013
-Node: Configuring ASDF to find your systems --- old style23474
-Ref: Configuring ASDF to find your systems --- old style-Footnote-125901
-Ref: Configuring ASDF to find your systems --- old style-Footnote-226133
-Ref: Configuring ASDF to find your systems --- old style-Footnote-326900
-Node: Configuring where ASDF stores object files27056
-Node: Resetting the ASDF configuration28459
-Node: Using ASDF29516
-Node: Loading a system29727
-Node: Convenience Functions30744
-Ref: Convenience Functions-Footnote-136104
-Node: Moving on36182
-Node: Defining systems with defsystem36553
-Node: The defsystem form36981
-Node: A more involved example40387
-Ref: A more involved example-Footnote-147369
-Node: The defsystem grammar48051
-Ref: if-feature-option64666
-Node: Other code in .asd files66498
-Node: The package-inferred-system extension67634
-Node: The object model of ASDF71901
-Ref: The object model of ASDF-Footnote-174231
-Ref: The object model of ASDF-Footnote-274583
-Node: Operations74910
-Ref: operate76015
-Node: Predefined operations of ASDF78498
-Ref: test-op80612
-Node: Creating new operations88501
-Node: Components93714
-Ref: System names97198
-Ref: Components-Footnote-1101870
-Ref: Components-Footnote-2102166
-Node: Common attributes of components102488
-Ref: required-features104050
-Node: Pre-defined subclasses of component109897
-Node: Creating new component types112331
-Node: Dependencies113621
-Node: Functions115492
-Node: Controlling where ASDF searches for systems117326
-Node: Configurations117948
-Node: Truenames and other dangers121423
-Node: XDG base directory122709
-Node: Backward Compatibility124123
-Node: Configuration DSL124839
-Node: Configuration Directories130394
-Node: The here directive132221
-Node: Shell-friendly syntax for configuration134114
-Node: Search Algorithm135131
-Node: Caching Results136632
-Node: Configuration API139876
-Node: Introspection141915
-Node: *source-registry-parameter* variable142179
-Node: Information about system dependencies142748
-Node: Status143664
-Node: Rejected ideas144119
-Node: TODO146500
-Node: Credits for the source-registry146685
-Node: Controlling where ASDF saves compiled files147220
-Ref: Controlling where ASDF saves compiled files-Footnote-1148632
-Node: Output Configurations148676
-Ref: Output Configurations-Footnote-1151537
-Node: Output Backward Compatibility151603
-Node: Output Configuration DSL154329
-Node: Output Configuration Directories159784
-Node: Output Shell-friendly syntax for configuration161341
-Node: Semantics of Output Translations162650
-Node: Output Caching Results164219
-Node: Output location API164699
-Node: Credits for output translations167121
-Node: Error handling167641
-Node: Miscellaneous additional functionality168482
-Node: Controlling file compilation168954
-Node: Controlling source file character encoding172220
-Node: Miscellaneous Functions179035
-Ref: system-relative-pathname179332
-Ref: Miscellaneous Functions-Footnote-1184956
-Node: Some Utility Functions185067
-Node: Getting the latest version195795
-Node: FAQ196740
-Node: Where do I report a bug?197135
-Node: Mailing list197500
-Node: What has changed between ASDF 1 ASDF 2 and ASDF 3?197835
-Node: What are ASDF 1 2 3?200009
-Node: How do I detect the ASDF version?201050
-Node: ASDF can portably name files in subdirectories203357
-Node: Output translations204907
-Node: Source Registry Configuration205934
-Node: Usual operations are made easier to the user207561
-Node: Many bugs have been fixed208147
-Node: ASDF itself is versioned209979
-Node: ASDF can be upgraded210854
-Node: Decoupled release cycle212006
-Node: Pitfalls of the transition to ASDF 2212935
-Node: Pitfalls of the upgrade to ASDF 3217205
-Ref: Pitfalls of the upgrade to ASDF 3-Footnote-1221572
-Node: What happened to the bundle operations221742
-Node: Issues with installing the proper version of ASDF222844
-Node: My Common Lisp implementation comes with an outdated version of ASDF. What to do?223315
-Node: I'm a Common Lisp implementation vendor. When and how should I upgrade ASDF?224248
-Node: Issues with configuring ASDF228131
-Node: How can I customize where fasl files are stored?228506
-Node: How can I wholly disable the compiler output cache?229599
-Node: Issues with using and extending ASDF to define systems230978
-Node: How can I cater for unit-testing in my system?231739
-Node: How can I cater for documentation generation in my system?232627
-Node: How can I maintain non-Lisp (e.g. C) source files?233148
-Ref: report-bugs233580
-Node: I want to put my module's files at the top level. How do I do this?233580
-Node: How do I create a system definition where all the source files have a .cl extension?236730
-Node: How do I mark a source file to be loaded only and not compiled?238703
-Node: How do I work with readtables?239699
-Node: How can I capture ASDF's output?243426
-Node: ASDF development FAQs243857
-Node: How do I run the tests interactively in a REPL?244096
-Node: Ongoing Work245962
-Node: Bibliography246241
-Node: Concept Index249677
-Node: Function and Class Index256539
-Node: Variable Index268093
+Node: Introduction7706
+Node: Quick start summary10009
+Node: Loading ASDF11716
+Node: Loading a pre-installed ASDF12018
+Ref: Loading a pre-installed ASDF-Footnote-113831
+Node: Checking whether ASDF is loaded14013
+Node: Upgrading ASDF14927
+Node: Replacing your implementation's ASDF15915
+Node: Loading ASDF from source17338
+Node: Configuring ASDF18439
+Node: Configuring ASDF to find your systems19212
+Ref: Configuring ASDF to find your systems-Footnote-122517
+Ref: Configuring ASDF to find your systems-Footnote-222764
+Ref: Configuring ASDF to find your systems-Footnote-323046
+Node: Configuring ASDF to find your systems --- old style23507
+Ref: Configuring ASDF to find your systems --- old style-Footnote-125969
+Ref: Configuring ASDF to find your systems --- old style-Footnote-226201
+Ref: Configuring ASDF to find your systems --- old style-Footnote-326968
+Node: Configuring where ASDF stores object files27124
+Node: Resetting the ASDF configuration28527
+Node: Using ASDF29584
+Node: Loading a system29795
+Node: Convenience Functions30812
+Ref: Convenience Functions-Footnote-136172
+Node: Moving on36250
+Node: Defining systems with defsystem36621
+Node: The defsystem form37049
+Node: A more involved example40455
+Ref: A more involved example-Footnote-147437
+Node: The defsystem grammar48119
+Ref: if-feature-option65617
+Node: Other code in .asd files67160
+Node: The package-inferred-system extension68296
+Node: The object model of ASDF72563
+Ref: The object model of ASDF-Footnote-174894
+Ref: The object model of ASDF-Footnote-275246
+Node: Operations75573
+Ref: operate76678
+Ref: make-operation79414
+Node: Predefined operations of ASDF79835
+Ref: test-op81949
+Node: Creating new operations89838
+Node: Components95051
+Ref: System names98535
+Ref: Components-Footnote-1103207
+Ref: Components-Footnote-2103503
+Node: Common attributes of components103825
+Ref: required-features105387
+Node: Pre-defined subclasses of component111234
+Node: Creating new component types113668
+Node: Dependencies114958
+Node: Functions116829
+Node: Controlling where ASDF searches for systems118663
+Node: Configurations119285
+Node: Truenames and other dangers122760
+Node: XDG base directory124046
+Node: Backward Compatibility125460
+Node: Configuration DSL126176
+Node: Configuration Directories131731
+Node: The here directive133558
+Node: Shell-friendly syntax for configuration135451
+Node: Search Algorithm136468
+Node: Caching Results137969
+Node: Configuration API141213
+Node: Introspection143252
+Node: *source-registry-parameter* variable143516
+Node: Information about system dependencies144085
+Node: Status145001
+Node: Rejected ideas145456
+Node: TODO147837
+Node: Credits for the source-registry148022
+Node: Controlling where ASDF saves compiled files148557
+Ref: Controlling where ASDF saves compiled files-Footnote-1149969
+Node: Output Configurations150013
+Ref: Output Configurations-Footnote-1152874
+Node: Output Backward Compatibility152940
+Node: Output Configuration DSL155666
+Node: Output Configuration Directories161121
+Node: Output Shell-friendly syntax for configuration162678
+Node: Semantics of Output Translations164197
+Node: Output Caching Results165766
+Node: Output location API166246
+Node: Credits for output translations168668
+Node: Error handling169188
+Node: Miscellaneous additional functionality170029
+Node: Controlling file compilation170501
+Node: Controlling source file character encoding173767
+Node: Miscellaneous Functions180584
+Ref: system-relative-pathname180881
+Ref: Miscellaneous Functions-Footnote-1187328
+Node: Some Utility Functions187439
+Node: Getting the latest version198217
+Node: FAQ199162
+Node: Where do I report a bug?199557
+Node: Mailing list199922
+Node: What has changed between ASDF 1 ASDF 2 and ASDF 3?200257
+Node: What are ASDF 1 2 3?202431
+Node: How do I detect the ASDF version?203472
+Node: ASDF can portably name files in subdirectories205779
+Node: Output translations207329
+Node: Source Registry Configuration208356
+Node: Usual operations are made easier to the user209983
+Node: Many bugs have been fixed210569
+Node: ASDF itself is versioned212401
+Node: ASDF can be upgraded213276
+Node: Decoupled release cycle214428
+Node: Pitfalls of the transition to ASDF 2215357
+Node: Pitfalls of the upgrade to ASDF 3219627
+Ref: Pitfalls of the upgrade to ASDF 3-Footnote-1223996
+Node: What happened to the bundle operations224166
+Node: Issues with installing the proper version of ASDF225331
+Node: My Common Lisp implementation comes with an outdated version of ASDF. What to do?225802
+Node: I'm a Common Lisp implementation vendor. When and how should I upgrade ASDF?226735
+Node: Issues with configuring ASDF230618
+Node: How can I customize where fasl files are stored?230993
+Node: How can I wholly disable the compiler output cache?232086
+Node: Issues with using and extending ASDF to define systems233465
+Node: How can I cater for unit-testing in my system?234262
+Node: How can I cater for documentation generation in my system?235150
+Node: How can I maintain non-Lisp (e.g. C) source files?235671
+Ref: report-bugs236103
+Node: I want to put my module's files at the top level. How do I do this?236103
+Node: How do I create a system definition where all the source files have a .cl extension?239253
+Node: How do I mark a source file to be loaded only and not compiled?241226
+Node: How do I work with readtables?242222
+Node: How can I capture ASDF's output?245949
+Node: LOAD-PATHNAME has a weird value246420
+Node: ASDF development FAQs247906
+Node: How do I run the tests interactively in a REPL?248145
+Node: Ongoing Work250011
+Node: Bibliography250290
+Node: Concept Index253761
+Node: Function and Class Index260620
+Node: Variable Index272394
 
 End Tag Table
diff --git a/src/contrib/asdf/doc/asdf.pdf b/src/contrib/asdf/doc/asdf.pdf
index 84c1abf7874ab4a466661322ca5cb81bd441847a..c440927bc0c12cb960ec4aded44d751b1cc3968b 100644
GIT binary patch
delta 293033
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
DZh$MC

delta 287278
zcmZsC18^o$w{5J6ZB1<3wl&Gbwv8{gZJQI@w)rKQI1}4?`R{#I@4kAkPE}V|SMAel
z_g=l%-sg0Oz7pQe5dJxX1~4lQG9iaNy+`6*^p6}j5@gksL%>FW;?|>wmXje@$cy2I
zetMs$lR^c@L;uam-F_nsj6@=#qKYtKB6JHAp<g}0xV?5z-AS8?kNwI+O<)82GNdr7
zq<YwMSI5Fqw-ly5scuzrj~M4kE_qVw?MtoUI6F=JK|`;Du>ZcI0PtMTj&=4PyX){(
zu?Y3M91Rd$ZDp3Up!9`VFWT$>W43zrmVwrwx`4jwdh>~pqSBlye8TE;iUt%buL!Aa
zo2^~}tEBpot`)<wKn;zloY;@=whI5-`*HsKCqByAh?ra`zmvTdF9F(t6ETkW=S*QW
znYmv>K77CoU0!ml5$Jka!Zjp%(kBc?5{e*ABR}k4Pyj__BGTf!5~fEPozCXLL#;@h
zo+nagW;li}xK%MG!)ASr)$&5-)!Bj?$_5bweRh%TS*7foXkRXzmQ1+ExysPzENLo!
z!xy6n;a6EatyA|8tV@z<Jd9>G5}Vm~t+n2`PKKTo`Tn0GxR?YVL}zDDf%3H3aZL25
zsR57*1c00qpjE4cJ~c+!oH>;;IGy_Lq=amgXaRca8L6O~CkW8^?}ySSBtn^&J_lbG
z-CvAkYye%0xGtZe)pk0d)|0P!7?+}jp1!^!D)7l6cXu5F&gSm5U5S*QOXG$x&(HWs
z9CG82`rP%>(P04}AFZK;W+g1ndG%bmDd%o?Ie??a%`(4tZ@fza>4L#nicMa8M3Y?3
z60#P<WfKeExHcDmZIGn5h%yR$)S^}9SkrP{mT8uMd_^E2cnE76N|3gsJO2o*QjJHE
zW+smHRl5avy5<)i8C1EeTQP~@6^7%6pwzxWu$s&TY*CPmSWkIt_yOt35;b(9vVRuz
z2~dkB$`YyIHzj<HBBp-C=-xhax{Jj%nzhGMJIJ7d?8VR9Nmz?zP&d=%@X?%4KlCmX
z-c@(B-~p+0mA~pZzSd=M<2~xDON<0%djPM_mba(7_6|fn%|(5!RT|fzdmYdxoqN5I
z1mS5g3>GK2>8N>38!%{enD!EPQAYv206<M0X%P{lEm>if;qEqTXITy5#RnH0aRvTW
z*fdgp+nOugsDK^AD&f2&H^KOUVE-60n-&dc&rNy^D=O2$h&EKQX$ROq^C{OZkK&Qh
z=Sf}kZ30=|+FN|*5?r)#ro&IPYGNLg*Qw@J`1Q}Elk_KotpmwZe08b%UHQ2LC!kYx
zIT<>%T>O=quh#*q_pzZ9890J6X_D%TBSS47k7^QSF|HGZ&QA7x$DJ9fD&a^5Aw#O|
zhkKL3sO*-;X9Dm3x<EWbh$CZ0hcyKEOdnZ>Rj2U$Mv9PT(Z?#Dc#FHmc%;llK+TXl
zMO3Qn6ID%aH^#8zSQzf<LS%Zt1Yp8>R4lZB!wc_;Qf})yfN4MP*b^w`le-i`FB5S<
zn=U$c9O`VOidxq-p)#aq1!cS+fTaF3n?EolEWa2Q?T|_>NQ^0y8<NH!-UzAZk|o)`
z7Kmo`p_l)W*k>JGkWmUFI7lcu*=ZnPo(K*_Dzr+NFLja#>V&o;-QXct1ORqMFK?3H
zS*GjBjmd`-T?m+Pwq^XJk9i7r42p~zG9eUu`k9(uDCVH}Xiu_8CPZn#3i`F+UZZQ2
z@a2TnV=wXt3m=XcvQ)IbUr_Q_G8G|h*cn+wqnd3j_5^BeFshtma|)h{h`!jQ!;nF|
zgzPDEa`ugGo2K{Dsjq7O3D0Pzazt^A-%!CVl4lp4oTH~dS8phYa=<GK(qtn+3O`wy
zArrKD+LW#W7VQA+JZGu<SE>)RK=>3&k|Gi{C|g<pA~-c5TgMsLhB5m0j{08XM3|};
zV!d^%_@rrZrU}pf$q)!#D+aW2aingqFn`^R;w8onj%97HHkPMA5hdEc+WFe=?++ni
zt@ca!6=a^symal=ve7eebm_p_h$Z;Gi{a=fi_s=W+S}{(0BjYRf{{S58#_PsqL7Ng
z#mVf{p7jIdK1BiaK2Dae>O^=0Rr2#=eTu143dNFPYB82))t2#5Mrt;e3wQ4x)8t#V
zSg4QQtlwU|dUcps1l=C@^8pk<bjfH<HO`Vx*KFc#B_QfAI@kiEPsum>LA_?NqqDc=
zdd--OD@yD#1Y}ownp#{Igm(pYCFwWioOcAjJ7YlaRn%5CJWj@p`YMNwhGXQ?6>CrD
zjwvcZb=(%e)j|fx3I;Y!CFv}c)tW;PL`5~OYxw&`kG`eUw$2*js2f+u<l99H0pV@i
z7@T^8=VhB5_Qfl#g-bL8w(rIRcadS?$iKou7HukbE#u+zyO-HFx2-F?>gK=Q-gg{V
zv_*h$wTH6%hhJpTd@!{{hWJA}mhcKO<4Pc^OUTg&3ZpE6?YQpGa^X<yfn37HVUW>|
z17OB?8i4DUt-vX0_S^WEhQAeOK|Opec&_ctt*ab-g{t*v(h&*yL|G`gjKAZ?l=rEy
z3XW&%jf>KxJw|36iy-|B8ldtEO^Cxa%SQkK#HTP`zQ7vHrrch4?3<S`9q~xeL+sj6
z2ps2SqVr=3(6yRIY<6sEW#1%h`GUO;>_{1S#sa539ZZb$YT*(p93|ypJ90kisf648
zt?77^tnqtcwHNKXv;=`37xn%4Kc7O(Kjz6NP$xYxS>j6#tBbLai?rmO-a#VUjL!jK
zmv)P_V8%#1tQS|%S?RAATcyCt@uUt<n+J%0oM9|cYSR!WjT6GEv7MKJ+Ju9$xn+b0
z@?qn+t5J#lZglG87&ch#EEI?=tAl>lHG)(y8oC@?FcE*AA7=D>sKiw7+w{T~&<17i
zi#3i;0>*K@BogB&M1IR0oRMErh|~d|Ispa)_LtCoE>cV3JNC{z$$7VJghBG2M%VYr
zl+F1QF9@njZgB^<?SYyQh9{|N9_hEyx`N}_qutY3JVvd4eBpmyc6S}lTf*KgNOF&d
z%=hY_2w;59ldcDh0edop;OW)7`BXSUJE-hSg71z;x0XUohF^_Ok9b&C$5Q~FPs1bv
zw{jCHr(4fo8Mn(1&`Yb>dbjKsCK(SH6xKfUGEn+Bk}6(0>rFL8cD&vB2|U#@f%|^{
zet)!nnbxB(zw2+ETG;=?<k0=3);z2z?p?@qm~aHDDh-Odj9(SsomFoU%kR5MGp5VK
zR*JC1J$x4M5(dqW0%tPuhz<bieFZT(gmId<RKCiz2(_FALc#w~kt2jXiG?zu!d1H^
zhw-gp5}PO42h^Pf2|?8Hm52SN^-i}}*3eVNPa}gb`Szou^eA@QjqI1ox8?@8iTyh=
z!|TliB&n{JXZ!K7hQ;l8y%cK%ndS61Zy(Hcf0!dIY@H$SNM^=-n*rK~Sgo4GaOGCx
zHJ0Fu)zMLUM;R6pRaSkz<^e99J;0hxk9#-eyO)od^A7VWxB(h5hPi%PJo_G2Fc~#?
zMwFBeUSV{(Rb=%gcrnM4>5p{G%JtrJ1SJyRLt1Qhf?AyJYD3@U5)Gs{R#X|2Z-a~l
z;f7Ht|BleHgrj{hKoncJ(GlfIOP|+b#<)Xy!ybgz$Dt^ot6B5xl84~8BnCDHDvCP2
zpN3l5DgIMk;0iZ$m)dc$u6V<nwUF-ql$0~6ra@%!U)u_i9B0=viuQRh*5}_>VLl~A
z6X%(evK#SvCS*>fLV0i4dR~{RWt9H{PjEXTGjkcVIm<~m0gH#$SyyyAz>giPOo0`i
zw-|cQl}FkwfKK;vs%fldx#2^}9JgS+2a&%J`7UI>!W8+sEmnRlRAn`ee<H?S3X!~s
zC2LBpU8n{T=hUKT0&Wn)y}$YIo~r`n;cHZ}iUP9EaHJ)6WDNEQT$Hnp-1$fn2~x3f
zznMq7`Xy-#z;VkXy?UoxmVTdlGyK4V>6$l~SndBXHiG#tV{kFBpL<x;>|*!uVs1Z1
z{VXFXsulJ147`lm4{H2bFa~AiN<I~sAQ#!?FxbIW<tmvY#7f_v9~q)8ZF)AEpj*|o
z#$+pnsTqRs^4Xkx5kn|L({`j|vH||krPe#tR!|=0x#ALT?>#G7O=JrgiL%0-4+Tw#
zVqC&aM~r-U^1{Y%xD#^W3?xZwoWk%@OCYMK@LlEJEaU8-Ae&E5A7<T~yfSb)IY-)j
zbqIgz*4EHvR-mY4NIHU5_UJ4dr~<?gWXOf%P%X(&3nS>%V@vWd*|Xd)-T>2sXh}%R
zl+=f&?_kCU^dL^j!B|2(H|&b2N}5G#EAVv7_>R9NQ;UsH>N@=F;#xcYIZ_tk%T?*s
zQMeBd*<nkl4>M5ZFoyW7isD4>l834YQeuBcI5aXdfTY3-D}hOkH}uo)cHUu5bOQ~U
z6r=K`B-8H}mL$%<5qv@&9>D0B;w9IJS0$u7sIJWFV5(p@Ii`*_6Z`SjL)1{Ult@a#
z_*S7`q4X3hJRh}7ey;*=@rdA^Un^W!jx)E9&rX`LjdK1sgg2PrWBRjHzZvi8($;!A
zqiL|j?}6iOL?$HMM_7kSHN9;+#0YgzHoZ7i-T-WoJsq7LoFY0O7f_b|+<f7_HK)U-
zFmY|ydP=zxk1d|8r<WVNv+qR^sR+-wo21PhfF!rNqq+qD9FMCmLiYTue&POD!<l9V
z&rjRQwu9LI!-hm9JQg>VP2u3u2h`qJ@=G(8`~6HrJ&KGsx6r;MH7{`76C{K>G|fOJ
zres}IP)HYCRhhLf7yyZyPRaCgc>d|-xz#-C{Y5eSY3G$7O}g-Bl5}y@jN%v+y%bw7
zkeb~Mj3T`@prZW5(2B~4)HFgeRU^)AGu0|sN3Zqc$N`gSJwH_aubYfx4s<ZF1Qxc`
zNB;Vt7?ZNRkn$Wj@uG1sE=aGQZ=y65FUp<$(eW8>L8(_-5DrmE6NzCN9syH>%bdfK
z321uazc0{n0hZ7IbX;hlENS%#U})ehtQ={=z2D{1MYgUz-Y7=s)d#IdJAB{x%#+<^
zb{nD!x~l=Kct8sltrJ;&fs}iDbP?e1`pX6hKdXR3v34a4cxsct4(;sQzo`t?uz^PH
zul~lCTxl8Q$;|cJOLg1aM^4ta@i!uUL#)=hfGDclw@J;vJ%>J_)=Mk&xw?9@Tu0?4
zwjSMp$>npRWiS4()x$jfj}w+IR7wacZV5jLv{kt;+AQgh>e2-(xS^vTzgJx!?Ap{n
ze1xfMQafJ)*_LJ28CQWfKdY2l_17uCs+oc1AI}$lZyIwyF=*l~LOyG!&H!clx>9e#
z_`WGVFfcDcNWGs?IUZ9MQ6tTFEy=!*^HEd)zTJnDC|pLE53#IOC0#v$!s1=YmZUt|
z^ImM-q)ymkm>oA|!>j3x`0`fyu$Onut6mM}+uKL}rA_>+trGCVt5u#^V&qD+;qUmG
z<`AiIw?1?JgR)2e>rcFe6>wL{Ge!226_aolVF~%1>)<(14Y|`V28vB?2G55}s~%)P
z(`&0X;$we~0u%ZfL}R`FRqe&-Dwh4W_8>b;JqU?hQW(*~&0o`FN+^{jnDfuOyvErP
z1`!7%k~sZ2ZOX(IVe}YBNvn)JExn(W>NValZv?wR>riTc5niF0GcHVnic9yz$=)a%
za}FB9ol!EyORrThBj(5QVHVk$Fxi;_cCN9OW`Qzd6u97Vf@ks~F(soK?K~##BIUjw
zwv#EVSkAv+e4JE@+2C)EXKfK7I{lOoMO<Km#!yL<(EY^_Ajtds`qHn5hd><R-{)vA
z9v(-uyVZ$mR-qt%$*HFsi=9MO$vQ``J%q5J7RpA8r7CBeK#*BsQ^SVZP72%s;vvM`
z+&SpaTda6jiNeT`Vn!;Dj%&_nQ@Un&sr*$vBKojlWD;QpTo8i9<@3rtXcG?P{h7`+
za0ffLR*ov{uwNgR4VAppYHL4)@q%e8VE5jC*=XW)e$aqk#18y$BckU&r0xvpDB3cW
zm&385%5c=>4(Dm%#r|BqR3Ntom_%!@=b}vyQXddIZwrxR4amk1hnf=yo#2i|W`eTB
z!0)q!PTAW5vN+Y!xJy}$vYcttxL1r#t6xn{M7atRd#-bT$KtlGDOr_Xqq5fr;aC}T
zgk~0+<%e>HE3n^5A-FDeX?}56djqUGR><!QW}ECIgb*kg`E(AI9BJVJ;-+wn1*pJO
zVaQTzrEl3#!<I}ZD%h(7-KKIc-98;^_-#&AL0;JL%zb64uMOQE5{Akak_HpGRXk3J
zptOptwgeBM9BAe16A5!0^NF<O&^f&%QiJ$YvDNXb%PzVLS}FY-m|T55+xjW!DQ^0=
zQxu!|p^exSyN0KtaRB=<vY*q*#d}jrgG`6j{w(YvY3Y$4)Bjue2HU%iq*hQ=O-@M}
z6*k7+22%`e+D{(6T^A%i@1t`C3OQfz%C;0HeqCz7S-qg^HSp<uMjtZi8ha`)>db7^
z%ZpG>TDDuBXQ#~k`h~z@fUVo(ZfTy^DOis4BG@f>eFlJmAcbQDaWp}+RS^Pll_Z|X
z>=B+aiPDniL%x@l`Ax5s^!O5k&4(3&?>)mp<^4^F?sV`CiuLaRJ$_3PKMC?~06(D1
zi}%qU5or1;kwZFg-JY4CSSET<6U@T>?M?K{7!&NbjOSYTvE&Yx3u(1|v^j$F2%fh%
zM^*s}{@QZ5c_(+hdQ^E~#O$ZfK31NkIm=Y)s1lw~u6AyJBxP)DP>#A$N&fz#`*$c#
zj}gb$dH1}-_ae|nKxouKND9FhhaQ4Ok?50r6Hi{}9?%iGiZ(5WSOc4Q$x|1>u+n1u
z;O9*B`>_?Z`<dd%nCgI~m>n*YSk#4DP+}Wk?f@QvyCD-u$g$BRH7ArM$e<UC=LS$R
zmYmFi@2nvby#2XYt?dfruC;U78&b~`V1?1;aCmjfpZc@6iUT8yu9tr}#+Tal0(~0W
zmCO##q(Z#HMu-jQcz(+wq9@SY(&Oe@>DET<{1our7jYS0&4oT9I(Xla4_NpP^*=yl
z&dl6*k>m1R<md*H%7E*BzF&WE@%>fn^}+wTd`*G0!S`Iq+FkZ)Y?+QCvxp{+oE_}A
zww?9{39*D@>_^AT3V<!OHlVSBO81EQ17H+Fv$Im5q0VaA{{2oajg<Nd6g01Z-h#`a
zSL*pDqJI4<-AfNre(i2mInHw-E&vhGXFYHzpUK#Yb5xs}A*7OvM~v*VSt)vxF(CUq
zq|tD|1*Y^LslJc#mbu4i%(#Y??7q&ezxu68imrO5KkBP+SehdyJ6ogkEO5L+1h;^$
z2S&}2LSBaI-vL!zXf`JLno+zNL`EQi)oRuF>-Sl5qpt1cR?gq<?x{0BK%>^WUuwoU
zzk+tgqySB>A%Nt#SBIngOVwliYb`4Ji%EAMpuG5|s2$<4-<e&0^O<#7;`X-E&1%7#
zyZnI3wz*wmO%P3$bPRtBQ$uQx65mYK)whvwMdt~GUn2NLYYnx68;V_$+q|;M_vr72
zSDW=WD|hbm4-QL_%l&30;9VabxXnoAq3QwKg&hd*!K4eWr_Ab4$xJE_g0xy<_4Y6;
zSYk~Ut>sI&<C9*R<PH(Jg03e*+mb;JP4VqvO`(}klyxo@ti=n@JEacoLuYqZw$_nM
zk;Z$##J^46=i7@VZYXj4?<|95+?VLSD5M*tr@WX43cCoy;UNNG#0TqLze4;_q4#oa
z+(!EN*b`lKcehgd;N%$n;5qI(eRXwjRzA_k5>b9r1CYzlXtv@j>6cw6*4^Nm`-Gg}
z>PKbvYep)I8tY3-(Y#K%VqK``<P2;QKmo+=dXXgZUQ@io+%3(lmr!qMFRi#)w{V4~
zvj=3&Mt)>5qm=@zr|7IgKR`L9f_Y)jbGooQcH>>d{_SaG18|nml*S4y2|^Na3S|u>
z;!WBhB5>(s0|O>9e=3x6C!FZo@7v?wif*5!oU%|dMYkQ8OA+}lY~n$d*upXHVs_^3
zB9vPD(^`4$ImjZ%P$a!yoF8^_UL{(_=fHX|SkB?Wk+I6aF~)m}!PcpofVoPtOlAhi
z;l!L+vb@}5hA(?LfXmgcPFME-t;<ec8)u{DHaZ}mVm!o7_){-48%`I)mD^(xk&t)^
z0A>A0jrw2p6&NRXT0%ZJ8Yo9vfIleBf6A-4@8zh_t2^3gz4g9KT0fan`GhT-7HW=v
zZmdyyF5U%enK%Uvrc$?N$A8oQ7TP2Z9vSl_F@upc`0lLky~XqK6@y{ne1T(`wu~`D
zkyB%4ZAHoT0RPf04KoV%`19CJgRd$axN9=@_{yJvndMK(w6%5UDTNO;fAmxVF81^%
zOD#3NdR~E1M78Id%E74Y;s+TPGvcs)!6YO!eu7^JI5R1F?b@Q@|8C#xdIuc1A9aBo
zZ&}N@$1X3sEtl4=FSlD&tEX1w8rbvztoeuh?G2Ys(Zv;=htpR0#8kkL{XTG&Y4W$H
z94NU-eJFf#dPUx~`6rrI?WZB2Q8VxP$o!*$@&;USj08U<upg3^*&nAXj1aBcZGayl
z$FJf(et^|Bv*h%4jCI;mGXQ5-E(vlH#{k~i1@z!4$27xVQ^?)<ysG}>5tpCv*hf4A
zJiKjZl=ulk+Jh;C^+1MLdy~tR$ce`5BG~&}@M8hn$+82ry}VRB*02vCX%&ROFy^ai
zt5L4?c^vfIc{)571`F-zz5~-^zhQ<>wD}?x3;_y%_ao|r$r4G$Fmu3|seMG{AcR_8
za{zt0iD@3*0182FP0$ZE_4;<XGq3BuFZ=8L7<4u*kBA*^BUSA?tzqleu7dU~xRC2B
z%THp>fHrs}Q0d9*+m8Th?N9p!rI_Q7uYYpC@$CMXFT&-=AjBgu9=%CWVdRl6Ow3Nt
zhlECnX9h=H-s$SB0lN84<E+~Qd55PRTCrGxS|0_aU1znLL^cXkcS0czfuipajep|r
zDwkDqTIZRM34VgjP)5ic8waj<KIGQt;+&o7mPFfe1UYqdYDfUSKDY>Di#mF=F+A2a
z-wF`SxBpNH3HLPkP>KcHO{<Z8V@InM2c`PPj-f0c1bKK?l8p%!wJAqVbJ49%4u;sr
z$o^%*jSrl^@(pF2tPPVgjMk6X;oe2LHbYiA0%ug#^v7Cl+QESMGZm<5alI*AcA;U7
zxH~d#ruX?i0*E5olkG~>Z8%ianZi?4+5LXJ4($@qJ2HzY4&v<ezquiTGZ!eSrps4W
zfoAyVGCT#lcLb7lkZF-T4ft1CM^0c&eu&1p;iy|}70GhD%rd`6EiOyQ<TX{C3OzOO
z${@g0al<ldW4`8|5+kx1>}hjhqsC`7H$&S%uJ39y0ECvhyh`RPHECLAxrIN~%~p}M
zJuVbcQ!ZyA!9^hyGi9UU!CFSDIfb4<lz-sAvzyfysQzxqf!6cKn^b|$rRL+fZo`Kd
zlU+>t_YKz@Ik3w=mEYtCml0rE+TDtu^hQ>IxZ*`xv+#+7Jugn3lGgFlo62|7bSNI!
zk)W~#$Q>}Y>!c@g;FZ_x@GbP@n2ra#?Mk*ND#$h8<`^us16t|3OLjME+j<%e*w$%3
zyuP;mEnl6cax=Jk@2til`Um$a*p7$2FwH2BznF79mM_rhtNp6YtE}1dSW((*k0JrO
zM|48r{)A|nVZ8Btq$_D_SmoF3$dku-VGKbGfXUlJ{W-@g&r12IK*_hjYrYNXA-$N=
zCB{zAhz^=A-<6NeDC&OBnVA+r(4{t<SXswmT%(Ec;P*4N?!^fYKT}rd`sXyMNbT8(
zjH@qPT>B+YA4}btWyiupd8uno*)@4Hc;i+9FF|H|Yn}LsD$?jKeR7~~i_+!nj$C6I
z;FdLH^x3i7WP1@Tq9ZY{yz~%SS;=JW*0^P7+m)A}?43s;4E(^qkDK(#0YW(87%MjM
zOnoFoE&H383boDf-j3f);mWbdEeUTcCJytWgdxo#{nUyp;?L#WJ{|Pr<E;o&)~yQi
z{4iKdN!mp2$B!@cpksqvP;h>Vuq*?h5lZu#%TIJQ7mMlc8vIt}8bbzHYB+20K6{aW
z`ceOW4O=Bnz1t)Ztl9pAp<Uf@x)7$3RP~7dxvF)fOGj}k6RW`Xf%bzUx!0Tm(<Y6v
zS6J?|BJSjN-4s|MeHi1lz6#y0zVP66R;=>XCAj^5sQ9@I4@p;)wj7OnCtn4iR3KCE
zFd@zOh0{kVuepb|-1KY!;S@<HV8(veVpXax2fUUZ0vAuXdsrZk`w(32jCQSnSJ-8S
z(j^3gFFlcgD#}b1*1D}XHA0>Z{bR+ZF6+A~R+sa{dD{-gY%yL?o!Z_==eF{o7oyPY
z`5d#2v~m?s{%WQ{Ijq3+7#9GLihdq8qL=su$H+UXs7|t!#{vZ-UrWThTmM;HWc2Z!
z<Q~h)DGol$cX0S<Jc%;BlH_4ad(<8td<h`V5JlbzhW-j-=MN8NAH#W++wso}<Kf@T
zTFUl%OGgfLrf0g=jy=!qX_=Sq_qtg*B!${&I&do<w>)UsPdNqyUzY&2e-HDi()|4P
ziNWXq+9~2&Y84v5f9b0VXRP+j-12H21ZYietWXmTF7G4eSrb_@v!>9$@Q+}<AGYz^
zw=_F{+5W;J#_Pu63P<yhM2yNLZoLWG3a?{?Ey|<M`teeF#l74{&3BXyj0Zhia4B(D
zmbWH6j1stWDP@cEh%E+ed2_+2#_!)cu@Q$x+nuPHeDjK>*0<dqjYL_K^gA45@$i2Z
z#779rTi?X?4$cwu?H}Ba#+iM+a-a6ELA|t)b1jm}VwGV)w(KfEz7r70Z&omn;u9H=
z!c0t%WN;ZLXb|V>&(&S3*4y^49GdB+ql{(Gk(R2K%%l$7On^4gBX(!f_!rl8oKF!S
zG=|@aIlL&xX{TbdBV642KMu>j5jI^*W3|N%Dk}iFv(1$4x{1BJg9*EQ-7kCEo0f?|
zvnY*56%5~Zq@MhTT%u`^SDCVKWa^FpRq2cY<Knj3!)@DMF<ogHwZ+6lVgK-~c`S1r
zJyt|l?;0kHP(WieKL})rf4_Ot6BemBrvnZ3H@VSQn?a~8I}(%2OG(7};8Ri<s7*cS
zuk~sn@1q^~Ht$ok&?YGDz?vMiNIV~#(j^p%hhgL9Se$1RWeaQb$!jew$JI}ksBcYh
z(=;DSc?q>u@h{F&DdCRBHnvJ@KKzsO;xT<7XOA<W0P^I<aB&H{9m(E#_X<lXCf|7n
z2R^VXJLOC6<LcO~t9C;}k@=`XK8NM>SS#~{u6}~roZK03Lj`?aL}c%|1Dz^&R=mL%
zGHT<N#b@B0S=+>2X=zIVX<%Z;D%1E&9?Nyi7~e~v(_`pPa>{W_sUlW!mw9w+Wwu+=
z57o5<u&*qC##QQ{Jm!j@hw*4%6{N?1ISs)?kDwk&d>6LwXB}IZOUDVG@)20YFGqy*
zQf@D}Jo-(jB48=^&1-rot#7nd=9WUZSsB1)`FffOUmo&FbZ|@MN8ksO#!P@wXP@Bx
z3YYshu}WVq9=&yM%o^3&EYU(5|CY|@p(ixpbzrntWV^6wkZVK-ofq5rwPZr)YVana
zV*yxRdQpU<SR^wFTzAZF?V!8%Z3W`!_*sPp=|Nq3EVNWT01BDq2ea%byZFRKZGLBs
zDz{JXx8N?zBq)ygR12(^x~(J~bAh;W$B>$ht+@pZ3MK!=HJjZNw4=fqOI#Ge!{3Eh
z85S##ruxKUaC?$SyD0=kOFE`!1!v)6O{)K(2I%P86SSiE_VxzGorpd;aS@S${}fUk
z6c50JvB9$V`P|>UJW^9*EyWW5`9^pdy*bpLHNk=ve`V)3?rb(j!p%2nF(Iuo8^M(z
zLn>2}DwbM&FGg;;Sj?WWYbcvMilnDxS&^@?>qZs4VN{VHPE`v&VMXKL80nN*-jW+x
z0I-@N7E&L;sDnunR)aeZ?i~<;9{D++*p^=@Z6vX56#=QPBU@d*;cdh>!IW-o1jfCu
zE^IhLizyE#HSdLtu6%Y4qmKJ7p0FW{D)dBWNzcPK^7mSnCbF<$C)F@4zp@W;_-Boq
zl8Evev!41|K{P3j=DR5yVy4iYh3r~!F~CA_NnMNI4&mP)VOkkZk-HTi3#!!{qL`$^
znF{HKMD~J{7}!Jl^?$LUeo7wTcC3F2<>wiAI%c(NDpVV`UqO4+MMS|X3qw@X)Ns1z
z+0})sTxHdFb?YiJ3x3Ns7q0I9*uV-cV!&^l-(q5E1wTyG#v#ZRp8SU+GRU5w>;b^8
zEc(;0a?fj;{+qUtjB^dH3Z^C~SMqm0kas?uRi+!Af9_A5Avy_IXJ6$_M^((uKunB<
zSo}R4Q!t910SAf^O&Z@N6l)zbcRA#|sC98A(_9!vi`xhj;U%errxp~I_Vm@yR}^q2
z>Nps}(qzLzco#zDGYyg%DX6$ueK7!d8$A&rKM#K1*YSrbkKfa6URv1xm7->Anr18K
zI8#e5VXPvfy#i6KzV5a`eht#6&&%udq`jhGX;d_HD3lOe4_E#x`)Pk+^BU*h>M=$C
zR6>54QA&(%&g~t{fTa~3bRIu<U$2MrTMpem|53$-o0r45){|k~kH*vlA1eTE^fNp#
zwzso`2lUuz3TqHi+xH{cmEM)h&%49V*YhI$W!S(M(mKO4fmux)vj&^Q7~;$;j%8Nh
z{ljhec`>UB0B&g;XnyjXRtC7wtMhB?_66KM+&rJ&Uv8b8w%Y&Q?9#7gu#dZ{Q~Uz!
zzd4*f15^u6BDG#^f10r^e*j`crHIGU5Z}s=LYTOiS?SX;-C8aHTOajtj#0=<ZKHf*
z53;X%z%t*u$G#r-H>RPH5|dsJq2xWR$EfGw94bP(;Vr6I75or_|96Pv|9=L7_<zQW
zCh3QHLOljRCs1f$DjLVPUl2R6MPt)kJRz?CK5X$$l}A89f8Ok$AEr)AN#U+0$LSBu
z+D02wxGW95Y}qV&Ezw!0n=~iGhWPr*6-e6S2{YGu6?fCY<v%SoF6p&x8?`QS*Hr)J
z+Dfv^lB8Xhc9fkv7E*t^YIam#m-7&eFRZ?}LU*tOXiDHlKx%9jXhuNtOdGjpB3eqU
z=Y9<u*mo{OFl;*(c1Q^d!kv<_5GJLCl^BqUz5-Hf<qPpxHIO<MuueOE5U3=YX`SME
z)xIr7=k%)_`e><qs`T_62yie(8}9gQ#=9x~O`C<wWO}YHqCD&IF`6XE!S%ZJ`J<Gv
z<O_iaxWx#NY+8dNQgmW8XEVH39x+%;sg16v;?+HIU5CTW5DWX2^iz>qK6MJuha+MZ
zhT)~@SG>0-5N3uWLh;X(^fgHeQ-kk|R_c-JFPudk;Cgr9OH>fjIK<=E+wCD#ULexC
zm?fT%FCtMY*z>^;ePJHq>bF}%zY&<<FUX~`0Q&|;q9gOYohpQkOV1t_%UTLDq;Ah!
zh0>^vmxJy(G655$nB|v02rAndNIwFbcLrJQniz=+_@ll#9#nTc>P?;W%rZ!+PY~`g
zZmZdmn>NtHb&n{?>6Vg|+M~T2*J!B!>&$nJu<QrI)_EP^&CjBw`M~92_X3F3OVjZV
z5VOPcDnH}}h03yg4Pm-dBAJ0q%%gR@XX2L7T~p#LZ||O#w`I^{!(z-#vr%3kk3ZVx
zc<OD3SRg3jm2pqLq}o#MC~}cJiT%%o2@ApAQ0;Wt-`usRnlV+w%_Ho|rT8A`9`2_<
zAqgRK&$9H%7B<E4Z`<(~?Mo5}u4@4(b_CvPcPABQzf7!O54qbLa9DU0{i=<mZ0F@=
zF8@I5MFt<Kr?n(l%NH3B2k(xDldM<bjZ0M|J;T*x-b`>N<MH%r-4zcH$J@j(8r7aQ
zhu8+$FWA&cwa`ffk*x2<m;}3`5<TKw&p#CCrFNm@E<V$snjr93?%~|^_^bgCRLOou
znp8FCe4vp*(2?k2+Q83H3i4ULQzzEk2s<7QvTjMWcq}}tp1;$EVMd!+TR%@1iq@7S
z#8ElbG$h1N?V*|IpsuHy(aGVB6DV#>!rs;_TtcYocx~-uHLapFmRS6=OG(SLr4-PA
z53SZB<xE@PfHcft)15?)q<aR0Dw%Z9617H>kG-@NF<J)IO)W4(3M|htCurHwNiIG|
z?<8HRw;z?*lbJ6*hpL(MhuxQKK>ejNOn?-4xn&YaGDdR9wO_dHgWM;5{N!sQ<rUP8
znnqQ?^GQTjNa&gC@iDa!#}v7ki{$7jS^gzr8z5Vd9eYmx<ooiU*#Mlyq~AcvA4t4$
zj_WjfNHA=rG8W9Kn@uDB(M>p{Je7#vstoe-C3ZEsV}sOlBqwy({7YZ_7vCvWyaL(&
z<Iwj72HbzYliRg81h1lbW`Q}O6aK^CQ1o)4VKeB;u_K?W<JQw^UQxZ^Zem^(qi_RI
zfV})VH>h1uH{?hk2}lxiaZjX-y;aISEZ|}hbu<gzn}Z*&z=<?wML#y9LYz^`&Mx5M
z5p{G6-MfYlQ4=pvPk_>caV-ug3&4_>a&zCHyZ*n2)y{HXRe&aVox)t4i2jMOh4Mdc
zAkl<tDyh;a)*Z4-d?1G1+bs#?z8@v=JRlJWrN1sNbc$#7%GTixCsp|dBQ?T%=SxZ~
zy{P+gNlSb}2MR`=KD63FLaYqTK%!pbntK0&Aggh9`!lg`ZT*iMJ3`0BHZ?a0VLS(<
zKYh9-bdauRGi}YD`tfwl`9ciK3nbC(iwNwG;1#xS$L{uM_P<`3m+c-nQ#%u97epsh
zL)-tH+8bHHvHbVWC<HSX7uSEjB%=YyI|Dh8yWcb|ydqqX0~Nu}$&=a~vlPrWN^_6q
z?uBHdhhW96q-bK_&VC?+z-p7h^D0m(@bQEb$?}0+T^Q99X9~ZFHe%0kkr0;}wQS_{
zJz6zqoCI+S<`EmWCWp$7-VVQvFS3r9!31KDSh#)qjUa<!@78wTJ)B>8J~{$!W?$+k
z8D~3Fu}1>pCvKtSf{loS(;Yn#P-~eFy_Nj2WFbhhdqsnLyc%@qU`g)8KIUI6+kq(|
zJ@-6SPp?$Ki#wMz%pX(7@(U&_d;4Hfp4!!uaCE833ok%h?SG+(Ml~IrgD@~;X0j2{
z>3$Km6@;BjZVxSd2S3>K&lUli9lL{ms^n*Cd3;}YWsT;7<tw?l;wE#FG$3fdW2J%D
zaSg^OtAP0(y7xWZyw0bQTFanB>~cLxM>5Mp&VPg2j0ATmF~9Ab2*hV%|KPw6r=)Tk
zkV=(UozS5|IH0<Am`J45oxaAeWWG#RuUqL>PwWwhxj2_M7%fg3si6aYg9$lGDsR$$
z>0=wpkeZo@k}qVvk?k!E7b!;s@3x@c7;Vg9I8tq8J)nY)!Rq$58JeV|$D4qSohor2
zGQ4pvw=%X`nih_~70)~*psLlDQ0%94Gv-w-Ja}~VgMkI?cS>1D(k>1w)p|J-X<oL;
zJ79zYoeqc3+l=s)_M8AAqU{}<sh)l%ajU;_ejkK3n^|-HO6l}XElUxgMVkJcTWis%
zJhbIezz%>{8jFR=G8%LtO^(^#91Z1VL9_XWXyd`$xg&GP#%M7raez=8*72j#YQqj`
zK`|zKEv#Q7Nd>o5<xnu>A+xGO+LR{X=z$AKt4Gm=b~Iye%mqN7T=YFx0<T_noD=#t
zvV-AszEEO+m=o>}aTi(K3wW2$9yUEkss^+5V%J5-)Qm7U8rx1M&&+T;KCtVV_2f8~
z#YLrwZ|6)eujQ36LxCzs!{=0@_(KCF@Bl<p>l2yVh~)zLnqlJR?P76l?&FN{D)))&
zQ?6!-*AgGVy9yLn>0e>Jdv#*Dm%!+`z#Rkqf78A_2Gu@2$f3a3K&-`Auqc#p2q&L_
z;MW0$@#yWE%BTjd$H{5;_<nSosmxooT+&7@I;3S90uy_*0=f~9hQ1fGKx$yWP$|AM
zl4_7Lo;eM&CiCIwdHSAHirnwgave~nb^lB<RQV`Cj}hf7!zxRGq-we7>T7(N;%U9h
z28WSqTj}N*uV-ZyRC|GYezL1&2n)tewRq$7={OT5)f<I17!u`FeK;s-pl?~@V|y&e
zt)~LA#Tl1C-;8~_oc5tr-4mWp5w?|Ez|mp8S97HbHxN$}`)E|*D0_X}_Ya@^t<MfO
z&p&BEc#2GISiSv%bW4Pn;Dve6DoE9)^p*7s*sO#s6|$cM#WVfbXY8bB>8EGgrMGk5
zbxevz54O4=wjHf6qgk2nlu&d?(Fc{>TW9erQ#lpU?E0YVfjDmhc2JkxO2w~$)DU{O
zbnyxqv`p#gEZlxCwK;e&RQ`#VAHA2!s>JXBE+mFuyhj3MOd1>1d&*@ngSI&XQI<J@
zBh29r2V9Uy&XKaNtxK`OodZ8ICOwU|%DpuC2}6xZ<A@AsSV<sw{Q^WBruap$<5?Jj
zg?^Jm2$ssF0aH*gSi+9LNnD1r^lPu|q}dP7_Tf8bVbnkwT#ZVLe)#f!G}#B4RNR69
zQnb=9STOjym;J?{rfTT3G8g*N=RDxs`r=XocrVA56+rs?O^ru4%dCx;RY-TrYX=>4
zbiJ8*btRFB6`(stT9;gNb=9Oz(;~*9n``eYfd`dznUudS(Z41uKK6gg$4M%#8_y7m
z6TEIFw@^bPL#F`=oby^@QWSxPZ8a@`?)0q#c^Kr)nypA?Q=(Pdr|ANx9x)Fi8hkG-
zD>YB-3F%<JE#5g*mn>ztl1|R2`3uAkh%Li5`Yk=VPH+ik2>kt6yR3@!7`kS7&X95^
zdqLZI&KXRYf){7kySVu+x*_cF!mI8fwi062>jJpbX<s;}^=u_2Y`ZFAMl&n`6ESo&
zFC4DoO>E=GsnT!S-E!OZ4&bOV`AU<FhWulF4*mtp>g8&N<?Zz3U;Vf+tlFa?@3pZE
zqd6D8<o@qhH=j2X4L)?Y1zvCP05u6r<YzULG1t#*a4W%p=bE)-FU{n}7ofNtuvv?@
zAyM&38UlwHLa<t<|Enc3$&nKvvNg9&hGg6AG9_8wv0a`DO_(G}T$>n1q&gm?;y*=t
zBJP%8epo8=2!s^&Vs|Br#tur~vKGGAL77aJxrYghEN*<X93qjASB`)PXo0%{r3n~A
z9=VX@Ei<i`d5Vc8s*7}ewPf*t8R?--*yQm@cSKkgx4%RSl}*hrnt-tyv@O{kPTuHa
z=~!bVnO(ARqS7#9lspy1syghq%w2kj$wc{QXk`|t&&m;S|F}ZvwzZ2{^p_$mfX1%d
zKT=yp$fm5I7rj+FB_nfax<`>v_wW9zn~iAmeAe60E-HnDdq{WN7ibKz^WcAPoqg*r
zNg6l>5*HUY9HX46ow<tzF*6ri8VVFBHK6&IZQP;+@@KAo{of5ggGSyr1`@Iz7j^P@
zD)*EP6@lO(AsM4QR3eA3o>>o02T7aD+BH-YEN`=1PvAOEQ4Xezg`|k}yQ>5;PPGQM
zaXpV=&FE=}Gm15`0Fy5|35zc(bHL1ghKgTlcPKG}OkArNEM7P(W*q-NI*=xJIsmdD
zVWKb0`%jl}Iry34bS_vG+##W#@@}O;X3KpjQt|b~@JcHzPJaUNx6fdVi0T8B;BW;Y
z_R7;IVT(weJq@L(F_G}tr==2@Qi(-z46_~A`h1W&r2}aDv;tw!eqmt*OEcxDp=*$r
z=O_M=lhTH@##XcTh*^M-{BdT$+YdlJTW{Zh!{b96Y)n{Q(p!TVhRIfFG;+u@#wkv6
z2<0M^;fnG=ZgQD<#Ys5w|3jJWkn3yQhmp^P;{f?5k=zD*64yrMm>!hE53)L($SFQs
z%kv;Wc4Zo-;0f+~A>k@zUlRq-OtPsvlsb6Fi$Ex7$BT4Kn2NvuE?DVx1{UCu%2^u)
z&H=hDl-?y?iej{zv!@w<zUvxDHyiLX{Q%s7O2o;8mXvJt5`&B~PyjX&ZIMh$0hH$_
zWKbZGirdD3ft-vgEK3Dd*cws5FsO;S??-kD6f?rPGPpVztsQc|e{!FMvGKwbv0gu!
zAJ}+mI#eRPIa>0MSTu-wm{<TY&Nyba{F?tHi6X*M2zwux`E{l$()o7g`e0b&%geGj
z`BB_iho$*l<0Pl;)0O$z>!8hN@p?^Vjz@_D-}2e|yJ@q{Fs*f>8WYg#r(<Qj?pV7J
z3ob(D=-#d<vmn}?e%77Dl;Y4V!v`rLf9CEi(%w25n#jU#JDKl!$Q{6nj0?@wX_)V<
zg!RM0i;RoqPdH09GwS+AoVg$R>{vKlL~tT3&ipPl<p;7JHY^f~GXu~(o}OpJuZt^I
zFovB49Z;Ar!)x+a%R@pMJtx{cWr!pTQ_<5>w}0^u<EiwG(m%2^Afh5QPEZ~uBhB~|
z+K!T|De)>2r-~zqy&*tl%A;Qfi(<qXm*a3>QcrgCquax<*ebLNhvOyMyr|fqboeK9
z7F@2Q%HohmCfVN;0z%6Su!sE^wc7c1=>|weaU5yI$g-j!`4^6bh{=Z`51#_n9vfG(
z6R1t;pZ&Wq4(@CHFJv)_i+eXA3NLPb_{8%^kNX)3*ByBLn%01rENKKb#{Sq~Ng2Ya
zpH1>S_k-<@JBewP2c;r-MIQun3PZG0I>=8dQ(y0A_5rax1|#K+oLQ^TnTw@%yv$|k
zpl}z|3Z7Itgz8;1Upw4F?%ocw`sbO4zaR;Q--pL5((^R)bZ%ZtD;P1aD%ansg(^F?
z+*K*p*4uoY+jRgM?^4H-vsKGpH^nd6{5$h`VMCI8!$#10={e&(#}}Xzjf7PLMTB*H
zCx<B$Rufi}rxRZJNTxBS@}ARDTRv&4q>5Oc9b=2)xeT{131v}yx(CXsPp_j%eU!AG
zOZ#knAY?UV(n*L#I4bn}o-UNwnXfnRQXaz6SU>c_QP~03+I+_bs<jc@ycHCojTRHW
z0iy1x(1?!Mu!yG8C%+5%GL!Nbnmi&+=GwvbpJl4{iai+o2#9oL9Lh2<k#LNhz9K7#
z<`zR|Z?s=c!zPzH13q1g9s4Y!H5s0g5Yw`7utx{Ai13hE^j|g00>!p+F&Xpo=-kVP
z|0O{wc;f@k&O)2}xP0XLyOO?d1BIZ6^Hnq4WlTA;sO*&z*GWFbORW%9#&mVi*>4ri
z%OMA$*;8sD_CURl6Fuq%6DKhsIySXy963CGC5Yfy9jD6WSkbn))AYt>kV^m^C(<`|
zb7&ldgRN172aAX%M3V!-eSRV26l#xa_E{JF#tE3x$J;MBdT9xLDb?;>zNr1B%K&s$
zb%)#baT5D_JM?<lB{E&^(LLX=b8g>aaMR52e11qMHlH?XuKmkAz2BI$IQ4Zgc;!g{
zd~Br2ueB-!w5eRqufB>WB;oVbrx!%;QM{^p^lj!vzU$b&yMk({QXgqY8vOp#59`W}
z-w(j$=QH%u(6L6B8gc-~ssP>6y{4uk$NU5Fui{&l%GIco&X9+1r*(^Nawkp|XDGkP
zsDS-x>zR96=TE`=?zSJCb+(Jbb!W@2&QF?eEgP56!+&SE;RNi7_&oY#8-E?5IX72)
z_G*iQ*)L+^bXL_CodeA@UH39MzY3R3r{n?4R}J2Oo=mQLtbn92qemU-rUAcv=;hog
z1qDps_R(5;HFL)GE*a?#b@R#uH6A)D({gId(p)vwdU+bYE)uejr$@ou9fo5lCGROQ
zoQk`8Qwj1`F1+<Lmw{(1n;EY#$9$tZKg6+4%`^`Xd-xOY()De#vL(-6jT>Lmf4C?=
zc=iudPj;r9D!dj{-}<su?*;5gWyXfJ*)nG0J|tG04Yx2hdRw-aJtJPMV_~Fb4f_E)
z@4rBlF`P#KyW9Pr%`Ph|^M7eAG8YH)|Iu1j7Ve~7iSNeO9?12d#`iiM^IGB^wWN@0
zu6Dk#&j^idD^8TLK@PYvk*HY+Jo@_-L&fbz)j4xXf+FAJ$(rqnuQCxXE+^A378z%x
zy;GD?AU&uOp*X-bS{R9~simHMv$jKvqX?=R30q5{GAt*R$tg$mS}KPeGolZ{YlMlb
ze{#$=0tg*pR?XheVhRB%R>)W|BQ>5;1N%*ve$+PtgIGVN#Y!;9prA!(!EefJQ;aeN
zv+kIg?l($@!rT)|UY{%FKu+yPnO%aif;Oz;Feb)I=!&*xAtomsDI6KE5>WGFD2C4=
zwn++^7{@>wVPB*aEdz`WxhRqpm)OH5H7eQ606@;&g4G|A+yvpg9<Uq5N6U3&B10|Y
zMGnOzNlFn(3*XcaKb1lPU(Gh4R1Uog>w%0Pr;O8Z;3xv##)QuYhJq_BEpAXc$?zK+
zO`d9+PuLf|&11q)TwDPo9fkZ6+ALXH?7B$F93_DpBi&drl4h#EQc0pe!MubUjZ|a`
z7hr@u6m$v~a8IKJH(vk4L_;bB=g*IcauJLWR4Qk9Ge~;se=-&@(QdRZBH&D;3E5QO
zN7%yD--pr(GBTzRP-+CA`dBzqj$NM({IoxJ0vm`k7;!rabxWa=K|-llp^7*dq;n*g
zq*S5|NmRH@#NGsq(;S&WY@o%tzSB@OKv`ydS4ncN!~YL^8EcRSTLlhF&hP2-249Pu
zEuUDmrawA5^xC*9%TeQJtLLw|x`1-Q<#Vr*T94PjZco;BuU6WL;il~k3g=<&9es{B
z6#>4W7Y^q$8lcudvrZP)<N$|lI99^wSA@FQwJO)sHSgP1t;M-zACawcO?XW;KvO(7
zg>CbZIcK-KRerbMFRx`HO1bOb%|q>Y%~O&)ck#_}m1a=gETaM**5t{8ncb=j#DiNG
zgvjN*XZQL_O3fzvynNa(<(4!pLM}_6ZH^t78%{f0JdwkPLQ$+OJHPP_NZ&N^2sM{z
zEE4cfMeDQ4c)+-Zo3@%Pkj;%5;G10YacLvYb8VMv>@cCj|229PD}gt(k<y~K@YVX%
z_#|m(H$ysTgHUERHokua;vH3f(NKOquxc$7EAC9faeZSQ#PU>Fciw7jtmsRK%7W;G
zH$?=9Gvw5J&v2G!{>$x+>`2I>8;bZYb%EnIy3W(>H75_3ZMfQ;w0PYE$nv;&9b`G;
zdHlD&K0_QMiGZ*JUs!O^sf-zJ;FTZf#yLA#Z7bQ>ls0{cnHFvyS4wngXssA!0fFnm
zHL(Hd>C;<v3w|Q-iJzc%nAt)1mflmqzP_98Qt{_kQk^eps_SZt5BPf2jUX^?xPeZi
zb6?e+4~wJH%)HaOf)^<TAowU6q-(MqX(#fxoIx1s9WW~}_sVD8X-l7fzqvdebj;U|
zd)+09_nFF`qiF@XHrqw@V-+n&PauzcVD=J#H@^JGDZrQLK~KjVrK~ox;93BBSkv2u
zzY8u6yzs4=e)0rWuQCL{(2SHa*+V2nDHvT15aU~=xd%!&q1m<r1}L_?Si8&zLYQ)X
z^;`}E%z?V?R|~uEv$8jjkNXj*b20{B2{VM<&xDJPd>C3?Hl3WSP4!iUuG51qS?pYB
zGaQWLldJHIZJz6^mnzp%zsKIqh`c%K+%Inqppk|IuFcnj)m_@WylVaM4KC^URea(`
zms6Vu5guK5&|jwI&P%b_Vn%BH#di@qv+o7~i31<>4mhtb7d&sLc=%g19#R6n-k(Ts
z*9fi7I{HNkBOl-yclGxFZ<=LiX8*4=n`A482+Ebl+yh1p7}nCU2XdhMJ=N{#sN`cw
zcS(UoBI-8SLGm<NYoC`OsgrGB(nN()kw5r-2t+2+Nj4Z$>ORGXqt3p}9P;v!P5Vml
z4fqPbBgdr&Ctvsd>^a_-j+h1K!!hH|C4r?HWF-yg<9&cN^(X@^V9s-#fZg{m2y`e?
zG#=od!}$~ebg{|=GlLWK=g*3udc~Wfz-A;oNMjoka{Oe>cASwCE12YtNPi(rq++{5
ziP*)%5{M{*nFaYA;0jai!4efACM3FaLO~O}Mh3rs_a9}A1@X124h@gQtzjA>7Qr_Z
z^Euj=Juo)li}j!4Z^H!5P+f}-#!3HQY<**sW=*hd+vc=AZA{y?ZQHh<wr$(Cr)}G|
zZQgnB`En!f`2jnkc4bE8s>-!i((@nxfv7tn`A6%F^{2@jHzJI5g&B>91Q-&E%_50M
z5|Fq8=Yq^cGVJ~m#)k+1<DIA0r-$MXzU6@<{)5UZvJd(YY~a_F#tZ@X&<}|T2aV=0
z2V%PjN{Hi*45R@y3dWDX!vy4Lz8Jqm81*-uUt9pp7mPWOA_xQA5jPDu&WL1^ztOCU
z=@xKF1RTPB9thqCmhX>fFe?Vi1l~<);{2Ok#NihJNT40l5DA4Us&cl72u9M6A3KxO
zPvF>}9vC7WGo4c47t{dZZyNq25V!_H1Tzpg#t36rhS9V>;K0dS%3eZL3QQqT*u89^
zKpMe%D8GhPVdV64;TEvh-EIL^bX50mX&?X^DJUeIV+fS6wdE)i=%PlLCA5rzSQsI*
z3Oa0rfRx$ha>K2l(qcT(%s{U_MD7f|GRF+2O!8to)l=fyMC#!Xy2oATd(mj5l;d}I
z`HIZfkkNLn#QPO%IU`fId?gEW%>!{Qo7`xnTI0jl0wjZ5RVHGp+6~R-;iQDP2N_^N
zQ>A_J0|^oZGOjkIfg)#$NY!*`*n2LsLAE<{PFv+T9wEQFIk8z3UwceNaoM9Hx+){{
zN2`=qMWP&5EQ7_p={29`_ZcHSrs=D~c}ZF4W^@k$Kc(_I`P)-yD~93EBh*<zf`;ye
zK!tLxb}R^=rl;{qYefUh1Q;n1FD!uln|uB+9^J>s<!xA8vasM~A{{&)(`T`v5eW3y
z-$kk8@w)ZRtVU^3Sy6JSY3?`HK7^rSQ$3rB<<2{qN5XI#xXN-e70k&hH+@m{I&YG%
z&K9{FL5r$P@;Kg=i6WT=?FP*lql$*y45-V^%n42^;$L#Fjkh~ZmCEJElMaB52dX(F
znW%fuM2G9$(u68vdQwOA8IHyo@7oAe%<N9r_k?9;pZW7mag}C~bo!6oRF7nh%2L4Z
z;~kgA*CAr>FVCXawKXtMiS2sz!wy%Ao(G5io}w0N5w4brVC&Sm<|@15CZ8c%X}~KA
zT#EKfGy(_*_{$l>?SjN%c^ZI=I$UNwCbw@k-zQ+?7k=iK(AM@IMIwu9kHDVud5v`z
z4x$3C#trFwkxT()%;EZVgh|6Wrd{Ss7y8_ki>n(bfO*`X)~c(zi_a0Y{rqD_tewA4
zHFM6P=mO{kHfEOZVwlycIpsQvl_EkVp;<2dbhD*X6F$tMsjBK~WB?#dv+a0*(b_U`
zEV@2qs5Z|1L)U04K|s>cYFXDlQNS~M=qYc8_x@%0vUJc4@AS7UF3h@N^*SsHiQc3l
z!^Pl3gbcQ5{#qonDGuYVZWQWHNOvZ&;1})*E}jj?@s>hA<I)SL)wzGi$j2_qABg-H
zc6<Ii{zAQ46N`ryr8K|_{IsNFYn5B(i9`iz^hNb@v<*e8$KR%CkrfHRtG)TfcphAY
zElz9r%==?t-7xIjQ~c8Sc=yCphlpPOswzrqOpG1wm@8ggbM%2@h>%dr%CQsEsiNgV
zTDkAeXV0bFRgK+@>R0)}uUK1qE~Vsw)~QjO5~<FcvtrALsvW=w#E}*5h0|^0mFzHY
zMeTLK8O)_TrEK^$mvCFkDrX97hic_#?sD_SH3hqzbA2OTXEa1ZTh)`shl0D(T3T<n
z&i?W&hE<AH7Ve?`(%MEumy?gQ!&P$VrVquT!zau7+@7V7Z><6wXavNC!1TlXv2meQ
z`}{|kFWRvJdOV;lGqp2{%|w@vNe#tpAZJoFllHpLlO6AB)UquytGsDVqY%~_cY`1j
z|K#~>S4^~C(lJl-OEGz-Bjw>pn^&*t>u7%>@s34<!122;Em6e=utNd)ccU5%=UUQ4
zhG^#T`W|1G-f~Hk{xF(G^8!^3rM3BFqs_Nv3)CAPZ5|+5!1!L>@3>Xl{H?#t#+!uz
zfxk8Oa!aw*&m$M<D?!lJ|7Fb<Gdf9C-fe@2{Z(Rw)l_;bn9k(Bp(?fEtwT?(!eidG
zwtf49swFn)URkwOgBch+scrCa<eo7;YIu0nYdwQBFuiZ<?DNS}a5TADu~mytrwzVd
zX|S<j_JXBX>PS8Q|CdTOmj5eE1Y=}jU{CB*N(E3>mR_B&eZ0jHKyFmCDWG|r&s;<=
z4}Z*84J_hxxc>FOc~*uq*&wt|x?g;6E$sokUM#d#LJzn_geJM&lM(9ehmM=a)5|v3
z5>MTiKMfBONup7vKy}L!BN^8a;PR)v3;dqo^ZEFMk_s55_WBIjE-k@BC}JS&(RuG%
zh64avdLSg(td5ea=!gkcEDn!EG?GE_$G{OOCcCoCAi47ft*G&@H4QchpzR``AliUO
zwu-Hvx!ug;=QN-!esUnMV#q$*tF2TKnib+}qYQ1jQ${%?QEKhnKp*^byBed=37^ls
zsmm7P{|w>|i)ayyRoED<jq}KTVyETt{RLRp5cgGdt#xP=Q*VIAdjd&kXqVQ&^a05Q
zwH(M;ry>%MHi+s+;6u;9LMHSHhqs8s&odTKzd#c28f@5%<p4cblT4YQVCVz^wi#~w
zhug0;Rb3-BP14nx?Hz3y)Y)O!>V)=c*&On^=sR&_)Z<}c7IRi(R}tc$vAs;;vH`G!
zygq>&w{Lg;Vt<>R%wSZ`Gf8!asGeosQ-nCqr-Hou&Q7Fnc=(L{bKatW?{<_l@+51y
zFGIU<(o6wVt<SBH!vqh1U2sh^%+UjKdz6rge1&4Mq!b6pjr<NseN*}*db2uQzS*B*
z@U$B*ia{prPiZ9a$+zj~tz&awrWI_IgI;1ST=l6PE&SyEUKvxiqj(R=L4QZ+%1Xyf
zI`8LA(*t|)Hc8L;ZtNcRDg{nDW3(7%CqdXeO|c}d7Q5`?ZLz4H+Kg9T=6dE(lG<t|
zW~tr*3`7!T?lBQ43I{NKko?e^K_9s9d#4Oj^eIke%nk8^w_Cxj1e_)FivDokDSeeR
z2YE6P=`}1zomDr>SEcdID6Yqi)$BiWv!@RD=T~pt!KEe2(kT;<KCXAh5qME$T$J~(
zh8F6ji+?znZqF_#*!@0)^_)(RVT~cR44^;<e8dGnfy)nwW7?VbCP5?>H6o!qem~YA
zL=`Cp)EYm^)(ut&pk|t&lKT@3JbC7x$GpQYok*XAb3LPcbMxT|7h;U#7<K)u8tMyQ
zH3+brj||I*1eH68ndKb1UIpJ}=Nlc6{|;W)dxLOX#0kOpFHU2#OeJbUo$J`fV;+f-
z>XHCEPX=>&K~OOv+&lseOJhNx!gz{Qo*H;a1dbbE`DA+gtIn>@+cYIoAjf*lAbHMb
z7o-mOaR|vS7+AvEaloQB)|HsUVajLF*{@Er?Q`{`MdBx7kX(@!)#b6*hzHeQBTB>W
z=f1dRt*Q0XdRO~%gTAJsV|#EI>>#<M3I~8YmPj+WJ(*&X_(O&!$k);in5b>Z7lgPG
z?Qz4~KhKD1l@AcR2ufWNb!udn$dbnm>?$5F_ESld#e7ZVREP;<zMEX&i@BpMFqZA6
zkYnZ(Y_t6FIFtMJkvqd5rIl;cRJKS<uAf8IY<i=^OM%R_&Uy}v1iLY~CcPZf@*{v1
z>tH|s)eS?D$@tkLeiBO}<}qr;BqBopMZMDu-i>c{g!!hNb_*%(QpmF3wK`&4XK#K5
zd{-~C*%I`eOED)>7Wzl_@K{Fc&?7W0#FYc5N2Ckw*7^qEthKPgJM~TAx|WZ^G_(Wi
z6^F)E342te`8m)bu<{I_$H`W|G>-xHmgm|a=-yYVqoeUca2Gu8^ZXpLX+HsWs41mf
zu+i2wI2y+tbKrY&n|5Lk8z{v@e}Ol}-e=YPH3WcfMtTpc#b*{Xp*h6fwQjQhkc}Y>
z*blxW_kM&S2m0psvFDy$pdxH2BCFfa_WV;9^;C8+@-2>WiMTDk6wFlAXq5m+IlCio
z%MEdxIry;c8$b?MDM3D6xUW9sK^9OXwZF)SWwejI^&9aRcqqH=ZC=*pLQ=YbL^--m
zZLsKq1$Ft_yu~sMDF7!bn8TafLfl5xcXOb>1JAfZGgts&dvGwBj+)67{;-(XhP~Gv
zExH}WGzu#ZokpS#^4p};qN4zT13xWwVFZsCkeU!5r8JXA+@Mnh^P=hp77r-I^=ZcF
zsgH&Z25qN|EyWYbO!)pg8Z6*=)Las1>gzX*CXM?_=|GEtWCRdBlQpfI4(YCRd3yJy
zsH4Sl>5yyYZwzN5wo7q_l2qE-`hlS1)n;vBUA6F#sB|u^vaiGJa|XcGU)I(b*8zKH
zCN%Vlm_M)JriNj`f`pNuy~cDSKQ{-$Pq9)g0x-ei_SKyX+K_4JMagjaARRsl{vD8w
z0%$S8rW1wbr6F@+bR*p8AuFRuG4a58Z<!NvVY08tF?g6MIa>$!ggD|Jz(`Ohp}ztI
zg^sXnHXa%pC@U70>9zq24e3j>v&hHflgjtcD?)tAt1@OUCVbAAB@iovh6aH1GW$br
zzHS|z+yi{6vYx)7UVFk!|FA9lyR7#8H85cQBw}E-hmTe02}N8Id`kX6j2#b%$%b@@
zp*v=e>N>A6FX}}!OC$;kQVIQhGaWSldtTWU+z~oHZ_kO=o>~ArZ#ZUJmXK$|fLm*V
z?pyt7xY0Ik5gQxKZ=k<G(|vh-**x$e7=e;hh?+qh>aE>qA<Dgk@`cW&AaaL<q|sFk
zI<$*ukb71=C+>ng5O#GOtf8>SrdBm~E~oFNqXW~17^fb+E5LqAEJ-Xqrvv64SrJsx
z3RvUa8P~wud<=l;m>rGq?`r^tre)q80AVnor}b$p;Fad!a#+&y!jA6JCRChd(XCEf
z_aTtBJ39fMz&2wbp4#-N0c2#Lj3{b^vV0kfAbJi+LepTSXZx`(-mPwF&JFnSr={#F
z;(vh_tgM6#g#U4TxVis5b|y~gK&3Juf=~gb)c=R#bMlYkL&<{LKS<uUIbU=wP0mx~
zAS;UyC9IJpUm&S?_d36`twSRok7hl@>%wgmunXg^e%b8<q(^!?f~nCUUTmD+5V>@%
zvhSJM3C{BUeSrSr`sdd$$;6JWu8xk?-(Bd5geZDj)`NW8<;acGEml5fk;bTEKvKMW
zV^s3|+=x-TCJc^G>2=FQCPF5aWo)O;HaCq?ew04}P0#k{+xbf-us_B=d49nW)-qaM
ziL`w+x2h5Pfg-YMeN;2@+=$5}i7-X5P}(^#5i5@%kgJQ$qWcxb@qDDZdWx~{C_S{?
znDhB>x-|cspeoxGRZ$j>!ionLK=VD%+u>E|%gVL_qK(?+HuoPkwkSTUb3|sHf)5K6
z)MOnkWt?-`7pZvBtpqOb+dE*k8eZ1N=X`6#ZTr+6^xFKXJ`bDro(HGQyUhTtlz&XK
zZ?ZWFrB5fC%m9p6sqGrJ9)31NqE@U0Oa5uXl%fzI>JW7h{w>xUs5r<704QzV0Aqad
zF5y^P32+OC=4UT}{jY367QRe9)${7s99KHCjmAMt+2!4nLl|35bZRK9XW-910dv1m
z<bmJpy>nNGwCD;QBX)+X8XNv;$LW28<=mDg{LVzQUI^$9KmAh(H(`>##Jrc^0?pPk
z7w-=QCFDPNEJ3o<b5`01IHiv8;Dj+q3;JSaD4TA8rCie*A$b4_o`mE%L6!)2i0p#}
z9xv=vD)D|YM?{MG`vliKNs0>nBeD4R34HNE;EN7Ikp+XYBro4OdCh75srJ*0pmrGu
zlf|cU+xc}5|Ap?xYhs!2g<oGqrRwa-SL+dj_bk8J(HRsTsNi`U&@ea{D$g7qW!v(l
zeRM64ZgT=TVBwU70Xl8TM`<s51wx-Ly15tDqjZ~CQ7{}Pzk4MF&D1j5J4#Izt=b$p
z=_0T*!NapbB5I9Y?a!sEvy~(wML@AV6GlEqgWTYD(4$uA*;@JH0RHKMeuzzhTaIPc
zPzjv&Vw>^Nuz|u4I1!Zm14{#^#izl*oZed$+NLaO)Btf?9tB+~cdM>adw*WB)vqgC
z*Ror#f*dr-v@13}lEx+uFKOzVo7|*+SVuBKJ1m+kq?ujEk?FV#mv=EKjk)+hRR{ZW
z=SnOUvvHk+RtkPyfPvgsLT?MZm%d=6RkIR&bME#4jCV`{n2n)8g7btqM1^4{vQ_+T
zB)^TRsU_wuXXast7dr{6!Ar2{afqs4vJTY7FZY^20<XlrUv{|JJpj_XwDr%G1jLgw
z+3kcgubv1r-!2I+5UBUke8yus>n;lztX$i?IBhAFd-lJOBF#)e_(Yr}nWop#tCA5b
z6+Rtk_4oqfEyjE0;g7Shh^8YLU@F@Pdc)xnHKix&49b6@0A6N)NEuLrPQ_!nskDG%
z=ats_iA<+KRe_bv<J#h!KMlJQ9Jm`0f-js$EyzSdEj>4VuhHQpiiPF+S(VjP1{0Y$
zfcU1Gz(>qWri#fPm+wZoNg+)Gd6DgLby4W_kn90Q;N4tH>gA@;r(pA6u)%K+l3yFo
ze=MHgKZ|y8D*bgMPzS}lMG|>-RLG$d90N&n9PzFqy*vqiWxeYF_kSni+(myraVGh>
z3&)j`^fRF_sH3qMKM+>*Ibg()zv;xVK>5!qEil5hErv&^T)$>n>R0&7mM~v~CxPJY
z!cqg8vi$l*<#tx-xJF+V1%XA|19?Q2I&w{sq0{=&LA*l)<#i3nWZ|KmR?=IG7c^ft
zBAVht#Za3bxtX6@Kee8a92cYmWQJyTck4>xDC1Ib<5Qbig>@Mfq%}$FgEU;~m)$Si
zjqxj38U;$1R5dDEYW~z#t)9FLCr~J;X0-qy-b2EiHzt*)*@>~eB5)6+szF2|>JOMM
zs@7qEVk`=T$Kk?CU=L5K58^$-KL2f<fUibBI{<pF%L-=JZx?M=fiA=afaO=+ZMeVU
zvWKhg`7@vfMKnM7DkyMqiGa4@CGSd2K2?uX)ZWPD0Q~%{4V1ZGgD+SL0ksNRzYEyT
zoy@*f8dl0pVD~tiMjGGJ@ROKBLh$PU^Apb(EzW)V_^(%*Ab};<h-r@kdWO6XOq6Fa
zl0mp+-|uKf?iXlV1EUw4AA&<!g0Qv+6I<Pr$KErR7s$iB?tP;5k)Pc9h?~sXbol~Y
zi}ra&BQ)+G-BpScr?QP9n_QXaiwtmYHpQ@q0-MXHhyL|n#tXrivYuWt0@>quZg!XM
zYVQLNNMXgX=0Q#db^6FEp?oOeDo?xA=hFjcJGuH3G9q-5VxS=0bGJ9mZ*$_OhbsE8
zo+@#YgYzbx!A88Cv_KKWj+7q!_!~p$s)6Dg+W}i#1f_Ro^s{w*BH4q`13LAz&YcV*
zb?Edjjyn&2e}X*CISGJ@pbX*<|3Ula$2}m!w+=*^yqEHlYPlO_uWMWYo~dnY>X{}+
z=Ea4Xk#h$gf=7;NmE{X<Y3=rN<NYUscR2q63hW#V|6i&w8^`}!h5yleQuFda!9ds;
z{)ga`jAivtDSzkX8yrs`@83)nzi9Q5FWw@NVdc28eVq?J?>)Qzs2N7{M(RN@^!1vF
zY4XqcGyq&x$Wa{Ogy+B>qgRi8B0!^{IXB(8WwRT`yrn(;&+WyCTK+CAki(x|Z?~s&
zdV&IT3<zHg<Go8u9`18XmXC8C>w6uu%r`-R)z#U<TYuW<hxSQjLC4-$YbxM}L9c8u
zD7^G!r^eUw>ARxmkK%c75z#TU4fJfvD^*m~EJo=tVza^eqc`%<_y@OMkglA9VHz=E
z&<l=Uruv?*dzZu~X|zcvK@37#Xbu<2z2o;Kb|*ze%f!Tdjr+O%dzzEIXWCmn%CHW=
zhUTHPe!{b}*<CDHZI)x*-OVYvpXK((pS&Z3E$KFe$O@TCbGV)M-l?4%U$;h)FZe^L
zP4DjO2eu%u{-5b1L`{tH;os?vrFRzTP^CqB!K+gH<I|{C6Ut3>*CE;j%L&MwwPTTB
zR6K7yGhWPpuM_gtZpB-gz2ZQH)Rx`=j|p{^=#Oi6dF2Vmo(7T}`itxXn5gq7{xasm
zw*{N~m{k1R4A0mZkau|VxcrwOh0z=J<E6Cb-b?sK<=k<Do#zf8;DkyO`tEBPuAxtc
zg>D51W<Oge?cCjlIo|@5(6((gsl(`*GE<BXjRGY>Wx`;4h-D;`C~jI7^gvHQ;5cp4
zeV}sA2ef(#+$e;Ke7f+UKeoAuIVp;!(`2E*w)!>|H@`i&Wq5*JB^#d66*kJAO+CtG
z7GK_(BX8^w6Hw92u{hN|=Uos*@9$2~jWSgp+OsCYH-nEYnZ(4Fpn5fDUU!o0IVT50
zox)5I`hW7IJ`3yZgwOtgy(W9WNG+XOKq_c0c1UH%0lZjiA8Hefy3YH7m|SmpAMNX)
zPCC5=>L?GKvf?eabJ<<5Zk9d&f;qUyDU-X!RlS#r!!CI}FdHoPuQD_3ssUZNS#rVN
zyL{oBVx5L*LNbP#-W9#G;38`F?|3yIE>sS3!KFB!&QH<JQVw6Ivam&f1{f)IFW`L&
z!RrryuKUBkPr>fC>U{n6M#peKBwDP4+gx;$uCVA^Rex_lbDXWl2EGO}b6uL5^YS{=
zkVmZe4mSB5g~7|dhL9t~n`|v=<>P?0Htig8$cgt3*604FPxc$|J!XMeBm@y6_<Nk8
zBR57gU=}>*a406hj-UddAT2Bm{KC3FOfj4LS#U!eu|H;y+1o7NzIVWNKngsZCKR>N
z#^o5=%l_CZsKl)7YK(=X&|3P)gs<a@<`!qIkuvtN?DbFD?W3WWCza*^<}kY5wE^<T
zEL8H^70_*I&Kl{aJbH!6wUQ6~f*;t;4;yk>xC0|2IwL9x(H#K5qHF>iLa0`1syea*
zPWMQUmwQEw>CWV*6RKXa51H_+)(E(($ojau#2&mzDXhfJ1f6aKTU{g+I$H~)Wu!b*
zp^YQwFs$76GM6d2aj4X-|6a3W_QB=VSLyxr4hcts;TjbO`wf={mepnz5%ZT|a-K@s
z(bj*Km7Hw-gbWHWS$0|Hpp#m#^!2RNoTxNh0iI_4x2*`0jkiK45DpUMl>+u}>kS<*
ziHJY|N6udhOZ-u5xZaHkz?9NeyMx9LU}qH>14z&J!maDZjPLt1lk0F{Hx5iWtg&}?
z1NfFeyFByeYE9Yu^Ion<Z91w;ityK#gFbuxaJvx(#GDa;25h5zbT`n53%(#HeOPHU
zoB6K$bAIPTucZG3S=XoHY{WUQMP@!9om44FglIZ`Kwfy1qgH2eD&;E_1;6)D%s=U6
zPPJvs0jYR9)%P6*I(xU+p5}SHt5DN+vce%E#@&MihXS)8z5W0$>p&VI2KBh^xb8)&
zGf~H|Z+{5jfuQTpGO8CG!7}4G9)k31ZV<KCmQ)hi#{6%}nT2+;NRDE|$0tM?=K=aE
z6)zaOFMPL(s2li*6BC7?C`+pECV{v9mWY+~Zt}}e%A|KBDrFllO4sXHzpB(knoo_)
z2F&ei7R^B%<9rwPq`a~JO~~ha^<g$U2^B072J;}mr|sDm)N+n#2u?{?JERRn_FIA6
zL42zTI=dC}R5>}mR#d73{?{|F7%sjxS1!E$8s?F^?8uG_(@0c0<mEUp;r_FuNvCy0
zc3!8H>c>?LA9Zd7+egcQkqSy6P+1J{DdH!;L^$pye+$B(&q?xtmx^A;{-^VN1U01D
zw2>hI2!wjWfY(nJ<ot4CCbzrmM5)hPeFv%Xio}Mic<)WwB>fFaynQugXqm1qB9{u>
z2uvxInrfA0sJStq%gNx0>ntp2ph2B0aD1abeL-i=2H|;E&P55s;n)o8(1r7Hf!&b@
zeTXMH5?*Bg2={aTrMnV@iYhq8s>mLbUlSBiFeS&VR`jcz_`?W9qKtF{%!JGPQW+9F
z3rGSxswgQSx0Z)XLZHbCm!G($c5|-A4rqVpo1Y%y$TjBYUpvP_pxU<#Rp_jm(OBfw
z#=6yxqKqQi18=&S@ai1G2smjzp>jVZrH61f4i~DoRXG$D%UhWCB+^X5bl>l&+hPzv
zM*+2)U={6uO)me%$#_=t32jGW8v#9AZg|(*x`k=T#0jq>Ms&xCPeP(4;Y1`M5^n;5
z<5A|?mhCi;M3QY2HxK}#NsbAxXi9bu{`u@xe^9Ohoa!p=m*C9)NaeLNhM~x28IdE`
zmLE>c1II{Uo<@n}SkZU_quTfHuq*|@EEfvNWj2dS_P{DP&u+@o(Pz^hP}#>s`jlhl
zqSd57AJBLZT_Jp6t;ZrJ8)hbx$$XK{m#)_)E5qN~+!v7j1dr?8t+2{O=LfGd$D^{-
zq3t^=-ykHlfxbGnik<nR`fU}7O5%aAZY|aU6J2@+S^K;qNBiz7$Yd7}FjE5F3zy|<
z5w|7BZ?Zgx;MA5Sg;txxhOT3*-cpTesNlP3N5uSG^De=)h!9}k1ce89L7IUK*xiLE
zm>zk-?j`-kw+#~MVN2c#b~nr05D#YA_}3RK59=^NAE8+|d7U?Z_%r-Q(BhE3-w{{b
zN+6d%znH!0Va1EDpB=tA5GVkqqe(q7>WZ$0l2i~=vI3mth#0q7l+e$He!M1<Vxck8
z5(4@NQ{|N9G+b>0xb_>EKwdKv5jG4~CU0hxWYckI%~6Bxz=8#}P}fBY{`R4&en4*W
zA4c+C7Ct0lr^OpFd%XStiAf}qwN6hISgDgWPX!yImEG-T^_jLzQZs<I6JuSCj?N!h
zAkx@?_mMAlLKAVa&;<H(o9Efo+w4!kO>jnE58-2Cn(yxWJ8fFEK0Yy&`@OTPn7S4c
z*>{5cG@ag8CK>Oi4q+tWilpglpiqGrA6%KnxtW7BUlQ<20oW!3DT;sFO74z<0}jQt
zA+f!<bE8mn1Z+)!P#VDUjRLATB^9-<S$H;q;mj8g0ZJa?u;hb)Q?y6KqOfbFj3aQT
zAY_mn33s0Nj3<+w=Ptj^<Iwu*Z$4bQWANF6%>0isNp)r6Lq38^cYnzr^^EWVF*;7b
zeZjBZ0TFc^VQ9}ibxCY{j2isW+Q^1H*+o#6azBA;(law|?o%ex8k@sV*uwGwk9R+$
z2>;SHz@yae!RAf!s~qTDn)LqyXgN}m^+3@Rx$K#7m>sdO!WN0k&1@xppJi_uo5o%D
zT@y1wHV?HVM%d#4I$-wXbdL5^ET!Yb)|Nb9Xh<zP+xPoMGR-7kz4af-vuba0bb2BW
zsL>%j(kd%EL(f#*j+V%8rdrq^TXf!rf6a7hzbT-3-DDP2J>&fD?)bXf8eg#}Ql!`X
za(H<$v%A^EG^*}VVm{<fqy=9q=oJpfSWBRRNeWkIMNLZv5Rk8bT-8}XhR>&wfe6UX
zK!mD!<Tc@5l|r&dBm6B*mi>FYdSA7UXW7~Kkv!eieOhT6>wJXnVikEGo{nG>c%fG@
z@7gt~*~>BzTXGcKLHI;;_QHS==`;3NVP@EB6XOCcbq-FY=Jhg?!;y1~Iu*Z$uP_==
z+}}87Af0Cj;FapbY}9&#>8aw53>vh$(v0bMLPk~ZAzW&~BS1=dx2ZoNd$XT-6bS~x
zJR>y0%R4Rir>(MP9Y@Fl;B&owZm%a;_%Lw=?;EZ9xLGSa!X4!U<5pmaH!c`oGxsXF
zNS8nB=q<ANfRB0o#^lyv``8gex7o!ZqsNW#h3y|nBz43APEO=^BrtGMS>(Qoe8xv0
zv7+T$DSNEeIl#~L*wA&w;?>zGK;^(+Hw`V^+)&m>=ZU3OH6)Qu$l@G3l>hlV9LVg|
zQ`0fvGM9|FB2`n|Pcy0vW4E9MOff-fe4E`|Dj;w{Bk$pu*z1S}a+Q&|>`3<y)6<ih
zAtQmPS1jCcU-tU!)s<$>8~h2WGk8}>gS0T+rAq7_L?Q8AtDS2b(AI{9z{52stig%e
z*QH#5gwba}A`e97z~Y4@7iwKOL*jQpuJ-y7n(^MhV!-|j{rlN!2jl*08(+96B=-`n
zO<~AkI<)Xufw^_u3kh92`6dWpD=y+qg^Sxs(l#4lBXl3u=*^(mG`;-oQpM1v|Jy6(
z_zQQb&3In}e^7zDD=K|<FmS3@44x04+F8BOu$KLK3Ss{UTlr})(nZLTEjQTBilc59
z%m@e?K$wFvFG>j`&T%4h@Wt&}xoO3aPPwRQc44r2rzy~Gi7upEdA<+mZV`lN-Io7%
z|73*@-ZOHlio_5R{f)`kr@?LsqEMBKqAH#m@A>RMz)YjoKrS33q#_ie4V7Yu{I$FX
zrRA0~wX*d(=>A6|x5J<#Ei>*L2=eN<n_FT{`q$RhZDG6&rBS32y)b>^MQ_oY3U07}
z%p!Owe%lxHM}SbSttUR<uQbx#?t++CS!8oib-3uLx-`X3Ce??w3}2qBG?=8H*Vi51
z(4RC(+`tWXAxF-Lz+aQ}%N9t-sfH~KA0#h|qd9hz>4DmI2%p~Q6TX~?kGr5n$Uy)C
z<R|H*1kpUS!a->uq>cwr2gmOlzX;+bYG=#rpzWHtO=!7Ch@xzORqH`854mT~<Rv0>
zKqjhSRMSjO?rwz2gb=gHqdeXTz9(j{#IUQM*qjy=c7YY)K$ww(s$*3>UeEz1Y}lPb
zFM{p|SoQ7}S5tu1=_^=maO*i{7V{nt;21RU&lxVeLJbXe>j3m&OoS|$I<yRq#YoIG
zd}wf7Mu%~ZLVG#j!M+Go^D4c$N^+c?J%^gZX$bmyHK#ra7J68OoRcQpU=ohDM}NGm
z$GxV<d^8qijTp?d|7f-{ev`;o%~`rZuP<V)A&$nP#??{;A96d)q|5pJep(NvC33q~
zo0tHEJm?Z7VXwn(oqVt%Xy5S$Vag`bj)3bp!yC<%tECCh&@U`daImb;svM2050p!e
znLT3R?lPM4c1q2ju6xk$aH!}+Aub_&v}N;W<xJZvVU|lbG@3ozFh!)_Nb4zuBQ#iN
z$z{K>m;VV1!8Mp4BkOYS+z(c`Rk}{^>YZXa%x-K2HpkIdn`&WPry26Y4tDmg_3Jby
zPC5;4FP$6!sy^Tl*#=Dy9Mr!-Oni7w#Hw%~Id-p~kGZM9l&oY3q9W|0KYn`0&&%m{
zg5K{M_vPX8C)Il*_O=8hO053Hu8AT7gh3-Qcf@*<(o2mgNl&;mFO~lbL~j@cf;>pU
zz8Q4PY7H7Uwto-*msFYJb4q%oEi~{sDQv$yB1H|rE~BHcVz`uOgwFw%;LN*euQ?sd
zP~>s7DYvs23`I-;?SgU<tZ7B@R8F)v3UygT&<%!ik}kYjAGa96Tlc#GTm1%-T2^t6
zz}rIak|q&}m3WBO;0a3pkLzEEf*dgeTlG3eLZuAmOzKh#9XbiJ)L)$E{bz=#hiA$v
z+F(ck(i5DFZE?TSpWl*des@gCaGefcToRTj6gva>(m$`yD=&&H{|q!}=ACxO^2x@N
zSE@J8XCKlE__ly#po0fc?E|)&;N`Zv07QWuZ-}idri+L@+49>Rb5rc^YYtz|AJp%&
zk#?yf?o{W3dB$x530?%>{ss5G@z1t;6Y?H_)|gj%Q)u^RrI{JZ0R3@$%Nz$1D1<L;
zyjh!%5(~FYiTMLFyUXpCAryo+e(qu8?NB{&Fi^@9yCGmINO8gV&`5dXE|B*0>hrYF
z3hs(3KX-GRoyhWqegCtp-|boZ$pMYdzoXeWab(-oMG!(T1_jx=S1;QI9Egj5LqnPY
z!1=)FxZ!CMTbA0W^g$jl-N02&ZD8kE>m;5_Q?R9xp&fxk($O3LJo&ZcHIPn;HdpS^
z>38DDcA8bF$-Z2IiBO-`wBKZ`KP!TX$BVA$R+Y_%;y||rhOUs^%@4^`z1}{Fpb_Ns
zzx>+kOm|LPFfSVi%80z^7f0DKNs|=;6y!J)INXPE_A(2m@AOh$$D;3XsvqK9yAxv~
zk}TViH>T{t3IZ~u&TYJEiXEgHnA9ypqTRrE5DrP!zUt3gnSRshL2}<HR`l$WDk`T<
zLZ=reDw!sUJj=`+<VQwGYf*lKSM{F{R@qanbsM|FZ1D4pIAaY!c~47OxL4`}-r;s7
zy<F$6e}jh@B&oCSu#^%9sx)AB4o;%lzVuQ>sMD8Dse@~rWAoB^(UeTF%co0a>NGYc
z)IsN>cI@7zWmV+lx;N6NcHdMo!#Xp{Q5Xe8x?J+~3}ZaH>}d1(C+l@CuRk3rhf+=L
z8$)vj$g3+YVX`EJ_)8T02nhrNW+q&OAGo%R7!r1^waxM9?^oCEMo7lGB}W$ZGbtzX
zhewN|l8D1576r6lq^~#xKs90{lw<J4MGy;55wWy&9cUf3-E>^F^RrBUQDr~*>=UkF
z2{+Nmj~#U*I(?u%4|UIYFG%<V8qU`8K6e++27@u@40%n0Bxde8w)g-5r@A$tG|x4A
zfPEb)C#c@|Im_#)#P9EMxj!AH_C|S>-czN+Yq=Q7+4ouU_4HmjeYK>}33HMV3)w6Q
zDEcdN$&3z2x{3$Am$92t(M4}5*W^%sd`T!keo@EJsIqQ;D&vCdKjNhNK*BVVc*!)Z
zii-9`?`Ix+-)(15nQ3o;?Er_lm+Vuz7&{sks-)d3>-oJgFmOVLg>`6;<%=N`kgIgZ
zsc88sJPY*SOzVXSE7^yNRFV*o106hewxZZKa(a~T@l5UZ9H5PSj`Z5oV<``M$qI_a
z8nbe2etYtF)|IBK-iDQ5NLvui2J-2rp&x0(Pk%`0C1x(=1Zd3wr<j$GjwFfcU(hcJ
zUsJ8PIO(^<VFae+l)HFF&YvQGu!*3)yGGaW#(45aqAH)lI*jkVD73kPnBVpqh2ZW6
zarG(;>yMW-;>c?-@O<ypZ?`Ez1gDo|14)0WZq%gaN?=uhc&J77qz>aBj+baYNX~sI
z%A5GTOkdAl|8g+U!Hh);o+wX0T(lm&#wzevO?f511*Rap0p)}B5Cc1+H2^h8)GM-I
z#apqG>d{K)#>)68eP^T!hT%+qfsz*lq!7%Nd_ykz_)`2Y@H<uh3mC1@$U7D|QO+A3
zl$nJs_3i<LDv{Zj9n7%4vm?>Y7aKS*F~S!I@TPckKlO1nq2#)Pd1Y%CwYFaC>Sa}U
zHBs_Sru=MbKH*u~!uGmotJmf8<k`BSP_S>)_3^azGSltDW{YR>mCi_f0!oAjbp}#R
zOf5JZ4xdy{Q?zwes7^m9n65p@=ueS40>*R7%s_Vxu6u*hXtSHds=QG%bIxt$lml-M
z=(TNC+Xy%bt)lKYVNeavO55gO5hAnm-aG@t=sa4}(R$=jy!P-NzO(QBk(0Iv(S;EE
zzLINLVJSmR5!{yRvnALt{#c-^r-|5Z;YxrpwwyjGn7+$%XEXspr{rDZfoAe!op;{Y
zN-@Kq!w{xI@L5~Lo5{cipsL%KOSlgL%!=J`Oa&2Elgt}rs3W)Cd>m3(m}UmdY+t2y
z>XAs-a?VJ<pr;3EDo2RWDVu4n+KMZP&#GWr?Z&TTa-FB*7vWoXTQsz8AHI{GJ~ww{
zN0d|@=EfFCuz<VlV{6$!Ew_d?+)4{lj_jn?DCo6jbzEkclwrDGS}5pbb~sT1<~VkS
z*<h>@xeS1rzq$3buV+UEQf4CI#Qz%Wqz(Ax@o(Edr3YToXj>PxGalZlTe~*Gd#b^y
zrLzXVf;hJZsbHjE7b&@4e22RoBPK*7IA_~s@J?}S;fCJTRg<AsSy$Fr&T)g2IuFD|
zw&2*vJzmW2PyE+Lq2f%+D(^7>wLQD&ugkYDNkng;+wBy+d_+u^>(4pO<w;pqwn^!)
zl<)Nt&8-$wEh&32FVeTNMMR^_Hgk7v?ZdClUj%8WsI!e!F^u^S2w>m3&PY;&B=8@S
zeFqkMV=he2*1uC47G~jhSzao0R1y^l$5%w+F*!ya8%)>pEv$0EDL^0qxGI0>HhNdp
z<rG*LMf)A|zS$WT!kFQEjM)9}zNRUl$r&E@jCo=zndLPbmfR?6`sH&Hn;43Yl81hI
zsHuXZY7{e+Wzd|QG(tf*uc3Sia?sP*J3J1X`)elxQ!y!d$J4js%Y`&45uJpcoG^sL
zRtdZqV2*ZpU$t=}M7ibwq$Y!C7y3;)C^U4bLV3D-u|@t3g;Jm<KMeH{AWlhwJ~h2l
zRkAW@W)CwQsT4pnR-4~0)$iqF!R9C#XF`ytk5N*ZnE7LSV5i$J3z1@Ak+zDNg?)bC
z>hBF=juz&?kj^blO4X{PFcvU?_v1^`hi4v?`lP*m)tI7dy7MFk$N<@^w-E*xSx!y@
zmuGW!7!D&D*xh^;GZ$64JEQK-UY)ih_kSuZ9^Y-Uy&_IVFw7ej`DPfUH9<So$C<}O
zGF7#hq^X_OZY&oO_Z^W{l;ejmLoZzd4F+$pHpW^F;Yeq(k$68D`o0bN&4?)bi_f=z
zrxvM@`KdcV*r&M!fGn;QF3HWe`91#p!Hht7_r(GnP{Comq~Zp$p(DQF?~6E8Ay3up
zzi@Y&Vl9r{y7DJDXY^$IM*PDQqD`NeA(%W$I?EW`kx*!?fHo)grsHm_tGwsZBMdoR
zY$SgO)7=sIoQ!ls2DfOM6iv1FSf`8)sH8CINZINHjG~GkP|egr8MrU1!2?50(k}qV
z&;&1tt^<}+45`81PhRgJkd;<mtur8nO&IMTW($nA%Ipba0rg+DhcMG&kWub5P|&Ca
zt-*-+{6HiKLf2QN^#9KEA}}B$gi!@~7pgMu<JT_WdjQM%2uIbX<J33=W%JKMCmrTF
zCkG%!j79+tkY@oBrZ5izNF;Eb$25bwz1}P`GFg*VIc)^$Jn{hO!a6A1UMON94L$@i
z6F;p-G4~?*5jx}x;AiVoIhl>SpndJE*Ta@LBk<MN`KSXcE#o(y9m0Nc5HkYTgrTWG
z8rxr*)s-5|FPP2Ns9YS}vZ6?m{i~z_O+rtw+yj7fh%?B^+~?lGu2V^n_|Z&<`6EM=
z<I<2y!u_IiurQTlY6ZfWDy4+{YJ3d&QSFHw6F1maP?3&M#?<$afEV?qB3_0iWYC8e
zssu@BM#}y`h!05Jy?c;CI9y2|9>KDhF(!|tAOs6V*U6t>lL6``N>{c1BtPA>w&OKs
zVE}-Ko!8Ge2&-{u166TFD7(b5B_aEO0ad`9Lr|-exs-nx#{z}ff!)rXAH76bRDgF6
zcrN~1D<867EHWTqo)JXO?{LmXx<k_`pvfT1Hj2gHU;I`X%<%dv%7+Dn7W1z;l7Alb
zPZxmFywRpj^h6lBqIVdxIdPLU$h6Hyo&W%Bljbb4+`tPJ-|L4=v|6Oi4sMwJ&JTxJ
z)u9Xu(a#*tHXP(HnM0+?^Iy;lLMB8;3YN~V_=Xo|qw^u}9@z-?(_qYD?NGd+75}+#
zx-%K-E`kND62GjH1nCDdP6tk3G>CX-lsS9(0j&&ph9huz6VDZPeyC&_6Fs!M10a$J
zA@C<M(WCw)Rz29;lF(p231ryVG;*l!1GPO>D-f=p6c%cSALB|v1W~o<nR6G#P@W)Z
zO+eb93J_0K@#U~YcJ`6aBSn!k5orde(vd()`|xNOV#$+us<>fos(lx>Q2}$9&iPY#
zhNeQI=y!X{B#9<*Yu0M-snKm6fCSXo`lgLAYLl2-;kz2Ka$bXCTx_ktUJqVpZXORZ
zu?VxA8myII=M7uxJ%~76MiE+u75)gHg3a&!A*+0IBB&1;#|s^eC=9&K4zgCrIqoE@
zK)(+p9#oO^ojhr$IKaujo5G>5As?THFUlvIJpf4{3|%Zp$eur7w$Yyna8z*E2PqUS
z6NsK|VFa2T(>%5W4K#~Rd3`?TC>qQPB=YJOGxa`hkXP#YU0*@4FMWC`vUEc&|94Uq
z+Es||6S8kv%}0xS-s2Yb$Hry|s%wqM<$frDlHJ~#7oafcRhh1~_DixK7A;bzkDjs#
z+m?aQ?>3tcs+aEuYK;&SU@R5O71v37U17aNiPmOa_I(K+Dv%I^mwDkpKEV+U-*EJ|
zv;c_!l^7d`Q1czW_t>9F%o7R5Xi$@jAQgPGPa%B-@+<=r3PzDh35@%(nG~*3XoiPB
zL&7B8JOy|KH~v_`U47B()>%@5pECB73lH`;X!9fL&i9~Bq!Ft!;45QzK&1CQ>Ke#B
z4{OgU1Y-9w%mb4U|I8eXBi0N%P$PURv(Y)%I}q*Ejh3h$(L~mMpuAq7yp_-_&qEv<
z8(%dpNRvueaqvEX(-$XS_}>pIP!}Qzb^Wkx9`Zw$;r<FEAqc;KOUKOaSnu+ACOL@m
z2oWzN4BrwhRv#AuM6Tnh$^<aSoN1*g>W3srCNlVFXL~+NX8HX@<4f{`=QT3>p}VFa
zEcMdrlclM=wIoCgTP3%gn{;A@8SO;B7PFLIu8KvAW`o2#R}?6eE_2ohVx5&bdmJLm
zg2xYC%RyNv1QFaYWnZIW<b6nwd^Fv$CX)M6S0;R-gb}y`(umg?55Us`<=MC&qlJIT
zh9ICuQBl5eGDLy`r{hBTM#{OVcu<^8AURG_Nt#l8yur%iLPDoW`G^FYJ))~D=ZYf@
zq}ZMK5EAakV3E#y7lSs1jvn`NClE$#g2YbIf>bDF(paB9(S^TRCfI){X`B?z#Nwec
zFe}3Tx!ZXGXmj?s=*Mfh9i$57?Ny82V>>VfIvXU~JM3V(*5Kie$Ebb`Wdi<s-yIJj
z@^yLMT@PVWv*HU}{(|LMdpLj=aE~C+bzp1oPMz+F(6)|PK`~dJ`sDTP@pN!|p}J_S
zWLs49ZtIjv^?9ct6%Q}r$v}~XD%mBxxOJ*W*A5N>pj!}<1|{xvf1XtCZv6Ou*gJtn
zM2rlA$-2;8RB39=@SD#W$<rc~hFnQF!~S_xcq&11S%i{+>hzyIxm<Rmrva&M$vd2e
zOt@L70}XmIFINcAW#Ruo&1?;QGrpGwSq<^6!v;<yl$gY||4BbL*@Hx~(P_JU(S1#v
zQ$QL4-1Qeuj!WvFZ7SmFoM(DXs=i_&MhJYPlw@aUqDKl1(S?b9P3OINBgT=s6h>p_
zz872*g7A)j;Wz5-LmbI$y<QOpJ8bsuJ*F#=cdrFJM(J~Ub-FgDu!e6i+zBhpn(25a
zr0TfppuY_a5m6kQ+(@M`BlJt9c1(}{u?y`4$P(+!5inr!dzXM2^VIl>;UznXXTWHA
z68;&XYv7#(dPpMSt+Uz@-!nmGPkU<GSC=mhVptEr&TKPZ3h#*vFtPZNiAk6HbVJ}D
zK~XN_y<fYlMAvwe93|P!)K)(ro(8j3wNNyl&}66mtq2j1{Ube0EBAnRjV~EV97Mqk
zaQ1PU7LVjF=>jvRH#^0tHy|E4@Wl2w1R52@5VAZG^YBo5{sdRyy$4w_5aZ!HgMS-3
z;$n^J94<vllP5;lBEdIg2B|tV$o^}OY(GHS{;5A+T3fngVkfwOQiN+z6dWJpBiQk$
z;V&L1n0zlFCsIS6v+2=8*U0vc>CZL<nQnaTf;ne%YZ4`s%;x)k=Vt#m(nra5LH+I%
z5K#WV`Cx@adG(3;k*JCHJ{TZuOsVy!|15VjH*7aYk$qm&;672tZ<|)9j;B1<pN9Pd
zMFNCj0(vhXEkg<oQiNnzajlxw4>z1DD#nP!l1#w-Y3u2SuFuaqvZy3$1wR)mxwVTG
ziX1bmSwq!`VqIUTEk3VeYnw{70_}P7Kfj-so<iAm&*YB`YSdag&lFoXmP&WOy4eBG
zCT`6!1r&8RHOtGxeIG4vl#9>biz-ve2-g<N5Ib9+w|ka0`_kkBo=<Pja<$*~T()>P
z57FExN3hbC)hZ2=jFryD!80S&iQre^zm_=5dYASrs{=`}T_mc7){rFh9#uAwRDR)h
zri64WZ_JN*1?N&m*3`T%o_e=O{2Rr3S|NxL*XK$u$HDv;=WnqYw>|Mf=(#UncX1%3
zrQGtIzz$44m!PwTylur6$=LO~kYS0~@X(p~nY!$U(y!2)_Zpfb-L_6U#NsY2@&&d9
z^&^iM@YksosmKv3mNou*3&hYCjg@3BUHa-&<2+eiZF)S4-mDUWp5;&C>V|dz9)%k%
zsqH*Xn~_G-eW#m`TAcHIR_()Lc$uaeXV~VU!R(Dg`={wrTX&gNKAmwDHJkGbWq8&*
zf@On&f<TEyS;C^{p5@*Fje7TyLbJucTX;Sutl=0F`i26{PkT;8z5T}4)Bf9lw23EL
zGD?YbS_MUTuX2HO%IKz;A$TZ&y%Ljiq-L`|<NoX)Ni~C9O|md<M2;b`!_qfpyXF+3
zRzjnGcA$HGHoz;rB8$9FGnk|id4nyS;@tVFQ;9xW=EBpCc2Jc1F|>g4n#ZEYY``$&
zG|0(h_$!N3&4-BhG<a|q0;WY8|6E%EwNnDWZ9hW958>Bk>a{?oaIpn|IqWfGa=!y&
zWvjWLr%D3B3Z?Hpcu<w>U$5e-75$5NczRy0E7U-gN36)lq#j+7alGY$EyKcOz`DkC
z$W<$zDWIFT!Jog6aH@vJQ?)0m77_8j*`?ikReY!(f3?|^hpS+{Y0CC4?YHvpr3E8V
z4!Zfy(Teg6F9S$1%-?kY^EcbERTn7yd2hq(y-u58sjH1^hww8OV<mB+nc}+!5|1~k
z#9Hm6R*niXgFZM^bkp`$vD#*#rp7*@A%xI?!E!r9C<dGk#q>*cg0d&^iV5Th&&)qT
z?|#C8G}e~0$|s&0&9w+e*3fdBZ?vQPVKKUvpQgdwn<QxWd8VR(Qu1#wglc~`=bBza
z4bljt?3euM5F5<s8fO#w?^!F6L!Yw_>Kp12xI3IwvqCle3SY$9d)u=LxUSvJjd+as
z74Oz^<j57wjVwE=`o_!#1}5$8%Yt6X4r@@VaIvRXaqE(WQN+$4K}WxzKBBBBdwy}U
z%bw)l1eHlGqZ_RNvPpX{Vgj0b{s|1<A$X4X6#b-BjrL?WS=lJ0DM9g@i|3lMR60~7
zGJ`NjwN$%QQfs5)#5u|a;~he({+Z=M<sBMH%J~KR+L~pHGzbE54GK*y(5MAhvS#Nx
z+C45y^6Y*w2N={vGY%D8<!zKGW`F7lgK;)j8y%+KUU`jx52)<2sAxM!UC5gNDG#r3
zMi*=49MZ~PgOtu^7vfHNx^knbv&TaPlYP<lKrKqUh9+eOfpSX5-t>w46y_;#$)XTK
z#m{Th@^X(O&~J8(%gb740|fGA<r6b;dbp;2@t`y^Ji!~BN*?dgj<<vKVS9#Sl=}5x
z>hl`%KVC|JfoeZ42XYi<+7BE>d&_!u2yyV$Ww?Wn2*2#;h2Af1JQI0h7!Q@7^CAC2
zwBxD=6<m;65&CTR{}zTB<K2EbG^He3L~Oy`?h(avIWc`8ooJ4J4ok~hC>g3g#sP(E
z0^8}&_Ji3H4-EZt-RL&$c(FK67p$M4Y|_iiDg^Kg{`u%Yf;fK)@)m$fjg+O=C1-#a
z8W~r~Dq?&&Nx6lUm2QhQT*YE@Vf@C-y_EMRG?-hBcFSJePT;EmVjyEQ3}Ol-zi7L|
z17&srvd-7exBGfD=rvuWw1gRo&9RHToS#N><rByvesTI`l!^;~+>T*>F>-!h6L^AW
z8w+qsJFR+@%(BE*szKH0MU*&}t|=J30Pc+aW!5&EPZ14?ClKlH;)(FE=-U<1G~+pk
z^B2;^HxbecG3PS;*<mpL&crpH+QxexF!9X}_xDCX2t|!v7F+*d$cdN~>-O4Kkg<cS
zY3AkM{F6?h()$@M|5qsnqSV`Kqq)1oXDLAFpV={cX|o~h`fIF2#~1a-j}rFXZFLgj
z4*co%-w@|__7?((`zzZQ!_2#M^%;Az3qMj_Pgq2op^&VsjEpaG2>pku(E@ZJvT`-4
z+n=fo{JbifOw%61`_5x?!8h$i)?(Y(x@J(4)yUY2rMA$UiWi+YP@(krcz1_0-7|pt
zT@EJP_*y)|nkS^xoGfoa@PG<Pl>Y;jKx)6qfJA;I7PP-*g5bRO3}6p6Dw_7%iFu^X
z?sR|@{1*G-$VG;L4^JyOPgr!G9Rh#!biUGZiNfH2`l_g_Uk6B^!R$6&btEU4*})xR
z^zKyETPJPyRz%rjBPW!TTmilJTuKnCA1kR8e}TT;ov*B*i{?>}_#y0^Q8b{M9rxh!
zNV5@)c*#B=i+$J4_wRocJ*Q;L`O1eAmuI~}AQEu}0F7#RHe-5FEfz_1ZdGRUbCpE7
zyG`9~mMkIGDz>Ass{!-F7$R~5-WK%PV=Z|MqikaTCo_zZqK*d4brEF4<>A;5`98XL
zf0OpM+!d#~myQS`9V2`i7<ou^m`-rn5c#!~Q=)X-%k`93dJJq-rY{m^cRKn)Sl9E-
z*xW}SOR4+;4z9YZYBG*~sG4Ag^Du6C9?;UHFS!o>A$1On&}9>2vA<jl^~KNZ9GrBI
zR94%T4W~Hhw?2GQ!sK5V5~DbjWFVaqe=Td^Je!1n^YPQJ5`fPr<ASE<tUXeBocjQ}
zn6}3WfNDg}Q$@MoVN6_1f?V&H;&7yd39Q9IUG~3o9#>3(!-!s~GcVxMBEAlgNGX>_
z#ymWc%w|b1Bdfw_v;(SUEJm_erLj5JC!Q?>(Mip`PJ;ig+g$J3mVTbwK}P^}e{pmX
zZmf}nVB(iQHuKVe4mz>*njMl@|J?maWtw<iEGx99+C!)jdZmGPKx2JjmJoiub}+_8
z@_JqQ?^8uSF*b4VnhgK-=s+%%j>s8G2<;Q;y_Sh*oX7J;qex}objFz=V>=uW<5cOa
zYM(J6Bc|-Q9*eJ1Fj*&-a|xevf4H*fq-HxN8f^CTe&I<t2>2Yzhdj(mp^6AfK>_ut
z7#J#xp$^PF(eUnhxGaT`;ighR4qs#Mi2GV5CuI-x3PG)ePCWdV^2oRdmzczdf=cji
z#KjME2fVi65DYStIFHyPcmx|SSKCz*B5+LTZik)E_duIXup&*;zC*6{fA2AY%JD15
zTE<Z3^yzcB+F~5~1$UFJ9+>I?*iZ4NUfsO<t7KPG&huDhNSkyPtHh);XJ%FzRUNE+
z?}EoO#CR5Zm-ms}Pabo$py%*S#8r&zXo&q0p1V^A0e8~b03)`C>eqp0?;B$(h4!{&
z7gl)`lgESW5z4Y4>lbyQf52fi#8`;)q#fGERmkWmCQ+a98T2g;2zmHH#20c3p#U}s
z>nh=>9wKDx;ZxL=$%n51TsE)(ozU5itO6SBZ6Rm9#T*R5!=ddsAmRj2n8-8Al|6&(
zH$JaJ2(RSSYhHN2-klmw_T8I>OG&UuVy2Zba6~w`EH4vtYjG;ze;$q46~*ZbiTOai
zo{+QZOt-&Wa{jfJ&YsBQ(+~bShl*MRY!inUqCV%2<ZL`fFobGkhN};DtUh2$M^DNR
zQKsTdLo%Vt@|S8b1NC}B{^XRGOP-_D+>qd+j7l|p6zB(O#0!^ZlqSheENOs2k@t^u
zwyN2df~lzfEimjte}|BZCg<;c<(Hy<x|`APJ>ypvj)_>XBo8@$b;E9FZ<{5gN946X
z_Ln?KEsPgvNacH9bg+?6EO;p~H1F7Xu3cc>gygqIaNSf3%){wxV=j;ZBECwfWJ*;)
z>%-bjPxT5;U2^gA^ig(j*fPvjt(2=;10km@AarHDTTd9re_HGtLWa>qDqktt%ISqo
z;ryy2yqcdb4OOVki+5wqm>NLEkFw;Jy(Yt4>NagparXDbkpJdMEIblB3<}YqI#V9_
zSjk0-D4AQA;EPBjnss*-Vhu+YbltlAg)-6M69a}?x!qQJ5*pFi47bj~RZoH|@;Y|I
zDMd3^&K8EMe@)jOD`M2~dB1d~inH}wdlo2{IQ3`1K6B8*RQXE}?|Br-!FFVnzFN$*
zl|QFqOLY&1W1R&oTPJj0iP4gkGFnLn*m9CV7-$U4`p?A-MlkI5C0ol#A!QD~0p~{3
zRjPqeN|18-h#QTIdEFY1EGMRfc=|nUGy+BvRF$9Zf4rca$VzPfZIz)p1V9RCW(g^6
z20v{mTa#WP4?yx>T67kA(jNc}5uW-Je8b(+Rrd`QPTgzVOpdJYJI{JNH5vM9Y|l0$
z3yNRJr~o`yj%mRyF_TT6o-Rv(%#!Kh=nX=%$f0)pg^V!ALB=P4v_SJ7)+Xkx(bT!n
zXnC=0DKJb*+Re5YWJ5#4?p$-aTy)o-8cK{QTb5E&!nL=YYi~Xt{uc+Gl_`^<izfjx
zlMg>De~lU0a@@G_-Cr@~q{^Hv5h4ii@>}d(r<`)uiKWyg<@EzaVl<36<SdWX>LuTv
zJ^&uG)Y@fP1R4!=qi?k2E`Wb>mj$~-DUs=PSDao11nus3Joxn27t-SSfaotU-`u{q
zeiubM8Hg;%<nH#cJnFXGefHiS^YdW3y|0w=fAs6UuXW_TZJVD1sqe?GYWC8*$5rk9
z<>vc$dq0d)8GGse%kAG@{BS#wj>7O8c|^>wGa08^NTr#{-kkF;A6jHHRbJKOS9^^q
zOyB3-6HkYhmj_eV4Ea#?XA3*#1CO5eVdAyptIqJetomZ?`>MI;J-GvSrT~ieY@mJw
ze@Va|>2=eQ4UclhL6Ox)?ENT<y!Qu`5Zu_8O2~-s0kl(~4d{{bYLnyiSNvrdR1N$E
z6zL6DI7zM8RTT2QacA{Fo9ZW?)5Q@EyI_bk9_)b)aslFvm*NeBNTeX~fVsLpwkLB9
zKYdqRTl|$el2oWbI`pdP2a}hU)58{le<%<-m7C`u+IEu$T9}AcV&x@yYu>YATBY#>
zE(KQ{OjDZjia~i(vW*@<1bJ2SgyaINs2E0=PhvF!QvU?kIq_m?2(=ojwh^R1sliM&
zFqMcTv(|Wv<e$z}k=LYwH1U?kK?4NlY+^CnN8;7(!1HaPNfn8B){4mca!XKQe<Eb4
z9TwYM4`R?kV8!4l#$M5$PHn@~tFmfO41UB5kZ6(hmVxJSu;kJeS7|Cj<;e9<r@MUw
zR#sO9l8nI?n}>c|p>ZU#NUa=zh{d2H^3XUyQ4pYQ%&UG&Dsd(>SjE?b5{pz{3WZOu
z8m5%<bP@@Smp&dl=>hya_Q!2mf51&<yQY}3#f%av&K%Z?hy>oEU^p74_%lQ}6d*4h
z^6vB!)+Je<uYypdO0FHEW!rBz-CB!CPxb?nI=ud_FwM~AwcnZhsvo+i@3t70N{S?m
z-OelLX3o#SOGr-uMA2}lgo()u<mSjIRZ~{KRwcStUT^r;BnOC?>|DOoe^RJ0S-Y2w
zcd+H5Y4QBWe(lbOwyt?$Q%N{Z76$vQg=+BaXu7pKos|RR@?seIA`n?QtQI*&1_n8a
zO!$1+UN9-Wi-8T55=%)UbfkBX@}i8X#m~e*Fr9SghoBGe9Kw8u^1{p)rh#XE%TMRp
zfQG^hOnWnqBnp%{nZcjVe=n!_Th!N<$?KP!cAx_h$;pi{-GnJ<v$4c$b21Ia&w&Bk
zaV&{N6irU@jTRUv5v19|0`Yz>U6QTnAQfr24ktxB);6y9W?(gp=apWRGeV}CtxW~P
z#zggCbLS?5DF`*2eQRZj37F{XEm8O~h((g5YXko?R0v_@6(xVSf7G+89pq|T-SF4%
z`TM^qt-^nbj|3K*1_tM)z~VZc9ZAs&qk4&h!0QJ}akXLify_@~@SN+ydq%ZIAuRGK
zf!AP~Ljd?Y1Y1het8)OwJTheLO^3-Vgq(6W+I`i)SdOiJJfB%J-C#-=Ic#2@je$<r
zP<qidaNtglRK&p@e}NMkt@7~k*xCVQMvk!z$@$Y)=yyvbk`Mz1yZhX=_g#KEL6oqy
z0YVEKv%9u-)HrWkD%eHH%2@N_0s=!(Nirm}z6?`yxa>{d%>fx=HPo!u43Y>d8KvV8
z%>d{^#8-)pFt7kJiq)d*-(%jyD4!s^hWLP?r3IrN_#`%Af85^fec1h9V4eXk|87_y
zUO9sTCR@e&OnWs|PeaeMxlm>STDA-W97lkNw4>P3&h#SpBVt8$28;j=+|=$T=1VBl
zW1w<ln!dWL?NVtD`B)Ejf9|R|RxXw6RcUQ-UE1f10@JdNIpK&As(Cf=TGMtXTQtJ#
z=<0uFY@uATf3UWrngP|%+_$3*an<k##VL8S4yneP(kITzVsr@Jou3SY`gZIJJ1#i-
zl@_Tp*5~?)ix)bg<;6Q%a)%tjPD>tJF%J|I>5T#jgRu-hbUI9_2(Z&05^B$<ayq&2
zZRuWs%k44%Tje@V2bq25;fTDHk`y=`C2J~;!|XZEe_#(Cow%a`-~s~;$qjH=R$y9c
zS>sD@3KXyovF=>eTp;}3JlgZj45*}n2LoobB`pp@FsQk#da&TG8VnE59TZr#BYtms
zKEsJ&QUs2jW{LADt`L0`LxI+xNM|m9mDhc{6_xm@Y0kC?a|bU=x+!2CI(lLNniaP#
z6}4B?f8#Ki&P6d60F_a*179EVzMfxf;Kk3I`OT1b1M5b+<FpQKKtWiDcTEB^`_0!@
zBGS3m!D`tD2ZL9T59LbJvnKoPGAR^cI=zVwc~RBX;PQc1^ZN=XHg@BX+y}nEBq;G6
zTYH#ABG4CQel_%_J_x=O>qv$11u29ql8eQ0f58!kB-_XZM*z&h5fM2!!f0}5oJ_%S
zNjjQICrmo>CZ<M?XfP~IUv!l{ZYxUSV@xL*WmWiawz3T<1Yl9E6SxnXB|uJ`jiD01
zx@<XxDi%Q!?i4(HvN-ul+sR@33-pcF)8(P-CK+;+@#pi~S@bnqVuDW+@XX6*0HRyN
ze}qxLX#3bpa_k^8ftl6Pmn#<zE#pfAIp_D*3HiCWl#7Jdu!`ZiAtji2{1v%4Y=42i
zA(zWT`8jS)SPC7k{qx6mpf_&fI&X36%nS-JyJWLJjL=zC0u~G2+A;RL2p;59l0a}v
zQJ4b>oo*P;New}Vu_@4Z^T|`-0cFo$f4o>>PqoJo{(R0E?*_7L(5sF9opB)_ft>S`
z1k4&W2oZzp2(p8zM(oiNUSkzXp8w8&Q#E<_<bPPbDIr559`cz2u=eX5?t$)hbTG(x
zh(gFdj_S&7I}_;l{<a7YwdpYCXUX$Spf$>b99zrOv#)PA8F;lZh69>(mGaYxe>94V
zTxG)w7e00eZ%yYS3@4EJO0ku2=DU-kv<y9X90maoEroDP9D9C*IC1#$;{Lob5g`wb
ztNtrOtc6l#0Mn66pfVqfB}x$-z9qbc@AJWKTNR-QU=QB9+!>PlRG_Te8mN|UE7vuW
z3%yTxLkJ=8YZ#_-ojqbztj`7Xe^j14SC`wr3jB0r8Dw)gixpZqp3V%mYRI5Yq=doi
zx!qKqAUt9I)sk8l2z%rs0c$=IzysSD>i~+@hZR}7_u>Nf<kdN33-(dAA@}veZYg%S
zfEk{BQ(aJ|w5aEv4DZVAk&Dt_LE>_08k-Wmx#&vFO{}R#a)FCl2|JZ4f9zwy(-?xQ
zjklkPutfvCf0-*ADY7UExr@X*1LscgEcD?Xhw6_EAWTKN3LXDyN{$WFYqVKh=vfIl
zq2A|RIW-EoXq;L=wxww0w^4Nom(qTj@>B-Du)&!{n4ms?33esGLC->E>F$xRPT)0I
z(bc<~7yslW7Vc6=<B+$gf62r_UdmAD%o+w1{}IHkdL(aFDzt_XQo|TN%l_?Rl{$hM
z|Dgq@)MZv7wRhoSBw!_%#3SHz?lt}R{sSYe7}Vf_;oQZJB-&e~yf>CO_KPQeUS6>r
zo%0~V$>hxf)%4YUWB+aju!9@et6_tn;k*emSCiv1=foI7O@bvte;{;h<<+!}Z%$`$
z+l*`h%GvMVfBNC=?Z;31H1__(AWVn+d~9s2d%4jU^)o1Jz{FD#Mail!x{?Y+f6%(G
zL>kz(!AFcFI`w|4&`5!kM|#;nsC&X0#RQGzB{wf|Odfc#hXIhPx}g{cJDu9zIH7tJ
zzW?}m^Zwr!-FB2gS~W?cu?I`w1!2rLPfQhRkQ@k8mL@Km(sZ_;DFT_UW&8KM_;`a_
zh01%<DvY@ggkl}LsvUctkR`(E5&WAWIp;6#6KLglva9AdR*8Z4T2q+G$Nmq^ztvQe
zp^Fq3HXtw{Z(?c+JUj|7Ol59obZ8(qHZ>rZ@$&*He^pD5(=ZUe_gCbGv)Y(Ab`qyI
zwy+4aT-b5~4&K&jE%G9d!t(2xvD0jWvI3z>_4qNKZ@&4)VO|J7=4GLma!xZLy<NEq
z?P`1QobmDPijC(2I2c@<yxFc^-o~-VLYjpc^S1frRolJynQV@#>2>P|oO2@9ejr3l
zHg)wSe`Mk?w5IYIIpD4!ukK&p`au*+mXOT<x_!TTvz<c6QS^@(@#J4XvQWUT@DeE~
z<H8}`9!=*5smw?|RJ-2P70j}boL8HnJL<h#gS|+SzIHqPQ6pT4lFXt=No5oRDtrH6
z>SldqN_Eh|ekhyZSl8dKM#nikE@;Bo+3^8me?7Xud!4JH=z+9rAF3h9kE7Y){t++o
zfJaHW^a92yi=BI^RRt-;JOrSscb3WB_=vvs;3l2I*$Mx&TT#_`98o)S=uCB3N;e8Q
z6(O6YYx8u@3wg>IOnG*IgyJ+Kb?f4sj9Q8!1eKGE>h}5CF<Li^5keaAsRF9nFI^c3
ze<rAi#K;=ExVvfVL#xW?ZvPX10xCAha0-PnMS&KF`UNASu&jo@E>&-Kswf`a5}GJ1
zv{6#%vn#Y}-O^a1akiUUN1;TiA260A<X!Ika-h!&VZ=5|sjEvskw!6Twd$<C!JZ_5
zlcv=<b}QOe-Y_D*+0k*|lue;a?OMU2e|gclouS(6ws=IL*!j7kRAE55y&t7;l@v&s
zjGhQW;NeWW-OvK!L^xt_v|tvBm?Y3L*|`>$z5uw&&6%miMq@FRVv=mBY%YT>jpPU~
zjhIy=hQ<fLSy*E`PR{_&p4hQ_OYGRvFd0#i%uA!c59Z{@2~h>Qq(D-T3Qp>Le<|4%
zJTv|u4@(59$g&H?N|6vv4|K8B5-PJv-rYl>fA;IEPMx%k&@G2x3C*G@gcTXEaSwIB
z0j-kF-SwDRyV#37;WUIo&e_4h4;sX+0~_B|rZ=FbUzXTskYo{shP*_A-=NKhPn$dU
z!NK>yuH9QyXz6}O&!3*(?G@026$)i;WOH<KWnpa!Wo~3|VrmLEF*27SmjfmaI5##5
zFHB`_XLM*FGBuY0gaayn&01S?+cp+{*RR0awhw`DaK}!knWR~FGn1W7lXP#{JkSzt
zYeS1FMaA*I-|v7_BTIH<UEKJ=1_&JjAAp1JT);piln7)*N+`S_A5aFN@fWlb+B=ja
zbmGzqlOV30uq>yeaLS-e!f6@=qlI%;1Y?Br=+AiJl}8zb$2-A)D&Yg#Eny6PhOEQ;
zPKyvwS|<{>S>R9+9oisBs|X1z$T(DN6yy}fb`DtiWt#+r#4<`yG7&=wypx2+@S1pB
z2mItQC?=z|Q-gr6v^Crf<eUda%tr@}7LQ5C$dx3F;=%EzA%l4bC5%qoj~2#e)cDCO
zRJ;)e;|#cr0Rv-yt|k%x!ixsjAw*#n(1xIe)e7^BB&=~MPu@CgLI@Ts>v<?FaY$&1
z5Khhx(2XOq=$I>*t45!WB8CDGr#0pf0xCQiY?3p)(m;Y80gC8^3p|+w;pn+z-W&=8
z9>o)HGbZf~LrzwB>+s|Rz$jiJRCqZ7&3oY2fa3$pVxfJ1-oONz2#p94Tad66fmKRH
z9ut3>HzF$$mNW9~4IoGKj$JmWc-{<dAzs#qN``Gw3H(49SwxC)pgn%oP)2MRD!>$>
zg%O*D-_c?Xzl}eKSx1#b<OPmcyqGM@D3M5UXVAAiw*b8(HPBctC?Nkrs9=R6jzIEI
z6bvj9>qgXnd{!_|fFPwXBORf5iVT!2TCPDUB0(#G88ytCl!4NH_t*OBzsjolMZKuT
zT)VvH|JCHQDVkipEIyW87W}U%i*Z|=R$a@dVp1(1+M55@?M2z-4zK5Jc{zXj{oscm
z#PF>c{#?JS#qfn#jyNi&T)gb+vv$$sZl1k;aq_2sdG2b_&KB*{@5PTl4t9QNV^kJl
zfpPh%tm@fiIc@pz<k>ItZiKH1+%<=B{X3dwk&$8gxhUst#xt3=WmAmW2|B&*8h&5P
zH-CBk>gM#0(ccEvzfaHW$@H8h{#iF4y8+i5H{N<aIjtu3c~i_TuDe%mv~0-#R8L3c
zEHBxA%jvlM+`Y5Wy7Au0Vv5<+-7KbA1AnTD`FyRT?P41}|D$LoOXXbYX|ow`4u<cp
zXQddvF3!ur5U5*h|2!K4CEg5%Z_0VSXh!8c^LB3fTREN-&+E_Py+VV}6s125&_#oH
zAs0HiXVYnouHI)$f|hJax-xVn=%jm&{qs_PF7?kUmmdaz{{?F9cQAarIBoOutI71^
zVEDXl#%0rCQXd%js1@%uMd`pJo{Ws3I!jtIpK2>ZfYdXwzIeYZCZmt}9JfW2_iw(q
zyaXfUMcf;Ru_P^9Vi%=`Epy7s1cHTSmK5TxP=1~FipnSSz~NPp!N68oCkf;U3k4{D
zUMhY2D!eGqCewcOp3t~@HEAz8syORf4?~p=Bgw?%t-UmC4Xu_jd`nO!DCuE~mdNr_
zeFfFKj;QL>|Kas)HtKO%<)*XaY#uKY^f<x^gl8bxU2-}}*zV&4x*Y*|ElI%%GF~S3
zJ5`bzr`XycqcI=WCL+F|`t{Ar?%#KR7i~NH^Kf`|btQk}GgeLJGg&w1!yU0Ci=pB1
zr64Ul4#P(ou3VHR(k?(o_2p$feUf2J%XT<xYF@D6s5)Its__k2FT{KHs+f$1|N8fT
zM0UHCm@ca7!!9x>;MWZ31XS0N-tYv@W$3HyQ#-$WfZyE_BHkXpZtBt767vUtSHCzB
z!*}K9cAXj5N!<Gl68Cmr5_e0I?#bErB<@vTF59Uq!?IoX&waZ$2a`H;1(w>A!l`6c
zFjB)&^_pbJO0an-Ue(3;Xl!ah+8*Aeb581>A-tCq)2(A;L(V4Wi)Ll~FMcB^EgSV~
z?9d9a9nKh_EW|JdxY(n2&PZi{9t%DTYY0!=X$K?Ntsj^rru5KuFjFbG+$4@lWy(})
zBs`FZx4@Pe3KSY8<q#3<nP7k)k<M6fX~H?yI9T2>-8&qx_*j%i2dT*;qSw;($BvJ_
zHQ(5WF`xs3XkRD776VjNpauU8L6HF?3S*U2k#X6~j|h9&=iE)x*{pegx83w@li6na
zV3;UuSU$9K(k32c21D8~gCXo|219So;?m5SzU*U}(8n-QA8h8ll5DS?#%T<$r%947
z+FQ5qO*yNIQNNALlQ+4XRV9b?1qYE`s^B;@iipC&6(pcbDrFDVW>@f=BGa%VoaJ1?
zv#@_Ld>!7JZ;%PBsW0<?5zPv7;9-QbY!Gy^!6D-0t&u))QkUtU?#r%+Mm0`494bQm
z$r)u<CSo_{jv!()FEcLNKAz}PGt0I5R5o+$;M0RuiV&P~_Lu!Tb~nkf@8TW;A2U{n
z+gWW784s(@iSKQ497Dka*fBs@VMb0_tG>?3S<}}I;lUonn29!j7&E558MDv&#GV<`
zl0p0S)H7)81Bzr14-jzDI0KF)_MCJl#E6=&Jrvl}JraM$BrW+`z!^{#**?(#n$qSm
z@H>1#gIG=5jyN2AK^^o1BD-sq5F^0bV{)*jTO}q2WAC4Kn13bQFXrR3ol_9tDx=}!
z8NP$b84<DuDyRQ{07&=rm0<?qf)H#BnJ(NQ19#BgzJouPZQJi(&z@DmsrMEBJe=MY
zb`qF4C#wvgal}W*fWz#X)OM!cLx!V81vcF#r(Kth+LO)qChD+3)XD8j)UnU-r1TX6
zzT=celAeS|VO8f{c&0b<yPb$?@^O;S!l-&u6^rTUV)vte>3x*g4!AcFeiq*+;tcqs
z0?7*C_Xv0n-tnm1`i}E;>wY`V_q~jTuY0?a`cn60IMfu|fJoG06F6sQx**2GM^{Gw
z0l6NmfpqY@v{IaD0SY5+3=cgr`yU22i*K7ac(tIq{OJIO_jg<)tOOy&7Z>9|D?mmn
z{&2$bl}49;FmVVV>CT)}+tgLn!??OAn;VYwyeyj0MVT%6S$)*ZlhL402c#5WBfKyM
zE9m0`!o(5g?;f_<gMDONu<#AS{+|76E@aiqU&)2saPwFF|9yFdHZFW4-S5IT(k8FO
zo<BNE!XJBdWzRSLOb_4{a#|+Ou02WRy7)e^;mMbOc1QE@x%%YElYDvBeI+t)udDLV
zSX|>cCSenlUG?_|iZA%?1$<NC+q&u0{mY%-*`z9ukPwbGN8;KC8Tqp)IOE=j$Ar>?
z+c=EoWCl@ZU?{-DjQU$9VEKCA;uym%jMfPaK68<>Ph!;ZQp3zXwEbdoU4|D;J97_)
zx<NUAcX8ATjol+Dfd}+Y{vf*2v`JTKU%H~6uJqwolkD2$TWN%crn}lQ2BD$d)0P#V
zx-)}VafZV(KHk~p{F6tpkiWd(&m#E~1M43UCM%-e9)hjQunTFG-YTcH&ENR!;)SnW
zxvy$3j7rpcQ^Sv&YKwZ~jy`I;lOm)0{{zPZsBnFgp^Foj7;OO!lU#fV128Z*lfefl
z0mYL)voe2eoB)A<oo2DRySmP=ni4lL{1Z1>e3L2_W!m0st5>n7whuQn`0<ag1oMT!
z7|uAqzkBt&_r~0aILhKo+}!QwOWo~mJ_c_O`LTEHCR9oV=Jh7j+5|s$Mg2geH$VO1
z{U(%YW>g^J&8NE`UcI{;H#AbdP%`9vCRz%jrICLWMzd&%)saw|L^GSvBytocH6#p(
zKr?lubRuykoLZU4>Xau&f~J1hgd%A2jR<z*8ae%R=dO1ZEw<DUEGDu@NLJ9@!QuJE
zaz-|vVc-lJ=6U{o1MD_v)|M7Fia|)`EIL}aZ1SDk;W!R{iA|i>J9@Egs$)^Q-7T)D
zf?|J9<l1dr*X8XQm<5sUH?ZZI#_rdRNrJpQ<-I>N(t0{X4APZlgUnCkyAMToq|v@<
ztJf@dGM78lNu+HGiZPLj6B6Hx+U@qQQT~v%19mn6uK~81pFOsb73rj=W^E^M2Vup)
z<PW%_$55y&vfwo&5S#t4HF|FvbWP=GR8)V*(p9d;1NWegrtatk%HBD5>CVz*a87w+
zG8-A4e8r^)?r_Gw5^<M{dRc#RTNH<+F_EOf$G44_^;i7k>cZ7qe-azK-&h@-YCoy_
z1P-CoBshX&=MT*BJUDd<O490ury01va+=FUM>~0$rVxdQw7j5Dkubz~;NW=dD7yg^
zlV7zJ0Xma)wIF|a0+n`{HF|n;>fCxnh!|4Y7!v6e5`%EpBLUMzD*rcuU@h#PEd%o}
zO^-g2rJ&Hf$C0H3fFw9-Qy1I3Bzm1!{G!>@Z%!|Uct#Q?Dx~G~*!3+W53sjU8RV$B
z$9ijmi{@o{ra7E#{Ofj`cP`q5nM#8<<Rp;9Gp*T21j%bZZVmcp`M@;ZMo7xbt|8Jr
zrmcYAQxXf@7Ohu+8Gng|#<Yqr^N#1zkGJp{c&ZIdp=FwqSkZ<>y)92vGG?<L{UL^_
zPdK${cZ2U6i{9)RpAN+qc@Kl+oud~;->um?Uc^XuuI`&M^e2;lwjY1zIKVj^%^*eN
zlnR+oT~G8;$9`Gj=uSnS-<QlklpE%OBEllAN3&8%B*Yk^udkgm)DU4Rx$upmhOJx1
zCjDyUXh=+;OJ2XqA6<CN`@^+;QmDyeaw%$B`3V9C>L{L^p%Hph=?2&IyJJXU(wGyA
zZWPVGyZ8Cd5pmy~YS1b_Ild54l89yGdaME2WNEe#>;}FFCDxmUmTbz7Sb2v-?!&NX
zPAG7kkdsKaAb$xX!n#ylkqGOCUx?yj=UQKL!Q;|c(c!cJ$ME_1IA})8n34~?B2{)o
zeByY+7e3l@$}hZ1LtNeINRi*PJyBc%rfG?b)v}qkx{L^n1Kz}E3HbFXWU2&B1z5`;
zG+rK&0-L<U#6Q=?=UcM+pY!c4z4&`k?`Xr0&>9kbgnyvp0Jx(gm0X^@sZy4=<r*|f
zoN^4$T?|UpkyY6)<tdM~-!r;`m?b0<X$HhB2{9u8Q33>jKO+D^y!?KXO#tKtu$lS>
z9n0X@HsqQ+*Ab;Zw3K*A^RY*|733^_?^6gdIvP|B<|7;-r^ijPm<k2Zn?VT#^Hz(t
zN=%fE2q|<9Ti5ce8W?ZaA+fZ$*wP^guzz7y8_&!7?F33zwg3aoa8K{L{!8MMkGLC1
zL;<iT?Fd;I;{0dFl)iev57mpd7^4}9kN{S;1$zncVuK}7GSwA=KDc!ESR6Y#Ca%Dp
ztwitP^ra;1qvg_;oQI4WP?Uialk&Jae-OeaK9ph1Y)!FSq^H43;q1I1W^vzw+Fi$B
z8#ZShX>?r997mq!7$+l=qME_!hJkZCEQ+|xGd}CJ$O*^VFvH2595OS2xr~~buXrJ1
z?nEt0`<f$2Iqv~HPE82A8m=SU5FmkIFA7rn&8aU&%7lPTuwyV#HjFacj->X+e*gx;
zd)(c4xR;H4?%X~<mHkjE1-H_ZrIxwN-?orH;GjPYxw7ySJE2!9PvEB!mbL_&L@F*g
zZ}KAvU@Rx%^K%gW$%~$1z3gbP1qbixR$`nzXavUvImIAbjdv^qJK?g+YKgZC=x@?!
zzo22v4hP>B2(PwC1a-kuq{!{5e`36HOSczQ@o?azfzzvefaKTag?l98zI+z~d~_EA
z(+9iwhi5hbS~20K=F#hIw{|eTd|7i?9clS8f6Zq8Ds2pVgRXN_XhOZ2Op+mgd2`F)
zPkVYx2ZF(99~gT}+riS7EDcNSNJXxzzwLR}XoUTlcrfW)Sr`^@Xe)r>AfTpO&Yx)n
z8DQbk435>LWXutx*Rhh3_EeN5u`aOkc$3MxD1V1zftQep?D7r=yZtezz&VUSmBQcr
zDk8!;@mRg!yekU}D9~nHcZ&-GhVVbNtNZnJK^t;jT(yRH?CHEdp^{ZH*dGew+$>8h
zCQV9_m;?{5c5SgG+MaRVs!IdxF?KrD5skU();f-GG;`||if%*uoqhLwqK9fo$X=lK
zzLRjfMgo8PleoKofAHn-^sUb?upjDo9c0Ftd4WU2*#tz?BA}iQ5IEeftz0ZpOFaQy
zJ;JCR|57_GsLV4~o84@QVDwvV5V6Cc>$h2&ytv%NUSUk0$|`D9GLMhF*dIMq7{Xix
zpC-k?5si^_UYdCoelI?Pq)_W7HO}uuzG>b3N|kE%nJ-Gdf1$#99&Sk5t(y(Qx?#Ps
zj_)Ugg-lHCI9WkctE0rqg^9k&hff}1gBJtgD8QPHrHEpomJ#sgcq~`zyONQ9iRWlF
z<9jN=)}e~|QWgi7-~(ybqC;RHtMLNxyO~)+5&@R@ZZ!ia@N}C@9g<tKqrmGkabd@m
z)!^)Ax`*_4e@SB}i;y6TM4B!2NP&Q9-RgNM+R^td_5>d@(C-j2Zy!c9*F~!eNpvKB
zlR9){#fZD^XR=NC-}*joEo+EKB#Y1hBYw3C{+_g>W9W~UJwP#C!eL=7cZ=J-H3^`%
zpXEI-!u_e<mF|ip5X?sD%j2S}`Qu_Q+Os>>wE4TYe^{`Pf}b9d($xN@D)x7A^yXRH
z$AX_8W(RWgwFcXtIFgB2`UN7d&%T2;01@6oyiPD|`6URHsnkpF15(huU0jr>3CA1^
zTK8}&u|l<YMw<cw@0MImtuJs;@*eb*QnQD@xbf^`@&qbzJbu!m^D2y1v4S&vHb1qk
zn^%XTf65;mr)^`%M=))tzddcQ-bpPY9&n<XzF+^pGB@N%%sUH3{THeGYnfX`@@1)8
z&lx#)TmGUxBB80LS-U*bQ9Si`gFV)Rbop(N@zj+}Et4pbFU{2EVom-+6#Jx{dJl((
z=^k)s?3s&g%@=0UrctIYE<dNdt%bSF+hLN$JHy==yrrfOarD%~BfUHM8#aL-lu9De
z9WV^|3k*H@dohtrZ^ypQ@6C(M{sV<piT~2U-^l+Bf`kVklc9?f0W+6T{Q(mLGch=q
zF}?yRlTg1H9d@1UZls(XAE+Tl!xD#_kTaH*+K=CUfsZj0DNd7xzajzYlc>Kjf9IiY
z?-=ye^*67tLX#Cq9B6&@?&cpazP%X_OpJLZWr+C%X<Fwh-=w)!I<`z*+ns=nJPum7
zbyuMdhN0~1=8=I-S5`Q(LD^oJJP>fVW8i7;4h*T=5yF7&x$hl)bK;fyP~N#Of%~Wk
zx|Wd+-5{&O<8X3^;U&z9G^mB9e}}qhP$0lZKIbFOGnJ<q@ICUtSPO1Lj~41!>4b5G
zqf`ea><t4GY`ep;Zk&LBiL`Cpz!PE%P?#+MEZKq;VoP0t^z+~b<+s0r&jw!Ho!jlH
zCT`(d_n{t6ex>UfI6NK>?$kf>?4dsGg_U&9N+dk!iHVR!w#Imxs#K5Cf4My)sj*NM
z8@X~A^bS}*xV9qR0pr{P=YsW!Om=6Ul)dA@Lyzp8M0pKtUN`dbfZT8U`Un^&*`#bM
z9^AJb?)QM?ZbBh&!PCRO1hOnC8J+w&o{96SgX2KNnaP5$&w>Ou(t@_wWJak4gacAh
z-|gj!5OfRHl?Sp}&6nqTe+Sa5M%aqXO`fRKSTDw7-`(})A?%K;BG;;j3y<5EKwj?&
zEmyY>W1FcYjThP}s`xvHB$+aq@rNjqr71wiiyXF#6?y<#di(kctj8;#4&F@!0G&x<
z#5}-PjB0WMfh={Zn4g_lWsAfk3m*Be&w58!f8yyq%GW&(vIx@*f2KSGt>3!YFcej^
z!F&3u=d0=lK@#YIT#(`ztJ2&oMD`ijG3!>?q13~XfHjw3w2E}R)V!~bNAPzmR|F!B
zCI#q@4(`>hZEGzc#vYN3n9TWv&Okf|Tq&s`>>=!29#_OFw#ni?*7d+f3P*y7J~Pe8
zMXlVMNtHI{;@(#Fe~gVvY<jULn=ksx(fg+nS^{3``?_N8bWrhvNd5s=J9HG4+*(?Y
zv=>q@`@8c&T<M@VDqcHx8UJ*Vs3gfYNs`0wQ!&tEhcooGIC!xs8;wZ(-Ah)!BRF<e
zPLp3!WwK1!IDIBn9{UNZE;pT7xh_(bK*(k**Pm|Xhw^?^e@)^De9>RD?muUVT4m`{
zBfjY{4Kl$mkeu9Lz{SZ=lP|~V%^qUG-+0V+W-^Tt05tC0^Ni>v7ErB>4X#fmY9mLj
z`Ilx)zDxjwyhIDd90nsL!p8W$<{a`!naK)gg1t;a7;nKU9bgK`L55C7$mIL0Bn`^C
zDQ_FhDXfkHe-;EFRBl(En-fpaPlDk0B^x5Mj*(3EJ;|<|?GVK8<1d#E74&-Nw<RlI
z<5p)7;5@TW<sU{B#TX1B=QF9LG=#hX3ZyW_!ikR>m&QSPKJB}H;K{aZdC;+Z$b<HE
z<rvCWg`-hCl$5o8+0{J{=O<JSlf1U}sTm<Y^5{^Gf1VCL5}&=TcO;d|JPe65IbI_q
z6fFh^nC6$Ro>2z=<$K6E5dp6a+1JdA;=*}wjEY&de1cry+VIH6=nkl>Mdmdb4_Lo8
z4R$@olrJb<3ptWadVQg=^38(N?kK{-OrCy|S;SeKnPw1i#@mN``F%x65|vF^6Ql$O
zKH--re~AW?$w%?P6p^w(l}!p|^7tvwE7;)-ea-V;Y)a%@yY0kts$ypP?G0BrcE%Yk
zU~+gUdx{=#F%mssL8l+pblNINW}nG}$9{r`%T0*~5F~gtHam!Ug;^Fu9N!^`l+)Ex
zb}S_UmU`#Y@hnB!5z^YWJV=GdB@FpX(BM*Ve=c>O%eeKb#^fm^mBod2j;E|B45Z{m
zlusFOm=p=dgh6=BjIz;1VKFPhAV}2`x=6b|9NCZdwa-M#hC{v-E>HnOp5hvbaAy&Z
z7-2<ei-lrd^3_tZS*b{*=I5B$@={+9_Z-t>(0(j}{%YdhyI;?B@BScn$Ha2VWB*Ul
ze|=fpq!yU63uRlSb9uXvM#obYa$g^jl7!R~D0$?`nKi5;cZ&cFc5yQH5Cll&B!c(l
z6gp(Prgvra$jee4x|Y{4w7Ck6ILX=5CDwboO(+yD^lLcQJvJ<iP0?kqdEr7u`N-F{
z`9ehToEi_3fF$@{wy!!S7Gnvd%l=def7>+P!Zl%@vsPaeDxZw!sTdB$Z&oZz8r;9+
zqnD|E#Xuh<5YK(sHs>nz1%Ot$y$C7XLxB2yb{$6K&vzjgs+c~zNkQx5oD%pL(no7H
zU<aV;w4Gk9l$1>&)0m;5&xmyJFS+g#ER9v85dsdSI6?UJgzUf+dnej6bh{Jxe=^_?
zH%0(jAC8S1y$H%de3Fh+Wwc(H0>(FVaqL$LY{X1WC793ZUb4lUJ8rP@)z`1yyyW4l
zru*&8eVII%pg;UPj=z;r9(?!X&$9gH`|E$BkCBBR{)tDuLLcyEJ;Ol}fC^s2!5mFs
z3U0ooLLL@4gT_&P8eFsEb#k)+fAi+FqK>*SD$cU!nME3@EE-Md#CFi}8Jr`+q0-x1
z5H)Ko>U@^qf>I_>-scy+fSs667~3egEw_k&&$IP1Ad5k>^FQ>(OCJaLc|J>dc=H2u
zgt_3kaSTHZ8DvO(5*T31?yjwWBh5q-eYOf?Zc@UahFz!+hOM}UA{}U^f7qf150hQ`
zFxFTKXNI)%$Bw)!SogjgmEFCkfPf^Mls)X)y~YL<KKoN5$)?uB<l|NvzXrleoIKI@
z)diF)W395|J}>qGr|U$owR)XUdgodGDX#iU+_o5{g2@Qf?D^90A2=~+B)O0ppr^t&
zsLosGvkzX!N_gI|<l2{-e-mr~Cvh9K&s*wNN*l>Y8nKikPbpNw?=5)Td;VhR4o>b^
zp@IKS``MreH_tLvqmpdQHqe2rrG92E=V$0hqHI3iDS2I+Lo_-b`|jA+lnWpL8N^?9
z1vuJ@WqAZ{Gs6g76#kNJ;XsONiJow88Jr(qL@jTqHOkrd&8u@ie|E&#3SqE(DgeL{
zn-J7Q<|Z{Jc=FNUhJg%lO;k1pJ$tsB%%`3NJ)iiNe|gK%Mte6Yw6d;7R_S!9s~<<S
zkUD=kcK(R-2+Z^YsNlfab(D?L0UtJexyp=ARg~I4<s7i_70vCZ{rp7!Jf0pbqRiLu
z5eH><@sRQ)*c@Mke>Cd3*j)QQ06hcbhDvk<k9i~lXXXKCCJ;j&_BHvDJtJUX<nJg}
z;y{Ax8%C(Q)oYCngdbfzUlO7JVyTb5Utwe4PO@=6d-DMBc_0>J?hE0vm<N8+&c3Jd
z`G9|AgP!p*{Xhhcs|fK`1hv}`Achr7ivvM$ZqJ~4fIH)%f2-+jWS(pIPJtw1-I0t5
zpLQ@j;&0_{&v$nKe#tW3`GxsqU@FN!$KGL6Y(S02dEE|B+0hdpPUp`GygvA2K;Z?6
zL<NbRc!jm(XaK7ic924L{o|^(gDZSyEWrdh9b+KTWwb~V2BkcVOqEPXmI+!9Oz=CF
zUd=&ifgJ&ke=66wJNA~if45q^X?$i$FH(eOnd(%Pa^h&SSwqcwy+g1(9mA*`c#Ttx
zrcvyT>7@_hk|SkvPtH3~g=aJ0{*~=|S)WpS)KYSO0Ii(lK}_vj0q5$6{>3B<y~8<?
zVj%rR9e${(?l<ui6n2jj?(~2P7{gwoK8&%!x8@p)e@LZPe^QTCjzsH6^2kitu|txZ
z+KZP~4h!JQj%Yj?WkfpXS9zU};)I$90mU-rZM|Y4s+0$yZhZ-1;3I*<3aE^KB-Xh^
zN55w_kD~yb-rlFZi$MHB{}`?r;c3sIH}kO_Y6`eFX+yQuz-z=@HtHRWFwON}q(T^g
zQP25pe|YUR4T`xm$)53?hInJx8Y`obv}`0T8%g^wQ!-tif#M>*C>_VGiX>>gWOzzq
z9(XKn-3tdGW2h{!Qu}<uqhI&o*wowlM7IX>NeVP2MyZbAc_&A*)QV)r)#@cxuHDv7
z`bua!4kJpIQ-f0Z{^+k`)3b;+g;o&DvDx|de_gbx01UgT7^3+DAssf_qJW#t^^5;-
zLv-FDC=&XwA326hv*-|*O|FU*i~>sqqqL<4K^{qi;Pn+aA9gvhFR3V*!+`Q~0mjxI
z6j{<-wA5UrBVxTcBZ4GkY;w*YzNOfb21v-ovKaj^CF2W<QxNO&{{W!q{s+z+YEuej
zlcS3f0yHv{+si<I!IG3P5WUY=a5JeABng4Ro35@^mR=N3?jGV07D`B_l8od0y&XC;
z#p=c4^76Vn{oW%iE8$~VTV{<AMO*E&!?G(^);(nizI@oR)R#kJzUh41?OxqWnX$5H
z%a&!`u)V75v+v|?RL7tl&4my|zNUFqN%GB4<_W1cU*Fw-)0{W06ohg5*nQl+?`{hv
z=l`iJcK#!+0clkss+uQh^}Z^Ys8E_L1kGj5$!D4~VyWQd7wT#xu_kKy+a1_vZNYdl
z*NrN?@F2ggiJIpKB)L$&C-#J_(Yi-ESY&=08yn7eLRONK*GQy1HUqO&=?Z`GK`&|F
z*-as6gOwkDlsB+=#WsxE`2v#W929C~o%R6-?T}WFl#$6to2xHTFp0JnWunBB0!N~(
zNw3xH5uPU)Lj?OVEjXaEYxhIRDg#w(($rubf;+n`knD;-P5zjs?GP{%aG{(=_Lk#y
z+jHJ|Jr6IRsb?sEGKcxp-(J{w&0C0S4K<SbH)Pi{Z=c|{nk;BM8J&jhF}_ryor>O&
zgQytk5g+UlJ3yV$Yk~nUSj}Cqq~Xt`NB#!@VBdd}p^Fm&G&Yx!paT<@^8qW99?lnk
zO*Xs0VuKvhNgj6h!ELLmoOam-AJfzSKBP#WZP)Y;f<ccZnWiX`B0sX^&V_$+7rVRA
z^F-`NyY%wTwX5}MM}vQU|4uU90SFHh%0E54``ve1@1!eYH<r7H<CN7yw)@HX^EtV;
zrrsYs&vSzN{lWLO^R4;Wm42C*Ct7cRUYgci8k#)k?HNbDlbIvE*&k%AlyaoE|K;I_
zcYk>pB+^Q~QFNqyC3^_6heAp1v+P0S3+eeJd$2#~K+UBM^+Z~ju(U85r3D$6Y5~1@
zN~n;v@^H@iwCP@j&QwR4Y0^4>+#gir7$!Pbdzd|wR@#adyT;Jqn~&dqH-D9Xk;LYe
zc6}!)v!3P?GBrhYWwPqnqA<_6oYY3pIZ#Eu@ccma=YUg1y@rG&9X)`FoHK41TD#%2
z*-Pi8A6P4*n(V8phNUe<$yi7g&lTl6jY-?QDoIvW&nYkY?dUWKlbFxR<ysh8td9J0
zs*&Ew$hye<J*)9-n8_*sgevKO?a-c?-?1wS8lCFoa!J^Buniq4SRTm}QqzfUx`~!T
z`x?Hmq}BqU@IVAEcrbXX?p^ao)BYBO(sAGvl~qRdgwxPTT3Sx%(d48Bd`0^TFn|JK
zNwv71H<M37C#~?4*3cqqr{HmWChoxMTy;f8t85J3FG2Sqt?~P$S<}jY0lX^qeb$Yn
zW1US=REHvOt|Do&H4VZ2R9f{K`q|ZPj<yOx`E_RRQ0TFo=!)Nb1V^*i114$0q}JjY
zjq{eC&t&wTk>S_&O2M~yOYlr}(z2IVWxtuB!D!aqfyJC1u1qc_TT_LnfoM3>-Kd1S
zH4Oxj2vsoAfE26x4YhE8A>Pc~=EDatiPFx$nl345_#^B?Be46$lx;&ZhyXkQX`Zbu
zVR8n|*b{<Nt3Y_J91SrE*GRfN$4*M&>xIGZDcoJ@YA-&!X94KZ@O_>O%|3nC3pHc@
z$<)or*cGmj>x4<yo*^a?-4B)NwPbkh_y4WTA3353(9<90Y?w=bk*B6i`Qy94caN|@
zlW(g_l9%gyXXa|ktU2^@qAKqy(8whb*K1mvJ7$RXf$$BgDa|3NPo1^a9eThjW4y;z
zIa(AM<KO);@AY_hP12|2WF}lfe`2N4xYLg=Nm^G8i?uHQjPI6&OTO0fH`(&eJ<}=k
z<uy6Pu?Pcy?*AWus|zQ^vT9AA5+Ci=uDZ4l|9x_1i{BG}U^eBiMI6U-_7GRXHCdz*
zfgZy8!`ZA|SfwBy4)^+Yn$RM2hk$XcYRqMk9P)lc(}W&Fwu{tu43fSt0x#@&j+byX
z1i?-AdQuLyuu%%Og5cjKl$K$oJ=eyt6gKa75RU7VLI`Ak4PS)dWDBRjeAC>ostE9g
zlKsZLkBKcY*_E06{TfF|t-)|;@~%yG0T6qG6%k0Si6{Y1dNVa{GSmP)Lp96xue?kJ
z5XNN)ItoMt_W3{fnFpz9(8{K8fRv>>=(_1(&)_q_cQ>|p!I!Rs&>~MUf#T{B11JtC
zI3qz*b!cpVyUKP2^bv%fmCY`%kkGd_|KKX)n-mgn#`~A_Y|rdS8Zwby_z|QFzUo<C
z19q(H7ryQjFt>IQT)5bydNyDPc;W=8^%!YhzA##x!cA`mH`gsLeSic0*BTt|n%m2>
zaynlM*Nx^5ziRzRXxATu(UmYB1Z2cIF@m2J?mB{hLgCf@T;uP@BG%Cq#$9XEbeH6@
zc%dB_Ri+8mIdCclS}`(4eEGE304`7bHn)HnUt2(kD?HE4f!st!p@^hh<TebL2=;sr
zzg&Z7G2rjuO{dbpe|jp36$KQ$RCW11SoFOcCIWmHk733}kW~vQ0f*bL5Nxnvp>XQA
zH|;Nf-6_a)ha;R3<M6rKIw>3QWy1T`bemg)cp!2V&#&pPQ>Vb#5OL|Ew015gDS1eF
z2uD;9<LEiZIt@n%hAh&+i9HJriYi%;;tDdX^4?@~xG8ZwCPPzh1l@RyDmU~V!rdS2
z!*>88D+fAAq>wTeDs0-MZiimVP@~d`ld))jrXu*3>q$6FG&<F$@2LnfVQ@Qf$r#Xf
zpSOZv7sl+()#0Ru*WnmNH8xBJiq_O6)-pJo+yZdY+%S<<06bgjqF}MiFF;xKlzX!Z
z5+J4tNLsyoQ*6G9JbU_AV3%D~dCs-AEuBw!hC(W3TNC)=Smz);-XvVi2~e5(m|&8B
zL;@^G@zo`1Q+#>0md7`>IduiLBJj2Od_|~bZ2tv|poYVd;&8NfPESuE=&asg|6_{T
z$%ay71FA-97U&r-#!Dr5v9gF2UQi1P|9hbYTZQ8nNo}(MlG3gicv}AYnlz0K<uU59
zy70GWP=ujzgDy=&J{<!Hl5%z|JT}LFoIr-o!#?t@-^7wzZ?Wu4g}4XV?-7{v0SK2b
zc!;iPX*P69yx4V83y4b)4lm@Xqm~0Q<z0p@1&jevw@`=^34B{!$-Ci|z1CJ1)0maA
zls)?cMTH!DaedE>nphr%!9IF$UyO<(>p#amcI-H;*nSC8*7?vDtELf$LC?^CXxxmk
zv4R*Iy{+PS3sm+33L{^IoGhmGgCWY`I4PQnMw7zIzM#irSJD-vDH;Nw*sgX=n`GeU
zP=ta1gpud`=WJDj1Qs#lli5|a{eeLYXYFE7UVUZVNxftW%=#*D$4reA4sS}w3#uZ2
zvc2Ec8~~{=8bRFsV|O}0nopm9fYnwvD*Qr?<*Gr`_m?Cu+SRP$y8=gVXH`_?>3|jO
zmpx{aTQKJ~ZAYyzjYHuD-c6<u0Dvf*cZR6SIY5Ej)>X0E*Mz|8E}^6L>Aq>#vlq9a
zVFOIc6Xpo*Dv0saxXWyh4i?aX@Hsk=T|FE68W$-dN~g#y*R|WJ;dYLHF!cTlig|+@
z%oVe2(R~sAZCG%Es`@V8mTQfiAXIpp1$-p@ARfJfdwN^)g$u5xVF;4u5U(+P>Bz~C
z1TtPM_ULHR=XSIMW`T@onWl#&_D30uT0$y`Es$aSGUgNbkblo9`(h^mC>bqsTHCQu
z9u_-k(OIXV8O88_bh(XxX-~EZzmDv_0E<9$zdFqRHQ~4esRho~)pit&dcozVvj4RU
zXXkMeY?ka$q51A`EpPf109<eI7;Ayf=4e)B-O#pNIE0g5H*jL{NA?>C$trOER$7>b
z%lvUpt%~f>7@)Kb3obk(p%yWrtja@aPKhm^Xal7Or#O)$uuD?YWwqlpe>GRz20>cF
zlG?$_+0b`bAGwk9(J(s}z8I7UYyaLuHtHMWxG;LG%@VY+=3;pIW2+xZ0YxF?ZBP4O
z__>v74<qr)kHvF_)S>Nv=0gzz;W6&iVBrPq{OO_ZuS|Y;nEWL7%X@lzr4|8<WUxFD
z7!N8LxeH^Vz=3WbsV6>+57aAXTCg1P3hw(q!h`zVlc9?f0yQ$1k)Q(;vq;!?0|J6l
zv%%Yh1O$EH8!nTfixUDhIhT>30}}!_IhQdH0x7ec;N%5=M)Xv&8Y;^Sii<j{p4AgU
zrwj0yo^qTFc^C>}Pv$M6fbIek!V6D!(9fNGhV<!Bt)x1E4ByrW&^P3H@*ip#=5@ty
zx=={i-?txr`sL~1<*8UR=sjO9RuBCQbLU7;-RhI(K-LB0qF%?i7k3BNd3bFzj}ko5
zJw5BDY0=t$bQhg`03KB@h8n&WiFNou-l+|y8Kymf4xHM3Yg+=`^CcZRBj|)CjAo;c
zlOq$ALMu!R+7XQ^3va1v!U+e@*UkY;mQ&dS4w!6RwBW*~FWl0bjXBJ;Zu_q7O?nn9
z5Xk=$dDJmcN+Y}wnxcaPaQ4$6NLz1Dp)K5uEln$bWBTGa&{~W~l)!-|1aI9C=|d0A
zr{x(_fDpwh*-l5-j6?qxhRUb**BqdE*0X7%N`}-~pALs~-|03=CFCHi_jvGs%#=`&
z>dmEww#u2T#kX{{w#3P}FL5$qOPn{fbTJ;^pS7Z}L!x#zMex{u5179n)<}7X3dhcY
zx>nbJPX`^?#s?4oJ+=MZ4nrJ8j$p81NAPS<jg+nq8#LuK{2%r%>e#~f`O&~vIsf~8
zunbKa14DwuilQtt=V@6{P*Gas;3T&4gB?xt7h7oKGZ_?swEe;FQE6EC?uyo7rh^b5
z5Qp#1j%nQ~gsbqgnId0^#b&`bG11X+yrfEhl;cFqm6`TwI*x8-$W_P3YpSYgSAQCf
zvC~uGhEcd14kp)uo$axAS=!<PmuNTbY{x&`a^!6To}2_1G+}s|rpQ3bw?V$e9abaZ
zEXWm>#3<$|FV~mb$JdXJq^h0LaBb&@<2=zmg>u~0v|$_2XdqFn$U=O;$ldnP`fcui
zL$z|Fr)Hai{KiX#ypS~@$rqteTFVg$3IUIA{qN+c+RR7Yp>A+@G|jPZoTb~Zb33kc
zGj(Oh&?}Sb4Qfk|h@e&^cwE>aA1)wv4tu<U!=bJZ47k8<ER)HPM+aza&A12Gan#g{
zcjhx~V-%ZcX;T}HpJT_tQKos)`??!{2<;sSYyyP2J$4<CbK3AG6dj?Ltf&`3JSZqO
zLFdcNfO@}ReWhTs_{KQj7@EHp+`AIgZejFIk2G+FMK|bp5>p)53RfKr>@3>o7Obq~
z$wGaY0?bgL9IS)G+M0ailuFuxmA_BvZWiR675?jVj?9rqBQvI@0lPhR=Q?eFSW~Pz
zGJj84vs$c&ga5WI(Gg^m%kU|#J8O2ikLS2$^O$?B{lXG#0rB>M_8w?X535HSzth8T
zYDbLQabUKqL?_tWp{*#B_uB{p%xgPaHu-y#YAK_$$i6>L(W^dLGIhFqBl<H5)*YS2
ztm@S-Sb>uD+6wHIRPLNd`r=7{0vC2{g<ByhL}OpcN)<*Z80M^Tq!&miq24cpCAoS+
zhI9<)VjW>e;v#vwAHt-ihOWIh8_c=;nv7#wg&al+&J`!HsXM$Wv&l;(cP-sa@%-X-
zd|tDv3dDWy0>t;1uH%a!$~k(K2BdN+mZGs4Ac_tu_mhL!_?jobL4Xc_Lop!RWp@1Y
z0>_B$<$$*jzrO$H&weCTL)-Xd7Av9gNV#0)Snvukamq+`|GsxtYhO~9&TL4cvf5wK
z*$W`5`!esmE<Vcj?Kb|=LSXA%x}i_rrT5X`0j>688u#P`OI3*S7nE2P5D&wVQ`hbd
z+Tu1kJj-&B()k_3W+0&pLoLmGGyGo=WW&Xip^Fm&Ha3${d=#^+>o^I2fD^GSY0zFU
z*TT?%C1`MX2{=3=rTR~j#sQaqvIO%~#(@e^3^zDUfR|GESq-BQN(u~HMX2J!XL3>>
z+gF@gU;#4;Uj3DyczkZnvMKD2^ZM$(u|q2i;UIH{RQ?$cEpyt3p=wv_1CWlJWQ>fT
zjav|8t<w~8@ED8Kp^nsl+M<iiuh;+P+Xvm`48F)ho$95E{VuCKI{UVMx+ozok9t-@
zJX`<#pj%Hqw?5C0zBzE4np-Zv`|IePbjqsVo%((}_MNNS$5C3*`eE))Rb7I#DARoA
zC{aF7heul8$LeWh#u~?qOF#2DLUwG+Q|;Esmdniuw*Jyc9VFs^e8Oa4E4_$`G6I@P
z$c%>GjmaQwk&_l|ve(C!o+LiymN-%kayhnsfUrT$&ehI(hB4f%zXq(c{yKg8)M=PQ
zDx}glOybO!S`C%qRJ7^bX8+=!vk3+KBqofq7-@g{CEAoQ4zht{E#Ev6)e&3>+DyH<
zfw@$Soo9AM0?Ahs1~f^SW!WOPi#LdTAdX8!&Qi>?boPn@1g3P1m6M^169G4u5nlrn
z12Hf&lMz2Df0b5EkEAvbz0a>e%3-^+Yu3hmj+9F_*+@AiecK&r8E`jf0TXO8X(>N`
z4Yt96>7G#^XhXT`Rr%E`BL|8fauVo77`urdJ6Zhz$G6?Zk$?XB;{ho<APj+F`RnQ7
z<L4l75OfomAm?;8U7d30%i&Xzww!cFfH6LVk4ND9f5G85@)aV#DVvLY&#sJ<n#sjW
z$&2Bif5^#MemMe^c%FAa(edf@=fm%(2~psAuY^8WZn1|Zc7$R#cEZ?q5%wi~86VJ=
zm$W$wC&A(I7xgS?P1^KA<dX4j$VcFFlE}rOh=#C>0_o>}wdc9N0N$n9_n{=KZBXq%
z%Pn<Ue^#8n*1Dq21vF_*b~h~T8ST4_fQ&Z0qm|mUe0L+-zocVRVblV!mSp9*6d4XX
zfv$!Zx)`ecwy3(UUts{hlj{rZax(|<8fhq_D^I$rY2H`FenJ_oTiTF@Gx=g#gQ{fw
z-dQoym8k;vMLxKED2t|4U!N?QDtIeggPk9^e=&-zA={J}^Wo{$s-in*A-W~)D-Px)
zvnpje^Wm@L#SIrN>CUvP<*FvUpg9;{?DL2G*H&rS+}^SZLwnx#9GuIFu(xd#0MntK
zAQu^e_ANlmGdPo!_nj)PS^$wiN7%^Xo5gKOlQW=?av<qo|M9apa8v$}8{$xS8F$NF
zf27H-K%9=WUrJ64T@)j2|MTQrQXQZO8C+RmDjOhrgmgfw!!D?Smv{@x1}KPJFY>hQ
z`!ygBLe~!j$8j<~O_3aXYSYTQfTkd<tlNqhywx<_=(7h+aGPp*C=%88mr}Fp`B&jX
z$ae$Z*MVjiJEs`=q8R@EDaNszB=J%hf0j-G5>S@7R*J>1t=9DYdM(qyBAy>i>{3!>
z!H<2DARGKRgo1^;b)At-!Yf62A(oFryD#4`E}A(5n-7#1g4L@4rt~WaR=WidcCDXj
z1)i_7^dTIHqTppq4FzX}tZx^dxC+E^;&_2*Q&HR7Hw<kJ40FpZW9@VV@Hffke>ovi
zR8!}Z&P|OUksy2epr?brdZ2J~ErOmKc=(mTwe=m~Yp1$$nk6xIqtT0TL_bM{r=nC!
zub(|5YP{>=VQ8$%Fjcm+ZRupL#qQg;S;#)TduJ1G75t?rv*K=aQ%x<tR#LuX*<M3B
zaUiM}+vd^S;*WYPSvq(WmZ>rAe<N$7k}w`;2HXd3N)r~6YMn0z!o@Yup6$*Ja2XEX
z3)GQ+`chA5b+en@&#-k}EmSjkA!zZ2W52_?eS(=Gha#`oxEZ^f8Kl2)agDXkBO$;z
zoP=CesUCE}LV#Jx-y5^h!=sA@e$&wgl=_&z2~$4v!p=?X!o&tI#N(*46879!mIc1~
zBB)z!P`@8P<mRK3p^Fm%H<J;+69Y0ZFq08KD}QZ|+cpyZo?qcl2l)^&;+rTfP#n_i
z?g58udN{i%inbrL7QGf?ORgk0G0-1>GaO2mY-XFbIQWD3Ix`$T^UTnEk-(2H@?>G8
zWVy-~o5QQbjkeDVYW(+~uee_q!@_v7^6T}hH;-B`c*61|=Zp1rDr#LWevIDjieqov
zWq&NCjMBShtdx%K?N13;byYvpcz5o4d+4b1vFdl&Qc-EQG_#C(E`*49w)}bhuU8N2
z(IPFx7n+VMZ*5PfwsW4bY>{S)ajD4s*8Xy;T3g1=aS0-HboUi~o1<-uzG~{YE)EvW
z0yVKnnM^os?W)6ZZ{tmKI5xGdds;XX(tq_W`T#d`p;?}1i<nEswHNUl96Zqp_~-D{
z?A^L}TsYNrEczXakGrGYRND$2K2<c#Q}4H#_Sw)y(bZ`Vw%;{nylvXUT=Y+1;FUAn
z_%EkoPpy4%cq)r{Uv)hV{H?XnL?xOTVdiIkYRWUn<aFA=f{Wn61hVa-);ZuGp?_0c
zE~B)^cw1C^xL7oNF7OU#W{$b*+jCsoPyKwfdaj!`c>7yh^rzOw_R|qg+uf-6V9y_$
zwtVsK2lw6;wOjb+F%?t1D$O#Uf#%O?bbGEao=BGD!=AriJk3=Gi(W9IX@fQ-3|oKP
zhAeCZC?9ONHKA_$|BoLA3*I~$V1F~5fjL+eOIT)-6z*0t;2>HJ*UUJWmCEQH01C*8
zM~JE=d;uWRs0ibr^Ll6e2r%J>r31gvev#3B`1VACwBNBHo;-AdJY`C#;RIo}2^hdd
z!h{jClRK4%Vkt~?rp}Wy%2LMyBM%f#q~T3#hQadzZKqAmzGFdO3ZAkwAAfwwFTNBn
z`?AOO8K*?_=bdUae4u?kjz@zb?`IyphJL0a`ztyDcDdPVOJ5HqTT-{c<C`@4fbt-Y
z@dL5kIT<M=u>GDEK225a8?uRZc~Ph1u+sb9+vN3oJHY(|$4nw)b86cOXfj~=4fZ}P
zHQ4xUX%M*s8is_y01Bg-u7BJHH{v;DPN#=ij5;S_+nh*Pb}Q`njA4-Zbr!7}ubU)p
z(Dig%CTil@Aw57QSE%{b6$YY0<xHg`7aY!$i0IG9U_|7G$y5$o@bKEZ9#StI5H!yZ
z2m{yN4v`F?((tJ@RL{iV`j90igU}pFX;ajs>B+gr+tK;MZz`;z9Dk0$%%ThFkEIeU
z6IY~u_eEZr6Xa_O^dSe#)c~U;@-MiY1#K6JW?JShw3TOGUk(N&O2e{jWHkc4kWtlR
ztU~G7ohTSL`vL;FquHVztjp#{*DMvIurcdgIVcB><J}f}h;NYpag1)1@AYg(h&wbJ
z2O%(OhGxHZ>qymEynn%^JL);C?W%p*I&!)Q&4#!EKV?kHG#ox*PEKygSP~hpeBq4*
z?0h!m%ipKqw-nz)`R-!fOM#|mIB0pUgw`bE7~)FfxYCd}WlCH*5}6se2ee$o;aM+v
z%+L+MUe7n-bc^@lwm?u%t-#FNS>GvqcEer2x=Y5?`8q^d_J7mH9zn8#i0OBQYY9-f
zKZk&xX_lm8puK?b9Ev76LpUmM2uJxh2*+7OxSJ(>ngO3c$3}^0O#rMmFnwNT65||c
z8fqpUSrS24ge{i{P*`oP*WNe7s{|fRTFmm(g{ii18wwLAeFju0$e|t;%3}-kYtExn
zy|=^gsdKNCaesdbcA$AN=8mpMM{qc2Nplz3dMdl57pL{B5JJw9=3qlN_;z*wNC$+H
z-_}?}de8JTkGUoLrYJ{$?Aqq^ybH1<v{OA^;Qhnn>W9_(;hXsW;Xe=W?^p4+?}IeM
z71K&hh#1XquvC{q&6AJ2Ruw(sRU(hz3dbYB9duFB#ee(Nlgc|vWPB)yL?)b*aLC0O
zHpna3x-A$)&JkNKP2q~x0zVxrqLgG{7!1-v-U0H`W~9?QGAT^-N{$bX;q``+M+U*p
zZJNYU!V)<Gs?j9LXNWB*%Mt60bzQK=^$Br8(o%jV3k&>LfwCB%osJ%a-~152fA~K3
zU|4<k^?$p6zg?|DM@LgLoz61idRO6frEn*0vFWP~o<B`|)Z#e6_taWy`)h!CcY_9R
zFr``%r-_$wnhG-vGjN}-HoaF;43dhG2b-#Ne4<1WeTxr;k5%Uo0dYpqNfYv(@s$ky
z!*G-E0q8jZeTK|0cMcc8k0u>};m;2+p1?u?EPsn~L^tw(Lp_giiDljr(TnFFG6XKT
zAU>T`d-Jlv=;_PqX$jSu#dMC}Ae1?idW3xCHSLOSX1J}X3y%=OUfbK!V_0f>olaf0
zZ5x-jrB9HMz$tKXXrwdh4%CHh{{#t@u@IXoHDhd!|I6XOC=lXZJif7CdTP4o5qP-p
zjDL=n6{LH3@?cd{d&JR#s-~lgJYz=A!_^l6^7`?iu5as0Yad0m&pjr;txGS^Iu8wB
z4`DL#k5M=}jfBsCRTHg0!+e6}f6BRvDSgd@=wQmpHxHw13bxB%s{zp(|8-M0m2Kz6
zJFi3I*f!5?0VLm!dfnH(r>WlcxgST1+F_TeLUX3_d=A>i|HEJs1S>fE(WUp2$`Hpw
z3feV+HMta)&~^oLnnO<P{lIp*sH0h;J{)#De(HSh^0<PIkB2~TL&eRc;C~>v1(STl
zz7NHT;b0OKCGqf|_WuAu0t1Vap^Fm&H#w70d=vpOli)@wmpcXl34c&IhkzAv7W2Ym
zbMk9b&LMWia`|BU0Fj`G5(zK>xLW1cr(Xkr6rhzWr2}UM^XTd6{`%_~>6;k-^i3Y$
zq}Hn3WjCASyO>(rhZ`>Z`ycPL^jky6^`z%FckkYR^!`T2Dvxu0bGMsLb+^6wE&6s}
zocgj|t*y0D@?o`h&VNVWmA}W@)m8n#?cH<Nm&cAPPgTFil8d(Gj=!wdIyc5dI$!;9
z_s@6V-whIZW8Nq__WZK!N#>Ncj%BZ_zG`ZaC38`Q(q%R}wasd6vS?FwUAa}Owa=62
zZUrsRr)pCi4$s`b-}8tt(nV+J&vWz*w;Y;c%cVkA`TFPYK7Vqb@^fFpwxfEbqYeud
z6oN4QzUb#Chn89v*_Ws+*!)^sr9E#c=o1yal~ce?D(w6IV+#7PDh7q1K47RZDo#=!
zn<%S1Y&bE|H|OfGT{kC~$V6pZke+CUOO4{<sY-%E?^q`2l}vjXt(>;dnL2&Am&sq5
zH+RY;I*e#ee1A^HY1Hk^3eGFzhyJ5o%}njV0MgJC&a=U@ed=U(*Z>v43?ACzctp!K
zE~X>J_U=U1QEsZ;Gk+;WutvU&n*!}>56bp(LYmj)!!@{SbvSV8p2u>fIGqkvxxIy&
zkLkRz^>ipU(xKVS=|F=Lyv@Vb(D?8KXH?*f^4XxRr+<A}&z@SUtj$8NWARwd&1Jl@
z`LO8kv5&j5y!K-2wetB*qBC$l^94ti&g)6<8DGAdl2-q@+=!uolE5Ok@Y}c0WYXvp
z9&}k(WgYbRaRq*Ku4z#B$E}=M!pl#O>{L9I=n6X0@%7%cNtCfSN$gY(N_~BA(s@1U
zJ+rr~DSv}zHH$!y0Ke_I=0YRCWV~2l<5!5qntYPGi5Fq{)5<4c{O2%W-<%IyE)S-7
zF=bsGsbtXjsHF(2qur;$?q$*M)q}d7Gpe;^1xz681s*VXHJb(N)u0vUU<x>4odw{j
zB)aU%qCdAK2bj=Ueh$uA9l_Y4)E5W-RMcDUdw(ceK;Q=gWdeDNwn2SMQ0JC*=AvIZ
znVS$A`aENo=G<~CqlxUHt-8lq;9ZA35d3B%{3Z;)zpio+x_BfxQV)QJNUXtnw;i{<
z4#$>f{1xpR#C35B`ji3Lr57pheDL0X{dhMwtBsXT1|Vq5O#`@yYQuSD`&>D9vKmK6
zEPu&)fcBEaM?dUlMip%sRUUy$$i#@a`1{mWy?ihD=K|aFYf#X+3!?5gls9vmT05OU
zC7r`&8=L3}A%l)!P1?sAXn#%i8C#SEyOAttGPCmN1j>GhHuqp+a|Z2InhpBB#ffuV
zpS=(k0hQwtLG9Qy3i^zKqAE$8;K)#}YJU)o2ndKPS`?9SwgnY}0VOJRS261~O#%WZ
ze$YA56O)jBK(JE*QMByaYQxR6t%B$j8YgZR8)#ebxdFyviA}=Tu3^kcCQ+B%7Fqzn
zJQz+@+#jS5%<;ZyrN4|!qkTh1*F18SnAz2Y)qiD%s_!@i$d0BUC8)S3(LYt-?|*;C
z7NTJoaQwukjn9UIzz?E(Y%aKE*@8{1A)aOn7JL=&r@s5Qx!J(5O!g(~%hed=g`0T7
z3)*qVf-^DlqEL|Nk;pxM!hnEZz~}3S(7kymVMwbarb0l|<ZBn0EfEDt1NazNc>&%}
zfo^8InOB(`1pV+d_-1g+xxK}Sf`2G_%_DKq1s<8I*uITM0<%lzXe3R}TeD0fA*>Wf
z!U(qPu=ou+x^h`^>1&r1)0!MiyFq1g1yhK%P<zS=pp6{*Ib;%?06=piL%Nb;RV=YP
zpX6gu5h#(VxuclxY{b9-GeBD3J}+QGoDQszy)Gw8ddmykpL<b33P!50RDV#H6a{QT
z=~2^jnbRp}J%J3iH0>7Ef=v`IplP5l*w~#nn8)qT2Z%qZ*O<tGqn=>WiXau>grhwU
zm7s<5cih5R7nZ7>ECc6IaubIwXe)xKu<-e~8tJ@<#&mr)QA2mh8O;gzV_FECz#TfF
zD)MC`h(aG5#-VM=4aIg#X@4HVBi47qY60E)3$Tq@_0;KU4@!WKdzqt^$?AqW0O{kn
z0~##&n1?+KVL=lA`=TR+2L=R7gHCB6d7F+H1m<Ylx97H%O&)@XE`yxv(1QUY9Rt}M
zoLhw^fXPtD_0dPr59p9QCu#U~v;oig88!yz$F`=XGxtmBBxpft_kTtp&{G(e4Tve>
zQp2*u+}Y+m1Q<wKE_7LdsS5ka46#f4t@-$<0>q1%NK==T(x7R0o$--kk4k>QK<*(l
z(l{Nq3+<4_tpwGv3Km9;ZL(lLpTb*z!DL?7NTRZMNG}g1Cte4M1;F4`3Yao=hM$IP
zo3s{u3ksX!jQZmfPJh@mvA{>22;=mF^WqTJQYKmg+v4`|BoasnP}#Cpm~vs~S*)D*
zZ`%1fbiO#*K?ApvIY?I04@nCE{INJR=Z-tvGu=e8foUrk&X8Xmg*&m=4XGL?8|ASX
z)7<TN*VddRQz1%Qw0JG|*6W~@^O2uckbD&VUa~;QKRQWB#D4+X?hUs?U$2mK10@U-
zVeQJ3TW&>4Fw1$gR@o3&!c6P#gwe7p=Lt@XTb$fbXkKGbC00hr(8OJ*f}&5`G_-a=
zW|8_}xoIZ@kk(DmzX=9!5c#r8llYZbqcxrb92ZB$V6Bs+V^j>ba`Nw^hf1z9u<8Ve
zjc3~JW_;k534ibe^RZu;P6&$!e>yY8hB=C^lu`0|I`4We9*ho$wptVM38{GBm4_W0
zVkLHdrW@9!;6S+|Z^^;ZgWg38*fwYZkH}@y-A%iZ_-@>t8+V7J<n!ecd^d-!qiGmo
z9&{tnLVRYhHtf)Yq(1tku0F3NlL-5o1bz<42f{5g^?wGBAsOk#lHvP-{=T0#bVyqU
zLuW-m`nBl=R!!KHw*g|fx#D0l*%UMuGG<!=G4Gr9nX6riDIL^1pi}_!(J!b|jNUGi
z8#E0l;`LQ#O-h;W9sH#&4@ECWh%MQmjgC8T7|>}TVo*Y4s1)5N<RKoQ>-9z3i(jVv
z#4v~D5Py5@7qo~uQ#uXjHe+4Dyv<3he-MY_5K4OAHHULwN`OaH&HVKxqU;SJ2(m}Z
zriWPWEN>MHE#E+)?~rcjl<)(wXlKP4p@0)|iFmzp(@*W_ico)v2Y8*8y69t7^XV}?
zbaK~3PPOIt8=SwMVXzDF5~zPZu|ilF*X-B*^M7gf0vRHv9xtO&2tVvGpJF1^#^?u?
zG5SH}g<oPL1zPwmD@mWQjeihR4>Goyd;-R{#ef@ZUi9MmqL2<Z&w(3W9&JVX2YTB7
zwc`@bWy3P0S;I@mlcj+t^21VaMr=A#)PLsjlRd^r@_A>N3jlHM!jZy3Ay<|u8~I&$
zi+{-sK$8A{&IcbmT3)0)bY<8&{}RNo6C|J^bH#EmC`<XdCwLOFvTK_o2L?WVd^i+D
zrl>JQ5XUGW(S)8$Hh2+)j<p<5=(ZmP_c&P%h*59wXnf|Dl$Ap<OBQqm^SJ24vDuyv
zvx?JJt6UFY!#7`SrX3G1_-BH!Se?)g&wo#c8f=n2bxjz^%)+L0Cvq8HNMm#0r<G2J
zgZygOH1F?=_N#@<4eQMyIYo^>=W;I{cn&Hc_fN*_+P|EFQ154@N-}`v;WQAyAV>YN
zzFM#ueSHr;D>2Dhn8(@c+unH>fjFx3#Z!lv_hDBpoVm^+xiL#;9uo-Q3;_hNjDP5j
zzato+j_33ROg0^#MGsXs`#=KWHy;Tvnvs)t4qSz72!0EeXW3rR_|x=l_L8btU)l@j
zdiefn7ZAYZ@eG}UMvAt%JU(H=t2UGvm6(?%q)<Dv!sZ%Ml4PnLx?<b%q6IIxtQN3Y
zGv@ola{oD>KhG|gc?Ao6K{wZ`fq!)4rD`w->G+pbW0Tia<G~o?Y(_UI?6QJ1IDkpb
z#L-gkub6^M7Ox6YV5;^N0>Cf4nZ9~s{Q!X6SDW>cYo(By=61oe@WrIyAMz}K%u?P_
zh71@gV@|bu=C~5ZAyeY3LF#~EPCI#*fRE@jlQqaXDCEw;hewj>-sU(Er+>7*0@^qq
z={Z)aTCxe7IijzZAT|MD$wlzyc}Uq_wGfl5JfE?UdHl6g7J&Iq9Tw%ESJjfF$|rxu
zZvgAAHDlaFGseB}5!RA(V7`~0HD0+$I{KPcGQ2O)3vROvDSmVqPJ__>GIL2n_=??K
zhfldIWVd$tEAXQs=BMKu#eY{y%}Qi|8H|Wr4D+*NV0n^w!h#oBUOaz?=HykfX}9zL
z<&&!{_2a+!6r0Cc(XvbYWi*7={3>Of-c`VnJ&Ex6KT~v=$FhAW`9Z-(5950kUr2Az
zpC7pfyWm2&isKZEX=Qz38g{A*Ty|fTZPAJ#;VNB){{s0RmAeb53X`IX5&}3jlTmyV
z12;D`m+|ugDu3&b+_n+_p1<PYe9-}3RuZX~8w5y`v~bZjLG1)6k^tpNyj|5=X{(3N
z*T25=q8@uX+X(K%kwa=Y91drGGu-GVgum#f2yZg2Rbld*^87_e)c$zGjeq{-i%8}j
zVB%pl^G|QT_`{!*<R%JL5f;(S+xs=Ex7E!r!M7)S8Gl`Wd(c`3>8sm=F-h>9`!$SA
zTenB150As>&I5NI>hXjv6IAY=M{W;M5yx>5hqu4I{p%OsznvvY;`lQ~$C;myJqits
znwvB?D$<5G@cRDt5GQe9@gItMzK!$X4tjaeH9S@iJb0|%<DhF_LO;!edSv=T-N;P-
z&T(h#ZGSs7c61d_t6Thf?6wPzJ?Kdo+P31ss=JM|;Gr$;;DiKUGuM;jFE4#ZtCemT
z6evE*g10aR8oW6~ywgLZRg~~Xk!8*->0sh42|C<-X0CTVFqO6qv!=G}NOajf?V|2l
z+o0Ha8r)4I&wRikE1wUpaU~pWzzP70y(d$l!GG@T_#5Co)RpTkvc!GFCivlQaQJ0^
z8wCg2Q7C(fcr)*BlQf_&(5jLw7^dUV4I_3^P?4QmP8ulL<Ha8jl5q3*f3Z&JJfPm)
z+{PoJ?FyGpKAA4es_SLMfmPErfcD9XvSv;V>z>rt<C!wqityz$?Cx^x&bEJqg$fh!
zSAW?0HB7>v+WG@1Ux#t<cUwy9p>E}n2bdG_><$%PB*9QOa&nF5xIR?e2ND}LytSlA
zCZmP_e&6dcl&870w5CWh$n^09HniRt@9S*e(E_-A69wn4cib9WJ4kbcqd$T2sbfbt
zq07h)1qbmQOc+c9**jeHbbZm|Fji@Tu781+dnFnN=ku!U&S%&+f3)!qS*pUU@ZVUG
z&GyIX>}DI_wRe`x5|!nt{~9*v4i`I~T6=c8iy37S<EOvmOKaj>71`DV9!_<Mi;K&w
zK`R3{dpDaP-Y?u;+l|~H{lFYL$F6_J)UFkGOm~mioiB~^+vDq`NS4`uB&sM_l7AoR
zHprF^Mu$NM{vt_&|G07-m~ysgJ&$;ai^Uh>$m}|~ivkjhl?C?T1!VLj4OAgByGJ`l
zlI4GJj<Wq$#0S@r!Is{DhNcq5kS|HfRHS_B97WF-O)$+f?<nfhHh58xG>FZYHHI}*
zHc}^cquA`7t?=?=`)td;8|1^upMM?p?67OAU<zq8+ufI!J#&e`Fw8s$RI$S-%2XWB
zHvgr<Yq_;UI((%RIfuPfV3{bNS*RVW<dJ`LBWf#wt*soJ9OFwohk||Zo|s{(biQmC
z<k^!&Cn}F(KMf-hE@$yyhBpA50~|Ei{)u8H4&Fbb7jOp2O2MR<i|q$@K!2@p{Qb0U
z3~*WGo)`7oygBF`4gd~m>%q~IlQi;|K|({_O+C{g2<^z67fOfoVo!wKk*~;9mgH-F
zA$PnbjT;?Wa+1d2AX<v3pgy$e3>9ea8V6^VMmYrf2CxKAeI(a0F(0}e*kGgQTLk+J
z({#JvZ`r-VUW?#w^>EqSTz^`qB$<!4>5h2UKI$!tNToXQUkr#kihS)FaXC=+nNdUY
z-bWXt*GrV^8XuH#pyP;*P0-6>_NMj@bktCA3+dc4KDSKHjd!0$a96h10u5_$?i#~J
z;BOL$EQwBG8=u0le)eHCeGkiCF(m=sfRC$D{Yf4LaLu^!%TMg7uz%g)r2&PbnrwqK
zcCut#zo8iz0G9UXczTpxZ$>AvGO+K@+l-(6iOpOym7qw%$N>m0!RrZ*9z0dH2}lFW
zd$yHGPFco|@d3;hk=ADWyS!zL4CatuB33aFXr^J}(1D#L212KTSj8<yJlJx8#{Fc@
zjEsk^*zn$o+K&>aKYwuF3S3{nrg&^G*=CDx2??Xwx453pbAgmPFFas|)_m=;197eK
zlUqk91E`k&k)ptyET(S+bYa#i*fIe<5v|b4>Q4ebuP+S=>zRag2*-yla(@aYA&azA
zGhzZ11sI_5>Y6CTNRC*9T^%0+%wQk^4a>6#m}Cr0qGxbLntxGh)jRkYeWiyc0)>Ft
z6%+!>aO$R}Vy3Ker1s!Rp}m9k7fUJ7&AJNKE#ffvsf7&tQsc#ayv;RUi$q7kH*dcC
zGtP~JX!(Q*gaWZaAPa^dQS_*t<N(q(fx*cbWZ2Y-Xh#deny%W8^az(z+%?&&@9<G_
z5?J5k4j3}Q7=Nlyrm@*$tEziYVAt0UeS8YOiQ_B`k%gpqK*($YUS~Wu@eVy9g6_PV
z4M3uxbeen&8F2uYd28eP$o-Eql@xOr+gwgSohMtZknRQzLr2ax({b=k%Ou-CZrlO}
z=gTpFyqn$>DhtzPL%Z%NRgup897L#xu|CWCfYrcSZGSUaju%M7n~MLvz|Z7XkttLW
z&u|KL>E1&qVXPQxP~jD{{x{B9)q2FQat88p*WW(tbF)ar*)>81U#E1OZL$@Hs5;W#
zw?XUSgtuHr@e0x3vq|FcN)qU;Z!~7LQ6_f|2P>|;Py!qIyep!z4H39#@W`EIF^srK
zkwTE`FMquo?cw>Xgij|1oJo}$!kdm8i?rCQTkw3z<l2(UMOe#W2{s??-D{e#_OS@B
zGL2xces}AuS?iVOx>GgvLL;xb7HhYj@kH$gYX$5w(9I@c@B><7h^KZ-K?U0!Heo7a
zeRRLkDo!zdi7N7W$0On&m{@}Iy`LH$@iTBY1b@jZS;Pu`@$Wd>!~AXRDZ3s$7R5*n
zT9_INK+VAY2l&dTMNGkB*VtPz0GUSU8XLX)?*uNe5^jBW=9ZYS-akN^L9y=QcZ(#t
znd*oYwWL7L?UDPn>xSvT$opR03MB?imQf#9u`LB$m;`|dLQ7xUQHC~lgqQe_C`-td
z2Y-y_Cz&YN8=G>dn#>hfo_H<+Dx{WmUry%*<;?qzbI&mI0`3*jt}1_eb_sKVgaS2H
zNKmYY+E<J2mXAzuPx&T=A75{o{8?~!!A{Vr@A<P0QR-^KahT5wA}(ABSU^%yLweV~
zIxG%817E0B2+k0FA#4+H9>hl8Cb&SABY*hP!Oypa!I((SLuUys1en1WF#2K7x1!oI
zfZtLV{~5u?%p?u3qB%0+8_HE$G-XN@nTTzY9lA#u!-`(VycWf#A*Z($x2f!gG{Gx1
zyPE1SIGDzzbR2K$VU(#<#)bdhsUAUSF#04m!E5CdnpT=o^&Dr7r(Gj)A1r3dFMszU
zo=H@i&G6wxsA3hp*wdha<B0V-2iGx|PVxWjim>B__3Fbw;P@J(LElZs6Zw?b%s$h;
z<7WaLC(l%pq9Rx6Qoh0aAF>t2Y*WvMRSj`-DL0_UFj4TjWdT6%V_i;-?L|CsXk;0C
z8I}gK%&$`8k83Rs&01@5o{)kvAAce#rU8*d5HyB4>A>DI>Hsl{!mQ3M48!MyNHV|`
z@lubalKFVTgV-#c1`XDtdl7PA8d^C*0BnQX>RPO5h-~zt1N5`yfK0JIj*T)`IcVb$
zGU|vSqYgRIf-XNp^zxh*%{7U+Uk}4Xc+zM9Db3Km+^-Mjs?f7}yoi+EReyz!72NH0
zp=%d{s$!{M126MAyvXs*8|WyEKo=ba1<}1qSg4Yvt~J%&<<)z(y{~rb>Y2**e2)9@
z8PIL4bf~xLM}36*n=pWB^~yGMQ3MdEDd@q;u7MKvA0(MhH_;_euV4yO{Ci64=1J0!
zoOpZRh%hHv*b!IiWNZU1U4P{>8`{D8LRxu^tsp3z372As>uve*M}XG=U&v0^nAGw=
zU#q}&?_mAGKNWiF3?Wxr60|9P`H7w3B~E7L`?KHmBjEkCUTkgsZbR7DwjLQD7F6qr
z?gI+!dBY9OA-&Vr#aujCqa{}&z&7}rV#O4G*eF(|f9zQy`iRI~d4EALy6`U^2&5Y+
zb;%g8?CbZGI^e{rI|F(=Y@Z}bp4iy-IN76ng;1JY=pNjws+!XZE$@2xUv$DQrC|7h
zuYq9XJy{2I=9g+LY2eehrf11^!$Ce5;!3O3r&vwzf-({EhVy6S>=?^lQ4V`wH}2rS
zy3W~Ui(k!2NY@`&>VL20`Oo9NuWX6W<_9~1Dls2H?B)8epH22txC=$Lb^-vZAN)H+
z?H`<UV&vBV*jjXwnAuixhL3PSK1JhETg|0)zuM-);_G9=3WJtmL}Mf}A>rvW6%Mbm
zTElO(JqH?-$RlUMyn(@Vx1P;E55NIgA_>X~@}1=|GzsRM9)H@k%<f&YlreTJkW!1B
zQww}YYwHiI#|^3QrePlZ>ozx1i_GWvNu6nMp2sc_!YaWwXw2umce*)5<2f*1sZoTL
zq$l?|OwI{bci|sGtn6khiY`>NxUc=?;X)aeNBLGw98w<T374>8q!*hBv!(Kh9Tp3;
zHska~{*dahdw=4kxr*aiQ{gT&Qdzt){3s621YB)9XDp#l#X?TS`a#4JdxaL^;Shc1
zI3eVPh=<u>gukY^!)Y?k9tA$IfMldJl3^6sR_2zw6(&zipTzW)MIELACBo0VMixsI
z505n3VCMK)%v`A0=%+^G3rZl>uaP#Q6%6NfUx~E7gnxPGwUg4ybz8X)+~s9yHeJHd
z<AE?)IL(^#1*BBP`pOrs`NF|@zF6S8_w_L+MKM=)ZN)?p45%9hnsbO3JVYL7&0($*
z0FjEUwdd!{IkYfL(+4)>1J!nr>iV7>!&AOG_#VyW2sz(r&!70P$DZRE;POTsl`$#Y
z8~S<LRe$=5BZN?~;o7pBdSF`dFWM-qo0J_75;mX=N9xL>9iL;<Jk&A{bAa~_ob9RD
zMm$LEmj~t#&s@bM+Y~>aZ~-2(Cwu(;Jp6?J?N(tS=FW@odkSm}95g-sbiIEMPgI_6
zgV+}LVRi{7!lkD83g-fWawlv+RGNPT1KmbyYF3T#csOxM1%`(D*fJzqezyhWZ+?8u
z4T4`KKNbL2{5j2C4JfCkQZBB!=42Z|&`;iK#0hK7PzQfX)0Ple2VWXmX@h^7gP%;R
zU)i}{`M1^o1BSb<mmvZK69PCnm$6L&69h6jH#d{P2PuDA>u=mP691mR!e~Eajf+%~
zdOM$5_tNGNT!F?#aY*xlmbhLWw9=j)asA)lyr{>noEQPT<Zw6~4u`)Pj-svt_@}P&
z;3^G6KaaAj;`k~cYWHx(jo*KHrG(D|MsLCS)7`5d-o^2i3j93C)z#g8DeA7g`n0<}
znA2dpYcGEc!(DQ7?L|?%``P{#sHmx$2d4K={a}whcOI+ZfURg(+C7h4dn(sj@3gx9
zeD|+c|Gb+tinV^B>d5&G-Bl35Xmpiik*~stH}KKg^F@`8{4mTWzOOIrxV;7Y*5YSE
zW$|LD+J+62`r21)nNPRv@#yGg7`p0y9IP0y-SdBM0cP8^$J4c^(_P!x=2~aFp-1ZH
zYqfjBqE6<)GJhDKZ!`)*KhD$(H|n^*vC(s(v{4_I{^4B;oS`28D{^|F5{WwW(^NBS
z;=>tUdvT(7zvEu)|Hi7bJb%3sIIBwi#I5m1FB=^WmiJyAPqjUYVGLUOwX-3T9#MQF
zl9PYcVMQP}Phka;+&!;D1e)uKacEh5-I|hBKwWrRzMK}vei~<P+7YIKKIK?juQA8X
zg%Yqzn7bKdPq15__$p1o4v8P6JoJ8mZ7Fbxs+YzCi<d=&I2gEjuH8yw?CqvGlE4pD
z;ugQD_TJu_VRR-*^h(nN&Sb$XhrkE$?EZh0PW)`%U}wN`ozw4NHjl{*lgv-U81^6f
zDpox8`+sa{rIa7VkrV$?rNF;*rk2N>rU_iO`iWbm<?Cmg(hc!1`5-p>6Peu>6=I?#
zws?8sUz-Pl>6TY;pK*G@$FB6owlAIC-3BuV6m;bFU#ikUNj3P4*c&LQliXLCzDj=r
zIDD}C*TKPYdkgjra5xuAntz)8$!kxj`R6yR-wa+_pX(Rqv9Htch59+}Z|HX}^lRW1
zh{SX7QURmaA3X;^IPSWAs0vea=LD{e4%fc`)Be29!X21Ehw-j#`L}5YY$Uq}+t?1I
zsvWu`QaW2e;2>v2PI4w};JqdWj2(YSm=wa!q!3tL$MMe2K5J?gy;!vuH3p}SeMGO4
zXk<Iu7VTr<oWz`_I~Uim{h{hl=zcoc{VI5ji+;IAx9?Dw%+Yv4DMI@3#0s|Ez!ctS
zn#x9@K^sjo+9()^w4?pP80{B`=1B3SXX-t!^dz(EQUq7HBd5#3Hml9?-ui#Bz^Rhd
zRQ(i$DoKk@o!#5cHic!_R-A?~Xp4dF@SqWfgFy2xs5PAv^-id?a~_XEyi!RHTB9*W
z;d-oUH{oFD!ix=wG`K|;Xdo2hMq~}?w)f!A@$SEns|fr!{TBypK%qQIK*k16hY8%2
zDcapk^0&gA2AfQ*XW-f48ti|0xK_c*Pqs>ah=CvvS;&&usD^8?myUo+Hxude;o-#o
zN#OHu*-gJ0cJhqCVd(_lpT7I>+b{2LfBfM6`rF658*|^cHRNn>akFoS_AM%ldJcXK
ze*fLp-gOFw4U+R1ALo7!v25io{~>o7(Z6yDN7!1QcNhhdk>m?Y?uCDM>9+X-p<vSN
z064U7J8p=ZNsm1639L#D%Hl~GH{81ULwoXSxz;t4z!=_!FY(^a&J-Xb4j@8}_uj^V
zzXpME2*6iE$eT7EM=MYZ<9v>%QyfMv@dOmXStHPTNVgqv=@2-^wtxW<y#aN6{UDG4
zqIjYYbl|#)1|6LikN|&L9!L>r%d03C(54ylRmU!+{X9;<LL8m516V21`R>k5Uf-O;
z<pT>jhJWDTy{&DqH$*C5cmwthZ9lly1!(g?<!(*3%B5ns+WF+&7*DqDK(I`6TTB8U
zt6tVFAqg)AG#~bsVF1lYOE>&WM#RRCAAbfHeJ3;UG*doJ?C*bJ2o97TF@@MZ<y7K{
zi+d1WfRO;b=^6OhZThc3{9!Y>)*70j+p+1(z1NPzX&k(vGfiLf(QPHCVeDs9Mq3+>
zU#KCv2gE+{L<nOuEVNb0q@jC~^n~+&oX}YSt?3fsyk_ENRfO))VzOM4rEB+@oEIE3
z4HP>j+T4_1u48{dRym0WB4^~4d~g^*#fyYu#Nnnehn>R6QI}k7uq&Rfx3x%ooaW;u
z9A4EFO2M-IG%rQjm*Jfp-0(F6-dK^j@Rx!MHu&<=&_PHOo?>TlgP^xJMO8yQqT>P>
zM+@btSO~_;swX4GZdEoCjF3ra6(g!td;XnGg91c9xnh6kH+x~Qco_z;w{STG&L|H=
zi6`NfdJXX&$cEejTlCyo>^xs$7<Snsqd0TexDHszQsV6jtphf=>>FDco6^;sp1Ckn
z7G@g0o-My8FUnEw;Hd+<*toy)u14HkdLecIn-1KfJEU@U3T(^~Rjur>A)^*9v_?9I
z?}gN&ZSa549`MP{0|(bw@A>=+Je#n|0YE^bOo3jW7?+}ScN8e0&K$%dN~cOp*|Qjd
z^&Jz7v7^&U>9mM+_R<6~P0PRQFkA?6mC&OAj<YaSE=!3~dY;d3_{JKvm*#o)X#d>~
zlM(2#9LbXcNu4!4+ZL#gQ)<P}5oDm35p&Y(i>rT13M(y6W67+Nl^?*E=`Pm&D~JOH
zf7Em;ovc?ec8N8gJ=n>T<{pa+VHOC4;R!u4f!qpy2@37No$<uKv%;CWc&ujYU>#8+
z95|N(&_R!)->r}pYCj6+ateDKEXj7r2vSQ-*m6yV&|-*8T|DG)+R~aLg;QpDaHLa2
zlK6jE9V<x_GDdKfO6H6dsiKnAgv9W!&~n6#sbVc8#!S<hV&JR?NT#<4nPCPP_D~JI
zOm0e^ejxjw;0;O18X*3khl=H;GYVm+FwK@@FJm)4<POrn3({dyhMlVKN1;=~2fvH7
z9jTPGHE84jG_`%vRrh?o@WJQ`qoF(%@t1!b9b$MjtOZ*$y&#afpViq9)(X>QS!%OD
zaGuPCK{UO{u`O^D$O9XGkBnSFEP<%u&U8b8rC?&jl><1U@i;#!q7Xn#WHH<Xkuxe}
zb8wfN(ya(KMT4necdVEi&*6_dc57GUbT0Q!IDq3XKnD96c5DO77qn^UIo6Lq-F|;~
z!%fb@5*PQeHAgKX14amtLl<`aTG$p?AXTC;(E!Vs_ewUG=nLh~b?><>bU$LX1#-6|
znsDp~CRYtaQ!IC5XU;8<k>7w+QfdmRc#^9ji7GU}G`lBJ**$s42#iv@EZur#1%YLx
zY7X>|=5)fu``NNnu67&`G@#1qKu&+vOZ6*XA{=$u#@HgKfhk=1%DDnNI4;W#NSPt;
zFC@NzQ(>xGi7fIzTHl>F%Dd+X$Q>g}bS<Fuaq~TiRVOdf(ZW*L!}1xnLei_I6br}%
zrPzSS;lM4*t%1*Qw>I$X6d@R>r{WG#Dp~CDP)&&;k_VPi$ufl$@~};43cr7n;zDbo
zQRrS+YwzNxT-#L~3Nu<ajB<LGM%fgyBoE1_2#K6UJ(g~s#OYkprmpA91|xLS$0Obp
zF*!ZifR&&MI4(d3Xkd{+(4wumc%ZqcF)5jeaS+ot4s6=IPGUX|odBRfw7@lx$nOPg
z_3eI`UeUq}<6Sijc<MN@YM6g`mKZY;w0-Ez@yNF-!NYAHMtCsD@{gQ8;0PCJn>pWR
zInM#ISo!RW+UUNqxsQ;PiT4G7PcI)F%XV-d*(Be-1;40oP4B+SHLkcnJrOtR>%m50
zU2$RkBc)g!U_<3<>hv8Z)c73+pr(3JZT&p~P`>y?w|<vrelS0;Z+d^*@oH#}E$OlL
zbvC`@`8x(LKyZ)*8=r!3lwuDy40F+^p_D!iVcj{!R2#O6;SY!TwLtu(NZ^l9*<$m=
zISHQQG?KYp)g|XjS>T7s+2j4P&L-buT6s*Fx?VX(I7{uU@C^3vVdU=zQUr$>H~p7@
z>B|$NC6VN}Y#Z?u<3=^a*(4#@tS|?@jwb8hfJwj_y|-OCNwlBm>u;%-pBD4Tk0QN#
zCrnNd>zJJYKS=!_c%`nslc9?fmwyuh6az9hF_$q90x5s38Oe^^#`UhR7&w<6N2FLq
zvPkOY#8Dsv0Rn4owhuLAahfrk>~PUof1kH;9k!Mv7z}FVtG92h?gIEzcUf?kgrT2B
z>0N$#70_<?bjOpQ|NctJJr6E=tDAp$c=hI89N($H&w@<dJ(O!u55?Utr@x-<b#UFi
z7lz@<yuE+-q9{K7=za}U)KtwA@Asej!CiV@JXgaRXVIx}C7;}TD$`n@w7&oC;ip%B
zdzdkbwf;)f@#ah1%^G*5Qa`;jY2>RgV)WnU?d94wt{DKkSjVSdgE+wdw`Em3-uljd
z2RmvxU!OgG<}9Z(ItQ}$ob*)ar+}cRjIWZ6@u`1=N$%fc_3=KAPquc=y-rU9?+>kj
z+7fmE>02lRkatPsM{!74saP?Lm&EeqZQ-u2DSEGM7T5x81{i!ER{jN88~$$jn8ZkN
z0Ms)dgV5KAx(4CL{F?FMX$>%pK7DA%E{A8sBtF$GjQW(@p~ClY3*Te7D%b#4F|Z_!
zfDnIX=+zGA#$MbJ5+?ACPNu6jMXpusD+SuB65mWZ_;7YdLe-$AX?o-JE!^0E*3XEx
zS0*mXV$vrZdC%6eE2p-WjokK5ZkBDwli6r-QLsh3f|nmFdx&zP{WLKXB8z<=;jH{P
zil?iuK~y0i)D)yUUKGTBJgXz$d2)^G0OfyAAh#f7Q-N`88kf7ix80}vG&=c!AwYWH
z@G1Bjb#grKtIM^PIa2%@r`f5W^aHk$%GwF!=L-3Qv&VZ6Y*6l$?FeYXR1+ilmFWqT
z5Y39JbNSE$QU}Ihk*$&D@1kh(ki6M;fLN3SET;7>L|X2YJYHJDtQZ05-B(s1kBEPK
zvciY9*$c0rYr!248<}ZAlnFebWA(gG=PDvi+<2mYw4IYUaAiK`74kVJS*9ThA5VYy
z@Z&q4m2C}%3OAp7jue*n&$dGR2^4@-lUGD;;Mk2UJ9Lz1JIJ@w>xJv9CsJVo(DE@|
zB%RCrKxbRjm4E1NW8b8+>Xubgc(;G`+!#LrMV8B=Qc(n+$QC@aJWMKp^RjDYR#g4(
zI78b2O)hwjN^S2!svqw~FX3v1o*pN&t6&JOv|~N+VrXSN%V}3VojJY`4+Ptdkgv7P
zMZBJnPE3l0Ng7Pfm;n43nq(5H6#_|!Mp6R0ZHHn01k6?^a!+`~?7&Z&cHn=>Y-+e@
z7aF_gt{Mi{@ByjsfoMXl{Vbbh^Su!7O&EDhMi?Z1sJ3Lv)&BcKZx#DVU{?M;cs^G-
zB8It43K69pYZOkpq5v0tdvVWaM>+`CT;0oot%vr>fgCzcAn>#*`HZCl8)HwY6>Oop
z^s;$fZXK~8RDQCkr*He>FcyD>Y2rtj+DB>he{3NYCmv!a=Q%Ygs-cyH&ypjAQ@IQN
zIUgz(SS^;?InPNdGumNqpJ?peMYPNKhSHdfA|E02UQFBaJF}65;hZZ8zvpZdS>*(;
za>A5Z8nTD)dhrcIb#dZ-*m@|%x_UKW44UU^-dY({IERIB9TpHZH|Kw7Z<*mH+Aur@
z&D{AHKqfg7j?%!1S%eQ00Ej?$zwYO@AKn!1W0ku%D}Ro!Uu`!L0N(J(X_?G7iwb{_
zT=Ir)bV%5t&ZjX>R}q@nREofdBOzd9^bd*GCIzyYdh>#KbDQ{=Cj41L#iY%I@eb=2
z?d-YgXE$b)uSxg+H&yE>3Kg7xVkpurm_v+tJp~uHQ>s*yO1w1saq^2db?g7CN$jy~
z^TZeiG09VB@X#OEy2`5otrpk)c!do#BV3^s=`1<5kAtn6X_unZQ5vX?pQg#Ts2YeN
zUZ>9ihG%?({RGY+{?Ul;5AzxDC6X+Lz=(jdj+G~yvpVt!#LPMCpCt-^@edQ*7%XYZ
z3#w-0Ft&OiX>f&bmLz{C9bx$<Mt-w+#L7TFb_RF0g6OpaN6?OaEgpc=Jm;F7JGv<)
zNU?)ZeYKtK4H`?B)ciMO)~*EHGOZ}R#8GeuZ;kF)1tulM#G{I?223|@tm&S<O_^@I
zHz$U;xJi2k8k(qY(9jHjY;H;8q)yp`^}-AaAidMXuhjowF5pl%bq4AF*mY9<vsq%X
zgUiL)^6p|V;cPJE$8abnx6?}Y-3fFyC<y2fosC52>B}RYK>$f&^;N~47sjcdk`b&J
zQBn>#>m;cuCUTR>+2&=2f#>Zg;X1F|M^Tkdd~mb`?wb~WvvZ(-m2Y0Q4MJ`kpaQCs
zS2{b4owN_6v_7CX*w^&rV3KsM#&K@fWeu!9VUp2~yr4u2#-&IqKgnl2tS}*e-9gbi
zgPy)#QWCthl58Qc=;@5(INjHX$59@cYCq2A`2VLrABS5%PUbrk5_#K9iFSrzKiy^8
z6*nVlszm{pCa=eT!tuiLfZZ$B@@8&;@m(0>09l6?(DCl$Sk;htcuA%yjN_ivwb_PM
z1fu7$v^DhrB4i(32DtKWBJU<r7zLY71VK;`gSz%A(kgg|>SYBIW|OPey9p{dK>Q>h
zJNdLJT$9VD&@AaR={Rm9V{xnothF+8`a#}7bfLg4w%5jg9=|-2X=401)L)P(MAKjn
z#;ZDqFz6@2f_8-2R<OWn@QkEtkXlfJA7F?@_a~XQ!n%c9H}TdUU@b!B&q$eI^K5aK
z^Km{QKLIE0BU<X|Ul6_dplUX7I$j;A5&^EDT<L^3vI5$k8v?st2m8w;nSvEBph7En
zMx_Q$F1D$Eu47HE2R(UWCadhLLOvsfCGq01_<@dB*RGxEdW|2ZTxa2T;@#mE1qs-(
zIX1tl$66pG+i(P@Nzc91-dvhCZeNK(f_!$87jfB#8LsVHNhvH-KD*;}X4FG`%h5f(
z>;p-9{m-s_>g?s>I%-qsQ;+@?I~h_sN9%$r!X|Bh=gP6>6K-5!o!uZ=ohWXy&1h0T
zGfS`K><(SEhS0S1YHw80_*22E`&yNAAh^-v3C%iuBdU~$tUWNcCKG-7*<t5P%qUEK
zh?N`ph(Js*b;OKXRjr166oS42>qai9jiMj{11J`36F*^ft!;x=XA&vZ4Yds#hU5Nl
z`2t{nc^1F&vHxyX7)WJ;&!e`Ur<#ZC=XXBgUnlm4(>v;BL?{rf!+1dfK8?BYgBzBI
zCCb5qSP3IK@X2-$1g|pXM@wyM1tQWRKSHHk>mTM`fgdH|x?qGtXU3`+y9L5o(3-+c
z3^(7)#dXh;M5_}8Ip)qo3X`!T-ykq><=|I;_%+xBZ*r)NLEtY<tuHAfwzl*pBx8r4
zgyv>xVW*#A^o+)W88=Mv7XT_D;B00>77G&)A~>vGXrKnH97=(m`r7D?Ue8>MQsx?D
z`8o9j8(y?n4pTW})`<)(*vsOK=%Ej{^cacZIOzw<WC>)+<BHY=cFB!tL$##@06ay1
zJmvE#WuBZlZq5No%JaRxuL=^X(*y)&zpl95Cg+qfMh7b?W2_~SuySAv3a+?cHN3?J
zinGwi$_Xa#u&0jZg}WD`k-tC;h!Fg>1+v)>&h3A1jY17cesTxVJ&dC-{Ny@a_LkcR
zzZma860N^<_yZ^8Et4Ymzr7ZR7zxZOO$XXONw5mzJ;q8y(hjw0lKDCazku;{*;{TO
zV7vp#ZPe-A{{S=I2zr<Cq5%^DFqg5B0u=!=m!OsbDt}s8bKJNQe)q3XIS=8uOo{*q
z9?sLo8z)X}RZ>~yX?GtmLyU$NhaB^;tbd<wbc4s3lAUsu2E@fiA76hBTHM6&Puvvo
zO{P>-B>BzZ{3>?6-Te(U{`2=&g6D-WF<i|2>)or{4_e=dI4a^o+}s_PTium6zXk74
z<}%oB7k?_Hg7n=kOcEXZY=4hM(p1eo_4iNxV9z~0JXXUATS-vbBaQ4rQAjBRsdj(d
z{qxn|?k0(}ls_ms&iqF93}jbP48pVQX`VzvB_w+qsYoQdP^U7ejvz!39@_H-gcCvA
z*k%X6Ls;5Ncr;aw;%7<FUWTe|P|j=BfbK*VrGHA%?suokojCPNT>Eh+v%v5`XV2|U
z=D`>IV^M&T1}dKY)2}~&pq7e2wOR!q2e&p0dV4kvt{bXDzp-~+ovXoK?RObFI36r&
zdrLj0DQUlQCxUTbwIlC8w0K5$DA1A?bSV4vQk$xIi@H#}IMqSrq{7DeQroj7!3-Z8
z`hOp>!|<eiXUzjS2Rs@2IkmOrJ!o}HPs543Sr^c1_h_@=lRXU70b0aEm9_>gX;lRO
zuC0L+ZX95wgDbZ$88KZNQK1D>SmkC{$M9&)Fm`s!;Hhi+xwDlO90A<glo733dtq4Q
zkxukYC=+;<UbvzrS9G4pZ*?x$+0WQDR)3vSt&+j;lK&-3|HBPoy<ZCsGEnDa5uK_l
zM=Uuc8X6?UV-Ls(3Kjz5f;H?Wlr0T6E$==0k!tYsKQ=UUZhJfnPdvaL{o5@&c(c)2
z-hIaq>C$Mw$2#t<y@nEzf!;-OqX7c4@1cpG9L}>h!0>8I_x9grQA2WxKi-m4Tz||x
z`<|57!l@XXAx?ixI6wJi;jXsysu3QA>zYvb(m~|6=ow$Ck_9yE$EF0=F@vR<{kZRk
zY8VIW92>M$6j7Q2?us<Z)5-5P14{}(=FHpZ1!E>ElF1ZROW)1WZDbLnf0Y>Vg+mGK
zu}$y7#r2&G&ok6<z{8yk`ZGSZM}Hb6tcM|o^%NO64uJ3A#5SdE4wda`x(k?gtV=q3
z9!KaOOKia`fq(=^e6kI-7~LLlfBQra$0@kebcu{Gd*8Dt2xN%}{_9SPLltj$Xq!)C
zbMVlbQa;^6vN(=pmUu;C2;qtGu*;;jVS&&uU7c>=d<Kr(5m<n`l;jzP27kJCY)Z4I
z3^NYwY3_jd=ZPjeWQPIBC7tbgPdHXt;h_w>CCXaWltM(XK++^q3HTggge;=MJ9ip!
zF8`N9n3H2A8SVtXGH||~X;LKoMy4;Rg=D3+{d1UFL_+c_K2$g_REZPV84BF00s$eL
zZP*|yA}Mljf|>7Zyh-aw7Jp)jkG4DWi;VM>1k=F%SeuS|f2sNlwY>Ch4*C9K8LHVH
zMq&amVNZtG3Qz^qsF?hvZcVu*r<BX2hpYrt{Jw2^8&Y7XLPV*MYv=hqasby)yIci;
zh!S|>6Kb#>;X#5z5p<*kKtj*Ko<}&0{o*30qaHdnPCEFMPmfO&oPRW{t|;8-X{Hl6
z5!|BZHLN&1LYxQxa6avv)y{kjvC#<&0XWbyi~`)Zv*4mQ=Zrv6ZjlZ0^c15X_Cr`v
zN&}1%AkmYzG)$xE#E9VW44!p1_1hIu)6=FE#swu)pc*t*67k*!;1u$JR6p#DvG!B#
z*8%Vq0@2G!PNwv%c7N<1nQ;MqhNy&)S!VF(Pzp#;o=g$)ZjuTS3iR5C+gw{nL?}7C
zA>|_lpq!=aeDo3F9(?Zfje$F~Y@rrzm;*tn?oU3|<c`TzJ-6G&_Z{l7bOaVxEM3u!
z((f|_6LK50r$Bcov=wGLD&}A$SLOYO-quGJ-A4BjH=T!rIDhu50ng#d=rv9?kinu{
z6>I-A<);x3r$ov;TWAJe8xGak(h!C2m#S+UpNG*YWgKw+?E7k8Khb1Ul4fu#bAeQG
z=_+CnFvyv&=U2Ad3>@&Im|WtGU-M?uQL_y<NMsIKVSQBR1qB35i=xMI0O`R}m+_6h
zJ#))}`?4<MN`K3R08V)15o|jkKoFqE*_+_u*aFRBdiCfGRlsX#%<~k1k<+=2C8OXh
z!qBxfci0Y-%?f9HC=XnpLLx<WgZYzSf2v5RTd|p8oD+yER<_I_QswC5_xv<<#mvf2
z`*$=GB5=tnL@oeTe01t*MYbK_QL3kXe`+TFfbt?{0)I2`=5gm6hl^(%SOBz~|J{*2
zoh2&L;l)JniLOIVh?=fzyPlc)<Efe<T5>9#mA7Ck)BQ%cVHbe0KRdG~%u|z~qy)wV
zIQF1nvYeSYcJwDlGF_Xf6wmAz9C+T*$>fGzDlnK8O4IQM?|;Ex$T<Vl+~-X^D$=OX
zlbzr6uzv-v4@sk&QCDP<N~frE0VUC`IsXGg6ZtiHG;AF9bw}~MU7(b#>ZeJyj#oLq
zUnzZ|yXsrVo*f_wjvZ!Z?DZEYFwUgDbCj~*B$Oc(Dd{z-<f{A*)qCQK{9+DxIrOlD
z0jTOia7l0=TZaBV3u)z)HeVu^1-<6i!E}Se&3^>srz<jSb(ZUFe8BQsg0_=1=7S}!
zD!VWYcX$hv5FJk-I|J1ZQBpYe!%nA8Qm=*3rxdrvfGU6TkEqhbRfg?-XU>pK?%!^>
z_aj2+-Uns@gp1yFq9^|XY`e+<e+O<*E^g?7l!gZrJ|c^Bs|>@*6pYXS&NUt!t%V1+
zIDfRBz1KnZv!vpnnFp-MHwz%1y)N$nbrt~Ak+0E_p!17UF(f;V(hVUBy@b@UYA;B5
zDl*e^!iYGJa*-`=H-x7<c@ZU9aYc9VqD5jAToFIS2Q+Yw1_mW-K$|PC;8~qLB4)bP
zc%|d&Hd@bajcsyH9CVTChRxYhSHrEs>3^tXGvhT+iGu%S7p9WAEKaJ9e3B$8lB;?X
zUk&0pSbLhO?wPvX-ImTg<Arg5e~P2eu}vh1xti(bp*Fq%Wea>0%3Bsm3-AuTz(1&W
zP#X=&G-(SYL4~lW4g(1yp}y9sT18Wj2tY+YYdDD+HnEQt3oTUa*gLGCDcs+~S%0<<
z4RBq^iA&yY9tnU?PM+D@ivgT$JIYG9yY~%zW9tRs!V@2$@b@<8t_0(GlR5!l<069h
zugra_0Gc}n5W*C^L3|{hhE3WK5O>lq-Z1hFrmuWTx^R@i2dpzONa-pQ)7k;uKLy%~
zm;JbCW#Tnl0ENu;ROX(a!n)dT-hWnsC1*DOjWp9u>c%@l1%9N`wHj`ZZF{>n-7US6
zf1YDsA_1lwXA4i%T6<3v@e2pcl*@6e^WFB{;TAY!T@6pqAyKNQMRbLTubF6y7D#zV
z7v9icu^5~RHg%u`5Xf~XT<c&VR#YPi*pe+*Pzi|Zf-ub^C9^f<q>FJ`<bN|P(&O~~
z1Ru_(<ZjNc7rK1Gp64%7ga+0;`_0kx^~FqBwDz1LiqmN(7i!<IGr%i3+4u8U9Uj8{
zSk>h-*WfcMu}vUpSx3+`p)QI~Wk>F*V-B3F=PtS%Mcikgf;^ZMS3uQO2m0hE^&*q#
zfbO@YW4VXwQbS^Mbs~POqJPhSlCLk|_iP?KeV6VQguC0$`U!k<1HWcpbFVM9J=oyw
z4Pea2frcx73*8W7Ya%F;KOt@0(@;r0=k|VLV`^e!Yc{D68M#{6JMy$$LkY0)<do>U
zkY7M|M{}^~+JJc5k><+(e95rqVr9B+J=#a+w!YX&0)#1mVBjIPCx87A;$|`uLSNm~
zJBUQg$oZ3v&iR@bTg(b!yV|MR<+&svh;HX92Im@H++J$Fv8#ELDHjqs;7!<eBDjw>
z-5!{YoN?`W_*FpOQ?<&(3DXN*1P3U3hP8w*LJ@!SS-Qr{_?yZomSP4(qV4)Q5}IgG
zzSv?P@BSb9k;kAMd1U?F5#L++-=W`nf2t!X(jU746wA6EqAb(#lvC-JCB~~ey}|~c
zXWwlbHOkix_@@x`dW7Z32DJ-4SBKN%Yc{)k;O{^^J@F?=Xu;ywj-_mbwWFZ(|1ntX
z`PzSf`yXWTgOZo=q5%^EFgBCHT@(T~IG6GB0x5r3OLN>d48HqU?4*ZkXChh@_1vD?
zrs=e|w!U<l9%L=o=2(x79<jH-z5qe$?XA<vI7^Wr0D>QYPvScd{_$Pv?P4KV8YH{C
zyz%sG^RT1A??2ygBj<vkJCXe1?&kJm81A^oQZMDZyVF$F-EsGq^W$T7?qsufg%D13
z*t>s05IP^^Cyxh}svc;*y|kSyTY7j_-6M_y=O|CKvUhpv`@Z7``@ipgz4_^G@F?{C
zH@c3JYu}@(?_7Ay4})El1dNM-4sghetOeIXKXeY~EPu)#q^qivY#MoVjep=3SaG>v
zJT%*m@+_-k>(&+R{p5w-yYk`|>i$+$5R!jWmdo3$DBkJaalisFO)5C)u;Oi#kAmK|
zjC|>utkq&*iEB}JrquYQDz|QqvT?h5bPWGG*>-My9w&=BI}Q`p4oVGH?BAAShcg_p
zZpu;L%7Aeo*D8kD_EO&0g`0yB6ZM5@Gpp6Lz3Sx36_;~5xF0d$8HZ5!1X0UFy)%Dm
zuie|~@b=)^jz8LI<bwh;jlqX&aMRAsE?}V7zQyh4#O@%l8R)MyH^6AaP<bw7DXT8)
zR9#)W*0-A*g0*1}*EVDL7Aq(pve=IonUEKC3*u#c-pmwoAooiP!Gqb5*JW8(;8!~=
z_<8ZFjN7+Z&jvyLJUtB7r_W=B5)pq(l4utsn2fea1uRWC)Sg`<cc+`*wkj$2Kqv@y
zL6ovIis%r(R8&E`M@fSmlE{ytRMKO1508mc@8Q2M_@8_a3$YkCVC8Mv4j%%iP?gn#
z!jBSuV&|!~M)usvI(m54+KiRP4Ek2ra2$UB$A^!k6k=|SK0hkbOCsln{8E2My2WMv
zbvd1Q3hyfwcNH+f0TmHMSMOxD6htgep!UOW>Y1)|htUusc20ejBjmT-i9+U!)T+A%
z$CW1mhXx|-*2k<RYglrHNSu3pXObSU(8=Rmpn<@{GIz)(ErLZ1-_t&X8_?;7vw%Lc
zxo+shzR#K9(H#Ag*rRwPzzKhNzR>uB<GM#fk&o>dZFkm*lBToD>{MM#1IUWAK1yB5
z3Xww#K3u#+h@gxH9uBIkl(br(7E87!(<CAe#g=ecCNyma#-IZeV_+f-3{9$*NJLe4
zG%<)Dwc2MqSp`STageoUQTsMZ2hJIDV5L9M$03LfsGS3>f+P^3uM>Z+kXrx?QWgww
z9h-q}&rFx2Eo||G2`D6HTVEYDK7vHMykRBum=_La3RP@r^<fA}VgajUlQkxFHA)iU
znB$oH0eeScaT<t03Z<t73X+>eRpCa=7X!*rKpHMeHXc{k8twp9zyW}x(Fejggjd$6
zwys(%C{g0HUDkAFhrWM61-H{Z(oR$2P*+jV9h>T;)t6dF3T_i-q07rESLA^2P~nsc
zA@N`oHtLIl?7VEWUG%N*DD{MMYU+|;@yaEn0ZZbcmK-2yH*X<g;dr%}ZyTy0yL~=f
z)uB``|E&r*ESPK$uT))+3Ft;M0AsW4Rec6Nbb=;f%bn?afTDlf1z;%^_?pG)wu=XT
zwduan&=*#;Bgz)*CEcFO-e(lx6)ByI$<LeTd1&hXJd()`*NDqN<Z1f}8lu~Gs<7_~
z7&$Y{3i$#z*{JLafjh{TbKP{bg)ugz6U&>0RD$w8zb$IMQDm!GMGu`swj4z^YiWd)
z5l5yl>G32f%xZsK(eJF^&Vd*KZelTF%+jwduOnbT=^#7hcbG$HXiZ%(0`E5=D@4jP
zVkdWU4J~V`5Cc#LcQ%dqAi~2*-Q2*}nzIS!rT<$k;BiA~%2_0$Q7JTd5x!O(T#>}g
z10Sx$M&o<Cw*>G498Pa(K{}u?rU@~DAWetHjg#0ATbh3^vyPevI2#6@mDermLL$!!
zp^0;*@X~ZabhduNhAYi3au%r^xi>r7v{xzQQWu2H>z$cWMWn*XiWccsiXR#}nQQI>
z)07Iyv_IgqF7X=y=MZo1kM$T{r67~tiTEtUF#v?ei@MAp10eDL+$RCBF!HI)EI&(;
zjo?Gy(vp9&tP3j!PGqLX#v$_(F{>^_+l#`r-TH`!i=0+=G(f_mCoUz5nk2+ZhO^Yz
zaD+7lf8`5gt?sLS60WJ27B!pk1A?_TD#BOx>>iq`R)DCnE@?1*w^g^190(4q0@)dl
zEnlU{b0bfh193y3IfhEoAggQ`;i2vA>j=u~6UTpsjMoK;oO<l{di`^s6$*o<yF5=u
z#*BJNW=%cGA>8(YjLG-V+1NN6Pp*|Cg8~3Fo1IGQ4;Ns(&?J^-{GA>rv^&Ox9XtvR
zb%y~_caHCk@HW+w^13?Gr#RGUsW^;*{MhYV$QSUw<)?2)zR!3h=Ex`922eGFA+HT?
z%~w}Ip@E0YN|xu&#tx=|IdoIX9;^`j-t0Hu6;-uKfBb|cYw82-W6pR^bq!VjD_G98
z4=A%xP4)jnPv0EiEPOKduW^TMWuN>0<*E-?C<lJQ_!r=M-6oguq5%^DF_*DT0TTo_
zGc+KVp_TzDe^tS9n=lZ)=PQ_=#7s~nfxzU}Hce-G=%Mwk>4Ac5Gy%j2IgbCnD=j$A
z3`yJZWwqMf_jdIb^N7KZM<t7jG^J&>iR%7}1+U#lXng;2#pk#L0+Wl#kK3#FcTz^2
z(UO%s+U_n(ZJX#P`P5dUQ#MZ0G$r{>oMf3Kx9Xnpe{9gh9{tm4a;l&3aMZ5#Rz@1N
z!<#tar4WJ$8UNaTz52X8Gm=95BXuA77w(*8aGOQ>CZjyfuz_u>fV323XKe4`AuGSk
zl8hE*0U#m#pv`y##Py((v8o@cy_%C=Lh+OqS-xcH2{ER_IL3+C5M!NcypNM=zB|U?
z2QHj+f8F_Jg%9Ti&7VsHmp6FGf{H>cvDZ*{19gW6A=?GJuLh5P@+G1ql^M;Lj1p*q
zOH4JR(`N8b$V=kd%7G;q8Ljb&k281gI!tPJ=rB+ZOM;((zpYI`a_Y%ldyk(<9gBjr
z7`fiFNF`<YxsMybNUTy%Bg}EF?V_M%S}x(ff8VvD9BQ6R_WJ2RN`?u9VP#y*gW@w<
z*M*rJQRKUr!)v2`5318ctE_g_P^)*i5N5Y*N$&^o8w64i(@mIzM>X$KMu6e0ASmpD
zUK+4yV8c=13C}^`CGz=Zd{oBS{A}KuTxDG-=})+k-umzZO5NV!0eYg6=6EnecZxS@
ze~^$UA#jO0>L6EE5@<URd%%mG?>c~)gRN%@{=3kr2@i*%QFfuG)}AOiH*_)J+VrCt
z)ZkzNT{~3$`UWzX0Xs{^D_s;hnQ(fl)}D&rLGOLk6&kPbC}9$Lde+KYxUf4?o@Iq=
zbL}w;a)g&xNCaNAvYqzr2mG)<cET0&U>?06j8!NxAq5qJznsFnQeHm+1Jwb0?DY_A
zSP~3)r6~@>WjSA{;-@&l*Gd{~Rqc#Dt<DzKF@0Xg(AS$#@C}9AC7xDOvsPB*R6c*$
zP%2o~s!2C$qRZdIA4?3of0yy10TTf+mr?xz69O|emw|u*Du10C*^=A1@!elBl^1iW
zMhpRhSMp?g<779ka<ZPPec0Uxj08#aP$a{{W9RGB7bsHV*xuAs4RJJpM&I3#x{2UV
z-4xMH7RO;>@|*4HMMR_B;f5PO|NVs$xD5bqW{|J%U;O!PlH8~$ETTf)-0$aG-S2LG
z4c;7WJGkz46Mx5Xkp1O$V@wj<9~}?8f4JQwY4Gt@1u&w5?ZD%w=60j=VCO3CH+%lR
z`tZYBm{GdWflhCKzyImQ-|i>$60N`U9te4Lkqj=9g<2&>E|TUZRI%ZUWQeH_?h#Ew
zKQn}W8V4U8;hiOfcdP_&=o8-XCA<OKOKJf*brvQ?%716b^@=Dcd;H=~eR-(ePDX3~
z+L~t@Bws@3Z<?-j^{vi=!9zdY0tqet`@-P+t~v44fH%OQL)VP8z>jSR?1`h`bu%30
zAcpF{^n*LS?0K*sx^X*<ox>a96;vFmMDZ0Y?iNQm9}!1c(6q!$*V&<L>fX=Vfv2~4
z860|GFn{jgnhe(Lo9^Uf$3_4d8`)^zR8@m_eB!?4UESxw)qVL;`Te?PV42!B)g3Y^
z4y<2U)`!Ja_$ILA(Am?;b$FBloQb(vV0SwnsNEAc1oa~k`%~GByd;w)IWacm=G)uc
z1Wm^s_t~D>%H4@<q;uH-!iQ<10V_ghyWf{<B7daQ5Jb^K0d9hAKekN7rW<%<?@#T8
zx}<TXt?2SN6Gl2+vh(fRAMtJ(3gWgaTVx>*{1z!wITVT9vlE9wM1cmN@q4><JoHqO
zI6><TLsuo}`$K0zVr4x^4MGr(w5YSK7o4jDv)O^}ghKzoH`?)bZ+L3!t;m|7vMv?D
zyMM9=xnH5biNYAj;R)OC_M4BkTVsJK!YEHXq!2zw!uNc}wsRo-AY~wnQScLs$t@T@
zD<iLdW<c9*@ixcu6M{HdUe*lu>h+s<tEg%af=Ew7&^G1xjHswA{TiOlsVyt74x8A3
z1S+-AiZe~gAQNivZEXkY#OB%rW6zg`iGK&X#j8AeLqouwsG{q8*VBz|lmT08;3&9>
zSX}ZF2JZbx#Q1_85ZKD%DxSgP@ymu2Tb9kzC54npLQ_n4$BQ<#tA{l*B}rH)H8CEr
zUL&~zd?)2>S}|{{`>8N76LY`}q~HQyt@9D+ZT=4=JJ)uucdUCt8(Rw((>#n*eSaza
zyYf@H8!d7y(LoP33-vWlVo@}1lgWU2%U$GRD>M7&R`zIL6H#geVONlx8NUPn(evDI
zQ4+cE5Xzdp?JGY)d%?WATI_af8ZGWE*Fia;Cj&)#Rj-jb0hfEG-Pd_%!c;#?W<1OC
zXXtF*qqnl&MC!>%X?Akhn4BDTW`Ab5+k;6&UxyvCVk+?4$O$M8tgp3TaK{W*N<)~U
z7itRbxh5Snn!NpqTTCKs^>|P-!l__#HWYs0@ML6ZUBlnWrhD{MP}+f3z;f4*)o`%_
zx2aLKu+xk~I}V`dn=DF#H&@r_c_X_XP;{=c6w;72;b?{#m0u~@q~AN&-hU==se0$?
zEqa+1)}|_q<4J?>_<&w~&bGuW_+#118Hqf2Z0G2bB?UEX!!|`07V*-E{c?0@qf&?k
zyPfNBN9+KhRs=K8L8;TFV7gV0lY}abJs>+++_rC!MReLC>XI?}TK-%M6py1yjy;%$
z>dOM2Z;uM;1rHscj+gvmQ-7R-rG6@_id#r2l(c@}KAt?H0Aa_ju~Qin#`(mZwz8}0
z3Bfa9=AlG7Xjjlj_Oh&QcsOto0$!Ou%IPR6L?{v!SqyPsd*r6LGHmY0dONcd3(jp+
zro!B03ne_+N4I$nbrRU*>=g*a+@xWV#W@1RVHCr^A}JU|t?dGCGk=B@W;26hw+Z17
zYbIL(=n^8-I;Ratn1Khk4a<NnF-FIc349V<=u~Ad3%~)aFixjgnC1E8J+~b6ub>Xu
z7i3^Fw^&3e8f-p$qBPtsi$X)O!Q6o%l8}2@{<OC2uw}?E(ZnjBvJ66?<ois23W-@h
z4+G@Dm2KfJD$c&oaT7224rT|!lBHu|j?M4Z4dr&MY?mKc0T+J&HVZ<woMf$9nJA13
zkEz?C0ndE~%o)2eC?2<{MjfMVQsw}BNyo4uk_Row$slj+{XDuyY}E~ah3nKV1<Kno
zp9$iaToQ)l1dEo2Rt-H14dXu7#-*lH>VbCr=<Nh~Vs<hF<|MS;j}>{v3Mp`<r3wNu
ztu!gBlsxnrEx~_SMxjnYRaFrdg@FEuXXHo<ye_sVTIQMwx+Dn7pTvaWEN5ZoOc{pI
z-oBK@jg(Vn^?;n~0XXY(V9<4P{*@fS;TfLoLu*EfGIVHx8JnR{4&L}nz&?|uv86CB
zlF-j&vNtpit_Bg=a>rZJp1YLT6L8ZDxS)bz9GnRzt^a?XefER%Tb*$>nQ)Y<8rYS{
z_#)7_^qAV;gBtu<bD1=a!C-<h%watFum+1=Q5>AGH!@!t8WjYg2hk#IORkP$$PDi;
zFaZ0EVt5!k`v5uG;OjcG{iJ-9Q2A)JpuzQt9Z7^rCWnb_5kY8;L~F&0j011pz5no1
zCiyntR$6~b5nyBo3A7#fepEopgI{j*IFM<M0toOzc<E4SpiLV#6lbZ`$mF?FlTL~i
z&J|vO?vSiTK+`C2pW6zEZYleR{?XTta1Ch(e5rUO3%F7SgPyp>vX;a{4-+?vDKJEH
zh&$B2xcRie?D^uE29<N53!LpB-L(`(aB9+bXdi!Q-{}A}#H1Q}rW(i+qt7gXWx^7G
zvQ^*k*d=qc*l&b7+4|YIJBBd2m^>dK4RY8#t~>lFRMF)5#J<2e+bL5mbQopHLTJwz
zfhj)gfRD_nzy^`|cI=1dRQ^{0hvU+g&nj~a?+eQAGsH7e@VE+Pk{I&D3E{J`S#y<f
zXbOLI5zS#i8RIiZzRCSUdJsh^H1aSlVks+!iVMr{k%KLjkEc@Udc_zVh|=OfrUbWG
zM1_!t=;9pZEYxES`#j9kDb%?N592r!g88y8G;9lc&~}^%(hSK+d*)Y8KAgUFKUfKF
zd@=`G2dR<!<c-~8b1*?N#6|2WQ6#8_zq@~i#U@R|tjLy{gozMXG+%|{3<();CC{5>
za#i`r-k&IwnngwiPA*v_bRdA)Y9y}1G)d+mU|ER}QgnicmxBZyKFwY^aU&binQ`$)
z4y_uyTgbmT=kt=rYEQnHDPe+ctm}zR5Z$+;7&U85*VHF@SNJBje~?10_davVOyz&1
z8I?Hq29AQnbTa3v-U<6*SFBp+B=fZQ`^zT>lP6q*F}XRL6dYxmkQ6p720NahDo5va
zKn0Ktg9QbDl4vfAArRK@%i1rY7#t4hov)}s=ZT}-oSa?h*TL0dM@2B~l8`rJCHu@`
z`1Lpo#km<NUC$N)vZM|acb&lU=Z1fRCkm6(oJuS-ZTa&6CQafJ>~iXqPu?dZ?}H=f
zvWNu{;UY#R^@MDt){yzK>7|ET3!q}4(xvghAqhYYrUg=sz}~L$^8$DP5uR=JbW4vO
zk8u42QmZRjpdC9|yUKo?pqMl_v&Sard@5J7zh#*9wXzMQyn1q$SZC>-yL^Ae#Ec>Z
zH=#1DCdJ=)$@I{h8TiVx?B%9}z^^mLx!>=6CI28Qrn5`bG~_TUSKo=6hyDg?mz#Rp
zsL&t(pJ~qm{(-rN7!x=9_4nvz2jd`RVGJqN6G5G@cm&_-=EIAB^MUh(tw_MvWk8TT
zR3=`ORy3OXG&N$Z5^b=sl1G1HRsI2?0%TQN5=F>LD1A!KayZq8pqI?VmttFyJD%f&
zScEmF>;XHtvy<0`Sj~{pIttDCVPNR&C)f4v8tXU%W0=otnt&ijm9T&3uq@0Ho-i&(
z3OXe6dzs)c=dYN)B$)3lFeRg;A?iyM=GTB&s-^@R>?Qkm6KQ#z(ZPQng0BK~tYEtd
zL%w#jxMdNC(fPgeqIfpHrAeTf&(%mu39vKYvFDEECnKpp;JFyuWRxKD!vYRIafvqK
zhl*>wP*l=$jJuAL)*zL75km1fg31$KpA9jS1`XELiw4BQpbX}Muu|W}_Y8jLf}lA@
z_N0=$<3K~+V;1@IFqMB%VDypBZwG-PM&P?CKF<}wBcW$I*#fOJm`lks3v|*r%r!7{
z3l1M}$HPIM7{CdQo!E7Ln?n;^PikUJzHkV$yPd2Y5F3ux3r^aRlcz?EbHQfWNG0C*
zCnXrD9hSv#Xg}g_5>`qyn*y>5h!68HNwP(W=0f2Md?lMHJXe2GF`RO~Kn6R`<Pe|h
z^s>~sA{j-fi%EBx&`2VBCna6shYcn(jQ$fnV?lLU==}>H%ZC$5aBNtquxv$)#V`(w
zgZLAIjY-nrHx-)+?H@P{QNir#-bnI;^Y3hT5YP|o=I;I^+dSi%A`V7W1X8M#Z@H$(
zhc0JuGRF(DUu=KLj_GyzP?Zgr;gK-poJ=%1ry|JXE9CI?CH-F982Ia`EjOI}lHkH-
zH7-Q8x!sQxDnXxr%2WiW@^BP(V)rcK&;difb+U_p5xOuv3d~A8w}~r~3)$N_+Y6b4
zuPO`?4@cSj=ubpRK4VRu2Rfvy)MAljOnuIe_C5}EmM?5omyHp6jH6f)&gI0LLCV+3
zj~+0@<qRxOre!A3OAm^5pL$C+D(0YA5aigo6QI6?pj8EKn&1YTiS7&cgv?-|YSbT(
zg?Djh)Ro}yaqNdR`&2gr8ye6tEF5)}*eYL?AEYddqWC|05dnmk@uC3}0Wz1dkpdG0
zGC4Ohlfeflf6W?QkK4HMJ-@=}Lu&&OEAc~=^44pc!xgw*(OaMompo`KuC2zF3`x#*
zQS`rehC|YnO=tJemm)w!lS9sMzGt|_Du;i?s?Jwh2v*B#wLQMe?d-T)(ctgjzbhPE
z27p-v`Q5|2-+xqURphMB>tglr6d(1_u6|knao?O~e=}|}A;emLz^`0C><vx)^tj2C
zTL05*XIeQ9n~YcM)*J|6c%ttge*V)(SSe&K)?9BsKm6t0pC1BUit{&K03lzwL6J*X
zm8-IntPql}LHGqP*W01r0EKhY^%KtMbwdkw`h3LyAMGXVtzp650lufvWUcv>7qT}k
zUI8$de+$gDV7wMUsl_>*%-GBw;3L=tl}a%n)Prsh%`};b@H`D85w;zU$Dx1ksO(!>
z2G$qruSllp-G-(c4=;#imGM$AA%RncV1=U7&pn-lx60w>)0fE&_YKI6>w5jN0TjcT
zejK~q9)G*F=Z!^gx#so_w9*dr`?;I<H0oxyf5{}k|Iiai)3zP*0B*tS!s`JnSUG4f
z2b}o?(rO;3d2F`xZ&Lit-K~nZ@K-Wj@EiW}I@}tlIgP_^Y>r1Wx}|N?)8ITA0%_dJ
z<GDMuUB7d`4y5N>WXczR?m%1GO+i9JRe^DD7Iz0o^RL<T6Hq=elA5D-alL<RDzSEU
zf7W)>_B>7WW8Ry|khyien>vqf<Wv{vgU>S^Uywm$g=SiEI{l}U({al|cXBg2e4Ukz
zRkGoWRkhaHb5Dq;muWUfx9w}!B+a4HOzCoI4kjfmnX|n1aE|62tru9r6%$<0(l6he
z-i+Or&_01)Bk`Xv$O~30#qr2Y$kN_6e}%o|F{rGWsOnp*%|tHI22Vq8`q?3=7dPZN
z<KT$g*58h1no}5f&2$yOy1tv6aW|z-RDxB}fyDcl)CGCPiYi<We8$!|4<HIw$}45E
z>sdd{bgQpsd>kf|yi=}OS*t)ob8xzp4WM{q=17`SaxAKvaUqwe{}-VRQ<9yMfALEG
z9|=sS1cvrjF`?wb7r(~Og#|&tWO*S{ZZB;|z!)hmWaH7ni1peeZy+irRb-{HUq~VW
za}gKr_enl0R+fQ(<SbHW3C@%(7nXm`gPKWR-6+KJ7+_OGQipD-Dr{VbkTkvY6lz|M
zG=cFofe6xt@{Ygw7MDNeD(_~(e>lw$rKbfJ&}mV#s+QM63~V;p&}YOVIICbOe&$Q(
z{ko7qErp61qGgQ?!O!#(B{{<ZCo2~eaoIzkFl4q6w<`sa;V@wALr4nt2r*+CXiq$!
zPKPceMGMj)^08X;JGQjc1_ibh9I?X;Q8i^5z;0IPV#(EG^98v1t+b$0e@uxomfiEd
zvr!!GBq2yYcZUOwwqU7AJt-J30+kjeq%a`)ZBkpb1oM&+#)6K=Y{8-#4eA-q?cLx?
zz%ZAu2h6ogn`<X^B;yh&gE+ci3A#fPH26eH;Zo{SGC;d9AZ_(U*i7x_2s_`JsoV9<
zJdBv4+N9|WJbQ^YS6~vOf6bb3%I38?p@29^3K*Yj0vVJe5sk4kC98Rl87J8Ja5Qsw
z#9dfrH1s)i;Nk5E(|G(6MGgu{vXe`a>?(IO;d-EHarktm4UR+FamZ%QxZk6s8(gKY
zL_7;iXx}c+!TKs?O5o<Sc#|bntf~T}P3ySO&ZKE<vsL^CTuUv_f0?e!w`;j(xd=vK
zO~;=8yvHI1M^?`%fp%E!;9Aq|+@-2?`7tjl$PoEL_<tQx8lqNSbzsyQcU<3^e%o0M
zg6U&}!hNA1+r}pMw9yT&sj!O!eM1=4J{NX-Fnp)BJEY+pVsKjgSimVV4ET2QM1xzC
zo1pZT(zyr(>CLm-f4rm}q7YSu<jD}?(dwq#=lu=VDRzSVIga345LmgMnqyK2MOni5
zO-h(~*u}k@OBF+<#4vWdu5Wz9pf^jCa3Sx9r(~W{KxnOQlHi;CK(o4z^Mh2ig4tg<
z>chqPFHhn)j6#%@I`9ojJ#<AFEis1hs7%5i)(mlA>1=6if5QNLUEM}MMuQ5_9XyZ;
z<v#xEp6F|{c^vqrONRv~Md201Wv10tFqk?tUx=N04F&N`BSK}B2Ws~+SNC`gm6(+B
zEzDMza_TO#)g>sVLlV<m$BfRga<?sy3LUMDGnMlsI0yy>W2f;HdGNMF)7lai#*`lF
zAO(BK;4}7|e~IEMR|}#Maw!@iRU{f*MbY4w3N2V(h{kJ4OF&*4Fm%$8DwYODRnV@-
z^GrbA;mElBhAmXJJFKy%aRvvd1-Mevf_QZ)?ufU{t%rS8x=?nOi_B8W+{Qyu+hB{L
zDoZCST*KrT7boYZwxp)fPWT);a$LpQLEF$N^T>jPf6o!@Hfu{Vzt|Ek4>acmW<^?6
zj4QpA=t78P9t%;`Bt)1cA;QG9ec4G%Y={1Kiz7p`PLQyBX;zBg<2%<i%avF#K68@1
zsXR*1&f-<m;!6E$KPH0A@EUH{3V$#K^;aTv*&NAxHSiii61jIxxpQxM?B4P#_m&6u
z<{fD6e_UKH@0t&;IrG6Gab3FVKXPVD-{JbwM83^*%^*0w!gS7fS^qkJR&j46%0~>v
zBi<@(<`rwSejHP65Fk8&WvlgbxaR#Fj!7^86a)j4Bp4W2!CX!tX_we*`-Z8grK#l3
z-z6<1zxcOc7HVM@G=Vi3P-QT`(df>te};u;e?-){A5@|>{f_)@O`T6zuuauOdIdwq
zsh)<)p}wOAAX~2aTW#;sIHC$kQIVs(-xHPcHl&sHd-%QedsjPYWM3H&Jh*lpGF$DP
zyuO$jj>$u572;PdAn1#QZeOAoWLFDm3UU3GfSq6WU~?-`nDi1AA!5Pg!sHUg%y$sC
zf6|VRRr*c2n=XTh@D(Io8Pym2drgk|(l>2RCrl);NF!GjTOdw`3efpEo~kkIdf(Ez
zeJ(K`x;a3;-TH<gmrNuIbQDOkrU&&E^_%rmTw0cML!}DpQK|9i3X}%O^%FyA4Vp2X
zSQl@T4hMyc-I~=^hs0U{#Fc43oDZ#Ae*|`5kDwAB`tiK6Q6G1l`#ngc3y)cXGYN_u
z>$A)J;{3@!FXE)Ndwhe^<@(2AH1S1kLRAI_N|h4qrWTOK77+g2H=*Ej$2%MHS>9-N
zV74G)m&i5lobGtUP3O6JJS1zrM=C>80i=wd13iKaPNdVa`#sbGoS4>eOUp+_f9~I$
zuswo|QLg<23$7S}!GRpDC2gX)Efld`YcH5Gw!8%0C>FZWW-ecV1X{~-dF?wITR=#>
zR9qMm>)M$SC{0xJP-@cM>)J-$Mb=F1-2!mg55ZF@8p2>SPotUk#^HV%hhxA?19XE2
z<9jw)1>*kMnCpjZSwdc=OJEV2e^33&W44FRBJjk6_VuCm4nLc%YYhT%V64LNUrJW!
za$zyQ{Mb!fb2v1;8P2Zy{)h(Xo?@oY?`iVX?3{Nmi|d>5O0XOlT|hpq`D-`x&{+hY
zxY_lg(feOkl+woLWn&D<9$YXoE~q`Dk4~rtR5Vdg_*O$-#JQO@2Xt8Of9Z92Pds^{
zc^C8=_YiuXAahAIsI_8Mt(Q#<G)~aarw{Ykd^IDsp_J|5xaLh}->GSmR4wb9qp?<N
zacH0$Sca)P;!sd(*R_2kRfYRY2Mu;!V9vwWe?uP!MjZZT0nAg{ev#mDvnt9yd^&Z_
zB8ur{_;U)|S_0Qc)wfKwf52e1HPd$NocDCj(k5<F`9u%>xL0K=W?c_TDhDd>wJ5p5
zx1r!Pk+DhJFIiaz>7E*Tv)?GdwKI&e&WF8uxhke_+kWl>?zJ10ykz-RNBRz_MHRm%
zzF8G_sh3lheh-0-Hd02`64cEjw2JjRJ9T;WjDx;pO5Q%KS|v<6GG7J5OV2EI=A!J0
zbUJCURSf*^SC6|8IGmi;;RP9E=^8BuhZ4fpf4o(pm-{c0@qv4n@uC3}m-A5p6az9g
zHj@!QDSxe6OOxcb4ZiQM=-P`lRok@q(!)7z;%v&fI2Dg82ipftOFdGomfDhf$6NXH
z0SHi!ZqB+BySAp90x5t1@%TWk+{N%u?(%q-YAte;?GC3mv7-*pI~x4+Z*L^8+rz^B
zYUQ6F-+cMO+MSF=9_MoRcwDo3EO$Rdf2oV}RDTT*d#!bpe)X_7#zv2IMTBpk9`-hg
z{{0{$pvdSj5&hIZ>{S+(RZGwPk$&HQ_w@&ukt$b_${v1t{QH}~KF-^-O5LdkuKW!}
zOp=OJrMo0ELTW?W{P6ABZLAuKsp-3)a0l>WvXfHe)+&5)uTy$6rgskg>D;u{zCZKo
zjei)GiEOu*T1ZRFAM0j(*eA+F{YDni4rnFE(3^}GPiRscjQrN2`7xHJDv@g4CV-ws
zeOGl4@H+{3S<5tfzv!^ul@v<qS%r2#_Lt#M?T?^INR2EJc|NayY1)={^F*5o$=K^8
z6Dm$vd%3mNYl7gNR3%=}7bU2X*erUF0)I_x$qqO;Jb>W3Y0Ci=c9fzkabUo$*hXDh
zb%&-JX&#*nrwe)<KaEp$;;DhAykA~gmO`51=*gMa?RmH7U2ZfRs>5X%n~%7!s{KR`
zeS4lIO+4YUPa(TWX@yPgeePvbq0;$WMDQGBszhec3lkB;;yc(TQlvWfY*+Slrhm-A
z%R-WD22L`^#d)aC#c-d5m%5?z1okqHnrW=sBZ;~a4zqnnGeyvP5O7Lno^jh3<tsZd
zMp!#9bj|_H3p}Wn1$i1By0%s*$N}qU=D5o^?y_k5V#EWsyzg{z!goY3c>aa_#3ev8
zQz;P|v;Yy%gulU9VA9Q^f7Mm+RDZNp0<1DCdd7qkj6I`8YWzCLQlxcmMV4e&QCzew
zrXG!HEGX5$TlRl(V&&JOom2t`(Gq`%__3nljp{_EAl0jM<R0+s{U!^)bg}x1%G)dd
zgpVnNB`%uYkpW~3ibJ~J7+~yAD8<HjK<=zePKO61m!pv2Qw$PMMbpt}sDF42D=r=F
z5|y^bCz(TW8JT_8Pj%Bh)9P(3;B?P?K;+3qKUi_?pWlzc+^k@j-V-BwUFoKtau>e9
zZc7BxljJL?r%FQ&R!}l!_W#$_&uj}~Jk9g%iBMfNN>g1;m%55HWag$7R}i52Q}<8q
zt&%5?t|Y+nf}U^7E=~dq%zx?Y(wn)`n@Sz7ycz-{SNUz_<!IySjcTveN|gvJ&9*3O
z9Y=M62!IL^Q8=B*mCi^$7GoPuqKQcK`XGYh6%PF>@?j9M%H{azWY8vf4^vIG5Xb#x
zI$tK5hwusQ#Uzj&<b9bWiA9z!{#qAP7@1@mkcr$x%H2_L6@-XhyMJ)u<@Yvq_ii!%
zIQ0rxqzka{F{n9F!hq6_HdoMSjjsz@Fy|$l8i;mc{|D&v$7lnvI+>lbXh%#QslGN}
zs$VG}SuCuQcY_HCoB){6shPpVtHRxH@md@xqwfO~D{XrgM@IvDm<b+9B*N(Q78!@2
zgucbI@Ax!FI=VHKSbwPg%sKY8hZ5;$7*h(@27nwOhTomSKYwbkXK|g_o9;*_3G8#c
z3>7bM(aocZ=2!Z7xZT0Pf$+w^=j;N%1-)}?cAmy=0vC||fU*JjGzZ%4167w9xf-2C
zU;!MY3m^gFkFky2Ndet!8tw+PNYq^}7>gwv1AB>Hk}${tDSrhChBFzeUoOqqOuQ`y
zO;GWw*McB5`JD+^3b{Zzv|$K+NMX|C4wYd4U{twvk*#B}C!Y%Hr<~{eR?R*5)kkoI
zemJdru)bSmMIAkJie>7pWBkF<;S}fU-=E>Mj7{c{nd#y7eHA$&X2BL7y1@7fEhrOn
zB~eCF93hGL5P#7DAtcVT2!L9QCY(kfi^PI{HVrh+gFWhM=1_DSUMoD}@*;0>3w|7a
zFxY4~tl+>^8htY%(ME_Rijl_Q93H14UQ+XG_O;u0;M8)txN*_;&$J1^z@cs@haO4Y
zm-e<TJ0819Ihmn=Ima2k^`VLZRaai+%D^>;^X7p)-+$vQ8J(a4Qra39^iVN|{|Kv^
zu<3G$W~IXZ8g#K($V_f-BX;2PiL$>xTBd58?kOajZXnHX>Il;KRtH9Nc7W7C6zc47
zgc3ayevx_y7_9sp95Txk-Ff0vSsjZ@JMp?|s(I;3^txjB!$f$L8{hBYwHGwObdj3t
zg(<Gt9)J8NBD%T>D<@{;l6*L$D`+xoeCHjB&bIwuzV5O?-r9oBrE)`wHD9@}${;{;
zyH$CUD<IRm#4?N+;Z`RQ;Ukf~?!npwMQ>?==xzg!d0#@(-Un66tw`cI{5I!<!iH+P
z4BZ$KmS!Set~9!)4W^D1LSS>3k#1WesK}?PaDR0xF>{N85e~hJH5)G`U=uGbEe7*|
z8ILg$Of`P5*=Db)u*+ReSACq(#b&oU7Al!lLZcDW|KN{8U`cfp#>F^ZPCU)f3#A|F
z*Ik+P7h2kMbN|`@?9o!Jy*u2d83miYBhEJn2TdF2Yr&d;a51B}SaZ6@zB(4>8f>Dd
ztAEysIwQu{m4|u=BMD10re37NJGH|eOS_G@f2fL*(Fj=8_q)KqUv6nueUyuH1%MJV
zKe#&9Rz|AI;oD}U>FZ>Mvo7D`B%}_alodu&htY_SPY>=+%Z>2^i=g2*6TMa!Ebct?
z%e?_JFY&q~Ik?n=i!lYPMTAlr1Qc+1L4S`;xzeW@8yiVCN&s!F`%7E$xOs+xOJfJV
zaj+N$nfA<+D;$n5qk|dv4)ZMNhn&LOAoaD@tz>?PLSQpbZ506XFU?ewuTeV}^F?2r
z`}oYkW&quaq3JIp&(OD<iJsc#$wlozMH;V^U3U@Z-Ur=?azxksa;cb&yC#HRx_=H_
z5oXD-^%K5!>6(ckaHd^sNaNx6_4zzE%Mp9u#{nYb!u3jM9<98gmhW;vyFuSLjl~Nm
z$pf{|qC_l+1SSGsZ7+Oc7))K+9DohpZsPNJIUK5ySvu4SZy$@M1w14|ihMv_-Tj5Z
zAnBcvOyX)R-<guf;_q|6eV%WjV1JCxtovblN0+H{+5@)Z<@p&;!x;q$?D;eQLl0{B
zPGrU3dojNAQoE)Cs6m_+-=?L{ToLIxRibU^F2JxuY1r`84-ICVXL@!X<Io`42k(d0
zTgHzK9Tsn2Q?&8<9g`R7ei$0y$aUX;z^EJ7TZ64?e$4?Umv4Ea>o~&Q27i;^Kb$xA
zXZOubf(4x)pBwzh@QFxsx^Yhh{fvmR@lyu9g@F{Pgc6`fZs$_SS6`u82$kDzunw}V
zdrV7CK)sTLA6=4MMPK*M5oq2)PPac_5BjELgD3^;uUpwm*H!59kQkh%F(ihvB#v=R
zA1Y%`5jZ*y#i?@M*$+SSntyS#_68avkv^EsYcLxXgG&^sg)vJY;dJ$Dae}jW7m7Fn
z2-t5o&j5BniNCeGN}|V22@E%^SKlA;{sVxWzlpTazP&y6{aYs$+5mF}g}!RKeLs}d
zu*Z|Z<;Vg5e7MZS4FQ>ciIlf^CF1|+Oe|k$t`rnP_<8)F2mb|?poj1ZWp0zCixHDf
znGBaKmjfFRI5#v3FHB`_XLM*FF*!9elfeflf5lo&a~ru4z4KS#m>diOjcx#4<=QHH
zUCJd}*;@OsiQ|JTjdz(y9EGG(>wlluL)xM^vP2CO`5+EvrUCTF>qd8vDis%8C3Y#h
znxcy#;#M8S?6SHf?5I|kG&oXnOc~egI2(Cz66^|6inE%ME6ljZU$$$-azQW<3>XXJ
ze=kNXTY`%Ok`yqopUO5c9vHMdJV`DJrCH_TVwU0xCKrvE#4c7ao&q+gIe`{WG+-d0
zQP31}6l!)UVi1Y&CYVe%sE$Yi)`gTDF)2q!g1aioQLbPZbX12~5MMFFc1fWWJP|Ca
zMiX30CN5Y@se<E-S6sodVB>6>$#_*De@MaXTA)s7HEEPVKS{Axg(^6xaZ#aNNL0Z)
zCu0YS;$-X;cFZ}=>?+0$)?-oZT`(!b9<{(GHDVGNVHI*kV4P|s#YrTvhn0j(s7g*!
zf<m(sE@f6hCSsbX>LdpvNlpr3>x$XNIabLb+A0+T#*WxNN2sm>7MW}(#VZC4f0)XW
zcvfKu7!H#lU(R@=SUcOg3JYg5I+o4~%O(J-gkbu@!vLErkXS;sfxz~~CV^)vVWvPp
zNl>r`aF#G#BZv)@3Jn&)HVRc2fdMpvI0L^52}=cG1Or6@O4tSi+Z`-d>^>W8Gwg1P
zA`q*o4u-}6BJviwW_>&{eP;-ff1pv=&uF6AFJX{P&)}J=X(-HIzMRe9xcBxfxL@4-
z*T4S*%tD^vme&^-A7(%NFwmUz%Z+>a(#=l{9b4KH04i?hfolHqsy}<%ZQOe||M|^{
zo4@P+*to9?y!(9B;l=51-E96N7VDOqH6$RLKAZp2t^4cMS+^eCcX;$ue|Nq(eck`z
z-rIu=k10wYu+8ZTb6t&POZRHI?6K7QAwC!{2U`yBXY;q$A2-AOUl+@N&*rcD)p@tt
zt{pxY183lzL_Hf0RlLELi+b~Tc#SVqLHBA<!do~0OaHESP~D#(%zwM(qFbJI{|p>X
zu9s(<MZaAC*_5*5#59a3e|E2iC(;1G-rVdVI?llZw?|kNkS<>g3?vbatUW(LBr5qU
z3=G@34F_e61DT2g1bpMg0)8VN5K+A#kct2gP$-q+8OMQS;DPUi!=_trUi4S{)}Mew
z4W4mmuw?9y{UQT@1xCdFS?=8U-R}eb&bv?R&+AQhX*a*EPA@M{e^(<Y<|)p8W98de
zxCIhKt{Qe@SgNMo7|JV^n=r!TSiz5r6?-b+BRuUPn)|(HvY2@+CLbpz*F#s}ohxu@
zbp<Zb4@a9P1Z|wyPSq=E3l<;Gg_$9HM!X|jbFy>IBN=J+2$mz@@OYY>#AoCRj|;l{
zaTXb58=Pe9H4+{Lf2Te1<Or`hppn9!H6NjZ8(DAbpxL8D$0{h3J!+d|Sav>KW#?g;
zcK5uy-#r&;^*kix9*pH0JtNgL*UL&CN&B<=Ue47MbVmWngjmw7KIUiUBXRN>nQ`Li
ztvoP=Bq7g4&#sU})hC!fvU)2DQc_PPJ}(~}fCl}_%b<^YfB5*@Rku1FrKr=ykK(Nw
ziCnx|?MN9={lD%SGy7y!_HOH>{Lt1r#rGfog%xac*`Ie8!=q33`|9nRlfwf+YEwOQ
z5Y6^er@hp9YCy~56d_Me5q6AOQ=mCeC0`J&QL1|hTgS{Xd5+KTm{QdvDBMIUTq#p)
zo{*2o0S;(Ve+oXRHXMNaIrUziaH|G;;#|ALF~W2z!gfry)a8}Eb%6+Rrljh`5Jt)2
zEVBDntCrB}?Cm~XWTf$ursipdpH86LxoLZ;U&h&3IWilo@eo>N7rb`<(Gt7_*@R+K
zL6#-k*o7k{MV{RCnU-P!+Jq!BVsjwe;%CgMsq<87e@h*EQ0(980^C&oQ_)bzM_J{m
zXsFcO@QLgN2$ht)_4F;Rv|cl_^#fbuOqE8ryt_3wRreaky04RUzpHm@a~cr|86JZC
zmx6~w@`4TTD|&wHFE9J0ss41cSuH+ZZ@TqOf_K(mUiC{8y0I;nQSJ=w;o>u?eJVkg
zZSCRef8`s;(BjjJPu=O}deyz?ugpD1pwK7u&iz*0Q}<|fd_rlO3K!j#%i5e9a3W-Q
z1xvvuc?jGQ$)2RUn?kGZKi7*@cmBmH?Gd{alzub>>}1~;EpDgB?`>F6emK26pfOBZ
z6Jl~8iS{W}^IbWpDYdEfVjn*bFk|1(reVfDf6ldrmI6nOjOu`V5c_t@-oA(mLW_Q*
zI(W!|?c?D?MmwYtV8#0T578kEqI!zov45x`k1hDP1A1S)@A8#VV;IYD+(D<2Ml$I4
zkzw?OOrtzXhCNS;+ZbY>o?AUiWbmL^a1_G4!~sWSw10r`@f*2wKeU3n#y${SSD77-
ze`3o$qFM(Ekw5#&cPDDE7auPcJyNr)-#;JvaLf<;@C2HaP*hNTqI7$|4{-aW-wWE`
zXawM<!ro0as?s=`Q=E!H+KOWTztEZiWJGUNf>9NjKpj#53W^AOcM9;+Vtv+KT%0bu
z{(Aki)tkXS;Dn=^d?-i?G^37a;KD#fE=L?N`!oqY$Ve-#enqx$FRk$ma*~z?!7VVh
zey&j(M>>+J(VFgY+W!GfyK!Wf@uC3}0y8p~k)Q(;12j1_lfeflf7KbwlH<1VzF(ni
z4xv&*n0W9tK4l%-RjHJ>Dw&(t2S|iQ%u=L^q&(K&ryC9Mp`kRI%_%iCMW6vR8vX7T
zUq$f8S9!EbrDVCvR@=je$U@ua6%GFN^9Szsg|IQ4?ELif;k%#Wc*P@@M>$_T?WU-n
ziq)^d4|{#=O}h@If0RM`xDJ(ygQvYAz~{|6jFaF$YaRfE2iu<Dhh`m$EGSGx^JYii
zzy15~KfwwYxd=qQ{_W`>AAWoq$cu%z^BuVJ^+S^BL%2#=oad_~1z4u&HD97QD$K4s
zcfC0P=^_q3?waPi-gNy(Bxl7rQ?XiwTrwVWI`vqXqp6E7e{5<xgJ|&FM~|ZX-RQ$d
z0CR$TPalHQxa{bw>4P`AO|3qdm!|zn)2iIGx;<NBqB$LmF?$6pU5YJK5fib5{V5ZX
zp#31G+VQ`(0#hK7FA-O@=^T<7%QD4eB;i(j`e@o+(;k*?Q<9}3@f#1O-#dAC{<<af
zaSl%r{uDAGe{7Cd(Wic6ciOH2_nsc0-4(r8!Cg~T4Q_ZT>*vR%dqZFd<550m&i|<@
zI5NC&1{yp&2S7u^&T9;CL^8{S$#Zbyscepq-TAO-s&K2Tiq1Vw3I5BUAKO#?Cqk1l
zo{1}Hc4b|JgzK-vQQ%H!$?HyKZwQG1bxryFO@5yxf7$=r?V$kmj+MOI9AuQSBvp8j
z3FRdI>*u4@Qq$_bZ0g@eUEwT`K{HWTWSUNuZ`&M>Wo5$6sV?Bt93Q{~g2y{FbyJo7
zzTAedwm7``lpv8S#*^HmeOSC(C@?^P&0bkGy10!yOIeoQ#GJ4s8O?Ph{cYSlPFT+Q
z{n)|fe}m$*q3()rCO4ES2A_Q)?g`y*UqW=hN%lYonA#OgGG$4e-H&O?-m6G?1ZVR6
zeyl}ReLH=jj5C&t<T^jEVt+TG<v~ARQ>GY<p1(sV$F_L}k9Z|YggoaE^Rk%}fsohP
zz>o&IwSy%1!lfc5|41v%%nx)A1nu{_rvqC|e`R#-CauxEM@gU#A`Ms!M$*cyT-=dB
zSZdvws`B_9J=>-Zm%@7w(Hh9=JBoBZXEJ&k|9rf{mC{9bA{Aoe@d$}nRc`IO9vqt1
z$H{gUIaT1UD_a*y;kZA`mf~nM51`llUOd+y!Sa0Y4lkvRFMMQc%q?3HL~Nz;PInb8
ze|j!kD82y)mM1Cl1ZT)8{Mwh{8DdgL(At>76b}?gJUuhUKex^42$y4W8<D_pP@*K1
z;=w^%PMryiq;+mbO&cJ+!nlyY%?+)b@j!E;$yU34)^Dw?>e0$5TU_?CwN$t(v|Dn#
z@dR9x&u9sEM5wu>5(U}xg`|{-21(%<f2k1@YJ{W4j=ZES6eWcND-%1=?X&6Kd3q>G
z#N9iSh^`CJ$vkn^0|P4zna99GXT5b{>TPMzd=(d#^SE)~JWed<>6GPsYB`U9GftY5
zo1rOyg_dAG)*A5U(Hb0}b6@&+9^iNf=WrQ}kKK~Yt&lzwMiw&;f}G1D7WO2Ke~7O!
z<l3kHc<KoVhOlru2dhmZel?|8A|OwhOom*Yt-~zh!7okkE+t=ySC%{X?MJ$-TxAq7
zo@VoxdtzlSZ5AwZ71WIboQ`4Ngas(u!{ReU3^`-`u4nLwLv$R@9JI4zyq9>17n4T>
zP)Q!qv<Fj^<n>|M89Z(v9ROG9f6`I`S%#dMT~`(+#3D<YZ4Z1?G7ml>iPpbJ=h`|N
z_6?ZC-l`<b4!Vb{-IAtHWtoFMuBPvgKm7B7MlW#CI6U?N;P?tq#B;3=<(B4fD?q;D
z-3tMSo@*UaQ;~I`c1cB!O%jjDF-ojc>W;wZaA{jn{$3U*UD4dTM%YX~e-B_AvR0aa
ztjn$K6zC0xsxxgqG_BiU{_xh_IZx^C-s^hl2?K#PfVmLqEt3jgHk_LTuU|ebmWmQ|
zHcH-aDRLpHnYvaMrTIdFc&B5IrnY$Xh9L*M!@a;WGkz0esI2|+Ycb{ROE{GAZ{5N(
zCPjX;c6cx0h*B=_`fcQ)e*jKLg3mSVh2k|TtrQZ%L+3Pf+dB<KEw*b|J%a@;5v5W{
zaR<WDPOkMnfQ0<^3!!#~@@C<QH_*D`|9-SqzBdpi*|bc)M}_#Z4&5SJ@@b!G@e(K|
zGv#+|%38PQE7)SrVin(yY(nTwyqsfSYovj+V@EDc2-ovepdY{mf98TCXeqyl9Mn`*
z=!-EfsXPEjZaRW>z0Cm-YW^s(UxZM~=>fK(Jo2kmR^1k~4DJP8Efxik$81V?4LbSr
zI#U4#5gV?X)AOE?KomLCLDF#Q={0TTpp|xSt7!g$Nx)KAaV@&%#(8E481<qT{#@H&
z5Q%(D+dxyJV6TVBf8;k%8d|uSb{i@Cw4fJ|)uLVluaivv59tr^ii=22X+(m2m1t+D
z&Mex1MAr;zH{;N;HI5AImib)xwar4_HtJ)Kr3E~BUPMSvsh4!sh@>PPKBNmIa0_rr
z8}97ri$tJi*sL8eSr*btRgTrD8YSX0iO>@_d)KSn94asff8MrNDr3*TmS*&D;BB1Q
zWQGzUT)_v~uRC9W!nft-WW|pFZ5JR12V|&0_L6qGM$J{cg_42SEmX4U@5h>Wsbif?
zoiT&Zu_Px*0^_l88oL70icGp3C=G@d{2)Jk5AGwr&x&(WY+9_`sB#wh)lJK<YmXLB
zmfdpuJC-byf2p%PdA0lfcsS3d+e&w?QT@2Au=5VN@8VMB?z+%jb1*c6%no8_SNg^|
zX(NtYQvmn;uB#KZ1#m|*Ym<Yf?$IMoJHyLAgQyEH(^B$2sSK5`4AnKmO*5vl_hcrD
zsWhG1s;x0hPXh`9SUL>-B!JqVHf$S%iV6by4iAjUf5BhUu3a@ksYzA&LRzpqxh$m7
ze3PpRE@Ku&>YXK(U}~@lD(J8T&#ehA8Bq*5Uh+*D*+mM8WvCPoC`<P$?SJ~|Tv&zo
z<d+HD*ouKtjGSmbF+%j>EdjTUwbR1TlzJF4pY#fFHZ+%T;<rq?1#U(AuRG;iCNL%!
z0k26De-V7%`O8mjM{T4StLoPtYw{3|vQGo*OZ5byr*Zdlk{#I|0dTDKzt483%B@kb
z820dBdum%V#b-OYK26GI4o`t!92*Lob<AzTW50_(#|ZlqY_#x>zCBOL7uFsvU~Ia<
zq&6?r*%jSjnt65+QGIr>pnsTAEAgfihq576Pje@Zt)*B^;(i<f3n62|1P#Zwb%6tT
zylrmb7#^}z0e~6cuh!A%e}R%6cv+)cC<N<W`Fx^=^fl)ONhZ)ZBr-POMVQ+8-_idI
z&8JBzm+_(j69O|fmyw_Y69PFnmqEV+DSwq3*^=D0@m*gr<(F`)mJo6A*q4-ITPdfU
zQW7hbq%1#hNz5)K4msu_dH+7$=q86Vi_uZ46@doWjc)YKk-G%`$z74`GOa~n@?CX!
zk$C9vu%p4h{`x}lz8E&fo1K4o`{LzmYj-jcMN-J!+x-^R+j{qF^!;OboZN5|Yk#ey
z?CvHu#zt=+9Rc3l-^4bJ-rvXwATp{Zf*<;uSmjaeTAKHJdcOMQhu5$oRiPrC-2C?T
zZ!dm)yB^Of^_6_!&Mz<`WiIkvnj0atAzoTnjuR4vz3FzZN=2UMfZA_+m)N8n>-}8?
zFAVY6&qL+n!96tNG(5qoWE|)8(tkwgR4qtuK~jZ`Mi7LtMbu3699(?#qUn!wTTX5y
z@Pq<2X%bx!qt*S;ACTlOmU$+Wg{KzM5}|3ii+71Mts9@l$sL5>4wo$pk>nZe#9Iq7
zZ-kX{IrnksABOS}_s0;EsS-tDm%Tl);)Zf+`VKTfndno~wm7m;H8^09#(yQRx<6bs
zPvw2faHd9!o=p$-JmFwO3R&c;2Dx)JNdbglla!?(=`6%Iyp?F6R@0!FMjF(PkJ{C)
zs~R_oo4Bwh`rl0s$~n`f%AXPj^XO>s@1NfMgGT#)xIlS?t85PCgNy6=a3t6xseS)p
zyj?F~b4Gf%C?ZyYabgUE8-J&MaJ0BZ5~pd(>=ec6{j#du$m6M}XVo7LXoA3mjOw^;
zI>47ENmLFGGl2Y}>uvz`gzQUYRP?H=LkE4rT_~0`Nl7d?7+Ho@vwtGUvchNw1~YpN
zK|?wx(^O>2EQ)k^ip%5i?oh%jA+0M!x+>^BB7J&(qNaNwV8e%ECVz$?eQAYOE6&>O
zS$_i5V{N5KZNTb~N`LgaAE04#k!CB2JJ*4H;v-0fedKo=uD=U<6a#KaW(x*?XQ_&Q
zIO#H6>&kY2$u<e&aBSUy@5h@dX=bbvD-8I&vwI)ru0w<YZj2T>%bvN&{)pDk9_UXV
zwDBMSHPIdM31_|LI)9b2!rB%2q2w#Jxs86G(RJF~uu}j~H4g)GM1Y^0@yJ}IxhTNh
zpPL=p7>L6p(afsZ(G+Y3#Dh{n;p)^xzc}7W7YqaUM~Rzg(sW@Dszk2W_yJyhdim(u
zwvRvcLtDp;LV$RJ3bwqzRj{(FgQOtjrNwhfqGcIeBF`-h^M6fLN)7lA^c{H`-Oo)s
z(U6=B3=pUD<7~0DkO65a&X0lr#eDZ-tcK<|g_T;1+^lzfh0R#Qxl?s<k)F<>{NUn^
zbgyzQ4d_C$F`pnC!e%QU<c!0S4}5^OtHa_bmt@i6{Bw$N0AY1Q(DYbN1Vo+AyiUWU
z>lu1ahRnJvQGYTQQEdVNm2Kboc&PZ6U{F(#!2AKHgb@bt!oWj{7BJ|M^rwy{`?;&g
z4M5^nfCljHeGd}F>;A-VaST=v4d=3@A%<@ZBN$H>x3|U)I&sx|%lvrbJrq)=+`weY
zXMrZuobAA1hHyNz<hpT=hI~t+dq0m80Y5d<BaIF|Mt|a{TJlSp9)~3XjoZGgU42XP
z^-<ds8hIybzJGSX08L)S4F^{@?A8q25^&tKHO(Ma&n>&~p7UZlBCeJU7|`QUazv2k
zBo;b*#Yqz`lDS+<+K_3Tz=e+VEL+Gb1InDDi(XZ<ZSJqAvd%=BF5A3_5G(qE+TVny
zK@Z3xK7ZU;$lowy3)xSSf%H~nq6{0N$gDht4op)CJ%*A0G+oV#cNZd&fp5&$loPD|
zJ{&@}Zq5f9Pl0kuk{Z?`kfgOfYM!wL{syXr>@sllSl!s@Jt_T!sc0aTM6mI!yng-D
zGV!VSEpBAjieS8MeE#_T&$l%4k;|jyR|q_D3V(=vTq5yije|qq^(`n~Q_<W(sQh>X
z)mRyabh~xe(=nBZRG+f36>)rBiHdAn?Lhc6GKX{$b5A&q^+t}0i$hdgWv?r44zjoF
z<<)I_U2&x>wmAqG<B|eS4f&k*iHS~3^-NB%;N=vv&&6nz>GR0@SxEug^4kTaFElf?
zY=3x=a%>DQB?khlWO(Uy!vlR?&mmT^p4)^3o{DF72iV!}@Ukd4TroW(%qIVYi@9og
z#U{hh;OhTgR&Rb`(@G`OtQVQ)e}e?UQy6nns`{zBV(umpNpUVyRitD$@LWny9GCdW
zq7fwAG6?XN2d@q=0SZHjl?zV%rTDkdTYq?zkNlGRV;V{tlAR-+QyAKkU&1=$hnvJH
z7q1q|ZLNZFr>AJ($_g*#@w|2Ngs>hX??9o3Dwc66{;wJX?mZO+o&b?+1`co#tJ;R*
z5y~<chhBO2nPX1lFqmpc58p{`?jeS^?mJrBHU!|HeK!)k^ptQwK@b(YX{il>V1Kxr
ziigx8LhPDxb~G)Q1C;07;p;O8+kTi_u%IPBtFaNY7DSmZi0GK8wP{M(kWQ0R34*Vz
z*NKz4TX?V=9$>+r({J!)tgpAA2CoTW>mJJL>GBA;Ck`Z0coSHo8=F7^;N!lwYwA{l
z&smPA)94e9OWt!F+{dP$$CejE0)N+w^MUozwT_y0Hc%^ixgeGWJ0_O_@h&=AvSvEi
zxK@Q{mGwpTkU)XEI)1DkW74Oqy{9ujqrI1R?ViZiZmcjW*R;f;U+bks<^ylscWt<$
z$)H>?XJ>I$(BT<-UY3)WgCJ%z^St90YXu2v2??T%!0j-=OH3_C!z6v4j(=YJ)<sOo
zyetUDoiOUPjRb7?InHaQ!YI5iS<%Mey1KDlGEU|5;J`ilR38%#3mI?M`W}<glAWMV
zo^||i(MNY!gSd)yg5Td0XbN{6WdT0$6cg`!1dOSbaB8NUM^WQXx!lh1Fdx<y08<RL
zU<y&luj}%F+q1@AT&e*Dg@2nqlM&gYk;eN4xRFO++M(5vZ^or%i?7R!)Lai?8tI$5
z02zVTaSzU{Cy1dG50}<r5hoSC`B-*XQ+m`LJ*kL-4f}bT2M69F%`L=T|0*Aib}rq#
z=YHm~Jk@G!y7R*WRN1Uz7=E}!d89;v4T>Wbd&X(~Ku}=>k>+7uLVrs${n^viSd1$W
zrOHJjHIe`I&6zs=cDh0-3TqX00<uhGYBe{Y0Flad@V9j4d#o7^xVTL|7Tm`8i?f{4
z7@;@)k<by8*VhX@z(R9Nrv5w~nHIvFbUsKZg}Q9R=;7G3?psKJ3sQypJTH)A3ZvAS
z8ZaxK-na0CeY@ghm48=+$D7WCx6PctO^!-~pH0jcX!53OG{0T8%0e2i^%uzUrmbwB
zbNV%6zUU81Z!;He$fsecH5X19V|Io~-AJq8Cz^qV1J;)^TE40HG|GDkT*TPKuRukP
z>7Zjw)a=5A&6x>M(h7dD@g10e555R7Rl6{|Z^CgtHzLVaPk&6CF>%UHH8M_`j-Dkw
zmhV5b&n7;>32yVX{Ib>iTtD#XCB85*0V?#fQ=#vZL<qWj{t89syrN@Vx*Kf7p~p`6
zs}>IWp+<*k63khUDW4|d%JOjo$IluKj1JH+LR2V1v!bT%l;271DO_cp3j_dSpHd`t
z^n?_B_xfd#kbj<+1^Jm8f_uMILjqFf4}*Dh`?;mD4<E*V9%dCBcsD)PyF{$Z(y2ya
zz_@v*z!Cy9(3g0Ax~L88Aho&u9Q*sFlQ)rxOoVNbL&^QVv25z?$5vWLiE*?%4yzO(
z%gha>sb*~y@=fq=CT}jJe+^f-E~78%)bI7Fupf`~+<!<IRSZETFO~FI>takJS!f7f
z7*t;47JO7|P<BGxDP!SouY5F8c>=*k2l^%3_`LiK;P=xH0W{z+=zy*F<NRX)BZ^$^
z3XvAsZg9K(i+}Qm|MdBXe+bzovs)i>y|HhN*?zW9GAyH3<D=G0K|N7;z*;+F$*+s$
z3JY~L)jPEoV)E+E<|cdyl?j;_o7OG0BoHy@SbN|5{tP7u{zW0T^~=jIeAZMN!b%bT
zjDD)E#Bx3V2Xd$j;Fs~D0TTf<m$6L&69Y3cFqaVq0V#i-T1%7LxDmelS4{0?sVa*h
z2)^W7ve`{-E=eVmLn_VzBSI2mic|>F<H@g2zW|aN&f2>*2Z4=O1O58CG3p_KKlN}(
z9!jm_LsmT;ukR9~4(A7M{OwQgl#JWM!2M$6A0FTR?x#F|P)U494(j3Yv|Q@3e)w1P
z!^PZ2JM4e<TI;C%u-j)@9z9+x6aMnF+vi2}pPh<;qN3x-^lQJ{r&UzjmcRQG|Nj2(
zfBXr0RC-7wt#<!@{PVjX9|L=NnttOsaOA6llyDFoCvXxuNKs|6(itD5j8&W>w`ugl
zV9nTcXW*&Kqs~5aqrbs#8rcCl`_3VE_qPMrr^<i0(3;oe<76t0o_A>(8OI;Bb<Mf6
zHGhpg{_5z7uEa9Yei?1&nx|I2n~n#Wj=y`kSbH4z{m|HM2XjZi<jJ@Tuo&<5MU_U6
zy9#btHnZl4LodAC%pjf;4n!x=vC0*nU>q76|H-|F4e<;xygEd;p+67idPT`+RTUkH
zG3bA2uD8}+g&!u37ZyLZ<&YPH{hynDlKB_ue@43D+0IXaj~Ce{NCtZh6WzqC9$VvN
z4(Jn0r?{8S;%xm*M7br&T*Y~o!xS1C)7|WK5f=%lmn!0<$Y&XU?@&WD+=|`T_G6+l
zk}i@^Y4F5eX^3bB%MBDO{&qe8vYN<&k??;J^z$|}pPSa6ZT%exL4z=#rcvhmUs-st
z|DCKG{pRDv$bj1J`3Nclo5<uM_ynJEKidXQajg{fo;wEqoSfx`h;!q9RZ_+IAzYeq
z^=a#B(<09D)Q`HcLVnuid1TJCM;4uW+4c4H5eN2#$JNMVDa<1Qx~|T)Om#83BPD<C
z2qy9>rnPbxI**gATx$hytrA#@ZWUU?gl4FfiabRw7Fr}R%k8@FzMsiKk9jJZIre~f
z%v0OA3x68!MLD0_{>ijL#=E1|`UaTRnX7C$*mL8?;e|9q<)j%KW^7v5vxj933yc9}
zlpcdUB=WwgnI!u_>xkYP?CXM;iW`3fJwj6u7y3_fG-%Sg%<dUyMW~jFP=X?;!Yjgc
za^t4Dl<}d`e$?b9)3z_X1$ZH1x~VM_u6DdgXmRYcS)9mDXT^;R;fhCs5AsdaapK?c
zBCDPHwxtc8!A?~q@!)Jbi(ZjcNF8FG={psgx+AIU2R;wn&*D54TwK2PA>e;8%1whx
z<023C1nvq>bKSb5OvhCjOzIz9Yta+xtOP%T0wtMb#hpx0XYwR!n@?oun;d8rmq{5|
z80-z4*B;i{@|k6v&RodqjWEK303K>9OmwyFjxS6EN#4xat2hkrI}mb}!76mmsZQf6
zS1Z3Ia;gALxRF~BePC^vJ&b>-<0a{MSq6#lDA9>3dcHJ18saBeLW!`1T{zD*vdOGk
zvX|puuaO(Kr@_Hw#ka^WiLte~IgEvYI}Sc&9_Qf-MAe>~w#5@?6j{j=;l~j;!XSWc
zJQe=(%?J<NbCKb_?-KzKO@0mj=*WrCjt$<8U;Ef!nGV*)KIJ`rf+v4J5h$buJclg!
zQUu>vx8<n>8L&cv>&ZN1upN6Mufcc>TgPFIg*l<W-;hR{##*J{W=(|(X15l63g8u)
zn@Hv03$J=>x2lNs!LQMDw`ts;Ac}9o#-fPxGz)RFt2fzKanO){8h>%YGL6%4fR9O@
zIBS_*xlQzIp#RXNm`;DX55FxR^=L*3l5l0QI;<_PL2Q;*1)odW$TrEInM1&s9ty9Q
z6hI7t2pq$z2eW`O$Xb4#R+yv6Dr=GwLuVg?lpO|g`$(15^5{xg1|gInGMXlPjIuCH
zH=pLY8+s@=JPxLFtv3r8&O5MOnyztI#2D!z`s*%eB@c9$erkVddvRvek_!kdm*DxD
zs~KLH`k7ErJ4xT*^QLiv*3em5PayF(K-{nBNm0dRTFxkUUt~J^8RB4;BpflZL6X&n
zgPdd4M>_y>BY&cEXr&7Uiof=Y*!>ZJ>3d8!N(Qd5BIgY-=q)o!%PKC)Y(w$4&V!*N
z&XW5$VMdQ)fQ^5Pm5fH<Pv{lE2QH@xeIEW`>c&6;ky0o4Xt3inbnC$x-NE3-yRm$C
z*x&9LNGgxO?3^*hTZmyVIN&#6hHr2bSsC04N*>V63N+jY4(uoBByO=Jw+O_GaXg;U
z<qK1pf%hEcWnI5WaHE-C#@vj84h>nkULauPCa)xXuXBIZi<g@Z_c50vINpcy!V>h>
z7UI;k=|ptT7dzNH*^4{l0lrYNj6z%~(E2r02U^?M%@{Rf<#df(h2WFG6c8t?nZ)ei
z!Fuilmr;<*Acu?olj)FRj1tLD0szc-K|~)0lEa3fW=0T|_|3kxhOQ5Cs-I6hEWm~J
zK<}eWxAK3Z5-HrKjw*okLF>Av-NgMWuF}IYh@lv>bfHH0aWXKST2x4ZUw>WLW+iLK
z=0;vAUAS0>!4KV0h9wFs69AdCy+e_1IU@+vRq#b0%+OCER<9967MHr(KoCyYGQoqR
z&&p$6RriG#4m`+pi3z85)Kn`m=1Cse_zZ%oat?ozIKp;r8f0R>QGr7`J8H)tW{|aA
zf3+8hzDyYVfvQR{ifT~si-Wd8=Bo5VCa_;&eV=pYCHPa0pkN#OT(OGjT%sZlVAQbC
zMeg5Lrxcuiu0x8rnMED|(gh^W;$CeSZk6d=p#eI?X3makNkkyYQQ2Xo<Xtb0Je2Ur
zfp~uj)*i=-S6n(5k_jf4oM5BoQKq?NG>8&sSo%xar<YNEp?%xYB?Vwy9m?MlUJ(By
z^dC{uAY`}SuBItf#mPF%s7h`D(14-Sj}5}Mj{ABU^V-qEc$rvj6i3Rig5jUnDGJjO
zBO2$kcw%p*&FeI^A#+2C%`r@8%NV9tF^qreDLiBq!w3j$qkHg)*{{FXEY7p+zD$V~
zwkmro;A}=#P9!n*j^>lkzAzFy?w|8N(>DJjoyOkbJb8<sqdy1!d(mVb49)R<Q#M(4
zm-((E%GjTQcd9#s%WG=y*m!<(LV%hx8#urmrP2Wx!uumNgovDYK@!JHB%tacMOc3t
z8gi3BsI5B=%@fz3apqBqlGw>O63K)^wu*4a85S(G%Xzhk?;cN3<vliK+>xz$!VV8v
zg*S$3^_)4Ed^;^=L|Dq&L?b^VR7kVgzpm<ZX+oG<l+2C8E=NN>hoZ-QEdx+^NM`HL
zjibDUs<TEm3RZ+4AyrDTTEL}Ka+ZHiXt!`#ejUq=!8!=;GHko(pJw1Ti*$)2FxS|3
z_RF{@GpH#G-pnSFGS+v=1Omsxd+<WfEZ_%;saOH%Vr6XTL@+8#50-r!dAosy@M+^a
z?m<`sL0r}q>nwCA)=@H1XbF+W<22CHDw=%pZ)W5BVKZK%;%ihUOgA%Ku5EvutU<FQ
z#$S0Vf?<K-&a_x!FY}5N2uD%Q2V<u00#a)zUDTD-py&|_z690?9e>dgfS-8c@scLf
zfbCMw{Yh@<B)3GUt5_%Hb}6S&xGx$7m^3IRWMy0vEe`U+LL<5(S<nrWTwi-GQqpC5
z_bHTDh7`+~qe!H0eIMB{bT)r7T2KN<Gx)xmP9A53+oitw9nsX6_=<Q!=eKFkKZaMn
zrPFv>X05jNnB}cnf>QaiD*0<-y_(Uz&&it6*;c%m@wt&3V_)CZR6BlE$D?XN$f)td
zuHF|h;Gg)H-$u*jajDec*4_8TPNeaRtO2n5VYe^v{k4%86DAg~A{u`!hVVM4ci1fx
z^Xsy#u_i*dfJ&B>>;)2j1A-s-LU7{A=T$@$^-1{A2k$ab9AlG>w;?Q~@GGdMVoaXQ
z^CkI(mUt6nr*oq`1~vPQU`vLoAwinnN{Ik^Cq)qU)qKLofnRu6t&*j3py$P~cSxe2
z2%iu<sf4eieZRG331EM%3O3#Lrhel+;=ZcBu@>ZW<qFL<?OU%Kg^H7T?At|JT^_#e
zx#Vua!53T)IV8T>T9JUYtH%y*;yTv+M(439Ak|)UO=okG0b#^@_OY2u>#rWC-z=un
zqcg@QZc&s2I5qz-0aBM<rV?OMv8`8H;MF|)4e(d#g)KTTMnHeJ!5FdE@TxMol*y%^
z{FXg#nIk~8*&GWA$_N=d>GU}(KY2(m0f0PP<a+Qi5yZjnXW(@khNw6zg4UjzuHFZa
z`gKEzH=h{de6HPneMJy?5~u30^@5ZY3%H0M{sjr!bS7$%N>TST3~S_#bP_5D%UL$i
zhj9{Tp)t&(Ik^{D(-Ej2q%^hK@U<{x0r?-H{{zGbmC2X!q5%_^Yk&b112Zr)m!Osb
zDt}r_kK8sAzWZ0qX`wbEt@w~A`R2{8gDkQzkey4A<Up(0)5@x)h8~{GzfV0#J$lr(
z7jtN;SQM*@_4rsC@sPrwcqr2cqf}Dr;-R{{Nr~D&J@DY?AKnPh7XxFw;{3<so4<d^
zvImhSWm<}d$J6>%kH?2!qwml5I=cQ4D}SXT^X?F9okfpl$Apic4sn)8e;h;v6cJS;
z(=Xj2mPK@Q4L^4${(b-7e|~@&Axjx4dHDVD-*5i)IE$A_`HgxY=T{UFLL~V^Ug$(9
z&AJS(>e?epmPfXKnl7$AfRtkbTFH{N!nyj06DAt#-%_E2ZoQuz_;<vmFW0)VO@H&^
z-^oA2*w^jTckoayw3iF=e<HJV4HJJ$vved&8JaPX<A-C1%+GCQ2N&e^+g|Ana3Eki
zP&r?#42LUJA~M#t>ReyBxV0DOnK$;y74Q=yh#^2)mFlSL7pY4VHT5tu0S^#=S+{|w
z12-ubROp%k?Wtt+W6Nw;+mCfMHGj6JT~suZp<%{du58Az9oTw6TaSC{$x<XD&x6=)
z-R$Wl(?pAz2~M&b-GGb_u`)Wz3hAvRm}3mS3}SkJz-JxR<KUW8!b|fc2Vr7SCWSJ*
z@O|rjI~<7}>#p@86&q8->e2*}F7{<tZk?zy3ryFZT;MafqK_yviyO~iA%7oR1B-d;
zd~nW+oVuoA2ZEzwrYG0BzOMZI)K)0!@Q&rk^;(X&Gzku40a6PQTtt|?BM}npG7DX|
z*J+GTb;AaK<#BnU!1|u~JqRPx=mI)<g_ywlz+gOMs1eBv%uj*Zokr(LaK?V%+|eD;
z&4iAIx~&}3Iq%@;Z2fY}KY!QWjU#&Ri$7=<a^oUZ<31la>S8G~aH^A?nq42wvqY-$
zTMd#WI-3o0aTRWIwrxFJFoe=F`sGkSP)@vU*HWT^5vs|fs&{t8Xp)+O7DyY5BB4I<
zFE~gaSa|@<sQLs>)x@m7P$@X8xQUVa+Mp#N)<JKKQgTPy8Jw2&<bQe0n4m7mpDPjl
zryE9Q*+$90%ykPQ)t=+jcbDC;H!_i;2xh{de75~D?ylRA+h+e%fft80;1F7f==of;
zi9<Tb5|tL4q-n1ZdDp%M)zH`&E`u9=sLc_^=jv7U(bt8ks+l-wR||%2>MK9yWv_FL
z%4Gt%1&$>tWX|IJ`hVe2sAy`z;uYmZR98g5FLn}1nSl>s;QANb^}TX!AV`IJNjEn+
zjO47k3sbu`<i#CB$2tRl$+rITvm2)#Ut=W2nGwE}Ac3#|{9f&N#^N+E!+5ryp?46J
z!;*`E#D;`H@HAY|?dc`+B9YqMQEW#6T|&gp{DB>^&;?@*H-DPfZ8n1JVG>>Fo0|JA
zHp^rpqzGFk`&n2enc<3)r~g+Lp5r1uf)w#}Pl6IoU(X@+3pyEPnaqSNlNBM$z=%Lf
zhIkI0w{^^EnYhh28S2jSe4<EM5;#6lKFToTB3$s>R<;d$jIJ6vLcN&VWDF3l_Blk$
z)bFB23BG|Z{C|7^Kx&)%NZAQFz?(kT-Q@Xuh@UAeMqlKYc;2<YV5w~}b!Zv+0?-Eb
zZhAWNxaEqBL!S^{hS5<by8&cl4bDDV^bm|Mu0)UoLfU`g%0)?pXP&X#W6m;=vp6UL
z5%OrZ9zOIOaC_NPfdei6eIGOxONu328d6s%cAT#WpnvUbW1wm*&}`r96C>AK2oJ54
z%9BEu1UQuOiI4IgBLQ%j7R&~<9IYcmGJpdQo@W?4l!P7j;sb1urE`D)9vq>1>?Q+<
zx_ma4ZJzOHEJ4(Pw_r=}+W_iR@ilk~Nkc3k$ZIrotf<d{uno%Sccfa4vm}mLi&I4X
z)Up+^N`Gd08!Gk$dGw5>*rd@%boI1=_?h|vO{wvQb9TE1!?KbW-(oO8)OyyLup4gT
zozp-0h~Vw9jCF)Kj*M}R&c|GPWERX5_-n&F+&?chprX-Vwiu{nd6J23`t8H3>}WqV
zyQ*a>$z{IL3|4jhJq3#t&P%M%s|3kVR8?frAAb{7H5dU7^E7r(xT=BiA#et!61rK>
zXS1}hITL*T@S9K)0O}2D5pe4*Qgf3O_tOHLHCmao4c#XWe97edLhZ537K48=orn@J
zMykFV=w?&hz&%r)<i*Vm>f<dY%(V0|kZHJ(^>x4iIMGcb)qb2B&a4^I2XY*whNW9x
zEPr17V&@k_GC2Z*Wb*ev1u7ijE&z>%PD;J?w720UF>m#Dx5}CXFxlF7z_#`lO#W04
z*9CC_UhA2GoeaoLXOE!+bL>1^Ft8Kc7<Degr46@&YxDvaOd_#611b_Kfg3rY68If=
zuOlg)j*vyTpzTAARLtRk0^>XP-2l+F(SLz;1M1KO8QdRQ{;i>+!%cUx4L{Fl8OAeO
zhB4IxT*p68eK%eG%<0}ril!{{*35*rI}NCl!M8pzUy*IAHRB41mnTO9kh{0-5Rf6x
zc>jbmiNWRXSWE*T6>~f+=-}2~P^8i&Gt~p{X?dp|U`ccvL}LI0866P}Qo^0JVShR!
zofYFgR0R_h;5S-r^UJx0Ankn`qJ|BWXY6nl0l3S&^cXG=Z7#>u6J>kqyTQ}v+U{Bj
zFmWztZ#jWW#P>}F7oD;!mlOjEsXNv$5|hp8irs@QMR)Gw<pNQt(FYP+)@knqknSBD
z%Nmoh>B7J!O(9p_)?{pf<=C5eB7e6|O^|B#beLvuO^x?fTrgFY8-|(>l_x`%!};Yh
zn&ut})0GsSmI6YnYQLiP%qy>^#$CQ|NvLRm3FgqhbjNAmipnG=UHdT^LrW+C`Aykk
z%%6rhawtR1{R{}uU5g_(U7C4JIe^++xMB!>8q6d(-C@szhp*p;sX^vs<9`dhk!$0?
z+?z8QcEEh-x}Bz;_gJ^RC+dLUqPcWnGfi$2Yq^D7Nm&#(St3>%@y}2{wRW7b?M=TP
zGPYd%EUvNqvwjU*jk2Lf*1DMasH@9ko+@8=tdZyeDvaiSwTSSNV)^QY#`hw4Xau9C
z{$Frf6s_e1!pR2UaC!?{{ePk1)qBqcunmBhF3T-ZX2dHCw_aEgAU)UPnMb{QqH^!M
z2J4Q32+)Z(YZop0fg2&Xd}>0If}4}D+zV#BV8&<9t&dQ5W4Y;kyDvbIU2wy$4d9OZ
zWxo(<2EbLX!AFjkXaH-?IRxH9_Q-Ossd@B?tpNqI>d3xpEn#bVkAGx81136uNGRY0
zbY#nm?n%A4VNM0zV_KPr@^zwAYH>}a=a{>3O%JTPfSWvO;)c`e<I~a6w*|bzvfX@)
zszN0tHr^DOebacWzT9!+m3NEQ7dmdt7q1SHWc*uq#T~7`JLc)_J+@rBn&|U;8)>TF
zp2_un*T)`Uj(cy_>3{m`1iI^PpHHe3u6kP({6jsrMU-M(2Iz9mIzU?V`)>bcj%C02
z*0PU*v-)f$bjx2sL;%ZTzMqpMmTCM(EN)syKc1M_cI!#z55-E9CD`z$2@W`>r3Q`6
z8M(@gt;<95GVHSRcR`PUb}!cu-ezh0*8_rq_={Ltq&PO4G=EPW{oa2mB)Lqq-~Y(L
z^A@+c-vTl+yWN4!Nu5yslCb~!vdnKCZqJ8Q4)#oM0zKS9PqrCcGN;ki*QZBn1|8y3
zaQ7So^2m>L?l_p(;@tH^0-x)!?{-EedTCdE#qEH(%oZPoq+pw7;9Z;z(2AZKcbT&t
z67UX>zjyj9v47NA0?24<khgPg0Kur$84nK7_c@-w-0faBr2zbDW`u?b5Zpqfs*K#9
z*QH)p1X1Inq!w;b7IQ0}iC7Yl`f2fDkkr3?BWdssYLapW)>87Fg(8c-Sy1Z-o;&}~
z0<IeU0&a@nk`+cpR?E~yE+k$of2X5|`HF#j?oR-*)owToLSCVzZzjAh%+Ga$fX3+M
zHOgev8YT-pf$3aNcsK)q$p7wu4Ajx_2t%*L!zY3uCuZ~@hmt8xl9R&(-Q|y-cH-Zz
z^{?+dVGR47u(wPfa}9sYU8}Ow52xO7=r8nBQ0HCvM~lAzc!|%2m+_(j69P0jlTmyV
z0ys01u>C53T3M6Z#u0wkuVDGbq)UM2!lmTJc5IiD*m5kn{9yY5OM)aKfS_?`wfXhw
zYjAL}B_*lURxM_F?w;<ikD=Zu_|uzAZ4zt4%%z)s{Y(+HJ#Dz~(|6Cb^b4S4Fzfl%
z+h;GnjiQZKVWu*@d3&5s_4cs&b^G->zxGAD3#_$&+vMdga4y=uJr_)PeYXpuc>B+t
z-U3B$_dV0=W*3-rdnhWdH%I<{`Q|U*LW?$;*;>2%{q0|$ee-tQUS!NCo&$S6I!Ns1
z2hk=86Bljb)P>qQKFx1RC%EeEskI4XpeXLupNm!wSa$ez+e^ds?xE|8dVVMe-E%qi
zC9nN|xC^({McuRyyyS9!fvg$mI85UIbbq|cHSf=UO(%P`+d~P{SUAFE2X`P_JGM=I
zyWRV9xyLSNZn(#CE|Xl_;(gf+UG>2As>u(<;s0_FZLzzniqAV463>S?8=6@AAywY>
zLERk6W9hfETp>xqG%@1}Wi3k-ANB>w=mCU(6%VN$t-rEjYDi-K*A+=VWECQe!lOw*
zV5$vhiH5~8;GPY2q<M}>YM_G-WBRX@<<?)$1xgpF&^RHK4+S#uQubwY>6nz06hlES
zkIEznD~C1;HZUC{%)8aYf>!Bt<PG0j_Z(nBC3w(>o0ZG@T9x~<Co#(OVkf`?1A`iW
zIj2>jg)J=@@x%q`1f<CC0Wl@``OP;!t!+1Qp>pGPuQ|#4yImA*^HTxaHj$dEfic;3
z=!#W2%v_l2#j30PF<A7yp07<5g-Mk79zVZ&{p0F9Q3x#cz4FUp{mw#_MDwX$eEs_S
z?_d8A{QcD%nbvLMFiUJoM*vx}(FS0DGs<|3U0WLl#2}HgZa=oosm<%UXgj_wYctYH
zzAf%_e@2ju0QTjZ697H*=kju5%B8skeOtaS^NI<ClTotGSFbr%VPZcnk}+J&jYz`P
z+SqNoVFb8HunqSosxt1XxaY$A9T>B`E%Q4TYMkOYT=uL}ba0&}VdQSav}sv?srP^t
z9f1su*2%UzH$!#sD!;FW!@59&*tlf8?n7||QGEv@x_Uh-j5Gal(a5q<G|Efx$rB!%
zw(drd5(F!|IZ)H#(rwo;QS=^4_hnUyI>(?ckz4ZV(tzc0I@&gPEAR1N(cZUZUog4I
z{dGB5wLv@FeJ)KO`r^{zJ%qb|AWqZmn_=o3`AuW7E>CAMd^k&9;Wn}1TvS&s5h7!w
z;1^Tx$Y&|e`LsDYi&{u|c@Vo=?(+&^4Uw-r;x``Q4QVxt|1kBsFZ=U4oY~N3qXh4(
zmpISbO*t1vCYjw7PkbnNyH#_oN2`ww+#!Yzcf;uf0*^>-kO9qbI(q|ulZ2Vk%bU9A
z;|C^7w{5X+K=nb+sQQ3S&A^qRlTO4^EF1^0udFibX9a-N6R>rM<4Zbj@Pu}!HgqPN
z1Q{$|en0_K(E_<;4{PQ;3!`*Ik*)#*jf)-ERtv0)fE($O8~cWt+Lm|h4ZQ<@5Ny}I
zI7>N;PBZl3C^1QBQ$bIEa+ghnHu{(kRnHX$n`)4@=D2Ef;!wL$HNRkkAHX~%Tl%0Y
z@^*g?MwI$u6(Lm$hZ>oV%8X0q{He;WANK%X4UB9H*%nS52<EFORPhaKdQnMdV+jjX
zMrzgKq*(D=<66a$LG!NTdWq7)MbiF+z#3}gJt+|^BpgZ*#J*{N%R+{pN|t&Veusk}
zco66Vn)qtSdq#O^2d4_Vi<XNaTk7`u9iYz&$M$!yFD`wXS3z5xfN|}^D#x`#tGiHC
zi`R{xNMMIaU^P1_iYpHt2yTJGhhH=iU*=7t6NvMpl438Ol`WRe!0O*#8(HQn^8zs;
z#WhzBZ^7K9b9G&RJuNzgqm=#$=1XLQIPoYASRso{m+YIWX?^;(ML)Ec0(IPh0N$Sq
zv;)|dF`k)J3<(aBFAnLX&){hdfAf9MAWZB4k1)9vVsQwNp@|jFLLt9i+vW=HKraMl
zb%-&q6KO{(;3M%J$}?ey+JS|g1Qt6sb>W>Mtd@0I<t<`=S!zW_WckOUxs?7Cu3au~
zkI|kZpBkuSvD4&9#~GaLc=9v4W@z`tD9Nkv3vj5?$)5#tqPBO)V%h|v4<RsbD-q^F
zlbBX7oIq(V6a_%1=CUum@rgmcqUCjv6gwEP7epWnji>9WkbsPIfTM^znUb5pc3^IM
z;2zUOU_+gMzuU=0xTm>e5)EG1JX%1HDJU<;qHT*qAct8q8-D2G9HY-7;WnP7Y2N|j
zJ?DtKD~j73h|vxl|9Au53Ao?(BY6<tJD7D}N$T8AO1pbgcu9r5!7cEXetkP77Z$<N
zBQ{W{@rb`a_oGgdjxdk&I}l=mo%qDF`Q9Hn+wG)(94d&#N*zF7ytKw&75jW($W?--
z%A={0BnYA7*y1}+($4iMGyu0Dlb{#q9!|(jiQMEd(Ih@1fbx~}2!@W!&!hMS3h22d
z0hvcjqQ;a0i)41=)Mr^bSs*sMtLUAQaEu<-Vu8_A0SS%JYOn$RE4U5QTFq0TnuCCK
z792x=%%EgJ%L}>@=pL9V*(xRJE&N`5i)?EzE^kXgB@pI#2JFiWB?1?QzFp0L?Q>Cw
zJ8u{%b=C|7?@$~%MsMq;Bpib%m&cWPy5@rHI}L44_o=rF_fX{V6`s#Xs?k8$bL`2b
zF}PfD94aQGHAC9WRza;sOaUlFH|k3F1YKEwC_0(;!o-}b9Xk@n%|bZ{2pG|g&(LB!
zGXqG1+dv}cErFJP%|zh}u}?~U-f?Xq&_L0XL_zCa-jU^kA~zf1YdlMCK^b|M*BDqA
zXnn!Tf4c*lN!LhYN?EQg@~*j1=$`qrz?#-?2PO^H^omzfqeT-p6dm*v7~TFX&1cGg
zAwXnxN1Q0w`AirGIkN@5=&opRMUn13cgmS63|KQjF<O!IQxpk7Z^}8!dK9OCdCOTx
zVsTA!uL__X5PU69J_$>z78<@llOzt~D7!_I7k7EPwmTbzNt)g!!Il$-cEX(5eE(XV
zFAi<&{)_qk7={l|urIdB9EdWrE&6?b_<T%F5<l|8!AmaGh|Q@t7Aa_43vyZ3IVn8U
zCo~4rtdda03k7+SyEghHoOYCX^4Tzaic#W)>Uqp%6bM4i?qPG8UIDZORnVSubyP9K
zS5II7N>W^NfGm<`Xu0#&P<ulK#IDM_Gt*dIV8p&J+SQC_;IhX_vlpxR+AuMHi+f2V
z7>dywtSUwe?`8rK+;ic7JVr^-P6v%S;DYMpxI6E-KRvb{%|DPQOAwQm(<u+Wjrws|
zK^tG%>fz}$h{Jqew#<UacErC5XhW-F0BfYP0Ea+$zhDbfargWtptT1*FszmdoVr8l
z<wT@rIo6EC7=8;m=g;&?p%!5zL;?r_f42gSQJP|0#6r#=5)X_Pl8j?CbgeKsNTn$v
z#1TC#ca;joZ1AN77*o!&#J&OVv-4toAVZAw@fK-a+Whl1h^MH+q?zo)WH>iv=sKo%
zl=A?x<gK|frI4}D;+5q&r=4Kp7ifu=LvK2BGbLD{Wi{Q6`IU4+rAOh%l!d`we=8uq
z3Y`w1(@voA=uN<e%FbT|+}bQzXh7uVF9NTQY+=N=Z9it(A`tjE{zS_*K>%lOEu}Eo
z@9D&{jb;n&tvHD>KRv*g5(JncJT_#56Sl#TcNHdM>2pYw(nZ&Sr5zMBQf?vbMR+3n
zkgziq&r&afAFJT5(dfqd7U6@we*g_wH=e0Z7Z~V9S0)zewQ(e8Tw)X;-d!anQgi5+
z4}DYTW4;=jBn!9a%!bEFWb!fa3{YW`+`LPcUY4CsB>SvWA0c5;ZUq(JW)jEi#B07z
z#g{}{N8Vh)6_}!w*_KL!jg(y1v&1u2iVxGnB6gxd2U(<D(|?8(lZxw(e}xe`u;MQh
z%i`x_5pR9{aSH7F^j`X#iWI^4vAirp<j+9ZKZ9ny3g#AquTd@JB7w8A!70~{+x9!{
z8^6n9!h{Ii!MU`;A#2LZ>g_K(JO?6>VYc^x`fYPLRS!&rhzrS6mft|cpJT3_E37nF
zx}yCn_v9%k<=+vgsg%yXf9rl|=_d$qyA`ZQOF{fGT(9IhH*L@QvL51M5GDx-%A4e^
zgkb2}fH2>cRmn+A3<N@-YWQQ!A7t<^iU8*52O_`zt~Ljt!)g$CrJH-|Rf91_x3b#2
zdG-%ZE-ao)K@;Ny`XphTn#F^u*`%P<_-hBs4@ZvBF;#+&KQyFRf0Sw>Xi7O^$iT_m
z!T)>w$H7C28BgF(1(6FU(bBC64NwxUa84H{0Hh8rIjEvXv=gi6Tgl=uQH#gr7e9Xa
z_20hy?wiN^j^fazOD9+|tGHTDFq0-@Qhc!xutZJ%_VkFo;7b~&CcBw``jH7t4FY_?
zY%#tA9GNubO45Ycf0T;@%aU$@*&r_pv_|CRVMj?{6dH_8{V$KW%29L7GhyzHsPqs=
z^tKrJ4mF7Vs*--}WXPyoxH|}EXvjCtX8SWSd5Rf%isS)fMcxg023dTLRoHVL!ZY;3
zXG*svTh5`G(Xc^j`c=Z>9@LT-pL!8aVrOUg1rG_B>z20>e<9$GviXjv7j6Cn52h0W
zb#@01lTtO-S>T(B-ol|X-MaHXeYrUZrYNJ)>J4Rcefhp<F|+vR#|MHiSx=AKD^3k2
zh(Ko{)J?-EN*12Yf-^R>+ALI;Ev-uoYGI5eOii(ujO9^Au!}rlcbI;mJfM@TKQ{6s
z1r!AHPymI(e}IaeuL#8mzBq;WvB~sPA)1H1Y$(Y)<a<Jo(PaUYPhGtIg@l@CFT7=N
zp|M_H_<TH=INNb@gkvQ&OP9!XGP!0Sx#!wKmSg%s&klc6wSq+n{sLe<D>%Oc2<~-i
z=Oz&L2Xh|DBvDQk)}3uhOKJ+JEWEK=IKXh=*)A0Re^4b^cwaEl3s_)GUMzOwLap@l
zLk!8}@+$Phz|#AOHo~mBS!y7;3qedQLmy%VI$fxy^FHA>fV$lH4GXc=I<z*Mr2=q4
zF!M1z=7C`*8H6vxd6wPCAW}rop%Y>o{ZxWv90>U0kK)MgfFnbn_goq;0xOctW{(l9
ztur_56&S9kHYYHip@j$<l<a7@{|)^5?a!C-q5%{EG?$T}0}}!{H<vNK0x5sBT3e6X
zxD|fSuNZ6}>RF5x@hU2B+jg@^(Hl1NQf&7@vE^7>SsF-krt|N6F4Tn%HRDN91c)h;
zBG3JN=V-)D3jf4Sp5A0iCAoGtyVIMLX1mWfJox#iH^T4R!p7}l=O6ChynS!XjYyL`
z&Be|AVR_X3{^pm>ACJYuP<DT}Tcy+{dw09l+HCHRB~SeQ)9u#S&2P7212bZ?8+iWI
z-fpGa?8};;+XMgp@bORYVMWMXZj`?L_5ROqe!QQ^Gg4m32kv}<5uL$mc4M7Rgwo8+
zFYj-i+MJu+P_+%v{3}ubFWMU+lH3@HFK(5iH&cG+p{q_s_q6Sw`k{Y3ZJXj$`nU4s
zbwcVSOYQj9Vp~AfHa9S~H(Q|+VR-L{<`!fHLT(BWmsD=^uhgVXJK#gMDgX08!fd;t
z+{23CJ%=+ez?|I8Y%B;eHc`152`c*i;oZA+W&$dO2I`y`-%UX4LT-L06%TlC*Yr%q
zfR=y*e=?qSvz2+Cm~4OKQt&B!C+yaO#X}=xl@HN!gN$a#D5{5+KN0KYq3!&BzgKMf
zy6BHl&SfeRrR7Nd+Zcx?$>gNsJ2=s%o66r=_zTKi+w74ie!L*xYXY7QU3-d}gv}DG
zUo;765^c;ZYm%TgAVrlZA-~;n>vmTRrPp<gK$j&c_|HowYg~UKVOyZg`(p(bplk+q
z=!v4I{@9-DJ&y-8>!*imSJd^BKiP$51}EFe%+TUv@<|hwsd1Ax2)>~r&-sG?wg1Nd
zOMmsg>dM^!w}Q~XdX2W54}*Wl(;c`KPZfUYq3HZ(id)Fav1Gjn>k<p$BoM|A|M&nN
zl9^50z?C#QfR2CKj>ivO`?)Jlr?TsL;_=w}LDe65G_=!RVyW7fe&JYF{v29)Y@#Ng
z>jacP3h8_A-}~}VH5F=SJ31!s3mvm8y4`U*Dzg7RriDC9l$94&>L)=eNv1Mh`l%v)
zlxPsSLuXQXzF9ZI%q4mLk`1af(PA=`ec4x^n__6YJB)u!dNZJt;x#BnytU^1gZ9r8
zkH@m}L*A3ao?`E3j(%zMaa`VmhYQWp^SV#-M5iK%-RS!m9*u_ZIGiaiDrGnLF3SO*
zGq6!elSO?l`*-o|;UEZ%{2khJvww)nK_#i0!&c-Z(1Zxi3H?7f&9V`^a9lcR=b;#m
zYZ}s7A~S#WinF@%OVytHD3^JXIk$+;D8ZuH#}1Vlgg<+EsyBCK;H1kuG*l~bSR?>U
z0t^4jRugB{6<V@D({vIA90|7Bol72pF*ZCx?@;M%cesdFQ}}o2jyv8|R$!;y{2u%?
z<)eS@dCwD>+`yCPrYk>JaB@ch4rbb>ykp5&o1}k`00Y5bypoy@mnNNLSwHdg@-SS7
z!w48yf`ifgXTc`q)z)YdH(O9g-o!V9^B8g-etfLzno0OXc%kHnB8q|l3z#_vuivg9
z7rMy<Tg0_y^IN$i$m4~kvUFiiUb_cxp8PXu62?IUp&2p-_$5*JDZfOTYtNlO21Yvy
z9nOEt9U`35gv5*;@%KyDk)R@ZS2;A~?1j9$9k&HWGUs0)2SX^?7Nl7c1k6<f{~n9J
z`Mn?em&ocbUMuRZEcQN8$NU?{nQ_;IAS07>HaG8Na2+9O8la5NXgow{&%Xu#JV3^V
z!}(!^bdWKvOfD1V<FVS|QMeflj}i*}`h<T17Rm|5jE;>C3<+X#U^LdgZ^?Mcz^Z~V
z2pKof5R-#4kh%4%Lc3gsP#^#uobI4IZxKv;4&n}Mb)sc<O~eL}B$M2#7~%(;wSZne
z9AZ}(o!Hs!p1VRreI<gRszu7WrGeKiA_546m7nHVfuqTA@u7&qQGhX8Ei%-tfwF&g
zih)`Zu7EkPUi{g|0*-^2r}Y)_#(`P6Al_Wm(MTuaPyC(mr_ykQa6t&_shC0>)cBDZ
zD@Z>-9E)Kb`3(VOp%?(-I$>t872=?;ye<WXMW`3ONFH1E_IF?fX*S-kr^tolYUs=Q
z;QdYHNop=q_Nky!0*p0NY{i*ePD+38<FM*e0#;|ycp_3Li`7>!WV?n6Y@VnYwfLa2
zyl@dzV48vo{Bi_<<pKTdggPzzp*TJ8GSwCHHW^qx@SYi{99_JA#y-krtk(oM>++75
z3*Uy}<6)J!qbbjUUyKDBK)FU-=aLFC_NA?_&^N;xSZ0&(MT9g^=ej(sBB+1dB|suA
zlxiS2Vh-w1N;Fa~GbTRm&Rth>BZViXv`J5pjiT_tA+v6ds%=vA`zWt6F?Qm$idJDz
ziW@sg?k$rvyv3aLc4*%|bGiWdp^aKLB!JUT=fQiu6N!jgLxc)AN~s0vYFEH+ZYRDc
z<v{oga34O8*;-@MX>N6doI`&&gYY@AKAv$E?@&7AGa4DtKx1}kpia!^-o{kmjaWYu
zU`8^GjO*doCc@2FfwBZz<_J3j?>V$}&Bb@seCD+Yl5#x<*FzX2th6xVl?Y^(Dew6z
zB6nYtI3}`~>amqH8R`8MjV~_a!H=yb+A;splDwAo=Rk;E)^XQ!FkOG}w-0}bT1>X=
zPI@K;yb2Y%=fZcd)fHSk3n{^)<^RCI?;gHe3j^OpIkV}q&2l$lP$>JQ3>BoWVeNT5
zl{$ODn^AL3g%3r;zau^=slji20)qwL<6D=9fJo!A$!|aY^W*)Ge_a7Yi}HH`gY88W
zNav2BZ*y_Av^`XHyqkXwDL<dFR$o)<HfnClco)W?a8cg1hd5IJjP+8<YXL8+Wf0cF
zRJ}gUEA+XJRxk|fP^n-&i$dA@xJCmw#e))jT;UanbaQBbHM0mO^VuU1nv6vF9t}hv
zU~wt+8Lm(@`5b(J=fq^bS+2glS$?P>l<nHnL)(C}##8}OQq6x#|5WszL=-|)%TPWU
zdC@9fbVrwUNPYn|lnw5Qe>KSFP>+OjH@lfY5T1`^0JWiEyf1sI`#v{R>GHIIAnw=u
zGZ(c8oqZLBJ-2l_B}h}uy_GdNU;q%yZXTYD@DRUW?U@K)7Njvoe0mj7+=q3~*aoK3
znWD0<2b5j|w+?@xhRR>0IEdlkA>A+~enLS03aZv(x0q!wbX9|CVy(UCsAKs9*MvAC
zUOMyeDqeKZi^KwfS%{epeXgCu{oT?J)hzR#PvFvR+|=w#p9)~a2i8xa+!nA31>@O<
z$gAwgwR@Ip@Zc+K4gzZ)HVY(ui_kI$g?6A$G(=2f9j|}&Pp4Z5ksK)7ns)*dEvtTd
z-TBvf!<Q=Bb(DxuX0W<zOUzGeAOl+`^JY)i8VrVT=X8EWbjXdk<iDG-vV+7EX1czu
zzl@*IB!tg_5H_{P@G)j8IRAC$0*jYiEt_Px??h#CKk%V*KALZsKCq6JpPT=V;LO!u
zt~ewSeMf))`XUS<b7>fG*G#<X=RiRdOl(#AV1mlpdpn)t%4*RpT)O;|fvY0n=<%r}
zlzffHLxq!zD?C0|S>W-R+pO3r;7U82X%j_?GNW$=<E|2$Y_Y@Ca$7W?2FE&`r~vK}
zodXyWH$~i-W087lmuJ~R{udwxaPw^NyP{i>KjeRrspodMJTi1N31BdLb#hZKA3s&G
zpDAN5zCTf}OAWYVf3AIafyV%2;{>@a{GNL%zhPAPndu0Y5RN#Fr<S4=ZYipoNBH^O
z&$Us#Wf}1BI>p&gaU)HU)2TD8#l=^IH3g+hX^ww1w5Fiod)=#iF2f+|UY}%F!>vwo
zaYcWU9fM>n*9HOf<&--nPLnvP{@<K5m>Ti#eyG3h!)7!+QT?jF4V18*<LM*NpMo=z
z>u+AG428r-^b}E=s(#tRF7DApa58`R$x?ZhXaTU#Xk%5h`1e>g$jO#Iw(2ZpPyqr)
zSYlHCRD;U|OPp^w5G=6)EQy@Jk88*TW1uvY--=93%67?A%yx-47TzKu4{&k2(z`Ca
z9ebqM#mL0Jvbm_uo@p}$R3_tJ75*3ZTUJAt@uC3}0XCNrUjr1Eo|XYDe_C5_+{P7t
z_pewu59K0ShWCs5<fwI#B29xxDNrN^IwEJaQ*+4;$+e|_-*X#YRwK)WVeeed%$zyb
z?+hJo0{9bd%3zbnv0o;|raHa}XtaOWaO0Q1y$OYG2ZXx?<@a}QzI&ghn=tUppbR&6
z`{h=5_2xJ4=Acfa?zg)*e~!KUdb>-K)Vn)q9{A_|c9&+}f489rBcWG~Jbvu9yQuJL
z-EhC#^Y6Rczr2T;Fe)Q2PPZTK{{H5#cN2SQ6n*7Akn)v_gkj+qo2*FuFi!X`KkV^D
zAS_pefuBaWGtu0uK?~JtyC?yw+)|kVZc!GV64Gq7Vd+OjYDufEe;u3~W`3AX8&<k$
zu0TdX>Y0)EuJvFZS~Y4pYeb<(Wez(YPbA*1)$JC3Wx>8Xw>3BKarnu_TolB9lqB}t
zy=m(mZisu0E<TIcPomP&e>UTRk1*rl+J6^kxgTcnW*5eALAjmkogxVQA}s9IYG4~7
z4L~dL6kNw~L|R~Tf0A7Nf9!oy<H2Y09LQroz@3n7FiAg7(#<Z4iG5m@`;i}_g-6~^
zcRY42?2@OR8pqz;pGh;=C+mh^R!khRV&HdlY94$r%>B$-<-4XquPPmS9l#`#yzqMc
zp!&Me!@!hyApVY|W?rO)_MmX^6aJ%x>L87M*EAhYd^YU^e-F)9@wdCY3}<eZm&Cq)
ztn_Jg=_3$bhkTz_9rX(apC*%As9r)ycN$ICs>ZDrS@c{hRxdwc*m>c^OF`p-R!dPX
zV$Qvht&R953N!Gp;)wwSf%3wkt{2nf?(lR(dET?y;0_?F0^`iQ{u$8~?|}Y8)0gKa
z-l#qzU%H*$e}Lvid8FFD0yn8iXqO7OI~Xzdu~+TTC={?9YW;vsrr&q{QP<*k95Z;~
zL0nKjib?hm;zx?{LcTw@6>aPaGFj>;=^_LIyL$JMVPuhCmXkm8m3A@Q2rje>Q$Non
zjQrZN3q*P7b+eWCy{T&y7LMCnM0xN+bPh^C%_iQie=#Jy#95m7Njb&n$s?{%BqAg{
zv)!TzqHHuD{Mn!vF*|5!LTA{kb${yhh+@Y<HCSe;yJQE=xAcP`TkCfa?N#RYAWUp-
zR#nyYwHPWe*DVY+2GN<v-N5mp5#0_?%#V5`yG^`XtuIq@9D)cSnWZu0(L8!3EnDi{
zg4~gse=j$sTixo)+G*@%e#|`n_A|0*WkPe8*B?Gy+2H;lHw&|8&;pJOi|8xwVX0ra
z$K|H8{XUChNhCWy4`dMsvVU#M7;JekHp`e=l89CF>k&>oA5#)VRkX|IB4=@T;1Fnq
zD616zh+A1!5=b09&v0D8RCn%s3;HYuLCWVjf6T}072X|E9(al44B+U{otxSf&m_y4
zN;M6}ry`J8s<}g4mvfkgA<D?`Yd!7(PU4Y4pH#2N`*<S>deE*rO1Lp(LB24I=|^=u
zHFD5@T=66hLqLX8JPG~44?~x(z(``yywLp#<x(Wx`z=Hg7H<i#x!0C)U|}brFiHKQ
ze<;>MIjY%PY;<4C)a5GTDZ_I|j}q{?EZHOg--0}T#X&6fZb9yFkjqWK<mgjPQS1Hi
zG>rPl-G^QskE;J5Y12A+>~L~CCQPHRyo05F<qnsdu96g_t|%zhSqflA5{9UZd{PDu
z9F^Ew5=Q7qGCY|w4*zl1y+PaLnH4<`e?I6INGcxvVh+wBtwNb3_V$Tc*$rSf!`^5o
zGA(mZ*R%uyWgJo_!NbsKhy}BE1OFoRqv*m+ujO24b_Iw&XV+Sbv9=KRDnqa{OBp97
zS>_SrWX3fzR+fy5kmfTB6Nx5+-#;<Nh3RKI+x0w+1sVV)W5XEk)9qQo!s6QVe@ttR
zN(x(xvqNv;cAR@-W_d4=sv@A;TC8Q`*K;owe03hCT(12G->Kp>r93JU{5?p6N#3;Z
z?ePgNkE!!5d(T@APj7+L8Kc5HURr>dc>>ojgILTw<GG(Y&Lx1K4{GF=Y3&G2VW9yb
zJw!{2i&BuQkX!_H7$O71RTsG-f9DKyUZ7|#p*}|xZ`WIDM;*oca-Ej1%O<BSLt-zX
zNM6>k5|dsH?1-hJ$osk1!}+N0kvV|FT-9fc@$vVF;o)2%CkGx8YzwXPp!a74kYI^W
zaDxC3C|T?(rg$(cqn5kO8^TgZBH#_ZHZsE)6&5z;zE_yCpJb!+c<6eYe_-eWD=W8^
z0$jrib1?UfUZcy8#0C1-s%rSOP2q&zbZ6NG4ZG1&-WZ#mo?5=Y6EX!ZtQ0d=`h~Fe
zA7|5(w*Y$BYc-yG{WbOW9cJ8K)rRX%5DDoBu=gVKU>DTT3pmH3I-i^!M_|(VI1v`5
zU*?ksee<o;%>e%fQ{?Nlf2tA1<CzeQYJ;T~@g}tnN}KD4syWxfKqo7pE}sY2p`>E<
zMgizIFW36D72wVwzB!7c2&ljiC@KSUE|PGDDL5sdNW$pN`}aRwaVX_11r)Yu92J=i
z4&5*bz#45H<cukQQEw`b_Nvk=AUM6GF_WgXL9&6SSXE=#7_XgAe@3~V#MwH4ee>;b
zUtt)}z<wxp?hP^vV9tA6?e}Jf^Dl-<@Ny^)qxGKes0xj|Gs3s=jIVb*Fqm3e8U!0_
zd?<}_ei+5kk&rvK)alfBY6=W6VrMwc;;Oc@yS5LF?Ca7aj#o+=J*6pC+s$l=xeRq;
z9I}fcG&;o>M65|*e~S#voC>@^+Q2lZ`Y1iK$B+-4GLVLm*=BGUA~O$vHp79GiPqEc
zFF$;8TRE`}R2qIB&98fXbugdwt~)suWvSOi1qm|+TtiujY7gpG;Et#@Y@_Jtw`YAA
z8v$^T9Yhw*rb&s37U3H}YOxzOhVI-~1V2)UkD$CtCP+%yf0)XR)jB!p3r}z2Al7L8
z#tcqb07MJ&Y?7NiNnJh|E+m588KEWxIVnU!1IYj*r(MAa3|jrUZKv18kqbT-bO|#*
zFOsj*AfW6po5E!$C#lxrW9X3e+j=QW{2;nSZEMfKh|y7I)$*bT1|fOr_WPS38Tm}U
zv2gL*QS~F=e=sQIJv<3Y`Luy!F-Ai;Yk@=7rSiaZM@lMB+!--z@2UR7-7a2ngYpGW
zh{|9on`^V*Nh)*-62jp8&4J$tz^k)7pieq1J*XR?U|$&)=kw-_p{58qXhD%GK@02c
zlLQ>Bu(^<@_GCJ^O!1iIk2?DC1X+8S77OY{a@G#Fe+PQ~q1~rPE7{cf6(UXxKMh{b
z!r)y~{lTBCDB~rdmmj7}s?kaY&`Ed^D(Bmj<@z?*2f?K%IDClV*VBP#D5b;i9+Er-
z#UPsv8YjRQz#u3>Ea~MVQ2D|~pwd1)mJ7GV4g}PWz!G-qGr?!aQw#2D_`#T%g0$Kx
zepJLSe@{?xeMh(h+K_rb!UReyj=WnVtmgA~s<kw7`Dm6C-r?5tSi4*Xj8b`JNp&wD
z#-2DVx%j5i;5<-zq=Oq%nUQf_4!H@FZt}=I*{0{-#pC?IqvY1kPkWJ{g%j4lcE(sg
zPo~r~bi5(lPMDe1l24+5mXebh#5{2b?(5;te<+A-!UrP7#R8jpdNqs;NfGe@RL;Vc
z4|AllFx_#tBnFI}z2Y*EKg#J_>CzWDgp!>L%0JFZ;6g&xg9ZLn{qWm3$$VKBjP@aj
zKY~o6u#dcyia(NL*{7iS(?x<HUZKA=qpe<J$TSzl>jY;buw4W7zXJ2Ua!Dlv35KaF
zf4)j#1GrH>&?MgVW05V!J9(PF7NCg~)$wcxs|K;<OZYNMazCHHU|u{Dpz=vp1PNmS
z3pg~Fh8(maxOSdDck|2O5yKAwyQs7^HBNLqGJVIu4o3-sZTL7(w})XYr65{p=`tpu
zO%Afqg;AI1V&=W#p__mFdh?^B2;j0OfADTAqg$<|2c%pSQQ1q$lKP|%Y#aqqL%l%p
zJ@Nj%EfS0-Gz}oR?MC@{)0<JsDI-JfBohIyguh?3jmb1tmSGKp?1DX3_FAjS+R7`Y
zl48|7845?@RXzSZ$l>$?=F#`hZgf0OafG4|OvAF~pCgog3oZOGxhSz5AC$rfKZ?<~
z*yN=j1+P8PTH@VI?fRb{>n-Wz-)3d(7@S;wC5pW$diDsO2K1jDzKS_Z{AK1Yww#~U
z@ZA3ajfoGAm+_(j69P6gmyw_Y69O<amqEV+DSxF{TaV+m6@K4eG1!-t(TEYL3#9=H
zB-u@h2@<sE&RdfQTBgU!>f%Upc8s?Fz31>8%91Sy3lsy7#6ybb_MHnUA0qgZ4@LB#
z<5(0){!lh=B1i3C9_Zzte|sZ&T?h-q*~;&p-+cW;nm))#6j31`p7-;uo_7!b3f>>g
zaeuV^CXC}a(2tuiNz&l?V2SYe?IujK;J1wofFgr(Bzn_rLX`(QThqAP)AQSpAAW!t
zsR|Xu+2+^hAK!fcJc*Yo^@V!i${R&AC=!bZG+{-uJP|TZND(cRkRm~ORq(+cK_C^_
zc4ynNvIB~8Z3?iJ)FO*x+Ti(64WND$1%GB7`)Yd{Ee!|QOX<Lt)i04uEHBz23$Ve3
zg(IUS@HsjY7DZ5Y4K3_i+iu`F^1_y$)yQ8C)wZtMmqBd8EJ=c=k-qmrb;q&lT2s>q
zq(haQ4zZA_Bptf_2uz$ST3gy-F#UOx$ANH*Wdin0;EPNsnR~5mZ&AL?al)r*>3?Zo
z%W4FP>NAZ|le#L+Xm>>DZEaAf;ZPlkvL%y@sOM+==TKvLLuV7msjWuSzj$`LtLes$
zhtApD&1f*03=W1g4ks;UdY_S3cOuPCgF|l;j2#io@QDa!>vru<BaO+2dI^(NGkv)A
zc8o|t+u_Tt;?55+^GlRQ9e><AbAJ(?aiJL(pd_r6G<P%=Xxt+d5)ku=KVdC<8nF>s
zl6}Wy0^Wi_c;9dylV6dg&KqYQ8kB~iG#DhGIfk-%45?h?OG`agZP@iY+lOfWRHe=W
z_(OrJ+J<NiPp><(n+R{sTYlNTC1dzy*Pp&E-2%4=b;~0mbGcOQX8T)y`+u&R_VIgN
zXNj;#L=@}msKH=ynb4YcV7U3Lx$o+_b4Y;bA<}rj(0(KaS+Zb|ilQi%`$MA9Yr;q+
zGN44Xia`giN5;7d7|lIU8e$E^x$SW500_^Kbl?@s6oqgok|~67QG@TNVZ3n4nG;ba
z%Q6p=zL-lN=dn;x?8P^08h;idQ*v4XsbOUwkWGnPT|s%fwp}KoY}$@N?h+0<Y+)I!
zVyjXYIbciqJ<2sMiO8W&O<dNTER_^G$();|{y*Fda?Xv9ZeEGYJQu0X{0`nXYobR2
z-<B5ojPcIQ4h9|nheyIJt>Uh02Fn-b*i);}t;Uv85V#rxw-74PQ-4X~ymO|+XkKaT
zW6m6py^F8cs)1@$uV$ujEsbLeK-^C$;G2KD{0yPnPqg0teyV!A3lSd}661i$;hX>d
zWy&{Dc2y?gh@m%BP#NuIeb}1D(q@l;rRM-G1-S~m>mz=K-v2<M1W7>WX4}=Au>Hb0
zuNCR8IIRjpj3c46ynkWrljGg3?^wi3$-B;_{8Llh6|j)dj-_|yd;G)pgDar-w{cSt
z6;*R;LS7$s+uv+C-p%kj6ImgbNcmXp7=>*&+Q+Hcx-9}SB49=ZrB)aldK^tp^v~6J
zAkt@SW8B-f2;lcW(O_ry!+98O!$YY46gHN6039@+!mCA|X@8B)hzxl2Vq0i4YHZ{&
zVwl;%@U&^~_X23o%I-+(WqZ3CVG`Qy^eVty8-gw{b<J*qhNWb`>>=CI+v``$n#|No
z)d&8-n(^mdK5GT$AFTK^7Rgmf<*bkGAy?&Osz3|1(tMu29$AoZDh|u~0?>)4JPYmE
zshPU`d9EB>7JohaW`KIx>%=Le1a{MxyuVr>iwnP*lZHPlVW}1%%yr$(m;27jfGNil
zo-|S!Ov!awH6TzY6HP79LbGKuj#Ky|RkzuA;m++B`2T_y^X1Oxvz_AO6h7PG1m!n_
zUVb{20omafU#xh6$kVZ+whl=@m+yai`kCG-5COzV3V-GDP?fmHf#x_{G9zaa_vS)^
zNW3GSCu_eD&k}cI6SelCdD9P=miqI>Q5={w+{a^j@Vz{L%rj(s-uKtLr=RbA><pY0
z6PFd&k|Lf}5}ml405p$ISzVpn<P<kswR_BVeZyxXq>&di2B;gqRMda)-cF(A@rfJ=
zOI?`bqJQf%7f!kp4NiJ1+_m@bC)-cCkTS*!tTR1tFFl;88qM+s`Q>;y{!#A<YSY?#
zI94%K)SLE|(54Y>IPC3s>V5nf?#!xTJq(qG45L=UaP2I%Jc2D}zwm%Y10lq$U5G`V
zW=jcHt+v(|OD&Qq`#Eo_OkXgKgW*KOvNpruZhtDWoB)NhjSCvLj`2aaIwcWrPeNZ`
z;|Q0HF5dXGMW;GcOo=4A!VzE}ZzEI+5o4V+X^KT*4NQ2MRV=^+86#}%>lnHlk=;F<
zK;tO#ES{g597pJreY_EYZdh=p9jM3ed7_&ZR7|=K);vZ4Djfx<7IM}weQ;*=HJl_O
zwSQFq_VB<6eetIPca7+gYz7}Kbe+LxwA#8RpTg*}Vc%D~sgy&5B|Q&ll+39f*BY4$
z8>)M0?rD$iO<mW7Pd1Tl-!Xw<ltSP3^zk3wB(xGZyxY-ehR5`N@{n4KR8C%l9iLZ|
z0Qfdims(3#W6o%}J?0S@ZL4;|XG-qOvVUOL@z|9=_tt~!p)X~0*R$Kf5bPjS>dz&_
z@4FM;1tc=N+yxW`L)l$(c0?IYjJ2-kd&|j0g2rfEd`?$&`1ut+3SS#>=c-{6VF8(d
zuA%fRiGh1P7*~Hkfu&j6r+1APthZ}7r3l=2yXm;gH<dM*(@s}m{;~~5m?K^pI|q2B
z{XZ2f6_){b0}}%|HaVA(paT;FGd4MwvFHIQe^^V8+c*-w=T{is!^l9y79V=$us|l0
z3}z7QW|N*%PY!H}Zfm25SCXgWf4@~MQkK=~BnvDWXp^O4k@fyazKP(EZ}Mo9O38AS
zZHneaWU2kbh6W#heZd`H2#n#3^XJ<aH}B$j!y}eQIp5sw=b~=Q&0X;3ppT>JccGLr
ze@I{LLZ#y1_F#zc&-+~%C&9mWJOBz0ijn9|w+lrUl%}S6x2NCNpMH4<U%1FcAk*FF
z+uvWjy`7F13-N<`Am?`!;gN!`YLjG&aj8g~*Sj#u@}Q~Os?jw~{@TGwO+Qp!ON2tZ
z!M#<&&}2B$tf>BsxH2VC_gzl|?bdb;fAMv#X;JV<^fQjT6HM|5%z`{=U|J`|@BC*J
zN8=8@oR3wZ>-vlq+Ju}m3AtoECPj4HjR$m#%9CI~)1QaYG$4S#1eeGZ4i7t?ks+nC
zr_M#y{tWJ_+6NR4R!gp|7AGuA1z6c`g9m!`mp2Z2aBKGs2fN)CX)4%qCYaoUe^lJx
ziM@749x)-M7hAQkT9<S<j18+r)f`FV<)K2UQpTg$S%8y}#Yt9n1<xmW;y2Y`CdE}S
zV({XC+>oIgOk13HnF<*CAqhSiv*fLY;xv#MaBdGhXBbSQ$>CKoOgt;fh%9AU<_|R)
zcjfqT#N^y&6bwoT<hZuQ=o7Lue|s_rdFG+lO{058;!_YWS%j-WJd^^Vn7|2&NWq7k
z#hA|`IO_4x>c*@c3)b<JB|fEY4;APuc^c?(?5q3JXlUxm-Ejm3G21K?#=QN!cZB<4
z$`qVq$UPpa0!fE!Nu(tVPQ%H|EA(Jo)JqXvSk@8|=~gQ{daUZ&nl!q~f2=9#(VVBj
zl-78gDF+j#q%#?Y$)bdDFsXu?6sMAj_&Zh1Glv)MwL*3+((PP~l#)sY36nTb!QBT`
z)Vt1pTU4!n_>6{933&LyvG8Q6goGWT2K<l?j`!OtTnn@sxMSG*iKoyl>0rJdYbYeT
z)m}kLHsm>UsNW+IM~XXKe>%mTO%NgJL^GdSPH-pW5R}2ucdPygquz{mQo{IoSO254
zVV&o&uf|ZyGaG9w37*1GOlf;b$h8cQS(Z<%jV}6*Ho+vo*mD~>YS9}_$H=hXSVm}V
zV|NT|Lv5_y5`CE30nJf6>d9sxiZ08_C8ldKoTbT?*^WIeDGXFTf9MyXN)me*l|WB1
zqa)Z7m|*5|RU2P^@Kf#9J6|G`Eu8aJaC)MwWh^pOaCEnrY>&*e3zX{&LV-$<<sGgv
zntLCNx~i=;AqY%8m`CUwh7p)q$zl;nri9wWQ0Qdxoec2I;e~r81r{QoVylEI_T4WA
z?bt%7^5B7Jq^yhKf5&P(5P1qMo73>g<ur`AT&kqvoFz&6V=8&(Z>zKrX;q>O3T2Er
zC|wRYD0#cfBnBZK(CX+M;+mHV-n{pEOeG9vMc4Oc@S#!KK(x!8C{2r>hR@5XhTB8Q
zBxjL;2!{rm`VhZ+hle_~R8D#D`I6C`<#8+se`J6(Q=g}}e-myphKn|tUzKg1f$H-$
zi{M_V2Vn*lmDj=h(Tu0QwWUrtQz<bwk(!$*y_iT@6Rn*rj{yYyk4K9E9f%1RV(O$k
zu*RbbE>`5YLl36{%kF_@+EcqzU-*&@_)hQzzH{Z|r4JG+;)?pVrCqgZeF?1E_~=oS
zp=`3N*@>|de|*&dInAqen8wmPzYgFx@54Vnz5V!iz(^vtHChkl{?$r6Tr=#ewhVn;
z#4p>gO+9R}I(xvpELng1u)X<XfPQ_`A0KY&YB=8DnwwRe8?GG|f!6<BFFa`i_%qL!
zzM88#Eu?k|*gX^9;$Jt-v!)8O2qf~WR`r~{@E^nJe|8N518QM0>ViO+&v9_#aBz>^
zNeZ|hj+GgH91cr)1&1LJJ=w$I6|CXhK`71w;4iy44)g;hbehgOL7HJJ<pF`0mOl69
zKc}iUG^ttuSB-~JDI#r3&(lbAmtZupIRQdvJD>=+(qRRf*}|J<)Qz8BP@Ns0-j}72
z)2$Q`f1!O0_-P>eu{U8!osU@6I)WE7yAC#|dGMj{@SZc!GKbHAae_-gC3Mu5R!xCr
zf$STu+yJ19f-C`&t*Pu_kH3+BzW~Z)C!F9#)PS`OO%EDn)0U2*qhEg{93yl)*19l<
zt}ac#B`SCgq1xoQ`RV~^1Ki&Ip02SiN{2fce;Oy_!Kbb<W7SwU1K4p5B%zZ~>5d)1
zP8<l2otikhJT1_?(cXc;{-wPD@|oxvva}!Ofw*#B?Qy_kH8^DBTRQ?!v}9GfB43RT
z`aqNyW9{zjYws8<d4)x1R?{H0A*;_GWcZRrUBi70TMgc5%yaJ=0`KU_<%t1Rf%^wE
zf4RXy-wOO)K6gz>bH5VM^nQH<1~6;7A(-*tUe;(I>V*QUO&vPul>m;%OXb|g_2j5D
zbB=;UK2qYKYYL*ADC0`Xo0Q->t*M45Wd%Yk2FeFpB=LQzr^hQ|#D?M4XsSt>H8V^~
zM|OqGJ_V%Hlhul`t`qd_zuvDtGEt+6e=ZkHu*=YqM-c@Q;oRUht`^q5D)+?p#U}0f
z(LUGp<>Kpr$#j5fy!xOL`cAj#CIWkj1T$TixD@1_?rnD|Y6uuImb>ky{yro*)j#-M
z#bpxWD9tjw_Oje<diUl@>3jy)y2U;SEhG!~a93K5#f&Y&>NT7XpGFDF*)cU0e;V76
z$)kWC#?DU}T&=bvN3zumi%vuHvZK&)qT0?anAIMbU0w!&$5sy@KA6_@6v_Bf+jmYR
zy_`O+`|AL9dc9VcS2ln9^fI126ewE{@f~CI6MIF)YB&%QwVEKIHF&?)eN~_73tf$|
z_*y7A$)YPb%(N4Q9YoU_Z&f50e;u7(SFKy3Fr&2>MQ2jW%d&e(w65~c&tNYR>}|Nh
zfD9`v)XoU-L#XsytOGd@e%oJtzBpP?B*3qCi4!=XflS!kq7h<&`O|~VKI9nbersjN
zkzo&PwV$l^gNUhUy1}u-YW)B=M#<&r+gUVL6gw+YRSZx#xkzQz>O-!SP%O@-B0fFL
zgJ69cot_=^{Say)Az%DveeThnimCbG2OB}Lji8s<<Q0lcy+{{nF}@GjVuO)`)!OlD
z`e++_cftp-!f8nwGyih%U$dOYn3wUQ0TY)4)&Ug*H90ev(b@tmf8@3ie&1iw@Qc;K
ziWWst$K+{adxHcykn98wu-ONWn%&J<Ewy!IX7b?Qo+=ipYt)&EgT*W<vPjm&s;}65
z7r{TiE23Q{1S^t!S6<#lcC<b1sPos~zT=KA1j2Ae`J4N9-+YvE$0Jrm1>fBt=Ud$$
zcAtZ9&+6Lib{`5Me}e38A0~+m?$4SA{`{~HWg7f*&jT3YLD|#zrP+sZ9vpN<-_4QQ
z51+pK2s1n`;y~p4FZaKH_x=6Io{Zx+%7K)x2*P>J@?DxIjEls{($st4>R<SuZaZB)
z?{g8n2bm%sJlauUGtYyIIi2ydr_ZyRmeGj9CJRojx}Hr*e`EiMcv5Ma=+DZnEmd7N
zJ&itCrT8s|zPYI0l&S(g?0l<Fy4J1g_2E7024oGnU|bUW4Ok&A?BUp4+veID-K+MQ
z2D-Cq^?~}8d1%K8;s$$ONbI+|)P{s|i&VEb;K9_e1)4lYiFD@{9vW)PW~iN(=BvAA
zXiL4|pOXNjf1!?C;n-NGN&+CKk?YW2VT&wiI_pdw8#j?mM$U+z22x{Lsjl;zdH<rb
zLtKrAfm>ROz$yC4bp7IF0Tz`qP_1bOw@sz$)1Xe8P6m(4=N=Wyh)FO;M2vj=-QWNC
zJ!nTrbo8!l&BI>C*1R$&efe#cH;l6+6T2{u7+eI}f9vzN&E;yvYHCeN{o>Z9;K{6z
zGRC!`$Rd{Ix#!{19EM77of4z>FSP$*c{PX1-C@&_h7^64O;zc#H*i;Gs!f7!cnHgh
zOMl~u*=<wZI<b5qEFE!H&JMkgFGpaeL5fE_%fO-a$=kDU9ml3Na0yP`9qA!W=6c8>
zM93vuf8ZI}q}*A=h*>H}^WGts$Y9@X={HSTDn{aw;g_O0?UodKdSz<7Zp62j)|+6`
zlvVGBIAK<>xN!2w|4E*MKB}SW!%?o#UZE}Fcmh6}$A0OD3d49>1mzxX=h;+;b}~Or
zY>EvNj~E_t5q%z-`s<#$9WBtMIX=?}DABame~&`Xz&!jBw^n2N=~|i6^fqv!>$cvP
z>!WU4ui(C+=?5ECTp;kF!fPFR$ndjchiz)zsq&Yo-5h5cKj>?CRHoY2x{ypnsb6_d
z3<6WC?;*Ghy{6AcRH$-ut-dr<c0$49f;<bpDcxdEFwEQ{_^zRE%1O`}I_*^MPM@pX
zfAox^|KB>jB`PkFd@kxytA1$pjT;lm!V{ai>$SqflSiOR8FgB(@qmaT#xsBg5ldf%
z1dceIQE#Av)s_@|Tm92uz-v7B-Iw>6%6M>vTtFNOxn?eb2rIJWjof+aSJ+!`YWZ`_
zsM=|3LsLl>vlx=f8<}y`uQ9XQl$13Ye>o(_5rVTEcbg}h=872v^=LD@)g$)ec+Gmu
zQ<kN0N|dpr$X;RHQ-?G14c6D2x(h4$_VvyS7V-QSWr<F=Mpaw>o(Pu6@izZ()_5r+
z408}X?bU{l`PGI`8U_rddsH2VJf}*$*=L&X28v~y85HJiaEo#u+@j(JWj-;`e>pQc
zb{AIchKt39Nnv9twh+N6P+D(HEEKR43X=qOIuFpcasm>J;g|<UP(_2m8^=xWTDPN3
zs@SP4bi>}s0oHnCYAY(C8MC+Map4KyJ9o}<T)ohPVcNz|PEv|ECQZi{s$8f?NeHH@
zMja>;3lI5^jh|FBj!YSghv38Fe^Iy4jW{JkEr6iMVzJmkHE6Gs1~C)E?iYXHNZJ!5
zgB!!psu{~=?h}i4*_aRkeaw$+Tw4FJZZOw8x@3O#Pz+Eg_!02sx~*E&RWzz-(G2~e
zOJ`Uh_!*1HfwXY~(b*jhJ{k`@Fj;Ms6SZC^dMJr3Bj(`3%|-WTcfL#Ze-rFb;8uPE
z0=o`?WtQ2o23Yvk3gO<y-y(;=GvRcrAVe!!F)IVJ*=@1q%z*~2JkYlK3fXA7x7jVE
zg&Uza3}BQIZ)F9c1ZdI!%&882fkUH}seg2^fn1+>UMQIgNi!B&tw&trNoFjJVcwN^
z<a+{8Tmi)jl{)<YD|NbOe*g@ZEt|Y7br!Tsvt+C&CJ^GJQe%lj(X~=mn^SSQacY*l
ztq>Cl6H}039^YmNvR+n8ndja1iNB2a%hrVyTujrS7ZgX2%kh$ml=@G2Ra-|fCLFi5
zD~2<w>cI~o<hx46*MOO?%yX>FyI<p&OJh{0Zx;I_CO?f1LgfPDfA^}>k7wOdR84|U
zFA+@)mdc_6)R#bRehn2k;&7tg0tL%0=`~?q>ZVMPBYYkoxFAGM1`+t+bGfLNa7{A9
zH9UO*$z*P!$D0K3#Q$A@)s}OI0*kN|H<)`Ap!U|6pUTNtwgBE-DOBr6H#@zhB-8T<
z)njxstPVQ&{O79Oe`HJ`o0k$$;gp3ZJ#JhPDH+d`DOQ%Pi|4(f_%yyyY#f9R%A$lX
zz3=X3ZM%#BwEwex7i-#s4{oRN7Pu^s!5)G|u!%hrYMBf+31a|*PT3iY(S2kZ2j8NO
zjeV)eq|-8VD0GXM0w1(JjrV)OZT$(2-sCy52|V@hn18Z6e@6TUxZ}%;wxcn+kI*@2
z4AS%p0iO>(Gez+t0Cprmgy_SqBy`E0{ej*-s*QAxo6K>Od2S}}il~a&h!%^q{BPQF
zGk^O`?ZeN^k8eLLSq|u?@PrjfvWmQRZ@^|Xwfae2t^`*ED&;x`KN=aIilM)H8%Fx(
z;(7*mS%lMYe+Hjt9LB+MsBItu>3eSw^bmSSp3ZdH!^tpHpq*Fad#sd%*r7FDQ`swT
zKM*;~glvif9)BF5051E+J{iNj2ZKcP2V?Dn>tBfE_8T0jkCwEz*IbJ)gki$-;0Jti
z*R;sRqL(k-?qP3%jmFoTjTn#$mh&+emsRNAfsbZ8e<$Y=1f1#JVl%98@DN_Scxsao
zgfhpFjAby?SCCFUR61OpYo~F+avZBr@<a{=SF(^Bsd3)Ztoa75F~OHCeME&i@7WS0
z$(b0#o$3z9J8whhlKt~lZ$APGTh~VuZ~AGpCx#E11DH2;iL&NJ5JOT*7*8zscG9Q*
zjtGX1e}--Rz=2v_oJ+@0sKejt5#fkROdNfjY&a{(4vxj4R;O1=B3J#_9rY`H?5Stm
z2wn?peHbJ=jit?;q*PTo(A`<EaaH}<vTm1pE>(T2V3-Vi+golJVDf5q!%G2P=9^Ax
zW9NZ*oL(T8ygP@B#`#yAdhVRJ9QdN!lOE6Me|}|YCClP${cDhnt_sS<aH!2wXo&%v
zV(9m*VPUHrPqnG2^VQEd_45a8_%~lo)VG}5Gwm5il=jo~qoV{cmEsRQk|mH~9Z-W1
z3lV|?UemkdyT3R%magAxk*I)5Ae!EoBK$=!to2hLk_p!5zqr+cvq-G4+lW9Xkap|G
zFPDv1?By>zL%06PVG~L5JZ5=PydAQQ5ftq-KOmVsa={1XCd=QQH^6@YN*B(~m+_(j
z69PCgmyw_Y69PFjmk|a5DSw?A%W~Yf@$Ros>9U+E6H7b@lDc`lacWaZToo&al<fme
zVl>=v$O*}@t-nt<8sJM%<W0F`;?Zbyqu)LJCV_warbuowDOsWNo9g^3v8%(w4GsSB
z=U3dp#Q+$uAb+`k_4B(lz2ONfl7ipdAJ?ev>zj|!+f#X&%y5XMlz&lncZiirqx+Mg
zh4)_$ajK)=4?Kbu9#s>qpZh~B@~Ac~&HE#L-+cJ>9qe#Xh)5QP&-Z_M^{4xpyi|xE
z<O3m}GNRXvaGtaLM(2ugsfd?PNt)E=I6jV(IRoJ$jqZ+pk7V2k0VngDm`lb}0>7*J
z^QG@hH;on~al3rMhJSx|$EG!e?e<bu|1KZQcncfc9!gmz^6f#!*aqK%?(W)M`e7=+
zv?i|Fc<ir3W#Se7=`@(K9&cyV*%tL(Z7!y($GGq41Y%vNqBXc5$(u=x1Bg70@tXdb
zP<!s@cNu7oVp3^=4<4tSW%z_LVJZ^@oH2<SBBEc-1yn#pK!2U-s>Y0jVyk@kA_e2Z
z>E8Vz2i1XNN=2Y(B10v^$#|_QGmgh=+djJOYtz;-KHO_u(9v{iM%sE9%FBs{Rt@1>
zR#O8n#3KiCJ^=3Ph{~&^y(;%tmDOX_HWdTK&vf+L(V;Kh$&x<T(F|_Ke4miVA*3=r
z*pW(Q)SNG^Ie(k(0QXGRaNGtGh+njm*ED=Yp#F*z6*WL}hr~`pZy%(-R))4p0!MO<
zyM^%gv_GBPa*dKe2CXC>Y0*9s-k5tM#no?3+XhtiST<nSimRyYuQiYaQh;;tMmpCh
zHHA{ceW0ZrP)0aGNE8Z>CLDDS*JeD?77>Rq&0t74Fn@LLfy*13L3@zY*`FYUqz?#U
zq@y#+Z}tI)+G||C*SM8{hC_;;4F3DiwHbiKkd`XVxX$3HJyLdc2(f^n_Apzthg8s{
z4r1p_az0~6J>yAKUM_88YMP)(?P7;t?$z0@tzL>AnLzxueH9$^FdFXY73amlc(w^Y
z;UywB&VM!LNzRnqIkuJa2{5J;>tP*ZlMf;2WLx7HkZKMUW$R)G5oLMD<;p71V!l#&
zgFW_x!`b*SRHE!3396Y!(>mnd!~?8}B4H_?MRzd+;5`Q=m9V7naHe(+Q)Zf_=uI=m
z3+Dy@IodZ>DG4BOYbsch2#;(DQh{qz%@nLS(0}ofti1e=CXp4^6`=`$e$DLT#iksa
z){nnm2JoLWA(M0Cy`9l=+4ej7fj=RcO88a-oUc`hAk&2}*<k{<jJZM@{Z5y`!l^Ms
zIaEmF$r1|cnC8L@XTr5_=<JN?2v<oTR2d6{!P#<82+<TR0En6fmvV3r_&Oq4b}B@C
zLVthS)&S$SHy8pAd~Ck7Aj%QLfz;72s9Fi;IiC`)Ix?K3h$@IB{h9XO{`LI_8lA1D
zpH6V6OOMcvNpMlKk4Lb|nl)gVrDPA2awj<@S}h<c>7n|eoD7{H@nzc}yXOI2iV}Ji
zSYYxEkv3#fJVFwI#Z1WPZ#{-Z1hIzKpMTHRH^aPlcfs{wjn*TBen4m@fm)by44RnC
zS&=HQ!fjvHF<^Vi#9oJRWvr01-JoJXvh)lx%~>I4&)N?mbePX%dPAAZ!kl$$$wVeM
z;V^s~Pa%<+c`V5_!HZl$GvLLll5!WBMVFz!ln*3CfcOOYYTaAq?`9Jyhx(Sboqyxh
zK`TIXPt3|)+|{%{lY$pj_M)!`FwAmjO2TvNESxylD9^WM!d!}HU?F#81Qd-jj21L-
z;Upss$-RcSwax=k&46QPrCH<<oPBOX*__}j1Ho;aP__m$w7kJjW*VAldmTj+t{38*
z1F+T~GLxszYpoS+h2B8;z$w%cfq!94-__>gglO*k8+i)=-0#~6D3nJa1K1U~b8lxj
zqcJdpj!E(8Jx2FH=C+jxG9>b1WwRp7pRw6OtfLM%CZzf~Lra)U<kJL6?-C@P=siMb
zY|off0*H$lG1fLN#~qwQg>1McE?@(`nXfouMcTrJSVR-B1F%MC*<jTyOMiD|(ArY9
zvX+XDmy8t?ICKcskggYJtGTyT?Ij2Ur%ahsCen1h4}qDrRqX;9o+DdzS5&=YwnR{{
zS-r7Yd%)?YmexK4YHh6*ia_tYZE|B*oVuku$L`jS?wFO6Q(YAuv7*6s^1S6rPu+pi
z?Ry1Xz*p}<@mbmj@P-ahD}O^@Q5=UV63c~9IdOr5z4NhaNBXX~z^UZ|2OBQd2W;9P
zRI#yDe`4z;(57@sB1DL>cc?nIV>PGqq4qksG(9A%Q;ED6xpQBIV-E)lAwP|@@-+C<
z(ZQWSb8!K(c3WLdHh~k2b$(-;P%qc6ye6#&^g6)Dl7=tY9Zq<(qJIarNbO-jv@lEu
zi|AiiTbhXu*s_Iyp87IbsFg26@MrRmLNcArv3WA%^j!X-m{<~(XHo{q@`7(thA-Ey
zel`t>Wy)F3i;V&g=3Ju70Ifh$zfua4P)xXF;WB4f@C_>*x8^JIXIjj+v<vI@6v_&Z
zb^Syub6(*gT3a+d&}_#3G+%#!_jcI7Tpg}vR@ljuHC<Hq!4$bao9RRz0xGSCw*OML
zuC(iDZLa-@F&643CHp>-qCV2QLm{JUXCq>;ha_{!3UK2Bs`Rv=(;wd<Pwo^j@_CUX
z<b-KT{VR9U3GyqHQ2-r}pkCu~Zdd_zt23MnxJB;HU^1>21Q$~U^#Fgalj$~<{FUO^
z+#M@6YMZe<oeOAE1G+Ex3@lNzRuU6f{kg;>fId|$PeSN{1EMO(Mhc=?@?5MMprCm}
zH$9ln3{6FoqkDf3LaiIje+EiIo7&c!u!7yZDQ-HKhh{nBa#v}hlKCnM172ahcz`X)
z`c<xe^wofw#ojlG8r*+ShRk0UP!Mb?5Zf{iK2^%n>}79~EkYir=bBIwOhwD(*#n#x
zEJ=$$EKdy@y|h2ZQ-8J29@t+zw|$FPW{D%vw?2UQWY-h=?dV%FKe=vAx%7RWL{5Tq
zfNNRN&PZSL9de**Nx`r!<hDvWiezD{^kLs1azzKM9j}9nC6a$s5J9l3JoA%mn>cT<
zZb)}j!Ge<!jgcg@HLOZ(1m-@m+8$lWz-~21`j$ufu?2<@;gJ^GA}AIlnCf_t#@*2M
z^zGZ4wlvjOWfx8>4CVch>A-EamyzIaIs--gkX9xf3h`OXZ@~jHe*6Db?3#&OZZL^3
zCaAPk_Hq@G$u)mnJh^?wu+tgLW>dECac(hySmhA;f0$vua2yLvpsrJp+7w*un)jTk
z+i;GcL16sJuLog=QAoZfH2eU9<x4!MQDJgaoC&-336E@qwAnl?yJi!Nnhy2N=k>X!
zrW53Q*NNsQ>Qsbf1DTO5UI?iB5|6WVX|AIUSTo8~uK|CUKY@$Nwm(X_I?xP|+S^=R
zCtFJunlD~qq&em206DtMxoXgEtED*3z@&}Y|4u0(EmYv>xCD8=_*<oij#uD;A71xJ
zEn6S_k0D5<#^2I#@X`MMilf!9nK*qI%JaD#KEHM)E$ExxJ7h=+ZKB8{uJ?@b6pRzh
zi3`Crq(XoHn=ua^ufPM0acum{Y(_fQ?i=|aL9<V^Vt^g0PLvd0_-kUJx@QXH|6{~@
z=og6HBi%{?iOd*i9}Pdg#U?M0&VCR4>Ck}f+dKy5wg)bGsF&nr#M7K<OV<+_VPKN!
zQyHa<L*(a4!BVAPlo3J4EAWtvc1V|`0$q{KG&X;+@b5iFUr}VPM#YisxD@%?>_*zL
zRdg};VhU_|Hn!$Q1U(&t)PeEWlsY$E)n03=&kNU3#DROf#<p+Z%z}{9hb-D(6^MO;
z`aUD1rT8Oa$nhr-pZFhiTG*GGofiGzXwxR!V`^;+AS>vXEO0>7eJcFhWxi{X<vX91
z<&F^}3rx8Sj-O5DP*MI10)wf1m+_(j6O&P86azRoFq6OsDt}eMj@vj4z0X(pRt2b4
z%d%s;J#BZlMfXym&8^*oV#|pNTMjIFrt|kpigM}%19UOKm?A~;QG8@XlEI%ynk=cL
z<V{g0?f8%d?R-i|`10{V#Cs`ROgA^*A0FO(D9c1-yvZ7o9QtjjLzjGGf1cIF>v@+-
zDOvS)mlj3I4u5A&iqFSgTJG78onW95to5WHr(K%YtkVOXr=GrleEsVKSVZ3BtjKo%
z9{zdw`*4L<=K24u18@GO5Fu(_C;PhKLKalZS?vJSBmM)lc~vrh4no148l!4dP*TZ$
zOfy;Fdd2kY%w$Pn(SI57|1ngl<IV3`nZ<x597HiYPk$B@e7ru<)e;rKaLqp$=fPjR
zgJS~@{T;r5iXM83F{lm#1`i1jlM2a2Nwszc5J)}i?lnAp-cTqMwtk?f*%MYcEkj4g
zSQH)F$vV?v7;;vQ^mg(jjLNs@e>V0+nwY3&4jFMluuQicnIqZz#jkKwjL>W4ms#J`
zAgG8Zgnx=D^L;}pQRs+V?K0~4u2^GU=MZ!y;=Brdcri_$msz`IRL9}@F668SgC(N8
z5ah|mpigHge+6Np!woVOqXl9Zr)>LTH6C!wN;0P-r_?}-#X&nbHn?D4y_!9}C0L#e
zlmt={CkJ(sXI#9-1VH)ymh!nM_&%#4Z^-vZO@B_E^2YT>yXbQ}CYj)cELWfSw%SoH
zYBLBPp1>0l>@QZAO0nlzA#Z56@-&dNu5QVO3X7#L(3BB{Be8=z7VPdq09vC4Xj5G<
zY(rBqWjnetYoLpDbU5G#sAk4XXey|}?7)|12aI79A!Fd9C!?BASNf2q)6Sf%^7Ksi
zy?+ZWuI`q>zKS$P$vFEeiqp`ALEqyrsOwD~tyYumSE-1Q=vPHjRg@7fX&AxPv;mFt
zluP!hCzI8>i;i)A1AE2Vt$V86m4~bA?c;SRz^3M$<34(cGIh?gOstG?&jd*Q1jn*r
zJ+@w!+w%HnB6Nwr2vKW0ZCev~22O2UKY!(R{lEeDB-&}GfTCZ*t_Vu~(_@&9*cef5
z$ruK%X>O2^2Afi38H8wu#hLXd0Zq&0a^329COp%EO~5nN*C6Kc0+V$dqT_}eE@p|}
zuq^a2P|j7081QTC7Q+kN8>Ss?=?F>|ac&S4Uw=gZ14MKXc?xB2WOH<KWnpa!WtaV;
z0SA}s@&OeBG%%MD1_3F5of*q++eq@Buh3x+6kxX5FFtbfI8N4!na#r1V0SSy2pEyF
zh@nV<q-<*s^X*&J)qILloInS5byru{tE;L@eBr^5FCuRdNXa4<F4ntuo|&zl7BqPH
z^p0CR7ZBY6=1;44*B`ZBaF0b^#22g0kkl$!{N~(l<9(A>OIJ#N>4fi>u2R~$EsLcH
zou(@DJS(1P@nxG<DGhHPKYYZIa_Tg$)`+`JYg*fsm0dd4O}c|wF105e#g~7q{_*Z^
z)p4tZc%xW|c_LQ;as^Cqt*l&rs2G=u<O-Lr_Jxr|@}VSw?j(Vsl>|m43E+|>Fhi2y
zl9dGbr(+e9$`^QlEa+PSTfWt1$ar_|?;clAhbnHevaox{rhvUXVqCPAm~JuZtoKV7
z)SIre&5>sIakH&S#RHQxC4G@Zk=VUQ)V>3}_iK4tGh}9=S;RGP5HL>);()WI>-(Ow
z+5%DK^VYh7vn9AnpR&5Cjs)#uG`s~4b-SnBnUQd|ag{88xwA$dfIA?QqzNItRPlaq
z>@g)PNa6q`Mt;{u8NgTwXRWrG(d2?_=7-3=WFUlLKF;$J`FW|)hrN~$89CW*pQpRD
zKtUQH2Rs?|BG&Jo_KLEJzvf3me*Ee7XPD%)j9SInu@!K}s(y&ns(yTWzctPc@1A9w
z6W={|q2aE7EZlu%Bzew^zN8=ZcL{-J8#gp6QbGvH{4lex;GjB1X%O7S4c*RmXG()-
zoJ^}4PNV(hW`dFJ+&ONiypkWHN*m*AX}*Cmd6?T-$!9vWW)jxNZeXj3q!aG}f1hV-
zOAhBc$3h@|#nr6I4J@3j$Qn>(_P><Y4ac}pmxpS9ow~g<;p%#PsR;8>8`m4{21NJN
zwXD=*5>g81=3n<TKnJSRbQ;@)=R=GL7FsG6@^8hr7TX=5&&2L2(P;n|81?Y;+wD|r
z%kv*sG~CBeDUD9UvWzsCi@%Ze7W*5lPl+1VEi+%~g4pXzmk;MN%lFGRYl9Gi>$tYO
zH*Gk7fc+4Jk&8h<XyQMOm*Y*>p1B!mk{0U}JTQo~bKlTHAI1R4ni^f$jMwFEe`rzy
z%vpANqFbEYROPNkOuOy7xJX>cJL%QjU7|f0m}8qU*HyM}u52FdR<p*2ds0wAv+Gk6
zw-Nq|(9>o;cM*L$T@Hi27QVedIM#!Rj4LmHS)S9pH5E<w9AFf}W#SpvnwBaBi|4E=
zi#Bi&?(<S>C$2IGy{XNP{>Wqe5IjYK(#Xw!{_^<w*N5A?FC>!G(xlFz#UJiI-9N4#
z{yUd!Rm2oj3YJ>7X;o`g^$OzJ#OV4O%7|#JEj83uBt@q!9QWEnh_n^;j!nQ=TR201
z+QJbe&uWU*CMudI!_Mj{3Ybz+E7{-v^WjsgqL8z|S0feOe*Wjj`%hm!+&?^Cqk}@!
z%d>iaJqex+_}I*;Q3N5=K+J0cqxR@}nj9k()K5vei4QsYtN|f2&2a6ughn^wuWNH~
z_Vi=CDUWF-2fT4><&8~K4Z$O83+*$1VH|0YrS#C;+{0SR+8Y2hFt}MGi<_0NRJ&Mc
zY;%K4MmIyU`UKHlW`mGq5VM*R&Y98RT%Iz<{~i;w<a$n%(u<hq^D|Zk-iB5-;2A5o
zgnrP<XV?=uV1dxzYv@2S#m9E`hjxZ&)0r8^y_FFnBjc#M)(DJEj5B0m99bQI5kS^9
zTTDS*!0jH}9M_sEP3yOs`>&A#=QI@tOv~Yo@SyZT`TRiHw~rr4$OW7Unk<X_hzh-$
zWkLo_!o$bw3|W6&=hwD6o#h}3Au$I-4p3A)2`g<n{^FUg6q1FZnDO)vH>;a3fB*c;
z-Pn;Xa3kR97LD{#l=wh}I}2BT?O+OG$evsWz5{vtPrJ5>tDW((Ii2`E3#EEv{5`|6
z@w!=#k-Qgn;T`;yM*%tP3^Q7=J{62qH0vFb`LeT3A8p)FiNOUA)rI>l;05lV-0!?x
z$KV(60-TpBgx9AR4up!JVEPP>p*`;WJ1Y|VlmlC6rA#$3r+TP|{it()M{}qP56dKO
z;<;0Uh()547izOPqTp?w>R7u#O+iKLtEu)ftT(kMptMP?8z^q;iGhwF8rVmAR)D+4
z$%Q9VFiJ)|QhhQ)z=SFD&WDI%auSE?*5)Kc=;D=uCOHYGY)&$i&E+{kZL<>2o-ak_
zV$?NMp+A<*f!ZLOU#!@Fgyg3=JRFs5p4XRb-mv9>E4E~VQD3qFQZGMf7WL;Ogk>u?
zq-pgvMz`uhgzwJbZ&KK~#3;ouF<#c03Qy8uG-?0|-l+`7gDwp~q%s_JDnnrGT{yEr
z<(bD305N^K#5ms4wt50Da8{`9Eo?Q<F2QHA=K1%!eV2v9#~lEF)FKL;7XnRx4+k?X
zn7(Ucnoxw-bzu-NU7v8^F+}oEBp9@K(38KoZSGx&L;%ZcACu@?hpOtHPio{>W*t*m
z+)Oq#nQ20qDO%+1;@mS9CXKQIt8cO-wiyPCv0Z#I&+2^K&9dS0T<roGwe`yP(<?D@
zVP7ym=t8;`nWCzHil`?$m-pZVUygFH$$Y0p@TKCw(=62DTlqn-DCn-(do0*yOK8PB
zse3tGn+zg6LrvV(%BTEu@+l}?`zq>^d>1N-NDYGnc&Q577V_MY-cZibiDz=F<XzhA
ziw6|yT=Agc3FuA3-=VIq2j#<TO$pUQpLx&OiNml%GGxzx67)Iqz3#bVnkiA>{90tM
zs3k7U8D{QGB?5JJ(A8bm9v4c7P=VmlOyPw`!11=jf#u`4!!an0+At2qg&OxN;GjVm
z7eSx-L;zvD&1GGiG#G?Q1mJ~`9}>HD)I5i+6dse*#>XP*q7o8MuxC*j@}?MS&#H+S
zg&`cRONeKGHprG_z(p&{@MhS5HKr|mY?9+iCY-l@a`WJ8(gKV4u9w4nu#_u2rhKcO
zySQtKN0J)f)Ce|h#bM7FPw4)OfrZR|$H~E*jh$?>ioRm8-1K!1LfR%f?zi9A9$972
znBd}^;H2Ee*=g#bx)9ziYW$SQ<KpRH`nY(<Faacgsrd`SWL}uEy$GB0Fpgtx4TW=)
zBpHeY`S7?5RT~Oo+O{hzOS9fWly^4}or=W#KZ0{dn<ifg&g>mG4n#e@EJr`Vwq6&~
zC=6_8)7@-`5X%*y=64-J+uj@riAYD2jO=^=w3E!*?)Luy^i{Rd3T19&b98cLVQmU!
zZe(wkqX7h$Q2hZFw=WL@FaiPMw_p(hj|l|S+hPBgk?;i*0x&R_u}uLKw;US+>;VGI
ze76c60#O45-0eZ}myz%V69O<WlfYdRw}>DDUIv#M4+0gp`z8X|0|E$Rx78{F90df8
z-KbBOk?;i*mj)XG6$3IgGnX+B0x6eCFapqj4Av#X2o}ccO7kQXGNE<lVH%3nTBUJt
z3nqYlU{#g`uXq)i3TiXxYBY~4DFThgJ@*wjQ)FQ(C8@k^{HSz3Dh4Am80*H6`UPDw
z4hxa{Vbj#$IkcvbfkFQjaZq;jUVgHDdl)rI_vP4h<&MYJ+L~=wj?UH4J2vG=J%he~
z*8^)Bdy<U}E1_BY;YjkT@78E4_*aERp2KQoD3l-*$I^7u-jfR0RQTqPNF*x}Y!5>@
zn!Y1B3R{kj>M#tN0;oNb=+kPAE1mT1hu%plZLO|DXN5>$dlN7s2dCv<b9n;p{i@Gp
zD5K<p&l7l{&)t)()m^P?lA!PKY0Ykb-<ta)OPiJO-`2WCU0I+9*P8|XJ@r&Qe4{_p
z%bWMCh_c}&yeYTIBB;svnFzB;o;%+qQ6glZON-jY<oT1^vD-~4*q<s5{sSwtB(hC8
zxYY>UzM(&C8+sY^qp_^Psr9MO-<=GFeKkB$SylZ|mtEx??J{F#?vnw}tYw;i1pNU+
zGF2R+B-{_CtIXcT2fT8$!XRA|cF^0t9Kb81sW4v+H22^p@assQ*``0VHMKdO=)3aM
zq`CJK_W0qWskx(UTW)kUebjd@Hk~<(Ycd^d!fpz2Z~>b7xKc2oX?adejh>#3*-<L=
z45kp3mjfFR)`E2|e<M)6mU$6>>}gelbyI@;j^s~GPw!1>Nn-U#lEa<^oa0eoVFxO1
zSCnKm1uaSjO>^|tFb=@CgxG9``;6n)*))qRiq~m53jv^<jx-H+rKPHpsu}Doq_RMS
zJ>e&e-7KYY9Andu3c;i#3Vt4H)0KmPoy=wM5>XveqT{gG8HjicZL-LJW%7}_8s1AE
zLn-?Yx(?QxUDh@AmGfnI{9so^p%N+kf^n0g8w)1JV1EGbyRe1OXmLY8_P`ag-|4ZL
zK(RFs-Xe)%Y3!>dk0l7!g2SnxN&kpc^lBV5e5+y=e1qj;Gxi&>`5WjHOD<hY5k@jQ
zkIU~499U1Z42S@8e-?~?4_%K|K3S5E)3}i<D+ZElfb0a2_|}%g)`#ig6PnB6eCVcB
z0E@l4a(t%E6`2-6%~=RB_wsT`>Tnx6v@L=kXQ@lD=CdSmC5^H~^Judxx7<Zl4FOdu
z#$?1qz)Z`7^;m`fTCKAr3tl6}V7~)pNx<S7rL9>+;7aXUqx#N&Ai`K4I4nYu$7ra?
zZt+R#a2cNzx6lBGy4do`X29&FbW^zL^K7$2wP}srFQ#3VhjE<x;Rv2f)mVfwnNypM
z{yetk(`B`V09G~CZ%o{zU}&Z_SzZ-wJup%a((n?8u`JF~j<Fn4Xuf*RBA<;@`8d%L
z?jQ=A1zg;P1Iz_~=;mB|*LhB4c#^8L7(6JvV+vF<FWMh?dZrlt;-*NL=IaochANqy
zR+3ugT}!)?hG{w}#Sjc3j_#K<1N{@Z@Iy~7o5kJaPVHHK+Y$}{d@aJ%I*yA_MbGfX
z0TpH6deB>AM=A?fPzHoUwOQOhLpAqGAmc!8id+YA9_FTh<oR1VW|6wAWp2uhKQHO(
z51>mACv*NU<OQmWF(VWnv|KB71%m1sh;{3-0>n6RMU)2Qje|~T{O0C!Blt+>9uJme
zy$eM_B^n-8zsIOQ(i?&nJ~^skJaL6=;tE`11+b5XP3pA6BUFwlcoB=SlrDv69_9;m
z49H@8sJ&NzH@=qbj++XW^Z@JFOgpie0{e2E150w1o_l+AtR^D1;2QVzbl$|q9(i(q
zu<dcJKSP|lGL0RC=GgL81lwHND<+I6`hu~ekV^`9G8LKQiYO&?aMYrIm<YxfDYfKV
zgB7G~&42ZJA+Mf0L#V{DhiJ~*l*%wD@Ue8hLpgGP;c0{i1#$_<2r?AVL<`OW&spm^
zeBXr}7d-PkIr$y|fd0w2aE3C<(^E0XP6dw8%QdINX5yzt=^Z_YBST|$2&flIOh?}n
zlLnDv(pX46frierO|>LLm%(-|V8jHDMEr&aTtAV!<m~J%{dwwizV2z%-M7}`x{3zf
zmY#2aa%$6wOa#uoBOaFym9s6R&Bi;C1gdcw^Zf-JfultEE0GMNO$IlOZrk-eRLQP(
zl`~VoOuChfVOu}bI~@u#^+gn4xF;z>5p!<+I^kEvryN=*2<Tei(F}dJ<0}H{0CI-a
z-netsQi%l0kc)}9ym|lU&Cee{yt)4K!}Sk;?{02C{I(eE5tPgm&){eiQ?wz%KA1fN
zUr&+_O2TA4-;cya?kLW)k}%J0iPs4C{2bjj#syvG;QsCQBd+#HV#rQ#Nr;ziaqw;=
zp)+c6=`zgXDP=!gzkYjx9wf!Ah-;derebR>$x3?MT;Kgd9WGF*Ieqx{=KXwCFleNI
zcP39;Bn9N1I0|DCFP#VzDmVCm)4lGN)|aLLYTj;)`$dWZF34tt5ea#ZCypnBRS_pZ
z`|wGdi!EZrzMJoO27srLE=J&th_VB-KX)JE4q@3c{>G47LdD*U+v~e`KmGFY_GZyw
z0c<UKW^rlHTmr0vZKivi#9i}QKGaBm2|<_2Gr)ZES6z$D^dF!k%Sj0~3*yfxvl{$g
z(z-L;LkdPWW|@)}KuM>3d$pWiV1k<OT-CRT76?^1i@Rfj89pLpna}jH2T;RmVrdM1
zMg`x6DT=D&7FZ>!0k<i)kKWpR+1fab!bD8L|IbAlkU)mSnf!tsTD>zf!x4Rd{jH{p
zFut)oneFj;2PN=y^#H<OO;_{b7<GkzwNW_UU4OaAb8mbR#}&dKF3R(h&GEco&?Uv}
z8fv<!J>AUn0w5~Fscg-t5E`QrN^|8EK*Jq{W;UUyt1XS@3m+w&eITg&16_%M$hM_z
z7NaVMGLcSMvDqwBlu(K}kacW-AYKk~vx8%FS)b%xZJ<bNHjYgq){h1mRxz!OPRnrU
zHy+`kfF+_h$FQ@rBwe<mXP+7~cdXwE7=0M5zI^BB9G$YG{m~uR(|qHx-=6iSTs(-W
zBgOKFuIMB%H%H;k+iWbKjIp-v`F61!d{?D8$7C8$eohJJ@i}*DN<`};BEz4!kLe&~
zj02j#`oG}vX?)+BO4m~`59Cn%-{^n!2@NBck?;i*128c*mq9uL6_*hP0V$V%Is(dn
zDe$HJNGGB2m1Npik!HR!Kf67|N$7n7nw4j6l?Q}I%6kOr(%5@fpW3b(9?wYCR!AU4
zmHR3b8GUR(EOF=+rnkHr9?gI&<yC$2w?VdR5XKu=X9^Gmv$to%!mNs(LG95UV)=}s
zZGI1wK8>9js#Y$m`t4PqfW{r_q)ys@K@f=@7X}$34kBO0%mAx`^@F#gdJI3Fs=x3c
zJQ<;lIomh9Q&ycV2HEcAC1(MbuDw0LMq&HjmJF*JxuGj<=Mx#Apj>O9CHC_;XJY=t
zY$)Z`d`A13xlq6~sHx$lVH~ES?VfJ4$V1_R3acaUu>b+r@rOW?n?iw%O(`#b2%=gD
zPF@^~!rHPIycQ6<FI6wt)j&)fCN5@)7UCfl{fxH%7QYdot@(|@ltl(0!#_i3N%~<<
zJR+!VEH5S<!WwzRU&kZ9Ks*xSf=7B59)0xf$onV<pNa5#s4n&DhW;wgto%?duGQ{Z
zFk*BwkO~MHSN6{lmgIW~qg}FpB0!xE8k_z?BC$n<9$-rhKv6!Qx@IQy&ITWzWD^e^
z-Ra0A!@q!E%T1u3)S;8*hsqr;CbDuDwe*)>Sfqdk=%(TKZPzhKfe<OS%p^T9JN!Zi
zq?wAvQIhxr7dla3W7k=tZ>Z(%&JJVO^!)Y!Z#zm+I9)$1*q*Fmt&abHA}#O#{nH*-
z?!rti1Xt~VJa%8r>;a6}BWg7p3x)+YLv->f%*&+_+5oG1oe&t093_3(Q6$X%{I#gZ
z63;=;91Jih<n{uajOF;mkPAw97|6^}+Kph6s>#1uAuftkRuI?*)KZwTbHq&1p84U+
zV^tvekBmID46aU1+gX2q$5TYq_hb^6sxUQ*I)ps*grIihhq9%tfy*xlmlVMeyaj(p
zj6-39`Qbu@BM>>mU$ltY0Y6iWzR3FzVvo26=NDz*6UXwdrzC@bVovme??izQMt(nl
zN=0uQlbTfqWIj__5{RqAX44M5fXs0*C%`NjgJcTu<Je*JWnk5R(77dVwG$K&s=<Mu
zrA@?fa(SKv>6A3}?AJ>NSqt9ie*{Pl;j{s!P08DA8EN8`_GlnJ_6%l5U;*#ifiX-+
z0fbK#**@{(bJ_rZ7EtQR5yZXRx+7nqK@##z5IP_lDc3H^vUX8H<m*twNgTBM@_2Xm
zTHZbM?bsFe(AiUe)eqg%!J-057O(dTp-=~YtRr`rSUjW~KM13>_kL_9@68>j9Q`K`
z&Y^-LqmIJBd0@T?@nR4F2ag>)hb<vp<@0+NGsqhh7eED+1}KrZoB+bV#jMmb;!zxX
zN-)k|u6yz}L0u1D?;18ss$s}b4?7mRaTBp*5liC4l58@6Um~#w5N5F?Q>I(KCt?8*
zg*GP|BEK+)>zpEmOWTsrE^)uHUxz88Z<qq$??D{&)^1DuFpd07Wj7k_C{Djo<~!`e
z0)3~2*&a&Nf5KYTQIq+K$^Y&BL@Z?rWbqHlS`dYVH?6jGYn}NTZv8&G9ricqhU(nM
z<%({@393bZO>+nVQ7WIEaoys8QuzRQ!H>h-H99#rI`0klH(Xpoi}S1PDO|kJ;K&*G
zq~#bQ>=~*-XPZvFI_Inp`;g9vQc7ABhhuSAK(dttaDZ75ZbwxHY!vPJG7fSDTNIwz
zK+ke^m&B8IYUiB*a<+EZiRWT}y(`YB_=}uF)0(q?*{Y0-m|Xa+&HpMcyr5FEhnYy&
zs|JQ+R8J+UV@XzVcNE5()37&`HkiSj(4Y9>VmdjGOVIgz)9*!n+zs>8J8{2YsdSG*
z>O&EJ=?oZqL8JuYqX>u4(4Ikim^k+`Ll*ius9b{iCKc?NNd`8e6ZgWTQ@pEa>l$3H
z=O>bXK7q|V4PcTc8$|yG`vsd`G0TcmSfzugu|UFyhKqTXNjjjkT~|fLr7OTe&oTJ)
z*gpy$=LI1l_1q)RBLIO3GtEgh_~2|&vLn!Zp4wrBl>vEzV49+Uginw+l9q5LV)~ha
zowB1Y4^X+IHE^EUszpbBlBZ6{uM67@ov9~(z3k>?6(oKdPMSGe$6VD*;Qn*8Qtd*3
zo1(Z>N7Fb!uj&@W1Pga{Z4~=D&DYKBJ+|R!mU*<&2tK1mNFDevIRHMaTpa<EnUwte
zAZ;41#hjz5<E7({G^C=X96?Gp*j%3I1udm?&--UnT6g<=@U`A{DHzags8h%&&(fKH
zN&={@k{jp+e3gA`YUQvG3-q0|usw90&O(Sakj?^JCChwf=KXj7`iMylmz>lPRcBl3
zqd4;8ApcJ49rib<-yTZTiv&3;09DpMVF(Mb0IcghCrH570<|hyX`JQ?R#$jJwo~i)
z@lyQKF%=4%>NW7QbW^*18X!bd;*67jRH`amakq{uxY5_ZR|4!ztsHI?*f-<C)P0Mq
zj2r{Zvf_FaR^%eM^MDbns!Mr;f26{MwhXM#m4%4C$SH`2$pe4Ij<+J*E$Vy_<!)i0
z`k@M)WTs{^0xvpBQ<KLYEGVJpJT3$X4kbFO>+Ky<lgLyO_qa0U@&n#j#7@|MGz^@_
zdHiUL8agYvP8!!8-l8b;0pHPkhl8>`wj#)I(UjphwIC@j13|Y3{mdo<LAY)D%1t`K
zP7^mcNSA{HoDt$#N5;VUB$V58|L`o`f=#P@?wyKy+kN?<;KyA)6jYR<nltZL!0-89
z*Rq?c;jw9=m=>A=pM_80PowjHE<&6Pk~Pn8@YnE9UG=ijlN(_Fa$*2^!X9st_LF#`
z?{3>xUS|xwZ<5Ke-PV(MsheNyl1RgIBDDkdNhxVSL7zBlc0D7+@RB8KwPVY2g>XuR
zKk!jdd#@Cu{2<F`2HLj|rdxQ~I;u^a{_xV7F;(?~iT&H#p?!PC3DcE-b93b<Q9Pf$
zb7<~I^X<Ox?`koHki7^3vD#Bv43)-Io`AgLlu8|pdT#8D3sH#J9~3n~mToFN3>-R0
zNL$e0j%U(%z*7(%q#pa+t~cco^g&Yq7@O+r0l!u7t-G}=g!f>I{XJh$x|wueof?C|
zjD0AOxerl?g~eaDF|4Y8+C0=NqJ`ioVB&*BNj`*p3|XR4K9?J5?uT)>Q}${Vxo;EN
zg-`na1Mt<i2(<V1f_*@e#oVqTP}~AurYwXY&O*4F>RQ~l=L^@Mx0&Y8D0*(@<ns$R
zGl-3s$#MKsv_0mq=hf|k==l@S^l|BtX1=b?UdDbLEr5ise>HJ`g(iCU$QiOU*q$L^
zG5F`<EX4r)QOl%>k5V`y!j!fVjx#?H0NQg9^9|{A1CJc>oz9+Hwg-_V-cB)t@jA=2
zwU9tumcRquU01&!p}x`_4j5%&@COo4(N#FeMNo+`sd^Y`;)wt*OmKyT$=#lxgpq;_
zH`)ErwsrsZdFtVRK<9%2UG}2K!5y=**|#n>&6?cpO~Ci_x#$90%TS%#qc#dZB)2tp
zagh`W>}_?$@{gQX;9^qeo2g68q)Uuginu6kZ8xumFQjJ72f0!^sae8TlKVk$rO>>d
zwKMHU@pLNrLgqf;;%fCR69f~3B0mb&G(5@NcV>lt$_1H!z>UMja)9eBc=~7M27UO%
zA7)ehFiUYxXlVHtM|46|C81h~UK!`qDa)v=8r%@jmae62d5fxaaeg<NmXuDzUmh7Q
zh9gnrrk2=!Vq>st#i1Xk$s#oc&wB!=kZXwx8>=V@x8;AD`gy*IHXo!7uG^^?$C4_a
zzc-TOo1;a4!^MpP`hE%)ur>l(M4luk{o^m_wUTI3&ezNXV8Y=KzxaO=oEQN1Wf5|w
z$<Eb)0=J+`Ww}>U#T~HH;MvG8`$dlPx(h>S8kJ2H;?l)7!t2;t<YP4c4!pCdL3`f8
zYDM0{kAY;VImKi;^^9#FE$QRONFSdiL3L|l_CDZCta7Gaea`z4rIrZ$TEjUFsR*!m
zhJ>qi0s%lZFtYqhh0YcSux6>SOeOwjbNt5}I(}ufv)8oHylpC-UTDR#O(W*J*8Trl
zMP09#k?;i*m*pk`76UjjH<z*K0V=mcPXglvf1D!2>?Bp5A`T?BGL{L{mQY&CvSQRS
z772J{o?;mcK|viR7s`_&i(Y;Be(k)3^IbaUJ4_{2!Ojdit}(tSln6riQ(sf~;wcqT
zI53}mf^g%E>TJg&pZXln?x&{pC|qfO<B6@*Pcj9DC_{N1ax5IM2jK{nyQ1^jI&d7%
ze^u}83R;B44RFe3APlHLQof2Skc&LxiUokd5O4#z4H6<BS9$aUGWg~nuNlm?27@m%
zu;z53Qz3T1#Lhwq>;N#F$YqNxp}&9>k%9q0eM5A9e21RlPXdGe`D~;juCmOV5%2V-
z*7VKT=(hQn*{)ZA)rFnrWt^)yPyWfCfAA>XGW#F!_*Wla{q61D+mCBz2e+=`682x!
zB^bDrNFZWrEC)m=0{~QCTQven9f)@3-Y+mEL8-08)JDwV(gRtT1F<xiN1^)L=1?jA
zlY+^_I9SdW)KJ01e1@uQ$7AbOyMl9x<6MJrSjjbx0my!VBfc37I7K})&i37$f39$W
zZ?{S*ts;c9R4>RRlypn72cP2mHT_*Cucf{~E~_dlM4abyV8XJe#OAu0OTbY7s!T2$
z!|T`xu`4ahK&Nk3tFSbMm^2@Tsk*mJ`MD@EIm^HB^2hA$Ikb*ZG=Dz5{ow<TkZ990
z-{WynFc)c@l$ZMDT~f*DyHD>ue{rc&?kpiALvzml&15MVD(}Vc_2i%7E{VxN?4-vd
z`mF9SF&RDxsZvXG#$)yKm}8NQc4*X)V{s?sS(rWX0-48Zn7oi?;HF4@HKgdY9A8DK
z^XDSMQdO4`S9>^wwe3p^K<3i(9P2#vs7D?>9*u|9;HO-^WswU#(?~g%e?oMgad(5b
zbbq3=_TZpB6K7Av%lHtPWw8h$QvLoAS+_>J?N{{1aL|<nfov@M1g0{HiNqJ#sm$kQ
z3&%5ELVITJym!aA#L&Rw1;K1?rwvazZ_1p5148@*7`5R<vOPduHXgfpMYeNjlw}%q
z&EXhIYK#E%n$j;Iq<#3-e-wjp3wJpPTUbQtt=jR5j~F9F>f6<lN@j79h)Y#~boR|G
zo3(N(0ZoWv5lF=OIEWT|YTFPH8gz;QQmHr-S1R019X6qgL=E2p>PgDU2x8;L(IZOL
zPFUpNG(<w0Kt(WhX2-jI$X4_Qf}e9Q7jgh#T^RsIwL<yKps=+Ve<#<k))M4mGBVxi
z+|NCWpV-7f!v4FZhqPSIUMhpuV6-q@oc7jZKqJzkukQTbx+VYR+)6=?kU+>?s6+t}
zJat-YqvqFF3Ae;RE)@3>h2n5pgc=I~_2kaNA`Dc>Ew^o<<)kgz2QKP03Vc}$!Nz%7
z{L-YNmhWnR<*9#Ze^Qr>u>=Zw)&VP8ZJ=i6|GzQF^uy%7u0&HZ&Sd`kOEhRX3fO<~
ztjqlu7o}8s6bo67XQ|>6y-+F)Z}cEZQJtQYWU+{Hh=BX_z+>+)rswIoumeGE3rO7G
z?|B6!X0a)Tw&=3{!)+sfLtT{rr$*s7t0YjCDpio+7ez)Te^PPLyRjIP<Vy2z=NGH3
z#3qIxysMlIib5?+xa;)o&NstaSfn~y%u3!j{cg*qy2fCh##L1<YdGOEJ$7@PK)~(E
zb*Z<aSiqbN45QZ&_+so{H0gk&*BJz%h%_8&PsZV!{R(d?iE%XZwn7Wa-jaHqg+;bj
z|5rCoODMR<e>&z;XYIWZd+PkF-0d>eAa67O^lY3LbAf|nwnZG_bAxueW3Mr*FY-d<
zU^ibXltmGXGQGOrqAE|rLmCb+Ah}`mIW9xv&aR$H*bpH%Yv=1Z%H&@E06%y0wDRn!
z0n@$Z@0|K@f*l<un<^y-_N0ortYC(9fAINOd+^!;e_Z-voUgKr#C_%4y&=&{u1WA~
zKA+mAZpL=?skltz;{0m!#fJD&5m0QZ^E<OX=mwK@nsIfGhx^}1X0ae_z&EL<naMRf
zNWmaev08%$O%`#cE(7&%v8td0tClrUV%IG&U*70{skqX#@J7i6Cr+u?#}Qc<57|;d
zI<xFUCe@qrZ$bFIcrZpl4-L9ULG$%p93;P7UO%s(O~>H}-G2kgQwOh?@uC3}0Wy~$
zmjfpcI5{&4FHB`_XLM*FF*z`oF}?yRf6ZD;Z{tQ1zUx=?F?(>UAJtu5i$Q=%1`Y!3
z0)v?eklooiXl%+B#ugolMv{M@uP7xWi?Sq>UhiJa7Fn#W$5*eWOBCabgk%Vp=#BRU
z*Jy%|xH=O^a7`w5&)E>x63GyIT*V|j_km3&n#7V#E=pGn`)q`wDW35hJbf@xfAEa3
zreLI$ZtcAXL&_k+Zjzkwu`m`8g+iPN;eE;wCPm}3(?!BU@OlcyGh~sBw+eKS1U~vl
z5}V*e`4kfZ<ncjFh?yY-K`9p}MR12m8S0{7fo(!!a8<=Kh$ROTSU1h!qq;~=CWsm%
zXA@mfdA*52O#+o8s3)S^L=PH<f8iqb5m+lGh#}w}JI)Lm7I5YWnP7Dv1DpU^C^#$x
z>aa3ZgBOpxF;9dGJivM<8cN+3cp;PCQKvvT5ATtho&xT4&td=MJj8&wNw*MqDtWM1
zH>8kdA|;s=9r%dHg2B0{cX8W8x0GRif`lpKHbuP7YH)Zoan=Ry6aproe^QbR&JZPg
zl8Gvi19m1@Ek_uM2#;dYMZp5E3bf72RbZ@~f^G^d<p7hw%Q?f10+(m?yLWI%W~K>N
zc(16(oCBFS(G}3Brt^R+J60AMcw9fzm4eK{b{qg;uV9UeY@mpvnjF$Id9UmRD}|W@
zN;w7H96*M~Sy$08!x0{Ae^^v8poA5ugk4#U10piTX<#|{xOn*1!wx0*GI{lCGJRt{
zO2~-8cV_zYzy59TP9(CPvsvEX+<cmR`)x;eUN2ko>Xn(E1O8=Af38xbKiAkgtr_8!
z>D#8hcwe>VqnW;ab8e;|s^41k7q<_;-&J@pyQ(JB@4>lRwkw2ff6&(_(|6UXzHct7
zRhI#}TmP&s7qjo`-^@q7k<|tgK4F_#gLk{=R=N#)RSGI^E5%U!i3$m<6rNGL+}Dl<
zYnPr+yP*n^>nl`FQ;2*|AvvtjDKvYPMzZ3=aGjnb;5?7B1@&w}VW=&TJCE98hbES2
zo%6$EcH0O$*x#~Xf7Sw;##u`Gmf|N_YWjM)tikGISGQG`oh`fPlj-~W&u#bnAB*Le
z$@IIrxvZKsZ}&+BxPaurlO<$j^1%iq!sMdWLV$8-Q8_^Ox-;Q>GyS3dP#YNkn-AC3
ze;m2H*~J$qceYs0tEQ<g&sM*$+Uiyx!4B1OwWybWQ#)<Df32M0+J`hTi}iGhYae)U
z%grb!#qIMf3|uxiI!C_bLVx}MQ$H@<rG7-D!4Z+-|5-B6zOS7OMe#-!Z5r3tG8WZQ
zQQdV^-Vy>f;Ws)|^i#pcM2Ap)S<S!V_^O%R-p-nB6b}e7$~NY%ud$J|OJVDQ1>$5w
zN-ryn4-i6If39o^Jx)l@5?b@ZHkSROEaqqPYS!L2)meSl?uqH_j>q&4P0r4u-#khe
zQ-bNjDPVs9@Ga#3mAwZ;y&uSVa3JUSd?ozRg7qBn-LF#l#45#ZH@@>)Vx8DV#<ikX
zhnB?7rhvf>ztQTaf-sNag~M7aB}P2WEm>#2BvvO&e@ssnd1kLLZ>srXxmaGQ5NmN(
zy8Ly~UOy1B7h)%r%^ezF$m)>$v^ud3wecM?_gj9Zp(x_@K%*1<`nstW97k6R=P>Z;
zKyD@Iv~G0_#k6TlkiC9vs$cFG+VX5N<7ym~Fs|AFJvI`g5DxBsFe5*GcRfRJh$A+^
zXUkdTe@Hg-i)<buTgI3l$=lE!suWAY$o#>285PnR6r7F+&JIm<h+kC569Q*@e0VG~
zkFGzZe=1Pi;2>JdE}OPjPp8(uX><^g4ib8dhQVQtVUJrbzHC<3%;yD}58lW&#O^TB
zmPf$+-zyHxmVk$iES)tD$nkxBds{Dc_gULEe~ZueZPgWqdai#j>f5_|sc0B)8wa`c
zcn^)0N2Gg1d}4k!p){U~KOS>CG!OwbG#{l4NR;AbL{WP%@#{%qdA@R2xF4zMNs+p(
zc^)<L4b?&V*+vFun<Ar+Cmd!cLIA~Jop=)k$r+$X6d%FtvTf>{n@x}P>vh$15&ru9
zf1C5J>8fVU#q}D;^SasU!*)?DC!lx$O-|7=JT|cFAMDmXG$jpnt89vg94Z=*H1KFN
z^sq1nXM-pG8e$8f{KxM1ryW?BuP*-S-H+=(-(0ut-QTCvRXbZ=&YH`Woi|l=S*^ab
z^_{JotLf+23OY4stGnvr!H=_>8FE-_f3Mryn`a%Pb)?ttOb5nj_+q}ex^FhfR6zD1
zmrsDxLz;|EEtGPU4#MeBa+FSsCThfpbLG)#)H~NdSeMfd*1etq?<7(=;beV>CZicG
zK<B_RGhFfBQA77#ZJ_4ece?*U4Z*%;j~;o19(>e=JtD$*9%6cyR$;Iqyx(I8e;IBF
z?@lnp5Tbwt=D56YS%Mh3Zy--kGtk${)O{RQdAe`IV_Of7NCMsWeyf8iVK9Xq^vY2V
z=J=V;#Uq<_pY>$6`yU5OS^s;%CY_TpP{e$~_Fa*A`{PcH={}^NfQ|t~5EcP9qI7Jv
z<HPYJd+@{~0`9=U+aEedzqkrzmy_@X5dttWm$8uo69Y0fGM7QW11W#4SzD8wxD|f)
zub4b7?b>DmAsW0-UMEhRR3%ljQ%S0J_d!FeyUEZ%3Gle{>vL|Rp-sl#tu5CWAswWn
zbNRj_b$l1Wzxb|*?siIrMVjB0=T{N+y5k);?*IHM7P&15ZfBA|JiPkuz1DYe6c$kt
z-#r}WQ$6hOehS{5OgDd6x7jMCg8a>9o2EK=*EX9Z4+huPb=4es@cCq&<>uQT|M(tT
zY0z8aN|Zg>p2rTYlc7sL*faFTN=GV4i_I?&e|`0*he=zVBwx8Ll>BU8JJ?qmsx(Vv
zUs;}pu}XPgc^Jo=t<I9*L$gsa?xpWQu{f~hP{IB{8J<Ih5g305=K$j+S(s>bog$P;
zUia<jO1pLTSoMRuY&+x3*@ER>!=yVMeB6MPag}+jEziBQJIo#L!py7puT8E3v}US;
zlR*Q1+$1~Sb2fWv8SMSI(OF=sn&yV?G#E~sIFL4vE>_OwE62M$OtKs_pp{?R$%@{w
z&O?<a{_Ejn2G)P9G!3u+xY>gGqVL$-J+~fF^9xRS2jP%~nFb4}FxD~8RJQaTZZyGI
zqluHG2%f8+f(hG0%cGT#NAw}CR*JCU)!T9K(^ww(Inq&Q`T?FX50!26a}=k?(HRN=
z5^E1Uh!OpbEXoGres3joS19(`&Fzyyj6}+t=iyZKyk&psUu=2dDKb)jYR6g(*4U4@
zNy<gC-^{GN9saQDom7Qd6@K{-;+yBHuGeRgsOo)maeuY9TMNcfWLNA$yRerT0oLLw
z*P+_Qe(kEMhRW2{f9+NxOnjf@A$-7wVA08_D?3Vcn8#DFe$SW!Q6->4QM03{A&l|%
z1EIlLicNoLRs#<k!6X>jZ`-DxyK$NNTUi&J9wMMj`JZ?Y0fWRr>&^x;kK+f^9^+3X
z9Dn%EpvUdK6~Jlswka#ye+4cuvL>nk40xh&z@SW{Krmts1SmC}oV6@*7#l*iUPfAe
z;@-LCbwgoEDC<Z`T*oUJ0tLhhBH8w`hH=usk9L3X5s2=|xzRGdaY;0{srGFD&b3De
z_A+NQ-r2g|Q;A4ouCu8BR<v<IBWLbeYIu<)8dG0-)E4znIZ(q6oEL?0F3SA$9-S>V
z0Udt1#&8@KS`%w*<x2@Sw$OHO4^yjyW&5q?3tcRcHHFZ=`FhRCNmPW9R^;kj<-dc1
zFRFhPC*TwH6>9Bb2>RXcrq;7HPxa+X+UYEe^8Cx%ZR2DYCLp<pv3om=4r5&DnD7f8
zHJ}N%2)5wa0HcviGIdSm2)+o7;S^NUK;xPC7dOD~9Ck#>Fy96{_A+C`5|5Zdm$f}A
z&^$`xFYi$$p-wX|hpAWOSR16gENBA@dlG-uMX2-L0!in&vB$)XNjrQ_`^6X9C5?9I
zRsi)2zt^pqed&9v13wv!utjW-4W!UUKJZltr1tk%I2OSHz-jbrK}xTHgr5MjxF5N8
zyeSwd>$yCbKr>%PcpPf5f!M8ShxM!rqbT)4r5Stc!GjmH&b3ncRt-PV9>8}DE1-Wj
zu2VomhiM@Y{r7f2Jj}GOS*Rslj>41MjMnu?Ls@XxAb+efX$oObBwv|LHw8chCGfP#
zs^_Kq>fF`HnWAR1t|o0V$&;{9*;=Ury7z1<$|5A$li09@mT>ZbK77Xi1jAti7!<=4
z9WMa+N@d67ibo00Xfw*bR{S6xB4K|6dq(lZ*u>W=_;Dbf9{(@r79d*8iZ+-n1BNOQ
z1;Acaf95Vf1O@@N?*~i~e2362ZQmcp`djEIz*rd6I6{^{JLfPHk{_4wzB2<mlr<#e
zo<%5$%&-<0DvH8nH#yhz`@@^prELah>ZyKTt=hN#(>Yk+R&<h5x=_Q}vORyF1v{|A
zkTWjl)>+t<-X)-2J04Fw>NiGhsxYxtwp<ld8-z({jUs}Kj?aGV7)e_v>sA9GT^z-`
z;H{tK#OdBXiH;H$s|Z4|4Qi7F)$-dZcq)XKl09-goANt(Hy7{r+_yY?C584Cvu#+w
z7fMGsHIU1=kDizeYi`4w%qD+ydUmGk08?(tVi8*G?8U;k2veQjoWmeVEGrKmq5T>=
zRm=jU71dtd25GXahR<r?SwhJYw<)E#1ir_4?0+CZi3p*<g=2$xF~Ovycw0lE*?^}$
z`id4|;{)r52etS2_k2#n4hSebkWhk95l`gHZFgOt%E+p=9$VN9b=!YU7Z(1OLInwb
zO(9y=BgFd~@`8r)O)t?shS1EiDEONNv|4d49=NWD>0gnOv4Z1LmR-LT@brLs25|9+
z`dkgdiPa!(EJx=oXPSVlJ#)GaRf(SIzxCuMw(8rn54Jc{VUiZhV1tw++=lZ@B5FY6
zvr{s5cE<4u4BGZn2TOnSH=i~3`GxOm(;P>06xk`a>CMciT|ZaA+7(3&g2;iN`wGx&
zX#GGw4fNw99}#Z_c)=Y|JfqRm*rCbbz~4E%4gm}I96M;_lVjkcDHrHM(T6NiS!djK
zp|F%11T%7$O0^ISC8Io_APA3?iML*>J!yJi@(BaANi__$Klp!kru0mF@N7AZPKL|c
za&U}YzgPh9;u9R;`iWI3`m@|;f$Sjpau!5ag!@%lkcN4t=2-wGz7!_FhCU0h^N}uf
zpp#VIb0;MPc1rvs^OVv>xSZon4>H7H>x&Qn1j1h}d?W#@nbpYH7fK=YcgsTpvPhX;
z`l*uG*Aj3#5F&r_fu>;(d@!Jw>jez5+QeLVjNWsnk<Sc2BoKYUfL%glTuz9Nb|}NO
zT)D<tZ!JN;e+4*ro>=42(1cICd$(T=27yE+!SL>CR-lR)G(ESo+Gee=MRtkP-xMcs
zg37OGNk<M?^U*<7EX~_3a5p+1py#oIbYVYuz5`+d4BmgmH>CTQR?-`4Iog^+&!ZKw
z#f46)uvCyb21^6%s2UbA{5W8YU_UW2xJ+g+2a0GM@i%-|u10}#Ma2b+AWF?9mGBv+
zDTvfo{0<iS&L3v@E+q~Ajmy0I=MRE0luz^PF|OIC3$$yf!i$eTa5Ei2>4QhJpRd5D
zG^QzjZ<v2mUI?aCg6ZCNHA2`*)aWcslj65hY&wziqfbM{ECY}Ja>h=%G_JR2Q@WOi
zJm-RJ*SWTH75M}^&gO_5OHwB*$EJ9fg%KRu7G7Y-j(9(SHHota_-hEMwO9!T$WNN?
zV-MV-idaW!@Q;S?AN)y6E5RPEZm*A_=NbKjRSkcsuG6dRygKM*4S7QSyRZ2!V{uEr
z<glqO;VBnC^~g<~<C?v+d*B_Sx)d>DDmU#XU%>g}{=oOra_j>P#MqMG0mjl7hQQ#1
zuj`go4ux9ZkN)0oi$5!5%loSj-%QY{)x4S~vy8{1?FYYmv2o(X>Zv4x!GkqOs6+}{
z*oaW=cV%YonN_7c=~=$v-@<fqb!IQOx)KQDe(tlK+_b}n(y&O=Wo%u`*+#Ms&uPA9
zMri)z&*=Vw12Uy5>B!2S#1pHT{g{Ej#{CabBX+Qtk?;i*m#r8B4wKAX2m>`SG?(%7
z0x5r2ZExE)5dNND;SU2U7nMRv)LXu6Nt&)Hnzl$>pujc^v_;!QWyuhwv>Eo}cgLet
z%T<wd2oUq-c<=YziO(4P@mbDhX%q#y$Y!hE3A3loW=4zK-%q%s^MTMmpuAX|oW6?V
z8D~Mxaz0zE4_PgW*&p8JR_<HX%>5{eyzGB$?h6rnmvuD{Gp}vxveeavF28J5qiA`4
z_wp64glCj&R!F;5hVIsN<E|b|t9Ee8qnJfr%;tYB-ke-525sXoe4<%M`JG*f7}=G<
zWjsqV5%5TmZGSSJqR?X>@GwZ=gb~$Ejb`N>H3qX&ua&D-uiR0$kqvl-CoIK#a?F1N
znuXWa*qp~+yLCKPbp>L@rfX!Yf!ZDxx>3OM9^WeS0@$&H0dMjgagfHTnjESM@#Im!
z<KCc{oynr`iDBJ5kk3EC1)sE(WkJM6Zz`%gAtYo$lqNlq74lR8X%<wSLzE`Lx~|K%
zZQHhO+qV6eZL7<+ZQFKr+3f0apW6GJJGi5aLC$hztcdT$)6fHe4li}S{t|++8d^$9
zOd|i*sD?<k{-}_b#v9oz0Nl2)88TszSs(9=6Fv}{Ut{BW#5qgveQO0#Avr%ss(Pc4
zy>0BZDPJNVi6PWPc!7(t%()4o86%BxXQm6)oe8E~#nh@A3H~MiV`KWPlF`*FEw5l@
zTV%B&kpqnFrhe|L@77epf9fSo&Uk<VWiHJ5Cp*9w)7HFf)+t+?77$QnR1clI0wDu8
z16@4wLH40Cv>TS3=3`;CeA(2X)>z(mYpz}(?Nt~he>2e*ziPnYdP{8QT@@6IKwV4^
zs(N?r-MuOlG7!layLX|&!B4o!^F7ADRn_#oSW}p-&r>(Zt*%^jBx)RXz_?g{xl4d#
zrd<WZoaMVd57Px%4QQWQ3}}lidTDWOfUEvh_pFe9dm+BwWoixD+cK!>2GM4OB{~5O
zl}RxyTrTP_y=#ye$MctsC2q(71D_#6?suYaH%|NCx-cgfmcGhVn)8WP*hFu^1XRUz
ze6Us`nv<?XjWPhEuFfC)NMBv+0C84gc+khRd!FK%)L~-IasUlG9LqT^L$|=5{_cDI
z{=QysPv0NGTt<U_-u}*P1sUW(kT2ee8tIKAVHEhvkLlgflkNVb547=6(BX!1e|^=Y
zDtAp0K9-<Y9CKoyMH4j~pQZ~;b5Qiictuhxx>uI4PxdM$4SFGXA#aA{M$x`7+NQxQ
zrU8##gYssPT7bD`n?RxH6O;BP3G{EiZ^75+#SJ}V1$?dNKMU&nRp9mZ_2I{fhUJ5t
z2up>GzXSjR<TxTJh=;gLa$Inti!s%T>vsZvdOL5WW!L#=5MDFGg@n0z3Y>9)mZEmZ
z?ltHPBecB%L`hHrFt&+E!wCafv7<)~#u-h+;%LK8#(<dXnB74v;RuBM8z>3Nx;LOG
z55!6wV_|oX`kbyUYMh|+V40@HWFsnzEYF*|mdd<Ve!>e4M|PZ079y=)VsyG_X(45t
zq#5@Jv>kA8^5n#9ycPJ*`CvN4D4vjKaQx&2-5$w4#-O{8%Fklyg)?q3@{g=*UPe7c
zRl^epLjcW_+pNjbb(3<K19I)shOq8sxTs!cm#xNSh1VEPW8?3b+8TlGNgb7T`l~hc
znyVGhTAJ1xD_4EZDU;VK+}R^##J-Jb_iE?{;`p#+4iGC-hLH+FLK#Zyq3&8w-jlLG
z+|8CQm4A5h->S(*Aq>0Ra-PG?D$^J)Zu=0T!9QJXW8TmS;BpJHy4g%Wg6X-uctk~a
zp{bZ54{k|`1`L_BKJskSHWo=!LzLt~_X;ds&&CfY#0z@s3c><IaFWI5mz4Eoae2;`
ziJd*{hVk{mP>9YAdK&{#SnaBMzHRB2l*?3Mz8$W>qk3rX0s>F|>|f?9{};xjzHCdT
z5x}I4y6w?^)l}FqhWmNE;OG!j*acsXFl~?=9N`<@Rpl3`%lismdmm{T+tUxX-j-Kt
zslb6_+-Cq&gsAB=%IA4y|B9KW(zNWWJ$m+_%SRX(dU((=IM7xalK3cABlcJ0GhMXR
z*|3zL-|{zPj@#qo{}=Sh$h!xJ0AXTHLGJ$<K5+e?BruAtpODM-$lniAtHC3IgB1%O
z?mK-V+Z>&2*QMFLL>4V2s#siHh<Pq&L3rD4m{wf?KWpZak)l8ff8w%PcSqA5hB}b%
zv^21&@?I&EJNqqd)NoTPI`E;X2)67kbgrHHPfM`V2U|QI>XS_>ta)!sx7PJ+%)f0K
z!GF=f3!oyy`SlT2u68V7dl|#z{Lxlf)znuy*{#2b0Vbf&4~R;1>4t;uKj<$aT`Ain
zoT{3LdKM*83sV)LNOB`}esKPpPQkoNI-`Q?SLG_<OHl}M+d>pC(dyz-?n{g=k!9?m
zLWtv2*?2s+N`(|kha^gbgz7&KBu&Vh00j%-0}zeswHACReMsXhZZbB(SD8az!NGp;
zI~gCWn|lgLb)0-Fp?`q1)b0vg$rd5qGF(NrTw_}~)${HdZMS^XP^tt%TR%V-E8j`6
zCfYUEUHbjj=Wfim$s#&qNee)eM5y49iSlhEBMvNFinm<UceK9pJ+9~eO*5_<^o$C;
z20&TDOd^^xh1^02a!V)~uVNJT7|LBqY{22kenk=kX6f&V-Ko1#c%H@RH@d)2aoha9
zhEw_z<}}OP(BBd2T?+~Pt)bo`zCM7-)QU`Pq%DP}<`5T+ATg+m;|^rMPz`c%YOZVd
zUPd2>ZPY~L3)LEoxtI18U%-f|d~9J44Y&+()qZHKeN}=HL}G3*o|EKd*rbF*#;fR>
zF0BQMT{bJ2Z2wpNi(|hXRXP`bOO(F2E_*9t1$6W1Z;V(_zsG2W{td<#`CA$s_=pG3
zpXy4(2`(KE%3LOf$iN3gunEDRVH+`)z|a@W*g3o!ZZpupLuDpFZ~vMyf@F1Q5b#lB
zX2$)8GJWvA7-jI2i0!^Od4Rs}MSM4F+4<5zQ$tRinxfiKUPlz}Bs?CHzG3g$TIets
zuMIWmKD4jVdTUu*6pX~LqKTlLFoRBtWx>cSNLrQY!bg*Yx6*@CTV6=rj9Y{mA1>41
z0?kdaxX6AG5{jcsVu}BK$XTi?60lhS2cK=}YnJW|%!sFwjO~WxP+p3|X1W5B!{*+I
z^!rR8^bZ}|XZBsZtug$V@V@$#zxJB8`ff3#;S!k`7gcAmu<oaKXzIcugs1%`CYVKz
z{G$8IcTaKxRtn4vqBOWdk{gWpa+7K+_(rfN_rTC)CZc)Qw(uCX4ezP^C&0pw=rWDO
z)TJks#I(s|ZWxu*VtzhTW^&X=wLX>;ogF#li%ChC4b`RrOr)ta`4|d3O+N^(aUP{+
zDjQ+VbULZyklY_K)+5LUjgC28drHGO*nTK6vWa2eXSPug&$r&OxvQGXAY&?TsD)H<
z(^FN1#?n(9V!|q_oAKk318|jPZUMHO{y5B*`?_9eFAx&q%sj>*@uo6*xFAJV7N~-H
z6w??tSmWetM|g_v4}=k_mp7lDX%cq>sbit)a0lHyk6?xF1VvH!%0w>(&qLBca^-m4
z8+)zg6URW$!@nTxCbpp1ORhWQ<`HAP5O_=s`>>9&%FoHTgX%no0k|ccH$=YYzQO_z
zkU9jxPTFNgpkr2s#I5fCT?SoI{w}N$^q{Uhv#kcMU#7IAjH8458qlqdU%?;aSBRbO
z$a6Ij)E_FqshYJ}{R+o>Iv)5rfqkC1>rztLyrye)&yvPNGbTeIK(Z`!qkRm^GRw(s
zryS@D{S4xQa;QaW0$^H=zO+gdVYYo@o<0ukwjJcB)*iHaW&;+7x^WP%7oLliseai+
zYG8Vmix&o!67IYZV9THp6Co*2?=Id!dvivS=X*ZZ$8L*FBEW_%KF(zpi@%{mBJ3tb
zhfNt1jSC8gM#&z;$`P)L=+TXDw02J^V}RX)0!8XCmg^W`0+d6pOY)O=EVn2D5Oy|x
zm+h$>Voigbu)EWE=yx(!$2!KSf)j;z+unKsE3b*Nn^LyeO6%^V>no<k;+v^Gof8rB
zPN<qnocAC^RN;wYBc<!3v&nGjzMv;e<FL4Bqyf;`C<K7Cramo920a_38lNheD;c>)
znwv|t+V}KH0Z7d>Y#fe9y-FtW*JCciaUgqO|Gc}DY*jmAdIF!L3~<E9;=01n(4hpQ
z(nwQQ5L3PA#F<+ylNd`YHp`wQLE}8_K6e5+`EfrQqex<{htU`kyz*|W3-D7ahP<TI
zfW%>=WQGqbK{1^=3<a~xBR6=J8Otgs(^E^SDpFx~0atlm+}@a69C~9hHnON*+X62$
z%sF!fX97S{b*14ASQ(<@Ilk)Jm=eIy%Gm0oN%bq&>8x%RIc<E;8EA4njAPpK!0Sdp
zd#j?&9;b=JA#j=zMf<su28m4qWaE2VI|?Gq67?`4s?XV3-6(gnk%Y@gMT&SvFhkb2
z-J*4804SxDuTr}lAFB>)6S=SjYWh|;mZiSfF<dH+(EPpcwt&Ce@2DA4Ry!vAv`JTg
z758fl1oaL3{hM_z3*649z3g75ZVHT-ydTg@Zo_@j0};tRx>VYxRJ?tVgkFEb;7L<R
zIO^dcl~YKfG@?*BC*0_nFTvSlBTu!?(%O|A0E1DNFF5?sf>N<ppIEv0`*ueIgZ}sD
z&-brO8`HeH0rl?TRZ;t9L^%757HaWxN*_K9)r>S?R3;|_JJt?#H?|_(lU#4d4GWV=
zfPR+g^fsX>vW}~u6iSTvAjf|4?Bt7!jW4#9A?`j-9O33z!jTzU0G{piE0^e)<foM%
zKrF!mJO$^2H2FGV!MUTo828|JGnC}<h04o6XHda@ooBEP@X2L*n^R~M2PjI#fkn~0
zf$h%<O1=^E#P`B)MSox~nPTaEl<htuF&`WMnE@}*-IT$lzYw^MnpnY$^fOl3XmHUz
z!5)2g?<N3=DF)*P#Ivw4iBp)VA;fSsK+R3!y9EmTp#~Ey8UJLFu+vmgP(w4-j1vZY
z%}|I~GaU|G*tp%;W%g2ITjD_uFxz6rt0US=;8|Ey6W`r7O^5*vys7IdVz{A;LO<t#
z`%=&O0cI5)M<$fR+#U#$?xUxVHpdB01NOYdvv%+65k6xzCF;TxfO#DV?-;%h;OWzR
z#W}04ed9dN%=cF-x`$r{Gjj})y;Fpm2y#^TMiKQ(i*aHlPrPphZjPgLobn#{GCMG5
zBmt^}`|c6=!|%`5bK}LvI7rEHu6O0Y>f*1yn75#J<kPd9_$b&AD4pPPZv&F@HG9>l
z1-8`J3YohQAouQ~svdg1z0001fTd&%1O^?c``=HRcXSL2<X*?23;@i?KFdM!>t@eA
zaQ2=K(12RIDcLTXB|o8poR2_=_W*K9^cPdwm`7AB;VQYZFUDIDLwU{|9&m@WpZvhA
zO%-EEZZ(9tr8vS_{?aua!5JgRlKMl|-|~aV1_LQ8yOi-zg8yuwlOL9V932ERuW>@i
z)`q92JKm=<Sof2K#}uQ*2Yl{PL&@{$aQ1oU$|77R9=)NYcomOfLE@YY(-Bda8)%lh
zC0TL!q>rNg2T|n+1^klX940vxeW8l0oZ(^YGcC>28~&A7msr6n5;N!ce)z3<7%uxg
zr-K+ll#SQT>gmn4lY4vsVU4q=t2gO$-GCvu3r=3Id=u*@w+<J4uG%XLlVHTYA6zcp
zLO)j!<MK!+tC;Vz`K!j<<z&5?|3}6?nnQo12g(KHuq*4oM_it${4wUQnp?=N&+8m8
zKlV?e5+85kP>{6#?+XxD^b=t4G_&;<{z9r3V9VvFohypzLGw?je2C6(c;?r{|B$!P
zfSEFa`oK`ZiCDN<*#4KirM>IA(*X~dH*9o8ti5i;N-FAGD)(!<C|Q60opmLb40$Va
zrCyxYR)jYGbp?yGurBd(!pE8SpaLX@LUa!*G${`Ra7h8rA%hbyTb{jrC39MNu@DV0
z{C*c}%0&$RmU|rilTz+jWJL;^1fI2{cXy_$f0mQ5Hyy(5F7A5>h%i1kpJ(u^CA~9O
zHLO^<+A6D>dJoTRk0_$Idi@-(=Hyz+W2bsW|A(F~)qUzkQ%yp-s2H?@-ei_3QHWU?
zGrtZ1JihzvxR$IS(nKWp7yg1{bNWM}(3)6CfevusX}=q}LMSU<#PIZ!JnGrV>AS2u
zpIn%~7?S*@)8B3e_%*Vfh2Q6XFexM3Pn5W9wa+!VVf%i&@+4yi1e_j6a`(>EV^LK#
zc;Rr<z?rv>aSFw##kMk*QG%4II1%|A1g^~Tl+FLO6=H3Tn5DVa7E&p%$-zEX6Cz!+
z>FFT;X{nQECL67QS0Gzo@%Aftu8kcXc>xbYzO>ZR#-N22U`T;DQO4?-;})K2AA&yX
zMd*f9VLPBBqq00HJNd{o;mxSdiWg4~;bp-;wYO-s-Q@mezWsa?Ki)mon~zx$5zBvu
zc6$SR!Hs=_zVDO-2FE<ZbUW@>m>Jl3IGJGNa>_A0abqK1ug=~g*E39)9=XK+itF3`
z6K6_#NBu$oFoa((?oBvFuqavQHt0L4VS+zdKaO-$^Wa?1HrB{2qkOc1xz40NVs<6c
z=-b-xzTrgp+VTbsDeemqMbkm6!p*9|Kn22!Ii@adM~9+B8qtg3)1p0TBj`y~0GF^7
zGJH~L?7>0}D)|^XJoH;HexZa`A3<|8hV6Pzbo`KKG8O`P=R?)_PU<nOBP}$fuYbL#
z#}_q<yGO7Ag@sc}pQQ|(s%$t4xvt2!x1rFXmQ515kw|{(oPy8xkYl|K8E2xpbFK$9
zKu@~CbW9Gls7EP<njy%@hD*YDQQDK|If{?UfT<w(3h%rarnXw&opXILA%w{cl}7a0
zdia$AXt%^07dEYe6@}4CpzOCklyVo6fR5FX%mxxQZFOZxh*K7M3SJs3zp7d&0qZLa
zM}f(<8t}$7&2K|dP)^u7eb(z5%LM?o%l_)mspmhpPW2`}0{tk)Vm_}tt4<)H|9bWU
z8Vb-@;xV0_eW@fD$wCL_tc_$NnJ|s+om5u<VAZb;tdvJ{eQuQ`aqK10!Cv$G{jF>w
zP(y}LmeX=h^*L*J+JQhl<^=EMxW{4ijy6!A=v*$+vXIynmUmWS)QFN!WLS%w{#SUx
zk-LTV?>WPuD5`TYs25)<*DzI-NQ%L%XX0<}XZU`uqv`}sdl9`<2x4#%txhE33di?=
zo;l54Dh%oDuS`tgJ_JkyoM<AbGV*ug{8;Z=28VTwSrcR+ibuJzQ{Vg~FW_$5!XnV5
zOXjfwfEI5Z^$;8q4HPCr4km*koH?#0xL#4@s*nbW@+3|RUnHT5FbvevVQ(_(cwc?h
z&)dEVz4U4tEyVmQIM*v&1D|2J^w5CiVWrrx`{0m8(`AfcS!$s>ERI82p!m?;Fjy9$
z+9rcRBeM<BWlis|Gl%5rayk7B@f#ReBYfvYGp~eJD+ToHfdr77-db0wel2&g%Jv9T
z!V?wB@e|3CP1z!+`-x@|r~5y99<z;~gi|)`10d-Zlp|FmA1=tk-ma<}{X_unJlTcE
z`?VH6*9x{3QTWitEp3xs0vwZ@1_EK3^>jm7QA<d-lpNLZT#Fra<c;}x;Bz?P1|^NG
zzX@X=9bRoa`7)hu;_<HFc(J26>2(d-4GmLF<wKqHVyYw4!qgd;%iN(4Aa>-(H?YgV
zyGy9yt`GLLC|jM!<tkRNHl~0CtB(LFU@3Nw+-#^Fw}oL(qUaG{mabT^jWgsoRr5M>
zocofw{JQcPCKT(k0I2IvCin`S9K!R)&|@K|dX*DnW%~spQS)jQ?gLrnWz)TmWSr4W
z5vTYkYa|9q<cy|7iyTte?zT|Z)+w|>aF$!Ali;%s`bMtt#p5l!J_i7g8zB=fUAUvX
zKT54*7yI8YFo`ckN9<IG2k{Mpl?sQp{5q^StW%3V4ib7&2`q$KWTClVH_@cRItDsW
zP4@ep*7cDaEl1ls<2D}DJN&?VkyuckJ1~ehcr~H?6gse7ODLBx;H*2u%@-FzY>1?G
zF8AIE#0m3P@zm}h=8k}uNIxVY6hc|Hc2a(iqK>_$;IUuGy}>qBqO2tFHQ+4#=Heo9
zPUy&xmWkeYKK+&oRC2_)<V3K7JJ^1HA+^9AJvq`o`9FU;8)K5myeH#hUCfqU^^m8u
zkF1Pl$kI1oEnKa1Tg?)y)E`r;@2Knx-ZhXdX!J?emctKhRbarY>T|dG^dZXF8;D(B
zunln1Q#EYJ)ckbYMi6D=u<%b9xaS_T9X~)@G!&mwHqZNWG1pJXFJH$7uyzxHC(_Y$
z)m92Q{qf7XaPs-E7j@*m3NtW!p&~cUB{jzss_)AQ@4kd9HpyU3iJ6ylp&6D4t+Tu=
zSxN1J%wJErR2+~UUwX86ZD9^_6PC`QXJ$=3<mK(k+W&BWM0WsNiKV)6-ft!I8-2v2
z=J+ZIrAEQ+8UiC&zE!7}h7Ph^=FwBkf+U$vZxxF~3{KpO=JylYJ?$>Kg|!e+Y-TWG
zI~Y@D+QY*NMn%G?TrM#XsS@c?nN8aU4)H^Ewec1T=?tJQ95K|SLISMQkBWyu6FrT2
zWqK1#m^MZzA4TY>OYJGS`4!9bf@F;0?#A>e0u!_#O2V%5bCyWo5HcHseDzMtlE02|
z9aT^Z)L!84ZDX!h9dZm6e!KHz3LpXIFBR~vDhH13j3TpIWGskKWu+|f<0A(ArdA}$
znOTi_bPNECNZZwn_?~6LP2I3zVu5y&3KeO0+SM|U!f^~Y7t0TC<su=>7KlfdOb5Gu
zU#1LBh~i#EPu!0)E*F$Gh-+5b$7|C#w1{NsYwcOr?<#r=g^s36*Z}$;>vMp|9dr$W
z5SyZF%AVfwL9Ya!e3fbfp{)QOUKal9n1dec%OOA(ZCyPJ6;b85aO}vaS=GS6t->qH
zxU2Aavp%CfQI-^&AK{P~QXU;{uLLu^nyss6ZBOmOSUFtc$Rgzgf}XCpSViaDOWCkT
zd?Wo~ChHIwBZTD+#`!b$h=(38bBcql$dpRqc|}(f>nQOP2jZ_qu$Wi^^`c1<{ViKr
zm<>RHiRw$NWG<Q>K|HpmN#t`(cW2_w8Et$n;lcBCd}6FZ*k!fgk8|i6<(#!bq%gSC
zkf!6$35MO9%V~QU)5$l!>1H}Qi~P-c*q6BIDtvcFy>DrczP@HDvCpC;kjP5xmN&6y
zl-C=tBjz6VmYOFSe;ys2YF`&4f@FWw@(%z(6E^K~+?y@Xk*V*JAw^STK$knI<U-pN
z^ei@p|ERZ?{<5xBqkf=ON{x;7QXi=mO{^F{k?RU0iL>od)HGb|y76_RpsoR*>r+v0
zKxaE)@CVzv!qt7?jbI!SQH=HuDF^joA}60p&|l0&L$FbSw}{lC98dF^8!5UT1_xjO
zMp`h<@>$oyVW0UeS{lW(2X1gvgFiHt(I<EhHF7zgE)4a^{i?;`XAga0J3akm3;ntA
zcsbln_}cT>{-EnTi9flq{oDP|VvDREekY;9zYqR6C*twpa6kMjbs%(`)Nf!TfCuQ4
z-K)&k{=<_ih8;`AIq2Vux1%$o6i@)RlSnAgb-TiOq&&!{Mh>Flw|IW}nc+Ya)YQEh
z=&B8n`{pNV=2nRksz`I7%0XA+t4I=rAHlpdRVr+y9Zi)%pYPYF<-h#9{(Lx^e-|M5
zOCDpRo)zP?20l#Bt}OH~s&3AfIaOz_>xb7o^S>%Q@(Bhg6HFRb{{h2yX9N9L%LHL!
z`%k?TC<_yJ${-{aU{+IK@rVn}|4j4QK88&?g~PbOicp4HPBO8GqXy&VIwXgyR@}tW
zK0*ch#?g?nO%!E^<tJD`67OoC@9TFfxtmA&y|Wj#{K12>iMi*^IHizllkVW-($K^2
zoc4<xt~UHc-HWB;;VbWI19L8H8#d)s!+7VTT5vZwSJcM_5GPUmJ^H%x$k#7O{_5tn
zca~a0J%sz_+#ZHDb!g`9uNvPY09tw|`-aHEjh;j&NgZ2yfjItW=`n?u=dYwc!0p}h
z^~(%nE%WQ}p7Iwhy`Ych+QaSjPV;UOWp8&6ANus?x0nD)Flq}m)q#|kmOL><zT9h;
z2)DuPx1Ulo08hz)S*h;^X@6>wb>|K$?qoVMDOh5m$SDM?{9{QpNXyHvI{;Ub1d5!u
z0;BHlBlIyTdi6;p*&{Y73~9UpQL}DN*X1q7;Oys%GdJ{EjF9o0z5sx$kCg&^9@fDb
zhDnw-KdpKF>BJ6a?qBAl=5||HZ*>Az-X`fdJBk)4z$QhK$qw{Pcf(DKiHn1KVUTzr
zLt@z2JKtV5&Xm9}hyLu4EOU;hE;eD|n~dSS0OY_{f!OrV$JY@}O&qt-MyTE$oT2c@
z@)s~p0TNsZVTJL+#2A*baa@Nv(3=Lmlm7M-e{l?*qB7X3e??r&9Nb6RI}vn*R(&|K
zOrk*|0A$QoT&q^qwgy*@s^u~z0L3k$FEja5lgQHvq^G`VNwS6lo-*_ns1|X;rST1?
zH1aO)cio&Qmr6a$Sz2-7P3m}RL_iWNc!+dT6<K4LBziMt7z>zI7%$}?4wt~gTOxR9
zu%3eVvh}bnQ&={K-tBB8h9%?)_hfE7LidhnKuD_r^=CO!=!pIustn6)pNa=gKcfus
zg26q#(t!yG_IGX6Gn6n~LC4KykkulLA24+^eI&Pdc6z&Mr`(RU&PYR=ue=zkJ|dJo
zOsE@6&sOhLM{O-3#bLXVi(qq|W%Zjq6Ex<uOhrCvC|1p%!<^Kbpd}435`R^x!cR{l
z04%j7m~N5ZambX(z?!m6XB(-B@J|Y56-3+b6h3~j?w1)^h#xIWTjOyoIh(9hnhrdd
zqvVQv+y=6zU7CBV0;D}UE^~ruXDM<}loHZ-?UjSZ$6sChh=lhUlE6lUkjG@^MV$l~
zo%A@1n`;`8^zzZiO5$LPLmR+b4a_<;K%_GXjmrm<u0ANLV({050~_#-4_GYSNMh70
zh{^AD{%Vp!czQjB;8p$AaxKn;!4|yKxjsq<{pTD9LV@2><w!GkEksoj4n}VInm<zZ
zpT}62*_2!JDZZxm?HDlJBG{UVWm@5~`l8mxsM>|l^5z;G%RpG}=B_q%<JVGqz<%Ik
z5=bdVukKGPuSokSyAeI=2(}z*w>$v#@3Bp5hcBGvnw#^#1}F>R*FypZ#Kxem_p6tQ
zs`-H&5W53o=*-ZkN-zz@znU@eFl<ZyZ4@+LP%@Wmdw5Fjz()t#`>^}e-$1))SxPZ9
zihZ^pd5&|n?69XfTAn7)y}ePqLRYk5sRapSE~YDLVC_Ux;+`oV)wYW}-QSx1+t)Dx
z)XV(v(JPFER8{uGL``k57T*J|^7sG3+aBA`0Qc1R5dT-^!uEfZZ_Xch(0>gYKT_N_
z$Bz^@WJOT48-t}>)VEWvmyFRFL6E3_pwt3B)oQJasr`6Cio0LmkBuO$+?LxGVMOY}
zMRw*JZrT@pKxmk@NTZ0N5pB}S-51H$vR!X=e=&}^a}XAY<&y~j_&uCPu<1WUrYTQq
zCh-2N7{9s9IM@}=gIL`SlTHSJoxC%kk-+b@&g$!diT=j}d~N;k_EW$++>Uq$7)XNh
ziHbD57hFZPS|(6buWbu`w;d6WljWmcB9j{3bxio@^>Dbjm^=26Z-&5J-#P7f>qU_%
zHA+JZb`(W~(f{uo;iYWwBOza)$M^HBJb(BvA%Vd6>#{BuDSHM9%rYRk)X5Mozo>*&
zpi&0`{Q)}mL9W>wbEwB2O}e@~j1pcQRN5V6K}>x(2xF<BIpWl#m0kB8ne$|@?Q+G!
zs#_*&cpKmU5D6#u*eO%L*_PMb`Id`dCgjNW*cIIcxC!-M9!oK*ajoLp`WmwAr;lt*
z%wz+wvVP*MG#yZ|$PV~dZ(JA|Vj~G9Z_7mPpSUDJkS1{?yvo~BWpAdRU+!wlZuJp#
zflA=dVUvBq69t>@+=3wgJLltr^Y3+lbRmg}vh@QNmgrbW{v8Z*OL3<v2U$UhlorKO
zR;Z7Os(lrHa%R+l6iGO;j%V?ZKV|h83@-FMiWw$d!3FeULm^<?R8at2RGN?$C%d&^
zk`4YFKAThP6iI~#E*68Ou>d@nw#`yjBnHkl*UQ)Yz0NV=5*{TGWT*A!D~ED3?5`c=
z$9p%q_1yKa7;>V8$P$<;kIXckSP1e+@E&55HWB1bYp&YUqa!bQL?fuFVFzc7-%era
zG>1|9P2+og(G@^S49XE#Z7$%NY%7B>Hq$wr%N(510n4ZU0L(N*cUAL40%1$jXz!M9
z7~(Fu9Mu}l2=!^pYw`(`D}h_f@pQww%13#P`$*g_spgDr+Xhr`lQtrRE$=kAwyaJS
zGd?o(vccq9ErwWuG(E#LrF{sz9q5|1!ig)B52%a}p#=cbB=Ay|2ma5nnC)^h*%_c{
zh>zlT!*wy_MWHX`Gxl_?&<u(?`>DhQH_=o*;kAzF#M_TQ^6jp)g<$s_8nhXa@)?{6
zN4gUH+bg-5YWf#GLnXbrckYKy$nx&5l+FRMwUN4XS4ZS<co4*@2qSVLTLb01k5o&6
z6SFPrxko@rW<;Z~M`qD)64*RqX!?hA7!1oWa=+cy8xmhEuauc1Mh4X)I7H9S#gPXQ
zpiQiQ1Cxc~2v9wxgBt#o958S3(+8%aLOE<lB&%}~Oo7j*V{zB&^^+4Vm09M=;>e)8
zCIl}vZ=)wWoku87Do-|AYJBniwSR{al$LfEl9vG&A?#vT!Qt&{gT=u?t^eHh$&^E9
zIA6*T+!k@ydIo}GN?5d*e1MQp?1x0gV3cQ0PERUHSb!lQGDQ&RFaKl#<-Dj}fFT@J
z6*6iwz*RIUe^gmdzyp<$RwbCh<~Q>@5zo%PD8G=~j5&x-C0Gy~C?|l=*XRuqu`AJ4
z+MNR~%$7xi%Gv;ED!)nEPxBSq)MrRx<{ZV)fRV`=zg5J9RXsI*2+Hp=QPu3@CIW?T
zd=jhT0AJjXqNr*tP&7q7QfOGTq=!YaD5ae8KLsx{um6k}cW@x|*u)h(F2G8IFU!Et
zHqk(B&6c5-;v+$$>04^(Er%kis;dXc%<TaR5WXy@CevY5Ce*M0W{3l9Am7w%lRye9
z5f&<dlufMa4-+v+Kbj#*iF`ASvO-binj#_b76*QA$?8iH1Yluzn2}+6P_{5!UIJ<q
zd&z1%Acl6$gAYYGWFY6z6`e>2@bDWlc^OLBtw-NNLR|<A@2pwrpO<$smB&Ie|6&2F
zMoy*Ls!f8+QcqM3M14Yw+{(RMOEq-@SKLxsLg=i}$ZaMkbx8<&qAPf7bWc#=FyfI+
z)TAxWP?22{BbPyeDM^DPUI_@|NVFeGU~(~CSV4CP22*Ij@In#%LV~17x1{Ip>M%km
zye{RliGddRg^*Y57X~7j&hVq{Xc_>SG1d$rHPG-XkxfU>LsX`nU&CFyRy6NO!?bYu
zRb4o9F#^;F`uZ@w8}x_~(Ocavy~^-li#X9w4R!CRySmEmh}dORSSxL;H#<}zM^c)X
zFCMl>Wd=11^ETOb+uFOC9bL+D<aWVR!f8WKGd;Y(ZOwnmlRkZzLmO36uK5A}1}tpU
zUO#JK%2!A=d(nHHd%jr)H8W=d!|mV70UC#?S@)5xXSG~_FfZF>x(2TI&#KMJI-70+
z`StHCr_n5_<*Se9K7DmnpiE=`94g01%gjT})jwN_jF{n1lal=uN`g~wxdZ#P&s5y!
zH}(F~K1j!dzdT~L9rK#&8UV{qV5IDGUj7}5kLo#6BL}FMYxjZPO55590o7k*GcikU
zGfrsDP?g}G5lwC`u43zhaF9GiBuyNqq0iZC4vSQ%2%#ekjo-J-3JC^|G{NkAPx8&A
zbK1%JQa3VGUL)^$gZ)|G>0LlqRhuhE8uTwlGE|iGQA+f1UJ<rA<^Xc0`p&V!3)fVo
z*onDL9)<!>OL3rEW)F;<(CZsoJ5@MEr&-+CCW^hqr8?V$(AzzjEF*8?^pqk5isoeu
zSW(jGgv?CRzi^!z*fFx0RQjddZ#ycCL{r*0yx0Wj(h?l%fRSmJ7DAaGr^b?1na!6X
z2o!=fcl@=pY!O#(C;)`2lAVD|2N;Yq;#BC#W>~vIEdm0`o!k2d$SMVJ1NYFA5hn+(
zsT9z&=wClo#q+ZID4OskVbn^*>c2|)7Xl;5wwlP`h^hqP{>k@z7Elet->S`npHW{R
zp^RwYUB`^DOZC<XiSb`$23d;sd}0KO<?nV=U`0R$iRTbF$^dI4?ICzI9mW%RDJN`C
zMoG+n!*9diQzTqw3zhuG4B0-QPQ6u=%Z~#<1r}s~6=l*T{4hTKzr@NUaXT+_Ak`v&
zx%;nqY@bBf)?AtCf^mUr`K&snN4vdv&DwX~?p}6@1FdXT=$rcbz)PI6L%p&xkPL(8
z>)ZjQ{8X+WBLgbi9Bg%pZ@irv+8D7gF)O!e!l(WOPdzU+dw{j!3zN&+Ug)>63;jVS
zWX=>FtdniHlB79_+0;I9J51N8CI7u;)GmkNVSU)NosiN1=Ep{F>Sz)2X?GMVvFPZX
z3Jv^uvtf-~c|mYc#L8*h5#rjSdtOYprlxQpC#d&nt_w)n2CXFGSl3(cStA4MS)Gy1
zs|)S4hlBaTsBOpH#Fo2Ewdt^D`E6#SA}og3ydn_m948}=FQ(h{U5k*C4iI`k18*kS
zlWy&-R~_D<m%!7^SI~!$ndfmAo>)r$J$M86)TaI12e-GukSHVq5mOIAb)TbuVt_AO
z2xhSBoeQ9+IOn}aRt>ndmfHov$^?t+6M?1o*AE_pCb!y>jE^y$T6{;!QP(d9E;3dz
z2tAMa{MGqspHrkwz;<~hRB#o60aR@fo)4~QY7ejp-o@&ASSL;bLzL0~R)D@^(kSV4
zm^o2;@&9O-iNW_dhwUFTAn<uep-a?SI?M2M4F|mM&nWsJHOz=N3+(P?VyfE;5c16x
zT%uO9m}eaT2ExS=D6hd87~*rg_N0mAt$q=lomx^0{k65G5(ocDZ6JJ}#&8fc)46M#
z+8eZK)r8`9a_>;(vF!I%JAU^xJm1G;QtkZGQpvgW;otSWDpVr-zDm;$`$VkCkox|y
zs%50!gCl`5v9qNp`=Mr#8-mgT(sXnaj@r<Fxa`cC88*S}l4#=kJAHPZoTC`RC}tK(
zAo9pgcAFR^vUOy4W{(T|d#<SD-ezQjAf(AfUI_CiyqNWU(1-bblfyYHSZU*%v!|~V
zC958Q;Sj>_2Z`xEbUQtHkMFOC*{}7ry>q1#<2pwI&*fr*cFunYdxSfHO2)13G-is4
zb<b+9w!x3GzL=&0$DAsfEB<~z0W|x;VNXQDzA<GyHw4arK|%3x*_{7Ka3<5b02p_@
zLt1+lTM*m3@2A&!PC`Qdd5-AsgA=E->TU9eYY*(67EWmlT6>c|Vy8qB<wP---D=Xb
zKs%AW*1hy!zE#nyWA*@qu<Lwj23DHoi-!K|*MP4=EHY=biw=h<J)A18r{e$^`;BR6
zrZrixVzEsw>^`L)^ML)dxwxjnAmJjD+J7r?^ZJVh{SL`hSdo(!8?c!1!?}!jS4ht@
z5-Rti2AsSB0iDepPWDkO`p4w)sqEi=>-L^ke>6#D4e1|BhSdPtSAsqQskkNnM#+kv
z$~ZmuUb@#iotNG!$s!IK5<e3nu`Me5H@L<8hxZs|K#R-m!V9L?JPSI7Pu0|)LhKem
zb>u%?fh&xj!;O{ds%wSz9%KEVtAjJ$<=&qkJ#)2BK26~X_D^{Or3QrpiAujTO4=xA
zHI=4y=Hr~+s3(9nN9=s`-2cN>HZ;)3CIs<+t!yz4Q8tkjrEY8m!_}m6IChkh3m{q|
znjZX$3qbeO@&7O^fe;)*wzy~h%Arx6B~o`brKjKvR>dr{9vmt_LP_#$JfDC84i=gO
z+0OFR2%_sonel!hQkbCNqx~tfsjI}Q5lpbe2`5zqoCU15*WJ=2hi68qTxKJ*!mHc#
z!ro=SR0wen43lQzI~_hCQ_h>KKb&7UglYbk{?V5Yse7>;l|m*x{Ao3TXcw|%9*=*|
zd3l(HppavZ4g<q_a%4qISiBwd)9cf6&@k`0UeOcI<bkCs>EhQXbs0s;TNF`h*?N3;
zEA-(3!ho+TBn>2tOM<R}NjJHG@W)Al;>_tG+qR3;u?F4l>nxJYbj-C`p1j=pT~uFW
zNg_oP;?3b7>aI0~95sC)wNzNR3{CiIq7ep}B=Cnyz-)OPxoJQ~o=u+*NSim4bgHE!
zhm*h~y`YI(qFoV1ud!1CLv55yu(Ye-HdrM9QDm&2gTu1xnB%Lioui0LP{-r*s873f
zNO9g5{DoNY^7rsU*!3Q>b&_!cM}+HB%t%s$Zh3PdF$ZJKe*-ePwZD}3(&{j>;{y*c
zqj5e&fN%>K5{^3gNi&o!g1AT+;yup3cb2%4<VtR!YVOG+&6!ccX;ut8axO3QG`490
zZ3JNksFIYo5t1P#wq-CFP+Xx#YJ&$o=oUTPsQqWamriZDq((||&2|MIhR-=4(m<W#
zRGrCM7!)*cf5PkxOjAWZ)VF={>pbK|o5gjbiSQI-EA=f9YsQOz|GP#17_-F)Lu3|6
zse<~wMtAw`jlkaFg5taR43DD#5>!eHsKz8<MJu&-vV&r7JDX}9{*gUGjGKg2E3iRv
z&tv0w!R0}uV2?mYvmz4&kVJ~c3E~ICRiPdu+%6GG;a>T+J|r8>|2}I7I4i^>7LJUl
zU1txIE=PE#hJ-h`IPs5Z;~PgFvd3b}p>X8Q(et`5JBx+?ibZWmDT2Bqg$pVLAV(z0
z&{O(=j;W8wh%(#{RlBVFYa4nR4Z6cm+zl2VhS_&AQoC7+W+bnIta#8}iS&_-8ABfO
z*CQv~=Te~gz|l8!5-|rK2ydoxKw$^j;wv8Dq;C(|Gp7nwJ=9&|Bx`ddV$2yTpk$O~
zje*71KEQ2A6Njdd1^~)R#&8G$`{{ZNEiwt_!|wmWCLH~)B|PjoQXmp5af={@3{zAG
zR3rzHv~jtPXorj@RJch|i%BiWfrA>WtHRwT(jjPhB@oacQe_vx1@LiQVE9L{8kDOL
zH;7;@+8F-%QaBjJ{lQ7Pzob_s-nNJ6P1fpFkXDqw7bAei#Xpail>8e5P!u?5R^bQ~
z_M_G(N8O|?Ex==TQ9>Vn)3c^C%cLixki5GT1OKsi#s)GI0p(g0WLq3Q5>OB^@8n=Q
z`Qek5{RAOxc*4s!$cp)oa+tpkG>6;R&O>L)c6ycYwx7C=Ah}+N^dDUL4vybN<-t*J
zg=Yp=r3Gljymwb+%lIJykooS&`7udYFgcAcIp(R3+M!`v)qhB+MfaFd3CRC|a!*X!
zJNY6$oPAHW{%toE0Vq3-YMAqM({<2c>LEfVtE$&}6r}h}7eb2sll8Y8=-H{~vrJUD
z;e(;K%)kWSOvrU53y)y{5=!P^U>fqL-YygHnI6Jai4MW3*F3@o=nYwNZ|uFjb<Zd4
z0|GwZ9wI#V1^k|FAC`Zfbm1plYKeY|g636lHC&eg)Qe*%FQ9r!Eto&<#u*ddzlB||
zt(JnQZw1Qn=u|bT^u>i`7yp(XU`~=6RPYpgTY#OW)}(~;AoG0;$mTFYk$}xcw{$lU
z3HSXwmeQHmEM)*FC@3W0u`FWbxyK4vzOS$KcVX6@q5mF1{a)_l`mrhHG2rMrk>G};
zQ!P`dwjV$u)bO|ia`A$vP57kM9G<MryEm>>-Zp#+T3{6M&tq&P6^>h<L$*|Pm7FEu
zkYnBkurwdJhLED>r8$G1%}yJ_b$KezxOpMHt*Tv8W|aV@q@@E`xkYfY(M_X)NGDqU
z_OcZ?o0=>j?tXZ?7i6{;@l+EqnTwJaAuO~Flg@>}<nq8Qr#R2a4Z3u7z<tkF99QO*
zmc|_Fvt^Yf!eWrF@}|M_?r+tv3G&jvSXsG+P2y_99nJ@~5}oJ9OJ}DEL^ufOCN4sF
zz$?kSrC9*xs`*Br?onTQS!Qdj7tyBNogf5rm9BVfMqf*A21b9+W#p6(svNx^B$bFP
zaq#oV&1)4%(#|GDPT`#3r*=i(MMWjR5xlw5^pL1Vq=@HCgVFpVIN}vssAH=FHICPM
z-eX?_0z0oFz`3GoQp((F&zev%{Ek2pE)JVRV!;8cTXkoh2kx|R=^}Ib^F@nY`z|+h
zW3%!l#Dd|%lKu!w-Xu5aV5;VqwoZc7eQ?4XdBGE3)*CyB-5nBAbfDX@a=?~$ZzsnD
zaxwW1#Nq@DMyO>bf38WG(qIM<T4Ctqr{Oc>J7G&3bob&+V?ADrMVavUb2snv8cV@a
zsx|<VZO!-ds~27c@cGJDrH-Zpdm&GL7_yZGY^lY3R8+g$N=2A5q6`_~dIHb0kDDh(
zK2Ev>P!kyJirXR%ad1tXHNQ6k4_%cTv9?s;BX1WYSbnjW@z{QTY`=SSZpS;E=n{ri
zcL$lS!+w`2d2Yne^$P|r9<FT!3w26_9AW^#p*YEE*(wS~8A`$%<NWRmbM2ydQK?gW
zZ#%XiXjpd-dk)VkoaR?e451zi%*f&=4+v@7f6KiKdwq)tMtX6h4Sx(mmSz;EaV(0<
z<-DEf?(d}R4YS#2keCjT=S3pid%`USF{7gDvLu7aw7L1b?bk^Q$js_JT2L`2aZ~_|
zoCKFf9vv~2^9JmTr}cP}^s-f~sjQHE;kD#CFSx8Jh(gXhSImAt9N`PSwy^&D$a-GK
zGT1te6yU3XfRIfz(awP1yHuf$Dyy2?I+TPNV6FSUNi=ZdGlh}?nQ+i;zlbP?CS?{r
zYfqHua#5^{RaVxKZptWvU-!BqpTGt{j};!%I7c?tRKb)*UZLrWT;v<Q#)tr=&34{&
zxWFPiZJ+iC!hQJPNEtq)OXCfmOsj;yIAuJcGZ{o;J;;_9h(?ZS5h0ZnwK$PM7YlI-
zD8dC&w~bPN4G9fk6W#i(wrR~?*n900(a0gCsJZMwqkHiaKl1oVQ}@?rQ`!IsGcy6M
zV5pVv`&U=ui$?TJB;AokgYCsu@31~(#I(O9#MmaaFK{nZ#g^0)8bG<&%)8jv`Sl!z
zs)yb@l+ff&T938A%h5imjd<0*YI|&A>MFUo`|{H66NbY9lZV&gV9RN~Z-Wqq3Ly9j
zr4CkJr#9bEddIQJ`mcdqh)@(Bl4cDDU%a;>2Z*3&9;9|^J5YO4<!=sYW84&+j{u}^
zM3$&Fn*YwzftgZ_5r3G1{|lA@)c(I=x=B6)OM`~Ef3@Q_Tj$kb9j4u<llV4do!GX>
zv$2v3$8CN8TM?OW8U;VtkM3~j#I?^_vZ@aRxU7S^ZK8UN;p(T|)&v&5IgE!)002tC
z9AP83!A}vpHTQevlX=l!#g!_$cLSttG<Ux)dj&3+t*$L_#ghP<e*K$c&cAzayX7-|
zi*ItuZV`H3{n*y-?+?Ec9G%g8LnKBLUgzQ9Xg*%lILk~{_Ce4&J4%Z9qI$@7Kl?t;
zsyVx(&dA{URk%hzo7}7keo&FxU3HKQDkrV)ZYIJ;kFh(KL6pPR&EluiINaoQz&^x5
z5_#9Y(;*KP;46UVmg*JLUC+Nz)BLvKea7-!ZrE^T*Sv*#S%m^_K5mrit?VZo+cDP{
z%7R3U=hK?dvW2`%vIRZge0g)E3H4k?O0CL!a`41mRb~VE((qhC#ji1TOG1L|7VwM2
za9^A0r_E>k_jQ@xYa+SGe+P(R0+%sq<Uo+nT2abpxJ&>Sb&w$Gh0W;3=8hlfgPN2~
zZ_nw1Ls!_f1dz+u-k-XOU}rxYbRdKj*TkD`^2~UM;nf(9zP^`;ui&Z>IQ}j!Bt-Mk
zKp=PM;0W;uv~wnO#6ZO3g%WxQVBE>&vYO;11+W16E}Iz=iw}r0%PhBJUog}n+HT=s
zj!yaNqy=b0M(QKN)xvf8TGDKKw~lUNk5lp!@b2Pla=yq(f(eJWqmIMs%Wo4En-QH9
zhEGiJh14aF9w%tC@S?@;A{bFA4-N%1%^5(2l-(g%V0kZHHjX6nHno%B%NF_n4!OLw
zXvceFnV9P1Za=4%zWsBKFHP(LDimX}dfxXNxC0Ow{WoZv>7HP=a<P<1HXA543o}%Z
zxHtoM%G{B@RPs*j7AVSuCny!p5~h_rf@s~+l%AG|zMZ9sKkt18HJKI>C;>ljj40d{
z05?1oM(n_GwCTZ@X9e1QW+68CwD4g)FC^1)|Lb~C)s6G>_QO>Z`j2`MtwrYp85ff}
zI5^-M6a}VNbXo8sd^~N_R!yDt(Jx*-^PW1)W%QgSw(Nv_+F>mrR)`v8KsB03WzK<#
zdDp2;ME-gPa)UkJr!Hr#G{*87KtX<S7)6^v<fM}M?8zwJPLRNdk^(Ykz&Y!|xApDk
zWLvhX*LdZUsWR#5*bKG|P1b@GLwb*K8URQ#pV2$CG#X}mHn?&@rG_qqGC5A7<70}u
z0*QG<?}LFYYc%CV=;`8TFJqq>Np&3sW@_e)<06UHV@^bMIn2^=;Twn*z}nXH0@jUs
zqLP%#hRnt%TU)~ip{+xcGe#enLx}U=sM9*Jvu1R`2>*Ruc%|kw!w}2?Wtz~$1q6uF
zf8}^j$mR;&U9+>KFs>!QcHr987RI%eu~W|6QGz8NZX65)+I|>HNof;FAn_D7M6_)b
zsXjo2e6eAD-I>4P;Eo*JGZpxi-BmMw%EE3n>5U|rt(d^%c}rY`Q8jit=d8<32*J$A
zsqU~waLt8yYVmfstJw1_hCN?kX$IJPT7R>f6ZjyM)2z$1(32~6V)%P7>NS(^<<$3V
zWcF@O8cD8KRsP(z<vvg#u7Kx}tF#GA%BCBI;=e(rl#CdYmqqKBDhituWK>8fVbW>1
z@9;R`TB_sS4|{d-OC=zQtR%Mf8g67upMR~Z@*k5f!}#{%rGwQ-_YaaNRUd$!ls}3Z
z)c=Q4Y&E%fj~Es)0r6izv+q+!8PB<N!;0m)!nibpM&>5_OU_hltWCUV6gPy*1o0MK
z5FHb_UV)ei9dm>%A*VFR<v0fB6@!mQcIh7Dge$-TZ)W8<j*B^8V)zUU%awL<X<if4
z_6o*3a*ZoqFMJSL76Nq6oe*HV?a6TW03!QSn@V^3fn?(3(N7{9rxL%SdF}aYJpBcv
zw<eoTH6Xie?f@y-Ii9m~3;lv?FjHbLxsyn~uDu}T!#IzZM}M~l9|ECv=z^(cWdnog
zB%=zbU>QL1K0ZW_XOb+2Hk<#~@%tlQQYzJl=Rmg$>sGjV0rAoH;}K9t72iX+|4%kj
z(pjn$BXHR2gk{j|LIUcj>*#KUZ1;d6N<1FRojS0-QkBgQNu_jz|43e(!h-nW>ek-P
z{d{qhu}A2(@plL3mfMaQaf)1J|Jb~fwQ_H+r7zqQ8*v>|V{>aGv#A-4RD*ya78H%=
z9@gDI5L#k|x9@DPwLgG((l*0%6!O52IVOflMYlB^GJ3h0Bre0yBC>~7PN@`iextG1
z6g=;nk<R>j@(!q}X%<8Ib#Cj0#vyv?X^3x|i_`NHW17aKWd||%>TB&b1Sa<{#`y^;
zWit57-fJMoNV!h^UKA+-=aalv;`I%$8w(%uh*S>!HF!46pYLCo_SyzPgIj#_&zRui
zv}?+pH`6$zGa_nuGzB_V@_9AP3`%!$ks;)W#)aeFOPJ$;gQ~a;zT9oGoD^?lS5Skl
zC`Z(hxJkF?r!^+MAyWqHh1njSpMM=C_p!84S7-v5C0;lP?=2mjkrdM+)t@ebyg5Nh
z`EGs5R|~8!dKJ(rF2woavosS;uLd-xv`KPEJ2$2b%&+T$Dlr6l4wH`&olCf>bl*VL
zbGeg;6}t*W>@M4j8q6h!^g8349bLX8{0PQaM&Fw<fWc4;wFXyV6O9tn%JU=vv6o4B
zL@hP(&FH%7=2&V;{Ta-5W9@c`*H09&>zU^*__vr(NgB{G-pPtHfUy??tIv36>aNLg
zHU(wOHu3!2+5=R}ojH9?Wo977D{yb-^Ll8#`=FVZaxmpSM%9?Q^lKlPMCT~4RU#=4
z8XVI>F~!n^Wa~+D&*dGFuhhzW5DTV{WabkEcC*T56v8}^Ir70?71{8vzw4KRtKhHV
z)B5&h<Q;&e(Z5wzG{gGyryv@UV45^o7P(WgUp-V@QJ#7|<E&ys@iv@tXDAwrCk+Rb
zcv`@qJNv&Um?eD}gcSsqlbo=j`xpAgDh-cQ>iR1PFZC(iesctV;D94g>~e311<@`Q
zX1jtYlxct~)uAZ0)S$5i9Y-$8q4wp9z8y$%n?3-rlX2z2ITRfXc=dm!O5(j-IbLNc
zDP~Wv^IDvXV*U>RmOyF0cCBeFGrNEM4Ep|zGe&*_dzQ}l0EgC?nF{wa01oCXhng+u
zhY4(g$SsSPzYWmlD^D$^Ukh$IkAm1&#b04OgAIXNUOLd`!&;StQV7?WLR}m0i!py)
z^ODd{;@F*c`w+w*-*g%CYaIUO^*_a{VtAL4@C6eCFg7xi!CeyqF)^1B1_3F5jaE%>
z<2Dez=U3=f8CbFW6s4Zpq{*Uf4n^u)w+GgyZFXhJprr14(I4L-hmt?w%?1JD5j7gl
zd-G;UmQna)Sxqx71gT|}t@d{`uKI0;#>@LVmi!8EEY3Xdmv`SkDU~rwYFe{wxj7HD
zTxWmg4?A-htX~vDh`jz`QAnwO@`tWn@G2jC*EFu(;>%Av>n)l;{qgftuw>qw;P`L&
zXM0>)b^C*B>>6D^P$rx3iit{zT<OJM%U|yvmvhdF^EZMEp5H*nsD!sND=SHukO=V+
z)AL8jhyg0Mw`d&~T<6`04`ZKJ1Gw+{kS0VgFQN-Yln{_jjN6UFVH}EojSKkD{UVvN
zBAV;T`yE8*Eblz-Vj{!GVTb&Nymn@oQwdzMI(KR116B0&ejiCsa1!0`LIzpESxq>V
z8PH9b!kznZ75sPLuj}00geEFdS0`i#>&;+qfs&Na`h@95C{1|9CJzX->HPi;kqS}M
z+zu-OSlP|Mz`oXU`ogw<{pf9xiZFQ7_Kg`_*WRoJQ-V;TrjK3VR|9#bL8SsQpWLv+
z)r0Y7Z$nqy$O1@Lge#FKW*D$_&CP8!VHH0I$s{zAn+rl~sJlfYw2JSCw2CSP%lK|=
z*J!Uylqt)5d_IOa-RRTXt_?A^qmM+SKpp=6y(mH#;DfhjO`z9*MVbGyxd@dah0fTS
zc01)TZ&0Al60i#nuJ$fjYW@Jb)MwpR(!8~icJPV$!LR*%Xxz#T&GBaI>55ePRKL~@
z&NS}J+XbLOJ!)3C*&5fz#42n_$SJfHq#20PxxHO`B}vJvi}qSI*7!H4A)!6WS;V2Q
zyPGm&6`^YO!##k1{*9X%z7?GUOH7|dX8~iSE;Oe>g05-MN{SL%B_YDv%&tk*<~od1
zby@CIW|;A@gfRKxC|R)lfI@3=t+k(r<b{d`3l&We0Th)<B4o(}0yw`oV5m9nQImR6
zsFLRoKFWUWh8}a=#HvBoNPI%@4fY{A%tyx4*|!9Re~hPp7K;jppQel1@`Q=yzsIv9
zosbMpI;Fzwjt`H=c5Ttze5Hz76UF9f_|Wb56KT(`KOjYL+QyT1o;Q~@<%-CYZsQ~n
zY|iigpU$Uro?W|6UGBFD6}ZO=3d-SNWS13uZ{nE<$^4d1dHFRUnh`3?DT{DK7Wb}&
z?~CVd^@`koIVD`r_{lUpN+NWape4wvPBEh*1q>>)Mq_Pzw{6jOYioKm69upaV%rB*
z1l2WBAA5@zmuUutaN~CR(1V{v8|ka_y=&uqk}Pkr^l>0N--q!CW9fcOt9>^`Ng=jf
z<hqOFBGJt7`f<VX35GbqkP{4%+s1D3Hjo;{oq>v6<~1njC6Dd=u}4bhea{H}4_%)Y
zmB^tlR-NmM7u%*Dd<m(H*OxKQH4(JRK(j={DgOF}Z1OJ7-0@O&p`GiXF}n@$_~S6P
zwkI8^^(qfRHIY^QdLI7+nw`)2myz%V69O<clM%lY12{7<lfVZme^pIyn?Mk~=U4a$
zQQ7V{OKxf6RH@Xaa(t<p9*DiRQ87e-<M!WohFRl~x>dx1+1c4Qvv1yjm~eQ+B;%7*
zDVAwBS!~aE?`_r-GG-soM2JfuFnJOAVSe`h#+ZrVEaRD&%vUd==F7?V=xUQcb-sxc
zrBo#NMVx4DqG{9Af5ErOt7TbK>o}3th%7QL{xSb_Hk}Vyjg)UJ4<rAoFNOM2CWX<V
zKI=3SN>hD;$BD5rn#PHULRG0gRt2>Xgl0-xi4een=FDk(KwyF}E)nDY`i3ApqO}At
z<_G{p#)QlW;C2P1WNCESA4O~FJHO~!TI3bIi)v9f4ftu<fBtSezdgi1aG|TBE9&YU
z)S_Hegs^>4mf=9LuJT~#^jiDMH+fmKetF2zc6qh%xN=dw3f0@!)hi|p6@UNjem?!2
zTu*OqzueAm@4h6{+3aq1>e@mHmP!i%{Yi!~fF&$T9rO*}A~fah3Dn?#!5nXdJQx*i
z^B8=;aiODie@)JPQ=@dyeBg$!uz$Gl*ot5I_Nj~oF7V8L<15;2>s_-5USzKHA;+Sw
zFiDpeA(EO1(1OK@<0hJKeCug1Z+y6d2EpkOEkt&SyrRf=ZLe^p^q6zpJ8<68@-*qf
zIc5MnaCi50I=lQo+s=ULMr6Mhaw1dBv{Ya?<}x|xe_4{Auj=hnQT9DRNgHB=OqdTc
z_OTK`MMW0`$9Qy3D?fZ3Nb$<ZXo0kEeE<5{lCN(j8hi9oim*l5!3aY}VSRs<5h!nT
zP;1F9LeQeWlV3tR4d>WS@;}GMLXIMTL@`k5*~`+Ebu3E{e4YoKgmNS#gb+hQ5ES{c
z_~emvf4%9Y{9J$x&rePYm&~al8Q%6pMN%-y#lI?A<wdz`{F_r6#jG2K^DqcaU7{>y
z)b&Iizt=EU>p`%6L|%pY#6`P<R;JO0c#&xelds3b_-Bmwl&8gcW%zT@p(lV0JprMW
z#d26ei^?5MiVpgKjgDsWc;wK=-WA65^+ZW&L76=^^n$c~f*Az^W7Q$<-6<?UvPYyn
zbo&$#44GB-2t?Hly&YGVGM8opBz#Tk;Tj`Q_!IGLH0Ai~`~&3f`k<GQ@C6f>>zx7>
z12Zu*moX0lDSwq(S(D?o5q{raF;#vrm0HmRc(0%AjqMyhQud_$5a$6yLJ~6+sSuQR
z<zJt^z(d2$+O<_991Wn+=;Q0=s)q>vsfRLp$m2LHlj5N|zlvydI6iRW$8TOKq1yxD
zenI)=<EziUPSXb!g=JK#hsVQmtH=7`U%}gxxr}z$?SJDq4wQPc+b2mHeAl?jwyo)G
ze|0=(>be=5zB4WN57(~ZelzZL5!`lrl_fd~(sK9j$G^S$>TzN#)%thxkCZPiki!M?
zP^&bN3uHwSsyN{bD7D+CnGU{#^Ml6iRIuVaPuHA7f5myMfOFvYUQQs$I16(nr+o3#
zpT7pt=zlC|x~jd_)?qIXoc$FqZwK5Q2lz1Hg3rUDgEixI;1yXgp3EqugXN*4MczAD
zM2!I&rfqLbb#?Y|ZJF@U4|43yjrPogwf!YhNk>=2n;`2d4ppj{b<@@SVzuzv_LsAq
z2;DK{>!XyDFitY<uOEjx(q71+i1{rX0x}zizJG0-?#L2F23pJQsy|<v)_86<<f_V0
zX;HtQPqu?~Sq|J)$Wx1#A9&}i2n<is6l}cP!{z(VGUrV4OO!?|kJrdS7Myz^D}wsk
zS{Y&ffKbW64cGTq-k>tVg1gW{TQ!H<>iB1p+wI*BPakR?G{f<F_MGrdv-_Jap5cud
z`hROz?^!-}ZA4p=QgIr_@EQ@X579D{;I9W<se{%YMs8g}V%^L--qqGTg`$z?*PwWI
zu%JO!mJ#PqEKy+0ONS}B@#`)H^J%ZtRl&QaZF%B}Pa}2Pdq!8+Z8|uv8Hp1GHaGNV
zZt><S3ofAl(>p3w9NKpIzA)Y#nBH{kW^0N#Kt2@^4m|U&8Ba`W_@}l9b8TgPf7p7R
zILgDMEWC8Prrml29fg^mo`5+?gRbY_rFf80$Lu&()A=n(O0h0L?L|mlM&erKX3$B%
zvP|c|nAujDU=|e_D;jE<BxFgEig~j~l&eODmY1=#0vdlu#02hH6_c1=<IW0iMSCA+
z9peFaBZg$S_2fL+nzPqSFk!Q|?=Rpw9oh)Zqe|QG7;f>ZK^|q9cs`I6wtK3Lyg;c!
zAY7>_(u}8T_l)Y#!Vbd_N6|D5>pMIOk}Rjyy0aydQioAdE|^iQwWOovZ2GLqaACOJ
ze{41K^mKpEeG-=t1kfXHJx`K`1q{h4pM;-$x~a!m7|##%bRGFrj76V1KCo`Qg6u_H
z8H59!ujN(s*TEdosuK{)q(cyN4FoD2je}<7S$H^B;trpCbUaJ;kJAmS=+IBTi^YL+
zHTVF31e*r7Ssppy6XWW`zP7Tkt8G`^_Q#<|VhMk8;?I(_L_e{NixL)LE`l465NzP)
zNA5~=j-uclMy3skmuaYyNyi3j>P>+IV96)%a%*f`J3hhi_GAQJ&-<3=D7?d@@V2%E
z42*jeHJXIS3S=4E#t<oR4%x>XoC?!ad7`rg-{S>gnU}5~&ZZTWNWk%cPT#2n1+@JH
z0+N4XsoY8F<3>_Uaf3Q&UbaRJFUsHxChhuekE{{__}9$)SC|9P)f_uBB9g*svvpQ~
z;89W_qPh#y_i>qDT$ib^smp9;6Ni~ip5RD>qlO3O!*S5>l}&r4qUNNO{qv5@W$U$)
zC`={;^&&mMpFeFqTb_s6tX?x$9Fc~GurGhH>2D7P=<WM+c}!J=5k$bHQAp$m4SWGs
zqTs~1s(<G0*-TLj)cJb3w9;N@3Xz~EJoyGJEI<^UGrx}Gp|R)Ri*c(F)Je2~kvrZw
z)AYyT*T+Sggh`srXp3Z&mSL*aarTE!P<z*p=Bbs=I_NHOenz+ee^1ud<T*7)Uyy&o
zZQE|+umHFFyHx>rE2l66XKh6Z2z-;ayzyIBCtE#lZCOMR&ebBECtz4cQV>vhA0Wyo
zjN-e1Dn1-ByVwo3$(d4%{R&Pm@&u+q;Te<_0Pi00$h*b~vEd(gtttQmz)>10QTx@V
z&Yb;<wPMkb`+s`!Qrugj$%-(aALmPRbTOG&O`=z>2#oE-Dhd;Wg$%Ic_BgOZQ;a7Q
zJ+EKM1P2(rBPm%2?c@O2a(*<e@EB9LyF)lWH^apgGdw<Jbe_in^9cl;N9~sqxB?`9
zhj67pC^&!wmow79{?p)HD|Kf)4Kx%Gaujm!nOfgMv>C#6m=?)>?#v2=4_%~u9%vG}
zzMKw#PU9RsC}=IK@X*2YI3A%C1&Hi0^n;8EYLZk81{%p^r>H(6SRXpKEjb<L(H}$P
z5M$FMr^opI%Qt)&<qMR@J~eX*2WQBC-NJ-8U>E_r!}*h!R2dc%kmeKYd&pamn2G_Z
z;rmNYlqC?3DLP~rI9c}40#zpmio<R+gQzu-OGXFdTzJ8j4z&(r0pBTr;>VNUT`DZg
zBUACua;klAhYH+Dy#)cDra%^x15yOG4uoj1O7xo@+=mmdFX;#^7#*65%LbZ%vE>o1
zBP*9B2enincxZco%)F~Cuad=+FHwQ)@B%Utbyt7JN~Yk!D%|#&6#FRKaU8;FfnhL4
zufe&yztBn?9;6jnPyxbaKT+fWNV!x9<MmaFG=;cd9DKSqZT*^YBPSUJhQIF9kqJo#
zR>m=}n-hJQH8LUF!M@Ge-VH&2X76iX*u{bvNRvAp`|cdN^&k>&fmjm+@fXSy$XI>(
z4n>?q>{#OIv8XIMB`}yEarLB}3UJsag#$9L066UphI)qQC;TLb%^CqT3p53kq#knx
zKx`7o0Q<L1)r|6fcZ$5oe}<u{X|1og!~j6BEV;mNDcjj5U;xAb9_6Ed)sZ5ef*}<r
zaZ>?i)4}PoBIksLt5Uvn===gkcPZCKu`vZW>WOOlD%RqN8JtQ@3cO@_Uz2ja5K5Mf
z`tTv6{wKd>q7p`(gyEpGd_&A;Z-i#AI2q4xh?Iskpt1fLad6fP>>(R5gki_ajRV)5
zMQPCTA(a$?ffC$<IZt_iDhynB`)Bf_N9%;0r>3jtN<q1NthK50E&qh+E1_7oi7m4<
z)X5ZT=*{r!0D&`Zx*J=tc@MdQPw1sGjPpJrp)-(42)`%X2(sIWh*E+nY~sk)QLumQ
zgS9aB0(m+rCdJ@edJ3{tYnn5iqtgO+a1Ge)TpNRzynvT!eiO_UrBf{Fj~IyjR*nPK
zViVS7%hb@FOqWNy0w;fejhXQhbUPAksy*jCb+jD@3|Yt3Uhv+IXIa3|_{Wdmf5Su$
z(vvL@%BHGg{}!<ZJqF)ck<~(n5Ejg1?p|9s19)m2RpTLHxbsQuBDK_k=Dqfl(hK_4
z@f_QL3S$9a1h_w|_q`a|Arlk@JD@lS=?&S4c;$F<FL>rzN~?b!@Jp<L5eJTw>nyW*
z;yA|(c05?z>IEPVtyFHGOlu&D*TRDxs}K8^@B2{-T#_eJi*~2lnB!lpG~=(N<85!G
z@^)hV?w_e3mJ1eIF7>6f%XN^?CWLG(Ey#kONCLFrd}*yul}P&T!`NWqz)A*7`1{q{
zZ(noko44O`gGzr{r4GLPJ3a-EYP9)hnV$-tQj^AM2?m(op}<eg>ae!uxGjhB$FMSH
zA;IsOx5-n(g-cMTAIOi(2ey}5z9j{&*ZE@^*6^t?4$cI075uW89L#;agSZKZ^;_=F
zw@Fm7x(!U$%${X%L`6S3D8D->;+hR61gzAn3gM&%TPA<OMSb~h^z*Jr0{N^1K2ZuP
zQdp@QCxu<^JO12e$CHma{8>n<#Xteznj7-TW}qk{-;WF~lCMrDBP+bg!OZokk<ZGI
z$}xV!jTFXAQid&P)3G0rlJ7wNl`%7nijM-rwr9!Nno8W$RD`A;S0b=QS(j#mnRo7;
zYv3j%HI08}g<sbwo6+e4u>t+LIi5Uv#f>TV>lPy<U7gTV6NP}S7ycEeHQ6{G=FJ?(
zmL)f>1QqG&``gHH9A>y+?zfpMcdvz&Q-3|4n3V6W7l;#AjXX(imWKxW-)qAM&Kj}x
zG?XGVzs@-%I2HORYsI6=cZ`Hw+&0{d!mON-B!C~AXVAsHpq}FvG${cA<Wqvn-XBxL
z(EsOy{{g6awHcR@@C6eBFgKSGUjq~aH90hw@$&*Ie@m0xwh_MTS8P=d<~SOLAi$S=
zvXwZcR9sHQ>(U|40n5ScP~wnNd`MpZ`t%EY%yQ(7YYzj0Ab@UkfBki1)m;RC>aK|H
zGOfeH<ag!yRYbkr;~h8t{r6W&#_eI?elha9`&WPYK1uFW6c$mT?(UDvsqPPV{|Vln
z>}7D>e{Qd}4wQPc+Z&SvKU96`>e@E09eaLf4~J@~+Q!!Wd>osSpQ~XP=fTr%uTm37
zK^pD;d;gDDf4iTymBjH2_m3l=36OyRCe$X4MSwInq0)v0P%4af`y`Enw{5f2Dj2%9
zuB+w|wwWbC-;Q1Bxcy6{OfBsahn{R_OO_tGe_T_x&{DwxzXlnubqC5-MW|v?-A{w<
z23{yN!RKl?aqHWk{`x();xJaPadH)u?fJ6XgPz*PHK?zl=P|Y{-DQxrteP%YjWtXY
z6|g$3`UbaoYlle^CMxkm+Y25LPu;h&#5kPVPS!qKIXN1^`*US=e8Rc!;3*5U*nreJ
ze}q|S&d;Z+#E(E$6N6a0I9sR@yI74dgf>ZC{iz-61GgV|6@D0dN8NESwA|A<D+6sK
z4fko6B!R6*JIH6l$yKtNKVO`K*3E*03wQf0DuVYXP&G;ti3o~isNE419v4M0HnY@d
z9qxd~6{WZWk622xQvn`!6a`h!Z>#3yf4XWwA@K3owP$Wk-(PGe=grS&nQg3PK-=+e
z|I`oe{0$nQ3aTS_HtlK`*<_m6BH@N~5%D2rs9rc55(zd<Pq0Ou7l9pkpl$ro!vlZR
zR=iPAfr$)l3}3=tHmp*aJd923O|7ZwEqjbrXtef&{3hM6m%1vep?=~$ZJYsaf50~U
z+Wk7Xrmr5zb#b>{JFphZw&o!R*Oy%-rgdQJRcR5XfE_D6$&k85Nk21^(YCY+j({7|
zPt&~S*Tac)1_Q==sLo)7v~PHGa7PP$0+6t$E$>xXs0%ZB?>HRy`If45?#J|1Lx=@)
z3Y5UwIuxHYQD{)846sFf@*a&1f6c~gCKJs-*U<9s!GVLGt42l+{7H1}tz>*Xzw)1!
zwyv+f^5DNIagl{8nhqToE{FY>P%BTMIf;*ISIGisNNx?Y7Rl9VRzvUVBbp2PBKV9+
zQ&a+e_o+G%wm^^NAAk{P*Ol~gG?0%`#-960NNh|(($lq(a_<9s5erqUf6g<Soa5`2
zlJ~3;n0SBU-u5Fn>DODDQE?g;*{m5-g^6?QT%t1isxdJbcJH_~+a^8{y5cX$wy{?Q
zQ$=PvvajXi{c7Kv8_dDS<_#k5W)a!rmPQg-<mEcqRtN;cY>6i*l^nuSZZVn+oF(5v
zfOf>_5-02+`1>W3hBz3he`#4;f3{EkeyOBemaVjc2%0QRJ5F;!6kHUh!o6FJqE9{d
zb#55DMjkkhBpBNmoM-ZYz3p-HI5P$OD0_CCq7*o@JS)~(`TdhNS(s$$e9{~1f`{t#
z4;WEl!Z?jrQ9>uHgTm)+d`)1{*#N%;uW*DD#(0atdA-HZ!!J=1e@Touww>cnkHSfy
zDJBR;EI$@(PQolN)_jT1x8DTHXyMy$7Bf9leG=xg`N0;I1OsT~;I<qLQhxp3<0jB1
z6oZgKZ}1rG^&Z4FN1z5zXEevLAG~*Y!UhkPzZ1gH4VI!Zc73GPo=D!dqZkfQz^0C0
zey%WzJezRnY}40vf0&}S0q$?s#>vq>Awm%6CaBJr+MUG{ETP64ol72%#G!)(We-Pr
zCYOVcfhtswjU9-0<;i3U`0h&>pb>SIKLqde`)LhvE*`bC09ky?CLyay^#UA>PF4gP
z!XSq@Zucno6SsZ9f+hznWtIU8M_&i54Udg=3R}1Z%2)bhe`wBbLUV$Qa1!U6jbP=^
zlZ+yXmmwCP9tZ}xJ$WTQRGa>zG!ndYCK_uzzTW=ko^u_>nOYn{l9_3LAZk;~emYmS
zk4^QP+uRDAdkl7aCFhsXX!d=~bT+ADsMU+{Va1<};q*y^V@@81xGEfg8mJb^eT5*<
zVE=N%#|};`f2uk7lxEAM0L_bJ4nCv<@eUJ3p~~Zxdt9B;rfFpbaNcDU#T1PNjG{T$
z0wF02r39>%Oila;`w-lP&0oEtm=kd#gzz;0L^8Bt@53m`+sVo}LL&U`xt3T`+40I8
zHuOg%|Lkl7_B!MGgn<i={|=KO4e26C+i}xFZBHjoe_Vkh7UhjTzk!s`_rhLfT_61l
zWDxXAIpVJ%_CPI+5j{4zfB*wd(Br9@Uy&4pFCP{&F5+o1g-%Ri;ebnapBpgGIF<o}
zcb_UOJh3U{OH)Wq7|qn?;21QIww&m}+BI~Tsfk+j0~n3%4!n%Sp_Aowp&dK!Z;$*t
z_A{%yf69HMFpty=NQYUXD*=2SR1F(~Wa+4BvWF}f7~C_dBN&z95h_x><#X{dUFtIc
zI_gS`Kok-0AIHv0^~cjl4TN#*$$Fq`uKgs7kc@9g?vV4M`xA~D>A)d-;vxlqgOwz-
z2`VNbL$$IP8ec}nM{Jg|WoX?9t0_RCNnS+Yf7A?_vSD8h0c1(39I;XbSC@2BU{EDz
zP9rMBRZ<^J3SUaXCMSd>Dr9y@pWuiZeuv4W4CiUQA_Y6(w;a1}agNw^(}FZ`za*Pt
z<(rRfmG8Sv0|t9nlc}}cb|4H>Gc!pymirHv-=EC(K19b0-A%qoYAGQ2O5%YvzKZP+
ze_vz^N(pAbCX)i3A<BN|*)t3i2!NT8JsULxRgq2fnBHTx3xE5O%ZmK;INHw29^C6~
z8!{n8>z9Pe1Om|HkPB{phXg82)9kqgNg0U4jW);$K;9>QxYV|4e68l~J5t9xex5~x
zalJjdsZ7LGr>3mOgX7nJj;UG=ZLeGxe_~{~85n+Q&yJIl+CAEm_LXe}rk)2eqrp}`
zUgmH|J^B8j8u)vrpi<W*mw--D0em{GDeEwhE!MgT@{8&W`-oo@d`k8Pom{HvDmnK)
zL=vWhA9uJ6jRhO(Wrht|#fNW{JFu>;b8|&eUP45aN<%dx|0C$fP25I@Ccg^#f5)*V
zOpg?VC?@RCe6Xb6kNmWq*Fuu6v*Hi2KcjLfp2O@vH`QcF+_OGf?vvy!T9)UdsTdC}
zD+A9I4(g%Wucq-Y!3<i_htdfF_7YV-R1cQ(M8t|h2lu;NBdfqr$0Z<c&j>(I)i6%y
zYQXA#eupceHT;VMrtBZaUdCR&f0_?}&8o31oXpT``@?ZRqLvPBlY2t`GS_d9&O)Z_
zcm>Y1#0h)?XmSGMl^I++BHs{LVU=q~jEj7AXiK(>qo0WNjr>r0B0BbtKgA<+9h}ad
zA}(HL$t~S)!UsG%rrU|GWu@bTzY^F`+SP5t)g4qCU)@2e{8^&BX}Ni5e`eSQayCqE
zjFqy4;WO5F&$6|vEDh(A`O}|QCrJ=G?~_n=a|k-WSZoeKc`6t3teaFM3A1=v^Gr=1
zyx-+!cAK&#UjS*uf20l)srmfKtq2RLr;?G(8MxWV`MB-;Ffo8Q>ZKQh#Y}_O#S(9o
zyd<f=5;U;K!IMpm&=+47e^WiZ&*`d@TXb&(znF4%K0P41D_WsM6b5{T7|>tPV3BMB
zkbf&LI48-2AM7Hnh$EG}mV}1xBVfSU3ORvaqIyWLX^jh5e(iX<XMrjDLP$b>!ct+2
z7>ibPdy3EV;i(0KHgxqeu35Z7gYE`y`a>o1Lq#{`FF2tgIUP0ye_vz--YK`E%t4sw
z??ax8AocUx8RUEBzyw%>WIAyEnu7qQU03NLL7e15Q&qm_{$nf2l3dQU4QVR#LS+m-
zlF&_CUw<N-k>$k~@T#|}?E@Vkzd=UXyG=CT<QU}T-W&SOYYR-wimPNoF8`2iy=Lku
z=8YvsDHdQ`XbQ9ze?=jA<G8VLYYe@zPG23iBNO0Rp2z=xMff#yX-jbL*+>>fX@14&
zDdJ@6Mm<eyNCW;rQX4}IUsNq+0s5U|@H&adn;^AJ;<2c5JBg1VVqfR*vaqcYK%RIx
zPWZ4jRdq98AIg*%S3ht!xbGfV=7+YM{(%Jtp~d4blKkqSe*+Ra)hselP?2oaGIbVn
z2-cYn&Yb#WbamYD%Q-m+x#P!%hint|OfM!rwA_Qo+Ya2mBJa5T6=%qOr4L4X*7AbL
z{t`N*i`5MrLfJz<2W|w+3EOV4utH(;g&CWkZ<C*u^o?9tGs-%@s^GN{SQQ6y8`21t
za-PLilvt7ce@j=9QUIqK2Upg%qxh1l8+SQb0YF>4(0TNNJ78`3$E%zMnzLDCVivw2
zN2yH)xpK1?qsl1bOrJA*nuw=BBC_~LkW_B>;nx#>HgV8Fl3$fkScy7`IGd$Xj^mEE
z|Kwj`>!2N49GB_%&7#bN0@BSAi-HpoKf*WTg?|@ye;s=EYb#khnlq3~z1qaJ_*B43
zxNeH&uC^bxB4=rPD*2c!_n{f4<bPN~oqsiOkEKva`H7J-5H|YuIB>NKll{(p)l0uS
zOYT~g{TrZ&8U9bk`8;3W;wVX5L~bew(&`_pi&O{?-19+h;|lLjlNbVu_RNU_d^~g%
z^?=gHe_TGSu&Rr|3<=k?4!&jOVoS1%7>I-~_Z;{G{<k)K)z{S{RRf9OV9%jq{;>E5
zrx=2E^EjM(zndqzOyp(pe^PKr1H0}0^oX<ddUG4cWXrPcFr0IRAPMTWd34=tHhiu_
zCs;vZ%S@O<CQNnkx%Y)s{!cV~b*AeA^g%#`BJcbZmd796=Vi&W=UxG299BY3TKnBB
zO8fqwAO8nEEZCBlk?;i*128u>lTmyV0yQ?15kDz^r5f3e<HqrQzhdBrEN5YI*$1!j
zOMGOF4X|<I9U};AKX61!B8DOblG?HUK6Nz@4d;jhJ+Qm_s;;}LrLIEwsjDo!N{k6I
zn_g`WZ$g50yDM(|{No!X^L&`-&t`si`{w<JD7sQ%kcFALy4}vVx-G7L^}gTd$D!=5
zePfJ&r_{~0Z*Am#s`^b?*LhR6r=G|1qNs+dZStD?+f%dQel=X{)H`4MDz-ZGVs-ud
z?cd-0?RG>f()yM7<II;Y5T`a!#_|Q)=Gxa;<ei#o(?T=#iV`8Qw?VY_d6#eCf<40y
zx!{URws}=EcxV~&fTL}9&(LGn9%;w2tIyYesr9~wtA_?AJlZT?ERDRXVQ9|X{&Y9g
zGO?(B3zaFmvcVO@cyQv$c5qMtY%tpUT$V^nppCCgpd!BUwiR|&O+Vz#hUNg7;yIb3
zEKsS2m9(VJ4|hfGcV%7xuX*}{s)-G3WZm?DPW6>agE#|@s3<UD%wzw)PK^f?wsDAm
zw*-v8RD<--M1vD|kf!)84+y;jHpr}BZa?@bH}hWR?q#fO922W%2cRh9>*83`HvYGt
zzyC<%9~pMZV}t=wx&fE-B`gS&6#^>0!ysokf*a(lRhd_QK?rchx1shPs$t)r2JYmI
zFdIANAIG}dR5H|ylx&c*c9Wx8@JK~}UxkE8fH2(}r*v!rZPJnUd0(t?NGE~LMh@XY
zb=iZQ#8K#dY>Kih<PPrazCDzJ#o<_&K9fUdVGtR;q{l&IkuXOp0!8ws;KrtH@U-2j
z<6$@^(rV-)%&6Rw8U^gk9c1b1ZQ~$G$9voq<u*Un!`h8)6r^gTiyRAVP#$4_X1yAk
zZ7z}mM~+k$yqU=`iM7Z#N(XVM7s@p1u!&(we(FnX0*AY<MS;S0wdLUowi=`<LzBFg
zg-mYvi}I3q=V4FiA>{5faDzw(tc#5DZc*};*AbS`*y5eK5-m*<&g2mfMS0{MNMEo~
zm%Ds(UKk1C=^e}DK4%pLvLFRN!-UkxF)tD3!FP88En+b!@h&#etimvM2YkKfCTn9d
ziWh)@W*tdIn0gO;Fl?mNiS|}bId<hB?qUUJvJ@wm@y`Mpe+#1!3^_96OI0{B7d$u_
zELdB#B8BNfVACv!m6Jj|drdi^sYjtEAtG$}l<$7}1X!rA1z4k1+3k6(8k}sRUS8O#
zLj}{=Ntj3xOB2K&JE&^hsz3(2uH2A^F<=hR0^k6%2q9zvNXrw^av(&Hga}rZG>X6^
zC8Ls_hAl91f92jL1urws+au#=h?ar}ODmw^l%1eot|Rb|^-1p2Zr3mYdu0Nv?LueY
z$v!@6AFBVmHQZDPmPW@8xxPYANq+O&&p&*?mi3Hyx=evlx^Q$Kx5%NnQ-e;!QW$2W
zM(BQvyeoKY;fokFcV|HHUC&@vqG@mG_0S?G3EOXwe>pADu|R8Jb>`&Cxl7#tkD+XO
zWapE<u0Qt!xZoAqnm9;J<mdx#XFC$KUn6K50<+c39$QfOJ7+#KGxLMnv-sc3Ga=51
z!+37}89%=$k7ZNzKFKcd2-WthB~D+V60K^VQGuSsuo7xmt#Qhd93#b7eN$kP(cz4^
ztsNPue;~5a6fgN{lz=T~GdJf8bd}=)wI8aw=2lnks-8s!mh`71ldtUt9v4#^dWV*b
z8GshyQO~ebKgK#q0%piu#5(JKSY?4pjk~}*M`Rx{?;xo6;q*g3`1`iKUstabbS4=|
zu+2Bsm<dQg6`~0OcBZLw&Dcr6%{B~mVH6oIf9THzXcg%sgCJ<KOAc!>p&+0Zker)}
zn;NWLvnn;#2BD2-LPI|GIr#u<r)NxmDo_Kpilb$qM$R4_VlTnKli^XKgGrDlt`y}^
zQnvLBKWqX?(WC@}iy2VdC?Khc82}rj3Un=}yspneKn+Pld?7!R>tH{WX3nobD?hnV
zf7&6)@OCTX{6Qjs`K!tGzGc^g@QY|4LEEl9$XeN}Jmi}mOf894y-GD>;~<{y?!WWd
zh#cCYykSdUS14Qv{6;P-YZjMfa^LVo5gl5NTdw*T6Qp4@nT$=HbC`_spQMy3S_=dL
zes>QQ8E^|$GbiUuz682tCoEr?zj=M`f616wCMJD}RN!0&?jQ33b(P790B86dR&zy=
zh%sb=bYT$6r3QyM1{oPl<k&X!#2j&wH+;RSkP0mC<YO21dNs{V!NQJwY8#GNvW4-J
z(<Nxg9@#t|%mv-NlY7Y)32wo$IHi|N5RBo%3&B3-XlM-tr6jG%Jb%F6Lhy;Fe@Ly^
zdY>hdNUR_UlR>;>GYD%Uz^W>H?t^1vqt=L!<AKdnM_?RnAhn@tg6!Q7sKYDaGQ@oC
z0hSkBLl^@U$P+16SYcQOE-s5+5!fX`l#F~8gVAwZEme?*J?29jq}iU&ta?U-sDgk)
z+e>|8WKDiomkdG=-+;T}sjdQ3e+}batAS}4#PJkAJY(I%09^lQgu!1+P!MJi>X~Jz
z_j9=!4IC!Sa@}6C;ZU&-!uMaNif(+5=By$mKJo|%MSUvDC*77-e>T$k28%%vWudcL
z!dr?7pwH=0=mG&oW{_gQ6ubh|<+@x5fKUu<;8LP?Y+I~Y0c_1f8EeNwf1tUmh8xB{
z)=N(Wo^>i!?8p^?J>Ar8Q?fbT55uv)dH){9>ijN1F$Uj;Hacj^;XM!+iS(W*<w9HD
zbZ*l|8V0*+H7$d9Na-=iX}eWyHE2Zq9I^oW>pG%03q)T;$CwNP6m?N$vpNm33qSN9
z455&1QDQh;ion{i2ahNre{YeM59m)KXNPd06Km7<)zEfl26B2ZugHRi1tv~F%^}eX
z^$S&5H`||0=gRC-IWIQloRByTdXgpHd;G-wNjxSgw*wxTk#_-aP%OtC5~8`=i-kE9
z4Ch3AtY>o)sDzaaLZbl8!wV#Ev;EohmE!c}rgJ{WoKr80se8<kf3=<|s+L4=#g4>D
zkVfkNNZ7!9j&;mc>k4M-#qc%?Y<LmgGS+pQQx#03WK!7a?m`Xr3VI$ix-evn9dT)1
z@7k^!_6K1turv<UGMFJ}p(*O@4pmcfw;FnGOd-QH8s;69(-md(I6QNddhVYYzz+&a
zOrSf)Aqd@lesoJ<e{b@J;d0M@-=1pOZkFS$xNxM|Dl2TD)&G*4+qo4h^Nv%hnDd%6
znN=DPdUvYo0*lAs$N$j|CC{O#YR!Lv_cT%TeAd1e9m6ebI${NOjC>U#zyx%O8@@hV
z)TBXfFgn)YEFk6p3li&StTrH+iy+vj4&?+|!ylp<6WTw8e}6hfOXLyZ6qa*zur{8s
z0QS^v|3ujXUs7}wzpAuwk;kg>(dWRPiK}eJPUUul3PDRLpWq1Fov|h~FKwYSk0C0<
zT2-~7`cjrUrw;>%GH;~Gp*FYHsT-Rho6O8>i*qTZnsd^^5vQKhQR$EbKx^Bs=Hpou
z#8L8!hm&l2e+e5OPT2RtyhJAp<MREfb8mCCD`n_3boL-lCcA~jdc3Q^hjx`dAVu*M
z4m}fdqYtxlbDf6#41=3b1_nB#fr%$o;(>fCEezDK<jB2Wman4#dGtC8FnYC&QK;Kq
zbW=qcc(QaUjMM9rg#?|;UIy~m0}=(Z0xVl6lu;s-UGh}4laZFkOMtq^OM#P}!pY^3
z`$axr<p48bE+x||91er;*tgx=o=2PfFk<nO%dllbk=92~3^~8aS>hs{gB=GP_Kvrd
zs)xqiRi^a}gg`~&tY(%tSbl8Chdr0r*8($t0bTA&wxZ{vyutUG_6|}sF)CG07~*V~
z0m?L&tYbPSPY6kbwgyrPjlvvah5_M(D3t;ag4wh7K9P*{m^#k?VUR@LhwBWk&i^V{
zb#h383?h2@>%uMGYWZgbXBj(zgY$KmQcZvir4+1T-nXBB06aciP;2HY0laDXk(*0@
zW))a9zVMYv4ae>HK9n#@zkWc2A;`eizfT511z8knG4Ql9oEPZ*uEb>aOX;KhpzO%f
zZ0U*PAWYNcQpTE=5XOJGCtQV913g0?<>_e6-za2MdZFSUhqq(-X(**GwFfyqbCcfQ
z;7f0?T$sw~Zvd96e)w^*A-3gqQq`D$Zy@i8*rMBjIwue|-L5+u19Xh0>gpx!+*=w?
zx+wQ7$hs^RWb=PNIAM|+Vp$Ho)0j&B41>==&V}&WrGF)*0Xv%ClfL)TrJRk@cLp5r
z`H1s0?B?C><f=jaD*NMXUgLc_hA{CWd~Axf-LwkyQ~-a9HaZIu6VJC|T=9c{br2FY
z`SVM0aSwC>YuC__bE|PruIwJCi0}~#z|PTu->mHjrV?_U<e8VR%j%X*m%&HmGzbDw
zuJ!;V=MQg$raaZ-3-_vahG6m1mndpf5Khr3y9PL=J<8v!lvkhEwuiJj)Y<E)7K30;
zreglILYI`wEi_Y}0Yb{(=RuKw(;gy1B7gh=PlNCI6s1LpS6BB=zoVG9Pu4vp43Fwa
zvwE>l{0|y>5(DVnlbNakPov{eCN^!^Z5~<9Wr7qzGrcUmtVoUg=W0<Zz-R8vTwxh6
zG%r;OWU@caUMmzVx0I7-W+z5}iALwwe<Bq|YT?-O|3={Me;40=%y;4)15|u@3D8zZ
zX4LC0;U+(SiHj{K%Hp~I1-0jNC6|%#1rq}>I5Lw_d=mpPGdY)m4g)HGNw3_-5x(nJ
z3>+Zl03yZi=Bh&g#fbw2N#NM;ChO3T(=)?}%Y=)h_wQ31w-F^PPEJ7}K+|1az1CMN
zpE`u_PaX2`kQx)@QFbWmXCYC$%Yhp|{^^+#J|7tU73c3Cp1t@!jt?pf@-SD2hx2-=
zhtuJW_ubXr2G<>ZV~nSN)XSqEMX~qSvM*d!*~YbF&tvv<Du=RdY{mWa*c99^hojEC
zr=zcuNQYjck8dCT{Opep^RZ&Bzw-RZ`3o0NDhskhl0|_s5#QnU07uGmuXDrLHE`Z2
z3_Z)Vn;ou=tsN5|$FdUUbJx~P9IlQ@ReSW|CWXa&F{wS@@$^rB{ov|vWs|-gyFx}z
zW#@{a?Ve=+=7jG6_wtnqRLn=^b>R6rSHU*#@#TmT%_j{|1d;dsF*9B(f^i>heXHC{
zToE25SwD!*f;7)zmpI6Cd6C~8;VEP9=P(X!e>%V9Q~R>1^Osjawr`8dzuk&Xy5Dr}
z;ywl^JJ@ev1+{a3jo<w6&5O?6+P=gKzi8oF-HU0J7pwVl;Ee>0P6CsHw6zKnf#Dmv
zu0ZOjytm6uRglNA#)-bk02wKqh33emSO)&`{5&(?fF{a=OzFFsC)byk#=@k%WBLlt
z7s90V#b5pOhwnioT6-r3i|e`Dw1_Khyj$0zP~Vp)$0L@1=>Sc*SM%<uQ_nr|P~TRg
zU=4a_k~Xjs4pYKmb72xbCUc=onNfT6?#xiHHTDy!DL(zrp^7Rzu})Kfq8+f6c@`y)
zq*K`sUHLc;?j$_z#ql1<_n{oF(_EP`DF6-^{30hALe;@v%cK0}2yUHtKXmP-vvut{
zIZR=jy#tSbz1xGl$^#7s;;V45H6A7o(qzWL04FwSNbdsbO6`6uP=42C1YQh|9mkRP
z<78lP$nwvkO4w^3fiv;`0Y{KI4_CK`NKn@p(6s^ASHUvNgETYK4Qea47cIym!A8u9
zWy^sAZ7$EH^Hd}Jn6Is#Gv{Pv1lz=i2a!>{Q7kuqLJ{dC4osH*$Ld>D&UU_Rwevz*
z7^JEC_f$59-O}x&l5+riTq4rYfVZ_9N|cxKgajx%j}@~KB;Xg7QF#S&IpzXbwe_v6
zChq`D2yw%{203n>dtZY3RZmQ=T6-c*n*9bYhbjPX3@;{6&+dhhey;$9?Op$T*X)Bu
z%aiGUd1gz$c~uhT%X8aK2H{hE$O2>XX_XIURUtOeJ=JW+#6clVlzxE+w%Ltth6npt
zNt11W_KLCVT!YvfDtK1XO}J>11=_^h8&8jBR4g0y7?hY;d?%0*VI;qgC|ebIEKeMo
zc{aG(K3u2*70$qd*V%g+9R>+NNSH`Yuxi_XIN6bmCz4L?#*Uyl^*l!CfRR!-N}+eo
z=gaNN)7PL+sY*8B{rurFm2IVlqJHF)aA$r<GzJ%2HUTdc9THFylTkF71yL3sKrLg@
zWVP=K!Qz_GKqCiM&8&ZG2NZK0Pp*Voq-W4t`A6)Mf5ZmHMbrS3KNH7>*kci(1`~RJ
z10jn(F#+#Wq6@unpRl#eh*us)W!`sfUAMbF<u7HA5=+3wTU<Ix;c!fteRoePjwEu*
z$kQX>MzRS2<0})baJ7Pgj*P=|>?pY@aFs*PY!H8ywjqCslNuQY-C#ZI`jS-#MtcY#
zd<Xu=faUG?LP@k#dFoxN_K||}9DFZ-oR1>~=z!@T3vgHzq5xxU-yNrj1&0?$m#3c0
z0r^qL0hF@lOSQe6iii#WN<5r-7uUe8E2g5gg7;5M;=Mjk3+~#rzCBac@B#m$_`@XO
zgkL@a^k<FXE-4cHa;yc7qJ_tlAX<1hM#0u~;u>!dYn)^Yx&ZvvWphIR2k$R`yUe>z
zK6Td|V?^Q`KwAy67uO45bY0hW{c|}3BE)u0iH7RZGY6RvMCtfARI)~2R*qH~nCFH*
zr-jERM=>pDWd+m-OXz!dgs#0f=1?qzvfxFh#B2vL>^l(=I5AZ#hzMc8<)3aGNH9^u
zRg12jIN;6uf$u&{G&d9&?SR;SMU>`FlxX};j>0S!lmS7YI|Y65_a6EYd?-W|xN2nB
zhbM^uAO(qXpHu*U360PI>2%C84NahDYCm>vnqp;9P|8L6%O3aOhapmEY>?qtZ48k!
z#3gXWy{k+*40lPD_Fgv_0vn1$u%$_BCV6A#=ROYLejT&b&i1UrG-=j<S?t-K7l6oQ
z1k=HKfWZe2o?PWPe?XSor@+BHe{B36m_YspiGb^Pc9?P8n2Ai=ie^I;FA|;EAh5bh
z4sfL43W*HFPo1z1(j|l+Z;;?Pza(fu5D!+@N5q^<z>8m0w(ocS(zMLx!AVRJI9@vR
z@?uD7QU2JnQ=@T(>w8OoX*+bu-bduEXILN|@r1uudlT(wn9$dJWyr;5%qCe5(KNgP
z2GkLS0==uw+`i0?aR)54O@;~o;F^A}4-g4))OG{*^vt;68+(?2u4qOEZqL>aJACvR
z)JS53i7h~xxUu4H6LMhKAouv8;n6wY3wAK{nhGa5*hhSukvnXE7}<6ZhO+HAW`We`
z9NF1Og_E9yQ!OT!(?A1q=c*h^C*75DD6*P+xJz|lqG-ll+1_3<%zRLhcc2=(VKQ7y
z&tR3x&L;t!$>Jc<(Om|MJK!7pEC~CEXZ}ob3IU*=L;B~ETTm2{qmduD0a|h^J4r*3
zFqH(b4JrI;oZ^0eqD!0(tq*8xt`sOBK~tPcQ#Zi$r{ip{Q|@ZB0xi^YVs~|bw=SqK
z&f2+Vk^~SS{K8{GEUcG$jbQlmOJ?hbV>l|1MwaB9rl$F?&r>IB=-=2RfI<3v(y9``
zS2E`fQW$_}{I{T80|(=*uuuCIO&Jr!$z4wL3LqVabKZr2ZBg4O=RNk05~e|@_2wvh
zxkMa9al8Uul!795&QcKww|bnzp?fJMQJ@mF)FR$3CVX$J6q1OAU2Xsypu@A=ynCDb
zf<Ttes{5r^ggd2Lt#e}+T!POitq$Tm+Ssm_?=cde9oJ^*2vDWc)zS*}G*%opL@C1s
zRSY0Qu@2CGW?PhP?gOWcX4FFL2de<W@COYx{G4`AU_gHstb-{|y$6nFV5_p9&NI+~
zHf1?v;MfHZRe_LCPs}9Y8ag!`o1<<RqMVCT_f`x;8V4#jcaG~y_Ii`*Goh@(sv@q8
zo?J5!$r&25LD&~7uVxoju9sLw!K;Dsavk@+kmToohHA|6Okm@0n4tUnLQT>j%4hpt
z%C1jTs+CS7mxq9y&B`{Lk<S1+-#j;T2^I$HNs!~h*{SBHxHd2i)2s#)K1K}mtxQ{l
zr1N!YnQ|8+-T}v^!gM~D1462kP!a^~&X&C#$?iSa)_d0_gb2;W#}K`3Tr=$Ys}S1x
zTs)$G6etjg$k67a!~@j^qSdz}?oHI2?S`@#E89^F3zVraM_gzAT>=K^ECuV$V8^|c
zD6ng%-ECh<Q*01^VJWH3{e_pAQa~yKI{y*m2|w*^|7lbZhv}+(wC6Pq*t4aQ+cqsk
z2G_FizitZvqFGAWh=*Jh%%s~;3n-aXHnVVl_GjD!72*^Cv<~gj_HzeT-w^*;=*QnF
zZ$iqd@HN%rnyF-3PL!T!F(z>qCH!soj_G4lLcm><ym9a<UmI|Y)UO@Cr8*FgkG;g>
z=~~jjyDBH76x#2E)*Jy*d3#dVRq=ZnMR+ibA)5|V`d^G7%DNt@I{N<z;(s-QP`@&N
zgov_;4PhM3c;V-ZJ`+CVVUT3AaAs)j?wAK*vWk!WEKDS3!1XC+paTqYg0<y@F2xLV
zlF1!mM?N=EA`D%L8QA_qY_ni+P94w~p%v0op<YLGyufw}My7bd=&9m@#4~eKm;=8Q
zVNq0oJ*m}{%QE*I^Ow>ueHk!e6eO{K{@S1+3F2sp8RW#}bc=raD~Ny2f8LOXhg=0F
zq(5zV^EN!3fDCpjFc5rvAg21DC_AkVKRx?9|M|nFUXM9VdI0N!AEws@dws})JV_$r
z3c?i37PyyCtk$av;MDLR9OP6Z%3^XEkzO1sc8YeaDDE>LDa@yHNEK-VqgFdtC>;g)
z61$$;Hn9Ea)03D442ao$MTzL+5=JKSeJQ8nTqGZmuu<S>C*=sp`x~jw!THW8RWQ(8
zUqWUv+{=6oml<y3z(oFlE0?oeAmD-p%I05)??mR8k?;i*mv+no76UOdIg{Z=DSuk)
zkKDEq|L(uy&;p4TI4Pp2*Sen^$8KHJbr4@*193j+R@_^~T4_T{zT5x4^P*O|lUoCY
zVT+F;Ih@CDX1G>YG5k?i+xV)`I@+e?)$aH#rcrx$#f@M7{!9s72!!E`^2eKJKfKPe
zD-}oEc&n~%_VcZ7>Z{*^mxt;!7=OD7wbp@B&o^P3X2ILW?M&NNo#{u%b5&h8L(_Lv
z%l-Y>?YQ3zo1_fRn^5Ix5(l~7{C@M#XRmH1wz4GoM*flVe_TMRGAgg~GL4i@`3}3j
zb4_imsW)Mg=RxJ<+gelAXY6Fb$@ZJ12);BM71XA_hS4$(s;=hgu9r2#V1JIMfjjq2
z+j8p`$pgc*N4P4;12!@|JIG>ZD!W5r9Js&lt?b(IcRazj2<mD8UO`H5>rm-PWqgq@
zxYk$)Vg(^5AY==N^hfRt2ZN0yaQ$d^CbZ_Raf3bcEFOiEa1?8U24RhiAI)&+=@xZ_
zN>;%Q%*l>?QCx9L3>xmBP=Dya*}aIZ*<o-CP*FZtk-wDUTSb+tg>0e8B#*K*18SoB
z6sxo~*J5m_7Om5u!~3tDk>$}g-}=SJ#<`}u3wQnT)OV&E*3MHgw71h5V{LCE(n6@f
zoHC`M0X$`5RyT(R3@MG(Wb54f6lZaT()hB;vY=|(>K3?c4bFnBntyI*nDE8>pI&nd
zq!DGXPI1@od#dcv?8dgT?U_eLXZB+&RD1rO@vMI2PK_#WZpT5+s8-Af_Pe9$LhM%b
ze&(^B_AS9}*cc6WE639ncTd)!G@BN^3dfscb%**%lbrQ~gZIcAnp_bKJc7PJ+q5k?
z+&y>UV%E(mz|bEC<A3)-+n!%UOoz?{3Z=kAhXb~fU=PwBEn7DBX&?3(By?v7F6@v~
ztpbqLWqt2E$Lcef3%7CD!G#>}M$%DA?2$KHW6hdBN8<)WM-V~FBJO!x91$NWgQhbN
zpfp2%Iq(>oke??J_STW@C)<FS#0lgCzlauWJJ@6A=k`t%YkwXcS+O^l9x_TVl(mZt
zhYAneropZ{8gAW=T}_I|4oe<eyd5+ehQPatTz06e>Asit#ZqM-G%);5H^3ujH^2jW
z{sOe2SFG4J*%5oK&ay}qS7DMsxX5|>x7V9e2i{#(@cRWjRJ6^q1c4ybB}ACQ1A!g8
z&>bM$A$%Osw10Wcb{TdO;6eK}5OPSJwr@kcCTSh;>N_~o8i&#u1j_84TSKD|c+i<%
z>cT@#v4EUB@T2{$>stVtKxMx(h;xe<=IE==T%0fu`mPmcC!6pdMsu$EykUqZ%Dn(Z
zMF9Vq9op6og@M;N!Hue+xos%U7s2`Ynh|}1VEhKRDgY>k?~#AqB8T`f@X(Xp!PWt9
zC(^=`<^h5Zp4XbcK%6RzEck#bH6p`u5kb;2iu1%P1r)K#AYOELaQhXJr@(ML1st%?
z9atg*46!X-gNez>ZwB_5Fxjd|<;B7hccZnFQ>QBRq4Q92o&kH~xMt<SyeI`mNDOFj
zwLzHa2x5tX=YN0gng<>^wbcMBJUX60+_*n9J{BVdgqwCG42Su*)$ZMU9{;$eCXTBR
zwRY#b`=&!wfvaZmHh9<Z#D}J<d))pWb)@rH(ESV;03nI&9LVn2Z;g}XH-ro@vF|<Z
zH|T#tUNiY_Jc`6Bwr!k4@!*%m!+Y3upfc=Ir_r7mZk>OO5LANuNvM=`_SoE6IEZ}{
zJdwi@TA)vnFpssAU%}!=JhtgPJq<ruA%F=}C(Ah?1RY~Jd6R6}nWK-2AhjKlMAM~a
zNyeKFfVsjX6zq-dg4+~+kF+@oQYc6U2^uMk5zLsi>`0|W1mtssgZvkyaa{9@e1bK~
ziZLZ{JAi*~wr4pRrLy3l^LKw3c*Yq*EZRd-1RP$ZN}>1@oR0j>{i(WbMVk~TP`r>H
z&GoA#qap!wnuTPSK^=W99i2)1YjFQ4S4^U~R9-FvVkT=h6$VqCAhxqbgP#2mQ=rdQ
z!@6qHC{1T^WFA9SIDyP`N?953pBzjg)mlYqq8@*_OwU>3RK9T5=^Q6@3JF$tEVfWw
zO-8Y}%YrvuMujdX?)Fqj(za9TycQ_sU}nZj1~BfXjFvu34Dgbt#Vi${@6pKBl`5jL
zcyx92-VD!Y9aD!ejGQ-9zUIkh(!q`aQ^nG8tT=JWeCnyQ*l+styZ3KCa+55Ho0zX7
zk;i`~he7Ob459=~X1MlH$14_K`!v^aJ^Fu|#*lBFTC>1T#}j-BY>iH6U%ve*f@{9|
z`083{4oxd_R1eBhj3sUJSs({T-v9XWUs9y-)>zhX=XgmP^j6BgC&9&+&g8=akxj?$
zKTD1;&<b*dBS@6c^P<!o=cEP%Ujp2a%>;i2CZraipyYufgCs&AC5~-mv;Z_JjdYrG
z_LtxT0)%v`_=t1J4O56?xenfw$aRqhzYdh~XhpCOIQDu2iK%2|s~H`N0~{wQeJ)3@
z1L{&zqcpLc<*FzFv)E7j5oKj%30(*Y%!62y9r$$vx8qQRZH7K1gzUw%`)h_=%Ex~n
z)BgJA-OrdwUGsuR6>KXfI||!7jx0pz&rkxdkJZj1ONy9K8oyv<M{XUeN&7;BW#wpH
zk5-6%3M={6p8_KZ1rY5ovBjuZ_~jB6Ikv=?(wOFaKtd^>g{6+am+duw<Y@+M85Hn^
zPguEJZJ7DCKY91VlqW4jo}o??ep-KmYc@57e;7IXR~VMJPSeW}6ZG`-0<Dql>@qdk
zge+t~fC--+V0$J9?0Pw@)~QwPy++*Smsc--di!ee(xRm*6AG>*F@<72DJ$YQ0Gvtr
z#YNQrU4B87cP1Pm<qbP1Ko^m4S%PUuYO*O9c3iCjYu_<8`Sgrrd73aChH8Jauf}$e
z+^p`05dL!PC<}<j`2u!L=SFM7x&a{%y_Idh;|C3_*TKZXo?;1^n++L6&+BzwqM}$m
zs`Fk-`pk7O?Edc;ULg%f^?nAFIv~e=f&bk6<3c*R2~gbtiiE<7dt5&drk*8cJgjD)
zQfQQtOHRZ*MlrWcFtpS>LU(_kE<O_hPgAW43%Hmol@y)0MOPc!o;h@v{*i{~{4u}`
z?Dqf>Gs|+Wg=nuXBsN!U+rMgnKgJXk=qr6Gw+al6jBly;`;?FbN~^|06OKUHc_0hK
z>Mu(nHJ6QSZDbK;Ed_?dt~rgcfmzw?X&|3=2BoMeK|s73fU^lDRK|ai4eF^zNOyMJ
zHT2}J`1IL&$l{!kRlI776_QJ<%cZ#IW*Wvm<R6Bgqyb9&3&M(^DgQ3z5kZ$F=#!q&
zy-IQD-TR1%I9bCMf5BxAU&)0F1OoLfNU+S#6Ud=w2r|RpYe^yr)_{fkgNN3#^av^?
zeHo>BxxDA-3(Dq_zD$3G$EpW?I2a5uV6b<hf9Y0h7tZsjyu4aZx><XxD5G3WDR_U2
zP7(ZJC@>Ec=2h^==mtK_nqjnZa6@ASRfvKmBR?1zdihsdVA?zG6W&*tP9S-LWNN})
z$i~)mQbeju=7nUD0EfOzT{60I3dFHID%7$j{BLJX49U+KtO<XeD85Y*_-@6&RUnX%
z^^a}4YK)M)rP)-?xbyM0Up-wzF1aX~b&}F^v2_C<B}sj^tDOA6!m$^*U|*!)PHJup
z5Ta!v0-!W2Ss>i|a)=9_0%A&>ENxfr55_vPM6}^`OWa0!o6cU&zT#?6FN<mR3}?<h
z#Nxx<@>Ql;)Bt~rkd~71qlHQom*-)veKjV*cD14pRji{TE0(VKSA2y0VfB}$I4ade
zvj%_$pxdVd^EjUda*ZOu-;ub$7OBfFkA5RU?jenAE4K=9sfN-t_eX!7#ijd%p2wPZ
zcjN8!$}Axchefc)LRLM|k{l`0`Gmzi$Jf?8P$AE}*{^@4S4mnxiZ)4UnMSP%H3Knt
z>c*|R6d2ERspl6-ujNTP&7y5mF8rS#0-q*=QJzmSeUh%NJ))>6->Mn2ASv)PJJOFX
zx&NUgzq~JC+tVGZT4pCQQa82c=98=7;su@53vvRxJMKEH$|~Guk<N;xPk${sBzXk3
zI)4^g#cfUiiOUn#`SdMY+4c9ta=z6!MF2!)U2@5;{7*;Fm;{V(*N(sRY%s5vR4G3V
z@KTOem>*pzX=<L`Og~gXi+=#a)7qZJjsG9vKLi(~cbAdy1rq}>I60G1d=mmNH<Pga
zDt}r_ljF7#zVEM?lTEpn2m#_jY)+dvo3g8tRK=6>!S;b8Q4+Hhsp4a2=ijFr4Zbwc
zj3#kvYfE?$XaL<`f87{<m%u-MXOlaVrp(IhZhLx{xYqV?M}>d>^&R))Vi*`NM*ivk
z-5)+Fb;lEC6U*=J_sgm7cXz);e?I2tzJF*pahj$P=N~q)lq&jL*=>ue%Il&TI_k@J
zyRt8vI<Kg{AL=dD%YGxW=xGykEkzP(x%ut>$9I3ZpTtr^+$cYee7*s_+yLhp%kFe0
z8BZncp)M<2@^Y)(FrMMmZV=nVDix84L42J?KkWS{cKHdc%#&>Vg!Xmb#PCyuR(}wR
zNu$Q$W#`9S$jd}FP5F|jVjT1yL^Mg%9}ARKMBVVv^=(-nNc6I!=A5d(CR|oUT<52P
zM)}Y4dPn2RJ}8(-EF9sqD1IN@qh^_w<0zaoG#6(oosRA4e9KI&8*~?^S;n+bcQJ><
zSJc@R=e*7P0(W3|^gs$0SXe8@rGFmh?9QN!?j+)CLSzbx*-|N#j?$RcxvCUOs<$YG
z(&<7e+|)T;%6vmv0vAJ#;~2VdC>+W!xJpq66$;LgXZqFC7Fb-WR5t2_*DX4IWtmXM
zpFXG2kH@Ae$jm3jOC`w(ZT{m+!7OK5n^*N|B^M(pIG0Qr4F%1FG1T{c*?$(>zG(qj
zQYE5obD~pkYB(79?K|ptEc+vs@|u2&(|N=stU6I#iB1@sHgF{;fUGFE6`>QRXM<#+
zjaay5z0_tmaa)`kT$(O$hYFVP=wrPQXE*K3?Om9J34puR4WP(DOG`DIbc+S$!Xr%W
zQvYOXL9Tp<r7X(3kdiCGW`DETHGK^KL$jw~aB7KEQY+Axa*G>0(po1h4_!~|J$O@b
zU2u2Q+U&z%X<4c!9s2N)Z$Ag6NSU03XxiXZpiz7p^I<p#m60>MxWw8Y(XQC%L)H7E
z>zmO0aVjiJgkIm<Rfz?FT&gb>YCWSLvoeBX)AhHQcL*Ed048186@OpKZO|Z7!?MJ@
z4)6(|mitn)9k~9`Y!bjSoxn0|vs`<7;VSC$&l_P7>Rff-Hm8t!f}>(KGxKiz1%>wm
zV6_B3ZkHO0%Y#cSsy&sLbHS}90w{o7-)dL`xL~QBuJk)_?eRJ9k7&Bz1zk_F<|BbA
z%@R{?m{G9ItV~@<6MyAZ*I)^45Ircil|j#@B})=@%c07I$yxR*OebN<f=}GSbO0VD
zT*2QPlF})=D}hbB9n5MAR|6((kRUFI!WJQ4WZI#OL6pHt=iT$RL~`WLAX8E4hdL*K
z4Wn<v#u6L?DknIEY7a^y><ZR!_z6|jAsLT4KV?r}5Ab!}4S!{yKU7|Zz1sqe$sf9=
z8hYP6-Y2PBvevU^=(}>~J@3Ej@++H0AtZRp{%Mn??ts$F0IpYg@96@zWb+CL&WU3c
zo$vDIXuLTZGDn!@*F+`64Pex<sJ8{RlfTSnM1+Byx*j)fo^N}qp7Nf;2pCMtHf@fi
zenJtO0Y)SW6@N46+<@ArlaZf__E1a)&;>2PN&xT)<Q|5e=6@`!ib|7QP%iiMdy6Ps
zKoDZ(6<J<qmJWCL3U^R~j(+pnt2Dr+NyJ(U$`Lc$J}1y5g#Z`cH8oK&KqQLFsz)4=
zJ9^Pk-?bfqi(l}wn@*QMb6Vh~q-1H5uHDqf_Mz<C9Dli*v?d}$L4mO5z}^+M+XAA^
z-FuA1GVgD#S2HXC>+gKAEjmy*Dwo~Z-8n>a-vlu^1$+^9QiuYKvYmGs+G9L^vSz@J
zQ%Z^E(>Rf2ve*?T=3{2Mhd^@0Z{Y>s96Tf;x4xP(V_evqFk3KXpZj%tK_k*Ey_NSZ
zgK496^ndda{WhMGH>q#kO+)>Z*X0>e5z&c`1~f-=7XhwLdbTMz6bwvqhpC*j2AjI!
z><xn48T6t0W7iDH*xJE$`)_6odZ?bLw-{q8zfLn8j()bI|LPw<jng8yJyE4@yg;Li
zd5&!e)n#`a-Nq!60{sBYJr%WgK~D}e2dZ4PQ-2BiIC<p{k9pn49_GDk2;Ptd^H$Sm
zjsn0U?mR<=0%$c;2WNNj0NYsP5rWntfOA;TzYA-rsxdTdojp7f6uE#5nv1q=e2&S1
zFe2E|Z)P%1>h>TudQAeIRDt?Ikc#RGrs@{`#rZ*>h5BvYBT#w;5sEYI3_x7lS0Ha~
zuz!gHPG#nd!X=YHA-`$P%T(A)Mi?8z5_1vV-5=dHZ8l}ms79^EB@3Y17UwG87ANnk
zsc(NJ+|dw^D*Xn3Whv|&k;&N|t_o`Dg`+F7BQL`yA_;a)%!INKLdca#I3gcQAr{$!
z)j>-PPvng_md+Wp7WRY=ou)<wdtnh{nSV|7)yoVmra;3Mb}{NEF7ill=a+MZ%F_!h
zJ1-?tygjV0m>HcD5Ll6#F#aK=X4b2Q1nQet6`7K+fBfnDPrk?bO(>KuM3vU@Pa?0a
zAB_l!zgu7peR1*K(D{~0Mn|2o<wbsqUa>)rg=-%3$?+{#w9)5!L;$Q!yqrgS5P!01
zi=!6<gR<PuMGQfDm2<N@m0L({N0oEsW`8k$V%g8pdEsGv_Ug%FOk0f1YDJ<Qzxq9a
zryCwFD9Bn%C6hDYukp}->T!o+<)_gLyh0{oP-bm)5PJ+DiHllB_<@GrdsE+^hw%~Y
zcFy&_#H<t?h~=x~N@{d?+LQwr>3@s!x&{X7znSxm)C&`LMqbGX!%%I~TczdeTrdXc
z?S_+0<hu=bdBMebU!<9&VJWv^&<L)XF+Hbh8ZbbmqkoSJZjsDD14ewrY?O&+pO5h!
z(ikJ?aIx3r72p#WYD0Yy&?>V~SJ&sKM|a}qDf{I#NSXVgtqFZWMM>J#?tj3vT+Ec$
zhhq0f45Wa{A?iPtUGYAwl^Iisz2!zAq!D^`BOKTuN#x2U#as;qa5*(zAOy55%oJ)q
z2MwizhtoQ!I6PxAk+<t4gtznXe9TeVlu4PcL5?N~a|2BAXK&_u99B=}hYz>KP-+ll
z%wD0Z4pToYo+{S2hwo^M_kW|e21#He7GWJ>Olo>o!QYO49T(coIV7z@vEB<08xW-H
zIV~|>d_3jxUyLug${<XhFre9oPk>1wZvj<612IF-d!GgHq?wXCVI@fIGVykE^sg?W
z|J0(WVjcbej1IA&CnnIRraoZMg|(vIHba{qe5cPRCB#6mfR3Dc+<$dJ2`Dju)fT~O
zbWN7BY3cL84x8En@Q8Q_Ro59YGSxW5XBMoW^obQ8$ogPq>!PS=OvyduUGab71;Jn>
zOPHBe=XWFq=$efP5d)LhMNon@!s{z<+Xm3oypr-ofZ+2h`JSeAs(=MN)L?QNn0R)R
zO~74fp1qQsRxHuxt$)w(S(474hs4ddy+5X^{JdG5@Woq>Rm|8mMn9*4tJUW`Ch3>}
zQ~Td_tR3q3+%|_cKfTU9F<C*R>X}lNhZ@Lx>>~NN>+^p6!w@jdZ4r0Jf^q;7Oz8{;
zJb2WHc;P(sW9rbos;<<ICiJ6xh9HJ1224ef3U@IumALp?c7O8-`hXg{sdYKo*cY(-
zqN1Q0+<e@-RL^+~Q&8mME5vjV-N&%CQ|{ONW{SsRrxEd#4GdmCzL%{d;^!B!zJ1NI
zIq+Okag|-+w`Ljfk5?D6j|41f&IGoHVcb2<?qh$?(eT$%MfW7)Vr>$^^;C2TDkJ1p
zl&pa2896QO&VSX%M|b1jXW=ZAWSI=4|KRMk|JwvCxTw~(EF|q5n^g2LgnjfgJ>fvv
zB?aMkdT_={@wM0v?hi?*i=N?^Goa$)JCsPGA9~+*cCqba?FFF(Ar$-}zYhk-E)ieS
zUnPtl3kr^oC`*h|jd+TlTWkMk0xcyZ{Fmc(%%6fL(|_N>KzUmgdF@;uRFK6FbyalZ
zr%mODIc`5Li!P07{%pJ^d$x~)c-6TGoyR<vTTe*x$~l@h?7_(^l#jxo0NU-$XzS$R
zq`mMJoe2ye!(@~q#=~}>yGH>(;*?K+DFGjP0CFeWv^#2?w8B4M3F+SgE-z%;)Of6i
zVGQ$04i_+RpOiSdH1C%Z-90DJ#Xnp756ki#e3y~%1rq`=IhV1K0u%x=GM7QW11XnU
zz5)t=%pp}~tJE|>09=%l7ul9eid>OgaaEE7r-`0snN4<a(Mb9Ac^kO2IHO5w4h?`H
z@b>q;$5A&C{HdEfx=FPTbCca1&d(xR?e1=P@b{meDcQG&jr+yU?>{{I_9ts^R21e>
zu5LaYmq&dlZ~htla4If?>vnssb)eMC-QE~~8@#RhgRASJaqZaiv!X1kp=z6==J|1K
z4m_`hU7Q7<cYBqXI0_QG`}c=mpS}7pk!9ofiS*;nFBwRd3@DX_*-es}P-(+FbYru>
zbnRVNobl>wmXjpRA`2JrW;cvogG`w`7*3sYJp8z`Nl?_I>rn=20?&3Tkca<@l<E3^
zfhWhd^KZ-Jb{sC_@B$__o>zN!Xq)n(cU;%C-5%+^*$ahxr9)+z%;`v@qoBZJjFPjB
zQZT5xl81COugODZk;lN6CAPxdK1nm+#75t{d(>FbO@|c&pMSgC$7$f;NXHA`z5nqi
z-lW4Qj6<b_Bv3k%9tqKksV=Ls`3BE_GD&a(s%yvNssUzrNYuhF^FOnhT458OF#}F!
zZBu{tBROy4irzHB`f>+L#iU-18^rS6pbfaXI^r)FKqIz{i_AgCPgrC<Kj|+Zs4Q@Y
z3N6ExsQQd~!^f`f9lyou#-&fyz)Odg-Ywl<VV)<!rFMniK3>3xOL+xl|AL2qaPX1=
zrXQ7to`~<$&;-A~e)rohGr<d<4lVEK97+&JZ6i;-al^O)bD)Q=0gewScAVWZi>Cq^
z|5&wS7lQF9@vwa9VL(@`LY=PUy5WgB2~8S%Ppn9oDVUNB&MonQOJ^2v+YPJ{SueV~
z@$6s)^h)B(gGwHeO2Bpx5QhSPQVVma0y+KE;z9R35xt}fBS<HL4iFN@j^u!Mf>n~2
z3iT@+g0Mq`9$eqMGGwQD4aO8}OQgj*!E;#{t3Z~;p;3t!MpM;W5>siYGUYdcT4OML
zAim*~i4DBUvmw{f8gNi`?l2%Dw7I={i6lGLH7}R$V|8%T6@{F3U-1Ti3(nmiicW-)
z=b_Ehl|5Di@}FnKKSn}Qja3iuZ*qtx6aO!(2GURgDdnTv4B}as#>qku+9o0hx?;YH
zuWnARtB7@6K6dSyN33`l9LBB_OX7v4DtQHCrFel4n3x-~2*YpBa!{b5%v@Q;xsWJg
zbn5+xCnZ{@c62jYH7+uLbw=YWX!K*Z<z!03O|$nr@4+=n(1*m(=UY<Cve2eWshLDe
zn1y@Cro`xm!}o7qzkS6+R`?f`W8}c!D-u^K-N!Nb2&C?nG@e(@5tISZzOMSqHl2Bx
zf;9=9w<8M)!wr~}RYpuI5k035m{e-QNNa!0W(cxiM%mJgl6a1P0dVkL%VDJFDMe7b
z;F_rLwv$bFtTkl-oY?e#($rpq$Wmq3qU(pw6=#q^24Ur$589C7VQ^1@Zb$JAmS1dA
z5=Ei$bUYH5({L7Be`?1XEd&@9JiwEJe<q;BQvnYUGtl=I`}(mOirZSYNkHz1Sb1TJ
z=IjZULe!R7q3Nf8dKGN?dh9NH!WDa#(q{OKAbv&@Yv|BD0lp;j)?IU2KwEnuDWT&H
z1^?8OjL}3Acz)yu{dmCeaa!z7XJjI)1OQ?1C*I;dQyghKSzHRB4<(=o$tyc}jqyIo
zIqrZ;BFItwr1F)pY#v5)#`qdEwqdSwzga>(o(=*X9N$@g@Y3MUoMGFp=sxqB2%g4A
zkP=Fc_MYTje>JVL{XyD}bG3wJdllO-`ZBTdo8TAlCT#W)TY>jCyw0|#!8e!^dCYv^
zhAD#Ko^`JF8wBpbxZrJv!oR(3jd7lWgePx#q8$Q!&gZa0Y#VS+wN9a9Up04IjvVI@
zSM?J-87hf?e993BR{>-A%D~Qb46a_epGwF-xSC)@jBC~KP0uR@FF+6<9y`|6Zhb2F
z%N9p~fAk#lpUl#P#xffwu~}P<z&b>{3?;Qdc8w00E*!A;$t5wt2mjWktIlNHI9bFw
zIT2$3T4Ft*mSEM8)ibuBDx{E0#fD%cBHgeftpP%RCFUyt5O8&DXUKfyQ=4{ikATxC
z%m7ZU#4*(@Sim)oQb*}?2o4C)6K0jH5Buh<zpN=2Dpt!NH`kl4^zV~PZFvq9_KC`#
z8k^!U&nKUe^7U1C7g7bPR=$#4)%zx&eC6eAStuotj#|0gOYqwHpcMs1hc=7X(NV`y
zASKa%j#DG95G;XTUwPx0Z4n0I3{@xd32wx51jR8~YOE*@@gtxMA+?Eu?<kMJ>VsTs
z1?DtEn}^vJ+xP}8(=$&6A5AV7uK&QA7uDW6m_fKsjk%IbvXBdh+(hJ(EaZ}Sxxk<=
z&VJ;nknu&z>yno^;YN$%JVB|JA_-0)NYRRaK`3kMs&V1h3)W>TV$%|Js7<~qTQf-i
z)w!yRjwe&9SY4B-Fn<dCibEC0OOzhPf%|lDmqAYFz(OO(0|-Z>k3(6u3RW=nG|rxh
zv!b65VY%59YS6VmOkFFzf_gZe0{I$rTZqs4sZOnDhu%6X%&mD8zvrROCRLQKukIRu
zKq@^GD2!dJAyrFA^n9uAO)Q>3HIikE$YY=w{I2dd;Q%PlW_H8vHlj&7NAj~P8Yv+m
zkVA66!au%vpS+Vb4}MAHOE<?y60N6R&$Ms(aE3=PsiX&Vj}WYyFs#-DDmQtI@-Ufm
z^+Tx&Gf=j26Y4#&32yo!?1(~(RnNkI9l2S!<tMOLFV8o|%x(zy=pi>m$*2F1AEs*Z
zL%fUpa4X|vp_x_tu{~FV*w<s25Y(Mmd(F={Rdl6LfXN=2TNYlh(RUzp1V#RJ=J!$;
zl?!UxpxYYzHGi8i%G%%bWB#VUtbR$a+vUH);iHjZAA|NYY%QRrB)LRx!kWW>e)xRZ
z>>7b*rE~w|0V%{W0Le)T?$hA9rl|MFwmTQwGJ)Z2PuxaN06i95SKyesB?)__Nn-3D
zq})Hi*_#TxmH50mUj#0v!B7lXYPOBk2P%WI++H<P?z!cKI=x)#>VOrtD4D-8fMZkj
zR<*K^vghN0A@tqlg%`e~PP+Af?INpvAKn`2vRghIe;FoPJ>ePLMWqo08x`EiYaMSQ
zgn&*$!3|fiVU|+E3=i$*Med@(yG=Xr>Z!O$r?=rJaKlD(|59{-ja@BGV%!@=i&dQ6
zSHp>)GySmCkGEVVrcfqQ^SFP(RZQswlr#vOnR0lcm6O{GNt}Ea=PWgU7|a^ZNW)&e
zSG|1N9&4e=#0HCzwwu1K;WI(zd^gPRD#lt3zd*JY&sl*Eq55Phdl^usP_n%PmOI|h
zI_vobwq{s8v`F}XUk<j!D~FcjfpLGvYJ*>Z4?WbCvMMzDFG};a;z*wzaVSMbj?&*<
zH)3&}Vk2zqFJuz;9N3J1&IJzhDQ@~`fHm9((OAROuHTF=YvTuU4{qO|TwOo#MNubH
zyr<0=5hGyKmqy+JVT~Lx^4KlPQM6}n4AE-Wj&~=X6#PRMQ!~ThiK1hCQps5atl_Bn
zs}w9s0P>#{k;Ija_3ZzJd^W25SEH_AW8f%JG^=fkGQ@HlcJYjV1Vk%7-H*K_9m6yt
z-q`Hb#wLd>F~NmzZ>#3p{`3%Vil^-0!`kmn^-1E{W_fLGsAi=2!`mOjSAV>E((#;C
za}_4pRXg?{Ra0`i5Tk;QlNqJQhAD$z@pz0L3$O3_p+I>UVf}?zj=r&jmt~sz(J@FF
zUwsRn@VEEByyFso9ha-dLj%^_;!5(ldf0DS{R8!)%0NDo4gcl+FR$Lbd7wAED8uXO
zPhZ|)qQQp#cDl9+eYjfTy1NFVz@FhZpn_rSw{cM%#`%<w4+WT1zuiEAed$vR5BzvH
zSsQ_62rQIUaL^SMeS^io)bNtW*%*J0{L3DUfocv!yZ|?U%eVX($dA@tJ!xd>jJ^Vs
zqeu@Em+%^@G1A~CG=jF4mb5_sEcgxd{_g$jKX?YZUY6P3$SASUhGKcLT-HyIFr5si
z>FirZ0x7$61`+|(Q*YUke8D!U&zmL*M2oaKeb?sce_YohTbT*IM=C$_8>KrIV5#&0
zFJe+*vnSPmNOv7J4vYvO9Y{ZFD~14oP4Wrfaq`Br!A7=;-7HkR>mmg%CG}6Ac}=L4
zxppES9xI8WSSvl2NjyaTnq8*U#f%mWySDpNl5s1Uow|vX&g)`8Tq@7|@iKiUr-Tb@
zw-aD6{yzwCIF&Il{@FFID+mZA!F%TfKKQPHkhK0I5Cz!v;G{}iC|aAT@sHy(rFq;`
zN)8`a&?of&8uVYJVu!t#k?;i*0Wg<P{Q(vNH8huj4g)EFSxb-PND;ozuc#Baq_J^6
z?6mu~AQpi@AhsnA%O2dWtS+-IyX41qH@}{Uj7Y!6wKFuV*aI4ADj$&<?=K?V;t<0>
zameF?Q7X!Hb||kOVz=5oA87E`-+d5F7Xo3pp#1gYhhKf2BnJ^kd7O*G<9T`2<LU5i
z@S96<8*F!f43$!W5D&*t>m>M7)t9!ei^jHNPkY7bR1H<z6gADyV^h++8jdmx-j1P2
zwTy!_J%0E2hY!DfoWx3`{6hJW@-qr(1H0ysW;zl|lM>&4eauwA0v$#09ZCQP(}NIE
zo+J_vhAML>V>;8<V|NRy<~9ytKXkUZ@}YdmO^7Ui(#oH?b?q?(T}#{dE!%8$gIoE<
z_eW_0`!)+P-xp?il&V80R3wtm2(nUJ#A#&GN&3op#RLWYJln>0RY?=?8Je|c`W;ZH
z7xYxiN4w|oY8zY``j5Dl`RfMQvjd-hI)+Ia{KJ;KP&6k$KtVwl7LAk=EFkIwbXgpD
z+lT;vx#W^>$V5<-rM(SR^Gt-_qb&CA1to2}6D_X9j6jym1b^x5$^JbSy0J`kwZnyc
zbL#2tr=s_p&J?gTT&$BgUW+<wtG3!g*mo8OIw&{~&TU<{D9ua%K#ofF(oq@2ZUPKa
z2+y1tfTU*Er!q=mg<bmlGciCZ9Y-fivXF&;oUX}Ba|V9goLl<eA5uYC)U`7RP`p&b
zWpzjea{$k(E=?cp=^C;IPFwwNE1RawKQ$X=VaLgxQiQ{_Y#SG(CJCycr!|a#u4j5%
zTPG_<`r?8#C~mj9a+)K*mTsNy=&Zj0=v)BV=H#iL@VYnNrk}b3`ehK2KJC_d5dQ#w
zL@otjM%Mi)Y$zr3lxkx`$-bAEa7-|QOampR^gc(cN<H5KmUbTZImbuW%;c2dauGYo
zs++F4k=5}~yJNCyz-&$x>0y*l&n*ON6UAbJ;JRw;OV!&w^JoznAw1=bCK;oNS%fr&
ziD4VTFJe1T{!oGU(IlBu!BsW_D4@B2%rU~JKpZeBs%$idi>rgYVLuW+W?5vUUSp1f
zKpp4KH97_fZ(Lk=ERcyvCfQts9Q3{JSwP813b`y2$m7;k>{4b5ae@`<+@iB^!4@T&
z<U+Eb?BJW!h~UrQln(6;Cec{=mL|cIY!bN5R|8N}Z;FA(Vg%S`g<(%4=%Rdo|3O&<
z=~DgE-mAtrpepO<4~Gl-bwFg1G*jp>PL4hKQ|Sfzv0KXuO$)N_FwZ9sc&Gu3hOVr>
zu?hBMNX616`w*a19>peqchxXHFJZ8*V6XsDu+xZ`BvN_mZ}}ypFj{5LhR|mvll;*2
z>|6%EHrZsJhab5tj&QVaNVX7veL^1W6=*oAKm^dMj-3l7T%|N_X;#n=@pi}}g0ISu
zgA$rXEjLk#y@$IiiML?U)2d7E5~ZmTIZu|B?*Nrh5S{M~k_5WK$s5!k>D=iA{2&sN
z;(3o{A|kD)juuq+_;lJuhddIQTv|VYUf@zWB`N)p>&wM9tY|k<#}vwcJc*>rHU=!l
z-uhml@wF1u30zQfY9W|Vwn1Ta2KC9;G6aysH0kWM#fyG8k`{C~^I+X}Lr_ATN<Aqz
zR_)Ej;jM0V4UU*>K9iLayyAfSeOak}djk)ubyn*1URHt<Grm2b?fP9$>PV$4U<1D~
zvvga*Cx)~+=MczM@M=MSKd!rRBL~GmK>5@&i?(4FlPet2qS%Qzi_%!G0|ood7P|#$
zd_YL!0s_K;(pAgESxw$=1cWq^o}WNvJF<Q|29kM{Wa@4!fZUheE%8MY;m)QNkQw%z
zYm$Pd*W$IhBJFr(^%Lk;l2xBG%eks?<XdVQKg|RUnNXa5f`(ClLIdpr1qZ9B#DzOi
zDIzgPn~Ta_n`cW9bA~fBuVql0VCF}gQ&8fpaH}ajQ})VDqJfk8f;2IZCNr#(eaW{j
zB3MR;w``b(1si$~e9%<p8{q55r*Lkzu|A+aIVG9Q0pwqYt|(n~!707Bkl<cuCn}oj
zVzC?2D1e!17SW4;$r(E&FL8b$rYCzY#(H3hs0IJDa3@iwrvQof_$EuFWLB)7Yoy%m
z{IZ5k2!dq&fn$EAF;rl>!?XM=T4^|c;Qyx;s=QQnO(SNv!PK(t;PpmG)OslKIL2+c
z2#}e{gKw<e96z<L9+zOox!)+<!+GZ;!TC<-lSb+MP03Y%9sH=#_u;-1vlvRS`0=_U
zVgN6t-d%TMECu{3f$_TZKzn~D$>Aa~<;nx-d;P-FBlL>jCyCBHX>+bVuv+kHK~t_i
zDD#<Cz6tFsym$J(;^)86(;)=N`2$q$+UMn)!#~Dy-(lt=_+y3ff+IX_JACDcoXo~_
zyNw-qEmvQERCs_i+s{&B;S2%%H#J7bsjD$dl7fD?#u&^Ix3J=mQ6i!^-MlZI0gaie
zjPZ@K@sB^6P?ZT2fV{uqH`HmlY_C`A`cQ*y9j4ew6Yt-yt@+{$pX%Q@iC$^WpP6uH
z^vHy>Yf*MAOtBk_>kkDktMIO{FU~fs+7K8alU<O1gdQPLpGmL;{26Eey9$cQ^|Pv=
z_p|-~74+v+L1ls;pt~y;HIZQj#g&H9VO2qKgDNPFrV1(({_KIPn+i(8tXa6aiEDgF
z|JUlK%Juu}W~kKyvEn4?oG>$L!P1Ocak@dR*!KZIwnD8q^{54-1!@5upcb;|pwhLp
zzYks$VV*{Sr)x9(rx=ERPWu<(yB1KFk?;i*mlFX46$CLcFgTOJ2PuD6O^@3)5WVlO
z(5*5Mam6ovY)@%7NztMx+W1l=InWZ<CL&9&NM)OU-yw(e+FmysEU+4mMl+A|9*3q`
z34b(e%dF;{w4%wn{Y@FX^EN}{uXi^z#uX4)oJ9V#zPWuXWkyTVmMzWJ52vZtefA;$
zd8ZCe&#QuSo>O+WDujQK`8(~L8Mo+lJB`MmoVL!}BLA{tO|EBarg2p;TDNUp)vHhI
zUvJ*5k9Z_w-wE7DK0{su@|rLzMMPdTf>16HIc2LtR_p|8EhAPij#$C|vf?yh1%#I^
zfu6C3lx@s=uRGI27AD*Lac8;}tMeT$&o>Q@uih~&u&B!X(Jz10=>IzcePm_61~^!;
zI;}`+PGs3a<xp|2tf$}#G+q<h(iFFu)!6y;5stC3@J`PWaIX>LFdg<9p<oQqd;qJ?
z^=N+tqY=4r_A0oxA^fT6FK=GoUxQYNvL)UwC?`}>j1G`$kuP>p!|)XsfBg0e4KsGb
z(g(8qGLYqsM3#TIKbBPdt7959_GozQ(COK!jTwyd8;i+<{pd;3>a+EQnkwHcE+xR{
z6!zYAtAge#@CVPqJ7qrW?W}E5hnK_Yj`k`R^Qwm~!iNY3+8cbmwg=<l5t){Fls=ZS
z9LyeG^kC9>lKj4C?r>!ncuPV}DnR%G3Rj@-77PE6b{KynRMd%`Sr1xSeT^W&i4g5I
z?eMY*MEU3APC2wXwKy{^(I3S!9R`gKyPKAwM|*<}z{O&LP>>X-6-WwwJ7v?$sDtzw
z<P432rRQAtVgE%_5-BbkKh63Tb}Gog_d0IZM)w@M-Ysz|sn}YDkEj}x4uTJfhb0cS
zWEwmEkaB;FN5Xmjd7Og2BG=0}1OM8SXr}>>TAwo5<r{4Ny=pj43dWu^<riD+waVh0
z^`6)7@86<jK~G)u&N^<#8aK`H<Iwz=$GAJxLB-AlBTB+*mV~f1u}9r7jXKKOxr4pC
zy@hv!+K_JA@29ay)BK;4c`gVqWhNU+nntFX4%>fiD3r`*oju(AiNpIG1PpIkQy@29
zJA<(YGHQ3LZ2u7c5fAK&jKA4TQOW$#41>3Dba<tBZ)m1B6pA&_h=iek)(^n`*y;3v
z+FG<gE-{6%DHe~z6pk<8q`7ARK){@DczX`0Q!#-W?1a{4Mj2WCgf8g*xVsbKKO;H}
zmhpe`a;35&b<<>002$Rw7i@|yPQvl$!TIpNNE!fLm&bDoFA?%alBTY{6Jd&ej_~|S
zyhs`l;<<ySK^$l2V!1cATX4J=qJ^vA!9Qg@W!`i3()1yLe+cNNv0pkDqyp}g2{i`B
zK3ppXWHE%}=!2j=4&VB#z-oQj9Z@k-RW(^0DoJYAzR;Z%U7Unp>CR=+(1G{5bI0w2
z(inD&*D>X(_&)ru%y9ha=Qr^w4&j5^#&J<K&$QTb_{|_PNg0v#i&~7)#Yy;;y<8>@
z`21x`Qu+S?%w585myz%V69X_ZFqa{h11JGAlW8|Kf6ZD;ZyQGvzVlb~F?(>cUscr|
z7{MlMXt6*71eOD2*Xsi#jU-|z(jckC{`dK+DaI5zGKVuv)(3KGn%{KStLxFjBy61V
z&WlMN*AR@47{E;k*`(}DV8S(-=mM_U#1u^`!9<Lu!X|~J4|<cBMj*sc)+qxSE(KEs
zlOq{&f6inHxF%D4Q~;Yo`fSuMz%T@S@T6l5MzX?`9U_ORqZltf>lk>=x#EHeZZnom
z@DRsm@E&8tN*Iaa40(W(69q+3N#O~Sky05ya^ev|2Z6C9L6#t)u3bQ}at5J8ajK$3
zpj0qrIaWp;=81muE1MWp3`gF?SaeZxCK3loe~<)JeU_q$T)71ylCUa4rQU-mAPAZQ
zvoROt19!1hH4zNupiZya_bO#n(}^1qY?gvoCP=M9$~I#xR?AW`DKT^jwIzbx2!bSz
zIz5IHi%!p&RY*~+M$bSMwYplCtKI9Yu(8vXG6?UAA<Rx5vJ*h$tKArPq56iJAgakT
ze^5z9)Co3bU>&N{3w(r~dX9RDsIi@>GZn>2H0%geafUtAO5zQNsuRheM7;qraP(>s
zH~}Yh69;A(I>icbOD3+r!Z*3#*#ejpT@NF<+6{{3EXoI*or|czSXA6*OpN&IN_a|q
z^+8M|AxEr$=_CflLBSF$=lBxcC!olPe;U=p(GA>6wFGAnQL}i6E=7GGZep^!p2rf|
zvvOBJlrnnxax{Kr-g@<TXI`7}&;S090dug1O#sdxX0vyrZ@#I(i^Y6xUcNNr3nKG~
zzkq9CjSUT%Wjl-oU|PMw)8ikPi>u3KZQh#kkFPGw_)YU+ZT^_}&Byl*ewf@gf1~j~
zut+msuXOW9eSS24-K-W5%d2L!2@7@Xhvs@Z`EK#Symdwm2>DBRhlM6fJgvY~fsZRx
z86WxC$|%t56Zv|BSe(^8bQDO%S#^`6z~lk!FkuYI`h8%lopx=rV=`?2Tw08V8@L(q
zKnvy;3-W0e9Dh5XFEHENO$tzcfA*HGfYJE7#qzpYZl-hZbkQrY8-mz~z>T<V6SjYJ
zVpG<LSnq+meE4Nu=lOm*{~u<ns=GAfpI-lK^YzvJWI9_fzP<rxe_ub$o0VNGZ~vxh
zd14yr;yF)22yK>#jsp{Cn|$hEXhd8upWB?htr_XinlTQrW~uzt-26zme=Q+f!f%PN
zCGux{;E64ta|vWO>$T_*Z$0#btb&vjEZhs2KkWa{#hZnJF}_k2EElucbbk9^r1{_O
znq{NJx0kOj^tx&$%d5L)rS#2WS%*HZ*3JED*GEq0Q_W6d3--5{Y_n!gxIvcmMX{NX
zD>A$;X11D@Rh_6)YzUzrf1i_IH%wkF?%z*m&2?oM#Bg;+i3pcSlOon74FbucI{2d4
z^a&vy`xzgLSQ%5W8izeISTE19dNaL!SWec{#a!8Vb@}};CSqb6v{J<CwI0(ljiN=J
z(8|H(T{D}#xLHn{`StAM#<k|_$%h?ZyV_-PuqA!Sw$$<s0aS~ee^}sza(3owERLx|
zWbXr_;A}yxJ1KpmILxjkz$4`5I4r^^-xA?V|B5TQ4m#NbF;XI`(W5wYbGA!9+*Q|Z
z5%j6N*{g_li=a<B9bX_7NlpV5oDLP7!T<%w&nx&y$=+X%(jtfSF9p)J0w6y$yGPX6
znY5u|>v)shy=Pncf2PepFCCR=wW$usn_SN=Z1D0YGP!Y?Jji8s3(Vf`LoM5Yx^4ra
zgKa>uL!8+IF)~J!d>j~AkYYLjJ!;4l!#Qg7^R!>o(tZ&SP;-|KXAeYaQ^6huCec<l
z4QOT0aOA+@P-E;))7WlYqtd%!B?tecPYo;idVj`-m3;?uf9`?UC2&W54~F_1rlt4f
z*x!}8OSN_k^p|^Q%YNno`<c7!=RP3zWOEMxUu{WCG0UaDwxmljdkoZ5348S_>v3-$
zs2)C4kED+3k#Z2~WP3m(+p`;qrw6}+@B(Lwg02_Ixt=BDN_Pr;ckA{0)z{<k?Q}hx
z{9;iJ-7n@Ze`eFwdpmE|<H_p!rhdI>=2werR8!9vanBzjP_Z2J)seIMZYXlL;{S5~
zx*aB<N%H99g>8btV-%Z<HyJ4=w;y)BxvPccb#t>h9MYTH<>dZ;vOGv2LS1&mQ&8~H
z=8%p9^^8Wa1y0K}&ux>lznsV|l|pu>ZJ%A~vmaQNe?N&9PtFK-RdVizHn&8PoCc_&
zi%ac+G*~d|lmYsBqNCx}N^WV7vkcHmKA&^+7OJ$ojw`;uP$hf`LP?8IG(adm=QbYR
zYI}ERHT`2jCjn6g9i;j4_|isSFFz9L<TUSzt-z@XJ$Op`>Hzhk=wArx{aI7#z?U1W
zu|-gbH$>~4uLTLkXp3*no<E@RdOV{6C+oo{MA`&q@&-BF#**rRvGA!&t7qz81dc}5
z&w_pj1&F;;myz%V69O?Ym$8uo69h6gI5d~RBm-lAVqL6*EjAJSiA@%55~adSr<?ux
zMMTi{xZ%nBf4&e7ZwH9G8Rp+_U);Qn<Bf>IEXu^@_An=PTWmfBKb`VRZ`<uoDHRCy
zdb`s)4&H8s5W$<ROoM;JQj}>Om~{Kc?Z009<90kQmhzc=A?5?d5@0L|rHHj-%%nOL
zN;6}BLTz`kk;saSffXfy6<~n(=}>7SaUV#mRhSszw}pZ?eg;z8od`ajY->S?Bo2xO
zM;-japRK*XL<UXUGa%>TZaDt<7d~sLJUB~ap^zD$_2$FRZ&`7$qr;gFaykn@eVgx5
ze_!yQEqJx5d9lienpRJjym)=BSD7TC%Jjy6ND)e{pU|zx-p$b2@Mg~YHBpk_)c2R}
z_00|OgS>>b?Qim~I9&6jr3qCepUIQQe#p~8pVvf*rx1_cfL%nW;uJJ)!Yq-z_R9hM
zQ|RCu>aH1HqO!G!gQ4yQo`VJMwmVww`TPE4`xAONess;*qEqx+5uD2U$lJ@#ZRG)f
ztoaINDhAJB$iYvJw7Z7gG-+XyS4^ZRyZz90WmD5;9Soi04vuG;z-{3s!3a(oJBLMO
z?+W{s+@xYRIp<|n;vq-=uF9@w$N3z^QD^M~j{&!g6SIjk0q!ZD@)(D`o1w2*=b9+7
z`@!z}(z`LpA(_KZ?~rBSxSp~6$16sEyW~fADIUfUg?B!c&*a==Kf(DmQQ{m_C&IM|
zvXhyks-jTnDUe7GB=6ADWRW9>4>HGh!h;K~KaUQ9K{W}Q1CJawa5kE~xtwi{)1DW|
zAz|D%busLF3?D?nQ9_5J$=S1o9}`<3*IXMi4Kq~X!ryH5w|#RyH}%fnH^N$f_$E-i
zU_@9GR>xr~QcpF!wyS`kY%*{jAe%%_+0|q3X6P$1?3(Bp!ytq?VLZz>`(wGgE9)Cn
z(K)YgP&;LPXl^D2Jcw}#$OOLeJf1!F1D==O1$ixw1hAcrex<GxRNk{=o$`(|&>qv>
zDX))|I4~u_05PXW_&xr!w&oRomxN#@UR^_^gXDEVMpgzArR0#Rl0^~&EVZ8WcH^#@
zZ-3mT3PYgE45ZP@<{fbgUydHkWEe#ePT6r0^e#sy|HdCmP*g+ANJJPkg&emhfeNEA
z;`P<-BJNL&3ES1U9b(W#0n!Qy9xeTv?va?$!w-Yxa029XxZRmd2Jcyaw2l|(0t+u9
zq4JPptS)$7H(Qy2jVSU@n2LuJoyfPIAzfMT-4w31V~kUn^`C%J4TUWhval#6qCjNL
ztIACvKD(&$jUjLYIJUq@kpy5r{mNr`zEsx7o*W~4#|u3<CC-M<Z|WN!?*@{$vi#|U
z#C(8Oh|}Ow4V^!`W)-i0SYh>Sm89-$l_bHXwO`9-=ui~=F3N&Y>ZS)1L3SGbH}SV8
zoof%_=e)2y>l;S6r}Clw!qEGY90}m0L<B9AxWf7am1de%3gfy;VF7O;O<dHk9hirM
zy?<iAGfBopCg0R_5$F>I2|MvI8FaLEpP{ZwAguaya4jj^oH&GkT>U+PxkMYQnOTAM
z7UROuV!?H8T8sVw*Qi9kjo`Ef<Ap0U$c=a8L;xb+GEp#GjxE^>frqv^^UV1e%mm{x
z{(M35K$Y5TA)>2?3$;7xd)3(INW|!CCZ$rVKQ+Vg#NYSs(&D_em~Jc@6hF(l>uv5n
zSOP8<OoF8<#J{0`b(nB*&KUGBFsZ19T$q}%8i(EbI+L*Ty(0=_`i>_g<-@3OZb-w$
zP+2Z}AdDz9jwaetWuOMM2F_Xtaa6R*I2onHg)vwq3`v8oZ!T;+^m@eU1_C75L=k%k
zWZmNi!2ojo<%)DnVM&iGuB3PPtvhh&km$+{bk|-hJOT%Q(wSDX1<3=QO%rO(U}FDd
zmTg<w+9{O~QBt(Nmcf_OZ^NjMW7%~BW`g-)Re3Jm9mQ0u&EzGpI(f;80F%6s%SNxq
z4|Hvr`Q(8R#l!y?&dSWDvv3YFRd`3~<J92F{gPbKxNis}sC#I9KRoOtR0fekCL0B{
zu!`cR>T!pEy_=!0)#F!0moE>agmLic*T!8P=}HOcAvh{U?xdNQPkn`YP<~1}eWOGI
z=ue5^v3E1{6)~=f&f8THhnb08FjTzsThn78i;WN6am@LeAZ`gte7gSj&z=EPWzfR;
z0<Lw(eO2##6KS;ezeCw_j)0_wuBX$nEQzu5l8FO<PQ@9~u9*UbX?wR42VId$m6?fs
zX{8eB?h(Ka9N+Ond-@$O4Hq6M(ZZ^POhVfgh%@*O2QesD0|sRH9n-)#XC0L8oEb}5
zm_6X4fXF7a>%{5IlTV7~x+$AoyVqF$tF^qSpu9C>LvyfsKX3vw*l=+k&^q$Xm%v=1
z+pcGSXxHbQ%V5FjgcrE$8}pIod<4Ti8ZYnoW41+5<%=;p0jWNe$GXIm_8gvipQMS|
zg=jTa5K6f80V7lrZ8L@Nf}sbh-uCngf*A*2FiP)Uh`?cmf+c+AMd5d%@8amJ0y8-M
zulR(f9@D-|(@>|{Yn8Phiq(cP3uT&I>E9iH-0=v`(v5wx5*c#D>QG6TBx2#i5Pc_H
z=mu=<aydj6u6Wwc)toL$B35C0yLW8~r%0TE&gj{LH3ju7NUf3d$@M^^FW?8cGWdf_
z@kn;GFRgRQk8m#el@I3N4v*(L<2o8Fe4*X{4a~iwaR{}M9?QEQoF2O$)>LkQS}MnX
zQm}Q^4LL>S${=rlIGw6;0G)GeV1xf`#aOAF%gRD=P+Q7_iShT;s|a@26ycb@1KpQZ
z<-?~4mArCj@ZLMPRo~njE7u)sGMgwg%3L{_eCDeKH|%idFtlU8D<Tu>7y_cyVWQR4
zw)>amk7(bqY0v%Z@^d@!t0nd0V{b`+2}q?EE+7q+I}#o00RGD$@?B|W1&lN^kHfp4
zw^d0YTT(Kr9j#EAj4>Lw*g0BQ{c`z@t8a$mK;A8}J&wfu+$8vY-#5-W?TC|M;rVLK
zow*OvydOv3BYy8q3<dgH`o}agNkoK5BHZoX91w^SObx!~R|Z!NCn*=62zG^km?K4T
zvAN8)H4g8QQoG<%+jjL!R8W-8+B^L6`JIY01k7R&1MpR<JyR8lUII07*}v>~Eq6Fg
zg?<zH$3p~BRj*9&-s#2daE9o)0;E2epR8%S2u*A}>D9Uvx<i@rje~pc{7EhIH$F4C
z-#b>#g$rZvGS&yMi{8=I_-25Ac=GXPa&mh4nA0co0tBFw%lg+RdF2VX=3buU<P!|{
z7YXVo!w}s1``#g|h#m@fn`HmScT;z(F`ds|J68M4$JI4@H>w9yxxY?I`x`sc8@D~m
zcQ^RcQdRh$@g{UE1bG<+q5jX_F+ljA6tKh_-^RadhYU*>940$tPG{Lu!VcMJhs?78
zvn2}va8}4h7M2vTc;uPWZ#KRO!j!KSXU(>lPIxyuEv(QR;iJZwB!>&GXUZZDNPWb?
z=>5sk`_-&^wcT>-WGFShjsG94rBT9{k?;i*12Hi<myw_Y6SsXY16TnBz#Q%Qx7jcQ
zO9=$;K##$fk?;i*12Hl-myw_Y6Sq-11Cj%OaB9y7Rx)>>MPd+mI+M%<7_=ASbqk!g
zhy};ta0K7gN$3onY5LlrO8PbXK^mlB)iI3#DT%V-5i#Xhn~sUw(hNt$4D3K)K_tQ^
zA`$*_3WBYBQg+XsR(3;jM+?xzX>Y5}tz+#4iMCh4^u^Y_ts2uk*!U+5%lOykmya8N
zDK846CqhG-Wm9O_@7u<$tN!5TZ2)&bh`%#*ZCwMLuU&)yLPVB+hUnU@4TR&}>OSE*
zO>iV>i*JL8juZrw9JTzR=MhplAvzA4x@Phs3mkK=AcWWp;cTHdgmH9#O1i-L*@%=R
zNHW3D*CNVc7eF!rS3AOD4|Xc(3v66*Qib^kf9)I^1>UkaKh^_FN2ftLC>5{Y9XJ+8
z)dir~peimD#^KC`us3rdBt%Zt^FZ16_SBgB;1Di}L;a3IE;ZX@mzO+TR2@J^+f}8A
zXtz9Ypu}>_6_Etc>Rt}59IitM1Sap=UfLW}>Y+N26re1OBR)$5m~G?l$EyhQgUXCq
ze|$*M1?=2zudx70M&9u#!Rb*@;8vLM=mqWEUxbXR=?Ac*-2_?&=b)v={DbT%2b%0}
z4}=s*5V~Galqv?84jzG<$9sDwTyvU)Y=+bK7G-`UUtVzs0jVF+L$l1*JkSbI87iVe
z0lILOrZ8Q>y?seH1+uTI-!lol1b+`5e}(ps6@eL2xYB{furtHzB@U9<i%w99G0uGo
zY!&3|VWbxrfwe;FjS<{tXOv4|feCKh^L@e|gmnWdM<s`V?xraJb2NhtPIt*(2p~c^
zaCd}=##1z^h<VYA*sqWh!$JcOk+ZCbJNKHYV4JQwq`57d@<T7R#RvlZ@h}!%e^QUM
zQcyR5vcEOeCkerzL>Sulm!05|BqN027(r?A%p_yR{z#Hxxz67LGD$IBx2#T#5eT(3
zC}}n}#a;1A5v;PCi}t9n1MtM^x~7C)bS64JO-`UrQ)eZr&cHPBGtY0ipE&=i&_|LJ
z9g4)W<Rs$c<egxYP9o>m@~(m+f8~LDug`t$iA-gh!Me`E5f4Hsldwf`27WuZC>2=(
zI#cRLbum!(=B~<@GsZ+8JLUkDj+OZrRR%<sUxqPUrn=k7og%TVh4<^l^^sdHOAK6I
zU=wQz4Vq$s(3m7}U(OgS#xS7Ntzq;68sD_X=2MiP%|=b3YsDD{eiXtZf3x^+Wg07_
zXU=5`ov$E-4f7+;V~Dt3(DW=0CK3mkK92V`yvVhhLCPqEER>J40fwjsqox&bd#vgL
zWL!p-n;r8e;1PutkXV?CQ6GtO|ABQw0S1U?xQkO}*cjXGCK#Ez;do$bpLf+^ko82n
zB<@&?<fa{XbaF<VH%0N)fBfTuTZ#5<fZm%1u%xi5o!A+5TkNX_@1}tiqMt`|gr6KW
z@Zkzd`^D_Ud9aBdK0VwXDF|Lp>DZ6M*vI!u{Gm{sP$=%1V)%zofQSf5t#Vw(MgU7X
zWq!1dgPR%ot>1>RlDyBKr<zQ_JzUEqj<@L3Q@jQG6mKtTdy2u!e|&c4$nzMy@Lppl
zNia?viHj7B=ULb&7f#;IynHPLYYxFFhTzK<`1e(+QLmw|tj7SveH3kn_=G%s)$_Pv
z!bdVYf?vol%pKWbOxY%=!Et$z%?-U9u|O7Al;GnB+BT9GSC__TKE#x52WjL*6V%mh
zXDE~e%gOle94ffge<hDCK_Up~0f*u^4CY3NQ*>^tf=T!m{ejU3IBif5EYLy&_CTiL
zq?^QaCE7b+d#}Jh&-LTk{-HDOpWobLe$F|3xI<wIwpkO5Q4ba=*eFd-ml4=4!opxV
z<os|0!9J4n`SJ21AOSYA=T_TLeD>{AIgk+h&VgMV1vh<Se?riC43+2aS83>!;tJr-
z13gDlk2W&%5bl(wuWAw3PWe&SRYg(C1W`OTo3bn@bcG5M{+8Y3UL4=<Zes1%43JM5
zo7@}vo&ndY{ABXMmbI416&x26%Mr;gibwEHE=G{X_IZ%nJ(aRS3T0ijM}G;jNWc+^
z0dsZb-c(pSe<5vNV`HDOiv<g*#Q=g0$!l<MeC1`j03?p!cFc5(nFF(d*|hGFaD(nB
zAAZJ&2F5_Y<&eEnMP-mxPp`jU=Vb%&rgl5Y3RmCtl^=sbgZZn-T7Bkw>GX8+HJ7h0
z0C~k<i`>36UA}Yer;zn;2>2kZ(%I{@vc+2BCDF;#e+gwd5u|~ps_E87HYJS4tTYN&
zVnY;;b4NW>&*~JK1|ffF_p>?V(3G|L_H79GFgo^BMp!~^;rYI2($?;-DeqS<HF=Aq
z2R&tF-ATaOx3-#*LQZlFxW(NTH(JY8K}r8p@up%hLh#($ZQ_2UbQ7lY$}Ro;$_;&o
z0KmrFf31D!kav>vLM=Qm)WQHN{^)sUwaky7^+e=jRazwS&Z@MStF+(xBb7x^mbI9v
z0yKBy+f9OxED-0Uii0d!S_t2y*Mwi%=yxZB7?Yk+)BPy9v(<O%sB8Wm!3#S(BiS@p
z7l6su^GlmcOJgNnPv#%D*Wg2gu3$s6?^5{0fAg|!#o%927ppFp)Po;YwrzXy14$ft
zQ92?CZ#ki=O&+nc)Qj<}|01cBOGrL-_KZ^PtJ-unJV}5)`_!ZX2*deH_Mxgv-1FLd
zbK(U_@cd7vL)i}(M1{VGt>vfEKxJO0PhujO+aJvhtw0i&$=pDcyd~l9kJ#vUZ8zjc
zR1P$;{qF>8cj9ChhGr`@s<`m_x5yNLV%qa)b29S$Guoqu4l?lM=oycD>xKk$Mz~(J
zWg2)<7@wL_cDDAp+K1q!KGU3+#l?DIPK2`m0?*+XNtcoE1rq`>GncVV0TTo=IW;(!
zvFHIQmwZM8uYVE*%i;ti6Tym|j#Z{vFc`|>a<k2gH2P(;Rgq~oSsFcpIAtE)PIm*h
zj%Jgo=o9|4G6o;$*p|EhOqBj?YZU(JWx#EzGA^==x4b!8zK28CG#wuP0XKFV6}5Lb
zq9Zp9lO34Lv^6(QA|6b5WJ)(4Z7*yfU|NEJFe=M~fPdH_0ii1bzGMjty_9eVH<pu>
zNnWs&z+SE$Mx}89lw^4pIKFE^{DV1llU&%%yH}*$zrA_){tc3JbeP)x=(^V5=)mNq
zoY3v<r%j$m=5%Iy&E$P|IyZK-&11NJIIkV?)DN5G0<Yfx@RoVVl<4}iSmlaEru$5H
z8SsI~$bX8R^cucZ7CpG}h?F!sg{#JKwgjXPsD_U)buz=z)-jkeu>I8X=-Kq6+fR+@
zWx?9YIojH`duL^p2bA0PmV0eC@;3Xf@9lnsL#{}E?z^+OGb3F|3YM|&yJ6t=siR%$
zsj))2okni7-o|K7Z&6~cqMu}#^^jiLOPXC?IDhm}Ruw(;aB??}%%vB%ggm1=!S+kh
zS#pwqZ4)sdP5ovgi#G3@diA9$O5-F+xXDg%F`8Yo1gtTnfPK~GWJ#dWG&~`=5->Q~
zVkD~tLf5-H*D|XLcW9fn+ZTx)`e>R4f5O{L%IF48j`uT+V7LQw@VQ9Gq=u0jOEqHO
z2!Gu)4cZLgBAe(^b?L0SWXE2IB*$m9J)I$4*nyRPcUU{iF|1o@Fe7qGg_e!|g~hT7
zqsQXcnmtZCG8=&p54eH9?Q&Um&~6m=eb)|d7)3kGZ~PA4*6@6QzIZ-{o?;0-S)t>6
zmwN1Z`3b-eC0{|Qt>^vH^$`ol^$m0q)_*>9{oZ=u%#+~}L_aA;=Q!p8CjJq|)hbfv
zDz2)^FL|(LoO(N>HF-q&>u4RXq4hRRG=Q*%!xeE}mEQu`e`cG6<ALYW2@@p{01W|E
zvSbt_NziP~EnxtRyAv4i?8`M%VKHt1>fKqM#&;vj(hVAq6F?B3h1Ph4hyi*Tcz+t0
zE0Mt<wyO|Gx74*_Mg!gbHq8?dUBDXJ)4*N|O*q<dizgu91%hiqFjI2}x5IDaT5Ec4
z57649VvgvIMIlxixV9s?IunMGTV}tXPB>}W;5Ce5mQTeGn^W{YusQ9gTelaxq@}S1
zQD6e=URsDb2fw`b2}JL61X*&<0e^ac6ETO~(j3yfj8m0)d-xOTrhU$Y(=yh1>3P{p
zKf5ucAUgUqtZh<MaOU)Kk2Qx=ka*1N|9fqzJTB9~p`Z1&Bu=uxw(d1LQL(Ca|BKiB
z5~7?g6Y=B?WrBp7x~RbB&>gTfcFabAj|6dT?uZ5VWRsxBJkgOI&g^)52Y*_VT^^1U
zI%tj=kFCMb$|E7J;2_2TQF_;iU&d?3_rbL_1N6YU8>TZHA_&ALM2U%!q;htC=zN@9
zfB$%aR(k`-=Ec~W0Td@6B#??>rE9l~L%YV?52QQmijuo$J?*|Z9o3K&Tn0v+=Fmo8
z#j#;>qp*q6phZdpwv!pi>wn;IqzD)~7}szM10gd7bHKgOD?-|Vu0KG4C{-DKIJ(C2
zlwovDvknP9_<=F#T>;4zd?5i2!Bpo3q&939KtF?oWC=hffiPKa8g8t}!knOMwlPow
zof&8zGI1iML`al-0utTR^-4B}n0<E?b$2H*0G#Mc79Zx|Xy_tdAb;zTZxUmpS^(x6
z!87~7jrkbme5L<iQ+Yp~mzJ+3T_ekfPGcwr+*2Sy0%NTXC)Up?USkRJ`um@m$Djw)
z-2Rb?%ft}Lvy<V_v1`_||J%O1r+ID6)$<!#4sOeShO}y6U5g9v7@NEv2#V-pMG<$s
zlo44-ptH;;*A#vlYkvm&6_;Lqd$|bf*PNz8&|F@h$P@GcjCWY#G!krPyAiOd&FE#k
zEc3UiiVOI!<6T-VD*YW-`mgYE-v0oqkxJ2xgKZAdmI{`OeM&KZy{?z1gx8^(DJ73f
zpt2*APBNeV4cGM00Z?5tgFG=LA>|W>U^p-m7V*rfS7h(YzJGm~IC9)T_Jy5656Wst
zW_rgZdJ>d8tXUi0u+Ej31h!nuUoaMmeAs?)O--;R6&li7L{iM7=urb)WWi3cC7_OC
z)P*mH3`?JT;XOJZNU$ria_4C3B~!^v$(&;2*kH%iFvuBjcP3;mlus71i7t-chu)2W
z7&2Mx@XkfTl79oiIxd5-eKPkOAL!+<T|bQ5Jqr#rfbQvZ_OMI@{_=7d^r0I35^=rp
zV6~){b!C-A^6rDWbqyvJLgv~^xVxT3tLasuqLbp_7(~Y2U2mxvh3RMGTG<X|L(*l<
zf)olG$Rf`cOl1x(&4@r*b|tp-OjZmL%%?3%$CcKXuYXY=7^BKEyzcDi$tK(F0^A|Z
zmnW{a%x?I@9s~@-$XA3!un;B^oRnp_Dh7QRnC~5jM^p~Ateo+2!_^2=_mqaiwB8DY
zZ^K!Zu7z9$<P|+e$E;X{dhB$F?|HV1{yMA{sVXUAJty$L`JEZ+L%N1fTE|Hdl44XN
zu3tl{fq$w(5zcTn%Vi+$d|;|vF;LR$RS9$zmzDMlV|I@+_<DRh0GJO4C%}SrU7VKs
z!l1(({I`{fT+AV^f0xFY&f}u|?%9OD1R3(`;&4^|6iAT7k3G;3^YxB0C!#b;hbJ!j
zND;+GoK>1&4F{kCY#hB}(b}dJMT<Nan(i&;%zvSZzYI~yN_eU+!qZ!M`84hP;+*>D
z=jjYFy#A`d^x<e*PVS84ixhp3aB)l;Iq-nT{d^9`NNzgZ^CD9%mK=E$JcD{i)5}f_
z^+E2ZyEu`MJqoI;6`X*IxDW3~85Bb9WazyCYa)kPsnBl$$Gj6K<g9qe$MFa>bS~KM
zCx3bH0(j$s92jM9?i@XpObeI6!j~x$0kcv?KRc}5kczdGgyX%XXW5cb_)9p)6f!))
zWfYZr)6!8e74P^9P(`UJjx&W(jPicr6%5JQZZXfNq_k%m-47mEfjPmRbOEvnV;Qu-
zynZX&ghCbRHEyz^1=+IVR~&j$1&qggK!3AHusV{v2NpAp-O1;65(<z`R|(%5fAxUG
zr$9~Yr)Gq%EVGF1I1{TR&ex~5rqs0x??^CQJ6wfU@IFl`%bFP>(kOj5^(5FeWA=%R
zGAk+p3~ZR;o?9QeWW**~G}(}f{*EOq#SoxV!V2Fx8bJzV0<MQw0H`CZY`L-#M}MG+
zl0({Ter&r~#kMPE<>5x&k~%5DeeVBcu}ljK6gzJDyOFO4v<T=c3e08X#mWpa;2)sc
z%ObzA{xRT|gY4pgU@kIzbp5YkACOjNRTPu9T6q&HI9(@T9t6rc7!)(qAkmxcyi^gT
zOa2_+?HJfEaB;YtUo6Z%7qfph)PM7Xb6$!PpfNH+blhWj^mP29%-{noHuSxNhr|b3
z>T=3FkUpIgM1?krN?1@tA2vH3$p*t^9gISC<C@#dx0#9`rz-p$llWg~68eR*<R63t
zi7DjX$xkk%E@a~_R5aWdKuXo@K`Fv|BR|ey#Yj6(z0Bk%vq5H!GEP+#Re#6{mYcn7
z%TE$8{^dgqAFpvI7hX)zdHHwB#Gjjdwvx9G$~=?k)D036<{G|~v=|!)vkxJ|NXs19
z$T;4VA>Pc_3mv@H>&u|DqLC90P2MR@GjySN@4_Q<&!hM*9d;n@=BYc*&j_*q3I0FT
zT~wzEWo~41baG{3Z3<;>WS5`t1qA{zGm{a&6qhkl1KNLqus8^TG9fH0k|2r`CJeUX
zAPP5rnknyFz3s+RqiY~0PrY6@y0V%V+w->3NZR#NffrF8WO2*~{&3JOz9sh_@m;#D
zyWTS3X`^ya_nKFHx@q^k91hy_Jbi2IiD%{r)EwbJ_~B3urfc0%W;pQd_4{wXyPb|W
z^XyR70_uNwe1My_RnwgD1w=BuI*pj*Rx_z^y~<;6i;F|m?lrCzz5~g&a61DYU;y-O
zHCjPwHPGXJKc4n|RlA)|pmm4GKDD#GCxld%_fK?aXRUc?+&&!IjRWsLY$9M;^#K{S
z@&?--^>AQrf{N`r(zS%(U8`>yT(vb%+K#uo2c&=D(R8Ebjfr?%oGRin%t&;V;5-^3
za&}|_#BIAH$f~YjFCZGD1T--LLbITZGtm!{T%sb99M9A(+Jm}WjzD91Trh?ZV-FPP
z%)4|wPPSFc6O<0fix*7P#*a`DfrA>SI0-g>9v0sH!CiCIRV&lsPz^-CKRsZ^>4jRW
zEarckRR+ASb{aH{fc9WcJgayBN>GmrZ(w9mIngRW=yp7cLet4z`%@St_3Vc+Q%6Ub
z-Qot&#-3-!wqFVMZfqu!z<?~Cr|a7_6*{0qO9lGxBVT!eCW;5({GuCWEYd?TYXE?1
zT{R36^DK!r1laK;a_k3kF94f!1W^|pK>&Yp1QE>u(#n()X(5QEHGc%ZfteGB$;^3$
z;=C+xJej89nb<Ke(3;6X(5iNx5Dg~^(Y5eNr@q<_=t|^Q;F0t%qi(ly4AG3Y9LyGN
z=5T!}QohFhU1g^L0jJ_`g&})69X1AbB4mtxE#}Cy!KA4MZ3ni-B{MG`0c=P7*%^N^
zz%>Ny)R$obh*L?Bhxt58L>wjlf%;*F9dHXN$mP)xBbXAL^dKHH@a4Gfcoe09nfg>H
zk=S&9AS=$jV`W;Nou+#epx!}QF<}*Xd)~ndamV?X94@56YJFUyOj>{o(3*-A6c-L-
zaCCq(KA}IRpTiU3K8ws~U_#MpO|XAQ?E;FiM`3oB%%5F=lS!9e63jGT<4~l63?Lz6
zy%TyASOl@WaWN7hMn>JDN3L;!-Vxq$=8anKsu4(U(7uv568plfV}&#eo*nyBZz$H`
z3L*;6(BW8$y`gvPtPnze3<){_r&su4TGr4L+GjO60Dy2jl#3DYQ<#RFH1L1=(4E-1
z!$x$=u!@JBev*i`<B_hXnY*x(acn<*brEB9NRrHZBfI2v@XX#k8Zv!cNC>TsMgFcm
z)#*!IgbVq=@hRN$UhC^zPeJk)=E+TxN1zO!N%tJGf5Bc!MX!#$N=JdRDCY6UpCBvz
zt9TfKP-Khq(tE?}r$fgc66SyI+59**{1QAD1=|y7m1*1s!Um40DhiT3Svc)&#TKIf
z{Kd~A)l;<>r<N7hJc`OB2o*diErR@WDX~NLFW4(Qx;m1mS~XR_Oo5pt8EYCBzsFeL
zlikGdP<sYfe?*-ET_){BMLfuEQ}y(A3?8JBkIn)v&PvOVKD3fm@@{|I4RTn=<Efd<
zNxA%+0+E_hXbb{QP0`ma)O1Cs?>Wg%3bq+e=M(XqhG``o0T`!gh)V<k1k;aS(YlJ<
zd&gl7cB?%&c$9pKfrT;2=5VjE-N#P5=wLE?MKZm@UwZ&OP4Z!vC9^HVTKJ9c>P;<f
z#|(Cg%lLr(*b{@+HAH`;{s%OK<6W9TIq`&(DSQEF3Oz7ix_X3Ez2+a77Az3bc7x?Y
zBS4lk;^BGzooTE7?7!_um$qxNUWhuzR1GwVlMv;-_R+-e{I|EfmI{D8elIxeF_q`2
zF%8JoIrbQ$1^My%lGYG5cx=EKF$6Q<yrHPu^Xk;=sZv2QfP{ZF0Y8%x#J0paTaZAu
zh`nW?ir7hjL#1EYdgnhdo0?8I<j>!7UX!Lu;-E+-agt?+F{T{XE(|<ikf`(~&awE8
zKI6k2wm(B(abnkpUU_<;q+}l)XDTT0ygAo?ykjr?L9)vY)=8xP-(1V^=UZ1EIwze*
z&jMMV2P)2Q;<SGZ%Jg%AOpyHx_F5oY9w|;50(Iiujf0E&-N+=_L)8qf*p=O;tEB#Y
zefL%@zI7^in&%HweFHNUNa)H{pdf<!Dhy&JIqEyE`w`DrJ8J84j%_ne>g^Kr9fVJI
z*ifjyTJ;`jP?qH%$pyt#6eU&dZH2)mDIrd4YxZq5P`Q7K0QMCyX<ewtAK8;MH4ImX
zj6w-EjAZ?mF`wAV5zGx2oLyo8uEzFq+^P?DRVZk5F8(7cDV56#N#$T|j}-+g+^YXG
z+TkemqGd!3kFH8$v;nlX<LRZi1I#0rt%xDpoW<f^+qM2wn@TtV1W1l0POpZ+zjugB
z$s+b7vXp;$6_+IK6-SeUqk(ctr1feN(u!cyEQmq)f(q%tc$^Alx}oE-TD=F$w&};y
zD?WP9q(IzBfnzD$;RGEXGp2Qnr?+M(DMV<xJ(a>_9x8)?S1dETnJUH^rSlkZaemd=
z!+a6sP;1efww}Eht7zD#-VOSts^`+0%Wyo+-GhI10Yf;F*nwB5>N%-8EG`WqIN6@u
zD)P3gx_U7P6>}(E;d&YdNis?I%hRg8W{^5Y4#%GPfz_{avY3@hT)hd73!Y@5=xF!6
zKAQc(aRu;@D+?1q92X>;Gq3Fk^k-XL{|QA`Lg?-FJk4R@q3oh!`S2(1<fe+b^SHr8
zqZxlIDeF^-@@Y&yrUw?SFeXxEkmr+<eHpBBCI!b@I-HB>@a#!ixPXe2yapyUl57B!
zQpR-Zr&8|=;jIRzWg&<QwJn3$9RmP-ek0wGW{q|~N>VPcW-9$@%T0r*h}JFF6||U{
zxo|b75F?0Gs2$qFfo1cIp%A>Y_%}L|kCK05(Nfm)S5>4CSCT)Nz@kjjFeBB#vBCk&
zthuNzg2l}HUDqEgssj-EFz!LRX;NayCihBUR5u*o-+hBQCr(*6@ni$6YRzD{cSm<=
zau5(7$Z!xHn_nxuys~si`&QGsD2THuMMQ7VXeuDeOmqo?0QxhtHN$F-nFioAF9(05
zVGZW8g^(<A|KcU&tUCi4tFB+7Kwp0S^~<jVpyvznXlq0%I5bu6Q10#(+}$gvy9di;
z%7uN&{9;I9ifH+4ycNWe7ToV&c|ZbH@tpiuL$CG6NdG9w5vb#gk*Mr=>6GKITpU9>
zluwVefVI_rulEML;%W+B0Htc8^{Rgo;QO}Hf5p-_$TM}-ir{ZLS;SrSXrZ|(Q`FjE
zB>ISusL;E|ETBI#J_P4As|Ch~3my*UC@jPkRvfPk>#_N-_OG6bEd979lu&g{>V?Sx
z(XHhj2TAiJ^^bxw%9aZ7Kv^;NQ>6(&ew`8`fs0Q?K}qL<yT@Zc?`Q=473Y7=Zh<04
zwANVZPITAp3h8t3*DLCU80n6jkkx2ws$8DOttr>EBc<<5y;|>+iAE)#g+B_t2Um*%
z_^Re-BBIhYWI}F}QY{gc&vcN0&-4s|oYqFAduHhI^|Up+zt;NnDd!}9o=k2<{BacI
zv-*`Zm2?rT|ACsr1y(uDc{P7o451Lb#FC3!TDd5LswYdYZ!%aG;9c~cv*5a`k#uX_
z7b-P{q~G@{xGUi1`@5bmom2vE=I?Mt!c8WI&7BL@nP4h#?lQldGSNc5G0%HwGcCPT
z6af8YG=p~9T8VM+$AGDWs&bb@0RT8V_I9S?_&v89_tJxNtfx0JLyCU|L!hY7)RZIr
z`?N`+K*vVO8u#KLPcBU6$0uPPV2!<O<{4>iJrBqTg@Ei57htKbuj<)D)z|ay!?O;L
zOJ%_A0b&2=M%g<$JoJ7rt$bGJhF-*qPTm6liQorx%w7M%GWz@@q<~Jn`=rn_;9~5s
zcy8DD6G^z_gon!NdZmAPM&YKEzOE|sIkCJm`4IWw5G&VBz}@F+DL*?_A0*w!Ro(IF
z+~Y$C|K!p1U3*DBaf1{1-e8SuZ`WNVYI2fKL75lR$DkxHFFk3lICA-rmZKv>X0>`c
zfdYip&5rlYZn5(fl{)|**(z|0zTv~zH8t`9cNZTrX-|%u@iPf<-KYNn=lVz~myz%V
z69F-ofxZM2m!UWTEq|q1TeIB65q|ft*m54wp)4V3bakG9;1sElg7{DrMR<@`v%4y^
z(xQux55GSBb@yns#{!$AT*ouh>Y3^3d-q1Wkp4xxGTi0H1Z7g}_UC6ILx<x|Cjb8X
zvq<rLLiAUdU)(?Y>{XiXqA)1KGTPlA)<@mfyPv!-Pt|3z!+)J`jPWA#^3G3^)O&Ro
zMUnUUU0itI(WkIX5-&G*Ki~i3*;n_=b!i-bBwfJ#0AX}tknOS}2_lmSZ9g<!-GhdQ
zk%&l3Z=5feJ3r37ewYN(@R!0H`?GyGRg<h*JL-<fj+3ngI-ROcpx<}RJKZNI7C14u
z^V6vGzHMzaT7N-2-9;WvBd?{&MPP$ncE}l3SA#S3Qa>_5lnU|x38Um4xS4ow=HnOu
zh2C7O-<*a)m?X53cYJ@jOCztYCabtN{2}J$N#t-zPFa?DpO11we~|I>*MEB@vp9&O
z7c|XduWDO?HRnrf&$a_gr)p~YPPdPzer{`-cfxU5%zt16CeukLV|8Zoc78zw6{)^C
z60$BsFU)~PC1L8-_E633B#V9Dfh)&(;L8Pgsisp$hmNuYGkHQcKFVyNF3h}YKg|_{
z(LM^`;f_V|3*H(V+SSj;)9Qq^V3f#Hg*|WapY1+@5KSUXf(^V8`fVpmQ6QCGmaHY>
zM{$s);D107#BsieJ>L?a;;Q)W!Ok>`y|dke4${nKJOdOF0i@uMGJiNV@?Eg|&I)`#
zk5hkceuHX)bAVNXGd>c*deqnpY+}m*<e$xW5f~)V%3dOaS)!M+&;hNsxK}r{)7U}P
zh*+HwyWUN<8%3tHJPiF=W}-JVaf%?U$!=Jamw!P~F1!g^(D-{65IeL}HOk43fk%kR
zFA}og!M<(!c_bYv5|1<^4dW{%PT@q0V|rU=^4m8adZ;f<TZVmqR-5mx&rS<bKBj~G
zLR<aTuvY4ZnH>+KouEyaE!IH>&>a=l-P|SegE|+bT0;ua;PzQ=5}k)lY;g0b7fM57
z{eRh#Vbr40V?Pgj>mQod`qSgZiv9x;f1n(%oCJB_`YU`why)H)r)h3&e{HuE2A>Y(
z$^A9{Cx^brY3si$A+_DN)nKnjH^;6YsyD5Io)9Sq-yZXvwCFi6w=^k_f+#N*jUzJ(
z%hdZ<57T>iA)4WkZXUy0l$n(l(JB{(0e`rXK@}!fg~_2Xz(csgcUv9p0A+E=qAWlW
zWdXdlu+fec1z(oCor=64bXZ^Vj9h(3D3vZ2<-y{iY1>UJBrjH^x#Ni{4#|N->3gaG
zE4>QrkJJQztY^$scg+n~Up8Gc5f4>47TGN#-EyduFBD5W<cF7~IIoS@rAd%P*MI1#
z-pF4R$^YYrZrtxjSw?O@x_yZ_B?>3QaXznHBt_7Ei!QjnXmNc+mKw>%g=rL|$$|<8
zQD)11wVf&=ww6`XDHRyVKCFG3x|uW%(gG=56vRpSf%MH``z!Q~6z=Jvw+SW)ij0gu
zA;FB1VCLR;Kfe$%FJu(*IV+yhn|~A;yXlXk*I|Ev-lU|Iv&?Vl)%f2^8Wd~^%{K)l
zZe@OBdhfZ_4H1@Ukms2bAsbK;lI$*n-B+Au_-SFhdxWiCK34m^B(s>)ke3_L=o3Yd
znC?#;%r(>ybItGDMVui8EgeaJNc~d<WP47+Ja`&D)%k4lE+MPUm-{}FX@7CPgnf2j
z>qJc!gFUnJmaNWQozp>vBo&rov1t+HL?rDC!a@@^LLky($#}j+LPf5KvO%ykm(1Ga
zsW@Lu=F4%YYF$jdjFNX_X11OHC!Lc<y1M4na3qUEw~@*YBLG$k8Y%uAEg}RKkT_)w
zZ``hjW;)3(-A}L>g60g^4u6U!A(XHxSs(0!OfJ_a;xvvpn9Zni@I1tvjZiLm9r&&H
zlKba-2~y803g!uoZF6pxDg&5Jce~e6k+PLn7gQxuRvm|diLyVFRlDkk4#p58QOd<d
z(xSE_r4j5R6T_)7#%7Xn?<%19s#t)lxa+^d-{w@xO>4L$akR%BGk@4$=Vox1RC<@>
z0(Re2n;Ft*ry0d%LFLaRqo^BAl$c}FNg@Ck>m-ejcph1hV$Ka-fT`y8<W90Mq+*`j
z2}Or_&@)*=#afkV(eTX~r6!!10Hi#@bg(0rag5n*WFF+ds&S(74;2dwx0)!BU9`M%
zN-^5@;9u`0h-gLPoqwC!e?$6*SA0adRs0#ncs*5vCfrf3)`OWU49$!T$W^Fv&Sk|_
z0F5pA<^g#K0u|+7*KOjBFso)N$Vl7wWLJ+0aty!%48Z8#zM%%q1nxj(B30VR)!h+`
zbQmXDkbAwzOx1&OC&jBet>hR_Gj7b+rAOa!$W^MaYw?|ZQ-5z9r154Pn>S6{Osg-w
z5<JdYsD4m2=q8r6sw*wmN)d=XeE~Z&oIORJ^mS-a_hLw+l<hP<+4dsenu9<z*&Srn
zyF1?ReQa9dw1k(-z!|{Xrnc(8KIFIl4+Z_2J0!`<VbNml#_C{Y&KX^}G<d?4T^s?V
zR1GE9qhS#_H-BHGfN;$gF++??fyFHs2U88{YTNA}1=z3deX+^0rrX1kGx32Ko!da;
zVQ7v=?k=J;;Z%fHW~CL<V*`vI160aZhEb*ur(P!<+6TR?>)mbij>F7GCzrb(lcZB7
z^1eQ7DCJTU87i}{^=2W#vMAnX2fl$FD;!GOmhuj3+kZ*-2`Iubp7LFGl7;jPTx9@=
zxZ`4#&=9a|_BzvGUvM*J-1Ho3o|CF~BR(iLAz9kE=7<29yF^=@M#@!z({uVW*@&V^
z*9fzPSy(XVG3h&Z%c!i{HwT4O%ZW=7gf*-0mg@swL$fwsTHT7EVLOD8fFWBIY@7vU
zTCR$`3xDk#{l2>`Mqj?A=Qq8^o#)k9AD(OBNhAgF^FJy(V@l-0qF9w-CM+c_0Lj8L
zeF}o}R@>J%NkUooZT(QSW50Q!p?Z0#T*ZRWG|atU5REduGBF5eWJ>HGj6^j0ihL4F
z<m99lwr0;COKc;!ZMntE=U4$P;Th1Ynd;YbLw_2sWi2hKy3_2Y(}tSRdn4YPC}q;f
zu_=w0+z5&H9<9Y>ugziLNqax?_`N6TmHr|rJ~*Fd=$3LU;<J`8k3CKRkvD8sK4}t^
z=Gp@yHP~c-7Ub6!y(Ct0zS?CPvo|2XTU@xPmQcMG7C_agTq>yaEaIna$5zYE@#QAT
zMSoD-Mwh?%&|VUC8mH2O8wN-g%jX)S;+tZMt~E>8`Q}Ie^^dRbzxrmgWs<M!E=_Dl
zIa|UIW><^Z4v8gY@mc)8^vHkUvLsIPmHQ!qFWQMOQjlOaNovr`io-r8m2A2Z4FE`6
z@Ljz$K$mORm_M~W@_vV=mW9RA>>jsVnSbg!c~a1raJtON6<txa4fHmqP{$1`e3le4
zPBO2vR$=^@B)dig00%1+Aw!B%@2hteQW`;Ak)(I-+qu?{U%q<vwf}cbXV`e!7u&y!
zh<(9hM4|i)5P7w%oSk9b3_YD+u`7v7ifnrzqS~MW__ZVij5p~h`5LCHM6y*Z$$yN)
z_cQ1ST`jxUo$~7*X7-)G5zwy;Fj=9z#EheBCebyQM5ADtfEj7ZGN~qq&0;Z>89(4j
zNKM#LWv=O}$1`t?{Jw!+y~$lM0igCMvizy+uRrbG!~;_nK~`RSnJs>Z^xDm?qr-jj
zv)fg5(d==mi}{uAGIphY8A-BMs(**Q*%C{ZL$C=o114N>mi!YF2J+*Qs1CJH(ss=W
z&Ex2R-wX4ieQbuBK_@$k**UpkuptW)dadCgF1;Do2K;sD?UnRj7zKI8za#(jbGWMs
zPB#U_ncV|pop%wt>~{D1*>}?TTi;WrL6POV(gaCvRu_HtDn{=iBNql|lz#+CSQ5j7
zB2;pykS5PDNCr0$v(gfoxnsbpGQx*Fer-<6^lHUeK&6Ls!+i*>XG)-naYtEk490|1
z2K;UKHxH)GL@VOrJPgusag_)HpQ&Sf`SMfpes-LEhzTOnh?CQ^xl<PgNu~n1HkLS$
z_?j7gy1@=|&Sk!CKbyqp?=6!h=k#c%K$)m|ivwc>!q$`MuWtZM&Djcwl?srP+x9Rt
z2;YH|`hNkVbA`;8k?;i*0x>j~QT+iF12{A{m$B#pDSugQkJ~m9{+?g4=zWM5SSzAP
zy*NGKkmj1+9WL!%li~`r{h+nzH7~N{6Xh)Y?{D5H%eHotY>Nd}d>N9%;qaMfXmypq
zpSoHmSB2K`(v(-L?X!eh`@1VH{P^87C2|W8TudatdH?Lin=HFhNxV#!>gxS^I@SC7
z>X+#CrhnQEw!dCzts|vhUN4NvqBqw{sp!>pT1Nkdu4HLURG91E-v8s-x9`X0vNZin
zy-@N(vD};}RzhcXm6s+~+OTrJCaS<i&o`mcIER*mrQTncI_j<$X;DP?y}MS?V7XTD
zX9u4$>iVI&ZKUUR@0uEmdE{5U+YL7;Q$~mDw10@YJ@>TM)+|2A^u28kT<Y4%5;=6N
zY>Q(Du7AX`?Y(2UJnGgg|I^=p_!sJX6ZDV)`xcEoxCZwNJ6k9ntBf~zz%EouD-&%h
ztnvKZVq3rOVb@SqQH^aH)xs`R3tM?|ZhQ6auWz{IJbxP)+*P%$Z?ImTuD7b%=R=qc
zcYlv1+!cOlH&nVM8(Y`jaedcYZ+TgnwQB2=y(!+@utA|cs-jJ_<;uYRxUFc0ebvyy
z&>uDr`nj5gpp*MxCNct+ch#_ItF2{`og3C5=DBviu`NqAuxr*Bn#C?qa)Y<cI%dy1
z_0om7-a=(@mK9&(rr+%EK!G%0My}=W>wmXDz5XW_**MhpGwzLBmuN)Vs}1Lejr-kQ
z4~NASax3_<@;KAF@3!1l$ueCdbFaJp9w(~$dg0ntw*@OXyb?3V!t0U)$AAe%8vU)>
z?Hrs#Y0!B!poHkJjgDY4i{>?HbnoCGs8n&E+zoa>!-l>Q3EVaoenx-h$x`-9_<wG@
z-trLK=43|NMc048vzyVqw%d+Ra@bUI)E*QZHsfK7i$511+I#UEZ+qA6J-eHZ*#8b}
zHB^zd|3`bq8v-!E;1mI5W4TcAmFh;1r}h%eS^2K@2q0zzEEybN4TrZ<@I%!P`<+w}
z4G{1UB|T5*H{Cvr!W%&|FX2dAP=DWm;N8BLwZ}<=6V6y)?ok5L+m7rFMcNg_k>FPc
zZpH<Ay6q$b$Kyx&0}rSXoNgFY*j<v6A<qWUN+vk2ta&Wj6st|eAr6X876|x+h<%B;
zuB|P@Avl3R+nT+Ryvhn3k!^zuT_6cS5-NYhniHp*cq3snqA(qg{S5yqzkkHPz9%2L
zhqX!_%vGiWoKSGvU1PVCKmo7-9>$%!o;}bZ<lqFdJLuB<AuB^iurf6Lnq&#sV<ki0
z5^Nv1FHKYi{R*wS%)~RG-IE$KhvB<sKTsewX+j5x-~UpSFsY*8j4gDDv9Rjs#A>Nl
zGD6O=3D&@|PG%K6=(*-CTz{Awq(TBw*vMgnRFH+&m213+?eRtlFk|01;mi#YdrxdF
zK#jM!NZ^L=nrbBo?*@N__?U}iUTe?!7`S|_65wSzjZ=W2$2nP$UQEPi2;=#rw1anc
zbyQo&h6}&^NQ#qN<35f?rHx$d`nf0TEYz}yGt}f9Mt+kUxU232pMNhns45kxs;@GI
zYUZEVbC6z4#Ao(=KB?TbOudxLmY>{Aqd<Lqj{I5D+yCtyf<~5R(N~qP*I(fzb1w0x
z1$Ju|#j&>U(H&?c-#9FaK<K%JJ1|ap0T`f``Mm)tFN7a^t}uEa&lr$$9;DoHFWo>a
z9O($%>I1iabk&^w(to6gb6tkTgVkoVG&)X_A_%f3MF=9q;8kE!1(3%NA!>pi8{2no
z#XZ$9*ez~}yf4j?I5*iDD@9CMCW6|gT=J!d7Q!oR*Z_^<ra%t};;_N3S)`INW0=E6
zjvm-tcSNnR(eGC)jyPEgHEU-LwanrYnv$Sn*Z3ExAvsUnIDfyJv)Uqzn}TZX{Lni{
zKQP5H$f=07VTpHW0@7p2!!2G(E1(k-6Yqwu4}8!Riah3If+-L)i#xl$1~kgAj49*H
zeB$b|=;A2L_x8j<C)3e3SIwfS_U&pjXP7LHb+HWQ#9KFKbrYv14MLk?*m+2j;q+d}
ze{v$7!v#vuAb)JtxDPIF?eOAJHB?f@r79+RsB=4|sflygna*NeE<a%@5nfEBXE5$;
zN?Q6M;*rILdJ>R)-wnjl(vhX56ms!f)wSawLj7HklL3>QEeVMN6jsPmV32SnLZQkr
zkqfdH#QA0<mBjNCJ;DLXj{t`i3aw0tXJC5Fj7@6b#(#LcF{u^?V(|50u-rs<0h+dQ
z1>E`|9jz7iV@y8DcTsp4Aq#7(s<)@}3ngbhjvaJE`4q~NplwX7mZR4W_psLtljE5a
zOX1EeM^FKV0cRb(;spt~Mq3A0FXFN+&+yW1*~&%KySq)u_7Y%UYvJC><Xs^N$f^@{
z%-f+%xqm8l2QHsPsm#+#&nX>0pLWcSvBFN31gA=(*530vuin9$yn>4K&D>dgBJKqN
zKYq8808#}FLkd9|h#_YN#Y7dT?DjG;<O2mzC9rFjqj|CFEu5&#5-h08u)|d)X=y>(
zEB9TpC_h7)!=nvwC&+;7#)j7uYVzWg9VP0RyMK&E)9h?0e0&elHz9G645sNqzI^mZ
z;jtv=&-0|Zi)RBG0N;5+lO^u1g|l4{1M){kv<Cd7lm#1}KftXBJgM#Lulf7u#bUvw
z0kcjlKn5+-Pz=8`-{n}>dW)GJ4I=FDW5wQx%v#nVsKXK_2pC_fwc{`3Q=Cg-<;d*P
zQ-5Zs=RERpwcse$?syQNR8A;|odr5HI2!dO(F=d@z?dH8u@7ko2N@Kz7fJzx3F?W)
ztICVmXhTQL35y53Sy;I1hD-aAe-!|2KoY^hD0Bg}GZ+x#!U&6pUQic#be=~4L0IF!
zRN%|%4w#KjBirJk>4Fc9z62lzGH$s|P=D@F8jy=E?*B69;b<OYw?aqIb_=^|X36a`
zHjqUGa!YqDCEiK+i)9E*{jg{pM>P?kbM(IJ=hj!ch*dgrYg%9SFrz}A$60AcVL~-n
zp+zgeiufK!P>_UIXnw%}5rnKFvh=VDRmouM&`H!-*fyA7ow4mHPlVvyjv0D_4}Z%l
z+Ph}pnq%PWSWpNmln_|+%tUWN#SU>=-kEMVV`oMR<M~Y(N8pnpex*x~M~h;3wDf=<
zUP4e{Lk|hiyTZ8vSMTQUPI&k@c?p7ka6A%MCSDqIN~d1YahEAa5PFKCck`t=K9H<!
zHSnt!WM@vEXWDMy2HRF>s%HEZpnnun1z!m$T!Elc^N{1YTmZAl;xt#m6Q&?A=QiMD
z#VC9`dF!c3n>BK@eItrelz_f(>A4r*p(GL0X#spZKQ(3tbi%da2LK%$z_#*pg*L(W
z#&Bu)xmfEE?{4>Z-0mbm@zUc<KX<MHT~x#&4kFgRAD`z2>j$Vje0uLVJbx=$S%pIb
zB1P^in4z*u$3o$I{;|l0Us=#eYkBb$_H^>Q4f)dKSC!KhnL;V{b$|AwQOO(-)DPR3
z*jn7gij{hNMjwA`s*$=F6aCQC!K#5+Xx>&iZtIjUkZw+XVhnuP_Oc4b@sHQQiK@mP
zX*`bZ?aR4*gnuV|C>hBgPJc$$m2Vc^?tzDeA{{d@CmOVbB=>VOYb4F%0Q@NhBE2B%
zxW-u?wM^m!(#<DmPWSH-^@}vtxqh<xH2vecD^*T%!17C!zlH1DA0E&=%VJfkCu?3?
z2!^)D_m2lPPgI;~{S>oryS8iGuyL!$jIWX$oF{+s9ww`No*yX)p)yHP{>~kJ%BK`Q
z4CLt_v8~VXuTp`3nWy;IWT8i04PE#FUn{?GLzixck2U`XGN63ymyz%V69X|dG?zg-
z0zQ{kcLS||1;$Jmn?ws^NoGP78)i(!p;>QiqJ!(cKbJkQk=o#)8V(FqO+OTMT{U|i
z4~LS0Q`epVQUOT?h|g;p^i|t1qP^$u+naCSqfE?797b?S$O>GdHes&x$VsS}mtTOt
z^+p9BA9;&+?eXZg{ZRF56`X{<<Ebu>WrJrA#o*6>-nPf5vJ?%nu`+hGfg6F#=7Zbw
zuq%dg_X06O27fvfgIq_;-(CClS1jXP4>ojI8Yb?(uW>h%29NmY?U@IM0!N?MIt@z3
z6#VJREyxCQ1CPD9h$3;XV8W`P5`zBFp6i|LQNulTWwCqY@fL3s?uAEkEdbH`5ES#L
z?f6@N!>x26vdQcdzVRaA0pZb<RV-Rl;vJfpxW~`2?MjBGa^Uzg!tRn0F&qkk;C1N>
z`bC#g?aCbpX_7d2pjCcH(225<6a97KpvP-^WcYmAcW@2GPS!bP^vpBwceoz!367bm
zJd6we%-#aV{9H~^Xx)td1UjOE0}uG_8$kSj5-GDkccgBUMUS`}2mmj}h@MsuVp}4-
z>B@c858dNBGXcDcjZJV<mY3ebBzb5-36m%SqmRGfF&y<~LcZY6E;pq+yD7JW7d{SS
zx>m3T*>S2GpMHdAD0Y0M-~sU!e!XJ&RP0eDK^k)@i&p8%W@)H${RKIYax)=akYT!i
z88H<y!%FEevIzh-%u_uv(^OB)6b2V&3YendZ%Z}@z*7Td{2(4fgQr+;P>p*YHm%?%
z`pyV3OMqg$sZ4wQM_flb;cZ~bD@(-=ZmQ#5d8!N4C6h)@-#Q*WW&3r{Gvf73s+N>3
zMt#un%GxZ9(l5M`Bi@YE3(s`1<y_N$kRu9M$j_%ANFY)w5h-&bfky<(IpQ6i007|-
zybzEsN-N=Ns;@89PnE#h2zWIZ$MP@8@2EEu@`Vey+;r5{%K*AbWkapPB%cKIP|w5Y
zHC(~#qXfali28+a%0aQ&wHOX?=bsK`<AUmL9#zFV99mrSz(hVQ0esD$GkFAm(q;oG
z5O8_(EwK6iYXn~wOK++M)mbOG7z;xB3hj#{B97hB2p2V(5Sj5~&$v4_M<L+Po^2HW
zrh%*-s-qBL%*U^nV2YF-rojTovw(*P%qkq?A%a=(^E!*439ZM%#V2jR=$rmrqubE2
z3*!KBW(M=eq7pr?8cNP!^1c;+;Nehh(ez~zK0I=^tuQWa898GXcZ97UdCG@fG!AWp
zyYt{k;PHe3%p3Yao-mm{;e}XTS(im$E<Lu1!$hI!5TVx}VBwBlrR2f3?SQ2LJ(N+w
zEs*U+GVd$_MxPsN@WP#lL1`O)kx!ZuZ%ZN)Q$3H0eS!Ia4C<Pxot<od*oO$SQ)kQ8
zgHBW@;{6fwDGZ3PEiijCCZAxF@u`u7q61>R(1=B@+3UfKXOITSAOfG)7DioFuqO1p
z5S0#RC!P{UOG)K|4i*$=)F=bOqhcy6u}meSO(C{BHw_1Vm?;~1A%F+g7!~wG|98As
zHQRdV&b{n6Mq$Layzg*-Xgl1jeiS^vCCpT^Ol(6<1;+Un4d9_!5^^zqqn@)w_mt5h
zVq^&hPLF9&Ic=mILQ~1)Ruvv-yg|bXS9xh)t!P(i0kA!Tj{D4WJdR8do^N<9Ym24C
z_ADuvWFQd6M%DrCEh|RNXK&DU10&8S$T!R4$m>`ECR<I645lA{DzXm1qAU5sC3<ha
zN4LhgmQPA1nbzB0Hf?#E1EoO^b7X~?Gv&}VX2d%=5{>riDJPTKfY~h>xNqy4-=6l{
zzhTFdm|2to-tt^{6s-V((j_ManPUQ&Xv`UncO?i_ee-%?ux=q#>=>p8C<iira<0vi
zuT<8C+U@;IWTUQs{QX>YBFk4rzq|hm&}xaX94cv(UwTi+2Sao%2+WHyK(tdqI7u=&
z<o)^FRzwZJ(O}IM+Z2?o+0|6pSZ{qcomwB@`^SDLkC;a&!!`mWC-QG?-&c2a$*8^+
zdggxNhBQ_skZ(MDM<~Fvca-5`|9HaB&sbcMZ2$+(xp7^8WAiY|viTMGihy-5%Gmcr
zsoXO{J(t`7wde^LoEMLPfS^9D3<2Xy(kK-b2H@P2$HbBr6<<LCdCxPWRYzF*i=qn)
z=Pk}2E{`Gy7cN?XsP<np18hl*6$Xy@)e)YRIz7)8JaH_U&!VY%p(PIh6bDJkev^Jj
zgS*4zl3GB2;;f_0@w2VpIIURV-KL>Vy$W5i$_<>|y1t5)(n~xg496S<22HgsMMokP
znoM1o32<&8>VQ5dOePT)7Xb?AW`_ecK9reC$`d8y`{GzKYLdh{8p<z#=<PS}K3p;K
zoj@jd_u=}6ys#U8{Lxc=htSioaRd9X5sB9~!HvUzP&Nf$33N92-bFu*C*JLzdkGsS
zY!#x$R*)AmZp$+6%Bh==<r0tpc6otb>OZ5GF1_ApYss|HX29C9UV!Sku6`3U)}R3_
zKT`HmWB^iy@GoW<^J)Bk{1>kB#AuvYdCu14as;NxbnfTLNm9AM;w^;QL9pye8I~^b
z&4+$};h|h(A(Px9&1ao6#uPo19Oc^2bt#xTz6OFPZW`9Oq7cZj>r_FePtIavvuNTb
zfpW|N@u<3Qsa=svZII@ZzC|9O5wsW;7m}}O+_o8)6dYnQmoQ;V5w}ka3k6=9I%x0}
zl?B@Ki7{tRnyQ-7^nCh?`&Adc9P8Vl7{+{m`U<NsBdoU7Kxw8W54>Aqe%TiRMFtxD
zB3G1v^N79M0=p-h%Jk*4WxkyR5Wjk+FJC>=V*ttY^lf1zZwrunTexX_UP!|YL<ov0
z*|htGq%Av&O=`n9(lafb5RMghoJZd2A?zi}pGcJRE5er}UFPfZedVf$jEm-R4#Mew
zqWe!ZWSObE$A=Ca5bUt&LHunwc2So)3~ud{!e{9m6>6oQ9MhhM(|OnoUD5Ql6oE^=
z3A;Rr9@CFSX9szl*7;xYcGvgZRPZl@&4zipg44%hUu~sPLJ_)WeBr)w)uXXUdu8G-
zflS;bHbu}p2*(|fjP!<<a8yO2hsn}^@{iHJ_~hT1Xu^3mT35EzPGFJ${h!;Vd(oJ;
z`HS|>tXz6iNONuEvjI%8L-@1UpU6X%<Rc}gR;Qwq{Et*MLMPVtlDo-WQ$ogfjqx*1
z#>hld&Uz3YxTZprY_|1zSB~i*cX@Rhrq;~$6_dMqQ9PA|Nn&T>)#wVA@*>cGJa0p2
zoZ3!1tT<wWVt9u^kD}i|k)ERk&rt?}z=<6Esj6iWwdhR#%=ULxQ((V_w;w~0^FqLD
zeDN~_Mx13!O_h1ct6GQ<iFd*11`RkaxqHmra*jxdg&g||e}#$0`U<c<b~JrsbY{WQ
zb(~C+iEZ1qjfrhcY;&I2wr$(CZQHi<<=*#x|IRvV9jxxI>e^jZd++$r72u$Y_j)hm
zVeWOnJs~#|c$oSnY-&vc)P#e>X1FHmTF)<~<+;YNBf>V<k-bXBs!mAmi{%9ZU&wq{
zKAZ5ys(_ydrgB_TV?u|s^UUIFal!ppZBasE4p^Q}dHV)=Kj$L#)z}7OwN%v0V5grG
zk*qQvq^r@3a}|v;pC-mnNha=Ukq)$abSRqxY%#C;3omI!%;IGLiAJFGPZ6V@i*9^m
z>gl>RPdL+(XhmG9OL*oHp@(xr3Mr!h_P=cWJ?WXu`zRIxVX~{28g%;_F`5QJ2t(+M
zcWtYQ58SkcGRnYzP<}y*TP4!p#Q76P#-X=ukUY}v_F0erS;U&{rB3E?_!aC7wXiC~
zSiZNHWB#huJedUzaKx5#<exD%7sCkUe}VbIg=teXb|1Js7THsl9LXqvC@@_5bI%}3
zfj-I&0)dGSHIVU43?kkHmEnaQk!$Iia_iHg8Ny$)#KQA>Kxpk5H=1)VkRg(k-GgM9
z?j>#yKl)UvB&GvzwyN+S-|3J;e>@U~9C||~u7W@rri~CR_TNh-<lr7;aD~4L`y;{(
zJMtb*u4*DqjpxVDU}NX%7z=18k50*Wa>UhJ%;<wAnJCwFh?h+kx^pnqE(xR7O+s+{
z3HQ*y&&3UOG+8xz9;*5Z1#8zwLm?mLBqmJXwLt(&ANX*e`fC3>MrZqP^J??AKj;!D
zXumZ@^GYx%1SFV_*-FFz@B!QZaczJwFeEEjf>0&1M}w9Dzz0#{sStH*L+U9G3ow#t
zG=l7j{M3eU8h}~nI9}8rwKQ>M7Ol)QSV(Cfigno!Yrgx>vvp_6Y)>`LToKhG#iY@g
z3@At7-1{6-<CGn3Jvy0RGEov}Ku+X)XXe8L{!)3*#M#f?<0e~R-tGKtPat}cKvEMG
z4p;lioC!Jvv^j?hD?J)i%krD)whFiZggd;Il8x8Z63wM*y_Y<HLzN2>nYBrKyDVoz
z@yq6jpsHv;ATN6<%pp;8RND1|h<-b%{ooZIN09hhfnIQANeI760UqqWTFgadFenc$
zh~31{oyMi%T9Ww?`x|c}$E1Nf86NjDI}twQi(wf+C0z9*^dymz($K6o)WkafAA(u|
zV<-_bVhG&~?Hlgs%*&n$!*uY=w5*VC{%NyLdbTvxy#tU?3X@tXv|j<rIGN0AO2Nc;
znEBDEd_dXY&059bt}bkKu^G5yDUezrX(&P%{9ZKx?srkJMCL}iw#cgM&2U{U8%iCP
zgKKbr!ou8I{yJhx2Dc|o%GDY%C{#rcN2BWE+rLyw27NMUqba6TZKMFZ$kw}n^}d)G
z?zmiR584}Fwu^Gq%N*g`RuJ@l)U&X5&G|nXsf)cB*b+%|yt6mN^we3*sRiL+7hq7+
zZma+OLwbDX#vs%p?cl<Dby?`ku(Bq1aDd(!^oC7ua$hK>|2JJ&K4%6hvJ~ve<0sy@
z2#$9D_P|$Q$I_LHHL{;ir?=^oR{py$k{O$dTX3m0N8s3H*e#reI_tR$Nsksd+GLCB
zSOlrp44ljkIb00o0YM9*!hp!YG-r>(&j4{kQcRH~{FY+{GW!#sE=4jvP<R*m0?2rw
z9M7LfI#f>$aCDY}73Vy^ycSk2KtWBZ5;>Yjy&_w!#pF4r8Lb!102aFC<mPeaAj)Pu
zNIBgREtmf@i2GQ}P9uA4lM-T7L|{y>G@+EOaFJ4~Qb7kd30=MHqQ}vB1(#lP4c-2p
z<v{BFvSGdF_SccMOYZ3CZLLnM2>@#|$qMnQ-Qt+o%jHS4QM=j(`)fUkHwvWTFXMpR
zmzkGv{m31SV}fa4-)s=*t+u=j241qYm2#;?`Oal}<rT|i5-qRZZ1EqZ-{$REPcR-n
z{awXp8L*2QQvuv8;BK~bjAOBU7V`m{J3JHdGaH?~SjCdp3e#d`sV>KS)&RJgU+Au*
zu_=&2P*jlN?N}&#{fVx*+*Rr;7tQCbI{^(y!bvSP)%);~o7%$@#AeaNE#@FsEiw5?
z8eV_Lt#l^+7Y!f>vC+JD{Xn~{o%Y*OS52^h6&Wdt^|2K8n*d$SaJ082?O&d$f;7%5
zo&qn#hwIkrtH1*-K@1L6GJsBMgZ@?|)oW_*Mv+@n9KsxL<k1<<<jXVWC?AJJ<GFd+
zb<PO7QmbxjQPf6rxv+RCYiu;}8Tzcuga1rLv3|A-thfw$DjZ#oK^5EJX$d6G;ff?t
z#}{0bb~%fhxl`ObvKfebojj+>qT`w8f9x*#JvxOCZNGG%B4-RBwqGm%PcTB5_+W2E
z+!Azi!L}*Ak6orC%^IWD%VwTWHt;f6%Uo_irE*e~I1jt`kA)H+ooxAITiQM;7#;7T
z67%@4B>3I%j6T`re?_6v2dN?;%xw~bGDHeWF|--b@(?sILQZcmJzq1~QA^xoWQVy+
za+6@v&!GOMb&FYm^n2;wlWcA(%S+62T&bSq$(7Hy+EcfB@790mCV2Ssy6m#0v%i;X
zDBzsGBc3GrM=s&l`srZl)#Vr(F7#ov63c-D0ayn?R?8wjAw8HP0TgVPvyvXH!QAg!
zf*Q{9+3Qo3C;y6K=gPqn2B&H*>;gkX;w^21>ttqr0aLmFW`GyUDqB;g1XiTA@PkiT
z3Qv^}`V1w5FTsUfY=-jDsVbz`b_5|a+RJDzfuMq~ZpL|I(MUgIjF;<waY+*h1ow2V
zqJK7FMs%b-n#I*8z=Kjp%ryPWb(8?+{^Wwy{udwwm#nWiT0G@zN8hO7ytwuE1H)tm
zeMRoYu#_Ja(C%HyD51anC~Y?}b$9bH&u9JgpxqeUR&WTEo4CmK<t9A6tBT>1(-%@9
zEYd9QL_4+it1i&t!kv$<8!Y2JHpk%+n<zMp&&$CXO|`F)0asyRg>YknJM`}pdKZN>
zzNUHwC3~T+XKQVUKXo~8$(E}o_BpSaumOm?l8&uDU~Ur>Le}<3M)2w7+hjQoKy%&R
zXJ+{8af+-?VJDhs7)fvPwp00{4J+U(e9_a)w)!KYCPag3F7#xdxP*MqLG;>ZR+qi-
z*DPv_?*nod=ryMIPy{14%4E@!-jD|oQHDM{8p{yYCb}xZbpW!{O08_Z5sm3zE&R-t
zduyEq_ExiZ5OnJufqd@-KEK11=Rq4L?^$o^t@k(muB2z4b2+^pm!Y}pkS6%W?r+Bw
z1NskqekT2(|82VL|IJ;4FtH>fLI6`XPv?NPf&=V`V#q<NMT)^r_fkYt+d+HKPey7p
zqx|tJgK^?8#)u2p%m;gKk$?ZKUd;KW%929fa+HDFD2A90ohX$eej_ax4Gs;QEMY*|
zkWUKU-5ERwK6uE2UMBIJ1NSR92cmY#vwp62K@VaRW93mUot<=?*I%{A{@YppQ(xLN
z4i!)(EmOC#?Ahb{PXLF`YAg!vFMe0%qOxt+j;r0<EG*0ENQB1jG}Lk$B2<}2%_;Jc
z@mZx4k~j^r(ii=C%z_d9g4;}`1*$z+SSbQUG6z@+x@Wn{@3pR!9$LcjVjLI81#<96
z00%E$fVBIvCrnH8aeT+Tti8k8Wx63Wr!IgF`eO8TTJ^5r`4{~<T5}AYDtfbK#6W7j
zcQ^-sV9Bg`H7?|&WbHqPRu_+PgL#7F*eQ(mw<$#FBs+4m3%Xo+2>g%xwat@FFy=v4
z_FaWO5xVLY$={=f^Kyz5BJ;9E4x9yn6w)jzZVW4>&T$jHkjR@jl!`ui7EScujC}y5
zWN*<BH`zlA?X)@yx}~T0fN0Y3lK#-k<wRG80sY~K{L3;#c@`XM*DBK61VS^5X)Iyp
z&lmZ`lmUD*Da;-R4N}7aCtg<c#o0@C4Oq3b+H|f=_Nv@ldb;{(4b*;KLvO5s9dkSF
zJHm+e{G6L01}Fa5`A;w;0_`uV%M^fc@&>}eJjNsg-NioepPi=$Nqo_+fiPIwnAY>C
zj4Ez)zU#Oy-NiytQ6(FmM(0hUZt;4|ar>z|XE(2J-oUNxw<eowaqoRYOq)=!)LPe>
z{C}6dv%HD}O)~0Ci!HX9RNwN?X*!;Yfv`IgAzu)8K}^F+9PQDvc$iS5?7DzIr=;NM
zdsL7@T%66aA=Nd@x&fDlpM~{o!=l@p+F~w$m#UkoF-_=HkpCTmNn;v%5k{&VcW2$5
zjZM&RoZBK#M>d>gmjxI9$i@qX10kL`+~Z*YK2zON`E;^c8Z&v{mM)5a>5S9rR~p=-
zE$FKy(seL)A4S^vY;^6?eB8odpFw|t9sr2dv*i94c`~s5hn$}ogo*jTg2zAf{MOOf
z&4^!BdcC%?3MoXK{e&7Alo?oRU=l#fE-?*N{3CN)nFyIA5^XGB&)z}h&eN`3W{(cF
zpMvb|+}t=*<IK$3p4T1rL!S6DbT8*|zb2%Ng;NtK$o44JGh%TP_2cb#VN!*xh*qTT
zUeY66>EI1-2{5ivYufh&N~{2PZ*^Y<RP@;RaaD)CLw~NpLn09!ps&bp!u;VvnV~jh
zTVZ?PsNyYfZw&48hz7vOskrqa1xep_WC=#4z>)Kma6wWDexWGCa2f*BAUO<yxREEw
zL+rtXC?D1ns<Fa>C)m`45W+J<ktq1+_xhn2GWvZYw!Yy-h*w<q@(loR);5(UFyD|x
zNYt_+FjmVGe+fwqb;iMZZqkb)v>~AOw;`lJB~Wm4_mfy~j|FMqstANQf*RQUI@rbB
zN+^KPXUy=&639*}IO-*uZGPSvkk73AV^n<v><bX%@TF+u5=Rb%!VWPuB+}vSYvw#p
zN?b0D_F}b2#0Fm)g`EZvIANrP@%>QAj#U|uTC`v|U#eHDAMR(FUAP7K84qar6c-wg
z^gqS>Uy33@r3fH+jJA(u3f2aJc4UE+vxS5XB>IUX6CvG^rX-XpJ!~rC!nUrO>zmmf
z<ro|j@+y@m=8bA!(i+ye=@9Qmg5?tKs467Z)M|s#`DAE^okal_?Aq)D{;Y<XDzQv~
zYbbjC*03rJz(SA|AdS@DAYw(CkZ(ECQ=|&&y+8Kf9W?xD(#THV1&2+I?X4E{Bea%O
z$J^bQYtu4!@A`CM@M_eI*k-}LpMurv>|p3`p1j7s|K}r4^>R7<*B>&!+=StS8_oPE
zy|D=W^xc2=+@urGq7#|!oId)v6+LOp^=5P1?tW|sS`{qW?@7a=xoa&Nv%=JsGL0Vd
zR27K1Sll;}M4{E!9<?L2p;QTt3EQnzK{i>YGuNp$IJAN!WBO}`kZ&D_MT3S@R-qGY
zIei^Io$4_7^h0f=jLgd@=%<{e>+|)<qh6!xn+s=3toa^r`{=+@dvC&wQ%Rl-P(8m?
zJY>#|wm1rpyrHWrw2(-x3=R_zE0NfFFPPv*vqd*~ne)2eH{(j5s{YzvnJhY=%!j_v
zMNG8;H$yc5`%PJpISCaj@z~bPsvmK?cVxl{fFMm;#Mv)Dt%sj~y@7z<iZ~KpwBhR3
zR_5kSXXys8*3Van4z4QNv-Vo_Q1;*}G-b^Hk^Zc~kZnrxxIH=?G!M_$jg4LcwvH`s
zB4DB{Y2M4V><&P0s9WOsIMn-w00T<ONZp<?xt24DlV~DneP$AK+sbddHhnP0)wiZM
zvJ277xipOsH$=h%s<^#j@uA`dqQZrj*OIjqzvBQvKf;)hLus?1A6Ol*rGR>l+q*J!
z+a%S`x?wBg*J6KicWO+fVV7{P$)Ml!S5Bjy^->$>4TUNZ2ps|oaB^0gSi>IjF=ky4
zy46u8d`6gkSqb>^F%d;awG+Va)7|{CC)e3<MrC@5g2ELn4k7_nLpD!Nv=)diBn&MY
z%xed%>Vy`Z+cT#}9!>5wak;Ui$}Dc?r|RnDsWz$2PY%ZuBVFb^nw<%wz2M0vggEp4
zGZ@@a2}cS5nPNLumi7~lj*6Nqs#~|Rt;Sw7oYSu2uVSB!)YYyOV`tA_bWad0x4D(R
z!7)q)W*AM(EHfLaLaVRJez|t8w`h}D>^=v~+RCyLSbREgS&}V!5iA|gqI9+{`XbiH
zRPF~0n4(9`H)2)}EmyWBheHchdN0E>kPqOcI7U<Eg&IS@W6maN^|jO{BN`#iRm!z?
zXc6-RFV60W*g$d|_V=9DTPN}@@%V*?sb^|EGeL+MCG{CFR6DL$ksaW8Lk<R$k#Pa=
zzDtEY&!B;wYvfLqSKtdiak0hjP6NtordKsm+)aseJ6?`Q&884fB4@YIcmB>ag6ot6
z(jGZ#|B~R7nvym;M>-UCQz<XRh?^omut1w3KRiGdVs!lzVzuN$d>)xHN+AN`BRuU&
zn=tMsW|p3wIJjY8z901$fMqj@W~2tJvpxEF6ewuQ+j$g<H1f3LU9}DmoLoU!K2r#O
zH-GNKwVn63=i{U&G{fla{41jUtuCGV)2r`sA|Ex(onQ`Av5_gr=qkeLeKP+wq_#bT
zW=_oA(&`1ytoL9j2~S+#T(|_RFFz$$vPx`sIhtoJDm#6nE*o0H+s%JcV#5PS|KhTq
zE;N~5b8H8FocYMn2hYWssSZ06VJoUXoBffTkldV3-N8(6m7AUi{WCqQD)uiWgb^n@
zq?Y?Oax+)@qAjO#sW_tT#Q8y3j0VHm-&R~F+3L1^|Ff8stf3x{>}+5J>9L^jPk6#h
zw0dereE<Y#`fx&BAOVXWVNf*y*pC6y<FlfH*Ci|#g+6;{g;Fs(fjdaj!uaqr0@2zv
z!LHBzbhCp`*ph_%s4qoMVke#)xf*f|d>)u8?nD7XpF`i8&McLL&sh!UeWKzyg-A+d
z&0WSWd$#_u6q2~sY?kvTWyi*DBQo1@U^GhDS#o$d)Tt(mYarRCMRpTFeA-sGz#CUZ
z9bd&G!H!)VFDK-zxG)&VkOW~q4oaSG?mE+{$r^v;z-60nUTdX_3b4qarJII`Mk@KE
z)GLZT3lEh`JNkh_#k-V7NVscx`$k&zX-1ekr*}5KyWdzqGVW0!INAnc)Ec1?+;v8u
zL1TP=ysi4!M18uz_oW25A><8ZgX{vbm9FxZbUS$1ZJ3?`zJzRhlcQc@JD9i7yYlaN
zPVr`P$?8zSA<PuY(S%z%+zfhYEoX=i{Q6hTUvAQ>Zhe*v`T1(+`PeMX{M#&_5)XGw
z#7sChDWV4w6H2=JQkeSpw;!Z%#COI9qEYO>5V;>&3?35}l{#H<{zAh>CaG-Oz+ndS
z`5~MqW-*BT2Yq9ah%ddA&xi_f;DulXIhyYqxm5GvS1GO=ufwY<#cYjdJY-S<H@7r+
z(r?gpC^n}5MK>Hj7ysd~Z7u~J0Rcb)<wKq-A%t-twF#aKQW<-w%XNU+NPrykiso5k
z_)NDOgau9QL*o4reIAhS1-<XTF%AQQud@vX?nN}-L_-~f^;s|K8k3C7Nps107P&>?
zAj|iARt4xrmWyP1g#NyW)_=0oD?oCP#Ys;Zc3jRg2QXpG28s-^<9B-wBLGU$fuTN(
z#J57~chzBGA1_0v<U$#tluG^6gr+fi#65JWX^=%_ck6rj)eJ_U{g%`cM;w0WyQ4G4
zXLGdkWje6rMv+>H!cEl*yuf!VW(Y<OyV45cVwIOZn0|m5DH|J6@Y2fKecDd_O8DHw
zTz==X=JxR|#T2i^6oX$-58&n>f3lW^t5}z!*#^E8tk=R}k7gjbpRmVXh5?c3RL4az
zz*!T7(3}wDcNXWi6HXgg>+$WR_{_QM^*{H)dFDXM0KbQ?UO_xWIRzB=+V4Wh|Gw>R
z=UupR0F^1=PY@&iD<U!Y$Ov+n$)&f@<{d?;DqF@h>k)(04M_&Tn23fX^|kM@PoH!y
zuvRGk2oVyBbU5ieEX6xxi9(<Us;Xbvnmj#?($SZ>7J$f1x(L~$HHuv{gS@_0I2@5>
zIu(6E?=(3J#auKOsNEWz7bSRu)OiLVHsMW_>`dTFJRPsSwqAloDK^dNfeNKjJPbPh
zE~Lq@d~(l<4YmN3k=sF}rV&~nG*UH+Y8)*Tx$kiS)f6W^D4DOWU%7waU3t9w@3bAZ
zmfnYsl}|P7pS`;nDaA&7WLOhtTIo>@!oN7+=Sit3GztV7knr?XNrg+YCLY~^grIlq
z&3fW-b`T9T9;mDF45kI`Efv$Q6A+EE>2GKp?hoKisu%(q6){pE{PB1U#Y@54;J7Fv
z2n70Aox`8C-2(G?Kt3f{Cu2<mFV10?OSUx80=4`XV3ZlgvrqBIvy*9!`<IU7XVC;Q
z>B@3fe1BDwaRO5J_+Tl*GBS8ZdgdgUXj6{ioWrDr$BkCmD60Ecev(U{yU@z;ra^C(
z!l-(;smB0rMy&ujtIfn!y-|WwD^C$lm&~J1Ru&lqpGq`)XAfj7<rwa3jjyXTPK&LT
zSlhxS%iM!lA$AFy;oCkDy8sq-#?f3GS2H=*Q+$LcQi+j9o-3elQ|X?J)lqjOu+?)v
zt*?gi6irMqt$%|#SA&qM_$pYtU_wX<kB1h-$m9TByny?Lb`u~o+u4N{{lSK$zQp8h
zrWPI_sli5KC597Yi=3BN+EwD3_I$RXtvGrNI35Oy_Um;?+U+VGq+xk1$Rvz;)PR_-
zLun2zLgSz;U%3U%g?uzGTS{=jqaH~LX`Yasa3J{vo$yA71S$XU9=LZ4|J$GHd;H_^
zPkDe-z&+<C=or?1VsTT&Uyi3?h>eD1+UA)>=b|!(YJ#mbm_B9tsuCD1S%j&AxB9D=
z`5vGLd8f;jiZnmVXIiVvg51Y_Aj&{sJYsrt4roO+PZ$TKRyb+ac6Uk$m=xTy>@tlt
zt_jdG97KBtxW?Zg9c-@31(@xn<Z#wsKy`pkD5={P#5%oSCfi~q`h!>a*>Mnc^q~X}
z%dCmF=zPqfxEAWwkonlTr%us?+ESbY`WnKxd|>$)_3K&9TON7@We3=hbJsb#`gV7p
z0WH_bt}Wf4x&2Qoz*=_X_P2%%NcK6-w!3j>kjy!aYgjBJ-V|9yk$slK%w`YM`6K`k
zN`Ue3+w0$T=Y98{kf3=f5A1+ii2|>=giOBEAsxvoVc%Wmr^>CI8L13>g}k&|97&@p
z-y*8&_OWMJK-tR_L2Dgz^Ffs7Lty9?3#4>LsnL5QOnBekC>ji-C#@m8Ro@<%5NFKa
z1uTBPqSuFC;HnRr1G-yylnj-k_I`jA(@C_wo;Fx^r<l|e<PgjvdMO18d^fvCCfvW+
z90E@*$73U5g~XBMRw-C=7j)5@BT>rQ&_>j9t+w2w#jAKu#D8UxXtB6zcHB+_^wmz!
zf*XLad{)HhsKk+?mN@)|T##Vwr3xh+%6}Itg4l@~S^iEDps*>+D|ZtE#~=Z?Qc&0M
zi787PO$D5gCp`sF4W3LZQ7q-c9)N-|J9|>+<zeCbuPX>Gt>bS2v{7TJ;fF0~Ccp79
zKS3k24UGvpeF&2NHq7$o%PC#^NCk{t%|LzD$AmAmnF$otCF9W6T#CfViYh}~s_kzL
zM5Lsrs99pfe5xf401jbH@wNdC_(!9>mNj0cz!FZJicHHq^Vy;<JGD<Tl&CAe8B^@d
z$93p!h)xLz4@!Ln({r!!`R@tXB9P*kGMA;XP=@o!h|<%bMw=^|=7~6);{4@M0-;~E
zKN3Z?({&&#v(f0VW&hHU=}B&*wi|NNrPi-rVqSk{ypE);*O9c$<Ld)jYLPx4^<E?2
z|LlveaU^)~r7zxxWR3zAXQ1qJ_+S7Scrj7-4o9KFT3I36i>>jl_^$)xo!=CiMnNg~
zx*wc}k=ohM62Jd!;z~wy!}Vh-CXIO=v%<!->fT>Cv@+~4wpC2Vw;Jf1J?OjIWoC#W
zOxG70eB&A&W`lfR7G$EBZrA4g2s+88dHUj4b>9Ov!$l$g|3>|P2{2%`WPxr_DnO%#
zM)XF@f11@(2;fz*lW3$CSl<y=(r>FkA+gty!35dhu|jz#)y2h!Bi>27z01`}r7X(5
z3DhxeP)3n7(7VeF!>RGVLdz$*rTS*ZjXhKr<h+>IH}w#2zlzEIUbXd|&@-xSvOC;x
zMb-MAnfQ^_n%@sqn-3SeGw|VG0rv8nQ@{IX5O*J^5}6!yuLBUK#&u%2uJuQ!3!D@I
z&)4hSJgu#b!=i#Wkq(5%YGBA+0V?jO#dFBHB&S;!yAKjv<Ov11_6VHO93$8tfSkkJ
z!o*rNmf6w{oV)h0VAcvy*HXY^AkCd%v+T4Up2JrDNP5v<uI~B5Jlg9UK+62U#uVg(
za4}5%ykkn3H#ITFFDL2bwpKqUN70ke5asgWfBIXAxPAjL^(Yf2EzmQ@J<OoH2M@z$
zh-H6#!I6xBQ?#jI`=4x%{cgS$z^jjCCBdi&GENVyoa^x26j1(%^VfUwt;aEsbx_13
z*WUtJ@t3@rS#7$w7ndVX0=7<1-6rp3KCBwx<XZf$^_4JdGr_DkOT@#b3ZrtJ{yh?Z
z-{!z<><ZvSx0QvoF$*yqw;=yfYWfX--}(E+NIX`dq-%MSR~8P^(=X=6yl{tN7Zb6P
z*ogk&6}oe)knp74ai4|>7#ujZ0H-*th+Cz>xpD@UgD3Z#A<JGr4}cc>wc!7`vT{4d
z>id9ngQnF!YN^t;g!h>QsGEQhse6FOQ=n2V+XW@h6=X~1K?o{M2DgOtdG_HSH7p)p
z5wt|3`1U13H|*g6cAkmDmVyc;3QSIDp<DdtavLN@1WZh_1VvV$0A$3^gNdUC5QTu^
z0?Kv#&5ta~ew8d53NV_MtEAYPnq=DD_;6i-Z>Mm%lS1U_1@~F;aSJhI^j9Y_48SH?
zdFOCkeJ6_Sv5OrH7`v34i~+25B=v0&m>kCc9>e^WYS}NHP?abM)>Q#&@O@B7`zH;S
z>ZU-^P5l*s9xN^BN8x-m<U3XBIHZE}Kx@^UL7{bI!7aLw55R-#2)?`Oq<uk>JbE34
z)f@g3kG!!jlhnq41ZpruR`Dw*o*<J~+Qi@U8j^AQ{o-OP*kGpwvIA+y1(cA4W9pbx
zL<Fo?vm|b*$5jmN2LIkqca(~=k|Cn6Xtx@l(f~Md9++Agma-~FK07L=K*qsumWVU+
zFL4*h5+RfqIKY^7#0NGG+N!$EvQCvIc?qP3!LCz4c!p?|#cF3THZs_Yc}kc*!aww|
zq|JMMQOi@1#UypGNmJ0U2n@cNKZK){9GFTGpOp}K;`jlw5!>q1huO@XW#`VQUp#7V
z(gF08phe~a260&c8HPTht}*uegqM0vF*SYPP@?@O_1RkDi(-4E+>9CT3*UpO(Jw&L
zUYf1{3k+ZsTyrGoYOPc*No(u|)=Wth?0*&7Ui?u3ovD`L?Eaou5@3{>bx)h9^U1`v
zZVxRTKP}98_$Ng8DJ0GD`GFMd-5fO$$8-s;0TnY~zxlGMZ~8E&4=4cTl^2-9=HPuC
zDkDgj1pvw*d2|MGK)W!zu~G^8xgdS~bMQsP)WTvO7Jy!4b*UCsVYx$>F*ZjKA=4Yc
ze8Ts^&F0;e-J+Rw?!I>z%->CBvEBICfJ)!h{kp#X=n7us*g;q{l6#LZZC7bAYv9`m
zjSmm5R(KRi-#1!@H!1LTbSglifgSP%be1HN4X6cm;5~7<DE&7fFKANG#^^7SN1b)H
z{^>K6PIF=agUt2Ka?+s@CER#b=ty`QD5YJrbjnINl%hs}x+rB1?dDv>u>pmk@W$s#
zL5?F2ZUq9Tw)ScA<+p$Xd51l2D=#<&PACR*Wfc*A99u6L5eH?ZA*0#nJo3s?j?GJe
z1V{lcEVEE%0sAmxs7|Fq^MFm$DURa^5Tejt&jG@=-t#>ATgz$&0~DR?4YMswKSi@;
zko%n@+jgJ4%Fp*sB5|qHf8wmR>~7s*S0&B%6qf5yi`oNZ@;;~9a{*JX<Vsl$z8Zli
zPv)}j@s6ihzvY)uv>t(?<+~A%!d@d_4gj4rtnvn4Wlo^eR`KNY-8$AesOvXGCPy5*
zGF8955TqHPNd;>_tQgSU`$fYDdTi=X%1t3rqa~e_%Gr?LnkTT_E{`!GXBBT`cD9Th
zuYNm?1fdT_3X4!<%}%j(8s#E%nTKKH({R(zD;VB5c2~e}jk(r{PrhUM^>WQi4k#bp
zK-=eoi80eK1}L$@qIww;udV5)dY^Up*f>$Yl8lEvd|#_Tb>#3z)H|OBRntPj^#db;
zfd0^~jY?X8`FdBCXSHHp&!lSg;!Da+4X&{_!`<dN#}F~Ht`-04P@M^i#zG!BWHGSx
z!ipOH=R<6{#Ot#*As5GL*4f*}2}rwBf|U)a3^7RBlGA7FR%4mJGT*~}>R)3Sz^9H}
zT%3RxQAkz(yA@)%(XoFy=?oqu1us14=@-#i`el&0)xaeFxL}p87DG`V2ov+k@wn?$
zFgvAJUU=y_p?zn#qViTX&Rx~-0185Wp-H#-0rWOz<$dpe-SK)K+Y$p902Eff!#_13
z#1PN-!$tY}q{kYV(F^sM0?mBeKp_CwK|;2{fxF)9>U@EY>DXxLut3(VZ9%~HPagcz
zOXtD%CRu(;qle-8q#n%WoVekJ?N=WBrk~(XJM>`5lblZvKypgTeoyAxy7LwC{f16c
z@tDb!G9&R=hu#f28*(b+11KF2H&2-O7>u99NE5ni?sx?88l}1xO21jD{?!0M-EC_D
z8i$a-&CZpL&cQSoQ2GnS2#{k=n29x<^-0P>d(`BJK2({WNZ&<zL9k3kCB7d2d_*s+
z1nbCHQ_r%YmsC58a`3ea^A+u7SJk#&)#5Pk5Zy`3X)=wZe}}>51laI%dj#qY<UI)e
z+T`z-J^F>YN+Cl5p_hl#phA?}?8Shf*eHJCDQu9DnW9IZ!wd*zzJ8N-gYeD#dk>6$
zjzM#buCNt}^N1oTA>ca_TO|oCUxo1iYLizMucJwXi)N?SffymtTx6RZYL`=I|Gu<o
z^vcmqmsZ&EZ5H+r2MDU!nx{sJD!Pu&ta_EyCFASTn&D}MD2=oH9D9S(izedFGvzkk
z)f0&E;%U%&6=MY#DMO6jiY{R8l!%O^Jh@4Y*faM)RMJ_#!}c-R!lUOegcOmG55XV5
z8@%t`i{18;3<jxYdUZK-LN4z7aQkNVx@q7CHGI<`u!kl#1N>t5@%fE?E~z*NURhAA
zhW?)CBgahx1UW3!n4!u5Qbq3sWA5~{@X`;z0~K<r#{TX0`gH`)@-nj&M!^Rzi7@_g
z;{Pzp!v+aKHnGipB(5;=;Y-dl?di*K>qir*WOr|n-^5+n(SZgDBgR)k9EOGL2mxdK
zPkFzei|?x7MvNV)AWV2`qx@bctk!?%Ks)BV(k)#C*h%^0F}T_G%j5oI0?Zk18~cni
z^K=S2?ex2|N6&0+XpqQ;Z7BRye0m#5OC?wJzp*6-BPSC91A(of1vC#2G`-AU8&fAU
z0uCmY_#Q|qfNHPeIs-!IJt`g?>8Qw1-!IvTUuLH>1{8r03r{&KmRkN+txYmg-Cc2{
ztD%HJyD^C!?H=zgk6<o5ufdsx$6gQKuAEvN1};0S?SJ>o_P@q~+5Smz<<U-uFZSLp
zdR^&H>v%|CRP0?Umyf)1w#i5m=HL)-KZ~!x51Fy01EQ;jF!pC(UyK>w==j~oSFIX)
z_P5KcA+yyk?eF8`UH25T=zTM7K>OWx=`!XACkDS{jJUb6$46d6!coS4WEkkP-76y_
zcq~D)pvprTwyCpxCCsx<Nb{o+C{B=|`?|u9x!&n*uM%&HiwZ-zNmNkq$E+)s#{{jx
zonsSzAYlR8<}ve-WWgl<^7d83qu}>~=t7@@0$sjJtv|3UfyG!jfef+c(^O>^H83WX
zFQQ;J5UNN4=cvq<z$?Z92$lVYfbGpCX9<V_2pQr)fk~ch=!6*SDFaIj62dOonJFKq
zvp4*;%V|-eaML&jQqrlU`dr_dv%-yH%e%e{pabuW!I&5&JlJ-(WvVnMU=}bVe6I`3
zHcM5Q*u<8=I4`4WZyiWE8gD}+drb!Z3tti>NUXOVQy}d3bE06w@un^qS}iX})xErY
z)_LOQr9ce15T*vRKQWzq5iMxHz~7RpoF92!>ARE218k}}zWmYy1ew!KW3ho9)|TZB
zfEbqg;?`EP2)H2FIoIjchW@Z@=0TyzO~??6jP)^mb``8cTClgC*hK>s5L-}~;MUp+
zj#Ys5+c}YboNCX6j`nq!dbyT3rh7oX4q50SE=D?B1k!d~+_QN`o0A00R8ogi6s=!}
zf>CEn$87g=_O%U!MqZIBrj=O0aZP#)0NW#R5~t}%j=@cwyd33j)QMv8VNz`MnAq*H
zU`suShnfO(0pTg@wBs=SbSwDW7MOIB0G<9yojQ{+T36ea8S<*BU=V4MKn;FIO(ab%
zuL3)eF@W?gvo;fr*R}?!cfadmP?2)2*E;7qTXvi)(s-4HO~y(QD{an5*QDK#yI2z<
z)&OzCxY|o1XlW#DVn%6Y!Yk**#v?=sX^m;|coU}Xk)U)<p4Pb0PYQGX<C>@A48PzT
z<svotzt;6bF(&^*5s(Zu3`z%>l=El67`lF^_Mizxc@xZSH+Le_O~OEeKl25~HkL?M
zlzH0LGMn`!qr-W7d~gR`3o}AZ2Kzz@%1|QF0KX1X;kYgWuZ-UBLvv@^27CqH(dmGv
zQ-E-Y5TRfcyi1oi09D(q;~8(_@nkDP>vaSOl}4F}LLD*?Zh5{nct`-csYL>`LzyT5
zwF5z<VqoGEwKoBTGOKZ<QLy3q#NmYMYzA#4zn}x#n`>8^f-9Vjs?O!2NosJGVA-6D
zFGDxh71WB<P30OJJh`W{tK`*3nmTIdtDM-{sBjUxNto;jE!>2p6Kt-V0lvslL};>Q
z%?R~Fi)HKh04;?lDp!D`N|qSi>Y`@Z{R|z}g)D3WAtBL@QB+O%e$#0||JI|Df2xD7
zd$sZ^T<^)zg`d2}RV)VHa0_&D+<5Kin+s3nAB|mu7G1ty#6k(=K1#j={LzMUZ`+3N
zBBmNszlW2kD&;o0pu|#u!5RzU>Z(@g&DDhvLSI!_;$0+}-~Ylo_QyiVigp75-L8QC
zcXmLS7?Tn8Kv9xGs)1>fQAa_E0fDTd7LsFl*VWs60-<pn#N3o>q5Ac}EHlf?K8GYe
z{G6kHl6eUuPF$ntwjg<I&&W2~fM+o-K75Q%;N#QD^wVI9v=ISgK{9f7*Zy1^lX!r8
z@l#X7qqkAgeLlluR`i$m{ijH<A_1U>r&Q=H{XYFsL;<5qp6Fl$nG!e_fP^?E!5zD&
z3{(2hB_UNOF%MshM@JlZn-_{tm8&wb`48T>uVS4#DL2G-Z|QEALPgi8tfQ$Cprbq(
zTV2=F-c(O~+8h2b0j+r*^+6%kxh+@{FL%ukq?G1<_A;{U`*aq>{dv|Dp-X4oevo9H
z`Z@eYA=5$rj}aBXGkR|bSWR7@ll`Eyy{M~S?8F{a<|_q4p-hZHl=kjsdLGou;FIcL
zh|$D(4TbAW=loNYcqcQziUYYw^<W|j)4zrHN}#)o(boEIR$eC7iXWXf!kk%I-t^s*
z(V<^J!S2H9crC<*8G-%yOPp$Kj<HFrP8to*_~LBn2%-hWZuP7RV1vfOjQmpC`B#Z&
z&0~@2F*e9X6Gi?4D+gK_acGo8RkMVKQ$K*WnP1;@J0v)%j+;Vy+j;zH)5*iO{q;=s
z;L*^-G|kXrZ8h^w5dD3M&?xrrF3jKa)@S2&wwDN6zNFL`^CzrueoEPOOc*w7vRK!(
zl~r#+3uc{JpG-?kKz!!6_g_a6{+DKIt*I@h?`uI68f=&$BqK<YAv~)-5Dhg{Gt@^Y
zZ8J;*sU=Kk^2MpEA|kjs-HPu%C!4Zb)`40mzZz39YH@SeRdly7wAziPx+S_Kv+vxn
zRej+^H(Bp?3vRNd#CPcRqH&PHNQi~P(ODgQv)t#Xkv)Zaz~IWwhRdLzhZsjLt!zKC
z^W#cfKMhi>cJ<y=!{MCMeeL6!M1eym=O2y-i43hGLUt*wT>kxt$INvY+CW9ES)%IE
zd()N>iCAb-b?6SW3$cM>PD{_JYW>-d&NA+zjie$E0nWV&atlQ-1%vLYA4QaY4P<)T
zc8ETWa5BOfK%3(Av4u^Nv=*Pyh4W@bdJ!eskZQiYkqWI^%&#?f-(7JsIyk|8p@1t*
z8$GWB@)fsc2bS}!a%dr<vJek$qAMUixt<DX8wU|wCH=He5_NK+hgV9BF;I+<?KsAW
zH~b2r!P_1;NhL0Mq8<ts?Snj<_PbPKybHRN;KL0d!0pX1p(vQtO-6RKKaJ&eCVmD>
zso>?RqWcN`+iQ7Rw5{&qoG=*eSRDbv<uJpJS}a8dMm3_;LvxkaLSgj8h!CTeebfB1
zwx-aqFAWSTzJlVW>w=IE9bTRjGC6QenG!;N`JEvhv|=XhwCA2*5<$KN+Z)E)4IjFi
zx@UkhfQpj+SEzovdwfJ?%J|iRc5#|P(j28JC4#4PT;~8vkUpaZOQ<qc-wguSS?ee8
zyM*Byu2W`;KKb7h*<H0++Y>f$UGPrDghN`b`Lm-f=M~v9NirskFVQ;cSVb?s7<VO7
zBxf`4sB`e~cdNTseaf8eNSjcpEHpC0o>6OSfZ^Vj4g*F`h#%~Z6^Y-0e9_f^zLLz$
zY8S>b^+m+C_){9B2}BXt<U)vmwcP0MDm$#by?AJ4K($gw5;f91h0mC~cu2g``f$~X
z@7M0S(NUJ}r)7%Mc3y}bSMlWr7Oaa#D>h4WK(~W3IiWfbHH8f<26p^gfKvnG;RFTH
z!hXVnEm$mI<OCfF?oQfdwO;kYEW)G?&UqKny~(u`Y3)}|e1(1WS_B4`7w?wWyOH-2
zWBau6<>Niz;tGlDGenH<!@pvkHfJk#T3_Y$B%TAErz*<6qs{gR2=fvir8tL$NL_s0
znM~rmdZ}P^-4MT_sBhm~Jm>H?l<WdnJz~vBILx#==ZQi&Z~D@nt-@I&?x$jSfehoE
zA@#VLLwP;FlM{p?LS(n$uE3b=XbBeR-w6mr@uL*u{CI`$I@@!oxtx#kzos!2I@s$F
zolZlSa#P6V9cC#GYb_Js5nC{S89iQXPasUYGrF{*1*Z3!t4cJ3iFZC>?Z5$^mW{oT
z0^i_)R9FFUZPowM8P)bapi`bvZW%(sP7)Zw<)<ZRH@YtF-Dn6=1YiS72nu1qM{3}}
zIR?m3NO(Gp&d^;Ztb$5+uxxOxcfmlyF(x-{zPZ*Hm0!$~(6BM+yAH_)q+w&HKg4D*
zvYIS)Koj=U9Q`A3{8RS!)D!@my7Jch1^zFgcZ{h|?OQUFfifdtbjmroB_3gfa7*Ry
zuM!8O3a>T5^4h<9>?#?=LTIRayQY$Oo3KN4yyq|T6V;(h3EhCJr1SjE2JPQLpBNkJ
zm`_wOd7TWPyp+(din8yA*E>HdkO%obh;BWucyEWiIiN&PI){S!=hy%)#$P^I=4zIZ
zgwwS|_KywzP2P>of{iD?iA94VkYi0w!^=dVb|twg!t4*6NyAQ>%2QV!M_O4ZR!#;4
zsp1|`QD2LS1pA!}-6-bdZ9VY`m?D6nCs1+Q_mk;ikcx!@cgxEw5DL`1tM{0}c?W2_
zq<T2{_64!0U`3}lI4}Vf`4yT0XcDP{pIl`qzsGf|)gmNgLOHai;s5Z{Z`2udjakDR
zL*rgs$!Vpz@M+o%346;7AA{Ypb2qAhH4V=BU^p`?CI;wpU=nyu4Fs1V9X&x_<g1K6
z<#7MwqaN_q*-i$}Or<UE)VcQLjEJXv725q7gI%#sZP8SyhjM`8<9m^tA$r@`Hu_}V
zRhzF`_6_;SF_v;yPkaLyd_duIkDhkn@6Je_<y5b(@U2l@OyQ{vqsFXuwF%xAmI;^6
zvNt})!iD{2BaJIRatf@V9d)o%0w?j=6|VAf?ktFD>%T#Q6kJD2n8{cSok9-;H9k5}
z|N0$&Nn1eUE5QO-X$z%j*gzx;8S7JR<TB+4C4ZavifgVCT638I`gtJ;nuBqcf(gEy
zZr&drMC1g!-OqJb(0e<HGAvsHry*b)QYwq?Jro+|SBX=~G|*(Z2T@Q(48bI+Q+=}k
zB=`Xp)cKFZrF;TEt4*M$5I=G`k}f10Z<U%$ajgLQtQCIz?;QxA9;1(XY8;ZH*bVG8
zVxF=GKc_OJmoiJ6k!w+mbzi*^Y_hS}LbAuJMQv}qK$qp2=(HxsAK{WhTtOBV8n;Ab
zM9n)bFy~)SVj0NbPBUtUhZd?WuE7pItt>7>m6+9QxYG}Xgmw2@C%an+c}{9rFM(4V
zSnGEdzB>T8%^Y@=1wGNh`n{<7`0zfrDK4}{;u-6?a?9JD>i0+!4T;fRuFD<5GMHPh
zfkO8Bf8L5b3ZYA-#+#$d`SC&$lXbnj%uydT>UWH3PgP-o+%__xqmb=J!2t$oP(3JD
z2@KwmsCuaoa+S^q?&NSxYG_2&e>L^64LpJRZxR7v7)rO38?TP6{riIyhwbgNBrql9
zbLSnOUmyL&0IxRAZY*RZRjkv-7#6#|%!nxH$9zrUlt6cip&=M#Ag=QV*;0_@8Fcv;
zu&}2YSX4Q%SWvtCC694;o0dO4k!@NAD{_k0Z8!8ca0RYXt}db3CllCN4RSk4{Jk!F
zgAjl@x|tsK=4_`ZVpg$WglQxnP<Vr3IwugyxJlYuLTu^VzGhRr1c#VLw^Vs|NWl&z
zcN-h3calN1kPoL*Wlz&&{>)6qO3Js`+856ukxxJ7%VkY!<9GStEqEN2_MmEI>*sFQ
z48qyBt!M5%GxCjK*cO`&QU=AUiGD=2o)>`FO5Z^fSj}0P(xn|Zn}<=ai=K5b5ZB)%
zaKGyNj6N4oRk)V=#@7<M#F4p|X>dv@a;#n6!x$DPXv>QAjHFVOn_bQpk3O|FkG!Ff
zDkTV#7h@ga{AE@ajb)&o6PKu}K>0&sIiw5r*xjV{8}LWGB{dMV8rxwhFFY;Yoj(BF
z)66mb<))f8*oADyD$8c>qTG7l2#fK$2B&F=>gC7F%E~oYFXuoPm$&=D!*|ygR#I%?
z<iV1YC^KoYR?rwH{FJ>C9~3Q^@~S)2qr7(U1Kn*7%;oQSM{bWJztor-aP^(V!QX5I
zK{`9k4>nb=sbp)lBQ%juFo{t9j$D9PNixNfLwFRbsCE3BXjCe0e}^0J7mm!i-^AMn
z&3)>%HMqHgMxVRnu56UfGT*~YER;RL^YP*7mLUlqurxuwNVy>HIsg9n`BOXmY>J=b
zc8E>7Cl@Ng82lB8=@1xBq%W_tE-+)iui7vi_>0_YN--{=tRv|5Ztgv~>a+lD8z5j~
zv^O0rlb!po12rLE2H<b;j3*Q%Mmgrc<n&=~25wVmeeDt0CJnER*-6aMk#fS0C89^e
zzu0~6Q{a=XvUQkX)Tma<bjZ=g8^jB>?8oWfog<_S;0ZOPDfmzdwuRAkCNAMu#BJM}
zAaRqJ(yH1T3btp;kH+T?GLiwiDl@iGP@a=_^2(W>ho03O#9p<HiTJG<gpV(Om<_jR
z$Go@a)k{YhkeIkHJO(b{Te=O4ee@YRJDMtH?GHY~R%>chehPL#^n3@g)H#l)Qm#N$
zWYzS6lliNVhN`bjR^}?P5Q83LrjS_XjlLk3g3)J64KIZ2H&emCEaw0rm06#cd&7=2
zt%}#f*>ZHXiI+MKyJ~NG$R8ne{&GyBAAK|Bl!EI?)4kkZHQAEp1j~R(ox!hBa|)tT
zG7TC<R9qg8zyEQS9^v(@2TP<;5vP1%_*Ynv9#>nvTWeLU(fW~jmOZ(IuP=iaTet{<
zIDseJlam#xM>*s(6ZrUT>Dkj?FaK2h_=c()ew0F>YF9$%>D^Agfq&WngZ~E`IsOY9
zL6{lh5&0<rmpWRG>n*7NrmJuAHz*bMgnUM{;wD|@R;9^Zxa;Si1Z&Nz$?6Ui=dO;n
z(FuSNi0pgfW#=mB;~}|c$^RX^c7ft-V0fse@ju8Un}#{&iF&&@zgJv*HFk2I1Ki)2
zO&4~dL1~B%#>Y(ouT5oBW|B^&r>lp~UZvxUtKDdTYM1r$qboaIyD4<rrt%~9dupQu
zIt%-+?D1}1Pj5^*J;tC8`0$L45GM9KsQg4bb|Onb3iN$!g~WD5;cb940v$>HHq$h@
zRG!o#;8cz`D05Lnni9tkOP3CJuT29l%DUclhRY9HOj#w})@kJU7+j^{yZ6tR*fD?m
zvmOROa?(Q7Vr-gZUIgR#;PB~$$j>!yxG#c!6<p`+SG{V1G1mCS4DylEx_W(Lf->o|
z=Je~)t3&-Z>ZGk&`hFQ>5sFpqHtu@)m1|ean)SDiqWwIePP2J((cp8OvmAYL!Bkl}
zz~U(|0)j#<H9JvR{g8;GBxBe~j*z1OCvFu$oovL`rZTqUbf{wPI(%8yvbMQZ$sQ^%
zEy<D(&sj*=s*_UV0B@&$#c_w4QX+9g;2N|#W{r|CQGDvq-S+1oo{iVX%c7ZITDTe$
zk<7?z<5>A(RunAz&D3f14=MB-q~yhAJYmyQDM>DB<VAncmjQ&5s@#|0KVXLl7}g~K
zBPfoGOa<Nr21%`}OwbC~kkgdn=?LS;D5Ks8Bi(}fFs$7QW35MxQOv*=Bc|awhA!ff
zIKlKb?sB?HZ96x;)$KAJ{P`xEMl!`DzLCzJUtpy)1c!F=z-_Uej-L@+o@q+ui44M^
zH|E*d^xj#<>EQHaBJIbvoJuuItTHbk%LMe!Cmi>uc^2nMfJVHCZIBTX-Z-Taav~&7
zQZKzK?flT*kz(!0q?5k^|IS~eOFi@FsFb6Y30^H+?ir@Qza3Bk2a2;q2q$SG5n=?#
z_46zoDSIU)uG0!&1wU=waIr<zt$hu>RCUD(i*4{)hfm0(jYIztXQw91-V9*=`z+K5
z&ch@nGE2y@uav&`Z8SkATYiHqK@x|em}bc<W0Z1AqVl^s-pfbxi!#<i)K0!KzNdFJ
z*!aofFr`wnF|_37P>$t?$)8CRhgmZ<+VK*<JS6Yp{E)mL!_%<B0Tf4-4$e@F6UR}W
zuHPzADZ=j1GUd^kJ#wk>hxW_5zA+ES3R_c~emUKHJCifO1*((d!SL#8&Y3PTO}X)l
z;#Y1-d;6f6w@<%9G-%IG$$pCP0`mmhSsap17~z?XXy5TjrDRxiIAbE&5Fllif+XA1
zs=^BtCy74l$MJe`91-aKEEzQgB98mJO{<^$Y6W-ZKhEj}!&Z%IXh1UWW!oy?OjA(y
z7k%#+G;~wDq*V<h2hPPyD>E%h6ek#Wzm-3&)V&)1`K76b7h~qwa>Xmb;2ZfMG}=s!
zuEGhEL#~;>CPO7^c(TZXv;6sSkq$mI{nV^%pjVzp8ChbM){L*=g$)As0Wh36=f5MF
z6#EInDNGY=Gu61bH$a0~`ZwNk*Sk7v?lVJvmWk(ItsF^|$;tDxFS-<gyS5trL)@L3
z4*LR3j_eR)xI2@S%8tU))Bt(}IP3e=GII;D_D6i{Da5(CL7?(Opy0-c{xnGy9LE`^
zeyfH9&GfAyHJI)ds$BEuQKl$Iq4Hq{P7XLP6=aK`WIknPUx4e6#mkZ6>(pg;rd;S5
zDk4r%)6@$er-~<Eq<r%bvJr#b|E8%GJ`Vl4p;h6KrWY}jW{`@@HO<pTax+2)Q#(Lc
zdp}T|d=cUfPRbUyO70T1O6H=2ybb!jR`_`LdE}q&uyB)*KPPe?T;~8~zA*?<UIW?x
z2A3P8<|>~75L`!|8eL+rNrRWvk-If?v0O3T#1xaH9ZYV7EJ#BTp>lG@=`}dSF)11s
zWrBQUno#AXgQD(aD}L|i`n~1a`#tmbvPy?knL@hnq;rK8!u-_GXVJl@UvtPHP;Dh<
zLU0_melgBI?;}dT9X)>q7v6PP*xoF8{j&&LfozEV|FQLzL16^Vwzvg{1PJc#?hqV;
zyL)hV0xa(C?(QDk-QC^YT_5+mPk!82UA46}vo$|vd!|QDp92&gACz`XzBC^WoUnK4
zzwgMYY{@|l<J^rhXukjE9wrI9<Gx5^lYdQhmkud<X9@0@7ePM_2Swy2{t?ns!4k>I
zLELMZA<wk)c-+?XbfC%Jzi#Yeu<O5Gd;jF@`U~&KFsMO5pcgT?uUKjdgkmL||F^~7
zzt;wiioqALuXH8hIyxx@=KCY<t;UvTWFnVI5nJ2GwGb*j3?EWw(IFH~^0~sj@AkI8
zu5ZSX=r=MK?XMND*Q2U*mNw}&-=2C!)CgLc-#=RK|9DngKS%2@mmCdNraWN_7AiwP
z-=6G!iD~%24dZ~N>NkQa&nfW}!I`cmOO~kL&tEpc_VxfW-ya6EW77;Eije-;FKMod
zK&H`x<4h!SOxZRPgtRwd8BkZ&i#@85T=3KBbe<=)Yqod>Ie)()V{EC<(|O)1eD@Tu
zcH{2aZi~np>kfq(#>vNJls&-3WC!V7xw3cO*j}F=e^2X{`*(fkx%rn2k&Q|y58urV
zVL3=Lce)P11OLe;i*y{t?8|*%Ti?yaP;oC!DWSZu@xA!{FdatyiwpvaKK2`y$^$6k
zDPEbt_6NuyPCP!N>`#PJc<<)MlX=U$YjZb~m-qXHaj^-c_A{g87W_0L(25eH{L<+F
zZ3yUwhvXC#wAf{f48ulA)o?j}+6+EB@3c*p`!Fv+U^UZItNI1eR&A4G?#hTfmh&i0
zzwrf5GGEWHqeznxZN25}L5A1qlv1%t&p?{7OJA|?#nzT3$Oy4;h(S})R<an3cbcAx
z_4R(-*=>nbl3yA&4vAv%)mBd#!BlOIq614>zFu%fam6f2J9W}xvE>V^WenVP=Qi*X
z#P9=ZBq21NYu!Y*ez1;qtl5GII7WYPQN&J_N2cual2q<~!zq$6A4b~f0DrG%`}a>T
zUnw^0rO*ymSB=xOfY`@f$HS)xzIYU6)$MMRjg#G}uh`dT?=jrLlUU*cOQ?R{>Te$|
z$ZMUVohmJh(tM_0LM*I(a&-5gFHLpNS_ljhl&mQl6#U$(R<heFJYJ9pFg(xy$(YF&
zBuFz$wy?6i>(nBR-d7LJYv4F`<Pt{NVGRjsYOd=;OsO&hia>QjfF)=buQG|Ets(Oo
z3%S2}e+`v5+i<M=ff=A6yoldy!y_!aM0pKYF$fX_X_uT%#IYa~3vVdbhfXTldIC6k
z{<R?X<e}NL@<4Sm`Ga-}%4Yxap&H$D_nNv$i1=LX?ugP&o`b7fyXjCuW{?;<6-u1K
z%Qec=VdOq(%zz!q@x(61(_+Lwn({y&*>GzU$oQ0$lDoX<JuROt%a3A7SKhZ+wLoya
z=3v;5y;bdMN8vL7J-8B*qz}I{9SbNK@Atnlk^7-<*98US5VXGbLb-YO3P$2%!7xQO
ze7gx|Tt9^~)@9i7f46Q7UZIIv_4>H7ZkFsoR4gk>!rAvAHWJ|wQ#D7yxr-PCITc$#
z5LY=(!!fj#CJlzqTv{)$N=)Mey-W<sl3s1r-Y8^)qYyN|?<&M6%+L<5<^sN!HisN1
zvw6lD6JH&3h(bKY#~^bu<97PGT>9qRywQ|E)Uj0lcuZ+Zds;+!ly7!6%`h@uh_zL1
zhC{Z<v8Bd68;&_!xLryX+uS^aZ^E6B!3{F&bkcY&e)cdg9RF5gn34svHFMO>y6_7H
zr#^b{?p($m4{_L>mgS2Y80h0fNx-Ik^IZ7VxLV^GSq77lQ@PNHX}L1zb`T5mB7md}
zxn4}Blq)p{gQ(f9@13Wd@!hsO<2zG$H;l3Lm}@syj`k*9ufHYx`xNztS(e6dZv4ip
zTQIT*23&dO*TRH3l1>(pGrBw@lX$?<oSFG7){E%$+)`qiZB&{47^s(xWIuU1W}V=i
zWf+bCJK|#T^((wiraPiqh9OX|FdGQ>Hfv&d_o?gaw*;zfzJM&T!k2e`8`k<z-SMYE
z>(~q`sD47&`rf^ww#j4O5W_22guR%SdZ)6TBu8A{$7P8P-F)A}@Hds3whVBYy7Ytk
z+@;y291*)~oDqi^0QVp{Z5JDX2;7}iAM4Suj3w!F_ZmgC0(W#pG(KVR3}TMrTZy?@
zE@JhH3C@9R2W_+i7<!@<pOhj={>okN=sVB3>Jexb8V?eo7Oy^e=i029f^VR&frdKG
z&*7uXzqV#FAuS$)7$}{rVu7VW9xJHdBE$HznhVtCJ0%gn0pB=<5p|2ZuP993X6HV9
zXI3<U&7r_1gxS`8&PaV2@kFcE=~5SjHTkB$=?-Pw6b8!H56zLjYo|7Qsvy1~GlW7M
zeem$Pa<hu{$;mB#mh`mJzCO5A_3h@GCR+PSIs>_Ke4VG%<5EQA+ykC%_{;-G8`(81
zK7mi{nIBgajJ@DL+oB}JeQ+uyPL}@*B4A=?V2<mCrU1q@t!%KHQ9dqoyXhe-@yAF_
zo-`n!_vobU`f-s-D5uyE5Nk<RTZUq(huxmPl4emGB#HVH+g4jWqMNlY#%y)6wyn#h
zRj`b$evh<x3mS+l5C2w~P*1TNDJl<+4LwsHQtub1`l&KpOT$3r=0-xA(9TahGV*hh
zN@Fb5k^um58&we@BGeudH69+J*bN#Uh1tV_mF9tP6Rw3Xd3&KNhCG}IX2g$!W?hpC
zFdFdPtBdX%A2aq;AmPUp^l<K(!W2QYH^8NY`{f<3jP4hQa=;YCyk^`_#CgC#G{|Hh
zs*V|R9oim;;yg5sP9<muXFNe|qUM@htc4P6DF;LfrAUpqQSsQa@5E+f4xwl3<Y^W5
zd|R2U1$>>`?L>C+Jy=Anu*fJ+VO*F;JBCa3+OC3r`66K9RFlZXX2dA^IH*ITxoa*!
zeg|_kL{|<r=4Y@M&lxjL=7M7v{~nPX7z!C7r_TX`<_Fz7Q7PUfBce;<{bGnrjb^A?
zlMJNhg)R?8W~UmJAHhd;2k7zJUlCHZ`cIP5E!gJAN<r~tdts_(+R7A|j-u%l2=9kv
zD>(0m6xUMffG8}B#`GH}l&H;MCur9s{IgZM#=gn7--5uqTEyv(faT}xzwuY)EV_a4
z3TNF%IUA6R+4O7QCi1sstyI$<gOY*)od)t@1@YqW!L_}Wz3HT>n1)3wC>{G<u4GAI
zP(zf`nT12rS+(tqRpZgS#$R^uiHZ^ADdL+#`#0>Z6cJ5iGt*hC_}3$qZw+i&`7FHB
zCslTr%_;xE=6v3iyK(AFT>j|2w#OYczDT+@WqQ*8kZ+F(0f`v=Z8Irg<Wpp<uLjV2
zaHWk4o{w_{>6vE;Er9PukB3wH{WIAFI*H}o9?IRETxzHm`DOoHPNd==giX8F{IT2!
zb?r@X-}P8P={RVc#rmK+aOk#pf?MEGmdz|aNHG6k19(-(neW%b`dwK%(#Hn!J~2%W
z{_Xbbv8GHW?w=@lWp%heyiLM^WdJm2G{NX4hVZe>PTso&^-kg)NHGti-syRyy!r4A
zd%1~Pfi|5>{^q1FgQHms{F~ZUD*phpR3v=9qix3<>s*sv<=aucrsU6%v8YAAe!Zrj
z^oe34Bv|}rl*B_(KRe*C49}!<O-{Z}rE8K(pAS1fD*X9Tch9W3JYOqBHh|j5p@K)c
zJ<JBNiWkdm2VsSnPtKXXm3zi`^9C&9_dYHJTx2Ucl7mHdffBcxWF*~)99H3@y2Da8
z-jAjiCb<s8^)_<HUAvsuWv^MG`p0J?Nn6kOs#gq+yqNckFL1p@{vk94mUv%~XX&~!
zP<DW;m|lL}My~$Hp=IEf7x-|Ga>?k3YBIt9xXaJ#Ojt(Br};yxMqxXL*gQ)*1ENRO
zWdFX!QX`z1jCk><_jI+pcrT>e-tk%a&(Jn#hv#N)`@s^zm6)bz^;J?LO1V>uu{q~N
z8Wqi!3vacOi6!nF)~M4TZd<3V)710d#mx7KAx?!GOeGV2ySxEgSb%_lKna(aXb&P6
zF{&T+qL|yrypfZqOHR;j+5xHtbw|(P6bQchx_7vf@Q^FiOLQiIWIH6A%l=C;l?!8r
z?(ye_bl_!S+<rwSePwFiD8D48jd9Ek;ERI~-D|;{(T4vCHJOG`C?Yk8;VCPlDOhq=
zA9U&tg?aP#nFzr<3y@W*A+*6KCpX05Q74_|wLzWP9Ms(!;0-hU3wyTFQ)nx~8V~x)
z=k`ZRnKrO(p81zmlm$I>k~=$7uB860oL5lB_0dtT?Jsqut0Ia6@y_*wBO%e+)ThSG
z%w(%tC1BD$rDVogW-DMrgDbe#;HXr|&3HMu{Tg;~)Fxp2#f$Bs$Lg*=B*fKw&XI6R
zy#F)ee%`~26*mc{Nn}Dp#s<3V)Ue=}6r7bH)!<4_6*{z`?ts|tb-@RVx4`bSwgYb`
z7Jb_E-(WTY;yO#=fPpMzP_U|HQ&CubY}Qn9=lz=~LOgem^Mb>`%T{SW$YR=EXjoVE
zz1H^DWSPKIXFwK-?B!1_l|3TaVe7x2LyJ7`$M>VR{%y9gbXEetd{E^(8`3+L)G9w+
zYwejR(z=c)v?-27s$>EOmpq+4xpCna8E+89VZ4izUk|%?%soC%X6;!!)K5<5$L}Dd
ziM)tYRc~b4X6&2agv1Yta`254GMv35L|h8Pqehr8;(&SkD?HTWc>{(NnLnzByVLVz
zyIn2S9?Ur5KgO@znOd=b15Rb9osnMeuj}ZP=OmYX4*p}fq~tLp_V=w4G)=mQCYM%-
z7ut@x4%Mq6&Qlcmyb-^6+U27i_7Q$nMS#tV`j`U(4gA?FKjf^yiVc9$=qz(IfdnSy
z5iLrG0$?nGN%cQ(|M%sL%2<`MRdQK*q*B2-p|&huyWl@Xuae8EBOMA43AI)6o&{&r
z#=4aMDauhmO!$&56Dq)=+LxmYlH^nx`A<=KykP+j^}ZVApd_ctNR2{d!p*_&M-=FP
z{sxqnAz&+H1ezk8fH^Te28XF*$X{7WA+NP=%l%_C4Z<B-*{o^W?;x+NvV*wS;W~9T
zkH^zFIZ^AQv;59kSkY*VCqh&DE?LD$(1<x!VmO{t&MrwlEEvht_)^(^-aP+|k1Hm~
z?s{rhVj(G76AS8&NY=d)wV%uD5mGcVK?XVR_V^RXfAVzp0<rMF8a62ym2@;M)iv@W
zc(?dVurp^=UvDb^jL+`Fo8r5#n;f4?p9<0$Tjic6nXqu#TFCflcAq^GoP?S%tXvec
zfoz{o)(PX<IjRTExkum1Lub9r)0mW~)5>D7A}e?DP#%BDhr>8AuVnHLk<or3W8>t?
z)<Ka@C>FW=fKFPmQ>XBEOH|x;$T{QcSeHj{`Be3e<trHJR({B4u^VB*i7qS6%#ivv
z;PZzp(>jIoXkF<8HqWw4A2TFKG@Be|hI#Ii#kLXop_Ns3wb(XG$D)8f6dSBn_Rw^K
z;YEWQGw9<Ph#6G%gnlQlr&#xJBJ26ZEZA7lJ94)(P@riDiefN2OOkQ!g)do%9Zm@>
zH`e^(G&}Uj!i+<uDl)6#F7UtN+4?m%&6WqLVIu_jj)&}f?v%!tr*AslYNRdo${Wmm
zL+}eFhS-l*))yn~9S@xgEX622(sceG4`>B3{#ACQqXlS3tcCUvm}fuu6}6L+GEFV@
zAlo-}KuOuTadFH9v{S*_b7%w_+%Y@W34*x-M^o-pC{bS8;Vi-AW+iPQfGKrqNftM5
zK(-@40po<QLYE&3#NrZ(r8$S#i>BFg98r`v+P!5(n-glK?KPG-TWAyBc>sxmz;eUP
zHR#|};Ppez3lTAvGl3Y)tdN(W{@&iw2i4#aI8+J6J+HZm=k@Z_J(4W)<v>Ocz$b+I
z8wrC{kJ393_=6ThvFc4r?|k;4RVCi!^0h=!(+khE*~`}ZB?hTJKFaE{@og*3u8#Nk
zT&t>eS3rXg^9!>=O!fVeA2U1hCZ(;J&LqAkiiZl~e&*Ej8S6RM8P}6$bE#$STWskY
z5zGeVr_Zk^c>zxjz0RfSkD)>Zr*Hgl(A3ta8K2-~SkbrteXh^^rQ;I=h7QKY`rl+P
z=NX!DtBv0WH{U5A?AXzA`y!G$NK0nziYk~ZH&^(Es4FW<R1_#F(H>_pK<tQvg)+5p
z{;H<_{?dr<$>Qk*N9N%0Kawu_$Yr;3Q*@Bgm|k1s@1Ph5&NnyV@i*R{Asd_nm}rPb
zZ8kfedLI=wref=jrEE6%`lQ>nH{Wi7hu7A?%}kfaqH!-5Roe+0)z<r~?bh=X*E#(D
z^Rji^c5N5__3!0BjQ_3<wE~^*qhU!l?e#|RZV@Z?_Aw1DL#Yf@0qsMjDE{`_bhY27
zMHXgs@?W;-6g)i|W>t$TElg#Q>8J|R6lJzqw`*}VUjI~Y-xU&CDZ^Uib`YEZ?hNWy
zuhtD8YL<^>PXFj4@uP|^t~oraLOMjH1XD{DblG)ZceMpAxZb)&KSh&1H;Z0=frYZN
zno)F?a1fVk`|g*A4XuF~#$e2lMbMja%3E6~)cz>5tRNpDw&qg6B(2@~v9?|Pu68zA
z)cdTI{xW~jq<vgGTw_R@Q~!JhoDuLnG*)}~a*mNd#Fq>3aTrgM%V%E6=gIbJ4RTfD
zhvK(>6#u<}2(c7byrFMle=pSap3;ocpN4k8^n}kb7rf&zj^dNYLuw6ex1>OsiQL(o
z2ydO&yRoj*yf6L4n+v9UI`5QJzu3fmJlU>0m&tfh<w8hRK_%NmgZt?Xw3JiLEF6Jy
zGC`McWACPD2+YNdM7o#q6igJjuV^e^CYEg4v?}YaUAiEpJsxg^FJg_w*VlX18us?x
zhr<*WNtZ&iT29~lIiaM;=8#MO<Yy&t$geicgemfCQz8caPMp~k#9$?{96IUEdM~Ao
zrv42e{^nJ)AY#M^8Os6-fS6(CjMRziTkz7SvzYmJLJi{PS7W>U2^f^7`^^$P!Uu)6
z&jKZ~iYmB^%yTjM?x}jW{yKg=2aJtxN)b_Aql<p`&TKa$Y12cf4Qr?9`pO489U`qo
zvy~R2x<?NgPWis*6bK{#53kn%>44!8^H;yX6^F4bpL}Mvs-e*+aNhIgwRwEeqRH!w
zb(79=t_YpQr5sS_4(3iz!!fUc5%Y|0GLvtIQG~W%N|r8FUfYnVDw7J4$;CRm*#)P0
z>b9LfyqySnmn}lo3VmK~KePAd_k;S3>%9D`>8pZt$;@t~W0q_rPNqz}F1A(X)pg0T
zb!Xk}p9)Z1u$m8?vYB6qA2Vas6E-c7t2K4w1Y);h>9i9j@U98FfvKvPOU{AVc1}zw
zpDR!P(LV67Y4`5O8q-g&F~myt6{Px`9&!Uw6rF!y8GbAHzFS5)99lMnjKR?Co2{v<
zpY!D;?q^=GLW7ilkG?+S!pOHeWxQJ(qL~w*U*7*+1OO^5YUBoagvq_r$PW5fJ8(s3
zd4%$r!r*A;{)M}y-aph%j^z^O9U@_1{@tVgaA63t8;lHk?2R75bIIlDmgbE44Yl^F
z{g2!DrGqK%uIKfm2U$-$BqBr)aZvbokWUF?er;5Uup25GDX~+Uzi`b3;<~jbP3`eR
zX#98Jr4^uhn5cnhXN705H~yo2{*+_H+fidF8TBtb-Wr2;i@RI~|E4+Cgp<@oM<6$R
zOfZpn@aCs)h>|ml;y&y|AgYX~&DwgE%(~3``ON&X@&Z~Vi``=wB*vJ&ZOu2%CnFK6
zzqTPaMuu@=iAog-@3S`p2Q7cS57f<}blD~?Gr!W@*g2E@86(H7MGy3xXP4obsS%CY
zV@Bv&Im^;nIJ4G;;ablQ%57)%Y)AE+(Mry0)9OYf;%=9v%d1cK>w0#{f;6EHCB=<5
zN743&ugVV=b4#?5HmtqQUJRVHOfaS}TD9zTdUg;G7%rBsZ9BeNup=KqTQfh=l4=##
zv;iW^T)0$ysR@*_u-?JUG19@$EA&zz9Fir@a9zpqOU_bAM&h6=u-vs)&i3uwD^vN+
zEDKwv7NV^lAHkb`O(xF|x}=>S#Fv4Z!dlD|{C1-3a$<bL{{56(4r?_%dN70&E@Z;o
zN7%$2q2z3rOjTqEj`kg;(z0z8caqoL6dBlaI8Y{Jc<`#$^W}smb4KA2AV}a%{&GE0
z-d+oK=4w6Uem+@e*!>HPZ*<AMTLu_C0es@dNOba<k!NteVA~s~YB<aIDud_wc&@AK
z)0)M2P4ey)uGR@ei9fC8;Lvq{;-&ccY+3#&)D}0!fGM$G@iSYGE^Lr>ZO2zn=L7Is
zED~QZe!r$u*D#`tZ6^mG&*6l_rvGoJNzhmy9qI40)*iFerO?#jZ?(4mLcF34y$Kp2
z9w3QMjFVKJ8+`TB4fKEh$}@O*b=Z#jwq2Z@U~-tjS1UVTuGep_K&gh_r$<}nK9-Qg
zUN86t{ZIe;uSK#~pAX<i4V7MQ!k?HiW=#>7PkC<tJb!ccr*1W!t?c{&SaJ%G(>_tO
zIT!GzAWhGC)FpDjjA>9;<N4~Od||g4!O_^E!VF|J9RZJ&GA<W>HHK~+D701>9i0F4
zA}3^CVR*z|WY`6QyMb$4Wcn@cYzsmNznb5jA>!3gNSqUJhPHe?G(3OUSje8B@vwM-
z>)#31OHN+FjUmvPSrz9s3$tC}E~=}FaJ5B9N$f;CKKeAilg2aA5<Et}9mfW1IdOc8
zA6@#AAFO1Dj>Kn+saWPiLGh<_n%;VJzyT}WpY*&!e=26NC<MG0i`0xEYX2sF-ml$m
z^%9CX8kY+=ev{+l79I`sD6t6>T065c?1pqm);f~_!Ihb>mO{V1k}NHpkcOaN<ZLEr
zFs%fCH2AX=S8v@9CB_isM@+_Ap}^MdqsZDFL-EH?sFBpn7zf9pL5`K!_?gEKBKz#k
zFCQnxFJ6ppQc<+je5Ax6(_S$U;lt-f%iLf41!5D(tM%%g`I?#EG5hOT)~5zbe!hel
zWO{vRrl~}Jw3oR0Z~U6FAsQb2i#EJl)6s+a_38D}JJ0KoSn1E55Cbn>@_D9m>+*xm
z#6^dwvQMK%@4IIOU)@89PU|0(PUZ?sj^dCG9Qozr48c>D;@e8n;-sO^g8q^{>)UKm
z+Mhtjt?||17<PnHK_>BeU1jY(L%B({hacw{yR&lwK9g-}piOS_p=K$6$v7_0#p0pW
zAAzj`JhMvhp2<uRjY9(=lH^`O)Z3kBbrP9*fAQR81eEF0;hevEXD+Yj2Y31oy5W(L
zhIvLH(XdnW(_W<{Oafgx+^7Q8Q1AHM#GOFopoIA)xxL#V`-z=)1KK6Aj8Aqt+Jx8Q
zA%}4H2E-2`h9J&9FHnIkC4>-R#;Du_;ig#?Vst6e)86Ky^CahslE?gZTAFk{#NH5I
z$gb{^pBy0uc##_2@s-6?zHt(28`G=H`k|`%v_O_05+TXMpK5Vm&Tx_kByWf!^Jsu1
z)Quz-<+xOkh(ziYQr8`*`4<p?Hm1)}Qv|}np$twg|Am?gkB=DZ4dFsK>DEa&xvd(;
z6Rd2+2yt>^2-3#gWZyDRFST>ZP1a5LmQm^As!Lxr^7yJn8mdvQe8vSmH~}J3HaTZ*
z-SiPhOPiejUke2T3M<r+{RGyWSb#Vo<G$Q}#i*lpvY$g?$tg|!E1(j(X&<&AC@8z6
zDKT>Yx-KN^X@_m#cYHsI*G!cpI_{^F&Po1P**oCD5M;<#$cT1Jv5$PqJYp92jWG)C
zfsvp5YwE_h<xobu4Kd(5uwZ?(+=-sV8~3c3)=lS9lQrn=*8GZhIVpI=fT1rashNR3
zO%hT-Dben<Y{0LYjmwrD+i5q|uN*#g8-%zB9^Q%$W+VC7z%w;ESrwIhN0Z==kL~?5
zn~e_l_s5<6H1?`Zt;damN2Eksh9Hzdx}@cDN`-j=8T8xufYg+xS#qliP9^QX%O;k8
z#TN|KF1m3J@PxLO5t#E!f$dC+1J%D;Hm$a0&%HP1m(?dx+IAaOUQEz-__FVR9`U$1
zKP4=ug*=?}6+&bN#10sAEtoBnjj45G{^OeGi@z~8T%EN)t1t1ZjGa2U$_~~-;UkA|
z;3H8=JPyT5PqxIr-*)Gm+OHvb;l9Y+pQkwJJ>TOjSyFrjej(s1^5-Bs3@>gFDoaz4
zgg(m^Ys|E;yCc0H$lD|$?yGho(G`QtuHMTY)k7rV*gl4iu?rvQb?EQ$P2_lh%Pb#a
zAH>g+9o`~{>*MD;^hm@pLmG-Jqvd}M&DtKvZZ%`p&9UDqmYY}`^QSKcw@<EoDa_v4
zvA-ne>l6QF*#WQ1gRyju2DDr}ew;X&3s55n&1%0WgRau$Wzw`@WYepWCONnBCAJ>T
zf4lA|NxPDTJ~PIPc3K<?$?~d-@uR)&IU}!I>2E_gV9K0Pf*{JwcS)e%+TI=WRpvHd
ze*E3ITU4AVDz8YYF8><TT+SXHaOfrGYUH8n3rea~&49+iN1LLj?PrIswl0a<(eZ?h
z_)83@IN(pDOB|{+f2Y{b<Ef2HYLpGUO<DbGfjF1{q<Io~e~TW}^YkUf9@DR_NxL0}
z&o3oRqc}JOlq3~f^jSV@(#yH5C*N~0C*U|TU+CB&c*=UGcyY9keSmX%rXV-XG#?jd
zDcBNoz?D4oIdhCMW`>XJ3>)C0^u!&+IMVFYKZbTl_6qkkaY_36&tAF7MU%yx;JgJ$
z=@2f0e?upj)jGbs2%EcgBI<xcxtCpj?6!ckWNmKC)eHJlr@z4^>i;zYmRzu{gzzrR
zDBC&Lxj;jH*V$st@oTMOuzJl;hjWZK5XAOt+Pw%dNNnYMtaF}a)_eB!^f^ru3BIRg
z67Xfk#AhsjTh-){z{L&GV&gbrd&@0Z_qgheVS05?>Q#R|yUl92<T1H~2q9AQqcB(u
zW(zWqx%vE&Qhf8DJtr13JLmsQzhq}(CP?x@1g8X&v~6Y?&;!4c#_X3Rm%=&?(xkFQ
zL=56uU|<R9au@tUy(ovFULQF^(wbz}Ucf@EvUOOjHl7+L9nKtlbJYMjlHFi5Fw*bS
z_S~VTz^#qELyar{FHz`vWVI3Y<0JC{HGcyN!;sv&2|Oxo5#52h5Q5#;^;)e<7c>DF
zEEAwr+2Ptb?z_kr58LfJM1<<eB7~ldA?J_bJ&PB87HLh3K)Wp*YGa#N2obOmlAJ%0
zA=$_%D`PdTG?ERF)J}4(%Aj|`4bStx)uMti;gr<pklHdq`s8l|WW91mA3r|8WlU?f
z-0kushM%wS=DT7S2?tb~)(B6F<(C~2aRvajKrU>j$!6#z!(vu)TZe|>k$XR|pz^nl
z(Z<qAOhPEm9a+fQs91F^iUOI7BBMcSK^;l`30l&@W-&@ZWNyvsrOiVrNR?A9+ELFB
z4iL&jWb!w&3t@bwx*0j6jJ2pSL>=Gup`LV2qeurNtb}N8?9-wVFH5{hyv#`>!xW%D
zK;dN1OVYV*0tfit?S{aJM>gBNKC@+bL0lHrJ>T<WY-;%(8`#yk5@L^*v!JV!KN8pZ
z4f<oKCp(0V*&Vc)<VH_HsBQ@BN=3?)8Ltp<`INQN=f9@*iAyTS>j6h~B<S|*Z*Ae$
z`%!#b&IvH56@89oVL5!+bO1}DC_I-FeMCCw>60Pj+*qKxN_)AXODu}j2}4O3ZQV^S
zXXa~jH$^_<$Dw^M^hO_Tya)MX-amN)mLa~ehQLb>#M#B~pb}<Bhs%B=VLnhvrr%!y
zs;5)Qu&F*~7HY0$erikMWTZbL$rc&kBlC(f_3}?cI0N{!E6J5tj+7T2<&M}3cC0Hx
zeIE57u#zSzg3>t@wPQ$8<WU_w3uC|4@Rj<IUZOY$l@kl8McF!~#Rwecy_DB+8=b$6
zq|NCMSSe&NI|o`O(m=<(q@UVAjf{%?$MeCNIGF#7TbB%(k%58X|6Lj~asKz=OM`~A
z4Nfyk`>E<xvKB`<(hrF)H9ht~2MG|vb0O4T=s{|TFq-_XM4$1_N$Q8WdbZ?5v@&dl
z{F$a_yt0<kry)YSI3-lOS>ZnGxjr5QDWVfmsnYp~OmnM{fH-w2gwNFx4}<)|c=4Y_
zbo+r#yM|>?!Q7&3JP4zx_ZL&R01!F7ei9OblZSM8KPd_t5ULrkc4`}jws;VS8M_4K
zV`#dggX5+*;dco0yJZMxI#w=&*d5iHFNtw0R#r$-Lg8Dhh(vgcW_sV(TqxllfDiU)
zw1gucm&hlkrU1r6BP?p_wSYpLnH7;gZ$hsWtKnpnn?Fu`hGY@sS4}bxD8S>`cE$$b
z+)5|(%MU3eaLH?wn)lKobp|P#=C6c8r%RP)czFFTL9{axP?sMR5)Uu+^<%}7<!>U3
zJE${|Ds-SrZdwk9((z^m@Oy~WP4GeGupLx>ee`(JiTj8iFe6JKNI)RULZ{rug?c2T
zph}I8;Q08P@rd2cwTvAC(d@m7QuX;dV~4&xCwn$hTfYu37zH?5!{HF;{V{fjFc%_l
z)M@X@9E7FXCzmW_J(V88XK{@OsuEd>xuH=VTuZxlSgthIV_B$Pxd*HDccuki!V4o6
zXd`qEgA)g;Il=fP)j@o8O`kAba$PsN`qD#VUrnB>6j1((wiPD>M+gS{3y$+ZJlo-R
zRiUH3Qg5DjMqv{9_@e$iwNr;KkTc5DM;-2XkSrT{;!$(K-q6ENud|lE@$str@A&S0
zef_<6{CGU6lYgx9^X_(?-$sUi4R|?zP;^(Ff**NJn~nO1k3YkmZ*1+Fr}fi|SUN`I
zH)|f|)!5^4f0!fS9w!5|0e`b(=w~nefvk?#3#iY`!Jv~7$3kjWG~Cez+P{rlxCrCH
z`%Zjrbh@KEoVoGsEaX{{;fc-(QO@?Vl5CDg66Cyj2URmAXT6ISl?5^_gzBsJO4~Qd
z=f>_q-@C58eiwDV-P=&8J0`?lbiCb+zJ8wOs6M(N#hn4)L;ulFc6@0!OpyJ(<Xm+C
z-Fb!<&C&r{KA#SLWaiJFCRNQGpPyGD9lzUv-@NqlTieJ0Aj9YDy(aXFum_A!9-sTO
zgR7HLtdo-;9<Q^L_+Cw)P9gC*kN>)Z2TqZ)7*_D-_PenTCJ8dX6-}B{rkV8inCjm#
z3@l@k!ovZ6z0nL{ZV)#xdniN1(Suma7$bFp`nH&;fr0Y9)eIV#yx{_c{~tRL_@9<2
z@IP%q;D1`Bj}~|{ls&@U&mn*{+JazF;J-?i!M^Or-s9$mNc4X5?mKo%ViAfxGsYs(
zkye4W&6rZ=Vl!PjOYN6_l+m3<d&h&)YFO>wL=?wxtyOs?+rxHwq1#ib*Fm{76Gr>U
z@?A>0UtJ4JL1wGe+m_LjnJVQgGnQtrl)ozlFB&QiE+1NpM}ReeRURZKs^`a)?%``+
z1>tKu9Qwm`+p&F)UF9j`O$mnV41q2kZaV+ICAh{Ul%+D5lB<<%)E_boK_q0NRNFoe
zAxCslnsB1yxYagO@kl~uowBhTtHv|5?xN3()exh@zU4C`$_%DkeZFCP#4KIC$^~Mh
z<hq0?u|+{;#K{n_k$=oZA1>h8nTuUbB-tqA!OE#`Af-s0A=;fPP=u|CZ@8ySR9IG1
zbgf!YMINoG%vc&cG=EP{v^|LTQCnGgf#_`2qW^BjZO7IZyO>Du)D|9*DEDCYFS;&e
zf5wW?FM43{3+#|(jU9jZ=apn%Mw)_xxLQ{JBEEhp)Cd=_5b8<<>(@X!Z&=dbS5dtt
zt#sIzQ}1ce$I@Ko&TEfq>>lQ}qe?{AJoTr3$*wni7lwLX-VH#bRQiTb)d|xny|6?y
z(X7hL5&%=1AH^C_Y_Y*XX2E?A&O|{tD<wo=sTg>abN=3gWzE;$tZHh}|HDkXau}k3
z8Ikj*&GrXCLs?5_C`_?vZz+YTmVpneN!92!)1q4NM6Vf!=47C0aW7*s+%>6fmg)5p
z6EMwTG~IS(H~f*%y=PdyzJhcNj=@JVK{2Y{tS>8T8FVwxSQ|>~QD97Wj(qO1eTqA7
z!r3m`nEP+F#-l=(li|6#Vj~u8a{d^D@0227zcmP0p}M<e96#?F>|nd@A@_e-jaKFM
zT$Y!pz1ts+9P$6-^{!+<{}_58DAlY=wag}?V^riQ&o47u@J7|h-`D_kxtHbaYpFRR
z``UH!tk-dHb37Jgh4jyGHS8yPC(V8(REM9@TtL+iOZg;wRm+Cze_V;OHQKmR&1Jq(
zk(~3uwc-%r`lY1N&E?PO(svT2Z+q7{2<JUVc-FOctHYg$6)LKqMo&;TYS4bDh<t*N
zT1a2qpPe{r5CH;ihMTTKgcAXiEUFq@sRGXqmqBnWB?m$J-|$O2ZPF_iGPoLxjXIlH
zo~ewNId<bSeh4^s3y=CzXBK$wYI%`^j?g6o6TV5>3|5ZG>u(O-_4(ggbyl9dE}CCx
z;5LxD2GqV~YBS?H@$Q}J%e92bPMy!yrjWX*E^X(O)z2VWF=5EKT*LCMmK-fBZ>!JO
zmGvMfcVg>y)7kcUQYM+*%gsyOYN~MRCR3%bDZT5|Vn~y|wzs<#3>g#RuNn;*k8$b(
z;x#3kBN(fvBj`q^yqhp+{9yltWS;0fSO{hlJ-Q>g9xK4N+jrF68=HJY6Zf|~us+(K
zYRTlUFZ=f8xcKqUM`KyEc&>B))-Ev78?6`2-rtK40=h1@tuwmq7Z3A69nS0HHfNbt
z@$Uy6tGi*gn_iDrTFtKu9nTkOn=ZV-*B0kg{KsMpO(n6qmRN05q>&wNNxxJ6kG#}#
zXWU_=94B6eeo=gE;2D48o|yw%CGt9WwjjzXenJL%OQi<Z>x{flJjbun8G@Y4{qLDc
z#S#fVj^_3Fqx+OiX$srhngz99ARDGh1G2N>F42XKNtnv&Sk|zK6SIrT_Zxf&Ub<WH
z|16Y1ng7Ef0nW+E`o+mY3GAzB+N`o+dQMhN8KQdA*zAznU^OD*20EM0wZjYLXgJc0
zCBkdBJZwhAQm7{mCAa2|BX=dH6K6&pM&ozNa{M|#5`z=*RVYplXA7d9`_$kS?d@N^
ztg7w@{o;AtV;`OmOR~e!hxo3*A=!AF6HD{5|8j^eQ8h~?%YSx{0A$DObW$<B4{M?N
z?lqvZcargIc_#hFVI=hFb{tY>=@BL-=w_^&wjCxYv<w%mQD-4)oKD6J6vN67kGqg(
zR-__`n7`UP_s-#nm9v|mfpBqI`o*@toqWl<^nh>HVMC3;cclHoNWVG~NnirLl`KH&
zk5!DnbpfU46GU(C3<S}CR=wI0lE#2Z{w9`bv2hlhKtcF(rK7+U=E`Y=??R(GCMh7S
zL{TSFl{`6j(Z=#2z90YkSWk7cQ`3?C&rWHmv+AF$DYkC$6nT^G(Q|wjGFP}8s(W`E
z>Q8+Ki+@*Eh5yW2Z3L{8)=lM(2ivSmCk23&vsEtou$6)a0e~U#PS)%^ZeA3P>J;`O
z$%#*ptgSYXQMQ&YIjMF)L9ow&`c$PTVi=k3I@zC$`@_&}yUa_^7{MoeOJY=N0p66s
zuL`5zU`WUDOcO1q&smx#MAhP#ZSc4RTY1P^G@p5NLlE&&!oE#p0U@KX7Ee{dcHNRB
zn)x;C#Xr}|M&L#RN1R8ajX+0zjIz(1hUCFG)#t@w{Ro^QsznkzPEZ>bol?9*sfahl
zJ>5*NFtfWo<>fa|cw1rsqiiB=vT9;K460%ZLgM#lJe=7-s`=38wxQpKP=JZ$6_bC;
zlyetoYc^k;yAy5BL5#A_^vRQFg@u?3U}EWZ6n(B-Nx<vxMTDiq1WH=wsqbljic&j3
z^PL(Y@xLUR9x9d_L(>*O1lby)J}=SU=<y*K$>fGOcH)KHYa%eG^`LYs>h`1Cd3{@2
zrUVu$ziBhIEMkP@7$x2~tN+HI9WhE0<$nEPP>C=JWa)bZE|vKIwD)~QNGa=$pN(c%
z*ocPATLqAD(wuFX@+HE`S5J&raaISE-3jAzub78#`AjOvawamjyi5+6r1l)y!W&$i
zyN{fIq}Z@<a-(Y&MvRBGl{E@f%$nDMuQo2ReCm91!RqC~&fh^iT5x3%kjhB+s{NJ5
z2tTyx5tTRWCctPk>3D2I%9E4-d*pPux4v$rd1?x0IWs<?%$1^;<<XuHH+Y#$Opy$8
z{}<}<h1Vc(QDAJ}g}~zQF?PB+Xo9NdHONM{1GuGoKGweBbNl=GvOV~^H=nkM6zOUB
zP}HUSdv&LdqS%W^{Z4ql1;@S`hMU$s^d9N+;MC~920uC&BU{on7X%tABO43H|Jful
z5pXgya3%=^L!d)4GBAH#S9f<nPymgPO6Vs)*x+X>#EF?42dCC)#a$44L4?MpA{-^e
zUD#&`z`$Y^W(dToX4bXwGaWA4H(oz2JU3Gt{%n{$Zd}%FvN|f6r&`ATuyqK=!8z!G
zGCD*D6E717<pfPnUpq@r*GhJD)R4pA9^yCn&4n8r$Bd4M_R=e`0t;sE77q-2YvG+M
zZ83Pqmf?a7A%NV#f<6auaDr;3r~7^~`E$d98VOj-ee;In7Jx<c<1n0&=*8v9$W~dP
zi!%Fgf?)7X0TB=s^jhd#1C4z^Ca1uJ05A5|Dkpr1!s;gA_9nxD4`_1zP=ygivB1E9
zCPYMZadB~uZfE9R8<q?Y`4TQhbgF?e6-XzPu}1#Zbr}d+CHN5C$!$284{oY1l<}Ep
z(L<}fCMbj4mDhy`7uc1K&#R^X1DU+b(B8W+mq}nA6zp|X?b!xgrHj7~6lB@w6Y(+X
z@lrr;Nq2&P0n_>t#MkYYz6yv`F)l<lRngeR&UOzRNH>iaw(nW`b`<bIz>YkJX!K!v
zrMgexou1DHa<{a_f6nQbk&Q?<aW)~>x=CyQhIq?itezaevbKQ-=3qDQrkw>p2Mgwf
z(@H+L$!_uOONF-W6EsmSIbi>ij7AHWqh4Q5Of@)njGruuXzX*SoPZ8QM@B}*i;n<g
z2gcjgyMogzXz|9;`wb{~lX_e7srm=L2CDbG1ks0K4(s;Tedi3-EC@m;Q;Dp5$^ZQ`
zg26|?8xs8tj3G!(Q2z^3_(2h<_7Q<kzX^K+%CP6Lhlkwt{CayCcTL<*v&FzY`I-Fb
z)QKZ$AIk*CL<6|I*<{3{uYqrk4-7);?e6SDfN<i^-tyyld;;9zKVe>Ev4AJ49-3{C
z?#?n#oY_t)=hq;R@J||Ow5?9V_CWsHA7FZKNW&2vZk*jwx?P_prJwsZpMzJM@*g%N
zpPRmWTIXjU3d|n`pP$8o4|3d-06d<=>B&tK2-VdftM_|V3EkdhL4xn9`dgLEG~`_q
zR4fB^D}aP@0?<I;d#e=-YIiLF4*NFE50|)gemw-{wkAiHVvt=>dwXyA>$?U%R`~dc
zhho1z3VeAk#(|>v0H5t2ofzR^Nk|~}_F!%Xd^*>}JCLs6`0UeQJJ%Qipg3m?O{00=
zwrV(ay-C+#Zy!D3u0S~Iy}~|z`M!Z5P65#%-o0;|z>$j+&JRF<z#II=W@!99n5WB`
z;FX^S&sYWM8dO>U1av^4?~tC7$1ad4V78u!=ZG^n^}edsuJ{QsynDC5s)mmL>+y^<
z1ifYZ49?eh_5$re(|eBeq!#$9d(~Np=<H<g?&18g5;{ozjPY?A;U~aDpf|Q`#-YXm
zEEUo<-Pel7u4PzR2|LDGOS310jQ?FI8NdIDK^s!S#e5Ys+iWx=us9p=U44K#gmZ-Z
zGUEWrR6h%KPSe`MT6&jdU{QmiGYaKC^2dev0+7??+FeLmbK!7!l!vAlHW$8BDV%hA
zMCDzU`1v-|F1C^PG5Y$PGj+^*e{bFasH*+DBwxyH$O{LPEIhgytLuo7%WJ8Y&t~4m
zci)oE$dKJR4Cj-h>aWpzxe#^0aKnDv3vGTmXi&@P-(M4ylrsMU13Cusv&dZ1Hl&mb
z^XzJC;M@y2lBMzQXn$(i%D(+m<;tJ4nG;X<9bFP;eoI)*nswf5@?%avbL`3kszC4H
z<L{3)2ptP<5@D5DzzYi1>9f65U0Bdluib-x&{$>Ab2~patg3TdRql}tvdC8R&+tp9
zGELoF##3q_4^K3<>5#OdG^L3cA>;kRb3qw#tE4hC6kT2&3izliKge1BJ(cHr602YQ
zz(%3C>;xQ|K_<zXlCce;+x1=maRExq?BI|$KWFTNvFsK<G<)$y=%d0nufoQ{dw->6
z!s^hb#vikslY>9kmzw8thMry7Ab2fXJO*VTdRf~O!}jn7L?*7Xp&`1Png<)c4Y{85
z4fy$aVj~xD>GFJ#xz8(OTr@T<f;A7Ap@`F}Rd040Wo2sAEK;#DrEuN@!}W+o<VdlU
zTB329JrPN+8TE>P9Q$#fuZx1|?Iqb8tl(csdssOw`kWuGWW!Rtq2EDtsZRDQ3+%;y
z@dUz(yQXx-rGu+Z>d=TA<3+G$J$QRyE>DkV$6A_ArGi>CWTtjIdh%rT)bX%SFwOU(
zw@GtZi4XtSJtBHo3rpz*vgV`xDVEA=+<xGkNYQg++NJ&(M6{!RuBc;+0@-D_?MHdQ
zY;;AyC(=!ao=FrO%YN^Wyo1QDm&afA+=|u1Xfn42S2T2;-1o8wjg<UB0*^zMrmmPP
zsO-jxA6FOW^CK$Or6q4=E!Ztp*E`0Z;a(|7_gP`JNaPFWL`>!gkRBV#m_F94#^-$r
zb`i|kDUI~)3t8sEhbY8s?lXodmo#{dw_GSi<o>daBw0)grggs`c8Ugp`<-4_-++F~
z%*2YZ;nPf}JzkGK8Kbc=A2jx165||p#NdS6lG))cZ^+gPp0X@6U0r?-(MgPC)Pd__
z2twEXYdEA-lD-ok2s`EbOwQ*;>Nd?C{3(;7u$*q;Ci~e|713T;;*XrG)^#P88q87<
zq_(UW`KtwIvF13cky8IWj=g|fQq-w<d4241=4N#$?}^dZdw?#;Q5=UdU^a<~{>3cU
zdakrZ>DKKctZCMrNgFbAhqI_W>Dh{R*JCFEcB&O_?o-4AxaBb*=UMxVJMXa6)X!4%
zNty0{T->#uh)=uW-s}s`RZPhxGov-WU5I>NqKowiY=GiN={WxlVtq?E5Y;0d5I?=m
zlC(IBX3a9>wjD=5IZu(xxg-Y@MX_ra_HQ;op)(KuQawqJ75ge8#-CuRjxIto?axzs
zmK<E*%<e`2z)Sddm2$$i)Iz<gRgP6Kc<<*mT_uvhI@wB#spA*8kayFh`)As&`MIlK
znLKmfA+cpSdWYfSf*RdB$tY^uqrv<z4XqPK!cr;bQq+c78Qp9~i&+w(9q4GSSU21Q
z37)S55}ysIxZ;xvRRf82j^)<rc7Jf(hR5}L>iNnc;E3!%Lmrdr`yljqo>Os3Z{yZY
zwKwp@Soj2^P|~kdL&updi_0aGM{Xu2>!0dJ=?A|88svZ=<3}j(l|7^Ql&wDafOP#h
zQh<c;Tk!V=baiNN1E^Sx;^|?wiMp)x9;7cD15atGW7cuB_IL>$Y4Ri}Y5YS%&HOA{
zROZbv;F_d2RAId^he$K4%{k!{MN>g=i6GxMOmv!jfy~G8V{(w6oHo>S>OgGgH2eLj
zUkrxD%P0=Un#i-6ob-<avt3_S=#23(0z^UR3~mLs^yKH=^nztOzgWoD;cD1~zL#vQ
zY5T$mnyIUASu~S!ppj@<jr`s)R_;enhoe*;P#WVUY&6b&TE-81>tnpmC!Ft)Q?ao4
zrkqmOimISE!cj^9w>suwnDZ{eWY{0%frxEg9>yG^DRB}2efT}S+Q{Oy^}J9D8m|s>
zLzTj!8+=aJsV<%GEjWE{?)x?bHkjm&$O)(0ESmeRgs!mm5-*FLON?oKx%Pf|jnfV|
z@MKA5nOHBi(78kO6JFK^UQbv;B5PolX>#oSXD$k(7nOeYXw>oPNwFb2=RhgH687B3
zscrJfYre$CBUMD!41$M2dC_Rom<(T==G!8vGsfAGINBIz0UW9we(abTzUA;~o0RnX
zWZ_hn%yo;K?RAE=8e{V0vr|CfL!WsDpol<CNAg|YO@fk|7dxc)FDf6DUSnuIIOOBG
zDsK27%fx=zR@f=USY&x<E1fSX)h6#*L1ux7Os0L?FW8s4z);+kxKez!^P&|LdIm=U
z2zEevZ;W)FcHZ=JyEzN__YwiE={8v+jEB)s^GnA{yU&D|!y`|Y$z24unMo)S!1=Ji
z89ty>e(I-Dt4_3nn*t?YoLf+<bJx6G)DaoA)I`M}tr)AZL=>bMB^hcQJ%9Gwap~!;
zMT0FZGd2f$kX80)3mQi`IfjYzQBH=Q`;|RGAYqD}1Zx)Td_FzDcsWIu{0G7E!?;Kz
z2|g^Qz1rL|;X)9avx{GD#8`wI;P&oQd^4vEx6B8P_rWbEpN`!9XtvES@owp7v&6f!
z(|j{F@XA-XHrSY%<EEezV~FhLhR6h=2!#uTtgbs-kd-ZoubanHMxQilPV|IBb8#B2
z{+t}ho8!xt{hZmGVCr~b=#f@#Wezj{gL%|zkNYHg5RmA6nqk+MBC{a^-0Wn0R}wuV
zry8%<ry5oWaBw!~TFtn$T<SKtS5mUT$<x(#ZjRQAO5F~}{!Obfyzjlc=m3UWe9~i=
zs9WwVE8R|=arq5|=Ez-F%Up<9d?iami2f#O?v2)Di%`+3xhe^@DcYVGT8=YaId1L7
zin{Z*k|EORFWgHe*8DaKz($X2?>~bNP*6*X8P1L&vdKHGJ<5r{G)Q<Fv*P=C2#~~N
zE$|in9HY#B&rlFwv}iJHsV&a;q1{%I4WvgDh+=w66t*ol$VJxT9C~QJ%ms{)#Z`(?
zA`K??r>$^N-nH*S7A{VUBwoUZnXm*qKTp>q$H!2yT;pgRzc9$ann(<gbO^!rV4i%C
zXao-S3wg_BbAA>{ap~3CU5Cv6XUiyl4y{Qd{}!0^-jD%Tu^JfL+F(-%YKg-*BfL4s
z_Q=F2Hvabk>fW90<+>W?ap%x;yPM@(Rn~kKHu(O474vof01Qt&G7JGT3ry~D$gIZJ
z-igNYl(TP&laua%_kj3SfV8rWL==(pv^P1yBP0tn%5=aW389rW;e&R3_K##zJ0W4E
zt>jJq=jHV`?}|}a#q0=jg)Pj3%I8N>oWK4;RL}OgQfC<=B8H5Q@m=t>oX@UNAz%qj
zxkz{<-wHi?nVRL?2`ulnW=o$E#4WnxqS`UuJ2A1$W}5N<etwvQVGPs@GM50y=uj%Y
z>e#httDs{!X)&D9Z_J(WwiY!B1W{st21-`W`Z3XF9Wahwm57qXe7?cvd+Z4RzF%Q_
z$=sJqr9VdFQac6<M3wZGQ2xl%8ze^sKa^21q%K)vhw@}=0Xeo!Oz+yx2<PsNYzuob
z{{#7!Fl{{sbkrcb@Mvequ_36y#B4FQqDDOaKzC{}xW(LES%b2<n7?bB=??(N_NUM7
zPiHqU8Xe@^cLMZPL%-x>VrQL1AcU)EwJj$XbpDN8=3*QW319`s5Uc%|mkrg`*8}xa
z%R;02cvF}dS26c^^An;(SW5j;y_qT(TpDB2>@c+lW_++(kqgj4C1WIIf9Fyyf#G)d
zO0YLgp%PM4UOW6&{rl3#)YDnejj;Q@_)4m$Tlv0qp1%Dp6Sr+L7d?Pn8Qc)-duD&9
zsqlR0>8}<t?b#hP9CVrnLHE?a!I149%t+h!Hx57Qhx<`&oh(eovgH_oM`7lK_AnA!
zXsb43z%P#T8+V`;L2gX6sL``h-Rbeg#|S7&;$Ed1YU!~<5n2cS1SO$J&wIdi8{dS+
zRY8^M!)=4K=dvDoipR)<SvJjp>YtvB7K<z6zM^Lk5f2~EVQ@J3RJGKHW6>6HrckNr
z)eno5j~ij+y1#AC%i8wAnS_Wbx{A9R6eZu<ffjZ?fxj%;;8veJZq1Z>+B#(~(2eSH
zYE$lMJMq1^p@kwU<9;qmo$I8Ck`drJpMiGCH2SiDME1~+^99lUX>TF%YnbznJ5hVM
zosODh$`y435A~Ea*dBwad1?LGt3a3!42J&&SU{)0YTP82?y=@PLX2!u6`MSb+hz<W
zt)&za#RGqk>&kK5iS+bi@1-+R`P%Y_QL;7U@zsWQqtIVmA83$+F*E94JAX<oAhAJg
zWJ?_YaFO7Aoh)@!Bhq$6Zx&<{qk;Mcbl<n~>#_KG6-jmh7L60uv@5h`CfqCSf5qvI
zL`M9|v?@TkqXb}?jM0S;y~G|$xauDne~xM=@sfY?>+2sMGUI9S7LnAG^c$ac$o=4$
z#<`bZx=TU{b*7pPK|9nCOK?sPDBGaroWwy1N%5Ve8KGvAh<VL6=hr?<_Hy~cP!rp(
z=)An3CByDYnJLIiGITpZ#Jd=CJM-w`oa^iiRQT0%P*a!-HS29OTbqBxanj8jRA9wn
zSmS?&d%OFtpvu1C%ExquT59f8rW1X!Sq`ZO2C860?!{zTtl9b2tKfP8;U8uVy=G#0
zzTXPQT8esKlDYG*T{vd5R_pIKIVH68v0|;AmH8aM`#wTS?9IQ~MWdAyZ)=m16VU<R
zxeq0d43s%#>hA75SF_ubTS9Z$!=GtSbhUpMD6RD;N4MLcY~zn2E*8wy@JAAFC~0!X
zOcKHVN>Cp<$=5l!Jb1r9^!`Nx$U<A>+G`<O3rVxp{fpP-mEG8lkK{LcwP*eCY1@)C
z@l~V9G1TUE?AsZtQY7oVo<+`m!hH>UxH`qR56rHan&51s83Ebb+(@c|1Ah^msRe(K
zepI)N&HB4<3e9ILi64t#M>B16d%>4fVvP&^ub~;UA$u`K53Ej^Ps-@NH^zc3+hhUN
z<T}OU_J+}98R>a@6GPup+LOhlKokm_6CW<P=MK58W7VIBSKg9^BTnecY#BD`FSwCA
zHE*SB>Zvr#E;S{6j<lQN5S-PC8p(f&@E{_Pb_mx~(me=Q2IJpMZiFdIUA>86+o$3z
zKgXHI6b+_UIy-MgJzCNammWZb52800NZ;xR6kRIzzoLy2o(hXFHKVqkTtC}?dxt>u
zx%yWuxh}4&oI&V&USGn4C;NiqZ_98zRK|&i;wa=>hrP|IPIFzz7cSd5cZz=@$;U*>
zMj08kKc5d=vEkB}_OouR@7IK3)fJCrobU}X_tYD^AR`rH15;I>)l6-@jZ9j&vhnWl
zp}bJXEpEifzdpwwzA$v`Ty@+%h9JhvNzdL6*WT@_j_Xw+yG3DS`gC4XLdC;hBWth|
zXJ&)lqa9>O3$~?*OAWqnVA+43iHAw!s=p9#+a<;Lsu9P2D`sIDY>g+c=El;MxwJZ|
zy>dJUeJ8J?XCh%ef>qX~8L<JEjtHxdP{8!5&ulZJNN3iO*cV7FkkxueLZ8K8I3@1t
zj=v$dv7Pc%`<8()m1Le>PL6TKd_SKoQ$wvXRd1f)i1D~nP(|QuoR)u>fZ_tF(D8Es
z7j(EzO#E$CAU33gg<#WCY}{tG#XBWQ_S#FV@cFv5308$E(O$8tL64!ZWca5Mw*;x>
z1_=Yvu!7A={>|PNmyVk%6yckGD><P-9T6;td+z!uQzIOQSFzu71J3ea4&P(@V~_rd
z4Xq%%6U!0e@1@rv;dp;n%CeAQAMma<!JXkn!|6FLbDk87l170R&o^BO0X)Vh_P3<i
zIZemYm|<JfT{n=GM%kUcINu?o8Snk#EY{@I-24{th5T-T+NnGF8u;p4atqO~Rreb%
zC1AKO(_N!?^sUZ~J5+;2w_-JuSuQVoQ@l*_=ptQEKqV6!dQyMRPF*W?J$t?jSIJr8
zTV|QD1i<EI;#&Ib2F`b;Eh9hhsu5#+T^^<BW;J3C^VXFysc-U}xDCPaXl-03>Lk<;
zxU6lYHvN$FGu~TjiQ&km<cB`Lxm9r`9TtD6)dpf}%`0R?uBv*MHxXCI`Ohn|5JL1O
znQ7)g4duQhKVpA-Bad^=1;98a&@fhE-&pm)PY}x&hf+JUdQBGZ3?ayLO<=y0Gp_|@
zp(leC=$pO`JLgMLFo}`P#^(VjVZv_lCZ^~+X_-p2%O^VrGa1B_<Q>1pS(P;$-XU#M
zTI<(ek%ybQt?#EymOeiQYXGkXL@n4`&Mo)Wnh07YMGSvKRw$aYyYi+(Nf7%g^U3dt
zTqNsYFIg6BKc`DaN;a&NAXxG{1b|0zlip*?cN))yMF@5K06A9!4uh|)UPIMQ6tM%6
z-MUt9ENvv|`mFqRqPUo{t<<Y<Cyu__>~-McMaS&*_VE^d4G^aoN@~;b=Uf+>SpfRL
zLCxucy@r1YV}aqsd1yHjvFV8UM`VcCboQ*e7x|G7fm181Bh+{dD160IGS>M;Mmk;>
zn&7^cO~p?r@{^%{JVoe&C8+pe473)9Uk2p|Ao-A=G6j}{=IF_lr29!W{)z?IED6_7
z6KN}<m)%hQOhfz5-lTb=RY82t=#`ZdlC${3F71Cb^{d)Fl?=<V^SIB{Q<|U|B`Q0W
zxJKsg1jhW}fF^$5w}4*@En)ZXi+emk<IHs&%S+}%5YK2G0=?>%B`sTB{NfzaOp4$k
z0OJc<TDzOAy1A3Gh55p@@lSzY9RgR*%rw{(<r|&_N|U!fp+i-enP_x;*sOCph7wGb
z*fM_@QZ$BiyW}&Ns}9I4#`xy~Vb@)TKFzMACjE5^vTRuxUG>N}9LAEi9|e3^aBIwI
zD$z5V+o?XHWl&Q8IC+ap8=1mAnliyfP=ILF%?|eGB_s;bL1lBq`=!^rQkf<CH9SHs
z5${dhS;K@8QbWGM7<a#nXf7#1K5psp`rv;x;rTL-j_f@9fv>rD!(7N5#RNiT`_;rE
zVa}Bi)pN53;)8tf=-32b)N=s};r1|}vgqE5!KcC)SzRaBjm4e0FSfakQ5<c9hDIl_
zW5&Hi-6Q!rkE6mH35oc>SL6-HDlj3b{HhNh`WzNfEN`YjmzYz|MAa8%g)<{rwH1G!
z9CISKEVA;1f()m;mS1jP#e<&H;hh8zSZ{oTVx%BEeQu8mbC4ibSrzqwGE|Gzpj}o2
z(ZX4K*lYEv8Q)RkzDK@3&*qr>B+V75gtB00_$<H2`a?AOX9h42lo#_S<GgV<d+^Bz
z6-I4v)wM}1-P>L_I0qX*7GF<-sbqhvM@~0l+qhkoq9dk9=Kk<l-m1WpK#B{y4#qMe
z+58+85g}3{Y%jafroF*ZtKze_nl!EeLfn(tGddI0%Qsb9Rnk_z!i9YuQkygrCyg32
zuE!iS)*l@eMhZ>`kUKM6bV`MZ(RrZzd_JAG!-c0qg?6p1xS^}_?~H(w?{0rRZiJ)H
z#5Px-KUqtuHR7<qE`>7@OQM*i7s4XaY)^L@gIV6`4L52~ZJ<GAMaOk(&3EHetb_{L
zL_4r*x6PQA<P|#FOnD-orb+dZ$jI4wt(_M|2U~Hme>C8T>_tIE`5JcOKa;p2tww{Y
z7KVqFE=W_oW_@Ug@g|2zsNa9<MtxX-=`g~D;q^U+LD)Lw>sV9D7QHq`KPlN_w@-An
z>O~j?uFu|;<wZjR!)3I)#QOn6;ois}HF$ok{#xbMy0W$N{_%?k^^38lEq>AbLyIXB
z+t$|#Qj)1tkGbhL_ATY*y_4+NF&|dEne7wg3{dqDUifqw<JC)k`M7`d-Eq?0BhQWz
z`KLzY_38eJn>%21)0}x}vU<C<yUu*h{IZJ9vs1G@-2hQ+jn}4yjB4muOpxs`oo@9(
zK}K)aOFjg)7<pv3NSsPNAw#0UP1Md*R!AVa7+TZNe-mL+DVKkr)7T>)X>)SpKpjt{
zsD~^RG-W%ci`PVOb%uXkMqQ|)@Wm;PnilnNpFByp`3wOr`qej>UgMj`3(6!x!t+hG
z?JGx=oapqfOTqx6Q{hCGE$Y>bdffot0N`Z7;y6`8V~Ucs`STqFoJ!|j<pyBGK0_m#
zE&W##&Y^`&OqXEOx|G)#Z^9&*S}?fk_1qGZeu%vFeqiVyAkcr$?%0kPO5W&x=p<Vz
z!^AV}aw3ws_RCMJp9QVees?`ujIDS3b<iPG<{7099wDva-ur^!BViPtww#?jdhP#d
zSD@vBq_?J@P|778MG>jkAWwW_(DcEYWx6eNUHq`s;GKaDOdlBmT)~tZpG!8bc7e)s
zXIzbS;Iy>@Y(syv_o3tzC>d>XeQ;SVYs0P1^~7HCD(6-GmbpUtY~pe{hQUa+zNrWr
z->Yg+cmI`5+~CyOnYp81P6cbzY%16#OTP5Fjehu4HAI(*tS8c?ajG<1n(RH33M{6D
zAQ3ZZ5OLtGLSto+Q9LsF)oZ_M`)pVN4YN_79K*_Wmm+`qSyBKvEKF#{a*`way=#)n
zrvqoi9Lea|5j4=xOvOXgz~@T3#kkk`n^YmrZHaX@92Zkk$<}MPV=O#n<3U#iiXN=n
zi8v!l;+GbQp|z$-nV(7Wd36)@gzv=%g`T4FrjmV1C<Q+pNJG*_qdwH3YO6V%Qbnrx
z(7h7eqN#sp;P7H5DJYSE{2Gaoe#w(vu}wk#-H;|Qpg~~a{c`rnyKK`V=&bVM$8T)K
z*ec?mGGzKJ$t2uO*#q;?ex^--=HT0@h&i2RK^^e{7m91xV?@xif7!BZWYbu()?^uX
zlt|KYeAZ)LFLXo||Mt=@9`+W%zAml4yj*##WUYUUBdui6lmh50WEv8P!QqGJ*Q)oK
znG2oIZi!Nes@$-X_L{zCL1XEZz|8Wx9!!0LKH4m{)WRkmz%CTYG6`*G#J33zn}HjL
zhZ5qu?#Z?~6?xj2$T}|~Z`65j_`sGn=;S}I>mb&2zhlv1Wboo2mVMnmVrAUXx%Ii$
zY9fEyi{P;6+ra!_dym2Q55R!cl?C@;s=3@EmS;{cQ(uF#tKp0w1mi`$R<CYb=@MC@
zn&4vIhN5RiywCk8Lt3n;(;^~^7Lwk~N>CyZR8x(pZaM@`3aZUl&-GtCd8OcA9_20`
ziGir|X;Og0hGE0k-#r%_=c?7BCYQeFhVOqVMP0}XI@#pCP0^NLlZ@T$O9zG(Ff`%w
z5tFYov-+=3cj-WEwFy9Pw!ZHc<uk5NdVa}9u`}bxL6MpXb35gh(M(KTph~e0qv~JN
z+m9tn$>M(z_uk9iVi$7fQBcJ7^qNA%epr04K6UeFk8LkYWVRKV2Twi^SA-wi^L~H%
zm~lXavf-Vuw$tRYY2Ii#a5?GB`|?_X#=+|3?i<*h#wIYIbMr!_{eGW!Xd=9Enoin5
zj9a^@eIoH<r9Mh|!Ok~cXQIt7@BJcG7C#5#P%KZ}I5!1{$KoiLon>9^jTmIQn6(qh
z>iA%LLtyu$Zbi+=-E)Tf{jqy#`HO#(3z^%c?JKd+-7K@uwsyi(HMj0|KAk*o_k9zx
z28cTVp|;$iVZN&^tm2?9z6Mi*rr4v8Z^#RDdJ})1A*gpDy~J`jiXr}xMIqGqv1q#N
z`i^*@NgGgtMaPkF#IPVtI`@Xcye^231$6#Ov_DSpKGw`ew3$S>ltq#|{>6VmPJV6h
zQ3*y%TZI)Tt-bMjo6*c0%tQ9t@_z0P3kFMDh^L~%`giM3(PcJD%S#$)>-=W5mJKXU
z;_|h{2cM1BmYbijvCAVEYY%k0Ki8SA+ETrB*}nx}>iH<=UTNEC+4_gQ?O8q+1OrWI
z+KO#(<5X|}VS{_5exdOqtkHjAT@b97y!>qsHc}Ba3Rxa%ad?~sg3_L|Qwo#5V+6;N
zJx>GdNn#Dl-deS1nPSxp38Pb|?*uK6ynoVdn1Cgf{`CPJMDlhf>vJTt(dgjY9kXds
zi6GB3GVP!nF<rd-nqT|ToAF1u@ddMmy)8bN$fXqQb)&`?B6&!~>79Rzr9u&KR&MjO
zHw+2Q=F!`MAyaneQwr9v6fT))Yj$&k#(JHHLx%XjDr3*R54uvMqs$69lWQ=%RQCUJ
zTrr$1h$xNCt-_mIj4R;AEq-J4WJRso<H>MRLuRsIp?@PJYQpc!o!?+(SI^mJRY?DA
z&`kfvmT!M+nK(}8543;Y!0#!cpDOhnPTuv7-qN`%+)8@+t8_P4w}bYST1knKYX+Z)
zQtaTiQNA?4!6W@C`YT736V{He|0}n&nm@ymX;~l0*f(M$xUy)&{jQw(A=|jsxs&rj
zxb7Q+9t%1d$QQ;(-nm-6XP;IWTZ73%274x-t`>RrDl0c@U9x{37$M>w)Y7<_RRa2i
zr470}yOPO^NcKX>EF|%P)CFm<QQ_DC4+7IF$`2ToNzY@sQ?^M+jzYe>%%V04E5EFH
zB6+!6$4%D3thzG0Zz4tS*Re%J7?MGeY^fhzZ$d$de%ye)k*NFAsb|q#9QNrxmbU`Q
zx}4g%(|XhO<Kchtt2R_RI_oI-IM5`m$e?x>|0nmxuffe!L!E-RPI+b3G+Im<GE3xC
zH2|<=x#Nr1ZAq11FPxkV8@*_+%^O9i#*iK?Hk^&<uVqP&WJJl{T8A*2EBg9$6sSbi
zD?0=ZpgkCH9jU1H!-A=_l(CwR$KDz&R~vj=KPL9}G4y|Cb#GrM4@;;ciGC@S8{;QU
z^{l%KADWZKQkIPT66gg}u5mM^LQ-Xhct`2aJ}~5R$lK7*Nqsw7=|Lkl_KD43Y&#ii
zIoKnmA=tZRA|=l1!FbukYg3<JRY_a6hR?o{T1Kw#5R3N?$o!n%eZEcCB1Z7tU{4JZ
zSSZxdp|yX{Q-BeHPyzO;JbGb+>ijaR&%u=)67dG>w7H-@G4o|)y{t{*!`k=ru_KGL
zFdpi5mCrj9z&jwR#L7Gap7=Vp)m&8jdF49*zVGH@2qVd2<7(uGQ2W)qw#`r-=8|}r
zwvFz*O-63bS}X1*EQkCdQMCfN;-~j>vokY(eT{!9lY9`m`I0xWLg>uBb;w)$<ss)y
zy|W`pt{Di+TWSOGo*urjnaESkf1QKE|0<vlP`f*7iY<1VZ9_@=vHz3%odHXzGN$SY
zYMtRtD(l)6=0)$$I>Y)grbHltDOx?&HB9;^1`^%VF;t9ozVkT*U*;;^)Omh&5)Zjx
zCZ>Nzyhe{gL9t{;r4rfv8@a1w745@q%IcON3wm53IN3G6px-i(4SH*Q-l1(}HBd?S
zORQCj5klg7fMu*LFXIz@7WbM3wK9u4hFXHT$hnnEEGvyL>?{tZRPLmp9&yyCcRCw$
zJEI!-WGht(_O$zuWK)(u*$ksgk4r?kQG9>+S*gEQPfd`1!gr?rl%<Dk?!G;Ke7y#O
zF;q?hc*D(j(}76aNxZ?F=Dc!1r;^TIM9fv(xFt_H_dM;$H>kE6lcRRGf^B0KWu*4&
zAo98KtznI?VW85xkBIpTAz!fktI~1DC2Po33h8Of;-~M%9qyse8`+S)9lR>m(W8IP
zn?#_!c@x_4Ug^x(ldw!;LFAgz7kl_C*@p$Qd*bG{%OR#-hP7pX=CQf{@^3V_8oW|r
zupmsE41k&J3lP?rH~Q-G0JR*it!(;zg9Q+m#hT=5GCv&Sf>TlYyZ#s0oIa^g*G(nP
z*>!8^Yi7PvZeX`It4H+#(JSHclqP?>T}7AGh;{J&4MgxxRQH3e%MT+&5+(&yOltOn
zc`lw^ol!wZMmc??!!q3}>;3_IB-bpT6w7yP93gLi8B#vQXcAp>LD%`d)%HePBIEJ*
z`eW}~H>}$<p&$g$AKA&n(z(5{mISzCdL`ZuiaRchyqT;m%Ds^6U1BHGA3lG)r<6=j
zj@dPWn=d#~35juvrM~B}rsDG`JdAutIODInH#gi`-w#rY%*ti%s7hq8e>LoviuAL<
zzyR79(L*)4@I$RX+dJmfAb({w<w0+Xyt?x}A$1=X!Bc*oW1;>&cpC=DxV^Xg^nDD+
zF;3o+cZ@W|1NTi2xnfd!JV<}oVi;!m_S-tPND~`Y#S?j>y=G*{EdhZD)aGWCh+_io
z4peWYOpSTySI(yhw0c(0p=qDb+iv=VItY=6io4G1nk7U)1!p?J?39+z@nr=CD99q`
z>5$sw=1MnoyNpHqqsN6qJ=6D~0+lVN<h>ahn2ukc$2BhX$Jq(juklOCO~guv)pdZQ
zGsW<wCL_<PALDj>&085au!;KCe*WF$w<2IdwNqXPypMGfZ_g@BO-LDgY&@bJs-mT;
z72ddOwjM7(`#<mKI(L_m@C6hCF*uj;Is_CEG&wK|FHB`_XLM*XATc;FIG5o@2Nnc5
zH8M1pL0knWfA$4XoLklg3gZwUxNGC??(Xgcx5lAycL*BX-3bshxVr^+3GTszJC`$O
zW^(5H|EhbdtGeH3`Fi$R`)vvmWi<v7Gmr^T5@hefz{1GP3lLKf)n;J@Ff+3;GBdNn
zQ&6Z|x!3~#BZsHZ1Uflef$VwzVIk%OG<JEHi5t7Te;X=*>;bZ_wg47301GEC3l}dl
zGk}$undd)-ASYgcxUrj+89;#%APcewI>S?lfgC)YtSl^D-t+wD5kPH917P9d;iCVS
zJ3zz^=wxMTY!6T{cCiH7y=OEvwgsqxOs#+}p8peqn%~mJ#etWJ$=%(Z(b&$J5#(ec
zNJ9^Bf46e61gHX?flh8fGr(Uh0~C$zfd6id5uO5|ZfWKGw?YkM?&5Cj1O&VbY^_Xz
z_RjAvuJ&d?C%}7lfSQavK*<4U|F^OH-v;!6f0F}XVPyGlxPN>970Al|U(Uv+rXV{9
zV|!04dkcWMl`RmUBq`76;^9IMFt#`Q%h1@?e;M@dZ|r7lWovBmZt$<tjRBG(Dgfj6
z4*%Vsv#FDngNrkxvz6^%Ju>|j=AC8<dowYRogL8L#Tovu`oyiAfTr)fdoum|aBb{C
z?)KjQLFQKWX6ApjVdm<<q+xI6=n9k(|F_M%2>y@E0_XzZU}k3K;^YAU9RWZOQ%k15
ze-fyBIspHrWcf?{-h;2V1IPhj{@w=A*UB9D{sZsrZ0rUExH!22eZBvw_+JFi!U8a}
zGIar%04=QS;r~Q`7X!`z#_#9vWaR<SWquz&769{KpZ`ATzfYJM$lliTkNLljm`O)W
zMngrC?%yr{S1BqA@&I@<aIgUwSUFe#e=IC)JOC~ZW`OVi#!)u5`ga}7e|%-^%|QU3
zzsr5+=|3gA{d)$e|GgkIfd7r92zsAfAb|SMpzASnFq^)AvHX7?_kX$k|C{o^qWr%O
z`v0v+($&`XUwZ1l4gP=h#&%Y=p8vLZpIld$_bpHWz3+nk|25SD{=K@QAX~Hlf2)&m
zF@E0#5qk^U|I%pXENSHdG*h;6F}3`AT>h48{IzJdR`x(;kh9faR||lFg_-&P=-#)>
z)aL#AaDJc3f2n})%k#e}CG1T>W`AuND+edQ*vZM*6Q22flvp`90NyO`>u3h__}3Hz
zm>BIrF7GaY_vU;7<{&5dzfP2se*?fI@|Wmu#0g*${e!pwOk#f!H-Jg}58?qZN&FXa
zF$0(+{~#6slhhx?3Sg4{gV+E}GJnu}KKVcBJ)goK^qx=g4|>n1^k2mNo=^D?de5iw
z2fgQ0{e#}~sr^Ch04DW6=)HH1Kj^&{%|Gb97Og+%y%z2NBA$1h@qZEfe|tV-=l6NB
za<=(n^6p^r2fY_>`d`HHt}_MMzMuGiL$LoPv9tRV^siB1GW!R7ZxQ$>!h5NIPvL(J
zSl>ec?aYjwE&t*4UYYqnOx}^zpBQX^LAQSd{YwvWb^3?@yNSg=;CqTc(b?b0v-EVZ
z1ls?@;$3F-5BOfD^*`V{e{DAZfbTTe{sX>qWcLTMy!ZbnGRM2C{rf)rL;p?)=ua{4
z&Y=HMzc=IXNBthm;r&f#Zwoa4!x=lvzokz9LnZrr)ei5c3Hk^9?=N~L$3L_G7jgwU
z|7&aid&aDP2|+GEGZWkYNyEneNAbUz-Y??6HUBGSVR`rX$1$+Hf3xcRhl;-t(Cr_z
zbG(~7zrQX1IJ|f8C*1p;%j9C|1pLQIztiF34*G|~JH4*|fbS>c_7C`8ru#p}=-vAt
z$yndRd;SBy)8O@o%lAlLK&QV`{m;E+>gx2)yvx7dEbo`vfAGKlDgc2VKvVeT1&}FU
zi1qi7_WK$Ue0PSue+hwEiao6~8V2uWrw-RgB-mt{>a3s*r(2QakzSP59SQ0i;T7T+
z@8gzw*s#__m9{6JXTx~a>Ag1ir75hz$)aPCx&guu1PtoJ`#vv@KAM3xkS*X{vJ`oa
zuG~n<1?czg{Zbxv1LZ%*LKpT__NzJN5T46t7@{@4=mmbAf1}7Z$)3j{g>hjZgrh~f
z@Iaosxt&GJoqQvfji-b6J&9&3_SV^Cjd_^&TB}fJb?(L`$JN0hguFo;o2K*@Jxr0s
zUi2<4iIokFDlsQCSZEULKsI({uO;bP<}V+e+#1FCWf&+{j=VD+8f&VuO(8n+%T_J7
z69+A?j_d2pe+!FYA-uCn=fMk>S5)O(mQ%3MppDC^GHY0RUxF=B$PKj+Oy^<PVag)s
z5^llZ0FU1cRei#nzi|8#t4Y3#ZjZOI$H&u72(J6zzLS$u_Ha46*Xo~61=Xj(2u8?^
zf3R4R<nqB7o#to_4_2YQ*$9H;mqkxQ$XSooZpe0de<8i~DdrrT1`Dki@b5neBSLI0
zI;!uvhAf$t>jI}^GOT%Jd+eb`<(?wRSk($@bd!z;vPDhMgvKfqz=J>`-?^$wjg5;^
zA_}PRn!_xvzuqYm@=nxGm(7GD{4%Q+HB0cBmMNb)`z&qX9<G2~^=%SJCN6%?lKqWM
zE3vRUe}Zvr>Z(hY5sP!NYL1XUO&wQZ<b<?AFvJOm8n;3*Xb3YW1#vr=EK{&a$GYd%
zvS6fvE=}Xrz54C<4*YXHdE9Q_)VAK1mLj8AF}3E5-nrubK0#hbZ!;Sz67-yi(50;*
zigQnyLa1`nT{%K$jHkJpXX(~Lm&qpTc%KoEe=DIw%;2r^_HbN{qN~#ajl6)XWm(L8
z(9E#-#BzRXkMdlU!B=0Lre<R3?(RAGU53&LFAdu9pG0gG2Y$CZ(#7uB!CreRyb$vv
zux-Rh3tQuiNz<679<AkAg>E>h<#^N?L1_Fs{E?hX860vy=Q8TRXX(72QKdTanZaqg
zfBl_4RU}68E>>fVm==IziGD20=aSK!4}5`M*vr#;YspmA|Jabl(+{nqlSydjV~Pz5
z39F3@90`)qvkO%O3-z;4PdeH=MZC?!W!A%eF_%Zobb?x1fJ$x;RO)~8gIie}KaI((
z>_!HM<O2_({z0{}PaK%qV_qBl@tLXEe^e_qSUhd$1-FzNJov|>>L9fqa%o8G1bP8f
z|ME;%#xuFY1$rXM6e;2A6;It4Re%7O&ZTcz)@qzS-LV(&Gma*#Zu*Z8crbPi44t$a
zJKdY?B^cz(Nt)t14Am(;Rq1nDD{?6g4b_Ne1<j55e(J7w#TN@o$8{{2@f9Qwe}M#k
z#+j5{>_x!`&|iM7&U6jH(hIcGjh1UlVw>)>4Y1XW;tp}!3?NvZ7($=I*tTIFh}gr$
zZ5U_lH3T)?Ds~Tjoa^Gf$p5OFPClM%#ye$Yin)+({UY|Hz`AQR#^F>YAA7}Hh_hQ)
zH2k<(**WgF`D&Vnwy0qAp>#6>f1Sjf$52rDsM;4!vZ(B~QV@D+KMg&(F%5PPjy<uR
zklPCgp#euHi*pM7fNO(_i^wlXFYQ-l@NF1eL$KNp6>Z&*28steMJks8!!U$yaxM%e
zmG!<o&Mw1h|6wAV1<a{7x$NY6Kv3t~+1R?!WXw4Cwz3Ym-C-OInH^AEfBAYkqcohe
z6+b@dfv3bxz*3^yP@8(tGcHu|J`I+d2k+|vwi(9)f5EyodpUF)2RcdY1){cCCQOY4
zk?d{Ex6URMy`?#Q?R*TJ))b=ps?6tQTiWKiF?`-n1Pu&=1P&uyx5>@&txxqsOFB72
zVt#c)wl@zq6_IFdX6Y<Nf8)GNfsX(S5_*gw_>NWI=zJuV3Azhd9yU#HKxeW_wC%#N
zR8>Rc_D3!-5<X%Ga8F0Nt^IGmKhDV3C;N*WL&JR7ce}G@a+;c7$qLpXR7Rm;uQ6Ys
zQ*zKY40rJZaHQzQs_KyQTjq(ayQg&!|9)au7C}#Pw>0VUmwsTgf0FPG32M+qF19=I
zx=U8YyeB7|eTLMP$Yb|L|J?83rOKrB@C%9ILt9{}v7rp~enX<2Wnwwd{F17@Ip9Fo
zF|+9_9Aox^7_%#ZM!_B7Ne5;5-cNdw=@0G<q;%|c<m<(PGc84F0%TP{VL4hYh<1sH
zY8NQO5eC_gq#*<of5M5vu)-@Hv)GF=%dnKV?@_V+f*y*eWd-XFJF(7?CD|=f@&U_A
z#g>9sxwD|?>)GSH(rmnLuoYRp3t2inJNOA=0$JQAPMjaTHn`|93wD7#q%ewz03-34
z9^H-$z@a6lySE6kDZjvam78zo7_u^$Sn&qj3~i*3v&drVe~G!=Al-E(3rS#Q^w&f+
z`-h@|9Y3;Ye?wH-P<_Ij20g0_63hqLajUE!j-zRIvH-a{fO$t=xF@aJ12~fJZG@GS
zCa1e`6FBx3x!w0rH+~c^9Tj{7`S}B8#UoY6j9ZeQv|J;u@=EO!0w(_BerL~yYqB3+
z#DZjm_&I(Te?udvBYHW1tv~g3l{ZRJSPCfbB<0GH>zqY^Ji9w+yW9<3<MvbnM0sCc
z#ufSGxf#(A^)iZw5)iQEFYhPIktgF~6dry^ZwJt``G3zynOSr0%NECO+niN>i%2Z)
zRsYx+FlJf{`;GM^KA0l#*;8Ckp&nI@M|$Z(CAxh+f7{9YTI#F8vmOUWSTfnpvKyxE
z=TDRMG?)iia=U891_bqf_ATj^3V7O2^xTw%T*e;<&B$L<*OCzoT$r@b0+&1|yZpQQ
zalXP`Rj@a!$a&K&3ygz())H?w6Kn(F0gqO6G98wa@vK4^fXKqi3G#0yu|5^IWDd}z
zoLzF!e@ODg%G#qFUM5H-xjLbyGk3mkfu}SS*z!wq=1Q!{YgK{Un*eIXxq6MbYKD5?
zTZfZ>?w3nfMAdICo?p~$Y_SAesW!h$pUxt#^GpXZB+)!{J-ODxce~PI*w&lf?6Nof
zYW6BKm3IzH#JX3Ph0*1Ou5g>cd;YxtMMx_`fAKy_0h6}%V~rxT)%lsc`IWik9Me}J
zghH^fBoNBPn4$4FN#5$mZP6na{Tr_!y$<Y5=!*3uRi<<&_M+p%V=RTo(iE(Du*^kC
zcmLsYAO}^9{-uAtPPg(nk;5=}%;I8WiBq-EuyUMn$O!U;d?FPCB>n*Wq$wt9dDQA1
zf18wVu{t>J0aeCIeyn{r*|32iMC?r70#zPEW;0a4dcdmWeW$yEl6qXVxU+29s0w~-
z{bNtCH|&R}zz+5G&ZcYDDoxz@Dn;jwnV6?bWdBYI(cl%!FPA^b2^Q(Mt^{-U!|<*^
zzvNO^NTstUtC8lA^8n4?SSLhLN;Ss0f2d?@sT<GR2!}GKFDp%1lx5c9w(b~h^Hk=*
ztw$s&taD41>)~0>+Pq9yN2+SI0@fAi?Btq4S_X&A=}A|a*!&9ntNEU8Q@9G4xOyrD
zMnMb*suTf{`<wPD1hS%y1j6?F;BTBF%)fdqyD?NHd1`Xi7ZAPUs0%35F32}Nf5-Xr
zj$T`K;oZI6#45a5cOSr(<{~cPpHRd}LSSo#ysd;wZ4bLO1;Gdzsqt<e^U4ApR0qcz
zN09IRw|O$ZfqlsvUE}|Br)xi)+E{r#v<?w-42Lnh*}1h4%zZ@u*hNMPgqspTo3|lE
zApC8<ZXS}K68j~06rl>OET|q)f7u;hqJih@%_O;ETgVE3!At2|IH|QZbepy_<coq6
z-qMjob^S^9y!<oiA;}4?ISySW3AlzxMEv9r2t;}zHni>?53ZEooMiZ2Z^k57kpkg6
zWW(rBF9;*aBd*2RQ6>e=Oo<y(U3IHu0BPkry)r!`ldYY3@>?f?PMUF{e>kQRygQy4
z{!9?Ms0PZ>@iJExV;)D@4vuK!j;ahGy{?$Ym=s5o1bv5+&;ymlV*l%Lg=3mcvOr4c
z$rlEI4oiDzbanfhwC;IT#;&9>WUHE+@JylAuSWNS8Bekovy3;0-qG_=6bk1b8-AI3
zkidtC`&oVJnDZ5Q-n~m>f7aF_p=tEhRqxMvdplCO3psGY-+2e~Z7UuJoQ?On50^Wo
zT4yvP&D*YJQQPxZJCBRUWWf22TFzn^gwAgC`53N_v0$Wp)yRpAeGu=qK!}TtHm+3X
z?wKer)v2C=V3J2^A?pr(^{hk~Es6cUGPLXU*rH;Sf}TPdN`@ogf6(phsc6r<+sU;i
z5(jyj`XMZhGny9<CiKCiVR9fzW;2sGW4zWA+_$mZb#rzpgRu&m1ZwYtzH#1Fc)0Y2
z*L8gcpls8U310H3Y2dsNW^L~CnB~ZwGacGQfq&%Vpkae^X3n76ckJv#LV9DDQco-J
z+TYV-POmK#^_P-tf4I*UD8;$O>rs>i3cgD}ONZHV#chTyjiU8(om|ZXH-7WoS+$7Z
z8+M*WV8VkW4X4vhZEh4Z=c4Y3?Trc^-4-$DX;?Fof2Jqwl9Qc&<b0U+em#eK{&uik
z)u<=wcB65kMTpQ9V0#8n;Q_5{Q9p-r`q`S(uNX}XVGeVZe>5S%z{XbW`?)7_>na7o
zD>2O!g?*#eykwRV6Bvd9O1fvI{|Lt1f!~#mW5;RP3bB<;!RJ8ol3cM-^-Nli;PL_e
zr}BdonrmXKTySs~cAd-=O|UtAyS<1&%~`Pc6{V-dz<{cob{Y#XtJfCzO9}=ES&hLw
zUGo}sZLT>ce@48|reRo7fp8j7;q-TwT<6>h1?-bY1RuN(d3blm>b9(3?VQ|hGL^4m
z$UX`t<iVK)cwDya7~Zv&jLP>l_va#behV#646eDJ<UpQQ6=w1_KUNX@?fcE_M>pK?
z;;rA(j#J$)l4?lywwK)LxSO^w=E{Yjrqh5fg;_cSe=7Pkq%%%Krk`5gmP_L!=OauJ
z(-}u&)(3TJzB8|<vSD5b)6Suh^NqWaTMO3MA4=Ej{Jb*dy&XmLz*J`}$!Vf^y%g1C
z<<~q3tPOJdlZFxq8^GfR35aNB)TjKW<a8iKFdvnfp<{z!WR<b}s0ICawki9H*WG%y
z4c<uMe}bVqX*$BRIS%jzEFl$Vf{YbWmcEx!M6*C|FSx<5tXjAU9R#p*)^P<&-^ODd
zle}IvC|<wxSQl(7u@jbdU@Ui<tiA0OwM2uv<V#+9UhdcJ-TbCJ_r7vh(WTRgluamb
zY=)<6*%C%L-?6i&->_D&moS$>v_mLWl_IRxe}Jm2|AbV{-J5Z*_!+yj@GV;oC6X6k
zzrRS7q<jEdQ7AwbGxGd^YEgvo)~4H=UwODURcMc#$)sS1!c?_BFm%hlodk+Dc;_-B
zp9cejJCb-+5!uyHJ^Ltwr4f;s@{AT5Sfpq``PEg%=jI`V?rnj&tbr7P7XduZ3|kHM
zf1>hRFK3m8`;8K*#Nv}b;nc<Dv4CW3AO9e69`dv<>1PjS3^3H47lia19dGZT=)UW9
zV#W|0#8d9kA*x255A{9chQ<^YW*`09{Nqe^4&}7wz8!1id4*nr-xfsuP|OZ3xTTi?
zOaafVJ{&;U3N}6;RBoB>6oz&~(=pkKf96g5VL*C)zGK+WL+Dh5&eFm}*D`H$ik(9L
z^*I9ji;#b>CcRkzxE?uQNrel6x@tECh5~nw_=$h>lzgu9C+`UHdNOu|`(SZz<1#&K
zz9w?}VidC<xm4rhauSFsR1S%Ih{m%-x2uL?sMz2v3uZ`2&p)1xB_xnm*-5)ffB1Ee
zMk;)vxdON-mRi#f0&JLAWg2ZFs4Bm@Lz?i9i6*1n`V8@X+Kxx4>ay*Y^j<2b$Gpwj
zFXn+qr=k}Owml{&)Nynat}()jz`+oUsyU-a;>2C?xzxZt{I1J7ROWr(Jhr#*eQj7r
z5cxjbw%P5v-PAW}s}dDEpX0J9f9vH)7@1vu(Nq-2p_pIX%+FnMCBwwnPTOZFxbJE6
zXCe5EeC)c<Z@yS}$6+OF`@!ooI@Qj(p1;U0{ZLapXXEtSPbLIRBBt2xdhU0ITV+JG
z34O0_hDUi&;MOq8r_aJoX`4<2^4Lw?RFA}Lqr67NB3xpze%f?~`)Qr3e`Hd-BAWd!
z`jO)6W*<B2Nj@wv2W-;@x^6)K^tv|L#jXiTtHD41=JaX$wB);DWKC`(#nm*f1svGr
zFrJ1srR8`yXWWuf=fTzE=A709YpuZw&V3v>l9yEV=`+AeF>hw#+slimd559e8|kv(
z6QhOEEuJW+)B*g<@Udtzf6?=>nf6&+1IA5Ei?)O>SZ&tn=g<2<Ewnbn!(3Zil`?eB
z7Z@v0X-Hs#B!68T9@|{{vkv6z+O{GE*18Ief%^o`T5wdKcP6Do<rm%p8vy`v#4r5c
z83dxGwM{ZU#mVrwe)B7t)#h?#RyH2RfY>vy9=nES0KzQW<8qy!f8D7KylNpsv47K!
zQ=4?{v2)5w#LBbI*S(5zMkxK)9)0Wrev(E^OPVo2pHHT_t~6%3?P@67&%htL8)069
zNCQj&n6Kx-pI*MUrO+RmO^4}Sb#a2C(@v}BmbwpH@FaS<!KCJOQD)GQ%<I2;3I}j$
z>*gV%M1jNpGDFj%f8uPD6)Am^x{+l%M<DkTBa9)b-}cS>xDx=SAXkSV(xk(Cn}^%k
z^D#ai<cl#@C8?6X&Ksrn1uL;h*-{M_Yhr)Jt>q;{qtL1jockNj%6UDfzQJA6h0IuA
zdqrZfEAnUB3|0P~jmzyu(sN!$$YZ~W^m{nU%BRrf2K5g~e_-<Xiad2vegbsH6CK9+
zOplA9ZPfMfZ}44^KW5*Yc*-rCCx`b5w+rn%W+)Kk{P<T#J<_&aJ&hH~eyf;bb5Gen
zkf-PxmIU=yw!XTDMri2vD3~3b9;<Ywzpk6tN5D=sxbv>9k&Plz>K`h!@@3LCamL>~
zZyPA|&Uijaf0?!1$P;|!B>7H3B)9Ic8Bd?FWAD&|MI`U1B~It#{KHI3inHpwCkw2}
zHw;*9c4#@N;_qbrXI#?<Z1W6GSSTp*?4<S|Cqz<Yua?p9VUo9qG5Hw%z+=Vb=D|l-
zK|wktQ+$Q)CLUMq$5_E6&mp~9Om@k=Ke`6-QzbUre_344u`tB2-Spwvq7>#Y=nOdT
zmL~5ka|Sv|>ec*ZHs#fuOR$3;Sv`XoEaA{$%jc>Y>!8B*O{(0S_&T;YBCcz<TfJiA
z@LPW=?PfK!*rBvf9kb;+Qqw6BvLcjTe+fxnyrwzM)W>*=aQ>JQ#gPUDj!YwOVjGyD
zV4!P@f7u)`p76QPco(Y^iWsJ_-<N6sr#3e1i2H->4il+pM3pZz0(DZOnw!gh^5uYm
zrifknq46F?)wzCk3j>3`;^$$Eh4aR^k6Jtq7Jd45@_Cdm74@fJ#Z$lSofi+U?v`xB
zCy!)I?J>eiYU{)Bg0*|ryVyjUW|Cy~n+u_(f1V!Ts-SF`S%+$8!*MrrR(bGDK4rWA
zI9BM%1bk+s8(VWZT3fPxFnsAM@-FZ*iY~PObXhcVkq$4!kUDAPtSWgvEi4MvHet;a
z9xEirn`Z?tl5{K9Io{<1o1uglIW{EZ8zm42z43GCWW`fR&8rcMJQGs;Y_l{^+V1AX
zf7G2=)=ho*rLUN6S4m`y&DaUWFa(bx=Qdr}8B253FGs`H>!8auDoglTsN~p7kL8I*
zb!DamXK)m@W87mP)T{QONU$%dk}ajF%m~czrl|Bg1pC5U6)nIu|JxUaDMkoqX5H`#
zbO!a}GShD=;5mf-sFquKyDu9-$AX!$e<0t4U;@VP+eL8hziiEZOt{>hW2rz;wd(@w
z3adz>@L&Q#$c~1Fn8v{<*6h5-Fwk#YK6;aW?ehemeDH2jNK*5M9TmgYcP^$dCXpao
zaTV0<ysnj4w#q##l;FD#%d<<AncHX?Xj^6Q>1*ZAFe5}r4ksI5;Y?Yp9e=J^e-QlO
z4^{hg_A3ldSHr6*nFE2W^m?yfr74uCoshagl<E@a$7v`w_C4{dJdXOnsW=DOgJBrC
zX7de{y4PU^ot;@pBGSe0$IMyk6}p2DB4h6NG%l|nQ3Gn9^S>(lXu2T2#<o_laa##0
zFTKjBd_>SKog0<RW6J3{=xNM3e=b73I>X&%6?BR4Y>J%<IaJy?z~UcUONH-?-|MQB
zj7@=$A*F7wb@?Ql0sd9@2S+WN=@#0_kdje1tzz-!j?dV)6{axJEqk0G&_q>qU<hs$
z4HN2%GHWc1>s}&*6Tb&m3J1Xxy$?6iXTEv7GtRZc1vBD?sc^2VOuIr-e^}Wod!O#G
z<tD}2AlF1iyq>Dc$F;-`{$ALn?X0<#N8y=0KJ{1LNV9tdMfKH8TW`12T>Q(8!8L>J
zZ%~-c!US+|lv>XGT9qIr=xX4BA?z;S5L&2S6J?yu>Xk;;tQk$DMw<A_{pxl!WU=;P
z%YrSIJ!#udXt|6o$uBEse_^{G@aIpe#sKL4FSmrr&cO}~8%(4|vCp6~)g$#Bio=|@
zJ5{2OpHkn(CZgfTxZgKr_@f6UF$V{kC1sAT>#I-7l1`q>&7LIZ!TO0>Frl#rX@n8G
zaPuJOx1J!b=YBQlT*i|kq&Up!W@=%AsHXGl1s6`3C7svN%yekue<$KPAYHIbM7d9}
zIWpe)v-$YV!Li(4=Bah2;GMC;srop+#O9Ntk%#(hN+$Cd5gp8QA36SO;uGH8^6SX_
z2L~E2xEa$s<RqPds&$2&u;T6yQ%3%HOx921`7OdK2%(K_sexuNDW>1%nF>rtLOj53
z0*r^EpsdCz$}v70fBQq#&&GbaUA>*AR|G-dYHB;$bNV$&z!$U+atjOYrGH!g;Y0-?
z8$4h3UjM=Vt(q?sz}bw%cwk?BoB)lTf0{o?)|w78zU=%vU-#7vm<5O^LCc$J_n~8}
zjZh6Y8l+<piBy+>Vcp%fKLM=dT%2QNR;L{`c%y*Rq=Y)ye;mv+4oWM6v#t|`2l;oX
zSy91MG-)Vg*x>Q1-w66IfA0W>9?x>0=7aZi9j0oLU}}`!>#8kccx$&ORo&<bKd0cq
zmy8u7b{-`QY`kU?o{D2?S7yxwDh>5Mu%n`$H*p@ScQSfLcu0Q<ePv!S1l*tD2rr1s
zI+$C39KUE^f4vre5_=&0dNEF*+-Lg@71bd~G|FxR`O8AMQHazk*K5+6fO0FUNz3$j
zMh!?;lA1H(z!cXM5?a7RXX(3MW&PXk-TX!Ura0|>kmwV|%cmV*6Jq8pL1PpH9=QSM
z+F-A<t#e#(R!i?9BOQMr7KKunw%^2eeGXi8r;A7Gf2zd&2(shO^Qvqs-qWy4-gHtz
zsRJ`JgAQ-m@l2<IxR9<ZETD}qMYB}2LTP)#64zzaSDq{K&a9q%QOAQzIlc4G(}N)A
zS0CwOyYTlikc59@TY~K2&G8<jKbrKPiJB5MX2?_Kf3g0;#xpT5U&Fx{ztGOALzK2{
z=;LB%e;vB0+O_3R!FlL%eiUlzjy*rTVaxi;A{Go8$*IHbNG9DA^UX-|{#i&4J}Dqm
z@<opFhOi_ypl0OAuum?GwPt`qXcWruSGBhclUW{g?u=rNx^x?OKfQ0G1=G@eSCdra
zDrJdYzriDcL_NZ}B_Jr-X?O~p<E|-*VEkxffBeP*${8`i1UGt51jGtg(05s#`uH7N
zQLD;yDDvFXB)6o|=GoGETn4*pgTqcWZ#23XW0wBp>)lRN@BWrjm88+^Gr@xeOPV1e
zv1i=ZbcnMytihi+T%T=7;nT*%Pe-CdQ<?TK^*U7UMzC<=9glwx<y0Ka0TiGNy4K+~
ze_0F2H{J*i2uk@1kD7drdELO%*aQ$7)$m>dg&ju|GDME=Y3W8u)j!ly#=u7<f?v{<
zt!%{n;yr2dWRP;_l+U7|bgzMXQrs|~LPl1&wIejH(H9q~&U(E)3j+q)2LRyR)l}U>
z9eFuP3u>>DddsdQL-C4PUU>6rxby%!e>aQmNLni|s7oV}2ZRz3;<_>xgK`Opb-y(S
zpbR|SicK_Eu<(sKD|0-rK1fv{7W7Ew2|r2E*j@t&sAz`b461N?z0unRODwS8EW+)O
za>PHn>G{nNY6W)VzmZz!r+6eP><dtT7wIdHl{5UN%I3vuoYuwV?iN7zh}jlafAzxW
z(McoZ6}yRMV%dE>n&+2BfS>v>z-n6U)kyUMrV$W$yuv|X=F`8494Loh!0*77=eYY~
zz+qMh?(=CV-Knium-(=QeT`>vaMDYLYDt7ctfs3&!zrz4yf+>h$Sf6Hkc~xl1AdM0
z@FZJ2!$V&SfP1tc&S2A8>UMoCf6U6vXc>3Mq)GqKcy*>ZG$REjE7{#N44^mmP{8Nt
zn_2W|fx#f4MGp3jKQm5zOo$$;^1#dpt2Jm=wvUxZL*7eTagplIg-QfP!BKHYVw|oB
zaDOBB7wfw{vP?2CM;y7vkR_4;Uyvh0oKdYUx6=o;g7J9_4KXeDdlU^<fA>g#G+JEx
z;+0!*q(EuYLI~l1eSnxTJdYCqwdTrjejcYVllj}oWRpNLncZOP;MXh0#~{oM-k2XQ
zqC?(0@O~L@#h=A*gFj@Wl?rDL#^yh~ajR{#k`o`q%im81EJABIz>1NrHn;Nh_aR^@
zzL?osh4n)cqFu(}c=gS)e=W&>it*NRy?-!8NSsT+7r~F^W`+u0jfP<|tn#<<y8rqF
z2j;z3S*!|y%s#WLsi4sWfbwR=L~kq=1<UUF)BtQt)GNzY(BOM+QE?iPD{2&#4|+Cr
z%fcpcFqS!kWE$UclGxC!65kRzFY>R6BiE5fsQUO?a~*$&fS4C`fAxDFZ^_sRhqoZp
zf3&_U+74H=Mz?s0=U)3)Yd%GgOm}1)Y>RV3r4?kieJT<7InS#_@2U40R=Dl?CEZ5g
z{lTCon5o$*Y#$PP7CtcO05#%Ee13bp#?FD`;15hGGNoaG?{&Y27C-ur(WeX|Gid=u
z$@=IzUVi4gl`ux}e@!Vq@9hFnMBt^%u!cD}ChidhA%r!Z2s;tgkUq>Xj?v0|Di2O|
z9|Z?_L})ZYoX``1va2LyB~NFU&C+b0+Y*~hzS>9<4q;?aD8|7r`ZFdz_8zu#>H!?u
zM_3_Q&82*J<bD03{Jdq248YMHrOSoGYxQ%`9;s{*H#AY7f7X1jr50qSVbaGUHR|?3
z-{atTtFVhDsU5`B#CBdQurQ5P!yUkUe(;L?(4e8JS{~Gvw08;$A#8f_l7=KKntC-P
zlsd$N!M&$dzONNj`RYDaw)aHeTVi3qI0rgtDM%$g=w~EZ)zygbqccq?{{geytD!n@
zO45!{T&N~uf7`k8YBYPSyVx(*yg@DDe%cWD=~MkoZ)uv?fMagyUC3c6lfiRR0;ay1
zZ{*Agd32^6N3O;fvhTe)i`%KAirMDe<-1iW+DheDiBuC@MJl=dR?8m(U~Pm$o_ATp
zw&=Zt<(&9D$4+unNV>kZ2ZU<=$U2#h2OT5YI_zSqe^}G^BBv0#z7n^6_K7_bS8=uc
z?CO1lQCpueYYX`tLU}f%9ml?^DIWo28{maNu+jcYU2w&E20P|)XEuodF`8NTkunX8
zRw+$@h%bIAp2!pfytRancZ^=@CrVD?**eakv1v_~BfTYk(<k)tu$3G^YOf(0yNrr&
z!))zDe?4$)yuV9o%=~FSLZH-jS_BUW@N|`GMN*}ja#70s)a$gyGi{e$(1*B?xpJf~
zMR6upU{ntM@w<6|bk|Th+jFb`Oub`pC&Bu^9ox2T+fFvN&5iARV`pP~W81cE+qRSc
zp7T3T)$?w;X694fuV(7LyRS=P;l}bMYlc_|0+`2g7WKL%%*=)(D+<yEebIf$u8^6(
zM!6@Kg%o#EownYjjh9R7qG$Jz<W{6|d6@%1N$p5~9}#8Ut*z2;`gmcnb?OVh{Qa+m
zBT>NTIko#+$MJ0eg1X{|AY@h_U)+WTcwRB1zW8`s^<^s|9NgIzY_s%(>s#R-h?)i4
zsqa-j`ZB%<u@HYW>^ChF%DRtj5*Q-Ma;_Ysa`#pnzY*?5n6J<RgLTsPRx;3#;1L7>
zl9^#wF4u?!RDxkC@FD@ZjD-#RbGICf?2RH4C=5ORZ-#hP3w$xhsS@Z<D3ZoFAHJ$W
z_)xmv;Oz$xVoF7YeV9BJcwb@wV_hysuH+3Z`=D|{DitkN1*VD1pNSn8KF6Db#^M5M
z4<DbaO1Pru3ks!NPj{|duMho@2eA-9iW;l0N=5>-A5>CFn92UwbnCgKJ`3L10*k^E
zbY30p?~Z9J=j-l~^To=5qIO^8*+1ODtHi*+t{Uu%_<Uh}AFK(Bf!aSCU6!Q-rd&qH
zOD@;RRhIWdB_ei;vvva(i<_3lzE0ug_FnPAW>)moYe?ynQWxZTwWQvrWc^$LMllZ#
z6Mw=Z5*P`Q{v3n-MVxQ=U3hUAKR@xWyTqDE1#kS9<dZ;1J9mXz2YpZULLs7RW~e{#
z-<CEMd~I3*jYTygXxiPWLT07iJ#4eq(EOCol#KG*P%5XBvD8#Q^67!S2A;-=hQp8}
zDw1w2d{esU3I>smpmOffb#~%TfcAzC1hSKC)Q24Lkm91(0cU18iWS8h?mb-WVuZmH
z&u96VyR(%yPezCHbxhScF=_JVmv%#anC6%~p{9~_rIWa;1#TT%v{2Zc?WA7?@7XJa
z`{!)X-Xy0UZagE5PS4(p3{X%sCgHo33aaQ9`fVyf#zto);iOgwn{MYTz_-P+!ssgG
zHWnLHANQBT?@{T1s97^9gB1?wgh9q5{1ci4J(@6k@9j@;JdsWD&jaXID|seJ#)ppk
z5YUJ(Jjz)C+2~xIL!h#WXGd;#F~{RV2Ux0A=Fq`3?ieT*hjZgp^sG-4%vlyjd%?8<
z9abG8rq}IW{$Kp^l4CiIfcnE<i8!5wf!ip~2Mk^kP>(pdy9N1SP54xDhfEqN2MEVK
zXdMMUil#DJFPdEceDW498TCer1w@I#(<K)5=0SfV@QXWs(5O&4A3t@ZHhpvrGjMn}
z_z$lBtiHcx#@pKuycpenurbU*dh|3I|LOBlnND1H!Fy!@3CLQK0E~?`gt$UQgtM~@
z@%wdgn$x}sKn)4)V~Jr7Z2m*0m1`L!Lj^F7dveSF>A+UcmRa|^qmQ3rAQ!n0KSMd0
z+Y|AgJ%Jn&%RQ-~%^v1^Q5lBd8?X>m*Pe}B+X)Gu4!Rns5LES;WIOPa#+@jxt&Yp0
zFImi4wHl=L<oGdz1PIEuY1AZAq7r1hOaD{NnCv7pX?@(<`U4#%-AYrm`H{)SrfHmC
z6HWa)C%EP@)z1t9Zxd`d;rQ5I9uZou^m6_O<#^G@yU;iIYvW*nPx=x~goJ2a?EzbL
z`==Fc7@?wEr~NfKFT1!pMx)M!zZgMgRB8@pIjeZ@SS$Ym7a#%WR!sqqf1??wtWFw&
zQv($Z1mYL`5i)vqTfJD962ZrJaeq4VM@4Hr5fW}P3g11pRt2)BBF|t~)(Ekrg3<5@
z{QK~23xm9)Q}UHX@Rermmj?VodzOjFoZ0=?oCVQB*y()13<%}yR&eZL;M-X%o(v6w
zJ;r0RD$k3zA;6*x_I!N|*Bu`ssBJa2h#N)qEgO2;I9!cTP&U{~#HS29L&3OM+U$H_
zI75Y&O`G_0x`9*C^r7N-guv>Db8x6LIp&FeQGt$sn;!h`kql&XbJudeW{@pb7@D-D
zeB?`}3-~e?7ms)K_-@Oz8&8Xc^sF?~1S(fBRDm}>9q^^NXjUj2XJCduO~<aQv#u9n
zR_u1Ttw7~rd`d8d#8?&660sw^qt-+k+q?nScx|5SI5OHlc|CEw%2pHZA_5w&^hjWA
z{#s!kRVy+!u7SJ&zHX@J=>W4&tzMp^<HHPYcpUSuSLey_J2@$>IuzNO)=PmsCdR*K
zf6m<v25|n8b`T;N4qg)yp#RYmy*$C&u>6m9Uz1>@YZ7#qn~cIwe;AFF%2VGVdynb<
z`z0lPCs1oDSdE-W0OIlT%Fc>idzMz}O2>tmCdOiBv&||)d)AK(6lMmdLBZ730D`&G
zwQS}Ii<QKTr#Bl#d_3;BokQU-V8&YFGRFJb8$c|D2(prr+q=wZ8ZEkVED<)l+f*Sj
zaw{lRmV<Rj+tc#Un0@gVCxhS9yfA!4T!*q{HY>{C7S<0&&fxMPU6xHVW25y*5QA7q
zBu_OCB6fQeN8(BAZ>l+`LJLY!GeM|yQqF>K4F|@xhSDpE>yfJ{S(wJc@AF-wYNERZ
z1ORW2LL02oqU{0a0C0gE4~BA#KbC25z{f3P!x+|TRY~6W&WL95%mr4H96bY9TQ^**
z#OO4h-rm(N8nz=&`FUi}rvUVAH8y(u`wmfBh$`S|v`~TjNy8uy)|$UyR*H@`wjUkK
zx*?f-B5hpiGZ+o%()I-W9jB?P@*z@(9Wcv%-1FP0#_mU|{}sIPW#piwRcJiOOFS{+
zv0nslg_-|V->e&UiWBsn>L@+nu@(E=+3*W!;*6kEOP1$wK^``Bq&`Bv;rb`!THXJ?
z-pscgS+Y+Aww&U`)>(^Mw15JRJYG3O%Rp?7zUVmLrNmtS9%+0QV+Dq!A?Dg415jTk
z@aF>toN;lpHfI;EMOK-P1C23nfti(=-Tp72ID(?V7QMX9wD6|P&O2R#uC0shCIdMX
z)y_ADd)4>i;_={Gcmr4DhbSc;)cASp!SKscPbdirZ8nDnwEA;QI_>FP$BL%=CdZ2x
z!8?UMHQoO2?y+pIJ0DEV`KWUy0U%8k|6pF&r+0v%E3V9c6FVTqvKcJ;=t544L_!5B
z3G>>XyNDX}<Tfhki#n7R>iSWp*5C9S?Df~6@_pfcmRKTPjzgef2g@~)Sy=UW08Jv}
zy`wb~PxyoJ2@s2OHxw)azL^d1QQ|eZEnf#k#(hThmjHeRkvJeDxUrMyFTmUCbwbtq
zZx#%Npb{hBYO<InVEc1$O?J@}?0`P`j&!B`evN%6Oi063!%6&?rL-O;EZUBhWzN--
zuAYuLU4^i7UjANPt<jg6N-j8FYK0~kqITg2ch2rn1#p7Sou}7x3e(YNB_Y-CTM7v<
zS|4=R5V)#&o#B&RNe@-4Y=E7hR;A>12t}**BP{AFl(bYpPM|0uxbq>U?A0>g$8Tv=
zxXS$r760h-hp-cob%O6PA{+YlTugqWleC;+OI=5O!73;UD%@uxO(O60;OebQ+;y*;
z4?PT=L`$G#j?Fli%5-B|;+?By6k-(~2F7;?2bE0Tef0{xczvac89)Q01fCV3sNYc$
zVJQD|A4I<uanG0EN;~EAFaN15*!BE(lqMgDR?21r-SA1Ln8&47p3K}{>Kn^|m|tzb
z=GmFY5!Ip++Xz;xfjz|9N!zNo69zkc>ZxKBfzy)uwuElnE7^Lg0l_9zQ;ZgKv7e;~
z<=>e*$taq8Y7}K<4?u14d2;%YL|Ffv65hr3uz_Nm#TA&qgpK-oNd^-MI`nOh`(owE
z!{kFPzkIrIz($VMkn((iw@!n!Ot(yh%#UuOuj|C;Tyc=_{lcHzI2*^$XM~W?X)jfy
z<~6fML^Xz;#n_w_G7}^x-?#KE`vHSC(r5y!f$1gcsBoINGk~X`v_-Zz+}kz9YUe|P
z%-la@kDiLwG#9S?QV}V*NZXDAU?RywrWj{bGp>I3VOkVS>lM1kOnYm3I0o#Xip9^f
z%p)`G=hv*laqhW-VwAUYnNpj#b@bW$0mnl}A9KAfNR_kV6}U}EhNBLnwd|wpJ5JOH
zek@|>nMu`D1b}`|Du(sZcV*f9OY+uoANl?%m(67=D?rt*MT9Q8pDA!!mqC<$jGLN!
zh~l|@)ya>@;Q)`ClY^Pt4$f1$jZMcn_gLt&?k&LVW-TMxy9GB+PPlWrsAc4c#f1PG
z&qAC2fT4Xe#&pFxk&z`Gf()UfBW%;pfM3RQr%@sj2~bY9NlG)dv9fL_+f~<MS$YP8
zDxyA;PWIejxM4&*0;CP+fRER#;y39;j^rDO5@45~Ch_SwjQmd|q?!?F=Hn^79kO@N
zYMt(=Qk(_sNMy#!_7sLp0=$@Q%4|w0^l2WB2lKc*w8>H|V`8G#F}m8oA3rz*TDNVN
zl$K->1E@xNk8Ff?j=OI&<olVlhuRqM$B5DPcop*xg<r(^OL<Yg=XfVyQLOV&Lvo=w
zzKbC7+XIZ}mLBdgoieJ6X^l_kl_GfKL75G!3;_dCe@U5u<z0H~U>7P97TTLOe>jlL
zDpn_<DI9c}n<TnbCquN2aDTGomxnUN{6eUoD!@iSegkFSao};$ElkGX`V4>~a|Oq(
zBda8vJGtgy{(aj{Fi*~kyCr{bi2T-hQxTeG#vMn>`ft<Xp7hBi)E*6WdHG{9uc_m=
zEY|=YGZ66SuTXcxU}e>?_uEf<Ot-1%32@^yG-hmQNrlKaSH(fF3=%X{<jfX)dqOM~
z8o=1x-!y5ia_`$UAJN2a_a~ZTD;vv_0DuwWM3SCPeIA8EI|N@L#FG~b=nQ2wr?chy
z17l1P){cB@GQQnXrXT<hhKclD!~!ilw7>?Vp;-=?RWrc|F|4cD3^nnBJp0$tXZ&1_
z<*nS_Nyw^wekNZ!Njsw6FVIc>DLo$xBtY3l#OstUL&m{sMY=@Q0+zALX6u^RrT)Ri
zEo~)rEe-|D-O>hQnGBURs(=_yT1aNY`l<?>*VmZz$X|IiQ=(!r%X?!h55f)}Wh4z=
z=!T9LYTcETw1Jmpa{EKJ^QmK8$7YwLcwvJo+zH+EDd7fzz}sO$uckG`Y)aUseE=@s
zJM@?iFpsaDEZ<HP%;cx0kg^Is(Iy!^E~hQ5ZMYVZS|;L(_$5{M+Ou?J#vSUUty!Kn
z2C#$JaOw3b2r9qZ2PyPPUO&;R4rp>^7BYL)!87NmoT-wvB$#YA&3)Wj=!g+udT}<~
z!Pc@-Nixt3(oQF{Dvoi_E4`<k2as7f=mT=Mu&0vkL-|Et<rSv(UR%h=?EYHa0MlBt
zU}estr!MAY_x|P#*|5fg47Y+X6ZsYxGyCffKxSFx?XeJL@$t~IiiYxD%(%WKt)8mX
zufOn$^aJ&`3-x-`X@Mhjb0$3yFO`#200!d#32We;1~IIKX7iz7Z+W><8Zc;ru?dUM
z_oQ+=y6M=CSN?Y#HQke@t4P0$)l8}l$k9fe!%vE6?->tlpr+QIzi4FLA}Az2#h1_{
z-C{0zx8aXUdL2`1D#9b5Q>+Yy@IA}vZ#9uVFWS-N5=nBGBJ$p6H3zQWOm_2Dj-6Z|
zidCX@5Y0k<#&Nsbu+Auywty9dZa=>2pc4lzSq;Ma8aRg7(D79wxcX6f#2L;Lw#@S|
zZ9^<~l?s{&?8W5`dMk$){^6~K?xCy^$YujMbj(1Vr*-^TO;2%O&*fHRV!^(1#GG5H
zMYe#o>&Su-QC4-@op_n+wPX`p1vJ?=H7zu4y_7+OTwD~iz8jCVE`W>4k~&2Gh&LG_
zNO%PdcFU6eeCKM7t0MF#|HlXOX1~)+>|e*0Gk$NzFh?&s8!Ja_Bf&nIA$jT4qZ$T>
z5nSkT{RoQ;@RtcgX;)vNmvswhjp(LQ?6<TgSg{|xS>>VC4a6O2%dxMtwk|~%y{Ic^
zM>|DFZ0kD22`g14JAf(blkh#wnheuin9;+MFH53qL=T8I^GIN#%y#K(2R}>}0`LJ0
zM2G!8R7#e(akZE7gy`!bSHmBWKbHeM&hXr3fdR!w(B3Px=A>a?Kta<5VU36e`9IYI
z42&Fn132#(-V3FAdLq$hakEk8SNBWcs9*6BmU)j89^p<Bhyc0DXqkK~<_D0)wc=&Q
z6%M3ISNz!cf2Ip+toJbT^xK3!eBHGXrlaVm{XNTrMzj5DRA*;x60@O8h?e+dhWV;;
zWGP(|>CW^~vdUDe>3dkECYQ#mg*B8CU$H?c(A+_T?G3Sokn8y+RZbNywPfn!p$;#`
z98WKY@wIKaRzTsEG;24m9S&8?9|7KE;H8VlKts>2DfYqY_smR(U5Y_?alYMSd-~*T
zx}oI{`5lrl$2eHsqow*u<9cZLNDhHF#V}!~dzHDa{E#}^d1w+lJ{)Fof$O=7l*+#r
zHVo_Q^%bK}7{_0$#VW)P;r_&7hT^fTwN8oZB>q~bX#lYd?Mk^Epz9WuPqdq?4Roxu
z;k^Es8*5V?!fvZ<`l1XIFR+^YZyav2W>l504pYuN_E)&iGQ+U&6#rjZ^co?@_f;lj
z<f#o5cklW)w;h^ESC*v};FKs~(m{MRqgnpbrbvITo!0-}7O~nv;6qe4F`-_h>x{}g
z;x}eex&k7#xy<|lpl41I<QpPgxTO8_Wx)G`^6y9FrzP9!Hig`J>dDQ4Y8F{3o<}dv
z_XWqO)QmC;Ff9Vmsv~6+#bZZzBwO5ny=IpNIc$aNZ6jT=x-F(2sY_7EF7L4oOvRep
zE!}Cz(tO`V&L>gnJ%_oOzcEf<6mDlmBJesav;m#ArC9&y6)n9`+Q|zON3(tFBh+p;
zgrPZtf{BIh%aK!uPSSMRZ0s0}NqXZ>uSf^q{(RftzRi%U#@P<tGt^G!4Jm}>+F5z^
z$vyC&L`xp`AXF^)>E9G2BDoqHIouj-9}gu2CTQcG1c}|7gC;qa86ML!R5dUJ@!ev?
z#DKXb+>^S(>v{<AH{nedJ?-uF#sHbif(|ycHOpwk<>L+TMV6{5@gw@x(U}H{%=rQ8
zlpadLhrO*CH2B4G2K4~5QavwD69%!4`EgaSsk<|R3v|OY#$4UhuK=pZ;vH7p!{T<L
znV8g)0%iq(BFAL{b$=8n8)ic8&CyAF6kxTxbdJD!GoQY!L=FT+$N^7lmY6wQ_m)`}
zSQlB6azH*f@Gf?1^CX!iusUsTS{fe}(>4aw@fFmioqlM5W%!^DmPFH??j9W4goM+Y
zLYrkbUW^}YXK|VA%bq_u+#g?TRZ{Uwc7*54hzbR5jFMFZt%7^U@CGk4B%Db19-yOY
zn!-jarU3<GqpM0yZIkqio7r2i3^kS$`;gM>krn2lQ|b)ey&q(azzvj;eODEHap6H=
zzHpOnWN#!B#x^3m=ZGEi&bjlN@aii|G^$E)!A^|+&c9T|SC|{^%m*!)Ixq>8tRUp{
z^O4r<H@&yORfjnWa82GCy{^J;A7C?+d_g)VT*u#Mn;*5OEC{E98t*ix;<3bj=$m7X
zgW1rsx(<01aB}TK9n+DdT?@*%*GkS?f<R>rmq^)fi6cGXuS!dRVY%dqYsIVaSXOwG
zE6hY2LK7eOC4jX2`NgAK8Hyg*#P}Yx00dl@a?vFVEL7&dxFipi<Tkb`4R8#0<`+;U
zrE$kEgLt{>SA}^YC1rjqvT`11uUx~&WQnSZT~Lss_`_4FH=;siA76@gou={WJ?bn|
zZ(@jA9d&j{q^d)Kt-&kd>04sT7fjhF^o5{to`BQBX0W1Qo#@T^eu&6BxnuO#8Dzu{
zmcyN(D*V`5v4al34wTbm;$QulLh0j3ZLD5#=<Brq@@X+id`(h}4ra_OfKc=$>}#@Q
z<EbyC_X87?RE7(>+uO1%3iHLI(g#6T2MRl<{l%p*J)P8Pf}Gd)dTa_d<Fm|kj93cK
zhr0=j2;0IjD;Zkd8pM@P>!LuCZN0~|m9YKu0R&<ScB2e?KTfpA4iM15R3_KkeETP-
z>_|ikf{<6RhzNFNF_msbdx2YssZY%t_l|?>L?G1CC<KfH3nspDtJbn21u7Yw_~Hs4
zVV`eq<#b`;73A{-F0yj(uD8AwAI#MW{CP(J=dNrur`h0?u&Xse#P-fid<@%3M^B43
zGEzVO30D0S=y@6=8?Z*IO{r+V%gxyHHe@l?*-nvT3ETcxGE;t+Wv}`Zgwi=-jtO}#
zV0K5%>>5_~83pFC^y8VYH5F8W-|1*M@3PUg+vXc3?(`m05g=+a$2&5^%1gu*p`M3!
z;6-F<AHQR;l^3*)L&-gUHsq<LHyuZ2cN)+%0q2hhj>$o*0Z1(B5@y|qr@f`wg&oFn
zG_ICJ^JggfQq2?*=r5jeULO<dXn<66ywYwW;y&WG*@~7KOPl7Yn!@KcfO>y79&o%@
zhhZuLfz!mQz^0;oZn<7R?Ipo1G(ul?nG>6WWF1Ipe16a?F)mLYEIG`~>@SfTYY6cj
zM}3UaoGW3J0l-G6({swU==aIraDGXN8*zP7{b_7+K()J~(Zz~BV#TA{RCXu%CCW}W
z?NZ87;~}VcAR)d>R(IJJ#*Ne@vnlfQWNJ2GNv9;oLyVvTP_8Q#H9xBZ@|$V1Ao;nJ
zj)yB>t=IYvEx7~{T=S8D^w=cP&bRDvN=V~Con)jn1Uv@1m;ah8n&qfK@*IohilmyM
zt!Wc8O2>z)_aDxP1ojl$iA#ILSh!F59r^?FbYNJFYjh+BLkadpA{S0Tl2evNV#M&x
z)RR8SIsQUTR$^X8anR9OprgazcJk}-q<2j|H(SyNHr>oUdUV1Lc2SXU48kI(s2w{V
zzm{B39T0E-dh30sB$I}MPiT{GANTlZlL9fMqmqF1^zsLmpr|-I$-x_&%esY7;I{;3
zwEMRpa3qZDlUnzu8#!Qkakl<P&JW{y%^0>v2aF?PKy9-BN(^|Us$$@l6QQo^2#P$w
zBOYY-is=_6!guQ)^b8{OToYOUg@|+@{Of&gAAssH3{1-&In{hy#uGYtoImW@e<G3K
zFNQgmwRdj0m6F@2Kq`zC)@5LVa1Ym()XHe1^zIn>ejCedW->GeU);aqbWdfZ)0wAR
zNs!fEfM*VC)Kx-rX)Pabbj5pG%TC&X!U5S3iPG+Uc@4`f*Qi>$tb%xxZ@U&q6wYo@
z4?vlYT|G>1Rhna@jH~s_X39zNfOs^xxC-vV6@0<t?YAJnZB`FmQqxcaoe0WyR}ASQ
zx~2p>EQ9_EK^ZvGHm5|YhG>6e$I%V63i{%pwcJ|`6&1ZLvhZvEl~au@r{&<}kn2aQ
z7wXD;wK-77qjgdEp0xS5r%QOhtZMcoJ3uckMM|<M?b{LuJM^KvF7!eMz=q&Dar{_+
zJL_a+UC|+dIVulqw>-cr&{KCckBuQ*Nu~RAm=V?8?4jz#bPZoKJ!fxO|NW83Mu$cI
z4RPvNiC!^XyZ`UBKwZXrUB}}?^saxJY{p-P)&zMPuPBk)7^USQ-EJiu?@2Zb1we#k
zz7j2Hdj?=a$sHtMXu-=sh9?QTRw%=DM?D&Gfd?KSsL&z2i%sSBKpa}nxT;bYpaF+b
z)Qlz)I}oeda^RkMePG4`s@cq~_Ts{Yrb+z;-WYYJ@t!uwuE87shbkzIuKY(RMz5h7
zy=U5i%hTQfksys(RwFpI4;?2@3_wg5H;Z`uC3+na!$I4Rb!Kd$+ll(An}4u4grb|;
z;6<oH(tju+=+{Pxsw!Ux5AiKW+O-=9CUi&f>?_ZttC6_UP}?huf#Sf}F>rO=$_VCS
zT!Fwf;mP{pMVpu_nrg{1@)4)#^{-mi?1<Y8Y)lfDMmHO}T*$ZtQD}J52iWlW<{dj^
z@~YAwb$Ken+$Q!NrSil`-teh*pP0<v<8?<hl)hwQeak7(FSp8>)b)&*sy>XVxxMMK
zaEE9?f!z8B(eTIG_;-2>C@@r;T3AxNei4`@u_)#JsWc85B$yIpJG)#TZ)8-6uy4Yp
zfOt2bgwJnlMp6A{c8TqA3Gn;=W@pJ<ti0?XTv<^!^xb%aRlMmoL7r~Y)?|K+^`3x2
zVV6qMJ4Yr<khKrb7@hs%`R{Kpr1y!FBdP#&&c<L@j5jRhz4twwH$X;moVdVWxr#vN
zT^^X~(O+O2Szu5mLr7nw^n1hcO0@HiG0T-w>4DrCUi25g5~4<j-vCHRpQ@$S0J+gJ
z(nZ(uj1Z36so50XJCurxM>o_U8wj}fX)DFwTTm;&RQUWmy`U8XtLkYkG!R?4N~<uC
zaj%q1SqDrYSJ5#sAG1m;tCuAy+)_-s@OuoBca0Am!aZjxs)<(AzFn+i$ySwBr^Yf!
zG6$F-{5UXV(oBOvxqu3%?gCuPM>VaxH{CM!v$0TKpIs0bQS5EJ*{8@tc!L2zXr^p<
zme=&_kZSC-Yl?KHq!63JxK3X+-x2(ls9z~wQvnnnTO37Ub=p$+v<w2pvwG6|-A(+!
zHzIJ?R-A;?(4-3<rQLFs0VmHYvF?ckt1dw47BY54nw<Oi2(V!k_0|mo+59no*7l(_
zC71$4K}G}Qd5Z>A|5j{|cd`IfliBA%zD#vF8x90!Z@U?Kqh?Qw#9L}ww_K~IZ^^rB
z+1M9SSHs)8u!S;oaxe3bHU_`}EvU!Z3SpJ?(i9pV`7HALLD&o!K~W?T)lsFy?1I#k
zBf$X5_p<2=24L3`Z5AQQEoAZ8a~bcMQh%>O8~yc;{DxdO`a#`drty%Jn0|#eN=$?g
zYi@j!XMvHztDow0mK;+y+*xmDWG0C??_!8&CR-29Klpn+TFmQ~)F;eIm-R;|ngK{V
zUkAJIH;;uxss1-&kVVAj+b-RW4+tB^C;Ha|X-Pyz0{|%GlJIFAs;D$}4mtj&3kadi
zA^T|#A#4N0;Cv~sB#Bv@Ur@#tp{X%VK*iu@Kkr;8ysuaaR&|Oxk@uaBKtf5uUD*|8
z{$h21L<bGJfM{Z((C+asTPY(@^uig4ZMkUxDu}ySS>LagM*%2<f~rdcdTRF8ee{oN
z>(a%&S3r#YQ{;(|(PD{q!IY(}-XU}&)Ylnv(h^!kdI5=6cJ=rXlJ;I+ZhNZ-Quzha
zgD<4tlr6ej;d~Y)wo&w;Ftf>7M21*?rpmCxElR-)CO;mgFt)PZg*~#)&f+dcBd094
z_zV%T$0S3DcnBKZMMx#14!q10U<NWNZ3aEU2O##WCJSFsGWFHRjm)&*Z_FPXEJ2dA
z@X7C61W+k-u{M9KttxtUKIXmDqjuO~fwG+cd%k}<o0`Mfpp#LJM-4tH?GP(i)%H@a
z$U12emA|o<;Hn&-vH-TyBLl&%)*USo$Ch!Ms@h$WTrf}_x;;0K)LyJB-xRnM-*4)d
z2ABkk+2t%$qxHglxrcjHn9^O-AZLoYiAEY{^%awG9PO-UijIX>FouX`F(fJYv5=M|
z*7p~DD2#_y5-quQtuDB2z4w@NjL&f{lGQ2hu~|1xh2g$ajNp?<OD~e|ps}UU8|^x_
zwGa;?!Y7$C-Ub^!F4}jPk;H%sUDw0V1FXFHB1|mPVBV}1eo`}1$SM+6XN8D9`h&PN
z+{V7PiP<qtyaIEOi@j${3jh1iTA!kQOYm(^H?DY1g*N|U$`9>`-~<ZT9U-Vop+D3Z
zmpMT%D2NQWkHIBl@HYVSV&t*y=!!h>blspcqpX@?jy%>k|BTX~tHiu__fie)2L$9Q
z)y5`Td}N0k9-vm)p^3l7DT0IjTGC}>$E5Ny`7E1kis2-^U!xw}!x=x>hQal$HOPRi
zdn!Ek(9FGx@In?-96+YW#q=)MOoD}WcDN@O%snXonP!7@8f1q6TRytlHU?(pFlLFA
z@^)W%Cu-(YZWI&XoPX)49mvF618mFK_R8=+L&8@T$1DYr<WK1|pLMZmnNqT-y){vx
zrvIIQmz^lCIul&lhn;u8`worlxey|y$_3Ty*J%qEaoZoTZ|)3JeeN@!6{Z)wN5V~d
zmydmvQE-{_L%@wsoplES9u3HH+rwTNdE2;yAq@&d^1-w6c6hoFWMp2?1)vO&gM1XY
zAD7{QiaK{TOdl3lQ-iiT_1-Y<5a1@Pno!kb^n!%_WOy`i)PY#EvyUlIusB=K7kWs3
zZEJT<$oT}QP0iJ824Hav*<SrB9It8Cc@;ky6nQbS&zakx^HiXIs5EjqY|;+RO8G1y
zvdPrj>~~?Tx8jHmU1emu02HSsqP+i9{2>st=s_h5?>!wV-b_Dspmdl$o-Uq{9yP!G
zu<X<V{An9MN~~7r8Fw$UhgIp@0i6jEvi0Y~4-&LtAG}g?liO+*L$06a52zv}CqVP`
zk<E%Nrh$x|DN)Q7E?J#zCaPiQ76NIn<Fv{Evm}Zzg~Zkj|C@5Rtv$#@g5`hSwi#;=
zHlRD@61HlOVn|{ghS4}u)+ny^P4%f&7D400658mP;e}55Mzf}bY)sX$8y#j+q>FB@
zT(a(@XG0vk)g5@UE-%Ct%Ym4qAcITvJCG0R|3GLgO#hX@wlIW)5#oZdu>5zF`fsGt
z(o_I8i39Qvg!UgxY)eWv7|Fi}{_BiIYnfgHV>ba|`7cEcwFQeG{FDHM^}kUVEm*qX
zG^!x1|BXUx(X0iR69QrVUrPHe_!k8T>;IW&TP86fP*^}%|CjP04KaWV!uG!jO_)LO
z;eoLI--KH50wEp+K-m75Lf!`vLkPn5zqyR=LfC17u>CLP7dNCmJP7-LQ_xUYIRF2A
zH#R0trvJHZ+1Z#m|IcmP0<NfI+rbdsp|Tm+(ShzxZ6^*3{O<~lI%)s<dfm8)3+<l`
zmijuYv%cqf<44eW+LS_T<?5YJYw?igeA3wbnb3d!*^OcHlFkMM2$~!o-VX>Dml75i
z7ZQcN31V~z;*}9QLL2t<5U#!j^;J};AKG#sq*ywm)&D5z@(KWSU(EsJCJ)3L3&dOV
z?@j-pn3x{`*i|+dPy&S=5vxB6tkCv0!fCV^z0u9?8CZR-3vkC<t|U-4HNSs$Zf@$C
zy{ms3{VcTUZ(~SB7RP^dw?O`kj8&k;D>-2y%$Xk+VM^1p{e7a|@qcEOX=CGyN#h&S
zyObR0U4(ydH$W-y|3`O&22GN)3HUJ`4itl*tp(%$5!Gnnba&)*1Oe#<!;Pb!oyM-*
z`)vW?0^*+yx_E>Je1qrj_5(%xP1+0g+VXD^7|%ax9~vKwqC_1%$#SxCSGM@Fmwdu*
z7(mW(@JP4v+VMj}10m3c#um@1c@Z%U{F*z1fGIFjlY3ygTlYf>AS-4ye`u~gz=AV}
zD+qThR|8j&&9_Ya6C>*`&9Aj|>D7&OkSpD+`0q#sltVB!@YJour`&1njkS&q&mY)H
zVYh#5H}e0m-O8;Xom{}jrN3!GD2Ts`wSe@1Hf?Nde6lWq@<@SBjed{4r+UIGK<@4U
zCVR$q;e5LAFY$qncgg&_iJXaEA;&h>2H~L`9G$@5y?(}C?SluW5tu;J+kpgt=!M**
zda8oPgdPA)t#9%~h`rt%x0iLGtKaXRCu2Z-`sUAW963EhKi7;E<q3`Dl{^Q6*gs*E
z40bobx8}#dOwJBYAgyg&KzyG*Ks!GGj=#nr@0?K0I~h)H$In3D0Ap~>Gr+#<N6VMX
zPc;PpZjUYXMvw&tRNe>w{=3blP4O<{^UsO!kIvDLefLlOJplLa2S2W{B4%pGroHFw
zhp;(<esuW30Qh#az1@GrV2q#>%<V@<758;!oCbJGsJi(lllH_IL?4uy7d8{{lZ1Ro
z2Y(NgQRc5JOaDU<4H(S;RHea>B9t26z`b9{0y8x<)O|4$c+|*N^__&WdJz1W1NT`!
z><|=P%3e)<uQMXp5%@<WCPq-A;Ce)JwYC9oU+#*tfqH%N_W`M6@Oop`!T@DuGxlz7
zL!Z@z-aCM54t<k+1$h8hqVxce3H{aXIrkxJWxgQq>VY+j0Hkg}6_fu#z9oOe^b(-?
zkrDt^?AwDqmptMId{O^M7y@p-gI;^TRsBd2fGXDibLSh^5m=MmkF?f(Y6t34_=FS0
zd-e-)A9BR_o^Ws)7-4a64Gru%CI<Uf(B<~pe{A;-h+F4J9X#_3aElu-mGKSf801;}
z%(46ZJp#63fTpt{m=%CK^ZOYREEV+?66}NR2Q+Y@=@m3^O6!{gVR~hLp%2CKB@8SL
z;vF;)wdor)5VY}a%glj{0|38iFTjPru@i?+cN=DVD?I%B2NEpo{FWE1wi5K!uC4(%
zqvNx<{^!@%iRmjLfQ6Ea4l)n*72!=Z>BJsq^gDLn-(E+3WJi1V5?}91&)=NTkFsy<
zhw-k5zqTPLB>UTcxBXK-3HEYlZFq3)9uc_qLvX1NrMhPWZu$Eo$AzQG{k=fva@VW<
z3%IYY^@mw~H^Ji*xUcE<6Etw*<cagMhMd#Y6(n`y=tcz#-~;lB`28UP4#MyM@5i;_
zxj2wm-IaLf=J#OuX1cpXNJ*)CqsnP|7iQMFF5&Dh>RAPA;BuDTAPQtVQ%XzWX|*`!
zSWZ`L2JY^F_P&}9p>IyK@e+lbcKq>(<Hs<}pTTo)X{3mBb}@I~9DLtKkgEJl;*Fy+
zXFR>PS=IYmz|E$&Dc`yGL`taO^mXaA`U4e_V6q&Gq_xBuB!+^@iQi~eUx~l75rwc}
zFVBlmZg+Qj|2Tm+d19=Y*ggNBW4gy>os(A|!Gk8{{Jy<SVIlFnFa;3b7<NA41N!b<
zvRKX&J!P~e3cl1Ki5U=P`;~Ne20L?)0d1-2K04Nse{N-^M<bBH7J@t<NfXphV~9OC
z*X(*>+nFto>9Wm7E*69WW$ST3`B+k(w<_*nC}@S|ieG~U@93+1<$`Rf7WqQ|-62yr
zUSY0T+p!W6)%5G5T1mP&cjop^Hv>BCS>1hD#3rN3Xg^6EYYOo{SGRY8ey^!wo0fTb
zU%z7+pwyYA5!CZ#Ubo)x!<YA9;hnm-QH**kS0A<4P$zAP8#{AkNXk$l8B)A>4T;Vy
zgJ?+c%@mA22+cc&70P~Cd9FNNa7fV2y+Knd-MDr_@=r$P^~CQ4-A!$O9Y3MFhfte@
zC<U2cP*1ky^@b38E!3}-N7<RpFQ1}fcZVTp0Ptmr++qP`;ZiwS-`-5=^xD%dF(GV+
zuS+GCq9RjIzACAqGLYnYmwR)kz6SId-hzF2l@9(PE=Jo|eOS=V2vy;5B-tv0!;3}X
zI;)GC`gla2IeFFLdHfBiilNG;bVPYh4ayx+jq7$ekbUsM8peG0!^g7Egpd-G2OI=Y
zz;J&M?t?(dE(2Uw+ei9cL$=QcQ(1L`dQ*XLHt?{N<D#>U#cW`HOqQ~);`(LG38-Ls
zCflzlNz9mMC!p=s?Lw>I{*SRB!em5sjby35i5|s^Wj2;H`l<}&Vk4e?Brx*}gfPLh
zXZa&fq^*w_ojC1-f!enc?Bfe^?C2CWz^s^~leXB`{wBXm%Ta5{+3O_{K{7EX9#9kp
z@h;|pCUH!&9}?OgO`~x*q9X$(Io~i7vEa0F*~z!#{3BW@E0S|c?5SppTS^H2fQ;}Y
zw{~sYZD+~TL)Ber#$F?3dN2)UpoR78$x^N*FV)VwRVTEr$+Q}MVf-*O%$ChLK-Fm`
zL&o|(l$SRSBEXx!pCyOmT8aR|4xBzM-r<c6@ha{4^Ef7oXz2z4UazYHHRraud_kTF
zOt*qjbbj{NJ1Ks~t>!*bwOKgGG^96~QF0maS5BwohUe{$3CohDJKOp$skZ1y{&1HZ
zXf})Hj3Az*S9%A6w?1dpbKe0g0GFCihvD4}ILp!A_<=T~m}VzqmfV}1!k6XW&U+sQ
z7+0M+=dW&v{FYz&OI6hDabLUoo-dO=;L>o!>*t6q;9UOwU(G-uHi8+W%*8|%_{MN8
zE9GQe7+*+>Zw$b@z|Hvah3-r_+TuVb5IcaY-LDY$0UJwn$n=)C@5?C?05D3v_}~f7
zw*nS&Rx;JYR=%%CLQ!_G<I5g$c<~}tliWkuubicOl>Q?9+AwHJkF>-aJs`WXGU%Wp
z`=CZQZ|+|<Dh3s=cRWGUtRYSKk^R^$Hs&TgSI7OMT=Y&dRGuGT5Ne=zyy89OuW~Ge
z9g*@&GC5XfsN5B)!_eIx04Ngh2@SRAeDyh=K{8Q&q9%_>xSl~Q88}@Nz0HYyzk+uX
z+Jejj7Bks!oIroSyq@5aG$ZjZ8~u1@n5#K}LnT5gLJ!uFOK1IO!6E!cRGvdhjNz1<
zyU?Hc;7uKG|G_>D7&5Vq?xpv%<qDQIG0_0wEO&vcYP!%&)bTWLKy_*`_BCO2Eaj_C
z>&`OzW)(@=*hJXh#mB6MY+b!`A8H;#BFEOTP*1^gr?&b(axlER?F!~n{01&YvLfCw
zgT;HfQ6QuzF;W=gCgfSaZh_b@3AkgqX4O}_u>xj!7AHR9cdsqR9}rvXicBuIKg5A=
z!v1m=ovy6W8<B9-1K@X5&KMJ3UX8ca(lHO$&R3bmmlKQOs>ln<3x%5kgcu({A$Zs<
zBPjP{3ATf&H_85yb_bOO`!y>3q)^%_Z#<{&H{d;wBf}D&pMmCEbg__I+Wz(%=|ecq
zraR#sm)?u<Tjuym&3MVQntrv`$`>4Z{u&HgUI@OQAL$t10Z1((lwST3H3xHhZ}+-#
ze>2_Ib}<p*VLm7}f<ZdI?64EnKSt55>bXhTT)_l`I@4vu?Ld{U8;X;F8`Z**6<(sk
z^{`U{_Tft5z{%Ceci^zR9g>do<5GN;#9&aF9v#gj5FwJW*p53lUz7YGX^bjDi!m0I
zw?!L3oFg3K1L#P7bq=tovHoiIw_NM!oH1uf7?zr8dFgZ8@-wJ=J2ux=`?H1?Hr~c#
zg)ebM_g;ra>Sq~z)O&UMcTI?j^-98S(x3}XFN!-vi)3E8U`G@Oo;rRt<eaKB56Ii*
zhb>;=N|idw0U;+Q$eEMhVTq!Bm}#e7=1w@T69r!@9uRHkm?2W<jdPUDCdGBn@oQ`B
z9GUbE^S*(z(f_K#o#U_{C#Ng&I#dn9OA!nREhxxj)D~S)n|T{2RpyQEL9NKqjCwWh
zqDwj9TUuq8%AEPo)y(5E=L9k*FR+^NOXnbjpf-h-dh`H@_S;?`Lr_Z@;HFpGY~v(-
z5N}(84iGy=M`NhUCl9|9*zYa<@XH^_-FP_r?PNbtcsEN19KPJK=4a~<_X)Ivw~_`T
zT{Bn_PJ|o{R_V8WUIlGInT~>6k$W%gV3R=+FxCse*roVb+Ms}cTY4jTN6_iJ_1XD3
zS^9m>6faBl7U%JsEF;K>kAtjvRz)T^!}N~=0f0G1bc=LRW>l!Y7WBIf``s_|R)!4D
zq9^%qx?-bmrf_`1%&oASG?AB!9l0YnVF*)M4A>_)T=>!?y9U1jPwFWC-h1Da0m5%;
zc~x|NqWZ};j=zntj{e9@kNE4}%dbDFF>4T$T+CkKxa`<8+opGAmgLVHqj~hiVeLT5
z0-(1czJ)m#G&{Bn+%&xj6!dx3x<)7G*1v)!h8{OJuf%BL5yPjw|Fr1!t;|D49wv$~
zNgRmS3m?WS><!$Gv-j+%Xo46yHTOgQ*VQ*S9x!KQjQukC$;^B-J~8fA|3strSV{g;
z10In*?OuImE6{wY2C#J)9jR#c9=BQP6TtnF6*kK(Ia~iu!IeC3G3JDX>|rW~ER}+=
z^x33~hlemUYD*}ai-v}pdh{Kg1hLyTPKG&9Xk!?3AA_aBtO=NBf(yi}L0sIKBT?ln
z&Tezutnexp@{+FH%>O{sIhH-~w_c?gCNlLVxx18&BSl+lfRU|_c~8;p)E<5S9YD9G
zk?CAWQYXtjy#GOYGEBIfCXp=3-ul7pQxIwU!w?p{d(Qr@VTEH=9(()_-3>`K-ghJl
zEH=9AiT#vPEOYvWUyJ5R1bLi)_95~;+04}d)+q#a(I-foW|^Y78SKg`6g;DK{3V0f
zkP8a@gg<Lh@o>A9c66aiZgC)g0YK`>hC<^rUW>#4mn{v5yK;T<%Y4^elQ~>j&%!F#
zc32E3?NNvj2^;5!NX4?|8WtC#Z+ITIG&eq$UO%KxF}fee?Xu-I|NdOtKE+G^Eoc)6
zrYPl;wb^#PT#Ty4z5Wjnc8v^Ivf^~l#CmEI6(4g4gh;W2RJ=jHnb^r@1<>Lx<Cq_2
z!&jD${GetF%2FJ)z@@=at$gBc;lS8x=?>83ZX#qOJi1-#Qi0_1zzhKhr^*uy6i7vt
z=!8|ylb~OL1NG-=eNuV(y&KqenC5m4yci#=dW*$w>RB%0dgf-~;VQ7Uu^UpqIbEob
z7PnK762l_Rmc-bwa75%l0k-!oyYDcXXFOpqU|8iJ(y!V)tJsB+Uh5)bwuG$F@>2&I
z537j|oVy&gr$;;@2t1#K=$0>`hkjpSE~4qFTm-ZS28KI=X`&2X*cmJscZ*AjL+2)}
z>qi-$-?Sf@e$pw`VH$|fGu|x_=>#CV9z+8Rvs!M^BnEI=IO)oE1CqFNkdz;c$~Ykw
zaR%(ea)V|t>wMCAmXKjbzpy`fwHRO(kq%Tgm37^QJq5S*6Lz~OJyz0o#MLVxoHeRH
z=;1yNfHv=36TCv-U9ewdQ{WGD8slenh<|6=%zBo)vsJk0Ov_l&{<@C2$1643oe8$i
zfrA6D<Ob?`C0sY+22fsX>gGQh1ezEpRE;eNs9&v_3Ftb*0bnrH;G@m_dk5SyZ?lh|
z_Z#(c6*>&BIvC2TYep$7nM7h+AFTzkQkezAdK0-BqGC>Dpp0oMKV7JF2fsWdvpZI8
zYUz`yajon)YteS^$`oQ+_x6c(;*+DBv3sL>6Xsf<V4=Ku0n6%m_eDH((W9oy!|s%5
zfF9VbG6u}Cn-qegO`&ia<mb+efhTL=_}PZc*`cg@m}Z5X)fq}`k&8ehQw$IEt?}*%
z>UsA-@+#Z?-`InX$wklTklJDFTPNp?9U}a~)PWRT<%O3@)%rGjF#L;Tzd`Nd+%N*`
zw$<!bmXEr`03`<-eh<iQqM`Y>$oM{gE2_-eIb&GmTpohe2u@%lTo}Gg*?8J9C##Y>
z;f};GZ7c}x9tV_57*MXR12HJjE;sohZl*45HIY_cp8mSSh8_v{H1~e799(u+Bg?7i
zYZr2EKFTs;)96Uw&K1Fh-`l29)<7@SM18njXG%fr0esZt2Q&pQ4<sxwKQmlkIi#uT
zP+`AX#4<xOHwSYGBwRfTN%qQ<*HN?Z@^7tNILLJ*OUdFpPz3^Rjs^bpt*_*;YRQl_
z%FN28_Q{~+R_vq&x^+^6ZDly)F3ZoAgUL}tjkct}(pLi9w#pnL=Ky+IDu#R=0z~*W
z`M=qy0AY<0pw=&^rOI3D^O|;Ism9EVqJ=^x8w>mMhfA)vs#aiH=COPhlWLbkYQ1<<
zQN4D)=AqYFuR~p8JD_TeynhhefuDL+1li@TaM6^u*AMUB(%=VcPuZ+`mAy`n?(J4q
zAZXGO&L5D+6+p%GC>mq77laLjo>u)}IMh*j0owZ|J@N-#Y`C9VuB%Fm&Mo*Mnfi2A
z9(s%uMyAz`GSA3^(Z#&n-bp#voSdKSaH0!(ZuzVI=XrUimcj1;0r?s7clrI?9j$7=
ztMA6IUJMpR!*(VuXSBpu41Tcv4Yf*s1rOY>jFxf_k&tQcakU5nZuyE`%w02Gt_mk0
zfQwsHF#?52A2RS@rQ@m}oj4g?=(zXSh->(6iY;?C2C4|5BCxD7NMxlRdAchrsuAgZ
z5|mS=Ph&h~39&h5<=JR<4Ptc!EP*!ez6x74(ql1EhfbE|bvbA8qN(`X46%!9QX{8l
zcBPf_NM|&OrP#1R3ASekn^dup3Pisa;GzEOo_qhkFo0JnKE~-Rb@TCDEsY1()NVW;
zzIQkJbv8GAKT++fIY$qfU*fVsmqDScN8ZV<#5Q4VGf_XD3mq?>jpHVD<Zm5KSjQ7B
zQAxLVw(p+?Vg^{&yl+LQgIk;UHrZj?AR)1x<9e+JKRsGw5$>0f&nSZ*-hschfTXTc
zD^(OK&V$i=O3s4_CLNc;ZHH{UiQ<Hl!xs70rYn%XPazVwCt9<J16P`btvBA^Nl=e_
zoGYrPdg8J;Z88pc@g^uY>N$;00c-sc?qBDMow(I+0TB|+#FpCx*rgFssv{stUYL1=
zmqA8m9N42drCU32zN&-`PS$86fPT3RE2v?!tNqhdWTX)ph#SDWCdggKorWT>4<Ns2
zVylTNMvwULiSqYM7Hb|W%Y_<V6?1x3if6`2%4)k@32rM<H&lNd5;mhT#5(6BDi)d8
z?+JCorL4*ek($^2xpFGpmeP*M%mZa+vz#e1dFpLhdjk#_!PbI}<%TsBfEBT!><tmc
z8dxz&n004^Gx6w2y2{^KY?y75ZfKX!Zqm24EZf=Tbc5hRO4=zZdh?ZK`DKq^bgDK8
z3vMh`AwX7cZ7kbl*K~}~#)9XI<C}Jx&VJPF<vJv^U29}JMe*#vJ!>pl;P?A&tvu~)
zm4@OqBW1LPW-W=?Mlbz#09DOr#c3dVq_`sc{JTY4C57-+qrNP0TVa?NG+J3+=T95m
zo=92(Ic{cbAzC94h=DYnS<)L<rpJ<v`qU}#`Gn``dC?!!rkCleUYFRzHCm$siw9jy
z?ZbiL%wzFtn}<d)&ynX<W8<uaj+`kpDH{nVQ9FyqDtGCCU{!WhK)C_lr60_iHM%fd
zC)Ij7wc?3)FmV(a<1cd@ya90pYIj_fVbW@E#4mh9J|SWR`+D4!A^u;>;&17_lU?B7
zLYdkt6#HR>3^_p7qO%(`T`0o4jV>iEEM|XR4kK>zplVLC!BN~I$pgGhED6Tj>!S3L
z!C^pwue-~^VggyS02NcajXowBh!8V)XqL(2)VjabwMY7mA4hOvHg*-XNZam7-rv8`
z#o0gMLuZ=AVrt9vFhF^hkgBb;We*(D%oZgKWTd;P{)D0_I<(PqV!F{MwS&8~oIe>P
z4v<_;!sQB7pG9s{OGtFyJrla=SVx$_1^=*>Pv%A83J#t^0a#i^xy;yA3wKCjY{JPR
zNb8?;O(@a2;Sg20J|n-d*_+m9a37b3yyxwdf}c&WB(t%J7gnyCAC)E@OKw$CSDW4g
zHiB`FZ{{cRlf^aT!5#MIIlx9E!*h^lk9|AlNn}2NB|L>`;V81xq?HQArXCdevx7HT
z={HntBlMIG0afV8Z{|a#c$T@%5({%eh~(FmXeNPwj@L2KaueZ^%bQnAndmP?r_1FU
z8J)KfY_)PE?gvwOH08t_I>Fbcs6Yk@aPGE-ui;dE$aiP3EqAN<A;4>#sz5zb1m*vF
z!hwk@wM^#WoIA);NoZjm4sRjrg(6t5sdK7}U{Gs$0XFR{DrU3hV!SO-uk^vR_>N<6
zr;iW5d?YTZ)BfPzbC=oX^KvwNw~4O$O=j@6Z=%rSGGzl@aZxB-=o9;8+$b+esN%)p
zo#vX|*$utw*~;%_oIR>J^T{Opg@O!_TaQB>n}ABFp^BWlM=`p7dU1-_*lq0B#b^|+
z!}O1R12)R*ASgbuL`?9tMJAJFdJ#hfDuCbqh`r&X@rRlWIJ0rAatlB*PlsXTtw5{o
z*_+~Pra`XAt1$5bZM-0nfhB^($w#`V$ff2JQ}F0vTWvXU7)%7jyQ|CqU;Em&qRx_d
zsf{-aqhx#&;u0Jy<r-U<pn%(g@W>j0!G}am0PK1iMBrq=l?kfCc$CX{Cy|IztXz6?
z4}cXlweZjf3nk*D-8~bGX8~#$@c3@Hv86Km5i!XziL=w|=y$!nJ+z)F>6?Goh2roc
zI!L^0*4sx;=nCn^5{-!!tFkoraR)G2=Z|r2GVKHXYpXU2olW0Gax#NO-1hnbJAc|v
z0qYWS`SV-*k!aUI6O`RCj0QpYMV?=tC7T>o{;UW6@^r4D$Nppb7XJ^EKy1IB3vgA#
zI471Lv@~)sHu;@vZM}Oj-Y)%Xxxr@lcH^^JTkdijobHQPYnO*?Ex(rcxEe8k62*i-
z-4Yp^WwHs2p*8Y49l-do0=%kKT4g`hHJ4f*zPo>a@vu|ulX{&owq;7o=ndaYKg6wn
zrZ{@c#NL}b(w);ddG}UPTMSW44Lu{tTOtXTMcaM9Z`2i*J6FL@e8q{m<5aRWuS@M2
z1Bg`<8_G{7T>fjnaQ1;q145lAaG&{1Hm99fFp9>K2wJ+XcytkW0pkqT%GBHLxmR{q
za}IyQ(T;y(sy<y0gL$U}&Rs=Np}e52>|sJ~JW>0K5%?>}WlOa))5JXzy_VG|neanG
ztzKUus-U0|B{WlKRJDHVS&3D5r3$f`Cc;dFUtMcXiHp_AR0*Ysl5<uMaZ_kPlukaT
zXcEX#??c@SHHuaNS$cu6{#Zcd%EcB>e1d<d?`>V5aZ$g=#HSdMdonim1+&F~cm=ck
z-o?Wyigw<Q#M!R-7)*jMgP<!3ccVOn#Ma1@#EOVtBLrWAKXsC85>47GyQHU{VT(x#
znnmn;GP7tvK%yQU%zlh--tT>J)mQv96-3chn8M4EYYcB$Dumn$+oNzv@{$N-N3MTI
z{kE`n00=j$)^K2(nPfvQcn}E2M|$vm4oKFqH?Ms2(eZ;yrPd}4de9tiud5R~P*IhL
zUtRzOzg7nMM9H5YHB>mrz1(7c2l=)cLBKO{6)(RP*zKxZv^dlIa=<?+mPGz3h0N6>
zZ~eN`DBKtzjuuTpb-XPCSs1`n!+C%2g~)Ec$vXO!E08DKR=6GNM_i^XRzvBSkjLCN
z0Ql7+ZN_M7gj!HX>h<$OExF)bc#O1*ZZ^h4`cTAS1F4h{6k@r$G<+cKboAj`Yu1b@
zO0Pjm7ZRPp1#0m7AvNh?_QsqG`ZwdE%9xXbeIW+j7SVh~FKR1=zeHUN1TBAQ;)0*Y
zlS#$iql)K37aTl6eIR+)N}!SYGQGyDeNSq@E+VKqdSaJsB!Kwf|3&XO`1L3GM}wCx
zT>EeRyj%L(@`+7!?ixoK33B98={^?}C!?u{6pk(}ZM=fT6eudQSA^+S#1*m)aEpd}
zPja7Bss+E|>LE?`>}z~q9W#G;8lM^A!SSm)Bsg=@DLCYgl81tzqqhJytzuUTW)c-<
zSBr<r7F*t*I+au=>9rvnz_<~)oyC9t;Ja~QNtMwcL7lhiKs4~lGDR!KvF{!kNRH;n
z{5I5!Yqnx?)p73ul3po&n2q+)Xw9bXz6n|wi^elzg@4_*1t~YVuu^|_bET!nm;8Ai
z`&|%rd-fNmQ^O34-aO=XMmT;Ydv(>v__rS}?l*_5Hea#1u+|p$bFa$2xc&M-!09-j
zqP?<a_EX9;@H#ympWrM*gpGCS${(uN7fIV`y-NYz1xj_uUU4~*<+z!)D0GT*y*#Q&
z>LZUXlHx%!uV(A#Q;UBuo?i1q6>7-YEz=;4(Z!3m@nrtSE;ODPGM$9W*t=WK%n||z
z*E~1qTs-o2_|#vI`Q2XCkQ+5Vu~~tRYZ1Ew_fwU|?rj8%O2pG?d++H&7fLk>lF<g&
zIhXf6L%pr}_m-FFZ3gcNf05G*Gi>NCLq3vJPbw)S#>EDly2pP@=dxxxjM{Q<Q`fWW
zeS5MCnHA|gh$i(NAbX?vpy3zz!l3%?OpO{s6^)v^WjOE4!P_#t81<C`#|kr*eTtR^
zU!4PX)M%J$FDvX98ii3>U#Ae=vrsAs#w8yndGq%hHvPBw)$$)YTOwB7-)g`*_j_a%
znYjjv7&2JzF(7|W4?rN|SqTyE<IH8p=NLEdG4R?aKTDxlL5tud^*#TvNt3FmJjIUH
z*Dt6~4(()0xtxTexuw^}u`;88wNN1?vv|XdzslFAwv1h?uUNG9g%*YBx(9hwD5x{J
zl{;*MTE#1sPodN<P$xX{s8ZvGu6#Pg!6Th)n*_W2UVne-Q#xvNh?^NwQ(I<pmD^~7
zoKN0|rP~hrr`nkGa$&gL&1GRgyu&%SNkOo`EhCI)Fe`<_MiHFTguwm=`ps;A_eqx1
z*Y018G59l#(@*lpSphnZ{n2G7I(xXk@{^!YPwTt~M-yOs!`4rC)LBTx8U^CXf2iwO
zK6~p(#pr+STym4h=OkDv4ACUpUxY$$s$U>_r1L#rO$l$_J6^;NM{IUfZA|N;?pDW!
zZKe!)mFuRG!n<n430};`%WI5%(}1j@ITx{`fR3xBkx*E3Q0WWoLis9L_o;F2#GRq)
zn|ZEIAqL8>n6iNMUD@d_nu5uICPiw#9S*^B6bpamsYM-Iy5u=bOtSw3=Xf6DfntbB
zwSnrLJWNpjtXNUP=rW>HGhKftiJa5QR{=&0hp{g@N_Pce9bW+ZxL&WwiItKW_EkE@
zNV3QYGhT^B{MJS)z2ljAvVHLZk>Z%Bi>s4L%+X(%ueAs+E_FWy*6X!0r=vF2KaFzu
zZw-GGf4|?5oEh~Z7S=c?!}~VPaEdwI08jEPOp5aZOK@W$o<~gR^DJJwTjLHfpW$#$
z=VT#P7#+oG$-VQ}`UKe&*P8FB%-#Y7zSxoThidBf_~!y?j|HW$Kw&DCcNgZ?n^<)o
zD<qsAe#SOUNbi-QP54qlS%FCq`ZpcYOYwhJYVitihv<W}()Aha5#AA{Eoce0lj7TX
zAY{Hw6S(B!GBT4UPs(Ea&(=r1kV#g%Ktb(Ln1L|tc+HQ5)-yRJk;xBiv@U5U%ER@$
zTk7JBDIyWHnX=FR?|6px4}nLykdQi>LA6ce6AQWtytS|&%a2n0!LJvnw*<y!j;Vje
z)RDc-Zw%~2K%VC7l6=KYJVrWDZ1Go3llsJ<Z3s&9^&jf_c>FcQ@AlZNcQ>ns`HW|{
zTu_QH)}q>=4EaR0f|Buv_(*15k$dy%zE9$`{1Elq-Ocqi)xGahnW`KZEF+d$Di?HL
z(*oGXuel8Z&BlFZhxklu28${~Sw(+wRJSzrv<cGGurS_iTU@rz(QwD=<dWlWW($Kj
z=-e#kWwXAM-1z}8BWNa{BbXpVYZeF5JxSh&tKg=SB_o3<5eiLAWxLw~Wmp>cmk<%J
z4|({ZXdyjv5eSS3{B&;dU&3d&C@zd3-!`D>IjfSvRtCU}HhnH;^A8%OdqaN)!I6DP
zr5#KdS4wmRBmS*DSR-lan!*k~yDLzEoYi%bch7^J3zuZaZ>xlxvRLP5x2&r11aEmP
z5&W%6{M9SrNb#e5sMnb0lX9gVYO**J6~==L)smA4j(~@!oAVokci(s+rO+JcxPQGb
z^7j7%a?9@<k7x*MY+`g|*TsKv+Xm9W2JS;zoG6vPY9xI@WZs}9NEvd6LuEZCBaeh*
zWPVr4`4V1JB!+6k=*?=G_2W}URX~lPGTW1ID_~6}aEMYW)*TsnmFwg6>wA-g=wwuK
znXa7Ix0>s$RdI;tFRFJ&yX2DHL1>C}G7qbqwb*Ee>MbbtL?2TQWLbZMPU2XX+<)N5
zViHma3+$HqMU60u#$rItX1!X<e=LqXRVG;!VJd1mNd)ZAkZEEFIBK;Lc};FOP~Zf?
z6()<SFE+>f8NsSTGnC7X*K#Bi-=Oc$WcdFmXauQ*k4Qw87Yl{Db0-wl+zPB_*9038
zj!3Lx6;9iKW0W=CQ*nQ5n08k~;mLMWW2A0<94b?h5z}u%O$O}u=hN)%KC4(wT$b|h
z&z2-7vHTcyi8(b?ozv5$8w0wvB)HD-5#4Xp8|@9csY0#S=C&NG_OhozanosqTI-D-
z6fb!LW;~;&@CBp-pICep(Cy<Tn|l_5eL5~<9^!;{BG>3s^16QpqP20Dj8Sxi(ClG7
zJn-k?ayhtpy|#VZR|G77NE55o+UCU5OMe!fFfmuO==aAwm)`!I6tijMexvqFoA`-w
zF&CuAX<C`L?S57VquoghPixthHXPeNq!EWP{KGw+O)ROMkeb|<|I^f4=pnh(A2p;g
z>fe~+ZbdR#utI;>1WSvEzQX4Xs)+Gf=+t;9+H}Xqy+=ZZWcPz;7;Bfvgv2lkvfikV
z)5!AqBrG$AH<rahudz!^J;<vH<0_*-`Ocv$*2LEQy<>9rw{xr_&+m0XNbA8geb2{{
z;mD^l2s)o}^)W0@U?v1Mc?J~1G3n3OCdI!fpO3(Cw<v#L?(M&|?uAlI#^4&!mi5}`
zWqHFouy_!1;((f>tL_DaUkwQ_u@X+z8u_4cx8@;dZ`|S=!0hnTod)l-sQ=#jkbrQe
zfpDE_msE4o?IkUfLy$l79qm*|t=<n&k?(sqtm>D^%`>DhffZ0J<)p_m4o@Atmxoq>
zR}06ArJH|;k+YXt$!%58Oxx!Zz7FW`6M_f1erq|0kqf;rn;yu*Hh2W;*9_wt@AAsc
zwzO9OiOM(vM-L92)7#@sdY`x}Gf128)Sxsf1~vMOm<O0>FTPEyfz0K58^cR=Nn~^H
z+=v&nE3y{FW?BYZteKS?xk&oOg~VWthDyfEi|BvWX*ZC{FupHt<kDgZiv4_`;*leQ
zO!Ob=4$4Q!;cK>`BA$)MYdyYYK5(1Q%J!#;Y&MM7GRs%xAj{v3@=faLe=?jXnN%`C
znY}w|-d0;CAc@+#FkXjwfj|O>cRj|R&J9(q=GeO^Xh=P|l=p}ZC~ZVHcJ@cCVjMZ<
zS?+&7kDGnd?&ZyIoLDNesn;vPt#<;=>3f3UY3oc!W$kJKnm4BH<8;Ln?U+Cy`fQb9
z=8?rf`D(@5LRIXj>Qlqh9$se%w;>pX91p_hoEXBj){G(jT>mPleq5q>U@&_P6)jVJ
zA4x{kA@)|uYXM)A4+ZflDLuH9MV?P(%wK=ny$++3i;16>P9!@fqbB=|G#s)nUH$dU
zXu4Is*=2Amd{m6pa7(Dc%5XN4qvPyLLf5p_er4X8`hC9}k4vMA#%(m@40H0TW`-_}
zI8<zm7;J<avgQ59sfQYwk8k+S?f}<K;B%z(oRSL8|K}UX<PW|*BGtRt4?1s6pkRN$
z$G)9@Jd%zVK|wHm?}vosf;!0<7NfV)=w7LG9<MTu*(-Z*M%FmiTb#1TGLjOEQL!ac
zlk)O~%!5_@2+w_qV6Z7oBb{8x*FIMCqicJhIYEU6uX++oP!@s6o)uz>FJ_0$j6~%d
z5hjgJ1;>EklXQ{3SYT!*KfSDRQ?q{oBL5qtq{5m}dLct+F&1^U1u;&_0g<UU``*~X
zYgt>dbJ}gEuPLnfLksF&M@lqbEN_NZ&VJ^eAvOu+D`Ow*w9=z{R^vS2_AtIk%G=g7
zRwxs53(pZJ2xa5Ct;<DCH>ylV4*N!#PkHLiFdtIGu;5LxxEq&`U32M$*!6#vIwbby
z*5US!F!*+*8-4B62<Lny-|-IYAco2cFG!e-XS%$G4O29ec2{1N)Kj1iN*;tq8$cny
z$9dtutl;P1&`i>r>sCdLPxL`)PKT;Rx`kDrf(b>A`?N$i^C(>}HH=ER4W}kD@4hY4
z=HZTOM%X8cBHY_43LVw|<+y)EfX;Ndt0WO<XP`>&&;1@EB*9c}py|Yzn?{Yw4=b&g
zzoM-m^K#C+KJ+M^xnYX~ozFxewMVS3lXcJ?7LSm34=W1x&OCHw2fix_HNoa}r=8gT
zVEOox|80y1RnUbMM+ZOiG9KiyhY=6=M_22i4nI0!Hps|%&O4sb3W$HJCy{Mjo7kD|
z?@YR1cBUhWibNIkyLjs9$}oVL->Vo^gyL}!DHi;Gq5Ixyg_~Wi=H#*1`0DKGPJ}d?
z^$w*%Sj>W79wOlYpBZy?>({r<G3}!j=O}LZd<BEa?PxLbhrb@%Zvv3Xy{g!gf{Hl5
zCSC=Rr^#a>4^tz;xSW5Rvt1CCD#{poHaW=N2A#pmbhgSLtTOHh5W?^(t6hB;w*(!n
zS>QGaFruI1jIN5|Ypf)<LUL=%Spjd+3$gIfW7Co5!^4g|*p3?QMuorHwwS5t$4|~6
zirCwra&4hw504*Egv+4}MDDH6<>Oef3(?6AeL{aePMLN!f1rOv2|J>{ZOl>+ZW+e9
z44m3?F(|9{D0gWH*SL4@4sK1sly(S(I{JKXdV4MGe3q)7<jlsu*Mlz}*5JRzF7pB2
zY^G(zbO|sjgB!YoviMx-1X*~49F{A3q9YZ#X_XD9W$He;djEuo$t;aRb^IdLSJ}A(
z{Q2tmEikJJj)Z^W?R;3HVbrS2mXB&3I!Uqr(W_B*vru=EM2PlgTsMhQdc!)JR_3a9
zh7Lj@f>IP5!$c*MJW?_HKJj{Id?W6B;CHm-A8ni$O(W4OtcQ#w3<WZct+S0H<3)H}
zibB+K#lvdK@^m=bW`qzmho4CmW+F{OZaMV}V#zIb13-ViE7oU)grr}W_@Nramw4}~
z-_+H&?43V*a22h4WdxvP#*Gqovk~n!!8)cn#SFmDd*(V3xk_|T;ccyMugrxF+6;FL
z(d1K4YmofBWF@cwhIbENF1FQ7ut0~a*nW!4$yyE@QlFQv@MmOzb{t&a>Kdn2X+RuL
zHPJ(;)4zWZp@ijlXlEP}>N#wm{)r=}LFie|C9U465f4jTniMaM9JeoU=&l<Nr!;if
z1V@Hryj|H5>G=#7oLA*i#BB=i^h_Yv^CLws+*X&Qj4p_gh?zV42Sa*SSWvh=umV?S
zp+0K(SOQ0rW>JFCQs*h6thg}H-nUj{Bh<dQUo?L|=_7O?^VIvG>Mv4V8}9PJqfD8g
z8d3tz>@@e$l2Mvyk^8SKt7NATDE#A%pC#DHsd=szd7*q7-tL4V4jNy%kA2-WJ4PbH
zh;WC)jNwsmH~D6vUKqIiluLW+7q9mGov~aNS1v0E7m5e%qgsVAUv#*TReqE3fjp)A
zyBB{>{xwQmhL4%fIL0m^@+wkCd|3u6!Gfcs(R%G$E?xx}wpttzd4p~HuPXb=uaI_r
z#+u6-mQ$_P)w{`LY}&)8`CJ_{(Q`Qw5zn&|zt-6B;v5*MbvedH;{!=veqwB5ycg6Z
z^$%(-cN>lpK??fhL5Rq{xH?SCE`BI095jExgS3QYq7`)YfVLbxf-|=-QaZx>WZ*=(
z0xV5d$>*JTLOBJToKbaIRoZ8~LqGEfO=mS$T)uZm2$5gu7s-eYsv`@H+UoMhPE(q~
zfr%Bsw1a=bDkNldQSxw%GjX?*rb<~k!xNW#l~}HA%4>Ap0Nm|^-fHW;8B;)l`$m7`
zq3#V~fC*$`C+oKfUU+p|(gF4bPFi*-jcmQsfVkq=&W|xi)Hl}r!nHelfPphzDH*I2
zu4ePGKG5etkh)2M;6n8BjdBpD3Bz#l_kgo+aS~Mh)5pkD2g&frnzuf~cCU&n!i3wr
z^wBd;vH}ogm|r*a-aKM1#2yGX>TiE=F+12vKlB%d4ERxvsXHy9VW#6S51|PJ3nNyW
z_K?nhP{h=OU<xR$x-I8wW$QSN@p=@I=J?=UBAjNKT!5Tgn5!qpC!OChB=B<FpFbsT
zw&vyzjC!#!HbbLKu&mzQ?sLe*Pk#)*pW2H5DoYJD&Ir_H^ywvrs$16x6|;XnYzs%-
z8Km6q=^nVPK%?ILM6PkQb1malZ9kdM;o-+Tvy~|Fn5hDx)hUhCAX4f52xuX$K3b4t
z>JjTm-{Vxt>Jus<r0~faPAy~OuU;VFr2+uUP#g^rNSOroz2M6TP7;G&@mNLf3<GBu
z(-q6_dnN$+fkVVk9}7O<&fkAVItp5N=@sL=!@f8-F&@*6$}it23$HOJC+`R&>`k10
z624CFOh{-*tdcFWe!GgYU*K}|BRDbtM&5P<TLNgg(wt1QRy|TUL^IWWTBSsiui0^B
zE)T^%Ej2NlM<VuxIeG?~<`FR)9!?`DB2mGKk;^fwr`q2s;Et%@OhSKo_e(FKRYr%r
zeCv0J9b#V3*OU6FF3QOC2JZ{9F5(~KaIMif+;3uC=;oprhb<ALB|^ks3{#w?6Du+%
zK`>?SCyZ@~k=~(wBf*Oez^~KrTWdjXZb<(ihA){@+$Lo(vwdKL(bAZ|^=4!$y-u~M
zkTiJF^eBk>>7kGow2Obvx7~|y*t893KUv&CO+QHfLeh8iBr|2HI5~NCr}M@9XhxpK
zvT}03c`H4o{!u&Pf!(ZwvUg$+iX-SteXt_}G`(QRU0w-%uK_+j;Z^jDADsHAUgCs0
z+FYvkOuPeO{3GlvjqMU=@%FlPEpHe(_M$0HTN{$gFRdyT-U@#@7b`NeCW3DfAcV`L
z#*D8k_hnAjJqCn2G1vO(Cs{i36HBIhtAbTh9y+lEN<8BWocR*%(bP7kL7(}Q-<qTN
zZsP^?tx1WfoD&S)0IzTrPiZdutGsODZck<;?iZ;ryk<<$V%9}Vzh+T)7A_8iy06co
zUU7qddYzG`XBvOD+Gaqje)h2+J)DNQ?edq=TEvx3TXgc&V`pfwvraS<v{>w^a<gfh
z*PB<iqMmLiUBlJ3G&s|N)~q=7{SN<hwR=5GCpJEJQ@<|!(iWY$Q0KSATWV^Q;&2Ys
zf87!EW%{WcO(Ux9USs;bo7s~k!8(E>gL{>adxeoby61nBC#s3F0o0Q91?GntmhXtR
zN2BKPYxZpxg1rq4gg&3t$IFGbnvbXC@pcDgQ<>Y5sb|;+NC`DAG?mBG@;39AzIGgk
z#1^6EWTF2u^P*6+g!_3!piPzl71r+aEuv5P+w&~cN}4_YO}5NN+x^#{Ac$psoqQ=H
zY4uNq-6((f39sww`{Bt~=j4r#%u(9Y3AIA{ew9K8);;wwvQ)kb7KCqtBH`azc}C`b
zjMv|xnGh)zG6KyZYaY`IHa;rpza>iI!+*%*>`Qu`po5LO#^MZ#{5W=EXw~wRe#Buo
z>MZ~}XlG1{PA)iD^8A(glLZmZZfx+ekf@B<<{N*@8RCeUH8i3bwT|z#pYh@v*1qny
zq><&%nuqa1KeXOjhJ32W;b5B+glklLs;ZZ##-M%6bS>WV!)SR6@p1V_4(AW6DF1o{
zLcgExstNICkYm}7I$wv-%Ol!_*9c9Zws;vBbjl9ngSb@Ck*5vI8N4JBHXuE+tmv>m
zj(&fCg`n`V?CQ?@#Wc}0#i`9QnhHRU4Eolzb6F%%CCkw#bLb^O&<|-}&O%F)yh#~F
zoGw6SwSYXc8miH|*IB2oL)edL=*56s){F}HkvY&jWThTtR7}_mOW`y!l^d;n)fMhD
zYK#B*7RHmjFA}pf5u>K0kr>Kx+AM95-*SJpd>*dFslz=ByQpA@vas@P%z|TeoGw66
zGw^#K9HKwdPaq7jXvju=%c$vz;EpE&c1*RU@L-g*Rl#kVBHmfKt)^|;HZ?L(Dcmo_
zKb@J^+ivQi*@5z8e{U;m^(jTiocA-&3a!PLo*x9_(W4rMZj=yy(5~uCnxYSMf&_m=
z4>Ki4Z9Nt5$SG^c0C89aH=C>#XsxY)Pm9+vE(z34Z8*5EvTf*bt=J>&!CyoKGSVcF
zt)}gjPtihfMT`3tD4h5Usx3H0v|p!5;+6;b14gL?N1NN*unYuWiyZK)&{%xFe9@Rd
zIPQLt$Ri5niW>_RR7WjvYxXV7)i8g@C$RqRFNPn@SYMHv)HvQsb_D&B;2T$oK|5NT
z%2V!9;esz&0nrGx>xpT?hNHcwH4nL5AiigKoxGeoPA@%xi1<c`6ea`RMVqkBYUxwX
zucin>oQ)cH3!L*USxz|;+ura<1I3ilgOD^zM(a})Q(VH{t2bCEZ5rs%O$L9fGZ$DH
z0P&zq|Me7yl`|Y?N!>O*`W75jB^703mQKx=2^A3SUIP}$y^w^Nj_)Lvxp6Eq^Xccl
z%uY<r18J1pJLau&U%^~hqK~bev=*(3zgm05sOVT8N)f2J2d<HHGf@2y()Gu-Il5(s
z=1TYrt-hhD_bJPM|H{n`f~J3$Y&kc|@f%Usm#l*{6B>Tc=d<MStP5F#X6og`l%(XX
zM6mr{&h6QWyNDr8)M%QuRE^aXrG&k`*(fkN3jF8aYL=ygw3Wj_n#OITY@uq-^Mi+-
z4O(QH2TQ9@r!R595Ly4o=Zlf6FYgrWWe)w=duv%gI*<bAWW{4*`UZbyqN}vatU!*m
znL8a4R9NYJpT1e;NISoEJSLrBcliX{<`<8Hn#>2>Kt7t<dru<a{~WU2CzFM$Bl|q$
z%w5zYF}taSh!flOInXFqT)8cH=+;qn=X<gVqpkFa<Q!;Wk^8wPcC(MsUB*lda~^jV
zp!}21qnJoB?SZ7q$5DT(`0=I{>yG%aXr|yjhxC54r^P#J2#YL&n{O|}#Q66;gX;*i
zj1C{k_t_Urq~<Q91Vy@WYT;Pw-0@mP)ml!*prnvn8dSG}MfyGK;vPS@wkuMGfc(fI
zSrXHMpOX@{3?Hu#?MVEVinc@ou+Zyhf=9$d>32#du(zCrT=;*v`661G!WxQq=(s}6
z`=_{vL3L}qm=(gY2@CETGSV%z#Cy!Atq{Jndy<euJBjU_5Kp{zey4;ToexW|Qrj`E
zHg8w^2}Og2S4neXI}AdV2qEAOgpAyC&ZGy}+CNfzw!({NWbejBe7Xx$Wr%54X8$Zm
zdgX|n)4-&+xFCN?yAK`GVcDM)Ibk=v;CitWnnrKxe%y3V=kOk-@%;<&5|YpT(=<iO
z{w#-hef5s(rQF?MPBIf!a#w&y^PyyY%O?Lr5*Z3l=sA7yG)0#Hj95%ge<$T6CtTp+
zb5224?1j9`wj}j{EYV5i!K|YMf$Rp2$7o)HNb*&%?zex9F`j`XqDlS{vE+_VG8{}3
zwE~T*F_w$zsS01pw3zEn-YkfC7X@U2WIIMEl}!1s!;Jg4sXmPgh=U-K5#5q?;UCwl
zv^d1xV_vtr)xd0hU5C!zn>$Kms^7TIE=PNcWQXnv7HCxHaQR^#y6NFt$!q$9rWtv=
zAAdc5V;6tU)(MVKrb0|vVzHc~e|u|2EFHlv>>ct_(qn(D0Rts+T!bE%cO0Hb{ijW4
z8K<}`mgzx_&rvJ-&1V4-Nv!-YUcQy@x@Qyd9x%vZ$!WixKMm$rKlPLJ&z}qR`H4*D
zm<n;yjGxlf9e$uheZwY3kwR03Fjah05l);I9v6Qh^_HR+pEEZgQP=6+5$+C7<fw;u
z#%}M_^tbbsT;qAV4>6~2KV2G7@Dh#f)V|0WIl-C=PO60%tW+|{igLmWoezJx^o{dI
zvA3)~Z}Y$v)?Y9oV`|iPRE}Z`uoM_5rcT-6hoIq~Z|6mG6wHh*C?z3MRnMDFiS(yq
z2^=rNYI=)&x2sBJ*5fY((eL*%%*()6I{Y|U2)(p)N9Xb}QW@v{+~uYG{{i%a4Sbi8
z@C6eCGdMAqA(sOt5HT<?GYT(EWo~D5XdpB(F_$q90x5s(9NBK$#`fJ`!N(RC<?I_!
z6mXol*<;5}>m<m7Vl#<uWXX}_HtE;jbI#0A6e-G<rMCAWfIT`K4$r;~B~mEI3tkB2
zOd*6sz!p+E06Z_0@;KuPI<0~&w4+n9a9ksx3NP_;uZy5?jfa67u?LU^jMm~DTq8X#
z^AQa|p%8zD2nIM|C1MMr5KiIQ04Kbr#i|g&;<Z5+k~>*Q1pu7ga~ck$6nM@6WN5vI
z1#x{q2<9~B00GYci9#CWTywZKAhVh)kW&kUbOBTXLZ;B5i9LW&X2WsL6^4Y;+!sbm
z!V(JO3_^kz7Fh&H6c*6~BoRUmgaSw^gmhs&M{0k<6iy4IAza}>XE+x?p8>A`vAjb$
z@G>79o|UEug5&@L1yYihp$MdTtzZck7KtbrxFwnJ6b}~3D2FB{=@keG>PJGjN;r*_
zG+YMC#swNK12-TLt*6mm8g-+Dz*%Hhf!>fe^bznB@(i!`Ea?&$Bld+M>l3e_??@8-
z2mOCR8#w7avTVtfaFqw)yg)q%rwWG_Gy+%+$di#M3Scy-XJ=rUF(6GqS&T)4;-6O>
z7{ikR{Mmtb3M&vh`I-fy$dy$ft4C~BTVM?x&Ke-#J&0f}tPAL(7MTdBDC;fIa)^aS
zj+S&Bt;5kFoWS_t26%81sd5+4r_r-v8bE)I)&*4nXt~(~!GKHWV(1|TFHqA47x+LR
zsK;|o>VgFxEK8b0Fc1iXm!NEi2J{MC$Dx5eMx{ds@Y;&KpMTzCr{Ausg6)sTlldMy
zxqd&V<EO*%=RJ0BGQFs##aqk={M{aVS)I>|w-BSH1GQQmN&);B(4sZE49>xt{o;S;
zp9^+UuwN&qlY-qZevt0R;+J3c;O}nq!02TFX9DGvAdca#6rcgHUKxy7Nm7~ZNY)}I
zk|^Oia-m7?e(@Fz=K<l%f}Op7Q$RX%kP^q&qtUy(=x{Qg6P`nZ5kPAXAzslj<AIMc
z5)UNBM1&#nIsyR|JDN_;Pby%!U`K!V4-0l$eVrHYmL)$Le604^0Z^>Q^BLwrx*mm{
zO|GZs)hy;qntN7V3<vinU!zJa#$}Ko_0eDoS4Wqmg{03J5T@jh{7~{wfX;x)fX#r*
zfX_fkK;Rh=8OWGJ#vCH%cXv0g^se-nex)ffzew;e%1ug@hGgwp*!b-ns-}MlUW74R
z)0Dil?r$Y&LMSoi)g&Q)oL)^+ZyBmG$P(+6@uB39oHI=mG^kpyq$zep(&-YUttom@
z2EIC6!;TbdMG5W4f~57JXun!Wz9X92msmw=n#Pt;TUOGvdPhl6*-}A;r!1&t$$MhN
zsU6Xis`SuI5IrSID_7IgVMl-TgesL!^rV2|vYMXfyDBPBNkpP2ApZSodP?qwp0OMQ
zp6Ed<QyRJ2U(AmD#Xw(xEi}<v<DW)!s%Eh3tLCj1tt_o|(Y#%iU0+%u98C#Ay@eW9
zhJr>oGE$cg_6D+)X>86w2$g<mKF&1frIjT#y(*NTM(664OPCe7PXT}X0=!m(yCNUZ
zr&v(DE}?scGKO6ePmlvVumhs8!7r^?I!CJ`jOT9qFPk`skBGIYhdAR5ofW_{SdHev
z9UU}}IBzAb@fOc|<OTW^)PTS>amE6@09&tkgqtv1L(T-$RKyif6V3)4X-4p<jL1S<
zM2z4rG%AjumOz@=iAaAntx7O4p45(tpxLGpj9g$zCNaya;|fiqB8H&>TC9ueKsBLj
zfs?@8_wnx<QOCYvB^smMd?PR#7H|D~?iW6Sp(PiNkH-PBzQ^sjg4k=u-6G=t&B%>o
zf8+v15Kz@|i&9w6F^r6)xWx>G>y*W?G7UK`-KDVUe43+c6Lx>K2(pBq;u&|-vL=tg
z9wW9Ev<)>>(2ZDvcM-9$JHgnG5gQHCj@SgJ2uI2k!>E#NMk+f?qYIegG{7p2amG20
z>IV8?1dT<7IuAN$;T%ZFEnZLSl*4YsW8#GsvCC6M&@$tR*G0^6G?q$~$k^jL8U=@w
za%svE^2l;il&*hRNnAjz0gF$Ni}kZ{Hm;^QU_hs1U$eDX8PDVGH;ub_FdWs1`b-oc
z!ZcDP2Q1(J|H*&UI@$#OqZQ-Wu=Co`h<=uQCeB31BzKK7fx=O6^lO^#I$m<12Had3
zT_-tEB+@(!1nsgLe~<P5^H`6R(f2I%-0Q~gd105aZmEAvdMdUa3#yL=l~ZG_=&XpH
z#Ol#2fq`J5I4kNcMBH6aDUK^Vb|(0hPTXfmD$|hyHhpxbA4@h^SJZH9>~Yi_i+da+
z#^zaNV(SpGt>g4IW5U@OBdz9|IO8<+hMdxmNZT0*bnMPjFXj}^(mLg1Yl1pJIdGRH
z@r#fJrnr9xqw5m|NjZ}&lqkfNG=|_Q(JW@@2Fj9Nn_6kg6lc(8WViY#>ARk5UW2pI
za?wJ`a~gUfd{WdFOWvdM)z%_UntE1DoY?GBn@69xy%K!U7Jm=(e={v?wFkpJ!uK86
z_Z`^E9T;K3KnFKNeUMI+EAyy?q$W;bp0bjv{_20xYw8J*Dg4p_@)FIud>&lP<A(rT
zaX#b52GMwtD8|(hUaZn|tQ#vD7;0!ehqoCM#s+630aevF;&GG}8$qAtq<fT3dF-b+
zRTJ<$TpiHJg1&o!Icz+wGhiIStwS}@0uQzbRE$i5@ph*mb2yJJnYWtO1=69F35=ul
z3tN97ou)RL5*cl&+C@9jXRJ~U`{L}9)q|qDvJ0!wb@keKUK`{?!xcVRX>l%UD8gw(
zFNt0uFvBfwt>bO#`_=4xI=q@srt!A*^T8#Yd3?Bk|Ka`r96Y-xILwa*A7_P*3+~Z3
zvp<1Sev%ZO^pgj?2fsf%$M0utfRzV>tA~Hp@Z%>q^mdOS6+HKoz>|;WgVFGOfBbP&
z6@dO^US0kMi2NQqOBX@70FF<CDc=45ft|7ed(SRd#j3C8qroNn$Ud<l8?j3^W)pVB
zrfkOM?3(?-{`@hrc{l{*LJPW6zx<6tzu0dM9=$p~M6u6=TrIazC^!CcLWLd49eRJ|
z-e>pN0lUv0utWAMd&nNKr|cPf&R(!1cFbO~6VS{n_8a@1oq>i1vw1Zg&OU>x&e{27
zG#SHqc{zxRL;S3|yco<ru@CIS5dQwC*oVpWl(hNj+tsIP3`+ek`<xUz9*!%}?gYjw
zc7<QQkE##z2u%sy70{bpurKV(bv1vR4}sv9>&d*jct4_*`5-Q)qX?q8X4M}+Z#Mi2
zhMRwyRu!B7If*7@U)eYI7yGN4PFmLVn^^PU)#HcH(TSfu>hoe%d$IO6SW~UD=1)Rr
zdpg-LrxHzbMs+QVB>5&H{d%<j{PZk})Z?H^WRaxZkx15TCX(Dlq@&|UPfvdzl1O2-
zL^5QF@GG?47)fs?k={h2!+WpqpP-Rm_PL$rSt1^`k*H20HuTEV%^{E3lQntdHG8w1
zOWsch=bx)NMRbB=6yK0!s&V{?85>d#{tXwIXY`LJpT&GL4P6eS7>k578zJMjPfK#6
zBJ<+$o8!~R=pL@e-(B(!{BeKaF1*9_d&i;(pr$DsXQ5j%Zj^doKYVcX0t@NOo|sm3
zOe?z^8TAGc(DeW8{n7Wg^ZdV|uHL?!cK!JF9;`O1LNA{jz5M+Etb6kG#`aK1wN=gz
zw{YTpFzrJ!D4G+S#la=0a5flU+@>jtscE=uuFs9`@=Mfk$_folwv>OkQQdp+;L)4I
z*QCUr7_qsMi@5dOUWdNFHyMzEP$?fk5yK>VQ|@mqX*a5g$G^UQ@ahdodwSaEG!o0A
z!n=76M6?Zgg;<go4{Ld)lzsB9DT@c-Gw3lG{1o={hKFP|^!UU2m~H#Y*N)~kDi?=`
zub-S@7khHj8*Ir@Lco7+BJ}$S9^NLG_V2`2iQbZKqe8KNe0q5B3Z;A9>lIKc=wS=k
zi5Je9g?JDXcWeJN@AZrK*N|)>!w;wDqw0Ke^=;acPj8ee_g_8OKlu&hJMG_tm^xMJ
zT{Y~!S3WF)k5ci&vUipuzv=i`#B%-G)bn$GZ27$2C^tTR^I(7f=}XdDxJhZd+qm&H
z$?+T%fhuS_!$wK)-r0*sN5?2uZwk~g0~)ne2E6OOVBM}@xu~8GhZrK)ml2*1M;Fzi
z)>1Nk4-HeygYO4Z>Yu8*lS+-ttsAV1$!G*f>K(?H>%pk8vuJc&AE(s-xaf9XqiQx=
zv|r=v%l9D6@Z*2@#!d`%oPGRibUj<O<Jf+GaXr2Oe$FS;YHg#YH>w?HhfkiIyoe6h
zbGrabhr(Z0<2UYRdxtaYf{64`fo;$ZSDj$msB#=XJ3M}PLbCPsPbrol_t@aK7H#bg
zV-ZQKcNckY(T$Z=ed&tcqjulPEnW3X%Q+h^SvM!EoNj;FCZ?y_HGYtdlc0@zgIPtt
zdv4!6Ub0|84;IqXJBP#RY>qlC6r|{<gLEJSnDh7H#r)GOJ{w7kPbaU&5Jwll)8-7d
zZ|inA3T=*X*@7df8ypF<1CH9aCfgiI(dNkb21j_XVCW7eYTrlf&{rGKzk~d(n|>Yg
z=GNr#+1h`N$+zy%b;x%-6jMZ>Kj<C!!}2|$4nH0L)S;=4COh11PJQ`qO`EzBH$;bQ
zlD9k1M*IFkha+`^eU>;<JK(6bS?@5^@mKAZ7!pl}cHuDH{d9+?juYdqr;jJ!=1JWl
zs#-hM4o6`vM_M$aI_yA6?agJIA>H-trAlO)VJ?5~K)<#5>(Ey>MAnjtIvTkHN3D%j
zhoO!ihb2E2w#g9R0YmLAQHP@&ng!Y9NT?lnal2>ka1_?ork0N64mfIcx^0F`$BUKj
zRS`G0U<jYqp5f!#*VrvD9=ygE0MOM>h8MHqZGNtrK1_P1TBgUP)6?fN9>2R20T&Mo
zXCr?pmyo*jl(tLH;rW<S??%MO$fj3@#Lq~~$GQifiAc;AcO;?{Qj?IHD2Y#!d6$U0
zZ6rzR@#%?opPp*>>4EhSy%9dm-HC*lhw!&t@iQ4b$aI|47Sv`$)DjVuh{OyDpHZ@4
z(y`^~Q*A-SCZsN^EBM5DdQU(|uK)<q%kF<jB&0VBaIP|tB83Z{0h0lLcS?fi(Bm>w
zQ0W~ATxU``bD_5)Wipx^_S}jLWSTagioShUQZ6gUX9~WaNw06<`5g^>LsRJ`QX<8N
z5TXVW1(A{h0Lh+0>1{}5g9x2oN+GgJg~=3bChoS9D(g*Tb&33L3z70CG#ZH=d;ov-
z22!e@lydo987{wA<7R`XCEm@l@nf1#PUc1W)H%<k02OizB0(oCF2@MZjwZ7!o9uBe
z+(Zd`wmxwL&t9angVpaOxjFF%RU=9{xsI0F6s_xDT+c_tF`}U6ppbb}fZYMTnTL)d
ze&Oqjhx1Vdr}Jx8@Rd*zTu7Goc}FeN>JNIcPqT?gm-G7aOt$axq^9Ticzfn*8Cm+y
zjF74I$V3y_g0uetwtC$_myz%V6#+MwA(sOt5I8t93NK7$ZfA68ATc;IIg`N$D1Uuf
z-O44o4ZJ^3(Jv6z)}L)y7D6CbA%u_@*o(PX2nkFkA&;NxU$q>4h8a$uX{jVt$(E0&
zaox(+sBH~@h_|Y;wK_H`giqbLFh0x1rdum*lijq)CVk+uY=&nWwplM98}QNnxo@2b
zpR$e8_jlXCvo+gl5g0VuYPGtV^?$7r!kP&ly5ga1Rd!$iRWbUQ!dMCJ0%PNW2N<^k
zcY$$3=EgAY3LJ#3gJ44)H535ClS+p%m5r*xxY~x8{IN<Kae*<CB;KQ=8j?LRWI)Po
zQ`AN}1|DF%Goq-D+NgMd@g7uB9}R;I3S<=cQ547(sEPu)!cb8l6N*#(Wq&5x6a}&{
zYyiQEfU0<<hF9Q-t>Kjbr=d!P9rp@k22MvV$}k>)SF%kCC{ch)MU`4R9+0?J-UWj(
ziWG*cf)NqKQP3v}0%Sl`)bx=7<6VbcTG@jN7?F-f5YQ)me+91Lu)pUW3-9-`E4oO~
zAWD0OfIg)TFmSER^&>k+f`6JsV0@%0FxG)I1;*BZymQ@<7}5lxdt!8uj#vca0m6lL
zVGJSat|E<(pg`z~G|-|(`>V2dgYZrX`U9OTN23h1GUA!Giif?=5QhP3?O?R+-8%39
zz)|amQKSu2$?a%-*uWDjV_ypUQbAX;VQnxPjiG7d{S``XAQ2B(Mt_HT3NM2ojP7kV
z<n!~-pP&Br+mFA0+kLV4{`&dp_rM$H<6nOL{_P(>(D~?&^B=x{`_HjJk8gke_TL}y
z)8pGOzr4Ya#{;G-u)S~JU^N312de>W-y9PA^4QlF?4M{y?0pM3zWwpH@BjL7>^R5Q
zKmGdt_J@D|8=k+bQ-6?Z9)v@X2liyENRnc$k9Ub=-}bk6OT3G-TP*iJ>8vI5R`;f5
z<|SZhAnQu(BI^otlSOmLr(7F-5pv(WUm-K<unrtcmRJ<9N`}RbRaRKNzp(BsBUT>|
zR<|XV1T4z1)UjxZ^_J+)a>8=%+ZWtl-Wl7?*>190OBNe%ynmbJN%LwJ4b9T$kS<D_
zM6nn$E7x2Gv)ubEw`Ihe6K}LCS1DkHjpR=3EcXud#o91)eRR_24swOex=vjmmE8MG
z(X#$mr&`ORTn+2;A@VBs-q6o-ZMhX-_&p&d>hlCS%ayDh#q|+ddWVG}S*M5-&wYi(
zq4+c}b{SZfSbsqj$wXlnh06+y!luModyunDOSUPj4bIjEIrp^Wo&xujaZk>DU2<Oo
z_mpv8o%_1vz6S0o<Gwogb;*4R+}Diz;@p=d_hDw=Sx#8aeOYoJX7-)sg!OQ*;|uOD
z?}Tmj@vB3YTSj2}-i)p-qr3;gy*!_z7SA!+V=lL;Fn^{s8`J7zTBk7`kD{6lX7$0W
z(_sF;b8R?0-ACrL{3p+A9*$6cn`63O(*U1i+B>FZ^IUzN>pahI?-MH<kLsgYr_nrl
zTM(jULinK8X;9BtL6$TxAKN;Q?Z`=XWKf^Ls%wHZ5?q3)cb<o+cg?q`GR5?{tr~wI
zJwdLJoPT7j;@*^dpDAW%234<D*7e?7*hOBfSKmLE?nqyZeHE`)roMZA039JE(^tIj
zq^!I-^qpkYv-cg_5-apwniqTDF)guzDx7s8yDHRISY!b!Tjk_z(~@nXfK@Uq=bo0_
z*T6kx+*jwmF1f$w@P(CeUwsYKnq!^bHDkLzcYg$0+G-65hg3AKfg09;#5FLcn8iG1
zyfS!#T+1%G1<~@{&&U`HZyE3F87;~6jEwGBy2J{_XL-pG$Equ=dyXAgca{^@ql)yX
z%Hw@uWmR=^Z_d5X*nMQ)&Tm`t+ghlD-wkmmb~eNv=!;EJn#<6ZGBgh9XEHRGp)F;w
z_kZHJi<z)o25U<!4Oq#j5_3^()%2o)R?8$Zmq;gxG^<0MUtRL6fnN(ZU2-1}PD$@?
z`L&?<WENe@AVG#aeV0L&GDwgiJ28m346>9#!b*`$25}j9xl%YtD%qN4mx#ZR=<?2*
zo}F#3t6iL%hK(#-Pd#~_yLgG$Q&s1nE`JL}S)M3o`IHq*E(Gzyn@13WG9k!?s8NW=
z`^=<f?Ny!nsta!(p}i;*!iTX`ny>;V*^RXLZMc-N@-CsFYS!p}H!jn!?iou0R+g9l
z>XvC>&sagL?9N_Z<GYjv7LOjVlH(nZ=NQGK<ye<@&AiRMIoJK-B>ZT75<B<78h`(L
z#O5GRx!lL9&0E+9Nn^+`O(|}@(=7q_?jfgsZtue-_oQ#Qi+k7H`$&;{%e<dGf!h~*
z!s&f8d==Q==f@lRi{k<}7q0Pgw=1CwI2=))axPNG>USzP*U=^&OVH6WTFfOeU3u5{
z!seE>t+_zcZ~Vvm%A{o8&lbbe(K})C4#yC-tX2G2!D>q^30PTPs*c4=toPF7?7YD0
zT1~h46PEOVm2EM8P0!QWW5x>Yt&ej515c5#ZI_Yo1rq}`Ff*4woCioTHZU_XHZV6e
zGBPkNFgGVKFefPrFHLV`L}7GgASgsSGB7bVFf%eXFgG<aGB7PLH<!4a2V?;?mm!@8
z7ZEWj3O+sxWo~3|VrmL8G&MMvA(sOi8aFfwFGgu{b95j#FgOY?Ol59obZ8(mH!?Su
zft?2`e_4~;HWGgKui)EyQYD+jL4Z}Mq?~b_omx9~d~CLAlLwB38F3?tT9O)j_SbJW
z(9J`jl(E;fFCI`pA75W+fV5OPNfW6=V)8`FBFVIXzj-2rg}*Y9sY;|M5@}(X$P=Yu
zosfx^uuh~&p2E7!B)Lf+$xJ53!hBjJHi!9Ce<y_i`ZP<jRHcb1Op;}(fPsX8v5BxC
zQs9);NhX20u&`KVFlAt|D%2xkV6ir^CWpm22o^akHVW3{u-IlWrD3rJ*+RqO0)z`y
zBqEit1|W(og*7SzSQ)I51_p(Elqn61P->=fWP%1zz*FSF97e##XpJKYisgQ!5QeAF
ze}K$-3bYAGfRO>KWeP_Y&1ygfXf3ruRDeO|sGu@gB8}%~z)senG=M1!&(Ektfx&R3
z6D6%*2evl?<$_&Q;k5!XV4Q;tQzY7=4HWn(&m{5#L*{wre*^bQG`X_ip~4&1s>I41
z`2l-t1o8v>6=~sTO;RY0h^$QtD=f%Bf7McfzEnku4h8eT5PgeYhao&?!rRdMSEtr{
z5Qe!xG=)a5E585;GEe}A7!*Yq0)a?%2GR-)j0~4)w5*V+A7&UX(hmg=wSDyMw~wB_
zueyx`gXa*<Zy!B<216BwZ_38)Iv=Cqxp8+s;QiCj?i0*`v+?P>?<TzDz$-h)e+vMQ
zdFeS`Y0pdAv%K;NFEPVQnt_)-%S(=Vk(Nii)WA!e<0U2-Ny{T%14eNcqnKbMEvLN1
zfKi;qC?*)i97Zu<6z4If6JB!|Mb`7mig{i{J%=i@1N9NARF5^uCa7}a{Gw{wZcy`O
ziBCB#y{r$wXOZb+nFIPPJ0~-pe|VVC9Pt`FoSJ!FL_LQ-9da|36Y2~%l|dEU6GqI8
zp1@~41ALQB;2)z;1<Mr0)L*@jAhMXjD+)VM>$B7of2G+RFE#MW=6QMQ6Pomv7uKA$
zT|Tj0I<Z}^XRuv5wVgbYY4btm)L*?2a@QPQJ6PTn=cvs%Z?Fr9d6~fve@36>B`3V*
z^fH4VOg7IeP@6eFn86SEc|RyUQKgvp!HoUDnAs2NNM=6xAwTki(i7Lu;mrp>=;9o;
zp7<f3^MfAzp!Hc^6F<!Ar3XLg>>MvO@rs`FiXOb8%selmo~cV>=oy4MUzfNIAXrnM
zs&QRn`<<vuLJeM##aWqhf8v(8=0eE9Ek_N(z>LTzp7^=kx;FXe<8Rvf&@A1eako|5
zHTR2s*}zoins0uCuKliTs`7f{E)wh+fj)V>$S#r)O)wT0*oV=Bga@0_gSvn=n`VF_
zgyQdDqH0@ppCuW{e?L|`OMxXRkpX)f>;Mm-ks%#2P$=X%j6okGe`u_MAWx4KLY_Dm
z3(J9460NzwhM68LOfbd*#yX5ahn&_6U~2M66mZ0;NR$99q4>Z&LLpcJp%7jHP>Pfn
z0hS^okRnHS=woTf6z5`T2G{3A3}6bu@&HXC2?NN^38hT&cakkLBsY;b;EHpRIO(H>
zBuL;|X!4XqNSdrCe>E;6uo59jUWWS0>{uZ3#kp9Z#r5PYS>OXf0(m)!QwYhDRth0W
z0;^D88JQEg;#?$7VFE}prvedh@MIx~iS4F5CYI<i5n6=`t0*#&G0w#j5tAbCYYY+M
zs#BaG<QhR)UWK46&!EPsiXb9ioQwo&kBZ%<5tSvAYDC3Fe?lWFOW-x4vSb&HD%&V%
zkTK3h5`k+@q&b4JWU3rN6{JXxpi<T(M^pvj&ArA&WK+yQn2Y6Uzn*a9xql+7=7_2w
z+vSL=V3CN5iC|S80Ytu!XJXVKsDdnIJSc)|5L7`iV>~9(!yu-D3}JvV-aj14L%ui{
z3(T=Hvp|Cne=N}A0}CuJ{5_C=fQg)kDgItW;?SOUrlMJd)Z57dCc)`!B|ea!EN&Q_
zs}?bFuG)|;5klmQld(ty#Yqe>EMt0x8_TwC9R96#clGAZt#Ir<mD@e;H8LX&p1phi
z0%w-x4*y(xlEePCDOYZV<vp8Sx38NHcCC9H??4^=e|uAHTpJ|fzwP0ARW)we)lKDE
zV8x}JS*_fi+tm9lY~uL%;@K}P?qfE>k9GDOQDhii4D@bu<40bxJJ+;Tz4O4>RzH->
zKR%X?H_v6g-IrZ;U2UrF9$EoKvG7B6y{T%j$$ov0TO|4QvRtmK-7QkSb?sr(f&Pm3
z%*(Y~fBr$UAJ?v1y9S57YF?pD9n35=Q`OsT?afzqT~l2jx?s}UqgaA|p#Ba8$&iI(
zLp=cY!v#b}y_^VV6V$t<+k01B?N;s+T1WL$H`VQ-0fPpC&)!_2ee#7}XHb+&n+1j-
zL4sst5CjC2Jis71qvV{Uz>tR=1>b=o%LU0GIVeMrLCHBN8OcG(pddMiAuo6Le!E}Q
zZq@$j>T~)z)%~M?bXT9}Y0B~8#g?#*4)UJyUq%I~dk*v(y(j|ut>ET2__paBJ^6|q
z;%1Zp40hmV7`eZA&fFO3JKS>{Jlnu?k6J0{`Eyd*x8Z)H-FyyBuLrF>TzXli<Q5>8
zG_gujtv9skm74lX)&x*r^_HLHWLazOD3Jw&5n``0ziQFyI?6A?-t_~#xXrUXTh!c&
z_)kv1$2PR-wP!(kf?f?I`*rYR+jAz^GBi&C+42t|9(Gk`1X9qGi6a%#oHnl}BE6Gp
zKGG(3yz(XU{VyI?>&&))q%^*aD)(J4D7U`QtU#YtXyQ8F<uvf0zG%4^*&z$D*WI1D
zpR`^tePPLsaqs*5>#+)Ft~}?lGM6`{e&!#z@uSls*<T_RF7l{3J^@qDk^nFp1Hsfg
z;MJotIJh<~bAKxw;8I|FO;F=nNAe+(?6tIr`iQIfu0baGa!ergkJKfuV@Jx@QgrF|
z6!a0Gp6NX;K3=HZti~oE-Y#b^)frT}A<iZO7fEI|`<E}_NG6#T@JTwZ_Nt73!7q{p
z|7MI7e$51R^NC12OhKSGSF!yLTH6<a#_Wgv!RsuwXUN>vo&`0j^jm8~AL4IH{(tD-
zqdHzAqT5n2y)9lrWLj-?lfWF?Exg|s;@Hr?--JGShMSt1lsc12oi52)UFP>TO~0w<
zz%710X_kX&-;LH|*|i0vQFUD(A-8<+sg%Y|NJ(31bs2S!J0I{|ApRM)Rmub`*`yqC
z_jh<Equ%vwqZasAVU%{0-?W@jMv_e&1M2HB;&oqtD4S!V9&CN_1iR*b%PC{FBh@KB
zq&lf}xuJ7cFg0<&k-G#p%DI)9S90R5RP1(lO_e>w+n**bxTTHJ4d73lW%OnJYGX0_
z67+>sEQE*@?@a!Ez|O)AX6^19C^i<2hTk^ecK3rwBh%%Q?#M=K!-x;;JDoZ2SD>~>
zwH9CzUcJta<X@s2PPvv3B^ohT@1sA7m7{}F4>E2x`DU4hM(Vv<4g8ZcleN|b419hm
zUN!pudQeOHVAd!2p84;|^{k%Hu?6SdM@|IcF0)>|=q*G*R!EX-f?H|@P-$ZXPR)0u
z@{qm}&K6Ih=}O3TJ&Q}$p4+vk+38R}y<RnAeec!t5RLYAH9QTbaBOv}1U=LbTeeap
z@$rpW&S$sy&2O1xP{n~~c`;WsI(V*h%FZ@_yj?J{9UDLOae*`-_D|OOivZgW0{7@F
z{>NO%l)2DB+J4Y8CssveK=_fkoyu=RyRL{unYysLWBTFkpggljaE`8<nQ+_s5~=Vi
z>GKo)N#1#w?ygy|Lp+1m_e`B?l-Z}NZrzB@muz<RkP)$`y<|e|e+Xj+uS#24S=Ko-
zbWm-LfWrYIP~v`HWr)lI+KSjBo5cAkbQL94;bf`8`NVP$?yR!|7^3Qp5;t591B0xV
z4YAPYrMPiE@E4aHcH&azFIu^S=j$l#;hx?!V9DasK=RDqHPGms{=2o;`=eies*>@1
zk+u|Vy%`Dm6cCD)wvV@1`FozBz}W-Dz0@rC7boU+9OY~t*N~UBlHT{xLW9q{I%YvP
z3pzj#vnP>|EM2<-o~)}+&dV_URZ;0r+i?;M&~+w0O9fo@uLzN&3!)!R-J(&5<`6y7
zRewdp994;DgBB$nH%Y6KKck#PYai{=CN5fDd7@H*u!VA$PN|?Da(uq=J`hRQ+mgwl
z%4qJ}sbzC*txA&)M}~<%WifT|Hm<bahOOxLG|3~R2PeirzqhOR&GueOaRLVhZ$KPq
zSuupeS+1IdUGQS~elIle2*D;jZ5yz!E;n}YEvtYx3@CrgEP>%akhs{J3R39CBQZ<&
z0&w(~8}miKwhxz~C>*PpeW(52j;8p~4fDm$<?q37-PpJ?7uw$3Fzo5|TJ9m=UWilR
ztn4Wjm|g%!jk#;o^wx0pqQ~7_t#!Q|jR(e0njH}u6fMH~K>bOW#=L6*<1gCT>L9Y!
zw&pJIMYr&~;<vJIZ?dBFxQm{Px^-*s861(;KJ}}sv|Gu<HM!|9OmU3-SV(hTP6+c?
z5V;!BP;~dY$(Ia+y)yAyU#j~MNU&^%hh;8V5%mdh=C43`-egOe(Je|IWE#N<`Zs*6
z*UHd*1&cPb25N@r0ZB$KIURL2%SX(Ga|hJ+6@vo7s&!wjPW2tG8sjG})xFpKLKCJh
zE_U_bR>;MxU7Um~X<XHi?T%{qEoauXri3Zc)~uRl01~%-w<><QR~O&g`U^PGa2jaE
zH*ug@v4t$9)AN!sc57dr_)v|!uKmqLConlEeS4{84JR+7$xsO1L!RU=)6%oDbryIS
zjqJ_g%zP1En-9O`7e|G2D9eOf_9^sdecbB{%mB&^WLDZTm0Rfzsct7F?&FfNkxirl
z7|6{>WcaxK!<(kp40KFJOqHQevakJZB7jfUxDga|N-_&4i@(O1bAxB!Y_gm1A*qGS
zQPzq)rej~23?#Ncj9k6URW!l3rVq0tPu;OM=5fB=PQP3=4M3B#^3r*9L=o2pu}FJS
zO466$74p*gbfAcp%qt-)YQg?RN(>S`v+ws8X}cfo%<q{W9)Aggz=PjfZqCa+kmr;e
zO?y33*g+_D^=)zYT;lBZEJSLz$p>xKrjhf;0gP5Yy~PuEe{BA*yRuMP!zY5r0Kc#~
z5udJOpdGV-FuyPnpCPlU05gPH;EvUCbMyY26=ddT)*<4135U7;4I%$P1!hwT1vw!(
zd42(?ECi|`uOuiZ2o)6(R)h!%3qS>w6a|%}nE#&;^1GP3ss6FnK}3Z9%UZ{tVd}zU
zNYUfxJN!AjjFMxhtKqp}j|bzQl^-5oe0ggr#Wk{icvRF<a%`wjVShppsOYcDC&YxB
z-2FL<>r_KcRil;fmXP;UIpv*J6XGcwCr(Hy(L`~np5CTB7xC)l_0i#Y#?O;CP4;Wj
z;#F}4oEH-XsOMie-+U&Orti`Qs(WSTU4lyB7u$5AaBaV;K`%yi1i@!T^%T-r8!>}o
zW8u&zmG`*uRoitcNw^8VTj3cInzTQyWT*}mw&F1&m_mwFV!PmGw!<p%s*#_p9{wQp
zMPysiu46UHa{K_DhA>sq3K>l_=kaW;e8!h$Q1<wV?~6n(iPmFPAWc1h<RVfbq`?UO
zDFT`Ih!Mom&M7)TwnISBF6(~pIP_~C*)fvU3X2i1M}`Q$gIttU1Cg{uMTgI7Ma8LQ
z-%h86>+_IOCP9kqNe7-gg<6QCJDwTdbi0o`XfTw1#C5dMuqHaqzrSn=20njWN#cTQ
z+QC~%b{z6+Nl28SUS<fu^E6+AgY|Keb-b*Y=5XuUaq92yA}%ZyLS7U8_K(6YVPs^^
zl?O5Vff^q6&dcoLdqVf+L+0-PhW|VDuIXP?AH$2OJls~7(OT{K0Wl`oAGp1VPSRFn
zrG-|#1^Km6ll-E@A7!sU&v~;N5sDyyPkF?QSRe$|y(l*3M8pf6$AtfPX9RCVc^%*3
zNnXa?8pcGbjVI3Xa@76!@hd_CIn8!EUR5$optqCo-N7M_x1{-n7hf@QXR$b))<Icj
z4wR#E>pgz=a(!v_!?1%|FenP_;4m8u=`R~#52Qkf#AqxPmf{Lg7X41bPzg>@YOIKd
zYkpQxwx(ND3?dSYAu7at+~>M*c$U@S2g+q4P6_u2BE}^1t@EfYHT|U-9d_6mki2rh
z^>xIm9ua?M-U>tss4Y8xE6!3#lhrW|(d>&M|7sWHywCME0sf9*dPO&ob;TW=dujm$
z#AkiwmWr`rk!7yokLOCrt8*vT?UePFC1VxHZ+54xy5Sem20q8$2)?qzFqYA=r4v3o
zKmIK?f_04OE+ypdoY1F1Ud&(4m>Z~e2o8#ury^m4v*iYelyu_qyNx<%T5f<e7|bl6
zLexl{<F*D2`dCS}dSTZ1XWQ|Erh)zMui&`7&)G|yq5M!J4<_o(ju=c_Yr`~lk6}%u
z61?acWGLW=$i|2)H-$D3ds|t+Y98jr&ybW!BHm5%ex4z26eu>{0ZFFomY*U)>9odR
z+(?YD`3(+?Pc&8&5Q+Xt;Ged7jTy3G!UkdDmc%0isP-ENMonFDAb3asGh({Ky+*Dz
zDvfkwJi--?b|YD&TjP>pAM82E?qI}jesOe!(Xb)1-~Yb!uxkRZ`+&>j0&<PPl~Q!3
z(}l+2dkHpu%$<-g>@cH{h%UJ=kK7D(YBYBhU?^XYbm|eHrV=tr_$e$|+8KraOvwD<
zH$9@fj+kV$V`j3HL*<>d)sIBC1RAgTvx3K9X6%h#e-^eH`-N-J)&ZA9VuVGmD+X2Y
z(majwh~n9=b{Ofgb+-)qCl7}6Ycz-{SFoJ63R`Gp_HF!w93gCr;}o5EIF~U=>XL3J
zxZR9s9j_FLIkn*>@YYI6EF<v3Gm4I{sIDce!h7*;zT5y5?av3431d+h_8j<FSAe4G
zb;Nc%iaw~4dkBZ3DZN-n#EtO~5qv*M$US@rEeT-aGT*4}Dr$+n9{v~-*JPQEZUAk6
zQ$8>4o9F{$^ss7eHY3FjN-8#V8eg_dq^-=xln`upPlsyO<@0QG6!ZKHE!mmK^k<cl
z43+b^mrK<DL@gXR;FnUgj7L+g_tf2A#2;jpaqaRAnrSRtqH6_XrfkNZaUe0t6f>tR
z?u@yDuXxr7-5=x@px<TVe8t4AICn8(7h?Ru(^MPdOC+t<L1p|s?V?g$I)t7yYD>C(
zM$rMJSv`I<xp!67%-W07p*9w{x)?pC<n-~S2T~S$HFiKcWJ$2qI7nsl+0xV2=RvCc
z=#VW8d?kq)jxY}L+vn-b0v#Q{cuMwQT-}{Gw_l!h4QDCbGzotX%dVjK6N>m!*^PO7
z3<LQ<b-_d7o3W&;!k#Xchp(=$SnNKU$OK6%CrNtEMY}wU)J*&HT!mMYdjF@n+G*Zz
z9f`c*`Whhd`dI*neOZUA+G*=uei8*Yq3cVgWH$AeA}K{S4Pylxmt^uv$<@5{dokM*
zPcqCC57{p`DRiR`RcuWj=X>5gjO}gW>|D`v=|8S~Ae@T&tYE+{_O#?V`zF`R^9MZ1
z<}{M~VfYqfwMA>mR9|AJjXo-AfKetIC+SWklLDuJ>G6o`wWueTu<GNe#8@6>?!e=m
zxKdZPD%G)CHceGYW@E!R)8ijf*~ONuHmW-4W|E3fWB0y-*9k+cgsK*P^pE?FX^&(M
z(yP`pfc0o{^FEi9r@ekW7ago>U`N~24{Z)zZ<$?jPWsx`lidXJ3W}5Wy%QAC_t)EX
zEK*DW?W*xrn(I?(!MjpSIn`YSP}cKg5+`>kD5BH5MG+YCt_Hh+#M|NR)#+29iy>XH
z@Ka8GK#@mdBX6uF?`y%C#WYto;#|<KU1h6kqo+`81hnoy2BOg)9#F1IV#02L?LrSv
zJd$XQ1=2pqGvk3^JgVMA*QzRC6G`8@P689Df?q!hadXYT2<$I^UE-V7nY5w9x}B1f
zwZ^7@CJmdqP2kPT%@TU(m{Q`ZlO$~?qTLJq{y~Vu4BP3<4MAVk*S0m?&3_W`igbj!
zs0wx@*@*RBVQ4_Q#pZPB$@#8{!~wOz^G8C5Kek8DY!eBR^VrT{i<r8g`v{5N%t4^_
zn(vxT*J;R9!qVw<8~s~1O-YF#>&ZD$RocQdo(Wb%!cq5->355r=@4NA)ORQ{IqS?@
zqv*&7hW1;h@?>>`ULr%&lGqy<U^?uJ@Y88vv*&~&gkF3PXC7hOEB<}qy74BpsP9}O
z=?q7>ieOL*qoq7aTSoC@|6IFD6R;S^7OuBdctbQ%c-wY4t?O_yLb7{a*`<EzWA$L-
zPu}E1A7@Cq0)Ly;!3Bp8QOIz#os{bVO$i4_={faVap=HZ0#&H8%#rb1GV`%IoL3o(
zpE2KtdJ|Le&L?8KXe=A^bM@p)VQSe^uipNlUQ|)1$wy({=u;q6c1G`N?*l(R=tdbR
z;yybu<gA`?IFQes*8XkiT7wzo%?K-g%tU>F@-@2h&n5N7N;b<MC>>vUZ8`BNp^G}x
z{KV*LzRp{4)`F$4bb93~@{l6jseOfZXh0!gGOvrTl_$v+tzmq1G~BQ7h8m}g+{kBU
z#j;FL??vIOj{_6&RXdYKT>#)RqJ3;Yk>k|A;@8TNJJjTIaCzn@U#DtY>P!P%>7P$@
zmnrAgd|OP2chKJ)rS+d3@EcFGLpybuN;JXx{7`{#G5qF&V(?OzL<>ne`_^rlE`toj
z2!tsTY?(_0w~dcdTY-(pX4+{+oL&xliP`aJ8P34_KHIPA%9oOQ1CM^#^<|(p+ToQ1
z+XPO`uemcC9toZZIWbQPl!CWwY?s|GW~JP5Q5<@dC^&D;Z?8Yz{p6z96Jyz+VxE8^
zb7hVWMgIFR#LTB>h>s2z&Fq@q8@4CzPBRl9?#}gT?^}s!xX)=Gdo;X%>?5n5SCMR=
zJB58J<(JxgLMb_W9~fM<N?_*;%<hENHUCV^olok6>9#VS^sn-yUKQvQ+{0QO&~9a1
z6bE}X7e+KRgZD>y?Je>gp0B}`Lp;w-R4vY57%u-}a=WMe$xBbPhd@_3+>1)Er&zZq
zXqVHGxA;%-yXP^fh3}s~P5ZS~Y6J5l*@z?hb6ALYr#)?^5euMTap=mpj(LF+@tDkk
zjlmM<xW+Y%(pLIUuzaJ<Q@;tZv~iE4gDHU&aiW}oXcC|A+FNEC+~?I>bYtL}p;g>u
zzLq$ad4ZHBGweM1k4p_^!3XMja5{n2i{@Sq?biF3Vf6yv17SwPBwHC~l1XKnRJ$#y
z%?Fh$;<kN}xxlC;e-!(s&Bj|wAN1fjNnsAf1SB*NUlZMtlriqSW;=Hro0-Eh4zUeX
zQXO{Kpy!kXeXx%`j!no}9)(B*Dk%;3uG3RVA`9##j$<Qp@<%u>3{-l)bFR~4NrLk1
zw~u0jbF7CU+W|@v!%=_ew<VC-_E|@<UO6m7kZ%D>0CaeLjsAxODAQi;DAqA&c@UBn
zpd>i_VvYWr1Tx+J>M+(aCw~Cq9iYTBj9R6ylmMmLmmkLJ=UDec)B=<^hwrV@XGtKF
z?9C2iRdZPSAXolMOvAmu=)Ifq!7xTNJ%?^@dR<~8?_z-Q=Wm1ef|QmZT|q;MWD!0>
zpSvT0JwMA>{fr3eh~wB23Dyhx(c!2!O2?3bT*p@||DZvLTOUW;^hwm4j~QX>_6pMf
z9!7DkCV%h0MHJVu>-ON(piS@d`86@A(bDm`G|N$^_=e)e>C%C@_}Q8n=iQSs6Q9hz
zAd9l#wH_d6ytL=)Y_AS^`MpiDU=rKe-LP8B;eK$uqfalxM?U9C=lhoavSnYV_762{
zHmf3_#nqd2-Pyp{W|S~fV+D0UioiZhfuA*$o??)u{NSMYvGdiM_0Y2)QK5fv{;vjy
zo~k!*1i*eLo9{N(n<s;>izmqWPBw&u$X1IPDR;{{B8_)!iS;+Q3!Q`iGw`1>8T{}Y
z?Yvu(bxZ8OmH#7*HT{(&c~Ts-=6(#sK`8^$=9>u^?+ZPLLIt2i?Cgq~N<{wwt6Z?i

diff --git a/src/general-info/release-21c.txt b/src/general-info/release-21c.txt
index ae60900b3..f5eaef34b 100644
--- a/src/general-info/release-21c.txt
+++ b/src/general-info/release-21c.txt
@@ -22,6 +22,7 @@ New in this release:
   * Feature enhancements
 
   * Changes
+    * ASDF 3.2.0
 
   * ANSI compliance fixes:
 
-- 
GitLab