Skip to content

Instantly share code, notes, and snippets.

@takikawa
Created September 30, 2015 21:48
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
Star You must be signed in to star a gist
Save takikawa/df6328a95a4ccd3d568a to your computer and use it in GitHub Desktop.
`(
(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)