diff --git a/collects/mzlib/cm.ss b/collects/mzlib/cm.ss
index 931ce71f3a..64df0367ed 100644
--- a/collects/mzlib/cm.ss
+++ b/collects/mzlib/cm.ss
@@ -25,11 +25,11 @@
       (x (apply max x))))
   
   (define (get-deps code path)
-    (let-values ([(imports fs-imports ft-imports fl-imports) (module-compiled-imports code)])
+    (let-values ([(imports) (apply append (map cdr (module-compiled-imports code)))])
       (map path->bytes
            (let ([l (map (lambda (x)
                            (resolve-module-path-index x path))
-                         (append imports fs-imports ft-imports fl-imports))])
+                         imports)])
              ;; Filter symbols:
              (let loop ([l l])
                (cond
diff --git a/collects/mzlib/match.ss b/collects/mzlib/match.ss
index 8d99336d09..1cbc47dd5a 100644
--- a/collects/mzlib/match.ss
+++ b/collects/mzlib/match.ss
@@ -133,7 +133,6 @@
 	    "private/match/match-error.ss"
 	    "private/match/test-no-order.ss")
   
-  
   (define-syntax match-definer
     (syntax-rules ()
       [(match-definer name clauses ...)
diff --git a/collects/rnrs/base-6.ss b/collects/rnrs/base-6.ss
index 36d3687ab2..dff5488b89 100644
--- a/collects/rnrs/base-6.ss
+++ b/collects/rnrs/base-6.ss
@@ -9,7 +9,7 @@
 (provide 
  ;; PLT Scheme pre-requisites:
  (rename-out [datum #%datum])
- #%app
+ #%app #%top #%top-interaction
 
  ;; 11.2
  (rename-out [r5rs:define define]
diff --git a/collects/scheme/private/old-rp.ss b/collects/scheme/private/old-rp.ss
index cd0e672170..2634ece8ff 100644
--- a/collects/scheme/private/old-rp.ss
+++ b/collects/scheme/private/old-rp.ss
@@ -38,13 +38,13 @@
                   (if for-stx
                       (with-syntax ([for for-stx])
                         (syntax/loc stx
-                          (#%require (for elem ...))))
+                          (#%require (for-meta for (just-meta 0 elem ...)))))
                       (syntax/loc stx
                         (#%require elem ...)))])))])
       (values (mk #f)
-              (mk #'for-syntax)
-              (mk #'for-template)
-              (mk #'for-label))))
+              (mk #'1)
+              (mk #'-1)
+              (mk #'#f))))
 
   (define-syntaxes (provide provide-for-syntax provide-for-label)
     (let ([mk
diff --git a/collects/scheme/private/reqprov.ss b/collects/scheme/private/reqprov.ss
index cd3cf1e474..fbbf6b8060 100644
--- a/collects/scheme/private/reqprov.ss
+++ b/collects/scheme/private/reqprov.ss
@@ -8,9 +8,9 @@
                          "struct-info.ss"))
   
   (#%provide lib file planet
-             for-syntax for-template for-label
+             for-syntax for-template for-label for-meta
              require
-             only-in rename-in prefix-in except-in
+             only-in rename-in prefix-in except-in only-meta-in
              provide
              all-defined-out all-from-out
              rename-out except-out prefix-out struct-out
@@ -31,7 +31,7 @@
   (define-for-syntax (xlate-path stx)
     (if (pair? (syntax-e stx))
         (let ([kw
-               ;; free-identifier=? identifers are not necessarily module=?
+               ;; symbolic-identifier=? identifers are not necessarily free-identifier=?
                (syntax-case stx (lib planet file quote)
                  [(quote . _) 'quote]
                  [(lib . _) 'lib]
@@ -57,26 +57,27 @@
   (define-syntaxes (lib file planet)
     (let ([t (lambda (stx)
                (check-lib-form stx)
-               (let*-values ([(mod-path) (syntax->datum stx)]
-                             [(names et-names lt-names) (syntax-local-module-exports stx)])
+               (let* ([mod-path (syntax->datum stx)]
+                      [namess (syntax-local-module-exports stx)])
                  (values
                   (apply
                    append
-                   (map (lambda (names mode)
-                          (map (lambda (name)
-                                 (make-import (datum->syntax
-                                               stx
-                                               name
-                                               stx)
-                                              name
-                                              mod-path
-                                              mode
-                                              'run
-                                              stx))
-                               names))
-                        (list names et-names lt-names)
-                        (list 'run 'syntax 'label)))
-                  (list (make-import-source stx 'run)))))])
+                   (map (lambda (names)
+                          (let ([mode (car names)])
+                            (map (lambda (name)
+                                   (make-import (datum->syntax
+                                                 stx
+                                                 name
+                                                 stx)
+                                                name
+                                                mod-path
+                                                mode
+                                                0
+                                                mode
+                                                stx))
+                                 (cdr names))))
+                        namess))
+                  (list (make-import-source stx 0)))))])
       (let ([t2
              (let-values ([(s: mk s? s-ref s-set!)
                            (make-struct-type 'req+prov
@@ -96,6 +97,9 @@
   ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   ;; for-syntax, for-template, for-label
 
+  (define-for-syntax (phase+ a b)
+    (and a b (+ a b)))
+
   (define-for-syntax (shift-subs stx mode)
     (syntax-case stx ()
       [(_ in ...)
@@ -110,18 +114,17 @@
                         (make-import (import-local-id import)
                                      (import-src-sym import)
                                      (import-src-mod-path import)
-                                     mode
-                                     mode
+                                     (phase+ mode (import-mode import))
+                                     (phase+ mode (import-req-mode import))
+                                     (import-orig-mode import)
                                      (import-orig-stx import)))
-                      (filter (lambda (import)
-                                (eq? (import-mode import) 'run))
-                              imports))
+                      imports)
                  (map (lambda (source)
-                        (make-import-source (import-source-mod-path-stx source)
-                                            mode))
-                      (filter (lambda (source)
-                                (eq? (import-source-mode source) 'run))
-                              sources))))]))
+                        (make-import-source 
+                         (import-source-mod-path-stx source)
+                         (phase+ mode
+                                 (import-source-mode source))))
+                      sources)))]))
 
   (define-for-syntax (make-require+provide-transformer r p)
     (let-values ([(s: mk s? s-ref s-set!)
@@ -149,21 +152,50 @@
   (define-syntax for-syntax
     (make-require+provide-transformer
      (lambda (stx)
-       (shift-subs stx 'syntax))
+       (shift-subs stx 1))
      (lambda (stx modes)
-       (exports-at-phase stx modes 'syntax))))
+       (exports-at-phase stx modes 1))))
   
   (define-syntax for-template
-    (make-require-transformer
+    (make-require+provide-transformer
      (lambda (stx)
-       (shift-subs stx 'template))))
+       (shift-subs stx -1))
+     (lambda (stx modes)
+       (exports-at-phase stx modes -1))))
   
   (define-syntax for-label
     (make-require+provide-transformer
      (lambda (stx)
-       (shift-subs stx 'label))
+       (shift-subs stx #f))
      (lambda (stx modes)
-       (exports-at-phase stx modes 'label))))
+       (exports-at-phase stx modes #f))))
+  
+  (define-syntax for-meta
+    (make-require+provide-transformer
+     (lambda (stx)
+       (syntax-case stx ()
+         [(_ mode in ...)
+          (let ([base-mode (syntax-e #'mode)])
+            (unless (or (not base-mode)
+                        (exact-integer? base-mode))
+              (raise-syntax-error
+               #f
+               "phase level must be #f or an exact integer"
+               stx
+               #'mode))
+            (shift-subs #'(for-meta in ...) base-mode))]))
+     (lambda (stx modes)
+       (syntax-case stx ()
+         [(_ mode out ...)
+          (let ([base-mode (syntax-e #'mode)])
+            (unless (or (not base-mode)
+                        (exact-integer? base-mode))
+              (raise-syntax-error
+               #f
+               "phase level must be #f or an exact integer"
+               stx
+               #'mode))
+            (exports-at-phase #'(for-meta out ...) modes base-mode))]))))
   
   ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   ;; require
@@ -176,11 +208,8 @@
     (letrec ([mode-wrap
               (lambda (mode base)
                 (cond
-                  [(eq? mode 'run) base]
-                  [(eq? mode 'syntax) #`(for-syntax #,base)]
-                  [(eq? mode 'template) #`(for-template #,base)]
-                  [(eq? mode 'label) #`(for-label #,base)]
-                  [else (error "huh?" mode)]))]
+                  [(eq? mode 0) base]
+                  [else #`(for-meta #,mode #,base)]))]
              [simple-path? (lambda (p)
                              (syntax-case p (lib quote)
                                [(lib . _)
@@ -249,27 +278,17 @@
                        ;; TODO: collapse back to simple cases when possible
                        (append
                         (map (lambda (import)
-                               (mode-wrap (if (eq? base-mode 'run)
-                                              (import-req-mode import)
-                                              base-mode)
-                                          #`(rename #,(import-src-mod-path import)
-                                                    #,(import-local-id import)
-                                                    #,(import-src-sym import))))
-                             (if (eq? base-mode 'run)
-                                 imports
-                                 (filter (lambda (import)
-                                           (eq? (import-mode import) 'run))
-                                         imports)))
+                               #`(just-meta
+                                  #,(import-orig-mode import)
+                                  #,(mode-wrap (phase+ base-mode (import-req-mode import))
+                                               #`(rename #,(import-src-mod-path import)
+                                                         #,(import-local-id import)
+                                                         #,(import-src-sym import)))))
+                             imports)
                         (map (lambda (src)
-                               (mode-wrap (if (eq? base-mode 'run)
-                                              (import-source-mode src)
-                                              base-mode)
+                               (mode-wrap (phase+ base-mode (import-source-mode src))
                                           #`(only #,(import-source-mod-path-stx src))))
-                             (if (eq? base-mode 'run)
-                                 sources
-                                 (filter (lambda (source)
-                                           (eq? (import-source-mode source) 'run))
-                                         sources)))))]))]
+                             sources)))]))]
              [transform-one
               (lambda (in)
                 ;; Recognize `for-syntax', etc. for simple cases:
@@ -283,13 +302,13 @@
                                  (transform-simple in
                                                    (cond
                                                     [(free-identifier=? #'for-something #'for-syntax)
-                                                     'syntax]
+                                                     1]
                                                     [(free-identifier=? #'for-something #'for-template)
-                                                     'template]
+                                                     -1]
                                                     [(free-identifier=? #'for-something #'for-label)
-                                                     'label])))
+                                                     #f])))
                                (syntax->list #'(elem ...))))]
-                  [_ (transform-simple in 'run)]))])
+                  [_ (transform-simple in 0 #| run phase |#)]))])
       (syntax-case stx ()
         [(_ in ...)
          (with-syntax ([(new-in ...)
@@ -339,26 +358,32 @@
                    stx
                    dup-id)))
               (values
-               (map (lambda (new-id orig-id)
-                      (or (ormap (lambda (import)
-                                   (and (free-identifier=? orig-id
-                                                             (import-local-id import))
-                                        (if (eq? new-id orig-id)
-                                            import
-                                            (make-import new-id
-                                                         (import-src-sym import)
-                                                         (import-src-mod-path import)
-                                                         (import-mode import)
-                                                         (import-req-mode import)
-                                                         new-id))))
-                                 imports)
-                          (raise-syntax-error
-                           #f
-                           (format "identifier `~a' not included in nested require spec"
-                                   (syntax-e orig-id))
-                           stx
-                           #'in)))
-                    new-ids orig-ids)
+               (apply
+                append
+                (map (lambda (new-id orig-id)
+                       (let ([l (filter
+                                 values
+                                 (map (lambda (import)
+                                        (and (free-identifier=? orig-id (import-local-id import)) ; don't compare at mode
+                                             (if (eq? new-id orig-id)
+                                                 import
+                                                 (make-import new-id
+                                                              (import-src-sym import)
+                                                              (import-src-mod-path import)
+                                                              (import-mode import)
+                                                              (import-req-mode import)
+                                                              (import-orig-mode import)
+                                                              new-id))))
+                                      imports))])
+                         (if (null? l)
+                             (raise-syntax-error
+                              #f
+                              (format "identifier `~a' not included in nested require spec"
+                                      (syntax-e orig-id))
+                              stx
+                              #'in)
+                             l)))
+                     new-ids orig-ids))
                sources)))]))))
 
   (define-syntax except-in
@@ -402,6 +427,31 @@
                      imports)
              sources))]))))
 
+  (define-syntax only-meta-in
+    (make-require-transformer
+     (lambda (stx)
+       (syntax-case stx ()
+         [(_ mode in ...)
+          (let ([base-mode (syntax-e #'mode)])
+            (unless (or (not base-mode)
+                        (exact-integer? base-mode))
+              (raise-syntax-error
+               #f
+               "phase level must be #f or an exact integer"
+               stx
+               #'mode))
+            (let ([subs
+                   (map (lambda (in)
+                          (let-values ([(imports sources) (expand-import in)])
+                            (cons
+                             (filter (lambda (import)
+                                       (equal? (import-mode import) base-mode))
+                                     imports)
+                             sources)))
+                        (syntax->list #'(in ...)))])
+              (values (apply append (map car subs))
+                      (apply append (map cdr subs)))))]))))
+
   (define-syntax rename-in
     (make-require-transformer
      (lambda (stx)
@@ -444,6 +494,7 @@
                                                (import-src-mod-path import)
                                                (import-mode import)
                                                (import-req-mode import)
+                                               (import-orig-mode import)
                                                bind-id)
                                   import)))
                         orig-ids bind-ids)])
@@ -500,6 +551,7 @@
                                    (import-src-mod-path import)
                                    (import-mode import)
                                    (import-req-mode import)
+                                   (import-orig-mode import)
                                    (import-orig-stx import))))
                   imports)
              sources))]))))
@@ -538,9 +590,8 @@
                                   [mode (export-mode export)])
                               (let ([phased
                                      (cond
-                                      [(eq? mode 'run) base]
-                                      [(eq? mode 'syntax) #`(for-syntax #,base)]
-                                      [(eq? mode 'label) #`(for-label #,base)])])
+                                      [(eq? mode 0) base]
+                                      [else #`(for-meta #,mode #,base)])])
                                 (if (export-protect? export)
                                     #`(protect #,phased)
                                     phased))))
@@ -569,16 +620,16 @@
                                                             stx
                                                             (syntax-e id)))))])
             (append
-             (if (memq 'syntax modes)
+             (if (memq 1 modes)
                  (map (lambda (id)
-                        (make-export id (syntax-e id) 'syntax #f stx))
+                        (make-export id (syntax-e id) 1 #f stx))
                       (filter (same-ctx? free-transformer-identifier=?)
                               stx-ids))
                  null)
              (if (or (null? modes)
-                     (memq 'run modes))
+                     (memq 0 modes))
                  (map (lambda (id)
-                        (make-export id (syntax-e id) 'run #f stx))
+                        (make-export id (syntax-e id) 0 #f stx))
                       (filter (same-ctx? free-identifier=?)
                               ids))
                  null)))]))))
@@ -598,61 +649,42 @@
                  "bad module path"
                  stx
                  mp))
-              (let-values ([(ids stx-ids label-ids) 
-                            (syntax-local-module-required-identifiers (syntax->datum mp) 
-                                                                      (or (null? modes)
-                                                                          (memq 'run modes))
-                                                                      (memq 'syntax modes)
-                                                                      (memq 'label modes))]
-                           [(ok-context?) (lambda (id id=?)
-                                            (id=? id
-                                                  (datum->syntax mp (syntax-e id))))]) 
-                (when (or (null? modes) 
-                          (memq 'run modes))
-                  (unless ids
-                    (raise-syntax-error
-                     #f
-                     "no corresponding require"
-                     stx
-                     mp)))
-                (when (memq 'syntax modes)
-                  (unless stx-ids
-                    (raise-syntax-error
-                     #f
-                     "no corresponding for-syntax require"
-                     stx
-                     mp)))
-                (when (memq 'label modes)
-                  (unless label-ids
-                    (raise-syntax-error
-                     #f
-                     "no corresponding for-label require"
-                     stx
-                     mp)))
+              (let ([idss
+                     (apply
+                      append
+                      (map (lambda (mode)
+                             (let ([r (syntax-local-module-required-identifiers (syntax->datum mp) 
+                                                                                mode)])
+                               (or r
+                                   (raise-syntax-error
+                                    #f
+                                    (format "no corresponding require~a"
+                                            (cond
+                                             [(eq? mode 0) ""]
+                                             [(not mode)
+                                              " at the label phase level"]
+                                             [else
+                                              (format " at phase level ~a" mode)]))
+                                    stx
+                                    mp))))
+                           (if (null? modes)
+                               '(0)
+                               modes)))]
+                    [ok-context? (lambda (id id=?)
+                                   (id=? id
+                                         (datum->syntax mp (syntax-e id))))]) 
                 (filter
                  values
-                 (append
-                  (map (lambda (id)
-                         (and (ok-context? id free-transformer-identifier=?)
-                              (make-export id (syntax-e id) 'syntax #f stx)))
-                       (if (or (null? modes)
-                               (memq 'syntax modes))
-                           (or stx-ids null)
-                           null))
-                  (map (lambda (id)
-                         (and (ok-context? id free-label-identifier=?)
-                              (make-export id (syntax-e id) 'label #f stx)))
-                       (if (or (null? modes)
-                               (memq 'label modes))
-                           (or label-ids null)
-                           null))
-                  (map (lambda (id)
-                         (and (ok-context? id free-identifier=?)
-                              (make-export id (syntax-e id) 'run #f stx)))
-                       (if (or (null? modes)
-                               (memq 'run modes))
-                           ids
-                           null))))))
+                 (apply
+                  append
+                  (map (lambda (ids)
+                         (let ([mode (car ids)])
+                           (map (lambda (id)
+                                  (and (free-identifier=? id (datum->syntax mp (syntax-e id))
+                                                          mode)
+                                       (make-export id (syntax-e id) mode #f stx)))
+                                (cdr ids))))
+                       idss)))))
             (syntax->list #'(mp ...))))]))))
   
   (define-syntax rename-out
@@ -672,12 +704,16 @@
                       (append orig-ids bind-ids))
             (apply
              append
-             (map (lambda (mode identifier-binding env-desc)
+             (map (lambda (mode)
                     (map (lambda (orig-id bind-id)
-                           (unless (list? (identifier-binding orig-id))
+                           (unless (list? (identifier-binding orig-id mode))
                              (raise-syntax-error
                               #f
-                              (format "no binding~a for identifier" env-desc)
+                              (format "no binding~a for identifier"
+                                      (cond
+                                       [(eq? mode 0) ""]
+                                       [(not mode) " in the label phase level"]
+                                       [(not mode) (format " at phase level ~a" mode)]))
                               stx
                               orig-id))
                            (make-export orig-id
@@ -687,24 +723,8 @@
                                         bind-id))
                          orig-ids bind-ids))
                   (if (null? modes)
-                      '(run)
-                      modes)
-                  (if (null? modes)
-                      (list identifier-binding)
-                      (map (lambda (mode)
-                             (cond
-                              [(eq? mode 'run) identifier-binding]
-                              [(eq? mode 'syntax) identifier-transformer-binding]
-                              [(eq? mode 'label) identifier-label-binding]))
-                           modes))
-                  (if (null? modes)
-                      (list "")
-                      (map (lambda (mode)
-                             (cond
-                              [(eq? mode 'run) ""]
-                              [(eq? mode 'syntax) " for-syntax"]
-                              [(eq? mode 'label) " for-label"]))
-                           modes)))))]))))
+                      '(0)
+                      modes))))]))))
 
   (define-syntax except-out
     (make-provide-transformer
@@ -728,26 +748,22 @@
                  "duplicate identifier"
                  stx
                  dup-id)))
-            (map (lambda (id)
-                   (or (ormap (lambda (export)
-                                (free-identifier=? id (export-local-id export)))
-                              exports)
-                       (raise-syntax-error
-                        #f
-                        (format "identifier `~a' not included in nested provide spec"
-                                (syntax-e id))
-                        stx
-                        #'out)))
-                 ids)
+            (for-each (lambda (id)
+                        (or (ormap (lambda (export)
+                                     (free-identifier=? id (export-local-id export)
+                                                        (export-mode export)))
+                                   exports)
+                            (raise-syntax-error
+                             #f
+                             (format "identifier `~a' not included in nested provide spec"
+                                     (syntax-e id))
+                             stx
+                             #'out)))
+                      ids)
             (filter (lambda (export)
                       (not (ormap (lambda (id)
-                                    ((let ([mode (export-mode export)])
-                                       (cond
-                                        [(eq? mode 'run) free-identifier=?]
-                                        [(eq? mode 'syntax) free-transformer-identifier=?]
-                                        [(eq? mode 'label) free-label-identifier=?]))
-                                     id 
-                                     (export-local-id export)))
+                                    (free-identifier=? id (export-local-id export)
+                                                       (export-mode export)))
                                   ids)))
                     exports))]))))
 
@@ -767,10 +783,10 @@
     (make-provide-transformer
      (lambda (stx modes)
        (unless (or (null? modes)
-                   (memq 'run modes))
+                   (equal? '(0) modes))
          (raise-syntax-error
           #f
-          "allowed only for run-time bindings"
+          "allowed only for phase level 0"
           stx))
        (syntax-case stx ()
          [(_ id)
@@ -805,9 +821,13 @@
                          ;; used a lot.
                          [avail-ids (append (let-values ([(ids _) (syntax-local-module-defined-identifiers)])
                                               ids)
-                                            (let-values ([(ids _ __)
-                                                          (syntax-local-module-required-identifiers #f #t #f #f)])
-                                              ids))]
+                                            (let ([idss (syntax-local-module-required-identifiers #f #t)])
+                                              (if idss
+                                                  (let ([a (assoc 0 idss)])
+                                                    (if a
+                                                        (cdr a)
+                                                        null))
+                                                  null)))]
                          [find-imported/defined (lambda (id)
                                                   (let ([ids (filter (lambda (id2)
                                                                        (and (free-identifier=? id2 id)
@@ -839,7 +859,7 @@
                                  (let ([id (find-imported/defined id)])
                                    (make-export id
                                                 (syntax-e id)
-                                                'run
+                                                0
                                                 #f
                                                 id))))
                           (append
diff --git a/collects/scheme/provide-transform.ss b/collects/scheme/provide-transform.ss
index b4bf94cb71..304d3a750a 100644
--- a/collects/scheme/provide-transform.ss
+++ b/collects/scheme/provide-transform.ss
@@ -19,8 +19,9 @@
                 (raise-type-error 'make-export "identifier" i))
               (unless (symbol? s)
                 (raise-type-error 'make-export "symbol" s))
-              (unless (memq mode '(run syntax label))
-                (raise-type-error 'make-export "'run, 'syntax, or 'label" mode))
+              (unless (or (not mode)
+                          (exact-integer? mode))
+                (raise-type-error 'make-export "exact integer or #f" mode))
               (unless (syntax? stx)
                 (raise-type-error 'make-export "syntax" stx))
               (values i s mode (and protect? #t) stx)))
@@ -42,9 +43,9 @@
          (map (lambda (mode)
                 (list (make-export stx (syntax-e stx) mode #f stx)))
               (if (null? modes)
-                  '(run)
+                  '(0)
                   modes)))
-        (syntax-case stx (lib)
+        (syntax-case stx ()
           [(id . rest)
            (identifier? #'id)
            (let ([t (syntax-local-value #'id (lambda () #f))])
diff --git a/collects/scheme/require-transform.ss b/collects/scheme/require-transform.ss
index 71cc792c70..2e474399d6 100644
--- a/collects/scheme/require-transform.ss
+++ b/collects/scheme/require-transform.ss
@@ -12,34 +12,46 @@
              make-require-transformer prop:require-transformer require-transformer?
              ;; the import struct type:
              import struct:import make-import import?
-             import-local-id import-src-sym import-src-mod-path import-orig-stx import-mode import-req-mode
+             import-local-id import-src-sym import-src-mod-path import-orig-stx import-mode import-req-mode import-orig-mode
              ;; the import-source struct type:
              import-source struct:import-source make-import-source import-source?
              import-source-mod-path-stx import-source-mode)
   
-  (define-struct* import (local-id src-sym src-mod-path mode req-mode orig-stx)
-    #:guard (lambda (i s path mode req-mode stx info)
+  (define-struct* import (local-id src-sym src-mod-path mode req-mode orig-mode orig-stx)
+    #:guard (lambda (i s path mode req-mode orig-mode stx info)
               (unless (identifier? i)
                 (raise-type-error 'make-import "identifier" i))
               (unless (symbol? s)
                 (raise-type-error 'make-import "symbol" s))
               (unless (module-path? path)
                 (raise-type-error 'make-import "module-path" path))
-              (unless (memq mode '(run syntax template label))
-                (raise-type-error 'make-import "'run, 'syntax, 'template, or 'label" mode))
-              (unless (memq req-mode '(run syntax template label))
-                (raise-type-error 'make-import "'run, 'syntax, 'template, or 'label" req-mode))
+              (unless (or (not mode)
+                          (exact-integer? mode))
+                (raise-type-error 'make-import "exact integer or #f" mode))
+              (unless (or (not req-mode)
+                          (exact-integer? req-mode))
+                (raise-type-error 'make-import "'exact integer or #f" req-mode))
+              (unless (or (not orig-mode)
+                          (exact-integer? orig-mode))
+                (raise-type-error 'make-import "'exact integer or #f" orig-mode))
+              (unless (equal? mode (and req-mode orig-mode (+ req-mode orig-mode)))
+                (raise-mismatch-error 'make-import 
+                                      (format
+                                       "orig mode: ~a and require mode: ~a not consistent with mode: " 
+                                       orig-mode req-mode)
+                                      mode))
               (unless (syntax? stx)
                 (raise-type-error 'make-import "syntax" stx))
-              (values i s path mode req-mode stx)))
+              (values i s path mode req-mode orig-mode stx)))
               
   (define-struct* import-source (mod-path-stx mode)
     #:guard (lambda (path mode info)
               (unless (and (syntax? path)
                            (module-path? (syntax->datum path)))
                 (raise-type-error 'make-import-source "syntax module-path" path))
-              (unless (memq mode '(run syntax template label))
-                (raise-type-error 'make-import-source "'run, 'syntax, 'template, or 'label" mode))
+              (unless (or (not mode)
+                          (exact-integer? mode))
+                (raise-type-error 'make-import-source "exact integer or #f" mode))
               (values path mode)))
     
   (define-values (prop:require-transformer require-transformer? require-transformer-get-proc)
@@ -69,25 +81,26 @@
             #f
             "invalid module-path form"
             stx))
-         (let-values ([(names et-names lt-names) (syntax-local-module-exports stx)])
+         (let ([namess (syntax-local-module-exports stx)])
            (values
             (apply
              append
-             (map (lambda (names mode)
-                    (map (lambda (name)
-                           (make-import (datum->syntax
-                                         stx
-                                         name
-                                         stx)
-                                        name
-                                        mod-path
-                                        mode
-                                        'run
-                                        stx))
-                         names))
-                  (list names et-names lt-names)
-                  (list 'run 'syntax 'label)))
-            (list (make-import-source #'simple 'run)))))]
+             (map (lambda (names)
+                    (let ([mode (car names)])
+                      (map (lambda (name)
+                             (make-import (datum->syntax
+                                           stx
+                                           name
+                                           stx)
+                                          name
+                                          mod-path
+                                          mode
+                                          0
+                                          mode
+                                          stx))
+                           (cdr names))))
+                  namess))
+            (list (make-import-source #'simple 0)))))]
       [(id . rest)
        (identifier? #'id)
        (let ([t (syntax-local-value #'id (lambda () #f))])
diff --git a/collects/scribble/manual.ss b/collects/scribble/manual.ss
index bc001a45d9..68d9fa0964 100644
--- a/collects/scribble/manual.ss
+++ b/collects/scribble/manual.ss
@@ -446,7 +446,7 @@
     (let ([s (to-element/no-color elem)])
       (make-delayed-element
        (lambda (renderer sec ri)
-         (let* ([tag (find-scheme-tag sec ri sig 'for-label)]
+         (let* ([tag (find-scheme-tag sec ri sig #f)]
                 [taglet (and tag (append (cadr tag) (list elem)))]
                 [vtag (and tag `(sig-val ,taglet))]
                 [stag (and tag `(sig-form ,taglet))]
@@ -490,7 +490,7 @@
            (lambda (c mk)
              (make-delayed-element
               (lambda (ren p ri)
-                (let ([tag (find-scheme-tag p ri id/tag 'for-label)])
+                (let ([tag (find-scheme-tag p ri id/tag #f)])
                   (if tag
                       (list (mk tag))
                       content)))
@@ -1851,7 +1851,7 @@
          (list
           (make-link-element #f 
                              content
-                             (or (find-scheme-tag p ri stx-id 'for-label)
+                             (or (find-scheme-tag p ri stx-id #f)
                                  (format "--UNDEFINED:~a--" (syntax-e stx-id))))))
        (lambda () content)
        (lambda () content))))
@@ -2023,15 +2023,17 @@
                   (if (path? p)
                       (intern-taglet (path->main-collects-relative p))
                       p))
-                (cadddr b)
-                (list-ref b 5))
+                (list-ref b 3)
+                (list-ref b 4)
+                (list-ref b 5)
+                (list-ref b 6))
           (error 'scribble "no class/interface/mixin information for identifier: ~e"
                  id))))
 
   (define-serializable-struct cls/intf (name-element app-mixins super intfs methods))
 
   (define (make-inherited-table r d ri decl)
-    (let* ([start (let ([key (find-scheme-tag d ri (decl-name decl) 'for-label)])
+    (let* ([start (let ([key (find-scheme-tag d ri (decl-name decl) #f)])
                     (if key
                         (list (cons key (lookup-cls/intf d ri key)))
                         null))]
@@ -2047,7 +2049,7 @@
                             (let ([super (car supers)])
                               (loop (append (filter values
                                                     (map (lambda (i)
-                                                           (let ([key (find-scheme-tag d ri i 'for-label)])
+                                                           (let ([key (find-scheme-tag d ri i #f)])
                                                              (and key
                                                                   (cons key (lookup-cls/intf d ri key)))))
                                                          (append
@@ -2452,14 +2454,14 @@
                  null))])
       (make-delayed-element
        (lambda (r d ri)
-         (let loop ([search (get d ri (find-scheme-tag d ri cname 'for-label))])
+         (let loop ([search (get d ri (find-scheme-tag d ri cname #f))])
            (cond
             [(null? search)
              (list (make-element #f '("<method not found>")))]
             [(not (car search))
              (loop (cdr search))]
             [else
-             (let* ([a-key (find-scheme-tag d ri (car search) 'for-label)]
+             (let* ([a-key (find-scheme-tag d ri (car search) #f)]
                     [v (and a-key (lookup-cls/intf d ri a-key))])
                (if v
                    (if (member name (cls/intf-methods v))
@@ -2468,7 +2470,7 @@
                                       (list (**method name a-key)
                                             " in " 
                                             (cls/intf-name-element v))))
-                       (loop (append (cdr search) (get d ri (find-scheme-tag d ri (car search) 'for-label)))))
+                       (loop (append (cdr search) (get d ri (find-scheme-tag d ri (car search) #f)))))
                    (loop (cdr search))))])))
        (lambda () (format "~a in ~a" (syntax-e cname) name))
        (lambda () (format "~a in ~a" (syntax-e cname) name)))))
diff --git a/collects/scribble/scheme.ss b/collects/scribble/scheme.ss
index 300ecbaf2e..1be9817076 100644
--- a/collects/scribble/scheme.ss
+++ b/collects/scribble/scheme.ss
@@ -85,7 +85,7 @@
                       (weak-box-value b))))
           (let ([e (make-cached-delayed-element
                     (lambda (renderer sec ri)
-                      (let* ([tag (find-scheme-tag sec ri c 'for-label)])
+                      (let* ([tag (find-scheme-tag sec ri c #f)])
                         (if tag
                             (list
                              (case (car tag)
diff --git a/collects/scribble/search.ss b/collects/scribble/search.ss
index df69f14770..ef5408b54e 100644
--- a/collects/scribble/search.ss
+++ b/collects/scribble/search.ss
@@ -36,17 +36,21 @@
           v)))
      
 
-  ;; mode is #f, 'for-label, or 'for-run
-  (define (find-scheme-tag part ri stx/binding mode)
+  (define (find-scheme-tag part ri stx/binding phase-level)
+    ;; The phase-level argument is used only when `stx/binding'
+    ;; is an identifier.
+    ;;
+    ;; Note: documentation key currently don't distinguish different
+    ;; phase definitions of an identifier from a source module.
+    ;; That is, there's no way to document (define x ....) differently
+    ;; from (define-for-syntax x ...). This isn't a problem in practice,
+    ;; because no one uses the same name for different-phase exported
+    ;; bindings.
     (let ([b (cond
               [(identifier? stx/binding)
-               ((case mode
-                  [(for-label) identifier-label-binding]
-                  [(for-syntax) identifier-transformer-binding]
-                  [else identifier-binding])
-                stx/binding)]
+               (identifier-binding stx/binding phase-level)]
               [(and (list? stx/binding)
-                    (= 6 (length stx/binding)))
+                    (= 7 (length stx/binding)))
                stx/binding]
               [else
                (and (not (symbol? (car stx/binding)))
@@ -57,15 +61,20 @@
                             (cadr stx/binding)
                             p
                             (cadr stx/binding)
-                            #f
                             (if (= 2 (length stx/binding))
-                                mode
-                                (caddr stx/binding)))))])])
+                                0
+                                (caddr stx/binding))
+                            (if (= 2 (length stx/binding))
+                                0
+                                (cadddr stx/binding))
+                            (if (= 2 (length stx/binding))
+                                0
+                                (cadddr (cdr stx/binding))))))])])
       (and 
        (pair? b)
        (let ([seen (make-hash-table)]
              [search-key #f])
-         (let loop ([queue (list (list (caddr b) (cadddr b) (eq? mode (list-ref b 5))))]
+         (let loop ([queue (list (list (caddr b) (cadddr b) (list-ref b 4) (list-ref b 5) (list-ref b 6)))]
                     [rqueue null])
            (cond
             [(null? queue)
@@ -74,12 +83,14 @@
                  #f
                  (loop (reverse rqueue) null))]
             [else
-             (let ([mod (caar queue)]
-                   [id (cadar queue)]
-                   [here? (caddar queue)]
+             (let ([mod (list-ref (car queue) 0)]
+                   [id (list-ref (car queue) 1)]
+                   [defn-phase (list-ref (car queue) 2)]
+                   [import-phase (list-ref (car queue) 3)]
+                   [export-phase (list-ref (car queue) 4)]
                    [queue (cdr queue)])
                (let* ([rmp (module-path-index-resolve mod)]
-                      [eb (and here?
+                      [eb (and (equal? defn-phase export-phase)
                                (list (let ([p (resolved-module-path-name rmp)])
                                        (if (path? p)
                                            (intern-taglet (path->main-collects-relative p))
@@ -106,35 +117,46 @@
                                        module-info-cache
                                        rmp
                                        (lambda ()
-                                         (let-values ([(run-vals run-stxes
-                                                                 syntax-vals syntax-stxes
-                                                                 label-vals label-stxes)
+                                         (let-values ([(valss stxess)
                                                        (module-compiled-exports
                                                         (get-module-code (resolved-module-path-name rmp)))])
-                                           (let ([t (list (append run-vals run-stxes)
-                                                          (append syntax-vals syntax-stxes)
-                                                          (append label-vals label-stxes))])
+                                           (let ([t 
+                                                  ;; Merge the two association lists:
+                                                  (let loop ([base valss]
+                                                             [stxess stxess])
+                                                    (cond
+                                                     [(null? stxess) base]
+                                                     [(assoc (caar stxess) base)
+                                                      => (lambda (l)
+                                                           (loop (cons (cons (car l)
+                                                                             (append (cdar stxess)
+                                                                                     (cdr l)))
+                                                                       (remq l base))
+                                                                 (cdr stxess)))]
+                                                     [else (loop (cons (car stxess)
+                                                                       base)
+                                                                 (cdr stxess))]))])
                                              (hash-table-put! module-info-cache rmp t)
                                              t))))])
                                  (hash-table-put! seen rmp #t)
-                                 (let ([a (assq id (list-ref exports
-                                                             (if here?
-                                                                 0
-                                                                 (case mode
-                                                                   [(for-syntax) 1]
-                                                                   [(for-label) 2]
-                                                                   [else 0]))))])
+                                 (let ([a (assq id (let ([a (assoc export-phase exports)])
+                                                     (if a
+                                                         (cdr a) 
+                                                         null)))])
                                    (if a
                                        (loop queue
                                              (append (map (lambda (m)
                                                             (if (pair? m)
                                                                 (list (module-path-index-rejoin (car m) mod)
-                                                                      (caddr m) 
-                                                                      (or here?
-                                                                          (eq? mode (cadr m))))
+                                                                      (list-ref m 2)
+                                                                      defn-phase
+                                                                      (list-ref m 1)
+                                                                      (list-ref m 3))
                                                                 (list (module-path-index-rejoin m mod)
                                                                       id
-                                                                      here?)))
+                                                                      0
+                                                                      0
+                                                                      0)))
                                                           (cadr a))
                                                      rqueue))
                                        (error 'find-scheme-tag
diff --git a/collects/scribblings/reference/module-reflect.scrbl b/collects/scribblings/reference/module-reflect.scrbl
index 7b7031a71e..6333550571 100644
--- a/collects/scribblings/reference/module-reflect.scrbl
+++ b/collects/scribblings/reference/module-reflect.scrbl
@@ -242,37 +242,34 @@ the module's declared name.}
 
 
 @defproc[(module-compiled-imports [compiled-module-code compiled-module-expression?])
-         (values (listof module-path-index?)
-                 (listof module-path-index?)
-                 (listof module-path-index?)
-                 (listof module-path-index?))]{
+         (listof (cons/c (or/c exact-integer? false/c) 
+                         (listof module-path-index?)))]{
+
+Takes a module declaration in compiled form and returns an association
+list mapping @tech{phase level} shifts (where @scheme[#f] corresponds
+to a shift into the @tech{label phase level}) to module references for
+the module's explicit imports.}
 
-Takes a module declaration in compiled form and returns four values: a
-list of module references for the module's explicit imports, a list of
-module references for the module's explicit for-syntax imports, a list
-of module references for the module's explicit for-template imports,
-and a list of module references for the module's explicit for-label
-imports.}
 
 @defproc[(module-compiled-exports [compiled-module-code compiled-module-expression?])
-         (values list? list? list? list? list? list?)]{
+         (values (listof (cons/c (or/c exact-integer? false/c) list?))
+                 (listof (cons/c (or/c exact-integer? false/c) list?)))]
 
-Returns six lists: one for the module's explicit variable exports, one
-for the module's explicit syntax exports, one for the module's
-explicit @scheme[for-syntax] variable exports, one for the module's
-explicit @scheme[for-syntax] syntax exports, one for the module's
-explicit @scheme[for-label] variable exports, one for the module's
-explicit @scheme[for-label] syntax exports.
+Returns two association lists mapping @tech{phase level} values (where
+@scheme[#f] corresponds to the @tech{label phase level}) to exports at
+the corresponding phase. The first association list is for exported
+variables, and the second is for exported syntax.
 
-Each list more precisely matches the contract
+Each associated list more precisely matches the contract
 
 @schemeblock[
 (listof (list/c symbol?
                 (listof 
                  (or/c module-path-index?
                        (list/c module-path-index?
-                               (one-of/c #f 'for-syntax 'for-label)
-                               symbol?)))))
+                               (or/c exact-integer? false/c)
+                               symbol?
+                               (or/c exact-integer? false/c))))))
 ]
 
 For each element of the list, the leading symbol is the name of the
@@ -287,12 +284,15 @@ The origin list has more than one element if the binding was imported
 multiple times from (possibly) different sources.
 
 For each origin, a @tech{module path index} by itself means that the
-binding was imported with a plain @scheme[require] (not
-@scheme[for-syntax] or @scheme[for-label]), and imported identifier
-has the same name as the re-exported name. An origin represented with
-a list indicates explicitly the import, the import mode (plain
-@scheme[require], @scheme[for-syntax], or @scheme[for-label]) and the
-original export name of the re-exported binding.}
+binding was imported with a @tech{phase level} shift of @scheme[0]
+(i.e., a plain @scheme[require] without @scheme[for-meta],
+@scheme[for-syntax], etc.), and imported identifier has the same name
+as the re-exported name. An origin represented with a list indicates
+explicitly the import, the import @tech{phase level} shift (where
+@scheme[#f] corresponds to a @scheme[for-label] import), the import
+name of the re-exported binding, and the @tech{phase level} of the
+import.}
+
 
 @;------------------------------------------------------------------------
 @section[#:tag "dynreq"]{Dynamic Module Access}
diff --git a/collects/scribblings/reference/stx-comp.scrbl b/collects/scribblings/reference/stx-comp.scrbl
index 4600700c4e..be7df791aa 100644
--- a/collects/scribblings/reference/stx-comp.scrbl
+++ b/collects/scribblings/reference/stx-comp.scrbl
@@ -3,19 +3,30 @@
 
 @title[#:tag "stxcmp"]{Syntax Object Bindings}
 
-@defproc[(bound-identifier=? [a-id syntax?][b-id syntax?]) boolean?]{
+@defproc[(bound-identifier=? [a-id syntax?][b-id syntax?]
+                             [phase-level (or/c exact-integer? false/c)
+                                          (syntax-local-phase-level)])
+         boolean?]{
 
 Returns @scheme[#t] if the identifier @scheme[a-id] would bind
 @scheme[b-id] (or vice-versa) if the identifiers were substituted in a
-suitable expression context, @scheme[#f] otherwise.}
+suitable expression context at the @tech{phase level} indicated by
+@scheme[phase-level], @scheme[#f] otherwise. A @scheme[#f] value for
+@scheme[phase-level] corresponds to the @tech{label phase level}.}
 
 
-@defproc[(free-identifier=? [a-id syntax?][b-id syntax?]) boolean?]{
+@defproc[(free-identifier=? [a-id syntax?][b-id syntax?]
+                            [phase-level (or/c exact-integer? false/c)
+                                         (syntax-local-phase-level)])
+         boolean?]{
 
 Returns @scheme[#t] if @scheme[a-id] and @scheme[b-id] access the same
-lexical, module, or top-level binding at @tech{phase level} 0. ``Same
-module binding'' means that the identifiers refer to the same original
-definition site, not necessarily the @scheme[require] or
+lexical, module, or top-level binding at the @tech{phase level}
+indicated by @scheme[phase-level]. A @scheme[#f] value for
+@scheme[phase-level] corresponds to the @tech{label phase level}.
+
+``Same module binding'' means that the identifiers refer to the same
+original definition site, not necessarily the @scheme[require] or
 @scheme[provide] site. Due to renaming in @scheme[require] and
 @scheme[provide], the identifiers may return distinct results with
 @scheme[syntax-e].}
@@ -23,23 +34,15 @@ definition site, not necessarily the @scheme[require] or
 
 @defproc[(free-transformer-identifier=? [a-id syntax?][b-id syntax?]) boolean?]{
 
-Returns @scheme[#t] if @scheme[a-id] and @scheme[b-id] access the same
-lexical, module, or top-level binding at @tech{phase level} 1 (see
-@secref["id-model"]).}
-
+Same as @scheme[(free-identifier=? a-id b-id (add1 (syntax-local-phase-level)))].}
 
 @defproc[(free-template-identifier=? [a-id syntax?][b-id syntax?]) boolean?]{
 
-Returns @scheme[#t] if @scheme[a-id] and @scheme[b-id] access the same
-lexical or module binding at @tech{phase level} -1 (see
-@secref["id-model"]).}
-
+Same as @scheme[(free-identifier=? a-id b-id (sub1 (syntax-local-phase-level)))].}
 
 @defproc[(free-label-identifier=? [a-id syntax?][b-id syntax?]) boolean?]{
 
-Returns @scheme[#t] if @scheme[a-id] and @scheme[b-id] access the same
-lexical or module binding at the @tech{label phase level} (see
-@secref["id-model"]).}
+Same as @scheme[(free-identifier=? a-id b-id #f)].}
 
 
 @defproc[(check-duplicate-identifier [ids (listof identifier?)])
@@ -52,33 +55,41 @@ first one in @scheme[ids] that is a duplicate), otherwise the result
 is @scheme[#f].}
 
 
-@defproc[(identifier-binding [id-stx syntax?])
+@defproc[(identifier-binding [id-stx syntax?]
+                             [phase-level (or/c exact-integer? false/c)
+                                          (syntax-local-phase-level)])
          (or/c (one-of 'lexical #f)
                (listof module-path-index?
                        symbol?
                        module-path-index?
                        symbol?
-                       boolean?
-                       (one-of/c #f 'for-syntax 'for-template)))]{
+                       (one-of/c 0 1)
+                       (or/c exact-integer? false/c)
+                       (or/c exact-integer? false/c)))]{
 
 Returns one of three kinds of values, depending on the binding of
-@scheme[id-stx] at @tech{phase level} 0:
+@scheme[id-stx] at the @tech{phase level} indicated by
+@scheme[phase-level] (where a @scheme[#f] value for
+@scheme[phase-level] corresponds to the @tech{label phase level}):
 
 @itemize{ 
 
       @item{The result is @indexed-scheme['lexical] if @scheme[id-stx]
-      has a @tech{local binding}.}
+      has a @tech{local binding}. If @scheme['lexical] is produced for
+      any @scheme[phase-level] value, then it is produced for all
+      @scheme[phase-level] values.}
 
       @item{The result is a list of six items when @scheme[id-stx]
-      has a @tech{module binding}: @scheme[(list source-mod source-id
-      nominal-source-mod nominal-source-id et? mode)].
+      has a @tech{module binding}: @scheme[(list _source-mod _source-id
+      _nominal-source-mod _nominal-source-id _source-phase _import-phase 
+      _nominal-export-phase)].
 
         @itemize{
 
-        @item{@scheme[source-mod] is a module path index (see
+        @item{@scheme[_source-mod] is a module path index (see
         @secref["modpathidx"]) that indicates the defining module.}
 
-        @item{@scheme[source-id] is a symbol for the identifier's name
+        @item{@scheme[_source-id] is a symbol for the identifier's name
         at its definition site in the source module. This can be
         different from the local name returned by
         @scheme[syntax->datum] for several reasons: the identifier is
@@ -86,27 +97,32 @@ Returns one of three kinds of values, depending on the binding of
         implicitly renamed because the identifier (or its import) was
         generated by a macro invocation.}
 
-        @item{@scheme[nominal-source-mod] is a module path index (see
+        @item{@scheme[_nominal-source-mod] is a module path index (see
         @secref["modpathidx"]) that indicates the module
         @scheme[require]d into the context of @scheme[id-stx] to
         provide its binding. It can be different from
-        @scheme[source-mod] due to a re-export in
-        @scheme[nominal-source-mod] of some imported identifier.}
+        @scheme[_source-mod] due to a re-export in
+        @scheme[_nominal-source-mod] of some imported identifier.  If
+        the same binding is imported in multiple ways, an arbitrary
+        representative is chosen.}
 
-        @item{@scheme[nominal-source-id] is a symbol for the
+        @item{@scheme[_nominal-source-id] is a symbol for the
         identifier's name as exported by
-        @scheme[nominal-source-mod]. It can be different from
-        @scheme[source-id] due to a renaming @scheme[provide], even if
-        @scheme[source-mod] and @scheme[nominal-source-mod] are the
+        @scheme[_nominal-source-mod]. It can be different from
+        @scheme[_source-id] due to a renaming @scheme[provide], even if
+        @scheme[_source-mod] and @scheme[_nominal-source-mod] are the
         same.}
 
-        @item{@scheme[et?] is @scheme[#t] if the source definition is
-        for-syntax, @scheme[#f] otherwise.}
+        @item{@scheme[_source-phase] is @scheme[1] if the source
+        definition is for-syntax, @scheme[0] otherwise.}
 
-        @item{@scheme[mode] is @scheme[#f] if the binding import is a
-        plain @scheme[require], @scheme['for-syntax] if it is from a
-        @scheme[for-syntax] import, or @scheme['for-template] if it is
-        from a @scheme[for-template] import.}
+        @item{@scheme[_import-phase] is @scheme[0] if the binding
+        import of @scheme[_nominal-source-mode] is a plain
+        @scheme[require], @scheme[1] if it is from a
+        @scheme[for-syntax] import, etc.}
+
+        @item{@scheme[_nominal-export-phase] is the @tech{phase level}
+        of the export from @scheme[_nominal-source-mod].}
 
         }}
 
@@ -121,17 +137,11 @@ Returns one of three kinds of values, depending on the binding of
                        symbol?
                        module-path-index?
                        symbol?
-                       boolean?
-                       (one-of/c #f 'for-syntax 'for-template)))]{
+                       (one-of/c 0 1)
+                       (or/c exact-integer? false/c)
+                       (or/c exact-integer? false/c)))]{
 
-Like @scheme[identifier-binding], but that the reported information is
-for the identifier's binding in @tech{phase level} 1 (see
-@secref["id-model"]).
-
-If the result is @scheme['lexical] for either of
-@scheme[identifier-binding] or
-@scheme[identifier-transformer-binding], then the result is always
-@scheme['lexical] for both.}
+Same as @scheme[(identifier-binding id-stx (add1 (syntax-local-phase-level)))].}
 
 
 @defproc[(identifier-template-binding [id-stx syntax?])
@@ -140,32 +150,22 @@ If the result is @scheme['lexical] for either of
                        symbol?
                        module-path-index?
                        symbol?
-                       boolean?
-                       (one-of/c #f 'for-syntax 'for-template)))]{
+                       (one-of/c 0 1)
+                       (or/c exact-integer? false/c)
+                       (or/c exact-integer? false/c)))]{
 
-Like @scheme[identifier-binding], but that the reported information is
-for the identifier's binding in @tech{phase level} -1 (see
-@secref["id-model"]).
-
-If the result is @scheme['lexical] for either of
-@scheme[identifier-binding] or
-@scheme[identifier-template-binding], then the result is always
-@scheme['lexical] for both.}
+Same as @scheme[(identifier-binding id-stx (sub1 (syntax-local-phase-level)))].}
 
 
 @defproc[(identifier-label-binding [id-stx syntax?])
-         (or/c false/c
-               (listof (or/c module-path-index? symbol?)
+         (or/c (one-of 'lexical #f)
+               (listof module-path-index?
                        symbol?
-                       (or/c module-path-index? symbol?)
+                       module-path-index?
                        symbol?
-                       boolean?
-                       (one-of/c #f 'for-label)))]{
+                       (one-of/c 0 1)
+                       (or/c exact-integer? false/c)
+                       (or/c exact-integer? false/c)))]{
 
-Like @scheme[identifier-binding], but that the reported information is
-for the identifier's binding in the @tech{label phase level} (see
-@secref["id-model"]). 
-
-Unlike @scheme[identifier-binding], the result cannot be
-@scheme['lexical].}
+Same as @scheme[(identifier-binding id-stx #f)].}
 
diff --git a/collects/scribblings/reference/stx-trans.scrbl b/collects/scribblings/reference/stx-trans.scrbl
index 0592236985..3e46acd87b 100644
--- a/collects/scribblings/reference/stx-trans.scrbl
+++ b/collects/scribblings/reference/stx-trans.scrbl
@@ -356,6 +356,13 @@ contexts.
 @transform-time[]}
 
 
+@defproc[(syntax-local-phase-level) (or/c exact-integer? false/c)]{
+
+During the dynamic extent of a @tech{syntax transformer} application
+by the expander, the result is the @tech{phase level} of the form
+being expanded. Otherwise, the result is @scheme[0].}
+
+
 @defproc[(syntax-local-module-exports [mod-path module-path?]) 
          (values (listof symbol?) (listof symbol?) (listof symbol?))]{
 
@@ -558,9 +565,10 @@ Returns @scheme[#t] if @scheme[v] has the
 @defstruct[import ([local-id identifier?]
                    [src-sym symbol?]
                    [src-mod-path module-path?]
-                   [orig-stx syntax?]
-                   [mode (one-of/c 'run 'syntax 'template 'label)]
-                   [req-mode (one-of/c 'run 'syntax 'template 'label)])]{
+                   [mode (or/c exact-integer? false/c)]
+                   [req-mode (or/c exact-integer? false/c)]
+                   [orig-mode (or/c exact-integer? false/c)]
+                   [orig-stx syntax?])]{
 
 A structure representing a single imported identifier:
 
@@ -582,11 +590,10 @@ A structure representing a single imported identifier:
        importing module.}
 
  @item{@scheme[req-mode] --- the @tech{phase level} shift of the
-       import relative to the exporting module. Since the underlying
-       module system currently allows only for-run @scheme[require]s
-       to import into other @tech{phase levels}, if this value is not
-       @scheme['run], then it must match the @scheme[mode] field's
-       value.}
+       import relative to the exporting module.}
+
+ @item{@scheme[orig-mode] --- the @tech{phase level} of the
+       binding as exported by the exporting module.}
 
 }}
 
@@ -594,7 +601,7 @@ A structure representing a single imported identifier:
 @defstruct[import-source ([mod-path-stx (and/c syntax?
                                                (lambda (x)
                                                  (module-path? (syntax->datum x))))]
-                          [mode (one-of/c 'run 'syntax 'template 'label)])]{
+                          [mode (or/c exact-integer? false/c)])]{
 
 A structure representing an imported module, which must be
 instantiated or visited even if no binding is imported into a module.
@@ -630,7 +637,7 @@ If the derived form contains a sub-form that is a
 transform the sub-@scheme[_provide-spec] to a lists of exports.
 
 
-@defproc[(expand-export [stx syntax?] [modes (listof (one-of/c 'run 'syntax 'label))])
+@defproc[(expand-export [stx syntax?] [modes (listof (or/c exact-integer? false/c))])
          (listof export?)]{
 
 Expands the given @scheme[_provide-spec] to a list of exports. The
@@ -638,10 +645,10 @@ Expands the given @scheme[_provide-spec] to a list of exports. The
 sub-@scheme[_provide-specs]; for example, an identifier refers to a
 @tech{phase level} 0 binding unless the @scheme[modes] list specifies
 otherwise. Normally, @scheme[modes] is either empty or contains a
-single symbol.}
+single element.}
 
 
-@defproc[(make-provide-transformer [proc (syntax? (listof (one-of/c 'run 'syntax 'label)) 
+@defproc[(make-provide-transformer [proc (syntax? (listof (or/c exact-integer? false/c))
                                           . -> . (listof export?))])
          provide-transformer?]{
 
@@ -667,7 +674,7 @@ Returns @scheme[#t] if @scheme[v] has the
                    [out-sym symbol?]
                    [orig-stx syntax?]
                    [protect? any/c]
-                   [mode (one-of/c 'run 'syntax 'label)])]{
+                   [mode (or/c exact-integer? false/c)])]{
 
 A structure representing a single imported identifier:
 
diff --git a/collects/scribblings/reference/syntax-model.scrbl b/collects/scribblings/reference/syntax-model.scrbl
index 2b67c2f8d3..d4f496f55e 100644
--- a/collects/scribblings/reference/syntax-model.scrbl
+++ b/collects/scribblings/reference/syntax-model.scrbl
@@ -79,7 +79,7 @@ run time of the enclosing module (or the run time of top-level
 expression). Bindings in @tech{phase level} 0 constitute the
 @deftech{base environment}.  @tech{Phase level} 1 corresponds to the
 time during which the enclosing module (or top-level expression) is
-expanded; bindings in @tech{phase level} 0 constitute the
+expanded; bindings in @tech{phase level} 1 constitute the
 @deftech{transformer environment}.  Phase level -1 corresponds to the
 run time of a different module for which the enclosing module is
 imported for use at @tech{phase level} 1 (relative to the importing
@@ -385,20 +385,21 @@ core syntactic forms are encountered:
        @tech{phase level}s specified by the exporting modules:
        @tech{phase level} 0 for each normal @scheme[provide],
        @tech{phase level} 1 for each @scheme[for-syntax]
-       @scheme[provide], and the @tech{label phase level} for each
-       @scheme[for-label] @scheme[provide].
+       @scheme[provide], and so on. The @scheme[for-meta]
+       @scheme[provide] form allows exports at an arbitrary
+       @tech{phase level} (as long as a binding exists within the
+       module at the @tech{phase level}).
 
        A @scheme[for-syntax] sub-form within @scheme[require] imports
-       only @tech{phase level} 0 exports from the specified modules,
-       but the resulting bindings are for @tech{phase level} 1.
-
-       A @scheme[for-template] sub-form within @scheme[require] imports
-       only @tech{phase level} 0 exports from the specified modules,
-       but the resulting bindings are for @tech{phase level} -1.
-
-       A @scheme[for-label] sub-form within @scheme[require] imports
-       only @tech{phase level} 0 exports from the specified modules,
-       but the resulting bindings are for the @tech{label phase level}.}
+       similarly, but the resulting bindings have a @tech{phase level}
+       that is one more than the exported @tech{phase levels}, when
+       exports for the @tech{label phase level} are still imported at
+       the @tech{label phase level}. More generally, a
+       @scheme[for-meta] sub-form within @scheme[require] imports with
+       the specified @tech{phase level} shift; if the specified shift
+       is @scheme[#f], or if @scheme[for-label] is used to import,
+       then all bindings are imported into the @tech{label phase
+       level}.}
 
  @item{When a @scheme[define], @scheme[define-values],
        @scheme[define-syntax], or @scheme[define-syntaxes] form is
diff --git a/collects/scribblings/reference/syntax.scrbl b/collects/scribblings/reference/syntax.scrbl
index dc35cc447c..2327aae60b 100644
--- a/collects/scribblings/reference/syntax.scrbl
+++ b/collects/scribblings/reference/syntax.scrbl
@@ -1238,16 +1238,18 @@ Legal only in a @tech{module begin context}, and handled by the
 @guideintro["module-require"]{@scheme[require]}
 
 @defform/subs[#:literals (only-in prefix-in except-in rename-in lib file planet + - =
-                          for-syntax for-template for-label quote)
+                          for-syntax for-template for-label for-meta only-meta-in quote)
               (require require-spec ...)
               ([require-spec module-path
                              (only-in require-spec id-maybe-renamed ...)
                              (except-in require-spec id ...)
                              (prefix-in prefix-id require-spec)
                              (rename-in require-spec [orig-id bind-id] ...)
+                             (only-meta-in require-spec ...)
                              (for-syntax require-spec ...)
                              (for-template require-spec ...)
                              (for-label require-spec ...)
+                             (for-meta phase-level require-spec ...)
                              derived-require-spec]
                [module-path (#,(scheme quote) id)
                             rel-string
@@ -1259,6 +1261,7 @@ Legal only in a @tech{module begin context}, and handled by the
                                     rel-string ...)]
                [id-maybe-renamed id
                                  [orig-id bind-id]]
+               [phase-level exact-integer #f]
                [vers nat
                      (nat nat)
                      (= nat)
@@ -1316,22 +1319,29 @@ pre-defined forms are as follows.
   @scheme[orig-id] is not in the set that @scheme[require-spec]
   describes, a syntax error is reported.}
 
+ @defsubform[(only-meta-in phase-level require-spec ...)]{
+  Like the combination of @scheme[require-spec]s, but removing any
+  binding that is not for @scheme[phase-level], where @scheme[#f] for
+  @scheme[phase-level] corresponds to the @tech{label phase level}.}
+
+ @specsubform[#:literals (for-meta)
+              (for-meta phase-level require-spec ...)]{Like the combination of
+  @scheme[require-spec]s, but constrained each binding specified by
+  each @scheme[require-spec] is shifted by @scheme[phase-level]. The
+  @tech{label phase level} corresponds to @scheme[#f], and a shifting
+  combination that involves @scheme[#f] produces @scheme[#f].}
+
  @specsubform[#:literals (for-syntax)
-              (for-syntax require-spec ...)]{Like the combination of
-  @scheme[require-spec]s, but constrained to imports specified as
-  @tech{phase level} 0 imports, each shifted to a @tech{phase level} 1
-  binding. A @scheme[for-syntax] form cannot appear within a
-  @scheme[for-syntax], @scheme[for-template], or @scheme[for-label]
-  form.}
+              (for-syntax require-spec ...)]{Same as 
+  @scheme[(for-meta 1 require-spec ...)].}
 
  @specsubform[#:literals (for-template)
-              (for-template require-spec ...)]{Analogous to
-  @scheme[for-syntax-spec], but shifts bindings to @tech{phase level} -1.}
+              (for-template require-spec ...)]{Same as 
+  @scheme[(for-meta -1 require-spec ...)].}
 
  @specsubform[#:literals (for-label)
-              (for-label require-spec ...)]{Analogous to
-  @scheme[for-syntax-spec], but shifts bindings to the @tech{label
-  phase level}.}
+              (for-label require-spec ...)]{Same as 
+  @scheme[(for-meta #f require-spec ...)].}
 
  @specsubform[derived-require-spec]{See @secref["require-trans"] for
  information on expanding the set of @scheme[require-spec] forms.}
@@ -1427,8 +1437,8 @@ an identifier can be either imported or defined for a given
 @guideintro["module-provide"]{@scheme[provide]}
 
 @defform/subs[#:literals (protect-out all-defined-out all-from-out rename-out 
-                          except-out prefix-out struct-out
-                          for-syntax for-label)
+                          except-out prefix-out struct-out for-meta
+                          for-syntax for-label for-template)
               (provide provide-spec ...)
               ([provide-spec id
                              (all-defined-out)
@@ -1438,7 +1448,12 @@ an identifier can be either imported or defined for a given
                              (prefix-out prefix-id provide-spec)
                              (struct-out id)
                              (protect-out provide-spec ...)
-                             derived-provide-spec])]{
+                             (for-meta phase-level provide-spec ...)
+                             (for-syntax provide-spec ...)
+                             (for-template provide-spec ...)
+                             (for-label provide-spec ...)
+                             derived-provide-spec]
+               [phase-level exact-integer #f])]{
 
 Declares exports from a module. A @scheme[provide] form must appear in
 a @tech{module context} or a @tech{module-begin context}.
@@ -1514,19 +1529,27 @@ pre-defined forms are as follows.
  @secref["modprotect"]. The @scheme[provide-spec] must specify only
  bindings that are defined within the exporting module.}
 
- @specsubform[#:literals (for-syntax) 
-              (for-syntax provide-spec ...)]{ Like the union of the
+ @specsubform[#:literals (for-meta) 
+              (for-meta phase-level provide-spec ...)]{ Like the union of the
  @scheme[provide-spec]s, but adjusted to apply to @tech{phase level}
- 1. In particular, an @scheme[id] or @scheme[rename-out] formas a
- @scheme[provide-spec] refers to a @tech{phase-level}-1 binding, an
- @scheme[all-define-out] exports only @tech{phase-level}-1
- definitions, and an @scheme[all-from-out] exports only bindings
- imported with a shift to @tech{phase level} 1.}
+ specified by @scheme[phase-level] (where @scheme[#f] corresponds to the
+ @tech{label phase level}). In particular, an @scheme[id] or @scheme[rename-out] form as
+ a @scheme[provide-spec] refers to a binding at @scheme[phase-level], an
+ @scheme[all-define-out] exports only @scheme[phase-level]
+ definitions, and an @scheme[all-from-out] exports bindings
+ imported with a shift by @scheme[phase-level].}
 
- @specsubform[#:literals (for-label)
-              (for-label provide-spec ...)]{Analogous to
- @scheme[for-syntax], adjusting each @scheme[provide-spec] to the
- @tech{label phase level}.}
+ @specsubform[#:literals (for-syntax) 
+              (for-syntax provide-spec ...)]{Same as
+ @scheme[(for-meta 1 provide-spec ...)].}
+
+ @specsubform[#:literals (for-template) 
+              (for-template provide-spec ...)]{Same as
+ @scheme[(for-meta -1 provide-spec ...)].}
+
+ @specsubform[#:literals (for-label) 
+              (for-label provide-spec ...)]{Same as
+ @scheme[(for-meta #f provide-spec ...)].}
 
  @specsubform[derived-provide-spec]{See @secref["provide-trans"] for
  information on expanding the set of @scheme[provide-spec] forms.}
@@ -1536,15 +1559,20 @@ export name, though the same binding can be specified with the
 multiple symbolic names.}
 
 
+@defform[(for-meta require-spec ...)]{See @scheme[require] and @scheme[provide].}
 @defform[(for-syntax require-spec ...)]{See @scheme[require] and @scheme[provide].}
-@defform[(for-template require-spec ...)]{See @scheme[require].}
+@defform[(for-template require-spec ...)]{See @scheme[require] and @scheme[provide].}
 @defform[(for-label require-spec ...)]{See @scheme[require] and @scheme[provide].}
 
 @defform/subs[(#%require raw-require-spec ...)
-              ([raw-require-spec phaseless-require-spec
+              ([raw-require-spec phaseless-spec
+                                 (#,(schemeidfont "for-meta") phase-level phaseless-spec ...)
                                  (#,(schemeidfont "for-syntax") phaseless-spec ...)
                                  (#,(schemeidfont "for-template") phaseless-spec ...)
-                                 (#,(schemeidfont "for-label") phaseless-spec ...)]
+                                 (#,(schemeidfont "for-label") phaseless-spec ...)
+                                 (#,(schemeidfont "just-meta") phase-level raw-require-spec ...)]
+               [phase-level exact-integer
+                            #f]
                [phaseless-spec raw-module-path
                                (#,(schemeidfont "only") rw-module-path id ...)
                                (#,(schemeidfont "prefix") prefix-id raw-module-path)
@@ -1565,7 +1593,9 @@ The primitive import form, to which @scheme[require] expands. A
 @scheme[require] form, except that the syntax is more constrained, not
 composable, and not extensible. Also, sub-form names like
 @schemeidfont{for-syntax} and @schemeidfont{lib} are recognized
-symbolically, instead of via bindings.
+symbolically, instead of via bindings. Although not formalized in the
+grammar above, a @schemeidfont{just-meta} form cannot appear within a
+@schemeidfont{just-meta} form.
 
 Each @scheme[raw-require-spec] corresponds to the obvious
 @scheme[_require-spec], but the @schemeidfont{rename} sub-form has the
@@ -1579,9 +1609,12 @@ where the lexical context of the @scheme[local-id] is preserved.}
 
 @defform/subs[(#%provide raw-provide-spec ...)
               ([raw-provide-spec phaseless-spec
+                                 (#,(schemeidfont "for-meta") phase-level phaseless-spec)
                                  (#,(schemeidfont "for-syntax") phaseless-spec)
                                  (#,(schemeidfont "for-label") phaseless-spec)
                                  (#,(schemeidfont "protect") raw-provide-spec)]
+               [phase-level exact-integer
+                            #f]
                [phaseless-spec id 
                                (#,(schemeidfont "rename") local-id export-id) 
                                (#,(schemeidfont "struct") struct-id (field-id ...))
diff --git a/collects/scribblings/scribble/xref.scrbl b/collects/scribblings/scribble/xref.scrbl
index bd923a2b69..b9b6840262 100644
--- a/collects/scribblings/scribble/xref.scrbl
+++ b/collects/scribblings/scribble/xref.scrbl
@@ -49,15 +49,18 @@ get all cross-reference information for installed documentation.}
                                                               symbol?
                                                               module-path-index?
                                                               symbol?
-                                                              boolean?
-                                                              (one-of/c #f 'for-syntax 'for-label))
+                                                              (one-of/c 0 1)
+                                                              (or/c exact-integer? false/c)
+                                                              (or/c exact-integer? false/c))
                                                       (list/c (or/c module-path?
                                                                     module-path-index?
                                                                     path?
                                                                     resolved-module-path?)
                                                               symbol?
-                                                              (one-of/c #f 'for-syntax 'for-label)))]
-                                       [mode (one-of/c #f 'for-syntax 'for-label)])
+                                                              (one-of/c 0 1)
+                                                              (or/c exact-integer? false/c)
+                                                              (or/c exact-integer? false/c)))]
+                                       [mode (or/c exact-integer? false/c)])
          (or/c tag? false/c)]{
 
 Locates a tag in @scheme[xref] that documents a module export. The
@@ -68,35 +71,27 @@ either for the specified module or, if the exported name is
 re-exported from other other module, for the other module
 (transitively).
 
-The @scheme[mode] argument specifies more information about the
-binding: whether it refers to a normal binding, a @scheme[for-syntax]
-binding, or a @scheme[for-label] binding.
-
-The @scheme[binding] is specified in one of four ways:
+The @scheme[mode] argument specifies the relevant phase level for the
+binding. The @scheme[binding] is specified in one of four ways:
 
 @itemize{
 
  @item{If @scheme[binding] is an identifier, then
-       @scheme[identifier-binding],
-       @scheme[identifier-transformer-binding], or
-       @scheme[identifier-label-binding] is used to determine the
-       binding, depending on the value of @scheme[mode].}
+       @scheme[identifier-binding] is used with @scheme[mode] to
+       determine the binding.}
 
  @item{If @scheme[binding] is a two-element list, then the first
        element provides the exporting module and the second the
        exported name. The @scheme[mode] argument is effectively
        ignored.}
 
- @item{If @scheme[binding] is a six-element list, then it corresponds
-       to a result from @scheme[identifier-binding],
-       @scheme[identifier-transformer-binding], or
-       @scheme[identifier-label-binding], depending on the value of
+ @item{If @scheme[binding] is a seven-element list, then it corresponds
+       to a result from @scheme[identifier-binding] using
        @scheme[mode].}
 
- @item{If @scheme[binding] is a three-element list, then the first
-       element is as for the 2-element-list case, the second element
-       is like the fourth element of the six-element case, and the
-       third element is like the sixth element of the six-element
+ @item{If @scheme[binding] is a five-element list, then the first
+       element is as for the two-element-list case, and the remain
+       elements are as in the last four elements of the seven-element
        case.}
 
 }
diff --git a/collects/tests/mzscheme/stx.ss b/collects/tests/mzscheme/stx.ss
index a0dc5bee2b..d750ef2174 100644
--- a/collects/tests/mzscheme/stx.ss
+++ b/collects/tests/mzscheme/stx.ss
@@ -445,11 +445,11 @@
                (cdddr b))
         b)))
 
-(test '('#%kernel case-lambda (lib "scheme/init") case-lambda #f #f)  identifier-binding* #'case-lambda)
-(test '(scheme/promise delay (lib "scheme/init") delay #f #f)  identifier-binding* #'delay)
-(test '('#%kernel #%module-begin (lib "scheme/init") #%plain-module-begin #f #f)  identifier-binding* #'#%plain-module-begin)
+(test '('#%kernel case-lambda (lib "scheme/init") case-lambda 0 0 0)  identifier-binding* #'case-lambda)
+(test '(scheme/promise delay (lib "scheme/init") delay 0 0 0)  identifier-binding* #'delay)
+(test '('#%kernel #%module-begin (lib "scheme/init") #%plain-module-begin 0 0 0)  identifier-binding* #'#%plain-module-begin)
 (require (only-in scheme/base [#%plain-module-begin #%pmb]))
-(test '('#%kernel #%module-begin scheme/base #%plain-module-begin #f #f)  identifier-binding* #'#%pmb)
+(test '('#%kernel #%module-begin scheme/base #%plain-module-begin 0 0 0)  identifier-binding* #'#%pmb)
 
 (let ([b (identifier-binding (syntax-case (expand #'(module m scheme/base
 						      (require (only-in (lib "lang/htdp-intermediate.ss") [cons bcons]))
@@ -1275,6 +1275,97 @@
 
 ;; If we get here, then macro expansion didn't fail.
 
+;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Check that the free-identifier=? cache doesn't kick in too eagerly.
+
+(module @w@ scheme/base
+  (define add '+)
+  
+  (provide (rename-out [add plus])))
+
+(module @q@ scheme/base
+  (require (for-syntax scheme/base))
+  (provide result)
+  
+  (define-for-syntax a #'plus)
+  (define-for-syntax b #'plus)
+
+  (define-for-syntax accum null)
+  
+  (begin-for-syntax 
+   (set! accum (cons (free-identifier=? a #'plus)
+                     accum)))
+
+  (require '@w@)
+
+  (begin-for-syntax 
+   (set! accum (list*
+                (free-identifier=? a #'plus)
+                (free-identifier=? b #'plus)
+                accum)))
+
+  (define-syntax (accumulated stx)
+    (datum->syntax stx `',accum))
+
+  (define result (accumulated)))
+
+(require '@q@)
+(test '(#t #t #t) values result)
+
+;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;  Test namespace-attach with phase-levels -2 and 2
+
+(when (file-exists? "tmp10")
+  (delete-file "tmp10"))
+
+(module @!a scheme/base
+  (provide x)
+  (with-output-to-file "tmp10" 
+    #:exists 'append
+    (lambda ()
+      (printf "a\n")))
+  (define x 5))
+
+(module @!b scheme/base
+  (provide get-x)
+  (require (for-meta -2 '@!a))
+  (define (get-x) #'x))
+
+(module @!c scheme/base
+  (require (for-meta 2 '@!b)
+           (for-syntax scheme/base
+                       (for-syntax scheme/base)))
+  (define-syntax (foo stx)
+    (let-syntax ([ref-x (lambda (stx)
+                          #`(quote-syntax #,(get-x)))])
+      (ref-x)))
+  
+  (with-output-to-file "tmp10" 
+    #:exists 'append
+    (lambda ()
+      (printf "~s\n" (foo)))))
+
+(define (check-tmp10 s)
+  (test s with-input-from-file "tmp10" (lambda () (read-string 1000))))
+
+(require '@!c)
+(check-tmp10 "a\n5\n")
+
+(let ()
+  (define n (make-base-namespace))
+  (namespace-attach-module (current-namespace) ''@!c n)
+  (test 5
+        'use-a
+        (parameterize ([current-namespace n])
+          ;; Shouldn't instantiate new:
+          (namespace-require ''@!a)
+          ;; Should see `x' from @!a:
+          (eval 'x)))
+  (check-tmp10 "a\n5\n"))
+
+(when (file-exists? "tmp10")
+  (delete-file "tmp10"))
+
 ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (report-errs)
diff --git a/src/mzscheme/gc2/setup.ss b/src/mzscheme/gc2/setup.ss
index d1b31aefcc..fdd9e4f936 100644
--- a/src/mzscheme/gc2/setup.ss
+++ b/src/mzscheme/gc2/setup.ss
@@ -55,10 +55,9 @@
           (printf "Copying ~a to ~a~n" path target)
           (copy-file path target)
           (let ([code (get-module-code path "no-such-dir")])
-            (let-values ([(a b c d) (module-compiled-imports code)])
-              (map (lambda (x)
-                     (go x path #f))
-                   (append a b c d)))))))))
+            (map (lambda (x)
+                   (go x path #f))
+                 (apply append (map cdr (module-compiled-imports code))))))))))
 
 (unless (directory-exists? "xform-collects")
   (make-directory "xform-collects"))
diff --git a/src/mzscheme/src/cstartup.inc b/src/mzscheme/src/cstartup.inc
index cd8f145ece..e71bb53616 100644
--- a/src/mzscheme/src/cstartup.inc
+++ b/src/mzscheme/src/cstartup.inc
@@ -1,112 +1,111 @@
   {
-    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35,126,9,51,46,57,57,46,48,46,49,49,50,0,0,0,1,0,0,6,0,
-9,0,14,0,18,0,23,0,36,0,41,0,45,0,52,0,55,0,62,0,69,
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35,126,9,51,46,57,57,46,48,46,49,51,50,0,0,0,1,0,0,6,0,
+9,0,22,0,27,0,31,0,36,0,41,0,45,0,52,0,55,0,62,0,69,
 0,78,0,84,0,98,0,112,0,115,0,119,0,121,0,132,0,134,0,148,0,
-155,0,177,0,179,0,193,0,203,0,209,0,232,0,33,1,43,1,60,1,99,
-1,138,1,212,1,1,2,94,2,139,2,144,2,164,2,54,3,74,3,124,3,
-190,3,75,4,238,4,25,5,36,5,115,5,0,0,133,7,0,0,65,98,101,
-103,105,110,29,11,11,64,108,101,116,42,63,108,101,116,64,119,104,101,110,72,
-112,97,114,97,109,101,116,101,114,105,122,101,64,99,111,110,100,63,97,110,100,
+155,0,177,0,179,0,193,0,250,0,17,1,23,1,29,1,39,1,56,1,95,
+1,134,1,203,1,248,1,80,2,125,2,130,2,150,2,40,3,60,3,110,3,
+176,3,61,4,219,4,6,5,17,5,96,5,0,0,117,7,0,0,65,98,101,
+103,105,110,29,11,11,72,112,97,114,97,109,101,116,101,114,105,122,101,64,108,
+101,116,42,63,108,101,116,64,119,104,101,110,64,99,111,110,100,63,97,110,100,
 66,108,101,116,114,101,99,62,111,114,66,100,101,102,105,110,101,66,117,110,108,
 101,115,115,68,104,101,114,101,45,115,116,120,65,113,117,111,116,101,29,94,2,
-14,68,35,37,112,97,114,97,109,122,11,29,94,2,14,68,35,37,107,101,114,
-110,101,108,11,62,105,102,63,115,116,120,61,115,70,108,101,116,45,118,97,108,
+14,68,35,37,107,101,114,110,101,108,11,29,94,2,14,68,35,37,112,97,114,
+97,109,122,11,62,105,102,63,115,116,120,61,115,70,108,101,116,45,118,97,108,
 117,101,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,95,8,240,48,117,0,0,11,16,0,95,8,193,11,16,0,96,35,11,93,
-159,2,16,34,35,16,2,2,13,161,2,2,35,2,13,2,2,2,13,97,10,
-34,11,94,159,2,15,34,34,159,2,16,34,34,16,20,2,10,2,2,2,3,
-2,2,2,4,2,2,2,5,2,2,2,6,2,2,2,7,2,2,2,8,2,
-2,2,9,2,2,2,11,2,2,2,12,2,2,13,16,4,34,29,11,11,2,
-2,11,18,98,64,104,101,114,101,8,31,8,30,8,29,8,28,8,27,27,248,
-22,178,3,23,196,1,249,22,171,3,80,158,37,34,251,22,73,2,17,248,22,
-88,23,200,2,12,249,22,63,2,1,248,22,90,23,202,1,27,248,22,178,3,
-23,196,1,249,22,171,3,80,158,37,34,251,22,73,2,17,248,22,88,23,200,
-2,249,22,63,2,1,248,22,90,23,202,1,12,27,248,22,65,248,22,178,3,
-23,197,1,28,248,22,71,23,194,2,87,94,23,193,1,20,15,159,35,34,35,
-28,248,22,71,248,22,65,23,195,2,248,22,64,193,249,22,171,3,80,158,37,
-34,251,22,73,2,17,248,22,64,23,200,2,249,22,63,2,8,248,22,65,23,
-202,1,11,18,100,10,8,31,8,30,8,29,8,28,8,27,16,4,11,11,2,
-18,3,1,7,101,110,118,54,57,49,51,16,4,11,11,2,19,3,1,7,101,
-110,118,54,57,49,52,27,248,22,65,248,22,178,3,23,197,1,28,248,22,71,
-23,194,2,87,94,23,193,1,20,15,159,35,34,35,28,248,22,71,248,22,65,
-23,195,2,248,22,64,193,249,22,171,3,80,158,37,34,250,22,73,2,20,248,
-22,73,249,22,73,248,22,73,2,21,248,22,64,23,202,2,251,22,73,2,17,
-2,21,2,21,249,22,63,2,10,248,22,65,23,205,1,18,100,11,8,31,8,
+115,97,10,34,11,94,159,2,16,34,34,159,2,15,34,34,16,20,2,10,2,
+2,2,3,2,2,2,4,2,2,2,5,2,2,2,6,2,2,2,7,2,2,
+2,8,2,2,2,9,2,2,2,11,2,2,2,12,2,2,96,35,11,93,159,
+2,15,34,35,16,2,2,13,161,2,2,35,2,13,2,2,2,13,96,10,11,
+11,16,0,96,10,36,11,16,0,13,16,4,34,29,11,11,2,2,11,18,98,
+64,104,101,114,101,8,31,8,30,8,29,8,28,8,27,27,248,22,178,3,23,
+196,1,249,22,171,3,80,158,37,34,251,22,73,2,17,248,22,88,23,200,2,
+12,249,22,63,2,1,248,22,90,23,202,1,27,248,22,178,3,23,196,1,249,
+22,171,3,80,158,37,34,251,22,73,2,17,248,22,88,23,200,2,249,22,63,
+2,1,248,22,90,23,202,1,12,27,248,22,65,248,22,178,3,23,197,1,28,
+248,22,71,23,194,2,20,15,159,35,34,35,28,248,22,71,248,22,65,23,195,
+2,248,22,64,193,249,22,171,3,80,158,37,34,251,22,73,2,17,248,22,64,
+23,200,2,249,22,63,2,8,248,22,65,23,202,1,11,18,100,10,8,31,8,
 30,8,29,8,28,8,27,16,4,11,11,2,18,3,1,7,101,110,118,54,57,
-49,54,16,4,11,11,2,19,3,1,7,101,110,118,54,57,49,55,248,22,178,
-3,193,27,248,22,178,3,194,249,22,63,248,22,73,248,22,64,196,248,22,65,
-195,27,248,22,65,248,22,178,3,23,197,1,249,22,171,3,80,158,37,34,28,
-248,22,51,248,22,172,3,248,22,64,23,198,2,27,249,22,2,32,0,89,162,
-8,44,35,41,9,222,33,39,248,22,178,3,248,22,88,23,200,2,250,22,73,
-2,22,248,22,73,249,22,73,248,22,73,248,22,64,23,204,2,250,22,74,2,
-23,249,22,2,22,64,23,204,2,248,22,90,23,206,2,249,22,63,248,22,64,
-23,202,1,249,22,2,22,88,23,200,1,250,22,74,2,20,249,22,2,32,0,
-89,162,42,35,45,9,222,33,40,248,22,178,3,248,22,64,201,248,22,65,198,
-27,248,22,178,3,194,249,22,63,248,22,73,248,22,64,196,248,22,65,195,27,
-248,22,65,248,22,178,3,23,197,1,249,22,171,3,80,158,37,34,250,22,74,
-2,22,249,22,2,32,0,89,162,42,35,45,9,222,33,42,248,22,178,3,248,
-22,64,201,248,22,65,198,27,248,22,65,248,22,178,3,196,27,248,22,178,3,
-248,22,64,195,249,22,171,3,80,158,38,34,28,248,22,71,195,250,22,74,2,
-20,9,248,22,65,199,250,22,73,2,4,248,22,73,248,22,64,199,250,22,74,
-2,3,248,22,65,201,248,22,65,202,27,248,22,65,248,22,178,3,23,197,1,
-27,249,22,1,22,77,249,22,2,22,178,3,248,22,178,3,248,22,64,199,249,
-22,171,3,80,158,38,34,251,22,73,1,22,119,105,116,104,45,99,111,110,116,
-105,110,117,97,116,105,111,110,45,109,97,114,107,2,24,250,22,74,1,23,101,
-120,116,101,110,100,45,112,97,114,97,109,101,116,101,114,105,122,97,116,105,111,
-110,21,95,1,27,99,111,110,116,105,110,117,97,116,105,111,110,45,109,97,114,
-107,45,115,101,116,45,102,105,114,115,116,11,2,24,201,250,22,74,2,20,9,
-248,22,65,203,27,248,22,65,248,22,178,3,23,197,1,28,248,22,71,23,194,
-2,87,94,23,193,1,20,15,159,35,34,35,249,22,171,3,80,158,37,34,27,
-248,22,178,3,248,22,64,23,198,2,28,249,22,138,8,62,61,62,248,22,172,
-3,248,22,88,23,197,2,250,22,73,2,20,248,22,73,249,22,73,21,93,2,
-25,248,22,64,199,250,22,74,2,7,249,22,73,2,25,249,22,73,248,22,97,
-203,2,25,248,22,65,202,251,22,73,2,17,28,249,22,138,8,248,22,172,3,
-248,22,64,23,201,2,64,101,108,115,101,10,248,22,64,23,198,2,250,22,74,
-2,20,9,248,22,65,23,201,1,249,22,63,2,7,248,22,65,23,203,1,99,
-8,31,8,30,8,29,8,28,8,27,16,4,11,11,2,18,3,1,7,101,110,
-118,54,57,51,57,16,4,11,11,2,19,3,1,7,101,110,118,54,57,52,48,
-18,158,94,10,64,118,111,105,100,8,47,27,248,22,65,248,22,178,3,196,249,
-22,171,3,80,158,37,34,28,248,22,51,248,22,172,3,248,22,64,197,250,22,
-73,2,26,248,22,73,248,22,64,199,248,22,88,198,27,248,22,172,3,248,22,
-64,197,250,22,73,2,26,248,22,73,248,22,64,197,250,22,74,2,23,248,22,
-65,199,248,22,65,202,159,34,20,102,159,34,16,1,20,24,2,1,16,0,83,
-158,40,20,99,134,69,35,37,109,105,110,45,115,116,120,2,2,10,11,10,10,
-10,10,34,80,158,34,34,20,102,159,34,16,0,16,0,11,11,16,0,34,11,
-11,11,16,0,16,0,16,0,34,34,11,11,16,0,16,0,16,0,34,34,11,
-16,10,9,9,9,9,9,9,9,9,9,9,16,10,2,3,2,4,2,5,2,
-6,2,7,2,8,2,9,2,10,2,11,2,12,16,10,11,11,11,11,11,11,
-11,11,11,11,16,10,2,3,2,4,2,5,2,6,2,7,2,8,2,9,2,
-10,2,11,2,12,34,44,16,11,16,5,93,2,13,20,15,159,34,34,34,34,
-20,102,159,34,16,0,16,1,33,32,10,16,5,93,2,12,89,162,8,44,35,
-51,9,223,0,33,33,34,20,102,159,34,16,1,20,25,159,35,2,2,2,13,
-16,0,11,16,5,93,2,5,89,162,8,44,35,51,9,223,0,33,34,34,20,
-102,159,34,16,1,20,25,159,35,2,2,2,13,16,0,11,16,5,93,2,8,
-89,162,8,44,35,51,9,223,0,33,35,34,20,102,159,34,16,1,20,25,159,
-35,2,2,2,13,16,1,33,36,11,16,5,93,2,10,89,162,8,44,35,54,
-9,223,0,33,37,34,20,102,159,34,16,1,20,25,159,35,2,2,2,13,16,
-1,33,38,11,16,5,93,2,4,89,162,8,44,35,56,9,223,0,33,41,34,
-20,102,159,34,16,1,20,25,159,35,2,2,2,13,16,0,11,16,5,93,2,
-9,89,162,8,44,35,51,9,223,0,33,43,34,20,102,159,34,16,1,20,25,
-159,35,2,2,2,13,16,0,11,16,5,93,2,3,89,162,8,44,35,52,9,
-223,0,33,44,34,20,102,159,34,16,1,20,25,159,35,2,2,2,13,16,0,
-11,16,5,93,2,6,89,162,8,44,35,53,9,223,0,33,45,34,20,102,159,
-34,16,1,20,25,159,35,2,2,2,13,16,0,11,16,5,93,2,7,89,162,
-8,44,35,56,9,223,0,33,46,34,20,102,159,34,16,1,20,25,159,35,2,
-2,2,13,16,1,33,48,11,16,5,93,2,11,89,162,8,44,35,52,9,223,
-0,33,49,34,20,102,159,34,16,1,20,25,159,35,2,2,2,13,16,0,11,
-16,0,94,2,16,2,15,93,2,16,9,0};
-    EVAL_ONE_SIZED_STR((char *)expr, 2048);
+56,55,16,4,11,11,2,19,3,1,7,101,110,118,54,57,56,56,27,248,22,
+65,248,22,178,3,23,197,1,28,248,22,71,23,194,2,20,15,159,35,34,35,
+28,248,22,71,248,22,65,23,195,2,248,22,64,193,249,22,171,3,80,158,37,
+34,250,22,73,2,20,248,22,73,249,22,73,248,22,73,2,21,248,22,64,23,
+202,2,251,22,73,2,17,2,21,2,21,249,22,63,2,10,248,22,65,23,205,
+1,18,100,11,8,31,8,30,8,29,8,28,8,27,16,4,11,11,2,18,3,
+1,7,101,110,118,54,57,57,48,16,4,11,11,2,19,3,1,7,101,110,118,
+54,57,57,49,248,22,178,3,193,27,248,22,178,3,194,249,22,63,248,22,73,
+248,22,64,196,248,22,65,195,27,248,22,65,248,22,178,3,23,197,1,249,22,
+171,3,80,158,37,34,28,248,22,51,248,22,172,3,248,22,64,23,198,2,27,
+249,22,2,32,0,89,162,8,44,35,41,9,222,33,39,248,22,178,3,248,22,
+88,23,200,2,250,22,73,2,22,248,22,73,249,22,73,248,22,73,248,22,64,
+23,204,2,250,22,74,2,23,249,22,2,22,64,23,204,2,248,22,90,23,206,
+2,249,22,63,248,22,64,23,202,1,249,22,2,22,88,23,200,1,250,22,74,
+2,20,249,22,2,32,0,89,162,42,35,45,9,222,33,40,248,22,178,3,248,
+22,64,201,248,22,65,198,27,248,22,178,3,194,249,22,63,248,22,73,248,22,
+64,196,248,22,65,195,27,248,22,65,248,22,178,3,23,197,1,249,22,171,3,
+80,158,37,34,250,22,74,2,22,249,22,2,32,0,89,162,42,35,45,9,222,
+33,42,248,22,178,3,248,22,64,201,248,22,65,198,27,248,22,65,248,22,178,
+3,196,27,248,22,178,3,248,22,64,195,249,22,171,3,80,158,38,34,28,248,
+22,71,195,250,22,74,2,20,9,248,22,65,199,250,22,73,2,5,248,22,73,
+248,22,64,199,250,22,74,2,4,248,22,65,201,248,22,65,202,27,248,22,65,
+248,22,178,3,23,197,1,27,249,22,1,22,77,249,22,2,22,178,3,248,22,
+178,3,248,22,64,199,249,22,171,3,80,158,38,34,251,22,73,1,22,119,105,
+116,104,45,99,111,110,116,105,110,117,97,116,105,111,110,45,109,97,114,107,2,
+24,250,22,74,1,23,101,120,116,101,110,100,45,112,97,114,97,109,101,116,101,
+114,105,122,97,116,105,111,110,21,95,1,27,99,111,110,116,105,110,117,97,116,
+105,111,110,45,109,97,114,107,45,115,101,116,45,102,105,114,115,116,11,2,24,
+201,250,22,74,2,20,9,248,22,65,203,27,248,22,65,248,22,178,3,23,197,
+1,28,248,22,71,23,194,2,20,15,159,35,34,35,249,22,171,3,80,158,37,
+34,27,248,22,178,3,248,22,64,23,198,2,28,249,22,138,8,62,61,62,248,
+22,172,3,248,22,88,23,197,2,250,22,73,2,20,248,22,73,249,22,73,21,
+93,2,25,248,22,64,199,250,22,74,2,7,249,22,73,2,25,249,22,73,248,
+22,97,203,2,25,248,22,65,202,251,22,73,2,17,28,249,22,138,8,248,22,
+172,3,248,22,64,23,201,2,64,101,108,115,101,10,248,22,64,23,198,2,250,
+22,74,2,20,9,248,22,65,23,201,1,249,22,63,2,7,248,22,65,23,203,
+1,99,8,31,8,30,8,29,8,28,8,27,16,4,11,11,2,18,3,1,7,
+101,110,118,55,48,49,51,16,4,11,11,2,19,3,1,7,101,110,118,55,48,
+49,52,18,158,94,10,64,118,111,105,100,8,47,27,248,22,65,248,22,178,3,
+196,249,22,171,3,80,158,37,34,28,248,22,51,248,22,172,3,248,22,64,197,
+250,22,73,2,26,248,22,73,248,22,64,199,248,22,88,198,27,248,22,172,3,
+248,22,64,197,250,22,73,2,26,248,22,73,248,22,64,197,250,22,74,2,23,
+248,22,65,199,248,22,65,202,159,34,20,103,159,34,16,1,20,24,2,1,16,
+0,83,158,40,20,100,137,69,35,37,109,105,110,45,115,116,120,2,2,10,11,
+10,34,80,158,34,34,20,103,159,34,16,0,16,0,11,11,16,0,34,11,37,
+34,11,16,10,9,9,9,9,9,9,9,9,9,9,16,10,2,3,2,4,2,
+5,2,6,2,7,2,8,2,9,2,10,2,11,2,12,16,10,11,11,11,11,
+11,11,11,11,11,11,16,10,2,3,2,4,2,5,2,6,2,7,2,8,2,
+9,2,10,2,11,2,12,34,44,35,11,11,16,0,16,0,16,0,34,34,11,
+11,11,16,0,16,0,16,0,34,34,16,11,16,5,93,2,13,20,15,159,34,
+34,34,34,20,103,159,34,16,0,16,1,33,32,10,16,5,93,2,12,89,162,
+8,44,35,51,9,223,0,33,33,34,20,103,159,34,16,1,20,25,159,35,2,
+2,2,13,16,0,11,16,5,93,2,6,89,162,8,44,35,51,9,223,0,33,
+34,34,20,103,159,34,16,1,20,25,159,35,2,2,2,13,16,0,11,16,5,
+93,2,8,89,162,8,44,35,51,9,223,0,33,35,34,20,103,159,34,16,1,
+20,25,159,35,2,2,2,13,16,1,33,36,11,16,5,93,2,10,89,162,8,
+44,35,54,9,223,0,33,37,34,20,103,159,34,16,1,20,25,159,35,2,2,
+2,13,16,1,33,38,11,16,5,93,2,5,89,162,8,44,35,56,9,223,0,
+33,41,34,20,103,159,34,16,1,20,25,159,35,2,2,2,13,16,0,11,16,
+5,93,2,9,89,162,8,44,35,51,9,223,0,33,43,34,20,103,159,34,16,
+1,20,25,159,35,2,2,2,13,16,0,11,16,5,93,2,4,89,162,8,44,
+35,52,9,223,0,33,44,34,20,103,159,34,16,1,20,25,159,35,2,2,2,
+13,16,0,11,16,5,93,2,3,89,162,8,44,35,53,9,223,0,33,45,34,
+20,103,159,34,16,1,20,25,159,35,2,2,2,13,16,0,11,16,5,93,2,
+7,89,162,8,44,35,56,9,223,0,33,46,34,20,103,159,34,16,1,20,25,
+159,35,2,2,2,13,16,1,33,48,11,16,5,93,2,11,89,162,8,44,35,
+52,9,223,0,33,49,34,20,103,159,34,16,1,20,25,159,35,2,2,2,13,
+16,0,11,16,0,94,2,15,2,16,93,2,15,9,9,34,0};
+    EVAL_ONE_SIZED_STR((char *)expr, 2032);
   }
   {
-    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35,126,9,51,46,57,57,46,48,46,49,49,61,0,0,0,1,0,0,3,0,
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35,126,9,51,46,57,57,46,48,46,49,51,61,0,0,0,1,0,0,3,0,
 16,0,21,0,38,0,53,0,71,0,87,0,97,0,115,0,135,0,151,0,169,
 0,200,0,229,0,251,0,9,1,15,1,29,1,34,1,44,1,52,1,80,1,
-112,1,157,1,202,1,226,1,9,2,11,2,20,2,71,2,87,3,96,3,126,
-3,170,4,242,4,58,5,146,5,158,5,201,5,217,5,204,6,218,6,69,7,
-8,8,202,8,209,8,215,8,75,9,87,9,155,9,1,10,14,10,36,10,170,
-10,36,11,37,12,45,12,53,12,79,12,158,12,0,0,209,15,0,0,29,11,
+112,1,157,1,202,1,226,1,9,2,11,2,20,2,77,2,167,3,176,3,217,
+3,51,5,155,5,3,6,119,6,133,6,176,6,192,6,42,8,56,8,219,8,
+226,9,232,10,239,10,245,10,117,11,129,11,242,11,88,12,101,12,123,12,75,
+13,235,13,50,15,58,15,66,15,92,15,193,15,0,0,251,18,0,0,29,11,
 11,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,
@@ -133,199 +132,238 @@
 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,68,35,37,107,
 101,114,110,101,108,27,20,14,159,80,158,35,49,250,80,158,38,50,249,22,27,
-11,80,158,40,49,22,138,12,10,248,22,186,4,195,28,248,22,164,5,193,12,
-87,94,248,22,141,8,193,248,80,159,36,53,35,195,28,248,22,71,194,9,27,
-248,22,64,195,27,28,248,22,183,12,194,193,28,248,22,182,12,194,249,22,184,
-12,195,250,80,158,41,47,248,22,134,13,2,20,11,10,250,80,158,39,47,248,
-22,134,13,2,20,196,10,28,192,249,22,63,248,22,186,12,249,22,184,12,197,
-247,22,135,13,27,248,22,65,199,28,248,22,71,193,9,27,248,22,64,194,27,
-28,248,22,183,12,194,193,28,248,22,182,12,194,249,22,184,12,195,250,80,158,
-46,47,248,22,134,13,2,20,11,10,250,80,158,44,47,248,22,134,13,2,20,
-196,10,28,192,249,22,63,248,22,186,12,249,22,184,12,197,247,22,135,13,248,
-80,159,44,52,35,248,22,65,198,248,80,159,42,52,35,248,22,65,196,27,248,
-22,65,197,28,248,22,71,193,9,27,248,22,64,194,27,28,248,22,183,12,194,
-193,28,248,22,182,12,194,249,22,184,12,195,250,80,158,44,47,248,22,134,13,
-2,20,11,10,250,80,158,42,47,248,22,134,13,2,20,196,10,28,192,249,22,
-63,248,22,186,12,249,22,184,12,197,247,22,135,13,248,80,159,42,52,35,248,
-22,65,198,248,80,159,40,52,35,248,22,65,196,249,80,159,36,37,35,2,7,
-195,27,248,22,159,12,194,28,192,192,28,248,22,133,6,194,27,248,22,181,12,
-195,28,192,192,248,22,182,12,195,11,87,94,28,28,248,22,160,12,194,10,27,
-248,22,159,12,195,28,192,192,28,248,22,133,6,195,27,248,22,181,12,196,28,
-192,192,248,22,182,12,196,11,12,250,22,168,8,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,196,28,28,248,22,160,12,194,249,
-22,138,8,248,22,161,12,196,2,21,249,22,138,8,247,22,152,7,2,21,27,
-28,248,22,133,6,195,194,248,22,142,7,248,22,164,12,196,28,249,22,147,13,
-0,21,35,114,120,34,94,91,92,92,93,91,92,92,93,91,63,93,91,92,92,
-93,34,194,28,248,22,133,6,195,248,22,167,12,195,194,27,248,22,172,6,194,
-249,22,168,12,248,22,145,7,250,22,153,13,0,6,35,114,120,34,47,34,28,
-249,22,147,13,0,22,35,114,120,34,91,47,92,92,93,91,46,32,93,43,91,
-47,92,92,93,42,36,34,200,198,250,22,153,13,0,19,35,114,120,34,91,32,
-46,93,43,40,91,47,92,92,93,42,41,36,34,201,6,2,2,92,49,80,158,
-42,35,2,21,28,248,22,133,6,194,248,22,167,12,194,193,87,94,28,27,248,
-22,159,12,195,28,192,192,28,248,22,133,6,195,27,248,22,181,12,196,28,192,
-192,248,22,182,12,196,11,12,250,22,168,8,195,2,22,196,28,248,22,181,12,
-194,12,248,22,183,10,249,22,128,10,248,22,162,6,250,22,181,6,2,23,199,
-200,247,22,23,87,94,28,27,248,22,159,12,195,28,192,192,28,248,22,133,6,
-195,27,248,22,181,12,196,28,192,192,248,22,182,12,196,11,12,250,22,168,8,
-195,2,22,196,28,248,22,181,12,194,12,248,22,183,10,249,22,128,10,248,22,
-162,6,250,22,181,6,2,23,199,200,247,22,23,87,94,87,94,28,27,248,22,
-159,12,195,28,192,192,28,248,22,133,6,195,27,248,22,181,12,196,28,192,192,
-248,22,182,12,196,11,12,250,22,168,8,195,2,22,196,28,248,22,181,12,194,
-12,248,22,183,10,249,22,128,10,248,22,162,6,250,22,181,6,2,23,199,200,
-247,22,23,249,22,3,89,162,34,35,48,9,223,2,33,36,196,248,22,183,10,
-249,22,158,10,195,247,22,23,87,94,87,94,249,80,159,36,37,35,2,7,195,
+11,80,158,40,49,22,138,12,10,248,22,186,4,23,196,2,28,248,22,164,5,
+23,194,2,12,87,94,248,22,141,8,23,194,1,248,80,159,36,53,35,195,28,
+248,22,71,23,195,2,9,27,248,22,64,23,196,2,27,28,248,22,183,12,23,
+195,2,23,194,1,28,248,22,182,12,23,195,2,249,22,184,12,23,196,1,250,
+80,158,41,47,248,22,134,13,2,20,11,10,250,80,158,39,47,248,22,134,13,
+2,20,23,197,1,10,28,23,193,2,249,22,63,248,22,186,12,249,22,184,12,
+23,198,1,247,22,135,13,27,248,22,65,23,200,1,28,248,22,71,23,194,2,
+9,27,248,22,64,23,195,2,27,28,248,22,183,12,23,195,2,23,194,1,28,
+248,22,182,12,23,195,2,249,22,184,12,23,196,1,250,80,158,46,47,248,22,
+134,13,2,20,11,10,250,80,158,44,47,248,22,134,13,2,20,23,197,1,10,
+28,23,193,2,249,22,63,248,22,186,12,249,22,184,12,23,198,1,247,22,135,
+13,248,80,159,44,52,35,248,22,65,23,199,1,87,94,23,193,1,248,80,159,
+42,52,35,248,22,65,23,197,1,87,94,23,193,1,27,248,22,65,23,198,1,
+28,248,22,71,23,194,2,9,27,248,22,64,23,195,2,27,28,248,22,183,12,
+23,195,2,23,194,1,28,248,22,182,12,23,195,2,249,22,184,12,23,196,1,
+250,80,158,44,47,248,22,134,13,2,20,11,10,250,80,158,42,47,248,22,134,
+13,2,20,23,197,1,10,28,23,193,2,249,22,63,248,22,186,12,249,22,184,
+12,23,198,1,247,22,135,13,248,80,159,42,52,35,248,22,65,23,199,1,248,
+80,159,40,52,35,248,22,65,196,249,80,159,36,37,35,2,7,195,27,248,22,
+159,12,23,195,2,28,23,193,2,192,87,94,23,193,1,28,248,22,133,6,23,
+195,2,27,248,22,181,12,195,28,192,192,248,22,182,12,195,11,87,94,28,28,
+248,22,160,12,23,195,2,10,27,248,22,159,12,23,196,2,28,23,193,2,192,
+87,94,23,193,1,28,248,22,133,6,23,196,2,27,248,22,181,12,23,197,2,
+28,23,193,2,192,87,94,23,193,1,248,22,182,12,23,197,2,11,12,250,22,
+168,8,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,160,12,23,195,2,249,22,138,8,248,22,161,12,
+23,197,2,2,21,249,22,138,8,247,22,152,7,2,21,27,28,248,22,133,6,
+23,196,2,23,195,2,248,22,142,7,248,22,164,12,23,197,2,28,249,22,147,
+13,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,133,6,195,248,22,167,12,195,194,27,248,22,
+172,6,23,195,1,249,22,168,12,248,22,145,7,250,22,153,13,0,6,35,114,
+120,34,47,34,28,249,22,147,13,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,153,
+13,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,158,42,35,2,21,28,248,22,133,6,194,
+248,22,167,12,194,193,87,94,28,27,248,22,159,12,23,196,2,28,23,193,2,
+192,87,94,23,193,1,28,248,22,133,6,23,196,2,27,248,22,181,12,23,197,
+2,28,23,193,2,192,87,94,23,193,1,248,22,182,12,23,197,2,11,12,250,
+22,168,8,23,196,2,2,22,23,197,2,28,248,22,181,12,23,195,2,12,248,
+22,183,10,249,22,128,10,248,22,162,6,250,22,181,6,2,23,23,200,1,23,
+201,1,247,22,23,87,94,28,27,248,22,159,12,23,196,2,28,23,193,2,192,
+87,94,23,193,1,28,248,22,133,6,23,196,2,27,248,22,181,12,23,197,2,
+28,23,193,2,192,87,94,23,193,1,248,22,182,12,23,197,2,11,12,250,22,
+168,8,23,196,2,2,22,23,197,2,28,248,22,181,12,23,195,2,12,248,22,
+183,10,249,22,128,10,248,22,162,6,250,22,181,6,2,23,23,200,1,23,201,
+1,247,22,23,87,94,87,94,28,27,248,22,159,12,23,196,2,28,23,193,2,
+192,87,94,23,193,1,28,248,22,133,6,23,196,2,27,248,22,181,12,23,197,
+2,28,23,193,2,192,87,94,23,193,1,248,22,182,12,23,197,2,11,12,250,
+22,168,8,195,2,22,23,197,2,28,248,22,181,12,23,195,2,12,248,22,183,
+10,249,22,128,10,248,22,162,6,250,22,181,6,2,23,199,23,201,1,247,22,
+23,249,22,3,89,162,42,35,48,9,223,2,33,36,196,248,22,183,10,249,22,
+158,10,23,196,1,247,22,23,87,94,87,94,249,80,159,36,37,35,2,7,195,
 249,22,3,80,159,36,51,35,196,251,80,159,38,40,35,2,7,32,0,89,162,
-34,35,43,9,222,33,38,197,198,32,40,89,162,34,40,57,65,99,108,111,111,
-112,222,33,41,28,248,22,71,198,248,195,251,22,181,6,2,24,198,28,248,22,
-71,202,200,250,22,1,22,177,12,203,204,197,27,249,22,177,12,248,22,64,201,
-198,28,248,22,172,12,193,27,250,22,1,22,177,12,196,201,28,248,22,172,12,
-193,192,27,248,22,65,201,28,248,22,71,193,248,198,251,22,181,6,2,24,201,
-28,248,22,71,205,203,250,22,1,22,177,12,206,23,15,200,27,249,22,177,12,
-248,22,64,196,201,28,248,22,172,12,193,27,250,22,1,22,177,12,196,204,28,
-248,22,172,12,193,192,253,2,40,203,204,205,206,23,15,248,22,65,201,253,2,
-40,202,203,204,205,206,248,22,65,200,27,248,22,65,200,28,248,22,71,193,248,
-197,251,22,181,6,2,24,200,28,248,22,71,204,202,250,22,1,22,177,12,205,
-206,199,27,249,22,177,12,248,22,64,196,200,28,248,22,172,12,193,27,250,22,
-1,22,177,12,196,203,28,248,22,172,12,193,192,253,2,40,202,203,204,205,206,
-248,22,65,201,253,2,40,201,202,203,204,205,248,22,65,200,27,247,22,136,13,
-253,2,40,198,199,200,201,202,198,87,95,28,28,248,22,160,12,193,10,27,248,
-22,159,12,194,28,192,192,28,248,22,133,6,194,27,248,22,181,12,195,28,192,
-192,248,22,182,12,195,11,12,252,22,168,8,199,2,25,34,197,198,28,28,248,
-22,133,6,194,10,248,22,185,6,194,12,252,22,168,8,199,2,26,35,197,198,
-91,159,37,11,90,161,37,34,11,248,22,180,12,196,87,94,28,192,12,250,22,
-169,8,200,2,27,198,249,22,7,194,195,91,159,36,11,90,161,36,34,11,87,
-95,28,28,248,22,160,12,195,10,27,248,22,159,12,196,28,192,192,28,248,22,
-133,6,196,27,248,22,181,12,197,28,192,192,248,22,182,12,197,11,12,252,22,
-168,8,2,10,2,25,34,199,200,28,28,248,22,133,6,196,10,248,22,185,6,
-196,12,252,22,168,8,2,10,2,26,35,199,200,91,159,37,11,90,161,37,34,
-11,248,22,180,12,198,87,94,28,192,12,250,22,169,8,2,10,2,27,200,249,
-22,7,194,195,27,249,22,169,12,250,22,152,13,0,18,35,114,120,35,34,40,
-91,46,93,91,94,46,93,42,124,41,36,34,248,22,165,12,200,28,248,22,133,
-6,202,249,22,145,7,203,8,63,201,28,248,22,160,12,198,248,22,161,12,198,
-247,22,162,12,28,248,22,159,12,194,249,22,177,12,195,194,192,91,159,36,11,
-90,161,36,34,11,87,95,28,28,248,22,160,12,195,10,27,248,22,159,12,196,
-28,192,192,28,248,22,133,6,196,27,248,22,181,12,197,28,192,192,248,22,182,
-12,197,11,12,252,22,168,8,2,11,2,25,34,199,200,28,28,248,22,133,6,
-196,10,248,22,185,6,196,12,252,22,168,8,2,11,2,26,35,199,200,91,159,
-37,11,90,161,37,34,11,248,22,180,12,198,87,94,28,192,12,250,22,169,8,
-2,11,2,27,200,249,22,7,194,195,27,249,22,169,12,249,22,131,7,250,22,
-153,13,0,9,35,114,120,35,34,91,46,93,34,248,22,165,12,202,6,1,1,
-95,28,248,22,133,6,201,249,22,145,7,202,8,63,200,28,248,22,160,12,198,
-248,22,161,12,198,247,22,162,12,28,248,22,159,12,194,249,22,177,12,195,194,
-192,249,247,22,184,5,194,11,248,80,158,35,45,9,27,247,22,138,13,249,80,
-158,37,46,28,194,27,248,22,150,7,6,11,11,80,76,84,67,79,76,76,69,
-67,84,83,28,192,192,6,0,0,6,0,0,27,28,195,250,22,177,12,248,22,
+42,35,43,9,222,33,38,197,198,32,40,89,162,42,40,57,65,99,108,111,111,
+112,222,33,41,28,248,22,71,23,199,2,87,94,23,198,1,248,23,196,1,251,
+22,181,6,2,24,23,199,1,28,248,22,71,23,203,2,87,94,23,202,1,23,
+201,1,250,22,1,22,177,12,23,204,1,23,205,1,23,198,1,27,249,22,177,
+12,248,22,64,23,202,2,23,199,2,28,248,22,172,12,23,194,2,27,250,22,
+1,22,177,12,23,197,1,23,202,2,28,248,22,172,12,23,194,2,192,87,94,
+23,193,1,27,248,22,65,23,202,1,28,248,22,71,23,194,2,87,94,23,193,
+1,248,23,199,1,251,22,181,6,2,24,23,202,1,28,248,22,71,23,206,2,
+87,94,23,205,1,23,204,1,250,22,1,22,177,12,23,207,1,23,208,1,23,
+201,1,27,249,22,177,12,248,22,64,23,197,2,23,202,2,28,248,22,172,12,
+23,194,2,27,250,22,1,22,177,12,23,197,1,204,28,248,22,172,12,193,192,
+253,2,40,203,204,205,206,23,15,248,22,65,201,253,2,40,202,203,204,205,206,
+248,22,65,200,87,94,23,193,1,27,248,22,65,23,201,1,28,248,22,71,23,
+194,2,87,94,23,193,1,248,23,198,1,251,22,181,6,2,24,23,201,1,28,
+248,22,71,23,205,2,87,94,23,204,1,23,203,1,250,22,1,22,177,12,23,
+206,1,23,207,1,23,200,1,27,249,22,177,12,248,22,64,23,197,2,23,201,
+2,28,248,22,172,12,23,194,2,27,250,22,1,22,177,12,23,197,1,203,28,
+248,22,172,12,193,192,253,2,40,202,203,204,205,206,248,22,65,201,253,2,40,
+201,202,203,204,205,248,22,65,200,27,247,22,136,13,253,2,40,198,199,200,201,
+202,198,87,95,28,28,248,22,160,12,23,194,2,10,27,248,22,159,12,23,195,
+2,28,23,193,2,192,87,94,23,193,1,28,248,22,133,6,23,195,2,27,248,
+22,181,12,23,196,2,28,23,193,2,192,87,94,23,193,1,248,22,182,12,23,
+196,2,11,12,252,22,168,8,23,200,2,2,25,34,23,198,2,23,199,2,28,
+28,248,22,133,6,23,195,2,10,248,22,185,6,23,195,2,87,94,23,194,1,
+12,252,22,168,8,23,200,2,2,26,35,23,198,2,23,199,1,91,159,37,11,
+90,161,37,34,11,248,22,180,12,23,197,2,87,94,23,195,1,87,94,28,192,
+12,250,22,169,8,23,201,1,2,27,23,199,1,249,22,7,194,195,91,159,36,
+11,90,161,36,34,11,87,95,28,28,248,22,160,12,23,196,2,10,27,248,22,
+159,12,23,197,2,28,23,193,2,192,87,94,23,193,1,28,248,22,133,6,23,
+197,2,27,248,22,181,12,23,198,2,28,23,193,2,192,87,94,23,193,1,248,
+22,182,12,23,198,2,11,12,252,22,168,8,2,10,2,25,34,23,200,2,23,
+201,2,28,28,248,22,133,6,23,197,2,10,248,22,185,6,23,197,2,12,252,
+22,168,8,2,10,2,26,35,23,200,2,23,201,2,91,159,37,11,90,161,37,
+34,11,248,22,180,12,23,199,2,87,94,23,195,1,87,94,28,23,193,2,12,
+250,22,169,8,2,10,2,27,23,201,2,249,22,7,23,195,1,23,196,1,27,
+249,22,169,12,250,22,152,13,0,18,35,114,120,35,34,40,91,46,93,91,94,
+46,93,42,124,41,36,34,248,22,165,12,23,201,1,28,248,22,133,6,23,203,
+2,249,22,145,7,23,204,1,8,63,23,202,1,28,248,22,160,12,23,199,2,
+248,22,161,12,23,199,1,87,94,23,198,1,247,22,162,12,28,248,22,159,12,
+194,249,22,177,12,195,194,192,91,159,36,11,90,161,36,34,11,87,95,28,28,
+248,22,160,12,23,196,2,10,27,248,22,159,12,23,197,2,28,23,193,2,192,
+87,94,23,193,1,28,248,22,133,6,23,197,2,27,248,22,181,12,23,198,2,
+28,23,193,2,192,87,94,23,193,1,248,22,182,12,23,198,2,11,12,252,22,
+168,8,2,11,2,25,34,23,200,2,23,201,2,28,28,248,22,133,6,23,197,
+2,10,248,22,185,6,23,197,2,12,252,22,168,8,2,11,2,26,35,23,200,
+2,23,201,2,91,159,37,11,90,161,37,34,11,248,22,180,12,23,199,2,87,
+94,23,195,1,87,94,28,23,193,2,12,250,22,169,8,2,11,2,27,23,201,
+2,249,22,7,23,195,1,23,196,1,27,249,22,169,12,249,22,131,7,250,22,
+153,13,0,9,35,114,120,35,34,91,46,93,34,248,22,165,12,23,203,1,6,
+1,1,95,28,248,22,133,6,23,202,2,249,22,145,7,23,203,1,8,63,23,
+201,1,28,248,22,160,12,23,199,2,248,22,161,12,23,199,1,87,94,23,198,
+1,247,22,162,12,28,248,22,159,12,194,249,22,177,12,195,194,192,249,247,22,
+184,5,194,11,248,80,158,35,45,9,27,247,22,138,13,249,80,158,37,46,28,
+23,195,2,27,248,22,150,7,6,11,11,80,76,84,67,79,76,76,69,67,84,
+83,28,192,192,6,0,0,6,0,0,27,28,23,196,1,250,22,177,12,248,22,
 134,13,69,97,100,100,111,110,45,100,105,114,247,22,148,7,6,8,8,99,111,
-108,108,101,99,116,115,11,27,248,80,159,40,52,35,249,22,77,201,248,22,73,
-248,22,134,13,72,99,111,108,108,101,99,116,115,45,100,105,114,28,193,249,22,
-63,195,194,192,32,49,89,162,34,37,49,2,19,222,33,50,27,249,22,145,13,
-196,197,28,192,27,248,22,88,194,27,250,2,49,198,199,248,22,97,198,28,249,
-22,191,6,195,2,28,249,22,77,197,194,249,22,63,248,22,168,12,196,194,28,
-249,22,191,6,197,2,28,249,22,77,195,9,249,22,63,248,22,168,12,198,9,
-87,95,28,28,248,22,185,6,194,10,248,22,133,6,194,12,250,22,168,8,2,
-14,6,21,21,98,121,116,101,32,115,116,114,105,110,103,32,111,114,32,115,116,
-114,105,110,103,196,28,28,248,22,72,195,249,22,4,22,159,12,196,11,12,250,
-22,168,8,2,14,6,13,13,108,105,115,116,32,111,102,32,112,97,116,104,115,
-197,250,2,49,197,195,28,248,22,133,6,197,248,22,144,7,197,196,32,52,89,
-162,8,36,38,56,2,19,222,33,55,32,53,89,162,8,36,37,53,70,102,111,
-117,110,100,45,101,120,101,99,222,33,54,28,192,91,159,37,11,90,161,37,34,
-11,248,22,180,12,198,27,28,197,27,248,22,185,12,200,28,249,22,140,8,194,
-201,11,28,248,22,181,12,193,250,2,53,200,201,249,22,177,12,199,197,250,2,
-53,200,201,195,11,28,192,192,27,28,248,22,159,12,195,27,249,22,177,12,197,
-200,28,28,248,22,172,12,193,10,248,22,171,12,193,192,11,11,28,192,192,28,
-198,11,27,248,22,185,12,201,28,249,22,140,8,194,202,11,28,248,22,181,12,
-193,250,2,53,201,202,249,22,177,12,200,197,250,2,53,201,202,195,194,28,248,
-22,71,196,11,27,248,22,184,12,248,22,64,198,27,249,22,177,12,195,196,28,
-248,22,171,12,193,250,2,53,198,199,195,27,248,22,65,199,28,248,22,71,193,
-11,27,248,22,184,12,248,22,64,195,27,249,22,177,12,195,199,28,248,22,171,
-12,193,250,2,53,201,202,195,27,248,22,65,196,28,248,22,71,193,11,27,248,
-22,184,12,248,22,64,195,27,249,22,177,12,195,202,28,248,22,171,12,193,250,
-2,53,204,205,195,251,2,52,204,205,206,248,22,65,199,87,95,28,27,248,22,
-159,12,195,28,192,192,28,248,22,133,6,195,27,248,22,181,12,196,28,192,192,
-248,22,182,12,196,11,12,250,22,168,8,2,15,6,25,25,112,97,116,104,32,
-111,114,32,115,116,114,105,110,103,32,40,115,97,110,115,32,110,117,108,41,196,
-28,28,194,28,27,248,22,159,12,196,28,192,192,28,248,22,133,6,196,27,248,
-22,181,12,197,28,192,192,248,22,182,12,197,11,248,22,181,12,195,11,10,12,
-250,22,168,8,2,15,6,29,29,35,102,32,111,114,32,114,101,108,97,116,105,
-118,101,32,112,97,116,104,32,111,114,32,115,116,114,105,110,103,197,28,28,248,
-22,181,12,194,91,159,37,11,90,161,37,34,11,248,22,180,12,197,249,22,138,
-8,194,68,114,101,108,97,116,105,118,101,11,27,248,22,150,7,6,4,4,80,
-65,84,72,251,2,52,198,199,200,28,196,27,249,80,158,42,46,199,9,28,249,
-22,138,8,247,22,152,7,2,21,249,22,63,248,22,168,12,5,1,46,194,192,
-9,27,248,22,184,12,195,28,248,22,171,12,193,250,2,53,198,199,195,11,250,
-80,158,37,47,196,197,11,250,80,158,37,47,196,11,11,87,94,249,22,189,5,
-247,22,166,4,195,248,22,140,5,249,22,151,3,34,249,22,135,3,197,198,27,
-248,22,134,13,2,20,27,249,80,158,38,47,195,11,27,27,248,22,154,3,198,
-28,192,192,34,27,27,248,22,154,3,200,28,192,192,34,27,249,22,183,4,197,
-89,162,34,34,46,9,224,4,3,33,59,27,248,22,170,4,194,87,94,248,22,
-134,4,21,94,2,17,2,29,248,80,159,41,53,35,193,159,34,20,102,159,34,
-16,1,20,24,65,98,101,103,105,110,16,0,83,158,40,20,99,134,67,35,37,
-117,116,105,108,115,2,1,11,10,10,10,10,10,41,80,158,34,34,20,102,159,
-37,16,17,30,2,1,2,2,193,30,2,1,2,3,193,30,2,1,2,4,193,
-30,2,1,2,5,193,30,2,1,2,6,193,30,2,1,2,7,193,30,2,1,
-2,8,193,30,2,1,2,9,193,30,2,1,2,10,193,30,2,1,2,11,193,
-30,2,1,2,12,193,30,2,1,2,13,193,30,2,1,2,14,193,30,2,1,
-2,15,193,30,2,1,2,16,193,30,2,18,1,20,112,97,114,97,109,101,116,
-101,114,105,122,97,116,105,111,110,45,107,101,121,4,30,2,18,1,23,101,120,
-116,101,110,100,45,112,97,114,97,109,101,116,101,114,105,122,97,116,105,111,110,
-3,16,0,11,11,16,4,2,6,2,5,2,3,2,9,38,11,11,11,16,0,
-16,0,16,0,34,34,11,11,16,0,16,0,16,0,34,34,11,16,11,9,9,
-9,9,9,9,9,9,9,9,9,16,11,2,8,2,7,2,16,2,15,2,13,
-2,12,2,4,2,11,2,14,2,10,2,2,16,11,11,11,11,11,11,11,11,
-11,11,11,11,16,11,2,8,2,7,2,16,2,15,2,13,2,12,2,4,2,
-11,2,14,2,10,2,2,45,45,16,0,16,18,83,158,34,16,2,89,162,34,
-35,47,2,19,223,0,33,30,80,159,34,53,35,83,158,34,16,2,89,162,34,
-35,54,2,19,223,0,33,31,80,159,34,52,35,83,158,34,16,2,89,162,8,
-36,35,43,9,223,0,33,32,80,159,34,51,35,83,158,34,16,2,32,0,89,
-162,34,35,43,2,2,222,33,33,80,159,34,34,35,83,158,34,16,2,249,22,
-135,6,7,92,7,92,80,159,34,35,35,83,158,34,16,2,89,162,34,35,52,
-2,4,223,0,33,34,80,159,34,36,35,83,158,34,16,2,32,0,89,162,34,
-36,48,2,5,222,33,35,80,159,34,37,35,83,158,34,16,2,32,0,89,162,
-34,37,49,2,6,222,33,37,80,159,34,38,35,83,158,34,16,2,89,162,8,
-37,36,46,2,7,223,0,33,39,80,159,34,39,35,83,158,34,16,2,32,0,
-89,162,34,38,50,2,8,222,33,42,80,159,34,40,35,83,158,34,16,2,32,
-0,89,162,34,37,48,2,9,222,33,43,80,159,34,41,35,83,158,34,16,2,
-32,0,89,162,34,36,51,2,10,222,33,44,80,159,34,42,35,83,158,34,16,
-2,32,0,89,162,34,36,52,2,11,222,33,45,80,159,34,43,35,83,158,34,
-16,2,32,0,89,162,34,35,42,2,12,222,33,46,80,159,34,44,35,83,158,
-34,16,2,83,158,37,20,96,95,2,13,89,162,34,34,41,9,223,0,33,47,
-89,162,34,35,51,9,223,0,33,48,80,159,34,45,35,83,158,34,16,2,27,
-248,22,141,13,248,22,144,7,27,28,249,22,138,8,247,22,152,7,2,21,6,
-1,1,59,6,1,1,58,250,22,181,6,6,14,14,40,91,94,126,97,93,42,
-41,126,97,40,46,42,41,195,195,89,162,34,36,46,2,14,223,0,33,51,80,
-159,34,46,35,83,158,34,16,2,83,158,37,20,96,96,2,15,89,162,8,36,
-37,52,9,223,0,33,56,89,162,34,36,45,9,223,0,33,57,89,162,34,35,
-44,9,223,0,33,58,80,159,34,47,35,83,158,34,16,2,89,162,34,36,49,
-2,16,223,0,33,60,80,159,34,48,35,94,29,94,2,17,2,29,11,29,94,
-2,17,69,35,37,109,105,110,45,115,116,120,11,9,9,0};
-    EVAL_ONE_SIZED_STR((char *)expr, 4194);
+108,108,101,99,116,115,11,27,248,80,159,40,52,35,249,22,77,23,202,1,248,
+22,73,248,22,134,13,72,99,111,108,108,101,99,116,115,45,100,105,114,28,23,
+194,2,249,22,63,23,196,1,23,195,1,192,32,49,89,162,42,37,49,2,19,
+222,33,50,27,249,22,145,13,23,197,2,23,198,2,28,23,193,2,87,94,23,
+196,1,27,248,22,88,23,195,2,27,250,2,49,23,199,2,23,200,1,248,22,
+97,23,199,1,28,249,22,191,6,23,196,2,2,28,249,22,77,197,194,87,94,
+23,196,1,249,22,63,248,22,168,12,23,197,1,194,87,95,23,195,1,23,193,
+1,28,249,22,191,6,23,198,2,2,28,249,22,77,195,9,87,94,23,194,1,
+249,22,63,248,22,168,12,23,199,1,9,87,95,28,28,248,22,185,6,194,10,
+248,22,133,6,194,12,250,22,168,8,2,14,6,21,21,98,121,116,101,32,115,
+116,114,105,110,103,32,111,114,32,115,116,114,105,110,103,196,28,28,248,22,72,
+195,249,22,4,22,159,12,196,11,12,250,22,168,8,2,14,6,13,13,108,105,
+115,116,32,111,102,32,112,97,116,104,115,197,250,2,49,197,195,28,248,22,133,
+6,197,248,22,144,7,197,196,32,52,89,162,8,44,38,56,2,19,222,33,55,
+32,53,89,162,8,44,37,53,70,102,111,117,110,100,45,101,120,101,99,222,33,
+54,28,23,193,2,91,159,37,11,90,161,37,34,11,248,22,180,12,23,199,2,
+87,95,23,195,1,23,194,1,27,28,23,198,2,27,248,22,185,12,23,201,2,
+28,249,22,140,8,23,195,2,23,202,2,11,28,248,22,181,12,23,194,2,250,
+2,53,23,201,2,23,202,2,249,22,177,12,23,200,2,23,198,1,250,2,53,
+23,201,2,23,202,2,23,196,1,11,28,23,193,2,192,87,94,23,193,1,27,
+28,248,22,159,12,23,196,2,27,249,22,177,12,23,198,2,23,201,2,28,28,
+248,22,172,12,193,10,248,22,171,12,193,192,11,11,28,23,193,2,192,87,94,
+23,193,1,28,23,199,2,11,27,248,22,185,12,23,202,2,28,249,22,140,8,
+23,195,2,23,203,1,11,28,248,22,181,12,23,194,2,250,2,53,23,202,1,
+23,203,1,249,22,177,12,23,201,1,23,198,1,250,2,53,201,202,195,194,28,
+248,22,71,23,197,2,11,27,248,22,184,12,248,22,64,23,199,2,27,249,22,
+177,12,23,196,1,23,197,2,28,248,22,171,12,23,194,2,250,2,53,198,199,
+195,87,94,23,193,1,27,248,22,65,23,200,1,28,248,22,71,23,194,2,11,
+27,248,22,184,12,248,22,64,23,196,2,27,249,22,177,12,23,196,1,23,200,
+2,28,248,22,171,12,23,194,2,250,2,53,201,202,195,87,94,23,193,1,27,
+248,22,65,23,197,1,28,248,22,71,23,194,2,11,27,248,22,184,12,248,22,
+64,195,27,249,22,177,12,23,196,1,202,28,248,22,171,12,193,250,2,53,204,
+205,195,251,2,52,204,205,206,248,22,65,199,87,95,28,27,248,22,159,12,23,
+196,2,28,23,193,2,192,87,94,23,193,1,28,248,22,133,6,23,196,2,27,
+248,22,181,12,23,197,2,28,23,193,2,192,87,94,23,193,1,248,22,182,12,
+23,197,2,11,12,250,22,168,8,2,15,6,25,25,112,97,116,104,32,111,114,
+32,115,116,114,105,110,103,32,40,115,97,110,115,32,110,117,108,41,23,197,2,
+28,28,23,195,2,28,27,248,22,159,12,23,197,2,28,23,193,2,192,87,94,
+23,193,1,28,248,22,133,6,23,197,2,27,248,22,181,12,23,198,2,28,23,
+193,2,192,87,94,23,193,1,248,22,182,12,23,198,2,11,248,22,181,12,23,
+196,2,11,10,12,250,22,168,8,2,15,6,29,29,35,102,32,111,114,32,114,
+101,108,97,116,105,118,101,32,112,97,116,104,32,111,114,32,115,116,114,105,110,
+103,23,198,2,28,28,248,22,181,12,23,195,2,91,159,37,11,90,161,37,34,
+11,248,22,180,12,23,198,2,249,22,138,8,194,68,114,101,108,97,116,105,118,
+101,11,27,248,22,150,7,6,4,4,80,65,84,72,251,2,52,23,199,1,23,
+200,1,23,201,1,28,23,197,2,27,249,80,158,42,46,23,200,1,9,28,249,
+22,138,8,247,22,152,7,2,21,249,22,63,248,22,168,12,5,1,46,23,195,
+1,192,9,27,248,22,184,12,23,196,1,28,248,22,171,12,193,250,2,53,198,
+199,195,11,250,80,158,37,47,196,197,11,250,80,158,37,47,196,11,11,87,94,
+249,22,189,5,247,22,166,4,195,248,22,140,5,249,22,151,3,34,249,22,135,
+3,197,198,27,248,22,134,13,2,20,27,249,80,158,38,47,23,196,1,11,27,
+27,248,22,154,3,23,199,1,28,192,192,34,27,27,248,22,154,3,23,201,1,
+28,192,192,34,27,249,22,183,4,23,198,1,83,158,38,20,97,95,89,162,42,
+34,46,9,224,4,3,33,59,23,196,1,23,197,1,27,248,22,170,4,23,195,
+1,87,94,248,22,134,4,21,94,2,17,2,29,248,80,159,41,53,35,193,159,
+34,20,103,159,34,16,1,20,24,65,98,101,103,105,110,16,0,83,158,40,20,
+100,137,67,35,37,117,116,105,108,115,2,1,11,10,10,41,80,158,34,34,20,
+103,159,37,16,17,30,2,1,2,2,193,30,2,1,2,3,193,30,2,1,2,
+4,193,30,2,1,2,5,193,30,2,1,2,6,193,30,2,1,2,7,193,30,
+2,1,2,8,193,30,2,1,2,9,193,30,2,1,2,10,193,30,2,1,2,
+11,193,30,2,1,2,12,193,30,2,1,2,13,193,30,2,1,2,14,193,30,
+2,1,2,15,193,30,2,1,2,16,193,30,2,18,1,20,112,97,114,97,109,
+101,116,101,114,105,122,97,116,105,111,110,45,107,101,121,4,30,2,18,1,23,
+101,120,116,101,110,100,45,112,97,114,97,109,101,116,101,114,105,122,97,116,105,
+111,110,3,16,0,11,11,16,4,2,6,2,5,2,3,2,9,38,11,37,34,
+11,16,11,9,9,9,9,9,9,9,9,9,9,9,16,11,2,8,2,7,2,
+16,2,15,2,13,2,12,2,4,2,11,2,14,2,10,2,2,16,11,11,11,
+11,11,11,11,11,11,11,11,11,16,11,2,8,2,7,2,16,2,15,2,13,
+2,12,2,4,2,11,2,14,2,10,2,2,45,45,35,11,11,16,0,16,0,
+16,0,34,34,11,11,11,16,0,16,0,16,0,34,34,16,0,16,18,83,158,
+34,16,2,89,162,42,35,47,2,19,223,0,33,30,80,159,34,53,35,83,158,
+34,16,2,89,162,42,35,54,2,19,223,0,33,31,80,159,34,52,35,83,158,
+34,16,2,89,162,8,44,35,43,9,223,0,33,32,80,159,34,51,35,83,158,
+34,16,2,32,0,89,162,42,35,43,2,2,222,33,33,80,159,34,34,35,83,
+158,34,16,2,249,22,135,6,7,92,7,92,80,159,34,35,35,83,158,34,16,
+2,89,162,42,35,52,2,4,223,0,33,34,80,159,34,36,35,83,158,34,16,
+2,32,0,89,162,42,36,48,2,5,222,33,35,80,159,34,37,35,83,158,34,
+16,2,32,0,89,162,42,37,49,2,6,222,33,37,80,159,34,38,35,83,158,
+34,16,2,89,162,8,45,36,46,2,7,223,0,33,39,80,159,34,39,35,83,
+158,34,16,2,32,0,89,162,42,38,50,2,8,222,33,42,80,159,34,40,35,
+83,158,34,16,2,32,0,89,162,42,37,48,2,9,222,33,43,80,159,34,41,
+35,83,158,34,16,2,32,0,89,162,42,36,51,2,10,222,33,44,80,159,34,
+42,35,83,158,34,16,2,32,0,89,162,42,36,52,2,11,222,33,45,80,159,
+34,43,35,83,158,34,16,2,32,0,89,162,42,35,42,2,12,222,33,46,80,
+159,34,44,35,83,158,34,16,2,83,158,37,20,96,95,2,13,89,162,42,34,
+41,9,223,0,33,47,89,162,42,35,51,9,223,0,33,48,80,159,34,45,35,
+83,158,34,16,2,27,248,22,141,13,248,22,144,7,27,28,249,22,138,8,247,
+22,152,7,2,21,6,1,1,59,6,1,1,58,250,22,181,6,6,14,14,40,
+91,94,126,97,93,42,41,126,97,40,46,42,41,23,196,2,23,196,1,89,162,
+42,36,46,2,14,223,0,33,51,80,159,34,46,35,83,158,34,16,2,83,158,
+37,20,96,96,2,15,89,162,8,44,37,52,9,223,0,33,56,89,162,42,36,
+45,9,223,0,33,57,89,162,42,35,44,9,223,0,33,58,80,159,34,47,35,
+83,158,34,16,2,89,162,42,36,49,2,16,223,0,33,60,80,159,34,48,35,
+94,29,94,2,17,2,29,11,29,94,2,17,69,35,37,109,105,110,45,115,116,
+120,11,9,9,9,34,0};
+    EVAL_ONE_SIZED_STR((char *)expr, 5004);
   }
   {
-    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35,126,9,51,46,57,57,46,48,46,49,49,7,0,0,0,1,0,0,6,0,
-19,0,34,0,48,0,62,0,76,0,0,0,253,0,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,159,34,20,102,159,34,16,1,20,24,65,98,101,
-103,105,110,16,0,83,158,40,20,99,134,69,35,37,98,117,105,108,116,105,110,
-29,11,11,10,10,18,94,11,97,10,34,11,97,159,2,2,34,34,159,2,3,
-34,34,159,2,4,34,34,159,2,5,34,34,159,2,6,34,34,16,0,18,94,
-11,95,35,11,16,0,10,18,94,11,95,8,240,48,117,0,0,11,16,0,34,
-80,158,34,34,20,102,159,34,16,0,16,0,11,11,16,0,34,11,11,11,16,
-0,16,0,16,0,34,34,11,11,16,0,16,0,16,0,34,34,11,11,16,0,
-16,0,16,0,34,34,16,0,16,0,98,2,6,2,5,29,94,2,1,69,35,
-37,102,111,114,101,105,103,110,11,2,4,2,3,2,2,9,9,0};
-    EVAL_ONE_SIZED_STR((char *)expr, 290);
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35,126,9,51,46,57,57,46,48,46,49,51,8,0,0,0,1,0,0,6,0,
+19,0,34,0,48,0,62,0,76,0,108,0,0,0,240,0,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,10,34,11,97,159,2,2,34,34,159,
+2,3,34,34,159,2,4,34,34,159,2,5,34,34,159,2,6,34,34,16,0,
+159,34,20,103,159,34,16,1,20,24,65,98,101,103,105,110,16,0,83,158,40,
+20,100,137,69,35,37,98,117,105,108,116,105,110,29,11,11,10,10,18,96,11,
+41,41,41,34,80,158,34,34,20,103,159,34,16,0,16,0,11,11,16,0,34,
+11,37,34,11,11,16,0,16,0,16,0,34,34,35,11,11,16,0,16,0,16,
+0,34,34,11,11,11,16,0,16,0,16,0,34,34,16,0,16,0,98,2,6,
+2,5,29,94,2,1,69,35,37,102,111,114,101,105,103,110,11,2,4,2,3,
+2,2,9,9,9,34,0};
+    EVAL_ONE_SIZED_STR((char *)expr, 279);
   }
   {
-    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35,126,9,51,46,57,57,46,48,46,49,49,52,0,0,0,1,0,0,3,0,
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35,126,9,51,46,57,57,46,48,46,49,51,52,0,0,0,1,0,0,3,0,
 14,0,41,0,47,0,60,0,74,0,96,0,122,0,134,0,152,0,172,0,184,
 0,200,0,223,0,3,1,8,1,13,1,18,1,23,1,54,1,58,1,66,1,
-74,1,82,1,163,1,199,1,216,1,245,1,17,2,47,2,57,2,87,2,97,
-2,104,2,178,3,190,3,209,3,33,4,45,4,173,4,185,4,30,5,36,5,
-50,5,77,5,148,5,150,5,203,5,93,10,151,10,183,10,0,0,118,13,0,
+74,1,82,1,185,1,230,1,253,1,32,2,67,2,101,2,111,2,145,2,155,
+2,162,2,65,4,77,4,96,4,215,4,227,4,131,5,145,5,6,6,12,6,
+26,6,53,6,138,6,140,6,201,6,118,12,176,12,208,12,0,0,146,15,0,
 0,29,11,11,70,100,108,108,45,115,117,102,102,105,120,1,25,100,101,102,97,
 117,108,116,45,108,111,97,100,47,117,115,101,45,99,111,109,112,105,108,101,100,
 65,113,117,111,116,101,29,94,2,4,67,35,37,117,116,105,108,115,11,29,94,
@@ -342,154 +380,179 @@
 97,107,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,158,36,44,249,80,159,36,47,
-35,195,10,27,28,194,28,249,22,138,8,196,80,158,37,45,80,158,35,46,27,
-248,22,149,4,196,28,248,22,159,12,193,91,159,37,11,90,161,37,34,11,248,
-22,180,12,196,87,95,83,160,36,11,80,158,39,45,198,83,160,36,11,80,158,
-39,46,192,192,11,11,28,192,192,27,247,22,185,5,28,192,192,247,22,135,13,
-20,14,159,80,158,34,38,250,80,158,37,39,249,22,27,11,80,158,39,38,22,
-185,5,28,248,22,159,12,197,196,247,22,135,13,247,194,250,22,177,12,196,198,
-249,80,158,41,37,197,5,3,46,122,111,252,22,177,12,198,200,6,6,6,110,
-97,116,105,118,101,247,22,153,7,249,80,158,43,37,199,80,158,43,34,27,193,
-27,250,22,130,13,196,11,32,0,89,162,8,36,34,39,9,222,11,28,192,249,
-22,63,195,194,11,27,248,194,195,27,250,22,130,13,196,11,32,0,89,162,8,
-36,34,39,9,222,11,28,192,249,22,63,195,194,11,249,247,22,140,13,248,22,
-64,195,195,27,248,194,195,27,250,22,130,13,196,11,32,0,89,162,8,36,34,
-39,9,222,11,28,192,249,22,63,195,194,11,249,247,22,183,5,248,22,64,195,
-195,249,247,22,183,5,194,195,87,94,28,248,80,158,35,36,194,12,250,22,168,
-8,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,196,91,159,40,11,90,161,35,34,11,28,248,22,183,12,200,
-199,27,247,22,185,5,28,192,249,22,184,12,202,194,200,90,161,37,35,11,248,
-22,180,12,193,90,161,35,38,11,28,249,22,138,8,195,68,114,101,108,97,116,
-105,118,101,2,17,193,90,161,35,39,11,247,22,137,13,27,89,162,34,35,48,
-62,122,111,225,7,5,3,33,27,27,89,162,34,35,50,9,225,8,6,4,33,
-28,27,249,22,5,89,162,34,35,46,9,223,5,33,29,202,27,28,194,27,249,
-22,5,89,162,34,35,46,9,223,5,33,30,204,27,28,195,11,193,28,192,192,
-28,193,28,195,28,249,22,147,3,248,22,65,196,248,22,65,198,193,11,11,11,
-11,28,192,249,80,159,46,53,35,202,89,162,34,34,44,9,224,14,2,33,31,
-27,28,196,27,249,22,5,89,162,34,35,46,9,223,7,33,32,205,27,28,196,
-11,193,28,192,192,28,193,28,196,28,249,22,147,3,248,22,65,196,248,22,65,
-199,193,11,11,11,11,28,192,249,80,159,47,53,35,203,89,162,34,34,44,9,
-224,15,2,33,33,249,80,159,47,53,35,203,89,162,34,34,43,9,224,15,7,
-33,34,32,36,89,162,34,35,53,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,145,13,2,37,195,28,
-192,249,22,63,248,22,88,195,27,248,22,97,196,27,249,22,145,13,2,37,195,
-28,192,249,22,63,248,22,88,195,27,248,22,97,196,27,249,22,145,13,2,37,
-195,28,192,249,22,63,248,22,88,195,248,2,36,248,22,97,196,248,22,73,194,
-248,22,73,194,248,22,73,194,32,39,89,162,34,35,53,2,19,222,33,40,28,
-248,22,71,248,22,65,194,249,22,7,9,248,22,64,195,91,159,36,11,90,161,
-36,34,11,27,248,22,65,196,28,248,22,71,248,22,65,194,249,22,7,9,248,
-22,64,195,91,159,36,11,90,161,36,34,11,27,248,22,65,196,28,248,22,71,
-248,22,65,194,249,22,7,9,248,22,64,195,91,159,36,11,90,161,36,34,11,
-248,2,39,248,22,65,196,249,22,7,249,22,63,248,22,64,199,196,195,249,22,
-7,249,22,63,248,22,64,199,196,195,249,22,7,249,22,63,248,22,64,199,196,
-195,27,248,2,36,194,28,194,192,248,2,39,193,87,95,28,248,22,147,4,195,
-12,250,22,168,8,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,207,248,208,195,12,27,27,250,22,126,
-80,158,40,41,248,22,163,13,247,22,147,11,11,28,192,192,27,247,22,120,87,
-94,250,22,125,80,158,41,41,248,22,163,13,247,22,147,11,195,192,250,22,125,
-195,198,66,97,116,116,97,99,104,251,211,197,198,199,10,28,192,250,22,167,8,
-11,196,195,248,22,165,8,194,28,249,22,139,6,194,6,1,1,46,2,17,28,
-249,22,139,6,194,6,2,2,46,46,62,117,112,192,28,249,22,140,8,248,22,
-65,199,196,28,249,22,138,8,248,22,64,199,195,251,22,165,8,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,199,249,22,2,22,65,248,22,78,249,22,63,205,201,12,
-12,247,192,20,14,159,80,158,38,43,249,22,63,247,22,147,11,196,20,14,159,
-80,158,38,38,250,80,158,41,39,249,22,27,11,80,158,43,38,22,131,4,195,
-249,247,22,184,5,197,248,22,52,248,22,163,12,197,87,94,28,28,248,22,159,
-12,196,10,248,22,152,4,196,12,28,197,250,22,167,8,11,6,15,15,98,97,
-100,32,109,111,100,117,108,101,32,112,97,116,104,200,250,22,168,8,2,20,6,
-19,19,109,111,100,117,108,101,45,112,97,116,104,32,111,114,32,112,97,116,104,
-198,28,28,248,22,61,196,249,22,138,8,248,22,64,198,2,4,11,248,22,148,
-4,248,22,88,197,28,28,248,22,61,196,249,22,138,8,248,22,64,198,66,112,
-108,97,110,101,116,11,87,94,28,207,12,20,14,159,80,158,36,38,250,80,158,
-39,39,249,22,27,11,80,158,41,38,22,147,11,196,90,161,35,34,10,249,22,
-132,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,
-27,89,162,34,35,44,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,51,198,27,250,22,126,80,158,
-42,42,249,22,63,203,247,22,136,13,11,28,192,192,91,159,36,11,90,161,36,
-34,11,249,80,159,43,47,35,248,22,54,203,11,27,251,80,158,46,49,2,20,
-201,28,248,22,71,198,198,248,22,64,198,28,248,22,71,198,9,248,22,65,198,
-249,22,177,12,194,28,248,22,71,196,6,7,7,109,97,105,110,46,115,115,249,
-22,156,6,198,6,3,3,46,115,115,28,248,22,133,6,198,27,248,80,159,40,
-54,35,200,27,250,22,126,80,158,43,42,249,22,63,204,198,11,28,192,192,91,
-159,36,11,90,161,36,34,11,249,80,159,44,47,35,203,11,250,22,1,22,177,
-12,198,249,22,77,249,22,2,32,0,89,162,8,36,35,42,9,222,33,45,199,
-248,22,73,199,28,248,22,159,12,198,28,248,22,182,12,198,197,248,22,73,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,138,8,248,22,64,200,2,21,27,250,22,
-126,80,158,42,42,249,22,63,203,247,22,136,13,11,28,192,192,91,159,37,11,
-90,161,36,34,11,249,80,159,44,47,35,248,22,88,204,11,90,161,35,36,11,
-28,248,22,71,248,22,90,203,28,248,22,71,193,249,22,147,13,0,8,35,114,
-120,34,91,46,93,34,195,11,10,27,27,28,196,249,22,77,28,248,22,71,248,
-22,90,23,15,21,93,6,5,5,109,122,108,105,98,249,22,1,22,77,249,22,
-2,80,159,50,55,35,248,22,90,23,18,196,28,248,22,71,195,248,22,73,196,
-194,251,80,158,48,49,2,20,203,248,22,64,197,248,22,65,197,249,22,177,12,
-194,28,197,196,28,248,22,71,196,6,7,7,109,97,105,110,46,115,115,28,249,
-22,147,13,0,8,35,114,120,34,91,46,93,34,198,196,249,22,156,6,198,6,
-3,3,46,115,115,28,249,22,138,8,248,22,64,200,64,102,105,108,101,249,22,
-184,12,248,22,88,200,248,80,159,41,54,35,201,12,87,94,28,28,248,22,159,
-12,193,10,248,22,155,7,193,12,28,199,250,22,167,8,67,114,101,113,117,105,
-114,101,249,22,181,6,6,17,17,98,97,100,32,109,111,100,117,108,101,32,112,
-97,116,104,126,97,28,197,248,22,64,198,6,0,0,202,250,22,168,8,2,20,
-249,22,181,6,6,13,13,109,111,100,117,108,101,32,112,97,116,104,126,97,28,
-197,248,22,64,198,6,0,0,200,27,28,248,22,155,7,194,249,22,160,7,195,
-34,249,22,186,12,248,22,187,12,196,11,27,28,248,22,155,7,195,249,22,160,
-7,196,35,248,80,158,41,50,194,91,159,37,11,90,161,37,34,11,28,248,22,
-155,7,198,250,22,7,2,22,249,22,160,7,202,36,2,22,248,22,180,12,197,
-27,28,248,22,155,7,199,249,22,160,7,200,37,249,80,158,46,51,196,5,0,
-27,28,248,22,155,7,200,249,22,160,7,201,38,248,22,148,4,199,27,27,250,
-22,126,80,158,50,41,248,22,163,13,247,22,147,11,11,28,192,192,27,247,22,
-120,87,94,250,22,125,80,158,51,41,248,22,163,13,247,22,147,11,195,192,87,
-95,28,23,16,27,250,22,126,196,197,11,28,192,12,87,95,27,27,28,248,22,
-17,80,158,50,44,80,158,49,44,247,22,19,250,22,25,248,22,23,196,80,158,
-52,43,195,27,247,22,147,11,249,22,3,89,162,34,35,53,9,226,12,11,2,
-3,33,46,195,248,28,248,22,17,80,158,49,44,32,0,89,162,34,35,40,9,
-222,33,47,80,159,48,56,35,89,162,34,34,49,9,227,14,9,8,4,3,33,
-48,250,22,125,196,197,10,12,28,28,248,22,155,7,201,11,27,248,22,133,6,
-23,15,28,192,192,28,248,22,61,23,15,249,22,138,8,248,22,64,23,17,2,
-21,11,250,22,125,80,158,49,42,28,248,22,133,6,23,17,249,22,63,23,18,
-248,80,159,52,54,35,23,20,249,22,63,23,18,247,22,136,13,252,22,157,7,
-23,15,206,204,202,201,12,193,91,159,36,10,90,161,35,34,10,11,90,161,35,
-35,10,83,158,37,20,96,96,2,20,89,162,34,35,49,9,224,2,0,33,42,
-89,162,34,37,47,9,223,1,33,43,89,162,34,38,8,30,9,225,2,3,0,
-33,49,208,87,95,248,22,130,4,248,80,158,36,48,247,22,147,11,248,22,184,
-5,80,158,35,35,248,22,133,12,80,159,35,40,35,159,34,20,102,159,34,16,
-1,20,24,65,98,101,103,105,110,16,0,83,158,40,20,99,134,66,35,37,98,
-111,111,116,2,1,11,10,10,10,10,10,36,80,158,34,34,20,102,159,38,16,
-19,30,2,1,2,2,193,30,2,1,2,3,193,30,2,5,72,112,97,116,104,
-45,115,116,114,105,110,103,63,10,30,2,5,75,112,97,116,104,45,97,100,100,
-45,115,117,102,102,105,120,7,30,2,6,1,20,112,97,114,97,109,101,116,101,
-114,105,122,97,116,105,111,110,45,107,101,121,4,30,2,6,1,23,101,120,116,
-101,110,100,45,112,97,114,97,109,101,116,101,114,105,122,97,116,105,111,110,3,
-30,2,1,2,7,193,30,2,1,2,8,193,30,2,1,2,9,193,30,2,1,
-2,10,193,30,2,1,2,11,193,30,2,1,2,12,193,30,2,1,2,13,193,
-30,2,1,2,14,193,30,2,1,2,15,193,30,2,5,69,45,102,105,110,100,
-45,99,111,108,0,30,2,5,76,110,111,114,109,97,108,45,99,97,115,101,45,
-112,97,116,104,6,30,2,5,79,112,97,116,104,45,114,101,112,108,97,99,101,
-45,115,117,102,102,105,120,9,30,2,1,2,16,193,16,0,11,11,16,11,2,
-10,2,11,2,8,2,9,2,12,2,13,2,3,2,7,2,2,2,15,2,14,
-45,11,11,11,16,0,16,0,16,0,34,34,11,11,16,0,16,0,16,0,34,
-34,11,16,1,9,16,1,2,16,16,1,11,16,1,2,16,35,35,16,0,16,
-16,83,158,34,16,2,89,162,34,35,43,9,223,0,33,23,80,159,34,56,35,
-83,158,34,16,2,89,162,8,36,35,43,9,223,0,33,24,80,159,34,55,35,
-83,158,34,16,2,89,162,34,35,47,67,103,101,116,45,100,105,114,223,0,33,
-25,80,159,34,54,35,83,158,34,16,2,89,162,34,36,47,68,119,105,116,104,
-45,100,105,114,223,0,33,26,80,159,34,53,35,83,158,34,16,2,248,22,152,
-7,69,115,111,45,115,117,102,102,105,120,80,159,34,34,35,83,158,34,16,2,
-89,162,34,36,58,2,3,223,0,33,35,80,159,34,35,35,83,158,34,16,2,
-32,0,89,162,8,36,35,40,2,7,222,192,80,159,34,40,35,83,158,34,16,
-2,248,22,120,2,18,80,159,34,41,35,83,158,34,16,2,249,22,120,2,18,
-65,101,113,117,97,108,80,159,34,42,35,83,158,34,16,2,247,22,59,80,159,
-34,43,35,83,158,34,16,2,248,22,18,74,109,111,100,117,108,101,45,108,111,
-97,100,105,110,103,80,159,34,44,35,83,158,34,16,2,11,80,158,34,45,83,
-158,34,16,2,11,80,158,34,46,83,158,34,16,2,32,0,89,162,34,36,43,
-2,14,222,33,41,80,159,34,47,35,83,158,34,16,2,89,162,8,36,35,43,
-2,15,223,0,33,50,80,159,34,48,35,83,158,34,16,2,89,162,34,34,42,
-2,16,223,0,33,51,80,159,34,52,35,95,29,94,2,4,68,35,37,107,101,
-114,110,101,108,11,29,94,2,4,69,35,37,109,105,110,45,115,116,120,11,2,
-5,9,9,0};
-    EVAL_ONE_SIZED_STR((char *)expr, 3573);
+35,195,10,27,28,23,195,2,28,249,22,138,8,23,197,2,80,158,37,45,87,
+94,23,195,1,80,158,35,46,27,248,22,149,4,23,197,2,28,248,22,159,12,
+23,194,2,91,159,37,11,90,161,37,34,11,248,22,180,12,23,197,1,87,95,
+83,160,36,11,80,158,39,45,198,83,160,36,11,80,158,39,46,192,192,11,11,
+28,23,193,2,192,87,94,23,193,1,27,247,22,185,5,28,192,192,247,22,135,
+13,20,14,159,80,158,34,38,250,80,158,37,39,249,22,27,11,80,158,39,38,
+22,185,5,28,248,22,159,12,23,198,2,23,197,1,87,94,23,197,1,247,22,
+135,13,247,194,250,22,177,12,23,197,1,23,199,1,249,80,158,41,37,23,198,
+1,5,3,46,122,111,252,22,177,12,23,199,1,23,201,1,6,6,6,110,97,
+116,105,118,101,247,22,153,7,249,80,158,43,37,23,200,1,80,158,43,34,87,
+94,23,194,1,27,23,194,1,27,250,22,130,13,196,11,32,0,89,162,8,44,
+34,39,9,222,11,28,192,249,22,63,195,194,11,27,248,23,195,1,23,196,1,
+27,250,22,130,13,196,11,32,0,89,162,8,44,34,39,9,222,11,28,192,249,
+22,63,195,194,11,249,247,22,140,13,248,22,64,195,195,27,248,23,195,1,23,
+196,1,27,250,22,130,13,196,11,32,0,89,162,8,44,34,39,9,222,11,28,
+192,249,22,63,195,194,11,249,247,22,183,5,248,22,64,195,195,249,247,22,183,
+5,194,195,87,94,28,248,80,158,35,36,23,195,2,12,250,22,168,8,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,40,11,90,161,35,34,11,28,248,22,183,12,23,201,
+2,23,200,1,27,247,22,185,5,28,23,193,2,249,22,184,12,23,203,1,23,
+195,1,200,90,161,37,35,11,248,22,180,12,23,194,2,87,94,23,196,1,90,
+161,35,38,11,28,249,22,138,8,23,196,2,68,114,101,108,97,116,105,118,101,
+87,94,23,194,1,2,17,23,194,1,90,161,35,39,11,247,22,137,13,27,89,
+162,42,35,48,62,122,111,225,7,5,3,33,27,27,83,158,38,20,97,94,89,
+162,42,35,50,9,225,8,6,4,33,28,23,197,1,27,249,22,5,89,162,42,
+35,46,9,223,5,33,29,23,203,2,27,28,23,195,2,27,249,22,5,83,158,
+38,20,97,94,89,162,42,35,46,9,223,5,33,30,23,198,1,23,205,2,27,
+28,23,196,2,11,193,28,192,192,28,193,28,23,196,2,28,249,22,147,3,248,
+22,65,196,248,22,65,23,199,2,193,11,11,11,87,94,23,195,1,11,28,23,
+193,2,249,80,159,46,53,35,202,89,162,42,34,44,9,224,14,2,33,31,87,
+94,23,193,1,27,28,23,197,2,27,249,22,5,83,158,38,20,97,94,89,162,
+42,35,46,9,223,7,33,32,23,200,1,23,206,1,27,28,196,11,193,28,192,
+192,28,193,28,196,28,249,22,147,3,248,22,65,196,248,22,65,199,193,11,11,
+11,11,28,192,249,80,159,47,53,35,203,89,162,42,34,44,9,224,15,2,33,
+33,249,80,159,47,53,35,203,89,162,42,34,43,9,224,15,7,33,34,32,36,
+89,162,42,35,53,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,145,13,2,37,23,196,2,28,23,193,
+2,87,94,23,194,1,249,22,63,248,22,88,23,196,2,27,248,22,97,23,197,
+1,27,249,22,145,13,2,37,23,196,2,28,23,193,2,87,94,23,194,1,249,
+22,63,248,22,88,23,196,2,27,248,22,97,23,197,1,27,249,22,145,13,2,
+37,23,196,2,28,23,193,2,87,94,23,194,1,249,22,63,248,22,88,23,196,
+2,248,2,36,248,22,97,23,197,1,248,22,73,194,248,22,73,194,248,22,73,
+194,32,39,89,162,42,35,53,2,19,222,33,40,28,248,22,71,248,22,65,23,
+195,2,249,22,7,9,248,22,64,195,91,159,36,11,90,161,36,34,11,27,248,
+22,65,23,197,2,28,248,22,71,248,22,65,23,195,2,249,22,7,9,248,22,
+64,23,196,1,91,159,36,11,90,161,36,34,11,27,248,22,65,23,197,2,28,
+248,22,71,248,22,65,23,195,2,249,22,7,9,248,22,64,23,196,1,91,159,
+36,11,90,161,36,34,11,248,2,39,248,22,65,23,197,2,249,22,7,249,22,
+63,248,22,64,23,200,1,23,197,1,23,196,1,249,22,7,249,22,63,248,22,
+64,23,200,1,23,197,1,23,196,1,249,22,7,249,22,63,248,22,64,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,147,4,195,12,250,22,168,8,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,126,80,158,40,41,248,22,
+163,13,247,22,147,11,11,28,23,193,2,192,87,94,23,193,1,27,247,22,120,
+87,94,250,22,125,80,158,41,41,248,22,163,13,247,22,147,11,195,192,250,22,
+125,195,198,66,97,116,116,97,99,104,251,211,197,198,199,10,28,192,250,22,167,
+8,11,196,195,248,22,165,8,194,28,249,22,139,6,194,6,1,1,46,2,17,
+28,249,22,139,6,194,6,2,2,46,46,62,117,112,192,28,249,22,140,8,248,
+22,65,23,200,2,23,197,1,28,249,22,138,8,248,22,64,23,200,2,23,196,
+1,251,22,165,8,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,65,248,22,78,249,22,63,23,206,1,23,202,1,12,12,247,192,20,14,159,
+80,158,38,43,249,22,63,247,22,147,11,23,197,1,20,14,159,80,158,38,38,
+250,80,158,41,39,249,22,27,11,80,158,43,38,22,131,4,23,196,1,249,247,
+22,184,5,23,198,1,248,22,52,248,22,163,12,23,198,1,87,94,28,28,248,
+22,159,12,23,197,2,10,248,22,152,4,23,197,2,12,28,23,198,2,250,22,
+167,8,11,6,15,15,98,97,100,32,109,111,100,117,108,101,32,112,97,116,104,
+23,201,2,250,22,168,8,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,61,23,197,2,
+249,22,138,8,248,22,64,23,199,2,2,4,11,248,22,148,4,248,22,88,197,
+28,28,248,22,61,23,197,2,249,22,138,8,248,22,64,23,199,2,66,112,108,
+97,110,101,116,11,87,94,28,207,12,20,14,159,80,158,36,38,250,80,158,39,
+39,249,22,27,11,80,158,41,38,22,147,11,23,197,1,90,161,35,34,10,249,
+22,132,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,42,35,44,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,51,23,
+199,2,27,250,22,126,80,158,42,42,249,22,63,23,204,2,247,22,136,13,11,
+28,23,193,2,192,87,94,23,193,1,91,159,36,11,90,161,36,34,11,249,80,
+159,43,47,35,248,22,54,23,204,2,11,27,251,80,158,46,49,2,20,23,202,
+1,28,248,22,71,23,199,2,23,199,2,248,22,64,23,199,2,28,248,22,71,
+23,199,2,9,248,22,65,23,199,2,249,22,177,12,23,195,1,28,248,22,71,
+23,197,1,87,94,23,197,1,6,7,7,109,97,105,110,46,115,115,249,22,156,
+6,23,199,1,6,3,3,46,115,115,28,248,22,133,6,23,199,2,87,94,23,
+194,1,27,248,80,159,40,54,35,23,201,2,27,250,22,126,80,158,43,42,249,
+22,63,23,205,2,23,199,2,11,28,23,193,2,192,87,94,23,193,1,91,159,
+36,11,90,161,36,34,11,249,80,159,44,47,35,23,204,2,11,250,22,1,22,
+177,12,23,199,1,249,22,77,249,22,2,32,0,89,162,8,44,35,42,9,222,
+33,45,23,200,1,248,22,73,23,200,1,28,248,22,159,12,23,199,2,87,94,
+23,194,1,28,248,22,182,12,23,199,2,23,198,2,248,22,73,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,138,8,248,22,64,23,201,2,2,21,27,250,22,126,
+80,158,42,42,249,22,63,23,204,2,247,22,136,13,11,28,23,193,2,192,87,
+94,23,193,1,91,159,37,11,90,161,36,34,11,249,80,159,44,47,35,248,22,
+88,23,205,2,11,90,161,35,36,11,28,248,22,71,248,22,90,23,204,2,28,
+248,22,71,23,194,2,249,22,147,13,0,8,35,114,120,34,91,46,93,34,23,
+196,2,11,10,27,27,28,23,197,2,249,22,77,28,248,22,71,248,22,90,23,
+208,2,21,93,6,5,5,109,122,108,105,98,249,22,1,22,77,249,22,2,80,
+159,50,55,35,248,22,90,23,211,2,23,197,2,28,248,22,71,23,196,2,248,
+22,73,23,197,2,23,195,2,251,80,158,48,49,2,20,23,204,1,248,22,64,
+23,198,2,248,22,65,23,198,1,249,22,177,12,23,195,1,28,23,198,1,87,
+94,23,196,1,23,197,1,28,248,22,71,23,197,1,87,94,23,197,1,6,7,
+7,109,97,105,110,46,115,115,28,249,22,147,13,0,8,35,114,120,34,91,46,
+93,34,23,199,2,23,197,1,249,22,156,6,23,199,1,6,3,3,46,115,115,
+28,249,22,138,8,248,22,64,23,201,2,64,102,105,108,101,249,22,184,12,248,
+22,88,23,201,2,248,80,159,41,54,35,23,202,2,12,87,94,28,28,248,22,
+159,12,23,194,2,10,248,22,155,7,23,194,2,87,94,23,200,1,12,28,23,
+200,2,250,22,167,8,67,114,101,113,117,105,114,101,249,22,181,6,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,64,23,199,2,6,0,0,23,203,1,87,94,23,200,1,250,22,168,8,
+2,20,249,22,181,6,6,13,13,109,111,100,117,108,101,32,112,97,116,104,126,
+97,28,23,198,2,248,22,64,23,199,2,6,0,0,23,201,2,27,28,248,22,
+155,7,23,195,2,249,22,160,7,23,196,2,34,249,22,186,12,248,22,187,12,
+23,197,2,11,27,28,248,22,155,7,23,196,2,249,22,160,7,23,197,2,35,
+248,80,158,41,50,23,195,2,91,159,37,11,90,161,37,34,11,28,248,22,155,
+7,23,199,2,250,22,7,2,22,249,22,160,7,23,203,2,36,2,22,248,22,
+180,12,23,198,2,87,95,23,195,1,23,193,1,27,28,248,22,155,7,23,200,
+2,249,22,160,7,23,201,2,37,249,80,158,46,51,23,197,2,5,0,27,28,
+248,22,155,7,23,201,2,249,22,160,7,23,202,2,38,248,22,148,4,23,200,
+2,27,27,250,22,126,80,158,50,41,248,22,163,13,247,22,147,11,11,28,23,
+193,2,192,87,94,23,193,1,27,247,22,120,87,94,250,22,125,80,158,51,41,
+248,22,163,13,247,22,147,11,195,192,87,95,28,23,209,1,27,250,22,126,23,
+197,2,197,11,28,23,193,1,12,87,95,27,27,28,248,22,17,80,158,50,44,
+80,158,49,44,247,22,19,250,22,25,248,22,23,23,197,2,80,158,52,43,23,
+196,1,27,247,22,147,11,249,22,3,83,158,38,20,97,94,89,162,42,35,53,
+9,226,12,11,2,3,33,46,23,195,1,23,196,1,248,28,248,22,17,80,158,
+49,44,32,0,89,162,42,35,40,9,222,33,47,80,159,48,56,35,89,162,42,
+34,49,9,227,14,9,8,4,3,33,48,250,22,125,23,197,1,197,10,12,28,
+28,248,22,155,7,23,202,1,11,27,248,22,133,6,23,208,2,28,192,192,28,
+248,22,61,23,208,2,249,22,138,8,248,22,64,23,210,2,2,21,11,250,22,
+125,80,158,49,42,28,248,22,133,6,23,210,2,249,22,63,23,211,1,248,80,
+159,52,54,35,23,213,1,87,94,23,210,1,249,22,63,23,211,1,247,22,136,
+13,252,22,157,7,23,208,1,23,207,1,23,205,1,23,203,1,201,12,193,91,
+159,36,10,90,161,35,34,10,11,90,161,35,35,10,83,158,37,20,96,96,2,
+20,89,162,42,35,49,9,224,2,0,33,42,89,162,42,37,47,9,223,1,33,
+43,89,162,42,38,8,30,9,225,2,3,0,33,49,208,87,95,248,22,130,4,
+248,80,158,36,48,247,22,147,11,248,22,184,5,80,158,35,35,248,22,133,12,
+80,159,35,40,35,159,34,20,103,159,34,16,1,20,24,65,98,101,103,105,110,
+16,0,83,158,40,20,100,137,66,35,37,98,111,111,116,2,1,11,10,10,36,
+80,158,34,34,20,103,159,38,16,19,30,2,1,2,2,193,30,2,1,2,3,
+193,30,2,5,72,112,97,116,104,45,115,116,114,105,110,103,63,10,30,2,5,
+75,112,97,116,104,45,97,100,100,45,115,117,102,102,105,120,7,30,2,6,1,
+20,112,97,114,97,109,101,116,101,114,105,122,97,116,105,111,110,45,107,101,121,
+4,30,2,6,1,23,101,120,116,101,110,100,45,112,97,114,97,109,101,116,101,
+114,105,122,97,116,105,111,110,3,30,2,1,2,7,193,30,2,1,2,8,193,
+30,2,1,2,9,193,30,2,1,2,10,193,30,2,1,2,11,193,30,2,1,
+2,12,193,30,2,1,2,13,193,30,2,1,2,14,193,30,2,1,2,15,193,
+30,2,5,69,45,102,105,110,100,45,99,111,108,0,30,2,5,76,110,111,114,
+109,97,108,45,99,97,115,101,45,112,97,116,104,6,30,2,5,79,112,97,116,
+104,45,114,101,112,108,97,99,101,45,115,117,102,102,105,120,9,30,2,1,2,
+16,193,16,0,11,11,16,11,2,10,2,11,2,8,2,9,2,12,2,13,2,
+3,2,7,2,2,2,15,2,14,45,11,37,34,11,16,1,9,16,1,2,16,
+16,1,11,16,1,2,16,35,35,35,11,11,16,0,16,0,16,0,34,34,11,
+11,11,16,0,16,0,16,0,34,34,16,0,16,16,83,158,34,16,2,89,162,
+42,35,43,9,223,0,33,23,80,159,34,56,35,83,158,34,16,2,89,162,8,
+44,35,43,9,223,0,33,24,80,159,34,55,35,83,158,34,16,2,89,162,42,
+35,47,67,103,101,116,45,100,105,114,223,0,33,25,80,159,34,54,35,83,158,
+34,16,2,89,162,42,36,47,68,119,105,116,104,45,100,105,114,223,0,33,26,
+80,159,34,53,35,83,158,34,16,2,248,22,152,7,69,115,111,45,115,117,102,
+102,105,120,80,159,34,34,35,83,158,34,16,2,89,162,42,36,58,2,3,223,
+0,33,35,80,159,34,35,35,83,158,34,16,2,32,0,89,162,8,44,35,40,
+2,7,222,192,80,159,34,40,35,83,158,34,16,2,248,22,120,2,18,80,159,
+34,41,35,83,158,34,16,2,249,22,120,2,18,65,101,113,117,97,108,80,159,
+34,42,35,83,158,34,16,2,247,22,59,80,159,34,43,35,83,158,34,16,2,
+248,22,18,74,109,111,100,117,108,101,45,108,111,97,100,105,110,103,80,159,34,
+44,35,83,158,34,16,2,11,80,158,34,45,83,158,34,16,2,11,80,158,34,
+46,83,158,34,16,2,32,0,89,162,42,36,43,2,14,222,33,41,80,159,34,
+47,35,83,158,34,16,2,89,162,8,44,35,43,2,15,223,0,33,50,80,159,
+34,48,35,83,158,34,16,2,89,162,42,34,42,2,16,223,0,33,51,80,159,
+34,52,35,95,29,94,2,4,68,35,37,107,101,114,110,101,108,11,29,94,2,
+4,69,35,37,109,105,110,45,115,116,120,11,2,5,9,9,9,34,0};
+    EVAL_ONE_SIZED_STR((char *)expr, 4113);
   }
diff --git a/src/mzscheme/src/env.c b/src/mzscheme/src/env.c
index f60a82febb..d266da7039 100644
--- a/src/mzscheme/src/env.c
+++ b/src/mzscheme/src/env.c
@@ -79,10 +79,12 @@ static Scheme_Object *namespace_module_registry(int, Scheme_Object *[]);
 static Scheme_Object *variable_module_path(int, Scheme_Object *[]);
 static Scheme_Object *variable_namespace(int, Scheme_Object *[]);
 static Scheme_Object *variable_top_level_namespace(int, Scheme_Object *[]);
+static Scheme_Object *variable_phase(int, Scheme_Object *[]);
 static Scheme_Object *now_transforming(int argc, Scheme_Object *argv[]);
 static Scheme_Object *local_exp_time_value(int argc, Scheme_Object *argv[]);
 static Scheme_Object *local_exp_time_name(int argc, Scheme_Object *argv[]);
 static Scheme_Object *local_context(int argc, Scheme_Object *argv[]);
+static Scheme_Object *local_phase_level(int argc, Scheme_Object *argv[]);
 static Scheme_Object *local_make_intdef_context(int argc, Scheme_Object *argv[]);
 static Scheme_Object *local_introduce(int argc, Scheme_Object *argv[]);
 static Scheme_Object *local_module_introduce(int argc, Scheme_Object *argv[]);
@@ -530,7 +532,11 @@ static void make_init_env(void)
 						      "variable-reference->top-level-namespace",
 						      1, 1),
 			     env);
-
+  scheme_add_global_constant("variable-reference->phase",
+			     scheme_make_prim_w_arity(variable_phase,
+						      "variable-reference->phase",
+						      1, 1),
+			     env);
 
   scheme_add_global_constant("syntax-transforming?", 
 			     scheme_make_prim_w_arity(now_transforming,
@@ -552,6 +558,11 @@ static void make_init_env(void)
 						      "syntax-local-context",
 						      0, 0),
 			     env);
+  scheme_add_global_constant("syntax-local-phase-level", 
+			     scheme_make_prim_w_arity(local_phase_level,
+						      "syntax-local-phase-level",
+						      0, 0),
+			     env);
   scheme_add_global_constant("syntax-local-make-definition-context", 
 			     scheme_make_prim_w_arity(local_make_intdef_context,
 						      "syntax-local-make-definition-context",
@@ -591,7 +602,7 @@ static void make_init_env(void)
   scheme_add_global_constant("syntax-local-module-required-identifiers", 
 			     scheme_make_prim_w_arity(local_module_imports,
 						      "syntax-local-module-required-identifiers",
-						      4, 4),
+						      2, 2),
 			     env);
   scheme_add_global_constant("syntax-local-transforming-module-provides?", 
 			     scheme_make_prim_w_arity(local_module_expanding_provides,
@@ -709,20 +720,14 @@ static void skip_certain_things(Scheme_Object *o, Scheme_Close_Custodian_Client
 /*                        namespace constructors                          */
 /*========================================================================*/
 
-static void create_env_marked_names(Scheme_Env *e)
+void scheme_prepare_env_renames(Scheme_Env *env, int kind)
 {
-  Scheme_Hash_Table *mn;
-  Scheme_Object *rn;
+  if (!env->rename_set) {
+    Scheme_Object *rns;
 
-  /* Set up a rename table, in case an identifier with a let-binding
-     renaming ends up in a definition position: */
-
-  mn = scheme_make_hash_table(SCHEME_hash_ptr);
-  scheme_hash_set(mn, scheme_false, scheme_null);
-  e->marked_names = mn;
-
-  rn = scheme_make_module_rename(e->phase, mzMOD_RENAME_TOPLEVEL, mn);
-  e->rename = rn;
+    rns = scheme_make_module_rename_set(kind, NULL);
+    env->rename_set = rns;
+  }
 }
 
 Scheme_Env *scheme_make_empty_env(void)
@@ -730,7 +735,6 @@ Scheme_Env *scheme_make_empty_env(void)
   Scheme_Env *e; 
 
   e = make_env(NULL, 0, 7);
-  create_env_marked_names(e);
 
   return e;
 }
@@ -843,8 +847,11 @@ void scheme_prepare_exp_env(Scheme_Env *env)
     env->exp_env = eenv;
     eenv->template_env = env;
 
-    if (!env->module && !env->phase)
-      create_env_marked_names(eenv);
+    scheme_prepare_env_renames(env, mzMOD_RENAME_TOPLEVEL);
+    eenv->rename_set = env->rename_set;
+
+    if (env->disallow_unbound)
+      eenv->disallow_unbound = 1;
   }
 }
 
@@ -875,26 +882,19 @@ void scheme_prepare_template_env(Scheme_Env *env)
     }
     eenv->modchain = modchain;
 
+    scheme_prepare_env_renames(env, mzMOD_RENAME_TOPLEVEL);
+    eenv->rename_set = env->rename_set;
+
     env->template_env = eenv;
-    eenv->exp_env = env;
+    eenv->exp_env = env;       
+
+    if (env->disallow_unbound)
+      eenv->disallow_unbound = 1;
   }
 }
 
 void scheme_prepare_label_env(Scheme_Env *env)
 {
-  if (!env->label_env) {
-    /* Used only for its marked_names table */
-    Scheme_Env *lenv;
-    lenv = make_env(NULL, 1, 7);
-    lenv->phase = MZ_LABEL_PHASE;
-    lenv->mod_phase = MZ_LABEL_PHASE;
-    env->label_env = lenv;
-    lenv->module = env->module;
-    lenv->module_registry = env->module_registry;
-    lenv->export_registry = env->export_registry;
-    lenv->insp = env->insp;
-    lenv->modchain = env->modchain;
-  }
 }
 
 Scheme_Env *scheme_clone_module_env(Scheme_Env *menv, Scheme_Env *ns, Scheme_Object *modchain)
@@ -1115,22 +1115,31 @@ scheme_add_global_keyword_symbol(Scheme_Object *name, Scheme_Object *obj,
 
 void scheme_shadow(Scheme_Env *env, Scheme_Object *n, int stxtoo)
 {
-  if (env->rename) {
-    scheme_remove_module_rename(env->rename, n);
-    if (env->module) {
-      scheme_extend_module_rename(env->rename,
-				  env->module->self_modidx,
-				  n, n,
-				  env->module->self_modidx,
-				  n,
-				  env->mod_phase,
-                                  -1,
-				  0);
+  Scheme_Object *rn;
+
+  if (env->rename_set) {
+    rn = scheme_get_module_rename_from_set(env->rename_set,
+                                           scheme_make_integer(env->phase),
+                                           0);
+    if (rn) {
+      scheme_remove_module_rename(rn, n);
+      if (env->module) {
+        scheme_extend_module_rename(rn,
+                                    env->module->self_modidx,
+                                    n, n,
+                                    env->module->self_modidx,
+                                    n,
+                                    env->mod_phase,
+                                    NULL,
+                                    NULL,
+                                    0);
+      }
     }
-  }
+  } else
+    rn = NULL;
 
   if (stxtoo) {
-    if (!env->module || env->rename) {
+    if (!env->module || rn) {
       if (!env->shadowed_syntax) {
 	Scheme_Hash_Table *ht;
 	ht = scheme_make_hash_table(SCHEME_hash_ptr);
@@ -1732,7 +1741,7 @@ Scheme_Object *scheme_hash_module_variable(Scheme_Env *env, Scheme_Object *modid
   return val;
 }
 
-Scheme_Object *scheme_tl_id_sym(Scheme_Env *env, Scheme_Object *id, Scheme_Object *bdg, int is_def)
+Scheme_Object *scheme_tl_id_sym(Scheme_Env *env, Scheme_Object *id, Scheme_Object *bdg, int is_def, Scheme_Object *phase)
 /* The `env' argument can actually be a hash table. */
 {
   Scheme_Object *marks = NULL, *sym, *map, *l, *a, *amarks, *m, *best_match, *cm, *abdg;
@@ -1745,9 +1754,11 @@ Scheme_Object *scheme_tl_id_sym(Scheme_Env *env, Scheme_Object *id, Scheme_Objec
     marked_names = (Scheme_Hash_Table *)env;
   else {
     /* If there's no table and we're not defining, bail out fast */
-    if (!is_def && !env->marked_names)
+    if (!is_def && !env->rename_set)
       return sym;
-    marked_names = env->marked_names;
+    marked_names = scheme_get_module_rename_marked_names(env->rename_set,
+                                                         phase ? phase : scheme_make_integer(env->phase),
+                                                         0);
   }
 
   if (is_def) {
@@ -1762,8 +1773,10 @@ Scheme_Object *scheme_tl_id_sym(Scheme_Env *env, Scheme_Object *id, Scheme_Objec
   }
 
   if (!marked_names) {
-    marked_names = scheme_make_hash_table(SCHEME_hash_ptr);
-    env->marked_names = marked_names;
+    scheme_prepare_env_renames(env, mzMOD_RENAME_TOPLEVEL);
+    marked_names = scheme_get_module_rename_marked_names(env->rename_set,
+                                                         phase ? phase : scheme_make_integer(env->phase),
+                                                         1);
   }
   
   map = scheme_hash_get(marked_names, sym);
@@ -1865,7 +1878,7 @@ Scheme_Object *scheme_tl_id_sym(Scheme_Env *env, Scheme_Object *id, Scheme_Objec
        existing rename. */
     if (!SCHEME_HASHTP((Scheme_Object *)env) && env->module && (is_def != 2)) {
       Scheme_Object *mod, *nm = id;
-      mod = scheme_stx_module_name(&nm, env->phase, NULL, NULL, NULL, NULL);
+      mod = scheme_stx_module_name(&nm, scheme_make_integer(env->phase), NULL, NULL, NULL, NULL, NULL);
       if (mod /* must refer to env->module, otherwise there would
 		 have been an error before getting here */
 	  && NOT_SAME_OBJ(nm, sym))
@@ -2331,9 +2344,10 @@ scheme_lookup_binding(Scheme_Object *find_id, Scheme_Comp_Env *env, int flags,
                       Scheme_Object **_lexical_binding_id)
 {
   Scheme_Comp_Env *frame;
-  int j = 0, p = 0, modpos, skip_stops = 0, mod_defn_phase, module_self_reference = 0;
+  int j = 0, p = 0, modpos, skip_stops = 0, module_self_reference = 0;
   Scheme_Bucket *b;
-  Scheme_Object *val, *modidx, *modname, *src_find_id, *find_global_id;
+  Scheme_Object *val, *modidx, *modname, *src_find_id, *find_global_id, *mod_defn_phase;
+  Scheme_Object *find_id_sym = NULL;
   Scheme_Env *genv;
   long phase;
 
@@ -2372,16 +2386,20 @@ scheme_lookup_binding(Scheme_Object *find_id, Scheme_Comp_Env *env, int flags,
 
       uid = scheme_env_frame_uid(frame);
 
+      if (!find_id_sym 
+          && (frame->flags & SCHEME_CAPTURE_WITHOUT_RENAME))
+        find_id_sym = scheme_stx_get_module_eq_sym(find_id, scheme_make_integer(phase));
+
       for (i = frame->num_bindings; i--; ) {
 	if (frame->values[i]) {
 	  if (frame->uids) 
 	    uid = frame->uids[i];
 	  if (SAME_OBJ(SCHEME_STX_VAL(find_id), SCHEME_STX_VAL(frame->values[i]))
-	      && (scheme_stx_env_bound_eq(find_id, frame->values[i], uid, phase)
+	      && (scheme_stx_env_bound_eq(find_id, frame->values[i], uid, scheme_make_integer(phase))
 		  || ((frame->flags & SCHEME_CAPTURE_WITHOUT_RENAME)
-		      && scheme_stx_module_eq(find_id, frame->values[i], phase))
+		      && scheme_stx_module_eq2(find_id, frame->values[i], scheme_make_integer(phase), find_id_sym))
 		  || ((frame->flags & SCHEME_CAPTURE_LIFTED)
-		      && scheme_stx_bound_eq(find_id, frame->values[i], phase)))) {
+		      && scheme_stx_bound_eq(find_id, frame->values[i], scheme_make_integer(phase))))) {
 	    /* Found a lambda-, let-, etc. bound variable: */
 	    /* First, check certs (don't bind with fewer certs): */
 	    if (!(flags & SCHEME_NO_CERT_CHECKS) 
@@ -2414,12 +2432,14 @@ scheme_lookup_binding(Scheme_Object *find_id, Scheme_Comp_Env *env, int flags,
       for (i = COMPILE_DATA(frame)->num_const; i--; ) {
 	int issame;
 	if (frame->flags & SCHEME_CAPTURE_WITHOUT_RENAME)
-	  issame = scheme_stx_module_eq(find_id, COMPILE_DATA(frame)->const_names[i], phase);
-	else {
+	  issame = scheme_stx_module_eq2(find_id, COMPILE_DATA(frame)->const_names[i], 
+                                         scheme_make_integer(phase), find_id_sym);
+        else {
 	  if (COMPILE_DATA(frame)->const_uids) uid = COMPILE_DATA(frame)->const_uids[i];
 	  issame = (SAME_OBJ(SCHEME_STX_VAL(find_id), 
 			     SCHEME_STX_VAL(COMPILE_DATA(frame)->const_names[i]))
-		    && scheme_stx_env_bound_eq(find_id, COMPILE_DATA(frame)->const_names[i], uid, phase));
+		    && scheme_stx_env_bound_eq(find_id, COMPILE_DATA(frame)->const_names[i], uid, 
+                                               scheme_make_integer(phase)));
 	}
       
 	if (issame) {
@@ -2466,7 +2486,7 @@ scheme_lookup_binding(Scheme_Object *find_id, Scheme_Comp_Env *env, int flags,
   }
 
   src_find_id = find_id;
-  modidx = scheme_stx_module_name(&find_id, phase, NULL, NULL, &mod_defn_phase, NULL);
+  modidx = scheme_stx_module_name(&find_id, scheme_make_integer(phase), NULL, NULL, &mod_defn_phase, NULL, NULL);
 
   /* Used out of context? */
   if (SAME_OBJ(modidx, scheme_undefined)) {
@@ -2488,7 +2508,7 @@ scheme_lookup_binding(Scheme_Object *find_id, Scheme_Comp_Env *env, int flags,
 	 and references to top-level definitions: */
       module_self_reference = 1;
     } else {
-      genv = scheme_module_access(modname, env->genv, mod_defn_phase);
+      genv = scheme_module_access(modname, env->genv, SCHEME_INT_VAL(mod_defn_phase));
 
       if (!genv) {
 	if (env->genv->phase) {
@@ -2496,14 +2516,14 @@ scheme_lookup_binding(Scheme_Object *find_id, Scheme_Comp_Env *env, int flags,
 	     execution. Force all laziness at the prior level 
 	     and try again. */
 	  scheme_module_force_lazy(env->genv, 1);
-	  genv = scheme_module_access(modname, env->genv, mod_defn_phase);
+	  genv = scheme_module_access(modname, env->genv, SCHEME_INT_VAL(mod_defn_phase));
 	}
 
 	if (!genv) {
 	  scheme_wrong_syntax("require", NULL, src_find_id, 
                               "namespace mismatch; reference (phase %d) to a module"
                               " %D that is not available (phase %d)", 
-			      env->genv->phase, modname, mod_defn_phase);
+			      env->genv->phase, modname, SCHEME_INT_VAL(mod_defn_phase));
 	  return NULL;
 	}
       }
@@ -2512,7 +2532,7 @@ scheme_lookup_binding(Scheme_Object *find_id, Scheme_Comp_Env *env, int flags,
     genv = env->genv;
     modname = NULL;
 
-    if (genv->module && !genv->rename) {
+    if (genv->module && genv->disallow_unbound) {
       /* Free variable. Maybe don't continue. */
       if (flags & (SCHEME_SETTING | SCHEME_REFERENCING)) {
         scheme_wrong_syntax(((flags & SCHEME_SETTING) 
@@ -2530,7 +2550,7 @@ scheme_lookup_binding(Scheme_Object *find_id, Scheme_Comp_Env *env, int flags,
     *_menv = genv;
   
   if (!modname && SCHEME_STXP(find_id))
-    find_global_id = scheme_tl_id_sym(env->genv, find_id, NULL, 0);
+    find_global_id = scheme_tl_id_sym(env->genv, find_id, NULL, 0, NULL);
   else
     find_global_id = find_id;
 
@@ -2576,7 +2596,8 @@ scheme_lookup_binding(Scheme_Object *find_id, Scheme_Comp_Env *env, int flags,
     return NULL;
   }
 
-  if (!modname && (flags & (SCHEME_SETTING | SCHEME_REFERENCING)) && (genv->module && !genv->rename)) {
+  if (!modname && (flags & (SCHEME_SETTING | SCHEME_REFERENCING)) 
+      && (genv->module && genv->disallow_unbound)) {
     /* Check for set! of unbound variable: */    
     if (!scheme_lookup_in_table(genv->toplevel, (const char *)find_global_id)) {
       scheme_wrong_syntax(((flags & SCHEME_SETTING) 
@@ -2610,7 +2631,7 @@ scheme_lookup_binding(Scheme_Object *find_id, Scheme_Comp_Env *env, int flags,
     /* Create a module variable reference, so that idx is preserved: */
     return scheme_hash_module_variable(env->genv, modidx, find_id, 
 				       genv->module->insp,
-				       modpos, mod_defn_phase);
+				       modpos, SCHEME_INT_VAL(mod_defn_phase));
   }
 
   if (!modname && (flags & (SCHEME_SETTING | SCHEME_REFERENCING)) && genv->module) {
@@ -2693,7 +2714,7 @@ void scheme_dup_symbol_check(DupCheckRecord *r, const char *where,
 
   if (r->count <= 5) {
     for (i = 0; i < r->count; i++) {
-      if (scheme_stx_bound_eq(symbol, r->syms[i], r->phase))
+      if (scheme_stx_bound_eq(symbol, r->syms[i], scheme_make_integer(r->phase)))
 	scheme_wrong_syntax(where, symbol, form,
 			    "duplicate %s name", what);
     }
@@ -2729,7 +2750,7 @@ int scheme_check_context(Scheme_Env *env, Scheme_Object *name, Scheme_Object *ok
   if (mod && SCHEME_TRUEP(mod) && NOT_SAME_OBJ(ok_modidx, mod)) {
     return 1;
   } else {
-    mod = scheme_stx_module_name(&id, env->phase, NULL, NULL, NULL, NULL);
+    mod = scheme_stx_module_name(&id, scheme_make_integer(env->phase), NULL, NULL, NULL, NULL, NULL);
     if (SAME_OBJ(mod, scheme_undefined))
       return 1;
   }
@@ -3614,10 +3635,8 @@ namespace_identifier(int argc, Scheme_Object *argv[])
   obj = scheme_datum_to_syntax(obj, scheme_false, scheme_false, 1, 0);
 
   /* Renamings: */
-  if (genv->rename)
-    obj = scheme_add_rename(obj, genv->rename);
-  if (genv->exp_env && genv->exp_env->rename)
-    obj = scheme_add_rename(obj, genv->exp_env->rename);
+  if (genv->rename_set)
+    obj = scheme_add_rename(obj, genv->rename_set);
 
   return obj;
 }
@@ -3648,7 +3667,9 @@ namespace_variable_value(int argc, Scheme_Object *argv[])
   else {
     Scheme_Full_Comp_Env inlined_e;
 
-    id = scheme_make_renamed_stx(argv[0], genv->rename);
+    scheme_prepare_env_renames(genv, mzMOD_RENAME_TOPLEVEL);
+
+    id = scheme_make_renamed_stx(argv[0], genv->rename_set);
 
     inlined_e.base.num_bindings = 0;
     inlined_e.base.next = NULL;
@@ -3774,8 +3795,8 @@ namespace_mapped_symbols(int argc, Scheme_Object *argv[])
     }
   }
 
-  if (env->rename)
-    scheme_list_module_rename(env->rename, mapped);
+  if (env->rename_set)
+    scheme_list_module_rename(env->rename_set, mapped);
 
   l = scheme_null;
   for (i = mapped->size; i--; ) {
@@ -3816,7 +3837,9 @@ static Scheme_Object *do_variable_namespace(const char *who, int tl, int argc, S
                       0, argc, argv);
 
   ph = env->phase;
-  if (tl) {
+  if (tl == 2) {
+    return scheme_make_integer(ph);
+  } else if (tl) {
     while (ph--) {
       env = env->template_env;
     }
@@ -3846,6 +3869,11 @@ static Scheme_Object *variable_top_level_namespace(int argc, Scheme_Object *argv
   return do_variable_namespace("variable-reference->top-level-namespace", 1, argc, argv);
 }
 
+static Scheme_Object *variable_phase(int argc, Scheme_Object *argv[])
+{
+  return do_variable_namespace("variable-reference->phase", 2, argc, argv);
+}
+
 static Scheme_Object *variable_module_path(int argc, Scheme_Object *argv[])
 {
   Scheme_Object *v;
@@ -4016,6 +4044,19 @@ local_context(int argc, Scheme_Object *argv[])
     return scheme_intern_symbol("expression");
 }
 
+static Scheme_Object *
+local_phase_level(int argc, Scheme_Object *argv[])
+{
+  Scheme_Thread *p = scheme_current_thread;
+  int phase;
+
+  phase = (p->current_local_env
+           ? p->current_local_env->genv->phase
+           : 0);
+
+  return scheme_make_integer(phase);
+}
+
 static Scheme_Object *
 local_make_intdef_context(int argc, Scheme_Object *argv[])
 {
@@ -4079,22 +4120,9 @@ local_module_introduce(int argc, Scheme_Object *argv[])
 	v = scheme_stx_to_rename(env->genv->module->rn_stx);
 	s = scheme_add_rename(s, v);
       }
-      if (env->genv->module->et_rn_stx && !SAME_OBJ(scheme_true, env->genv->module->et_rn_stx)) {
-	v = scheme_stx_to_rename(env->genv->module->et_rn_stx);
-	s = scheme_add_rename(s, v);
-      }
-      if (env->genv->module->dt_rn_stx && !SAME_OBJ(scheme_true, env->genv->module->dt_rn_stx)) {
-	v = scheme_stx_to_rename(env->genv->module->dt_rn_stx);
-	s = scheme_add_rename(s, v);
-      }
     } else {
-      if (env->genv->rename)
-	s = scheme_add_rename(s, env->genv->rename);
-      if (env->genv->et_rename)
-	s = scheme_add_rename(s, env->genv->et_rename);
-      if (env->genv->dt_rename) {
-	s = scheme_add_rename(s, env->genv->dt_rename);
-      }
+      if (env->genv->rename_set)
+	s = scheme_add_rename(s, env->genv->rename_set);
     }
   }
 
@@ -4326,12 +4354,16 @@ local_module_imports(int argc, Scheme_Object *argv[])
   if (SCHEME_TRUEP(argv[0]) && !scheme_is_module_path(argv[0]))
     scheme_wrong_type("syntax-local-module-required-identifiers", "module-path or #f", 0, argc, argv);
   
+  if (!SCHEME_FALSEP(argv[1]) 
+      && !SAME_OBJ(scheme_true, argv[1])
+      && !SCHEME_INTP(argv[1])
+      && !SCHEME_BIGNUMP(argv[1]))
+    scheme_wrong_type("syntax-local-module-required-identifiers", "exact integer, #f, or #t", 1, argc, argv);
+  
   return scheme_module_imported_list(scheme_current_thread->current_local_env->genv,
                                      scheme_current_thread->current_local_bindings,
                                      argv[0],
-                                     SCHEME_TRUEP(argv[1]),
-                                     SCHEME_TRUEP(argv[2]),
-                                     SCHEME_TRUEP(argv[3]));
+                                     argv[1]);
 }
 
 static Scheme_Object *
diff --git a/src/mzscheme/src/error.c b/src/mzscheme/src/error.c
index ecfb4d27a2..fdbc5c8393 100644
--- a/src/mzscheme/src/error.c
+++ b/src/mzscheme/src/error.c
@@ -1553,7 +1553,7 @@ static void do_wrong_syntax(const char *where,
  	  if (scheme_current_thread->current_local_env)
 	    phase = scheme_current_thread->current_local_env->genv->phase;
 	  else phase = 0;
-	  scheme_stx_module_name(&first, phase, &mod, &nomwho, NULL, NULL);
+	  scheme_stx_module_name(&first, scheme_make_integer(phase), &mod, &nomwho, NULL, NULL, NULL);
 	}
       }
     } else {
diff --git a/src/mzscheme/src/eval.c b/src/mzscheme/src/eval.c
index 59d4d5fec5..d14bcb1aa4 100644
--- a/src/mzscheme/src/eval.c
+++ b/src/mzscheme/src/eval.c
@@ -4606,13 +4606,13 @@ static Scheme_Object *call_compile_handler(Scheme_Object *form, int immediate_ev
 
 static Scheme_Object *add_renames_unless_module(Scheme_Object *form, Scheme_Env *genv)
 {
-  if (genv->rename) {
+  if (genv->rename_set) {
     if (SCHEME_STX_PAIRP(form)) {
       Scheme_Object *a, *d;
       
       a = SCHEME_STX_CAR(form);
       if (SCHEME_STX_SYMBOLP(a)) {
-	a = scheme_add_rename(a, genv->rename);
+	a = scheme_add_rename(a, genv->rename_set);
 	if (scheme_stx_module_eq(a, scheme_module_stx, 0)) {
 	  /* Don't add renames to the whole module; let the 
 	     module's language take over. */
@@ -4625,14 +4625,8 @@ static Scheme_Object *add_renames_unless_module(Scheme_Object *form, Scheme_Env
     }
   }
 
-  if (genv->rename)
-    form = scheme_add_rename(form, genv->rename);
-  if (genv->exp_env && genv->exp_env->rename)
-    form = scheme_add_rename(form, genv->exp_env->rename);
-  if (genv->template_env && genv->template_env->rename)
-    form = scheme_add_rename(form, genv->template_env->rename);
-  if (genv->dt_rename)
-    form = scheme_add_rename(form, genv->dt_rename);
+  if (genv->rename_set)
+    form = scheme_add_rename(form, genv->rename_set);
 
   return form;
 }
@@ -5343,7 +5337,7 @@ scheme_compile_expand_expr(Scheme_Object *form, Scheme_Comp_Env *env,
     /* If form is a marked name, then force #%top binding.
        This is so temporaries can be used as defined ids. */
     Scheme_Object *nm;
-    nm = scheme_tl_id_sym(env->genv, form, NULL, 0);
+    nm = scheme_tl_id_sym(env->genv, form, NULL, 0, NULL);
     if (!SAME_OBJ(nm, SCHEME_STX_VAL(form))) {
       stx = scheme_datum_to_syntax(top_symbol, scheme_false, scheme_sys_wraps(env), 0, 0);
 
@@ -5738,11 +5732,11 @@ static Scheme_Object *check_top(const char *when, Scheme_Object *form, Scheme_Co
     Scheme_Object *modidx, *symbol = c, *tl_id;
     int bad;
 
-    tl_id = scheme_tl_id_sym(env->genv, symbol, NULL, 0);
+    tl_id = scheme_tl_id_sym(env->genv, symbol, NULL, 0, NULL);
     if (NOT_SAME_OBJ(tl_id, SCHEME_STX_SYM(symbol))) {
       /* Since the module has a rename for this id, it's certainly defined. */
     } else {
-      modidx = scheme_stx_module_name(&symbol, env->genv->phase, NULL, NULL, NULL, NULL);
+      modidx = scheme_stx_module_name(&symbol, scheme_make_integer(env->genv->phase), NULL, NULL, NULL, NULL, NULL);
       if (modidx) {
 	/* If it's an access path, resolve it: */
 	if (env->genv->module
@@ -5753,7 +5747,7 @@ static Scheme_Object *check_top(const char *when, Scheme_Object *form, Scheme_Co
       } else
 	bad = 1;
 
-      if (!env->genv->rename) {
+      if (env->genv->disallow_unbound) {
 	if (bad || !scheme_lookup_in_table(env->genv->toplevel, (const char *)SCHEME_STX_SYM(c))) {
 	  scheme_wrong_syntax(when, NULL, c, 
 			      (env->genv->phase
@@ -5774,7 +5768,7 @@ top_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec,
 
   c = check_top(scheme_compile_stx_string, form, env);
 
-  c = scheme_tl_id_sym(env->genv, c, NULL, 0);
+  c = scheme_tl_id_sym(env->genv, c, NULL, 0, NULL);
 
   if (env->genv->module && !rec[drec].resolve_module_ids) {
     /* Self-reference in a module; need to remember the modidx.  Don't
@@ -8779,7 +8773,7 @@ scheme_make_lifted_defn(Scheme_Object *sys_wraps, Scheme_Object **_id, Scheme_Ob
   Scheme_Object *l;
 
   /* Registers marked id: */
-  scheme_tl_id_sym(env->genv, *_id, scheme_false, 2);
+  scheme_tl_id_sym(env->genv, *_id, scheme_false, 2, NULL);
 
   l = icons(scheme_datum_to_syntax(define_values_symbol, scheme_false, sys_wraps, 0, 0), 
 	    icons(scheme_make_pair(*_id, scheme_null),
diff --git a/src/mzscheme/src/fun.c b/src/mzscheme/src/fun.c
index f655fded3d..35b839e8f3 100644
--- a/src/mzscheme/src/fun.c
+++ b/src/mzscheme/src/fun.c
@@ -2570,73 +2570,73 @@ scheme_apply_macro(Scheme_Object *name, Scheme_Env *menv,
   Scheme_Object *certs;
   certs = rec[drec].certs;
 
- if (SAME_TYPE(SCHEME_TYPE(rator), scheme_id_macro_type)) {
-   Scheme_Object *mark;
+  if (SAME_TYPE(SCHEME_TYPE(rator), scheme_id_macro_type)) {
+    Scheme_Object *mark;
    
-   rator = SCHEME_PTR1_VAL(rator);
-   /* rator is now an identifier */
+    rator = SCHEME_PTR1_VAL(rator);
+    /* rator is now an identifier */
 
-   /* and it's introduced by this expression: */
-   mark = scheme_new_mark();
-   rator = scheme_add_remove_mark(rator, mark);
+    /* and it's introduced by this expression: */
+    mark = scheme_new_mark();
+    rator = scheme_add_remove_mark(rator, mark);
 
-   if (for_set) {
-     Scheme_Object *tail, *setkw;
+    if (for_set) {
+      Scheme_Object *tail, *setkw;
 
-     tail = SCHEME_STX_CDR(code);
-     setkw = SCHEME_STX_CAR(code);
-     tail = SCHEME_STX_CDR(tail);
-     code = scheme_make_pair(setkw, scheme_make_pair(rator, tail));
-     code = scheme_datum_to_syntax(code, orig_code, orig_code, 0, 0);
-   } else if (SCHEME_SYMBOLP(SCHEME_STX_VAL(code)))
-     code = rator;
-   else {
-     code = SCHEME_STX_CDR(code);
-     code = scheme_make_pair(rator, code);
-     code = scheme_datum_to_syntax(code, orig_code, scheme_sys_wraps(env), 0, 0);
-   }
+      tail = SCHEME_STX_CDR(code);
+      setkw = SCHEME_STX_CAR(code);
+      tail = SCHEME_STX_CDR(tail);
+      code = scheme_make_pair(setkw, scheme_make_pair(rator, tail));
+      code = scheme_datum_to_syntax(code, orig_code, orig_code, 0, 0);
+    } else if (SCHEME_SYMBOLP(SCHEME_STX_VAL(code)))
+      code = rator;
+    else {
+      code = SCHEME_STX_CDR(code);
+      code = scheme_make_pair(rator, code);
+      code = scheme_datum_to_syntax(code, orig_code, scheme_sys_wraps(env), 0, 0);
+    }
 
-   code = cert_with_specials(code, mark, menv, orig_code, orig_code, env, env->genv->phase, 0, 0);
+    code = cert_with_specials(code, mark, menv, orig_code, orig_code, env, env->genv->phase, 0, 0);
 
-   code = scheme_stx_track(code, orig_code, name);
+    code = scheme_stx_track(code, orig_code, name);
 
-   return code;
- } else {
-   Scheme_Object *mark, *rands_vec[1];
+    return code;
+  } else {
+    Scheme_Object *mark, *rands_vec[1];
 
-   certs = scheme_stx_extract_certs(code, certs);
+    certs = scheme_stx_extract_certs(code, certs);
  
-   if (SAME_TYPE(SCHEME_TYPE(rator), scheme_set_macro_type))
-     rator = SCHEME_PTR_VAL(rator);
+    if (SAME_TYPE(SCHEME_TYPE(rator), scheme_set_macro_type))
+      rator = SCHEME_PTR_VAL(rator);
 
-   mark = scheme_new_mark();
-   code = scheme_add_remove_mark(code, mark);
+    mark = scheme_new_mark();
+    code = scheme_add_remove_mark(code, mark);
 
-   SCHEME_EXPAND_OBSERVE_MACRO_PRE_X(rec[drec].observer, code);
+    SCHEME_EXPAND_OBSERVE_MACRO_PRE_X(rec[drec].observer, code);
 
-   scheme_on_next_top(env, mark, boundname, certs, 
-		      menv, menv ? menv->link_midx : env->genv->link_midx);
+    scheme_on_next_top(env, mark, boundname, certs, 
+                       menv, menv ? menv->link_midx : env->genv->link_midx);
 
-   rands_vec[0] = code;
-   code = scheme_apply(rator, 1, rands_vec);
+    rands_vec[0] = code;
+    code = scheme_apply(rator, 1, rands_vec);
 
-   SCHEME_EXPAND_OBSERVE_MACRO_POST_X(rec[drec].observer, code);
+    SCHEME_EXPAND_OBSERVE_MACRO_POST_X(rec[drec].observer, code);
 
-   if (!SCHEME_STXP(code)) {
-     scheme_raise_exn(MZEXN_FAIL_CONTRACT,
-		      "%S: return value from syntax expander was not syntax: %V",
-		      SCHEME_STX_SYM(name),
-		      code);
-   }
+    if (!SCHEME_STXP(code)) {
+      scheme_raise_exn(MZEXN_FAIL_CONTRACT,
+                       "%S: return value from syntax expander was not syntax: %V",
+                       SCHEME_STX_SYM(name),
+                       code);
+    }
 
-   code = scheme_add_remove_mark(code, mark);
+    code = scheme_add_remove_mark(code, mark);
 
-   code = cert_with_specials(code, mark, menv, orig_code, orig_code, env, env->genv->phase, 0, 0);
+    code = cert_with_specials(code, mark, menv, orig_code, orig_code, env, env->genv->phase, 0, 0);
 
-   code = scheme_stx_track(code, orig_code, name);
+    code = scheme_stx_track(code, orig_code, name);
 
-   return code;
- }
+    return code;
+  }
 }
 
 /*========================================================================*/
diff --git a/src/mzscheme/src/hash.c b/src/mzscheme/src/hash.c
index e57d540e7a..ef3a3ba30e 100644
--- a/src/mzscheme/src/hash.c
+++ b/src/mzscheme/src/hash.c
@@ -166,6 +166,8 @@ static Scheme_Object *do_hash(Scheme_Hash_Table *table, Scheme_Object *key, int
       _h2 = NULL;
     } else
       _h2 = &h2;
+    if ((long)table->make_hash_indices < 0x100)
+      *(long *)0x0 = 1; /* REMOVEME */
     table->make_hash_indices((void *)key, (long *)&h, (long *)_h2);
     h = h & mask;
     if (_h2) {
diff --git a/src/mzscheme/src/module.c b/src/mzscheme/src/module.c
index c57ebbaade..49c9a6eb76 100644
--- a/src/mzscheme/src/module.c
+++ b/src/mzscheme/src/module.c
@@ -138,6 +138,8 @@ static Scheme_Object *expand_symbol;
 static Scheme_Object *for_syntax_symbol;
 static Scheme_Object *for_template_symbol;
 static Scheme_Object *for_label_symbol;
+static Scheme_Object *for_meta_symbol;
+static Scheme_Object *just_meta_symbol;
 
 static Scheme_Object *quote_symbol;
 static Scheme_Object *lib_symbol;
@@ -196,43 +198,42 @@ typedef void (*Check_Func)(Scheme_Object *prnt_name, Scheme_Object *name,
 			   Scheme_Object *modname, Scheme_Object *srcname, 
 			   int isval, void *data, Scheme_Object *e, Scheme_Object *form, 
                            Scheme_Object *err_src, Scheme_Object *mark_src,
-                           int src_phase_index);
+                           Scheme_Object *to_phase, Scheme_Object *src_phase_index,
+                           Scheme_Object *nominal_export_phase);
 static void parse_requires(Scheme_Object *form,
                            Scheme_Object *base_modidx,
                            Scheme_Env *env,
                            Scheme_Module *for_m,
-                           Scheme_Object *rn, Scheme_Object *post_ex_rn,
-                           Scheme_Object *et_rn, Scheme_Object *et_post_ex_rn,
-                           Scheme_Object *tt_rn, Scheme_Object *tt_post_ex_rn,
-                           Scheme_Object *dt_rn, Scheme_Object *dt_post_ex_rn,
-                           Check_Func ck, void *data, void *et_data, void *tt_data, void *dt_data,
+                           Scheme_Object *rns, Scheme_Object *post_ex_rns,
+                           Check_Func ck, void *data,
                            Scheme_Object *redef_modname,
                            int unpack_kern, int copy_vars, int can_save_marshal, int always_run,
-                           int *all_simple, int *et_all_simple, int *tt_all_simple, int *dt_all_simple);
+                           int *all_simple);
 static void parse_provides(Scheme_Object *form, Scheme_Object *fst, Scheme_Object *e,
-                           Scheme_Hash_Table *provided, Scheme_Object **_reprovided,
-                           Scheme_Hash_Table *et_provided, Scheme_Object **_et_reprovided,
-                           Scheme_Hash_Table *dt_provided, Scheme_Object **_dt_reprovided,
+                           Scheme_Hash_Table *all_provided,
+                           Scheme_Hash_Table *all_reprovided,
                            Scheme_Object *self_modidx,
                            Scheme_Object **_all_defs_out, 
                            Scheme_Object **_et_all_defs_out, 
-                           Scheme_Hash_Table *required, Scheme_Hash_Table *et_required, Scheme_Hash_Table *dt_required, 
+                           Scheme_Hash_Table *tables,
                            Scheme_Object *all_defs, Scheme_Object *all_et_defs,
                            Scheme_Comp_Env *cenv, Scheme_Compile_Info *rec, int drec,
                            Scheme_Object **_expanded);
-static int compute_reprovides(Scheme_Hash_Table *provided, Scheme_Hash_Table *et_provided, Scheme_Hash_Table *dt_provided, 
-                              Scheme_Object *reprovided, 
-                              Scheme_Object *requires, 
-                              Scheme_Hash_Table *required, Scheme_Hash_Table *et_required, Scheme_Hash_Table *dt_required, 
-                              Scheme_Env *genv, Scheme_Object *all_defs, Scheme_Object *all_defs_out, 
+static int compute_reprovides(Scheme_Hash_Table *all_provided,
+                              Scheme_Hash_Table *all_reprovided, 
+                              Scheme_Module *mod_for_requires,
+                              Scheme_Hash_Table *tables,
+                              Scheme_Env *genv, 
+                              Scheme_Object *all_rt_defs, Scheme_Object *all_rt_defs_out, 
+                              Scheme_Object *all_et_defs, Scheme_Object *all_et_defs_out, 
                               Scheme_Object **_exclude_hint,
-                              const char *matching_form, int phase);
-static char *compute_provide_arrays(Scheme_Hash_Table *provided, Scheme_Hash_Table *required,
-                                    Scheme_Module_Phase_Exports *pt,
-                                    Scheme_Env *genv, int def_phase,
+                              const char *matching_form,
+                              Scheme_Object *all_mods, Scheme_Object *all_phases);
+static char *compute_provide_arrays(Scheme_Hash_Table *all_provided, Scheme_Hash_Table *tables,
+                                    Scheme_Module_Exports *me,
+                                    Scheme_Env *genv,
                                     int reprovide_kernel,
-                                    Scheme_Object *form,
-                                    const char *def_way);
+                                    Scheme_Object *form);
 static void start_module(Scheme_Module *m, Scheme_Env *env, int restart, Scheme_Object *syntax_idx, int delay_exptime, int with_tt, Scheme_Object *cycle_list);
 static int expstart_module(Scheme_Module *m, Scheme_Env *env, int restart, Scheme_Object *syntax_idx, int delay_exptime, int with_tt, Scheme_Object *cycle_list);
 static void finish_expstart_module(Scheme_Env *menv, int check_req, int with_tt, Scheme_Object *cycle_list);
@@ -384,10 +385,9 @@ void scheme_init_module(Scheme_Env *env)
 						       1, 1),
 			     env);
   scheme_add_global_constant("module-compiled-imports",
-			     scheme_make_prim_w_arity2(module_compiled_imports,
-						       "module-compiled-imports",
-						       1, 1,
-						       3, 3),
+			     scheme_make_prim_w_arity(module_compiled_imports,
+                                                      "module-compiled-imports",
+                                                      1, 1),
 			     env);
   scheme_add_global_constant("module-compiled-exports",
 			     scheme_make_prim_w_arity2(module_compiled_exports,
@@ -479,6 +479,7 @@ void scheme_finish_kernel(Scheme_Env *env)
   kernel->et_requires = scheme_null;
   kernel->tt_requires = scheme_null;
   kernel->dt_requires = scheme_null;
+  kernel->other_requires = NULL;
 
   kernel->insp = insp;
   
@@ -537,10 +538,14 @@ void scheme_finish_kernel(Scheme_Env *env)
   scheme_initial_env->et_running = 1;
   scheme_initial_env->attached = 1;
 
-  rn = scheme_make_module_rename(0, mzMOD_RENAME_NORMAL, NULL);
+  /* Since this is the first module rename, it's registered as
+     the kernel module rename: */
+  rn = scheme_make_module_rename(scheme_make_integer(0), mzMOD_RENAME_NORMAL, NULL);
   for (i = kernel->me->rt->num_provides; i--; ) {
-    scheme_extend_module_rename(rn, kernel_modidx, exs[i], exs[i], kernel_modidx, exs[i], 0, 0, 0);
+    scheme_extend_module_rename(rn, kernel_modidx, exs[i], exs[i], kernel_modidx, exs[i], 
+                                0, scheme_make_integer(0), NULL, 0);
   }
+  scheme_seal_module_rename(rn);
 
   scheme_sys_wraps(NULL);
 
@@ -606,6 +611,8 @@ void scheme_finish_kernel(Scheme_Env *env)
   REGISTER_SO(for_syntax_symbol);
   REGISTER_SO(for_template_symbol);
   REGISTER_SO(for_label_symbol);
+  REGISTER_SO(for_meta_symbol);
+  REGISTER_SO(just_meta_symbol);
   prefix_symbol = scheme_intern_symbol("prefix");
   only_symbol = scheme_intern_symbol("only");
   rename_symbol = scheme_intern_symbol("rename");
@@ -623,6 +630,8 @@ void scheme_finish_kernel(Scheme_Env *env)
   for_syntax_symbol = scheme_intern_symbol("for-syntax");
   for_template_symbol = scheme_intern_symbol("for-template");
   for_label_symbol = scheme_intern_symbol("for-label");
+  for_meta_symbol = scheme_intern_symbol("for-meta");
+  just_meta_symbol = scheme_intern_symbol("just-meta");
 
   REGISTER_SO(module_name_symbol);
   module_name_symbol = scheme_intern_symbol("enclosing-module-name");
@@ -637,14 +646,11 @@ void scheme_require_from_original_env(Scheme_Env *env, int syntax_only)
 {
   Scheme_Object *rn, *mod_sym;
 
-  rn = env->rename;
-  if (!rn) {
-    rn = scheme_make_module_rename(env->phase, mzMOD_RENAME_TOPLEVEL, NULL);
-    env->rename = rn;
-  }
-
+  scheme_prepare_env_renames(env, mzMOD_RENAME_TOPLEVEL);
+  rn = scheme_get_module_rename_from_set(env->rename_set, scheme_make_integer(0), 1);
+  
   mod_sym = scheme_intern_symbol("module");
-  scheme_extend_module_rename(rn, kernel_modidx, mod_sym, mod_sym, kernel_modidx, mod_sym, 0, 0, 0);
+  scheme_extend_module_rename(rn, kernel_modidx, mod_sym, mod_sym, kernel_modidx, mod_sym, 0, NULL, NULL, 0);
 }
 
 Scheme_Object *scheme_sys_wraps(Scheme_Comp_Env *env)
@@ -664,11 +670,15 @@ Scheme_Object *scheme_sys_wraps(Scheme_Comp_Env *env)
   if ((phase == 1) && scheme_sys_wraps1)
     return scheme_sys_wraps1;
 
-  rn = scheme_make_module_rename(phase, mzMOD_RENAME_NORMAL, NULL);
+  rn = scheme_make_module_rename(scheme_make_integer(phase), 
+                                 mzMOD_RENAME_NORMAL, 
+                                 NULL);
 
   /* Add a module mapping for all kernel provides: */
   scheme_extend_module_rename_with_kernel(rn, kernel_modidx);
   
+  scheme_seal_module_rename(rn);
+
   w = scheme_datum_to_syntax(kernel_symbol, scheme_false, scheme_false, 0, 0);
   w = scheme_add_rename(w, rn);
   if (phase == 0) {
@@ -721,9 +731,16 @@ void scheme_save_initial_module_set(Scheme_Env *env)
   if (!initial_renames) {
     REGISTER_SO(initial_renames);
   }
-  initial_renames = scheme_make_module_rename(0, mzMOD_RENAME_NORMAL, NULL);
-  scheme_append_module_rename(env->rename, initial_renames, 1);
-
+  initial_renames = scheme_make_module_rename(scheme_make_integer(0), 
+                                              mzMOD_RENAME_NORMAL, 
+                                              NULL);
+  scheme_prepare_env_renames(env, mzMOD_RENAME_TOPLEVEL);
+  scheme_append_module_rename(scheme_get_module_rename_from_set(env->rename_set, 
+                                                                scheme_make_integer(0),
+                                                                1),
+                              initial_renames, 
+                              1);
+  
   /* Clone variable bindings: */
   if (!initial_toplevel) {
      REGISTER_SO(initial_toplevel);
@@ -751,12 +768,12 @@ void scheme_install_initial_module_set(Scheme_Env *env)
   }
 
   /* Copy renamings: */
-  if (!env->rename) {
-    Scheme_Object *rn;
-    rn = scheme_make_module_rename(0, mzMOD_RENAME_TOPLEVEL, NULL);
-    env->rename = rn;
-  }
-  scheme_append_module_rename(initial_renames, env->rename, 1);
+  scheme_prepare_env_renames(env, mzMOD_RENAME_TOPLEVEL);
+  scheme_append_module_rename(initial_renames, 
+                              scheme_get_module_rename_from_set(env->rename_set, 
+                                                                scheme_make_integer(0),
+                                                                1),
+                              1);
 
   /* Copy toplevel: */
   {
@@ -766,21 +783,6 @@ void scheme_install_initial_module_set(Scheme_Env *env)
   }
 }
 
-static void annote_marked_names_nonempty(Scheme_Hash_Table *mn_ht)
-{
-  /* Prevents a module-renaming record for macro-introduced bindings
-     from being dropped in syntax objects until the module is fully
-     compiled/expanded. */
-  scheme_hash_set(mn_ht, scheme_false, scheme_null);
-}
-
-static void clear_marked_names_nonempty(Scheme_Hash_Table *mn_ht)
-{
-  /* Clears the annotation, since the module is fully
-     compiled/expanded. */
-  scheme_hash_set(mn_ht, scheme_false, NULL);
-}
-
 /**********************************************************************/
 /*                             parameters                             */
 /**********************************************************************/
@@ -1083,7 +1085,7 @@ static Scheme_Object *dynamic_require_for_syntax(int argc, Scheme_Object *argv[]
 static Scheme_Object *do_namespace_require(Scheme_Env *env, int argc, Scheme_Object *argv[], 
                                            int copy, int etonly)
 {
-  Scheme_Object *form, *rn, *brn, *et_rn, *tt_rn, *dt_rn;
+  Scheme_Object *form, *rns;
 
   if (!env)
     env = scheme_get_env(NULL);
@@ -1092,67 +1094,17 @@ static Scheme_Object *do_namespace_require(Scheme_Env *env, int argc, Scheme_Obj
   form = scheme_datum_to_syntax(scheme_make_pair(require_stx,
 						 scheme_make_pair(argv[0], scheme_null)),
 				scheme_false, scheme_false, 1, 0);
-  
-  rn = scheme_make_module_rename(0, mzMOD_RENAME_TOPLEVEL, NULL);
 
-  scheme_prepare_exp_env(env);
-  et_rn = env->exp_env->rename;
-  if (!et_rn) {
-    et_rn = scheme_make_module_rename(1, mzMOD_RENAME_TOPLEVEL, NULL);
-    env->exp_env->rename = et_rn;
-  }
-
-  scheme_prepare_template_env(env);
-  tt_rn = env->template_env->rename;
-  if (!tt_rn) {
-    tt_rn = scheme_make_module_rename(-1, mzMOD_RENAME_TOPLEVEL, NULL);
-    env->template_env->rename = tt_rn;
-  }
-
-  scheme_prepare_label_env(env);
-  dt_rn = env->dt_rename;
-  if (!dt_rn) {
-    dt_rn = scheme_make_module_rename(MZ_LABEL_PHASE, mzMOD_RENAME_TOPLEVEL, NULL);
-    env->dt_rename = dt_rn;
-  }
+  rns = scheme_make_module_rename_set(mzMOD_RENAME_TOPLEVEL, NULL);
 
   parse_requires(form, scheme_false, env, NULL,
-                 rn, rn, 
-                 et_rn, et_rn,
-                 tt_rn, tt_rn,
-                 dt_rn, dt_rn,
-                 NULL, NULL, NULL, NULL, NULL,
+                 rns, NULL,
+                 NULL /* ck */, NULL /* data */,
                  NULL, 
                  1, copy, 0, !etonly,
-                 NULL, NULL, NULL, NULL);
+                 NULL);
 
-  brn = env->rename;
-  if (!brn) {
-    brn = scheme_make_module_rename(0, mzMOD_RENAME_TOPLEVEL, NULL);
-    env->rename = brn;
-  }
-  scheme_append_module_rename(rn, brn, 0);
-
-  brn = env->exp_env->rename;
-  if (!brn) {
-    brn = scheme_make_module_rename(1, mzMOD_RENAME_TOPLEVEL, NULL);
-    env->exp_env->rename = brn;
-  }
-  scheme_append_module_rename(et_rn, brn, 0);
-
-  brn = env->template_env->rename;
-  if (!brn) {
-    brn = scheme_make_module_rename(-1, mzMOD_RENAME_TOPLEVEL, NULL);
-    env->template_env->rename = brn;
-  }
-  scheme_append_module_rename(tt_rn, brn, 0);
-
-  brn = env->dt_rename;
-  if (!brn) {
-    brn = scheme_make_module_rename(MZ_LABEL_PHASE, mzMOD_RENAME_TOPLEVEL, NULL);
-    env->dt_rename = brn;
-  }
-  scheme_append_module_rename(dt_rn, brn, 0);
+  scheme_append_rename_set_to_env(rns, env);
 
   return scheme_void;
 }
@@ -1179,11 +1131,68 @@ static Scheme_Object *namespace_require_etonly(int argc, Scheme_Object *argv[])
   return do_namespace_require(NULL, argc, argv, 0, 1);
 }
 
-/* I think we don't need to copy phaseless modules for an
-   attach. (If we do try to copy, there's a problem in that the 
-   transitive requirements of a for-label import are not 
-   necessarily loaded, yet.) */
-#define NEED_COPY_NOPHASE 0
+static Scheme_Object *extend_list_depth(Scheme_Object *l, Scheme_Object *n, int with_ht)
+{
+  Scheme_Object *p, *orig;
+  int k;
+
+  if (!SCHEME_INTP(n))
+    scheme_raise_out_of_memory(NULL, NULL);
+
+  k = SCHEME_INT_VAL(n);
+
+  if (SCHEME_NULLP(l)) {
+    if (with_ht)
+      p = (Scheme_Object *)scheme_make_hash_table(SCHEME_hash_ptr);
+    else
+      p = scheme_null;
+    l = scheme_make_pair(p, scheme_null);
+  }
+   
+  orig = l;
+  
+  while (k--) {
+    if (SCHEME_NULLP(SCHEME_CDR(l))) {
+      if (with_ht)
+        p = (Scheme_Object *)scheme_make_hash_table(SCHEME_hash_ptr);
+      else
+        p = scheme_null;
+      p = scheme_make_pair(p, scheme_null);
+      SCHEME_CDR(l) = p;
+    }
+    l = SCHEME_CDR(l);
+  }
+
+  return orig;
+}
+
+static Scheme_Object *extract_at_depth(Scheme_Object *l, Scheme_Object *n)
+{
+  int k = SCHEME_INT_VAL(n);
+
+  while (k--) {
+    l = SCHEME_CDR(l);
+  }
+
+  return SCHEME_CAR(l);
+}
+
+static void set_at_depth(Scheme_Object *l, Scheme_Object *n, Scheme_Object *v)
+{
+  int k = SCHEME_INT_VAL(n);
+
+  while (k--) {
+    l = SCHEME_CDR(l);
+  }
+  
+  SCHEME_CAR(l) = v;
+}
+
+#if 0
+# define LOG_ATTACH(x) x
+#else
+# define LOG_ATTACH(x) /* nothing */
+#endif
 
 static Scheme_Object *namespace_attach_module(int argc, Scheme_Object *argv[])
 {
@@ -1192,12 +1201,8 @@ static Scheme_Object *namespace_attach_module(int argc, Scheme_Object *argv[])
   Scheme_Object *name, *notifies = scheme_null, *a[1], *resolver;
   Scheme_Object *to_modchain, *from_modchain, *l;
   Scheme_Hash_Table *checked, *next_checked, *prev_checked;
-  Scheme_Object *past_checkeds, *future_checkeds, *future_todos, *past_to_modchains;
+  Scheme_Object *past_checkeds, *future_checkeds, *future_todos, *past_to_modchains, *past_todos;
   Scheme_Module *m2;
-# if NEED_COPY_NOPHASE
-  Scheme_Object *nophase_todo;
-  Scheme_Hash_Table *nophase_checked;
-# endif
   int same_namespace, set_env_for_notify = 0, phase;
 
   if (!SCHEME_NAMESPACEP(argv[0]))
@@ -1219,9 +1224,6 @@ static Scheme_Object *namespace_attach_module(int argc, Scheme_Object *argv[])
   todo = scheme_make_pair(name, scheme_null);
   next_phase_todo = scheme_null;
   prev_phase_todo = scheme_null;
-# if NEED_COPY_NOPHASE
-  nophase_todo = scheme_null;
-# endif
   from_modchain = from_env->modchain;
   to_modchain = to_env->modchain;
   phase = 0;
@@ -1231,14 +1233,11 @@ static Scheme_Object *namespace_attach_module(int argc, Scheme_Object *argv[])
   prev_checked = NULL;
 
   past_checkeds = scheme_null;
+  past_todos = scheme_null;
   future_checkeds = scheme_null;
   future_todos = scheme_null;
   past_to_modchains = scheme_null;
 
-# if NEED_COPY_NOPHASE
-  nophase_checked = scheme_make_hash_table(SCHEME_hash_ptr);
-# endif
-
   /* Check whether todo, or anything it needs, is already declared
      incompatibly. Successive iterations of the outer loop explore
      successive phases (i.e, for-syntax levels). */
@@ -1260,7 +1259,7 @@ static Scheme_Object *namespace_attach_module(int argc, Scheme_Object *argv[])
       if (!SAME_OBJ(name, kernel_modname)) {
 	menv = (Scheme_Env *)scheme_hash_get(MODCHAIN_TABLE(from_modchain), name);
 
-	/* printf("Check %d %s\n", phase, SCHEME_SYM_VAL(name)); */
+	LOG_ATTACH(printf("Check %d %s\n", phase, scheme_write_to_string(name, 0)));
 	
 	if (!menv) {
 	  /* Assert: name == argv[1] */
@@ -1320,7 +1319,7 @@ static Scheme_Object *namespace_attach_module(int argc, Scheme_Object *argv[])
 	  while (!SCHEME_NULLP(l)) {
 	    name = scheme_module_resolve(SCHEME_CAR(l), 0);
 	    if (!scheme_hash_get(checked, name)) {
-              /* printf("Add %d %s (%p)\n", phase, SCHEME_SYM_VAL(name), checked); */
+              LOG_ATTACH(printf("Add %d %s (%p)\n", phase, scheme_write_to_string(name, 0), checked));
 	      todo = scheme_make_pair(name, todo);
 	      scheme_hash_set(checked, name, scheme_true);
 	    }
@@ -1339,7 +1338,7 @@ static Scheme_Object *namespace_attach_module(int argc, Scheme_Object *argv[])
 	  while (!SCHEME_NULLP(l)) {
 	    name = scheme_module_resolve(SCHEME_CAR(l), 0);
 	    if (!scheme_hash_get(next_checked, name)) {
-	      /* printf("Add +%d %s (%p)\n", phase+1, SCHEME_SYM_VAL(name), next_checked); */
+	      LOG_ATTACH(printf("Add +%d %s (%p)\n", phase+1, scheme_write_to_string(name, 0), next_checked));
 	      next_phase_todo = scheme_make_pair(name, next_phase_todo);
 	      scheme_hash_set(next_checked, name, scheme_true);
 	    }
@@ -1354,109 +1353,70 @@ static Scheme_Object *namespace_attach_module(int argc, Scheme_Object *argv[])
                 if (!prev_checked)
                   prev_checked = scheme_make_hash_table(SCHEME_hash_ptr);
                 if (!scheme_hash_get(prev_checked, name)) {
-                  /* printf("Add -%d %s (%p)\n", phase-1, SCHEME_SYM_VAL(name), prev_checked); */
+                  LOG_ATTACH(printf("Add -%d %s (%p)\n", phase-1, scheme_write_to_string(name, 0), prev_checked));
                   prev_phase_todo = scheme_make_pair(name, prev_phase_todo);
                   scheme_hash_set(prev_checked, name, scheme_true);
                 }
-              } else {
-#               if NEED_COPY_NOPHASE
-                /* Need (phaseless) declaration, only */
-                if (!same_namespace) {
-                  if (!scheme_hash_get(nophase_checked, name)) {
-                    /* printf("Add -* %s\n", SCHEME_SYM_VAL(name)); */
-                    nophase_todo = scheme_make_pair(name, nophase_todo);
-                    scheme_hash_set(nophase_checked, name, scheme_true);
+              }
+              l = SCHEME_CDR(l);
+            }
+	  }
+
+          if (menv->other_require_names) {
+            Scheme_Hash_Table *oht;
+            int i;
+            oht = menv->other_require_names;
+            for (i = 0; i < oht->size; i++) {
+              if (oht->vals[i]) {
+                Scheme_Object *lphase = oht->keys[i];
+                Scheme_Object *l = oht->vals[i], *todos, *checkeds;
+
+                if (scheme_is_negative(lphase)) {
+                  lphase = scheme_bin_minus(scheme_make_integer(0), lphase);
+                  if (scheme_bin_gt_eq(scheme_make_integer(phase), lphase)) {
+                    lphase = scheme_bin_minus(lphase, scheme_make_integer(2));
+                    past_todos = extend_list_depth(past_todos, lphase, 0);
+                    past_checkeds = extend_list_depth(past_checkeds, lphase, 1);
+                    todos = past_todos;
+                    checkeds = past_checkeds;
+                  } else {
+                    todos = NULL;
+                    checkeds = NULL;
                   }
+                } else {
+                  lphase = scheme_bin_minus(lphase, scheme_make_integer(2));
+                  future_todos = extend_list_depth(future_todos, lphase, 0);
+                  future_checkeds = extend_list_depth(future_checkeds, lphase, 1);
+                  todos = future_todos;
+                  checkeds = future_checkeds;
                 }
-#               endif
-              }
-              l = SCHEME_CDR(l);
-            }
-	  }
-
-#         if NEED_COPY_NOPHASE
-          if (!same_namespace) {
-            l = menv->dt_require_names;
-            if (l) {
-              /* Need (phaseless) declaration, only */
-              while (!SCHEME_NULLP(l)) {
-                name = scheme_module_resolve(SCHEME_CAR(l), 0);
-              
-                if (!scheme_hash_get(nophase_checked, name)) {
-                  /* printf("Add * %s\n", SCHEME_SYM_VAL(name)); */
-                  nophase_todo = scheme_make_pair(name, nophase_todo);
-                  scheme_hash_set(nophase_checked, name, scheme_true);
+                if (todos) {
+                  Scheme_Object *a_todo;
+                  Scheme_Hash_Table *a_checked;
+                  
+                  a_todo = extract_at_depth(todos, lphase);
+                  a_checked = (Scheme_Hash_Table *)extract_at_depth(checkeds, lphase);
+                  
+                  while (!SCHEME_NULLP(l)) {
+                    name = scheme_module_resolve(SCHEME_CAR(l), 0);
+                    if (!scheme_hash_get(a_checked, name)) {
+                      LOG_ATTACH(printf("Add +%d %s (%p)\n", 
+                                        SCHEME_INT_VAL(oht->keys[i]), 
+                                        scheme_write_to_string(name, 0), a_checked));
+                      a_todo = scheme_make_pair(name, a_todo);
+                      scheme_hash_set(a_checked, name, scheme_true);
+                    }
+                    l = SCHEME_CDR(l);
+                  }
+                  
+                  set_at_depth(todos, lphase, a_todo);
                 }
-                l = SCHEME_CDR(l);
               }
             }
           }
-#         endif
         }
       }
     }
-
-#   if NEED_COPY_NOPHASE
-    while (!SCHEME_NULLP(nophase_todo)) {
-      name = SCHEME_CAR(nophase_todo);
-      nophase_todo = SCHEME_CDR(nophase_todo);
-
-      if (!SAME_OBJ(name, kernel_modname)) {
-        if (!scheme_hash_get(to_env->module_registry, name)) {
-          Scheme_Object *m1;
-          int step;
-
-          m1 = (Scheme_Module *)scheme_hash_get(from_env->module_registry, name);
-
-          if (!m1) {
-            /* This shouldn't happen! */
-            scheme_arg_mismatch("namespace-attach-module",
-				"unknown module (in the source namespace, for no-phase): ",
-				name);
-          }
-
-          m2 = (Scheme_Module *)scheme_hash_get(from_env->module_registry, name);
-
-          if (m2 && !SAME_OBJ(m1, m2)) {
-            scheme_raise_exn(MZEXN_FAIL_CONTRACT,
-			     "namespace-attach-module: "
-			     "a different module with the same name is already "
-			     "in the destination namespace, for name: %D",
-			     name);
-          }
-
-          /* Need transitive declarations for all phases 
-             (but not neecssarily instantiations): */
-          for (step = 0; step < 4; step++) {
-            switch (step) {
-            case 0:
-              l = m2->requires;
-              break;
-            case 1:
-              l = m2->et_requires;
-              break;
-            case 2:
-              l = m2->tt_requires;
-              break;
-            case 3:
-            default:
-              l = m2->dt_requires;
-              break;
-            }
-
-            while (!SCHEME_NULLP(l)) {
-              name = scheme_module_resolve(SCHEME_CAR(l), 0);
-              if (!scheme_hash_get(nophase_checked, name)) {
-                nophase_todo = scheme_make_pair(name, nophase_todo);
-                scheme_hash_set(nophase_checked, name, scheme_true);
-              }
-              l = SCHEME_CDR(l);
-            }
-	  }
-        }
-      }
-    }
-#   endif
     
     do {
       if (SCHEME_PAIRP(prev_phase_todo)) {
@@ -1466,7 +1426,12 @@ static Scheme_Object *namespace_attach_module(int argc, Scheme_Object *argv[])
 	
 	next_phase_todo = scheme_null;
 	todo = prev_phase_todo;
-	prev_phase_todo = scheme_null;
+        if (SCHEME_NULLP(past_todos)) {
+          prev_phase_todo = scheme_null;
+        } else {
+          prev_phase_todo = SCHEME_CAR(past_todos);
+	  past_todos = SCHEME_CDR(past_todos);
+        }
 	
 	checked = prev_checked;
 	prev_checked = (Scheme_Hash_Table *)SCHEME_CAR(past_checkeds);
@@ -1503,7 +1468,7 @@ static Scheme_Object *namespace_attach_module(int argc, Scheme_Object *argv[])
 				    || SCHEME_PAIRP(future_todos)));
   }
 
-  /* printf("Done phase: %d\n", phase); */
+  LOG_ATTACH(printf("Done phase: %d\n", phase));
   
   phase += 2; /* represents phase at the start of in future_checkeds */
 
@@ -1534,25 +1499,6 @@ static Scheme_Object *namespace_attach_module(int argc, Scheme_Object *argv[])
   /* Now all the modules to check are in the future_checkeds
      list of hash tables. */
 
-# if NEED_COPY_NOPHASE
-  /* Before we transfer instances, we can transfer modules for which we
-     just need declarations. */
-  {
-    int i;
-    for (i = nophase_checked->size; i--; ) {
-      if (nophase_checked->vals[i]) {
-        name = nophase_checked->keys[i];
-        
-        if (!SAME_OBJ(name, kernel_modname)) {
-          
-          m2 = (Scheme_Module *)scheme_hash_get(from_env->module_registry, name);
-          scheme_hash_set(to_env->module_registry, name, (Scheme_Object *)m2);
-        }
-      }
-    }
-  }
-# endif
-
   /* Go through that list, this time tranferring module instances */
   from_modchain = from_env->modchain;
   to_modchain = to_env->modchain;
@@ -1564,7 +1510,7 @@ static Scheme_Object *namespace_attach_module(int argc, Scheme_Object *argv[])
 
     checked = (Scheme_Hash_Table *)SCHEME_CAR(future_checkeds);
 
-    /* printf("Copying %d (%p)\n", phase, checked); */
+    LOG_ATTACH(printf("Copying %d (%p)\n", phase, checked));
 
     for (i = checked->size; i--; ) {
       if (checked->vals[i]) {
@@ -1573,7 +1519,7 @@ static Scheme_Object *namespace_attach_module(int argc, Scheme_Object *argv[])
 	if (!SAME_OBJ(name, kernel_modname)) {
 	  menv = (Scheme_Env *)scheme_hash_get(MODCHAIN_TABLE(from_modchain), name);
 	  
-	  /* printf("Copy %d %s\n", phase, SCHEME_SYM_VAL(name)); */
+	  LOG_ATTACH(printf("Copy %d %s\n", phase, scheme_write_to_string(name, 0)));
 
 	  menv2 = (Scheme_Env *)scheme_hash_get(MODCHAIN_TABLE(to_modchain), name);
 	  if (!menv2) {
@@ -1926,11 +1872,12 @@ static Scheme_Object *is_module_path(int argc, Scheme_Object **argv)
           : scheme_false);
 }
 
-static int do_add_require_renames(Scheme_Object *rn, 
-                                  Scheme_Hash_Table *required, Scheme_Object *orig_src,
-                                  Scheme_Module *im, Scheme_Module_Phase_Exports *pt,
-                                  Scheme_Object *idx,
-                                  int marshal_k)
+static int do_add_simple_require_renames(Scheme_Object *rn, 
+                                         Scheme_Hash_Table *required, Scheme_Object *orig_src,
+                                         Scheme_Module *im, Scheme_Module_Phase_Exports *pt,
+                                         Scheme_Object *idx,
+                                         Scheme_Object *marshal_phase_index,
+                                         Scheme_Object *src_phase_index)
 {
   int i, saw_mb, numvals;
   Scheme_Object **exs, **exss, **exsns, *midx, *info, *vec, *nml, *mark_src;
@@ -1945,7 +1892,9 @@ static int do_add_require_renames(Scheme_Object *rn,
   if (with_shared) {
     if (!pt->src_modidx)
       pt->src_modidx = im->me->src_modidx;
-    scheme_extend_module_rename_with_shared(rn, idx, pt, marshal_k, 0, 1);
+    scheme_extend_module_rename_with_shared(rn, idx, pt, 
+                                            marshal_phase_index, 
+                                            scheme_make_integer(0), 1);
   }
 
   mark_src = scheme_rename_to_stx(rn);
@@ -1962,7 +1911,7 @@ static int do_add_require_renames(Scheme_Object *rn,
       midx = idx;
     if (!with_shared) {
       scheme_extend_module_rename(rn, midx, exs[i], exsns[i], idx, exs[i], 
-                                  exets ? exets[i] : 0, pt->phase_index, 1);
+                                  exets ? exets[i] : 0, src_phase_index, pt->phase_index, 1);
     }
     if (SAME_OBJ(exs[i], module_begin_symbol))
       saw_mb = 1;
@@ -2008,7 +1957,7 @@ static int do_add_require_renames(Scheme_Object *rn,
   }
 
   if (!with_shared) {
-    info = cons(idx, cons(scheme_make_integer(marshal_k), 
+    info = cons(idx, cons(marshal_phase_index, 
                           cons(scheme_make_integer(0),
                                cons(scheme_null, scheme_false))));
     scheme_save_module_rename_unmarshal(rn, info);
@@ -2017,30 +1966,90 @@ static int do_add_require_renames(Scheme_Object *rn,
   return saw_mb;
 }
 
-static int add_initial_require_renames(Scheme_Object *orig_src,
-                                       Scheme_Object *rn, Scheme_Hash_Table *rn_required,
-                                       Scheme_Object *et_rn, Scheme_Hash_Table *et_required,
-                                       Scheme_Object *dt_rn, Scheme_Hash_Table *dt_required,
-                                       Scheme_Module *im, Scheme_Object *idx)
+static Scheme_Hash_Table *get_required_from_tables(Scheme_Hash_Table *tables, Scheme_Object *phase)
 {
-  int saw_mb;
+  Scheme_Object *vec;
 
-  if (rn)
-    saw_mb = do_add_require_renames(rn, rn_required, orig_src, im, im->me->rt, idx, 0);
-  else
-    saw_mb = 0;
-  if (et_rn && im->me->et)
-    do_add_require_renames(et_rn, et_required, orig_src, im, im->me->et, idx, 1);
-  if (dt_rn && im->me->dt)
-    do_add_require_renames(dt_rn, dt_required, orig_src, im, im->me->dt, idx, 2);
+  if (!tables)
+    return NULL;
+  
+  vec = scheme_hash_get(tables, phase);
+  if (!vec) {
+    Scheme_Hash_Table *res;
+    vec = scheme_make_vector(3, NULL);
+    res = scheme_make_hash_table(SCHEME_hash_ptr);
+    SCHEME_VEC_ELS(vec)[1] = (Scheme_Object *)res;
+    scheme_hash_set(tables, phase, vec);
+  }
 
-  return saw_mb;
+  return (Scheme_Hash_Table *)SCHEME_VEC_ELS(vec)[1];
 }
 
-static int add_require_renames(Scheme_Object *rn, Scheme_Object *et_rn, Scheme_Object *dt_rn, 
-                               Scheme_Module *im, Scheme_Object *idx)
+static int add_simple_require_renames(Scheme_Object *orig_src,
+                                      Scheme_Object *rn_set, 
+                                      Scheme_Hash_Table *tables,
+                                      Scheme_Module *im, Scheme_Object *idx,
+                                      Scheme_Object *import_shift /* = src_phase_index */,
+                                      Scheme_Object *only_export_phase)
 {
-  return add_initial_require_renames(NULL, rn, NULL, et_rn, NULL, dt_rn, NULL, im, idx);
+  int saw_mb;
+  Scheme_Object *phase;
+
+  if (im->me->rt
+      && (!only_export_phase || SAME_OBJ(only_export_phase, scheme_make_integer(0))))
+    saw_mb = do_add_simple_require_renames(scheme_get_module_rename_from_set(rn_set, import_shift, 1), 
+                                           get_required_from_tables(tables, import_shift),
+                                           orig_src, im, im->me->rt, idx,
+                                           scheme_make_integer(0),
+                                           import_shift);
+  else
+    saw_mb = 0;
+  
+  if (im->me->et
+      && (!only_export_phase || SAME_OBJ(only_export_phase, scheme_make_integer(1)))) {
+    if (SCHEME_FALSEP(import_shift))
+      phase = scheme_false;
+    else
+      phase = scheme_bin_plus(scheme_make_integer(1), import_shift);
+    do_add_simple_require_renames(scheme_get_module_rename_from_set(rn_set, phase, 1), 
+                                  get_required_from_tables(tables, phase),
+                                  orig_src, im, im->me->et, idx,
+                                  scheme_make_integer(1),
+                                  import_shift);
+  }
+
+  if (im->me->dt
+      && (!only_export_phase || SAME_OBJ(only_export_phase, scheme_false))) {
+    do_add_simple_require_renames(scheme_get_module_rename_from_set(rn_set, scheme_false, 1), 
+                                  get_required_from_tables(tables, scheme_false),
+                                  orig_src, im, im->me->dt, idx,
+                                  scheme_false,
+                                  import_shift);
+  }
+
+  if (im->me->other_phases) {
+    Scheme_Object *val, *key;
+    int i;
+    for (i = 0; i < im->me->other_phases->size; i++) {
+      val = im->me->other_phases->vals[i];
+      if (val) {
+        key = im->me->other_phases->keys[i];
+        if (!only_export_phase || scheme_eqv(only_export_phase, key)) {
+          if (SCHEME_FALSEP(import_shift))
+            phase = scheme_false;
+          else
+            phase = scheme_bin_plus(key, import_shift);
+          do_add_simple_require_renames(scheme_get_module_rename_from_set(rn_set, phase, 1), 
+                                        get_required_from_tables(tables, phase),
+                                        orig_src, im, (Scheme_Module_Phase_Exports *)val, idx,
+                                        key,
+                                        import_shift);
+        }
+      }
+    }
+  }
+
+  return saw_mb;
 }
 
 Scheme_Object *scheme_module_to_namespace(Scheme_Object *name, Scheme_Env *env)
@@ -2073,224 +2082,103 @@ Scheme_Object *scheme_module_to_namespace(Scheme_Object *name, Scheme_Env *env)
     }
   }
 
-  if (!menv->rename) {
-    if (menv->module->rn_stx) {
-      Scheme_Object *v, *rn;
-      Scheme_Module *m = menv->module;
-
-      if (SAME_OBJ(scheme_true, m->rn_stx)) {
-	/* Reconstruct renames based on defns and requires */
-	int i;
-	Scheme_Module *im;
-	Scheme_Object *l, *idx;
-	Scheme_Hash_Table *mn_ht;
-
-	if (menv->marked_names)
-	  mn_ht = menv->marked_names;
-	else {
-	  mn_ht = scheme_make_hash_table(SCHEME_hash_ptr);
-	  menv->marked_names = mn_ht;
-	}
-
-	rn = scheme_make_module_rename(0, mzMOD_RENAME_NORMAL, mn_ht);
-
-	/* Local, provided: */
-	for (i = 0; i < m->me->rt->num_provides; i++) {
-	  if (SCHEME_FALSEP(m->me->rt->provide_srcs[i])) {
-	    name = m->me->rt->provides[i];
-	    scheme_extend_module_rename(rn, m->self_modidx, name, name, m->self_modidx, name, 0, 0, 0);
-	  }
-	}
-	/* Local, not provided: */
-	for (i = 0; i < m->num_indirect_provides; i++) {
-	  name = m->indirect_provides[i];
-	  scheme_extend_module_rename(rn, m->self_modidx, name, name, m->self_modidx, name, 0, 0, 0);
-	}
-
-	/* Required: */
-	for (l = menv->require_names; SCHEME_PAIRP(l); l = SCHEME_CDR(l)) {
-	  idx = SCHEME_CAR(l);
-	  name = scheme_module_resolve(idx, 0);
-
-	  if (SAME_OBJ(name, kernel_modname))
-	    im = kernel;
-	  else
-	    im = (Scheme_Module *)scheme_hash_get(menv->module_registry, name);
-
-	  add_require_renames(rn, NULL, NULL, im, idx);
-	}
-	
-	rn = scheme_rename_to_stx(rn);
-	m->rn_stx = rn;
-      } else if (SCHEME_PAIRP(m->rn_stx)) {
-	/* Delayed shift: */
-	Scheme_Object *rn_stx, *rn, *midx;
-	rn_stx = SCHEME_CAR(m->rn_stx);
-	midx = SCHEME_CDR(m->rn_stx);
-	rn = scheme_stx_to_rename(rn_stx);
-	rn = scheme_stx_shift_rename(rn, midx, m->self_modidx);
-	rn_stx = scheme_rename_to_stx(rn);
-	m->rn_stx = rn_stx;
-      }
-
-      v = scheme_stx_to_rename(m->rn_stx);
-      rn = scheme_make_module_rename(0, mzMOD_RENAME_NORMAL, NULL);
-      scheme_append_module_rename(v, rn, 1);
-      menv->rename = rn;
-      if (!menv->marked_names) {
-	Scheme_Hash_Table *mn;
-	mn = scheme_module_rename_marked_names(rn);
-	menv->marked_names = mn;
-      }
-    }
-  }
-
   if (menv->lazy_syntax)
     finish_expstart_module_in_namespace(menv, env);
   if (!menv->et_ran)
     scheme_run_module_exptime(menv, 1);
   scheme_prepare_exp_env(menv);
 
-  if (!menv->exp_env->rename) {
-    Scheme_Module *m = menv->module;
+  if (!menv->rename_set_ready) {
+    if (menv->module->rn_stx) {
+      Scheme_Object *rns;
+      Scheme_Module *m = menv->module;
 
-    if (m->et_rn_stx) {
-      Scheme_Object *v, *rn;
+      scheme_prepare_env_renames(menv, mzMOD_RENAME_NORMAL);
 
-      if (SAME_OBJ(scheme_true, m->et_rn_stx)) {
-	/* Reconstruct renames based on defns and requires */
+      if (SAME_OBJ(scheme_true, m->rn_stx)) {
+	/* Reconstruct renames based on defns and requires. This case is
+           used only when it's easy to reconstruct: no renames, no for-syntax
+           definitions, etc. */
+	int i;
 	Scheme_Module *im;
-	Scheme_Object *l, *idx;
-	Scheme_Hash_Table *mn_ht;
+	Scheme_Object *l, *idx, *one_rn, *shift;
 
-	if (menv->exp_env->marked_names)
-	  mn_ht = menv->exp_env->marked_names;
-	else {
-	  mn_ht = scheme_make_hash_table(SCHEME_hash_ptr);
-	  menv->exp_env->marked_names = mn_ht;
+	rns = menv->rename_set;
+        one_rn = scheme_get_module_rename_from_set(rns, scheme_make_integer(0), 1);
+
+	/* Local, provided: */
+	for (i = 0; i < m->me->rt->num_provides; i++) {
+	  if (SCHEME_FALSEP(m->me->rt->provide_srcs[i])) {
+	    name = m->me->rt->provides[i];
+	    scheme_extend_module_rename(one_rn, m->self_modidx, name, name, m->self_modidx, name, 0, 
+                                        scheme_make_integer(0), NULL, 0);
+	  }
+	}
+	/* Local, not provided: */
+	for (i = 0; i < m->num_indirect_provides; i++) {
+	  name = m->indirect_provides[i];
+	  scheme_extend_module_rename(one_rn, m->self_modidx, name, name, m->self_modidx, name, 0, 
+                                      scheme_make_integer(0), NULL, 0);
 	}
 
-	rn = scheme_make_module_rename(0, mzMOD_RENAME_NORMAL, mn_ht);
+        one_rn = scheme_get_module_rename_from_set(rns, scheme_make_integer(1), 1);
 
-	/* Required for syntax: */
-	for (l = menv->et_require_names; SCHEME_PAIRP(l); l = SCHEME_CDR(l)) {
-	  idx = SCHEME_CAR(l);
-	  name = scheme_module_resolve(idx, 0);
-          if (SAME_OBJ(name, kernel_modname))
-	    im = kernel;
-          else
-            im = (Scheme_Module *)scheme_hash_get(menv->module_registry, name);
-	 
-	  add_require_renames(rn, NULL, NULL, im, idx);
-	}
-	/* Required, maybe has for-syntax exports: */
-	for (l = menv->require_names; SCHEME_PAIRP(l); l = SCHEME_CDR(l)) {
-	  idx = SCHEME_CAR(l);
-	  name = scheme_module_resolve(idx, 0);
+	/* Required: */
+        for (i = -4; i < (menv->other_require_names ? menv->other_require_names->size : 0); i++) {
+          switch (i) {
+          case -4:
+            l = menv->require_names;
+            shift = scheme_make_integer(0);
+            break;
+          case -3:
+            l = menv->et_require_names;
+            shift = scheme_make_integer(1);
+            break;
+          case -2:
+            l = menv->tt_require_names;
+            shift = scheme_make_integer(-1);
+            break;
+          case -1:
+            l = menv->dt_require_names;
+            shift = scheme_false;
+            break;
+          default:
+            l = menv->other_require_names->vals[i];
+            shift = menv->other_require_names->keys[i];
+            break;
+          }
 
-	  if (SAME_OBJ(name, kernel_modname))
-	    im = kernel;
-	  else
-	    im = (Scheme_Module *)scheme_hash_get(menv->module_registry, name);
-
-	  add_require_renames(NULL, rn, NULL, im, idx);
-	}
-
-	rn = scheme_rename_to_stx(rn);
-	m->et_rn_stx = rn;
-      } else if (SCHEME_PAIRP(m->et_rn_stx)) {
-	/* Delayed shift: */
-	Scheme_Object *et_rn_stx, *rn, *midx;
-	et_rn_stx = SCHEME_CAR(m->et_rn_stx);
-	midx = SCHEME_CDR(m->et_rn_stx);
-	rn = scheme_stx_to_rename(et_rn_stx);
-	rn = scheme_stx_shift_rename(rn, midx, m->self_modidx);
-	et_rn_stx = scheme_rename_to_stx(rn);
-	m->et_rn_stx = et_rn_stx;
-      }
-
-      v = scheme_stx_to_rename(m->et_rn_stx);
-      rn = scheme_make_module_rename(1, mzMOD_RENAME_NORMAL, NULL);
-      scheme_append_module_rename(v, rn, 1);
-      menv->exp_env->rename = rn;
-      if (!menv->exp_env->marked_names) {
-	Scheme_Hash_Table *mn;
-	mn = scheme_module_rename_marked_names(rn);
-	menv->exp_env->marked_names = mn;
-      }
-    }
-  }
-
-  scheme_prepare_label_env(menv);
-  if (!menv->dt_rename) {
-    Scheme_Module *m = menv->module;
-
-    if (m->dt_rn_stx) {
-      Scheme_Object *v, *rn;
-
-      if (SAME_OBJ(scheme_true, m->dt_rn_stx)) {
-	/* Reconstruct renames based on requires */
-	Scheme_Module *im;
-	Scheme_Object *l, *idx;
-	Scheme_Hash_Table *mn_ht;
-
-	if (menv->label_env->marked_names)
-	  mn_ht = menv->label_env->marked_names;
-	else {
-	  mn_ht = scheme_make_hash_table(SCHEME_hash_ptr);
-	  menv->label_env->marked_names = mn_ht;
-	}
-
-	rn = scheme_make_module_rename(MZ_LABEL_PHASE, mzMOD_RENAME_NORMAL, mn_ht);
-
-	/* Required for label: */
-        if (menv->dt_require_names) {
-          for (l = menv->dt_require_names; SCHEME_PAIRP(l); l = SCHEME_CDR(l)) {
-            idx = SCHEME_CAR(l);
-            name = scheme_module_resolve(idx, 0);
-            if (SAME_OBJ(name, kernel_modname))
-              im = kernel;
-            else
-              im = (Scheme_Module *)scheme_hash_get(menv->module_registry, name);
-            
-            add_require_renames(rn, NULL, NULL, im, idx);
+          if (l) {
+            for (; SCHEME_PAIRP(l); l = SCHEME_CDR(l)) {
+              idx = SCHEME_CAR(l);
+              name = scheme_module_resolve(idx, 0);
+              
+              if (SAME_OBJ(name, kernel_modname))
+                im = kernel;
+              else
+                im = (Scheme_Module *)scheme_hash_get(menv->module_registry, name);
+              
+              add_simple_require_renames(NULL, rns, NULL, im, idx, shift, NULL);
+            }
           }
         }
-	/* Required, maybe has for-label exports: */
-	for (l = menv->require_names; SCHEME_PAIRP(l); l = SCHEME_CDR(l)) {
-	  idx = SCHEME_CAR(l);
-	  name = scheme_module_resolve(idx, 0);
-
-	  if (SAME_OBJ(name, kernel_modname))
-	    im = kernel;
-	  else
-	    im = (Scheme_Module *)scheme_hash_get(menv->module_registry, name);
-
-	  add_require_renames(NULL, NULL, rn, im, idx);
-	}
-
-	rn = scheme_rename_to_stx(rn);
-	m->dt_rn_stx = rn;
-      } else if (SCHEME_PAIRP(m->dt_rn_stx)) {
+	
+	rns = scheme_rename_to_stx(rns);
+	m->rn_stx = rns;
+      } else if (SCHEME_PAIRP(m->rn_stx)) {
 	/* Delayed shift: */
-	Scheme_Object *dt_rn_stx, *rn, *midx;
-	dt_rn_stx = SCHEME_CAR(m->dt_rn_stx);
-	midx = SCHEME_CDR(m->dt_rn_stx);
-	rn = scheme_stx_to_rename(dt_rn_stx);
-	rn = scheme_stx_shift_rename(rn, midx, m->self_modidx);
-	dt_rn_stx = scheme_rename_to_stx(rn);
-	m->dt_rn_stx = dt_rn_stx;
+	Scheme_Object *rn_stx, *midx;
+	rn_stx = SCHEME_CAR(m->rn_stx);
+	midx = SCHEME_CDR(m->rn_stx);
+	rns = scheme_stx_to_rename(rn_stx);
+	rns = scheme_stx_shift_rename_set(rns, midx, m->self_modidx);
+	rn_stx = scheme_rename_to_stx(rns);
+	m->rn_stx = rn_stx;
       }
 
-      v = scheme_stx_to_rename(m->dt_rn_stx);
-      rn = scheme_make_module_rename(MZ_LABEL_PHASE, mzMOD_RENAME_NORMAL, NULL);
-      scheme_append_module_rename(v, rn, 1);
-      menv->dt_rename = rn;
-      if (!menv->label_env->marked_names) {
-	Scheme_Hash_Table *mn;
-	mn = scheme_module_rename_marked_names(rn);
-	menv->label_env->marked_names = mn;
-      }
+      rns = scheme_stx_to_rename(m->rn_stx);
+      scheme_append_rename_set_to_env(rns, menv);
+      menv->rename_set_ready = 1;
     }
   }
 
@@ -2337,17 +2225,41 @@ static Scheme_Object *module_compiled_name(int argc, Scheme_Object *argv[])
 static Scheme_Object *module_compiled_imports(int argc, Scheme_Object *argv[])
 {
   Scheme_Module *m;
-  Scheme_Object *a[4];
+  Scheme_Object *l;
+  int i;
 
   m = scheme_extract_compiled_module(argv[0]);
 
   if (m) {
-    a[0] = m->requires;
-    a[1] = m->et_requires;
-    a[2] = m->tt_requires;
-    a[3] = m->dt_requires;
+    l = scheme_null;
+    if (!SCHEME_NULLP(m->requires))
+      l = scheme_make_pair(scheme_make_pair(scheme_make_integer(0),
+                                            m->requires),
+                           l);
+    if (!SCHEME_NULLP(m->et_requires))
+      l = scheme_make_pair(scheme_make_pair(scheme_make_integer(1),
+                                            m->et_requires),
+                           l);
+    if (!SCHEME_NULLP(m->tt_requires))
+      l = scheme_make_pair(scheme_make_pair(scheme_make_integer(-1),
+                                            m->tt_requires),
+                           l);
+    if (!SCHEME_NULLP(m->dt_requires))
+      l = scheme_make_pair(scheme_make_pair(scheme_false,
+                                            m->dt_requires),
+                           l);
+
+    if (m->other_requires) {
+      for (i = 0; i < m->other_requires->size; i++) {
+        if (m->other_requires->vals[i]) {
+          l = scheme_make_pair(scheme_make_pair(m->other_requires->keys[i],
+                                                m->other_requires->vals[i]),
+                               l);
+        }
+      }
+    }
     
-    return scheme_values(4, a);
+    return l;
   }
 
   scheme_wrong_type("module-compiled-imports", "compiled module declaration", 0, argc, argv);
@@ -2362,47 +2274,61 @@ static Scheme_Object *make_provide_desc(Scheme_Module_Phase_Exports *pt, int i)
                                             : scheme_null),
                                            scheme_null));
 }
-  
+
 static Scheme_Object *module_compiled_exports(int argc, Scheme_Object *argv[])
 {
   Scheme_Module *m;
-  Scheme_Object *a[6];
-  Scheme_Object *ml, *vl;
+  Scheme_Object *a[2];
+  Scheme_Object *ml, *vl, *val_l, *mac_l;
   Scheme_Module_Phase_Exports *pt;
   int i, n, k;
 
   m = scheme_extract_compiled_module(argv[0]);
 
   if (m) {
-    for (k = 0; k < 3; k++) {
+    val_l = scheme_null;
+    mac_l = scheme_null;
+
+    for (k = -3; k < (m->me->other_phases ? m->me->other_phases->size : 0); k++) {
       switch(k) {
-      case 0:
+      case -3:
         pt = m->me->rt;
         break;
-      case 1:
+      case -2:
         pt = m->me->et;
         break;
-      case 2:
-      default:
+      case -1:
         pt = m->me->dt;
         break;
+      default:
+        pt = (Scheme_Module_Phase_Exports *)m->me->other_phases->vals[k];
+        break;
       }
 
-      ml = scheme_null;
-      vl = scheme_null;
-      n = pt->num_var_provides;
-      for (i = pt->num_provides - 1; i >= n; --i) {
-        ml = scheme_make_pair(make_provide_desc(pt, i), ml);
+      if (pt) {
+        ml = scheme_null;
+        vl = scheme_null;
+        n = pt->num_var_provides;
+        for (i = pt->num_provides - 1; i >= n; --i) {
+          ml = scheme_make_pair(make_provide_desc(pt, i), ml);
+        }
+        for (; i >= 0; --i) {
+          vl = scheme_make_pair(make_provide_desc(pt, i), vl);
+        }
+
+        if (!SCHEME_NULLP(vl))
+          val_l = scheme_make_pair(scheme_make_pair(pt->phase_index, vl), 
+                                   val_l);
+
+        if (!SCHEME_NULLP(ml))
+          mac_l = scheme_make_pair(scheme_make_pair(pt->phase_index, ml),
+                                   mac_l);
       }
-      for (; i >= 0; --i) {
-        vl = scheme_make_pair(make_provide_desc(pt, i), vl);
-      }
-      
-      a[2 * k] = vl;
-      a[(2 * k) + 1] = ml;
     }
     
-    return scheme_values(6, a);
+    a[0] = val_l;
+    a[1] = mac_l;
+    return scheme_values(2, a);
   }
 
   scheme_wrong_type("module-compiled-exports", "compiled module declaration", 0, argc, argv);
@@ -2933,7 +2859,7 @@ Scheme_Object *scheme_check_accessible_in_module(Scheme_Env *env, Scheme_Object
 	supplied (not both). For unprotected access, both prot_insp
 	and stx+certs should be supplied. */
 {
-  symbol = scheme_tl_id_sym(env, symbol, NULL, 0);
+  symbol = scheme_tl_id_sym(env, symbol, NULL, 0, NULL);
 
   if ((env == scheme_initial_env)
       || ((env->module->primitive
@@ -3094,7 +3020,7 @@ Scheme_Object *scheme_module_syntax(Scheme_Object *modname, Scheme_Env *env, Sch
     if (!menv->et_ran)
       scheme_run_module_exptime(menv, 1);
 
-    name = scheme_tl_id_sym(menv, name, NULL, 0);
+    name = scheme_tl_id_sym(menv, name, NULL, 0, NULL);
 
     val = scheme_lookup_in_table(menv->syntax, (char *)name);
 
@@ -3150,31 +3076,77 @@ static void show_done() { --indent; }
 # define show_done() /* nothing */
 #endif
 
-static void compute_et_require_names(Scheme_Env *menv)
+static void compute_require_names(Scheme_Env *menv, Scheme_Object *phase, 
+                                  Scheme_Env *load_env, Scheme_Object *syntax_idx)
 {
-  Scheme_Object *np, *midx, *l;
+  Scheme_Object *np, *midx, *l, *reqs, *req_names;
 
-  if (menv->et_require_names
-      && !SCHEME_NULLP(menv->et_require_names))
+  if (SAME_OBJ(phase, scheme_make_integer(0))) {
+    req_names = menv->require_names;
+    reqs = menv->module->requires;
+  } else if (SAME_OBJ(phase, scheme_make_integer(1))) {
+    req_names = menv->et_require_names;
+    reqs = menv->module->et_requires;
+  } else if (SAME_OBJ(phase, scheme_make_integer(-1))) {
+    req_names = menv->tt_require_names;
+    reqs = menv->module->tt_requires;
+  } else if (SAME_OBJ(phase, scheme_false)) {
+    req_names = menv->dt_require_names;
+    reqs = menv->module->dt_requires;
+  } else {
+    if (menv->module->other_requires) {
+      reqs = scheme_hash_get(menv->module->other_requires, phase);
+      if (!reqs)
+        reqs = scheme_null;
+    } else
+      reqs = scheme_null;
+    if (!SCHEME_NULLP(reqs) && !menv->other_require_names) {
+      Scheme_Hash_Table *ht;
+      ht = scheme_make_hash_table_equal();
+      menv->other_require_names = ht;
+    }
+    if (menv->other_require_names)
+      req_names = scheme_hash_get(menv->other_require_names, phase);
+    else
+      req_names = NULL;
+  }
+
+  if (req_names && !SCHEME_NULLP(req_names))
     return;
 
   np = scheme_null;
 
-  for (l = menv->module->et_requires; !SCHEME_NULLP(l); l = SCHEME_CDR(l)) {
+  for (l = reqs; !SCHEME_NULLP(l); l = SCHEME_CDR(l)) {
     midx = scheme_modidx_shift(SCHEME_CAR(l), 
                                menv->module->me->src_modidx, 
-                               menv->link_midx);
+                               (syntax_idx ? syntax_idx : menv->link_midx));
+
+    if (load_env)
+      module_load(scheme_module_resolve(midx, 1), load_env, NULL);
     
     np = cons(midx, np);
   }
-  
-  menv->et_require_names = np;
+
+  if (!SAME_OBJ(np, req_names)) {
+    if (SAME_OBJ(phase, scheme_make_integer(0))) {
+      menv->require_names = np;
+    } else if (SAME_OBJ(phase, scheme_make_integer(1))) {
+      menv->et_require_names = np;
+    } else if (SAME_OBJ(phase, scheme_make_integer(-1))) {
+      menv->tt_require_names = np;
+    } else if (SAME_OBJ(phase, scheme_false)) {
+      menv->dt_require_names = np;
+    } else {
+      if (menv->other_require_names)
+        scheme_hash_set(menv->other_require_names, phase, np);
+    }
+  }
 }
 
 static void templstart_module(Scheme_Env *menv, Scheme_Env *env, 
 			      int delay_exptime, int with_tt, Scheme_Object *cycle_list)
 {
-  Scheme_Object *np, *new_cycle_list, *midx, *l;
+  Scheme_Object *new_cycle_list, *midx, *l;
   Scheme_Module *im;
   int state;
 
@@ -3190,17 +3162,7 @@ static void templstart_module(Scheme_Env *menv, Scheme_Env *env,
 
   if (!SCHEME_NULLP(menv->module->tt_requires)) {
 
-    if (!menv->tt_require_names || SCHEME_NULLP(menv->tt_require_names)) {
-      np = scheme_null;
-      for (l = menv->module->tt_requires; !SCHEME_NULLP(l); l = SCHEME_CDR(l)) {
-        midx = scheme_modidx_shift(SCHEME_CAR(l), menv->module->me->src_modidx, menv->link_midx);
-      
-        im = module_load(scheme_module_resolve(midx, 1), env, NULL);
-
-        np = cons(midx, np);
-      }
-      menv->tt_require_names = np;
-    }
+    compute_require_names(menv, scheme_make_integer(-1), env, NULL);
 
     scheme_prepare_template_env(menv);
 
@@ -3224,7 +3186,6 @@ static void templstart_module(Scheme_Env *menv, Scheme_Env *env,
                           new_cycle_list);
       }
     }
-
   }
 
   for (l = menv->require_names; !SCHEME_NULLP(l); l = SCHEME_CDR(l)) {
@@ -3238,7 +3199,7 @@ static void templstart_module(Scheme_Env *menv, Scheme_Env *env,
   if (!SCHEME_NULLP(menv->module->et_requires)) {
     scheme_prepare_exp_env(menv);
     menv->exp_env->link_midx = menv->link_midx;
-    compute_et_require_names(menv);
+    compute_require_names(menv, scheme_make_integer(1), NULL, NULL);
     
     for (l = menv->et_require_names; !SCHEME_NULLP(l); l = SCHEME_CDR(l)) {
       midx = SCHEME_CAR(l);
@@ -3249,6 +3210,75 @@ static void templstart_module(Scheme_Env *menv, Scheme_Env *env,
     }
   }
 
+  if (menv->module->other_requires) {
+    int i, rel_phase;
+    Scheme_Object *phase, *n;
+    Scheme_Env *menv2;
+    for (i = 0; i < menv->module->other_requires->size; i++) {
+      if (menv->module->other_requires->vals[i]) {
+        phase = menv->module->other_requires->keys[i];
+
+        if (scheme_is_negative(phase)) {
+          compute_require_names(menv, phase, env, NULL);
+
+          n = phase;
+          menv2 = menv;
+          rel_phase = 0;
+          while (scheme_is_negative(n)) {
+            scheme_prepare_template_env(menv2);
+            menv2 = menv2->template_env;
+            rel_phase += 2;
+            n = scheme_bin_plus(n, scheme_make_integer(1));
+          }
+
+          l = scheme_hash_get(menv->other_require_names, phase);
+
+          for (; !SCHEME_NULLP(l); l = SCHEME_CDR(l)) {
+            midx = SCHEME_CAR(l);
+
+            im = module_load(scheme_module_resolve(midx, 1), env, NULL);
+
+            if ((with_tt > rel_phase) && (!delay_exptime || (with_tt == (rel_phase + 1))))
+              start_module(im, 
+                           menv2, 0, 
+                           midx,
+                           delay_exptime, with_tt - rel_phase,
+                           new_cycle_list);
+            else
+              expstart_module(im, 
+                              menv2, 0, 
+                              midx,
+                              delay_exptime, with_tt - rel_phase,
+                              new_cycle_list);
+          }
+        } else {
+          compute_require_names(menv, phase, NULL, NULL);
+
+          n = phase;
+          menv2 = menv;
+          rel_phase = 2;
+          while (scheme_is_positive(n)) {
+            scheme_prepare_exp_env(menv2);
+            menv2->exp_env->link_midx = menv2->link_midx;
+            menv2 = menv2->exp_env;
+            rel_phase += 2;
+            n = scheme_bin_minus(n, scheme_make_integer(1));
+          }
+
+          l = scheme_hash_get(menv->other_require_names, phase);
+
+          for (; !SCHEME_NULLP(l); l = SCHEME_CDR(l)) {
+            midx = SCHEME_CAR(l);
+            
+            im = module_load(scheme_module_resolve(midx, 1), env, NULL);
+            
+            expstart_module(im, menv2, 0, midx, delay_exptime, with_tt+rel_phase, new_cycle_list);
+          }
+        }
+      }
+    }
+  }
+
   show_done();
 }
 
@@ -3380,19 +3410,11 @@ static int expstart_module(Scheme_Module *m, Scheme_Env *env, int restart,
     menv->attached = 1; /* protect initial modules from redefinition, etc. */
 
   np = scheme_null;
-  for (l = m->dt_requires; !SCHEME_NULLP(l); l = SCHEME_CDR(l)) {
-    if (syntax_idx)
-      midx = scheme_modidx_shift(SCHEME_CAR(l), m->me->src_modidx, syntax_idx);
-    else
-      midx = scheme_modidx_shift(SCHEME_CAR(l), m->me->src_modidx, m->self_modidx);
+  
+  /* Load dt imports (but don't invoke) */
+  compute_require_names(menv, scheme_false, env, syntax_idx);
 
-    np = cons(midx, np);
-
-    im = module_load(scheme_module_resolve(midx, 1), env, NULL);
-  }
-  menv->dt_require_names = np;
-
-  if (m->prim_et_body || SCHEME_VEC_SIZE(m->et_body) || !SCHEME_NULLP(m->et_requires)) {
+  if (m->prim_et_body || SCHEME_VEC_SIZE(m->et_body) || !SCHEME_NULLP(m->et_requires) || m->other_requires) {
     if (delay_exptime) {
       /* Set lazy-syntax flag. */
       menv->lazy_syntax = 1;
@@ -3452,7 +3474,7 @@ static void finish_expstart_module(Scheme_Env *menv, int check_req, int with_tt,
 
     exp_env->link_midx = menv->link_midx;
 
-    compute_et_require_names(menv);
+    compute_require_names(menv, scheme_make_integer(1), NULL, NULL);
 
     for (l = menv->et_require_names; !SCHEME_NULLP(l); l = SCHEME_CDR(l)) {
       midx = SCHEME_CAR(l);
@@ -3466,11 +3488,51 @@ static void finish_expstart_module(Scheme_Env *menv, int check_req, int with_tt,
                    new_cycle_list);
     }
 
-    menv->et_running = 1;
-    if (!menv->module->et_functional)
-      scheme_run_module_exptime(menv, 0);
+    if (menv->module->other_requires) {
+      int i, rel_phase;
+      Scheme_Object *phase, *n;
+      Scheme_Env *menv2;
+      for (i = 0; i < menv->module->other_requires->size; i++) {
+        if (menv->module->other_requires->vals[i]) {
+          phase = menv->module->other_requires->keys[i];
+          
+          if (scheme_is_positive(phase)) {
+            compute_require_names(menv, phase, NULL, NULL);
+
+            n = phase;
+            menv2 = menv;
+            rel_phase = 2;
+            while (scheme_is_positive(n)) {
+              scheme_prepare_exp_env(menv2);
+              menv2->exp_env->link_midx = menv2->link_midx;
+              menv2 = menv2->exp_env;
+              rel_phase += 2;
+              n = scheme_bin_minus(n, scheme_make_integer(1));
+            }
+
+            l = scheme_hash_get(menv->other_require_names, phase);
+
+            for (; !SCHEME_NULLP(l); l = SCHEME_CDR(l)) {
+              midx = SCHEME_CAR(l);
+              
+              im = module_load(scheme_module_resolve(midx, 1), menv, NULL);
+              
+              start_module(im, 
+                           menv2, 0,
+                           midx,
+                           0, with_tt+rel_phase,
+                           new_cycle_list);
+            }
+          }
+        }
+      }
+    }
   }
 
+  menv->et_running = 1;
+  if (!menv->module->et_functional)
+    scheme_run_module_exptime(menv, 0);
+
   show_done();
 }
 
@@ -3899,18 +3961,18 @@ static Scheme_Module_Exports *make_module_exports()
   SET_REQUIRED_TAG(me->type = scheme_rt_module_exports);
 
   pt = MALLOC_ONE_RT(Scheme_Module_Phase_Exports);
-  SET_REQUIRED_TAG(pt->type = scheme_rt_module_phase_exports);
-  pt->phase_index = 0;
+  pt->so.type = scheme_module_phase_exports_type;
+  pt->phase_index = scheme_make_integer(0);
   me->rt = pt;
 
   pt = MALLOC_ONE_RT(Scheme_Module_Phase_Exports);
-  SET_REQUIRED_TAG(pt->type = scheme_rt_module_phase_exports);
-  pt->phase_index = 1;
+  pt->so.type = scheme_module_phase_exports_type;
+  pt->phase_index = scheme_make_integer(1);
   me->et = pt;
 
   pt = MALLOC_ONE_RT(Scheme_Module_Phase_Exports);
-  SET_REQUIRED_TAG(pt->type = scheme_rt_module_phase_exports);
-  pt->phase_index = 2;
+  pt->so.type = scheme_module_phase_exports_type;
+  pt->phase_index = scheme_false;
   me->dt = pt;
 
   return me;
@@ -4106,18 +4168,6 @@ module_execute(Scheme_Object *data)
 	  v = scheme_make_pair(m->rn_stx, (Scheme_Object *)midx);
 	  m->rn_stx = v;
 	}
-	if (m->et_rn_stx && !SAME_OBJ(scheme_true, m->et_rn_stx)) {
-	  /* Delay the shift: */
-	  Scheme_Object *v;
-	  v = scheme_make_pair(m->et_rn_stx, (Scheme_Object *)midx);
-	  m->et_rn_stx = v;
-	}
-	if (m->dt_rn_stx && !SAME_OBJ(scheme_true, m->dt_rn_stx)) {
-	  /* Delay the shift: */
-	  Scheme_Object *v;
-	  v = scheme_make_pair(m->dt_rn_stx, (Scheme_Object *)midx);
-	  m->dt_rn_stx = v;
-	}
       }
     }
   }
@@ -4673,13 +4723,12 @@ module_sfs(Scheme_Object *data, SFS_Info *old_info)
 static Scheme_Object *do_module(Scheme_Object *form, Scheme_Comp_Env *env, 
 				Scheme_Compile_Expand_Info *rec, int drec)
 {
-  Scheme_Object *fm, *nm, *ii, *rn, *et_rn, *tt_rn, *dt_rn, *iidx, *self_modidx, *rmp;
+  Scheme_Object *fm, *nm, *ii, *rn, *et_rn, *iidx, *self_modidx, *rmp, *rn_set;
   Scheme_Module *iim;
   Scheme_Env *menv;
   Scheme_Comp_Env *benv;
   Scheme_Module *m;
   Scheme_Object *mbval;
-  Scheme_Hash_Table *mn_ht, *et_mn_ht, *tt_mn_ht, *dt_mn_ht;
   int saw_mb, check_mb = 0;
   int restore_confusing_name = 0;
 
@@ -4703,7 +4752,7 @@ static Scheme_Object *do_module(Scheme_Object *form, Scheme_Comp_Env *env,
 
   m->functional = 1;
   m->et_functional = 1;
-  
+
   /* must set before calling new_module_env: */
   rmp = SCHEME_STX_VAL(nm);
   rmp = scheme_intern_resolved_module_path(rmp);
@@ -4724,6 +4773,8 @@ static Scheme_Object *do_module(Scheme_Object *form, Scheme_Comp_Env *env,
   }
 
   menv = scheme_new_module_env(env->genv, m, 1);
+
+  menv->disallow_unbound = 1;
   
   self_modidx = scheme_make_modidx(scheme_false, scheme_false, m->modname);
   m->self_modidx = self_modidx;
@@ -4756,25 +4807,11 @@ static Scheme_Object *do_module(Scheme_Object *form, Scheme_Comp_Env *env,
     m->dt_requires = scheme_null;
   }
 
-  mn_ht = scheme_make_hash_table(SCHEME_hash_ptr);
-  et_mn_ht = scheme_make_hash_table(SCHEME_hash_ptr);
-  tt_mn_ht = scheme_make_hash_table(SCHEME_hash_ptr);
-  dt_mn_ht = scheme_make_hash_table(SCHEME_hash_ptr);
+  scheme_prepare_env_renames(menv, mzMOD_RENAME_NORMAL);
 
-  annote_marked_names_nonempty(mn_ht);
-  annote_marked_names_nonempty(et_mn_ht);
-  annote_marked_names_nonempty(tt_mn_ht);
-  annote_marked_names_nonempty(dt_mn_ht);
-
-  rn = scheme_make_module_rename(0, mzMOD_RENAME_NORMAL, mn_ht);
-  et_rn = scheme_make_module_rename(1, mzMOD_RENAME_NORMAL, et_mn_ht);
-  tt_rn = scheme_make_module_rename(-1, mzMOD_RENAME_NORMAL, tt_mn_ht);
-  dt_rn = scheme_make_module_rename(MZ_LABEL_PHASE, mzMOD_RENAME_NORMAL, dt_mn_ht);
-
-  menv->rename = rn;
-  menv->et_rename = et_rn;
-  menv->tt_rename = tt_rn;
-  menv->dt_rename = dt_rn;
+  rn_set = menv->rename_set;
+  rn = scheme_get_module_rename_from_set(rn_set, scheme_make_integer(0), 1);
+  et_rn = scheme_get_module_rename_from_set(rn_set, scheme_make_integer(1), 1);
 
   {
     Scheme_Object *insp;
@@ -4782,20 +4819,14 @@ static Scheme_Object *do_module(Scheme_Object *form, Scheme_Comp_Env *env,
     menv->insp = insp;
   }
 
-  menv->marked_names = mn_ht;
   scheme_prepare_exp_env(menv);
-  menv->exp_env->marked_names = et_mn_ht;
-  scheme_prepare_template_env(menv);
-  menv->template_env->marked_names = tt_mn_ht;
-  scheme_prepare_label_env(menv);
-  menv->label_env->marked_names = dt_mn_ht;
-
+  
   /* For each provide in iim, add a module rename to fm */
   if (SAME_OBJ(iim, kernel)) {
     scheme_extend_module_rename_with_kernel(rn, kernel_modidx);
     saw_mb = 1;
   } else {
-    saw_mb = add_require_renames(rn, et_rn, dt_rn, iim, iidx);
+    saw_mb = add_simple_require_renames(NULL, rn_set, NULL, iim, iidx, scheme_make_integer(0), NULL);
   }
 
   if (rec[drec].comp)
@@ -4828,10 +4859,7 @@ static Scheme_Object *do_module(Scheme_Object *form, Scheme_Comp_Env *env,
   /* phase shift to replace self_modidx of previous expansion (if any): */
   fm = scheme_stx_phase_shift(fm, 0, empty_self_modidx, self_modidx, NULL);
 
-  fm = scheme_add_rename(fm, rn);
-  fm = scheme_add_rename(fm, et_rn);
-  fm = scheme_add_rename(fm, tt_rn);
-  fm = scheme_add_rename(fm, dt_rn);
+  fm = scheme_add_rename(fm, rn_set);
 
   if (!check_mb) {
     
@@ -4849,10 +4877,7 @@ static Scheme_Object *do_module(Scheme_Object *form, Scheme_Comp_Env *env,
       fm = scheme_datum_to_syntax(fm, form, form, 0, 2);
       fm = scheme_stx_property(fm, module_name_symbol, SCHEME_PTR_VAL(m->modname));
       /* Since fm is a newly-created syntax object, we need to re-add renamings: */
-      fm = scheme_add_rename(fm, rn);
-      fm = scheme_add_rename(fm, et_rn);
-      fm = scheme_add_rename(fm, tt_rn);
-      fm = scheme_add_rename(fm, dt_rn);
+      fm = scheme_add_rename(fm, rn_set);
       check_mb = 1;
     }
   }
@@ -4937,10 +4962,10 @@ static Scheme_Object *do_module(Scheme_Object *form, Scheme_Comp_Env *env,
     ((Scheme_Modidx *)self_modidx)->resolved = empty_self_modname;
   }
 
-  clear_marked_names_nonempty(mn_ht);
-  clear_marked_names_nonempty(et_mn_ht);
-  clear_marked_names_nonempty(tt_mn_ht);
-  clear_marked_names_nonempty(dt_mn_ht);
+  if (rec[drec].comp || (rec[drec].depth != -2)) {
+    /* rename tables no longer needed; NULL them out */
+    menv->rename_set = NULL;
+  }
   
   return fm;
 }
@@ -4981,35 +5006,28 @@ Scheme_Object *scheme_apply_for_syntax_in_env(Scheme_Object *proc, Scheme_Env *e
 /*                          #%module-begin                            */
 /**********************************************************************/
 
-Scheme_Object *scheme_phase_index_symbol(int src_phase_index)
-{
-  switch (src_phase_index) {
-  case 0:
-  default:
-    return scheme_false;
-  case 1:
-    return for_syntax_symbol;
-  case 2:
-    return for_label_symbol;
-  case 3:
-    return for_template_symbol;
-  }
-}
-
 static void check_require_name(Scheme_Object *prnt_name, Scheme_Object *name, 
                                Scheme_Object *nominal_modidx, Scheme_Object *nominal_name,
 			       Scheme_Object *modidx, Scheme_Object *exname,
 			       int isval, void *tables, Scheme_Object *e, Scheme_Object *form, 
                                Scheme_Object *err_src, Scheme_Object *mark_src,
-                               int src_phase_index)
+                               Scheme_Object *phase, Scheme_Object *src_phase_index,
+                               Scheme_Object *nominal_export_phase)
 {
   Scheme_Bucket_Table *toplevel, *syntax;
   Scheme_Hash_Table *required;
-  Scheme_Object *vec, *nml;
+  Scheme_Object *vec, *nml, *tvec;
 
-  toplevel = ((Scheme_Bucket_Table **)tables)[0];
-  required = ((Scheme_Hash_Table **)tables)[1];
-  syntax = ((Scheme_Bucket_Table **)tables)[2];
+  tvec = scheme_hash_get((Scheme_Hash_Table *)tables, phase);
+  if (!tvec) {
+    required = get_required_from_tables(tables, phase);
+    toplevel = NULL;
+    syntax = NULL;
+  } else {
+    toplevel = (Scheme_Bucket_Table *)(SCHEME_VEC_ELS(tvec)[0]);
+    required = (Scheme_Hash_Table *)(SCHEME_VEC_ELS(tvec)[1]);
+    syntax = (Scheme_Bucket_Table *)(SCHEME_VEC_ELS(tvec)[2]);
+  }
 
   /* Check that it's not yet defined: */
   if (toplevel) {
@@ -5018,13 +5036,14 @@ static void check_require_name(Scheme_Object *prnt_name, Scheme_Object *name,
     }
   }
 
-  if (src_phase_index || !SAME_OBJ(nominal_name, prnt_name)) {
-    Scheme_Object *v;
-    v = scheme_phase_index_symbol(src_phase_index);
+  if (!SAME_OBJ(src_phase_index, scheme_make_integer(0))
+      || !SAME_OBJ(nominal_export_phase, scheme_make_integer(0))
+      || !SAME_OBJ(nominal_name, prnt_name)) {
     nominal_modidx = scheme_make_pair(nominal_modidx,
-                                      scheme_make_pair(v,
+                                      scheme_make_pair(src_phase_index,
                                                        scheme_make_pair(nominal_name,
-                                                                        scheme_null)));
+                                                                        scheme_make_pair(nominal_export_phase,
+                                                                                         scheme_null))));
   }
 	    
   /* Not required, or required from same module: */
@@ -5089,7 +5108,7 @@ static void check_require_name(Scheme_Object *prnt_name, Scheme_Object *name,
 
 static Scheme_Object *stx_sym(Scheme_Object *name, Scheme_Object *_genv)
 {
-  return scheme_tl_id_sym((Scheme_Env *)_genv, name, NULL, 2);
+  return scheme_tl_id_sym((Scheme_Env *)_genv, name, NULL, 2, NULL);
 }
 
 static Scheme_Object *add_a_rename(Scheme_Object *fm, Scheme_Object *post_ex_rn)
@@ -5130,13 +5149,13 @@ static Scheme_Object *add_lifted_defn(Scheme_Object *data, Scheme_Object **_id,
   self_modidx = SCHEME_VEC_ELS(data)[1];
   rn = SCHEME_VEC_ELS(data)[2];
   
-  name = scheme_tl_id_sym(env->genv, *_id, scheme_false, 2);
+  name = scheme_tl_id_sym(env->genv, *_id, scheme_false, 2, NULL);
 
   /* Create the bucket, indicating that the name will be defined: */
   scheme_add_global_symbol(name, scheme_undefined, env->genv);
   
   /* Add a renaming: */
-  scheme_extend_module_rename(rn, self_modidx, name, name, self_modidx, name, 0, -1, 0);
+  scheme_extend_module_rename(rn, self_modidx, name, name, self_modidx, name, 0, NULL, NULL, 0);
 
   id = scheme_add_rename(*_id, rn);
   *_id = id;
@@ -5162,31 +5181,28 @@ static void flush_definitions(Scheme_Env *genv)
 static Scheme_Object *do_module_begin(Scheme_Object *form, Scheme_Comp_Env *env, 
 				      Scheme_Compile_Expand_Info *rec, int drec)
 {
-  Scheme_Object *fm, *first, *last, *p, *rn, *exp_body, *et_rn, *tt_rn, *dt_rn, *self_modidx, *prev_p;
+  Scheme_Object *fm, *first, *last, *p, *rn_set, *rn, *exp_body, *et_rn, *self_modidx, *prev_p;
   Scheme_Comp_Env *xenv, *cenv, *rhs_env;
   Scheme_Hash_Table *et_required; /* just to avoid duplicates */
-  Scheme_Hash_Table *tt_required; /* just to avoid duplicates */
-  Scheme_Hash_Table *dt_required; /* just to avoid duplicates */
   Scheme_Hash_Table *required;    /* name -> (vector nominal-modidx-list modidx srcname var? prntname) */
   /**/                            /*   first nominal-modidx goes with modidx, rest are for re-provides */
   Scheme_Hash_Table *provided;    /* exname -> (cons locname-stx-or-sym protected?) */
-  Scheme_Object *reprovided;      /* list of (list modidx syntax except-name ...) */
+  Scheme_Hash_Table *all_reprovided; /* phase -> list of (list modidx syntax except-name ...) */
   Scheme_Object *all_defs_out;    /* list of (cons protected? (stx-list except-name ...)) */
   Scheme_Object *all_et_defs_out;
-  Scheme_Hash_Table *et_provided, *dt_provided;
-  Scheme_Object *et_reprovided, *dt_reprovided;
+  Scheme_Hash_Table *all_provided; /* phase -> table like `provided' */
   Scheme_Object *all_defs;        /* list of stxid; this is almost redundant to the syntax and toplevel
 				     tables, but it preserves the original name for exporting */
   Scheme_Object *all_et_defs;
-  Scheme_Object *post_ex_rn, *post_ex_et_rn, *post_ex_tt_rn, *post_ex_dt_rn; /* renames for ids introduced by expansion */
-  void *tables[3], *et_tables[3], *tt_tables[3], *dt_tables[3];
+  Scheme_Object *post_ex_rn, *post_ex_et_rn; /* renames for ids introduced by expansion */
+  Scheme_Object *post_ex_rn_set; /* phase -> post_ex_rn-like rename */
+  Scheme_Hash_Table *tables; /* phase -> (vector toplevels requires syntaxes) */
   Scheme_Object *exclude_hint = scheme_false, *lift_data;
-  Scheme_Hash_Table *et_mn;
   Scheme_Object **exis;
   Scheme_Object *lift_ctx;
   int exicount;
   char *exps;
-  int all_simple_renames = 1, et_all_simple_renames = 1, tt_all_simple_renames = 1, dt_all_simple_renames = 1;
+  int all_simple_renames = 1;
   int maybe_has_lifts = 0;
   int reprovide_kernel;
   Scheme_Object *redef_modname;
@@ -5241,16 +5257,33 @@ static Scheme_Object *do_module_begin(Scheme_Object *form, Scheme_Comp_Env *env,
   first = scheme_null;
   last = NULL;
 
-  rn = env->genv->rename;
-  et_rn = env->genv->et_rename;
-  tt_rn = env->genv->tt_rename;
-  dt_rn = env->genv->dt_rename;
+  rn_set = env->genv->rename_set;
+  rn = scheme_get_module_rename_from_set(rn_set, scheme_make_integer(0), 1);
+  et_rn = scheme_get_module_rename_from_set(rn_set, scheme_make_integer(1), 1);
 
   required = scheme_make_hash_table(SCHEME_hash_ptr);
   et_required = scheme_make_hash_table(SCHEME_hash_ptr);
-  dt_required = scheme_make_hash_table(SCHEME_hash_ptr);
 
-  /* Put initial requires into the table: */
+  tables = scheme_make_hash_table_equal();
+  {
+    Scheme_Object *vec;
+
+    vec = scheme_make_vector(3, NULL);
+    SCHEME_VEC_ELS(vec)[0] = (Scheme_Object *)env->genv->toplevel;
+    SCHEME_VEC_ELS(vec)[1] = (Scheme_Object *)required;
+    SCHEME_VEC_ELS(vec)[2] = (Scheme_Object *)env->genv->syntax;
+    scheme_hash_set(tables, scheme_make_integer(0), vec);
+
+    vec = scheme_make_vector(3, NULL);
+    SCHEME_VEC_ELS(vec)[0] = (Scheme_Object *)env->genv->exp_env->toplevel;
+    SCHEME_VEC_ELS(vec)[1] = (Scheme_Object *)et_required;
+    SCHEME_VEC_ELS(vec)[2] = NULL;
+    scheme_hash_set(tables, scheme_make_integer(1), vec);
+  }
+
+  /* Put initial requires into the table:
+     (This is redundant for the rename set, but we need to fill
+     the `all_requires' table, etc.) */
   {
     Scheme_Module *iim;
     Scheme_Object *nmidx, *orig_src;
@@ -5265,55 +5298,23 @@ static Scheme_Object *do_module_begin(Scheme_Object *form, Scheme_Comp_Env *env,
     nmidx = SCHEME_CAR(env->genv->module->requires);
     iim = module_load(scheme_module_resolve(nmidx, 1), env->genv, NULL);
 
-    add_initial_require_renames(orig_src, 
-                                rn, required, 
-                                et_rn, et_required, 
-                                dt_rn, dt_required,
-                                iim, nmidx);
-  }
-
-  if (rec[drec].comp || (rec[drec].depth != -2)) {
-    /* rename tables no longer needed; NULL them out */
-    env->genv->rename = NULL;
-    env->genv->et_rename = NULL;
-    env->genv->tt_rename = NULL;
+    add_simple_require_renames(orig_src, rn_set, tables, 
+                               iim, nmidx,
+                               scheme_make_integer(0),
+                               NULL);
   }
 
   {
     Scheme_Object *v;
-    v = scheme_rename_to_stx(rn);
+    v = scheme_rename_to_stx(rn_set);
     env->genv->module->rn_stx = v;
-    v = scheme_rename_to_stx(et_rn);
-    env->genv->module->et_rn_stx = v;
-    v = scheme_rename_to_stx(tt_rn);
-    env->genv->module->tt_rn_stx = v;
-    v = scheme_rename_to_stx(dt_rn);
-    env->genv->module->dt_rn_stx = v;
   }
 
-  tables[0] = env->genv->toplevel;
-  tables[1] = required;
-  tables[2] = env->genv->syntax;
-
-  et_tables[0] = NULL;
-  et_tables[1] = et_required;
-  et_tables[2] = NULL;
-
-  tt_required = scheme_make_hash_table(SCHEME_hash_ptr);
-  tt_tables[0] = NULL;
-  tt_tables[1] = tt_required;
-  tt_tables[2] = NULL;
-
-  dt_tables[0] = NULL;
-  dt_tables[1] = dt_required;
-  dt_tables[2] = NULL;
-
   provided = scheme_make_hash_table(SCHEME_hash_ptr);
-  reprovided = scheme_null;
-  et_provided = scheme_make_hash_table(SCHEME_hash_ptr);
-  et_reprovided = scheme_null;
-  dt_provided = scheme_make_hash_table(SCHEME_hash_ptr);
-  dt_reprovided = scheme_null;
+  all_provided = scheme_make_hash_table_equal();
+  scheme_hash_set(all_provided, scheme_make_integer(0), (Scheme_Object *)provided);
+
+  all_reprovided = scheme_make_hash_table_equal();
 
   all_defs_out = scheme_null;
   all_et_defs_out = scheme_null;
@@ -5325,10 +5326,9 @@ static Scheme_Object *do_module_begin(Scheme_Object *form, Scheme_Comp_Env *env,
 
   self_modidx = env->genv->module->self_modidx;
 
-  post_ex_rn = scheme_make_module_rename(0, mzMOD_RENAME_MARKED, env->genv->marked_names);
-  post_ex_et_rn = scheme_make_module_rename(1, mzMOD_RENAME_MARKED, env->genv->exp_env->marked_names);
-  post_ex_tt_rn = scheme_make_module_rename(-1, mzMOD_RENAME_MARKED, env->genv->template_env->marked_names);
-  post_ex_dt_rn = scheme_make_module_rename(MZ_LABEL_PHASE, mzMOD_RENAME_MARKED, env->genv->label_env->marked_names);
+  post_ex_rn_set = scheme_make_module_rename_set(mzMOD_RENAME_MARKED, rn_set);
+  post_ex_rn = scheme_get_module_rename_from_set(post_ex_rn_set, scheme_make_integer(0), 1);
+  post_ex_et_rn = scheme_get_module_rename_from_set(post_ex_rn_set, scheme_make_integer(1), 1);
 
   /* For syntax-local-context, etc., in a d-s RHS: */
   rhs_env = scheme_new_comp_env(env->genv, env->insp, SCHEME_TOPLEVEL_FRAME);
@@ -5337,14 +5337,11 @@ static Scheme_Object *do_module_begin(Scheme_Object *form, Scheme_Comp_Env *env,
 
   /* It's possible that #%module-begin expansion introduces
      marked identifiers for definitions. */
-  form = scheme_add_rename(form, post_ex_rn);
-  form = scheme_add_rename(form, post_ex_et_rn);
-  form = scheme_add_rename(form, post_ex_tt_rn);
-  form = scheme_add_rename(form, post_ex_dt_rn);
+  form = scheme_add_rename(form, post_ex_rn_set);
 
   maybe_has_lifts = 0;
   lift_ctx = scheme_generate_lifts_key();
-  
+
   /* Pass 1 */
 
   observer = rec[drec].observer;
@@ -5382,15 +5379,10 @@ static Scheme_Object *do_module_begin(Scheme_Object *form, Scheme_Comp_Env *env,
       if (!SCHEME_NULLP(fst)) {
 	/* Expansion lifted expressions, so add them to
 	   the front and try again. */
+        all_simple_renames = 0;
 	fm = SCHEME_STX_CDR(fm);
-        e = scheme_add_rename(e, post_ex_rn);
-        e = scheme_add_rename(e, post_ex_et_rn);
-        e = scheme_add_rename(e, post_ex_tt_rn);
-        e = scheme_add_rename(e, post_ex_dt_rn);
-        fm = scheme_named_map_1(NULL, add_a_rename, fm, post_ex_rn);
-        fm = scheme_named_map_1(NULL, add_a_rename, fm, post_ex_et_rn);
-        fm = scheme_named_map_1(NULL, add_a_rename, fm, post_ex_tt_rn);
-        fm = scheme_named_map_1(NULL, add_a_rename, fm, post_ex_dt_rn);
+        e = scheme_add_rename(e, post_ex_rn_set);
+        fm = scheme_named_map_1(NULL, add_a_rename, fm, post_ex_rn_set);
 	fm = scheme_append(fst, scheme_make_pair(e, fm));
         SCHEME_EXPAND_OBSERVE_MODULE_LIFT_LOOP(observer, fst);
       } else {
@@ -5402,10 +5394,7 @@ static Scheme_Object *do_module_begin(Scheme_Object *form, Scheme_Comp_Env *env,
 	
 	if (fst && SCHEME_STX_SYMBOLP(fst) && scheme_stx_module_eq(scheme_begin_stx, fst, 0)) {
 	  fm = SCHEME_STX_CDR(fm);
-	  e = scheme_add_rename(e, post_ex_rn);
-	  e = scheme_add_rename(e, post_ex_et_rn);
-	  e = scheme_add_rename(e, post_ex_tt_rn);
-	  e = scheme_add_rename(e, post_ex_dt_rn);
+	  e = scheme_add_rename(e, post_ex_rn_set);
 	  fm = scheme_flatten_begin(e, fm);
 	  SCHEME_EXPAND_OBSERVE_SPLICE(observer, fm);
 	  if (SCHEME_STX_NULLP(fm)) {
@@ -5424,10 +5413,7 @@ static Scheme_Object *do_module_begin(Scheme_Object *form, Scheme_Comp_Env *env,
     }
     if (!e) break; /* (begin) expansion at end */
 
-    e = scheme_add_rename(e, post_ex_rn);
-    e = scheme_add_rename(e, post_ex_et_rn);
-    e = scheme_add_rename(e, post_ex_tt_rn);
-    e = scheme_add_rename(e, post_ex_dt_rn);
+    e = scheme_add_rename(e, post_ex_rn_set);
     
     if (SCHEME_STX_PAIRP(e)) {
       Scheme_Object *fst;
@@ -5458,7 +5444,7 @@ static Scheme_Object *do_module_begin(Scheme_Object *form, Scheme_Comp_Env *env,
 	    /* Remember the original: */
 	    all_defs = scheme_make_pair(name, all_defs);
 	    
-	    name = scheme_tl_id_sym(env->genv, name, NULL, 2);
+	    name = scheme_tl_id_sym(env->genv, name, NULL, 2, NULL);
 
 	    /* Check that it's not yet defined: */
 	    if (scheme_lookup_in_table(env->genv->toplevel, (const char *)name)) {
@@ -5482,10 +5468,11 @@ static Scheme_Object *do_module_begin(Scheme_Object *form, Scheme_Comp_Env *env,
 	    scheme_add_global_symbol(name, scheme_undefined, env->genv);
 
 	    /* Add a renaming: */
-	    if (!SAME_OBJ(SCHEME_STX_VAL(orig_name), name))
-	      scheme_extend_module_rename(post_ex_rn, self_modidx, name, name, self_modidx, name, 0, -1, 0);
-	    else
-	      scheme_extend_module_rename(rn, self_modidx, name, name, self_modidx, name, 0, -1, 0);
+	    if (!SAME_OBJ(SCHEME_STX_VAL(orig_name), name)) {
+	      scheme_extend_module_rename(post_ex_rn, self_modidx, name, name, self_modidx, name, 0, NULL, NULL, 0);
+              all_simple_renames = 0;
+	    } else
+	      scheme_extend_module_rename(rn, self_modidx, name, name, self_modidx, name, 0, NULL, NULL, 0);
 	    
 	    vars = SCHEME_STX_CDR(vars);
 	  }
@@ -5534,7 +5521,7 @@ static Scheme_Object *do_module_begin(Scheme_Object *form, Scheme_Comp_Env *env,
             else
               all_et_defs = scheme_make_pair(name, all_et_defs);
 	    
-	    name = scheme_tl_id_sym(oenv->genv, name, NULL, 2);
+	    name = scheme_tl_id_sym(oenv->genv, name, NULL, 2, NULL);
 	    
 	    if (scheme_lookup_in_table(oenv->genv->syntax, (const char *)name)) {
 	      scheme_wrong_syntax("module", orig_name, e, 
@@ -5562,12 +5549,13 @@ static Scheme_Object *do_module_begin(Scheme_Object *form, Scheme_Comp_Env *env,
 	      return NULL;
 	    }
 
-	    if (!SAME_OBJ(SCHEME_STX_VAL(orig_name), name))
+	    if (!SAME_OBJ(SCHEME_STX_VAL(orig_name), name)) {
 	      scheme_extend_module_rename(for_stx ? post_ex_et_rn : post_ex_rn, self_modidx, name, name, self_modidx, name,
-					  for_stx ? 1 : 0, -1, 0);
-	    else
+					  for_stx ? 1 : 0, NULL, NULL, 0);
+              all_simple_renames = 0;
+	    } else
 	      scheme_extend_module_rename(for_stx ? et_rn : rn, self_modidx, name, name, self_modidx, name,
-					  for_stx ? 1 : 0, -1, 0);
+					  for_stx ? 1 : 0, NULL, NULL, 0);
 
 	    count++;
 	  }
@@ -5640,17 +5628,11 @@ static Scheme_Object *do_module_begin(Scheme_Object *form, Scheme_Comp_Env *env,
 
 	  /* Adds requires to renamings and required modules to requires lists: */
 	  parse_requires(e, self_modidx, env->genv, env->genv->module,
-                         rn, post_ex_rn, 
-                         et_rn, post_ex_et_rn,
-                         tt_rn, post_ex_tt_rn,
-                         dt_rn, post_ex_dt_rn,
-                         check_require_name, tables, et_tables, tt_tables, dt_tables,
+                         rn_set, post_ex_rn_set,
+                         check_require_name, tables,
                          redef_modname, 
                          0, 0, 1, 0,
-                         &all_simple_renames,
-                         &et_all_simple_renames,
-                         &tt_all_simple_renames,
-                         &dt_all_simple_renames);
+                         &all_simple_renames);
 
 	  if (rec[drec].comp)
 	    e = NULL;
@@ -5734,12 +5716,10 @@ static Scheme_Object *do_module_begin(Scheme_Object *form, Scheme_Comp_Env *env,
         ex = e;
   
         parse_provides(form, fst, e, 
-                       provided, &reprovided,
-                       et_provided, &et_reprovided,
-                       dt_provided, &dt_reprovided,
+                       all_provided, all_reprovided,
                        self_modidx,
                        &all_defs_out, &all_et_defs_out,
-                       required, et_required, dt_required, 
+                       tables,
                        all_defs, all_et_defs, cenv, rec, drec,
                        &ex);
         
@@ -5792,6 +5772,7 @@ static Scheme_Object *do_module_begin(Scheme_Object *form, Scheme_Comp_Env *env,
 	p = SCHEME_CDR(p);
       } else {
 	/* Lifts - insert them and try again */
+        all_simple_renames = 0;
         SCHEME_EXPAND_OBSERVE_MODULE_LIFT_LOOP(observer, scheme_copy_list(l));
 	e = scheme_make_pair(e, scheme_make_integer(0)); /* don't re-compile/-expand */
 	SCHEME_CAR(p) = e;
@@ -5831,8 +5812,6 @@ static Scheme_Object *do_module_begin(Scheme_Object *form, Scheme_Comp_Env *env,
   }
   /* first = a list of expanded/compiled expressions */
 
-  et_mn = env->genv->exp_env->marked_names;
-
   /* If compiling, drop expressions that are constants: */
   if (rec[drec].comp) {
     Scheme_Object *prev = NULL, *next;
@@ -5848,30 +5827,21 @@ static Scheme_Object *do_module_begin(Scheme_Object *form, Scheme_Comp_Env *env,
     }
   }
 
-  /* Compute provides for re-provides and all-defs-out: */
-  reprovide_kernel = compute_reprovides(provided, et_provided, dt_provided,
-                                        reprovided, 
-                                        env->genv->module->requires, 
-                                        required, et_required, dt_required,
-                                        env->genv, all_defs, all_defs_out, 
-                                        &exclude_hint,
-                                        "require", 0);
-  (void)compute_reprovides(et_provided, NULL, NULL,
-                           et_reprovided, 
-                           env->genv->module->et_requires, 
-                           et_required, NULL, NULL,
-                           env->genv->exp_env, all_et_defs, all_et_defs_out, 
-                           NULL,
-                           "require-for-syntax", 1);
-  (void)compute_reprovides(dt_provided, NULL, NULL,
-                           dt_reprovided, 
-                           env->genv->module->dt_requires, 
-                           dt_required, NULL, NULL,
-                           NULL, NULL, NULL,
-                           NULL,
-                           "require-for-label", MZ_LABEL_PHASE);
+  scheme_seal_module_rename_set(rn_set);
+  scheme_seal_module_rename_set(post_ex_rn_set);
 
-  /* Ad hoc optimization: mzscheme is everything from kernel except
+  /* Compute provides for re-provides and all-defs-out: */
+  reprovide_kernel = compute_reprovides(all_provided,
+                                        all_reprovided, 
+                                        env->genv->module, 
+                                        tables,
+                                        env->genv, 
+                                        all_defs, all_defs_out, 
+                                        all_et_defs, all_et_defs_out, 
+                                        &exclude_hint,
+                                        "require", NULL, NULL);
+
+  /* Ad hoc optimization: some early modules are everything from kernel except
      #%module_begin */
   if ((reprovide_kernel == (kernel->me->rt->num_provides - 1))
       && SCHEME_FALSEP(exclude_hint)) {
@@ -5893,7 +5863,7 @@ static Scheme_Object *do_module_begin(Scheme_Object *form, Scheme_Comp_Env *env,
 	  /* may be a single shadowed exclusion, now bound to exclude_hint... */
 	  n = SCHEME_CAR(n);
 	  if (SCHEME_STXP(n))
-	    n = scheme_tl_id_sym(env->genv, n, NULL, 0);
+	    n = scheme_tl_id_sym(env->genv, n, NULL, 0, NULL);
 	  n = scheme_hash_get(required, n);
 	  if (n && !SAME_OBJ(SCHEME_VEC_ELS(n)[1], kernel_modidx)) {
 	    /* there is a single shadowed exclusion. */
@@ -5911,24 +5881,11 @@ static Scheme_Object *do_module_begin(Scheme_Object *form, Scheme_Comp_Env *env,
   /* If reprovide_kernel is non-zero, we re-provide all of it */
 
   /* Compute provide arrays */
-  exps = compute_provide_arrays(provided, required,
-                                env->genv->module->me->rt,
-                                env->genv, 0,
+  exps = compute_provide_arrays(all_provided, tables,
+                                env->genv->module->me,
+                                env->genv,
                                 reprovide_kernel,
-                                form,
-                                "provided identifier not defined or imported");
-  (void)compute_provide_arrays(et_provided, et_required,
-                               env->genv->module->me->et,
-                               env->genv->exp_env, 1,
-                               0,
-                               form,
-                               "for-syntax provided identifier not defined for syntax or imported for syntax");
-  (void)compute_provide_arrays(dt_provided, dt_required,
-                               env->genv->module->me->dt,
-                               NULL, 0,
-                               0,
-                               form,
-                               "for-label provided identifier not imported for label");
+                                form);
   
   if (rec[drec].comp || (rec[drec].depth != -2)) {
     scheme_clean_dead_env(env->genv);
@@ -6091,22 +6048,9 @@ static Scheme_Object *do_module_begin(Scheme_Object *form, Scheme_Comp_Env *env,
 
     env->genv->module->comp_prefix = cenv->prefix;
 
-    if (all_simple_renames 
-	&& (env->genv->marked_names->count == 1 /* just the false mapping */)) {
+    if (all_simple_renames) {
       env->genv->module->rn_stx = scheme_true;
     }
-    if (et_all_simple_renames 
-        && all_simple_renames
-	&& (et_mn->count == 1 /* just the false mapping */)) {
-      env->genv->module->et_rn_stx = scheme_true;
-    }
-    if (tt_all_simple_renames) {
-      env->genv->module->tt_rn_stx = scheme_true;
-    }
-    if (dt_all_simple_renames
-        && all_simple_renames) {
-      env->genv->module->dt_rn_stx = scheme_true;
-    }
 
     return (Scheme_Object *)env->genv->module;
   } else {
@@ -6136,13 +6080,13 @@ module_begin_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Inf
 }
 
 static void check_already_provided(Scheme_Hash_Table *provided, Scheme_Object *outname, Scheme_Object *name, 
-                                   int protected, Scheme_Object *form, int phase)
+                                   int protected, Scheme_Object *form, Scheme_Object *phase)
 {
   Scheme_Object *v;
 
   v = scheme_hash_get(provided, outname);
   if (v) {
-    if (!scheme_stx_module_eq(SCHEME_CAR(v), name, phase))
+    if (!scheme_stx_module_eq2(SCHEME_CAR(v), name, phase, NULL))
       scheme_wrong_syntax("module", outname, form, "identifier already provided (as a different binding)");
     
     if (protected && SCHEME_FALSEP(SCHEME_CDR(v)))
@@ -6152,289 +6096,352 @@ static void check_already_provided(Scheme_Hash_Table *provided, Scheme_Object *o
   }
 }
 
-int compute_reprovides(Scheme_Hash_Table *_provided, Scheme_Hash_Table *_et_provided, Scheme_Hash_Table *_dt_provided, 
-                       Scheme_Object *reprovided, 
-                       Scheme_Object *requires, 
-                       Scheme_Hash_Table *_required, Scheme_Hash_Table *_et_required, Scheme_Hash_Table *_dt_required, 
-                       Scheme_Env *genv, Scheme_Object *all_defs, Scheme_Object *all_defs_out, 
+int compute_reprovides(Scheme_Hash_Table *all_provided,
+                       Scheme_Hash_Table *all_reprovided, 
+                       Scheme_Module *mod_for_requires,
+                       Scheme_Hash_Table *tables,
+                       Scheme_Env *_genv, 
+                       Scheme_Object *all_rt_defs, Scheme_Object *all_rt_defs_out, 
+                       Scheme_Object *all_et_defs, Scheme_Object *all_et_defs_out, 
                        Scheme_Object **_exclude_hint,
-                       const char *matching_form, int phase)
+                       const char *matching_form,
+                       Scheme_Object *all_mods, /* a phase list to use for all mods */
+                       Scheme_Object *all_phases) /* a module-path list for all phases */
 {
   Scheme_Hash_Table *provided, *required;
-  int i, k;
-  Scheme_Object *rx, *provided_list;
-  int reprovide_kernel = 0, all_mods = 0;
-  int src_phase_index;
+  Scheme_Object *reprovided, *tvec;
+  int i, k, z;
+  Scheme_Object *rx, *provided_list, *phase, *req_phase;
+  int reprovide_kernel = 0;
+  Scheme_Object *all_defs, *all_defs_out;
+  Scheme_Env *genv;
 
-  if (phase == MZ_LABEL_PHASE)
-    src_phase_index = 2;
-  else
-    src_phase_index = phase;
-
-  if (SCHEME_FALSEP(reprovided)) {
-    all_mods = 1;
-    /* more convenient: */
+  if (all_phases) {
+    /* synthesize all_reprovided for the loop below: */
+    if (all_mods)
+      reprovided = scheme_make_pair(scheme_false, scheme_null);
+    else
+      reprovided = all_phases;
+    all_reprovided = scheme_make_hash_table_equal();
+    if (mod_for_requires->requires
+        && !SCHEME_NULLP(mod_for_requires->requires))
+      scheme_hash_set(all_reprovided, scheme_make_integer(0), reprovided);
+    if (mod_for_requires->et_requires
+        && !SCHEME_NULLP(mod_for_requires->et_requires))
+      scheme_hash_set(all_reprovided, scheme_make_integer(1), reprovided);
+    if (mod_for_requires->tt_requires
+        && !SCHEME_NULLP(mod_for_requires->tt_requires))
+      scheme_hash_set(all_reprovided, scheme_make_integer(-1), reprovided);
+    if (mod_for_requires->dt_requires
+        && !SCHEME_NULLP(mod_for_requires->dt_requires))
+      scheme_hash_set(all_reprovided, scheme_false, reprovided);
+    if (mod_for_requires->other_requires) {
+      for (z = 0; z < mod_for_requires->other_requires->size; z++) {
+        if (mod_for_requires->other_requires->vals[z])
+          scheme_hash_set(all_reprovided, 
+                          mod_for_requires->other_requires->keys[z],
+                          reprovided);
+      }
+    }
+  } else if (all_mods) {
     reprovided = scheme_make_pair(scheme_false, scheme_null);
+    all_reprovided = scheme_make_hash_table_equal();
+    while (SCHEME_PAIRP(all_mods)) {
+      scheme_hash_set(all_reprovided, SCHEME_CAR(all_mods), reprovided);
+      all_mods = SCHEME_CDR(all_mods);
+    }
   }
 
-  /* First, check the sanity of the re-provide specifications: */
+  /* First, check the sanity of the re-provide specifications (unless
+     we synthesized them): */
   if (!all_mods) {
-    for (rx = reprovided; !SCHEME_NULLP(rx); rx = SCHEME_CDR(rx)) {
-      Scheme_Object *midx = SCHEME_CAR(SCHEME_CAR(rx)), *l, *exns;
-	
-      for (l = requires; SCHEME_PAIRP(l); l = SCHEME_CDR(l)) {
-        if (same_modidx(midx, SCHEME_CAR(l)))
-          break;
-      }
-      if (SCHEME_NULLP(l)) {
-        /* Didn't require the named module */
-        if (matching_form) {
-          Scheme_Object *name;
-          name = SCHEME_CAR(rx);
-          name = SCHEME_STX_CDR(name);
-          name = SCHEME_STX_CAR(name);
-          scheme_wrong_syntax("module", 
-                              SCHEME_MODNAMEP(midx) ? midx : ((Scheme_Modidx *)midx)->path, 
-                              name,
-                              "cannot provide from a module without a matching `%s'",
-                              matching_form);
+    for (z = 0; z < all_reprovided->size; z++) {
+      if (all_reprovided->vals[z]) {
+        Scheme_Object *requires;
+
+        reprovided = all_reprovided->vals[z];
+        phase = all_reprovided->keys[z];
+
+        if (SAME_OBJ(phase, scheme_make_integer(0))) {
+          requires = mod_for_requires->requires;
+        } else if (SAME_OBJ(phase, scheme_make_integer(1))) {
+          requires = mod_for_requires->et_requires;
+        } else if (SAME_OBJ(phase, scheme_make_integer(-1))) {
+          requires = mod_for_requires->tt_requires;
+        } else if (SAME_OBJ(phase, scheme_false)) {
+          requires = mod_for_requires->dt_requires;
         } else {
-          return -1;
-        }
-      }
-
-      exns = SCHEME_CDR(SCHEME_CDR(SCHEME_CAR(rx)));
-      for (l = exns; !SCHEME_STX_NULLP(l); l = SCHEME_STX_CDR(l)) {
-        /* Make sure excluded name was required: */
-        Scheme_Object *a, *vec;
-        a = SCHEME_STX_VAL(SCHEME_STX_CAR(l));
-        for (k = 0; k < 3; k++) {
-          switch (k) {
-          case 0:
-            required = _required;
-            break;
-          case 1:
-            required = _et_required;
-            break;
-          default:
-          case 2:
-            required = _dt_required;
-            break;
-          }
-          if (required)
-            vec = scheme_hash_get(required, a);
+          if (mod_for_requires->other_requires)
+            requires = scheme_hash_get(mod_for_requires->other_requires, phase);
           else
-            vec = NULL;
-      
-          if (vec) {
-            /* Check for nominal modidx in list */
-            Scheme_Object *nml, *nml_modidx;
-            nml = SCHEME_VEC_ELS(vec)[0];
-            for (; SCHEME_PAIRP(nml); nml = SCHEME_CDR(nml)) {
-              nml_modidx = SCHEME_CAR(nml);
-              if (SCHEME_PAIRP(nml_modidx))
-                nml_modidx = SCHEME_CAR(nml_modidx);
-              if (same_modidx(SCHEME_CAR(SCHEME_CAR(rx)), nml_modidx))
-                break;
+            requires = NULL;
+        }
+        if (!requires)
+          requires = scheme_null;
+        
+        for (rx = reprovided; !SCHEME_NULLP(rx); rx = SCHEME_CDR(rx)) {
+          Scheme_Object *midx = SCHEME_CAR(SCHEME_CAR(rx)), *l, *exns;
+	
+          for (l = requires; SCHEME_PAIRP(l); l = SCHEME_CDR(l)) {
+            if (same_modidx(midx, SCHEME_CAR(l)))
+              break;
+          }
+          if (SCHEME_NULLP(l)) {
+            /* Didn't require the named module */
+            if (matching_form) {
+              Scheme_Object *name;
+              name = SCHEME_CAR(rx);
+              name = SCHEME_STX_CDR(name);
+              name = SCHEME_STX_CAR(name);
+              scheme_wrong_syntax("module", 
+                                  SCHEME_MODNAMEP(midx) ? midx : ((Scheme_Modidx *)midx)->path, 
+                                  name,
+                                  "cannot provide from a module without a matching `%s'",
+                                  matching_form);
+            } else {
+              return -1;
             }
-            if (!SCHEME_PAIRP(nml))
-              vec = NULL; /* So it was provided, but not from the indicated module */
           }
 
-          if (vec)
-            break;
-        }
-        if (!vec) {
-          a = SCHEME_STX_CAR(l);
-          scheme_wrong_syntax("module", a, SCHEME_CADR(SCHEME_CAR(rx)),
-                              "excluded name was not required from the module");
-        }
-      }
-    }
-  }
+          exns = SCHEME_CDR(SCHEME_CDR(SCHEME_CAR(rx)));
+          for (l = exns; !SCHEME_STX_NULLP(l); l = SCHEME_STX_CDR(l)) {
+            /* Make sure excluded name was required: */
+            Scheme_Object *a, *vec = NULL;
+            a = SCHEME_STX_VAL(SCHEME_STX_CAR(l));
 
-  /* Walk through requires, check for re-providing: */
-  for (k = 0; k < 3; k++) {
-    switch (k) {
-    case 0:
-      provided = _provided;
-      required = _required;
-      break;
-    case 1:
-      provided = _et_provided;
-      required = _et_required;
-      break;
-    case 2:
-    default:
-      provided = _dt_provided;
-      required = _dt_required;
-      break;
-    }
-
-    provided_list = scheme_null;
-
-    if (required) {
-      for (i = required->size; i--; ) {
-        if (required->vals[i]) {
-          Scheme_Object *nominal_modidx, *name, *modidx, *srcname, *outname, *nml, *orig_nml, *mark_src;
-          int break_outer = 0;
-	
-          name = required->keys[i]; /* internal symbolic name */
-          orig_nml = SCHEME_VEC_ELS(required->vals[i])[0];
-          modidx = SCHEME_VEC_ELS(required->vals[i])[1];
-          srcname = SCHEME_VEC_ELS(required->vals[i])[2];
-          outname = SCHEME_VEC_ELS(required->vals[i])[4];
-          mark_src = SCHEME_VEC_ELS(required->vals[i])[6];
-
-          for (rx = reprovided; !SCHEME_NULLP(rx); rx = SCHEME_CDR(rx)) {
-            for (nml = orig_nml; SCHEME_PAIRP(nml); nml = SCHEME_CDR(nml)) {
-              nominal_modidx = SCHEME_CAR(nml);
-              if (SCHEME_PAIRP(nominal_modidx))
-                nominal_modidx = SCHEME_CAR(nominal_modidx);
-              if (all_mods || same_modidx(SCHEME_CAR(SCHEME_CAR(rx)), nominal_modidx)) {
-                Scheme_Object *pi, *nml_pi;
-
-                if (SCHEME_PAIRP(SCHEME_CAR(nml))) {
-                  nml_pi = SCHEME_CADR(SCHEME_CAR(nml));
-                } else
-                  nml_pi = scheme_false;
-                pi = scheme_phase_index_symbol(src_phase_index);
-
-                if (SAME_OBJ(pi, nml_pi)) {
-            
-                  Scheme_Object *exns, *ree;
-	      
-                  if (!all_mods) {
-                    break_outer = 1;
-                  
-                    ree = SCHEME_CDR(SCHEME_CAR(rx));
-
-                    exns = SCHEME_CDR(ree);
-                    if (SAME_OBJ(modidx, kernel_modidx))
-                      if (!SCHEME_STX_NULLP(exns)) {
-                        if (_exclude_hint)
-                          *_exclude_hint = exns;
-                      }
-                  } else {
-                    ree = NULL;
-                    exns = scheme_null;
-                  }
-	    
-                  for (; !SCHEME_STX_NULLP(exns); exns = SCHEME_STX_CDR(exns)) {
-                    /* Was this name excluded? */
-                    Scheme_Object *a;
-                    a = SCHEME_STX_VAL(SCHEME_STX_CAR(exns));
-                    if (SAME_OBJ(a, name))
+            for (k = 0; k < tables->size; k++) {
+              if (tables->vals[k]) {
+                tvec = tables->vals[k];
+                required = (Scheme_Hash_Table *)SCHEME_VEC_ELS(tvec)[1];
+                
+                if (required)
+                  vec = scheme_hash_get(required, a);
+                else
+                  vec = NULL;
+      
+                if (vec) {
+                  /* Check for nominal modidx in list */
+                  Scheme_Object *nml, *nml_modidx;
+                  nml = SCHEME_VEC_ELS(vec)[0];
+                  for (; SCHEME_PAIRP(nml); nml = SCHEME_CDR(nml)) {
+                    nml_modidx = SCHEME_CAR(nml);
+                    if (SCHEME_PAIRP(nml_modidx))
+                      nml_modidx = SCHEME_CAR(nml_modidx);
+                    if (same_modidx(SCHEME_CAR(SCHEME_CAR(rx)), nml_modidx))
                       break;
                   }
-
-                  if (SCHEME_STX_NULLP(exns)) {
-                    /* Not excluded, so provide it. */
-                    if (matching_form) {
-                      /* Assert: !all_mods */
-                      check_already_provided(provided, outname, name, 0, SCHEME_CAR(ree), phase);
-                      scheme_hash_set(provided, outname, scheme_make_pair(name, scheme_false));
-                    } else {
-                      if (SCHEME_TRUEP(mark_src)) {
-                        if (SCHEME_SYM_PARALLELP(name)) {
-                          /* reverse scheme_tl_id_sym */
-                          char *s;
-                          int len;
-                          len = SCHEME_SYM_LEN(name);
-                          s = scheme_malloc_atomic(len + 1);
-                          memcpy(s, SCHEME_SYM_VAL(name), len+1);
-                          while (len && (s[len] != '.')) {
-                            --len;
-                          }
-                          s[len] = 0;
-                          name = scheme_intern_exact_symbol(s, len);
-                        }
-                        name = scheme_datum_to_syntax(name, scheme_false, mark_src, 0, 0);
-                      } else {
-                        scheme_signal_error("found an import with no lexical context");
-                      }
-                      
-                      provided_list = scheme_make_pair(name, provided_list);
-                    }
-
-                    if (SAME_OBJ(modidx, kernel_modidx) && SAME_OBJ(outname, srcname))
-                      reprovide_kernel++;
-                  }
+                  if (!SCHEME_PAIRP(nml))
+                    vec = NULL; /* So it was provided, but not from the indicated module */
                 }
+
+                if (vec)
+                  break;
               }
-              if (break_outer) break;
+            }
+            if (!vec) {
+              a = SCHEME_STX_CAR(l);
+              scheme_wrong_syntax("module", a, SCHEME_CADR(SCHEME_CAR(rx)),
+                                  "excluded name was not required from the module");
             }
           }
         }
       }
+    }
+  }
 
-      if (!matching_form) {
-        scheme_hash_set(provided, scheme_void, provided_list);
+  /* For each reprovided, walk through requires, check for re-provided bindings: */
+  for (z = 0; z < all_reprovided->size; z++) {
+    reprovided = all_reprovided->vals[z];
+    if (reprovided && !SCHEME_NULLP(reprovided)) {
+      phase = all_reprovided->keys[z];
+
+      for (k = 0; k < tables->size; k++) {
+        tvec = tables->vals[k];
+        if (tvec) {
+          required = (Scheme_Hash_Table *)SCHEME_VEC_ELS(tvec)[1];
+          req_phase = tables->keys[k];
+
+          for (i = required->size; i--; ) {
+            if (required->vals[i]) {
+              Scheme_Object *nominal_modidx, *name, *modidx, *srcname, *outname, *nml, *orig_nml, *mark_src;
+              int break_outer = 0;
+	
+              name = required->keys[i]; /* internal symbolic name */
+              orig_nml = SCHEME_VEC_ELS(required->vals[i])[0];
+              modidx = SCHEME_VEC_ELS(required->vals[i])[1];
+              srcname = SCHEME_VEC_ELS(required->vals[i])[2];
+              outname = SCHEME_VEC_ELS(required->vals[i])[4];
+              mark_src = SCHEME_VEC_ELS(required->vals[i])[6];
+
+              for (rx = reprovided; !SCHEME_NULLP(rx); rx = SCHEME_CDR(rx)) {
+                for (nml = orig_nml; SCHEME_PAIRP(nml); nml = SCHEME_CDR(nml)) {
+                  nominal_modidx = SCHEME_CAR(nml);
+                  if (SCHEME_PAIRP(nominal_modidx))
+                    nominal_modidx = SCHEME_CAR(nominal_modidx);
+                  if (all_mods || same_modidx(SCHEME_CAR(SCHEME_CAR(rx)), nominal_modidx)) {
+                    Scheme_Object *nml_pi;
+
+                    if (SCHEME_PAIRP(SCHEME_CAR(nml)))
+                      nml_pi = SCHEME_CADR(SCHEME_CAR(nml));
+                    else
+                      nml_pi = scheme_make_integer(0);
+
+                    if (SAME_OBJ(phase, nml_pi)) {
+                      Scheme_Object *exns, *ree;
+
+                      if (!all_mods) {
+                        break_outer = 1;
+                  
+                        ree = SCHEME_CDR(SCHEME_CAR(rx));
+
+                        exns = SCHEME_CDR(ree);
+                        if (SAME_OBJ(modidx, kernel_modidx))
+                          if (!SCHEME_STX_NULLP(exns)) {
+                            if (SAME_OBJ(phase, scheme_make_integer(0)) && _exclude_hint)
+                              *_exclude_hint = exns;
+                          }
+                      } else {
+                        ree = NULL;
+                        exns = scheme_null;
+                      }
+	    
+                      for (; !SCHEME_STX_NULLP(exns); exns = SCHEME_STX_CDR(exns)) {
+                        /* Was this name excluded? */
+                        Scheme_Object *a;
+                        a = SCHEME_STX_VAL(SCHEME_STX_CAR(exns));
+                        if (SAME_OBJ(a, name))
+                          break;
+                      }
+
+                      if (SCHEME_STX_NULLP(exns)) {
+                        /* Not excluded, so provide it. */
+                        if (matching_form) {
+                          /* Assert: !all_mods */
+                          provided = (Scheme_Hash_Table *)scheme_hash_get(all_provided, req_phase);
+                          if (!provided) {
+                            provided = scheme_make_hash_table(SCHEME_hash_ptr);
+                            scheme_hash_set(all_provided, req_phase, (Scheme_Object *)provided);
+                          }
+                          check_already_provided(provided, outname, name, 0, SCHEME_CAR(ree), req_phase);
+                          scheme_hash_set(provided, outname, scheme_make_pair(name, scheme_false));
+                        } else {
+                          if (SCHEME_TRUEP(mark_src)) {
+                            if (SCHEME_SYM_PARALLELP(name)) {
+                              /* reverse scheme_tl_id_sym */
+                              char *s;
+                              int len;
+                              len = SCHEME_SYM_LEN(name);
+                              s = scheme_malloc_atomic(len + 1);
+                              memcpy(s, SCHEME_SYM_VAL(name), len+1);
+                              while (len && (s[len] != '.')) {
+                                --len;
+                              }
+                              s[len] = 0;
+                              name = scheme_intern_exact_symbol(s, len);
+                            }
+                            name = scheme_datum_to_syntax(name, scheme_false, mark_src, 0, 0);
+                          } else {
+                            scheme_signal_error("found an import with no lexical context");
+                          }
+
+                          provided_list = scheme_hash_get(all_provided, req_phase);
+                          if (!provided_list)
+                            provided_list = scheme_null;
+                          provided_list = scheme_make_pair(name, provided_list);
+                          scheme_hash_set(all_provided, req_phase, provided_list);
+                        }
+
+                        if (SAME_OBJ(phase, scheme_make_integer(0)))
+                          if (SAME_OBJ(modidx, kernel_modidx) && SAME_OBJ(outname, srcname))
+                            reprovide_kernel++;
+                      }
+                    }
+                  }
+                  if (break_outer) break;
+                }
+              }
+            }
+          }
+        }
       }
     }
   }
 
   /* Do all-defined provides */
-  if (all_defs_out) {
-    provided = _provided;
+  for (z = 0; z < 2; z++) {
+    if (!z) {
+      all_defs = all_rt_defs;
+      all_defs_out = all_rt_defs_out;
+      provided = (Scheme_Hash_Table *)scheme_hash_get(all_provided, scheme_make_integer(0));
+      phase = scheme_make_integer(0);
+      genv = _genv;
+    } else {
+      all_defs = all_et_defs;
+      all_defs_out = all_et_defs_out;
+      provided = (Scheme_Hash_Table *)scheme_hash_get(all_provided, scheme_make_integer(1));
+      phase = scheme_make_integer(1);
+      genv = _genv->exp_env;
+    }
 
-    for (; !SCHEME_NULLP(all_defs_out); all_defs_out = SCHEME_CDR(all_defs_out)) {
-      Scheme_Object *exns, *ree, *ree_kw, *exl, *name, *a, *adl, *exname, *pfx;
-      int protected;
+    if (all_defs_out) {
+      for (; !SCHEME_NULLP(all_defs_out); all_defs_out = SCHEME_CDR(all_defs_out)) {
+        Scheme_Object *exns, *ree, *ree_kw, *exl, *name, *a, *adl, *exname, *pfx;
+        int protected;
 	    
-      ree = SCHEME_CAR(all_defs_out);
-      protected = SCHEME_TRUEP(SCHEME_CDR(ree));
-      ree = SCHEME_CAR(ree);
-      ree_kw = SCHEME_CAR(ree);
-      ree = SCHEME_CDR(ree);
-      exl = SCHEME_CAR(ree);
-      pfx = SCHEME_CDR(ree);
+        ree = SCHEME_CAR(all_defs_out);
+        protected = SCHEME_TRUEP(SCHEME_CDR(ree));
+        ree = SCHEME_CAR(ree);
+        ree_kw = SCHEME_CAR(ree);
+        ree = SCHEME_CDR(ree);
+        exl = SCHEME_CAR(ree);
+        pfx = SCHEME_CDR(ree);
 
-      /* Make sure each excluded name was defined: */
-      for (exns = exl; !SCHEME_STX_NULLP(exns); exns = SCHEME_STX_CDR(exns)) {
-        a = SCHEME_STX_CAR(exns);
-        name = scheme_tl_id_sym(genv, a, NULL, 0);
-        if (!scheme_lookup_in_table(genv->toplevel, (const char *)name)
-            && !scheme_lookup_in_table(genv->syntax, (const char *)name)) {
-          scheme_wrong_syntax("module", a, ree_kw, "excluded identifier was not defined");
-        }
-      }
-
-      for (adl = all_defs; SCHEME_PAIRP(adl); adl = SCHEME_CDR(adl)) {
-        name = SCHEME_CAR(adl);
-        exname = SCHEME_STX_SYM(name);
-        name = scheme_tl_id_sym(genv, name, NULL, 0);
-	
-        /* Was this one excluded? */
+        /* Make sure each excluded name was defined: */
         for (exns = exl; !SCHEME_STX_NULLP(exns); exns = SCHEME_STX_CDR(exns)) {
           a = SCHEME_STX_CAR(exns);
-          a = scheme_tl_id_sym(genv, a, NULL, 0);
-          if (SAME_OBJ(a, name))
-            break;
+          name = scheme_tl_id_sym(genv, a, NULL, 0, NULL);
+          if (!scheme_lookup_in_table(genv->toplevel, (const char *)name)
+              && !scheme_lookup_in_table(genv->syntax, (const char *)name)) {
+            scheme_wrong_syntax("module", a, ree_kw, "excluded identifier was not defined");
+          }
         }
 
-        if (SCHEME_STX_NULLP(exns)) {
-          /* not excluded */
+        for (adl = all_defs; SCHEME_PAIRP(adl); adl = SCHEME_CDR(adl)) {
+          name = SCHEME_CAR(adl);
+          exname = SCHEME_STX_SYM(name);
+          name = scheme_tl_id_sym(genv, name, NULL, 0, NULL);
+	
+          /* Was this one excluded? */
+          for (exns = exl; !SCHEME_STX_NULLP(exns); exns = SCHEME_STX_CDR(exns)) {
+            a = SCHEME_STX_CAR(exns);
+            a = scheme_tl_id_sym(genv, a, NULL, 0, NULL);
+            if (SAME_OBJ(a, name))
+              break;
+          }
+
+          if (SCHEME_STX_NULLP(exns)) {
+            /* not excluded */
 	  
-          /* But don't export uninterned: */
-          if (!SCHEME_SYM_UNINTERNEDP(name)) {
-            /* Also, check that ree_kw and the identifier have the same
-               introduction (in case one or the other was introduced by
-               a macro). We perform this check by getting exname's tl_id
-               as if it had ree_kw's context, then comparing that result
-               to the actual tl_id. */
-            a = scheme_datum_to_syntax(exname, scheme_false, ree_kw, 0, 0);
-            a = scheme_tl_id_sym(genv, a, NULL, 0);
+            /* But don't export uninterned: */
+            if (!SCHEME_SYM_UNINTERNEDP(name)) {
+              /* Also, check that ree_kw and the identifier have the same
+                 introduction (in case one or the other was introduced by
+                 a macro). We perform this check by getting exname's tl_id
+                 as if it had ree_kw's context, then comparing that result
+                 to the actual tl_id. */
+              a = scheme_datum_to_syntax(exname, scheme_false, ree_kw, 0, 0);
+              a = scheme_tl_id_sym(genv, a, NULL, 0, NULL);
 	    
-            if (SAME_OBJ(a, name)) {
-              /* Add prefix, if any */
-              if (SCHEME_TRUEP(pfx)) {
-                exname = scheme_symbol_append(pfx, exname);
-              }
-              check_already_provided(provided, exname, name, protected, ree_kw, phase);
+              if (SAME_OBJ(a, name)) {
+                /* Add prefix, if any */
+                if (SCHEME_TRUEP(pfx)) {
+                  exname = scheme_symbol_append(pfx, exname);
+                }
+                check_already_provided(provided, exname, name, protected, ree_kw, phase);
 	      
-              scheme_hash_set(provided, exname, 
-                              scheme_make_pair(name, protected ? scheme_true : scheme_false));
+                scheme_hash_set(provided, exname, 
+                                scheme_make_pair(name, protected ? scheme_true : scheme_false));
+              }
             }
           }
         }
@@ -6446,86 +6453,65 @@ int compute_reprovides(Scheme_Hash_Table *_provided, Scheme_Hash_Table *_et_prov
 }
 
 Scheme_Object *scheme_module_imported_list(Scheme_Env *genv, Scheme_Object *bindings, Scheme_Object *modpath,
-                                           int include_run, int include_exp, int include_lbl)
+                                           Scheme_Object *mode)
 {
-  Scheme_Hash_Table *ht, *et_ht, *dt_ht, *_ht, *_et_ht, *_dt_ht;
-  Scheme_Object *l, *requires, *required, *et_required, *dt_required, *a[3];
-  int v, i, phase, inc;
+  Scheme_Object *l, *all_mods, *all_phases;
+  Scheme_Hash_Table *tables, *all_reprovided, *all_provided;
+  int v, i;
 
-  _ht = scheme_make_hash_table(SCHEME_hash_ptr);
-  _et_ht = scheme_make_hash_table(SCHEME_hash_ptr);
-  _dt_ht = scheme_make_hash_table(SCHEME_hash_ptr);
+  tables = (Scheme_Hash_Table *)SCHEME_CAR(bindings);
+  all_reprovided = scheme_make_hash_table_equal();
 
-  bindings = SCHEME_CAR(bindings);
-  
-  for (i = 0; i < 3; i++) {
-    /* It's important to run the normal phase first, so that et and dt tables get filled. */
-    switch (i) {
-    case 0:
-      ht = _ht;
-      et_ht = _et_ht;
-      dt_ht = _dt_ht;
-      requires = genv->module->requires;
-      et_required = SCHEME_VEC_ELS(bindings)[1];
-      dt_required = SCHEME_VEC_ELS(bindings)[2];
-      phase = 0;
-      inc = include_run;
-      break;
-    case 1:
-      requires = genv->module->et_requires;
-      phase = 1;
-      ht = _et_ht;
-      et_ht = NULL;
-      dt_ht = NULL;
-      et_required = NULL;
-      dt_required = NULL;
-      inc = include_exp;
-      break;
-    default:
-    case 2:
-      requires = genv->module->dt_requires;
-      phase = MZ_LABEL_PHASE;
-      ht = _dt_ht;
-      et_ht = NULL;
-      dt_ht = NULL;
-      et_required = NULL;
-      dt_required = NULL;
-      inc = include_lbl;
-      break;
-    }
-    
-    required = SCHEME_VEC_ELS(bindings)[i];
-  
-    if (inc) {
-      if (SCHEME_FALSEP(modpath))
-        l = scheme_false;
-      else
-        l = scheme_make_pair(scheme_make_pair(modpath,
-                                              scheme_make_pair(scheme_false,
-                                                               scheme_null)),
-                             scheme_null);
-
-      v = compute_reprovides(ht, et_ht, dt_ht,
-                             l,
-                             requires, 
-                             (Scheme_Hash_Table *)required, (Scheme_Hash_Table *)et_required,(Scheme_Hash_Table *)dt_required,
-                             genv, NULL, NULL, NULL, 
-                             NULL, phase);
-    } else
-      v = 0;
-    
-    if (v < 0) {
-      l = scheme_false;
+  if (SCHEME_FALSEP(modpath)) {
+    if (SAME_OBJ(mode, scheme_true)) {
+      all_mods = scheme_null; 
+      all_phases = scheme_null; 
     } else {
-      l = scheme_hash_get(ht, scheme_void);
-      if (!l)
-        l = scheme_null;
+      all_mods = scheme_make_pair(mode, scheme_null);
+      all_phases = NULL;
     }
+  } else {
+    Scheme_Object *reprovided;
 
-    a[i] = l;
+    reprovided = scheme_make_pair(scheme_make_pair(modpath,
+                                                   scheme_make_pair(scheme_false,
+                                                                    scheme_null)),
+                                  scheme_null);
+    all_mods = NULL;
+    if (SAME_OBJ(mode, scheme_true)) {
+      all_phases = reprovided;
+    } else {
+      scheme_hash_set(all_reprovided, mode, reprovided);
+      all_phases = NULL;
+    }
   }
 
-  return scheme_values(3, a);
+  /* Receives result: */
+  all_provided = scheme_make_hash_table_equal();
+  
+  v = compute_reprovides(all_provided,
+                         all_reprovided,
+                         genv->module, 
+                         tables,
+                         genv, 
+                         NULL, NULL, NULL, NULL, 
+                         NULL, NULL,
+                         all_mods, all_phases);
+    
+  if (v < 0) {
+    return scheme_false;
+  } else {
+    l = scheme_null;
+    for (i = 0; i < all_provided->size; i++) {
+      if (all_provided->vals[i]) {
+        l = scheme_make_pair(scheme_make_pair(all_provided->keys[i],
+                                              all_provided->vals[i]),
+                             l);
+      }
+    }
+
+    return l;
+  }
 }
 
 static Scheme_Object *adjust_for_rename(Scheme_Object *out_name, Scheme_Object *in_name, Scheme_Object *noms)
@@ -6544,9 +6530,10 @@ static Scheme_Object *adjust_for_rename(Scheme_Object *out_name, Scheme_Object *
       /* no change */
     } else {
       a = scheme_make_pair(a,
-                           scheme_make_pair(scheme_false,
+                           scheme_make_pair(scheme_make_integer(0),
                                             scheme_make_pair(in_name,
-                                                             scheme_null)));
+                                                             scheme_make_pair(scheme_make_integer(0),
+                                                                              scheme_null))));
     }
 
     p = scheme_make_pair(a, scheme_null);
@@ -6562,181 +6549,227 @@ static Scheme_Object *adjust_for_rename(Scheme_Object *out_name, Scheme_Object *
   return first;
 }
 
-char *compute_provide_arrays(Scheme_Hash_Table *provided, Scheme_Hash_Table *required,
-                             Scheme_Module_Phase_Exports *pt,
-                             Scheme_Env *genv, int def_phase,
+char *compute_provide_arrays(Scheme_Hash_Table *all_provided, Scheme_Hash_Table *tables,
+                             Scheme_Module_Exports *me,
+                             Scheme_Env *genv,
                              int reprovide_kernel,
-                             Scheme_Object *form,
-                             const char *def_way)
+                             Scheme_Object *form)
 {
-  int i, count;
-  Scheme_Object **exs, **exsns, **exss, **exsnoms;
-  char *exps, *exets;
+  int i, count, z;
+  Scheme_Object **exs, **exsns, **exss, **exsnoms, *phase;
+  Scheme_Hash_Table *provided, *required;
+  char *exps, *exets, *phase0_exps = NULL;
   int excount, exvcount;
-    
-  for (count = 0, i = provided->size; i--; ) {
-    if (provided->vals[i])
-      count++;
-  }
-    
-  count -= reprovide_kernel;
+  Scheme_Module_Phase_Exports *pt;
+  
+  for (z = 0; z < all_provided->size; z++) {
+    provided = (Scheme_Hash_Table *)all_provided->vals[z];
 
-  exs = MALLOC_N(Scheme_Object *, count);
-  exsns = MALLOC_N(Scheme_Object *, count);
-  exss = MALLOC_N(Scheme_Object *, count);
-  exsnoms = MALLOC_N(Scheme_Object *, count);
-  exps = MALLOC_N_ATOMIC(char, count);
-  if (def_phase) {
-    exets = MALLOC_N_ATOMIC(char, count);
-    memset(exets, 0, count);
-  } else
-    exets = NULL;
+    if (provided) {
+      phase = all_provided->keys[z];
+      required = get_required_from_tables(tables, phase);
+      if (!required)
+        required = scheme_make_hash_table(SCHEME_hash_ptr);
+      
+      if (SAME_OBJ(phase, scheme_make_integer(0)))
+        pt = me->rt;
+      else if (SAME_OBJ(phase, scheme_make_integer(1)))
+        pt = me->et;
+      else if (SAME_OBJ(phase, scheme_false))
+        pt = me->dt;
+      else {
+        pt = MALLOC_ONE_RT(Scheme_Module_Phase_Exports);
+        pt->so.type = scheme_module_phase_exports_type;
+        pt->phase_index = phase;
+        if (!me->other_phases) {
+          Scheme_Hash_Table *ht;
+          ht = scheme_make_hash_table_equal();
+          me->other_phases = ht;
+        }
+        scheme_hash_set(me->other_phases, phase, (Scheme_Object *)pt);
+      }
 
-  /* Do non-syntax first. */
-  for (count = 0, i = provided->size; i--; ) {
-    if (provided->vals[i]) {
-      Scheme_Object *name, *prnt_name, *v;
-      int protected;
+      for (count = 0, i = provided->size; i--; ) {
+        if (provided->vals[i])
+          count++;
+      }
+    
+      if (SAME_OBJ(phase, scheme_make_integer(0)))
+        count -= reprovide_kernel;
+
+      exs = MALLOC_N(Scheme_Object *, count);
+      exsns = MALLOC_N(Scheme_Object *, count);
+      exss = MALLOC_N(Scheme_Object *, count);
+      exsnoms = MALLOC_N(Scheme_Object *, count);
+      exps = MALLOC_N_ATOMIC(char, count);
+      if (SAME_OBJ(phase, scheme_make_integer(1))) {
+        exets = MALLOC_N_ATOMIC(char, count);
+        memset(exets, 0, count);
+      } else
+        exets = NULL;
+
+      /* Do non-syntax first. */
+      for (count = 0, i = provided->size; i--; ) {
+        if (provided->vals[i]) {
+          Scheme_Object *name, *prnt_name, *v;
+          int protected;
 	
-      v = provided->vals[i]; /* external name */
-      name = SCHEME_CAR(v);  /* internal name (maybe already a symbol) */
-      protected = SCHEME_TRUEP(SCHEME_CDR(v));
+          v = provided->vals[i]; /* external name */
+          name = SCHEME_CAR(v);  /* internal name (maybe already a symbol) */
+          protected = SCHEME_TRUEP(SCHEME_CDR(v));
 
-      prnt_name = name;
-      if (SCHEME_STXP(name)) {
-        if (genv)
-          name = scheme_tl_id_sym(genv, name, NULL, 0);
-        else
-          name = SCHEME_STX_VAL(name); /* shouldn't get here; no `define-for-label' */
-      }
+          prnt_name = name;
+          if (SCHEME_STXP(name)) {
+            if (genv)
+              name = scheme_tl_id_sym(genv, name, NULL, 0, phase);
+            else
+              name = SCHEME_STX_VAL(name); /* shouldn't get here; no `define-for-label' */
+          }
 
-      if (genv && scheme_lookup_in_table(genv->toplevel, (const char *)name)) {
-        /* Defined locally */
-        exs[count] = provided->keys[i];
-        exsns[count] = name;
-        exss[count] = scheme_false; /* means "self" */
-        exsnoms[count] = scheme_null; /* since "self" */
-        exps[count] = protected;
-        if (exets)
-          exets[count] = def_phase;
-        count++;
-      } else if (genv && scheme_lookup_in_table(genv->syntax, (const char *)name)) {
-        /* Skip for now. */
-      } else if ((v = scheme_hash_get(required, name))) {
-        /* Required */
-        if (protected) {
-          name = SCHEME_CAR(provided->vals[i]);
-          scheme_wrong_syntax("module", NULL, name, "cannot protect imported identifier with re-provide"); 
-        }
-        if (SCHEME_TRUEP(SCHEME_VEC_ELS(v)[3])) {
-          /* If this is a kernel re-provide, don't provide after all. */
-          if (reprovide_kernel
-              && SAME_OBJ(SCHEME_VEC_ELS(v)[1], kernel_modidx)
-              && SAME_OBJ(provided->keys[i], SCHEME_VEC_ELS(v)[2])) {
-            /* skip */
-          } else {
-            Scheme_Object *noms;
+          if (genv 
+              && (SAME_OBJ(phase, scheme_make_integer(0))
+                  || SAME_OBJ(phase, scheme_make_integer(1)))
+              && scheme_lookup_in_table(SAME_OBJ(phase, scheme_make_integer(0))
+                                        ? genv->toplevel
+                                        : genv->exp_env->toplevel,
+                                        (const char *)name)) {
+            /* Defined locally */
             exs[count] = provided->keys[i];
-            exsns[count] = SCHEME_VEC_ELS(v)[2];
-            exss[count] = SCHEME_VEC_ELS(v)[1];
-            noms = adjust_for_rename(exs[count], SCHEME_VEC_ELS(v)[4], SCHEME_VEC_ELS(v)[0]);
-            exsnoms[count] = noms;
+            exsns[count] = name;
+            exss[count] = scheme_false; /* means "self" */
+            exsnoms[count] = scheme_null; /* since "self" */
             exps[count] = protected;
+            if (exets)
+              exets[count] = 1;
             count++;
+          } else if (genv 
+                     && SAME_OBJ(phase, scheme_make_integer(0))
+                     && scheme_lookup_in_table(genv->syntax, (const char *)name)) {
+            /* Skip for now. */
+          } else if ((v = scheme_hash_get(required, name))) {
+            /* Required */
+            if (protected) {
+              name = SCHEME_CAR(provided->vals[i]);
+              scheme_wrong_syntax("module", NULL, name, "cannot protect imported identifier with re-provide"); 
+            }
+            if (SCHEME_TRUEP(SCHEME_VEC_ELS(v)[3])) {
+              /* If this is a kernel re-provide, don't provide after all. */
+              if ((reprovide_kernel && SAME_OBJ(phase, scheme_make_integer(0)))
+                  && SAME_OBJ(SCHEME_VEC_ELS(v)[1], kernel_modidx)
+                  && SAME_OBJ(provided->keys[i], SCHEME_VEC_ELS(v)[2])) {
+                /* skip */
+              } else {
+                Scheme_Object *noms;
+                exs[count] = provided->keys[i];
+                exsns[count] = SCHEME_VEC_ELS(v)[2];
+                exss[count] = SCHEME_VEC_ELS(v)[1];
+                noms = adjust_for_rename(exs[count], SCHEME_VEC_ELS(v)[4], SCHEME_VEC_ELS(v)[0]);
+                exsnoms[count] = noms;
+                exps[count] = protected;
+                count++;
+              }
+            }
+          } else {
+            /* Not defined! */
+            scheme_wrong_syntax("module", prnt_name, form, "provided identifier not defined or imported");
           }
         }
-      } else {
-        /* Not defined! */
-        scheme_wrong_syntax("module", prnt_name, form, def_way);
       }
-    }
-  }
 
-  exvcount = count;
+      exvcount = count;
 
-  for (i = provided->size; i--; ) {
-    if (provided->vals[i]) {
-      Scheme_Object *name, *v;
-      int protected;
+      for (i = provided->size; i--; ) {
+        if (provided->vals[i]) {
+          Scheme_Object *name, *v;
+          int protected;
 	  
-      v = provided->vals[i];
-      name = SCHEME_CAR(v); /* internal name (maybe already a symbol) */
-      protected = SCHEME_TRUEP(SCHEME_CDR(v));
+          v = provided->vals[i];
+          name = SCHEME_CAR(v); /* internal name (maybe already a symbol) */
+          protected = SCHEME_TRUEP(SCHEME_CDR(v));
 
-      if (SCHEME_STXP(name)) {
-        if (genv)
-          name = scheme_tl_id_sym(genv, name, NULL, 0);
-        else {
-          name = SCHEME_STX_VAL(name); /* shouldn't get here; no `define-for-label' */
-        }
-      }
+          if (SCHEME_STXP(name)) {
+            if (genv
+                && (SAME_OBJ(phase, scheme_make_integer(0))
+                    || SAME_OBJ(phase, scheme_make_integer(1))))
+              name = scheme_tl_id_sym(genv, name, NULL, 0, phase);
+            else {
+              name = SCHEME_STX_VAL(name); /* shouldn't get here; no `define-for-label' */
+            }
+          }
 
-      if (genv && scheme_lookup_in_table(genv->syntax, (const char *)name)) {
-        /* Defined locally */
-        exs[count] = provided->keys[i];
-        exsns[count] = name;
-        exss[count] = scheme_false; /* means "self" */
-        exsnoms[count] = scheme_null; /* since "self" */
-        exps[count] = protected;
-        if (exets)
-          exets[count] = def_phase;
-        count++;
-      } else if ((v = scheme_hash_get(required, name))) {
-        /* Required */
-        if (SCHEME_FALSEP(SCHEME_VEC_ELS(v)[3])) {
-          /* If this is a kernel re-provide, don't provide after all. */
-          if (reprovide_kernel
-              && SAME_OBJ(SCHEME_VEC_ELS(v)[1], kernel_modidx)
-              && SAME_OBJ(provided->keys[i], SCHEME_VEC_ELS(v)[2])) {
-            /* skip */
-          } else {
-            Scheme_Object *noms;
+          if (genv 
+              && SAME_OBJ(phase, scheme_make_integer(0))
+              && scheme_lookup_in_table(genv->syntax, (const char *)name)) {
+            /* Defined locally */
             exs[count] = provided->keys[i];
-            exsns[count] = SCHEME_VEC_ELS(v)[2];
-            exss[count] = SCHEME_VEC_ELS(v)[1];
-            noms = adjust_for_rename(exs[count], SCHEME_VEC_ELS(v)[4], SCHEME_VEC_ELS(v)[0]);
-            exsnoms[count] = noms;
+            exsns[count] = name;
+            exss[count] = scheme_false; /* means "self" */
+            exsnoms[count] = scheme_null; /* since "self" */
             exps[count] = protected;
+            if (exets)
+              exets[count] = 1;
             count++;
+          } else if ((v = scheme_hash_get(required, name))) {
+            /* Required */
+            if (SCHEME_FALSEP(SCHEME_VEC_ELS(v)[3])) {
+              /* If this is a kernel re-provide, don't provide after all. */
+              if ((reprovide_kernel && SAME_OBJ(phase, scheme_make_integer(0)))
+                  && SAME_OBJ(SCHEME_VEC_ELS(v)[1], kernel_modidx)
+                  && SAME_OBJ(provided->keys[i], SCHEME_VEC_ELS(v)[2])) {
+                /* skip */
+              } else {
+                Scheme_Object *noms;
+                exs[count] = provided->keys[i];
+                exsns[count] = SCHEME_VEC_ELS(v)[2];
+                exss[count] = SCHEME_VEC_ELS(v)[1];
+                noms = adjust_for_rename(exs[count], SCHEME_VEC_ELS(v)[4], SCHEME_VEC_ELS(v)[0]);
+                exsnoms[count] = noms;
+                exps[count] = protected;
+                count++;
+              }
+            }
           }
         }
       }
+
+      excount = count;
+
+      /* Discard exsnom[n]s if there are no re-exports */
+      for (i = 0; i < excount; i++) {
+        if (!SCHEME_NULLP(exsnoms[count]))
+          break;
+      }
+      if (i >= excount) {
+        exsnoms = NULL;
+      }
+
+      /* Sort provide array for variables: interned followed by
+         uninterned, alphabetical within each. This is important for
+         having a consistent provide arrays. */
+      qsort_provides(exs, exsns, exss, exps, exets, exsnoms, 0, exvcount, 1);
+
+      pt->num_provides = excount;
+      pt->num_var_provides = exvcount;
+      pt->provides = exs;
+      pt->provide_src_names = exsns;
+      pt->provide_srcs = exss;
+      pt->provide_nominal_srcs = exsnoms;
+      if (exets) {
+        for (i = 0; i < excount; i++) {
+          if (exets[i])
+            break;
+        }
+        if (i >= excount)
+          exets = NULL;
+      }
+      pt->provide_src_phases = exets;
+
+      if (SAME_OBJ(phase, scheme_make_integer(0)))
+        phase0_exps = exps;
     }
   }
-
-  excount = count;
-
-  /* Discard exsnom[n]s if there are no re-exports */
-  for (i = 0; i < excount; i++) {
-    if (!SCHEME_NULLP(exsnoms[count]))
-      break;
-  }
-  if (i >= excount) {
-    exsnoms = NULL;
-  }
-
-  /* Sort provide array for variables: interned followed by
-     uninterned, alphabetical within each. This is important for
-     having a consistent provide arrays. */
-  qsort_provides(exs, exsns, exss, exps, exets, exsnoms, 0, exvcount, 1);
-
-  pt->num_provides = excount;
-  pt->num_var_provides = exvcount;
-  pt->provides = exs;
-  pt->provide_src_names = exsns;
-  pt->provide_srcs = exss;
-  pt->provide_nominal_srcs = exsnoms;
-  if (exets) {
-    for (i = 0; i < excount; i++) {
-      if (exets[i])
-        break;
-    }
-    if (i >= excount)
-      exets = NULL;
-  }
-  pt->provide_src_phases = exets;
-
-  return exps;
+    
+  return phase0_exps;
 }
 
 /* Helper: */
@@ -6862,7 +6895,7 @@ static void qsort_provides(Scheme_Object **exs, Scheme_Object **exsns, Scheme_Ob
 }
 
 static Scheme_Object *expand_provide(Scheme_Object *e, 
-                                     Scheme_Object *expand_vec,
+                                     Scheme_Hash_Table *tables,
                                      Scheme_Object *all_defs, Scheme_Object *all_et_defs,
                                      Scheme_Comp_Env *cenv, Scheme_Compile_Info *rec, int drec)
 {
@@ -6877,7 +6910,7 @@ static Scheme_Object *expand_provide(Scheme_Object *e,
   scheme_add_local_syntax(1, xenv);
   scheme_set_local_syntax(0, scheme_begin_stx, stop, xenv);
 
-  b = scheme_make_pair(expand_vec,
+  b = scheme_make_pair((Scheme_Object *)tables,
                        scheme_make_pair(all_defs, all_et_defs));
   scheme_current_thread->current_local_bindings = b;
   
@@ -6893,22 +6926,22 @@ static Scheme_Object *expand_provide(Scheme_Object *e,
 }
 
 void parse_provides(Scheme_Object *form, Scheme_Object *fst, Scheme_Object *e, 
-                    Scheme_Hash_Table *provided, Scheme_Object **_reprovided,
-                    Scheme_Hash_Table *et_provided, Scheme_Object **_et_reprovided,
-                    Scheme_Hash_Table *dt_provided, Scheme_Object **_dt_reprovided,
+                    Scheme_Hash_Table *all_provided,
+                    Scheme_Hash_Table *all_reprovided,
                     Scheme_Object *self_modidx, 
                     Scheme_Object **_all_defs_out,
                     Scheme_Object **_et_all_defs_out,
-                    Scheme_Hash_Table *required, Scheme_Hash_Table *et_required, Scheme_Hash_Table *dt_required, 
+                    Scheme_Hash_Table *tables,
                     Scheme_Object *all_defs, Scheme_Object *all_et_defs,
                     Scheme_Comp_Env *cenv, Scheme_Compile_Info *rec, int drec,
                     Scheme_Object **_expanded)
 {
-  Scheme_Object *l, *rebuilt = scheme_null, *protect_stx = NULL, *expand_vec = NULL;
+  Scheme_Object *l, *rebuilt = scheme_null, *protect_stx = NULL;
   int protect_cnt = 0, mode_cnt = 0, expanded = 0;
-  Scheme_Object *all_defs_out, *mode_symbol = NULL, *reprovided, *mode_stx = NULL;
-  Scheme_Hash_Table *_provided, *_required;
-  int phase;
+  Scheme_Object *mode = scheme_make_integer(0), *mode_stx = NULL;
+  Scheme_Object *all_defs_out;
+  Scheme_Hash_Table *provided;
+  Scheme_Object *phase;
 
   if (scheme_stx_proper_list_length(e) < 0)
     scheme_wrong_syntax(NULL, e, form, "bad syntax (" IMPROPER_LIST_FORM ")");
@@ -6944,22 +6977,40 @@ void parse_provides(Scheme_Object *form, Scheme_Object *fst, Scheme_Object *e,
 
           a = SCHEME_STX_CAR(l);
         } else if (SAME_OBJ(av, for_syntax_symbol)
-                   || SAME_OBJ(av, for_label_symbol)) {
+                   || SAME_OBJ(av, for_label_symbol)
+                   || SAME_OBJ(av, for_meta_symbol)) {
           if (mode_cnt)
             scheme_wrong_syntax(NULL, a, e, 
                                 (SAME_OBJ(av, for_syntax_symbol)
                                  ? "bad syntax (nested `for-syntax')"
-                                 : "bad syntax (nested `for-label')"));
-
+                                 : (SAME_OBJ(av, for_label_symbol)
+                                    ? "bad syntax (nested `for-label')"
+                                    : "bad syntax (nested `for-meta')")));
+          
           mode_stx = a;
           a = SCHEME_STX_CDR(a);
           a = scheme_flatten_syntax_list(a, NULL);
+          if (SAME_OBJ(av, for_meta_symbol)) {
+            if (SCHEME_NULLP(a)) {
+              scheme_wrong_syntax(NULL, mode_stx, e, "missing `for-meta' phase");
+            }
+            mode = SCHEME_CAR(a);
+            mode = SCHEME_STX_VAL(mode);
+            if (!SCHEME_FALSEP(mode)
+                && !SCHEME_INTP(mode)
+                && !SCHEME_BIGNUMP(mode)) {
+              scheme_wrong_syntax(NULL, mode_stx, e, "bad `for-meta' phase");
+            }
+            a = SCHEME_CDR(a);
+          } else if (SAME_OBJ(av, for_syntax_symbol))
+            mode = scheme_make_integer(1);
+          else if (SAME_OBJ(av, for_label_symbol))
+            mode = scheme_false;
           l = SCHEME_STX_CDR(l);
           l = scheme_append(a, l);
           mode_cnt = scheme_list_length(a);
           if (protect_cnt)
             protect_cnt += mode_cnt;
-          mode_symbol = av;
           a = SCHEME_STX_CAR(l);
         } else
           break;
@@ -6967,32 +7018,26 @@ void parse_provides(Scheme_Object *form, Scheme_Object *fst, Scheme_Object *e,
         break;
     }
 
-    if (SAME_OBJ(mode_symbol, for_syntax_symbol)) {
-      phase = 1;
-      reprovided = *_et_reprovided;
+    if (SAME_OBJ(mode, scheme_make_integer(0)))
+      all_defs_out = *_all_defs_out;
+    else if (SAME_OBJ(mode, scheme_make_integer(1)))
       all_defs_out = *_et_all_defs_out;
-      _provided = et_provided;
-      _required = et_required;
-    } else if (SAME_OBJ(mode_symbol, for_label_symbol)) {
-      phase = MZ_LABEL_PHASE;
-      reprovided = *_dt_reprovided;
-      all_defs_out = *_all_defs_out;
-      _provided = dt_provided;
-      _required = dt_required;
-    } else {
-      phase = 0;
-      reprovided = *_reprovided;
-      all_defs_out = *_all_defs_out;
-      _provided = provided;
-      _required = required;
+    else
+      all_defs_out = NULL;
+
+    provided = (Scheme_Hash_Table *)scheme_hash_get(all_provided, mode);
+    if (!provided) {
+      provided = scheme_make_hash_table(SCHEME_hash_ptr);
+      scheme_hash_set(all_provided, mode, (Scheme_Object *)provided);
     }
+    phase = mode;
 
     if (SCHEME_STX_SYMBOLP(a)) {
       /* <id> */
       name = SCHEME_STX_VAL(a);
-      check_already_provided(_provided, name, a, protect_cnt, form, phase);
+      check_already_provided(provided, name, a, protect_cnt, form, phase);
       /* Provide a: */
-      scheme_hash_set(_provided, name, scheme_make_pair(a, protect_cnt ? scheme_true : scheme_false));
+      scheme_hash_set(provided, name, scheme_make_pair(a, protect_cnt ? scheme_true : scheme_false));
     } else if (SCHEME_STX_PAIRP(a)) {
       Scheme_Object *rest;
 
@@ -7013,14 +7058,7 @@ void parse_provides(Scheme_Object *form, Scheme_Object *fst, Scheme_Object *e,
           return;
         }
 
-        if (!expand_vec) {
-          expand_vec = scheme_make_vector(3, NULL);
-          SCHEME_VEC_ELS(expand_vec)[0] = (Scheme_Object *)required;
-          SCHEME_VEC_ELS(expand_vec)[1] = (Scheme_Object *)et_required;
-          SCHEME_VEC_ELS(expand_vec)[2] = (Scheme_Object *)dt_required;
-        }
-
-        p = expand_provide(p, expand_vec, all_defs, all_et_defs, cenv, rec, drec);
+        p = expand_provide(p, tables, all_defs, all_et_defs, cenv, rec, drec);
 
         /* Check for '(begin datum ...) result: */
         p = scheme_flatten_syntax_list(p, &islist);
@@ -7073,11 +7111,13 @@ void parse_provides(Scheme_Object *form, Scheme_Object *fst, Scheme_Object *e,
 		
         enm = SCHEME_STX_VAL(enm);
 		
-        check_already_provided(_provided, enm, inm, protect_cnt, a, phase);
+        check_already_provided(provided, enm, inm, protect_cnt, a, phase);
         /* Provide enm: */
-        scheme_hash_set(_provided, enm, scheme_make_pair(inm, protect_cnt ? scheme_true : scheme_false));
+        scheme_hash_set(provided, enm, scheme_make_pair(inm, protect_cnt ? scheme_true : scheme_false));
       } else if (SAME_OBJ(all_from_symbol, SCHEME_STX_VAL(fst))) {
         /* (all-from <modname>) */
+        Scheme_Object *reprovided;
+        
         if (protect_cnt)
           scheme_wrong_syntax(NULL, a, e, "bad syntax (not allowed as protected)");
         if (!SCHEME_STX_PAIRP(rest))
@@ -7089,11 +7129,18 @@ void parse_provides(Scheme_Object *form, Scheme_Object *fst, Scheme_Object *e,
         midx = scheme_make_modidx(scheme_syntax_to_datum(midx, 0, NULL),
                                   self_modidx,
                                   scheme_false);
-		
+	
+        reprovided = scheme_hash_get(all_reprovided, mode);
+        if (!reprovided)
+          reprovided = scheme_null;
+            
         reprovided = scheme_make_pair(scheme_make_pair(midx, scheme_make_pair(e, scheme_null)), 
                                       reprovided);
+
+        scheme_hash_set(all_reprovided, mode, reprovided);
       } else if (SAME_OBJ(all_from_except_symbol, SCHEME_STX_VAL(fst))) {
         /* (all-from-except <modname> <id> ...) */
+        Scheme_Object *reprovided;
         Scheme_Object *exns, *el, *p;
         int len;
 		
@@ -7122,8 +7169,14 @@ void parse_provides(Scheme_Object *form, Scheme_Object *fst, Scheme_Object *e,
           }
         }
 		
+        reprovided = scheme_hash_get(all_reprovided, mode);
+        if (!reprovided)
+          reprovided = scheme_null;
+        
         reprovided = scheme_make_pair(scheme_make_pair(midx, scheme_make_pair(e, exns)), 
                                       reprovided);
+
+        scheme_hash_set(all_reprovided, mode, reprovided);
       } else if (SAME_OBJ(struct_symbol, SCHEME_STX_VAL(fst))) {
         /* (struct <id> (<id> ...)) */
         int len, i;
@@ -7169,15 +7222,20 @@ void parse_provides(Scheme_Object *form, Scheme_Object *fst, Scheme_Object *e,
           /* Wrap local name with prnt_base in case there are marks that 
              trigger "gensym"ing */
           p = scheme_datum_to_syntax(names[i], scheme_false, prnt_base, 0, 0);
-          check_already_provided(_provided, names[i], p, protect_cnt, e, phase);
-          scheme_hash_set(_provided, names[i], 
+          check_already_provided(provided, names[i], p, protect_cnt, e, phase);
+          scheme_hash_set(provided, names[i], 
                           scheme_make_pair(p, protect_cnt ? scheme_true : scheme_false));
         }
       } else if (SAME_OBJ(all_defined_symbol, SCHEME_STX_VAL(fst))) {
         /* (all-defined) */
         if (!SCHEME_STX_NULLP(rest))
           scheme_wrong_syntax(NULL, a, e, "bad syntax");
-		
+        
+        if (!all_defs_out) {
+          scheme_wrong_syntax(NULL, a, e, "no definitions at phase level %V",
+                              mode);
+        }
+
         all_defs_out = scheme_make_pair(scheme_make_pair(scheme_make_pair(e, 
                                                                           scheme_make_pair(scheme_null, 
                                                                                            scheme_false)),
@@ -7200,6 +7258,11 @@ void parse_provides(Scheme_Object *form, Scheme_Object *fst, Scheme_Object *e,
         }
         prefix = SCHEME_STX_VAL(prefix);
 
+        if (!all_defs_out) {
+          scheme_wrong_syntax(NULL, a, e, "no definitions at phase level %V",
+                              mode);
+        }
+        
         all_defs_out = scheme_make_pair(scheme_make_pair(scheme_make_pair(e, 
                                                                           scheme_make_pair(scheme_null, 
                                                                                            prefix)),
@@ -7240,6 +7303,11 @@ void parse_provides(Scheme_Object *form, Scheme_Object *fst, Scheme_Object *e,
           }
         }
 		
+        if (!all_defs_out) {
+          scheme_wrong_syntax(NULL, a, e, "no definitions at phase level %V",
+                              mode);
+        }
+        
         all_defs_out = scheme_make_pair(scheme_make_pair(scheme_make_pair(e, 
                                                                           scheme_make_pair(exns,
                                                                                            prefix)),
@@ -7251,7 +7319,7 @@ void parse_provides(Scheme_Object *form, Scheme_Object *fst, Scheme_Object *e,
     } else {
       scheme_wrong_syntax(NULL, a, e, NULL);
     }
-
+    
     a = SCHEME_STX_CAR(l);
     if (SCHEME_TRUEP(a)) {
       if (protect_cnt) {
@@ -7260,10 +7328,11 @@ void parse_provides(Scheme_Object *form, Scheme_Object *fst, Scheme_Object *e,
         a = scheme_make_pair(f, scheme_make_pair(a, scheme_null));
         a = scheme_datum_to_syntax(a, protect_stx, protect_stx, 0, 0);
       }
-      if (mode_symbol) {
+      if (!SAME_OBJ(mode, scheme_make_integer(0))) {
         Scheme_Object *f;
         f = SCHEME_STX_CAR(mode_stx);
-        a = scheme_make_pair(f, scheme_make_pair(a, scheme_null));
+        a = scheme_make_pair(f, scheme_make_pair(for_meta_symbol, 
+                                                 scheme_make_pair(mode, scheme_null)));
         a = scheme_datum_to_syntax(a, mode_stx, mode_stx, 0, 0);
       }
       rebuilt = scheme_make_pair(a, rebuilt);
@@ -7272,22 +7341,15 @@ void parse_provides(Scheme_Object *form, Scheme_Object *fst, Scheme_Object *e,
     if (protect_cnt)
       --protect_cnt;
 
-    if (SAME_OBJ(mode_symbol, for_syntax_symbol)) {
-      *_et_reprovided = reprovided;
+    if (SAME_OBJ(mode, scheme_make_integer(0)))
+      *_all_defs_out = all_defs_out;
+    else if (SAME_OBJ(mode, scheme_make_integer(1)))
       *_et_all_defs_out = all_defs_out;
-    } else if (SAME_OBJ(mode_symbol, for_label_symbol)) {
-      phase = MZ_LABEL_PHASE;
-      *_dt_reprovided = reprovided;
-      *_all_defs_out = all_defs_out;
-    } else {
-      *_reprovided = reprovided;
-      *_all_defs_out = all_defs_out;
-    }
 
     if (mode_cnt) {
       --mode_cnt;
       if (!mode_cnt)
-        mode_symbol = NULL;
+        mode = scheme_make_integer(0);
     }
   }
 
@@ -7306,7 +7368,7 @@ void parse_provides(Scheme_Object *form, Scheme_Object *fst, Scheme_Object *e,
 
 Scheme_Object *scheme_module_exported_list(Scheme_Object *modpath, Scheme_Env *genv)
 {
-  Scheme_Object *modname, *l, *modidx, *a[3], *stx;
+  Scheme_Object *modname, *l, *modidx, *stx, *phase, *result;
   Scheme_Module *m;
   int i, j;
   Scheme_Module_Phase_Exports *pt;
@@ -7327,33 +7389,42 @@ Scheme_Object *scheme_module_exported_list(Scheme_Object *modpath, Scheme_Env *g
 
   if (!m) {
     /* Can we get here? */
-    a[0] = scheme_null;
-    a[1] = scheme_null;
-    a[2] = scheme_null;
+    return scheme_null;
   } else {
-    for (i = 0; i < 3; i++) {
+    result = scheme_null;
+
+    for (i = -3; i < (m->me->other_phases ? m->me->other_phases->size : 0); i++) {
       l = scheme_null;
       switch (i) {
-      case 0:
+      case -3:
         pt = m->me->rt;
+        phase = scheme_make_integer(0);
         break;
-      case 1:
+      case -2:
         pt = m->me->et;
+        phase = scheme_make_integer(1);
+        break;
+      case -1:
+        pt = m->me->dt;
+        phase = scheme_false;
         break;
       default:
-      case 2:
-        pt = m->me->dt;
+        pt = (Scheme_Module_Phase_Exports *)m->me->other_phases->vals[i];
+        phase = m->me->other_phases->keys[i];
         break;
       }
-      for (j = 0; j < pt->num_provides; j++) {
-        l = scheme_make_pair(pt->provides[j], l);
+      if (pt) {
+        for (j = 0; j < pt->num_provides; j++) {
+          l = scheme_make_pair(pt->provides[j], l);
+        }
+
+        result = scheme_make_pair(scheme_make_pair(phase, l),
+                                  result);
       }
-
-      a[i] = l;
     }
-  }
 
-  return scheme_values(3, a);
+    return result;
+  }
 }
 
 /**********************************************************************/
@@ -7361,14 +7432,13 @@ Scheme_Object *scheme_module_exported_list(Scheme_Object *modpath, Scheme_Env *g
 /**********************************************************************/
 
 void add_single_require(Scheme_Module_Exports *me, /* from module */
-                        int base_k, /* [0, 1, 2] => start with [rt, et, dt] */
-                        int src_phase_index,
+                        Scheme_Object *only_phase,
+                        Scheme_Object *src_phase_index,
 			Scheme_Object *idx, /* from module's idx; may be saved for unmarshalling */
 			Scheme_Env *orig_env, /* env for mark_src or copy_vars */
-			Scheme_Object *rt_rn, /* add requires to this rename when no mark_src */
-			Scheme_Object *post_ex_rt_rn, /* add requires to this rename when mark_src */
-			Scheme_Object *et_rn, Scheme_Object *post_ex_et_rn,
-			Scheme_Object *dt_rn, Scheme_Object *post_ex_dt_rn,
+			Scheme_Object *rn_set, /* add requires to renames in this set when no mark_src */
+			Scheme_Object *post_ex_rn_set, /* add requires to this rename when mark_src */
+                        Scheme_Object *single_rn, /* instead of rn_set */
 			Scheme_Object *exns, /* NULL or [syntax] list of [syntax] symbols not to import */
 			Scheme_Hash_Table *onlys, /* NULL or hash table of names to import; the hash table is mutated */
 			Scheme_Object *prefix, /* NULL or prefix symbol */
@@ -7379,19 +7449,17 @@ void add_single_require(Scheme_Module_Exports *me, /* from module */
 			int can_save_marshal,
 			int *all_simple,
 			Check_Func ck, /* NULL or called for each addition */
-			void *rt_data, void *et_data, void *dt_data, 
+			void *data,
                         Scheme_Object *form, Scheme_Object *err_src, Scheme_Object *cki /* ck args */
 			)
 {
   int j, var_count;
-  Scheme_Object *orig_idx = idx;
+  Scheme_Object *orig_idx = idx, *to_phase;
   Scheme_Object **exs, **exsns, **exss;
   char *exets;
-  void *data;
   int is_kern, has_context, save_marshal_info = 0;
-  Scheme_Object *nominal_modidx, *one_exn, *prnt_iname, *name, *rn, *post_ex_rn, *ename = orig_ename;
+  Scheme_Object *nominal_modidx, *one_exn, *prnt_iname, *name, *rn, *ename = orig_ename;
   Scheme_Hash_Table *orig_onlys;
-  Scheme_Env *env;
   int k, skip_rename;
   
   if (mark_src) {
@@ -7415,219 +7483,228 @@ void add_single_require(Scheme_Module_Exports *me, /* from module */
   else
     orig_onlys = NULL;
     
-  for (k = 0; k < (et_rn ? 3 : 1); k++) {
+  for (k = -3; k < (me->other_phases ? me->other_phases->size : 0); k++) {
     Scheme_Module_Phase_Exports *pt;
 
     switch(k) {
-    case 0:
-      switch(base_k) {
-      case 0:
-        pt = me->rt;
-        break;
-      case 1:
-        pt = me->et;
-        break;
-      case 2:
-      default:
-        pt = me->dt;
-        break;
-      }
-      env = orig_env;
-      rn = rt_rn;
-      post_ex_rn = post_ex_rt_rn;
-      data = rt_data;
+    case -3:
+      pt = me->rt;
       break;
-    case 1:
+    case -2:
       pt = me->et;
-      env = orig_env->exp_env;
-      rn = et_rn;
-      post_ex_rn = post_ex_et_rn;
-      data = et_data;
       break;
-    case 2:
-    default:
+    case -1:
       pt = me->dt;
-      env = orig_env->label_env;
-      rn = dt_rn;
-      post_ex_rn = post_ex_dt_rn;
-      data = dt_data;
+      break;
+    default:
+      pt = (Scheme_Module_Phase_Exports *)me->other_phases->vals[k];
       break;
     }
 
-    is_kern = (SAME_OBJ(idx, kernel_modidx)
-               && !exns
-               && !onlys
-               && !prefix
-               && !iname
-               && !unpack_kern
-               && !has_context);
-    
-    one_exn = NULL;
-    
-    nominal_modidx = idx;
+    if (pt && only_phase) {
+      if (!scheme_eqv(pt->phase_index, only_phase))
+        pt = NULL;
+    }
 
-    if (can_save_marshal
-        && !exns
-        && !prefix
-        && !orig_ename
-        && (pt->num_provides || pt->reprovide_kernel)) {
-      /* Simple "import everything" whose mappings can be shared via the exporting module: */
-      if (!pt->src_modidx)
-        pt->src_modidx = me->src_modidx;
-      scheme_extend_module_rename_with_shared(rn, idx, pt, k + base_k, src_phase_index, 1);
-      skip_rename = 1;
+    if (pt) {
+      if (SCHEME_FALSEP(pt->phase_index))
+        to_phase = scheme_false;
+      else if (SCHEME_FALSEP(src_phase_index))
+        to_phase = scheme_false;
+      else
+        to_phase = scheme_bin_plus(pt->phase_index, src_phase_index);
     } else
-      skip_rename = 0;
+      to_phase = NULL;
 
-    while (1) { /* loop to handle kernel re-provides... */
-      int break_if_iname_null = !!iname;
+    if (pt) {
+      is_kern = (SAME_OBJ(idx, kernel_modidx)
+                 && !exns
+                 && !onlys
+                 && !prefix
+                 && !iname
+                 && !unpack_kern
+                 && !has_context);
+    
+      one_exn = NULL;
+    
+      nominal_modidx = idx;
 
-      exs = pt->provides;
-      exsns = pt->provide_src_names;
-      exss = pt->provide_srcs;
-      exets = pt->provide_src_phases;
-      var_count = pt->num_var_provides;
+      if (single_rn)
+        rn = single_rn;
+      else
+        rn = scheme_get_module_rename_from_set((has_context ? post_ex_rn_set : rn_set),
+                                               to_phase,
+                                               1);
 
-      for (j = pt->num_provides; j--; ) {
-        Scheme_Object *modidx;
+      if (can_save_marshal
+          && !exns
+          && !prefix
+          && !orig_ename
+          && (pt->num_provides || pt->reprovide_kernel)) {
+        /* Simple "import everything" whose mappings can be shared via the exporting module: */
+        if (!pt->src_modidx)
+          pt->src_modidx = me->src_modidx;
+        scheme_extend_module_rename_with_shared(rn, idx, pt, pt->phase_index, src_phase_index, 1);
+        skip_rename = 1;
+      } else
+        skip_rename = 0;
+
+      while (1) { /* loop to handle kernel re-provides... */
+        int break_if_iname_null = !!iname;
+
+        exs = pt->provides;
+        exsns = pt->provide_src_names;
+        exss = pt->provide_srcs;
+        exets = pt->provide_src_phases;
+        var_count = pt->num_var_provides;
+
+        for (j = pt->num_provides; j--; ) {
+          Scheme_Object *modidx;
 	
-        if (orig_ename) {
-          if (!SAME_OBJ(SCHEME_STX_VAL(orig_ename), exs[j]))
-            continue;  /* we don't want this one. */
-        } else if (onlys) {
-          name = scheme_hash_get(orig_onlys, exs[j]);
-          if (!name)
-            continue;  /* we don't want this one. */
-          mark_src = name;
-          {
-            Scheme_Object *l;
-            l = scheme_stx_extract_marks(mark_src);
-            has_context = !SCHEME_NULLP(l);
-          }
-          /* Remove to indicate that it's been imported: */
-          scheme_hash_set(onlys, exs[j], NULL);
-        } else {
-          if (exns) {
-            Scheme_Object *l, *a;
-            for (l = exns; SCHEME_STX_PAIRP(l); l = SCHEME_STX_CDR(l)) {
-              a = SCHEME_STX_CAR(l);
-              if (SCHEME_STXP(a)) 
-                a = SCHEME_STX_VAL(a);
-              if (SAME_OBJ(a, exs[j]))
-                break;
+          if (orig_ename) {
+            if (!SAME_OBJ(SCHEME_STX_VAL(orig_ename), exs[j]))
+              continue;  /* we don't want this one. */
+          } else if (onlys) {
+            name = scheme_hash_get(orig_onlys, exs[j]);
+            if (!name)
+              continue;  /* we don't want this one. */
+            mark_src = name;
+            {
+              Scheme_Object *l;
+              l = scheme_stx_extract_marks(mark_src);
+              has_context = !SCHEME_NULLP(l);
+            }
+            /* Remove to indicate that it's been imported: */
+            scheme_hash_set(onlys, exs[j], NULL);
+          } else {
+            if (exns) {
+              Scheme_Object *l, *a;
+              for (l = exns; SCHEME_STX_PAIRP(l); l = SCHEME_STX_CDR(l)) {
+                a = SCHEME_STX_CAR(l);
+                if (SCHEME_STXP(a)) 
+                  a = SCHEME_STX_VAL(a);
+                if (SAME_OBJ(a, exs[j]))
+                  break;
+              }
+              if (!SCHEME_STX_NULLP(l))
+                continue; /* we don't want this one. */
             }
-            if (!SCHEME_STX_NULLP(l))
-              continue; /* we don't want this one. */
-          }
 
-          if (one_exn) {
-            if (SAME_OBJ(one_exn, exs[j]))
-              continue; /* we don't want this one. */
+            if (one_exn) {
+              if (SAME_OBJ(one_exn, exs[j]))
+                continue; /* we don't want this one. */
+            }
           }
-        }
 	
-        modidx = ((exss && !SCHEME_FALSEP(exss[j])) 
-                  ? scheme_modidx_shift(exss[j], me->src_modidx, idx)
-                  : idx);
+          modidx = ((exss && !SCHEME_FALSEP(exss[j])) 
+                    ? scheme_modidx_shift(exss[j], me->src_modidx, idx)
+                    : idx);
       
-        if (!iname)
-          iname = exs[j];
+          if (!iname)
+            iname = exs[j];
 
-        if (SCHEME_SYM_WEIRDP(iname)) {
-          /* This shouldn't happen. In case it does, don't import a
-             gensym or parallel symbol. The former is useless. The
-             latter is supposed to be module-specific, and it could
-             collide with local module-specific ids. */
-          iname = NULL;
-          continue;
-        }
+          if (SCHEME_SYM_WEIRDP(iname)) {
+            /* This shouldn't happen. In case it does, don't import a
+               gensym or parallel symbol. The former is useless. The
+               latter is supposed to be module-specific, and it could
+               collide with local module-specific ids. */
+            iname = NULL;
+            continue;
+          }
 
-        if (prefix)
-          iname = scheme_symbol_append(prefix, iname);
+          if (prefix)
+            iname = scheme_symbol_append(prefix, iname);
 
-        prnt_iname = iname;
-        if (has_context) {
-          /* The `require' expression has a set of marks in its
-             context, which means that we need to generate a name. */
-          iname = scheme_datum_to_syntax(iname, scheme_false, mark_src, 0, 0);
-          iname = scheme_tl_id_sym(env, iname, scheme_false, 2);
-        }
+          prnt_iname = iname;
+          if (has_context) {
+            /* The `require' expression has a set of marks in its
+               context, which means that we need to generate a name. */
+            iname = scheme_datum_to_syntax(iname, scheme_false, mark_src, 0, 0);
+            iname = scheme_tl_id_sym(orig_env, iname, scheme_false, 2, to_phase);
+            if (all_simple)
+              *all_simple = 0;
+          }
 
-        if (ck)
-          ck(prnt_iname, iname, nominal_modidx, exs[j], modidx, exsns[j], (j < var_count), 
-             data, cki, form, err_src, mark_src, src_phase_index);
-	
-        if (!is_kern) {
-          if (copy_vars && (j < var_count) && !env->module && !env->phase && !k) {
-            Scheme_Env *menv;
-            Scheme_Object *val;
-            modidx = scheme_module_resolve(modidx, 1);
-            menv = scheme_module_access(modidx, env, 0);
-            val = scheme_lookup_in_table(menv->toplevel, (char *)exsns[j]);
-            scheme_add_global_symbol(iname, val, env);
-            scheme_shadow(env, iname, 1);
-          } else if (!for_unmarshal || !has_context) {
-            if (!skip_rename) {
-              if (!save_marshal_info && !has_context && can_save_marshal)
-                save_marshal_info = 1;
-              scheme_extend_module_rename((has_context ? post_ex_rn : rn), 
-                                          modidx, iname, exsns[j], nominal_modidx, exs[j], 
-                                          exets ? exets[j] : 0,
-                                          src_phase_index,
-                                          for_unmarshal || (!has_context && can_save_marshal));
+          if (ck)
+            ck(prnt_iname, iname, nominal_modidx, exs[j], modidx, exsns[j], (j < var_count), 
+               data, cki, form, err_src, mark_src, to_phase, src_phase_index, pt->phase_index);
+
+          if (!is_kern) {
+            if (copy_vars && (j < var_count) && !orig_env->module 
+                && SAME_OBJ(src_phase_index, scheme_make_integer(0))
+                && !orig_env->phase && !k) {
+              Scheme_Env *menv;
+              Scheme_Object *val;
+              modidx = scheme_module_resolve(modidx, 1);
+              menv = scheme_module_access(modidx, orig_env, 0);
+              val = scheme_lookup_in_table(menv->toplevel, (char *)exsns[j]);
+              scheme_add_global_symbol(iname, val, orig_env);
+              scheme_shadow(orig_env, iname, 1);
+            } else if (!for_unmarshal || !has_context) {
+              if (!skip_rename) {
+                if (!save_marshal_info && !has_context && can_save_marshal)
+                  save_marshal_info = 1;
+
+                scheme_extend_module_rename(rn, 
+                                            modidx, iname, exsns[j], nominal_modidx, exs[j], 
+                                            exets ? exets[j] : 0,
+                                            src_phase_index,
+                                            pt->phase_index,
+                                            for_unmarshal || (!has_context && can_save_marshal));
+              }
             }
           }
+
+          iname = NULL;
+	
+          if (ename) {
+            ename = NULL;
+            break;
+          }
         }
 
-        iname = NULL;
-	
-        if (ename) {
-          ename = NULL;
+        if (is_kern && !skip_rename)
+          scheme_extend_module_rename_with_kernel(rn, nominal_modidx);
+
+        if (break_if_iname_null && !iname)
+          break;
+
+        if (pt->reprovide_kernel) {
+          idx = kernel_modidx;
+          one_exn = pt->kernel_exclusion;
+          me = kernel->me;
+          pt = kernel->me->rt;
+          is_kern = !prefix && !unpack_kern && !ename && !has_context && !onlys;
+        } else
           break;
-        }
       }
 
-      if (is_kern && !skip_rename)
-        scheme_extend_module_rename_with_kernel(rn, nominal_modidx);
+      if (save_marshal_info) {
+        Scheme_Object *info, *a;
 
-      if (break_if_iname_null && !iname)
-        break;
+        if (exns) {
+          /* Convert to a list of symbols: */
+          info = scheme_null;
+          for (; SCHEME_STX_PAIRP(exns); exns = SCHEME_STX_CDR(exns)) {
+            a = SCHEME_STX_CAR(exns);
+            if (SCHEME_STXP(a))
+              a = SCHEME_STX_VAL(a);
+            info = cons(a, info);
+          }
+          exns = info;
+        } else
+          exns = scheme_null;
 
-      if (pt->reprovide_kernel) {
-        idx = kernel_modidx;
-        one_exn = pt->kernel_exclusion;
-        me = kernel->me;
-        pt = kernel->me->rt;
-        is_kern = !prefix && !unpack_kern && !ename && !has_context && !onlys;
-      } else
-        break;
-    }
+        /* The format of this data is checked in stxobj for unmarshaling
+           a Module_Renames. Also the idx must be first, to support shifting. */
+        info = cons(orig_idx, cons(pt->phase_index,
+                                   cons(src_phase_index,
+                                        cons(exns, prefix ? prefix : scheme_false))));
 
-    if (save_marshal_info) {
-      Scheme_Object *info, *a;
+        scheme_save_module_rename_unmarshal(rn, info);
 
-      if (exns) {
-        /* Convert to a list of symbols: */
-        info = scheme_null;
-        for (; SCHEME_STX_PAIRP(exns); exns = SCHEME_STX_CDR(exns)) {
-          a = SCHEME_STX_CAR(exns);
-          if (SCHEME_STXP(a))
-            a = SCHEME_STX_VAL(a);
-          info = cons(a, info);
-        }
-        exns = info;
-      } else
-        exns = scheme_null;
-
-      /* The format of this data is checked in stxobj for unmarshaling
-         a Module_Renames. Also the idx must be first, to support shifting. */
-      info = cons(orig_idx, cons(scheme_make_integer(k+base_k),
-                                 cons(scheme_make_integer(src_phase_index),
-                                      cons(exns, prefix ? prefix : scheme_false))));
-
-      scheme_save_module_rename_unmarshal(rn, info);
-
-      save_marshal_info = 0;
+        save_marshal_info = 0;
+      }
     }
   }
 
@@ -7641,25 +7718,26 @@ void scheme_do_module_rename_unmarshal(Scheme_Object *rn, Scheme_Object *info,
 				       Scheme_Object *modidx_shift_from, Scheme_Object *modidx_shift_to,
 				       Scheme_Hash_Table *export_registry)
 {
-  Scheme_Object *orig_idx, *exns, *prefix, *idx, *name, *kv, *spi;
+  Scheme_Object *orig_idx, *exns, *prefix, *idx, *name, *pt_phase, *src_phase_index;
   Scheme_Module_Exports *me;
   Scheme_Env *env;
-  int share_all, src_phase_index;
+  int share_all;
 
   idx = SCHEME_CAR(info);
   orig_idx = idx;
   info = SCHEME_CDR(info);
-  kv = SCHEME_CAR(info);
+  pt_phase = SCHEME_CAR(info);
   info = SCHEME_CDR(info);
-  if (SCHEME_INTP(info)) {
+  if (SCHEME_INTP(info)
+      || SCHEME_FALSEP(info)) {
     share_all = 1;
-    spi = info;
+    src_phase_index = info;
     
     exns = NULL;
     prefix = NULL;
   } else {
     share_all = 0;
-    spi = SCHEME_CAR(info);
+    src_phase_index = SCHEME_CAR(info);
     info = SCHEME_CDR(info);
     exns = SCHEME_CAR(info);
     prefix = SCHEME_CDR(info);
@@ -7695,39 +7773,31 @@ void scheme_do_module_rename_unmarshal(Scheme_Object *rn, Scheme_Object *info,
     }
   }
 
-  src_phase_index = SCHEME_INT_VAL(spi);
-
   if (share_all) {
     Scheme_Module_Phase_Exports *pt;
-    int k = SCHEME_INT_VAL(kv);
 
-    switch(k) {
-    case 0:
+    if (SAME_OBJ(pt_phase, scheme_make_integer(0)))
       pt = me->rt;
-      break;
-    case 1:
+    else if (SAME_OBJ(pt_phase, scheme_make_integer(1)))
       pt = me->et;
-      break;
-    case 2:
-    default:
+    else if (SAME_OBJ(pt_phase, scheme_false))
       pt = me->dt;
-      break;
+    else
+      pt = (Scheme_Module_Phase_Exports *)scheme_hash_get(me->other_phases, pt_phase);
+    
+    if (pt) {
+      if (!pt->src_modidx)
+        pt->src_modidx = me->src_modidx;
+      scheme_extend_module_rename_with_shared(rn, orig_idx, pt, pt->phase_index, src_phase_index, 0);
     }
-
-    if (!pt->src_modidx)
-      pt->src_modidx = me->src_modidx;
-    scheme_extend_module_rename_with_shared(rn, orig_idx, pt, k, src_phase_index, 0);
   } else {
-    add_single_require(me, SCHEME_INT_VAL(kv), src_phase_index, orig_idx, NULL,
-                       rn, NULL, 
-                       NULL, NULL,
-                       NULL, NULL,
+    add_single_require(me, pt_phase, src_phase_index, orig_idx, NULL,
+                       NULL, NULL, rn,
                        exns, NULL, prefix, NULL, NULL,
                        NULL,
                        0, 0, 1, 0,
-                       NULL,
-                       NULL, 
-                       NULL, NULL, NULL, 
+                       NULL/* _all_simple */,
+                       NULL /* ck */, NULL /* data */, 
                        NULL, NULL, NULL);
   }
 }
@@ -7741,22 +7811,19 @@ void parse_requires(Scheme_Object *form,
                     Scheme_Object *base_modidx,
                     Scheme_Env *main_env,
                     Scheme_Module *for_m,
-                    Scheme_Object *rn, Scheme_Object *post_ex_rn,
-                    Scheme_Object *et_rn, Scheme_Object *post_ex_et_rn,
-                    Scheme_Object *tt_rn, Scheme_Object *post_ex_tt_rn,
-                    Scheme_Object *dt_rn, Scheme_Object *post_ex_dt_rn,
-                    Check_Func ck, void *data, void *et_data, void *tt_data, void *dt_data,
+                    Scheme_Object *rn_set, Scheme_Object *post_ex_rn_set,
+                    Check_Func ck, void *data,
                     Scheme_Object *redef_modname,
                     int unpack_kern, int copy_vars, int can_save_marshal, int always_run,
-                    int *all_simple, int *et_all_simple, int *tt_all_simple, int *dt_all_simple) 
+                    int *all_simple) 
 {
-  Scheme_Object *ll = form, *mode = NULL;
+  Scheme_Object *ll = form, *mode = scheme_make_integer(0), *just_mode = NULL;
   Scheme_Module *m;
   Scheme_Object *idxstx, *idx, *name, *i, *exns, *prefix, *iname, *ename, *aa, *aav;
   Scheme_Object *mark_src, *err_src;
   Scheme_Hash_Table *onlys;
   Scheme_Env *env;
-  int skip_one, *_all_simple, mode_cnt = 0, phase_index;
+  int skip_one, mode_cnt = 0, just_mode_cnt = 0;
 
   if (scheme_stx_proper_list_length(form) < 0)
     scheme_wrong_syntax(NULL, NULL, form, "bad syntax (" IMPROPER_LIST_FORM ")");
@@ -7777,44 +7844,73 @@ void parse_requires(Scheme_Object *form,
     mark_src = i;
     skip_one = 0;
 
-    if (!mode) {
-      _all_simple = all_simple;
-    } else if (SAME_OBJ(mode, for_syntax_symbol)) {
-      _all_simple = et_all_simple;
-    } else if (SAME_OBJ(mode, for_template_symbol)) {
-      _all_simple = tt_all_simple;
-    } else if (SAME_OBJ(mode, for_label_symbol)) {
-      _all_simple = dt_all_simple;
-    } else {
-      scheme_signal_error("internal mode errror");
-      return;
-    }
-
     if (SAME_OBJ(for_syntax_symbol, aav)
         || SAME_OBJ(for_template_symbol, aav)
-        || SAME_OBJ(for_label_symbol, aav)) {
-      if (mode_cnt)
-        scheme_wrong_syntax(NULL, i, form, 
-                            (SAME_OBJ(for_syntax_symbol, aav)
-                             ? "bad syntax (nested `for-syntax')"
-                             : (SAME_OBJ(for_template_symbol, aav)
-                                ? "bad syntax (nested `for-template')"
-                                : "bad syntax (nested `for-label')")));
-
+        || SAME_OBJ(for_label_symbol, aav)
+        || SAME_OBJ(for_meta_symbol, aav)
+        || SAME_OBJ(just_meta_symbol, aav)) {
+      if (!SAME_OBJ(just_meta_symbol, aav)) {
+        if (mode_cnt)
+          scheme_wrong_syntax(NULL, i, form, 
+                              (SAME_OBJ(for_syntax_symbol, aav)
+                               ? "bad syntax (nested `for-syntax')"
+                               : (SAME_OBJ(for_template_symbol, aav)
+                                  ? "bad syntax (nested `for-template')"
+                                  : (SAME_OBJ(for_label_symbol, aav)
+                                     ? "bad syntax (nested `for-label')"
+                                     : "bad syntax (nested `for-meta')"))));
+      } else {
+        if (just_mode_cnt)
+          scheme_wrong_syntax(NULL, i, form, "bad syntax (nested `just-meta')");
+      }
+      
       aa = scheme_flatten_syntax_list(i, NULL);
       ll = SCHEME_STX_CDR(ll);
+      if (SAME_OBJ(for_meta_symbol, aav)
+          || SAME_OBJ(just_meta_symbol, aav)) {
+        Scheme_Object *a_mode;
+        aa = SCHEME_STX_CDR(aa);
+        if (SCHEME_STX_NULLP(aa))
+          scheme_wrong_syntax(NULL, i, form, "missing `%s-meta' level specification",
+                              (SAME_OBJ(for_meta_symbol, aav) ? "for" : "just"));
+        a_mode = SCHEME_STX_CAR(aa);
+        a_mode = SCHEME_STX_VAL(a_mode);
+        if (!SCHEME_FALSEP(a_mode)
+            && !SCHEME_INTP(a_mode)
+            && !SCHEME_BIGNUMP(a_mode))
+          scheme_wrong_syntax(NULL, i, form, "bad `%s-meta' level specification",
+                              (SAME_OBJ(for_meta_symbol, aav) ? "for" : "just"));
+        if (SAME_OBJ(for_meta_symbol, aav)) 
+          mode = a_mode;
+        else
+          just_mode = a_mode;
+      } else {
+        if (SAME_OBJ(for_syntax_symbol, aav))
+          mode = scheme_make_integer(1);
+        else if (SAME_OBJ(for_template_symbol, aav))
+          mode = scheme_make_integer(-1);
+        else
+          mode = scheme_false;
+      }
       ll = scheme_append(aa, ll);
-
-      mode_cnt = scheme_list_length(aa);
-      mode = aav;
+      
+      if (!SAME_OBJ(just_meta_symbol, aav)) {
+        mode_cnt = scheme_list_length(aa);
+        if (just_mode_cnt)
+          just_mode_cnt += (mode_cnt - 1);
+      } else {
+        just_mode_cnt = scheme_list_length(aa);
+        if (mode_cnt)
+          mode_cnt += (just_mode_cnt - 1);
+      }
 
       skip_one = 1;
     } else if (aa && SAME_OBJ(prefix_symbol, SCHEME_STX_VAL(aa))) {
       /* prefix */
       int len;
 
-      if (_all_simple)
-	*_all_simple = 0;
+      if (all_simple)
+	*all_simple = 0;
 
       len = scheme_stx_proper_list_length(i);
       if (len != 3) {
@@ -7852,8 +7948,8 @@ void parse_requires(Scheme_Object *form,
       int len;
       int has_prefix;
 
-      if (_all_simple)
-	*_all_simple = 0;
+      if (all_simple)
+	*all_simple = 0;
 
       has_prefix = SAME_OBJ(prefix_all_except_symbol, SCHEME_STX_VAL(aa));
 
@@ -7894,8 +7990,8 @@ void parse_requires(Scheme_Object *form,
       int len;
       Scheme_Object *rest, *nm;
 
-      if (_all_simple)
-	*_all_simple = 0;
+      if (all_simple)
+	*all_simple = 0;
 
       len = scheme_stx_proper_list_length(i);
       if (len < 2) {
@@ -7931,8 +8027,8 @@ void parse_requires(Scheme_Object *form,
       int len;
       Scheme_Object *rest;
 
-      if (_all_simple)
-	*_all_simple = 0;
+      if (all_simple)
+	*all_simple = 0;
 
       len = scheme_stx_proper_list_length(i);
       if (len != 4) {
@@ -7978,12 +8074,32 @@ void parse_requires(Scheme_Object *form,
 
     if (!skip_one) {
       int start, expstart;
-      Scheme_Object *_rn, *_post_ex_rn;
-      Scheme_Object *_et_rn, *_post_ex_et_rn;
-      Scheme_Object *_dt_rn, *_post_ex_dt_rn;
-      void *_data, *_et_data, *_dt_data;
-        
-      if (!mode) {
+
+      if (SCHEME_FALSEP(mode)) {
+        start = 0;
+        expstart = 0;
+        env = main_env;
+      } else if (scheme_is_positive(mode)) {
+        Scheme_Object *n = mode;
+        start = 1;
+        expstart = 0;
+        env = main_env;
+        do {
+          scheme_prepare_exp_env(env);
+          env = env->exp_env;
+          n = scheme_bin_minus(n, scheme_make_integer(1));
+        } while (scheme_is_positive(n));
+      } else if (scheme_is_negative(mode)) {
+        Scheme_Object *n = mode;
+        start = 0;
+        expstart = 0;
+        env = main_env;
+        do {
+          scheme_prepare_template_env(env);
+          env = env->template_env;
+          n = scheme_bin_plus(n, scheme_make_integer(1));
+        } while (scheme_is_negative(n));
+      } else {
         if (always_run) {
           start = 1;
           expstart = 0;
@@ -7991,52 +8107,9 @@ void parse_requires(Scheme_Object *form,
           start = 0;
           expstart = 1;
         }
-        _rn = rn; _post_ex_rn = post_ex_rn;
-        _et_rn = et_rn; _post_ex_et_rn = post_ex_et_rn;
-        _dt_rn = dt_rn; _post_ex_dt_rn = post_ex_dt_rn;
-        _data = data;
-        _et_data = et_data;
-        _dt_data = dt_data;
         env = main_env;
-        phase_index = 0;
-      } else if (SAME_OBJ(mode, for_syntax_symbol)) {
-        start = 1;
-        expstart = 0;
-        _rn = et_rn; _post_ex_rn = post_ex_et_rn;
-        _et_rn = NULL; _post_ex_et_rn = NULL;
-        _dt_rn = NULL; _post_ex_dt_rn = NULL;
-        _data = et_data;
-        _et_data = NULL;
-        _dt_data = NULL;
-        env = main_env->exp_env;
-        phase_index = 1;
-      } else if (SAME_OBJ(mode, for_template_symbol)) {
-        start = 0;
-        expstart = 0;
-        _rn = tt_rn; _post_ex_rn = post_ex_tt_rn;
-        _et_rn = NULL; _post_ex_et_rn = NULL;
-        _dt_rn = NULL; _post_ex_dt_rn = NULL;
-        _data = tt_data;
-        _et_data = NULL;
-        _dt_data = NULL;
-        env = main_env->template_env;
-        phase_index = 3;
-      } else if (SAME_OBJ(mode, for_label_symbol)) {
-        start = 0;
-        expstart = 0;
-        _rn = dt_rn; _post_ex_rn = post_ex_dt_rn;
-        _et_rn = NULL; _post_ex_et_rn = NULL;
-        _dt_rn = NULL; _post_ex_dt_rn = NULL;
-        _data = dt_data;
-        _et_data = NULL;
-        _dt_data = NULL;
-        env = main_env->label_env;
-        phase_index = 2;
-      } else {
-        scheme_signal_error("internal mode errror");
-        return;
       }
-
+      
       idx = scheme_make_modidx(scheme_syntax_to_datum(idxstx, 0, NULL), 
                                base_modidx,
                                scheme_false);
@@ -8054,31 +8127,40 @@ void parse_requires(Scheme_Object *form,
       /* Add name to require list, if it's not there: */
       if (env->module) {
         Scheme_Object *reqs;
-        if (!mode) {
+        if (SAME_OBJ(mode, scheme_make_integer(0))) {
           reqs = add_req(scheme_make_pair(idx, scheme_null), env->module->requires);
           env->module->requires = reqs;
-        } else if (SAME_OBJ(mode, for_syntax_symbol)) {
+        } else if (SAME_OBJ(mode, scheme_make_integer(1))) {
           reqs = add_req(scheme_make_pair(idx, scheme_null), env->module->et_requires);
           env->module->et_requires = reqs;
-        } else if (SAME_OBJ(mode, for_template_symbol)) {
+        } else if (SAME_OBJ(mode, scheme_make_integer(-1))) {
           reqs = add_req(scheme_make_pair(idx, scheme_null), env->module->tt_requires);
           env->module->tt_requires = reqs;
-        } else if (SAME_OBJ(mode, for_label_symbol)) {
+        } else if (SAME_OBJ(mode, scheme_false)) {
           reqs = add_req(scheme_make_pair(idx, scheme_null), env->module->dt_requires);
           env->module->dt_requires = reqs;
+        } else {
+          Scheme_Hash_Table *oht;
+          oht = env->module->other_requires;
+          if (!oht) {
+            oht = scheme_make_hash_table_equal();
+            env->module->other_requires = oht;
+          }
+          reqs = scheme_hash_get(oht, mode);
+          if (!reqs)
+            reqs = scheme_null;
+          reqs = add_req(scheme_make_pair(idx, scheme_null), reqs);
+          scheme_hash_set(oht, mode, reqs);
         }
       }
-
-      add_single_require(m->me, 0, phase_index, idx, env, 
-                         _rn, _post_ex_rn,
-                         _et_rn, _post_ex_et_rn,
-                         _dt_rn, _post_ex_dt_rn,
+      
+      add_single_require(m->me, just_mode, mode, idx, env, 
+                         rn_set, post_ex_rn_set, NULL,
                          exns, onlys, prefix, iname, ename,
                          mark_src, 
                          unpack_kern, copy_vars && start, 0, can_save_marshal,
-                         _all_simple,
-                         ck, 
-                         _data, _et_data, _dt_data, 
+                         all_simple,
+                         ck, data,
                          form, err_src, i);
 
       if (onlys && onlys->count) {
@@ -8094,7 +8176,12 @@ void parse_requires(Scheme_Object *form,
     if (mode_cnt) {
       --mode_cnt;
       if (!mode_cnt)
-        mode = NULL;
+        mode = scheme_make_integer(0);
+    }
+    if (just_mode_cnt) {
+      --just_mode_cnt;
+      if (!just_mode_cnt)
+        just_mode = NULL;
     }
   }
 }
@@ -8103,12 +8190,22 @@ static void check_dup_require(Scheme_Object *prnt_name, Scheme_Object *name,
                               Scheme_Object *nominal_modidx, Scheme_Object *nominal_name, 
 			      Scheme_Object *modidx, Scheme_Object *srcname, 
 			      int isval, void *ht, Scheme_Object *e, Scheme_Object *form, 
-                              Scheme_Object *err_src, Scheme_Object *mark_src, int src_phase_index)
+                              Scheme_Object *err_src, Scheme_Object *mark_src, 
+                              Scheme_Object *to_phase, Scheme_Object *src_phase_index,
+                              Scheme_Object *nominal_export_phase)
 {
   Scheme_Object *i;
 
   if (ht) {
-    i = scheme_hash_get((Scheme_Hash_Table *)ht, name);
+    Scheme_Hash_Table *pht;
+
+    pht = (Scheme_Hash_Table *)scheme_hash_get((Scheme_Hash_Table *)ht, to_phase);
+    if (!pht) {
+      pht = scheme_make_hash_table(SCHEME_hash_ptr);
+      scheme_hash_set((Scheme_Hash_Table *)ht, name, (Scheme_Object *)pht);
+    }
+
+    i = scheme_hash_get(pht, name);
 
     if (i) {
       if (same_resolved_modidx(modidx, SCHEME_CAR(i)) && SAME_OBJ(srcname, SCHEME_CDR(i)))
@@ -8122,9 +8219,9 @@ static void check_dup_require(Scheme_Object *prnt_name, Scheme_Object *name,
 static Scheme_Object *
 top_level_require_execute(Scheme_Object *data)
 {
-  Scheme_Hash_Table *ht, *et_ht, *tt_ht, *dt_ht;
-  Scheme_Object *rn, *et_rn, *tt_rn, *dt_rn, *modidx;
-  Scheme_Object *form = SCHEME_CDR(data), *rest, *brn;
+  Scheme_Hash_Table *ht;
+  Scheme_Object *rn_set, *modidx;
+  Scheme_Object *form = SCHEME_CDR(data), *rest;
   Scheme_Env *env;
 
   env = scheme_environment_from_dummy(SCHEME_CAR(data));
@@ -8148,60 +8245,22 @@ top_level_require_execute(Scheme_Object *data)
   scheme_prepare_exp_env(env);
   scheme_prepare_template_env(env);
 
-  rn = scheme_make_module_rename(0, mzMOD_RENAME_TOPLEVEL, NULL);
-  et_rn = scheme_make_module_rename(1, mzMOD_RENAME_TOPLEVEL, NULL);
-  tt_rn = scheme_make_module_rename(-1, mzMOD_RENAME_TOPLEVEL, NULL);
-  dt_rn = scheme_make_module_rename(MZ_LABEL_PHASE, mzMOD_RENAME_TOPLEVEL, NULL);
+  rn_set = scheme_make_module_rename_set(mzMOD_RENAME_TOPLEVEL, NULL);
 
   if (rest) {
-    ht = scheme_make_hash_table(SCHEME_hash_ptr);
-    et_ht = scheme_make_hash_table(SCHEME_hash_ptr);
-    tt_ht = scheme_make_hash_table(SCHEME_hash_ptr);
-    dt_ht = scheme_make_hash_table(SCHEME_hash_ptr);
+    ht = scheme_make_hash_table_equal();
   } else {
     ht = NULL;
-    et_ht = NULL;
-    tt_ht = NULL;
-    dt_ht = NULL;
   }
 
   parse_requires(form, modidx, env, NULL,
-                 rn, rn,
-                 et_rn, et_rn,
-                 tt_rn, tt_rn,
-                 dt_rn, dt_rn,
-                 check_dup_require, ht, et_ht, tt_ht, dt_ht, 
+                 rn_set, rn_set,
+                 check_dup_require, ht,
                  NULL,
                  !env->module, 0, 0, 1,
-                 NULL, NULL, NULL, NULL);
+                 NULL);
 
-  brn = env->rename;
-  if (!brn) {
-    brn = scheme_make_module_rename(0, mzMOD_RENAME_TOPLEVEL, NULL);
-    env->rename = brn;
-  }
-  scheme_append_module_rename(rn, brn, 0);
-  
-  brn = env->exp_env->rename;
-  if (!brn) {
-    brn = scheme_make_module_rename(1, mzMOD_RENAME_TOPLEVEL, NULL);
-    env->exp_env->rename = brn;
-  }
-  scheme_append_module_rename(et_rn, brn, 0);
-
-  brn = env->template_env->rename;
-  if (!brn) {
-    brn = scheme_make_module_rename(-1, mzMOD_RENAME_TOPLEVEL, NULL);
-    env->template_env->rename = brn;
-  }
-  scheme_append_module_rename(tt_rn, brn, 0);
-
-  brn = env->dt_rename;
-  if (!brn) {
-    brn = scheme_make_module_rename(MZ_LABEL_PHASE, mzMOD_RENAME_TOPLEVEL, NULL);
-    env->dt_rename = brn;
-  }
-  scheme_append_module_rename(dt_rn, brn, 0);
+  scheme_append_rename_set_to_env(rn_set, env);
 
   return scheme_void;
 }
@@ -8245,8 +8304,8 @@ top_level_require_sfs(Scheme_Object *data, SFS_Info *rslv)
 static Scheme_Object *do_require(Scheme_Object *form, Scheme_Comp_Env *env, 
 				 Scheme_Compile_Expand_Info *rec, int drec)
 {
-  Scheme_Hash_Table *ht, *et_ht, *tt_ht, *dt_ht;
-  Scheme_Object *rn, *et_rn, *tt_rn, *dt_rn, *dummy, *modidx;
+  Scheme_Hash_Table *ht;
+  Scheme_Object *rn_set, *dummy, *modidx;
   Scheme_Env *genv;
 
   if (!scheme_is_toplevel(env))
@@ -8255,15 +8314,9 @@ static Scheme_Object *do_require(Scheme_Object *form, Scheme_Comp_Env *env,
   /* If we get here, it must be a top-level require. */
 
   /* Hash table is for checking duplicate names in require list: */
-  ht = scheme_make_hash_table(SCHEME_hash_ptr);
-  et_ht = scheme_make_hash_table(SCHEME_hash_ptr);
-  tt_ht = scheme_make_hash_table(SCHEME_hash_ptr);
-  dt_ht = scheme_make_hash_table(SCHEME_hash_ptr);
+  ht = scheme_make_hash_table_equal();
 
-  rn = scheme_make_module_rename(0, mzMOD_RENAME_TOPLEVEL, NULL);
-  et_rn = scheme_make_module_rename(1, mzMOD_RENAME_TOPLEVEL, NULL);
-  tt_rn = scheme_make_module_rename(-1, mzMOD_RENAME_TOPLEVEL, NULL);
-  dt_rn = scheme_make_module_rename(MZ_LABEL_PHASE, mzMOD_RENAME_TOPLEVEL, NULL);
+  rn_set = scheme_make_module_rename_set(mzMOD_RENAME_TOPLEVEL, NULL);
 
   genv = env->genv;
   scheme_prepare_exp_env(genv);
@@ -8275,15 +8328,12 @@ static Scheme_Object *do_require(Scheme_Object *form, Scheme_Comp_Env *env,
     modidx = scheme_false;
 
   parse_requires(form, modidx, genv, NULL,
-                 rn, rn,
-                 et_rn, et_rn,
-                 tt_rn, tt_rn,
-                 dt_rn, dt_rn,
-                 check_dup_require, ht, et_ht, tt_ht, dt_ht,
+                 rn_set, rn_set,
+                 check_dup_require, ht,
                  NULL, 
                  0, 0, 0, 0,
-                 NULL, NULL, NULL, NULL);
-  
+                 NULL);
+
   if (rec[drec].comp) {
     /* Dummy lets us access a top-level environment: */
     dummy = scheme_make_environment_dummy(env);
@@ -8343,9 +8393,23 @@ static Scheme_Object *write_module(Scheme_Object *obj)
   Scheme_Module *m = (Scheme_Module *)obj;
   Scheme_Module_Phase_Exports *pt;
   Scheme_Object *l, *v;
-  int i, k, count;
+  int i, k, count, cnt;
 
-  l = m->dt_requires;
+  l = scheme_null;
+  cnt = 0;
+  if (m->other_requires) {
+    for (i = 0; i < m->other_requires->size; i++) {
+      if (m->other_requires->vals[i]) {
+        cnt++;
+        l = scheme_make_pair(scheme_make_pair(m->other_requires->keys[i],
+                                              m->other_requires->vals[i]),
+                             l);
+      }
+    }
+  }
+  l = cons(scheme_make_integer(cnt), l);
+
+  l = cons(m->dt_requires, l);
   l = cons(m->tt_requires, l);
   l = cons(m->et_requires, l);
   l = cons(m->requires, l);
@@ -8353,63 +8417,72 @@ static Scheme_Object *write_module(Scheme_Object *obj)
   l = cons(m->body, l);
   l = cons(m->et_body, l);
 
-  for (k = 0; k < 3; k++) {
+  cnt = 0;
+  for (k = -3; k < (m->me->other_phases ? m->me->other_phases->size : 0); k++) {
     switch (k) {
-    case 2:
+    case -3:
       pt = m->me->dt;
       break;
-    case 1:
+    case -2:
       pt = m->me->et;
       break;
-    case 0:
-    default:
+    case -1:
       pt = m->me->rt;
       break;
+    default:
+      pt = (Scheme_Module_Phase_Exports *)m->me->other_phases->vals[k];
     }
     
-    l = cons(scheme_make_integer(pt->num_provides), l);
-    l = cons(scheme_make_integer(pt->num_var_provides), l);
+    if (pt) {
+      l = cons(scheme_make_integer(pt->num_provides), l);
+      l = cons(scheme_make_integer(pt->num_var_provides), l);
 
-    count = pt->num_provides;
+      count = pt->num_provides;
 
-    v = scheme_make_vector(count, NULL);
-    for (i = 0; i < count; i++) {
-      SCHEME_VEC_ELS(v)[i] = pt->provides[i];
-    }
-    l = cons(v, l);
-  
-    v = scheme_make_vector(count, NULL);
-    for (i = 0; i < count; i++) {
-      SCHEME_VEC_ELS(v)[i] = pt->provide_srcs[i];
-    }
-    l = cons(v, l);
-    
-    v = scheme_make_vector(count, NULL);
-    for (i = 0; i < count; i++) {
-      SCHEME_VEC_ELS(v)[i] = pt->provide_src_names[i];
-    }
-    l = cons(v, l);
-
-    if (pt->provide_nominal_srcs) {
       v = scheme_make_vector(count, NULL);
       for (i = 0; i < count; i++) {
-        SCHEME_VEC_ELS(v)[i] = pt->provide_nominal_srcs[i];
+        SCHEME_VEC_ELS(v)[i] = pt->provides[i];
       }
       l = cons(v, l);
-    } else {
-      l = cons(scheme_false, l);
-    }
-
-    if (pt->provide_src_phases) {
+  
       v = scheme_make_vector(count, NULL);
       for (i = 0; i < count; i++) {
-        SCHEME_VEC_ELS(v)[i] = (pt->provide_src_phases[i] ? scheme_true : scheme_false);
-      } 
-    } else
-      v = scheme_false;
-    l = cons(v, l);
+        SCHEME_VEC_ELS(v)[i] = pt->provide_srcs[i];
+      }
+      l = cons(v, l);
+    
+      v = scheme_make_vector(count, NULL);
+      for (i = 0; i < count; i++) {
+        SCHEME_VEC_ELS(v)[i] = pt->provide_src_names[i];
+      }
+      l = cons(v, l);
+
+      if (pt->provide_nominal_srcs) {
+        v = scheme_make_vector(count, NULL);
+        for (i = 0; i < count; i++) {
+          SCHEME_VEC_ELS(v)[i] = pt->provide_nominal_srcs[i];
+        }
+        l = cons(v, l);
+      } else {
+        l = cons(scheme_false, l);
+      }
+
+      if (pt->provide_src_phases) {
+        v = scheme_make_vector(count, NULL);
+        for (i = 0; i < count; i++) {
+          SCHEME_VEC_ELS(v)[i] = (pt->provide_src_phases[i] ? scheme_true : scheme_false);
+        } 
+      } else
+        v = scheme_false;
+      l = cons(v, l);
+
+      l = cons(pt->phase_index, l);
+      cnt++;
+    }
   }
 
+  l = cons(scheme_make_integer(cnt), l);
+
   count = m->me->rt->num_provides;
 
   if (m->provide_protects) {
@@ -8446,9 +8519,6 @@ static Scheme_Object *write_module(Scheme_Object *obj)
 
   l = cons(scheme_make_integer(m->max_let_depth), l);
 
-  l = cons(wrap_mod_stx(m->dt_rn_stx), l);
-  l = cons(wrap_mod_stx(m->tt_rn_stx), l);
-  l = cons(wrap_mod_stx(m->et_rn_stx), l);
   l = cons(wrap_mod_stx(m->rn_stx), l);
 
   l = cons(m->et_functional ? scheme_true : scheme_false, l);
@@ -8486,7 +8556,7 @@ static Scheme_Object *read_module(Scheme_Object *obj)
   Scheme_Module_Exports *me;
   Scheme_Module_Phase_Exports *pt;
   char *ps, *sps;
-  int i, k, count;
+  int i, count, cnt;
 
   m = MALLOC_ONE_TAGGED(Scheme_Module);
   m->so.type = scheme_module_type;
@@ -8519,24 +8589,6 @@ static Scheme_Object *read_module(Scheme_Object *obj)
   if (SCHEME_FALSEP(m->rn_stx))
     m->rn_stx = NULL;
 
-  if (!SCHEME_PAIRP(obj)) return_NULL();
-  m->et_rn_stx = SCHEME_CAR(obj);
-  obj = SCHEME_CDR(obj);
-  if (SCHEME_FALSEP(m->et_rn_stx))
-    m->et_rn_stx = NULL;
-
-  if (!SCHEME_PAIRP(obj)) return_NULL();
-  m->tt_rn_stx = SCHEME_CAR(obj);
-  obj = SCHEME_CDR(obj);
-  if (SCHEME_FALSEP(m->tt_rn_stx))
-    m->tt_rn_stx = NULL;
-
-  if (!SCHEME_PAIRP(obj)) return_NULL();
-  m->dt_rn_stx = SCHEME_CAR(obj);
-  obj = SCHEME_CDR(obj);
-  if (SCHEME_FALSEP(m->dt_rn_stx))
-    m->dt_rn_stx = NULL;
-
   if (!SCHEME_PAIRP(obj)) return_NULL();
   m->max_let_depth = SCHEME_INT_VAL(SCHEME_CAR(obj));
   obj = SCHEME_CDR(obj);
@@ -8578,18 +8630,38 @@ static Scheme_Object *read_module(Scheme_Object *obj)
   esp = SCHEME_CAR(obj);
   obj = SCHEME_CDR(obj);
 
-  for (k = 0; k < 3; k++) {
-    switch (k) {
-    case 0:
-      pt = me->dt;
-      break;
-    case 1:
-      pt = me->et;
-      break;
-    case 2:
-    default:
+  if (!SCHEME_PAIRP(obj)) return_NULL();
+  cnt = SCHEME_INT_VAL(SCHEME_CAR(obj));
+  obj = SCHEME_CDR(obj);
+  
+  while (cnt--) {
+    Scheme_Object *phase;
+
+    if (!SCHEME_PAIRP(obj)) return_NULL();
+    phase = SCHEME_CAR(obj);
+    obj = SCHEME_CDR(obj);
+
+    if (!SCHEME_FALSEP(phase)
+        && !SCHEME_INTP(phase)
+        && !SCHEME_BIGNUMP(phase))
+      return_NULL();
+
+    if (SAME_OBJ(phase, scheme_make_integer(0))) {
       pt = me->rt;
-      break;
+    } else if (SAME_OBJ(phase, scheme_make_integer(1))) {
+      pt = me->et;
+    } else if (SAME_OBJ(phase, scheme_false)) {
+      pt = me->dt;
+    } else {
+      pt = MALLOC_ONE_RT(Scheme_Module_Phase_Exports);
+      pt->so.type = scheme_module_phase_exports_type;
+      pt->phase_index = phase;
+      if (!me->other_phases) {
+        Scheme_Hash_Table *ht;
+        ht = scheme_make_hash_table_equal();
+        me->other_phases = ht;
+      }
+      scheme_hash_set(me->other_phases, phase, (Scheme_Object *)pt);      
     }
 
     if (!SCHEME_PAIRP(obj)) return_NULL();
@@ -8668,6 +8740,8 @@ static Scheme_Object *read_module(Scheme_Object *obj)
     pt->provide_src_phases = sps;
   }
 
+  count = me->rt->num_provides;
+
   if (SCHEME_FALSEP(esp)) {
     m->provide_protects = NULL;
   } else {
@@ -8712,10 +8786,45 @@ static Scheme_Object *read_module(Scheme_Object *obj)
   if (!check_requires_ok(e)) return_NULL();
   obj = SCHEME_CDR(obj);
 
-  if (scheme_proper_list_length(obj) < 0) return_NULL();
-  e = scheme_copy_list(obj);
+  if (!SCHEME_PAIRP(obj)) return_NULL();
+  if (scheme_proper_list_length(SCHEME_CAR(obj)) < 0) return_NULL();
+  e = scheme_copy_list(SCHEME_CAR(obj));
   m->dt_requires = e;
   if (!check_requires_ok(e)) return_NULL();
+  obj = SCHEME_CDR(obj);
 
+  if (!SCHEME_PAIRP(obj)) return_NULL();
+  cnt = SCHEME_INT_VAL(SCHEME_CAR(obj));
+  obj = SCHEME_CDR(obj);
+  while (cnt--) {
+    Scheme_Object *phase;
+
+    if (!SCHEME_PAIRP(obj)) return_NULL();
+    phase = SCHEME_CAR(obj);
+    obj = SCHEME_CDR(obj);
+
+    if (!SCHEME_INTP(phase)
+        && !SCHEME_BIGNUMP(phase))
+      return_NULL();
+
+    if (SAME_OBJ(phase, scheme_make_integer(0))
+        || SAME_OBJ(phase, scheme_make_integer(1))
+        || SAME_OBJ(phase, scheme_make_integer(-1)))
+      return_NULL();
+
+    if (!SCHEME_PAIRP(obj)) return_NULL();
+    e = scheme_copy_list(SCHEME_CAR(obj));
+    if (!check_requires_ok(e)) return_NULL();
+
+    if (!m->other_requires) {
+      Scheme_Hash_Table *ht;
+      ht = scheme_make_hash_table_equal();
+      m->other_requires = ht;
+    }
+    scheme_hash_set(m->other_requires, phase, e);
+    
+    obj = SCHEME_CDR(obj);
+  }
+  
   return (Scheme_Object *)m;
 }
diff --git a/src/mzscheme/src/mzmark.c b/src/mzscheme/src/mzmark.c
index 192b872eb3..81c769279e 100644
--- a/src/mzscheme/src/mzmark.c
+++ b/src/mzscheme/src/mzmark.c
@@ -2054,15 +2054,11 @@ static int namespace_val_MARK(void *p) {
   gcMARK(e->export_registry);
   gcMARK(e->insp);
 
-  gcMARK(e->rename);
-  gcMARK(e->et_rename);
-  gcMARK(e->tt_rename);
-  gcMARK(e->dt_rename);
+  gcMARK(e->rename_set);
 
   gcMARK(e->syntax);
   gcMARK(e->exp_env);
   gcMARK(e->template_env);
-  gcMARK(e->label_env);
 
   gcMARK(e->shadowed_syntax);
 
@@ -2071,13 +2067,13 @@ static int namespace_val_MARK(void *p) {
   gcMARK(e->et_require_names);
   gcMARK(e->tt_require_names);
   gcMARK(e->dt_require_names);
+  gcMARK(e->other_require_names);
 
   gcMARK(e->toplevel);
   gcMARK(e->modchain);
 
   gcMARK(e->modvars);
 
-  gcMARK(e->marked_names);
 
   return
   gcBYTES_TO_WORDS(sizeof(Scheme_Env));
@@ -2091,15 +2087,11 @@ static int namespace_val_FIXUP(void *p) {
   gcFIXUP(e->export_registry);
   gcFIXUP(e->insp);
 
-  gcFIXUP(e->rename);
-  gcFIXUP(e->et_rename);
-  gcFIXUP(e->tt_rename);
-  gcFIXUP(e->dt_rename);
+  gcFIXUP(e->rename_set);
 
   gcFIXUP(e->syntax);
   gcFIXUP(e->exp_env);
   gcFIXUP(e->template_env);
-  gcFIXUP(e->label_env);
 
   gcFIXUP(e->shadowed_syntax);
 
@@ -2108,13 +2100,13 @@ static int namespace_val_FIXUP(void *p) {
   gcFIXUP(e->et_require_names);
   gcFIXUP(e->tt_require_names);
   gcFIXUP(e->dt_require_names);
+  gcFIXUP(e->other_require_names);
 
   gcFIXUP(e->toplevel);
   gcFIXUP(e->modchain);
 
   gcFIXUP(e->modvars);
 
-  gcFIXUP(e->marked_names);
 
   return
   gcBYTES_TO_WORDS(sizeof(Scheme_Env));
@@ -2324,6 +2316,7 @@ static int module_val_MARK(void *p) {
   gcMARK(m->requires);
   gcMARK(m->tt_requires);
   gcMARK(m->dt_requires);
+  gcMARK(m->other_requires);
 
   gcMARK(m->body);
   gcMARK(m->et_body);
@@ -2351,9 +2344,6 @@ static int module_val_MARK(void *p) {
   gcMARK(m->dummy);
 
   gcMARK(m->rn_stx);
-  gcMARK(m->et_rn_stx);
-  gcMARK(m->tt_rn_stx);
-  gcMARK(m->dt_rn_stx);
 
   gcMARK(m->primitive);
   return
@@ -2368,6 +2358,7 @@ static int module_val_FIXUP(void *p) {
   gcFIXUP(m->requires);
   gcFIXUP(m->tt_requires);
   gcFIXUP(m->dt_requires);
+  gcFIXUP(m->other_requires);
 
   gcFIXUP(m->body);
   gcFIXUP(m->et_body);
@@ -2395,9 +2386,6 @@ static int module_val_FIXUP(void *p) {
   gcFIXUP(m->dummy);
 
   gcFIXUP(m->rn_stx);
-  gcFIXUP(m->et_rn_stx);
-  gcFIXUP(m->tt_rn_stx);
-  gcFIXUP(m->dt_rn_stx);
 
   gcFIXUP(m->primitive);
   return
@@ -2416,6 +2404,8 @@ static int module_phase_exports_val_SIZE(void *p) {
 static int module_phase_exports_val_MARK(void *p) {
   Scheme_Module_Phase_Exports *m = (Scheme_Module_Phase_Exports *)p;
 
+  gcMARK(m->phase_index);
+
   gcMARK(m->src_modidx);
 
   gcMARK(m->provides);
@@ -2436,6 +2426,8 @@ static int module_phase_exports_val_MARK(void *p) {
 static int module_phase_exports_val_FIXUP(void *p) {
   Scheme_Module_Phase_Exports *m = (Scheme_Module_Phase_Exports *)p;
 
+  gcFIXUP(m->phase_index);
+
   gcFIXUP(m->src_modidx);
 
   gcFIXUP(m->provides);
@@ -2468,6 +2460,7 @@ static int module_exports_val_MARK(void *p) {
   gcMARK(m->rt);
   gcMARK(m->et);
   gcMARK(m->dt);
+  gcMARK(m->other_phases);
 
   gcMARK(m->src_modidx);
   return
@@ -2480,6 +2473,7 @@ static int module_exports_val_FIXUP(void *p) {
   gcFIXUP(m->rt);
   gcFIXUP(m->et);
   gcFIXUP(m->dt);
+  gcFIXUP(m->other_phases);
 
   gcFIXUP(m->src_modidx);
   return
@@ -4842,6 +4836,7 @@ static int mark_rename_table_SIZE(void *p) {
 
 static int mark_rename_table_MARK(void *p) {
   Module_Renames *rn = (Module_Renames *)p;
+  gcMARK(rn->phase);
   gcMARK(rn->ht);
   gcMARK(rn->nomarshal_ht);
   gcMARK(rn->unmarshal_info);
@@ -4854,6 +4849,7 @@ static int mark_rename_table_MARK(void *p) {
 
 static int mark_rename_table_FIXUP(void *p) {
   Module_Renames *rn = (Module_Renames *)p;
+  gcFIXUP(rn->phase);
   gcFIXUP(rn->ht);
   gcFIXUP(rn->nomarshal_ht);
   gcFIXUP(rn->unmarshal_info);
@@ -4868,6 +4864,35 @@ static int mark_rename_table_FIXUP(void *p) {
 #define mark_rename_table_IS_CONST_SIZE 1
 
 
+static int mark_rename_table_set_SIZE(void *p) {
+  return
+  gcBYTES_TO_WORDS(sizeof(Module_Renames_Set));
+}
+
+static int mark_rename_table_set_MARK(void *p) {
+  Module_Renames_Set *rns = (Module_Renames_Set *)p;
+  gcMARK(rns->et);
+  gcMARK(rns->rt);
+  gcMARK(rns->other_phases);
+  gcMARK(rns->share_marked_names);
+  return
+  gcBYTES_TO_WORDS(sizeof(Module_Renames_Set));
+}
+
+static int mark_rename_table_set_FIXUP(void *p) {
+  Module_Renames_Set *rns = (Module_Renames_Set *)p;
+  gcFIXUP(rns->et);
+  gcFIXUP(rns->rt);
+  gcFIXUP(rns->other_phases);
+  gcFIXUP(rns->share_marked_names);
+  return
+  gcBYTES_TO_WORDS(sizeof(Module_Renames_Set));
+}
+
+#define mark_rename_table_set_IS_ATOMIC 0
+#define mark_rename_table_set_IS_CONST_SIZE 1
+
+
 static int mark_srcloc_SIZE(void *p) {
   return
   gcBYTES_TO_WORDS(sizeof(Scheme_Stx_Srcloc));
diff --git a/src/mzscheme/src/mzmarksrc.c b/src/mzscheme/src/mzmarksrc.c
index 82cbf9a08a..3254d720a5 100644
--- a/src/mzscheme/src/mzmarksrc.c
+++ b/src/mzscheme/src/mzmarksrc.c
@@ -814,15 +814,11 @@ namespace_val {
   gcMARK(e->export_registry);
   gcMARK(e->insp);
 
-  gcMARK(e->rename);
-  gcMARK(e->et_rename);
-  gcMARK(e->tt_rename);
-  gcMARK(e->dt_rename);
+  gcMARK(e->rename_set);
 
   gcMARK(e->syntax);
   gcMARK(e->exp_env);
   gcMARK(e->template_env);
-  gcMARK(e->label_env);
 
   gcMARK(e->shadowed_syntax);
 
@@ -831,13 +827,13 @@ namespace_val {
   gcMARK(e->et_require_names);
   gcMARK(e->tt_require_names);
   gcMARK(e->dt_require_names);
+  gcMARK(e->other_require_names);
 
   gcMARK(e->toplevel);
   gcMARK(e->modchain);
 
   gcMARK(e->modvars);
 
-  gcMARK(e->marked_names);
 
  size:
   gcBYTES_TO_WORDS(sizeof(Scheme_Env));
@@ -921,6 +917,7 @@ module_val {
   gcMARK(m->requires);
   gcMARK(m->tt_requires);
   gcMARK(m->dt_requires);
+  gcMARK(m->other_requires);
 
   gcMARK(m->body);
   gcMARK(m->et_body);
@@ -948,9 +945,6 @@ module_val {
   gcMARK(m->dummy);
 
   gcMARK(m->rn_stx);
-  gcMARK(m->et_rn_stx);
-  gcMARK(m->tt_rn_stx);
-  gcMARK(m->dt_rn_stx);
 
   gcMARK(m->primitive);
  size:
@@ -961,6 +955,8 @@ module_phase_exports_val {
  mark:
   Scheme_Module_Phase_Exports *m = (Scheme_Module_Phase_Exports *)p;
 
+  gcMARK(m->phase_index);
+
   gcMARK(m->src_modidx);
 
   gcMARK(m->provides);
@@ -985,6 +981,7 @@ module_exports_val {
   gcMARK(m->rt);
   gcMARK(m->et);
   gcMARK(m->dt);
+  gcMARK(m->other_phases);
 
   gcMARK(m->src_modidx);
  size:
@@ -1974,6 +1971,7 @@ START stxobj;
 mark_rename_table {
  mark:
   Module_Renames *rn = (Module_Renames *)p;
+  gcMARK(rn->phase);
   gcMARK(rn->ht);
   gcMARK(rn->nomarshal_ht);
   gcMARK(rn->unmarshal_info);
@@ -1984,6 +1982,17 @@ mark_rename_table {
   gcBYTES_TO_WORDS(sizeof(Module_Renames));
 }
 
+mark_rename_table_set {
+ mark:
+  Module_Renames_Set *rns = (Module_Renames_Set *)p;
+  gcMARK(rns->et);
+  gcMARK(rns->rt);
+  gcMARK(rns->other_phases);
+  gcMARK(rns->share_marked_names);
+ size:
+  gcBYTES_TO_WORDS(sizeof(Module_Renames_Set));
+}
+
 mark_srcloc {
  mark:
   Scheme_Stx_Srcloc *s = (Scheme_Stx_Srcloc *)p;
diff --git a/src/mzscheme/src/portfun.c b/src/mzscheme/src/portfun.c
index 87a16cbe20..c45435eaa4 100644
--- a/src/mzscheme/src/portfun.c
+++ b/src/mzscheme/src/portfun.c
@@ -4460,12 +4460,8 @@ static Scheme_Object *do_load_handler(void *data)
     /* ... end special support for module loading ... */
 
     genv = scheme_get_env(config);
-    if (genv->rename)
-      obj = scheme_add_rename(obj, genv->rename);
-    if (genv->exp_env && genv->exp_env->rename)
-      obj = scheme_add_rename(obj, genv->exp_env->rename);
-    if (genv->template_env && genv->template_env->rename)
-      obj = scheme_add_rename(obj, genv->template_env->rename);
+    if (genv->rename_set)
+      obj = scheme_add_rename(obj, genv->rename_set);
 
     last_val = _scheme_apply_multi_with_prompt(scheme_get_param(config, MZCONFIG_EVAL_HANDLER),
                                                1, &obj);
diff --git a/src/mzscheme/src/renumber.ss b/src/mzscheme/src/renumber.ss
index c0fb35c4ea..26792f1fac 100644
--- a/src/mzscheme/src/renumber.ss
+++ b/src/mzscheme/src/renumber.ss
@@ -1,3 +1,4 @@
+#lang scheme/base
 
 (define filename "stypes.h")
 
diff --git a/src/mzscheme/src/schminc.h b/src/mzscheme/src/schminc.h
index 07a6c63afd..440fd872f4 100644
--- a/src/mzscheme/src/schminc.h
+++ b/src/mzscheme/src/schminc.h
@@ -13,7 +13,7 @@
 
 #define USE_COMPILED_STARTUP 1
 
-#define EXPECTED_PRIM_COUNT 893
+#define EXPECTED_PRIM_COUNT 895
 
 #ifdef MZSCHEME_SOMETHING_OMITTED
 # undef USE_COMPILED_STARTUP
diff --git a/src/mzscheme/src/schpriv.h b/src/mzscheme/src/schpriv.h
index 2b781a5a81..b3f6667a9f 100644
--- a/src/mzscheme/src/schpriv.h
+++ b/src/mzscheme/src/schpriv.h
@@ -591,7 +591,7 @@ typedef struct Scheme_Stx {
   Scheme_Stx_Srcloc *srcloc;
   Scheme_Object *wraps;
   union {
-    long lazy_prefix; /* # of initial items in wraps to propagate */
+    long lazy_prefix; /* # of insitial items in wraps to propagate */
     Scheme_Object *modinfo_cache;
   } u;
   Scheme_Object *certs; /* cert chain or pair of cert chains */
@@ -658,14 +658,27 @@ Scheme_Object *scheme_stx_remove_extra_marks(Scheme_Object *o, Scheme_Object *re
 
 struct Scheme_Module_Phase_Exports; /* forward declaration */
 
-Scheme_Object *scheme_make_module_rename(long phase, int kind, Scheme_Hash_Table *mns);
+Scheme_Object *scheme_make_module_rename_set(int kind, Scheme_Object *share_marked_names);
+void scheme_add_module_rename_to_set(Scheme_Object *set, Scheme_Object *rn);
+Scheme_Object *scheme_get_module_rename_from_set(Scheme_Object *set, Scheme_Object *phase, int create);
+
+Scheme_Hash_Table *scheme_get_module_rename_marked_names(Scheme_Object *set, Scheme_Object *phase, int create);
+
+void scheme_append_rename_set_to_env(Scheme_Object *rns, Scheme_Env *env);
+
+void scheme_seal_module_rename(Scheme_Object *rn);
+void scheme_seal_module_rename_set(Scheme_Object *rns);
+
+Scheme_Object *scheme_make_module_rename(Scheme_Object *phase, int kind, Scheme_Hash_Table *mns);
 void scheme_extend_module_rename(Scheme_Object *rn, Scheme_Object *modname,
 				 Scheme_Object *locname, Scheme_Object *exname,
 				 Scheme_Object *nominal_src, Scheme_Object *nominal_ex,
-				 int mod_phase, int src_phase_index, int drop_for_marshal);
+				 int mod_phase, Scheme_Object *src_phase_index, 
+                                 Scheme_Object *nom_export_phase, int drop_for_marshal);
 void scheme_extend_module_rename_with_shared(Scheme_Object *rn, Scheme_Object *modidx, 
-                                             struct Scheme_Module_Phase_Exports *pt, int k,
-                                             int src_phase_index, 
+                                             struct Scheme_Module_Phase_Exports *pt, 
+                                             Scheme_Object *unmarshal_phase_index,
+                                             Scheme_Object *src_phase_index, 
                                              int save_unmarshal);
 void scheme_extend_module_rename_with_kernel(Scheme_Object *rn, Scheme_Object *nominal_src);
 void scheme_save_module_rename_unmarshal(Scheme_Object *rn, Scheme_Object *info);
@@ -681,21 +694,26 @@ void scheme_list_module_rename(Scheme_Object *src, Scheme_Hash_Table *ht);
 Scheme_Object *scheme_rename_to_stx(Scheme_Object *rn);
 Scheme_Object *scheme_stx_to_rename(Scheme_Object *stx);
 Scheme_Object *scheme_stx_shift_rename(Scheme_Object *mrn, Scheme_Object *old_midx, Scheme_Object *new_midx);
+Scheme_Object *scheme_stx_shift_rename_set(Scheme_Object *mrns, Scheme_Object *old_midx, Scheme_Object *new_midx);
 Scheme_Hash_Table *scheme_module_rename_marked_names(Scheme_Object *rn);
 
 Scheme_Object *scheme_stx_content(Scheme_Object *o);
 Scheme_Object *scheme_flatten_syntax_list(Scheme_Object *lst, int *islist);
 
 int scheme_stx_module_eq(Scheme_Object *a, Scheme_Object *b, long phase);
-Scheme_Object *scheme_stx_module_name(Scheme_Object **name, long phase,
+int scheme_stx_module_eq2(Scheme_Object *a, Scheme_Object *b, Scheme_Object *phase, Scheme_Object *asym);
+Scheme_Object *scheme_stx_get_module_eq_sym(Scheme_Object *a, Scheme_Object *phase);
+Scheme_Object *scheme_stx_module_name(Scheme_Object **name, Scheme_Object *phase,
 				      Scheme_Object **nominal_modidx,
 				      Scheme_Object **nominal_name,
-				      int *mod_phase, int *src_phase_index);
-Scheme_Object *scheme_stx_moduleless_env(Scheme_Object *a, long phase);
+				      Scheme_Object **mod_phase, 
+                                      Scheme_Object **src_phase_index, 
+                                      Scheme_Object **nominal_src_phase);
+Scheme_Object *scheme_stx_moduleless_env(Scheme_Object *a, Scheme_Object *phase);
 int scheme_stx_parallel_is_used(Scheme_Object *sym, Scheme_Object *stx);
 
-int scheme_stx_bound_eq(Scheme_Object *a, Scheme_Object *b, long phase);
-int scheme_stx_env_bound_eq(Scheme_Object *a, Scheme_Object *b, Scheme_Object *uid, long phase);
+int scheme_stx_bound_eq(Scheme_Object *a, Scheme_Object *b, Scheme_Object *phase);
+int scheme_stx_env_bound_eq(Scheme_Object *a, Scheme_Object *b, Scheme_Object *uid, Scheme_Object *phase);
 
 Scheme_Object *scheme_stx_source_module(Scheme_Object *stx, int resolve);
 
@@ -2225,6 +2243,7 @@ Scheme_Env *scheme_make_empty_env(void);
 void scheme_prepare_exp_env(Scheme_Env *env);
 void scheme_prepare_template_env(Scheme_Env *env);
 void scheme_prepare_label_env(Scheme_Env *env);
+void scheme_prepare_env_renames(Scheme_Env *env, int kind);
 
 int scheme_used_app_only(Scheme_Comp_Env *env, int which);
 int scheme_used_ever(Scheme_Comp_Env *env, int which);
@@ -2346,6 +2365,8 @@ void scheme_unmarshal_wrap_set(Scheme_Unmarshal_Tables *ut,
 struct Scheme_Env {
   Scheme_Object so; /* scheme_namespace_type */
 
+  char disallow_unbound, rename_set_ready;
+
   struct Scheme_Module *module; /* NULL => top-level */
 
   Scheme_Hash_Table *module_registry; /* symbol -> module ; loaded modules,
@@ -2354,17 +2375,11 @@ struct Scheme_Env {
   Scheme_Object *insp; /* instantiation-time inspector, for granting
 			  protected access and certificates */
 
-  /* For compilation, per-declaration: */
-  /* First two are passed from module to module-begin: */
-  Scheme_Object *rename;    /* module rename record */
-  Scheme_Object *et_rename; /* exp-time rename record */
-  Scheme_Object *tt_rename; /* template-time rename record */
-  Scheme_Object *dt_rename; /* template-time rename record */
+  Scheme_Object *rename_set;
 
   Scheme_Bucket_Table *syntax;
   struct Scheme_Env *exp_env;
   struct Scheme_Env *template_env;
-  struct Scheme_Env *label_env; /* just for renamings */
 
   Scheme_Hash_Table *shadowed_syntax; /* top level only */
 
@@ -2372,6 +2387,7 @@ struct Scheme_Env {
   long phase, mod_phase;
   Scheme_Object *link_midx;
   Scheme_Object *require_names, *et_require_names, *tt_require_names, *dt_require_names; /* resolved */
+  Scheme_Hash_Table *other_require_names;
   char running, et_running, tt_running, lazy_syntax, attached, ran, et_ran;
 
   Scheme_Bucket_Table *toplevel;
@@ -2383,8 +2399,6 @@ struct Scheme_Env {
 
   Scheme_Hash_Table *modvars; /* for scheme_module_variable_type hashing */
 
-  Scheme_Hash_Table *marked_names; /* for mapping marked ids to uninterned symbols */
-
   int id_counter;
 };
 
@@ -2405,6 +2419,7 @@ typedef struct Scheme_Module
   Scheme_Object *requires;     /* list of symbol-or-module-path-index */
   Scheme_Object *tt_requires;  /* list of symbol-or-module-path-index */
   Scheme_Object *dt_requires;  /* list of symbol-or-module-path-index */
+  Scheme_Hash_Table *other_requires;  /* phase to list of symbol-or-module-path-index */
 
   Scheme_Invoke_Proc prim_body;
   Scheme_Invoke_Proc prim_et_body;
@@ -2442,21 +2457,21 @@ typedef struct Scheme_Module
 
   Scheme_Env *primitive;
 
-  Scheme_Object *rn_stx, *et_rn_stx, *tt_rn_stx, *dt_rn_stx;
+  Scheme_Object *rn_stx;
 } Scheme_Module;
 
 typedef struct Scheme_Module_Phase_Exports
 {
-  MZTAG_IF_REQUIRED
+  Scheme_Object so;
 
-  int phase_index;
+  Scheme_Object *phase_index;
 
   Scheme_Object *src_modidx;  /* same as in enclosing Scheme_Module_Exports */
 
   Scheme_Object **provides;          /* symbols (extenal names) */
   Scheme_Object **provide_srcs;      /* module access paths, #f for self */
   Scheme_Object **provide_src_names; /* symbols (original internal names) */
-  Scheme_Object **provide_nominal_srcs;      /* import source if re-exported; NULL or array of lists */
+  Scheme_Object **provide_nominal_srcs; /* import source if re-exported; NULL or array of lists */
   char *provide_src_phases;          /* NULL, or src phase for for-syntax import */
   int num_provides;
   int num_var_provides;              /* non-syntax listed first in provides */
@@ -2476,7 +2491,10 @@ typedef struct Scheme_Module_Exports
      unmarshal syntax-object context. */
   MZTAG_IF_REQUIRED
 
+  /* Most common phases: */
   Scheme_Module_Phase_Exports *rt, *et, *dt;
+  /* All others: */
+  Scheme_Hash_Table *other_phases;
 
   Scheme_Object *src_modidx;  /* the one used in marshalled syntax */
 } Scheme_Module_Exports;
@@ -2504,7 +2522,7 @@ void scheme_add_global_keyword_symbol(Scheme_Object *name, Scheme_Object *v, Sch
 void scheme_add_global_constant(const char *name, Scheme_Object *v, Scheme_Env *env);
 void scheme_add_global_constant_symbol(Scheme_Object *name, Scheme_Object *v, Scheme_Env *env);
 
-Scheme_Object *scheme_tl_id_sym(Scheme_Env *env, Scheme_Object *id, Scheme_Object *bdg, int is_def);
+Scheme_Object *scheme_tl_id_sym(Scheme_Env *env, Scheme_Object *id, Scheme_Object *bdg, int is_def, Scheme_Object *phase);
 int scheme_tl_id_is_sym_used(Scheme_Hash_Table *marked_names, Scheme_Object *sym);
 
 Scheme_Object *scheme_sys_wraps(Scheme_Comp_Env *env);
@@ -2552,8 +2570,8 @@ void scheme_clear_modidx_cache(void);
 void scheme_clear_shift_cache(void);
 void scheme_clear_prompt_cache(void);
 
-Scheme_Object *scheme_module_imported_list(Scheme_Env *genv, Scheme_Object *binings, Scheme_Object *modpath,
-                                           int include_run, int include_exp, int include_lbl);
+Scheme_Object *scheme_module_imported_list(Scheme_Env *genv, Scheme_Object *bindings, Scheme_Object *modpath,
+                                           Scheme_Object *mode);
 Scheme_Object *scheme_module_exported_list(Scheme_Object *modpath, Scheme_Env *genv);
 
 void scheme_run_module(Scheme_Env *menv, int set_ns);
diff --git a/src/mzscheme/src/schvers.h b/src/mzscheme/src/schvers.h
index cf2386fd9e..e1435fbfab 100644
--- a/src/mzscheme/src/schvers.h
+++ b/src/mzscheme/src/schvers.h
@@ -13,12 +13,12 @@
    consistently.)
 */
 
-#define MZSCHEME_VERSION "3.99.0.12"
+#define MZSCHEME_VERSION "3.99.0.13"
 
 #define MZSCHEME_VERSION_X 3
 #define MZSCHEME_VERSION_Y 99
 #define MZSCHEME_VERSION_Z 0
-#define MZSCHEME_VERSION_W 12
+#define MZSCHEME_VERSION_W 13
 
 #define MZSCHEME_VERSION_MAJOR ((MZSCHEME_VERSION_X * 100) + MZSCHEME_VERSION_Y)
 #define MZSCHEME_VERSION_MINOR ((MZSCHEME_VERSION_Z * 1000) + MZSCHEME_VERSION_W)
diff --git a/src/mzscheme/src/stxobj.c b/src/mzscheme/src/stxobj.c
index 91652f3abf..27791d9362 100644
--- a/src/mzscheme/src/stxobj.c
+++ b/src/mzscheme/src/stxobj.c
@@ -115,15 +115,16 @@ static void preemptive_chunk(Scheme_Stx *stx);
 
 typedef struct Module_Renames {
   Scheme_Object so; /* scheme_rename_table_type */
-  char plus_kernel, kind, needs_unmarshal;
-  long phase;
+  char plus_kernel, kind, needs_unmarshal, sealed;
+  Scheme_Object *phase;
   Scheme_Object *plus_kernel_nominal_source;
   Scheme_Hash_Table *ht; /* localname ->  modidx  OR
                                           (cons modidx exportname) OR
                                           (cons modidx nominal_modidx) OR
                                           (list* modidx exportname nominal_modidx_plus_phase nominal_exportname) OR
                                           (list* modidx mod-phase exportname nominal_modidx_plus_phase nominal_exportname)
-                            nominal_modix_plus_phase -> nominal_modix | (cons nominal_modix phase-index-int) */
+                            nominal_modix_plus_phase -> nominal_modix | (cons nominal_modix import_phase_plus_nominal_phase)
+                            import_phase_plus_nominal_phase -> import-phase-index | (cons import-phase-index nom-phase) */
   Scheme_Hash_Table *nomarshal_ht; /* like ht, but dropped on marshal */
   Scheme_Object *shared_pes; /* list of (cons modidx (cons phase_export phase-index-int)) like nomarshal ht, but shared from provider */
   Scheme_Hash_Table *marked_names; /* shared with module environment while compiling the module;
@@ -133,6 +134,14 @@ typedef struct Module_Renames {
 				    imported modules and restore renames from their exports */
 } Module_Renames;
 
+typedef struct Module_Renames_Set {
+  Scheme_Object so; /* scheme_rename_table_set_type */
+  char kind, sealed;
+  Module_Renames *rt, *et;
+  Scheme_Hash_Table *other_phases;
+  Scheme_Object *share_marked_names; /* a Module_Renames_Set */
+} Module_Renames_Set;
+
 typedef struct Scheme_Cert {
   Scheme_Inclhash_Object iso;
   Scheme_Object *mark;
@@ -176,6 +185,7 @@ typedef struct Scheme_Lexical_Rib {
 static Module_Renames *krn;
 
 #define SCHEME_RENAMESP(obj) (SAME_TYPE(SCHEME_TYPE(obj), scheme_rename_table_type))
+#define SCHEME_RENAMES_SETP(obj) (SAME_TYPE(SCHEME_TYPE(obj), scheme_rename_table_set_type))
 
 /* Wraps:
 
@@ -208,6 +218,9 @@ static Module_Renames *krn;
    - A wrap-elem <rename-table> is a module rename set
          the hash table maps renamed syms to modname-srcname pairs
 
+   - A wrap-elem <rename-table-set> is a set of <rename-table>s for
+         different phases.
+
    - A wrap-elem <hash-table> is a chain-specific cache; it maps
          identifiers to #t, and 0 to a deeper part of the chain; a
          resolution for an identifier can safely skip to the deeper
@@ -424,12 +437,12 @@ void scheme_init_stx(Scheme_Env *env)
   scheme_add_global_constant("bound-identifier=?", 
 			     scheme_make_immed_prim(bound_eq,
 						    "bound-identifier=?",
-						    2, 2),
+						    2, 3),
 			     env);
   scheme_add_global_constant("free-identifier=?", 
 			     scheme_make_immed_prim(module_eq,
 						    "free-identifier=?",
-						    2, 2),
+						    2, 3),
 			     env);
   scheme_add_global_constant("free-transformer-identifier=?", 
 			     scheme_make_immed_prim(module_trans_eq,
@@ -450,7 +463,7 @@ void scheme_init_stx(Scheme_Env *env)
   scheme_add_global_constant("identifier-binding", 
 			     scheme_make_immed_prim(module_binding,
 						    "identifier-binding",
-						    1, 1),
+						    1, 2),
 			     env);
   scheme_add_global_constant("identifier-transformer-binding", 
 			     scheme_make_immed_prim(module_trans_binding,
@@ -1033,7 +1046,101 @@ void scheme_drop_first_rib_rename(Scheme_Object *ro)
 
 /******************** module renames ********************/
 
-Scheme_Object *scheme_make_module_rename(long phase, int kind, Scheme_Hash_Table *marked_names)
+static int same_phase(Scheme_Object *a, Scheme_Object *b)
+{
+  if (SAME_OBJ(a, b))
+    return 1;
+  else if (SCHEME_INTP(a) || SCHEME_INTP(b)
+           || SCHEME_FALSEP(a) || SCHEME_FALSEP(b))
+    return 0;
+  else
+    return scheme_eqv(a, b);
+}
+
+Scheme_Object *scheme_make_module_rename_set(int kind, Scheme_Object *share_marked_names)
+{
+  Module_Renames_Set *mrns;
+
+  mrns = MALLOC_ONE_TAGGED(Module_Renames_Set);
+  mrns->so.type = scheme_rename_table_set_type;
+  mrns->kind = kind;
+  mrns->share_marked_names = share_marked_names;
+
+  return (Scheme_Object *)mrns;
+}
+
+void scheme_add_module_rename_to_set(Scheme_Object *set, Scheme_Object *rn)
+{
+  Module_Renames_Set *mrns = (Module_Renames_Set *)set;
+  Module_Renames *mrn = (Module_Renames *)rn;
+
+  if (same_phase(mrn->phase, scheme_make_integer(0)))
+    mrns->rt = mrn;
+  else if (same_phase(mrn->phase, scheme_make_integer(1)))
+    mrns->et = mrn;
+  else {
+    Scheme_Hash_Table *ht;
+    ht = mrns->other_phases;
+    if (!ht) {
+      ht = scheme_make_hash_table_equal();
+      mrns->other_phases = ht;
+    }
+    scheme_hash_set(ht, mrn->phase, (Scheme_Object *)mrn);
+  }
+}
+
+Scheme_Object *scheme_get_module_rename_from_set(Scheme_Object *set, Scheme_Object *phase, int create)
+{
+  Module_Renames_Set *mrns = (Module_Renames_Set *)set;
+  Module_Renames *mrn;
+
+  if (same_phase(phase, scheme_make_integer(0)))
+    mrn = mrns->rt;
+  else if (same_phase(phase, scheme_make_integer(1)))
+    mrn = mrns->et;
+  else if (mrns->other_phases)
+    mrn = (Module_Renames *)scheme_hash_get(mrns->other_phases, phase);
+  else
+    mrn = NULL;
+
+  if (!mrn && create) {
+    Scheme_Hash_Table *marked_names;
+
+    if (mrns->share_marked_names)
+      marked_names = scheme_get_module_rename_marked_names(mrns->share_marked_names, phase, 1);
+    else
+      marked_names = NULL;
+
+    mrn = (Module_Renames *)scheme_make_module_rename(phase, mrns->kind, marked_names);
+
+    scheme_add_module_rename_to_set(set, (Scheme_Object *)mrn);
+  }
+
+  return (Scheme_Object *)mrn;
+}
+
+Scheme_Hash_Table *scheme_get_module_rename_marked_names(Scheme_Object *set, Scheme_Object *phase, int create)
+{
+  Scheme_Object *rn;
+
+  rn = scheme_get_module_rename_from_set(set, phase, create);
+  if (!rn)
+    return NULL;
+
+  if (((Module_Renames *)rn)->marked_names)
+    return ((Module_Renames *)rn)->marked_names;
+
+  if (create) {
+    Scheme_Hash_Table *ht;
+    ht = scheme_make_hash_table(SCHEME_hash_ptr);
+    ((Module_Renames *)rn)->marked_names = ht;
+    return ht;
+  }
+
+  return NULL;
+}
+
+Scheme_Object *scheme_make_module_rename(Scheme_Object *phase, int kind, Scheme_Hash_Table *marked_names)
 {
   Module_Renames *mr;
   Scheme_Hash_Table *ht;
@@ -1058,22 +1165,48 @@ Scheme_Object *scheme_make_module_rename(long phase, int kind, Scheme_Hash_Table
   return (Scheme_Object *)mr;
 }
 
+void scheme_seal_module_rename(Scheme_Object *rn)
+{
+  ((Module_Renames *)rn)->sealed = 1;
+}
+
+void scheme_seal_module_rename_set(Scheme_Object *_rns)
+{
+  Module_Renames_Set *rns = (Module_Renames_Set *)_rns;
+  
+  rns->sealed = 1;
+  if (rns->rt)
+    rns->rt->sealed = 1;
+  if (rns->et)
+    rns->et->sealed = 1;
+  if (rns->other_phases) {
+    int i;
+    for (i = 0; i < rns->other_phases->size; i++) {
+      if (rns->other_phases->vals[i]) {
+        ((Module_Renames *)rns->other_phases->vals[i])->sealed = 1;
+      }
+    }
+  }
+}
+
+static void check_not_sealed(Module_Renames *mrn)
+{
+  if (mrn->sealed)
+    scheme_signal_error("internal error: attempt to change sealed module rename");
+}
+
 void scheme_extend_module_rename_with_kernel(Scheme_Object *mrn, Scheme_Object *nominal_mod)
 {
   /* Don't use on a non-module namespace, where renames may need
      to be removed... */
+  check_not_sealed((Module_Renames *)mrn);
   ((Module_Renames *)mrn)->plus_kernel = 1;
   ((Module_Renames *)mrn)->plus_kernel_nominal_source = nominal_mod;
 }
 
-static int phase_to_index(int phase)
+static Scheme_Object *phase_to_index(Scheme_Object *phase)
 {
-  if (phase == MZ_LABEL_PHASE)
-    return 2;
-  else if (phase == -1)
-    return 3;
-  else
-    return phase;
+  return phase;
 }
 
 void scheme_extend_module_rename(Scheme_Object *mrn,
@@ -1083,20 +1216,26 @@ void scheme_extend_module_rename(Scheme_Object *mrn,
 				 Scheme_Object *nominal_mod, /* nominal source module */
 				 Scheme_Object *nominal_ex,  /* nominal import before local renaming */
 				 int mod_phase,              /* phase of source defn */
-                                 int src_phase_index,        /* nominal import phase */
+                                 Scheme_Object *src_phase_index, /* nominal import phase */
+                                 Scheme_Object *nom_phase,   /* nominal export phase */
 				 int unmarshal_drop)         /* 1 => can be reconstructed from unmarshal info */
 {
   Scheme_Object *elem;
-  int phase_index;
+  Scheme_Object *phase_index;
+
+  check_not_sealed((Module_Renames *)mrn);
 
   phase_index = phase_to_index(((Module_Renames *)mrn)->phase);
-  if (src_phase_index < 0)
+  if (!src_phase_index)
     src_phase_index = phase_index;
+  if (!nom_phase)
+    nom_phase = scheme_make_integer(mod_phase);
 
   if (SAME_OBJ(modname, nominal_mod)
       && SAME_OBJ(exname, nominal_ex)
       && !mod_phase
-      && src_phase_index == phase_index) {
+      && same_phase(src_phase_index, phase_index)
+      && same_phase(nom_phase, scheme_make_integer(mod_phase))) {
     if (SAME_OBJ(localname, exname))
       elem = modname;
     else
@@ -1104,7 +1243,8 @@ void scheme_extend_module_rename(Scheme_Object *mrn,
   } else if (SAME_OBJ(exname, nominal_ex)
 	     && SAME_OBJ(localname, exname)
 	     && !mod_phase
-             && src_phase_index == phase_index) {
+             && same_phase(src_phase_index, phase_index)
+             && same_phase(nom_phase, scheme_make_integer(mod_phase))) {
     /* It's common that a sequence of similar mappings shows up,
        e.g., '(#%kernel . mzscheme) */
     if (nominal_ipair_cache
@@ -1116,10 +1256,14 @@ void scheme_extend_module_rename(Scheme_Object *mrn,
       nominal_ipair_cache = elem;
     }
   } else {
-    if (src_phase_index == phase_index)
-      elem = nominal_mod;
-    else
-      elem = CONS(nominal_mod, scheme_make_integer(src_phase_index));
+    if (same_phase(nom_phase, scheme_make_integer(mod_phase))) {
+      if (same_phase(src_phase_index, phase_index))
+        elem = nominal_mod;
+      else
+        elem = CONS(nominal_mod, src_phase_index);
+    } else {
+      elem = CONS(nominal_mod, CONS(src_phase_index, nom_phase));
+    }
     elem = CONS(exname, CONS(elem, nominal_ex));
     if (mod_phase)
       elem = CONS(scheme_make_integer(mod_phase), elem);
@@ -1138,22 +1282,26 @@ void scheme_extend_module_rename(Scheme_Object *mrn,
 }
 
 void scheme_extend_module_rename_with_shared(Scheme_Object *rn, Scheme_Object *modidx, 
-                                             Scheme_Module_Phase_Exports *pt, int k,
-                                             int src_phase_index,
+                                             Scheme_Module_Phase_Exports *pt, 
+                                             Scheme_Object *unmarshal_phase_index,
+                                             Scheme_Object *src_phase_index,
                                              int save_unmarshal)
 {
   Module_Renames *mrn = (Module_Renames *)rn;
   Scheme_Object *pr;
 
+  check_not_sealed(mrn);
+
   pr = scheme_make_pair(scheme_make_pair(modidx, 
                                          scheme_make_pair((Scheme_Object *)pt,
-                                                          scheme_make_integer(src_phase_index))),
+                                                          src_phase_index)),
                         mrn->shared_pes);
   mrn->shared_pes = pr;
 
   if (save_unmarshal) {
-    pr = scheme_make_pair(scheme_make_pair(modidx, scheme_make_pair(scheme_make_integer(k),
-                                                                    scheme_make_integer(src_phase_index))),
+    pr = scheme_make_pair(scheme_make_pair(modidx, 
+                                           scheme_make_pair(unmarshal_phase_index,
+                                                            src_phase_index)),
                           mrn->unmarshal_info);
     mrn->unmarshal_info = pr;
   }
@@ -1175,6 +1323,8 @@ static void do_append_module_rename(Scheme_Object *src, Scheme_Object *dest,
   Scheme_Object *v;
   int i, t;
 
+  check_not_sealed((Module_Renames *)dest);
+
   if (((Module_Renames *)src)->plus_kernel) {
     ((Module_Renames *)dest)->plus_kernel = 1;
     ((Module_Renames *)dest)->plus_kernel_nominal_source = ((Module_Renames *)src)->plus_kernel_nominal_source;
@@ -1295,39 +1445,81 @@ void scheme_append_module_rename(Scheme_Object *src, Scheme_Object *dest, int do
   do_append_module_rename(src, dest, NULL, NULL, 1, do_unm);
 }
 
+void scheme_append_rename_set_to_env(Scheme_Object *_mrns, Scheme_Env *env)
+{
+  Module_Renames_Set *mrns = (Module_Renames_Set *)_mrns;
+  Scheme_Object *mrns2;
+  int i;
+
+  scheme_prepare_env_renames(env, mzMOD_RENAME_TOPLEVEL);
+  mrns2 = env->rename_set;
+
+  if (mrns->rt) {
+    scheme_append_module_rename((Scheme_Object *)mrns->rt, 
+                                scheme_get_module_rename_from_set(mrns2, scheme_make_integer(0), 1),
+                                1);
+  }
+  if (mrns->et) {
+    scheme_append_module_rename((Scheme_Object *)mrns->et, 
+                                scheme_get_module_rename_from_set(mrns2, scheme_make_integer(1), 1),
+                                1);
+  }
+  if (mrns->other_phases) {
+    for (i = 0; i < mrns->other_phases->size; i++) {
+      if (mrns->other_phases->vals[i]) {
+        scheme_append_module_rename(mrns->other_phases->vals[i],
+                                    scheme_get_module_rename_from_set(mrns2, 
+                                                                      mrns->other_phases->keys[i],
+                                                                      1),
+                                    1);
+      }
+    }
+  }
+}
+
 void scheme_remove_module_rename(Scheme_Object *mrn,
 				 Scheme_Object *localname)
 {
+  check_not_sealed((Module_Renames *)mrn);
   scheme_hash_set(((Module_Renames *)mrn)->ht, localname, NULL);
   if (((Module_Renames *)mrn)->nomarshal_ht)
     scheme_hash_set(((Module_Renames *)mrn)->nomarshal_ht, localname, NULL);
 }
 
-void scheme_list_module_rename(Scheme_Object *src, Scheme_Hash_Table *ht)
+void scheme_list_module_rename(Scheme_Object *set, Scheme_Hash_Table *ht)
 {
   /* Put every name mapped by src into ht: */
   Scheme_Object *pr;
   Scheme_Hash_Table *hts;
   int i, t;
   Scheme_Module_Phase_Exports *pt;
+  Module_Renames *src;
+
+  if (SCHEME_RENAMES_SETP(set))
+    src = ((Module_Renames_Set *)set)->rt;
+  else
+    src = (Module_Renames *)set;
+
+  if (!src)
+    return;
 
   for (t = 0; t < 2; t++) {
     if (!t)
-      hts = ((Module_Renames *)src)->ht;
+      hts = src->ht;
     else {
-      hts = ((Module_Renames *)src)->nomarshal_ht;
-      if (!hts)
-	break;
+      hts = src->nomarshal_ht;
     }
-   
-    for (i = hts->size; i--; ) {
-      if (hts->vals[i]) {
-	scheme_hash_set(ht, hts->keys[i], scheme_false);
+
+    if (hts) {
+      for (i = hts->size; i--; ) {
+        if (hts->vals[i]) {
+          scheme_hash_set(ht, hts->keys[i], scheme_false);
+        }
       }
     }
   }
 
-  for (pr = ((Module_Renames *)src)->shared_pes; !SCHEME_NULLP(pr); pr = SCHEME_CDR(pr)) {
+  for (pr = src->shared_pes; !SCHEME_NULLP(pr); pr = SCHEME_CDR(pr)) {
     pt = (Scheme_Module_Phase_Exports *)SCHEME_CADR(SCHEME_CAR(pr));
     for (i = pt->num_provides; i--; ) {
       scheme_hash_set(ht, pt->provides[i], scheme_false);
@@ -1336,7 +1528,7 @@ void scheme_list_module_rename(Scheme_Object *src, Scheme_Hash_Table *ht)
       scheme_list_module_rename((Scheme_Object *)krn, ht);
   }
 
-  if (((Module_Renames *)src)->plus_kernel) {
+  if (src->plus_kernel) {
     scheme_list_module_rename((Scheme_Object *)krn, ht);
   }
 }
@@ -1351,9 +1543,30 @@ Scheme_Object *scheme_rename_to_stx(Scheme_Object *mrn)
 
 Scheme_Object *scheme_stx_to_rename(Scheme_Object *stx)
 {
-  Scheme_Object *wraps;
-  wraps = ((Scheme_Stx *)stx)->wraps;
-  return SCHEME_CAR(wraps);
+  Scheme_Object *rns = NULL, *v;
+  WRAP_POS wl;
+  
+  WRAP_POS_INIT(wl, ((Scheme_Stx *)stx)->wraps);
+  while (!WRAP_POS_END_P(wl)) {
+    v = WRAP_POS_FIRST(wl);
+    if (SCHEME_RENAMES_SETP(v)) {
+      if (rns)
+        scheme_signal_error("can't convert syntax to rename (two sets)");
+      rns = v;
+    } else if (SCHEME_RENAMESP(v)) {
+      if (!rns)
+        rns = scheme_make_module_rename_set(((Module_Renames *)v)->kind, NULL);
+      scheme_add_module_rename_to_set(rns, v);
+    } else {
+      scheme_signal_error("can't convert syntax to rename (non-rename in wrap)");
+    }
+    WRAP_POS_INC(wl);
+  }
+
+  if (!rns)
+    scheme_signal_error("can't convert syntax to rename (empty)");
+
+  return rns;
 }
 
 Scheme_Object *scheme_stx_shift_rename(Scheme_Object *mrn, 
@@ -1361,7 +1574,9 @@ Scheme_Object *scheme_stx_shift_rename(Scheme_Object *mrn,
 {
   Scheme_Object *nmrn, *a, *l, *nl;
 
-  nmrn = scheme_make_module_rename(0, mzMOD_RENAME_NORMAL, NULL);
+  nmrn = scheme_make_module_rename(((Module_Renames *)mrn)->phase, 
+                                   mzMOD_RENAME_NORMAL, 
+                                   NULL);
 
   /* use "append" to copy most info: */
   do_append_module_rename(mrn, nmrn, old_midx, new_midx, 0, 0);
@@ -1397,6 +1612,35 @@ Scheme_Object *scheme_stx_shift_rename(Scheme_Object *mrn,
   return nmrn;
 }
 
+Scheme_Object *scheme_stx_shift_rename_set(Scheme_Object *_mrns, 
+                                           Scheme_Object *old_midx, Scheme_Object *new_midx)
+{
+  Module_Renames_Set *mrns = (Module_Renames_Set *)_mrns;
+  Scheme_Object *mrn, *mrns2;
+  int i;
+
+  mrns2 = scheme_make_module_rename_set(mrns->kind, NULL);
+  if (mrns->rt) {
+    mrn = scheme_stx_shift_rename((Scheme_Object *)mrns->rt, old_midx, new_midx);
+    scheme_add_module_rename_to_set(mrns2, mrn);
+  }
+  if (mrns->et) {
+    mrn = scheme_stx_shift_rename((Scheme_Object *)mrns->et, old_midx, new_midx);
+    scheme_add_module_rename_to_set(mrns2, mrn);
+  }
+  if (mrns->other_phases) {
+    for (i = 0; i < mrns->other_phases->size; i++) {
+      if (mrns->other_phases->vals[i]) {
+        mrn = scheme_stx_shift_rename(mrns->other_phases->vals[i], old_midx, new_midx);
+        scheme_add_module_rename_to_set(mrns2, mrn);
+      }
+    }
+  }
+
+  return (Scheme_Object *)mrns2;
+}
+
+
 Scheme_Hash_Table *scheme_module_rename_marked_names(Scheme_Object *rn)
 {
   return ((Module_Renames *)rn)->marked_names;
@@ -1407,13 +1651,22 @@ static void unmarshal_rename(Module_Renames *mrn,
 			     Scheme_Hash_Table *export_registry)
 {
   Scheme_Object *l;
+  int sealed;
 
   mrn->needs_unmarshal = 0;
+
+  sealed = mrn->sealed;
+  if (sealed)
+    mrn->sealed = 0;
+    
   for (l = mrn->unmarshal_info; 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);
   }
+
+  if (sealed)
+    mrn->sealed = 1;
 }
 
 /******************** wrap manipulations ********************/
@@ -2328,7 +2581,7 @@ Scheme_Object *scheme_stx_strip_module_context(Scheme_Object *_stx)
   WRAP_POS_INIT(awl, stx->wraps);
   while (!WRAP_POS_END_P(awl)) {
     v = WRAP_POS_FIRST(awl);
-    if (SCHEME_RENAMESP(v) || SCHEME_BOXP(v)) {
+    if (SCHEME_RENAMESP(v) || SCHEME_BOXP(v) || SCHEME_RENAMES_SETP(v)) {
       mod_ctx_count++;
     }
     WRAP_POS_INC(awl);
@@ -2350,7 +2603,7 @@ Scheme_Object *scheme_stx_strip_module_context(Scheme_Object *_stx)
     WRAP_POS_INIT(awl, stx->wraps);
     while (!WRAP_POS_END_P(awl)) {
       v = WRAP_POS_FIRST(awl);
-      if (!SCHEME_RENAMESP(v) && !SCHEME_BOXP(v)) {
+      if (!SCHEME_RENAMESP(v) && !SCHEME_BOXP(v) && !SCHEME_RENAMES_SETP(v)) {
 	chunk->a[skipped] = v;
 	skipped++;
       }
@@ -2770,7 +3023,8 @@ static Scheme_Object *scheme_search_shared_pes(Scheme_Object *shared_pes, Scheme
         /* If module bound, result is module idx, and get_names[0] is set to source name,
            get_names[1] is set to the nominal source module, get_names[2] is set to
            the nominal source module's export, get_names[3] is set to the phase of
-           the source definition, and get_names[4] is set to the nominal phase index */
+           the source definition, get_names[4] is set to the module import phase index,
+           and get_names[5] is set to the nominal export phase */
 
         if (pt->provide_src_phases)
           phase = pt->provide_src_phases[i];
@@ -2782,6 +3036,7 @@ static Scheme_Object *scheme_search_shared_pes(Scheme_Object *shared_pes, Scheme
         get_names[2] = glob_id;
         get_names[3] = scheme_make_integer(phase);
         get_names[4] = SCHEME_CDR(SCHEME_CDR(SCHEME_CAR(pr)));
+        get_names[5] = pt->phase_index;
       }
 
       if (SCHEME_FALSEP(src)) {
@@ -2804,7 +3059,8 @@ static Scheme_Object *scheme_search_shared_pes(Scheme_Object *shared_pes, Scheme
           get_names[1] = idx;
           get_names[2] = glob_id;
           get_names[3] = scheme_make_integer(0);
-          get_names[4] = scheme_make_integer(pt->phase_index);
+          get_names[4] = pt->phase_index;
+          get_names[5] = scheme_make_integer(0);
         }
         return scheme_get_kernel_modidx();
       }
@@ -2814,6 +3070,18 @@ static Scheme_Object *scheme_search_shared_pes(Scheme_Object *shared_pes, Scheme
   return NULL;
 }
 
+static Module_Renames *extract_renames(Module_Renames_Set *mrns, Scheme_Object *phase)
+{
+  if (SCHEME_INTP(phase) && (SCHEME_INT_VAL(phase) == 0))
+    return mrns->rt;
+  else if (SCHEME_INTP(phase) && (SCHEME_INT_VAL(phase) == 1))
+    return mrns->et;
+  else if (mrns->other_phases)
+    return (Module_Renames *)scheme_hash_get(mrns->other_phases, phase);
+  else
+    return NULL;
+}
+
 #define QUICK_STACK_SIZE 10
 
 #define EXPLAIN_RESOLVE 0
@@ -2829,14 +3097,15 @@ static int explain_resolves = 0;
    etc.). */
 
 static Scheme_Object *resolve_env(WRAP_POS *_wraps,
-				  Scheme_Object *a, long phase, 
+				  Scheme_Object *a, Scheme_Object *orig_phase, 
 				  int w_mod, Scheme_Object **get_names,
 				  Scheme_Object *skip_ribs)
 /* Module binding ignored if w_mod is 0.
    If module bound, result is module idx, and get_names[0] is set to source name,
      get_names[1] is set to the nominal source module, get_names[2] is set to
      the nominal source module's export, get_names[3] is set to the phase of
-     the source definition, and get_names[4] is set to the nominal phase index.
+     the source definition, and get_names[4] is set to the nominal import phase index,
+     and get_names[5] is set to the nominal export phase.
    If lexically bound, result is env id, and a get_names[0] is set to scheme_undefined.
    If neither, result is #f and get_names[0] is either unchanged or NULL. */
 {
@@ -2848,7 +3117,7 @@ static Scheme_Object *resolve_env(WRAP_POS *_wraps,
   int stack_pos = 0, no_lexical = 0;
   int is_in_module = 0, skip_other_mods = 0;
   Scheme_Lexical_Rib *rib = NULL, *did_rib = NULL;
-  long orig_phase = phase;
+  Scheme_Object *phase = orig_phase;
   Scheme_Object *bdg = NULL;
   Scheme_Hash_Table *export_registry = NULL;
 
@@ -2907,14 +3176,30 @@ static Scheme_Object *resolve_env(WRAP_POS *_wraps,
       EXPLAIN(printf("Result: %s\n", scheme_write_to_string(result, 0)));
 
       return result;
-    } else if (SCHEME_RENAMESP(WRAP_POS_FIRST(wraps)) && w_mod) {
+    } else if ((SCHEME_RENAMESP(WRAP_POS_FIRST(wraps)) 
+                || SCHEME_RENAMES_SETP(WRAP_POS_FIRST(wraps)))
+               && w_mod) {
       /* Module rename: */
-      Module_Renames *mrn = (Module_Renames *)WRAP_POS_FIRST(wraps);
-      if ((!is_in_module || (mrn->kind != mzMOD_RENAME_TOPLEVEL)) && !skip_other_mods) {
+      Module_Renames *mrn;
+
+      if (SCHEME_RENAMESP(WRAP_POS_FIRST(wraps))) {
+        mrn = (Module_Renames *)WRAP_POS_FIRST(wraps);
+      } else {
+        /* Extract the relevant phase, if available */
+        Module_Renames_Set *mrns = (Module_Renames_Set *)WRAP_POS_FIRST(wraps);
+
+        if (mrns->kind != mzMOD_RENAME_TOPLEVEL)
+	  is_in_module = 1;
+
+        mrn = extract_renames(mrns, phase);
+      }
+
+      if (mrn && (!is_in_module || (mrn->kind != mzMOD_RENAME_TOPLEVEL)) 
+          && !skip_other_mods) {
 	if (mrn->kind != mzMOD_RENAME_TOPLEVEL)
 	  is_in_module = 1;
 	
-	if (phase == mrn->phase) {
+	if (same_phase(phase, mrn->phase)) {
 	  Scheme_Object *rename, *nominal = NULL, *glob_id;
           int get_names_done;
 
@@ -2926,7 +3211,7 @@ static Scheme_Object *resolve_env(WRAP_POS *_wraps,
 	    if (!bdg)
 	      bdg = resolve_env(NULL, a, orig_phase, 0, NULL, skip_ribs);
 	    /* Remap id based on marks and rest-of-wraps resolution: */
-	    glob_id = scheme_tl_id_sym((Scheme_Env *)mrn->marked_names, a, bdg, 0);
+	    glob_id = scheme_tl_id_sym((Scheme_Env *)mrn->marked_names, a, bdg, 0, NULL);
 	    if (SCHEME_TRUEP(bdg)
 		&& !SAME_OBJ(glob_id, SCHEME_STX_VAL(a))) {
 	      /* Even if this module doesn't match, the lex-renamed id
@@ -2956,8 +3241,13 @@ static Scheme_Object *resolve_env(WRAP_POS *_wraps,
           }
             	  
 	  if (rename) {
-	    if (mrn->kind == mzMOD_RENAME_MARKED)
+	    if (mrn->kind == mzMOD_RENAME_MARKED) {
+              /* One job of a mzMOD_RENAME_MARKED renamer is to replace any
+                 binding that might have come from the identifier in its source
+                 module, instead of the module where it was eventually bound
+                 (after being introduced by a macro in the source module). */
 	      skip_other_mods = 1;
+            }
 
 	    /* match; set mresult, which is used in the case of no lexical capture: */
 	    if (SCHEME_PAIRP(rename))
@@ -2984,7 +3274,8 @@ static Scheme_Object *resolve_env(WRAP_POS *_wraps,
                     rename = SCHEME_CDR(rename);
                     if (SCHEME_PAIRP(rename)) {
                       /* (list* modidx [mod-phase] exportname nominal_modidx nominal_exportname) case */
-                      if (SCHEME_INTP(SCHEME_CAR(rename))) {
+                      if (SCHEME_INTP(SCHEME_CAR(rename))
+                          || SCHEME_FALSEP(SCHEME_CAR(rename))) {
                         get_names[3] = SCHEME_CAR(rename);
                         rename = SCHEME_CDR(rename);
                       }
@@ -2993,6 +3284,12 @@ static Scheme_Object *resolve_env(WRAP_POS *_wraps,
                       if (SCHEME_PAIRP(get_names[1])) {
                         get_names[4] = SCHEME_CDR(get_names[1]);
                         get_names[1] = SCHEME_CAR(get_names[1]);
+                        if (SCHEME_PAIRP(get_names[4])) {
+                          get_names[5] = SCHEME_CDR(get_names[4]);
+                          get_names[4] = SCHEME_CAR(get_names[4]);
+                        } else {
+                          get_names[5] = get_names[3];
+                        }
                       }
                       get_names[2] = SCHEME_CDDR(rename);
                     } else {
@@ -3017,9 +3314,12 @@ static Scheme_Object *resolve_env(WRAP_POS *_wraps,
                 }
                 if (!get_names[4]) {
                   GC_CAN_IGNORE Scheme_Object *pi;
-                  pi = scheme_make_integer(phase_to_index(mrn->phase));
+                  pi = phase_to_index(mrn->phase);
                   get_names[4] = pi;
                 }
+                if (!get_names[5]) {
+                  get_names[5] = get_names[3];
+                }
               }
 
               if (modidx_shift_from && !no_shift) {
@@ -3043,7 +3343,8 @@ static Scheme_Object *resolve_env(WRAP_POS *_wraps,
       Scheme_Object *vec, *n, *dest, *src;
       vec = SCHEME_PTR_VAL(WRAP_POS_FIRST(wraps));
       n = SCHEME_VEC_ELS(vec)[0];
-      phase -= SCHEME_INT_VAL(n);
+      if (SCHEME_TRUEP(phase))
+        phase = scheme_bin_minus(phase, n);
      
       src = SCHEME_VEC_ELS(vec)[1];
       dest = SCHEME_VEC_ELS(vec)[2];
@@ -3215,18 +3516,19 @@ static Scheme_Object *resolve_env(WRAP_POS *_wraps,
   }
 }
 
-static Scheme_Object *get_module_src_name(Scheme_Object *a, long phase)
+static Scheme_Object *get_module_src_name(Scheme_Object *a, Scheme_Object *orig_phase)
      /* Gets a module source name under the assumption that the identifier
 	is not lexically renamed. This is used as a quick pre-test for
 	free-identifier=?. */
 {
   WRAP_POS wraps;
-  Scheme_Object *result;
-  int is_in_module = 0, skip_other_mods = 0;
-  long orig_phase = phase;
+  Scheme_Object *result, *result_from;
+  int is_in_module = 0, skip_other_mods = 0, can_cache = 1;
+  Scheme_Object *phase = orig_phase;
   Scheme_Object *bdg = NULL;
 
-  if (((Scheme_Stx *)a)->u.modinfo_cache)
+  if (SAME_OBJ(phase, scheme_make_integer(0))
+      && ((Scheme_Stx *)a)->u.modinfo_cache)
     return ((Scheme_Stx *)a)->u.modinfo_cache;
 
   WRAP_POS_INIT(wraps, ((Scheme_Stx *)a)->wraps);
@@ -3235,23 +3537,50 @@ static Scheme_Object *get_module_src_name(Scheme_Object *a, long phase)
 
   while (1) {
     if (WRAP_POS_END_P(wraps)) {
+      if (result) 
+        can_cache = 1; /* If it becomes bound, it can't become unbound. */
+
       if (!result)
 	result = SCHEME_STX_VAL(a);
-
-      ((Scheme_Stx *)a)->u.modinfo_cache = result;
+      
+      if (can_cache && SAME_OBJ(orig_phase, scheme_make_integer(0)))
+        ((Scheme_Stx *)a)->u.modinfo_cache = result;
  
       return result;
-    } else if (SCHEME_RENAMESP(WRAP_POS_FIRST(wraps))) {
-      Module_Renames *mrn = (Module_Renames *)WRAP_POS_FIRST(wraps);
+    } else if (SCHEME_RENAMESP(WRAP_POS_FIRST(wraps))
+               || SCHEME_RENAMES_SETP(WRAP_POS_FIRST(wraps))) {
+      Module_Renames *mrn;
 
-      if ((!is_in_module || (mrn->kind != mzMOD_RENAME_TOPLEVEL)) && !skip_other_mods) {
+      if (SCHEME_RENAMESP(WRAP_POS_FIRST(wraps))) {
+        mrn = (Module_Renames *)WRAP_POS_FIRST(wraps);
+      } else {
+        /* Extract the relevant phase, if available */
+        Module_Renames_Set *mrns = (Module_Renames_Set *)WRAP_POS_FIRST(wraps);
+
+        if (mrns->kind != mzMOD_RENAME_TOPLEVEL)
+	  is_in_module = 1;
+        
+        if ((!is_in_module || (mrns->kind != mzMOD_RENAME_TOPLEVEL))
+            && !skip_other_mods) {
+          if (!mrns->sealed)
+            can_cache = 0;
+        }
+
+        mrn = extract_renames(mrns, phase);
+      }
+
+      if (mrn && (!is_in_module || (mrn->kind != mzMOD_RENAME_TOPLEVEL)) 
+          && !skip_other_mods) {
 	if (mrn->kind != mzMOD_RENAME_TOPLEVEL)
 	  is_in_module = 1;
-	
-	if (phase == mrn->phase) {
+
+	if (same_phase(phase, mrn->phase)) {
 	  /* Module rename: */
 	  Scheme_Object *rename, *glob_id;
 
+          if (!mrn->sealed)
+            can_cache = 0;
+          
 	  if (mrn->needs_unmarshal) {
 	    /* Use resolve_env to trigger unmarshal, so that we
 	       don't have to implement top/from shifts here: */
@@ -3263,7 +3592,7 @@ static Scheme_Object *get_module_src_name(Scheme_Object *a, long phase)
 	    if (!bdg)
 	      bdg = resolve_env(&wraps, a, orig_phase, 0, NULL, NULL);
 	    /* Remap id based on marks and rest-of-wraps resolution: */
-	    glob_id = scheme_tl_id_sym((Scheme_Env *)mrn->marked_names, a, bdg, 0);
+	    glob_id = scheme_tl_id_sym((Scheme_Env *)mrn->marked_names, a, bdg, 0, NULL);
 	  } else
 	    glob_id = SCHEME_STX_VAL(a);
 
@@ -3291,6 +3620,8 @@ static Scheme_Object *get_module_src_name(Scheme_Object *a, long phase)
 	      result = glob_id;
 	  } else
 	    result = NULL;
+
+          result_from = WRAP_POS_FIRST(wraps);
 	}
       }
     } else if (SCHEME_BOXP(WRAP_POS_FIRST(wraps))) {
@@ -3298,7 +3629,8 @@ static Scheme_Object *get_module_src_name(Scheme_Object *a, long phase)
       Scheme_Object *n, *vec;
       vec = SCHEME_PTR_VAL(WRAP_POS_FIRST(wraps));
       n = SCHEME_VEC_ELS(vec)[0];
-      phase -= SCHEME_INT_VAL(n);
+      if (SCHEME_TRUEP(phase))
+        phase = scheme_bin_minus(phase, n);
     }
     
     /* Keep looking: */
@@ -3306,17 +3638,19 @@ static Scheme_Object *get_module_src_name(Scheme_Object *a, long phase)
   }
 }
 
-int scheme_stx_module_eq(Scheme_Object *a, Scheme_Object *b, long phase)
+int scheme_stx_module_eq2(Scheme_Object *a, Scheme_Object *b, Scheme_Object *phase, Scheme_Object *asym)
 {
-  Scheme_Object *asym, *bsym;
+  Scheme_Object *bsym;
 
   if (!a || !b)
     return (a == b);
 
-  if (SCHEME_STXP(a))
-    asym = get_module_src_name(a, phase);
-  else
-    asym = a;
+  if (!asym) {
+    if (SCHEME_STXP(a))
+      asym = get_module_src_name(a, phase);
+    else
+      asym = a;
+  }
   if (SCHEME_STXP(b))
     bsym = get_module_src_name(b, phase);
   else
@@ -3341,20 +3675,36 @@ int scheme_stx_module_eq(Scheme_Object *a, Scheme_Object *b, long phase)
   return SAME_OBJ(a, b);
 }
 
-Scheme_Object *scheme_stx_module_name(Scheme_Object **a, long phase, 
+int scheme_stx_module_eq(Scheme_Object *a, Scheme_Object *b, long phase)
+{
+  return scheme_stx_module_eq2(a, b, scheme_make_integer(phase), NULL);
+}
+
+Scheme_Object *scheme_stx_get_module_eq_sym(Scheme_Object *a, Scheme_Object *phase)
+{
+  if (SCHEME_STXP(a))
+    return get_module_src_name(a, phase);
+  else
+    return a;
+}
+
+Scheme_Object *scheme_stx_module_name(Scheme_Object **a, Scheme_Object *phase, 
 				      Scheme_Object **nominal_modidx,
 				      Scheme_Object **nominal_name,
-				      int *mod_phase, int *src_phase_index)
+				      Scheme_Object **mod_phase, 
+                                      Scheme_Object **src_phase_index,
+                                      Scheme_Object **nominal_src_phase)
      /* If module bound, result is module idx, and a is set to source name.
 	If lexically bound, result is scheme_undefined and a is unchanged. 
 	If neither, result is NULL and a is unchanged. */
 {
   if (SCHEME_STXP(*a)) {
-    Scheme_Object *modname, *names[5];
+    Scheme_Object *modname, *names[6];
 
     names[0] = NULL;
     names[3] = scheme_make_integer(0);
     names[4] = NULL;
+    names[5] = NULL;
 
     modname = resolve_env(NULL, *a, phase, 1, names, NULL);
     
@@ -3368,9 +3718,11 @@ Scheme_Object *scheme_stx_module_name(Scheme_Object **a, long phase,
 	if (nominal_name)
 	  *nominal_name = names[2];
 	if (mod_phase)
-	  *mod_phase = SCHEME_INT_VAL(names[3]);
+	  *mod_phase = names[3];
         if (src_phase_index)
-	  *src_phase_index = SCHEME_INT_VAL(names[4]);
+	  *src_phase_index = names[4];
+	if (nominal_src_phase)
+	  *nominal_src_phase = names[5];
 	return modname;
       }
     } else
@@ -3379,7 +3731,7 @@ Scheme_Object *scheme_stx_module_name(Scheme_Object **a, long phase,
     return NULL;
 }
 
-Scheme_Object *scheme_stx_moduleless_env(Scheme_Object *a, long phase)
+Scheme_Object *scheme_stx_moduleless_env(Scheme_Object *a, Scheme_Object *phase)
   /* Returns either NULL or a lexical-rename symbol */
 {
   if (SCHEME_STXP(a)) {
@@ -3393,7 +3745,7 @@ Scheme_Object *scheme_stx_moduleless_env(Scheme_Object *a, long phase)
   return NULL;
 }
 
-int scheme_stx_env_bound_eq(Scheme_Object *a, Scheme_Object *b, Scheme_Object *uid, long phase)
+int scheme_stx_env_bound_eq(Scheme_Object *a, Scheme_Object *b, Scheme_Object *uid, Scheme_Object *phase)
      /* If uid is given, it's the environment for b. */
 {
   Scheme_Object *asym, *bsym, *ae, *be;
@@ -3441,7 +3793,7 @@ int scheme_stx_env_bound_eq(Scheme_Object *a, Scheme_Object *b, Scheme_Object *u
   return 1;
 }
 
-int scheme_stx_bound_eq(Scheme_Object *a, Scheme_Object *b, long phase)
+int scheme_stx_bound_eq(Scheme_Object *a, Scheme_Object *b, Scheme_Object *phase)
 {
   return scheme_stx_env_bound_eq(a, b, NULL, phase);
 }
@@ -3514,6 +3866,22 @@ int scheme_stx_parallel_is_used(Scheme_Object *sym, Scheme_Object *stx)
       
       if (scheme_tl_id_is_sym_used(mrn->marked_names, sym))
 	return 1;
+    } else if (SCHEME_RENAMES_SETP(WRAP_POS_FIRST(w))) {
+      Module_Renames_Set *mrns = (Module_Renames_Set *)WRAP_POS_FIRST(w);
+      int i;
+      
+      if (mrns->rt && scheme_tl_id_is_sym_used(mrns->rt->marked_names, sym))
+	return 1;
+      if (mrns->et && scheme_tl_id_is_sym_used(mrns->et->marked_names, sym))
+	return 1;
+
+      if (mrns->other_phases) {
+        for (i = 0; i < mrns->other_phases->size; i++) {
+          if (mrns->other_phases->vals[i])
+            scheme_tl_id_is_sym_used(((Module_Renames *)mrns->other_phases->vals[i])->marked_names, 
+                                     sym);
+        }
+      }
     }
     WRAP_POS_INC(w);
   }
@@ -4156,119 +4524,166 @@ static Scheme_Object *wraps_to_datum(Scheme_Object *w_in,
 	}
       }
       /* else empty simplified vector, which we drop */
-    } else if (SCHEME_RENAMESP(a)) {
-      Module_Renames *mrn = (Module_Renames *)a;
-      int redundant = 0;
+    } else if (SCHEME_RENAMESP(a)
+               || SCHEME_RENAMES_SETP(a)) {
+      int which = 0;
+
+      while (1) {
+        Module_Renames *mrn;
+        int redundant = 0;
       
-      if (mrn->kind == mzMOD_RENAME_MARKED) {
-	/* Not useful if there's no marked names. */
-	redundant = !mrn->marked_names->count;
-	if (!redundant) {
-	  /* Otherwise, watch out for multiple instances of the same rename: */
-	  WRAP_POS l;
-	  Scheme_Object *la;
+        if (SCHEME_RENAMESP(a))  {
+          if (!which) {
+            mrn = (Module_Renames *)a;
+            which++;
+          } else
+            break;
+        } else {
+          /* flatten sets */
+          Module_Renames_Set *s = (Module_Renames_Set *)a;
+          mrn = NULL;
+          while (!mrn 
+                 && (which - 2 < (s->other_phases
+                                  ? s->other_phases->size
+                                  : 0))) {
+            if (!which)
+              mrn = s->rt;
+            else if (which == 1)
+              mrn = s->et;
+            else
+              mrn = (Module_Renames *)s->other_phases->vals[which - 2];
+            which++;
+          }
+          if (!mrn
+              && (which - 2 >= (s->other_phases
+                                ? s->other_phases->size
+                                : 0)))
+            break;
+        }
+      
+        if (mrn) {
+          if (mrn->kind == mzMOD_RENAME_MARKED) {
+            /* Not useful if there's no marked names. */
+            redundant = !mrn->marked_names || !mrn->marked_names->count;
+            if (!redundant) {
+              /* Otherwise, watch out for multiple instances of the same rename: */
+              WRAP_POS l;
+              Scheme_Object *la;
 	
-	  WRAP_POS_COPY(l,w);
+              WRAP_POS_COPY(l,w);
 	  
-	  for (; !WRAP_POS_END_P(l); WRAP_POS_INC(l)) {
-	    la = WRAP_POS_FIRST(l);
-	    if (SAME_OBJ(a, la)) {
-	      redundant = 1;
-	      break;
-	    }
-	  }
-	}
-      } else {
-	/* Check for later [non]module rename at the same phase: */
-	long shift = 0;	
-	WRAP_POS l;
-	Scheme_Object *la;
-	
-	WRAP_POS_COPY(l,w);
-
-	for (; !WRAP_POS_END_P(l); WRAP_POS_INC(l)) {
-	  la = WRAP_POS_FIRST(l);
-	  if (SCHEME_RENAMESP(la)) {
-	    Module_Renames *lrn = (Module_Renames *)WRAP_POS_FIRST(l);
-	    if ((lrn->kind == mrn->kind)
-		&& ((lrn->phase + shift) == mrn->phase)) {
-	      /* mrn is redundant */
-	      redundant = 1;
-	      break;
-	    }
-	  } else if (SCHEME_BOXP(la)) {
-	    shift += SCHEME_INT_VAL(SCHEME_VEC_ELS(SCHEME_PTR_VAL(WRAP_POS_FIRST(l)))[0]);
-	  }
-	}
-      }
-
-      if (!redundant) {
-	if (just_simplify) {
-	  stack = CONS((Scheme_Object *)mrn, stack);
-	} else {
-	  if (mrn->kind == mzMOD_RENAME_TOPLEVEL) {
-	    stack = CONS(((mrn->phase == 0)
-			  ? scheme_true
-			  : scheme_false), 
-			 stack);
-	  } else {
-	    Scheme_Object *local_key;
-	  
-	    local_key = scheme_marshal_lookup(mt, (Scheme_Object *)mrn);
-	    if (!local_key) {
-	      /* Convert hash table to vector: */
-	      int i, j, count = 0;
-	      Scheme_Object *l;
-	    
-	      count = mrn->ht->count;
-
-	      l = scheme_make_vector(count * 2, NULL);
-	    
-	      for (i = mrn->ht->size, j = 0; i--; ) {
-		if (mrn->ht->vals[i]) {
-		  SCHEME_VEC_ELS(l)[j++] = mrn->ht->keys[i];
-		  SCHEME_VEC_ELS(l)[j++] = mrn->ht->vals[i];
-		}
-	      }
-
-	      if (mrn->marked_names && mrn->marked_names->count) {
-		Scheme_Object *d = scheme_null, *p;
-
-		for (i = mrn->marked_names->size; i--; ) {
-		  if (mrn->marked_names->vals[i]) {
-		    p = CONS(mrn->marked_names->keys[i],
-			     mrn->marked_names->vals[i]);
-		    d = CONS(p, d);
-		  }
-		}
-
-		l = CONS(l, d);
-	      } else
-		l = CONS(l, scheme_null);
-
-	      if (SCHEME_PAIRP(mrn->unmarshal_info))
-		l = CONS(mrn->unmarshal_info, l); 
-	      
-	      l = CONS((mrn->kind == mzMOD_RENAME_MARKED) ? scheme_true : scheme_false, l);
-	      l = CONS(scheme_make_integer(mrn->phase), l);
-	      if (mrn->plus_kernel) {
-		l = CONS(scheme_true,l);
-		/* FIXME: plus-kernel nominal omitted */
-	      }
-	    
-              local_key = scheme_marshal_lookup(mt, a);
-              if (local_key)
-                scheme_marshal_using_key(mt, a);
-              else {
-                local_key = scheme_marshal_wrap_set(mt, a, l);
+              for (; !WRAP_POS_END_P(l); WRAP_POS_INC(l)) {
+                la = WRAP_POS_FIRST(l);
+                if (SAME_OBJ(a, la)) {
+                  redundant = 1;
+                  break;
+                }
               }
-	    } else {
-              scheme_marshal_using_key(mt, (Scheme_Object *)mrn);
             }
-            stack = CONS(local_key, stack);
-	  }
-	}
-	stack_size++;
+          } else {
+            /* Check for later [non]module rename at the same phase: */
+            Scheme_Object *phase;
+            WRAP_POS l;
+            Scheme_Object *la;
+	
+            WRAP_POS_COPY(l,w);
+
+            phase = mrn->phase;
+
+            for (; !WRAP_POS_END_P(l); WRAP_POS_INC(l)) {
+              la = WRAP_POS_FIRST(l);
+              if (SCHEME_RENAMESP(la)) {
+                Module_Renames *lrn = (Module_Renames *)WRAP_POS_FIRST(l);
+                if ((lrn->kind == mrn->kind)
+                    && (same_phase(lrn->phase, phase))) {
+                  /* mrn is redundant */
+                  redundant = 1;
+                  break;
+                }
+              } else if (SCHEME_RENAMES_SETP(la)) {
+                Module_Renames_Set *s = (Module_Renames_Set *)WRAP_POS_FIRST(l);
+                if ((s->kind == mrn->kind)
+                    && extract_renames(s, phase)) {
+                  redundant = 1;
+                  break;
+                }
+              } else if (SCHEME_BOXP(la)) {
+                if (SCHEME_TRUEP(phase))
+                  phase = scheme_bin_minus(phase,
+                                           SCHEME_VEC_ELS(SCHEME_PTR_VAL(WRAP_POS_FIRST(l)))[0]);
+              }
+            }
+          }
+
+          if (!redundant) {
+            if (just_simplify) {
+              stack = CONS((Scheme_Object *)mrn, stack);
+            } else {
+              if (mrn->kind == mzMOD_RENAME_TOPLEVEL) {
+                if (same_phase(mrn->phase, scheme_make_integer(0)))
+                  stack = CONS(scheme_true, stack);
+                else
+                  stack = CONS(scheme_false, stack);
+              } else {
+                Scheme_Object *local_key;
+	  
+                local_key = scheme_marshal_lookup(mt, (Scheme_Object *)mrn);
+                if (!local_key) {
+                  /* Convert hash table to vector: */
+                  int i, j, count = 0;
+                  Scheme_Object *l;
+	    
+                  count = mrn->ht->count;
+
+                  l = scheme_make_vector(count * 2, NULL);
+	    
+                  for (i = mrn->ht->size, j = 0; i--; ) {
+                    if (mrn->ht->vals[i]) {
+                      SCHEME_VEC_ELS(l)[j++] = mrn->ht->keys[i];
+                      SCHEME_VEC_ELS(l)[j++] = mrn->ht->vals[i];
+                    }
+                  }
+
+                  if (mrn->marked_names && mrn->marked_names->count) {
+                    Scheme_Object *d = scheme_null, *p;
+
+                    for (i = mrn->marked_names->size; i--; ) {
+                      if (mrn->marked_names->vals[i]) {
+                        p = CONS(mrn->marked_names->keys[i],
+                                 mrn->marked_names->vals[i]);
+                        d = CONS(p, d);
+                      }
+                    }
+
+                    l = CONS(l, d);
+                  } else
+                    l = CONS(l, scheme_null);
+
+                  if (SCHEME_PAIRP(mrn->unmarshal_info))
+                    l = CONS(mrn->unmarshal_info, l); 
+	      
+                  l = CONS((mrn->kind == mzMOD_RENAME_MARKED) ? scheme_true : scheme_false, l);
+                  l = CONS(mrn->phase, l);
+                  if (mrn->plus_kernel) {
+                    l = CONS(scheme_true,l);
+                    /* FIXME: plus-kernel nominal omitted */
+                  }
+	    
+                  local_key = scheme_marshal_lookup(mt, a);
+                  if (local_key)
+                    scheme_marshal_using_key(mt, a);
+                  else {
+                    local_key = scheme_marshal_wrap_set(mt, a, l);
+                  }
+                } else {
+                  scheme_marshal_using_key(mt, (Scheme_Object *)mrn);
+                }
+                stack = CONS(local_key, stack);
+              }
+            }
+            stack_size++;
+          }
+        }
       }
     } else if (SCHEME_SYMBOLP(a)) {
       /* mark barrier */
@@ -4730,7 +5145,18 @@ static Scheme_Object *unmarshal_mark(Scheme_Object *_a, Scheme_Unmarshal_Tables
   return n;
 }
 
-#define return_NULL return NULL
+#if 0
+# define return_NULL return (printf("%d\n", __LINE__), NULL)
+#else
+# define return_NULL return NULL
+#endif
+
+static int ok_phase(Scheme_Object *o) {
+  return (SCHEME_INTP(o) || SCHEME_BIGNUMP(o) || SCHEME_FALSEP(o));
+}
+static int ok_phase_index(Scheme_Object *o) {
+  return ok_phase(o);
+}
 
 static Scheme_Object *datum_to_wraps(Scheme_Object *w,
                                      Scheme_Unmarshal_Tables *ut)
@@ -4820,20 +5246,21 @@ static Scheme_Object *datum_to_wraps(Scheme_Object *w,
       Module_Renames *mrn;
       Scheme_Object *p, *key;
       int plus_kernel, i, count, kind;
-      long phase;
+      Scheme_Object *phase;
       
       if (!SCHEME_PAIRP(a)) return_NULL;
       
       /* Convert list to rename table: */
       
-      if (SCHEME_BOOLP(SCHEME_CAR(a))) {
+      if (SAME_OBJ(SCHEME_CAR(a), scheme_true)) {
 	plus_kernel = 1;
 	a = SCHEME_CDR(a);
       } else
 	plus_kernel = 0;
 
       if (!SCHEME_PAIRP(a)) return_NULL;
-      phase = SCHEME_INT_VAL(SCHEME_CAR(a));
+      phase = SCHEME_CAR(a);
+      if (!ok_phase(phase)) return_NULL;
       a = SCHEME_CDR(a);
 
       if (!SCHEME_PAIRP(a)) return_NULL;
@@ -4868,25 +5295,19 @@ static Scheme_Object *datum_to_wraps(Scheme_Object *w,
 
           /* A phase/dimension index */
           p = SCHEME_CAR(mli);
-          if ((SCHEME_INT_VAL(p) < 0)
-              || (SCHEME_INT_VAL(p) > 2))
+          if (!ok_phase_index(p))
             return_NULL;
           
           p = SCHEME_CDR(mli);
-          if (SCHEME_INTP(p)) {
+          if (ok_phase_index(p)) {
             /* For a shared table: (cons k src-phase-index) */
-            if ((SCHEME_INT_VAL(p) < 0)
-                || (SCHEME_INT_VAL(p) > 3))
-              return_NULL;
           } else {
             mli = p;
             if (!SCHEME_PAIRP(mli)) return_NULL;
 
             /* For a shared table: (cons k src-phase-index) */
             p = SCHEME_CAR(mli);
-            if (!SCHEME_INTP(p)
-                || (SCHEME_INT_VAL(p) < 0)
-                || (SCHEME_INT_VAL(p) > 3))
+            if (!ok_phase_index(p))
               return_NULL;
             mli = SCHEME_CDR(mli);
 
@@ -4970,7 +5391,11 @@ static Scheme_Object *datum_to_wraps(Scheme_Object *w,
               if (!SAME_TYPE(SCHEME_TYPE(SCHEME_CAR(ap)), scheme_module_index_type))
                 return_NULL;
               ap = SCHEME_CDR(ap);
-              if ((SCHEME_INT_VAL(ap) < 0) || (SCHEME_INT_VAL(ap) > 3))
+              /* import_phase_plus_nominal_phase */
+              if (SCHEME_PAIRP(ap)) {
+                if (!ok_phase_index(SCHEME_CAR(ap))) return_NULL;
+                if (!ok_phase_index(SCHEME_CDR(ap))) return_NULL;
+              } else if (!ok_phase_index(ap))
                 return_NULL;
             } else
               return_NULL;
@@ -5060,29 +5485,21 @@ static Scheme_Object *datum_to_wraps(Scheme_Object *w,
 
       scheme_unmarshal_wrap_set(ut, local_key, (Scheme_Object *)mrn);
 
+      scheme_seal_module_rename((Scheme_Object *)mrn);
+
       a = (Scheme_Object *)mrn;
-    } else if (SAME_OBJ(a, scheme_true)) {
+    } else if (SAME_OBJ(a, scheme_true)
+               || SCHEME_FALSEP(a)) {
       /* current env rename */
       Scheme_Env *env;
 
       env = scheme_get_env(NULL);
-      if (!env->rename) {
-	Scheme_Object *rn;
-	rn = scheme_make_module_rename(0, mzMOD_RENAME_TOPLEVEL, NULL);
-	env->rename = rn;
-      }
-      a = env->rename;
-    } else if (SCHEME_FALSEP(a)) {
-      /* current exp-env rename */
-      Scheme_Env *env;
-      env = scheme_get_env(NULL);
-      scheme_prepare_exp_env(env);
-      if (!env->exp_env->rename) {
-	Scheme_Object *rn;
-	rn = scheme_make_module_rename(1, mzMOD_RENAME_TOPLEVEL, NULL);
-	env->exp_env->rename = rn;
-      }
-      a = env->exp_env->rename;
+      scheme_prepare_env_renames(env, mzMOD_RENAME_TOPLEVEL);
+      a = scheme_get_module_rename_from_set(env->rename_set, 
+                                            (SCHEME_FALSEP(a) 
+                                             ? scheme_make_integer(1) 
+                                             : scheme_make_integer(0)), 
+                                            1);
     } else if (SCHEME_SYMBOLP(a)) {
       /* mark barrier */
     } else {
@@ -6057,36 +6474,60 @@ static Scheme_Object *syntax_track_origin(int argc, Scheme_Object **argv)
 
 static Scheme_Object *bound_eq(int argc, Scheme_Object **argv)
 {
-  Scheme_Thread *p = scheme_current_thread;
+  Scheme_Object *phase;
 
   if (!SCHEME_STX_IDP(argv[0]))
     scheme_wrong_type("bound-identifier=?", "identifier syntax", 0, argc, argv);
   if (!SCHEME_STX_IDP(argv[1]))
     scheme_wrong_type("bound-identifier=?", "identifier syntax", 1, argc, argv);
 
-  return (scheme_stx_bound_eq(argv[0], argv[1],
-			      (p->current_local_env
-			       ? p->current_local_env->genv->phase
-			       : 0))
+  if (argc > 2) {
+    phase = argv[2];
+    if (!SCHEME_FALSEP(phase)
+        && !SCHEME_INTP(phase)
+        && !SCHEME_BIGNUMP(phase))
+      scheme_wrong_type("bound-identifier=?", "exact integer or #f", 2, argc, argv);
+  } else {
+    Scheme_Thread *p = scheme_current_thread;
+    phase = scheme_make_integer(p->current_local_env
+                                ? p->current_local_env->genv->phase
+                                : 0);
+  }
+
+  return (scheme_stx_bound_eq(argv[0], argv[1], phase)
 	  ? scheme_true
 	  : scheme_false);
 }
 
 static Scheme_Object *do_module_eq(const char *who, int delta, int argc, Scheme_Object **argv)
 {
-  Scheme_Thread *p = scheme_current_thread;
+  Scheme_Object *phase;
 
   if (!SCHEME_STX_IDP(argv[0]))
     scheme_wrong_type(who, "identifier syntax", 0, argc, argv);
   if (!SCHEME_STX_IDP(argv[1]))
     scheme_wrong_type(who, "identifier syntax", 1, argc, argv);
 
-  return (scheme_stx_module_eq(argv[0], argv[1],
-                               ((delta == MZ_LABEL_PHASE)
-                                ? MZ_LABEL_PHASE
-                                : (delta + (p->current_local_env
-                                            ? p->current_local_env->genv->phase
-                                            : 0))))
+  if (argc > 2) {
+    phase = argv[2];
+    if (!SCHEME_FALSEP(phase)
+        && !SCHEME_INTP(phase)
+        && !SCHEME_BIGNUMP(phase))
+      scheme_wrong_type(who, "exact integer or #f", 2, argc, argv);
+  } else {
+    Scheme_Thread *p = scheme_current_thread;
+    if (delta == MZ_LABEL_PHASE)
+      phase = scheme_false;
+    else {
+      long ph;
+      ph = (delta + (p->current_local_env
+                     ? p->current_local_env->genv->phase
+                     : 0));
+      phase = scheme_make_integer(ph);
+    }
+  }
+
+  return (scheme_stx_module_eq2(argv[0], argv[1], phase, NULL)
 	  ? scheme_true
 	  : scheme_false);
 }
@@ -6111,26 +6552,39 @@ static Scheme_Object *module_label_eq(int argc, Scheme_Object **argv)
   return do_module_eq("free-label-identifier=?", MZ_LABEL_PHASE, argc, argv);
 }
 
-static Scheme_Object *do_module_binding(char *name, int argc, Scheme_Object **argv, int dphase)
+static Scheme_Object *do_module_binding(char *name, int argc, Scheme_Object **argv, Scheme_Object *dphase)
 {
-  Scheme_Thread *p = scheme_current_thread;
-  Scheme_Object *a, *m, *nom_mod, *nom_a;
-  int mod_phase, src_phase_index;
+  Scheme_Object *a, *m, *nom_mod, *nom_a, *phase;
+  Scheme_Object *src_phase_index, *mod_phase, *nominal_src_phase;
 
   a = argv[0];
 
   if (!SCHEME_STXP(a) || !SCHEME_STX_SYMBOLP(a))
     scheme_wrong_type(name, "identifier syntax", 0, argc, argv);
 
+  if (argc > 1) {
+    phase = argv[1];
+    if (!SCHEME_FALSEP(phase)
+        && !SCHEME_INTP(phase)
+        && !SCHEME_BIGNUMP(phase))
+      scheme_wrong_type(name, "exact integer or #f", 1, argc, argv);
+  } else {
+    Scheme_Thread *p = scheme_current_thread;
+    phase = scheme_make_integer(p->current_local_env
+                                ? p->current_local_env->genv->phase
+                                : p->current_phase_shift);
+    if (SCHEME_FALSEP(dphase) || SCHEME_FALSEP(phase))
+      phase = scheme_false;
+    else
+      phase = scheme_bin_plus(dphase, phase);
+  }
+
   m = scheme_stx_module_name(&a, 
-                             ((dphase == MZ_LABEL_PHASE)
-                              ? MZ_LABEL_PHASE
-                              : (dphase + (p->current_local_env
-					   ? p->current_local_env->genv->phase
-					   : p->current_phase_shift))),
+                             phase,
 			     &nom_mod, &nom_a,
 			     &mod_phase,
-                             &src_phase_index);
+                             &src_phase_index,
+                             &nominal_src_phase);
 
   if (!m)
     return scheme_false;
@@ -6139,29 +6593,30 @@ static Scheme_Object *do_module_binding(char *name, int argc, Scheme_Object **ar
   } else
     return CONS(m, CONS(a, CONS(nom_mod, 
                                 CONS(nom_a, 
-                                     CONS(mod_phase ? scheme_true : scheme_false, 
-                                          CONS(scheme_phase_index_symbol(src_phase_index), 
-                                               scheme_null))))));
+                                     CONS(mod_phase,
+                                          CONS(src_phase_index, 
+                                               CONS(nominal_src_phase,
+                                                    scheme_null)))))));
 }
 
 static Scheme_Object *module_binding(int argc, Scheme_Object **argv)
 {
-  return do_module_binding("identifier-binding", argc, argv, 0);
+  return do_module_binding("identifier-binding", argc, argv, scheme_make_integer(0));
 }
 
 static Scheme_Object *module_trans_binding(int argc, Scheme_Object **argv)
 {
-  return do_module_binding("identifier-transformer-binding", argc, argv, 1);
+  return do_module_binding("identifier-transformer-binding", argc, argv, scheme_make_integer(1));
 }
 
 static Scheme_Object *module_templ_binding(int argc, Scheme_Object **argv)
 {
-  return do_module_binding("identifier-template-binding", argc, argv, -1);
+  return do_module_binding("identifier-template-binding", argc, argv, scheme_make_integer(-1));
 }
 
 static Scheme_Object *module_label_binding(int argc, Scheme_Object **argv)
 {
-  return do_module_binding("identifier-label-binding", argc, argv, MZ_LABEL_PHASE);
+  return do_module_binding("identifier-label-binding", argc, argv, scheme_false);
 }
 
 static Scheme_Object *syntax_src_module(int argc, Scheme_Object **argv)
@@ -6349,7 +6804,7 @@ static Scheme_Object *explode_wraps(Scheme_Object *wraps, Scheme_Hash_Table *ht)
         v = scheme_make_vector(7, NULL);
         o = scheme_intern_symbol("rename:");
         SCHEME_VEC_ELS(v)[0] = o;
-        SCHEME_VEC_ELS(v)[1] = scheme_make_integer(mrn->phase);
+        SCHEME_VEC_ELS(v)[1] = mrn->phase;
         SCHEME_VEC_ELS(v)[2] = (Scheme_Object *)mrn->ht;
         SCHEME_VEC_ELS(v)[3] = (mrn->nomarshal_ht ? (Scheme_Object *)mrn->nomarshal_ht : scheme_false);
         SCHEME_VEC_ELS(v)[4] = scheme_true; /* mrn->shared_pes; */
@@ -6412,6 +6867,7 @@ START_XFORM_SKIP;
 static void register_traversers(void)
 {
   GC_REG_TRAV(scheme_rename_table_type, mark_rename_table);
+  GC_REG_TRAV(scheme_rename_table_set_type, mark_rename_table_set);
   GC_REG_TRAV(scheme_rt_srcloc, mark_srcloc);
   GC_REG_TRAV(scheme_wrap_chunk_type, mark_wrapchunk);
   GC_REG_TRAV(scheme_certifications_type, mark_cert);
diff --git a/src/mzscheme/src/stypes.h b/src/mzscheme/src/stypes.h
index 8008657cba..c196f0e201 100644
--- a/src/mzscheme/src/stypes.h
+++ b/src/mzscheme/src/stypes.h
@@ -114,129 +114,130 @@ enum {
   scheme_case_lambda_sequence_type,     /* 96 */
   scheme_begin0_sequence_type,          /* 97 */
   scheme_rename_table_type,             /* 98 */
-  scheme_module_type,                   /* 99 */
-  scheme_svector_type,                  /* 100 */
-  scheme_lazy_macro_type,               /* 101 */
-  scheme_resolve_prefix_type,           /* 102 */
-  scheme_security_guard_type,           /* 103 */
-  scheme_indent_type,                   /* 104 */
-  scheme_udp_type,                      /* 105 */
-  scheme_udp_evt_type,                  /* 106 */
-  scheme_tcp_accept_evt_type,           /* 107 */
-  scheme_id_macro_type,                 /* 108 */
-  scheme_evt_set_type,                  /* 109 */
-  scheme_wrap_evt_type,                 /* 110 */
-  scheme_handle_evt_type,               /* 111 */
-  scheme_nack_guard_evt_type,           /* 112 */
-  scheme_semaphore_repost_type,         /* 113 */
-  scheme_channel_type,                  /* 114 */
-  scheme_channel_put_type,              /* 115 */
-  scheme_thread_resume_type,            /* 116 */
-  scheme_thread_suspend_type,           /* 117 */
-  scheme_thread_dead_type,              /* 118 */
-  scheme_poll_evt_type,                 /* 119 */
-  scheme_nack_evt_type,                 /* 120 */
-  scheme_module_registry_type,          /* 121 */
-  scheme_thread_set_type,               /* 122 */
-  scheme_string_converter_type,         /* 123 */
-  scheme_alarm_type,                    /* 124 */
-  scheme_thread_cell_type,              /* 125 */
-  scheme_channel_syncer_type,           /* 126 */
-  scheme_special_comment_type,          /* 127 */
-  scheme_write_evt_type,                /* 128 */
-  scheme_always_evt_type,               /* 129 */
-  scheme_never_evt_type,                /* 130 */
-  scheme_progress_evt_type,             /* 131 */
-  scheme_certifications_type,           /* 132 */
-  scheme_already_comp_type,             /* 133 */
-  scheme_readtable_type,                /* 134 */
-  scheme_intdef_context_type,           /* 135 */
-  scheme_lexical_rib_type,              /* 136 */
-  scheme_thread_cell_values_type,       /* 137 */
-  scheme_global_ref_type,               /* 138 */
-  scheme_cont_mark_chain_type,          /* 139 */
-  scheme_raw_pair_type,                 /* 140 */
-  scheme_prompt_type,                   /* 141 */
-  scheme_prompt_tag_type,               /* 142 */
-  scheme_expanded_syntax_type,          /* 143 */
-  scheme_delay_syntax_type,             /* 144 */
-  scheme_cust_box_type,                 /* 145 */
-  scheme_resolved_module_path_type,     /* 146 */
+  scheme_rename_table_set_type,         /* 99 */
+  scheme_module_type,                   /* 100 */
+  scheme_svector_type,                  /* 101 */
+  scheme_lazy_macro_type,               /* 102 */
+  scheme_resolve_prefix_type,           /* 103 */
+  scheme_security_guard_type,           /* 104 */
+  scheme_indent_type,                   /* 105 */
+  scheme_udp_type,                      /* 106 */
+  scheme_udp_evt_type,                  /* 107 */
+  scheme_tcp_accept_evt_type,           /* 108 */
+  scheme_id_macro_type,                 /* 109 */
+  scheme_evt_set_type,                  /* 110 */
+  scheme_wrap_evt_type,                 /* 111 */
+  scheme_handle_evt_type,               /* 112 */
+  scheme_nack_guard_evt_type,           /* 113 */
+  scheme_semaphore_repost_type,         /* 114 */
+  scheme_channel_type,                  /* 115 */
+  scheme_channel_put_type,              /* 116 */
+  scheme_thread_resume_type,            /* 117 */
+  scheme_thread_suspend_type,           /* 118 */
+  scheme_thread_dead_type,              /* 119 */
+  scheme_poll_evt_type,                 /* 120 */
+  scheme_nack_evt_type,                 /* 121 */
+  scheme_module_registry_type,          /* 122 */
+  scheme_thread_set_type,               /* 123 */
+  scheme_string_converter_type,         /* 124 */
+  scheme_alarm_type,                    /* 125 */
+  scheme_thread_cell_type,              /* 126 */
+  scheme_channel_syncer_type,           /* 127 */
+  scheme_special_comment_type,          /* 128 */
+  scheme_write_evt_type,                /* 129 */
+  scheme_always_evt_type,               /* 130 */
+  scheme_never_evt_type,                /* 131 */
+  scheme_progress_evt_type,             /* 132 */
+  scheme_certifications_type,           /* 133 */
+  scheme_already_comp_type,             /* 134 */
+  scheme_readtable_type,                /* 135 */
+  scheme_intdef_context_type,           /* 136 */
+  scheme_lexical_rib_type,              /* 137 */
+  scheme_thread_cell_values_type,       /* 138 */
+  scheme_global_ref_type,               /* 139 */
+  scheme_cont_mark_chain_type,          /* 140 */
+  scheme_raw_pair_type,                 /* 141 */
+  scheme_prompt_type,                   /* 142 */
+  scheme_prompt_tag_type,               /* 143 */
+  scheme_expanded_syntax_type,          /* 144 */
+  scheme_delay_syntax_type,             /* 145 */
+  scheme_cust_box_type,                 /* 146 */
+  scheme_resolved_module_path_type,     /* 147 */
+  scheme_module_phase_exports_type,     /* 148 */
 
 #ifdef MZTAG_REQUIRED
-  _scheme_last_normal_type_,            /* 147 */
+  _scheme_last_normal_type_,            /* 149 */
 
-  scheme_rt_weak_array,                 /* 148 */
+  scheme_rt_weak_array,                 /* 150 */
 
-  scheme_rt_comp_env,                   /* 149 */
-  scheme_rt_constant_binding,           /* 150 */
-  scheme_rt_resolve_info,               /* 151 */
-  scheme_rt_optimize_info,              /* 152 */
-  scheme_rt_compile_info,               /* 153 */
-  scheme_rt_cont_mark,                  /* 154 */
-  scheme_rt_saved_stack,                /* 155 */
-  scheme_rt_reply_item,                 /* 156 */
-  scheme_rt_closure_info,               /* 157 */
-  scheme_rt_overflow,                   /* 158 */
-  scheme_rt_overflow_jmp,               /* 159 */
-  scheme_rt_meta_cont,                  /* 160 */
-  scheme_rt_dyn_wind_cell,              /* 161 */
-  scheme_rt_dyn_wind_info,              /* 162 */
-  scheme_rt_dyn_wind,                   /* 163 */
-  scheme_rt_dup_check,                  /* 164 */
-  scheme_rt_thread_memory,              /* 165 */
-  scheme_rt_input_file,                 /* 166 */
-  scheme_rt_input_fd,                   /* 167 */
-  scheme_rt_oskit_console_input,        /* 168 */
-  scheme_rt_tested_input_file,          /* 169 */
-  scheme_rt_tested_output_file,         /* 170 */
-  scheme_rt_indexed_string,             /* 171 */
-  scheme_rt_output_file,                /* 172 */
-  scheme_rt_load_handler_data,          /* 173 */
-  scheme_rt_pipe,                       /* 174 */
-  scheme_rt_beos_process,               /* 175 */
-  scheme_rt_system_child,               /* 176 */
-  scheme_rt_tcp,                        /* 177 */
-  scheme_rt_write_data,                 /* 178 */
-  scheme_rt_tcp_select_info,            /* 179 */
-  scheme_rt_namespace_option,           /* 180 */
-  scheme_rt_param_data,                 /* 181 */
-  scheme_rt_will,                       /* 182 */
-  scheme_rt_will_registration,          /* 183 */
-  scheme_rt_struct_proc_info,           /* 184 */
-  scheme_rt_linker_name,                /* 185 */
-  scheme_rt_param_map,                  /* 186 */
-  scheme_rt_finalization,               /* 187 */
-  scheme_rt_finalizations,              /* 188 */
-  scheme_rt_cpp_object,                 /* 189 */
-  scheme_rt_cpp_array_object,           /* 190 */
-  scheme_rt_stack_object,               /* 191 */
-  scheme_rt_preallocated_object,        /* 192 */
-  scheme_thread_hop_type,               /* 193 */
-  scheme_rt_srcloc,                     /* 194 */
-  scheme_rt_evt,                        /* 195 */
-  scheme_rt_syncing,                    /* 196 */
-  scheme_rt_comp_prefix,                /* 197 */
-  scheme_rt_user_input,                 /* 198 */
-  scheme_rt_user_output,                /* 199 */
-  scheme_rt_compact_port,               /* 200 */
-  scheme_rt_read_special_dw,            /* 201 */
-  scheme_rt_regwork,                    /* 202 */
-  scheme_rt_buf_holder,                 /* 203 */
-  scheme_rt_parameterization,           /* 204 */
-  scheme_rt_print_params,               /* 205 */
-  scheme_rt_read_params,                /* 206 */
-  scheme_rt_native_code,                /* 207 */
-  scheme_rt_native_code_plus_case,      /* 208 */
-  scheme_rt_jitter_data,                /* 209 */
-  scheme_rt_module_exports,             /* 210 */
-  scheme_rt_module_phase_exports,       /* 211 */
-  scheme_rt_delay_load_info,            /* 212 */
-  scheme_rt_marshal_info,               /* 213 */
-  scheme_rt_unmarshal_info,             /* 214 */
-  scheme_rt_runstack,                   /* 215 */
-  scheme_rt_sfs_info,                   /* 216 */
-  scheme_rt_validate_clearing,          /* 217 */
+  scheme_rt_comp_env,                   /* 151 */
+  scheme_rt_constant_binding,           /* 152 */
+  scheme_rt_resolve_info,               /* 153 */
+  scheme_rt_optimize_info,              /* 154 */
+  scheme_rt_compile_info,               /* 155 */
+  scheme_rt_cont_mark,                  /* 156 */
+  scheme_rt_saved_stack,                /* 157 */
+  scheme_rt_reply_item,                 /* 158 */
+  scheme_rt_closure_info,               /* 159 */
+  scheme_rt_overflow,                   /* 160 */
+  scheme_rt_overflow_jmp,               /* 161 */
+  scheme_rt_meta_cont,                  /* 162 */
+  scheme_rt_dyn_wind_cell,              /* 163 */
+  scheme_rt_dyn_wind_info,              /* 164 */
+  scheme_rt_dyn_wind,                   /* 165 */
+  scheme_rt_dup_check,                  /* 166 */
+  scheme_rt_thread_memory,              /* 167 */
+  scheme_rt_input_file,                 /* 168 */
+  scheme_rt_input_fd,                   /* 169 */
+  scheme_rt_oskit_console_input,        /* 170 */
+  scheme_rt_tested_input_file,          /* 171 */
+  scheme_rt_tested_output_file,         /* 172 */
+  scheme_rt_indexed_string,             /* 173 */
+  scheme_rt_output_file,                /* 174 */
+  scheme_rt_load_handler_data,          /* 175 */
+  scheme_rt_pipe,                       /* 176 */
+  scheme_rt_beos_process,               /* 177 */
+  scheme_rt_system_child,               /* 178 */
+  scheme_rt_tcp,                        /* 179 */
+  scheme_rt_write_data,                 /* 180 */
+  scheme_rt_tcp_select_info,            /* 181 */
+  scheme_rt_namespace_option,           /* 182 */
+  scheme_rt_param_data,                 /* 183 */
+  scheme_rt_will,                       /* 184 */
+  scheme_rt_will_registration,          /* 185 */
+  scheme_rt_struct_proc_info,           /* 186 */
+  scheme_rt_linker_name,                /* 187 */
+  scheme_rt_param_map,                  /* 188 */
+  scheme_rt_finalization,               /* 189 */
+  scheme_rt_finalizations,              /* 190 */
+  scheme_rt_cpp_object,                 /* 191 */
+  scheme_rt_cpp_array_object,           /* 192 */
+  scheme_rt_stack_object,               /* 193 */
+  scheme_rt_preallocated_object,        /* 194 */
+  scheme_thread_hop_type,               /* 195 */
+  scheme_rt_srcloc,                     /* 196 */
+  scheme_rt_evt,                        /* 197 */
+  scheme_rt_syncing,                    /* 198 */
+  scheme_rt_comp_prefix,                /* 199 */
+  scheme_rt_user_input,                 /* 200 */
+  scheme_rt_user_output,                /* 201 */
+  scheme_rt_compact_port,               /* 202 */
+  scheme_rt_read_special_dw,            /* 203 */
+  scheme_rt_regwork,                    /* 204 */
+  scheme_rt_buf_holder,                 /* 205 */
+  scheme_rt_parameterization,           /* 206 */
+  scheme_rt_print_params,               /* 207 */
+  scheme_rt_read_params,                /* 208 */
+  scheme_rt_native_code,                /* 209 */
+  scheme_rt_native_code_plus_case,      /* 210 */
+  scheme_rt_jitter_data,                /* 211 */
+  scheme_rt_module_exports,             /* 212 */
+  scheme_rt_delay_load_info,            /* 213 */
+  scheme_rt_marshal_info,               /* 214 */
+  scheme_rt_unmarshal_info,             /* 215 */
+  scheme_rt_runstack,                   /* 216 */
+  scheme_rt_sfs_info,                   /* 217 */
+  scheme_rt_validate_clearing,          /* 218 */
 #endif
 
   _scheme_last_type_
diff --git a/src/mzscheme/src/syntax.c b/src/mzscheme/src/syntax.c
index eacc0f602e..fd337d4a07 100644
--- a/src/mzscheme/src/syntax.c
+++ b/src/mzscheme/src/syntax.c
@@ -1102,7 +1102,7 @@ defn_targets_syntax (Scheme_Object *var, Scheme_Comp_Env *env, Scheme_Compile_In
     Scheme_Object *name, *pr, *bucket;
 
     name = SCHEME_STX_CAR(var);
-    name = scheme_tl_id_sym(env->genv, name, NULL, 2);
+    name = scheme_tl_id_sym(env->genv, name, NULL, 2, NULL);
 
     if (rec[drec].resolve_module_ids || !env->genv->module) {
       bucket = (Scheme_Object *)scheme_global_bucket(name, env->genv);
@@ -4025,7 +4025,7 @@ gen_let_syntax (Scheme_Object *form, Scheme_Comp_Env *origenv, char *formname,
 
       for (j = pre_k; j < k; j++) {
 	for (m = j + 1; m < k; m++) {
-	  if (scheme_stx_bound_eq(names[m], names[j], env->genv->phase))
+	  if (scheme_stx_bound_eq(names[m], names[j], scheme_make_integer(env->genv->phase)))
 	    scheme_wrong_syntax(NULL, NULL, form,
 				"multiple bindings of `%S' in the same clause", 
 				SCHEME_STX_SYM(names[m]));
@@ -5285,7 +5285,7 @@ static Scheme_Object *stx_val(Scheme_Object *name, Scheme_Object *_env)
 {
   Scheme_Env *env = (Scheme_Env *)_env;
 
-  return scheme_tl_id_sym(env, name, NULL, 2);
+  return scheme_tl_id_sym(env, name, NULL, 2, NULL);
 }
 
 static Scheme_Object *
diff --git a/src/mzscheme/src/type.c b/src/mzscheme/src/type.c
index c7edb0ab45..62e0d3c99f 100644
--- a/src/mzscheme/src/type.c
+++ b/src/mzscheme/src/type.c
@@ -579,7 +579,7 @@ void scheme_register_traversers(void)
   GC_REG_TRAV(scheme_expanded_syntax_type, twoptr_obj);
   GC_REG_TRAV(scheme_module_type, module_val);
   GC_REG_TRAV(scheme_rt_module_exports, module_exports_val);
-  GC_REG_TRAV(scheme_rt_module_phase_exports, module_phase_exports_val);
+  GC_REG_TRAV(scheme_module_phase_exports_type, module_phase_exports_val);
   GC_REG_TRAV(scheme_module_index_type, modidx_val);
 
   GC_REG_TRAV(scheme_security_guard_type, guard_val);