(declare (block) (standard-bindings) (extended-bindings))
(begin
  (declare (fixnum))
  (define std/srfi/1#srfi-1-map
    (lambda _g5168_
      (let ((_g5167_ (let () (declare (not safe)) (##length _g5168_))))
        (cond ((let () (declare (not safe)) (##fx= _g5167_ 2))
               (apply map _g5168_))
              ((let () (declare (not safe)) (##fx= _g5167_ 3))
               (apply std/srfi/1#map2 _g5168_))
              ((let () (declare (not safe)) (##fx>= _g5167_ 3))
               (apply std/srfi/1#mapN _g5168_))
              (else
               (##raise-wrong-number-of-arguments-exception
                std/srfi/1#srfi-1-map
                _g5168_))))))
  (define std/srfi/1#map2
    (lambda (_f1499_ _lst11500_ _lst21501_)
      (let _recur1503_ ((_rest11505_ _lst11500_) (_rest21506_ _lst21501_))
        (let ((_rest115071518_ _rest11505_) (_rest215081520_ _rest21506_))
          (let* ((_else15101528_ (lambda () '()))
                 (_K15121536_
                  (lambda (_rest11531_ _x11532_ _rest21533_ _x21534_)
                    (cons (_f1499_ _x11532_ _x21534_)
                          (_recur1503_ _rest11531_ _rest21533_)))))
            (if (let () (declare (not safe)) (##pair? _rest115071518_))
                (let ((_hd15151539_
                       (let () (declare (not safe)) (##car _rest115071518_)))
                      (_tl15161541_
                       (let () (declare (not safe)) (##cdr _rest115071518_))))
                  (let* ((_x11544_ _hd15151539_) (_rest11546_ _tl15161541_))
                    (if (let () (declare (not safe)) (##pair? _rest215081520_))
                        (let ((_hd15131548_
                               (let ()
                                 (declare (not safe))
                                 (##car _rest215081520_)))
                              (_tl15141550_
                               (let ()
                                 (declare (not safe))
                                 (##cdr _rest215081520_))))
                          (let* ((_x21553_ _hd15131548_)
                                 (_rest21555_ _tl15141550_))
                            (_K15121536_
                             _rest11546_
                             _x11544_
                             _rest21555_
                             _x21553_)))
                        (_else15101528_))))
                (_else15101528_)))))))
  (define std/srfi/1#mapN
    (lambda (_f1492_ . _lsts1493_)
      (let _recur1495_ ((_rest1497_ _lsts1493_))
        (if (andmap1 pair? _rest1497_)
            (cons (apply _f1492_ (map car _rest1497_))
                  (_recur1495_ (map cdr _rest1497_)))
            '()))))
  (define std/srfi/1#srfi-1-for-each
    (lambda _g5170_
      (let ((_g5169_ (let () (declare (not safe)) (##length _g5170_))))
        (cond ((let () (declare (not safe)) (##fx= _g5169_ 2))
               (apply for-each _g5170_))
              ((let () (declare (not safe)) (##fx= _g5169_ 3))
               (apply std/srfi/1#for-each2 _g5170_))
              ((let () (declare (not safe)) (##fx>= _g5169_ 3))
               (apply std/srfi/1#for-eachN _g5170_))
              (else
               (##raise-wrong-number-of-arguments-exception
                std/srfi/1#srfi-1-for-each
                _g5170_))))))
  (define std/srfi/1#for-each2
    (lambda (_f1422_ _lst11423_ _lst21424_)
      (let _lp1426_ ((_rest11428_ _lst11423_) (_rest21429_ _lst21424_))
        (let ((_rest114301441_ _rest11428_) (_rest214311443_ _rest21429_))
          (let* ((_else14331451_ (lambda () '#!void))
                 (_K14351459_
                  (lambda (_rest11454_ _x11455_ _rest21456_ _x21457_)
                    (_f1422_ _x11455_ _x21457_)
                    (_lp1426_ _rest11454_ _rest21456_))))
            (if (let () (declare (not safe)) (##pair? _rest114301441_))
                (let ((_hd14381462_
                       (let () (declare (not safe)) (##car _rest114301441_)))
                      (_tl14391464_
                       (let () (declare (not safe)) (##cdr _rest114301441_))))
                  (let* ((_x11467_ _hd14381462_) (_rest11469_ _tl14391464_))
                    (if (let () (declare (not safe)) (##pair? _rest214311443_))
                        (let ((_hd14361471_
                               (let ()
                                 (declare (not safe))
                                 (##car _rest214311443_)))
                              (_tl14371473_
                               (let ()
                                 (declare (not safe))
                                 (##cdr _rest214311443_))))
                          (let* ((_x21476_ _hd14361471_)
                                 (_rest21478_ _tl14371473_))
                            (_K14351459_
                             _rest11469_
                             _x11467_
                             _rest21478_
                             _x21476_)))
                        '#!void)))
                '#!void))))))
  (define std/srfi/1#for-eachN
    (lambda (_f1415_ . _lsts1416_)
      (let _lp1418_ ((_rest1420_ _lsts1416_))
        (if (andmap1 pair? _rest1420_)
            (begin
              (apply _f1415_ (map car _rest1420_))
              (_lp1418_ (map cdr _rest1420_)))
            '#!void))))
  (define std/srfi/1#srfi-1-assoc__1
    (lambda (_x1409_ _lst1410_ _eqf1411_)
      (find (lambda (_p1413_) (_eqf1411_ (car _p1413_) _x1409_)) _lst1410_)))
  (define std/srfi/1#srfi-1-assoc
    (lambda _g5172_
      (let ((_g5171_ (let () (declare (not safe)) (##length _g5172_))))
        (cond ((let () (declare (not safe)) (##fx= _g5171_ 2))
               (apply assoc _g5172_))
              ((let () (declare (not safe)) (##fx= _g5171_ 3))
               (apply std/srfi/1#srfi-1-assoc__1 _g5172_))
              (else
               (##raise-wrong-number-of-arguments-exception
                std/srfi/1#srfi-1-assoc
                _g5172_))))))
  (define std/srfi/1#srfi-1-member__1
    (lambda (_x1398_ _lst1399_ _eqf1400_)
      (std/srfi/1#find-tail
       (lambda (_g14011403_) (_eqf1400_ _g14011403_ _x1398_))
       _lst1399_)))
  (define std/srfi/1#srfi-1-member
    (lambda _g5174_
      (let ((_g5173_ (let () (declare (not safe)) (##length _g5174_))))
        (cond ((let () (declare (not safe)) (##fx= _g5173_ 2))
               (apply member _g5174_))
              ((let () (declare (not safe)) (##fx= _g5173_ 3))
               (apply std/srfi/1#srfi-1-member__1 _g5174_))
              (else
               (##raise-wrong-number-of-arguments-exception
                std/srfi/1#srfi-1-member
                _g5174_))))))
  (define std/srfi/1#xcons (lambda (_d1392_ _a1393_) (cons _a1393_ _d1392_)))
  (define std/srfi/1#tree-copy
    (lambda (_x1386_)
      (let _recur1388_ ((_x1390_ _x1386_))
        (if (not (pair? _x1390_))
            _x1390_
            (cons (_recur1388_ (car _x1390_)) (_recur1388_ (cdr _x1390_)))))))
  (define std/srfi/1#list-tabulate
    (lambda (_len1375_ _proc1376_)
      (if ((lambda (_n1378_) (and (integer? _n1378_) (>= _n1378_ '0)))
           _len1375_)
          _len1375_
          (error '"Bad argument"
                 _len1375_
                 '(lambda (n) (and (integer? n) (>= n 0)))
                 'list-tabulate))
      (if (procedure? _proc1376_)
          _proc1376_
          (error '"Bad argument" _proc1376_ 'procedure? 'list-tabulate))
      (let _$loop1380_ ((_i1383_ (- _len1375_ '1)) (_ans1384_ '()))
        (if (< _i1383_ '0)
            _ans1384_
            (_$loop1380_
             (- _i1383_ '1)
             (cons (_proc1376_ _i1383_) _ans1384_))))))
  (define std/srfi/1#list-copy
    (lambda (_lis1369_)
      (let _recur1371_ ((_lis1373_ _lis1369_))
        (if (pair? _lis1373_)
            (cons (car _lis1373_) (_recur1371_ (cdr _lis1373_)))
            _lis1373_))))
  (define std/srfi/1#circular-list
    (lambda (_val11364_ . _vals1365_)
      (let ((_ans1367_ (cons _val11364_ _vals1365_)))
        (set-cdr! (last-pair _ans1367_) _ans1367_)
        _ans1367_)))
  (define std/srfi/1#proper-list?
    (lambda (_x1352_)
      (let _lp1354_ ((_x1356_ _x1352_) (_lag1357_ _x1352_))
        (if (pair? _x1356_)
            (let ((_x1359_ (cdr _x1356_)))
              (if (pair? _x1359_)
                  (let ((_x1361_ (cdr _x1359_)) (_lag1362_ (cdr _lag1357_)))
                    (if (not (eq? _x1361_ _lag1362_))
                        (_lp1354_ _x1361_ _lag1362_)
                        '#f))
                  (null? _x1359_)))
            (null? _x1356_)))))
  (define std/srfi/1#dotted-list?
    (lambda (_x1340_)
      (let _lp1342_ ((_x1344_ _x1340_) (_lag1345_ _x1340_))
        (if (pair? _x1344_)
            (let ((_x1347_ (cdr _x1344_)))
              (if (pair? _x1347_)
                  (let ((_x1349_ (cdr _x1347_)) (_lag1350_ (cdr _lag1345_)))
                    (if (not (eq? _x1349_ _lag1350_))
                        (_lp1342_ _x1349_ _lag1350_)
                        '#f))
                  (not (null? _x1347_))))
            (not (null? _x1344_))))))
  (define std/srfi/1#circular-list?
    (lambda (_x1325_)
      (let _lp1327_ ((_x1329_ _x1325_) (_lag1330_ _x1325_))
        (if (pair? _x1329_)
            (let ((_x1332_ (cdr _x1329_)))
              (if (pair? _x1332_)
                  (let ((_x1334_ (cdr _x1332_)) (_lag1335_ (cdr _lag1330_)))
                    (let ((_$e1337_ (eq? _x1334_ _lag1335_)))
                      (if _$e1337_ _$e1337_ (_lp1327_ _x1334_ _lag1335_))))
                  '#f))
            '#f))))
  (define std/srfi/1#not-pair? (lambda (_x1323_) (not (pair? _x1323_))))
  (define std/srfi/1#null-list?
    (lambda (_l1321_)
      (if (pair? _l1321_)
          '#f
          (if (null? _l1321_)
              '#t
              (error '"null-list?: argument out of domain" _l1321_)))))
  (define std/srfi/1#list=
    (lambda (_=1299_ . _lists1300_)
      (let ((_$e1302_ (null? _lists1300_)))
        (if _$e1302_
            _$e1302_
            (let _lp11305_ ((_list-a1307_ (car _lists1300_))
                            (_others1308_ (cdr _lists1300_)))
              (let ((_$e1310_ (null? _others1308_)))
                (if _$e1310_
                    _$e1310_
                    (let ((_list-b1313_ (car _others1308_))
                          (_others1314_ (cdr _others1308_)))
                      (if (eq? _list-a1307_ _list-b1313_)
                          (_lp11305_ _list-b1313_ _others1314_)
                          (let _lp21316_ ((_list-a1318_ _list-a1307_)
                                          (_list-b1319_ _list-b1313_))
                            (if (std/srfi/1#null-list? _list-a1318_)
                                (if (std/srfi/1#null-list? _list-b1319_)
                                    (_lp11305_ _list-b1319_ _others1314_)
                                    '#f)
                                (if (not (std/srfi/1#null-list? _list-b1319_))
                                    (if (_=1299_ (car _list-a1318_)
                                                 (car _list-b1319_))
                                        (_lp21316_
                                         (cdr _list-a1318_)
                                         (cdr _list-b1319_))
                                        '#f)
                                    '#f))))))))))))
  (define std/srfi/1#length+
    (lambda (_x1284_)
      (let _lp1286_ ((_x1288_ _x1284_) (_lag1289_ _x1284_) (_len1290_ '0))
        (if (pair? _x1288_)
            (let ((_x1292_ (cdr _x1288_)) (_len1293_ (+ _len1290_ '1)))
              (if (pair? _x1292_)
                  (let ((_x1295_ (cdr _x1292_))
                        (_lag1296_ (cdr _lag1289_))
                        (_len1297_ (+ _len1293_ '1)))
                    (if (not (eq? _x1295_ _lag1296_))
                        (_lp1286_ _x1295_ _lag1296_ _len1297_)
                        '#f))
                  _len1293_))
            _len1290_))))
  (define std/srfi/1#zip
    (lambda (_list11281_ . _more-lists1282_)
      (apply map list _list11281_ _more-lists1282_)))
  (define std/srfi/1#first car)
  (define std/srfi/1#second cadr)
  (define std/srfi/1#third caddr)
  (define std/srfi/1#fourth cadddr)
  (define std/srfi/1#fifth (lambda (_x1279_) (car (cddddr _x1279_))))
  (define std/srfi/1#sixth (lambda (_x1277_) (cadr (cddddr _x1277_))))
  (define std/srfi/1#seventh (lambda (_x1275_) (caddr (cddddr _x1275_))))
  (define std/srfi/1#eighth (lambda (_x1273_) (cadddr (cddddr _x1273_))))
  (define std/srfi/1#ninth (lambda (_x1271_) (car (cddddr (cddddr _x1271_)))))
  (define std/srfi/1#tenth (lambda (_x1269_) (cadr (cddddr (cddddr _x1269_)))))
  (define std/srfi/1#car+cdr
    (lambda (_pair1267_) (values (car _pair1267_) (cdr _pair1267_))))
  (define std/srfi/1#take
    (lambda (_lis1259_ _k1260_)
      (if (integer? _k1260_)
          _k1260_
          (error '"Bad argument" _k1260_ 'integer? 'take))
      (let _recur1262_ ((_lis1264_ _lis1259_) (_k1265_ _k1260_))
        (if (zero? _k1265_)
            '()
            (cons (car _lis1264_)
                  (_recur1262_ (cdr _lis1264_) (- _k1265_ '1)))))))
  (define std/srfi/1#drop
    (lambda (_lis1251_ _k1252_)
      (if (integer? _k1252_)
          _k1252_
          (error '"Bad argument" _k1252_ 'integer? 'drop))
      (let _iter1254_ ((_lis1256_ _lis1251_) (_k1257_ _k1252_))
        (if (zero? _k1257_)
            _lis1256_
            (_iter1254_ (cdr _lis1256_) (- _k1257_ '1))))))
  (define std/srfi/1#take!
    (lambda (_lis1248_ _k1249_)
      (if (integer? _k1249_)
          _k1249_
          (error '"Bad argument" _k1249_ 'integer? 'take!))
      (if (zero? _k1249_)
          '()
          (begin
            (set-cdr! (std/srfi/1#drop _lis1248_ (- _k1249_ '1)) '())
            _lis1248_))))
  (define std/srfi/1#take-right
    (lambda (_lis1240_ _k1241_)
      (if (integer? _k1241_)
          _k1241_
          (error '"Bad argument" _k1241_ 'integer? 'take-right))
      (let _lp1243_ ((_lag1245_ _lis1240_)
                     (_lead1246_ (std/srfi/1#drop _lis1240_ _k1241_)))
        (if (pair? _lead1246_)
            (_lp1243_ (cdr _lag1245_) (cdr _lead1246_))
            _lag1245_))))
  (define std/srfi/1#drop-right
    (lambda (_lis1232_ _k1233_)
      (if (integer? _k1233_)
          _k1233_
          (error '"Bad argument" _k1233_ 'integer? 'drop-right))
      (let _recur1235_ ((_lag1237_ _lis1232_)
                        (_lead1238_ (std/srfi/1#drop _lis1232_ _k1233_)))
        (if (pair? _lead1238_)
            (cons (car _lag1237_)
                  (_recur1235_ (cdr _lag1237_) (cdr _lead1238_)))
            '()))))
  (define std/srfi/1#drop-right!
    (lambda (_lis1222_ _k1223_)
      (if (integer? _k1223_)
          _k1223_
          (error '"Bad argument" _k1223_ 'integer? 'drop-right!))
      (let ((_lead1225_ (std/srfi/1#drop _lis1222_ _k1223_)))
        (if (pair? _lead1225_)
            (let _lp1227_ ((_lag1229_ _lis1222_) (_lead1230_ (cdr _lead1225_)))
              (if (pair? _lead1230_)
                  (_lp1227_ (cdr _lag1229_) (cdr _lead1230_))
                  (begin (set-cdr! _lag1229_ '()) _lis1222_)))
            '()))))
  (define std/srfi/1#split-at
    (lambda (_x1211_ _k1212_)
      (if (integer? _k1212_)
          _k1212_
          (error '"Bad argument" _k1212_ 'integer? 'split-at))
      (let _recur1214_ ((_lis1216_ _x1211_) (_k1217_ _k1212_))
        (if (zero? _k1217_)
            (values '() _lis1216_)
            (let ((_g5175_ (_recur1214_ (cdr _lis1216_) (- _k1217_ '1))))
              (begin
                (let ((_g5176_ (let ()
                                 (declare (not safe))
                                 (if (##values? _g5175_)
                                     (##vector-length _g5175_)
                                     1))))
                  (if (not (let () (declare (not safe)) (##fx= _g5176_ 2)))
                      (error "Context expects 2 values" _g5176_)))
                (let ((_prefix1219_
                       (let () (declare (not safe)) (##vector-ref _g5175_ 0)))
                      (_suffix1220_
                       (let () (declare (not safe)) (##vector-ref _g5175_ 1))))
                  (values (cons (car _lis1216_) _prefix1219_)
                          _suffix1220_))))))))
  (define std/srfi/1#split-at!
    (lambda (_x1203_ _k1204_)
      (if (integer? _k1204_)
          _k1204_
          (error '"Bad argument" _k1204_ 'integer? 'split-at!))
      (if (zero? _k1204_)
          (values '() _x1203_)
          (let* ((_prev1206_ (std/srfi/1#drop _x1203_ (- _k1204_ '1)))
                 (_suffix1208_ (cdr _prev1206_)))
            (set-cdr! _prev1206_ '())
            (values _x1203_ _suffix1208_)))))
  (define std/srfi/1#unzip1 (lambda (_lis1201_) (map car _lis1201_)))
  (define std/srfi/1#unzip2
    (lambda (_lis1190_)
      (let _recur1192_ ((_lis1194_ _lis1190_))
        (if (std/srfi/1#null-list? _lis1194_)
            (values _lis1194_ _lis1194_)
            (let* ((_elt1196_ (car _lis1194_))
                   (_g5177_ (_recur1192_ (cdr _lis1194_))))
              (begin
                (let ((_g5178_ (let ()
                                 (declare (not safe))
                                 (if (##values? _g5177_)
                                     (##vector-length _g5177_)
                                     1))))
                  (if (not (let () (declare (not safe)) (##fx= _g5178_ 2)))
                      (error "Context expects 2 values" _g5178_)))
                (let ((_a1198_ (let ()
                                 (declare (not safe))
                                 (##vector-ref _g5177_ 0)))
                      (_b1199_ (let ()
                                 (declare (not safe))
                                 (##vector-ref _g5177_ 1))))
                  (values (cons (car _elt1196_) _a1198_)
                          (cons (cadr _elt1196_) _b1199_)))))))))
  (define std/srfi/1#unzip3
    (lambda (_lis1178_)
      (let _recur1180_ ((_lis1182_ _lis1178_))
        (if (std/srfi/1#null-list? _lis1182_)
            (values _lis1182_ _lis1182_ _lis1182_)
            (let* ((_elt1184_ (car _lis1182_))
                   (_g5179_ (_recur1180_ (cdr _lis1182_))))
              (begin
                (let ((_g5180_ (let ()
                                 (declare (not safe))
                                 (if (##values? _g5179_)
                                     (##vector-length _g5179_)
                                     1))))
                  (if (not (let () (declare (not safe)) (##fx= _g5180_ 3)))
                      (error "Context expects 3 values" _g5180_)))
                (let ((_a1186_ (let ()
                                 (declare (not safe))
                                 (##vector-ref _g5179_ 0)))
                      (_b1187_ (let ()
                                 (declare (not safe))
                                 (##vector-ref _g5179_ 1)))
                      (_c1188_ (let ()
                                 (declare (not safe))
                                 (##vector-ref _g5179_ 2))))
                  (values (cons (car _elt1184_) _a1186_)
                          (cons (cadr _elt1184_) _b1187_)
                          (cons (caddr _elt1184_) _c1188_)))))))))
  (define std/srfi/1#unzip4
    (lambda (_lis1165_)
      (let _recur1167_ ((_lis1169_ _lis1165_))
        (if (std/srfi/1#null-list? _lis1169_)
            (values _lis1169_ _lis1169_ _lis1169_ _lis1169_)
            (let* ((_elt1171_ (car _lis1169_))
                   (_g5181_ (_recur1167_ (cdr _lis1169_))))
              (begin
                (let ((_g5182_ (let ()
                                 (declare (not safe))
                                 (if (##values? _g5181_)
                                     (##vector-length _g5181_)
                                     1))))
                  (if (not (let () (declare (not safe)) (##fx= _g5182_ 4)))
                      (error "Context expects 4 values" _g5182_)))
                (let ((_a1173_ (let ()
                                 (declare (not safe))
                                 (##vector-ref _g5181_ 0)))
                      (_b1174_ (let ()
                                 (declare (not safe))
                                 (##vector-ref _g5181_ 1)))
                      (_c1175_ (let ()
                                 (declare (not safe))
                                 (##vector-ref _g5181_ 2)))
                      (_d1176_ (let ()
                                 (declare (not safe))
                                 (##vector-ref _g5181_ 3))))
                  (values (cons (car _elt1171_) _a1173_)
                          (cons (cadr _elt1171_) _b1174_)
                          (cons (caddr _elt1171_) _c1175_)
                          (cons (cadddr _elt1171_) _d1176_)))))))))
  (define std/srfi/1#unzip5
    (lambda (_lis1151_)
      (let _recur1153_ ((_lis1155_ _lis1151_))
        (if (std/srfi/1#null-list? _lis1155_)
            (values _lis1155_ _lis1155_ _lis1155_ _lis1155_ _lis1155_)
            (let* ((_elt1157_ (car _lis1155_))
                   (_g5183_ (_recur1153_ (cdr _lis1155_))))
              (begin
                (let ((_g5184_ (let ()
                                 (declare (not safe))
                                 (if (##values? _g5183_)
                                     (##vector-length _g5183_)
                                     1))))
                  (if (not (let () (declare (not safe)) (##fx= _g5184_ 5)))
                      (error "Context expects 5 values" _g5184_)))
                (let ((_a1159_ (let ()
                                 (declare (not safe))
                                 (##vector-ref _g5183_ 0)))
                      (_b1160_ (let ()
                                 (declare (not safe))
                                 (##vector-ref _g5183_ 1)))
                      (_c1161_ (let ()
                                 (declare (not safe))
                                 (##vector-ref _g5183_ 2)))
                      (_d1162_ (let ()
                                 (declare (not safe))
                                 (##vector-ref _g5183_ 3)))
                      (_e1163_ (let ()
                                 (declare (not safe))
                                 (##vector-ref _g5183_ 4))))
                  (values (cons (car _elt1157_) _a1159_)
                          (cons (cadr _elt1157_) _b1160_)
                          (cons (caddr _elt1157_) _c1161_)
                          (cons (cadddr _elt1157_) _d1162_)
                          (cons (car (cddddr _elt1157_)) _e1163_)))))))))
  (define std/srfi/1#append!
    (lambda _lists1133_
      (let _lp1135_ ((_lists1137_ _lists1133_) (_prev1138_ '()))
        (if (not (pair? _lists1137_))
            _prev1138_
            (let ((_first1140_ (car _lists1137_))
                  (_rest1141_ (cdr _lists1137_)))
              (if (not (pair? _first1140_))
                  (_lp1135_ _rest1141_ _first1140_)
                  (let _lp21143_ ((_tail-cons1145_ (last-pair _first1140_))
                                  (_rest1146_ _rest1141_))
                    (if (pair? _rest1146_)
                        (let ((_next1148_ (car _rest1146_))
                              (_rest1149_ (cdr _rest1146_)))
                          (set-cdr! _tail-cons1145_ _next1148_)
                          (_lp21143_
                           (if (pair? _next1148_)
                               (last-pair _next1148_)
                               _tail-cons1145_)
                           _rest1149_))
                        _first1140_))))))))
  (define std/srfi/1#append-reverse
    (lambda (_rev-head1125_ _tail1126_)
      (let _lp1128_ ((_rev-head1130_ _rev-head1125_) (_tail1131_ _tail1126_))
        (if (std/srfi/1#null-list? _rev-head1130_)
            _tail1131_
            (_lp1128_
             (cdr _rev-head1130_)
             (cons (car _rev-head1130_) _tail1131_))))))
  (define std/srfi/1#append-reverse!
    (lambda (_rev-head1115_ _tail1116_)
      (let _lp1118_ ((_rev-head1120_ _rev-head1115_) (_tail1121_ _tail1116_))
        (if (std/srfi/1#null-list? _rev-head1120_)
            _tail1121_
            (let ((_next-rev1123_ (cdr _rev-head1120_)))
              (set-cdr! _rev-head1120_ _tail1121_)
              (_lp1118_ _next-rev1123_ _rev-head1120_))))))
  (define std/srfi/1#concatenate
    (lambda (_lists1113_) (std/srfi/1#reduce-right append '() _lists1113_)))
  (define std/srfi/1#concatenate!
    (lambda (_lists1111_)
      (std/srfi/1#reduce-right std/srfi/1#append! '() _lists1111_)))
  (define std/srfi/1#%cdrs
    (lambda (_lists1101_)
      (call-with-current-continuation
       (lambda (_abort1103_)
         (let _recur1105_ ((_lists1107_ _lists1101_))
           (if (pair? _lists1107_)
               (let ((_lis1109_ (car _lists1107_)))
                 (if (std/srfi/1#null-list? _lis1109_)
                     (_abort1103_ '())
                     (cons (cdr _lis1109_) (_recur1105_ (cdr _lists1107_)))))
               '()))))))
  (define std/srfi/1#%cars+
    (lambda (_lists1094_ _last-elt1095_)
      (let _recur1097_ ((_lists1099_ _lists1094_))
        (if (pair? _lists1099_)
            (cons (caar _lists1099_) (_recur1097_ (cdr _lists1099_)))
            (list _last-elt1095_)))))
  (define std/srfi/1#%cars+cdrs
    (lambda (_lists1077_)
      (call-with-current-continuation
       (lambda (_abort1079_)
         (let _recur1081_ ((_lists1083_ _lists1077_))
           (if (pair? _lists1083_)
               (let ((_g5185_ (std/srfi/1#car+cdr _lists1083_)))
                 (begin
                   (let ((_g5186_ (let ()
                                    (declare (not safe))
                                    (if (##values? _g5185_)
                                        (##vector-length _g5185_)
                                        1))))
                     (if (not (let () (declare (not safe)) (##fx= _g5186_ 2)))
                         (error "Context expects 2 values" _g5186_)))
                   (let ((_list1085_
                          (let ()
                            (declare (not safe))
                            (##vector-ref _g5185_ 0)))
                         (_other-lists1086_
                          (let ()
                            (declare (not safe))
                            (##vector-ref _g5185_ 1))))
                     (if (std/srfi/1#null-list? _list1085_)
                         (_abort1079_ '() '())
                         (let ((_g5187_ (std/srfi/1#car+cdr _list1085_)))
                           (begin
                             (let ((_g5188_ (let ()
                                              (declare (not safe))
                                              (if (##values? _g5187_)
                                                  (##vector-length _g5187_)
                                                  1))))
                               (if (not (let ()
                                          (declare (not safe))
                                          (##fx= _g5188_ 2)))
                                   (error "Context expects 2 values" _g5188_)))
                             (let ((_a1088_ (let ()
                                              (declare (not safe))
                                              (##vector-ref _g5187_ 0)))
                                   (_d1089_ (let ()
                                              (declare (not safe))
                                              (##vector-ref _g5187_ 1))))
                               (let ((_g5189_ (_recur1081_ _other-lists1086_)))
                                 (begin
                                   (let ((_g5190_ (let ()
                                                    (declare (not safe))
                                                    (if (##values? _g5189_)
                                                        (##vector-length
                                                         _g5189_)
                                                        1))))
                                     (if (not (let ()
                                                (declare (not safe))
                                                (##fx= _g5190_ 2)))
                                         (error "Context expects 2 values"
                                                _g5190_)))
                                   (let ((_cars1091_
                                          (let ()
                                            (declare (not safe))
                                            (##vector-ref _g5189_ 0)))
                                         (_cdrs1092_
                                          (let ()
                                            (declare (not safe))
                                            (##vector-ref _g5189_ 1))))
                                     (values (cons _a1088_ _cars1091_)
                                             (cons _d1089_
                                                   _cdrs1092_))))))))))))
               (values '() '())))))))
  (define std/srfi/1#%cars+cdrs+
    (lambda (_lists1059_ _cars-final1060_)
      (call-with-current-continuation
       (lambda (_abort1062_)
         (let _recur1064_ ((_lists1066_ _lists1059_))
           (if (pair? _lists1066_)
               (let ((_g5191_ (std/srfi/1#car+cdr _lists1066_)))
                 (begin
                   (let ((_g5192_ (let ()
                                    (declare (not safe))
                                    (if (##values? _g5191_)
                                        (##vector-length _g5191_)
                                        1))))
                     (if (not (let () (declare (not safe)) (##fx= _g5192_ 2)))
                         (error "Context expects 2 values" _g5192_)))
                   (let ((_list1068_
                          (let ()
                            (declare (not safe))
                            (##vector-ref _g5191_ 0)))
                         (_other-lists1069_
                          (let ()
                            (declare (not safe))
                            (##vector-ref _g5191_ 1))))
                     (if (std/srfi/1#null-list? _list1068_)
                         (_abort1062_ '() '())
                         (let ((_g5193_ (std/srfi/1#car+cdr _list1068_)))
                           (begin
                             (let ((_g5194_ (let ()
                                              (declare (not safe))
                                              (if (##values? _g5193_)
                                                  (##vector-length _g5193_)
                                                  1))))
                               (if (not (let ()
                                          (declare (not safe))
                                          (##fx= _g5194_ 2)))
                                   (error "Context expects 2 values" _g5194_)))
                             (let ((_a1071_ (let ()
                                              (declare (not safe))
                                              (##vector-ref _g5193_ 0)))
                                   (_d1072_ (let ()
                                              (declare (not safe))
                                              (##vector-ref _g5193_ 1))))
                               (let ((_g5195_ (_recur1064_ _other-lists1069_)))
                                 (begin
                                   (let ((_g5196_ (let ()
                                                    (declare (not safe))
                                                    (if (##values? _g5195_)
                                                        (##vector-length
                                                         _g5195_)
                                                        1))))
                                     (if (not (let ()
                                                (declare (not safe))
                                                (##fx= _g5196_ 2)))
                                         (error "Context expects 2 values"
                                                _g5196_)))
                                   (let ((_cars1074_
                                          (let ()
                                            (declare (not safe))
                                            (##vector-ref _g5195_ 0)))
                                         (_cdrs1075_
                                          (let ()
                                            (declare (not safe))
                                            (##vector-ref _g5195_ 1))))
                                     (values (cons _a1071_ _cars1074_)
                                             (cons _d1072_
                                                   _cdrs1075_))))))))))))
               (values (list _cars-final1060_) '())))))))
  (define std/srfi/1#%cars+cdrs/no-test
    (lambda (_lists1044_)
      (let _recur1046_ ((_lists1048_ _lists1044_))
        (if (pair? _lists1048_)
            (let ((_g5197_ (std/srfi/1#car+cdr _lists1048_)))
              (begin
                (let ((_g5198_ (let ()
                                 (declare (not safe))
                                 (if (##values? _g5197_)
                                     (##vector-length _g5197_)
                                     1))))
                  (if (not (let () (declare (not safe)) (##fx= _g5198_ 2)))
                      (error "Context expects 2 values" _g5198_)))
                (let ((_list1050_
                       (let () (declare (not safe)) (##vector-ref _g5197_ 0)))
                      (_other-lists1051_
                       (let () (declare (not safe)) (##vector-ref _g5197_ 1))))
                  (let ((_g5199_ (std/srfi/1#car+cdr _list1050_)))
                    (begin
                      (let ((_g5200_ (let ()
                                       (declare (not safe))
                                       (if (##values? _g5199_)
                                           (##vector-length _g5199_)
                                           1))))
                        (if (not (let ()
                                   (declare (not safe))
                                   (##fx= _g5200_ 2)))
                            (error "Context expects 2 values" _g5200_)))
                      (let ((_a1053_ (let ()
                                       (declare (not safe))
                                       (##vector-ref _g5199_ 0)))
                            (_d1054_ (let ()
                                       (declare (not safe))
                                       (##vector-ref _g5199_ 1))))
                        (let ((_g5201_ (_recur1046_ _other-lists1051_)))
                          (begin
                            (let ((_g5202_ (let ()
                                             (declare (not safe))
                                             (if (##values? _g5201_)
                                                 (##vector-length _g5201_)
                                                 1))))
                              (if (not (let ()
                                         (declare (not safe))
                                         (##fx= _g5202_ 2)))
                                  (error "Context expects 2 values" _g5202_)))
                            (let ((_cars1056_
                                   (let ()
                                     (declare (not safe))
                                     (##vector-ref _g5201_ 0)))
                                  (_cdrs1057_
                                   (let ()
                                     (declare (not safe))
                                     (##vector-ref _g5201_ 1))))
                              (values (cons _a1053_ _cars1056_)
                                      (cons _d1054_ _cdrs1057_)))))))))))
            (values '() '())))))
  (define std/srfi/1#count
    (lambda (_pred1026_ _list11027_ . _lists1028_)
      (if (procedure? _pred1026_)
          _pred1026_
          (error '"Bad argument" _pred1026_ 'procedure? 'count))
      (if (pair? _lists1028_)
          (let _lp1030_ ((_list11032_ _list11027_)
                         (_lists1033_ _lists1028_)
                         (_i1034_ '0))
            (if (std/srfi/1#null-list? _list11032_)
                _i1034_
                (let ((_g5203_ (std/srfi/1#%cars+cdrs _lists1033_)))
                  (begin
                    (let ((_g5204_ (let ()
                                     (declare (not safe))
                                     (if (##values? _g5203_)
                                         (##vector-length _g5203_)
                                         1))))
                      (if (not (let () (declare (not safe)) (##fx= _g5204_ 2)))
                          (error "Context expects 2 values" _g5204_)))
                    (let ((_as1036_
                           (let ()
                             (declare (not safe))
                             (##vector-ref _g5203_ 0)))
                          (_ds1037_
                           (let ()
                             (declare (not safe))
                             (##vector-ref _g5203_ 1))))
                      (if (null? _as1036_)
                          _i1034_
                          (_lp1030_
                           (cdr _list11032_)
                           _ds1037_
                           (if (apply _pred1026_ (car _list11032_) _as1036_)
                               (+ _i1034_ '1)
                               _i1034_))))))))
          (let _lp1039_ ((_lis1041_ _list11027_) (_i1042_ '0))
            (if (std/srfi/1#null-list? _lis1041_)
                _i1042_
                (_lp1039_
                 (cdr _lis1041_)
                 (if (_pred1026_ (car _lis1041_)) (+ _i1042_ '1) _i1042_)))))))
  (define std/srfi/1#unfold-right
    (lambda (_p1012_ _f1013_ _g1014_ _seed1015_ . _maybe-tail1016_)
      (if (procedure? _p1012_)
          _p1012_
          (error '"Bad argument" _p1012_ 'procedure? 'unfold-right))
      (if (procedure? _f1013_)
          _f1013_
          (error '"Bad argument" _f1013_ 'procedure? 'unfold-right))
      (if (procedure? _g1014_)
          _g1014_
          (error '"Bad argument" _g1014_ 'procedure? 'unfold-right))
      (let _lp1018_ ((_seed1020_ _seed1015_)
                     (_ans1021_
                      (let ((_maybe-arg1023_ _maybe-tail1016_))
                        (if (null? _maybe-arg1023_)
                            '()
                            (if (null? (cdr _maybe-arg1023_))
                                (car _maybe-arg1023_)
                                (error '"too many optional arguments"
                                       _maybe-arg1023_))))))
        (if (_p1012_ _seed1020_)
            _ans1021_
            (_lp1018_
             (_g1014_ _seed1020_)
             (cons (_f1013_ _seed1020_) _ans1021_))))))
  (define std/srfi/1#unfold
    (lambda (_p996_ _f997_ _g998_ _seed999_ . _maybe-tail-gen1000_)
      (if (procedure? _p996_)
          _p996_
          (error '"Bad argument" _p996_ 'procedure? 'unfold))
      (if (procedure? _f997_)
          _f997_
          (error '"Bad argument" _f997_ 'procedure? 'unfold))
      (if (procedure? _g998_)
          _g998_
          (error '"Bad argument" _g998_ 'procedure? 'unfold))
      (if (pair? _maybe-tail-gen1000_)
          (let ((_tail-gen1002_ (car _maybe-tail-gen1000_)))
            (if (pair? (cdr _maybe-tail-gen1000_))
                (apply error
                       '"Too many arguments"
                       std/srfi/1#unfold
                       _p996_
                       _f997_
                       _g998_
                       _seed999_
                       _maybe-tail-gen1000_)
                (let _recur1004_ ((_seed1006_ _seed999_))
                  (if (_p996_ _seed1006_)
                      (_tail-gen1002_ _seed1006_)
                      (cons (_f997_ _seed1006_)
                            (_recur1004_ (_g998_ _seed1006_)))))))
          (let _recur1008_ ((_seed1010_ _seed999_))
            (if (_p996_ _seed1010_)
                '()
                (cons (_f997_ _seed1010_)
                      (_recur1008_ (_g998_ _seed1010_))))))))
  (define std/srfi/1#pair-fold-right
    (lambda (_f981_ _zero982_ _lis1983_ . _lists984_)
      (if (procedure? _f981_)
          _f981_
          (error '"Bad argument" _f981_ 'procedure? 'pair-fold-right))
      (if (pair? _lists984_)
          (let _recur986_ ((_lists988_ (cons _lis1983_ _lists984_)))
            (let ((_cdrs990_ (std/srfi/1#%cdrs _lists988_)))
              (if (null? _cdrs990_)
                  _zero982_
                  (apply _f981_
                         (std/srfi/1#append!
                          _lists988_
                          (list (_recur986_ _cdrs990_)))))))
          (let _recur992_ ((_lis994_ _lis1983_))
            (if (std/srfi/1#null-list? _lis994_)
                _zero982_
                (_f981_ _lis994_ (_recur992_ (cdr _lis994_))))))))
  (define std/srfi/1#pair-fold
    (lambda (_f962_ _zero963_ _lis1964_ . _lists965_)
      (if (procedure? _f962_)
          _f962_
          (error '"Bad argument" _f962_ 'procedure? 'pair-fold))
      (if (pair? _lists965_)
          (let _lp967_ ((_lists969_ (cons _lis1964_ _lists965_))
                        (_ans970_ _zero963_))
            (let ((_tails972_ (std/srfi/1#%cdrs _lists969_)))
              (if (null? _tails972_)
                  _ans970_
                  (_lp967_ _tails972_
                           (apply _f962_
                                  (std/srfi/1#append!
                                   _lists969_
                                   (list _ans970_)))))))
          (let _lp974_ ((_lis976_ _lis1964_) (_ans977_ _zero963_))
            (if (std/srfi/1#null-list? _lis976_)
                _ans977_
                (let ((_tail979_ (cdr _lis976_)))
                  (_lp974_ _tail979_ (_f962_ _lis976_ _ans977_))))))))
  (define std/srfi/1#reduce
    (lambda (_f958_ _ridentity959_ _lis960_)
      (if (procedure? _f958_)
          _f958_
          (error '"Bad argument" _f958_ 'procedure? 'reduce))
      (if (std/srfi/1#null-list? _lis960_)
          _ridentity959_
          (foldl1 _f958_ (car _lis960_) (cdr _lis960_)))))
  (define std/srfi/1#reduce-right
    (lambda (_f949_ _ridentity950_ _lis951_)
      (if (procedure? _f949_)
          _f949_
          (error '"Bad argument" _f949_ 'procedure? 'reduce-right))
      (if (std/srfi/1#null-list? _lis951_)
          _ridentity950_
          (let _recur953_ ((_head955_ (car _lis951_))
                           (_lis956_ (cdr _lis951_)))
            (if (pair? _lis956_)
                (_f949_ _head955_ (_recur953_ (car _lis956_) (cdr _lis956_)))
                _head955_)))))
  (define std/srfi/1#append-map
    (lambda (_f945_ _lis1946_ . _lists947_)
      (std/srfi/1#really-append-map
       std/srfi/1#append-map
       append
       _f945_
       _lis1946_
       _lists947_)))
  (define std/srfi/1#append-map!
    (lambda (_f941_ _lis1942_ . _lists943_)
      (std/srfi/1#really-append-map
       std/srfi/1#append-map!
       std/srfi/1#append!
       _f941_
       _lis1942_
       _lists943_)))
  (define std/srfi/1#really-append-map
    (lambda (_who915_ _appender916_ _f917_ _lis1918_ _lists919_)
      (if (procedure? _f917_)
          _f917_
          (error '"Bad argument" _f917_ 'procedure? 'who))
      (if (pair? _lists919_)
          (let ((_g5205_ (std/srfi/1#%cars+cdrs (cons _lis1918_ _lists919_))))
            (begin
              (let ((_g5206_ (let ()
                               (declare (not safe))
                               (if (##values? _g5205_)
                                   (##vector-length _g5205_)
                                   1))))
                (if (not (let () (declare (not safe)) (##fx= _g5206_ 2)))
                    (error "Context expects 2 values" _g5206_)))
              (let ((_cars921_
                     (let () (declare (not safe)) (##vector-ref _g5205_ 0)))
                    (_cdrs922_
                     (let () (declare (not safe)) (##vector-ref _g5205_ 1))))
                (if (null? _cars921_)
                    '()
                    (let _recur924_ ((_cars926_ _cars921_)
                                     (_cdrs927_ _cdrs922_))
                      (let* ((_vals929_ (apply _f917_ _cars926_))
                             (_g5207_ (std/srfi/1#%cars+cdrs _cdrs927_)))
                        (begin
                          (let ((_g5208_ (let ()
                                           (declare (not safe))
                                           (if (##values? _g5207_)
                                               (##vector-length _g5207_)
                                               1))))
                            (if (not (let ()
                                       (declare (not safe))
                                       (##fx= _g5208_ 2)))
                                (error "Context expects 2 values" _g5208_)))
                          (let ((_cars2931_
                                 (let ()
                                   (declare (not safe))
                                   (##vector-ref _g5207_ 0)))
                                (_cdrs2932_
                                 (let ()
                                   (declare (not safe))
                                   (##vector-ref _g5207_ 1))))
                            (if (null? _cars2931_)
                                _vals929_
                                (_appender916_
                                 _vals929_
                                 (_recur924_ _cars2931_ _cdrs2932_)))))))))))
          (if (std/srfi/1#null-list? _lis1918_)
              '()
              (let _recur934_ ((_elt936_ (car _lis1918_))
                               (_rest937_ (cdr _lis1918_)))
                (let ((_vals939_ (_f917_ _elt936_)))
                  (if (std/srfi/1#null-list? _rest937_)
                      _vals939_
                      (_appender916_
                       _vals939_
                       (_recur934_ (car _rest937_) (cdr _rest937_))))))))))
  (define std/srfi/1#pair-for-each
    (lambda (_proc899_ _lis1900_ . _lists901_)
      (if (procedure? _proc899_)
          _proc899_
          (error '"Bad argument" _proc899_ 'procedure? 'pair-for-each))
      (if (pair? _lists901_)
          (let _lp903_ ((_lists905_ (cons _lis1900_ _lists901_)))
            (let ((_tails907_ (std/srfi/1#%cdrs _lists905_)))
              (if (pair? _tails907_)
                  (begin (apply _proc899_ _lists905_) (_lp903_ _tails907_))
                  '#!void)))
          (let _lp909_ ((_lis911_ _lis1900_))
            (if (not (std/srfi/1#null-list? _lis911_))
                (let ((_tail913_ (cdr _lis911_)))
                  (_proc899_ _lis911_)
                  (_lp909_ _tail913_))
                '#!void)))))
  (define std/srfi/1#map!
    (lambda (_f885_ _lis1886_ . _lists887_)
      (if (procedure? _f885_)
          _f885_
          (error '"Bad argument" _f885_ 'procedure? 'map!))
      (if (pair? _lists887_)
          (let _lp889_ ((_lis1891_ _lis1886_) (_lists892_ _lists887_))
            (if (not (std/srfi/1#null-list? _lis1891_))
                (let ((_g5209_ (std/srfi/1#%cars+cdrs/no-test _lists892_)))
                  (begin
                    (let ((_g5210_ (let ()
                                     (declare (not safe))
                                     (if (##values? _g5209_)
                                         (##vector-length _g5209_)
                                         1))))
                      (if (not (let () (declare (not safe)) (##fx= _g5210_ 2)))
                          (error "Context expects 2 values" _g5210_)))
                    (let ((_heads894_
                           (let ()
                             (declare (not safe))
                             (##vector-ref _g5209_ 0)))
                          (_tails895_
                           (let ()
                             (declare (not safe))
                             (##vector-ref _g5209_ 1))))
                      (begin
                        (set-car!
                         _lis1891_
                         (apply _f885_ (car _lis1891_) _heads894_))
                        (_lp889_ (cdr _lis1891_) _tails895_)))))
                '#!void))
          (std/srfi/1#pair-for-each
           (lambda (_pair897_) (set-car! _pair897_ (_f885_ (car _pair897_))))
           _lis1886_))
      _lis1886_))
  (define std/srfi/1#map-in-order
    (lambda (_f865_ _lis1866_ . _lists867_)
      (if (procedure? _f865_)
          _f865_
          (error '"Bad argument" _f865_ 'procedure? 'map-in-order))
      (if (pair? _lists867_)
          (let _recur869_ ((_lists871_ (cons _lis1866_ _lists867_)))
            (let ((_g5211_ (std/srfi/1#%cars+cdrs _lists871_)))
              (begin
                (let ((_g5212_ (let ()
                                 (declare (not safe))
                                 (if (##values? _g5211_)
                                     (##vector-length _g5211_)
                                     1))))
                  (if (not (let () (declare (not safe)) (##fx= _g5212_ 2)))
                      (error "Context expects 2 values" _g5212_)))
                (let ((_cars873_
                       (let () (declare (not safe)) (##vector-ref _g5211_ 0)))
                      (_cdrs874_
                       (let () (declare (not safe)) (##vector-ref _g5211_ 1))))
                  (if (pair? _cars873_)
                      (let ((_x876_ (apply _f865_ _cars873_)))
                        (cons _x876_ (_recur869_ _cdrs874_)))
                      '())))))
          (let _recur878_ ((_lis880_ _lis1866_))
            (if (std/srfi/1#null-list? _lis880_)
                _lis880_
                (let ((_tail882_ (cdr _lis880_))
                      (_x883_ (_f865_ (car _lis880_))))
                  (cons _x883_ (_recur878_ _tail882_))))))))
  (define std/srfi/1#filter!
    (lambda (_pred845_ _lis846_)
      (if (procedure? _pred845_)
          _pred845_
          (error '"Bad argument" _pred845_ 'procedure? 'filter!))
      (let _lp848_ ((_ans850_ _lis846_))
        (if (std/srfi/1#null-list? _ans850_)
            _ans850_
            (if (not (_pred845_ (car _ans850_)))
                (_lp848_ (cdr _ans850_))
                (letrec ((_scan-in852_
                          (lambda (_prev855_ _lis856_)
                            (if (pair? _lis856_)
                                (if (_pred845_ (car _lis856_))
                                    (_scan-in852_ _lis856_ (cdr _lis856_))
                                    (_scan-out853_ _prev855_ (cdr _lis856_)))
                                '#!void)))
                         (_scan-out853_
                          (lambda (_prev858_ _lis859_)
                            (let _lp861_ ((_lis863_ _lis859_))
                              (if (pair? _lis863_)
                                  (if (_pred845_ (car _lis863_))
                                      (begin
                                        (set-cdr! _prev858_ _lis863_)
                                        (_scan-in852_ _lis863_ (cdr _lis863_)))
                                      (_lp861_ (cdr _lis863_)))
                                  (set-cdr! _prev858_ _lis863_))))))
                  (_scan-in852_ _ans850_ (cdr _ans850_))
                  _ans850_))))))
  (define std/srfi/1#partition
    (lambda (_pred832_ _lis833_)
      (if (procedure? _pred832_)
          _pred832_
          (error '"Bad argument" _pred832_ 'procedure? 'partition))
      (let _recur835_ ((_lis837_ _lis833_))
        (if (std/srfi/1#null-list? _lis837_)
            (values _lis837_ _lis837_)
            (let ((_elt839_ (car _lis837_)) (_tail840_ (cdr _lis837_)))
              (let ((_g5213_ (_recur835_ _tail840_)))
                (begin
                  (let ((_g5214_ (let ()
                                   (declare (not safe))
                                   (if (##values? _g5213_)
                                       (##vector-length _g5213_)
                                       1))))
                    (if (not (let () (declare (not safe)) (##fx= _g5214_ 2)))
                        (error "Context expects 2 values" _g5214_)))
                  (let ((_in842_ (let ()
                                   (declare (not safe))
                                   (##vector-ref _g5213_ 0)))
                        (_out843_
                         (let ()
                           (declare (not safe))
                           (##vector-ref _g5213_ 1))))
                    (if (_pred832_ _elt839_)
                        (values (if (pair? _out843_)
                                    (cons _elt839_ _in842_)
                                    _lis837_)
                                _out843_)
                        (values _in842_
                                (if (pair? _in842_)
                                    (cons _elt839_ _out843_)
                                    _lis837_)))))))))))
  (define std/srfi/1#partition!
    (lambda (_pred798_ _lis799_)
      (if (procedure? _pred798_)
          _pred798_
          (error '"Bad argument" _pred798_ 'procedure? 'partition!))
      (if (std/srfi/1#null-list? _lis799_)
          (values _lis799_ _lis799_)
          (letrec ((_scan-in801_
                    (lambda (_in-prev804_ _out-prev805_ _lis806_)
                      (let _lp808_ ((_in-prev810_ _in-prev804_)
                                    (_lis811_ _lis806_))
                        (if (pair? _lis811_)
                            (if (_pred798_ (car _lis811_))
                                (_lp808_ _lis811_ (cdr _lis811_))
                                (begin
                                  (set-cdr! _out-prev805_ _lis811_)
                                  (_scan-out802_
                                   _in-prev810_
                                   _lis811_
                                   (cdr _lis811_))))
                            (set-cdr! _out-prev805_ _lis811_)))))
                   (_scan-out802_
                    (lambda (_in-prev813_ _out-prev814_ _lis815_)
                      (let _lp817_ ((_out-prev819_ _out-prev814_)
                                    (_lis820_ _lis815_))
                        (if (pair? _lis820_)
                            (if (_pred798_ (car _lis820_))
                                (begin
                                  (set-cdr! _in-prev813_ _lis820_)
                                  (_scan-in801_
                                   _lis820_
                                   _out-prev819_
                                   (cdr _lis820_)))
                                (_lp817_ _lis820_ (cdr _lis820_)))
                            (set-cdr! _in-prev813_ _lis820_))))))
            (if (_pred798_ (car _lis799_))
                (let _lp822_ ((_prev-l824_ _lis799_) (_l825_ (cdr _lis799_)))
                  (if (not (pair? _l825_))
                      (values _lis799_ _l825_)
                      (if (_pred798_ (car _l825_))
                          (_lp822_ _l825_ (cdr _l825_))
                          (begin
                            (_scan-out802_ _prev-l824_ _l825_ (cdr _l825_))
                            (values _lis799_ _l825_)))))
                (let _lp827_ ((_prev-l829_ _lis799_) (_l830_ (cdr _lis799_)))
                  (if (not (pair? _l830_))
                      (values _l830_ _lis799_)
                      (if (_pred798_ (car _l830_))
                          (begin
                            (_scan-in801_ _l830_ _prev-l829_ (cdr _l830_))
                            (values _l830_ _lis799_))
                          (_lp827_ _l830_ (cdr _l830_))))))))))
  (define std/srfi/1#remove
    (lambda (_pred793_ _l794_)
      (filter (lambda (_x796_) (not (_pred793_ _x796_))) _l794_)))
  (define std/srfi/1#remove!
    (lambda (_pred788_ _l789_)
      (std/srfi/1#filter! (lambda (_x791_) (not (_pred788_ _x791_))) _l789_)))
  (define std/srfi/1#delete
    (lambda (_x777_ _lis778_ . _maybe-=779_)
      (let ((_=784_ (let ((_maybe-arg781_ _maybe-=779_))
                      (if (null? _maybe-arg781_)
                          equal?
                          (if (null? (cdr _maybe-arg781_))
                              (car _maybe-arg781_)
                              (error '"too many optional arguments"
                                     _maybe-arg781_))))))
        (filter (lambda (_y786_) (not (_=784_ _x777_ _y786_))) _lis778_))))
  (define std/srfi/1#delete!
    (lambda (_x766_ _lis767_ . _maybe-=768_)
      (let ((_=773_ (let ((_maybe-arg770_ _maybe-=768_))
                      (if (null? _maybe-arg770_)
                          equal?
                          (if (null? (cdr _maybe-arg770_))
                              (car _maybe-arg770_)
                              (error '"too many optional arguments"
                                     _maybe-arg770_))))))
        (std/srfi/1#filter!
         (lambda (_y775_) (not (_=773_ _x766_ _y775_)))
         _lis767_))))
  (define std/srfi/1#delete-duplicates
    (lambda (_lis747_ . _maybe-=748_)
      (let ((_elt=753_
             (let ((_maybe-arg750_ _maybe-=748_))
               (if (null? _maybe-arg750_)
                   equal?
                   (if (null? (cdr _maybe-arg750_))
                       (car _maybe-arg750_)
                       (error '"too many optional arguments"
                              _maybe-arg750_))))))
        (if (procedure? _elt=753_)
            _elt=753_
            (error '"Bad argument" _elt=753_ 'procedure? 'delete-duplicates))
        (let _recur755_ ((_lis757_ _lis747_))
          (if (std/srfi/1#null-list? _lis757_)
              _lis757_
              (let* ((_x759_ (car _lis757_))
                     (_tail761_ (cdr _lis757_))
                     (_new-tail763_
                      (_recur755_
                       (std/srfi/1#delete _x759_ _tail761_ _elt=753_))))
                (if (eq? _tail761_ _new-tail763_)
                    _lis757_
                    (cons _x759_ _new-tail763_))))))))
  (define std/srfi/1#delete-duplicates!
    (lambda (_lis728_ . _maybe-=729_)
      (let ((_elt=734_
             (let ((_maybe-arg731_ _maybe-=729_))
               (if (null? _maybe-arg731_)
                   equal?
                   (if (null? (cdr _maybe-arg731_))
                       (car _maybe-arg731_)
                       (error '"too many optional arguments"
                              _maybe-arg731_))))))
        (if (procedure? _elt=734_)
            _elt=734_
            (error '"Bad argument" _elt=734_ 'procedure? 'delete-duplicates!))
        (let _recur736_ ((_lis738_ _lis728_))
          (if (std/srfi/1#null-list? _lis738_)
              _lis738_
              (let* ((_x740_ (car _lis738_))
                     (_tail742_ (cdr _lis738_))
                     (_new-tail744_
                      (_recur736_
                       (std/srfi/1#delete! _x740_ _tail742_ _elt=734_))))
                (if (eq? _tail742_ _new-tail744_)
                    _lis738_
                    (cons _x740_ _new-tail744_))))))))
  (define std/srfi/1#alist-cons
    (lambda (_key724_ _datum725_ _alist726_)
      (cons (cons _key724_ _datum725_) _alist726_)))
  (define std/srfi/1#alist-copy
    (lambda (_alist720_)
      (map (lambda (_elt722_) (cons (car _elt722_) (cdr _elt722_)))
           _alist720_)))
  (define std/srfi/1#alist-delete
    (lambda (_key709_ _alist710_ . _maybe-=711_)
      (let ((_=716_ (let ((_maybe-arg713_ _maybe-=711_))
                      (if (null? _maybe-arg713_)
                          equal?
                          (if (null? (cdr _maybe-arg713_))
                              (car _maybe-arg713_)
                              (error '"too many optional arguments"
                                     _maybe-arg713_))))))
        (filter (lambda (_elt718_) (not (_=716_ _key709_ (car _elt718_))))
                _alist710_))))
  (define std/srfi/1#alist-delete!
    (lambda (_key698_ _alist699_ . _maybe-=700_)
      (let ((_=705_ (let ((_maybe-arg702_ _maybe-=700_))
                      (if (null? _maybe-arg702_)
                          equal?
                          (if (null? (cdr _maybe-arg702_))
                              (car _maybe-arg702_)
                              (error '"too many optional arguments"
                                     _maybe-arg702_))))))
        (std/srfi/1#filter!
         (lambda (_elt707_) (not (_=705_ _key698_ (car _elt707_))))
         _alist699_))))
  (define std/srfi/1#find-tail
    (lambda (_pred691_ _list692_)
      (if (procedure? _pred691_)
          _pred691_
          (error '"Bad argument" _pred691_ 'procedure? 'find-tail))
      (let _lp694_ ((_list696_ _list692_))
        (if (not (std/srfi/1#null-list? _list696_))
            (if (_pred691_ (car _list696_))
                _list696_
                (_lp694_ (cdr _list696_)))
            '#f))))
  (define std/srfi/1#take-while
    (lambda (_pred682_ _lis683_)
      (if (procedure? _pred682_)
          _pred682_
          (error '"Bad argument" _pred682_ 'procedure? 'take-while))
      (let _recur685_ ((_lis687_ _lis683_))
        (if (std/srfi/1#null-list? _lis687_)
            '()
            (let ((_x689_ (car _lis687_)))
              (if (_pred682_ _x689_)
                  (cons _x689_ (_recur685_ (cdr _lis687_)))
                  '()))))))
  (define std/srfi/1#drop-while
    (lambda (_pred675_ _lis676_)
      (if (procedure? _pred675_)
          _pred675_
          (error '"Bad argument" _pred675_ 'procedure? 'drop-while))
      (let _lp678_ ((_lis680_ _lis676_))
        (if (std/srfi/1#null-list? _lis680_)
            '()
            (if (_pred675_ (car _lis680_))
                (_lp678_ (cdr _lis680_))
                _lis680_)))))
  (define std/srfi/1#take-while!
    (lambda (_pred662_ _lis663_)
      (if (procedure? _pred662_)
          _pred662_
          (error '"Bad argument" _pred662_ 'procedure? 'take-while!))
      (if (or (std/srfi/1#null-list? _lis663_)
              (not (_pred662_ (car _lis663_))))
          '()
          (begin
            (let _lp668_ ((_prev670_ _lis663_) (_rest671_ (cdr _lis663_)))
              (if (pair? _rest671_)
                  (let ((_x673_ (car _rest671_)))
                    (if (_pred662_ _x673_)
                        (_lp668_ _rest671_ (cdr _rest671_))
                        (set-cdr! _prev670_ '())))
                  '#!void))
            _lis663_))))
  (define std/srfi/1#span
    (lambda (_pred650_ _lis651_)
      (if (procedure? _pred650_)
          _pred650_
          (error '"Bad argument" _pred650_ 'procedure? 'span))
      (let _recur653_ ((_lis655_ _lis651_))
        (if (std/srfi/1#null-list? _lis655_)
            (values '() '())
            (let ((_x657_ (car _lis655_)))
              (if (_pred650_ _x657_)
                  (let ((_g5215_ (_recur653_ (cdr _lis655_))))
                    (begin
                      (let ((_g5216_ (let ()
                                       (declare (not safe))
                                       (if (##values? _g5215_)
                                           (##vector-length _g5215_)
                                           1))))
                        (if (not (let ()
                                   (declare (not safe))
                                   (##fx= _g5216_ 2)))
                            (error "Context expects 2 values" _g5216_)))
                      (let ((_prefix659_
                             (let ()
                               (declare (not safe))
                               (##vector-ref _g5215_ 0)))
                            (_suffix660_
                             (let ()
                               (declare (not safe))
                               (##vector-ref _g5215_ 1))))
                        (values (cons _x657_ _prefix659_) _suffix660_))))
                  (values '() _lis655_)))))))
  (define std/srfi/1#span!
    (lambda (_pred635_ _lis636_)
      (if (procedure? _pred635_)
          _pred635_
          (error '"Bad argument" _pred635_ 'procedure? 'span!))
      (if (or (std/srfi/1#null-list? _lis636_)
              (not (_pred635_ (car _lis636_))))
          (values '() _lis636_)
          (let ((_suffix648_
                 (let _lp641_ ((_prev643_ _lis636_) (_rest644_ (cdr _lis636_)))
                   (if (std/srfi/1#null-list? _rest644_)
                       _rest644_
                       (let ((_x646_ (car _rest644_)))
                         (if (_pred635_ _x646_)
                             (_lp641_ _rest644_ (cdr _rest644_))
                             (begin (set-cdr! _prev643_ '()) _rest644_)))))))
            (values _lis636_ _suffix648_)))))
  (define std/srfi/1#break
    (lambda (_pred630_ _lis631_)
      (std/srfi/1#span (lambda (_x633_) (not (_pred630_ _x633_))) _lis631_)))
  (define std/srfi/1#break!
    (lambda (_pred625_ _lis626_)
      (std/srfi/1#span! (lambda (_x628_) (not (_pred625_ _x628_))) _lis626_)))
  (define std/srfi/1#any
    (lambda (_pred599_ _lis1600_ . _lists601_)
      (if (procedure? _pred599_)
          _pred599_
          (error '"Bad argument" _pred599_ 'procedure? 'any))
      (if (pair? _lists601_)
          (let ((_g5217_ (std/srfi/1#%cars+cdrs (cons _lis1600_ _lists601_))))
            (begin
              (let ((_g5218_ (let ()
                               (declare (not safe))
                               (if (##values? _g5217_)
                                   (##vector-length _g5217_)
                                   1))))
                (if (not (let () (declare (not safe)) (##fx= _g5218_ 2)))
                    (error "Context expects 2 values" _g5218_)))
              (let ((_heads603_
                     (let () (declare (not safe)) (##vector-ref _g5217_ 0)))
                    (_tails604_
                     (let () (declare (not safe)) (##vector-ref _g5217_ 1))))
                (if (pair? _heads603_)
                    (let _lp606_ ((_heads608_ _heads603_)
                                  (_tails609_ _tails604_))
                      (let ((_g5219_ (std/srfi/1#%cars+cdrs _tails609_)))
                        (begin
                          (let ((_g5220_ (let ()
                                           (declare (not safe))
                                           (if (##values? _g5219_)
                                               (##vector-length _g5219_)
                                               1))))
                            (if (not (let ()
                                       (declare (not safe))
                                       (##fx= _g5220_ 2)))
                                (error "Context expects 2 values" _g5220_)))
                          (let ((_next-heads611_
                                 (let ()
                                   (declare (not safe))
                                   (##vector-ref _g5219_ 0)))
                                (_next-tails612_
                                 (let ()
                                   (declare (not safe))
                                   (##vector-ref _g5219_ 1))))
                            (if (pair? _next-heads611_)
                                (let ((_$e614_ (apply _pred599_ _heads608_)))
                                  (if _$e614_
                                      _$e614_
                                      (_lp606_ _next-heads611_
                                               _next-tails612_)))
                                (apply _pred599_ _heads608_))))))
                    '#f))))
          (if (not (std/srfi/1#null-list? _lis1600_))
              (let _lp617_ ((_head619_ (car _lis1600_))
                            (_tail620_ (cdr _lis1600_)))
                (if (std/srfi/1#null-list? _tail620_)
                    (_pred599_ _head619_)
                    (let ((_$e622_ (_pred599_ _head619_)))
                      (if _$e622_
                          _$e622_
                          (_lp617_ (car _tail620_) (cdr _tail620_))))))
              '#f))))
  (define std/srfi/1#every
    (lambda (_pred573_ _lis1574_ . _lists575_)
      (if (procedure? _pred573_)
          _pred573_
          (error '"Bad argument" _pred573_ 'procedure? 'every))
      (if (pair? _lists575_)
          (let ((_g5221_ (std/srfi/1#%cars+cdrs (cons _lis1574_ _lists575_))))
            (begin
              (let ((_g5222_ (let ()
                               (declare (not safe))
                               (if (##values? _g5221_)
                                   (##vector-length _g5221_)
                                   1))))
                (if (not (let () (declare (not safe)) (##fx= _g5222_ 2)))
                    (error "Context expects 2 values" _g5222_)))
              (let ((_heads577_
                     (let () (declare (not safe)) (##vector-ref _g5221_ 0)))
                    (_tails578_
                     (let () (declare (not safe)) (##vector-ref _g5221_ 1))))
                (let ((_$e580_ (not (pair? _heads577_))))
                  (if _$e580_
                      _$e580_
                      (let _lp583_ ((_heads585_ _heads577_)
                                    (_tails586_ _tails578_))
                        (let ((_g5223_ (std/srfi/1#%cars+cdrs _tails586_)))
                          (begin
                            (let ((_g5224_ (let ()
                                             (declare (not safe))
                                             (if (##values? _g5223_)
                                                 (##vector-length _g5223_)
                                                 1))))
                              (if (not (let ()
                                         (declare (not safe))
                                         (##fx= _g5224_ 2)))
                                  (error "Context expects 2 values" _g5224_)))
                            (let ((_next-heads588_
                                   (let ()
                                     (declare (not safe))
                                     (##vector-ref _g5223_ 0)))
                                  (_next-tails589_
                                   (let ()
                                     (declare (not safe))
                                     (##vector-ref _g5223_ 1))))
                              (if (pair? _next-heads588_)
                                  (if (apply _pred573_ _heads585_)
                                      (_lp583_ _next-heads588_ _next-tails589_)
                                      '#f)
                                  (apply _pred573_ _heads585_)))))))))))
          (let ((_$e591_ (std/srfi/1#null-list? _lis1574_)))
            (if _$e591_
                _$e591_
                (let _lp594_ ((_head596_ (car _lis1574_))
                              (_tail597_ (cdr _lis1574_)))
                  (if (std/srfi/1#null-list? _tail597_)
                      (_pred573_ _head596_)
                      (if (_pred573_ _head596_)
                          (_lp594_ (car _tail597_) (cdr _tail597_))
                          '#f))))))))
  (define std/srfi/1#list-index
    (lambda (_pred556_ _lis1557_ . _lists558_)
      (if (procedure? _pred556_)
          _pred556_
          (error '"Bad argument" _pred556_ 'procedure? 'list-index))
      (if (pair? _lists558_)
          (let _lp560_ ((_lists562_ (cons _lis1557_ _lists558_)) (_n563_ '0))
            (let ((_g5225_ (std/srfi/1#%cars+cdrs _lists562_)))
              (begin
                (let ((_g5226_ (let ()
                                 (declare (not safe))
                                 (if (##values? _g5225_)
                                     (##vector-length _g5225_)
                                     1))))
                  (if (not (let () (declare (not safe)) (##fx= _g5226_ 2)))
                      (error "Context expects 2 values" _g5226_)))
                (let ((_heads565_
                       (let () (declare (not safe)) (##vector-ref _g5225_ 0)))
                      (_tails566_
                       (let () (declare (not safe)) (##vector-ref _g5225_ 1))))
                  (if (pair? _heads565_)
                      (if (apply _pred556_ _heads565_)
                          _n563_
                          (_lp560_ _tails566_ (+ _n563_ '1)))
                      '#f)))))
          (let _lp568_ ((_lis570_ _lis1557_) (_n571_ '0))
            (if (not (std/srfi/1#null-list? _lis570_))
                (if (_pred556_ (car _lis570_))
                    _n571_
                    (_lp568_ (cdr _lis570_) (+ _n571_ '1)))
                '#f)))))
  (define std/srfi/1#reverse!
    (lambda (_lis547_)
      (let _lp549_ ((_lis551_ _lis547_) (_ans552_ '()))
        (if (std/srfi/1#null-list? _lis551_)
            _ans552_
            (let ((_tail554_ (cdr _lis551_)))
              (set-cdr! _lis551_ _ans552_)
              (_lp549_ _tail554_ _lis551_))))))
  (define std/srfi/1#%lset2<=
    (lambda (_=541_ _lis1542_ _lis2543_)
      (std/srfi/1#every
       (lambda (_x545_) (std/srfi/1#srfi-1-member__1 _x545_ _lis2543_ _=541_))
       _lis1542_)))
  (define std/srfi/1#lset<=
    (lambda (_=521_ . _lists522_)
      (if (procedure? _=521_)
          _=521_
          (error '"Bad argument" _=521_ 'procedure? 'lset<=))
      (let ((_$e524_ (not (pair? _lists522_))))
        (if _$e524_
            _$e524_
            (let _lp527_ ((_s1529_ (car _lists522_))
                          (_rest530_ (cdr _lists522_)))
              (let ((_$e532_ (not (pair? _rest530_))))
                (if _$e532_
                    _$e532_
                    (let ((_s2535_ (car _rest530_))
                          (_rest536_ (cdr _rest530_)))
                      (if (or (eq? _s2535_ _s1529_)
                              (std/srfi/1#%lset2<= _=521_ _s1529_ _s2535_))
                          (_lp527_ _s2535_ _rest536_)
                          '#f)))))))))
  (define std/srfi/1#lset=
    (lambda (_=501_ . _lists502_)
      (if (procedure? _=501_)
          _=501_
          (error '"Bad argument" _=501_ 'procedure? 'lset=))
      (let ((_$e504_ (not (pair? _lists502_))))
        (if _$e504_
            _$e504_
            (let _lp507_ ((_s1509_ (car _lists502_))
                          (_rest510_ (cdr _lists502_)))
              (let ((_$e512_ (not (pair? _rest510_))))
                (if _$e512_
                    _$e512_
                    (let ((_s2515_ (car _rest510_))
                          (_rest516_ (cdr _rest510_)))
                      (if (or (eq? _s1509_ _s2515_)
                              (and (std/srfi/1#%lset2<= _=501_ _s1509_ _s2515_)
                                   (std/srfi/1#%lset2<=
                                    _=501_
                                    _s2515_
                                    _s1509_)))
                          (_lp507_ _s2515_ _rest516_)
                          '#f)))))))))
  (define std/srfi/1#lset-adjoin
    (lambda (_=494_ _lis495_ . _elts496_)
      (if (procedure? _=494_)
          _=494_
          (error '"Bad argument" _=494_ 'procedure? 'lset-adjoin))
      (foldl1 (lambda (_elt498_ _ans499_)
                (if (std/srfi/1#srfi-1-member__1 _elt498_ _ans499_ _=494_)
                    _ans499_
                    (cons _elt498_ _ans499_)))
              _lis495_
              _elts496_)))
  (define std/srfi/1#lset-union
    (lambda (_=483_ . _lists484_)
      (if (procedure? _=483_)
          _=483_
          (error '"Bad argument" _=483_ 'procedure? 'lset-union))
      (std/srfi/1#reduce
       (lambda (_lis486_ _ans487_)
         (if (null? _lis486_)
             _ans487_
             (if (null? _ans487_)
                 _lis486_
                 (if (eq? _lis486_ _ans487_)
                     _ans487_
                     (foldl1 (lambda (_elt489_ _ans490_)
                               (if (std/srfi/1#any
                                    (lambda (_x492_) (_=483_ _x492_ _elt489_))
                                    _ans490_)
                                   _ans490_
                                   (cons _elt489_ _ans490_)))
                             _ans487_
                             _lis486_)))))
       '()
       _lists484_)))
  (define std/srfi/1#lset-union!
    (lambda (_=470_ . _lists471_)
      (if (procedure? _=470_)
          _=470_
          (error '"Bad argument" _=470_ 'procedure? 'lset-union!))
      (std/srfi/1#reduce
       (lambda (_lis473_ _ans474_)
         (if (null? _lis473_)
             _ans474_
             (if (null? _ans474_)
                 _lis473_
                 (if (eq? _lis473_ _ans474_)
                     _ans474_
                     (std/srfi/1#pair-fold
                      (lambda (_pair476_ _ans477_)
                        (let ((_elt479_ (car _pair476_)))
                          (if (std/srfi/1#any
                               (lambda (_x481_) (_=470_ _x481_ _elt479_))
                               _ans477_)
                              _ans477_
                              (begin
                                (set-cdr! _pair476_ _ans477_)
                                _pair476_))))
                      _ans474_
                      _lis473_)))))
       '()
       _lists471_)))
  (define std/srfi/1#lset-intersection
    (lambda (_=460_ _lis1461_ . _lists462_)
      (if (procedure? _=460_)
          _=460_
          (error '"Bad argument" _=460_ 'procedure? 'lset-intersection))
      (let ((_lists464_ (std/srfi/1#delete _lis1461_ _lists462_ eq?)))
        (if (std/srfi/1#any std/srfi/1#null-list? _lists464_)
            '()
            (if (null? _lists464_)
                _lis1461_
                (filter (lambda (_x466_)
                          (std/srfi/1#every
                           (lambda (_lis468_)
                             (std/srfi/1#srfi-1-member__1
                              _x466_
                              _lis468_
                              _=460_))
                           _lists464_))
                        _lis1461_))))))
  (define std/srfi/1#lset-intersection!
    (lambda (_=450_ _lis1451_ . _lists452_)
      (if (procedure? _=450_)
          _=450_
          (error '"Bad argument" _=450_ 'procedure? 'lset-intersection!))
      (let ((_lists454_ (std/srfi/1#delete _lis1451_ _lists452_ eq?)))
        (if (std/srfi/1#any std/srfi/1#null-list? _lists454_)
            '()
            (if (null? _lists454_)
                _lis1451_
                (std/srfi/1#filter!
                 (lambda (_x456_)
                   (std/srfi/1#every
                    (lambda (_lis458_)
                      (std/srfi/1#srfi-1-member__1 _x456_ _lis458_ _=450_))
                    _lists454_))
                 _lis1451_))))))
  (define std/srfi/1#lset-difference
    (lambda (_=440_ _lis1441_ . _lists442_)
      (if (procedure? _=440_)
          _=440_
          (error '"Bad argument" _=440_ 'procedure? 'lset-difference))
      (let ((_lists444_ (filter pair? _lists442_)))
        (if (null? _lists444_)
            _lis1441_
            (if (memq _lis1441_ _lists444_)
                '()
                (filter (lambda (_x446_)
                          (std/srfi/1#every
                           (lambda (_lis448_)
                             (not (std/srfi/1#srfi-1-member__1
                                   _x446_
                                   _lis448_
                                   _=440_)))
                           _lists444_))
                        _lis1441_))))))
  (define std/srfi/1#lset-difference!
    (lambda (_=430_ _lis1431_ . _lists432_)
      (if (procedure? _=430_)
          _=430_
          (error '"Bad argument" _=430_ 'procedure? 'lset-difference!))
      (let ((_lists434_ (filter pair? _lists432_)))
        (if (null? _lists434_)
            _lis1431_
            (if (memq _lis1431_ _lists434_)
                '()
                (std/srfi/1#filter!
                 (lambda (_x436_)
                   (std/srfi/1#every
                    (lambda (_lis438_)
                      (not (std/srfi/1#srfi-1-member__1
                            _x436_
                            _lis438_
                            _=430_)))
                    _lists434_))
                 _lis1431_))))))
  (define std/srfi/1#lset-xor
    (lambda (_=418_ . _lists419_)
      (if (procedure? _=418_)
          _=418_
          (error '"Bad argument" _=418_ 'procedure? 'lset-xor))
      (std/srfi/1#reduce
       (lambda (_b421_ _a422_)
         (let ((_g5227_ (std/srfi/1#lset-diff+intersection
                         _=418_
                         _a422_
                         _b421_)))
           (begin
             (let ((_g5228_ (let ()
                              (declare (not safe))
                              (if (##values? _g5227_)
                                  (##vector-length _g5227_)
                                  1))))
               (if (not (let () (declare (not safe)) (##fx= _g5228_ 2)))
                   (error "Context expects 2 values" _g5228_)))
             (let ((_a-b424_
                    (let () (declare (not safe)) (##vector-ref _g5227_ 0)))
                   (_a-int-b425_
                    (let () (declare (not safe)) (##vector-ref _g5227_ 1))))
               (if (null? _a-b424_)
                   (std/srfi/1#lset-difference _=418_ _b421_ _a422_)
                   (if (null? _a-int-b425_)
                       (append _b421_ _a422_)
                       (foldl1 (lambda (_xb427_ _ans428_)
                                 (if (std/srfi/1#srfi-1-member__1
                                      _xb427_
                                      _a-int-b425_
                                      _=418_)
                                     _ans428_
                                     (cons _xb427_ _ans428_)))
                               _a-b424_
                               _b421_)))))))
       '()
       _lists419_)))
  (define std/srfi/1#lset-xor!
    (lambda (_=406_ . _lists407_)
      (if (procedure? _=406_)
          _=406_
          (error '"Bad argument" _=406_ 'procedure? 'lset-xor!))
      (std/srfi/1#reduce
       (lambda (_b409_ _a410_)
         (let ((_g5229_ (std/srfi/1#lset-diff+intersection!
                         _=406_
                         _a410_
                         _b409_)))
           (begin
             (let ((_g5230_ (let ()
                              (declare (not safe))
                              (if (##values? _g5229_)
                                  (##vector-length _g5229_)
                                  1))))
               (if (not (let () (declare (not safe)) (##fx= _g5230_ 2)))
                   (error "Context expects 2 values" _g5230_)))
             (let ((_a-b412_
                    (let () (declare (not safe)) (##vector-ref _g5229_ 0)))
                   (_a-int-b413_
                    (let () (declare (not safe)) (##vector-ref _g5229_ 1))))
               (if (null? _a-b412_)
                   (std/srfi/1#lset-difference! _=406_ _b409_ _a410_)
                   (if (null? _a-int-b413_)
                       (std/srfi/1#append! _b409_ _a410_)
                       (std/srfi/1#pair-fold
                        (lambda (_b-pair415_ _ans416_)
                          (if (std/srfi/1#srfi-1-member__1
                               (car _b-pair415_)
                               _a-int-b413_
                               _=406_)
                              _ans416_
                              (begin
                                (set-cdr! _b-pair415_ _ans416_)
                                _b-pair415_)))
                        _a-b412_
                        _b409_)))))))
       '()
       _lists407_)))
  (define std/srfi/1#lset-diff+intersection
    (lambda (_=398_ _lis1399_ . _lists400_)
      (if (procedure? _=398_)
          _=398_
          (error '"Bad argument" _=398_ 'procedure? 'lset-diff+intersection))
      (if (std/srfi/1#every std/srfi/1#null-list? _lists400_)
          (values _lis1399_ '())
          (if (memq _lis1399_ _lists400_)
              (values '() _lis1399_)
              (std/srfi/1#partition
               (lambda (_elt402_)
                 (not (std/srfi/1#any
                       (lambda (_lis404_)
                         (std/srfi/1#srfi-1-member__1
                          _elt402_
                          _lis404_
                          _=398_))
                       _lists400_)))
               _lis1399_)))))
  (define std/srfi/1#lset-diff+intersection!
    (lambda (_=390_ _lis1391_ . _lists392_)
      (if (procedure? _=390_)
          _=390_
          (error '"Bad argument" _=390_ 'procedure? 'lset-diff+intersection!))
      (if (std/srfi/1#every std/srfi/1#null-list? _lists392_)
          (values _lis1391_ '())
          (if (memq _lis1391_ _lists392_)
              (values '() _lis1391_)
              (std/srfi/1#partition!
               (lambda (_elt394_)
                 (not (std/srfi/1#any
                       (lambda (_lis396_)
                         (std/srfi/1#srfi-1-member__1
                          _elt394_
                          _lis396_
                          _=390_))
                       _lists392_)))
               _lis1391_))))))
