(declare (block) (standard-bindings) (extended-bindings))
(begin
  (define std/parser/rx-parser#simplify
    (lambda (_e2342_)
      (let* ((_e23432359_ _e2342_) (_else23462367_ (lambda () _e2342_)))
        (let ((_K23532393_ (lambda (_e2391_) _e2391_))
              (_K23482373_ (lambda (_e2371_) _e2371_)))
          (if (let () (declare (not safe)) (##pair? _e23432359_))
              (let ((_tl23552398_
                     (let () (declare (not safe)) (##cdr _e23432359_)))
                    (_hd23542396_
                     (let () (declare (not safe)) (##car _e23432359_))))
                (if (let () (declare (not safe)) (##eq? _hd23542396_ '@cat))
                    (if (let () (declare (not safe)) (##pair? _tl23552398_))
                        (let ((_tl23572403_
                               (let ()
                                 (declare (not safe))
                                 (##cdr _tl23552398_)))
                              (_hd23562401_
                               (let ()
                                 (declare (not safe))
                                 (##car _tl23552398_))))
                          (if (let ()
                                (declare (not safe))
                                (##null? _tl23572403_))
                              (let ((_e2406_ _hd23562401_))
                                (_K23532393_ _e2406_))
                              (_else23462367_)))
                        (_else23462367_))
                    (if (let ()
                          (declare (not safe))
                          (##eq? _hd23542396_ '@alt))
                        (if (let ()
                              (declare (not safe))
                              (##pair? _tl23552398_))
                            (let ((_tl23522383_
                                   (let ()
                                     (declare (not safe))
                                     (##cdr _tl23552398_)))
                                  (_hd23512381_
                                   (let ()
                                     (declare (not safe))
                                     (##car _tl23552398_))))
                              (if (let ()
                                    (declare (not safe))
                                    (##null? _tl23522383_))
                                  (let ((_e2386_ _hd23512381_))
                                    (_K23482373_ _e2386_))
                                  (_else23462367_)))
                            (_else23462367_))
                        (_else23462367_))))
              (_else23462367_))))))
  (define std/parser/rx-parser#current-rx-syntax-context (make-parameter '#f))
  (define std/parser/rx-parser#wrap-identifier-e
    (lambda (_lst2332_ _loc2333_)
      (let* ((_sym2335_ (string->symbol (list->string _lst2332_)))
             (_$e2337_ (std/parser/rx-parser#current-rx-syntax-context)))
        (if _$e2337_
            ((lambda (_stx2340_)
               (gx#datum->syntax
                _stx2340_
                _sym2335_
                (std/parser/base#location->source-location _loc2333_)))
             _$e2337_)
            _sym2335_))))
  (define std/parser/rx-parser#parse-rx__%
    (lambda (_input2308_ _$lexer2310_ _wrap-e2312_)
      (std/parser/defparser#parser-parse
       'parse-rx
       (std/parser/defparser#parser-input-stream _input2308_ _$lexer2310_)
       std/parser/rx-parser#RX
       _wrap-e2312_)))
  (define std/parser/rx-parser#parse-rx__0
    (lambda (_input2317_)
      (let* ((_$lexer2319_ std/parser/lexer#lex-chars)
             (_wrap-e2321_ std/parser/base#wrap-ast))
        (std/parser/rx-parser#parse-rx__%
         _input2317_
         _$lexer2319_
         _wrap-e2321_))))
  (define std/parser/rx-parser#parse-rx__1
    (lambda (_input2323_ _$lexer2324_)
      (let ((_wrap-e2326_ std/parser/base#wrap-ast))
        (std/parser/rx-parser#parse-rx__%
         _input2323_
         _$lexer2324_
         _wrap-e2326_))))
  (define std/parser/rx-parser#parse-rx
    (lambda _g6241_
      (let ((_g6240_ (let () (declare (not safe)) (##length _g6241_))))
        (cond ((let () (declare (not safe)) (##fx= _g6240_ 1))
               (apply std/parser/rx-parser#parse-rx__0 _g6241_))
              ((let () (declare (not safe)) (##fx= _g6240_ 2))
               (apply std/parser/rx-parser#parse-rx__1 _g6241_))
              ((let () (declare (not safe)) (##fx= _g6240_ 3))
               (apply std/parser/rx-parser#parse-rx__% _g6241_))
              (else
               (##raise-wrong-number-of-arguments-exception
                std/parser/rx-parser#parse-rx
                _g6241_))))))
  (define std/parser/rx-parser#RX::app::cat::1::rep*
    (lambda (_ts2301_ _toks2302_ _wrap-e2303_ _K2304_ _E2305_)
      (std/parser/rx-parser#L
       _ts2301_
       _toks2302_
       _wrap-e2303_
       _K2304_
       _E2305_)))
  (define std/parser/rx-parser#RX::app::cat::1
    (lambda (_ts2283_ _toks2284_ _wrap-e2285_ _K2286_ _E2287_)
      (let _lp2289_ ((_toks2291_ _toks2284_) (_$14012292_ '()))
        (std/parser/rx-parser#L
         _ts2283_
         _toks2291_
         _wrap-e2285_
         (lambda (_toks2295_ _g4022296_)
           (_lp2289_ _toks2295_ (cons _g4022296_ _$14012292_)))
         (lambda (_xtoks2299_)
           (std/parser/defparser#parser-rewind _ts2283_ _xtoks2299_ _toks2291_)
           (_K2286_ _toks2291_ (reverse _$14012292_)))))))
  (define std/parser/rx-parser#RX::app::cat::2
    (lambda (_ts2272_ _toks2273_ _wrap-e2274_ _K2275_ _E2276_)
      (let* ((_next2278_ (std/parser/lexer#token-stream-next _ts2272_))
             (_toks2280_ (cons _next2278_ _toks2273_)))
        (if (std/parser/lexer#$$? _next2278_)
            (_K2275_ _toks2280_ _next2278_)
            (_E2276_ _toks2280_)))))
  (define std/parser/rx-parser#RX::app
    (lambda (_ts2260_ _toks2261_ _wrap-e2262_ _K2263_ _E2264_)
      (std/parser/rx-parser#RX::app::cat::1
       _ts2260_
       _toks2261_
       _wrap-e2262_
       (lambda (_toks2266_ _g4032267_)
         (std/parser/rx-parser#RX::app::cat::2
          _ts2260_
          _toks2266_
          _wrap-e2262_
          (lambda (_toks2270_ _g6242_) (_K2263_ _toks2270_ _g4032267_))
          _E2264_))
       _E2264_)))
  (define std/parser/rx-parser#RX
    (lambda (_ts2239_ _toks2240_ _wrap-e2241_ _K2242_ _E2243_)
      (let ((_start2245_ (std/parser/lexer#token-stream-loc _ts2239_)))
        (std/parser/rx-parser#RX::app
         _ts2239_
         _toks2240_
         _wrap-e2241_
         (lambda (_toks2247_ _$14042248_)
           (let* ((_end2251_ (std/parser/lexer#token-stream-loc _ts2239_))
                  (_@loc2253_
                   (std/parser/base#location-delta* _start2245_ _end2251_)))
             (_K2242_ _toks2247_
                      (let ((__tmp6243
                             (_wrap-e2241_
                              ((lambda (_$12256_)
                                 (std/parser/rx-parser#simplify
                                  (cons '@cat _$12256_)))
                               ((lambda (_$x2258_)
                                  (map std/parser/base#token-e _$x2258_))
                                _$14042248_))
                              _@loc2253_)))
                        (declare (not safe))
                        (##structure
                         std/parser/base#token::t
                         'RX
                         __tmp6243
                         _@loc2253_)))))
         _E2243_))))
  (define std/parser/rx-parser#L::1::app::cat::1
    (lambda (_ts2233_ _toks2234_ _wrap-e2235_ _K2236_ _E2237_)
      (std/parser/rx-parser#L1
       _ts2233_
       _toks2234_
       _wrap-e2235_
       _K2236_
       _E2237_)))
  (define std/parser/rx-parser#L::1::app::cat::2
    (lambda (_ts2222_ _toks2223_ _wrap-e2224_ _K2225_ _E2226_)
      (let* ((_next2228_ (std/parser/lexer#token-stream-next _ts2222_))
             (_toks2230_ (cons _next2228_ _toks2223_)))
        (if (eq? (##direct-structure-ref
                  _next2228_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\*)
            (_K2225_ _toks2230_ _next2228_)
            (_E2226_ _toks2230_)))))
  (define std/parser/rx-parser#L::1::app
    (lambda (_ts2210_ _toks2211_ _wrap-e2212_ _K2213_ _E2214_)
      (std/parser/rx-parser#L1
       _ts2210_
       _toks2211_
       _wrap-e2212_
       (lambda (_toks2216_ _$14052217_)
         (std/parser/rx-parser#L::1::app::cat::2
          _ts2210_
          _toks2216_
          _wrap-e2212_
          (lambda (_toks2220_ _g6244_) (_K2213_ _toks2220_ _$14052217_))
          _E2214_))
       _E2214_)))
  (define std/parser/rx-parser#L::1
    (lambda (_ts2191_ _toks2192_ _wrap-e2193_ _K2194_ _E2195_)
      (let ((_start2197_ (std/parser/lexer#token-stream-loc _ts2191_)))
        (std/parser/rx-parser#L::1::app
         _ts2191_
         _toks2192_
         _wrap-e2193_
         (lambda (_toks2199_ _$14062200_)
           (let* ((_end2203_ (std/parser/lexer#token-stream-loc _ts2191_))
                  (_@loc2205_
                   (std/parser/base#location-delta* _start2197_ _end2203_)))
             (_K2194_ _toks2199_
                      (let ((__tmp6245
                             (_wrap-e2193_
                              ((lambda (_$12208_)
                                 (cons '@rep* (cons _$12208_ '())))
                               (##direct-structure-ref
                                _$14062200_
                                '2
                                std/parser/base#token::t
                                '#f))
                              _@loc2205_)))
                        (declare (not safe))
                        (##structure
                         std/parser/base#token::t
                         'L
                         __tmp6245
                         _@loc2205_)))))
         _E2195_))))
  (define std/parser/rx-parser#L::2::app::cat::1
    (lambda (_ts2185_ _toks2186_ _wrap-e2187_ _K2188_ _E2189_)
      (std/parser/rx-parser#L1
       _ts2185_
       _toks2186_
       _wrap-e2187_
       _K2188_
       _E2189_)))
  (define std/parser/rx-parser#L::2::app::cat::2
    (lambda (_ts2174_ _toks2175_ _wrap-e2176_ _K2177_ _E2178_)
      (let* ((_next2180_ (std/parser/lexer#token-stream-next _ts2174_))
             (_toks2182_ (cons _next2180_ _toks2175_)))
        (if (eq? (##direct-structure-ref
                  _next2180_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\+)
            (_K2177_ _toks2182_ _next2180_)
            (_E2178_ _toks2182_)))))
  (define std/parser/rx-parser#L::2::app
    (lambda (_ts2162_ _toks2163_ _wrap-e2164_ _K2165_ _E2166_)
      (std/parser/rx-parser#L1
       _ts2162_
       _toks2163_
       _wrap-e2164_
       (lambda (_toks2168_ _$14072169_)
         (std/parser/rx-parser#L::2::app::cat::2
          _ts2162_
          _toks2168_
          _wrap-e2164_
          (lambda (_toks2172_ _g6246_) (_K2165_ _toks2172_ _$14072169_))
          _E2166_))
       _E2166_)))
  (define std/parser/rx-parser#L::2
    (lambda (_ts2143_ _toks2144_ _wrap-e2145_ _K2146_ _E2147_)
      (let ((_start2149_ (std/parser/lexer#token-stream-loc _ts2143_)))
        (std/parser/rx-parser#L::2::app
         _ts2143_
         _toks2144_
         _wrap-e2145_
         (lambda (_toks2151_ _$14082152_)
           (let* ((_end2155_ (std/parser/lexer#token-stream-loc _ts2143_))
                  (_@loc2157_
                   (std/parser/base#location-delta* _start2149_ _end2155_)))
             (_K2146_ _toks2151_
                      (let ((__tmp6247
                             (_wrap-e2145_
                              ((lambda (_$12160_)
                                 (cons '@rep+ (cons _$12160_ '())))
                               (##direct-structure-ref
                                _$14082152_
                                '2
                                std/parser/base#token::t
                                '#f))
                              _@loc2157_)))
                        (declare (not safe))
                        (##structure
                         std/parser/base#token::t
                         'L
                         __tmp6247
                         _@loc2157_)))))
         _E2147_))))
  (define std/parser/rx-parser#L::3::app::cat::1
    (lambda (_ts2137_ _toks2138_ _wrap-e2139_ _K2140_ _E2141_)
      (std/parser/rx-parser#L1
       _ts2137_
       _toks2138_
       _wrap-e2139_
       _K2140_
       _E2141_)))
  (define std/parser/rx-parser#L::3::app::cat::2
    (lambda (_ts2126_ _toks2127_ _wrap-e2128_ _K2129_ _E2130_)
      (let* ((_next2132_ (std/parser/lexer#token-stream-next _ts2126_))
             (_toks2134_ (cons _next2132_ _toks2127_)))
        (if (eq? (##direct-structure-ref
                  _next2132_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\?)
            (_K2129_ _toks2134_ _next2132_)
            (_E2130_ _toks2134_)))))
  (define std/parser/rx-parser#L::3::app
    (lambda (_ts2114_ _toks2115_ _wrap-e2116_ _K2117_ _E2118_)
      (std/parser/rx-parser#L1
       _ts2114_
       _toks2115_
       _wrap-e2116_
       (lambda (_toks2120_ _$14092121_)
         (std/parser/rx-parser#L::3::app::cat::2
          _ts2114_
          _toks2120_
          _wrap-e2116_
          (lambda (_toks2124_ _g6248_) (_K2117_ _toks2124_ _$14092121_))
          _E2118_))
       _E2118_)))
  (define std/parser/rx-parser#L::3
    (lambda (_ts2095_ _toks2096_ _wrap-e2097_ _K2098_ _E2099_)
      (let ((_start2101_ (std/parser/lexer#token-stream-loc _ts2095_)))
        (std/parser/rx-parser#L::3::app
         _ts2095_
         _toks2096_
         _wrap-e2097_
         (lambda (_toks2103_ _$14102104_)
           (let* ((_end2107_ (std/parser/lexer#token-stream-loc _ts2095_))
                  (_@loc2109_
                   (std/parser/base#location-delta* _start2101_ _end2107_)))
             (_K2098_ _toks2103_
                      (let ((__tmp6249
                             (_wrap-e2097_
                              ((lambda (_$12112_)
                                 (cons '@maybe (cons _$12112_ '())))
                               (##direct-structure-ref
                                _$14102104_
                                '2
                                std/parser/base#token::t
                                '#f))
                              _@loc2109_)))
                        (declare (not safe))
                        (##structure
                         std/parser/base#token::t
                         'L
                         __tmp6249
                         _@loc2109_)))))
         _E2099_))))
  (define std/parser/rx-parser#L::4::app::cat::1
    (lambda (_ts2089_ _toks2090_ _wrap-e2091_ _K2092_ _E2093_)
      (std/parser/rx-parser#L1
       _ts2089_
       _toks2090_
       _wrap-e2091_
       _K2092_
       _E2093_)))
  (define std/parser/rx-parser#L::4::app::cat::2::rep*
    (lambda (_ts2083_ _toks2084_ _wrap-e2085_ _K2086_ _E2087_)
      (std/parser/rx-parser#L1+
       _ts2083_
       _toks2084_
       _wrap-e2085_
       _K2086_
       _E2087_)))
  (define std/parser/rx-parser#L::4::app::cat::2
    (lambda (_ts2065_ _toks2066_ _wrap-e2067_ _K2068_ _E2069_)
      (let _lp2071_ ((_toks2073_ _toks2066_) (_$24112074_ '()))
        (std/parser/rx-parser#L1+
         _ts2065_
         _toks2073_
         _wrap-e2067_
         (lambda (_toks2077_ _g4122078_)
           (_lp2071_ _toks2077_ (cons _g4122078_ _$24112074_)))
         (lambda (_xtoks2081_)
           (std/parser/defparser#parser-rewind _ts2065_ _xtoks2081_ _toks2073_)
           (_K2068_ _toks2073_ (reverse _$24112074_)))))))
  (define std/parser/rx-parser#L::4::app
    (lambda (_ts2051_ _toks2052_ _wrap-e2053_ _K2054_ _E2055_)
      (std/parser/rx-parser#L1
       _ts2051_
       _toks2052_
       _wrap-e2053_
       (lambda (_toks2057_ _$14132058_)
         (std/parser/rx-parser#L::4::app::cat::2
          _ts2051_
          _toks2057_
          _wrap-e2053_
          (lambda (_toks2061_ _g4142062_)
            (_K2054_ _toks2061_ _$14132058_ _g4142062_))
          _E2055_))
       _E2055_)))
  (define std/parser/rx-parser#L::4
    (lambda (_ts2027_ _toks2028_ _wrap-e2029_ _K2030_ _E2031_)
      (let ((_start2033_ (std/parser/lexer#token-stream-loc _ts2027_)))
        (std/parser/rx-parser#L::4::app
         _ts2027_
         _toks2028_
         _wrap-e2029_
         (lambda (_toks2035_ _$14152036_ _$24162038_)
           (let* ((_end2041_ (std/parser/lexer#token-stream-loc _ts2027_))
                  (_@loc2043_
                   (std/parser/base#location-delta* _start2033_ _end2041_)))
             (_K2030_ _toks2035_
                      (let ((__tmp6250
                             (_wrap-e2029_
                              ((lambda (_$12046_ _$22047_)
                                 (std/parser/rx-parser#simplify
                                  (cons '@cat (cons _$12046_ _$22047_))))
                               (##direct-structure-ref
                                _$14152036_
                                '2
                                std/parser/base#token::t
                                '#f)
                               ((lambda (_$x2049_)
                                  (map std/parser/base#token-e _$x2049_))
                                _$24162038_))
                              _@loc2043_)))
                        (declare (not safe))
                        (##structure
                         std/parser/base#token::t
                         'L
                         __tmp6250
                         _@loc2043_)))))
         _E2031_))))
  (define std/parser/rx-parser#L
    (lambda (_ts2015_ _toks2016_ _wrap-e2017_ _K2018_ _E2019_)
      (std/parser/rx-parser#L::1
       _ts2015_
       _toks2016_
       _wrap-e2017_
       _K2018_
       (lambda (_xtoks2021_)
         (std/parser/defparser#parser-rewind _ts2015_ _xtoks2021_ _toks2016_)
         (std/parser/rx-parser#L::2
          _ts2015_
          _toks2016_
          _wrap-e2017_
          _K2018_
          (lambda (_xtoks2023_)
            (std/parser/defparser#parser-rewind
             _ts2015_
             _xtoks2023_
             _toks2016_)
            (std/parser/rx-parser#L::3
             _ts2015_
             _toks2016_
             _wrap-e2017_
             _K2018_
             (lambda (_xtoks2025_)
               (std/parser/defparser#parser-rewind
                _ts2015_
                _xtoks2025_
                _toks2016_)
               (std/parser/rx-parser#L::4
                _ts2015_
                _toks2016_
                _wrap-e2017_
                _K2018_
                _E2019_)))))))))
  (define std/parser/rx-parser#L1+::1::app::cat::1
    (lambda (_ts2009_ _toks2010_ _wrap-e2011_ _K2012_ _E2013_)
      (std/parser/rx-parser#L1
       _ts2009_
       _toks2010_
       _wrap-e2011_
       _K2012_
       _E2013_)))
  (define std/parser/rx-parser#L1+::1::app::cat::2
    (lambda (_ts2003_ _toks2004_ _wrap-e2005_ _K2006_ _E2007_)
      (std/parser/rx-parser#SuffixOpChar
       _ts2003_
       _toks2004_
       _wrap-e2005_
       _K2006_
       _E2007_)))
  (define std/parser/rx-parser#L1+::1::app
    (lambda (_ts1993_ _toks1994_ _wrap-e1995_ _K1996_ _E1997_)
      (std/parser/rx-parser#L1
       _ts1993_
       _toks1994_
       _wrap-e1995_
       (lambda (_toks1999_ _g6251_)
         (std/parser/rx-parser#SuffixOpChar
          _ts1993_
          _toks1999_
          _wrap-e1995_
          (lambda (_toks2001_ _g6252_) (_K1996_ _toks2001_ std/parser/lexer#$))
          _E1997_))
       _E1997_)))
  (define std/parser/rx-parser#L1+::1
    (lambda (_ts1985_ _toks1986_ _wrap-e1987_ _K1988_ _E1989_)
      (std/parser/rx-parser#L1+::1::app
       _ts1985_
       _toks1986_
       _wrap-e1987_
       (lambda (_toks1991_ . _g6253_) (_K1988_ _toks1991_))
       _E1989_)))
  (define std/parser/rx-parser#L1+::2::app
    (lambda (_ts1979_ _toks1980_ _wrap-e1981_ _K1982_ _E1983_)
      (std/parser/rx-parser#L1
       _ts1979_
       _toks1980_
       _wrap-e1981_
       _K1982_
       _E1983_)))
  (define std/parser/rx-parser#L1+::2
    (lambda (_ts1970_ _toks1971_ _wrap-e1972_ _K1973_ _E1974_)
      (std/parser/rx-parser#L1
       _ts1970_
       _toks1971_
       _wrap-e1972_
       (lambda (_toks1976_ _rtok1977_)
         (_K1973_ _toks1976_
                  (let ((__tmp6255
                         (##direct-structure-ref
                          _rtok1977_
                          '2
                          std/parser/base#token::t
                          '#f))
                        (__tmp6254
                         (##direct-structure-ref
                          _rtok1977_
                          '3
                          std/parser/base#token::t
                          '#f)))
                    (declare (not safe))
                    (##structure
                     std/parser/base#token::t
                     'L1+
                     __tmp6255
                     __tmp6254))))
       _E1974_)))
  (define std/parser/rx-parser#L1+
    (lambda (_ts1962_ _toks1963_ _wrap-e1964_ _K1965_ _E1966_)
      (std/parser/rx-parser#L1+::1
       _ts1962_
       _toks1963_
       _wrap-e1964_
       _E1966_
       (lambda (_xtoks1968_)
         (std/parser/defparser#parser-rewind _ts1962_ _xtoks1968_ _toks1963_)
         (std/parser/rx-parser#L1+::2
          _ts1962_
          _toks1963_
          _wrap-e1964_
          _K1965_
          _E1966_)))))
  (define std/parser/rx-parser#L1::1::app::cat::1
    (lambda (_ts1951_ _toks1952_ _wrap-e1953_ _K1954_ _E1955_)
      (let* ((_next1957_ (std/parser/lexer#token-stream-next _ts1951_))
             (_toks1959_ (cons _next1957_ _toks1952_)))
        (if (eq? (##direct-structure-ref
                  _next1957_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\()
            (_K1954_ _toks1959_ _next1957_)
            (_E1955_ _toks1959_)))))
  (define std/parser/rx-parser#L1::1::app::cat::2
    (lambda (_ts1945_ _toks1946_ _wrap-e1947_ _K1948_ _E1949_)
      (std/parser/rx-parser#L
       _ts1945_
       _toks1946_
       _wrap-e1947_
       _K1948_
       _E1949_)))
  (define std/parser/rx-parser#L1::1::app::cat::3::rep*::cat::1
    (lambda (_ts1934_ _toks1935_ _wrap-e1936_ _K1937_ _E1938_)
      (let* ((_next1940_ (std/parser/lexer#token-stream-next _ts1934_))
             (_toks1942_ (cons _next1940_ _toks1935_)))
        (if (eq? (##direct-structure-ref
                  _next1940_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\|)
            (_K1937_ _toks1942_ _next1940_)
            (_E1938_ _toks1942_)))))
  (define std/parser/rx-parser#L1::1::app::cat::3::rep*::cat::2
    (lambda (_ts1928_ _toks1929_ _wrap-e1930_ _K1931_ _E1932_)
      (std/parser/rx-parser#L
       _ts1928_
       _toks1929_
       _wrap-e1930_
       _K1931_
       _E1932_)))
  (define std/parser/rx-parser#L1::1::app::cat::3::rep*
    (lambda (_ts1916_ _toks1917_ _wrap-e1918_ _K1919_ _E1920_)
      (std/parser/rx-parser#L1::1::app::cat::3::rep*::cat::1
       _ts1916_
       _toks1917_
       _wrap-e1918_
       (lambda (_toks1922_ _g6256_)
         (std/parser/rx-parser#L
          _ts1916_
          _toks1922_
          _wrap-e1918_
          (lambda (_toks1924_ _$24171925_) (_K1919_ _toks1924_ _$24171925_))
          _E1920_))
       _E1920_)))
  (define std/parser/rx-parser#L1::1::app::cat::3
    (lambda (_ts1898_ _toks1899_ _wrap-e1900_ _K1901_ _E1902_)
      (let _lp1904_ ((_toks1906_ _toks1899_) (_$24181907_ '()))
        (std/parser/rx-parser#L1::1::app::cat::3::rep*
         _ts1898_
         _toks1906_
         _wrap-e1900_
         (lambda (_toks1910_ _g4191911_)
           (_lp1904_ _toks1910_ (cons _g4191911_ _$24181907_)))
         (lambda (_xtoks1914_)
           (std/parser/defparser#parser-rewind _ts1898_ _xtoks1914_ _toks1906_)
           (_K1901_ _toks1906_ (reverse _$24181907_)))))))
  (define std/parser/rx-parser#L1::1::app::cat::4
    (lambda (_ts1887_ _toks1888_ _wrap-e1889_ _K1890_ _E1891_)
      (let* ((_next1893_ (std/parser/lexer#token-stream-next _ts1887_))
             (_toks1895_ (cons _next1893_ _toks1888_)))
        (if (eq? (##direct-structure-ref
                  _next1893_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\))
            (_K1890_ _toks1895_ _next1893_)
            (_E1891_ _toks1895_)))))
  (define std/parser/rx-parser#L1::1::app
    (lambda (_ts1869_ _toks1870_ _wrap-e1871_ _K1872_ _E1873_)
      (std/parser/rx-parser#L1::1::app::cat::1
       _ts1869_
       _toks1870_
       _wrap-e1871_
       (lambda (_toks1875_ _g6257_)
         (std/parser/rx-parser#L
          _ts1869_
          _toks1875_
          _wrap-e1871_
          (lambda (_toks1877_ _$14201878_)
            (std/parser/rx-parser#L1::1::app::cat::3
             _ts1869_
             _toks1877_
             _wrap-e1871_
             (lambda (_toks1881_ _g4211882_)
               (std/parser/rx-parser#L1::1::app::cat::4
                _ts1869_
                _toks1881_
                _wrap-e1871_
                (lambda (_toks1885_ _g6258_)
                  (_K1872_ _toks1885_ _$14201878_ _g4211882_))
                _E1873_))
             _E1873_))
          _E1873_))
       _E1873_)))
  (define std/parser/rx-parser#L1::1
    (lambda (_ts1845_ _toks1846_ _wrap-e1847_ _K1848_ _E1849_)
      (let ((_start1851_ (std/parser/lexer#token-stream-loc _ts1845_)))
        (std/parser/rx-parser#L1::1::app
         _ts1845_
         _toks1846_
         _wrap-e1847_
         (lambda (_toks1853_ _$14221854_ _$24231856_)
           (let* ((_end1859_ (std/parser/lexer#token-stream-loc _ts1845_))
                  (_@loc1861_
                   (std/parser/base#location-delta* _start1851_ _end1859_)))
             (_K1848_ _toks1853_
                      (let ((__tmp6259
                             (_wrap-e1847_
                              ((lambda (_$11864_ _$21865_)
                                 (std/parser/rx-parser#simplify
                                  (cons '@alt (cons _$11864_ _$21865_))))
                               (##direct-structure-ref
                                _$14221854_
                                '2
                                std/parser/base#token::t
                                '#f)
                               ((lambda (_$x1867_)
                                  (map std/parser/base#token-e _$x1867_))
                                _$24231856_))
                              _@loc1861_)))
                        (declare (not safe))
                        (##structure
                         std/parser/base#token::t
                         'L1
                         __tmp6259
                         _@loc1861_)))))
         _E1849_))))
  (define std/parser/rx-parser#L1::2::app::cat::1
    (lambda (_ts1834_ _toks1835_ _wrap-e1836_ _K1837_ _E1838_)
      (let* ((_next1840_ (std/parser/lexer#token-stream-next _ts1834_))
             (_toks1842_ (cons _next1840_ _toks1835_)))
        (if (eq? (##direct-structure-ref
                  _next1840_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\{)
            (_K1837_ _toks1842_ _next1840_)
            (_E1838_ _toks1842_)))))
  (define std/parser/rx-parser#L1::2::app::cat::2::rep*
    (lambda (_ts1828_ _toks1829_ _wrap-e1830_ _K1831_ _E1832_)
      (std/parser/rx-parser#IdentifierChar
       _ts1828_
       _toks1829_
       _wrap-e1830_
       _K1831_
       _E1832_)))
  (define std/parser/rx-parser#L1::2::app::cat::2
    (lambda (_ts1807_ _toks1808_ _wrap-e1809_ _K1810_ _E1811_)
      (std/parser/rx-parser#IdentifierChar
       _ts1807_
       _toks1808_
       _wrap-e1809_
       (lambda (_toks1813_ _g4251814_)
         (let _lp1817_ ((_toks1819_ _toks1813_)
                        (_$14241820_ (cons _g4251814_ '())))
           (std/parser/rx-parser#IdentifierChar
            _ts1807_
            _toks1819_
            _wrap-e1809_
            (lambda (_toks1823_ _g4251824_)
              (_lp1817_ _toks1823_ (cons _g4251824_ _$14241820_)))
            (lambda (_xtoks1826_)
              (std/parser/defparser#parser-rewind
               _ts1807_
               _xtoks1826_
               _toks1819_)
              (_K1810_ _toks1819_ (reverse _$14241820_))))))
       _E1811_)))
  (define std/parser/rx-parser#L1::2::app::cat::3
    (lambda (_ts1796_ _toks1797_ _wrap-e1798_ _K1799_ _E1800_)
      (let* ((_next1802_ (std/parser/lexer#token-stream-next _ts1796_))
             (_toks1804_ (cons _next1802_ _toks1797_)))
        (if (eq? (##direct-structure-ref
                  _next1802_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\})
            (_K1799_ _toks1804_ _next1802_)
            (_E1800_ _toks1804_)))))
  (define std/parser/rx-parser#L1::2::app
    (lambda (_ts1782_ _toks1783_ _wrap-e1784_ _K1785_ _E1786_)
      (std/parser/rx-parser#L1::2::app::cat::1
       _ts1782_
       _toks1783_
       _wrap-e1784_
       (lambda (_toks1788_ _g6260_)
         (std/parser/rx-parser#L1::2::app::cat::2
          _ts1782_
          _toks1788_
          _wrap-e1784_
          (lambda (_toks1790_ _g4261791_)
            (std/parser/rx-parser#L1::2::app::cat::3
             _ts1782_
             _toks1790_
             _wrap-e1784_
             (lambda (_toks1794_ _g6261_) (_K1785_ _toks1794_ _g4261791_))
             _E1786_))
          _E1786_))
       _E1786_)))
  (define std/parser/rx-parser#L1::2
    (lambda (_ts1761_ _toks1762_ _wrap-e1763_ _K1764_ _E1765_)
      (let ((_start1767_ (std/parser/lexer#token-stream-loc _ts1761_)))
        (std/parser/rx-parser#L1::2::app
         _ts1761_
         _toks1762_
         _wrap-e1763_
         (lambda (_toks1769_ _$14271770_)
           (let* ((_end1773_ (std/parser/lexer#token-stream-loc _ts1761_))
                  (_@loc1775_
                   (std/parser/base#location-delta* _start1767_ _end1773_)))
             (_K1764_ _toks1769_
                      (let ((__tmp6262
                             (_wrap-e1763_
                              ((lambda (_$11778_)
                                 (std/parser/rx-parser#wrap-identifier-e
                                  _$11778_
                                  _@loc1775_))
                               ((lambda (_$x1780_)
                                  (map std/parser/base#token-e _$x1780_))
                                _$14271770_))
                              _@loc1775_)))
                        (declare (not safe))
                        (##structure
                         std/parser/base#token::t
                         'L1
                         __tmp6262
                         _@loc1775_)))))
         _E1765_))))
  (define std/parser/rx-parser#L1::3::app::cat::1
    (lambda (_ts1755_ _toks1756_ _wrap-e1757_ _K1758_ _E1759_)
      (std/parser/rx-parser#L2
       _ts1755_
       _toks1756_
       _wrap-e1757_
       _K1758_
       _E1759_)))
  (define std/parser/rx-parser#L1::3::app::cat::2::rep*
    (lambda (_ts1749_ _toks1750_ _wrap-e1751_ _K1752_ _E1753_)
      (std/parser/rx-parser#L2+
       _ts1749_
       _toks1750_
       _wrap-e1751_
       _K1752_
       _E1753_)))
  (define std/parser/rx-parser#L1::3::app::cat::2
    (lambda (_ts1731_ _toks1732_ _wrap-e1733_ _K1734_ _E1735_)
      (let _lp1737_ ((_toks1739_ _toks1732_) (_$24281740_ '()))
        (std/parser/rx-parser#L2+
         _ts1731_
         _toks1739_
         _wrap-e1733_
         (lambda (_toks1743_ _g4291744_)
           (_lp1737_ _toks1743_ (cons _g4291744_ _$24281740_)))
         (lambda (_xtoks1747_)
           (std/parser/defparser#parser-rewind _ts1731_ _xtoks1747_ _toks1739_)
           (_K1734_ _toks1739_ (reverse _$24281740_)))))))
  (define std/parser/rx-parser#L1::3::app
    (lambda (_ts1717_ _toks1718_ _wrap-e1719_ _K1720_ _E1721_)
      (std/parser/rx-parser#L2
       _ts1717_
       _toks1718_
       _wrap-e1719_
       (lambda (_toks1723_ _$14301724_)
         (std/parser/rx-parser#L1::3::app::cat::2
          _ts1717_
          _toks1723_
          _wrap-e1719_
          (lambda (_toks1727_ _g4311728_)
            (_K1720_ _toks1727_ _$14301724_ _g4311728_))
          _E1721_))
       _E1721_)))
  (define std/parser/rx-parser#L1::3
    (lambda (_ts1693_ _toks1694_ _wrap-e1695_ _K1696_ _E1697_)
      (let ((_start1699_ (std/parser/lexer#token-stream-loc _ts1693_)))
        (std/parser/rx-parser#L1::3::app
         _ts1693_
         _toks1694_
         _wrap-e1695_
         (lambda (_toks1701_ _$14321702_ _$24331704_)
           (let* ((_end1707_ (std/parser/lexer#token-stream-loc _ts1693_))
                  (_@loc1709_
                   (std/parser/base#location-delta* _start1699_ _end1707_)))
             (_K1696_ _toks1701_
                      (let ((__tmp6263
                             (_wrap-e1695_
                              ((lambda (_$11712_ _$21713_)
                                 (std/parser/rx-parser#simplify
                                  (cons '@cat (cons _$11712_ _$21713_))))
                               (##direct-structure-ref
                                _$14321702_
                                '2
                                std/parser/base#token::t
                                '#f)
                               ((lambda (_$x1715_)
                                  (map std/parser/base#token-e _$x1715_))
                                _$24331704_))
                              _@loc1709_)))
                        (declare (not safe))
                        (##structure
                         std/parser/base#token::t
                         'L1
                         __tmp6263
                         _@loc1709_)))))
         _E1697_))))
  (define std/parser/rx-parser#L1
    (lambda (_ts1683_ _toks1684_ _wrap-e1685_ _K1686_ _E1687_)
      (std/parser/rx-parser#L1::1
       _ts1683_
       _toks1684_
       _wrap-e1685_
       _K1686_
       (lambda (_xtoks1689_)
         (std/parser/defparser#parser-rewind _ts1683_ _xtoks1689_ _toks1684_)
         (std/parser/rx-parser#L1::2
          _ts1683_
          _toks1684_
          _wrap-e1685_
          _K1686_
          (lambda (_xtoks1691_)
            (std/parser/defparser#parser-rewind
             _ts1683_
             _xtoks1691_
             _toks1684_)
            (std/parser/rx-parser#L1::3
             _ts1683_
             _toks1684_
             _wrap-e1685_
             _K1686_
             _E1687_)))))))
  (define std/parser/rx-parser#L2+::1::app::cat::1
    (lambda (_ts1677_ _toks1678_ _wrap-e1679_ _K1680_ _E1681_)
      (std/parser/rx-parser#L2
       _ts1677_
       _toks1678_
       _wrap-e1679_
       _K1680_
       _E1681_)))
  (define std/parser/rx-parser#L2+::1::app::cat::2
    (lambda (_ts1671_ _toks1672_ _wrap-e1673_ _K1674_ _E1675_)
      (std/parser/rx-parser#SuffixOpChar
       _ts1671_
       _toks1672_
       _wrap-e1673_
       _K1674_
       _E1675_)))
  (define std/parser/rx-parser#L2+::1::app
    (lambda (_ts1661_ _toks1662_ _wrap-e1663_ _K1664_ _E1665_)
      (std/parser/rx-parser#L2
       _ts1661_
       _toks1662_
       _wrap-e1663_
       (lambda (_toks1667_ _g6264_)
         (std/parser/rx-parser#SuffixOpChar
          _ts1661_
          _toks1667_
          _wrap-e1663_
          (lambda (_toks1669_ _g6265_) (_K1664_ _toks1669_ std/parser/lexer#$))
          _E1665_))
       _E1665_)))
  (define std/parser/rx-parser#L2+::1
    (lambda (_ts1653_ _toks1654_ _wrap-e1655_ _K1656_ _E1657_)
      (std/parser/rx-parser#L2+::1::app
       _ts1653_
       _toks1654_
       _wrap-e1655_
       (lambda (_toks1659_ . _g6266_) (_K1656_ _toks1659_))
       _E1657_)))
  (define std/parser/rx-parser#L2+::2::app
    (lambda (_ts1647_ _toks1648_ _wrap-e1649_ _K1650_ _E1651_)
      (std/parser/rx-parser#L2
       _ts1647_
       _toks1648_
       _wrap-e1649_
       _K1650_
       _E1651_)))
  (define std/parser/rx-parser#L2+::2
    (lambda (_ts1638_ _toks1639_ _wrap-e1640_ _K1641_ _E1642_)
      (std/parser/rx-parser#L2
       _ts1638_
       _toks1639_
       _wrap-e1640_
       (lambda (_toks1644_ _rtok1645_)
         (_K1641_ _toks1644_
                  (let ((__tmp6268
                         (##direct-structure-ref
                          _rtok1645_
                          '2
                          std/parser/base#token::t
                          '#f))
                        (__tmp6267
                         (##direct-structure-ref
                          _rtok1645_
                          '3
                          std/parser/base#token::t
                          '#f)))
                    (declare (not safe))
                    (##structure
                     std/parser/base#token::t
                     'L2+
                     __tmp6268
                     __tmp6267))))
       _E1642_)))
  (define std/parser/rx-parser#L2+
    (lambda (_ts1630_ _toks1631_ _wrap-e1632_ _K1633_ _E1634_)
      (std/parser/rx-parser#L2+::1
       _ts1630_
       _toks1631_
       _wrap-e1632_
       _E1634_
       (lambda (_xtoks1636_)
         (std/parser/defparser#parser-rewind _ts1630_ _xtoks1636_ _toks1631_)
         (std/parser/rx-parser#L2+::2
          _ts1630_
          _toks1631_
          _wrap-e1632_
          _K1633_
          _E1634_)))))
  (define std/parser/rx-parser#L2::1::app
    (lambda (_ts1624_ _toks1625_ _wrap-e1626_ _K1627_ _E1628_)
      (std/parser/rx-parser#EscapedChar
       _ts1624_
       _toks1625_
       _wrap-e1626_
       _K1627_
       _E1628_)))
  (define std/parser/rx-parser#L2::1
    (lambda (_ts1605_ _toks1606_ _wrap-e1607_ _K1608_ _E1609_)
      (let ((_start1611_ (std/parser/lexer#token-stream-loc _ts1605_)))
        (std/parser/rx-parser#EscapedChar
         _ts1605_
         _toks1606_
         _wrap-e1607_
         (lambda (_toks1613_ _$14341614_)
           (let* ((_end1617_ (std/parser/lexer#token-stream-loc _ts1605_))
                  (_@loc1619_
                   (std/parser/base#location-delta* _start1611_ _end1617_)))
             (_K1608_ _toks1613_
                      (let ((__tmp6269
                             (_wrap-e1607_
                              ((lambda (_$11622_)
                                 (cons '@char (cons _$11622_ '())))
                               (##direct-structure-ref
                                _$14341614_
                                '2
                                std/parser/base#token::t
                                '#f))
                              _@loc1619_)))
                        (declare (not safe))
                        (##structure
                         std/parser/base#token::t
                         'L2
                         __tmp6269
                         _@loc1619_)))))
         _E1609_))))
  (define std/parser/rx-parser#L2::2::app
    (lambda (_ts1599_ _toks1600_ _wrap-e1601_ _K1602_ _E1603_)
      (std/parser/rx-parser#NegSet
       _ts1599_
       _toks1600_
       _wrap-e1601_
       _K1602_
       _E1603_)))
  (define std/parser/rx-parser#L2::2
    (lambda (_ts1590_ _toks1591_ _wrap-e1592_ _K1593_ _E1594_)
      (std/parser/rx-parser#NegSet
       _ts1590_
       _toks1591_
       _wrap-e1592_
       (lambda (_toks1596_ _rtok1597_)
         (_K1593_ _toks1596_
                  (let ((__tmp6271
                         (##direct-structure-ref
                          _rtok1597_
                          '2
                          std/parser/base#token::t
                          '#f))
                        (__tmp6270
                         (##direct-structure-ref
                          _rtok1597_
                          '3
                          std/parser/base#token::t
                          '#f)))
                    (declare (not safe))
                    (##structure
                     std/parser/base#token::t
                     'L2
                     __tmp6271
                     __tmp6270))))
       _E1594_)))
  (define std/parser/rx-parser#L2::3::app
    (lambda (_ts1584_ _toks1585_ _wrap-e1586_ _K1587_ _E1588_)
      (std/parser/rx-parser#CharSet
       _ts1584_
       _toks1585_
       _wrap-e1586_
       _K1587_
       _E1588_)))
  (define std/parser/rx-parser#L2::3
    (lambda (_ts1575_ _toks1576_ _wrap-e1577_ _K1578_ _E1579_)
      (std/parser/rx-parser#CharSet
       _ts1575_
       _toks1576_
       _wrap-e1577_
       (lambda (_toks1581_ _rtok1582_)
         (_K1578_ _toks1581_
                  (let ((__tmp6273
                         (##direct-structure-ref
                          _rtok1582_
                          '2
                          std/parser/base#token::t
                          '#f))
                        (__tmp6272
                         (##direct-structure-ref
                          _rtok1582_
                          '3
                          std/parser/base#token::t
                          '#f)))
                    (declare (not safe))
                    (##structure
                     std/parser/base#token::t
                     'L2
                     __tmp6273
                     __tmp6272))))
       _E1579_)))
  (define std/parser/rx-parser#L2::4::app
    (lambda (_ts1564_ _toks1565_ _wrap-e1566_ _K1567_ _E1568_)
      (let* ((_next1570_ (std/parser/lexer#token-stream-next _ts1564_))
             (_toks1572_ (cons _next1570_ _toks1565_)))
        (if (eq? (##direct-structure-ref
                  _next1570_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\.)
            (_K1567_ _toks1572_ _next1570_)
            (_E1568_ _toks1572_)))))
  (define std/parser/rx-parser#L2::4
    (lambda (_ts1546_ _toks1547_ _wrap-e1548_ _K1549_ _E1550_)
      (let ((_start1552_ (std/parser/lexer#token-stream-loc _ts1546_)))
        (std/parser/rx-parser#L2::4::app
         _ts1546_
         _toks1547_
         _wrap-e1548_
         (lambda (_toks1554_ _@@1555_)
           (let* ((_end1557_ (std/parser/lexer#token-stream-loc _ts1546_))
                  (_@loc1559_
                   (std/parser/base#location-delta* _start1552_ _end1557_)))
             (_K1549_ _toks1554_
                      (let ((__tmp6274
                             (_wrap-e1548_
                              ((lambda (_@@1562_) '@dot) _@@1555_)
                              _@loc1559_)))
                        (declare (not safe))
                        (##structure
                         std/parser/base#token::t
                         'L2
                         __tmp6274
                         _@loc1559_)))))
         _E1550_))))
  (define std/parser/rx-parser#L2::5::app
    (lambda (_ts1540_ _toks1541_ _wrap-e1542_ _K1543_ _E1544_)
      (std/parser/rx-parser#SpecialChar
       _ts1540_
       _toks1541_
       _wrap-e1542_
       _K1543_
       _E1544_)))
  (define std/parser/rx-parser#L2::5
    (lambda (_ts1532_ _toks1533_ _wrap-e1534_ _K1535_ _E1536_)
      (std/parser/rx-parser#SpecialChar
       _ts1532_
       _toks1533_
       _wrap-e1534_
       (lambda (_toks1538_ . _g6275_) (_K1535_ _toks1538_))
       _E1536_)))
  (define std/parser/rx-parser#L2::6::app
    (lambda (_ts1526_ _toks1527_ _wrap-e1528_ _K1529_ _E1530_)
      (std/parser/rx-parser#Char
       _ts1526_
       _toks1527_
       _wrap-e1528_
       _K1529_
       _E1530_)))
  (define std/parser/rx-parser#L2::6
    (lambda (_ts1507_ _toks1508_ _wrap-e1509_ _K1510_ _E1511_)
      (let ((_start1513_ (std/parser/lexer#token-stream-loc _ts1507_)))
        (std/parser/rx-parser#Char
         _ts1507_
         _toks1508_
         _wrap-e1509_
         (lambda (_toks1515_ _$14351516_)
           (let* ((_end1519_ (std/parser/lexer#token-stream-loc _ts1507_))
                  (_@loc1521_
                   (std/parser/base#location-delta* _start1513_ _end1519_)))
             (_K1510_ _toks1515_
                      (let ((__tmp6276
                             (_wrap-e1509_
                              ((lambda (_$11524_)
                                 (cons '@char (cons _$11524_ '())))
                               (##direct-structure-ref
                                _$14351516_
                                '2
                                std/parser/base#token::t
                                '#f))
                              _@loc1521_)))
                        (declare (not safe))
                        (##structure
                         std/parser/base#token::t
                         'L2
                         __tmp6276
                         _@loc1521_)))))
         _E1511_))))
  (define std/parser/rx-parser#L2
    (lambda (_ts1491_ _toks1492_ _wrap-e1493_ _K1494_ _E1495_)
      (std/parser/rx-parser#L2::1
       _ts1491_
       _toks1492_
       _wrap-e1493_
       _K1494_
       (lambda (_xtoks1497_)
         (std/parser/defparser#parser-rewind _ts1491_ _xtoks1497_ _toks1492_)
         (std/parser/rx-parser#L2::2
          _ts1491_
          _toks1492_
          _wrap-e1493_
          _K1494_
          (lambda (_xtoks1499_)
            (std/parser/defparser#parser-rewind
             _ts1491_
             _xtoks1499_
             _toks1492_)
            (std/parser/rx-parser#L2::3
             _ts1491_
             _toks1492_
             _wrap-e1493_
             _K1494_
             (lambda (_xtoks1501_)
               (std/parser/defparser#parser-rewind
                _ts1491_
                _xtoks1501_
                _toks1492_)
               (std/parser/rx-parser#L2::4
                _ts1491_
                _toks1492_
                _wrap-e1493_
                _K1494_
                (lambda (_xtoks1503_)
                  (std/parser/defparser#parser-rewind
                   _ts1491_
                   _xtoks1503_
                   _toks1492_)
                  (std/parser/rx-parser#L2::5
                   _ts1491_
                   _toks1492_
                   _wrap-e1493_
                   _E1495_
                   (lambda (_xtoks1505_)
                     (std/parser/defparser#parser-rewind
                      _ts1491_
                      _xtoks1505_
                      _toks1492_)
                     (std/parser/rx-parser#L2::6
                      _ts1491_
                      _toks1492_
                      _wrap-e1493_
                      _K1494_
                      _E1495_)))))))))))))
  (define std/parser/rx-parser#EscapedChar::app::cat::1
    (lambda (_ts1480_ _toks1481_ _wrap-e1482_ _K1483_ _E1484_)
      (let* ((_next1486_ (std/parser/lexer#token-stream-next _ts1480_))
             (_toks1488_ (cons _next1486_ _toks1481_)))
        (if (eq? (##direct-structure-ref
                  _next1486_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\\)
            (_K1483_ _toks1488_ _next1486_)
            (_E1484_ _toks1488_)))))
  (define std/parser/rx-parser#EscapedChar::app::cat::2
    (lambda (_ts1474_ _toks1475_ _wrap-e1476_ _K1477_ _E1478_)
      (std/parser/rx-parser#Char
       _ts1474_
       _toks1475_
       _wrap-e1476_
       _K1477_
       _E1478_)))
  (define std/parser/rx-parser#EscapedChar::app
    (lambda (_ts1462_ _toks1463_ _wrap-e1464_ _K1465_ _E1466_)
      (std/parser/rx-parser#EscapedChar::app::cat::1
       _ts1462_
       _toks1463_
       _wrap-e1464_
       (lambda (_toks1468_ _g6277_)
         (std/parser/rx-parser#Char
          _ts1462_
          _toks1468_
          _wrap-e1464_
          (lambda (_toks1470_ _$14361471_) (_K1465_ _toks1470_ _$14361471_))
          _E1466_))
       _E1466_)))
  (define std/parser/rx-parser#EscapedChar
    (lambda (_ts1443_ _toks1444_ _wrap-e1445_ _K1446_ _E1447_)
      (let ((_start1449_ (std/parser/lexer#token-stream-loc _ts1443_)))
        (std/parser/rx-parser#EscapedChar::app
         _ts1443_
         _toks1444_
         _wrap-e1445_
         (lambda (_toks1451_ _$14371452_)
           (let* ((_end1455_ (std/parser/lexer#token-stream-loc _ts1443_))
                  (_@loc1457_
                   (std/parser/base#location-delta* _start1449_ _end1455_)))
             (_K1446_ _toks1451_
                      (let ((__tmp6278
                             (_wrap-e1445_
                              ((lambda (_$11460_)
                                 (std/parser/rx-parser#escape-char _$11460_))
                               (##direct-structure-ref
                                _$14371452_
                                '2
                                std/parser/base#token::t
                                '#f))
                              _@loc1457_)))
                        (declare (not safe))
                        (##structure
                         std/parser/base#token::t
                         'EscapedChar
                         __tmp6278
                         _@loc1457_)))))
         _E1447_))))
  (define std/parser/rx-parser#CharSet::1::app::cat::1
    (lambda (_ts1432_ _toks1433_ _wrap-e1434_ _K1435_ _E1436_)
      (let* ((_next1438_ (std/parser/lexer#token-stream-next _ts1432_))
             (_toks1440_ (cons _next1438_ _toks1433_)))
        (if (eq? (##direct-structure-ref
                  _next1438_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\[)
            (_K1435_ _toks1440_ _next1438_)
            (_E1436_ _toks1440_)))))
  (define std/parser/rx-parser#CharSet::1::app::cat::2
    (lambda (_ts1421_ _toks1422_ _wrap-e1423_ _K1424_ _E1425_)
      (let* ((_next1427_ (std/parser/lexer#token-stream-next _ts1421_))
             (_toks1429_ (cons _next1427_ _toks1422_)))
        (if (eq? (##direct-structure-ref
                  _next1427_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\-)
            (_K1424_ _toks1429_ _next1427_)
            (_E1425_ _toks1429_)))))
  (define std/parser/rx-parser#CharSet::1::app::cat::3::rep*
    (lambda (_ts1415_ _toks1416_ _wrap-e1417_ _K1418_ _E1419_)
      (std/parser/rx-parser#CharRange
       _ts1415_
       _toks1416_
       _wrap-e1417_
       _K1418_
       _E1419_)))
  (define std/parser/rx-parser#CharSet::1::app::cat::3
    (lambda (_ts1397_ _toks1398_ _wrap-e1399_ _K1400_ _E1401_)
      (let _lp1403_ ((_toks1405_ _toks1398_) (_$14381406_ '()))
        (std/parser/rx-parser#CharRange
         _ts1397_
         _toks1405_
         _wrap-e1399_
         (lambda (_toks1409_ _g4391410_)
           (_lp1403_ _toks1409_ (cons _g4391410_ _$14381406_)))
         (lambda (_xtoks1413_)
           (std/parser/defparser#parser-rewind _ts1397_ _xtoks1413_ _toks1405_)
           (_K1400_ _toks1405_ (reverse _$14381406_)))))))
  (define std/parser/rx-parser#CharSet::1::app::cat::4
    (lambda (_ts1386_ _toks1387_ _wrap-e1388_ _K1389_ _E1390_)
      (let* ((_next1392_ (std/parser/lexer#token-stream-next _ts1386_))
             (_toks1394_ (cons _next1392_ _toks1387_)))
        (if (eq? (##direct-structure-ref
                  _next1392_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\])
            (_K1389_ _toks1394_ _next1392_)
            (_E1390_ _toks1394_)))))
  (define std/parser/rx-parser#CharSet::1::app
    (lambda (_ts1370_ _toks1371_ _wrap-e1372_ _K1373_ _E1374_)
      (std/parser/rx-parser#CharSet::1::app::cat::1
       _ts1370_
       _toks1371_
       _wrap-e1372_
       (lambda (_toks1376_ _g6279_)
         (std/parser/rx-parser#CharSet::1::app::cat::2
          _ts1370_
          _toks1376_
          _wrap-e1372_
          (lambda (_toks1378_ _g6280_)
            (std/parser/rx-parser#CharSet::1::app::cat::3
             _ts1370_
             _toks1378_
             _wrap-e1372_
             (lambda (_toks1380_ _g4401381_)
               (std/parser/rx-parser#CharSet::1::app::cat::4
                _ts1370_
                _toks1380_
                _wrap-e1372_
                (lambda (_toks1384_ _g6281_) (_K1373_ _toks1384_ _g4401381_))
                _E1374_))
             _E1374_))
          _E1374_))
       _E1374_)))
  (define std/parser/rx-parser#CharSet::1
    (lambda (_ts1349_ _toks1350_ _wrap-e1351_ _K1352_ _E1353_)
      (let ((_start1355_ (std/parser/lexer#token-stream-loc _ts1349_)))
        (std/parser/rx-parser#CharSet::1::app
         _ts1349_
         _toks1350_
         _wrap-e1351_
         (lambda (_toks1357_ _$14411358_)
           (let* ((_end1361_ (std/parser/lexer#token-stream-loc _ts1349_))
                  (_@loc1363_
                   (std/parser/base#location-delta* _start1355_ _end1361_)))
             (_K1352_ _toks1357_
                      (let ((__tmp6282
                             (_wrap-e1351_
                              ((lambda (_$11366_)
                                 (cons '@charset
                                       (cons (cons 'quote
                                                   (cons (apply append
                                                                (cons '#\- '())
                                                                (map std/parser/base#unwrap-ast
;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
                             _$11366_))
                 '()))
;;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
                                             '())))
                               ((lambda (_$x1368_)
                                  (map std/parser/base#token-e _$x1368_))
                                _$14411358_))
                              _@loc1363_)))
                        (declare (not safe))
                        (##structure
                         std/parser/base#token::t
                         'CharSet
                         __tmp6282
                         _@loc1363_)))))
         _E1353_))))
  (define std/parser/rx-parser#CharSet::2::app::cat::1
    (lambda (_ts1338_ _toks1339_ _wrap-e1340_ _K1341_ _E1342_)
      (let* ((_next1344_ (std/parser/lexer#token-stream-next _ts1338_))
             (_toks1346_ (cons _next1344_ _toks1339_)))
        (if (eq? (##direct-structure-ref
                  _next1344_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\[)
            (_K1341_ _toks1346_ _next1344_)
            (_E1342_ _toks1346_)))))
  (define std/parser/rx-parser#CharSet::2::app::cat::2::rep*
    (lambda (_ts1332_ _toks1333_ _wrap-e1334_ _K1335_ _E1336_)
      (std/parser/rx-parser#CharRange
       _ts1332_
       _toks1333_
       _wrap-e1334_
       _K1335_
       _E1336_)))
  (define std/parser/rx-parser#CharSet::2::app::cat::2
    (lambda (_ts1311_ _toks1312_ _wrap-e1313_ _K1314_ _E1315_)
      (std/parser/rx-parser#CharRange
       _ts1311_
       _toks1312_
       _wrap-e1313_
       (lambda (_toks1317_ _g4431318_)
         (let _lp1321_ ((_toks1323_ _toks1317_)
                        (_$14421324_ (cons _g4431318_ '())))
           (std/parser/rx-parser#CharRange
            _ts1311_
            _toks1323_
            _wrap-e1313_
            (lambda (_toks1327_ _g4431328_)
              (_lp1321_ _toks1327_ (cons _g4431328_ _$14421324_)))
            (lambda (_xtoks1330_)
              (std/parser/defparser#parser-rewind
               _ts1311_
               _xtoks1330_
               _toks1323_)
              (_K1314_ _toks1323_ (reverse _$14421324_))))))
       _E1315_)))
  (define std/parser/rx-parser#CharSet::2::app::cat::3
    (lambda (_ts1300_ _toks1301_ _wrap-e1302_ _K1303_ _E1304_)
      (let* ((_next1306_ (std/parser/lexer#token-stream-next _ts1300_))
             (_toks1308_ (cons _next1306_ _toks1301_)))
        (if (eq? (##direct-structure-ref
                  _next1306_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\])
            (_K1303_ _toks1308_ _next1306_)
            (_E1304_ _toks1308_)))))
  (define std/parser/rx-parser#CharSet::2::app
    (lambda (_ts1286_ _toks1287_ _wrap-e1288_ _K1289_ _E1290_)
      (std/parser/rx-parser#CharSet::2::app::cat::1
       _ts1286_
       _toks1287_
       _wrap-e1288_
       (lambda (_toks1292_ _g6283_)
         (std/parser/rx-parser#CharSet::2::app::cat::2
          _ts1286_
          _toks1292_
          _wrap-e1288_
          (lambda (_toks1294_ _g4441295_)
            (std/parser/rx-parser#CharSet::2::app::cat::3
             _ts1286_
             _toks1294_
             _wrap-e1288_
             (lambda (_toks1298_ _g6284_) (_K1289_ _toks1298_ _g4441295_))
             _E1290_))
          _E1290_))
       _E1290_)))
  (define std/parser/rx-parser#CharSet::2
    (lambda (_ts1265_ _toks1266_ _wrap-e1267_ _K1268_ _E1269_)
      (let ((_start1271_ (std/parser/lexer#token-stream-loc _ts1265_)))
        (std/parser/rx-parser#CharSet::2::app
         _ts1265_
         _toks1266_
         _wrap-e1267_
         (lambda (_toks1273_ _$14451274_)
           (let* ((_end1277_ (std/parser/lexer#token-stream-loc _ts1265_))
                  (_@loc1279_
                   (std/parser/base#location-delta* _start1271_ _end1277_)))
             (_K1268_ _toks1273_
                      (let ((__tmp6285
                             (_wrap-e1267_
                              ((lambda (_$11282_)
                                 (cons '@charset
                                       (cons (cons 'quote
                                                   (cons (apply append
                                                                (map std/parser/base#unwrap-ast
;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
                             _$11282_))
                 '()))
;;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
                                             '())))
                               ((lambda (_$x1284_)
                                  (map std/parser/base#token-e _$x1284_))
                                _$14451274_))
                              _@loc1279_)))
                        (declare (not safe))
                        (##structure
                         std/parser/base#token::t
                         'CharSet
                         __tmp6285
                         _@loc1279_)))))
         _E1269_))))
  (define std/parser/rx-parser#CharSet
    (lambda (_ts1257_ _toks1258_ _wrap-e1259_ _K1260_ _E1261_)
      (std/parser/rx-parser#CharSet::1
       _ts1257_
       _toks1258_
       _wrap-e1259_
       _K1260_
       (lambda (_xtoks1263_)
         (std/parser/defparser#parser-rewind _ts1257_ _xtoks1263_ _toks1258_)
         (std/parser/rx-parser#CharSet::2
          _ts1257_
          _toks1258_
          _wrap-e1259_
          _K1260_
          _E1261_)))))
  (define std/parser/rx-parser#NegSet::1::app::cat::1
    (lambda (_ts1246_ _toks1247_ _wrap-e1248_ _K1249_ _E1250_)
      (let* ((_next1252_ (std/parser/lexer#token-stream-next _ts1246_))
             (_toks1254_ (cons _next1252_ _toks1247_)))
        (if (eq? (##direct-structure-ref
                  _next1252_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\[)
            (_K1249_ _toks1254_ _next1252_)
            (_E1250_ _toks1254_)))))
  (define std/parser/rx-parser#NegSet::1::app::cat::2
    (lambda (_ts1235_ _toks1236_ _wrap-e1237_ _K1238_ _E1239_)
      (let* ((_next1241_ (std/parser/lexer#token-stream-next _ts1235_))
             (_toks1243_ (cons _next1241_ _toks1236_)))
        (if (eq? (##direct-structure-ref
                  _next1241_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\^)
            (_K1238_ _toks1243_ _next1241_)
            (_E1239_ _toks1243_)))))
  (define std/parser/rx-parser#NegSet::1::app::cat::3
    (lambda (_ts1224_ _toks1225_ _wrap-e1226_ _K1227_ _E1228_)
      (let* ((_next1230_ (std/parser/lexer#token-stream-next _ts1224_))
             (_toks1232_ (cons _next1230_ _toks1225_)))
        (if (eq? (##direct-structure-ref
                  _next1230_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\-)
            (_K1227_ _toks1232_ _next1230_)
            (_E1228_ _toks1232_)))))
  (define std/parser/rx-parser#NegSet::1::app::cat::4::rep*
    (lambda (_ts1218_ _toks1219_ _wrap-e1220_ _K1221_ _E1222_)
      (std/parser/rx-parser#CharRange
       _ts1218_
       _toks1219_
       _wrap-e1220_
       _K1221_
       _E1222_)))
  (define std/parser/rx-parser#NegSet::1::app::cat::4
    (lambda (_ts1200_ _toks1201_ _wrap-e1202_ _K1203_ _E1204_)
      (let _lp1206_ ((_toks1208_ _toks1201_) (_$14461209_ '()))
        (std/parser/rx-parser#CharRange
         _ts1200_
         _toks1208_
         _wrap-e1202_
         (lambda (_toks1212_ _g4471213_)
           (_lp1206_ _toks1212_ (cons _g4471213_ _$14461209_)))
         (lambda (_xtoks1216_)
           (std/parser/defparser#parser-rewind _ts1200_ _xtoks1216_ _toks1208_)
           (_K1203_ _toks1208_ (reverse _$14461209_)))))))
  (define std/parser/rx-parser#NegSet::1::app::cat::5
    (lambda (_ts1189_ _toks1190_ _wrap-e1191_ _K1192_ _E1193_)
      (let* ((_next1195_ (std/parser/lexer#token-stream-next _ts1189_))
             (_toks1197_ (cons _next1195_ _toks1190_)))
        (if (eq? (##direct-structure-ref
                  _next1195_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\])
            (_K1192_ _toks1197_ _next1195_)
            (_E1193_ _toks1197_)))))
  (define std/parser/rx-parser#NegSet::1::app
    (lambda (_ts1171_ _toks1172_ _wrap-e1173_ _K1174_ _E1175_)
      (std/parser/rx-parser#NegSet::1::app::cat::1
       _ts1171_
       _toks1172_
       _wrap-e1173_
       (lambda (_toks1177_ _g6286_)
         (std/parser/rx-parser#NegSet::1::app::cat::2
          _ts1171_
          _toks1177_
          _wrap-e1173_
          (lambda (_toks1179_ _g6287_)
            (std/parser/rx-parser#NegSet::1::app::cat::3
             _ts1171_
             _toks1179_
             _wrap-e1173_
             (lambda (_toks1181_ _g6288_)
               (std/parser/rx-parser#NegSet::1::app::cat::4
                _ts1171_
                _toks1181_
                _wrap-e1173_
                (lambda (_toks1183_ _g4481184_)
                  (std/parser/rx-parser#NegSet::1::app::cat::5
                   _ts1171_
                   _toks1183_
                   _wrap-e1173_
                   (lambda (_toks1187_ _g6289_)
                     (_K1174_ _toks1187_ _g4481184_))
                   _E1175_))
                _E1175_))
             _E1175_))
          _E1175_))
       _E1175_)))
  (define std/parser/rx-parser#NegSet::1
    (lambda (_ts1150_ _toks1151_ _wrap-e1152_ _K1153_ _E1154_)
      (let ((_start1156_ (std/parser/lexer#token-stream-loc _ts1150_)))
        (std/parser/rx-parser#NegSet::1::app
         _ts1150_
         _toks1151_
         _wrap-e1152_
         (lambda (_toks1158_ _$14491159_)
           (let* ((_end1162_ (std/parser/lexer#token-stream-loc _ts1150_))
                  (_@loc1164_
                   (std/parser/base#location-delta* _start1156_ _end1162_)))
             (_K1153_ _toks1158_
                      (let ((__tmp6290
                             (_wrap-e1152_
                              ((lambda (_$11167_)
                                 (cons '@negset
                                       (cons (cons 'quote
                                                   (cons (apply append
                                                                (cons '#\- '())
                                                                (map std/parser/base#unwrap-ast
;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
                             _$11167_))
                 '()))
;;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
                                             '())))
                               ((lambda (_$x1169_)
                                  (map std/parser/base#token-e _$x1169_))
                                _$14491159_))
                              _@loc1164_)))
                        (declare (not safe))
                        (##structure
                         std/parser/base#token::t
                         'NegSet
                         __tmp6290
                         _@loc1164_)))))
         _E1154_))))
  (define std/parser/rx-parser#NegSet::2::app::cat::1
    (lambda (_ts1139_ _toks1140_ _wrap-e1141_ _K1142_ _E1143_)
      (let* ((_next1145_ (std/parser/lexer#token-stream-next _ts1139_))
             (_toks1147_ (cons _next1145_ _toks1140_)))
        (if (eq? (##direct-structure-ref
                  _next1145_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\[)
            (_K1142_ _toks1147_ _next1145_)
            (_E1143_ _toks1147_)))))
  (define std/parser/rx-parser#NegSet::2::app::cat::2
    (lambda (_ts1128_ _toks1129_ _wrap-e1130_ _K1131_ _E1132_)
      (let* ((_next1134_ (std/parser/lexer#token-stream-next _ts1128_))
             (_toks1136_ (cons _next1134_ _toks1129_)))
        (if (eq? (##direct-structure-ref
                  _next1134_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\^)
            (_K1131_ _toks1136_ _next1134_)
            (_E1132_ _toks1136_)))))
  (define std/parser/rx-parser#NegSet::2::app::cat::3::rep*
    (lambda (_ts1122_ _toks1123_ _wrap-e1124_ _K1125_ _E1126_)
      (std/parser/rx-parser#CharRange
       _ts1122_
       _toks1123_
       _wrap-e1124_
       _K1125_
       _E1126_)))
  (define std/parser/rx-parser#NegSet::2::app::cat::3
    (lambda (_ts1100_ _toks1101_ _wrap-e1102_ _K1103_ _E1104_)
      (std/parser/rx-parser#CharRange
       _ts1100_
       _toks1101_
       _wrap-e1102_
       (lambda (_toks1106_ _g4511107_)
         (let _lp1110_ ((_toks1113_ _toks1106_)
                        (_$14501114_ (cons _g4511107_ '())))
           (std/parser/rx-parser#CharRange
            _ts1100_
            _toks1113_
            _wrap-e1102_
            (lambda (_toks1117_ _g4511118_)
              (_lp1110_ _toks1117_ (cons _g4511118_ _$14501114_)))
            (lambda (_xtoks1120_)
              (std/parser/defparser#parser-rewind
               _ts1100_
               _xtoks1120_
               _toks1113_)
              (_K1103_ _toks1113_ (reverse _$14501114_))))))
       _E1104_)))
  (define std/parser/rx-parser#NegSet::2::app::cat::4
    (lambda (_ts1089_ _toks1090_ _wrap-e1091_ _K1092_ _E1093_)
      (let* ((_next1095_ (std/parser/lexer#token-stream-next _ts1089_))
             (_toks1097_ (cons _next1095_ _toks1090_)))
        (if (eq? (##direct-structure-ref
                  _next1095_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\])
            (_K1092_ _toks1097_ _next1095_)
            (_E1093_ _toks1097_)))))
  (define std/parser/rx-parser#NegSet::2::app
    (lambda (_ts1073_ _toks1074_ _wrap-e1075_ _K1076_ _E1077_)
      (std/parser/rx-parser#NegSet::2::app::cat::1
       _ts1073_
       _toks1074_
       _wrap-e1075_
       (lambda (_toks1079_ _g6291_)
         (std/parser/rx-parser#NegSet::2::app::cat::2
          _ts1073_
          _toks1079_
          _wrap-e1075_
          (lambda (_toks1081_ _g6292_)
            (std/parser/rx-parser#NegSet::2::app::cat::3
             _ts1073_
             _toks1081_
             _wrap-e1075_
             (lambda (_toks1083_ _g4521084_)
               (std/parser/rx-parser#NegSet::2::app::cat::4
                _ts1073_
                _toks1083_
                _wrap-e1075_
                (lambda (_toks1087_ _g6293_) (_K1076_ _toks1087_ _g4521084_))
                _E1077_))
             _E1077_))
          _E1077_))
       _E1077_)))
  (define std/parser/rx-parser#NegSet::2
    (lambda (_ts1051_ _toks1052_ _wrap-e1053_ _K1054_ _E1055_)
      (let ((_start1057_ (std/parser/lexer#token-stream-loc _ts1051_)))
        (std/parser/rx-parser#NegSet::2::app
         _ts1051_
         _toks1052_
         _wrap-e1053_
         (lambda (_toks1059_ _$14531060_)
           (let* ((_end1063_ (std/parser/lexer#token-stream-loc _ts1051_))
                  (_@loc1065_
                   (std/parser/base#location-delta* _start1057_ _end1063_)))
             (_K1054_ _toks1059_
                      (let ((__tmp6294
                             (_wrap-e1053_
                              ((lambda (_$11068_)
                                 (cons '@negset
                                       (cons (cons 'quote
                                                   (cons (apply append
                                                                (map std/parser/base#unwrap-ast
;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
                             _$11068_))
                 '()))
;;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
                                             '())))
                               ((lambda (_$x1070_)
                                  (map std/parser/base#token-e _$x1070_))
                                _$14531060_))
                              _@loc1065_)))
                        (declare (not safe))
                        (##structure
                         std/parser/base#token::t
                         'NegSet
                         __tmp6294
                         _@loc1065_)))))
         _E1055_))))
  (define std/parser/rx-parser#NegSet
    (lambda (_ts1043_ _toks1044_ _wrap-e1045_ _K1046_ _E1047_)
      (std/parser/rx-parser#NegSet::1
       _ts1043_
       _toks1044_
       _wrap-e1045_
       _K1046_
       (lambda (_xtoks1049_)
         (std/parser/defparser#parser-rewind _ts1043_ _xtoks1049_ _toks1044_)
         (std/parser/rx-parser#NegSet::2
          _ts1043_
          _toks1044_
          _wrap-e1045_
          _K1046_
          _E1047_)))))
  (define std/parser/rx-parser#CharRange::1::app::cat::1
    (lambda (_ts1037_ _toks1038_ _wrap-e1039_ _K1040_ _E1041_)
      (std/parser/rx-parser#CharRangeChar
       _ts1037_
       _toks1038_
       _wrap-e1039_
       _K1040_
       _E1041_)))
  (define std/parser/rx-parser#CharRange::1::app::cat::2
    (lambda (_ts1026_ _toks1027_ _wrap-e1028_ _K1029_ _E1030_)
      (let* ((_next1032_ (std/parser/lexer#token-stream-next _ts1026_))
             (_toks1034_ (cons _next1032_ _toks1027_)))
        (if (eq? (##direct-structure-ref
                  _next1032_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\-)
            (_K1029_ _toks1034_ _next1032_)
            (_E1030_ _toks1034_)))))
  (define std/parser/rx-parser#CharRange::1::app::cat::3
    (lambda (_ts1020_ _toks1021_ _wrap-e1022_ _K1023_ _E1024_)
      (std/parser/rx-parser#CharRangeChar
       _ts1020_
       _toks1021_
       _wrap-e1022_
       _K1023_
       _E1024_)))
  (define std/parser/rx-parser#CharRange::1::app
    (lambda (_ts1004_ _toks1005_ _wrap-e1006_ _K1007_ _E1008_)
      (std/parser/rx-parser#CharRangeChar
       _ts1004_
       _toks1005_
       _wrap-e1006_
       (lambda (_toks1010_ _$14541011_)
         (std/parser/rx-parser#CharRange::1::app::cat::2
          _ts1004_
          _toks1010_
          _wrap-e1006_
          (lambda (_toks1014_ _g6295_)
            (std/parser/rx-parser#CharRangeChar
             _ts1004_
             _toks1014_
             _wrap-e1006_
             (lambda (_toks1016_ _$24551017_)
               (_K1007_ _toks1016_ _$14541011_ _$24551017_))
             _E1008_))
          _E1008_))
       _E1008_)))
  (define std/parser/rx-parser#CharRange::1
    (lambda (_ts982_ _toks983_ _wrap-e984_ _K985_ _E986_)
      (let ((_start988_ (std/parser/lexer#token-stream-loc _ts982_)))
        (std/parser/rx-parser#CharRange::1::app
         _ts982_
         _toks983_
         _wrap-e984_
         (lambda (_toks990_ _$1456991_ _$2457993_)
           (let* ((_end996_ (std/parser/lexer#token-stream-loc _ts982_))
                  (_@loc998_
                   (std/parser/base#location-delta* _start988_ _end996_)))
             (_K985_ _toks990_
                     (let ((__tmp6296
                            (_wrap-e984_
                             ((lambda (_$11001_ _$21002_)
                                (std/parser/rx-parser#make-char-range
                                 _$11001_
                                 _$21002_
                                 _@loc998_))
                              (##direct-structure-ref
                               _$1456991_
                               '2
                               std/parser/base#token::t
                               '#f)
                              (##direct-structure-ref
                               _$2457993_
                               '2
                               std/parser/base#token::t
                               '#f))
                             _@loc998_)))
                       (declare (not safe))
                       (##structure
                        std/parser/base#token::t
                        'CharRange
                        __tmp6296
                        _@loc998_)))))
         _E986_))))
  (define std/parser/rx-parser#CharRange::2::app
    (lambda (_ts976_ _toks977_ _wrap-e978_ _K979_ _E980_)
      (std/parser/rx-parser#CharRangeChar
       _ts976_
       _toks977_
       _wrap-e978_
       _K979_
       _E980_)))
  (define std/parser/rx-parser#CharRange::2
    (lambda (_ts957_ _toks958_ _wrap-e959_ _K960_ _E961_)
      (let ((_start963_ (std/parser/lexer#token-stream-loc _ts957_)))
        (std/parser/rx-parser#CharRangeChar
         _ts957_
         _toks958_
         _wrap-e959_
         (lambda (_toks965_ _$1458966_)
           (let* ((_end969_ (std/parser/lexer#token-stream-loc _ts957_))
                  (_@loc971_
                   (std/parser/base#location-delta* _start963_ _end969_)))
             (_K960_ _toks965_
                     (let ((__tmp6297
                            (_wrap-e959_
                             ((lambda (_$1974_) (cons _$1974_ '()))
                              (##direct-structure-ref
                               _$1458966_
                               '2
                               std/parser/base#token::t
                               '#f))
                             _@loc971_)))
                       (declare (not safe))
                       (##structure
                        std/parser/base#token::t
                        'CharRange
                        __tmp6297
                        _@loc971_)))))
         _E961_))))
  (define std/parser/rx-parser#CharRange
    (lambda (_ts949_ _toks950_ _wrap-e951_ _K952_ _E953_)
      (std/parser/rx-parser#CharRange::1
       _ts949_
       _toks950_
       _wrap-e951_
       _K952_
       (lambda (_xtoks955_)
         (std/parser/defparser#parser-rewind _ts949_ _xtoks955_ _toks950_)
         (std/parser/rx-parser#CharRange::2
          _ts949_
          _toks950_
          _wrap-e951_
          _K952_
          _E953_)))))
  (define std/parser/rx-parser#CharRangeChar::1::app
    (lambda (_ts938_ _toks939_ _wrap-e940_ _K941_ _E942_)
      (let* ((_next944_ (std/parser/lexer#token-stream-next _ts938_))
             (_toks946_ (cons _next944_ _toks939_)))
        (if (eq? (##direct-structure-ref
                  _next944_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\])
            (_K941_ _toks946_ _next944_)
            (_E942_ _toks946_)))))
  (define std/parser/rx-parser#CharRangeChar::1
    (lambda (_ts930_ _toks931_ _wrap-e932_ _K933_ _E934_)
      (std/parser/rx-parser#CharRangeChar::1::app
       _ts930_
       _toks931_
       _wrap-e932_
       (lambda (_toks936_ . _g6298_) (_K933_ _toks936_))
       _E934_)))
  (define std/parser/rx-parser#CharRangeChar::2::app
    (lambda (_ts919_ _toks920_ _wrap-e921_ _K922_ _E923_)
      (let* ((_next925_ (std/parser/lexer#token-stream-next _ts919_))
             (_toks927_ (cons _next925_ _toks920_)))
        (if (eq? (##direct-structure-ref
                  _next925_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\-)
            (_K922_ _toks927_ _next925_)
            (_E923_ _toks927_)))))
  (define std/parser/rx-parser#CharRangeChar::2
    (lambda (_ts901_ _toks902_ _wrap-e903_ _K904_ _E905_)
      (let ((_start907_ (std/parser/lexer#token-stream-loc _ts901_)))
        (std/parser/rx-parser#CharRangeChar::2::app
         _ts901_
         _toks902_
         _wrap-e903_
         (lambda (_toks909_ _@@910_)
           (let* ((_end912_ (std/parser/lexer#token-stream-loc _ts901_))
                  (_@loc914_
                   (std/parser/base#location-delta* _start907_ _end912_)))
             (_K904_ _toks909_
                     (let ((__tmp6299
                            (_wrap-e903_
                             ((lambda (_@@917_)
                                (std/parser/base#raise-parse-error
                                 'parse-rx
                                 '"Illegal character range"
                                 _@@917_))
                              _@@910_)
                             _@loc914_)))
                       (declare (not safe))
                       (##structure
                        std/parser/base#token::t
                        'CharRangeChar
                        __tmp6299
                        _@loc914_)))))
         _E905_))))
  (define std/parser/rx-parser#CharRangeChar::3::app
    (lambda (_ts895_ _toks896_ _wrap-e897_ _K898_ _E899_)
      (std/parser/rx-parser#EscapedChar
       _ts895_
       _toks896_
       _wrap-e897_
       _K898_
       _E899_)))
  (define std/parser/rx-parser#CharRangeChar::3
    (lambda (_ts886_ _toks887_ _wrap-e888_ _K889_ _E890_)
      (std/parser/rx-parser#EscapedChar
       _ts886_
       _toks887_
       _wrap-e888_
       (lambda (_toks892_ _rtok893_)
         (_K889_ _toks892_
                 (let ((__tmp6301
                        (##direct-structure-ref
                         _rtok893_
                         '2
                         std/parser/base#token::t
                         '#f))
                       (__tmp6300
                        (##direct-structure-ref
                         _rtok893_
                         '3
                         std/parser/base#token::t
                         '#f)))
                   (declare (not safe))
                   (##structure
                    std/parser/base#token::t
                    'CharRangeChar
                    __tmp6301
                    __tmp6300))))
       _E890_)))
  (define std/parser/rx-parser#CharRangeChar::4::app
    (lambda (_ts880_ _toks881_ _wrap-e882_ _K883_ _E884_)
      (std/parser/rx-parser#Char _ts880_ _toks881_ _wrap-e882_ _K883_ _E884_)))
  (define std/parser/rx-parser#CharRangeChar::4
    (lambda (_ts871_ _toks872_ _wrap-e873_ _K874_ _E875_)
      (std/parser/rx-parser#Char
       _ts871_
       _toks872_
       _wrap-e873_
       (lambda (_toks877_ _rtok878_)
         (_K874_ _toks877_
                 (let ((__tmp6303
                        (##direct-structure-ref
                         _rtok878_
                         '2
                         std/parser/base#token::t
                         '#f))
                       (__tmp6302
                        (##direct-structure-ref
                         _rtok878_
                         '3
                         std/parser/base#token::t
                         '#f)))
                   (declare (not safe))
                   (##structure
                    std/parser/base#token::t
                    'CharRangeChar
                    __tmp6303
                    __tmp6302))))
       _E875_)))
  (define std/parser/rx-parser#CharRangeChar
    (lambda (_ts859_ _toks860_ _wrap-e861_ _K862_ _E863_)
      (std/parser/rx-parser#CharRangeChar::1
       _ts859_
       _toks860_
       _wrap-e861_
       _E863_
       (lambda (_xtoks865_)
         (std/parser/defparser#parser-rewind _ts859_ _xtoks865_ _toks860_)
         (std/parser/rx-parser#CharRangeChar::2
          _ts859_
          _toks860_
          _wrap-e861_
          _K862_
          (lambda (_xtoks867_)
            (std/parser/defparser#parser-rewind _ts859_ _xtoks867_ _toks860_)
            (std/parser/rx-parser#CharRangeChar::3
             _ts859_
             _toks860_
             _wrap-e861_
             _K862_
             (lambda (_xtoks869_)
               (std/parser/defparser#parser-rewind
                _ts859_
                _xtoks869_
                _toks860_)
               (std/parser/rx-parser#CharRangeChar::4
                _ts859_
                _toks860_
                _wrap-e861_
                _K862_
                _E863_)))))))))
  (define std/parser/rx-parser#IdentifierChar::1::app
    (lambda (_ts848_ _toks849_ _wrap-e850_ _K851_ _E852_)
      (let* ((_next854_ (std/parser/lexer#token-stream-next _ts848_))
             (_toks856_ (cons _next854_ _toks849_)))
        (if (eq? (##direct-structure-ref
                  _next854_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\})
            (_K851_ _toks856_ _next854_)
            (_E852_ _toks856_)))))
  (define std/parser/rx-parser#IdentifierChar::1
    (lambda (_ts840_ _toks841_ _wrap-e842_ _K843_ _E844_)
      (std/parser/rx-parser#IdentifierChar::1::app
       _ts840_
       _toks841_
       _wrap-e842_
       (lambda (_toks846_ . _g6304_) (_K843_ _toks846_))
       _E844_)))
  (define std/parser/rx-parser#IdentifierChar::2::app
    (lambda (_ts834_ _toks835_ _wrap-e836_ _K837_ _E838_)
      (std/parser/rx-parser#SeparatorChar
       _ts834_
       _toks835_
       _wrap-e836_
       _K837_
       _E838_)))
  (define std/parser/rx-parser#IdentifierChar::2
    (lambda (_ts814_ _toks815_ _wrap-e816_ _K817_ _E818_)
      (let ((_start820_ (std/parser/lexer#token-stream-loc _ts814_)))
        (std/parser/rx-parser#SeparatorChar
         _ts814_
         _toks815_
         _wrap-e816_
         (lambda (_toks823_ _@@824_)
           (let* ((_end826_ (std/parser/lexer#token-stream-loc _ts814_))
                  (_@loc829_
                   (std/parser/base#location-delta* _start820_ _end826_)))
             (_K817_ _toks823_
                     (let ((__tmp6305
                            (_wrap-e816_
                             ((lambda (_@@832_)
                                (std/parser/base#raise-parse-error
                                 'parse-rx
                                 '"Illegal identifier character"
                                 _@@832_))
                              _@@824_)
                             _@loc829_)))
                       (declare (not safe))
                       (##structure
                        std/parser/base#token::t
                        'IdentifierChar
                        __tmp6305
                        _@loc829_)))))
         _E818_))))
  (define std/parser/rx-parser#IdentifierChar::3::app
    (lambda (_ts808_ _toks809_ _wrap-e810_ _K811_ _E812_)
      (std/parser/rx-parser#Char _ts808_ _toks809_ _wrap-e810_ _K811_ _E812_)))
  (define std/parser/rx-parser#IdentifierChar::3
    (lambda (_ts799_ _toks800_ _wrap-e801_ _K802_ _E803_)
      (std/parser/rx-parser#Char
       _ts799_
       _toks800_
       _wrap-e801_
       (lambda (_toks805_ _rtok806_)
         (_K802_ _toks805_
                 (let ((__tmp6307
                        (##direct-structure-ref
                         _rtok806_
                         '2
                         std/parser/base#token::t
                         '#f))
                       (__tmp6306
                        (##direct-structure-ref
                         _rtok806_
                         '3
                         std/parser/base#token::t
                         '#f)))
                   (declare (not safe))
                   (##structure
                    std/parser/base#token::t
                    'IdentifierChar
                    __tmp6307
                    __tmp6306))))
       _E803_)))
  (define std/parser/rx-parser#IdentifierChar
    (lambda (_ts789_ _toks790_ _wrap-e791_ _K792_ _E793_)
      (std/parser/rx-parser#IdentifierChar::1
       _ts789_
       _toks790_
       _wrap-e791_
       _E793_
       (lambda (_xtoks795_)
         (std/parser/defparser#parser-rewind _ts789_ _xtoks795_ _toks790_)
         (std/parser/rx-parser#IdentifierChar::2
          _ts789_
          _toks790_
          _wrap-e791_
          _K792_
          (lambda (_xtoks797_)
            (std/parser/defparser#parser-rewind _ts789_ _xtoks797_ _toks790_)
            (std/parser/rx-parser#IdentifierChar::3
             _ts789_
             _toks790_
             _wrap-e791_
             _K792_
             _E793_)))))))
  (define std/parser/rx-parser#SpecialChar::1::app
    (lambda (_ts778_ _toks779_ _wrap-e780_ _K781_ _E782_)
      (let* ((_next784_ (std/parser/lexer#token-stream-next _ts778_))
             (_toks786_ (cons _next784_ _toks779_)))
        (if (eq? (##direct-structure-ref
                  _next784_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\*)
            (_K781_ _toks786_ _next784_)
            (_E782_ _toks786_)))))
  (define std/parser/rx-parser#SpecialChar::1
    (lambda (_ts769_ _toks770_ _wrap-e771_ _K772_ _E773_)
      (std/parser/rx-parser#SpecialChar::1::app
       _ts769_
       _toks770_
       _wrap-e771_
       (lambda (_toks775_ _rtok776_)
         (_K772_ _toks775_
                 (let ((__tmp6309
                        (##direct-structure-ref
                         _rtok776_
                         '2
                         std/parser/base#token::t
                         '#f))
                       (__tmp6308
                        (##direct-structure-ref
                         _rtok776_
                         '3
                         std/parser/base#token::t
                         '#f)))
                   (declare (not safe))
                   (##structure
                    std/parser/base#token::t
                    'SpecialChar
                    __tmp6309
                    __tmp6308))))
       _E773_)))
  (define std/parser/rx-parser#SpecialChar::2::app
    (lambda (_ts758_ _toks759_ _wrap-e760_ _K761_ _E762_)
      (let* ((_next764_ (std/parser/lexer#token-stream-next _ts758_))
             (_toks766_ (cons _next764_ _toks759_)))
        (if (eq? (##direct-structure-ref
                  _next764_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\+)
            (_K761_ _toks766_ _next764_)
            (_E762_ _toks766_)))))
  (define std/parser/rx-parser#SpecialChar::2
    (lambda (_ts749_ _toks750_ _wrap-e751_ _K752_ _E753_)
      (std/parser/rx-parser#SpecialChar::2::app
       _ts749_
       _toks750_
       _wrap-e751_
       (lambda (_toks755_ _rtok756_)
         (_K752_ _toks755_
                 (let ((__tmp6311
                        (##direct-structure-ref
                         _rtok756_
                         '2
                         std/parser/base#token::t
                         '#f))
                       (__tmp6310
                        (##direct-structure-ref
                         _rtok756_
                         '3
                         std/parser/base#token::t
                         '#f)))
                   (declare (not safe))
                   (##structure
                    std/parser/base#token::t
                    'SpecialChar
                    __tmp6311
                    __tmp6310))))
       _E753_)))
  (define std/parser/rx-parser#SpecialChar::3::app
    (lambda (_ts738_ _toks739_ _wrap-e740_ _K741_ _E742_)
      (let* ((_next744_ (std/parser/lexer#token-stream-next _ts738_))
             (_toks746_ (cons _next744_ _toks739_)))
        (if (eq? (##direct-structure-ref
                  _next744_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\?)
            (_K741_ _toks746_ _next744_)
            (_E742_ _toks746_)))))
  (define std/parser/rx-parser#SpecialChar::3
    (lambda (_ts729_ _toks730_ _wrap-e731_ _K732_ _E733_)
      (std/parser/rx-parser#SpecialChar::3::app
       _ts729_
       _toks730_
       _wrap-e731_
       (lambda (_toks735_ _rtok736_)
         (_K732_ _toks735_
                 (let ((__tmp6313
                        (##direct-structure-ref
                         _rtok736_
                         '2
                         std/parser/base#token::t
                         '#f))
                       (__tmp6312
                        (##direct-structure-ref
                         _rtok736_
                         '3
                         std/parser/base#token::t
                         '#f)))
                   (declare (not safe))
                   (##structure
                    std/parser/base#token::t
                    'SpecialChar
                    __tmp6313
                    __tmp6312))))
       _E733_)))
  (define std/parser/rx-parser#SpecialChar::4::app
    (lambda (_ts718_ _toks719_ _wrap-e720_ _K721_ _E722_)
      (let* ((_next724_ (std/parser/lexer#token-stream-next _ts718_))
             (_toks726_ (cons _next724_ _toks719_)))
        (if (eq? (##direct-structure-ref
                  _next724_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\.)
            (_K721_ _toks726_ _next724_)
            (_E722_ _toks726_)))))
  (define std/parser/rx-parser#SpecialChar::4
    (lambda (_ts709_ _toks710_ _wrap-e711_ _K712_ _E713_)
      (std/parser/rx-parser#SpecialChar::4::app
       _ts709_
       _toks710_
       _wrap-e711_
       (lambda (_toks715_ _rtok716_)
         (_K712_ _toks715_
                 (let ((__tmp6315
                        (##direct-structure-ref
                         _rtok716_
                         '2
                         std/parser/base#token::t
                         '#f))
                       (__tmp6314
                        (##direct-structure-ref
                         _rtok716_
                         '3
                         std/parser/base#token::t
                         '#f)))
                   (declare (not safe))
                   (##structure
                    std/parser/base#token::t
                    'SpecialChar
                    __tmp6315
                    __tmp6314))))
       _E713_)))
  (define std/parser/rx-parser#SpecialChar::5::app
    (lambda (_ts703_ _toks704_ _wrap-e705_ _K706_ _E707_)
      (std/parser/rx-parser#SeparatorChar
       _ts703_
       _toks704_
       _wrap-e705_
       _K706_
       _E707_)))
  (define std/parser/rx-parser#SpecialChar::5
    (lambda (_ts694_ _toks695_ _wrap-e696_ _K697_ _E698_)
      (std/parser/rx-parser#SeparatorChar
       _ts694_
       _toks695_
       _wrap-e696_
       (lambda (_toks700_ _rtok701_)
         (_K697_ _toks700_
                 (let ((__tmp6317
                        (##direct-structure-ref
                         _rtok701_
                         '2
                         std/parser/base#token::t
                         '#f))
                       (__tmp6316
                        (##direct-structure-ref
                         _rtok701_
                         '3
                         std/parser/base#token::t
                         '#f)))
                   (declare (not safe))
                   (##structure
                    std/parser/base#token::t
                    'SpecialChar
                    __tmp6317
                    __tmp6316))))
       _E698_)))
  (define std/parser/rx-parser#SpecialChar
    (lambda (_ts680_ _toks681_ _wrap-e682_ _K683_ _E684_)
      (std/parser/rx-parser#SpecialChar::1
       _ts680_
       _toks681_
       _wrap-e682_
       _K683_
       (lambda (_xtoks686_)
         (std/parser/defparser#parser-rewind _ts680_ _xtoks686_ _toks681_)
         (std/parser/rx-parser#SpecialChar::2
          _ts680_
          _toks681_
          _wrap-e682_
          _K683_
          (lambda (_xtoks688_)
            (std/parser/defparser#parser-rewind _ts680_ _xtoks688_ _toks681_)
            (std/parser/rx-parser#SpecialChar::3
             _ts680_
             _toks681_
             _wrap-e682_
             _K683_
             (lambda (_xtoks690_)
               (std/parser/defparser#parser-rewind
                _ts680_
                _xtoks690_
                _toks681_)
               (std/parser/rx-parser#SpecialChar::4
                _ts680_
                _toks681_
                _wrap-e682_
                _K683_
                (lambda (_xtoks692_)
                  (std/parser/defparser#parser-rewind
                   _ts680_
                   _xtoks692_
                   _toks681_)
                  (std/parser/rx-parser#SpecialChar::5
                   _ts680_
                   _toks681_
                   _wrap-e682_
                   _K683_
                   _E684_)))))))))))
  (define std/parser/rx-parser#SeparatorChar::1::app
    (lambda (_ts669_ _toks670_ _wrap-e671_ _K672_ _E673_)
      (let* ((_next675_ (std/parser/lexer#token-stream-next _ts669_))
             (_toks677_ (cons _next675_ _toks670_)))
        (if (eq? (##direct-structure-ref
                  _next675_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\()
            (_K672_ _toks677_ _next675_)
            (_E673_ _toks677_)))))
  (define std/parser/rx-parser#SeparatorChar::1
    (lambda (_ts660_ _toks661_ _wrap-e662_ _K663_ _E664_)
      (std/parser/rx-parser#SeparatorChar::1::app
       _ts660_
       _toks661_
       _wrap-e662_
       (lambda (_toks666_ _rtok667_)
         (_K663_ _toks666_
                 (let ((__tmp6319
                        (##direct-structure-ref
                         _rtok667_
                         '2
                         std/parser/base#token::t
                         '#f))
                       (__tmp6318
                        (##direct-structure-ref
                         _rtok667_
                         '3
                         std/parser/base#token::t
                         '#f)))
                   (declare (not safe))
                   (##structure
                    std/parser/base#token::t
                    'SeparatorChar
                    __tmp6319
                    __tmp6318))))
       _E664_)))
  (define std/parser/rx-parser#SeparatorChar::2::app
    (lambda (_ts649_ _toks650_ _wrap-e651_ _K652_ _E653_)
      (let* ((_next655_ (std/parser/lexer#token-stream-next _ts649_))
             (_toks657_ (cons _next655_ _toks650_)))
        (if (eq? (##direct-structure-ref
                  _next655_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\))
            (_K652_ _toks657_ _next655_)
            (_E653_ _toks657_)))))
  (define std/parser/rx-parser#SeparatorChar::2
    (lambda (_ts640_ _toks641_ _wrap-e642_ _K643_ _E644_)
      (std/parser/rx-parser#SeparatorChar::2::app
       _ts640_
       _toks641_
       _wrap-e642_
       (lambda (_toks646_ _rtok647_)
         (_K643_ _toks646_
                 (let ((__tmp6321
                        (##direct-structure-ref
                         _rtok647_
                         '2
                         std/parser/base#token::t
                         '#f))
                       (__tmp6320
                        (##direct-structure-ref
                         _rtok647_
                         '3
                         std/parser/base#token::t
                         '#f)))
                   (declare (not safe))
                   (##structure
                    std/parser/base#token::t
                    'SeparatorChar
                    __tmp6321
                    __tmp6320))))
       _E644_)))
  (define std/parser/rx-parser#SeparatorChar::3::app
    (lambda (_ts629_ _toks630_ _wrap-e631_ _K632_ _E633_)
      (let* ((_next635_ (std/parser/lexer#token-stream-next _ts629_))
             (_toks637_ (cons _next635_ _toks630_)))
        (if (eq? (##direct-structure-ref
                  _next635_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\|)
            (_K632_ _toks637_ _next635_)
            (_E633_ _toks637_)))))
  (define std/parser/rx-parser#SeparatorChar::3
    (lambda (_ts620_ _toks621_ _wrap-e622_ _K623_ _E624_)
      (std/parser/rx-parser#SeparatorChar::3::app
       _ts620_
       _toks621_
       _wrap-e622_
       (lambda (_toks626_ _rtok627_)
         (_K623_ _toks626_
                 (let ((__tmp6323
                        (##direct-structure-ref
                         _rtok627_
                         '2
                         std/parser/base#token::t
                         '#f))
                       (__tmp6322
                        (##direct-structure-ref
                         _rtok627_
                         '3
                         std/parser/base#token::t
                         '#f)))
                   (declare (not safe))
                   (##structure
                    std/parser/base#token::t
                    'SeparatorChar
                    __tmp6323
                    __tmp6322))))
       _E624_)))
  (define std/parser/rx-parser#SeparatorChar::4::app
    (lambda (_ts609_ _toks610_ _wrap-e611_ _K612_ _E613_)
      (let* ((_next615_ (std/parser/lexer#token-stream-next _ts609_))
             (_toks617_ (cons _next615_ _toks610_)))
        (if (eq? (##direct-structure-ref
                  _next615_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\{)
            (_K612_ _toks617_ _next615_)
            (_E613_ _toks617_)))))
  (define std/parser/rx-parser#SeparatorChar::4
    (lambda (_ts600_ _toks601_ _wrap-e602_ _K603_ _E604_)
      (std/parser/rx-parser#SeparatorChar::4::app
       _ts600_
       _toks601_
       _wrap-e602_
       (lambda (_toks606_ _rtok607_)
         (_K603_ _toks606_
                 (let ((__tmp6325
                        (##direct-structure-ref
                         _rtok607_
                         '2
                         std/parser/base#token::t
                         '#f))
                       (__tmp6324
                        (##direct-structure-ref
                         _rtok607_
                         '3
                         std/parser/base#token::t
                         '#f)))
                   (declare (not safe))
                   (##structure
                    std/parser/base#token::t
                    'SeparatorChar
                    __tmp6325
                    __tmp6324))))
       _E604_)))
  (define std/parser/rx-parser#SeparatorChar::5::app
    (lambda (_ts589_ _toks590_ _wrap-e591_ _K592_ _E593_)
      (let* ((_next595_ (std/parser/lexer#token-stream-next _ts589_))
             (_toks597_ (cons _next595_ _toks590_)))
        (if (eq? (##direct-structure-ref
                  _next595_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\})
            (_K592_ _toks597_ _next595_)
            (_E593_ _toks597_)))))
  (define std/parser/rx-parser#SeparatorChar::5
    (lambda (_ts580_ _toks581_ _wrap-e582_ _K583_ _E584_)
      (std/parser/rx-parser#SeparatorChar::5::app
       _ts580_
       _toks581_
       _wrap-e582_
       (lambda (_toks586_ _rtok587_)
         (_K583_ _toks586_
                 (let ((__tmp6327
                        (##direct-structure-ref
                         _rtok587_
                         '2
                         std/parser/base#token::t
                         '#f))
                       (__tmp6326
                        (##direct-structure-ref
                         _rtok587_
                         '3
                         std/parser/base#token::t
                         '#f)))
                   (declare (not safe))
                   (##structure
                    std/parser/base#token::t
                    'SeparatorChar
                    __tmp6327
                    __tmp6326))))
       _E584_)))
  (define std/parser/rx-parser#SeparatorChar
    (lambda (_ts566_ _toks567_ _wrap-e568_ _K569_ _E570_)
      (std/parser/rx-parser#SeparatorChar::1
       _ts566_
       _toks567_
       _wrap-e568_
       _K569_
       (lambda (_xtoks572_)
         (std/parser/defparser#parser-rewind _ts566_ _xtoks572_ _toks567_)
         (std/parser/rx-parser#SeparatorChar::2
          _ts566_
          _toks567_
          _wrap-e568_
          _K569_
          (lambda (_xtoks574_)
            (std/parser/defparser#parser-rewind _ts566_ _xtoks574_ _toks567_)
            (std/parser/rx-parser#SeparatorChar::3
             _ts566_
             _toks567_
             _wrap-e568_
             _K569_
             (lambda (_xtoks576_)
               (std/parser/defparser#parser-rewind
                _ts566_
                _xtoks576_
                _toks567_)
               (std/parser/rx-parser#SeparatorChar::4
                _ts566_
                _toks567_
                _wrap-e568_
                _K569_
                (lambda (_xtoks578_)
                  (std/parser/defparser#parser-rewind
                   _ts566_
                   _xtoks578_
                   _toks567_)
                  (std/parser/rx-parser#SeparatorChar::5
                   _ts566_
                   _toks567_
                   _wrap-e568_
                   _K569_
                   _E570_)))))))))))
  (define std/parser/rx-parser#SuffixOpChar::1::app
    (lambda (_ts555_ _toks556_ _wrap-e557_ _K558_ _E559_)
      (let* ((_next561_ (std/parser/lexer#token-stream-next _ts555_))
             (_toks563_ (cons _next561_ _toks556_)))
        (if (eq? (##direct-structure-ref
                  _next561_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\*)
            (_K558_ _toks563_ _next561_)
            (_E559_ _toks563_)))))
  (define std/parser/rx-parser#SuffixOpChar::1
    (lambda (_ts546_ _toks547_ _wrap-e548_ _K549_ _E550_)
      (std/parser/rx-parser#SuffixOpChar::1::app
       _ts546_
       _toks547_
       _wrap-e548_
       (lambda (_toks552_ _rtok553_)
         (_K549_ _toks552_
                 (let ((__tmp6329
                        (##direct-structure-ref
                         _rtok553_
                         '2
                         std/parser/base#token::t
                         '#f))
                       (__tmp6328
                        (##direct-structure-ref
                         _rtok553_
                         '3
                         std/parser/base#token::t
                         '#f)))
                   (declare (not safe))
                   (##structure
                    std/parser/base#token::t
                    'SuffixOpChar
                    __tmp6329
                    __tmp6328))))
       _E550_)))
  (define std/parser/rx-parser#SuffixOpChar::2::app
    (lambda (_ts535_ _toks536_ _wrap-e537_ _K538_ _E539_)
      (let* ((_next541_ (std/parser/lexer#token-stream-next _ts535_))
             (_toks543_ (cons _next541_ _toks536_)))
        (if (eq? (##direct-structure-ref
                  _next541_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\+)
            (_K538_ _toks543_ _next541_)
            (_E539_ _toks543_)))))
  (define std/parser/rx-parser#SuffixOpChar::2
    (lambda (_ts526_ _toks527_ _wrap-e528_ _K529_ _E530_)
      (std/parser/rx-parser#SuffixOpChar::2::app
       _ts526_
       _toks527_
       _wrap-e528_
       (lambda (_toks532_ _rtok533_)
         (_K529_ _toks532_
                 (let ((__tmp6331
                        (##direct-structure-ref
                         _rtok533_
                         '2
                         std/parser/base#token::t
                         '#f))
                       (__tmp6330
                        (##direct-structure-ref
                         _rtok533_
                         '3
                         std/parser/base#token::t
                         '#f)))
                   (declare (not safe))
                   (##structure
                    std/parser/base#token::t
                    'SuffixOpChar
                    __tmp6331
                    __tmp6330))))
       _E530_)))
  (define std/parser/rx-parser#SuffixOpChar::3::app
    (lambda (_ts515_ _toks516_ _wrap-e517_ _K518_ _E519_)
      (let* ((_next521_ (std/parser/lexer#token-stream-next _ts515_))
             (_toks523_ (cons _next521_ _toks516_)))
        (if (eq? (##direct-structure-ref
                  _next521_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '#\?)
            (_K518_ _toks523_ _next521_)
            (_E519_ _toks523_)))))
  (define std/parser/rx-parser#SuffixOpChar::3
    (lambda (_ts505_ _toks506_ _wrap-e507_ _K508_ _E509_)
      (std/parser/rx-parser#SuffixOpChar::3::app
       _ts505_
       _toks506_
       _wrap-e507_
       (lambda (_toks511_ _rtok512_)
         (_K508_ _toks511_
                 (let ((__tmp6333
                        (##direct-structure-ref
                         _rtok512_
                         '2
                         std/parser/base#token::t
                         '#f))
                       (__tmp6332
                        (##direct-structure-ref
                         _rtok512_
                         '3
                         std/parser/base#token::t
                         '#f)))
                   (declare (not safe))
                   (##structure
                    std/parser/base#token::t
                    'SuffixOpChar
                    __tmp6333
                    __tmp6332))))
       _E509_)))
  (define std/parser/rx-parser#SuffixOpChar
    (lambda (_ts494_ _toks495_ _wrap-e496_ _K497_ _E498_)
      (std/parser/rx-parser#SuffixOpChar::1
       _ts494_
       _toks495_
       _wrap-e496_
       _K497_
       (lambda (_xtoks500_)
         (std/parser/defparser#parser-rewind _ts494_ _xtoks500_ _toks495_)
         (std/parser/rx-parser#SuffixOpChar::2
          _ts494_
          _toks495_
          _wrap-e496_
          _K497_
          (lambda (_xtoks503_)
            (std/parser/defparser#parser-rewind _ts494_ _xtoks503_ _toks495_)
            (std/parser/rx-parser#SuffixOpChar::3
             _ts494_
             _toks495_
             _wrap-e496_
             _K497_
             _E498_)))))))
  (define std/parser/rx-parser#Char
    (lambda (_ts477_ _toks479_ _wrap-e481_ _K483_ _E485_)
      (let* ((_next488_ (std/parser/lexer#token-stream-next _ts477_))
             (_toks491_ (cons _next488_ _toks479_)))
        (if (eq? (##direct-structure-ref
                  _next488_
                  '1
                  std/parser/base#token::t
                  '#f)
                 'Char)
            (_K483_ _toks491_ _next488_)
            (_E485_ _toks491_)))))
  (define std/parser/rx-parser#escape-char
    (lambda (_char472_)
      (let ((_$e474_ _char472_))
        (if (eq? '#\n _$e474_)
            '#\newline
            (if (eq? '#\r _$e474_)
                '#\return
                (if (eq? '#\t _$e474_) '#\tab _char472_))))))
  (define std/parser/rx-parser#make-char-range
    (lambda (_char-start460_ _char-end461_ _loc462_)
      (let ((_start464_ (char->integer _char-start460_))
            (_end465_ (char->integer _char-end461_)))
        (if (fx<= _start464_ _end465_)
            (let _lp467_ ((_k469_ _start464_) (_chars470_ '()))
              (if (fx<= _k469_ _end465_)
                  (_lp467_ (fx+ _k469_ '1)
                           (cons (integer->char _k469_) _chars470_))
                  (reverse _chars470_)))
            (std/parser/base#raise-parse-error
             'parse-rx
             '"Illegal character range"
             (let ((__tmp6334 (cons _char-start460_ (cons _char-end461_ '()))))
               (declare (not safe))
               (##structure
                std/parser/base#token::t
                'CharRange
                __tmp6334
                _loc462_))))))))
