(declare (block) (standard-bindings) (extended-bindings))
(begin
  (define std/parser/grammar-reader#read-module-body
    (lambda (_port1628_)
      (let _lp1630_ ((_body1632_ '()))
        (let ((_next1634_ (read-syntax _port1628_)))
          (if (eof-object? _next1634_)
              (gx#raise-syntax-error
               '#f
               '"Bad syntax; no parser or lexer definitions"
               (std/parser/grammar-reader#read-error-token _port1628_))
              (if (or (eq? (gx#stx-e _next1634_) '%%parser)
                      (eq? (gx#stx-e _next1634_) '%%lexer))
                  (std/parser/grammar-reader#read-module-section
                   _port1628_
                   _body1632_
                   (let ((__tmp5446 (gx#stx-e _next1634_)))
                     (declare (not safe))
                     (##structure std/parser/base#token::t '$$ __tmp5446 '#f)))
                  (_lp1630_ (cons _next1634_ _body1632_))))))))
  (define std/parser/grammar-reader#read-error-token
    (lambda (_port1623_)
      (let ((_name1625_ (let () (declare (not safe)) (##port-name _port1623_)))
            (_loc1626_ (std/parser/stream#port-location _port1623_)))
        (let ((__tmp5448 (cons 'read-module-body (cons _name1625_ '())))
              (__tmp5447
               (std/parser/base#location->source-location _loc1626_)))
          (declare (not safe))
          (##structure AST::t __tmp5448 __tmp5447)))))
  (define std/parser/grammar-reader#read-module-section
    (lambda (_port1617_ _body1618_ _tok1619_)
      (let ((_e1621_ (##direct-structure-ref
                      _tok1619_
                      '2
                      std/parser/base#token::t
                      '#f)))
        (if (eof-object? _e1621_)
            (reverse _body1618_)
            (if (eq? _e1621_ '%%parser)
                (std/parser/grammar-reader#read-parser-section
                 _port1617_
                 _body1618_)
                (if (eq? _e1621_ '%%lexer)
                    (std/parser/grammar-reader#read-lexer-section
                     _port1617_
                     _body1618_)
                    (gx#raise-syntax-error
                     '#f
                     '"Bad syntax; unexpected token"
                     (std/parser/base#token->syntax _tok1619_))))))))
  (define std/parser/grammar-reader#read-parser-section
    (lambda (_port1614_ _body1615_)
      (std/parser/grammar-reader#read-%%-section
       _port1614_
       _body1615_
       'defparser
       std/parser/grammar-reader#read-parser-body)))
  (define std/parser/grammar-reader#read-lexer-section
    (lambda (_port1611_ _body1612_)
      (std/parser/grammar-reader#read-%%-section
       _port1611_
       _body1612_
       'deflexer
       std/parser/grammar-reader#read-lexer-body)))
  (define std/parser/grammar-reader#read-%%-section
    (lambda (_port1397_ _body1398_ _defmacro1399_ _read-body-e1400_)
      (letrec ((_raise-e1402_
                (lambda (_exn1604_)
                  (if (let ()
                        (declare (not safe))
                        (##structure-instance-of?
                         _exn1604_
                         'std/parser/base#parse-error::t))
                      (apply gx#raise-syntax-error
                             '#f
                             (string-append
                              '"Bad syntax; parse error: "
                              (let ((_$e1606_ (error-trace _exn1604_)))
                                (if _$e1606_
                                    ((lambda (_where1609_)
                                       (string-append
                                        (symbol->string _where1609_)
                                        '" :"))
                                     _$e1606_)
                                    '""))
                              (error-message _exn1604_))
                             (map std/parser/base#token->syntax
                                  (error-irritants _exn1604_)))
                      (raise _exn1604_)))))
        (let ((_g5449_ (std/parser/grammar-reader#read-section-head
                        _port1397_)))
          (begin
            (let ((_g5450_ (let ()
                             (declare (not safe))
                             (if (##values? _g5449_)
                                 (##vector-length _g5449_)
                                 1))))
              (if (not (let () (declare (not safe)) (##fx= _g5450_ 2)))
                  (error "Context expects 2 values" _g5450_)))
            (let ((_macro-id1404_
                   (let () (declare (not safe)) (##vector-ref _g5449_ 0)))
                  (_opts1405_
                   (let () (declare (not safe)) (##vector-ref _g5449_ 1))))
              (let ((_g5451_ (with-exception-catcher
                              _raise-e1402_
                              (lambda () (_read-body-e1400_ _port1397_)))))
                (begin
                  (let ((_g5452_ (let ()
                                   (declare (not safe))
                                   (if (##values? _g5451_)
                                       (##vector-length _g5451_)
                                       1))))
                    (if (not (let () (declare (not safe)) (##fx= _g5452_ 2)))
                        (error "Context expects 2 values" _g5452_)))
                  (let ((_rules1408_
                         (let ()
                           (declare (not safe))
                           (##vector-ref _g5451_ 0)))
                        (_end1409_
                         (let ()
                           (declare (not safe))
                           (##vector-ref _g5451_ 1))))
                    (let* ((_g14111418_
                            (lambda (_g14121415_)
                              (gx#raise-syntax-error
                               '#f
                               '"Bad syntax"
                               _g14121415_)))
                           (_g14101601_
                            (lambda (_g14121421_)
                              ((lambda (_L1423_)
                                 (let ()
                                   (let* ((_g14351442_
                                           (lambda (_g14361439_)
                                             (gx#raise-syntax-error
                                              '#f
                                              '"Bad syntax"
                                              _g14361439_)))
                                          (_g14341598_
                                           (lambda (_g14361445_)
                                             ((lambda (_L1447_)
                                                (let ()
                                                  (let* ((_g14571473_
                                                          (lambda (_g14581470_)
                                                            (gx#raise-syntax-error
                                                             '#f
                                                             '"Bad syntax"
                                                             _g14581470_)))
                                                         (_g14561595_
                                                          (lambda (_g14581476_)
                                                            (if (gx#stx-pair/null?
;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
                         _g14581476_)
                        (let ((_g5453_ (gx#syntax-split-splice
                                        _g14581476_
                                        '0)))
                          (begin
                            (let ((_g5454_ (let ()
                                             (declare (not safe))
                                             (if (##values? _g5453_)
                                                 (##vector-length _g5453_)
                                                 1))))
                              (if (not (let ()
                                         (declare (not safe))
                                         (##fx= _g5454_ 2)))
                                  (error "Context expects 2 values" _g5454_)))
                            (let ((_target14601478_
                                   (let ()
                                     (declare (not safe))
                                     (##vector-ref _g5453_ 0)))
                                  (_tl14621480_
                                   (let ()
                                     (declare (not safe))
                                     (##vector-ref _g5453_ 1))))
                              (if (gx#stx-null? _tl14621480_)
                                  (letrec ((_loop14631483_
                                            (lambda (_hd14611486_
                                                     _macro-opt14671488_)
                                              (if (gx#stx-pair? _hd14611486_)
                                                  (let ((_e14641491_
                                                         (gx#syntax-e
                                                          _hd14611486_)))
                                                    (let ((_lp-hd14651494_
                                                           (let ()
                                                             (declare
                                                               (not safe))
                                                             (##car _e14641491_)))
                                                          (_lp-tl14661496_
                                                           (let ()
                                                             (declare
                                                               (not safe))
                                                             (##cdr _e14641491_))))
                                                      (_loop14631483_
                                                       _lp-tl14661496_
                                                       (cons _lp-hd14651494_
                                                             _macro-opt14671488_))))
                                                  (let ((_macro-opt14681499_
                                                         (reverse _macro-opt14671488_)))
                                                    ((lambda (_L1502_)
                                                       (let ()
                                                         (let* ((_g15161532_
;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
                         (lambda (_g15171529_)
                           (gx#raise-syntax-error
                            '#f
                            '"Bad syntax"
                            _g15171529_)))
                        (_g15151592_
                         (lambda (_g15171535_)
                           (if (gx#stx-pair/null? _g15171535_)
                               (let ((_g5455_ (gx#syntax-split-splice
                                               _g15171535_
                                               '0)))
                                 (begin
                                   (let ((_g5456_ (let ()
                                                    (declare (not safe))
                                                    (if (##values? _g5455_)
                                                        (##vector-length
                                                         _g5455_)
                                                        1))))
                                     (if (not (let ()
                                                (declare (not safe))
                                                (##fx= _g5456_ 2)))
                                         (error "Context expects 2 values"
                                                _g5456_)))
                                   (let ((_target15191537_
                                          (let ()
                                            (declare (not safe))
                                            (##vector-ref _g5455_ 0)))
                                         (_tl15211539_
                                          (let ()
                                            (declare (not safe))
                                            (##vector-ref _g5455_ 1))))
                                     (if (gx#stx-null? _tl15211539_)
                                         (letrec ((_loop15221542_
                                                   (lambda (_hd15201545_
                                                            _rule15261547_)
                                                     (if (gx#stx-pair?
                                                          _hd15201545_)
                                                         (let ((_e15231550_
                                                                (gx#syntax-e
;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
                         _hd15201545_)))
                   (let ((_lp-hd15241553_
                          (let () (declare (not safe)) (##car _e15231550_)))
                         (_lp-tl15251555_
                          (let () (declare (not safe)) (##cdr _e15231550_))))
                     (_loop15221542_
                      _lp-tl15251555_
                      (cons _lp-hd15241553_ _rule15261547_))))
                 (let ((_rule15271558_ (reverse _rule15261547_)))
                   ((lambda (_L1561_)
                      (let ()
                        (let ()
                          (let ((_defn1590_
                                 (gx#stx-wrap-source
                                  (cons _L1423_
                                        (cons _L1447_
                                              (foldr1 (lambda (_g15751580_
                                                               _g15761582_)
                                                        (cons _g15751580_
                                                              _g15761582_))
                                                      (foldr1 (lambda (_g15771585_
;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
                               _g15781587_)
                        (cons _g15771585_ _g15781587_))
                      '()
                      _L1561_)
              _L1502_)))
;;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
                                  (gx#stx-source _L1447_))))
                            (std/parser/grammar-reader#read-module-section
                             _port1397_
                             (cons _defn1590_ _body1398_)
                             _end1409_)))))
                    _rule15271558_))))))
;;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
                                           (_loop15221542_
                                            _target15191537_
                                            '()))
                                         (_g15161532_ _g15171535_)))))
                               (_g15161532_ _g15171535_)))))
                   (_g15151592_ _rules1408_))))
;;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
                                                     _macro-opt14681499_))))))
                                    (_loop14631483_ _target14601478_ '()))
                                  (_g14571473_ _g14581476_)))))
                        (_g14571473_ _g14581476_)))))
;;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
                                                    (_g14561595_ _opts1405_))))
                                              _g14361445_))))
                                     (_g14341598_ _macro-id1404_))))
                               _g14121421_))))
                      (_g14101601_ _defmacro1399_)))))))))))
  (define std/parser/grammar-reader#read-section-head
    (lambda (_port1377_)
      (letrec ((_read-id1379_
                (lambda ()
                  (let ((_next1390_ (peek-char _port1377_)))
                    (if (or (eof-object? _next1390_)
                            (memq _next1390_ '(#\newline #\# #\;)))
                        (gx#raise-syntax-error
                         '#f
                         '"Bad syntax; missing section id"
                         (std/parser/grammar-reader#read-error-token
                          _port1377_)
                         _next1390_)
                        (if (char-whitespace? _next1390_)
                            (begin (read-char _port1377_) (_read-id1379_))
                            (let ((_id1395_ (read-syntax _port1377_)))
                              (if (gx#identifier? _id1395_)
                                  '#!void
                                  (gx#raise-syntax-error
                                   '#f
                                   '"Bad syntax; expected identifier"
                                   _id1395_))
                              (_read-opts1380_ _id1395_ '())))))))
               (_read-opts1380_
                (lambda (_id1382_ _opts1383_)
                  (let ((_next1385_ (peek-char _port1377_)))
                    (if (eof-object? _next1385_)
                        (gx#raise-syntax-error
                         '#f
                         '"Bad syntax; premature end of input"
                         (std/parser/grammar-reader#read-error-token
                          _port1377_))
                        (if (eq? '#\newline _next1385_)
                            (begin
                              (read-char _port1377_)
                              (values _id1382_ (reverse _opts1383_)))
                            (if (eq? _next1385_ '#\;)
                                (begin
                                  (read-line _port1377_)
                                  (values _id1382_ (reverse _opts1383_)))
                                (if (eq? _next1385_ '#\#)
                                    (gx#raise-syntax-error
                                     '#f
                                     '"Bad syntax; unexpected character"
                                     (std/parser/grammar-reader#read-error-token
                                      _port1377_)
                                     _next1385_)
                                    (if (char-whitespace? _next1385_)
                                        (begin
                                          (read-char _port1377_)
                                          (_read-opts1380_
                                           _id1382_
                                           _opts1383_))
                                        (let ((_opt1387_
                                               (read-syntax _port1377_)))
                                          (_read-opts1380_
                                           _id1382_
                                           (cons _opt1387_
                                                 _opts1383_))))))))))))
        (_read-id1379_))))
  (define std/parser/grammar-reader#raise-unexpected-token
    (lambda (_tok1375_)
      (gx#raise-syntax-error
       '#f
       '"Bad syntax; unexpected token"
       (std/parser/base#token->syntax _tok1375_))))
  (define std/parser/grammar-reader#read-parser-body
    (lambda (_port1217_)
      (letrec ((_locat-delta*1219_
                (lambda (_start1372_ _end1373_)
                  (std/parser/base#location->source-location
                   (std/parser/base#location-delta*
                    (##direct-structure-ref
                     _start1372_
                     '3
                     std/parser/base#token::t
                     '#f)
                    (##direct-structure-ref
                     _end1373_
                     '3
                     std/parser/base#token::t
                     '#f)))))
               (_make-rule1220_
                (lambda (_rule-id1367_ _prods1368_ _start1369_ _end1370_)
                  (let ((__tmp5458 (cons _rule-id1367_ (reverse _prods1368_)))
                        (__tmp5457 (_locat-delta*1219_ _start1369_ _end1370_)))
                    (declare (not safe))
                    (##structure AST::t __tmp5458 __tmp5457))))
               (_parse-rule1221_
                (lambda (_ts1300_ _K1301_ _E1302_)
                  (let* ((_rule1304_
                          (std/parser/grammar-reader#parse-rule-head__0
                           _ts1300_))
                         (_$e1306_
                          (##direct-structure-ref
                           _rule1304_
                           '1
                           std/parser/base#token::t
                           '#f)))
                    (if (eq? 'Rule _$e1306_)
                        (let* ((_g13091323_
                                (lambda (_g13101320_)
                                  (gx#raise-syntax-error
                                   '#f
                                   '"Bad syntax"
                                   _g13101320_)))
                               (_g13081364_
                                (lambda (_g13101326_)
                                  (if (gx#stx-pair? _g13101326_)
                                      (let ((_e13131328_
                                             (gx#syntax-e _g13101326_)))
                                        (let ((_hd13141331_
                                               (let ()
                                                 (declare (not safe))
                                                 (##car _e13131328_)))
                                              (_tl13151333_
                                               (let ()
                                                 (declare (not safe))
                                                 (##cdr _e13131328_))))
                                          (if (gx#stx-pair? _tl13151333_)
                                              (let ((_e13161336_
                                                     (gx#syntax-e
                                                      _tl13151333_)))
                                                (let ((_hd13171339_
                                                       (let ()
                                                         (declare (not safe))
                                                         (##car _e13161336_)))
                                                      (_tl13181341_
                                                       (let ()
                                                         (declare (not safe))
                                                         (##cdr _e13161336_))))
                                                  (if (gx#stx-null?
                                                       _tl13181341_)
                                                      ((lambda (_L1344_
                                                                _L1345_)
                                                         (let ()
                                                           (_parse-rule-k1222_
                                                            _ts1300_
                                                            _rule1304_
                                                            _L1345_
                                                            _L1344_
                                                            '()
                                                            _K1301_
                                                            _E1302_)))
                                                       _hd13171339_
                                                       _hd13141331_)
                                                      (_g13091323_
                                                       _g13101326_))))
                                              (_g13091323_ _g13101326_))))
                                      (_g13091323_ _g13101326_)))))
                          (_g13081364_
                           (##direct-structure-ref
                            _rule1304_
                            '2
                            std/parser/base#token::t
                            '#f)))
                        (_E1302_ _ts1300_ _rule1304_ '#f)))))
               (_parse-rule-k1222_
                (lambda (_ts1284_
                         _start1285_
                         _rule-id1286_
                         _head1287_
                         _prods1288_
                         _K1289_
                         _E1290_)
                  (let* ((_next1292_
                          (std/parser/lexer#token-stream-next _ts1284_))
                         (_$e1294_
                          (##direct-structure-ref
                           _next1292_
                           '1
                           std/parser/base#token::t
                           '#f)))
                    (if (eq? '$$ _$e1294_)
                        (let ((_$e1297_
                               (##direct-structure-ref
                                _next1292_
                                '2
                                std/parser/base#token::t
                                '#f)))
                          (if (eq? 'ACTION _$e1297_)
                              (_parse-rule-action1223_
                               _ts1284_
                               _start1285_
                               _rule-id1286_
                               _head1287_
                               _prods1288_
                               _K1289_
                               _E1290_)
                              (if (eq? 'ALTRULE _$e1297_)
                                  (_parse-rule-altrule1224_
                                   _ts1284_
                                   _start1285_
                                   _rule-id1286_
                                   (cons _head1287_ _prods1288_)
                                   _K1289_
                                   _E1290_)
                                  (if (eq? 'ENDRULE _$e1297_)
                                      (_K1289_ _ts1284_
                                               (_make-rule1220_
                                                _rule-id1286_
                                                (cons _head1287_ _prods1288_)
                                                _start1285_
                                                _next1292_))
                                      (_E1290_ _ts1284_
                                               _next1292_
                                               (_make-rule1220_
                                                _rule-id1286_
                                                (cons _head1287_ _prods1288_)
                                                _start1285_
                                                _next1292_))))))
                        (std/parser/grammar-reader#raise-unexpected-token
                         _next1292_)))))
               (_parse-rule-action1223_
                (lambda (_ts1263_
                         _start1264_
                         _rule-id1265_
                         _head1266_
                         _prods1267_
                         _K1268_
                         _E1269_)
                  (let ((_action1271_ (read-syntax _port1217_)))
                    (if (eof-object? _action1271_)
                        (gx#raise-syntax-error
                         '#f
                         '"Bad syntax; unexpected end of input"
                         _rule-id1265_)
                        (let* ((_ts1273_
                                (std/parser/grammar-reader#lex-parser
                                 _port1217_))
                               (_next1275_
                                (std/parser/lexer#token-stream-next _ts1273_)))
                          (let ((_$e1278_
                                 (##direct-structure-ref
                                  _next1275_
                                  '1
                                  std/parser/base#token::t
                                  '#f)))
                            (if (eq? '$$ _$e1278_)
                                (let ((_$e1281_
                                       (##direct-structure-ref
                                        _next1275_
                                        '2
                                        std/parser/base#token::t
                                        '#f)))
                                  (if (eq? 'ACTION _$e1281_)
                                      (std/parser/grammar-reader#raise-unexpected-token
                                       _next1275_)
                                      (if (eq? 'ALTRULE _$e1281_)
                                          (_parse-rule-altrule1224_
                                           _ts1273_
                                           _start1264_
                                           _rule-id1265_
                                           (cons _action1271_
                                                 (cons '=>
                                                       (cons _head1266_
                                                             _prods1267_)))
                                           _K1268_
                                           _E1269_)
                                          (if (eq? 'ENDRULE _$e1281_)
                                              (_K1268_ _ts1273_
                                                       (_make-rule1220_
                                                        _rule-id1265_
                                                        (cons _action1271_
                                                              (cons '=>
;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
                            (cons _head1266_ _prods1267_)))
                _start1264_
                _next1275_))
;;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
                                              (_E1269_ _ts1273_
                                                       _next1275_
                                                       (_make-rule1220_
                                                        _rule-id1265_
                                                        (cons _action1271_
                                                              (cons '=>
;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
                            (cons _head1266_ _prods1267_)))
                _start1264_
                _next1275_))))))
;;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
                                (std/parser/grammar-reader#raise-unexpected-token
                                 _next1275_))))))))
               (_parse-rule-altrule1224_
                (lambda (_ts1240_
                         _start1241_
                         _rule-id1242_
                         _prods1243_
                         _K1244_
                         _E1245_)
                  (let* ((_prod1247_
                          (std/parser/grammar-reader#parse-rule-prod__0
                           _ts1240_))
                         (_$e1249_
                          (##direct-structure-ref
                           _prod1247_
                           '1
                           std/parser/base#token::t
                           '#f)))
                    (if (eq? 'Prod _$e1249_)
                        (let* ((_prod1252_
                                (##direct-structure-ref
                                 _prod1247_
                                 '2
                                 std/parser/base#token::t
                                 '#f))
                               (_next1254_
                                (std/parser/lexer#token-stream-next _ts1240_)))
                          (let ((_$e1257_
                                 (##direct-structure-ref
                                  _next1254_
                                  '1
                                  std/parser/base#token::t
                                  '#f)))
                            (if (eq? '$$ _$e1257_)
                                (let ((_$e1260_
                                       (##direct-structure-ref
                                        _next1254_
                                        '2
                                        std/parser/base#token::t
                                        '#f)))
                                  (if (eq? 'ACTION _$e1260_)
                                      (_parse-rule-action1223_
                                       _ts1240_
                                       _start1241_
                                       _rule-id1242_
                                       _prod1252_
                                       _prods1243_
                                       _K1244_
                                       _E1245_)
                                      (if (eq? 'ALTRULE _$e1260_)
                                          (_parse-rule-altrule1224_
                                           _ts1240_
                                           _start1241_
                                           _rule-id1242_
                                           (cons _prod1252_ _prods1243_)
                                           _K1244_
                                           _E1245_)
                                          (if (eq? 'ENDRULE _$e1260_)
                                              (_K1244_ _ts1240_
                                                       (_make-rule1220_
                                                        _rule-id1242_
                                                        (cons _prod1252_
                                                              _prods1243_)
                                                        _start1241_
                                                        _next1254_))
                                              (_E1245_ _ts1240_
                                                       _next1254_
                                                       (_make-rule1220_
                                                        _rule-id1242_
                                                        (cons _prod1252_
                                                              _prods1243_)
                                                        _start1241_
                                                        _next1254_))))))
                                (std/parser/grammar-reader#raise-unexpected-token
                                 _next1254_))))
                        (std/parser/grammar-reader#raise-unexpected-token
                         _prod1247_))))))
        (let _lp1226_ ((_ts1228_
                        (std/parser/grammar-reader#lex-parser _port1217_))
                       (_rules1229_ '()))
          (_parse-rule1221_
           _ts1228_
           (lambda (_ts1231_ _rule1232_)
             (_lp1226_ _ts1231_ (cons _rule1232_ _rules1229_)))
           (lambda (_ts1234_ _tok1235_ _rule1236_)
             (let ((_rules1238_
                    (if _rule1236_ (cons _rule1236_ _rules1229_) _rules1229_)))
               (if (eq? (##direct-structure-ref
                         _tok1235_
                         '2
                         std/parser/base#token::t
                         '#f)
                        'ENDRULE)
                   (_lp1226_ _ts1234_ _rules1238_)
                   (values (reverse _rules1238_) _tok1235_)))))))))
  (define std/parser/grammar-reader#read-lexer-body
    (lambda (_port1165_)
      (letrec ((_make-rule1167_
                (lambda (_rx1213_ _action1214_ _end1215_)
                  (let ((__tmp5460
                         (cons (##direct-structure-ref
                                _rx1213_
                                '2
                                std/parser/base#token::t
                                '#f)
                               (cons _action1214_ '())))
                        (__tmp5459
                         (std/parser/base#location->source-location
                          (std/parser/base#location-delta
                           (##direct-structure-ref
                            _rx1213_
                            '3
                            std/parser/base#token::t
                            '#f)
                           _end1215_))))
                    (declare (not safe))
                    (##structure AST::t __tmp5460 __tmp5459))))
               (_parse-rule1168_
                (lambda (_ts1204_ _K1205_ _E1206_)
                  (let* ((_next1208_
                          (std/parser/lexer#token-stream-next _ts1204_))
                         (_$e1210_
                          (##direct-structure-ref
                           _next1208_
                           '1
                           std/parser/base#token::t
                           '#f)))
                    (if (eq? 'RX _$e1210_)
                        (_parse-rule-k1169_
                         _ts1204_
                         _next1208_
                         _K1205_
                         _E1206_)
                        (_E1206_ _ts1204_ _next1208_)))))
               (_parse-rule-k1169_
                (lambda (_ts1182_ _rx1183_ _K1184_ _E1185_)
                  (let* ((_next1187_
                          (std/parser/lexer#token-stream-next _ts1182_))
                         (_$e1189_
                          (##direct-structure-ref
                           _next1187_
                           '1
                           std/parser/base#token::t
                           '#f)))
                    (if (eq? '$$ _$e1189_)
                        (let ((_$e1192_
                               (##direct-structure-ref
                                _next1187_
                                '2
                                std/parser/base#token::t
                                '#f)))
                          (if (eq? 'ACTION _$e1192_)
                              (let ((_action1195_ (read-syntax _port1165_)))
                                (if (eof-object? _action1195_)
                                    (gx#raise-syntax-error
                                     '#f
                                     '"Bad syntax; unexpected end of input"
                                     (std/parser/base#token->syntax
                                      _next1187_))
                                    (let* ((_ts1197_
                                            (std/parser/grammar-reader#lex-lexer
                                             _port1165_))
                                           (_end1199_
                                            (std/parser/lexer#token-stream-loc
                                             _ts1197_))
                                           (_rule1201_
                                            (_make-rule1167_
                                             _rx1183_
                                             _action1195_
                                             _end1199_)))
                                      (_K1184_ _ts1197_ _rule1201_))))
                              (std/parser/grammar-reader#raise-unexpected-token
                               _next1187_)))
                        (std/parser/grammar-reader#raise-unexpected-token
                         _next1187_))))))
        (let _lp1171_ ((_ts1173_
                        (std/parser/grammar-reader#lex-lexer _port1165_))
                       (_rules1174_ '()))
          (_parse-rule1168_
           _ts1173_
           (lambda (_ts1176_ _rule1177_)
             (_lp1171_ _ts1176_ (cons _rule1177_ _rules1174_)))
           (lambda (_ts1179_ _tok1180_)
             (if (eq? (##direct-structure-ref
                       _tok1180_
                       '2
                       std/parser/base#token::t
                       '#f)
                      'ENDRULE)
                 (_lp1171_ _ts1179_ _rules1174_)
                 (values (reverse _rules1174_) _tok1180_))))))))
  (define std/parser/grammar-reader#WS
    (std/parser/rlang#@charset '(#\space #\tab)))
  (define std/parser/grammar-reader#lex-parser::L
    (cons (std/parser/rlang#@cat__2
           (let ()
             (declare (not safe))
             (##structure std/parser/rlang#char::t '#\%))
           (let ()
             (declare (not safe))
             (##structure std/parser/rlang#char::t '#\%))
           (let ()
             (declare (not safe))
             (##structure std/parser/rlang#char::t '#\p))
           (let ()
             (declare (not safe))
             (##structure std/parser/rlang#char::t '#\a))
           (let ()
             (declare (not safe))
             (##structure std/parser/rlang#char::t '#\r))
           (let ()
             (declare (not safe))
             (##structure std/parser/rlang#char::t '#\s))
           (let ()
             (declare (not safe))
             (##structure std/parser/rlang#char::t '#\e))
           (let ()
             (declare (not safe))
             (##structure std/parser/rlang#char::t '#\r)))
          (cons (std/parser/rlang#@cat__2
                 (let ()
                   (declare (not safe))
                   (##structure std/parser/rlang#char::t '#\%))
                 (let ()
                   (declare (not safe))
                   (##structure std/parser/rlang#char::t '#\%))
                 (let ()
                   (declare (not safe))
                   (##structure std/parser/rlang#char::t '#\l))
                 (let ()
                   (declare (not safe))
                   (##structure std/parser/rlang#char::t '#\e))
                 (let ()
                   (declare (not safe))
                   (##structure std/parser/rlang#char::t '#\x))
                 (let ()
                   (declare (not safe))
                   (##structure std/parser/rlang#char::t '#\e))
                 (let ()
                   (declare (not safe))
                   (##structure std/parser/rlang#char::t '#\r)))
                (cons (std/parser/rlang#@cat__1
                       (let ()
                         (declare (not safe))
                         (##structure std/parser/rlang#char::t '#\=))
                       (let ()
                         (declare (not safe))
                         (##structure std/parser/rlang#char::t '#\>)))
                      (cons (let ()
                              (declare (not safe))
                              (##structure std/parser/rlang#char::t '#\|))
                            (cons (std/parser/rlang#@cat__1
                                   (std/parser/rlang#@rep+
                                    (let ()
                                      (declare (not safe))
                                      (##structure
                                       std/parser/rlang#char::t
                                       '#\newline)))
                                   (std/parser/rlang#@rep+
                                    std/parser/grammar-reader#WS))
                                  (cons (std/parser/rlang#@rep+
                                         (let ()
                                           (declare (not safe))
                                           (##structure
                                            std/parser/rlang#char::t
                                            '#\newline)))
                                        (cons (std/parser/rlang#@rep+
                                               std/parser/grammar-reader#WS)
                                              (cons (std/parser/rlang#@cat__1
                                                     (let ()
                                                       (declare (not safe))
                                                       (##structure
                                                        std/parser/rlang#char::t
                                                        '#\;))
                                                     (std/parser/rlang#@rep+
                                                      (std/parser/rlang#@negset
                                                       '(#\newline))))
                                                    (cons (std/parser/rlang#@cat__1
                                                           (let ()
                                                             (declare
                                                               (not safe))
                                                             (##structure
                                                              std/parser/rlang#char::t
                                                              '#\<))
                                                           (let ()
                                                             (declare
                                                               (not safe))
                                                             (##structure
                                                              std/parser/rlang#char::t
                                                              '#\-)))
                                                          (cons (let ()
;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
                          (declare (not safe))
                          (##structure std/parser/rlang#char::t '#\())
                        (cons (let ()
                                (declare (not safe))
                                (##structure std/parser/rlang#char::t '#\)))
                              (cons (std/parser/rlang#@cat__2
                                     (let ()
                                       (declare (not safe))
                                       (##structure
                                        std/parser/rlang#char::t
                                        '#\'))
                                     (std/parser/rlang#@rep*
                                      (std/parser/rlang#@negset '(#\')))
                                     (let ()
                                       (declare (not safe))
                                       (##structure
                                        std/parser/rlang#char::t
                                        '#\')))
                                    (cons (std/parser/rlang#@cat__2
                                           (let ()
                                             (declare (not safe))
                                             (##structure
                                              std/parser/rlang#char::t
                                              '#\"))
                                           (std/parser/rlang#@rep*
                                            (std/parser/rlang#@alt__1
                                             (let ()
                                               (declare (not safe))
                                               (##structure
                                                std/parser/rlang#char::t
                                                '#\"))
                                             (std/parser/rlang#@negset
                                              '(#\"))))
                                           (let ()
                                             (declare (not safe))
                                             (##structure
                                              std/parser/rlang#char::t
                                              '#\")))
                                          (cons (let ()
                                                  (declare (not safe))
                                                  (##structure
                                                   std/parser/rlang#char::t
                                                   '#\*))
                                                (cons (let ()
                                                        (declare (not safe))
                                                        (##structure
                                                         std/parser/rlang#char::t
                                                         '#\+))
                                                      (cons (let ()
                                                              (declare
                                                                (not safe))
                                                              (##structure
                                                               std/parser/rlang#char::t
                                                               '#\?))
                                                            (cons (std/parser/rlang#@rep+
;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
                           (std/parser/rlang#@charset
                            '(#\-
                              #\+
                              #\*
                              #\/
                              #\=
                              #\?
                              #\<
                              #\>
                              #\~
                              #\!
                              #\@
                              #\$
                              #\%
                              #\^
                              #\&
                              #\:
                              #\_
                              #\a
                              #\b
                              #\c
                              #\d
                              #\e
                              #\f
                              #\g
                              #\h
                              #\i
                              #\j
                              #\k
                              #\l
                              #\m
                              #\n
                              #\o
                              #\p
                              #\q
                              #\r
                              #\s
                              #\t
                              #\u
                              #\v
                              #\w
                              #\x
                              #\y
                              #\z
                              #\A
                              #\B
                              #\C
                              #\D
                              #\E
                              #\F
                              #\G
                              #\H
                              #\I
                              #\J
                              #\K
                              #\L
                              #\M
                              #\N
                              #\O
                              #\P
                              #\Q
                              #\R
                              #\S
                              #\T
                              #\U
                              #\V
                              #\W
                              #\X
                              #\Y
                              #\Z
                              #\0
                              #\1
                              #\2
                              #\3
                              #\4
                              #\5
                              #\6
                              #\7
                              #\8
                              #\9)))
                          '()))))))))))))))))))
;;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
;;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  (define std/parser/grammar-reader#lex-parser::R
    (cons (lambda (_@@1112_ _@loc1113_)
            (let ()
              (declare (not safe))
              (##structure std/parser/base#token::t '$$ '%%parser _@loc1113_)))
          (cons (lambda (_@@1115_ _@loc1116_)
                  (let ()
                    (declare (not safe))
                    (##structure
                     std/parser/base#token::t
                     '$$
                     '%%lexer
                     _@loc1116_)))
                (cons (lambda (_@@1118_ _@loc1119_)
                        (let ()
                          (declare (not safe))
                          (##structure
                           std/parser/base#token::t
                           '$$
                           'ACTION
                           _@loc1119_)))
                      (cons (lambda (_@@1121_ _@loc1122_)
                              (let ()
                                (declare (not safe))
                                (##structure
                                 std/parser/base#token::t
                                 '$$
                                 'ALTRULE
                                 _@loc1122_)))
                            (cons (lambda (_@@1124_ _@loc1126_)
                                    std/parser/lexer#$)
                                  (cons (lambda (_@@1129_ _@loc1130_)
                                          (let ()
                                            (declare (not safe))
                                            (##structure
                                             std/parser/base#token::t
                                             '$$
                                             'ENDRULE
                                             _@loc1130_)))
                                        (cons (lambda (_@@1132_ _@loc1133_)
                                                std/parser/lexer#$)
                                              (cons (lambda (_@@1135_
                                                             _@loc1136_)
                                                      std/parser/lexer#$)
                                                    (cons (lambda (_@@1138_
;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
                           _@loc1139_)
                    (let ()
                      (declare (not safe))
                      (##structure
                       std/parser/base#token::t
                       'PROD
                       '<-
                       _@loc1139_)))
                  (cons (lambda (_@@1141_ _@loc1142_)
                          (let ()
                            (declare (not safe))
                            (##structure
                             std/parser/base#token::t
                             'LPAREN
                             '|(|
                             _@loc1142_)))
                        (cons (lambda (_@@1144_ _@loc1145_)
                                (let ()
                                  (declare (not safe))
                                  (##structure
                                   std/parser/base#token::t
                                   'RPAREN
                                   '|)|
                                   _@loc1145_)))
                              (cons (lambda (_@@1147_ _@loc1148_)
                                      (let ((__tmp5461
                                             (std/parser/grammar-reader#string->token-symbol
                                              _@@1147_)))
                                        (declare (not safe))
                                        (##structure
                                         std/parser/base#token::t
                                         'EQ
                                         __tmp5461
                                         _@loc1148_)))
                                    (cons (lambda (_@@1150_ _@loc1151_)
                                            (let ((__tmp5462
                                                   (std/parser/grammar-reader#string->token-string
                                                    _@@1150_)))
                                              (declare (not safe))
                                              (##structure
                                               std/parser/base#token::t
                                               'EQUAL
                                               __tmp5462
                                               _@loc1151_)))
                                          (cons (lambda (_@@1153_ _@loc1154_)
                                                  (let ()
                                                    (declare (not safe))
                                                    (##structure
                                                     std/parser/base#token::t
                                                     'STAR
                                                     '*
                                                     _@loc1154_)))
                                                (cons (lambda (_@@1156_
                                                               _@loc1157_)
                                                        (let ()
                                                          (declare (not safe))
                                                          (##structure
                                                           std/parser/base#token::t
                                                           'PLUS
                                                           '+
                                                           _@loc1157_)))
                                                      (cons (lambda (_@@1159_
;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
                             _@loc1160_)
                      (let ()
                        (declare (not safe))
                        (##structure
                         std/parser/base#token::t
                         'MAYBE
                         '?
                         _@loc1160_)))
                    (cons (lambda (_@@1162_ _@loc1163_)
                            (let ((__tmp5463 (string->symbol _@@1162_)))
                              (declare (not safe))
                              (##structure
                               std/parser/base#token::t
                               'Ident
                               __tmp5463
                               _@loc1163_)))
                          '()))))))))))))))))))
;;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
;;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  (define std/parser/grammar-reader#lex-parser
    (lambda (_input1109_)
      (std/parser/lexer#lex
       _input1109_
       std/parser/grammar-reader#lex-parser::L
       std/parser/grammar-reader#lex-parser::R)))
  (define std/parser/grammar-reader#parse-rule-head__%
    (lambda (_input1085_ _$lexer1087_ _wrap-e1089_)
      (std/parser/defparser#parser-parse
       'parse-rule-head
       (std/parser/defparser#parser-input-stream _input1085_ _$lexer1087_)
       std/parser/grammar-reader#Rule
       _wrap-e1089_)))
  (define std/parser/grammar-reader#parse-rule-head__0
    (lambda (_input1094_)
      (let* ((_$lexer1096_ std/parser/grammar-reader#lex-parser)
             (_wrap-e1098_ std/parser/base#wrap-ast))
        (std/parser/grammar-reader#parse-rule-head__%
         _input1094_
         _$lexer1096_
         _wrap-e1098_))))
  (define std/parser/grammar-reader#parse-rule-head__1
    (lambda (_input1100_ _$lexer1101_)
      (let ((_wrap-e1103_ std/parser/base#wrap-ast))
        (std/parser/grammar-reader#parse-rule-head__%
         _input1100_
         _$lexer1101_
         _wrap-e1103_))))
  (define std/parser/grammar-reader#parse-rule-head
    (lambda _g5465_
      (let ((_g5464_ (let () (declare (not safe)) (##length _g5465_))))
        (cond ((let () (declare (not safe)) (##fx= _g5464_ 1))
               (apply std/parser/grammar-reader#parse-rule-head__0 _g5465_))
              ((let () (declare (not safe)) (##fx= _g5464_ 2))
               (apply std/parser/grammar-reader#parse-rule-head__1 _g5465_))
              ((let () (declare (not safe)) (##fx= _g5464_ 3))
               (apply std/parser/grammar-reader#parse-rule-head__% _g5465_))
              (else
               (##raise-wrong-number-of-arguments-exception
                std/parser/grammar-reader#parse-rule-head
                _g5465_))))))
  (define std/parser/grammar-reader#Rule::1::app::cat::1
    (lambda (_ts1078_ _toks1079_ _wrap-e1080_ _K1081_ _E1082_)
      (std/parser/grammar-reader#Ident
       _ts1078_
       _toks1079_
       _wrap-e1080_
       _K1081_
       _E1082_)))
  (define std/parser/grammar-reader#Rule::1::app::cat::2
    (lambda (_ts1067_ _toks1068_ _wrap-e1069_ _K1070_ _E1071_)
      (let* ((_next1073_ (std/parser/lexer#token-stream-next _ts1067_))
             (_toks1075_ (cons _next1073_ _toks1068_)))
        (if (eq? (##direct-structure-ref
                  _next1073_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '<-)
            (_K1070_ _toks1075_ _next1073_)
            (_E1071_ _toks1075_)))))
  (define std/parser/grammar-reader#Rule::1::app::cat::3
    (lambda (_ts1061_ _toks1062_ _wrap-e1063_ _K1064_ _E1065_)
      (std/parser/grammar-reader#Prod
       _ts1061_
       _toks1062_
       _wrap-e1063_
       _K1064_
       _E1065_)))
  (define std/parser/grammar-reader#Rule::1::app
    (lambda (_ts1045_ _toks1046_ _wrap-e1047_ _K1048_ _E1049_)
      (std/parser/grammar-reader#Ident
       _ts1045_
       _toks1046_
       _wrap-e1047_
       (lambda (_toks1051_ _$14021052_)
         (std/parser/grammar-reader#Rule::1::app::cat::2
          _ts1045_
          _toks1051_
          _wrap-e1047_
          (lambda (_toks1055_ _g5466_)
            (std/parser/grammar-reader#Prod
             _ts1045_
             _toks1055_
             _wrap-e1047_
             (lambda (_toks1057_ _$24031058_)
               (_K1048_ _toks1057_ _$14021052_ _$24031058_))
             _E1049_))
          _E1049_))
       _E1049_)))
  (define std/parser/grammar-reader#Rule::1
    (lambda (_ts1021_ _toks1022_ _wrap-e1023_ _K1024_ _E1025_)
      (let ((_start1027_ (std/parser/lexer#token-stream-loc _ts1021_)))
        (std/parser/grammar-reader#Rule::1::app
         _ts1021_
         _toks1022_
         _wrap-e1023_
         (lambda (_toks1030_ _$14041031_ _$24051033_)
           (let* ((_end1036_ (std/parser/lexer#token-stream-loc _ts1021_))
                  (_@loc1039_
                   (std/parser/base#location-delta* _start1027_ _end1036_)))
             (_K1024_ _toks1030_
                      (let ((__tmp5467
                             (_wrap-e1023_
                              ((lambda (_$11042_ _$21043_)
                                 (cons _$11042_ (cons _$21043_ '())))
                               (##direct-structure-ref
                                _$14041031_
                                '2
                                std/parser/base#token::t
                                '#f)
                               (##direct-structure-ref
                                _$24051033_
                                '2
                                std/parser/base#token::t
                                '#f))
                              _@loc1039_)))
                        (declare (not safe))
                        (##structure
                         std/parser/base#token::t
                         'Rule
                         __tmp5467
                         _@loc1039_)))))
         _E1025_))))
  (define std/parser/grammar-reader#Rule::2
    (lambda (_ts1009_ _toks1010_ _wrap-e1011_ _K1012_ _E1013_)
      (let* ((_next1015_ (std/parser/lexer#token-stream-next _ts1009_))
             (_toks1018_ (cons _next1015_ _toks1010_)))
        (if (std/parser/lexer#$$? _next1015_)
            (_K1012_ _toks1018_ _next1015_)
            (_E1013_ _toks1018_)))))
  (define std/parser/grammar-reader#Rule
    (lambda (_ts995_ _toks997_ _wrap-e999_ _K1001_ _E1003_)
      (std/parser/grammar-reader#Rule::1
       _ts995_
       _toks997_
       _wrap-e999_
       _K1001_
       (lambda (_xtoks1006_)
         (std/parser/defparser#parser-rewind _ts995_ _xtoks1006_ _toks997_)
         (std/parser/grammar-reader#Rule::2
          _ts995_
          _toks997_
          _wrap-e999_
          _K1001_
          _E1003_)))))
  (define std/parser/grammar-reader#parse-rule-prod__%
    (lambda (_input971_ _$lexer973_ _wrap-e975_)
      (std/parser/defparser#parser-parse
       'parse-rule-prod
       (std/parser/defparser#parser-input-stream _input971_ _$lexer973_)
       std/parser/grammar-reader#Prod
       _wrap-e975_)))
  (define std/parser/grammar-reader#parse-rule-prod__0
    (lambda (_input980_)
      (let* ((_$lexer982_ std/parser/grammar-reader#lex-parser)
             (_wrap-e984_ std/parser/base#wrap-ast))
        (std/parser/grammar-reader#parse-rule-prod__%
         _input980_
         _$lexer982_
         _wrap-e984_))))
  (define std/parser/grammar-reader#parse-rule-prod__1
    (lambda (_input986_ _$lexer987_)
      (let ((_wrap-e989_ std/parser/base#wrap-ast))
        (std/parser/grammar-reader#parse-rule-prod__%
         _input986_
         _$lexer987_
         _wrap-e989_))))
  (define std/parser/grammar-reader#parse-rule-prod
    (lambda _g5469_
      (let ((_g5468_ (let () (declare (not safe)) (##length _g5469_))))
        (cond ((let () (declare (not safe)) (##fx= _g5468_ 1))
               (apply std/parser/grammar-reader#parse-rule-prod__0 _g5469_))
              ((let () (declare (not safe)) (##fx= _g5468_ 2))
               (apply std/parser/grammar-reader#parse-rule-prod__1 _g5469_))
              ((let () (declare (not safe)) (##fx= _g5468_ 3))
               (apply std/parser/grammar-reader#parse-rule-prod__% _g5469_))
              (else
               (##raise-wrong-number-of-arguments-exception
                std/parser/grammar-reader#parse-rule-prod
                _g5469_))))))
  (define std/parser/grammar-reader#Prod::app::rep*
    (lambda (_ts964_ _toks965_ _wrap-e966_ _K967_ _E968_)
      (std/parser/grammar-reader#Pattern
       _ts964_
       _toks965_
       _wrap-e966_
       _K967_
       _E968_)))
  (define std/parser/grammar-reader#Prod::app
    (lambda (_ts942_ _toks943_ _wrap-e944_ _K945_ _E946_)
      (std/parser/grammar-reader#Pattern
       _ts942_
       _toks943_
       _wrap-e944_
       (lambda (_toks948_ _g407949_)
         (let _lp952_ ((_toks955_ _toks948_) (_$1406956_ (cons _g407949_ '())))
           (std/parser/grammar-reader#Pattern
            _ts942_
            _toks955_
            _wrap-e944_
            (lambda (_toks959_ _g407960_)
              (_lp952_ _toks959_ (cons _g407960_ _$1406956_)))
            (lambda (_xtoks962_)
              (std/parser/defparser#parser-rewind _ts942_ _xtoks962_ _toks955_)
              (_K945_ _toks955_ (reverse _$1406956_))))))
       _E946_)))
  (define std/parser/grammar-reader#Prod
    (lambda (_ts920_ _toks921_ _wrap-e922_ _K923_ _E924_)
      (let ((_start926_ (std/parser/lexer#token-stream-loc _ts920_)))
        (std/parser/grammar-reader#Prod::app
         _ts920_
         _toks921_
         _wrap-e922_
         (lambda (_toks928_ _$1408929_)
           (let* ((_end932_ (std/parser/lexer#token-stream-loc _ts920_))
                  (_@loc934_
                   (std/parser/base#location-delta* _start926_ _end932_)))
             (_K923_ _toks928_
                     (let ((__tmp5470
                            (_wrap-e922_
                             ((lambda (_$1937_)
                                (std/parser/grammar-reader#simplify
                                 (cons '@cat _$1937_)))
                              ((lambda (_$x939_)
                                 (map std/parser/base#token-e _$x939_))
                               _$1408929_))
                             _@loc934_)))
                       (declare (not safe))
                       (##structure
                        std/parser/base#token::t
                        'Prod
                        __tmp5470
                        _@loc934_)))))
         _E924_))))
  (define std/parser/grammar-reader#Pattern::1::app::cat::1
    (lambda (_ts914_ _toks915_ _wrap-e916_ _K917_ _E918_)
      (std/parser/grammar-reader#SimplePattern
       _ts914_
       _toks915_
       _wrap-e916_
       _K917_
       _E918_)))
  (define std/parser/grammar-reader#Pattern::1::app::cat::2
    (lambda (_ts903_ _toks904_ _wrap-e905_ _K906_ _E907_)
      (let* ((_next909_ (std/parser/lexer#token-stream-next _ts903_))
             (_toks911_ (cons _next909_ _toks904_)))
        (if (eq? (##direct-structure-ref
                  _next909_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '+)
            (_K906_ _toks911_ _next909_)
            (_E907_ _toks911_)))))
  (define std/parser/grammar-reader#Pattern::1::app
    (lambda (_ts891_ _toks892_ _wrap-e893_ _K894_ _E895_)
      (std/parser/grammar-reader#SimplePattern
       _ts891_
       _toks892_
       _wrap-e893_
       (lambda (_toks897_ _$1409898_)
         (std/parser/grammar-reader#Pattern::1::app::cat::2
          _ts891_
          _toks897_
          _wrap-e893_
          (lambda (_toks901_ _g5471_) (_K894_ _toks901_ _$1409898_))
          _E895_))
       _E895_)))
  (define std/parser/grammar-reader#Pattern::1
    (lambda (_ts872_ _toks873_ _wrap-e874_ _K875_ _E876_)
      (let ((_start878_ (std/parser/lexer#token-stream-loc _ts872_)))
        (std/parser/grammar-reader#Pattern::1::app
         _ts872_
         _toks873_
         _wrap-e874_
         (lambda (_toks880_ _$1410881_)
           (let* ((_end884_ (std/parser/lexer#token-stream-loc _ts872_))
                  (_@loc886_
                   (std/parser/base#location-delta* _start878_ _end884_)))
             (_K875_ _toks880_
                     (let ((__tmp5472
                            (_wrap-e874_
                             ((lambda (_$1889_)
                                (cons '@rep+ (cons _$1889_ '())))
                              (##direct-structure-ref
                               _$1410881_
                               '2
                               std/parser/base#token::t
                               '#f))
                             _@loc886_)))
                       (declare (not safe))
                       (##structure
                        std/parser/base#token::t
                        'Pattern
                        __tmp5472
                        _@loc886_)))))
         _E876_))))
  (define std/parser/grammar-reader#Pattern::2::app::cat::1
    (lambda (_ts866_ _toks867_ _wrap-e868_ _K869_ _E870_)
      (std/parser/grammar-reader#SimplePattern
       _ts866_
       _toks867_
       _wrap-e868_
       _K869_
       _E870_)))
  (define std/parser/grammar-reader#Pattern::2::app::cat::2
    (lambda (_ts855_ _toks856_ _wrap-e857_ _K858_ _E859_)
      (let* ((_next861_ (std/parser/lexer#token-stream-next _ts855_))
             (_toks863_ (cons _next861_ _toks856_)))
        (if (eq? (##direct-structure-ref
                  _next861_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '*)
            (_K858_ _toks863_ _next861_)
            (_E859_ _toks863_)))))
  (define std/parser/grammar-reader#Pattern::2::app
    (lambda (_ts843_ _toks844_ _wrap-e845_ _K846_ _E847_)
      (std/parser/grammar-reader#SimplePattern
       _ts843_
       _toks844_
       _wrap-e845_
       (lambda (_toks849_ _$1411850_)
         (std/parser/grammar-reader#Pattern::2::app::cat::2
          _ts843_
          _toks849_
          _wrap-e845_
          (lambda (_toks853_ _g5473_) (_K846_ _toks853_ _$1411850_))
          _E847_))
       _E847_)))
  (define std/parser/grammar-reader#Pattern::2
    (lambda (_ts824_ _toks825_ _wrap-e826_ _K827_ _E828_)
      (let ((_start830_ (std/parser/lexer#token-stream-loc _ts824_)))
        (std/parser/grammar-reader#Pattern::2::app
         _ts824_
         _toks825_
         _wrap-e826_
         (lambda (_toks832_ _$1412833_)
           (let* ((_end836_ (std/parser/lexer#token-stream-loc _ts824_))
                  (_@loc838_
                   (std/parser/base#location-delta* _start830_ _end836_)))
             (_K827_ _toks832_
                     (let ((__tmp5474
                            (_wrap-e826_
                             ((lambda (_$1841_)
                                (cons '@rep* (cons _$1841_ '())))
                              (##direct-structure-ref
                               _$1412833_
                               '2
                               std/parser/base#token::t
                               '#f))
                             _@loc838_)))
                       (declare (not safe))
                       (##structure
                        std/parser/base#token::t
                        'Pattern
                        __tmp5474
                        _@loc838_)))))
         _E828_))))
  (define std/parser/grammar-reader#Pattern::3::app::cat::1
    (lambda (_ts818_ _toks819_ _wrap-e820_ _K821_ _E822_)
      (std/parser/grammar-reader#SimplePattern
       _ts818_
       _toks819_
       _wrap-e820_
       _K821_
       _E822_)))
  (define std/parser/grammar-reader#Pattern::3::app::cat::2
    (lambda (_ts807_ _toks808_ _wrap-e809_ _K810_ _E811_)
      (let* ((_next813_ (std/parser/lexer#token-stream-next _ts807_))
             (_toks815_ (cons _next813_ _toks808_)))
        (if (eq? (##direct-structure-ref
                  _next813_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '?)
            (_K810_ _toks815_ _next813_)
            (_E811_ _toks815_)))))
  (define std/parser/grammar-reader#Pattern::3::app
    (lambda (_ts795_ _toks796_ _wrap-e797_ _K798_ _E799_)
      (std/parser/grammar-reader#SimplePattern
       _ts795_
       _toks796_
       _wrap-e797_
       (lambda (_toks801_ _$1413802_)
         (std/parser/grammar-reader#Pattern::3::app::cat::2
          _ts795_
          _toks801_
          _wrap-e797_
          (lambda (_toks805_ _g5475_) (_K798_ _toks805_ _$1413802_))
          _E799_))
       _E799_)))
  (define std/parser/grammar-reader#Pattern::3
    (lambda (_ts776_ _toks777_ _wrap-e778_ _K779_ _E780_)
      (let ((_start782_ (std/parser/lexer#token-stream-loc _ts776_)))
        (std/parser/grammar-reader#Pattern::3::app
         _ts776_
         _toks777_
         _wrap-e778_
         (lambda (_toks784_ _$1414785_)
           (let* ((_end788_ (std/parser/lexer#token-stream-loc _ts776_))
                  (_@loc790_
                   (std/parser/base#location-delta* _start782_ _end788_)))
             (_K779_ _toks784_
                     (let ((__tmp5476
                            (_wrap-e778_
                             ((lambda (_$1793_)
                                (cons '@maybe (cons _$1793_ '())))
                              (##direct-structure-ref
                               _$1414785_
                               '2
                               std/parser/base#token::t
                               '#f))
                             _@loc790_)))
                       (declare (not safe))
                       (##structure
                        std/parser/base#token::t
                        'Pattern
                        __tmp5476
                        _@loc790_)))))
         _E780_))))
  (define std/parser/grammar-reader#Pattern::4::app
    (lambda (_ts770_ _toks771_ _wrap-e772_ _K773_ _E774_)
      (std/parser/grammar-reader#SimplePattern
       _ts770_
       _toks771_
       _wrap-e772_
       _K773_
       _E774_)))
  (define std/parser/grammar-reader#Pattern::4
    (lambda (_ts751_ _toks752_ _wrap-e753_ _K754_ _E755_)
      (let ((_start757_ (std/parser/lexer#token-stream-loc _ts751_)))
        (std/parser/grammar-reader#SimplePattern
         _ts751_
         _toks752_
         _wrap-e753_
         (lambda (_toks759_ _$1415760_)
           (let* ((_end763_ (std/parser/lexer#token-stream-loc _ts751_))
                  (_@loc765_
                   (std/parser/base#location-delta* _start757_ _end763_)))
             (_K754_ _toks759_
                     (let ((__tmp5477
                            (_wrap-e753_
                             ((lambda (_$1768_) _$1768_)
                              (##direct-structure-ref
                               _$1415760_
                               '2
                               std/parser/base#token::t
                               '#f))
                             _@loc765_)))
                       (declare (not safe))
                       (##structure
                        std/parser/base#token::t
                        'Pattern
                        __tmp5477
                        _@loc765_)))))
         _E755_))))
  (define std/parser/grammar-reader#Pattern
    (lambda (_ts739_ _toks740_ _wrap-e741_ _K742_ _E743_)
      (std/parser/grammar-reader#Pattern::1
       _ts739_
       _toks740_
       _wrap-e741_
       _K742_
       (lambda (_xtoks745_)
         (std/parser/defparser#parser-rewind _ts739_ _xtoks745_ _toks740_)
         (std/parser/grammar-reader#Pattern::2
          _ts739_
          _toks740_
          _wrap-e741_
          _K742_
          (lambda (_xtoks747_)
            (std/parser/defparser#parser-rewind _ts739_ _xtoks747_ _toks740_)
            (std/parser/grammar-reader#Pattern::3
             _ts739_
             _toks740_
             _wrap-e741_
             _K742_
             (lambda (_xtoks749_)
               (std/parser/defparser#parser-rewind
                _ts739_
                _xtoks749_
                _toks740_)
               (std/parser/grammar-reader#Pattern::4
                _ts739_
                _toks740_
                _wrap-e741_
                _K742_
                _E743_)))))))))
  (define std/parser/grammar-reader#SimplePattern::1::app::cat::1
    (lambda (_ts728_ _toks729_ _wrap-e730_ _K731_ _E732_)
      (let* ((_next734_ (std/parser/lexer#token-stream-next _ts728_))
             (_toks736_ (cons _next734_ _toks729_)))
        (if (eq? (##direct-structure-ref
                  _next734_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '|(|)
            (_K731_ _toks736_ _next734_)
            (_E732_ _toks736_)))))
  (define std/parser/grammar-reader#SimplePattern::1::app::cat::2
    (lambda (_ts722_ _toks723_ _wrap-e724_ _K725_ _E726_)
      (std/parser/grammar-reader#Ident
       _ts722_
       _toks723_
       _wrap-e724_
       _K725_
       _E726_)))
  (define std/parser/grammar-reader#SimplePattern::1::app::cat::3
    (lambda (_ts716_ _toks717_ _wrap-e718_ _K719_ _E720_)
      (std/parser/grammar-reader#Ident
       _ts716_
       _toks717_
       _wrap-e718_
       _K719_
       _E720_)))
  (define std/parser/grammar-reader#SimplePattern::1::app::cat::4
    (lambda (_ts705_ _toks706_ _wrap-e707_ _K708_ _E709_)
      (let* ((_next711_ (std/parser/lexer#token-stream-next _ts705_))
             (_toks713_ (cons _next711_ _toks706_)))
        (if (eq? (##direct-structure-ref
                  _next711_
                  '2
                  std/parser/base#token::t
                  '#f)
                 '|)|)
            (_K708_ _toks713_ _next711_)
            (_E709_ _toks713_)))))
  (define std/parser/grammar-reader#SimplePattern::1::app
    (lambda (_ts687_ _toks688_ _wrap-e689_ _K690_ _E691_)
      (std/parser/grammar-reader#SimplePattern::1::app::cat::1
       _ts687_
       _toks688_
       _wrap-e689_
       (lambda (_toks693_ _g5478_)
         (std/parser/grammar-reader#Ident
          _ts687_
          _toks693_
          _wrap-e689_
          (lambda (_toks695_ _$1416696_)
            (std/parser/grammar-reader#Ident
             _ts687_
             _toks695_
             _wrap-e689_
             (lambda (_toks699_ _$2417700_)
               (std/parser/grammar-reader#SimplePattern::1::app::cat::4
                _ts687_
                _toks699_
                _wrap-e689_
                (lambda (_toks703_ _g5479_)
                  (_K690_ _toks703_ _$1416696_ _$2417700_))
                _E691_))
             _E691_))
          _E691_))
       _E691_)))
  (define std/parser/grammar-reader#SimplePattern::1
    (lambda (_ts665_ _toks666_ _wrap-e667_ _K668_ _E669_)
      (let ((_start671_ (std/parser/lexer#token-stream-loc _ts665_)))
        (std/parser/grammar-reader#SimplePattern::1::app
         _ts665_
         _toks666_
         _wrap-e667_
         (lambda (_toks673_ _$1418674_ _$2419676_)
           (let* ((_end679_ (std/parser/lexer#token-stream-loc _ts665_))
                  (_@loc681_
                   (std/parser/base#location-delta* _start671_ _end679_)))
             (_K668_ _toks673_
                     (let ((__tmp5480
                            (_wrap-e667_
                             ((lambda (_$1684_ _$2685_)
                                (cons _$1684_ (cons _$2685_ '())))
                              (##direct-structure-ref
                               _$1418674_
                               '2
                               std/parser/base#token::t
                               '#f)
                              (##direct-structure-ref
                               _$2419676_
                               '2
                               std/parser/base#token::t
                               '#f))
                             _@loc681_)))
                       (declare (not safe))
                       (##structure
                        std/parser/base#token::t
                        'SimplePattern
                        __tmp5480
                        _@loc681_)))))
         _E669_))))
  (define std/parser/grammar-reader#SimplePattern::2::app
    (lambda (_ts659_ _toks660_ _wrap-e661_ _K662_ _E663_)
      (std/parser/grammar-reader#Ident
       _ts659_
       _toks660_
       _wrap-e661_
       _K662_
       _E663_)))
  (define std/parser/grammar-reader#SimplePattern::2
    (lambda (_ts640_ _toks641_ _wrap-e642_ _K643_ _E644_)
      (let ((_start646_ (std/parser/lexer#token-stream-loc _ts640_)))
        (std/parser/grammar-reader#Ident
         _ts640_
         _toks641_
         _wrap-e642_
         (lambda (_toks648_ _$1420649_)
           (let* ((_end652_ (std/parser/lexer#token-stream-loc _ts640_))
                  (_@loc654_
                   (std/parser/base#location-delta* _start646_ _end652_)))
             (_K643_ _toks648_
                     (let ((__tmp5481
                            (_wrap-e642_
                             ((lambda (_$1657_) _$1657_)
                              (##direct-structure-ref
                               _$1420649_
                               '2
                               std/parser/base#token::t
                               '#f))
                             _@loc654_)))
                       (declare (not safe))
                       (##structure
                        std/parser/base#token::t
                        'SimplePattern
                        __tmp5481
                        _@loc654_)))))
         _E644_))))
  (define std/parser/grammar-reader#SimplePattern::3::app
    (lambda (_ts634_ _toks635_ _wrap-e636_ _K637_ _E638_)
      (std/parser/grammar-reader#EQ
       _ts634_
       _toks635_
       _wrap-e636_
       _K637_
       _E638_)))
  (define std/parser/grammar-reader#SimplePattern::3
    (lambda (_ts615_ _toks616_ _wrap-e617_ _K618_ _E619_)
      (let ((_start621_ (std/parser/lexer#token-stream-loc _ts615_)))
        (std/parser/grammar-reader#EQ
         _ts615_
         _toks616_
         _wrap-e617_
         (lambda (_toks623_ _$1421624_)
           (let* ((_end627_ (std/parser/lexer#token-stream-loc _ts615_))
                  (_@loc629_
                   (std/parser/base#location-delta* _start621_ _end627_)))
             (_K618_ _toks623_
                     (let ((__tmp5482
                            (_wrap-e617_
                             ((lambda (_$1632_)
                                (cons '@eq
                                      (cons (cons 'quote (cons _$1632_ '()))
                                            '())))
                              (##direct-structure-ref
                               _$1421624_
                               '2
                               std/parser/base#token::t
                               '#f))
                             _@loc629_)))
                       (declare (not safe))
                       (##structure
                        std/parser/base#token::t
                        'SimplePattern
                        __tmp5482
                        _@loc629_)))))
         _E619_))))
  (define std/parser/grammar-reader#SimplePattern::4::app
    (lambda (_ts609_ _toks610_ _wrap-e611_ _K612_ _E613_)
      (std/parser/grammar-reader#EQUAL
       _ts609_
       _toks610_
       _wrap-e611_
       _K612_
       _E613_)))
  (define std/parser/grammar-reader#SimplePattern::4
    (lambda (_ts588_ _toks589_ _wrap-e590_ _K591_ _E592_)
      (let ((_start594_ (std/parser/lexer#token-stream-loc _ts588_)))
        (std/parser/grammar-reader#EQUAL
         _ts588_
         _toks589_
         _wrap-e590_
         (lambda (_toks597_ _$1422598_)
           (let* ((_end601_ (std/parser/lexer#token-stream-loc _ts588_))
                  (_@loc604_
                   (std/parser/base#location-delta* _start594_ _end601_)))
             (_K591_ _toks597_
                     (let ((__tmp5483
                            (_wrap-e590_
                             ((lambda (_$1607_)
                                (cons '@eq
                                      (cons (cons 'quote (cons _$1607_ '()))
                                            (cons equal? '()))))
                              (##direct-structure-ref
                               _$1422598_
                               '2
                               std/parser/base#token::t
                               '#f))
                             _@loc604_)))
                       (declare (not safe))
                       (##structure
                        std/parser/base#token::t
                        'SimplePattern
                        __tmp5483
                        _@loc604_)))))
         _E592_))))
  (define std/parser/grammar-reader#SimplePattern
    (lambda (_ts575_ _toks576_ _wrap-e577_ _K578_ _E579_)
      (std/parser/grammar-reader#SimplePattern::1
       _ts575_
       _toks576_
       _wrap-e577_
       _K578_
       (lambda (_xtoks581_)
         (std/parser/defparser#parser-rewind _ts575_ _xtoks581_ _toks576_)
         (std/parser/grammar-reader#SimplePattern::2
          _ts575_
          _toks576_
          _wrap-e577_
          _K578_
          (lambda (_xtoks584_)
            (std/parser/defparser#parser-rewind _ts575_ _xtoks584_ _toks576_)
            (std/parser/grammar-reader#SimplePattern::3
             _ts575_
             _toks576_
             _wrap-e577_
             _K578_
             (lambda (_xtoks586_)
               (std/parser/defparser#parser-rewind
                _ts575_
                _xtoks586_
                _toks576_)
               (std/parser/grammar-reader#SimplePattern::4
                _ts575_
                _toks576_
                _wrap-e577_
                _K578_
                _E579_)))))))))
  (define std/parser/grammar-reader#Ident
    (lambda (_ts564_ _toks565_ _wrap-e566_ _K567_ _E568_)
      (let* ((_next570_ (std/parser/lexer#token-stream-next _ts564_))
             (_toks572_ (cons _next570_ _toks565_)))
        (if (eq? (##direct-structure-ref
                  _next570_
                  '1
                  std/parser/base#token::t
                  '#f)
                 'Ident)
            (_K567_ _toks572_ _next570_)
            (_E568_ _toks572_)))))
  (define std/parser/grammar-reader#EQ
    (lambda (_ts553_ _toks554_ _wrap-e555_ _K556_ _E557_)
      (let* ((_next559_ (std/parser/lexer#token-stream-next _ts553_))
             (_toks561_ (cons _next559_ _toks554_)))
        (if (eq? (##direct-structure-ref
                  _next559_
                  '1
                  std/parser/base#token::t
                  '#f)
                 'EQ)
            (_K556_ _toks561_ _next559_)
            (_E557_ _toks561_)))))
  (define std/parser/grammar-reader#EQUAL
    (lambda (_ts536_ _toks538_ _wrap-e540_ _K542_ _E544_)
      (let* ((_next547_ (std/parser/lexer#token-stream-next _ts536_))
             (_toks550_ (cons _next547_ _toks538_)))
        (if (eq? (##direct-structure-ref
                  _next547_
                  '1
                  std/parser/base#token::t
                  '#f)
                 'EQUAL)
            (_K542_ _toks550_ _next547_)
            (_E544_ _toks550_)))))
  (define std/parser/grammar-reader#lex-lexer::L
    (cons (std/parser/rlang#@cat__2
           (let ()
             (declare (not safe))
             (##structure std/parser/rlang#char::t '#\%))
           (let ()
             (declare (not safe))
             (##structure std/parser/rlang#char::t '#\%))
           (let ()
             (declare (not safe))
             (##structure std/parser/rlang#char::t '#\p))
           (let ()
             (declare (not safe))
             (##structure std/parser/rlang#char::t '#\a))
           (let ()
             (declare (not safe))
             (##structure std/parser/rlang#char::t '#\r))
           (let ()
             (declare (not safe))
             (##structure std/parser/rlang#char::t '#\s))
           (let ()
             (declare (not safe))
             (##structure std/parser/rlang#char::t '#\e))
           (let ()
             (declare (not safe))
             (##structure std/parser/rlang#char::t '#\r)))
          (cons (std/parser/rlang#@cat__2
                 (let ()
                   (declare (not safe))
                   (##structure std/parser/rlang#char::t '#\%))
                 (let ()
                   (declare (not safe))
                   (##structure std/parser/rlang#char::t '#\%))
                 (let ()
                   (declare (not safe))
                   (##structure std/parser/rlang#char::t '#\l))
                 (let ()
                   (declare (not safe))
                   (##structure std/parser/rlang#char::t '#\e))
                 (let ()
                   (declare (not safe))
                   (##structure std/parser/rlang#char::t '#\x))
                 (let ()
                   (declare (not safe))
                   (##structure std/parser/rlang#char::t '#\e))
                 (let ()
                   (declare (not safe))
                   (##structure std/parser/rlang#char::t '#\r)))
                (cons (std/parser/rlang#@cat__1
                       (std/parser/rlang#@rep+ std/parser/grammar-reader#WS)
                       (std/parser/rlang#@cat__1
                        (let ()
                          (declare (not safe))
                          (##structure std/parser/rlang#char::t '#\-))
                        (let ()
                          (declare (not safe))
                          (##structure std/parser/rlang#char::t '#\>))))
                      (cons (std/parser/rlang#@rep+
                             (let ()
                               (declare (not safe))
                               (##structure
                                std/parser/rlang#char::t
                                '#\newline)))
                            (cons (std/parser/rlang#@rep+
                                   std/parser/grammar-reader#WS)
                                  (cons (std/parser/rlang#@cat__1
                                         (let ()
                                           (declare (not safe))
                                           (##structure
                                            std/parser/rlang#char::t
                                            '#\;))
                                         (std/parser/rlang#@rep+
                                          (std/parser/rlang#@negset
                                           '(#\newline))))
                                        (cons (std/parser/rlang#@rep+
                                               (std/parser/rlang#@alt__2
                                                (std/parser/rlang#@cat__1
                                                 (let ()
                                                   (declare (not safe))
                                                   (##structure
                                                    std/parser/rlang#char::t
                                                    '#\\))
                                                 (let ()
                                                   (declare (not safe))
                                                   (##structure
                                                    std/parser/rlang#char::t
                                                    '#\;)))
                                                (std/parser/rlang#@cat__1
                                                 (let ()
                                                   (declare (not safe))
                                                   (##structure
                                                    std/parser/rlang#char::t
                                                    '#\\))
                                                 (let ()
                                                   (declare (not safe))
                                                   (##structure
                                                    std/parser/rlang#char::t
                                                    '#\space)))
                                                (std/parser/rlang#@negset
                                                 '(#\space
                                                   #\newline
                                                   #\tab
                                                   #\;))))
                                              '()))))))))
  (define std/parser/grammar-reader#lex-lexer::R
    (cons (lambda (_@@513_ _@loc514_)
            (let ()
              (declare (not safe))
              (##structure std/parser/base#token::t '$$ '%%parser _@loc514_)))
          (cons (lambda (_@@516_ _@loc517_)
                  (let ()
                    (declare (not safe))
                    (##structure
                     std/parser/base#token::t
                     '$$
                     '%%lexer
                     _@loc517_)))
                (cons (lambda (_@@519_ _@loc520_)
                        (let ()
                          (declare (not safe))
                          (##structure
                           std/parser/base#token::t
                           '$$
                           'ACTION
                           _@loc520_)))
                      (cons (lambda (_@@522_ _@loc523_)
                              (let ()
                                (declare (not safe))
                                (##structure
                                 std/parser/base#token::t
                                 '$$
                                 'ENDRULE
                                 _@loc523_)))
                            (cons (lambda (_@@525_ _@loc527_)
                                    std/parser/lexer#$)
                                  (cons (lambda (_@@530_ _@loc531_)
                                          std/parser/lexer#$)
                                        (cons (lambda (_@@533_ _@loc534_)
                                                (let ((__tmp5484
                                                       (std/parser/grammar-reader#escape-chars
                                                        _@@533_)))
                                                  (declare (not safe))
                                                  (##structure
                                                   std/parser/base#token::t
                                                   'RX
                                                   __tmp5484
                                                   _@loc534_)))
                                              '()))))))))
  (define std/parser/grammar-reader#lex-lexer
    (lambda (_input510_)
      (std/parser/lexer#lex
       _input510_
       std/parser/grammar-reader#lex-lexer::L
       std/parser/grammar-reader#lex-lexer::R)))
  (define std/parser/grammar-reader#simplify
    (lambda (_cat471_)
      (let* ((_cat472482_ _cat471_)
             (_else474490_ (lambda () _cat471_))
             (_K476495_ (lambda (_e493_) _e493_)))
        (if (let () (declare (not safe)) (##pair? _cat472482_))
            (let ((_hd477498_
                   (let () (declare (not safe)) (##car _cat472482_)))
                  (_tl478500_
                   (let () (declare (not safe)) (##cdr _cat472482_))))
              (if (let () (declare (not safe)) (##eq? _hd477498_ '@cat))
                  (if (let () (declare (not safe)) (##pair? _tl478500_))
                      (let ((_hd479503_
                             (let () (declare (not safe)) (##car _tl478500_)))
                            (_tl480505_
                             (let () (declare (not safe)) (##cdr _tl478500_))))
                        (let ((_e508_ _hd479503_))
                          (if (let ()
                                (declare (not safe))
                                (##null? _tl480505_))
                              (_K476495_ _e508_)
                              (_else474490_))))
                      (_else474490_))
                  (_else474490_)))
            (_else474490_)))))
  (define std/parser/grammar-reader#string->token-symbol
    (lambda (_str469_)
      (string->symbol
       (std/parser/grammar-reader#string->token-string _str469_))))
  (define std/parser/grammar-reader#string->token-string
    (lambda (_str467_)
      (std/parser/grammar-reader#escape-chars
       (substring _str467_ '1 (fx- (string-length _str467_) '1)))))
  (define std/parser/grammar-reader#escape-chars
    (lambda (_str424_)
      (let _lp426_ ((_rest428_ (string->list _str424_)) (_chars429_ '()))
        (let* ((_rest430438_ _rest428_)
               (_else432446_ (lambda () (list->string (reverse _chars429_))))
               (_K434455_
                (lambda (_rest449_ _char450_)
                  (if (eq? _char450_ '#\\)
                      (let ((_$e452_ _char450_))
                        (if (eq? '#\n _$e452_)
                            (_lp426_ _rest449_ (cons '#\newline _chars429_))
                            (if (eq? '#\r _$e452_)
                                (_lp426_ _rest449_ (cons '#\return _chars429_))
                                (if (eq? '#\t _$e452_)
                                    (_lp426_ _rest449_
                                             (cons '#\tab _chars429_))
                                    (_lp426_ _rest449_
                                             (cons _char450_ _chars429_))))))
                      (_lp426_ _rest449_ (cons _char450_ _chars429_))))))
          (if (let () (declare (not safe)) (##pair? _rest430438_))
              (let ((_hd435458_
                     (let () (declare (not safe)) (##car _rest430438_)))
                    (_tl436460_
                     (let () (declare (not safe)) (##cdr _rest430438_))))
                (let* ((_char463_ _hd435458_) (_rest465_ _tl436460_))
                  (_K434455_ _rest465_ _char463_)))
              (_else432446_)))))))
