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