iterate-20160825-darcs/0000755000000000000000000000000012757566717012727 5ustar0000000000000000iterate-20160825-darcs/Makefile0000644000000000000000000000067012757566717014372 0ustar0000000000000000FILES = package.lisp iterate.lisp iterate-test.lisp iterate-pg.lisp iterate.asd TEXFILES = doc/iter-man.tex doc/iter-bare.tex doc/aimemo.sty doc/GNUmakefile RCSFILES = package.lisp,v iterate.lisp,v iterate-test.lisp,v iterate-pg.lisp,v doc/iter-man.tex,v PDFFILES = doc/iter-man.pdf doc/iter-bare.pdf distrib: tar czf iterate.tgz $(FILES) $(TEXFILES) $(PDFFILES) devel: tar czf iterate-rcs.tgz $(FILES) $(RCSFILES) $(TEXFILES) Makefile iterate-20160825-darcs/iterate.lisp0000644000000000000000000040033712757566717015264 0ustar0000000000000000;;;-*- syntax:COMMON-LISP; Package: (ITERATE :use "COMMON-LISP" :colon-mode :external) -*- ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ITERATE, An Iteration Macro ;;; ;;; Copyright 1989 by Jonathan Amsterdam ;;; Adapted to ANSI Common Lisp in 2003 by Andreas Fuchs ;;; ;;; Permission to use, copy, modify, and distribute this software and its ;;; documentation for any purpose and without fee is hereby granted, ;;; provided that this copyright and permission notice appear in all ;;; copies and supporting documentation, and that the name of M.I.T. not ;;; be used in advertising or publicity pertaining to distribution of the ;;; software without specific, written prior permission. M.I.T. makes no ;;; representations about the suitability of this software for any ;;; purpose. It is provided "as is" without express or implied warranty. ;;; M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ;;; ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL ;;; M.I.T. BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ;;; ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, ;;; WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ;;; ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS ;;; SOFTWARE. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; FIXES. ;;; (v. 1.2-ansi) ;;; 2004-11-30 - Joerg Hoehle: a dozen small fixes to various functions ;;; 2003-12-16 - Tested a bit more, implemented FOR-HASHTABLE and ;;; FOR-PACKAGES (FOR-PACKAGE) iteration CLtS-style ;;; using (with-{package,hashtable}-iterator) ;;; 2003-12-16 - ported iterate-1.2 to ANSI Common Lisp (in the form ;;; of SBCL). Extremely untested. Works for simple ;;; examples, though. ;;; (v. 1.2) ;;; 6/14/91 - fixed generation of previous code ;;; 5/6/91 - improved code generated for COLLECT and ADJOINING ;;; 4/10/91 - added *binding-context?* to correctly determine when inside ;;; a binding context ;;; 12/20/90 - fixed ,. bug in IN-HASHTABLE ;;; 3/3/91 - no longer generates loop-end and loop-step tags if they're not ;;; used, to avoid compiler warnings from some compilers (Allegro) ;;; 3/4/91 - treat cond as a special form for allegro ;;; (v. 1.1.1) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; OUTSTANDING PROBLEMS & QUESTIONS: ;;; - What happens if there are two contradictory declarations ;;; about a variable's type? We just take the second one. CLM ;;; doesn't say, but presumably this is an error. Let's say it is. ;;; ;;; - Is there a more general way to do synonyms that still allows ;;; some specificity to particular clauses? Right now, all we allow ;;; is for the first words of clauses to have synonyms. ;;; ;;; - We should look at function type declarations, at least at the ;;; result type, and record them. ;;; ;;; - Consider adding an if-never keyword to find...max/min ;;; ;;; - Consider allowing accumulation variables to be generalized ;;; variables, acceptable to setf. ;;; ;;; - Consider parsing type declarations of the form (vector * integer), ;;; to generate types for internal variables. ;;; ;;; - Vector destructuring? ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; TO DO: ;;; - do I walk &optional and &key code in lambda-lists? ;;; - try binding *macroexpand-hook* in walk ;;; - track down PREVIOUS bug in Symbolics and sparc lucid ;;; - reducing and accum: RESULT-TYPE ;;; - rethink types ;;; - how to type result var? ;;; - (for var concatenate (from 1 to 10) (in '(a b c)) (next (gensym))) ;;; - (if (< var 10) ;;; (next [from-to]) ;;; (if lst ;;; (next [in]) ;;; (gensym))) ;;; - for var choose, for var repeatedly ;;; For CL version 2: ;;; - variable info from environments ;;; - macro info " " (so we can support macrolet) ;;; - use errors for EOF ;;; - change WALK and FREE-VARIABLES to take symbol macros into account ;;; - array indices are fixnums ;;; - type REAL for extremum clauses ;;; Maybe: ;;; - decls can appear not at top level, as long as they appear before use. ;;; - extremum and find-extremum should do reductions when possible ;;; - optimize collections, hashtables, packages for lispms ;;; - fix :using-type-of to check for supplied ??? ;;; - for-in should allow numerical keywords (from, to, etc.)...? ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; TO TEST: ;;; - leaving driver code where it is ;;; - typing ;;; - macroexpand & walk after-each ;;; - check for duplicate keywords in defclause, defmacro-clause ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; TO DOCUMENT: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (in-package #:iterate) (declaim (declaration declare-variables)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Constants and global variables. (defconst version "1.4" "Current version of Iterate") (defconst standard-type-symbols ; of CLtL2 '(array atom bignum bit bit-vector boolean character compiled-function complex cons double-float fixnum float function hash-table integer keyword list long-float nil null number package pathname random-state ratio rational readtable real sequence short-float signed-byte simple-array simple-bit-vector simple-string simple-vector single-float standard-char stream string string-char symbol t unsigned-byte vector) "Table 4-1 of the Common Lisp Manual") ;;; These next two can be used for maximizing and minimizing. #+nil ;; unused (defconst smallest-number-alist `((fixnum . ,most-negative-fixnum) (float . ,most-negative-long-float) (long-float . ,most-negative-long-float) (short-float . ,most-negative-short-float) (double-float . ,most-negative-double-float) (single-float . ,most-negative-single-float))) #+nil ;; unused (defconst largest-number-alist `((fixnum . ,most-positive-fixnum) (float . ,most-positive-long-float) (long-float . ,most-positive-long-float) (short-float . ,most-positive-short-float) (double-float . ,most-positive-double-float) (single-float . ,most-positive-single-float))) ;;; This is like (declare (declare-variables)). (defvar *always-declare-variables* nil) ;;; *result-var* is bound to a gensym before the clauses of an iterate ;;; form are processed. In the generated code, the gensym is bound ;;; to nil before any other bindings are performed. Clauses are free ;;; to generate code that sets the value of *result-var*. (defvar *result-var*) ;;; Iterate binds *type-alist* to an alist of variables and their ;;; types before processing clauses. It does this by looking at ;;; (declare (type ...)) forms in the clauses and recording the information ;;; there. (Just variable type information, not function.) (defvar *type-alist*) ;;; *declare-variables* is bound to T iff the ;;; (declare (iterate:declare-variables)) ;;; declaration was seen at top-level, or if ;;; *always-declare-variables* is non-nil. This indicates that variables ;;; that haven't been declared by the user should be declared to have ;;; the appropriate types. What "appropriate" means depends on the ;;; context. (defvar *declare-variables*) ;;; *clause* is bound to each entire iterate clause before the clause ;;; is processed. Mostly for error output (see clause-error). (defvar *clause*) ;;; *top-level?* is bound to T at top-level (i.e. before any forms that ;;; contain clauses inside them, like IF, LET, etc.) and to NIL ;;; inside such forms. It is useful to ensure that certain forms ;;; (particularly iteration drivers) occur only at top-level. (defvar *top-level?*) ;;; *binding-context?* a misnomer, should be named *declaration-context*, is ;;; bound to T inside a form that allows declarations (flet, labels). We used ;;; to just see if *internal-variables* was non-nil, but that's wrong--you can ;;; be inside a binding context that binds no variables. (defvar *binding-context?*) ;;; For the use of make-binding-internal, to pass back bindings. ;;; if-1st-time also uses it to create first-time variables. (defvar *bindings*) ;;; This is a list of variable-lists containing the variables made by ;;; internal let's or other binding forms. It is used to check for ;;; the error of having iterate try to bind one of these variables at ;;; top-level. E.g. ;;; (iterate (for i from 1 to 10) ;;; (let ((a nil)) ;;; (collect i into a))) ;;; is an error. (defvar *internal-variables*) ;;; For functions (like make-binding) that don't want to or can't pass ;;; declarations normally. These are really decl-specs, not full ;;; declarations. (defvar *declarations*) ;;; This is how we get multiple accumulations into the same variable ;;; to come out right. See make-accum-var-binding. ;;; It's an alist of (accum-var kind ). ;;; The currently used kinds are: ;;; :collect for collect, nconc, append, etc. ;;; :increment for count, sum and multiply ;;; :max for maximize ;;; :min for minimize ;;; :if-exists for always/never/thereis and finding such-that ;;; Note that we do not check for type conflict in the re-use of these ;;; variables. (defvar *accum-var-alist*) ;;; Shared variables created by make-shared-binding. ;;; It's an alist of (name gensym-var ). ;;; Tipical use is FIRST-ITERATION-P. (defvar *shared-bindings-alist*) ;;; Name of the block for this iterate form. Used in generating ;;; return statements. (defvar *block-name*) ;;; The index of standard clauses (a discrimination tree). This is a ;;; defvar so that reloading doesn't clobber existing defs (though it ;;; will clobber those clauses that are defined in this file, of ;;; course). (defvar *clause-info-index* (list :index)) (eval-when (:compile-toplevel) ;; This is so the variable has a value when we compile this file, since ;; the process of compilation results in actually setting things up. (if (not (boundp '*clause-info-index*)) (setq *clause-info-index* (list :index)))) ;;; An alist of lisp special forms and the functions for handling them. ;;; nil as function means leave form as-is. (defparameter *special-form-alist* '(;; First the special operators that every code walker must recognize (block . walk-cddr) (catch . walk-cdr) (declare . walk-declare) (eval-when . walk-cddr) (flet . walk-flet) (function . walk-function) (go . nil) (if . walk-cdr) ; also walk test form (labels . walk-flet) (let . walk-let) (let* . walk-let) (load-time-value . nil) (locally . walk-cdr-with-declarations) ;(macrolet . walk-macrolet) ; uncomment to raise error (multiple-value-call . walk-cdr) (multiple-value-prog1 . walk-cdr) (progn . walk-progn) (progv . walk-cdr) (quote . nil) (return-from . walk-cddr) (setq . walk-setq) (symbol-macrolet . walk-cddr-with-declarations) (tagbody . walk-tagbody) (the . walk-cddr) (throw . walk-cdr) (unwind-protect . walk-cdr) ;; Next some special cases: ;; m-v-b is a macro, not a special form, but we want to recognize bindings. ;; Furthermore, Lispworks macroexpands m-v-b into some unknown m-v-BIND-call special form. (multiple-value-bind . walk-multiple-value-bind) ;; Allegro treats cond as a special form, it does not macroexpand. #+allegro (cond . walk-cond) ;; Prior to 2005, CLISP expanded handler-bind into some ;; sys::%handler-bind syntax not declared as a special operator. #+clisp (handler-bind . walk-cddr) ; does not recognize clauses in handlers ;; A suitable generalization would be a pattern language that describes ;; which car/cdr are forms to be walked, declarations or structure. ;; Walk with-*-iterator ourselves in order to avoid macrolet warnings. ;; Note that walk-cddr-with-declarations won't walk the ;; package/hash-table descriptor argument, but it's good enough for now. (with-package-iterator . walk-cddr-with-declarations) (with-hash-table-iterator . walk-cddr-with-declarations) ;; Finally some cases where code compiled from the macroexpansion ;; may not be as good as code compiled from the original form: ;; -- and iterate's own expansion becomes more readable (and . walk-cdr) (ignore-errors . walk-cdr) ; expands to handler-bind in CLISP (multiple-value-list . walk-cdr) (multiple-value-setq . walk-cddr) (nth-value . walk-cdr) (or . walk-cdr) (prog1 . walk-cdr) (prog2 . walk-cdr) (psetq . walk-setq))) ;;; For clauses that are "special" in the sense that they don't conform to the ;;; keyword-argument syntax of Iterate clauses. (defvar *special-clause-alist* nil) ;;; These two are for conserving temporaries. *temps* is a list ;;; of temporaries that have already been created and given bindings. ;;; *temps-in-use* is a list of temporaries that are currently being used. ;;; See with-temporary, with-temporaries. ;;; This seems to stem from a time where it was more efficient to use ;;; (prog (temp) ;;; ... (setq temp #) ; somewhere deep inside the body ;;; (foo temp) ;;; (bar temp) ;;; ...) ;;; than using a local let deep inside that body, as in ;;; (tagbody ... (let ((temp #)) (foo temp) (bar temp)) ...) ;;; which may be be easier for compiler data flow and lifetime analysis. (defvar *temps*) (defvar *temps-in-use*) ;;; This is the environment, for macroexpand. (defvar *env*) ;;; This is a list of information about drivers, for use by the NEXT ;;; mechanism. (defvar *driver-info-alist*) ;;; This is used by the PREVIOUS mechanism. (defvar *previous-vars-alist*) ;;; Loop labels (defvar *loop-top*) (defvar *loop-step*) (defvar *loop-end*) ;;; Whether a label was used, to avoid generating them. This is so we don't ;;; get a warning from compilers that check for unused tags. (defvar *loop-step-used?*) (defvar *loop-end-used?*) ;;; Things that we should wrap the loop's body in (defvar *loop-body-wrappers*) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (eval-when (:compile-toplevel :load-toplevel :execute) ;;; Clause-info structures, which are put in the clause index. (defstruct clause-info function keywords req-keywords doc-string generator?) ;;; Driver-info structures, for information about driver variables--used by ;;; NEXT. (defstruct driver-info next-code generator? (used nil)) ;;; Previous-info structures, used by the PREVIOUS mechanism. (defstruct previous-info var save-info-list code (class :step)) (defstruct save-info save-var save-vars iv-ref) ) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Macros. (eval-when (:compile-toplevel :load-toplevel :execute) ;; Allegro needs this #+nil ;; unused (defmacro assertion (test) `(if (not ,test) (bug "Assertion ~a failed" ',test))) (defmacro augment (var stuff) `(setf ,var (nconc ,var ,stuff))) (defmacro prepend (stuff var) `(setf ,var (nconc ,stuff ,var))) ) ;end eval-when (eval-when (:compile-toplevel :load-toplevel :execute) (defun list-of-forms? (x) (and (consp x) (consp (car x)) (not (eq (caar x) 'lambda)))) ) ;end eval-when ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; SharpL. ;;; ;;; the #L reader macro is an abbreviation for lambdas with numbered ;;; arguments, with the last argument being the greatest numbered ;;; argument that is used in the body. Arguments which are not used ;;; in the body are (declare ignore)d. ;;; ;;; e.g. #L(list !2 !3 !5) is equivalent to: ;;; (lambda (!1 !2 !3 !4 !5) (declare (ignore !1 !4)) (list !2 !3 !5)) (eval-when (:compile-toplevel :execute) (defun sharpL-reader (stream subchar n-args) (declare (ignore subchar)) ;; Depending how an implementation chooses to expand `(,!1 (get-free-temp)) ;; at read-time, it might be a macro that must be expanded before groveling ;; the resultant sexpr. Here it gets expanded in the null environment for ;; lack of anything better. If the macro is sensitive to its lexical ;; environment, it suggests perhaps an inappropriate use of #L. ;; However, to support unforseen cases, we will use the original form as ;; read for the resulting lambda's body. Moreover, rather than stuff new ;; atoms into the body which is impossible if the representation is opaque, ;; redirect "!" vars onto gensyms using SYMBOL-MACROLET. (let* ((form (read stream t nil t)) (refd-!vars (sort (bang-vars (macroexpand form)) #'< :key #'bang-var-num)) (bang-var-nums (mapcar #'bang-var-num refd-!vars)) (max-bv-num (if refd-!vars (car (last bang-var-nums)) 0))) (cond ((null n-args) (setq n-args max-bv-num)) ((< n-args max-bv-num) (error "#L: digit-string ~d specifies too few arguments" n-args))) (let* ((all-!vars (loop for i from 1 to n-args collect (make-bang-var i))) (formals (mapcar (lambda (x) (declare (ignore x)) (gensym)) all-!vars))) `#'(lambda ,formals ,@(let ((ignore (mapcan (lambda (!var tempvar) (unless (member !var refd-!vars) (list tempvar))) all-!vars formals))) (if ignore `((declare (ignore ,@ignore))))) (symbol-macrolet ,(mapcan (lambda (!var tempvar) (when (member !var refd-!vars) (list (list !var tempvar)))) all-!vars formals) ,@(if (list-of-forms? form) form (list form))))))) (defun make-bang-var (n) (intern (format nil "!~d" n))) (defun bang-vars (form) (delete-duplicates (bang-vars-1 form '()) :test #'eq)) (defun bang-vars-1 (form vars) (cond ((consp form) (bang-vars-1 (cdr form) (bang-vars-1 (car form) vars))) ((and (symbolp form) (bang-var? form)) (cons form vars)) (t vars))) (defun bang-var? (sym) (char= (char (symbol-name sym) 0) #\!)) (defun bang-var-num (sym) (let ((num (read-from-string (subseq (symbol-name sym) 1)))) (if (not (and (integerp num) (> num 0))) (error "#L: ~a is not a valid variable specifier" sym) num))) (defun enable-sharpL-reader () (set-dispatch-macro-character #\# #\L #'sharpL-reader)) ;; According to CLHS, *readtable* must be rebound when compiling ;; so we are free to reassign it to a copy and modify that copy. (setf *readtable* (copy-readtable *readtable*)) (enable-sharpL-reader) ) ; end eval-when #| ;; Optionally set up Slime so that C-c C-c works with #L #+#.(cl:when (cl:find-package "SWANK") '(:and)) (unless (assoc "ITERATE" swank:*readtable-alist* :test #'string=) (bind ((*readtable* (copy-readtable *readtable*))) (enable-sharpL-reader) (push (cons "ITERATE" *readtable*) swank:*readtable-alist*))) ;|# ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; The ITERATE macro. (defmacro iterate (&body body) "Jonathan Amsterdam's powerful iteration facility" `(iter .,body)) (defmacro iter (&body body &environment env) "Jonathan Amsterdam's powerful and extensible iteration facility, providing multiple accumulation, generators, memory of previous iterations, over 50 clauses to start with and a Lisp-like syntax. Evaluate (iterate:display-iterate-clauses) for an overview of clauses" (let* ((*env* env) (*result-var* (genvar 'result)) (*type-alist* nil) (*declare-variables* *always-declare-variables*) (*bindings* nil) (*internal-variables* nil) (*previous-vars-alist* nil) (*declarations* nil) (*loop-body-wrappers* nil) (*accum-var-alist* nil) (*shared-bindings-alist* nil) (*top-level?* t) (*binding-context?* nil) (*temps* nil) (*temps-in-use* nil) (*driver-info-alist* nil) (*block-name* (if (symbolp (car body)) (pop body) nil)) (*loop-top* (symbol-append 'loop-top- *block-name*)) (*loop-step* (symbol-append 'loop-step- *block-name*)) (*loop-end* (symbol-append 'loop-end- *block-name*)) (*loop-step-used?* nil) (*loop-end-used?* nil)) (process-top-level-decls body) (multiple-value-bind (body decls init-code steppers final-code final-prot) (walk-list body) (multiple-value-bind (init step) (insert-previous-code) (augment init-code init) (augment steppers step)) (prepend (default-driver-code) body) (let ((it-bod `(block ,*block-name* (tagbody (progn ,.init-code) ,*loop-top* (progn ,.body) ,.(if *loop-step-used?* (list *loop-step*)) (progn ,.steppers) (go ,*loop-top*) ,.(if *loop-end-used?* (list *loop-end*)) (progn ,.final-code)) ,(if (member *result-var* *bindings* :key #'car) *result-var* nil)))) (wrap-form *loop-body-wrappers* `(let* ,(nreverse *bindings*) ,.(if *declarations* `((declare .,*declarations*))) ,.decls ,(if final-prot `(unwind-protect ,it-bod .,final-prot) it-bod))))))) (defmacro defmacro-clause (clause-template &body body) "Create your own iterate clauses" (define-clause 'defmacro clause-template body nil)) (defmacro defmacro-driver (clause-template &body body) "Create iterators which may also be used as generators" (define-clause 'defmacro clause-template body t)) ;;;;;;;;;;;;;;;; (defun process-top-level-decls (clauses) ;; This sets *type-alist* to an alist of (var . type), and ;; sets *declare-variables* to t if such a declaration was seen. (dolist (clause clauses) (when (and (consp clause) (eq (car clause) 'declare)) (dolist (spec (cdr clause)) (cond ((eq (first spec) 'declare-variables) (setq *declare-variables* t)) ((or (eq (first spec) 'type) ; We don't do ftypes ;; FIXME recognize all shorthand type declarations ;; e.g. (declare ((unsigned-byte 8) x) etc. ;; -- but how to recognize type specifications? (member (first spec) standard-type-symbols :test #'eq)) (let ((type (first spec)) (vars (cdr spec))) (if (eq type 'type) (setq type (pop vars))) (dolist (var vars) (push (cons var type) *type-alist*))))))))) (defun default-driver-code () nil) (defun wrap-form (wrappers form) (if (consp wrappers) (wrap-form (cdr wrappers) (nconc (copy-list (car wrappers)) (list form))) form)) (defun add-loop-body-wrapper (wrapper) (push wrapper *loop-body-wrappers* )) ;(defun default-driver-code () ; ;; Collect all non-generator code. ; ;; [Old version: Collect all code not explicitly invoked with NEXT.] ; (let ((code nil)) ; ;; Put list in same order as clauses ; (setq *driver-info-alist* (nreverse *driver-info-alist*)) ; (dolist (entry *driver-info-alist*) ; (let ((di (cdr entry))) ; (when (not (driver-info-generator? di)) ; (assert (not (driver-info-used di))) ; (augment code (copy-list (driver-info-next-code di)))) ; (if (and (driver-info-generator? di) ; (not (driver-info-used di))) ; (clause-warning "A generator was never used")))) ; code)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; The code walker. (defun walk (form) ;; Returns the usual five things; body is a list of forms. (cond ((atom form) ; symbol-macrolet must not expand into Iterate clauses (list form)) ((symbolp (car form)) (cond ;; The ordering of these checks is such that: ;; 1. We handle special operators that any Common Lisp code walker ;; must recognize. ;; 2. We handle some special cases like Allegro's cond ;; 3. Then we expand macros. ;; 4. Then only do we recognize Iterate clauses ;; -- which may thus be shadowed ;; ;; Note that implementations are permitted to let SPECIAL-OPERATOR-P ;; return T for any macros (e.g. CLISP for WHEN). Yet they must provide ;; a macroexpansion for these. ((special-form? (car form)) (walk-special-form form)) ((macro-function (car form) *env*) ;; Some compilers (e.g. Lucid on Sparcs) treat macros differently at ;; compile-time; macroexpand does not expand them. We assume that if ;; this happens, macroexpand's second value is nil. ;; What do we do with the form in that case? This is actually a ;; very serious problem: if we don't walk it, we miss things, but if we ;; do walk it, we don't know how to walk it. Right now, we don't walk ;; it and print out a warning. ;; --Jeff Siskind says try binding *macroexpand-hook* to #'funcall. (multiple-value-bind (ex-form expanded?) (macroexpand-1 form *env*) (cond (expanded? (walk ex-form)) (t (clause-warning "The form ~a is a macro that won't expand. ~ It will not be walked, which means that Iterate clauses inside it will ~ not be seen." form) (list form))))) ((special-operator-p (car form)) (clause-warning "Iterate does not know how to handle the special form ~s~%~ It will not be walked, which means that Iterate clauses inside it will ~ not be seen." form) (list form)) ((starts-clause? (symbol-synonym (car form))) (process-clause form)) (t ;; Lisp function call (return-code-modifying-body #'walk-arglist (cdr form) #L(list (cons (car form) !1)))))) ((lambda-expression? (car form)) ;; Function call with a lambda in the car (multiple-value-bind (bod decs init step final final-prot) (walk-fspec (car form)) (multiple-value-bind (abod adecs ainit astep afinal afinal-prot) (walk-arglist (cdr form)) (values (list (cons bod abod)) (nconc decs adecs) (nconc init ainit) (nconc step astep) (nconc final afinal) (nconc final-prot afinal-prot))))) #+clisp ; some macros expand into ((setf foo) value other-args...) ;; reported by Marco Baringer on 24 Jan 2005 ((typep form '(cons (cons (eql setf) *) *)) (apply #'walk-cdr form)) (t (clause-error "The form ~a is not a valid Lisp expression" form)))) (defun walk-list (forms) (walk-list-nconcing forms #'walk)) (defun walk-arglist (args) (let ((*top-level?* nil)) (walk-list-nconcing args #'walk #L(if (is-iterate-clause? !1) (list (prognify !2)) !2)))) (defun walk-fspec (form) ;; Works for lambdas and function specs in flet and labels. ;; FORM = (LAMBDA-or-name args . body) ;; We only walk at the body. The args are set up as internal variables. ;; Declarations are kept internal to the body. (let* ((args (second form)) (body (cddr form)) (*top-level?* nil) (*binding-context?* t) (*internal-variables* (add-internal-vars args))) (multiple-value-bind (bod decs init step final finalp) (walk-list body) (values `(,(first form) ,args ,.decs ,.bod) nil init step final finalp)))) (defun walk-list-nconcing (list walk-fn &optional (body-during #L!2)) (let (body-code decls init-code step-code final-code finalp-code) (dolist (form list) (declare (optimize (speed 0))) (multiple-value-bind (body decs init step final finalp) (funcall walk-fn form) (augment decls decs) (augment init-code init) (augment body-code (funcall body-during form body)) (augment step-code step) (augment final-code final) (augment finalp-code finalp))) (values body-code decls init-code step-code final-code finalp-code))) (defun return-code-modifying-body (f stuff mod-f) (declare (optimize (speed 0))) (multiple-value-bind (bod decs init step final finalp) (funcall f stuff) (values (funcall mod-f bod) decs init step final finalp))) (defun add-internal-var (var) ;; VAR can be a symbol or a list (symbol ...). (cons (if (consp var) (car var) var) *internal-variables*)) (defun add-internal-vars (vars) ;; VARS could be a lambda-list, a list of LET bindings, or just a list of ;; variables; all will work. (nconc (lambda-list-vars vars) *internal-variables*)) (defun lambda-list-vars (lambda-list) ;; Return the variables in the lambda list, omitting keywords, default ;; values. (mapcan #'(lambda (thing) (cond ((consp thing) (if (consp (car thing)) ; this is a full keyword spec (list (second (car thing))) (list (car thing)))) ((not (member thing lambda-list-keywords)) (list thing)))) lambda-list)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Special forms. (defun special-form? (symbol) ;; special-operator-p doesn't work in Lucid--it returns NIL for let, for ;; example. Plus, we want to catch Iterate special clauses. (assoc symbol *special-form-alist*)) (defun walk-special-form (form) (let ((*clause* form) (func (cdr (assoc (car form) *special-form-alist*)))) (if (null func) ; there's nothing to transform (list form) (apply func form)))) #+nil (defun walk-identity (&rest stuff) (list stuff)) (defun walk-cdr (first &rest stuff) ;; This is for anything where only the car isn't to be walked. (return-code-modifying-body #'walk-arglist stuff #L(list (cons first !1)))) (defun walk-cddr (first second &rest stuff) ;; This is for anything where the first two elements aren't to be walked. (return-code-modifying-body #'walk-arglist stuff #L(list (cons first (cons second !1))))) (defun walk-progn (progn &rest stuff) ;; The only difference between this and walk-cdr is that *top-level* is not ;; bound. This is so macros can return PROGNs of things. It's exactly like ;; the definition of "top-level" in lisp. ;; (Also, just for looks, this returns nil if the progn is empty.) (return-code-modifying-body #'walk-list stuff #L(if (null !1) nil (list (cons progn !1))))) (defun walk-setq (setq &rest things) ;; Walk every other thing. (let ((*top-level?* nil) (i 1) body-code decls init-code step-code final-code finalp-code) (dolist (thing things) (if (oddp i) (push thing body-code) (multiple-value-bind (body decs init step final finalp) (walk thing) (augment decls decs) (augment init-code init) (push (prognify body) body-code) (augment step-code step) (augment final-code final) (augment finalp-code finalp))) (incf i)) (values (list (cons setq (nreverse body-code))) decls init-code step-code final-code finalp-code))) (defun walk-function (function form) (if (lambda-expression? form) (return-code-modifying-body #'walk-fspec form #L(list (list function !1))) (list (list function form)))) (defun walk-declare (&rest declaration) ;; DECLARE is a declaration, and should be put in the declaration ;; section of the loop. Declarations are only allowed at top-level, ;; except that they are allowed within binding environments, in which case ;; they apply only to that binding environment. #+ symbolics (setq declaration (copy-list declaration)) (if (or *top-level?* *binding-context?*) (return-code :declarations (list declaration)) (clause-error "Declarations must occur at top-level, or inside a ~ binding context like let or multiple-value-bind."))) (defun walk-let (let bindings &rest body) ;; The bindings or body may contain iterate clauses. ;; Important: the decls go inside this let, not at top-level. ;; It is an error to use a variable in the let bindings as the ;; target of an accumulation (i.e. INTO), because iterate will try ;; to make a top-level binding for that variable. The same goes for ;; other variables that might be so bound. (let ((*top-level?* nil)) (multiple-value-bind (binds b-decls b-init b-step b-final b-finalp) (walk-let-bindings let bindings) (let ((*binding-context?* t) (*internal-variables* (add-internal-vars binds))) (multiple-value-bind (bod decls init step final finalp) (walk-list body) (return-code :declarations b-decls :initial (nconc b-init init) :body (list `(,let ,binds ,.decls ,.bod)) :step (nconc b-step step) :final (nconc b-final final) :final-protected (nconc b-finalp finalp))))))) (defun walk-let-bindings (let bindings) (if (eq let 'let) (walk-list-nconcing bindings #'walk-let-binding #L(list !2)) (walk-let*-bindings bindings))) (defun walk-let*-bindings (bindings) ;; We have to do this one binding at a time, to get the variable scoping ;; right. (if (null bindings) nil (multiple-value-bind (bod decls init step final finalp) (walk-let-binding (car bindings)) (let ((*internal-variables* (add-internal-var (car bindings)))) (multiple-value-bind (bod1 decls1 init1 step1 final1 finalp1) (walk-let*-bindings (cdr bindings)) (values (cons bod bod1) (nconc decls decls1) (nconc init init1) (nconc step step1) (nconc final final1) (nconc finalp finalp1))))))) (defun walk-let-binding (binding) (if (consp binding) (multiple-value-bind (bod decls init step final finalp) (walk (second binding)) (values (list (first binding) (prognify bod)) decls init step final finalp)) binding)) (defun walk-multiple-value-bind (mvb vars expr &rest body) ;; Important: decls go inside the mvb, not at top-level. See ;; walk-let for binding subtleties. (declare (ignore mvb)) (let ((*top-level?* nil)) (multiple-value-bind (ebod edecls einit estep efinal efinalp) (walk expr) (let ((*binding-context?* t) (*internal-variables* (add-internal-vars vars))) (multiple-value-bind (bod decls init step final finalp) (walk-list body) (return-code :declarations edecls :initial (nconc einit init) :body (list `(multiple-value-bind ,vars ,(prognify ebod) ,.decls ,.bod)) :step (nconc estep step) :final (nconc efinal final) :final-protected (nconc efinalp finalp))))))) (defun walk-flet (flet bindings &rest body) ;; For FLET or LABELS. We don't worry about the function bindings. (let ((*top-level?* nil)) (multiple-value-bind (binds b-decls b-init b-step b-final b-finalp) (walk-list-nconcing bindings #'walk-fspec #L(list !2)) (let ((*binding-context?* t)) (multiple-value-bind (bod decls init step final finalp) (walk-list body) (return-code :declarations b-decls :initial (nconc b-init init) :body (list `(,flet ,binds ,.decls ,.bod)) :step (nconc b-step step) :final (nconc b-final final) :final-protected (nconc b-finalp finalp))))))) (defun walk-cdr-with-declarations (first &rest stuff) ; aka walk-locally ;; Set *top-level?* false (via walk-arglist). ;; Note that when *top-level?* is false, walk won't yield declarations ;; because walk-declare errors out since all forms with ;; *declaration-context?* true keep them local (that is, in walk-let, ;; walk-flet and walk-multiple-value-bind b-decls/edecls are always NIL). ;; Ignoring code-movement issues, this approach should be fine. (let* ((forms (member 'declare stuff :key #L(if (consp !1) (car !1)) :test-not #'eq)) (decls (ldiff stuff forms))) (return-code-modifying-body #'walk-arglist forms #L(list (cons first (nconc decls !1)))))) (defun walk-cddr-with-declarations (first second &rest stuff) (let* ((forms (member 'declare stuff :key #L(if (consp !1) (car !1)) :test-not #'eq)) (decls (ldiff stuff forms))) (return-code-modifying-body #'walk-arglist forms #L(list (cons first (cons second (nconc decls !1))))))) (defun walk-tagbody (tagbody &rest statements) (flet ((walk-statements (statements) (walk-list-nconcing statements #L(if (atom !1) (list !1) (walk !1)) #'(lambda (form body) (cond ((atom form) body) ;; wrap statements which expand into an atom ((typep body '(cons atom null)) (list (cons 'progn body))) (t body)))))) (let ((*top-level?* nil)) (return-code-modifying-body #'walk-statements statements #L(list (cons tagbody !1)))))) (defun walk-macrolet (form-name &rest stuff) (declare (ignore stuff)) (error "~A is not permitted inside Iterate. Please ~ refactor the Iterate form (e.g. by using ~As that wrap ~ the ITERATE form)." form-name form-name)) #+allegro (defun walk-cond (cond &rest stuff) ;; Because the allegro compiler insists on treating COND as a special form, ;; and because some version macroexpands (cond #) into (cond #)! (declare (ignore cond)) (if (null stuff) nil (let* ((first-clause (first stuff)) (test (if (not (consp first-clause)) (error "cond clause ~a is not a list" first-clause) (car first-clause))) (thens (cdr first-clause)) (if-form (if (null thens) (let ((var (gensym))) `(let ((,var ,test)) (if ,var ,var (cond ,@(cdr stuff))))) `(if ,test (progn ,@thens) (cond ,@(cdr stuff)))))) (walk if-form)))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Processing Iterate clauses. (defvar *initial*) (defvar *decls*) (defvar *step*) (defvar *final*) (defvar *finalp*) (defun process-clause (clause) ;; This should observe the invariant that the forms it returns are ;; already copied from the original code, hence nconc-able. (let ((*clause* clause) (special-func (assoc (car clause) *special-clause-alist*))) (if special-func (apply-clause-function (car clause) (cdr clause)) (let* ((ppclause (preprocess-clause clause)) (info (get-clause-info ppclause))) (cond (info (arg-check ppclause info) (let ((args (cons (keywordize (first ppclause)) (cdr ppclause))) (func (clause-info-function info))) (if (macro-function func *env*) (walk (macroexpand-1 (cons func args) *env*)) (apply-clause-function func args)))) (t (clause-error "No iterate function for this clause; do ~ (~S) to see the existing clauses." 'display-iterate-clauses))))))) (defun apply-clause-function (func args) (let ((*initial* nil) (*decls* nil) (*step* nil) (*final* nil) (*finalp* nil)) (declare (optimize (speed 0))) (multiple-value-bind (body decls init step final finalp) (apply func args) (values body (nconc *decls* decls) (nconc *initial* init) (nconc *step* step) (nconc *final* final) (nconc *finalp* finalp))))) (defun preprocess-clause (clause) ;; First, check for errors. ;; Then, turn every other symbol except the first into a keyword, ;; and replace synonyms occurring as the first keyword. (do ((cl clause (cddr cl))) ((null cl)) (if (not (symbolp (car cl))) (clause-error "~a should be a symbol" (car cl))) (if (null (cdr cl)) (clause-error "Missing value for ~a keyword" (car cl)))) (let ((new-clause nil) (syn (symbol-synonym (first clause)))) (do ((cl (cddr clause) (cddr cl))) ((null cl)) (push (keywordize (first cl)) new-clause) (push (second cl) new-clause)) ;; Hack so that (generate ...) turns into (for ... :generate t) (if (eq syn 'generate) `(for ,(second clause) ,.(nreverse new-clause) :generate t) `(,syn ,(second clause) ,.(nreverse new-clause))))) (defun symbol-synonym (symbol) (or (get symbol 'synonym) symbol)) (eval-when (:compile-toplevel :load-toplevel :execute) (defun listify (x) (if (listp x) x (list x))) (defun keywordize (symbol) (intern (symbol-name symbol) :keyword)) );end eval-when (defun arg-check (clause info) ;; Make sure that each keyword in clause is in info. (let ((keywords (clause-info-keywords info))) (do ((cl clause (cddr cl))) ((null cl)) (if (null (cdr cl)) (clause-error "Missing a value for ~a" (car cl))) (if (not (member (car cl) keywords :test #'eq)) (if (eq (car cl) :generate) (if (not (clause-info-generator? info)) (clause-error "Clause cannot be used as a generator")) (clause-error "Unknown keyword ~a" (car cl))))))) (defun walk-expr (expr) ;; This isn't used by the code walker itself, but is useful for clauses that ;; need to walk parts of themselves. It always returns a single expression. ;; The other parts are collected using globals and returned by ;; process-clause. (multiple-value-bind (body decls init step final finalp) (walk expr) (augment *decls* decls) (augment *initial* init) (augment *step* step) (augment *final* final) (augment *finalp* finalp) (prognify body))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Displaying clauses. (defun display-iterate-clauses (&optional clause-spec) (fresh-line) (if (and clause-spec (symbolp clause-spec)) (setq clause-spec (list clause-spec))) (if (member '&optional clause-spec) (error "Iterate: clause-spec cannot mention optional keywords")) (if clause-spec (setq clause-spec (cons (car clause-spec) (mapcar #'keywordize (cdr clause-spec))))) (dolist (spec-entry *special-clause-alist*) (let ((spec-clause-kws (list (car spec-entry)))) (if (clause-matches? clause-spec spec-clause-kws) (display-clause spec-clause-kws (cdr spec-entry))))) (disp-std-clauses clause-spec *clause-info-index*) t) (defun disp-std-clauses (clause-spec index) (if (index? index) (dolist (entry (cdr index)) (disp-std-clauses clause-spec (cdr entry))) (if (clause-matches? clause-spec (clause-info-keywords index)) (display-clause (clause-info-keywords index) (clause-info-doc-string index))))) (defun display-clause (kws doc-string) (display-kws kws) (if doc-string (format t "~25,4t ~a~%" doc-string) (terpri))) (defconst fill-col 77) (defun display-kws (kws) (do* ((col 1) (kw-list kws (cdr kw-list)) (kw (car kw-list) (car kw-list))) ((null kw-list)) (let ((len (length (symbol-name kw)))) (when (>= (+ col len) fill-col) (format t "~%~4t") (setq col 4)) (if (= col 1) ; the first one--print package name (format t "~s" kw) (format t "~a" kw)) (incf col len) (when (cdr kw-list) (cond ((>= (+ col 1) fill-col) (format t "~%~4t") (setq col 4)) (t (format t " ") (incf col))))))) (defun clause-matches? (clause-spec kws) (or (null clause-spec) (every #'eq clause-spec kws))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Indexing of clause functions. ;;; Each clause has one or more required keywords, which must ;;; appear in order, and zero or more optional keywords, which may be ;;; omitted and may appear in any order. ;;; The first word of a clause, though used as a keyword when the ;;; clause function is called, is kept in its original package for ;;; indexing purposes. This provides iterate's interface with the ;;; package system. ;;; Two clauses can be ambiguous when 1) they have the same list of required ;;; keywords, or 2) #1's required-list is a prefix of #2's and #1 has optional ;;; keywords which match the remaining keywords of #2's required-list. We ;;; check for these situations and signal an error. ;;; Indexing scheme: basically a discrimination tree. There is a tree ;;; of alists with root *clause-info-index*. (defun get-clause-info (clause &optional (index *clause-info-index*)) (let ((entry (cdr (index-lookup (car clause) index)))) (if (index? entry) (let ((result (get-clause-info (cddr clause) entry))) ;; It could be that the required part of the clause ends here. (or result (get-clause-info nil entry))) entry))) (defun is-iterate-clause? (form) (and (consp form) (symbolp (car form)) (starts-clause? (car form)))) (defun starts-clause? (symbol) ;; A symbol starts a clause if it appears in the top-level index, or if it ;; is in the special-clause alist, or if it is GENERATE. ;; This is used to distinguish the case where there's a lisp form ;; (in which case the symbol doesn't start a clause), versus the ;; situation where an erroneous clause is provided. (or (assoc symbol *special-clause-alist*) (index-lookup symbol *clause-info-index*) (eq symbol 'generate))) ;;; The code generated by DEFINE-CLAUSE (below) is the only code that ;;; invokes this. (eval-when (:compile-toplevel :load-toplevel :execute) (defun install-clause-info (req-keywords keywords function doc-string generator?) (install-clause-info-1 req-keywords *clause-info-index* (make-clause-info :function function :keywords keywords :req-keywords req-keywords :doc-string doc-string :generator? generator?))) (defun install-clause-info-1 (keywords index info) ;; Here, KEYWORDS is a list of the required keywords. ;; The basic rule here is to build indices all the way out to the ;; end of the list of keywords. That way it will be necessary for ;; the user's clause to contain all of the required keywords. ;; If index contains no entry for the first keyword, build a full ;; set of indices and put it in index. ;; If there is an entry and it's an index, call recursively. ;; If there's an entry and it's not an index, then we have a case of ;; duplication or prefix. If duplication, we replace and warn; if ;; prefix, we check for ambiguity, and if so, error. (if (null keywords) (ambiguity-check-index info index)) (let ((entry (index-lookup (car keywords) index))) (cond ((null entry) (index-add (car keywords) (build-index (cdr keywords) info) index)) ((index? (cdr entry)) (install-clause-info-1 (cdr keywords) (cdr entry) info)) ((clause-info-p (cdr entry)) (cond ((null (cdr keywords)) ;; Duplication; warn if they are not completely identical. (unless (equal (clause-info-keywords (cdr entry)) (clause-info-keywords info)) (warn "replacing clause ~a~%with ~a" (clause-info-keywords (cdr entry)) (clause-info-keywords info))) (setf (cdr entry) info)) (t (ambiguity-check-clause (cdr entry) info 2) ;; Replace this entry with an index. (let ((index2 (build-index (cdr keywords) info))) (index-add nil (cdr entry) index2) (setf (cdr entry) index2))))) (t (bug "install-clause-info-1: index is broken"))))) (defun build-index (keywords info) (if (null keywords) info `(:index (,(car keywords) . ,(build-index (cdr keywords) info))))) (defun index? (x) (and (consp x) (eq (car x) :index))) (defun index-add (key thing index) (push (cons key thing) (cdr index))) (defun index-lookup (item index) (assoc item (cdr index) :test #'eq)) (defun ambiguity-check-index (ci1 index) ;; We're trying to add CI1, and we have to check it against all the things ;; in INDEX. (dolist (entry (cdr index)) (if (clause-info-p (cdr entry)) (ambiguity-check-clause ci1 (cdr entry) 1) (ambiguity-check-index ci1 (cdr entry))))) (defun ambiguity-check-clause (ci1 ci2 insert-n) ;; It is known that the required keywords of CI1 are a prefix of those ;; of CI2, and that we are trying to add INSERT-N (1 or 2). (if (ambiguous-clauses? ci1 ci2) (let ((kw1 (clause-info-keywords ci1)) (kw2 (clause-info-keywords ci2))) (if (= insert-n 2) (rotatef kw1 kw2)) (restart-case (error "Iterate: Inserting clause ~a would create ~ an ambiguity with clause ~a" kw1 kw2) (delete-conflict () :report "Delete the original clause" (remove-clause kw2)))))) (defun ambiguous-clauses? (ci1 ci2) ;; rk1 is a prefix of rk2 (let* ((rk1 (clause-info-req-keywords ci1)) (rk2 (clause-info-req-keywords ci2)) (rest-rk2 (nthcdr (length rk1) rk2)) (ok1 (cdr (member '&optional (clause-info-keywords ci1))))) (if (null rest-rk2) nil ; Don't consider identical clauses ambiguous--that will be ; handled elsewhere. (dolist (k2 rest-rk2 t) (if (not (member k2 ok1)) (return nil)))))) ) ;end eval-when (defun display-index (&optional (index *clause-info-index*) (indent 0)) ;; for debugging (if (not (index? index)) (format t "~vt~a~%" indent (clause-info-keywords index)) (dolist (entry (cdr index)) (format t "~vt~a:~%" indent (car entry)) (display-index (cdr entry) (+ indent 2))))) (defun remove-clause (clause-keywords) ;; CLAUSE-KEYWORDS is a list that (once the symbols have been ;; keywordized) should be equal to some clause in the index. (let* ((all-keywords (cons (first clause-keywords) (mapcar #L(if (eq !1 '&optional) !1 (keywordize !1)) (rest clause-keywords)))) (req-keywords (ldiff all-keywords (member '&optional all-keywords :test #'eq)))) (labels ((remove-clause-internal (keywords index) (let ((entry (and keywords (index-lookup (car keywords) index)))) (cond ((null entry) (error "Clause ~a not found" clause-keywords)) ((clause-info-p (cdr entry)) (when (equal all-keywords (clause-info-keywords (cdr entry))) ;; else warn that an &optional part is missing?? (rplacd index (delete entry (cdr index))) t)) (t ;; an index (prog1 (remove-clause-internal (cdr keywords) (cdr entry)) ;; if the index is empty, delete it too (if (null (cddr entry)) (rplacd index (delete entry (cdr index)))))))))) (remove-clause-internal req-keywords *clause-info-index*)))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Macros and useful functions for defining new iterate clauses. (defmacro defclause (clause-template &body body) (define-clause 'defun clause-template body nil)) (defmacro defclause-driver (clause-template &body body) (define-clause 'defun clause-template body t)) ; ;; This duplicates body, which is annoying but not serious. ; (let* ((gen-clause-template (cons 'generate (cdr clause-template))) ; (for-body `((let ((generator? nil)) ,@body))) ; (gen-body `((let ((generator? t)) ,@body)))) ; (define-clause 'defun clause-template for-body) ; (define-clause 'defun gen-clause-template gen-body))) (eval-when (:compile-toplevel :load-toplevel :execute) (defconst sequence-keyword-list '(:from from :upfrom upfrom :downfrom downfrom :to to :downto downto :above above :below below :by (by 1) :with-index with-index)) (defun define-clause (define-form clause-template body generator?) ;; CLAUSE-TEMPLATE is of the form ;; ( ... [&optional ...] [&sequence]) ;; The forms must be symbols (in any package); they are the ;; keywords for the clause. The forms are to be bound to the ;; values of those keywords when the clause is processed; such a ;; form can be either a symbol, a list (symbol initform), or a list ;; (symbol initform svar). These are processed exactly as if they ;; were keyword specifiers. To be precise, a pair of keyword and ;; value-form behaves exactly like the keyword specification ;; ((:keyword var) initform svar). ;; If the special symbol &sequence occurs, it must be the last ;; form. It is equivalent to specifying all the sequence optional ;; symbols (FROM, TO, etc.), with specs of the same name (i.e. the ;; variable bound to the FROM keyword is "from", etc.). There are ;; no defaults except that BY defaults to 1. ;; The BODY is just an ordinary lisp body; it will refer to the ;; value-forms in the clause template. It should use return-code to ;; return the appropriate arguments. (if (null clause-template) (error "Iterate: empty clause template with body ~a" body)) (flet ((make-keyword-spec (kw val) (if (symbolp val) `((,kw ,val)) `((,kw ,(car val)) ,@(cdr val))))) (let ((last (car (last clause-template)))) (if (and (symbolp last) (string= last '&sequence)) (setq clause-template (nconc (butlast clause-template) (if (member '&optional clause-template) sequence-keyword-list (cons '&optional sequence-keyword-list)))))) (multiple-value-bind (rkws rvals okws ovals) (split-clause-template clause-template) (let* ((req-keywords (mapcar #'keywordize rkws)) (req-kws-but-first (cons (car clause-template) (cdr req-keywords))) (opt-keywords (mapcar #'keywordize okws)) (keywords&opt (if opt-keywords (append req-kws-but-first '(&optional) opt-keywords) req-kws-but-first)) (rkw-specs (mapcar #'make-keyword-spec req-keywords rvals)) (okw-specs (mapcar #'make-keyword-spec opt-keywords ovals)) (func-name (make-function-name rkws)) (doc-string (if (stringp (car body)) (car body) nil)) (all-keywords (append req-keywords opt-keywords)) (arglist `(&key ,@rkw-specs ,@okw-specs))) (if (contains-duplicates? all-keywords) (error "While defining ~a: keyword list contains duplicates" clause-template)) (if generator? (augment arglist (list 'generate))) ;; Actually define a named function, instead of using an ;; anonymous lambda, to ensure that it gets compiled. A ;; compiler should compile a sharp-quoted lambda, but the ;; Symbolics one doesn't. Also, use the original first symbol ;; of the clause for indexing. This provides the following behavior ;; re the package system: the first symbol of the user's clause ;; must be eq to (hence in the same package as) the first symbol of ;; the defined clause; but the packages of the other symbols don't ;; matter. `(eval-when (:compile-toplevel :load-toplevel :execute) (,define-form ,func-name ,arglist .,body) (install-clause-info ',req-kws-but-first ',keywords&opt ',func-name ,doc-string ,generator?) ',clause-template))))) (defun make-function-name (req-syms) (let ((req-string "CLAUSE-")) (dolist (sym req-syms) (setq req-string (concatenate 'string req-string (symbol-name sym) "-"))) (gentemp req-string))) (defun split-clause-template (ct) ;; Splits template into required keywords, optional keywords and ;; values. (let* ((opt&-list (member '&optional ct)) (req-list (ldiff ct opt&-list)) (opt-list (cdr opt&-list))) (if (zerop (length req-list)) (error "DEFCLAUSE: template ~a has no required part" ct)) (if (oddp (length req-list)) (error "DEFCLAUSE: required part of template ~a is of odd length" ct)) (if (oddp (length opt-list)) (error "DEFCLAUSE: optional part of template ~a is of odd length" ct)) (multiple-value-bind (rkws rvals) (split-list-odd-even req-list) (multiple-value-bind (okws ovals) (split-list-odd-even opt-list) (values rkws rvals okws ovals))))) (defun split-list-odd-even (list) ;; Splits list into odd- and even-numbered elements, returns ;; the odds and evens as two values. (do ((lis list (cddr lis)) (odds nil) (evens nil)) ((null lis) (values (nreverse odds) (nreverse evens))) (push (car lis) odds) (push (cadr lis) evens))) (defun contains-duplicates? (list) (not (equal list (remove-duplicates list :test #'eq)))) ) ; end eval-when (defmacro defsynonym (syn word) "Makes SYN a synonym for the existing iterate keyword WORD." `(eval-when (:compile-toplevel :load-toplevel :execute) (setf (get ',syn 'synonym) ',word))) (defmacro defclause-sequence (element-name index-name &key access-fn size-fn element-type sequence-type element-doc-string index-doc-string) "A simple way to define a simple FOR ... &sequence clause" ;; Package subtlety: the FOR should be in the same package as the ;; element-name or index-name. (let* ((seq-for (if element-name (intern (symbol-name 'for) (symbol-package element-name)))) (seq-def (if element-name `(defclause-driver (,seq-for var ,element-name seq &sequence) ,element-doc-string (return-sequence-code :element-var var :sequence seq :access-fn ,access-fn :size-fn ,size-fn :element-type ,element-type :sequence-type ,sequence-type)))) (inx-for (if index-name (intern (symbol-name 'for) (symbol-package index-name)))) (inx-def (if index-name `(defclause-driver (,inx-for var ,index-name seq &sequence) ,index-doc-string (cond (with-index (clause-error "WITH-INDEX should not be specified for this clause")) (t (setq with-index var) (return-sequence-code :sequence seq :size-fn ,size-fn :sequence-type ,sequence-type))))))) `(progn ,seq-def ,inx-def))) (defun if-1st-time (then &optional else first-time-var) ;; Returns 1: a form which evaluates THEN the first time through the ;; loop, ELSE subsequent times; 2: the variable that keeps track of ;; the first time. (let* ((var (or first-time-var (make-var-and-binding 'first-time t :type 'boolean))) (code (if else `(cond (,var (setq ,var nil) ,@then) (t ,@else)) `(when ,var (setq ,var nil) ,@then)))) (values code var))) ;;; Deprecated. Dangerous when incorrectly nested (defmacro with-temporary (var &body body) (let ((old-var (gensym)) (vars (listify var))) `(let ((,old-var *temps-in-use*)) (unwind-protect (let ,(mapcar #L`(,!1 (get-free-temp)) vars) .,body) (setq *temps-in-use* ,old-var))))) #+nil ;; unused (defmacro with-temporaries (n vlist &body body) (let ((old-var (gensym))) `(let ((,old-var *temps-in-use*)) (unwind-protect (let ((,vlist (let ((ts nil)) (dotimes (i ,n) (push (get-free-temp) ts)) ts))) .,body) (setq *temps-in-use* ,old-var))))) (defun get-free-temp () (let ((temp (some #L(if (not (member !1 *temps-in-use*)) !1) *temps*))) (when (null temp) (setq temp (make-var-and-default-binding 'temp)) (push temp *temps*)) (push temp *temps-in-use*) temp)) ;;;;;;;;;;;;;;;; ;;; Typing. (defun var-type (var) (if (the-expression? var) (second var) (var-declaration var))) (defun var-declaration (var) (cdr (assoc var *type-alist* :test #'eq))) (defun expr-type-only (expr) ;; If expr is self-evaluating, return its type (using type-of); ;; if expr is of the form (the
), return ; ;; else, return nil. (cond ((self-evaluating? expr) ;; Attempt to work-around (type-of 0) -> useless types like ;; (integer 0 0) [cmucl/sbcl], (integer 0 16777215) or BIT [clisp] ;; -- possibly conterproductive for (array type dim1 .. dimn) types (let ((type (type-of expr))) (if (consp type) (first type) type))) ((the-expression? expr) (second expr)) (t nil))) (defun expression-type (form) (if (symbolp form) (var-type form) (expr-type-only form))) (defun quoted? (x) ;; Returns T iff x is of the form (quote ...) (and (consp x) (eq (car x) 'quote))) (defun function-quoted? (x) ;; Returns T iff x is of the form (function ...) [same as #'(...)] (and (consp x) (eq (car x) 'function))) (defun lambda-expression? (x) (and (consp x) (eq (car x) 'lambda))) (defun the-expression? (x) (and (consp x) (eq (first x) 'the))) (defun self-evaluating? (x) ;; Everything but symbols and lists are self-evaluating since CLtL2. ;; This differs from constantp in that it returns nil for quoted ;; things and defconstants. ;; (typep x '(and atom (or (not symbol) keyword (member t nil)))) (and (atom x) (or (null x) (not (symbolp x)) (eq x t) (keywordp x)))) (defun constant? (x) ;; This differs from constantp in that it doesn't acknowledge ;; defconstants to be constants; the problem with so acknowledging ;; them is that the run-time and compile-time environments may ;; differ. The things constant? returns T for are really and truly ;; constant everywhere. (or (self-evaluating? x) (quoted? x) (function-quoted? x))) (defun duplicable? (x) ;; Returns T if X can be copied in code. This returns T for symbols, on the ;; assumption that the copies are close enough to each other so that ;; updating the variable cannot occur. (or (numberp x) (symbolp x) (characterp x))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Variable specifiers. They're either a symbol, or a the-expression ;;; constaining a symbol. (defun var-spec? (x) (or (the-expression? x) (symbolp x))) (defun extract-var (var-spec) (if (the-expression? var-spec) (third var-spec) var-spec)) ;;; Possible extension: ;;; When more than one variable can occur, we allow a single ;;; the-expression to cover them all. Unfortunately, this makes ;;; things rather hairy--probably better to avoid it. ;(defun distribute-type-spec (x) ; (if (and (the-expression? x) (not (symbolp (third x)))) ; (let ((type (second x)) ; (vars (third x))) ; (mapcar #'(lambda (v) `(the ,type ,v)) vars)) ; x)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Binding and destructuring. (defun make-binding (var value &key type using-type-of) ;; This creates a binding of VAR to VALUE. TYPE means declare VAR ;; to be of that type if it isn't declared to be a type already. ;; (But do so only when declare-variables has been declared.) ;; USING-TYPE-OF means to use the type of that form, if any. ;; Specifying both keyword args is an error. ;; It is okay to pass nil for VAR; in this case, nothing will ;; happen and nil will be returned. This is done just to simplify ;; coding of clauses. (make-binding-internal var value t type using-type-of)) (defun make-default-binding (var &key type using-type-of) ;; This makes a random binding of VAR (i.e. you should not depend on ;; the binding's value). It will observe TYPE and USING-TYPE-OF in ;; choosing a value to bind to (see the comment for make-binding). ;; It is okay to pass nil for VAR; in this case, nothing will ;; happen and nil will be returned. This is done just to simplify ;; coding of clauses. (make-binding-internal var nil nil type using-type-of)) (defun make-var-and-binding (string value &key type using-type-of) (let ((var (genvar string))) (make-binding-internal var value t type using-type-of) var)) (defun make-var-and-default-binding (string &key type using-type-of) (let ((var (genvar string))) (make-binding-internal var nil nil type using-type-of) var)) (defun make-accum-var-binding (var value kind &key type using-type-of) (make-accum-var-binding-internal var value t kind type using-type-of)) (defun make-accum-var-default-binding (var kind &key type using-type-of) (make-accum-var-binding-internal var nil nil kind type using-type-of)) (defun make-accum-var-binding-internal (var value value-supplied? kind type using-type-of) ;; Possibly creates a binding for an accumulation variable, like ;; those generated by COLLECT, MAXIMIZE, COUNT, etc. ;; It checks *accum-var-alist* to see if the variable already exists. ;; If so, and it is of the right kind, it does not create a new ;; binding. If it is of the wrong kind, an error is signalled. If kind is ;; NIL, then we don't do this error check. However, we aways check to make ;; sure the initial value, if supplied, is correct. ;; In all cases, *internal-variables* is checked to make sure the ;; variable does not occur there. ;; The alist entry is returned. It can be used to store ;; additional info, like the end-pointer for collections. (let ((entry (assoc var *accum-var-alist* :test #'eq))) (cond ((null entry) (if value-supplied? (make-binding var value :type type :using-type-of using-type-of) (make-default-binding var :type type :using-type-of using-type-of)) (setq entry (list var kind)) (push entry *accum-var-alist*) entry) ((and kind (second entry) (not (eq (second entry) kind))) (clause-error "Attempt to do ~a accumulation into a variable ~ already being used for ~a accumulation." kind (second entry))) (t (if value-supplied? (let ((orig-value (second (assoc var *bindings*)))) (if (not (equal value orig-value)) (clause-error "Initial values ~a and ~a are not equal ~ for variable ~a" orig-value value var)))) (check-internal-variables var) entry)))) (defun make-shared-binding (var value &key type using-type-of) "Look up or create an alist entry keyed by var, store a gensym in the value and also add it as a binding. Return the entry." (let ((entry (assoc var *shared-bindings-alist* :test #'eq))) (unless entry (setq entry (list var (gensym (string var)))) (push entry *shared-bindings-alist*) (make-binding (second entry) value :type type :using-type-of using-type-of)) entry)) (defun make-binding-internal (var-spec value value-supplied? use-type using-type-of) ;; This returns T if it actually created a binding, else NIL. ;; Declaration and typing rules: first of all, no declaration is ;; generated unless *declare-variables* is T and var doesn't already ;; have a type declaration. If there is no type for var, we infer ;; it as best we can as follows: if use-type is supplied, we use ;; that type. If using-type-of is supplied, we try to determine a ;; type for that variable or expression (see expression-type) and ;; use that if we find it. (It is erroneous to supply both use-type ;; and using-type-of.) If neither is supplied, we DO NOT try to ;; infer the type of value--we just give up. Otherwise, someone who ;; innocently did (make-binding 'foo nil) would discover that the ;; resulting code, if declare-variables was used, would ;; have foo declared to be of type symbol (since, in Lucid at least, ;; (type-of nil) == symbol). Note that we do not check for a type ;; conflict between a supplied type and the existing type; the ;; existing type just wins. ;; ;; The var can actually be of the form (the var). (let ((var (extract-var var-spec))) (cond ((null var-spec) nil) ((not (symbolp var)) (clause-error "The variable ~a is not a symbol" var)) (t (let* ((existing-type (var-type var-spec)) (declared? (var-declaration var)) (type (or existing-type use-type (if using-type-of (expression-type using-type-of))))) (if (or declared? (and *declare-variables* type)) ;; We only have to be concerned about getting value to be ;; the right type if there will actually be a declaration ;; for var. This will be either when there is an existing ;; declaration, or when *declare-variables* is true and ;; there is some type. (setq value (make-initial-value value value-supplied? type))) (if (and (not declared?) *declare-variables* type) (push `(type ,type ,var) *declarations*)) (add-binding var value) t))))) (defun make-initial-value (value value-supplied? type) ;; This should really be done by trying to coerce, then trapping the error, ;; because the subtype checks aren't really right--nil, for instance, is a ;; subtype of anything, but you can't coerce anything to it. (Sure, we ;; check for nil explicitly, but there are other things like it.) Yet if we ;; omit the subtype tests currently, how will we know that we can convert ;; nil to a vector? (cond ((null type) value) (value-supplied? (if (self-evaluating? value) (coerce value type) `(the ,type ,value))) ((or (subtypep 'number type) (subtypep type 'number)) (coerce 0 type)) ((or (subtypep 'sequence type) (subtypep 'symbol type) (subtypep type 'sequence) (subtypep type 'symbol)) (coerce nil type)) ((subtypep type 'character) (coerce (code-char 0) type)) ; Neither #\Null nor #\Nul are valid characters. (t (clause-warning "Cannot supply an initial value for type ~s; using NIL." type) nil))) (defun add-binding (var value) (cond ((var-binding var) (clause-error "Duplicate variable: ~a" var)) (t (check-internal-variables var) (push (list var value) *bindings*)))) (defun check-internal-variables (var) (if (internal-variable? var) (clause-error "The variable ~a, which Iterate would like to bind, already has a ~ binding in a context internal to the iterate form. Give the variable ~ another name." var))) (defun internal-variable? (var) (member var *internal-variables* :test #'eq)) ; (some #L(if (symbolp !1) ; (eq var !1) ; (member var !1 :test #'eq)) ; *internal-variables*)) (defun var-binding (var) (car (member var *bindings* :test #'eq :key #'car))) ;;;;;;;;;;;;;;;;;; ;;; Destructuring. ;;; Where destructuring happens: ;;; WITH (bind) ;;; FOR...INIT...THEN (setq) ;;; FOR...FIRST...THEN (setq) ;;; FOR...= (setq) ;;; FOR...IN-FILE (setq) ;;; FOR...IN-STREAM (setq) ;;; FOR...IN-HASHTABLE (setq) ;;; FOR...IN-PACKAGE (setq) ;;; element-var of sequence & list drivers (setq) (defun make-destructuring-bindings (template value &key type using-type-of) (cond ((null template) (clause-error "Can't bind to NIL: ~a" value)) ((var-spec? template) (make-binding template value :type type :using-type-of using-type-of)) ((atom template) (clause-error "Invalid binding form: ~a" template)) ((eq (car template) 'values) (clause-error "Cannot perform multiple-value destructuring in ~ this context")) (t (let ((var (make-var-and-binding 'temp value))) (push var *temps*) ; so that others can benefit (do-destructuring-bindings template var))))) (defun do-destructuring-bindings (template value) (cond ((null template) nil) ((var-spec? template) (make-binding template value) nil) ((atom template) (clause-error "Invalid binding form: ~a" template)) ((eq (car template) 'values) (clause-error "Multiple-value destructuring cannot be nested")) (t (nconc (do-destructuring-bindings (car template) `(car ,value)) (do-destructuring-bindings (cdr template) `(cdr ,value)))))) (defun extract-vars (template) ;; Like extract-var, but will work with a destructuring template as well. ;; Returns a list of variables. (cond ((null template) nil) ((var-spec? template) (list (extract-var template))) ((not (consp template)) (clause-error "Invalid binding form: ~a" template)) ((eq (car template) 'values) (mapcan #'extract-vars (cdr template))) (t (nconc (extract-vars (car template)) (extract-vars (cdr template)))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Dsetq. (defmacro dsetq (template value) "Destructuring assignment; supports both (VALUES ...) for destructuring a multiple-value form and NIL as a variable name, meaning to ignore that position, e.g. (DSETQ (VALUES (a . b) nil c) form)" ;; This macro can be used outside an Iterate form. ;; The semantics are that if you say (DSETQ (A B) A), then b will get its ;; value from the original A. (do-dsetq template value nil)) (defun do-dsetq (template value &optional (bindings? t) type) (cond ((null template) (dsetq-error "Can't bind to nil")) ((var-spec? template) ; not only (symbolp template) (if bindings? (make-default-binding template :type type)) `(setq ,(extract-var template) ,value)) ((and (consp template) (eq (car template) 'values)) ;; Just do a simple check for the most common errors. There's no way we ;; can catch all problems. (if (or (atom value) (member (car value) '(car cdr cdar caar aref get))) (dsetq-error "Multiple values make no sense for this expression" ) (make-mv-dsetqs (cdr template) value bindings?))) (t (let ((temp (gensym "DSETQ"))) `(let ((,temp ,value)) ,.(if (and type *declare-variables*) `((declare (type ,type ,temp)))) ,.(make-dsetqs template temp bindings?) ,temp))))) (defun make-dsetqs (template value bindings?) (cond ((null template) nil) ((var-spec? template) (if bindings? (make-default-binding template)) `((setq ,(extract-var template) ,value))) ((atom template) (dsetq-error "Invalid binding form: ~a" template)) ((eq (car template) 'values) (dsetq-error "Multiple-value destructuring cannot be nested")) (t (nconc (make-dsetqs (car template) `(car ,value) bindings?) (make-dsetqs (cdr template) `(cdr ,value) bindings?))))) (defun make-mv-dsetqs (templates value bindings?) (let ((temps '()) (vars '()) (tplates '())) (declare (type list temps vars tplates)) (dolist (tp templates) (cond ((and tp (var-spec? tp)) ; either var or (the type var) (push nil tplates) (push nil temps) (push (extract-var tp) vars) (if bindings? (make-default-binding tp))) (t ; either NIL or destructuring template (let ((temp (gensym "VALUE"))) (push tp tplates) (push temp temps) (push temp vars))))) (setq temps (nreverse temps)) (setq vars (nreverse vars)) (setq tplates (nreverse tplates)) (let ((mv-setq `(multiple-value-setq ,vars ,value)) ;; Remove, don't delete. Bug ;; reported by Francois Ren'e Rideau on 2005-11-01 (temp-vars (remove nil temps))) (if (null temp-vars) mv-setq `(let ,temp-vars (declare (ignorable .,temp-vars)) ; in case of NIL template ,mv-setq ,.(mapcan #L(make-dsetqs !1 !2 bindings?) tplates temps) ,(car vars)))))) (defun dsetq-error (format-string &rest args) (if (in-iterate?) (apply #'clause-error format-string args) (apply #'error (concatenate 'string "DSETQ: " format-string) args))) (defun in-iterate? () (boundp '*result-var*)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Free variables; checking for local bindings. (defun local-binding-check (form) (when *internal-variables* ; else no need to extract free variables (let ((vars (remove-if-not #'internal-variable? (free-variables form)))) (if vars (clause-error "The variable~p ~{~a~^, ~} ~:[is~;are~] bound in a context internal to ~ the Iterate form.~%~ This part of the clause will be moved outside the body of the loop, so it ~ must not contain anything that depends on the body." (length vars) vars (rest vars)))))) (defun free-variables (form) ;; This will return a list of the (lexically) free variables in FORM. It ;; will never return anything that is not a free variable (except for not ;; processing MACROLET), but it may not get all of them. (delete-duplicates (free-vars form nil) :test #'eq)) (defun free-vars (form bound-vars) ;; To compute the variables that are free in a form, we have to walk it, ;; keeping track of what variables are bound. (cond ((constantp form) nil) ((symbolp form) (if (not (member form bound-vars :test #'eq)) (list form))) ((atom form) nil) ((symbolp (car form)) (cond ((or (special-operator-p (car form)) ;; Lucid doesn't think that these are special forms ;; and we need to handle declarations: (member (car form) '(declare multiple-value-bind flet labels let let*) :test #'eq)) (case (car form) ((catch if locally multiple-value-call multiple-value-prog1 progn progv setq tagbody throw unwind-protect) (free-vars-list (cdr form) bound-vars)) ((block eval-when return-from the) (free-vars-list (cddr form) bound-vars)) (multiple-value-bind (free-vars-list (cddr form) (append (cadr form) bound-vars))) (function (free-vars-fspec (second form) bound-vars)) ((flet labels macrolet) (nconc (mapcan #L(free-vars-fspec !1 bound-vars) (second form)) (free-vars-list (cddr form) bound-vars))) ((let symbol-macrolet) (let* ((bindings (second form)) (body (cddr form)) (vars (mapcar #L(if (consp !1) (car !1) !1) bindings))) (nconc (mapcan #L(if (consp !1) (free-vars (second !1) bound-vars) nil) bindings) (free-vars-list body (append vars bound-vars))))) (let* (let* ((bindings (second form)) (body (cddr form)) (free-vars nil)) (dolist (binding bindings) (if (consp binding) (augment free-vars (free-vars (second binding) bound-vars))) (push (if (consp binding) (car binding) binding) bound-vars)) (nconc free-vars (free-vars-list body bound-vars)))) (otherwise nil))) ((macro-function (car form) *env*) (free-vars (macroexpand-1 form *env*) bound-vars)) (t ; function call (free-vars-list (cdr form) bound-vars)))) ((and (consp (car form)) (eq (caar form) 'lambda)) (nconc (free-vars-fspec (car form) bound-vars) (free-vars-list (cdr form) bound-vars))) (t (error "The form ~a is not a valid Lisp expression" form)))) (defun free-vars-list (list bound-vars) (mapcan #L(free-vars !1 bound-vars) list)) (defun free-vars-fspec (fspec bound-vars) ;; FSPEC is either: a symbol, or ;; ( () . body), or ;; (SETF ) (if (or (symbolp fspec) (eq (car fspec) 'setf)) nil (free-vars-list (cddr fspec) (append (second fspec) bound-vars)))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Functions that return code. (defun return-code (&key declarations initial body step final final-protected) (values body declarations initial step final final-protected)) (defmacro return-driver-code (&key variable initial declarations body step final final-protected next) ;; This assumes there is a local var called 'generate' (let ((btemp (gensym)) (ntemp (gensym))) `(let ((,btemp ,body) (,ntemp ,next)) (add-driver-info ,variable ,ntemp generate) (if (not generate) (augment ,btemp ,ntemp)) (values ,btemp ,declarations ,initial ,step ,final ,final-protected)))) (defun add-driver-info (var-template next-code generator?) ;; VAR-TEMPLATE could be a single var-spec or a destructuring template. ;; Copy the code--the original could be nconc'ed. (let ((vars (extract-vars var-template)) (di (make-driver-info :next-code (copy-list next-code) :generator? generator?))) (register-previous-code vars next-code :next) (push (cons vars di) *driver-info-alist*))) (defmacro return-sequence-code (&key element-var sequence access-fn size-fn element-type sequence-type) ;; This assumes all the sequence keywords will be in the lexical ;; environment. `(return-seq-code :element-var ,element-var :sequence ,sequence :access-fn ,access-fn :size-fn ,size-fn :element-type ,element-type :sequence-type ,sequence-type :from from :upfrom upfrom :to to :downto downto :above above :below below :downfrom downfrom :by by :with-index with-index :generate generate)) (defun return-seq-code (&key element-var sequence access-fn size-fn element-type sequence-type from upfrom to downto above below downfrom with-index (by 1) generate) ;; element-var might involve destructuring; the others won't. If ;; access-fn is NIL, don't generate element-accessing code at all. (top-level-check) (check-sequence-keywords from upfrom downfrom to downto above below t) (let* ((index-var-spec (or with-index (genvar 'index))) (index-var (extract-var index-var-spec)) (seq-var (if (or access-fn (not (symbolp sequence))) (make-var-and-default-binding 'sequence :type sequence-type))) (seq-code (or seq-var sequence)) (step-var (if (not (constant? by)) (make-var-and-default-binding 'step :type 'fixnum))) (step (or step-var by)) (step-func (if (or downto downfrom above) '- '+)) (test-func (cond (to '>) ((or downto downfrom) '<) (below '>=) (above '<=) (t '>=))) (size-code (make-application size-fn seq-code)) (limit-value (cond ((or to below)) ((or downto above)) (downfrom 0) (t size-code))) (limit-var (if (not (numberp limit-value)) (make-var-and-default-binding 'limit :type 'fixnum))) (limit-code (or limit-var limit-value)) (other-func (if (eq step-func '-) '+ '-)) (initial-value (eval-const-expr (cond ((or from upfrom downfrom) `(,other-func ,(or from upfrom downfrom) ,step)) ((or downto above) (if (eql step 1) size-code `(+ ,size-code (1- ,step)))) (t `(- ,step))))) (access-code (if (null access-fn) nil (make-application access-fn seq-code index-var))) (step-code `(setq ,index-var (,step-func ,index-var ,step))) (setqs (if access-fn (do-dsetq element-var access-code t element-type))) (test `(if (,test-func ,index-var ,limit-code) (go ,*loop-end*)))) (make-default-binding index-var-spec :type 'fixnum) (setq *loop-end-used?* t) (return-driver-code :initial (nconc (if seq-var `((setq ,seq-var ,sequence))) (if step-var `((setq ,step-var ,by))) (if limit-var `((setq ,limit-var ,limit-value))) (if index-var `((setq ,index-var ,initial-value)))) :next (list step-code test setqs) ;; say (list nil ...) in case element-var = VALUES :variable (list nil element-var index-var)))) (defun check-sequence-keywords (from upfrom downfrom to downto above below known-limits? &aux count) ;; If the limits aren't known, the possibilities are: FROM; UPFROM; ;; DOWNFROM; TO; BELOW; or FROM and exactly one of TO, DOWNTO, ABOVE and ;; BELOW. ;; If the limits are known: you also have DOWNTO; ABOVE; and nothing. (if (or (and upfrom downfrom) (and (or upfrom downfrom) (or from to downto above below))) (clause-error "UPFROM or DOWNFROM must occur alone")) (if (> (setq count (count-if #'identity (list to downto above below))) 1) (clause-error "Use at most one of TO, DOWNTO, ABOVE and BELOW")) (if (not known-limits?) ;; eliminate the cases DOWNTO, ABOVE, and nothing. (if (and (not (or from upfrom downfrom)) (or downto above (zerop count))) (clause-error "Illegal set of sequence keywords")))) (defun eval-const-expr (expr) ;; This is very simple: if expr is a list, and all the args are constants, ;; it will evaluate it; else it will just return it. (if (and (consp expr) (every #'constantp (cdr expr))) (eval expr) expr)) (defun make-funcall (fn &rest args) ;; This should be used when FN is something the user has written in a ;; clause. #+symbolics (setq args (copy-list args)) (cond ((or (quoted? fn) (function-quoted? fn)) `(,(second fn) ,@args)) ((lambda-expression? fn) `(,fn ,@args)) ;;((functionp fn) `(funcall ,fn ,@args)) ; same treatment as default case (t `(funcall ,fn ,@args)))) (defun make-application (fn &rest args) ;; Use this when FN is given in the implementation code. #+ symbolics (setq args (copy-list args)) (cond ((or (symbolp fn) (lambda-expression? fn)) `(,fn ,@args)) ((function-quoted? fn) `(,(second fn) ,@args)) ((and (consp fn) (eq (car fn) 'subst)) (apply-subst-expr fn args)) ((functionp fn) `(funcall ,fn ,@args)) ;; Siskind's patch for compiled fns (t (clause-error "~a should denote a function, but it doesn't" fn)))) (defun apply-subst-expr (subst-expr args) (let ((params (second subst-expr)) (body (cddr subst-expr))) (prognify (sublis (pairlis params args) body)))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Clauses ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Special clauses. These must return freshly consed lists that are ;;; nconcable. (defmacro def-special-clause (name arglist &body body) `(progn (defun ,name ,arglist .,body) (install-special-clause-function ',name ,(if (stringp (car body)) (car body))))) (defun install-special-clause-function (symbol &optional doc-string) ;; Put it at the end, if not already present. (let ((entry (assoc symbol *special-clause-alist*))) (if (null entry) (augment *special-clause-alist* (list (cons symbol doc-string))) (setf (cdr entry) doc-string)) symbol)) ;;; (INITIALLY &rest) (def-special-clause initially (&rest forms) "Lisp forms to execute before loop starts" (mapc #'local-binding-check forms) (return-code :initial (copy-list forms))) ;;; (AFTER-EACH &rest) (def-special-clause after-each (&rest forms) "Lisp forms to execute after each iteration" (mapc #'local-binding-check forms) (return-code :step (walk-list forms))) ;;; (ELSE &rest) (def-special-clause else (&rest forms) "Lisp forms to execute if the loop is never entered" (mapc #'local-binding-check forms) (let ((flag (make-var-and-binding 'else t :type 'boolean))) (return-code :final `((when ,flag .,(walk-list forms))) :body (list `(setq ,flag nil))))) ;;; (FINALLY &rest) (def-special-clause finally (&rest forms) "Lisp forms to execute after loop ends" (mapc #'local-binding-check forms) (return-code :final (copy-list forms))) ;;; (FINALLY-PROTECTED &rest) (def-special-clause finally-protected (&rest forms) "Lisp forms in an UNWIND-PROTECT after loop ends" (mapc #'local-binding-check forms) (return-code :final-protected (copy-list forms))) ;;; (IF-FIRST-TIME then &optional else) (def-special-clause if-first-time (then &optional else) "Evaluate branch depending on whether this clause is met for the first time" (return-code :body (list (if-1st-time (list (walk-expr then)) (if else (list (walk-expr else))))))) ;;; (FIRST-TIME-P) (def-special-clause FIRST-TIME-P () "True when evaluated for the first time" (return-code :body (list (if-1st-time '(t))))) ;;; (FIRST-ITERATION-P) (def-special-clause FIRST-ITERATION-P () "True within first iteration through the body" ;; Like (with ,var = t) (after-each (setq ,var nil)) ;; except all these clauses shares a single binding. (let* ((entry (make-shared-binding 'first-iteration t :type 'boolean)) (step-body nil) (first-usage (not (cddr entry))) (var (second entry))) (when first-usage (setf step-body (list `(setf ,var nil))) (setf (cddr entry) (list t))) (return-code :body `(,var) :step step-body))) ;;; (IN &body) (def-special-clause in (block-name &rest forms) "Process forms in a named Iterate block" ;; VALUE: depends on forms (if (eq block-name *block-name*) (walk-list forms) `((in ,block-name ,.(copy-list forms))))) ;;; (NEXT var) (def-special-clause next (var &optional (n 1)) "Explicitly step a driver variable" ;; VALUE: var, after stepping. ;; Enclose the returned code in a PROGN so that the variable reference isn't ;; confusable with a tag (since the code might appear within a tagbody). ;; The PROGN is also necessary so that spliced-in save code will not result ;; in extra forms, for cases when the NEXT appears as an argument. (let ((entry (assoc var *driver-info-alist* :test #'member))) (if (or (null entry) (not (driver-info-generator? (cdr entry)))) (clause-error "Variable is not associated with a generator") (let* ((vars (car entry)) (di (cdr entry)) (code (copy-list (driver-info-next-code di)))) (if (internal-variable? var) (clause-error "The variable ~a is bound in a context internal ~ to the Iterate form. ~ It cannot be stepped at this point in the code." var)) (if (some #'internal-variable? vars) (clause-error "Some of the variables ~a, which will be stepped ~ when this clause is executed, are bound in a context internal to the Iterate ~ form, so ~a cannot be stepped at this point in the code." vars var)) (setf (driver-info-used di) t) (register-previous-code vars code :next) (return-code :body (make-next-code var code n)))))) (defun make-next-code (var code n) ;; Construct the body carefully (avoid backquote), ensuring that CODE, ;; and not a copy, appears in it. (if (eql n 1) (let ((var-code (if (eq var (var-value-returned code)) () (list var)))) ;; This var-value-returned optimization benefits ;; FOR IN-VECTOR/SEQUENCE/STRING. ;; Too small a benefit in light of current compilers? (list (cons 'progn (nconc code var-code)))) (let ((i (genvar 'next))) (list (list* 'dotimes (list i n var) `(declare (ignorable ,i)) code))))) (defun var-value-returned (forms) ;; If the result of evaluating FORMS would be the value of some variable, ;; then that variable is returned; else NIL. ;; We only check for progns, setqs and raw variables. (let ((form (car (last forms)))) (cond ((symbolp form) form) ((atom form) nil) ((eq (car form) 'setq) (second (last form 3))) ; support degenerated (setq) ((eq (car form) 'progn) (var-value-returned (cdr form))) (t nil)))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Iteration-driving clauses. (defsynonym as for) (defsynonym generating generate) (defclause (repeat n) "Repeat the loop some number of times" (top-level-check) (let* ((c-type (or (expression-type n) 'fixnum)) (count-var (make-var-and-default-binding 'count :type c-type))) (setq *loop-end-used?* t) (return-code :initial `((setq ,count-var ,n)) :body `((if (<= ,count-var 0) (go ,*loop-end*))) :step `((setq ,count-var (1- ,count-var)))))) ;;; (FOR &sequence) (defclause-driver (for var-spec &sequence) "Numbers" (top-level-check) (if with-index (clause-error "WITH-INDEX should not be specified for this clause")) (check-sequence-keywords from upfrom downfrom to downto above below nil) (make-default-binding var-spec :type 'number) (let* ((var (extract-var var-spec)) (initial (or from upfrom downfrom 0)) (limit (or to downto above below)) (step-func (if (or downfrom downto above) '- '+)) (test-func (cond (to '>) (downto '<) (below '>=) (above '<=))) (limit-var (if (and limit (not (constant? limit))) (make-var-and-default-binding 'limit :using-type-of (if (expression-type limit) limit var)))) (step-var (if (not (constantp by)) (make-var-and-default-binding 'step :using-type-of by))) (step-thing (or step-var by)) (limit-code (or limit-var limit)) (init-val (eval-const-expr (list (if (eq step-func '+) '- '+) initial step-thing))) (test (if limit (progn (setq *loop-end-used?* t) `((if (,test-func ,var ,limit-code) (go ,*loop-end*)))) nil)) (next `((setq ,var (,step-func ,var ,step-thing)) .,test))) (return-driver-code :initial `(,.(if limit-var `((setq ,limit-var ,limit))) ,.(if step-var `((setq ,step-var ,by))) (setq ,var ,init-val)) :next next :variable var))) ;;;;;;;;;;;;;;;;;;;;;;; ;;; Sequence iteration ;;; (FOR ON &optional BY) (defclause-driver (for var on list &optional by (step ''cdr)) "Sublists of a list" (top-level-check) (let* ((list-var (make-var-and-default-binding 'list)) ;; Handle dotted lists, so type declaration is not possible (setqs (do-dsetq var list-var t 'list)) (test `(if (atom ,list-var) (go ,*loop-end*)))) (setq *loop-end-used?* t) (return-driver-code :initial `((setq ,list-var ,list)) :next (list test setqs (generate-function-step-code list-var step)) :variable var))) ;;; (FOR IN &optional BY) (defclause-driver (for var in list &optional by (step ''cdr)) "Elements of a list" (top-level-check) (let* ((on-var (make-var-and-default-binding 'list :type 'list)) (setqs (do-dsetq var `(car ,on-var))) (test `(if (endp ,on-var) (go ,*loop-end*)))) (setq *loop-end-used?* t) (return-driver-code :initial `((setq ,on-var ,list)) :next (list test setqs (generate-function-step-code on-var step)) :variable var))) (defun generate-function-step-code (var step) ;; If the stepping function is quoted or sharp-quoted, we don't need to make ;; a variable for it. The two constant cases are distinguished solely for ;; compilers too stupid to compile (funcall 'cdr foo) the same as (cdr foo). ;; (Really, for cosmetics--there probably are no such stupid compilers.) (cond ((quoted? step) `(setq ,var (,(second step) ,var))) ((function-quoted? step) `(setq ,var (funcall ,step ,var))) (t (let ((step-var (make-var-and-binding 'step step :type 'function))) `(setq ,var (funcall ,step-var ,var)))))) ;;; (FOR IN-VECTOR &sequence) (defclause-sequence in-vector index-of-vector ;; This observes fill-pointers. :access-fn 'aref :size-fn 'length :sequence-type 'vector :element-doc-string "Elements of a vector" :index-doc-string "Indices of a vector") ;;; (FOR IN-SEQUENCE) (defclause-sequence in-sequence index-of-sequence ;; This observes fill pointers, and works for any sequence. :access-fn 'elt :size-fn 'length :sequence-type 'sequence :element-doc-string "Elements of a sequence (vector or list)" :index-doc-string "Indices of a sequence (vector or list)") ;;; (FOR IN-STRING) (defclause-sequence in-string index-of-string :access-fn 'char :size-fn 'length :sequence-type 'string :element-type 'character :element-doc-string "Characters in a string" :index-doc-string "Indices of a string") ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Hash-table, Packages and Streams ;;; (FOR IN-HASHTABLE) (defclause-driver (for key-val-vars in-hashtable table) "Elements and keys of a hashtable" (top-level-check) (unless (consp key-val-vars) (clause-error "~a should be a list of up to two variables: the first ~ for the keys, the second for the values." key-val-vars)) (let* ((iterator (gensym "HASH-TABLE-ITERATOR-")) (more? (gensym)) (var-spec `(values ,more? .,key-val-vars)) (setqs (do-dsetq var-spec `(,iterator))) (test `(if (not ,more?) (go ,*loop-end*)))) ;; FIXME 2004-11-11 destructure only after termination test (setq *loop-end-used?* t) (add-loop-body-wrapper `(with-hash-table-iterator (,iterator ,table))) (return-driver-code :next (list setqs test) :variable var-spec))) ;;; (FOR IN-PACKAGES &optional HAVING-ACCESS) (defclause-driver (for sym-access-pkg-vars in-packages pkgs &optional having-access (sym-types '(:external :internal :inherited))) "Symbols and their access-types in packages" ;;defclause-driver has the benefit over defmacro-driver of less code walking (top-level-check) (unless (and (listp sym-access-pkg-vars) ; empty list is allowed (count) (every #'symbolp sym-access-pkg-vars)) (clause-error "~a should be a list of up to three variables: the symbol, ~ the access type and the home package." sym-access-pkg-vars)) (unless (consp sym-types) (clause-error "~s should be a list of symbols indicating the symbols' ~ access types." sym-types)) (let* ((iterator (gensym "PACKAGE-ITERATOR-")) (more? (gensym)) (var-spec `(values ,more? .,sym-access-pkg-vars)) (setqs (do-dsetq var-spec `(,iterator))) (test `(if (not ,more?) (go ,*loop-end*)))) (setq *loop-end-used?* t) (add-loop-body-wrapper `(with-package-iterator (,iterator ,pkgs .,sym-types))) (return-driver-code :next (list setqs test) :variable var-spec))) ;;; (FOR IN-PACKAGE &optional EXTERNAL-ONLY) (defmacro-driver (for var in-package pkg &optional external-only (ext nil)) "Symbols accessible in a package" `(,(if generate 'generate 'for) (,var) in-packages ,pkg having-access ,(if ext '(:external) '(:external :internal :inherited)))) ;;; (FOR IN-FILE &optional USING) (defclause-driver (for var in-file filename &optional using (reader '#'read)) "Forms in a file" (top-level-check) (return-stream-driver-code var filename reader :file generate)) ;;; (FOR IN-STREAM &optional USING) (defclause-driver (for var in-stream stream &optional using (reader '#'read)) "Forms in a stream (which will be closed at the end)" (top-level-check) (return-stream-driver-code var stream reader :stream generate)) (defun return-stream-driver-code (var thing reader stream-or-file generate) (let* ((evar (extract-var var)) (type (or (var-type evar) t)) (stream-var (make-var-and-binding 'stream nil)) (set-var (if (and (var-spec? var) (subtypep 'symbol type)) ;; We can use the given variable directly if no ;; destructuring is required, and if the type of the ;; variable can hold a symbol (since we use a gensym for ;; the eof-marker). evar (genvar 'element))) (setq (cond ((eq set-var evar) (make-default-binding var) ()) (t (make-default-binding set-var) (list (do-dsetq var set-var))))) (eof (gensym "EOF"))) (setq *loop-end-used?* t) (return-driver-code :initial (if (eq stream-or-file :file) `((setq ,stream-var (open ,thing :direction :input))) `((setq ,stream-var ,thing))) :next `((if (eq (setq ,set-var ,(make-funcall reader stream-var nil `',eof)) ',eof) (go ,*loop-end*)) .,setq) :final-protected `((if (streamp ,stream-var) (close ,stream-var))) :variable var))) ;;; (FOR NEXT) (defclause-driver (for var next next) "General driver; VAR is set to value of NEXT" (return-driver-code :variable var :next (list (do-dsetq var (walk-expr next))))) ;;; (FOR DO-NEXT) (defclause-driver (for var do-next next) "General driver; VAR must be set in DO-NEXT" (do-dsetq var '(list)) ; for effect only, to make var known ;; We can't use (make-destructuring-bindings var) here because ;; we support the (values ...) template, ;; to maintain the documented equivalence with FOR ... NEXT. (return-driver-code :variable var :next (mapcar #'walk-expr (if (list-of-forms? next) (copy-list next) (list next))))) ; No NEXT: ; LOOP-TOP: SET ; (if test (go LOOP-END)) ; STEP ; ; NEXT: ; ... ; LOOP-TOP ... ; [next] SET; (if test (go LOOP-END)); STEP ;(FOR var FROM n) => (initially (setq var (- n 1))) ; (FOR var NEXT (1+ var)) ; ;(FOR var FROM n TO m) => (initially (setq var (- n 1)) (setq limit (- m 1))) ; (FOR var NEXT (if (> var limit) (finish) (1+ var)) ; ; ;(FOR var ON list) => (initially (setq temp list)) ; (FOR var NEXT (if (atom temp) ; (finish) ; (progn (setq temp (cdr temp)) ; temp))) ; ;(FOR var IN list) => (initially (setq temp list)) ; (FOR var NEXT (if (endp temp) ; (finish) ; (pop temp))) ; ;(FOR var IN-VECT v) => (initially (setq index -1) (setq len (1- (length v)))) ; (FOR var NEXT (if (>= index len) (finish)) ; (setq index (1+ index)) ; (aref v index)) ; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Variable binding and setting; pseudo-drivers. ;;; (WITH &optional =) (defclause (with var &optional = (value nil supplied?)) "Bind a variable" ;; Special case: if value is not supplied, var can be a list of ;; variables, all bound defaultly. (if (not supplied?) (mapc #'make-default-binding (if (var-spec? var) (list var) var)) (make-destructuring-bindings var value)) (return-code)) ; nothing to return ;;; (FOR INITIALLY THEN) (defclause (for var initially initial then then) "Set var initially, then on subsequent iterations" ;; This is a pseudo-driver: it doesn't work with NEXT. ;; Set var in initialization code, then set it in the step section on ;; subsequent iterations. (top-level-check) (let* ((initial-setq (list (do-dsetq var initial))) (then-setq (list (do-dsetq var (walk-expr then) nil)))) (register-previous-code (extract-vars var) then-setq :initial) (return-code :initial initial-setq :step then-setq))) ;;; (FOR =) (defclause (for var = expr) "Set a variable on each iteration" ;; Set var each time through the loop. ;; VALUE: primary value of expr. (let ((vars (extract-vars var)) (code (list (do-dsetq var (walk-expr expr))))) (register-previous-code vars code :next) (return-code :body code))) ;;; (FOR FIRST THEN) (defclause (for var first first-expr then then-expr) "Set var on first, and then on subsequent iterations" ;; Set var in the loop, but differently the first time. Most ;; inefficient of the three. ;; VALUE: primary value of first- or then-expr. (let* ((first-setq (list (do-dsetq var (walk-expr first-expr)))) (then-setq (list (do-dsetq var (walk-expr then-expr) nil)))) (register-previous-code (extract-vars var) then-setq :initial) (return-code :body (list (if-1st-time first-setq then-setq))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Reducers. (defun return-reduction-code (&key identity operation external-op? variable expression test type using-type-of accum-kind) ;; A reduction is an iteration pattern in which a value is accumulated ;;(into VARIABLE) by repeatedly applying a binary OPERATION to the ;;variable and an EXPRESSION. The first time, the operation is applied ;;to the IDENTITY and the expression. ;; Some other options allow for a wider range of patterns. If TEST ;;is present, the result will only be accumulated on each iteration if ;;it succeeds. ;; TYPE is the type of the accumulation variable. ;; ACCUM-KIND is the kind of accumulation this is--:increment, :max, ;;etc. If NIL, then it matches any kind. ;; VALUE: the value accumulated so far. (setq variable (or variable *result-var*)) (let* ((var (extract-var variable)) (expr (walk-expr expression)) (test-expr (if test (walk-expr test))) (op-expr (if external-op? (make-funcall operation var expr) (make-application operation var expr))) (update-code `(setq ,var ,op-expr))) (make-accum-var-binding variable identity accum-kind :type type :using-type-of using-type-of) (return-code :body (if test `((if ,test-expr ,update-code ,var)) (list update-code))))) (defsynonym count counting) ;;; (COUNTING &optional INTO) (defclause (counting expr &optional into var) "Increment a variable if expression is non-nil" (return-reduction-code :identity 0 :operation '(subst (var expr) (1+ var)) :expression nil :test expr :variable var :type 'fixnum :accum-kind :increment)) ;;; (SUM &optional INTO) (defclause (sum expr &optional into var) "Sum into a variable" (return-reduction-code :identity 0 :operation '+ :expression expr :test nil :variable var :type 'number :accum-kind :increment)) (defsynonym summing sum) ;;; (MULTIPLY &optional INTO) (defclause (multiply expr &optional into var) "Multiply into a variable" (return-reduction-code :identity 1 :operation '* :expression expr :test nil :variable var :type 'number :accum-kind :increment)) (defsynonym multiplying multiply) ;;; (REDUCING BY &optional INITIAL-VALUE INTO) (defclause (reducing expr by op &optional initial-value (init-val nil iv?) into var-spec) "Generalized reduction" ;; VALUE: the value accumulated so far. ;; If we don't know the initial value, we can't use RETURN-REDUCTION-CODE. ;; We have to be inefficient and do something different the first time. ;; Also, we have to share the first-time-var in case of multiple reductions ;; into the same variable. (cond (iv? (local-binding-check init-val) (return-reduction-code :identity init-val :operation op :external-op? t :expression expr :test nil :variable var-spec :type (expr-type-only op) :accum-kind nil)) ; matches anything (t (setq expr (walk-expr expr)) (setq var-spec (or var-spec *result-var*)) (let* ((var (extract-var var-spec)) (entry (make-accum-var-default-binding var-spec nil :using-type-of expr)) (prev-first-time-var (third entry))) (multiple-value-bind (update-code first-time-var) (if-1st-time `((setq ,var ,expr)) `((setq ,var ,(make-funcall op var expr))) prev-first-time-var) (if (null prev-first-time-var) (setf (cddr entry) (list first-time-var))) (return-code :body (list update-code))))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Extrema. ;;; (MAXIMIZE &optional INTO) (defclause (maximize expr &optional into var) "Maximize value of an expression" (return-extremum-code expr var 'max)) (defsynonym maximizing maximize) ;;; (MINIMIZE &optional INTO) (defclause (minimize expr &optional into var) "Minimize value of an expression" (return-extremum-code expr var 'min)) (defsynonym minimizing minimize) (defun return-extremum-code (expr var-spec operation) ;; If we know the extremal value for the type of var, we COULD generate ;; a reduction...but don't right now, because it complicates ;; multiple accumulation. ;; In order to accomodate multiple maxmins into the same variable, ;; we store the first-time-variable in the accum-var-alist entry and ;; reuse it. We have to do it this way, testing the var each time ;; through the loop, because due to conditionalization we don't know ;; if any of the first-time code will be executed. ;; VALUE: extremum so far. (setq expr (walk-expr expr)) (let* ((m-var-spec (or var-spec *result-var*)) (m-var (extract-var m-var-spec)) (entry (make-accum-var-default-binding m-var-spec (if (eq operation 'min) :min :max) :using-type-of expr)) (prev-first-time-var (third entry))) (multiple-value-bind (update-code first-time-var) (if-1st-time `((setq ,m-var ,expr)) `((setq ,m-var (,operation ,m-var ,expr))) prev-first-time-var) (if (null prev-first-time-var) (setf (cddr entry) (list first-time-var))) (return-code :body (list update-code))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Control flow. ;;; (FIMISH) (defmacro finish () "Leave the loop gracefully, executing the epilogue" (setq *loop-end-used?* t) `(go ,*loop-end*)) ;;; (TERMINATE) (defmacro terminate () ; recommended for use with FOR ... NEXT "Use within FOR ... DO-/NEXT clause to end the iteration" '(finish)) ;;; (NEXT-ITERATION) (defmacro next-iteration () "Begin the next iteration" (setq *loop-step-used?* t) `(go ,*loop-step*)) ;;; (LEAVE &optional) (defmacro leave (&optional value) "Exit the loop without running the epilogue code" `(return-from ,*block-name* ,value)) ;;; (WHILE) (defclause (while expr) "Exit loop if test is nil" (setq *loop-end-used?* t) (return-code :body `((if (not ,(walk-expr expr)) (go ,*loop-end*))))) ;;; (UNTIL) (defclause (until expr) "Exit loop if test is non-nil" (setq *loop-end-used?* t) (return-code :body `((if ,(walk-expr expr) (go ,*loop-end*))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Aggregated Boolean tests. ;; Use same :if-exists kind of accumulation as finding ... such-that ;; so the clauses can be used together. ;;; (ALWAYS) (defclause (always expr) "Return last value iff expression is always non-nil" ;; VALUE: primary value of expr (setq expr (walk-expr expr)) (let ((var *result-var*)) (make-accum-var-binding var t :if-exists) (return-code :body `((or (setq ,var ,expr) (return-from ,*block-name* nil)))))) ;;; (NEVER) (defclause (never expr) "Return T iff expression is never non-nil" ;; VALUE: always nil (setq expr (walk-expr expr)) (let ((var *result-var*)) ;; Do not use :type 'symbol so as be compatible with ALWAYS (make-accum-var-binding var t :if-exists) (return-code :body `((if ,expr (return-from ,*block-name* nil)))))) ;;; (THEREIS) (defclause (thereis expr) "Return value of expression as soon as it is non-nil" ;; VALUE: always nil (setq expr (walk-expr expr)) (let ((var *result-var*)) (make-accum-var-default-binding var :if-exists) (return-code :body `((if (setq ,var ,expr) (return-from ,*block-name* ,var)))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Finders. ;;; (FINDING SUCH-THAT &optional INTO ON-FAILURE) (defclause (finding expr such-that test &optional into var-spec on-failure fval) "Return expression when test is non-nil" ;; VALUE: undefined. (setq expr (walk-expr expr)) (setq test (walk-expr test)) (local-binding-check fval) (setq var-spec (or var-spec *result-var*)) (setq *loop-end-used?* t) (let ((var (extract-var var-spec))) (make-accum-var-binding var-spec fval :if-exists :using-type-of fval) (if (function-quoted? test) (if (duplicable? expr) (return-code :body `((when ,(make-funcall test expr) (setq ,var ,expr) (go ,*loop-end*)))) (let ((temp-var (gensym "FINDING"))) (return-code :body `((let ((,temp-var ,expr)) (when ,(make-funcall test temp-var) (setq ,var ,temp-var) (go ,*loop-end*))))))) (return-code :body `((when ,test (setq ,var ,expr) (go ,*loop-end*))))))) ;;; (FINDING MAXIMIZING &optional INTO) (defclause (finding expr maximizing max-expr &optional into variable) "Return value which maximizes expression" (return-find-extremum-code expr max-expr variable :max)) ;;; (FINDING MINIMIZING &optional INTO) (defclause (finding expr minimizing min-expr &optional into variable) "Return value which minimizes expression" (return-find-extremum-code expr min-expr variable :min)) (defun return-find-extremum-code (expr m-expr var kind) ;; VALUE: expr corresponding to max/min-expr so far. ;; Variable can be a list of two variables, in which case the first ;; is used for the expr and the second for the extremum. ;; The update code looks something like this: ;; When m-expr is not a function: ;; (setq temp m-expr) ;; (cond ;; ((> temp m-var) ;; (setq m-var temp) ;; (setq expr-var expr)) ;; (t expr-var)) ;; ;; When m-expr is a function: ;; (setq temp2 expr) ;; (setq temp (funcall m-expr temp2)) ;; or (m-expr temp2) ;; (cond ;; ((> temp m-var) ;; (setq m-var temp) ;; (setq expr-var temp2)) ;; (t expr-var)) ;; (setq expr (walk-expr expr)) (setq m-expr (walk-expr m-expr)) (let* ((function? (function-quoted? m-expr)) (temp-var (make-var-and-default-binding 'temp :using-type-of (if (not function?) m-expr))) (temp-var-2 (if (and function? (not (duplicable? expr))) (make-var-and-default-binding 'temp :using-type-of expr))) (test (if (eq kind :max) '> '<)) expr-var m-var) (cond ((null var) ;; no var means return expr as a result (setq expr-var *result-var*) (setq m-var (genvar kind))) ((var-spec? var) ;; a single var-spec means set expr to that var (setq expr-var var) (setq m-var (genvar kind))) ((and (consp var) (= (length var) 2) (every #'var-spec? var)) ;; a two-element list means set expr to 1st, m to 2nd (setq expr-var (first var)) (setq m-var (second var))) (t (clause-error "The value for INTO, ~a, should be a variable specifier ~ or a list of two variable specifiers." var))) (make-default-binding expr-var :using-type-of expr) (make-accum-var-default-binding m-var kind :using-type-of m-expr) (setq expr-var (extract-var expr-var)) (setq m-var (extract-var m-var)) (let* ((expr-code (or temp-var-2 expr)) (esetq-code (if temp-var-2 `((setq ,temp-var-2 ,expr)))) (m-code (if function? (make-funcall m-expr expr-code) m-expr))) (return-code :body `(,.esetq-code (setq ,temp-var ,m-code) ,(if-1st-time `((setq ,m-var ,temp-var) (setq ,expr-var ,expr-code)) `((cond ((,test ,temp-var ,m-var) (setq ,m-var ,temp-var) (setq ,expr-var ,expr-code)) (t ,expr-var))))))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Collectors. (defun return-collection-code (&key variable expression start-operation end-operation one-element test (place 'end) (result-type 'list)) ;; VALUE: the list so far. ;; Remove the "maybe quoted" idiom from documentation & code in the next release (when (quoted? result-type) (setq result-type (second result-type))) (when (quoted? place) (setq place (second place))) (let ((place-string (locally (declare (optimize safety)) (symbol-name place)))) (cond ((string= place-string '#:end) (setq place 'end)) ((or (string= place-string '#:start) (string= place-string '#:beginning)) (setq place 'start)) (t (clause-error "~a is neither 'start', 'beginning' nor 'end'" place)))) (let* ((collect-var-spec (or variable *result-var*)) (collect-var (extract-var collect-var-spec)) (entry (make-accum-var-binding collect-var-spec nil :collect :type (if (eq result-type 'list) 'list `(or list ,result-type)))) (end-pointer (third entry)) (prev-result-type (fourth entry))) (cond ((null end-pointer) (if (eq place 'end) (setq end-pointer (make-var-and-binding 'end-pointer nil :type 'list))) (setf (cddr entry) (list end-pointer result-type))) (t (if (not (equal result-type prev-result-type)) (clause-error "Result type ~a doesn't match ~a" result-type prev-result-type)))) (let* ((expr (walk-expr expression)) (op-expr (if (eq place 'start) (if (null start-operation) expr (make-application start-operation expr collect-var)) (if (null end-operation) expr (make-application end-operation collect-var expr))))) (if (eq place 'start) (return-code :body `((setq ,collect-var ,op-expr)) :final (unless (eq result-type 'list) `((setq ,collect-var (coerce ,collect-var ',result-type))))) (with-temporary temp-var ;; In the update code, must test if collect-var is null to allow ;; for other clauses to collect into same var. This code ;; is a tad bummed, but probably more for looks than real ;; efficiency. (let* ((update-code `(if ,collect-var (setf (cdr ,end-pointer) ,temp-var) (setq ,collect-var ,temp-var))) (main-code (cond ((not one-element) `((if (setq ,temp-var ,op-expr) (setq ,end-pointer (last ,update-code))))) (test `((when ,(make-application test collect-var expr) (setq ,temp-var ,op-expr) (setq ,end-pointer ,update-code)))) (t `((setq ,temp-var ,op-expr) (setq ,end-pointer ,update-code)))))) (return-code ;; Use a progn so collect-var isn't mistaken for a tag. :body `((progn ,.main-code ,collect-var)) :final (if (eq result-type 'list) nil `((setq ,collect-var (coerce ,collect-var ',result-type))))))))))) ;;; (COLLECT &optional INTO AT RESULT-TYPE) (defclause (collect expr &optional into var at (place 'end) result-type (type 'list)) "Collect into a list" (return-collection-code :variable var :expression expr :one-element t :start-operation 'cons :end-operation '(subst (var expr) (list expr)) :place place :result-type type)) (defsynonym collecting collect) ;;; (ADJOINING &optional INTO AT TEST RESULT-TYPE) (defclause (adjoining expr &optional into var at (place 'end) test (test '#'eql) result-type (type 'list)) "Adjoin into a list (tests for membership first)" (if (duplicable? expr) (return-collection-code :variable var :expression expr :start-operation `(subst (expr var) (adjoin expr var :test ,test)) :test `(subst (var expr) (not (member expr var :test ,test))) :end-operation '(subst (var expr) (list expr)) :one-element t :result-type type :place place) (with-temporary temp (return-collection-code :variable var :expression expr :start-operation `(subst (expr var) (progn ,temp ; silence unused variable warning (adjoin expr var :test ,test))) :test `(subst (var expr) (progn (setq ,temp expr) (not (member ,temp var :test ,test)))) :end-operation `(subst (var expr) (list ,temp)) :one-element t :result-type type :place place)))) ;;; (NCONCING &optional INTO AT) (defclause (nconcing expr &optional into var at (place 'end)) "Nconc into a list" (return-collection-code :variable var :expression expr :start-operation 'nconc :place place :one-element nil)) ;;; (APPENDING &optional INTO AT) (defclause (appending expr &optional into var at (place 'end)) "Append into a list" (return-collection-code :variable var :expression expr :start-operation 'append :end-operation '(subst (var expr) (copy-list expr)) :place place :one-element nil)) ;;; (UNIONING &optional INTO AT TEST) (defclause (unioning expr &optional into var at (place 'end) test (test '#'eql)) "Union into a list" ;; Can't use UNION because it says nothing about the order. (return-collection-code :variable var :expression expr :start-operation `(subst (expr var) (nconc (delete-if #L(member !1 var :test ,test) (copy-list expr)) var)) :end-operation `(subst (var expr) (delete-if #L(member !1 var :test ,test) (copy-list expr))) :place place :one-element nil)) ;;; (NUNIONING &optional INTO AT TEST) (defclause (nunioning expr &optional into var at (place 'end) test (test '#'eql)) "Union into a list, destructively" ;; Can't use NUNION because it says nothing about the order. (return-collection-code :variable var :expression expr :start-operation `(subst (expr var) (nconc (delete-if #L(member !1 var :test ,test) expr) var)) :end-operation `(subst (var expr) (delete-if #L(member !1 var :test ,test) expr)) :place place :one-element nil)) ;;; (ACCUMULATE BY &optional INITIAL-VALUE INTO) (defclause (accumulate expr by op &optional initial-value init-val into var-spec) "Generalized accumulation" ;; VALUE: the value accumulated so far. ;; This is just like REDUCING except, 1. the args to OP are in the other ;; order, and 2. if no initial value is supplied, NIL is used. (local-binding-check init-val) (setq var-spec (or var-spec *result-var*)) ;; ignore the THE expression--it was a bad idea (if (the-expression? op) (setq op (third op))) (let* ((var (extract-var var-spec)) (op-expr (make-funcall op (walk-expr expr) var))) (make-accum-var-binding var-spec init-val nil :type nil) (return-code :body `((setq ,var ,op-expr))))) (defsynonym accumulating accumulate) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; The PREVIOUS mechanism. ;;; It makes no sense to save local vars, so this is not as complex as I had ;;; thought. There is one list: an alist of top-level vars and their info ;;; (*previous-vars-alist*). Also, I now insist that the default value be ;;; fixed at the initialization section of the loop, so the old *unset* ;;; implementation is unnecessary. ;;; However, generators complicate things. In the absence of a generator, ;;; the save code can go in the step portion of the loop; but if there is a ;;; generator, the best we can do is use a flag for the first time. ;;; (FOR PREVIOUS &optional INITIALLY BACK) (defclause (for pvar-spec previous var &optional initially (default nil default?) back (n-expr 1)) "Previous value of a variable" ;; Set each save variable to the default in the initialization. (top-level-check) (if (not (constantp n-expr)) (clause-error "~a should be a compile-time constant" n-expr)) (let ((pvar (extract-var pvar-spec)) (n (eval n-expr))) ; Is this okay? It should be. (if (not (and (integerp n) (> n 0))) (clause-error "~a should be a positive integer" n-expr) ;; Here, n is a positive integer. (let* ((p-i (intern-previous-info var)) (init-val (make-initial-value default default? (var-type var))) (temp (if (not (duplicable? init-val)) (make-var-and-default-binding 'temp :using-type-of init-val))) (iv-ref (or temp init-val)) (save-vars (cons pvar (make-save-vars var (1- n)))) (inits (mapcar #L`(setq ,!1 ,iv-ref) save-vars))) (if temp (push `(setq ,temp ,init-val) inits)) (make-default-binding pvar-spec) (push (make-save-info :save-var pvar :iv-ref iv-ref :save-vars save-vars) (previous-info-save-info-list p-i)) (return-code :initial inits))))) (defun register-previous-code (vars code class) ;; It's important for this that code is never copied; we keep a pointer to ;; it. (dolist (var (listify vars)) (let ((p-i (intern-previous-info var))) (setf (previous-info-class p-i) class) (push (cons code (last code)) (previous-info-code p-i))))) (defun intern-previous-info (var) ;; If VAR already has a previous-info structure, return it; else ;; create a new one, put it where it belongs, and return it. ;; Make sure that if VAR is itself a save-var, the new record goes after ;; the one for VAR's var, so that the previous code is generated before it ;; is itself considered update code for another previous splicing. (or (cdr (assoc var *previous-vars-alist*)) (let* ((p-i (make-previous-info :var var)) (place (member var *previous-vars-alist* :test #'is-save-var))) (if (null place) (push (cons var p-i) *previous-vars-alist*) (push (cons var p-i) (cdr place))) p-i))) (defun is-save-var (var entry) (member var (previous-info-save-info-list (cdr entry)) :key #'save-info-save-var)) (defun make-save-vars (var n) (let ((list nil) (string (format nil "SAVE-~a-" var))) (dotimes (i n) (let ((svar (make-var-and-default-binding string :using-type-of var))) (push svar list))) list)) (defun insert-previous-code () ;; For each variable that requires a previous value, get all the update code ;; for that variable and splice in code that will remember the previous ;; values for the desired number of iterations. Return code to put in the ;; init and step sections of the loop. ;; There are three situations here: ;; 1. Variable has its initial value at the beginning of the loop, or gets ;; its initial value in a different place than where it is updated. In ;; this case, we can put the save code just before each update of the ;; variable. Applicable clauses are: FOR-PREVIOUS, FOR-INITIALLY-THEN, ;; and FOR-FIRST-THEN. (class :INITIAL) ;; 2. The variable is updated somewhere inside the loop, and the update also ;; gives it its first value. We use another, internal save variable, ;; which is set to the variable after each update. This is for FOR-= and ;; driver clauses when NEXT is used.(class :NEXT) ;; 3. Variable is a driver with no NEXT. We can put the update in the step ;; portion of the loop, since we know the update code occurs at the ;; beginning. (class :STEP) ;; Note that (3) is really an optimization of (2), and we could perform such ;; an optimization more generally if we could show that a variable in class ;; (2) was always updated before being used. Right now, we don't bother. ;; *** (3) is no longer done because driver code stays where the driver is. ;; We could try to detect that the driver is at the beginning, but don't ;; for now. (let ((init-code nil) (step-code nil) (pv-list *previous-vars-alist*)) ;; Step through this manually, because it may be that we add to it in ;; the process, and we must make sure that we don't cdr till we have to. (loop (if (null pv-list) (return)) (let* ((entry (car pv-list)) (var (car entry)) (p-i (cdr entry)) (save-info-list (previous-info-save-info-list p-i)) (code-list (previous-info-code p-i)) (class (previous-info-class p-i))) (if save-info-list (if (and (null code-list) (not (eq class :step))) (clause-error "Cannot obtain previous values of ~a" var) (let ((prev-code (if (not (eq class :next)) (mapcan #L(make-prev-code var !1) save-info-list)))) (case class ;;;;;; (:step (augment step-code prev-code)) (:initial (splice-in-code prev-code nil code-list)) ((:next :step) (augment init-code (do-extra-save-var-hack var save-info-list code-list))) (otherwise (bug "unknown class ~a" class))))))) (setq pv-list (cdr pv-list))) (values init-code step-code))) (defun do-extra-save-var-hack (var save-info-list code-list) (let ((init-code nil) (prev-code nil) (post-code nil)) (dolist (s-i save-info-list) (let* ((extra-save-var (make-post-save-var var)) (prev (make-prev-code extra-save-var s-i :next))) (augment init-code `((setq ,extra-save-var ,(save-info-iv-ref s-i)))) (augment post-code `((setq ,extra-save-var ,var))) (augment prev-code prev))) (splice-in-code prev-code post-code code-list) init-code)) (defun make-post-save-var (var) (make-var-and-default-binding (format nil "POST-SAVE-~a-" var) :using-type-of var)) (defun make-prev-code (set-var s-i &optional (class :initial)) (let ((prev (make-save-previous-code set-var (save-info-save-vars s-i)))) (register-previous-code (save-info-save-var s-i) prev class) prev)) (defun make-save-previous-code (var save-vars) ;; The first save-var is the furthest back. (if (null (cdr save-vars)) `((setq ,(car save-vars) ,var)) (cons `(setq ,(first save-vars) ,(second save-vars)) (make-save-previous-code var (cdr save-vars))))) (defun splice-in-code (prev-code post-code code-list) ;; Put PREV-CODE in at the first cons cell of CODE, and POST-CODE at the ;; last cons cell. Both PREV-CODE and POST-CODE are single forms. ;; Some list splicing here--danger. It's crucial that ;; CODE actually appears in the code to be generated. ;; Can't use prognify here, because other people might have pointers to ;; this code, and when prognify takes the car it ruins that. (setq prev-code (add-progn prev-code)) (setq post-code (add-progn post-code)) (dolist (code code-list) (let* ((first-cons-cell (car code)) (last-cons-cell (cdr code))) (when post-code ;;; (format t "Splicing ~a after ~a~%" post-code last-cons-cell) (setf (cdr last-cons-cell) (cons post-code (cdr last-cons-cell)))) (when prev-code ;;; (format t "Splicing ~a before ~a~%" prev-code first-cons-cell) (let ((new-start (cons (car first-cons-cell) (cdr first-cons-cell)))) (setf (car first-cons-cell) prev-code) (setf (cdr first-cons-cell) new-start)))))) (defun add-progn (forms) ;; If more than one form, cons the progn in; else do nothing. (cond ((null forms) nil) ((and (listp (car forms)) (not (lambda-expression? (car forms)))) (cons 'progn forms)) (t forms))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Miscellaneous. ;; unused (defun at-top-level? () *top-level?*) (defun top-level-check () (if (not *top-level?*) (clause-error "Clause can occur only at top-level"))) (defun prognify (forms) ;; If more than one form, and the first is a list, then insert a PROGN. ;; Be careful to not copy forms. (if (cdr forms) (if (and (listp (car forms)) (not (eq (caar forms) 'lambda))) (cons 'progn forms) forms) (car forms))) (defun clause-error (format-string &rest args) (apply #'error (concatenate 'string "Iterate~@[, in ~a~]:~%" format-string) (and (boundp' *clause*) *clause*) args)) (defun clause-warning (format-string &rest args) (let ((*print-pretty* t)) (apply #'warn (concatenate 'string "Iterate~@[, in clause ~a~]:~%" format-string) (and (boundp' *clause*) *clause*) args))) (defun bug (format-string &rest args) (apply #'format *error-output* (concatenate 'string "Bug in Iterate: " format-string) args)) ;;; I need something that's a cross between gensym and gentemp... (defvar *genvar-counter* 0) (defun genvar (&optional (string "TEMP")) (prog1 (make-symbol (format nil "~a~d" string *genvar-counter*)) (incf *genvar-counter*))) (defun symbol-append (&rest syms) (intern (apply #'concatenate 'string (mapcar #'symbol-name syms)))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Debugging. #| (defun run-test () (with-open-file (ifile "/wh/jba/Lisp/test-iter.lisp" :direction :input) (loop (let ((form (read ifile nil :eof))) (if (eq form :eof) (return-from run-test nil)) (print form) (format t "==>~%") (print (eval form)) (format t "~%--------------------~2%"))))) (defun expand-test () (with-open-file (ifile "test-iter.lisp" :direction :input) (loop (let ((form (read ifile nil :eof))) (if (eq form :eof) (return-from expand-test nil)) (print form) (format t "==>~%") (print (macroexpand-1 form)) (format t "~%--------------------~2%"))))) (defmacro me (x) `(progn (setq *print-pretty* t) (macroexpand-1 ',x))) |# ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Junk. ;;;;;;; For Gnu Emacs ;;;;;;; ;;; Local variables: ;;; version-control: t ;;; kept-new-versions: 5 ;;; kept-old-versions: 0 ;;; end: iterate-20160825-darcs/iterate.asd0000644000000000000000000000117012757566717015054 0ustar0000000000000000;;; -*- lisp -*- system definition (defsystem :iterate :description "Jonathan Amsterdam's iterator/gatherer/accumulator facility" :licence "MIT" :in-order-to ((test-op (test-op :iterate/tests))) :components ((:file "package") (:file "iterate" :depends-on ("package")))) (defsystem :iterate/tests :depends-on (:iterate #+sbcl :sb-rt #-sbcl :rt) :components ((:file "iterate-test"))) (defmethod perform ((operation test-op) (component (eql (find-system :iterate/tests)))) (funcall (intern "DO-TESTS" (find-package #+sbcl "SB-RT" #-sbcl "REGRESSION-TEST")))) iterate-20160825-darcs/iterate-test.lisp0000644000000000000000000013756712757566717016255 0ustar0000000000000000;;; Test cases for Iterate. ;;; Copyright (c) 2003 Andreas Fuchs ;;; Copyright (c) 2004-2007 Joerg Hoehle ;;; License: ;; Permission is hereby granted, free of charge, to any person ;; obtaining a copy of this software and associated documentation ;; files (the "Software"), to deal in the Software without ;; restriction, including without limitation the rights to use, copy, ;; modify, merge, publish, distribute, sublicense, and/or sell copies ;; of the Software, and to permit persons to whom the Software is ;; furnished to do so, subject to the following conditions: ;; The above copyright notice and this permission notice shall be ;; included in all copies or substantial portions of the Software. ;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS ;; BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ;; ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN ;; CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE ;; SOFTWARE. ;;; Commentary: ;; Although growing, this testsuite does not yet cover every documented ;; feature of Iterate. (cl:defpackage #:iterate.test (:use #:cl #:iterate #+sbcl #:sb-rt #-sbcl #:regression-test)) (cl:in-package #:iterate.test) (rem-all-tests) (deftest dsetq.1 (let (x y) (dsetq (x y) (list* 4 5 6)) (list x y)) (4 5)) (deftest dsetq.2 (let (x y) (dsetq (x nil y) (list* 4 5 6 7)) (list x y)) (4 6)) (deftest dsetq.3 (let ((a '((1 2) 3)) b) (dsetq (a b) a) (values a b)) (1 2) 3) (deftest dsetq.destructuring.1 (let (x y) (dsetq (x . y) (list* 4 5 6)) (list x y)) (4 (5 . 6))) (deftest dsetq.destructuring.2 (let (x y z) (dsetq (x nil (y . z)) (list* 4 5 '(6 7 . 8) 9)) (list x y z)) (4 6 (7 . 8))) (deftest dsetq.values.1 (let (x y) (dsetq (values x y) (values 1 'a)) (list x y)) (1 a)) (deftest dsetq.values.2 (let (x y) (dsetq (values x nil y) (values 1 'a "c")) (list x y)) (1 "c")) (deftest dsetq.values.3 (let (x) (dsetq (values nil (nil . x)) (values 1 '(a b . c))) x) (b . c)) (deftest dsetq.values.4 (let (x y z) (dsetq (values nil x (y z)) (values 1 'a '(b c))) (list x y z)) (a b c)) (deftest repeat.1 (iter (repeat 9) (count 1)) 9) (deftest repeat.2 (iter (repeat 2.5s0) (counting t)) 3) (deftest repeat.3 (iter (repeat -1.5f0) (counting t)) 0) (deftest locally.1 (iterate (for i in '(1 2 3)) (repeat 2) (locally (collect i) (collect 0))) (1 0 2 0)) (deftest locally.2 (iterate (for i in '(1 2 3)) (repeat 2) (locally (declare (optimize safety)) (declare (fixnum i)) (collect i))) (1 2)) (deftest always.1 (iter (repeat 3) (always 2)) 2) (deftest always.2 (iter (repeat 0) (always 2)) t) (deftest always.3 (iter (for i in '()) (always i)) t) (deftest always.never.1 (iterate (repeat 2) (always 2) (never nil)) 2) (deftest always.never.2 (iter (for x in '(b (2 . a))) (if (consp x) (always (car x)) (always x)) (never nil)) 2) (deftest thereis.finally.1 (iter (repeat 3) (thereis nil) (finally (prin1 "hi"))) nil) (deftest thereis.finally.2 (with-output-to-string (*standard-output*) (iter (repeat 3) (thereis nil) (finally (princ "hi")))) "hi") (deftest thereis.finally.3 (iter (repeat 3) (thereis nil) (finally (return 2))) 2) (deftest thereis.finally-protected.1 (iter (repeat 3) (thereis 4) (finally-protected (prin1 "hi"))) 4) (deftest thereis.finally-protected.2 (with-output-to-string (*standard-output*) (iter (repeat 3) (thereis 4) (finally-protected (princ "hi")))) "hi") (deftest finding.such-that.2 (iter (for i in '(7 -4 2 -3 4)) (if (plusp i) (finding i such-that (evenp i)) (finding (- i) such-that (oddp i)))) 2) (deftest finding.such-that.nest.1 (iter (for i in '(1 2 3)) (finding (1+ i) such-that #'(lambda (x) (declare (ignore x)) (collect (- i) into m)))) 2) ; not -1 as some old version did (deftest finding.such-that.nest.2 (iter (for i in '(1 2 3)) (finding (1+ i) such-that #'(lambda (x) (finding (- x) such-that #'(lambda (x) x nil) into n) t) into m) (finally (return (values m n)))) 2 nil) ; not -2 nil as some old version did (deftest finding.thereis.1 (iterate (for x in '(a 7 (-4 -3))) (thereis (consp x)) (finding x such-that (numberp x))) 7) (deftest finding.thereis.2 (iterate (for x in '(a (-4 -3) 7)) (thereis (consp x)) (finding x such-that (numberp x))) t) (deftest finding.thereis.3 (iterate (for x in '(a #\b)) (thereis (consp x)) (finding x such-that (numberp x))) nil) (deftest finding.always.1 (iterate (for x in '(-4 -2 -3)) (always (numberp x)) (finding x such-that (plusp x) on-failure t)) t) (deftest finding.always.2 (iterate (for x in '(-4 7 -2 -3)) (always (numberp x)) (finding x such-that (plusp x) on-failure t)) 7) (deftest finding.always.3 (iterate (for x in '(-4 c -3)) (always (numberp x)) (finding x such-that (plusp x) on-failure t)) nil) (defun setup-hash-table (hash) (dotimes (i (random 100)) (declare (ignorable i)) (setf (gethash (random 10000) hash) (random 10000)) (setf (gethash (gensym) hash) (gensym)))) (deftest in-hashtable.keys (let* ((hash (make-hash-table)) (all-entries (progn (setup-hash-table hash) '())) (generated-entries (iterate (for (key) in-hashtable hash) (collect key)))) (maphash (lambda (key value) value (push key all-entries)) hash) (= (length all-entries) (length generated-entries) (length (union all-entries generated-entries :test (hash-table-test hash))))) t) (deftest in-hashtable.items.1 (let ((items nil) (hash (make-hash-table))) (setup-hash-table hash) (maphash (lambda (key item) key (push item items)) hash) (set-difference items (iterate (for (key item) in-hashtable hash) (declare (ignore key)) (collect item)))) nil) (deftest in-hashtable.items.2 (let ((items nil) (hash (make-hash-table))) (setup-hash-table hash) (maphash (lambda (key item) key (push item items)) hash) (set-difference items (iterate (for (nil item) in-hashtable hash) (collect item)))) nil) (deftest in-hashtable.1 (let* ((hash (make-hash-table)) (all-entries (progn (setup-hash-table hash) '())) (generated-entries (iterate (as (key item) in-hashtable hash) (collect (cons key item))))) (maphash #'(lambda (key value) (push (cons key value) all-entries)) hash) (= (length all-entries) (length generated-entries) (length (union all-entries generated-entries :key #'car :test (hash-table-test hash))))) t) (deftest in-hashtable.destructuring.1 (let ((hash (make-hash-table :test #'equal)) (entries '(((a . b) . (1 . 2)) (("c" . 3) . (6 . "7"))))) (iterate (for (k . v) in entries) (setf (gethash k hash) v)) (sort (iterate (for ((nil . k2) (v1 . v2)) in-hashtable hash) (always (numberp v1)) (while k2) (collect (cons v1 k2) into vals) (finally (return vals))) #'< :key #'car)) ((1 . b) (6 . 3))) (deftest in-package.internals (let ((syms nil) (iter-syms (iterate (for sym in-package *package* :external-only nil) (collect sym)))) (do-symbols (sym *package* nil) (push sym syms)) (list (set-difference syms iter-syms :test #'eq) (set-difference iter-syms syms))) (()())) (deftest in-package.externals.1 (let ((syms nil) (iter-syms (iterate (for sym in-package '#:cl-user external-only t) (collect sym)))) (do-external-symbols (sym '#:cl-user nil) (push sym syms)) (list (set-difference syms iter-syms :test #'eq) (set-difference iter-syms syms))) (()())) (deftest in-package.externals.2 (let ((sym-count 0)) (do-external-symbols (sym '#:iterate) (declare (ignore sym)) (incf sym-count)) (= sym-count (iterate (for () in-package '#:iterate external-only t) (count 1)))) t) (deftest in-package.generator (let ((syms nil) (iter-syms (iterate (generate sym in-package *package*) (collect (next sym))))) (do-symbols (sym *package*) (push sym syms)) (list (set-difference syms iter-syms :test #'eq) (set-difference iter-syms syms))) (()())) (deftest in-packages.external (let ((syms nil) (iter-syms (iterate (as (sym access package) in-packages '(#:cl-user) :having-access (:external)) (collect sym)))) (do-external-symbols (sym '#:cl-user nil) (push sym syms)) (list (set-difference syms iter-syms :test #'eq) (set-difference iter-syms syms))) (()())) (deftest in-packages.generator-access (let ((iter-syms (iterate (generate (sym access) in-packages (list (find-package "COMMON-LISP"))) (repeat 1) (next sym) (collect (list sym access))))) (equal (multiple-value-list (find-symbol (symbol-name (caar iter-syms)) "COMMON-LISP")) (car iter-syms))) t) (deftest in-stream.1 (iter (as x in-stream (make-string-input-stream "#xa()2")) (collect x)) (10 () 2)) (deftest in-stream.previous (iter (for x in-stream (make-string-input-stream "#xa()2")) (as p previous x :initially 1) (collect p)) (1 10 ())) (deftest in-stream.2 ;; This fails in cmucl, sbcl and gcl, because string-input-streams ;; are always open, even after close. (let ((s (make-string-input-stream "("))) (ignore-errors (iter (for x in-stream s :using #'read))) (open-stream-p s)) nil) (deftest in-stream.3 (iter (for c in-stream (make-string-input-stream "235") :using #'read-char) (accumulating (digit-char-p c) by #'+ initial-value 0)) 10) (deftest in-stream.reducing (iter (with s = (make-string-input-stream "(+ 2)(+ 10)(- 5)(+ 6)")) (for (op num) in-stream s) (reducing num :by op :initial-value 0)) 13) (deftest in-stream.accumulating (iter (with s = (make-string-input-stream "(+ 2)(+ 10)(- 5)(+ 6)")) (for (op num) in-stream s) (accumulating num :by op :initial-value 0)) -1) ; (6 + (5 - (10 + (2 + 0)))) (deftest in-stream.generate (iter (with s = (make-string-input-stream "2 + 10 - 5 + 6")) (with start = (read s)) (generate e in-stream s using #'read) (as op = (next e)) (for arg = (next e)) (reducing arg by op initial-value start)) 13) (deftest reducing.0 (iter (with expr = '(2 + 10 - 5 + 6)) (with start = (pop expr)) (for (op arg) on expr by #'cddr) (reducing arg by op initial-value start)) 13) (deftest until.1 (iter (with rest = 235) (with digit = 0) (multiple-value-setq (rest digit) (floor rest 10)) (sum digit into sum) (multiplying digit into product) (until (zerop rest)) (finally (return (values sum product)))) 10 30) (deftest until.2 (iter (for i in-sequence '#(1 2 -3 6)) (until (zerop (sum i into x))) (multiplying i)) 2) (deftest while.1 (iter (for i in-sequence '#(1 2 -3 6)) (while (< (length (collect i)) 2))) (1 2)) (deftest else.1 (iter (repeat 0) (else (return 1))) 1) (deftest else.2 (iter (for i below -3) (else (return 2))) 2) ;;; tests for my examples: (eval-when (:compile-toplevel :load-toplevel :execute) (defparameter *an-alist* '((a . 2) (b . 3) (zero . 10) (c . 4) (one . 20) (d . 5) (e . 99))) (defparameter *list-of-lists* (loop for i from 0 to 100 collect (loop for len from 0 to (random 20) collect len))) (defun longest-list (list1 list2) (if (< (length list2) (length list1)) list1 list2))) (deftest collect.1 (iterate (as (key . item) in *an-alist*) (collect key into keys) (collect item into items) (finally (return (values keys items)))) #.(loop for (key . nil) in *an-alist* collect key) #.(loop for (key . item) in *an-alist* collect item)) (deftest generate.1 (iterate (generate i from 0 to 6) (for (key . value) in *an-alist*) (when (>= value 10) (collect (cons key (next i))))) #.(loop with counter = 0 for (key . value) in *an-alist* when (>= value 10) collect (cons key (prog1 counter (incf counter))))) (deftest find-longest-list.1 (iterate (for elt in *list-of-lists*) (finding elt maximizing (length elt))) #.(reduce #'longest-list *list-of-lists*)) (deftest find-longest-list.2 (iterate (for elt in *list-of-lists*) (finding elt maximizing (length elt) into (e m)) (finally (return m))) #.(reduce #'max *list-of-lists* :key #'length)) (deftest find-longest-list.3 (iterate (for elt in *list-of-lists*) (finding elt maximizing #'length)) #.(reduce #'longest-list *list-of-lists*)) (deftest find-longest-list.4 (iterate (for elt in *list-of-lists*) (finding elt maximizing #'length into (e m)) (finally (return m))) #.(reduce #'max *list-of-lists* :key #'length)) (deftest maximize.1 (iterate (for elt in *list-of-lists*) (maximizing (length elt) into m) (finally (return m))) #.(reduce #'max *list-of-lists* :key #'length)) (deftest maximize.2 (iterate (for elt in *list-of-lists*) (maximize (length elt))) #.(reduce #'max *list-of-lists* :key #'length)) (deftest finding.minimizing.1 (iterate (for elt in *list-of-lists*) (finding elt minimizing #'length into (e m)) (finally (return m))) #.(reduce #'min *list-of-lists* :key #'length)) (deftest minimize.1 (iterate (for elt in *list-of-lists*) (minimizing (length elt) into m) (finally (return m))) #.(reduce #'min *list-of-lists* :key #'length)) (deftest minimize.2 (iterate (for elt in *list-of-lists*) (minimize (length elt))) #.(reduce #'min *list-of-lists* :key #'length)) (deftest subblocks.maximize.1 (iter outer (for elt in *list-of-lists*) (iterate running (for e in elt) (in outer (maximize e))) (maximizing (length elt))) #.(reduce #'max *list-of-lists* :key #'length)) (deftest subblocks.minimize.1 (iter outer (for elt in *list-of-lists*) (minimizing (length elt)) (iterate running (for e in elt) (in outer (minimize e)))) 0) (deftest maximize.3 (iterate (for i in-vector '#(-3)) (maximize i)) -3) (deftest minimize.3 (iterate (as i in-vector '#(3)) (minimize i)) 3) (deftest maximize.multiple (iter (as i from 3 downto -3 by 2) (maximize i) (for j from -1) (maximizing j)) 3) (deftest minimize.multiple (iter (as i from -3 to 3 by 2) (minimize i into x) (for j downfrom -1) (minimizing j into x) (finally (return x))) -4) (deftest accumulate.1 (iter (for c in-string "235") (declare (type character c)) (accumulate (digit-char-p c) by '* initial-value 1)) 30) (deftest accumulate.2 (iter (for c in-sequence "235") (accumulating (digit-char-p c) by #'* initial-value 1)) 30) (deftest accumulate.3 (iter (for c in-sequence "235") (accumulate (digit-char-p c) by 'cons initial-value 1)) (5 3 2 . 1)) (deftest accumulate.4 (iter (for c in-vector "235") (accumulating (digit-char-p c) by #'cons)) (5 3 2)) (deftest accumulate.5 (iter (repeat 0) (accumulating 1 by #'cons)) nil) (deftest accumulate.6 (iter (repeat 0) (accumulate 1 by #'cons initial-value 2)) 2) (deftest in-string.downto.1 (iter (for c in-string "235" downto 1) (accumulate (digit-char-p c) by 'cons)) (3 5)) (deftest in-sequence.downto.1 (iter (for c in-sequence "235" downto 1) (accumulate (digit-char-p c) by #'cons)) (3 5)) (deftest reducing.1 (iter (for c in-string "235") (reducing (digit-char-p c) by 'list initial-value 1)) (((1 2) 3) 5)) (deftest reducing.2 (iter (as x index-of-string "235") (reducing x :by #'list initial-value -1)) (((-1 0) 1) 2)) (deftest reducing.3 (iter (repeat 0) (reducing 1 #:by 'cons initial-value -1)) -1) (deftest reducing.4 (iter (for i from 3 to 5) (reducing i by #'- :initial-value '0)) -12) (deftest reducing.5 (iter (for x in-vector #(3)) (reducing (cons x x) by #'list)) (3 . 3)) (deftest reducing.6 (iter (for x in-vector (vector 3)) (reducing (cons x x) by #'list :initial-value nil)) (nil (3 . 3))) ;; synonyms (e.g. GENERATING, COLLECTING) didn't work (deftest generate.destructuring.1 (iter (generate (key . item) in '((a . 1) (b . 2) (c .3))) (collect (next key)) (collect (next item))) (a 2 c)) (deftest generating.destructuring.1 (iter (generating (key . item) in '((a . 1) (b . 2) (c .3))) (collect (next key)) (collect (next item))) (a 2 c)) (deftest for.generate-t.destructuring.1 (iter (for (key . item) in '((a . 1) (b . 2) (c .3)) :generate t) (collect (next key)) (collect (next item))) (a 2 c)) (deftest generate.next.1 (iter (generate c in '(a b c d e f g h i j k l m n o p q)) (for s in '(1 1 2 3 1 0 1 0 2 1)) (collect (next c s))) (a b d g h h i i k l)) (deftest generate.previous.1 (iter (generate c in '(a b c d e f g h i j k l m n o p q)) (for s in '(1 1 2 3 1 0 1 0 2 1)) (for x = (next c s)) (as y previous x) (collect (list y x))) ((nil a) (a b) (b d) (d g) (g h) (h h) (h i) (i i) (i k) (k l))) (deftest generate.next.2 (with-output-to-string (*standard-output*) (iter (generate i in '(1 2 3 4 5)) (princ (next i 2)))) "24") (deftest if.1 (iter (generate x in-vector '#(t nil nil t)) (as i from 0) (if (next x) (collect i))) (0 3)) (deftest if.2 (iter (generate x in-vector '#(t nil nil t) with-index i) (if (next x) (collect i))) (0 3)) (deftest or.1 (iter (generate x in '(a nil nil 1)) (generate y in-vector '#(2 #\c #\d)) (collect (or (next x) (next y)))) (a 2 #\c 1)) (deftest or.2 (iter (generate x in '(a nil nil 1 nil)) (generate y in-sequence '#(2 nil #\c #\d)) (collect (or (next x) (next y) 3))) (a 2 3 1 #\c)) (deftest setf.1 (iter (generate i from 0 to 3) (with v = (vector 'a 'b 'c 'd)) (setf (aref v (next i)) i) (finally (return v))) #(0 1 2 3)) (deftest setf.2 ;; These setf tests fail in CormanLisp 2.0 because ccl does ;; not respect setf evaluation order rules. (iter (generate i from 0 to 3) (with v = (vector 'a 'b 'c 'd)) (setf (aref v (next i)) (next i)) (finally (return v))) #(1 b 3 d)) (deftest setf.3 (iter (generate i in '(0 1 2 3 4 5)) (with v = (vector 'a 'b 'c 'd)) (setf (aref v (next i)) (next i 2)) (finally (return v))) #(2 b c 5)) (deftest setf.4 (iter (generate i from 0 to 3) (with v = (vector 'a 'b 'c 'd)) (setf (apply #'aref v (list (next i))) (next i)) (finally (return v))) #(1 b 3 d)) (deftest after-each.1 (iter (after-each (collecting 0)) (generate i in '(a b c)) (adjoining (next i))) (a 0 b 0 c 0)) (deftest after-each.2 (iter (with i = 0) (while (< i 4)) (after-each (incf i)) ; the C programmer's for (;;) loop (collect i)) (0 1 2 3)) (deftest after-each.3 (iter (with i = 0) (while (< i 4)) (collect i) (after-each (incf i))) (0 1 2 3)) (deftest next-iteration.1 (iter (for i below 10) (when (oddp i) (next-iteration)) (count t)) 5) (deftest next-iteration.2 (iter (for thing in '(var &optional else &key (test #'eql))) (collect (cond ((consp thing) (first thing)) ((not (member thing lambda-list-keywords)) thing) (t (next-iteration))))) (var else test)) ;;;; tests from the documentation: (deftest collect.2 (iter (for i from 1 to 10) (collect i)) (1 2 3 4 5 6 7 8 9 10)) (deftest for-in.2 (iter (for el in '(1 2 3 4 5 6 f 7 8 9 a 10)) (if (and (numberp el) (oddp el)) (collect el))) (1 3 5 7 9)) (deftest for.destructuring.1 (iter (for (key . item) in '((a . 10) (b . 20) (c . 30))) (for i from 0) (declare (fixnum i)) (collect (cons i key))) ((0 . a) (1 . b) (2 . c))) (deftest repeat.0 (with-output-to-string (*standard-output*) (iter (repeat 100) (print "I will not talk in class."))) #.(with-output-to-string (*standard-output*) (dotimes (i 100) (declare (ignorable i)) ; cmucl/sbcl complain about (ignore i) (print "I will not talk in class.")))) ;;; for.next.1 and for.do-next.1 used to be broken in older versions; ;;; they didn't WALK their NEXT args. (deftest for.next.1 (iterate (initially (setq i 0)) (for i next (if (> i 10) (terminate) (1+ i))) (finally (return i))) 11) ;;; This gave STYLE-WARNINGS for undefined i in old versions. (deftest for.do-next.1 (iterate (initially (setq i 0)) (as i do-next (if (> i 10) (terminate) (incf i))) (finally (return i))) 11) (deftest for.do-next.2 ;; INITIALLY not needed because 0 is inferred from type declaration (iterate (for i do-next (if (> i 7) (terminate) (incf i))) (declare (type fixnum i)) (finally (return i))) 8) (deftest for.do-next.3 (iter (for a from 1 to 3) (for b = (1+ (* a a))) ;; (values ...) is supported, even though (x y) would do (for (values x y) do-next (dsetq (values x y) (floor b a))) (collect x) (collect y)) (2 0 2 1 3 1)) (deftest for.next.walk (iter (repeat 2) (for x next (progn (after-each (collect 1)) 2)) (collect x)) (2 1 2 1)) (deftest for.do-next.walk (iter (repeat 2) (for x do-next (progn (after-each (collect 1)) (dsetq x 2))) (collect x)) (2 1 2 1)) (deftest for.next.previous (iter (for i from 2 to 4) (for x next (progn (after-each (collect i)) (- i))) (for z previous x initially 0) (nconcing (list z x))) (0 -2 2 -2 -3 3 -3 -4 4)) (deftest for.do-next.previous (iter (for i from 2 to 4) (for x do-next (progn (setq x (- i)) (after-each (collect i)))) (for z previous x initially 0) (appending (list z x))) (0 -2 2 -2 -3 3 -3 -4 4)) (deftest for-nongenerator.1 (iter (for el in '(a b c d)) (generate i upfrom 1) (if el (collect (cons el (next i))))) #.(iter (for el in '(a b c d)) (for i upfrom 1) (if el (collect (cons el i))))) (deftest for.previous.in (iter (for el in '(1 2 3 4)) (for pp-el previous el back 2 initially 0) (collect pp-el)) (0 0 1 2)) (deftest for.previous.type.1 (iter (for el in '(1 2 3 4)) (declare (type integer el)) (for pp-el previous el back 2) (collect pp-el)) (0 0 1 2)) (deftest for.previous.index-of-string.1 (iter (as x index-of-string "235") (as p previous x :initially 9) (collecting p)) (9 0 1)) (deftest for.previous.in-string.with-index (iter (as x in-string "235" :with-index y) (as p previous y :initially 9) (collecting p)) (9 0 1)) (deftest for.previous.index-of-vector (iter (as x index-of-vector '#(2 3 4 5)) (as p previous x :initially 9 back 2) (collecting p)) (9 9 0 1)) (deftest for.previous.in-vector.with-index (iter (as x in-vector '#(2 3 4 5) with-index y) (as p previous y :initially 9 back 2) (collecting p)) (9 9 0 1)) (deftest for.previous.var-with-type-declaration (iter (for i from 1 to 5) (for (the fixnum i-prev) previous i) (collect i-prev)) (nil 1 2 3 4)) (deftest for.first.1 (iter (for num in '(20 19 18 17 16)) (for i first num then (1+ i)) (collect i)) (20 21 22 23 24)) (deftest for.initially.1 (iter (with (v z)) (for i initially (length v) then (1+ i)) (collect (cons i z)) (while (evenp i))) ((0) (1))) (deftest sum.1 (iter (for el in '(100 200 300)) (sum el into x) (declare (fixnum x)) (finally (return x))) 600) (deftest collect.3 (iter (for i from 1 to 5) (collect i)) (1 2 3 4 5)) (deftest collect.4 (iter (for i from 1 to 5) (collect i at beginning)) (5 4 3 2 1)) (deftest collect.5 (iter (for i from 1 to 4) (collect i at :end)) (1 2 3 4)) (deftest collect.6 (iter (for i from 1 to 3) (collect i :at start)) (3 2 1)) (deftest collect-by.1 (iter (for i downfrom 10 by 2) (repeat 3) (collect i)) (10 8 6)) (deftest in-vector.by.1 (iter (for i in-vector '#(0 1 2 3 4) by 2) (collect i)) (0 2 4)) (deftest index-of-vector.by.1 (iter (for i index-of-vector '#(0 1 2 3 4) by 2) (collect i)) (0 2 4)) (deftest in-vector.downto.1 (iter (for i in-vector '#(0 1 2 3 4) downto 0) (collect i)) (4 3 2 1 0)) (deftest index-of-vector.downto.1 (iter (for i index-of-vector #(0 1 2 3 4) downto 0) (collect i)) (4 3 2 1 0)) (deftest in-vector.downto.2 (iter (for i in-vector '#(0 1 2 3 4) downto 0 by 2) (collect i)) (4 2 0)) ; erroneously got (3 1) in some past (deftest index-of-vector.downto.2 (iter (for i index-of-vector #(0 1 2 3 4) downto 0 by 2) (collect i)) (4 2 0)) (deftest generate.in-vector.downto.1 (iter (generate i in-vector #(0 1 2 3 4) downto 0 by 2) (collect (next i))) (4 2 0)) (deftest generate.index-of-vector.downto.1 (iter (generate i index-of-vector '#(0 1 2 3 4) downto 0 by 2) (collect (next i))) (4 2 0)) (deftest if-first-time.1 (with-output-to-string (*standard-output*) (iter (for i from 200 to 203) (if-first-time (format t "honka")))) "honka") (deftest if-first-time.2 (with-output-to-string (*standard-output*) (iter (for i from 200 to 204) (if (oddp i) (if-first-time (princ "honka") (princ "tah"))))) "honkatah") (deftest if-first-time.3 (iter (for i to 5) (when (oddp i) (if-first-time nil (collect -1)) (collect i))) (1 -1 3 -1 5)) (deftest first-time-p.0 (with-output-to-string (*standard-output*) (iter (for el in '(nil 1 2 nil 3)) (when el (unless (first-time-p) (princ ", ")) (princ el)))) "1, 2, 3") (deftest first-time-p.1 (iter (for i to 5) (if (first-time-p) (collect -1)) (if (first-time-p) (collect -2)) (when (oddp i) (if (first-time-p) nil (collect -1)) (collect i))) (-1 -2 1 -1 3 -1 5)) (deftest first-iteration-p.1 (iter (for i to 5) (if (first-iteration-p) (collect -1)) (if (first-iteration-p) (collect -2)) (when (oddp i) (if (first-iteration-p) nil (collect -1)) (collect i))) (-1 -2 -1 1 -1 3 -1 5)) (deftest collect.multiple.1 (iter (for i from 1 to 10) (collect i into nums) (collect (sqrt i) into nums) (finally (return nums))) #.(loop for i from 1 to 10 collect i collect (sqrt i))) (deftest collect.type.string.1 (locally (declare (optimize safety (debug 2) (speed 0) (space 1))) (iter (declare (iterate:declare-variables)) (for s in-vector '#(\a |b| |cD|)) (collect (char (symbol-name s) 0) :result-type string))) "abc") (deftest collect.type.string.2 (iter (for c in-stream (make-string-input-stream "aBc") :using #'read-char) (when (digit-char-p c 16) (collect c :result-type string))) "aBc") (deftest collect.type.string.3 (iter (for c in-string "235" downfrom 1) (collect c into s result-type string) (finally (return s))) "32") (deftest collect.type.vector.1 (locally (declare (optimize safety (debug 2) (speed 0) (space 1))) (iter (declare (iterate:declare-variables)) (for s in-vector '#(\a |b| |cD|)) (collect (char (symbol-name s) 0) :result-type vector))) #(#\a #\b #\c)) (deftest collect.type.vector.2 (iter (for c in-vector "235" downfrom 1) (collect (digit-char-p c) :into v :result-type vector) (finally (return v))) #(3 2)) (deftest adjoin.1 (iter (for i in '("ab" "aB" "abc" "AB")) (adjoining i at :start :test #'string-equal)) ("abc" "ab")) (deftest adjoin.2 (iter (for i in '("ab" "aB" "abc" "AB")) (adjoining i at :start)) ("AB" "abc" "aB" "ab")) (deftest adjoin.3 (iter (for i in '("ab" "aB" "abc" "AB")) (adjoining i :at end #:test #'string-equal)) ("ab" "abc")) (deftest adjoin.4 (iter (for i in '("ab" "aB" "abc" "AB")) (adjoining i at :end)) ("ab" "aB" "abc" "AB")) (deftest adjoin.5 (iter (for i in '("ab" "aB" "abc" "AB")) (adjoining (string-downcase i) at :start :test #'string-equal)) ("abc" "ab")) (deftest adjoin.6 (iter (for i in '("ab" "aB" "abc" "AB")) (adjoining (string-upcase i) #:at :end test #'string=)) ("AB" "ABC")) (deftest append.1 (iter (for l on '(1 2 3)) (appending l at :start)) (3 2 3 1 2 3)) (deftest nconc.1 (iter (for l on (list 1 2 3)) (nconcing (copy-list l) at :beginning)) (3 2 3 1 2 3)) (deftest append.2 (iter (for l on '(1 2 3)) (appending l :at #:end)) (1 2 3 2 3 3)) (deftest nconc.2 (iter (for l on (list 1 2 3)) (nconcing (copy-list l) at end)) (1 2 3 2 3 3)) (deftest append.3 (iter (for l on '(1 2 3)) (appending l into x) (finally (return x))) (1 2 3 2 3 3)) (deftest nconc.3 (iter (for l on (list 1 2 3)) (nconcing (copy-list l) into x) (finally (return x))) (1 2 3 2 3 3)) (deftest append.4 (iter (for l on '(1 2 3)) (appending l into x)) nil) (deftest nconc.4 (iter (for l on (list 1 2 3)) (nconcing (copy-list l) into x)) nil) (deftest append.5 (iter (for l on '(1 2 3)) (appending l :at #:end) (collect (first l))) (1 2 3 1 2 3 2 3 3)) (deftest append.6 (iter (for l on '(1 2 3)) (appending l :at :end) (collect l)) (1 2 3 (1 2 3) 2 3 (2 3) 3 (3))) (deftest nconc.5 (iter (for l on (list 1 2 3)) (collect (first l)) (nconcing (copy-list l) at end)) (1 1 2 3 2 2 3 3 3)) (deftest union.1 (iter (for l on '(a b c)) (unioning l) (collect (first l))) (a b c a b c)) (deftest union.2 (iter (for l on '(a b c)) (collecting (first l)) (unioning l :test #'eql)) (a b c b c)) (deftest union.3 (iter (for l in-vector '#("a" "A" "aB" "ab" "AB")) (unioning (list l) :test #'string-equal)) ("a" "aB")) (deftest nunion.3 (iter (for l in-vector '#("a" "A" "aB" "ab" "AB")) (nunioning (list l) :test #'string-equal :at :start)) ("aB" "a")) (deftest value.minimize (iter (for i from 4 downto -3 by 3) (collect (minimize (* i i) into foo))) (16 1 1)) (deftest value.maximize (iter (for i from 3 to 5) (sum (maximize (- i 2) into foo))) 6) (deftest value.finding-maximizing.1 (iter (for i from 3 to 6) (adjoining (finding (* i i) maximizing #'integer-length :into foo) :test #'=)) (9 16 36)) (deftest value.finding-maximizing.2 (iter (for i from 3 to 6) (adjoining (finding (* i i) maximizing (integer-length i) :into foo) :test #'=)) (9 16)) (deftest walk.counting (iter (for i from 3 to 5) (counting (if-first-time nil t))) 2) (deftest value.counting (iter (for x in-sequence '#(nil t nil t)) (collect (counting x into foo))) (0 1 1 2)) (deftest value.adjoining (iter (for i from 3 to 5) (sum (length (adjoining i into foo)))) 6) (deftest value.collecting (iter (for i from 3 to 5) (collect (copy-list (collecting i :into foo at #:start)) :at end)) ((3) (4 3) (5 4 3))) (deftest value.accumulate (iter (for c in-string "245") (collect (accumulate (digit-char-p c) by #'+ :initial-value 0 into s) into l) (finally (return (cons s l)))) (11 2 6 11)) (deftest value.always (iter (for i from -3 downto -6 by 2) (summing (always i) into x) (finally (return x))) -8) (deftest dotted.1 (iter (for l on '(1 2 . 3)) (collect l)) ((1 2 . 3) (2 . 3))) (deftest dotted.2 (iter (for (e) on '(1 2 . 3)) (collect e)) (1 2)) (deftest dotted.3 (values (ignore-errors (iter (for i in '(1 2 . 3)) (count t)))) nil) (deftest dotted.4 (iter (for i in '(1 1 2 3 . 3)) (thereis (evenp i))) t) (deftest dotted.5 (iter (for i in '(1 2 . 3)) (thereis (evenp i))) t) (deftest walk.multiple-value-bind (string-upcase (iter (for name in-vector (vector 'iterate "FoOBaRzOt" '#:repeat)) (multiple-value-bind (sym access) (find-symbol (string name) #.*package*) (declare (type symbol sym)) (collect (if access (char (symbol-name sym) 0) #\-) result-type string)))) "I-R") (deftest subblocks.1 (iter fred (for i from 1 to 10) (iter barney (for j from i to 10) (if (> (* i j) 17) (return-from fred j)))) 9) (deftest subblocks.wrong.1 (let ((ar #2a((1 2 3) (4 5 6) (7 8 9)))) (iter (for i below (array-dimension ar 0)) (iter (for j below (array-dimension ar 1)) (collect (aref ar i j))))) nil) (deftest subblocks.2 (let ((ar #2a((1 2 3) (4 5 6) (7 8 9)))) (iter outer (for i below (array-dimension ar 0)) (iter (for j below (array-dimension ar 1)) (in outer (collect (aref ar i j)))))) (1 2 3 4 5 6 7 8 9)) (deftest destructuring.1 (iter (for (values (a . b) c) = (funcall #'(lambda () (values (cons 1 'b) 2)))) (leave (list a b c))) (1 b 2)) (deftest leave (iter (for x in '(1 2 3)) (if (evenp x) (leave x)) (finally (error "not found"))) 2) (deftest lambda (iter (for i index-of-sequence "ab") (collecting ((lambda(n) (cons 1 n)) i))) ((1 . 0) (1 . 1))) (deftest type.1 (iter (for el in '(1 2 3 4 5)) (declare (fixnum el)) (counting (oddp el))) 3) (deftest type.2 (iter (for (the fixnum el) in '(1 2 3 4 5)) (counting (oddp el))) 3) (deftest type.3 (iter (declare (iterate:declare-variables)) (for el in '(1 2 3 4 5)) (count (oddp el) into my-result) (declare (integer my-result)) (finally (return my-result))) 3) (deftest type.4 (iter (declare (iterate:declare-variables)) (for i from 1 to 10) (collect i)) (1 2 3 4 5 6 7 8 9 10)) (deftest type.5 (iter (declare (iterate:declare-variables)) (repeat 0) (minimize (the fixnum '1))) 0) (deftest type.6 (iter (declare (iterate:declare-variables)) (repeat 0) (maximize 1)) 0) (deftest type.7 (iter (declare (iterate:declare-variables)) (repeat 0) (minimize (the double-float '1.0d0))) 0.0d0) (deftest static.error.1 (values (ignore-errors ; Iterate complains multiple values make no sense here (macroexpand-1 '(iter (for (values a b) in '(1 2 3)))) t)) nil) (deftest code-movement.1 (handler-case (macroexpand ' (iter (for i from 1 to 10) (let ((x 3)) (initially (setq x 4)) (return x)))) (error () t) (:no-error (f x) (declare (ignore f x)) nil)) t) (deftest code-movement.2 (handler-case (macroexpand ' (iter (for i from 1 to 10) (let ((x 3)) (collect i into x)))) (error () t) (:no-error (f x) (declare (ignore f x)) nil)) t) (deftest code-movement.3 (iter (with x = 3) (for el in '(0 1 2 3)) (setq x 1) (reducing el by #'+ initial-value x)) 9 ; not 7 ) (deftest code-movement.else (handler-case (macroexpand ' (iter (for i from 1 to 10) (let ((x 3)) (else (return x))))) (error () t) (:no-error (f x) (declare (ignore f x)) nil)) t) (deftest code-movement.after-each (handler-case (macroexpand ' (iter (for i from 1 to 10) (let ((y i)) (after-each (princ y))))) (error () t) (:no-error (f x) (declare (ignore f x)) nil)) t) (deftest code-movement.declare.1 (handler-case (macroexpand ' (iter (for i from 1 to 10) (let ((y i)) (declare (optimize safety)) (after-each (princ y))))) (error () t) (:no-error (f x) (declare (ignore f x)) nil)) t) (deftest code-movement.declare.2 (handler-case (macroexpand ' (iter (for i from 1 to 10) (let ((safety i)) (after-each (let () (declare (optimize safety)) (princ i)))))) (error () t) (:no-error (f x) (declare (ignore f x)) nil)) nil) (deftest code-movement.locally.1 (handler-case (macroexpand ' (iter (for i from 1 to 10) (let ((y i)) (else (locally (princ y)))))) (error () t) (:no-error (f x) (declare (ignore f x)) nil)) t) (deftest code-movement.locally.2 (handler-case (macroexpand ' (iter (for i from 1 to 10) (let ((y i)) (else (locally (princ i)))))) (error () t) (:no-error (f x) (declare (ignore f x)) nil)) nil) (deftest code-movement.initially (handler-case (macroexpand ' (iter (for i from 1 to 10) (let ((y i)) (initially (princ y))))) (error () t) (:no-error (f x) (declare (ignore f x)) nil)) t) (deftest code-movement.finally (handler-case (macroexpand ' (iter (for i from 1 to 10) (let ((y i)) (finally (return y))))) (error () t) (:no-error (f x) (declare (ignore f x)) nil)) t) (deftest code-movement.finally-protected (handler-case (macroexpand ' (iter (for i from 1 to 10) (let ((y i)) (finally-protected (return y))))) (error () t) (:no-error (f x) (declare (ignore f x)) nil)) t) (deftest static.conflict.1 (handler-case (macroexpand ' (iter (for i from 1 to 10) (collect i) (sum i))) (error () t) (:no-error (f x) (declare (ignore f x)) nil)) t) ;;; 2005: I'm considering making this shadowing feature unspecified (and ;;; removing the test), because it takes away implementation freedom of ;;; choosing to reimplement Iterate's own clauses via macrolet or defmacro. (deftest macro.shadow.clause (macrolet ((multiply (expr) `(reducing ,expr :by #'+ :initial-value 0))) (iter (for el in '(1 2 3 4)) (multiply el))) 10) (deftest multiply.1 (iter (for el in '(1 2 3 4)) (multiply el)) 24) (defmacro sum-of-squares (expr) (let ((temp (gensym))) `(let ((,temp ,expr)) (sum (* ,temp ,temp))))) (deftest sum-of-squares.1 (iter (for el in '(1 2 3)) (sum-of-squares el)) 14) (deftest defmacro-clause.1 (defmacro-clause (multiply.clause expr &optional INTO var) "from testsuite" `(reducing ,expr by #'* into ,var initial-value 1)) ;; A better return value would be the exact list usable with remove-clause ;; The next version shall do that (multiply.clause expr &optional INTO var)) (deftest multiply.clause (iter (for el in '(1 2 3 4)) (multiply.clause el)) 24) (deftest remove-clause.1 (iter::remove-clause '(multiply.clause &optional INTO)) t) (deftest remove-clause.2 (values (ignore-errors (iter::remove-clause '(multiply.clause &optional INTO)))) nil) (iter:defmacro-clause (for var IN-WHOLE-VECTOR.clause v) "All the elements of a vector (disregards fill-pointer)" (let ((vect (gensym "VECTOR")) (index (gensym "INDEX"))) `(progn (with ,vect = ,v) (for ,index from 0 below (array-dimension ,vect 0)) (for ,var = (aref ,vect ,index))))) (deftest in-whole-vector.clause (iter (for i IN-WHOLE-VECTOR.clause (make-array 3 :fill-pointer 2 :initial-contents '(1 2 3))) (collect i)) (1 2 3)) (deftest in-vector.fill-pointer (iter (for i in-vector (make-array 3 :fill-pointer 2 :initial-contents '(1 2 3))) (collect i)) (1 2)) (iter:defmacro-driver (for var IN-WHOLE-VECTOR v) "All the elements of a vector (disregards fill-pointer)" (let ((vect (gensym "VECTOR")) (end (gensym "END")) (index (gensym "INDEX")) (kwd (if iter:generate 'generate 'for))) `(progn (with ,vect = ,v) (with ,end = (array-dimension ,vect 0)) (with ,index = -1) (,kwd ,var next (progn (incf ,index) (if (>= ,index ,end) (terminate)) (aref ,vect ,index)))))) (deftest in-whole-vector.driver (iter (for i IN-WHOLE-VECTOR (make-array '(3) :fill-pointer 2 :initial-contents '(1 2 3))) (collect i)) (1 2 3)) (deftest in-whole-vector.generate (iter (generating i IN-WHOLE-VECTOR (make-array '(3) :fill-pointer 2 :initial-contents '(1 2 3))) (collect (next i))) (1 2 3)) (deftest defclause-sequence (progn (iter:defclause-sequence IN-WHOLE-VECTOR.seq INDEX-OF-WHOLE-VECTOR :access-fn 'aref :size-fn '#'(lambda (v) (array-dimension v 0)) :sequence-type 'vector :element-type t :element-doc-string "Elements of a vector, disregarding fill-pointer" :index-doc-string "Indices of vector, disregarding fill-pointer") t) t) (deftest in-whole-vector.seq (iter (for i IN-WHOLE-VECTOR.seq (make-array '(3) :fill-pointer 2 :initial-contents '(1 2 3))) (collect i)) (1 2 3)) (deftest in-whole-vector.seq.index (iter (for i INDEX-OF-WHOLE-VECTOR (make-array 3 :fill-pointer 2 :initial-contents '(1 2 3))) (for j previous i :initially 9) (collect (list j i))) ((9 0)(0 1)(1 2))) (deftest in-whole-vector.seq.with-index (iter (for e IN-WHOLE-VECTOR.seq (make-array '(3) :fill-pointer 2 :initial-contents '(a b c)) :with-index i) (for j previous i :initially 9) (collect (list j i e))) ((9 0 a)(0 1 b)(1 2 c))) (deftest in-whole-vector.seq.generate (iter (generate e IN-WHOLE-VECTOR.seq (make-array 3 :fill-pointer 2 :initial-contents '(a b c)) :with-index i) (collect (list (next e) e i))) ((a a 0) (b b 1) (c c 2))) ;; The original example had three bugs: ;; - ,expr and ,func occured twice in expansion ;; - (finally (leave ,winner)) breaks because FINALLY does not walk ;; its forms, so LEAVE does not work inside FINALLY. ;; - Do not use (finally (RETURN ,winner)) either, as that would ;; always return accumulated value, even in case of ... INTO nil. (deftest defmacro-clause.2 (defmacro-clause (FINDING expr MAXING func &optional INTO var) "Iterate paper demo example" (let ((max-val (gensym "MAX-VAL")) (temp1 (gensym "EL")) (temp2 (gensym "VAL")) (winner (or var iterate::*result-var*))) `(progn (with ,max-val = nil) (with ,winner = nil) (let* ((,temp1 ,expr) (,temp2 (funcall ,func ,temp1))) (when (or (null ,max-val) (> ,temp2 ,max-val)) (setq ,winner ,temp1 ,max-val ,temp2))) #|(finally (return ,winner))|# ))) (FINDING expr MAXING func &optional INTO var)) (deftest maxing.1 (iter (for i in-vector #(1 5 3)) (finding i :maxing #'identity)) 5) (deftest maxing.2 (iter (for i in-vector #(1 5 3)) (finding i maxing #'identity into foo)) nil) (deftest maxing.3 (iter (for i in-vector #(2 5 4)) (finding i maxing #'identity into foo) (when (evenp i) (sum i))) 6) (deftest display.1 (let ((*standard-output* (make-broadcast-stream))) (display-iterate-clauses) t) t) (deftest display.2 (let ((*standard-output* (make-broadcast-stream))) (display-iterate-clauses 'for) t) t) (deftest multiple-value-prog1.1 (iter (for x in '(a b c)) (collect (multiple-value-prog1 7))) (7 7 7)) (deftest ignore-errors.1 (iter (for x in '(a b c)) (collect (ignore-errors x))) (a b c)) (deftest ignore-errors.2 (iter (generate x in '(a b c)) (collect (ignore-errors (next x)))) (a b c)) (deftest handler-bind.1 (iter (for i from -1 to 2 by 2) (handler-bind ((error (lambda(c) c nil))) (collect i))) (-1 1)) (deftest destructuring-bind.1 ;; One version of Iterate would enter endless loop in ACL 7 and SBCL ;; reported by Julian Stecklina in early 2005 (null (macroexpand '(iter (for index in '((1 2))) (collect (destructuring-bind (a b) index (+ a b)))))) nil) (deftest destructuring-bind.2 (iter (for index in '((1 2))) (collect (destructuring-bind (a b) index (+ a b)))) (3)) (deftest symbol-macrolet (iter (for i from -1 downto -3) (symbol-macrolet ((x (* i i))) (declare (optimize debug)) (sum x))) 14) (defclass polar () ((rho :initarg :mag) (theta :initform 0 :accessor angle))) (deftest with-slots (iter (with v = (vector (make-instance 'polar :mag 2))) (for x in-sequence v) (with-slots (rho) x (multiplying rho))) 2) (deftest with-accessors (iter (with v = (vector (make-instance 'polar :mag 1))) (for x in-sequence v) (with-accessors ((alpha angle)) x (incf alpha 2) (summing alpha))) 2) ;;; Tests for bugs. ;; when these start failing, I have done something right (-: ;; The walker ignores function bindings, ;; therefore shadowing is not handled correctly. (deftest bug/walk.1 (macrolet ((over(x) `(collect ,x))) (iter (for i in '(1 2 3)) (flet ((over(x)(declare (ignore x)) (collect 1))) (over i)))) ; would yield (1 1 1) if correct (1 2 3)) (deftest bug/walk.2 (iter (return (if (oddp 1) (progn) 'even))) ;; The bug is in emtpy PROGN walking. Due to that the THEN branch is lost ;; and it returns 'EVEN instead of NIL. nil) (deftest bug/macrolet.2 (progn (format *error-output* "~&Note: These tests generate warnings ~ involving MACROLET within Iterate~%") (values (ignore-errors ; would yield 1 if correct (iterate (repeat 10) (macrolet ((foo () 1)) (multiplying (foo))))))) nil) (deftest macrolet.3 (iterate (repeat 2) (multiplying (macrolet ((foo () 1)) (foo)))) 1) (deftest bug/collect-at-beginning (iterate (for i from 1 to 10) (if (oddp i) (collect i :at :beginning) (collect i))) (9 7 5 3 1 2 4 6 8 10)) ;; Hashtable iterators are specified to be defined as macrolets. ;; But we handle these by special-casing with-hash-table/package-iterator (deftest nested-hashtable.1 (let ((ht1 (make-hash-table)) (ht2 (make-hash-table))) (setup-hash-table ht2) (setf (gethash 'a ht1) ht2) (= (hash-table-count ht2) (length (iter outer (for (k1 v1) in-hashtable ht1) (iter (for (k2 v2) in-hashtable ht2) (in outer (collect k2))))))) t) (deftest nested.in-hashtable.2 ;; Here the inner macrolet code does not affect the outer iteration (let ((ht1 (make-hash-table)) (ht2 (make-hash-table))) (setup-hash-table ht2) (setf (gethash 'a ht1) ht2) (iter (for (k1 v1) in-hashtable ht1) (counting (iter (for (k2 nil) in-hashtable ht2) (count k2))))) 1) (deftest nested.in-hashtable.3 (let ((ht1 (make-hash-table)) (ht2 (make-hash-table))) (setup-hash-table ht2) (setf (gethash 'a ht1) ht2) (iter (for (k1 v1) in-hashtable ht1) (progn (iter (for (nil v2) in-hashtable v1) (count v2)) (collect k1)))) (a)) (deftest nested.in-package (< 6 (print (iter (for scl in-package '#:iterate :external-only t) (count ; Iterate exports ~50 symbols (iter (for si in-package #.*package*) (thereis (eq si scl)))))) 80) t) (deftest macrolet.loop-finish (iter (for l on *an-alist*) (loop for e in l when (equal (car e) 'zero) do (loop-finish))) nil) ;; Misc tests to make sure that bugs don't reappear (defmacro problem-because-i-return-nil (&rest args) (declare (ignore args)) nil) (deftest tagbody.nil-tags ;; Allegro (correctly) won't compile when a tag (typically NIL) is used more than once in a tagbody. (labels ((find-tagbody (form) (cond ((and (consp form) (eq (first form) 'tagbody)) form) ((consp form) (iter (for x in (rest form)) (thereis (find-tagbody x)))) (t nil))) (all-tagbody-tags (form) (iter (for tag-or-form in (rest (find-tagbody form))) (when (symbolp tag-or-form) (collect tag-or-form))))) (let* ((form (macroexpand ' (iter (for x in '(1 2 3)) (problem-because-i-return-nil) (+ x x) (problem-because-i-return-nil)))) (tags (all-tagbody-tags form))) (iter (for tag in tags) ;; invoke cl:count, not the Iterate clause: (always (= 1 (funcall #'count tag tags :from-end nil)))))) t) (deftest walk.tagbody.1 (iter (tagbody (problem-because-i-return-nil) 3 (problem-because-i-return-nil) (leave 2))) 2) (deftest walk.tagbody.2 (symbol-macrolet ((error-out (error "do not expand me"))) (iter (tagbody error-out (leave 2)))) 2) ;;; eof iterate-20160825-darcs/package.lisp0000644000000000000000000000242612757566717015217 0ustar0000000000000000;;; Some of the 7 extremely random interface commands ;;; got replaced by defpackage. ;;; Use uninterned symbols here so that: ;;; 1. there's no iterate symbol in package USER. ;;; 2. it may work in case-sensitive mode/packages. (defpackage #:iterate (:use #:cl) (:nicknames #:iter) (:export #:iterate #:iter #:display-iterate-clauses #:defsynonym #:dsetq #:declare-variables #:defmacro-clause #:defmacro-driver #:defclause-sequence #:initially #:after-each #:finally #:finally-protected #:else #:if-first-time #:first-iteration-p #:first-time-p #:finish #:leave #:next-iteration #:next #:terminate #:repeat #:for #:as #:generate #:generating #:in #:sum #:summing #:multiply #:multiplying #:maximize #:minimize #:maximizing #:minimizing #:counting #:always #:never #:thereis #:finding #:collect #:collecting #:with #:while #:until #:adjoining #:nconcing #:appending #:nunioning #:unioning #:reducing #:accumulate #:accumulating)) (in-package #:iterate) ;;; work around sbcl's obnoxious standard compliance (defmacro defconst (name value &optional doc) `(eval-when (:compile-toplevel :load-toplevel :execute) (unless (boundp ',name) ,(if doc `(defconstant ,name ,value ,doc) `(defconstant ,name ,value))))) iterate-20160825-darcs/doc/0000755000000000000000000000000012757566717013474 5ustar0000000000000000iterate-20160825-darcs/doc/Makefile0000644000000000000000000000345312757566717015141 0ustar0000000000000000# -*- Mode: Makefile; tab-width: 4; indent-tabs-mode: t -*- # # Makefile --- Make targets for generating the documentation. # # Copyright (C) 2005-2006, Luis Oliveira # # Permission is hereby granted, free of charge, to any person # obtaining a copy of this software and associated documentation # files (the "Software"), to deal in the Software without # restriction, including without limitation the rights to use, copy, # modify, merge, publish, distribute, sublicense, and/or sell copies # of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be # included in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT # HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, # WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # all: docs docs: sh gendocs.sh -o manual --html "--css-include=style.css" iterate "The Iterate Manual" clean: find . \( -name "*.info" -o -name "*.aux" -o -name "*.cp" -o -name "*.fn" -o -name "*.fns" -o -name "*.ky" -o -name "*.log" -o -name "*.pg" -o -name "*.toc" -o -name "*.tp" -o -name "*.vr" -o -name "*.dvi" -o -name "*.cps" -o -name "*.vrs" \) -exec rm {} \; rm -rf manual upload-docs: rsync -av --delete -e ssh manual common-lisp.net:/project/iterate/public_html/ # scp -r manual spec common-lisp.net:/project/cells/public_html/ # vim: ft=make ts=4 noet iterate-20160825-darcs/doc/gendocs.sh0000644000000000000000000002306212757566717015455 0ustar0000000000000000#!/bin/sh # gendocs.sh -- generate a GNU manual in many formats. This script is # mentioned in maintain.texi. See the help message below for usage details. # $Id: gendocs.sh,v 1.17 2006/05/19 00:07:52 karl Exp $ # # Copyright (C) 2003, 2004, 2005, 2006 Free Software Foundation, Inc. # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2, or (at your option) # any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, you can either send email to this # program's maintainer or write to: The Free Software Foundation, # Inc.; 51 Franklin Street, Fifth Floor; Boston, MA 02110-1301, USA. # # Original author: Mohit Agarwal. # Send bug reports and any other correspondence to bug-texinfo@gnu.org. prog=`basename "$0"` srcdir=`pwd` scripturl="http://savannah.gnu.org/cgi-bin/viewcvs/~checkout~/texinfo/texinfo/util/gendocs.sh" templateurl="http://savannah.gnu.org/cgi-bin/viewcvs/~checkout~/texinfo/texinfo/util/gendocs_template" : ${MAKEINFO="makeinfo"} : ${TEXI2DVI="texi2dvi -t @finalout"} : ${DVIPS="dvips"} : ${DOCBOOK2TXT="docbook2txt"} : ${DOCBOOK2HTML="docbook2html"} : ${DOCBOOK2PDF="docbook2pdf"} : ${DOCBOOK2PS="docbook2ps"} : ${GENDOCS_TEMPLATE_DIR="."} unset CDPATH rcs_revision='$Revision: 1.17 $' rcs_version=`set - $rcs_revision; echo $2` program=`echo "$0" | sed -e 's!.*/!!'` version="gendocs.sh $rcs_version Copyright (C) 2006 Free Software Foundation, Inc. There is NO warranty. You may redistribute this software under the terms of the GNU General Public License. For more information about these matters, see the files named COPYING." usage="Usage: $prog [OPTION]... PACKAGE MANUAL-TITLE Generate various output formats from PACKAGE.texinfo (or .texi or .txi) source. See the GNU Maintainers document for a more extensive discussion: http://www.gnu.org/prep/maintain_toc.html Options: -o OUTDIR write files into OUTDIR, instead of manual/. --docbook convert to DocBook too (xml, txt, html, pdf and ps). --html ARG pass indicated ARG to makeinfo for HTML targets. --help display this help and exit successfully. --version display version information and exit successfully. Simple example: $prog emacs \"GNU Emacs Manual\" Typical sequence: cd YOURPACKAGESOURCE/doc wget \"$scripturl\" wget \"$templateurl\" $prog YOURMANUAL \"GNU YOURMANUAL - One-line description\" Output will be in a new subdirectory \"manual\" (by default, use -o OUTDIR to override). Move all the new files into your web CVS tree, as explained in the Web Pages node of maintain.texi. MANUAL-TITLE is included as part of the HTML of the overall manual/index.html file. It should include the name of the package being documented. manual/index.html is created by substitution from the file $GENDOCS_TEMPLATE_DIR/gendocs_template. (Feel free to modify the generic template for your own purposes.) If you have several manuals, you'll need to run this script several times with different YOURMANUAL values, specifying a different output directory with -o each time. Then write (by hand) an overall index.html with links to them all. You can set the environment variables MAKEINFO, TEXI2DVI, and DVIPS to control the programs that get executed, and GENDOCS_TEMPLATE_DIR to control where the gendocs_template file is looked for. Email bug reports or enhancement requests to bug-texinfo@gnu.org. " calcsize() { size=`ls -ksl $1 | awk '{print $1}'` echo $size } outdir=manual html= PACKAGE= MANUAL_TITLE= while test $# -gt 0; do case $1 in --help) echo "$usage"; exit 0;; --version) echo "$version"; exit 0;; -o) shift; outdir=$1;; --docbook) docbook=yes;; --html) shift; html=$1;; -*) echo "$0: Unknown or ambiguous option \`$1'." >&2 echo "$0: Try \`--help' for more information." >&2 exit 1;; *) if test -z "$PACKAGE"; then PACKAGE=$1 elif test -z "$MANUAL_TITLE"; then MANUAL_TITLE=$1 else echo "$0: extra non-option argument \`$1'." >&2 exit 1 fi;; esac shift done if test -s "$srcdir/$PACKAGE.texinfo"; then srcfile=$srcdir/$PACKAGE.texinfo elif test -s "$srcdir/$PACKAGE.texi"; then srcfile=$srcdir/$PACKAGE.texi elif test -s "$srcdir/$PACKAGE.txi"; then srcfile=$srcdir/$PACKAGE.txi else echo "$0: cannot find .texinfo or .texi or .txi for $PACKAGE in $srcdir." >&2 exit 1 fi if test ! -r $GENDOCS_TEMPLATE_DIR/gendocs_template; then echo "$0: cannot read $GENDOCS_TEMPLATE_DIR/gendocs_template." >&2 echo "$0: it is available from $templateurl." >&2 exit 1 fi echo Generating output formats for $srcfile cmd="${MAKEINFO} -o $PACKAGE.info \"$srcfile\"" echo "Generating info files... ($cmd)" eval "$cmd" mkdir -p $outdir/ tar czf $outdir/$PACKAGE.info.tar.gz $PACKAGE.info* info_tgz_size=`calcsize $outdir/$PACKAGE.info.tar.gz` # do not mv the info files, there's no point in having them available # separately on the web. cmd="${TEXI2DVI} \"$srcfile\"" echo "Generating dvi ... ($cmd)" eval "$cmd" # now, before we compress dvi: echo Generating postscript... ${DVIPS} $PACKAGE -o gzip -f -9 $PACKAGE.ps ps_gz_size=`calcsize $PACKAGE.ps.gz` mv $PACKAGE.ps.gz $outdir/ # compress/finish dvi: gzip -f -9 $PACKAGE.dvi dvi_gz_size=`calcsize $PACKAGE.dvi.gz` mv $PACKAGE.dvi.gz $outdir/ cmd="${TEXI2DVI} --pdf \"$srcfile\"" echo "Generating pdf ... ($cmd)" eval "$cmd" pdf_size=`calcsize $PACKAGE.pdf` mv $PACKAGE.pdf $outdir/ cmd="${MAKEINFO} -o $PACKAGE.txt --no-split --no-headers \"$srcfile\"" echo "Generating ASCII... ($cmd)" eval "$cmd" ascii_size=`calcsize $PACKAGE.txt` gzip -f -9 -c $PACKAGE.txt >$outdir/$PACKAGE.txt.gz ascii_gz_size=`calcsize $outdir/$PACKAGE.txt.gz` mv $PACKAGE.txt $outdir/ cmd="${MAKEINFO} --no-split --html -o $PACKAGE.html $html \"$srcfile\"" echo "Generating monolithic html... ($cmd)" rm -rf $PACKAGE.html # in case a directory is left over eval "$cmd" html_mono_size=`calcsize $PACKAGE.html` gzip -f -9 -c $PACKAGE.html >$outdir/$PACKAGE.html.gz html_mono_gz_size=`calcsize $outdir/$PACKAGE.html.gz` mv $PACKAGE.html $outdir/ cmd="${MAKEINFO} --html -o $PACKAGE.html $html \"$srcfile\"" echo "Generating html by node... ($cmd)" eval "$cmd" split_html_dir=$PACKAGE.html ( cd ${split_html_dir} || exit 1 tar -czf ../$outdir/${PACKAGE}.html_node.tar.gz -- *.html ) html_node_tgz_size=`calcsize $outdir/${PACKAGE}.html_node.tar.gz` rm -f $outdir/html_node/*.html mkdir -p $outdir/html_node/ mv ${split_html_dir}/*.html $outdir/html_node/ rmdir ${split_html_dir} echo Making .tar.gz for sources... srcfiles=`ls *.texinfo *.texi *.txi *.eps 2>/dev/null` tar cvzfh $outdir/$PACKAGE.texi.tar.gz $srcfiles texi_tgz_size=`calcsize $outdir/$PACKAGE.texi.tar.gz` if test -n "$docbook"; then cmd="${MAKEINFO} -o - --docbook \"$srcfile\" > ${srcdir}/$PACKAGE-db.xml" echo "Generating docbook XML... $(cmd)" eval "$cmd" docbook_xml_size=`calcsize $PACKAGE-db.xml` gzip -f -9 -c $PACKAGE-db.xml >$outdir/$PACKAGE-db.xml.gz docbook_xml_gz_size=`calcsize $outdir/$PACKAGE-db.xml.gz` mv $PACKAGE-db.xml $outdir/ cmd="${DOCBOOK2HTML} -o $split_html_db_dir ${outdir}/$PACKAGE-db.xml" echo "Generating docbook HTML... ($cmd)" eval "$cmd" split_html_db_dir=html_node_db ( cd ${split_html_db_dir} || exit 1 tar -czf ../$outdir/${PACKAGE}.html_node_db.tar.gz -- *.html ) html_node_db_tgz_size=`calcsize $outdir/${PACKAGE}.html_node_db.tar.gz` rm -f $outdir/html_node_db/*.html mkdir -p $outdir/html_node_db mv ${split_html_db_dir}/*.html $outdir/html_node_db/ rmdir ${split_html_db_dir} cmd="${DOCBOOK2TXT} ${outdir}/$PACKAGE-db.xml" echo "Generating docbook ASCII... ($cmd)" eval "$cmd" docbook_ascii_size=`calcsize $PACKAGE-db.txt` mv $PACKAGE-db.txt $outdir/ cmd="${DOCBOOK2PS} ${outdir}/$PACKAGE-db.xml" echo "Generating docbook PS... $(cmd)" eval "$cmd" gzip -f -9 -c $PACKAGE-db.ps >$outdir/$PACKAGE-db.ps.gz docbook_ps_gz_size=`calcsize $outdir/$PACKAGE-db.ps.gz` mv $PACKAGE-db.ps $outdir/ cmd="${DOCBOOK2PDF} ${outdir}/$PACKAGE-db.xml" echo "Generating docbook PDF... ($cmd)" eval "$cmd" docbook_pdf_size=`calcsize $PACKAGE-db.pdf` mv $PACKAGE-db.pdf $outdir/ fi echo Writing index file... curdate=`date '+%B %d, %Y'` sed \ -e "s!%%TITLE%%!$MANUAL_TITLE!g" \ -e "s!%%DATE%%!$curdate!g" \ -e "s!%%PACKAGE%%!$PACKAGE!g" \ -e "s!%%HTML_MONO_SIZE%%!$html_mono_size!g" \ -e "s!%%HTML_MONO_GZ_SIZE%%!$html_mono_gz_size!g" \ -e "s!%%HTML_NODE_TGZ_SIZE%%!$html_node_tgz_size!g" \ -e "s!%%INFO_TGZ_SIZE%%!$info_tgz_size!g" \ -e "s!%%DVI_GZ_SIZE%%!$dvi_gz_size!g" \ -e "s!%%PDF_SIZE%%!$pdf_size!g" \ -e "s!%%PS_GZ_SIZE%%!$ps_gz_size!g" \ -e "s!%%ASCII_SIZE%%!$ascii_size!g" \ -e "s!%%ASCII_GZ_SIZE%%!$ascii_gz_size!g" \ -e "s!%%TEXI_TGZ_SIZE%%!$texi_tgz_size!g" \ -e "s!%%DOCBOOK_HTML_NODE_TGZ_SIZE%%!$html_node_db_tgz_size!g" \ -e "s!%%DOCBOOK_ASCII_SIZE%%!$docbook_ascii_size!g" \ -e "s!%%DOCBOOK_PS_GZ_SIZE%%!$docbook_ps_gz_size!g" \ -e "s!%%DOCBOOK_PDF_SIZE%%!$docbook_pdf_size!g" \ -e "s!%%DOCBOOK_XML_SIZE%%!$docbook_xml_size!g" \ -e "s!%%DOCBOOK_XML_GZ_SIZE%%!$docbook_xml_gz_size!g" \ -e "s,%%SCRIPTURL%%,$scripturl,g" \ -e "s!%%SCRIPTNAME%%!$prog!g" \ $GENDOCS_TEMPLATE_DIR/gendocs_template >$outdir/index.html echo "Done! See $outdir/ subdirectory for new files." ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������iterate-20160825-darcs/doc/style.css����������������������������������������������������������������0000644�0000000�0000000�00000005163�12757566717�015353� 0����������������������������������������������������������������������������������������������������ustar�00����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������body {font-family: century schoolbook, serif; line-height: 1.3; padding-left: 5em; padding-right: 1em; padding-bottom: 1em; max-width: 60em;} table {border-collapse: collapse} span.roman { font-family: century schoolbook, serif; font-weight: normal; } h1, h2, h3, h4, h5, h6 {font-family: Helvetica, sans-serif} /*h4 {padding-top: 0.75em;}*/ dfn {font-family: inherit; font-variant: italic; font-weight: bolder } kbd {font-family: monospace; text-decoration: underline} /*var {font-family: Helvetica, sans-serif; font-variant: slanted}*/ var {font-variant: slanted;} td {padding-right: 1em; padding-left: 1em} sub {font-size: smaller} .node {padding: 0; margin: 0} .lisp { font-family: monospace; background-color: #F4F4F4; border: 1px solid #AAA; padding-top: 0.5em; padding-bottom: 0.5em; } /* coloring */ .lisp-bg { background-color: #F4F4F4 ; color: black; } .lisp-bg:hover { background-color: #F4F4F4 ; color: black; } .symbol { font-weight: bold; color: #770055; background-color : transparent; border: 0px; margin: 0px;} a.symbol:link { font-weight: bold; color : #229955; background-color : transparent; text-decoration: none; border: 0px; margin: 0px; } a.symbol:active { font-weight: bold; color : #229955; background-color : transparent; text-decoration: none; border: 0px; margin: 0px; } a.symbol:visited { font-weight: bold; color : #229955; background-color : transparent; text-decoration: none; border: 0px; margin: 0px; } a.symbol:hover { font-weight: bold; color : #229955; background-color : transparent; text-decoration: none; border: 0px; margin: 0px; } .special { font-weight: bold; color: #FF5000; background-color: inherit; } .keyword { font-weight: bold; color: #770000; background-color: inherit; } .comment { font-weight: normal; color: #007777; background-color: inherit; } .string { font-weight: bold; color: #777777; background-color: inherit; } .character { font-weight: bold; color: #0055AA; background-color: inherit; } .syntaxerror { font-weight: bold; color: #FF0000; background-color: inherit; } span.paren1 { font-weight: bold; color: #777777; } span.paren1:hover { color: #777777; background-color: #BAFFFF; } span.paren2 { color: #777777; } span.paren2:hover { color: #777777; background-color: #FFCACA; } span.paren3 { color: #777777; } span.paren3:hover { color: #777777; background-color: #FFFFBA; } span.paren4 { color: #777777; } span.paren4:hover { color: #777777; background-color: #CACAFF; } span.paren5 { color: #777777; } span.paren5:hover { color: #777777; background-color: #CAFFCA; } span.paren6 { color: #777777; } span.paren6:hover { color: #777777; background-color: #FFBAFF; } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������iterate-20160825-darcs/doc/gendocs_template���������������������������������������������������������0000644�0000000�0000000�00000013151�12757566717�016735� 0����������������������������������������������������������������������������������������������������ustar�00����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<?xml version="1.0" encoding="utf-8" ?> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> <!-- $Id: gendocs_template,v 1.7 2005/05/15 00:00:08 karl Exp $ --> <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en"> <!-- This template was adapted from Texinfo: http://savannah.gnu.org/cgi-bin/viewcvs/texinfo/texinfo/util/gendocs_template --> <head> <title>%%TITLE%%

%%TITLE%%

last updated %%DATE%%

This document is available in the following formats:

(This page was generated by the %%SCRIPTNAME%% script.)

Return to Iterate's home page.

Updated: %%DATE%%

iterate-20160825-darcs/doc/iterate.texinfo0000644000000000000000000031634412757566717016542 0ustar0000000000000000\input texinfo @c -*- Mode: Texinfo; Mode: auto-fill -*- @c %**start of header @setfilename iterate.info @settitle The Iterate Manual and Paper @exampleindent 2 @c @documentencoding utf-8 @macro iter {} @code{iterate} @end macro @macro mathx {tex, non-tex} @iftex @math{\tex\} @end iftex @ifnottex @emph{\non-tex\} @end ifnottex @end macro @macro impnote {text} @quotation Implementor's note @emph{\text\} @end quotation @end macro @c Set ROMANCOMMENTS to get comments in roman font. @ifset ROMANCOMMENTS @alias lispcmt = r @end ifset @ifclear ROMANCOMMENTS @alias lispcmt = asis @end ifclear @c Index for iterate clauses. @defindex it @macro clauseu {name1} @itindex \name1\ @c @end macro @macro claused {name1, name2} @itindex \name1\@dots{}\name2\ @c @end macro @macro clauset {name1, name2, name3} @itindex \name1\@dots{}\name2\@dots{}\name3\ @c @end macro @macro k {what} @code{\what\} @end macro @iftex @alias v = asis @alias cl = code @end iftex @ifnottex @alias v = var @alias cl = strong @end ifnottex @c Show variables, clauses, and concepts in the same index. @syncodeindex it cp @syncodeindex vr cp @copying Copyright @copyright{} 1989 Jonathan Amsterdam @* @c Copyright @copyright{} 2006 Lu@'{@dotless{i}}s Oliveira @c @* @quotation The present manual is a conversion of Jonathan Amsterdam's ``The Iterate Manual'', @acronym{MIT} @acronym{AI} Memo No.@: 1236. Said memo mentioned the following contract information: @emph{This report describes research done at the Artificial Intelligence Laboratory of the Massachusetts Institute of Technology. Support for the laboratory's artificial intelligence research is provided in part by the Advanced Research Projects Agency of the Department of Defense under Office of Naval Research contract N00014-85-K-0124.} The appendix includes Jonathan Amsterdam's Working Paper 324, MIT AI Lab entitled ``Don't Loop, Iterate.'' @end quotation @end copying @c %**end of header @titlepage @title The Iterate Manual and Paper @c @subtitle Version X.X @c @author Jonathan Amsterdam @page @vskip 0pt plus 1filll @insertcopying @end titlepage @contents @ifnottex @node Top @top iterate @insertcopying @end ifnottex @menu * Introduction:: * Clauses:: * Other Features:: * Types and Declarations:: * Problems with Code Movement:: * Differences Between Iterate and Loop:: * Rolling Your Own:: * Non-portable Extensions to Iterate (Contribs):: * Obtaining Iterate:: * Acknowledgements:: * Don't Loop Iterate:: * Comprehensive Index:: @end menu @c =================================================================== @node Introduction @chapter Introduction This manual describes @iter{}, a powerful iteration facility for Common Lisp. @iter{} provides abstractions for many common iteration patterns and allows for the definition of additional patterns. @iter{} is a macro that expands into ordinary Lisp at compile-time, so it is more efficient than higher-order functions like @code{map} and @code{reduce}. While it is similar to @code{loop}, @iter{} offers a more Lisp-like syntax and enhanced extensibility. (For a more complete comparison of @iter{} with other iteration constructs, see @acronym{MIT} @acronym{AI} Lab Working Paper No.@: 324, @emph{Don't Loop, Iterate.} also included in this manual in @ref{Don't Loop Iterate}.) An @iter{} form consists of the symbol @code{iter}@footnote{You can also use @code{iterate}, but @code{iter} is preferred because it avoids potential conflicts with possible future additions to Common Lisp, and because it saves horizontal space when writing code.} followed by one or more forms, some of which may be @iter{} @emph{clauses}. Here is a simple example of @iter{} which collects the numbers from 1 to 10 into a list, and returns the list. The return value is shown following the arrow. @lisp (iter (for i from 1 to 10) (collect i)) @result{} (1 2 3 4 5 6 7 8 9 10) @end lisp This form contains two clauses: a @code{for} clause that steps the variable @code{i} over the integers from 1 to 10, and a @code{collect} clause that accumulates its argument into a list. With a few exceptions, all @iter{} clauses have the same format: alternating symbols (called @emph{keywords}) and expressions (called @emph{arguments}). The syntax and terminology are those of Common Lisp's keyword lambda lists. One difference is that @iter{}'s keywords do not have to begin with a colon---though they may, except for the first symbol of a clause. So you can also write @code{(for i :from 1 :to 10)} if you prefer. Any Lisp form can appear in the body of an @iter{}, where it will have its usual meaning. @iter{} walks the entire body, expanding macros, and recognizing clauses at any level. This example collects all the odd numbers in a list: @lisp (iter (for el in list) (if (and (numberp el) (oddp el)) (collect el))) @end lisp There are clauses for iterating over numbers, lists, arrays and other objects, and for collecting, summing, counting, maximizing and other useful operations. @iter{} also supports the creation of new variable bindings, stepping over multiple sequences at once, destructuring, and compiler declarations of variable types. The following example illustrates some of these features: @lisp (iter (for (key . item) in alist) (for i from 0) (declare (fixnum i)) (collect (cons i key))) @end lisp This loop takes the keys of an alist and returns a new alist associating the keys with their positions in the original list. The compiler declaration for @code{i} will appear in the generated code in the appropriate place. @c =================================================================== @node Clauses @chapter Clauses Most of @iter{}'s clauses will be familiar to @code{loop} programmers. (@code{loop} is an iteration macro that has been incorporated into Common Lisp. See Guy Steele's @emph{Common Lisp, 2nd Edition}.) In nearly all cases they behave the same as their @code{loop} counterparts, so a @code{loop} user can switch to @iter{} with little pain (and much gain). All clauses with the standard keyword-argument syntax consist of two parts: a @emph{required} part, containing keywords that must be present and in the right order; and an @emph{optional} part, containing keywords that may be omitted and, if present, may occur in any order. In the descriptions below, the parts are separated by the Lisp lambda-list keyword @code{&optional}. @menu * Drivers:: * Variable Binding and Setting:: * Gathering Clauses:: * Control Flow:: * Predicates:: * Code Placement:: @end menu @c =================================================================== @node Drivers @section Drivers An iteration-driving clause conceptually causes the iteration to go forward. Driver clauses in @iter{} allow iteration over numbers, lists, vectors, hashtables, packages, files and streams. Iteration-driving clauses must appear at the top level of an @iter{} form; they cannot be nested inside another clause. The driver variable is updated at the point where the driver clause occurs. Before the clause is executed for the first time, the value of the variable is undefined. @c Also, regardless of where the driver clause appears in the body, @c the driver variable is stepped at the top of the loop; hence it is @c stylistically preferable, though not required, to place driver @c clauses at the beginning of the @iter{}. Multiple drivers may appear in a single @iter{} form, in which case all of the driver variables are updated each time through the loop, in the order in which the clauses appear. The first driver to terminate will terminate the entire loop. In all cases, the value of the driver variable on exit from the loop, including within the epilogue code (see the @code{finally} clause), is undefined. All the parameters of a driver clause are evaluated once, before the loop begins. Hence it is not possible to change the bounds or other properties of an iteration by side-effect from within the loop. With one exception, driver clauses begin with the word @code{for} (or the synonym @code{as}) and mention an iteration variable, which is given a binding within the @iter{} form. The exception is @code{repeat}, which just executes a loop a specified number of times: @clauseu{repeat} @deffn Clause repeat @v{n} Repeat the loop @var{n} times. For example: @lisp (iter (repeat 100) (print "I will not talk in class.")) @end lisp If @mathx{n \leq 0, n <= 0}, then loop will never be executed. If @var{n} is not an integer, the actual number of executions will be @mathx{\lceil n \rceil, ceil(n)}. @end deffn @menu * Numerical Iteration:: * Sequence Iteration:: * Generalized Drivers:: * Generators:: * Previous Values of Driver Variables:: @end menu @c =================================================================== @node Numerical Iteration @subsection Numerical Iteration @clauseu{for} @deffn Clause for @v{var} @k{&sequence} The general form for iterating over a sequence of numbers requires a variable and, optionally, one or more keywords that provide the bounds and step size of the iteration. The @code{&sequence} lambda-list keyword is a shorthand for these sequence keywords. They are: @code{from}, @code{upfrom}, @code{downfrom}, @code{to}, @code{downto}, @code{above}, @code{below} and @code{by}. @code{from} provides the starting value for @var{var} and defaults to zero. @code{to} provides a final value and implies that the successive values of @var{var} will be increasing; @code{downto} implies that they will be decreasing. The loop terminates when @var{var} passes the final value (i.e.@: becomes smaller or larger than it, depending on the direction of iteration); in other words, the loop body will never be executed for values of @var{var} past the final value. @code{below} and @code{above} are similar to @code{to} and @code{downto}, except that the loop terminates when @var{var} equals or passes the final value. If no final value is specified, the variable will be stepped forever. Using @code{from} or @code{upfrom} will result in increasing values, while @code{downfrom} will give decreasing values. On each iteration, @var{var} is incremented or decremented by the value of the sequence keyword @code{by}, which defaults to 1. It should always be a positive number, even for downward iterations. In the following examples, the sequence of numbers generated is shown next to the clause. @lisp (for i upfrom 0) @result{} 0 1 2 @dots{} (for i from 5) @result{} 5 6 7 @dots{} ; either from or upfrom is okay (for i downfrom 0) @result{} 0 -1 -2 @dots{} (for i from 1 to 3) @result{} 1 2 3 (for i from 1 below 3) @result{} 1 2 (for i from 1 to 3 by 2) @result{} 1 3 (for i from 1 below 3 by 2) @result{} 1 (for i from 5 downto 3) @result{} 5 4 3 @end lisp @end deffn @c =================================================================== @node Sequence Iteration @subsection Sequence Iteration There are a number of clauses for iterating over sequences. In all of them, the argument following @code{for} may be a list instead of a symbol, in which case destructuring is performed. See @ref{Destructuring}. @claused{for, in} @deffn Clause for @v{var} @cl{in} @v{list} @k{&optional} @k{by} @v{step-function} @var{var} is set to successive elements of list. @var{step-function}, which defaults to @code{cdr}, is used to obtain the next sublist. This clause uses @code{endp} to test for the end of a list, hence should signal an error when processing an improper list whose final @code{cdr} is not @code{nil}---like @code{loop}. Prior to 2007, @iter{} would default to @code{atom} and silently exit. @vindex *list-end-test* @quotation Compatibility Note The original implementation used the variable @code{iterate::*list-end-test*}, defaulting to @code{atom}. Years later, it was deemed unacceptable for the semantics @emph{not} to be lexically apparent from the iteration form so this variable was removed. If your application depends on the original behaviour, the ancient @code{for @v{var} in} is equivalent to @code{for (@v{var}) on}. @end quotation @end deffn @claused{for, on} @deffn Clause for @v{var} @cl{on} @v{list} @k{&optional} @k{by} @v{step-function} @var{var} is set to successive sublists of list. @var{step-function} (default @code{cdr}) is used as in @code{for@dots{} in}. This clause uses @code{atom} to test for the end of a list, so it can be used with dotted lists---like @code{loop}. @end deffn @c These two clauses use @code{atom} to test for the end of a list. @c Hence, given a list whose final @code{cdr} is not @code{nil}, they @c will silently ignore the last @code{cdr}. Other choices are @c @code{endp}, which would signal an error, and @code{null}, which would @c probably result in an error somewhere else. If you wish to use an @c end-test other than @code{atom}, set the variable @c @code{iterate::*list-end-test*} to the name of the desired function. @claused{for, in-vector} @deffn Clause for @v{var} @cl{in-vector} @v{vector} @k{&sequence} @var{var} takes on successive elements from @var{vector}. The vector's fill-pointer is observed. Here and in subsequent clauses, the @code{&sequence} keywords include @code{with-index}, which takes a symbol as argument and uses it for the index variable instead of an internally generated symbol. The other @code{&sequence} keywords behave as in numerical iteration, except that the default iteration bounds are the bounds of the vector. E.g.@: in @code{(for i in-vector v downto 3)}, @code{i} will start off being bound to the last element in @code{v}, and will be set to preceding elements down to and including the element with index 3. @end deffn @claused{for, in-sequence} @deffn Clause for @v{var} @cl{in-sequence} @v{seq} @k{&sequence} This uses Common Lisp's generalized sequence functions, @code{elt} and @code{length}, to obtain elements and determine the length of @var{seq}. Hence it will work for any sequence, including lists, and will observe the fill-pointers of vectors. @end deffn @claused{for, in-string} @deffn Clause for @v{var} @cl{in-string} @v{string} @k{&sequence} @var{var} is set to successive characters of @var{string}. @end deffn @claused{for, index-of-vector} @claused{for, index-of-sequence} @claused{for, index-of-string} @deffn Clause for @v{var} @cl{index-of-vector} @v{vector} @k{&sequence} @deffnx Clause for @v{var} @cl{index-of-sequence} @v{sequence} @k{&sequence} @deffnx Clause for @v{var} @cl{index-of-string} @v{string} @k{&sequence} @var{var} is set to successive indices of the sequence. These clauses avoid the overhead of accessing the sequence elements for those applications where they do not need to be examined, or are examined rarely. They admit all the optional keywords of the other sequence drivers except the (redundant) @code{with-index} keyword. @end deffn @claused{for, in-hashtable} @deffn Clause for (@v{key} @v{value}) @cl{in-hashtable} @v{table} @var{key} and @var{value}, which must appear as shown in a list and may be destructuring templates, are set to the keys and values of @var{table}. If @var{key} is @code{nil}, then the hashtable's keys will be ignored; similarly for @var{value}. The order in which elements of @var{table} will be retrieved is unpredictable. @end deffn @claused{for, in-package} @deffn Clause for @v{var} @cl{in-package} @v{package} @ @k{&optional} @k{external-only} @v{ext} Iterates over all the symbols in @var{package}, or over only the external symbols if @var{ext} is specified and non-@code{nil}. @var{ext} is not evaluated. The same symbol may appear more than once. @end deffn @claused{for, in-packages} @deffn Clause for @v{var} @cl{in-packages} @ @k{&optional} @k{having-access} @v{symbol-types} Iterates over all the symbols from the list of packages denoted by the descriptor @var{packages} and having accessibility (or visibility) given by @var{symbol-types}. This defaults to the list @code{(:external :internal :inherited)} and is not evaluated. @var{var} must be a list of up to three variables: in each iteration, these will be set to a symbol, its access-type and package (as per @code{with-package-iterator} in ANSI CL). The same symbol may appear more than once. @end deffn @claused{for, in-file} @deffn Clause for @v{var} @cl{in-file} @v{name} @ @k{&optional} @k{using} @v{reader} Opens the file @var{name} (which may be a string or pathname) for input, and iterates over its contents. @var{reader} defaults to @code{read}, so by default @emph{var} will be bound to the successive forms in the file. The @iter{} body is wrapped in an @code{unwind-protect} to ensure that the file is closed no matter how the @iter{} is exited. @end deffn @claused{for, in-stream} @deffn Clause for @v{var} @cl{in-stream} @v{stream} @k{&optional} @k{using} @ @v{reader} Like @code{for@dots{} in-file}, except that @var{stream} should be an existing stream object that supports input operations. @end deffn @c =================================================================== @node Generalized Drivers @subsection Generalized Drivers These are primarily useful for writing drivers that can also be used as generators (see @ref{Generators}). @clauseu{terminate} @claused{for, next} @deffn Clause for @v{var} @cl{next} @v{expr} @var{var} is set to @var{expr} each time through the loop. Destructuring is performed. When the clause is used as a generator, @var{expr} is the code that is executed when @code{(next @emph{var})} is encountered (see @ref{Generators}). @var{expr} should compute the first value for @var{var}, as well as all subsequent values, and is responsible for terminating the loop. For compatibility with future versions of @iter{}, this termination should be done with @code{terminate}, which can be considered a synonym for @code{finish} (see @ref{Control Flow}). As an example, the following clauses are equivalent to @code{(for i from 1 to 10)}: @lisp (initially (setq i 0)) (for i next (if (> i 10) (terminate) (incf i))) @end lisp @end deffn @claused{for, do-next} @deffn Clause for @v{var} @k{do-next} @v{form} @var{form} is evaluated each time through the loop. Its value is @var{not} set to @var{var}; that is @var{form}'s job. @var{var} is only present so that @iter{} knows it is a driver variable. @* @code{(for @var{var} next @var{expr})} is equivalent to @code{(for @var{var} do-next (dsetq @var{var} @var{expr}))}. (See @ref{Destructuring} for an explanation of @code{dsetq}.) @end deffn @c =================================================================== @node Generators @subsection Generators In all of the above clauses, the driver variable is updated on each iteration. Sometimes it is desirable to have greater control over updating. For instance, consider the problem of associating numbers, in increasing order and with no gaps, with the non-@code{nil} elements of a list. One obvious first pass at writing this is: @lisp (iter (for el in list) (for i upfrom 1) (if el (collect (cons el i)))) @end lisp But on the list @code{(a b nil c)} this produces @code{((a . 1) (b . 2) (c . 4))} instead of the desired @code{((a . 1) (b . 2) (c . 3))}. The problem is that @code{i} is incremented each time through the loop, even when @code{el} is @code{nil}. The problem could be solved elegantly if we could step @code{i} only when we wished to. This can be accomplished for any @iter{} driver by writing @code{generate} (or its synonym @code{generating}) instead of @code{for}. Doing so produces a @emph{generator}---a driver whose values are yielded explicitly. To obtain the next value of a generator variable @var{v}, write @code{(next @var{v})}. The value of a @code{next} form is the next value of @emph{v}, as determined by its associated driver clause. @code{next} also has the side-effect of updating @var{v} to that value. If there is no next value, @code{next} will terminate the loop, just as with a normal driver. Using generators, we can now write our example like this: @lisp (iter (for el in list) (generate i upfrom 1) (if el (collect (cons el (next i))))) @end lisp Now @code{i} is updated only when @code{(next i)} is executed, and this occurs only when @code{el} is non-@code{nil}. To better understand the relationship between ordinary drivers and generators, observe that we can rewrite an ordinary driver using its generator form immediately followed by @code{next}, as this example shows: @lisp (iter (generating i from 1 to 10) (next i) @dots{}) @end lisp Provided that the loop body contains no @code{(next i)} forms, this will behave just as if we had written @code{(for i from 1 to 10)}. We can still refer to a driver variable @var{v} without using @code{next}; in this case, its value is that given to it by the last evaluation of @code{(next @var{v})}. Before @code{(next @var{v})} has been called the first time, the value of @var{v} is undefined. This semantics is more flexible than one in which @var{v} begins the loop bound to its first value and calls of @code{next} supply subsequent values, because it means the loop will not terminate too soon if the generator's sequence is empty. For instance, consider the following code, which tags non-@code{nil} elements of a list using a list of tags, and also counts the null elements. (We assume there are at least as many tags as non-@code{nil} elements.) @lisp (let* ((counter 0) (tagged-list (iter (for el in list) (generating tag in tag-list) (if (null el) (incf counter) (collect (cons el (next tag))))))) @dots{}) @end lisp It may be that there are just as many tags as non-null elements of @code{list}. If all the elements of @code{list} are null, we still want the counting to proceed, even though @code{tag-list} is @code{nil}. If @code{tag} had to be assigned its first value before the loop begins, we would have had to terminate the loop before the first iteration, since when @code{tag-list} is @code{nil}, @code{tag} has no first value. With the existing semantics, however, @code{(next tag)} will never execute, so the iteration will cover all the elements of @code{list}. When the ``variable'' of a driver clause is actually a destructuring template containing several variables, all the variables are eligible for use with @code{next}. As before, @code{(next @var{v})} evaluates to @var{v}'s next value; but the effect is to update all of the template's variables. For instance, the following code will return the list @code{(a 2 c)}. @lisp (iter (generating (key . item) in '((a . 1) (b . 2) (c . 3))) (collect (next key)) (collect (next item))) @end lisp Only driver clauses with variables can be made into generators. This includes all clauses mentioned so far except for @code{repeat}. It does @emph{not} include @code{for@dots{} previous}, @code{for@dots{} =}, @code{for@dots{} initially@dots{} then} or @code{for@dots{} first@dots{} then} (see below). @c =================================================================== @node Previous Values of Driver Variables @subsection Previous Values of Driver Variables Often one would like to access the value of a variable on a previous iteration. @iter{} provides a special clause for accomplishing this. @claused{for, previous} @deffn Clause for @v{pvar} @cl{previous} @v{var} @ @k{&optional} @k{initially} @v{init} @k{back} @v{n} Sets @var{pvar} to the previous value of @var{var}, which should be a driver variable, a variable from another @code{for@dots{} previous} clause, or a variable established by a @code{for@dots{} =}, @code{for@dots{} initially@dots{} then} or @code{for@dots{} first@dots{} then} clause (see @ref{Variable Binding and Setting}). Initially, @var{pvar} is given the value @var{init} (which defaults to @code{nil}). The @var{init} expression will be moved outside the loop body, so it should not depend on anything computed within the loop. @var{pvar} retains the value of @var{init} until @var{var} is set to its second value, at which point @var{pvar} is set to @var{var}'s first value; and so on. The argument @var{n} to @code{back} must be a constant, positive integer, and defaults to 1. It determines how many iterations back @var{pvar} should track @var{var}. For example, when @var{n} is 2, then @var{pvar} will be assigned @var{var}'s first value when @var{var} is set to its third value. A @code{for@dots{} previous} clause may occur after or before its associated driver clause. @code{for@dots{} previous} works with generators as well as ordinary drivers. Example: @lisp (iter (for el in '(1 2 3 4)) (for p-el previous el) (for pp-el previous p-el initially 0) (collect pp-el)) @end lisp This evaluates to @code{(0 0 1 2)}. It could have been written more economically as @lisp (iter (for el in '(1 2 3 4)) (for pp-el previous el back 2 initially 0) (collect pp-el)) @end lisp @end deffn @c =================================================================== @node Variable Binding and Setting @section Variable Binding and Setting Several clauses exist for establishing new variable bindings or for setting variables in the loop. They all support destructuring. @clauseu{with} @deffn Clause with @v{var} @k{&optional} @k{=} @v{value} Causes @var{var} to be bound to value before the loop body is entered. If @var{value} is not supplied, @var{var} assumes a default binding, which will be @code{nil} in the absence of declarations. Also, if @var{value} is not supplied, no destructuring is performed; instead, @var{var} may be a list of symbols, all of which are given default bindings. If @var{value} is supplied, @var{var} is bound to it, with destructuring. Because @code{with} creates bindings whose scope includes the entire @iter{} form, it is good style to put all @code{with} clauses at the beginning. Successive occurrences of @code{with} result in sequential bindings (as with @code{let*}). There is no way to obtain parallel bindings; see @ref{Parallel Binding and Stepping} for a rationale. @end deffn @claused{for, =} @deffn Clause for @v{var} @cl{=} @v{expr} On each iteration, @var{expr} is evaluated and @var{var} is set to its value. This clause may appear to do the same thing as @code{for@dots{} next}. In fact, they are quite different. @code{for@dots{} =} provides only three services: it sets up a binding for @var{var}, sets it to @var{expr} on each iteration, and makes it possible to use @code{for@dots{} previous} with @var{var}. @code{for@dots{} next} provides these services in addition to the ability to turn the driver into a generator. @c Also, the code which sets @var{var} appears in the loop body in the @c same place as the @code{for@dots{} =} clause; the code for @c @code{for@dots{} next} appears at the top of the loop, as with @c other drivers (except when being used as a generator). @end deffn @clauset{for, initially, then} @deffn Clause for @v{var} @cl{initially} @v{init-expr} @cl{then} @v{then-expr} Before the loop begins, @var{var} is set to @var{init-expr;} on all iterations after the first it is set to @var{then-expr.} This clause must occur at top-level. @var{init-expr} will be moved outside the loop body and @var{then-expr} will be moved to the end of the loop body, so they are subject to code motion problems (see @ref{Problems with Code Movement}). This clause may appear to be similar to @code{for@dots{} next}, but in fact they differ significantly. @code{for@dots{} initially@dots{} then} is typically used to give @var{var} its first value before the loop begins, and subsequent values on following iterations. This is incompatible with generators, whose first value and subsequent values must all be computed by @code{(next @var{var})}. Also, the update of @var{var} in @code{for@dots{} initially@dots{} then} does not occur at the location of the clause. Use @code{for@dots{} initially@dots{} then} for one-shot computations where its idiom is more convenient, but use @code{for@dots{} next} for extending @iter{} with new drivers (see @ref{Rolling Your Own}). @end deffn @clauset{for, first, then} @deffn Clause for @v{var} @cl{first} @v{first-expr} @cl{then} @v{then-expr} The first time through the loop, @var{var} is set to @var{first-expr}; on subsequent iterations, it is set to @var{then-expr}. This differs from @code{for@dots{} initially} in that @var{var} is set to @var{first-expr} inside the loop body, so @var{first-expr} may depend on the results of other clauses. For instance, @lisp (iter (for num in list) (for i first num then (1+ i)) ...) @end lisp will set @code{i} to the first element of @code{list} on the first iteration, whereas @lisp (iter (for num in list) (for i initially num then (1+ i)) ...) @end lisp is probably erroneous; @code{i} will be bound to @code{num}'s default binding (usually @code{nil}) for the first iteration. @end deffn @quotation Compatibility Note @code{loop}'s @code{for@dots{} =} works like @iter{}'s, but @code{loop} used the syntax @code{for@dots{} =@dots{} then} to mean @code{for@dots{} initially@dots{} then}. It was felt that these two operations were sufficiently different to warrant different keywords. Also, the @code{for} in the above three clauses is misleading, since none is true driver (e.g.@: none has a corresponding @code{generate} form). @code{setting} would have been a better choice, but @code{for} was used to retain some compatibility with @code{loop}. @end quotation @c =================================================================== @node Gathering Clauses @section Gathering Clauses Many of @iter{}'s clauses accumulate values into a variable, or set a variable under certain conditions. At the end of the loop, this variable contains the desired result. All these clauses have an optional @code{into} keyword, whose argument should be a symbol. If the @code{into} keyword is not supplied, the accumulation variable will be internally generated and its value will be returned at the end of the loop; if a variable is specified, that variable is used for the accumulation, and is not returned as a result---it is up to the user to return it explicitly, in the loop's epilogue code (see @code{finally}). It is safe to examine the accumulation variable during the loop, but it should not be modified. These clauses all begin with a verb. When the verb does not conflict with an existing Common Lisp function, then it may be used in either its infinitival or present-participle form (e.g.@: @code{sum}, @code{summing}). However, when there is a conflict with Common Lisp, only the present-participle form may be used (e.g.@: @code{unioning}). This is to prevent @iter{} clauses from clashing with Common Lisp functions. @c although these clauses are described as ``producing a value,'' it @c is a mistake to think of the lisp list representing the clause as a @c value-producing form in the usual way. clauses may legally be @c written where a value is expected, e.g.@: @code{(setq x (sum i))}, @c but the lisp value of a clause in such a context is undefined. @menu * Reductions:: * Accumulations:: * Finders:: * Aggregated Boolean Tests:: @end menu @c =================================================================== @node Reductions @subsection Reductions @emph{Reduction} is an extremely common iteration pattern in which the results of successive applications of a binary operation are accumulated. For example, a loop that computes the sum of the elements of a list is performing a reduction with the addition operation. This could be written in Common Lisp as @code{(reduce #'+ list)} or with @iter{} as @lisp (iter (for el in list) (sum el)) @end lisp @clauseu{sum} @deffn Clause sum @v{expr} @k{&optional} @k{into} @v{var} Each time through the loop, @var{expr} is evaluated and added to a variable, which is bound initially to zero. If @var{expr} has a type, it is @emph{not} used as the type of the sum variable, which is always @code{number}. To get the result variable to be of a more specific type, use an explicit variable, as in @lisp (iter (for el in number-list) (sum el into x) (declare (fixnum x)) (finally (return x))) @end lisp @end deffn @clauseu{multiply} @deffn Clause multiply @v{expr} @k{&optional} @k{into} @v{var} Like @code{sum}, but the initial value of the result variable is @math{1}, and the variable is updated by multiplying @var{expr} into it. @end deffn @clauseu{counting} @deffn Clause counting @v{expr} @k{&optional} @k{into} @v{var} @var{expr} is evaluated on each iteration. If it is non-@code{nil}, the accumulation variable, initially zero, is incremented. @end deffn @clauseu{maximize} @clauseu{minimize} @deffn Clause maximize @v{expr} @k{&optional} @k{into} @v{var} @deffnx Clause minimize @v{expr} @k{&optional} @k{into} @v{var} @var{expr} is evaluated on each iteration and its extremum (maximum or minimum) is stored in the accumulation variable. If @var{expr} is never evaluated, then the result is @code{nil} (if the accumulation variable is untyped) or @math{0} (if it has a numeric type). @end deffn @clauseu{reducing} @deffn Clause reducing @v{expr} @k{by} @v{func} @k{&optional} @k{initial-value} @v{init-val} @k{into} @v{var} This is a general way to perform reductions. @var{func} should be a function of two arguments, the first of which will be the value computed so far and the second of which will be the value of @var{expr}. It should return the new value. @code{reducing} is roughly equivalent to the Common Lisp @code{(reduce @var{func} @var{sequence} :key @var{expr-function})}, where @var{expr-function} is used to derive values from the successive elements of @var{sequence}. If the @code{reducing} clause is never executed, the result is undefined. It is not necessary to provide an initial value, but better code can be generated if one is supplied. Regardless of its location in the @iter{} body, @var{init-val} will be evaluated before the loop is entered, so it should not depend on any value computed inside the @iter{} form. @c if a @var{var} is not specified, you can get @iter{} to declare the @c type of the internal variable by putting a @code{the} expression @c around @var{func}. see @ref{Types}. @end deffn @c @impnote{in principle, |maximize| and |minimize| can be thought of @c as reductions where the initial value is the smallest (or largest) @c value that the accumulation variable can assume. because lisp's @c bignums can represent arbitrary integers, these clauses cannot be @c implemented as reductions in general. if, however, the type of @c ~expr~ or ~var~ can be determined to be a fixnum or a float, @c @iter{} will implement the clause as a true reduction, using one of @c the constants |most-negative-fixnum|, |@c most-positive-fixnum|, @c |most-negative-short-float|, etc.@: as appropriate.} @c =================================================================== @node Accumulations @subsection Accumulations All the predefined accumulation clauses add values to a sequence. If the sequence is a list, they all have the property that the partial list is kept in the correct order and available for inspection at any point in the loop. @clauseu{collect} @deffn Clause collect @v{exptr} @k{&optional} @k{into} @v{var} @k{at} @v{place} @k{result-type} @v{type} Produces a sequence of the values of @var{exptr} on each iteration. @var{place} indicates where the next value of @var{exptr} is added to the list and may be one of the symbols @code{start}, @code{beginning} (a synonym for @code{start}) or @code{end}. The symbol may be quoted, but need not be. The default is @code{end}. For example, @lisp (iter (for i from 1 to 5) (collect i)) @end lisp produces @code{(1 2 3 4 5)}, whereas @lisp (iter (for i from 1 to 5) (collect i at beginning)) @end lisp produces @code{(5 4 3 2 1)} (and is likely to be faster in most Common Lisp implementations). If @var{type} is provided, it should be a subtype of @code{sequence}. The default is @code{list}. Specifying a type other than @code{list} will result in @code{collect} returning a sequence of that type. @emph{However}, the type of the sequence being constructed when inside the loop body is undefined when a non-@code{list} type is specified. (As with @var{place}, quoting @var{type} is optional.) @end deffn @clauseu{adjoining} @deffn Clause adjoining @v{exptr} @k{&optional} @k{into} @v{var} @ @k{test} @v{test} @k{at} @v{place} @ @k{result-type} @v{type} Like @code{collect}, but only adds the value of @var{exptr} if it is not already present. @var{test}, which defaults to @code{#'eql}, is the test to be used with @code{member}. @end deffn @clauseu{appending} @clauseu{nconcing} @clauseu{unioning} @clauseu{nunioning} @deffn Clause appending @v{expr} @k{&optional} @k{into} @v{var} @k{at} @v{place} @deffnx Clause nconcing @v{expr} @k{&optional} @k{into} @v{var} @k{at} @v{place} @deffnx Clause unioning @v{expr} @k{&optional} @k{into} @v{var} @ @k{test} @v{test} @k{at} @v{place} @deffnx Clause nunioning @v{expr} @k{&optional} @k{into} @v{var} @ @k{test} @v{test} @k{at} @v{place} These are like @code{collect}, but behave like the Common Lisp functions @code{append}, @code{nconc}, @code{union} or @code{nunion}. As in Common Lisp, they work only on lists. Also as in Common Lisp, @code{unioning} and @code{nunioning} assume that the value of @var{expr} contains no duplicates. @end deffn @clauseu{accumulate} @deffn Clause accumulate @v{expr} @k{by} @v{func} @k{&optional} @ @k{initial-value} @v{init-val} @k{into} @v{var} This is a general-purpose accumulation clause. @var{func} should be a function of two arguments, the value of @var{expr} and the value accumulated so far in the iteration, and it should return the updated value. If no initial value is supplied, @code{nil} is used. @c If a @var{var} is not specified, you can get @iter{} to declare the @c type of the internal variable by putting a @code{the} expression @c around @var{func}. see section \ref{types}. The differences between @code{accumulate} and @code{reducing} are slight. One difference is that the functions take their arguments in a different order. Another is that in the absence of @var{init-val}, @code{accumulate} will use @code{nil}, whereas @code{reducing} will generate different code that avoids any dependence on the initial value. The reason for having both clauses is that one usually thinks of reductions (like @code{sum}) and accumulations (like @code{collect}) as different beasts. @end deffn @c =================================================================== @node Finders @subsection Finders A @emph{finder} is a clause whose value is an expression that meets some condition. @claused{finding, such-that} @deffn Clause finding @var{expr} @cl{such-that} @v{test} @k{&optionally} @ @k{into} @v{var} @k{on-failure} @v{failure-value} If @var{test} (which is an expression) ever evaluates to non-@code{nil}, the loop is terminated, the epilogue code is run and the value of @var{expr} is returned. Otherwise, @code{nil} (or @var{failure-value}, if provided) is returned. If @var{var} is provided, it will have either the non-@code{nil} value of @var{expr} or @var{failure-value} when the epilogue code is run. As a special case, if the @var{test} expression is a sharp-quoted function, then it is applied to @var{expr} instead of being simply evaluated. E.g.@: @code{(finding x such-that #'evenp)} is equivalent to @code{(finding x such-that (evenp x))}. @c \cpar although @var{test} need have nothing to do with ~@c expr~ as in @c |(finding j such-that (> i 3))|, it usually @c will: |(finding (length el) such-that (oddp (length el)))|. to @c avoid performing the |length| computation twice, you could write @c |(finding (length el) such-that \#'oddp)| or |(finding (length @c el) such-that 'oddp)|; for these cases, @iter{} generates code that @c executes @var{expr} only once. the code for |\#'oddp| @c is slightly different from that for {\lisp 'oddp}; see the discussion @c under {\lisp for\dots in} and {\lisp for\dots on}. @code{On-failure} is a misnomer. Because it is always evaluated, it behaves more like the default third argument to the @code{gethash} function. As a result, @code{on-failure (error "Not found")} makes no sense. Instead, the clauses @code{leave} or @code{thereis} can be used in conjunction with @code{finally} as follows: @lisp (iter (for x in '(1 2 3)) (if (evenp x) (leave x)) (finally (error "not found"))) @end lisp This clause may appear multiple times when all defaults are identical. It can also be used together with either @code{always}/@code{never} or @code{thereis} if their defaults match. More specifically, @code{on-failure nil} is compatible with @code{thereis}, while @code{on-failure t} is compatible with @code{always} and @code{never} clauses. @lisp (iter (for i in '(7 -4 2 -3)) (if (plusp i) (finding i such-that (evenp i)) (finding (- i) such-that (oddp i)))) @end lisp @end deffn @claused{finding, maximizing} @claused{finding, minimizing} @deffn Clause finding @v{expr} @cl{maximizing} @v{m-expr} @ @k{&optional} @k{into} @v{var} @deffnx Clause finding @v{expr} @cl{minimizing} @v{m-expr} @ @k{&optional} @k{into} @v{var} Computes the extremum (maximum or minimum) value of @var{m-expr} over all iterations, and returns the value of @var{expr} corresponding to the extremum. @var{expr} is evaluated inside the loop at the time the new extremum is established. If @var{m-expr} is never evaluated (due to, for example, being embedded in a conditional clause), then the returned value depends on the type, if any, of @var{expr} (or @var{var}, if one is supplied). If there is no type, the returned value will be @code{nil}; if the type is numeric, the returned value will be zero. For these two clauses, @var{var} may be a list of two symbols; in that case, the first is used to record @var{expr} and the second, @var{m-expr}. As with @code{finding@dots{} such-that}, if @var{m-expr} is a sharp-quoted function, then it is called on @var{expr} instead of being evaluated. @end deffn @c =================================================================== @node Aggregated Boolean Tests @subsection Aggregated Boolean Tests @clauseu{always} @deffn Clause always @v{expr} If @var{expr} ever evaluates to @code{nil}, then @code{nil} is immediately returned; the epilogue code is not executed. If @var{expr} never evaluates to @code{nil}, the epilogue code is executed and the last value of @var{expr} (or @code{t} if @var{expr} was never evaluated) is returned (whereas @code{loop} would constantly return @code{t}). @c mention last evaluated clause when multiple always clauses? @end deffn @clauseu{never} @deffn Clause never @v{expr} Like @code{(always (not @var{expr}))}, except it does not influence the last value returned by a possible other @code{always} clause. That is, @lisp (iter (repeat 2) (always 2) (never nil)) @result{} 2 ; not t @end lisp @end deffn @clauseu{thereis} @deffn Clause thereis @v{expr} If @var{expr} is ever non-@code{nil}, its value is immediately returned without running epilogue code. Otherwise, the epilogue code is performed and @code{nil} is returned. This clause cannot be used together with @code{always} or @code{never}, because their defaults are opposed (similarly, @code{(loop always 3 thereis nil)} refuses to compile in some implementations of @code{loop}). @end deffn @c =================================================================== @node Control Flow @section Control Flow Several clauses can be used to alter the usual flow of control in a loop. @quotation Note The clauses of this and subsequent sections don't adhere to @iter{}'s usual syntax, but instead use standard Common Lisp syntax. Hence the format for describing syntax subsequently is like the standard format used in the Common Lisp manual, not like the descriptions of clauses above. @end quotation @clauseu{finish} @deffn Clause finish Stops the loop and runs the epilogue code. @end deffn @c for example: @c @c @lisp @c (iter (with answer = nil) @c (initially (make-a-mess)) @c (for i from 1 to 10) @c (when (correct? i) @c (setq answer i) @c (finish)) @c (finally (cleanup))) @c @end lisp @c @c this code will execute |cleanup| whether or not the test |(correct? @c i)| ever succeeds. @c the (more elegant) formulation, @c @lisp @c (iter (initially (make-a-mess)) @c (for i from 1 to 10) @c (finding i such-that (correct? i)) @c (finally (cleanup))) @c @end lisp @c would not execute |cleanup| if |(correct? i)| succeeded; it @c would do an immediate return. @clauseu{leave} @deffn Clause leave @k{&optional} @v{value} Immediately returns @var{value} (default @code{nil}) from the current @iter{} form, skipping the epilogue code. Equivalent to using @code{return-from}. @end deffn @clauseu{next-iteration} @deffn Clause next-iteration Skips the remainder of the loop body and begins the next iteration of the loop. @end deffn @clauseu{while} @deffn Clause while @v{expr} If @var{expr} ever evaluates to @code{nil}, the loop is terminated and the epilogue code executed. Equivalent to @code{(if (not @var{expr}) (finish))}. @end deffn @clauseu{until} @deffn Clause until @v{expr} Equivalent to @code{(if @var{expr} (finish))}. @end deffn @clauseu{if-first-time} @deffn Clause if-first-time @v{then} @k{&optional} @v{else} If this clause is being executed for the first time in this invocation of the @iter{} form, then the @var{then} code is evaluated; otherwise the @var{else} code is evaluated. @code{(for @var{var} first @var{expr1} then @var{expr2})} is almost equivalent to @lisp (if-first-time (dsetq @var{var} @var{expr1}) (dsetq @var{var} @var{expr2})) @end lisp The only difference is that the @code{for} version makes @var{var} available for use with @code{for@dots{} previous}. @end deffn @c =================================================================== @node Predicates @section Predicates @quotation Compatibility Note The clauses in this section were added in the twenty-first century and not part of Jonathan Amsterdam's original design. @end quotation @clauseu{first-iteration-p} @deffn Clause first-iteration-p Returns @code{t} in the first iteration of the loop, otherwise @code{nil}. @end deffn @clauseu{first-time-p} @deffn Clause first-time-p Returns @code{t} the first time the expression is evaluated, and then @code{nil} forever. This clause comes handy when printing (optional) elements separated by a comma: @lisp (iter (for el in '(nil 1 2 nil 3)) (when el (unless (first-time-p) (princ ", ")) (princ el))) @print{} 1, 2, 3 @end lisp @end deffn @c =================================================================== @node Code Placement @section Code Placement When fine control is desired over where code appears in a loop generated by @iter{}, the following special clauses may be useful. They are all subject to code-motion problems (see @ref{Problems with Code Movement}). @clauseu{initially} @deffn Clause initially @k{&rest} @var{forms} The lisp @var{forms} are placed in the prologue section of the loop, where they are executed once, before the loop body is entered. @end deffn @clauseu{after-each} @deffn Clause after-each @k{&rest} @v{forms} The @var{forms} are placed at the end of the loop body, where they are executed after each iteration. Unlike the other clauses in this section, @var{forms} may contain @iter{} clauses. @end deffn @clauseu{else} @deffn Clause else @k{&rest} @v{forms} The lisp @var{forms} are placed in the epilogue section of the loop, where they are executed if this @code{else} clause is never met during execution of the loop and the loop terminates normally. @end deffn @clauseu{finally} @deffn Clause finally @k{&rest} @v{forms} The lisp @var{forms} are placed in the epilogue section of the loop, where they are executed after the loop has terminated normally. @end deffn @clauseu{finally-protected} @deffn finally-protected @k{&rest} @v{forms} The lisp @var{forms} are placed in the second form of an @code{unwind-protect} outside the loop. They are always executed after the loop has terminated, regardless of how the termination occurred. @end deffn @c =================================================================== @node Other Features @chapter Other Features @section Multiple Accumulations It is permitted to have more than one clause accumulate into the same variable, as in the following: @lisp (iter (for i from 1 to 10) (collect i into nums) (collect (sqrt i) into nums) (finally (return nums))) @end lisp Clauses can only accumulate into the same variable if they are compatible. @code{collect}, @code{adjoining}, @code{appending}, @code{nconcing}, @code{unioning} and @code{nunioning} are compatible with each other; @code{sum}, @code{multiply} and @code{counting} are compatible; @code{always} and @code{never} are compatible; @code{finding}@dots{} @code{such-that} is compatible with either @code{thereis} or @code{always} and @code{never} when their defaults match; and @code{maximize} and @code{minimize} clauses are compatible only with other @code{maximize} and @code{minimize} clauses, respectively. @c note that the same variable ~cannot~ be both an accumulation @c variable and an ordinary variable; there can be only one variable @c with a given name within an @iter{} form. @menu * Named Blocks:: * Destructuring:: * On-line Help:: * Parallel Binding and Stepping:: @end menu @c =================================================================== @node Named Blocks @section Named Blocks Like Common Lisp @code{block}s, @iter{} forms can be given names. The name should be a single symbol, and it must be the first form in the @iter{}. The generated code behaves exactly like a named block; in particular, @code{(return-from @var{name})} can be used to exit it: @lisp (iter fred (for i from 1 to 10) (iter barney (for j from i to 10) (if (> (* i j) 17) (return-from fred j)))) @end lisp An @iter{} form that is not given a name is implicitly named @code{nil}. Sometimes one would like to write an expression in an inner @iter{} form, but have it processed by an outer @iter{} form. This is possible with the @code{in} clause. @clauseu{in} @deffn Clause in @v{name} @k{&rest} @v{forms} Evaluates @var{forms} as if they were part of the @iter{} form named @var{name}. In other words, @iter{} clauses are processed by the @iter{} form named @var{name}, and not by any @iter{} forms that occur inside @var{name}. As an example, consider the problem of collecting a list of the elements in a two-dimensional array. The naive solution, @lisp (iter (for i below (array-dimension ar 0)) (iter (for j below (array-dimension ar 1)) (collect (aref ar i j)))) @end lisp is wrong because the list created by the inner @iter{} is simply ignored by the outer one. But using @code{in} we can write: @lisp (iter outer (for i below (array-dimension ar 0)) (iter (for j below (array-dimension ar 1)) (in outer (collect (aref ar i j))))) @end lisp which has the desired result. @end deffn @c =================================================================== @node Destructuring @section Destructuring In many places within @iter{} clauses where a variable is expected, a list can be written instead. In these cases, the value to be assigned is @emph{destructured} according to the pattern described by the list. As a simple example, the clause @lisp (for (key . item) in alist) @end lisp will result in @code{key} being set to the @code{car} of each element in @code{alist}, and @code{item} being set to the @code{cdr}. The pattern list may be nested to arbitrary depth, and (as the example shows) need not be terminated with @code{nil}; the only requirement is that each leaf be a bindable symbol (or @code{nil}, in which case no binding is generated for that piece of the structure). Sometimes, you might like to do the equivalent of a @code{multiple-value-setq} in a clause. This ``multiple-value destructuring'' can be expressed by writing @code{(values @var{pat_1} @var{pat_2} @dots{})} for a destructuring pattern, as in @lisp (for (values (a . b) c d) = (three-valued-function ...)) @end lisp Note that the @var{pat_i} can themselves be destructuring patterns (though not multiple-value destructuring patterns). You can't do multiple-value destructuring in a @code{with} clause; instead wrap the whole @iter{} form in a @code{multiple-value-bind}. @quotation Rationale There are subtle interactions between variable declarations and evaluation order that make the correct implementation of multiple-value destructuring in a @code{with} somewhat tricky. @end quotation The destructuring feature of @iter{} is available as a separate mechanism, using the @code{dsetq} macro: @itindex dsetq @defmac dsetq @v{template} @v{expr} Performs destructuring of @var{expr} using @var{template}. May be used outside of an @iter{} form. Yields the primary value of @var{expr}. @end defmac @c =================================================================== @node On-line Help @section On-line Help There is a limited facility for on-line help, in the form of the @code{display-iterate-clauses} function. @itindex display-iterate-clauses @defun display-iterate-clauses @k{&optional} @v{clause-spec} Displays a list of @iter{} clauses. If @var{clause-spec} is not provided, all clauses are shown; if it is a symbol, all clauses beginning with that symbol are shown; and if it is a list of symbols, all clauses for which @var{clause-spec} is a prefix are shown. @end defun @c =================================================================== @node Parallel Binding and Stepping @section Parallel Binding and Stepping The parallel binding and stepping of variables is a feature that @iter{} does @emph{not} have. This section attempts to provide a rationale. We say that two variables are bound @emph{in parallel} if neither binding shadows the other. This is the usual semantics of @code{let} (as opposed to @code{let*}). Similarly, we can say that iteration variables are stepped in parallel if neither variable is updated before the other, conceptually speaking; in other words, if the code to update each variable can reference the old values of both variables. @code{loop} allows parallel binding of variables and parallel stepping of driver variables. My view is that if you are depending on the serial/parallel distinction, you are doing something obscure. If you need to bind variables in parallel using @code{with}, then you must be using a variable name that shadows a name in the existing lexical environment. Don't do that. The most common use for parallel stepping is to track the values of variables on the previous iteration, but in fact this does not require parallel stepping at all; the following will work: @lisp (iter (for current in list) (for prev previous current) @dots{}) @end lisp @c =================================================================== @node Types and Declarations @chapter Types and Declarations @section Discussion Sometimes efficiency dictates that the types of variables be declared. This type information needs to be communicated to @iter{} so it can bind variables to appropriate values. Furthermore, @iter{} must often generate internal variables invisible to the user; there needs to be a way for these to be declared. As an example, consider this code, which will return the number of odd elements in @code{number-list}: @lisp (iter (for el in number-list) (count (oddp el))) @end lisp In processing this form, @iter{} will create an internal variable, let us call it @code{list17}, to hold the successive @code{cdr}s of @code{number-list}, and will bind the variable to @code{number-list}. It will also generate a default binding for @code{el}; only inside the body of the loop will @code{el} be set to the @code{car} of @code{list17}. Finally, @iter{} will generate a variable, call it @code{result}, to hold the result of the count, and will bind it to zero. When dealing with type declarations, @iter{} observes one simple rule: @emph{it will never generate a declaration unless requested to do so}. The reason is that such declarations might mask errors in compiled code by avoiding error-checks; the resulting problems would be doubly hard to track down because the declarations would be hidden from the programmer. Of course, a compiler might omit error-checks even in the absence of declarations, though this behavior can usually be avoided, e.g.@: by saying @code{(declaim (optimize (safety 3)))}. So, the above @iter{} form will generate code with no declarations. But say we wish to declare the types of @code{el} and the internal variables @code{list17} and @code{result}. How is this done? Declaring the type of @code{el} is easy, since the programmer knows the variable's name: @lisp (iter (for el in number-list) (declare (fixnum el)) (counting (oddp el))) @end lisp @iter{} can read variable type declarations like this one. Before processing any clauses, it scans the entire top-level form for type declarations and records the types, so that variable bindings can be performed correctly. In this case, @code{el} will be bound to zero instead of @code{nil}. Also, @iter{} collects all the top-level declarations and puts them at the begining of the generated code, so it is not necessary to place all declarations at the beginning of an @iter{} form; instead, they can be written near the variables whose types they declare. Since @iter{} is not part of the compiler, it will not know about declarations that occur outside an @iter{} form; these declarations must be repeated inside the form. Here is another way we could have declared the type of @code{el}: @lisp (iter (for (the fixnum el) in number-list) (counting (oddp el))) @end lisp @itindex the @iter{} extends the Common Lisp @code{the} form to apply to variables as well as value-producing forms; anywhere a variable is allowed---in a @code{with} clause, as the iteration variable in a driver clause, as the @code{into} argument of an accumulation clause, even inside a destructuring template---you can write @code{(the @var{type} @var{symbol})} instead. There is one crucial difference between using a @code{the} form and actually declaring the variable: explicit declarations are always placed in the generated code, but type information from a @code{the} form is not turned into an actual declaration unless you tell @iter{} to do so using @code{iterate:declare-variables}. See below. Declaring the types of internal variables is harder than declaring the types of explicitly mentioned variables, since their names are unknown. You do it by declaring @code{iterate:declare-variables} somewhere inside the top level of the @iter{} form. (This will also generate declarations for variables declared using @code{the}.) @iter{} does not provide much selectivity here: it's all or none. And unfortunately, since @iter{} is not privy to compiler information but instead reads declarations itself, it will not hear if you @code{(declaim (iterate:declare-variables))}. Instead, set the variable @code{iterate::*always-declare-variables*} to @code{t} at compile-time, using @code{eval-when}. To determine the appropriate types for internal variables, @iter{} uses three sources of information: @itemize @item Often, the particular clause dictates a certain type for a variable; @iter{} will use this information when available. In the current example, the variable @code{list17} will be given the type @code{list}, since that is the only type that makes sense; and the variable @code{result} will be given the type @code{fixnum}, on the assumption that you will not be counting high enough to need bignums. You can override this assumption only by using and explicitly declaring a variable: @lisp (iter (declare (iterate:declare-variables)) (for el in number-list) (count (oddp el) into my-result) (declare (integer my-result)) (finally (return my-result))) @end lisp Other examples of the type assumptions that @iter{} makes are: type @code{list} for @code{into} variables of collection clauses; type @code{list} for expressions that are to be destructured; type @code{vector} for the variable holding the vector in a @code{for@dots{} in-vector} clause, and similarly for @code{string} and the @code{for@dots{} in-string} clause; and the implementation-dependent type @code{(type-of array-dimension-limit)} for the index and limit variables generated by sequence iteration drivers like @code{for@dots{} in-vector} and @code{for@dots{} in-string} (but not @code{for@dots{} in-sequence}, because it may be used to iterate over a list). @item Sometimes, @iter{} will examine expressions and try to determine their types in a simple-minded way. If the expression is self-evaluating (like a number, for instance), @iter{} knows that the expression's type is the same as the type of the value it denotes, so it can use that type. If the expression is of the form @code{(the @var{type} @var{expr})}, @iter{} is smart enough to extract @var{type} and use it. However, the current version of @iter{} does not examine declarations of function result types or do any type inference. It will not determine, for example, that the type of @code{(+ 3 4)} is @code{fixnum}, or even @code{number}. @item In some cases, the type of an internal variable should match the type of some other variable. For instance, @iter{} generates an internal variable for @code{(f x)} in the clause @code{(for i from 1 to (f x))}, and in the absence of other information will give it the same type as @code{i}. If, however, the expression had been written @code{(the fixnum (f x))}, then @iter{} would have given the internal variable the type @code{fixnum} regardless of @code{i}'s type. The type incompatibility errors that could arise in this situation are not checked for. @end itemize Note that if you do declare @code{iterate:declare-variables}, then @iter{} may declare user variables as well as internal ones if they do not already have declarations, though only for variables that it binds. For instance, in this code: @lisp (iter (declare (iterate:declare-variables)) (for i from 1 to 10) (collect i into var)) @end lisp the variable @code{var} will be declared to be of type @code{list}. @section Summary @itindex declare-variables @itindex *always-declare-variables* @iter{} understands standard Common Lisp variable type declarations that occur within an @iter{} form and will pass them through to the generated code. If the declaration @code{(iterate:declare-variables)} appears at the top level of an @iter{} form, or if @code{iterate::*always-declare-variables*} is non-@code{nil}, then @iter{} will use the type information gleaned from user declarations, self-evaluating expressions and @code{the} expressions, combined with reasonable assumptions, to determine variable types and declare them. @c =================================================================== @node Problems with Code Movement @chapter Problems with Code Movement Some @iter{} clauses, or parts of clauses, result in code being moved from the location of the clause to other parts of the loop. Drivers behave this way, as do code-placement clauses like @code{initially} and @code{finally}. When using these clauses, there is a danger of writing an expression that makes sense in its apparent location but will be invalid or have a different meaning in another location. For example: @lisp (iter (for i from 1 to 10) (let ((x 3)) (initially (setq x 4)))) @end lisp While it may appear that the @code{x} of @code{(initially (setq x 4))} is the same as the @code{x} of @code{(let ((x 3)) @dots{}}, in fact they are not: @code{initially} moves its code outside the loop body, so @code{x} would refer to a global variable. Here is another example of the same problem: @lisp (iter (for i from 1 to 10) (let ((x 3)) (collect i into x))) @end lisp If this code were executed, @code{collect} would create a binding for its @code{x} at the top level of the @iter{} form that the @code{let} will shadow. Happily, @iter{} is smart enough to catch these errors; it walks all problematical code to ensure that free variables are not bound inside the loop body, and checks all variables it binds for the same problem. However, some errors cannot be caught: @lisp (iter (with x = 3) (for el in list) (setq x 1) (reducing el by #'+ initial-value x)) @end lisp @code{reducing} moves its @code{initial-value} argument to the initialization part of the loop in order to produce more efficient code. Since @iter{} does not perform data-flow analysis, it cannot determine that @code{x} is changed inside the loop; all it can establish is that @code{x} is not bound internally. Hence this code will not signal an error and will use @math{3} as the initial value of the reduction. The following list summarizes all cases that are subject to these code motion and variable-shadowing problems. @itemize @item Any variable for which @iter{} creates a binding, including those used in @code{with} and the @code{into} keyword of many clauses. @item The special clauses which place code: @code{initially}, @code{after-each}, @code{else}, @code{finally} and @code{finally-protected}. @item The variables of a @code{next} or @code{do-next} form. @item The @code{initially} arguments of @code{for@dots{} initially@dots{} then} and @code{for@dots{} previous}. @item The @code{then} argument of @code{for@dots{} initially@dots{} then}. @item The @code{initial-value} arguments of @code{reducing} and @code{accumulate}. @item The @code{on-failure} argument of @code{finding@dots{} such-that}. @end itemize @c =================================================================== @node Differences Between Iterate and Loop @chapter Differences Between @code{Iterate} and @code{Loop} @code{loop} contains a great deal of complexity which @iter{} tries to avoid. Hence many esoteric features of @code{loop} don't exist in @iter{}. Other features have been carried over, but in a cleaned-up form. And of course, many new features have been added; they are not mentioned in this list. @itemize @item @iter{}'s syntax is more Lisp-like than @code{loop}'s, having a higher density of parens. @item The current implementation of @iter{}, unlike the standardised version of @code{loop}, is extensible (see @ref{Rolling Your Own}). @item @code{loop} puts the updates of all driver variables at the top of the loop; @iter{} leaves them where the driver clauses appear. In particular, @iter{} allows to place drivers after @code{while} clauses. @item While for the most part @iter{} clauses that resemble @code{loop} clauses behave similarly, there are some differences. For instance, there is no @code{for@dots{} =@dots{} then} in @iter{}; instead use @code{for@dots{} initially@dots{} then}. @item @code{loop} binds the variable @code{it} at certain times to allow pseudo-English expressions like @code{when @var{expr} return it}. In @iter{}, you must bind @var{expr} to a variable yourself. Note that @code{when @var{expr} return it} is like @code{thereis @var{expr}} except that the latter is an accumulation clause and therefore competes with other accumulations (remember ``Multiple Accumulations'' in @ref{Other Features}). @c repeat different behaviour of |always| clause here? @item @code{loop} has a special @code{return} clause, illustrated in the previous item. @iter{} doesn't need one, since an ordinary Lisp @code{return} has the same effect. @item @code{loop} allows for parallel binding and stepping of iteration variables. @iter{} does not. (See @ref{Parallel Binding and Stepping}.) @item @code{loop} and @iter{} handle variable type declarations very differently. @code{loop} provides a special syntax for declaring variable types, and does not examine declarations. Moreover, the standard implementation of @code{loop} will generate declarations when none are requested. @iter{} parses standard Common Lisp type declarations, and will never declare a variable itself unless declarations are specifically requested. @end itemize @c =================================================================== @node Rolling Your Own @chapter Rolling Your Own @section Introduction @iter{} is extensible---you can write new clauses that embody new iteration patterns. You might want to write a new driver clause for a data structure of your own, or you might want to write a clause that collects or manipulates elements in a way not provided by @iter{}. This section describes how to write clauses for @iter{}. Writing a clause is like writing a macro. In fact, writing a clause @emph{is} writing a macro: since @iter{} code-walks its body and macroexpands, you can add new abstractions to @iter{} with good old @code{defmacro}. Actually, there are two extensions you can make to @iter{} that are even easier than writing a macro. They are adding a synonym for an existing clause and defining a driver clause for an indexable sequence. These can be done with @code{defsynonym} and @code{defclause-sequence}, respectively. See @ref{Extensibility Aids}. The rest of this section explains how to write macros that expand into @iter{} clauses. Here's how you could add a simplified version of @iter{}'s @code{multiply} clause, if @iter{} didn't already have one: @lisp (defmacro multiply (expr) `(reducing ,expr by #'* initial-value 1)) @end lisp If you found yourself summing the square of an expression often, you might want to write a macro for that. A first cut might be @lisp (defmacro sum-of-squares (expr) `(sum (* ,expr ,expr))) @end lisp but if you are an experienced macro writer, you will realize that this code will evaluate @var{expr} twice, which is probably a bad idea. A better version would use a temporary: @lisp (defmacro sum-of-squares (expr) (let ((temp (gensym))) `(let ((,temp ,expr)) (sum (* ,temp ,temp))))) @end lisp Although this may seem complex, it is just the sort of thing you'd have to go through to write any macro, which illustrates the point of this section: if you can write macros, you can extend @iter{}. Our macros don't use @iter{}'s keyword-argument syntax. We could just use keywords with @code{defmacro}, but we would still not be using @iter{}'s clause indexing mechanism. Unlike Lisp, which uses just the first symbol of a form to determine what function to call, @iter{} individuates clauses by the list of required keywords. For instance, @code{for@dots{} in} and @code{for@dots{} in-vector} are different clauses implemented by distinct Lisp functions. To buy into this indexing scheme, as well as the keyword-argument syntax, use @code{defmacro-clause}: @itindex defmacro-clause @defmac defmacro-clause @v{arglist} @k{&body} @v{body} Defines a new @iter{} clause. @var{arglist} is a list of symbols which are alternating keywords and arguments. @code{&optional} may be used, and the list may be terminated by @code{&sequence}. @var{body} is an ordinary macro body, as with @code{defmacro}. If the first form of @var{body} is a string, it is considered a documentation string and will be shown by @code{display-iterate-clauses}. @code{defmacro-clause} will signal an error if defining the clause would result in an ambiguity. E.g.@: you cannot define the clause @code{for@dots{} from} because there would be no way to distinguish it from a use of the @code{for} clause with optional keyword @code{from}. @end defmac Here is @code{multiply} using @code{defmacro-clause}. The keywords are capitalized for readability. @lisp (defmacro-clause (MULTIPLY expr &optional INTO var) `(reducing ,expr by #'* into ,var initial-value 1)) @end lisp You don't have to worry about the case when @code{var} is not supplied; for any clause with an @code{into} keyword, saying @code{into nil} is equivalent to omitting the @code{into} entirely. As another, more extended example, consider the fairly common iteration pattern that involves finding the sequence element that maximizes (or minimizes) some function. @iter{} provides this as @code{finding@dots{} maximizing}, but it's instructive to see how to write it. Here, in pseudocode, is how you might write such a loop for maximizing a function F: @example @r{set variable MAX-VAL to NIL;} @r{set variable WINNER to NIL;} @r{for each element EL in the sequence} @r{if MAX-VAL is NIL or F(EL) > MAX-VAL then} @r{set MAX-VAL to F(EL);} @r{set WINNER to EL;} @r{end if;} @r{end for;} @r{return WINNER.} @end example Here is the macro: @lisp (defmacro-clause (FINDING expr MAXIMIZING func &optional INTO var) "Simple FINDING... MAXIMIZING implementation" (let ((max-val (gensym "MAX-VAL")) (temp1 (gensym "EL")) (temp2 (gensym "VAL")) (winner (or var iterate::*result-var*))) `(progn (with ,max-val = nil) (with ,winner = nil) (let* ((,temp1 ,expr) (,temp2 (funcall ,func ,temp1))) (when (or (null ,max-val) (> ,temp2 ,max-val)) (setq ,winner ,temp1 ,max-val ,temp2)))))) @end lisp @c This example differs from the built-in finder: @c - The built-in one specifies the clause's value (el so far) @c (trivial to implement: add ,winner at end of progn) @c - The built-in one accepts an (el max-val) tuple var spec. @c - Influence of (the type var) on type declarations Note that if no @code{into} variable is supplied, we use @code{iterate::*result-var*}, which contains the internal variable into which all clauses place their results. If this variable is bound by some clause, then @iter{} will return its value automatically; otherwise, @code{nil} will be returned. @c The original example had four flaws: @c - ,expr and ,func occured twice in expansion @c - (finally (leave ,winner)) breaks because FINALLY does not walk @c its forms, so LEAVE does not work inside FINALLY. @c - Do not use (finally (return ,winner)) either, as that would @c always return winner, even in case of ... INTO nil. @c - Value of clause as form undefined, unlike all built-in clauses @menu * Writing Drivers:: * Extensibility Aids:: * Subtleties:: @end menu @c =================================================================== @node Writing Drivers @section Writing Drivers In principle, drivers can be implemented just as easily as other @iter{} clauses. In practice, they are a little harder to get right. As an example, consider writing a driver that iterates over all the elements of a vector, ignoring its fill-pointer. @code{for@dots{} in-vector} won't work for this, because it observes the fill-pointer. It's necessary to use @code{array-dimension} instead of @code{length} to obtain the size of the vector. Here is one approach: @lisp (defmacro-clause (FOR var IN-WHOLE-VECTOR v) "All the elements of a vector (disregards fill-pointer)" (let ((vect (gensym)) (index (gensym))) `(progn (with ,vect = ,v) (for ,index from 0 below (array-dimension ,vect 0)) (for ,var = (aref ,vect ,index))))) @end lisp Note that we immediately put @code{v} in a variable, in case it is an expression. Again, this is just good Lisp macrology. It also has a subtle effect on the semantics of the driver: @code{v} is evaluated only once, at the beginning of the loop, so changes to @code{v} in the loop have no effect on the driver. Similarly, the bounds for numerical iteration e.g.@: the above @code{array-dimension} are also evaluated once only. This is how all of @iter{}'s drivers work. There is an important point concerning the @code{progn} in this code. We need the @code{progn}, of course, because we are returning several forms, one of which is a driver. But @iter{} drivers must occur at top-level. Is this code in error? No, because @emph{top-level} is defined in @iter{} to include forms inside a @code{progn}. This is just the definition of top-level that Common Lisp uses, and for the same reason: to allow macros to return multiple forms at top-level. While our @code{for@dots{} in-whole-vector} clause will work, it is not ideal. In particular, it does not support generating. Do do so, we need to use @code{for@dots{} next} or @code{for@dots{} do-next}. The job is simplified by the @code{defmacro-driver} macro. @itindex defmacro-driver @defmac defmacro-driver @v{arglist} @k{&body} @v{body} Defines a driver clause in both the @code{for} and @code{generate} forms, and provides a parameter @code{generate} which @var{body} can examine to determine how it was invoked. @var{arglist} is as in @code{defmacro-clause}, and should begin with the symbol @code{for}. @end defmac With @code{defmacro-driver}, our driver looks like this: @lisp (defmacro-driver (FOR var IN-WHOLE-VECTOR v) "All the elements of a vector (disregards fill-pointer)" (let ((vect (gensym)) (end (gensym)) (index (gensym)) (kwd (if generate 'generate 'for))) `(progn (with ,vect = ,v) (with ,end = (array-dimension ,vect 0)) (with ,index = -1) (,kwd ,var next (progn (incf ,index) (if (>= ,index ,end) (terminate)) (aref ,vect ,index)))))) @end lisp We are still missing one thing: the @code{&sequence} keywords. We can get them easily enough, by writing @lisp (defmacro-driver (FOR var IN-WHOLE-VECTOR v &sequence) @dots{}) @end lisp We can now refer to parameters @code{from}, @code{to}, @code{by}, etc.@: which contain either the values for the corresponding keyword, or @code{nil} if the keyword was not supplied. Implementing the right code for these keywords is cumbersome but not difficult; it is left as an exercise. But before you begin, see @code{defclause-sequence} below for an easier way. @c =================================================================== @node Extensibility Aids @section Extensibility Aids This section documents assorted features that may be of use in extending @iter{}. @itindex *result-var* @defvr {Unexported Variable} *result-var* Holds the variable that is used to return a value as a result of the @iter{} form. You may examine this and use it in a @code{with} clause, but you should not change it. @end defvr @itindex defsynonym @defmac defsynonym @v{syn} @v{word} Makes @var{syn} a synonym for the existing @iter{} keyword @var{word}. Only the first word in each clause can have synonyms. @end defmac @itindex defclause-sequence @defmac defclause-sequence @v{element-name} @v{index-name} @k{&key} @ @v{access-fn} @v{size-fn} @v{sequence-type} @ @v{element-type} @v{element-doc-string} @ @v{index-doc-string} Provides a simple way to define sequence clauses. Generates two clauses, one for iterating over the sequence's elements, the other for iterating over its indices. The first symbol of both clauses will have print-name @code{for}. @var{element-name} and @var{index-name} should be symbols. @var{element-name} is the second keyword of the element iterator (typically of the form @code{in-@var{sequence-type}}), and @var{index-name} is the second keyword of the index-iterator (typically of the form @code{index-of-@var{sequence-type}}). Either name may be @code{nil}, in which case the corresponding clause is not defined. If both symbols are supplied, they should be in the same package. The @code{for} that begins the clauses will be in this package. @var{access-fn} is the function to be used to access elements of the sequence in the element iterator. The function should take two arguments, a sequence and an index, and return the appropriate element. @var{size-fn} should denote a function of one argument, a sequence, that returns its size. Both @var{access-fn} and @var{size-fn} are required for the element iterator, but only @var{size-fn} is needed for the index iterator. The @var{sequence-type} and @var{element-type} keywords are used to suggest types for the variables used to hold the sequence and the sequence elements, respectively. The usual rules about @iter{}'s treatment of variable type declarations apply (see @ref{Types and Declarations}). @var{element-doc-string} and @var{index-doc-string} are the documentation strings, for use with @code{display-iterate-clauses}. The generated element-iterator performs destructuring on the element variable. @end defmac As an example, the above @code{for@dots{} in-whole-vector} example could have been written: @lisp (defclause-sequence IN-WHOLE-VECTOR INDEX-OF-WHOLE-VECTOR :access-fn 'aref :size-fn (lambda (v) (array-dimension v 0)) :sequence-type 'vector :element-type t :element-doc-string "Elements of a vector, disregarding fill-pointer" :index-doc-string "Indices of vector, disregarding fill-pointer") @end lisp @c =================================================================== @node Subtleties @section Subtleties There are some subtleties to be aware of when writing @iter{} clauses. First, the code returned by your macros may be @code{nconc}'ed into a list, so you should always returned freshly consed lists, rather than constants. Second, @iter{} matches clauses by using @code{eq} on the first symbol and @code{string=} on the subsequent ones, so the package of the first symbol of a clause is relevant. All of the clauses in this manual have their first word in the @iter{} package. You can use the package system in the usual way to shadow @iter{} clauses without replacing them. @c say more here, about the badness that only the first word of a @c clause is packagey. @c =================================================================== @node Non-portable Extensions to Iterate (Contribs) @chapter Non-portable Extensions to Iterate (Contribs) Currently, there is only one non-portable extension to iterate in the distribution: @code{iterate-pg}. If you have made an extension that depends on non-portable features, feel free to send them to the @iter{} project team for inclusion in the iterate distribution. @section An SQL Query Driver for Iterate The pg package by Eric Marsden (see @url{http://cliki.net/pg}) provides an interface to the PostgreSQL database. Using the @code{in-relation} driver, it is possible to handle the results of SQL queries with @iter{}. This usage example should give you an idea of how to use it: @lisp (pg:with-pg-connection (c "somedb" "someuser") (iter (for (impl version date) in-relation "select * from version" on-connection *dbconn*) (collect version))) @end lisp The distribution now contains an @file{iterate.asd} system definition file for the @iter{} package. To use the extension via @acronym{ASDF, Another System Definition Facility}, simply make your system depend on the @code{iterate-pg} system instead of the @code{iterate} system. To load it manually, use: @lisp (asdf:oos 'asdf:load-op :iterate-pg) @end lisp @c =================================================================== @node Obtaining Iterate @chapter Obtaining @code{Iterate} @iter{} has been successfully ported to most implementations that purport to conform to ANSI CL. Since 2006, source and project information is available from @url{http://common-lisp.net/project/iterate/}. The mailing list for all purposes is @email{iterate-devel@@common-lisp.net}, but you need to subscribe to it before posting. The source file was split into two files in 2003: @file{package.lisp} contains the package definition, @file{iterate.lisp} the main code. Other files in the distribution contain user contributions, test cases and documentation. @iter{} resides in the @code{iterate} package (nickname @code{iter}). Just say @code{(use-package :iterate)} to make all the necessary symbols available. If a symbol is not exported, it appears in this manual with an ``@code{iterate::}'' prefix. The regression test suite in @file{iterate-test.lisp}, based on @acronym{MIT}'s @code{RT} package, contains many examples. @quotation Note The rest of this chapter serves history. @end quotation @iter{} currently runs on Lisp Machines, and on HP's, Sun3's and Sparcstations under Lucid. @iter{} source and binaries are available at the @acronym{MIT} @acronym{AI} Lab in the subdirectories of @file{/src/local/lisplib/}. The source file, @code{iterate.lisp}, is also available for anonymous FTP in the directory @file{/com/ftp/pub/} on the machine @code{TRIX.AI.MIT.EDU} (Internet number 128.52.32.6). If you are unable to obtain @code{iterate} in one of these ways, send mail to @email{jba@@ai.mit.edu} and I will send you the source file. Send bug reports to @email{bug-iterate@@ai.mit.edu}. The @code{info-iterate} mailing list will have notices of changes and problems; to have yourself added, send mail to @email{info-iterate-request@@ai.mit.edu}. @c =================================================================== @node Acknowledgements @chapter Acknowledgements Richard Waters provided invaluable criticism which spurred me to improve @iter{} greatly. As early users, David Clemens, Oren Etzioni and Jeff Siskind helped ferret out many bugs. Thanks to Andreas Fuch, J@"org H@"ohle and Attila Lendvai, who more than a decade after the original release, ported the code to ANSI CL and fixed long-standing bugs. @c =================================================================== @node Don't Loop Iterate @appendix Don't Loop, Iterate @quotation Note This appendix is a Texinfo conversion performed by Lu@'{@dotless{i}}s Oliveira of Jonathan Amsterdam's Working Paper 324, MIT AI Lab entitled ``Don't Loop, Iterate.'' @end quotation @section Introduction Above all the wonders of Lisp's pantheon stand its metalinguistic tools; by their grace have Lisp's acolytes been liberated from the rigid asceticism of lesser faiths. Thanks to Macro and kin, the jolly, complacent Lisp hacker can gaze through a fragrant cloud of setfs and defstructs at the emaciated unfortunates below, scraping out their meager code in inflexible notation, and sneer superciliously. It's a good feeling. But all's not joy in Consville. For---I beg your pardon, but---there really is no good way to @emph{iterate} in Lisp. Now, some are happy to map their way about, whether for real with @code{mapcar} and friends, or with the make-believe of Series; others are so satisfied with @code{do} it's a wonder they're not C hackers.@footnote{Hey, don't get mad---I'll be much more polite later, when the real paper starts.} Still others have gotten by with @code{loop}, but are getting tired of looking up the syntax in the manual over and over again. And in the elegant schemes of some, only tail recursion and lambdas figure. But that still leaves a sizeable majority of folk---well, me, at least---who would simply like to @emph{iterate}, thank you, but in a way that provides nice abstractions, is extensible, and looks like honest-to-God Lisp. In what follows I describe a macro package, called @iter{}, that provides the power and convenient abstractions of @code{loop} but in a more syntactically palatable way. @code{iter} also has many features that @code{loop} lacks, like generators and better support for nested loops. @iter{} generates inline code, so it's more efficient than using the higher-order function approach. And @iter{} is also extensible---it's easy to add new clauses to its vocabulary in order to express new patterns of iteration in a convenient way. @c \iter\ is fully documented in AI Lab Memo No.@: 1236, \iman. @section More about @iter{} A Common Lisp programmer who wonders what's lacking with present-day iteration features would do well to consider @code{setf}. Of course, @code{setf} doesn't iterate, but it has some other nice properties. It's easy to use, for one thing. It's extensible---you can define new @code{setf} methods very easily, so that @code{setf} will work with new forms. @code{setf} is also efficient, turning into code that's as good as anyone could write by hand. Arguably, @code{setf} provides a nice abstraction: it allows you to view value-returning forms, like @code{(car @dots{})} or @code{(get @dots{})} as locations that can be stored into. Finally and most obviously, @code{setf} @emph{looks} like Lisp; it's got a syntax right out of @code{setq}. @iter{} attempts to provide all of these properties. Here is a simple use of @iter{} that returns all the elements of @code{num-list} that are greater than three: @lisp (iterate (for el in num-list) (when (> el 3) (collect el))) @end lisp An @iter{} form consists of the symbol @iter{} followed by some Lisp forms. Any legal Lisp form is allowed, as well as certain forms that @iter{} treats specially, called @emph{clauses}. @code{for@dots{}in} and @code{collect} are the two clauses in the above example. An @iter{} clause can appear anywhere a Lisp form can appear; @iter{} walks its body, looking inside every form, processing @iter{} clauses when it finds them. It even expands macros, so you can write macros that contain @iter{} clauses. Almost all clauses use the syntax of function keyword-argument lists: alternating keywords and arguments. @iter{} keywords don't require a preceding colon, but you can use one if you like. @iter{} provides many convenient iteration abstractions, most of them familiar to @code{loop} users. Iteration-driving clauses (those beginning with @code{for}) can iterate over numbers, lists, arrays, hashtables, packages and files. There are clauses for collecting values into a list, summing and counting, maximizing, finding maximal elements, and various other things. Here are a few examples, for extra flavor. To sum a list of numbers: @lisp (iterate (for i in list) (sum i)) @end lisp To find the length of the shortest element in a list: @lisp (iterate (for el in list) (minimize (length el))) @end lisp To find the shortest element in a list: @lisp (iterate (for el in list) (finding el minimizing (length el))) @end lisp To return @code{t} only if every other element of a list is odd: @lisp (iterate (for els on list by #'cddr) (always (oddp (car els)))) @end lisp To split an association list into two separate lists (this example uses @iter{}'s ability to do destructuring): @lisp (iterate (for (key . item) in alist) (collect key into keys) (collect item into items) (finally (return (values keys items)))) @end lisp @section Comparisons With Other Iteration Methods As with any aspect of coding, how to iterate is a matter of taste. I do not wish to dictate taste or even to suggest that @iter{} is a ``better'' way to iterate than other methods. I would, however, like to examine the options, and explain why I prefer @iter{} to its competitors. @subsection @code{do}, @code{dotimes} and @code{dolist} The @code{do} form has long been a Lisp iteration staple. It provides for binding of iteration variables, an end-test, and a body of arbitrary code. It can be a bit cumbersome for simple applications, but the most common special cases---iterating over the integers from zero and over the members of a list---appear more conveniently as @code{dotimes} and @code{dolist}. @code{do}'s major problem is that it provides no abstraction. For example, collection is typically handled by binding a variable to @code{nil}, pushing elements onto the variable, and @code{nreverse}ing the result before returning it. Such a common iteration pattern should be easier to write. (It is, using @code{mapcar}---but see below.) Another problem with @code{do}, for me at least, is that it's hard to read. The crucial end-test is buried between the bindings and the body, marked off only by an extra set of parens (and some indentation). It is also unclear, until after a moment of recollection, whether the end-test has the sense of a ``while'' or an ``until.'' Despite its flaws, @code{do} is superior to the iteration facilities of every other major programming language except CLU. Perhaps that is the reason many Lisp programmers don't mind using it. @subsection Tail Recursion @c FIXME: removed citation due to laziness Tail-recursive implementations of loops, like those found in Scheme code [SchemeBook], are parsimonious and illuminating. They have the advantage of looking like recursion, hence unifying the notation for two different types of processes. For example, if only tail-recursion is used, a loop that operates on list elements from front to back looks very much like a recursion that operates on them from back to front. However, using tail-recursion exclusively can lead to cumbersome code and a proliferation of functions, especially when one would like to embed a loop inside a function. Tail-recursion also provides no abstraction for iteration; in Scheme, that is typically done with higher-order functions. @subsection High-order Functions Lisp's age-old mapping functions, recently revamped for Common Lisp [CLM], are another favorite for iteration. They provide a pleasing abstraction, and it's easy to write new higher-order functions to express common iteration patterns. Common Lisp already comes with many such useful functions, for removing, searching, and performing reductions on lists. Another Common Lisp advantage is that these functions work on any sequence---vectors as well as lists. One problem with higher-order functions is that they are inefficient, requiring multiple calls on their argument function. While the the built-ins, like @code{map} and @code{mapcar}, can be open-coded, that cannot be so easily done for user-written functions. Also, using higher-order functions often results in the creation of intermediate sequences that could be avoided if the iteration were written out explicitly. The second problem with higher-order functions is very much a matter of personal taste. While higher-order functions are theoretically elegant, they are often cumbersome to read and write. The unpleasant sharp-quote required by Common Lisp is particularly annoying here, and even in Scheme, I find the presence of a lambda with its argument list visually distracting. Another problem is that it's difficult to express iteration of sequences of integers without creating such sequences explicitly as lists or arrays. One could resort to tail-recursion or @code{dotimes}---but then it becomes very messy to express double iterations where one driver is over integers. Multiple iteration is easy in @iter{}, as illustrated by the following example, which creates an alist of list elements and their positions: @lisp (iterate (for el in list) (for i from 0) (collect (cons el i))) @end lisp @subsection Streams and Generators For really heavy-duty iteration jobs, nothing less than a coroutine-like mechanism will do. Such mechanisms hide the state of the iteration behind a convenient abstraction. A @emph{generator} is a procedure that returns the next element in the iteration each time it is called. A @emph{stream} (in the terminology of [SchemeBook]) is a data structure which represents the iteration, but which computes the next element only on demand. Generators and streams support a similar style of programming. Here, for example, is how you might enumerate the leaves of a tree (represented as a Lisp list with atoms at the leaves) using streams: @lisp (defun tree-leaves (tree) (if (atom tree) (stream-cons tree empty-stream) (stream-append (tree-leaves (car tree)) (tree-leaves (cdr tree))))) @end lisp Although @code{tree-leaves} looks like an ordinary recursion, it will only do enough work to find the first leaf before returning. The stream it returns can be accessed with @code{stream-car}, which will yield the (already computed) first leaf of the tree, or with @code{stream-cdr}, which will initiate computation of the next leaf. Such a computation would be cumbersome to write using @iter{}, or any of the other standard iteration constructs; in fact, it is not even technically speaking an iteration, if we confine that term to processes that take constant space and linear time. Streams, then, are definitely more powerful than standard iteration machinery. Unfortunately, streams are very expensive, since they must somehow save the state of the computation. Generators are typically cheaper, but are less powerful and still require at least a function call. So these powerful tools should be used only when necessary, and that is not very often; most of the time, ordinary iteration suffices. There is one aspect of generators that @iter{} can capture, and that is the ability to produce elements on demand. Say we wish to create an alist that pairs the non-null elements of a list with the positive integers. We saw above that it is easy to iterate over a list and a series of numbers simultaneously, but here we would like to do something a little different: we want to iterate over the list of elements, but only draw a number when we need one (namely, when a list element is non-null). The solution employs the @iter{} @code{generate} keyword in place of @code{for} and the special clause @code{next}: @lisp (iterate (for el in list) (generate i from 1) (if el (collect (cons el (next i))))) @end lisp Using @code{next} with any driver variable changes how that driver works. Instead of supplying its values one at a time on each iteration, the driver computes a value only when a @code{next} clause is executed. This ability to obtain values on demand greatly increases @iter{}'s power. Here, @code{el} is set to the next element of the list on each iteration, as usual; but @code{i} is set only when @code{(next i)} is executed. @subsection Series Richard C. Waters has developed a very elegant notation called Series which allows iteration to be expressed as sequence-mapping somewhat in the style of APL, but which compiles to efficient looping code [Series]. My reasons for not using Series are, again, matters of taste. Like many elegant notations, Series can be somewhat cryptic. Understanding what a Series expression does can require some effort until one has mastered the idiom. And if you wish to share your code with others, they will have to learn Series as well. @iter{} suffers from this problem to some extent, but since the iteration metaphor it proposes is much more familiar to most programmers than that of Series, it is considerably easier to learn and read. @subsection @code{Prog} and @code{Go} Oh, don't be silly. @subsection @code{Loop} @code{loop} is the iteration construct most similar to @iter{} in appearance. @code{loop} is a macro written originally for MacLisp and in widespread use [Loop]. It has been adopted as part of Common Lisp. @code{loop} provides high-level iteration with abstractions for collecting, summing, maximizing and so on. Recall our first @iter{} example: @lisp (iterate (for el in num-list) (when (> el 3) (collect el))) @end lisp Expressed with @code{loop}, it would read @lisp (loop for el in list when (> el 3) collect el) @end lisp The similarity between the two macros should immediately be apparent. Most of @iter{}'s clauses were borrowed from @code{loop}. But compared to @iter{}, @code{loop} has a paucity of parens. Though touted as more readable than heavily-parenthesized code, @code{loop}'s Pascalish syntax creates several problems. First, many dyed-in-the-wool Lisp hackers simply find it ugly. Second, it requires learning the syntax of a whole new sublanguage. Third, the absence of parens makes it hard to parse, both by machine and, more importantly, by human. Fourth, one often has to consult the manual to recall lesser-used aspects of the strange syntax. Fifth, there is no good interface with the rest of Lisp, so @code{loop} clauses cannot appear inside Lisp forms and macros cannot expand to pieces of @code{loop}. And Sixth, pretty-printers and indenters that don't know about @code{loop} will invariably display it wrongly. This is particularly a problem with program-editor indenters. A reasonably clever indenter, like that of Gnu Emacs, can indent nearly any normal Lisp form correctly, and can be easily customized for most new forms. But it can't at present handle @code{loop}. The syntax of @iter{} was designed to keep parens to a minimum, but conform close enough to Lisp so as not to confuse code-display tools. Gnu Emacs indents @iter{} reasonably with no modifications. Indenting is a mere annoyance; @code{loop}'s lack of extensibility is a more serious problem. The original @code{loop} was completely extensible, but the Symbolics version only provides for the definition of new iteration-driving clauses, and the Common Lisp specification does not have any extension mechanism. But extensibility is a boon. Consider first the problem of adding the elements of a list together, which can be accomplished with @iter{} by @lisp (iterate (for el in list) (sum el)) @end lisp and in @code{loop} with @lisp (loop for el in list sum el) @end lisp But now, say that you wished to compute the sum of the square roots of the elements. You could of course write, in either @code{loop} or @iter{}, @lisp (iterate (for el in list) (sum (sqrt el))) @end lisp But perhaps you find yourself writing such loops often enough to make it worthwhile to create a new abstraction. There is nothing you can do in @code{loop}, but in @iter{} you could simply write a macro: @lisp (defmacro (sum-of-sqrts expr &optional into-var) `(sum (sqrt ,expr) into ,into-var)) @end lisp @code{sum-of-sqrts} is a perfectly ordinary Lisp macro. Since @iter{} expands all macros and processes the results, @code{(sum-of-sqrts el)} will behave exactly as if we'd written @code{(sum (sqrt el))}. There's also a way to define macros that use @iter{}'s clause syntax. @c removed citation again @c Just to beat a dead horse, I'd like to point out that there's no @c way to define {\lisp for...maximizing} in \looP.\footnote{In fact, @c it was in part the frustration of knowing that \looP\ could @c generate code to maximize a value, but could not be easily altered @c to supply the element associated with that maximum, that prompted @c me to write \iter.} @section Implementation A Common Lisp implementation of @iter{} has existed for well over a year. It runs under Lucid for HP 300's, Sun 3's and SPARCstations, and on Symbolics Lisp machines. @c See \iman\ for details. @section Conclusion Iteration is a matter of taste. I find @iter{} more palatable than other iteration constructs: it's more readable, more efficient than most, provides nice abstractions, and can be extended. If you're new to Lisp iteration, start with @iter{}---look before you @code{loop}. If you're already using @code{loop} and like the power that it offers, but have had enough of its syntax and inflexibility, then my advice to you is, don't @code{loop}---@iter{}. @section Acknowledgments Thanks to David Clemens for many helpful suggestions and for the egregious pun near the end. Conversations with Richard Waters prompted me to add many improvements to @iter{}. Alan Bawden, Sundar Narasimhan, and Jerry Roylance also provided useful comments. David Clemens and Oren Etzioni shared with me the joys of beta-testing. @section Bibliography @itemize @item [SchemeBook] Abelson, Harold and Gerald Jay Sussman. @emph{Structure and Interpretation of Computer Programs.} Cambridge, MA: The MIT Press, 1985. @item [Loop] ``The loop Iteration Macro.'' In @emph{Symbolics Common Lisp---Language Concepts}, manual 2A of the Symbolics documentation, pp.@: 541--567. @item [CLM] Steele, Guy L@. @emph{Common Lisp: The Language}. Bedford, MA: Digital Press, 1984. @item [Series] Waters, Richard C@. @emph{Optimization of Series Expressions: Part I: User's Manual for the Series Macro Package}. MIT AI Lab Memo No.@: 1082. @end itemize @c =================================================================== @node Comprehensive Index @unnumbered Index @printindex cp @bye iterate-20160825-darcs/doc/examples/0000755000000000000000000000000012757566717015312 5ustar0000000000000000iterate-20160825-darcs/doc/examples/iterate-pg.lisp0000644000000000000000000000625312757566717020252 0ustar0000000000000000;;;-*- LISP -*- ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; An ITERATE driver for postgresql queries via PG (http://cliki.net/pg) ;;; Written by Andreas Fuchs ;;; ;;; Permission to use, copy, modify, and distribute this software and its ;;; documentation for any purpose and without fee is hereby granted, ;;; provided that this copyright and permission notice appear in all ;;; copies and supporting documentation, and that the name of M.I.T. not ;;; be used in advertising or publicity pertaining to distribution of the ;;; software without specific, written prior permission. M.I.T. makes no ;;; representations about the suitability of this software for any ;;; purpose. It is provided "as is" without express or implied warranty. ;;; M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ;;; ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL ;;; M.I.T. BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ;;; ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, ;;; WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ;;; ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS ;;; SOFTWARE. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; An extension to Eric Marsden's pg.lisp: ;;; https://gitlab.common-lisp.net/pg/pg ;;; https://common-lisp.net/project/pg/ ;;; As of 2016 pg seems to be abandoned and also superseded by Postmodern: ;;; http://marijnhaverbeke.nl/postmodern/ ;;; Usage example: ;;; (iterate (for (impl version date) in-relation "select * from version" on-connection *dbconn*) ;;; (collect version)) (cl:in-package :iterate) (defvar *in-pg-transaction* nil) (defmacro with-pg-cursor (cursor connection query &body body) (let ((conn (gensym)) (begin-transaction (gensym)) (success (gensym))) `(let ((,cursor (symbol-name (gensym "PGCURSOR"))) (,conn ,connection) (,begin-transaction (not *in-pg-transaction*)) (,success nil) (*in-pg-transaction* t)) (when ,begin-transaction (pg:pg-exec ,conn "BEGIN WORK")) (pg:pg-exec ,conn "DECLARE " ,cursor " CURSOR FOR " ,query) (unwind-protect (multiple-value-prog1 (progn ,@body) (setf ,success t)) (pg:pg-exec ,conn "CLOSE " ,cursor) (when ,begin-transaction (pg:pg-exec ,conn (if ,success "COMMIT WORK" "ROLLBACK WORK"))))))) (defclause-driver (FOR var-spec IN-RELATION query ON-CONNECTION conn) (top-level-check) (let* ((row-var (make-var-and-default-binding 'row :type 'list)) (cursor (gensym "CURSOR")) (test `(when (null ,row-var) (go ,*loop-end*))) (setq (do-dsetq var-spec row-var))) (add-loop-body-wrapper `(with-pg-cursor ,cursor ,conn ,query)) (setf *loop-end-used?* t) (return-driver-code :next (list `(setq ,row-var (first (pg:pg-result (pg:pg-exec ,conn "FETCH 1 FROM " ,cursor) :tuples))) test setq) :variable var-spec))) ;;; arch-tag: c08d68b2-63b2-4347-b261-133ae30b3e18iterate-20160825-darcs/doc/tex/0000755000000000000000000000000012757566717014274 5ustar0000000000000000iterate-20160825-darcs/doc/tex/iterate-bare.pdf0000644000000000000000000037672512757566717017357 0ustar0000000000000000%PDF-1.3 %쏢 6 0 obj <> stream xW{SgEZ.+!9iձlκNN&=6MKڲJb[]Ud\DϺ1+(~L =i\W6}ϛ!b3Y CfaÐ?Z}a܆3FBE4YM~C޽f{ֽmXSfm(?`\_}ok?i}n&fhݷuK[{\Pza6<{/io6 v+_ݺa&ommkmnh8m5 [ =UOxhc;|O=G~NhLBԮz%eA)uJ$(EUq}bq%Ġ,U$X7,?460␒yJڕ ƼbOs69]/>ѝ酘l<=1:Հ,fҸP5"êw0NdRvKQ)#UId9]#tX<2),&i:}GG㕢,4)B}e +,:us]H Eγ/FIM9'9Q|G;|bm8/0 ( {"-1=aP& 2(0NeQMm2JZOP$JPƲIO)f4zWR(3wB tgKR2 %ӓH5iq)c  MEC "?w+XXq3:-ҁ1- 2ye L#jOfB&6E:B WS| = mbx<s{͵nXjwS8UA@x; ;Ψ]"UyMJCj圮^i2:5 @#C 3о)Ձ&Wu35ye@)MK( ##U91T➞^ْr54X4'U;x!;˩^·/_xDXU" Ka VC.]\yJI;4ʳ.F-#&Aġ`bcYPy' S^<=rgΏYy=6?Mܼ}߯TĪTVۤf[MsJZvoAYIѧUƜ +‹u!5ef:F8Ծ%g3Jb&Vrc\bXO tUMĢj+lO$AxcjM`U@}ō|*F풿c w:D(f5+@@MT<Zta'g?ZCR* :lR΀Pfwcs(D-Pn9t"c+3=I@_[,a9_(?_2\\OMbm1e}j`[lA0V\y ?_lB`׭,rw35n|#{ʢ'cV!ZC\hi#nY\/ =k5W7Z%^^9\{ׇZf7Vk3˩37\/q+g> stream xmUmsU1 iHqX/1|2tH6d]BHi&0)jX@БO2ៈw7NI޳>9y8裩Xs9NdQ[Qyg'C3} L_9K躼PԣuULլZ]r⒒\%{PTn9"حW8m"^L$BTpz?gn$(H3_m|ٳ;_Ξ?czC3&a%:zy+/_@wNcz@Ba`c=no^B(`-cۢ/=ku¯y S̀w2,?zygϑBB7F{F\k|.)&0S9w=S 5rZYIھ1}H|M5OZڅ!8M2)]|>[&} 3 ,(A.u5gp@*ס};R"RkhËY`%t}ާ{Ff[{XP#FPbK2$1.KQuyXb^܊ZH444*`otUd!fyؠ>.yOT$tBW~s|$# fQ~;u)áejmc7d`zM%&86%bI{@Zˆ 4X 8<.DO˷䲀ƸW 8T WKiO\:rކh=6LmO=iW'5]˄˃C'C=&~rC9}1s6L 1 Mnğ|Uendstream endobj 246 0 obj 1477 endobj 287 0 obj <> stream xXOU#"6RA*KqJe]C:9לh6?[Yܔ*;ʮ8qo'!'z>yu\b^qm3:%eKD4dcf>>m~ '|̗=dII:+շ|JJ4I38[)OyI)To"3 yr܇Mc̔V)dkG%ΤwbDl}ř *1g|+Yގ_RI6 Eu/N s!Igd&_8)%#X4VVj = ד*XwZCr_)^(h(j>UNg^#Jz4T&cRW]$!׈3@Fyꠞz@ ckVsmՔtid"ݩQ*E=7UFocTQd+Я,2PuV/& w(n &uhP6_&Ʋ9f b5l.NswhnFzh3hU(6-[iTF.-5) u(T%AAK8kl7PBU1Iʎ)5?6]y7c$1Dfn&BC 5! Jxm,@r+r.0ڠbԈXFLjʠdQl{۠UQ AhCG(ygZxҥkC*YSLH&>_lf=6y¼ *a%s\1|Ao 4Ѐ*+Ц?cposr[~[ _g}G~вZxO&ϡcӶ/!πwOKaV":-5JOB:oiicc>NqN(_ Oʉmxc-v}:tlBKtܠƚ &27(Du9mZ;:݆NGkގZ]~U_   û/="31rҜXvM^QCoP 61@A_DغTs.#;W[I^܋~v`~>lO/3grc 5q?GV℡8q&]_6qz H־Pm܍6C>k$MPV;жu<<VzH@@3[mP7z nt,~֦4;nD||ԧ<)|tE_Vendstream endobj 288 0 obj 2114 endobj 308 0 obj <> stream xXO["!A[(QZ@m_m.q>ifnOOmYKeoc퍥}w6;~o;'RY5LCe!vVV{tF苽ϴN2O2VPXaOq#9YHhtXhtoz|7?֦daTIgpB+㏫'Jy:<*pIMҙ:9s"s;͂@?- 6{tsၲ)v_un[q"fsnOqʙ'ܪKZF]ve}oqYQv;_rn'soGXT{B#̈́ Vޗm+fyr 7\j[Evl<Vy{!On*)TrPul.tSu#ivjz[#nl)M9kWFئΥ.\<ʭx}cU94 $sLl 0Imjr5Bw'WO_7\vT/#k} /ͭ{4R=n#WHj.HgeQ`tKI(L^*'8ֆT?b({R>II(&Ä\ҟxLtPS . @ޘ*ZB:ZEd$RcӰǔ(Ca6m¯~їX\I},j3g+4rh~\n~rQaV#O0'SSW㥓 ˽^u9t{)pFh&k{_FR1Lt2Á0!_9J0 s{l nWKRwRARY96Su >r)> k-0@bhZ";/Y2;6-~=52XR@;ν&+\7zm4fh_,k, M9;94x~[#& MU45-Z7\γke8ր<5#"#WJn ݐX#.&ᬎçUUE͢l6’Hai}"ͽ7ȉѨԍ?!_{qGˋx\cW_ܧy9F[:tp6h?E i ɊF?`hƔ2W!{ct0pCLcސ8{#{:z!XK?vlF  $RrbhBW}tB/oާ~J1h7d.̴nt}eć9?kbx,$=$4u8!~DyG? UlT67 qb- qM㈘+NˆD%A4"YF@vtKY>=eG܇AJ]?gQNM ">/uTl+_(@ 3ﶮpN8ɏ ^ћ~Nrendstream endobj 309 0 obj 2511 endobj 347 0 obj <> stream xXO[!E E΢Ie5K*C+8׾ \IpKJaƇ|p5ٺIST5i%i{ιNE"q=9yzu\_ѻڻjsg ;ދܶRpݣ^-oF]6˿z8 k_];[oPݾsnngxwrcƦ#w6&+ hô&̺.Z6zUb Dbr,{ %t,]D`(z0v⬬)CKºTR$x)Wzl#9Y.eΔ"r& {6/WSߴ?5ᶍO?=@I0-VS԰g/ktsw ZByH+d,WMJJe@[*WErBҳ>95#%qZQGfҙ*ai~>9,CFyg"'祄]Zzzx̀$)nҸIcx3?UDB(h{&jXnK{ r%SeIޗHĚoUT4#5|Ǣ^!R1\B6Sdz@T]h=0çT-XtGfP.]Bo>3!y#8 O0']M e_VL B]W Ghinjr2x}8A+.7Q`_H_=}E>{ &~#Ps|Qo>w<NOyvO#?摑ӵ@O! kGΫŊ$|&k%Cp~9: \JU/N˛Fywc?6WNOk$h-%`CKwxx JhZp o+_ANLE6[Xf ] `c2>LGCh0P Lg»',¿6a* fac"!5Ǘd'q1 ^@b7!qΛсTU =7r+j0Giך8'P?-25$Cã֧9bP2ynpcߤhfPld4x5!G-.n"D{WDtюSF|hTy?G.҉hˏyywbTc>f I\~hN4 I)z=䎘(|Wޡ=w ؄>LC Mk\̓b c'JN0"OQl.Ar-`E8pڏ;cO1̵ =w2sǟWMY"< }y~'50Ӈ&vӢa f=7(g6+5{iDx[XSM.Oֺjo?zw'R5}kDQ7a/Æq:}zNJ:Ma~Vd3PQGY鞹Ia38I˷K:< ,s<ʑ4 `C0).6LmlMwia~()(!a(.5^)CڄIEeoCJb"̐׋Eou" i ԑPHퟢ׋]")"'UI,@/1bd2kqPiaY$~Vխ:8U)o٥:AOIrq znJ|ԤE,`Jӂe4_I/ls9j5jW stE?'tA֬oPu5p/0Y װ9eIuи#SKE rzΌY3 y-?&VN9 -忭DSb8:kJ5$0i>5.n Wzj]~,MruF'|7ghǐrp[7:0~ֲYG81$r"7@ ]i?ZDStf3h"3Ѻr"Mx-ĜL$̆eRƠ&]\gsߪoO);Q" |ޭxөhq%e's62 PĂY!‹$_'a{Co!1*P_6-
QaqKfpB5>%:h^)el]m)qEGtwSJڼ] <$UO{MisQq@AWwY&//J,Wu#*R}3 ?Ց Oxm5~R[Sngsm!-YDq{\^73aK(endstream endobj 348 0 obj 2783 endobj 373 0 obj <> stream xXO[&D#iXp&1f}_cse*864q AQ(FQe,DIH"m_яe@9{%da}ysy=k8v馳Mg~en::Mեp0ۡç:]L:d>6U fWM,ሱȈfәaȥCT:tÙ#Gy]X:G7C*J}ִsi癶6lW>z1k˾SyJvO~\UO+ۖϤ}{wЩؕ fnUagS>hOdCPDv'mEq=oD5H‘th(c,bS#z:/^Y#eTf3ϟHv³1]]"bH~n+be:c䦹vэt( 5>OU8gbn7cY5[x;dg\S囍Gs)6#IZ 9H9xXMh_1g /f9GJOԐn Y3x[ l7vsv!I ;n@6{g'uk+d$ a\!`‘!+1M]b P%b0]拗_Aax )@ȓ xś(vfꎴviՇz1.h7({뚐FR@ GvdA|,"ˈe*)uctL ]urO9z8V_Ԑ40g IZk묱K섬ypI,h[u #RNϷmf7% ܡ{|D$8fIU%r j,q g ?0=GB1ĎJjW`8Ȩ:sdy%L:y:END0QFL\ PԬ*u{h-&E <nWY~N} R& Q1 /S9Bxާ@~]O]6[RLfyauxG9uػ~0حWv/$ji-\8̶^O*hzM9}#w_TvrA;~^易2+Ns?f쐅!y }_aYls݊,y`0w6|WK.cs\vXb!RmG ypϿ!ss2a{V%k[LO>I) ʄoשA2(sIK⬪GtSϿX2fL9EҜCK T IRT}l4%׋ q'b+XɤP,N Y2p*C9=KfD+VQ1\_j~;@Qtd]B%**Z5O{hLJR:h$)(#gP?zddLҷ$~mZZn f/VHCf]V.5oӝV<U(TA\6@n!$АEk/pmvl^09rmwxlIʅvtw:}Õ6Whk=oSRL:\]][ A$^ Ih+d#$H"U5_FO'Am}G/[@#KQ|Yrj@wY:B+.ʣT+bp;iL HW&>cC܊6F]33NF: |v`&sXW8(DG]%* W1 #ی5y9zW<QLV\04ڤ,"?KXq{)gEJ~s` n]U&dyU1r payDy]ap}jߠczm\Y ѻ Aa\JrC  ssD7k`LuG,pUGQEyn0B,mշYxQqG75w}ZpM׽4&^YT,ŦQMGjQY^&Vf!]UmtyRendstream endobj 374 0 obj 2576 endobj 387 0 obj <> stream xXmoSPDi#b5C<+I}s/]*'~}ccǘ`vL5*$Q1u> -xX%eCRG87GTz?L5vG#]^6]grQ5je8Pj6RPSj6sfNñ!ͅ'i$e {ǸUK:Gpb^u5 K\IG阖^0W긡`kԬMi}|spz*vK5FU&KFo] +5R0C0.Nd?`_mT< |TC<|!5W,sy8S<Kw#'Oզ&nN'p˔ܻ OWfV\plu1SA˙mێ*mm\Q,s<"w ' xxկP*l0THZ;j\ߟf^H܈Dt "7F0l $/єq5%H]u4m{#CYI^&USqcлsۿ'  }b!iiJ4N!95WEqӎ` sds2#f[<[ADN8$ x Rc0>|jmp:O!j9T #q 𦊋ܭZM5Hh,~;2x!k"шp,h%)R"8 `w2IGQ?yCNdNؔ§pǗɒpɎxSkCQHCJvmFc`%db+=@zinr-/h,XYij1%Ѻw<}*KqEBeCM;Bq8ǯ\wpݬ̀O]? mxtӂNMnۆܡ#}y3ߖvrM/^=0&6nx~+IQCnw>8h]ސ:3Vxismr0DE$Z 1`(Lط{ 1sH>Fxµ2g}QufȠH&u& AbMWCc0Gaau*Ԡ 7ֲP} ;h|;BDp yG"ye'MxKAK om~6j&_<ŻREqO{U CBo-D0W5DћO`G,^gn]?ʙyQd9vg['C-,pm'knbErLe~-kN3b.5  sv&ueDFzC[=ORtv4c@=G{ Aiz-RXfpc-Ϙ6ȉ}sWqMA3Rd4d͜I^weBd*!iH|xg1b#.=f(A-2fOT NZX.53,AS]Zԓ3!ϩZ$8*dBj )J&ן[a ڇsۯ{P0gzz]"d~LDfi#(q+|ye-bQsXuuqv`+A%RCTr}b17Qbu`чdh7<o;lí6DL} =پɲR+rM[cb5c,ܮ!*iβC f!#Sн[M5(@͋=YS-<9; 갍aqi*2@ꁓCcVx1ºݏdcy{PXpLړƿQ|bVC#s-`>A ~1kP}4{4OgLrFxmLR{0̢11:1|k E55ƚHR 5Nˀ36R-׹8xeUcԸxz^30$  (5T.V3; p蔳|h]_"٦.|iG7).Y>@Jh~?05?]:ӂڃ˭%0Cl+8o.[}f$*\D0I"d*m^sMo>ٍԿX-UOcSҀ栉V4wx]0#I[;A>="Pￏ{(*endstream endobj 388 0 obj 2609 endobj 402 0 obj <> stream xX]OV#DA)-mYƯ?JB k`g:vcԄ]$vY@8˶Ш"t7K(UfrѮwcOUHgޏ>9y^/FKKK6?kQ/ދtME:C W`9,γ_D˜9Dbwzd+W;sWܾ4+fZ.bP2P෬tTROy5y^-@.Y^8_G_Q$KYA)  ۓJ5#z}).&<\L+wUD;Hr1D%׃,,O*aE&> ُi76.P0Kʩ%B.3w˧j%]aZ(jI`/۱6O(G6>jm)_ 3 uӃbz` KIDKR"d 3`J~hj|3gHob8Ms2@ ;Ѽq>$f"G|q, FƻlHFAE=YW-CQ$[wWT >w#}CO?א%եj7֎c(fc;?*r2|5D}(' G]ƶf@A; ژwt osX{E-Iﳎ|ccGcY/,wGgZfv2v t| Tбw~j9?+ O|p{4t$A8vwO#i_i&z[&2%JVBxWSsAVAS4%lᅌ:z+F[-m^YsL[rpVMT4GN<ȁs` v jVc<4G=\;I$ݛ3b146mbR=U(PJ_hr@,V%^auHhG HOC(lTkP;_D'(RةL8=f-Iu>M"VdiԖ4ԕg?fƗ!U W׸ߡ2jA,A}dc yMϒcGsI!H%cbiXb:A4V>WP؁,f(џ"D-}#`- =w0Pn ľZԃF"1PÏh4pSs>}˧Kvb >%Wj]F Sa2?p 8oZ6W`D@g2~xLBOBzʝ0 Bx!4L]je6-͜ eTx[Hڈ$h}. sC"nq fZE!̨s.!aqRV/}SĨj9_/H7FMeMí [t`)V?jb}iz΋ vjAϛ T{p8#l]XtnRyC.1e6>^ v7zzzPp=%BƤ)΂,aɕ Dh 01U#a-lqu  g9٦LGP7Wswws1!= $`d#D64+-dQlت==p ϮA:%9Q-BXEfNUɡ&̄T.gD}tO: a3#BbǼ Pc" `v*`jԯ`]GH&"NN9fPLiif*t,z[M{ykDD4."r/V@er(kd2R:&f05Fx#BEq1H(!yȁۺgMTڵivN7;75S@\j8bLb&`+Dw O]I.W]X=&TAl+6]dq[V>VRfXp*5v r"AŒSNZ yAS1^roDe{7LQzBv9)/ߴ\*2ASTo \I?l?endstream endobj 403 0 obj 2765 endobj 411 0 obj <> stream xXodž yhg$*Ц6p$%Q_ו<0!*m@Kd. /] 5A=Rx aKw>w9&:2Q}ZgXgCN0,Fe?r<>3T9])Q\L?l*WӖS=" sZc:ي.%:VŐz,WS KP՜V_ e,rq>!yCEkw D1I?DM/"c 5Лl[N鳕Lv6 5eyjT iG rJdQ5ᦧ$)=S:>'|f^UB%vs7&m8514C̃qS&>ѧ܈ ݃H{z۴u[GhwjN&~FQsbIm ۦdc_ >]MV!HLʡ n*u!lO o6w]Gs*"ldbV(D.nSw I05 4XX3f)Plt$Ѯ K>䒿~ލw釒y: Ap0WuCpx],]$uÁڙA,c҃.bBbB!HIYeED 99<ۭO.f ʆk $ 6* 0 (EH [\M`PF^ 5l({Y,-)@oC:'/sk$\ !vިCGVnM˰wnm;mĈu RU\i}wt+Բ0q<81nMoG޹jlCߤs be2#jo3t(`c OԎ]mZy0}8I,% ]Յ%˴Y^sq7~_%<ߔ~O;QDw{{ow}xuDƱ~8-oG+*':mÙ}󪚇jXt@<_",&K^7#HBL}6tjӁfW%yI<>*L%F۰ru5Ip Ѵ- sˤlx?X_zzP8{נ/ZйX'?:Dw<' HB[ IWq2O0<6hVitxZ'C{d&!?L5˸5@qO7X`cSx9m(оI&0۫G}`@PR$<#?Fs0~uckTMeyve" ^q;lDrP7^5 Z@UQGb)$qI~ tp/i0bQlfkyvajTDiyw[Q``vO1%Sۓ%I oj Z+g7$8+M3|endstream endobj 412 0 obj 2052 endobj 426 0 obj <> stream xeSOP .$!ĒL2Fۻ0"ƌveewkŦ ,F|!`5H|`|@b?bsιy>jrq4,K䄜щqu!%Giz($+87N4d2d4ȈƕRQDb1rR! Jsc_. BGtхduFdlQC֜O5} e[Rt=dph$²|18mY E"+ gzR،5hMlj]j|C kf[PַTI(5д=;wegwTUY]&Q'tu5ChDLxf@ ֶ.eumH0o?QHz߹ȸDϸ\)4Kv\$5Ԏd=W_CJ;nYqQeK-3I'J%?JF-͢>=cQ8P \ c-JZƫ9~:TڜN3VMi=ݦ-}Τ/)6j 6_lmR?{P4ۚHDhLjބ-;^iendstream endobj 427 0 obj 779 endobj 431 0 obj <> stream xX}le,, Җ޽wm?$#@JicM FL (eDKL4C4QQ[DDaK1{}y~]#r~oaw/W]r{&*RJeڥTXQlI,Q-m%+)Olj xLe)jI ٩ ԮJTKChbs3,/[!%՞:E Vg"UI1Uٱ*QoX.Kh\'۸r0:#G *vlZ-:%I.KsP,O  #%r@+׆D2S:a =%PԊN:~ KErĝ;Kh`$a*; ;vR78G$DˎL5ɴS_G 6)Bn"f@VFˌ) (jZJ֔(gJuuq_8 15Fu?lAl{=0.*x4A=\@X $*8eX4 (xB@z e;Ңͮ5ΔMYtԄfq3ĭg.ƭEu]<:}#x^l\]2K*h-Pg'q/" qfKybND{K?i`ub7G 1jb=NVj:SYh}u<{YYIw숽p ] پjyd5"ug CPBwPա~d-$/"/^?~,9ܟ@&s.YҗqH&Z $i@wu^P丧M{,ɍ"EtwVsA+7 (KiS?{rBG9hbBRe80wtK(GW~ӷڰ/ζta|mؗS8=o6OQdHCj*^݋t:Xgm/`miaZ0;h.y8'ށ&~*˧ ͞ٶt dEL] Xb&JpyRU"T 4=ni"Z 7+oy۸.r9lY; <]<6rZLQޭ`6.'@`h:R)ZQ'$[1^e; 5.k9cu'Mp*c 6G"DY4ml42lmҥX佃1C殰CeoëG~CN[&ND'b,I*a|ڇ8۲sk lS/굤obP6@ױY9͚㙿#a;[q{wƕMy=5xm|5W5$604n'fe8NHgqזѐWFK.w}gӴ;r_2b^Q xˤu&3Y'Vp^Ne-ʂjF*aendstream endobj 432 0 obj 1807 endobj 5 0 obj <> /Contents 6 0 R >> endobj 244 0 obj <> /Contents 245 0 R >> endobj 286 0 obj <> /Contents 287 0 R >> endobj 307 0 obj <> /Contents 308 0 R >> endobj 346 0 obj <> /Contents 347 0 R >> endobj 372 0 obj <> /Contents 373 0 R >> endobj 386 0 obj <> /Contents 387 0 R >> endobj 401 0 obj <> /Contents 402 0 R >> endobj 410 0 obj <> /Contents 411 0 R >> endobj 425 0 obj <> /Contents 426 0 R >> endobj 430 0 obj <> /Contents 431 0 R >> endobj 3 0 obj << /Type /Pages /Kids [ 5 0 R 244 0 R 286 0 R 307 0 R 346 0 R 372 0 R 386 0 R 401 0 R 410 0 R 425 0 R 430 0 R ] /Count 11 >> endobj 1 0 obj <> endobj 4 0 obj <> endobj 10 0 obj <>stream 0 0 0 0 126 141 d1 126 0 0 141 0 0 cm BI /IM true /W 126 /H 141 /BPC 1 /D[1 0] /F/CCF /DP<> ID ;@) e&IpT~ooῇ߇/_ //K_ ^ /^,)B kuvS EI endstream endobj 11 0 obj <>stream 0 0 0 49 83 143 d1 83 0 0 94 0 49 cm BI /IM true /W 83 /H 94 /BPC 1 /D[1 0] /F/CCF /DP<> ID &jW0' @|> oX}> a7O-z 0_xaw@0]  0\ =  EI endstream endobj 12 0 obj <> stream 140 0 0 0 0 0 d1 endstream endobj 13 0 obj <>stream 0 0 0 50 96 141 d1 96 0 0 91 0 50 cm BI /IM true /W 96 /H 91 /BPC 1 /D[1 0] /F/CCF /DP<> ID %@9N8{5a?/p\z0ivxXfW ,!_ EI endstream endobj 14 0 obj <> stream 94 0 0 0 0 0 d1 endstream endobj 15 0 obj <>stream 0 0 0 -3 21 55 d1 21 0 0 58 0 -3 cm BI /IM true /W 21 /H 58 /BPC 1 /D[1 0] /F/CCF /DP<> ID &>?~]C|a~ @ EI endstream endobj 16 0 obj <> stream 118 0 0 0 0 0 d1 endstream endobj 17 0 obj <>stream 0 0 0 14 63 143 d1 63 0 0 129 0 14 cm BI /IM true /W 63 /H 129 /BPC 1 /D[1 0] /F/CCF /DP<> ID &H |P=c __%MK ?  EI endstream endobj 18 0 obj <> stream 36 0 0 0 0 0 d1 endstream endobj 19 0 obj <>stream 0 0 0 0 101 141 d1 101 0 0 141 0 0 cm BI /IM true /W 101 /H 141 /BPC 1 /D[1 0] /F/CCF /DP<> ID ;5 K6ÐU?kВR@ EI endstream endobj 20 0 obj <> stream 145 0 0 0 0 0 d1 endstream endobj 21 0 obj <> stream 115 0 0 0 0 0 d1 endstream endobj 22 0 obj <> stream 100 0 0 0 0 0 d1 endstream endobj 23 0 obj <>stream 0 0 0 50 94 182 d1 94 0 0 132 0 50 cm BI /IM true /W 94 /H 132 /BPC 1 /D[1 0] /F/CCF /DP<> ID %@o9N!OA@h@?X&?o >o~__\: ΋ KaK Qh  EI endstream endobj 24 0 obj <>stream 0 0 0 124 19 182 d1 19 0 0 58 0 124 cm BI /IM true /W 19 /H 58 /BPC 1 /D[1 0] /F/CCF /DP<> ID &O{pCM,( EI endstream endobj 25 0 obj <>stream 0 0 0 0 50 141 d1 50 0 0 141 0 0 cm BI /IM true /W 50 /H 141 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A`~@ EI endstream endobj 26 0 obj <> stream 105 0 0 0 0 0 d1 endstream endobj 27 0 obj <> stream 60 0 0 0 0 0 d1 endstream endobj 28 0 obj <>stream 0 0 0 49 73 143 d1 73 0 0 94 0 49 cm BI /IM true /W 73 /H 94 /BPC 1 /D[1 0] /F/CCF /DP<> ID &u!!pD |0}&A(~A+z_Zk+-,6] kAsN Aaf(V EI endstream endobj 29 0 obj <> stream 78 0 0 0 0 0 d1 endstream endobj 30 0 obj <>stream 0 0 0 50 65 141 d1 65 0 0 91 0 50 cm BI /IM true /W 65 /H 91 /BPC 1 /D[1 0] /F/CCF /DP<> ID &0?// a~ ~R0S  EI endstream endobj 31 0 obj <> stream 83 0 0 0 0 0 d1 endstream endobj 32 0 obj <>stream 0 0 0 49 86 143 d1 86 0 0 94 0 49 cm BI /IM true /W 86 /H 94 /BPC 1 /D[1 0] /F/CCF /DP<> ID &]@ x h4: Daz}AO_h5o0 y. ojdȓ@? Q׆ ް. w.t X0`!@ EI endstream endobj 33 0 obj <> stream 77 0 0 0 0 0 d1 endstream endobj 34 0 obj <> stream 88 0 0 0 0 0 d1 endstream endobj 35 0 obj <>stream 0 0 0 0 57 101 d1 57 0 0 101 0 0 cm BI /IM true /W 57 /H 101 /BPC 1 /D[1 0] /F/CCF /DP<> ID & 3d8>L=oA Ax5𿧐`@ EI endstream endobj 36 0 obj <>stream 0 0 0 33 61 100 d1 61 0 0 67 0 33 cm BI /IM true /W 61 /H 67 /BPC 1 /D[1 0] /F/CCF /DP<> ID &`C8L=8$<-IX w__ 4 ,6 w\/Y|@ EI endstream endobj 37 0 obj <> stream 69 0 0 0 0 0 d1 endstream endobj 38 0 obj <>stream 0 0 0 35 68 98 d1 68 0 0 63 0 35 cm BI /IM true /W 68 /H 63 /BPC 1 /D[1 0] /F/CCF /DP<> ID #Cɨ0.tAk k0K $ EI endstream endobj 39 0 obj <> stream 70 0 0 0 0 0 d1 endstream endobj 40 0 obj <>stream 0 0 0 33 63 100 d1 63 0 0 67 0 33 cm BI /IM true /W 63 /H 67 /BPC 1 /D[1 0] /F/CCF /DP<> ID & 3 <Ou>h@ >Z7X0?j/Ai6"g_W8 @b !O EI endstream endobj 41 0 obj <> stream 79 0 0 0 0 0 d1 endstream endobj 42 0 obj <>stream 0 0 0 10 44 100 d1 44 0 0 90 0 10 cm BI /IM true /W 44 /H 90 /BPC 1 /D[1 0] /F/CCF /DP<> ID &`_xD ?p(b3l EI endstream endobj 43 0 obj <> stream 68 0 0 0 0 0 d1 endstream endobj 44 0 obj <>stream 0 0 0 -1 68 98 d1 68 0 0 99 0 -1 cm BI /IM true /W 68 /H 99 /BPC 1 /D[1 0] /F/CCF /DP<> ID #Cɨ0.tAk/ 5 |~/H,j EI endstream endobj 45 0 obj <> stream 56 0 0 0 0 0 d1 endstream endobj 46 0 obj <>stream 0 0 0 -4 96 98 d1 96 0 0 102 0 -4 cm BI /IM true /W 96 /H 102 /BPC 1 /D[1 0] /F/CCF /DP<> ID &&Saa__ p__4ᰂ]awpa> stream 124 0 0 0 0 0 d1 endstream endobj 48 0 obj <>stream 0 0 0 35 109 98 d1 109 0 0 63 0 35 cm BI /IM true /W 109 /H 63 /BPC 1 /D[1 0] /F/CCF /DP<> ID #Bɨ0!Q OM58w(Y=~OXP  5]<,00a.8 PA  EI endstream endobj 49 0 obj <>stream 0 0 0 33 45 100 d1 45 0 0 67 0 33 cm BI /IM true /W 45 /H 67 /BPC 1 /D[1 0] /F/CCF /DP<> ID 6C {"@h8b}xO_~ P3 ?p, L/uC2>_&/ .^P| EI endstream endobj 50 0 obj <> stream 53 0 0 0 0 0 d1 endstream endobj 51 0 obj <>stream 0 0 0 33 53 100 d1 53 0 0 67 0 33 cm BI /IM true /W 53 /H 67 /BPC 1 /D[1 0] /F/CCF /DP<> ID &| =cHx[>a}+X}| o&ax]\<-`< A`@ EI endstream endobj 52 0 obj <> stream 57 0 0 0 0 0 d1 endstream endobj 53 0 obj <>stream 0 0 0 35 47 98 d1 47 0 0 63 0 35 cm BI /IM true /W 47 /H 63 /BPC 1 /D[1 0] /F/CCF /DP<> ID "`Qh a[{ 0Ԛ  EI endstream endobj 54 0 obj <> stream 62 0 0 0 0 0 d1 endstream endobj 55 0 obj <>stream 0 0 0 -1 68 100 d1 68 0 0 101 0 -1 cm BI /IM true /W 68 /H 101 /BPC 1 /D[1 0] /F/CCF /DP<> ID &`'H> P g7!zbO ?_v850dI~ 0Gr?  EI endstream endobj 56 0 obj <> stream 54 0 0 0 0 0 d1 endstream endobj 57 0 obj <>stream 0 0 0 0 113 98 d1 113 0 0 98 0 0 cm BI /IM true /W 113 /H 98 /BPC 1 /D[1 0] /F/CCF /DP<> ID Al&SfI O= A$ $?A,?A A!LA)A@ EI endstream endobj 58 0 obj <> stream 126 0 0 0 0 0 d1 endstream endobj 59 0 obj <>stream 0 0 0 33 53 100 d1 53 0 0 67 0 33 cm BI /IM true /W 53 /H 67 /BPC 1 /D[1 0] /F/CCF /DP<> ID & px'@ | aoɯ @>?eg . K"#Y|@ EI endstream endobj 60 0 obj <> stream 55 0 0 0 0 0 d1 endstream endobj 61 0 obj <> stream 58 0 0 0 0 0 d1 endstream endobj 62 0 obj <>stream 0 0 0 3 59 101 d1 59 0 0 98 0 3 cm BI /IM true /W 59 /H 98 /BPC 1 /D[1 0] /F/CCF /DP<> ID & $:G@7 h }q _Y !U8<>0"}~s4P ,A EI endstream endobj 63 0 obj <>stream 0 0 0 3 47 98 d1 47 0 0 95 0 3 cm BI /IM true /W 47 /H 95 /BPC 1 /D[1 0] /F/CCF /DP<> ID & <>MC O EI endstream endobj 64 0 obj <>stream 0 0 0 83 17 126 d1 17 0 0 43 0 83 cm BI /IM true /W 17 /H 43 /BPC 1 /D[1 0] /F/CCF /DP<> ID &a߇>? _ EI endstream endobj 65 0 obj <>stream 0 0 0 3 55 98 d1 55 0 0 95 0 3 cm BI /IM true /W 55 /H 95 /BPC 1 /D[1 0] /F/CCF /DP<> ID *k3Ç߶a0~Ã{|77 ~ >~5:ɮa ׯaK f  4i EI endstream endobj 66 0 obj <> stream 81 0 0 0 0 0 d1 endstream endobj 67 0 obj <>stream 0 0 0 3 59 101 d1 59 0 0 98 0 3 cm BI /IM true /W 59 /H 98 /BPC 1 /D[1 0] /F/CCF /DP<> ID &\ $38 `Ox[?O?oO-/a K 4 ްb Ȁ EI endstream endobj 68 0 obj <> stream 71 0 0 0 0 0 d1 endstream endobj 69 0 obj <>stream 0 0 0 3 59 101 d1 59 0 0 98 0 3 cm BI /IM true /W 59 /H 98 /BPC 1 /D[1 0] /F/CCF /DP<> ID &\ > | z____~ ׿%5x-0A|~ $}?3'0 aXd C EI endstream endobj 70 0 obj <>stream 0 0 0 0 67 112 d1 67 0 0 112 0 0 cm BI /IM true /W 67 /H 112 /BPC 1 /D[1 0] /F/CCF /DP<> ID P0K)M@ 4U?5i@ EI endstream endobj 71 0 obj <>stream 0 0 0 -6 61 112 d1 61 0 0 118 0 -6 cm BI /IM true /W 61 /H 118 /BPC 1 /D[1 0] /F/CCF /DP<> ID PB%a@ EI endstream endobj 72 0 obj <>stream 0 0 0 34 96 112 d1 96 0 0 78 0 34 cm BI /IM true /W 96 /H 78 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A:a/ ? aC /!Ԇ@ EI endstream endobj 73 0 obj <> stream 74 0 0 0 0 0 d1 endstream endobj 74 0 obj <>stream 0 0 0 3 61 114 d1 61 0 0 111 0 3 cm BI /IM true /W 61 /H 111 /BPC 1 /D[1 0] /F/CCF /DP<> ID &k x C,ĖMG ? EI endstream endobj 75 0 obj <> stream 98 0 0 0 0 0 d1 endstream endobj 76 0 obj <>stream 0 0 0 34 68 112 d1 68 0 0 78 0 34 cm BI /IM true /W 68 /H 78 /BPC 1 /D[1 0] /F/CCF /DP<> ID !A"SCgO:0\}~ ,0MAx2@ EI endstream endobj 77 0 obj <>stream 0 0 0 32 85 114 d1 85 0 0 82 0 32 cm BI /IM true /W 85 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &F_e d6AO.jO[A5x\0 a2 xz dH2Ag@ EI endstream endobj 78 0 obj <> stream 80 0 0 0 0 0 d1 endstream endobj 79 0 obj <>stream 0 0 0 -7 95 114 d1 95 0 0 121 0 -7 cm BI /IM true /W 95 /H 121 /BPC 1 /D[1 0] /F/CCF /DP<> ID &j @ HoEArK:,y00A? ׆ !> stream 103 0 0 0 0 0 d1 endstream endobj 81 0 obj <>stream 0 0 0 34 96 114 d1 96 0 0 80 0 34 cm BI /IM true /W 96 /H 80 /BPC 1 /D[1 0] /F/CCF /DP<> ID &D A o ?)G|s /CD6 _@ EI endstream endobj 82 0 obj <> stream 107 0 0 0 0 0 d1 endstream endobj 83 0 obj <>stream 0 0 0 32 74 114 d1 74 0 0 82 0 32 cm BI /IM true /W 74 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &F07x,>zaa\38IaIR5 /4kaC%džA_2Ŀ _ EI endstream endobj 84 0 obj <> stream 84 0 0 0 0 0 d1 endstream endobj 85 0 obj <>stream 0 0 0 -9 43 112 d1 43 0 0 121 0 -9 cm BI /IM true /W 43 /H 121 /BPC 1 /D[1 0] /F/CCF /DP<> ID & ? >OA/_ @ EI endstream endobj 86 0 obj <>stream 0 0 0 0 80 85 d1 80 0 0 85 0 0 cm BI /IM true /W 80 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID *+&u CP%[PU\=kK^_l2]z5u޿k i_P EI endstream endobj 87 0 obj <>stream 0 0 0 2 57 87 d1 57 0 0 85 0 2 cm BI /IM true /W 57 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &N>D?h0A7a}?_v&/a dᣏQ0 EI endstream endobj 88 0 obj <> stream 87 0 0 0 0 0 d1 endstream endobj 89 0 obj <>stream 0 0 0 31 51 87 d1 51 0 0 56 0 31 cm BI /IM true /W 51 /H 56 /BPC 1 /D[1 0] /F/CCF /DP<> ID &4|0<-oM ްo[[;__kio_ a- !ax EI endstream endobj 90 0 obj <>stream 0 0 0 33 56 87 d1 56 0 0 54 0 33 cm BI /IM true /W 56 /H 54 /BPC 1 /D[1 0] /F/CCF /DP<> ID &`2|~7?VWO׭_ޘA09@ EI endstream endobj 91 0 obj <>stream 0 0 0 31 44 87 d1 44 0 0 56 0 31 cm BI /IM true /W 44 /H 56 /BPC 1 /D[1 0] /F/CCF /DP<> ID & "A &ޗZ_&kXa m\ @ EI endstream endobj 92 0 obj <> stream 59 0 0 0 0 0 d1 endstream endobj 93 0 obj <>stream 0 0 0 31 53 87 d1 53 0 0 56 0 31 cm BI /IM true /W 53 /H 56 /BPC 1 /D[1 0] /F/CCF /DP<> ID &DxDa l#KQM?O=߆3S!&@y[AxU\a\^,( EI endstream endobj 94 0 obj <> stream 97 0 0 0 0 0 d1 endstream endobj 95 0 obj <>stream 0 0 0 2 26 85 d1 26 0 0 83 0 2 cm BI /IM true /W 26 /H 83 /BPC 1 /D[1 0] /F/CCF /DP<> ID j)@_5 EI endstream endobj 96 0 obj <> stream 33 0 0 0 0 0 d1 endstream endobj 97 0 obj <>stream 0 0 0 12 37 87 d1 37 0 0 75 0 12 cm BI /IM true /W 37 /H 75 /BPC 1 /D[1 0] /F/CCF /DP<> ID &O?t?jd0" EI endstream endobj 98 0 obj <>stream 0 0 0 2 57 85 d1 57 0 0 83 0 2 cm BI /IM true /W 57 /H 83 /BPC 1 /D[1 0] /F/CCF /DP<> ID $&k.6 ^8g~?L@ EI endstream endobj 99 0 obj <> stream 47 0 0 0 0 0 d1 endstream endobj 100 0 obj <> stream 64 0 0 0 0 0 d1 endstream endobj 101 0 obj <>stream 0 0 0 33 79 87 d1 79 0 0 54 0 33 cm BI /IM true /W 79 /H 54 /BPC 1 /D[1 0] /F/CCF /DP<> ID &6 ?k k׵i~z__Oo_ >Am}.c>_> stream 95 0 0 0 0 0 d1 endstream endobj 103 0 obj <> stream 82 0 0 0 0 0 d1 endstream endobj 104 0 obj <>stream 0 0 0 32 57 85 d1 57 0 0 53 0 32 cm BI /IM true /W 57 /H 53 /BPC 1 /D[1 0] /F/CCF /DP<> ID $&k.6p &C'  EI endstream endobj 105 0 obj <>stream 0 0 0 2 57 87 d1 57 0 0 85 0 2 cm BI /IM true /W 57 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &!1T3 |@&trւb}//55ap6ix0day ] _) EI endstream endobj 106 0 obj <> stream 65 0 0 0 0 0 d1 endstream endobj 107 0 obj <>stream 0 0 0 32 39 85 d1 39 0 0 53 0 32 cm BI /IM true /W 39 /H 53 /BPC 1 /D[1 0] /F/CCF /DP<> ID A?&=~C?Ѣa=5BN  EI endstream endobj 108 0 obj <> stream 52 0 0 0 0 0 d1 endstream endobj 109 0 obj <>stream 0 0 0 31 38 87 d1 38 0 0 56 0 31 cm BI /IM true /W 38 /H 56 /BPC 1 /D[1 0] /F/CCF /DP<> ID 0$< zÈ ap_uAY py  @ ^j P_d5ȁx20O EI endstream endobj 110 0 obj <> stream 46 0 0 0 0 0 d1 endstream endobj 111 0 obj <> stream 90 0 0 0 0 0 d1 endstream endobj 112 0 obj <>stream 0 0 0 1 40 85 d1 40 0 0 84 0 1 cm BI /IM true /W 40 /H 84 /BPC 1 /D[1 0] /F/CCF /DP<> ID &\OɨC@==O 7جX0P EI endstream endobj 113 0 obj <>stream 0 0 0 3 64 85 d1 64 0 0 82 0 3 cm BI /IM true /W 64 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &?4!> cO P@ EI endstream endobj 114 0 obj <>stream 0 0 0 4 26 85 d1 26 0 0 81 0 4 cm BI /IM true /W 26 /H 81 /BPC 1 /D[1 0] /F/CCF /DP<> ID j)@_5L/ EI endstream endobj 115 0 obj <> stream 72 0 0 0 0 0 d1 endstream endobj 116 0 obj <> stream 34 0 0 0 0 0 d1 endstream endobj 117 0 obj <>stream 0 0 0 32 57 108 d1 57 0 0 76 0 32 cm BI /IM true /W 57 /H 76 /BPC 1 /D[1 0] /F/CCF /DP<> ID $j)@kZ"&a0@ a}~}ׯ]kX@"hRj$8h EI endstream endobj 118 0 obj <>stream 0 0 0 2 14 37 d1 14 0 0 35 0 2 cm BI /IM true /W 14 /H 35 /BPC 1 /D[1 0] /F/CCF /DP<> ID &7 ߿^1& @ EI endstream endobj 119 0 obj <> stream 27 0 0 0 0 0 d1 endstream endobj 120 0 obj <> stream 89 0 0 0 0 0 d1 endstream endobj 121 0 obj <> stream 66 0 0 0 0 0 d1 endstream endobj 122 0 obj <> stream 51 0 0 0 0 0 d1 endstream endobj 123 0 obj <> stream 109 0 0 0 0 0 d1 endstream endobj 124 0 obj <> stream 45 0 0 0 0 0 d1 endstream endobj 125 0 obj <> stream 48 0 0 0 0 0 d1 endstream endobj 126 0 obj <>stream 0 0 0 32 91 85 d1 91 0 0 53 0 32 cm BI /IM true /W 91 /H 53 /BPC 1 /D[1 0] /F/CCF /DP<> ID $I56@4ӄOK~6LX`iqdž&AP EI endstream endobj 127 0 obj <>stream 0 0 0 31 54 111 d1 54 0 0 80 0 31 cm BI /IM true /W 54 /H 80 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A6| =>z o.Kz!\Ap B)uGL8#P(>H {7&av/^ +Ma7$ EI endstream endobj 128 0 obj <>stream 0 0 0 32 57 87 d1 57 0 0 55 0 32 cm BI /IM true /W 57 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &CAa<3 o OZ]W A5A  EI endstream endobj 129 0 obj <>stream 0 0 0 31 44 87 d1 44 0 0 56 0 31 cm BI /IM true /W 44 /H 56 /BPC 1 /D[1 0] /F/CCF /DP<> ID &h7A [W(6^K 0l<@ EI endstream endobj 130 0 obj <> stream 93 0 0 0 0 0 d1 endstream endobj 131 0 obj <>stream 0 0 0 33 13 108 d1 13 0 0 75 0 33 cm BI /IM true /W 13 /H 75 /BPC 1 /D[1 0] /F/CCF /DP<> ID &w߿y| ,/05( EI endstream endobj 132 0 obj <>stream 0 0 0 33 56 109 d1 56 0 0 76 0 33 cm BI /IM true /W 56 /H 76 /BPC 1 /D[1 0] /F/CCF /DP<> ID &3@~ ŷo ? |'[}a-}o[oL   EI endstream endobj 133 0 obj <> stream 61 0 0 0 0 0 d1 endstream endobj 134 0 obj <> stream 92 0 0 0 0 0 d1 endstream endobj 135 0 obj <> stream 99 0 0 0 0 0 d1 endstream endobj 136 0 obj <> stream 113 0 0 0 0 0 d1 endstream endobj 137 0 obj <> stream 37 0 0 0 0 0 d1 endstream endobj 138 0 obj <> stream 142 0 0 0 0 0 d1 endstream endobj 139 0 obj <> stream 110 0 0 0 0 0 d1 endstream endobj 140 0 obj <> stream 144 0 0 0 0 0 d1 endstream endobj 141 0 obj <> stream 38 0 0 0 0 0 d1 endstream endobj 142 0 obj <>stream 0 0 0 73 13 85 d1 13 0 0 12 0 73 cm BI /IM true /W 13 /H 12 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Mu` EI endstream endobj 143 0 obj <>stream 0 0 0 3 77 85 d1 77 0 0 82 0 3 cm BI /IM true /W 77 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A+?A>  x {`KL  EI endstream endobj 144 0 obj <> stream 108 0 0 0 0 0 d1 endstream endobj 145 0 obj <>stream 0 0 0 2 55 85 d1 55 0 0 83 0 2 cm BI /IM true /W 55 /H 83 /BPC 1 /D[1 0] /F/CCF /DP<> ID $QJskz_z^Kzz]]^.ik_oo?_Dpj&  EI endstream endobj 146 0 obj <> stream 96 0 0 0 0 0 d1 endstream endobj 147 0 obj <>stream 0 0 0 3 95 85 d1 95 0 0 82 0 3 cm BI /IM true /W 95 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID & |`0[A? F[I- ?ooH0o[ I,OA@ EI endstream endobj 148 0 obj <>stream 0 0 0 73 14 108 d1 14 0 0 35 0 73 cm BI /IM true /W 14 /H 35 /BPC 1 /D[1 0] /F/CCF /DP<> ID &7{ cM~( EI endstream endobj 149 0 obj <>stream 0 0 0 4 30 109 d1 30 0 0 105 0 4 cm BI /IM true /W 30 /H 105 /BPC 1 /D[1 0] /F/CCF /DP<> ID &~wɪMk:4O~_ EI endstream endobj 150 0 obj <> stream 35 0 0 0 0 0 d1 endstream endobj 151 0 obj <> stream 73 0 0 0 0 0 d1 endstream endobj 152 0 obj <> stream 111 0 0 0 0 0 d1 endstream endobj 153 0 obj <>stream 0 0 0 33 43 85 d1 43 0 0 52 0 33 cm BI /IM true /W 43 /H 52 /BPC 1 /D[1 0] /F/CCF /DP<> ID c&!{o ww}>xaow EI endstream endobj 154 0 obj <> stream 102 0 0 0 0 0 d1 endstream endobj 155 0 obj <> stream 112 0 0 0 0 0 d1 endstream endobj 156 0 obj <> stream 50 0 0 0 0 0 d1 endstream endobj 157 0 obj <> stream 91 0 0 0 0 0 d1 endstream endobj 158 0 obj <> stream 104 0 0 0 0 0 d1 endstream endobj 159 0 obj <>stream 0 0 0 1 58 85 d1 58 0 0 84 0 1 cm BI /IM true /W 58 /H 84 /BPC 1 /D[1 0] /F/CCF /DP<> ID &/4#iP~~C KC3A EI endstream endobj 160 0 obj <>stream 0 0 0 33 58 85 d1 58 0 0 52 0 33 cm BI /IM true /W 58 /H 52 /BPC 1 /D[1 0] /F/CCF /DP<> ID %?jauM`/[ o޸iaۭoֺZxF[ՇWo ^a}C4/ EI endstream endobj 161 0 obj <> stream 63 0 0 0 0 0 d1 endstream endobj 162 0 obj <> stream 86 0 0 0 0 0 d1 endstream endobj 163 0 obj <>stream 0 0 0 3 35 85 d1 35 0 0 82 0 3 cm BI /IM true /W 35 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID jī  EI endstream endobj 164 0 obj <> stream 41 0 0 0 0 0 d1 endstream endobj 165 0 obj <> stream 26 0 0 0 0 0 d1 endstream endobj 166 0 obj <>stream 0 0 0 0 72 82 d1 72 0 0 82 0 0 cm BI /IM true /W 72 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &>DЂ <0~߃~%^ %q\.P`p~߆K z XLX࿐P  EI endstream endobj 167 0 obj <> stream 40 0 0 0 0 0 d1 endstream endobj 168 0 obj <> stream 76 0 0 0 0 0 d1 endstream endobj 169 0 obj <> stream 101 0 0 0 0 0 d1 endstream endobj 170 0 obj <>stream 0 0 0 1 72 88 d1 72 0 0 87 0 1 cm BI /IM true /W 72 /H 87 /BPC 1 /D[1 0] /F/CCF /DP<> ID &t  8< 3 @&o_I&|$ ސ}~I ?_kao[\50 W 4p EI endstream endobj 171 0 obj <>stream 0 0 0 3 67 85 d1 67 0 0 82 0 3 cm BI /IM true /W 67 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &OȚᮿx^?_ׅp/Q@ EI endstream endobj 172 0 obj <>stream 0 0 0 51 117 54 d1 117 0 0 3 0 51 cm BI /IM true /W 117 /H 3 /BPC 1 /D[1 0] /F/CCF /DP<> ID  EI endstream endobj 173 0 obj <> stream 43 0 0 0 0 0 d1 endstream endobj 174 0 obj <> stream 120 0 0 0 0 0 d1 endstream endobj 175 0 obj <> stream 32 0 0 0 0 0 d1 endstream endobj 176 0 obj <>stream 0 0 0 6 29 87 d1 29 0 0 81 0 6 cm BI /IM true /W 29 /H 81 /BPC 1 /D[1 0] /F/CCF /DP<> ID &AzO~ks_aXa@ EI endstream endobj 177 0 obj <>stream 0 0 0 10 33 87 d1 33 0 0 77 0 10 cm BI /IM true /W 33 /H 77 /BPC 1 /D[1 0] /F/CCF /DP<> ID &~߇a=$Brk |@ EI endstream endobj 178 0 obj <>stream 0 0 0 32 41 87 d1 41 0 0 55 0 32 cm BI /IM true /W 41 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &?ȩxa%4~? ~_& H 81.A~@pxww߶߆uia/H EI endstream endobj 179 0 obj <> stream 42 0 0 0 0 0 d1 endstream endobj 180 0 obj <>stream 0 0 0 32 47 87 d1 47 0 0 55 0 32 cm BI /IM true /W 47 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &p5><d1O6Hh.8[A@@ EI endstream endobj 181 0 obj <>stream 0 0 0 32 51 87 d1 51 0 0 55 0 32 cm BI /IM true /W 51 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &σ xG0A} K7>L~~C{o߼?߼H5 EI endstream endobj 182 0 obj <>stream 0 0 0 3 78 85 d1 78 0 0 82 0 3 cm BI /IM true /W 78 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID & szr$/_|/(_K_/_/A_Kh=" z!_ EI endstream endobj 183 0 obj <> stream 85 0 0 0 0 0 d1 endstream endobj 184 0 obj <>stream 0 0 0 32 60 85 d1 60 0 0 53 0 32 cm BI /IM true /W 60 /H 53 /BPC 1 /D[1 0] /F/CCF /DP<> ID &GSQ 4k%0a{Gԍ ɪ(40 EI endstream endobj 185 0 obj <>stream 0 0 0 31 55 87 d1 55 0 0 56 0 31 cm BI /IM true /W 55 /H 56 /BPC 1 /D[1 0] /F/CCF /DP<> ID &AF2ukCtpc]~ k x|Σ a?4G_^ -X`@ EI endstream endobj 186 0 obj <>stream 0 0 0 32 56 112 d1 56 0 0 80 0 32 cm BI /IM true /W 56 /H 80 /BPC 1 /D[1 0] /F/CCF /DP<> ID &P /-N0Aa/^^0r`)UL$) EI endstream endobj 187 0 obj <>stream 0 0 0 31 45 87 d1 45 0 0 56 0 31 cm BI /IM true /W 45 /H 56 /BPC 1 /D[1 0] /F/CCF /DP<> ID & D@OA=Fz:~&|}ɪAm{5᭯X0gP EI endstream endobj 188 0 obj <>stream 0 0 0 32 54 85 d1 54 0 0 53 0 32 cm BI /IM true /W 54 /H 53 /BPC 1 /D[1 0] /F/CCF /DP<> ID &ɮO}Nq\It8{0 EI endstream endobj 189 0 obj <>stream 0 0 0 56 32 64 d1 32 0 0 8 0 56 cm BI /IM true /W 32 /H 8 /BPC 1 /D[1 0] /F/CCF /DP<> ID  EI endstream endobj 190 0 obj <> stream 49 0 0 0 0 0 d1 endstream endobj 191 0 obj <>stream 0 0 0 0 53 87 d1 53 0 0 87 0 0 cm BI /IM true /W 53 /H 87 /BPC 1 /D[1 0] /F/CCF /DP<> ID &C6(~hߠ'7L>K륐kOfQ AkZ@/ 5\.ZD4_{.hxaO/|0t<@ EI endstream endobj 192 0 obj <>stream 0 0 0 1 58 85 d1 58 0 0 84 0 1 cm BI /IM true /W 58 /H 84 /BPC 1 /D[1 0] /F/CCF /DP<> ID &/4#i5h ?\/+C1 EI endstream endobj 193 0 obj <> stream 44 0 0 0 0 0 d1 endstream endobj 194 0 obj <>stream 0 0 0 12 56 87 d1 56 0 0 75 0 12 cm BI /IM true /W 56 /H 75 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A@ed]pAwO=r bW~II ɯ/ka fe_0^^?Aua@@ EI endstream endobj 195 0 obj <>stream 0 0 0 31 46 87 d1 46 0 0 56 0 31 cm BI /IM true /W 46 /H 56 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A8==D2z zL>AM&__ Av[a  EI endstream endobj 196 0 obj <> stream 127 0 0 0 0 0 d1 endstream endobj 197 0 obj <>stream 0 0 0 -11 28 42 d1 28 0 0 53 0 -11 cm BI /IM true /W 28 /H 53 /BPC 1 /D[1 0] /F/CCF /DP<> ID &5!{@ EI endstream endobj 198 0 obj <> stream 31 0 0 0 0 0 d1 endstream endobj 199 0 obj <>stream 0 0 0 12 47 85 d1 47 0 0 73 0 12 cm BI /IM true /W 47 /H 73 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Zqy5Kk!ɪ@@ EI endstream endobj 200 0 obj <> stream 114 0 0 0 0 0 d1 endstream endobj 201 0 obj <>stream 0 0 0 73 19 108 d1 19 0 0 35 0 73 cm BI /IM true /W 19 /H 35 /BPC 1 /D[1 0] /F/CCF /DP<> ID 0 Too>=0 EI endstream endobj 202 0 obj <> stream 67 0 0 0 0 0 d1 endstream endobj 203 0 obj <>stream 0 0 0 1 81 88 d1 81 0 0 87 0 1 cm BI /IM true /W 81 /H 87 /BPC 1 /D[1 0] /F/CCF /DP<> ID &t  85mp˄H a1>/A}A/}|koG_ aw^mwl/ v ='0 EI endstream endobj 204 0 obj <>stream 0 0 0 10 44 85 d1 44 0 0 75 0 10 cm BI /IM true /W 44 /H 75 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Qw5@Qc O@ EI endstream endobj 205 0 obj <>stream 0 0 0 19 50 87 d1 50 0 0 68 0 19 cm BI /IM true /W 50 /H 68 /BPC 1 /D[1 0] /F/CCF /DP<> ID &` zz@xD? ,)( EI endstream endobj 206 0 obj <>stream 0 0 0 31 48 87 d1 48 0 0 56 0 31 cm BI /IM true /W 48 /H 56 /BPC 1 /D[1 0] /F/CCF /DP<> ID &@@t ޾z}<%u֣*7_il/ /[_hD@ EI endstream endobj 207 0 obj <> stream 116 0 0 0 0 0 d1 endstream endobj 208 0 obj <>stream 0 0 0 1 91 85 d1 91 0 0 84 0 1 cm BI /IM true /W 91 /H 84 /BPC 1 /D[1 0] /F/CCF /DP<> ID &&Ȉ!4 #MB@oipkp4fa\& <0"|j EI endstream endobj 209 0 obj <> stream 117 0 0 0 0 0 d1 endstream endobj 210 0 obj <> stream 121 0 0 0 0 0 d1 endstream endobj 211 0 obj <> stream 75 0 0 0 0 0 d1 endstream endobj 212 0 obj <>stream 0 0 0 0 27 46 d1 27 0 0 46 0 0 cm BI /IM true /W 27 /H 46 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Mʿ|< EI endstream endobj 213 0 obj <>stream 0 0 0 13 67 82 d1 67 0 0 69 0 13 cm BI /IM true /W 67 /H 69 /BPC 1 /D[1 0] /F/CCF /DP<> ID bB@!i' h8 @ EI endstream endobj 214 0 obj <>stream 0 0 0 36 39 84 d1 39 0 0 48 0 36 cm BI /IM true /W 39 /H 48 /BPC 1 /D[1 0] /F/CCF /DP<> ID &8DFb0Iޯp%h j_ׇ_h,=a a_' EI endstream endobj 215 0 obj <>stream 0 0 0 39 48 103 d1 48 0 0 64 0 39 cm BI /IM true /W 48 /H 64 /BPC 1 /D[1 0] /F/CCF /DP<> ID &ftټ$Èwa~/0?M ߿_M%A@ EI endstream endobj 216 0 obj <>stream 0 0 0 71 13 102 d1 13 0 0 31 0 71 cm BI /IM true /W 13 /H 31 /BPC 1 /D[1 0] /F/CCF /DP<> ID &~˾c  EI endstream endobj 217 0 obj <>stream 0 0 0 12 49 84 d1 49 0 0 72 0 12 cm BI /IM true /W 49 /H 72 /BPC 1 /D[1 0] /F/CCF /DP<> ID &8c97>(|-| ZA~_ .a]x1^ _eҜ@ EI endstream endobj 218 0 obj <>stream 0 0 0 36 45 84 d1 45 0 0 48 0 36 cm BI /IM true /W 45 /H 48 /BPC 1 /D[1 0] /F/CCF /DP<> ID &@13PzMAXz Ow&_K_ m.ް !~( EI endstream endobj 219 0 obj <>stream 0 0 0 37 50 82 d1 50 0 0 45 0 37 cm BI /IM true /W 50 /H 45 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Nis4-[ BQ@ EI endstream endobj 220 0 obj <>stream 0 0 0 12 13 43 d1 13 0 0 31 0 12 cm BI /IM true /W 13 /H 31 /BPC 1 /D[1 0] /F/CCF /DP<> ID &o1ɪ a@@ EI endstream endobj 221 0 obj <>stream 0 0 0 21 32 84 d1 32 0 0 63 0 21 cm BI /IM true /W 32 /H 63 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A|fo_?$$}  EI endstream endobj 222 0 obj <>stream 0 0 0 36 46 104 d1 46 0 0 68 0 36 cm BI /IM true /W 46 /H 68 /BPC 1 /D[1 0] /F/CCF /DP<> ID &0@0|'M5L/2+Z 0z3_䏶?&  v׆a! EI endstream endobj 223 0 obj <>stream 0 0 0 37 78 82 d1 78 0 0 45 0 37 cm BI /IM true /W 78 /H 45 /BPC 1 /D[1 0] /F/CCF /DP<> ID ȃ?jDA80PV /a.fo66L4Q / EI endstream endobj 224 0 obj <>stream 0 0 0 36 47 84 d1 47 0 0 48 0 36 cm BI /IM true /W 47 /H 48 /BPC 1 /D[1 0] /F/CCF /DP<> ID &IϟFm<,zA矠c7\?~ |ʿ!?w__A K A~A EI endstream endobj 225 0 obj <>stream 0 0 0 54 99 57 d1 99 0 0 3 0 54 cm BI /IM true /W 99 /H 3 /BPC 1 /D[1 0] /F/CCF /DP<> ID  EI endstream endobj 226 0 obj <>stream 0 0 0 13 32 82 d1 32 0 0 69 0 13 cm BI /IM true /W 32 /H 69 /BPC 1 /D[1 0] /F/CCF /DP<> ID jă @ EI endstream endobj 227 0 obj <>stream 0 0 0 12 22 82 d1 22 0 0 70 0 12 cm BI /IM true /W 22 /H 70 /BPC 1 /D[1 0] /F/CCF /DP<> ID jDkɨ EI endstream endobj 228 0 obj <>stream 0 0 0 12 49 84 d1 49 0 0 72 0 12 cm BI /IM true /W 49 /H 72 /BPC 1 /D[1 0] /F/CCF /DP<> ID &+ao7//u .yi{^ɨ EI endstream endobj 229 0 obj <>stream 0 0 0 37 50 84 d1 50 0 0 47 0 37 cm BI /IM true /W 50 /H 47 /BPC 1 /D[1 0] /F/CCF /DP<> ID &8cAΡ 9A,d_Qh EI endstream endobj 230 0 obj <>stream 0 0 0 36 38 84 d1 38 0 0 48 0 36 cm BI /IM true /W 38 /H 48 /BPC 1 /D[1 0] /F/CCF /DP<> ID &8joHxA7}&_}u!ɮ#=|0ݬ0N@ EI endstream endobj 231 0 obj <>stream 0 0 0 12 50 82 d1 50 0 0 70 0 12 cm BI /IM true /W 50 /H 70 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Nis4_` ޼ɨ EI endstream endobj 232 0 obj <>stream 0 0 0 37 34 82 d1 34 0 0 45 0 37 cm BI /IM true /W 34 /H 45 /BPC 1 /D[1 0] /F/CCF /DP<> ID *8k |a>- `IC  EI endstream endobj 233 0 obj <> stream 39 0 0 0 0 0 d1 endstream endobj 234 0 obj <>stream 0 0 0 37 49 102 d1 49 0 0 65 0 37 cm BI /IM true /W 49 /H 65 /BPC 1 /D[1 0] /F/CCF /DP<> ID /85".G? O}x_KvX xX1 MG  EI endstream endobj 235 0 obj <>stream 0 0 0 15 22 82 d1 22 0 0 67 0 15 cm BI /IM true /W 22 /H 67 /BPC 1 /D[1 0] /F/CCF /DP<> ID jDkXQ=?0 EI endstream endobj 236 0 obj <> stream 28 0 0 0 0 0 d1 endstream endobj 237 0 obj <> stream 29 0 0 0 0 0 d1 endstream endobj 238 0 obj <>stream 0 0 0 39 67 84 d1 67 0 0 45 0 39 cm BI /IM true /W 67 /H 45 /BPC 1 /D[1 0] /F/CCF /DP<> ID &g0?_AtդMx}PT'q:@ EI endstream endobj 239 0 obj <>stream 0 0 0 36 32 84 d1 32 0 0 48 0 36 cm BI /IM true /W 32 /H 48 /BPC 1 /D[1 0] /F/CCF /DP<> ID 0!_ m8 7_ PU/BX%Z8PD3kkapboN<@ EI endstream endobj 240 0 obj <>stream 0 0 0 71 12 82 d1 12 0 0 11 0 71 cm BI /IM true /W 12 /H 11 /BPC 1 /D[1 0] /F/CCF /DP<> ID &ۂ!MPX0 EI endstream endobj 241 0 obj <>stream 0 0 0 0 39 79 d1 39 0 0 79 0 0 cm BI /IM true /W 39 /H 79 /BPC 1 /D[1 0] /F/CCF /DP<> ID & m||@ EI endstream endobj 242 0 obj <> endobj 243 0 obj <> endobj 247 0 obj <>stream 0 0 0 0 47 79 d1 47 0 0 79 0 0 cm BI /IM true /W 47 /H 79 /BPC 1 /D[1 0] /F/CCF /DP<> ID &= f{o7{}o= >oO7 ]XzimX0 EI endstream endobj 248 0 obj <>stream 0 0 0 0 49 82 d1 49 0 0 82 0 0 cm BI /IM true /W 49 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &3`g*"qG|'MCIf>A .?X_u d0ΡAE8>stream 0 0 0 0 49 82 d1 49 0 0 82 0 0 cm BI /IM true /W 49 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A <,=W}~___>_m/`^8 _Ooo [dž V aD@ EI endstream endobj 250 0 obj <>stream 0 0 0 3 74 85 d1 74 0 0 82 0 3 cm BI /IM true /W 74 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &C-l22U=v^`À EI endstream endobj 251 0 obj <>stream 0 0 0 2 55 87 d1 55 0 0 85 0 2 cm BI /IM true /W 55 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &>aazO&~û u]u܉O? EI endstream endobj 252 0 obj <>stream 0 0 0 3 53 85 d1 53 0 0 82 0 3 cm BI /IM true /W 53 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &&5???h EI endstream endobj 253 0 obj <>stream 0 0 0 0 109 82 d1 109 0 0 82 0 0 cm BI /IM true /W 109 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID *r7&C aۻh>A}?{o^}{ o<0b!!~@ EI endstream endobj 254 0 obj <>stream 0 0 0 32 59 87 d1 59 0 0 55 0 32 cm BI /IM true /W 59 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &p3O>?=?}ws_{߿߿rkv_uíxh0[C=  EI endstream endobj 255 0 obj <>stream 0 0 0 32 55 87 d1 55 0 0 55 0 32 cm BI /IM true /W 55 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &`O>l m/Iww!wa󃽇ᆂk ! EI endstream endobj 256 0 obj <>stream 0 0 0 2 26 87 d1 26 0 0 85 0 2 cm BI /IM true /W 26 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &|zO~{M}ÇD @ EI endstream endobj 257 0 obj <>stream 0 0 0 0 79 112 d1 79 0 0 112 0 0 cm BI /IM true /W 79 /H 112 /BPC 1 /D[1 0] /F/CCF /DP<> ID &N^8|2m8x}!kA|230߇a?a>?/ ^fal 3P8\x`` AO~C0D@ EI endstream endobj 258 0 obj <>stream 0 0 0 -6 169 112 d1 169 0 0 118 0 -6 cm BI /IM true /W 169 /H 118 /BPC 1 /D[1 0] /F/CCF /DP<> ID &QjA>stream 0 0 0 32 77 114 d1 77 0 0 82 0 32 cm BI /IM true /W 77 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &K"<,>K~ | x__X_; 7p]pka_\=S0_i EI endstream endobj 260 0 obj <>stream 0 0 0 32 87 114 d1 87 0 0 82 0 32 cm BI /IM true /W 87 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &O\ $ /蕗jsǒ\Bɯ?~_ O aO Bk~ $ 7<2R _e EI endstream endobj 261 0 obj <>stream 0 0 0 -7 94 114 d1 94 0 0 121 0 -7 cm BI /IM true /W 94 /H 121 /BPC 1 /D[1 0] /F/CCF /DP<> ID &j dC 7 ? w/pk#D" _ _ &  EI endstream endobj 262 0 obj <>stream 0 0 0 7 62 112 d1 62 0 0 105 0 7 cm BI /IM true /W 62 /H 105 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A_@dA_@ EI endstream endobj 263 0 obj <>stream 0 0 0 17 72 114 d1 72 0 0 97 0 17 cm BI /IM true /W 72 /H 97 /BPC 1 /D[1 0] /F/CCF /DP<> ID &j ֯ >S@`?AxMᬆ@ EI endstream endobj 264 0 obj <>stream 0 0 0 34 68 114 d1 68 0 0 80 0 34 cm BI /IM true /W 68 /H 80 /BPC 1 /D[1 0] /F/CCF /DP<> ID &S0c!SD_N"j A/\/8A.vo?_   /+p/_ [a3* EI endstream endobj 265 0 obj <>stream 0 0 0 36 77 112 d1 77 0 0 76 0 36 cm BI /IM true /W 77 /H 76 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Uk?7a!ap0c_aF$ EI endstream endobj 266 0 obj <>stream 0 0 0 34 79 114 d1 79 0 0 80 0 34 cm BI /IM true /W 79 /H 80 /BPC 1 /D[1 0] /F/CCF /DP<> ID & DOEW@r .j/ A@?N~;dLKh+e CM'C/Ia_ `_ GX2!g@ EI endstream endobj 267 0 obj <> stream 130 0 0 0 0 0 d1 endstream endobj 268 0 obj <>stream 0 0 0 31 44 87 d1 44 0 0 56 0 31 cm BI /IM true /W 44 /H 56 /BPC 1 /D[1 0] /F/CCF /DP<> ID &@LA#u=6Rj^ W O- 30D4wT׆.}% @@ EI endstream endobj 269 0 obj <>stream 0 0 0 10 49 85 d1 49 0 0 75 0 10 cm BI /IM true /W 49 /H 75 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A,ɯb톟i} H EI endstream endobj 270 0 obj <>stream 0 0 0 1 79 88 d1 79 0 0 87 0 1 cm BI /IM true /W 79 /H 87 /BPC 1 /D[1 0] /F/CCF /DP<> ID &t h<#@<AxI0>MzO0AA7kz]x]][ m[ X0 ,0 z@@ EI endstream endobj 272 0 obj <>stream 0 0 0 0 13 52 d1 13 0 0 52 0 0 cm BI /IM true /W 13 /H 52 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Mu`_` EI endstream endobj 273 0 obj <>stream 0 0 0 2 31 95 d1 31 0 0 93 0 2 cm BI /IM true /W 31 /H 93 /BPC 1 /D[1 0] /F/CCF /DP<> ID &]a:ZZ-ZuֽatZ__&?{{}=?5 EI endstream endobj 274 0 obj <>stream 0 0 0 72 15 85 d1 15 0 0 13 0 72 cm BI /IM true /W 15 /H 13 /BPC 1 /D[1 0] /F/CCF /DP<> ID & kj  EI endstream endobj 275 0 obj <>stream 0 0 0 2 31 95 d1 31 0 0 93 0 2 cm BI /IM true /W 31 /H 93 /BPC 1 /D[1 0] /F/CCF /DP<> ID &.!Mw{὾߇o~_~ֽk]axZ֖-.&P EI endstream endobj 276 0 obj <>stream 0 0 0 32 56 114 d1 56 0 0 82 0 32 cm BI /IM true /W 56 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &$0?kt & |. o\{_pguG`}A}o_"Gj|0N `P EI endstream endobj 277 0 obj <>stream 0 0 0 32 45 87 d1 45 0 0 55 0 32 cm BI /IM true /W 45 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &ȵ  o޷{{d~o6-0.<5/H EI endstream endobj 278 0 obj <>stream 0 0 0 2 51 87 d1 51 0 0 85 0 2 cm BI /IM true /W 51 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &0|?vI5\7_-K@[ Do 0{a^= _3  EI endstream endobj 279 0 obj <>stream 0 0 0 32 41 87 d1 41 0 0 55 0 32 cm BI /IM true /W 41 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &J?a xA}7&߿'^>d \.h:p00,z@@ EI endstream endobj 280 0 obj <>stream 0 0 0 32 58 112 d1 58 0 0 80 0 32 cm BI /IM true /W 58 /H 80 /BPC 1 /D[1 0] /F/CCF /DP<> ID &ᅐקC9?OЇ@_IO}u/ wkךav_kh;P EI endstream endobj 281 0 obj <>stream 0 0 0 3 78 85 d1 78 0 0 82 0 3 cm BI /IM true /W 78 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Ți ( ??8 EI endstream endobj 282 0 obj <>stream 0 0 0 32 58 85 d1 58 0 0 53 0 32 cm BI /IM true /W 58 /H 53 /BPC 1 /D[1 0] /F/CCF /DP<> ID &P(Za8&5JO k ]*bɪ_ b ( EI endstream endobj 283 0 obj <>stream 0 0 0 33 58 87 d1 58 0 0 54 0 33 cm BI /IM true /W 58 /H 54 /BPC 1 /D[1 0] /F/CCF /DP<> ID &_-p@Ӻ։3=dV5U  EI endstream endobj 284 0 obj <>stream 0 0 0 44 49 53 d1 49 0 0 9 0 44 cm BI /IM true /W 49 /H 9 /BPC 1 /D[1 0] /F/CCF /DP<> ID &? EI endstream endobj 285 0 obj <> endobj 289 0 obj <> stream 123 0 0 0 0 0 d1 endstream endobj 290 0 obj <>stream 0 0 0 33 56 85 d1 56 0 0 52 0 33 cm BI /IM true /W 56 /H 52 /BPC 1 /D[1 0] /F/CCF /DP<> ID &O}{_Z_/}4O "  5I EI endstream endobj 291 0 obj <>stream 0 0 0 12 58 85 d1 58 0 0 73 0 12 cm BI /IM true /W 58 /H 73 /BPC 1 /D[1 0] /F/CCF /DP<> ID &P(Za8&5JO kh axXMWa@@ EI endstream endobj 292 0 obj <> stream 143 0 0 0 0 0 d1 endstream endobj 293 0 obj <>stream 0 0 0 18 49 79 d1 49 0 0 61 0 18 cm BI /IM true /W 49 /H 61 /BPC 1 /D[1 0] /F/CCF /DP<> ID &|<0`oo|0xoۃްZX^ h.ZX.a. h ah/p( EI endstream endobj 294 0 obj <>stream 0 0 0 10 52 87 d1 52 0 0 77 0 10 cm BI /IM true /W 52 /H 77 /BPC 1 /D[1 0] /F/CCF /DP<> ID &>C =?5`~[k_%\,׼Q}?ᄶaD bkk ,p  EI endstream endobj 295 0 obj <>stream 0 0 0 32 41 87 d1 41 0 0 55 0 32 cm BI /IM true /W 41 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &J?GzS PPo۵j> stream 119 0 0 0 0 0 d1 endstream endobj 297 0 obj <>stream 0 0 0 32 57 108 d1 57 0 0 76 0 32 cm BI /IM true /W 57 /H 76 /BPC 1 /D[1 0] /F/CCF /DP<> ID &kk)b́-@&zM?DŽ}_/_ h/z`'y x EI endstream endobj 298 0 obj <>stream 0 0 0 -5 28 115 d1 28 0 0 120 0 -5 cm BI /IM true /W 28 /H 120 /BPC 1 /D[1 0] /F/CCF /DP<> ID &cXZZ -p]~p/z__a{x}{p EI endstream endobj 299 0 obj <>stream 0 0 0 -5 28 115 d1 28 0 0 120 0 -5 cm BI /IM true /W 28 /H 120 /BPC 1 /D[1 0] /F/CCF /DP<> ID &{{|7{{??_kz_ֽaz׭uZu@ EI endstream endobj 300 0 obj <>stream 0 0 0 33 51 85 d1 51 0 0 52 0 33 cm BI /IM true /W 51 /H 52 /BPC 1 /D[1 0] /F/CCF /DP<> ID &k3{~톶{὾oo/ EI endstream endobj 301 0 obj <>stream 0 0 0 12 56 87 d1 56 0 0 75 0 12 cm BI /IM true /W 56 /H 75 /BPC 1 /D[1 0] /F/CCF /DP<> ID &H>CA0|_q @7^z`W !׬& EI endstream endobj 302 0 obj <>stream 0 0 0 33 55 113 d1 55 0 0 80 0 33 cm BI /IM true /W 55 /H 80 /BPC 1 /D[1 0] /F/CCF /DP<> ID & zz}.^K޿[?_?_!D4' |5 EI endstream endobj 303 0 obj <>stream 0 0 0 12 54 85 d1 54 0 0 73 0 12 cm BI /IM true /W 54 /H 73 /BPC 1 /D[1 0] /F/CCF /DP<> ID &?uO_)w`| O EI endstream endobj 304 0 obj <>stream 0 0 0 12 19 48 d1 19 0 0 36 0 12 cm BI /IM true /W 19 /H 36 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A& w䃭~ EI endstream endobj 305 0 obj <> stream 137 0 0 0 0 0 d1 endstream endobj 306 0 obj <> endobj 310 0 obj <> stream 141 0 0 0 0 0 d1 endstream endobj 311 0 obj <>stream 0 0 0 12 56 85 d1 56 0 0 73 0 12 cm BI /IM true /W 56 /H 73 /BPC 1 /D[1 0] /F/CCF /DP<> ID &(RjY 2)}ץz/]ip/ {~߰7~߷ OO0* EI endstream endobj 312 0 obj <> stream 125 0 0 0 0 0 d1 endstream endobj 313 0 obj <>stream 0 0 0 33 56 85 d1 56 0 0 52 0 33 cm BI /IM true /W 56 /H 52 /BPC 1 /D[1 0] /F/CCF /DP<> ID &\ O[?&oo[[0N,'5H5M@@ EI endstream endobj 314 0 obj <>stream 0 0 0 0 79 114 d1 79 0 0 114 0 0 cm BI /IM true /W 79 /H 114 /BPC 1 /D[1 0] /F/CCF /DP<> ID &AOh.[ p 15 awa( O_ւ/0,ND/  Q0!ă`<7a>B'| _.@f!NXb4 / EI endstream endobj 315 0 obj <>stream 0 0 0 -7 118 114 d1 118 0 0 121 0 -7 cm BI /IM true /W 118 /H 121 /BPC 1 /D[1 0] /F/CCF /DP<> ID &PB+? ;P3\1a <,>}aA a_a__ xekd),? ᅇ)[d5.Eg0j?  EI endstream endobj 316 0 obj <>stream 0 0 0 34 152 112 d1 152 0 0 78 0 34 cm BI /IM true /W 152 /H 78 /BPC 1 /D[1 0] /F/CCF /DP<> ID &KBa !4;pS0 =a6(   `2` / jW EI endstream endobj 317 0 obj <>stream 0 0 0 34 94 145 d1 94 0 0 111 0 34 cm BI /IM true /W 94 /H 111 /BPC 1 /D[1 0] /F/CCF /DP<> ID %MC*CHSJD0`6~O ?O7 /48XA0A| \xa~ B| @ EI endstream endobj 318 0 obj <>stream 0 0 0 32 62 114 d1 62 0 0 82 0 32 cm BI /IM true /W 62 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &.SBCB|? =_ dAr KaxX@^"A0 A//p?(x|%4 @ EI endstream endobj 319 0 obj <>stream 0 0 0 -6 193 114 d1 193 0 0 120 0 -6 cm BI /IM true /W 193 /H 120 /BPC 1 /D[1 0] /F/CCF /DP<> ID &f `? ?[ 0!a}~>ma _ ? XkA(l,?~X Ck]a a/xOPx/?,?'oa (e EI endstream endobj 320 0 obj <>stream 0 0 0 -7 96 112 d1 96 0 0 119 0 -7 cm BI /IM true /W 96 /H 119 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A%#0 2OAO!??\/T@ EI endstream endobj 321 0 obj <>stream 0 0 0 -7 123 114 d1 123 0 0 121 0 -7 cm BI /IM true /W 123 /H 121 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Bm5T e# A`1`&\ @Ǭ>  &AA A x&>stream 0 0 0 65 51 81 d1 51 0 0 16 0 65 cm BI /IM true /W 51 /H 16 /BPC 1 /D[1 0] /F/CCF /DP<> ID & EI endstream endobj 323 0 obj <>stream 0 0 0 2 37 37 d1 37 0 0 35 0 2 cm BI /IM true /W 37 /H 35 /BPC 1 /D[1 0] /F/CCF /DP<> ID &p wU˜Ax{l?{m{ EI endstream endobj 324 0 obj <>stream 0 0 0 2 37 37 d1 37 0 0 35 0 2 cm BI /IM true /W 37 /H 35 /BPC 1 /D[1 0] /F/CCF /DP<> ID &`&{a}߇w/2  kU_& EI endstream endobj 325 0 obj <>stream 0 0 0 0 65 96 d1 65 0 0 96 0 0 cm BI /IM true /W 65 /H 96 /BPC 1 /D[1 0] /F/CCF /DP<> ID &_  z@#lzal8&_k?_K gp_h ֟ |="Aӿ^ག/_Ρ1a~ AB EI endstream endobj 326 0 obj <>stream 0 0 0 72 23 94 d1 23 0 0 22 0 72 cm BI /IM true /W 23 /H 22 /BPC 1 /D[1 0] /F/CCF /DP<> ID &ka`|@ EI endstream endobj 327 0 obj <>stream 0 0 0 0 56 94 d1 56 0 0 94 0 0 cm BI /IM true /W 56 /H 94 /BPC 1 /D[1 0] /F/CCF /DP<> ID &lOZC ?!>@Ƙ? EI endstream endobj 328 0 obj <>stream 0 0 0 6 67 96 d1 67 0 0 90 0 6 cm BI /IM true /W 67 /H 90 /BPC 1 /D[1 0] /F/CCF /DP<> ID &ܐ  "| h< =sPa~t  ?A x5?k]0dP|{d CPf@ EI endstream endobj 329 0 obj <>stream 0 0 0 29 56 96 d1 56 0 0 67 0 29 cm BI /IM true /W 56 /H 67 /BPC 1 /D[1 0] /F/CCF /DP<> ID &ܐ @ xA#X|> |'A_\<.^a p` k7# EI endstream endobj 330 0 obj <>stream 0 0 0 72 24 122 d1 24 0 0 50 0 72 cm BI /IM true /W 24 /H 50 /BPC 1 /D[1 0] /F/CCF /DP<> ID &l>a~!~X0_ EI endstream endobj 331 0 obj <>stream 0 0 0 15 60 96 d1 60 0 0 81 0 15 cm BI /IM true /W 60 /H 81 /BPC 1 /D[1 0] /F/CCF /DP<> ID &C O#xr]? dGa@@ EI endstream endobj 332 0 obj <>stream 0 0 0 5 53 94 d1 53 0 0 89 0 5 cm BI /IM true /W 53 /H 89 /BPC 1 /D[1 0] /F/CCF /DP<> ID &(|)5 3aႀ EI endstream endobj 333 0 obj <>stream 0 0 0 31 72 94 d1 72 0 0 63 0 31 cm BI /IM true /W 72 /H 63 /BPC 1 /D[1 0] /F/CCF /DP<> ID &j, T ÿ &eAt5 _ɪ@00 EI endstream endobj 334 0 obj <>stream 0 0 0 29 57 96 d1 57 0 0 67 0 29 cm BI /IM true /W 57 /H 67 /BPC 1 /D[1 0] /F/CCF /DP<> ID &`| x F|| @t +NM]a0\=lB5,>  EI endstream endobj 335 0 obj <>stream 0 0 0 29 52 96 d1 52 0 0 67 0 29 cm BI /IM true /W 52 /H 67 /BPC 1 /D[1 0] /F/CCF /DP<> ID &SP1+@ +Nj z4 ('Aqంx,"4 W5yภX}^k|2  EI endstream endobj 336 0 obj <>stream 0 0 0 28 73 96 d1 73 0 0 68 0 28 cm BI /IM true /W 73 /H 68 /BPC 1 /D[1 0] /F/CCF /DP<> ID &~A\D4`D ~1) )ɯ` !  @_U!~/Ix^aK``` <@ EI endstream endobj 337 0 obj <>stream 0 0 0 29 80 94 d1 80 0 0 65 0 29 cm BI /IM true /W 80 /H 65 /BPC 1 /D[1 0] /F/CCF /DP<> ID &]_V V >b 9 EI endstream endobj 338 0 obj <>stream 0 0 0 -5 79 96 d1 79 0 0 101 0 -5 cm BI /IM true /W 79 /H 101 /BPC 1 /D[1 0] /F/CCF /DP<> ID &`tC:H:" B MaC~/ ` /!?I}  EI endstream endobj 339 0 obj <>stream 0 0 0 6 57 94 d1 57 0 0 88 0 6 cm BI /IM true /W 57 /H 88 /BPC 1 /D[1 0] /F/CCF /DP<> ID &- \k_ڀ EI endstream endobj 340 0 obj <>stream 0 0 0 1 73 85 d1 73 0 0 84 0 1 cm BI /IM true /W 73 /H 84 /BPC 1 /D[1 0] /F/CCF /DP<> ID &0C`{LIpPH=a ?a\1?X` ! R  EI endstream endobj 341 0 obj <>stream 0 0 0 0 79 82 d1 79 0 0 82 0 0 cm BI /IM true /W 79 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &FI4 ޭ7~/_//K Zd8_X4 EI endstream endobj 342 0 obj <>stream 0 0 0 3 78 88 d1 78 0 0 85 0 3 cm BI /IM true /W 78 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &HP#aAH7ނa_2Z4Cb EI endstream endobj 343 0 obj <>stream 0 0 0 3 68 85 d1 68 0 0 82 0 3 cm BI /IM true /W 68 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Ț@|>P ?߆_}xAz_ (AC` EI endstream endobj 344 0 obj <>stream 0 0 0 0 51 81 d1 51 0 0 81 0 0 cm BI /IM true /W 51 /H 81 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Hߜ @aa{ EI endstream endobj 345 0 obj <> endobj 349 0 obj <>stream 0 0 0 0 65 94 d1 65 0 0 94 0 0 cm BI /IM true /W 65 /H 94 /BPC 1 /D[1 0] /F/CCF /DP<> ID &O>M7`m߇܆axa=?MxKׂ(^aapt `a,  EI endstream endobj 350 0 obj <>stream 0 0 0 -3 101 94 d1 101 0 0 97 0 -3 cm BI /IM true /W 101 /H 97 /BPC 1 /D[1 0] /F/CCF /DP<> ID &џ]z _ A|?\G EI endstream endobj 351 0 obj <>stream 0 0 0 -7 36 94 d1 36 0 0 101 0 -7 cm BI /IM true /W 36 /H 101 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Z_A @ EI endstream endobj 352 0 obj <>stream 0 0 0 -5 37 94 d1 37 0 0 99 0 -5 cm BI /IM true /W 37 /H 99 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Z O@ EI endstream endobj 353 0 obj <>stream 0 0 0 -4 116 96 d1 116 0 0 100 0 -4 cm BI /IM true /W 116 /H 100 /BPC 1 /D[1 0] /F/CCF /DP<> ID &x)yTx'cz&a!k~ׂ ~ c#+ ?_z^/2pP\) EI endstream endobj 354 0 obj <>stream 0 0 0 28 64 96 d1 64 0 0 68 0 28 cm BI /IM true /W 64 /H 68 /BPC 1 /D[1 0] /F/CCF /DP<> ID &k ?CN@  ATֿPzkq<5 2 EI endstream endobj 355 0 obj <>stream 0 0 0 28 62 96 d1 62 0 0 68 0 28 cm BI /IM true /W 62 /H 68 /BPC 1 /D[1 0] /F/CCF /DP<> ID &j ! X|'7>&>?ChA!t  k 2 EI endstream endobj 356 0 obj <>stream 0 0 0 29 80 96 d1 80 0 0 67 0 29 cm BI /IM true /W 80 /H 67 /BPC 1 /D[1 0] /F/CCF /DP<> ID &`CCb&>5ħ P ?8d  EI endstream endobj 357 0 obj <>stream 0 0 0 29 57 94 d1 57 0 0 65 0 29 cm BI /IM true /W 57 /H 65 /BPC 1 /D[1 0] /F/CCF /DP<> ID % Ph;{X>~ l)5(  EI endstream endobj 358 0 obj <>stream 0 0 0 28 52 96 d1 52 0 0 68 0 28 cm BI /IM true /W 52 /H 68 /BPC 1 /D[1 0] /F/CCF /DP<> ID &9 F!~_A|XLyK^~\&y4}u᰼0_/> ? EI endstream endobj 359 0 obj <>stream 0 0 0 28 71 96 d1 71 0 0 68 0 28 cm BI /IM true /W 71 /H 68 /BPC 1 /D[1 0] /F/CCF /DP<> ID &j nc ?)<aoX} O4/`S   3* EI endstream endobj 360 0 obj <>stream 0 0 0 -5 18 115 d1 18 0 0 120 0 -5 cm BI /IM true /W 18 /H 120 /BPC 1 /D[1 0] /F/CCF /DP<> ID & EI endstream endobj 361 0 obj <>stream 0 0 0 -11 18 109 d1 18 0 0 120 0 -11 cm BI /IM true /W 18 /H 120 /BPC 1 /D[1 0] /F/CCF /DP<> ID 5? EI endstream endobj 362 0 obj <>stream 0 0 0 -4 115 94 d1 115 0 0 98 0 -4 cm BI /IM true /W 115 /H 98 /BPC 1 /D[1 0] /F/CCF /DP<> ID &00 @_ EI endstream endobj 363 0 obj <>stream 0 0 0 29 73 125 d1 73 0 0 96 0 29 cm BI /IM true /W 73 /H 96 /BPC 1 /D[1 0] /F/CCF /DP<> ID &` `[ Ȁ#PeCMA0>stream 0 0 0 -5 80 94 d1 80 0 0 99 0 -5 cm BI /IM true /W 80 /H 99 /BPC 1 /D[1 0] /F/CCF /DP<> ID &]_뚓H+`/!.Q?8p EI endstream endobj 365 0 obj <>stream 0 0 0 55 43 68 d1 43 0 0 13 0 55 cm BI /IM true /W 43 /H 13 /BPC 1 /D[1 0] /F/CCF /DP<> ID  EI endstream endobj 366 0 obj <>stream 0 0 0 -4 88 94 d1 88 0 0 98 0 -4 cm BI /IM true /W 88 /H 98 /BPC 1 /D[1 0] /F/CCF /DP<> ID &_/}`? B>stream 0 0 0 3 52 96 d1 52 0 0 93 0 3 cm BI /IM true /W 52 /H 93 /BPC 1 /D[1 0] /F/CCF /DP<> ID &C Ca7z FWD|? EI endstream endobj 368 0 obj <>stream 0 0 0 3 115 88 d1 115 0 0 85 0 3 cm BI /IM true /W 115 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &`L4OOOOz ?k|' 7߾p[V-? $k}>moz-> ׾$h4 !* EI endstream endobj 369 0 obj <> stream 133 0 0 0 0 0 d1 endstream endobj 370 0 obj <>stream 0 0 0 0 47 82 d1 47 0 0 82 0 0 cm BI /IM true /W 47 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &@h0H#1x0oM޿ S]?~G{_vFc !yͯ|(|(@ EI endstream endobj 371 0 obj <> endobj 375 0 obj <>stream 0 0 0 10 49 87 d1 49 0 0 77 0 10 cm BI /IM true /W 49 /H 77 /BPC 1 /D[1 0] /F/CCF /DP<> ID &3 x  >AOwKK޶  kk/ EI endstream endobj 376 0 obj <> stream 129 0 0 0 0 0 d1 endstream endobj 377 0 obj <>stream 0 0 0 0 71 94 d1 71 0 0 94 0 0 cm BI /IM true /W 71 /H 94 /BPC 1 /D[1 0] /F/CCF /DP<> ID &c64P!5o7 ??o}@ EI endstream endobj 378 0 obj <>stream 0 0 0 -5 72 96 d1 72 0 0 101 0 -5 cm BI /IM true /W 72 /H 101 /BPC 1 /D[1 0] /F/CCF /DP<> ID &e2 vBp@@!|C ?-rF?!')r̆p,\, Z(l d\kkd*d2ׅ 5`O?  ^ EI endstream endobj 379 0 obj <>stream 0 0 0 29 126 94 d1 126 0 0 65 0 29 cm BI /IM true /W 126 /H 65 /BPC 1 /D[1 0] /F/CCF /DP<> ID &E̫pᦼR׷R8_ `^ Pb`9ԃF EI endstream endobj 380 0 obj <> stream 136 0 0 0 0 0 d1 endstream endobj 381 0 obj <>stream 0 0 0 -5 110 96 d1 110 0 0 101 0 -5 cm BI /IM true /W 110 /H 101 /BPC 1 /D[1 0] /F/CCF /DP<> ID &DkQ "\0_K L/ ATX_a _/ z^z/!@0k~] /k^ *, |=H(|'!4 [@ EI endstream endobj 382 0 obj <> stream 147 0 0 0 0 0 d1 endstream endobj 383 0 obj <>stream 0 0 0 32 52 109 d1 52 0 0 77 0 32 cm BI /IM true /W 52 /H 77 /BPC 1 /D[1 0] /F/CCF /DP<> ID &X z3a|0C G w$ ?w aۇ߆koK   EI endstream endobj 384 0 obj <>stream 0 0 0 32 89 87 d1 89 0 0 55 0 32 cm BI /IM true /W 89 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &p  0Aa߇wp|? 濇w{~5 ?wwϯ}[{a[ |?L:aæ & .8A B) EI endstream endobj 385 0 obj <> endobj 389 0 obj <>stream 0 0 0 33 54 85 d1 54 0 0 52 0 33 cm BI /IM true /W 54 /H 52 /BPC 1 /D[1 0] /F/CCF /DP<> ID &." 5k"Pvt 5pKmv׊ }O:}? zMF#M8P EI endstream endobj 390 0 obj <>stream 0 0 0 10 41 85 d1 41 0 0 75 0 10 cm BI /IM true /W 41 /H 75 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Z}?E}@ EI endstream endobj 391 0 obj <> stream 135 0 0 0 0 0 d1 endstream endobj 392 0 obj <>stream 0 0 0 0 65 96 d1 65 0 0 96 0 0 cm BI /IM true /W 65 /H 96 /BPC 1 /D[1 0] /F/CCF /DP<> ID & L!Π`x[@0;M ׬ax\"\/^ BWX6o>|>m EI endstream endobj 393 0 obj <>stream 0 0 0 0 82 85 d1 82 0 0 85 0 0 cm BI /IM true /W 82 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &xnN,?h77&|0? ?_~/ @|Au37P߃~_//K,&@~8/5@ EI endstream endobj 394 0 obj <>stream 0 0 0 0 65 96 d1 65 0 0 96 0 0 cm BI /IM true /W 65 /H 96 /BPC 1 /D[1 0] /F/CCF /DP<> ID &u ^?AxHz ?}(o__AC_ #/^/t C7 ~  ?}> r / x0` A_ EI endstream endobj 395 0 obj <>stream 0 0 0 6 65 94 d1 65 0 0 88 0 6 cm BI /IM true /W 65 /H 88 /BPC 1 /D[1 0] /F/CCF /DP<> ID & HOA_H6d\?7 }~/Y&/ Hl EI endstream endobj 396 0 obj <>stream 0 0 0 31 64 94 d1 64 0 0 63 0 31 cm BI /IM true /W 64 /H 63 /BPC 1 /D[1 0] /F/CCF /DP<> ID &, &_]݄P٨qxk5 i EI endstream endobj 397 0 obj <>stream 0 0 0 31 67 129 d1 67 0 0 98 0 31 cm BI /IM true /W 67 /H 98 /BPC 1 /D[1 0] /F/CCF /DP<> ID & Faep a🧎a~M}v d -EG˭x_H؃}PH0a޿) O' ܂  EI endstream endobj 398 0 obj <>stream 0 0 0 5 63 96 d1 63 0 0 91 0 5 cm BI /IM true /W 63 /H 91 /BPC 1 /D[1 0] /F/CCF /DP<> ID &`_F pAF@|/}' O_4_ 뿆kLJ@ / 2@" EI endstream endobj 399 0 obj <>stream 0 0 0 0 52 84 d1 52 0 0 84 0 0 cm BI /IM true /W 52 /H 84 /BPC 1 /D[1 0] /F/CCF /DP<> ID &f~a}~ݾߋ EI endstream endobj 400 0 obj <> endobj 404 0 obj <>stream 0 0 0 -3 69 96 d1 69 0 0 99 0 -3 cm BI /IM true /W 69 /H 99 /BPC 1 /D[1 0] /F/CCF /DP<> ID &5z?t?~o|_?0( EI endstream endobj 405 0 obj <>stream 0 0 0 6 64 94 d1 64 0 0 88 0 6 cm BI /IM true /W 64 /H 88 /BPC 1 /D[1 0] /F/CCF /DP<> ID &5B R?8_rk EI endstream endobj 406 0 obj <>stream 0 0 0 31 67 126 d1 67 0 0 95 0 31 cm BI /IM true /W 67 /H 95 /BPC 1 /D[1 0] /F/CCF /DP<> ID &0C@@?@b@?&?x_~a{^ j$B_ Mx5D@ EI endstream endobj 407 0 obj <>stream 0 0 0 0 71 82 d1 71 0 0 82 0 0 cm BI /IM true /W 71 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &sDІ]xhY(|/ ?z}}|.!WV  EI endstream endobj 408 0 obj <>stream 0 0 0 0 49 82 d1 49 0 0 82 0 0 cm BI /IM true /W 49 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &H`G'>}0'_/཮ h- o[a, q년@5}>a7 _._[ - b ,0 EI endstream endobj 409 0 obj <> endobj 413 0 obj <>stream 0 0 0 3 85 85 d1 85 0 0 82 0 3 cm BI /IM true /W 85 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &F/4OE _z zW ҿo 7_+ ޓ(z $ o EI endstream endobj 414 0 obj <> stream 139 0 0 0 0 0 d1 endstream endobj 415 0 obj <>stream 0 0 0 10 54 87 d1 54 0 0 77 0 10 cm BI /IM true /W 54 /H 77 /BPC 1 /D[1 0] /F/CCF /DP<> ID & 9? x@ ONĜ@?O^&aixXsO&o}c +w߇aS߅ ۯ׊  EI endstream endobj 416 0 obj <>stream 0 0 0 0 19 37 d1 19 0 0 37 0 0 cm BI /IM true /W 19 /H 37 /BPC 1 /D[1 0] /F/CCF /DP<> ID &|?~>&}{p EI endstream endobj 417 0 obj <>stream 0 0 0 72 19 102 d1 19 0 0 30 0 72 cm BI /IM true /W 19 /H 30 /BPC 1 /D[1 0] /F/CCF /DP<> ID &8}ɯ}Aֵ_o@ EI endstream endobj 418 0 obj <> stream 138 0 0 0 0 0 d1 endstream endobj 419 0 obj <>stream 0 0 0 0 85 112 d1 85 0 0 112 0 0 cm BI /IM true /W 85 /H 112 /BPC 1 /D[1 0] /F/CCF /DP<> ID &d"@k&o ?~ ?~~ ?~~0} EI endstream endobj 420 0 obj <>stream 0 0 0 -7 45 112 d1 45 0 0 119 0 -7 cm BI /IM true /W 45 /H 119 /BPC 1 /D[1 0] /F/CCF /DP<> ID & ? 5 EI endstream endobj 421 0 obj <>stream 0 0 0 0 49 82 d1 49 0 0 82 0 0 cm BI /IM true /W 49 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &3.=X=&Oo[o\=]Xad4  EI endstream endobj 422 0 obj <>stream 0 0 0 0 49 82 d1 49 0 0 82 0 0 cm BI /IM true /W 49 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &^B |@x[" Ӧow{^! y| oo 1?K_ wam+h<@ EI endstream endobj 423 0 obj <> endobj 424 0 obj <>stream 0 0 0 0 79 114 d1 79 0 0 114 0 0 cm BI /IM true /W 79 /H 114 /BPC 1 /D[1 0] /F/CCF /DP<> ID &D_l'V8cu?>Q??00__Ad/?. ~"Gr*bS`_?JZ_$Ȁox EI endstream endobj 428 0 obj <> endobj 429 0 obj <>stream 0 0 0 0 92 83 d1 92 0 0 83 0 0 cm BI /IM true /W 92 /H 83 /BPC 1 /D[1 0] /F/CCF /DP<> ID &B̂Xua߽v Wz/kkp]]t .? kkkk / EI endstream endobj 433 0 obj <>stream 0 0 0 28 52 85 d1 52 0 0 57 0 28 cm BI /IM true /W 52 /H 57 /BPC 1 /D[1 0] /F/CCF /DP<> ID & 0<"0G&x[>CLQ~> aiq0Y 0gP EI endstream endobj 434 0 obj <>stream 0 0 0 0 65 83 d1 65 0 0 83 0 0 cm BI /IM true /W 65 /H 83 /BPC 1 /D[1 0] /F/CCF /DP<> ID eMD$}~/ //KK]\/?a??aD.  EI endstream endobj 435 0 obj <>stream 0 0 0 29 67 83 d1 67 0 0 54 0 29 cm BI /IM true /W 67 /H 54 /BPC 1 /D[1 0] /F/CCF /DP<> ID &"hA?(оd* EI endstream endobj 436 0 obj <>stream 0 0 0 28 60 85 d1 60 0 0 57 0 28 cm BI /IM true /W 60 /H 57 /BPC 1 /D[1 0] /F/CCF /DP<> ID & >@ x zxFC`=7 ɯx\5zz/kaK`ȺAF EI endstream endobj 437 0 obj <>stream 0 0 0 30 92 83 d1 92 0 0 53 0 30 cm BI /IM true /W 92 /H 53 /BPC 1 /D[1 0] /F/CCF /DP<> ID &p3V  GO o>ao}[[Z__NZ[TFH  EI endstream endobj 438 0 obj <>stream 0 0 0 0 31 83 d1 31 0 0 83 0 0 cm BI /IM true /W 31 /H 83 /BPC 1 /D[1 0] /F/CCF /DP<> ID &D@@ EI endstream endobj 439 0 obj <>stream 0 0 0 28 54 85 d1 54 0 0 57 0 28 cm BI /IM true /W 54 /H 57 /BPC 1 /D[1 0] /F/CCF /DP<> ID & 0z#| 7}&5M?IC:_k.a-a`0  EI endstream endobj 440 0 obj <>stream 0 0 0 0 66 85 d1 66 0 0 85 0 0 cm BI /IM true /W 66 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &9@_ xA@P T2 tA^ᆻaw 'k"7#ra? @@ EI endstream endobj 441 0 obj <>stream 0 0 0 29 61 109 d1 61 0 0 80 0 29 cm BI /IM true /W 61 /H 80 /BPC 1 /D[1 0] /F/CCF /DP<> ID &!<E8a7z_]d .-E>N ȡq{:@azMڗߧvv G)`h  EI endstream endobj 442 0 obj <>stream 0 0 0 29 106 83 d1 106 0 0 54 0 29 cm BI /IM true /W 106 /H 54 /BPC 1 /D[1 0] /F/CCF /DP<> ID &M(Ђ?KtMvE`L41A_kY d00H  EI endstream endobj 443 0 obj <>stream 0 0 0 7 43 85 d1 43 0 0 78 0 7 cm BI /IM true /W 43 /H 78 /BPC 1 /D[1 0] /F/CCF /DP<> ID &ܠ' <.}&޾!ā5>3? EI endstream endobj 444 0 obj <>stream 0 0 0 28 43 85 d1 43 0 0 57 0 28 cm BI /IM true /W 43 /H 57 /BPC 1 /D[1 0] /F/CCF /DP<> ID &R?K>/jAp/׮Ay $Z kPe8aAG_k.%  EI endstream endobj 445 0 obj <>stream 0 0 0 3 48 88 d1 48 0 0 85 0 3 cm BI /IM true /W 48 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &^B'#=`zM'訽p~7x EI endstream endobj 446 0 obj <>stream 0 0 0 0 139 120 d1 139 0 0 120 0 0 cm BI /IM true /W 139 /H 120 /BPC 1 /D[1 0] /F/CCF /DP<> ID &xm<"LGɨg!T  _ k_A e.!;6!?a??_K/A#f v`I X EI endstream endobj 447 0 obj <>stream 0 0 0 -9 68 112 d1 68 0 0 121 0 -9 cm BI /IM true /W 68 /H 121 /BPC 1 /D[1 0] /F/CCF /DP<> ID & 3EjF Aa?aü W<_ EI endstream endobj 448 0 obj <>stream 0 0 0 1 66 88 d1 66 0 0 87 0 1 cm BI /IM true /W 66 /H 87 /BPC 1 /D[1 0] /F/CCF /DP<> ID 0!0@h v&@o}?o y x% sX5֯]uA?_߰]ypI TiT  EI endstream endobj 449 0 obj <>stream 0 0 0 2 54 87 d1 54 0 0 85 0 2 cm BI /IM true /W 54 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &σ?<#Ga~}&?ۿ?w{{]yKk|~?Z EI endstream endobj 450 0 obj <>stream 0 0 0 32 57 108 d1 57 0 0 76 0 32 cm BI /IM true /W 57 /H 76 /BPC 1 /D[1 0] /F/CCF /DP<> ID !H?R'_@7~{ =ÿ ?Mv~h-iqdž ` EI endstream endobj 451 0 obj <>stream 0 0 0 1 56 109 d1 56 0 0 108 0 1 cm BI /IM true /W 56 /H 108 /BPC 1 /D[1 0] /F/CCF /DP<> ID &|6q<~|P=?͟#A|;{\1Xaa EI endstream endobj 452 0 obj <>stream 0 0 0 1 78 88 d1 78 0 0 87 0 1 cm BI /IM true /W 78 /H 87 /BPC 1 /D[1 0] /F/CCF /DP<> ID &r<"@}0 xH7I[V7߰h >|0|2@WkyD8 EI endstream endobj 453 0 obj <>stream 0 0 0 3 77 85 d1 77 0 0 82 0 3 cm BI /IM true /W 77 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID #@5H{]"@܃saow_K^_ !O EI endstream endobj 454 0 obj <>stream 0 0 0 73 13 85 d1 13 0 0 12 0 73 cm BI /IM true /W 13 /H 12 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A  EI endstream endobj 455 0 obj <>stream 0 0 0 32 50 109 d1 50 0 0 77 0 32 cm BI /IM true /W 50 /H 77 /BPC 1 /D[1 0] /F/CCF /DP<> ID &TA?Lm75o |p }'?>ɯ~݇{ 4 a0 EI endstream endobj 456 0 obj <>stream 0 0 0 2 41 87 d1 41 0 0 85 0 2 cm BI /IM true /W 41 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID & xI&oP{??v]Ǹax0^=  EI endstream endobj 457 0 obj <>stream 0 0 0 3 64 85 d1 64 0 0 82 0 3 cm BI /IM true /W 64 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID +?P?a ?{3w EI endstream endobj 458 0 obj <>stream 0 0 0 51 109 54 d1 109 0 0 3 0 51 cm BI /IM true /W 109 /H 3 /BPC 1 /D[1 0] /F/CCF /DP<> ID  EI endstream endobj 459 0 obj <>stream 0 0 0 56 30 63 d1 30 0 0 7 0 56 cm BI /IM true /W 30 /H 7 /BPC 1 /D[1 0] /F/CCF /DP<> ID _y5 EI endstream endobj 460 0 obj <>stream 0 0 0 45 58 48 d1 58 0 0 3 0 45 cm BI /IM true /W 58 /H 3 /BPC 1 /D[1 0] /F/CCF /DP<> ID  EI endstream endobj 461 0 obj <>stream 0 0 0 33 24 85 d1 24 0 0 52 0 33 cm BI /IM true /W 24 /H 52 /BPC 1 /D[1 0] /F/CCF /DP<> ID & ,  EI endstream endobj 462 0 obj <>stream 0 0 0 1 76 88 d1 76 0 0 87 0 1 cm BI /IM true /W 76 /H 87 /BPC 1 /D[1 0] /F/CCF /DP<> ID &R #AA H0} 7V_տޡo ?[~~imkAa ,0ipdR0 , EI endstream endobj 463 0 obj <>stream 0 0 0 32 49 87 d1 49 0 0 55 0 32 cm BI /IM true /W 49 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &g< {{h?3  >>oooaxoo}a{y oC#> ! &w @ EI endstream endobj 464 0 obj <>stream 0 0 0 3 80 85 d1 80 0 0 82 0 3 cm BI /IM true /W 80 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A(ro߾o4_߿^wx__ / _ EI endstream endobj 465 0 obj <>stream 0 0 0 32 55 87 d1 55 0 0 55 0 32 cm BI /IM true /W 55 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &>3?= >stream 0 0 0 3 76 88 d1 76 0 0 85 0 3 cm BI /IM true /W 76 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &8)A['00zOo~a߻p{>stream 0 0 0 2 17 37 d1 17 0 0 35 0 2 cm BI /IM true /W 17 /H 35 /BPC 1 /D[1 0] /F/CCF /DP<> ID 0MP{x}g,!j  EI endstream endobj 468 0 obj <> endobj 271 0 obj <>/FontBBox[0 -73 193 131]/FontMatrix[1 0 0 1 0 0]/FirstChar 0/LastChar 249/Widths[ 0 0 0 109 0 144 62 61 0 47 0 44 145 0 34 54 0 0 0 63 0 79 0 77 0 0 66 140 123 67 69 0 43 0 57 143 0 46 0 120 0 119 60 48 82 53 0 51 0 96 0 84 68 55 0 56 64 142 0 0 0 124 0 59 137 112 141 0 70 125 58 0 0 0 0 98 0 0 107 0 0 0 0 102 0 117 0 0 0 0 0 0 78 0 76 92 0 0 83 0 0 81 0 0 0 0 89 0 73 72 113 28 0 104 52 118 26 0 0 0 65 0 0 41 0 0 0 0 97 0 121 0 74 0 0 0 0 45 0 0 33 0 127 0 0 88 0 80 0 87 0 0 101 133 42 0 0 129 0 38 0 0 136 116 90 0 147 0 130 0 108 71 32 36 100 0 0 135 0 85 75 0 99 50 0 0 0 0 0 0 0 0 0 0 0 0 139 0 0 0 138 0 0 0 0 0 86 0 0 0 0 0 0 0 0 37 0 0 0 0 0 0 0 0 110 0 0 0 40 0 0 0 94 0 27 0 0 0 0 114 0 0 93 0 0 0 0 0 0 0] >> endobj 9 0 obj <>/FontBBox[0 -124 169 141]/FontMatrix[1 0 0 1 0 0]/FirstChar 0/LastChar 255/Widths[ 0 0 140 0 94 0 118 0 36 0 145 115 100 0 0 0 105 60 0 78 0 83 0 77 88 0 0 69 0 70 0 79 0 68 0 56 0 124 0 0 53 0 57 0 62 0 54 0 126 0 55 58 0 0 0 0 81 0 71 0 0 0 0 74 0 98 0 0 80 0 103 0 107 0 84 0 0 0 87 0 0 0 59 0 97 0 33 0 0 47 64 0 95 82 0 0 65 0 52 0 46 90 0 0 0 72 34 0 0 27 89 66 51 109 45 48 0 0 0 0 93 0 0 61 92 99 113 37 142 110 144 38 0 0 108 0 96 0 0 0 35 73 111 0 102 112 50 91 104 0 0 63 86 0 41 26 0 40 76 101 0 0 0 43 120 32 0 0 0 42 0 0 0 85 0 0 0 0 0 0 49 0 0 44 0 0 127 0 31 0 114 0 67 0 0 0 0 116 0 117 121 75 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 39 0 0 28 29 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 130 0 0 0] >> endobj 8 0 obj <> endobj 2 0 obj <>endobj xref 0 469 0000000000 65535 f 0000026848 00000 n 0000121005 00000 n 0000026708 00000 n 0000026896 00000 n 0000024988 00000 n 0000000015 00000 n 0000002536 00000 n 0000119768 00000 n 0000115835 00000 n 0000026965 00000 n 0000027305 00000 n 0000027608 00000 n 0000027673 00000 n 0000027948 00000 n 0000028012 00000 n 0000028226 00000 n 0000028291 00000 n 0000028567 00000 n 0000028631 00000 n 0000028913 00000 n 0000028978 00000 n 0000029043 00000 n 0000029108 00000 n 0000029438 00000 n 0000029652 00000 n 0000029900 00000 n 0000029965 00000 n 0000030029 00000 n 0000030326 00000 n 0000030390 00000 n 0000030647 00000 n 0000030711 00000 n 0000031046 00000 n 0000031110 00000 n 0000031174 00000 n 0000031429 00000 n 0000031690 00000 n 0000031754 00000 n 0000031996 00000 n 0000032060 00000 n 0000032345 00000 n 0000032409 00000 n 0000032652 00000 n 0000032716 00000 n 0000032976 00000 n 0000033040 00000 n 0000033327 00000 n 0000033392 00000 n 0000033673 00000 n 0000033938 00000 n 0000034002 00000 n 0000034264 00000 n 0000034328 00000 n 0000034556 00000 n 0000034620 00000 n 0000034913 00000 n 0000034977 00000 n 0000035318 00000 n 0000035383 00000 n 0000035643 00000 n 0000035707 00000 n 0000035771 00000 n 0000036073 00000 n 0000036302 00000 n 0000036505 00000 n 0000036781 00000 n 0000036845 00000 n 0000037127 00000 n 0000037191 00000 n 0000037498 00000 n 0000037736 00000 n 0000037967 00000 n 0000038227 00000 n 0000038291 00000 n 0000038550 00000 n 0000038614 00000 n 0000038854 00000 n 0000039140 00000 n 0000039204 00000 n 0000039519 00000 n 0000039584 00000 n 0000039852 00000 n 0000039917 00000 n 0000040198 00000 n 0000040262 00000 n 0000040508 00000 n 0000040772 00000 n 0000041035 00000 n 0000041099 00000 n 0000041344 00000 n 0000041577 00000 n 0000041818 00000 n 0000041882 00000 n 0000042148 00000 n 0000042212 00000 n 0000042424 00000 n 0000042488 00000 n 0000042719 00000 n 0000042962 00000 n 0000043026 00000 n 0000043091 00000 n 0000043360 00000 n 0000043425 00000 n 0000043490 00000 n 0000043721 00000 n 0000043990 00000 n 0000044055 00000 n 0000044274 00000 n 0000044339 00000 n 0000044588 00000 n 0000044653 00000 n 0000044718 00000 n 0000044953 00000 n 0000045186 00000 n 0000045401 00000 n 0000045466 00000 n 0000045531 00000 n 0000045792 00000 n 0000045987 00000 n 0000046052 00000 n 0000046117 00000 n 0000046182 00000 n 0000046247 00000 n 0000046313 00000 n 0000046378 00000 n 0000046443 00000 n 0000046705 00000 n 0000047006 00000 n 0000047245 00000 n 0000047490 00000 n 0000047555 00000 n 0000047770 00000 n 0000048031 00000 n 0000048096 00000 n 0000048161 00000 n 0000048226 00000 n 0000048292 00000 n 0000048357 00000 n 0000048423 00000 n 0000048489 00000 n 0000048555 00000 n 0000048620 00000 n 0000048801 00000 n 0000049039 00000 n 0000049105 00000 n 0000049358 00000 n 0000049423 00000 n 0000049734 00000 n 0000049932 00000 n 0000050171 00000 n 0000050236 00000 n 0000050301 00000 n 0000050367 00000 n 0000050599 00000 n 0000050665 00000 n 0000050731 00000 n 0000050796 00000 n 0000050861 00000 n 0000050927 00000 n 0000051181 00000 n 0000051426 00000 n 0000051491 00000 n 0000051556 00000 n 0000051770 00000 n 0000051835 00000 n 0000051900 00000 n 0000052178 00000 n 0000052243 00000 n 0000052308 00000 n 0000052374 00000 n 0000052662 00000 n 0000052906 00000 n 0000053078 00000 n 0000053143 00000 n 0000053209 00000 n 0000053274 00000 n 0000053521 00000 n 0000053759 00000 n 0000054011 00000 n 0000054076 00000 n 0000054313 00000 n 0000054576 00000 n 0000054862 00000 n 0000054927 00000 n 0000055175 00000 n 0000055430 00000 n 0000055693 00000 n 0000055930 00000 n 0000056151 00000 n 0000056319 00000 n 0000056384 00000 n 0000056689 00000 n 0000056943 00000 n 0000057008 00000 n 0000057268 00000 n 0000057509 00000 n 0000057575 00000 n 0000057782 00000 n 0000057847 00000 n 0000058063 00000 n 0000058129 00000 n 0000058332 00000 n 0000058397 00000 n 0000058699 00000 n 0000058917 00000 n 0000059146 00000 n 0000059389 00000 n 0000059455 00000 n 0000059752 00000 n 0000059818 00000 n 0000059884 00000 n 0000059949 00000 n 0000060148 00000 n 0000060383 00000 n 0000060617 00000 n 0000060865 00000 n 0000061062 00000 n 0000061319 00000 n 0000061555 00000 n 0000061777 00000 n 0000061974 00000 n 0000062197 00000 n 0000062476 00000 n 0000062725 00000 n 0000062976 00000 n 0000063144 00000 n 0000063352 00000 n 0000063560 00000 n 0000063812 00000 n 0000064043 00000 n 0000064274 00000 n 0000064509 00000 n 0000064723 00000 n 0000064788 00000 n 0000065037 00000 n 0000065246 00000 n 0000065311 00000 n 0000065376 00000 n 0000065629 00000 n 0000065867 00000 n 0000066048 00000 n 0000066267 00000 n 0000066298 00000 n 0000025158 00000 n 0000002556 00000 n 0000004107 00000 n 0000066328 00000 n 0000066590 00000 n 0000066873 00000 n 0000067157 00000 n 0000067410 00000 n 0000067683 00000 n 0000067911 00000 n 0000068242 00000 n 0000068509 00000 n 0000068774 00000 n 0000069011 00000 n 0000069326 00000 n 0000069707 00000 n 0000069989 00000 n 0000070292 00000 n 0000070600 00000 n 0000070837 00000 n 0000071090 00000 n 0000071371 00000 n 0000071614 00000 n 0000071908 00000 n 0000071974 00000 n 0000072228 00000 n 0000072458 00000 n 0000111938 00000 n 0000072754 00000 n 0000072951 00000 n 0000073189 00000 n 0000073370 00000 n 0000073611 00000 n 0000073907 00000 n 0000074149 00000 n 0000074432 00000 n 0000074688 00000 n 0000074952 00000 n 0000075198 00000 n 0000075433 00000 n 0000075667 00000 n 0000075841 00000 n 0000025313 00000 n 0000004129 00000 n 0000006317 00000 n 0000075881 00000 n 0000075947 00000 n 0000076192 00000 n 0000076438 00000 n 0000076504 00000 n 0000076751 00000 n 0000077022 00000 n 0000077265 00000 n 0000077331 00000 n 0000077594 00000 n 0000077851 00000 n 0000078107 00000 n 0000078333 00000 n 0000078590 00000 n 0000078850 00000 n 0000079094 00000 n 0000079294 00000 n 0000079360 00000 n 0000025468 00000 n 0000006339 00000 n 0000008924 00000 n 0000079400 00000 n 0000079466 00000 n 0000079721 00000 n 0000079787 00000 n 0000080023 00000 n 0000080362 00000 n 0000080708 00000 n 0000081018 00000 n 0000081316 00000 n 0000081612 00000 n 0000082007 00000 n 0000082289 00000 n 0000082642 00000 n 0000082819 00000 n 0000083035 00000 n 0000083252 00000 n 0000083551 00000 n 0000083740 00000 n 0000083969 00000 n 0000084243 00000 n 0000084502 00000 n 0000084713 00000 n 0000084952 00000 n 0000085177 00000 n 0000085441 00000 n 0000085696 00000 n 0000085968 00000 n 0000086247 00000 n 0000086492 00000 n 0000086783 00000 n 0000087004 00000 n 0000087279 00000 n 0000087547 00000 n 0000087814 00000 n 0000088064 00000 n 0000088311 00000 n 0000025623 00000 n 0000008946 00000 n 0000011803 00000 n 0000088351 00000 n 0000088628 00000 n 0000088886 00000 n 0000089122 00000 n 0000089347 00000 n 0000089658 00000 n 0000089921 00000 n 0000090183 00000 n 0000090436 00000 n 0000090666 00000 n 0000090940 00000 n 0000091202 00000 n 0000091438 00000 n 0000091657 00000 n 0000091915 00000 n 0000092236 00000 n 0000092498 00000 n 0000092669 00000 n 0000092932 00000 n 0000093178 00000 n 0000093506 00000 n 0000093572 00000 n 0000093842 00000 n 0000025778 00000 n 0000011825 00000 n 0000014475 00000 n 0000093882 00000 n 0000094143 00000 n 0000094209 00000 n 0000094466 00000 n 0000094800 00000 n 0000095086 00000 n 0000095152 00000 n 0000095485 00000 n 0000095551 00000 n 0000095826 00000 n 0000096128 00000 n 0000025933 00000 n 0000014497 00000 n 0000017180 00000 n 0000096168 00000 n 0000096414 00000 n 0000096636 00000 n 0000096702 00000 n 0000096996 00000 n 0000097281 00000 n 0000097575 00000 n 0000097830 00000 n 0000098060 00000 n 0000098378 00000 n 0000098661 00000 n 0000098900 00000 n 0000026088 00000 n 0000017202 00000 n 0000020041 00000 n 0000098940 00000 n 0000099196 00000 n 0000099419 00000 n 0000099698 00000 n 0000099961 00000 n 0000100256 00000 n 0000026243 00000 n 0000020063 00000 n 0000022189 00000 n 0000100296 00000 n 0000100559 00000 n 0000100625 00000 n 0000100912 00000 n 0000101109 00000 n 0000101307 00000 n 0000101373 00000 n 0000101650 00000 n 0000101889 00000 n 0000102151 00000 n 0000102431 00000 n 0000102471 00000 n 0000026398 00000 n 0000022211 00000 n 0000023064 00000 n 0000102796 00000 n 0000102836 00000 n 0000026553 00000 n 0000023085 00000 n 0000024966 00000 n 0000103096 00000 n 0000103344 00000 n 0000103593 00000 n 0000103825 00000 n 0000104075 00000 n 0000104338 00000 n 0000104553 00000 n 0000104802 00000 n 0000105073 00000 n 0000105370 00000 n 0000105639 00000 n 0000105872 00000 n 0000106132 00000 n 0000106372 00000 n 0000106711 00000 n 0000106980 00000 n 0000107277 00000 n 0000107559 00000 n 0000107834 00000 n 0000108101 00000 n 0000108397 00000 n 0000108654 00000 n 0000108834 00000 n 0000109116 00000 n 0000109376 00000 n 0000109617 00000 n 0000109789 00000 n 0000109960 00000 n 0000110128 00000 n 0000110330 00000 n 0000110626 00000 n 0000110889 00000 n 0000111160 00000 n 0000111424 00000 n 0000111700 00000 n 0000111898 00000 n trailer << /Size 469 /Root 1 0 R /Info 2 0 R >> startxref 121055 %%EOF iterate-20160825-darcs/doc/tex/iterate-bare.tex0000644000000000000000000004526612757566717017377 0ustar0000000000000000\documentclass[12pt]{article} \newcommand{\lisp}{\tt} \newcommand{\iter}{{\lisp iterate}} \newcommand{\Iter}{{\lisp Iterate}} \newcommand{\Do}{{\lisp do}} \newcommand{\Doing}{{\lisp doing}} \newcommand{\looP}{{\lisp loop}} \newcommand{\LooP}{{\lisp Loop}} \newcommand{\setf}{{\lisp setf}} \newcommand{\iman}{{\em The Iterate Manual\/}} \begin{document} \title{Don't Loop, Iterate} \author{Jonathan Amsterdam} \maketitle \section{Introduction} Above all the wonders of Lisp's pantheon stand its metalinguistic tools; by their grace have Lisp's acolytes been liberated from the rigid asceticism of lesser faiths. Thanks to Macro and kin, the jolly, complacent Lisp hacker can gaze through a fragrant cloud of setfs and defstructs at the emaciated unfortunates below, scraping out their meager code in inflexible notation, and sneer superciliously. It's a good feeling. But all's not joy in Consville. For---I beg your pardon, but---there really is no good way to {\em iterate\/} in Lisp. Now, some are happy to map their way about, whether for real with {\lisp mapcar} and friends, or with the make-believe of Series; others are so satisfied with \Do\ it's a wonder they're not C hackers.\footnote{Hey, don't get mad---I'll be much more polite later, when the real paper starts.} Still others have gotten by with \looP, but are getting tired of looking up the syntax in the manual over and over again. And in the elegant schemes of some, only tail recursion and lambdas figure. But that still leaves a sizeable majority of folk---well, me, at least---who would simply like to {\em iterate,} thank you, but in a way that provides nice abstractions, is extensible, and looks like honest-to-God Lisp. In what follows I describe a macro package, called \iter, that provides the power and convenient abstractions of \looP\ but in a more syntactically palatable way. \iter\ also has many features that \looP\ lacks, like generators and better support for nested loops. \iter\ generates inline code, so it's more efficient than using the higher-order function approach. And \iter\ is also extensible---it's easy to add new clauses to its vocabulary in order to express new patterns of iteration in a convenient way. \iter\ is fully documented in AI Lab Memo No. 1236, \iman. \section{More about \Iter} A Common Lisp programmer who wonders what's lacking with present-day iteration features would do well to consider \setf. Of course, \setf\ doesn't iterate, but it has some other nice properties. It's easy to use, for one thing. It's extensible---you can define new \setf\ methods very easily, so that \setf\ will work with new forms. \setf\ is also efficient, turning into code that's as good as anyone could write by hand. Arguably, \setf\ provides a nice abstraction: it allows you to view value-returning forms, like {\lisp (car ...)} or {\lisp (get ...)} as locations that can be stored into. Finally and most obviously, \setf\ {\em looks\/} like Lisp; it's got a syntax right out of {\lisp setq}. \iter\ attempts to provide all of these properties. Here is a simple use of \iter\ that returns all the elements of {\lisp num-list} that are greater than three: \pagebreak[4] \begin{verbatim} (iterate (for el in num-list) (when (> el 3) (collect el))) \end{verbatim} An \iter\ form consists of the symbol \iter\ followed by some Lisp forms. Any legal Lisp form is allowed, as well as certain forms that \iter\ treats specially, called {\em clauses}. {\lisp for...in} and {\lisp collect} are the two clauses in the above example. An \iter\ clause can appear anywhere a Lisp form can appear; \iter\ walks its body, looking inside every form, processing \iter\ clauses when it finds them. It even expands macros, so you can write macros that contain \iter\ clauses. Almost all clauses use the syntax of function keyword-argument lists: alternating keywords and arguments. \iter\ keywords don't require a preceding colon, but you can use one if you like. \iter\ provides many convenient iteration abstractions, most of them familiar to \looP\ users. Iteration-driving clauses (those beginning with {\lisp for}) can iterate over numbers, lists, arrays, hashtables, packages and files. There are clauses for collecting values into a list, summing and counting, maximizing, finding maximal elements, and various other things. Here are a few examples, for extra flavor. \pagebreak[2] To sum a list of numbers: \begin{verbatim} (iterate (for i in list) (sum i)) \end{verbatim} \pagebreak[2] To find the length of the shortest element in a list: \begin{verbatim} (iterate (for el in list) (minimize (length el))) \end{verbatim} \pagebreak[2] To find the shortest element in a list: \begin{verbatim} (iterate (for el in list) (finding el minimizing (length el))) \end{verbatim} \pagebreak[2] To return {\lisp t} only if every other element of a list is odd: \begin{verbatim} (iterate (for els on list by #'cddr) (always (oddp (car els)))) \end{verbatim} \pagebreak[2] To split an association list into two separate lists (this example uses \iter's ability to do destructuring): \begin{verbatim} (iterate (for (key . item) in alist) (collect key into keys) (collect item into items) (finally (return (values keys items)))) \end{verbatim} \section{Comparisons With Other Iteration Methods} As with any aspect of coding, how to iterate is a matter of taste. I do not wish to dictate taste or even to suggest that \iter\ is a ``better'' way to iterate than other methods. I would, however, like to examine the options, and explain why I prefer \iter\ to its competitors. \subsection{\Do, {\lisp dotimes} and {\lisp dolist}} The \Do\ form has long been a Lisp iteration staple. It provides for binding of iteration variables, an end-test, and a body of arbitrary code. It can be a bit cumbersome for simple applications, but the most common special cases---iterating over the integers from zero and over the members of a list---appear more conveniently as {\lisp dotimes} and {\lisp dolist}. \Do's major problem is that it provides no abstraction. For example, collection is typically handled by binding a variable to {\lisp nil}, pushing elements onto the variable, and {\lisp nreverse}ing the result before returning it. Such a common iteration pattern should be easier to write. (It is, using {\lisp mapcar}---but see below.) Another problem with \Do, for me at least, is that it's hard to read. The crucial end-test is buried between the bindings and the body, marked off only by an extra set of parens (and some indentation). It is also unclear, until after a moment of recollection, whether the end-test has the sense of a ``while'' or an ``until.'' Despite its flaws, \Do\ is superior to the iteration facilities of every other major programming language except CLU. Perhaps that is the reason many Lisp programmers don't mind using it. \subsection{Tail Recursion} % (check hyphenation) Tail-recursive implementations of loops, like those found in Scheme code \cite{SchemeBook}, are parsimonious and illuminating. They have the advantage of looking like recursion, hence unifying the notation for two different types of processes. For example, if only tail-recursion is used, a loop that operates on list elements from front to back looks very much like a recursion that operates on them from back to front. However, using tail-recursion exclusively can lead to cumbersome code and a proliferation of functions, especially when one would like to embed a loop inside a function. Tail-recursion also provides no abstraction for iteration; in Scheme, that is typically done with higher-order functions. \subsection{Higher-order Functions} Lisp's age-old mapping functions, recently revamped for Common Lisp \cite{CLM}, are another favorite for iteration. They provide a pleasing abstraction, and it's easy to write new higher-order functions to express common iteration patterns. Common Lisp already comes with many such useful functions, for removing, searching, and performing reductions on lists. Another Common Lisp advantage is that these functions work on any sequence---vectors as well as lists. One problem with higher-order functions is that they are inefficient, requiring multiple calls on their argument function. While the the built-ins, like {\lisp map} and {\lisp mapcar}, can be open-coded, that cannot be so easily done for user-written functions. Also, using higher-order functions often results in the creation of intermediate sequences that could be avoided if the iteration were written out explicitly. The second problem with higher-order functions is very much a matter of personal taste. While higher-order functions are theoretically elegant, they are often cumbersome to read and write. The unpleasant sharp-quote required by Common Lisp is particularly annoying here, and even in Scheme, I find the presence of a lambda with its argument list visually distracting. Another problem is that it's difficult to express iteration of sequences of integers without creating such sequences explicitly as lists or arrays. One could resort to tail-recursion or {\lisp dotimes}---but then it becomes very messy to express double iterations where one driver is over integers. Multiple iteration is easy in \iter, as illustrated by the following example, which creates an alist of list elements and their positions: {\samepage \begin{verbatim} (iterate (for el in list) (for i from 0) (collect (cons el i))) \end{verbatim} } \subsection{Streams and Generators} For really heavy-duty iteration jobs, nothing less than a coroutine-like mechanism will do. Such mechanisms hide the state of the iteration behind a convenient abstraction. A {\em generator\/} is a procedure that returns the next element in the iteration each time it is called. A {\em stream\/} (in the terminology of \cite{SchemeBook}) is a data structure which represents the iteration, but which computes the next element only on demand. Generators and streams support a similar style of programming. Here, for example, is how you might enumerate the leaves of a tree (represented as a Lisp list with atoms at the leaves) using streams: \begin{verbatim} (defun tree-leaves (tree) (if (atom tree) (stream-cons tree empty-stream) (stream-append (tree-leaves (car tree)) (tree-leaves (cdr tree))))) \end{verbatim} Although {\lisp tree-leaves} looks like an ordinary recursion, it will only do enough work to find the first leaf before returning. The stream it returns can be accessed with {\lisp stream-car}, which will yield the (already computed) first leaf of the tree, or with {\lisp stream-cdr}, which will initiate computation of the next leaf. Such a computation would be cumbersome to write using \iter, or any of the other standard iteration constructs; in fact, it is not even technically speaking an iteration, if we confine that term to processes that take constant space and linear time. Streams, then, are definitely more powerful than standard iteration machinery. Unfortunately, streams are very expensive, since they must somehow save the state of the computation. Generators are typically cheaper, but are less powerful and still require at least a function call. So these powerful tools should be used only when necessary, and that is not very often; most of the time, ordinary iteration suffices. There is one aspect of generators that \iter\ can capture, and that is the ability to produce elements on demand. Say we wish to create an alist that pairs the non-null elements of a list with the positive integers. We saw above that it is easy to iterate over a list and a series of numbers simultaneously, but here we would like to do something a little different: we want to iterate over the list of elements, but only draw a number when we need one (namely, when a list element is non-null). The solution employs the \iter\ {\lisp generate} keyword in place of {\lisp for} and the special clause {\lisp next}: {\samepage \begin{verbatim} (iterate (for el in list) (generate i from 1) (if el (collect (cons el (next i))))) \end{verbatim} } Using {\lisp next} with any driver variable changes how that driver works. Instead of supplying its values one at a time on each iteration, the driver computes a value only when a {\lisp next} clause is executed. This ability to obtain values on demand greatly increases \iter's power. Here, {\lisp el} is set to the next element of the list on each iteration, as usual; but {\lisp i} is set only when {\lisp (next i)} is executed. \subsection{Series} Richard C. Waters has developed a very elegant notation called Series which allows iteration to be expressed as sequence-mapping somewhat in the style of APL, but which compiles to efficient looping code \cite{Series}. My reasons for not using Series are, again, matters of taste. Like many elegant notations, Series can be somewhat cryptic. Understanding what a Series expression does can require some effort until one has mastered the idiom. And if you wish to share your code with others, they will have to learn Series as well. \iter\ suffers from this problem to some extent, but since the iteration metaphor it proposes is much more familiar to most programmers than that of Series, it is considerably easier to learn and read. \subsection{{\lisp Prog} and {\lisp Go}} Oh, don't be silly. \subsection{\LooP} \looP\ is the iteration construct most similar to \iter\ in appearance. \looP\ is a macro written originally for MacLisp and in widespread use \cite{Loop}. It has been adopted as part of Common Lisp. \looP\ provides high-level iteration with abstractions for collecting, summing, maximizing and so on. Recall our first \iter\ example: \pagebreak[2] \begin{verbatim} (iterate (for el in num-list) (when (> el 3) (collect el))) \end{verbatim} \pagebreak[2] Expressed with \looP, it would read n \begin{verbatim} (loop for el in list when (> el 3) collect el) \end{verbatim} The similarity between the two macros should immediately be apparent. Most of \iter's clauses were borrowed from \looP. But compared to \iter, \looP\ has a paucity of parens. Though touted as more readable than heavily-parenthesized code, \looP's Pascalish syntax creates several problems. First, many dyed-in-the-wool Lisp hackers simply find it ugly. Second, it requires learning the syntax of a whole new sublanguage. Third, the absence of parens makes it hard to parse, both by machine and, more importantly, by human. Fourth, one often has to consult the manual to recall lesser-used aspects of the strange syntax. Fifth, there is no good interface with the rest of Lisp, so \looP\ clauses cannot appear inside Lisp forms and macros cannot expand to pieces of \looP. And Sixth, pretty-printers and indenters that don't know about \looP\ will invariably display it wrongly. This is particularly a problem with program-editor indenters. A reasonably clever indenter, like that of Gnu Emacs, can indent nearly any normal Lisp form correctly, and can be easily customized for most new forms. But it can't at present handle \looP. The syntax of \iter\ was designed to keep parens to a minimum, but conform close enough to Lisp so as not to confuse code-display tools. Gnu Emacs indents \iter\ reasonably with no modifications. Indenting is a mere annoyance; \looP's lack of extensibility is a more serious problem. The original \looP\ was completely extensible, but the Symbolics version only provides for the definition of new iteration-driving clauses, and the Common Lisp specification does not have any extension mechanism. But extensibility is a boon. Consider first the problem of adding the elements of a list together, which can be accomplished with \iter\ by \pagebreak[3] \begin{verbatim} (iterate (for el in list) (sum el)) \end{verbatim} and in \looP\ with \begin{verbatim} (loop for el in list sum el) \end{verbatim} But now, say that you wished to compute the sum of the square roots of the elements. You could of course write, in either \looP\ or \iter, \begin{verbatim} (iterate (for el in list) (sum (sqrt el))) \end{verbatim} But perhaps you find yourself writing such loops often enough to make it worthwhile to create a new abstraction. There is nothing you can do in \looP, but in \iter\ you could simply write a macro: \begin{verbatim} (defmacro (sum-of-sqrts expr &optional into-var) `(sum (sqrt ,expr) into ,into-var)) \end{verbatim} {\lisp sum-of-sqrts} is a perfectly ordinary Lisp macro. Since \iter\ expands all macros and processes the results, {\lisp (sum-of-sqrts el)} will behave exactly as if we'd written {\lisp (sum (sqrt el))}. There's also a way to define macros that use \iter's clause syntax. It's fully documented in \iman. %Just to beat a dead horse, I'd like to point out that there's no way %to define {\lisp for...maximizing} in %\looP.\footnote{In fact, it was in part the frustration of knowing %that \looP\ could generate code to maximize a value, but could not be %easily altered to supply the element associated with that maximum, %that prompted me to write \iter.} \section{Implementation} A Common Lisp implementation of \iter\ has existed for well over a year. It runs under Lucid for HP 300's, Sun 3's and SPARCstations, and on Symbolics Lisp machines. See \iman\ for details. \section{Conclusion} Iteration is a matter of taste. I find \iter\ more palatable than other iteration constructs: it's more readable, more efficient than most, provides nice abstractions, and can be extended. If you're new to Lisp iteration, start with \iter---look before you \looP. If you're already using \looP\ and like the power that it offers, but have had enough of its syntax and inflexibility, then my advice to you is, don't \looP---\iter. \pagebreak \begin{flushleft} \bf Acknowledgements \end{flushleft} Thanks to David Clemens for many helpful suggestions and for the egregious pun near the end. Conversations with Richard Waters prompted me to add many improvements to \iter. Alan Bawden, Sundar Narasimhan, and Jerry Roylance also provided useful comments. David Clemens and Oren Etzioni shared with me the joys of beta-testing. \begin{thebibliography}{9} \bibitem{SchemeBook} Abelson, Harold and Gerald Jay Sussman. {\em Structure and Interpretation of Computer Programs.} Cambridge, MA: The MIT Press, 1985. \bibitem{Loop} ``The loop Iteration Macro.'' In {\em Symbolics Common Lisp---Language Concepts}, manual 2A of the Symbolics documentation, pp. 541--567. \bibitem{CLM} Steele, Guy L. {\em Common Lisp: The Language}. Bedford, MA: Digital Press, 1984. \bibitem{Series} Waters, Richard C. {\em Optimization of Series Expressions: Part I: User's Manual for the Series Macro Package}. MIT AI Lab Memo No. 1082. \end{thebibliography} \end{document} % arch-tag: "c0ff23d7-313c-11d8-abb9-000c76244c24" iterate-20160825-darcs/doc/tex/iterate-manual.tex0000644000000000000000000023377612757566717017750 0ustar0000000000000000% Fix ``.'' spacing in lists \documentstyle[12pt,aimemo]{article} \setlength{\textwidth}{6.0in} \setlength{\oddsidemargin}{0.25in} \setlength{\evensidemargin}{0.25in} \setlength{\topmargin}{0pt} \setlength{\headsep}{24pt} \setlength{\textheight}{8.5in} \let\origpar=\par % somehow, LaTex fucks with things so that the plain Tex \obeyspaces % doesn't work. This is the same, except we use an mbox containing % a space instead of just a space. \newcommand{\spc}{\mbox{ }} \newcommand{\tAb}{\mbox{ }} \def\obspaces{\catcode`\ =\active\catcode`\^^I=\active} {\obspaces \global\let =\spc\global\let^^I=\tAb} \newenvironment{program}{\medskip\samepage\tt\obeylines\obspaces}{\medskip} % use | for \tt \catcode`\|=13 \newif\ifvbar \def|{\ifvbar \endgroup\vbarfalse \else \begingroup\tt\vbartrue \fi} \newcommand{\lisp}{\tt} \newcommand{\iter}{|iterate|} \newcommand{\iterpg}{|iterate-pg|} \newcommand{\setf}{|setf|} \newcommand{\nil}{|nil|} \newcommand{\nonnil}{non-\nil} \newcommand{\opt}{{\lisp \&optional}} \newcommand{\yields}{$\Rightarrow$} \newbox\Dots \setbox\Dots=\hbox{\small ...} \renewcommand{\dots}{\copy\Dots} % Here's a way to define an environment which will treat all % paragraphs inside it in the same manner. It's, as near as I can % figure, the way that Latex does things. Using \everypar won't work; % apparently Latex resets that a lot. What you have to do is: at the % top of the file do \let\origpar=\par. In the % begin part of the environment, do the parshape (or whatever), then say % \def\par{{\origpar}}. The extra braces are necessary. That's all % you have to do; at the end of the environment things will return to % normal automatically. Why does this all work? I have no idea. % Another important thing: there should be a blank line (i.e. a \par) % between the end of the last paragraph and the \end{environment}. \newlength{\clindent} \setlength{\clindent}{0.5in} \newlength{\clparindent} \setlength{\clparindent}{\parindent} \newenvironment{clauses}{\advance\linewidth -\parindent \hangindent\clindent\relax \hangafter=0 \parindent=0pt \def\par{{\origpar}}}{} \newcommand{\cpar}{\hspace \clparindent} \newcommand{\startitem}{\bigskip\pagebreak[3]} \newcommand{\finishitem}{\smallskip} \newcommand{\clause}[1]{\startitem\Clause{#1}\finishitem} \newcommand{\Clause}[1]{\hbox{#1}} \newcommand{\clindex}[1]{\index{{\lisp #1}}} \newcommand{\clindexx}[2]{\index{{\lisp #1\dots #2}}} \newcommand{\clindexxx}[3]{\index{{\lisp #1\dots #2\dots #3}}} \newcommand{\clausex}[2]{\startitem\Clausex{#1}{#2}\finishitem} \newcommand{\Clausex}[2]{\Clause{|#1| #2}\clindex{#1}} \newcommand{\defvar}[1]{\startitem\deff{#1}{}{Variable}\finishitem} \newcommand{\defunexpvar}[1]{\startitem\deffnoindex{iterate::#1}{}{Variable} \lispindex{#1}\finishitem} \newcommand{\defun}[2]{\startitem\deff{#1}{#2}{Function}\finishitem} \newcommand{\defmacro}[2]{\startitem\deff{#1}{#2}{Macro}\finishitem} \newcommand{\defunx}[3]{\startitem\deffx{#1}{#2}{#3}{Function}\finishitem} \newcommand{\defmacrox}[3]{\startitem\deffx{#1}{#2}{#3}{Macro}\finishitem} \newcommand{\defunxx}[4]{\startitem\deffxx{#1}{#2}{#3}{#4}{Function}\finishitem} \newcommand{\defmacroxx}[4]{\startitem\deffxx{#1}{#2}{#3}{#4}{Macro}\finishitem} \newcommand{\deff}[3]{\deffnoindex{#1}{#2}{#3}\lispindex{#1}} \newcommand{\deffnoindex}[3]{\hbox to \hsize{{\tt #1} {\it #2}\hfill [{\it #3}]}} \newcommand{\deffx}[4]{\deff{#1}{#2}{#4}\moreargs{#1}{#3}} \newcommand{\deffxx}[5]{\deffx{#1}{#2}{#3}{#5}\moreargs{#1}{#4}} \newcommand{\moreargs}[2]{\hbox to \hsize{\phantom{\lisp #1} {\it #2}\hfill}} \newcommand{\lispindex}[1]{\index{{\lisp #1}}} \newenvironment{note}[1]{\pagebreak[2]\bigskip \hrule\smallskip\small {\setlength{\parindent}{0pt} \par{\bf #1:}}}{\smallskip\hrule\bigskip} \makeindex %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %\thispagestyle{empty} %\vspace*{2in} %\title{The |Iterate| Manual} %\author{Jonathan Amsterdam} %\maketitle %\thispagestyle{empty} %\begin{center} %\Large *** DRAFT *** %\end{center} %This manual is in beta-test. It will become an AI Memo in a couple of %months. I would appreciate any comments or %corrections. You can reach me at email address |jba@ai.ai.mit.edu|. \begin{document} \def\writtenby{Jonathan Amsterdam} \def\contractno{This report describes research done at the Artificial Intelligence Laboratory of the Massachusetts Institute of Technology. Support for the laboratory's artificial intelligence research is provided in part by the Advanced Research Projects Agency of the Department of Defense under Office of Naval Research contract N00014-85-K-0124.} \AIMEMO{1236}{\Large The Iterate Manual \\[1in]} {This is the manual for version 1.4 of \iter, a powerful iteration macro for Common Lisp. \iter\ is similar to {\tt loop} but provides numerous additional features, is well integrated with Lisp, and is extensible. \vfill } % use ~ for \em \catcode`\~=13 \newif\ifem \def~{\ifem \/\endgroup\emfalse \else \begingroup\em\emtrue \fi} %\pagebreak %\setcounter{page}{1} %\thispagestyle{empty} \tableofcontents \pagebreak \pagestyle{headings} \section{Introduction} \begin{sloppypar} This manual describes \iter, a powerful iteration facility for Common Lisp. \iter\ provides abstractions for many common iteration patterns and allows for the definition of additional patterns. \iter\ is a macro that expands into ordinary Lisp at compile-time, so it is more efficient than higher-order functions like |map| and |reduce.| While it is similar to |loop|, \iter\ offers a more Lisp-like syntax and enhanced extensibility. (For a more complete comparison of \iter\ with other iteration constructs, see MIT AI Lab Working Paper No. 324, ~Don't Loop, Iterate.~) \end{sloppypar} An \iter\ form consists of the symbol |iter|\footnote{You can also use |iterate|, but |iter| is preferred because it avoids potential conflicts with possible future additions to Common Lisp, and because it saves horizontal space when writing code.} followed by one or more forms, some of which may be \iter\ ~clauses.~ Here is a simple example of \iter\ which collects the numbers from 1 to 10 into a list, and returns the list. The return value is shown following the arrow. \begin{program} (iter (for i from 1 to 10) (collect i)) \yields (1 2 3 4 5 6 7 8 9 10) \end{program} This form contains two clauses: a |for| clause that steps the variable |i| over the integers from 1 to 10, and a |collect| clause that accumulates its argument into a list. With a few exceptions, all \iter\ clauses have the same format: alternating symbols (called ~keywords~) and expressions (called ~arguments~). The syntax and terminology are those of Common Lisp's keyword lambda lists. One difference is that \iter's keywords do not have to begin with a colon---though they may, except for the first symbol of a clause. So you can also write |(for i :from 1 :to 10)| if you prefer. Any Lisp form can appear in the body of an \iter, where it will have its usual meaning. \iter\ walks the entire body, expanding macros, and recognizing clauses at any level. This example collects all the odd numbers in a list: \begin{program} (iter (for el in list) (if (and (numberp el) (oddp el)) (collect el))) \end{program} There are clauses for iterating over numbers, lists, arrays and other objects, and for collecting, summing, counting, maximizing and other useful operations. \iter\ also supports the creation of new variable bindings, stepping over multiple sequences at once, destructuring, and compiler declarations of variable types. The following example illustrates some of these features: \begin{program} (iter (for (key . item) in alist) (for i from 0) (declare (fixnum i)) (collect (cons i key))) \end{program} This loop takes the keys of an alist and returns a new alist associating the keys with their positions in the original list. The compiler declaration for |i| will appear in the generated code in the appropriate place. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \section{Clauses} Most of \iter's clauses will be familiar to |loop| programmers. (|loop| is an iteration macro that has been incorporated into Common Lisp. Seen Guy Steele's {\em Common Lisp, 2nd Edition}.) In nearly all cases they behave the same as their |loop| counterparts, so a |loop| user can switch to \iter\ with little pain (and much gain). All clauses with the standard keyword-argument syntax consist of two parts: a ~required~ part, containing keywords that must be present and in the right order; and an ~optional~ part, containing keywords that may be omitted and, if present, may occur in any order. In the descriptions below, the parts are separated by the Lisp lambda-list keyword \opt. \subsection{Drivers} An iteration-driving clause conceptually causes the iteration to go forward. Driver clauses in \iter\ allow iteration over numbers, lists, vectors, hashtables, packages, files and streams. Iteration-driving clauses must appear at the top level of an \iter\ form; they cannot be nested inside another clause. The driver variable is updated at the point where the driver clause occurs. Before the clause is executed for the first time, the value of the variable is undefined. %Also, regardless of where the driver clause %appears in the body, the driver variable is stepped at the top of the %loop; hence it is stylistically preferable, though %not required, to place driver clauses at the beginning of the \iter. Multiple drivers may appear in a single \iter\ form, in which case all of the driver variables are updated each time through the loop, in the order in which the clauses appear. The first driver to terminate will terminate the entire loop. In all cases, the value of the driver variable on exit from the loop, including within the epilogue code (see the |finally| clause), is undefined. All the parameters of a driver clause are evaluated once, before the loop begins. Hence it is not possible to change the bounds or other properties of an iteration by side-effect from within the loop. With one exception, driver clauses begin with the word |for| (or the synonym |as|) and mention an iteration variable, which is given a binding within the \iter\ form. The exception is |repeat|, which just executes a loop a specified number of times: \begin{clauses} \clausex{repeat}{~n~} Repeats the loop ~n~ times. For example: \begin{program} (iter (repeat 100) (print "I will not talk in class.")) \end{program} \cpar If $n \leq 0$, the loop will never be executed. If ~n~ is not an integer, the actual number of executions will be $\lceil n \rceil$. \end{clauses} \pagebreak[3] \subsubsection{Numerical Iteration} \begin{clauses} \clausex{for}{~var~ |\&sequence|} The general form for iterating over a sequence of numbers requires a variable and, optionally, one or more keywords that provide the bounds and step size of the iteration. The |\&sequence| lambda-list keyword is a shorthand for these sequence keywords. They are: |from|, |upfrom|, |downfrom|, |to|, |downto|, |above|, |below| and |by|. |from| provides the starting value for ~var~ and defaults to zero. |to| provides a final value and implies that the successive values of ~var~ will be increasing; |downto| implies that they will be decreasing. The loop terminates when ~var~ passes the final value (i.e. becomes smaller or larger than it, depending on the direction of iteration); in other words, the loop body will never be executed for values of ~var~ past the final value. |below| and |above| are similar to |to| and |downto|, except that the loop terminates when ~var~ equals or passes the final value. \cpar If no final value is specified, the variable will be stepped forever. Using |from| or |upfrom| will result in increasing values, while |downfrom| will give decreasing values. \cpar On each iteration, ~var~ is incremented or decremented by the value of the sequence keyword |by|, which defaults to 1. It should always be a positive number, even for downward iterations. \cpar In the following examples, the sequence of numbers generated is shown next to the clause. \begin{program} (for i upfrom 0) \yields\ 0 1 2 \ldots (for i from 5) \yields\ 5 6 7 \ldots ; either from or upfrom is okay (for i downfrom 0) \yields\ 0 -1 -2 \ldots (for i from 1 to 3) \yields\ 1 2 3 (for i from 1 below 3) \yields\ 1 2 (for i from 1 to 3 by 2) \yields\ 1 3 (for i from 1 below 3 by 2) \yields\ 1 (for i from 5 downto 3) \yields\ 5 4 3 \end{program} \end{clauses} \subsubsection{Sequence Iteration} There are a number of clauses for iterating over sequences. In all of them, the argument following |for| may be a list instead of a symbol, in which case destructuring is performed. See section \ref{destructuring}. \begin{clauses} \clause{|for| ~var~ |in| ~list~ \opt\ |by| ~step-function~} \clindexx{for}{in} ~var~ is set to successive elements of list. ~step-function,~ which defaults to |cdr|, is used to obtain the next sublist. \clause{|for| ~var~ |on| ~list~ \opt\ |by| ~step-function~} \clindexx{for}{on} ~var~ is set to successive sublists of list. ~step-function~ (default |cdr|) is used as in |for\dots in|. \end{clauses} \medskip These two clauses use |atom| to test for the end of a list. Hence, given a list whose final |cdr| is not \nil, they will silently ignore the last |cdr|. Other choices are |endp|, which would signal an error, and |null|, which would probably result in an error somewhere else. If you wish to use an end-test other than |atom|, set the variable |iterate::*list-end-test*|\lispindex{*list-end-test*} to the name of the desired function. \begin{clauses} \clause{|for| ~var~ |in-vector| ~vector~ |\&sequence|} \clindexx{for}{in-vector} ~var~ takes on successive elements from ~vector.~ The vector's fill-pointer is observed. Here and in subsequent clauses, the |\&sequence| keywords include |with-index|, which takes a symbol as argument and uses it for the index variable instead of an internally generated symbol. The other |\&sequence| keywords behave as in numerical iteration, except that the default iteration bounds are the bounds of the vector. E.g. in |(for i in-vector v downto 3)|, |i| will start off being bound to the last element in |v|, and will be set to preceding elements down to and including the element with index 3. \clause{|for| ~var~ |in-sequence| ~seq~ |\&sequence|} \clindexx{for}{in-sequence} This uses Common Lisp's generalized sequence functions, |elt| and |length|, to obtain elements and determine the length of ~seq.~ Hence it will work for any sequence, including lists, and will observe the fill-pointers of vectors. \clause{|for| ~var~ |in-string| ~string~ |\&sequence|} \clindexx{for}{in-string} ~var~ is set to successive characters of ~string.~ \startitem \Clause{|for| ~var~ |index-of-vector| ~vector~ |\&sequence|} \clindexx{for}{index-of-vector} \Clause{|for| ~var~ |index-of-sequence| ~sequence~ |\&sequence|} \clindexx{for}{index-of-sequence} \Clause{|for| ~var~ |index-of-string| ~string~ |\&sequence|} \clindexx{for}{index-of-string} \finishitem ~var~ is set to successive indices of the sequence. These clauses avoid the overhead of accessing the sequence elements for those applications where they do not need to be examined, or are examined rarely. They admit all the optional keywords of the other sequence drivers except the (redundant) |with-index| keyword. \clause{|for| ~(key value)~ |in-hashtable| ~table~} \clindexx{for}{in-hashtable} ~key~ and ~value,~ which must appear as shown in a list and may be destructuring templates, are set to the keys and values of ~table~. If ~key~ is |nil|, then the hashtable's keys will be ignored; similarly for ~value~. The order in which elements of ~table~ will be retrieved is unpredictable. \clause{|for| ~var~ |in-package| ~package~ \opt\ |external-only| ~ext~} \clindexx{for}{in-package} Iterates over all the symbols in ~package,~ or over only the external symbols if ~ext~ is specified and non-|nil|. ~ext~ is not evaluated. The same symbol may appear more than once. \clause{|for| ~var~ |in-packages| ~packages~ \opt\ |having-access| ~symbol-types~} \clindexx{for}{in-packages} Iterates over all the symbols from the list of packages denoted by the descriptor ~packages~ and having accessibility (or visibility) given by ~symbol-types~. This defaults to the list |(:external :internal :inherited)| and is not evaluated. ~var~ must be a list of up to three variables: in each iteration, these will be set to a symbol, its access-type and package (as per |with-package-iterator| in ANSI-CL). The same symbol may appear more than once. \end{clauses} \begin{clauses} \clause{|for| ~var~ |in-file| ~name~ \opt\ |using| ~reader~} \clindexx{for}{in-file} Opens the file ~name~ (which may be a string or pathname) for input, and iterates over its contents. ~reader~ defaults to |read|, so by default ~var~ will be bound to the successive forms in the file. The \iter\ body is wrapped in an unwind-protect to ensure that the file is closed no matter how the \iter\ is exited. \clause{|for| ~var~ |in-stream| ~stream~ \opt\ |using| ~reader~} \clindexx{for}{in-stream} Like |for\dots in-file|, except that ~stream~ should be an existing stream object that supports input operations. \end{clauses} \subsubsection{Generalized Drivers} These are primarily useful for writing drivers that can also be used as generators (see section \ref{generators}, below). \begin{clauses} \clause{|for| ~var~ |next| ~expr~} \clindexx{for}{next} ~var~ is set to ~expr~ each time through the loop. Destructuring is performed. When the clause is used as a generator, ~expr~ is the code that is executed when |(next ~var~)| is encountered (see section \ref{generators}, below). ~expr~ should compute the first value for ~var~, as well as all subsequent values, and is responsible for terminating the loop. For compatibility with future versions of \iter, this termination should be done with |terminate|\clindex{terminate}, which can be considered a synonym for |finish| (see section \ref{control-flow}). \cpar As an example, the following clauses are equivalent to |(for i from 1 to 10)|: \begin{program} (initially (setq i 0)) (for i next (if (> i 10) (terminate) (incf i))) \end{program} \clause{|for| ~var~ |do-next| ~form~} \clindexx{for}{do-next} ~form~ is evaluated each time through the loop. Its value is ~not~ set to ~var~; that is ~form's~ job. ~var~ is only present so that \iter\ knows it is a driver variable. \linebreak |(for ~var~ next ~expr~)| is equivalent to |(for ~var~ do-next (dsetq ~var~ ~expr~))|. (See section \ref{destructuring} for an explanation of |dsetq|.) \end{clauses} \subsubsection{Generators} \label{generators} In all of the above clauses, the driver variable is updated on each iteration. Sometimes it is desirable to have greater control over updating. For instance, consider the problem of associating numbers, in increasing order and with no gaps, with the \nonnil\ elements of a list. One obvious first pass at writing this is: \begin{program} (iter (for el in list) (for i upfrom 1) (if el (collect (cons el i)))) \end{program} But on the list |(a b nil c)| this produces |((a . 1) (b . 2) (c . 4))| instead of the desired |((a . 1) (b . 2) (c . 3))|. The problem is that |i| is incremented each time through the loop, even when |el| is |nil|. The problem could be solved elegantly if we could step |i| only when we wished to. This can be accomplished for any \iter\ driver by writing |generate| (or its synonym |generating|) instead of |for|. Doing so produces a ~generator~---a driver whose values are yielded explicitly. To obtain the next value of a generator variable ~v~, write \linebreak |(next ~v~)|. The value of a |next| form is the next value of ~v~, as determined by its associated driver clause. |next| also has the side-effect of updating ~v~ to that value. If there is no next value, |next| will terminate the loop, just as with a normal driver. Using generators, we can now write our example like this: \begin{program} (iter (for el in list) (generate i upfrom 1) (if el (collect (cons el (next i))))) \end{program} Now |i| is updated only when |(next i)| is executed, and this occurs only when |el| is \nonnil. To better understand the relationship between ordinary drivers and generators, observe that we can rewrite an ordinary driver using its generator form immediately followed by |next|, as this example shows: \begin{program} (iter (generating i from 1 to 10) (next i) ...) \end{program} Provided that the loop body contains no |(next i)| forms, this will behave just as if we had written |(for i from 1 to 10)|. We can still refer to a driver variable ~v~ without using |next|; in this case, its value is that given to it by the last evaluation of |(next ~v~)|. Before |(next ~v~)| has been called the first time, the value of ~v~ is undefined. This semantics is more flexible than one in which ~v~ begins the loop bound to its first value and calls of |next| supply subsequent values, because it means the loop will not terminate too soon if the generator's sequence is empty. For instance, consider the following code, which tags \nonnil\ elements of a list using a list of tags, and also counts the null elements. (We assume there are at least as many tags as \nonnil\ elements.) \begin{program} (let* ((counter 0) (tagged-list (iter (for el in list) (generating tag in tag-list) (if (null el) (incf counter) (collect (cons el (next tag))))))) ...) \end{program} It may be that there are just as many tags as non-null elements of |list|. If all the elements of |list| are null, we still want the counting to proceed, even though |tag-list| is \nil. If |tag| had to be assigned its first value before the loop begins, we would have had to terminate the loop before the first iteration, since when |tag-list| is \nil, |tag| has no first value. With the existing semantics, however, |(next tag)| will never execute, so the iteration will cover all the elements of |list|. When the ``variable'' of a driver clause is actually a destructuring template containing several variables, all the variables are eligible for use with |next|. As before, |(next ~v~)| evaluates to ~v's~ next value; but the effect is to update all of the template's variables. For instance, the following code will return the list |(a 2 c)|. \begin{program} (iter (generating (key . item) in '((a . 1) (b . 2) (c . 3))) (collect (next key)) (collect (next item))) \end{program} Only driver clauses with variables can be made into generators. This includes all clauses mentioned so far except for |repeat|. It does ~not~ include |for\dots previous|, |for\dots =|, |for\dots initially\dots then| or |for\dots first\dots then| (see below). \subsubsection{Previous Values of Driver Variables} Often one would like to access the value of a variable on a previous iteration. \iter\ provides a special clause for accomplishing this. \begin{clauses} \clause{|for| ~pvar~ |previous| ~var~ \opt\ |initially| ~init~ |back| ~n~} \clindexx{for}{previous} Sets ~pvar~ to the previous value of ~var,~ which should be a driver variable, a variable from another |for\dots previous| clause, or a variable established by a |for\dots =|, |for\dots initially\dots then| or |for\dots first\dots then| clause (see section \ref{setting}). Initially, ~pvar~ is given the value ~init~ (which defaults to \nil). The ~init~ expression will be moved outside the loop body, so it should not depend on anything computed within the loop. ~pvar~ retains the value of ~init~ until ~var~ is set to its second value, at which point ~pvar~ is set to ~var's~ first value; and so on. \cpar The argument ~n~ to |back| must be a constant, positive integer, and defaults to 1. It determines how many iterations back ~pvar~ should track ~var~. For example, when ~n~ is 2, then ~pvar~ will be assigned ~var's~ first value when ~var~ is set to its third value. \cpar A |for\dots previous| clause may occur after or before its associated driver clause. |for\dots previous| works with generators as well as ordinary drivers. \pagebreak[3] \cpar Example: \begin{program} (iter (for el in '(1 2 3 4)) (for p-el previous el) (for pp-el previous p-el initially 0) (collect pp-el)) \end{program} This evaluates to |(0 0 1 2)|. It could have been written more economically as \begin{program} (iter (for el in '(1 2 3 4)) (for pp-el previous el back 2 initially 0) (collect pp-el)) \end{program} \end{clauses} \subsection{Variable Binding and Setting} \label{setting} Several clauses exist for establishing new variable bindings or for setting variables in the loop. They all support destructuring. \begin{clauses} \clausex{with}{~var~ \opt\ |=| ~value~} Causes ~var~ to be bound to value before the loop body is entered. If ~value~ is not supplied, ~var~ assumes a default binding, which will be \nil\ in the absence of declarations. Also, if ~value~ is not supplied, no destructuring is performed; instead, ~var~ may be a list of symbols, all of which are given default bindings. If ~value~ is supplied, ~var~ is bound to it, with destructuring. \cpar Because |with| creates bindings whose scope includes the entire \iter\ form, it is good style to put all |with| clauses at the beginning. \cpar Successive occurrences of |with| result in sequential bindings (as with |let*|). There is no way to obtain parallel bindings; see section \ref{bindings} for a rationale. \clause{|for| ~var~ |=| ~expr~} \clindexx{for}{=} On each iteration, ~expr~ is evaluated and ~var~ is set to its value. \cpar This clause may appear to do the same thing as |for\dots next|. In fact, they are quite different. |for\dots =| provides only three services: it sets up a binding for ~var~, sets it to ~expr~ on each iteration, and makes it possible to use |for\dots previous| with ~var~. |for\dots next| provides these services in addition to the ability to turn the driver into a generator. %Also, the code which sets ~var~ appears in the loop body in the same %place as the |for\dots =| clause; the code for |for\dots next| appears %at the top of the loop, as with other drivers (except when being used %as a generator). \clause{|for| ~var~ |initially| ~init-expr~ |then| ~then-expr~} \clindexxx{for}{initially}{then} Before the loop begins, ~var~ is set to ~init-expr;~ on all iterations after the first it is set to ~then-expr.~ This clause must occur at top-level. ~init-expr~ will be moved outside the loop body and ~then-expr~ will be moved to the end of the loop body, so they are subject to code motion problems (see section \ref{code-movement}). \cpar This clause may appear to be similar to |for\dots next|, but in fact they differ significantly. |for\dots initially\dots then| is typically used to give ~var~ its first value before the loop begins, and subsequent values on following iterations. This is incompatible with generators, whose first value and subsequent values must all be computed by |(next ~var~)|. Also, the update of ~var~ in |for\dots initially\dots then| does not occur at the location of the clause. Use |for\dots initially\dots then| for one-shot computations where its idiom is more convenient, but use |for\dots next| for extending \iter\ with new drivers (see section \ref{extend}). \clause{|for| ~var~ |first| ~first-expr~ |then| ~then-expr~} \clindexxx{for}{first}{then} The first time through the loop, ~var~ is set to ~first-expr;~ on subsequent iterations, it is set to ~then-expr.~ This differs from |for\dots initially| in that ~var~ is set to ~first-expr~ inside the loop body, so ~first-expr~ may depend on the results of other clauses. For instance, \begin{program} (iter (for num in list) (for i first num then (1+ i)) ...) \end{program} will set |i| to the first element of |list| on the first iteration, whereas \begin{program} (iter (for num in list) (for i initially num then (1+ i)) ...) \end{program} is probably erroneous; |i| will be bound to |num|'s default binding (usually \nil) for the first iteration. \end{clauses} \begin{note}{Compatibility note} |loop|'s |for\dots =| works like \iter's, but |loop| used the syntax |for\dots =\dots then| to mean |for\dots initially\dots then|. It was felt that these two operations were sufficiently different to warrant different keywords. Also, the |for| in the above three clauses is misleading, since none is true driver (e.g. none has a corresponding |generate| form). |setting| would have been a better choice, but |for| was used to retain some compatibility with |loop|. \end{note} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \subsection{Gathering Clauses} Many of \iter's clauses accumulate values into a variable, or set a variable under certain conditions. At the end of the loop, this variable contains the desired result. All these clauses have an optional |into| keyword, whose argument should be a symbol. If the |into| keyword is not supplied, the accumulation variable will be internally generated and its value will be returned at the end of the loop; if a variable is specified, that variable is used for the accumulation, and is not returned as a result---it is up to the user to return it explicitly, in the loop's epilogue code (see |finally|). It is safe to examine the accumulation variable during the loop, but it should not be modified. These clauses all begin with a verb. When the verb does not conflict with an existing Common Lisp function, then it may be used in either its infinitival or present-participle form (e.g. |sum|, |summing|). However, when there is a conflict with Common Lisp, only the present-participle form may be used (e.g. |unioning|). This is to prevent \iter\ clauses from clashing with Common Lisp functions. %although these clauses are described as ``producing a value,'' it is a %mistake to think of the lisp list representing the clause as a %value-producing form in the usual way. clauses may legally be written %where a value is expected, e.g. |(setq x (sum i))|, but the %lisp value of a clause in such a context is undefined. \subsubsection{Reductions} ~Reduction~ is an extremely common iteration pattern in which the results of successive applications of a binary operation are accumulated. For example, a loop that computes the sum of the elements of a list is performing a reduction with the addition operation. This could be written in Common Lisp as |(reduce \#'+ list)| or with \iter\ as \begin{program} (iter (for el in list) (sum el)) \end{program} \begin{clauses} \clausex{sum}{~expr~ \opt\ |into| ~var~} Each time through the loop, ~expr~ is evaluated and added to a variable, which is bound initially to zero. If ~expr~ has a type, it is ~not~ used as the type of the sum variable, which is always |number|. To get the result variable to be of a more specific type, use an explicit variable, as in \begin{program} (iter (for el in number-list) (sum el into x) (declare (fixnum x)) (finally (return x))) \end{program} \clausex{multiply}{~expr~ \opt\ |into| ~var~} Like |sum|, but the initial value of the result variable is $1$, and the variable is updated by multiplying ~expr~ into it. \clausex{counting}{~expr~ \opt\ |into| ~var~} ~expr~ is evaluated on each iteration. If it is \nonnil, the accumulation variable, initially zero, is incremented. \startitem \Clausex{maximize}{~expr~ \opt\ |into| ~var~} \Clausex{minimize}{~expr~ \opt\ |into| ~var~} \finishitem ~expr~ is evaluated on each iteration and its extremum (maximum or minimum) is stored in the accumulation variable. If ~expr~ is never evaluated, then the result is \nil\ (if the accumulation variable is untyped) or $0$ (if it has a numeric type). \clausex{reducing}{~expr~ |by| ~func~ \opt\ |initial-value| ~init-val~ |into| ~var~} This is a general way to perform reductions. ~func~ should be a function of two arguments, the first of which will be the value computed so far and the second of which will be the value of ~expr~. It should return the new value. |reducing| is roughly equivalent to the Common Lisp |(reduce ~func~ ~sequence~ :key ~expr-function~)|, where ~expr-function~ is used to derive values from the successive elements of ~sequence~. \cpar If the |reducing| clause is never executed, the result is undefined. \cpar It is not necessary to provide an initial value, but better code can be generated if one is supplied. Regardless of its location in the \iter\ body, ~init-val~ will be evaluated before the loop is entered, so it should not depend on any value computed inside the \iter\ form. %\cpar if a ~var~ is not specified, you can get \iter\ to declare the %type of the internal variable by putting a |the| expression around %~func.~ see section \ref{types}. \end{clauses} %\begin{note}{implementation note} %in principle, |maximize| and |minimize| can be thought of %as reductions where the initial value is the smallest (or largest) %value that the accumulation variable can assume. because lisp's %bignums can represent arbitrary integers, these clauses cannot be %implemented as reductions in general. if, however, the type of %~expr~ or ~var~ can be determined to be a fixnum %or a float, \iter\ will implement the clause as a true reduction, %using one of the constants |most-negative-fixnum|, |%most-positive-fixnum|, %|most-negative-short-float|, etc. as appropriate. %\end{note} \subsubsection{Accumulations} All the predefined accumulation clauses add values to a sequence. If the sequence is a list, they all have the property that the partial list is kept in the correct order and available for inspection at any point in the loop. \begin{clauses} \clausex{collect}{~expr~ \opt\ |into| ~var~ |at| ~place~ |result-type| ~type~} Produces a sequence of the values of ~expr~ on each iteration. ~place~ indicates where the next value of ~expr~ is added to the list and may be one of the symbols |start|, |beginning| (a synonym for |start|) or |end|. The symbol may be quoted, but need not be. The default is |end|. For example, \begin{program} (iter (for i from 1 to 5) (collect i)) \end{program} produces |(1 2 3 4 5)|, whereas \begin{program} (iter (for i from 1 to 5) (collect i at beginning)) \end{program} produces |(5 4 3 2 1)| (and is likely to be faster in most Common Lisp implementations). \cpar If ~type~ is provided, it should be a subtype of |sequence|. The default is |list|. Specifying a type other than |list| will result in |collect| returning a sequence of that type. ~However,~ the type of the sequence being constructed when inside the loop body is undefined when a non-|list| type is specified. (As with ~place~, quoting ~type~ is optional.) \clausex{adjoining}{~expr~ \opt\ |into| ~var~ |test| ~test~ |at| ~place~ |result-type| ~type~} Like |collect|, but only adds the value of ~expr~ if it is not already present. ~test,~ which defaults to |\#'eql|, is the test to be used with |member|. \startitem \Clausex{appending}{~expr~ \opt\ |into| ~var~ |at| ~place~} \Clausex{nconcing}{\ ~expr~ \opt\ |into| ~var~ |at| ~place~} \Clausex{unioning}{\ ~expr~ \opt\ |into| ~var~ |test| ~test~ |at| ~place~} \Clausex{nunioning}{~expr~ \opt\ |into| ~var~ |test| ~test~ |at| ~place~} \finishitem These are like |collect|, but behave like the Common Lisp functions |append|, |nconc|, |union| or |nunion|. As in Common Lisp, they work only on lists. Also as in Common Lisp, |unioning| and |nunioning| assume that the value of ~expr~ contains no duplicates. \clausex{accumulate}{~expr~ |by| ~func~ \opt\ |initial-value| ~init-val~ |into| ~var~} This is a general-purpose accumulation clause. ~func~ should be a function of two arguments, the value of ~expr~ and the value accumulated so far in the iteration, and it should return the updated value. If no initial value is supplied, \nil\ is used. %\cpar If a ~var~ is not specified, you can get \iter\ to declare the %type of the internal variable by putting a |the| expression around %~func.~ see section \ref{types}. \cpar The differences between |accumulate| and |reducing| are slight. One difference is that the functions take their arguments in a different order. Another is that in the absence of ~init-val~, |accumulate| will use \nil, whereas |reducing| will generate different code that avoids any dependence on the initial value. The reason for having both clauses is that one usually thinks of reductions (like |sum|) and accumulations (like |collect|) as different beasts. \end{clauses} \subsubsection{Finders} A ~finder~ is a clause whose value is an expression that meets some condition. \begin{clauses} \clause{|finding| ~expr~ |such-that| ~test~ \opt\ |into| ~var~ |on-failure| ~failure-value~} \clindexx{finding}{such-that} If ~test~ (which is an expression) ever evaluates to \nonnil, the loop is terminated, the epilogue code is run and the value of ~expr~ is returned. Otherwise, \nil\ (or ~failure-value,~ if provided) is returned. If ~var~ is provided, it will have either the \nonnil\ value of ~expr~ or ~failure-value~ when the epilogue code is run. \cpar As a special case, if the ~test~ expression is a sharp-quoted function, then it is applied to ~expr~ instead of being simply evaluated. E.g. |(finding x such-that \#'evenp)| is equivalent to |(finding x such-that (evenp x))|. %\cpar although ~test~ need have nothing to do with ~%expr~ as in %|(finding j such-that (> i 3))|, it usually %will: |(finding (length el) such-that (oddp (length el)))|. to %avoid performing the |length| computation twice, you could write %|(finding (length el) such-that \#'oddp)| or |(finding (length %el) such-that 'oddp)|; for these cases, \iter\ generates code that %executes ~expr~ only once. the code for |\#'oddp| %is slightly different from that for {\lisp 'oddp}; see the discussion %under {\lisp for\dots in} and {\lisp for\dots on}. \cpar |On-failure| is a misnomer. Because it is always evaluated, it behaves more like the default third argument to the |gethash| function. As a result, |on-failure (error "Not found")| makes no sense. Instead, the clauses |leave| or |thereis| can be used in conjunction with |finally| as follows: \begin{program} (iter (for x in '(1 2 3)) (if (evenp x) (leave x)) (finally (error "not found"))) \end{program} \cpar This clause may appear multiple times when all defaults are identical. It can also be used together with either |always|/|never| or |thereis| if their defaults match. More specifically, |on-failure nil| is compatible with |thereis|, while |on-failure t| is compatible with |always| and |never| clauses. \begin{program} (iter (for i in '(7 -4 2 -3)) (if (plusp i) (finding i such-that (evenp i)) (finding (- i) such-that (oddp i)))) \end{program} \startitem \Clause{|finding| ~expr~ |maximizing| ~m-expr~ \opt\ |into| ~var~} \clindexx{finding}{maximizing} \Clause{|finding| ~expr~ |minimizing| ~m-expr~ \opt\ |into| ~var~} \clindexx{finding}{minimizing} \finishitem Computes the extremum (maximum or minimum) value of ~m-expr~ over all iterations, and returns the value of ~expr~ corresponding to the extremum. ~expr~ is evaluated inside the loop at the time the new extremum is established. If ~m-expr~ is never evaluated (due to, for example, being embedded in a conditional clause), then the returned value depends on the type, if any, of ~expr~ (or ~var,~ if one is supplied). If there is no type, the returned value will be \nil; if the type is numeric, the returned value will be zero. \cpar For these two clauses, ~var~ may be a list of two symbols; in that case, the first is used to record ~expr~ and the second, ~m-expr.~ \cpar As with |finding\dots such-that|, if ~m-expr~ is a sharp-quoted function, then it is called on ~expr~ instead of being evaluated. \end{clauses} \subsubsection{Boolean Tests} \begin{clauses} \clausex{first-iteration-p}{} Returns |t| in the first cycle of the loop, otherwise \nil. \clausex{first-time-p}{} Returns |t| the first time the expression is evaluated, and then \nil\ forever. This clause comes handy when printing (optional) elements separated by a comma: \begin{program} (iter (for el in '(nil 1 2 nil 3)) (when el (unless (first-time-p) (princ ", ")) (princ el))) \end{program} produces |"1, 2, 3"|. \end{clauses} \subsubsection{Aggregated Boolean Tests} \begin{clauses} \clausex{always}{~expr~} If ~expr~ ever evaluates to \nil, then \nil\ is immediately returned; the epilogue code is not executed. If ~expr~ never evaluates to \nil, the epilogue code is executed and the last value of ~expr~ (or |t| if ~expr~ was never evaluated) is returned (whereas |loop| would constantly return |t|). % mention last evaluated clause when multiple always clauses? \clausex{never}{~expr~} Like |(always (not ~expr~))|, except it does not influence the last value returned by a possible other |always| clause. That is, \begin{program} (iter (repeat 2) (always 2) (never nil)) \yields 2 ; not t \end{program} \clausex{thereis}{~expr~} If ~expr~ is ever \nonnil, its value is immediately returned without running epilogue code. Otherwise, the epilogue code is performed and \nil\ is returned. This clause cannot be used together with |always| or |never|, because their defaults are opposed (similarly, |(loop always 3 thereis nil)| refuses to compile in some implementations of |loop|). \end{clauses} \subsection{Control Flow} \label{control-flow} Several clauses can be used to alter the usual flow of control in a loop. Note: the clauses of this and subsequent sections don't adhere to \iter's usual syntax, but instead use standard Common Lisp syntax. Hence the format for describing syntax subsequently is like the standard format used in the Common Lisp manual, not like the descriptions of clauses above. \begin{clauses} \clausex{finish}{} Stops the loop and runs the epilogue code. %for example: % %\begin{program} %(iter (with answer = nil) % (initially (make-a-mess)) % (for i from 1 to 10) % (when (correct? i) % (setq answer i) % (finish)) % (finally (cleanup))) %\end{program} % %this code will execute |cleanup| whether or not the test |(correct? %i)| ever succeeds. %the (more elegant) formulation, %\begin{program} %(iter (initially (make-a-mess)) % (for i from 1 to 10) % (finding i such-that (correct? i)) % (finally (cleanup))) %\end{program} %would not execute |cleanup| if |(correct? i)| succeeded; it %would do an immediate return. \clausex{leave}{\opt\ ~value~} Immediately returns ~value~ (default \nil) from the current \iter\ form, skipping the epilogue code. Equivalent to using |return-from|. \clausex{next-iteration}{} Skips the remainder of the loop body and begins the next iteration of the loop. \clausex{while}{~expr~} If ~expr~ ever evaluates to \nil, the loop is terminated and the epilogue code executed. Equivalent to |(if (not ~expr~) (finish))|. \clausex{until}{~expr~} Equivalent to |(if ~expr~ (finish))|. \clausex{if-first-time}{~then~ \opt\ ~else~} If this clause is being executed for the first time in this invocation of the \iter\ form, then the ~then~ code is evaluated; otherwise the ~else~ code is evaluated. \cpar |(for ~var~ first ~expr1~ then ~expr2~)| is almost equivalent to \begin{program} (if-first-time (dsetq ~var~ ~expr1~) (dsetq ~var~ ~expr2~)) \end{program} The only difference is that the |for| version makes ~var~ available for use with |for\dots previous|. \end{clauses} \subsection{Code Placement} When fine control is desired over where code appears in a loop generated by \iter, the following special clauses may be useful. They are all subject to code-motion problems (see section \ref{code-movement}). \begin{clauses} \clausex{initially}{|\&rest| ~forms~} The lisp ~forms~ are placed in the prologue section of the loop, where they are executed once, before the loop body is entered. \clausex{after-each}{|\&rest| ~forms~} The ~forms~ are placed at the end of the loop body, where they are executed after each iteration. Unlike the other clauses in this section, ~forms~ may contain \iter\ clauses. \clausex{else}{|\&rest| ~forms~} The lisp ~forms~ are placed in the epilogue section of the loop, where they are executed if this |else| clause is never met during execution of the loop and the loop terminates normally. \clausex{finally}{|\&rest| ~forms~} The lisp ~forms~ are placed in the epilogue section of the loop, where they are executed after the loop has terminated normally. \clausex{finally-protected}{|\&rest| ~forms~} The lisp ~forms~ are placed in the second form of an unwind-protect outside the loop. They are always executed after the loop has terminated, regardless of how the termination occurred. \end{clauses} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \section{Other Features} \subsection{Multiple Accumulations} \label{multiple} \begin{sloppypar} It is permitted to have more than one clause accumulate into the same variable, as in the following: \begin{program} (iter (for i from 1 to 10) (collect i into nums) (collect (sqrt i) into nums) (finally (return nums))) \end{program} Clauses can only accumulate into the same variable if they are compatible. |collect|, |adjoining|, |appending|, |nconcing|, |unioning| and |nunioning| are compatible with each other; |sum|, |multiply| and |counting| are compatible; |always| and |never| are compatible; |finding| \dots |such-that| is compatible with either |thereis| or |always| and |never| when their defaults match; and |maximize| and |minimize| clauses are compatible only with other |maximize| and |minimize| clauses, respectively. %note that the same variable ~cannot~ be both an accumulation %variable and an ordinary variable; there can be only one variable with %a given name within an \iter\ form. \end{sloppypar} \subsection{Named Blocks} Like Common Lisp |block|s, \iter\ forms can be given names. The name should be a single symbol, and it must be the first form in the \iter. The generated code behaves exactly like a named block; in particular, |(return-from ~name~)| can be used to exit it: \begin{program} (iter fred (for i from 1 to 10) (iter barney (for j from i to 10) (if (> (* i j) 17) (return-from fred j)))) \end{program} An \iter\ form that is not given a name is implicitly named \nil. Sometimes one would like to write an expression in an inner \iter\ form, but have it processed by an outer \iter\ form. This is possible with the |in| clause. \begin{clauses} \clausex{in}{~name~ |\&rest| ~forms~} Evaluates ~forms~ as if they were part of the \iter\ form named ~name~. In other words, \iter\ clauses are processed by the \iter\ form named ~name,~ and not by any \iter\ forms that occur inside ~name.~ \cpar As an example, consider the problem of collecting a list of the elements in a two-dimensional array. The naive solution, \begin{program} (iter (for i below (array-dimension ar 0)) (iter (for j below (array-dimension ar 1)) (collect (aref ar i j)))) \end{program} \noindent is wrong because the list created by the inner \iter\ is simply ignored by the outer one. But using |in| we can write: \begin{program} (iter outer (for i below (array-dimension ar 0)) (iter (for j below (array-dimension ar 1)) (in outer (collect (aref ar i j))))) \end{program} \noindent which has the desired result. \end{clauses} \subsection{Destructuring} \label{destructuring} In many places within \iter\ clauses where a variable is expected, a list can be written instead. In these cases, the value to be assigned is ~destructured~ according to the pattern described by the list. As a simple example, the clause \begin{program} (for (key . item) in alist) \end{program} \noindent will result in |key| being set to the |car| of each element in |alist|, and |item| being set to the |cdr|. The pattern list may be nested to arbitrary depth, and (as the example shows) need not be terminated with \nil; the only requirement is that each leaf be a bindable symbol (or \nil, in which case no binding is generated for that piece of the structure). Sometimes, you might like to do the equivalent of a |multiple-value-setq| in a clause. This ``multiple-value destructuring'' can be expressed by writing \linebreak |(values $pat_1$ $pat_2 \ldots$)| for a destructuring pattern, as in \begin{program} (for (values (a . b) c d) = (three-valued-function ...)) \end{program} \begin{sloppypar} Note that the $pat_i$ can themselves be destructuring patterns (though not multiple-value destructuring patterns). You can't do multiple-value destructuring in a |with| clause; instead wrap the whole \iter\ form in a |multiple-value-bind|. \end{sloppypar} \begin{note}{Rationale} There are subtle interactions between variable declarations and evaluation order that make the correct implementation of multiple-value destructuring in a |with| somewhat tricky. \end{note} The destructuring feature of \iter\ is available as a separate mechanism, using the |dsetq| macro: \begin{clauses} \defmacro{dsetq}{template expr} Performs destructuring of ~expr~ using ~template~. May be used outside of an \iter\ form. Yields the primary value of ~expr~. \end{clauses} \subsection{On-line Help} \begin{sloppypar} There is a limited facility for on-line help, in the form of the |display-iterate-clauses| function. \end{sloppypar} \begin{clauses} \defun{display-iterate-clauses}{\opt\ clause-spec} Displays a list of \iter\ clauses. If ~clause-spec~ is not provided, all clauses are shown; if it is a symbol, all clauses beginning with that symbol are shown; and if it is a list of symbols, all clauses for which ~clause-spec~ is a prefix are shown. \end{clauses} \subsection{Parallel Binding and Stepping} \label{bindings} The parallel binding and stepping of variables is a feature that \iter\ does ~not~ have. This section attempts to provide a rationale. We say that two variables are bound ~in parallel~ if neither binding shadows the other. This is the usual semantics of |let| (as opposed to |let*|). Similarly, we can say that iteration variables are stepped in parallel if neither variable is updated before the other, conceptually speaking; in other words, if the code to update each variable can reference the old values of both variables. |loop| allows parallel binding of variables and parallel stepping of driver variables. My view is that if you are depending on the serial/parallel distinction, you are doing something obscure. If you need to bind variables in parallel using |with|, then you must be using a variable name that shadows a name in the existing lexical environment. Don't do that. The most common use for parallel stepping is to track the values of variables on the previous iteration, but in fact this does not require parallel stepping at all; the following will work: \begin{program} (iter (for current in list) (for prev previous current) ...) \end{program} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \section{Types and Declarations} \label{types} \subsection{Discussion} Sometimes efficiency dictates that the types of variables be declared. This type information needs to be communicated to \iter\ so it can bind variables to appropriate values. Furthermore, \iter\ must often generate internal variables invisible to the user; there needs to be a way for these to be declared. As an example, consider this code, which will return the number of odd elements in |number-list|: \begin{program} (iter (for el in number-list) (count (oddp el))) \end{program} In processing this form, \iter\ will create an internal variable, let us call it |list17|, to hold the successive |cdr|s of |number-list|, and will bind the variable to |number-list|. It will also generate a default binding for |el|; only inside the body of the loop will |el| be set to the |car| of |list17|. Finally, \iter\ will generate a variable, call it |result|, to hold the result of the count, and will bind it to zero. When dealing with type declarations, \iter\ observes one simple rule: ~it will never generate a declaration unless requested to do so.~ The reason is that such declarations might mask errors in compiled code by avoiding error-checks; the resulting problems would be doubly hard to track down because the declarations would be hidden from the programmer. Of course, a compiler might omit error-checks even in the absence of declarations, though this behavior can usually be avoided, e.g. by saying |(declaim (optimize (safety 3)))|. So, the above \iter\ form will generate code with no declarations. But say we wish to declare the types of |el| and the internal variables |list17| and |result|. How is this done? Declaring the type of |el| is easy, since the programmer knows the variable's name: \begin{program} (iter (for el in number-list) (declare (fixnum el)) (counting (oddp el))) \end{program} \iter\ can read variable type declarations like this one. Before processing any clauses, it scans the entire top-level form for type declarations and records the types, so that variable bindings can be performed correctly. In this case, |el| will be bound to zero instead of \nil. Also, \iter\ collects all the top-level declarations and puts them at the begining of the generated code, so it is not necessary to place all declarations at the beginning of an \iter\ form; instead, they can be written near the variables whose types they declare. Since \iter\ is not part of the compiler, it will not know about declarations that occur outside an \iter\ form; these declarations must be repeated inside the form. Here is another way we could have declared the type of |el|: \begin{program} (iter (for (the fixnum el) in number-list) (counting (oddp el))) \end{program} \iter\ extends the Common Lisp |the|\lispindex{the} form to apply to variables as well as value-producing forms; anywhere a variable is allowed---in a |with| clause, as the iteration variable in a driver clause, as the |into| argument of an accumulation clause, even inside a destructuring template---you can write |(the ~type~ ~symbol~)| instead. There is one crucial difference between using a |the| form and actually declaring the variable: explicit declarations are always placed in the generated code, but type information from a |the| form is not turned into an actual declaration unless you tell \iter\ to do so using |iterate:declare-variables|. See below. \begin{sloppypar} Declaring the types of internal variables is harder than declaring the types of explicitly mentioned variables, since their names are unknown. You do it by declaring |iterate:declare-variables| somewhere inside the top level of the \iter\ form. (This will also generate declarations for variables declared using |the|.) \iter\ does not provide much selectivity here: it's all or none. And unfortunately, since \iter\ is not privy to compiler information but instead reads declarations itself, it will not hear if you |(declaim (iterate:declare-variables))|. Instead, set the variable |iterate::*always-declare-variables*| to |t| at compile-time, using |eval-when|. \end{sloppypar} To determine the appropriate types for internal variables, \iter\ uses three sources of information: \begin{itemize} \item Often, the particular clause dictates a certain type for a variable; \iter\ will use this information when available. In the current example, the variable |list17| will be given the type |list|, since that is the only type that makes sense; and the variable |result| will be given the type |fixnum|, on the assumption that you will not be counting high enough to need bignums. You can override this assumption only by using and explicitly declaring a variable: \begin{verbatim} (iter (declare (iterate:declare-variables)) (for el in number-list) (count (oddp el) into my-result) (declare (integer my-result)) (finally (return my-result))) \end{verbatim} \begin{sloppypar} Other examples of the type assumptions that \iter\ makes are: type |list| for |into| variables of collection clauses; type |list| for expressions that are to be destructured; type |vector| for the variable holding the vector in a |for\dots in-vector| clause, and similarly for |string| and the |for\dots in-string| clause; and the implementation-dependent type |(type-of array-dimension-limit)| for the index and limit variables generated by sequence iteration drivers like |for\dots in-vector| and |for\dots in-string| (but not |for\dots in-sequence|, because it may be used to iterate over a list). \end{sloppypar} \item Sometimes, \iter\ will examine expressions and try to determine their types in a simple-minded way. If the expression is self-evaluating (like a number, for instance), \iter\ knows that the expression's type is the same as the type of the value it denotes, so it can use that type. If the expression is of the form |(the ~type~ ~expr~)|, \iter\ is smart enough to extract ~type~ and use it. However, the current version of \iter\ does not examine declarations of function result types or do any type inference. It will not determine, for example, that the type of |(+ 3 4)| is |fixnum|, or even |number|. \item In some cases, the type of an internal variable should match the type of some other variable. For instance, \iter\ generates an internal variable for |(f x)| in the clause |(for i from 1 to (f x))|, and in the absence of other information will give it the same type as |i|. If, however, the expression had been written |(the fixnum (f x))|, then \iter\ would have given the internal variable the type |fixnum| regardless of |i|'s type. The type incompatibility errors that could arise in this situation are not checked for. \end{itemize} Note that if you do declare |iterate:declare-variables|, then \iter\ may declare user variables as well as internal ones if they do not already have declarations, though only for variables that it binds. For instance, in this code: \begin{program} (iter (declare (iterate:declare-variables)) (for i from 1 to 10) (collect i into var)) \end{program} the variable |var| will be declared to be of type |list|. \subsection{Summary} \iter\ understands standard Common Lisp variable type declarations that occur within an \iter\ form and will pass them through to the generated code. If the declaration |(iterate:declare-variables)|\lispindex{declare-variables} appears at the top level of an \iter\ form, or if |iterate::*always-declare-variables*|\lispindex{*always-declare-variables*} is \nonnil, then \iter\ will use the type information gleaned from user declarations, self-evaluating expressions and |the| expressions, combined with reasonable assumptions, to determine variable types and declare them. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \section{Problems with Code Movement} \label{code-movement} Some \iter\ clauses, or parts of clauses, result in code being moved from the location of the clause to other parts of the loop. Drivers behave this way, as do code-placement clauses like |initially| and |finally|. When using these clauses, there is a danger of writing an expression that makes sense in its apparent location but will be invalid or have a different meaning in another location. For example: \begin{program} (iter (for i from 1 to 10) (let ((x 3)) (initially (setq x 4)))) \end{program} While it may appear that the |x| of |(initially (setq x 4))| is the same as the |x| of |(let ((x 3)) \dots|, in fact they are not: |initially| moves its code outside the loop body, so |x| would refer to a global variable. Here is another example of the same problem: \begin{program} (iter (for i from 1 to 10) (let ((x 3)) (collect i into x))) \end{program} If this code were executed, |collect| would create a binding for its |x| at the top level of the \iter\ form that the |let| will shadow. Happily, \iter\ is smart enough to catch these errors; it walks all problematical code to ensure that free variables are not bound inside the loop body, and checks all variables it binds for the same problem. However, some errors cannot be caught: \begin{program} (iter (with x = 3) (for el in list) (setq x 1) (reducing el by \#'+ initial-value x)) \end{program} |reducing| moves its |initial-value| argument to the initialization part of the loop in order to produce more efficient code. Since \iter\ does not perform data-flow analysis, it cannot determine that |x| is changed inside the loop; all it can establish is that |x| is not bound internally. Hence this code will not signal an error and will use $3$ as the initial value of the reduction. The following list summarizes all cases that are subject to these code motion and variable-shadowing problems. \begin{itemize} \item Any variable for which \iter\ creates a binding, including those used in |with| and the |into| keyword of many clauses. \begin{sloppypar} \item The special clauses which place code: |initially|, |after-each|, |else|, |finally| and |finally-protected|. \end{sloppypar} \item The variables of a |next| or |do-next| form. \item The |initially| arguments of |for\dots initially\dots then| and |for\dots previous|. \item The |then| argument of |for\dots initially\dots then|. \item The |initial-value| arguments of |reducing| and |accumulate|. \item The |on-failure| argument of |finding\dots such-that|. \end{itemize} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \section{Differences Between {\tt Iterate} and {\tt Loop}} |loop| contains a great deal of complexity which \iter\ tries to avoid. Hence many esoteric features of |loop| don't exist in \iter. Other features have been carried over, but in a cleaned-up form. And of course, many new features have been added; they are not mentioned in this list. \begin{itemize} \item \iter's syntax is more Lisp-like than |loop|'s, having a higher density of parens. \item The current implementation of \iter, unlike the current version of |loop| (as documented in {\em Common Lisp, 2nd Ed.\/}), is extensible (see section \ref{extend}). \item |loop| puts the updates of all driver variables at the top of the loop; \iter\ leaves them where the driver clauses appear. \item While for the most part \iter\ clauses that resemble |loop| clauses behave similarly, there are some differences. For instance, there is no |for\dots =\dots then| in \iter; instead use |for\dots initially\dots then|. \item |loop| binds the variable |it| at certain times to allow pseudo-English expressions like |when ~expr~ return it|. In \iter, you must bind ~expr~ to a variable yourself. Note that |when ~expr~ return it| is like |thereis ~expr~| except that the latter is an accumulation clause and therefore competes with other accumulations (remember section \ref{multiple} above). % repeat different behaviour of |always| clause here? \item |loop| has a special |return| clause, illustrated in the previous item. \iter\ doesn't need one, since an ordinary Lisp |return| has the same effect. \item |loop| allows for parallel binding and stepping of iteration variables. \iter\ does not. (See section \ref{bindings}.) \item |loop| and \iter\ handle variable type declarations very differently. |loop| provides a special syntax for declaring variable types, and does not examine declarations. Moreover, the standard implementation of |loop| will generate declarations when none are requested. \iter\ parses standard Common Lisp type declarations, and will never declare a variable itself unless declarations are specifically requested. \end{itemize} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \section{Rolling Your Own} \label{extend} \subsection{Introduction} \iter\ is extensible---you can write new clauses that embody new iteration patterns. You might want to write a new driver clause for a data structure of your own, or you might want to write a clause that collects or manipulates elements in a way not provided by \iter. This section describes how to write clauses for \iter. Writing a clause is like writing a macro. In fact, writing a clause ~is~ writing a macro: since \iter\ code-walks its body and macroexpands, you can add new abstractions to \iter\ with good old |defmacro|. Actually, there are two extensions you can make to \iter\ that are even easier than writing a macro. They are adding a synonym for an existing clause and defining a driver clause for an indexable sequence. These can be done with |defsynonym| and |defclause-sequence|, respectively. See section \ref{aids}, below. The rest of this section explains how to write macros that expand into \iter\ clauses. Here's how you could add a simplified version of \iter's |multiply| clause, if \iter\ didn't already have one: \begin{program} (defmacro multiply (expr) `(reducing ,expr by \#'* initial-value 1)) \end{program} If you found yourself summing the square of an expression often, you might want to write a macro for that. A first cut might be \begin{program} (defmacro sum-of-squares (expr) `(sum (* ,expr ,expr))) \end{program} but if you are an experienced macro writer, you will realize that this code will evaluate ~expr~ twice, which is probably a bad idea. A better version would use a temporary: \begin{program} (defmacro sum-of-squares (expr) (let ((temp (gensym))) `(let ((,temp ,expr)) (sum (* ,temp ,temp))))) \end{program} Although this may seem complex, it is just the sort of thing you'd have to go through to write any macro, which illustrates the point of this section: if you can write macros, you can extend \iter. Our macros don't use \iter's keyword-argument syntax. We could just use keywords with |defmacro|, but we would still not be using \iter's clause indexing mechanism. Unlike Lisp, which uses just the first symbol of a form to determine what function to call, \iter\ individuates clauses by the list of required keywords. For instance, |for\dots in| and |for\dots in-vector| are different clauses implemented by distinct Lisp functions. To buy into this indexing scheme, as well as the keyword-argument syntax, use |defmacro-clause|: \begin{clauses} \defmacro{defmacro-clause}{arglist |\&body| body} Defines a new \iter\ clause. ~arglist~ is a list of symbols which are alternating keywords and arguments. \opt\ may be used, and the list may be terminated by |\&sequence|. ~body~ is an ordinary macro body, as with |defmacro|. If the first form of ~body~ is a string, it is considered a documentation string and will be shown by |display-iterate-clauses|. |defmacro-clause| will signal an error if defining the clause would result in an ambiguity. E.g. you cannot define the clause |for\dots from| because there would be no way to distinguish it from a use of the |for| clause with optional keyword |from|. \end{clauses} \medskip Here is |multiply| using |defmacro-clause|. The keywords are capitalized for readability. \begin{program} (defmacro-clause (MULTIPLY expr \opt\ INTO var) `(reducing ,expr by \#'* into ,var initial-value 1)) \end{program} You don't have to worry about the case when |var| is not supplied; for any clause with an |into| keyword, saying |into nil| is equivalent to omitting the |into| entirely. As another, more extended example, consider the fairly common iteration pattern that involves finding the sequence element that maximizes (or minimizes) some function. \iter\ provides this as |finding\dots maximizing|, but it's instructive to see how to write it. Here, in pseudocode, is how you might write such a loop for maximizing a function F: \begin{quote} \begin{tabbing} set variable MAX-VAL to NIL; \\ set variable WINNER to NIL; \\ for\=\ each element EL in the sequence \\ \> if\=\ MAX-VAL\=\ is NIL or F(EL) $>$ MAX-VAL then \\ \>\> set MAX-VAL to F(EL); \\ \>\> set WINNER to EL; \\ \> end if; \\ end for; \\ return WINNER. \end{tabbing} \end{quote} Here is the macro: \begin{program} (defmacro-clause (FINDING expr MAXIMIZING func \opt\ INTO var) (let ((max-val (gensym)) (temp1 (gensym)) (temp2 (gensym)) (winner (or var iterate::*result-var*))) `(progn (with ,max-val = nil) (with ,winner = nil) (cond ((null ,max-val) (setq ,winner ,expr) (setq ,max-val (funcall ,func ,winner)) (t (let* ((,temp1 ,expr) (,temp2 (funcall ,func ,temp1))) (when (> ,temp2 ,max-val) (setq ,max-val ,temp2) (setq ,winner ,temp1)))))) (finally (leave ,winner))))) \end{program} Note that if no |into| variable is supplied, we use |iterate::*result-var*|, which contains the internal variable into which all clauses place their results. If this variable is bound by some clause, then \iter\ will return its value automatically; otherwise, \nil\ will be returned. \subsection{Writing Drivers} In principle, drivers can be implemented just as easily as other \iter\ clauses. In practice, they are a little harder to get right. As an example, consider writing a driver that iterates over all the elements of a vector, ignoring its fill-pointer. |for\dots in-vector| won't work for this, because it observes the fill-pointer. It's necessary to use |array-dimension| instead of |length| to obtain the size of the vector. Here is one approach: \begin{program} (defmacro-clause (FOR var IN-WHOLE-VECTOR v) "All the elements of a vector (disregards fill-pointer)" (let ((vect (gensym)) (index (gensym))) `(progn (with ,vect = ,v) (for ,index from 0 below (array-dimension ,vect 0)) (for ,var = (aref ,vect ,index))))) \end{program} Note that we immediately put |v| in a variable, in case it is an expression. Again, this is just good Lisp macrology. It also has a subtle effect on the semantics of the driver: |v| is evaluated only once, at the beginning of the loop, so changes to |v| in the loop have no effect on the driver. Similarly, the bounds for numerical iteration e.g. the above |array-dimension| are also evaluated once only. This is how all of \iter's drivers work. There is an important point concerning the |progn| in this code. We need the |progn|, of course, because we are returning several forms, one of which is a driver. But \iter\ drivers must occur at top-level. Is this code in error? No, because ~top-level~ is defined in \iter\ to include forms inside a |progn|. This is just the definition of top-level that Common Lisp uses, and for the same reason: to allow macros to return multiple forms at top-level. While our |for\dots in-whole-vector| clause will work, it is not ideal. In particular, it does not support generating. Do do so, we need to use |for\dots next| or |for\dots do-next|. The job is simplified by the |defmacro-driver| macro. \begin{clauses} \defmacro{defmacro-driver}{arglist |\&body| body} Defines a driver clause in both the |for| and |generate| forms, and provides a parameter |generate| which ~body~ can examine to determine how it was invoked. ~arglist~ is as in |defmacro-clause|, and should begin with the symbol |for|. \end{clauses} With |defmacro-driver|, our driver looks like this: \begin{program} (defmacro-driver (FOR var IN-WHOLE-VECTOR v) "All the elements of a vector (disregards fill-pointer)" (let ((vect (gensym)) (end (gensym)) (index (gensym)) (kwd (if generate 'generate 'for))) `(progn (with ,vect = ,v) (with ,end = (array-dimension ,vect 0)) (with ,index = -1) (,kwd ,var next (progn (incf ,index) (if (>= ,index ,end) (terminate)) (aref ,vect ,index)))))) \end{program} We are still missing one thing: the |\&sequence| keywords. We can get them easily enough, by writing \begin{program} (defmacro-driver (FOR var IN-WHOLE-VECTOR v \&sequence) ...) \end{program} We can now refer to parameters |from|, |to|, |by|, etc. which contain either the values for the corresponding keyword, or \nil\ if the keyword was not supplied. Implementing the right code for these keywords is cumbersome but not difficult; it is left as an exercise. But before you begin, see |defclause-sequence| below for an easier way. \subsection{Extensibility Aids} \label{aids} This section documents assorted features that may be of use in extending \iter. \begin{clauses} \defunexpvar{*result-var*} Holds the variable that is used to return a value as a result of the \iter\ form. You may examine this and use it in a |with| clause, but you should not change it. \defmacro{defsynonym}{syn word} Makes ~syn~ a synonym for the existing \iter\ keyword ~word.~ Only the first word in each clause can have synonyms. \defmacroxx{defclause-sequence}{element-name index-name}{|\&key| access-fn size-fn sequence-type}{element-type element-doc-string index-doc-string} Provides a simple way to define sequence clauses. Generates two clauses, one for iterating over the sequence's elements, the other for iterating over its indices. The first symbol of both clauses will have print-name |for|. ~element-name~ and ~index-name~ should be symbols. ~element-name~ is the second keyword of the element iterator (typically of the form |in-~sequence-type~|), and ~index-name~ is the second keyword of the index-iterator (typically of the form |index-of-~sequence-type~|). Either name may be \nil, in which case the corresponding clause is not defined. If both symbols are supplied, they should be in the same package. The |for| that begins the clauses will be in this package. \cpar ~access-fn~ is the function to be used to access elements of the sequence in the element iterator. The function should take two arguments, a sequence and an index, and return the appropriate element. ~size-fn~ should denote a function of one argument, a sequence, that returns its size. Both ~access-fn~ and ~size-fn~ are required for the element iterator, but only ~size-fn~ is needed for the index iterator. \cpar The ~sequence-type~ and ~element-type~ keywords are used to suggest types for the variables used to hold the sequence and the sequence elements, respectively. The usual rules about \iter's treatment of variable type declarations apply (see section \ref{types}). \cpar ~element-doc-string~ and ~index-doc-string~ are the documentation strings, for use with |display-iterate-clauses|. \cpar The generated element-iterator performs destructuring on the element variable. \cpar As an example, the above |for\dots in-whole-vector| example could have been written: \begin{program} (defclause-sequence IN-WHOLE-VECTOR INDEX-OF-WHOLE-VECTOR :access-fn 'aref :size-fn \#'(lambda (v) (array-dimension v 0)) :sequence-type 'vector :element-type t :element-doc-string "Elements of a vector, disregarding fill-pointer" :index-doc-string "Indices of vector, disregarding fill-pointer") \end{program} \end{clauses} \subsection{Subtleties} There are some subtleties to be aware of when writing \iter\ clauses. First, the code returned by your macros may be |nconc|'ed into a list, so you should always returned freshly consed lists, rather than constants. Second, \iter\ matches clauses by using |eq| on the first symbol and |string=| on the subsequent ones, so the package of the first symbol of a clause is relevant. All of the clauses in this manual have their first word in the \iter\ package. You can use the package system in the usual way to shadow \iter\ clauses without replacing them. %%% say more here, about the badness that only the first word of a %%% clause is packagey. \section{Non-portable Extensions to Iterate (Contribs)} \label{contribs} Currently, there is only one non-portable extension to iterate in the distribution: iterate-pg. If you have made an extension that depends on non-portable features, feel free to send them to |asf@boinkor.net| for inclusion in the iterate distribution. \subsection{An SQL query driver for iterate} The pg package by Eric Marsden (see |http://cliki.net/pg|) provides an interface to the PostgreSQL database. Using the \iterpg\ extension, it is possible to handle the results of SQL queries using \iter. This usage example should give you an idea of how to use it: \begin{program} (pg:with-pg-connection (c "somedb" "someuser") (iter (for (impl version date) in-relation "select * from version" on-connection *dbconn*) (collect version))) \end{program} To use the extension via |ASDF|, simply make your system depend on the |iterate-pg| system instead of the |iterate| system. To load it manually, use: \begin{program} (asdf:oos 'asdf:load-op :iterate-pg) \end{program} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \section{Obtaining {\tt Iterate}} \begin{sloppypar} The information in this chapter is obsolete but included for completeness's sake; Currently, the most up-to-date information on \iter\ can be found at |http://boinkor.net/iterate.html|. \end{sloppypar} \begin{sloppypar} \iter\ currently runs on Lisp Machines, and on HP's, Sun3's and Sparcstations under Lucid. \iter\ source and binaries are available at the MIT AI Lab in the subdirectories of |/src/local/lisplib/|. The source file, |iterate.lisp|, is also available for anonymous FTP in the directory |/com/fpt/pub/| on the machine |TRIX.AI.MIT.EDU| (Internet number 128.52.32.6). If you are unable to obtain |iterate| in one of these ways, send mail to |jba@ai.mit.edu| and I will send you the source file. \end{sloppypar} \begin{sloppypar} \iter\ resides in the |iterate| package (nickname |iter|). Just say \linebreak |(use-package :iterate)| to make all the necessary symbols available. If a symbol is not exported, it appears in this manual with an ``|iterate::|'' prefix. \end{sloppypar} Send bug reports to |bug-iterate@ai.mit.edu|. The |info-iterate| mailing list will have notices of changes and problems; to have yourself added, send mail to |info-iterate-request@ai.mit.edu|. \medskip \begin{flushleft} \bf Acknowledgements \end{flushleft} \smallskip Richard Waters provided invaluable criticism which spurred me to improve \iter\ greatly. As early users, David Clemens, Oren Etzioni and Jeff Siskind helped ferret out many bugs. %\begin{theindex} % The index files must be generated with the genindex program % or from makeindex iterate-manual.idx which creates iterate-manual.ind. %\baselineskip\normalbaselineskip %\advance\baselineskip by -2pt \input{iterate-manual.ind} %\underline{Clauses} %\input{iterate-manual.clindex} % %\indexspace %\underline{Lisp} %\input{iterate-manual.lispindex} %\end{theindex} \end{document} % arch-tag: "c0f871a6-313c-11d8-abb9-000c76244c24" iterate-20160825-darcs/doc/tex/iterate-manual.pdf0000644000000000000000000072732712757566717017721 0ustar0000000000000000%PDF-1.3 %쏢 6 0 obj <> stream xTWT)k&mIIVcBڎcI:B%Y,euU7 T6oM ~7Y]x^ ^wj={Qzn\dqE+#. ty041ryhĻ/i}WCCW}4zUg,3u;MDE52q6#K b$(D2E,׶M*INOܐffX"Ȍ;E{yb.wZ쟧|ť;⠦9+7۾+ R~Y),H+ȉƐ^D)-+瀰<&{+/}Z_HCx8Re܁ߒng Uf6 -c6-ߙG?^'Jݗ`%># ٺ[%jmkcfC '*R UϦ`t 'r2g-$}튑1-.iZ8m{6OT)}N3%("8ق\E*%|bFbZtP/V 5 e*X]ͪMV~$EP*KXot0<ͯp}>S5 Iq$1I*#NJAIsF_b"&p[kIFefcNb+?,`A8wR;oӼiqZ%t֨YfHFRpAụ TP/Ca"S0353 =&S6=0fN0~PIfeOv ']m:wrްY wendstream endobj 7 0 obj 1144 endobj 184 0 obj <> stream xXoG.5Ԋ4AKծ!$]o8EZ'dGb8&$6u%p)I*PA$$!ЦBKOA}C쬝 CVۙolTK%A7FQA"s'eA|[̴REE+O53iv6V `]y%U{m4xK7=0K&J7phRvo˳Ē+i5hZl'mZ69ߴeZC[ZIG,M[i60]>_5Fc~k~O:;qh\&d&#lt>VK <.Eo`>9Đ'UȤ69E>9)/NLݟWkynbxL:E23^ =.R%SHM;in-`'ɑf(S.OGU6|&CCҸ?v2 "=hfvnӇLAYOtt"/ A3D-M=pm0z.C-= , ^Q}"~ $IaU+ B|<rR8ܖIzQA.{9qgLH6͌qq(*l/ z_- KؚfZʹwߒ;d(L4v<")e 7{CFd *aI@EfJa2aH?"Ct}5}W.) fCw҄)4=21,YF j&Yf{>H&\4 CÒ:+Xi@LESulM5psI a !WA\ LCgZ6 Ef́5ڗe-Bp'_W[ca{}%c fTrFx:(=ض_”35ϦhI˄4 j.>FJ@rlow7mpgrL̸EP]@>I+& pendstream endobj 185 0 obj 1740 endobj 256 0 obj <> stream x+T03T0A(UU`Qɹ N!\ !i\0 BH.;͐,.Cs ]S.3srY7_1YgmphdkkI+B̍ Ft ̌,b 1@.2endstream endobj 257 0 obj 159 endobj 262 0 obj <> stream xY]p.!+lQl"AlgBڕGJ*Y#D1U(" Y?ؖD+6cD ;@;0} g!@ϹZsww,dzi٦dSɳrizXh/N%ɎmёX/9Hl}>j:?j Cb{dW"kloBNQ[wS^|}ԙ׺O]xdYfm@k4&Sʦ̨Ǖ2}7,-%\bްO&(b yg\gIïqjd<]7<._,ʕE̕ۻuWFNt+1HA5/U`~B9ukQDa1_ 6,0pdMq|/q!"ib Xd~ EAST"F 3*YmEvLH읆]$=o$g,-D#MXa熙(4$Kld\ޒ]t_'tΔ/ t%: 04N&$ i07 4޴ 8UNDLWx`f0ȫfuknAu7R[.ו=0.:osN|5_߽À%Nڡ)сd2gB{1]Z2hBG9jI5DUXJ2):D$=BGI4^}S;Όrb@lkkt1()pZ OerJ8おZo\ם{z(;QAiPJ.\o^a Tl.-= U}WݢemBFu . .Gt GƕX Iླwhy&VYs tm$'^dԹw]9J3L9p>wck9:wQ$-DS-_=&H$lcyK$ L*JY\I2QAN A/ZVn$`i$:/uaS`3L3߉=S[Fʚ#;C]CG{[,ne]k Zq(N6m'FK عeRt|GVLM( 4;ŧqǦ&t'=)`꫁@`T!W] c5A101ƅU$ #T6*Ay:6 E ϘTgЁ`lY<Ԧ-c I(yfiÜh%=oT) ,!T ,].&挟_"zfegd'_ϥ͡hV?q~,=Oy 82.;EYPIOUqHyCUoOW TGX˙P;dmOpJ` |򋞔4A'3=A3ICpywn=mu-;ekjR$^ϏЏeMU6gi-\xcjL$}7It05w4Rʨ'$Iilڥv褓A?NUJ3I5Z"Rw5!z[Vo R0QF%d(`\_ ّ>xj /MY.(j An:-LXbk Ѹj/ -$Ph7XQ˚5}]X,pCq ʱdt x'h/)tiQ(+W`]!`IX`p/7KqAى {:>9P)#Z_mZB;J+nKsc\_K?* *q4^{I#BO2}{0>V? mTabSwR"rI oBZ\ k:>gA|ėXt/{,o՝i˂]v%9u4%m>*ȉW:|$!*GTElgԫ}I|N799p$l{J͡jzLk%N Sm3c≉dcԾtfڞZ[ }3-Kqq>?X(RٙTT_lj2+bvh,s+]6JyX> v=\c|#e,_Y\/_Rw> stream x}X]pW.V'P9l;u`lծ4h-ɑMǫ5X,ˉOe5!qPĦBfxK/d O#wήֺN`2ݽ|wuQVBWTG(yJ ~yͥ& d] FSG>6^B8ez6n]w4O7ﴮP]U `(_=5)Lo7Xm(0GՂ͖%uo4LY.<07\TɬȥxYNUx2-Աj&.#j&ͲHhŒNiim.;9(?!iXVjz,I}ťbi-o28}EnMhz4IzZHhՒO!2v# gO9gIQOKi EUU'{!߂ Gxe` oJoM5꣍r0`UPT+9pW@Xhdv=wEQJo\RHfR̈Vڶ Z@N_^n\rdYŐքª/ {yJP.g)'CXI}%{G-DW=[x:ٲ~}z EoL!˵߭)\ѷfk ptal}r?һ/hoϾÇʋƋ=;/w.~ȈVT衧m Q\o,#$ Ԧ2<1uorM#gvBw+WLT/dhw_v)+_ɓ;/6kj2{=(C_k,-/H5cf{ G }< INiqVx/ktS&y| 3)jT]0G/=3'<{ѦfAXzZ;es!8\rCA&ݤaL*ͯs$_Q!G-7j" 7qPӳsn w7խ0M\Y&)j6|j!3d7Ւ~|IN5^bf ?MY4ji_\݈{3 BˣyXyZG,tJ_ Jh+ªU{.Y29Wz -4D\|m?irVᆁ-.INo<5kg + M#+ԓj66/iF=JoAE鮵މn:, $_.b6eMktmVhAO.qA%h7ׇZя LQ 9RbC\QbYf%/KG "%N|~@/EZFV /$H^_'75ġ66 MZ̞6r , ?g1T{8W4cQ2$p==vZҦG4axi(6rn<CǺxWG}Sw[ ciYS Le=.Unix8m^F0#$"j. gWIC-iF.{P+BG̤=8hn'WF([2L[B=6)c QƳ# Vޡé^&u#Vä-Y'AaDEض1"ibxS0X[ItpKiͱћN`{Me|,ݤ'Nxd:,p贇/xJ"| FZѶfѠgپW7LOaCaky`rp.R*R}Ҙy'ax@8ݎwnZ36Q0/tÕdOjAůJ\A$Q RTS\Se4H| Mo ݗ/ +FsŠ};T mD:yز;fQD-rq 97 ,8G7Jƞ(p` #q,ULaZ_5}B8x.S'Ir_6MyȐBS 5wcz8t'c5IrH1Pl[7:0۹+T aB#-;l;x߰ 4WN3*=Ë4A'nxxqH*".v37V#@X>!Wr}Oؒ ԣ|-hhjت}]?pAb+&t{R|Z#u|~9B(F2yԢs=쩡0!3,ݫG)Bt!d4q\|$4TŽ^k]6$؉]̠ Mw빅 mNGɑd.#x}?!/ndCZ֬x?bpljK >f]po wq^P,n}uҴ˓bH3 p?G` xjZ >bUQѬ/uCmN}S/Miwxܽ+zރѺJӜsƸ<<+13Mkz#qZ XS-;twAXgcwֿiLmR57&UL dw8J[ʈWDA3p\2VTfK菻FuƱ=a5v&@! ݥ.^;Fr\~&Jendstream endobj 375 0 obj 3047 endobj 398 0 obj <> stream xYkLg ukWKebl ;;/;^,Zď.-FeullW5W[ɱĭ҇Ҧ$}J?3?(qs{S%sϜ{εĐ>^8!>+}Cj‡Cb5%Vڔ*mFxM}} b}f~rf7ח%V.ICG?d1B0B ].jV1#-¢z)M77xo8r.+D6$Hk͞hEQɒA[MQөsntwg0N42R-wՇYf#wdk5şH| d͌5Rxa$tfT,97zKs$1UuNDS8++3= (O,eZ+'S9W vCC"qj . ާE&S"0]0#`Wÿ9r$ɽx4goI .KN6͓ExaGq vY)xϒ4NXsN'k B-p}AغA@kTwzq?U4gؑu `tw *xXgع.~ǨЏh #d Z]W>w%awẕؓJ$*>"%/qC<{8~\(mlG>7GӗS*;xfu:oPZ(WH7ȸ(#(n f;eE hl"M" Q쥩сk`|c J* ђtuʎ%%ȏqr5 YBK HT>}4seBrЮNjP"Gmm3z5 = i@q(:D$ D$gr'M" T09G&N6wѪc wj2Q9Q[ d3w:Y\/8pFCz)ja!,*P<YېhL1`@i4_^&;hew' (v FG(@qMDw&pNU(:Xf,$H|:Kn{S#Xv ɗ&$:0ǧ7Gh^DuUKs ^OaS5AHA' ҌS;8ͤhBOAC*c^xBsU^*5hJ:mٵMp{Weέ("šɏC_Ǣq4Ia ^8hâ%0m?+v sq(Gc }aCE%ʦ*UEP/ph:КG 냰L.%5v2%+2a Qd iyOpZЋiόmNo&h8 {s3g dE2 e&8"̄G~ PwzJYְto{Xdf~J0 EXc/De# 탼Υ 2P%"IӍe#J{M)RAqsX+~!^ך-%Lוta\}qp i *](]A63@3e'd.lY7" %c[G$^tCHhQ(#n3y8.,5},1Hk_&Ppf% uKge聙\N4̮Ksd01R.vw1ggHLB-؍P ͶkؼeҮ*ۛ &cE=k{/$50KgCgy@70oMݭJE PkӬi*%)v&e;o}ðAT.&> ֖|)X:I聵Ŏ-BZXj/R' Aڨ%p`zFШ e]Q47}?S$*iA7ҋ:`ؔc_34ʶmݿmU#U5b%fpu_әա}꧚vԎJ`kD?w pD&YwreȱWH?PQm^DUBƖ lg^ۿ:%zݠ;`GsCOʄ^5 cvIA˄s1d #/x:22j ~ywe-endstream endobj 399 0 obj 2751 endobj 413 0 obj <> stream xYoL"1]Xá\$Ǟm0Mg54D1` $qZ󡩴njjEe6u_˾-<R%* w{^87S;^JqnlC;εwW997ͪUQw8IU-NV9DU?cc} pf\o/*[Kq/K#z8 W5bU@+p^ 6aN PJH!Dē &.]Uzr6PIV)C =D[z=˦ GO*j&+lIW ] KhJ(pZS|0_8΍sb.tďEB0$j  ) e*6G}j!yRo >r :9)0OeqL_IV_4Q9&tߑԘ8bh>S+Z݅@(A;80tPbK"Y,G;3=dC|5jl'A)w1@iNV*C؈FOx6tLuW ng4]辣%QR(r&t5N*@Ѭ(fi۩c?eLtry{khr/nz2&7E5z*~6ܷgs ߴg:?bg,VG3l"0:@:9 Rvxj%ضL=Wv( +yVf^r:wi N bTTOxpƁl ԑ6` ÊfG0;J$( 22*hE`K0NlJ_  ~l@=,t[q Wg I⟮ z0JcAX B [ t6-}E6&Q)fL|yt~K w$@չʷ]}~ s!,~r|]S^޽vIyz{38f~Kyw~})fkY"s=VC3ItBiLO/k~îgLQE8P7x'chF3`ltr{2x* )< "!…R&%skrIՊ-Ƈ!x/b<ީ cst*塵X?-(e@̣듔p8jrû@g {M"D:J?ُ(b `hZ /I 8 ]ژ+\}d= qTO"c8N0x 0jZvendstream endobj 414 0 obj 2968 endobj 424 0 obj <> stream xXmlSֲ\BҬPSI}Ợ+!D6lb!׵8<&@hHLюjuIciTֲ[y{8RL}{sܴ˻QryُijH7]armllvIo5wTeT'd->,L6moϟP=/;sUr*׺ew?rWQoO/tUJdO<w*h2`ُSe#bbO#~Hqgn6f^ F|av"`VglDi{N9=^y J@-ݧr`d҅sQ9 1y,"PE(Y!:#cDD͈8 O.!xɭ.k•ZDP\7밯Ҥ ez !cR`ކn@r=B-WQ8W%O+:JǻƢ[z~^m#DhƎw}Wnu[?p,]kknj-jԖVmkkm(䃼 >J0;(ñ51.L=+!%9tSc.ktfRZ7A(T{UɠPp;0s1]gp~ Ȅut[1K":buLyO!}zOt S6.0ʈ bd VW;f` ŲXBkiX2XQ(a}_YRt.=>Z Pjh'"?<|zy;d!Ӊwp\oS|&'@Qz2ռ2TSԄb "eygJvLȘ%M0*M ߭}E^J]G :U2[+C ^uoY4C#Xɚ^|/84bl hf3k}O/a 嵖q= wRw2PiM#:[D!}wp xmzqw?N/ts}n$PS8g7yw\ϧ>@)ۡRGi@_YcU۶统Vmª/+RnO+8#9Kf+>bjxU_Q':  Bh` &Ҵw^1婥8vB;ӷSB@$eSGՌ{YS𕕹1ih-[ -Ǝ?7df db ܳaBa зvwF3ʄ$jEj>dó+VK935YDhT3IPrÊ$\e>"ŋ+&iO*0bfs"m<6{[ϽhEhI3ZT&'7fPKޑ\1H@5n:vc7 j6JZP[-oy(d팍'bV|b{` 6B fEv 2,SkfL9~ -aCGb̩Y1Y@:ڎXuȏɝNJn:Un/үYuRG.==Kxk?rR[;kv|"WA>0q| 2BfguȬ߇tpZ2ɘO6v֝=HNiK30m;B6C/9ـJf5QnIDGո¬@H٫;K*z _ zg>g1tivJ7O%$~QUyD^ܮXE RyP61 # mIJɒZ`MN#P` h;!9Vel/xڳh= Tesnw =a:FW*9ClbJ6S}jݧ^: 7q]8C472n@L\v@[>'>;U>s"yw(X-,U =)GJjDGSiL]B5g5bf9L&Tn[14#60Fi\Ǒ@b!ޣY!Q#x8 t,EFcg(Pr aˆF3H$L@PuÝi`ldMxQ`~~UkvTI͟/;&.{sU/=Cvۭci E&'E6L''r֨g0 Ny(R";t.X1)@"|hBk"9 ®$$[Ň~]Y 'vRa"X(U'^iJ* Z_էmrT Jѷ+zM[AXHk0l~n.y)j9\OkI>y7> -ܼ 7'f릻~_ۘ Z9 5 endstream endobj 425 0 obj 2969 endobj 433 0 obj <> stream xYoS( 8̈́R)!}+!>"іoX:30i$ZB[u:}ԩLZ4UM6i hw=qBӨsKe IF-.}5WN3h4^&yUϜTsw"ʕ5K &RXވE R٨>Jk. =9vv=ΫӉMnq+8Fԝ8Nߧçɸb)6;N܈skEqҥYx鸪;cthc&g"|gӢ#s\9хvG2B,+Xי+Q;ύGyTVmΊN᝛gGtD'ϧJ":j*7k o!w^u;Lwq> |tl x,٨ղWZ_gl>F'iN V *6\H[xx0aiHES=qv=+OL̈ĂQۙRfh!نjDFNɃi4>gOکzH(}MƜtu,wي&~s&.ܪjKWN~2?&;e ɲLW<Ǚ U {rRK49?`tښz b"M<9F$5j:яQ @ DT/GB X*zVG| |<M23̦WsKy5#|?B+DGaM"p'aoR)`] ޥmzdzoyJ =Y[n?961j+]A)wuuB<5M$]Έ*=:˳a©me~ܸs|k0",4@ؕ1D\R7 cQ{֏շQzN))F{\J>Ct’SL֩t.ʸ'û\;#>H,-p:nU+$J"H \4_Bm$Yg14ڐXP1Duc"j+9vw ϒ?~ɧ%*/r<װl.3˸$;}fځߎxjĎ !mghYZ -E6ć$hC|1h_ Wn +ЏW$Qv.P)}%qs.CVaXYlb P̭wq:lm.*rK_Q>ʰ1ԣu"]'NkglX<!;BKh+ȕ'ͭ=Yb8YD3Jk=`&R-c9M2+K4:a` tp5M-i Y9^.+XR\9)?Zͺee|'R:>zaM۩UDyaJ& q{ķb<hבN@u}Gu@(.Sz4aT4ĩhPtK$Z):tKF,.bQ̃fpk17@Ȑiʠx/Əa7o C<7/S7}aW s?7aEn}0+pՎnraY{wz IJnLkt-ehfQy p:I2}&1mzOHLwgj˨La F{U_+$tÇI{;3E%`U-E\ᴚI76 Fm&?36 endstream endobj 434 0 obj 2961 endobj 437 0 obj <> stream xYmh'k6w̵ܝnC$վtƐ,dI'&d[NLbډ] ]Khڕ+beAR(}eۗݚ?yN\0{ﹼ$K28ֱ|{^gtpwPKO׺?_tMoH^;k݆}⏝}3IڿR/5`|wA] A裗YOT ikw*/ xȆN0-8*Y!˗OX\b6R߾F6:ߝ/S t fIk"c3UB̀/[x.҃# kT*Qu6N+&?SűD-^ XʆNa0PnN5M  "߶sIz_;h/׿rS'P$Faݬ?[Vu1r62VB8 >UfZvCHaS@&id7Wq;&s#I.~]̺@S p1tf턧ݪWO@qaCzET`qP7a|95ߍG2nQE[ A9T+zhk1Anf[uxssiZ.;`œ0'k!ʴOZZr2Qf43Zz / ~Rȇrmt3Փ@)AՑ2|>mᯙ|>_.)BebgIt٠՘a9՘󤾰f_mǵ%F54U̗8 wlؿ:1Y(RFU"i0mz%dmBI+1jB L4tCnzKNMb{`_*6aܠȎѭ^Չ08D$dd`IX5#4v}J0 ɭ^ ˜Qn d=[SUa>̩eujyYU4)"À>~ǵљȁF:B&Vgo׀A Cn; MWfٱӤ!v%aFtgg H_i!ܺ_N{0" $p3O, ' ͊idid4F#K d@%YC:x/eSWfԓ秓CNވ"[u`C.B)rVNy~]ߏ!SOɐ作;M䔼u|$/& CO MBy뼃/}5LQxU0tW!3 a8Q-9%[|n='\ k +P/4'DX. oTEɏIs+,ڨПC8Dxz|#Өr8 c@> +&;Rvg;EEh ]ׅ-@qnoo0Z =)Q@k*8)uʰn>.#΢蓝t>sFF e`a N L h+IxwT7%p3] ^j*Gs:6}G>zX ){Y"W^d@H鸞 V+s_hS癠H&9ix*NT LoƁ&aGNQxx:Q>+a+5t]-kɋ|d?BH1;y7<jBIj ѡToPluGAbhh0ކw.hQ58'y)YyəZC@<[J6ii?bz6giGѫ, * $, ,uz<Vq=Ԕ]L BwwDns Au2fڽy9蔏}d6G-S}8, f$=t\Q 48j z1|gm݆g({s= {-|6#-ZojZ4r5 Q餀`\ 9RLNH]*9lLsL3N(H LG hgؚ ԢRz'vёPM(.ex=r{]5Y3鳵q'8G_ЛU P ̮BB,_TW9D&//;w^/hV5zP"P@YE_q>15AVcr*7.kx|Z<9-L% KVHAFz6l+mñɡJq.~`&~*}CIȕ!Ie5ZV˛Sthז7MOwݮ[d|bEqGI﵇H!CFۋ 8Dd6BPǯ9ɲs_WCyzx5~SdN=6WRy*4~Ry|;qLx7Ov STIQன%T5r,#F!% EAQA)ZZ]u8"Ӡ~~~N~;YLُrmutF8OvW\i*sҽxtW u_36,} ;e~"endstream endobj 438 0 obj 3098 endobj 448 0 obj <> stream xY_lSWd#uA wʎKZbϹ#{@EăbB M iEV& :m=VP&MPa{شIC;!@>LHM=~y|]~?\K翫0==oR5|]GU.nxk{< [fLKǿsWk:$߿w-9ZI3uh_u'|' cg*EƟ۳䀁փ? /'N8:) v/XR8}5:MjuJbvcƘ‚`ft.l$<_%&]դ=R4=zuO.o> 妡0(I'c:zs^Bs;̹R(PhJ4 rwWZ{Xe{A,װ7\P>Es X,pPg'ݹ<2հYX 3*Pc<8o.ՊOJF]fL+f jhI(F;NtBfHՓ#PGFIauCQEemB(4S2C4+'Gx XɏM|%1?߰bF:A_TRMіqnE! 0OKV.f=@a3MNJ}Nvgz&;j5 p #k뉴7'[e_m_~s0vP)u3\ivk'$'BNƕgreHꥆHPHVm B֢3ҳ Tu?hl91M 熺. !6o)$ż73wڬ{9|j`,T'I7fQÒWeP'時jDhr>`q4pro$Vȇ(8JH~, ) *CU+ ob:}lU&_;UJw.>:,彣7{p;om&v}Xx-rHdޛG^j;hn!XKE-R wA (!AF-~B;z/PռVKvaU 8N-ՠ<<Ĺg\V^3V&ZTi!R( #]Dag Dy$"{DyT-\Xwzǟ |6mSb{a[5),!(0`oFo >{'&kAĞݰ}: _l5U\Y{//gK>;*;#X'8#U|PA\_7Bgk°)'h{4XXA4*s?Ջ`$'V:*MIW@8¥z5xP5 JW³2p-fl"#BOGzP2L&m#o])cX#dfz[E|ei^@ah\>.B!9L$,L3JXxk&1{SH;AG/4xΧ*uϥyx2]Eg.XY@aA0a*,M܇.fANsԭNn74C]d*P7$> stream xYmlSitqBRMZ4ع~Ύ?GېmX͵Vau5 FhR5MUT6e&o+ITg[usﱝ@&IS~y{y}s8ٟ\kȳylnեʜA<kdu(l-4MfZ_~? :9ɛ?Zv@(s W$ˀ{"Oxju;<ӷ>LMr*}$;ѵp:z0ޙlX8*j(y{-?˛({n>lEh8d2OGޛxCTwzo&NUM^-"nm'/aȘp̔*FTAf3BB7lnDI MW )D^,u5"I};}a|hIn潰ͦ Cxq@$ٹES@;3lmZDf3YO)lr: Q$Dws3"me&SGe~@ S؂E_%+(\v$w5Op/2e>읃|If}P7j6DB9dlv@1h4C c)1>Z #yhl*lW=ܪ<ՐY0cS Nҋ,M]ōmE`ty.yhЫ#_Q+qHHQԍAo SP%?_6˜:l@V)&f7 D džXeK0@H]ɼaPAUȪTעe(U(tDr87rs!@ x[ $*J4 |T +8S+|֥ąӗuwov:v~Z?3'mٽԚU NhpDϗ**oDمfUZbv}ӎ/ſQ{W!˸tc͎pz䩗(SK NGȦu]@3('fBz+&uKog,5z٨Rd#<5S +aC/TOv]b:J)87nbJvY:jȂ>ƈ$+v &Q<߬f~_udބ ^!XX9o杈pQ~>Ȍ7*N83Vdf Dfa5jFD7BDY ЯP. EKJk?cQ;T%8Ң\ enQڱA\P*Τ#u t~Zq_urljx>gw$v_k7 w7,i_sZ7nbل6!DYY [K"km#>bKJOT_t GPYf,.X(ʁ ^jPV~(m2gl}9]2 9,b,¥Rz ֣`MtKc?L/0K8WOҊ*28UpdVlQE Zy9́$o.2$٪A1p0RwJo}sS6Fw>] Hq^Vx(ʺUpWd(QqV"~0Z|pf OJ!mReZ62S֟NCXf%)2ah֡|C.m3gqdV&~Ժe2 w 4SF@D8a\Gc;k 7IoT oZ8IY MI2@ůb"*aaG_rDӄbfV{Xwc EȠ.KWY-DeTt Rx}I:_JV2K\WZ}*2ßR%~AC7=} 5~&$]rUɕVNYM?j}ZAx- o-_|^/Ri]7/{M+H=KoyfD 9{$6쮩$:Bxwj ~YvWQRƸQ7?Ka@\Y<(ח7~hv@/Q{ONDR8[Z|<;ĩi4c3(8*p[ux$dTD~ Dӿ􏏿RRy[Z6=x6QWWyLzFR6JADַ}붎G:w=ݲgۈ $ k#mPҾwgk Gw{e1ޝ }r ggdgqu :D>$28ӡj^*uo"]H֭.׎mISdI!_Bx^ r!Mv.~dJ!uHo؉F.խ )Z|>EELqZ8";){?L HA׵YhySĨk`Dw?$Y%C0U{bS[G*@E+5@Yqr\~:lz+Iijn  '.rTk?!w%w4 kGjI;7lendstream endobj 454 0 obj 3251 endobj 516 0 obj <> stream xY]L1)ZCj@^,`wf̮ viԔ"!e{cwYb;mc![K8Oۨm*/nԨO}j8g~v줲lعg=;ι묏 >~5ٚOgc70V gkl^KK>EatM絮LM@3 fccNo:Caֿۂ ^KQs/( x.q?K(+Hd?,>x(L taɶis`_eK$Ra+۶MMP'>=~p6HLv7 =TcIضۛH?ccom;*ō$Ǧ?g}I?w\FжCy{Ibn QkV&+NFZ mW;JXCPAZ9AbjP (vl+aIB&(N.^쏶ʉF<us?9J0qPrdݵ{X< {<9|"ᔕ)hR.>v 5$Caχ|5(?vPۮʲ' һL+ԽN7ji{W-]C'Lso,SRRٵE_:~{&r ?ac5-U<aMebr6 \NKdŔ8XeKY}RyS Oh<{MSs9)&2ZM->Ij &.ɥDv2o.j*}%Q"e/ݐ;3OU"嶞\NYP"śCt=3+ۈ 9خ=zϖ6* $M}<I0)&[Q;Wkēe#N'/FU-3 AS|/1R ߨ$6{CQPAN1W! Y +a)m:8h#8B758s(_oEΕ:^a{Lr+o+B%"uqpIe,.]Ӗ!9Hǘ s\셩Dr Rv8(G 4wi-ѹ <4~ΥP/.!q(J9Y`#xH)d`.t2J-z#[H3IO²)rшG->~= gN[Y#9}u$U- YRY9tcJ߃4f'|mvnKM56ucLxْy+ye2iؔ.8 %-׼E(lJkD] @<͓'/@.9vWaⱁb Df дm*+>}>yb$lelF?ԫZ88}ͫR똿m@YAt9 &U0*\ 1Y ^LXo/[oJ:} qp'(9a╲BD# _@Yh+b|Mlb/Z u C.ZtFi3Op`ɨ&"t8bd=v6@ BR$B ċɂ72NG9 Tǥv|u@&CE)QqȀ$G?eK%'Nj p[v0-6Abr6GO걈y"Q] 0F36~zsJV'0ݻsdSP, r:1؇ 'جqTb%HHD Iar h'nƳn[x_0[h3!~ ÐVLdI.z*{)rY[y<0g.j^> (uX@51*> stream xX]l[gQd4I.=$u@# H30;Q5$M̭PH bA .b7, p\q NIp1^y>:%݂>uߕ?:Q- ~,E%AnUu_[w˳+r1Ͽu#zFHB:i4 'j!lQ2< 8{ 5U,ñ> EFp/e'ʤeݪkx?zq6n0Ά|>MFqyW̺9({}ؼ2m׹;P\#]PI(ǎ[:wJ8mtĸ֤J`#U%{_(NGA 5 Xeh &,P8A'f1sBg8a..s55L?bCn2~L n.߫Ϯ/}'uib]J=ezfU Y.2*awG+r{O`2UXGGXTj6c-j9YчGǯ_>(~g_W,:o‹>>?3*?X{7}"0E7Yء ' LZ0qOxޔ|*F+U)Ȭ>N*HS aF_҂ׁy'N|!f]b?0|yllyjW4!Ґ\6Īmb鲩]w<]$eSLo'v߮fׇ'(ݓYbqz-lc ̞9 'ڇ;HMpV|YdUE?`$ Eb VPcë^IOthd\VTퟩ6l՛QQ5eT Δ4JEiϥ3psrLGύNۣlIި^`O@8"-)Q023`Ʊ`9Fn"Qo_%MĬDHܥv̑㠖 5jk1g+b'); :k?ҝ{4r~ŘR؃HlǒˢXw];^jsʷ}惋ڹ2ul"μ"D8r d[c>-CE6,83^*Zvrϐ.ՃejHQz+_\*sgH˲}sю4UzΞ{9Qe}—ȿ endstream endobj 530 0 obj 2774 endobj 534 0 obj <> stream xY[L[WXKu8)3iiH\6͌~z|9ֲx$6 !F!ЗeZf[UR2Ma} h?ǎSU0]~Fs8'~"տXcsquԷs@$Qq}e:mmtG'c|r}}P?YU^_m;gv%8;|zqt/5|][}fNIf>Hr Cѥ̌ޣtq:(M{7fyI\<] .Vv:]'حc㸃}/~8}eKnPZ}EEj}ݸ=|NM)&iȄD>6\ -yQ玅 yÎv~I/jw9re-Q6v+WÉ *ʲd}#,xW9\EXI- / ^^T w (0}ůSb'uI/k3FxϜtZ6X \>p\I.|\-Nݿ5pC-Y6ѵTmRK;~W7zxt?8>e2E0S$]݂&"0QWPl1$+`xsN'@}^ 'RC J;/_*|y XE5Ls>*͔t̏.XPXUq ǩ7" b2cDd[/8?Ҷ7[סJ̳Dx,֯ۼHhE]2|O%RB ei _ I* {mTl(.`%i/9-* N,tS7D;i3Wp߰:;O3Aao:đ'Ý4_Vxu[l 1_-)biyRO9^Qo3&clc;YNsj'33:(C4Mb՘a>~w==qfH-jmA[]fjO1K]݌NW?$i\5$_ YT\$tC>բ412E6ы)--iva@ZktwR2Ubpq*R)HϺ?:@Ò~9B\"ZBk4uQRwM4!qUEUE;}Nt#53ATc`Xj(imʗG-8Дb5K_ϸ^^rBֵ̨1>B{f7jom׾6)}`GݤNhUmgq7̽C4Ү]oag+n Rb075EI0c6\ k劖aH\k4"҆'y,ɠJV;0ȴHa(x}!JrNZ;f4Cm{[ՍY^`NBdSvVEGs>=b'x_a GO}냤c0뮀_HbΊYڡ!/aLz ;^hYhP\vڳL={d~vul3{1-C61ｬ$ooڿzwce ؾ{ ][]z~o4=olrv?u:Es 9&aMv,Ʊ5ͮ)ܩ(@@2$25(_m52p~fV̔gd|@9GؖBIWق+ʈL;rm5?w wj͇E!Du%$vˋjX8xPP({$>K Pv¬$R-aep S <'UŲ8܂ԉ)gN<"ȥaV6J5_x9Hvid3J^5Q`kPVh͇f^ϩaL Rc .Rԧ AD's*&1OD*$s4d)= ' ҹ.gK鴞n/&4γ2nO'| {{uG`,2q g)=)<a'mUe(EhJ9 )tߎ:6bD7,f)yp`j+ v:=Rb%2%Oa%ɹ +2N+qeI2s f|ALmgJf&15eBVz΃S.Nnquc6sO̚QN}|XqBҍ[P,#P;%&%:Q7̘8#q<{j2rmp%KW!0)M0a_)&Tk`I[9%xS6LDxrޞ{zkjN>p[oџ~GnOɩl]tZMɶ ERs4XI p:1{bRmD(ZndD8$=cw:qendstream endobj 535 0 obj 2724 endobj 540 0 obj <> stream xZ]ln ETXqdZC<ݑ@PzjTIH:!lդ)J lӕ(F M@*KK҇M;8GR۽ٙoQ 1}]Ů;տ}TopU?A٭*`؝5T3&BLK˧.4/nog{o)*~Cd=A6?f{'e7Fdn_z̈&7hmo>?"Cj?If1ljMT:v8CWoo2'lO$*8BASDŽCgn8G ]o륯?S2ݷ{qSk\+ |9KV9ojMDgՑGw](tw,]`sB<U5NV`gw.33 x?[VjDVO v$Nby#[fJ, }8cpZ&hZ -3eN,#Lg<1-hhb~ F*UQ#TMK&P*RfىiP&Ϋ{jxx(HxdKϛMj5[z)z&n/.ԡgk_z xu&R}v\oyT;'|j^HNP޹+; edJqT-2&6c+:̖Mle^"[t$B[JOM*%Wa ;/Oڨe+a=17ƔB%%䒃`$?>۸i;b qX$-8m gEðظi;t Xw=]rsV5n *R%$<>qA,#DE"X#ӟ^w ttp#WN  }6(iZM;5Mn؞7\Hu!+>Dr*oSq9P 0߸2$P^#zR@b7!mcȎrR1(&4лvsi %F.è<v% ݈8/c??yd n(| =p,LFzBV d~ dygJ\v%Qja:jE o8Jp#iLOs-I ]?!d+NQrJoB)2Њ7 $D,8u`KKÐs)$xc 0<̍QFhEp*۱ I}BVH$eGŊXdؠDr2.U'IO{8)QB 5v-ѲWfY=Pl\I,pG!RfUZ1@Pf탂e8"Q ZLD59&ZBA49:XM' o_ Uz@J~AQ~KXi="4d=/S mK"νՀaԵy^@vJ~y#8qhYzXlR2ւK/}my3 E<2i œYO쓶r3`0OHpiƚhJZ=D 3"~j8d̎C78!ҾU۬uss0jjT "^!mbe' {)`** ĸءsbj"Us&!VeY#\TRGy~ePUX6^򶊑2@],d)ș!AƳgB B][mߏvS‡.endstream endobj 541 0 obj 3219 endobj 547 0 obj <> stream xX_l[W:nBui”;ҹsYb H+&} Y6U1DqڴZ =E^++0E @$xι׎kgm5<8IkMwiah+8$HwOHP]SBtWk'` s]bכ6xveU(S, Ug]N")tvVxj1A2ƓH6Ehjhm*p{,}̺5PCQa(,:l>]9$yVE g *YX />б|z3;}'g"ۼK_isG4V +'n3{EŽ:ƓItJnP ~: 5,r;XA}Rdou>:衫ǩĐU~qwtph[1>YxJٯ~~WIT@ˢӦ$Z+qq mx+DOb7 :W9 (!(p?C;E՟UJϱcdEI8ߞ{3w6kOoln$6g'f"+Whl߬`|. v&n _}(}t{h; 衅:X鬎K:F ]l?i tj:@1 cv8=r3RX6M@ ȓA!ܿH^ Z.,ik5?0y9׼ iιڌ;F@nӐ#CN0ERD=`#S(I U|8kѳ2p5,.Mk50.7d!`Ľ׃iUb r[Y ^[zZ9e{e`zr!\X1/ޑ6UxRX_y&_FS֌>]g*a>]'?32H6zaZנO`7q(0(Ab7Gݼ@#EHC'a:nBiݩ$DpR1gzZ|-,R-Lp]Y(F\òE .v,W03I-|gwɊ)9婡,![CV2CGmO]6 {ϣ)y?Ѷ=P rDx Aj/TR2\ġ8Q/ :o 锵1Bs>NR@+87a;Vh0B0N3|1:wCO`z0{`$a8VdO5Ьa'=!A4Rףcmj[-w(]qluY֍G)/`'ѣ-Hxﴰ|! >}-~fe-Ga-N9a:bWoxxUd XIdT[Rz&GP3ݶJ"j!9~Bri;䤏4ZQy:9V~6  }jI *灦irَFewL/Z}|;y܋{w6jsjnB˙8˯IY4!M@f5QJPl<+-Xj N٧wIcPQp/}c'ƅwѿϔendstream endobj 548 0 obj 2144 endobj 552 0 obj <> stream xXoGc rTpmEqo,IW[T>86#*]HJa+Ze+4X&Am$h6Ko qtvxдܺ(@vwfv7$+>ַq5ۚe"C"EZ~x~Mҩ"gZ]׏E2sQa[$'lwosy_݌mmo I}n.[>"Uɭyï}AbFO %G"i eJh 5<3|1!=e +X1n %Rٜ{#+ـ/-m09H޹ya8+F;SU|%nB4nVb 5v52|oE(l<W nNq %Nݯy41Z~qHx?zAʐY kSw[XU4bL0-+Ue. N˗k`Te˷}d wQI.\}^ %f˱kܸnM]}1Pim#n %ho%ZƺGna 08`VFs~UӠRSG_=ξK'W{O~]uOTyݿ$^pa1F2K?z%-Z$Qʥ^/#RF hughUXX\FyG\L' K-HL"Uy,YT >â<KR9vga@ye6tqa-+Z'"C[2#l4wbA^:P!&N`uL.b}Q\O~XĶc&H}J*BGp(:MVh5~jܔLy}(/shg>J2a 5J9 +e}ed9k]$^pe)```{k u9[ߦ>yN~?98~hMZ ̹5E..alE?o8/7_G7<7-}ט r c]u KT@O4[6 l0RQu/ԛ܊HJP (߯xR3.a0ʖ7cnxl(3Eiuћ@4\jn;D(ZgAB;n6 `u~<sߺѵaR}YJkHceSK ̎SH F71 P.?}7, <#ʤ ggB5Rv-znu]d(/<+i(Y IZ{)䛯ŃahV*C󟳕lb(e\"}D)VdjȖZYND+q~/ܑ R, v)`C^N7]|$ @48^y2č@g~:}5֝ըӸf(^wla I ٣*dc!zB Z 3H2$j|^`dMtۯLN!ֽȢg mhl`ZEkSWOtogT4%]R3_-ae>m$T 2EqzTt;)6GΑ9f`R/A%J)hhL QmŘ6$y5y`So50R[UFEβn<{8R"S$ŌD$>ߑo7zS|{ko`LV峨V姑q,U5ǎt>:MV.`U Yj9Y4Z N8O ׬NZ$,$1 Hjq_g@s)ۚ%B%Zf(޽n0a8zOv2H`;eA/Y(B ]!(;0c3PuBf`'Jz#\J'02 5Y/ctpg f@>*. ̕+T̓<nj$(1ǟ1<ơDvxA`$LEt'b#7v_r<⯎X# =5AtOى-. ,C@^ `h,|a/ 2g k8>[ nd-\>Syi1%]rx3fI,(Zc*0b;f7b+_endstream endobj 553 0 obj 2359 endobj 558 0 obj <> stream xY_L["C)! mdTQ׾߽wBWvl(iA<$476 X+5 ej>lMQԩˤm4E4{i&=~3^>RI6f# _c-uWdԴ]~?Y0z|tY7?g my}5?76˷}O-vnu|a;pV"x%-2Y=rcs%w{ذY.EE~$s#ßuъA?ݹx~^+GT_A=mCxp\&dL\l c`$`@&[\A)*,b¹ ,4MIzH-E|ﺃȡ36H{aⓟƈl!2\X b錢Ez;Zl8st^J]  N#I} t&][.:aHj`x9$ÎlytTxzxƙO:4bkN\֓ ALxl;ѵ(6stF7W6]A   : [R6M,e8q91qOJfpId 5ј.Lm:œZFH. vFpi#7@ n](GfR3٪r&P@3-9 c CGBvaL hBnuC("@ D1S4yetαvn5{QET :XrɤmMtG^f Ei+{jv1]ZZ|F3͗hcy P*V5M7'*wKIp)P'e_BL\$D&xy.8FS:K?H4z{F0=%R|/(WpKEv5wrK{HDE⩙t A=%УRS ҎQda?ysW VQuLK|vlg9_S)Q?TRF&O!W]x*sy-6x<))ܜ`Ia#^d5% O6zv %-V}qr^HC ZBɰ& \a%dRD6'8sZ_BӅ Y +_3 !x)N,CAfRg*.=sfᵺM=XrhƧ8ܱ rRnෞl~Ojpg1>vuR֫"Kj^lئr5-toadK$ۨ2Y= ntG6^op)+mxDrm=kw؃ݧvglMðu納c>.hK+@j+2 Iȁr沝vsXvxEт8M<\ƹUCOPÒld:./K_ q06紙ߋ4qNgo+?C ,w ۲{I*]^&h$0> h[-8eKuod~]f!~u;RxOrOv@\ͷIFEpd_VA$U+^e$Ɩ|w{Q :lDԻ|=]ړ4 iQa@Kw]K<^"XCdz0}pW0d^)_ua M%=EW7G.hC@ 6DQ+X\s]Eis9 =W 8ꛔOP~ #V7z}:4f> stream xX]lYֆNhhSKJLn4M*ΦѮDv˙u+/|Mtt?=r5GpGfIOe .&4@+~֨ު񓥿kAT6笠kp?a.[AM37񇍵y ڑ`R~;*a^IphW[6*)!\ysYlpZ \ԫp2ᶲC'Mk!krhfCx U[+sBdD5k%1Znudž[9Th§6CszH ĨUL45ߡplz2Hyw$g9V8ino7 R b6$N  qw#iW)ENu٨_TJՖOZrCA;)baihQA`oj(b $G Y2Jy*n aOo,J!q7$x*Ű@X|b] ]xsPҟWh]ٻ㌶"mĥ(zB\n,֣/J)YIP5ichÖ$} N6m3W~ }_ϼqcoފwߋwƀ_V e54^AuJ+!V~jJRâx5ZgKu#1 Zޣ=25t`pS;ac{p28+JP1:aoh>}:O*f PxJu Pö%r`폀ԡL@3Π?Euhk8t_摼 gN4iD$mql]h 3]ij4ʂ:tdsJl?S7ϵە,\Uu%^Zb-:e*{*sz3 gsޠQV8P8ӓPSLlB#-PS3]>EW+kQ!wy x&Gq(т1Ge=&MF;Os걹]WnN]V՜HѣjnAʎ׍Nx P+# } 3-2.bӳ$,Z@vy9htO18i2i*xIEw',IU0BiG !FXHjh|{oec8$*| tew#+E,x17'YB#c,/[K7r[c@ ;uf^ 4 :}@Iu^/5ݴY٬6n5:-F-xzygc|6D=z8N.P~C5-@NXDFrR?,LƾUvgcN%qV\}8Rff 3S}0K[{ýhT_Р& ?n2 ghxå4BC3>ZAGx9%{xr*F %BEw\Łj8L ޑ ;A#Zn_3"zxj+sWA&lq_^ ={^pk3K:ņ;X;s=1FXqMN7aQendstream endobj 566 0 obj 2698 endobj 574 0 obj <> stream xYolo!B$HZz?拝:hJ[:vZVǁUJ j0MLjV4VU&M4K&֖y|]mB$>9^y~չ/g/sWǿ_m/.W+GV Pxz?>!/, O=em2Y_efy'5j#+5HD3DlyXĽ ćdd<xq:}½K k|'}Ӂ7iIߩ/qCd 3SUKITD/>!.)zsf(|϶f[{#-;{c H?a]&Š`]FtV3c̚YTH?fe=RhuDY%\aH qF:u~S16])\I8ȚY@Rheٽ.Gٛ*D E.6.r\>ɝo-T)$g2[8mQ#E|o%Ɂ]r_*s). "?GF/rh![S^!K\l I?kC}+c@P\ 6\RƯ;8Mo[Do}_?/nmHP k 04 Tdv"\"")91{Z0. `Ѽg&C@M}R-f OQ#тI!Y`I OΟ~*։|:cz?U.AǫE F %@[cvi3:VL켇ygMks}%5rH;$ߝ"w`_鍪[vMYc4{{Ŏ`Hf"?d{V_,ѽʚD4Y[rWC˕Pu2H~ti`\Urec%9+&Ueaq% _3GF:Gey{K _tE\@Sc/=HlR龦M={҅лHxm`,wy΋*Omf.ܕu^T F׫nl^a&fS${z-@{'{A3aAX4 Is'^Y9 >.`\t>qɋ.3tBpNNN ARC"dvͽ_xh[:^ox= ʆ+3* )IGMRiED}~:jeAd},syYٽRJbNi~.HC-Wlj$9sԘWS*O'=\4IGXGJVQ[9ڭI{ u؍Ifp6+LN~=2+[cNc(j ]8R䒤re;My笌g|CQ;?żm[#ʎڦxih_`KlOYXs~5L<TޟVї7&q@3]R8DU#o;.2Ho&rҟGgry|GҡXI[z(lpE&7tSmHq՟+OɕSAMc]gҍ~n!W1Ј# ݟn}Ƿ7]2_̹̥D@½5 qХl*v҅y;I}}h7p UHg~E=pWjgKʔ6Jpj7w KJE|L* |yd7@ތ!B WBx^{YOFx(`9YpA,W3E( <=tf΁T~-Spp7D> N-endstream endobj 575 0 obj 3500 endobj 589 0 obj <> stream xX]l֦7mOP &?ohYb6Dn8c 6NE&!dAR]PVyA}A}kPۮJiϹ3:BKe)ܟs{w3c1Í #c֗~oYFkj'v(oS1'Y?۟ll ۗ.]&[Wܿ\38 ( jɯ :l7Ϸ͟Qs޽R='lgXuk3;9x<|zo>TNV/ `C]nޠY'Ï''m; EYfl7Mϝ~ßA8nC/6tFz6'0ƽ!jf{|By{cm=LmO#i'Y+jhdg'~o $'cK^ǟ]/Ia{;qcu6 Q5FFb&(X>mqqk?_* LSz=zO"'L|9d>Jh9NзjA6pZk4Q6hRHu0Z?礤"%| ^W{`WXmX%J3Y6vLT9>f >pDaK(2bd02!=)r0GLQsY*2)6X)&+h$3g 0aait28ʄwLR`svlCC]LQ B`d %+pmʠ̑8OJ/r&1Mυl!h99Q@= 㜀P@r^BuxQADq!.LSޮ~B=R@#oԒI>԰NG>fآ\`לet- 6j N7rvfx?[\Žln}nP$r AAb(LQo0zG DV 6!uf JOZs#=l 7!7}(AjIB㊨dI!E6 k++ Q"y0N"*~WxwhW``A.Ɉ6a4y-`B3RO&€tkձ:] \ec CR7v q Y9yΰz4oH9}DXdk0 B>>u@΢D /R& 5/C/azn+]REKk-c#/AߒV!91$)^z !эTUۉ|'iARrϖ[`rhA``Pp >/CrD Q 럪Q8Sd-0O4 s+NYy9&iCebF>tՈ+JD덂I5@&"i"@u@gt4'L*k\Ib#TGA^2a( QG[v(nPQkڊBaɋQSLm pTxmޙUw?_]=qevNIP{}BXI's#nv؅Ϋe9ZzM 2- XϺx<6> stream xY]L#V&b g~UU_ڊhANjZmtR)ތu.e<}+Y槤d^mTÌK;Vv6ة?7vKz/ JlLD|ќN j&ݳ2JKP63Ls겶"$LLId xj+/ayg׋A!U=$ׯ@Ll F.T#%sJA5RQJ-CY!62`̌称I=,˄c̙a!`ɇO7](0!rVO3l> )0??e"Xd5%ּ:23)sI/f[K 3ERI";-}z9|0~ϲg05V|YWp9`==ͥz@]pKZĹ@ /q)/,;^Z+l_}ywĽ!^0{}ƽ!%1oԻsqß"[QJf,k,%ݪ~@7dEHţwJwY8h|܌p!](E>i%HJ f o$UO! +~wp#ͬ+H=}ь9k*ZR?쐃3y<AQfQA5.|jH;ӔZHˬuҷQ, \P㑱ŝ>'!a)Y#J)pf,C醚dC0 @UKŋ}Pe-P )>J6A\@G(Dʡ*CìQ5vn ``тr<'użE{ QYR@H fGr(HMˬ"#*f": 42BZ#YA6q$e[86K{KqZ掸,~>f\g~k|x5y9sw4_oMe;2G4C=fhU:o wmp1?l#WrQ8Yz%E}]dPIWG&JŦ!t0jw>x~Q- `owl2C?%)T;Hd{[/M`[ ?Vq+"gdS)kq؟1Xլn^|Tr& f'vQoZO FI?6:fzyؕʨÇ6D^ͺSV j Md>c}Δx gKƾ)' ]s OU?3Ŵ\}Yb>rNuˢY R'(OtʹduPyO𸻳SnLJ|6ҿacendstream endobj 597 0 obj 3357 endobj 601 0 obj <> stream xYMl,֒H%w]đٸ $Z ,Dlmhr ٲLX"QhH>4-=/i=(FskOؤ j}ovvɷMٙ7}Uؘ,vNvW̞ҡ$K?Fؘ)<=''7PI&#7_g/lퟎqYTbnFҞfgOB/yNZӭjLکLcm__ϟ1)CS$ȃ" d}iGâRTfd]^r.=~ötؖD/ɜUUːdMX?,haFS3tKssd8]]3˂.MhL gnstҚssħH|q/U cd]H,-Ȕӥ<4Տ trDdGd4sdݢQC^fơZU,Ͼ0nwR7Fڄr<KR^, :C ier\߬V6IԠ4sXd!mhgF01oT/&47Uw&k koB?p,G-?Ѳ?;x=kR/hP(ǾV~gUaV,iIO)PߎA4H6Op% ݫ, Dǫ͢t]m]'OlrqڼC>ȴAHu%5՚ȉd":YѤ(:xhLq("~\8xN=~|qm-@+0B o6tER(oTPdz{>{1j\V$ )'#Dꂙc .W:d̫mV]z: 5 F}icWlKM{~ d@!T8 qDWYKl}0[gfDfѫLCլX+@g7n ,mڋ < Xs8 "z t[^JR*kjx15XLT+Qftj4_K[%Y=,> Uՙ>i#mJ;;GS#ݦ[ {@~өi[Z F}eѯ~To*Pa%/Dy M'sX@7 Hi!$l7E  tSۦo Q3@ v"&ԇF!;יc9CuQ >㤣r c{_sihIl":z`<AjL7(\>H1 ÔCaxK&=iدŶ׃UG0zzZ+}H[g8@ձ<ɦ٪9t{QkZwS8W"7q”qPI=$@rn%ǯrLAԯFAҹXfGrx9[rGVX!0"3[M@cVW^'kC()fw+vCz;pOW0ٓ??nb)+B;v՝.Y30r;^nM$T`諭&;)k 8Y (ԲX1!X"W0^U,_ pwiB]@Ji|ǝ(eMpք,`nT$"_6KIoBF={77rRMv,I# |orY-;O, }#)$vىKPǤc[n?%:?:?Ϯn Tsӳ `ZuSsޭbCWF&2=~;fAQՎ,\{ 7*ރ@+xИ}a*Oו$9:쯇!yK,]"^>TT+{~zVyDY&&Wz7_GKS{VJ& 7&A A%ddrBe9};/š2졑k wx].'Xă?loPBoQNžz%ƌܔ@7qEgCw8N3P־_p"l̿7;Vl5Nf`:ӌxiGfχv\\  ȯ0'0YE|fRA7d{5endstream endobj 602 0 obj 3138 endobj 606 0 obj <> stream xX]lYlƤQeHՀ&mֱFNSUB68vRFI64i/QMF>l,D@Z j[XG !~q;㉯d+Ox}|޼ sZMyQbUXŞ@L盪C=إM5IjMugۻg/|=8VkWor߹}ߔp8ɽ߾w}&)wnr6][ﮡ`K,69Da7' Űb?~ ~G=$#wv`ׂtd}o{w*$Vn'!Ef1TNBj5 /-$eŖv3e%:q6KXW5'p KEd;RAĕh&=/fJlhs\AYjPͰsY&E}k4ͣG/K%+Z0;=f/[GW>o԰6dxc)>l7+ Q#9@KG8GJ|!s\ʗ9.yc3?>ύKfqFJ֎tU _;VD]_r?[}G& |9%,m{[ xp0D`B 689<ô"H",%5ϬI,Fj2]eҾ5g)vf|̬hJΤ[Kep Y̔ yGsB\Wf:s.5J|9{ 9.eZt-" .ڿ2B;` Гj '|WWphSCǮ ,+&2`5EI*hgjOUm^8,UhM5!Lj㖶DXV OcV_HR+DsXEu7ݟQqn,Zteф2 P@z~6-d#žFLN8}>̀k^'h!p 44ЕznLJ s53ǡw{ʮxэOJ}~(H6Jj'~2Nqyi1GGJ<ZpG,ΫSs팙+q<mY LNEd;Zd EBQʑ-cEjyfLձ+F^6۶̬JV Ssb>S.4Ke-gz/sZh4S|K/^u<ԫۆj/YXŻ\rTx0nm %j87|M(9Ȩ.2nCKJ0c(ZYtN prCHR`LZ!IBG.d@_rd 0=?BN5zPYvp.X1cC -0,۲%ѕiqvIsӨvm9"C,חjn%R^fOEz_;hkؖW$kIgj[rNc$g<>?[DdGN+tqzZ0|Chǹ{[E't k-L c*c/\k2OU(xNnjnL = 0dI^=odIB34UKh\!u>JǴB`4"cbN*(70ʫUuy fZ(%+'H30qϝ2nL-d{'m)\is7c mf L㡋tH3Md/и6#\4;ZFt(E3E! 6r`ápB6|^f,;}o w6pԺrQ#lЅXmoecHӍZDCWx=ۖhۆEw$k`-=Ի ǍuN]szIm8iPԵ#?M󱻚^Vvjn|![ʸO)BvsҜ_^:wA#n]s@86F'gڄ3vQ cBYl#˥پ˞X%ZuV~5y0MڎpWE$׫m8blA.'5]&2vX 0Pp\+KviZex!H-SƟ$hi3[;?'U ԕ27)ǧgMoI͂W^v8}8WbjÁu¯n\=1|ˋg% K2%/5ѿ}endstream endobj 607 0 obj 2821 endobj 615 0 obj <> stream xXo[Wf!t!4in'f܏sʎ4"1ȱ}-&-&5m]IVi4mm:lC P@B&?M9q4+,͹~<>sܩH2xΎ\SNRZ!u7uE$E\Sek%wZiGSgFŤ3M7=Nhyy-s/'t{syyo=?Ϳn׸ݯMGTtB3w|Go5$bhw^{Mnlh\D ]:LWj_ F$q( c-="v${1lJpvg\~gp{p'PqnWSF'x@ݭȲ57,|0W43=9f4F asĀi1RF2*ïc<+R &v؛wbp>ՉU707tPdf ]9pYF\uv R7H8ɢ WjD=RV#܆و{8"&fLԀ=?~4z5λb~ƚ^Ĉ{ ;yj S1 !#2WMfnZ%Fo;N-SdO _hˈm)0 p,WW(5mƝ5M| `Jͬvi$;re4{yDL.27"+g.w˅Xg."j-X* PلޒGouXJ%i?`xɺ ߶=-:B]D!Z2U2D6B$2D@;i2///gG3ZHW%71SgLIB[oDaȰsa;jDF}nD`ρZڥA߈;6rվd!j6f8c-v6Ȳt,K!e =}ʅ"{@t8WV"蝴bzzµSbc/#qyYY]'kT:9'A5Xj H4[ fwkD0Vb%\}ŠB%rEPX$yF_CҸD' LD_,/v*ѧ (d+& C BQebzaG{*fl<:} kȧws?~G90sL -! e"11qyC(/HJf=ۻPEzfhyX+A:=_kTS/\KidӴ]Y.DyQob ĥF MM /+ rEH/Zq!'`E]+d.}d+=+/=D?'bendstream endobj 616 0 obj 2918 endobj 625 0 obj <> stream xX]l4,rY lؾ3ѦSOOmiiHgo@qDxoMª*} n[T*Z7nPڮUl;3o6PoU~;ޜ "9\SNwyPhE0&wi7H"v d|/KB@:?ާzs+;w}? GGg0+ZsS|**hG-a Dt7UwP/LZ;)i#($gfP-/UJ$OG$ ;Qv#Ҫ GҰ7Y'-1cD.%Rf|`j ~"Qsk|Lme1^F^+R`vTr"g(n[ĭn޸ymh_u5q&{-IU ͜LC'ZQS|k#\iznܼY49O{𻔫 Ut4ɛ\~2p`2V1 XR-AN - *Z3!fs"KgJksA jl ] !IFPP@4\|8>j<(#F\S TW1vd\rd萍3F'#-h.1#h(a*.p6DZr[rom itRilP.O-lF qkdẅKij@QjoTVPy~I"^IUf"V{Jo\Ї;%֣h/#\:;^{`p/G!0qRKfL$ZCelƢ\ejyX;!`+Wky?~e$w~Lsz[K\v8UZcV}(o7'nsqohWAŤ>YfҕfrQMNiLO /gv f 5Ed+"O#LQ7EeN ub8k @Dc8ŔFp_2|,P,yX3 .dxdx:QUH|Q`]xM8& lz !*Ia0/u̖BJfh.3%=! peay779g:$N[ecsdlu rZsv21h´)05b95 @)y ^ҞDf $iuҙuT}hW:䌤g}{6z1ƌQ1ZlCC|CWY6y4|z[lO :?a`ӝ%ſ~!MyVpvS#ۖ"d >U "" `V,_䍥ܙZ:v sapGht՝ʜS'Ȏ wzb_^X_cJ7"'Sڱ'հ񋒳 s+7> #Rډ /֫Zzɾ6p|HrȲvꮻSlMF?HA1& _amI|'I4dDˢ!qX7! @ owm r6 C*a)4\o 0p6|2i`P'?6ۂ`vY:ϧaX8VA<5euvF.VvN R5@XPF̨qjACyt~ {r:Vl+Qbѹ2ŭX;e)me|yKue 2KQn{vmS8z$fylûOZ0Do(ƍ~€oNroiaa0K76 ; řЫxfWE({r[oj8鉸^{x j¿V0endstream endobj 626 0 obj 2891 endobj 631 0 obj <> stream xXmlQJ&Wގ!w{Eƛ~;khV`kBc $b%:&K7MH4Nݾ}>ljS ў=NЭ6!5s{~K9/g5f[OVOD{ȏGYZ~Hգ,qןnx'Edף/$T>=1yPp;9ɷ^A}^1cڛQ(x%'C/!/1&[6RAW)ߪsiiDt1V 3׮ĞDF8WKVdu_oyNQy* x-)eKHD9r;'ݠL2A5aEs?h T{^u# ²aV'؅c P؅ڄz<}hޮ}=?k>4􍭝_^M=oP"y9ֈֈ?}\# RǦ\Ds3@P03z?j3瀭fcCit9Ȕ=zV[Emd3:LO{T+C :"6%bZ WqzH$}j.vcm^bţ x;v A-`u&0jPNCҎxyҝ-k5$O}g1MGz)*B=MV`6[ V:4skRNM.=@6$D d`Tj(I9ݟf\'F;m^uGxM`,avah0d%!{o[~Wݐ;jVz-+jZ7ߟNY py7nxL~N}karXKa.N>',ߥ]H~Ax|Z'P% L z-72P_.QC]Ό$/"]ؗ 38*G@kFsUuܼ϶juݨ7F_ť$/g?mȿqYoڥxě20t5*3'VU"4%lrsI}AT8E!.:( MhDȊI.Iң؄2}7)/ءIB<҄$.(l) P` mihHZaҗmjGHbd0WqD<):[8ι5I;^KbTozM_` ('Pߦ\25'Cv;ihJ,vk\mҖ@SB“ ʑaOJu)a`%D5205]%u^"!yJRd%E|fykLBx$5qsnͰW0 bm!R'L"3gd~C9&kPnd,/2 #Ol[uݾV33pCteǎ)1 ;Iz=%(6-Ey+qxKmT+P]Wb›cc7H,O)xq^hwpoM"~߿B?endstream endobj 632 0 obj 3117 endobj 646 0 obj <> stream xZ}lTYoR*Q`7}Lv)v3`3Sv 5iC)VŅ1ew%F+Ȣ QW4%Ͻcybh23{s9/yٟBC3<̷u7DyJC_b.WvnpGw!EE%!a}f-_(\R>O=qUD?}HNG[>]"cHGsR$QYe;I~S$t1T>,V>"0vݿoMQcD!A'n_2-o#}IK{彈77d {)vl~3>d\G#O#:|"__,C;2> l݇}51s Snr#y,UXI&^lUKfj%W:KgiĿ,#X` wJHk=#BO3 y{.4bJ'`œyľͮ[Hʊ,س4{-ЅEDWtԧ=Lz{<'ũ/=BzN gz{קR/f B({:'~LKO9`t,%Ztǚ:B9J]B'zj -3gI;8T(ó"Qڋ).>l|:ֹ|5+ҫ ءHr 9r0;Gr#Lsrh*# vU08&Y*v4>sTs)T~~,#M S3,HT~0Sk*%!ړtfJ}AJgYh5]5d5c)מ3 Wԥ9Exh&>**l;^ AY0$T~xRTm$gq0s/?O;g\=+gjDK@7nJ\B))w{ŊZ,\(@tпP\wA3nr.1S`F'`{."$GV\dAl<1) Pd:[& i/lsV't#oȧEj 26_ u v-Ylk]uĆj*8_1Nx g$bj:~G5d㍔.Q\.DI@25N~}(ҹ'#tG׈s# yI%P%wۻd >^{=&6tvջ;7(7If9зN5&i̜.6QmD7^K+m6C29ssb8*kړ%#ek&+d<{RY3{8Nm_26{5U<n^_)كm guëT>E +S@X!Mndkukfɥx=G9l/ucQuKN߃$Ua?j~>ȏdp?&ƃN Ykl J[?`.e $Yzq!ʊ,ǖh[e,s/۽]6U}LS;|sv_MM%u]SjځǢPzŞjݖù OBQr4,MuCQέZ]Ѕh+q_2fq(@8㠨jUm*u82gN[1XߴDr3Ly;tV޽Ja /~'xG(Fz6j3{a / -Ya/D]gi*I;gsN0w'UDz:NKJ} MJRoKԜqIՒW-U-^Vw&k 񄮩uoZ3(R,:&3|yV|su|x]x3|j3!/%X Is:~ԏ=z3\r6zF9~ 3XP0, n<_ SCetj5FVO;=oF֯Z;k@ٗi9]ii:{SvzОgAz Xf|+̢zQY:eJ7 B Ra? B++~[ARܠ 9#uPck+ѡ냦uuȜ`7H w K^/ͱF#ֹYv k.Bnu'>sT_J\G¼Ed7/gz?endstream endobj 647 0 obj 2760 endobj 655 0 obj <> stream xZml[ֲ^/d[H2 Q5M{}= tevpIh]um}EJn*͗Я"k)P14u - L0&cڏiJC{nth6EUsy}}9)ý|0L~C-RϬ_CP<~b !Q^1% ;PK׏5Pl Ō$@듶O}]O+sAkt1#|s'䑂XL)wg^8O'ȣ$`DC-Ergpt|?$"`aWHi"s89U94WiKK!RYKZ9Wjd>yӎhꊁd#\+pz8oTG8QY*zLLm/յ |jRj(5r(LiYMq|.sqt}qeF͌`FD0?SIX;W+*9 #YI2Xp("?j[}\_&9~c,>wlLS7SV+oaS A}S3@MaxRF>rfX;(8ፌq@8tQ8#~]JB3Bw| p,"*W8Q֥vb/:>M±&ԭ۩=#^-1ƢfL ^`HE=Z3I@i4VF pT$<,$ ֪HK\ &%+QfKq"$ƭnݳշO+/Zhd&(xQlXT(M(ky|8QCZ#M뤨[sOcm+AWBfVtWM*@xpp uBM 4*8V7]T։UQex;`d;tr I9Sz%,.+t?\CB&Sa y0NEqӯ->iwky`I2DS&No"d 8lh1H.Q ~MB'xrwZ!(fD_ OOߝ|wC"(3r˞ذ6~≙QVK[LM Akn!JCi7g86S [54x`[ko2 +IML/rŁ9{ tEJ1 :Ar*[/ԧmAxåA6*dAYDz[gkˀ9rcҪrq_rezjEeQݨ#64&zГAJd,!gAN!aaD蘌׳gdzn#\mDu<"%Gܔh$$0^SX`.vK3,;;hwnbAWvKln'E6#Xry;wl0ksH8 &(;I;v qҬmvWe(1ˁh?a7;e^:OCXqw [mY-Rj$)Jz0fP@ /-hFh)BXd붍@Hnfu9h[mW\@?rB67KZYRkM ީN(iH vk-ww ,@3G] UrN/  sf>ӏq/ì ~]ΒT:%XPg#^ ݢXUd[4e ˢ]Y>~t4n,Ҵ9zހe\>Bm2Sf` mN@~CR`Vo+PE}s|4=WXU._N bZ"EC dsj!Mgڇ8`b#ڦYZGla|YgKӕULd̯1ڮ0!Wt /]ms|x*8NJ>I|! yvسݹㅎ4 tՒRlE*(B<;<[˪l=3Hxrj4 ._=>a؊a_3 bGnGl&v)Jrnt4Nܷ+#י_P5eǢ;uWK}1F+h#ro\hݴJݾɫF˄ݡ3(a+iB|klVev\o0થ=Bc[bn,Kshd!6>iNMr-_3뫴婟nޕ4(hsEy &M'rm@a+Z!Gnd\>geQD]8j:4}sn;/}CZPq(]t)Vgb6vkz6)F2KV3ȑ#ˇE䌙gRٓCSc7OX+ߑo_>EŦ濪ÌaGnd8|GHo*ɛGz,U(jWR35X2Tje 4P/> stream xYolSߢdx1`7{R!hȜg?-Vbc, DJ!d5%Lt@]7۲j[ud|`J}6M޳y PuS>~{s~wncOTfk,G~6_e9Zcj:VEڿmڮ6k>qߡm\v<I{E~re4̿>!Rv'A~ ]lNz y_L01v1:H[7o; >q׮?;po>2IV[b8Xۓ׮<5!XO3KݎlNmVSRٜ$'Ҍ4 3CJJj\Kh\b3z?N*YIu3Y8>;>7Iy)Kx'Ƥ>nhq\OZI^'2:>2VCǑ=-<]0J9[SK0Cch[f~I-D6m8p`#._`ޣ|,'i'\b.ͨ,Ga9X`:-d&}KKhh'n *| 7PhqJJ|7WN&p20ׂc0qPյ&)T2p̖ OLd{XN8җ 0Ǜ-)6pf$lFo/X,;H,S|9,É{)8lQET% ΢hryOvJ9_]*gۡndjl4ۿg(7n|f.K3b)>^IhiAQ44I> tίȼ .84;!h!BEe|oC*dC'Z%4]mҳϑ(=qX[KyNӗlM_$9 ypϪq0#p]-?ˑiȩ=tIBg% Ȗ!<ދ#w\@)Om l{7m_XmۻKp?N?"LᓂB-?y);^۝Jnm-Nxmqmu.mkuUvp[-x@P.+<0o}=?psPSx6 4#((:o3dKiN?t|$ _>1ǕowaU?;T`x1D~Dx>N=ƒɋ<(jr-GB * d$MkP5h*|xi;P&)9Gm*$_T7"h(SwfhUGBU{%iapMX&2$ҷfGh vHV}vS^9:P{IȚUhىq 1npPiV eAE|D4sDCWE?gP3B :7w8Wa VTΣjR9VUv`p:GhPa9  $X54N+,huRKxR-U0h#r:IrSCʁN4!6ЩU' |ݗ  aoL$Xݡ+P6bĂvRMCX3F &11LN <eK䍞~jGf,8/+0IUSs=1߻ȧC|R ~6%͔ vLHZ镂oQ)%K@3Hϧ _hdn44d+@m^ưg9[J$w,0h)Z-j7 Iq뫇4- ݳ$f{k!OuK?2N ZEODֽ'O/GDž8 תbʍ WƫEsG T6#Q? > eWwaZBWwEgO}_;&*u$Xg%Tx)endstream endobj 660 0 obj 3047 endobj 666 0 obj <> stream xY}l[+Yh-eiC޳YfuܦcP Yz^Kln@hbM#JcmSǤ! Dm!۹\eCsι7i.KNS4֧Ӓ̾>Ξ$K=-6]tMmH=[ wMAYwXOl/=V)Ac_,y oy?^|yI \D*XMhuez4Zu{eU$6-7ծ}hu5Z]z 0{}7Az4ZJ-`9\wTnlsNYrn}aqù6D":@CfG2륿D+4x7@*EGz4Tm՘._N[f{o<:R篠ؤuBTʚ.CLj ~q% NF+8^fjIz';)֦@Hͼp(~W?xSzhW+skj|tlRhQc5m.an{j[;(o ?[LV1`^͏C#HK jjdTV,N* ^GQ{:U}* `s VN,(rqȫ.w("IdWMeoGRS).SHkc)Kf]fkW8F F* VޤE됼|uB2o#LA stϾOx5xJ a3FZ Gȧsd)D*e]A7+e5fď*wdE% aǏ<|z\j9} HbN176ȒY2WϜ8#F"EqL$&0uɦ] ol dh6 I8{ݥ#K /mIgA#6Mu85i 91 )3 &u duѠzɅ3(JjUg)p=?QȤNnvr%辜P(&Bqr]2l7 gb끭6<(ſ)3-GE3m~h₷;bߵB(0gi0D%\z Y`+Tw4;q1LAf#DM)20l4Cfք!TgHYydj(ccBG9˹<}r(4 t)|A PIǓ0'50Ǹ; BMq74b$>JzGf!<1,aRZVrWɪnj Fk6=Ç!* PwM1gsz)B24ٙN3j)duu.C)V {@YdW^AoxX5"dEzgIF%C߾=5}ܹ+˹sNǔEb9't@0ZN x>ku%JxPًMAP&VSSBqp2PB~9- _lFPz!G; 'ˌY%Jᄎz y zNx ;Lh$(CPXF#ڀa}͂dq㩾 F FCF`< 0˚Ml̦)EgB& d.>l)b66 m,D"tw )X6~-߫͢'h *&Ǎ|l734M- |M'4h3(<[R#RFվ=]I",S=. w=%_LQ_, Y^ϛ+1 %ޛfbͭ[-yey,vBW*礷^6[uV..JeW{p=Q^7])Ywؗg~D믯Ԩ e/bqq1=U8.>91q.}HjꭘG uڑqqc 4lU9b y oRzwכyhWb؄ǿZ]t~T+Y@{Dů#궹z3n';P#hWJYYc̞esk/+Pw [^MB`uA/pɹb:nưلO_t=m,[=՜]n ݚ ~ob#4,R'r=Pat]džtw`,b8' 춇 Ӧh+5&Uv˨pVjp:/b WڇNS6µ:47? #,_@G endstream endobj 667 0 obj 3039 endobj 680 0 obj <> stream xXolS/!"$j;5$!1~ovlg!UcsWsm*b,8!hҵST&Ah*1MBLXIiۧMj_{{){;sN2^n7ȏii4e<]s?#޾X?影כ\QEv"ּ#Mwb&U be|k:?_eM~V+ 'чĞsg>k&ޱ=d' ., ο:J=䶤˔U:>u|FN%Ԫs{xP%O$!FtaHdTLסRKl"S{Rgo'S KjtWw{gcQҋe!tX"T. S>&@-z|涋Bi)`WBO#_D)u.z46I EFþڣl 3wah\>`%R"pUejDKv%܃zK׵Z)wmussaz)}߮u֓<Հ޿ )M@Qp\ԊtI'_:xWGbP-PHQ kV@jBk4JKKaFx3c)p2>:)L궬QȟK DZad\MR󱇷)u^ht N@N#õLSJM jcF+$e\&"EHZ(Mi裂DnDrsm>;vQ1FV/|C@/Pҋy4,{0d;in GO: nIy`-é2e)fjP:o欧 iO)[[ < #NZ5O;c`J>xH:9-m\Nis])d '%ax: TȡJ9ƎVqW>gWKc޴x(lӣ@ϯT~ .x EWlF:K5%I4.c' /$Y# Ld!cl#ø#R[$R&d nۆk0]t&cmF Gt20@Ż~ \U $MCF:/dzБ|SSbzi"i|E6:n^!(.0s~L?J*5[T`f7 _)ByD~ u'endstream endobj 681 0 obj 2304 endobj 684 0 obj <> stream xZ;oVH  ^ F%Y) (T@Cfe 'MѫCS+Et Z EDv,\"yKQd>;ctOJ::ƤOy*nU-F l$8dE7<3v0G;nF;&WzdJNu&!ͪ7=jY^h[D=arP>#1y,ns+aZXhs~gx ѥi>'sMjF;8)ma/&m-$JQэ*Z*ǣZO#i(V-e=$kDW¼֛.|vˮ- wۂVڡt-9KE0<쎽 X)4E6.m(M*;+Md;<,,Mhk!h^dWʴ1uYA'!+cv=6Bͤ7U4}9aIN⓭d˻;/fMqg z?<RZPGt$)>S0|[ rMfŜ\kΝqŞanTMlDF>1Ο\`!#' |Lb$:8:S3]7fj6lasd@= 3QG:A}1MU,P)k}0q!\(^ʥŞI>N06 0OB&=øe19x~Mu'EvO5:m&U%$︇p_4r$endstream endobj 685 0 obj 1690 endobj 5 0 obj <> /Contents 6 0 R >> endobj 183 0 obj <> /Contents 184 0 R >> endobj 255 0 obj <> /Contents 256 0 R >> endobj 261 0 obj <> /Contents 262 0 R >> endobj 373 0 obj <> /Contents 374 0 R >> endobj 397 0 obj <> /Contents 398 0 R >> endobj 412 0 obj <> /Contents 413 0 R >> endobj 423 0 obj <> /Contents 424 0 R >> endobj 432 0 obj <> /Contents 433 0 R >> endobj 436 0 obj <> /Contents 437 0 R >> endobj 447 0 obj <> /Contents 448 0 R >> endobj 452 0 obj <> /Contents 453 0 R >> endobj 515 0 obj <> /Contents 516 0 R >> endobj 528 0 obj <> /Contents 529 0 R >> endobj 533 0 obj <> /Contents 534 0 R >> endobj 539 0 obj <> /Contents 540 0 R >> endobj 546 0 obj <> /Contents 547 0 R >> endobj 551 0 obj <> /Contents 552 0 R >> endobj 557 0 obj <> /Contents 558 0 R >> endobj 564 0 obj <> /Contents 565 0 R >> endobj 573 0 obj <> /Contents 574 0 R >> endobj 588 0 obj <> /Contents 589 0 R >> endobj 595 0 obj <> /Contents 596 0 R >> endobj 600 0 obj <> /Contents 601 0 R >> endobj 605 0 obj <> /Contents 606 0 R >> endobj 614 0 obj <> /Contents 615 0 R >> endobj 624 0 obj <> /Contents 625 0 R >> endobj 630 0 obj <> /Contents 631 0 R >> endobj 645 0 obj <> /Contents 646 0 R >> endobj 654 0 obj <> /Contents 655 0 R >> endobj 658 0 obj <> /Contents 659 0 R >> endobj 665 0 obj <> /Contents 666 0 R >> endobj 679 0 obj <> /Contents 680 0 R >> endobj 683 0 obj <> /Contents 684 0 R >> endobj 3 0 obj << /Type /Pages /Kids [ 5 0 R 183 0 R 255 0 R 261 0 R 373 0 R 397 0 R 412 0 R 423 0 R 432 0 R 436 0 R 447 0 R 452 0 R 515 0 R 528 0 R 533 0 R 539 0 R 546 0 R 551 0 R 557 0 R 564 0 R 573 0 R 588 0 R 595 0 R 600 0 R 605 0 R 614 0 R 624 0 R 630 0 R 645 0 R 654 0 R 658 0 R 665 0 R 679 0 R 683 0 R ] /Count 34 >> endobj 1 0 obj <> endobj 4 0 obj <> endobj 10 0 obj <>stream 0 0 0 0 95 82 d1 95 0 0 82 0 0 cm BI /IM true /W 95 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID & |`0[A? F[I- ?ooH0o[ I,OA@ EI endstream endobj 11 0 obj <>stream 0 0 0 -3 80 82 d1 80 0 0 85 0 -3 cm BI /IM true /W 80 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID *+&u CP%[PU\=kK^_l2]z5u޿k i_P EI endstream endobj 12 0 obj <> stream 105 0 0 0 0 0 d1 endstream endobj 13 0 obj <>stream 0 0 0 -2 53 85 d1 53 0 0 87 0 -2 cm BI /IM true /W 53 /H 87 /BPC 1 /D[1 0] /F/CCF /DP<> ID &C6(~hߠ'7L>K륐kOfQ AkZ@/ 5\.ZD4_{.hxaO/|0t<@ EI endstream endobj 14 0 obj <> stream 89 0 0 0 0 0 d1 endstream endobj 15 0 obj <> stream 65 0 0 0 0 0 d1 endstream endobj 16 0 obj <> stream 63 0 0 0 0 0 d1 endstream endobj 17 0 obj <>stream 0 0 0 -2 72 85 d1 72 0 0 87 0 -2 cm BI /IM true /W 72 /H 87 /BPC 1 /D[1 0] /F/CCF /DP<> ID &t  8< 3 @&o_I&|$ ސ}~I ?_kao[\50 W 4p EI endstream endobj 18 0 obj <> stream 86 0 0 0 0 0 d1 endstream endobj 19 0 obj <>stream 0 0 0 0 78 82 d1 78 0 0 82 0 0 cm BI /IM true /W 78 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Ți ( ??8 EI endstream endobj 20 0 obj <> stream 83 0 0 0 0 0 d1 endstream endobj 21 0 obj <>stream 0 0 0 0 78 85 d1 78 0 0 85 0 0 cm BI /IM true /W 78 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &HP#aAH7ނa_2Z4Cb EI endstream endobj 22 0 obj <> stream 88 0 0 0 0 0 d1 endstream endobj 23 0 obj <>stream 0 0 0 0 71 82 d1 71 0 0 82 0 0 cm BI /IM true /W 71 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &sDІ]xhY(|/ ?z}}|.!WV  EI endstream endobj 24 0 obj <> stream 64 0 0 0 0 0 d1 endstream endobj 25 0 obj <>stream 0 0 0 0 77 82 d1 77 0 0 82 0 0 cm BI /IM true /W 77 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A+?A>  x {`KL  EI endstream endobj 26 0 obj <> stream 79 0 0 0 0 0 d1 endstream endobj 27 0 obj <> stream 84 0 0 0 0 0 d1 endstream endobj 28 0 obj <> stream 87 0 0 0 0 0 d1 endstream endobj 29 0 obj <>stream 0 0 0 0 35 82 d1 35 0 0 82 0 0 cm BI /IM true /W 35 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID jī  EI endstream endobj 30 0 obj <> stream 104 0 0 0 0 0 d1 endstream endobj 31 0 obj <>stream 0 0 0 0 78 82 d1 78 0 0 82 0 0 cm BI /IM true /W 78 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID & szr$/_|/(_K_/_/A_Kh=" z!_ EI endstream endobj 32 0 obj <> stream 43 0 0 0 0 0 d1 endstream endobj 33 0 obj <> stream 42 0 0 0 0 0 d1 endstream endobj 34 0 obj <> stream 85 0 0 0 0 0 d1 endstream endobj 35 0 obj <>stream 0 0 0 -2 79 85 d1 79 0 0 87 0 -2 cm BI /IM true /W 79 /H 87 /BPC 1 /D[1 0] /F/CCF /DP<> ID &t h<#@<AxI0>MzO0AA7kz]x]][ m[ X0 ,0 z@@ EI endstream endobj 36 0 obj <> stream 122 0 0 0 0 0 d1 endstream endobj 37 0 obj <>stream 0 0 0 0 67 82 d1 67 0 0 82 0 0 cm BI /IM true /W 67 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &OȚᮿx^?_ׅp/Q@ EI endstream endobj 38 0 obj <> stream 90 0 0 0 0 0 d1 endstream endobj 39 0 obj <> stream 114 0 0 0 0 0 d1 endstream endobj 40 0 obj <> stream 80 0 0 0 0 0 d1 endstream endobj 41 0 obj <>stream 0 0 0 0 64 82 d1 64 0 0 82 0 0 cm BI /IM true /W 64 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &?4!> cO P@ EI endstream endobj 42 0 obj <> stream 91 0 0 0 0 0 d1 endstream endobj 43 0 obj <> stream 74 0 0 0 0 0 d1 endstream endobj 44 0 obj <>stream 0 0 0 -2 81 85 d1 81 0 0 87 0 -2 cm BI /IM true /W 81 /H 87 /BPC 1 /D[1 0] /F/CCF /DP<> ID &t  85mp˄H a1>/A}A/}|koG_ aw^mwl/ v ='0 EI endstream endobj 45 0 obj <>stream 0 0 0 0 85 82 d1 85 0 0 82 0 0 cm BI /IM true /W 85 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &F/4OE _z zW ҿo 7_+ ޓ(z $ o EI endstream endobj 46 0 obj <>stream 0 0 0 0 82 85 d1 82 0 0 85 0 0 cm BI /IM true /W 82 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &xnN,?h77&|0? ?_~/ @|Au37P߃~_//K,&@~8/5@ EI endstream endobj 47 0 obj <> stream 76 0 0 0 0 0 d1 endstream endobj 48 0 obj <> stream 44 0 0 0 0 0 d1 endstream endobj 49 0 obj <> stream 82 0 0 0 0 0 d1 endstream endobj 50 0 obj <> stream 112 0 0 0 0 0 d1 endstream endobj 51 0 obj <> stream 73 0 0 0 0 0 d1 endstream endobj 52 0 obj <> stream 72 0 0 0 0 0 d1 endstream endobj 53 0 obj <> stream 92 0 0 0 0 0 d1 endstream endobj 54 0 obj <> stream 120 0 0 0 0 0 d1 endstream endobj 55 0 obj <>stream 0 0 0 0 72 82 d1 72 0 0 82 0 0 cm BI /IM true /W 72 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &>DЂ <0~߃~%^ %q\.P`p~߆K z XLX࿐P  EI endstream endobj 56 0 obj <> stream 78 0 0 0 0 0 d1 endstream endobj 57 0 obj <>stream 0 0 0 70 13 82 d1 13 0 0 12 0 70 cm BI /IM true /W 13 /H 12 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Mu` EI endstream endobj 58 0 obj <> stream 94 0 0 0 0 0 d1 endstream endobj 59 0 obj <> stream 26 0 0 0 0 0 d1 endstream endobj 60 0 obj <> stream 48 0 0 0 0 0 d1 endstream endobj 61 0 obj <> stream 28 0 0 0 0 0 d1 endstream endobj 62 0 obj <>stream 0 0 0 28 44 84 d1 44 0 0 56 0 28 cm BI /IM true /W 44 /H 56 /BPC 1 /D[1 0] /F/CCF /DP<> ID & "A &ޗZ_&kXa m\ @ EI endstream endobj 63 0 obj <>stream 0 0 0 29 91 82 d1 91 0 0 53 0 29 cm BI /IM true /W 91 /H 53 /BPC 1 /D[1 0] /F/CCF /DP<> ID $I56@4ӄOK~6LX`iqdž&AP EI endstream endobj 64 0 obj <> stream 52 0 0 0 0 0 d1 endstream endobj 65 0 obj <>stream 0 0 0 28 51 84 d1 51 0 0 56 0 28 cm BI /IM true /W 51 /H 56 /BPC 1 /D[1 0] /F/CCF /DP<> ID &4|0<-oM ްo[[;__kio_ a- !ax EI endstream endobj 66 0 obj <> stream 98 0 0 0 0 0 d1 endstream endobj 67 0 obj <> stream 99 0 0 0 0 0 d1 endstream endobj 68 0 obj <>stream 0 0 0 3 39 82 d1 39 0 0 79 0 3 cm BI /IM true /W 39 /H 79 /BPC 1 /D[1 0] /F/CCF /DP<> ID & m||@ EI endstream endobj 69 0 obj <>stream 0 0 0 3 47 82 d1 47 0 0 79 0 3 cm BI /IM true /W 47 /H 79 /BPC 1 /D[1 0] /F/CCF /DP<> ID &= f{o7{}o= >oO7 ]XzimX0 EI endstream endobj 70 0 obj <> stream 55 0 0 0 0 0 d1 endstream endobj 71 0 obj <>stream 0 0 0 3 49 85 d1 49 0 0 82 0 3 cm BI /IM true /W 49 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &3`g*"qG|'MCIf>A .?X_u d0ΡAE8> stream 58 0 0 0 0 0 d1 endstream endobj 73 0 obj <>stream 0 0 0 3 49 85 d1 49 0 0 82 0 3 cm BI /IM true /W 49 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A <,=W}~___>_m/`^8 _Ooo [dž V aD@ EI endstream endobj 74 0 obj <> stream 59 0 0 0 0 0 d1 endstream endobj 75 0 obj <>stream 0 0 0 28 53 84 d1 53 0 0 56 0 28 cm BI /IM true /W 53 /H 56 /BPC 1 /D[1 0] /F/CCF /DP<> ID &DxDa l#KQM?O=߆3S!&@y[AxU\a\^,( EI endstream endobj 76 0 obj <> stream 106 0 0 0 0 0 d1 endstream endobj 77 0 obj <>stream 0 0 0 29 39 82 d1 39 0 0 53 0 29 cm BI /IM true /W 39 /H 53 /BPC 1 /D[1 0] /F/CCF /DP<> ID A?&=~C?Ѣa=5BN  EI endstream endobj 78 0 obj <>stream 0 0 0 28 44 84 d1 44 0 0 56 0 28 cm BI /IM true /W 44 /H 56 /BPC 1 /D[1 0] /F/CCF /DP<> ID &h7A [W(6^K 0l<@ EI endstream endobj 79 0 obj <> stream 45 0 0 0 0 0 d1 endstream endobj 80 0 obj <>stream 0 0 0 -1 57 82 d1 57 0 0 83 0 -1 cm BI /IM true /W 57 /H 83 /BPC 1 /D[1 0] /F/CCF /DP<> ID $&k.6 ^8g~?L@ EI endstream endobj 81 0 obj <> stream 49 0 0 0 0 0 d1 endstream endobj 82 0 obj <>stream 0 0 0 70 14 105 d1 14 0 0 35 0 70 cm BI /IM true /W 14 /H 35 /BPC 1 /D[1 0] /F/CCF /DP<> ID &7{ cM~( EI endstream endobj 83 0 obj <> stream 71 0 0 0 0 0 d1 endstream endobj 84 0 obj <> stream 68 0 0 0 0 0 d1 endstream endobj 85 0 obj <>stream 0 0 0 3 49 85 d1 49 0 0 82 0 3 cm BI /IM true /W 49 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &3.=X=&Oo[o\=]Xad4  EI endstream endobj 86 0 obj <>stream 0 0 0 0 106 118 d1 106 0 0 118 0 0 cm BI /IM true /W 106 /H 118 /BPC 1 /D[1 0] /F/CCF /DP<> ID &U/Cl * ޿_=xy y /@ EI endstream endobj 87 0 obj <>stream 0 0 0 -2 80 118 d1 80 0 0 120 0 -2 cm BI /IM true /W 80 /H 120 /BPC 1 /D[1 0] /F/CCF /DP<> ID "MBA%_]?*|h/`Țxz/ A, @@ EI endstream endobj 88 0 obj <>stream 0 0 0 41 61 120 d1 61 0 0 79 0 41 cm BI /IM true /W 61 /H 79 /BPC 1 /D[1 0] /F/CCF /DP<> ID &C < = '@ޓx[a'Cz>ԂR_޿w o޻] [/e  EI endstream endobj 89 0 obj <>stream 0 0 0 0 41 118 d1 41 0 0 118 0 0 cm BI /IM true /W 41 /H 118 /BPC 1 /D[1 0] /F/CCF /DP<> ID 5 D kOHo EI endstream endobj 90 0 obj <> stream 125 0 0 0 0 0 d1 endstream endobj 91 0 obj <>stream 0 0 0 12 52 120 d1 52 0 0 108 0 12 cm BI /IM true /W 52 /H 108 /BPC 1 /D[1 0] /F/CCF /DP<> ID &N2ODxAOJ7ޟF$Jʃ EI endstream endobj 92 0 obj <> stream 50 0 0 0 0 0 d1 endstream endobj 93 0 obj <>stream 0 0 0 42 54 118 d1 54 0 0 76 0 42 cm BI /IM true /W 54 /H 76 /BPC 1 /D[1 0] /F/CCF /DP<> ID &CD|0N7·/ 5VG`/@@ EI endstream endobj 94 0 obj <> stream 69 0 0 0 0 0 d1 endstream endobj 95 0 obj <>stream 0 0 0 41 71 120 d1 71 0 0 79 0 41 cm BI /IM true /W 71 /H 79 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A@3xA <#t t m&?z~7y߆0u \k Я ٯA^x^[ %44" A EI endstream endobj 96 0 obj <>stream 0 0 0 0 127 118 d1 127 0 0 118 0 0 cm BI /IM true /W 127 /H 118 /BPC 1 /D[1 0] /F/CCF /DP<> ID #Al2ɩ! ,0[^ 'IaO&? Oa?[?MH7Oo[X?𷄘qɀ߄ EI endstream endobj 97 0 obj <> stream 126 0 0 0 0 0 d1 endstream endobj 98 0 obj <> stream 145 0 0 0 0 0 d1 endstream endobj 99 0 obj <>stream 0 0 0 42 80 118 d1 80 0 0 76 0 42 cm BI /IM true /W 80 /H 76 /BPC 1 /D[1 0] /F/CCF /DP<> ID "MBA%_]?*l. v[DXb0_  EI endstream endobj 100 0 obj <> stream 75 0 0 0 0 0 d1 endstream endobj 101 0 obj <>stream 0 0 0 42 80 120 d1 80 0 0 78 0 42 cm BI /IM true /W 80 /H 78 /BPC 1 /D[1 0] /F/CCF /DP<> ID &C \ :} ' j=}OcPX(&!W8f@@ EI endstream endobj 102 0 obj <>stream 0 0 0 -2 35 118 d1 35 0 0 120 0 -2 cm BI /IM true /W 35 /H 120 /BPC 1 /D[1 0] /F/CCF /DP<> ID 5u kk, @@ EI endstream endobj 103 0 obj <>stream 0 0 0 0 48 85 d1 48 0 0 85 0 0 cm BI /IM true /W 48 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &^B'#=`zM'訽p~7x EI endstream endobj 104 0 obj <>stream 0 0 0 29 57 82 d1 57 0 0 53 0 29 cm BI /IM true /W 57 /H 53 /BPC 1 /D[1 0] /F/CCF /DP<> ID $&k.6p &C'  EI endstream endobj 105 0 obj <> stream 66 0 0 0 0 0 d1 endstream endobj 106 0 obj <>stream 0 0 0 9 37 84 d1 37 0 0 75 0 9 cm BI /IM true /W 37 /H 75 /BPC 1 /D[1 0] /F/CCF /DP<> ID &O?t?jd0" EI endstream endobj 107 0 obj <> stream 57 0 0 0 0 0 d1 endstream endobj 108 0 obj <> stream 47 0 0 0 0 0 d1 endstream endobj 109 0 obj <>stream 0 0 0 28 38 84 d1 38 0 0 56 0 28 cm BI /IM true /W 38 /H 56 /BPC 1 /D[1 0] /F/CCF /DP<> ID 0$< zÈ ap_uAY py  @ ^j P_d5ȁx20O EI endstream endobj 110 0 obj <>stream 0 0 0 -1 57 84 d1 57 0 0 85 0 -1 cm BI /IM true /W 57 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &!1T3 |@&trւb}//55ap6ix0day ] _) EI endstream endobj 111 0 obj <>stream 0 0 0 0 92 83 d1 92 0 0 83 0 0 cm BI /IM true /W 92 /H 83 /BPC 1 /D[1 0] /F/CCF /DP<> ID &B̂Xua߽v Wz/kkp]]t .? kkkk / EI endstream endobj 112 0 obj <>stream 0 0 0 0 66 85 d1 66 0 0 85 0 0 cm BI /IM true /W 66 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &P DA'  7_~K0\y ?P EI endstream endobj 113 0 obj <> stream 101 0 0 0 0 0 d1 endstream endobj 114 0 obj <>stream 0 0 0 28 43 85 d1 43 0 0 57 0 28 cm BI /IM true /W 43 /H 57 /BPC 1 /D[1 0] /F/CCF /DP<> ID &R?K>/jAp/׮Ay $Z kPe8aAG_k.%  EI endstream endobj 115 0 obj <>stream 0 0 0 7 43 85 d1 43 0 0 78 0 7 cm BI /IM true /W 43 /H 78 /BPC 1 /D[1 0] /F/CCF /DP<> ID &ܠ' <.}&޾!ā5>3? EI endstream endobj 116 0 obj <> stream 51 0 0 0 0 0 d1 endstream endobj 117 0 obj <>stream 0 0 0 29 48 83 d1 48 0 0 54 0 29 cm BI /IM true /W 48 /H 54 /BPC 1 /D[1 0] /F/CCF /DP<> ID "At  Ԛh  EI endstream endobj 118 0 obj <> stream 54 0 0 0 0 0 d1 endstream endobj 119 0 obj <>stream 0 0 0 28 61 85 d1 61 0 0 57 0 28 cm BI /IM true /W 61 /H 57 /BPC 1 /D[1 0] /F/CCF /DP<> ID &@i|A 0E8p }?a0~?w y2j2&x@'~v X0Y5 EI endstream endobj 120 0 obj <>stream 0 0 0 28 52 85 d1 52 0 0 57 0 28 cm BI /IM true /W 52 /H 57 /BPC 1 /D[1 0] /F/CCF /DP<> ID & 0<"0G&x[>CLQ~> aiq0Y 0gP EI endstream endobj 121 0 obj <>stream 0 0 0 30 19 83 d1 19 0 0 53 0 30 cm BI /IM true /W 19 /H 53 /BPC 1 /D[1 0] /F/CCF /DP<> ID &|ɮkaa/ _5,0 EI endstream endobj 122 0 obj <> stream 60 0 0 0 0 0 d1 endstream endobj 123 0 obj <>stream 0 0 0 1 26 82 d1 26 0 0 81 0 1 cm BI /IM true /W 26 /H 81 /BPC 1 /D[1 0] /F/CCF /DP<> ID j)@_5L/ EI endstream endobj 124 0 obj <> stream 34 0 0 0 0 0 d1 endstream endobj 125 0 obj <> stream 77 0 0 0 0 0 d1 endstream endobj 126 0 obj <> stream 46 0 0 0 0 0 d1 endstream endobj 127 0 obj <> stream 100 0 0 0 0 0 d1 endstream endobj 128 0 obj <>stream 0 0 0 29 57 84 d1 57 0 0 55 0 29 cm BI /IM true /W 57 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &CAa<3 o OZ]W A5A  EI endstream endobj 129 0 obj <> stream 61 0 0 0 0 0 d1 endstream endobj 130 0 obj <>stream 0 0 0 -1 26 82 d1 26 0 0 83 0 -1 cm BI /IM true /W 26 /H 83 /BPC 1 /D[1 0] /F/CCF /DP<> ID j)@_5 EI endstream endobj 131 0 obj <>stream 0 0 0 -2 40 82 d1 40 0 0 84 0 -2 cm BI /IM true /W 40 /H 84 /BPC 1 /D[1 0] /F/CCF /DP<> ID &\OɨC@==O 7جX0P EI endstream endobj 132 0 obj <> stream 37 0 0 0 0 0 d1 endstream endobj 133 0 obj <>stream 0 0 0 30 56 84 d1 56 0 0 54 0 30 cm BI /IM true /W 56 /H 54 /BPC 1 /D[1 0] /F/CCF /DP<> ID &`2|~7?VWO׭_ޘA09@ EI endstream endobj 134 0 obj <> stream 103 0 0 0 0 0 d1 endstream endobj 135 0 obj <>stream 0 0 0 1 51 82 d1 51 0 0 81 0 1 cm BI /IM true /W 51 /H 81 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Hߜ @aa{ EI endstream endobj 136 0 obj <>stream 0 0 0 7 44 82 d1 44 0 0 75 0 7 cm BI /IM true /W 44 /H 75 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Qw5@Qc O@ EI endstream endobj 137 0 obj <>stream 0 0 0 16 50 84 d1 50 0 0 68 0 16 cm BI /IM true /W 50 /H 68 /BPC 1 /D[1 0] /F/CCF /DP<> ID &` zz@xD? ,)( EI endstream endobj 138 0 obj <>stream 0 0 0 28 48 84 d1 48 0 0 56 0 28 cm BI /IM true /W 48 /H 56 /BPC 1 /D[1 0] /F/CCF /DP<> ID &@@t ޾z}<%u֣*7_il/ /[_hD@ EI endstream endobj 139 0 obj <>stream 0 0 0 29 54 82 d1 54 0 0 53 0 29 cm BI /IM true /W 54 /H 53 /BPC 1 /D[1 0] /F/CCF /DP<> ID &ɮO}Nq\It8{0 EI endstream endobj 140 0 obj <>stream 0 0 0 28 55 84 d1 55 0 0 56 0 28 cm BI /IM true /W 55 /H 56 /BPC 1 /D[1 0] /F/CCF /DP<> ID &AF2ukCtpc]~ k x|Σ a?4G_^ -X`@ EI endstream endobj 141 0 obj <>stream 0 0 0 29 57 105 d1 57 0 0 76 0 29 cm BI /IM true /W 57 /H 76 /BPC 1 /D[1 0] /F/CCF /DP<> ID $j)@kZ"&a0@ a}~}ׯ]kX@"hRj$8h EI endstream endobj 142 0 obj <>stream 0 0 0 30 79 84 d1 79 0 0 54 0 30 cm BI /IM true /W 79 /H 54 /BPC 1 /D[1 0] /F/CCF /DP<> ID &6 ?k k׵i~z__Oo_ >Am}.c>_> stream 33 0 0 0 0 0 d1 endstream endobj 144 0 obj <> stream 135 0 0 0 0 0 d1 endstream endobj 145 0 obj <> stream 117 0 0 0 0 0 d1 endstream endobj 146 0 obj <>stream 0 0 0 9 47 82 d1 47 0 0 73 0 9 cm BI /IM true /W 47 /H 73 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Zqy5Kk!ɪ@@ EI endstream endobj 147 0 obj <> stream 118 0 0 0 0 0 d1 endstream endobj 148 0 obj <>stream 0 0 0 28 46 84 d1 46 0 0 56 0 28 cm BI /IM true /W 46 /H 56 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A8==D2z zL>AM&__ Av[a  EI endstream endobj 149 0 obj <> stream 62 0 0 0 0 0 d1 endstream endobj 150 0 obj <>stream 0 0 0 29 56 109 d1 56 0 0 80 0 29 cm BI /IM true /W 56 /H 80 /BPC 1 /D[1 0] /F/CCF /DP<> ID &P /-N0Aa/^^0r`)UL$) EI endstream endobj 151 0 obj <>stream 0 0 0 -1 57 84 d1 57 0 0 85 0 -1 cm BI /IM true /W 57 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &N>D?h0A7a}?_v&/a dᣏQ0 EI endstream endobj 152 0 obj <> stream 102 0 0 0 0 0 d1 endstream endobj 153 0 obj <> stream 32 0 0 0 0 0 d1 endstream endobj 154 0 obj <> stream 53 0 0 0 0 0 d1 endstream endobj 155 0 obj <> stream 56 0 0 0 0 0 d1 endstream endobj 156 0 obj <>stream 0 0 0 28 54 108 d1 54 0 0 80 0 28 cm BI /IM true /W 54 /H 80 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A6| =>z o.Kz!\Ap B)uGL8#P(>H {7&av/^ +Ma7$ EI endstream endobj 157 0 obj <>stream 0 0 0 30 58 82 d1 58 0 0 52 0 30 cm BI /IM true /W 58 /H 52 /BPC 1 /D[1 0] /F/CCF /DP<> ID %?jauM`/[ o޸iaۭoֺZxF[ՇWo ^a}C4/ EI endstream endobj 158 0 obj <> stream 97 0 0 0 0 0 d1 endstream endobj 159 0 obj <>stream 0 0 0 -2 58 82 d1 58 0 0 84 0 -2 cm BI /IM true /W 58 /H 84 /BPC 1 /D[1 0] /F/CCF /DP<> ID &/4#i5h ?\/+C1 EI endstream endobj 160 0 obj <>stream 0 0 0 30 56 106 d1 56 0 0 76 0 30 cm BI /IM true /W 56 /H 76 /BPC 1 /D[1 0] /F/CCF /DP<> ID &3@~ ŷo ? |'[}a-}o[oL   EI endstream endobj 161 0 obj <> stream 110 0 0 0 0 0 d1 endstream endobj 162 0 obj <> stream 108 0 0 0 0 0 d1 endstream endobj 163 0 obj <> stream 131 0 0 0 0 0 d1 endstream endobj 164 0 obj <>stream 0 0 0 -1 14 34 d1 14 0 0 35 0 -1 cm BI /IM true /W 14 /H 35 /BPC 1 /D[1 0] /F/CCF /DP<> ID &7 ߿^1& @ EI endstream endobj 165 0 obj <> stream 27 0 0 0 0 0 d1 endstream endobj 166 0 obj <> stream 35 0 0 0 0 0 d1 endstream endobj 167 0 obj <> stream 93 0 0 0 0 0 d1 endstream endobj 168 0 obj <> stream 109 0 0 0 0 0 d1 endstream endobj 169 0 obj <> stream 107 0 0 0 0 0 d1 endstream endobj 170 0 obj <> stream 95 0 0 0 0 0 d1 endstream endobj 171 0 obj <> stream 111 0 0 0 0 0 d1 endstream endobj 172 0 obj <>stream 0 0 0 0 68 82 d1 68 0 0 82 0 0 cm BI /IM true /W 68 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Ț@|>P ?߆_}xAz_ (AC` EI endstream endobj 173 0 obj <>stream 0 0 0 1 30 106 d1 30 0 0 105 0 1 cm BI /IM true /W 30 /H 105 /BPC 1 /D[1 0] /F/CCF /DP<> ID &~wɪMk:4O~_ EI endstream endobj 174 0 obj <>stream 0 0 0 0 79 82 d1 79 0 0 82 0 0 cm BI /IM true /W 79 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &FI4 ޭ7~/_//K Zd8_X4 EI endstream endobj 175 0 obj <>stream 0 0 0 -2 91 82 d1 91 0 0 84 0 -2 cm BI /IM true /W 91 /H 84 /BPC 1 /D[1 0] /F/CCF /DP<> ID &&Ȉ!4 #MB@oipkp4fa\& <0"|j EI endstream endobj 176 0 obj <>stream 0 0 0 53 32 61 d1 32 0 0 8 0 53 cm BI /IM true /W 32 /H 8 /BPC 1 /D[1 0] /F/CCF /DP<> ID  EI endstream endobj 177 0 obj <>stream 0 0 0 3 49 85 d1 49 0 0 82 0 3 cm BI /IM true /W 49 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &H`G'>}0'_/཮ h- o[a, q년@5}>a7 _._[ - b ,0 EI endstream endobj 178 0 obj <>stream 0 0 0 3 47 85 d1 47 0 0 82 0 3 cm BI /IM true /W 47 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &@h0H#1x0oM޿ S]?~G{_vFc !yͯ|(|(@ EI endstream endobj 179 0 obj <>stream 0 0 0 0 82 82 d1 82 0 0 82 0 0 cm BI /IM true /W 82 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &R c6-_^^^^_] K-xo_kװ޼1^^׵~߷? ~~~?_ EI endstream endobj 180 0 obj <> endobj 181 0 obj <> endobj 182 0 obj <>stream 0 0 0 0 82 85 d1 82 0 0 85 0 0 cm BI /IM true /W 82 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &k jI| )<- ޓ| IW¾s\(xd;k [k~07*~<x0O5y m\@ EI endstream endobj 186 0 obj <>stream 0 0 0 28 60 85 d1 60 0 0 57 0 28 cm BI /IM true /W 60 /H 57 /BPC 1 /D[1 0] /F/CCF /DP<> ID & >@ x zxFC`=7 ɯx\5zz/kaK`ȺAF EI endstream endobj 187 0 obj <>stream 0 0 0 29 67 83 d1 67 0 0 54 0 29 cm BI /IM true /W 67 /H 54 /BPC 1 /D[1 0] /F/CCF /DP<> ID &"hA?(оd* EI endstream endobj 188 0 obj <>stream 0 0 0 28 54 85 d1 54 0 0 57 0 28 cm BI /IM true /W 54 /H 57 /BPC 1 /D[1 0] /F/CCF /DP<> ID & 0z#| 7}&5M?IC:_k.a-a`0  EI endstream endobj 189 0 obj <>stream 0 0 0 0 47 78 d1 47 0 0 78 0 0 cm BI /IM true /W 47 /H 78 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A(? 1Cb? EI endstream endobj 190 0 obj <>stream 0 0 0 -4 43 78 d1 43 0 0 82 0 -4 cm BI /IM true /W 43 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID ?ā EI endstream endobj 191 0 obj <>stream 0 0 0 0 66 85 d1 66 0 0 85 0 0 cm BI /IM true /W 66 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &9@_ xA@P T2 tA^ᆻaw 'k"7#ra? @@ EI endstream endobj 192 0 obj <>stream 0 0 0 29 67 85 d1 67 0 0 56 0 29 cm BI /IM true /W 67 /H 56 /BPC 1 /D[1 0] /F/CCF /DP<> ID &/ a AD~?P=5rp.D@ EI endstream endobj 193 0 obj <>stream 0 0 0 -1 30 83 d1 30 0 0 84 0 -1 cm BI /IM true /W 30 /H 84 /BPC 1 /D[1 0] /F/CCF /DP<> ID &D\_A?_[ ( EI endstream endobj 194 0 obj <> stream 38 0 0 0 0 0 d1 endstream endobj 195 0 obj <>stream 0 0 0 5 55 83 d1 55 0 0 78 0 5 cm BI /IM true /W 55 /H 78 /BPC 1 /D[1 0] /F/CCF /DP<> ID &of0a}o;߾k { aa.OwKU^X`ȀX`Y @@ EI endstream endobj 196 0 obj <>stream 0 0 0 0 31 83 d1 31 0 0 83 0 0 cm BI /IM true /W 31 /H 83 /BPC 1 /D[1 0] /F/CCF /DP<> ID &D@@ EI endstream endobj 197 0 obj <>stream 0 0 0 5 55 85 d1 55 0 0 80 0 5 cm BI /IM true /W 55 /H 80 /BPC 1 /D[1 0] /F/CCF /DP<> ID &>Azz4 _a,.Ap. Ȁσ 'oȴNv @@~,05 EI endstream endobj 198 0 obj <> stream 41 0 0 0 0 0 d1 endstream endobj 199 0 obj <>stream 0 0 0 29 57 105 d1 57 0 0 76 0 29 cm BI /IM true /W 57 /H 76 /BPC 1 /D[1 0] /F/CCF /DP<> ID &kk)b́-@&zM?DŽ}_/_ h/z`'y x EI endstream endobj 200 0 obj <>stream 0 0 0 30 43 82 d1 43 0 0 52 0 30 cm BI /IM true /W 43 /H 52 /BPC 1 /D[1 0] /F/CCF /DP<> ID c&!{o ww}>xaow EI endstream endobj 201 0 obj <>stream 0 0 0 1 52 85 d1 52 0 0 84 0 1 cm BI /IM true /W 52 /H 84 /BPC 1 /D[1 0] /F/CCF /DP<> ID &f~a}~ݾߋ EI endstream endobj 202 0 obj <>stream 0 0 0 0 82 85 d1 82 0 0 85 0 0 cm BI /IM true /W 82 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &`5?EG^O>[VP?^ׅ}o߅>~&0O?BA@ EI endstream endobj 203 0 obj <> stream 121 0 0 0 0 0 d1 endstream endobj 204 0 obj <> stream 29 0 0 0 0 0 d1 endstream endobj 205 0 obj <>stream 0 0 0 3 49 85 d1 49 0 0 82 0 3 cm BI /IM true /W 49 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &^B |@x[" Ӧow{^! y| oo 1?K_ wam+h<@ EI endstream endobj 206 0 obj <> stream 143 0 0 0 0 0 d1 endstream endobj 207 0 obj <> stream 96 0 0 0 0 0 d1 endstream endobj 208 0 obj <>stream 0 0 0 0 86 85 d1 86 0 0 85 0 0 cm BI /IM true /W 86 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &j ?10+Ȁ" ް7MA[ }?O5x_Kzw zKzKa `,2 Xx,3Ld4 EI endstream endobj 209 0 obj <>stream 0 0 0 0 67 83 d1 67 0 0 83 0 0 cm BI /IM true /W 67 /H 83 /BPC 1 /D[1 0] /F/CCF /DP<> ID &"hAyh_ W`^?P?"  EI endstream endobj 210 0 obj <>stream 0 0 0 1 73 83 d1 73 0 0 82 0 1 cm BI /IM true /W 73 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &o%__|)~}}( EI endstream endobj 211 0 obj <>stream 0 0 0 -3 57 80 d1 57 0 0 83 0 -3 cm BI /IM true /W 57 /H 83 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A4=<'{~ =onp2o[7}`ٞ}|@ EI endstream endobj 212 0 obj <>stream 0 0 0 -1 55 82 d1 55 0 0 83 0 -1 cm BI /IM true /W 55 /H 83 /BPC 1 /D[1 0] /F/CCF /DP<> ID $QJskz_z^Kzz]]^.ik_oo?_Dpj&  EI endstream endobj 213 0 obj <> stream 142 0 0 0 0 0 d1 endstream endobj 214 0 obj <> stream 70 0 0 0 0 0 d1 endstream endobj 215 0 obj <>stream 0 0 0 0 60 78 d1 60 0 0 78 0 0 cm BI /IM true /W 60 /H 78 /BPC 1 /D[1 0] /F/CCF /DP<> ID &CK_&fg@~?? ߰ { EI endstream endobj 216 0 obj <>stream 0 0 0 -3 84 78 d1 84 0 0 81 0 -3 cm BI /IM true /W 84 /H 81 /BPC 1 /D[1 0] /F/CCF /DP<> ID &UCJf_fĆ+? EI endstream endobj 217 0 obj <>stream 0 0 0 25 66 102 d1 66 0 0 77 0 25 cm BI /IM true /W 66 /H 77 /BPC 1 /D[1 0] /F/CCF /DP<> ID &$xA<' rj{ uoX~_^}o Mרo+.   EI endstream endobj 218 0 obj <>stream 0 0 0 24 66 101 d1 66 0 0 77 0 24 cm BI /IM true /W 66 /H 77 /BPC 1 /D[1 0] /F/CCF /DP<> ID #AQDxA |C  >o ?_]iD%†B)5 !Q EI endstream endobj 219 0 obj <>stream 0 0 0 1 91 83 d1 91 0 0 82 0 1 cm BI /IM true /W 91 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &VM/4aA* \o?7_z_zz^ׄ` FVp\ @ EI endstream endobj 220 0 obj <>stream 0 0 0 5 58 85 d1 58 0 0 80 0 5 cm BI /IM true /W 58 /H 80 /BPC 1 /D[1 0] /F/CCF /DP<> ID & AAz:Az aI}oo ?턿zk `-a~,r37 EI endstream endobj 221 0 obj <> stream 137 0 0 0 0 0 d1 endstream endobj 222 0 obj <>stream 0 0 0 0 55 80 d1 55 0 0 80 0 0 cm BI /IM true /W 55 /H 80 /BPC 1 /D[1 0] /F/CCF /DP<> ID & Cx |@& ?|?N ENkKpa. % 0^ /C c)f>f~l4 EI endstream endobj 223 0 obj <>stream 0 0 0 -4 81 78 d1 81 0 0 82 0 -4 cm BI /IM true /W 81 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID %PsP)BFUC|Geῇ_ }z ^AAx(Rhe( EI endstream endobj 224 0 obj <> stream 67 0 0 0 0 0 d1 endstream endobj 225 0 obj <>stream 0 0 0 29 106 83 d1 106 0 0 54 0 29 cm BI /IM true /W 106 /H 54 /BPC 1 /D[1 0] /F/CCF /DP<> ID &M(Ђ?KtMvE`L41A_kY d00H  EI endstream endobj 226 0 obj <> stream 113 0 0 0 0 0 d1 endstream endobj 227 0 obj <>stream 0 0 0 30 92 83 d1 92 0 0 53 0 30 cm BI /IM true /W 92 /H 53 /BPC 1 /D[1 0] /F/CCF /DP<> ID &p3V  GO o>ao}[[Z__NZ[TFH  EI endstream endobj 228 0 obj <>stream 0 0 0 1 118 83 d1 118 0 0 82 0 1 cm BI /IM true /W 118 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &s`O&du?EA?M?[7ooAMO[ 7Ooodl7@ EI endstream endobj 229 0 obj <> stream 127 0 0 0 0 0 d1 endstream endobj 230 0 obj <>stream 0 0 0 30 66 83 d1 66 0 0 53 0 30 cm BI /IM true /W 66 /H 53 /BPC 1 /D[1 0] /F/CCF /DP<> ID &x)?Η[&} }azҸ EI endstream endobj 231 0 obj <>stream 0 0 0 0 55 80 d1 55 0 0 80 0 0 cm BI /IM true /W 55 /H 80 /BPC 1 /D[1 0] /F/CCF /DP<> ID &܆> A >t 7>A7_îsRi|0_b`P?O6?om[_ ,`p EI endstream endobj 232 0 obj <>stream 0 0 0 -1 85 83 d1 85 0 0 84 0 -1 cm BI /IM true /W 85 /H 84 /BPC 1 /D[1 0] /F/CCF /DP<> ID &o)5t@1 Ǩ ?}?w;e8@u dY CKR  EI endstream endobj 233 0 obj <> stream 36 0 0 0 0 0 d1 endstream endobj 234 0 obj <>stream 0 0 0 1 84 83 d1 84 0 0 82 0 1 cm BI /IM true /W 84 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &|0jC,~  Br P4aC`~C-?~~%r>\ EI endstream endobj 235 0 obj <>stream 0 0 0 10 43 83 d1 43 0 0 73 0 10 cm BI /IM true /W 43 /H 73 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Zqy5AӋɮ EI endstream endobj 236 0 obj <> stream 124 0 0 0 0 0 d1 endstream endobj 237 0 obj <>stream 0 0 0 10 54 83 d1 54 0 0 73 0 10 cm BI /IM true /W 54 /H 73 /BPC 1 /D[1 0] /F/CCF /DP<> ID &kJ˧΢.“]@@ EI endstream endobj 238 0 obj <> stream 119 0 0 0 0 0 d1 endstream endobj 239 0 obj <>stream 0 0 0 -4 97 80 d1 97 0 0 84 0 -4 cm BI /IM true /W 97 /H 84 /BPC 1 /D[1 0] /F/CCF /DP<> ID &xCK(<zDa>y55B[s_}//_5~ 0?~/!EAB&A EI endstream endobj 240 0 obj <>stream 0 0 0 29 61 109 d1 61 0 0 80 0 29 cm BI /IM true /W 61 /H 80 /BPC 1 /D[1 0] /F/CCF /DP<> ID &!<E8a7z_]d .-E>N ȡq{:@azMڗߧvv G)`h  EI endstream endobj 241 0 obj <>stream 0 0 0 1 97 83 d1 97 0 0 82 0 1 cm BI /IM true /W 97 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &JC3jOx]> zJMzM <%zM& 7פ޷I`3I EI endstream endobj 242 0 obj <>stream 0 0 0 0 115 85 d1 115 0 0 85 0 0 cm BI /IM true /W 115 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &`L4OOOOz ?k|' 7߾p[V-? $k}>moz-> ׾$h4 !* EI endstream endobj 243 0 obj <> stream 130 0 0 0 0 0 d1 endstream endobj 244 0 obj <> stream 150 0 0 0 0 0 d1 endstream endobj 245 0 obj <>stream 0 0 0 0 55 80 d1 55 0 0 80 0 0 cm BI /IM true /W 55 /H 80 /BPC 1 /D[1 0] /F/CCF /DP<> ID &>C OC  ? }_\0Kp. `!`%iaoA7a~~_^Av *؅`a`΁@ EI endstream endobj 246 0 obj <>stream 0 0 0 -4 96 78 d1 96 0 0 82 0 -4 cm BI /IM true /W 96 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &)𾾿____ 1}A__/~/__/KA~K__/K_Bd` EI endstream endobj 247 0 obj <>stream 0 0 0 50 35 62 d1 35 0 0 12 0 50 cm BI /IM true /W 35 /H 12 /BPC 1 /D[1 0] /F/CCF /DP<> ID  EI endstream endobj 248 0 obj <>stream 0 0 0 1 81 83 d1 81 0 0 82 0 1 cm BI /IM true /W 81 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID ; 55_5U?4g_ep?/O}/}@ EI endstream endobj 249 0 obj <>stream 0 0 0 30 66 83 d1 66 0 0 53 0 30 cm BI /IM true /W 66 /H 53 /BPC 1 /D[1 0] /F/CCF /DP<> ID *)(:iauim[ /[Xk KF~70o[7 ? EI endstream endobj 250 0 obj <>stream 0 0 0 -7 34 113 d1 34 0 0 120 0 -7 cm BI /IM true /W 34 /H 120 /BPC 1 /D[1 0] /F/CCF /DP<> ID &-, \%]tp/z/Z/߼0o}7ۇ EI endstream endobj 251 0 obj <>stream 0 0 0 -7 33 113 d1 33 0 0 120 0 -7 cm BI /IM true /W 33 /H 120 /BPC 1 /D[1 0] /F/CCF /DP<> ID 8ÓTo߇__-_ ^atK  EI endstream endobj 252 0 obj <>stream 0 0 0 -2 81 105 d1 81 0 0 107 0 -2 cm BI /IM true /W 81 /H 107 /BPC 1 /D[1 0] /F/CCF /DP<> ID &fx z}=5A3(.$xxA$U6K=~ajpZ moدI_B [?k_6kv ,=o l%k0KxXm @N פ@ EI endstream endobj 253 0 obj <> endobj 254 0 obj <>stream 0 0 0 0 55 80 d1 55 0 0 80 0 0 cm BI /IM true /W 55 /H 80 /BPC 1 /D[1 0] /F/CCF /DP<> ID & 2CzO0Ӿi׆ ty '>OA$}u^ïkl%l0aa٤@ EI endstream endobj 258 0 obj <> stream 39 0 0 0 0 0 d1 endstream endobj 259 0 obj <> endobj 260 0 obj <>stream 0 0 0 0 38 79 d1 38 0 0 79 0 0 cm BI /IM true /W 38 /H 79 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Mpo?*> !\Q EI endstream endobj 264 0 obj <>stream 0 0 0 -3 48 79 d1 48 0 0 82 0 -3 cm BI /IM true /W 48 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID "M~B鵇' EI endstream endobj 265 0 obj <>stream 0 0 0 -3 92 79 d1 92 0 0 82 0 -3 cm BI /IM true /W 92 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID & scF8A_i_?׿A_+W_/AA! EI endstream endobj 266 0 obj <>stream 0 0 0 -3 77 79 d1 77 0 0 82 0 -3 cm BI /IM true /W 77 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &AX`fɪzo\  EI endstream endobj 267 0 obj <>stream 0 0 0 -3 84 82 d1 84 0 0 85 0 -3 cm BI /IM true /W 84 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &xnh?4П ߭J}>- ~./K,?pP0H}߾ /KKL,p_he EI endstream endobj 268 0 obj <>stream 0 0 0 -5 81 82 d1 81 0 0 87 0 -5 cm BI /IM true /W 81 /H 87 /BPC 1 /D[1 0] /F/CCF /DP<> ID &t? xA^,= `}L=ao /Va\? ߺ]kì] %ioK 21Y Py  EI endstream endobj 269 0 obj <>stream 0 0 0 -3 86 79 d1 86 0 0 82 0 -3 cm BI /IM true /W 86 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &I+AoV ao=~l?~ÿۇ[p dk`.  EI endstream endobj 270 0 obj <>stream 0 0 0 -3 79 82 d1 79 0 0 85 0 -3 cm BI /IM true /W 79 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &ܐ  <"^7ս ްo ~޿>??0A6Cb EI endstream endobj 271 0 obj <>stream 0 0 0 -5 81 82 d1 81 0 0 87 0 -5 cm BI /IM true /W 81 /H 87 /BPC 1 /D[1 0] /F/CCF /DP<> ID &t y @ D  􁇄}C7A?P?z=_߿w] 0 4yvAאj `rCl@ EI endstream endobj 272 0 obj <> stream 81 0 0 0 0 0 d1 endstream endobj 273 0 obj <> stream 116 0 0 0 0 0 d1 endstream endobj 274 0 obj <>stream 0 0 0 29 60 82 d1 60 0 0 53 0 29 cm BI /IM true /W 60 /H 53 /BPC 1 /D[1 0] /F/CCF /DP<> ID &GSQ 4k%0a{Gԍ ɪ(40 EI endstream endobj 275 0 obj <>stream 0 0 0 9 56 84 d1 56 0 0 75 0 9 cm BI /IM true /W 56 /H 75 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A@ed]pAwO=r bW~II ɯ/ka fe_0^^?Aua@@ EI endstream endobj 276 0 obj <>stream 0 0 0 30 58 84 d1 58 0 0 54 0 30 cm BI /IM true /W 58 /H 54 /BPC 1 /D[1 0] /F/CCF /DP<> ID &_-p@Ӻ։3=dV5U  EI endstream endobj 277 0 obj <>stream 0 0 0 28 45 84 d1 45 0 0 56 0 28 cm BI /IM true /W 45 /H 56 /BPC 1 /D[1 0] /F/CCF /DP<> ID & D@OA=Fz:~&|}ɪAm{5᭯X0gP EI endstream endobj 278 0 obj <>stream 0 0 0 69 15 82 d1 15 0 0 13 0 69 cm BI /IM true /W 15 /H 13 /BPC 1 /D[1 0] /F/CCF /DP<> ID & kj  EI endstream endobj 280 0 obj <>stream 0 0 0 0 73 84 d1 73 0 0 84 0 0 cm BI /IM true /W 73 /H 84 /BPC 1 /D[1 0] /F/CCF /DP<> ID &0C`{LIpPH=a ?a\1?X` ! R  EI endstream endobj 281 0 obj <>stream 0 0 0 -8 28 112 d1 28 0 0 120 0 -8 cm BI /IM true /W 28 /H 120 /BPC 1 /D[1 0] /F/CCF /DP<> ID &cXZZ -p]~p/z__a{x}{p EI endstream endobj 282 0 obj <> stream 139 0 0 0 0 0 d1 endstream endobj 283 0 obj <>stream 0 0 0 0 83 82 d1 83 0 0 82 0 0 cm BI /IM true /W 83 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID TH( @; `ov0m{߿p7o}[]p/]8_ g EI endstream endobj 284 0 obj <>stream 0 0 0 29 45 84 d1 45 0 0 55 0 29 cm BI /IM true /W 45 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &ȵ  o޷{{d~o6-0.<5/H EI endstream endobj 285 0 obj <>stream 0 0 0 29 59 84 d1 59 0 0 55 0 29 cm BI /IM true /W 59 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &p3O>?=?}ws_{߿߿rkv_uíxh0[C=  EI endstream endobj 286 0 obj <>stream 0 0 0 -1 17 34 d1 17 0 0 35 0 -1 cm BI /IM true /W 17 /H 35 /BPC 1 /D[1 0] /F/CCF /DP<> ID 0MP{x}g,!j  EI endstream endobj 287 0 obj <>stream 0 0 0 7 33 84 d1 33 0 0 77 0 7 cm BI /IM true /W 33 /H 77 /BPC 1 /D[1 0] /F/CCF /DP<> ID &~߇a=$Brk |@ EI endstream endobj 288 0 obj <>stream 0 0 0 0 64 82 d1 64 0 0 82 0 0 cm BI /IM true /W 64 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID +?P?a ?{3w EI endstream endobj 289 0 obj <>stream 0 0 0 29 57 105 d1 57 0 0 76 0 29 cm BI /IM true /W 57 /H 76 /BPC 1 /D[1 0] /F/CCF /DP<> ID !H?R'_@7~{ =ÿ ?Mv~h-iqdž ` EI endstream endobj 290 0 obj <>stream 0 0 0 70 19 105 d1 19 0 0 35 0 70 cm BI /IM true /W 19 /H 35 /BPC 1 /D[1 0] /F/CCF /DP<> ID 0 Too>=0 EI endstream endobj 291 0 obj <>stream 0 0 0 0 53 82 d1 53 0 0 82 0 0 cm BI /IM true /W 53 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &&5???h EI endstream endobj 292 0 obj <>stream 0 0 0 29 41 84 d1 41 0 0 55 0 29 cm BI /IM true /W 41 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &?ȩxa%4~? ~_& H 81.A~@pxww߶߆uia/H EI endstream endobj 293 0 obj <>stream 0 0 0 29 47 84 d1 47 0 0 55 0 29 cm BI /IM true /W 47 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &p5><d1O6Hh.8[A@@ EI endstream endobj 294 0 obj <>stream 0 0 0 29 51 84 d1 51 0 0 55 0 29 cm BI /IM true /W 51 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &σ xG0A} K7>L~~C{o߼?߼H5 EI endstream endobj 295 0 obj <>stream 0 0 0 70 13 82 d1 13 0 0 12 0 70 cm BI /IM true /W 13 /H 12 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A  EI endstream endobj 296 0 obj <>stream 0 0 0 -8 28 112 d1 28 0 0 120 0 -8 cm BI /IM true /W 28 /H 120 /BPC 1 /D[1 0] /F/CCF /DP<> ID &{{|7{{??_kz_ֽaz׭uZu@ EI endstream endobj 297 0 obj <> stream 30 0 0 0 0 0 d1 endstream endobj 298 0 obj <>stream 0 0 0 -14 28 39 d1 28 0 0 53 0 -14 cm BI /IM true /W 28 /H 53 /BPC 1 /D[1 0] /F/CCF /DP<> ID &5!{@ EI endstream endobj 299 0 obj <>stream 0 0 0 29 41 84 d1 41 0 0 55 0 29 cm BI /IM true /W 41 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &J?GzS PPo۵j>stream 0 0 0 -1 26 84 d1 26 0 0 85 0 -1 cm BI /IM true /W 26 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &|zO~{M}ÇD @ EI endstream endobj 301 0 obj <>stream 0 0 0 29 55 84 d1 55 0 0 55 0 29 cm BI /IM true /W 55 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &`O>l m/Iww!wa󃽇ᆂk ! EI endstream endobj 302 0 obj <>stream 0 0 0 29 41 84 d1 41 0 0 55 0 29 cm BI /IM true /W 41 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &J?a xA}7&߿'^>d \.h:p00,z@@ EI endstream endobj 303 0 obj <>stream 0 0 0 0 31 93 d1 31 0 0 93 0 0 cm BI /IM true /W 31 /H 93 /BPC 1 /D[1 0] /F/CCF /DP<> ID &]a:ZZ-ZuֽatZ__&?{{}=?5 EI endstream endobj 304 0 obj <>stream 0 0 0 8 49 83 d1 49 0 0 75 0 8 cm BI /IM true /W 49 /H 75 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A,ɯb톟i} H EI endstream endobj 305 0 obj <>stream 0 0 0 7 41 82 d1 41 0 0 75 0 7 cm BI /IM true /W 41 /H 75 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Z}?E}@ EI endstream endobj 306 0 obj <> stream 128 0 0 0 0 0 d1 endstream endobj 307 0 obj <>stream 0 0 0 7 49 84 d1 49 0 0 77 0 7 cm BI /IM true /W 49 /H 77 /BPC 1 /D[1 0] /F/CCF /DP<> ID &3 x  >AOwKK޶  kk/ EI endstream endobj 308 0 obj <>stream 0 0 0 -1 31 92 d1 31 0 0 93 0 -1 cm BI /IM true /W 31 /H 93 /BPC 1 /D[1 0] /F/CCF /DP<> ID &.!Mw{὾߇o~_~ֽk]axZ֖-.&P EI endstream endobj 309 0 obj <>stream 0 0 0 76 2 84 d1 2 0 0 8 0 76 cm BI /IM true /W 2 /H 8 /BPC 1 /D[1 0] /F/CCF /DP<> ID T@ EI endstream endobj 310 0 obj <>stream 0 0 0 7 49 82 d1 49 0 0 75 0 7 cm BI /IM true /W 49 /H 75 /BPC 1 /D[1 0] /F/CCF /DP<> ID &ӯ|0}[ v{{ᇆ{{}7὾}o>z`4a"ձ_aaG@ EI endstream endobj 311 0 obj <>stream 0 0 0 7 52 84 d1 52 0 0 77 0 7 cm BI /IM true /W 52 /H 77 /BPC 1 /D[1 0] /F/CCF /DP<> ID &>C =?5`~[k_%\,׼Q}?ᄶaD bkk ,p  EI endstream endobj 312 0 obj <>stream 0 0 0 7 54 82 d1 54 0 0 75 0 7 cm BI /IM true /W 54 /H 75 /BPC 1 /D[1 0] /F/CCF /DP<> ID &t5EM!5~oo/ EI endstream endobj 313 0 obj <>stream 0 0 0 9 49 84 d1 49 0 0 75 0 9 cm BI /IM true /W 49 /H 75 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A 3xOOo_? _t& ~ K]sD y~?=j  EI endstream endobj 314 0 obj <>stream 0 0 0 7 49 84 d1 49 0 0 77 0 7 cm BI /IM true /W 49 /H 77 /BPC 1 /D[1 0] /F/CCF /DP<> ID &azz7 A7_] / v /i._^ /!w~ m>*kH EI endstream endobj 315 0 obj <> stream 123 0 0 0 0 0 d1 endstream endobj 316 0 obj <>stream 0 0 0 7 52 84 d1 52 0 0 77 0 7 cm BI /IM true /W 52 /H 77 /BPC 1 /D[1 0] /F/CCF /DP<> ID &hz>stream 0 0 0 7 52 84 d1 52 0 0 77 0 7 cm BI /IM true /W 52 /H 77 /BPC 1 /D[1 0] /F/CCF /DP<> ID &>Aq"<' xD0]}>}?Oakkua+ CzxA}&_׆a.\=lAlWm`aG@ EI endstream endobj 318 0 obj <>stream 0 0 0 7 49 84 d1 49 0 0 77 0 7 cm BI /IM true /W 49 /H 77 /BPC 1 /D[1 0] /F/CCF /DP<> ID &/D`h?A?߷ >!߿߿ *އ_D0  u]k zRW5Xad3 EI endstream endobj 319 0 obj <> stream 129 0 0 0 0 0 d1 endstream endobj 320 0 obj <>stream 0 0 0 30 13 82 d1 13 0 0 52 0 30 cm BI /IM true /W 13 /H 52 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Mu`_` EI endstream endobj 321 0 obj <>stream 0 0 0 -1 51 84 d1 51 0 0 85 0 -1 cm BI /IM true /W 51 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &0|?vI5\7_-K@[ Do 0{a^= _3  EI endstream endobj 322 0 obj <>stream 0 0 0 29 50 106 d1 50 0 0 77 0 29 cm BI /IM true /W 50 /H 77 /BPC 1 /D[1 0] /F/CCF /DP<> ID &TA?Lm75o |p }'?>ɯ~݇{ 4 a0 EI endstream endobj 323 0 obj <>stream 0 0 0 29 72 84 d1 72 0 0 55 0 29 cm BI /IM true /W 72 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A0hBk>0[ H6o6izvwow{kþok_ 4@Xaa@@ EI endstream endobj 324 0 obj <>stream 0 0 0 -1 54 84 d1 54 0 0 85 0 -1 cm BI /IM true /W 54 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &σ?<#Ga~}&?ۿ?w{{]yKk|~?Z EI endstream endobj 325 0 obj <>stream 0 0 0 29 52 106 d1 52 0 0 77 0 29 cm BI /IM true /W 52 /H 77 /BPC 1 /D[1 0] /F/CCF /DP<> ID &X z3a|0C G w$ ?w aۇ߆koK   EI endstream endobj 326 0 obj <> stream 40 0 0 0 0 0 d1 endstream endobj 327 0 obj <>stream 0 0 0 29 89 84 d1 89 0 0 55 0 29 cm BI /IM true /W 89 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &p  0Aa߇wp|? 濇w{~5 ?wwϯ}[{a[ |?L:aæ & .8A B) EI endstream endobj 328 0 obj <>stream 0 0 0 48 117 51 d1 117 0 0 3 0 48 cm BI /IM true /W 117 /H 3 /BPC 1 /D[1 0] /F/CCF /DP<> ID  EI endstream endobj 329 0 obj <>stream 0 0 0 30 15 82 d1 15 0 0 52 0 30 cm BI /IM true /W 15 /H 52 /BPC 1 /D[1 0] /F/CCF /DP<> ID & kk EI endstream endobj 330 0 obj <>stream 0 0 0 29 58 82 d1 58 0 0 53 0 29 cm BI /IM true /W 58 /H 53 /BPC 1 /D[1 0] /F/CCF /DP<> ID &P(Za8&5JO k ]*bɪ_ b ( EI endstream endobj 331 0 obj <>stream 0 0 0 28 44 84 d1 44 0 0 56 0 28 cm BI /IM true /W 44 /H 56 /BPC 1 /D[1 0] /F/CCF /DP<> ID &@LA#u=6Rj^ W O- 30D4wT׆.}% @@ EI endstream endobj 332 0 obj <> stream 141 0 0 0 0 0 d1 endstream endobj 333 0 obj <>stream 0 0 0 9 56 84 d1 56 0 0 75 0 9 cm BI /IM true /W 56 /H 75 /BPC 1 /D[1 0] /F/CCF /DP<> ID &H>CA0|_q @7^z`W !׬& EI endstream endobj 334 0 obj <>stream 0 0 0 10 56 83 d1 56 0 0 73 0 10 cm BI /IM true /W 56 /H 73 /BPC 1 /D[1 0] /F/CCF /DP<> ID &(RjY 2)}ץz/]ip/ {~߰7~߷ OO0* EI endstream endobj 335 0 obj <>stream 0 0 0 30 55 110 d1 55 0 0 80 0 30 cm BI /IM true /W 55 /H 80 /BPC 1 /D[1 0] /F/CCF /DP<> ID & zz}.^K޿[?_?_!D4' |5 EI endstream endobj 336 0 obj <>stream 0 0 0 30 54 82 d1 54 0 0 52 0 30 cm BI /IM true /W 54 /H 52 /BPC 1 /D[1 0] /F/CCF /DP<> ID &." 5k"Pvt 5pKmv׊ }O:}? zMF#M8P EI endstream endobj 337 0 obj <>stream 0 0 0 0 27 46 d1 27 0 0 46 0 0 cm BI /IM true /W 27 /H 46 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Mʿ|< EI endstream endobj 338 0 obj <>stream 0 0 0 13 71 82 d1 71 0 0 69 0 13 cm BI /IM true /W 71 /H 69 /BPC 1 /D[1 0] /F/CCF /DP<> ID &܁ha?ׂ*5+}zOa/z>o}7}(zhėo EI endstream endobj 339 0 obj <>stream 0 0 0 36 45 84 d1 45 0 0 48 0 36 cm BI /IM true /W 45 /H 48 /BPC 1 /D[1 0] /F/CCF /DP<> ID &@13PzMAXz Ow&_K_ m.ް !~( EI endstream endobj 340 0 obj <>stream 0 0 0 37 50 84 d1 50 0 0 47 0 37 cm BI /IM true /W 50 /H 47 /BPC 1 /D[1 0] /F/CCF /DP<> ID &8cAΡ 9A,d_Qh EI endstream endobj 341 0 obj <>stream 0 0 0 36 38 84 d1 38 0 0 48 0 36 cm BI /IM true /W 38 /H 48 /BPC 1 /D[1 0] /F/CCF /DP<> ID &8joHxA7}&_}u!ɮ#=|0ݬ0N@ EI endstream endobj 342 0 obj <>stream 0 0 0 36 47 84 d1 47 0 0 48 0 36 cm BI /IM true /W 47 /H 48 /BPC 1 /D[1 0] /F/CCF /DP<> ID &IϟFm<,zA矠c7\?~ |ʿ!?w__A K A~A EI endstream endobj 343 0 obj <>stream 0 0 0 37 50 82 d1 50 0 0 45 0 37 cm BI /IM true /W 50 /H 45 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Nis4-[ BQ@ EI endstream endobj 344 0 obj <>stream 0 0 0 12 22 82 d1 22 0 0 70 0 12 cm BI /IM true /W 22 /H 70 /BPC 1 /D[1 0] /F/CCF /DP<> ID jDkɨ EI endstream endobj 345 0 obj <>stream 0 0 0 36 32 84 d1 32 0 0 48 0 36 cm BI /IM true /W 32 /H 48 /BPC 1 /D[1 0] /F/CCF /DP<> ID 0!_ m8 7_ PU/BX%Z8PD3kkapboN<@ EI endstream endobj 346 0 obj <>stream 0 0 0 36 39 84 d1 39 0 0 48 0 36 cm BI /IM true /W 39 /H 48 /BPC 1 /D[1 0] /F/CCF /DP<> ID &8DFb0Iޯp%h j_ׇ_h,=a a_' EI endstream endobj 347 0 obj <>stream 0 0 0 19 38 82 d1 38 0 0 63 0 19 cm BI /IM true /W 38 /H 63 /BPC 1 /D[1 0] /F/CCF /DP<> ID &EjAy5^? EI endstream endobj 348 0 obj <>stream 0 0 0 27 43 82 d1 43 0 0 55 0 27 cm BI /IM true /W 43 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &ܠ$ >[(^/5K! EI endstream endobj 349 0 obj <>stream 0 0 0 39 43 82 d1 43 0 0 43 0 39 cm BI /IM true /W 43 /H 43 /BPC 1 /D[1 0] /F/CCF /DP<> ID &C0" 5Z φ_uXa~ EI endstream endobj 350 0 obj <>stream 0 0 0 39 46 82 d1 46 0 0 43 0 39 cm BI /IM true /W 46 /H 43 /BPC 1 /D[1 0] /F/CCF /DP<> ID & MRyia?h(cX5&  EI endstream endobj 351 0 obj <>stream 0 0 0 39 48 82 d1 48 0 0 43 0 39 cm BI /IM true /W 48 /H 43 /BPC 1 /D[1 0] /F/CCF /DP<> ID &" a@P # :'cG4'4GpAix_kj EI endstream endobj 352 0 obj <>stream 0 0 0 71 13 102 d1 13 0 0 31 0 71 cm BI /IM true /W 13 /H 31 /BPC 1 /D[1 0] /F/CCF /DP<> ID &~˾c  EI endstream endobj 353 0 obj <>stream 0 0 0 12 49 84 d1 49 0 0 72 0 12 cm BI /IM true /W 49 /H 72 /BPC 1 /D[1 0] /F/CCF /DP<> ID &+ao7//u .yi{^ɨ EI endstream endobj 354 0 obj <>stream 0 0 0 21 32 84 d1 32 0 0 63 0 21 cm BI /IM true /W 32 /H 63 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A|fo_?$$}  EI endstream endobj 355 0 obj <>stream 0 0 0 15 22 82 d1 22 0 0 67 0 15 cm BI /IM true /W 22 /H 67 /BPC 1 /D[1 0] /F/CCF /DP<> ID jDkXQ=?0 EI endstream endobj 356 0 obj <>stream 0 0 0 37 49 102 d1 49 0 0 65 0 37 cm BI /IM true /W 49 /H 65 /BPC 1 /D[1 0] /F/CCF /DP<> ID /85".G? O}x_KvX xX1 MG  EI endstream endobj 357 0 obj <>stream 0 0 0 37 34 82 d1 34 0 0 45 0 37 cm BI /IM true /W 34 /H 45 /BPC 1 /D[1 0] /F/CCF /DP<> ID *8k |a>- `IC  EI endstream endobj 358 0 obj <>stream 0 0 0 11 34 82 d1 34 0 0 71 0 11 cm BI /IM true /W 34 /H 71 /BPC 1 /D[1 0] /F/CCF /DP<> ID &gfa> EI endstream endobj 359 0 obj <> stream 31 0 0 0 0 0 d1 endstream endobj 360 0 obj <>stream 0 0 0 12 49 84 d1 49 0 0 72 0 12 cm BI /IM true /W 49 /H 72 /BPC 1 /D[1 0] /F/CCF /DP<> ID &8c97>(|-| ZA~_ .a]x1^ _eҜ@ EI endstream endobj 361 0 obj <>stream 0 0 0 39 48 84 d1 48 0 0 45 0 39 cm BI /IM true /W 48 /H 45 /BPC 1 /D[1 0] /F/CCF /DP<> ID &75}o߅XoOzi@ EI endstream endobj 362 0 obj <>stream 0 0 0 11 51 82 d1 51 0 0 71 0 11 cm BI /IM true /W 51 /H 71 /BPC 1 /D[1 0] /F/CCF /DP<> ID &/}QLG\?o  ` EI endstream endobj 363 0 obj <>stream 0 0 0 39 67 84 d1 67 0 0 45 0 39 cm BI /IM true /W 67 /H 45 /BPC 1 /D[1 0] /F/CCF /DP<> ID &g0?_AtդMx}PT'q:@ EI endstream endobj 364 0 obj <>stream 0 0 0 12 50 82 d1 50 0 0 70 0 12 cm BI /IM true /W 50 /H 70 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Nis4_` ޼ɨ EI endstream endobj 365 0 obj <>stream 0 0 0 11 60 85 d1 60 0 0 74 0 11 cm BI /IM true /W 60 /H 74 /BPC 1 /D[1 0] /F/CCF /DP<> ID &C D@c6$Xx A o &}'¿__@am[k0{Da8 EI endstream endobj 366 0 obj <>stream 0 0 0 37 78 82 d1 78 0 0 45 0 37 cm BI /IM true /W 78 /H 45 /BPC 1 /D[1 0] /F/CCF /DP<> ID ȃ?jDA80PV /a.fo66L4Q / EI endstream endobj 367 0 obj <>stream 0 0 0 13 55 82 d1 55 0 0 69 0 13 cm BI /IM true /W 55 /H 69 /BPC 1 /D[1 0] /F/CCF /DP<> ID 5v7Jo  EI endstream endobj 368 0 obj <>stream 0 0 0 39 38 82 d1 38 0 0 43 0 39 cm BI /IM true /W 38 /H 43 /BPC 1 /D[1 0] /F/CCF /DP<> ID _'2jþ۷ ?}<7Eaoÿm @ EI endstream endobj 369 0 obj <>stream 0 0 0 36 46 104 d1 46 0 0 68 0 36 cm BI /IM true /W 46 /H 68 /BPC 1 /D[1 0] /F/CCF /DP<> ID &0@0|'M5L/2+Z 0z3_䏶?&  v׆a! EI endstream endobj 370 0 obj <>stream 0 0 0 71 12 82 d1 12 0 0 11 0 71 cm BI /IM true /W 12 /H 11 /BPC 1 /D[1 0] /F/CCF /DP<> ID &ۂ!MPX0 EI endstream endobj 371 0 obj <> endobj 372 0 obj <>stream 0 0 0 0 57 79 d1 57 0 0 79 0 0 cm BI /IM true /W 57 /H 79 /BPC 1 /D[1 0] /F/CCF /DP<> ID &3~m a߰a{o|7{{{{{ A; v/]ap,5 Ј EI endstream endobj 376 0 obj <>stream 0 0 0 -3 68 79 d1 68 0 0 82 0 -3 cm BI /IM true /W 68 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID & !F7?}0?qO EI endstream endobj 377 0 obj <>stream 0 0 0 -6 80 79 d1 80 0 0 85 0 -6 cm BI /IM true /W 80 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID *+55*Xk ׿ ?׿zok_[8Xۯ /{_-[ EI endstream endobj 378 0 obj <>stream 0 0 0 -5 64 82 d1 64 0 0 87 0 -5 cm BI /IM true /W 64 /H 87 /BPC 1 /D[1 0] /F/CCF /DP<> ID &C ݂"'4 a`#@!A~oO{7|/׫B0\Qq%XAkL ̧ /D4_xkavxa9$0`nA EI endstream endobj 379 0 obj <>stream 0 0 0 -3 78 79 d1 78 0 0 82 0 -3 cm BI /IM true /W 78 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &p@fUa~l?}m<~^O 7p}az!f EI endstream endobj 380 0 obj <>stream 0 0 0 0 78 87 d1 78 0 0 87 0 0 cm BI /IM true /W 78 /H 87 /BPC 1 /D[1 0] /F/CCF /DP<> ID &r<"@}0 xH7I[V7߰h >|0|2@WkyD8 EI endstream endobj 381 0 obj <>stream 0 0 0 3 29 84 d1 29 0 0 81 0 3 cm BI /IM true /W 29 /H 81 /BPC 1 /D[1 0] /F/CCF /DP<> ID &AzO~ks_aXa@ EI endstream endobj 382 0 obj <>stream 0 0 0 3 55 85 d1 55 0 0 82 0 3 cm BI /IM true /W 55 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID 8 <95 ^06~Oo o7= ay}ލ6Mpwn~]x[ia40Y@ EI endstream endobj 383 0 obj <>stream 0 0 0 0 80 82 d1 80 0 0 82 0 0 cm BI /IM true /W 80 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A(ro߾o4_߿^wx__ / _ EI endstream endobj 384 0 obj <>stream 0 0 0 29 47 105 d1 47 0 0 76 0 29 cm BI /IM true /W 47 /H 76 /BPC 1 /D[1 0] /F/CCF /DP<> ID &ʰ ~>stream 0 0 0 30 13 105 d1 13 0 0 75 0 30 cm BI /IM true /W 13 /H 75 /BPC 1 /D[1 0] /F/CCF /DP<> ID &w߿y| ,/05( EI endstream endobj 386 0 obj <>stream 0 0 0 7 54 84 d1 54 0 0 77 0 7 cm BI /IM true /W 54 /H 77 /BPC 1 /D[1 0] /F/CCF /DP<> ID & 9? x@ ONĜ@?O^&aixXsO&o}c +w߇aS߅ ۯ׊  EI endstream endobj 387 0 obj <>stream 0 0 0 65 19 83 d1 19 0 0 18 0 65 cm BI /IM true /W 19 /H 18 /BPC 1 /D[1 0] /F/CCF /DP<> ID &|ɮkaa EI endstream endobj 388 0 obj <> stream 134 0 0 0 0 0 d1 endstream endobj 389 0 obj <>stream 0 0 0 7 34 44 d1 34 0 0 37 0 7 cm BI /IM true /W 34 /H 37 /BPC 1 /D[1 0] /F/CCF /DP<> ID &\60@[jX0  EI endstream endobj 390 0 obj <> stream 136 0 0 0 0 0 d1 endstream endobj 391 0 obj <>stream 0 0 0 31 56 83 d1 56 0 0 52 0 31 cm BI /IM true /W 56 /H 52 /BPC 1 /D[1 0] /F/CCF /DP<> ID &O}{_Z_/}4O "  5I EI endstream endobj 392 0 obj <>stream 0 0 0 29 63 84 d1 63 0 0 55 0 29 cm BI /IM true /W 63 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &`Mm߿ ?&Ϧv I\qaa ( EI endstream endobj 393 0 obj <>stream 0 0 0 77 3 78 d1 3 0 0 1 0 77 cm BI /IM true /W 3 /H 1 /BPC 1 /D[1 0] /F/CCF /DP<> ID @ EI endstream endobj 394 0 obj <>stream 0 0 0 77 4 82 d1 4 0 0 5 0 77 cm BI /IM true /W 4 /H 5 /BPC 1 /D[1 0] /F/CCF /DP<> ID Z EI endstream endobj 395 0 obj <>stream 0 0 0 78 3 82 d1 3 0 0 4 0 78 cm BI /IM true /W 3 /H 4 /BPC 1 /D[1 0] /F/CCF /DP<> ID T EI endstream endobj 396 0 obj <> endobj 400 0 obj <>stream 0 0 0 29 48 84 d1 48 0 0 55 0 29 cm BI /IM true /W 48 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &7GP"̞a}>M~~|aþz[ۭ\0^>Xa@ EI endstream endobj 401 0 obj <>stream 0 0 0 29 58 109 d1 58 0 0 80 0 29 cm BI /IM true /W 58 /H 80 /BPC 1 /D[1 0] /F/CCF /DP<> ID &ᅐקC9?OЇ@_IO}u/ wkךav_kh;P EI endstream endobj 402 0 obj <>stream 0 0 0 30 56 82 d1 56 0 0 52 0 30 cm BI /IM true /W 56 /H 52 /BPC 1 /D[1 0] /F/CCF /DP<> ID &\ O[?&oo[[0N,'5H5M@@ EI endstream endobj 403 0 obj <> stream 115 0 0 0 0 0 d1 endstream endobj 404 0 obj <>stream 0 0 0 30 18 99 d1 18 0 0 69 0 30 cm BI /IM true /W 18 /H 69 /BPC 1 /D[1 0] /F/CCF /DP<> ID &&7a߿"_ kkP EI endstream endobj 405 0 obj <>stream 0 0 0 9 58 82 d1 58 0 0 73 0 9 cm BI /IM true /W 58 /H 73 /BPC 1 /D[1 0] /F/CCF /DP<> ID &P(Za8&5JO kh axXMWa@@ EI endstream endobj 406 0 obj <>stream 0 0 0 41 49 50 d1 49 0 0 9 0 41 cm BI /IM true /W 49 /H 9 /BPC 1 /D[1 0] /F/CCF /DP<> ID &? EI endstream endobj 407 0 obj <>stream 0 0 0 0 59 85 d1 59 0 0 85 0 0 cm BI /IM true /W 59 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID 6W v\Appz.דPTZ4d3@Ŀ![p..,",26+@i0pl}t/5_ׇ] ^vu EO . g@π EI endstream endobj 408 0 obj <>stream 0 0 0 29 66 106 d1 66 0 0 77 0 29 cm BI /IM true /W 66 /H 77 /BPC 1 /D[1 0] /F/CCF /DP<> ID & Cb? A ~Pw}_O_߿xkm' x` ܇ EI endstream endobj 409 0 obj <>stream 0 0 0 53 30 60 d1 30 0 0 7 0 53 cm BI /IM true /W 30 /H 7 /BPC 1 /D[1 0] /F/CCF /DP<> ID _y5 EI endstream endobj 410 0 obj <>stream 0 0 0 -2 56 106 d1 56 0 0 108 0 -2 cm BI /IM true /W 56 /H 108 /BPC 1 /D[1 0] /F/CCF /DP<> ID &|6q<~|P=?͟#A|;{\1Xaa EI endstream endobj 411 0 obj <> endobj 415 0 obj <>stream 0 0 0 70 12 82 d1 12 0 0 12 0 70 cm BI /IM true /W 12 /H 12 /BPC 1 /D[1 0] /F/CCF /DP<> ID &ۂ5K` EI endstream endobj 416 0 obj <>stream 0 0 0 19 44 72 d1 44 0 0 53 0 19 cm BI /IM true /W 44 /H 53 /BPC 1 /D[1 0] /F/CCF /DP<> ID &gYK z[maCqa`p&aq EI endstream endobj 417 0 obj <> stream 147 0 0 0 0 0 d1 endstream endobj 418 0 obj <>stream 0 0 0 29 56 111 d1 56 0 0 82 0 29 cm BI /IM true /W 56 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &$0?kt & |. o\{_pguG`}A}o_"Gj|0N `P EI endstream endobj 419 0 obj <>stream 0 0 0 -8 44 112 d1 44 0 0 120 0 -8 cm BI /IM true /W 44 /H 120 /BPC 1 /D[1 0] /F/CCF /DP<> ID &LEu^K ֿ _{o{oo{{w EI endstream endobj 420 0 obj <>stream 0 0 0 -8 43 112 d1 43 0 0 120 0 -8 cm BI /IM true /W 43 /H 120 /BPC 1 /D[1 0] /F/CCF /DP<> ID 0 MS}߼7|=o_ EI endstream endobj 421 0 obj <>stream 0 0 0 -1 41 84 d1 41 0 0 85 0 -1 cm BI /IM true /W 41 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID & xI&oP{??v]Ǹax0^=  EI endstream endobj 422 0 obj <> endobj 426 0 obj <>stream 0 0 0 29 55 84 d1 55 0 0 55 0 29 cm BI /IM true /W 55 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &>3?= >stream 0 0 0 0 92 85 d1 92 0 0 85 0 0 cm BI /IM true /W 92 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &S5"2pA5X  AK^ X xS_& k\6]5 / !||'Q7kj EI endstream endobj 428 0 obj <>stream 0 0 0 30 50 83 d1 50 0 0 53 0 30 cm BI /IM true /W 50 /H 53 /BPC 1 /D[1 0] /F/CCF /DP<> ID MsPc ?~7~}}ko{x}~߷ow~t~_ EI endstream endobj 429 0 obj <> stream 140 0 0 0 0 0 d1 endstream endobj 430 0 obj <>stream 0 0 0 16 49 77 d1 49 0 0 61 0 16 cm BI /IM true /W 49 /H 61 /BPC 1 /D[1 0] /F/CCF /DP<> ID &|<0`oo|0xoۃްZX^ h.ZX.a. h ah/p( EI endstream endobj 431 0 obj <> endobj 435 0 obj <> endobj 439 0 obj <>stream 0 0 0 -2 58 82 d1 58 0 0 84 0 -2 cm BI /IM true /W 58 /H 84 /BPC 1 /D[1 0] /F/CCF /DP<> ID &/4#iP~~C KC3A EI endstream endobj 440 0 obj <>stream 0 0 0 -1 37 34 d1 37 0 0 35 0 -1 cm BI /IM true /W 37 /H 35 /BPC 1 /D[1 0] /F/CCF /DP<> ID &p wU˜Ax{l?{m{ EI endstream endobj 441 0 obj <>stream 0 0 0 -1 37 34 d1 37 0 0 35 0 -1 cm BI /IM true /W 37 /H 35 /BPC 1 /D[1 0] /F/CCF /DP<> ID &`&{a}߇w/2  kU_& EI endstream endobj 442 0 obj <>stream 0 0 0 9 19 45 d1 19 0 0 36 0 9 cm BI /IM true /W 19 /H 36 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A& w䃭~ EI endstream endobj 443 0 obj <>stream 0 0 0 31 52 60 d1 52 0 0 29 0 31 cm BI /IM true /W 52 /H 29 /BPC 1 /D[1 0] /F/CCF /DP<> ID &_amct EI endstream endobj 444 0 obj <>stream 0 0 0 1 97 85 d1 97 0 0 84 0 1 cm BI /IM true /W 97 /H 84 /BPC 1 /D[1 0] /F/CCF /DP<> ID &|Wo׭ (~_'׭X_ o()0 EI endstream endobj 445 0 obj <>stream 0 0 0 -1 48 83 d1 48 0 0 84 0 -1 cm BI /IM true /W 48 /H 84 /BPC 1 /D[1 0] /F/CCF /DP<> ID & Ij Gߺ߇[k!D@ EI endstream endobj 446 0 obj <> endobj 450 0 obj <> stream 144 0 0 0 0 0 d1 endstream endobj 451 0 obj <> endobj 455 0 obj <> stream 24 0 0 0 0 0 d1 endstream endobj 456 0 obj <>stream 0 0 0 -1 55 84 d1 55 0 0 85 0 -1 cm BI /IM true /W 55 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &>aazO&~û u]u܉O? EI endstream endobj 457 0 obj <>stream 0 0 0 30 28 105 d1 28 0 0 75 0 30 cm BI /IM true /W 28 /H 75 /BPC 1 /D[1 0] /F/CCF /DP<> ID 0ɪ|7}]?kAxOo  EI endstream endobj 458 0 obj <> stream 132 0 0 0 0 0 d1 endstream endobj 459 0 obj <>stream 0 0 0 -2 73 106 d1 73 0 0 108 0 -2 cm BI /IM true /W 73 /H 108 /BPC 1 /D[1 0] /F/CCF /DP<> ID &| !&0߿ џ #}x|7_{q~!/m72 /} 0v!`2 EI endstream endobj 460 0 obj <>stream 0 0 0 19 52 72 d1 52 0 0 53 0 19 cm BI /IM true /W 52 /H 53 /BPC 1 /D[1 0] /F/CCF /DP<> ID &7/_oO EI endstream endobj 461 0 obj <>stream 0 0 0 0 5 6 d1 5 0 0 6 0 0 cm BI /IM true /W 5 /H 6 /BPC 1 /D[1 0] /F/CCF /DP<> ID & /p EI endstream endobj 462 0 obj <>stream 0 0 0 2 4 6 d1 4 0 0 4 0 2 cm BI /IM true /W 4 /H 4 /BPC 1 /D[1 0] /F/CCF /DP<> ID Z EI endstream endobj 463 0 obj <>stream 0 0 0 2 6 6 d1 6 0 0 4 0 2 cm BI /IM true /W 6 /H 4 /BPC 1 /D[1 0] /F/CCF /DP<> ID A(@ EI endstream endobj 464 0 obj <>stream 0 0 0 2 4 8 d1 4 0 0 6 0 2 cm BI /IM true /W 4 /H 6 /BPC 1 /D[1 0] /F/CCF /DP<> ID  EI endstream endobj 465 0 obj <>stream 0 0 0 2 4 6 d1 4 0 0 4 0 2 cm BI /IM true /W 4 /H 4 /BPC 1 /D[1 0] /F/CCF /DP<> ID W  EI endstream endobj 466 0 obj <>stream 0 0 0 1 3 6 d1 3 0 0 5 0 1 cm BI /IM true /W 3 /H 5 /BPC 1 /D[1 0] /F/CCF /DP<> ID ,@ EI endstream endobj 468 0 obj <>stream 0 0 0 1 2 6 d1 2 0 0 5 0 1 cm BI /IM true /W 2 /H 5 /BPC 1 /D[1 0] /F/CCF /DP<> ID  EI endstream endobj 469 0 obj <>stream 0 0 0 1 4 6 d1 4 0 0 5 0 1 cm BI /IM true /W 4 /H 5 /BPC 1 /D[1 0] /F/CCF /DP<> ID @ EI endstream endobj 470 0 obj <>stream 0 0 0 1 2 6 d1 2 0 0 5 0 1 cm BI /IM true /W 2 /H 5 /BPC 1 /D[1 0] /F/CCF /DP<> ID  EI endstream endobj 471 0 obj <>stream 0 0 0 3 3 8 d1 3 0 0 5 0 3 cm BI /IM true /W 3 /H 5 /BPC 1 /D[1 0] /F/CCF /DP<> ID \  EI endstream endobj 472 0 obj <>stream 0 0 0 2 4 6 d1 4 0 0 4 0 2 cm BI /IM true /W 4 /H 4 /BPC 1 /D[1 0] /F/CCF /DP<> ID P EI endstream endobj 473 0 obj <>stream 0 0 0 2 3 6 d1 3 0 0 4 0 2 cm BI /IM true /W 3 /H 4 /BPC 1 /D[1 0] /F/CCF /DP<> ID T EI endstream endobj 474 0 obj <>stream 0 0 0 3 2 6 d1 2 0 0 3 0 3 cm BI /IM true /W 2 /H 3 /BPC 1 /D[1 0] /F/CCF /DP<> ID @ EI endstream endobj 475 0 obj <>stream 0 0 0 0 46 67 d1 46 0 0 67 0 0 cm BI /IM true /W 46 /H 67 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Q\/guqɮ EI endstream endobj 476 0 obj <>stream 0 0 0 20 47 67 d1 47 0 0 47 0 20 cm BI /IM true /W 47 /H 47 /BPC 1 /D[1 0] /F/CCF /DP<> ID & z|'oH0o?ɪh/p_ %Apapml,_@ EI endstream endobj 477 0 obj <>stream 0 0 0 20 52 91 d1 52 0 0 71 0 20 cm BI /IM true /W 52 /H 71 /BPC 1 /D[1 0] /F/CCF /DP<> ID &PBYI| ?%r,*S )5""  EI endstream endobj 478 0 obj <>stream 0 0 0 -9 14 24 d1 14 0 0 33 0 -9 cm BI /IM true /W 14 /H 33 /BPC 1 /D[1 0] /F/CCF /DP<> ID &؛7.!MR EI endstream endobj 479 0 obj <>stream 0 0 0 17 35 69 d1 35 0 0 52 0 17 cm BI /IM true /W 35 /H 52 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Bp~8 |p@~}׬A/VB K h΁ k0a@ EI endstream endobj 480 0 obj <>stream 0 0 0 0 45 67 d1 45 0 0 67 0 0 cm BI /IM true /W 45 /H 67 /BPC 1 /D[1 0] /F/CCF /DP<> ID &?Sb$h;~;_` EI endstream endobj 481 0 obj <>stream 0 0 0 20 51 67 d1 51 0 0 47 0 20 cm BI /IM true /W 51 /H 47 /BPC 1 /D[1 0] /F/CCF /DP<> ID & P }!(zamt@@ EI endstream endobj 482 0 obj <>stream 0 0 0 36 50 63 d1 50 0 0 27 0 36 cm BI /IM true /W 50 /H 27 /BPC 1 /D[1 0] /F/CCF /DP<> ID &?0.j  EI endstream endobj 483 0 obj <>stream 0 0 0 35 73 84 d1 73 0 0 49 0 35 cm BI /IM true /W 73 /H 49 /BPC 1 /D[1 0] /F/CCF /DP<> ID &70  kk5´P'a{ TAi\ EI endstream endobj 484 0 obj <>stream 0 0 0 32 50 84 d1 50 0 0 52 0 32 cm BI /IM true /W 50 /H 52 /BPC 1 /D[1 0] /F/CCF /DP<> ID &C0F |`o[|,=oa/] .z B( EI endstream endobj 485 0 obj <>stream 0 0 0 33 38 82 d1 38 0 0 49 0 33 cm BI /IM true /W 38 /H 49 /BPC 1 /D[1 0] /F/CCF /DP<> ID & 4mGPA4Vb9 EI endstream endobj 486 0 obj <>stream 0 0 0 6 54 82 d1 54 0 0 76 0 6 cm BI /IM true /W 54 /H 76 /BPC 1 /D[1 0] /F/CCF /DP<> ID &ei/_^밗k؅?7?D_U_i EI endstream endobj 487 0 obj <>stream 0 0 0 -9 25 67 d1 25 0 0 76 0 -9 cm BI /IM true /W 25 /H 76 /BPC 1 /D[1 0] /F/CCF /DP<> ID &kWZ@@ EI endstream endobj 488 0 obj <>stream 0 0 0 -7 25 67 d1 25 0 0 74 0 -7 cm BI /IM true /W 25 /H 74 /BPC 1 /D[1 0] /F/CCF /DP<> ID &k\""Xa|@ EI endstream endobj 489 0 obj <>stream 0 0 0 32 43 84 d1 43 0 0 52 0 32 cm BI /IM true /W 43 /H 52 /BPC 1 /D[1 0] /F/CCF /DP<> ID &03h(zc4x }>ﮠ_J@1aۅku\<,6_( EI endstream endobj 490 0 obj <>stream 0 0 0 14 41 82 d1 41 0 0 68 0 14 cm BI /IM true /W 41 /H 68 /BPC 1 /D[1 0] /F/CCF /DP<> ID &EjR5^?3? 0 EI endstream endobj 491 0 obj <>stream 0 0 0 21 47 82 d1 47 0 0 61 0 21 cm BI /IM true /W 47 /H 61 /BPC 1 /D[1 0] /F/CCF /DP<> ID &\C@A }[_*?>stream 0 0 0 35 47 82 d1 47 0 0 47 0 35 cm BI /IM true /W 47 /H 47 /BPC 1 /D[1 0] /F/CCF /DP<> ID & |?:_0O0_R @͓T,?[[X0C9 EI endstream endobj 493 0 obj <>stream 0 0 0 20 52 67 d1 52 0 0 47 0 20 cm BI /IM true /W 52 /H 47 /BPC 1 /D[1 0] /F/CCF /DP<> ID &@" /" <}=&1ǾCd.?A/S EI endstream endobj 494 0 obj <>stream 0 0 0 55 14 88 d1 14 0 0 33 0 55 cm BI /IM true /W 14 /H 33 /BPC 1 /D[1 0] /F/CCF /DP<> ID &؛ .!/ EI endstream endobj 495 0 obj <>stream 0 0 0 -9 54 69 d1 54 0 0 78 0 -9 cm BI /IM true /W 54 /H 78 /BPC 1 /D[1 0] /F/CCF /DP<> ID &`3`ax` >†~/kA}sD^ ^/ UE@ EI endstream endobj 496 0 obj <>stream 0 0 0 18 55 69 d1 55 0 0 51 0 18 cm BI /IM true /W 55 /H 51 /BPC 1 /D[1 0] /F/CCF /DP<> ID &C1ɨ71 ~Pu AAr  EI endstream endobj 497 0 obj <>stream 0 0 0 0 35 69 d1 35 0 0 69 0 0 cm BI /IM true /W 35 /H 69 /BPC 1 /D[1 0] /F/CCF /DP<> ID & #Bz'H?HKɫ?@ EI endstream endobj 498 0 obj <>stream 0 0 0 6 54 84 d1 54 0 0 78 0 6 cm BI /IM true /W 54 /H 78 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A@bj > ~?I(8H1}' _k </y  CZp EI endstream endobj 499 0 obj <>stream 0 0 0 -9 55 67 d1 55 0 0 76 0 -9 cm BI /IM true /W 55 /H 76 /BPC 1 /D[1 0] /F/CCF /DP<> ID &/gFk4_^a_ʫ-  EI endstream endobj 500 0 obj <>stream 0 0 0 20 52 90 d1 52 0 0 70 0 20 cm BI /IM true /W 52 /H 70 /BPC 1 /D[1 0] /F/CCF /DP<> ID &fOl>=?? Fmaoa}$a #Xo@ EI endstream endobj 501 0 obj <>stream 0 0 0 18 55 67 d1 55 0 0 49 0 18 cm BI /IM true /W 55 /H 49 /BPC 1 /D[1 0] /F/CCF /DP<> ID &/gFkVh/1h / EI endstream endobj 502 0 obj <>stream 0 0 0 17 51 69 d1 51 0 0 52 0 17 cm BI /IM true /W 51 /H 52 /BPC 1 /D[1 0] /F/CCF /DP<> ID &1<8AiϤ ~AB|U?>/~^Kj A~C EI endstream endobj 503 0 obj <>stream 0 0 0 20 55 67 d1 55 0 0 47 0 20 cm BI /IM true /W 55 /H 47 /BPC 1 /D[1 0] /F/CCF /DP<> ID " 9 *a-׿޶\5KV/ ^}W#"? EI endstream endobj 504 0 obj <>stream 0 0 0 15 55 82 d1 55 0 0 67 0 15 cm BI /IM true /W 55 /H 67 /BPC 1 /D[1 0] /F/CCF /DP<> ID &PAE0Ȕ! 4_a׆P?5€ EI endstream endobj 505 0 obj <>stream 0 0 0 35 55 82 d1 55 0 0 47 0 35 cm BI /IM true /W 55 /H 47 /BPC 1 /D[1 0] /F/CCF /DP<> ID &PAE0Ȕ! a~ Ie@ EI endstream endobj 506 0 obj <>stream 0 0 0 33 85 82 d1 85 0 0 49 0 33 cm BI /IM true /W 85 /H 49 /BPC 1 /D[1 0] /F/CCF /DP<> ID &"tЍ k4Y?* X5 - @ EI endstream endobj 507 0 obj <>stream 0 0 0 20 52 91 d1 52 0 0 71 0 20 cm BI /IM true /W 52 /H 71 /BPC 1 /D[1 0] /F/CCF /DP<> ID &3 Z!_OOxG/o_ >stream 0 0 0 7 35 82 d1 35 0 0 75 0 7 cm BI /IM true /W 35 /H 75 /BPC 1 /D[1 0] /F/CCF /DP<> ID &l/' EI endstream endobj 509 0 obj <>stream 0 0 0 -11 37 67 d1 37 0 0 78 0 -11 cm BI /IM true /W 37 /H 78 /BPC 1 /D[1 0] /F/CCF /DP<> ID &&'Ȩh ݂l5߸|Q? EI endstream endobj 510 0 obj <>stream 0 0 0 33 54 103 d1 54 0 0 70 0 33 cm BI /IM true /W 54 /H 70 /BPC 1 /D[1 0] /F/CCF /DP<> ID & k1<0~?  kA}a&ʩb "0_@ EI endstream endobj 511 0 obj <>stream 0 0 0 -11 86 67 d1 86 0 0 78 0 -11 cm BI /IM true /W 86 /H 78 /BPC 1 /D[1 0] /F/CCF /DP<> ID &PEA"tЍ XQ 7?B?w6C:x4dI Ae EI endstream endobj 512 0 obj <>stream 0 0 0 17 42 69 d1 42 0 0 52 0 17 cm BI /IM true /W 42 /H 52 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A@'B>(x,> oX|'?W P~~2'/gD@ EI endstream endobj 513 0 obj <>stream 0 0 0 -11 68 67 d1 68 0 0 78 0 -11 cm BI /IM true /W 68 /H 78 /BPC 1 /D[1 0] /F/CCF /DP<> ID &PE Ѵ"D 5H^@6 6!d0p_@ EI endstream endobj 514 0 obj <> endobj 518 0 obj <>stream 0 0 0 0 74 79 d1 74 0 0 79 0 0 cm BI /IM true /W 74 /H 79 /BPC 1 /D[1 0] /F/CCF /DP<> ID & Zͯ_Vl 0Qۅx_=_ ޿k/ EI endstream endobj 519 0 obj <>stream 0 0 0 35 52 84 d1 52 0 0 49 0 35 cm BI /IM true /W 52 /H 49 /BPC 1 /D[1 0] /F/CCF /DP<> ID &\(A7o ~ o$o I?y@5@ EI endstream endobj 520 0 obj <>stream 0 0 0 17 51 91 d1 51 0 0 74 0 17 cm BI /IM true /W 51 /H 74 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A8x#0[ [a ׆ h Wᅄ&z3 \/{' o[?l%W@ᆟbpx` € EI endstream endobj 521 0 obj <>stream 0 0 0 0 26 109 d1 26 0 0 109 0 0 cm BI /IM true /W 26 /H 109 /BPC 1 /D[1 0] /F/CCF /DP<> ID &ikZZ_Z ~ּ//_p?~o ?o @ EI endstream endobj 522 0 obj <>stream 0 0 0 18 54 92 d1 54 0 0 74 0 18 cm BI /IM true /W 54 /H 74 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A3:' ?Dn o_׆ ]bZ#@aKhA(z7OmK?I>T?L,AA EI endstream endobj 523 0 obj <>stream 0 0 0 0 26 109 d1 26 0 0 109 0 0 cm BI /IM true /W 26 /H 109 /BPC 1 /D[1 0] /F/CCF /DP<> ID 0 0>o{ __/Z_ _֖T.  EI endstream endobj 524 0 obj <>stream 0 0 0 35 43 82 d1 43 0 0 47 0 35 cm BI /IM true /W 43 /H 47 /BPC 1 /D[1 0] /F/CCF /DP<> ID &N?"xOixXѧY O"@ 0"MHh >my Ǿ Q; EI endstream endobj 525 0 obj <>stream 0 0 0 0 76 85 d1 76 0 0 85 0 0 cm BI /IM true /W 76 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &h$#@ч& ok| ?-/~P )? ?o{wݿ?K]_Op )@ EI endstream endobj 526 0 obj <>stream 0 0 0 9 54 82 d1 54 0 0 73 0 9 cm BI /IM true /W 54 /H 73 /BPC 1 /D[1 0] /F/CCF /DP<> ID &?uO_)w`| O EI endstream endobj 527 0 obj <> endobj 531 0 obj <>stream 0 0 0 30 51 82 d1 51 0 0 52 0 30 cm BI /IM true /W 51 /H 52 /BPC 1 /D[1 0] /F/CCF /DP<> ID &k3{~톶{὾oo/ EI endstream endobj 532 0 obj <> endobj 536 0 obj <>stream 0 0 0 0 91 82 d1 91 0 0 82 0 0 cm BI /IM true /W 91 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID #Ahj0̴w?~wǿ7{ÿƈA EI endstream endobj 537 0 obj <>stream 0 0 0 7 39 110 d1 39 0 0 103 0 7 cm BI /IM true /W 39 /H 103 /BPC 1 /D[1 0] /F/CCF /DP<> ID &C@==(ڿ0O?N 4?@ EI endstream endobj 538 0 obj <> endobj 542 0 obj <>stream 0 0 0 0 49 77 d1 49 0 0 77 0 0 cm BI /IM true /W 49 /H 77 /BPC 1 /D[1 0] /F/CCF /DP<> ID &'@< A? zi}v+  EI endstream endobj 543 0 obj <>stream 0 0 0 9 54 82 d1 54 0 0 73 0 9 cm BI /IM true /W 54 /H 73 /BPC 1 /D[1 0] /F/CCF /DP<> ID &4CAk__/_/qIMt@ EI endstream endobj 544 0 obj <>stream 0 0 0 -8 47 112 d1 47 0 0 120 0 -8 cm BI /IM true /W 47 /H 120 /BPC 1 /D[1 0] /F/CCF /DP<> ID &ڧ?=~ oo??߿@@ EI endstream endobj 545 0 obj <> endobj 549 0 obj <>stream 0 0 0 69 19 99 d1 19 0 0 30 0 69 cm BI /IM true /W 19 /H 30 /BPC 1 /D[1 0] /F/CCF /DP<> ID &8}ɯ}Aֵ_o@ EI endstream endobj 550 0 obj <> endobj 554 0 obj <>stream 0 0 0 3 42 82 d1 42 0 0 79 0 3 cm BI /IM true /W 42 /H 79 /BPC 1 /D[1 0] /F/CCF /DP<> ID &F?{?/N~ؼ}߽@ EI endstream endobj 555 0 obj <> endobj 556 0 obj <>stream 0 0 0 0 53 82 d1 53 0 0 82 0 0 cm BI /IM true /W 53 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &@eHqh <-0A&m65[ AZZZ,r.u oo xA[~\^0X0 EI endstream endobj 560 0 obj <>stream 0 0 0 -3 92 79 d1 92 0 0 82 0 -3 cm BI /IM true /W 92 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &|;ЃVL,;p?wÿ1{;h  EI endstream endobj 561 0 obj <>stream 0 0 0 -3 77 79 d1 77 0 0 82 0 -3 cm BI /IM true /W 77 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &oMv܂/7xZd2@ EI endstream endobj 562 0 obj <>stream 0 0 0 0 65 83 d1 65 0 0 83 0 0 cm BI /IM true /W 65 /H 83 /BPC 1 /D[1 0] /F/CCF /DP<> ID eMD$}~/ //KK]\/?a??aD.  EI endstream endobj 563 0 obj <> endobj 567 0 obj <>stream 0 0 0 29 61 105 d1 61 0 0 76 0 29 cm BI /IM true /W 61 /H 76 /BPC 1 /D[1 0] /F/CCF /DP<> ID *U8*"O#H0~)o 7??p;?߯oxpFh0Ai0iqdž0 EI endstream endobj 568 0 obj <>stream 0 0 0 29 54 84 d1 54 0 0 55 0 29 cm BI /IM true /W 54 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &M? <# o kzA&?߿> \>stream 0 0 0 7 37 84 d1 37 0 0 77 0 7 cm BI /IM true /W 37 /H 77 /BPC 1 /D[1 0] /F/CCF /DP<> ID &<- ߿?m$rj ᯀ EI endstream endobj 570 0 obj <>stream 0 0 0 47 35 100 d1 35 0 0 53 0 47 cm BI /IM true /W 35 /H 53 /BPC 1 /D[1 0] /F/CCF /DP<> ID kٰo߆}{xa{[^I[kmaN  EI endstream endobj 571 0 obj <>stream 0 0 0 70 13 82 d1 13 0 0 12 0 70 cm BI /IM true /W 13 /H 12 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Mu` EI endstream endobj 572 0 obj <> endobj 576 0 obj <>stream 0 0 0 46 22 102 d1 22 0 0 56 0 46 cm BI /IM true /W 22 /H 56 /BPC 1 /D[1 0] /F/CCF /DP<> ID &=75Aoح  ڀ EI endstream endobj 577 0 obj <>stream 0 0 0 0 6 5 d1 6 0 0 5 0 0 cm BI /IM true /W 6 /H 5 /BPC 1 /D[1 0] /F/CCF /DP<> ID TGAq? EI endstream endobj 578 0 obj <>stream 0 0 0 -69 71 6 d1 71 0 0 75 0 -69 cm BI /IM true /W 71 /H 75 /BPC 1 /D[1 0] /F/CCF /DP<> ID &X F v\dG EI endstream endobj 579 0 obj <>stream 0 0 0 54 30 61 d1 30 0 0 7 0 54 cm BI /IM true /W 30 /H 7 /BPC 1 /D[1 0] /F/CCF /DP<> ID  EI endstream endobj 580 0 obj <>stream 0 0 0 20 55 67 d1 55 0 0 47 0 20 cm BI /IM true /W 55 /H 47 /BPC 1 /D[1 0] /F/CCF /DP<> ID &O!4ygXka~?}?B&O EI endstream endobj 581 0 obj <>stream 0 0 0 -8 18 112 d1 18 0 0 120 0 -8 cm BI /IM true /W 18 /H 120 /BPC 1 /D[1 0] /F/CCF /DP<> ID & EI endstream endobj 582 0 obj <>stream 0 0 0 0 109 82 d1 109 0 0 82 0 0 cm BI /IM true /W 109 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID *r7&C aۻh>A}?{o^}{ o<0b!!~@ EI endstream endobj 583 0 obj <>stream 0 0 0 -8 18 112 d1 18 0 0 120 0 -8 cm BI /IM true /W 18 /H 120 /BPC 1 /D[1 0] /F/CCF /DP<> ID 5? EI endstream endobj 584 0 obj <>stream 0 0 0 1 96 83 d1 96 0 0 82 0 1 cm BI /IM true /W 96 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &?_)@ EI endstream endobj 585 0 obj <>stream 0 0 0 0 79 82 d1 79 0 0 82 0 0 cm BI /IM true /W 79 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID "@5H?C=߽|==ÿ{ ?}/`3@ EI endstream endobj 586 0 obj <> endobj 587 0 obj <>stream 0 0 0 0 51 81 d1 51 0 0 81 0 0 cm BI /IM true /W 51 /H 81 /BPC 1 /D[1 0] /F/CCF /DP<> ID &x  7 @ono~~{o} EI endstream endobj 591 0 obj <>stream 0 0 0 -3 85 79 d1 85 0 0 82 0 -3 cm BI /IM true /W 85 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &l?Q~~~z7oz[?ޓ=C}7VAz߷?} o[4u?Ĩ7@ EI endstream endobj 592 0 obj <>stream 0 0 0 -3 78 79 d1 78 0 0 82 0 -3 cm BI /IM true /W 78 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Bi@7` >N C(}{o}x_KL~Ax/( EI endstream endobj 593 0 obj <>stream 0 0 0 -2 43 82 d1 43 0 0 84 0 -2 cm BI /IM true /W 43 /H 84 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A?_ ~xo{xo;f1v - X0d0 EI endstream endobj 594 0 obj <> endobj 598 0 obj <>stream 0 0 0 0 6 6 d1 6 0 0 6 0 0 cm BI /IM true /W 6 /H 6 /BPC 1 /D[1 0] /F/CCF /DP<> ID A/#& @ EI endstream endobj 599 0 obj <> endobj 603 0 obj <> endobj 604 0 obj <>stream 0 0 0 0 52 82 d1 52 0 0 82 0 0 cm BI /IM true /W 52 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &<| 77a~3 &`oB ͠ݚ >stream 0 0 0 -3 79 79 d1 79 0 0 82 0 -3 cm BI /IM true /W 79 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &^VFR>B@{~  ޽~/ vXb ϓ 4op7w/^Z`:*`@ EI endstream endobj 609 0 obj <>stream 0 0 0 -3 109 79 d1 109 0 0 82 0 -3 cm BI /IM true /W 109 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID & 4zYX4~߿FW ?W{w]PW~om[۽߇ ·}xVd@ EI endstream endobj 610 0 obj <>stream 0 0 0 -3 116 82 d1 116 0 0 85 0 -3 cm BI /IM true /W 116 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &6J 4z\/WW?޺[X~~~?>]~oՍAVx@ *! EI endstream endobj 611 0 obj <>stream 0 0 0 -3 83 82 d1 83 0 0 85 0 -3 cm BI /IM true /W 83 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &` O'__o_߯A߿W?Aoo__o@?AA EI endstream endobj 612 0 obj <> endobj 613 0 obj <>stream 0 0 0 0 53 82 d1 53 0 0 82 0 0 cm BI /IM true /W 53 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &p̂5o @A} PoWÏ]u k4  .߽ xr " a`CH EI endstream endobj 617 0 obj <>stream 0 0 0 10 56 83 d1 56 0 0 73 0 10 cm BI /IM true /W 56 /H 73 /BPC 1 /D[1 0] /F/CCF /DP<> ID &&O ᭬zW1z5Xj  EI endstream endobj 618 0 obj <>stream 0 0 0 10 56 83 d1 56 0 0 73 0 10 cm BI /IM true /W 56 /H 73 /BPC 1 /D[1 0] /F/CCF /DP<> ID &cɪȔ!O1Oh ׏AS ɪ EI endstream endobj 619 0 obj <>stream 0 0 0 10 58 85 d1 58 0 0 75 0 10 cm BI /IM true /W 58 /H 75 /BPC 1 /D[1 0] /F/CCF /DP<> ID &f?\ q =>stream 0 0 0 8 54 83 d1 54 0 0 75 0 8 cm BI /IM true /W 54 /H 75 /BPC 1 /D[1 0] /F/CCF /DP<> ID &N  ɮPzp=a4_aA]kb@ EI endstream endobj 621 0 obj <>stream 0 0 0 2 54 75 d1 54 0 0 73 0 2 cm BI /IM true /W 54 /H 73 /BPC 1 /D[1 0] /F/CCF /DP<> ID &. _ɪXk"S>h ߿ K/ (X` EI endstream endobj 622 0 obj <> endobj 623 0 obj <>stream 0 0 0 0 55 84 d1 55 0 0 84 0 0 cm BI /IM true /W 55 /H 84 /BPC 1 /D[1 0] /F/CCF /DP<> ID & A{xoۃ 5ovo EI endstream endobj 627 0 obj <>stream 0 0 0 -5 81 82 d1 81 0 0 87 0 -5 cm BI /IM true /W 81 /H 87 /BPC 1 /D[1 0] /F/CCF /DP<> ID &t y?"@pký!a?aO__CHK?Fwo{a~ v6kx0aOg^A2oaky 0 EI endstream endobj 628 0 obj <>stream 0 0 0 0 19 37 d1 19 0 0 37 0 0 cm BI /IM true /W 19 /H 37 /BPC 1 /D[1 0] /F/CCF /DP<> ID &|?~>&}{p EI endstream endobj 629 0 obj <> endobj 633 0 obj <>stream 0 0 0 10 58 83 d1 58 0 0 73 0 10 cm BI /IM true /W 58 /H 73 /BPC 1 /D[1 0] /F/CCF /DP<> ID & Ӌ MR l&Sf_?_OO?:yO T[M@@ EI endstream endobj 634 0 obj <>stream 0 0 0 10 60 85 d1 60 0 0 75 0 10 cm BI /IM true /W 60 /H 75 /BPC 1 /D[1 0] /F/CCF /DP<> ID &` | x xOC'@M>aOrq ?ɪ  EI endstream endobj 635 0 obj <>stream 0 0 0 10 56 83 d1 56 0 0 73 0 10 cm BI /IM true /W 56 /H 73 /BPC 1 /D[1 0] /F/CCF /DP<> ID &A. S ~z_ޯzޗL=o|_ӓT EI endstream endobj 636 0 obj <> stream 138 0 0 0 0 0 d1 endstream endobj 637 0 obj <>stream 0 0 0 0 82 82 d1 82 0 0 82 0 0 cm BI /IM true /W 82 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID $+&20YaamWu o[ipa޻Ki}oᆂ/l% ~]봷=_O^X}z?}7I}?P=8x@? "M EI endstream endobj 638 0 obj <>stream 0 0 0 18 72 86 d1 72 0 0 68 0 18 cm BI /IM true /W 72 /H 68 /BPC 1 /D[1 0] /F/CCF /DP<> ID &?5 xxahu0`aa?X\, , A` XApX .\A@x@\ ,, \(ɮ@ EI endstream endobj 639 0 obj <>stream 0 0 0 10 54 83 d1 54 0 0 73 0 10 cm BI /IM true /W 54 /H 73 /BPC 1 /D[1 0] /F/CCF /DP<> ID &ɮD wC3?̩Qڀ EI endstream endobj 640 0 obj <>stream 0 0 0 9 54 82 d1 54 0 0 73 0 9 cm BI /IM true /W 54 /H 73 /BPC 1 /D[1 0] /F/CCF /DP<> ID & ;&GB߃~~_ /_ b%*T( EI endstream endobj 641 0 obj <>stream 0 0 0 7 53 84 d1 53 0 0 77 0 7 cm BI /IM true /W 53 /H 77 /BPC 1 /D[1 0] /F/CCF /DP<> ID &#Q(&~'~$OCA}Bo}7a / v?kd EI endstream endobj 642 0 obj <>stream 0 0 0 10 54 83 d1 54 0 0 73 0 10 cm BI /IM true /W 54 /H 73 /BPC 1 /D[1 0] /F/CCF /DP<> ID &Nӯ&k"Іvׯn:o[[_m~u ~|ȃ4  EI endstream endobj 643 0 obj <>stream 0 0 0 10 51 83 d1 51 0 0 73 0 10 cm BI /IM true /W 51 /H 73 /BPC 1 /D[1 0] /F/CCF /DP<> ID &ZG}>?}7|?{ ~/} EI endstream endobj 644 0 obj <> endobj 648 0 obj <>stream 0 0 0 1 134 85 d1 134 0 0 84 0 1 cm BI /IM true /W 134 /H 84 /BPC 1 /D[1 0] /F/CCF /DP<> ID &pg4AAauS.mo<'}~>i յO >O o? [Hr`7@ EI endstream endobj 649 0 obj <>stream 0 0 0 9 58 84 d1 58 0 0 75 0 9 cm BI /IM true /W 58 /H 75 /BPC 1 /D[1 0] /F/CCF /DP<> ID &sO[ᮏ,a/}{~0^}o?:pz 8 j  EI endstream endobj 650 0 obj <>stream 0 0 0 9 56 82 d1 56 0 0 73 0 9 cm BI /IM true /W 56 /H 73 /BPC 1 /D[1 0] /F/CCF /DP<> ID &MPMdt ^ 9xTP EI endstream endobj 651 0 obj <>stream 0 0 0 9 56 84 d1 56 0 0 75 0 9 cm BI /IM true /W 56 /H 75 /BPC 1 /D[1 0] /F/CCF /DP<> ID &\ =?Ooa o [Aqi5I EI endstream endobj 652 0 obj <>stream 0 0 0 8 52 85 d1 52 0 0 77 0 8 cm BI /IM true /W 52 /H 77 /BPC 1 /D[1 0] /F/CCF /DP<> ID & x xAao[ AC]]pak[ao0d0O  EI endstream endobj 653 0 obj <> endobj 657 0 obj <> endobj 661 0 obj <>stream 0 0 0 0 77 85 d1 77 0 0 85 0 0 cm BI /IM true /W 77 /H 85 /BPC 1 /D[1 0] /F/CCF /DP<> ID &(? ? aooooz A EI endstream endobj 662 0 obj <>stream 0 0 0 29 49 84 d1 49 0 0 55 0 29 cm BI /IM true /W 49 /H 55 /BPC 1 /D[1 0] /F/CCF /DP<> ID &g< {{h?3  >>oooaxoo}a{y oC#> ! &w @ EI endstream endobj 663 0 obj <> endobj 664 0 obj <>stream 0 0 0 0 53 82 d1 53 0 0 82 0 0 cm BI /IM true /W 53 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &@eHq@z" SH>a޷;&߇^4l]] al% .<0XK]F >?MO}~뿰mwKXk ,A EI endstream endobj 668 0 obj <>stream 0 0 0 50 34 58 d1 34 0 0 8 0 50 cm BI /IM true /W 34 /H 8 /BPC 1 /D[1 0] /F/CCF /DP<> ID &/ EI endstream endobj 669 0 obj <>stream 0 0 0 -3 91 79 d1 91 0 0 82 0 -3 cm BI /IM true /W 91 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID ) *]ۭzAwu .] ߱_~-[~[7}?ޓ(o C}?ޕ N_`hH EI endstream endobj 670 0 obj <>stream 0 0 0 -11 38 109 d1 38 0 0 120 0 -11 cm BI /IM true /W 38 /H 120 /BPC 1 /D[1 0] /F/CCF /DP<> ID &]p׭/_Mo ߽??}o~o@ EI endstream endobj 671 0 obj <>stream 0 0 0 -11 38 109 d1 38 0 0 120 0 -11 cm BI /IM true /W 38 /H 120 /BPC 1 /D[1 0] /F/CCF /DP<> ID 0nMS?}~o?߿KZ^KiZX].P EI endstream endobj 672 0 obj <>stream 0 0 0 8 52 85 d1 52 0 0 77 0 8 cm BI /IM true /W 52 /H 77 /BPC 1 /D[1 0] /F/CCF /DP<> ID &P0Ou!A0 :^'>OM>- ,?Oa][{ >k k v[gR[,5 d2 EI endstream endobj 673 0 obj <>stream 0 0 0 0 87 106 d1 87 0 0 106 0 0 cm BI /IM true /W 87 /H 106 /BPC 1 /D[1 0] /F/CCF /DP<> ID &~hx@O^x_?!U?C4O0,? tAD,<#^[t A7p ի0Wо>XU \=v]Ap Apap a`,0!c!T@ EI endstream endobj 674 0 obj <>stream 0 0 0 1 70 83 d1 70 0 0 82 0 1 cm BI /IM true /W 70 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID &w Q ?AQg@ EI endstream endobj 675 0 obj <>stream 0 0 0 -1 46 92 d1 46 0 0 93 0 -1 cm BI /IM true /W 46 /H 93 /BPC 1 /D[1 0] /F/CCF /DP<> ID &kxax߿~oa߿~a~k EI endstream endobj 676 0 obj <>stream 0 0 0 8 49 85 d1 49 0 0 77 0 8 cm BI /IM true /W 49 /H 77 /BPC 1 /D[1 0] /F/CCF /DP<> ID &CcA>k ??]z,X̃ptK-@E8uZ\.Ԇg}5w"ɏO!_@ EI endstream endobj 677 0 obj <> endobj 678 0 obj <>stream 0 0 0 0 54 82 d1 54 0 0 82 0 0 cm BI /IM true /W 54 /H 82 /BPC 1 /D[1 0] /F/CCF /DP<> ID & Hg<#Asg 5_x{C:<~6A~VQ Ǩ\?p u[u׃[ ,i EI endstream endobj 682 0 obj <> endobj 686 0 obj <> endobj 467 0 obj <>/FontBBox[0 -70 134 144]/FontMatrix[1 0 0 1 0 0]/FirstChar 0/LastChar 222/Widths[ 0 42 0 31 60 0 30 0 39 0 124 0 0 49 0 0 57 58 0 53 0 66 0 24 0 97 0 54 0 0 111 0 76 0 55 0 44 0 0 0 0 0 50 0 61 0 0 0 81 0 0 59 104 56 112 62 0 0 43 0 0 0 0 0 0 0 95 91 101 29 65 0 0 82 0 84 83 0 64 48 75 0 0 92 0 79 45 0 69 105 0 52 86 32 0 71 0 34 93 63 0 0 94 0 100 78 90 40 0 0 123 0 0 0 98 126 0 0 51 0 0 77 0 0 0 0 127 0 119 0 113 0 67 0 0 0 74 0 0 0 46 0 47 38 87 41 0 0 0 0 0 107 0 28 36 0 0 85 0 0 0 0 0 0 80 0 115 120 0 0 103 0 0 0 0 0 0 0 134 0 143 136 142 145 0 0 0 138 0 0 88 0 0 0 0 0 144 141 140 137 135 139 0 0 0 0 0 0 0 0 0 0 0 131 0 128 0 0 0 0 0 0 68] >> endobj 279 0 obj <>/FontBBox[0 -78 117 128]/FontMatrix[1 0 0 1 0 0]/FirstChar 0/LastChar 255/Widths[ 0 0 0 139 0 69 0 95 0 56 0 70 0 0 77 74 54 0 48 0 66 0 75 50 0 42 0 0 45 58 43 0 52 0 30 0 65 0 112 0 32 0 0 60 0 0 44 0 135 128 0 55 0 62 61 0 0 118 0 122 0 0 125 0 123 0 0 0 124 129 0 0 0 0 57 82 0 101 116 0 40 0 100 36 0 0 137 127 0 53 0 68 141 0 63 64 0 0 59 0 0 0 0 0 0 79 0 0 49 0 0 28 39 73 0 38 0 0 47 0 0 51 0 0 0 0 0 29 0 0 0 31 0 46 76 67 27 0 0 0 72 0 80 71 0 86 0 83 0 89 87 0 88 0 84 0 0 0 0 0 0 81 130 0 96 105 0 34 0 0 98 108 0 0 0 106 0 109 134 0 136 0 0 0 0 0 0 94 0 90 0 93 104 92 111 121 115 113 117 0 0 114 0 119 120 0 0 97 0 0 0 0 147 0 85 107 91 0 0 41 0 99 0 102 142 110 0 0 37 131 140 0 78 103 0 0 0 0 143 0 26 0 0 144 24 0 0 132 0 0 0 0 0 0 0 0] >> endobj 9 0 obj <>/FontBBox[0 -70 127 127]/FontMatrix[1 0 0 1 0 0]/FirstChar 0/LastChar 255/Widths[ 0 0 105 0 89 65 63 0 86 0 83 0 88 0 64 0 79 84 87 0 104 0 43 42 85 0 122 0 90 114 80 0 91 74 0 0 0 76 44 82 112 73 72 92 120 0 78 0 94 26 48 28 0 0 52 0 98 99 0 0 55 0 58 0 59 0 106 0 0 45 0 49 0 71 68 0 0 0 0 0 125 0 50 0 69 0 0 126 145 0 75 0 0 0 0 66 0 57 47 0 0 0 0 101 0 0 51 0 54 0 0 0 60 0 34 77 46 100 0 61 0 0 37 0 103 0 0 0 0 0 0 0 0 33 135 117 0 118 0 62 0 0 102 32 53 56 0 0 97 0 0 110 108 131 0 27 35 93 109 107 95 111 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 38 0 0 0 41 0 0 0 0 121 29 0 143 96 0 0 0 0 0 142 70 0 0 0 0 0 0 137 0 0 67 0 113 0 0 127 0 0 0 36 0 0 124 0 119 0 0 0 0 130 150 0 0 0 0 0 0 0 0 0 39 0 0 0 0 0 0 0 0 0 81 116 0 0 0 0 0] >> endobj 8 0 obj <> endobj 2 0 obj <>endobj xref 0 687 0000000000 65535 f 0000101888 00000 n 0000227495 00000 n 0000101564 00000 n 0000101936 00000 n 0000096319 00000 n 0000000015 00000 n 0000001229 00000 n 0000226258 00000 n 0000222316 00000 n 0000102005 00000 n 0000102315 00000 n 0000102581 00000 n 0000102646 00000 n 0000102952 00000 n 0000103016 00000 n 0000103080 00000 n 0000103144 00000 n 0000103433 00000 n 0000103497 00000 n 0000103742 00000 n 0000103806 00000 n 0000104072 00000 n 0000104136 00000 n 0000104398 00000 n 0000104462 00000 n 0000104699 00000 n 0000104763 00000 n 0000104827 00000 n 0000104891 00000 n 0000105104 00000 n 0000105169 00000 n 0000105454 00000 n 0000105518 00000 n 0000105582 00000 n 0000105646 00000 n 0000105943 00000 n 0000106008 00000 n 0000106251 00000 n 0000106315 00000 n 0000106380 00000 n 0000106444 00000 n 0000106676 00000 n 0000106740 00000 n 0000106804 00000 n 0000107107 00000 n 0000107369 00000 n 0000107653 00000 n 0000107717 00000 n 0000107781 00000 n 0000107845 00000 n 0000107910 00000 n 0000107974 00000 n 0000108038 00000 n 0000108102 00000 n 0000108167 00000 n 0000108444 00000 n 0000108508 00000 n 0000108688 00000 n 0000108752 00000 n 0000108816 00000 n 0000108880 00000 n 0000108944 00000 n 0000109185 00000 n 0000109446 00000 n 0000109510 00000 n 0000109755 00000 n 0000109819 00000 n 0000109883 00000 n 0000110101 00000 n 0000110362 00000 n 0000110426 00000 n 0000110708 00000 n 0000110772 00000 n 0000111055 00000 n 0000111119 00000 n 0000111385 00000 n 0000111450 00000 n 0000111668 00000 n 0000111912 00000 n 0000111976 00000 n 0000112221 00000 n 0000112285 00000 n 0000112482 00000 n 0000112546 00000 n 0000112610 00000 n 0000112871 00000 n 0000113147 00000 n 0000113430 00000 n 0000113706 00000 n 0000113941 00000 n 0000114006 00000 n 0000114267 00000 n 0000114331 00000 n 0000114575 00000 n 0000114639 00000 n 0000114950 00000 n 0000115323 00000 n 0000115388 00000 n 0000115453 00000 n 0000115711 00000 n 0000115776 00000 n 0000116048 00000 n 0000116287 00000 n 0000116527 00000 n 0000116758 00000 n 0000116823 00000 n 0000117053 00000 n 0000117118 00000 n 0000117183 00000 n 0000117432 00000 n 0000117703 00000 n 0000117963 00000 n 0000118226 00000 n 0000118292 00000 n 0000118552 00000 n 0000118785 00000 n 0000118850 00000 n 0000119070 00000 n 0000119135 00000 n 0000119400 00000 n 0000119648 00000 n 0000119853 00000 n 0000119918 00000 n 0000120133 00000 n 0000120198 00000 n 0000120263 00000 n 0000120328 00000 n 0000120394 00000 n 0000120633 00000 n 0000120698 00000 n 0000120913 00000 n 0000121150 00000 n 0000121215 00000 n 0000121449 00000 n 0000121515 00000 n 0000121762 00000 n 0000121978 00000 n 0000122207 00000 n 0000122450 00000 n 0000122671 00000 n 0000122926 00000 n 0000123187 00000 n 0000123456 00000 n 0000123521 00000 n 0000123587 00000 n 0000123653 00000 n 0000123867 00000 n 0000123933 00000 n 0000124174 00000 n 0000124239 00000 n 0000124502 00000 n 0000124768 00000 n 0000124834 00000 n 0000124899 00000 n 0000124964 00000 n 0000125029 00000 n 0000125330 00000 n 0000125575 00000 n 0000125640 00000 n 0000125896 00000 n 0000126157 00000 n 0000126223 00000 n 0000126289 00000 n 0000126355 00000 n 0000126552 00000 n 0000126617 00000 n 0000126682 00000 n 0000126747 00000 n 0000126813 00000 n 0000126879 00000 n 0000126944 00000 n 0000127010 00000 n 0000127260 00000 n 0000127499 00000 n 0000127767 00000 n 0000128066 00000 n 0000128234 00000 n 0000128529 00000 n 0000128799 00000 n 0000129083 00000 n 0000129114 00000 n 0000129144 00000 n 0000096489 00000 n 0000001249 00000 n 0000003063 00000 n 0000129434 00000 n 0000129684 00000 n 0000129916 00000 n 0000130165 00000 n 0000130384 00000 n 0000130597 00000 n 0000130868 00000 n 0000131109 00000 n 0000131332 00000 n 0000131397 00000 n 0000131660 00000 n 0000131875 00000 n 0000132155 00000 n 0000132220 00000 n 0000132483 00000 n 0000132715 00000 n 0000132954 00000 n 0000133224 00000 n 0000133290 00000 n 0000133355 00000 n 0000133635 00000 n 0000133701 00000 n 0000133766 00000 n 0000134057 00000 n 0000134301 00000 n 0000134547 00000 n 0000134791 00000 n 0000135046 00000 n 0000135112 00000 n 0000135177 00000 n 0000135419 00000 n 0000135660 00000 n 0000135922 00000 n 0000136180 00000 n 0000136450 00000 n 0000136713 00000 n 0000136779 00000 n 0000137055 00000 n 0000137306 00000 n 0000137371 00000 n 0000137640 00000 n 0000137706 00000 n 0000137969 00000 n 0000138283 00000 n 0000138349 00000 n 0000138580 00000 n 0000138859 00000 n 0000139136 00000 n 0000139201 00000 n 0000139478 00000 n 0000139694 00000 n 0000139760 00000 n 0000139978 00000 n 0000140044 00000 n 0000140325 00000 n 0000140622 00000 n 0000140879 00000 n 0000141207 00000 n 0000141273 00000 n 0000141339 00000 n 0000141630 00000 n 0000141915 00000 n 0000142086 00000 n 0000142346 00000 n 0000142589 00000 n 0000142850 00000 n 0000143109 00000 n 0000143452 00000 n 0000143482 00000 n 0000096644 00000 n 0000003085 00000 n 0000003318 00000 n 0000143758 00000 n 0000143823 00000 n 0000143853 00000 n 0000096799 00000 n 0000003339 00000 n 0000006840 00000 n 0000144080 00000 n 0000144304 00000 n 0000144596 00000 n 0000144845 00000 n 0000145140 00000 n 0000145441 00000 n 0000145719 00000 n 0000145997 00000 n 0000146299 00000 n 0000146364 00000 n 0000146430 00000 n 0000146678 00000 n 0000146936 00000 n 0000147170 00000 n 0000147407 00000 n 0000218321 00000 n 0000147588 00000 n 0000147863 00000 n 0000148120 00000 n 0000148186 00000 n 0000148460 00000 n 0000148702 00000 n 0000148969 00000 n 0000149169 00000 n 0000149405 00000 n 0000149646 00000 n 0000149921 00000 n 0000150124 00000 n 0000150352 00000 n 0000150604 00000 n 0000150841 00000 n 0000151104 00000 n 0000151284 00000 n 0000151540 00000 n 0000151605 00000 n 0000151812 00000 n 0000152055 00000 n 0000152294 00000 n 0000152559 00000 n 0000152815 00000 n 0000153053 00000 n 0000153281 00000 n 0000153501 00000 n 0000153567 00000 n 0000153826 00000 n 0000154069 00000 n 0000154236 00000 n 0000154488 00000 n 0000154757 00000 n 0000155000 00000 n 0000155253 00000 n 0000155524 00000 n 0000155590 00000 n 0000155821 00000 n 0000156107 00000 n 0000156379 00000 n 0000156445 00000 n 0000156644 00000 n 0000156929 00000 n 0000157211 00000 n 0000157490 00000 n 0000157774 00000 n 0000158049 00000 n 0000158114 00000 n 0000158416 00000 n 0000158588 00000 n 0000158787 00000 n 0000159022 00000 n 0000159276 00000 n 0000159342 00000 n 0000159597 00000 n 0000159852 00000 n 0000160112 00000 n 0000160358 00000 n 0000160557 00000 n 0000160807 00000 n 0000161043 00000 n 0000161274 00000 n 0000161505 00000 n 0000161756 00000 n 0000161978 00000 n 0000162186 00000 n 0000162424 00000 n 0000162658 00000 n 0000162872 00000 n 0000163090 00000 n 0000163322 00000 n 0000163536 00000 n 0000163778 00000 n 0000163975 00000 n 0000164227 00000 n 0000164450 00000 n 0000164659 00000 n 0000164908 00000 n 0000165122 00000 n 0000165349 00000 n 0000165414 00000 n 0000165671 00000 n 0000165896 00000 n 0000166140 00000 n 0000166393 00000 n 0000166628 00000 n 0000166899 00000 n 0000167148 00000 n 0000167368 00000 n 0000167590 00000 n 0000167869 00000 n 0000168050 00000 n 0000168090 00000 n 0000096954 00000 n 0000006862 00000 n 0000009983 00000 n 0000168360 00000 n 0000168604 00000 n 0000168870 00000 n 0000169181 00000 n 0000169451 00000 n 0000169747 00000 n 0000169994 00000 n 0000170297 00000 n 0000170568 00000 n 0000170834 00000 n 0000171049 00000 n 0000171334 00000 n 0000171519 00000 n 0000171585 00000 n 0000171794 00000 n 0000171860 00000 n 0000172105 00000 n 0000172373 00000 n 0000172538 00000 n 0000172706 00000 n 0000172872 00000 n 0000097109 00000 n 0000010005 00000 n 0000012830 00000 n 0000172912 00000 n 0000173162 00000 n 0000173426 00000 n 0000173662 00000 n 0000173728 00000 n 0000173943 00000 n 0000174187 00000 n 0000174361 00000 n 0000174660 00000 n 0000174924 00000 n 0000175095 00000 n 0000175364 00000 n 0000097264 00000 n 0000012852 00000 n 0000015894 00000 n 0000175404 00000 n 0000175585 00000 n 0000175829 00000 n 0000175895 00000 n 0000176191 00000 n 0000176452 00000 n 0000176709 00000 n 0000176971 00000 n 0000097419 00000 n 0000015916 00000 n 0000018959 00000 n 0000177011 00000 n 0000177275 00000 n 0000177574 00000 n 0000177809 00000 n 0000177875 00000 n 0000178122 00000 n 0000097574 00000 n 0000018981 00000 n 0000022016 00000 n 0000178162 00000 n 0000097721 00000 n 0000022038 00000 n 0000025210 00000 n 0000178202 00000 n 0000178458 00000 n 0000178676 00000 n 0000178895 00000 n 0000179093 00000 n 0000179282 00000 n 0000179546 00000 n 0000179785 00000 n 0000097876 00000 n 0000025232 00000 n 0000028234 00000 n 0000179825 00000 n 0000179891 00000 n 0000098023 00000 n 0000028256 00000 n 0000031581 00000 n 0000179931 00000 n 0000179996 00000 n 0000180271 00000 n 0000180492 00000 n 0000180558 00000 n 0000180865 00000 n 0000181071 00000 n 0000181239 00000 n 0000181403 00000 n 0000181568 00000 n 0000181732 00000 n 0000181897 00000 n 0000214838 00000 n 0000182060 00000 n 0000182221 00000 n 0000182384 00000 n 0000182545 00000 n 0000182709 00000 n 0000182872 00000 n 0000183035 00000 n 0000183197 00000 n 0000183406 00000 n 0000183641 00000 n 0000183891 00000 n 0000184089 00000 n 0000184338 00000 n 0000184559 00000 n 0000184777 00000 n 0000184962 00000 n 0000185223 00000 n 0000185467 00000 n 0000185686 00000 n 0000185936 00000 n 0000186150 00000 n 0000186366 00000 n 0000186608 00000 n 0000186825 00000 n 0000187047 00000 n 0000187285 00000 n 0000187531 00000 n 0000187729 00000 n 0000187990 00000 n 0000188227 00000 n 0000188453 00000 n 0000188717 00000 n 0000188960 00000 n 0000189213 00000 n 0000189442 00000 n 0000189700 00000 n 0000189941 00000 n 0000190179 00000 n 0000190406 00000 n 0000190663 00000 n 0000190917 00000 n 0000191127 00000 n 0000191362 00000 n 0000191621 00000 n 0000191916 00000 n 0000192155 00000 n 0000192427 00000 n 0000098178 00000 n 0000031603 00000 n 0000034934 00000 n 0000192477 00000 n 0000192735 00000 n 0000192964 00000 n 0000193254 00000 n 0000193499 00000 n 0000193785 00000 n 0000194032 00000 n 0000194280 00000 n 0000194570 00000 n 0000194812 00000 n 0000098333 00000 n 0000034956 00000 n 0000037804 00000 n 0000194862 00000 n 0000195088 00000 n 0000098488 00000 n 0000037826 00000 n 0000040624 00000 n 0000195138 00000 n 0000195403 00000 n 0000195644 00000 n 0000098643 00000 n 0000040646 00000 n 0000043939 00000 n 0000195694 00000 n 0000195940 00000 n 0000196201 00000 n 0000196460 00000 n 0000098798 00000 n 0000043961 00000 n 0000046179 00000 n 0000196510 00000 n 0000196707 00000 n 0000098953 00000 n 0000046201 00000 n 0000048634 00000 n 0000196757 00000 n 0000196992 00000 n 0000197042 00000 n 0000099108 00000 n 0000048656 00000 n 0000051259 00000 n 0000197323 00000 n 0000197586 00000 n 0000197837 00000 n 0000198086 00000 n 0000099263 00000 n 0000051281 00000 n 0000054053 00000 n 0000198136 00000 n 0000198415 00000 n 0000198678 00000 n 0000198916 00000 n 0000199150 00000 n 0000199331 00000 n 0000099418 00000 n 0000054075 00000 n 0000057649 00000 n 0000199381 00000 n 0000199608 00000 n 0000199777 00000 n 0000200014 00000 n 0000200182 00000 n 0000200422 00000 n 0000200658 00000 n 0000200989 00000 n 0000201206 00000 n 0000201446 00000 n 0000201700 00000 n 0000201750 00000 n 0000099573 00000 n 0000057671 00000 n 0000060755 00000 n 0000202010 00000 n 0000202277 00000 n 0000202537 00000 n 0000202789 00000 n 0000099728 00000 n 0000060777 00000 n 0000064208 00000 n 0000202839 00000 n 0000203008 00000 n 0000099883 00000 n 0000064230 00000 n 0000067442 00000 n 0000203058 00000 n 0000203108 00000 n 0000100030 00000 n 0000067464 00000 n 0000070359 00000 n 0000203387 00000 n 0000203678 00000 n 0000204010 00000 n 0000204339 00000 n 0000204610 00000 n 0000204660 00000 n 0000100185 00000 n 0000070381 00000 n 0000073373 00000 n 0000204946 00000 n 0000205168 00000 n 0000205403 00000 n 0000205663 00000 n 0000205910 00000 n 0000206152 00000 n 0000206202 00000 n 0000100340 00000 n 0000073395 00000 n 0000076360 00000 n 0000206449 00000 n 0000206757 00000 n 0000206954 00000 n 0000100495 00000 n 0000076382 00000 n 0000079573 00000 n 0000207004 00000 n 0000207278 00000 n 0000207531 00000 n 0000207776 00000 n 0000207842 00000 n 0000208133 00000 n 0000208418 00000 n 0000208649 00000 n 0000208898 00000 n 0000209163 00000 n 0000209423 00000 n 0000209662 00000 n 0000100650 00000 n 0000079595 00000 n 0000082429 00000 n 0000209712 00000 n 0000210031 00000 n 0000210303 00000 n 0000210541 00000 n 0000210789 00000 n 0000211047 00000 n 0000100805 00000 n 0000082451 00000 n 0000085833 00000 n 0000211097 00000 n 0000100952 00000 n 0000085855 00000 n 0000088976 00000 n 0000211147 00000 n 0000211412 00000 n 0000211675 00000 n 0000211725 00000 n 0000101107 00000 n 0000088998 00000 n 0000092111 00000 n 0000212022 00000 n 0000212196 00000 n 0000212493 00000 n 0000212752 00000 n 0000213011 00000 n 0000213307 00000 n 0000213641 00000 n 0000213874 00000 n 0000214114 00000 n 0000214396 00000 n 0000214446 00000 n 0000101262 00000 n 0000092133 00000 n 0000094511 00000 n 0000214738 00000 n 0000101417 00000 n 0000094533 00000 n 0000096297 00000 n 0000214788 00000 n trailer << /Size 687 /Root 1 0 R /Info 2 0 R >> startxref 227545 %%EOF iterate-20160825-darcs/doc/tex/GNUmakefile0000644000000000000000000000076412757566717016355 0ustar0000000000000000SOURCES=iterate-bare.tex iterate-manual.tex DUMMY_INDEXES=iterate-manual.ind MKIDX=makeindex MKIDXFLAGS=-l LATEX=latex all: iterate-bare.pdf iterate-manual.pdf iterate-bare.ps iterate-manual.ps %.dvi: %.tex touch $*.ind $*.idx ${LATEX} $< ${MKIDX} ${MKIDXFLAGS} $*.idx ${LATEX} $< %.ps: %.dvi dvips -o $@ $*.dvi %.pdf: %.dvi dvipdf $*.dvi $@ clean: rm -f *.dvi *.log *.aux *.ind *.idx *.toc *.auxs *.ilg shiny: clean rm -f *.ps *.pdf # arch-tag: "c8f080e3-313c-11d8-abb9-000c76244c24" iterate-20160825-darcs/doc/tex/aimemo.sty0000644000000000000000000001726112757566717016313 0ustar0000000000000000% Use the full page % \oddsidemargin 18pt \evensidemargin 18pt \topmargin 0pt \textheight 595pt \textwidth 432pt % Topheading supplies left and right flushed headings for the % lrheading command. % \def\topheadings#1#2{\def\@toplefthead{#1}\def\@toprighthead{#2}} % Page style: lrheadings % put text suplied by the topheadings command in the left and % right corners of the topheading. % \def\ps@lrheadings{% \def\@oddhead{\hbox{}\sl\@toplefthead\hfil\sl\@toprighthead}% \def\@evenhead{\sl\@toplefthead\hfil\sl\@toprighthead\hbox{}}% \def\@oddfoot{\hbox{}\hfil\rm\thepage\hfil}% \def\@evenfoot{\hbox{}\hfil\rm\thepage\hfil}} % Page style: footpagenumber % put nothing in header and center the page number in the footer. % \def\ps@footpagenumber{% \def\@oddhead{}\def\@evenhead{}% \def\@oddfoot{\hbox{}\hfil\rm\thepage\hfil}% \def\@evenfoot{\hbox{}\hfil\rm\thepage\hfil}} % \skipline leaves a blank line realitive to the size of the current % font. % \def\skipline{\vskip 2em} % % get the title page correct % % set these to do something \def\writtenby{Sundar Narasimhan} \def\contractno{Fill in appropriate ARPA/ONR contract no.} \def\AIMEMO #1#2#3{ % \begin{titlepage} \begin{center} MASSACHUSETTS INSTITUTE OF TECHNOLOGY\\ ARTIFICIAL INTELLIGENCE LABORATORY \end{center} \vskip 1in \hbox to \hsize{A.I.Memo No. #1 \hfill \shortdate} \vskip 1in \begin{center} {\bf #2} \end{center} \vskip 0.5in \begin{center} \writtenby \end{center} \vskip 1in {\bf Abstract: } #3 \hbox to \hsize{\hrulefill} % draw a line \contractno \end{titlepage} } % % Argument convention - same as before % \def\AIWORKINGPAPER #1#2#3{ % \begin{titlepage} \begin{center} MASSACHUSETTS INSTITUTE OF TECHNOLOGY\\ ARTIFICIAL INTELLIGENCE LABORATORY \end{center} \vskip 1in \hbox to \hsize{Working Paper No. #1 \hfill \shortdate} \vskip 1in \begin{center} {\bf #2} \end{center} \vskip 0.5in \begin{center} \writtenby \end{center} \vskip 1.5in {\bf Abstract: } #3 \hbox to \hsize{\hrulefill} % draw a line A.I.Lab Working Papers are produced for internal circulation and may contain information that is, for example, too preliminary or too detailed for formal publication. It is not intended that they should be considered papers to which reference can be made in the literature. \end{titlepage} } % stuff to change the format of figures % % change parameters to position floats % \renewcommand{\topfraction}{.9} \renewcommand{\bottomfraction}{.9} \renewcommand{\textfraction}{.1} \renewcommand{\floatpagefraction}{.8} \setcounter{totalnumber}{10} \setcounter{topnumber}{10} \setcounter{bottomnumber}{10} % % The new definition for chapterhead % %\def\@chapapp{\sf Section} \def\@makechapterhead#1{ \vspace*{10pt} { \parindent 0pt \raggedright \hfill \bf \hfill \thechapter. \ #1\par \nobreak \vskip 5pt \hrule \nobreak \vskip 40pt }} % % new section commands % \def\section{\@startsection {section}{1}{\z@}{3.5ex plus 1ex minus .2ex}{2.3ex plus .2ex}{\bf}} \def\subsection{\@startsection{subsection}{2}{\z@}{3.25ex plus 1ex minus .2ex}{1.5ex plus .2ex}{\bf}} \def\subsubsection{\@startsection{subsubsection}{3}{\z@}{3.25ex plus 1ex minus .2ex}{1.5ex plus .2ex}{\normalsize\bf}} \def\paragraph{\@startsection {paragraph}{4}{\z@}{3.25ex plus 1ex minus .2ex}{-1em}{\normalsize\bf}} \def\subparagraph{\@startsection {subparagraph}{4}{\parindent}{3.25ex plus 1ex minus .2ex}{-1em}{\normalsize\bf}} % % The new quotation environment % % we use the peni font that looks rather nice. %\font\peni=peni10 %\def\myquot#1{{\hbox{} %\hfill\parbox{3.5in}{\raggedright{\peni #1}} % \\*[\parskip]}\par} %\def\quotauth#1{\hbox to \hsize{\hfill \small #1 \\} \par} % Date and time macros \newcount\hour \newcount\minute \hour=\the\time \minute=\the\time \divide\hour by 60 \multiply\hour by 60% \advance\minute by -\hour \divide\hour by 60% \def\daytime{\number\hour:\ifnum \minute<10 0\fi\number\minute}% \def\monthname {\ifcase\month \or Jan\or Feb\or Mar\or Apr\or May\or Jun\or Jul\or Aug\or Sep\or Oct\or Nov\or Dec\fi}% \def\date{\monthname~\number\day,~\number\year}% \def\datetime{\monthname~\number\day,~\number\year~[\daytime]}% \def\slashdate{\number\month/\number\day/\number\year}% \def\slashdatetime{\number\month/\number\day/\number\year~[\daytime]}% % the new list environments - works only for top level environments \newenvironment{alphenumerate}{\def\labelenumi{(\alph{enumi})}\begin{enumerate}}{\end{enumerate}} \newenvironment{romanenumerate}{\def\labelenumi{\roman{enumi}.}\begin{enumerate}}{\end{enumerate}} \newenvironment{Romanenumerate}{\def\labelenumi{\Roman{enumi}.}\begin{enumerate}}{\end{enumerate}} \newenvironment{Alphenumerate}{\def\labelenumi{(\Alph{enumi})}\begin{enumerate}}{\end{enumerate}} % Date and time macros \newcount\hour \newcount\minute \hour=\the\time \minute=\the\time \divide\hour by 60 \multiply\hour by 60% \advance\minute by -\hour \divide\hour by 60% \def\daytime{\number\hour:\ifnum \minute<10 0\fi\number\minute}% \def\monthname {\ifcase\month \or Jan\or Feb\or Mar\or Apr\or May\or Jun\or Jul\or Aug\or Sep\or Oct\or Nov\or Dec\fi}% \def\longmonthname {\ifcase\month \or January\or February\or March\or April\or May\or June\or July\or August\or September\or October\or November\or December\fi}% \def\date{\monthname~\number\day,~\number\year~[\daytime]}% \def\slashdate{\number\month/\number\day/\number\year}% \def\shortdate{\longmonthname,~\number\year}% % Math macros \def\v#1{\mbox{$\bf #1$}} \def\cross{\times} \def\jac_t{{\bf J}^{T}} \def\jac_inv{{\bf J}^{-1}} \def\jac{{\bf J}} % Float stuff %\def\@float#1{\@ifnextchar[{\@xfloat{#1}}{\edef\@tempa{\noexpand\@xfloat % {#1}[\csname fps@#1\endcsname]}\@tempa}} % %\def\@xfloat#1[#2]{\ifhmode \@bsphack\@floatpenalty -\@Mii\else % \@floatpenalty-\@Miii\fi\def\@captype{#1}\ifinner % \@parmoderr\@floatpenalty\z@ % \else\@next\@currbox\@freelist{\@tempcnta\csname ftype@#1\endcsname % \multiply\@tempcnta\@xxxii\advance\@tempcnta\sixt@@n % \@tfor \@tempa :=#2\do % {\if\@tempa h\advance\@tempcnta \@ne\fi % \if\@tempa t\advance\@tempcnta \tw@\fi % \if\@tempa b\advance\@tempcnta 4\relax\fi % \if\@tempa p\advance\@tempcnta 8\relax\fi % }\global\count\@currbox\@tempcnta}\@fltovf\fi % \global\setbox\@currbox\vbox\bgroup % \boxmaxdepth\z@ % \hsize\columnwidth \@parboxrestore} % %\def\end@float{\egroup % \ifnum\@floatpenalty <\z@ % \@cons\@currlist\@currbox % \ifdim \ht\@currbox >\textheight % \ht\@currbox\textheight \fi % \global\@outputdonefalse % \ifnum\@floatpenalty < -\@Mii % \penalty\@floatpenalty % \if@outputdone\else\global\@outputdonetrue % \vbox{}\penalty\@floatpenalty\fi % \else \vadjust{\penalty \@floatpenalty}\@esphack\fi\fi} % %\def\@dblfloat#1{\if@twocolumn\else\@latexerr{Two-column float %on one-column page}\@ehd\fi %\@ifnextchar[{\@xdblfloat{#1}}{\@xdblfloat{#1}[tp]}} % line space commands (from dms.sty) \def\varspace#1{\def\baselinestretch{#1}\large\normalsize} \def\dspace{\def\baselinestretch{1.5}\large\normalsize} \def\mspace{\def\baselinestretch{1.25}\large\normalsize} \def\sspace{\def\baselinestretch{1.0}\large\normalsize} \def\tspace{\def\baselinestretch{.85}\large\normalsize} \let\double=\dspace \let\single=\sspace % Illustrate macros for latex - see GLR's working paper on the subject \newcommand{\psbox}[3]{% \makebox[#1][l]{% \parbox[b]{0.0in}{\vspace*{#2}}% \special{psfile=#3}}} % 4.25in=306 ps points, 5.50 in = 396 ps points \newlength{\illheight} \newcommand{\illustratefile}[3]{% \makebox[#1]{% \setlength{\illheight}{#2}% \raisebox{0.5\illheight}[\illheight][0.0in]{% \special{psfile=#3 hoffset=-306 voffset=-396}}}} \endinput % arch-tag: "185f1ce2-313d-11d8-abb9-000c76244c24" iterate-20160825-darcs/bin/0000755000000000000000000000000012757566717013477 5ustar0000000000000000iterate-20160825-darcs/bin/release.sh0000644000000000000000000000123512757566717015454 0ustar0000000000000000#!/bin/sh VERSION=$1 ARCHIVE_NAME=iterate-"$VERSION".tar.gz ARCHIVE_PATH="/project/iterate/public_html/releases" ARCHIVE_FULLNAME="$ARCHIVE_PATH/$ARCHIVE_NAME" if [ -e "$ARCHIVE_FULLNAME" ]; then echo "$ARCHIVE_FULLNAME already exists" exit -1 fi echo "Don't forget to tag the darcs repo! Creating release $ARCHIVE_FULLNAME, press enter to continue..." read cd /project/iterate/darcs cp -r iterate iterate-$VERSION tar --exclude="iterate*/_darcs*" -zvcf "$ARCHIVE_FULLNAME" iterate-$VERSION rm -rf iterate-$VERSION cd "$ARCHIVE_PATH" gpg -b -a "$ARCHIVE_NAME" ln -fs "$ARCHIVE_NAME" iterate-current.tar.gz ln -fs "$ARCHIVE_NAME".asc iterate-current.tar.gz.asc