sync to trunk

svn: r14861

collects/compiler/zo-parse.ss

@@ -505,6 +505,7 @@
 (define-form-struct wrap ())
 (define-form-struct (lexical-rename wrap) (alist))
 (define-form-struct (phase-shift wrap) (amt src dest))
+(define-form-struct (prune wrap) (sym))
 (define-form-struct (module-rename wrap) (phase kind set-id unmarshals renames mark-renames plus-kern?))
 
 (define-form-struct all-from-module (path phase src-phase exceptions prefix))
@@ -691,6 +692,7 @@
                  '(#%mark-barrier)]
                 [(box? a)
                  (match (unbox a)
+                   [(list (? symbol?) ...) (make-prune (unbox a))]
                    [`#(,amt ,src ,dest #f)
                     (make-phase-shift amt 
                                       (parse-module-path-index cp src)

collects/errortrace/stacktrace.ss

@@ -80,7 +80,7 @@
       ;; expressions with test suite coverage information.  Returning the
       ;; first argument means no tests coverage information is collected.
 
-      ;; test-coverage-point : syntax syntax -> syntax
+      ;; test-coverage-point : syntax syntax phase -> syntax
       ;; sets a test coverage point for a single expression
       (define (test-coverage-point body expr phase)
         (if (and (test-coverage-enabled)
@@ -353,14 +353,29 @@
              [(define-values names rhs)
               top?
               ;; Can't put annotation on the outside
-              (let ([marked (with-mark expr
+              (let* ([marked 
+                      (with-mark expr
                                  (annotate-named
                                   (one-name #'names)
                                   (syntax rhs)
-                                        phase))])
+                                  phase))]
+                     [with-coverage
+                      (let loop ([stx #'names]
+                                 [obj marked])
+                        (cond
+                          [(not (syntax? stx)) obj]
+                          [(identifier? stx)
+                           (test-coverage-point obj stx phase)]
+                          [(pair? (syntax-e stx))
+                           (loop (car (syntax-e stx))
+                                 (loop (cdr (syntax-e stx))
+                                       obj))]
+                          [else obj]))])
                 (certify
                  expr
-                 (rebuild expr (list (cons #'rhs marked)))))]
+                 (rebuild 
+                  expr 
+                  (list (cons #'rhs with-coverage)))))]
              [(begin . exprs)
               top?
               (certify

collects/htdp/Test/matrix-test.ss

@@ -2,7 +2,7 @@
 ;; about the language level of this file in a form that our tools can easily process.
 #reader(lib "htdp-intermediate-lambda-reader.ss" "lang")((modname matrix-test) (read-case-sensitive #t) (teachpacks ()) (htdp-settings #(#t constructor repeating-decimal #f #t none #f ())))
 ;(require htdp/matrix-invisible)
-(require htdp/matrix)
+(require (lib "matrix.ss" "htdp"))
 
 (define r1 '((a00 a01 a02)
              (a10 a11 a12)))
@@ -52,5 +52,5 @@
 
 ;; --- IMPERATIVE --- 
 (check-expect (matrix-ref m1 0 0) 'a00)
-(define m1-modified (matrix-set! m1 0 0 'xxx)) ;; <-------- uncomment this and the test engine breaks
+;(define m1-modified (matrix-set! m1 0 0 'xxx)) ;; <-------- uncomment this and the test engine breaks
-(check-expect (matrix-ref m1 0 0) 'xxx)
+;(check-expect (matrix-ref m1 0 0) 'xxx)

collects/htdp/Test/world-add-line.ss

@@ -1,6 +1,7 @@
 ;; The first three lines of this file were inserted by DrScheme. They record metadata
 ;; about the language level of this file in a form that our tools can easily process.
 #reader(lib "htdp-beginner-reader.ss" "lang")((modname world-add-line) (read-case-sensitive #t) (teachpacks ((lib "world.ss" "teachpack" "htdp"))) (htdp-settings #(#t constructor repeating-decimal #f #t none #f ((lib "world.ss" "teachpack" "htdp")))))
+(require (lib "world.ss" "htdp"))
 ;(require htdp/world)
 
 (define plain (empty-scene 100 100))

collects/htdp/Test/world.ss

@@ -1,6 +1,6 @@
 ;; The first three lines of this file were inserted by DrScheme. They record metadata
 ;; about the language level of this file in a form that our tools can easily process.
-#reader(lib "htdp-intermediate-lambda-reader.ss" "lang")((modname world) (read-case-sensitive #t) (teachpacks ((lib "world.ss" "teachpack" "htdp"))) (htdp-settings #(#t constructor repeating-decimal #f #t none #f ((lib "world.ss" "teachpack" "htdp")))))
+#reader(lib "htdp-intermediate-lambda-reader.ss" "lang")((modname world) (read-case-sensitive #t) (teachpacks ((lib "universe.ss" "teachpack" "2htdp") (lib "foo.ss" "installed-teachpacks"))) (htdp-settings #(#t constructor repeating-decimal #f #t none #f ((lib "universe.ss" "teachpack" "2htdp") (lib "foo.ss" "installed-teachpacks")))))
 ;; testing world
 ;; World = Nat
 
@@ -27,14 +27,15 @@
 (check-expect (key=? 'a #\a) false)
 (check-expect (key=? 'left 'left) true)
 
-(check-error (key=? 'a 0) "key=?: expected <KeyEvent> as first argument, given: 0")
+(check-error (key=? 'a 0) "key=?: expected <KeyEvent> as second argument, given: 0")
 
 
 ;; run world run
 
-(big-bang 100 100 .01 world0 true) ;; get ready to create images 
+xxx
 
-(on-redraw world->image)
+(big-bang world0
-(on-tick-event world->next)
+          (on-draw world->image)
-(on-key-event world->steer)
+          (on-tick world->next)
-(stop-when zero?)
+          (on-key world->steer)
+          (stop-when zero?))

collects/htdp/error.ss

@@ -34,7 +34,9 @@
 (define-struct (tp-exn exn) ())
 
 (define (tp-error name fmt . args)
-  (raise (make-tp-exn (string-append (format "~a: " name) (apply format fmt args))
+  (raise 
+   (make-exn:fail:contract #; make-tp-exn 
+    (string-append (format "~a: " name) (apply format fmt args))
     (current-continuation-marks))))
 
 (define (number->ord i)

collects/lang/private/beginner-funs.ss

@@ -358,11 +358,36 @@
       (char->integer (char -> integer)
 	"to lookup the number that corresponds to the"
 	" given character in the ASCII table (if any)"))
+    
     ("Strings"
       (string? (any -> boolean)
 	"to determine whether a value is a string")
       (string-length (string -> nat)
 	"to determine the length of a string")
+      
+      ((beginner-string-ith string-ith) (string -> string)
+        "to extract the ith 1-letter substring from the given one")
+      ((beginner-replicate replicate) (string nat -> string)
+        "to replicate the given string")
+      ((beginner-int->string int->string) (integer -> string)
+        "to convert an integer in [0,55295] or [57344 1114111] to a 1-letter string")
+      ((beginner-string->int string->int) (string -> integer)
+        "to convert a 1-letter string to an integer in [0,55295] or [57344 1114111]")
+      ((beginner-explode explode) (string -> (listof string))
+        "to translate a string into a list of 1-letter strings")
+      ((beginner-implode implode) ((listof string) -> string)
+        "to concatenate the list of 1-letter strings into one string")
+      ((beginner-string-numeric? string-numeric?) (string -> boolean)
+        "to determine whether all 'letters' in the string are numeric")
+      ((beginner-string-alphabetic? string-alphabetic?) (string -> boolean)
+        "to determine whether all 'letters' in the string are alphabetic")
+      ((beginner-string-whitespace? string-whitespace?) (string -> boolean)
+        "to determine whether all 'letters' in the string are white space") 
+      ((beginner-string-upper-case? string-upper-case?) (string -> boolean)
+        "to determine whether all 'letters' in the string are upper case")
+      ((beginner-string-lower-case? string-lower-case?) (string -> boolean)
+        "to determine whether all 'letters' in the string are lower case")
+ 
       (string (char ... -> string)
 	"(string c1 c2 ...) builds a string")
       (make-string (nat char -> string)

collects/lang/private/intermediate-funs.ss

@@ -7,8 +7,16 @@
 
   (provide-and-document
    procedures
-   (all-from beginner: lang/private/beginner-funs procedures)
+   (all-from-except beginner: lang/private/beginner-funs procedures
+                    + * - /)
 
+   ("Numbers (relaxed conditions)"
+    
+    (+ (number ... -> number) "to add all given numbers")
+    (* (number ... -> number) "to multiply all given numbers")
+    (- (number ... -> number) "to subtract from the first all remaining numbers")
+    (/ (number ... -> number) "to divide the first by all remaining numbers")
+    )
    ("Higher-Order Functions"
     (map ((X ... -> Z) (listof X) ... -> (listof Z))
 	 "to construct a new list by applying a function to each item on one or more existing lists") 

collects/lang/private/teachprims.ss

@@ -8,33 +8,37 @@ collects/tests/mzscheme/beginner.ss
 Each one has to run separately, since they mangle the top-level
 namespace.
 |#
-(module teachprims mzscheme
 
-  (require mzlib/list 
+;; MF: switched from 
+;; module teachprims mzscheme
+;; to 
+#lang scheme 
+
+(require mzlib/list 
          mzlib/math
          mzlib/etc)
 
-  (define-syntax (define-teach stx)
+(define-syntax (define-teach stx)
   (syntax-case stx ()
     [(_ level id expr)
-       (with-syntax ([level-id (datum->syntax-object
+     (with-syntax ([level-id (datum->syntax
                               (syntax id)
                               (string->symbol
                                (format "~a-~a"
-				     (syntax-object->datum (syntax level))
+                                       (syntax->datum (syntax level))
-				     (syntax-object->datum (syntax id))))
+                                       (syntax->datum (syntax id))))
                               (syntax id))])
        (syntax (define level-id
                  (let ([id expr])
                    id))))]))
 
-  (define-teach beginner list?
+(define-teach beginner list?
   (lambda (x)
     (or (null? x) (pair? x))))
 
-  ;; Don't need this anymore, since we just check for pairs:
+;; Don't need this anymore, since we just check for pairs:
-  #;
+#;
-  (define cyclic-list?
+(define cyclic-list?
   (lambda (l)
     (or (list? l)
         (and (pair? l)
@@ -46,9 +50,9 @@ namespace.
                  [(not (pair? (cdr hare))) #f]
                  [else (loop (cddr hare) (cdr turtle))]))))))
 
-  (define cyclic-list? beginner-list?)
+(define cyclic-list? beginner-list?)
 
-  (define (build-arg-list args)
+(define (build-arg-list args)
   (let loop ([args args][n 0])
     (cond
       [(null? args) ""]
@@ -56,7 +60,7 @@ namespace.
       [else
        (format " ~e~a" (car args) (loop (cdr args) (add1 n)))])))
 
-  (define (mk-check-second ok? type)
+(define (mk-check-second ok? type)
   (lambda (prim-name a b)
     (unless (ok? b)
       (raise
@@ -66,13 +70,13 @@ namespace.
                 a b)
         (current-continuation-marks))))))
 
-  (define check-second 
+(define check-second 
   (mk-check-second beginner-list? "list"))
 
-  (define check-second/cycle
+(define check-second/cycle
   (mk-check-second cyclic-list? "list or cyclic list"))
 
-  (define (mk-check-last ok? type)
+(define (mk-check-last ok? type)
   (lambda (prim-name args)
     (let loop ([l args])
       (cond
@@ -94,13 +98,13 @@ namespace.
                (current-continuation-marks)))))]
         [else (loop (cdr l))]))))
 
-  (define check-last
+(define check-last
   (mk-check-last beginner-list? "list"))
 
-  (define check-last/cycle
+(define check-last/cycle
   (mk-check-last cyclic-list? "list or cyclic list"))
 
-  (define (check-three a b c prim-name ok1? 1type ok2? 2type ok3? 3type)
+(define (check-three a b c prim-name ok1? 1type ok2? 2type ok3? 3type)
   (let ([bad
          (lambda (v which type)
            (raise
@@ -113,12 +117,12 @@ namespace.
     (unless (ok2? b) (bad b "second" 2type))
     (unless (ok3? c) (bad c "third"  3type))))
 
-  (define (positive-real? v)
+(define (positive-real? v)
   (and (real? v) (>= v 0)))
 
-  (define (false? v) (eq? v #f))
+(define (false? v) (eq? v #f))
 
-  (define-teach beginner not
+(define-teach beginner not
   (lambda (a)
     (unless (boolean? a)
       (raise
@@ -127,23 +131,23 @@ namespace.
         (current-continuation-marks))))
     (not a)))
 
-  (define-teach beginner random 
+(define-teach beginner random 
   (lambda (a)
     (random a)))
 
-  (define-teach beginner +
+(define-teach beginner +
   (lambda (a b . args)
     (apply + a b args)))
 
-  (define-teach beginner /
+(define-teach beginner /
   (lambda (a b . args)
     (apply / a b args)))
 
-  (define-teach beginner *
+(define-teach beginner *
   (lambda (a b . args)
     (apply * a b args)))
 
-  (define-teach beginner sqr
+(define-teach beginner sqr
   (lambda (a)
     (unless (number? a)
       (raise
@@ -152,27 +156,27 @@ namespace.
         (current-continuation-marks))))
     (sqr a)))
 
-  (define-teach beginner member 
+(define-teach beginner member 
   (lambda (a b)
     (check-second 'member a b)
     (not (boolean? (member a b)))))
 
-  (define-teach beginner cons 
+(define-teach beginner cons 
   (lambda (a b)
     (check-second 'cons a b)
     (cons a b)))
 
-  (define-teach beginner list*
+(define-teach beginner list*
   (lambda x
     (check-last 'list* x)
     (apply list* x)))
 
-  (define-teach beginner append
+(define-teach beginner append
   (lambda (a b . x)
     (check-last 'append (cons a (cons b x)))
     (apply append a b x)))
 
-  (define-teach beginner error
+(define-teach beginner error
   (lambda (sym str)
     (unless (and (symbol? sym)
                  (string? str))
@@ -183,7 +187,7 @@ namespace.
         (current-continuation-marks))))
     (error sym "~a" str)))
 
-  (define-teach beginner struct?
+(define-teach beginner struct?
   (lambda (x)
     (not (or (number? x)
              (boolean? x)
@@ -197,22 +201,22 @@ namespace.
              (eof-object? x)
              (void? x)))))
 
-  (define-teach beginner exit
+(define-teach beginner exit
   (lambda () (exit)))
 
-  (define (tequal? a b epsilon)
+(define (tequal? a b epsilon)
-    (let* ([ht (make-hash-table)]
+  (let* ([ht (make-hash)] ;; make-hash
          [union-find (lambda (a)
                        (let loop ([prev a]
                                   [prev-prev a])
-                           (let ([v (hash-table-get ht prev #f)])
+                         (let ([v (hash-ref ht prev #f)])
                            (if v
                                (loop v prev)
                                (begin
                                  (let loop ([a a])
                                    (unless (eq? a prev-prev)
-                                       (let ([v (hash-table-get ht a)])
+                                     (let ([v (hash-ref ht a)])
-                                         (hash-table-put! ht a prev)
+                                       (hash-set! ht a prev)
                                        (loop v))))
                                  prev)))))]
          [union-equal!? (lambda (a b)
@@ -221,7 +225,7 @@ namespace.
                             (if (eq? a b)
                                 #t
                                 (begin
-                                    (hash-table-put! ht b a)
+                                  (hash-set! ht b a)
                                   #f))))])
     (let ? ([a a][b b])
       (cond
@@ -231,27 +235,27 @@ namespace.
         [(union-equal!? a b) #t]
         [else (equal?/recur a b ?)]))))
 
-  (define-teach beginner equal?
+(define-teach beginner equal?
   (lambda (a b)
     (equal? a b)))
 
-  (define-teach beginner =~
+(define-teach beginner =~
   (lambda (a b c)
     (check-three a b c '=~ real? 'real real? 'real positive-real? 'non-negative-real)
     (<= (- a c) b (+ a c))))
 
-  (define-teach beginner equal~?
+(define-teach beginner equal~?
   (lambda (a b c)
     (check-three a b c 'equal~? values 'any values 'any positive-real? 'non-negative-real)
     (tequal? a b c)))
 
-  (define (qcheck quicksort fmt-str . x)
+(define (qcheck quicksort fmt-str . x)
   (raise
    (make-exn:fail:contract
     (string-append (format "~a : " quicksort) (apply format fmt-str x))
     (current-continuation-marks))))
 
-  (define (do-sort l cmp? name)
+(define (do-sort l cmp? name)
   (unless (beginner-list? l) 
     (qcheck name "first argument must be of type <list>, given ~e" l))
   (unless (and (procedure? cmp?) (procedure-arity-includes? cmp? 2))
@@ -262,14 +266,14 @@ namespace.
               (qcheck name "the results of the procedure argument must be of type <boolean>, produced ~e" r))
             r)))
 
-  (define-teach intermediate quicksort
+(define-teach intermediate quicksort
   (lambda (l cmp?)
     (do-sort l cmp? 'quicksort)))
-  (define-teach intermediate sort
+(define-teach intermediate sort
   (lambda (l cmp?)
     (do-sort l cmp? 'sort)))
 
-  (define-teach intermediate foldr
+(define-teach intermediate foldr
   (lambda (f e l)
     (unless (and (procedure? f) (procedure-arity-includes? f 2))
       (qcheck 'foldr "first argument must be a <procedure> that accepts two arguments, given ~e" f))
@@ -277,7 +281,7 @@ namespace.
       (qcheck 'foldr "third argument must be of type <list>, given ~e" l))
     (foldr f e l)))
 
-  (define-teach intermediate foldl
+(define-teach intermediate foldl
   (lambda (f e l)
     (unless (and (procedure? f) (procedure-arity-includes? f 2))
       (qcheck 'foldl "first argument must be a <procedure> that accepts two arguments, given ~e" f))
@@ -285,7 +289,7 @@ namespace.
       (qcheck 'foldl "third argument must be of type <list>, given ~e" l))
     (foldl f e l)))
 
-  (define-teach intermediate build-string
+(define-teach intermediate build-string
   (lambda (n f)
     (unless (and (procedure? f) (procedure-arity-includes? f 1))
       (qcheck 'build-string "second argument must be a <procedure> that accepts one argument, given ~e" f))
@@ -300,22 +304,22 @@ namespace.
 
 
 
-  (define-teach advanced cons 
+(define-teach advanced cons 
   (lambda (a b)
     (check-second/cycle 'cons a b)
     (cons a b)))
 
-  (define-teach advanced list*
+(define-teach advanced list*
   (lambda x
     (check-last/cycle 'list* x)
     (apply list* x)))
 
-  (define-teach advanced append
+(define-teach advanced append
   (lambda x
     (check-last/cycle 'append x)
     (apply append x)))
 
-  (provide  
+(provide  
  false?
  beginner-not
  beginner-random
@@ -342,4 +346,147 @@ namespace.
  advanced-cons
  advanced-list*
  advanced-append
-    cyclic-list?))
+ cyclic-list?)
+
+;; -----------------------------------------------------------------------------
+;; auxiliary stuff, ignore
+
+(define 1-LET "1-letter string")
+(define 1-LETTER (format "<~a>" 1-LET))
+(define 1-LETTER* (format "<list of ~as>" 1-LET))
+(define NAT "<natural number>")
+
+;; Symbol Any -> Boolean 
+;; is this a 1-letter string?
+(define (1-letter? tag s)
+  (unless (string? s) (err tag "~a expected, not a string: ~e" 1-LETTER s))
+  (= (string-length s) 1))
+
+;; Symbol Any -> Boolean 
+;; is s a list of 1-letter strings
+;; effect: not a list, not a list of strings 
+(define (1-letter*? tag s)
+  (unless (list? s) (err tag "~a expected, not a <list>: ~e" 1-LETTER* s))
+  (for-each 
+   (lambda (c) 
+     (unless (string? c) (err tag "~a expected, not a <string>: ~e" 1-LETTER* c)))
+   s)
+  (andmap (compose (curry = 1) string-length) s))
+
+(define (err tag msg-format . args)
+  (raise 
+   (make-exn:fail:contract
+    (apply format (string-append (symbol->string tag) ": " msg-format) args)
+    (current-continuation-marks))))
+
+(define cerr 
+  (case-lambda
+    [(tag check-result format-msg actual)
+     (unless check-result
+       (err tag (string-append format-msg " expected, given ~e") actual))]
+    [(tag check-result format-msg actual snd)
+     (unless check-result
+       (err tag (string-append format-msg " for ~a argument expected, given ~e")
+            snd actual))]))
+
+;; -----------------------------------------------------------------------------
+
+(define-teach beginner string-ith
+  (lambda (s n)
+    (define f "<exact integer in [0, length of the given string (~s)]>")
+    (cerr 'string-ith (string? s) "<string>" s "first")
+    (cerr 'string-ith (and (number? n) (integer? n) (>= n 0)) NAT n "second")
+    (let ([l (string-length s)]) 
+      (cerr 'string-ith (< n l) (format f l) n "second"))
+    (string (string-ref s n))))
+
+;; -----------------------------------------------------------------------------
+
+(define-teach beginner replicate 
+  (lambda (n s1)
+    (cerr 'replicate (and (number? n) (exact-integer? n) (>= n 0)) NAT n)
+    (cerr 'replicate (string? s1) "<string>" s1)
+    (apply string-append (build-list n (lambda (i) s1)))))
+
+;; -----------------------------------------------------------------------------
+
+(define-teach beginner int->string 
+  (lambda (i) 
+    (cerr 'int->string 
+          (and (exact-integer? i) (or (<= 0 i 55295) (<= 57344 i 1114111)))
+          "<exact integer in [0,55295] or [57344 1114111]>"
+          i)
+    (string (integer->char i))))
+
+;; -----------------------------------------------------------------------------
+
+(define-teach beginner string->int 
+  (lambda (s) 
+    (cerr 'string->int (1-letter? 'string->int s) 1-LETTER s)
+    (char->integer (string-ref s 0))))
+
+;; -----------------------------------------------------------------------------
+
+(define-teach beginner explode 
+  (lambda (s)
+    (cerr 'explode (string? s) "<string>" s)
+    (map string (string->list s))))
+
+;; -----------------------------------------------------------------------------
+
+(define-teach beginner implode
+  (lambda (los)
+    (cerr 'implode (1-letter*? 'implode los) 1-LETTER* los)
+    (apply string-append los)))
+
+;; -----------------------------------------------------------------------------
+
+(define-teach beginner string-numeric? 
+  ;; is this: (number? (string->number s)) enough?
+  (lambda (s1)
+    (cerr 'string-numeric? (string? s1) "<string>" s1)
+    (andmap char-numeric? (string->list s1))))
+
+;; -----------------------------------------------------------------------------
+
+;; I used copying here and I feel awful. 
+
+(define-teach beginner string-alphabetic? 
+  (lambda (s1)
+    (cerr 'string-alphabetic? (string? s1) "<string>" s1)
+    (andmap char-alphabetic? (string->list s1))))
+
+;; -----------------------------------------------------------------------------
+
+(define-teach beginner string-whitespace? 
+  (lambda (s)
+    (cerr 'string-upper-case? (string? s)  "<string>" s)
+    (andmap char-whitespace? (string->list s))))
+
+;; -----------------------------------------------------------------------------
+;; I copied the next two, and I feel awful, too. 
+
+(define-teach beginner string-upper-case? 
+  (lambda (s)
+    (cerr 'string-upper-case? (string? s) "<string>" s)
+    (andmap char-upper-case? (string->list s))))
+
+;; -----------------------------------------------------------------------------
+
+(define-teach beginner string-lower-case? 
+  (lambda (s)
+    (cerr 'string-lower-case? (string? s) "<string>" s)
+    (andmap char-lower-case? (string->list s))))
+
+(provide
+ beginner-string-ith
+ beginner-replicate
+ beginner-int->string 
+ beginner-string->int
+ beginner-explode
+ beginner-implode
+ beginner-string-numeric?
+ beginner-string-alphabetic?
+ beginner-string-whitespace?
+ beginner-string-upper-case?
+ beginner-string-lower-case?)

collects/lang/private/todo.ss

@@ -10,35 +10,6 @@ string:        use string-append instead
 substring consumes 2 or 3 arguments 
 |#
 
-;; -----------------------------------------------------------------------------
-;; auxiliary stuff, ignore
-(require test-engine/scheme-tests)
-
-(define 1-letter "1-letter string")
-(define 1-letter* (format "~as" 1-letter))
-
-;; Symbol Any -> Boolean 
-;; is this a 1-letter string?
-(define (1-letter? tag s)
-  (unless (string? s)
-    (error tag "~a expected, not a string: ~e" 1-letter s))
-  (= (string-length s) 1))
-
-
-;; Symbol Any -> Boolean 
-;; is s a list of 1-letter strings
-;; effect: not a list, not a list of strings 
-(define (1-letter*? tag s)
-  (unless (list? s)
-    (error tag "list of ~a expected, not a list: ~e" 1-letter* s))
-  (for-each 
-   (lambda (c) 
-     (unless (string? c)
-       (error tag "list of ~a expected, not a string: ~e" 1-letter* c)))
-   s)
-  #;     (lambda (s) (= 1 (string-length s)))
-  (andmap (compose (curry = 1) string-length) s))
-
 (define-syntax (define-teach stx)
   (syntax-case stx ()
     [(_ level id expr)
@@ -54,175 +25,223 @@ substring consumes 2 or 3 arguments
                    id))))]))
 
 ;; -----------------------------------------------------------------------------
+;; auxiliary stuff, ignore
+
+(define 1-LET "1-letter string")
+(define 1-LETTER (format "<~a>" 1-LET))
+(define 1-LETTER* (format "<list of ~as>" 1-LET))
+(define NAT "<natural number>")
+
+;; Symbol Any -> Boolean 
+;; is this a 1-letter string?
+(define (1-letter? tag s)
+  (unless (string? s) (err tag "~a expected, not a string: ~e" 1-LETTER s))
+  (= (string-length s) 1))
+
+;; Symbol Any -> Boolean 
+;; is s a list of 1-letter strings
+;; effect: not a list, not a list of strings 
+(define (1-letter*? tag s)
+  (unless (list? s) (err tag "~a expected, not a <list>: ~e" 1-LETTER* s))
+  (for-each 
+   (lambda (c) 
+     (unless (string? c) (err tag "~a expected, not a <string>: ~e" 1-LETTER* c)))
+   s)
+  (andmap (compose (curry = 1) string-length) s))
+
+(define (err tag msg-format . args)
+  (raise 
+   (make-exn:fail:contract
+    (apply format (string-append (symbol->string tag) ": " msg-format) args)
+    (current-continuation-marks))))
+
+(define cerr 
+  (case-lambda
+    [(tag check-result format-msg actual)
+     (unless check-result
+       (err tag (string-append format-msg " expected, given ~e") actual))]
+    [(tag check-result format-msg actual snd)
+     (unless check-result
+       (err tag (string-append format-msg " for ~a argument expected, given ~e")
+            snd actual))]))
+
+;; -----------------------------------------------------------------------------
+
+(define-teach beginner string-ith
+  (lambda (s n)
+    (define f "<exact integer in [0, length of the given string (~s)]>")
+    (cerr 'string-ith (string? s) "<string>" s "first")
+    (cerr 'string-ith (and (number? n) (integer? n) (>= n 0)) NAT n "second")
+    (let ([l (string-length s)]) 
+      (cerr 'string-ith (< n l) (format f l) n "second"))
+    (string (string-ref s n))))
+
+;; -----------------------------------------------------------------------------
+
+(define-teach beginner replicate 
+  (lambda (n s1)
+    (cerr 'replicate (and (number? n) (exact-integer? n) (>= n 0)) NAT n)
+    (cerr 'replicate (string? s1) "<string>" s1)
+  (apply string-append (build-list n (lambda (i) s1)))))
+
+;; -----------------------------------------------------------------------------
+
+(define-teach beginner int->string 
+  (lambda (i) 
+    (cerr 'int->string 
+          (and (exact-integer? i) (or (<= 0 i 55295) (<= 57344 i 1114111)))
+          "<exact integer in [0,55295] or [57344 1114111]>"
+          i)
+    (string (integer->char i))))
+
+;; -----------------------------------------------------------------------------
+
+(define-teach beginner string->int 
+  (lambda (s) 
+    (cerr 'string->int (1-letter? 'string->int s) 1-LETTER s)
+    (char->integer (string-ref s 0))))
+
+;; -----------------------------------------------------------------------------
+
+(define-teach beginner explode 
+  (lambda (s)
+    (cerr 'explode (string? s) "<string>" s)
+    (map string (string->list s))))
+
+;; -----------------------------------------------------------------------------
+
+(define-teach beginner implode
+  (lambda (los)
+    (cerr 'implode (1-letter*? 'implode los) 1-LETTER* los)
+    (apply string-append los)))
+
+;; -----------------------------------------------------------------------------
+
+(define-teach beginner string-numeric? 
+  ;; is this: (number? (string->number s)) enough?
+  (lambda (s1)
+    (cerr 'string-numeric? (string? s1) "<string>" s1)
+    (andmap char-numeric? (string->list s1))))
+
+;; -----------------------------------------------------------------------------
+
+;; I used copying here and I feel awful. 
+
+(define-teach beginner string-alphabetic? 
+  (lambda (s1)
+    (cerr 'string-alphabetic? (string? s1) "<string>" s1)
+    (andmap char-alphabetic? (string->list s1))))
+
+;; -----------------------------------------------------------------------------
+
+(define-teach beginner string-whitespace? 
+  (lambda (s)
+    (cerr 'string-upper-case? (string? s)  "<string>" s)
+    (andmap char-whitespace? (string->list s))))
+
+;; -----------------------------------------------------------------------------
+;; I copied the next two, and I feel awful, too. 
+
+(define-teach beginner string-upper-case? 
+  (lambda (s)
+    (cerr 'string-upper-case? (string? s) "<string>" s)
+    (andmap char-upper-case? (string->list s))))
+
+;; -----------------------------------------------------------------------------
+
+(define-teach beginner string-lower-case? 
+  (lambda (s)
+    (cerr 'string-lower-case? (string? s) "<string>" s)
+    (andmap char-lower-case? (string->list s))))
+
+;; -----------------------------------------------------------------------------
+;; -----------------------------------------------------------------------------
+;; -----------------------------------------------------------------------------
+
+(require test-engine/scheme-tests)
 
 (check-expect (beginner-string-ith "hell" 0) "h")
 (check-error
  (beginner-string-ith "hell" 4) 
  (string-append 
   "string-ith:"
-  " second argument must be between 0 and the length of the given string (4), given "
+  " <exact integer in [0, length of the given string (4)]>"
+  " for second argument expected, given "
   "4"))
 
-(define-teach beginner string-ith
+(check-error
-  (lambda (s n)
+ (beginner-string-ith 10 4) 
-    (unless (string? s)
+ (string-append "string-ith: <string> for first argument expected, given "
-      (error 'string-ith "first argument must be of type <string>, given ~e" s))
+                "10"))
-    (unless (and (number? n) (integer? n) (>= n 0))
+
-      (error 'string-ith
+(check-error
-             "second argument must be of type <natural number>, given ~e" 
+ (beginner-string-ith "10" 'a)
-             n))
+ (string-append "string-ith: <natural number> for second argument expected, given "
-    (unless (< n (string-length s))
+                "a"))
-      (error 'string-ith 
-             "second argument must be between 0 and the length of the given string (~s), given ~a"
-             (string-length s) n))
-    (string (string-ref s n))))
 
-;; -----------------------------------------------------------------------------
 
 (check-expect (beginner-replicate 3 "a") "aaa")
 (check-expect (beginner-replicate 3 "ab") "ababab")
-(check-error (beginner-replicate 3 10) "replicate: string expected, given 10")
+(check-error (beginner-replicate 3 10) "replicate: <string> expected, given 10")
-
-(define-teach beginner replicate 
-  (lambda (n s1)
-    (unless (and (number? n) (exact-integer? n) (>= n 0))
-      (error 'replicate "(exact) natural number expected, given ~e" n))
-    (unless (string? s1)
-      (error 'replicate "string expected, given ~e" s1))
-    (apply string-append (build-list n (lambda (i) s1)))))
-
-;; -----------------------------------------------------------------------------
 
 (check-expect (beginner-int->string 10) "\n")
 (check-error 
  (beginner-int->string 56555) 
  (string-append 
-  "int->string: exact integer in [0,55295] or [57344 1114111] expected, given "
+  "int->string: <exact integer in [0,55295] or [57344 1114111]> expected, given "
   "56555"))
 (check-error 
  (beginner-int->string "A") 
  (string-append 
-  "int->string: exact integer in [0,55295] or [57344 1114111] expected, given "
+  "int->string: <exact integer in [0,55295] or [57344 1114111]> expected, given "
-  "A"))
+  (format "~s" "A")))
-
-(define-teach beginner int->string 
-  (lambda (i) 
-    (unless (and (exact-integer? i) (or (<= 0 i 55295) (<= 57344 i 1114111)))
-      (error 'int->string 
-             "exact integer in [0,55295] or [57344 1114111] expected, given ~a"
-             i))
-    (string (integer->char i))))
-
-;; -----------------------------------------------------------------------------
 
 (check-expect (beginner-string->int "A") 65)
 (check-error 
  (beginner-string->int 10) 
- (string-append "string->int: " 1-letter " expected, not a string: 10"))
+ (string-append "string->int: " 1-LETTER " expected, not a string: 10"))
 (check-error 
  (beginner-string->int "AB") 
- (string-append "string->int: " 1-letter " expected, given " (format "~s" "AB")))
+ (string-append
-
+   "string->int: " 1-LETTER " expected, given " (format "~s" "AB")))
-(define-teach beginner string->int 
-  (lambda (s) 
-    (unless (1-letter? 'string->int s)
-      (error 'string->int "~a expected, given ~e" 1-letter s))
-    (char->integer (string-ref s 0))))
-
-;; -----------------------------------------------------------------------------
 
 (check-expect (beginner-explode "hello") (list "h" "e" "l" "l" "o"))
 (check-error (beginner-explode 10) 
-             (string-append "explode: string expected, given " "10"))
+             (string-append "explode: <string> expected, given " "10"))
-
-(define-teach beginner explode 
-  (lambda (s)
-    (unless (string? s)
-      (error 'explode "string expected, given ~e" s))
-    (map string (string->list s))))
-
-;; -----------------------------------------------------------------------------
 
 (check-expect (beginner-implode (list "h" "e" "l" "l" "o")) "hello")
 (check-error (beginner-implode 10)
-             (string-append "implode: list of " 1-letter* 
+             (string-append "implode: " 1-LETTER* 
-                            " expected, not a list: 10"))
+                            " expected, not a <list>: 10"))
 (check-error (beginner-implode '("he" "l"))
-             (string-append "implode: list of " 1-letter* " expected, given " 
+             (string-append "implode: " 1-LETTER* " expected, given " 
                             (format "~s" '("he" "l"))))
 
-(define-teach beginner implode
-  (lambda (los)
-    (unless (1-letter*? 'implode los)
-      (error 'implode "list of ~a expected, given ~e" 1-letter* los))
-    (apply string-append los)))
-
-;; -----------------------------------------------------------------------------
-
 (check-expect (beginner-string-numeric? "0") true)
 (check-expect (beginner-string-numeric? "10") true)
 (check-expect (beginner-string-numeric? "a") false)
 (check-expect (beginner-string-numeric? "ab") false)
 (check-error (beginner-string-numeric? 10)
-             (string-append "string-numeric?: string expected, given 10"))
+             (string-append "string-numeric?: <string> expected, given 10"))
 
-(define-teach beginner string-numeric? 
-  ;; is this: (number? (string->number s)) enough?
-  (lambda (s1)
-    (unless (string? s1)
-      (error 'string-numeric? "string expected, given ~e" s1))   
-    (andmap char-numeric? (string->list s1))))
 
-;; -----------------------------------------------------------------------------
-
-;; I used copying here and I feel awful. 
 (check-expect (beginner-string-alphabetic? "a0") false)
 (check-expect (beginner-string-alphabetic? "a") true)
 (check-expect (beginner-string-alphabetic? "ba") true)
 (check-expect (beginner-string-alphabetic? "ab") true)
 
-(define-teach beginner string-alphabetic? 
-  (lambda (s1)
-    (unless (string? s1)
-      (error 'string-alphabetic? "string expected, given ~e" s1))
-    (andmap char-alphabetic? (string->list s1))))
-
-;; -----------------------------------------------------------------------------
-
 (check-expect (beginner-string-whitespace? "  ") true)
 (check-expect (beginner-string-whitespace? "  \t") true)
 (check-expect (beginner-string-whitespace? "ABC") false)
 
-(define-teach beginner string-whitespace? 
-  (lambda (s)
-    (unless (string? s)
-      (error 'string-upper-case? "string expected, given ~e" s))
-    (andmap char-whitespace? (string->list s))))
-
-;; -----------------------------------------------------------------------------
-;; I copied the next two, and I feel awful, too. 
 (check-expect (beginner-string-upper-case? "  ") false)
 (check-expect (beginner-string-upper-case? "AB\t") false)
 (check-expect (beginner-string-upper-case? "ABC") true)
 
-(define-teach beginner string-upper-case? 
-  (lambda (s)
-    (unless (string? s)
-      (error 'string-upper-case? "string expected, given ~e" s))
-    (andmap char-upper-case? (string->list s))))
-
-;; -----------------------------------------------------------------------------
-
 (check-expect (beginner-string-lower-case? "  ") false)
 (check-expect (beginner-string-lower-case? "ab\t") false)
 (check-expect (beginner-string-lower-case? "abc") true)
 
-(define-teach beginner string-lower-case? 
-  (lambda (s)
-    (unless (string? s)
-      (error 'string-lower-case? "string expected, given ~e" s))
-    (andmap char-lower-case? (string->list s))))
 
-;; -----------------------------------------------------------------------------
 
 (test)

collects/mred/private/wxme/pasteboard.ss

@@ -166,8 +166,8 @@
 
   (define/private (rubber-band x y w h)
     (when (and s-admin
-               (positive? w)
+               (not (zero? w))
-               (positive? h))
+               (not (zero? h)))
       (let-values ([(x w)
                     (if (w . < . 0)
                         (values (+ x w) (- w))

collects/mrlib/switchable-button.ss

@@ -56,6 +56,10 @@
                 [alternate-bitmap bitmap]
                 [vertical-tight? #f])
     
+    (when (and (is-a? label bitmap%)
+               (not (send label ok?)))
+      (error 'switchable-button% "label bitmap is not ok?"))
+    
     (define/override (get-label) label)
     
     (define disable-bitmap (make-dull-mask bitmap))

collects/planet/planet.scrbl

@@ -38,7 +38,7 @@ how to use PLaneT by example.
 
 @subsection[#:tag "finding-a-package"]{Finding a Package}
 
-If you are new to PLaneT, the first thing to to is visit
+If you are new to PLaneT, the first thing to do is visit
 @link["http://planet.plt-scheme.org/"]{the PLaneT repository web site}
 and see what packages are available. People contribute new PLaneT
 packages all the time --- if you want to be notified whenever a new or

collects/profile/analyzer.ss

@@ -4,64 +4,10 @@
 
 (provide analyze-samples)
 
-(require scheme/list)
+(require "structs.ss" "utils.ss" scheme/list)
 
-;; An encapsulation of an analyzed profile call graph:
-;; - total-time: the total time observed in msec (this is generally different
-;;   than the time it took to run the profile).
-;; - sample-number: the number of samples taken.
-;; - thread-times: a list of (<thread-id> . msec) for the time spent in
-;;   observed threads.
-;; - nodes: the list of call-graph nodes sorted by their total time.
-;; - *-node: a special node that is connected as a "caller" for all toplevel
-;;   functions and a "callee" for all leaf functions.  It will also be
-;;   identifiable by having both id and src fields being #f.  Can be used to
-;;   start a graph traversal from the top or the bottom.
-(provide (struct-out profile))
-(define-struct profile
-  (total-time cpu-time sample-number thread-times nodes *-node))
-
-;; An entry for a single profiled function:
-;; - id, src: the corresponding values from `continuation-mark-set->context'.
-;; - thread-ids: the list of thread identifiers this function has been seen in.
-;; - total: total msecs it participated in (= time in it, including callees).
-;; - self: msecs where it was at the top of the stack (= time in its own code).
-;; - callers, callees: a list of `edge' values for the time spent while it was
-;;   called by the repective <node>, or it called it, sorted in decreasing msec
-;;   time.
-;; Note that the sum of caller/callee edges including the special `*-node'
-;; should be equal to the `total' time.  So the edge from/to the `*-node' can
-;; be used to get the time spent as a leaf or as a root divided by the number
-;; of time the function appeared on the stack: so this value can be displayed
-;; in the call-graph and the numbers will sum up nicely to a 100%.
-(provide (struct-out node))
-(define-struct node (id src thread-ids total self callers callees)
-  #:mutable
-  #:property prop:custom-write
-  (lambda (node o w?) (fprintf o "#<node:~s>" (or (node-id node) '???))))
-
-;; An edge representing function calls between two nodes:
-;; - time: the total time spent while the call was somewhere on the stack.
-;; - caller, callee: the two relevant `node' values.
-;; - caller-time, callee-time: the time that the caller/callee spent in this
-;;   call (different from the above time because each stack sample's time is
-;;   divided by the number of times the caller/callee appears in that slice).
-(provide (struct-out edge))
-(define-struct edge (total caller caller-time callee callee-time)
-  #:mutable
-  #:property prop:custom-write
-  (lambda (edge o w?)
-    (fprintf o "#<edge:~s-~s>"
-             (or (node-id (edge-caller edge)) '???)
-             (or (node-id (edge-callee edge)) '???))))
-
-(define with-hash:not-found (gensym))
 (define-syntax-rule (with-hash <hash> <key> <expr>)
-  (let ([t <hash>] [k <key>])
+  (hash-ref! <hash> <key> (lambda () <expr>)))
-    (let ([v (hash-ref t k with-hash:not-found)])
-      (if (eq? v with-hash:not-found)
-        (let ([v <expr>]) (hash-set! t k v) v)
-        v))))
 
 ;; This function analyzes the output of the sampler.  Returns a `profile'
 ;; struct holding a list of `node' values, each one representing a node in the
@@ -132,10 +78,8 @@
   (set-node-total! *-node total-time)
   ;; convert the nodes from the hash to a list, do a topological sort, and then
   ;; sort by total time (combining both guarantees(?) sensible order)
-  (let ([nodes (remq *-node (topological-sort
+  (let ([nodes (append-map (lambda (nodes) (sort nodes > #:key node-total))
-                             *-node
+                           (topological-sort *-node))])
-                             (lambda (nodes)
-                               (sort nodes > #:key node-total))))])
     ;; sort all the edges in the nodes according to total time
     (for ([n (in-list nodes)])
       (set-node-callees! n (sort (node-callees n) > #:key edge-callee-time))
@@ -149,32 +93,6 @@
      nodes
      *-node)))
 
-;; A simple topological sort of nodes using BFS, starting from node `x' which
-;; will be the special *-node.  `subsort' is a `resolver' function to sort
-;; nodes on the same level.
-(define (topological-sort x subsort)
-  (let loop ([todo (list x)] [seen (list x)])
-    (if (null? todo)
-      '()
-      (let* ([next (append-map (lambda (x)
-                                 (subsort (map edge-callee (node-callees x))))
-                               todo)]
-             [next (remq* seen (remove-duplicates next))])
-        (append todo (loop next (append next seen)))))))
-#|
-(define (node id) (make-node id #f '() 0 0 '() '()))
-(define (X . -> . Y)
-  (let ([e (make-edge 0 X 0 Y 0)])
-    (set-node-callers! Y (cons e (node-callers Y)))
-    (set-node-callees! X (cons e (node-callees X)))))
-(define A (node 'A))
-(define B (node 'B))
-(define C (node 'C))
-(A . -> . B)
-(B . -> . C)
-(topological-sort A 3)
-|#
-
 ;; Groups raw samples by their thread-id, returns a vector with a field for
 ;; each thread id holding the sample data for that thread.  The samples in
 ;; these are reversed (so they'll be sorted going forward in time).

collects/profile/main.ss

@@ -2,7 +2,7 @@
 
 (provide profile-thunk profile)
 
-(require "sampler.ss" (except-in "analyzer.ss" profile)
+(require "sampler.ss" "analyzer.ss"
          (prefix-in text: "render-text.ss")
          (for-syntax scheme/base))
 

collects/profile/render-graphviz.ss

@@ -2,7 +2,7 @@
 
 (provide render)
 
-(require "analyzer.ss" "utils.ss")
+(require "structs.ss" "analyzer.ss" "utils.ss")
 
 (define (render profile
                 #:hide-self [hide-self% 1/100]

collects/profile/render-text.ss

@@ -2,7 +2,7 @@
 
 (provide render)
 
-(require "analyzer.ss" "utils.ss" scheme/list)
+(require "structs.ss" "analyzer.ss" "utils.ss" scheme/list)
 
 (define (f:msec msec)
   (number->string (round (inexact->exact msec))))

collects/profile/structs.ss

@@ -0,0 +1,54 @@
+#lang scheme/base
+
+;; Struct definitions for the profiler
+
+;; An encapsulation of an analyzed profile call graph:
+;; - total-time: the total time observed in msec (this is generally different
+;;   than the time it took to run the profile).
+;; - sample-number: the number of samples taken.
+;; - thread-times: a list of (<thread-id> . msec) for the time spent in
+;;   observed threads.
+;; - nodes: the list of call-graph nodes sorted by their total time.
+;; - *-node: a special node that is connected as a "caller" for all toplevel
+;;   functions and a "callee" for all leaf functions.  It will also be
+;;   identifiable by having both id and src fields being #f.  Can be used to
+;;   start a graph traversal from the top or the bottom.
+(provide (struct-out profile))
+(define-struct profile
+  (total-time cpu-time sample-number thread-times nodes *-node))
+
+;; An entry for a single profiled function:
+;; - id, src: the corresponding values from `continuation-mark-set->context'.
+;; - thread-ids: the list of thread identifiers this function has been seen in.
+;; - total: total msecs it participated in (= time in it, including callees).
+;; - self: msecs where it was at the top of the stack (= time in its own code).
+;; - callers, callees: a list of `edge' values for the time spent while it was
+;;   called by the repective <node>, or it called it, sorted in decreasing msec
+;;   time.
+;; Note that the sum of caller/callee edges including the special `*-node'
+;; should be equal to the `total' time.  So the edge from/to the `*-node' can
+;; be used to get the time spent as a leaf or as a root divided by the number
+;; of time the function appeared on the stack: so this value can be displayed
+;; in the call-graph and the numbers will sum up nicely to a 100%.
+(provide (struct-out node))
+(define-struct node (id src thread-ids total self callers callees)
+  #:mutable
+  #:property prop:custom-write
+  (lambda (node o w?)
+    (fprintf o "#<node:~s>"
+             (or (node-id node) (if (node-src node) '??? 'ROOT)))))
+
+;; An edge representing function calls between two nodes:
+;; - total: the total time spent while the call was anywhere on the stack.
+;; - caller, callee: the two relevant `node' values.
+;; - caller-time, callee-time: the time that the caller/callee spent in this
+;;   call (different from the above time because each stack sample's time is
+;;   divided by the number of times the caller/callee appears in that slice).
+(provide (struct-out edge))
+(define-struct edge (total caller caller-time callee callee-time)
+  #:mutable
+  #:property prop:custom-write
+  (lambda (edge o w?)
+    (fprintf o "#<edge:~s-~s>"
+             (or (node-id (edge-caller edge)) '???)
+             (or (node-id (edge-callee edge)) '???))))

collects/profile/utils.ss

@@ -1,13 +1,13 @@
 #lang scheme/base
 
-(provide format-percent format-source get-hidden)
+(require "structs.ss" scheme/list)
-(require "analyzer.ss")
 
 ;; Format a percent number, possibly doing the division too.  If we do the
 ;; division, then be careful: if we're dividing by zero, then make the result
 ;; zero.  This is useful if the total time is zero because we didn't see any
 ;; activity (for example, the profiled code is just doing a `sleep'), in which
 ;; case all times will be 0.
+(provide format-percent)
 (define format-percent
   (case-lambda
     [(percent)
@@ -15,6 +15,7 @@
        (format "~a.~a%" (quotient percent 10) (modulo percent 10)))]
     [(x y) (format-percent (if (zero? y) 0 (/ x y)))]))
 
+(provide format-source)
 (define (format-source src)
   (if src
     (format "~a:~a"
@@ -27,6 +28,7 @@
 ;; Hide a node if its self time is smaller than the self threshold *and* all of
 ;; its edges are below the sub-node threshold too -- this avoids confusing
 ;; output where a node does not have an entry but appears as a caller/callee.
+(provide get-hidden)
 (define (get-hidden profile hide-self% hide-subs%)
   (define self% (or hide-self% 0))
   (define subs% (or hide-subs% 0))
@@ -45,3 +47,28 @@
   (cond [(and (<= self% 0) (<= subs% 0)) '()]
         [(zero? total-time) (profile-nodes profile)]
         [else (filter hide? (profile-nodes profile))]))
+
+;; A simple topological sort of nodes using the Khan method, starting from node
+;; `x' (which will be given as the special *-node).  The result is a list of
+;; node lists, each one corresponds to one level.  Conceptually, the input node
+;; is always only item in the first level, so it is not included in the result.
+(provide topological-sort)
+(define (topological-sort x)
+  (let loop ([todo (list x)] [sorted '()] [seen (list x)])
+    (let* (;; take the next level of nodes
+           [next (append-map (lambda (x) (map edge-callee (node-callees x)))
+                             todo)]
+           ;; remove visited and duplicates
+           [next (remove-duplicates (remq* seen next))]
+           ;; leave only nodes with no other incoming edges
+           [seen* (append next seen)] ; important for cycles
+           [next* (filter (lambda (node)
+                            (andmap (lambda (e) (memq (edge-caller e) seen*))
+                                    (node-callers node)))
+                          next)]
+           ;; but if all nodes have other incoming edges, then there must be a
+           ;; cycle, so just do them now (instead of dropping them)
+           [next (if (null? next*) next next*)])
+      (if (null? next)
+        (reverse sorted)
+        (loop next (cons next sorted) (append next seen))))))

collects/scheme/package.ss

@@ -266,10 +266,13 @@
                                          (let* ([exports-renamed (bound-identifier-mapping-map tmp (lambda (k v) k))]
                                                 [exports (map (lambda (id) (pre-package-id id def-ctxes))
                                                               exports-renamed)])
-                                           (values exports exports-renamed)))))])
+                                           (values exports exports-renamed)))))]
-                     (with-syntax ([(export ...) exports]
+                                [(prune)
-                                   [(renamed ...) exports-renamed]
+                                 (lambda (stx)
-                                   [(hidden ...) (complement new-bindings exports-renamed)])
+                                   (identifier-prune-lexical-context stx (list (syntax-e stx) '#%top)))])
+                     (with-syntax ([(export ...) (map prune exports)]
+                                   [(renamed ...) (map prune exports-renamed)]
+                                   [(hidden ...) (map prune (complement new-bindings exports-renamed))])
                        (let ([body (map (fixup-sub-package exports-renamed defined-renamed def-ctxes) 
                                         (reverse rev-forms))])
                          (if (eq? mode '#:begin)

collects/scheme/private/define-struct.ss

@@ -369,7 +369,9 @@
                                                stx
                                                super-id))
                                           (and super-expr
-                                               #`(check-struct-type 'fm #,super-expr)))])
+                                               #`(check-struct-type 'fm #,super-expr)))]
+                       [prune (lambda (stx) (identifier-prune-lexical-context stx
+                                                                              (list (syntax-e stx) '#%top)))])
                    (let ([run-time-defns
                           (lambda ()
                             (quasisyntax/loc stx
@@ -424,7 +426,7 @@
                             (let ([protect (lambda (sel)
                                              (and sel
                                                   (if (syntax-e sel)
-                                                      #`(quote-syntax #,sel)
+                                                      #`(quote-syntax #,(prune sel))
                                                       sel)))]
 				  [mk-info (if super-info-checked?
 					       #'make-checked-struct-info
@@ -434,9 +436,9 @@
                                   (#,mk-info
                                    (lambda ()
                                      (list
-                                      (quote-syntax #,struct:)
+                                      (quote-syntax #,(prune struct:))
-                                      (quote-syntax #,make-)
+                                      (quote-syntax #,(prune make-))
-                                      (quote-syntax #,?)
+                                      (quote-syntax #,(prune ?))
                                       (list
                                        #,@(map protect (reverse sels))
                                        #,@(if super-info

collects/scheme/private/stxloc.ss

@@ -43,4 +43,24 @@
 	     (syntax (syntax pattern))
 	     (syntax (relocate loc (syntax pattern))))])))
 
-  (#%provide syntax/loc syntax-case* syntax-case ... _))
+  (-define-syntax quote-syntax/prune
+    (lambda (stx)
+      (syntax-case** #f #t stx () free-identifier=?
+        [(_ id) 
+         (if (symbol? (syntax-e #'id))
+             (datum->syntax #'here
+                            (list (quote-syntax quote-syntax)
+                                  (identifier-prune-lexical-context (syntax id)
+                                                                    (list
+                                                                     (syntax-e (syntax id))
+                                                                     '#%top)))
+                            stx
+                            #f
+                            stx)
+             (raise-syntax-error
+              #f
+              "expected an identifier"
+              stx
+              #'id))])))
+
+  (#%provide syntax/loc quote-syntax/prune syntax-case* syntax-case ... _))

collects/scribblings/gui/bitmap-class.scrbl

@@ -125,7 +125,7 @@ Returns @scheme[#f] if the bitmap is monochrome, @scheme[#t] otherwise.
 
 }
 
-@defmethod[(load-file [name pat-string?]
+@defmethod[(load-file [name path-string?]
                       [kind (one-of/c 'unknown 'unknown/mask 
                                       'gif 'gif/mask 'jpeg 'png 'png/mask 
                                       'xbm 'xpm 'bmp 'pict)
@@ -188,7 +188,7 @@ Returns @scheme[#t] if the bitmap is usable (created or changed
 
 }
 
-@defmethod[(save-file [name pat-string?]
+@defmethod[(save-file [name path-string?]
                       [kind (one-of/c 'png 'jpeg 'xbm 'xpm 'bmp)]
                       [quality (integer-in 0 100) 75])
            boolean?]{

collects/scribblings/reference/class.scrbl

@@ -1117,8 +1117,8 @@ Returns an accessor procedure that takes an instance of the class
 produced by @scheme[class-expr] and returns the value of the object's
 field with (external) name @scheme[field-id].
 
-If @scheme[obj-expr] does not produce an object, the
+If @scheme[class-expr] does not produce a class, the
-@exnraise[exn:fail:contract]. If the object has no @scheme[field-id]
+@exnraise[exn:fail:contract]. If the class has no @scheme[field-id]
 field, the @exnraise[exn:fail:object].}
 
 @defform[(class-field-mutator class-expr field-id)]{
@@ -1128,8 +1128,8 @@ produced by @scheme[class-expr] and a value, and sets the value of the
 object's field with (external) name @scheme[field-id] to the given
 value. The result is @|void-const|.
 
-If @scheme[obj-expr] does not produce an object, the
+If @scheme[class-expr] does not produce a class, the
-@exnraise[exn:fail:contract]. If the object has no @scheme[field-id]
+@exnraise[exn:fail:contract]. If the class has no @scheme[field-id]
 field, the @exnraise[exn:fail:object].}
 
 @; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

collects/scribblings/reference/stx-ops.scrbl

@@ -224,3 +224,18 @@ in the corresponding generated name, which is useful for debugging
 purposes. The generated identifiers are built with interned symbols
 (not @scheme[gensym]s), so the limitations described with
 @scheme[current-compile] do not apply.}
+
+
+@defproc[(identifier-prune-lexical-context [id-stx identifier?]
+                                           [syms (listof symbol?) (list (syntax-e id-stx))])
+         identifier?]{
+
+Returns an identifier with the same binding as @scheme[id-stx], but
+without lexical information from @scheme[id-stx] that does not apply
+to the symbols in @scheme[syms], where even further extension of the
+lexical information drops information for other symbols. In
+particular, transferring the lexical context via
+@scheme[datum->syntax] from the result of this function to a symbol
+other than one in @scheme[syms] produces a identifier with no binding.
+
+See also @scheme[quote-syntax/prune].}

collects/scribblings/reference/stx-patterns.scrbl

@@ -358,6 +358,16 @@ Like @scheme[quasisyntax], but with source-location assignment like
 @scheme[syntax/loc].}
 
 
+@defform[(quote-syntax/prune id)]{
+
+Like @scheme[quote-syntax], but the lexical context of @scheme[id] is
+pruned via @scheme[identifier-prune-lexical-context] to including
+binding only for the symbolic name of @scheme[id] and for
+@scheme['#%top]. Use this form to quote an identifier when its lexical
+information will not be transferred to other syntax objects (except
+maybe to @scheme['#%top] for a top-level binding).}
+
+
 @defform[(syntax-rules (literal-id ...)
            [(id . pattern) template] ...)]{
 

collects/scribblings/reference/threads.scrbl

@@ -199,7 +199,9 @@ Returns a @tech{synchronizable event} (see @secref["sync"]) that is
 ready if and only if @scheme[thd] has terminated.  Unlike using
 @scheme[thd] directly, however, a reference to the event does not
 prevent @scheme[thd] from being garbage collected (see
-@secref["gc-model"]).}
+@secref["gc-model"]). For a given @scheme[thd],
+@scheme[thread-dead-evt] always returns the same (i.e., @scheme[eq?])
+result.}
 
 @defproc[(thread-resume-evt [thd thread?]) evt?]{
 

collects/slideshow/pict.ss

@@ -89,7 +89,7 @@
                              #:under? [under? #f]
                              #:solid? [solid? #t]
                              #:hide-arrowhead? [hide-arrowhead? #f])
-      (if (not sa ea)
+      (if (not (or sa ea))
           (finish-pin (launder (t:pin-arrows-line sz (ghost p)
                                                   src src-find 
                                                   dest dest-find

collects/string-constants/english-string-constants.ss

@@ -426,7 +426,7 @@ please adhere to these guidelines:
  (show-status-line "Show status-line")
  (count-columns-from-one "Count column numbers from one")
  (display-line-numbers "Display line numbers in buffer; not character offsets")
- (show-line-and-column-numbers "Show line & column numbers") ; used for popup menu; right click on line/column box in bottom of drs window
+ (show-line-and-column-numbers "Show line && column numbers") ; used for popup menu; right click on line/column box in bottom of drs window
  (show-character-offsets "Show character offsets") ; used for popup menu; right click on line/column box in bottom of drs window
  (enable-keybindings-in-menus "Enable keybindings in menus")
  (automatically-to-ps "Automatically print to PostScript file")

collects/tests/mzscheme/beg-adv.ss

@@ -133,14 +133,6 @@
 (htdp-test #t 'eq? (eq? #t true))
 (htdp-test #t 'eq? (eq? #f false))
 
-(htdp-err/rt-test (+) exn:application:arity?)
-(htdp-err/rt-test (+ 1) exn:application:arity?)
-(htdp-err/rt-test (*) exn:application:arity?)
-(htdp-err/rt-test (* 1) exn:application:arity?)
-(htdp-err/rt-test (-) exn:application:arity?)
-(htdp-err/rt-test (/) exn:application:arity?)
-(htdp-err/rt-test (/ 1) exn:application:arity?)
-
 (htdp-test -9 '- (- 9))
 
 (htdp-top (define-struct an-example-structure (first-field second-field)))
@@ -294,3 +286,104 @@
 (htdp-top (check-within 1 2 3))
 (htdp-test 2 'two 2)
 (htdp-top-pop 1)
+
+;; -----------------------------------------------------------------------------
+;; mf's tests for string functions replacing chars 
+
+(htdp-test "h" 'string-ith (string-ith "hell" 0))
+
+(htdp-err/rt-test (string-ith "hell" 4) exn:fail:contract?
+  #;
+  (string-append 
+    "string-ith:"
+    " <exact integer in [0, length of the given string (4)]>"
+    " for second argument expected, given "
+    "4"))
+
+(htdp-err/rt-test (string-ith 10 4) exn:fail:contract?
+  #;
+  (string-append "string-ith: <string> for first argument expected, given "
+    "10"))
+
+(htdp-err/rt-test (string-ith "10" 'a) exn:fail:contract?
+  #;
+  (string-append "string-ith: <natural number> for second argument expected, given "
+    "a"))
+
+(htdp-test "aaa" 'replicate (replicate 3 "a"))
+
+(htdp-test "ababab" 'replicate (replicate 3 "ab"))
+
+(htdp-err/rt-test (replicate 3 10) exn:fail:contract?
+  #;
+  "replicate: <string> expected, given 10")
+
+(htdp-test "\n" 'int->string (int->string 10))
+
+(htdp-err/rt-test (int->string 56555) exn:fail:contract?
+  #;
+  (string-append 
+    "int->string: <exact integer in [0,55295] or [57344 1114111]> expected, given "
+    "56555"))
+
+(htdp-err/rt-test (int->string "A") exn:fail:contract?
+  #;
+  (string-append 
+    "int->string: <exact integer in [0,55295] or [57344 1114111]> expected, given "
+    (format "~s" "A")))
+
+(htdp-test 65 'string->int (string->int "A"))
+
+(htdp-err/rt-test (string->int 10) exn:fail:contract?
+  #;
+  (string-append "string->int: " 1-LETTER " expected, not a string: 10"))
+
+(htdp-err/rt-test (string->int "AB") exn:fail:contract?
+  #;
+  (string-append
+    "string->int: " 1-LETTER " expected, given " (format "~s" "AB")))
+
+(htdp-test (list "h" "e" "l" "l" "o") 'explode (explode "hello"))
+
+(htdp-err/rt-test (explode 10) exn:fail:contract?
+  #;
+  (string-append "explode: <string> expected, given " "10"))
+
+(htdp-test "hello" 'implode (implode (list "h" "e" "l" "l" "o")))
+
+(htdp-err/rt-test (implode 10) exn:fail:contract?
+  #;
+  (string-append "implode: " 1-LETTER* " expected, not a <list>: 10"))
+
+(htdp-err/rt-test (implode (list "he" "l")) exn:fail:contract?
+  #;
+  (string-append "implode: " 1-LETTER* " expected, given " 
+    (format "~s" (list "he" "l"))))
+
+(htdp-test true 'string-numeric? (string-numeric? "0"))
+(htdp-test true 'string-numeric? (string-numeric? "10"))
+(htdp-test false 'string-numeric? (string-numeric? "a"))
+(htdp-test false 'string-numeric? (string-numeric? "ab"))
+
+(htdp-err/rt-test (string-numeric? 10) exn:fail:contract?
+  #;
+  (string-append "string-numeric?: <string> expected, given 10"))
+
+
+(htdp-test false 'string-alphabetic? (string-alphabetic? "a0"))
+(htdp-test true 'string-alphabetic? (string-alphabetic? "a"))
+(htdp-test true 'string-alphabetic? (string-alphabetic? "ba"))
+(htdp-test true 'string-alphabetic? (string-alphabetic? "ab"))
+
+(htdp-test true 'string-whitespace? (string-whitespace? "  "))
+(htdp-test true 'string-whitespace? (string-whitespace? "  \t"))
+(htdp-test false 'string-whitespace? (string-whitespace? "ABC"))
+
+(htdp-test false 'string-upper-case? (string-upper-case? "  "))
+(htdp-test false 'string-upper-case? (string-upper-case? "AB\t"))
+(htdp-test true 'string-upper-case? (string-upper-case? "ABC"))
+
+(htdp-test false 'string-lower-case? (string-lower-case? "  "))
+(htdp-test false 'string-lower-case? (string-lower-case? "ab\t"))
+(htdp-test true 'string-lower-case? (string-lower-case? "abc"))
+

collects/tests/mzscheme/beg-bega.ss

@@ -44,3 +44,15 @@
 
 (htdp-top-pop 1)
 (htdp-teachpack-pop)
+
+(htdp-err/rt-test (+) exn:application:arity?)
+(htdp-err/rt-test (+ 1) exn:application:arity?)
+(htdp-err/rt-test (*) exn:application:arity?)
+(htdp-err/rt-test (* 1) exn:application:arity?)
+(htdp-err/rt-test (-) exn:application:arity?)
+(htdp-err/rt-test (/) exn:application:arity?)
+(htdp-err/rt-test (/ 1) exn:application:arity?)
+
+(err/rt-test (+) exn:application:arity?)
+
+

collects/tests/mzscheme/beg-intm.ss

@@ -9,3 +9,4 @@
 (htdp-syntax-test #'(lambda (x) 10))
 
 (htdp-syntax-test #'(lambda (f) (f f)))
+

collects/tests/mzscheme/intm-adv.ss

@@ -1,10 +1,6 @@
 
 ;; These are true for beginner, but the operators are syntax, so
 ;; arity-test doesn't work.
-(arity-test + 2 -1)
-(arity-test * 2 -1)
-(arity-test / 2 -1)
-(arity-test - 1 -1)
 
 (htdp-syntax-test #'local)
 (htdp-syntax-test #'(local))
@@ -108,3 +104,11 @@
 
 (htdp-err/rt-test (build-string 2 add1)
   "build-string : second argument must be a <procedure> that produces a <char>, given #<procedure:add1>, which produced 1 for 0")
+
+(htdp-test 0 '+ (+))
+(htdp-test 1 '+ (+ 1))
+(htdp-test 1 '* (*))
+(htdp-test 1 '* (* 1))
+;(htdp-test (-) exn:application:arity?)
+;(htdp-err/rt-test (/) exn:application:arity?)
+;(htdp-test 1 (/ 1) exn:application:arity?)

collects/tests/mzscheme/intmlam-adv.ss

@@ -11,6 +11,6 @@
 (test 'id f11 'id)
 
 (err/rt-test (1 2 3))
-(err/rt-test (+) exn:application:arity?)
+
 
 

collects/tests/profile/main.ss

@@ -1,6 +1,7 @@
 #lang scheme/base
 
-(require tests/eli-tester profile/analyzer scheme/match scheme/list)
+(require tests/eli-tester profile/structs profile/analyzer
+         scheme/match scheme/list "topsort.ss")
 
 (define A '(A . #f))
 (define B '(B . #f))
@@ -36,6 +37,8 @@
 
 (test
 
+ do (topological-sort-tests)
+
  (match (analyze `(10
                    [0 0 ,A]
                    [0 1 ,A]))

collects/tests/profile/topsort.ss

@@ -0,0 +1,57 @@
+#lang scheme/base
+
+(require tests/eli-tester profile/structs profile/utils
+         scheme/list scheme/match)
+
+(define (connect! from to)
+  (define edge (make-edge 0 from 0 to 0))
+  (set-node-callers! to   (cons edge (node-callers to  )))
+  (set-node-callees! from (cons edge (node-callees from))))
+
+(define (sort-graph . edges)
+  (define names (remove-duplicates (remq* '(->) (append* edges))))
+  (define nodes (map (lambda (sym) (make-node sym #f '() 0 0 '() '())) names))
+  (define ->node (make-immutable-hasheq (map cons names nodes)))
+  (for ([edges edges])
+    (let loop ([xs edges])
+      (match xs
+        [(list from '-> to '-> _ ...)
+         (connect! (hash-ref ->node from) (hash-ref ->node to))
+         (loop (cddr xs))]
+        [(list from '-> to _ ...)
+         (connect! (hash-ref ->node from) (hash-ref ->node to))
+         (loop (cdddr xs))]
+        ['() (void)])))
+  (map (lambda (nodes) (map node-id nodes)) (topological-sort (car nodes))))
+
+(define (same-levels graph levels)
+  (define sorted (sort-graph graph))
+  (define (set=? l1 l2) (null? (append (remq* l1 l2) (remq* l2 l1))))
+  (andmap set=? sorted levels))
+
+(provide topological-sort-tests)
+(define (topological-sort-tests)
+  (test
+
+    (same-levels '(* -> A -> B)
+                 '((A) (B)))
+
+    (same-levels '(* -> A -> B -> *
+                   * -> B -> A -> *)
+                 '((A B)))
+
+    (same-levels '(* -> A -> B -> C
+                   * -> C)
+                 '((A) (B) (C)))
+
+    (same-levels '(* -> A
+                   * -> B
+                   B -> B)
+                 '((A B)))
+
+    (same-levels '(* -> A
+                   * -> B -> C
+                   * -> C -> B)
+                 '((A B C)))
+
+    ))

collects/tests/typed-scheme/unit-tests/parse-type-tests.ss

@@ -100,6 +100,8 @@
    [(All (a ...) (a ... -> Number))
     (-polydots (a) ((list) [a a] . ->... . N))]
    
+   [(Any -> Boolean : Number) (make-pred-ty -Number)]
+   
    ))
 
 ;; FIXME - add tests for parse-values-type, parse-tc-results

collects/texpict/private/common-unit.ss

@@ -1,7 +1,8 @@
 
 #lang scheme/unit
 
-  (require mzlib/etc)
+  (require scheme/gui/base
+           scheme/class)
   
   (require "common-sig.ss")
 
@@ -445,7 +446,7 @@
 	(let ([make-append-boxes 
 	       (lambda (wcomb hcomb fxoffset fyoffset rxoffset ryoffset 
 			      combine-ascent combine-descent)
-                 (rec *-append
+                 (letrec ([*-append
                            (lambda (sep . args)
                              (unless (number? sep)
                                (set! args (cons sep args))
@@ -486,7 +487,8 @@
                                      (list (make-child first dx1 dy1 1 1)
                                            (make-child rest dx2 dy2 1 1))
                                      #f
-                             (or (pict-last rest) rest)))])))))]
+                                     (or (pict-last rest) rest)))])))])
+                   *-append))]
 	      [2max (lambda (a b c . rest) (max a b))]
 	      [zero (lambda (fw fh rw rh sep fd1 fd2 rd1 rd2 . args) 0)]
 	      [fv (lambda (a b . args) a)]
@@ -895,14 +897,15 @@
 			(lambda (x)
 			  (and x #t))))
 
-      (define colorize
+      (define (colorize p color)
-        (case-lambda
+        (unless (or (string? color)
-          [(p color)
+                    (is-a? color color%))
+          (error 'colorize "expected a color, given ~e" color))
         (if (black-and-white)
             p
             (extend-pict 
              p 0 0 0 0 0
-                `(color ,color ,(pict-draw p))))]))
+             `(color ,color ,(pict-draw p)))))
 
       (define (optimize s)
 	(let o-loop ([s s][dx 0][dy 0])

doc/release-notes/mzscheme/HISTORY.txt

@@ -1,3 +1,10 @@
+Version 4.1.5.6
+Added identifier-prune-lexical-context and quote-syntax/prune
+
+Version 4.1.5.4
+Changed visiting of modules at phase N to happen only when compilation
+ at phase N starts
+
 Version 4.1.5.3
 Changed provide to convert an exported rename transformer to its
  free-identifier=? target

src/configure

@@ -5787,7 +5787,7 @@ case $OS in
     DYN_CFLAGS="-fPIC"
     ;;
   OpenBSD)
-    LIBS="$LIBS -rdynamic"
+    LIBS="$LIBS -rdynamic -Wl,--export-dynamic"
     ;;
   NetBSD)
     LIBS="$LIBS -rdynamic"

src/mzscheme/configure.ac

@@ -521,7 +521,7 @@ case $OS in
     DYN_CFLAGS="-fPIC"
     ;;
   OpenBSD)
-    LIBS="$LIBS -rdynamic"
+    LIBS="$LIBS -rdynamic -Wl,--export-dynamic"
     ;;
   NetBSD)
     LIBS="$LIBS -rdynamic"

src/mzscheme/src/cstartup.inc

@@ -1,5 +1,5 @@
   {
-    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35,126,7,52,46,49,46,53,46,53,50,0,0,0,1,0,0,3,0,12,0,
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35,126,7,52,46,49,46,53,46,54,50,0,0,0,1,0,0,3,0,12,0,
 17,0,20,0,27,0,40,0,47,0,51,0,58,0,63,0,68,0,72,0,78,
 0,92,0,106,0,109,0,115,0,119,0,121,0,132,0,134,0,148,0,155,0,
 177,0,179,0,193,0,1,1,27,1,35,1,43,1,53,1,89,1,128,1,167,
@@ -14,13 +14,13 @@
 115,61,120,73,108,101,116,114,101,99,45,118,97,108,117,101,115,66,108,97,109,
 98,100,97,1,20,112,97,114,97,109,101,116,101,114,105,122,97,116,105,111,110,
 45,107,101,121,61,118,73,100,101,102,105,110,101,45,118,97,108,117,101,115,97,
-35,11,8,168,228,95,159,2,15,35,35,159,2,14,35,35,159,2,14,35,35,
+35,11,8,136,232,95,159,2,15,35,35,159,2,14,35,35,159,2,14,35,35,
 16,20,2,3,2,1,2,5,2,1,2,6,2,1,2,7,2,1,2,8,2,
 1,2,9,2,1,2,10,2,1,2,4,2,1,2,11,2,1,2,12,2,1,
-97,36,11,8,168,228,93,159,2,14,35,36,16,2,2,2,161,2,1,36,2,
+97,36,11,8,136,232,93,159,2,14,35,36,16,2,2,2,161,2,1,36,2,
-2,2,1,2,2,96,11,11,8,168,228,16,0,96,37,11,8,168,228,16,0,
+2,2,1,2,2,96,11,11,8,136,232,16,0,96,37,11,8,136,232,16,0,
 13,16,4,35,29,11,11,2,1,11,18,16,2,99,64,104,101,114,101,8,31,
-8,30,8,29,8,28,8,27,93,8,224,47,57,0,0,95,9,8,224,47,57,
+8,30,8,29,8,28,8,27,93,8,224,15,58,0,0,95,9,8,224,15,58,
 0,0,2,1,27,248,22,135,4,23,196,1,249,22,128,4,80,158,38,35,251,
 22,75,2,16,248,22,90,23,200,2,12,249,22,65,2,17,248,22,92,23,202,
 1,27,248,22,135,4,23,196,1,249,22,128,4,80,158,38,35,251,22,75,2,
@@ -29,16 +29,16 @@
 36,28,248,22,73,248,22,67,23,195,2,248,22,66,193,249,22,128,4,80,158,
 38,35,251,22,75,2,16,248,22,66,23,200,2,249,22,65,2,12,248,22,67,
 23,202,1,11,18,16,2,101,10,8,31,8,30,8,29,8,28,8,27,16,4,
-11,11,2,18,3,1,7,101,110,118,57,56,49,54,16,4,11,11,2,19,3,
+11,11,2,18,3,1,7,101,110,118,57,56,51,50,16,4,11,11,2,19,3,
-1,7,101,110,118,57,56,49,55,93,8,224,48,57,0,0,95,9,8,224,48,
+1,7,101,110,118,57,56,51,51,93,8,224,16,58,0,0,95,9,8,224,16,
-57,0,0,2,1,27,248,22,67,248,22,135,4,23,197,1,28,248,22,73,23,
+58,0,0,2,1,27,248,22,67,248,22,135,4,23,197,1,28,248,22,73,23,
 194,2,20,15,159,36,35,36,28,248,22,73,248,22,67,23,195,2,248,22,66,
 193,249,22,128,4,80,158,38,35,250,22,75,2,20,248,22,75,249,22,75,248,
 22,75,2,21,248,22,66,23,202,2,251,22,75,2,16,2,21,2,21,249,22,
 65,2,4,248,22,67,23,205,1,18,16,2,101,11,8,31,8,30,8,29,8,
-28,8,27,16,4,11,11,2,18,3,1,7,101,110,118,57,56,49,57,16,4,
+28,8,27,16,4,11,11,2,18,3,1,7,101,110,118,57,56,51,53,16,4,
-11,11,2,19,3,1,7,101,110,118,57,56,50,48,93,8,224,49,57,0,0,
+11,11,2,19,3,1,7,101,110,118,57,56,51,54,93,8,224,17,58,0,0,
-95,9,8,224,49,57,0,0,2,1,248,22,135,4,193,27,248,22,135,4,194,
+95,9,8,224,17,58,0,0,2,1,248,22,135,4,193,27,248,22,135,4,194,
 249,22,65,248,22,75,248,22,66,196,248,22,67,195,27,248,22,67,248,22,135,
 4,23,197,1,249,22,128,4,80,158,38,35,28,248,22,53,248,22,129,4,248,
 22,66,23,198,2,27,249,22,2,32,0,89,162,8,44,36,42,9,222,33,39,
@@ -62,15 +62,15 @@
 102,105,114,115,116,11,2,24,201,250,22,76,2,20,9,248,22,67,203,27,248,
 22,67,248,22,135,4,23,197,1,28,248,22,73,23,194,2,20,15,159,36,35,
 36,249,22,128,4,80,158,38,35,27,248,22,135,4,248,22,66,23,198,2,28,
-249,22,164,8,62,61,62,248,22,129,4,248,22,90,23,197,2,250,22,75,2,
+249,22,165,8,62,61,62,248,22,129,4,248,22,90,23,197,2,250,22,75,2,
 20,248,22,75,249,22,75,21,93,2,25,248,22,66,199,250,22,76,2,3,249,
 22,75,2,25,249,22,75,248,22,99,203,2,25,248,22,67,202,251,22,75,2,
-16,28,249,22,164,8,248,22,129,4,248,22,66,23,201,2,64,101,108,115,101,
+16,28,249,22,165,8,248,22,129,4,248,22,66,23,201,2,64,101,108,115,101,
 10,248,22,66,23,198,2,250,22,76,2,20,9,248,22,67,23,201,1,249,22,
 65,2,3,248,22,67,23,203,1,100,8,31,8,30,8,29,8,28,8,27,16,
-4,11,11,2,18,3,1,7,101,110,118,57,56,52,50,16,4,11,11,2,19,
+4,11,11,2,18,3,1,7,101,110,118,57,56,53,56,16,4,11,11,2,19,
-3,1,7,101,110,118,57,56,52,51,93,8,224,50,57,0,0,18,16,2,158,
+3,1,7,101,110,118,57,56,53,57,93,8,224,18,58,0,0,18,16,2,158,
-94,10,64,118,111,105,100,8,47,95,9,8,224,50,57,0,0,2,1,27,248,
+94,10,64,118,111,105,100,8,47,95,9,8,224,18,58,0,0,2,1,27,248,
 22,67,248,22,135,4,196,249,22,128,4,80,158,38,35,28,248,22,53,248,22,
 129,4,248,22,66,197,250,22,75,2,26,248,22,75,248,22,66,199,248,22,90,
 198,27,248,22,129,4,248,22,66,197,250,22,75,2,26,248,22,75,248,22,66,
@@ -100,13 +100,13 @@
     EVAL_ONE_SIZED_STR((char *)expr, 2048);
   }
   {
-    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35,126,7,52,46,49,46,53,46,53,59,0,0,0,1,0,0,13,0,18,0,
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35,126,7,52,46,49,46,53,46,54,59,0,0,0,1,0,0,13,0,18,0,
 35,0,50,0,68,0,84,0,94,0,112,0,132,0,148,0,166,0,197,0,226,
 0,248,0,6,1,12,1,26,1,31,1,41,1,49,1,77,1,109,1,154,1,
 199,1,223,1,6,2,8,2,65,2,155,3,196,3,31,5,135,5,239,5,100,
-6,114,6,148,6,164,6,14,8,28,8,191,8,194,9,194,10,201,10,208,10,
+6,114,6,148,6,164,6,14,8,28,8,191,8,194,9,194,10,201,10,209,10,
-215,10,90,11,103,11,58,12,160,12,173,12,195,12,147,13,51,14,123,15,131,
+217,10,92,11,105,11,60,12,162,12,175,12,197,12,149,13,53,14,125,15,134,
-15,139,15,165,15,20,16,0,0,9,19,0,0,72,112,97,116,104,45,115,116,
+15,143,15,169,15,24,16,0,0,13,19,0,0,72,112,97,116,104,45,115,116,
 114,105,110,103,63,64,98,115,98,115,76,110,111,114,109,97,108,45,99,97,115,
 101,45,112,97,116,104,74,45,99,104,101,99,107,45,114,101,108,112,97,116,104,
 77,45,99,104,101,99,107,45,99,111,108,108,101,99,116,105,111,110,75,99,111,
@@ -132,222 +132,222 @@
 116,101,32,115,116,114,105,110,103,6,36,36,99,97,110,110,111,116,32,97,100,
 100,32,97,32,115,117,102,102,105,120,32,116,111,32,97,32,114,111,111,116,32,
 112,97,116,104,58,32,5,0,27,20,14,159,80,158,36,50,250,80,158,39,51,
-249,22,27,11,80,158,41,50,22,184,12,10,248,22,157,5,23,196,2,28,248,
+249,22,27,11,80,158,41,50,22,185,12,10,248,22,158,5,23,196,2,28,248,
-22,154,6,23,194,2,12,87,94,248,22,168,8,23,194,1,248,80,159,37,53,
+22,155,6,23,194,2,12,87,94,248,22,169,8,23,194,1,248,80,159,37,53,
 36,195,28,248,22,73,23,195,2,9,27,248,22,66,23,196,2,27,28,248,22,
-165,13,23,195,2,23,194,1,28,248,22,164,13,23,195,2,249,22,166,13,23,
+166,13,23,195,2,23,194,1,28,248,22,165,13,23,195,2,249,22,167,13,23,
-196,1,250,80,158,42,48,248,22,180,13,2,19,11,10,250,80,158,40,48,248,
+196,1,250,80,158,42,48,248,22,181,13,2,19,11,10,250,80,158,40,48,248,
-22,180,13,2,19,23,197,1,10,28,23,193,2,249,22,65,248,22,168,13,249,
+22,181,13,2,19,23,197,1,10,28,23,193,2,249,22,65,248,22,169,13,249,
-22,166,13,23,198,1,247,22,181,13,27,248,22,67,23,200,1,28,248,22,73,
+22,167,13,23,198,1,247,22,182,13,27,248,22,67,23,200,1,28,248,22,73,
-23,194,2,9,27,248,22,66,23,195,2,27,28,248,22,165,13,23,195,2,23,
+23,194,2,9,27,248,22,66,23,195,2,27,28,248,22,166,13,23,195,2,23,
-194,1,28,248,22,164,13,23,195,2,249,22,166,13,23,196,1,250,80,158,47,
+194,1,28,248,22,165,13,23,195,2,249,22,167,13,23,196,1,250,80,158,47,
-48,248,22,180,13,2,19,11,10,250,80,158,45,48,248,22,180,13,2,19,23,
+48,248,22,181,13,2,19,11,10,250,80,158,45,48,248,22,181,13,2,19,23,
-197,1,10,28,23,193,2,249,22,65,248,22,168,13,249,22,166,13,23,198,1,
+197,1,10,28,23,193,2,249,22,65,248,22,169,13,249,22,167,13,23,198,1,
-247,22,181,13,248,80,159,45,52,36,248,22,67,23,199,1,87,94,23,193,1,
+247,22,182,13,248,80,159,45,52,36,248,22,67,23,199,1,87,94,23,193,1,
 248,80,159,43,52,36,248,22,67,23,197,1,87,94,23,193,1,27,248,22,67,
 23,198,1,28,248,22,73,23,194,2,9,27,248,22,66,23,195,2,27,28,248,
-22,165,13,23,195,2,23,194,1,28,248,22,164,13,23,195,2,249,22,166,13,
+22,166,13,23,195,2,23,194,1,28,248,22,165,13,23,195,2,249,22,167,13,
-23,196,1,250,80,158,45,48,248,22,180,13,2,19,11,10,250,80,158,43,48,
+23,196,1,250,80,158,45,48,248,22,181,13,2,19,11,10,250,80,158,43,48,
-248,22,180,13,2,19,23,197,1,10,28,23,193,2,249,22,65,248,22,168,13,
+248,22,181,13,2,19,23,197,1,10,28,23,193,2,249,22,65,248,22,169,13,
-249,22,166,13,23,198,1,247,22,181,13,248,80,159,43,52,36,248,22,67,23,
+249,22,167,13,23,198,1,247,22,182,13,248,80,159,43,52,36,248,22,67,23,
-199,1,248,80,159,41,52,36,248,22,67,196,27,248,22,141,13,23,195,2,28,
+199,1,248,80,159,41,52,36,248,22,67,196,27,248,22,142,13,23,195,2,28,
-23,193,2,192,87,94,23,193,1,28,248,22,159,6,23,195,2,27,248,22,163,
+23,193,2,192,87,94,23,193,1,28,248,22,160,6,23,195,2,27,248,22,164,
-13,195,28,192,192,248,22,164,13,195,11,87,94,28,28,248,22,142,13,23,195,
+13,195,28,192,192,248,22,165,13,195,11,87,94,28,28,248,22,143,13,23,195,
-2,10,27,248,22,141,13,23,196,2,28,23,193,2,192,87,94,23,193,1,28,
+2,10,27,248,22,142,13,23,196,2,28,23,193,2,192,87,94,23,193,1,28,
-248,22,159,6,23,196,2,27,248,22,163,13,23,197,2,28,23,193,2,192,87,
+248,22,160,6,23,196,2,27,248,22,164,13,23,197,2,28,23,193,2,192,87,
-94,23,193,1,248,22,164,13,23,197,2,11,12,250,22,132,9,76,110,111,114,
+94,23,193,1,248,22,165,13,23,197,2,11,12,250,22,133,9,76,110,111,114,
 109,97,108,45,112,97,116,104,45,99,97,115,101,6,42,42,112,97,116,104,32,
 40,102,111,114,32,97,110,121,32,115,121,115,116,101,109,41,32,111,114,32,118,
 97,108,105,100,45,112,97,116,104,32,115,116,114,105,110,103,23,197,2,28,28,
-248,22,142,13,23,195,2,249,22,164,8,248,22,143,13,23,197,2,2,20,249,
+248,22,143,13,23,195,2,249,22,165,8,248,22,144,13,23,197,2,2,20,249,
-22,164,8,247,22,178,7,2,20,27,28,248,22,159,6,23,196,2,23,195,2,
+22,165,8,247,22,179,7,2,20,27,28,248,22,160,6,23,196,2,23,195,2,
-248,22,168,7,248,22,146,13,23,197,2,28,249,22,129,14,0,21,35,114,120,
+248,22,169,7,248,22,147,13,23,197,2,28,249,22,130,14,0,21,35,114,120,
 34,94,91,92,92,93,91,92,92,93,91,63,93,91,92,92,93,34,23,195,2,
-28,248,22,159,6,195,248,22,149,13,195,194,27,248,22,134,7,23,195,1,249,
+28,248,22,160,6,195,248,22,150,13,195,194,27,248,22,135,7,23,195,1,249,
-22,150,13,248,22,171,7,250,22,135,14,0,6,35,114,120,34,47,34,28,249,
+22,151,13,248,22,172,7,250,22,136,14,0,6,35,114,120,34,47,34,28,249,
-22,129,14,0,22,35,114,120,34,91,47,92,92,93,91,46,32,93,43,91,47,
+22,130,14,0,22,35,114,120,34,91,47,92,92,93,91,46,32,93,43,91,47,
-92,92,93,42,36,34,23,201,2,23,199,1,250,22,135,14,0,19,35,114,120,
+92,92,93,42,36,34,23,201,2,23,199,1,250,22,136,14,0,19,35,114,120,
 34,91,32,46,93,43,40,91,47,92,92,93,42,41,36,34,23,202,1,6,2,
-2,92,49,80,159,43,36,37,2,20,28,248,22,159,6,194,248,22,149,13,194,
+2,92,49,80,159,43,36,37,2,20,28,248,22,160,6,194,248,22,150,13,194,
-193,87,94,28,27,248,22,141,13,23,196,2,28,23,193,2,192,87,94,23,193,
+193,87,94,28,27,248,22,142,13,23,196,2,28,23,193,2,192,87,94,23,193,
-1,28,248,22,159,6,23,196,2,27,248,22,163,13,23,197,2,28,23,193,2,
+1,28,248,22,160,6,23,196,2,27,248,22,164,13,23,197,2,28,23,193,2,
-192,87,94,23,193,1,248,22,164,13,23,197,2,11,12,250,22,132,9,23,196,
+192,87,94,23,193,1,248,22,165,13,23,197,2,11,12,250,22,133,9,23,196,
-2,2,21,23,197,2,28,248,22,163,13,23,195,2,12,248,22,160,11,249,22,
+2,2,21,23,197,2,28,248,22,164,13,23,195,2,12,248,22,161,11,249,22,
-169,10,248,22,188,6,250,22,143,7,2,22,23,200,1,23,201,1,247,22,23,
+170,10,248,22,189,6,250,22,144,7,2,22,23,200,1,23,201,1,247,22,23,
-87,94,28,27,248,22,141,13,23,196,2,28,23,193,2,192,87,94,23,193,1,
+87,94,28,27,248,22,142,13,23,196,2,28,23,193,2,192,87,94,23,193,1,
-28,248,22,159,6,23,196,2,27,248,22,163,13,23,197,2,28,23,193,2,192,
+28,248,22,160,6,23,196,2,27,248,22,164,13,23,197,2,28,23,193,2,192,
-87,94,23,193,1,248,22,164,13,23,197,2,11,12,250,22,132,9,23,196,2,
+87,94,23,193,1,248,22,165,13,23,197,2,11,12,250,22,133,9,23,196,2,
-2,21,23,197,2,28,248,22,163,13,23,195,2,12,248,22,160,11,249,22,169,
+2,21,23,197,2,28,248,22,164,13,23,195,2,12,248,22,161,11,249,22,170,
-10,248,22,188,6,250,22,143,7,2,22,23,200,1,23,201,1,247,22,23,87,
+10,248,22,189,6,250,22,144,7,2,22,23,200,1,23,201,1,247,22,23,87,
-94,87,94,28,27,248,22,141,13,23,196,2,28,23,193,2,192,87,94,23,193,
+94,87,94,28,27,248,22,142,13,23,196,2,28,23,193,2,192,87,94,23,193,
-1,28,248,22,159,6,23,196,2,27,248,22,163,13,23,197,2,28,23,193,2,
+1,28,248,22,160,6,23,196,2,27,248,22,164,13,23,197,2,28,23,193,2,
-192,87,94,23,193,1,248,22,164,13,23,197,2,11,12,250,22,132,9,195,2,
+192,87,94,23,193,1,248,22,165,13,23,197,2,11,12,250,22,133,9,195,2,
-21,23,197,2,28,248,22,163,13,23,195,2,12,248,22,160,11,249,22,169,10,
+21,23,197,2,28,248,22,164,13,23,195,2,12,248,22,161,11,249,22,170,10,
-248,22,188,6,250,22,143,7,2,22,199,23,201,1,247,22,23,249,22,3,89,
+248,22,189,6,250,22,144,7,2,22,199,23,201,1,247,22,23,249,22,3,89,
-162,8,44,36,49,9,223,2,33,33,196,248,22,160,11,249,22,135,11,23,196,
+162,8,44,36,49,9,223,2,33,33,196,248,22,161,11,249,22,136,11,23,196,
 1,247,22,23,87,94,250,80,159,38,39,36,2,6,196,197,251,80,159,39,41,
 36,2,6,32,0,89,162,8,44,36,44,9,222,33,35,197,198,32,37,89,162,
 43,41,58,65,99,108,111,111,112,222,33,38,28,248,22,73,23,199,2,87,94,
-23,198,1,248,23,196,1,251,22,143,7,2,23,23,199,1,28,248,22,73,23,
+23,198,1,248,23,196,1,251,22,144,7,2,23,23,199,1,28,248,22,73,23,
-203,2,87,94,23,202,1,23,201,1,250,22,1,22,159,13,23,204,1,23,205,
+203,2,87,94,23,202,1,23,201,1,250,22,1,22,160,13,23,204,1,23,205,
-1,23,198,1,27,249,22,159,13,248,22,66,23,202,2,23,199,2,28,248,22,
+1,23,198,1,27,249,22,160,13,248,22,66,23,202,2,23,199,2,28,248,22,
-154,13,23,194,2,27,250,22,1,22,159,13,23,197,1,23,202,2,28,248,22,
+155,13,23,194,2,27,250,22,1,22,160,13,23,197,1,23,202,2,28,248,22,
-154,13,23,194,2,192,87,94,23,193,1,27,248,22,67,23,202,1,28,248,22,
+155,13,23,194,2,192,87,94,23,193,1,27,248,22,67,23,202,1,28,248,22,
-73,23,194,2,87,94,23,193,1,248,23,199,1,251,22,143,7,2,23,23,202,
+73,23,194,2,87,94,23,193,1,248,23,199,1,251,22,144,7,2,23,23,202,
-1,28,248,22,73,23,206,2,87,94,23,205,1,23,204,1,250,22,1,22,159,
+1,28,248,22,73,23,206,2,87,94,23,205,1,23,204,1,250,22,1,22,160,
-13,23,207,1,23,208,1,23,201,1,27,249,22,159,13,248,22,66,23,197,2,
+13,23,207,1,23,208,1,23,201,1,27,249,22,160,13,248,22,66,23,197,2,
-23,202,2,28,248,22,154,13,23,194,2,27,250,22,1,22,159,13,23,197,1,
+23,202,2,28,248,22,155,13,23,194,2,27,250,22,1,22,160,13,23,197,1,
-204,28,248,22,154,13,193,192,253,2,37,203,204,205,206,23,15,248,22,67,201,
+204,28,248,22,155,13,193,192,253,2,37,203,204,205,206,23,15,248,22,67,201,
 253,2,37,202,203,204,205,206,248,22,67,200,87,94,23,193,1,27,248,22,67,
 23,201,1,28,248,22,73,23,194,2,87,94,23,193,1,248,23,198,1,251,22,
-143,7,2,23,23,201,1,28,248,22,73,23,205,2,87,94,23,204,1,23,203,
+144,7,2,23,23,201,1,28,248,22,73,23,205,2,87,94,23,204,1,23,203,
-1,250,22,1,22,159,13,23,206,1,23,207,1,23,200,1,27,249,22,159,13,
+1,250,22,1,22,160,13,23,206,1,23,207,1,23,200,1,27,249,22,160,13,
-248,22,66,23,197,2,23,201,2,28,248,22,154,13,23,194,2,27,250,22,1,
+248,22,66,23,197,2,23,201,2,28,248,22,155,13,23,194,2,27,250,22,1,
-22,159,13,23,197,1,203,28,248,22,154,13,193,192,253,2,37,202,203,204,205,
+22,160,13,23,197,1,203,28,248,22,155,13,193,192,253,2,37,202,203,204,205,
-206,248,22,67,201,253,2,37,201,202,203,204,205,248,22,67,200,27,247,22,182,
+206,248,22,67,201,253,2,37,201,202,203,204,205,248,22,67,200,27,247,22,183,
-13,253,2,37,198,199,200,201,202,198,87,95,28,28,248,22,142,13,23,194,2,
+13,253,2,37,198,199,200,201,202,198,87,95,28,28,248,22,143,13,23,194,2,
-10,27,248,22,141,13,23,195,2,28,23,193,2,192,87,94,23,193,1,28,248,
+10,27,248,22,142,13,23,195,2,28,23,193,2,192,87,94,23,193,1,28,248,
-22,159,6,23,195,2,27,248,22,163,13,23,196,2,28,23,193,2,192,87,94,
+22,160,6,23,195,2,27,248,22,164,13,23,196,2,28,23,193,2,192,87,94,
-23,193,1,248,22,164,13,23,196,2,11,12,252,22,132,9,23,200,2,2,24,
+23,193,1,248,22,165,13,23,196,2,11,12,252,22,133,9,23,200,2,2,24,
-35,23,198,2,23,199,2,28,28,248,22,159,6,23,195,2,10,248,22,147,7,
+35,23,198,2,23,199,2,28,28,248,22,160,6,23,195,2,10,248,22,148,7,
-23,195,2,87,94,23,194,1,12,252,22,132,9,23,200,2,2,25,36,23,198,
+23,195,2,87,94,23,194,1,12,252,22,133,9,23,200,2,2,25,36,23,198,
-2,23,199,1,91,159,38,11,90,161,38,35,11,248,22,162,13,23,197,2,87,
+2,23,199,1,91,159,38,11,90,161,38,35,11,248,22,163,13,23,197,2,87,
-94,23,195,1,87,94,28,192,12,250,22,133,9,23,201,1,2,26,23,199,1,
+94,23,195,1,87,94,28,192,12,250,22,134,9,23,201,1,2,26,23,199,1,
-249,22,7,194,195,91,159,37,11,90,161,37,35,11,87,95,28,28,248,22,142,
+249,22,7,194,195,91,159,37,11,90,161,37,35,11,87,95,28,28,248,22,143,
-13,23,196,2,10,27,248,22,141,13,23,197,2,28,23,193,2,192,87,94,23,
+13,23,196,2,10,27,248,22,142,13,23,197,2,28,23,193,2,192,87,94,23,
-193,1,28,248,22,159,6,23,197,2,27,248,22,163,13,23,198,2,28,23,193,
+193,1,28,248,22,160,6,23,197,2,27,248,22,164,13,23,198,2,28,23,193,
-2,192,87,94,23,193,1,248,22,164,13,23,198,2,11,12,252,22,132,9,2,
+2,192,87,94,23,193,1,248,22,165,13,23,198,2,11,12,252,22,133,9,2,
-9,2,24,35,23,200,2,23,201,2,28,28,248,22,159,6,23,197,2,10,248,
+9,2,24,35,23,200,2,23,201,2,28,28,248,22,160,6,23,197,2,10,248,
-22,147,7,23,197,2,12,252,22,132,9,2,9,2,25,36,23,200,2,23,201,
+22,148,7,23,197,2,12,252,22,133,9,2,9,2,25,36,23,200,2,23,201,
-2,91,159,38,11,90,161,38,35,11,248,22,162,13,23,199,2,87,94,23,195,
+2,91,159,38,11,90,161,38,35,11,248,22,163,13,23,199,2,87,94,23,195,
-1,87,94,28,192,12,250,22,133,9,2,9,2,26,23,201,2,249,22,7,194,
+1,87,94,28,192,12,250,22,134,9,2,9,2,26,23,201,2,249,22,7,194,
-195,27,249,22,151,13,250,22,134,14,0,20,35,114,120,35,34,40,63,58,91,
+195,27,249,22,152,13,250,22,135,14,0,20,35,114,120,35,34,40,63,58,91,
-46,93,91,94,46,93,42,124,41,36,34,248,22,147,13,23,201,1,28,248,22,
+46,93,91,94,46,93,42,124,41,36,34,248,22,148,13,23,201,1,28,248,22,
-159,6,23,203,2,249,22,171,7,23,204,1,8,63,23,202,1,28,248,22,142,
+160,6,23,203,2,249,22,172,7,23,204,1,8,63,23,202,1,28,248,22,143,
-13,23,199,2,248,22,143,13,23,199,1,87,94,23,198,1,247,22,144,13,28,
+13,23,199,2,248,22,144,13,23,199,1,87,94,23,198,1,247,22,145,13,28,
-248,22,141,13,194,249,22,159,13,195,194,192,91,159,37,11,90,161,37,35,11,
+248,22,142,13,194,249,22,160,13,195,194,192,91,159,37,11,90,161,37,35,11,
-87,95,28,28,248,22,142,13,23,196,2,10,27,248,22,141,13,23,197,2,28,
+87,95,28,28,248,22,143,13,23,196,2,10,27,248,22,142,13,23,197,2,28,
-23,193,2,192,87,94,23,193,1,28,248,22,159,6,23,197,2,27,248,22,163,
+23,193,2,192,87,94,23,193,1,28,248,22,160,6,23,197,2,27,248,22,164,
-13,23,198,2,28,23,193,2,192,87,94,23,193,1,248,22,164,13,23,198,2,
+13,23,198,2,28,23,193,2,192,87,94,23,193,1,248,22,165,13,23,198,2,
-11,12,252,22,132,9,2,10,2,24,35,23,200,2,23,201,2,28,28,248,22,
+11,12,252,22,133,9,2,10,2,24,35,23,200,2,23,201,2,28,28,248,22,
-159,6,23,197,2,10,248,22,147,7,23,197,2,12,252,22,132,9,2,10,2,
+160,6,23,197,2,10,248,22,148,7,23,197,2,12,252,22,133,9,2,10,2,
-25,36,23,200,2,23,201,2,91,159,38,11,90,161,38,35,11,248,22,162,13,
+25,36,23,200,2,23,201,2,91,159,38,11,90,161,38,35,11,248,22,163,13,
-23,199,2,87,94,23,195,1,87,94,28,192,12,250,22,133,9,2,10,2,26,
+23,199,2,87,94,23,195,1,87,94,28,192,12,250,22,134,9,2,10,2,26,
-23,201,2,249,22,7,194,195,27,249,22,151,13,249,22,157,7,250,22,135,14,
+23,201,2,249,22,7,194,195,27,249,22,152,13,249,22,158,7,250,22,136,14,
-0,9,35,114,120,35,34,91,46,93,34,248,22,147,13,23,203,1,6,1,1,
+0,9,35,114,120,35,34,91,46,93,34,248,22,148,13,23,203,1,6,1,1,
-95,28,248,22,159,6,23,202,2,249,22,171,7,23,203,1,8,63,23,201,1,
+95,28,248,22,160,6,23,202,2,249,22,172,7,23,203,1,8,63,23,201,1,
-28,248,22,142,13,23,199,2,248,22,143,13,23,199,1,87,94,23,198,1,247,
+28,248,22,143,13,23,199,2,248,22,144,13,23,199,1,87,94,23,198,1,247,
-22,144,13,28,248,22,141,13,194,249,22,159,13,195,194,192,249,247,22,190,4,
+22,145,13,28,248,22,142,13,194,249,22,160,13,195,194,192,249,247,22,191,4,
-194,11,249,80,158,37,46,9,9,249,80,158,37,46,195,9,27,247,22,184,13,
+194,11,249,80,159,37,46,36,9,9,249,80,159,37,46,36,195,9,27,247,22,
-249,80,158,38,47,28,23,195,2,27,248,22,176,7,6,11,11,80,76,84,67,
+185,13,249,80,158,38,47,28,23,195,2,27,248,22,177,7,6,11,11,80,76,
-79,76,76,69,67,84,83,28,192,192,6,0,0,6,0,0,27,28,23,196,1,
+84,67,79,76,76,69,67,84,83,28,192,192,6,0,0,6,0,0,27,28,23,
-250,22,159,13,248,22,180,13,69,97,100,100,111,110,45,100,105,114,247,22,174,
+196,1,250,22,160,13,248,22,181,13,69,97,100,100,111,110,45,100,105,114,247,
-7,6,8,8,99,111,108,108,101,99,116,115,11,27,248,80,159,41,52,36,250,
+22,175,7,6,8,8,99,111,108,108,101,99,116,115,11,27,248,80,159,41,52,
-22,79,23,203,1,248,22,75,248,22,180,13,72,99,111,108,108,101,99,116,115,
+36,250,22,79,23,203,1,248,22,75,248,22,181,13,72,99,111,108,108,101,99,
-45,100,105,114,23,204,1,28,23,194,2,249,22,65,23,196,1,23,195,1,192,
+116,115,45,100,105,114,23,204,1,28,23,194,2,249,22,65,23,196,1,23,195,
-32,47,89,162,8,44,38,54,2,18,222,33,48,27,249,22,191,13,23,197,2,
+1,192,32,47,89,162,8,44,38,54,2,18,222,33,48,27,249,22,128,14,23,
-23,198,2,28,23,193,2,87,94,23,196,1,27,248,22,90,23,195,2,27,27,
+197,2,23,198,2,28,23,193,2,87,94,23,196,1,27,248,22,90,23,195,2,
-248,22,99,23,197,1,27,249,22,191,13,23,201,2,23,196,2,28,23,193,2,
+27,27,248,22,99,23,197,1,27,249,22,128,14,23,201,2,23,196,2,28,23,
-87,94,23,194,1,27,248,22,90,23,195,2,27,250,2,47,23,203,2,23,204,
+193,2,87,94,23,194,1,27,248,22,90,23,195,2,27,250,2,47,23,203,2,
-1,248,22,99,23,199,1,28,249,22,153,7,23,196,2,2,27,249,22,79,23,
+23,204,1,248,22,99,23,199,1,28,249,22,154,7,23,196,2,2,27,249,22,
-202,2,194,249,22,65,248,22,150,13,23,197,1,23,195,1,87,95,23,199,1,
+79,23,202,2,194,249,22,65,248,22,151,13,23,197,1,23,195,1,87,95,23,
-23,193,1,28,249,22,153,7,23,196,2,2,27,249,22,79,23,200,2,9,249,
+199,1,23,193,1,28,249,22,154,7,23,196,2,2,27,249,22,79,23,200,2,
-22,65,248,22,150,13,23,197,1,9,28,249,22,153,7,23,196,2,2,27,249,
+9,249,22,65,248,22,151,13,23,197,1,9,28,249,22,154,7,23,196,2,2,
-22,79,197,194,87,94,23,196,1,249,22,65,248,22,150,13,23,197,1,194,87,
+27,249,22,79,197,194,87,94,23,196,1,249,22,65,248,22,151,13,23,197,1,
-94,23,193,1,28,249,22,153,7,23,198,2,2,27,249,22,79,195,9,87,94,
+194,87,94,23,193,1,28,249,22,154,7,23,198,2,2,27,249,22,79,195,9,
-23,194,1,249,22,65,248,22,150,13,23,199,1,9,87,95,28,28,248,22,147,
+87,94,23,194,1,249,22,65,248,22,151,13,23,199,1,9,87,95,28,28,248,
-7,194,10,248,22,159,6,194,12,250,22,132,9,2,13,6,21,21,98,121,116,
+22,148,7,194,10,248,22,160,6,194,12,250,22,133,9,2,13,6,21,21,98,
-101,32,115,116,114,105,110,103,32,111,114,32,115,116,114,105,110,103,196,28,28,
+121,116,101,32,115,116,114,105,110,103,32,111,114,32,115,116,114,105,110,103,196,
-248,22,74,195,249,22,4,22,141,13,196,11,12,250,22,132,9,2,13,6,13,
+28,28,248,22,74,195,249,22,4,22,142,13,196,11,12,250,22,133,9,2,13,
-13,108,105,115,116,32,111,102,32,112,97,116,104,115,197,250,2,47,197,195,28,
+6,13,13,108,105,115,116,32,111,102,32,112,97,116,104,115,197,250,2,47,197,
-248,22,159,6,197,248,22,170,7,197,196,32,50,89,162,8,44,39,57,2,18,
+195,28,248,22,160,6,197,248,22,171,7,197,196,32,50,89,162,8,44,39,57,
-222,33,53,32,51,89,162,8,44,38,54,70,102,111,117,110,100,45,101,120,101,
+2,18,222,33,53,32,51,89,162,8,44,38,54,70,102,111,117,110,100,45,101,
-99,222,33,52,28,23,193,2,91,159,38,11,90,161,38,35,11,248,22,162,13,
+120,101,99,222,33,52,28,23,193,2,91,159,38,11,90,161,38,35,11,248,22,
-23,199,2,87,95,23,195,1,23,194,1,27,28,23,198,2,27,248,22,167,13,
+163,13,23,199,2,87,95,23,195,1,23,194,1,27,28,23,198,2,27,248,22,
-23,201,2,28,249,22,166,8,23,195,2,23,202,2,11,28,248,22,163,13,23,
+168,13,23,201,2,28,249,22,167,8,23,195,2,23,202,2,11,28,248,22,164,
-194,2,250,2,51,23,201,2,23,202,2,249,22,159,13,23,200,2,23,198,1,
+13,23,194,2,250,2,51,23,201,2,23,202,2,249,22,160,13,23,200,2,23,
-250,2,51,23,201,2,23,202,2,23,196,1,11,28,23,193,2,192,87,94,23,
+198,1,250,2,51,23,201,2,23,202,2,23,196,1,11,28,23,193,2,192,87,
-193,1,27,28,248,22,141,13,23,196,2,27,249,22,159,13,23,198,2,23,201,
+94,23,193,1,27,28,248,22,142,13,23,196,2,27,249,22,160,13,23,198,2,
-2,28,28,248,22,154,13,193,10,248,22,153,13,193,192,11,11,28,23,193,2,
+23,201,2,28,28,248,22,155,13,193,10,248,22,154,13,193,192,11,11,28,23,
-192,87,94,23,193,1,28,23,199,2,11,27,248,22,167,13,23,202,2,28,249,
+193,2,192,87,94,23,193,1,28,23,199,2,11,27,248,22,168,13,23,202,2,
-22,166,8,23,195,2,23,203,1,11,28,248,22,163,13,23,194,2,250,2,51,
+28,249,22,167,8,23,195,2,23,203,1,11,28,248,22,164,13,23,194,2,250,
-23,202,1,23,203,1,249,22,159,13,23,201,1,23,198,1,250,2,51,201,202,
+2,51,23,202,1,23,203,1,249,22,160,13,23,201,1,23,198,1,250,2,51,
-195,194,28,248,22,73,23,197,2,11,27,248,22,166,13,248,22,66,23,199,2,
+201,202,195,194,28,248,22,73,23,197,2,11,27,248,22,167,13,248,22,66,23,
-27,249,22,159,13,23,196,1,23,197,2,28,248,22,153,13,23,194,2,250,2,
+199,2,27,249,22,160,13,23,196,1,23,197,2,28,248,22,154,13,23,194,2,
-51,198,199,195,87,94,23,193,1,27,248,22,67,23,200,1,28,248,22,73,23,
+250,2,51,198,199,195,87,94,23,193,1,27,248,22,67,23,200,1,28,248,22,
-194,2,11,27,248,22,166,13,248,22,66,23,196,2,27,249,22,159,13,23,196,
+73,23,194,2,11,27,248,22,167,13,248,22,66,23,196,2,27,249,22,160,13,
-1,23,200,2,28,248,22,153,13,23,194,2,250,2,51,201,202,195,87,94,23,
+23,196,1,23,200,2,28,248,22,154,13,23,194,2,250,2,51,201,202,195,87,
-193,1,27,248,22,67,23,197,1,28,248,22,73,23,194,2,11,27,248,22,166,
+94,23,193,1,27,248,22,67,23,197,1,28,248,22,73,23,194,2,11,27,248,
-13,248,22,66,195,27,249,22,159,13,23,196,1,202,28,248,22,153,13,193,250,
+22,167,13,248,22,66,195,27,249,22,160,13,23,196,1,202,28,248,22,154,13,
-2,51,204,205,195,251,2,50,204,205,206,248,22,67,199,87,95,28,27,248,22,
+193,250,2,51,204,205,195,251,2,50,204,205,206,248,22,67,199,87,95,28,27,
-141,13,23,196,2,28,23,193,2,192,87,94,23,193,1,28,248,22,159,6,23,
+248,22,142,13,23,196,2,28,23,193,2,192,87,94,23,193,1,28,248,22,160,
-196,2,27,248,22,163,13,23,197,2,28,23,193,2,192,87,94,23,193,1,248,
+6,23,196,2,27,248,22,164,13,23,197,2,28,23,193,2,192,87,94,23,193,
-22,164,13,23,197,2,11,12,250,22,132,9,2,14,6,25,25,112,97,116,104,
+1,248,22,165,13,23,197,2,11,12,250,22,133,9,2,14,6,25,25,112,97,
-32,111,114,32,115,116,114,105,110,103,32,40,115,97,110,115,32,110,117,108,41,
+116,104,32,111,114,32,115,116,114,105,110,103,32,40,115,97,110,115,32,110,117,
-23,197,2,28,28,23,195,2,28,27,248,22,141,13,23,197,2,28,23,193,2,
+108,41,23,197,2,28,28,23,195,2,28,27,248,22,142,13,23,197,2,28,23,
-192,87,94,23,193,1,28,248,22,159,6,23,197,2,27,248,22,163,13,23,198,
+193,2,192,87,94,23,193,1,28,248,22,160,6,23,197,2,27,248,22,164,13,
-2,28,23,193,2,192,87,94,23,193,1,248,22,164,13,23,198,2,11,248,22,
+23,198,2,28,23,193,2,192,87,94,23,193,1,248,22,165,13,23,198,2,11,
-163,13,23,196,2,11,10,12,250,22,132,9,2,14,6,29,29,35,102,32,111,
+248,22,164,13,23,196,2,11,10,12,250,22,133,9,2,14,6,29,29,35,102,
-114,32,114,101,108,97,116,105,118,101,32,112,97,116,104,32,111,114,32,115,116,
+32,111,114,32,114,101,108,97,116,105,118,101,32,112,97,116,104,32,111,114,32,
-114,105,110,103,23,198,2,28,28,248,22,163,13,23,195,2,91,159,38,11,90,
+115,116,114,105,110,103,23,198,2,28,28,248,22,164,13,23,195,2,91,159,38,
-161,38,35,11,248,22,162,13,23,198,2,249,22,164,8,194,68,114,101,108,97,
+11,90,161,38,35,11,248,22,163,13,23,198,2,249,22,165,8,194,68,114,101,
-116,105,118,101,11,27,248,22,176,7,6,4,4,80,65,84,72,251,2,50,23,
+108,97,116,105,118,101,11,27,248,22,177,7,6,4,4,80,65,84,72,251,2,
-199,1,23,200,1,23,201,1,28,23,197,2,27,249,80,159,43,47,37,23,200,
+50,23,199,1,23,200,1,23,201,1,28,23,197,2,27,249,80,159,43,47,37,
-1,9,28,249,22,164,8,247,22,178,7,2,20,249,22,65,248,22,150,13,5,
+23,200,1,9,28,249,22,165,8,247,22,179,7,2,20,249,22,65,248,22,151,
-1,46,23,195,1,192,9,27,248,22,166,13,23,196,1,28,248,22,153,13,193,
+13,5,1,46,23,195,1,192,9,27,248,22,167,13,23,196,1,28,248,22,154,
-250,2,51,198,199,195,11,250,80,158,38,48,196,197,11,250,80,158,38,48,196,
+13,193,250,2,51,198,199,195,11,250,80,159,38,48,36,196,197,11,250,80,159,
-11,11,87,94,249,22,150,6,247,22,186,4,195,248,22,176,5,249,22,172,3,
+38,48,36,196,11,11,87,94,249,22,151,6,247,22,187,4,195,248,22,177,5,
-35,249,22,156,3,197,198,27,28,23,197,2,87,95,23,196,1,23,195,1,23,
+249,22,172,3,35,249,22,156,3,197,198,27,28,23,197,2,87,95,23,196,1,
-197,1,87,94,23,197,1,27,248,22,180,13,2,19,27,249,80,159,40,48,37,
+23,195,1,23,197,1,87,94,23,197,1,27,248,22,181,13,2,19,27,249,80,
-23,196,1,11,27,27,248,22,175,3,23,200,1,28,192,192,35,27,27,248,22,
+159,40,48,36,23,196,1,11,27,27,248,22,175,3,23,200,1,28,192,192,35,
-175,3,23,202,1,28,192,192,35,249,22,153,5,23,197,1,83,158,39,20,97,
+27,27,248,22,175,3,23,202,1,28,192,192,35,249,22,154,5,23,197,1,83,
-95,89,162,8,44,35,47,9,224,3,2,33,57,23,195,1,23,196,1,27,248,
+158,39,20,97,95,89,162,8,44,35,47,9,224,3,2,33,57,23,195,1,23,
-22,138,5,23,195,1,248,80,159,38,53,36,193,159,35,20,103,159,35,16,1,
+196,1,27,248,22,139,5,23,195,1,248,80,159,38,53,36,193,159,35,20,103,
-11,16,0,83,158,41,20,100,144,67,35,37,117,116,105,108,115,29,11,11,11,
+159,35,16,1,11,16,0,83,158,41,20,100,144,67,35,37,117,116,105,108,115,
-11,11,10,42,80,158,35,35,20,103,159,37,16,17,2,1,2,2,2,3,2,
+29,11,11,11,11,11,10,42,80,158,35,35,20,103,159,37,16,17,2,1,2,
-4,2,5,2,6,2,7,2,8,2,9,2,10,2,11,2,12,2,13,2,14,
+2,2,3,2,4,2,5,2,6,2,7,2,8,2,9,2,10,2,11,2,12,
-2,15,30,2,17,1,20,112,97,114,97,109,101,116,101,114,105,122,97,116,105,
+2,13,2,14,2,15,30,2,17,1,20,112,97,114,97,109,101,116,101,114,105,
-111,110,45,107,101,121,4,30,2,17,1,23,101,120,116,101,110,100,45,112,97,
+122,97,116,105,111,110,45,107,101,121,4,30,2,17,1,23,101,120,116,101,110,
-114,97,109,101,116,101,114,105,122,97,116,105,111,110,3,16,0,16,0,35,16,
+100,45,112,97,114,97,109,101,116,101,114,105,122,97,116,105,111,110,3,16,0,
-0,35,16,4,2,5,2,4,2,2,2,8,39,11,11,38,35,11,11,11,16,
+16,0,35,16,0,35,16,4,2,5,2,4,2,2,2,8,39,11,11,38,35,
-11,2,7,2,6,2,15,2,14,2,12,2,11,2,3,2,10,2,13,2,9,
+11,11,11,16,11,2,7,2,6,2,15,2,14,2,12,2,11,2,3,2,10,
-2,1,16,11,11,11,11,11,11,11,11,11,11,11,11,16,11,2,7,2,6,
+2,13,2,9,2,1,16,11,11,11,11,11,11,11,11,11,11,11,11,16,11,
-2,15,2,14,2,12,2,11,2,3,2,10,2,13,2,9,2,1,46,46,36,
+2,7,2,6,2,15,2,14,2,12,2,11,2,3,2,10,2,13,2,9,2,
-11,11,11,16,0,16,0,16,0,35,35,11,11,11,11,16,0,16,0,16,0,
+1,46,46,36,11,11,11,16,0,16,0,16,0,35,35,11,11,11,11,16,0,
-35,35,16,0,16,17,83,158,35,16,2,89,162,43,36,48,2,18,223,0,33,
+16,0,16,0,35,35,16,0,16,17,83,158,35,16,2,89,162,43,36,48,2,
-28,80,159,35,53,36,83,158,35,16,2,89,162,8,44,36,55,2,18,223,0,
+18,223,0,33,28,80,159,35,53,36,83,158,35,16,2,89,162,8,44,36,55,
-33,29,80,159,35,52,36,83,158,35,16,2,32,0,89,162,43,36,44,2,1,
+2,18,223,0,33,29,80,159,35,52,36,83,158,35,16,2,32,0,89,162,43,
-222,33,30,80,159,35,35,36,83,158,35,16,2,249,22,161,6,7,92,7,92,
+36,44,2,1,222,33,30,80,159,35,35,36,83,158,35,16,2,249,22,162,6,
-80,159,35,36,36,83,158,35,16,2,89,162,43,36,53,2,3,223,0,33,31,
+7,92,7,92,80,159,35,36,36,83,158,35,16,2,89,162,43,36,53,2,3,
-80,159,35,37,36,83,158,35,16,2,32,0,89,162,8,44,37,49,2,4,222,
+223,0,33,31,80,159,35,37,36,83,158,35,16,2,32,0,89,162,8,44,37,
-33,32,80,159,35,38,36,83,158,35,16,2,32,0,89,162,8,44,38,50,2,
+49,2,4,222,33,32,80,159,35,38,36,83,158,35,16,2,32,0,89,162,8,
-5,222,33,34,80,159,35,39,36,83,158,35,16,2,89,162,8,45,37,47,2,
+44,38,50,2,5,222,33,34,80,159,35,39,36,83,158,35,16,2,89,162,8,
-6,223,0,33,36,80,159,35,40,36,83,158,35,16,2,32,0,89,162,43,39,
+45,37,47,2,6,223,0,33,36,80,159,35,40,36,83,158,35,16,2,32,0,
-51,2,7,222,33,39,80,159,35,41,36,83,158,35,16,2,32,0,89,162,43,
+89,162,43,39,51,2,7,222,33,39,80,159,35,41,36,83,158,35,16,2,32,
-38,49,2,8,222,33,40,80,159,35,42,36,83,158,35,16,2,32,0,89,162,
+0,89,162,43,38,49,2,8,222,33,40,80,159,35,42,36,83,158,35,16,2,
-43,37,52,2,9,222,33,41,80,159,35,43,36,83,158,35,16,2,32,0,89,
+32,0,89,162,43,37,52,2,9,222,33,41,80,159,35,43,36,83,158,35,16,
-162,43,37,53,2,10,222,33,42,80,159,35,44,36,83,158,35,16,2,32,0,
+2,32,0,89,162,43,37,53,2,10,222,33,42,80,159,35,44,36,83,158,35,
-89,162,43,36,43,2,11,222,33,43,80,159,35,45,36,83,158,35,16,2,83,
+16,2,32,0,89,162,43,36,43,2,11,222,33,43,80,159,35,45,36,83,158,
-158,38,20,96,96,2,12,89,162,43,35,43,9,223,0,33,44,89,162,43,36,
+35,16,2,83,158,38,20,96,96,2,12,89,162,43,35,43,9,223,0,33,44,
-44,9,223,0,33,45,89,162,43,37,54,9,223,0,33,46,80,159,35,46,36,
+89,162,43,36,44,9,223,0,33,45,89,162,43,37,54,9,223,0,33,46,80,
-83,158,35,16,2,27,248,22,187,13,248,22,170,7,27,28,249,22,164,8,247,
+159,35,46,36,83,158,35,16,2,27,248,22,188,13,248,22,171,7,27,28,249,
-22,178,7,2,20,6,1,1,59,6,1,1,58,250,22,143,7,6,14,14,40,
+22,165,8,247,22,179,7,2,20,6,1,1,59,6,1,1,58,250,22,144,7,
-91,94,126,97,93,42,41,126,97,40,46,42,41,23,196,2,23,196,1,89,162,
+6,14,14,40,91,94,126,97,93,42,41,126,97,40,46,42,41,23,196,2,23,
-8,44,37,47,2,13,223,0,33,49,80,159,35,47,36,83,158,35,16,2,83,
+196,1,89,162,8,44,37,47,2,13,223,0,33,49,80,159,35,47,36,83,158,
-158,38,20,96,96,2,14,89,162,8,44,38,53,9,223,0,33,54,89,162,43,
+35,16,2,83,158,38,20,96,96,2,14,89,162,8,44,38,53,9,223,0,33,
-37,46,9,223,0,33,55,89,162,43,36,45,9,223,0,33,56,80,159,35,48,
+54,89,162,43,37,46,9,223,0,33,55,89,162,43,36,45,9,223,0,33,56,
-36,83,158,35,16,2,89,162,43,38,51,2,15,223,0,33,58,80,159,35,49,
+80,159,35,48,36,83,158,35,16,2,89,162,43,38,51,2,15,223,0,33,58,
-36,94,29,94,2,16,68,35,37,107,101,114,110,101,108,11,29,94,2,16,69,
+80,159,35,49,36,94,29,94,2,16,68,35,37,107,101,114,110,101,108,11,29,
-35,37,109,105,110,45,115,116,120,11,9,9,9,35,0};
+94,2,16,69,35,37,109,105,110,45,115,116,120,11,9,9,9,35,0};
-    EVAL_ONE_SIZED_STR((char *)expr, 5012);
+    EVAL_ONE_SIZED_STR((char *)expr, 5016);
   }
   {
-    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35,126,7,52,46,49,46,53,46,53,8,0,0,0,1,0,0,6,0,19,0,
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35,126,7,52,46,49,46,53,46,54,8,0,0,0,1,0,0,6,0,19,0,
 34,0,48,0,62,0,76,0,115,0,0,0,6,1,0,0,65,113,117,111,116,
 101,29,94,2,1,67,35,37,117,116,105,108,115,11,29,94,2,1,69,35,37,
 110,101,116,119,111,114,107,11,29,94,2,1,68,35,37,112,97,114,97,109,122,
 11,29,94,2,1,68,35,37,101,120,112,111,98,115,11,29,94,2,1,68,35,
-37,107,101,114,110,101,108,11,97,35,11,8,174,230,98,159,2,2,35,35,159,
+37,107,101,114,110,101,108,11,97,35,11,8,142,234,98,159,2,2,35,35,159,
 2,3,35,35,159,2,4,35,35,159,2,5,35,35,159,2,6,35,35,159,2,
 6,35,35,16,0,159,35,20,103,159,35,16,1,11,16,0,83,158,41,20,100,
 144,69,35,37,98,117,105,108,116,105,110,29,11,11,11,11,11,18,96,11,42,
@@ -360,7 +360,7 @@
     EVAL_ONE_SIZED_STR((char *)expr, 299);
   }
   {
-    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35,126,7,52,46,49,46,53,46,53,52,0,0,0,1,0,0,11,0,38,0,
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35,126,7,52,46,49,46,53,46,54,52,0,0,0,1,0,0,11,0,38,0,
 44,0,57,0,71,0,93,0,119,0,131,0,149,0,169,0,181,0,197,0,220,
 0,0,1,5,1,10,1,15,1,24,1,29,1,60,1,64,1,72,1,81,1,
 89,1,192,1,237,1,1,2,30,2,61,2,117,2,127,2,174,2,184,2,191,
@@ -382,32 +382,32 @@
 110,97,116,105,118,101,64,108,111,111,112,1,29,115,116,97,110,100,97,114,100,
 45,109,111,100,117,108,101,45,110,97,109,101,45,114,101,115,111,108,118,101,114,
 63,108,105,98,67,105,103,110,111,114,101,100,249,22,14,195,80,159,37,45,37,
-249,80,159,37,48,36,195,10,27,28,23,195,2,28,249,22,164,8,23,197,2,
+249,80,159,37,48,36,195,10,27,28,23,195,2,28,249,22,165,8,23,197,2,
-80,158,38,46,87,94,23,195,1,80,158,36,47,27,248,22,173,4,23,197,2,
+80,158,38,46,87,94,23,195,1,80,158,36,47,27,248,22,174,4,23,197,2,
-28,248,22,141,13,23,194,2,91,159,38,11,90,161,38,35,11,248,22,162,13,
+28,248,22,142,13,23,194,2,91,159,38,11,90,161,38,35,11,248,22,163,13,
 23,197,1,87,95,83,160,37,11,80,158,40,46,198,83,160,37,11,80,158,40,
-47,192,192,11,11,28,23,193,2,192,87,94,23,193,1,27,247,22,191,4,28,
+47,192,192,11,11,28,23,193,2,192,87,94,23,193,1,27,247,22,128,5,28,
-192,192,247,22,181,13,20,14,159,80,158,35,39,250,80,158,38,40,249,22,27,
+192,192,247,22,182,13,20,14,159,80,158,35,39,250,80,158,38,40,249,22,27,
-11,80,158,40,39,22,191,4,28,248,22,141,13,23,198,2,23,197,1,87,94,
+11,80,158,40,39,22,128,5,28,248,22,142,13,23,198,2,23,197,1,87,94,
-23,197,1,247,22,181,13,247,194,250,22,159,13,23,197,1,23,199,1,249,80,
+23,197,1,247,22,182,13,247,194,250,22,160,13,23,197,1,23,199,1,249,80,
-158,42,38,23,198,1,2,17,252,22,159,13,23,199,1,23,201,1,2,18,247,
+158,42,38,23,198,1,2,17,252,22,160,13,23,199,1,23,201,1,2,18,247,
-22,179,7,249,80,158,44,38,23,200,1,80,159,44,35,37,87,94,23,194,1,
+22,180,7,249,80,158,44,38,23,200,1,80,159,44,35,37,87,94,23,194,1,
-27,250,22,176,13,196,11,32,0,89,162,8,44,35,40,9,222,11,28,192,249,
+27,250,22,177,13,196,11,32,0,89,162,8,44,35,40,9,222,11,28,192,249,
-22,65,195,194,11,27,252,22,159,13,23,200,1,23,202,1,2,18,247,22,179,
+22,65,195,194,11,27,252,22,160,13,23,200,1,23,202,1,2,18,247,22,180,
-7,249,80,158,45,38,23,201,1,80,159,45,35,37,27,250,22,176,13,196,11,
+7,249,80,158,45,38,23,201,1,80,159,45,35,37,27,250,22,177,13,196,11,
 32,0,89,162,8,44,35,40,9,222,11,28,192,249,22,65,195,194,11,249,247,
-22,186,13,248,22,66,195,195,27,250,22,159,13,23,198,1,23,200,1,249,80,
+22,187,13,248,22,66,195,195,27,250,22,160,13,23,198,1,23,200,1,249,80,
-158,43,38,23,199,1,2,17,27,250,22,176,13,196,11,32,0,89,162,8,44,
+158,43,38,23,199,1,2,17,27,250,22,177,13,196,11,32,0,89,162,8,44,
-35,40,9,222,11,28,192,249,22,65,195,194,11,249,247,22,189,4,248,22,66,
+35,40,9,222,11,28,192,249,22,65,195,194,11,249,247,22,190,4,248,22,66,
-195,195,249,247,22,189,4,194,195,87,94,28,248,80,158,36,37,23,195,2,12,
+195,195,249,247,22,190,4,194,195,87,94,28,248,80,158,36,37,23,195,2,12,
-250,22,132,9,77,108,111,97,100,47,117,115,101,45,99,111,109,112,105,108,101,
+250,22,133,9,77,108,111,97,100,47,117,115,101,45,99,111,109,112,105,108,101,
 100,6,25,25,112,97,116,104,32,111,114,32,118,97,108,105,100,45,112,97,116,
 104,32,115,116,114,105,110,103,23,197,2,91,159,41,11,90,161,36,35,11,28,
-248,22,165,13,23,201,2,23,200,1,27,247,22,191,4,28,23,193,2,249,22,
+248,22,166,13,23,201,2,23,200,1,27,247,22,128,5,28,23,193,2,249,22,
-166,13,23,203,1,23,195,1,200,90,161,38,36,11,248,22,162,13,23,194,2,
+167,13,23,203,1,23,195,1,200,90,161,38,36,11,248,22,163,13,23,194,2,
-87,94,23,196,1,90,161,36,39,11,28,249,22,164,8,23,196,2,68,114,101,
+87,94,23,196,1,90,161,36,39,11,28,249,22,165,8,23,196,2,68,114,101,
 108,97,116,105,118,101,87,94,23,194,1,2,16,23,194,1,90,161,36,40,11,
-247,22,183,13,27,89,162,43,36,49,62,122,111,225,7,5,3,33,27,27,89,
+247,22,184,13,27,89,162,43,36,49,62,122,111,225,7,5,3,33,27,27,89,
 162,43,36,51,9,225,8,6,4,33,28,27,249,22,5,89,162,8,44,36,46,
 9,223,5,33,29,23,203,2,27,28,23,195,1,27,249,22,5,89,162,8,44,
 36,52,9,225,13,11,9,33,30,23,205,2,27,28,23,196,2,11,193,28,192,
@@ -420,10 +420,10 @@
 203,89,162,43,35,45,9,224,15,2,33,33,249,80,159,48,54,36,203,89,162,
 43,35,44,9,224,15,7,33,34,32,36,89,162,8,44,36,54,2,19,222,33,
 38,0,17,35,114,120,34,94,40,46,42,63,41,47,40,46,42,41,36,34,27,
-249,22,191,13,2,37,23,196,2,28,23,193,2,87,94,23,194,1,249,22,65,
+249,22,128,14,2,37,23,196,2,28,23,193,2,87,94,23,194,1,249,22,65,
-248,22,90,23,196,2,27,248,22,99,23,197,1,27,249,22,191,13,2,37,23,
+248,22,90,23,196,2,27,248,22,99,23,197,1,27,249,22,128,14,2,37,23,
 196,2,28,23,193,2,87,94,23,194,1,249,22,65,248,22,90,23,196,2,27,
-248,22,99,23,197,1,27,249,22,191,13,2,37,23,196,2,28,23,193,2,87,
+248,22,99,23,197,1,27,249,22,128,14,2,37,23,196,2,28,23,193,2,87,
 94,23,194,1,249,22,65,248,22,90,23,196,2,248,2,36,248,22,99,23,197,
 1,248,22,75,194,248,22,75,194,248,22,75,194,32,39,89,162,43,36,54,2,
 19,222,33,40,28,248,22,73,248,22,67,23,195,2,249,22,7,9,248,22,66,
@@ -434,97 +434,97 @@
 23,197,2,249,22,7,249,22,65,248,22,66,23,200,1,23,197,1,195,249,22,
 7,249,22,65,248,22,66,23,200,1,23,197,1,195,249,22,7,249,22,65,248,
 22,66,23,200,1,23,197,1,195,27,248,2,36,23,195,1,28,194,192,248,2,
-39,193,87,95,28,248,22,171,4,195,12,250,22,132,9,2,20,6,20,20,114,
+39,193,87,95,28,248,22,172,4,195,12,250,22,133,9,2,20,6,20,20,114,
 101,115,111,108,118,101,100,45,109,111,100,117,108,101,45,112,97,116,104,197,28,
 24,193,2,248,24,194,1,195,87,94,23,193,1,12,27,27,250,22,139,2,80,
-159,41,42,37,248,22,147,14,247,22,188,11,11,28,23,193,2,192,87,94,23,
+159,41,42,37,248,22,148,14,247,22,189,11,11,28,23,193,2,192,87,94,23,
-193,1,27,247,22,123,87,94,250,22,137,2,80,159,42,42,37,248,22,147,14,
+193,1,27,247,22,123,87,94,250,22,137,2,80,159,42,42,37,248,22,148,14,
-247,22,188,11,195,192,250,22,137,2,195,198,66,97,116,116,97,99,104,251,211,
+247,22,189,11,195,192,250,22,137,2,195,198,66,97,116,116,97,99,104,251,211,
-197,198,199,10,28,192,250,22,131,9,11,196,195,248,22,129,9,194,28,249,22,
+197,198,199,10,28,192,250,22,132,9,11,196,195,248,22,130,9,194,28,249,22,
-165,6,194,6,1,1,46,2,16,28,249,22,165,6,194,6,2,2,46,46,62,
+166,6,194,6,1,1,46,2,16,28,249,22,166,6,194,6,2,2,46,46,62,
-117,112,192,28,249,22,166,8,248,22,67,23,200,2,23,197,1,28,249,22,164,
+117,112,192,28,249,22,167,8,248,22,67,23,200,2,23,197,1,28,249,22,165,
-8,248,22,66,23,200,2,23,196,1,251,22,129,9,2,20,6,26,26,99,121,
+8,248,22,66,23,200,2,23,196,1,251,22,130,9,2,20,6,26,26,99,121,
 99,108,101,32,105,110,32,108,111,97,100,105,110,103,32,97,116,32,126,101,58,
 32,126,101,23,200,1,249,22,2,22,67,248,22,80,249,22,65,23,206,1,23,
-202,1,12,12,247,192,20,14,159,80,159,39,44,37,249,22,65,248,22,147,14,
+202,1,12,12,247,192,20,14,159,80,159,39,44,37,249,22,65,248,22,148,14,
-247,22,188,11,23,197,1,20,14,159,80,158,39,39,250,80,158,42,40,249,22,
+247,22,189,11,23,197,1,20,14,159,80,158,39,39,250,80,158,42,40,249,22,
-27,11,80,158,44,39,22,153,4,23,196,1,249,247,22,190,4,23,198,1,248,
+27,11,80,158,44,39,22,154,4,23,196,1,249,247,22,191,4,23,198,1,248,
-22,54,248,22,145,13,23,198,1,87,94,28,28,248,22,141,13,23,197,2,10,
+22,54,248,22,146,13,23,198,1,87,94,28,28,248,22,142,13,23,197,2,10,
-248,22,177,4,23,197,2,12,28,23,198,2,250,22,131,9,11,6,15,15,98,
+248,22,178,4,23,197,2,12,28,23,198,2,250,22,132,9,11,6,15,15,98,
-97,100,32,109,111,100,117,108,101,32,112,97,116,104,23,201,2,250,22,132,9,
+97,100,32,109,111,100,117,108,101,32,112,97,116,104,23,201,2,250,22,133,9,
 2,20,6,19,19,109,111,100,117,108,101,45,112,97,116,104,32,111,114,32,112,
-97,116,104,23,199,2,28,28,248,22,63,23,197,2,249,22,164,8,248,22,66,
+97,116,104,23,199,2,28,28,248,22,63,23,197,2,249,22,165,8,248,22,66,
-23,199,2,2,3,11,248,22,172,4,248,22,90,197,28,28,248,22,63,23,197,
+23,199,2,2,3,11,248,22,173,4,248,22,90,197,28,28,248,22,63,23,197,
-2,249,22,164,8,248,22,66,23,199,2,66,112,108,97,110,101,116,11,87,94,
+2,249,22,165,8,248,22,66,23,199,2,66,112,108,97,110,101,116,11,87,94,
 28,207,12,20,14,159,80,158,37,39,250,80,158,40,40,249,22,27,11,80,158,
-42,39,22,188,11,23,197,1,90,161,36,35,10,249,22,154,4,21,94,2,21,
+42,39,22,189,11,23,197,1,90,161,36,35,10,249,22,155,4,21,94,2,21,
 6,18,18,112,108,97,110,101,116,47,114,101,115,111,108,118,101,114,46,115,115,
 1,27,112,108,97,110,101,116,45,109,111,100,117,108,101,45,110,97,109,101,45,
 114,101,115,111,108,118,101,114,12,251,211,199,200,201,202,87,94,23,193,1,27,
 89,162,8,44,36,45,79,115,104,111,119,45,99,111,108,108,101,99,116,105,111,
 110,45,101,114,114,223,6,33,44,27,28,248,22,53,23,199,2,27,250,22,139,
-2,80,159,43,43,37,249,22,65,23,204,2,247,22,182,13,11,28,23,193,2,
+2,80,159,43,43,37,249,22,65,23,204,2,247,22,183,13,11,28,23,193,2,
 192,87,94,23,193,1,91,159,37,11,90,161,37,35,11,249,80,159,44,48,36,
 248,22,56,23,204,2,11,27,251,80,158,47,50,2,20,23,202,1,28,248,22,
 73,23,199,2,23,199,2,248,22,66,23,199,2,28,248,22,73,23,199,2,9,
-248,22,67,23,199,2,249,22,159,13,23,195,1,28,248,22,73,23,197,1,87,
+248,22,67,23,199,2,249,22,160,13,23,195,1,28,248,22,73,23,197,1,87,
-94,23,197,1,6,7,7,109,97,105,110,46,115,115,249,22,182,6,23,199,1,
+94,23,197,1,6,7,7,109,97,105,110,46,115,115,249,22,183,6,23,199,1,
-6,3,3,46,115,115,28,248,22,159,6,23,199,2,87,94,23,194,1,27,248,
+6,3,3,46,115,115,28,248,22,160,6,23,199,2,87,94,23,194,1,27,248,
 80,159,41,55,36,23,201,2,27,250,22,139,2,80,159,44,43,37,249,22,65,
 23,205,2,23,199,2,11,28,23,193,2,192,87,94,23,193,1,91,159,37,11,
-90,161,37,35,11,249,80,159,45,48,36,23,204,2,11,250,22,1,22,159,13,
+90,161,37,35,11,249,80,159,45,48,36,23,204,2,11,250,22,1,22,160,13,
 23,199,1,249,22,79,249,22,2,32,0,89,162,8,44,36,43,9,222,33,45,
-23,200,1,248,22,75,23,200,1,28,248,22,141,13,23,199,2,87,94,23,194,
+23,200,1,248,22,75,23,200,1,28,248,22,142,13,23,199,2,87,94,23,194,
-1,28,248,22,164,13,23,199,2,23,198,2,248,22,75,6,26,26,32,40,97,
+1,28,248,22,165,13,23,199,2,23,198,2,248,22,75,6,26,26,32,40,97,
 32,112,97,116,104,32,109,117,115,116,32,98,101,32,97,98,115,111,108,117,116,
-101,41,28,249,22,164,8,248,22,66,23,201,2,2,21,27,250,22,139,2,80,
+101,41,28,249,22,165,8,248,22,66,23,201,2,2,21,27,250,22,139,2,80,
-159,43,43,37,249,22,65,23,204,2,247,22,182,13,11,28,23,193,2,192,87,
+159,43,43,37,249,22,65,23,204,2,247,22,183,13,11,28,23,193,2,192,87,
 94,23,193,1,91,159,38,11,90,161,37,35,11,249,80,159,45,48,36,248,22,
 90,23,205,2,11,90,161,36,37,11,28,248,22,73,248,22,92,23,204,2,28,
-248,22,73,23,194,2,249,22,129,14,0,8,35,114,120,34,91,46,93,34,23,
+248,22,73,23,194,2,249,22,130,14,0,8,35,114,120,34,91,46,93,34,23,
 196,2,11,10,27,27,28,23,197,2,249,22,79,28,248,22,73,248,22,92,23,
 208,2,21,93,6,5,5,109,122,108,105,98,249,22,1,22,79,249,22,2,80,
 159,51,56,36,248,22,92,23,211,2,23,197,2,28,248,22,73,23,196,2,248,
 22,75,23,197,2,23,195,2,251,80,158,49,50,2,20,23,204,1,248,22,66,
-23,198,2,248,22,67,23,198,1,249,22,159,13,23,195,1,28,23,198,1,87,
+23,198,2,248,22,67,23,198,1,249,22,160,13,23,195,1,28,23,198,1,87,
 94,23,196,1,23,197,1,28,248,22,73,23,197,1,87,94,23,197,1,6,7,
-7,109,97,105,110,46,115,115,28,249,22,129,14,0,8,35,114,120,34,91,46,
+7,109,97,105,110,46,115,115,28,249,22,130,14,0,8,35,114,120,34,91,46,
-93,34,23,199,2,23,197,1,249,22,182,6,23,199,1,6,3,3,46,115,115,
+93,34,23,199,2,23,197,1,249,22,183,6,23,199,1,6,3,3,46,115,115,
-28,249,22,164,8,248,22,66,23,201,2,64,102,105,108,101,249,22,166,13,248,
+28,249,22,165,8,248,22,66,23,201,2,64,102,105,108,101,249,22,167,13,248,
-22,170,13,248,22,90,23,202,2,248,80,159,42,55,36,23,202,2,12,87,94,
+22,171,13,248,22,90,23,202,2,248,80,159,42,55,36,23,202,2,12,87,94,
-28,28,248,22,141,13,23,194,2,10,248,22,181,7,23,194,2,87,94,23,200,
+28,28,248,22,142,13,23,194,2,10,248,22,182,7,23,194,2,87,94,23,200,
-1,12,28,23,200,2,250,22,131,9,67,114,101,113,117,105,114,101,249,22,143,
+1,12,28,23,200,2,250,22,132,9,67,114,101,113,117,105,114,101,249,22,144,
 7,6,17,17,98,97,100,32,109,111,100,117,108,101,32,112,97,116,104,126,97,
 28,23,198,2,248,22,66,23,199,2,6,0,0,23,203,1,87,94,23,200,1,
-250,22,132,9,2,20,249,22,143,7,6,13,13,109,111,100,117,108,101,32,112,
+250,22,133,9,2,20,249,22,144,7,6,13,13,109,111,100,117,108,101,32,112,
 97,116,104,126,97,28,23,198,2,248,22,66,23,199,2,6,0,0,23,201,2,
-27,28,248,22,181,7,23,195,2,249,22,186,7,23,196,2,35,249,22,168,13,
+27,28,248,22,182,7,23,195,2,249,22,187,7,23,196,2,35,249,22,169,13,
-248,22,169,13,23,197,2,11,27,28,248,22,181,7,23,196,2,249,22,186,7,
+248,22,170,13,23,197,2,11,27,28,248,22,182,7,23,196,2,249,22,187,7,
 23,197,2,36,248,80,158,42,51,23,195,2,91,159,38,11,90,161,38,35,11,
-28,248,22,181,7,23,199,2,250,22,7,2,22,249,22,186,7,23,203,2,37,
+28,248,22,182,7,23,199,2,250,22,7,2,22,249,22,187,7,23,203,2,37,
-2,22,248,22,162,13,23,198,2,87,95,23,195,1,23,193,1,27,28,248,22,
+2,22,248,22,163,13,23,198,2,87,95,23,195,1,23,193,1,27,28,248,22,
-181,7,23,200,2,249,22,186,7,23,201,2,38,249,80,158,47,52,23,197,2,
+182,7,23,200,2,249,22,187,7,23,201,2,38,249,80,158,47,52,23,197,2,
-5,0,27,28,248,22,181,7,23,201,2,249,22,186,7,23,202,2,39,248,22,
+5,0,27,28,248,22,182,7,23,201,2,249,22,187,7,23,202,2,39,248,22,
-172,4,23,200,2,27,27,250,22,139,2,80,159,51,42,37,248,22,147,14,247,
+173,4,23,200,2,27,27,250,22,139,2,80,159,51,42,37,248,22,148,14,247,
-22,188,11,11,28,23,193,2,192,87,94,23,193,1,27,247,22,123,87,94,250,
+22,189,11,11,28,23,193,2,192,87,94,23,193,1,27,247,22,123,87,94,250,
-22,137,2,80,159,52,42,37,248,22,147,14,247,22,188,11,195,192,87,95,28,
+22,137,2,80,159,52,42,37,248,22,148,14,247,22,189,11,195,192,87,95,28,
 23,209,1,27,250,22,139,2,23,197,2,197,11,28,23,193,1,12,87,95,27,
 27,28,248,22,17,80,159,51,45,37,80,159,50,45,37,247,22,19,250,22,25,
-248,22,23,23,197,2,80,159,53,44,37,23,196,1,27,248,22,147,14,247,22,
+248,22,23,23,197,2,80,159,53,44,37,23,196,1,27,248,22,148,14,247,22,
-188,11,249,22,3,83,158,39,20,97,94,89,162,8,44,36,54,9,226,12,11,
+189,11,249,22,3,83,158,39,20,97,94,89,162,8,44,36,54,9,226,12,11,
 2,3,33,46,23,195,1,23,196,1,248,28,248,22,17,80,159,50,45,37,32,
 0,89,162,43,36,41,9,222,33,47,80,159,49,57,36,89,162,43,35,50,9,
 227,14,9,8,4,3,33,48,250,22,137,2,23,197,1,197,10,12,28,28,248,
-22,181,7,23,202,1,11,27,248,22,159,6,23,208,2,28,192,192,27,248,22,
+22,182,7,23,202,1,11,27,248,22,160,6,23,208,2,28,192,192,27,248,22,
-53,23,209,2,28,192,192,28,248,22,63,23,209,2,249,22,164,8,248,22,66,
+53,23,209,2,28,192,192,28,248,22,63,23,209,2,249,22,165,8,248,22,66,
-23,211,2,2,21,11,250,22,137,2,80,159,50,43,37,28,248,22,159,6,23,
+23,211,2,2,21,11,250,22,137,2,80,159,50,43,37,28,248,22,160,6,23,
 210,2,249,22,65,23,211,1,248,80,159,53,55,36,23,213,1,87,94,23,210,
-1,249,22,65,23,211,1,247,22,182,13,252,22,183,7,23,208,1,23,207,1,
+1,249,22,65,23,211,1,247,22,183,13,252,22,184,7,23,208,1,23,207,1,
 23,205,1,23,203,1,201,12,193,91,159,37,10,90,161,36,35,10,11,90,161,
 36,36,10,83,158,38,20,96,96,2,20,89,162,8,44,36,50,9,224,2,0,
 33,42,89,162,43,38,48,9,223,1,33,43,89,162,43,39,8,30,9,225,2,
-3,0,33,49,208,87,95,248,22,152,4,248,80,159,37,49,37,247,22,188,11,
+3,0,33,49,208,87,95,248,22,153,4,248,80,159,37,49,36,247,22,189,11,
-248,22,190,4,80,159,36,36,37,248,22,179,12,80,159,36,41,36,159,35,20,
+248,22,191,4,80,159,36,36,36,248,22,180,12,80,159,36,41,36,159,35,20,
 103,159,35,16,1,11,16,0,83,158,41,20,100,144,66,35,37,98,111,111,116,
 29,11,11,11,11,11,10,36,80,158,35,35,20,103,159,39,16,19,2,1,2,
 2,30,2,4,72,112,97,116,104,45,115,116,114,105,110,103,63,10,30,2,4,
@@ -543,7 +543,7 @@
 83,158,35,16,2,89,162,43,36,44,9,223,0,33,24,80,159,35,56,36,83,
 158,35,16,2,89,162,43,36,48,67,103,101,116,45,100,105,114,223,0,33,25,
 80,159,35,55,36,83,158,35,16,2,89,162,43,37,48,68,119,105,116,104,45,
-100,105,114,223,0,33,26,80,159,35,54,36,83,158,35,16,2,248,22,178,7,
+100,105,114,223,0,33,26,80,159,35,54,36,83,158,35,16,2,248,22,179,7,
 69,115,111,45,115,117,102,102,105,120,80,159,35,35,36,83,158,35,16,2,89,
 162,43,37,59,2,2,223,0,33,35,80,159,35,36,36,83,158,35,16,2,32,
 0,89,162,8,44,36,41,2,6,222,192,80,159,35,41,36,83,158,35,16,2,

src/mzscheme/src/eval.c

@@ -9366,11 +9366,15 @@ static Scheme_Object *add_intdef_renamings(Scheme_Object *l, Scheme_Object *rena
   Scheme_Object *rl = renaming;
 
   if (SCHEME_PAIRP(renaming)) {
+    int need_delim;
+    need_delim = !SCHEME_NULLP(SCHEME_CDR(rl));
+    if (need_delim)
       l = scheme_add_rib_delimiter(l, scheme_null);
     while (!SCHEME_NULLP(rl)) {
       l = scheme_add_rename(l, SCHEME_CAR(rl));
       rl = SCHEME_CDR(rl);
     }
+    if (need_delim)
       l = scheme_add_rib_delimiter(l, renaming);
   } else {
     l = scheme_add_rename(l, renaming);

src/mzscheme/src/module.c

@@ -2734,7 +2734,9 @@ Scheme_Object *scheme_intern_resolved_module_path_worker(Scheme_Object *o)
   rmp->type = scheme_resolved_module_path_type;
   SCHEME_PTR_VAL(rmp) = o;
 
+  scheme_start_atomic();
   b = scheme_bucket_from_table(modpath_table, (const char *)rmp);
+  scheme_end_atomic_no_swap();
   if (!b->val)
     b->val = scheme_true;
 
@@ -9151,6 +9153,7 @@ top_level_require_execute(Scheme_Object *data)
 {
   do_require_execute(scheme_environment_from_dummy(SCHEME_CAR(data)),
                      SCHEME_CDR(data));
+  return scheme_void;
 }
 
 static Scheme_Object *

src/mzscheme/src/schminc.h

@@ -13,7 +13,7 @@
 
 #define USE_COMPILED_STARTUP 1
 
-#define EXPECTED_PRIM_COUNT 950
+#define EXPECTED_PRIM_COUNT 951
 
 #ifdef MZSCHEME_SOMETHING_OMITTED
 # undef USE_COMPILED_STARTUP

src/mzscheme/src/schvers.h

@@ -13,12 +13,12 @@
    consistently.)
 */
 
-#define MZSCHEME_VERSION "4.1.5.5"
+#define MZSCHEME_VERSION "4.2.0.2"
 
 #define MZSCHEME_VERSION_X 4
-#define MZSCHEME_VERSION_Y 1
+#define MZSCHEME_VERSION_Y 2
-#define MZSCHEME_VERSION_Z 5
+#define MZSCHEME_VERSION_Z 0
-#define MZSCHEME_VERSION_W 5
+#define MZSCHEME_VERSION_W 2
 
 #define MZSCHEME_VERSION_MAJOR ((MZSCHEME_VERSION_X * 100) + MZSCHEME_VERSION_Y)
 #define MZSCHEME_VERSION_MINOR ((MZSCHEME_VERSION_Z * 1000) + MZSCHEME_VERSION_W)

src/mzscheme/src/stxobj.c

@@ -65,6 +65,7 @@ static Scheme_Object *module_binding(int argc, Scheme_Object **argv);
 static Scheme_Object *module_trans_binding(int argc, Scheme_Object **argv);
 static Scheme_Object *module_templ_binding(int argc, Scheme_Object **argv);
 static Scheme_Object *module_label_binding(int argc, Scheme_Object **argv);
+static Scheme_Object *identifier_prune(int argc, Scheme_Object **argv);
 static Scheme_Object *syntax_src_module(int argc, Scheme_Object **argv);
 
 static Scheme_Object *syntax_recertify(int argc, Scheme_Object **argv);
@@ -100,6 +101,8 @@ static THREAD_LOCAL Scheme_Object *unsealed_dependencies;
 static THREAD_LOCAL Scheme_Hash_Table *id_marks_ht; /* a cache */
 static THREAD_LOCAL Scheme_Hash_Table *than_id_marks_ht; /* a cache */
 
+static Scheme_Bucket_Table *interned_skip_ribs; /* FIXME: shared among threads */
+
 static Scheme_Object *no_nested_inactive_certs;
 
 #ifdef MZ_PRECISE_GC
@@ -222,6 +225,18 @@ static Module_Renames *krn;
 #define SCHEME_MODIDXP(obj) (SAME_TYPE(SCHEME_TYPE(obj), scheme_module_index_type))
 #define SCHEME_RIB_DELIMP(obj) (SAME_TYPE(SCHEME_TYPE(obj), scheme_rib_delimiter_type))
 
+#define SCHEME_PRUNEP(obj) (SAME_TYPE(SCHEME_TYPE(obj), scheme_prune_context_type))
+
+XFORM_NONGCING static int is_member(Scheme_Object *a, Scheme_Object *l)
+{
+  while (SCHEME_PAIRP(l)) {
+    if (SAME_OBJ(a, SCHEME_CAR(l)))
+      return 1;
+    l = SCHEME_CDR(l);
+  }
+  return 0;
+}
+
 static int is_rename_inspector_info(Scheme_Object *v)
 {
   return (SAME_TYPE(SCHEME_TYPE(v), scheme_inspector_type)
@@ -277,6 +292,10 @@ static int is_rename_inspector_info(Scheme_Object *v)
          when given a list of ribs, and simplifcation eliminates
          rib delimiters
 
+   - A wrap-elem (make-prune <sym>)
+         restricts binding information to that relevant for <sym>
+         as a datum
+
    - A wrap-elem <rename-table> is a module rename set
          the hash table maps renamed syms to modname-srcname pairs
 
@@ -548,6 +567,11 @@ void scheme_init_stx(Scheme_Env *env)
 						    "identifier-label-binding",
 						    1, 1),
 			     env);
+  scheme_add_global_constant("identifier-prune-lexical-context", 
+			     scheme_make_immed_prim(identifier_prune,
+						    "identifier-prune-lexical-context",
+						    1, 2),
+			     env);
 
 
   scheme_add_global_constant("syntax-source-module", 
@@ -610,6 +634,9 @@ void scheme_init_stx(Scheme_Env *env)
 
   scheme_install_type_writer(scheme_free_id_info_type, write_free_id_info_prefix);
   scheme_install_type_reader(scheme_free_id_info_type, read_free_id_info_prefix);
+
+  REGISTER_SO(interned_skip_ribs);
+  interned_skip_ribs = scheme_make_weak_equal_table();
 }
 
 /*========================================================================*/
@@ -1215,6 +1242,17 @@ Scheme_Object *scheme_stx_id_remove_rib(Scheme_Object *stx, Scheme_Object *ro)
   return stx;
 }
 
+static Scheme_Object *make_prune_context(Scheme_Object *a)
+{
+  Scheme_Object *p;
+
+  p = scheme_alloc_small_object();
+  p->type = scheme_prune_context_type;
+  SCHEME_BOX_VAL(p) = a;
+
+  return p;
+}
+
 /******************** module renames ********************/
 
 static int same_phase(Scheme_Object *a, Scheme_Object *b)
@@ -1855,7 +1893,8 @@ static void unmarshal_rename(Module_Renames *mrn,
   if (sealed)
     mrn->sealed = 0;
     
-  for (l = mrn->unmarshal_info; SCHEME_PAIRP(l); l = SCHEME_CDR(l)) {
+  l = scheme_reverse(mrn->unmarshal_info);
+  for (; SCHEME_PAIRP(l); l = SCHEME_CDR(l)) {
     scheme_do_module_rename_unmarshal((Scheme_Object *)mrn, SCHEME_CAR(l),
 				      modidx_shift_from, modidx_shift_to,
 				      export_registry);
@@ -3866,11 +3905,11 @@ static int nonempty_rib(Scheme_Lexical_Rib *rib)
 
 static int in_skip_set(Scheme_Object *timestamp, Scheme_Object *skip_ribs)
 {
-  while (skip_ribs) {
+  if (!skip_ribs)
-    if (SAME_OBJ(SCHEME_CAR(skip_ribs), timestamp))
+    return 0;
+  
+  if (scheme_hash_tree_get((Scheme_Hash_Tree *)skip_ribs, timestamp))
     return 1;
-    skip_ribs = SCHEME_CDR(skip_ribs);
-  }
   
   return 0;
 }
@@ -3879,20 +3918,29 @@ static Scheme_Object *add_skip_set(Scheme_Object *timestamp, Scheme_Object *skip
 {
   if (in_skip_set(timestamp, skip_ribs))
     return skip_ribs;
-  else
+  
-    return scheme_make_raw_pair(timestamp, skip_ribs);
+  if (!skip_ribs)
+    skip_ribs = (Scheme_Object *)scheme_make_hash_tree(1);
+  
+  skip_ribs = (Scheme_Object *)scheme_hash_tree_set((Scheme_Hash_Tree *)skip_ribs, timestamp, scheme_true);
+
+  {
+    Scheme_Bucket *b;
+    scheme_start_atomic();
+    b = scheme_bucket_from_table(interned_skip_ribs, (const char *)skip_ribs);
+    scheme_end_atomic_no_swap();
+    if (!b->val)
+      b->val = scheme_true;
+
+    skip_ribs = (Scheme_Object *)HT_EXTRACT_WEAK(b->key);
+  }
+
+  return skip_ribs;
 }
 
 XFORM_NONGCING static int same_skipped_ribs(Scheme_Object *a, Scheme_Object *b)
 {
-  while (a) {
+  return SAME_OBJ(a, b);
-    if (!b) return 0;
-    if (!SAME_OBJ(SCHEME_CAR(a), SCHEME_CAR(b)))
-      return 0;
-    a = SCHEME_CDR(a);
-    b = SCHEME_CDR(b);
-  }
-  return !b;
 }
 
 XFORM_NONGCING static Scheme_Object *filter_cached_env(Scheme_Object *other_env, Scheme_Object *skip_ribs)
@@ -3913,8 +3961,9 @@ XFORM_NONGCING static Scheme_Object *filter_cached_env(Scheme_Object *other_env,
   if (SCHEME_RPAIRP(other_env)) {
     while (other_env) {
       p = SCHEME_CAR(other_env);
-      if (same_skipped_ribs(SCHEME_CAR(p), skip_ribs))
+      if (same_skipped_ribs(SCHEME_CAR(p), skip_ribs)) {
         return SCHEME_CDR(p);
+      }
       other_env = SCHEME_CDR(other_env);
     }
     return scheme_void;
@@ -3978,6 +4027,36 @@ static Scheme_Object *extend_cached_env(Scheme_Object *orig, Scheme_Object *othe
   return orig;
 }
 
+static void extract_lex_range(Scheme_Object *rename, Scheme_Object *a, int *_istart, int *_iend)
+{
+  int istart, iend, c;
+
+  c = SCHEME_RENAME_LEN(rename);
+
+  if (!SCHEME_FALSEP(SCHEME_VEC_ELS(rename)[1])) {
+    void *pos;
+    pos = scheme_hash_get((Scheme_Hash_Table *)(SCHEME_VEC_ELS(rename)[1]), a);
+    if (pos) {
+      istart = SCHEME_INT_VAL(pos);
+      if (istart < 0) {
+        /* -1 indicates multiple slots matching this name. */
+        istart = 0;
+        iend = c;
+      } else
+        iend = istart + 1;
+    } else {
+      istart = 0;
+      iend = 0;
+    }
+  } else {
+    istart = 0;
+    iend = c;
+  }
+
+  *_istart = istart;
+  *_iend = iend;
+}
+
 /* This needs to be a multiple of 4: */
 #define QUICK_STACK_SIZE 16
 
@@ -4426,6 +4505,7 @@ static Scheme_Object *resolve_env(WRAP_POS *_wraps,
       } else {
 	rename = WRAP_POS_FIRST(wraps);
 	is_rib = NULL;
+        did_rib = NULL;
       }
 
       EXPLAIN(fprintf(stderr, "%d lexical rename (%d) %d %s%s\n", depth, is_rib ? 1 : 0,
@@ -4436,25 +4516,7 @@ static Scheme_Object *resolve_env(WRAP_POS *_wraps,
       c = SCHEME_RENAME_LEN(rename);
 
       /* Get index from hash table, if there is one: */
-      if (!SCHEME_FALSEP(SCHEME_VEC_ELS(rename)[1])) {
+      extract_lex_range(rename, SCHEME_STX_VAL(a), &istart, &iend);
-	void *pos;
-	pos = scheme_hash_get((Scheme_Hash_Table *)(SCHEME_VEC_ELS(rename)[1]), SCHEME_STX_VAL(a));
-	if (pos) {
-	  istart = SCHEME_INT_VAL(pos);
-	  if (istart < 0) {
-	    /* -1 indicates multiple slots matching this name. */
-	    istart = 0;
-	    iend = c;
-	  } else
-	    iend = istart + 1;
-	} else {
-	  istart = 0;
-	  iend = 0;
-	}
-      } else {
-	istart = 0;
-	iend = c;
-      }
 
       for (ri = istart; ri < iend; ri++) {
 	renamed = SCHEME_VEC_ELS(rename)[2+ri];
@@ -4591,6 +4653,7 @@ static Scheme_Object *resolve_env(WRAP_POS *_wraps,
       rib_delim = WRAP_POS_FIRST(wraps);
       if (SCHEME_NULLP(SCHEME_BOX_VAL(rib_delim)))
         rib_delim = scheme_false;
+      did_rib = NULL;
     } else if (SCHEME_NUMBERP(WRAP_POS_FIRST(wraps))) {
       EXPLAIN(fprintf(stderr, "%d mark %p\n", depth, WRAP_POS_FIRST(wraps)));
       did_rib = NULL;
@@ -4613,6 +4676,11 @@ static Scheme_Object *resolve_env(WRAP_POS *_wraps,
 
 	continue; /* <<<<< ------ */
       }
+    } else if (SCHEME_PRUNEP(WRAP_POS_FIRST(wraps))) {
+      if (!is_member(SCHEME_STX_VAL(a), SCHEME_BOX_VAL(WRAP_POS_FIRST(wraps)))) {
+        /* Doesn't match pruned-to sym; already produce #f */
+        return scheme_false;
+      }
     }
 
     if (!rib)
@@ -4859,6 +4927,11 @@ static Scheme_Object *get_module_src_name(Scheme_Object *a, Scheme_Object *orig_
           }
         }
       } while (rib);
+    } else if (SCHEME_PRUNEP(WRAP_POS_FIRST(wraps))) {
+      if (!is_member(SCHEME_STX_VAL(a), SCHEME_BOX_VAL(WRAP_POS_FIRST(wraps)))) {
+        /* Doesn't match pruned-to sym, so no binding */
+        return SCHEME_STX_VAL(a);
+      }
     }
     
     /* Keep looking: */
@@ -5001,7 +5074,7 @@ int scheme_stx_ribs_matter(Scheme_Object *a, Scheme_Object *skip_ribs)
   Scheme_Object *m1, *m2, *skips = NULL;
 
   while (SCHEME_PAIRP(skip_ribs)) {
-    skips = scheme_make_raw_pair(((Scheme_Lexical_Rib *)SCHEME_CAR(skip_ribs))->timestamp,
+    skips = add_skip_set(((Scheme_Lexical_Rib *)SCHEME_CAR(skip_ribs))->timestamp,
                          skips);
     skip_ribs = SCHEME_CDR(skip_ribs);
   }
@@ -5521,15 +5594,49 @@ static Scheme_Object *extract_free_id_info(Scheme_Object *id)
   }
 }
 
-static Scheme_Object *simplify_lex_renames(Scheme_Object *wraps, Scheme_Hash_Table *lex_cache)
+static int not_in_rename(Scheme_Object *constrain_to_syms, Scheme_Object *rename)
+{
+  int istart, iend, ri;
+  Scheme_Object *renamed, *s;
+
+  while (SCHEME_PAIRP(constrain_to_syms)) {
+  
+    s = SCHEME_CAR(constrain_to_syms);
+    extract_lex_range(rename, s, &istart, &iend);
+    
+    for (ri = istart; ri < iend; ri++) {
+      renamed = SCHEME_VEC_ELS(rename)[2+ri];
+      if (SAME_OBJ(renamed, s))
+        return 0;
+    }
+
+    constrain_to_syms = SCHEME_CDR(constrain_to_syms);
+  }
+  
+  return 1;
+}
+
+static int not_in_rib(Scheme_Object *constrain_to_syms, Scheme_Lexical_Rib *rib)
+{
+  for (rib = rib->next; rib; rib = rib->next) {
+    if (!not_in_rename(constrain_to_syms, rib->rename))
+      return 0;
+  }
+  return 1;
+}
+
+#define EXPLAIN_R(x) /* empty */
+
+static Scheme_Object *simplify_lex_renames(Scheme_Object *wraps, Scheme_Hash_Table *lex_cache, 
+                                           Scheme_Object *stx_datum)
 {
   WRAP_POS w, prev, w2;
-  Scheme_Object *stack = scheme_null, *key, *old_key, *prec_ribs = NULL, *prev_prec_ribs;
+  Scheme_Object *stack = scheme_null, *key, *old_key, *prec_ribs, *prev_prec_ribs;
-  Scheme_Object *ribs_stack = scheme_null, *rib_delim = scheme_false;
+  Scheme_Object *ribs_stack = scheme_null, *rib_delim = scheme_false, *constrain_to_syms = NULL;
   Scheme_Object *v, *v2, *v2l, *v2rdl, *stx, *name, *svl, *end_mutable = NULL, **v2_rib_delims = NULL, *svrdl;
   Scheme_Lexical_Rib *did_rib = NULL;
   Scheme_Hash_Table *skip_ribs_ht = NULL, *prev_skip_ribs_ht;
-  int copy_on_write, no_rib_mutation = 1;
+  int copy_on_write, no_rib_mutation = 1, rib_count = 0;
   long size, vsize, psize, i, j, pos;
 
   /* Although it makes no sense to simplify the rename table itself,
@@ -5563,25 +5670,81 @@ static Scheme_Object *simplify_lex_renames(Scheme_Object *wraps, Scheme_Hash_Tab
      the symbol and marks. So, we have to compute that summary as we
      go in. */
 
+  if (SCHEME_SYMBOLP(stx_datum)) {
+    /* Search for prunings */
+    WRAP_POS_INIT(w, wraps);
+    old_key = NULL;
+    prec_ribs = NULL;
+    while (!WRAP_POS_END_P(w)) {
+      if (SCHEME_VECTORP(WRAP_POS_FIRST(w))
+          || SCHEME_RIBP(WRAP_POS_FIRST(w))) {
+        /* Lexical rename --- maybe an already-simplified point  */
+        key = WRAP_POS_KEY(w);
+        if (!SAME_OBJ(key, old_key)) {
+          v = scheme_hash_get(lex_cache, key);
+          if (v && SCHEME_HASHTP(v)) {
+            v = scheme_hash_get((Scheme_Hash_Table *)v, prec_ribs ? prec_ribs : scheme_false);
+          } else if (prec_ribs)
+            v = NULL;
+        } else
+          v = NULL;
+        old_key = key;
+
+        if (v) {
+          /* Tables here are already simplified. */
+          break;
+        }
+
+        if (SCHEME_RIBP(WRAP_POS_FIRST(w))) {
+          Scheme_Lexical_Rib *rib = (Scheme_Lexical_Rib *)WRAP_POS_FIRST(w);
+          if (!nonempty_rib(rib))
+            prec_ribs = add_skip_set(rib->timestamp, prec_ribs);
+        }
+      } else if (SCHEME_PRUNEP(WRAP_POS_FIRST(w))) {
+        v = SCHEME_BOX_VAL(WRAP_POS_FIRST(w));
+        if (is_member(stx_datum, v)) {
+          if (!constrain_to_syms)
+            constrain_to_syms = v;
+          else {
+            v2 = scheme_null;
+            while (SCHEME_PAIRP(v)) {
+              if (is_member(SCHEME_CAR(v), constrain_to_syms))
+                v2 = scheme_make_pair(SCHEME_CAR(v), v2);
+              v = SCHEME_CDR(v);
+            }
+            constrain_to_syms = v2;
+          }
+        } else
+          constrain_to_syms = scheme_null;
+      }
+      WRAP_POS_INC(w);
+    }
+  }
+
   WRAP_POS_INIT(w, wraps);
   WRAP_POS_INIT_END(prev);
 
   old_key = NULL;
+  prec_ribs = NULL;
 
   v2l = scheme_null;
   v2rdl = NULL;
 
   EXPLAIN_S(fprintf(stderr, "[in simplify]\n"));
 
+  EXPLAIN_R(printf("Simplifying %p\n", lex_cache));
+
   while (!WRAP_POS_END_P(w)) {
     if (SCHEME_VECTORP(WRAP_POS_FIRST(w))
 	|| SCHEME_RIBP(WRAP_POS_FIRST(w))) {
       /* Lexical rename */
       key = WRAP_POS_KEY(w);
+      EXPLAIN_R(printf(" key %p\n", key));
       if (!SAME_OBJ(key, old_key)) {
-        if (!prec_ribs)
         v = scheme_hash_get(lex_cache, key);
-        else
+        if (v && SCHEME_HASHTP(v)) {
+          v = scheme_hash_get((Scheme_Hash_Table *)v, prec_ribs ? prec_ribs : scheme_false);
+        } else if (prec_ribs)
           v = NULL;
       } else
 	v = NULL;
@@ -5609,11 +5772,15 @@ static Scheme_Object *simplify_lex_renames(Scheme_Object *wraps, Scheme_Hash_Tab
             return NULL;
           }
           if (SAME_OBJ(did_rib, rib)
-              || !nonempty_rib(rib)) {
+              || !nonempty_rib(rib)
+              || (constrain_to_syms && !not_in_rib(constrain_to_syms, rib))) {
             skip_this = 1;
+            if (!nonempty_rib(rib))
+              prec_ribs = add_skip_set(rib->timestamp, prec_ribs);
             EXPLAIN_S(fprintf(stderr, " to skip %p=%s\n", rib, 
                               scheme_write_to_string(rib->timestamp, NULL)));
           } else {
+            rib_count++;
             did_rib = rib;
             prec_ribs = add_skip_set(rib->timestamp, prec_ribs);
 
@@ -5623,6 +5790,8 @@ static Scheme_Object *simplify_lex_renames(Scheme_Object *wraps, Scheme_Hash_Tab
           
             copy_on_write = 1;
 
+            EXPLAIN_R(printf(" rib %p\n", rib->timestamp));
+
             /* Compute, per id, whether to skip later instances of rib: */
             for (rib = rib->next; rib; rib = rib->next) {
               vsize = SCHEME_RENAME_LEN(rib->rename);
@@ -5636,8 +5805,9 @@ static Scheme_Object *simplify_lex_renames(Scheme_Object *wraps, Scheme_Hash_Tab
                                   scheme_write_to_string(SCHEME_VEC_ELS(rib->rename)[0], NULL)));
 
                 /* already skipped? */
-                if (!skip_ribs_ht
+                if ((!constrain_to_syms || is_member(SCHEME_STX_VAL(stx), constrain_to_syms))
-                    || !scheme_hash_get(skip_ribs_ht, scheme_make_pair(SCHEME_STX_VAL(stx), rib->timestamp))) {
+                    && (!skip_ribs_ht
+                        || !scheme_hash_get(skip_ribs_ht, scheme_make_pair(SCHEME_STX_VAL(stx), rib->timestamp)))) {
                   /* No. Should we skip? */
                   Scheme_Object *other_env;
                   other_env = SCHEME_VEC_ELS(rib->rename)[2+vsize+i];
@@ -5649,6 +5819,11 @@ static Scheme_Object *simplify_lex_renames(Scheme_Object *wraps, Scheme_Hash_Tab
                       scheme_signal_error("compile: unsealed local-definition context found in fully expanded form");
                       return NULL;
                     }
+                    {
+                      Scheme_Object *e;
+                      e = extend_cached_env(SCHEME_VEC_ELS(rib->rename)[2+vsize+i], other_env, prec_ribs, 0);
+                      SCHEME_VEC_ELS(rib->rename)[2+vsize+i] = e;
+                    }
                   }
                   WRAP_POS_INIT(w2, ((Scheme_Stx *)stx)->wraps);
                   if (same_marks(&w2, &w, other_env)) {
@@ -5678,8 +5853,16 @@ static Scheme_Object *simplify_lex_renames(Scheme_Object *wraps, Scheme_Hash_Tab
 	  if ((SCHEME_VEC_SIZE(v) > 2) /* a simplified vec can be empty */
 	      && !SCHEME_SYMBOLP(SCHEME_VEC_ELS(v)[2])) {
 	    add = 1;
+
+            if (constrain_to_syms) {
+              /* Maybe pruned so that we don't need to resolve: */
+              if (not_in_rename(constrain_to_syms, v))
+                skip_this = 1;
             }
           }
+          EXPLAIN_R(printf(" lex reset\n"));
+          did_rib = NULL;
+	}
 
 	if (add) {
           if (skip_this) {
@@ -5709,11 +5892,31 @@ static Scheme_Object *simplify_lex_renames(Scheme_Object *wraps, Scheme_Hash_Tab
       rib_delim = WRAP_POS_FIRST(w);
       if (SCHEME_NULLP(SCHEME_BOX_VAL(rib_delim)))
         rib_delim = scheme_false;
+      if (rib_count > 1) {
+        EXPLAIN_R(if (did_rib) printf("       reset delim %d\n", rib_count));
+        did_rib = NULL;
+      }
+      rib_count = 0;
+    } else if (SCHEME_NUMBERP(WRAP_POS_FIRST(w))) {
+      v = WRAP_POS_FIRST(w);
+      WRAP_POS_COPY(w2, w);
+      WRAP_POS_INC(w2);
+      if (!WRAP_POS_END_P(w2) && SAME_OBJ(v, WRAP_POS_FIRST(w2))) {
+        WRAP_POS_INC(w);
+      } else {
+        EXPLAIN_R(printf("         reset by mark\n"));
+        did_rib = NULL;
+      }
+    } else {
+      EXPLAIN_R(if (did_rib) printf("       reset %d\n", SCHEME_TYPE(WRAP_POS_FIRST(w))));
+      did_rib = NULL;
     }
 
     WRAP_POS_INC(w);
   }
 
+  EXPLAIN_R(printf(" ... phase2\n"));
+
   while (!SCHEME_NULLP(stack)) {
     key = SCHEME_CAR(stack);
     prev_prec_ribs = SCHEME_VEC_ELS(key)[1];
@@ -5803,9 +6006,10 @@ static Scheme_Object *simplify_lex_renames(Scheme_Object *wraps, Scheme_Hash_Tab
 	  name = SCHEME_STX_VAL(stx);
 	  SCHEME_VEC_ELS(v2)[2+pos] = name;
 
-	  if (!rib 
+          if ((!constrain_to_syms || is_member(name, constrain_to_syms))
+              && (!rib
                   || !skip_ribs_ht 
-              || !scheme_hash_get(skip_ribs_ht, scheme_make_pair(name, rib->timestamp))) {
+                  || !scheme_hash_get(skip_ribs_ht, scheme_make_pair(name, rib->timestamp)))) {
 	    /* Either this name is in prev, in which case the answer
 	       must match this rename's target, or this rename's
 	       answer applies. */
@@ -5840,6 +6044,10 @@ static Scheme_Object *simplify_lex_renames(Scheme_Object *wraps, Scheme_Hash_Tab
                   ok = other_env;
                 SCHEME_VEC_ELS(v)[2+vvsize+ii] = ok;
                 ok = NULL;
+              } else {
+                ok = extend_cached_env(SCHEME_VEC_ELS(v)[2+vvsize+ii], other_env, prec_ribs, 0);
+                SCHEME_VEC_ELS(v)[2+vvsize+ii] = ok;
+                ok = NULL;
               }
             }
 
@@ -6044,19 +6252,36 @@ static Scheme_Object *simplify_lex_renames(Scheme_Object *wraps, Scheme_Hash_Tab
       WRAP_POS_DEC(w);
     }
 
-    if (!prev_prec_ribs) {
+    if (!constrain_to_syms) {
-      /* no dependency on ribs, so we can globally cache this result */
+      v = scheme_hash_get(lex_cache, key);
+      if (!v && !prev_prec_ribs) {
+        /* no dependency on ribs, so we can simply cache this result: */
         scheme_hash_set(lex_cache, key, v2l);
+      } else {
+        Scheme_Hash_Table *ht;
+        if (v && SCHEME_HASHTP(v))
+          ht = (Scheme_Hash_Table *)v;
+        else {
+          ht = scheme_make_hash_table(SCHEME_hash_ptr);
+        }
+        if (v && !SCHEME_HASHTP(v))
+          scheme_hash_set(ht, scheme_false, v);
+        scheme_hash_set(ht, prev_prec_ribs ? prev_prec_ribs : scheme_false, v2l);
+        scheme_hash_set(lex_cache, key, (Scheme_Object *)ht);
+      }
       end_mutable = v2l;
     }
 
     stack = SCHEME_CDR(stack);
   }
 
+  EXPLAIN_R(printf(" ... done\n"));
+
   return v2l;
 }
 
-static Scheme_Object *wraps_to_datum(Scheme_Object *w_in, 
+static Scheme_Object *wraps_to_datum(Scheme_Object *stx_datum,
+                                     Scheme_Object *w_in, 
 				     Scheme_Marshal_Tables *mt,
                                      Scheme_Hash_Table *rns,
 				     int just_simplify)
@@ -6064,7 +6289,7 @@ static Scheme_Object *wraps_to_datum(Scheme_Object *w_in,
   Scheme_Object *stack, *a, *old_key, *simplifies = scheme_null, *prec_ribs = scheme_null;
   WRAP_POS w;
   Scheme_Hash_Table *lex_cache, *reverse_map;
-  int stack_size = 0;
+  int stack_size = 0, specific_to_datum = 0;
 
   if (!rns)
     rns = mt->rns;
@@ -6098,8 +6323,11 @@ static Scheme_Object *wraps_to_datum(Scheme_Object *w_in,
     scheme_hash_set(rns, scheme_void, (Scheme_Object *)lex_cache);
   }
 
+  if (!just_simplify)
+    stx_datum = scheme_false;
+
   /* Ensures that all lexical tables in w have been simplified */
-  simplifies = simplify_lex_renames(w_in, lex_cache);
+  simplifies = simplify_lex_renames(w_in, lex_cache, stx_datum);
 
   if (mt)
     scheme_marshal_push_refs(mt);
@@ -6382,6 +6610,16 @@ static Scheme_Object *wraps_to_datum(Scheme_Object *w_in,
       stack_size++;
     } else if (SCHEME_HASHTP(a)) {
       /* chain-specific cache; drop it */
+    } else if (SCHEME_PRUNEP(a)) {
+      if (SCHEME_SYMBOLP(stx_datum)) {
+        /* Assuming that there are lex renames later, then this chain is
+           specific to this wrap. */
+        specific_to_datum = 1;
+      }
+      if (!just_simplify)
+        a = scheme_box(SCHEME_BOX_VAL(a));
+      stack = CONS(a, stack);
+      stack_size++;
     } else {
       /* box, a phase shift */
       /* We used to drop a phase shift if there are no following
@@ -6460,6 +6698,7 @@ static Scheme_Object *wraps_to_datum(Scheme_Object *w_in,
       }
     }
 
+    if (!specific_to_datum)
       scheme_hash_set(reverse_map, stack, w_in);
   }
 
@@ -6487,6 +6726,7 @@ static Scheme_Object *wraps_to_datum(Scheme_Object *w_in,
 
   /* Remember this wrap set: */
   if (just_simplify) {
+    if (!specific_to_datum)
       scheme_hash_set(rns, w_in, stack);
     return stack;
   } else {
@@ -6670,7 +6910,7 @@ static Scheme_Object *syntax_to_datum_inner(Scheme_Object *o,
       if (with_marks) {
         v = extract_for_common_wrap(v, 1, 0);
         if (v && SAME_OBJ(common_wraps, v)) {
-          converted_wraps = wraps_to_datum(stx->wraps, mt, NULL, 0);
+          converted_wraps = wraps_to_datum(scheme_false, stx->wraps, mt, NULL, 0);
           if (SAME_OBJ(common_wraps, converted_wraps))
             lift_common_wraps(first, common_wraps, cnt, 1);
           else
@@ -6688,7 +6928,7 @@ static Scheme_Object *syntax_to_datum_inner(Scheme_Object *o,
 	first = scheme_make_pair(scheme_make_integer(cnt), first);
       }
     } else if (with_marks && SCHEME_TRUEP(common_wraps)) {
-      converted_wraps = wraps_to_datum(stx->wraps, mt, NULL, 0);
+      converted_wraps = wraps_to_datum(scheme_false, stx->wraps, mt, NULL, 0);
       if (SAME_OBJ(common_wraps, converted_wraps))
         lift_common_wraps(first, common_wraps, cnt, 0);
       else
@@ -6750,7 +6990,7 @@ static Scheme_Object *syntax_to_datum_inner(Scheme_Object *o,
 
   if (with_marks > 1) {
     if (!converted_wraps)
-      converted_wraps = wraps_to_datum(stx->wraps, mt, NULL, 0);
+      converted_wraps = wraps_to_datum(stx->val, stx->wraps, mt, NULL, 0);
     result = CONS(result, converted_wraps);
     if (stx->certs) {
       Scheme_Object *cert_marks = scheme_null, *icert_marks = scheme_null;
@@ -7348,9 +7588,19 @@ static Scheme_Object *datum_to_wraps(Scheme_Object *w,
                                             1);
     } else if (SCHEME_SYMBOLP(a)) {
       /* mark barrier */
+    } else if (SCHEME_BOXP(a)) {
+      if (SCHEME_PAIRP(SCHEME_BOX_VAL(a))) {
+        /* prune context */
+        a = make_prune_context(SCHEME_BOX_VAL(a));
       } else {
-      /* must be a box for a phase shift */
+        /* must be a phase shift */
-      /* (or garbage due to a bad .zo, and we'll ignore it) */
+        Scheme_Object *vec;
+        vec = SCHEME_BOX_VAL(a);
+        if (!SCHEME_VECTORP(vec)) return_NULL;
+        if (SCHEME_VEC_SIZE(vec) != 4) return_NULL;
+      }
+    } else {
+      return_NULL;
     }
 
     if (wc)
@@ -7827,7 +8077,7 @@ static void simplify_syntax_inner(Scheme_Object *o,
   scheme_stx_content((Scheme_Object *)stx);
 
   if (rns) {
-    v = wraps_to_datum(stx->wraps, NULL, rns, 1);
+    v = wraps_to_datum(stx->val, stx->wraps, NULL, rns, 1);
     stx->wraps = v;
   }
 
@@ -8638,6 +8888,32 @@ static Scheme_Object *module_label_binding(int argc, Scheme_Object **argv)
   return do_module_binding("identifier-label-binding", argc, argv, scheme_false);
 }
 
+static Scheme_Object *identifier_prune(int argc, Scheme_Object **argv)
+{
+  Scheme_Object *a = argv[0], *p, *l;
+
+  if (!SCHEME_STXP(a) || !SCHEME_STX_SYMBOLP(a))
+    scheme_wrong_type("identifier-prune-lexical-context", "identifier syntax", 0, argc, argv);
+
+  if (argc > 1) {
+    l = argv[1];
+    while (SCHEME_PAIRP(l)) {
+      if (!SCHEME_SYMBOLP(SCHEME_CAR(l)))
+        break;
+      l = SCHEME_CDR(l);
+    }
+    if (!SCHEME_NULLP(l))
+      scheme_wrong_type("identifier-prune-lexical-context", "list of symbols", 1, argc, argv);
+    l = argv[1];
+  } else {
+    l = scheme_make_pair(SCHEME_STX_VAL(a), scheme_null);
+  }
+
+  p = make_prune_context(l);
+
+  return scheme_add_rename(a, p);
+}
+
 static Scheme_Object *syntax_src_module(int argc, Scheme_Object **argv)
 {
   if (!SCHEME_STXP(argv[0]))

src/mzscheme/src/stypes.h

@@ -170,84 +170,85 @@ enum {
   scheme_free_id_info_type,             /* 152 */
   scheme_rib_delimiter_type,            /* 153 */
   scheme_noninline_proc_type,           /* 154 */
+  scheme_prune_context_type,            /* 155 */
 
 #ifdef MZTAG_REQUIRED
-  _scheme_last_normal_type_,            /* 155 */
+  _scheme_last_normal_type_,            /* 156 */
 
-  scheme_rt_weak_array,                 /* 156 */
+  scheme_rt_weak_array,                 /* 157 */
 
-  scheme_rt_comp_env,                   /* 157 */
+  scheme_rt_comp_env,                   /* 158 */
-  scheme_rt_constant_binding,           /* 158 */
+  scheme_rt_constant_binding,           /* 159 */
-  scheme_rt_resolve_info,               /* 159 */
+  scheme_rt_resolve_info,               /* 160 */
-  scheme_rt_optimize_info,              /* 160 */
+  scheme_rt_optimize_info,              /* 161 */
-  scheme_rt_compile_info,               /* 161 */
+  scheme_rt_compile_info,               /* 162 */
-  scheme_rt_cont_mark,                  /* 162 */
+  scheme_rt_cont_mark,                  /* 163 */
-  scheme_rt_saved_stack,                /* 163 */
+  scheme_rt_saved_stack,                /* 164 */
-  scheme_rt_reply_item,                 /* 164 */
+  scheme_rt_reply_item,                 /* 165 */
-  scheme_rt_closure_info,               /* 165 */
+  scheme_rt_closure_info,               /* 166 */
-  scheme_rt_overflow,                   /* 166 */
+  scheme_rt_overflow,                   /* 167 */
-  scheme_rt_overflow_jmp,               /* 167 */
+  scheme_rt_overflow_jmp,               /* 168 */
-  scheme_rt_meta_cont,                  /* 168 */
+  scheme_rt_meta_cont,                  /* 169 */
-  scheme_rt_dyn_wind_cell,              /* 169 */
+  scheme_rt_dyn_wind_cell,              /* 170 */
-  scheme_rt_dyn_wind_info,              /* 170 */
+  scheme_rt_dyn_wind_info,              /* 171 */
-  scheme_rt_dyn_wind,                   /* 171 */
+  scheme_rt_dyn_wind,                   /* 172 */
-  scheme_rt_dup_check,                  /* 172 */
+  scheme_rt_dup_check,                  /* 173 */
-  scheme_rt_thread_memory,              /* 173 */
+  scheme_rt_thread_memory,              /* 174 */
-  scheme_rt_input_file,                 /* 174 */
+  scheme_rt_input_file,                 /* 175 */
-  scheme_rt_input_fd,                   /* 175 */
+  scheme_rt_input_fd,                   /* 176 */
-  scheme_rt_oskit_console_input,        /* 176 */
+  scheme_rt_oskit_console_input,        /* 177 */
-  scheme_rt_tested_input_file,          /* 177 */
+  scheme_rt_tested_input_file,          /* 178 */
-  scheme_rt_tested_output_file,         /* 178 */
+  scheme_rt_tested_output_file,         /* 179 */
-  scheme_rt_indexed_string,             /* 179 */
+  scheme_rt_indexed_string,             /* 180 */
-  scheme_rt_output_file,                /* 180 */
+  scheme_rt_output_file,                /* 181 */
-  scheme_rt_load_handler_data,          /* 181 */
+  scheme_rt_load_handler_data,          /* 182 */
-  scheme_rt_pipe,                       /* 182 */
+  scheme_rt_pipe,                       /* 183 */
-  scheme_rt_beos_process,               /* 183 */
+  scheme_rt_beos_process,               /* 184 */
-  scheme_rt_system_child,               /* 184 */
+  scheme_rt_system_child,               /* 185 */
-  scheme_rt_tcp,                        /* 185 */
+  scheme_rt_tcp,                        /* 186 */
-  scheme_rt_write_data,                 /* 186 */
+  scheme_rt_write_data,                 /* 187 */
-  scheme_rt_tcp_select_info,            /* 187 */
+  scheme_rt_tcp_select_info,            /* 188 */
-  scheme_rt_namespace_option,           /* 188 */
+  scheme_rt_namespace_option,           /* 189 */
-  scheme_rt_param_data,                 /* 189 */
+  scheme_rt_param_data,                 /* 190 */
-  scheme_rt_will,                       /* 190 */
+  scheme_rt_will,                       /* 191 */
-  scheme_rt_struct_proc_info,           /* 191 */
+  scheme_rt_struct_proc_info,           /* 192 */
-  scheme_rt_linker_name,                /* 192 */
+  scheme_rt_linker_name,                /* 193 */
-  scheme_rt_param_map,                  /* 193 */
+  scheme_rt_param_map,                  /* 194 */
-  scheme_rt_finalization,               /* 194 */
+  scheme_rt_finalization,               /* 195 */
-  scheme_rt_finalizations,              /* 195 */
+  scheme_rt_finalizations,              /* 196 */
-  scheme_rt_cpp_object,                 /* 196 */
+  scheme_rt_cpp_object,                 /* 197 */
-  scheme_rt_cpp_array_object,           /* 197 */
+  scheme_rt_cpp_array_object,           /* 198 */
-  scheme_rt_stack_object,               /* 198 */
+  scheme_rt_stack_object,               /* 199 */
-  scheme_rt_preallocated_object,        /* 199 */
+  scheme_rt_preallocated_object,        /* 200 */
-  scheme_thread_hop_type,               /* 200 */
+  scheme_thread_hop_type,               /* 201 */
-  scheme_rt_srcloc,                     /* 201 */
+  scheme_rt_srcloc,                     /* 202 */
-  scheme_rt_evt,                        /* 202 */
+  scheme_rt_evt,                        /* 203 */
-  scheme_rt_syncing,                    /* 203 */
+  scheme_rt_syncing,                    /* 204 */
-  scheme_rt_comp_prefix,                /* 204 */
+  scheme_rt_comp_prefix,                /* 205 */
-  scheme_rt_user_input,                 /* 205 */
+  scheme_rt_user_input,                 /* 206 */
-  scheme_rt_user_output,                /* 206 */
+  scheme_rt_user_output,                /* 207 */
-  scheme_rt_compact_port,               /* 207 */
+  scheme_rt_compact_port,               /* 208 */
-  scheme_rt_read_special_dw,            /* 208 */
+  scheme_rt_read_special_dw,            /* 209 */
-  scheme_rt_regwork,                    /* 209 */
+  scheme_rt_regwork,                    /* 210 */
-  scheme_rt_buf_holder,                 /* 210 */
+  scheme_rt_buf_holder,                 /* 211 */
-  scheme_rt_parameterization,           /* 211 */
+  scheme_rt_parameterization,           /* 212 */
-  scheme_rt_print_params,               /* 212 */
+  scheme_rt_print_params,               /* 213 */
-  scheme_rt_read_params,                /* 213 */
+  scheme_rt_read_params,                /* 214 */
-  scheme_rt_native_code,                /* 214 */
+  scheme_rt_native_code,                /* 215 */
-  scheme_rt_native_code_plus_case,      /* 215 */
+  scheme_rt_native_code_plus_case,      /* 216 */
-  scheme_rt_jitter_data,                /* 216 */
+  scheme_rt_jitter_data,                /* 217 */
-  scheme_rt_module_exports,             /* 217 */
+  scheme_rt_module_exports,             /* 218 */
-  scheme_rt_delay_load_info,            /* 218 */
+  scheme_rt_delay_load_info,            /* 219 */
-  scheme_rt_marshal_info,               /* 219 */
+  scheme_rt_marshal_info,               /* 220 */
-  scheme_rt_unmarshal_info,             /* 220 */
+  scheme_rt_unmarshal_info,             /* 221 */
-  scheme_rt_runstack,                   /* 221 */
+  scheme_rt_runstack,                   /* 222 */
-  scheme_rt_sfs_info,                   /* 222 */
+  scheme_rt_sfs_info,                   /* 223 */
-  scheme_rt_validate_clearing,          /* 223 */
+  scheme_rt_validate_clearing,          /* 224 */
-  scheme_rt_rb_node,                    /* 224 */
+  scheme_rt_rb_node,                    /* 225 */
 #endif
 
-  scheme_place_type,                    /* 225 */
+  scheme_place_type,                    /* 226 */
-  scheme_engine_type,                   /* 226 */
+  scheme_engine_type,                   /* 227 */
 
   _scheme_last_type_
 };

src/mzscheme/src/type.c

@@ -622,6 +622,7 @@ void scheme_register_traversers(void)
 
   GC_REG_TRAV(scheme_rib_delimiter_type, small_object);
   GC_REG_TRAV(scheme_noninline_proc_type, small_object);
+  GC_REG_TRAV(scheme_prune_context_type, small_object);
 }
 
 END_XFORM_SKIP;

src/worksp/mred/mred.manifest

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?> 
 <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0"> 
 <assemblyIdentity 
-version="4.1.5.5" 
+version="4.2.0.2" 
 processorArchitecture="X86" 
 name="Org.PLT-Scheme.MrEd" 
 type="win32" 

src/worksp/mred/mred.rc

@@ -20,8 +20,8 @@ APPLICATION             ICON    DISCARDABLE     "mred.ico"
 //
 
 VS_VERSION_INFO VERSIONINFO
- FILEVERSION 4,1,5,5
+ FILEVERSION 4,2,0,2
- PRODUCTVERSION 4,1,5,5
+ PRODUCTVERSION 4,2,0,2
  FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
  FILEFLAGS 0x1L
@@ -39,11 +39,11 @@ BEGIN
             VALUE "CompanyName", "PLT Scheme Inc.\0"
             VALUE "FileDescription", "PLT Scheme GUI application\0"
             VALUE "InternalName", "MrEd\0"
-            VALUE "FileVersion", "4, 1, 5, 5\0"
+            VALUE "FileVersion", "4, 2, 0, 2\0"
             VALUE "LegalCopyright", "Copyright © 1995-2009\0"
             VALUE "OriginalFilename", "MrEd.exe\0"
             VALUE "ProductName", "PLT Scheme\0"
-            VALUE "ProductVersion", "4, 1, 5, 5\0"
+            VALUE "ProductVersion", "4, 2, 0, 2\0"
         END
     END
     BLOCK "VarFileInfo"

src/worksp/mzcom/mzcom.rc

@@ -53,8 +53,8 @@ END
 //
 
 VS_VERSION_INFO VERSIONINFO
- FILEVERSION 4,1,5,5
+ FILEVERSION 4,2,0,2
- PRODUCTVERSION 4,1,5,5
+ PRODUCTVERSION 4,2,0,2
  FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
  FILEFLAGS 0x1L
@@ -70,12 +70,12 @@ BEGIN
         BLOCK "040904b0"
         BEGIN
             VALUE "FileDescription", "MzCOM Module"
-            VALUE "FileVersion", "4, 1, 5, 5"
+            VALUE "FileVersion", "4, 2, 0, 2"
             VALUE "InternalName", "MzCOM"
             VALUE "LegalCopyright", "Copyright 2000-2009 PLT (Paul Steckler)"
             VALUE "OriginalFilename", "MzCOM.EXE"
             VALUE "ProductName", "MzCOM Module"
-            VALUE "ProductVersion", "4, 1, 5, 5"
+            VALUE "ProductVersion", "4, 2, 0, 2"
         END
     END
     BLOCK "VarFileInfo"
@@ -105,10 +105,10 @@ CAPTION "MzCOM"
 FONT 8, "MS Sans Serif", 0, 0, 0x0
 BEGIN
     DEFPUSHBUTTON   "OK",IDOK,76,69,50,14,BS_CENTER
-    CTEXT           "MzCOM v. 4.1",IDC_STATIC,71,8,61,8
+    CTEXT           "MzCOM v. 4.2",IDC_STATIC,71,8,61,8
     CTEXT           "Copyright (c) 2000-2009 PLT (Paul Steckler)",IDC_STATIC,
                     41,20,146,9
-    CTEXT           "MzScheme v. 4.1",IDC_STATIC,64,35,75,8
+    CTEXT           "MzScheme v. 4.2",IDC_STATIC,64,35,75,8
     CTEXT           "Copyright (c) 1995-2009 PLT Inc.",IDC_STATIC,
                     30,47,143,8
     ICON            MZICON,IDC_STATIC,11,16,20,20

src/worksp/mzcom/mzobj.rgs

@@ -1,19 +1,19 @@
 HKCR
 {
-	MzCOM.MzObj.4.1.5.5 = s 'MzObj Class'
+	MzCOM.MzObj.4.2.0.2 = s 'MzObj Class'
 	{
 		CLSID = s '{A3B0AF9E-2AB0-11D4-B6D2-0060089002FE}'
 	}
 	MzCOM.MzObj = s 'MzObj Class'
 	{
 		CLSID = s '{A3B0AF9E-2AB0-11D4-B6D2-0060089002FE}'
-		CurVer = s 'MzCOM.MzObj.4.1.5.5'
+		CurVer = s 'MzCOM.MzObj.4.2.0.2'
 	}
 	NoRemove CLSID
 	{
 		ForceRemove {A3B0AF9E-2AB0-11D4-B6D2-0060089002FE} = s 'MzObj Class'
 		{
-			ProgID = s 'MzCOM.MzObj.4.1.5.5'
+			ProgID = s 'MzCOM.MzObj.4.2.0.2'
 			VersionIndependentProgID = s 'MzCOM.MzObj'
 			ForceRemove 'Programmable'
 			LocalServer32 = s '%MODULE%'

src/worksp/mzscheme/mzscheme.rc

@@ -29,8 +29,8 @@ APPLICATION             ICON    DISCARDABLE     "mzscheme.ico"
 //
 
 VS_VERSION_INFO VERSIONINFO
- FILEVERSION 4,1,5,5
+ FILEVERSION 4,2,0,2
- PRODUCTVERSION 4,1,5,5
+ PRODUCTVERSION 4,2,0,2
  FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
  FILEFLAGS 0x1L
@@ -48,11 +48,11 @@ BEGIN
             VALUE "CompanyName", "PLT Scheme Inc.\0"
             VALUE "FileDescription", "PLT Scheme application\0"
             VALUE "InternalName", "MzScheme\0"
-            VALUE "FileVersion", "4, 1, 5, 5\0"
+            VALUE "FileVersion", "4, 2, 0, 2\0"
             VALUE "LegalCopyright", "Copyright <20>© 1995-2009\0"
             VALUE "OriginalFilename", "mzscheme.exe\0"
             VALUE "ProductName", "PLT Scheme\0"
-            VALUE "ProductVersion", "4, 1, 5, 5\0"
+            VALUE "ProductVersion", "4, 2, 0, 2\0"
         END
     END
     BLOCK "VarFileInfo"

src/worksp/starters/start.rc

@@ -22,8 +22,8 @@ APPLICATION             ICON    DISCARDABLE     "mzstart.ico"
 //
 
 VS_VERSION_INFO VERSIONINFO
- FILEVERSION 4,1,5,5
+ FILEVERSION 4,2,0,2
- PRODUCTVERSION 4,1,5,5
+ PRODUCTVERSION 4,2,0,2
  FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
  FILEFLAGS 0x1L
@@ -45,7 +45,7 @@ BEGIN
 #ifdef MZSTART
             VALUE "FileDescription", "PLT Scheme Launcher\0"
 #endif
-            VALUE "FileVersion", "4, 1, 5, 5\0"
+            VALUE "FileVersion", "4, 2, 0, 2\0"
 #ifdef MRSTART
             VALUE "InternalName", "mrstart\0"
 #endif
@@ -60,7 +60,7 @@ BEGIN
             VALUE "OriginalFilename", "MzStart.exe\0"
 #endif
             VALUE "ProductName", "PLT Scheme\0"
-            VALUE "ProductVersion", "4, 1, 5, 5\0"
+            VALUE "ProductVersion", "4, 2, 0, 2\0"
         END
     END
     BLOCK "VarFileInfo"