racket.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE language SYSTEM "language.dtd"
[
  <!ENTITY pipe_symbol   "\|[^|]*\|">
  <!ENTITY slash_symbol  "\\.">
  <!ENTITY normal_symbol "[^\(\)\[\]\{\},'|\\ ]">
  <!ENTITY symbol        "(&pipe_symbol;|&slash_symbol;|&normal_symbol;)+">
]>
<!-- (setq nxml-section-element-name-regexp "list") -->
<!-- (setq nxml-heading-element-name-regexp "item") -->
<language name="racket" 
          section="Scripts"
          extensions=".rkt"
          version="1"
          kateversion="5.62">
  <highlighting>
    <list name="single_defines">
      <item>define</item>
      <item>define-for-syntax</item>
      <item>define-logger</item>
      <item>define-namespace-anchor</item>
      <item>define-sequence-syntax</item>
      <item>define-struct</item>
      <item>define-struct/derived</item>
      <item>define-syntax</item>
      <item>define-syntax-rule</item>
    </list>
    <list name="multi_defines">
      <item>define-values</item>
      <item>define-syntaxes</item>
      <item>define-values-for-syntax</item>
    </list>
    <list name="keywords">
      <item>#%app</item>
      <item>#%datum</item>
      <item>#%declare</item>
      <item>#%expression</item>
      <item>#%module-begin</item>
      <item>#%plain-app</item>
      <item>#%plain-lambda</item>
      <item>#%plain-module-begin</item>
      <item>#%printing-module-begin</item>
      <item>#%provide</item>
      <item>#%require</item>
      <item>#%stratified-body</item>
      <item>#%top</item>
      <item>#%top-interaction</item>
      <item>#%variable-reference</item>
      <item>...</item>
      <item>:do-in</item>
      <item>=></item>
      <item>_</item>
      <item>all-defined-out</item>
      <item>all-from-out</item>
      <item>and</item>
      <item>apply</item>
      <item>arity-at-least</item>
      <item>begin</item>
      <item>begin-for-syntax</item>
      <item>begin0</item>
      <item>call-with-input-file</item>
      <item>call-with-input-file*</item>
      <item>call-with-output-file</item>
      <item>call-with-output-file*</item>
      <item>case</item>
      <item>case-lambda</item>
      <item>combine-in</item>
      <item>combine-out</item>
      <item>cond</item>
      <item>date</item>
      <item>date*</item>
      <item>do</item>
      <item>else</item>
      <item>except-in</item>
      <item>except-out</item>
      <item>exn</item>
      <item>exn:break</item>
      <item>exn:break:hang-up</item>
      <item>exn:break:terminate</item>
      <item>exn:fail</item>
      <item>exn:fail:contract</item>
      <item>exn:fail:contract:arity</item>
      <item>exn:fail:contract:continuation</item>
      <item>exn:fail:contract:divide-by-zero</item>
      <item>exn:fail:contract:non-fixnum-result</item>
      <item>exn:fail:contract:variable</item>
      <item>exn:fail:filesystem</item>
      <item>exn:fail:filesystem:errno</item>
      <item>exn:fail:filesystem:exists</item>
      <item>exn:fail:filesystem:missing-module</item>
      <item>exn:fail:filesystem:version</item>
      <item>exn:fail:network</item>
      <item>exn:fail:network:errno</item>
      <item>exn:fail:out-of-memory</item>
      <item>exn:fail:read</item>
      <item>exn:fail:read:eof</item>
      <item>exn:fail:read:non-char</item>
      <item>exn:fail:syntax</item>
      <item>exn:fail:syntax:missing-module</item>
      <item>exn:fail:syntax:unbound</item>
      <item>exn:fail:unsupported</item>
      <item>exn:fail:user</item>
      <item>file</item>
      <item>for</item>
      <item>for*</item>
      <item>for*/and</item>
      <item>for*/first</item>
      <item>for*/fold</item>
      <item>for*/fold/derived</item>
      <item>for*/hash</item>
      <item>for*/hasheq</item>
      <item>for*/hasheqv</item>
      <item>for*/last</item>
      <item>for*/list</item>
      <item>for*/lists</item>
      <item>for*/or</item>
      <item>for*/product</item>
      <item>for*/sum</item>
      <item>for*/vector</item>
      <item>for-label</item>
      <item>for-meta</item>
      <item>for-syntax</item>
      <item>for-template</item>
      <item>for/and</item>
      <item>for/first</item>
      <item>for/fold</item>
      <item>for/fold/derived</item>
      <item>for/hash</item>
      <item>for/hasheq</item>
      <item>for/hasheqv</item>
      <item>for/last</item>
      <item>for/list</item>
      <item>for/lists</item>
      <item>for/or</item>
      <item>for/product</item>
      <item>for/sum</item>
      <item>for/vector</item>
      <item>gen:custom-write</item>
      <item>gen:equal+hash</item>
      <item>if</item>
      <item>in-bytes</item>
      <item>in-bytes-lines</item>
      <item>in-directory</item>
      <item>in-hash</item>
      <item>in-hash-keys</item>
      <item>in-hash-pairs</item>
      <item>in-hash-values</item>
      <item>in-immutable-hash</item>
      <item>in-immutable-hash-keys</item>
      <item>in-immutable-hash-pairs</item>
      <item>in-immutable-hash-values</item>
      <item>in-indexed</item>
      <item>in-input-port-bytes</item>
      <item>in-input-port-chars</item>
      <item>in-lines</item>
      <item>in-list</item>
      <item>in-mlist</item>
      <item>in-mutable-hash</item>
      <item>in-mutable-hash-keys</item>
      <item>in-mutable-hash-pairs</item>
      <item>in-mutable-hash-values</item>
      <item>in-naturals</item>
      <item>in-port</item>
      <item>in-producer</item>
      <item>in-range</item>
      <item>in-string</item>
      <item>in-value</item>
      <item>in-vector</item>
      <item>in-weak-hash</item>
      <item>in-weak-hash-keys</item>
      <item>in-weak-hash-pairs</item>
      <item>in-weak-hash-values</item>
      <item>lambda</item>
      <item>let</item>
      <item>let*</item>
      <item>let*-values</item>
      <item>let-syntax</item>
      <item>let-syntaxes</item>
      <item>let-values</item>
      <item>let/cc</item>
      <item>let/ec</item>
      <item>letrec</item>
      <item>letrec-syntax</item>
      <item>letrec-syntaxes</item>
      <item>letrec-syntaxes+values</item>
      <item>letrec-values</item>
      <item>lib</item>
      <item>local-require</item>
      <item>log-debug</item>
      <item>log-error</item>
      <item>log-fatal</item>
      <item>log-info</item>
      <item>log-warning</item>
      <item>only-in</item>
      <item>only-meta-in</item>
      <item>open-input-file</item>
      <item>open-input-output-file</item>
      <item>open-output-file</item>
      <item>or</item>
      <item>parameterize</item>
      <item>parameterize*</item>
      <item>parameterize-break</item>
      <item>planet</item>
      <item>prefix-in</item>
      <item>prefix-out</item>
      <item>protect-out</item>
      <item>provide</item>
      <item>quasiquote</item>
      <item>quasisyntax</item>
      <item>quasisyntax/loc</item>
      <item>quote</item>
      <item>quote-syntax</item>
      <item>quote-syntax/prune</item>
      <item>regexp-match*</item>
      <item>regexp-match-peek-positions*</item>
      <item>regexp-match-positions*</item>
      <item>relative-in</item>
      <item>rename-in</item>
      <item>rename-out</item>
      <item>require</item>
      <item>set!</item>
      <item>set!-values</item>
      <item>sort</item>
      <item>srcloc</item>
      <item>struct</item>
      <item>struct-copy</item>
      <item>struct-field-index</item>
      <item>struct-out</item>
      <item>submod</item>
      <item>syntax</item>
      <item>syntax-case</item>
      <item>syntax-case*</item>
      <item>syntax-id-rules</item>
      <item>syntax-rules</item>
      <item>syntax/loc</item>
      <item>time</item>
      <item>unless</item>
      <item>unquote</item>
      <item>unquote-splicing</item>
      <item>unsyntax</item>
      <item>unsyntax-splicing</item>
      <item>when</item>
      <item>with-continuation-mark</item>
      <item>with-handlers</item>
      <item>with-handlers*</item>
      <item>with-input-from-file</item>
      <item>with-output-to-file</item>
      <item>with-syntax</item>
      <item>λ</item>
    </list>
    <list name="characters">
      <item>nul</item>
      <item>null</item>
      <item>backspace</item>
      <item>tab</item>
      <item>newline</item>
      <item>linefeed</item>
      <item>vtab</item>
      <item>page</item>
      <item>return</item>
      <item>space</item>
      <item>rubout</item>
    </list>
    <list name="numbers">
      <item>inf</item>
      <item>nan</item>
    </list>
    <list name="hash_tables">
      <item>#hash</item>
      <item>#hasheq</item>
      <item>#hasheqv</item>
    </list>
    <list name="reader_extensions">
      <item>#!</item>
      <item>#reader</item>
    </list>
    <list name="builtins">
      <item>!</item>
      <item>*</item>
      <item>*list/c</item>
      <item>+</item>
      <item>-</item>
      <item>-></item>
      <item>->*</item>
      <item>->*m</item>
      <item>->d</item>
      <item>->dm</item>
      <item>->i</item>
      <item>->m</item>
      <item>/</item>
      <item>:</item>
      <item>:print-type</item>
      <item>:query-type/args</item>
      <item>:query-type/result</item>
      <item>:type</item>
      <item>&lt;</item>
      <item>&lt;/c</item>
      <item>&lt;=</item>
      <item>&lt;=/c</item>
      <item>=</item>
      <item>=/c</item>
      <item>==</item>
      <item>></item>
      <item>>/c</item>
      <item>>=</item>
      <item>>=/c</item>
      <item>abort-current-continuation</item>
      <item>abs</item>
      <item>absent</item>
      <item>absolute-path?</item>
      <item>abstract</item>
      <item>acos</item>
      <item>add-between</item>
      <item>add1</item>
      <item>alarm-evt</item>
      <item>always-evt</item>
      <item>and/c</item>
      <item>andmap</item>
      <item>angle</item>
      <item>ann</item>
      <item>any</item>
      <item>any/c</item>
      <item>append</item>
      <item>append*</item>
      <item>append-map</item>
      <item>argmax</item>
      <item>argmin</item>
      <item>arithmetic-shift</item>
      <item>arity-at-least-value</item>
      <item>arity-at-least?</item>
      <item>arity-checking-wrapper</item>
      <item>arity-includes?</item>
      <item>arity=?</item>
      <item>arrow-contract-info</item>
      <item>arrow-contract-info-accepts-arglist</item>
      <item>arrow-contract-info-chaperone-procedure</item>
      <item>arrow-contract-info-check-first-order</item>
      <item>arrow-contract-info?</item>
      <item>asin</item>
      <item>assert</item>
      <item>assf</item>
      <item>assoc</item>
      <item>assq</item>
      <item>assv</item>
      <item>atan</item>
      <item>augment</item>
      <item>augment*</item>
      <item>augment-final</item>
      <item>augment-final*</item>
      <item>augride</item>
      <item>augride*</item>
      <item>bad-number-of-results</item>
      <item>banner</item>
      <item>base->-doms/c</item>
      <item>base->-rngs/c</item>
      <item>base->?</item>
      <item>between/c</item>
      <item>bitwise-and</item>
      <item>bitwise-bit-field</item>
      <item>bitwise-bit-set?</item>
      <item>bitwise-ior</item>
      <item>bitwise-not</item>
      <item>bitwise-xor</item>
      <item>blame-add-car-context</item>
      <item>blame-add-cdr-context</item>
      <item>blame-add-context</item>
      <item>blame-add-missing-party</item>
      <item>blame-add-nth-arg-context</item>
      <item>blame-add-range-context</item>
      <item>blame-add-unknown-context</item>
      <item>blame-context</item>
      <item>blame-contract</item>
      <item>blame-fmt->-string</item>
      <item>blame-missing-party?</item>
      <item>blame-negative</item>
      <item>blame-original?</item>
      <item>blame-positive</item>
      <item>blame-replace-negative</item>
      <item>blame-source</item>
      <item>blame-swap</item>
      <item>blame-swapped?</item>
      <item>blame-update</item>
      <item>blame-value</item>
      <item>blame?</item>
      <item>boolean=?</item>
      <item>boolean?</item>
      <item>bound-identifier=?</item>
      <item>box</item>
      <item>box-cas!</item>
      <item>box-immutable</item>
      <item>box-immutable/c</item>
      <item>box/c</item>
      <item>box?</item>
      <item>break-enabled</item>
      <item>break-parameterization?</item>
      <item>break-thread</item>
      <item>build-chaperone-contract-property</item>
      <item>build-compound-type-name</item>
      <item>build-contract-property</item>
      <item>build-flat-contract-property</item>
      <item>build-list</item>
      <item>build-path</item>
      <item>build-path/convention-type</item>
      <item>build-string</item>
      <item>build-vector</item>
      <item>byte-pregexp</item>
      <item>byte-pregexp?</item>
      <item>byte-ready?</item>
      <item>byte-regexp</item>
      <item>byte-regexp?</item>
      <item>byte?</item>
      <item>bytes</item>
      <item>bytes->immutable-bytes</item>
      <item>bytes->list</item>
      <item>bytes->path</item>
      <item>bytes->path-element</item>
      <item>bytes->string/latin-1</item>
      <item>bytes->string/locale</item>
      <item>bytes->string/utf-8</item>
      <item>bytes-append</item>
      <item>bytes-append*</item>
      <item>bytes-close-converter</item>
      <item>bytes-convert</item>
      <item>bytes-convert-end</item>
      <item>bytes-converter?</item>
      <item>bytes-copy</item>
      <item>bytes-copy!</item>
      <item>bytes-environment-variable-name?</item>
      <item>bytes-fill!</item>
      <item>bytes-join</item>
      <item>bytes-length</item>
      <item>bytes-no-nuls?</item>
      <item>bytes-open-converter</item>
      <item>bytes-ref</item>
      <item>bytes-set!</item>
      <item>bytes-utf-8-index</item>
      <item>bytes-utf-8-length</item>
      <item>bytes-utf-8-ref</item>
      <item>bytes&lt;?</item>
      <item>bytes=?</item>
      <item>bytes>?</item>
      <item>bytes?</item>
      <item>caaaar</item>
      <item>caaadr</item>
      <item>caaar</item>
      <item>caadar</item>
      <item>caaddr</item>
      <item>caadr</item>
      <item>caar</item>
      <item>cadaar</item>
      <item>cadadr</item>
      <item>cadar</item>
      <item>caddar</item>
      <item>cadddr</item>
      <item>caddr</item>
      <item>cadr</item>
      <item>call-in-nested-thread</item>
      <item>call-with-atomic-output-file</item>
      <item>call-with-break-parameterization</item>
      <item>call-with-composable-continuation</item>
      <item>call-with-continuation-barrier</item>
      <item>call-with-continuation-prompt</item>
      <item>call-with-current-continuation</item>
      <item>call-with-default-reading-parameterization</item>
      <item>call-with-escape-continuation</item>
      <item>call-with-exception-handler</item>
      <item>call-with-file-lock/timeout</item>
      <item>call-with-immediate-continuation-mark</item>
      <item>call-with-input-bytes</item>
      <item>call-with-input-string</item>
      <item>call-with-output-bytes</item>
      <item>call-with-output-string</item>
      <item>call-with-parameterization</item>
      <item>call-with-semaphore</item>
      <item>call-with-semaphore/enable-break</item>
      <item>call-with-values</item>
      <item>call/cc</item>
      <item>call/ec</item>
      <item>car</item>
      <item>cartesian-product</item>
      <item>case-></item>
      <item>case->m</item>
      <item>case-lambda:</item>
      <item>case→</item>
      <item>cast</item>
      <item>cdaaar</item>
      <item>cdaadr</item>
      <item>cdaar</item>
      <item>cdadar</item>
      <item>cdaddr</item>
      <item>cdadr</item>
      <item>cdar</item>
      <item>cddaar</item>
      <item>cddadr</item>
      <item>cddar</item>
      <item>cdddar</item>
      <item>cddddr</item>
      <item>cdddr</item>
      <item>cddr</item>
      <item>cdr</item>
      <item>ceiling</item>
      <item>channel-get</item>
      <item>channel-put</item>
      <item>channel-put-evt</item>
      <item>channel-put-evt?</item>
      <item>channel-try-get</item>
      <item>channel/c</item>
      <item>channel?</item>
      <item>chaperone-box</item>
      <item>chaperone-channel</item>
      <item>chaperone-continuation-mark-key</item>
      <item>chaperone-contract-property?</item>
      <item>chaperone-contract?</item>
      <item>chaperone-evt</item>
      <item>chaperone-hash</item>
      <item>chaperone-hash-set</item>
      <item>chaperone-of?</item>
      <item>chaperone-procedure</item>
      <item>chaperone-procedure*</item>
      <item>chaperone-prompt-tag</item>
      <item>chaperone-struct</item>
      <item>chaperone-struct-type</item>
      <item>chaperone-vector</item>
      <item>chaperone-vector*</item>
      <item>chaperone?</item>
      <item>char->integer</item>
      <item>char-alphabetic?</item>
      <item>char-blank?</item>
      <item>char-ci&lt;=?</item>
      <item>char-ci&lt;?</item>
      <item>char-ci=?</item>
      <item>char-ci>=?</item>
      <item>char-ci>?</item>
      <item>char-downcase</item>
      <item>char-foldcase</item>
      <item>char-general-category</item>
      <item>char-graphic?</item>
      <item>char-in</item>
      <item>char-in/c</item>
      <item>char-iso-control?</item>
      <item>char-lower-case?</item>
      <item>char-numeric?</item>
      <item>char-punctuation?</item>
      <item>char-ready?</item>
      <item>char-symbolic?</item>
      <item>char-title-case?</item>
      <item>char-titlecase</item>
      <item>char-upcase</item>
      <item>char-upper-case?</item>
      <item>char-utf-8-length</item>
      <item>char-whitespace?</item>
      <item>char&lt;=?</item>
      <item>char&lt;?</item>
      <item>char=?</item>
      <item>char>=?</item>
      <item>char>?</item>
      <item>char?</item>
      <item>check-duplicate-identifier</item>
      <item>check-duplicates</item>
      <item>check-tail-contract</item>
      <item>checked-procedure-check-and-extract</item>
      <item>choice-evt</item>
      <item>class</item>
      <item>class*</item>
      <item>class->interface</item>
      <item>class-field-accessor</item>
      <item>class-field-mutator</item>
      <item>class-info</item>
      <item>class-seal</item>
      <item>class-unseal</item>
      <item>class/c</item>
      <item>class/derived</item>
      <item>class?</item>
      <item>cleanse-path</item>
      <item>close-input-port</item>
      <item>close-output-port</item>
      <item>coerce-chaperone-contract</item>
      <item>coerce-chaperone-contracts</item>
      <item>coerce-contract</item>
      <item>coerce-contract/f</item>
      <item>coerce-contracts</item>
      <item>coerce-flat-contract</item>
      <item>coerce-flat-contracts</item>
      <item>collect-garbage</item>
      <item>collection-file-path</item>
      <item>collection-path</item>
      <item>combinations</item>
      <item>command-line</item>
      <item>compile</item>
      <item>compile-allow-set!-undefined</item>
      <item>compile-context-preservation-enabled</item>
      <item>compile-enforce-module-constants</item>
      <item>compile-syntax</item>
      <item>compiled-expression-recompile</item>
      <item>compiled-expression?</item>
      <item>compiled-module-expression?</item>
      <item>complete-path?</item>
      <item>complex?</item>
      <item>compose</item>
      <item>compose1</item>
      <item>compound-unit</item>
      <item>compound-unit/infer</item>
      <item>conjoin</item>
      <item>conjugate</item>
      <item>cons</item>
      <item>cons/c</item>
      <item>cons/dc</item>
      <item>cons?</item>
      <item>const</item>
      <item>continuation-mark-key/c</item>
      <item>continuation-mark-key?</item>
      <item>continuation-mark-set->context</item>
      <item>continuation-mark-set->list</item>
      <item>continuation-mark-set->list*</item>
      <item>continuation-mark-set-first</item>
      <item>continuation-mark-set?</item>
      <item>continuation-marks</item>
      <item>continuation-prompt-available?</item>
      <item>continuation-prompt-tag?</item>
      <item>continuation?</item>
      <item>contract</item>
      <item>contract-continuation-mark-key</item>
      <item>contract-custom-write-property-proc</item>
      <item>contract-exercise</item>
      <item>contract-first-order</item>
      <item>contract-first-order-passes?</item>
      <item>contract-late-neg-projection</item>
      <item>contract-name</item>
      <item>contract-out</item>
      <item>contract-proc</item>
      <item>contract-projection</item>
      <item>contract-property?</item>
      <item>contract-random-generate</item>
      <item>contract-random-generate-fail</item>
      <item>contract-random-generate-fail?</item>
      <item>contract-random-generate-get-current-environment</item>
      <item>contract-random-generate-stash</item>
      <item>contract-random-generate/choose</item>
      <item>contract-stronger?</item>
      <item>contract-struct</item>
      <item>contract-struct-exercise</item>
      <item>contract-struct-generate</item>
      <item>contract-struct-late-neg-projection</item>
      <item>contract-struct-list-contract?</item>
      <item>contract-val-first-projection</item>
      <item>contract?</item>
      <item>contracted</item>
      <item>convert-stream</item>
      <item>copy-directory/files</item>
      <item>copy-file</item>
      <item>copy-port</item>
      <item>cos</item>
      <item>cosh</item>
      <item>count</item>
      <item>current-blame-format</item>
      <item>current-break-parameterization</item>
      <item>current-code-inspector</item>
      <item>current-command-line-arguments</item>
      <item>current-compile</item>
      <item>current-compiled-file-roots</item>
      <item>current-continuation-marks</item>
      <item>current-contract-region</item>
      <item>current-custodian</item>
      <item>current-directory</item>
      <item>current-directory-for-user</item>
      <item>current-drive</item>
      <item>current-environment-variables</item>
      <item>current-error-port</item>
      <item>current-eval</item>
      <item>current-evt-pseudo-random-generator</item>
      <item>current-force-delete-permissions</item>
      <item>current-future</item>
      <item>current-gc-milliseconds</item>
      <item>current-get-interaction-input-port</item>
      <item>current-inexact-milliseconds</item>
      <item>current-input-port</item>
      <item>current-inspector</item>
      <item>current-library-collection-links</item>
      <item>current-library-collection-paths</item>
      <item>current-load</item>
      <item>current-load-extension</item>
      <item>current-load-relative-directory</item>
      <item>current-load/use-compiled</item>
      <item>current-locale</item>
      <item>current-logger</item>
      <item>current-memory-use</item>
      <item>current-milliseconds</item>
      <item>current-module-declare-name</item>
      <item>current-module-declare-source</item>
      <item>current-module-name-resolver</item>
      <item>current-module-path-for-load</item>
      <item>current-namespace</item>
      <item>current-output-port</item>
      <item>current-parameterization</item>
      <item>current-plumber</item>
      <item>current-preserved-thread-cell-values</item>
      <item>current-print</item>
      <item>current-process-milliseconds</item>
      <item>current-prompt-read</item>
      <item>current-pseudo-random-generator</item>
      <item>current-read-interaction</item>
      <item>current-reader-guard</item>
      <item>current-readtable</item>
      <item>current-recorded-disappeared-uses</item>
      <item>current-seconds</item>
      <item>current-security-guard</item>
      <item>current-subprocess-custodian-mode</item>
      <item>current-syntax-context</item>
      <item>current-thread</item>
      <item>current-thread-group</item>
      <item>current-thread-initial-stack-size</item>
      <item>current-write-relative-directory</item>
      <item>curry</item>
      <item>curryr</item>
      <item>custodian-box-value</item>
      <item>custodian-box?</item>
      <item>custodian-limit-memory</item>
      <item>custodian-managed-list</item>
      <item>custodian-memory-accounting-available?</item>
      <item>custodian-require-memory</item>
      <item>custodian-shutdown-all</item>
      <item>custodian?</item>
      <item>custom-print-quotable-accessor</item>
      <item>custom-print-quotable?</item>
      <item>custom-write-accessor</item>
      <item>custom-write-property-proc</item>
      <item>custom-write?</item>
      <item>date*-nanosecond</item>
      <item>date*-time-zone-name</item>
      <item>date*?</item>
      <item>date-day</item>
      <item>date-dst?</item>
      <item>date-hour</item>
      <item>date-minute</item>
      <item>date-month</item>
      <item>date-second</item>
      <item>date-time-zone-offset</item>
      <item>date-week-day</item>
      <item>date-year</item>
      <item>date-year-day</item>
      <item>date?</item>
      <item>datum->syntax</item>
      <item>datum-intern-literal</item>
      <item>declare-refinement</item>
      <item>default-continuation-prompt-tag</item>
      <item>define-compound-unit</item>
      <item>define-compound-unit/infer</item>
      <item>define-contract-struct</item>
      <item>define-custom-hash-types</item>
      <item>define-custom-set-types</item>
      <item>define-generics</item>
      <item>define-local-member-name</item>
      <item>define-match-expander</item>
      <item>define-member-name</item>
      <item>define-module-boundary-contract</item>
      <item>define-new-subtype</item>
      <item>define-opt/c</item>
      <item>define-predicate</item>
      <item>define-serializable-class</item>
      <item>define-serializable-class*</item>
      <item>define-signature</item>
      <item>define-signature-form</item>
      <item>define-simple-macro</item>
      <item>define-struct/contract</item>
      <item>define-struct/exec</item>
      <item>define-struct/exec:</item>
      <item>define-struct:</item>
      <item>define-type</item>
      <item>define-type-alias</item>
      <item>define-typed-struct</item>
      <item>define-typed-struct/exec</item>
      <item>define-unit</item>
      <item>define-unit-binding</item>
      <item>define-unit-from-context</item>
      <item>define-unit/contract</item>
      <item>define-unit/new-import-export</item>
      <item>define-unit/s</item>
      <item>define-values-for-export</item>
      <item>define-values/invoke-unit</item>
      <item>define-values/invoke-unit/infer</item>
      <item>define/augment</item>
      <item>define/augment-final</item>
      <item>define/augride</item>
      <item>define/contract</item>
      <item>define/final-prop</item>
      <item>define/generic</item>
      <item>define/match</item>
      <item>define/overment</item>
      <item>define/override</item>
      <item>define/override-final</item>
      <item>define/private</item>
      <item>define/public</item>
      <item>define/public-final</item>
      <item>define/pubment</item>
      <item>define/subexpression-pos-prop</item>
      <item>define/subexpression-pos-prop/name</item>
      <item>define/with-syntax</item>
      <item>define:</item>
      <item>defined?</item>
      <item>degrees->radians</item>
      <item>delay</item>
      <item>delay/idle</item>
      <item>delay/name</item>
      <item>delay/strict</item>
      <item>delay/sync</item>
      <item>delay/thread</item>
      <item>delete-directory</item>
      <item>delete-directory/files</item>
      <item>delete-file</item>
      <item>denominator</item>
      <item>dict->list</item>
      <item>dict-can-functional-set?</item>
      <item>dict-can-remove-keys?</item>
      <item>dict-clear</item>
      <item>dict-clear!</item>
      <item>dict-copy</item>
      <item>dict-count</item>
      <item>dict-empty?</item>
      <item>dict-for-each</item>
      <item>dict-has-key?</item>
      <item>dict-implements/c</item>
      <item>dict-implements?</item>
      <item>dict-iter-contract</item>
      <item>dict-iterate-first</item>
      <item>dict-iterate-key</item>
      <item>dict-iterate-next</item>
      <item>dict-iterate-value</item>
      <item>dict-key-contract</item>
      <item>dict-keys</item>
      <item>dict-map</item>
      <item>dict-mutable?</item>
      <item>dict-ref</item>
      <item>dict-ref!</item>
      <item>dict-remove</item>
      <item>dict-remove!</item>
      <item>dict-set</item>
      <item>dict-set!</item>
      <item>dict-set*</item>
      <item>dict-set*!</item>
      <item>dict-update</item>
      <item>dict-update!</item>
      <item>dict-value-contract</item>
      <item>dict-values</item>
      <item>dict?</item>
      <item>directory-exists?</item>
      <item>directory-list</item>
      <item>disjoin</item>
      <item>display</item>
      <item>display-lines</item>
      <item>display-lines-to-file</item>
      <item>display-to-file</item>
      <item>displayln</item>
      <item>do-standard-inits</item>
      <item>do:</item>
      <item>double-flonum?</item>
      <item>drop</item>
      <item>drop-common-prefix</item>
      <item>drop-right</item>
      <item>dropf</item>
      <item>dropf-right</item>
      <item>dump-memory-stats</item>
      <item>dup-input-port</item>
      <item>dup-output-port</item>
      <item>dynamic->*</item>
      <item>dynamic-get-field</item>
      <item>dynamic-object/c</item>
      <item>dynamic-place</item>
      <item>dynamic-place*</item>
      <item>dynamic-require</item>
      <item>dynamic-require-for-syntax</item>
      <item>dynamic-send</item>
      <item>dynamic-set-field!</item>
      <item>dynamic-wind</item>
      <item>eighth</item>
      <item>empty</item>
      <item>empty-sequence</item>
      <item>empty-stream</item>
      <item>empty?</item>
      <item>environment-variables-copy</item>
      <item>environment-variables-names</item>
      <item>environment-variables-ref</item>
      <item>environment-variables-set!</item>
      <item>environment-variables?</item>
      <item>eof</item>
      <item>eof-evt</item>
      <item>eof-object?</item>
      <item>ephemeron-value</item>
      <item>ephemeron?</item>
      <item>eprintf</item>
      <item>eq-contract-val</item>
      <item>eq-contract?</item>
      <item>eq-hash-code</item>
      <item>eq?</item>
      <item>equal-contract-val</item>
      <item>equal-contract?</item>
      <item>equal-hash-code</item>
      <item>equal-secondary-hash-code</item>
      <item>equal&lt;%&gt;</item>
      <item>equal?</item>
      <item>equal?/recur</item>
      <item>eqv-hash-code</item>
      <item>eqv?</item>
      <item>error</item>
      <item>error-display-handler</item>
      <item>error-escape-handler</item>
      <item>error-print-context-length</item>
      <item>error-print-source-location</item>
      <item>error-print-width</item>
      <item>error-value->string-handler</item>
      <item>eval</item>
      <item>eval-jit-enabled</item>
      <item>eval-syntax</item>
      <item>even?</item>
      <item>evt/c</item>
      <item>evt?</item>
      <item>exact->inexact</item>
      <item>exact-ceiling</item>
      <item>exact-floor</item>
      <item>exact-integer?</item>
      <item>exact-nonnegative-integer?</item>
      <item>exact-positive-integer?</item>
      <item>exact-round</item>
      <item>exact-truncate</item>
      <item>exact?</item>
      <item>except</item>
      <item>executable-yield-handler</item>
      <item>exit</item>
      <item>exit-handler</item>
      <item>exn-continuation-marks</item>
      <item>exn-message</item>
      <item>exn:break-continuation</item>
      <item>exn:break:hang-up?</item>
      <item>exn:break:terminate?</item>
      <item>exn:break?</item>
      <item>exn:fail:contract:arity?</item>
      <item>exn:fail:contract:blame</item>
      <item>exn:fail:contract:blame-object</item>
      <item>exn:fail:contract:blame?</item>
      <item>exn:fail:contract:continuation?</item>
      <item>exn:fail:contract:divide-by-zero?</item>
      <item>exn:fail:contract:non-fixnum-result?</item>
      <item>exn:fail:contract:variable-id</item>
      <item>exn:fail:contract:variable?</item>
      <item>exn:fail:contract?</item>
      <item>exn:fail:filesystem:errno-errno</item>
      <item>exn:fail:filesystem:errno?</item>
      <item>exn:fail:filesystem:exists?</item>
      <item>exn:fail:filesystem:missing-module-path</item>
      <item>exn:fail:filesystem:missing-module?</item>
      <item>exn:fail:filesystem:version?</item>
      <item>exn:fail:filesystem?</item>
      <item>exn:fail:network:errno-errno</item>
      <item>exn:fail:network:errno?</item>
      <item>exn:fail:network?</item>
      <item>exn:fail:object</item>
      <item>exn:fail:object?</item>
      <item>exn:fail:out-of-memory?</item>
      <item>exn:fail:read-srclocs</item>
      <item>exn:fail:read:eof?</item>
      <item>exn:fail:read:non-char?</item>
      <item>exn:fail:read?</item>
      <item>exn:fail:syntax-exprs</item>
      <item>exn:fail:syntax:missing-module-path</item>
      <item>exn:fail:syntax:missing-module?</item>
      <item>exn:fail:syntax:unbound?</item>
      <item>exn:fail:syntax?</item>
      <item>exn:fail:unsupported?</item>
      <item>exn:fail:user?</item>
      <item>exn:fail?</item>
      <item>exn:misc:match?</item>
      <item>exn:missing-module-accessor</item>
      <item>exn:missing-module?</item>
      <item>exn:srclocs-accessor</item>
      <item>exn:srclocs?</item>
      <item>exn?</item>
      <item>exp</item>
      <item>expand</item>
      <item>expand-for-clause</item>
      <item>expand-once</item>
      <item>expand-syntax</item>
      <item>expand-syntax-once</item>
      <item>expand-syntax-to-top-form</item>
      <item>expand-to-top-form</item>
      <item>expand-user-path</item>
      <item>explode-path</item>
      <item>export</item>
      <item>expt</item>
      <item>extends</item>
      <item>externalizable&lt;%&gt;</item>
      <item>failure-cont</item>
      <item>failure-result/c</item>
      <item>false</item>
      <item>false/c</item>
      <item>false?</item>
      <item>field</item>
      <item>field-bound?</item>
      <item>field-names</item>
      <item>fifth</item>
      <item>file->bytes</item>
      <item>file->bytes-lines</item>
      <item>file->lines</item>
      <item>file->list</item>
      <item>file->string</item>
      <item>file->value</item>
      <item>file-exists?</item>
      <item>file-name-from-path</item>
      <item>file-or-directory-identity</item>
      <item>file-or-directory-modify-seconds</item>
      <item>file-or-directory-permissions</item>
      <item>file-position</item>
      <item>file-position*</item>
      <item>file-size</item>
      <item>file-stream-buffer-mode</item>
      <item>file-stream-port?</item>
      <item>file-truncate</item>
      <item>filename-extension</item>
      <item>filesystem-change-evt</item>
      <item>filesystem-change-evt-cancel</item>
      <item>filesystem-change-evt?</item>
      <item>filesystem-root-list</item>
      <item>filter</item>
      <item>filter-map</item>
      <item>filter-not</item>
      <item>filter-read-input-port</item>
      <item>find-executable-path</item>
      <item>find-files</item>
      <item>find-library-collection-links</item>
      <item>find-library-collection-paths</item>
      <item>find-relative-path</item>
      <item>find-system-path</item>
      <item>findf</item>
      <item>first</item>
      <item>first-or/c</item>
      <item>fixnum?</item>
      <item>flat-contract</item>
      <item>flat-contract-predicate</item>
      <item>flat-contract-property?</item>
      <item>flat-contract-with-explanation</item>
      <item>flat-contract?</item>
      <item>flat-murec-contract</item>
      <item>flat-named-contract</item>
      <item>flat-rec-contract</item>
      <item>flatten</item>
      <item>floating-point-bytes->real</item>
      <item>flonum?</item>
      <item>floor</item>
      <item>flush-output</item>
      <item>fold-files</item>
      <item>foldl</item>
      <item>foldr</item>
      <item>for*/and:</item>
      <item>for*/async</item>
      <item>for*/extflvector:</item>
      <item>for*/first:</item>
      <item>for*/flvector:</item>
      <item>for*/fold:</item>
      <item>for*/hash:</item>
      <item>for*/hasheq:</item>
      <item>for*/hasheqv:</item>
      <item>for*/last:</item>
      <item>for*/list:</item>
      <item>for*/lists:</item>
      <item>for*/mutable-set</item>
      <item>for*/mutable-seteq</item>
      <item>for*/mutable-seteqv</item>
      <item>for*/or:</item>
      <item>for*/product:</item>
      <item>for*/set</item>
      <item>for*/set:</item>
      <item>for*/seteq</item>
      <item>for*/seteqv</item>
      <item>for*/stream</item>
      <item>for*/sum:</item>
      <item>for*/vector:</item>
      <item>for*/weak-set</item>
      <item>for*/weak-seteq</item>
      <item>for*/weak-seteqv</item>
      <item>for*:</item>
      <item>for-clause-syntax-protect</item>
      <item>for-each</item>
      <item>for/and:</item>
      <item>for/async</item>
      <item>for/extflvector:</item>
      <item>for/first:</item>
      <item>for/flvector:</item>
      <item>for/fold:</item>
      <item>for/hash:</item>
      <item>for/hasheq:</item>
      <item>for/hasheqv:</item>
      <item>for/last:</item>
      <item>for/list:</item>
      <item>for/lists:</item>
      <item>for/mutable-set</item>
      <item>for/mutable-seteq</item>
      <item>for/mutable-seteqv</item>
      <item>for/or:</item>
      <item>for/product:</item>
      <item>for/set</item>
      <item>for/set:</item>
      <item>for/seteq</item>
      <item>for/seteqv</item>
      <item>for/stream</item>
      <item>for/sum:</item>
      <item>for/vector:</item>
      <item>for/weak-set</item>
      <item>for/weak-seteq</item>
      <item>for/weak-seteqv</item>
      <item>for:</item>
      <item>force</item>
      <item>format</item>
      <item>format-id</item>
      <item>format-symbol</item>
      <item>fourth</item>
      <item>fprintf</item>
      <item>free-identifier=?</item>
      <item>free-label-identifier=?</item>
      <item>free-template-identifier=?</item>
      <item>free-transformer-identifier=?</item>
      <item>fsemaphore-count</item>
      <item>fsemaphore-post</item>
      <item>fsemaphore-try-wait?</item>
      <item>fsemaphore-wait</item>
      <item>fsemaphore?</item>
      <item>future</item>
      <item>future?</item>
      <item>futures-enabled?</item>
      <item>gcd</item>
      <item>gen:dict</item>
      <item>gen:set</item>
      <item>gen:stream</item>
      <item>generate-member-key</item>
      <item>generate-temporaries</item>
      <item>generate-temporary</item>
      <item>generic</item>
      <item>generic-set?</item>
      <item>generic?</item>
      <item>gensym</item>
      <item>get-field</item>
      <item>get-output-bytes</item>
      <item>get-output-string</item>
      <item>get-preference</item>
      <item>get/build-late-neg-projection</item>
      <item>get/build-val-first-projection</item>
      <item>getenv</item>
      <item>global-port-print-handler</item>
      <item>group-by</item>
      <item>group-execute-bit</item>
      <item>group-read-bit</item>
      <item>group-write-bit</item>
      <item>guard-evt</item>
      <item>handle-evt</item>
      <item>handle-evt?</item>
      <item>has-blame?</item>
      <item>has-contract?</item>
      <item>hash</item>
      <item>hash->list</item>
      <item>hash-clear</item>
      <item>hash-clear!</item>
      <item>hash-copy</item>
      <item>hash-copy-clear</item>
      <item>hash-count</item>
      <item>hash-empty?</item>
      <item>hash-eq?</item>
      <item>hash-equal?</item>
      <item>hash-eqv?</item>
      <item>hash-for-each</item>
      <item>hash-has-key?</item>
      <item>hash-iterate-first</item>
      <item>hash-iterate-key</item>
      <item>hash-iterate-key+value</item>
      <item>hash-iterate-next</item>
      <item>hash-iterate-pair</item>
      <item>hash-iterate-value</item>
      <item>hash-keys</item>
      <item>hash-keys-subset?</item>
      <item>hash-map</item>
      <item>hash-placeholder?</item>
      <item>hash-ref</item>
      <item>hash-ref!</item>
      <item>hash-remove</item>
      <item>hash-remove!</item>
      <item>hash-set</item>
      <item>hash-set!</item>
      <item>hash-set*</item>
      <item>hash-set*!</item>
      <item>hash-update</item>
      <item>hash-update!</item>
      <item>hash-values</item>
      <item>hash-weak?</item>
      <item>hash/c</item>
      <item>hash/dc</item>
      <item>hash?</item>
      <item>hasheq</item>
      <item>hasheqv</item>
      <item>identifier-binding</item>
      <item>identifier-binding-symbol</item>
      <item>identifier-label-binding</item>
      <item>identifier-prune-lexical-context</item>
      <item>identifier-prune-to-source-module</item>
      <item>identifier-remove-from-definition-context</item>
      <item>identifier-template-binding</item>
      <item>identifier-transformer-binding</item>
      <item>identifier?</item>
      <item>identity</item>
      <item>if/c</item>
      <item>imag-part</item>
      <item>immutable?</item>
      <item>impersonate-box</item>
      <item>impersonate-channel</item>
      <item>impersonate-continuation-mark-key</item>
      <item>impersonate-hash</item>
      <item>impersonate-hash-set</item>
      <item>impersonate-procedure</item>
      <item>impersonate-procedure*</item>
      <item>impersonate-prompt-tag</item>
      <item>impersonate-struct</item>
      <item>impersonate-vector</item>
      <item>impersonate-vector*</item>
      <item>impersonator-contract?</item>
      <item>impersonator-ephemeron</item>
      <item>impersonator-of?</item>
      <item>impersonator-prop:application-mark</item>
      <item>impersonator-prop:blame</item>
      <item>impersonator-prop:contracted</item>
      <item>impersonator-property-accessor-procedure?</item>
      <item>impersonator-property?</item>
      <item>impersonator?</item>
      <item>implementation?</item>
      <item>implementation?/c</item>
      <item>implies</item>
      <item>import</item>
      <item>in-combinations</item>
      <item>in-cycle</item>
      <item>in-dict</item>
      <item>in-dict-keys</item>
      <item>in-dict-pairs</item>
      <item>in-dict-values</item>
      <item>in-immutable-set</item>
      <item>in-mutable-set</item>
      <item>in-parallel</item>
      <item>in-permutations</item>
      <item>in-sequences</item>
      <item>in-set</item>
      <item>in-slice</item>
      <item>in-stream</item>
      <item>in-syntax</item>
      <item>in-values*-sequence</item>
      <item>in-values-sequence</item>
      <item>in-weak-set</item>
      <item>include</item>
      <item>include-at/relative-to</item>
      <item>include-at/relative-to/reader</item>
      <item>include/reader</item>
      <item>index-of</item>
      <item>index-where</item>
      <item>index?</item>
      <item>indexes-of</item>
      <item>indexes-where</item>
      <item>inexact->exact</item>
      <item>inexact-real?</item>
      <item>inexact?</item>
      <item>infinite?</item>
      <item>inherit</item>
      <item>inherit-field</item>
      <item>inherit/inner</item>
      <item>inherit/super</item>
      <item>init</item>
      <item>init-depend</item>
      <item>init-field</item>
      <item>init-rest</item>
      <item>inner</item>
      <item>input-port-append</item>
      <item>input-port?</item>
      <item>inspect</item>
      <item>inspector-superior?</item>
      <item>inspector?</item>
      <item>inst</item>
      <item>instanceof/c</item>
      <item>instantiate</item>
      <item>integer->char</item>
      <item>integer->integer-bytes</item>
      <item>integer-bytes->integer</item>
      <item>integer-in</item>
      <item>integer-length</item>
      <item>integer-sqrt</item>
      <item>integer-sqrt/remainder</item>
      <item>integer?</item>
      <item>interactive-command-procedure</item>
      <item>interactive-command?</item>
      <item>interface</item>
      <item>interface*</item>
      <item>interface->method-names</item>
      <item>interface-extension?</item>
      <item>interface?</item>
      <item>internal-definition-context-apply</item>
      <item>internal-definition-context-binding-identifiers</item>
      <item>internal-definition-context-introduce</item>
      <item>internal-definition-context-seal</item>
      <item>internal-definition-context?</item>
      <item>invariant-assertion</item>
      <item>invoke-unit</item>
      <item>invoke-unit/infer</item>
      <item>is-a?</item>
      <item>is-a?/c</item>
      <item>keyword->string</item>
      <item>keyword-apply</item>
      <item>keyword&lt;?</item>
      <item>keyword?</item>
      <item>keywords-match</item>
      <item>kill-thread</item>
      <item>lambda:</item>
      <item>last</item>
      <item>last-pair</item>
      <item>lazy</item>
      <item>lcm</item>
      <item>legacy-match-expander?</item>
      <item>length</item>
      <item>let*-values:</item>
      <item>let*:</item>
      <item>let-values:</item>
      <item>let/cc:</item>
      <item>let/ec:</item>
      <item>let:</item>
      <item>letrec-values:</item>
      <item>letrec:</item>
      <item>liberal-define-context?</item>
      <item>link</item>
      <item>link-exists?</item>
      <item>list</item>
      <item>list*</item>
      <item>list*of</item>
      <item>list->bytes</item>
      <item>list->mutable-set</item>
      <item>list->mutable-seteq</item>
      <item>list->mutable-seteqv</item>
      <item>list->set</item>
      <item>list->seteq</item>
      <item>list->seteqv</item>
      <item>list->string</item>
      <item>list->vector</item>
      <item>list->weak-set</item>
      <item>list->weak-seteq</item>
      <item>list->weak-seteqv</item>
      <item>list-contract?</item>
      <item>list-prefix?</item>
      <item>list-ref</item>
      <item>list-set</item>
      <item>list-tail</item>
      <item>list-update</item>
      <item>list/c</item>
      <item>list?</item>
      <item>listen-port-number?</item>
      <item>listof</item>
      <item>load</item>
      <item>load-extension</item>
      <item>load-on-demand-enabled</item>
      <item>load-relative</item>
      <item>load-relative-extension</item>
      <item>load/cd</item>
      <item>load/use-compiled</item>
      <item>local</item>
      <item>local-expand</item>
      <item>local-expand/capture-lifts</item>
      <item>local-transformer-expand</item>
      <item>local-transformer-expand/capture-lifts</item>
      <item>locale-string-encoding</item>
      <item>log</item>
      <item>log-all-levels</item>
      <item>log-level-evt</item>
      <item>log-level?</item>
      <item>log-max-level</item>
      <item>log-message</item>
      <item>log-receiver?</item>
      <item>logger-name</item>
      <item>logger?</item>
      <item>magnitude</item>
      <item>make-arity-at-least</item>
      <item>make-base-empty-namespace</item>
      <item>make-base-namespace</item>
      <item>make-bytes</item>
      <item>make-channel</item>
      <item>make-chaperone-contract</item>
      <item>make-continuation-mark-key</item>
      <item>make-continuation-prompt-tag</item>
      <item>make-contract</item>
      <item>make-custodian</item>
      <item>make-custodian-box</item>
      <item>make-custom-hash</item>
      <item>make-custom-hash-types</item>
      <item>make-custom-set</item>
      <item>make-custom-set-types</item>
      <item>make-date</item>
      <item>make-date*</item>
      <item>make-derived-parameter</item>
      <item>make-directory</item>
      <item>make-directory*</item>
      <item>make-do-sequence</item>
      <item>make-empty-namespace</item>
      <item>make-environment-variables</item>
      <item>make-ephemeron</item>
      <item>make-exn</item>
      <item>make-exn:break</item>
      <item>make-exn:break:hang-up</item>
      <item>make-exn:break:terminate</item>
      <item>make-exn:fail</item>
      <item>make-exn:fail:contract</item>
      <item>make-exn:fail:contract:arity</item>
      <item>make-exn:fail:contract:blame</item>
      <item>make-exn:fail:contract:continuation</item>
      <item>make-exn:fail:contract:divide-by-zero</item>
      <item>make-exn:fail:contract:non-fixnum-result</item>
      <item>make-exn:fail:contract:variable</item>
      <item>make-exn:fail:filesystem</item>
      <item>make-exn:fail:filesystem:errno</item>
      <item>make-exn:fail:filesystem:exists</item>
      <item>make-exn:fail:filesystem:missing-module</item>
      <item>make-exn:fail:filesystem:version</item>
      <item>make-exn:fail:network</item>
      <item>make-exn:fail:network:errno</item>
      <item>make-exn:fail:object</item>
      <item>make-exn:fail:out-of-memory</item>
      <item>make-exn:fail:read</item>
      <item>make-exn:fail:read:eof</item>
      <item>make-exn:fail:read:non-char</item>
      <item>make-exn:fail:syntax</item>
      <item>make-exn:fail:syntax:missing-module</item>
      <item>make-exn:fail:syntax:unbound</item>
      <item>make-exn:fail:unsupported</item>
      <item>make-exn:fail:user</item>
      <item>make-file-or-directory-link</item>
      <item>make-flat-contract</item>
      <item>make-fsemaphore</item>
      <item>make-generic</item>
      <item>make-handle-get-preference-locked</item>
      <item>make-hash</item>
      <item>make-hash-placeholder</item>
      <item>make-hasheq</item>
      <item>make-hasheq-placeholder</item>
      <item>make-hasheqv</item>
      <item>make-hasheqv-placeholder</item>
      <item>make-immutable-custom-hash</item>
      <item>make-immutable-hash</item>
      <item>make-immutable-hasheq</item>
      <item>make-immutable-hasheqv</item>
      <item>make-impersonator-property</item>
      <item>make-input-port</item>
      <item>make-input-port/read-to-peek</item>
      <item>make-inspector</item>
      <item>make-keyword-procedure</item>
      <item>make-known-char-range-list</item>
      <item>make-limited-input-port</item>
      <item>make-list</item>
      <item>make-lock-file-name</item>
      <item>make-log-receiver</item>
      <item>make-logger</item>
      <item>make-mixin-contract</item>
      <item>make-mutable-custom-set</item>
      <item>make-none/c</item>
      <item>make-object</item>
      <item>make-output-port</item>
      <item>make-parameter</item>
      <item>make-parent-directory*</item>
      <item>make-phantom-bytes</item>
      <item>make-pipe</item>
      <item>make-pipe-with-specials</item>
      <item>make-placeholder</item>
      <item>make-plumber</item>
      <item>make-polar</item>
      <item>make-predicate</item>
      <item>make-prefab-struct</item>
      <item>make-primitive-class</item>
      <item>make-proj-contract</item>
      <item>make-pseudo-random-generator</item>
      <item>make-reader-graph</item>
      <item>make-readtable</item>
      <item>make-rectangular</item>
      <item>make-rename-transformer</item>
      <item>make-resolved-module-path</item>
      <item>make-security-guard</item>
      <item>make-semaphore</item>
      <item>make-set!-transformer</item>
      <item>make-shared-bytes</item>
      <item>make-sibling-inspector</item>
      <item>make-special-comment</item>
      <item>make-srcloc</item>
      <item>make-string</item>
      <item>make-struct-field-accessor</item>
      <item>make-struct-field-mutator</item>
      <item>make-struct-type</item>
      <item>make-struct-type-property</item>
      <item>make-syntax-delta-introducer</item>
      <item>make-syntax-introducer</item>
      <item>make-temporary-file</item>
      <item>make-tentative-pretty-print-output-port</item>
      <item>make-thread-cell</item>
      <item>make-thread-group</item>
      <item>make-vector</item>
      <item>make-weak-box</item>
      <item>make-weak-custom-hash</item>
      <item>make-weak-custom-set</item>
      <item>make-weak-hash</item>
      <item>make-weak-hasheq</item>
      <item>make-weak-hasheqv</item>
      <item>make-will-executor</item>
      <item>map</item>
      <item>match</item>
      <item>match*</item>
      <item>match*/derived</item>
      <item>match-...-nesting</item>
      <item>match-define</item>
      <item>match-define-values</item>
      <item>match-equality-test</item>
      <item>match-expander?</item>
      <item>match-lambda</item>
      <item>match-lambda*</item>
      <item>match-lambda**</item>
      <item>match-let</item>
      <item>match-let*</item>
      <item>match-let*-values</item>
      <item>match-let-values</item>
      <item>match-letrec</item>
      <item>match-letrec-values</item>
      <item>match/derived</item>
      <item>match/values</item>
      <item>matches-arity-exactly?</item>
      <item>max</item>
      <item>mcar</item>
      <item>mcdr</item>
      <item>mcons</item>
      <item>member</item>
      <item>member-name-key</item>
      <item>member-name-key-hash-code</item>
      <item>member-name-key=?</item>
      <item>member-name-key?</item>
      <item>memf</item>
      <item>memq</item>
      <item>memv</item>
      <item>merge-input</item>
      <item>method-in-interface?</item>
      <item>min</item>
      <item>mixin</item>
      <item>mixin-contract</item>
      <item>module->exports</item>
      <item>module->imports</item>
      <item>module->indirect-exports</item>
      <item>module->language-info</item>
      <item>module->namespace</item>
      <item>module-compiled-cross-phase-persistent?</item>
      <item>module-compiled-exports</item>
      <item>module-compiled-imports</item>
      <item>module-compiled-indirect-exports</item>
      <item>module-compiled-language-info</item>
      <item>module-compiled-name</item>
      <item>module-compiled-submodules</item>
      <item>module-declared?</item>
      <item>module-path-index-join</item>
      <item>module-path-index-resolve</item>
      <item>module-path-index-split</item>
      <item>module-path-index-submodule</item>
      <item>module-path-index?</item>
      <item>module-path?</item>
      <item>module-predefined?</item>
      <item>module-provide-protected?</item>
      <item>modulo</item>
      <item>mpair?</item>
      <item>mu</item>
      <item>mutable-set</item>
      <item>mutable-seteq</item>
      <item>mutable-seteqv</item>
      <item>n->th</item>
      <item>nack-guard-evt</item>
      <item>namespace-anchor->empty-namespace</item>
      <item>namespace-anchor->namespace</item>
      <item>namespace-anchor?</item>
      <item>namespace-attach-module</item>
      <item>namespace-attach-module-declaration</item>
      <item>namespace-base-phase</item>
      <item>namespace-mapped-symbols</item>
      <item>namespace-module-identifier</item>
      <item>namespace-module-registry</item>
      <item>namespace-require</item>
      <item>namespace-require/constant</item>
      <item>namespace-require/copy</item>
      <item>namespace-require/expansion-time</item>
      <item>namespace-set-variable-value!</item>
      <item>namespace-symbol->identifier</item>
      <item>namespace-syntax-introduce</item>
      <item>namespace-undefine-variable!</item>
      <item>namespace-unprotect-module</item>
      <item>namespace-variable-value</item>
      <item>namespace?</item>
      <item>nan?</item>
      <item>nand</item>
      <item>natural-number/c</item>
      <item>natural?</item>
      <item>negate</item>
      <item>negative-integer?</item>
      <item>negative?</item>
      <item>never-evt</item>
      <item>new</item>
      <item>new-∀/c</item>
      <item>new-∃/c</item>
      <item>newline</item>
      <item>ninth</item>
      <item>non-empty-listof</item>
      <item>non-empty-string?</item>
      <item>none/c</item>
      <item>nonnegative-integer?</item>
      <item>nonpositive-integer?</item>
      <item>nor</item>
      <item>normal-case-path</item>
      <item>normalize-arity</item>
      <item>normalize-path</item>
      <item>normalized-arity?</item>
      <item>not</item>
      <item>not/c</item>
      <item>null</item>
      <item>null?</item>
      <item>number->string</item>
      <item>number?</item>
      <item>numerator</item>
      <item>object%</item>
      <item>object->vector</item>
      <item>object-contract</item>
      <item>object-info</item>
      <item>object-interface</item>
      <item>object-method-arity-includes?</item>
      <item>object-name</item>
      <item>object-or-false=?</item>
      <item>object/c</item>
      <item>object=?</item>
      <item>object?</item>
      <item>odd?</item>
      <item>one-of/c</item>
      <item>only</item>
      <item>open</item>
      <item>open-input-bytes</item>
      <item>open-input-string</item>
      <item>open-output-bytes</item>
      <item>open-output-nowhere</item>
      <item>open-output-string</item>
      <item>opt-lambda:</item>
      <item>opt/c</item>
      <item>or/c</item>
      <item>order-of-magnitude</item>
      <item>ormap</item>
      <item>other-execute-bit</item>
      <item>other-read-bit</item>
      <item>other-write-bit</item>
      <item>output-port?</item>
      <item>overment</item>
      <item>overment*</item>
      <item>override</item>
      <item>override*</item>
      <item>override-final</item>
      <item>override-final*</item>
      <item>pair?</item>
      <item>parameter-procedure=?</item>
      <item>parameter/c</item>
      <item>parameter?</item>
      <item>parameterization?</item>
      <item>parametric->/c</item>
      <item>parse-command-line</item>
      <item>parse-leftover->*</item>
      <item>partition</item>
      <item>path->bytes</item>
      <item>path->complete-path</item>
      <item>path->directory-path</item>
      <item>path->string</item>
      <item>path-add-extension</item>
      <item>path-add-suffix</item>
      <item>path-convention-type</item>
      <item>path-element->bytes</item>
      <item>path-element->string</item>
      <item>path-element?</item>
      <item>path-for-some-system?</item>
      <item>path-get-extension</item>
      <item>path-has-extension?</item>
      <item>path-list-string->path-list</item>
      <item>path-only</item>
      <item>path-replace-extension</item>
      <item>path-replace-suffix</item>
      <item>path-string?</item>
      <item>path&lt;?</item>
      <item>path?</item>
      <item>pathlist-closure</item>
      <item>pcase-lambda:</item>
      <item>pdefine:</item>
      <item>peek-byte</item>
      <item>peek-byte-or-special</item>
      <item>peek-bytes</item>
      <item>peek-bytes!</item>
      <item>peek-bytes!-evt</item>
      <item>peek-bytes-avail!</item>
      <item>peek-bytes-avail!*</item>
      <item>peek-bytes-avail!-evt</item>
      <item>peek-bytes-avail!/enable-break</item>
      <item>peek-bytes-evt</item>
      <item>peek-char</item>
      <item>peek-char-or-special</item>
      <item>peek-string</item>
      <item>peek-string!</item>
      <item>peek-string!-evt</item>
      <item>peek-string-evt</item>
      <item>peeking-input-port</item>
      <item>permutations</item>
      <item>phantom-bytes?</item>
      <item>pi</item>
      <item>pi.f</item>
      <item>pipe-content-length</item>
      <item>place</item>
      <item>place*</item>
      <item>place-break</item>
      <item>place-channel</item>
      <item>place-channel-get</item>
      <item>place-channel-put</item>
      <item>place-channel-put/get</item>
      <item>place-channel?</item>
      <item>place-dead-evt</item>
      <item>place-enabled?</item>
      <item>place-kill</item>
      <item>place-location?</item>
      <item>place-message-allowed?</item>
      <item>place-sleep</item>
      <item>place-wait</item>
      <item>place/context</item>
      <item>place?</item>
      <item>placeholder-get</item>
      <item>placeholder-set!</item>
      <item>placeholder?</item>
      <item>plambda:</item>
      <item>plet:</item>
      <item>plumber-add-flush!</item>
      <item>plumber-flush-all</item>
      <item>plumber-flush-handle-remove!</item>
      <item>plumber-flush-handle?</item>
      <item>plumber?</item>
      <item>poll-guard-evt</item>
      <item>popt-lambda:</item>
      <item>port->bytes</item>
      <item>port->bytes-lines</item>
      <item>port->lines</item>
      <item>port->list</item>
      <item>port->string</item>
      <item>port-closed-evt</item>
      <item>port-closed?</item>
      <item>port-commit-peeked</item>
      <item>port-count-lines!</item>
      <item>port-count-lines-enabled</item>
      <item>port-counts-lines?</item>
      <item>port-display-handler</item>
      <item>port-file-identity</item>
      <item>port-file-unlock</item>
      <item>port-next-location</item>
      <item>port-number?</item>
      <item>port-print-handler</item>
      <item>port-progress-evt</item>
      <item>port-provides-progress-evts?</item>
      <item>port-read-handler</item>
      <item>port-try-file-lock?</item>
      <item>port-write-handler</item>
      <item>port-writes-atomic?</item>
      <item>port-writes-special?</item>
      <item>port?</item>
      <item>positive-integer?</item>
      <item>positive?</item>
      <item>pred</item>
      <item>predicate/c</item>
      <item>prefab-key->struct-type</item>
      <item>prefab-key?</item>
      <item>prefab-struct-key</item>
      <item>preferences-lock-file-mode</item>
      <item>prefix</item>
      <item>pregexp</item>
      <item>pregexp?</item>
      <item>pretty-display</item>
      <item>pretty-format</item>
      <item>pretty-print</item>
      <item>pretty-print-.-symbol-without-bars</item>
      <item>pretty-print-abbreviate-read-macros</item>
      <item>pretty-print-columns</item>
      <item>pretty-print-current-style-table</item>
      <item>pretty-print-depth</item>
      <item>pretty-print-exact-as-decimal</item>
      <item>pretty-print-extend-style-table</item>
      <item>pretty-print-handler</item>
      <item>pretty-print-newline</item>
      <item>pretty-print-post-print-hook</item>
      <item>pretty-print-pre-print-hook</item>
      <item>pretty-print-print-hook</item>
      <item>pretty-print-print-line</item>
      <item>pretty-print-remap-stylable</item>
      <item>pretty-print-show-inexactness</item>
      <item>pretty-print-size-hook</item>
      <item>pretty-print-style-table?</item>
      <item>pretty-printing</item>
      <item>pretty-write</item>
      <item>primitive-closure?</item>
      <item>primitive-result-arity</item>
      <item>primitive?</item>
      <item>print</item>
      <item>print-as-expression</item>
      <item>print-boolean-long-form</item>
      <item>print-box</item>
      <item>print-graph</item>
      <item>print-hash-table</item>
      <item>print-mpair-curly-braces</item>
      <item>print-pair-curly-braces</item>
      <item>print-reader-abbreviations</item>
      <item>print-struct</item>
      <item>print-syntax-width</item>
      <item>print-unreadable</item>
      <item>print-vector-length</item>
      <item>printable/c</item>
      <item>printable&lt;%&gt;</item>
      <item>printf</item>
      <item>println</item>
      <item>private</item>
      <item>private*</item>
      <item>procedure->method</item>
      <item>procedure-arity</item>
      <item>procedure-arity-includes/c</item>
      <item>procedure-arity-includes?</item>
      <item>procedure-arity?</item>
      <item>procedure-closure-contents-eq?</item>
      <item>procedure-extract-target</item>
      <item>procedure-impersonator*?</item>
      <item>procedure-keywords</item>
      <item>procedure-reduce-arity</item>
      <item>procedure-reduce-keyword-arity</item>
      <item>procedure-rename</item>
      <item>procedure-result-arity</item>
      <item>procedure-specialize</item>
      <item>procedure-struct-type?</item>
      <item>procedure?</item>
      <item>process</item>
      <item>process*</item>
      <item>process*/ports</item>
      <item>process/ports</item>
      <item>processor-count</item>
      <item>progress-evt?</item>
      <item>promise-forced?</item>
      <item>promise-running?</item>
      <item>promise/c</item>
      <item>promise/name?</item>
      <item>promise?</item>
      <item>prompt-tag/c</item>
      <item>prop:arity-string</item>
      <item>prop:arrow-contract</item>
      <item>prop:arrow-contract-get-info</item>
      <item>prop:arrow-contract?</item>
      <item>prop:authentic</item>
      <item>prop:blame</item>
      <item>prop:chaperone-contract</item>
      <item>prop:checked-procedure</item>
      <item>prop:contract</item>
      <item>prop:contracted</item>
      <item>prop:custom-print-quotable</item>
      <item>prop:custom-write</item>
      <item>prop:dict</item>
      <item>prop:dict/contract</item>
      <item>prop:equal+hash</item>
      <item>prop:evt</item>
      <item>prop:exn:missing-module</item>
      <item>prop:exn:srclocs</item>
      <item>prop:expansion-contexts</item>
      <item>prop:flat-contract</item>
      <item>prop:impersonator-of</item>
      <item>prop:input-port</item>
      <item>prop:legacy-match-expander</item>
      <item>prop:liberal-define-context</item>
      <item>prop:match-expander</item>
      <item>prop:object-name</item>
      <item>prop:opt-chaperone-contract</item>
      <item>prop:opt-chaperone-contract-get-test</item>
      <item>prop:opt-chaperone-contract?</item>
      <item>prop:orc-contract</item>
      <item>prop:orc-contract-get-subcontracts</item>
      <item>prop:orc-contract?</item>
      <item>prop:output-port</item>
      <item>prop:place-location</item>
      <item>prop:procedure</item>
      <item>prop:recursive-contract</item>
      <item>prop:recursive-contract-unroll</item>
      <item>prop:recursive-contract?</item>
      <item>prop:rename-transformer</item>
      <item>prop:sequence</item>
      <item>prop:set!-transformer</item>
      <item>prop:stream</item>
      <item>proper-subset?</item>
      <item>provide-signature-elements</item>
      <item>provide/contract</item>
      <item>provide:</item>
      <item>pseudo-random-generator->vector</item>
      <item>pseudo-random-generator-vector?</item>
      <item>pseudo-random-generator?</item>
      <item>public</item>
      <item>public*</item>
      <item>public-final</item>
      <item>public-final*</item>
      <item>pubment</item>
      <item>pubment*</item>
      <item>put-preferences</item>
      <item>putenv</item>
      <item>quotient</item>
      <item>quotient/remainder</item>
      <item>radians->degrees</item>
      <item>raise</item>
      <item>raise-argument-error</item>
      <item>raise-arguments-error</item>
      <item>raise-arity-error</item>
      <item>raise-blame-error</item>
      <item>raise-contract-error</item>
      <item>raise-mismatch-error</item>
      <item>raise-not-cons-blame-error</item>
      <item>raise-range-error</item>
      <item>raise-result-error</item>
      <item>raise-syntax-error</item>
      <item>raise-type-error</item>
      <item>raise-user-error</item>
      <item>random</item>
      <item>random-seed</item>
      <item>range</item>
      <item>rational?</item>
      <item>rationalize</item>
      <item>read</item>
      <item>read-accept-bar-quote</item>
      <item>read-accept-box</item>
      <item>read-accept-compiled</item>
      <item>read-accept-dot</item>
      <item>read-accept-graph</item>
      <item>read-accept-infix-dot</item>
      <item>read-accept-lang</item>
      <item>read-accept-quasiquote</item>
      <item>read-accept-reader</item>
      <item>read-byte</item>
      <item>read-byte-or-special</item>
      <item>read-bytes</item>
      <item>read-bytes!</item>
      <item>read-bytes!-evt</item>
      <item>read-bytes-avail!</item>
      <item>read-bytes-avail!*</item>
      <item>read-bytes-avail!-evt</item>
      <item>read-bytes-avail!/enable-break</item>
      <item>read-bytes-evt</item>
      <item>read-bytes-line</item>
      <item>read-bytes-line-evt</item>
      <item>read-case-sensitive</item>
      <item>read-cdot</item>
      <item>read-char</item>
      <item>read-char-or-special</item>
      <item>read-curly-brace-as-paren</item>
      <item>read-curly-brace-with-tag</item>
      <item>read-decimal-as-inexact</item>
      <item>read-eval-print-loop</item>
      <item>read-language</item>
      <item>read-line</item>
      <item>read-line-evt</item>
      <item>read-on-demand-source</item>
      <item>read-square-bracket-as-paren</item>
      <item>read-square-bracket-with-tag</item>
      <item>read-string</item>
      <item>read-string!</item>
      <item>read-string!-evt</item>
      <item>read-string-evt</item>
      <item>read-syntax</item>
      <item>read-syntax/recursive</item>
      <item>read/recursive</item>
      <item>readtable-mapping</item>
      <item>readtable?</item>
      <item>real->decimal-string</item>
      <item>real->double-flonum</item>
      <item>real->floating-point-bytes</item>
      <item>real->single-flonum</item>
      <item>real-in</item>
      <item>real-part</item>
      <item>real?</item>
      <item>recontract-out</item>
      <item>record-disappeared-uses</item>
      <item>recursive-contract</item>
      <item>reencode-input-port</item>
      <item>reencode-output-port</item>
      <item>regexp</item>
      <item>regexp-match</item>
      <item>regexp-match-evt</item>
      <item>regexp-match-exact?</item>
      <item>regexp-match-peek</item>
      <item>regexp-match-peek-immediate</item>
      <item>regexp-match-peek-positions</item>
      <item>regexp-match-peek-positions-immediate</item>
      <item>regexp-match-peek-positions-immediate/end</item>
      <item>regexp-match-peek-positions/end</item>
      <item>regexp-match-positions</item>
      <item>regexp-match-positions/end</item>
      <item>regexp-match/end</item>
      <item>regexp-match?</item>
      <item>regexp-max-lookbehind</item>
      <item>regexp-quote</item>
      <item>regexp-replace</item>
      <item>regexp-replace*</item>
      <item>regexp-replace-quote</item>
      <item>regexp-replaces</item>
      <item>regexp-split</item>
      <item>regexp-try-match</item>
      <item>regexp?</item>
      <item>relative-path?</item>
      <item>relocate-input-port</item>
      <item>relocate-output-port</item>
      <item>remainder</item>
      <item>remf</item>
      <item>remf*</item>
      <item>remove</item>
      <item>remove*</item>
      <item>remove-duplicates</item>
      <item>remq</item>
      <item>remq*</item>
      <item>remv</item>
      <item>remv*</item>
      <item>rename</item>
      <item>rename-contract</item>
      <item>rename-file-or-directory</item>
      <item>rename-inner</item>
      <item>rename-super</item>
      <item>rename-transformer-target</item>
      <item>rename-transformer?</item>
      <item>replace-evt</item>
      <item>require-typed-struct</item>
      <item>require-typed-struct/provide</item>
      <item>require/opaque-type</item>
      <item>require/typed</item>
      <item>require/typed/provide</item>
      <item>reroot-path</item>
      <item>resolve-path</item>
      <item>resolved-module-path-name</item>
      <item>resolved-module-path?</item>
      <item>rest</item>
      <item>reverse</item>
      <item>round</item>
      <item>row-inst</item>
      <item>second</item>
      <item>seconds->date</item>
      <item>security-guard?</item>
      <item>semaphore-peek-evt</item>
      <item>semaphore-peek-evt?</item>
      <item>semaphore-post</item>
      <item>semaphore-try-wait?</item>
      <item>semaphore-wait</item>
      <item>semaphore-wait/enable-break</item>
      <item>semaphore?</item>
      <item>send</item>
      <item>send*</item>
      <item>send+</item>
      <item>send-generic</item>
      <item>send/apply</item>
      <item>send/keyword-apply</item>
      <item>sequence->list</item>
      <item>sequence->stream</item>
      <item>sequence-add-between</item>
      <item>sequence-andmap</item>
      <item>sequence-append</item>
      <item>sequence-count</item>
      <item>sequence-filter</item>
      <item>sequence-fold</item>
      <item>sequence-for-each</item>
      <item>sequence-generate</item>
      <item>sequence-generate*</item>
      <item>sequence-length</item>
      <item>sequence-map</item>
      <item>sequence-ormap</item>
      <item>sequence-ref</item>
      <item>sequence-tail</item>
      <item>sequence/c</item>
      <item>sequence?</item>
      <item>set</item>
      <item>set!-transformer-procedure</item>
      <item>set!-transformer?</item>
      <item>set->list</item>
      <item>set->stream</item>
      <item>set-add</item>
      <item>set-add!</item>
      <item>set-box!</item>
      <item>set-clear</item>
      <item>set-clear!</item>
      <item>set-copy</item>
      <item>set-copy-clear</item>
      <item>set-count</item>
      <item>set-empty?</item>
      <item>set-eq?</item>
      <item>set-equal?</item>
      <item>set-eqv?</item>
      <item>set-field!</item>
      <item>set-first</item>
      <item>set-for-each</item>
      <item>set-implements/c</item>
      <item>set-implements?</item>
      <item>set-intersect</item>
      <item>set-intersect!</item>
      <item>set-map</item>
      <item>set-mcar!</item>
      <item>set-mcdr!</item>
      <item>set-member?</item>
      <item>set-mutable?</item>
      <item>set-phantom-bytes!</item>
      <item>set-port-next-location!</item>
      <item>set-remove</item>
      <item>set-remove!</item>
      <item>set-rest</item>
      <item>set-subtract</item>
      <item>set-subtract!</item>
      <item>set-symmetric-difference</item>
      <item>set-symmetric-difference!</item>
      <item>set-union</item>
      <item>set-union!</item>
      <item>set-weak?</item>
      <item>set/c</item>
      <item>set=?</item>
      <item>set?</item>
      <item>seteq</item>
      <item>seteqv</item>
      <item>seventh</item>
      <item>sgn</item>
      <item>shared</item>
      <item>shared-bytes</item>
      <item>shell-execute</item>
      <item>shrink-path-wrt</item>
      <item>shuffle</item>
      <item>simple-form-path</item>
      <item>simplify-path</item>
      <item>sin</item>
      <item>single-flonum?</item>
      <item>sinh</item>
      <item>sixth</item>
      <item>skip-projection-wrapper?</item>
      <item>sleep</item>
      <item>some-system-path->string</item>
      <item>special-comment-value</item>
      <item>special-comment?</item>
      <item>special-filter-input-port</item>
      <item>split-at</item>
      <item>split-at-right</item>
      <item>split-common-prefix</item>
      <item>split-path</item>
      <item>splitf-at</item>
      <item>splitf-at-right</item>
      <item>sqr</item>
      <item>sqrt</item>
      <item>srcloc->string</item>
      <item>srcloc-column</item>
      <item>srcloc-line</item>
      <item>srcloc-position</item>
      <item>srcloc-source</item>
      <item>srcloc-span</item>
      <item>srcloc?</item>
      <item>stop-after</item>
      <item>stop-before</item>
      <item>stream</item>
      <item>stream*</item>
      <item>stream->list</item>
      <item>stream-add-between</item>
      <item>stream-andmap</item>
      <item>stream-append</item>
      <item>stream-cons</item>
      <item>stream-count</item>
      <item>stream-empty?</item>
      <item>stream-filter</item>
      <item>stream-first</item>
      <item>stream-fold</item>
      <item>stream-for-each</item>
      <item>stream-length</item>
      <item>stream-map</item>
      <item>stream-ormap</item>
      <item>stream-ref</item>
      <item>stream-rest</item>
      <item>stream-tail</item>
      <item>stream/c</item>
      <item>stream?</item>
      <item>string</item>
      <item>string->bytes/latin-1</item>
      <item>string->bytes/locale</item>
      <item>string->bytes/utf-8</item>
      <item>string->immutable-string</item>
      <item>string->keyword</item>
      <item>string->list</item>
      <item>string->number</item>
      <item>string->path</item>
      <item>string->path-element</item>
      <item>string->some-system-path</item>
      <item>string->symbol</item>
      <item>string->uninterned-symbol</item>
      <item>string->unreadable-symbol</item>
      <item>string-append</item>
      <item>string-append*</item>
      <item>string-ci&lt;=?</item>
      <item>string-ci&lt;?</item>
      <item>string-ci=?</item>
      <item>string-ci>=?</item>
      <item>string-ci>?</item>
      <item>string-contains?</item>
      <item>string-copy</item>
      <item>string-copy!</item>
      <item>string-downcase</item>
      <item>string-environment-variable-name?</item>
      <item>string-fill!</item>
      <item>string-foldcase</item>
      <item>string-join</item>
      <item>string-len/c</item>
      <item>string-length</item>
      <item>string-locale-ci&lt;?</item>
      <item>string-locale-ci=?</item>
      <item>string-locale-ci>?</item>
      <item>string-locale-downcase</item>
      <item>string-locale-upcase</item>
      <item>string-locale&lt;?</item>
      <item>string-locale=?</item>
      <item>string-locale>?</item>
      <item>string-no-nuls?</item>
      <item>string-normalize-nfc</item>
      <item>string-normalize-nfd</item>
      <item>string-normalize-nfkc</item>
      <item>string-normalize-nfkd</item>
      <item>string-normalize-spaces</item>
      <item>string-port?</item>
      <item>string-prefix?</item>
      <item>string-ref</item>
      <item>string-replace</item>
      <item>string-set!</item>
      <item>string-split</item>
      <item>string-suffix?</item>
      <item>string-titlecase</item>
      <item>string-trim</item>
      <item>string-upcase</item>
      <item>string-utf-8-length</item>
      <item>string&lt;=?</item>
      <item>string&lt;?</item>
      <item>string=?</item>
      <item>string>=?</item>
      <item>string>?</item>
      <item>string?</item>
      <item>struct*</item>
      <item>struct->vector</item>
      <item>struct-accessor-procedure?</item>
      <item>struct-constructor-procedure?</item>
      <item>struct-info</item>
      <item>struct-mutator-procedure?</item>
      <item>struct-predicate-procedure?</item>
      <item>struct-type-info</item>
      <item>struct-type-make-constructor</item>
      <item>struct-type-make-predicate</item>
      <item>struct-type-property-accessor-procedure?</item>
      <item>struct-type-property/c</item>
      <item>struct-type-property?</item>
      <item>struct-type?</item>
      <item>struct/c</item>
      <item>struct/ctc</item>
      <item>struct/dc</item>
      <item>struct:</item>
      <item>struct:arity-at-least</item>
      <item>struct:arrow-contract-info</item>
      <item>struct:date</item>
      <item>struct:date*</item>
      <item>struct:exn</item>
      <item>struct:exn:break</item>
      <item>struct:exn:break:hang-up</item>
      <item>struct:exn:break:terminate</item>
      <item>struct:exn:fail</item>
      <item>struct:exn:fail:contract</item>
      <item>struct:exn:fail:contract:arity</item>
      <item>struct:exn:fail:contract:blame</item>
      <item>struct:exn:fail:contract:continuation</item>
      <item>struct:exn:fail:contract:divide-by-zero</item>
      <item>struct:exn:fail:contract:non-fixnum-result</item>
      <item>struct:exn:fail:contract:variable</item>
      <item>struct:exn:fail:filesystem</item>
      <item>struct:exn:fail:filesystem:errno</item>
      <item>struct:exn:fail:filesystem:exists</item>
      <item>struct:exn:fail:filesystem:missing-module</item>
      <item>struct:exn:fail:filesystem:version</item>
      <item>struct:exn:fail:network</item>
      <item>struct:exn:fail:network:errno</item>
      <item>struct:exn:fail:object</item>
      <item>struct:exn:fail:out-of-memory</item>
      <item>struct:exn:fail:read</item>
      <item>struct:exn:fail:read:eof</item>
      <item>struct:exn:fail:read:non-char</item>
      <item>struct:exn:fail:syntax</item>
      <item>struct:exn:fail:syntax:missing-module</item>
      <item>struct:exn:fail:syntax:unbound</item>
      <item>struct:exn:fail:unsupported</item>
      <item>struct:exn:fail:user</item>
      <item>struct:srcloc</item>
      <item>struct:wrapped-extra-arg-arrow</item>
      <item>struct?</item>
      <item>sub1</item>
      <item>subbytes</item>
      <item>subclass?</item>
      <item>subclass?/c</item>
      <item>subprocess</item>
      <item>subprocess-group-enabled</item>
      <item>subprocess-kill</item>
      <item>subprocess-pid</item>
      <item>subprocess-status</item>
      <item>subprocess-wait</item>
      <item>subprocess?</item>
      <item>subset?</item>
      <item>substring</item>
      <item>suggest/c</item>
      <item>super</item>
      <item>super-instantiate</item>
      <item>super-make-object</item>
      <item>super-new</item>
      <item>symbol->string</item>
      <item>symbol-interned?</item>
      <item>symbol-unreadable?</item>
      <item>symbol&lt;?</item>
      <item>symbol=?</item>
      <item>symbol?</item>
      <item>symbols</item>
      <item>sync</item>
      <item>sync/enable-break</item>
      <item>sync/timeout</item>
      <item>sync/timeout/enable-break</item>
      <item>syntax->datum</item>
      <item>syntax->list</item>
      <item>syntax-arm</item>
      <item>syntax-column</item>
      <item>syntax-debug-info</item>
      <item>syntax-disarm</item>
      <item>syntax-e</item>
      <item>syntax-line</item>
      <item>syntax-local-bind-syntaxes</item>
      <item>syntax-local-certifier</item>
      <item>syntax-local-context</item>
      <item>syntax-local-eval</item>
      <item>syntax-local-expand-expression</item>
      <item>syntax-local-get-shadower</item>
      <item>syntax-local-identifier-as-binding</item>
      <item>syntax-local-introduce</item>
      <item>syntax-local-lift-context</item>
      <item>syntax-local-lift-expression</item>
      <item>syntax-local-lift-module</item>
      <item>syntax-local-lift-module-end-declaration</item>
      <item>syntax-local-lift-provide</item>
      <item>syntax-local-lift-require</item>
      <item>syntax-local-lift-values-expression</item>
      <item>syntax-local-make-definition-context</item>
      <item>syntax-local-make-delta-introducer</item>
      <item>syntax-local-match-introduce</item>
      <item>syntax-local-module-defined-identifiers</item>
      <item>syntax-local-module-exports</item>
      <item>syntax-local-module-required-identifiers</item>
      <item>syntax-local-name</item>
      <item>syntax-local-phase-level</item>
      <item>syntax-local-submodules</item>
      <item>syntax-local-transforming-module-provides?</item>
      <item>syntax-local-value</item>
      <item>syntax-local-value/immediate</item>
      <item>syntax-local-value/record</item>
      <item>syntax-original?</item>
      <item>syntax-parse</item>
      <item>syntax-parser</item>
      <item>syntax-pattern-variable?</item>
      <item>syntax-position</item>
      <item>syntax-property</item>
      <item>syntax-property-preserved?</item>
      <item>syntax-property-symbol-keys</item>
      <item>syntax-protect</item>
      <item>syntax-rearm</item>
      <item>syntax-recertify</item>
      <item>syntax-shift-phase-level</item>
      <item>syntax-source</item>
      <item>syntax-source-module</item>
      <item>syntax-span</item>
      <item>syntax-taint</item>
      <item>syntax-tainted?</item>
      <item>syntax-track-origin</item>
      <item>syntax-transforming-module-expression?</item>
      <item>syntax-transforming-with-lifts?</item>
      <item>syntax-transforming?</item>
      <item>syntax/c</item>
      <item>syntax?</item>
      <item>system</item>
      <item>system*</item>
      <item>system*/exit-code</item>
      <item>system-big-endian?</item>
      <item>system-idle-evt</item>
      <item>system-language+country</item>
      <item>system-library-subpath</item>
      <item>system-path-convention-type</item>
      <item>system-type</item>
      <item>system/exit-code</item>
      <item>tag</item>
      <item>tail-marks-match?</item>
      <item>take</item>
      <item>take-common-prefix</item>
      <item>take-right</item>
      <item>takef</item>
      <item>takef-right</item>
      <item>tan</item>
      <item>tanh</item>
      <item>tcp-abandon-port</item>
      <item>tcp-accept</item>
      <item>tcp-accept-evt</item>
      <item>tcp-accept-ready?</item>
      <item>tcp-accept/enable-break</item>
      <item>tcp-addresses</item>
      <item>tcp-close</item>
      <item>tcp-connect</item>
      <item>tcp-connect/enable-break</item>
      <item>tcp-listen</item>
      <item>tcp-listener?</item>
      <item>tcp-port?</item>
      <item>tentative-pretty-print-port-cancel</item>
      <item>tentative-pretty-print-port-transfer</item>
      <item>tenth</item>
      <item>terminal-port?</item>
      <item>the-unsupplied-arg</item>
      <item>third</item>
      <item>this</item>
      <item>this%</item>
      <item>thread</item>
      <item>thread-cell-ref</item>
      <item>thread-cell-set!</item>
      <item>thread-cell-values?</item>
      <item>thread-cell?</item>
      <item>thread-dead-evt</item>
      <item>thread-dead?</item>
      <item>thread-group?</item>
      <item>thread-receive</item>
      <item>thread-receive-evt</item>
      <item>thread-resume</item>
      <item>thread-resume-evt</item>
      <item>thread-rewind-receive</item>
      <item>thread-running?</item>
      <item>thread-send</item>
      <item>thread-suspend</item>
      <item>thread-suspend-evt</item>
      <item>thread-try-receive</item>
      <item>thread-wait</item>
      <item>thread/suspend-to-kill</item>
      <item>thread?</item>
      <item>thunk</item>
      <item>thunk*</item>
      <item>time-apply</item>
      <item>touch</item>
      <item>transplant-input-port</item>
      <item>transplant-output-port</item>
      <item>true</item>
      <item>truncate</item>
      <item>typecheck-fail</item>
      <item>udp-addresses</item>
      <item>udp-bind!</item>
      <item>udp-bound?</item>
      <item>udp-close</item>
      <item>udp-connect!</item>
      <item>udp-connected?</item>
      <item>udp-multicast-interface</item>
      <item>udp-multicast-join-group!</item>
      <item>udp-multicast-leave-group!</item>
      <item>udp-multicast-loopback?</item>
      <item>udp-multicast-set-interface!</item>
      <item>udp-multicast-set-loopback!</item>
      <item>udp-multicast-set-ttl!</item>
      <item>udp-multicast-ttl</item>
      <item>udp-open-socket</item>
      <item>udp-receive!</item>
      <item>udp-receive!*</item>
      <item>udp-receive!-evt</item>
      <item>udp-receive!/enable-break</item>
      <item>udp-receive-ready-evt</item>
      <item>udp-send</item>
      <item>udp-send*</item>
      <item>udp-send-evt</item>
      <item>udp-send-ready-evt</item>
      <item>udp-send-to</item>
      <item>udp-send-to*</item>
      <item>udp-send-to-evt</item>
      <item>udp-send-to/enable-break</item>
      <item>udp-send/enable-break</item>
      <item>udp?</item>
      <item>unbox</item>
      <item>uncaught-exception-handler</item>
      <item>unconstrained-domain-></item>
      <item>unit</item>
      <item>unit-from-context</item>
      <item>unit/c</item>
      <item>unit/new-import-export</item>
      <item>unit/s</item>
      <item>unit?</item>
      <item>unspecified-dom</item>
      <item>unsupplied-arg?</item>
      <item>use-collection-link-paths</item>
      <item>use-compiled-file-check</item>
      <item>use-compiled-file-paths</item>
      <item>use-user-specific-search-paths</item>
      <item>user-execute-bit</item>
      <item>user-read-bit</item>
      <item>user-write-bit</item>
      <item>value-blame</item>
      <item>value-contract</item>
      <item>values</item>
      <item>values/drop</item>
      <item>variable-reference->empty-namespace</item>
      <item>variable-reference->module-base-phase</item>
      <item>variable-reference->module-declaration-inspector</item>
      <item>variable-reference->module-path-index</item>
      <item>variable-reference->module-source</item>
      <item>variable-reference->namespace</item>
      <item>variable-reference->phase</item>
      <item>variable-reference->resolved-module-path</item>
      <item>variable-reference-constant?</item>
      <item>variable-reference?</item>
      <item>vector</item>
      <item>vector->immutable-vector</item>
      <item>vector->list</item>
      <item>vector->pseudo-random-generator</item>
      <item>vector->pseudo-random-generator!</item>
      <item>vector->values</item>
      <item>vector-append</item>
      <item>vector-argmax</item>
      <item>vector-argmin</item>
      <item>vector-copy</item>
      <item>vector-copy!</item>
      <item>vector-count</item>
      <item>vector-drop</item>
      <item>vector-drop-right</item>
      <item>vector-fill!</item>
      <item>vector-filter</item>
      <item>vector-filter-not</item>
      <item>vector-immutable</item>
      <item>vector-immutable/c</item>
      <item>vector-immutableof</item>
      <item>vector-length</item>
      <item>vector-map</item>
      <item>vector-map!</item>
      <item>vector-member</item>
      <item>vector-memq</item>
      <item>vector-memv</item>
      <item>vector-ref</item>
      <item>vector-set!</item>
      <item>vector-set*!</item>
      <item>vector-set-performance-stats!</item>
      <item>vector-sort</item>
      <item>vector-sort!</item>
      <item>vector-split-at</item>
      <item>vector-split-at-right</item>
      <item>vector-take</item>
      <item>vector-take-right</item>
      <item>vector/c</item>
      <item>vector?</item>
      <item>vectorof</item>
      <item>version</item>
      <item>void</item>
      <item>void?</item>
      <item>weak-box-value</item>
      <item>weak-box?</item>
      <item>weak-set</item>
      <item>weak-seteq</item>
      <item>weak-seteqv</item>
      <item>will-execute</item>
      <item>will-executor?</item>
      <item>will-register</item>
      <item>will-try-execute</item>
      <item>with-asserts</item>
      <item>with-contract</item>
      <item>with-contract-continuation-mark</item>
      <item>with-disappeared-uses</item>
      <item>with-input-from-bytes</item>
      <item>with-input-from-string</item>
      <item>with-method</item>
      <item>with-output-to-bytes</item>
      <item>with-output-to-string</item>
      <item>with-syntax*</item>
      <item>with-type</item>
      <item>would-be-future</item>
      <item>wrap-evt</item>
      <item>wrapped-extra-arg-arrow</item>
      <item>wrapped-extra-arg-arrow-extra-neg-party-argument</item>
      <item>wrapped-extra-arg-arrow-real-func</item>
      <item>wrapped-extra-arg-arrow?</item>
      <item>writable&lt;%&gt;</item>
      <item>write</item>
      <item>write-byte</item>
      <item>write-bytes</item>
      <item>write-bytes-avail</item>
      <item>write-bytes-avail*</item>
      <item>write-bytes-avail-evt</item>
      <item>write-bytes-avail/enable-break</item>
      <item>write-char</item>
      <item>write-special</item>
      <item>write-special-avail*</item>
      <item>write-special-evt</item>
      <item>write-string</item>
      <item>write-to-file</item>
      <item>writeln</item>
      <item>wrong-syntax</item>
      <item>xor</item>
      <item>zero?</item>
      <item>~.a</item>
      <item>~.s</item>
      <item>~.v</item>
      <item>~a</item>
      <item>~e</item>
      <item>~r</item>
      <item>~s</item>
      <item>~v</item>
      <item>λ:</item>
      <item>→</item>
      <item>∀</item>
      <item>∩</item>
    </list>
    <list name="types">
      <item>All</item>
      <item>Any</item>
      <item>AnyValues</item>
      <item>Async-ChannelTop</item>
      <item>Async-Channelof</item>
      <item>Boolean</item>
      <item>Bot</item>
      <item>BoxTop</item>
      <item>Boxof</item>
      <item>Byte</item>
      <item>Byte-PRegexp</item>
      <item>Byte-Regexp</item>
      <item>Bytes</item>
      <item>Bytes-Converter</item>
      <item>ChannelTop</item>
      <item>Channelof</item>
      <item>Char</item>
      <item>Class</item>
      <item>ClassTop</item>
      <item>Compiled-Expression</item>
      <item>Compiled-Module-Expression</item>
      <item>Complex</item>
      <item>Continuation-Mark-KeyTop</item>
      <item>Continuation-Mark-Keyof</item>
      <item>Continuation-Mark-Set</item>
      <item>Custodian</item>
      <item>Custodian-Boxof</item>
      <item>Datum</item>
      <item>EOF</item>
      <item>Environment-Variables</item>
      <item>Ephemeronof</item>
      <item>Evtof</item>
      <item>Exact-Nonnegative-Integer</item>
      <item>Exact-Number</item>
      <item>Exact-Positive-Integer</item>
      <item>Exact-Rational</item>
      <item>ExtFlVector</item>
      <item>ExtFlonum</item>
      <item>ExtFlonum-Nan</item>
      <item>ExtFlonum-Negative-Zero</item>
      <item>ExtFlonum-Positive-Zero</item>
      <item>ExtFlonum-Zero</item>
      <item>FSemaphore</item>
      <item>False</item>
      <item>Fixnum</item>
      <item>FlVector</item>
      <item>Float</item>
      <item>Float-Complex</item>
      <item>Float-Nan</item>
      <item>Float-Negative-Zero</item>
      <item>Float-Positive-Zero</item>
      <item>Float-Zero</item>
      <item>Flonum</item>
      <item>Flonum-Nan</item>
      <item>Flonum-Negative-Zero</item>
      <item>Flonum-Positive-Zero</item>
      <item>Flonum-Zero</item>
      <item>Futureof</item>
      <item>FxVector</item>
      <item>HashTable</item>
      <item>HashTableTop</item>
      <item>Identifier</item>
      <item>Immutable-HashTable</item>
      <item>Impersonator-Property</item>
      <item>Index</item>
      <item>Inexact-Complex</item>
      <item>Inexact-Real</item>
      <item>Inexact-Real-Nan</item>
      <item>Inexact-Real-Negative-Zero</item>
      <item>Inexact-Real-Positive-Zero</item>
      <item>Inexact-Real-Zero</item>
      <item>Input-Port</item>
      <item>Inspector</item>
      <item>Instance</item>
      <item>Integer</item>
      <item>Internal-Definition-Context</item>
      <item>Intersection</item>
      <item>Keyword</item>
      <item>List</item>
      <item>List*</item>
      <item>Listof</item>
      <item>Log-Level</item>
      <item>Log-Receiver</item>
      <item>Logger</item>
      <item>MListof</item>
      <item>MPairTop</item>
      <item>MPairof</item>
      <item>Module-Path</item>
      <item>Module-Path-Index</item>
      <item>Mutable-HashTable</item>
      <item>Mutable-HashTableTop</item>
      <item>Namespace</item>
      <item>Namespace-Anchor</item>
      <item>Natural</item>
      <item>Negative-Exact-Rational</item>
      <item>Negative-ExtFlonum</item>
      <item>Negative-Fixnum</item>
      <item>Negative-Float</item>
      <item>Negative-Flonum</item>
      <item>Negative-Inexact-Real</item>
      <item>Negative-Integer</item>
      <item>Negative-Real</item>
      <item>Negative-Single-Flonum</item>
      <item>Nonnegative-Exact-Rational</item>
      <item>Nonnegative-ExtFlonum</item>
      <item>Nonnegative-Fixnum</item>
      <item>Nonnegative-Float</item>
      <item>Nonnegative-Flonum</item>
      <item>Nonnegative-Inexact-Real</item>
      <item>Nonnegative-Integer</item>
      <item>Nonnegative-Real</item>
      <item>Nonnegative-Single-Flonum</item>
      <item>Nonpositive-Exact-Rational</item>
      <item>Nonpositive-ExtFlonum</item>
      <item>Nonpositive-Fixnum</item>
      <item>Nonpositive-Float</item>
      <item>Nonpositive-Flonum</item>
      <item>Nonpositive-Inexact-Real</item>
      <item>Nonpositive-Integer</item>
      <item>Nonpositive-Real</item>
      <item>Nonpositive-Single-Flonum</item>
      <item>Nothing</item>
      <item>Null</item>
      <item>Number</item>
      <item>Object</item>
      <item>One</item>
      <item>Opaque</item>
      <item>Option</item>
      <item>Output-Port</item>
      <item>PRegexp</item>
      <item>Pair</item>
      <item>Pairof</item>
      <item>Parameter</item>
      <item>Parameterization</item>
      <item>Parameterof</item>
      <item>Path</item>
      <item>Path-For-Some-System</item>
      <item>Path-String</item>
      <item>Place</item>
      <item>Place-Channel</item>
      <item>Port</item>
      <item>Positive-Byte</item>
      <item>Positive-Exact-Rational</item>
      <item>Positive-ExtFlonum</item>
      <item>Positive-Fixnum</item>
      <item>Positive-Float</item>
      <item>Positive-Flonum</item>
      <item>Positive-Index</item>
      <item>Positive-Inexact-Real</item>
      <item>Positive-Integer</item>
      <item>Positive-Real</item>
      <item>Positive-Single-Flonum</item>
      <item>Prefab</item>
      <item>Pretty-Print-Style-Table</item>
      <item>Procedure</item>
      <item>Promise</item>
      <item>Prompt-TagTop</item>
      <item>Prompt-Tagof</item>
      <item>Pseudo-Random-Generator</item>
      <item>Read-Table</item>
      <item>Real</item>
      <item>Real-Zero</item>
      <item>Rec</item>
      <item>Refine</item>
      <item>Refinement</item>
      <item>Regexp</item>
      <item>Resolved-Module-Path</item>
      <item>Row</item>
      <item>Security-Guard</item>
      <item>Semaphore</item>
      <item>Sequenceof</item>
      <item>Setof</item>
      <item>Sexp</item>
      <item>Sexpof</item>
      <item>Single-Flonum</item>
      <item>Single-Flonum-Complex</item>
      <item>Single-Flonum-Nan</item>
      <item>Single-Flonum-Negative-Zero</item>
      <item>Single-Flonum-Positive-Zero</item>
      <item>Single-Flonum-Zero</item>
      <item>Special-Comment</item>
      <item>String</item>
      <item>Struct</item>
      <item>Struct-Type</item>
      <item>Struct-Type-Property</item>
      <item>Struct-TypeTop</item>
      <item>Subprocess</item>
      <item>Symbol</item>
      <item>Syntax</item>
      <item>Syntax-E</item>
      <item>Syntaxof</item>
      <item>TCP-Listener</item>
      <item>Thread</item>
      <item>Thread-CellTop</item>
      <item>Thread-Cellof</item>
      <item>Thread-Group</item>
      <item>Top</item>
      <item>True</item>
      <item>Tuple</item>
      <item>U</item>
      <item>UDP-Socket</item>
      <item>Un</item>
      <item>Undefined</item>
      <item>Union</item>
      <item>Unit</item>
      <item>UnitTop</item>
      <item>Values</item>
      <item>Variable-Reference</item>
      <item>Vector</item>
      <item>VectorTop</item>
      <item>Vectorof</item>
      <item>Void</item>
      <item>Weak-BoxTop</item>
      <item>Weak-Boxof</item>
      <item>Weak-HashTable</item>
      <item>Weak-HashTableTop</item>
      <item>Will-Executor</item>
      <item>Zero</item>
    </list>
    <contexts>
      <context 
          name="default"
          attribute="Normal"
          lineEndContext="#stay"
          fallthroughContext="#stay"
          >
        <!-- NOT SUPPORTED:       -->
        <!-- S-expression comment -->
        <!-- Nested block comment -->
        <!-- #!_ and #!\ comments -->
        <DetectSpaces/>
        <RegExpr
            String="#:&symbol;"
            attribute="Kwarg"
            context="#stay"
            />
        <AnyChar
            String="()[]{}."
            attribute="List"
            context="#stay"
            />
        <StringDetect
            String="#lang"
            attribute="ReaderExtension"
            context="reader_extension"
            />
        <!-- the next three are dedicated to modules -->
        <StringDetect
            String="module+"
            attribute="Module"
            context="module"
            />
        <StringDetect
            String="module*"
            attribute="Module"
            context="module"
            />
        <StringDetect
            String="module"
            attribute="Module"
            context="module"
            />
        <keyword
            String="multi_defines"
            attribute="Keyword"
            context="multi_define"
            />
        <keyword
            String="single_defines"
            attribute="Keyword"
            context="single_define"
            />
        <keyword
            String="types"
            attribute="Type"
            context="#stay"
            />
        <keyword
            String="keywords"
            attribute="Keyword"
            context="#stay"
            />
        <keyword
            String="builtins"
            attribute="BuiltIn"
            context="#stay"
            />
        <RegExpr
            String="#%&symbol;"
            attribute="Symbol"
            context="#stay"
            />
        <DetectChar
            char="&quot;"
            attribute="String"
            context="string"
            />
        <DetectChar 
            char="&apos;"
            attribute="Quote"
            context="#stay"
            />
        <DetectChar 
            char="`"
            attribute="Quasiquote"
            context="#stay"
            />
        <DetectChar 
            char=","
            attribute="Unquote"
            context="#stay"
            />
        <DetectChar 
            char=";"
            attribute="Comment" 
            context="line_comment"
            />
        <Detect2Chars
            char="#"
            char1="|"
            attribute="Comment" 
            context="block_comment"
            />
        <RegExpr
            String="#[FTft]"
            attribute="Boolean"
            context="#stay"
            />
        <Detect2Chars
            char="#"
            char1="\"
            attribute="Character"
            context="character"
            />
        <RegExpr
            String="#s[\(\[\{]"
            attribute="Structure"
            context="#stay"
            />
        <Detect2Chars
            char="#"
            char1="&quot;"
            attribute="String"
            context="string"
            />
        <Detect2Chars
            char="#"
            char1="&amp;"
            attribute="Box"
            context="#stay"
            />
        <Detect2Chars
            char="#"
            char1="'"
            attribute="SyntaxQuote"
            context="#stay"
            />
        <Detect2Chars
            char="#"
            char1="`"
            attribute="SyntaxQuasiquote"
            context="#stay"
            />
        <Detect2Chars
            char="#"
            char1=","
            attribute="SyntaxUnquote"
            context="#stay"
            />
        <Detect2Chars
            char="#"
            char1="~"
            attribute="CompiledCode"
            context="#stay"
            />
        <RegExpr
            lookAhead="true"
            String="[0-9+\-]|(?:#[BDEIOXbdeiox])"
            attribute="Number"
            context="number"
            />
        <StringDetect
            String="#&lt;&lt;"
            attribute="String"
            context="here_string"
            />
        <RegExpr
            String="#[pr]x"
            attribute="Regexp"
            context="#stay"
            />
        <RegExpr
            String="#[Cc][ISis]"
            attribute="CaseSensitivity"
            context="#stay"
            />
        <keyword
            String="hash_tables"
            attribute="HashTable"
            context="#stay"
            />
        <keyword
            String="reader_extensions"
            attribute="ReaderExtension"
            context="#stay"
            />
        <RegExpr
            String="#[Ff]?[LXlx]?[0-9]*[\(\[\{]"
            attribute="Vector"
            context="#stay"
            />
        <RegExpr
            String="#[0-9]{1,8}="
            attribute="BindGraph"
            context="#stay"
            />
        <RegExpr
            String="#[0-9]{1,8}#"
            attribute="UseGraph"
            context="#stay"
            />
        <RegExpr
            String="&symbol;"
            attribute="Symbol"
            context="#stay"
            />
      </context>

      <!-- List -->
      <context 
          name="list"
          attribute="List"
          lineEndContext="#stay"
          >
        <DetectSpaces/>
        <DetectChar
            char="."
            attribute="List"
            context="#stay"
            />
        <AnyChar
            String=")]}"
            attribute="List"
            context="#pop"
            />
        <IncludeRules 
            context="default"
            />
      </context>

      <!-- Comment -->
      <context
          name="line_comment"
          attribute="Comment"
          lineEndContext="#pop"
          fallbackContext="#stay"
          >
      </context>
      <context
          name="block_comment"
          attribute="Comment"
          lineEndContext="#stay"
          fallbackContext="#stay"
          >
        <Detect2Chars
            char="|"
            char1="#"
            attribute="Comment"
            context="#pop"
            />        
      </context>

      <!-- Character -->
      <context
          name="character"
          attribute="Character"
          lineEndContext="#pop"
          >
        <keyword
            String="characters"
            attribute="Character" 
            context="#pop"
            />
        <RegExpr
            String="[0-7]{3}"
            attribute="Character"
            context="#pop"
            />
        <RegExpr
            String="u[0-9A-Fa-f]{1,4}"
            attribute="Character"
            context="#pop"
            />
        <RegExpr
            String="U[0-9A-Fa-f]{1,8}"
            attribute="Character"
            context="#pop"
            />
        <RegExpr
            String="."
            attribute="Character"
            context="#pop"
            />
      </context>

      <!-- String -->
      <context
          name="string"
          attribute="String"
          lineEndContext="#stay"
          fallthroughContext="#stay"
          >
        <DetectChar
            char="&quot;"
            attribute="String"
            context="#pop"
            />
        <DetectChar
            char=" "
            attribute="String"
            context="#stay"
            />
        <Detect2Chars
            char="\"
            char1="&quot;"
            attribute="String"
            context="#stay"
            />
      </context>

      <context
          name="here_string"
          attribute="String"
          lineEndContext="#pop"
          fallthroughContext="#stay"
          >
      </context>

      <!-- Number -->
      <context
          name="number"
          attribute="Number"
          lineEndContext="#pop"
          fallthroughContext="#pop"
          >
        <RegExpr
            String="inf|nan|[#0-9A-FIOXa-fiox+\-/.]"
            attribute="Number"
            context="#stay"
            />
      </context>

      <!-- #lang -->
      <context
          name="reader_extension"
          attribute="ReaderExtension"
          lineEndContext="#pop"
          fallthroughContext="#pop"
          >
        <DetectSpaces/>
        <RegExpr
            String="&symbol;"
            attribute="Language"
            context="#pop"
            />
      </context>

      <!-- module, module+, module* -->
      <context
          name="module"
          attribute="Module"
          lineEndContext="#stay"
          fallthroughContext="#pop"
          >
        <DetectSpaces/>
        <RegExpr
            String="&symbol;"
            attribute="ModId"
            context="#pop!reader_extension"
            />
      </context>

      <!-- define and friends -->
      <context
          name="single_define"
          attribute="Keyword"
          lineEndContext="#stay"
          fallthroughContext="#pop"
          >
        <DetectSpaces/>
        <AnyChar
            lookAhead="true"
            String="([{"
            attribute="List"
            context="#pop!function"
            />
        <RegExpr
            String="&symbol;"
            attribute="Variable"
            context="#pop"
            />
      </context>
      <context
          name="function"
          attribute="Function"
          lineEndContext="#stay"
          fallthroughContext="#pop"
          >
        <DetectSpaces/>
        <AnyChar
            String="([{"
            attribute="List"
            context="#stay"
            />
        <RegExpr
            String="&symbol;"
            attribute="Function"
            context="#pop"
            />
      </context>

      <!-- define-values and friends -->
      <context
          name="multi_define"
          attribute="Keyword"
          lineEndContext="#stay"
          fallthroughContext="#pop"
          >
        <DetectSpaces/>
        <AnyChar
            String="([{"
            attribute="List"
            context="#pop!variables"
            />
      </context>
      <context
          name="variables"
          attribute="Variable"
          lineEndContext="#stay"
          fallthroughContext="#pop"
          >
        <DetectSpaces/>
        <RegExpr
            String="&symbol;"
            attribute="Variable"
            context="#stay"
            />
        <AnyChar
            String=")]}"
            attribute="List"
            context="#pop"
            />
      </context>
    </contexts>

    <itemDatas>
      <itemData
          name="BuiltIn"
          defStyleNum="dsBuiltIn"
          />
      <itemData
          name="Comment"
          defStyleNum="dsComment"
          />
      <itemData
          name="Sexpcomment"
          defStyleNum="dsComment"
          />
      <itemData
          name="Boolean"
          defStyleNum="dsConstant"
          />
      <itemData
          name="Number"
          defStyleNum="dsConstant"
          />
      <itemData
          name="Character"
          defStyleNum="dsConstant"
          />
      <itemData
          name="Type"
          defStyleNum="dsDataType"
          />
      <itemData
          name="Kwarg"
          defStyleNum="dsError"
          />
      <itemData
          name="Function"
          defStyleNum="dsFunction"
          />
      <itemData
          name="ModId"
          defStyleNum="dsFunction"
          />
      <itemData
          name="Keyword"
          defStyleNum="dsKeyword"
          />
      <itemData
          name="Module"
          defStyleNum="dsKeyword"
          />
      <itemData
          name="ReaderExtension"
          defStyleNum="dsKeyword"
          />
      <itemData
          name="Normal"
          defStyleNum="dsNormal"
          />
      <itemData
          name="CaseSensitivity"
          defStyleNum="dsNormal"
          />
      <itemData
          name="Quote"
          defStyleNum="dsNormal"
          />
      <itemData
          name="Quasiquote"
          defStyleNum="dsNormal"
          />
      <itemData
          name="Unquote"
          defStyleNum="dsNormal"
          />
      <itemData
          name="SyntaxQuote"
          defStyleNum="dsNormal"
          />
      <itemData
          name="SyntaxQuasiquote"
          defStyleNum="dsNormal"
          />
      <itemData
          name="SyntaxUnquote"
          defStyleNum="dsNormal"
          />
      <itemData
          name="CompiledCode"
          defStyleNum="dsNormal"
          />
      <itemData
          name="List"
          defStyleNum="dsNormal"
          />
      <itemData
          name="Structure"
          defStyleNum="dsNormal"
          />
      <itemData
          name="Box"
          defStyleNum="dsNormal"
          />
      <itemData
          name="HashTable"
          defStyleNum="dsNormal"
          />
      <itemData
          name="Vector"
          defStyleNum="dsNormal"
          />
      <itemData
          name="BindGraph"
          defStyleNum="dsNormal"
          />
      <itemData
          name="UseGraph"
          defStyleNum="dsNormal"
          />
      <itemData
          name="Symbol"
          defStyleNum="dsNormal"
          />
      <itemData
          name="Language"
          defStyleNum="dsPreprocessor"
          />
      <itemData
          name="Regexp"
          defStyleNum="dsString"
          />
      <itemData
          name="String"
          defStyleNum="dsString"
          />
      <itemData
          name="Bytestring"
          defStyleNum="dsString"
          />
      <itemData
          name="Variable"
          defStyleNum="dsVariable"
          />
    </itemDatas>
  </highlighting>
  <general>
        <keywords 
            casesensitive="true" 
            weakDeliminator="+-#%.=&lt;>*:/!?~"
            />
    <!-- Comments -->
    <comments>
      <comment name="singleLine" start=";"/>
      <comment name="singleLine" start="#! "/>
      <comment name="singleLine" start="#!/"/>
      <comment name="multiLine" start="#|" end="|#" region="comment"/>
    </comments>    
  </general>
</language>

<!-- https://stackoverflow.com/questions/1091945/what-characters-do-i-need-to-escape-in-xml-documents/46637835#46637835 -->
<!-- https://github.com/greghendershott/racket-mode/blob/master/racket-keywords-and-builtins.el -->