aboutsummaryrefslogtreecommitdiff
path: root/src/algebra/strap/UPOLYC-.lsp
blob: c6c77d4bfdca73bc32e7a6fffba68637fc5ad661 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
(/VERSIONCHECK 2) 

(DEFUN |UPOLYC-;variables;SL;1| (|p| $)
  (COND
    ((OR (SPADCALL |p| (|getShellEntry| $ 9))
         (ZEROP (SPADCALL |p| (|getShellEntry| $ 11))))
     NIL)
    ('T (LIST (SPADCALL (|getShellEntry| $ 13)))))) 

(DEFUN |UPOLYC-;degree;SSaosNni;2| (|p| |v| $)
  (SPADCALL |p| (|getShellEntry| $ 11))) 

(DEFUN |UPOLYC-;totalDegree;SLNni;3| (|p| |lv| $)
  (COND ((NULL |lv|) 0) ('T (SPADCALL |p| (|getShellEntry| $ 17))))) 

(DEFUN |UPOLYC-;degree;SLL;4| (|p| |lv| $)
  (COND
    ((NULL |lv|) NIL)
    ('T (LIST (SPADCALL |p| (|getShellEntry| $ 11)))))) 

(DEFUN |UPOLYC-;eval;SLLS;5| (|p| |lv| |lq| $)
  (COND
    ((NULL |lv|) |p|)
    ((NULL (NULL (CDR |lv|)))
     (|error| "can only eval a univariate polynomial once"))
    ('T
     (SPADCALL |p| (|SPADfirst| |lv|) (|SPADfirst| |lq|)
         (|getShellEntry| $ 21))))) 

(DEFUN |UPOLYC-;eval;SSaos2S;6| (|p| |v| |q| $)
  (SPADCALL |p| |q| (|getShellEntry| $ 24))) 

(DEFUN |UPOLYC-;eval;SLLS;7| (|p| |lv| |lr| $)
  (COND
    ((NULL |lv|) |p|)
    ((NULL (NULL (CDR |lv|)))
     (|error| "can only eval a univariate polynomial once"))
    ('T
     (SPADCALL |p| (|SPADfirst| |lv|) (|SPADfirst| |lr|)
         (|getShellEntry| $ 26))))) 

(DEFUN |UPOLYC-;eval;SSaosRS;8| (|p| |v| |r| $)
  (SPADCALL (SPADCALL |p| |r| (|getShellEntry| $ 29))
      (|getShellEntry| $ 30))) 

(DEFUN |UPOLYC-;eval;SLS;9| (|p| |le| $)
  (COND
    ((NULL |le|) |p|)
    ((NULL (NULL (CDR |le|)))
     (|error| "can only eval a univariate polynomial once"))
    ('T
     (COND
       ((QEQCAR (SPADCALL
                    (SPADCALL (|SPADfirst| |le|)
                        (|getShellEntry| $ 33))
                    (|getShellEntry| $ 35))
                1)
        |p|)
       ('T
        (SPADCALL |p|
            (SPADCALL (|SPADfirst| |le|) (|getShellEntry| $ 36))
            (|getShellEntry| $ 24))))))) 

(DEFUN |UPOLYC-;mainVariable;SU;10| (|p| $)
  (COND
    ((ZEROP (SPADCALL |p| (|getShellEntry| $ 11))) (CONS 1 "failed"))
    ('T (CONS 0 (SPADCALL (|getShellEntry| $ 13)))))) 

(DEFUN |UPOLYC-;minimumDegree;SSaosNni;11| (|p| |v| $)
  (SPADCALL |p| (|getShellEntry| $ 41))) 

(DEFUN |UPOLYC-;minimumDegree;SLL;12| (|p| |lv| $)
  (COND
    ((NULL |lv|) NIL)
    ('T (LIST (SPADCALL |p| (|getShellEntry| $ 41)))))) 

(DEFUN |UPOLYC-;monomial;SSaosNniS;13| (|p| |v| |n| $)
  (SPADCALL (CONS #'|UPOLYC-;monomial;SSaosNniS;13!0| (VECTOR $ |n|))
      |p| (|getShellEntry| $ 46))) 

(DEFUN |UPOLYC-;monomial;SSaosNniS;13!0| (|#1| $$)
  (SPADCALL |#1| (|getShellEntry| $$ 1)
      (|getShellEntry| (|getShellEntry| $$ 0) 44))) 

(DEFUN |UPOLYC-;coerce;SaosS;14| (|v| $)
  (SPADCALL (|spadConstant| $ 49) 1 (|getShellEntry| $ 50))) 

(DEFUN |UPOLYC-;makeSUP;SSup;15| (|p| $)
  (COND
    ((SPADCALL |p| (|getShellEntry| $ 9)) (|spadConstant| $ 53))
    ('T
     (SPADCALL
         (SPADCALL (SPADCALL |p| (|getShellEntry| $ 54))
             (SPADCALL |p| (|getShellEntry| $ 11))
             (|getShellEntry| $ 55))
         (SPADCALL (SPADCALL |p| (|getShellEntry| $ 56))
             (|getShellEntry| $ 57))
         (|getShellEntry| $ 58))))) 

(DEFUN |UPOLYC-;unmakeSUP;SupS;16| (|sp| $)
  (COND
    ((SPADCALL |sp| (|getShellEntry| $ 60)) (|spadConstant| $ 61))
    ('T
     (SPADCALL
         (SPADCALL (SPADCALL |sp| (|getShellEntry| $ 62))
             (SPADCALL |sp| (|getShellEntry| $ 63))
             (|getShellEntry| $ 50))
         (SPADCALL (SPADCALL |sp| (|getShellEntry| $ 64))
             (|getShellEntry| $ 65))
         (|getShellEntry| $ 66))))) 

(DEFUN |UPOLYC-;karatsubaDivide;SNniR;17| (|p| |n| $)
  (SPADCALL |p|
      (SPADCALL (|spadConstant| $ 49) |n| (|getShellEntry| $ 50))
      (|getShellEntry| $ 69))) 

(DEFUN |UPOLYC-;shiftRight;SNniS;18| (|p| |n| $)
  (QCAR (SPADCALL |p|
            (SPADCALL (|spadConstant| $ 49) |n| (|getShellEntry| $ 50))
            (|getShellEntry| $ 69)))) 

(DEFUN |UPOLYC-;shiftLeft;SNniS;19| (|p| |n| $)
  (SPADCALL |p|
      (SPADCALL (|spadConstant| $ 49) |n| (|getShellEntry| $ 50))
      (|getShellEntry| $ 72))) 

(DEFUN |UPOLYC-;solveLinearPolynomialEquation;LSupU;20| (|lpp| |pp| $)
  (SPADCALL |lpp| |pp| (|getShellEntry| $ 78))) 

(DEFUN |UPOLYC-;factorPolynomial;SupF;21| (|pp| $)
  (SPADCALL |pp| (|getShellEntry| $ 84))) 

(DEFUN |UPOLYC-;factorSquareFreePolynomial;SupF;22| (|pp| $)
  (SPADCALL |pp| (|getShellEntry| $ 87))) 

(DEFUN |UPOLYC-;factor;SF;23| (|p| $)
  (PROG (|ansR| #0=#:G1518 |w| #1=#:G1519)
    (RETURN
      (SEQ (COND
             ((ZEROP (SPADCALL |p| (|getShellEntry| $ 11)))
              (SEQ (LETT |ansR|
                         (SPADCALL
                             (SPADCALL |p| (|getShellEntry| $ 54))
                             (|getShellEntry| $ 90))
                         |UPOLYC-;factor;SF;23|)
                   (EXIT (SPADCALL
                             (SPADCALL
                                 (SPADCALL |ansR|
                                     (|getShellEntry| $ 92))
                                 (|getShellEntry| $ 30))
                             (PROGN
                               (LETT #0# NIL |UPOLYC-;factor;SF;23|)
                               (SEQ (LETT |w| NIL
                                     |UPOLYC-;factor;SF;23|)
                                    (LETT #1#
                                     (SPADCALL |ansR|
                                      (|getShellEntry| $ 97))
                                     |UPOLYC-;factor;SF;23|)
                                    G190
                                    (COND
                                      ((OR (ATOM #1#)
                                        (PROGN
                                          (LETT |w| (CAR #1#)
                                           |UPOLYC-;factor;SF;23|)
                                          NIL))
                                       (GO G191)))
                                    (SEQ
                                     (EXIT
                                      (LETT #0#
                                       (CONS
                                        (VECTOR (QVELT |w| 0)
                                         (SPADCALL (QVELT |w| 1)
                                          (|getShellEntry| $ 30))
                                         (QVELT |w| 2))
                                        #0#)
                                       |UPOLYC-;factor;SF;23|)))
                                    (LETT #1# (CDR #1#)
                                     |UPOLYC-;factor;SF;23|)
                                    (GO G190) G191
                                    (EXIT (NREVERSE0 #0#))))
                             (|getShellEntry| $ 101)))))
             ('T
              (SPADCALL (ELT $ 65)
                  (SPADCALL (SPADCALL |p| (|getShellEntry| $ 57))
                      (|getShellEntry| $ 102))
                  (|getShellEntry| $ 106)))))))) 

(DEFUN |UPOLYC-;vectorise;SNniV;24| (|p| |n| $)
  (PROG (|v| |m| |i| #0=#:G1524 #1=#:G1520)
    (RETURN
      (SEQ (LETT |m|
                 (SPADCALL
                     (LETT |v|
                           (SPADCALL |n| (|spadConstant| $ 108)
                               (|getShellEntry| $ 110))
                           |UPOLYC-;vectorise;SNniV;24|)
                     (|getShellEntry| $ 111))
                 |UPOLYC-;vectorise;SNniV;24|)
           (SEQ (LETT |i| (SPADCALL |v| (|getShellEntry| $ 111))
                      |UPOLYC-;vectorise;SNniV;24|)
                (LETT #0# (QVSIZE |v|) |UPOLYC-;vectorise;SNniV;24|)
                G190 (COND ((> |i| #0#) (GO G191)))
                (SEQ (EXIT (SPADCALL |v| |i|
                               (SPADCALL |p|
                                         (PROG1
                                          (LETT #1# (- |i| |m|)
                                           |UPOLYC-;vectorise;SNniV;24|)
                                           (|check-subtype| (>= #1# 0)
                                            '(|NonNegativeInteger|)
                                            #1#))
                                         (|getShellEntry| $ 112))
                               (|getShellEntry| $ 113))))
                (LETT |i| (+ |i| 1) |UPOLYC-;vectorise;SNniV;24|)
                (GO G190) G191 (EXIT NIL))
           (EXIT |v|))))) 

(DEFUN |UPOLYC-;retract;SR;25| (|p| $)
  (COND
    ((SPADCALL |p| (|getShellEntry| $ 9)) (|spadConstant| $ 108))
    ((ZEROP (SPADCALL |p| (|getShellEntry| $ 11)))
     (SPADCALL |p| (|getShellEntry| $ 54)))
    ('T (|error| "Polynomial is not of degree 0")))) 

(DEFUN |UPOLYC-;retractIfCan;SU;26| (|p| $)
  (COND
    ((SPADCALL |p| (|getShellEntry| $ 9))
     (CONS 0 (|spadConstant| $ 108)))
    ((ZEROP (SPADCALL |p| (|getShellEntry| $ 11)))
     (CONS 0 (SPADCALL |p| (|getShellEntry| $ 54))))
    ('T (CONS 1 "failed")))) 

(DEFUN |UPOLYC-;init;S;27| ($)
  (SPADCALL (|spadConstant| $ 118) (|getShellEntry| $ 30))) 

(DEFUN |UPOLYC-;nextItemInner| (|n| $)
  (PROG (|nn| |n1| |n2| #0=#:G1545 |n3|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |n| (|getShellEntry| $ 9))
              (CONS 0
                    (SPADCALL
                        (PROG2 (LETT #0#
                                     (SPADCALL (|spadConstant| $ 108)
                                      (|getShellEntry| $ 121))
                                     |UPOLYC-;nextItemInner|)
                               (QCDR #0#)
                          (|check-union| (QEQCAR #0# 0)
                              (|getShellEntry| $ 7) #0#))
                        (|getShellEntry| $ 30))))
             ((ZEROP (SPADCALL |n| (|getShellEntry| $ 11)))
              (SEQ (LETT |nn|
                         (SPADCALL
                             (SPADCALL |n| (|getShellEntry| $ 54))
                             (|getShellEntry| $ 121))
                         |UPOLYC-;nextItemInner|)
                   (EXIT (COND
                           ((QEQCAR |nn| 1) (CONS 1 "failed"))
                           ('T
                            (CONS 0
                                  (SPADCALL (QCDR |nn|)
                                      (|getShellEntry| $ 30))))))))
             ('T
              (SEQ (LETT |n1| (SPADCALL |n| (|getShellEntry| $ 56))
                         |UPOLYC-;nextItemInner|)
                   (LETT |n2| (|UPOLYC-;nextItemInner| |n1| $)
                         |UPOLYC-;nextItemInner|)
                   (EXIT (COND
                           ((QEQCAR |n2| 0)
                            (CONS 0
                                  (SPADCALL
                                      (SPADCALL
                                       (SPADCALL |n|
                                        (|getShellEntry| $ 54))
                                       (SPADCALL |n|
                                        (|getShellEntry| $ 11))
                                       (|getShellEntry| $ 50))
                                      (QCDR |n2|)
                                      (|getShellEntry| $ 66))))
                           ((< (+ 1
                                  (SPADCALL |n1|
                                      (|getShellEntry| $ 11)))
                               (SPADCALL |n| (|getShellEntry| $ 11)))
                            (CONS 0
                                  (SPADCALL
                                      (SPADCALL
                                       (SPADCALL |n|
                                        (|getShellEntry| $ 54))
                                       (SPADCALL |n|
                                        (|getShellEntry| $ 11))
                                       (|getShellEntry| $ 50))
                                      (SPADCALL
                                       (PROG2
                                        (LETT #0#
                                         (SPADCALL
                                          (|spadConstant| $ 118)
                                          (|getShellEntry| $ 121))
                                         |UPOLYC-;nextItemInner|)
                                        (QCDR #0#)
                                         (|check-union| (QEQCAR #0# 0)
                                          (|getShellEntry| $ 7) #0#))
                                       (+ 1
                                        (SPADCALL |n1|
                                         (|getShellEntry| $ 11)))
                                       (|getShellEntry| $ 50))
                                      (|getShellEntry| $ 66))))
                           ('T
                            (SEQ (LETT |n3|
                                       (SPADCALL
                                        (SPADCALL |n|
                                         (|getShellEntry| $ 54))
                                        (|getShellEntry| $ 121))
                                       |UPOLYC-;nextItemInner|)
                                 (EXIT (COND
                                         ((QEQCAR |n3| 1)
                                          (CONS 1 "failed"))
                                         ('T
                                          (CONS 0
                                           (SPADCALL (QCDR |n3|)
                                            (SPADCALL |n|
                                             (|getShellEntry| $ 11))
                                            (|getShellEntry| $ 50))))))))))))))))) 

(DEFUN |UPOLYC-;nextItem;SU;29| (|n| $)
  (PROG (|n1| #0=#:G1558)
    (RETURN
      (SEQ (LETT |n1| (|UPOLYC-;nextItemInner| |n| $)
                 |UPOLYC-;nextItem;SU;29|)
           (EXIT (COND
                   ((QEQCAR |n1| 1)
                    (CONS 0
                          (SPADCALL
                              (PROG2 (LETT #0#
                                      (SPADCALL (|spadConstant| $ 118)
                                       (|getShellEntry| $ 121))
                                      |UPOLYC-;nextItem;SU;29|)
                                     (QCDR #0#)
                                (|check-union| (QEQCAR #0# 0)
                                    (|getShellEntry| $ 7) #0#))
                              (+ 1
                                 (SPADCALL |n| (|getShellEntry| $ 11)))
                              (|getShellEntry| $ 50))))
                   ('T |n1|))))))) 

(DEFUN |UPOLYC-;content;SSaosS;30| (|p| |v| $)
  (SPADCALL (SPADCALL |p| (|getShellEntry| $ 124))
      (|getShellEntry| $ 30))) 

(DEFUN |UPOLYC-;primeFactor| (|p| |q| $)
  (PROG (#0=#:G1564 |p1|)
    (RETURN
      (SEQ (LETT |p1|
                 (PROG2 (LETT #0#
                              (SPADCALL |p|
                                        (SPADCALL |p| |q|
                                         (|getShellEntry| $ 126))
                                        (|getShellEntry| $ 127))
                              |UPOLYC-;primeFactor|)
                        (QCDR #0#)
                   (|check-union| (QEQCAR #0# 0) (|getShellEntry| $ 6)
                       #0#))
                 |UPOLYC-;primeFactor|)
           (EXIT (COND
                   ((SPADCALL |p1| |p| (|getShellEntry| $ 128)) |p|)
                   ('T (|UPOLYC-;primeFactor| |p1| |q| $)))))))) 

(DEFUN |UPOLYC-;separate;2SR;32| (|p| |q| $)
  (PROG (|a| #0=#:G1570)
    (RETURN
      (SEQ (LETT |a| (|UPOLYC-;primeFactor| |p| |q| $)
                 |UPOLYC-;separate;2SR;32|)
           (EXIT (CONS |a|
                       (PROG2 (LETT #0#
                                    (SPADCALL |p| |a|
                                     (|getShellEntry| $ 127))
                                    |UPOLYC-;separate;2SR;32|)
                              (QCDR #0#)
                         (|check-union| (QEQCAR #0# 0)
                             (|getShellEntry| $ 6) #0#)))))))) 

(DEFUN |UPOLYC-;differentiate;SM2S;33| (|x| |deriv| |x'| $)
  (PROG (|dg| |lc| #0=#:G1575 |d|)
    (RETURN
      (SEQ (LETT |d| (|spadConstant| $ 61)
                 |UPOLYC-;differentiate;SM2S;33|)
           (SEQ G190
                (COND
                  ((NULL (< 0
                            (LETT |dg|
                                  (SPADCALL |x| (|getShellEntry| $ 11))
                                  |UPOLYC-;differentiate;SM2S;33|)))
                   (GO G191)))
                (SEQ (LETT |lc| (SPADCALL |x| (|getShellEntry| $ 54))
                           |UPOLYC-;differentiate;SM2S;33|)
                     (LETT |d|
                           (SPADCALL
                               (SPADCALL |d|
                                   (SPADCALL |x'|
                                    (SPADCALL
                                     (SPADCALL |dg| |lc|
                                      (|getShellEntry| $ 132))
                                     (PROG1
                                      (LETT #0# (- |dg| 1)
                                       |UPOLYC-;differentiate;SM2S;33|)
                                       (|check-subtype| (>= #0# 0)
                                        '(|NonNegativeInteger|) #0#))
                                     (|getShellEntry| $ 50))
                                    (|getShellEntry| $ 72))
                                   (|getShellEntry| $ 66))
                               (SPADCALL (SPADCALL |lc| |deriv|) |dg|
                                   (|getShellEntry| $ 50))
                               (|getShellEntry| $ 66))
                           |UPOLYC-;differentiate;SM2S;33|)
                     (EXIT (LETT |x|
                                 (SPADCALL |x| (|getShellEntry| $ 56))
                                 |UPOLYC-;differentiate;SM2S;33|)))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT (SPADCALL |d|
                     (SPADCALL
                         (SPADCALL
                             (SPADCALL |x| (|getShellEntry| $ 54))
                             |deriv|)
                         (|getShellEntry| $ 30))
                     (|getShellEntry| $ 66))))))) 

(DEFUN |UPOLYC-;ncdiff| (|n| |x'| $)
  (PROG (#0=#:G1593 |n1|)
    (RETURN
      (COND
        ((ZEROP |n|) (|spadConstant| $ 61))
        ((ZEROP (LETT |n1|
                      (PROG1 (LETT #0# (- |n| 1) |UPOLYC-;ncdiff|)
                        (|check-subtype| (>= #0# 0)
                            '(|NonNegativeInteger|) #0#))
                      |UPOLYC-;ncdiff|))
         |x'|)
        ('T
         (SPADCALL
             (SPADCALL |x'|
                 (SPADCALL (|spadConstant| $ 49) |n1|
                     (|getShellEntry| $ 50))
                 (|getShellEntry| $ 72))
             (SPADCALL
                 (SPADCALL (|spadConstant| $ 49) 1
                     (|getShellEntry| $ 50))
                 (|UPOLYC-;ncdiff| |n1| |x'| $) (|getShellEntry| $ 72))
             (|getShellEntry| $ 66))))))) 

(DEFUN |UPOLYC-;differentiate;SM2S;35| (|x| |deriv| |x'| $)
  (PROG (|dg| |lc| |d|)
    (RETURN
      (SEQ (LETT |d| (|spadConstant| $ 61)
                 |UPOLYC-;differentiate;SM2S;35|)
           (SEQ G190
                (COND
                  ((NULL (< 0
                            (LETT |dg|
                                  (SPADCALL |x| (|getShellEntry| $ 11))
                                  |UPOLYC-;differentiate;SM2S;35|)))
                   (GO G191)))
                (SEQ (LETT |lc| (SPADCALL |x| (|getShellEntry| $ 54))
                           |UPOLYC-;differentiate;SM2S;35|)
                     (LETT |d|
                           (SPADCALL
                               (SPADCALL |d|
                                   (SPADCALL (SPADCALL |lc| |deriv|)
                                    |dg| (|getShellEntry| $ 50))
                                   (|getShellEntry| $ 66))
                               (SPADCALL |lc|
                                   (|UPOLYC-;ncdiff| |dg| |x'| $)
                                   (|getShellEntry| $ 135))
                               (|getShellEntry| $ 66))
                           |UPOLYC-;differentiate;SM2S;35|)
                     (EXIT (LETT |x|
                                 (SPADCALL |x| (|getShellEntry| $ 56))
                                 |UPOLYC-;differentiate;SM2S;35|)))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT (SPADCALL |d|
                     (SPADCALL
                         (SPADCALL
                             (SPADCALL |x| (|getShellEntry| $ 54))
                             |deriv|)
                         (|getShellEntry| $ 30))
                     (|getShellEntry| $ 66))))))) 

(DEFUN |UPOLYC-;differentiate;SMS;36| (|x| |deriv| $)
  (SPADCALL |x| |deriv| (|spadConstant| $ 48) (|getShellEntry| $ 136))) 

(DEFUN |UPOLYC-;differentiate;2S;37| (|x| $)
  (PROG (|dg| #0=#:G1602 |d|)
    (RETURN
      (SEQ (LETT |d| (|spadConstant| $ 61)
                 |UPOLYC-;differentiate;2S;37|)
           (SEQ G190
                (COND
                  ((NULL (< 0
                            (LETT |dg|
                                  (SPADCALL |x| (|getShellEntry| $ 11))
                                  |UPOLYC-;differentiate;2S;37|)))
                   (GO G191)))
                (SEQ (LETT |d|
                           (SPADCALL |d|
                               (SPADCALL
                                   (SPADCALL |dg|
                                    (SPADCALL |x|
                                     (|getShellEntry| $ 54))
                                    (|getShellEntry| $ 132))
                                   (PROG1
                                    (LETT #0# (- |dg| 1)
                                     |UPOLYC-;differentiate;2S;37|)
                                     (|check-subtype| (>= #0# 0)
                                      '(|NonNegativeInteger|) #0#))
                                   (|getShellEntry| $ 50))
                               (|getShellEntry| $ 66))
                           |UPOLYC-;differentiate;2S;37|)
                     (EXIT (LETT |x|
                                 (SPADCALL |x| (|getShellEntry| $ 56))
                                 |UPOLYC-;differentiate;2S;37|)))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT |d|))))) 

(DEFUN |UPOLYC-;differentiate;SSaosS;38| (|x| |v| $)
  (SPADCALL |x| (|getShellEntry| $ 139))) 

(DEFUN |UPOLYC-;elt;3F;39| (|g| |f| $)
  (SPADCALL
      (SPADCALL (SPADCALL |g| (|getShellEntry| $ 142)) |f|
          (|getShellEntry| $ 144))
      (SPADCALL (SPADCALL |g| (|getShellEntry| $ 145)) |f|
          (|getShellEntry| $ 144))
      (|getShellEntry| $ 146))) 

(DEFUN |UPOLYC-;pseudoQuotient;3S;40| (|p| |q| $)
  (PROG (|n| #0=#:G1648 #1=#:G1650)
    (RETURN
      (SEQ (LETT |n|
                 (+ (- (SPADCALL |p| (|getShellEntry| $ 11))
                       (SPADCALL |q| (|getShellEntry| $ 11)))
                    1)
                 |UPOLYC-;pseudoQuotient;3S;40|)
           (EXIT (COND
                   ((< |n| 1) (|spadConstant| $ 61))
                   ('T
                    (PROG2 (LETT #1#
                                 (SPADCALL
                                     (SPADCALL
                                      (SPADCALL
                                       (SPADCALL
                                        (SPADCALL |q|
                                         (|getShellEntry| $ 54))
                                        (PROG1
                                         (LETT #0# |n|
                                          |UPOLYC-;pseudoQuotient;3S;40|)
                                          (|check-subtype| (>= #0# 0)
                                           '(|NonNegativeInteger|) #0#))
                                        (|getShellEntry| $ 148))
                                       |p| (|getShellEntry| $ 135))
                                      (SPADCALL |p| |q|
                                       (|getShellEntry| $ 149))
                                      (|getShellEntry| $ 150))
                                     |q| (|getShellEntry| $ 127))
                                 |UPOLYC-;pseudoQuotient;3S;40|)
                           (QCDR #1#)
                      (|check-union| (QEQCAR #1# 0)
                          (|getShellEntry| $ 6) #1#))))))))) 

(DEFUN |UPOLYC-;pseudoDivide;2SR;41| (|p| |q| $)
  (PROG (|n| |prem| #0=#:G1656 |lc| #1=#:G1658)
    (RETURN
      (SEQ (LETT |n|
                 (+ (- (SPADCALL |p| (|getShellEntry| $ 11))
                       (SPADCALL |q| (|getShellEntry| $ 11)))
                    1)
                 |UPOLYC-;pseudoDivide;2SR;41|)
           (EXIT (COND
                   ((< |n| 1)
                    (VECTOR (|spadConstant| $ 49) (|spadConstant| $ 61)
                            |p|))
                   ('T
                    (SEQ (LETT |prem|
                               (SPADCALL |p| |q|
                                   (|getShellEntry| $ 149))
                               |UPOLYC-;pseudoDivide;2SR;41|)
                         (LETT |lc|
                               (SPADCALL
                                   (SPADCALL |q|
                                    (|getShellEntry| $ 54))
                                   (PROG1
                                    (LETT #0# |n|
                                     |UPOLYC-;pseudoDivide;2SR;41|)
                                     (|check-subtype| (>= #0# 0)
                                      '(|NonNegativeInteger|) #0#))
                                   (|getShellEntry| $ 148))
                               |UPOLYC-;pseudoDivide;2SR;41|)
                         (EXIT (VECTOR |lc|
                                       (PROG2
                                        (LETT #1#
                                         (SPADCALL
                                          (SPADCALL
                                           (SPADCALL |lc| |p|
                                            (|getShellEntry| $ 135))
                                           |prem|
                                           (|getShellEntry| $ 150))
                                          |q| (|getShellEntry| $ 127))
                                         |UPOLYC-;pseudoDivide;2SR;41|)
                                        (QCDR #1#)
                                         (|check-union| (QEQCAR #1# 0)
                                          (|getShellEntry| $ 6) #1#))
                                       |prem|)))))))))) 

(DEFUN |UPOLYC-;composite;FSU;42| (|f| |q| $)
  (PROG (|n| |d|)
    (RETURN
      (SEQ (LETT |n|
                 (SPADCALL (SPADCALL |f| (|getShellEntry| $ 142)) |q|
                     (|getShellEntry| $ 154))
                 |UPOLYC-;composite;FSU;42|)
           (EXIT (COND
                   ((QEQCAR |n| 1) (CONS 1 "failed"))
                   ('T
                    (SEQ (LETT |d|
                               (SPADCALL
                                   (SPADCALL |f|
                                    (|getShellEntry| $ 145))
                                   |q| (|getShellEntry| $ 154))
                               |UPOLYC-;composite;FSU;42|)
                         (EXIT (COND
                                 ((QEQCAR |d| 1) (CONS 1 "failed"))
                                 ('T
                                  (CONS 0
                                        (SPADCALL (QCDR |n|) (QCDR |d|)
                                         (|getShellEntry| $ 155)))))))))))))) 

(DEFUN |UPOLYC-;composite;2SU;43| (|p| |q| $)
  (PROG (|cqr| |v| |u| |w| #0=#:G1684)
    (RETURN
      (SEQ (COND
             ((SPADCALL |p| (|getShellEntry| $ 158)) (CONS 0 |p|))
             ('T
              (SEQ (EXIT (SEQ (LETT |cqr|
                                    (SPADCALL |p| |q|
                                     (|getShellEntry| $ 159))
                                    |UPOLYC-;composite;2SU;43|)
                              (COND
                                ((SPADCALL (QVELT |cqr| 2)
                                     (|getShellEntry| $ 158))
                                 (SEQ (LETT |v|
                                       (SPADCALL (QVELT |cqr| 2)
                                        (QVELT |cqr| 0)
                                        (|getShellEntry| $ 160))
                                       |UPOLYC-;composite;2SU;43|)
                                      (EXIT
                                       (COND
                                         ((QEQCAR |v| 0)
                                          (SEQ
                                           (LETT |u|
                                            (SPADCALL (QVELT |cqr| 1)
                                             |q|
                                             (|getShellEntry| $ 154))
                                            |UPOLYC-;composite;2SU;43|)
                                           (EXIT
                                            (COND
                                              ((QEQCAR |u| 0)
                                               (SEQ
                                                (LETT |w|
                                                 (SPADCALL (QCDR |u|)
                                                  (QVELT |cqr| 0)
                                                  (|getShellEntry| $
                                                   160))
                                                 |UPOLYC-;composite;2SU;43|)
                                                (EXIT
                                                 (COND
                                                   ((QEQCAR |w| 0)
                                                    (PROGN
                                                      (LETT #0#
                                                       (CONS 0
                                                        (SPADCALL
                                                         (QCDR |v|)
                                                         (SPADCALL
                                                          (SPADCALL
                                                           (|spadConstant|
                                                            $ 49)
                                                           1
                                                           (|getShellEntry|
                                                            $ 50))
                                                          (QCDR |w|)
                                                          (|getShellEntry|
                                                           $ 72))
                                                         (|getShellEntry|
                                                          $ 66)))
                                                       |UPOLYC-;composite;2SU;43|)
                                                      (GO #0#))))))))))))))))
                              (EXIT (CONS 1 "failed"))))
                   #0# (EXIT #0#)))))))) 

(DEFUN |UPOLYC-;elt;S2F;44| (|p| |f| $)
  (PROG (|n| #0=#:G1690 |ans|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |p| (|getShellEntry| $ 9))
              (|spadConstant| $ 162))
             ('T
              (SEQ (LETT |ans|
                         (SPADCALL
                             (SPADCALL
                                 (SPADCALL |p| (|getShellEntry| $ 54))
                                 (|getShellEntry| $ 30))
                             (|getShellEntry| $ 163))
                         |UPOLYC-;elt;S2F;44|)
                   (LETT |n| (SPADCALL |p| (|getShellEntry| $ 11))
                         |UPOLYC-;elt;S2F;44|)
                   (SEQ G190
                        (COND
                          ((NULL (SPADCALL
                                     (SPADCALL
                                      (LETT |p|
                                       (SPADCALL |p|
                                        (|getShellEntry| $ 56))
                                       |UPOLYC-;elt;S2F;44|)
                                      (|getShellEntry| $ 9))
                                     (|getShellEntry| $ 164)))
                           (GO G191)))
                        (SEQ (EXIT (LETT |ans|
                                    (SPADCALL
                                     (SPADCALL |ans|
                                      (SPADCALL |f|
                                       (PROG1
                                        (LETT #0#
                                         (- |n|
                                          (LETT |n|
                                           (SPADCALL |p|
                                            (|getShellEntry| $ 11))
                                           |UPOLYC-;elt;S2F;44|))
                                         |UPOLYC-;elt;S2F;44|)
                                         (|check-subtype| (>= #0# 0)
                                          '(|NonNegativeInteger|) #0#))
                                       (|getShellEntry| $ 165))
                                      (|getShellEntry| $ 166))
                                     (SPADCALL
                                      (SPADCALL
                                       (SPADCALL |p|
                                        (|getShellEntry| $ 54))
                                       (|getShellEntry| $ 30))
                                      (|getShellEntry| $ 163))
                                     (|getShellEntry| $ 167))
                                    |UPOLYC-;elt;S2F;44|)))
                        NIL (GO G190) G191 (EXIT NIL))
                   (EXIT (COND
                           ((ZEROP |n|) |ans|)
                           ('T
                            (SPADCALL |ans|
                                (SPADCALL |f| |n|
                                    (|getShellEntry| $ 168))
                                (|getShellEntry| $ 166)))))))))))) 

(DEFUN |UPOLYC-;order;2SNni;45| (|p| |q| $)
  (PROG (|u| #0=#:G1704 |ans|)
    (RETURN
      (SEQ (EXIT (COND
                   ((SPADCALL |p| (|getShellEntry| $ 9))
                    (|error| "order: arguments must be nonzero"))
                   ((< (SPADCALL |q| (|getShellEntry| $ 11)) 1)
                    (|error| "order: place must be non-trivial"))
                   ('T
                    (SEQ (LETT |ans| 0 |UPOLYC-;order;2SNni;45|)
                         (EXIT (SEQ G190 NIL
                                    (SEQ
                                     (LETT |u|
                                      (SPADCALL |p| |q|
                                       (|getShellEntry| $ 127))
                                      |UPOLYC-;order;2SNni;45|)
                                     (EXIT
                                      (COND
                                        ((QEQCAR |u| 1)
                                         (PROGN
                                           (LETT #0# |ans|
                                            |UPOLYC-;order;2SNni;45|)
                                           (GO #0#)))
                                        ('T
                                         (SEQ
                                          (LETT |p| (QCDR |u|)
                                           |UPOLYC-;order;2SNni;45|)
                                          (EXIT
                                           (LETT |ans| (+ |ans| 1)
                                            |UPOLYC-;order;2SNni;45|)))))))
                                    NIL (GO G190) G191 (EXIT NIL)))))))
           #0# (EXIT #0#))))) 

(DEFUN |UPOLYC-;squareFree;SF;46| (|p| $)
  (SPADCALL |p| (|getShellEntry| $ 172))) 

(DEFUN |UPOLYC-;squareFreePart;2S;47| (|p| $)
  (SPADCALL |p| (|getShellEntry| $ 174))) 

(DEFUN |UPOLYC-;gcdPolynomial;3Sup;48| (|pp| |qq| $)
  (COND
    ((SPADCALL |pp| (|getShellEntry| $ 176))
     (SPADCALL |qq| (|getShellEntry| $ 177)))
    ((SPADCALL |qq| (|getShellEntry| $ 176))
     (SPADCALL |pp| (|getShellEntry| $ 177)))
    ('T
     (SPADCALL
         (SPADCALL
             (SPADCALL (SPADCALL |pp| (|getShellEntry| $ 178))
                 (SPADCALL |qq| (|getShellEntry| $ 178))
                 (|getShellEntry| $ 126))
             (SPADCALL
                 (SPADCALL (SPADCALL |pp| (|getShellEntry| $ 179))
                     (SPADCALL |qq| (|getShellEntry| $ 179))
                     (|getShellEntry| $ 180))
                 (|getShellEntry| $ 179))
             (|getShellEntry| $ 181))
         (|getShellEntry| $ 177))))) 

(DEFUN |UPOLYC-;squareFreePolynomial;SupF;49| (|pp| $)
  (SPADCALL |pp| (|getShellEntry| $ 184))) 

(DEFUN |UPOLYC-;elt;F2R;50| (|f| |r| $)
  (SPADCALL
      (SPADCALL (SPADCALL |f| (|getShellEntry| $ 142)) |r|
          (|getShellEntry| $ 29))
      (SPADCALL (SPADCALL |f| (|getShellEntry| $ 145)) |r|
          (|getShellEntry| $ 29))
      (|getShellEntry| $ 186))) 

(DEFUN |UPOLYC-;euclideanSize;SNni;51| (|x| $)
  (COND
    ((SPADCALL |x| (|getShellEntry| $ 9))
     (|error| "euclideanSize called on 0 in Univariate Polynomial"))
    ('T (SPADCALL |x| (|getShellEntry| $ 11))))) 

(DEFUN |UPOLYC-;divide;2SR;52| (|x| |y| $)
  (PROG (|lc| |f| #0=#:G1716 |n| |quot|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |y| (|getShellEntry| $ 9))
              (|error| "division by 0 in Univariate Polynomials"))
             ('T
              (SEQ (LETT |quot| (|spadConstant| $ 61)
                         |UPOLYC-;divide;2SR;52|)
                   (LETT |lc|
                         (SPADCALL
                             (SPADCALL |y| (|getShellEntry| $ 54))
                             (|getShellEntry| $ 189))
                         |UPOLYC-;divide;2SR;52|)
                   (SEQ G190
                        (COND
                          ((NULL (COND
                                   ((SPADCALL |x|
                                     (|getShellEntry| $ 9))
                                    'NIL)
                                   ('T
                                    (SPADCALL
                                     (<
                                      (SPADCALL |x|
                                       (|getShellEntry| $ 11))
                                      (SPADCALL |y|
                                       (|getShellEntry| $ 11)))
                                     (|getShellEntry| $ 164)))))
                           (GO G191)))
                        (SEQ (LETT |f|
                                   (SPADCALL |lc|
                                    (SPADCALL |x|
                                     (|getShellEntry| $ 54))
                                    (|getShellEntry| $ 190))
                                   |UPOLYC-;divide;2SR;52|)
                             (LETT |n|
                                   (PROG1
                                    (LETT #0#
                                     (-
                                      (SPADCALL |x|
                                       (|getShellEntry| $ 11))
                                      (SPADCALL |y|
                                       (|getShellEntry| $ 11)))
                                     |UPOLYC-;divide;2SR;52|)
                                     (|check-subtype| (>= #0# 0)
                                      '(|NonNegativeInteger|) #0#))
                                   |UPOLYC-;divide;2SR;52|)
                             (LETT |quot|
                                   (SPADCALL |quot|
                                    (SPADCALL |f| |n|
                                     (|getShellEntry| $ 50))
                                    (|getShellEntry| $ 66))
                                   |UPOLYC-;divide;2SR;52|)
                             (EXIT (LETT |x|
                                    (SPADCALL |x|
                                     (SPADCALL
                                      (SPADCALL |f| |n|
                                       (|getShellEntry| $ 50))
                                      |y| (|getShellEntry| $ 72))
                                     (|getShellEntry| $ 150))
                                    |UPOLYC-;divide;2SR;52|)))
                        NIL (GO G190) G191 (EXIT NIL))
                   (EXIT (CONS |quot| |x|))))))))) 

(DEFUN |UPOLYC-;integrate;2S;53| (|p| $)
  (PROG (|l| |d| |ans|)
    (RETURN
      (SEQ (LETT |ans| (|spadConstant| $ 61) |UPOLYC-;integrate;2S;53|)
           (SEQ G190
                (COND
                  ((NULL (SPADCALL |p| (|spadConstant| $ 61)
                             (|getShellEntry| $ 192)))
                   (GO G191)))
                (SEQ (LETT |l| (SPADCALL |p| (|getShellEntry| $ 54))
                           |UPOLYC-;integrate;2S;53|)
                     (LETT |d|
                           (+ 1 (SPADCALL |p| (|getShellEntry| $ 11)))
                           |UPOLYC-;integrate;2S;53|)
                     (LETT |ans|
                           (SPADCALL |ans|
                               (SPADCALL
                                   (SPADCALL
                                    (SPADCALL |d|
                                     (|getShellEntry| $ 194))
                                    (|getShellEntry| $ 195))
                                   (SPADCALL |l| |d|
                                    (|getShellEntry| $ 50))
                                   (|getShellEntry| $ 196))
                               (|getShellEntry| $ 66))
                           |UPOLYC-;integrate;2S;53|)
                     (EXIT (LETT |p|
                                 (SPADCALL |p| (|getShellEntry| $ 56))
                                 |UPOLYC-;integrate;2S;53|)))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT |ans|))))) 

(DEFUN |UnivariatePolynomialCategory&| (|#1| |#2|)
  (PROG (|dv$1| |dv$2| |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT |dv$1| (|devaluate| |#1|)
              . #0=(|UnivariatePolynomialCategory&|))
        (LETT |dv$2| (|devaluate| |#2|) . #0#)
        (LETT |dv$|
              (LIST '|UnivariatePolynomialCategory&| |dv$1| |dv$2|) . #0#)
        (LETT $ (|newShell| 203) . #0#)
        (|setShellEntry| $ 0 |dv$|)
        (|setShellEntry| $ 3
            (LETT |pv$|
                  (|buildPredVector| 0 0
                      (LIST (|HasCategory| |#2|
                                '(|Algebra| (|Fraction| (|Integer|))))
                            (|HasCategory| |#2| '(|Field|))
                            (|HasCategory| |#2| '(|GcdDomain|))
                            (|HasCategory| |#2| '(|IntegralDomain|))
                            (|HasCategory| |#2| '(|CommutativeRing|))
                            (|HasCategory| |#2| '(|StepThrough|)))) . #0#))
        (|stuffDomainSlots| $)
        (|setShellEntry| $ 6 |#1|)
        (|setShellEntry| $ 7 |#2|)
        (COND
          ((|HasCategory| |#2| '(|PolynomialFactorizationExplicit|))
           (PROGN
             (|setShellEntry| $ 82
                 (CONS (|dispatchFunction|
                           |UPOLYC-;solveLinearPolynomialEquation;LSupU;20|)
                       $))
             (|setShellEntry| $ 86
                 (CONS (|dispatchFunction|
                           |UPOLYC-;factorPolynomial;SupF;21|)
                       $))
             (|setShellEntry| $ 88
                 (CONS (|dispatchFunction|
                           |UPOLYC-;factorSquareFreePolynomial;SupF;22|)
                       $))
             (|setShellEntry| $ 107
                 (CONS (|dispatchFunction| |UPOLYC-;factor;SF;23|) $)))))
        (COND
          ((|testBitVector| |pv$| 6)
           (PROGN
             (|setShellEntry| $ 119
                 (CONS (|dispatchFunction| |UPOLYC-;init;S;27|) $))
             NIL
             (|setShellEntry| $ 123
                 (CONS (|dispatchFunction| |UPOLYC-;nextItem;SU;29|) $)))))
        (COND
          ((|testBitVector| |pv$| 3)
           (PROGN
             (|setShellEntry| $ 125
                 (CONS (|dispatchFunction| |UPOLYC-;content;SSaosS;30|)
                       $))
             NIL
             (|setShellEntry| $ 130
                 (CONS (|dispatchFunction| |UPOLYC-;separate;2SR;32|)
                       $)))))
        (COND
          ((|testBitVector| |pv$| 5)
           (|setShellEntry| $ 134
               (CONS (|dispatchFunction|
                         |UPOLYC-;differentiate;SM2S;33|)
                     $)))
          ('T
           (PROGN
             (|setShellEntry| $ 134
                 (CONS (|dispatchFunction|
                           |UPOLYC-;differentiate;SM2S;35|)
                       $)))))
        (COND
          ((|testBitVector| |pv$| 4)
           (PROGN
             (|setShellEntry| $ 147
                 (CONS (|dispatchFunction| |UPOLYC-;elt;3F;39|) $))
             (|setShellEntry| $ 151
                 (CONS (|dispatchFunction|
                           |UPOLYC-;pseudoQuotient;3S;40|)
                       $))
             (|setShellEntry| $ 153
                 (CONS (|dispatchFunction|
                           |UPOLYC-;pseudoDivide;2SR;41|)
                       $))
             (|setShellEntry| $ 157
                 (CONS (|dispatchFunction| |UPOLYC-;composite;FSU;42|)
                       $))
             (|setShellEntry| $ 161
                 (CONS (|dispatchFunction| |UPOLYC-;composite;2SU;43|)
                       $))
             (|setShellEntry| $ 169
                 (CONS (|dispatchFunction| |UPOLYC-;elt;S2F;44|) $))
             (|setShellEntry| $ 170
                 (CONS (|dispatchFunction| |UPOLYC-;order;2SNni;45|) $)))))
        (COND
          ((|testBitVector| |pv$| 3)
           (PROGN
             (|setShellEntry| $ 173
                 (CONS (|dispatchFunction| |UPOLYC-;squareFree;SF;46|)
                       $))
             (|setShellEntry| $ 175
                 (CONS (|dispatchFunction|
                           |UPOLYC-;squareFreePart;2S;47|)
                       $)))))
        (COND
          ((|HasCategory| |#2| '(|PolynomialFactorizationExplicit|))
           (PROGN
             (|setShellEntry| $ 182
                 (CONS (|dispatchFunction|
                           |UPOLYC-;gcdPolynomial;3Sup;48|)
                       $))
             (|setShellEntry| $ 185
                 (CONS (|dispatchFunction|
                           |UPOLYC-;squareFreePolynomial;SupF;49|)
                       $)))))
        (COND
          ((|testBitVector| |pv$| 2)
           (PROGN
             (|setShellEntry| $ 187
                 (CONS (|dispatchFunction| |UPOLYC-;elt;F2R;50|) $))
             (|setShellEntry| $ 188
                 (CONS (|dispatchFunction|
                           |UPOLYC-;euclideanSize;SNni;51|)
                       $))
             (|setShellEntry| $ 191
                 (CONS (|dispatchFunction| |UPOLYC-;divide;2SR;52|) $)))))
        (COND
          ((|testBitVector| |pv$| 1)
           (|setShellEntry| $ 197
               (CONS (|dispatchFunction| |UPOLYC-;integrate;2S;53|) $))))
        $)))) 

(MAKEPROP '|UnivariatePolynomialCategory&| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|Boolean|) (0 . |zero?|) (|NonNegativeInteger|)
             (5 . |degree|) (|SingletonAsOrderedSet|) (10 . |create|)
             (|List| 12) |UPOLYC-;variables;SL;1|
             |UPOLYC-;degree;SSaosNni;2| (14 . |totalDegree|)
             |UPOLYC-;totalDegree;SLNni;3| (|List| 10)
             |UPOLYC-;degree;SLL;4| (19 . |eval|) (|List| $)
             |UPOLYC-;eval;SLLS;5| (26 . |elt|)
             |UPOLYC-;eval;SSaos2S;6| (32 . |eval|) (|List| 7)
             |UPOLYC-;eval;SLLS;7| (39 . |elt|) (45 . |coerce|)
             |UPOLYC-;eval;SSaosRS;8| (|Equation| 6) (50 . |lhs|)
             (|Union| 12 '"failed") (55 . |mainVariable|) (60 . |rhs|)
             (|Equation| $) (|List| 37) |UPOLYC-;eval;SLS;9|
             |UPOLYC-;mainVariable;SU;10| (65 . |minimumDegree|)
             |UPOLYC-;minimumDegree;SSaosNni;11|
             |UPOLYC-;minimumDegree;SLL;12| (70 . +) (|Mapping| 10 10)
             (76 . |mapExponents|) |UPOLYC-;monomial;SSaosNniS;13|
             (82 . |One|) (86 . |One|) (90 . |monomial|)
             |UPOLYC-;coerce;SaosS;14| (|SparseUnivariatePolynomial| 7)
             (96 . |Zero|) (100 . |leadingCoefficient|)
             (105 . |monomial|) (111 . |reductum|) (116 . |makeSUP|)
             (121 . +) |UPOLYC-;makeSUP;SSup;15| (127 . |zero?|)
             (132 . |Zero|) (136 . |leadingCoefficient|)
             (141 . |degree|) (146 . |reductum|) (151 . |unmakeSUP|)
             (156 . +) |UPOLYC-;unmakeSUP;SupS;16|
             (|Record| (|:| |quotient| $) (|:| |remainder| $))
             (162 . |monicDivide|) |UPOLYC-;karatsubaDivide;SNniR;17|
             |UPOLYC-;shiftRight;SNniS;18| (168 . *)
             |UPOLYC-;shiftLeft;SNniS;19|
             (|SparseUnivariatePolynomial| 6) (|List| 74)
             (|Union| 75 '"failed")
             (|PolynomialFactorizationByRecursionUnivariate| 7 6)
             (174 . |solveLinearPolynomialEquationByRecursion|)
             (|SparseUnivariatePolynomial| $) (|List| 79)
             (|Union| 80 '"failed")
             (180 . |solveLinearPolynomialEquation|) (|Factored| 74)
             (186 . |factorByRecursion|) (|Factored| 79)
             (191 . |factorPolynomial|)
             (196 . |factorSquareFreeByRecursion|)
             (201 . |factorSquareFreePolynomial|) (|Factored| $)
             (206 . |factor|) (|Factored| 7) (211 . |unit|)
             (|Union| '"nil" '"sqfr" '"irred" '"prime") (|Integer|)
             (|Record| (|:| |flg| 93) (|:| |fctr| 7) (|:| |xpnt| 94))
             (|List| 95) (216 . |factorList|)
             (|Record| (|:| |flg| 93) (|:| |fctr| 6) (|:| |xpnt| 94))
             (|List| 98) (|Factored| 6) (221 . |makeFR|)
             (227 . |factorPolynomial|) (|Mapping| 6 52)
             (|Factored| 52) (|FactoredFunctions2| 52 6) (232 . |map|)
             (238 . |factor|) (243 . |Zero|) (|Vector| 7) (247 . |new|)
             (253 . |minIndex|) (258 . |coefficient|)
             (264 . |qsetelt!|) |UPOLYC-;vectorise;SNniV;24|
             |UPOLYC-;retract;SR;25| (|Union| 7 '"failed")
             |UPOLYC-;retractIfCan;SU;26| (271 . |init|) (275 . |init|)
             (|Union| $ '"failed") (279 . |nextItem|) (284 . |One|)
             (288 . |nextItem|) (293 . |content|) (298 . |content|)
             (304 . |gcd|) (310 . |exquo|) (316 . =)
             (|Record| (|:| |primePart| $) (|:| |commonPart| $))
             (322 . |separate|) (328 . |Zero|) (332 . *)
             (|Mapping| 7 7) (338 . |differentiate|) (345 . *)
             (351 . |differentiate|) |UPOLYC-;differentiate;SMS;36|
             |UPOLYC-;differentiate;2S;37| (358 . |differentiate|)
             |UPOLYC-;differentiate;SSaosS;38| (|Fraction| 6)
             (363 . |numer|) (|Fraction| $) (368 . |elt|)
             (374 . |denom|) (379 . /) (385 . |elt|) (391 . **)
             (397 . |pseudoRemainder|) (403 . -)
             (409 . |pseudoQuotient|)
             (|Record| (|:| |coef| 7) (|:| |quotient| $)
                 (|:| |remainder| $))
             (415 . |pseudoDivide|) (421 . |composite|) (427 . /)
             (|Union| 143 '"failed") (433 . |composite|)
             (439 . |ground?|) (444 . |pseudoDivide|) (450 . |exquo|)
             (456 . |composite|) (462 . |Zero|) (466 . |coerce|)
             (471 . |not|) (476 . **) (482 . *) (488 . +) (494 . **)
             (500 . |elt|) (506 . |order|)
             (|UnivariatePolynomialSquareFree| 7 6)
             (512 . |squareFree|) (517 . |squareFree|)
             (522 . |squareFreePart|) (527 . |squareFreePart|)
             (532 . |zero?|) (537 . |unitCanonical|) (542 . |content|)
             (547 . |primitivePart|) (552 . |subResultantGcd|)
             (558 . *) (564 . |gcdPolynomial|)
             (|UnivariatePolynomialSquareFree| 6 74)
             (570 . |squareFree|) (575 . |squareFreePolynomial|)
             (580 . /) (586 . |elt|) (592 . |euclideanSize|)
             (597 . |inv|) (602 . *) (608 . |divide|) (614 . ~=)
             (|Fraction| 94) (620 . |coerce|) (625 . |inv|) (630 . *)
             (636 . |integrate|) (|Symbol|) (|List| 198)
             (|Union| 94 '"failed") (|Union| 193 '"failed")
             (|OutputForm|))
          '#(|vectorise| 641 |variables| 647 |unmakeSUP| 652
             |totalDegree| 657 |squareFreePolynomial| 663
             |squareFreePart| 668 |squareFree| 673
             |solveLinearPolynomialEquation| 678 |shiftRight| 684
             |shiftLeft| 690 |separate| 696 |retractIfCan| 702
             |retract| 707 |pseudoQuotient| 712 |pseudoDivide| 718
             |order| 724 |nextItem| 730 |monomial| 735 |minimumDegree|
             742 |makeSUP| 754 |mainVariable| 759 |karatsubaDivide| 764
             |integrate| 770 |init| 775 |gcdPolynomial| 779
             |factorSquareFreePolynomial| 785 |factorPolynomial| 790
             |factor| 795 |eval| 800 |euclideanSize| 834 |elt| 839
             |divide| 857 |differentiate| 863 |degree| 887 |content|
             899 |composite| 905 |coerce| 917)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 197
                                '(1 6 8 0 9 1 6 10 0 11 0 12 0 13 1 6
                                  10 0 17 3 6 0 0 12 0 21 2 6 0 0 0 24
                                  3 6 0 0 12 7 26 2 6 7 0 7 29 1 6 0 7
                                  30 1 32 6 0 33 1 6 34 0 35 1 32 6 0
                                  36 1 6 10 0 41 2 10 0 0 0 44 2 6 0 45
                                  0 46 0 6 0 48 0 7 0 49 2 6 0 7 10 50
                                  0 52 0 53 1 6 7 0 54 2 52 0 7 10 55 1
                                  6 0 0 56 1 6 52 0 57 2 52 0 0 0 58 1
                                  52 8 0 60 0 6 0 61 1 52 7 0 62 1 52
                                  10 0 63 1 52 0 0 64 1 6 0 52 65 2 6 0
                                  0 0 66 2 6 68 0 0 69 2 6 0 0 0 72 2
                                  77 76 75 74 78 2 0 81 80 79 82 1 77
                                  83 74 84 1 0 85 79 86 1 77 83 74 87 1
                                  0 85 79 88 1 7 89 0 90 1 91 7 0 92 1
                                  91 96 0 97 2 100 0 6 99 101 1 7 85 79
                                  102 2 105 100 103 104 106 1 0 89 0
                                  107 0 7 0 108 2 109 0 10 7 110 1 109
                                  94 0 111 2 6 7 0 10 112 3 109 7 0 94
                                  7 113 0 7 0 118 0 0 0 119 1 7 120 0
                                  121 0 74 0 122 1 0 120 0 123 1 6 7 0
                                  124 2 0 0 0 12 125 2 6 0 0 0 126 2 6
                                  120 0 0 127 2 6 8 0 0 128 2 0 129 0 0
                                  130 0 74 0 131 2 7 0 10 0 132 3 0 0 0
                                  133 0 134 2 6 0 7 0 135 3 6 0 0 133 0
                                  136 1 6 0 0 139 1 141 6 0 142 2 6 143
                                  0 143 144 1 141 6 0 145 2 141 0 0 0
                                  146 2 0 143 143 143 147 2 7 0 0 10
                                  148 2 6 0 0 0 149 2 6 0 0 0 150 2 0 0
                                  0 0 151 2 0 152 0 0 153 2 6 120 0 0
                                  154 2 141 0 6 6 155 2 0 156 143 0 157
                                  1 6 8 0 158 2 6 152 0 0 159 2 6 120 0
                                  7 160 2 0 120 0 0 161 0 141 0 162 1
                                  141 0 6 163 1 8 0 0 164 2 141 0 0 94
                                  165 2 141 0 0 0 166 2 141 0 0 0 167 2
                                  141 0 0 10 168 2 0 143 0 143 169 2 0
                                  10 0 0 170 1 171 100 6 172 1 0 89 0
                                  173 1 171 6 6 174 1 0 0 0 175 1 74 8
                                  0 176 1 74 0 0 177 1 74 6 0 178 1 74
                                  0 0 179 2 74 0 0 0 180 2 74 0 6 0 181
                                  2 0 79 79 79 182 1 183 83 74 184 1 0
                                  85 79 185 2 7 0 0 0 186 2 0 7 143 7
                                  187 1 0 10 0 188 1 7 0 0 189 2 7 0 0
                                  0 190 2 0 68 0 0 191 2 6 8 0 0 192 1
                                  193 0 94 194 1 193 0 0 195 2 6 0 193
                                  0 196 1 0 0 0 197 2 0 109 0 10 114 1
                                  0 14 0 15 1 0 0 52 67 2 0 10 0 14 18
                                  1 0 85 79 185 1 0 0 0 175 1 0 89 0
                                  173 2 0 81 80 79 82 2 0 0 0 10 71 2 0
                                  0 0 10 73 2 0 129 0 0 130 1 0 116 0
                                  117 1 0 7 0 115 2 0 0 0 0 151 2 0 152
                                  0 0 153 2 0 10 0 0 170 1 0 120 0 123
                                  3 0 0 0 12 10 47 2 0 19 0 14 43 2 0
                                  10 0 12 42 1 0 52 0 59 1 0 34 0 40 2
                                  0 68 0 10 70 1 0 0 0 197 0 0 0 119 2
                                  0 79 79 79 182 1 0 85 79 88 1 0 85 79
                                  86 1 0 89 0 107 3 0 0 0 12 0 25 3 0 0
                                  0 14 22 23 3 0 0 0 14 27 28 3 0 0 0
                                  12 7 31 2 0 0 0 38 39 1 0 10 0 188 2
                                  0 143 0 143 169 2 0 7 143 7 187 2 0
                                  143 143 143 147 2 0 68 0 0 191 3 0 0
                                  0 133 0 134 2 0 0 0 133 137 1 0 0 0
                                  138 2 0 0 0 12 140 2 0 10 0 12 16 2 0
                                  19 0 14 20 2 0 0 0 12 125 2 0 120 0 0
                                  161 2 0 156 143 0 157 1 0 0 12 51)))))
          '|lookupComplete|)) 

(SETQ |$CategoryFrame|
      (|put| '|UnivariatePolynomialCategory&| '|isFunctor|
             '(((|coerce| ($ $)) T (ELT $ NIL))
               ((|gcdPolynomial|
                    ((|SparseUnivariatePolynomial| $)
                     (|SparseUnivariatePolynomial| $)
                     (|SparseUnivariatePolynomial| $)))
                T (ELT $ 182))
               ((|squareFree| ((|Factored| $) $)) T (ELT $ 173))
               ((|squareFreePart| ($ $)) T (ELT $ 175))
               ((|coerce| ($ (|Fraction| (|Integer|)))) T (ELT $ NIL))
               ((|init| ($)) T (ELT $ 119))
               ((|nextItem| ((|Union| $ "failed") $)) T (ELT $ 123))
               ((|elt| ((|Fraction| $) $ (|Fraction| $))) T
                (ELT $ 169))
               ((|euclideanSize| ((|NonNegativeInteger|) $)) T
                (ELT $ 188))
               ((|divide|
                    ((|Record| (|:| |quotient| $) (|:| |remainder| $))
                     $ $))
                T (ELT $ 191))
               ((|integrate| ($ $)) T (ELT $ 197))
               ((|elt| (|#2| (|Fraction| $) |#2|)) T (ELT $ 187))
               ((|separate|
                    ((|Record| (|:| |primePart| $)
                         (|:| |commonPart| $))
                     $ $))
                T (ELT $ 130))
               ((|pseudoDivide|
                    ((|Record| (|:| |coef| |#2|) (|:| |quotient| $)
                         (|:| |remainder| $))
                     $ $))
                T (ELT $ 153))
               ((|pseudoQuotient| ($ $ $)) T (ELT $ 151))
               ((|composite|
                    ((|Union| (|Fraction| $) "failed") (|Fraction| $)
                     $))
                T (ELT $ 157))
               ((|composite| ((|Union| $ "failed") $ $)) T (ELT $ 161))
               ((|order| ((|NonNegativeInteger|) $ $)) T (ELT $ 170))
               ((|elt| ((|Fraction| $) (|Fraction| $) (|Fraction| $)))
                T (ELT $ 147))
               ((|differentiate| ($ $ (|Mapping| |#2| |#2|) $)) T
                (ELT $ 134))
               ((|shiftLeft| ($ $ (|NonNegativeInteger|))) T
                (ELT $ 73))
               ((|shiftRight| ($ $ (|NonNegativeInteger|))) T
                (ELT $ 71))
               ((|karatsubaDivide|
                    ((|Record| (|:| |quotient| $) (|:| |remainder| $))
                     $ (|NonNegativeInteger|)))
                T (ELT $ 70))
               ((|unmakeSUP| ($ (|SparseUnivariatePolynomial| |#2|))) T
                (ELT $ 67))
               ((|makeSUP| ((|SparseUnivariatePolynomial| |#2|) $)) T
                (ELT $ 59))
               ((|vectorise|
                    ((|Vector| |#2|) $ (|NonNegativeInteger|)))
                T (ELT $ 114))
               ((|differentiate| ($ $ (|Mapping| |#2| |#2|))) T
                (ELT $ 137))
               ((|differentiate|
                    ($ $ (|Mapping| |#2| |#2|) (|NonNegativeInteger|)))
                T (ELT $ NIL))
               ((|differentiate|
                    ($ $ (|List| (|Symbol|))
                       (|List| (|NonNegativeInteger|))))
                T (ELT $ NIL))
               ((|differentiate|
                    ($ $ (|Symbol|) (|NonNegativeInteger|)))
                T (ELT $ NIL))
               ((|differentiate| ($ $ (|List| (|Symbol|)))) T
                (ELT $ NIL))
               ((|differentiate| ($ $ (|Symbol|))) T (ELT $ NIL))
               ((|differentiate| ($ $)) T (ELT $ 138))
               ((|differentiate| ($ $ (|NonNegativeInteger|))) T
                (ELT $ NIL))
               ((|elt| ($ $ $)) T (ELT $ NIL))
               ((|elt| (|#2| $ |#2|)) T (ELT $ NIL))
               ((|factor| ((|Factored| $) $)) T (ELT $ 107))
               ((|squareFreePolynomial|
                    ((|Factored| (|SparseUnivariatePolynomial| $))
                     (|SparseUnivariatePolynomial| $)))
                T (ELT $ 185))
               ((|factorPolynomial|
                    ((|Factored| (|SparseUnivariatePolynomial| $))
                     (|SparseUnivariatePolynomial| $)))
                T (ELT $ 86))
               ((|factorSquareFreePolynomial|
                    ((|Factored| (|SparseUnivariatePolynomial| $))
                     (|SparseUnivariatePolynomial| $)))
                T (ELT $ 88))
               ((|solveLinearPolynomialEquation|
                    ((|Union| (|List| (|SparseUnivariatePolynomial| $))
                              "failed")
                     (|List| (|SparseUnivariatePolynomial| $))
                     (|SparseUnivariatePolynomial| $)))
                T (ELT $ 82))
               ((|content| ($ $ (|SingletonAsOrderedSet|))) T
                (ELT $ 125))
               ((|variables| ((|List| (|SingletonAsOrderedSet|)) $)) T
                (ELT $ 15))
               ((|totalDegree|
                    ((|NonNegativeInteger|) $
                     (|List| (|SingletonAsOrderedSet|))))
                T (ELT $ 18))
               ((|totalDegree| ((|NonNegativeInteger|) $)) T
                (ELT $ NIL))
               ((|monomial|
                    ($ $ (|List| (|SingletonAsOrderedSet|))
                       (|List| (|NonNegativeInteger|))))
                T (ELT $ NIL))
               ((|monomial|
                    ($ $ (|SingletonAsOrderedSet|)
                       (|NonNegativeInteger|)))
                T (ELT $ 47))
               ((|minimumDegree|
                    ((|List| (|NonNegativeInteger|)) $
                     (|List| (|SingletonAsOrderedSet|))))
                T (ELT $ 43))
               ((|minimumDegree|
                    ((|NonNegativeInteger|) $
                     (|SingletonAsOrderedSet|)))
                T (ELT $ 42))
               ((|mainVariable|
                    ((|Union| (|SingletonAsOrderedSet|) "failed") $))
                T (ELT $ 40))
               ((|degree|
                    ((|List| (|NonNegativeInteger|)) $
                     (|List| (|SingletonAsOrderedSet|))))
                T (ELT $ 20))
               ((|degree|
                    ((|NonNegativeInteger|) $
                     (|SingletonAsOrderedSet|)))
                T (ELT $ 16))
               ((|retract| ((|SingletonAsOrderedSet|) $)) T
                (ELT $ NIL))
               ((|retractIfCan|
                    ((|Union| (|SingletonAsOrderedSet|) "failed") $))
                T (ELT $ NIL))
               ((|coerce| ($ (|SingletonAsOrderedSet|))) T (ELT $ 51))
               ((|eval| ($ $ (|List| (|SingletonAsOrderedSet|))
                           (|List| $)))
                T (ELT $ 23))
               ((|eval| ($ $ (|SingletonAsOrderedSet|) $)) T
                (ELT $ 25))
               ((|eval| ($ $ (|List| (|SingletonAsOrderedSet|))
                           (|List| |#2|)))
                T (ELT $ 28))
               ((|eval| ($ $ (|SingletonAsOrderedSet|) |#2|)) T
                (ELT $ 31))
               ((|eval| ($ $ (|List| $) (|List| $))) T (ELT $ NIL))
               ((|eval| ($ $ $ $)) T (ELT $ NIL))
               ((|eval| ($ $ (|Equation| $))) T (ELT $ NIL))
               ((|eval| ($ $ (|List| (|Equation| $)))) T (ELT $ 39))
               ((|degree| ((|NonNegativeInteger|) $)) T (ELT $ NIL))
               ((|monomial| ($ |#2| (|NonNegativeInteger|))) T
                (ELT $ NIL))
               ((|retract| ((|Integer|) $)) T (ELT $ NIL))
               ((|retractIfCan| ((|Union| (|Integer|) "failed") $)) T
                (ELT $ NIL))
               ((|retract| ((|Fraction| (|Integer|)) $)) T (ELT $ NIL))
               ((|retractIfCan|
                    ((|Union| (|Fraction| (|Integer|)) "failed") $))
                T (ELT $ NIL))
               ((|coerce| ($ |#2|)) T (ELT $ NIL))
               ((|retractIfCan| ((|Union| |#2| "failed") $)) T
                (ELT $ 117))
               ((|retract| (|#2| $)) T (ELT $ 115))
               ((|minimumDegree| ((|NonNegativeInteger|) $)) T
                (ELT $ NIL))
               ((|content| (|#2| $)) T (ELT $ NIL))
               ((|differentiate|
                    ($ $ (|List| (|SingletonAsOrderedSet|))
                       (|List| (|NonNegativeInteger|))))
                T (ELT $ NIL))
               ((|differentiate|
                    ($ $ (|SingletonAsOrderedSet|)
                       (|NonNegativeInteger|)))
                T (ELT $ NIL))
               ((|differentiate|
                    ($ $ (|List| (|SingletonAsOrderedSet|))))
                T (ELT $ NIL))
               ((|differentiate| ($ $ (|SingletonAsOrderedSet|))) T
                (ELT $ 140))
               ((|coerce| ($ (|Integer|))) T (ELT $ NIL))
               ((|coerce| ((|OutputForm|) $)) T (ELT $ NIL)))
             (|addModemap| '|UnivariatePolynomialCategory&|
                 '(|UnivariatePolynomialCategory&| |#1| |#2|)
                 '((CATEGORY |domain| (SIGNATURE |coerce| (|#1| |#1|))
                       (SIGNATURE |gcdPolynomial|
                           ((|SparseUnivariatePolynomial| |#1|)
                            (|SparseUnivariatePolynomial| |#1|)
                            (|SparseUnivariatePolynomial| |#1|)))
                       (SIGNATURE |squareFree|
                           ((|Factored| |#1|) |#1|))
                       (SIGNATURE |squareFreePart| (|#1| |#1|))
                       (SIGNATURE |coerce|
                           (|#1| (|Fraction| (|Integer|))))
                       (SIGNATURE |init| (|#1|))
                       (SIGNATURE |nextItem|
                           ((|Union| |#1| "failed") |#1|))
                       (SIGNATURE |elt|
                           ((|Fraction| |#1|) |#1| (|Fraction| |#1|)))
                       (SIGNATURE |euclideanSize|
                           ((|NonNegativeInteger|) |#1|))
                       (SIGNATURE |divide|
                           ((|Record| (|:| |quotient| |#1|)
                                (|:| |remainder| |#1|))
                            |#1| |#1|))
                       (SIGNATURE |integrate| (|#1| |#1|))
                       (SIGNATURE |elt| (|#2| (|Fraction| |#1|) |#2|))
                       (SIGNATURE |separate|
                           ((|Record| (|:| |primePart| |#1|)
                                (|:| |commonPart| |#1|))
                            |#1| |#1|))
                       (SIGNATURE |pseudoDivide|
                           ((|Record| (|:| |coef| |#2|)
                                (|:| |quotient| |#1|)
                                (|:| |remainder| |#1|))
                            |#1| |#1|))
                       (SIGNATURE |pseudoQuotient| (|#1| |#1| |#1|))
                       (SIGNATURE |composite|
                           ((|Union| (|Fraction| |#1|) "failed")
                            (|Fraction| |#1|) |#1|))
                       (SIGNATURE |composite|
                           ((|Union| |#1| "failed") |#1| |#1|))
                       (SIGNATURE |order|
                           ((|NonNegativeInteger|) |#1| |#1|))
                       (SIGNATURE |elt|
                           ((|Fraction| |#1|) (|Fraction| |#1|)
                            (|Fraction| |#1|)))
                       (SIGNATURE |differentiate|
                           (|#1| |#1| (|Mapping| |#2| |#2|) |#1|))
                       (SIGNATURE |shiftLeft|
                           (|#1| |#1| (|NonNegativeInteger|)))
                       (SIGNATURE |shiftRight|
                           (|#1| |#1| (|NonNegativeInteger|)))
                       (SIGNATURE |karatsubaDivide|
                           ((|Record| (|:| |quotient| |#1|)
                                      (|:| |remainder| |#1|))
                            |#1| (|NonNegativeInteger|)))
                       (SIGNATURE |unmakeSUP|
                           (|#1| (|SparseUnivariatePolynomial| |#2|)))
                       (SIGNATURE |makeSUP|
                           ((|SparseUnivariatePolynomial| |#2|) |#1|))
                       (SIGNATURE |vectorise|
                           ((|Vector| |#2|) |#1|
                            (|NonNegativeInteger|)))
                       (SIGNATURE |differentiate|
                           (|#1| |#1| (|Mapping| |#2| |#2|)))
                       (SIGNATURE |differentiate|
                           (|#1| |#1| (|Mapping| |#2| |#2|)
                                 (|NonNegativeInteger|)))
                       (SIGNATURE |differentiate|
                           (|#1| |#1| (|List| (|Symbol|))
                                 (|List| (|NonNegativeInteger|))))
                       (SIGNATURE |differentiate|
                           (|#1| |#1| (|Symbol|)
                                 (|NonNegativeInteger|)))
                       (SIGNATURE |differentiate|
                           (|#1| |#1| (|List| (|Symbol|))))
                       (SIGNATURE |differentiate|
                                  (|#1| |#1| (|Symbol|)))
                       (SIGNATURE |differentiate| (|#1| |#1|))
                       (SIGNATURE |differentiate|
                           (|#1| |#1| (|NonNegativeInteger|)))
                       (SIGNATURE |elt| (|#1| |#1| |#1|))
                       (SIGNATURE |elt| (|#2| |#1| |#2|))
                       (SIGNATURE |factor| ((|Factored| |#1|) |#1|))
                       (SIGNATURE |squareFreePolynomial|
                           ((|Factored|
                                (|SparseUnivariatePolynomial| |#1|))
                            (|SparseUnivariatePolynomial| |#1|)))
                       (SIGNATURE |factorPolynomial|
                           ((|Factored|
                                (|SparseUnivariatePolynomial| |#1|))
                            (|SparseUnivariatePolynomial| |#1|)))
                       (SIGNATURE |factorSquareFreePolynomial|
                           ((|Factored|
                                (|SparseUnivariatePolynomial| |#1|))
                            (|SparseUnivariatePolynomial| |#1|)))
                       (SIGNATURE |solveLinearPolynomialEquation|
                           ((|Union| (|List|
                                      (|SparseUnivariatePolynomial|
                                       |#1|))
                                     "failed")
                            (|List| (|SparseUnivariatePolynomial| |#1|))
                            (|SparseUnivariatePolynomial| |#1|)))
                       (SIGNATURE |content|
                           (|#1| |#1| (|SingletonAsOrderedSet|)))
                       (SIGNATURE |variables|
                           ((|List| (|SingletonAsOrderedSet|)) |#1|))
                       (SIGNATURE |totalDegree|
                           ((|NonNegativeInteger|) |#1|
                            (|List| (|SingletonAsOrderedSet|))))
                       (SIGNATURE |totalDegree|
                           ((|NonNegativeInteger|) |#1|))
                       (SIGNATURE |monomial|
                           (|#1| |#1|
                                 (|List| (|SingletonAsOrderedSet|))
                                 (|List| (|NonNegativeInteger|))))
                       (SIGNATURE |monomial|
                           (|#1| |#1| (|SingletonAsOrderedSet|)
                                 (|NonNegativeInteger|)))
                       (SIGNATURE |minimumDegree|
                           ((|List| (|NonNegativeInteger|)) |#1|
                            (|List| (|SingletonAsOrderedSet|))))
                       (SIGNATURE |minimumDegree|
                           ((|NonNegativeInteger|) |#1|
                            (|SingletonAsOrderedSet|)))
                       (SIGNATURE |mainVariable|
                           ((|Union| (|SingletonAsOrderedSet|)
                                     "failed")
                            |#1|))
                       (SIGNATURE |degree|
                           ((|List| (|NonNegativeInteger|)) |#1|
                            (|List| (|SingletonAsOrderedSet|))))
                       (SIGNATURE |degree|
                           ((|NonNegativeInteger|) |#1|
                            (|SingletonAsOrderedSet|)))
                       (SIGNATURE |retract|
                           ((|SingletonAsOrderedSet|) |#1|))
                       (SIGNATURE |retractIfCan|
                           ((|Union| (|SingletonAsOrderedSet|)
                                     "failed")
                            |#1|))
                       (SIGNATURE |coerce|
                           (|#1| (|SingletonAsOrderedSet|)))
                       (SIGNATURE |eval|
                           (|#1| |#1|
                                 (|List| (|SingletonAsOrderedSet|))
                                 (|List| |#1|)))
                       (SIGNATURE |eval|
                           (|#1| |#1| (|SingletonAsOrderedSet|) |#1|))
                       (SIGNATURE |eval|
                                  (|#1| |#1|
                                        (|List|
                                         (|SingletonAsOrderedSet|))
                                        (|List| |#2|)))
                       (SIGNATURE |eval|
                           (|#1| |#1| (|SingletonAsOrderedSet|) |#2|))
                       (SIGNATURE |eval|
                           (|#1| |#1| (|List| |#1|) (|List| |#1|)))
                       (SIGNATURE |eval| (|#1| |#1| |#1| |#1|))
                       (SIGNATURE |eval| (|#1| |#1| (|Equation| |#1|)))
                       (SIGNATURE |eval|
                           (|#1| |#1| (|List| (|Equation| |#1|))))
                       (SIGNATURE |degree|
                           ((|NonNegativeInteger|) |#1|))
                       (SIGNATURE |monomial|
                           (|#1| |#2| (|NonNegativeInteger|)))
                       (SIGNATURE |retract| ((|Integer|) |#1|))
                       (SIGNATURE |retractIfCan|
                           ((|Union| (|Integer|) "failed") |#1|))
                       (SIGNATURE |retract|
                           ((|Fraction| (|Integer|)) |#1|))
                       (SIGNATURE |retractIfCan|
                           ((|Union| (|Fraction| (|Integer|)) "failed")
                            |#1|))
                       (SIGNATURE |coerce| (|#1| |#2|))
                       (SIGNATURE |retractIfCan|
                           ((|Union| |#2| "failed") |#1|))
                       (SIGNATURE |retract| (|#2| |#1|))
                       (SIGNATURE |minimumDegree|
                           ((|NonNegativeInteger|) |#1|))
                       (SIGNATURE |content| (|#2| |#1|))
                       (SIGNATURE |differentiate|
                           (|#1| |#1|
                                 (|List| (|SingletonAsOrderedSet|))
                                 (|List| (|NonNegativeInteger|))))
                       (SIGNATURE |differentiate|
                           (|#1| |#1| (|SingletonAsOrderedSet|)
                                 (|NonNegativeInteger|)))
                       (SIGNATURE |differentiate|
                           (|#1| |#1|
                                 (|List| (|SingletonAsOrderedSet|))))
                       (SIGNATURE |differentiate|
                           (|#1| |#1| (|SingletonAsOrderedSet|)))
                       (SIGNATURE |coerce| (|#1| (|Integer|)))
                       (SIGNATURE |coerce| ((|OutputForm|) |#1|)))
                   (|UnivariatePolynomialCategory| |#2|) (|Ring|))
                 T '|UnivariatePolynomialCategory&|
                 (|put| '|UnivariatePolynomialCategory&| '|mode|
                        '(|Mapping|
                             (CATEGORY |domain|
                                 (SIGNATURE |coerce| (|#1| |#1|))
                                 (SIGNATURE |gcdPolynomial|
                                     ((|SparseUnivariatePolynomial|
                                       |#1|)
                                      (|SparseUnivariatePolynomial|
                                       |#1|)
                                      (|SparseUnivariatePolynomial|
                                       |#1|)))
                                 (SIGNATURE |squareFree|
                                     ((|Factored| |#1|) |#1|))
                                 (SIGNATURE |squareFreePart|
                                     (|#1| |#1|))
                                 (SIGNATURE |coerce|
                                     (|#1| (|Fraction| (|Integer|))))
                                 (SIGNATURE |init| (|#1|))
                                 (SIGNATURE |nextItem|
                                     ((|Union| |#1| "failed") |#1|))
                                 (SIGNATURE |elt|
                                     ((|Fraction| |#1|) |#1|
                                      (|Fraction| |#1|)))
                                 (SIGNATURE |euclideanSize|
                                     ((|NonNegativeInteger|) |#1|))
                                 (SIGNATURE |divide|
                                     ((|Record| (|:| |quotient| |#1|)
                                       (|:| |remainder| |#1|))
                                      |#1| |#1|))
                                 (SIGNATURE |integrate| (|#1| |#1|))
                                 (SIGNATURE |elt|
                                     (|#2| (|Fraction| |#1|) |#2|))
                                 (SIGNATURE |separate|
                                     ((|Record| (|:| |primePart| |#1|)
                                       (|:| |commonPart| |#1|))
                                      |#1| |#1|))
                                 (SIGNATURE |pseudoDivide|
                                     ((|Record| (|:| |coef| |#2|)
                                       (|:| |quotient| |#1|)
                                       (|:| |remainder| |#1|))
                                      |#1| |#1|))
                                 (SIGNATURE |pseudoQuotient|
                                     (|#1| |#1| |#1|))
                                 (SIGNATURE |composite|
                                     ((|Union| (|Fraction| |#1|)
                                       "failed")
                                      (|Fraction| |#1|) |#1|))
                                 (SIGNATURE |composite|
                                     ((|Union| |#1| "failed") |#1|
                                      |#1|))
                                 (SIGNATURE |order|
                                     ((|NonNegativeInteger|) |#1| |#1|))
                                 (SIGNATURE |elt|
                                     ((|Fraction| |#1|)
                                      (|Fraction| |#1|)
                                      (|Fraction| |#1|)))
                                 (SIGNATURE |differentiate|
                                     (|#1| |#1| (|Mapping| |#2| |#2|)
                                      |#1|))
                                 (SIGNATURE |shiftLeft|
                                     (|#1| |#1| (|NonNegativeInteger|)))
                                 (SIGNATURE |shiftRight|
                                     (|#1| |#1| (|NonNegativeInteger|)))
                                 (SIGNATURE |karatsubaDivide|
                                     ((|Record| (|:| |quotient| |#1|)
                                       (|:| |remainder| |#1|))
                                      |#1| (|NonNegativeInteger|)))
                                 (SIGNATURE |unmakeSUP|
                                     (|#1|
                                      (|SparseUnivariatePolynomial|
                                       |#2|)))
                                 (SIGNATURE |makeSUP|
                                     ((|SparseUnivariatePolynomial|
                                       |#2|)
                                      |#1|))
                                 (SIGNATURE |vectorise|
                                     ((|Vector| |#2|) |#1|
                                      (|NonNegativeInteger|)))
                                 (SIGNATURE |differentiate|
                                     (|#1| |#1| (|Mapping| |#2| |#2|)))
                                 (SIGNATURE |differentiate|
                                     (|#1| |#1| (|Mapping| |#2| |#2|)
                                      (|NonNegativeInteger|)))
                                 (SIGNATURE |differentiate|
                                     (|#1| |#1| (|List| (|Symbol|))
                                      (|List| (|NonNegativeInteger|))))
                                 (SIGNATURE |differentiate|
                                     (|#1| |#1| (|Symbol|)
                                      (|NonNegativeInteger|)))
                                 (SIGNATURE |differentiate|
                                     (|#1| |#1| (|List| (|Symbol|))))
                                 (SIGNATURE |differentiate|
                                     (|#1| |#1| (|Symbol|)))
                                 (SIGNATURE |differentiate|
                                     (|#1| |#1|))
                                 (SIGNATURE |differentiate|
                                     (|#1| |#1| (|NonNegativeInteger|)))
                                 (SIGNATURE |elt| (|#1| |#1| |#1|))
                                 (SIGNATURE |elt| (|#2| |#1| |#2|))
                                 (SIGNATURE |factor|
                                     ((|Factored| |#1|) |#1|))
                                 (SIGNATURE |squareFreePolynomial|
                                     ((|Factored|
                                       (|SparseUnivariatePolynomial|
                                        |#1|))
                                      (|SparseUnivariatePolynomial|
                                       |#1|)))
                                 (SIGNATURE |factorPolynomial|
                                     ((|Factored|
                                       (|SparseUnivariatePolynomial|
                                        |#1|))
                                      (|SparseUnivariatePolynomial|
                                       |#1|)))
                                 (SIGNATURE
                                     |factorSquareFreePolynomial|
                                     ((|Factored|
                                       (|SparseUnivariatePolynomial|
                                        |#1|))
                                      (|SparseUnivariatePolynomial|
                                       |#1|)))
                                 (SIGNATURE
                                     |solveLinearPolynomialEquation|
                                     ((|Union|
                                       (|List|
                                        (|SparseUnivariatePolynomial|
                                         |#1|))
                                       "failed")
                                      (|List|
                                       (|SparseUnivariatePolynomial|
                                        |#1|))
                                      (|SparseUnivariatePolynomial|
                                       |#1|)))
                                 (SIGNATURE |content|
                                     (|#1| |#1|
                                      (|SingletonAsOrderedSet|)))
                                 (SIGNATURE |variables|
                                     ((|List|
                                       (|SingletonAsOrderedSet|))
                                      |#1|))
                                 (SIGNATURE |totalDegree|
                                     ((|NonNegativeInteger|) |#1|
                                      (|List|
                                       (|SingletonAsOrderedSet|))))
                                 (SIGNATURE |totalDegree|
                                     ((|NonNegativeInteger|) |#1|))
                                 (SIGNATURE |monomial|
                                     (|#1| |#1|
                                      (|List|
                                       (|SingletonAsOrderedSet|))
                                      (|List| (|NonNegativeInteger|))))
                                 (SIGNATURE |monomial|
                                     (|#1| |#1|
                                      (|SingletonAsOrderedSet|)
                                      (|NonNegativeInteger|)))
                                 (SIGNATURE |minimumDegree|
                                     ((|List| (|NonNegativeInteger|))
                                      |#1|
                                      (|List|
                                       (|SingletonAsOrderedSet|))))
                                 (SIGNATURE |minimumDegree|
                                     ((|NonNegativeInteger|) |#1|
                                      (|SingletonAsOrderedSet|)))
                                 (SIGNATURE |mainVariable|
                                     ((|Union|
                                       (|SingletonAsOrderedSet|)
                                       "failed")
                                      |#1|))
                                 (SIGNATURE |degree|
                                     ((|List| (|NonNegativeInteger|))
                                      |#1|
                                      (|List|
                                       (|SingletonAsOrderedSet|))))
                                 (SIGNATURE |degree|
                                     ((|NonNegativeInteger|) |#1|
                                      (|SingletonAsOrderedSet|)))
                                 (SIGNATURE |retract|
                                     ((|SingletonAsOrderedSet|) |#1|))
                                 (SIGNATURE |retractIfCan|
                                     ((|Union|
                                       (|SingletonAsOrderedSet|)
                                       "failed")
                                      |#1|))
                                 (SIGNATURE |coerce|
                                     (|#1| (|SingletonAsOrderedSet|)))
                                 (SIGNATURE |eval|
                                     (|#1| |#1|
                                      (|List|
                                       (|SingletonAsOrderedSet|))
                                      (|List| |#1|)))
                                 (SIGNATURE |eval|
                                     (|#1| |#1|
                                      (|SingletonAsOrderedSet|) |#1|))
                                 (SIGNATURE |eval|
                                     (|#1| |#1|
                                      (|List|
                                       (|SingletonAsOrderedSet|))
                                      (|List| |#2|)))
                                 (SIGNATURE |eval|
                                     (|#1| |#1|
                                      (|SingletonAsOrderedSet|) |#2|))
                                 (SIGNATURE |eval|
                                     (|#1| |#1| (|List| |#1|)
                                      (|List| |#1|)))
                                 (SIGNATURE |eval|
                                     (|#1| |#1| |#1| |#1|))
                                 (SIGNATURE |eval|
                                     (|#1| |#1| (|Equation| |#1|)))
                                 (SIGNATURE |eval|
                                     (|#1| |#1|
                                      (|List| (|Equation| |#1|))))
                                 (SIGNATURE |degree|
                                     ((|NonNegativeInteger|) |#1|))
                                 (SIGNATURE |monomial|
                                     (|#1| |#2| (|NonNegativeInteger|)))
                                 (SIGNATURE |retract|
                                     ((|Integer|) |#1|))
                                 (SIGNATURE |retractIfCan|
                                     ((|Union| (|Integer|) "failed")
                                      |#1|))
                                 (SIGNATURE |retract|
                                     ((|Fraction| (|Integer|)) |#1|))
                                 (SIGNATURE |retractIfCan|
                                     ((|Union| (|Fraction| (|Integer|))
                                       "failed")
                                      |#1|))
                                 (SIGNATURE |coerce| (|#1| |#2|))
                                 (SIGNATURE |retractIfCan|
                                     ((|Union| |#2| "failed") |#1|))
                                 (SIGNATURE |retract| (|#2| |#1|))
                                 (SIGNATURE |minimumDegree|
                                     ((|NonNegativeInteger|) |#1|))
                                 (SIGNATURE |content| (|#2| |#1|))
                                 (SIGNATURE |differentiate|
                                     (|#1| |#1|
                                      (|List|
                                       (|SingletonAsOrderedSet|))
                                      (|List| (|NonNegativeInteger|))))
                                 (SIGNATURE |differentiate|
                                     (|#1| |#1|
                                      (|SingletonAsOrderedSet|)
                                      (|NonNegativeInteger|)))
                                 (SIGNATURE |differentiate|
                                     (|#1| |#1|
                                      (|List|
                                       (|SingletonAsOrderedSet|))))
                                 (SIGNATURE |differentiate|
                                     (|#1| |#1|
                                      (|SingletonAsOrderedSet|)))
                                 (SIGNATURE |coerce|
                                     (|#1| (|Integer|)))
                                 (SIGNATURE |coerce|
                                     ((|OutputForm|) |#1|)))
                             (|UnivariatePolynomialCategory| |#2|)
                             (|Ring|))
                        |$CategoryFrame|))))