(declare (block) (standard-bindings) (extended-bindings))
(begin
  (define std/srfi/125#srfi-make-hash-table
    (lambda (_comparator-or-equality774_ . _rest775_)
      (letrec ((_make777_
                (lambda (_eqf815_ _hashf816_ _args817_)
                  (let ((_size822_
                         (let ((_$e819_ (find integer? _rest775_)))
                           (if _$e819_ _$e819_ absent-obj)))
                        (_weak-keys823_
                         (if (memq 'weak-keys _rest775_) '#t absent-obj))
                        (_weak-values824_
                         (if (memq 'weak-values _rest775_) '#t absent-obj)))
                    (make-table
                     'test:
                     _eqf815_
                     'hash:
                     _hashf816_
                     'size:
                     _size822_
                     'weak-keys:
                     _weak-keys823_
                     'weak-values:
                     _weak-values824_)))))
        (if (let ()
              (declare (not safe))
              (##structure-direct-instance-of?
               _comparator-or-equality774_
               'std/srfi/128#comparator::t))
            (let ((_eqf779_
                   (##direct-structure-ref
                    _comparator-or-equality774_
                    '2
                    std/srfi/128#comparator::t
                    '#f))
                  (_hashf780_
                   (std/srfi/128#comparator-hash-function
                    _comparator-or-equality774_)))
              (_make777_ _eqf779_ _hashf780_ _rest775_))
            (if (procedure? _comparator-or-equality774_)
                (let* ((_rest781789_ _rest775_)
                       (_else783797_
                        (lambda ()
                          (_make777_
                           _comparator-or-equality774_
                           absent-obj
                           _rest775_)))
                       (_K785803_
                        (lambda (_rest800_ _hashf801_)
                          (_make777_
                           _comparator-or-equality774_
                           _hashf801_
                           _rest800_))))
                  (if (let () (declare (not safe)) (##pair? _rest781789_))
                      (let ((_hd786806_
                             (let ()
                               (declare (not safe))
                               (##car _rest781789_)))
                            (_tl787808_
                             (let ()
                               (declare (not safe))
                               (##cdr _rest781789_))))
                        (if (procedure? _hd786806_)
                            (let* ((_hashf811_ _hd786806_)
                                   (_rest813_ _tl787808_))
                              (_K785803_ _rest813_ _hashf811_))
                            (_else783797_)))
                      (_else783797_)))
                (error '"Illegal argument" _comparator-or-equality774_))))))
  (define std/srfi/125#hash-table
    (lambda (_comparator717_ . _args718_)
      (let ((_ht720_ (make-table
                      'test:
                      (##direct-structure-ref
                       _comparator717_
                       '2
                       std/srfi/128#comparator::t
                       '#f)
                      'hash:
                      (std/srfi/128#comparator-hash-function
                       _comparator717_))))
        (let _lp722_ ((_rest724_ _args718_))
          (let* ((_rest725736_ _rest724_)
                 (_E728740_
                  (lambda () (error '"No clause matching" _rest725736_))))
            (let ((_K730755_
                   (lambda (_rest751_ _val752_ _key753_)
                     (table-set! _ht720_ _key753_ _val752_)
                     (_lp722_ _rest751_)))
                  (_K729745_ (lambda () _ht720_)))
              (let ((_try-match727748_
                     (lambda ()
                       (if (let () (declare (not safe)) (##null? _rest725736_))
                           (_K729745_)
                           (_E728740_)))))
                (if (let () (declare (not safe)) (##pair? _rest725736_))
                    (let ((_tl732760_
                           (let () (declare (not safe)) (##cdr _rest725736_)))
                          (_hd731758_
                           (let () (declare (not safe)) (##car _rest725736_))))
                      (if (let () (declare (not safe)) (##pair? _tl732760_))
                          (let ((_tl734767_
                                 (let ()
                                   (declare (not safe))
                                   (##cdr _tl732760_)))
                                (_hd733765_
                                 (let ()
                                   (declare (not safe))
                                   (##car _tl732760_))))
                            (let ((_key763_ _hd731758_)
                                  (_val770_ _hd733765_)
                                  (_rest772_ _tl734767_))
                              (_K730755_ _rest772_ _val770_ _key763_)))
                          (_E728740_)))
                    (_try-match727748_)))))))))
  (define std/srfi/125#hash-table-unfold
    (lambda (_stop?701_
             _mapper702_
             _successor703_
             _seed704_
             _comparator705_
             .
             _args706_)
      (let ((_ht708_ (apply std/srfi/125#srfi-make-hash-table
                            _comparator705_
                            _args706_)))
        (let _lp710_ ((_seed712_ _seed704_))
          (if (_stop?701_ _seed712_)
              _ht708_
              (let ((_g4446_ (_mapper702_ _seed712_)))
                (begin
                  (let ((_g4447_ (let ()
                                   (declare (not safe))
                                   (if (##values? _g4446_)
                                       (##vector-length _g4446_)
                                       1))))
                    (if (not (let () (declare (not safe)) (##fx= _g4447_ 2)))
                        (error "Context expects 2 values" _g4447_)))
                  (let ((_key714_
                         (let ()
                           (declare (not safe))
                           (##vector-ref _g4446_ 0)))
                        (_val715_
                         (let ()
                           (declare (not safe))
                           (##vector-ref _g4446_ 1))))
                    (begin
                      (table-set! _ht708_ _key714_ _val715_)
                      (_lp710_ (_successor703_ _seed712_)))))))))))
  (define std/srfi/125#alist->hash-table
    (lambda (_alist663_ _comparator664_ . _args665_)
      (let ((_ht667_ (apply std/srfi/125#srfi-make-hash-table
                            _comparator664_
                            _args665_)))
        (for-each
         (lambda (_e668670_)
           (let* ((_g672679_ _e668670_)
                  (_E674683_
                   (lambda () (error '"No clause matching" _g672679_)))
                  (_K675689_
                   (lambda (_val686_ _key687_)
                     (table-set! _ht667_ _key687_ _val686_))))
             (if (let () (declare (not safe)) (##pair? _g672679_))
                 (let ((_hd676692_
                        (let () (declare (not safe)) (##car _g672679_)))
                       (_tl677694_
                        (let () (declare (not safe)) (##cdr _g672679_))))
                   (let* ((_key697_ _hd676692_) (_val699_ _tl677694_))
                     (_K675689_ _val699_ _key697_)))
                 (_E674683_))))
         _alist663_)
        _ht667_)))
  (define std/srfi/125#hash-table-empty?
    (lambda (_ht661_)
      (let ((__tmp4448 (table-length _ht661_)))
        (declare (not safe))
        (##zero? __tmp4448))))
  (define std/srfi/125#hash-table-mutable? (lambda (_ht659_) '#t))
  (define std/srfi/125#hash-table=?
    (lambda (_value-comparator641_ _ht1642_ _ht2643_)
      (let ((_eqf645_
             (##direct-structure-ref
              _value-comparator641_
              '2
              std/srfi/128#comparator::t
              '#f)))
        (call-with-current-continuation
         (lambda (_K647_)
           (table-for-each
            (lambda (_key649_ _val650_)
              (let ((_xval652_ (table-ref _ht2643_ _key649_ absent-value)))
                (if (or (eq? _xval652_ absent-value)
                        (not (_eqf645_ _val650_ _xval652_)))
                    (_K647_ '#f)
                    '#!void)))
            _ht1642_)
           (table-for-each
            (lambda (_key657_ _g4449_)
              (if (hash-key? _ht1642_ _key657_) '#!void (_K647_ '#f)))
            _ht2643_)
           '#t)))))
  (define std/srfi/125#hash-table-ref__1
    (lambda (_ht628_ _key629_ _failure630_)
      (let ((_val632_ (table-ref _ht628_ _key629_ absent-value)))
        (if (eq? _val632_ absent-value) (_failure630_) _val632_))))
  (define std/srfi/125#hash-table-ref__2
    (lambda (_ht634_ _key635_ _failure636_ _success637_)
      (let ((_val639_ (table-ref _ht634_ _key635_ absent-value)))
        (if (eq? _val639_ absent-value)
            (_failure636_)
            (_success637_ _val639_)))))
  (define std/srfi/125#hash-table-ref
    (lambda _g4451_
      (let ((_g4450_ (let () (declare (not safe)) (##length _g4451_))))
        (cond ((let () (declare (not safe)) (##fx= _g4450_ 2))
               (apply table-ref _g4451_))
              ((let () (declare (not safe)) (##fx= _g4450_ 3))
               (apply std/srfi/125#hash-table-ref__1 _g4451_))
              ((let () (declare (not safe)) (##fx= _g4450_ 4))
               (apply std/srfi/125#hash-table-ref__2 _g4451_))
              (else
               (##raise-wrong-number-of-arguments-exception
                std/srfi/125#hash-table-ref
                _g4451_))))))
  (define std/srfi/125#hash-table-ref/default
    (lambda (_ht621_ _key622_ _default623_)
      (table-ref _ht621_ _key622_ _default623_)))
  (define std/srfi/125#hash-table-set!__1
    (lambda (_ht564_ _key565_ _val566_ . _rest567_)
      (table-set! _ht564_ _key565_ _val566_)
      (let _lp569_ ((_rest571_ _rest567_))
        (let* ((_rest572583_ _rest571_)
               (_E575587_
                (lambda () (error '"No clause matching" _rest572583_))))
          (let ((_K577602_
                 (lambda (_rest598_ _val599_ _key600_)
                   (table-set! _ht564_ _key600_ _val599_)
                   (_lp569_ _rest598_)))
                (_K576592_ (lambda () '#!void)))
            (let ((_try-match574595_
                   (lambda ()
                     (if (let () (declare (not safe)) (##null? _rest572583_))
                         '#!void
                         (_E575587_)))))
              (if (let () (declare (not safe)) (##pair? _rest572583_))
                  (let ((_tl579607_
                         (let () (declare (not safe)) (##cdr _rest572583_)))
                        (_hd578605_
                         (let () (declare (not safe)) (##car _rest572583_))))
                    (if (let () (declare (not safe)) (##pair? _tl579607_))
                        (let ((_tl581614_
                               (let ()
                                 (declare (not safe))
                                 (##cdr _tl579607_)))
                              (_hd580612_
                               (let ()
                                 (declare (not safe))
                                 (##car _tl579607_))))
                          (let ((_key610_ _hd578605_)
                                (_val617_ _hd580612_)
                                (_rest619_ _tl581614_))
                            (_K577602_ _rest619_ _val617_ _key610_)))
                        (_E575587_)))
                  (_try-match574595_))))))))
  (define std/srfi/125#hash-table-set!
    (lambda _g4453_
      (let ((_g4452_ (let () (declare (not safe)) (##length _g4453_))))
        (cond ((let () (declare (not safe)) (##fx= _g4452_ 3))
               (apply table-set! _g4453_))
              ((let () (declare (not safe)) (##fx>= _g4452_ 3))
               (apply std/srfi/125#hash-table-set!__1 _g4453_))
              (else
               (##raise-wrong-number-of-arguments-exception
                std/srfi/125#hash-table-set!
                _g4453_))))))
  (define std/srfi/125#hash-table-delete!__1
    (lambda (_ht552_ _key553_ . _rest554_)
      (table-set! _ht552_ _key553_)
      (for-each
       (lambda (_g555557_) (table-set! _ht552_ _g555557_))
       _rest554_)))
  (define std/srfi/125#hash-table-delete!
    (lambda _g4455_
      (let ((_g4454_ (let () (declare (not safe)) (##length _g4455_))))
        (cond ((let () (declare (not safe)) (##fx= _g4454_ 2))
               (apply table-set! _g4455_))
              ((let () (declare (not safe)) (##fx>= _g4454_ 2))
               (apply std/srfi/125#hash-table-delete!__1 _g4455_))
              (else
               (##raise-wrong-number-of-arguments-exception
                std/srfi/125#hash-table-delete!
                _g4455_))))))
  (define std/srfi/125#hash-table-intern!
    (lambda (_ht541_ _key542_ _failure543_)
      (let ((_val545_ (table-ref _ht541_ _key542_ absent-value)))
        (if (eq? _val545_ absent-value)
            (let ((_val547_ (_failure543_)))
              (table-set! _ht541_ _key542_ _val547_)
              _val547_)
            _val545_))))
  (define std/srfi/125#hash-table-update!__0
    (lambda (_ht526_ _key527_ _updater528_)
      (table-set!
       _ht526_
       _key527_
       (_updater528_ (table-ref _ht526_ _key527_)))))
  (define std/srfi/125#hash-table-update!__1
    (lambda (_ht530_ _key531_ _updater532_ _failure533_)
      (table-set!
       _ht530_
       _key531_
       (_updater532_
        (std/srfi/125#hash-table-ref__1 _ht530_ _key531_ _failure533_)))))
  (define std/srfi/125#hash-table-update!__2
    (lambda (_ht535_ _key536_ _updater537_ _failure538_ _success539_)
      (table-set!
       _ht535_
       _key536_
       (_updater537_
        (std/srfi/125#hash-table-ref__2
         _ht535_
         _key536_
         _failure538_
         _success539_)))))
  (define std/srfi/125#hash-table-update!
    (lambda _g4457_
      (let ((_g4456_ (let () (declare (not safe)) (##length _g4457_))))
        (cond ((let () (declare (not safe)) (##fx= _g4456_ 3))
               (apply std/srfi/125#hash-table-update!__0 _g4457_))
              ((let () (declare (not safe)) (##fx= _g4456_ 4))
               (apply std/srfi/125#hash-table-update!__1 _g4457_))
              ((let () (declare (not safe)) (##fx= _g4456_ 5))
               (apply std/srfi/125#hash-table-update!__2 _g4457_))
              (else
               (##raise-wrong-number-of-arguments-exception
                std/srfi/125#hash-table-update!
                _g4457_))))))
  (define std/srfi/125#hash-table-update!/default
    (lambda (_ht521_ _key522_ _updater523_ _default524_)
      (table-set!
       _ht521_
       _key522_
       (_updater523_ (table-ref _ht521_ _key522_ _default524_)))))
  (define std/srfi/125#hash-table-pop!
    (lambda (_ht514_)
      (call-with-current-continuation
       (lambda (_K516_)
         (table-for-each
          (lambda (_key518_ _val519_)
            (table-set! _ht514_ _key518_)
            (_K516_ _key518_ _val519_))
          _ht514_)
         (error '"hash table is empty")))))
  (define std/srfi/125#hash-table-entries
    (lambda (_ht506_)
      (let ((_keys508_ '()) (_vals509_ '()))
        (table-for-each
         (lambda (_key511_ _val512_)
           (set! _keys508_ (cons _key511_ _keys508_))
           (set! _vals509_ (cons _val512_ _vals509_)))
         _ht506_)
        (values _keys508_ _vals509_))))
  (define std/srfi/125#hash-table-find
    (lambda (_proc494_ _ht495_ _failure496_)
      (call-with-current-continuation
       (lambda (_K498_)
         (table-for-each
          (lambda (_key500_ _val501_)
            (let ((_$e503_ (_proc494_ _key500_ _val501_)))
              (if _$e503_ (_K498_ _$e503_) '#!void)))
          _ht495_)
         (_failure496_)))))
  (define std/srfi/125#hash-table-count
    (lambda (_pred486_ _ht487_)
      (let ((_count489_ '0))
        (table-for-each
         (lambda (_key491_ _val492_)
           (if (_pred486_ _key491_ _val492_)
               (set! _count489_ (fx+ _count489_ '1))
               '#!void))
         _ht487_)
        _count489_)))
  (define std/srfi/125#hash-table-map
    (lambda (_proc477_ _comparator478_ _ht479_)
      (let ((_rt481_ (std/srfi/125#srfi-make-hash-table _comparator478_)))
        (table-for-each
         (lambda (_key483_ _val484_)
           (table-set! _rt481_ _key483_ (_proc477_ _val484_)))
         _ht479_)
        _rt481_)))
  (define std/srfi/125#hash-table-map!
    (lambda (_proc471_ _ht472_)
      (table-for-each
       (lambda (_key474_ _val475_)
         (table-set! _ht472_ _key474_ (_proc471_ _val475_)))
       _ht472_)))
  (define std/srfi/125#hash-table-map->list
    (lambda (_proc463_ _ht464_)
      (let ((_r466_ '()))
        (table-for-each
         (lambda (_key468_ _val469_)
           (set! _r466_ (cons (_proc463_ _key468_ _val469_) _r466_)))
         _ht464_)
        _r466_)))
  (define std/srfi/125#hash-table-walk
    (lambda (_ht460_ _proc461_) (table-for-each _proc461_ _ht460_)))
  (define std/srfi/125#hash-table-fold
    (lambda (_a1456_ _a2457_ _a3458_)
      (if (procedure? _a1456_)
          (hash-fold _a1456_ _a2457_ _a3458_)
          (if (table? _a1456_)
              (hash-fold _a2457_ _a3458_ _a1456_)
              (error '"Unexpected argument" _a1456_)))))
  (define std/srfi/125#hash-table-prune!
    (lambda (_proc450_ _ht451_)
      (table-for-each
       (lambda (_key453_ _val454_)
         (if (_proc450_ _key453_ _val454_)
             (table-set! _ht451_ _key453_)
             '#!void))
       _ht451_)))
  (define std/srfi/125#hash-table-copy__%
    (lambda (_ht437_ _ignore438_) (hash-copy _ht437_)))
  (define std/srfi/125#hash-table-copy__0
    (lambda (_ht443_)
      (let ((_ignore445_ '#f))
        (std/srfi/125#hash-table-copy__% _ht443_ _ignore445_))))
  (define std/srfi/125#hash-table-copy
    (lambda _g4459_
      (let ((_g4458_ (let () (declare (not safe)) (##length _g4459_))))
        (cond ((let () (declare (not safe)) (##fx= _g4458_ 1))
               (apply std/srfi/125#hash-table-copy__0 _g4459_))
              ((let () (declare (not safe)) (##fx= _g4458_ 2))
               (apply std/srfi/125#hash-table-copy__% _g4459_))
              (else
               (##raise-wrong-number-of-arguments-exception
                std/srfi/125#hash-table-copy
                _g4459_))))))
  (define std/srfi/125#hash-table-empty-copy
    (lambda (_ht432_)
      (if (table? _ht432_)
          (let ((_copy434_ (make-table)))
            (let ((__tmp4460
                   (let () (declare (not safe)) (##vector-ref _ht432_ '1))))
              (declare (not safe))
              (##vector-set! _copy434_ '1 __tmp4460))
            (let ((__tmp4461
                   (let () (declare (not safe)) (##vector-ref _ht432_ '2))))
              (declare (not safe))
              (##vector-set! _copy434_ '2 __tmp4461))
            (let ((__tmp4462
                   (let () (declare (not safe)) (##vector-ref _ht432_ '3))))
              (declare (not safe))
              (##vector-set! _copy434_ '3 __tmp4462))
            (let ((__tmp4463
                   (let () (declare (not safe)) (##vector-ref _ht432_ '4))))
              (declare (not safe))
              (##vector-set! _copy434_ '4 __tmp4463))
            (let ((__tmp4464
                   (let () (declare (not safe)) (##vector-ref _ht432_ '6))))
              (declare (not safe))
              (##vector-set! _copy434_ '6 __tmp4464))
            _copy434_)
          (error '"Invalid argument" _ht432_))))
  (define std/srfi/125#hash-table-union!
    (lambda (_ht1429_ _ht2430_) (hash-merge! _ht1429_ _ht2430_)))
  (define std/srfi/125#hash-table-intersection!
    (lambda (_ht1423_ _ht2424_)
      (table-for-each
       (lambda (_key426_ _val427_)
         (if (hash-key? _ht2424_ _key426_)
             '#!void
             (table-set! _ht1423_ _key426_)))
       _ht1423_)
      _ht1423_))
  (define std/srfi/125#hash-table-difference!
    (lambda (_ht1417_ _ht2418_)
      (table-for-each
       (lambda (_key420_ _val421_)
         (if (hash-key? _ht2418_ _key420_)
             (table-set! _ht1417_ _key420_)
             '#!void))
       _ht1417_)
      _ht1417_))
  (define std/srfi/125#hash-table-xor!
    (lambda (_ht1406_ _ht2407_)
      (let ((_removed409_ (make-table)))
        (table-for-each
         (lambda (_key411_ _val412_)
           (if (hash-key? _ht2407_ _key411_)
               (begin
                 (table-set! _ht1406_ _key411_)
                 (table-set! _removed409_ _key411_ '#t))
               '#!void))
         _ht1406_)
        (table-for-each
         (lambda (_key414_ _val415_)
           (if (hash-key? _removed409_ _key414_)
               '#!void
               (table-set! _ht1406_ _key414_ _val415_)))
         _ht2407_)
        _ht1406_)))
  (define std/srfi/125#hash-table-equivalence-function
    (lambda (_ht404_)
      (if (table? _ht404_)
          (let () (declare (not safe)) (##vector-ref _ht404_ '2))
          (error '"Invalid argument" _ht404_))))
  (define std/srfi/125#hash-table-hash-function
    (lambda (_ht402_)
      (if (table? _ht402_)
          (let () (declare (not safe)) (##vector-ref _ht402_ '3))
          (error '"Invalid argument" _ht402_)))))
