gistfile1.txt

`(
(start #f)
(visit
 ,(datum->syntax
   #f
   '(module anonymous-module typed/racket (#%module-begin "hello world"))))
(start #f)
(enter-check
 ,(datum->syntax
   #f
   '(module anonymous-module typed/racket (#%module-begin "hello world"))))
(exit-check
 ,(datum->syntax
   #f
   '(module anonymous-module typed/racket (#%module-begin "hello world"))))
(top-non-begin #f)
(start #f)
(visit
 ,(datum->syntax
   #f
   '(module anonymous-module typed/racket (#%module-begin "hello world"))))
(resolve ,(datum->syntax #f 'module))
(enter-prim
 ,(datum->syntax
   #f
   '(module anonymous-module typed/racket (#%module-begin "hello world"))))
(prim-module #f)
(prepare-env #f)
(rename-one ,(datum->syntax #f '(#%module-begin "hello world")))
(enter-check ,(datum->syntax #f '(#%module-begin "hello world")))
(visit ,(datum->syntax #f '(#%module-begin "hello world")))
(resolve ,(datum->syntax #f '#%module-begin))
(enter-macro ,(datum->syntax #f '(#%module-begin "hello world")))
(macro-pre-transform ,(datum->syntax #f '(#%module-begin "hello world")))
(enter-local ,(datum->syntax #f '(#%plain-module-begin "hello world")))
(local-pre ,(datum->syntax #f '(#%plain-module-begin "hello world")))
(start #f)
(visit ,(datum->syntax #f '(#%plain-module-begin "hello world")))
(resolve ,(datum->syntax #f '#%plain-module-begin))
(enter-prim ,(datum->syntax #f '(#%plain-module-begin "hello world")))
(prim-#%module-begin #f)
(rename-one ,(datum->syntax #f '(#%plain-module-begin "hello world")))
(next #f)
(visit ,(datum->syntax #f '"hello world"))
(resolve ,(datum->syntax #f '#%datum))
(tag ,(datum->syntax #f '(#%datum . "hello world")))
(enter-prim ,(datum->syntax #f '(#%datum . "hello world")))
(prim-#%datum #f)
(exit-prim ,(datum->syntax #f ''"hello world"))
(return ,(datum->syntax #f ''"hello world"))
(rename-one ,(datum->syntax #f ''"hello world"))
(lift-end-loop ())
(next-group #f)
(next #f)
(visit ,(datum->syntax #f ''"hello world"))
(resolve ,(datum->syntax #f 'quote))
(enter-prim ,(datum->syntax #f ''"hello world"))
(prim-quote #f)
(exit-prim ,(datum->syntax #f ''"hello world"))
(return ,(datum->syntax #f ''"hello world"))
(lift-end-loop ())
(next-group #f)
(next #f)
(exit-prim ,(datum->syntax #f '(#%plain-module-begin '"hello world")))
(return ,(datum->syntax #f '(#%plain-module-begin '"hello world")))
(local-post ,(datum->syntax #f '(#%plain-module-begin '"hello world")))
(exit-local ,(datum->syntax #f '(#%plain-module-begin '"hello world")))
(track-origin
 (,(datum->syntax
    #f
    '(begin-for-syntax
      (module*
       #%type-decl
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require typed-racket/types/numeric-tower
                 typed-racket/env/type-name-env
                 typed-racket/env/global-env
                 typed-racket/env/type-alias-env
                 typed-racket/types/struct-table
                 typed-racket/types/abbrev
                 (rename-in racket/private/sort (sort raw-sort)))
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)))))
  unquote
  (datum->syntax
   #f
   '(begin-for-syntax
     (module*
      #%type-decl
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require typed-racket/types/numeric-tower
                typed-racket/env/type-name-env
                typed-racket/env/global-env
                typed-racket/env/type-alias-env
                typed-racket/types/struct-table
                typed-racket/types/abbrev
                (rename-in racket/private/sort (sort raw-sort)))
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)))))))
(track-origin
 (,(datum->syntax
    #f
    '(begin-for-syntax
      (add-mod!
       (variable-reference->module-path-index (#%variable-reference)))))
  unquote
  (datum->syntax
   #f
   '(begin-for-syntax
     (add-mod!
      (variable-reference->module-path-index (#%variable-reference)))))))
(track-origin
 (,(datum->syntax #f '(define blame1 (quote-module-name)))
  unquote
  (datum->syntax #f '(define blame1 (quote-module-name)))))
(track-origin
 (,(datum->syntax
    #f
    '(begin-for-syntax
      (require typed-racket/utils/redirect-contract)
      (module #%contract-defs-reference racket/base
        (require racket/runtime-path (for-syntax racket/base))
        (define-runtime-module-path-index
         contract-defs-submod
         '(submod ".." #%contract-defs))
        (provide contract-defs-submod))
      (require (submod "." #%contract-defs-reference))
      (define make-redirect2
        (make-make-redirect-to-contract contract-defs-submod))))
  unquote
  (datum->syntax
   #f
   '(begin-for-syntax
     (require typed-racket/utils/redirect-contract)
     (module #%contract-defs-reference racket/base
       (require racket/runtime-path (for-syntax racket/base))
       (define-runtime-module-path-index
        contract-defs-submod
        '(submod ".." #%contract-defs))
       (provide contract-defs-submod))
     (require (submod "." #%contract-defs-reference))
     (define make-redirect2
       (make-make-redirect-to-contract contract-defs-submod))))))
(track-origin
 (,(datum->syntax
    #f
    '(module*
      #%contract-defs
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require (submod typed-racket/private/type-contract predicates)
                typed-racket/utils/utils
                (for-syntax typed-racket/utils/utils)
                typed-racket/utils/any-wrap
                typed-racket/utils/struct-type-c
                typed-racket/utils/opaque-object
                typed-racket/utils/evt-contract
                typed-racket/utils/sealing-contract
                racket/sequence
                racket/contract/parametric))))
  unquote
  (datum->syntax
   #f
   '(module*
     #%contract-defs
     #f
     (#%plain-module-begin
      (#%declare #:empty-namespace)
      (require (submod typed-racket/private/type-contract predicates)
               typed-racket/utils/utils
               (for-syntax typed-racket/utils/utils)
               typed-racket/utils/any-wrap
               typed-racket/utils/struct-type-c
               typed-racket/utils/opaque-object
               typed-racket/utils/evt-contract
               typed-racket/utils/sealing-contract
               racket/sequence
               racket/contract/parametric))))))
(track-origin
 (,(datum->syntax #f '(#%declare #:empty-namespace))
  unquote
  (datum->syntax #f '(#%declare #:empty-namespace))))
(track-origin
 (,(datum->syntax
    #f
    '(require (submod typed-racket/private/type-contract predicates)
              typed-racket/utils/utils
              (for-syntax typed-racket/utils/utils)
              typed-racket/utils/any-wrap
              typed-racket/utils/struct-type-c
              typed-racket/utils/opaque-object
              typed-racket/utils/evt-contract
              typed-racket/utils/sealing-contract
              racket/sequence
              racket/contract/parametric))
  unquote
  (datum->syntax
   #f
   '(require (submod typed-racket/private/type-contract predicates)
             typed-racket/utils/utils
             (for-syntax typed-racket/utils/utils)
             typed-racket/utils/any-wrap
             typed-racket/utils/struct-type-c
             typed-racket/utils/opaque-object
             typed-racket/utils/evt-contract
             typed-racket/utils/sealing-contract
             racket/sequence
             racket/contract/parametric))))
(macro-post-transform
 (,(datum->syntax
    #f
    '(#%module-begin
      (begin)
      (begin-for-syntax
       (module*
        #%type-decl
        #f
        (#%plain-module-begin
         (#%declare #:empty-namespace)
         (require typed-racket/types/numeric-tower
                  typed-racket/env/type-name-env
                  typed-racket/env/global-env
                  typed-racket/env/type-alias-env
                  typed-racket/types/struct-table
                  typed-racket/types/abbrev
                  (rename-in racket/private/sort (sort raw-sort)))
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin))))
      (begin-for-syntax
       (add-mod!
        (variable-reference->module-path-index (#%variable-reference))))
      (define blame1 (quote-module-name))
      (begin-for-syntax
       (require typed-racket/utils/redirect-contract)
       (module #%contract-defs-reference racket/base
         (require racket/runtime-path (for-syntax racket/base))
         (define-runtime-module-path-index
          contract-defs-submod
          '(submod ".." #%contract-defs))
         (provide contract-defs-submod))
       (require (submod "." #%contract-defs-reference))
       (define make-redirect2
         (make-make-redirect-to-contract contract-defs-submod)))
      (module*
       #%contract-defs
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require (submod typed-racket/private/type-contract predicates)
                 typed-racket/utils/utils
                 (for-syntax typed-racket/utils/utils)
                 typed-racket/utils/any-wrap
                 typed-racket/utils/struct-type-c
                 typed-racket/utils/opaque-object
                 typed-racket/utils/evt-contract
                 typed-racket/utils/sealing-contract
                 racket/sequence
                 racket/contract/parametric)))
      '"hello world"
      (void)))
  unquote
  (datum->syntax #f '(#%module-begin "hello world"))))
(exit-macro
 ,(datum->syntax
   #f
   '(#%module-begin
     (begin)
     (begin-for-syntax
      (module*
       #%type-decl
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require typed-racket/types/numeric-tower
                 typed-racket/env/type-name-env
                 typed-racket/env/global-env
                 typed-racket/env/type-alias-env
                 typed-racket/types/struct-table
                 typed-racket/types/abbrev
                 (rename-in racket/private/sort (sort raw-sort)))
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin))))
     (begin-for-syntax
      (add-mod!
       (variable-reference->module-path-index (#%variable-reference))))
     (define blame1 (quote-module-name))
     (begin-for-syntax
      (require typed-racket/utils/redirect-contract)
      (module #%contract-defs-reference racket/base
        (require racket/runtime-path (for-syntax racket/base))
        (define-runtime-module-path-index
         contract-defs-submod
         '(submod ".." #%contract-defs))
        (provide contract-defs-submod))
      (require (submod "." #%contract-defs-reference))
      (define make-redirect2
        (make-make-redirect-to-contract contract-defs-submod)))
     (module*
      #%contract-defs
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require (submod typed-racket/private/type-contract predicates)
                typed-racket/utils/utils
                (for-syntax typed-racket/utils/utils)
                typed-racket/utils/any-wrap
                typed-racket/utils/struct-type-c
                typed-racket/utils/opaque-object
                typed-racket/utils/evt-contract
                typed-racket/utils/sealing-contract
                racket/sequence
                racket/contract/parametric)))
     '"hello world"
     (void))))
(return
 ,(datum->syntax
   #f
   '(#%module-begin
     (begin)
     (begin-for-syntax
      (module*
       #%type-decl
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require typed-racket/types/numeric-tower
                 typed-racket/env/type-name-env
                 typed-racket/env/global-env
                 typed-racket/env/type-alias-env
                 typed-racket/types/struct-table
                 typed-racket/types/abbrev
                 (rename-in racket/private/sort (sort raw-sort)))
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin))))
     (begin-for-syntax
      (add-mod!
       (variable-reference->module-path-index (#%variable-reference))))
     (define blame1 (quote-module-name))
     (begin-for-syntax
      (require typed-racket/utils/redirect-contract)
      (module #%contract-defs-reference racket/base
        (require racket/runtime-path (for-syntax racket/base))
        (define-runtime-module-path-index
         contract-defs-submod
         '(submod ".." #%contract-defs))
        (provide contract-defs-submod))
      (require (submod "." #%contract-defs-reference))
      (define make-redirect2
        (make-make-redirect-to-contract contract-defs-submod)))
     (module*
      #%contract-defs
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require (submod typed-racket/private/type-contract predicates)
                typed-racket/utils/utils
                (for-syntax typed-racket/utils/utils)
                typed-racket/utils/any-wrap
                typed-racket/utils/struct-type-c
                typed-racket/utils/opaque-object
                typed-racket/utils/evt-contract
                typed-racket/utils/sealing-contract
                racket/sequence
                racket/contract/parametric)))
     '"hello world"
     (void))))
(visit
 ,(datum->syntax
   #f
   '(#%module-begin
     (begin)
     (begin-for-syntax
      (module*
       #%type-decl
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require typed-racket/types/numeric-tower
                 typed-racket/env/type-name-env
                 typed-racket/env/global-env
                 typed-racket/env/type-alias-env
                 typed-racket/types/struct-table
                 typed-racket/types/abbrev
                 (rename-in racket/private/sort (sort raw-sort)))
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin))))
     (begin-for-syntax
      (add-mod!
       (variable-reference->module-path-index (#%variable-reference))))
     (define blame1 (quote-module-name))
     (begin-for-syntax
      (require typed-racket/utils/redirect-contract)
      (module #%contract-defs-reference racket/base
        (require racket/runtime-path (for-syntax racket/base))
        (define-runtime-module-path-index
         contract-defs-submod
         '(submod ".." #%contract-defs))
        (provide contract-defs-submod))
      (require (submod "." #%contract-defs-reference))
      (define make-redirect2
        (make-make-redirect-to-contract contract-defs-submod)))
     (module*
      #%contract-defs
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require (submod typed-racket/private/type-contract predicates)
                typed-racket/utils/utils
                (for-syntax typed-racket/utils/utils)
                typed-racket/utils/any-wrap
                typed-racket/utils/struct-type-c
                typed-racket/utils/opaque-object
                typed-racket/utils/evt-contract
                typed-racket/utils/sealing-contract
                racket/sequence
                racket/contract/parametric)))
     '"hello world"
     (void))))
(resolve ,(datum->syntax #f '#%module-begin))
(enter-macro
 ,(datum->syntax
   #f
   '(#%module-begin
     (begin)
     (begin-for-syntax
      (module*
       #%type-decl
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require typed-racket/types/numeric-tower
                 typed-racket/env/type-name-env
                 typed-racket/env/global-env
                 typed-racket/env/type-alias-env
                 typed-racket/types/struct-table
                 typed-racket/types/abbrev
                 (rename-in racket/private/sort (sort raw-sort)))
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin))))
     (begin-for-syntax
      (add-mod!
       (variable-reference->module-path-index (#%variable-reference))))
     (define blame1 (quote-module-name))
     (begin-for-syntax
      (require typed-racket/utils/redirect-contract)
      (module #%contract-defs-reference racket/base
        (require racket/runtime-path (for-syntax racket/base))
        (define-runtime-module-path-index
         contract-defs-submod
         '(submod ".." #%contract-defs))
        (provide contract-defs-submod))
      (require (submod "." #%contract-defs-reference))
      (define make-redirect2
        (make-make-redirect-to-contract contract-defs-submod)))
     (module*
      #%contract-defs
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require (submod typed-racket/private/type-contract predicates)
                typed-racket/utils/utils
                (for-syntax typed-racket/utils/utils)
                typed-racket/utils/any-wrap
                typed-racket/utils/struct-type-c
                typed-racket/utils/opaque-object
                typed-racket/utils/evt-contract
                typed-racket/utils/sealing-contract
                racket/sequence
                racket/contract/parametric)))
     '"hello world"
     (void))))
(macro-pre-transform
 ,(datum->syntax
   #f
   '(#%module-begin
     (begin)
     (begin-for-syntax
      (module*
       #%type-decl
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require typed-racket/types/numeric-tower
                 typed-racket/env/type-name-env
                 typed-racket/env/global-env
                 typed-racket/env/type-alias-env
                 typed-racket/types/struct-table
                 typed-racket/types/abbrev
                 (rename-in racket/private/sort (sort raw-sort)))
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin))))
     (begin-for-syntax
      (add-mod!
       (variable-reference->module-path-index (#%variable-reference))))
     (define blame1 (quote-module-name))
     (begin-for-syntax
      (require typed-racket/utils/redirect-contract)
      (module #%contract-defs-reference racket/base
        (require racket/runtime-path (for-syntax racket/base))
        (define-runtime-module-path-index
         contract-defs-submod
         '(submod ".." #%contract-defs))
        (provide contract-defs-submod))
      (require (submod "." #%contract-defs-reference))
      (define make-redirect2
        (make-make-redirect-to-contract contract-defs-submod)))
     (module*
      #%contract-defs
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require (submod typed-racket/private/type-contract predicates)
                typed-racket/utils/utils
                (for-syntax typed-racket/utils/utils)
                typed-racket/utils/any-wrap
                typed-racket/utils/struct-type-c
                typed-racket/utils/opaque-object
                typed-racket/utils/evt-contract
                typed-racket/utils/sealing-contract
                racket/sequence
                racket/contract/parametric)))
     '"hello world"
     (void))))
(macro-post-transform
 (,(datum->syntax
    #f
    '(printing:module-begin
      (module configure-runtime '#%kernel
        (#%require racket/runtime-config)
        (configure #f))
      (begin)
      (begin-for-syntax
       (module*
        #%type-decl
        #f
        (#%plain-module-begin
         (#%declare #:empty-namespace)
         (require typed-racket/types/numeric-tower
                  typed-racket/env/type-name-env
                  typed-racket/env/global-env
                  typed-racket/env/type-alias-env
                  typed-racket/types/struct-table
                  typed-racket/types/abbrev
                  (rename-in racket/private/sort (sort raw-sort)))
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin))))
      (begin-for-syntax
       (add-mod!
        (variable-reference->module-path-index (#%variable-reference))))
      (define blame1 (quote-module-name))
      (begin-for-syntax
       (require typed-racket/utils/redirect-contract)
       (module #%contract-defs-reference racket/base
         (require racket/runtime-path (for-syntax racket/base))
         (define-runtime-module-path-index
          contract-defs-submod
          '(submod ".." #%contract-defs))
         (provide contract-defs-submod))
       (require (submod "." #%contract-defs-reference))
       (define make-redirect2
         (make-make-redirect-to-contract contract-defs-submod)))
      (module*
       #%contract-defs
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require (submod typed-racket/private/type-contract predicates)
                 typed-racket/utils/utils
                 (for-syntax typed-racket/utils/utils)
                 typed-racket/utils/any-wrap
                 typed-racket/utils/struct-type-c
                 typed-racket/utils/opaque-object
                 typed-racket/utils/evt-contract
                 typed-racket/utils/sealing-contract
                 racket/sequence
                 racket/contract/parametric)))
      '"hello world"
      (void)))
  unquote
  (datum->syntax
   #f
   '(#%module-begin
     (begin)
     (begin-for-syntax
      (module*
       #%type-decl
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require typed-racket/types/numeric-tower
                 typed-racket/env/type-name-env
                 typed-racket/env/global-env
                 typed-racket/env/type-alias-env
                 typed-racket/types/struct-table
                 typed-racket/types/abbrev
                 (rename-in racket/private/sort (sort raw-sort)))
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin))))
     (begin-for-syntax
      (add-mod!
       (variable-reference->module-path-index (#%variable-reference))))
     (define blame1 (quote-module-name))
     (begin-for-syntax
      (require typed-racket/utils/redirect-contract)
      (module #%contract-defs-reference racket/base
        (require racket/runtime-path (for-syntax racket/base))
        (define-runtime-module-path-index
         contract-defs-submod
         '(submod ".." #%contract-defs))
        (provide contract-defs-submod))
      (require (submod "." #%contract-defs-reference))
      (define make-redirect2
        (make-make-redirect-to-contract contract-defs-submod)))
     (module*
      #%contract-defs
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require (submod typed-racket/private/type-contract predicates)
                typed-racket/utils/utils
                (for-syntax typed-racket/utils/utils)
                typed-racket/utils/any-wrap
                typed-racket/utils/struct-type-c
                typed-racket/utils/opaque-object
                typed-racket/utils/evt-contract
                typed-racket/utils/sealing-contract
                racket/sequence
                racket/contract/parametric)))
     '"hello world"
     (void)))))
(exit-macro
 ,(datum->syntax
   #f
   '(printing:module-begin
     (module configure-runtime '#%kernel
       (#%require racket/runtime-config)
       (configure #f))
     (begin)
     (begin-for-syntax
      (module*
       #%type-decl
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require typed-racket/types/numeric-tower
                 typed-racket/env/type-name-env
                 typed-racket/env/global-env
                 typed-racket/env/type-alias-env
                 typed-racket/types/struct-table
                 typed-racket/types/abbrev
                 (rename-in racket/private/sort (sort raw-sort)))
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin))))
     (begin-for-syntax
      (add-mod!
       (variable-reference->module-path-index (#%variable-reference))))
     (define blame1 (quote-module-name))
     (begin-for-syntax
      (require typed-racket/utils/redirect-contract)
      (module #%contract-defs-reference racket/base
        (require racket/runtime-path (for-syntax racket/base))
        (define-runtime-module-path-index
         contract-defs-submod
         '(submod ".." #%contract-defs))
        (provide contract-defs-submod))
      (require (submod "." #%contract-defs-reference))
      (define make-redirect2
        (make-make-redirect-to-contract contract-defs-submod)))
     (module*
      #%contract-defs
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require (submod typed-racket/private/type-contract predicates)
                typed-racket/utils/utils
                (for-syntax typed-racket/utils/utils)
                typed-racket/utils/any-wrap
                typed-racket/utils/struct-type-c
                typed-racket/utils/opaque-object
                typed-racket/utils/evt-contract
                typed-racket/utils/sealing-contract
                racket/sequence
                racket/contract/parametric)))
     '"hello world"
     (void))))
(return
 ,(datum->syntax
   #f
   '(printing:module-begin
     (module configure-runtime '#%kernel
       (#%require racket/runtime-config)
       (configure #f))
     (begin)
     (begin-for-syntax
      (module*
       #%type-decl
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require typed-racket/types/numeric-tower
                 typed-racket/env/type-name-env
                 typed-racket/env/global-env
                 typed-racket/env/type-alias-env
                 typed-racket/types/struct-table
                 typed-racket/types/abbrev
                 (rename-in racket/private/sort (sort raw-sort)))
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin))))
     (begin-for-syntax
      (add-mod!
       (variable-reference->module-path-index (#%variable-reference))))
     (define blame1 (quote-module-name))
     (begin-for-syntax
      (require typed-racket/utils/redirect-contract)
      (module #%contract-defs-reference racket/base
        (require racket/runtime-path (for-syntax racket/base))
        (define-runtime-module-path-index
         contract-defs-submod
         '(submod ".." #%contract-defs))
        (provide contract-defs-submod))
      (require (submod "." #%contract-defs-reference))
      (define make-redirect2
        (make-make-redirect-to-contract contract-defs-submod)))
     (module*
      #%contract-defs
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require (submod typed-racket/private/type-contract predicates)
                typed-racket/utils/utils
                (for-syntax typed-racket/utils/utils)
                typed-racket/utils/any-wrap
                typed-racket/utils/struct-type-c
                typed-racket/utils/opaque-object
                typed-racket/utils/evt-contract
                typed-racket/utils/sealing-contract
                racket/sequence
                racket/contract/parametric)))
     '"hello world"
     (void))))
(visit
 ,(datum->syntax
   #f
   '(printing:module-begin
     (module configure-runtime '#%kernel
       (#%require racket/runtime-config)
       (configure #f))
     (begin)
     (begin-for-syntax
      (module*
       #%type-decl
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require typed-racket/types/numeric-tower
                 typed-racket/env/type-name-env
                 typed-racket/env/global-env
                 typed-racket/env/type-alias-env
                 typed-racket/types/struct-table
                 typed-racket/types/abbrev
                 (rename-in racket/private/sort (sort raw-sort)))
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin))))
     (begin-for-syntax
      (add-mod!
       (variable-reference->module-path-index (#%variable-reference))))
     (define blame1 (quote-module-name))
     (begin-for-syntax
      (require typed-racket/utils/redirect-contract)
      (module #%contract-defs-reference racket/base
        (require racket/runtime-path (for-syntax racket/base))
        (define-runtime-module-path-index
         contract-defs-submod
         '(submod ".." #%contract-defs))
        (provide contract-defs-submod))
      (require (submod "." #%contract-defs-reference))
      (define make-redirect2
        (make-make-redirect-to-contract contract-defs-submod)))
     (module*
      #%contract-defs
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require (submod typed-racket/private/type-contract predicates)
                typed-racket/utils/utils
                (for-syntax typed-racket/utils/utils)
                typed-racket/utils/any-wrap
                typed-racket/utils/struct-type-c
                typed-racket/utils/opaque-object
                typed-racket/utils/evt-contract
                typed-racket/utils/sealing-contract
                racket/sequence
                racket/contract/parametric)))
     '"hello world"
     (void))))
(resolve ,(datum->syntax #f 'printing:module-begin))
(enter-macro
 ,(datum->syntax
   #f
   '(printing:module-begin
     (module configure-runtime '#%kernel
       (#%require racket/runtime-config)
       (configure #f))
     (begin)
     (begin-for-syntax
      (module*
       #%type-decl
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require typed-racket/types/numeric-tower
                 typed-racket/env/type-name-env
                 typed-racket/env/global-env
                 typed-racket/env/type-alias-env
                 typed-racket/types/struct-table
                 typed-racket/types/abbrev
                 (rename-in racket/private/sort (sort raw-sort)))
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin))))
     (begin-for-syntax
      (add-mod!
       (variable-reference->module-path-index (#%variable-reference))))
     (define blame1 (quote-module-name))
     (begin-for-syntax
      (require typed-racket/utils/redirect-contract)
      (module #%contract-defs-reference racket/base
        (require racket/runtime-path (for-syntax racket/base))
        (define-runtime-module-path-index
         contract-defs-submod
         '(submod ".." #%contract-defs))
        (provide contract-defs-submod))
      (require (submod "." #%contract-defs-reference))
      (define make-redirect2
        (make-make-redirect-to-contract contract-defs-submod)))
     (module*
      #%contract-defs
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require (submod typed-racket/private/type-contract predicates)
                typed-racket/utils/utils
                (for-syntax typed-racket/utils/utils)
                typed-racket/utils/any-wrap
                typed-racket/utils/struct-type-c
                typed-racket/utils/opaque-object
                typed-racket/utils/evt-contract
                typed-racket/utils/sealing-contract
                racket/sequence
                racket/contract/parametric)))
     '"hello world"
     (void))))
(macro-pre-transform
 ,(datum->syntax
   #f
   '(printing:module-begin
     (module configure-runtime '#%kernel
       (#%require racket/runtime-config)
       (configure #f))
     (begin)
     (begin-for-syntax
      (module*
       #%type-decl
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require typed-racket/types/numeric-tower
                 typed-racket/env/type-name-env
                 typed-racket/env/global-env
                 typed-racket/env/type-alias-env
                 typed-racket/types/struct-table
                 typed-racket/types/abbrev
                 (rename-in racket/private/sort (sort raw-sort)))
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin))))
     (begin-for-syntax
      (add-mod!
       (variable-reference->module-path-index (#%variable-reference))))
     (define blame1 (quote-module-name))
     (begin-for-syntax
      (require typed-racket/utils/redirect-contract)
      (module #%contract-defs-reference racket/base
        (require racket/runtime-path (for-syntax racket/base))
        (define-runtime-module-path-index
         contract-defs-submod
         '(submod ".." #%contract-defs))
        (provide contract-defs-submod))
      (require (submod "." #%contract-defs-reference))
      (define make-redirect2
        (make-make-redirect-to-contract contract-defs-submod)))
     (module*
      #%contract-defs
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require (submod typed-racket/private/type-contract predicates)
                typed-racket/utils/utils
                (for-syntax typed-racket/utils/utils)
                typed-racket/utils/any-wrap
                typed-racket/utils/struct-type-c
                typed-racket/utils/opaque-object
                typed-racket/utils/evt-contract
                typed-racket/utils/sealing-contract
                racket/sequence
                racket/contract/parametric)))
     '"hello world"
     (void))))
(macro-post-transform
 (,(datum->syntax
    #f
    '(#%module-begin
      (do-wrapping-module-begin
       print-result
       (module configure-runtime '#%kernel
         (#%require racket/runtime-config)
         (configure #f)))
      (do-wrapping-module-begin print-result (begin))
      (do-wrapping-module-begin
       print-result
       (begin-for-syntax
        (module*
         #%type-decl
         #f
         (#%plain-module-begin
          (#%declare #:empty-namespace)
          (require typed-racket/types/numeric-tower
                   typed-racket/env/type-name-env
                   typed-racket/env/global-env
                   typed-racket/env/type-alias-env
                   typed-racket/types/struct-table
                   typed-racket/types/abbrev
                   (rename-in racket/private/sort (sort raw-sort)))
          (begin)
          (begin)
          (begin)
          (begin)
          (begin)
          (begin)
          (begin)))))
      (do-wrapping-module-begin
       print-result
       (begin-for-syntax
        (add-mod!
         (variable-reference->module-path-index (#%variable-reference)))))
      (do-wrapping-module-begin
       print-result
       (define blame1 (quote-module-name)))
      (do-wrapping-module-begin
       print-result
       (begin-for-syntax
        (require typed-racket/utils/redirect-contract)
        (module #%contract-defs-reference racket/base
          (require racket/runtime-path (for-syntax racket/base))
          (define-runtime-module-path-index
           contract-defs-submod
           '(submod ".." #%contract-defs))
          (provide contract-defs-submod))
        (require (submod "." #%contract-defs-reference))
        (define make-redirect2
          (make-make-redirect-to-contract contract-defs-submod))))
      (do-wrapping-module-begin
       print-result
       (module*
        #%contract-defs
        #f
        (#%plain-module-begin
         (#%declare #:empty-namespace)
         (require (submod typed-racket/private/type-contract predicates)
                  typed-racket/utils/utils
                  (for-syntax typed-racket/utils/utils)
                  typed-racket/utils/any-wrap
                  typed-racket/utils/struct-type-c
                  typed-racket/utils/opaque-object
                  typed-racket/utils/evt-contract
                  typed-racket/utils/sealing-contract
                  racket/sequence
                  racket/contract/parametric))))
      (do-wrapping-module-begin print-result '"hello world")
      (do-wrapping-module-begin print-result (void))))
  unquote
  (datum->syntax
   #f
   '(printing:module-begin
     (module configure-runtime '#%kernel
       (#%require racket/runtime-config)
       (configure #f))
     (begin)
     (begin-for-syntax
      (module*
       #%type-decl
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require typed-racket/types/numeric-tower
                 typed-racket/env/type-name-env
                 typed-racket/env/global-env
                 typed-racket/env/type-alias-env
                 typed-racket/types/struct-table
                 typed-racket/types/abbrev
                 (rename-in racket/private/sort (sort raw-sort)))
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin))))
     (begin-for-syntax
      (add-mod!
       (variable-reference->module-path-index (#%variable-reference))))
     (define blame1 (quote-module-name))
     (begin-for-syntax
      (require typed-racket/utils/redirect-contract)
      (module #%contract-defs-reference racket/base
        (require racket/runtime-path (for-syntax racket/base))
        (define-runtime-module-path-index
         contract-defs-submod
         '(submod ".." #%contract-defs))
        (provide contract-defs-submod))
      (require (submod "." #%contract-defs-reference))
      (define make-redirect2
        (make-make-redirect-to-contract contract-defs-submod)))
     (module*
      #%contract-defs
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require (submod typed-racket/private/type-contract predicates)
                typed-racket/utils/utils
                (for-syntax typed-racket/utils/utils)
                typed-racket/utils/any-wrap
                typed-racket/utils/struct-type-c
                typed-racket/utils/opaque-object
                typed-racket/utils/evt-contract
                typed-racket/utils/sealing-contract
                racket/sequence
                racket/contract/parametric)))
     '"hello world"
     (void)))))
(exit-macro
 ,(datum->syntax
   #f
   '(#%module-begin
     (do-wrapping-module-begin
      print-result
      (module configure-runtime '#%kernel
        (#%require racket/runtime-config)
        (configure #f)))
     (do-wrapping-module-begin print-result (begin))
     (do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (module*
        #%type-decl
        #f
        (#%plain-module-begin
         (#%declare #:empty-namespace)
         (require typed-racket/types/numeric-tower
                  typed-racket/env/type-name-env
                  typed-racket/env/global-env
                  typed-racket/env/type-alias-env
                  typed-racket/types/struct-table
                  typed-racket/types/abbrev
                  (rename-in racket/private/sort (sort raw-sort)))
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)))))
     (do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (add-mod!
        (variable-reference->module-path-index (#%variable-reference)))))
     (do-wrapping-module-begin
      print-result
      (define blame1 (quote-module-name)))
     (do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (require typed-racket/utils/redirect-contract)
       (module #%contract-defs-reference racket/base
         (require racket/runtime-path (for-syntax racket/base))
         (define-runtime-module-path-index
          contract-defs-submod
          '(submod ".." #%contract-defs))
         (provide contract-defs-submod))
       (require (submod "." #%contract-defs-reference))
       (define make-redirect2
         (make-make-redirect-to-contract contract-defs-submod))))
     (do-wrapping-module-begin
      print-result
      (module*
       #%contract-defs
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require (submod typed-racket/private/type-contract predicates)
                 typed-racket/utils/utils
                 (for-syntax typed-racket/utils/utils)
                 typed-racket/utils/any-wrap
                 typed-racket/utils/struct-type-c
                 typed-racket/utils/opaque-object
                 typed-racket/utils/evt-contract
                 typed-racket/utils/sealing-contract
                 racket/sequence
                 racket/contract/parametric))))
     (do-wrapping-module-begin print-result '"hello world")
     (do-wrapping-module-begin print-result (void)))))
(return
 ,(datum->syntax
   #f
   '(#%module-begin
     (do-wrapping-module-begin
      print-result
      (module configure-runtime '#%kernel
        (#%require racket/runtime-config)
        (configure #f)))
     (do-wrapping-module-begin print-result (begin))
     (do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (module*
        #%type-decl
        #f
        (#%plain-module-begin
         (#%declare #:empty-namespace)
         (require typed-racket/types/numeric-tower
                  typed-racket/env/type-name-env
                  typed-racket/env/global-env
                  typed-racket/env/type-alias-env
                  typed-racket/types/struct-table
                  typed-racket/types/abbrev
                  (rename-in racket/private/sort (sort raw-sort)))
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)))))
     (do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (add-mod!
        (variable-reference->module-path-index (#%variable-reference)))))
     (do-wrapping-module-begin
      print-result
      (define blame1 (quote-module-name)))
     (do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (require typed-racket/utils/redirect-contract)
       (module #%contract-defs-reference racket/base
         (require racket/runtime-path (for-syntax racket/base))
         (define-runtime-module-path-index
          contract-defs-submod
          '(submod ".." #%contract-defs))
         (provide contract-defs-submod))
       (require (submod "." #%contract-defs-reference))
       (define make-redirect2
         (make-make-redirect-to-contract contract-defs-submod))))
     (do-wrapping-module-begin
      print-result
      (module*
       #%contract-defs
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require (submod typed-racket/private/type-contract predicates)
                 typed-racket/utils/utils
                 (for-syntax typed-racket/utils/utils)
                 typed-racket/utils/any-wrap
                 typed-racket/utils/struct-type-c
                 typed-racket/utils/opaque-object
                 typed-racket/utils/evt-contract
                 typed-racket/utils/sealing-contract
                 racket/sequence
                 racket/contract/parametric))))
     (do-wrapping-module-begin print-result '"hello world")
     (do-wrapping-module-begin print-result (void)))))
(exit-check
 ,(datum->syntax
   #f
   '(#%module-begin
     (do-wrapping-module-begin
      print-result
      (module configure-runtime '#%kernel
        (#%require racket/runtime-config)
        (configure #f)))
     (do-wrapping-module-begin print-result (begin))
     (do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (module*
        #%type-decl
        #f
        (#%plain-module-begin
         (#%declare #:empty-namespace)
         (require typed-racket/types/numeric-tower
                  typed-racket/env/type-name-env
                  typed-racket/env/global-env
                  typed-racket/env/type-alias-env
                  typed-racket/types/struct-table
                  typed-racket/types/abbrev
                  (rename-in racket/private/sort (sort raw-sort)))
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)))))
     (do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (add-mod!
        (variable-reference->module-path-index (#%variable-reference)))))
     (do-wrapping-module-begin
      print-result
      (define blame1 (quote-module-name)))
     (do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (require typed-racket/utils/redirect-contract)
       (module #%contract-defs-reference racket/base
         (require racket/runtime-path (for-syntax racket/base))
         (define-runtime-module-path-index
          contract-defs-submod
          '(submod ".." #%contract-defs))
         (provide contract-defs-submod))
       (require (submod "." #%contract-defs-reference))
       (define make-redirect2
         (make-make-redirect-to-contract contract-defs-submod))))
     (do-wrapping-module-begin
      print-result
      (module*
       #%contract-defs
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require (submod typed-racket/private/type-contract predicates)
                 typed-racket/utils/utils
                 (for-syntax typed-racket/utils/utils)
                 typed-racket/utils/any-wrap
                 typed-racket/utils/struct-type-c
                 typed-racket/utils/opaque-object
                 typed-racket/utils/evt-contract
                 typed-racket/utils/sealing-contract
                 racket/sequence
                 racket/contract/parametric))))
     (do-wrapping-module-begin print-result '"hello world")
     (do-wrapping-module-begin print-result (void)))))
(visit
 ,(datum->syntax
   #f
   '(#%module-begin
     (do-wrapping-module-begin
      print-result
      (module configure-runtime '#%kernel
        (#%require racket/runtime-config)
        (configure #f)))
     (do-wrapping-module-begin print-result (begin))
     (do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (module*
        #%type-decl
        #f
        (#%plain-module-begin
         (#%declare #:empty-namespace)
         (require typed-racket/types/numeric-tower
                  typed-racket/env/type-name-env
                  typed-racket/env/global-env
                  typed-racket/env/type-alias-env
                  typed-racket/types/struct-table
                  typed-racket/types/abbrev
                  (rename-in racket/private/sort (sort raw-sort)))
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)))))
     (do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (add-mod!
        (variable-reference->module-path-index (#%variable-reference)))))
     (do-wrapping-module-begin
      print-result
      (define blame1 (quote-module-name)))
     (do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (require typed-racket/utils/redirect-contract)
       (module #%contract-defs-reference racket/base
         (require racket/runtime-path (for-syntax racket/base))
         (define-runtime-module-path-index
          contract-defs-submod
          '(submod ".." #%contract-defs))
         (provide contract-defs-submod))
       (require (submod "." #%contract-defs-reference))
       (define make-redirect2
         (make-make-redirect-to-contract contract-defs-submod))))
     (do-wrapping-module-begin
      print-result
      (module*
       #%contract-defs
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require (submod typed-racket/private/type-contract predicates)
                 typed-racket/utils/utils
                 (for-syntax typed-racket/utils/utils)
                 typed-racket/utils/any-wrap
                 typed-racket/utils/struct-type-c
                 typed-racket/utils/opaque-object
                 typed-racket/utils/evt-contract
                 typed-racket/utils/sealing-contract
                 racket/sequence
                 racket/contract/parametric))))
     (do-wrapping-module-begin print-result '"hello world")
     (do-wrapping-module-begin print-result (void)))))
(resolve ,(datum->syntax #f '#%module-begin))
(enter-prim
 ,(datum->syntax
   #f
   '(#%module-begin
     (do-wrapping-module-begin
      print-result
      (module configure-runtime '#%kernel
        (#%require racket/runtime-config)
        (configure #f)))
     (do-wrapping-module-begin print-result (begin))
     (do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (module*
        #%type-decl
        #f
        (#%plain-module-begin
         (#%declare #:empty-namespace)
         (require typed-racket/types/numeric-tower
                  typed-racket/env/type-name-env
                  typed-racket/env/global-env
                  typed-racket/env/type-alias-env
                  typed-racket/types/struct-table
                  typed-racket/types/abbrev
                  (rename-in racket/private/sort (sort raw-sort)))
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)))))
     (do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (add-mod!
        (variable-reference->module-path-index (#%variable-reference)))))
     (do-wrapping-module-begin
      print-result
      (define blame1 (quote-module-name)))
     (do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (require typed-racket/utils/redirect-contract)
       (module #%contract-defs-reference racket/base
         (require racket/runtime-path (for-syntax racket/base))
         (define-runtime-module-path-index
          contract-defs-submod
          '(submod ".." #%contract-defs))
         (provide contract-defs-submod))
       (require (submod "." #%contract-defs-reference))
       (define make-redirect2
         (make-make-redirect-to-contract contract-defs-submod))))
     (do-wrapping-module-begin
      print-result
      (module*
       #%contract-defs
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require (submod typed-racket/private/type-contract predicates)
                 typed-racket/utils/utils
                 (for-syntax typed-racket/utils/utils)
                 typed-racket/utils/any-wrap
                 typed-racket/utils/struct-type-c
                 typed-racket/utils/opaque-object
                 typed-racket/utils/evt-contract
                 typed-racket/utils/sealing-contract
                 racket/sequence
                 racket/contract/parametric))))
     (do-wrapping-module-begin print-result '"hello world")
     (do-wrapping-module-begin print-result (void)))))
(prim-#%module-begin #f)
(rename-one
 ,(datum->syntax
   #f
   '(#%module-begin
     (do-wrapping-module-begin
      print-result
      (module configure-runtime '#%kernel
        (#%require racket/runtime-config)
        (configure #f)))
     (do-wrapping-module-begin print-result (begin))
     (do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (module*
        #%type-decl
        #f
        (#%plain-module-begin
         (#%declare #:empty-namespace)
         (require typed-racket/types/numeric-tower
                  typed-racket/env/type-name-env
                  typed-racket/env/global-env
                  typed-racket/env/type-alias-env
                  typed-racket/types/struct-table
                  typed-racket/types/abbrev
                  (rename-in racket/private/sort (sort raw-sort)))
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)))))
     (do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (add-mod!
        (variable-reference->module-path-index (#%variable-reference)))))
     (do-wrapping-module-begin
      print-result
      (define blame1 (quote-module-name)))
     (do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (require typed-racket/utils/redirect-contract)
       (module #%contract-defs-reference racket/base
         (require racket/runtime-path (for-syntax racket/base))
         (define-runtime-module-path-index
          contract-defs-submod
          '(submod ".." #%contract-defs))
         (provide contract-defs-submod))
       (require (submod "." #%contract-defs-reference))
       (define make-redirect2
         (make-make-redirect-to-contract contract-defs-submod))))
     (do-wrapping-module-begin
      print-result
      (module*
       #%contract-defs
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require (submod typed-racket/private/type-contract predicates)
                 typed-racket/utils/utils
                 (for-syntax typed-racket/utils/utils)
                 typed-racket/utils/any-wrap
                 typed-racket/utils/struct-type-c
                 typed-racket/utils/opaque-object
                 typed-racket/utils/evt-contract
                 typed-racket/utils/sealing-contract
                 racket/sequence
                 racket/contract/parametric))))
     (do-wrapping-module-begin print-result '"hello world")
     (do-wrapping-module-begin print-result (void)))))
(next #f)
(visit
 ,(datum->syntax
   #f
   '(do-wrapping-module-begin
     print-result
     (module configure-runtime '#%kernel
       (#%require racket/runtime-config)
       (configure #f)))))
(resolve ,(datum->syntax #f 'do-wrapping-module-begin))
(enter-macro
 ,(datum->syntax
   #f
   '(do-wrapping-module-begin
     print-result
     (module configure-runtime '#%kernel
       (#%require racket/runtime-config)
       (configure #f)))))
(macro-pre-transform
 ,(datum->syntax
   #f
   '(do-wrapping-module-begin
     print-result
     (module configure-runtime '#%kernel
       (#%require racket/runtime-config)
       (configure #f)))))
(enter-local
 ,(datum->syntax
   #f
   '(module configure-runtime '#%kernel
      (#%require racket/runtime-config)
      (configure #f))))
(local-pre
 ,(datum->syntax
   #f
   '(module configure-runtime '#%kernel
      (#%require racket/runtime-config)
      (configure #f))))
(start #f)
(visit
 ,(datum->syntax
   #f
   '(module configure-runtime '#%kernel
      (#%require racket/runtime-config)
      (configure #f))))
(resolve ,(datum->syntax #f 'module))
(enter-prim
 ,(datum->syntax
   #f
   '(module configure-runtime '#%kernel
      (#%require racket/runtime-config)
      (configure #f))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax
   #f
   '(module configure-runtime '#%kernel
      (#%require racket/runtime-config)
      (configure #f))))
(return
 ,(datum->syntax
   #f
   '(module configure-runtime '#%kernel
      (#%require racket/runtime-config)
      (configure #f))))
(local-post
 ,(datum->syntax
   #f
   '(module configure-runtime '#%kernel
      (#%require racket/runtime-config)
      (configure #f))))
(exit-local
 ,(datum->syntax
   #f
   '(module configure-runtime '#%kernel
      (#%require racket/runtime-config)
      (configure #f))))
(macro-post-transform
 (,(datum->syntax
    #f
    '(begin
       (module configure-runtime '#%kernel
         (#%require racket/runtime-config)
         (configure #f))))
  unquote
  (datum->syntax
   #f
   '(do-wrapping-module-begin
     print-result
     (module configure-runtime '#%kernel
       (#%require racket/runtime-config)
       (configure #f))))))
(exit-macro
 ,(datum->syntax
   #f
   '(begin
      (module configure-runtime '#%kernel
        (#%require racket/runtime-config)
        (configure #f)))))
(visit
 ,(datum->syntax
   #f
   '(begin
      (module configure-runtime '#%kernel
        (#%require racket/runtime-config)
        (configure #f)))))
(resolve ,(datum->syntax #f 'begin))
(enter-prim
 ,(datum->syntax
   #f
   '(begin
      (module configure-runtime '#%kernel
        (#%require racket/runtime-config)
        (configure #f)))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax
   #f
   '(begin
      (module configure-runtime '#%kernel
        (#%require racket/runtime-config)
        (configure #f)))))
(return
 ,(datum->syntax
   #f
   '(begin
      (module configure-runtime '#%kernel
        (#%require racket/runtime-config)
        (configure #f)))))
(rename-one
 ,(datum->syntax
   #f
   '(begin
      (module configure-runtime '#%kernel
        (#%require racket/runtime-config)
        (configure #f)))))
(splice
 (,(datum->syntax
    #f
    '(module configure-runtime '#%kernel
       (#%require racket/runtime-config)
       (configure #f)))
  ,(datum->syntax #f '(do-wrapping-module-begin print-result (begin)))
  ,(datum->syntax
    #f
    '(do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (module*
        #%type-decl
        #f
        (#%plain-module-begin
         (#%declare #:empty-namespace)
         (require typed-racket/types/numeric-tower
                  typed-racket/env/type-name-env
                  typed-racket/env/global-env
                  typed-racket/env/type-alias-env
                  typed-racket/types/struct-table
                  typed-racket/types/abbrev
                  (rename-in racket/private/sort (sort raw-sort)))
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin))))))
  ,(datum->syntax
    #f
    '(do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (add-mod!
        (variable-reference->module-path-index (#%variable-reference))))))
  ,(datum->syntax
    #f
    '(do-wrapping-module-begin
      print-result
      (define blame1 (quote-module-name))))
  ,(datum->syntax
    #f
    '(do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (require typed-racket/utils/redirect-contract)
       (module #%contract-defs-reference racket/base
         (require racket/runtime-path (for-syntax racket/base))
         (define-runtime-module-path-index
          contract-defs-submod
          '(submod ".." #%contract-defs))
         (provide contract-defs-submod))
       (require (submod "." #%contract-defs-reference))
       (define make-redirect2
         (make-make-redirect-to-contract contract-defs-submod)))))
  ,(datum->syntax
    #f
    '(do-wrapping-module-begin
      print-result
      (module*
       #%contract-defs
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require (submod typed-racket/private/type-contract predicates)
                 typed-racket/utils/utils
                 (for-syntax typed-racket/utils/utils)
                 typed-racket/utils/any-wrap
                 typed-racket/utils/struct-type-c
                 typed-racket/utils/opaque-object
                 typed-racket/utils/evt-contract
                 typed-racket/utils/sealing-contract
                 racket/sequence
                 racket/contract/parametric)))))
  ,(datum->syntax #f '(do-wrapping-module-begin print-result '"hello world"))
  ,(datum->syntax #f '(do-wrapping-module-begin print-result (void)))))
(next #f)
(visit
 ,(datum->syntax
   #f
   '(module configure-runtime '#%kernel
      (#%require racket/runtime-config)
      (configure #f))))
(resolve ,(datum->syntax #f 'module))
(enter-prim
 ,(datum->syntax
   #f
   '(module configure-runtime '#%kernel
      (#%require racket/runtime-config)
      (configure #f))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax
   #f
   '(module configure-runtime '#%kernel
      (#%require racket/runtime-config)
      (configure #f))))
(return
 ,(datum->syntax
   #f
   '(module configure-runtime '#%kernel
      (#%require racket/runtime-config)
      (configure #f))))
(rename-one
 ,(datum->syntax
   #f
   '(module configure-runtime '#%kernel
      (#%require racket/runtime-config)
      (configure #f))))
(enter-prim
 ,(datum->syntax
   #f
   '(module configure-runtime '#%kernel
      (#%require racket/runtime-config)
      (configure #f))))
(prim-submodule #f)
(enter-prim
 ,(datum->syntax
   #f
   '(module configure-runtime '#%kernel
      (#%require racket/runtime-config)
      (configure #f))))
(prim-module #f)
(prepare-env #f)
(tag
 ,(datum->syntax
   #f
   '(#%module-begin (#%require racket/runtime-config) (configure #f))))
(rename-one
 ,(datum->syntax
   #f
   '(#%module-begin (#%require racket/runtime-config) (configure #f))))
(visit
 ,(datum->syntax
   #f
   '(#%module-begin (#%require racket/runtime-config) (configure #f))))
(resolve ,(datum->syntax #f '#%module-begin))
(enter-prim
 ,(datum->syntax
   #f
   '(#%module-begin (#%require racket/runtime-config) (configure #f))))
(prim-#%module-begin #f)
(rename-one
 ,(datum->syntax
   #f
   '(#%module-begin (#%require racket/runtime-config) (configure #f))))
(next #f)
(visit ,(datum->syntax #f '(#%require racket/runtime-config)))
(resolve ,(datum->syntax #f '#%require))
(enter-prim ,(datum->syntax #f '(#%require racket/runtime-config)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(#%require racket/runtime-config)))
(return ,(datum->syntax #f '(#%require racket/runtime-config)))
(rename-one ,(datum->syntax #f '(#%require racket/runtime-config)))
(enter-prim ,(datum->syntax #f '(#%require racket/runtime-config)))
(prim-require #f)
(exit-prim ,(datum->syntax #f '(#%require racket/runtime-config)))
(next #f)
(visit ,(datum->syntax #f '(configure #f)))
(resolve ,(datum->syntax #f 'configure))
(resolve ,(datum->syntax #f '#%app))
(enter-prim ,(datum->syntax #f '(configure #f)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(configure #f)))
(return ,(datum->syntax #f '(configure #f)))
(rename-one ,(datum->syntax #f '(configure #f)))
(lift-end-loop ())
(next-group #f)
(next #f)
(next #f)
(visit ,(datum->syntax #f '(configure #f)))
(resolve ,(datum->syntax #f 'configure))
(resolve ,(datum->syntax #f '#%app))
(tag ,(datum->syntax #f '(#%app configure #f)))
(enter-prim ,(datum->syntax #f '(#%app configure #f)))
(prim-#%app #f)
(enter-list ,(datum->syntax #f '(configure #f)))
(next #f)
(visit ,(datum->syntax #f 'configure))
(resolve ,(datum->syntax #f 'configure))
(variable (,(datum->syntax #f 'configure) . ,(datum->syntax #f 'configure)))
(return ,(datum->syntax #f 'configure))
(next #f)
(visit ,(datum->syntax #f '#f))
(resolve ,(datum->syntax #f '#%datum))
(tag ,(datum->syntax #f '(#%datum . #f)))
(enter-prim ,(datum->syntax #f '(#%datum . #f)))
(prim-#%datum #f)
(exit-prim ,(datum->syntax #f ''#f))
(return ,(datum->syntax #f ''#f))
(exit-list ,(datum->syntax #f '(configure '#f)))
(exit-prim ,(datum->syntax #f '(#%app configure '#f)))
(return ,(datum->syntax #f '(#%app configure '#f)))
(lift-end-loop ())
(next-group #f)
(next #f)
(exit-prim
 ,(datum->syntax
   #f
   '(#%module-begin (#%require racket/runtime-config) (#%app configure '#f))))
(return
 ,(datum->syntax
   #f
   '(#%module-begin (#%require racket/runtime-config) (#%app configure '#f))))
(rename-one
 ,(datum->syntax
   #f
   '(module configure-runtime '#%kernel
      (#%module-begin
       (#%require racket/runtime-config)
       (#%app configure '#f)))))
(exit-prim
 ,(datum->syntax
   #f
   '(module configure-runtime '#%kernel
      (#%module-begin
       (#%require racket/runtime-config)
       (#%app configure '#f)))))
(exit-prim
 ,(datum->syntax
   #f
   '(module configure-runtime '#%kernel
      (#%module-begin
       (#%require racket/runtime-config)
       (#%app configure '#f)))))
(next #f)
(visit ,(datum->syntax #f '(do-wrapping-module-begin print-result (begin))))
(resolve ,(datum->syntax #f 'do-wrapping-module-begin))
(enter-macro
 ,(datum->syntax #f '(do-wrapping-module-begin print-result (begin))))
(macro-pre-transform
 ,(datum->syntax #f '(do-wrapping-module-begin print-result (begin))))
(enter-local ,(datum->syntax #f '(begin)))
(local-pre ,(datum->syntax #f '(begin)))
(start #f)
(visit ,(datum->syntax #f '(begin)))
(resolve ,(datum->syntax #f 'begin))
(enter-prim ,(datum->syntax #f '(begin)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(begin)))
(return ,(datum->syntax #f '(begin)))
(local-post ,(datum->syntax #f '(begin)))
(exit-local ,(datum->syntax #f '(begin)))
(macro-post-transform
 (,(datum->syntax #f '(begin))
  unquote
  (datum->syntax #f '(do-wrapping-module-begin print-result (begin)))))
(exit-macro ,(datum->syntax #f '(begin)))
(visit ,(datum->syntax #f '(begin)))
(resolve ,(datum->syntax #f 'begin))
(enter-prim ,(datum->syntax #f '(begin)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(begin)))
(return ,(datum->syntax #f '(begin)))
(rename-one ,(datum->syntax #f '(begin)))
(splice
 (,(datum->syntax
    #f
    '(do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (module*
        #%type-decl
        #f
        (#%plain-module-begin
         (#%declare #:empty-namespace)
         (require typed-racket/types/numeric-tower
                  typed-racket/env/type-name-env
                  typed-racket/env/global-env
                  typed-racket/env/type-alias-env
                  typed-racket/types/struct-table
                  typed-racket/types/abbrev
                  (rename-in racket/private/sort (sort raw-sort)))
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin))))))
  ,(datum->syntax
    #f
    '(do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (add-mod!
        (variable-reference->module-path-index (#%variable-reference))))))
  ,(datum->syntax
    #f
    '(do-wrapping-module-begin
      print-result
      (define blame1 (quote-module-name))))
  ,(datum->syntax
    #f
    '(do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (require typed-racket/utils/redirect-contract)
       (module #%contract-defs-reference racket/base
         (require racket/runtime-path (for-syntax racket/base))
         (define-runtime-module-path-index
          contract-defs-submod
          '(submod ".." #%contract-defs))
         (provide contract-defs-submod))
       (require (submod "." #%contract-defs-reference))
       (define make-redirect2
         (make-make-redirect-to-contract contract-defs-submod)))))
  ,(datum->syntax
    #f
    '(do-wrapping-module-begin
      print-result
      (module*
       #%contract-defs
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require (submod typed-racket/private/type-contract predicates)
                 typed-racket/utils/utils
                 (for-syntax typed-racket/utils/utils)
                 typed-racket/utils/any-wrap
                 typed-racket/utils/struct-type-c
                 typed-racket/utils/opaque-object
                 typed-racket/utils/evt-contract
                 typed-racket/utils/sealing-contract
                 racket/sequence
                 racket/contract/parametric)))))
  ,(datum->syntax #f '(do-wrapping-module-begin print-result '"hello world"))
  ,(datum->syntax #f '(do-wrapping-module-begin print-result (void)))))
(next #f)
(visit
 ,(datum->syntax
   #f
   '(do-wrapping-module-begin
     print-result
     (begin-for-syntax
      (module*
       #%type-decl
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require typed-racket/types/numeric-tower
                 typed-racket/env/type-name-env
                 typed-racket/env/global-env
                 typed-racket/env/type-alias-env
                 typed-racket/types/struct-table
                 typed-racket/types/abbrev
                 (rename-in racket/private/sort (sort raw-sort)))
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)))))))
(resolve ,(datum->syntax #f 'do-wrapping-module-begin))
(enter-macro
 ,(datum->syntax
   #f
   '(do-wrapping-module-begin
     print-result
     (begin-for-syntax
      (module*
       #%type-decl
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require typed-racket/types/numeric-tower
                 typed-racket/env/type-name-env
                 typed-racket/env/global-env
                 typed-racket/env/type-alias-env
                 typed-racket/types/struct-table
                 typed-racket/types/abbrev
                 (rename-in racket/private/sort (sort raw-sort)))
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)))))))
(macro-pre-transform
 ,(datum->syntax
   #f
   '(do-wrapping-module-begin
     print-result
     (begin-for-syntax
      (module*
       #%type-decl
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require typed-racket/types/numeric-tower
                 typed-racket/env/type-name-env
                 typed-racket/env/global-env
                 typed-racket/env/type-alias-env
                 typed-racket/types/struct-table
                 typed-racket/types/abbrev
                 (rename-in racket/private/sort (sort raw-sort)))
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)))))))
(enter-local
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (module*
      #%type-decl
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require typed-racket/types/numeric-tower
                typed-racket/env/type-name-env
                typed-racket/env/global-env
                typed-racket/env/type-alias-env
                typed-racket/types/struct-table
                typed-racket/types/abbrev
                (rename-in racket/private/sort (sort raw-sort)))
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin))))))
(local-pre
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (module*
      #%type-decl
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require typed-racket/types/numeric-tower
                typed-racket/env/type-name-env
                typed-racket/env/global-env
                typed-racket/env/type-alias-env
                typed-racket/types/struct-table
                typed-racket/types/abbrev
                (rename-in racket/private/sort (sort raw-sort)))
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin))))))
(start #f)
(visit
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (module*
      #%type-decl
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require typed-racket/types/numeric-tower
                typed-racket/env/type-name-env
                typed-racket/env/global-env
                typed-racket/env/type-alias-env
                typed-racket/types/struct-table
                typed-racket/types/abbrev
                (rename-in racket/private/sort (sort raw-sort)))
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin))))))
(resolve ,(datum->syntax #f 'begin-for-syntax))
(enter-prim
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (module*
      #%type-decl
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require typed-racket/types/numeric-tower
                typed-racket/env/type-name-env
                typed-racket/env/global-env
                typed-racket/env/type-alias-env
                typed-racket/types/struct-table
                typed-racket/types/abbrev
                (rename-in racket/private/sort (sort raw-sort)))
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin))))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (module*
      #%type-decl
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require typed-racket/types/numeric-tower
                typed-racket/env/type-name-env
                typed-racket/env/global-env
                typed-racket/env/type-alias-env
                typed-racket/types/struct-table
                typed-racket/types/abbrev
                (rename-in racket/private/sort (sort raw-sort)))
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin))))))
(return
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (module*
      #%type-decl
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require typed-racket/types/numeric-tower
                typed-racket/env/type-name-env
                typed-racket/env/global-env
                typed-racket/env/type-alias-env
                typed-racket/types/struct-table
                typed-racket/types/abbrev
                (rename-in racket/private/sort (sort raw-sort)))
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin))))))
(local-post
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (module*
      #%type-decl
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require typed-racket/types/numeric-tower
                typed-racket/env/type-name-env
                typed-racket/env/global-env
                typed-racket/env/type-alias-env
                typed-racket/types/struct-table
                typed-racket/types/abbrev
                (rename-in racket/private/sort (sort raw-sort)))
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin))))))
(exit-local
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (module*
      #%type-decl
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require typed-racket/types/numeric-tower
                typed-racket/env/type-name-env
                typed-racket/env/global-env
                typed-racket/env/type-alias-env
                typed-racket/types/struct-table
                typed-racket/types/abbrev
                (rename-in racket/private/sort (sort raw-sort)))
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin))))))
(macro-post-transform
 (,(datum->syntax
    #f
    '(begin
       (begin-for-syntax
        (module*
         #%type-decl
         #f
         (#%plain-module-begin
          (#%declare #:empty-namespace)
          (require typed-racket/types/numeric-tower
                   typed-racket/env/type-name-env
                   typed-racket/env/global-env
                   typed-racket/env/type-alias-env
                   typed-racket/types/struct-table
                   typed-racket/types/abbrev
                   (rename-in racket/private/sort (sort raw-sort)))
          (begin)
          (begin)
          (begin)
          (begin)
          (begin)
          (begin)
          (begin))))))
  unquote
  (datum->syntax
   #f
   '(do-wrapping-module-begin
     print-result
     (begin-for-syntax
      (module*
       #%type-decl
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require typed-racket/types/numeric-tower
                 typed-racket/env/type-name-env
                 typed-racket/env/global-env
                 typed-racket/env/type-alias-env
                 typed-racket/types/struct-table
                 typed-racket/types/abbrev
                 (rename-in racket/private/sort (sort raw-sort)))
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin))))))))
(exit-macro
 ,(datum->syntax
   #f
   '(begin
      (begin-for-syntax
       (module*
        #%type-decl
        #f
        (#%plain-module-begin
         (#%declare #:empty-namespace)
         (require typed-racket/types/numeric-tower
                  typed-racket/env/type-name-env
                  typed-racket/env/global-env
                  typed-racket/env/type-alias-env
                  typed-racket/types/struct-table
                  typed-racket/types/abbrev
                  (rename-in racket/private/sort (sort raw-sort)))
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)))))))
(visit
 ,(datum->syntax
   #f
   '(begin
      (begin-for-syntax
       (module*
        #%type-decl
        #f
        (#%plain-module-begin
         (#%declare #:empty-namespace)
         (require typed-racket/types/numeric-tower
                  typed-racket/env/type-name-env
                  typed-racket/env/global-env
                  typed-racket/env/type-alias-env
                  typed-racket/types/struct-table
                  typed-racket/types/abbrev
                  (rename-in racket/private/sort (sort raw-sort)))
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)))))))
(resolve ,(datum->syntax #f 'begin))
(enter-prim
 ,(datum->syntax
   #f
   '(begin
      (begin-for-syntax
       (module*
        #%type-decl
        #f
        (#%plain-module-begin
         (#%declare #:empty-namespace)
         (require typed-racket/types/numeric-tower
                  typed-racket/env/type-name-env
                  typed-racket/env/global-env
                  typed-racket/env/type-alias-env
                  typed-racket/types/struct-table
                  typed-racket/types/abbrev
                  (rename-in racket/private/sort (sort raw-sort)))
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)))))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax
   #f
   '(begin
      (begin-for-syntax
       (module*
        #%type-decl
        #f
        (#%plain-module-begin
         (#%declare #:empty-namespace)
         (require typed-racket/types/numeric-tower
                  typed-racket/env/type-name-env
                  typed-racket/env/global-env
                  typed-racket/env/type-alias-env
                  typed-racket/types/struct-table
                  typed-racket/types/abbrev
                  (rename-in racket/private/sort (sort raw-sort)))
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)))))))
(return
 ,(datum->syntax
   #f
   '(begin
      (begin-for-syntax
       (module*
        #%type-decl
        #f
        (#%plain-module-begin
         (#%declare #:empty-namespace)
         (require typed-racket/types/numeric-tower
                  typed-racket/env/type-name-env
                  typed-racket/env/global-env
                  typed-racket/env/type-alias-env
                  typed-racket/types/struct-table
                  typed-racket/types/abbrev
                  (rename-in racket/private/sort (sort raw-sort)))
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)))))))
(rename-one
 ,(datum->syntax
   #f
   '(begin
      (begin-for-syntax
       (module*
        #%type-decl
        #f
        (#%plain-module-begin
         (#%declare #:empty-namespace)
         (require typed-racket/types/numeric-tower
                  typed-racket/env/type-name-env
                  typed-racket/env/global-env
                  typed-racket/env/type-alias-env
                  typed-racket/types/struct-table
                  typed-racket/types/abbrev
                  (rename-in racket/private/sort (sort raw-sort)))
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)
         (begin)))))))
(splice
 (,(datum->syntax
    #f
    '(begin-for-syntax
      (module*
       #%type-decl
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require typed-racket/types/numeric-tower
                 typed-racket/env/type-name-env
                 typed-racket/env/global-env
                 typed-racket/env/type-alias-env
                 typed-racket/types/struct-table
                 typed-racket/types/abbrev
                 (rename-in racket/private/sort (sort raw-sort)))
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)
        (begin)))))
  ,(datum->syntax
    #f
    '(do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (add-mod!
        (variable-reference->module-path-index (#%variable-reference))))))
  ,(datum->syntax
    #f
    '(do-wrapping-module-begin
      print-result
      (define blame1 (quote-module-name))))
  ,(datum->syntax
    #f
    '(do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (require typed-racket/utils/redirect-contract)
       (module #%contract-defs-reference racket/base
         (require racket/runtime-path (for-syntax racket/base))
         (define-runtime-module-path-index
          contract-defs-submod
          '(submod ".." #%contract-defs))
         (provide contract-defs-submod))
       (require (submod "." #%contract-defs-reference))
       (define make-redirect2
         (make-make-redirect-to-contract contract-defs-submod)))))
  ,(datum->syntax
    #f
    '(do-wrapping-module-begin
      print-result
      (module*
       #%contract-defs
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require (submod typed-racket/private/type-contract predicates)
                 typed-racket/utils/utils
                 (for-syntax typed-racket/utils/utils)
                 typed-racket/utils/any-wrap
                 typed-racket/utils/struct-type-c
                 typed-racket/utils/opaque-object
                 typed-racket/utils/evt-contract
                 typed-racket/utils/sealing-contract
                 racket/sequence
                 racket/contract/parametric)))))
  ,(datum->syntax #f '(do-wrapping-module-begin print-result '"hello world"))
  ,(datum->syntax #f '(do-wrapping-module-begin print-result (void)))))
(next #f)
(visit
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (module*
      #%type-decl
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require typed-racket/types/numeric-tower
                typed-racket/env/type-name-env
                typed-racket/env/global-env
                typed-racket/env/type-alias-env
                typed-racket/types/struct-table
                typed-racket/types/abbrev
                (rename-in racket/private/sort (sort raw-sort)))
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin))))))
(resolve ,(datum->syntax #f 'begin-for-syntax))
(enter-prim
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (module*
      #%type-decl
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require typed-racket/types/numeric-tower
                typed-racket/env/type-name-env
                typed-racket/env/global-env
                typed-racket/env/type-alias-env
                typed-racket/types/struct-table
                typed-racket/types/abbrev
                (rename-in racket/private/sort (sort raw-sort)))
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin))))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (module*
      #%type-decl
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require typed-racket/types/numeric-tower
                typed-racket/env/type-name-env
                typed-racket/env/global-env
                typed-racket/env/type-alias-env
                typed-racket/types/struct-table
                typed-racket/types/abbrev
                (rename-in racket/private/sort (sort raw-sort)))
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin))))))
(return
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (module*
      #%type-decl
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require typed-racket/types/numeric-tower
                typed-racket/env/type-name-env
                typed-racket/env/global-env
                typed-racket/env/type-alias-env
                typed-racket/types/struct-table
                typed-racket/types/abbrev
                (rename-in racket/private/sort (sort raw-sort)))
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin))))))
(rename-one
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (module*
      #%type-decl
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require typed-racket/types/numeric-tower
                typed-racket/env/type-name-env
                typed-racket/env/global-env
                typed-racket/env/type-alias-env
                typed-racket/types/struct-table
                typed-racket/types/abbrev
                (rename-in racket/private/sort (sort raw-sort)))
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin))))))
(enter-prim
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (module*
      #%type-decl
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require typed-racket/types/numeric-tower
                typed-racket/env/type-name-env
                typed-racket/env/global-env
                typed-racket/env/type-alias-env
                typed-racket/types/struct-table
                typed-racket/types/abbrev
                (rename-in racket/private/sort (sort raw-sort)))
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin))))))
(prim-begin-for-syntax #f)
(prepare-env #f)
(phase-up #f)
(exit-prim
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (module*
      #%type-decl
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require typed-racket/types/numeric-tower
                typed-racket/env/type-name-env
                typed-racket/env/global-env
                typed-racket/env/type-alias-env
                typed-racket/types/struct-table
                typed-racket/types/abbrev
                (rename-in racket/private/sort (sort raw-sort)))
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin)
       (begin))))))
(next #f)
(visit
 ,(datum->syntax
   #f
   '(do-wrapping-module-begin
     print-result
     (begin-for-syntax
      (add-mod!
       (variable-reference->module-path-index (#%variable-reference)))))))
(resolve ,(datum->syntax #f 'do-wrapping-module-begin))
(enter-macro
 ,(datum->syntax
   #f
   '(do-wrapping-module-begin
     print-result
     (begin-for-syntax
      (add-mod!
       (variable-reference->module-path-index (#%variable-reference)))))))
(macro-pre-transform
 ,(datum->syntax
   #f
   '(do-wrapping-module-begin
     print-result
     (begin-for-syntax
      (add-mod!
       (variable-reference->module-path-index (#%variable-reference)))))))
(enter-local
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (add-mod!
      (variable-reference->module-path-index (#%variable-reference))))))
(local-pre
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (add-mod!
      (variable-reference->module-path-index (#%variable-reference))))))
(start #f)
(visit
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (add-mod!
      (variable-reference->module-path-index (#%variable-reference))))))
(resolve ,(datum->syntax #f 'begin-for-syntax))
(enter-prim
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (add-mod!
      (variable-reference->module-path-index (#%variable-reference))))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (add-mod!
      (variable-reference->module-path-index (#%variable-reference))))))
(return
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (add-mod!
      (variable-reference->module-path-index (#%variable-reference))))))
(local-post
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (add-mod!
      (variable-reference->module-path-index (#%variable-reference))))))
(exit-local
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (add-mod!
      (variable-reference->module-path-index (#%variable-reference))))))
(macro-post-transform
 (,(datum->syntax
    #f
    '(begin
       (begin-for-syntax
        (add-mod!
         (variable-reference->module-path-index (#%variable-reference))))))
  unquote
  (datum->syntax
   #f
   '(do-wrapping-module-begin
     print-result
     (begin-for-syntax
      (add-mod!
       (variable-reference->module-path-index (#%variable-reference))))))))
(exit-macro
 ,(datum->syntax
   #f
   '(begin
      (begin-for-syntax
       (add-mod!
        (variable-reference->module-path-index (#%variable-reference)))))))
(visit
 ,(datum->syntax
   #f
   '(begin
      (begin-for-syntax
       (add-mod!
        (variable-reference->module-path-index (#%variable-reference)))))))
(resolve ,(datum->syntax #f 'begin))
(enter-prim
 ,(datum->syntax
   #f
   '(begin
      (begin-for-syntax
       (add-mod!
        (variable-reference->module-path-index (#%variable-reference)))))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax
   #f
   '(begin
      (begin-for-syntax
       (add-mod!
        (variable-reference->module-path-index (#%variable-reference)))))))
(return
 ,(datum->syntax
   #f
   '(begin
      (begin-for-syntax
       (add-mod!
        (variable-reference->module-path-index (#%variable-reference)))))))
(rename-one
 ,(datum->syntax
   #f
   '(begin
      (begin-for-syntax
       (add-mod!
        (variable-reference->module-path-index (#%variable-reference)))))))
(splice
 (,(datum->syntax
    #f
    '(begin-for-syntax
      (add-mod!
       (variable-reference->module-path-index (#%variable-reference)))))
  ,(datum->syntax
    #f
    '(do-wrapping-module-begin
      print-result
      (define blame1 (quote-module-name))))
  ,(datum->syntax
    #f
    '(do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (require typed-racket/utils/redirect-contract)
       (module #%contract-defs-reference racket/base
         (require racket/runtime-path (for-syntax racket/base))
         (define-runtime-module-path-index
          contract-defs-submod
          '(submod ".." #%contract-defs))
         (provide contract-defs-submod))
       (require (submod "." #%contract-defs-reference))
       (define make-redirect2
         (make-make-redirect-to-contract contract-defs-submod)))))
  ,(datum->syntax
    #f
    '(do-wrapping-module-begin
      print-result
      (module*
       #%contract-defs
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require (submod typed-racket/private/type-contract predicates)
                 typed-racket/utils/utils
                 (for-syntax typed-racket/utils/utils)
                 typed-racket/utils/any-wrap
                 typed-racket/utils/struct-type-c
                 typed-racket/utils/opaque-object
                 typed-racket/utils/evt-contract
                 typed-racket/utils/sealing-contract
                 racket/sequence
                 racket/contract/parametric)))))
  ,(datum->syntax #f '(do-wrapping-module-begin print-result '"hello world"))
  ,(datum->syntax #f '(do-wrapping-module-begin print-result (void)))))
(next #f)
(visit
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (add-mod!
      (variable-reference->module-path-index (#%variable-reference))))))
(resolve ,(datum->syntax #f 'begin-for-syntax))
(enter-prim
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (add-mod!
      (variable-reference->module-path-index (#%variable-reference))))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (add-mod!
      (variable-reference->module-path-index (#%variable-reference))))))
(return
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (add-mod!
      (variable-reference->module-path-index (#%variable-reference))))))
(rename-one
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (add-mod!
      (variable-reference->module-path-index (#%variable-reference))))))
(enter-prim
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (add-mod!
      (variable-reference->module-path-index (#%variable-reference))))))
(prim-begin-for-syntax #f)
(prepare-env #f)
(phase-up #f)
(exit-prim
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (#%app
      add-mod!
      (#%app variable-reference->module-path-index (#%variable-reference))))))
(next #f)
(visit
 ,(datum->syntax
   #f
   '(do-wrapping-module-begin
     print-result
     (define blame1 (quote-module-name)))))
(resolve ,(datum->syntax #f 'do-wrapping-module-begin))
(enter-macro
 ,(datum->syntax
   #f
   '(do-wrapping-module-begin
     print-result
     (define blame1 (quote-module-name)))))
(macro-pre-transform
 ,(datum->syntax
   #f
   '(do-wrapping-module-begin
     print-result
     (define blame1 (quote-module-name)))))
(enter-local ,(datum->syntax #f '(define blame1 (quote-module-name))))
(local-pre ,(datum->syntax #f '(define blame1 (quote-module-name))))
(start #f)
(visit ,(datum->syntax #f '(define blame1 (quote-module-name))))
(resolve ,(datum->syntax #f 'define))
(enter-macro ,(datum->syntax #f '(define blame1 (quote-module-name))))
(macro-pre-transform ,(datum->syntax #f '(define blame1 (quote-module-name))))
(macro-post-transform
 (,(datum->syntax #f '(define blame1 (quote-module-name)))
  unquote
  (datum->syntax #f '(define blame1 (quote-module-name)))))
(exit-macro ,(datum->syntax #f '(define blame1 (quote-module-name))))
(visit ,(datum->syntax #f '(define blame1 (quote-module-name))))
(resolve ,(datum->syntax #f 'define))
(enter-macro ,(datum->syntax #f '(define blame1 (quote-module-name))))
(macro-pre-transform ,(datum->syntax #f '(define blame1 (quote-module-name))))
(macro-post-transform
 (,(datum->syntax #f '(define-values (blame1) (quote-module-name)))
  unquote
  (datum->syntax #f '(define blame1 (quote-module-name)))))
(exit-macro ,(datum->syntax #f '(define-values (blame1) (quote-module-name))))
(visit ,(datum->syntax #f '(define-values (blame1) (quote-module-name))))
(resolve ,(datum->syntax #f 'define-values))
(enter-prim ,(datum->syntax #f '(define-values (blame1) (quote-module-name))))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(define-values (blame1) (quote-module-name))))
(return ,(datum->syntax #f '(define-values (blame1) (quote-module-name))))
(local-post ,(datum->syntax #f '(define-values (blame1) (quote-module-name))))
(exit-local ,(datum->syntax #f '(define-values (blame1) (quote-module-name))))
(macro-post-transform
 (,(datum->syntax #f '(begin (define-values (blame1) (quote-module-name))))
  unquote
  (datum->syntax
   #f
   '(do-wrapping-module-begin
     print-result
     (define blame1 (quote-module-name))))))
(exit-macro
 ,(datum->syntax #f '(begin (define-values (blame1) (quote-module-name)))))
(visit
 ,(datum->syntax #f '(begin (define-values (blame1) (quote-module-name)))))
(resolve ,(datum->syntax #f 'begin))
(enter-prim
 ,(datum->syntax #f '(begin (define-values (blame1) (quote-module-name)))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax #f '(begin (define-values (blame1) (quote-module-name)))))
(return
 ,(datum->syntax #f '(begin (define-values (blame1) (quote-module-name)))))
(rename-one
 ,(datum->syntax #f '(begin (define-values (blame1) (quote-module-name)))))
(splice
 (,(datum->syntax #f '(define-values (blame1) (quote-module-name)))
  ,(datum->syntax
    #f
    '(do-wrapping-module-begin
      print-result
      (begin-for-syntax
       (require typed-racket/utils/redirect-contract)
       (module #%contract-defs-reference racket/base
         (require racket/runtime-path (for-syntax racket/base))
         (define-runtime-module-path-index
          contract-defs-submod
          '(submod ".." #%contract-defs))
         (provide contract-defs-submod))
       (require (submod "." #%contract-defs-reference))
       (define make-redirect2
         (make-make-redirect-to-contract contract-defs-submod)))))
  ,(datum->syntax
    #f
    '(do-wrapping-module-begin
      print-result
      (module*
       #%contract-defs
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require (submod typed-racket/private/type-contract predicates)
                 typed-racket/utils/utils
                 (for-syntax typed-racket/utils/utils)
                 typed-racket/utils/any-wrap
                 typed-racket/utils/struct-type-c
                 typed-racket/utils/opaque-object
                 typed-racket/utils/evt-contract
                 typed-racket/utils/sealing-contract
                 racket/sequence
                 racket/contract/parametric)))))
  ,(datum->syntax #f '(do-wrapping-module-begin print-result '"hello world"))
  ,(datum->syntax #f '(do-wrapping-module-begin print-result (void)))))
(next #f)
(visit ,(datum->syntax #f '(define-values (blame1) (quote-module-name))))
(resolve ,(datum->syntax #f 'define-values))
(enter-prim ,(datum->syntax #f '(define-values (blame1) (quote-module-name))))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(define-values (blame1) (quote-module-name))))
(return ,(datum->syntax #f '(define-values (blame1) (quote-module-name))))
(rename-one ,(datum->syntax #f '(define-values (blame1) (quote-module-name))))
(enter-prim ,(datum->syntax #f '(define-values (blame1) (quote-module-name))))
(prim-define-values #f)
(exit-prim ,(datum->syntax #f '(define-values (blame1) (quote-module-name))))
(next #f)
(visit
 ,(datum->syntax
   #f
   '(do-wrapping-module-begin
     print-result
     (begin-for-syntax
      (require typed-racket/utils/redirect-contract)
      (module #%contract-defs-reference racket/base
        (require racket/runtime-path (for-syntax racket/base))
        (define-runtime-module-path-index
         contract-defs-submod
         '(submod ".." #%contract-defs))
        (provide contract-defs-submod))
      (require (submod "." #%contract-defs-reference))
      (define make-redirect2
        (make-make-redirect-to-contract contract-defs-submod))))))
(resolve ,(datum->syntax #f 'do-wrapping-module-begin))
(enter-macro
 ,(datum->syntax
   #f
   '(do-wrapping-module-begin
     print-result
     (begin-for-syntax
      (require typed-racket/utils/redirect-contract)
      (module #%contract-defs-reference racket/base
        (require racket/runtime-path (for-syntax racket/base))
        (define-runtime-module-path-index
         contract-defs-submod
         '(submod ".." #%contract-defs))
        (provide contract-defs-submod))
      (require (submod "." #%contract-defs-reference))
      (define make-redirect2
        (make-make-redirect-to-contract contract-defs-submod))))))
(macro-pre-transform
 ,(datum->syntax
   #f
   '(do-wrapping-module-begin
     print-result
     (begin-for-syntax
      (require typed-racket/utils/redirect-contract)
      (module #%contract-defs-reference racket/base
        (require racket/runtime-path (for-syntax racket/base))
        (define-runtime-module-path-index
         contract-defs-submod
         '(submod ".." #%contract-defs))
        (provide contract-defs-submod))
      (require (submod "." #%contract-defs-reference))
      (define make-redirect2
        (make-make-redirect-to-contract contract-defs-submod))))))
(enter-local
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (require typed-racket/utils/redirect-contract)
     (module #%contract-defs-reference racket/base
       (require racket/runtime-path (for-syntax racket/base))
       (define-runtime-module-path-index
        contract-defs-submod
        '(submod ".." #%contract-defs))
       (provide contract-defs-submod))
     (require (submod "." #%contract-defs-reference))
     (define make-redirect2
       (make-make-redirect-to-contract contract-defs-submod)))))
(local-pre
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (require typed-racket/utils/redirect-contract)
     (module #%contract-defs-reference racket/base
       (require racket/runtime-path (for-syntax racket/base))
       (define-runtime-module-path-index
        contract-defs-submod
        '(submod ".." #%contract-defs))
       (provide contract-defs-submod))
     (require (submod "." #%contract-defs-reference))
     (define make-redirect2
       (make-make-redirect-to-contract contract-defs-submod)))))
(start #f)
(visit
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (require typed-racket/utils/redirect-contract)
     (module #%contract-defs-reference racket/base
       (require racket/runtime-path (for-syntax racket/base))
       (define-runtime-module-path-index
        contract-defs-submod
        '(submod ".." #%contract-defs))
       (provide contract-defs-submod))
     (require (submod "." #%contract-defs-reference))
     (define make-redirect2
       (make-make-redirect-to-contract contract-defs-submod)))))
(resolve ,(datum->syntax #f 'begin-for-syntax))
(enter-prim
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (require typed-racket/utils/redirect-contract)
     (module #%contract-defs-reference racket/base
       (require racket/runtime-path (for-syntax racket/base))
       (define-runtime-module-path-index
        contract-defs-submod
        '(submod ".." #%contract-defs))
       (provide contract-defs-submod))
     (require (submod "." #%contract-defs-reference))
     (define make-redirect2
       (make-make-redirect-to-contract contract-defs-submod)))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (require typed-racket/utils/redirect-contract)
     (module #%contract-defs-reference racket/base
       (require racket/runtime-path (for-syntax racket/base))
       (define-runtime-module-path-index
        contract-defs-submod
        '(submod ".." #%contract-defs))
       (provide contract-defs-submod))
     (require (submod "." #%contract-defs-reference))
     (define make-redirect2
       (make-make-redirect-to-contract contract-defs-submod)))))
(return
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (require typed-racket/utils/redirect-contract)
     (module #%contract-defs-reference racket/base
       (require racket/runtime-path (for-syntax racket/base))
       (define-runtime-module-path-index
        contract-defs-submod
        '(submod ".." #%contract-defs))
       (provide contract-defs-submod))
     (require (submod "." #%contract-defs-reference))
     (define make-redirect2
       (make-make-redirect-to-contract contract-defs-submod)))))
(local-post
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (require typed-racket/utils/redirect-contract)
     (module #%contract-defs-reference racket/base
       (require racket/runtime-path (for-syntax racket/base))
       (define-runtime-module-path-index
        contract-defs-submod
        '(submod ".." #%contract-defs))
       (provide contract-defs-submod))
     (require (submod "." #%contract-defs-reference))
     (define make-redirect2
       (make-make-redirect-to-contract contract-defs-submod)))))
(exit-local
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (require typed-racket/utils/redirect-contract)
     (module #%contract-defs-reference racket/base
       (require racket/runtime-path (for-syntax racket/base))
       (define-runtime-module-path-index
        contract-defs-submod
        '(submod ".." #%contract-defs))
       (provide contract-defs-submod))
     (require (submod "." #%contract-defs-reference))
     (define make-redirect2
       (make-make-redirect-to-contract contract-defs-submod)))))
(macro-post-transform
 (,(datum->syntax
    #f
    '(begin
       (begin-for-syntax
        (require typed-racket/utils/redirect-contract)
        (module #%contract-defs-reference racket/base
          (require racket/runtime-path (for-syntax racket/base))
          (define-runtime-module-path-index
           contract-defs-submod
           '(submod ".." #%contract-defs))
          (provide contract-defs-submod))
        (require (submod "." #%contract-defs-reference))
        (define make-redirect2
          (make-make-redirect-to-contract contract-defs-submod)))))
  unquote
  (datum->syntax
   #f
   '(do-wrapping-module-begin
     print-result
     (begin-for-syntax
      (require typed-racket/utils/redirect-contract)
      (module #%contract-defs-reference racket/base
        (require racket/runtime-path (for-syntax racket/base))
        (define-runtime-module-path-index
         contract-defs-submod
         '(submod ".." #%contract-defs))
        (provide contract-defs-submod))
      (require (submod "." #%contract-defs-reference))
      (define make-redirect2
        (make-make-redirect-to-contract contract-defs-submod)))))))
(exit-macro
 ,(datum->syntax
   #f
   '(begin
      (begin-for-syntax
       (require typed-racket/utils/redirect-contract)
       (module #%contract-defs-reference racket/base
         (require racket/runtime-path (for-syntax racket/base))
         (define-runtime-module-path-index
          contract-defs-submod
          '(submod ".." #%contract-defs))
         (provide contract-defs-submod))
       (require (submod "." #%contract-defs-reference))
       (define make-redirect2
         (make-make-redirect-to-contract contract-defs-submod))))))
(visit
 ,(datum->syntax
   #f
   '(begin
      (begin-for-syntax
       (require typed-racket/utils/redirect-contract)
       (module #%contract-defs-reference racket/base
         (require racket/runtime-path (for-syntax racket/base))
         (define-runtime-module-path-index
          contract-defs-submod
          '(submod ".." #%contract-defs))
         (provide contract-defs-submod))
       (require (submod "." #%contract-defs-reference))
       (define make-redirect2
         (make-make-redirect-to-contract contract-defs-submod))))))
(resolve ,(datum->syntax #f 'begin))
(enter-prim
 ,(datum->syntax
   #f
   '(begin
      (begin-for-syntax
       (require typed-racket/utils/redirect-contract)
       (module #%contract-defs-reference racket/base
         (require racket/runtime-path (for-syntax racket/base))
         (define-runtime-module-path-index
          contract-defs-submod
          '(submod ".." #%contract-defs))
         (provide contract-defs-submod))
       (require (submod "." #%contract-defs-reference))
       (define make-redirect2
         (make-make-redirect-to-contract contract-defs-submod))))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax
   #f
   '(begin
      (begin-for-syntax
       (require typed-racket/utils/redirect-contract)
       (module #%contract-defs-reference racket/base
         (require racket/runtime-path (for-syntax racket/base))
         (define-runtime-module-path-index
          contract-defs-submod
          '(submod ".." #%contract-defs))
         (provide contract-defs-submod))
       (require (submod "." #%contract-defs-reference))
       (define make-redirect2
         (make-make-redirect-to-contract contract-defs-submod))))))
(return
 ,(datum->syntax
   #f
   '(begin
      (begin-for-syntax
       (require typed-racket/utils/redirect-contract)
       (module #%contract-defs-reference racket/base
         (require racket/runtime-path (for-syntax racket/base))
         (define-runtime-module-path-index
          contract-defs-submod
          '(submod ".." #%contract-defs))
         (provide contract-defs-submod))
       (require (submod "." #%contract-defs-reference))
       (define make-redirect2
         (make-make-redirect-to-contract contract-defs-submod))))))
(rename-one
 ,(datum->syntax
   #f
   '(begin
      (begin-for-syntax
       (require typed-racket/utils/redirect-contract)
       (module #%contract-defs-reference racket/base
         (require racket/runtime-path (for-syntax racket/base))
         (define-runtime-module-path-index
          contract-defs-submod
          '(submod ".." #%contract-defs))
         (provide contract-defs-submod))
       (require (submod "." #%contract-defs-reference))
       (define make-redirect2
         (make-make-redirect-to-contract contract-defs-submod))))))
(splice
 (,(datum->syntax
    #f
    '(begin-for-syntax
      (require typed-racket/utils/redirect-contract)
      (module #%contract-defs-reference racket/base
        (require racket/runtime-path (for-syntax racket/base))
        (define-runtime-module-path-index
         contract-defs-submod
         '(submod ".." #%contract-defs))
        (provide contract-defs-submod))
      (require (submod "." #%contract-defs-reference))
      (define make-redirect2
        (make-make-redirect-to-contract contract-defs-submod))))
  ,(datum->syntax
    #f
    '(do-wrapping-module-begin
      print-result
      (module*
       #%contract-defs
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require (submod typed-racket/private/type-contract predicates)
                 typed-racket/utils/utils
                 (for-syntax typed-racket/utils/utils)
                 typed-racket/utils/any-wrap
                 typed-racket/utils/struct-type-c
                 typed-racket/utils/opaque-object
                 typed-racket/utils/evt-contract
                 typed-racket/utils/sealing-contract
                 racket/sequence
                 racket/contract/parametric)))))
  ,(datum->syntax #f '(do-wrapping-module-begin print-result '"hello world"))
  ,(datum->syntax #f '(do-wrapping-module-begin print-result (void)))))
(next #f)
(visit
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (require typed-racket/utils/redirect-contract)
     (module #%contract-defs-reference racket/base
       (require racket/runtime-path (for-syntax racket/base))
       (define-runtime-module-path-index
        contract-defs-submod
        '(submod ".." #%contract-defs))
       (provide contract-defs-submod))
     (require (submod "." #%contract-defs-reference))
     (define make-redirect2
       (make-make-redirect-to-contract contract-defs-submod)))))
(resolve ,(datum->syntax #f 'begin-for-syntax))
(enter-prim
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (require typed-racket/utils/redirect-contract)
     (module #%contract-defs-reference racket/base
       (require racket/runtime-path (for-syntax racket/base))
       (define-runtime-module-path-index
        contract-defs-submod
        '(submod ".." #%contract-defs))
       (provide contract-defs-submod))
     (require (submod "." #%contract-defs-reference))
     (define make-redirect2
       (make-make-redirect-to-contract contract-defs-submod)))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (require typed-racket/utils/redirect-contract)
     (module #%contract-defs-reference racket/base
       (require racket/runtime-path (for-syntax racket/base))
       (define-runtime-module-path-index
        contract-defs-submod
        '(submod ".." #%contract-defs))
       (provide contract-defs-submod))
     (require (submod "." #%contract-defs-reference))
     (define make-redirect2
       (make-make-redirect-to-contract contract-defs-submod)))))
(return
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (require typed-racket/utils/redirect-contract)
     (module #%contract-defs-reference racket/base
       (require racket/runtime-path (for-syntax racket/base))
       (define-runtime-module-path-index
        contract-defs-submod
        '(submod ".." #%contract-defs))
       (provide contract-defs-submod))
     (require (submod "." #%contract-defs-reference))
     (define make-redirect2
       (make-make-redirect-to-contract contract-defs-submod)))))
(rename-one
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (require typed-racket/utils/redirect-contract)
     (module #%contract-defs-reference racket/base
       (require racket/runtime-path (for-syntax racket/base))
       (define-runtime-module-path-index
        contract-defs-submod
        '(submod ".." #%contract-defs))
       (provide contract-defs-submod))
     (require (submod "." #%contract-defs-reference))
     (define make-redirect2
       (make-make-redirect-to-contract contract-defs-submod)))))
(enter-prim
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (require typed-racket/utils/redirect-contract)
     (module #%contract-defs-reference racket/base
       (require racket/runtime-path (for-syntax racket/base))
       (define-runtime-module-path-index
        contract-defs-submod
        '(submod ".." #%contract-defs))
       (provide contract-defs-submod))
     (require (submod "." #%contract-defs-reference))
     (define make-redirect2
       (make-make-redirect-to-contract contract-defs-submod)))))
(prim-begin-for-syntax #f)
(prepare-env #f)
(phase-up #f)
(enter-local
 ,(datum->syntax
   #f
   '(module configure-runtime '#%kernel
      (#%require racket/runtime-config)
      (configure #f))))
(local-pre
 ,(datum->syntax
   #f
   '(module configure-runtime '#%kernel
      (#%require racket/runtime-config)
      (configure #f))))
(start #f)
(visit
 ,(datum->syntax
   #f
   '(module configure-runtime '#%kernel
      (#%require racket/runtime-config)
      (configure #f))))
(resolve ,(datum->syntax #f 'module))
(enter-prim
 ,(datum->syntax
   #f
   '(module configure-runtime '#%kernel
      (#%require racket/runtime-config)
      (configure #f))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax
   #f
   '(module configure-runtime '#%kernel
      (#%require racket/runtime-config)
      (configure #f))))
(return
 ,(datum->syntax
   #f
   '(module configure-runtime '#%kernel
      (#%require racket/runtime-config)
      (configure #f))))
(local-post
 ,(datum->syntax
   #f
   '(module configure-runtime '#%kernel
      (#%require racket/runtime-config)
      (configure #f))))
(exit-local
 ,(datum->syntax
   #f
   '(module configure-runtime '#%kernel
      (#%require racket/runtime-config)
      (configure #f))))
(enter-local
 ,(datum->syntax #f '(require racket/runtime-path (for-syntax racket/base))))
(local-pre
 ,(datum->syntax #f '(require racket/runtime-path (for-syntax racket/base))))
(start #f)
(visit
 ,(datum->syntax #f '(require racket/runtime-path (for-syntax racket/base))))
(resolve ,(datum->syntax #f 'require))
(enter-macro
 ,(datum->syntax #f '(require racket/runtime-path (for-syntax racket/base))))
(macro-pre-transform
 ,(datum->syntax #f '(require racket/runtime-path (for-syntax racket/base))))
(macro-post-transform
 (,(datum->syntax
    #f
    '(begin (require racket/runtime-path) (require (for-syntax racket/base))))
  unquote
  (datum->syntax #f '(require racket/runtime-path (for-syntax racket/base)))))
(exit-macro
 ,(datum->syntax
   #f
   '(begin (require racket/runtime-path) (require (for-syntax racket/base)))))
(visit
 ,(datum->syntax
   #f
   '(begin (require racket/runtime-path) (require (for-syntax racket/base)))))
(resolve ,(datum->syntax #f 'begin))
(enter-prim
 ,(datum->syntax
   #f
   '(begin (require racket/runtime-path) (require (for-syntax racket/base)))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax
   #f
   '(begin (require racket/runtime-path) (require (for-syntax racket/base)))))
(return
 ,(datum->syntax
   #f
   '(begin (require racket/runtime-path) (require (for-syntax racket/base)))))
(local-post
 ,(datum->syntax
   #f
   '(begin (require racket/runtime-path) (require (for-syntax racket/base)))))
(exit-local
 ,(datum->syntax
   #f
   '(begin (require racket/runtime-path) (require (for-syntax racket/base)))))
(track-origin
 (,(datum->syntax #f '(require racket/runtime-path))
  unquote
  (datum->syntax #f '(require racket/runtime-path))))
(track-origin
 (,(datum->syntax #f '(require (for-syntax racket/base)))
  unquote
  (datum->syntax #f '(require (for-syntax racket/base)))))
(enter-local ,(datum->syntax #f '(require racket/runtime-path)))
(local-pre ,(datum->syntax #f '(require racket/runtime-path)))
(start #f)
(visit ,(datum->syntax #f '(require racket/runtime-path)))
(resolve ,(datum->syntax #f 'require))
(enter-macro ,(datum->syntax #f '(require racket/runtime-path)))
(macro-pre-transform ,(datum->syntax #f '(require racket/runtime-path)))
(macro-post-transform
 (,(datum->syntax #f '(#%require racket/runtime-path))
  unquote
  (datum->syntax #f '(require racket/runtime-path))))
(exit-macro ,(datum->syntax #f '(#%require racket/runtime-path)))
(visit ,(datum->syntax #f '(#%require racket/runtime-path)))
(resolve ,(datum->syntax #f '#%require))
(enter-prim ,(datum->syntax #f '(#%require racket/runtime-path)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(#%require racket/runtime-path)))
(return ,(datum->syntax #f '(#%require racket/runtime-path)))
(local-post ,(datum->syntax #f '(#%require racket/runtime-path)))
(exit-local ,(datum->syntax #f '(#%require racket/runtime-path)))
(enter-local ,(datum->syntax #f '(require (for-syntax racket/base))))
(local-pre ,(datum->syntax #f '(require (for-syntax racket/base))))
(start #f)
(visit ,(datum->syntax #f '(require (for-syntax racket/base))))
(resolve ,(datum->syntax #f 'require))
(enter-macro ,(datum->syntax #f '(require (for-syntax racket/base))))
(macro-pre-transform ,(datum->syntax #f '(require (for-syntax racket/base))))
(track-origin
 (,(datum->syntax #f '(for-meta 1 racket/base))
  unquote
  (datum->syntax #f '(for-meta 1 racket/base))))
(macro-post-transform
 (,(datum->syntax #f '(#%require (for-meta 1 racket/base)))
  unquote
  (datum->syntax #f '(require (for-syntax racket/base)))))
(exit-macro ,(datum->syntax #f '(#%require (for-meta 1 racket/base))))
(visit ,(datum->syntax #f '(#%require (for-meta 1 racket/base))))
(resolve ,(datum->syntax #f '#%require))
(enter-prim ,(datum->syntax #f '(#%require (for-meta 1 racket/base))))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(#%require (for-meta 1 racket/base))))
(return ,(datum->syntax #f '(#%require (for-meta 1 racket/base))))
(local-post ,(datum->syntax #f '(#%require (for-meta 1 racket/base))))
(exit-local ,(datum->syntax #f '(#%require (for-meta 1 racket/base))))
(enter-local
 ,(datum->syntax
   #f
   '(define-runtime-module-path-index
     contract-defs-submod
     '(submod ".." #%contract-defs))))
(local-pre
 ,(datum->syntax
   #f
   '(define-runtime-module-path-index
     contract-defs-submod
     '(submod ".." #%contract-defs))))
(start #f)
(visit
 ,(datum->syntax
   #f
   '(define-runtime-module-path-index
     contract-defs-submod
     '(submod ".." #%contract-defs))))
(resolve ,(datum->syntax #f 'define-runtime-module-path-index))
(enter-macro
 ,(datum->syntax
   #f
   '(define-runtime-module-path-index
     contract-defs-submod
     '(submod ".." #%contract-defs))))
(macro-pre-transform
 ,(datum->syntax
   #f
   '(define-runtime-module-path-index
     contract-defs-submod
     '(submod ".." #%contract-defs))))
(macro-post-transform
 (,(datum->syntax
    #f
    '(-define-runtime-path
      (define-runtime-module-path-index
       contract-defs-submod
       '(submod ".." #%contract-defs))
      (contract-defs-submod)
      `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))
      list
      values
      #f))
  unquote
  (datum->syntax
   #f
   '(define-runtime-module-path-index
     contract-defs-submod
     '(submod ".." #%contract-defs)))))
(exit-macro
 ,(datum->syntax
   #f
   '(-define-runtime-path
     (define-runtime-module-path-index
      contract-defs-submod
      '(submod ".." #%contract-defs))
     (contract-defs-submod)
     `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))
     list
     values
     #f)))
(visit
 ,(datum->syntax
   #f
   '(-define-runtime-path
     (define-runtime-module-path-index
      contract-defs-submod
      '(submod ".." #%contract-defs))
     (contract-defs-submod)
     `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))
     list
     values
     #f)))
(resolve ,(datum->syntax #f '-define-runtime-path))
(enter-macro
 ,(datum->syntax
   #f
   '(-define-runtime-path
     (define-runtime-module-path-index
      contract-defs-submod
      '(submod ".." #%contract-defs))
     (contract-defs-submod)
     `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))
     list
     values
     #f)))
(macro-pre-transform
 ,(datum->syntax
   #f
   '(-define-runtime-path
     (define-runtime-module-path-index
      contract-defs-submod
      '(submod ".." #%contract-defs))
     (contract-defs-submod)
     `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))
     list
     values
     #f)))
(macro-post-transform
 (,(datum->syntax
    #f
    '(begin
       (define-values
        (contract-defs-submod)
        (let-values (((contract-defs-submod)
                      `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
          (let ((get-dir void))
            (apply
             values
             (resolve-paths
              (#%variable-reference)
              get-dir
              (list contract-defs-submod))))))
       (begin-for-syntax
        (register-ext-files
         (#%variable-reference)
         (let-values (((contract-defs-submod)
                       `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
           (list contract-defs-submod))))))
  unquote
  (datum->syntax
   #f
   '(-define-runtime-path
     (define-runtime-module-path-index
      contract-defs-submod
      '(submod ".." #%contract-defs))
     (contract-defs-submod)
     `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))
     list
     values
     #f))))
(exit-macro
 ,(datum->syntax
   #f
   '(begin
      (define-values
       (contract-defs-submod)
       (let-values (((contract-defs-submod)
                     `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
         (let ((get-dir void))
           (apply
            values
            (resolve-paths
             (#%variable-reference)
             get-dir
             (list contract-defs-submod))))))
      (begin-for-syntax
       (register-ext-files
        (#%variable-reference)
        (let-values (((contract-defs-submod)
                      `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
          (list contract-defs-submod)))))))
(visit
 ,(datum->syntax
   #f
   '(begin
      (define-values
       (contract-defs-submod)
       (let-values (((contract-defs-submod)
                     `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
         (let ((get-dir void))
           (apply
            values
            (resolve-paths
             (#%variable-reference)
             get-dir
             (list contract-defs-submod))))))
      (begin-for-syntax
       (register-ext-files
        (#%variable-reference)
        (let-values (((contract-defs-submod)
                      `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
          (list contract-defs-submod)))))))
(resolve ,(datum->syntax #f 'begin))
(enter-prim
 ,(datum->syntax
   #f
   '(begin
      (define-values
       (contract-defs-submod)
       (let-values (((contract-defs-submod)
                     `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
         (let ((get-dir void))
           (apply
            values
            (resolve-paths
             (#%variable-reference)
             get-dir
             (list contract-defs-submod))))))
      (begin-for-syntax
       (register-ext-files
        (#%variable-reference)
        (let-values (((contract-defs-submod)
                      `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
          (list contract-defs-submod)))))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax
   #f
   '(begin
      (define-values
       (contract-defs-submod)
       (let-values (((contract-defs-submod)
                     `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
         (let ((get-dir void))
           (apply
            values
            (resolve-paths
             (#%variable-reference)
             get-dir
             (list contract-defs-submod))))))
      (begin-for-syntax
       (register-ext-files
        (#%variable-reference)
        (let-values (((contract-defs-submod)
                      `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
          (list contract-defs-submod)))))))
(return
 ,(datum->syntax
   #f
   '(begin
      (define-values
       (contract-defs-submod)
       (let-values (((contract-defs-submod)
                     `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
         (let ((get-dir void))
           (apply
            values
            (resolve-paths
             (#%variable-reference)
             get-dir
             (list contract-defs-submod))))))
      (begin-for-syntax
       (register-ext-files
        (#%variable-reference)
        (let-values (((contract-defs-submod)
                      `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
          (list contract-defs-submod)))))))
(local-post
 ,(datum->syntax
   #f
   '(begin
      (define-values
       (contract-defs-submod)
       (let-values (((contract-defs-submod)
                     `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
         (let ((get-dir void))
           (apply
            values
            (resolve-paths
             (#%variable-reference)
             get-dir
             (list contract-defs-submod))))))
      (begin-for-syntax
       (register-ext-files
        (#%variable-reference)
        (let-values (((contract-defs-submod)
                      `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
          (list contract-defs-submod)))))))
(exit-local
 ,(datum->syntax
   #f
   '(begin
      (define-values
       (contract-defs-submod)
       (let-values (((contract-defs-submod)
                     `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
         (let ((get-dir void))
           (apply
            values
            (resolve-paths
             (#%variable-reference)
             get-dir
             (list contract-defs-submod))))))
      (begin-for-syntax
       (register-ext-files
        (#%variable-reference)
        (let-values (((contract-defs-submod)
                      `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
          (list contract-defs-submod)))))))
(track-origin
 (,(datum->syntax
    #f
    '(define-values
      (contract-defs-submod)
      (let-values (((contract-defs-submod)
                    `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
        (let ((get-dir void))
          (apply
           values
           (resolve-paths
            (#%variable-reference)
            get-dir
            (list contract-defs-submod)))))))
  unquote
  (datum->syntax
   #f
   '(define-values
     (contract-defs-submod)
     (let-values (((contract-defs-submod)
                   `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
       (let ((get-dir void))
         (apply
          values
          (resolve-paths
           (#%variable-reference)
           get-dir
           (list contract-defs-submod)))))))))
(track-origin
 (,(datum->syntax
    #f
    '(begin-for-syntax
      (register-ext-files
       (#%variable-reference)
       (let-values (((contract-defs-submod)
                     `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
         (list contract-defs-submod)))))
  unquote
  (datum->syntax
   #f
   '(begin-for-syntax
     (register-ext-files
      (#%variable-reference)
      (let-values (((contract-defs-submod)
                    `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
        (list contract-defs-submod)))))))
(enter-local
 ,(datum->syntax
   #f
   '(define-values
     (contract-defs-submod)
     (let-values (((contract-defs-submod)
                   `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
       (let ((get-dir void))
         (apply
          values
          (resolve-paths
           (#%variable-reference)
           get-dir
           (list contract-defs-submod))))))))
(local-pre
 ,(datum->syntax
   #f
   '(define-values
     (contract-defs-submod)
     (let-values (((contract-defs-submod)
                   `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
       (let ((get-dir void))
         (apply
          values
          (resolve-paths
           (#%variable-reference)
           get-dir
           (list contract-defs-submod))))))))
(start #f)
(visit
 ,(datum->syntax
   #f
   '(define-values
     (contract-defs-submod)
     (let-values (((contract-defs-submod)
                   `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
       (let ((get-dir void))
         (apply
          values
          (resolve-paths
           (#%variable-reference)
           get-dir
           (list contract-defs-submod))))))))
(resolve ,(datum->syntax #f 'define-values))
(enter-prim
 ,(datum->syntax
   #f
   '(define-values
     (contract-defs-submod)
     (let-values (((contract-defs-submod)
                   `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
       (let ((get-dir void))
         (apply
          values
          (resolve-paths
           (#%variable-reference)
           get-dir
           (list contract-defs-submod))))))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax
   #f
   '(define-values
     (contract-defs-submod)
     (let-values (((contract-defs-submod)
                   `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
       (let ((get-dir void))
         (apply
          values
          (resolve-paths
           (#%variable-reference)
           get-dir
           (list contract-defs-submod))))))))
(return
 ,(datum->syntax
   #f
   '(define-values
     (contract-defs-submod)
     (let-values (((contract-defs-submod)
                   `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
       (let ((get-dir void))
         (apply
          values
          (resolve-paths
           (#%variable-reference)
           get-dir
           (list contract-defs-submod))))))))
(local-post
 ,(datum->syntax
   #f
   '(define-values
     (contract-defs-submod)
     (let-values (((contract-defs-submod)
                   `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
       (let ((get-dir void))
         (apply
          values
          (resolve-paths
           (#%variable-reference)
           get-dir
           (list contract-defs-submod))))))))
(exit-local
 ,(datum->syntax
   #f
   '(define-values
     (contract-defs-submod)
     (let-values (((contract-defs-submod)
                   `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
       (let ((get-dir void))
         (apply
          values
          (resolve-paths
           (#%variable-reference)
           get-dir
           (list contract-defs-submod))))))))
(enter-local
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (register-ext-files
      (#%variable-reference)
      (let-values (((contract-defs-submod)
                    `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
        (list contract-defs-submod))))))
(local-pre
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (register-ext-files
      (#%variable-reference)
      (let-values (((contract-defs-submod)
                    `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
        (list contract-defs-submod))))))
(start #f)
(visit
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (register-ext-files
      (#%variable-reference)
      (let-values (((contract-defs-submod)
                    `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
        (list contract-defs-submod))))))
(resolve ,(datum->syntax #f 'begin-for-syntax))
(enter-prim
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (register-ext-files
      (#%variable-reference)
      (let-values (((contract-defs-submod)
                    `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
        (list contract-defs-submod))))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (register-ext-files
      (#%variable-reference)
      (let-values (((contract-defs-submod)
                    `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
        (list contract-defs-submod))))))
(return
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (register-ext-files
      (#%variable-reference)
      (let-values (((contract-defs-submod)
                    `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
        (list contract-defs-submod))))))
(local-post
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (register-ext-files
      (#%variable-reference)
      (let-values (((contract-defs-submod)
                    `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
        (list contract-defs-submod))))))
(exit-local
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (register-ext-files
      (#%variable-reference)
      (let-values (((contract-defs-submod)
                    `(module ,'(submod ".." #%contract-defs) ,(#%variable-reference))))
        (list contract-defs-submod))))))
(enter-local ,(datum->syntax #f '(provide contract-defs-submod)))
(local-pre ,(datum->syntax #f '(provide contract-defs-submod)))
(start #f)
(visit ,(datum->syntax #f '(provide contract-defs-submod)))
(resolve ,(datum->syntax #f 'provide))
(enter-macro ,(datum->syntax #f '(provide contract-defs-submod)))
(macro-pre-transform ,(datum->syntax #f '(provide contract-defs-submod)))
(macro-post-transform
 (,(datum->syntax
    #f
    '(#%provide (expand (provide-trampoline contract-defs-submod))))
  unquote
  (datum->syntax #f '(provide contract-defs-submod))))
(exit-macro
 ,(datum->syntax
   #f
   '(#%provide (expand (provide-trampoline contract-defs-submod)))))
(visit
 ,(datum->syntax
   #f
   '(#%provide (expand (provide-trampoline contract-defs-submod)))))
(resolve ,(datum->syntax #f '#%provide))
(enter-prim
 ,(datum->syntax
   #f
   '(#%provide (expand (provide-trampoline contract-defs-submod)))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax
   #f
   '(#%provide (expand (provide-trampoline contract-defs-submod)))))
(return
 ,(datum->syntax
   #f
   '(#%provide (expand (provide-trampoline contract-defs-submod)))))
(local-post
 ,(datum->syntax
   #f
   '(#%provide (expand (provide-trampoline contract-defs-submod)))))
(exit-local
 ,(datum->syntax
   #f
   '(#%provide (expand (provide-trampoline contract-defs-submod)))))
(exit-prim
 ,(datum->syntax
   #f
   '(begin-for-syntax
     (#%require typed-racket/utils/redirect-contract)
     (module #%contract-defs-reference racket/base
       (#%module-begin
        (module configure-runtime '#%kernel
          (#%module-begin
           (#%require racket/runtime-config)
           (#%app configure '#f)))
        (#%require racket/runtime-path)
        (#%require (for-meta 1 racket/base))
        (define-values
         (contract-defs-submod)
         (let-values (((contract-defs-submod)
                       (#%app
                        list
                        'module
                        '(submod ".." #%contract-defs)
                        (#%variable-reference))))
           (let-values (((get-dir) void))
             (#%app
              apply
              values
              (#%app
               resolve-paths
               (#%variable-reference)
               get-dir
               (#%app list contract-defs-submod))))))
        (begin-for-syntax
         (#%app
          register-ext-files
          (#%variable-reference)
          (let-values (((contract-defs-submod)
                        (#%app
                         list
                         'module
                         '(submod ".." #%contract-defs)
                         (#%variable-reference))))
            (#%app list contract-defs-submod))))
        (#%provide contract-defs-submod)))
     (#%require (submod "." #%contract-defs-reference))
     (define-values
      (make-redirect2)
      (#%app make-make-redirect-to-contract contract-defs-submod)))))
(next #f)
(visit
 ,(datum->syntax
   #f
   '(do-wrapping-module-begin
     print-result
     (module*
      #%contract-defs
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require (submod typed-racket/private/type-contract predicates)
                typed-racket/utils/utils
                (for-syntax typed-racket/utils/utils)
                typed-racket/utils/any-wrap
                typed-racket/utils/struct-type-c
                typed-racket/utils/opaque-object
                typed-racket/utils/evt-contract
                typed-racket/utils/sealing-contract
                racket/sequence
                racket/contract/parametric))))))
(resolve ,(datum->syntax #f 'do-wrapping-module-begin))
(enter-macro
 ,(datum->syntax
   #f
   '(do-wrapping-module-begin
     print-result
     (module*
      #%contract-defs
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require (submod typed-racket/private/type-contract predicates)
                typed-racket/utils/utils
                (for-syntax typed-racket/utils/utils)
                typed-racket/utils/any-wrap
                typed-racket/utils/struct-type-c
                typed-racket/utils/opaque-object
                typed-racket/utils/evt-contract
                typed-racket/utils/sealing-contract
                racket/sequence
                racket/contract/parametric))))))
(macro-pre-transform
 ,(datum->syntax
   #f
   '(do-wrapping-module-begin
     print-result
     (module*
      #%contract-defs
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require (submod typed-racket/private/type-contract predicates)
                typed-racket/utils/utils
                (for-syntax typed-racket/utils/utils)
                typed-racket/utils/any-wrap
                typed-racket/utils/struct-type-c
                typed-racket/utils/opaque-object
                typed-racket/utils/evt-contract
                typed-racket/utils/sealing-contract
                racket/sequence
                racket/contract/parametric))))))
(enter-local
 ,(datum->syntax
   #f
   '(module*
     #%contract-defs
     #f
     (#%plain-module-begin
      (#%declare #:empty-namespace)
      (require (submod typed-racket/private/type-contract predicates)
               typed-racket/utils/utils
               (for-syntax typed-racket/utils/utils)
               typed-racket/utils/any-wrap
               typed-racket/utils/struct-type-c
               typed-racket/utils/opaque-object
               typed-racket/utils/evt-contract
               typed-racket/utils/sealing-contract
               racket/sequence
               racket/contract/parametric)))))
(local-pre
 ,(datum->syntax
   #f
   '(module*
     #%contract-defs
     #f
     (#%plain-module-begin
      (#%declare #:empty-namespace)
      (require (submod typed-racket/private/type-contract predicates)
               typed-racket/utils/utils
               (for-syntax typed-racket/utils/utils)
               typed-racket/utils/any-wrap
               typed-racket/utils/struct-type-c
               typed-racket/utils/opaque-object
               typed-racket/utils/evt-contract
               typed-racket/utils/sealing-contract
               racket/sequence
               racket/contract/parametric)))))
(start #f)
(visit
 ,(datum->syntax
   #f
   '(module*
     #%contract-defs
     #f
     (#%plain-module-begin
      (#%declare #:empty-namespace)
      (require (submod typed-racket/private/type-contract predicates)
               typed-racket/utils/utils
               (for-syntax typed-racket/utils/utils)
               typed-racket/utils/any-wrap
               typed-racket/utils/struct-type-c
               typed-racket/utils/opaque-object
               typed-racket/utils/evt-contract
               typed-racket/utils/sealing-contract
               racket/sequence
               racket/contract/parametric)))))
(resolve ,(datum->syntax #f 'module*))
(enter-prim
 ,(datum->syntax
   #f
   '(module*
     #%contract-defs
     #f
     (#%plain-module-begin
      (#%declare #:empty-namespace)
      (require (submod typed-racket/private/type-contract predicates)
               typed-racket/utils/utils
               (for-syntax typed-racket/utils/utils)
               typed-racket/utils/any-wrap
               typed-racket/utils/struct-type-c
               typed-racket/utils/opaque-object
               typed-racket/utils/evt-contract
               typed-racket/utils/sealing-contract
               racket/sequence
               racket/contract/parametric)))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax
   #f
   '(module*
     #%contract-defs
     #f
     (#%plain-module-begin
      (#%declare #:empty-namespace)
      (require (submod typed-racket/private/type-contract predicates)
               typed-racket/utils/utils
               (for-syntax typed-racket/utils/utils)
               typed-racket/utils/any-wrap
               typed-racket/utils/struct-type-c
               typed-racket/utils/opaque-object
               typed-racket/utils/evt-contract
               typed-racket/utils/sealing-contract
               racket/sequence
               racket/contract/parametric)))))
(return
 ,(datum->syntax
   #f
   '(module*
     #%contract-defs
     #f
     (#%plain-module-begin
      (#%declare #:empty-namespace)
      (require (submod typed-racket/private/type-contract predicates)
               typed-racket/utils/utils
               (for-syntax typed-racket/utils/utils)
               typed-racket/utils/any-wrap
               typed-racket/utils/struct-type-c
               typed-racket/utils/opaque-object
               typed-racket/utils/evt-contract
               typed-racket/utils/sealing-contract
               racket/sequence
               racket/contract/parametric)))))
(local-post
 ,(datum->syntax
   #f
   '(module*
     #%contract-defs
     #f
     (#%plain-module-begin
      (#%declare #:empty-namespace)
      (require (submod typed-racket/private/type-contract predicates)
               typed-racket/utils/utils
               (for-syntax typed-racket/utils/utils)
               typed-racket/utils/any-wrap
               typed-racket/utils/struct-type-c
               typed-racket/utils/opaque-object
               typed-racket/utils/evt-contract
               typed-racket/utils/sealing-contract
               racket/sequence
               racket/contract/parametric)))))
(exit-local
 ,(datum->syntax
   #f
   '(module*
     #%contract-defs
     #f
     (#%plain-module-begin
      (#%declare #:empty-namespace)
      (require (submod typed-racket/private/type-contract predicates)
               typed-racket/utils/utils
               (for-syntax typed-racket/utils/utils)
               typed-racket/utils/any-wrap
               typed-racket/utils/struct-type-c
               typed-racket/utils/opaque-object
               typed-racket/utils/evt-contract
               typed-racket/utils/sealing-contract
               racket/sequence
               racket/contract/parametric)))))
(macro-post-transform
 (,(datum->syntax
    #f
    '(begin
       (module*
        #%contract-defs
        #f
        (#%plain-module-begin
         (#%declare #:empty-namespace)
         (require (submod typed-racket/private/type-contract predicates)
                  typed-racket/utils/utils
                  (for-syntax typed-racket/utils/utils)
                  typed-racket/utils/any-wrap
                  typed-racket/utils/struct-type-c
                  typed-racket/utils/opaque-object
                  typed-racket/utils/evt-contract
                  typed-racket/utils/sealing-contract
                  racket/sequence
                  racket/contract/parametric)))))
  unquote
  (datum->syntax
   #f
   '(do-wrapping-module-begin
     print-result
     (module*
      #%contract-defs
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require (submod typed-racket/private/type-contract predicates)
                typed-racket/utils/utils
                (for-syntax typed-racket/utils/utils)
                typed-racket/utils/any-wrap
                typed-racket/utils/struct-type-c
                typed-racket/utils/opaque-object
                typed-racket/utils/evt-contract
                typed-racket/utils/sealing-contract
                racket/sequence
                racket/contract/parametric)))))))
(exit-macro
 ,(datum->syntax
   #f
   '(begin
      (module*
       #%contract-defs
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require (submod typed-racket/private/type-contract predicates)
                 typed-racket/utils/utils
                 (for-syntax typed-racket/utils/utils)
                 typed-racket/utils/any-wrap
                 typed-racket/utils/struct-type-c
                 typed-racket/utils/opaque-object
                 typed-racket/utils/evt-contract
                 typed-racket/utils/sealing-contract
                 racket/sequence
                 racket/contract/parametric))))))
(visit
 ,(datum->syntax
   #f
   '(begin
      (module*
       #%contract-defs
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require (submod typed-racket/private/type-contract predicates)
                 typed-racket/utils/utils
                 (for-syntax typed-racket/utils/utils)
                 typed-racket/utils/any-wrap
                 typed-racket/utils/struct-type-c
                 typed-racket/utils/opaque-object
                 typed-racket/utils/evt-contract
                 typed-racket/utils/sealing-contract
                 racket/sequence
                 racket/contract/parametric))))))
(resolve ,(datum->syntax #f 'begin))
(enter-prim
 ,(datum->syntax
   #f
   '(begin
      (module*
       #%contract-defs
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require (submod typed-racket/private/type-contract predicates)
                 typed-racket/utils/utils
                 (for-syntax typed-racket/utils/utils)
                 typed-racket/utils/any-wrap
                 typed-racket/utils/struct-type-c
                 typed-racket/utils/opaque-object
                 typed-racket/utils/evt-contract
                 typed-racket/utils/sealing-contract
                 racket/sequence
                 racket/contract/parametric))))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax
   #f
   '(begin
      (module*
       #%contract-defs
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require (submod typed-racket/private/type-contract predicates)
                 typed-racket/utils/utils
                 (for-syntax typed-racket/utils/utils)
                 typed-racket/utils/any-wrap
                 typed-racket/utils/struct-type-c
                 typed-racket/utils/opaque-object
                 typed-racket/utils/evt-contract
                 typed-racket/utils/sealing-contract
                 racket/sequence
                 racket/contract/parametric))))))
(return
 ,(datum->syntax
   #f
   '(begin
      (module*
       #%contract-defs
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require (submod typed-racket/private/type-contract predicates)
                 typed-racket/utils/utils
                 (for-syntax typed-racket/utils/utils)
                 typed-racket/utils/any-wrap
                 typed-racket/utils/struct-type-c
                 typed-racket/utils/opaque-object
                 typed-racket/utils/evt-contract
                 typed-racket/utils/sealing-contract
                 racket/sequence
                 racket/contract/parametric))))))
(rename-one
 ,(datum->syntax
   #f
   '(begin
      (module*
       #%contract-defs
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (require (submod typed-racket/private/type-contract predicates)
                 typed-racket/utils/utils
                 (for-syntax typed-racket/utils/utils)
                 typed-racket/utils/any-wrap
                 typed-racket/utils/struct-type-c
                 typed-racket/utils/opaque-object
                 typed-racket/utils/evt-contract
                 typed-racket/utils/sealing-contract
                 racket/sequence
                 racket/contract/parametric))))))
(splice
 (,(datum->syntax
    #f
    '(module*
      #%contract-defs
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (require (submod typed-racket/private/type-contract predicates)
                typed-racket/utils/utils
                (for-syntax typed-racket/utils/utils)
                typed-racket/utils/any-wrap
                typed-racket/utils/struct-type-c
                typed-racket/utils/opaque-object
                typed-racket/utils/evt-contract
                typed-racket/utils/sealing-contract
                racket/sequence
                racket/contract/parametric))))
  ,(datum->syntax #f '(do-wrapping-module-begin print-result '"hello world"))
  ,(datum->syntax #f '(do-wrapping-module-begin print-result (void)))))
(next #f)
(visit
 ,(datum->syntax
   #f
   '(module*
     #%contract-defs
     #f
     (#%plain-module-begin
      (#%declare #:empty-namespace)
      (require (submod typed-racket/private/type-contract predicates)
               typed-racket/utils/utils
               (for-syntax typed-racket/utils/utils)
               typed-racket/utils/any-wrap
               typed-racket/utils/struct-type-c
               typed-racket/utils/opaque-object
               typed-racket/utils/evt-contract
               typed-racket/utils/sealing-contract
               racket/sequence
               racket/contract/parametric)))))
(resolve ,(datum->syntax #f 'module*))
(enter-prim
 ,(datum->syntax
   #f
   '(module*
     #%contract-defs
     #f
     (#%plain-module-begin
      (#%declare #:empty-namespace)
      (require (submod typed-racket/private/type-contract predicates)
               typed-racket/utils/utils
               (for-syntax typed-racket/utils/utils)
               typed-racket/utils/any-wrap
               typed-racket/utils/struct-type-c
               typed-racket/utils/opaque-object
               typed-racket/utils/evt-contract
               typed-racket/utils/sealing-contract
               racket/sequence
               racket/contract/parametric)))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax
   #f
   '(module*
     #%contract-defs
     #f
     (#%plain-module-begin
      (#%declare #:empty-namespace)
      (require (submod typed-racket/private/type-contract predicates)
               typed-racket/utils/utils
               (for-syntax typed-racket/utils/utils)
               typed-racket/utils/any-wrap
               typed-racket/utils/struct-type-c
               typed-racket/utils/opaque-object
               typed-racket/utils/evt-contract
               typed-racket/utils/sealing-contract
               racket/sequence
               racket/contract/parametric)))))
(return
 ,(datum->syntax
   #f
   '(module*
     #%contract-defs
     #f
     (#%plain-module-begin
      (#%declare #:empty-namespace)
      (require (submod typed-racket/private/type-contract predicates)
               typed-racket/utils/utils
               (for-syntax typed-racket/utils/utils)
               typed-racket/utils/any-wrap
               typed-racket/utils/struct-type-c
               typed-racket/utils/opaque-object
               typed-racket/utils/evt-contract
               typed-racket/utils/sealing-contract
               racket/sequence
               racket/contract/parametric)))))
(rename-one
 ,(datum->syntax
   #f
   '(module*
     #%contract-defs
     #f
     (#%plain-module-begin
      (#%declare #:empty-namespace)
      (require (submod typed-racket/private/type-contract predicates)
               typed-racket/utils/utils
               (for-syntax typed-racket/utils/utils)
               typed-racket/utils/any-wrap
               typed-racket/utils/struct-type-c
               typed-racket/utils/opaque-object
               typed-racket/utils/evt-contract
               typed-racket/utils/sealing-contract
               racket/sequence
               racket/contract/parametric)))))
(enter-prim
 ,(datum->syntax
   #f
   '(module*
     #%contract-defs
     #f
     (#%plain-module-begin
      (#%declare #:empty-namespace)
      (require (submod typed-racket/private/type-contract predicates)
               typed-racket/utils/utils
               (for-syntax typed-racket/utils/utils)
               typed-racket/utils/any-wrap
               typed-racket/utils/struct-type-c
               typed-racket/utils/opaque-object
               typed-racket/utils/evt-contract
               typed-racket/utils/sealing-contract
               racket/sequence
               racket/contract/parametric)))))
(prim-submodule* #f)
(exit-prim
 ,(datum->syntax
   #f
   '(module*
     #%contract-defs
     #f
     (#%plain-module-begin
      (#%declare #:empty-namespace)
      (require (submod typed-racket/private/type-contract predicates)
               typed-racket/utils/utils
               (for-syntax typed-racket/utils/utils)
               typed-racket/utils/any-wrap
               typed-racket/utils/struct-type-c
               typed-racket/utils/opaque-object
               typed-racket/utils/evt-contract
               typed-racket/utils/sealing-contract
               racket/sequence
               racket/contract/parametric)))))
(next #f)
(visit
 ,(datum->syntax #f '(do-wrapping-module-begin print-result '"hello world")))
(resolve ,(datum->syntax #f 'do-wrapping-module-begin))
(enter-macro
 ,(datum->syntax #f '(do-wrapping-module-begin print-result '"hello world")))
(macro-pre-transform
 ,(datum->syntax #f '(do-wrapping-module-begin print-result '"hello world")))
(enter-local ,(datum->syntax #f ''"hello world"))
(local-pre ,(datum->syntax #f ''"hello world"))
(start #f)
(visit ,(datum->syntax #f ''"hello world"))
(resolve ,(datum->syntax #f 'quote))
(enter-prim ,(datum->syntax #f ''"hello world"))
(prim-stop #f)
(exit-prim ,(datum->syntax #f ''"hello world"))
(return ,(datum->syntax #f ''"hello world"))
(local-post ,(datum->syntax #f ''"hello world"))
(exit-local ,(datum->syntax #f ''"hello world"))
(macro-post-transform
 (,(datum->syntax #f '(begin (print-result '"hello world")))
  unquote
  (datum->syntax #f '(do-wrapping-module-begin print-result '"hello world"))))
(exit-macro ,(datum->syntax #f '(begin (print-result '"hello world"))))
(visit ,(datum->syntax #f '(begin (print-result '"hello world"))))
(resolve ,(datum->syntax #f 'begin))
(enter-prim ,(datum->syntax #f '(begin (print-result '"hello world"))))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(begin (print-result '"hello world"))))
(return ,(datum->syntax #f '(begin (print-result '"hello world"))))
(rename-one ,(datum->syntax #f '(begin (print-result '"hello world"))))
(splice
 (,(datum->syntax #f '(print-result '"hello world"))
  ,(datum->syntax #f '(do-wrapping-module-begin print-result (void)))))
(next #f)
(visit ,(datum->syntax #f '(print-result '"hello world")))
(resolve ,(datum->syntax #f 'print-result))
(enter-macro ,(datum->syntax #f '(print-result '"hello world")))
(macro-pre-transform ,(datum->syntax #f '(print-result '"hello world")))
(macro-post-transform
 (,(datum->syntax
    #f
    '(#%app call-with-values (lambda () '"hello world") print-values))
  unquote
  (datum->syntax #f '(print-result '"hello world"))))
(exit-macro
 ,(datum->syntax
   #f
   '(#%app call-with-values (lambda () '"hello world") print-values)))
(visit
 ,(datum->syntax
   #f
   '(#%app call-with-values (lambda () '"hello world") print-values)))
(resolve ,(datum->syntax #f '#%app))
(enter-prim
 ,(datum->syntax
   #f
   '(#%app call-with-values (lambda () '"hello world") print-values)))
(prim-stop #f)
(exit-prim
 ,(datum->syntax
   #f
   '(#%app call-with-values (lambda () '"hello world") print-values)))
(return
 ,(datum->syntax
   #f
   '(#%app call-with-values (lambda () '"hello world") print-values)))
(rename-one
 ,(datum->syntax
   #f
   '(#%app call-with-values (lambda () '"hello world") print-values)))
(next #f)
(visit ,(datum->syntax #f '(do-wrapping-module-begin print-result (void))))
(resolve ,(datum->syntax #f 'do-wrapping-module-begin))
(enter-macro
 ,(datum->syntax #f '(do-wrapping-module-begin print-result (void))))
(macro-pre-transform
 ,(datum->syntax #f '(do-wrapping-module-begin print-result (void))))
(enter-local ,(datum->syntax #f '(void)))
(local-pre ,(datum->syntax #f '(void)))
(start #f)
(visit ,(datum->syntax #f '(void)))
(resolve ,(datum->syntax #f 'void))
(resolve ,(datum->syntax #f '#%app))
(tag ,(datum->syntax #f '(#%app void)))
(enter-macro ,(datum->syntax #f '(#%app void)))
(macro-pre-transform ,(datum->syntax #f '(#%app void)))
(macro-post-transform
 (,(datum->syntax #f '(#%app void)) . ,(datum->syntax #f '(#%app void))))
(exit-macro ,(datum->syntax #f '(#%app void)))
(visit ,(datum->syntax #f '(#%app void)))
(resolve ,(datum->syntax #f '#%app))
(enter-prim ,(datum->syntax #f '(#%app void)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(#%app void)))
(return ,(datum->syntax #f '(#%app void)))
(local-post ,(datum->syntax #f '(#%app void)))
(exit-local ,(datum->syntax #f '(#%app void)))
(macro-post-transform
 (,(datum->syntax #f '(begin (#%app void)))
  unquote
  (datum->syntax #f '(do-wrapping-module-begin print-result (void)))))
(exit-macro ,(datum->syntax #f '(begin (#%app void))))
(visit ,(datum->syntax #f '(begin (#%app void))))
(resolve ,(datum->syntax #f 'begin))
(enter-prim ,(datum->syntax #f '(begin (#%app void))))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(begin (#%app void))))
(return ,(datum->syntax #f '(begin (#%app void))))
(rename-one ,(datum->syntax #f '(begin (#%app void))))
(splice (,(datum->syntax #f '(#%app void))))
(next #f)
(visit ,(datum->syntax #f '(#%app void)))
(resolve ,(datum->syntax #f '#%app))
(enter-prim ,(datum->syntax #f '(#%app void)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(#%app void)))
(return ,(datum->syntax #f '(#%app void)))
(rename-one ,(datum->syntax #f '(#%app void)))
(lift-end-loop ())
(next-group #f)
(next #f)
(next #f)
(next #f)
(next #f)
(visit ,(datum->syntax #f '(define-values (blame1) (quote-module-name))))
(resolve ,(datum->syntax #f 'define-values))
(enter-prim ,(datum->syntax #f '(define-values (blame1) (quote-module-name))))
(prim-define-values #f)
(visit ,(datum->syntax #f '(quote-module-name)))
(resolve ,(datum->syntax #f 'quote-module-name))
(enter-macro ,(datum->syntax #f '(quote-module-name)))
(macro-pre-transform ,(datum->syntax #f '(quote-module-name)))
(macro-post-transform
 (,(datum->syntax #f '(module-name-fixup (module-source) (list)))
  unquote
  (datum->syntax #f '(quote-module-name))))
(exit-macro ,(datum->syntax #f '(module-name-fixup (module-source) (list))))
(visit ,(datum->syntax #f '(module-name-fixup (module-source) (list))))
(resolve ,(datum->syntax #f 'module-name-fixup))
(resolve ,(datum->syntax #f '#%app))
(tag ,(datum->syntax #f '(#%app module-name-fixup (module-source) (list))))
(enter-macro
 ,(datum->syntax #f '(#%app module-name-fixup (module-source) (list))))
(macro-pre-transform
 ,(datum->syntax #f '(#%app module-name-fixup (module-source) (list))))
(macro-post-transform
 (,(datum->syntax #f '(#%app module-name-fixup (module-source) (list)))
  unquote
  (datum->syntax #f '(#%app module-name-fixup (module-source) (list)))))
(exit-macro
 ,(datum->syntax #f '(#%app module-name-fixup (module-source) (list))))
(visit ,(datum->syntax #f '(#%app module-name-fixup (module-source) (list))))
(resolve ,(datum->syntax #f '#%app))
(enter-prim
 ,(datum->syntax #f '(#%app module-name-fixup (module-source) (list))))
(prim-#%app #f)
(enter-list ,(datum->syntax #f '(module-name-fixup (module-source) (list))))
(next #f)
(visit ,(datum->syntax #f 'module-name-fixup))
(resolve ,(datum->syntax #f 'module-name-fixup))
(variable
 (,(datum->syntax #f 'module-name-fixup)
  unquote
  (datum->syntax #f 'module-name-fixup)))
(return ,(datum->syntax #f 'module-name-fixup))
(next #f)
(visit ,(datum->syntax #f '(module-source)))
(resolve ,(datum->syntax #f 'module-source))
(enter-macro ,(datum->syntax #f '(module-source)))
(macro-pre-transform ,(datum->syntax #f '(module-source)))
(macro-post-transform
 (,(datum->syntax
    #f
    '(variable-reference->module-source/submod (#%variable-reference)))
  unquote
  (datum->syntax #f '(module-source))))
(exit-macro
 ,(datum->syntax
   #f
   '(variable-reference->module-source/submod (#%variable-reference))))
(visit
 ,(datum->syntax
   #f
   '(variable-reference->module-source/submod (#%variable-reference))))
(resolve ,(datum->syntax #f 'variable-reference->module-source/submod))
(resolve ,(datum->syntax #f '#%app))
(tag
 ,(datum->syntax
   #f
   '(#%app variable-reference->module-source/submod (#%variable-reference))))
(enter-macro
 ,(datum->syntax
   #f
   '(#%app variable-reference->module-source/submod (#%variable-reference))))
(macro-pre-transform
 ,(datum->syntax
   #f
   '(#%app variable-reference->module-source/submod (#%variable-reference))))
(macro-post-transform
 (,(datum->syntax
    #f
    '(#%app variable-reference->module-source/submod (#%variable-reference)))
  unquote
  (datum->syntax
   #f
   '(#%app variable-reference->module-source/submod (#%variable-reference)))))
(exit-macro
 ,(datum->syntax
   #f
   '(#%app variable-reference->module-source/submod (#%variable-reference))))
(visit
 ,(datum->syntax
   #f
   '(#%app variable-reference->module-source/submod (#%variable-reference))))
(resolve ,(datum->syntax #f '#%app))
(enter-prim
 ,(datum->syntax
   #f
   '(#%app variable-reference->module-source/submod (#%variable-reference))))
(prim-#%app #f)
(enter-list
 ,(datum->syntax
   #f
   '(variable-reference->module-source/submod (#%variable-reference))))
(next #f)
(visit ,(datum->syntax #f 'variable-reference->module-source/submod))
(resolve ,(datum->syntax #f 'variable-reference->module-source/submod))
(variable
 (,(datum->syntax #f 'variable-reference->module-source/submod)
  unquote
  (datum->syntax #f 'variable-reference->module-source/submod)))
(return ,(datum->syntax #f 'variable-reference->module-source/submod))
(next #f)
(visit ,(datum->syntax #f '(#%variable-reference)))
(resolve ,(datum->syntax #f '#%variable-reference))
(enter-prim ,(datum->syntax #f '(#%variable-reference)))
(prim-varref #f)
(exit-prim ,(datum->syntax #f '(#%variable-reference)))
(return ,(datum->syntax #f '(#%variable-reference)))
(exit-list
 ,(datum->syntax
   #f
   '(variable-reference->module-source/submod (#%variable-reference))))
(exit-prim
 ,(datum->syntax
   #f
   '(#%app variable-reference->module-source/submod (#%variable-reference))))
(return
 ,(datum->syntax
   #f
   '(#%app variable-reference->module-source/submod (#%variable-reference))))
(next #f)
(visit ,(datum->syntax #f '(list)))
(resolve ,(datum->syntax #f 'list))
(resolve ,(datum->syntax #f '#%app))
(tag ,(datum->syntax #f '(#%app list)))
(enter-macro ,(datum->syntax #f '(#%app list)))
(macro-pre-transform ,(datum->syntax #f '(#%app list)))
(macro-post-transform
 (,(datum->syntax #f '(#%app list)) . ,(datum->syntax #f '(#%app list))))
(exit-macro ,(datum->syntax #f '(#%app list)))
(visit ,(datum->syntax #f '(#%app list)))
(resolve ,(datum->syntax #f '#%app))
(enter-prim ,(datum->syntax #f '(#%app list)))
(prim-#%app #f)
(enter-list ,(datum->syntax #f '(list)))
(next #f)
(visit ,(datum->syntax #f 'list))
(resolve ,(datum->syntax #f 'list))
(variable (,(datum->syntax #f 'list) . ,(datum->syntax #f 'list)))
(return ,(datum->syntax #f 'list))
(exit-list ,(datum->syntax #f '(list)))
(exit-prim ,(datum->syntax #f '(#%app list)))
(return ,(datum->syntax #f '(#%app list)))
(exit-list
 ,(datum->syntax
   #f
   '(module-name-fixup
     (#%app variable-reference->module-source/submod (#%variable-reference))
     (#%app list))))
(exit-prim
 ,(datum->syntax
   #f
   '(#%app
     module-name-fixup
     (#%app variable-reference->module-source/submod (#%variable-reference))
     (#%app list))))
(return
 ,(datum->syntax
   #f
   '(#%app
     module-name-fixup
     (#%app variable-reference->module-source/submod (#%variable-reference))
     (#%app list))))
(exit-prim
 ,(datum->syntax
   #f
   '(define-values
     (blame1)
     (#%app
      module-name-fixup
      (#%app variable-reference->module-source/submod (#%variable-reference))
      (#%app list)))))
(return
 ,(datum->syntax
   #f
   '(define-values
     (blame1)
     (#%app
      module-name-fixup
      (#%app variable-reference->module-source/submod (#%variable-reference))
      (#%app list)))))
(next #f)
(next #f)
(next #f)
(visit
 ,(datum->syntax
   #f
   '(#%app call-with-values (lambda () '"hello world") print-values)))
(resolve ,(datum->syntax #f '#%app))
(enter-prim
 ,(datum->syntax
   #f
   '(#%app call-with-values (lambda () '"hello world") print-values)))
(prim-#%app #f)
(enter-list
 ,(datum->syntax
   #f
   '(call-with-values (lambda () '"hello world") print-values)))
(next #f)
(visit ,(datum->syntax #f 'call-with-values))
(resolve ,(datum->syntax #f 'call-with-values))
(variable
 (,(datum->syntax #f 'call-with-values)
  unquote
  (datum->syntax #f 'call-with-values)))
(return ,(datum->syntax #f 'call-with-values))
(next #f)
(visit ,(datum->syntax #f '(lambda () '"hello world")))
(resolve ,(datum->syntax #f 'lambda))
(enter-prim ,(datum->syntax #f '(lambda () '"hello world")))
(prim-lambda #f)
(renames-lambda
 (,(datum->syntax #f '()) . ,(datum->syntax #f '('"hello world"))))
(enter-block ,(datum->syntax #f '('"hello world")))
(renames-block
 (,(datum->syntax #f '('"hello world"))
  unquote
  (datum->syntax #f '('"hello world"))))
(next #f)
(enter-check ,(datum->syntax #f ''"hello world"))
(exit-check ,(datum->syntax #f ''"hello world"))
(block->list ,(datum->syntax #f '('"hello world")))
(enter-list ,(datum->syntax #f '('"hello world")))
(next #f)
(visit ,(datum->syntax #f ''"hello world"))
(resolve ,(datum->syntax #f 'quote))
(enter-prim ,(datum->syntax #f ''"hello world"))
(prim-quote #f)
(exit-prim ,(datum->syntax #f ''"hello world"))
(return ,(datum->syntax #f ''"hello world"))
(exit-list ,(datum->syntax #f '('"hello world")))
(exit-prim ,(datum->syntax #f '(lambda () '"hello world")))
(return ,(datum->syntax #f '(lambda () '"hello world")))
(next #f)
(visit ,(datum->syntax #f 'print-values))
(resolve ,(datum->syntax #f 'print-values))
(variable
 (,(datum->syntax #f 'print-values) . ,(datum->syntax #f 'print-values)))
(return ,(datum->syntax #f 'print-values))
(exit-list
 ,(datum->syntax
   #f
   '(call-with-values (lambda () '"hello world") print-values)))
(exit-prim
 ,(datum->syntax
   #f
   '(#%app call-with-values (lambda () '"hello world") print-values)))
(return
 ,(datum->syntax
   #f
   '(#%app call-with-values (lambda () '"hello world") print-values)))
(next #f)
(visit ,(datum->syntax #f '(#%app void)))
(resolve ,(datum->syntax #f '#%app))
(enter-prim ,(datum->syntax #f '(#%app void)))
(prim-#%app #f)
(enter-list ,(datum->syntax #f '(void)))
(next #f)
(visit ,(datum->syntax #f 'void))
(resolve ,(datum->syntax #f 'void))
(variable (,(datum->syntax #f 'void) . ,(datum->syntax #f 'void)))
(return ,(datum->syntax #f 'void))
(exit-list ,(datum->syntax #f '(void)))
(exit-prim ,(datum->syntax #f '(#%app void)))
(return ,(datum->syntax #f '(#%app void)))
(lift-end-loop ())
(next-group #f)
(next #f)
(enter-prim
 ,(datum->syntax
   #f
   '(module*
     #%type-decl
     #f
     (#%plain-module-begin
      (#%declare #:empty-namespace)
      (require typed-racket/types/numeric-tower
               typed-racket/env/type-name-env
               typed-racket/env/global-env
               typed-racket/env/type-alias-env
               typed-racket/types/struct-table
               typed-racket/types/abbrev
               (rename-in racket/private/sort (sort raw-sort)))
      (begin)
      (begin)
      (begin)
      (begin)
      (begin)
      (begin)
      (begin)))))
(prim-module #f)
(prepare-env #f)
(rename-one
 ,(datum->syntax
   #f
   '(#%plain-module-begin
     (#%declare #:empty-namespace)
     (require typed-racket/types/numeric-tower
              typed-racket/env/type-name-env
              typed-racket/env/global-env
              typed-racket/env/type-alias-env
              typed-racket/types/struct-table
              typed-racket/types/abbrev
              (rename-in racket/private/sort (sort raw-sort)))
     (begin)
     (begin)
     (begin)
     (begin)
     (begin)
     (begin)
     (begin))))
(enter-check
 ,(datum->syntax
   #f
   '(#%plain-module-begin
     (#%declare #:empty-namespace)
     (require typed-racket/types/numeric-tower
              typed-racket/env/type-name-env
              typed-racket/env/global-env
              typed-racket/env/type-alias-env
              typed-racket/types/struct-table
              typed-racket/types/abbrev
              (rename-in racket/private/sort (sort raw-sort)))
     (begin)
     (begin)
     (begin)
     (begin)
     (begin)
     (begin)
     (begin))))
(exit-check
 ,(datum->syntax
   #f
   '(#%plain-module-begin
     (#%declare #:empty-namespace)
     (require typed-racket/types/numeric-tower
              typed-racket/env/type-name-env
              typed-racket/env/global-env
              typed-racket/env/type-alias-env
              typed-racket/types/struct-table
              typed-racket/types/abbrev
              (rename-in racket/private/sort (sort raw-sort)))
     (begin)
     (begin)
     (begin)
     (begin)
     (begin)
     (begin)
     (begin))))
(visit
 ,(datum->syntax
   #f
   '(#%plain-module-begin
     (#%declare #:empty-namespace)
     (require typed-racket/types/numeric-tower
              typed-racket/env/type-name-env
              typed-racket/env/global-env
              typed-racket/env/type-alias-env
              typed-racket/types/struct-table
              typed-racket/types/abbrev
              (rename-in racket/private/sort (sort raw-sort)))
     (begin)
     (begin)
     (begin)
     (begin)
     (begin)
     (begin)
     (begin))))
(resolve ,(datum->syntax #f '#%plain-module-begin))
(enter-prim
 ,(datum->syntax
   #f
   '(#%plain-module-begin
     (#%declare #:empty-namespace)
     (require typed-racket/types/numeric-tower
              typed-racket/env/type-name-env
              typed-racket/env/global-env
              typed-racket/env/type-alias-env
              typed-racket/types/struct-table
              typed-racket/types/abbrev
              (rename-in racket/private/sort (sort raw-sort)))
     (begin)
     (begin)
     (begin)
     (begin)
     (begin)
     (begin)
     (begin))))
(prim-#%module-begin #f)
(rename-one
 ,(datum->syntax
   #f
   '(#%plain-module-begin
     (#%declare #:empty-namespace)
     (require typed-racket/types/numeric-tower
              typed-racket/env/type-name-env
              typed-racket/env/global-env
              typed-racket/env/type-alias-env
              typed-racket/types/struct-table
              typed-racket/types/abbrev
              (rename-in racket/private/sort (sort raw-sort)))
     (begin)
     (begin)
     (begin)
     (begin)
     (begin)
     (begin)
     (begin))))
(next #f)
(visit ,(datum->syntax #f '(#%declare #:empty-namespace)))
(resolve ,(datum->syntax #f '#%declare))
(enter-prim ,(datum->syntax #f '(#%declare #:empty-namespace)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(#%declare #:empty-namespace)))
(return ,(datum->syntax #f '(#%declare #:empty-namespace)))
(rename-one ,(datum->syntax #f '(#%declare #:empty-namespace)))
(next #f)
(visit
 ,(datum->syntax
   #f
   '(require typed-racket/types/numeric-tower
             typed-racket/env/type-name-env
             typed-racket/env/global-env
             typed-racket/env/type-alias-env
             typed-racket/types/struct-table
             typed-racket/types/abbrev
             (rename-in racket/private/sort (sort raw-sort)))))
(resolve ,(datum->syntax #f 'require))
(enter-macro
 ,(datum->syntax
   #f
   '(require typed-racket/types/numeric-tower
             typed-racket/env/type-name-env
             typed-racket/env/global-env
             typed-racket/env/type-alias-env
             typed-racket/types/struct-table
             typed-racket/types/abbrev
             (rename-in racket/private/sort (sort raw-sort)))))
(macro-pre-transform
 ,(datum->syntax
   #f
   '(require typed-racket/types/numeric-tower
             typed-racket/env/type-name-env
             typed-racket/env/global-env
             typed-racket/env/type-alias-env
             typed-racket/types/struct-table
             typed-racket/types/abbrev
             (rename-in racket/private/sort (sort raw-sort)))))
(macro-post-transform
 (,(datum->syntax
    #f
    '(begin
       (require typed-racket/types/numeric-tower)
       (require typed-racket/env/type-name-env)
       (require typed-racket/env/global-env)
       (require typed-racket/env/type-alias-env)
       (require typed-racket/types/struct-table)
       (require typed-racket/types/abbrev)
       (require (rename-in racket/private/sort (sort raw-sort)))))
  unquote
  (datum->syntax
   #f
   '(require typed-racket/types/numeric-tower
             typed-racket/env/type-name-env
             typed-racket/env/global-env
             typed-racket/env/type-alias-env
             typed-racket/types/struct-table
             typed-racket/types/abbrev
             (rename-in racket/private/sort (sort raw-sort))))))
(exit-macro
 ,(datum->syntax
   #f
   '(begin
      (require typed-racket/types/numeric-tower)
      (require typed-racket/env/type-name-env)
      (require typed-racket/env/global-env)
      (require typed-racket/env/type-alias-env)
      (require typed-racket/types/struct-table)
      (require typed-racket/types/abbrev)
      (require (rename-in racket/private/sort (sort raw-sort))))))
(visit
 ,(datum->syntax
   #f
   '(begin
      (require typed-racket/types/numeric-tower)
      (require typed-racket/env/type-name-env)
      (require typed-racket/env/global-env)
      (require typed-racket/env/type-alias-env)
      (require typed-racket/types/struct-table)
      (require typed-racket/types/abbrev)
      (require (rename-in racket/private/sort (sort raw-sort))))))
(resolve ,(datum->syntax #f 'begin))
(enter-prim
 ,(datum->syntax
   #f
   '(begin
      (require typed-racket/types/numeric-tower)
      (require typed-racket/env/type-name-env)
      (require typed-racket/env/global-env)
      (require typed-racket/env/type-alias-env)
      (require typed-racket/types/struct-table)
      (require typed-racket/types/abbrev)
      (require (rename-in racket/private/sort (sort raw-sort))))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax
   #f
   '(begin
      (require typed-racket/types/numeric-tower)
      (require typed-racket/env/type-name-env)
      (require typed-racket/env/global-env)
      (require typed-racket/env/type-alias-env)
      (require typed-racket/types/struct-table)
      (require typed-racket/types/abbrev)
      (require (rename-in racket/private/sort (sort raw-sort))))))
(return
 ,(datum->syntax
   #f
   '(begin
      (require typed-racket/types/numeric-tower)
      (require typed-racket/env/type-name-env)
      (require typed-racket/env/global-env)
      (require typed-racket/env/type-alias-env)
      (require typed-racket/types/struct-table)
      (require typed-racket/types/abbrev)
      (require (rename-in racket/private/sort (sort raw-sort))))))
(rename-one
 ,(datum->syntax
   #f
   '(begin
      (require typed-racket/types/numeric-tower)
      (require typed-racket/env/type-name-env)
      (require typed-racket/env/global-env)
      (require typed-racket/env/type-alias-env)
      (require typed-racket/types/struct-table)
      (require typed-racket/types/abbrev)
      (require (rename-in racket/private/sort (sort raw-sort))))))
(splice
 (,(datum->syntax #f '(require typed-racket/types/numeric-tower))
  ,(datum->syntax #f '(require typed-racket/env/type-name-env))
  ,(datum->syntax #f '(require typed-racket/env/global-env))
  ,(datum->syntax #f '(require typed-racket/env/type-alias-env))
  ,(datum->syntax #f '(require typed-racket/types/struct-table))
  ,(datum->syntax #f '(require typed-racket/types/abbrev))
  ,(datum->syntax
    #f
    '(require (rename-in racket/private/sort (sort raw-sort))))
  ,(datum->syntax #f '(begin))
  ,(datum->syntax #f '(begin))
  ,(datum->syntax #f '(begin))
  ,(datum->syntax #f '(begin))
  ,(datum->syntax #f '(begin))
  ,(datum->syntax #f '(begin))
  ,(datum->syntax #f '(begin))
  unquote
  (datum->syntax #f '())))
(next #f)
(visit ,(datum->syntax #f '(require typed-racket/types/numeric-tower)))
(resolve ,(datum->syntax #f 'require))
(enter-macro ,(datum->syntax #f '(require typed-racket/types/numeric-tower)))
(macro-pre-transform
 ,(datum->syntax #f '(require typed-racket/types/numeric-tower)))
(macro-post-transform
 (,(datum->syntax #f '(#%require typed-racket/types/numeric-tower))
  unquote
  (datum->syntax #f '(require typed-racket/types/numeric-tower))))
(exit-macro ,(datum->syntax #f '(#%require typed-racket/types/numeric-tower)))
(visit ,(datum->syntax #f '(#%require typed-racket/types/numeric-tower)))
(resolve ,(datum->syntax #f '#%require))
(enter-prim ,(datum->syntax #f '(#%require typed-racket/types/numeric-tower)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(#%require typed-racket/types/numeric-tower)))
(return ,(datum->syntax #f '(#%require typed-racket/types/numeric-tower)))
(rename-one ,(datum->syntax #f '(#%require typed-racket/types/numeric-tower)))
(enter-prim ,(datum->syntax #f '(#%require typed-racket/types/numeric-tower)))
(prim-require #f)
(exit-prim ,(datum->syntax #f '(#%require typed-racket/types/numeric-tower)))
(next #f)
(visit ,(datum->syntax #f '(require typed-racket/env/type-name-env)))
(resolve ,(datum->syntax #f 'require))
(enter-macro ,(datum->syntax #f '(require typed-racket/env/type-name-env)))
(macro-pre-transform
 ,(datum->syntax #f '(require typed-racket/env/type-name-env)))
(macro-post-transform
 (,(datum->syntax #f '(#%require typed-racket/env/type-name-env))
  unquote
  (datum->syntax #f '(require typed-racket/env/type-name-env))))
(exit-macro ,(datum->syntax #f '(#%require typed-racket/env/type-name-env)))
(visit ,(datum->syntax #f '(#%require typed-racket/env/type-name-env)))
(resolve ,(datum->syntax #f '#%require))
(enter-prim ,(datum->syntax #f '(#%require typed-racket/env/type-name-env)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(#%require typed-racket/env/type-name-env)))
(return ,(datum->syntax #f '(#%require typed-racket/env/type-name-env)))
(rename-one ,(datum->syntax #f '(#%require typed-racket/env/type-name-env)))
(enter-prim ,(datum->syntax #f '(#%require typed-racket/env/type-name-env)))
(prim-require #f)
(exit-prim ,(datum->syntax #f '(#%require typed-racket/env/type-name-env)))
(next #f)
(visit ,(datum->syntax #f '(require typed-racket/env/global-env)))
(resolve ,(datum->syntax #f 'require))
(enter-macro ,(datum->syntax #f '(require typed-racket/env/global-env)))
(macro-pre-transform
 ,(datum->syntax #f '(require typed-racket/env/global-env)))
(macro-post-transform
 (,(datum->syntax #f '(#%require typed-racket/env/global-env))
  unquote
  (datum->syntax #f '(require typed-racket/env/global-env))))
(exit-macro ,(datum->syntax #f '(#%require typed-racket/env/global-env)))
(visit ,(datum->syntax #f '(#%require typed-racket/env/global-env)))
(resolve ,(datum->syntax #f '#%require))
(enter-prim ,(datum->syntax #f '(#%require typed-racket/env/global-env)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(#%require typed-racket/env/global-env)))
(return ,(datum->syntax #f '(#%require typed-racket/env/global-env)))
(rename-one ,(datum->syntax #f '(#%require typed-racket/env/global-env)))
(enter-prim ,(datum->syntax #f '(#%require typed-racket/env/global-env)))
(prim-require #f)
(exit-prim ,(datum->syntax #f '(#%require typed-racket/env/global-env)))
(next #f)
(visit ,(datum->syntax #f '(require typed-racket/env/type-alias-env)))
(resolve ,(datum->syntax #f 'require))
(enter-macro ,(datum->syntax #f '(require typed-racket/env/type-alias-env)))
(macro-pre-transform
 ,(datum->syntax #f '(require typed-racket/env/type-alias-env)))
(macro-post-transform
 (,(datum->syntax #f '(#%require typed-racket/env/type-alias-env))
  unquote
  (datum->syntax #f '(require typed-racket/env/type-alias-env))))
(exit-macro ,(datum->syntax #f '(#%require typed-racket/env/type-alias-env)))
(visit ,(datum->syntax #f '(#%require typed-racket/env/type-alias-env)))
(resolve ,(datum->syntax #f '#%require))
(enter-prim ,(datum->syntax #f '(#%require typed-racket/env/type-alias-env)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(#%require typed-racket/env/type-alias-env)))
(return ,(datum->syntax #f '(#%require typed-racket/env/type-alias-env)))
(rename-one ,(datum->syntax #f '(#%require typed-racket/env/type-alias-env)))
(enter-prim ,(datum->syntax #f '(#%require typed-racket/env/type-alias-env)))
(prim-require #f)
(exit-prim ,(datum->syntax #f '(#%require typed-racket/env/type-alias-env)))
(next #f)
(visit ,(datum->syntax #f '(require typed-racket/types/struct-table)))
(resolve ,(datum->syntax #f 'require))
(enter-macro ,(datum->syntax #f '(require typed-racket/types/struct-table)))
(macro-pre-transform
 ,(datum->syntax #f '(require typed-racket/types/struct-table)))
(macro-post-transform
 (,(datum->syntax #f '(#%require typed-racket/types/struct-table))
  unquote
  (datum->syntax #f '(require typed-racket/types/struct-table))))
(exit-macro ,(datum->syntax #f '(#%require typed-racket/types/struct-table)))
(visit ,(datum->syntax #f '(#%require typed-racket/types/struct-table)))
(resolve ,(datum->syntax #f '#%require))
(enter-prim ,(datum->syntax #f '(#%require typed-racket/types/struct-table)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(#%require typed-racket/types/struct-table)))
(return ,(datum->syntax #f '(#%require typed-racket/types/struct-table)))
(rename-one ,(datum->syntax #f '(#%require typed-racket/types/struct-table)))
(enter-prim ,(datum->syntax #f '(#%require typed-racket/types/struct-table)))
(prim-require #f)
(exit-prim ,(datum->syntax #f '(#%require typed-racket/types/struct-table)))
(next #f)
(visit ,(datum->syntax #f '(require typed-racket/types/abbrev)))
(resolve ,(datum->syntax #f 'require))
(enter-macro ,(datum->syntax #f '(require typed-racket/types/abbrev)))
(macro-pre-transform ,(datum->syntax #f '(require typed-racket/types/abbrev)))
(macro-post-transform
 (,(datum->syntax #f '(#%require typed-racket/types/abbrev))
  unquote
  (datum->syntax #f '(require typed-racket/types/abbrev))))
(exit-macro ,(datum->syntax #f '(#%require typed-racket/types/abbrev)))
(visit ,(datum->syntax #f '(#%require typed-racket/types/abbrev)))
(resolve ,(datum->syntax #f '#%require))
(enter-prim ,(datum->syntax #f '(#%require typed-racket/types/abbrev)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(#%require typed-racket/types/abbrev)))
(return ,(datum->syntax #f '(#%require typed-racket/types/abbrev)))
(rename-one ,(datum->syntax #f '(#%require typed-racket/types/abbrev)))
(enter-prim ,(datum->syntax #f '(#%require typed-racket/types/abbrev)))
(prim-require #f)
(exit-prim ,(datum->syntax #f '(#%require typed-racket/types/abbrev)))
(next #f)
(visit
 ,(datum->syntax
   #f
   '(require (rename-in racket/private/sort (sort raw-sort)))))
(resolve ,(datum->syntax #f 'require))
(enter-macro
 ,(datum->syntax
   #f
   '(require (rename-in racket/private/sort (sort raw-sort)))))
(macro-pre-transform
 ,(datum->syntax
   #f
   '(require (rename-in racket/private/sort (sort raw-sort)))))
(local-value ,(datum->syntax #f 'rename-in))
(resolve ,(datum->syntax #f 'rename-in))
(local-value-result #t)
(local-value-binding
 (,(module-path-index-join
    `"reqprov.rkt"
    `,(module-path-index-join
       `"pre-base.rkt"
       `,(module-path-index-join
          `"private/base.rkt"
          `,(module-path-index-join `racket/base `#f))))
  rename-in
  ,(module-path-index-join `racket/base `#f)
  rename-in
  0
  0
  0))
(track-origin
 (,(datum->syntax #f '(just-meta 0 (rename racket/private/sort raw-sort sort)))
  unquote
  (datum->syntax
   #f
   '(just-meta 0 (rename racket/private/sort raw-sort sort)))))
(macro-post-transform
 (,(datum->syntax
    #f
    '(#%require
      (just-meta 0 (rename racket/private/sort raw-sort sort))
      (only racket/private/sort)))
  unquote
  (datum->syntax
   #f
   '(require (rename-in racket/private/sort (sort raw-sort))))))
(exit-macro
 ,(datum->syntax
   #f
   '(#%require
     (just-meta 0 (rename racket/private/sort raw-sort sort))
     (only racket/private/sort))))
(visit
 ,(datum->syntax
   #f
   '(#%require
     (just-meta 0 (rename racket/private/sort raw-sort sort))
     (only racket/private/sort))))
(resolve ,(datum->syntax #f '#%require))
(enter-prim
 ,(datum->syntax
   #f
   '(#%require
     (just-meta 0 (rename racket/private/sort raw-sort sort))
     (only racket/private/sort))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax
   #f
   '(#%require
     (just-meta 0 (rename racket/private/sort raw-sort sort))
     (only racket/private/sort))))
(return
 ,(datum->syntax
   #f
   '(#%require
     (just-meta 0 (rename racket/private/sort raw-sort sort))
     (only racket/private/sort))))
(rename-one
 ,(datum->syntax
   #f
   '(#%require
     (just-meta 0 (rename racket/private/sort raw-sort sort))
     (only racket/private/sort))))
(enter-prim
 ,(datum->syntax
   #f
   '(#%require
     (just-meta 0 (rename racket/private/sort raw-sort sort))
     (only racket/private/sort))))
(prim-require #f)
(exit-prim
 ,(datum->syntax
   #f
   '(#%require
     (just-meta 0 (rename racket/private/sort raw-sort sort))
     (only racket/private/sort))))
(next #f)
(visit ,(datum->syntax #f '(begin)))
(resolve ,(datum->syntax #f 'begin))
(enter-prim ,(datum->syntax #f '(begin)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(begin)))
(return ,(datum->syntax #f '(begin)))
(rename-one ,(datum->syntax #f '(begin)))
(splice
 (,(datum->syntax #f '(begin))
  ,(datum->syntax #f '(begin))
  ,(datum->syntax #f '(begin))
  ,(datum->syntax #f '(begin))
  ,(datum->syntax #f '(begin))
  ,(datum->syntax #f '(begin))
  unquote
  (datum->syntax #f '())))
(next #f)
(visit ,(datum->syntax #f '(begin)))
(resolve ,(datum->syntax #f 'begin))
(enter-prim ,(datum->syntax #f '(begin)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(begin)))
(return ,(datum->syntax #f '(begin)))
(rename-one ,(datum->syntax #f '(begin)))
(splice
 (,(datum->syntax #f '(begin))
  ,(datum->syntax #f '(begin))
  ,(datum->syntax #f '(begin))
  ,(datum->syntax #f '(begin))
  ,(datum->syntax #f '(begin))
  unquote
  (datum->syntax #f '())))
(next #f)
(visit ,(datum->syntax #f '(begin)))
(resolve ,(datum->syntax #f 'begin))
(enter-prim ,(datum->syntax #f '(begin)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(begin)))
(return ,(datum->syntax #f '(begin)))
(rename-one ,(datum->syntax #f '(begin)))
(splice
 (,(datum->syntax #f '(begin))
  ,(datum->syntax #f '(begin))
  ,(datum->syntax #f '(begin))
  ,(datum->syntax #f '(begin))
  unquote
  (datum->syntax #f '())))
(next #f)
(visit ,(datum->syntax #f '(begin)))
(resolve ,(datum->syntax #f 'begin))
(enter-prim ,(datum->syntax #f '(begin)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(begin)))
(return ,(datum->syntax #f '(begin)))
(rename-one ,(datum->syntax #f '(begin)))
(splice
 (,(datum->syntax #f '(begin))
  ,(datum->syntax #f '(begin))
  ,(datum->syntax #f '(begin))
  unquote
  (datum->syntax #f '())))
(next #f)
(visit ,(datum->syntax #f '(begin)))
(resolve ,(datum->syntax #f 'begin))
(enter-prim ,(datum->syntax #f '(begin)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(begin)))
(return ,(datum->syntax #f '(begin)))
(rename-one ,(datum->syntax #f '(begin)))
(splice
 (,(datum->syntax #f '(begin))
  ,(datum->syntax #f '(begin))
  unquote
  (datum->syntax #f '())))
(next #f)
(visit ,(datum->syntax #f '(begin)))
(resolve ,(datum->syntax #f 'begin))
(enter-prim ,(datum->syntax #f '(begin)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(begin)))
(return ,(datum->syntax #f '(begin)))
(rename-one ,(datum->syntax #f '(begin)))
(splice (,(datum->syntax #f '(begin)) . ,(datum->syntax #f '())))
(next #f)
(visit ,(datum->syntax #f '(begin)))
(resolve ,(datum->syntax #f 'begin))
(enter-prim ,(datum->syntax #f '(begin)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(begin)))
(return ,(datum->syntax #f '(begin)))
(rename-one ,(datum->syntax #f '(begin)))
(splice ,(datum->syntax #f '()))
(lift-end-loop ())
(next-group #f)
(next #f)
(next #f)
(next #f)
(next #f)
(next #f)
(next #f)
(next #f)
(next #f)
(next-group #f)
(next #f)
(exit-prim
 ,(datum->syntax
   #f
   '(#%plain-module-begin
     (#%declare #:empty-namespace)
     (#%require typed-racket/types/numeric-tower)
     (#%require typed-racket/env/type-name-env)
     (#%require typed-racket/env/global-env)
     (#%require typed-racket/env/type-alias-env)
     (#%require typed-racket/types/struct-table)
     (#%require typed-racket/types/abbrev)
     (#%require
      (just-meta 0 (rename racket/private/sort raw-sort sort))
      (only racket/private/sort)))))
(return
 ,(datum->syntax
   #f
   '(#%plain-module-begin
     (#%declare #:empty-namespace)
     (#%require typed-racket/types/numeric-tower)
     (#%require typed-racket/env/type-name-env)
     (#%require typed-racket/env/global-env)
     (#%require typed-racket/env/type-alias-env)
     (#%require typed-racket/types/struct-table)
     (#%require typed-racket/types/abbrev)
     (#%require
      (just-meta 0 (rename racket/private/sort raw-sort sort))
      (only racket/private/sort)))))
(rename-one
 ,(datum->syntax
   #f
   '(module*
     #%type-decl
     #f
     (#%plain-module-begin
      (#%declare #:empty-namespace)
      (#%require typed-racket/types/numeric-tower)
      (#%require typed-racket/env/type-name-env)
      (#%require typed-racket/env/global-env)
      (#%require typed-racket/env/type-alias-env)
      (#%require typed-racket/types/struct-table)
      (#%require typed-racket/types/abbrev)
      (#%require
       (just-meta 0 (rename racket/private/sort raw-sort sort))
       (only racket/private/sort))))))
(exit-prim
 ,(datum->syntax
   #f
   '(module*
     #%type-decl
     #f
     (#%plain-module-begin
      (#%declare #:empty-namespace)
      (#%require typed-racket/types/numeric-tower)
      (#%require typed-racket/env/type-name-env)
      (#%require typed-racket/env/global-env)
      (#%require typed-racket/env/type-alias-env)
      (#%require typed-racket/types/struct-table)
      (#%require typed-racket/types/abbrev)
      (#%require
       (just-meta 0 (rename racket/private/sort raw-sort sort))
       (only racket/private/sort))))))
(enter-prim
 ,(datum->syntax
   #f
   '(module*
     #%contract-defs
     #f
     (#%plain-module-begin
      (#%declare #:empty-namespace)
      (require (submod typed-racket/private/type-contract predicates)
               typed-racket/utils/utils
               (for-syntax typed-racket/utils/utils)
               typed-racket/utils/any-wrap
               typed-racket/utils/struct-type-c
               typed-racket/utils/opaque-object
               typed-racket/utils/evt-contract
               typed-racket/utils/sealing-contract
               racket/sequence
               racket/contract/parametric)))))
(prim-module #f)
(prepare-env #f)
(rename-one
 ,(datum->syntax
   #f
   '(#%plain-module-begin
     (#%declare #:empty-namespace)
     (require (submod typed-racket/private/type-contract predicates)
              typed-racket/utils/utils
              (for-syntax typed-racket/utils/utils)
              typed-racket/utils/any-wrap
              typed-racket/utils/struct-type-c
              typed-racket/utils/opaque-object
              typed-racket/utils/evt-contract
              typed-racket/utils/sealing-contract
              racket/sequence
              racket/contract/parametric))))
(enter-check
 ,(datum->syntax
   #f
   '(#%plain-module-begin
     (#%declare #:empty-namespace)
     (require (submod typed-racket/private/type-contract predicates)
              typed-racket/utils/utils
              (for-syntax typed-racket/utils/utils)
              typed-racket/utils/any-wrap
              typed-racket/utils/struct-type-c
              typed-racket/utils/opaque-object
              typed-racket/utils/evt-contract
              typed-racket/utils/sealing-contract
              racket/sequence
              racket/contract/parametric))))
(exit-check
 ,(datum->syntax
   #f
   '(#%plain-module-begin
     (#%declare #:empty-namespace)
     (require (submod typed-racket/private/type-contract predicates)
              typed-racket/utils/utils
              (for-syntax typed-racket/utils/utils)
              typed-racket/utils/any-wrap
              typed-racket/utils/struct-type-c
              typed-racket/utils/opaque-object
              typed-racket/utils/evt-contract
              typed-racket/utils/sealing-contract
              racket/sequence
              racket/contract/parametric))))
(visit
 ,(datum->syntax
   #f
   '(#%plain-module-begin
     (#%declare #:empty-namespace)
     (require (submod typed-racket/private/type-contract predicates)
              typed-racket/utils/utils
              (for-syntax typed-racket/utils/utils)
              typed-racket/utils/any-wrap
              typed-racket/utils/struct-type-c
              typed-racket/utils/opaque-object
              typed-racket/utils/evt-contract
              typed-racket/utils/sealing-contract
              racket/sequence
              racket/contract/parametric))))
(resolve ,(datum->syntax #f '#%plain-module-begin))
(enter-prim
 ,(datum->syntax
   #f
   '(#%plain-module-begin
     (#%declare #:empty-namespace)
     (require (submod typed-racket/private/type-contract predicates)
              typed-racket/utils/utils
              (for-syntax typed-racket/utils/utils)
              typed-racket/utils/any-wrap
              typed-racket/utils/struct-type-c
              typed-racket/utils/opaque-object
              typed-racket/utils/evt-contract
              typed-racket/utils/sealing-contract
              racket/sequence
              racket/contract/parametric))))
(prim-#%module-begin #f)
(rename-one
 ,(datum->syntax
   #f
   '(#%plain-module-begin
     (#%declare #:empty-namespace)
     (require (submod typed-racket/private/type-contract predicates)
              typed-racket/utils/utils
              (for-syntax typed-racket/utils/utils)
              typed-racket/utils/any-wrap
              typed-racket/utils/struct-type-c
              typed-racket/utils/opaque-object
              typed-racket/utils/evt-contract
              typed-racket/utils/sealing-contract
              racket/sequence
              racket/contract/parametric))))
(next #f)
(visit ,(datum->syntax #f '(#%declare #:empty-namespace)))
(resolve ,(datum->syntax #f '#%declare))
(enter-prim ,(datum->syntax #f '(#%declare #:empty-namespace)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(#%declare #:empty-namespace)))
(return ,(datum->syntax #f '(#%declare #:empty-namespace)))
(rename-one ,(datum->syntax #f '(#%declare #:empty-namespace)))
(next #f)
(visit
 ,(datum->syntax
   #f
   '(require (submod typed-racket/private/type-contract predicates)
             typed-racket/utils/utils
             (for-syntax typed-racket/utils/utils)
             typed-racket/utils/any-wrap
             typed-racket/utils/struct-type-c
             typed-racket/utils/opaque-object
             typed-racket/utils/evt-contract
             typed-racket/utils/sealing-contract
             racket/sequence
             racket/contract/parametric)))
(resolve ,(datum->syntax #f 'require))
(enter-macro
 ,(datum->syntax
   #f
   '(require (submod typed-racket/private/type-contract predicates)
             typed-racket/utils/utils
             (for-syntax typed-racket/utils/utils)
             typed-racket/utils/any-wrap
             typed-racket/utils/struct-type-c
             typed-racket/utils/opaque-object
             typed-racket/utils/evt-contract
             typed-racket/utils/sealing-contract
             racket/sequence
             racket/contract/parametric)))
(macro-pre-transform
 ,(datum->syntax
   #f
   '(require (submod typed-racket/private/type-contract predicates)
             typed-racket/utils/utils
             (for-syntax typed-racket/utils/utils)
             typed-racket/utils/any-wrap
             typed-racket/utils/struct-type-c
             typed-racket/utils/opaque-object
             typed-racket/utils/evt-contract
             typed-racket/utils/sealing-contract
             racket/sequence
             racket/contract/parametric)))
(macro-post-transform
 (,(datum->syntax
    #f
    '(begin
       (require (submod typed-racket/private/type-contract predicates))
       (require typed-racket/utils/utils)
       (require (for-syntax typed-racket/utils/utils))
       (require typed-racket/utils/any-wrap)
       (require typed-racket/utils/struct-type-c)
       (require typed-racket/utils/opaque-object)
       (require typed-racket/utils/evt-contract)
       (require typed-racket/utils/sealing-contract)
       (require racket/sequence)
       (require racket/contract/parametric)))
  unquote
  (datum->syntax
   #f
   '(require (submod typed-racket/private/type-contract predicates)
             typed-racket/utils/utils
             (for-syntax typed-racket/utils/utils)
             typed-racket/utils/any-wrap
             typed-racket/utils/struct-type-c
             typed-racket/utils/opaque-object
             typed-racket/utils/evt-contract
             typed-racket/utils/sealing-contract
             racket/sequence
             racket/contract/parametric))))
(exit-macro
 ,(datum->syntax
   #f
   '(begin
      (require (submod typed-racket/private/type-contract predicates))
      (require typed-racket/utils/utils)
      (require (for-syntax typed-racket/utils/utils))
      (require typed-racket/utils/any-wrap)
      (require typed-racket/utils/struct-type-c)
      (require typed-racket/utils/opaque-object)
      (require typed-racket/utils/evt-contract)
      (require typed-racket/utils/sealing-contract)
      (require racket/sequence)
      (require racket/contract/parametric))))
(visit
 ,(datum->syntax
   #f
   '(begin
      (require (submod typed-racket/private/type-contract predicates))
      (require typed-racket/utils/utils)
      (require (for-syntax typed-racket/utils/utils))
      (require typed-racket/utils/any-wrap)
      (require typed-racket/utils/struct-type-c)
      (require typed-racket/utils/opaque-object)
      (require typed-racket/utils/evt-contract)
      (require typed-racket/utils/sealing-contract)
      (require racket/sequence)
      (require racket/contract/parametric))))
(resolve ,(datum->syntax #f 'begin))
(enter-prim
 ,(datum->syntax
   #f
   '(begin
      (require (submod typed-racket/private/type-contract predicates))
      (require typed-racket/utils/utils)
      (require (for-syntax typed-racket/utils/utils))
      (require typed-racket/utils/any-wrap)
      (require typed-racket/utils/struct-type-c)
      (require typed-racket/utils/opaque-object)
      (require typed-racket/utils/evt-contract)
      (require typed-racket/utils/sealing-contract)
      (require racket/sequence)
      (require racket/contract/parametric))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax
   #f
   '(begin
      (require (submod typed-racket/private/type-contract predicates))
      (require typed-racket/utils/utils)
      (require (for-syntax typed-racket/utils/utils))
      (require typed-racket/utils/any-wrap)
      (require typed-racket/utils/struct-type-c)
      (require typed-racket/utils/opaque-object)
      (require typed-racket/utils/evt-contract)
      (require typed-racket/utils/sealing-contract)
      (require racket/sequence)
      (require racket/contract/parametric))))
(return
 ,(datum->syntax
   #f
   '(begin
      (require (submod typed-racket/private/type-contract predicates))
      (require typed-racket/utils/utils)
      (require (for-syntax typed-racket/utils/utils))
      (require typed-racket/utils/any-wrap)
      (require typed-racket/utils/struct-type-c)
      (require typed-racket/utils/opaque-object)
      (require typed-racket/utils/evt-contract)
      (require typed-racket/utils/sealing-contract)
      (require racket/sequence)
      (require racket/contract/parametric))))
(rename-one
 ,(datum->syntax
   #f
   '(begin
      (require (submod typed-racket/private/type-contract predicates))
      (require typed-racket/utils/utils)
      (require (for-syntax typed-racket/utils/utils))
      (require typed-racket/utils/any-wrap)
      (require typed-racket/utils/struct-type-c)
      (require typed-racket/utils/opaque-object)
      (require typed-racket/utils/evt-contract)
      (require typed-racket/utils/sealing-contract)
      (require racket/sequence)
      (require racket/contract/parametric))))
(splice
 (,(datum->syntax
    #f
    '(require (submod typed-racket/private/type-contract predicates)))
  ,(datum->syntax #f '(require typed-racket/utils/utils))
  ,(datum->syntax #f '(require (for-syntax typed-racket/utils/utils)))
  ,(datum->syntax #f '(require typed-racket/utils/any-wrap))
  ,(datum->syntax #f '(require typed-racket/utils/struct-type-c))
  ,(datum->syntax #f '(require typed-racket/utils/opaque-object))
  ,(datum->syntax #f '(require typed-racket/utils/evt-contract))
  ,(datum->syntax #f '(require typed-racket/utils/sealing-contract))
  ,(datum->syntax #f '(require racket/sequence))
  ,(datum->syntax #f '(require racket/contract/parametric))))
(next #f)
(visit
 ,(datum->syntax
   #f
   '(require (submod typed-racket/private/type-contract predicates))))
(resolve ,(datum->syntax #f 'require))
(enter-macro
 ,(datum->syntax
   #f
   '(require (submod typed-racket/private/type-contract predicates))))
(macro-pre-transform
 ,(datum->syntax
   #f
   '(require (submod typed-racket/private/type-contract predicates))))
(macro-post-transform
 (,(datum->syntax
    #f
    '(#%require (submod typed-racket/private/type-contract predicates)))
  unquote
  (datum->syntax
   #f
   '(require (submod typed-racket/private/type-contract predicates)))))
(exit-macro
 ,(datum->syntax
   #f
   '(#%require (submod typed-racket/private/type-contract predicates))))
(visit
 ,(datum->syntax
   #f
   '(#%require (submod typed-racket/private/type-contract predicates))))
(resolve ,(datum->syntax #f '#%require))
(enter-prim
 ,(datum->syntax
   #f
   '(#%require (submod typed-racket/private/type-contract predicates))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax
   #f
   '(#%require (submod typed-racket/private/type-contract predicates))))
(return
 ,(datum->syntax
   #f
   '(#%require (submod typed-racket/private/type-contract predicates))))
(rename-one
 ,(datum->syntax
   #f
   '(#%require (submod typed-racket/private/type-contract predicates))))
(enter-prim
 ,(datum->syntax
   #f
   '(#%require (submod typed-racket/private/type-contract predicates))))
(prim-require #f)
(exit-prim
 ,(datum->syntax
   #f
   '(#%require (submod typed-racket/private/type-contract predicates))))
(next #f)
(visit ,(datum->syntax #f '(require typed-racket/utils/utils)))
(resolve ,(datum->syntax #f 'require))
(enter-macro ,(datum->syntax #f '(require typed-racket/utils/utils)))
(macro-pre-transform ,(datum->syntax #f '(require typed-racket/utils/utils)))
(macro-post-transform
 (,(datum->syntax #f '(#%require typed-racket/utils/utils))
  unquote
  (datum->syntax #f '(require typed-racket/utils/utils))))
(exit-macro ,(datum->syntax #f '(#%require typed-racket/utils/utils)))
(visit ,(datum->syntax #f '(#%require typed-racket/utils/utils)))
(resolve ,(datum->syntax #f '#%require))
(enter-prim ,(datum->syntax #f '(#%require typed-racket/utils/utils)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(#%require typed-racket/utils/utils)))
(return ,(datum->syntax #f '(#%require typed-racket/utils/utils)))
(rename-one ,(datum->syntax #f '(#%require typed-racket/utils/utils)))
(enter-prim ,(datum->syntax #f '(#%require typed-racket/utils/utils)))
(prim-require #f)
(exit-prim ,(datum->syntax #f '(#%require typed-racket/utils/utils)))
(next #f)
(visit ,(datum->syntax #f '(require (for-syntax typed-racket/utils/utils))))
(resolve ,(datum->syntax #f 'require))
(enter-macro
 ,(datum->syntax #f '(require (for-syntax typed-racket/utils/utils))))
(macro-pre-transform
 ,(datum->syntax #f '(require (for-syntax typed-racket/utils/utils))))
(track-origin
 (,(datum->syntax #f '(for-meta 1 typed-racket/utils/utils))
  unquote
  (datum->syntax #f '(for-meta 1 typed-racket/utils/utils))))
(macro-post-transform
 (,(datum->syntax #f '(#%require (for-meta 1 typed-racket/utils/utils)))
  unquote
  (datum->syntax #f '(require (for-syntax typed-racket/utils/utils)))))
(exit-macro
 ,(datum->syntax #f '(#%require (for-meta 1 typed-racket/utils/utils))))
(visit ,(datum->syntax #f '(#%require (for-meta 1 typed-racket/utils/utils))))
(resolve ,(datum->syntax #f '#%require))
(enter-prim
 ,(datum->syntax #f '(#%require (for-meta 1 typed-racket/utils/utils))))
(prim-stop #f)
(exit-prim
 ,(datum->syntax #f '(#%require (for-meta 1 typed-racket/utils/utils))))
(return ,(datum->syntax #f '(#%require (for-meta 1 typed-racket/utils/utils))))
(rename-one
 ,(datum->syntax #f '(#%require (for-meta 1 typed-racket/utils/utils))))
(enter-prim
 ,(datum->syntax #f '(#%require (for-meta 1 typed-racket/utils/utils))))
(prim-require #f)
(exit-prim
 ,(datum->syntax #f '(#%require (for-meta 1 typed-racket/utils/utils))))
(next #f)
(visit ,(datum->syntax #f '(require typed-racket/utils/any-wrap)))
(resolve ,(datum->syntax #f 'require))
(enter-macro ,(datum->syntax #f '(require typed-racket/utils/any-wrap)))
(macro-pre-transform
 ,(datum->syntax #f '(require typed-racket/utils/any-wrap)))
(macro-post-transform
 (,(datum->syntax #f '(#%require typed-racket/utils/any-wrap))
  unquote
  (datum->syntax #f '(require typed-racket/utils/any-wrap))))
(exit-macro ,(datum->syntax #f '(#%require typed-racket/utils/any-wrap)))
(visit ,(datum->syntax #f '(#%require typed-racket/utils/any-wrap)))
(resolve ,(datum->syntax #f '#%require))
(enter-prim ,(datum->syntax #f '(#%require typed-racket/utils/any-wrap)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(#%require typed-racket/utils/any-wrap)))
(return ,(datum->syntax #f '(#%require typed-racket/utils/any-wrap)))
(rename-one ,(datum->syntax #f '(#%require typed-racket/utils/any-wrap)))
(enter-prim ,(datum->syntax #f '(#%require typed-racket/utils/any-wrap)))
(prim-require #f)
(exit-prim ,(datum->syntax #f '(#%require typed-racket/utils/any-wrap)))
(next #f)
(visit ,(datum->syntax #f '(require typed-racket/utils/struct-type-c)))
(resolve ,(datum->syntax #f 'require))
(enter-macro ,(datum->syntax #f '(require typed-racket/utils/struct-type-c)))
(macro-pre-transform
 ,(datum->syntax #f '(require typed-racket/utils/struct-type-c)))
(macro-post-transform
 (,(datum->syntax #f '(#%require typed-racket/utils/struct-type-c))
  unquote
  (datum->syntax #f '(require typed-racket/utils/struct-type-c))))
(exit-macro ,(datum->syntax #f '(#%require typed-racket/utils/struct-type-c)))
(visit ,(datum->syntax #f '(#%require typed-racket/utils/struct-type-c)))
(resolve ,(datum->syntax #f '#%require))
(enter-prim ,(datum->syntax #f '(#%require typed-racket/utils/struct-type-c)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(#%require typed-racket/utils/struct-type-c)))
(return ,(datum->syntax #f '(#%require typed-racket/utils/struct-type-c)))
(rename-one ,(datum->syntax #f '(#%require typed-racket/utils/struct-type-c)))
(enter-prim ,(datum->syntax #f '(#%require typed-racket/utils/struct-type-c)))
(prim-require #f)
(exit-prim ,(datum->syntax #f '(#%require typed-racket/utils/struct-type-c)))
(next #f)
(visit ,(datum->syntax #f '(require typed-racket/utils/opaque-object)))
(resolve ,(datum->syntax #f 'require))
(enter-macro ,(datum->syntax #f '(require typed-racket/utils/opaque-object)))
(macro-pre-transform
 ,(datum->syntax #f '(require typed-racket/utils/opaque-object)))
(macro-post-transform
 (,(datum->syntax #f '(#%require typed-racket/utils/opaque-object))
  unquote
  (datum->syntax #f '(require typed-racket/utils/opaque-object))))
(exit-macro ,(datum->syntax #f '(#%require typed-racket/utils/opaque-object)))
(visit ,(datum->syntax #f '(#%require typed-racket/utils/opaque-object)))
(resolve ,(datum->syntax #f '#%require))
(enter-prim ,(datum->syntax #f '(#%require typed-racket/utils/opaque-object)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(#%require typed-racket/utils/opaque-object)))
(return ,(datum->syntax #f '(#%require typed-racket/utils/opaque-object)))
(rename-one ,(datum->syntax #f '(#%require typed-racket/utils/opaque-object)))
(enter-prim ,(datum->syntax #f '(#%require typed-racket/utils/opaque-object)))
(prim-require #f)
(exit-prim ,(datum->syntax #f '(#%require typed-racket/utils/opaque-object)))
(next #f)
(visit ,(datum->syntax #f '(require typed-racket/utils/evt-contract)))
(resolve ,(datum->syntax #f 'require))
(enter-macro ,(datum->syntax #f '(require typed-racket/utils/evt-contract)))
(macro-pre-transform
 ,(datum->syntax #f '(require typed-racket/utils/evt-contract)))
(macro-post-transform
 (,(datum->syntax #f '(#%require typed-racket/utils/evt-contract))
  unquote
  (datum->syntax #f '(require typed-racket/utils/evt-contract))))
(exit-macro ,(datum->syntax #f '(#%require typed-racket/utils/evt-contract)))
(visit ,(datum->syntax #f '(#%require typed-racket/utils/evt-contract)))
(resolve ,(datum->syntax #f '#%require))
(enter-prim ,(datum->syntax #f '(#%require typed-racket/utils/evt-contract)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(#%require typed-racket/utils/evt-contract)))
(return ,(datum->syntax #f '(#%require typed-racket/utils/evt-contract)))
(rename-one ,(datum->syntax #f '(#%require typed-racket/utils/evt-contract)))
(enter-prim ,(datum->syntax #f '(#%require typed-racket/utils/evt-contract)))
(prim-require #f)
(exit-prim ,(datum->syntax #f '(#%require typed-racket/utils/evt-contract)))
(next #f)
(visit ,(datum->syntax #f '(require typed-racket/utils/sealing-contract)))
(resolve ,(datum->syntax #f 'require))
(enter-macro
 ,(datum->syntax #f '(require typed-racket/utils/sealing-contract)))
(macro-pre-transform
 ,(datum->syntax #f '(require typed-racket/utils/sealing-contract)))
(macro-post-transform
 (,(datum->syntax #f '(#%require typed-racket/utils/sealing-contract))
  unquote
  (datum->syntax #f '(require typed-racket/utils/sealing-contract))))
(exit-macro
 ,(datum->syntax #f '(#%require typed-racket/utils/sealing-contract)))
(visit ,(datum->syntax #f '(#%require typed-racket/utils/sealing-contract)))
(resolve ,(datum->syntax #f '#%require))
(enter-prim
 ,(datum->syntax #f '(#%require typed-racket/utils/sealing-contract)))
(prim-stop #f)
(exit-prim
 ,(datum->syntax #f '(#%require typed-racket/utils/sealing-contract)))
(return ,(datum->syntax #f '(#%require typed-racket/utils/sealing-contract)))
(rename-one
 ,(datum->syntax #f '(#%require typed-racket/utils/sealing-contract)))
(enter-prim
 ,(datum->syntax #f '(#%require typed-racket/utils/sealing-contract)))
(prim-require #f)
(exit-prim
 ,(datum->syntax #f '(#%require typed-racket/utils/sealing-contract)))
(next #f)
(visit ,(datum->syntax #f '(require racket/sequence)))
(resolve ,(datum->syntax #f 'require))
(enter-macro ,(datum->syntax #f '(require racket/sequence)))
(macro-pre-transform ,(datum->syntax #f '(require racket/sequence)))
(macro-post-transform
 (,(datum->syntax #f '(#%require racket/sequence))
  unquote
  (datum->syntax #f '(require racket/sequence))))
(exit-macro ,(datum->syntax #f '(#%require racket/sequence)))
(visit ,(datum->syntax #f '(#%require racket/sequence)))
(resolve ,(datum->syntax #f '#%require))
(enter-prim ,(datum->syntax #f '(#%require racket/sequence)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(#%require racket/sequence)))
(return ,(datum->syntax #f '(#%require racket/sequence)))
(rename-one ,(datum->syntax #f '(#%require racket/sequence)))
(enter-prim ,(datum->syntax #f '(#%require racket/sequence)))
(prim-require #f)
(exit-prim ,(datum->syntax #f '(#%require racket/sequence)))
(next #f)
(visit ,(datum->syntax #f '(require racket/contract/parametric)))
(resolve ,(datum->syntax #f 'require))
(enter-macro ,(datum->syntax #f '(require racket/contract/parametric)))
(macro-pre-transform ,(datum->syntax #f '(require racket/contract/parametric)))
(macro-post-transform
 (,(datum->syntax #f '(#%require racket/contract/parametric))
  unquote
  (datum->syntax #f '(require racket/contract/parametric))))
(exit-macro ,(datum->syntax #f '(#%require racket/contract/parametric)))
(visit ,(datum->syntax #f '(#%require racket/contract/parametric)))
(resolve ,(datum->syntax #f '#%require))
(enter-prim ,(datum->syntax #f '(#%require racket/contract/parametric)))
(prim-stop #f)
(exit-prim ,(datum->syntax #f '(#%require racket/contract/parametric)))
(return ,(datum->syntax #f '(#%require racket/contract/parametric)))
(rename-one ,(datum->syntax #f '(#%require racket/contract/parametric)))
(enter-prim ,(datum->syntax #f '(#%require racket/contract/parametric)))
(prim-require #f)
(exit-prim ,(datum->syntax #f '(#%require racket/contract/parametric)))
(lift-end-loop ())
(next-group #f)
(next #f)
(next #f)
(next #f)
(next #f)
(next #f)
(next #f)
(next #f)
(next #f)
(next #f)
(next #f)
(next #f)
(next-group #f)
(next #f)
(exit-prim
 ,(datum->syntax
   #f
   '(#%plain-module-begin
     (#%declare #:empty-namespace)
     (#%require (submod typed-racket/private/type-contract predicates))
     (#%require typed-racket/utils/utils)
     (#%require (for-meta 1 typed-racket/utils/utils))
     (#%require typed-racket/utils/any-wrap)
     (#%require typed-racket/utils/struct-type-c)
     (#%require typed-racket/utils/opaque-object)
     (#%require typed-racket/utils/evt-contract)
     (#%require typed-racket/utils/sealing-contract)
     (#%require racket/sequence)
     (#%require racket/contract/parametric))))
(return
 ,(datum->syntax
   #f
   '(#%plain-module-begin
     (#%declare #:empty-namespace)
     (#%require (submod typed-racket/private/type-contract predicates))
     (#%require typed-racket/utils/utils)
     (#%require (for-meta 1 typed-racket/utils/utils))
     (#%require typed-racket/utils/any-wrap)
     (#%require typed-racket/utils/struct-type-c)
     (#%require typed-racket/utils/opaque-object)
     (#%require typed-racket/utils/evt-contract)
     (#%require typed-racket/utils/sealing-contract)
     (#%require racket/sequence)
     (#%require racket/contract/parametric))))
(rename-one
 ,(datum->syntax
   #f
   '(module*
     #%contract-defs
     #f
     (#%plain-module-begin
      (#%declare #:empty-namespace)
      (#%require (submod typed-racket/private/type-contract predicates))
      (#%require typed-racket/utils/utils)
      (#%require (for-meta 1 typed-racket/utils/utils))
      (#%require typed-racket/utils/any-wrap)
      (#%require typed-racket/utils/struct-type-c)
      (#%require typed-racket/utils/opaque-object)
      (#%require typed-racket/utils/evt-contract)
      (#%require typed-racket/utils/sealing-contract)
      (#%require racket/sequence)
      (#%require racket/contract/parametric)))))
(exit-prim
 ,(datum->syntax
   #f
   '(module*
     #%contract-defs
     #f
     (#%plain-module-begin
      (#%declare #:empty-namespace)
      (#%require (submod typed-racket/private/type-contract predicates))
      (#%require typed-racket/utils/utils)
      (#%require (for-meta 1 typed-racket/utils/utils))
      (#%require typed-racket/utils/any-wrap)
      (#%require typed-racket/utils/struct-type-c)
      (#%require typed-racket/utils/opaque-object)
      (#%require typed-racket/utils/evt-contract)
      (#%require typed-racket/utils/sealing-contract)
      (#%require racket/sequence)
      (#%require racket/contract/parametric)))))
(exit-prim
 ,(datum->syntax
   #f
   '(#%module-begin
     (module configure-runtime '#%kernel
       (#%module-begin
        (#%require racket/runtime-config)
        (#%app configure '#f)))
     (begin-for-syntax
      (module*
       #%type-decl
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (#%require typed-racket/types/numeric-tower)
        (#%require typed-racket/env/type-name-env)
        (#%require typed-racket/env/global-env)
        (#%require typed-racket/env/type-alias-env)
        (#%require typed-racket/types/struct-table)
        (#%require typed-racket/types/abbrev)
        (#%require
         (just-meta 0 (rename racket/private/sort raw-sort sort))
         (only racket/private/sort)))))
     (begin-for-syntax
      (#%app
       add-mod!
       (#%app variable-reference->module-path-index (#%variable-reference))))
     (define-values
      (blame1)
      (#%app
       module-name-fixup
       (#%app variable-reference->module-source/submod (#%variable-reference))
       (#%app list)))
     (begin-for-syntax
      (#%require typed-racket/utils/redirect-contract)
      (module #%contract-defs-reference racket/base
        (#%module-begin
         (module configure-runtime '#%kernel
           (#%module-begin
            (#%require racket/runtime-config)
            (#%app configure '#f)))
         (#%require racket/runtime-path)
         (#%require (for-meta 1 racket/base))
         (define-values
          (contract-defs-submod)
          (let-values (((contract-defs-submod)
                        (#%app
                         list
                         'module
                         '(submod ".." #%contract-defs)
                         (#%variable-reference))))
            (let-values (((get-dir) void))
              (#%app
               apply
               values
               (#%app
                resolve-paths
                (#%variable-reference)
                get-dir
                (#%app list contract-defs-submod))))))
         (begin-for-syntax
          (#%app
           register-ext-files
           (#%variable-reference)
           (let-values (((contract-defs-submod)
                         (#%app
                          list
                          'module
                          '(submod ".." #%contract-defs)
                          (#%variable-reference))))
             (#%app list contract-defs-submod))))
         (#%provide contract-defs-submod)))
      (#%require (submod "." #%contract-defs-reference))
      (define-values
       (make-redirect2)
       (#%app make-make-redirect-to-contract contract-defs-submod)))
     (module*
      #%contract-defs
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (#%require (submod typed-racket/private/type-contract predicates))
       (#%require typed-racket/utils/utils)
       (#%require (for-meta 1 typed-racket/utils/utils))
       (#%require typed-racket/utils/any-wrap)
       (#%require typed-racket/utils/struct-type-c)
       (#%require typed-racket/utils/opaque-object)
       (#%require typed-racket/utils/evt-contract)
       (#%require typed-racket/utils/sealing-contract)
       (#%require racket/sequence)
       (#%require racket/contract/parametric)))
     (#%app call-with-values (lambda () '"hello world") print-values)
     (#%app void))))
(return
 ,(datum->syntax
   #f
   '(#%module-begin
     (module configure-runtime '#%kernel
       (#%module-begin
        (#%require racket/runtime-config)
        (#%app configure '#f)))
     (begin-for-syntax
      (module*
       #%type-decl
       #f
       (#%plain-module-begin
        (#%declare #:empty-namespace)
        (#%require typed-racket/types/numeric-tower)
        (#%require typed-racket/env/type-name-env)
        (#%require typed-racket/env/global-env)
        (#%require typed-racket/env/type-alias-env)
        (#%require typed-racket/types/struct-table)
        (#%require typed-racket/types/abbrev)
        (#%require
         (just-meta 0 (rename racket/private/sort raw-sort sort))
         (only racket/private/sort)))))
     (begin-for-syntax
      (#%app
       add-mod!
       (#%app variable-reference->module-path-index (#%variable-reference))))
     (define-values
      (blame1)
      (#%app
       module-name-fixup
       (#%app variable-reference->module-source/submod (#%variable-reference))
       (#%app list)))
     (begin-for-syntax
      (#%require typed-racket/utils/redirect-contract)
      (module #%contract-defs-reference racket/base
        (#%module-begin
         (module configure-runtime '#%kernel
           (#%module-begin
            (#%require racket/runtime-config)
            (#%app configure '#f)))
         (#%require racket/runtime-path)
         (#%require (for-meta 1 racket/base))
         (define-values
          (contract-defs-submod)
          (let-values (((contract-defs-submod)
                        (#%app
                         list
                         'module
                         '(submod ".." #%contract-defs)
                         (#%variable-reference))))
            (let-values (((get-dir) void))
              (#%app
               apply
               values
               (#%app
                resolve-paths
                (#%variable-reference)
                get-dir
                (#%app list contract-defs-submod))))))
         (begin-for-syntax
          (#%app
           register-ext-files
           (#%variable-reference)
           (let-values (((contract-defs-submod)
                         (#%app
                          list
                          'module
                          '(submod ".." #%contract-defs)
                          (#%variable-reference))))
             (#%app list contract-defs-submod))))
         (#%provide contract-defs-submod)))
      (#%require (submod "." #%contract-defs-reference))
      (define-values
       (make-redirect2)
       (#%app make-make-redirect-to-contract contract-defs-submod)))
     (module*
      #%contract-defs
      #f
      (#%plain-module-begin
       (#%declare #:empty-namespace)
       (#%require (submod typed-racket/private/type-contract predicates))
       (#%require typed-racket/utils/utils)
       (#%require (for-meta 1 typed-racket/utils/utils))
       (#%require typed-racket/utils/any-wrap)
       (#%require typed-racket/utils/struct-type-c)
       (#%require typed-racket/utils/opaque-object)
       (#%require typed-racket/utils/evt-contract)
       (#%require typed-racket/utils/sealing-contract)
       (#%require racket/sequence)
       (#%require racket/contract/parametric)))
     (#%app call-with-values (lambda () '"hello world") print-values)
     (#%app void))))
(rename-one
 ,(datum->syntax
   #f
   '(module anonymous-module typed/racket
      (#%module-begin
       (module configure-runtime '#%kernel
         (#%module-begin
          (#%require racket/runtime-config)
          (#%app configure '#f)))
       (begin-for-syntax
        (module*
         #%type-decl
         #f
         (#%plain-module-begin
          (#%declare #:empty-namespace)
          (#%require typed-racket/types/numeric-tower)
          (#%require typed-racket/env/type-name-env)
          (#%require typed-racket/env/global-env)
          (#%require typed-racket/env/type-alias-env)
          (#%require typed-racket/types/struct-table)
          (#%require typed-racket/types/abbrev)
          (#%require
           (just-meta 0 (rename racket/private/sort raw-sort sort))
           (only racket/private/sort)))))
       (begin-for-syntax
        (#%app
         add-mod!
         (#%app variable-reference->module-path-index (#%variable-reference))))
       (define-values
        (blame1)
        (#%app
         module-name-fixup
         (#%app
          variable-reference->module-source/submod
          (#%variable-reference))
         (#%app list)))
       (begin-for-syntax
        (#%require typed-racket/utils/redirect-contract)
        (module #%contract-defs-reference racket/base
          (#%module-begin
           (module configure-runtime '#%kernel
             (#%module-begin
              (#%require racket/runtime-config)
              (#%app configure '#f)))
           (#%require racket/runtime-path)
           (#%require (for-meta 1 racket/base))
           (define-values
            (contract-defs-submod)
            (let-values (((contract-defs-submod)
                          (#%app
                           list
                           'module
                           '(submod ".." #%contract-defs)
                           (#%variable-reference))))
              (let-values (((get-dir) void))
                (#%app
                 apply
                 values
                 (#%app
                  resolve-paths
                  (#%variable-reference)
                  get-dir
                  (#%app list contract-defs-submod))))))
           (begin-for-syntax
            (#%app
             register-ext-files
             (#%variable-reference)
             (let-values (((contract-defs-submod)
                           (#%app
                            list
                            'module
                            '(submod ".." #%contract-defs)
                            (#%variable-reference))))
               (#%app list contract-defs-submod))))
           (#%provide contract-defs-submod)))
        (#%require (submod "." #%contract-defs-reference))
        (define-values
         (make-redirect2)
         (#%app make-make-redirect-to-contract contract-defs-submod)))
       (module*
        #%contract-defs
        #f
        (#%plain-module-begin
         (#%declare #:empty-namespace)
         (#%require (submod typed-racket/private/type-contract predicates))
         (#%require typed-racket/utils/utils)
         (#%require (for-meta 1 typed-racket/utils/utils))
         (#%require typed-racket/utils/any-wrap)
         (#%require typed-racket/utils/struct-type-c)
         (#%require typed-racket/utils/opaque-object)
         (#%require typed-racket/utils/evt-contract)
         (#%require typed-racket/utils/sealing-contract)
         (#%require racket/sequence)
         (#%require racket/contract/parametric)))
       (#%app call-with-values (lambda () '"hello world") print-values)
       (#%app void)))))
(exit-prim
 ,(datum->syntax
   #f
   '(module anonymous-module typed/racket
      (#%module-begin
       (module configure-runtime '#%kernel
         (#%module-begin
          (#%require racket/runtime-config)
          (#%app configure '#f)))
       (begin-for-syntax
        (module*
         #%type-decl
         #f
         (#%plain-module-begin
          (#%declare #:empty-namespace)
          (#%require typed-racket/types/numeric-tower)
          (#%require typed-racket/env/type-name-env)
          (#%require typed-racket/env/global-env)
          (#%require typed-racket/env/type-alias-env)
          (#%require typed-racket/types/struct-table)
          (#%require typed-racket/types/abbrev)
          (#%require
           (just-meta 0 (rename racket/private/sort raw-sort sort))
           (only racket/private/sort)))))
       (begin-for-syntax
        (#%app
         add-mod!
         (#%app variable-reference->module-path-index (#%variable-reference))))
       (define-values
        (blame1)
        (#%app
         module-name-fixup
         (#%app
          variable-reference->module-source/submod
          (#%variable-reference))
         (#%app list)))
       (begin-for-syntax
        (#%require typed-racket/utils/redirect-contract)
        (module #%contract-defs-reference racket/base
          (#%module-begin
           (module configure-runtime '#%kernel
             (#%module-begin
              (#%require racket/runtime-config)
              (#%app configure '#f)))
           (#%require racket/runtime-path)
           (#%require (for-meta 1 racket/base))
           (define-values
            (contract-defs-submod)
            (let-values (((contract-defs-submod)
                          (#%app
                           list
                           'module
                           '(submod ".." #%contract-defs)
                           (#%variable-reference))))
              (let-values (((get-dir) void))
                (#%app
                 apply
                 values
                 (#%app
                  resolve-paths
                  (#%variable-reference)
                  get-dir
                  (#%app list contract-defs-submod))))))
           (begin-for-syntax
            (#%app
             register-ext-files
             (#%variable-reference)
             (let-values (((contract-defs-submod)
                           (#%app
                            list
                            'module
                            '(submod ".." #%contract-defs)
                            (#%variable-reference))))
               (#%app list contract-defs-submod))))
           (#%provide contract-defs-submod)))
        (#%require (submod "." #%contract-defs-reference))
        (define-values
         (make-redirect2)
         (#%app make-make-redirect-to-contract contract-defs-submod)))
       (module*
        #%contract-defs
        #f
        (#%plain-module-begin
         (#%declare #:empty-namespace)
         (#%require (submod typed-racket/private/type-contract predicates))
         (#%require typed-racket/utils/utils)
         (#%require (for-meta 1 typed-racket/utils/utils))
         (#%require typed-racket/utils/any-wrap)
         (#%require typed-racket/utils/struct-type-c)
         (#%require typed-racket/utils/opaque-object)
         (#%require typed-racket/utils/evt-contract)
         (#%require typed-racket/utils/sealing-contract)
         (#%require racket/sequence)
         (#%require racket/contract/parametric)))
       (#%app call-with-values (lambda () '"hello world") print-values)
       (#%app void)))))
(return
 ,(datum->syntax
   #f
   '(module anonymous-module typed/racket
      (#%module-begin
       (module configure-runtime '#%kernel
         (#%module-begin
          (#%require racket/runtime-config)
          (#%app configure '#f)))
       (begin-for-syntax
        (module*
         #%type-decl
         #f
         (#%plain-module-begin
          (#%declare #:empty-namespace)
          (#%require typed-racket/types/numeric-tower)
          (#%require typed-racket/env/type-name-env)
          (#%require typed-racket/env/global-env)
          (#%require typed-racket/env/type-alias-env)
          (#%require typed-racket/types/struct-table)
          (#%require typed-racket/types/abbrev)
          (#%require
           (just-meta 0 (rename racket/private/sort raw-sort sort))
           (only racket/private/sort)))))
       (begin-for-syntax
        (#%app
         add-mod!
         (#%app variable-reference->module-path-index (#%variable-reference))))
       (define-values
        (blame1)
        (#%app
         module-name-fixup
         (#%app
          variable-reference->module-source/submod
          (#%variable-reference))
         (#%app list)))
       (begin-for-syntax
        (#%require typed-racket/utils/redirect-contract)
        (module #%contract-defs-reference racket/base
          (#%module-begin
           (module configure-runtime '#%kernel
             (#%module-begin
              (#%require racket/runtime-config)
              (#%app configure '#f)))
           (#%require racket/runtime-path)
           (#%require (for-meta 1 racket/base))
           (define-values
            (contract-defs-submod)
            (let-values (((contract-defs-submod)
                          (#%app
                           list
                           'module
                           '(submod ".." #%contract-defs)
                           (#%variable-reference))))
              (let-values (((get-dir) void))
                (#%app
                 apply
                 values
                 (#%app
                  resolve-paths
                  (#%variable-reference)
                  get-dir
                  (#%app list contract-defs-submod))))))
           (begin-for-syntax
            (#%app
             register-ext-files
             (#%variable-reference)
             (let-values (((contract-defs-submod)
                           (#%app
                            list
                            'module
                            '(submod ".." #%contract-defs)
                            (#%variable-reference))))
               (#%app list contract-defs-submod))))
           (#%provide contract-defs-submod)))
        (#%require (submod "." #%contract-defs-reference))
        (define-values
         (make-redirect2)
         (#%app make-make-redirect-to-contract contract-defs-submod)))
       (module*
        #%contract-defs
        #f
        (#%plain-module-begin
         (#%declare #:empty-namespace)
         (#%require (submod typed-racket/private/type-contract predicates))
         (#%require typed-racket/utils/utils)
         (#%require (for-meta 1 typed-racket/utils/utils))
         (#%require typed-racket/utils/any-wrap)
         (#%require typed-racket/utils/struct-type-c)
         (#%require typed-racket/utils/opaque-object)
         (#%require typed-racket/utils/evt-contract)
         (#%require typed-racket/utils/sealing-contract)
         (#%require racket/sequence)
         (#%require racket/contract/parametric)))
       (#%app call-with-values (lambda () '"hello world") print-values)
       (#%app void)))))
(return
 ,(datum->syntax
   #f
   '(module anonymous-module typed/racket
      (#%module-begin
       (module configure-runtime '#%kernel
         (#%module-begin
          (#%require racket/runtime-config)
          (#%app configure '#f)))
       (begin-for-syntax
        (module*
         #%type-decl
         #f
         (#%plain-module-begin
          (#%declare #:empty-namespace)
          (#%require typed-racket/types/numeric-tower)
          (#%require typed-racket/env/type-name-env)
          (#%require typed-racket/env/global-env)
          (#%require typed-racket/env/type-alias-env)
          (#%require typed-racket/types/struct-table)
          (#%require typed-racket/types/abbrev)
          (#%require
           (just-meta 0 (rename racket/private/sort raw-sort sort))
           (only racket/private/sort)))))
       (begin-for-syntax
        (#%app
         add-mod!
         (#%app variable-reference->module-path-index (#%variable-reference))))
       (define-values
        (blame1)
        (#%app
         module-name-fixup
         (#%app
          variable-reference->module-source/submod
          (#%variable-reference))
         (#%app list)))
       (begin-for-syntax
        (#%require typed-racket/utils/redirect-contract)
        (module #%contract-defs-reference racket/base
          (#%module-begin
           (module configure-runtime '#%kernel
             (#%module-begin
              (#%require racket/runtime-config)
              (#%app configure '#f)))
           (#%require racket/runtime-path)
           (#%require (for-meta 1 racket/base))
           (define-values
            (contract-defs-submod)
            (let-values (((contract-defs-submod)
                          (#%app
                           list
                           'module
                           '(submod ".." #%contract-defs)
                           (#%variable-reference))))
              (let-values (((get-dir) void))
                (#%app
                 apply
                 values
                 (#%app
                  resolve-paths
                  (#%variable-reference)
                  get-dir
                  (#%app list contract-defs-submod))))))
           (begin-for-syntax
            (#%app
             register-ext-files
             (#%variable-reference)
             (let-values (((contract-defs-submod)
                           (#%app
                            list
                            'module
                            '(submod ".." #%contract-defs)
                            (#%variable-reference))))
               (#%app list contract-defs-submod))))
           (#%provide contract-defs-submod)))
        (#%require (submod "." #%contract-defs-reference))
        (define-values
         (make-redirect2)
         (#%app make-make-redirect-to-contract contract-defs-submod)))
       (module*
        #%contract-defs
        #f
        (#%plain-module-begin
         (#%declare #:empty-namespace)
         (#%require (submod typed-racket/private/type-contract predicates))
         (#%require typed-racket/utils/utils)
         (#%require (for-meta 1 typed-racket/utils/utils))
         (#%require typed-racket/utils/any-wrap)
         (#%require typed-racket/utils/struct-type-c)
         (#%require typed-racket/utils/opaque-object)
         (#%require typed-racket/utils/evt-contract)
         (#%require typed-racket/utils/sealing-contract)
         (#%require racket/sequence)
         (#%require racket/contract/parametric)))
       (#%app call-with-values (lambda () '"hello world") print-values)
       (#%app void)))))
(EOF #f)
)

"derivation-parser: error on token #247: <exit-prim, #<syntax:/home/asumu/plt/racket-git/extra-pkgs/typed-racket/typed-racket-lib/typed-racket/typecheck/tc-toplevel.rkt:450:11 (begin-for-syntax (module* #%...>>"
((parsing-loop
  "/home/asumu/plt/racket-git/racket/share/pkgs/parser-tools-lib/parser-tools/yacc.rkt"
  337
  16)
 (.../more-scheme.rkt:261:28)
 (|recache-deriv! method in term-record%|
  "/home/asumu/plt/racket-git/extra-pkgs/macro-debugger/macro-debugger/macro-debugger/view/term-record.rkt"
  126
  4)
 (|get-deriv-hidden? method in term-record%|
  "/home/asumu/plt/racket-git/extra-pkgs/macro-debugger/macro-debugger/macro-debugger/view/term-record.rkt"
  66
  16)
 (#f
  "/home/asumu/plt/racket-git/extra-pkgs/macro-debugger/macro-debugger/macro-debugger/view/stepper.rkt"
  72
  24)
 (#f
  "/home/asumu/plt/racket-git/extra-pkgs/gui/gui-lib/mred/private/wx/common/queue.rkt"
  454
  6))