aboutsummaryrefslogtreecommitdiff
path: root/src/algebra/strap/PSETCAT-.lsp
blob: a216f16eb99dddb7eef1563d5dd333911f9f5bb3 (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
(/VERSIONCHECK 2) 

(DECLAIM (FTYPE (FUNCTION (|%Thing| |%Shell|) |%List|)
                |PSETCAT-;elements|)) 

(DECLAIM (FTYPE (FUNCTION (|%List| |%Shell|) |%List|)
                |PSETCAT-;variables1|)) 

(DECLAIM (FTYPE (FUNCTION (|%List| |%Shell|) |%List|)
                |PSETCAT-;variables2|)) 

(DECLAIM (FTYPE (FUNCTION (|%Thing| |%Shell|) |%List|)
                |PSETCAT-;variables;SL;4|)) 

(DECLAIM (FTYPE (FUNCTION (|%Thing| |%Shell|) |%List|)
                |PSETCAT-;mainVariables;SL;5|)) 

(DECLAIM (FTYPE (FUNCTION (|%Thing| |%Thing| |%Shell|) |%Boolean|)
                |PSETCAT-;mainVariable?;VarSetSB;6|)) 

(DECLAIM (FTYPE (FUNCTION (|%Thing| |%Thing| |%Shell|) |%Thing|)
                |PSETCAT-;collectUnder;SVarSetS;7|)) 

(DECLAIM (FTYPE (FUNCTION (|%Thing| |%Thing| |%Shell|) |%Thing|)
                |PSETCAT-;collectUpper;SVarSetS;8|)) 

(DECLAIM (FTYPE (FUNCTION (|%Thing| |%Thing| |%Shell|) |%Thing|)
                |PSETCAT-;collect;SVarSetS;9|)) 

(DECLAIM (FTYPE (FUNCTION (|%Thing| |%Thing| |%Shell|) |%Shell|)
                |PSETCAT-;sort;SVarSetR;10|)) 

(DECLAIM (FTYPE (FUNCTION (|%Thing| |%Thing| |%Shell|) |%Boolean|)
                |PSETCAT-;=;2SB;11|)) 

(DECLAIM (FTYPE (FUNCTION (|%Thing| |%Thing| |%Shell|) |%Boolean|)
                |PSETCAT-;localInf?|)) 

(DECLAIM (FTYPE (FUNCTION (|%List| |%Shell|) |%Boolean|)
                |PSETCAT-;localTriangular?|)) 

(DECLAIM (FTYPE (FUNCTION (|%Thing| |%Shell|) |%Boolean|)
                |PSETCAT-;triangular?;SB;14|)) 

(DECLAIM (FTYPE (FUNCTION (|%Thing| |%Shell|) |%Boolean|)
                |PSETCAT-;trivialIdeal?;SB;15|)) 

(DECLAIM (FTYPE (FUNCTION (|%Thing| |%Shell|) |%Boolean|)
                |PSETCAT-;roughUnitIdeal?;SB;16|)) 

(DECLAIM (FTYPE (FUNCTION (|%Thing| |%Thing| |%Shell|) |%Boolean|)
                |PSETCAT-;relativelyPrimeLeadingMonomials?|)) 

(DECLAIM (FTYPE (FUNCTION (|%Thing| |%Shell|) |%Boolean|)
                |PSETCAT-;roughBase?;SB;18|)) 

(DECLAIM (FTYPE (FUNCTION (|%Thing| |%Thing| |%Shell|) |%Boolean|)
                |PSETCAT-;roughSubIdeal?;2SB;19|)) 

(DECLAIM (FTYPE (FUNCTION (|%Thing| |%Thing| |%Shell|) |%Boolean|)
                |PSETCAT-;roughEqualIdeals?;2SB;20|)) 

(DECLAIM (FTYPE (FUNCTION (|%Thing| |%Thing| |%Shell|) |%Thing|)
                |PSETCAT-;exactQuo|)) 

(DECLAIM (FTYPE (FUNCTION (|%Thing| |%Thing| |%Shell|) |%Pair|)
                |PSETCAT-;headRemainder;PSR;22|)) 

(DECLAIM (FTYPE (FUNCTION (|%Pair| |%Shell|) |%Pair|)
                |PSETCAT-;makeIrreducible!|)) 

(DECLAIM (FTYPE (FUNCTION (|%Thing| |%Thing| |%Shell|) |%Shell|)
                |PSETCAT-;remainder;PSR;24|)) 

(DECLAIM (FTYPE (FUNCTION (|%List| |%Thing| |%Shell|) |%List|)
                |PSETCAT-;rewriteIdealWithHeadRemainder;LSL;25|)) 

(DECLAIM (FTYPE (FUNCTION (|%List| |%Thing| |%Shell|) |%List|)
                |PSETCAT-;rewriteIdealWithRemainder;LSL;26|)) 

(DEFUN |PSETCAT-;elements| (|ps| $)
  (PROG (|lp|)
    (RETURN
      (LETT |lp| (SPADCALL |ps| (|getShellEntry| $ 12))
            |PSETCAT-;elements|)))) 

(DEFUN |PSETCAT-;variables1| (|lp| $)
  (PROG (#0=#:G1558 |p| #1=#:G1559 |lvars|)
    (RETURN
      (SEQ (LETT |lvars|
                 (PROGN
                   (LETT #0# NIL |PSETCAT-;variables1|)
                   (SEQ (LETT |p| NIL |PSETCAT-;variables1|)
                        (LETT #1# |lp| |PSETCAT-;variables1|) G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN
                                 (LETT |p| (CAR #1#)
                                       |PSETCAT-;variables1|)
                                 NIL))
                           (GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS
                                     (SPADCALL |p|
                                      (|getShellEntry| $ 14))
                                     #0#)
                                    |PSETCAT-;variables1|)))
                        (LETT #1# (CDR #1#) |PSETCAT-;variables1|)
                        (GO G190) G191 (EXIT (NREVERSE0 #0#))))
                 |PSETCAT-;variables1|)
           (EXIT (SPADCALL (CONS #'|PSETCAT-;variables1!0| $)
                     (SPADCALL
                         (SPADCALL |lvars| (|getShellEntry| $ 18))
                         (|getShellEntry| $ 19))
                     (|getShellEntry| $ 21))))))) 

(DEFUN |PSETCAT-;variables1!0| (|#1| |#2| $)
  (SPADCALL |#2| |#1| (|getShellEntry| $ 16))) 

(DEFUN |PSETCAT-;variables2| (|lp| $)
  (PROG (#0=#:G1560 |p| #1=#:G1561 |lvars|)
    (RETURN
      (SEQ (LETT |lvars|
                 (PROGN
                   (LETT #0# NIL |PSETCAT-;variables2|)
                   (SEQ (LETT |p| NIL |PSETCAT-;variables2|)
                        (LETT #1# |lp| |PSETCAT-;variables2|) G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN
                                 (LETT |p| (CAR #1#)
                                       |PSETCAT-;variables2|)
                                 NIL))
                           (GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS
                                     (SPADCALL |p|
                                      (|getShellEntry| $ 22))
                                     #0#)
                                    |PSETCAT-;variables2|)))
                        (LETT #1# (CDR #1#) |PSETCAT-;variables2|)
                        (GO G190) G191 (EXIT (NREVERSE0 #0#))))
                 |PSETCAT-;variables2|)
           (EXIT (SPADCALL (CONS #'|PSETCAT-;variables2!0| $)
                     (SPADCALL |lvars| (|getShellEntry| $ 19))
                     (|getShellEntry| $ 21))))))) 

(DEFUN |PSETCAT-;variables2!0| (|#1| |#2| $)
  (SPADCALL |#2| |#1| (|getShellEntry| $ 16))) 

(DEFUN |PSETCAT-;variables;SL;4| (|ps| $)
  (|PSETCAT-;variables1| (|PSETCAT-;elements| |ps| $) $)) 

(DEFUN |PSETCAT-;mainVariables;SL;5| (|ps| $)
  (|PSETCAT-;variables2|
      (SPADCALL (ELT $ 24) (|PSETCAT-;elements| |ps| $)
          (|getShellEntry| $ 26))
      $)) 

(DEFUN |PSETCAT-;mainVariable?;VarSetSB;6| (|v| |ps| $)
  (PROG (|lp|)
    (RETURN
      (SEQ (LETT |lp|
                 (SPADCALL (ELT $ 24) (|PSETCAT-;elements| |ps| $)
                     (|getShellEntry| $ 26))
                 |PSETCAT-;mainVariable?;VarSetSB;6|)
           (SEQ G190
                (COND
                  ((NULL (COND
                           ((NULL |lp|) 'NIL)
                           ('T
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL (|SPADfirst| |lp|)
                                     (|getShellEntry| $ 22))
                                    |v| (|getShellEntry| $ 28))
                                (|getShellEntry| $ 29)))))
                   (GO G191)))
                (SEQ (EXIT (LETT |lp| (CDR |lp|)
                                 |PSETCAT-;mainVariable?;VarSetSB;6|)))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT (SPADCALL (NULL |lp|) (|getShellEntry| $ 29))))))) 

(DEFUN |PSETCAT-;collectUnder;SVarSetS;7| (|ps| |v| $)
  (PROG (|p| |lp| |lq|)
    (RETURN
      (SEQ (LETT |lp| (|PSETCAT-;elements| |ps| $)
                 |PSETCAT-;collectUnder;SVarSetS;7|)
           (LETT |lq| NIL |PSETCAT-;collectUnder;SVarSetS;7|)
           (SEQ G190
                (COND
                  ((NULL (SPADCALL (NULL |lp|) (|getShellEntry| $ 29)))
                   (GO G191)))
                (SEQ (LETT |p| (|SPADfirst| |lp|)
                           |PSETCAT-;collectUnder;SVarSetS;7|)
                     (LETT |lp| (CDR |lp|)
                           |PSETCAT-;collectUnder;SVarSetS;7|)
                     (EXIT (COND
                             ((OR (SPADCALL |p| (|getShellEntry| $ 24))
                                  (SPADCALL
                                      (SPADCALL |p|
                                       (|getShellEntry| $ 22))
                                      |v| (|getShellEntry| $ 16)))
                              (LETT |lq| (CONS |p| |lq|)
                                    |PSETCAT-;collectUnder;SVarSetS;7|)))))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT (SPADCALL |lq| (|getShellEntry| $ 31))))))) 

(DEFUN |PSETCAT-;collectUpper;SVarSetS;8| (|ps| |v| $)
  (PROG (|p| |lp| |lq|)
    (RETURN
      (SEQ (LETT |lp| (|PSETCAT-;elements| |ps| $)
                 |PSETCAT-;collectUpper;SVarSetS;8|)
           (LETT |lq| NIL |PSETCAT-;collectUpper;SVarSetS;8|)
           (SEQ G190
                (COND
                  ((NULL (SPADCALL (NULL |lp|) (|getShellEntry| $ 29)))
                   (GO G191)))
                (SEQ (LETT |p| (|SPADfirst| |lp|)
                           |PSETCAT-;collectUpper;SVarSetS;8|)
                     (LETT |lp| (CDR |lp|)
                           |PSETCAT-;collectUpper;SVarSetS;8|)
                     (EXIT (COND
                             ((NULL (SPADCALL |p|
                                     (|getShellEntry| $ 24)))
                              (COND
                                ((SPADCALL |v|
                                     (SPADCALL |p|
                                      (|getShellEntry| $ 22))
                                     (|getShellEntry| $ 16))
                                 (LETT |lq| (CONS |p| |lq|)
                                       |PSETCAT-;collectUpper;SVarSetS;8|)))))))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT (SPADCALL |lq| (|getShellEntry| $ 31))))))) 

(DEFUN |PSETCAT-;collect;SVarSetS;9| (|ps| |v| $)
  (PROG (|p| |lp| |lq|)
    (RETURN
      (SEQ (LETT |lp| (|PSETCAT-;elements| |ps| $)
                 |PSETCAT-;collect;SVarSetS;9|)
           (LETT |lq| NIL |PSETCAT-;collect;SVarSetS;9|)
           (SEQ G190
                (COND
                  ((NULL (SPADCALL (NULL |lp|) (|getShellEntry| $ 29)))
                   (GO G191)))
                (SEQ (LETT |p| (|SPADfirst| |lp|)
                           |PSETCAT-;collect;SVarSetS;9|)
                     (LETT |lp| (CDR |lp|)
                           |PSETCAT-;collect;SVarSetS;9|)
                     (EXIT (COND
                             ((NULL (SPADCALL |p|
                                     (|getShellEntry| $ 24)))
                              (COND
                                ((SPADCALL
                                     (SPADCALL |p|
                                      (|getShellEntry| $ 22))
                                     |v| (|getShellEntry| $ 28))
                                 (LETT |lq| (CONS |p| |lq|)
                                       |PSETCAT-;collect;SVarSetS;9|)))))))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT (SPADCALL |lq| (|getShellEntry| $ 31))))))) 

(DEFUN |PSETCAT-;sort;SVarSetR;10| (|ps| |v| $)
  (PROG (|p| |lp| |us| |vs| |ws|)
    (RETURN
      (SEQ (LETT |lp| (|PSETCAT-;elements| |ps| $)
                 |PSETCAT-;sort;SVarSetR;10|)
           (LETT |us| NIL |PSETCAT-;sort;SVarSetR;10|)
           (LETT |vs| NIL |PSETCAT-;sort;SVarSetR;10|)
           (LETT |ws| NIL |PSETCAT-;sort;SVarSetR;10|)
           (SEQ G190
                (COND
                  ((NULL (SPADCALL (NULL |lp|) (|getShellEntry| $ 29)))
                   (GO G191)))
                (SEQ (LETT |p| (|SPADfirst| |lp|)
                           |PSETCAT-;sort;SVarSetR;10|)
                     (LETT |lp| (CDR |lp|) |PSETCAT-;sort;SVarSetR;10|)
                     (EXIT (COND
                             ((OR (SPADCALL |p| (|getShellEntry| $ 24))
                                  (SPADCALL
                                      (SPADCALL |p|
                                       (|getShellEntry| $ 22))
                                      |v| (|getShellEntry| $ 16)))
                              (LETT |us| (CONS |p| |us|)
                                    |PSETCAT-;sort;SVarSetR;10|))
                             ((SPADCALL
                                  (SPADCALL |p| (|getShellEntry| $ 22))
                                  |v| (|getShellEntry| $ 28))
                              (LETT |vs| (CONS |p| |vs|)
                                    |PSETCAT-;sort;SVarSetR;10|))
                             ('T
                              (LETT |ws| (CONS |p| |ws|)
                                    |PSETCAT-;sort;SVarSetR;10|)))))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT (VECTOR (SPADCALL |us| (|getShellEntry| $ 31))
                         (SPADCALL |vs| (|getShellEntry| $ 31))
                         (SPADCALL |ws| (|getShellEntry| $ 31)))))))) 

(DEFUN |PSETCAT-;=;2SB;11| (|ps1| |ps2| $)
  (PROG (#0=#:G1562 #1=#:G1563 #2=#:G1564 |p| #3=#:G1565)
    (RETURN
      (SEQ (SPADCALL
               (SPADCALL
                   (PROGN
                     (LETT #0# NIL |PSETCAT-;=;2SB;11|)
                     (SEQ (LETT |p| NIL |PSETCAT-;=;2SB;11|)
                          (LETT #1# (|PSETCAT-;elements| |ps1| $)
                                |PSETCAT-;=;2SB;11|)
                          G190
                          (COND
                            ((OR (ATOM #1#)
                                 (PROGN
                                   (LETT |p| (CAR #1#)
                                    |PSETCAT-;=;2SB;11|)
                                   NIL))
                             (GO G191)))
                          (SEQ (EXIT (LETT #0# (CONS |p| #0#)
                                      |PSETCAT-;=;2SB;11|)))
                          (LETT #1# (CDR #1#) |PSETCAT-;=;2SB;11|)
                          (GO G190) G191 (EXIT (NREVERSE0 #0#))))
                   (|getShellEntry| $ 38))
               (SPADCALL
                   (PROGN
                     (LETT #2# NIL |PSETCAT-;=;2SB;11|)
                     (SEQ (LETT |p| NIL |PSETCAT-;=;2SB;11|)
                          (LETT #3# (|PSETCAT-;elements| |ps2| $)
                                |PSETCAT-;=;2SB;11|)
                          G190
                          (COND
                            ((OR (ATOM #3#)
                                 (PROGN
                                   (LETT |p| (CAR #3#)
                                    |PSETCAT-;=;2SB;11|)
                                   NIL))
                             (GO G191)))
                          (SEQ (EXIT (LETT #2# (CONS |p| #2#)
                                      |PSETCAT-;=;2SB;11|)))
                          (LETT #3# (CDR #3#) |PSETCAT-;=;2SB;11|)
                          (GO G190) G191 (EXIT (NREVERSE0 #2#))))
                   (|getShellEntry| $ 38))
               (|getShellEntry| $ 39)))))) 

(DEFUN |PSETCAT-;localInf?| (|p| |q| $)
  (SPADCALL (SPADCALL |p| (|getShellEntry| $ 41))
      (SPADCALL |q| (|getShellEntry| $ 41)) (|getShellEntry| $ 42))) 

(DEFUN |PSETCAT-;localTriangular?| (|lp| $)
  (PROG (|q| |p|)
    (RETURN
      (SEQ (LETT |lp| (SPADCALL (ELT $ 43) |lp| (|getShellEntry| $ 26))
                 |PSETCAT-;localTriangular?|)
           (EXIT (COND
                   ((NULL |lp|) 'T)
                   ((SPADCALL (ELT $ 24) |lp| (|getShellEntry| $ 44))
                    'NIL)
                   ('T
                    (SEQ (LETT |lp|
                               (SPADCALL
                                   (CONS
                                    #'|PSETCAT-;localTriangular?!0| $)
                                   |lp| (|getShellEntry| $ 46))
                               |PSETCAT-;localTriangular?|)
                         (LETT |p| (|SPADfirst| |lp|)
                               |PSETCAT-;localTriangular?|)
                         (LETT |lp| (CDR |lp|)
                               |PSETCAT-;localTriangular?|)
                         (SEQ G190
                              (COND
                                ((NULL (COND
                                         ((NULL |lp|) 'NIL)
                                         ('T
                                          (SPADCALL
                                           (SPADCALL
                                            (LETT |q|
                                             (|SPADfirst| |lp|)
                                             |PSETCAT-;localTriangular?|)
                                            (|getShellEntry| $ 22))
                                           (SPADCALL |p|
                                            (|getShellEntry| $ 22))
                                           (|getShellEntry| $ 16)))))
                                 (GO G191)))
                              (SEQ (LETT |p| |q|
                                    |PSETCAT-;localTriangular?|)
                                   (EXIT
                                    (LETT |lp| (CDR |lp|)
                                     |PSETCAT-;localTriangular?|)))
                              NIL (GO G190) G191 (EXIT NIL))
                         (EXIT (NULL |lp|)))))))))) 

(DEFUN |PSETCAT-;localTriangular?!0| (|#1| |#2| $)
  (SPADCALL (SPADCALL |#2| (|getShellEntry| $ 22))
      (SPADCALL |#1| (|getShellEntry| $ 22)) (|getShellEntry| $ 16))) 

(DEFUN |PSETCAT-;triangular?;SB;14| (|ps| $)
  (|PSETCAT-;localTriangular?| (|PSETCAT-;elements| |ps| $) $)) 

(DEFUN |PSETCAT-;trivialIdeal?;SB;15| (|ps| $)
  (NULL (SPADCALL (ELT $ 43) (|PSETCAT-;elements| |ps| $)
            (|getShellEntry| $ 26)))) 

(DEFUN |PSETCAT-;roughUnitIdeal?;SB;16| (|ps| $)
  (SPADCALL (ELT $ 24)
      (SPADCALL (ELT $ 43) (|PSETCAT-;elements| |ps| $)
          (|getShellEntry| $ 26))
      (|getShellEntry| $ 44))) 

(DEFUN |PSETCAT-;relativelyPrimeLeadingMonomials?| (|p| |q| $)
  (PROG (|dp| |dq|)
    (RETURN
      (SEQ (LETT |dp| (SPADCALL |p| (|getShellEntry| $ 41))
                 |PSETCAT-;relativelyPrimeLeadingMonomials?|)
           (LETT |dq| (SPADCALL |q| (|getShellEntry| $ 41))
                 |PSETCAT-;relativelyPrimeLeadingMonomials?|)
           (EXIT (SPADCALL (SPADCALL |dp| |dq| (|getShellEntry| $ 50))
                     (SPADCALL |dp| |dq| (|getShellEntry| $ 51))
                     (|getShellEntry| $ 52))))))) 

(DEFUN |PSETCAT-;roughBase?;SB;18| (|ps| $)
  (PROG (|p| |lp| |rB?| |copylp|)
    (RETURN
      (SEQ (LETT |lp|
                 (SPADCALL (ELT $ 43) (|PSETCAT-;elements| |ps| $)
                     (|getShellEntry| $ 26))
                 |PSETCAT-;roughBase?;SB;18|)
           (EXIT (COND
                   ((NULL |lp|) 'T)
                   ('T
                    (SEQ (LETT |rB?| 'T |PSETCAT-;roughBase?;SB;18|)
                         (SEQ G190
                              (COND
                                ((NULL (COND
                                         ((NULL |lp|) 'NIL)
                                         ('T |rB?|)))
                                 (GO G191)))
                              (SEQ (LETT |p| (|SPADfirst| |lp|)
                                    |PSETCAT-;roughBase?;SB;18|)
                                   (LETT |lp| (CDR |lp|)
                                    |PSETCAT-;roughBase?;SB;18|)
                                   (LETT |copylp| |lp|
                                    |PSETCAT-;roughBase?;SB;18|)
                                   (EXIT
                                    (SEQ G190
                                     (COND
                                       ((NULL
                                         (COND
                                           ((NULL |copylp|) 'NIL)
                                           ('T |rB?|)))
                                        (GO G191)))
                                     (SEQ
                                      (LETT |rB?|
                                       (|PSETCAT-;relativelyPrimeLeadingMonomials?|
                                        |p| (|SPADfirst| |copylp|) $)
                                       |PSETCAT-;roughBase?;SB;18|)
                                      (EXIT
                                       (LETT |copylp| (CDR |copylp|)
                                        |PSETCAT-;roughBase?;SB;18|)))
                                     NIL (GO G190) G191 (EXIT NIL))))
                              NIL (GO G190) G191 (EXIT NIL))
                         (EXIT |rB?|))))))))) 

(DEFUN |PSETCAT-;roughSubIdeal?;2SB;19| (|ps1| |ps2| $)
  (PROG (|lp|)
    (RETURN
      (SEQ (LETT |lp|
                 (SPADCALL (|PSETCAT-;elements| |ps1| $) |ps2|
                     (|getShellEntry| $ 54))
                 |PSETCAT-;roughSubIdeal?;2SB;19|)
           (EXIT (NULL (SPADCALL (ELT $ 43) |lp|
                           (|getShellEntry| $ 26)))))))) 

(DEFUN |PSETCAT-;roughEqualIdeals?;2SB;20| (|ps1| |ps2| $)
  (COND
    ((SPADCALL |ps1| |ps2| (|getShellEntry| $ 56)) 'T)
    ((SPADCALL |ps1| |ps2| (|getShellEntry| $ 57))
     (SPADCALL |ps2| |ps1| (|getShellEntry| $ 57)))
    ('T 'NIL))) 

(DEFUN |PSETCAT-;exactQuo| (|r| |s| $)
  (PROG (#0=#:G1507)
    (RETURN
      (COND
        ((|HasCategory| (|getShellEntry| $ 7) '(|EuclideanDomain|))
         (SPADCALL |r| |s| (|getShellEntry| $ 59)))
        ('T
         (PROG2 (LETT #0# (SPADCALL |r| |s| (|getShellEntry| $ 61))
                      |PSETCAT-;exactQuo|)
                (QCDR #0#)
           (|check-union| (QEQCAR #0# 0) (|getShellEntry| $ 7) #0#))))))) 

(DEFUN |PSETCAT-;headRemainder;PSR;22| (|a| |ps| $)
  (PROG (|lp1| |p| |e| |g| |#G45| |#G46| |lca| |lcp| |r| |lp2|)
    (RETURN
      (SEQ (LETT |lp1|
                 (SPADCALL (ELT $ 43) (|PSETCAT-;elements| |ps| $)
                     (|getShellEntry| $ 26))
                 |PSETCAT-;headRemainder;PSR;22|)
           (EXIT (COND
                   ((NULL |lp1|) (CONS |a| (|spadConstant| $ 62)))
                   ((SPADCALL (ELT $ 24) |lp1| (|getShellEntry| $ 44))
                    (CONS (SPADCALL |a| (|getShellEntry| $ 63))
                          (|spadConstant| $ 62)))
                   ('T
                    (SEQ (LETT |r| (|spadConstant| $ 62)
                               |PSETCAT-;headRemainder;PSR;22|)
                         (LETT |lp1|
                               (SPADCALL
                                   (CONS
                                    (|function| |PSETCAT-;localInf?|)
                                    $)
                                   (REVERSE
                                    (|PSETCAT-;elements| |ps| $))
                                   (|getShellEntry| $ 46))
                               |PSETCAT-;headRemainder;PSR;22|)
                         (LETT |lp2| |lp1|
                               |PSETCAT-;headRemainder;PSR;22|)
                         (SEQ G190
                              (COND
                                ((NULL (COND
                                         ((SPADCALL |a|
                                           (|getShellEntry| $ 43))
                                          'NIL)
                                         ('T
                                          (SPADCALL (NULL |lp2|)
                                           (|getShellEntry| $ 29)))))
                                 (GO G191)))
                              (SEQ (LETT |p| (|SPADfirst| |lp2|)
                                    |PSETCAT-;headRemainder;PSR;22|)
                                   (LETT |e|
                                    (SPADCALL
                                     (SPADCALL |a|
                                      (|getShellEntry| $ 41))
                                     (SPADCALL |p|
                                      (|getShellEntry| $ 41))
                                     (|getShellEntry| $ 64))
                                    |PSETCAT-;headRemainder;PSR;22|)
                                   (EXIT
                                    (COND
                                      ((QEQCAR |e| 0)
                                       (SEQ
                                        (LETT |g|
                                         (SPADCALL
                                          (LETT |lca|
                                           (SPADCALL |a|
                                            (|getShellEntry| $ 65))
                                           |PSETCAT-;headRemainder;PSR;22|)
                                          (LETT |lcp|
                                           (SPADCALL |p|
                                            (|getShellEntry| $ 65))
                                           |PSETCAT-;headRemainder;PSR;22|)
                                          (|getShellEntry| $ 66))
                                         |PSETCAT-;headRemainder;PSR;22|)
                                        (PROGN
                                          (LETT |#G45|
                                           (|PSETCAT-;exactQuo| |lca|
                                            |g| $)
                                           |PSETCAT-;headRemainder;PSR;22|)
                                          (LETT |#G46|
                                           (|PSETCAT-;exactQuo| |lcp|
                                            |g| $)
                                           |PSETCAT-;headRemainder;PSR;22|)
                                          (LETT |lca| |#G45|
                                           |PSETCAT-;headRemainder;PSR;22|)
                                          (LETT |lcp| |#G46|
                                           |PSETCAT-;headRemainder;PSR;22|))
                                        (LETT |a|
                                         (SPADCALL
                                          (SPADCALL |lcp|
                                           (SPADCALL |a|
                                            (|getShellEntry| $ 63))
                                           (|getShellEntry| $ 67))
                                          (SPADCALL
                                           (SPADCALL |lca| (QCDR |e|)
                                            (|getShellEntry| $ 68))
                                           (SPADCALL |p|
                                            (|getShellEntry| $ 63))
                                           (|getShellEntry| $ 69))
                                          (|getShellEntry| $ 70))
                                         |PSETCAT-;headRemainder;PSR;22|)
                                        (LETT |r|
                                         (SPADCALL |r| |lcp|
                                          (|getShellEntry| $ 71))
                                         |PSETCAT-;headRemainder;PSR;22|)
                                        (EXIT
                                         (LETT |lp2| |lp1|
                                          |PSETCAT-;headRemainder;PSR;22|))))
                                      ('T
                                       (LETT |lp2| (CDR |lp2|)
                                        |PSETCAT-;headRemainder;PSR;22|)))))
                              NIL (GO G190) G191 (EXIT NIL))
                         (EXIT (CONS |a| |r|)))))))))) 

(DEFUN |PSETCAT-;makeIrreducible!| (|frac| $)
  (PROG (|g|)
    (RETURN
      (SEQ (LETT |g|
                 (SPADCALL (QCDR |frac|) (QCAR |frac|)
                     (|getShellEntry| $ 74))
                 |PSETCAT-;makeIrreducible!|)
           (EXIT (COND
                   ((SPADCALL |g| (|spadConstant| $ 62)
                        (|getShellEntry| $ 76))
                    |frac|)
                   ('T
                    (SEQ (PROGN
                           (RPLACA |frac|
                                   (SPADCALL (QCAR |frac|) |g|
                                    (|getShellEntry| $ 77)))
                           (QCAR |frac|))
                         (PROGN
                           (RPLACD |frac|
                                   (|PSETCAT-;exactQuo| (QCDR |frac|)
                                    |g| $))
                           (QCDR |frac|))
                         (EXIT |frac|))))))))) 

(DEFUN |PSETCAT-;remainder;PSR;24| (|a| |ps| $)
  (PROG (|hRa| |r| |lca| |g| |b| |c|)
    (RETURN
      (SEQ (LETT |hRa|
                 (|PSETCAT-;makeIrreducible!|
                     (SPADCALL |a| |ps| (|getShellEntry| $ 78)) $)
                 |PSETCAT-;remainder;PSR;24|)
           (LETT |a| (QCAR |hRa|) |PSETCAT-;remainder;PSR;24|)
           (LETT |r| (QCDR |hRa|) |PSETCAT-;remainder;PSR;24|)
           (EXIT (COND
                   ((SPADCALL |a| (|getShellEntry| $ 43))
                    (VECTOR (|spadConstant| $ 62) |a| |r|))
                   ('T
                    (SEQ (LETT |b|
                               (SPADCALL (|spadConstant| $ 62)
                                   (SPADCALL |a|
                                    (|getShellEntry| $ 41))
                                   (|getShellEntry| $ 68))
                               |PSETCAT-;remainder;PSR;24|)
                         (LETT |c|
                               (SPADCALL |a| (|getShellEntry| $ 65))
                               |PSETCAT-;remainder;PSR;24|)
                         (SEQ G190
                              (COND
                                ((NULL (SPADCALL
                                        (SPADCALL
                                         (LETT |a|
                                          (SPADCALL |a|
                                           (|getShellEntry| $ 63))
                                          |PSETCAT-;remainder;PSR;24|)
                                         (|getShellEntry| $ 43))
                                        (|getShellEntry| $ 29)))
                                 (GO G191)))
                              (SEQ (LETT |hRa|
                                    (|PSETCAT-;makeIrreducible!|
                                     (SPADCALL |a| |ps|
                                      (|getShellEntry| $ 78))
                                     $)
                                    |PSETCAT-;remainder;PSR;24|)
                                   (LETT |a| (QCAR |hRa|)
                                    |PSETCAT-;remainder;PSR;24|)
                                   (LETT |r|
                                    (SPADCALL |r| (QCDR |hRa|)
                                     (|getShellEntry| $ 71))
                                    |PSETCAT-;remainder;PSR;24|)
                                   (LETT |g|
                                    (SPADCALL |c|
                                     (LETT |lca|
                                      (SPADCALL |a|
                                       (|getShellEntry| $ 65))
                                      |PSETCAT-;remainder;PSR;24|)
                                     (|getShellEntry| $ 66))
                                    |PSETCAT-;remainder;PSR;24|)
                                   (LETT |b|
                                    (SPADCALL
                                     (SPADCALL
                                      (SPADCALL (QCDR |hRa|)
                                       (|PSETCAT-;exactQuo| |c| |g| $)
                                       (|getShellEntry| $ 71))
                                      |b| (|getShellEntry| $ 67))
                                     (SPADCALL
                                      (|PSETCAT-;exactQuo| |lca| |g| $)
                                      (SPADCALL |a|
                                       (|getShellEntry| $ 41))
                                      (|getShellEntry| $ 68))
                                     (|getShellEntry| $ 79))
                                    |PSETCAT-;remainder;PSR;24|)
                                   (EXIT
                                    (LETT |c| |g|
                                     |PSETCAT-;remainder;PSR;24|)))
                              NIL (GO G190) G191 (EXIT NIL))
                         (EXIT (VECTOR |c| |b| |r|)))))))))) 

(DEFUN |PSETCAT-;rewriteIdealWithHeadRemainder;LSL;25| (|ps| |cs| $)
  (PROG (|p| |rs|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |cs| (|getShellEntry| $ 82)) |ps|)
             ((SPADCALL |cs| (|getShellEntry| $ 83))
              (LIST (|spadConstant| $ 84)))
             ('T
              (SEQ (LETT |ps|
                         (SPADCALL (ELT $ 43) |ps|
                             (|getShellEntry| $ 26))
                         |PSETCAT-;rewriteIdealWithHeadRemainder;LSL;25|)
                   (EXIT (COND
                           ((NULL |ps|) |ps|)
                           ((SPADCALL (ELT $ 24) |ps|
                                (|getShellEntry| $ 44))
                            (LIST (|spadConstant| $ 75)))
                           ('T
                            (SEQ (LETT |rs| NIL
                                       |PSETCAT-;rewriteIdealWithHeadRemainder;LSL;25|)
                                 (SEQ G190
                                      (COND
                                        ((NULL
                                          (SPADCALL (NULL |ps|)
                                           (|getShellEntry| $ 29)))
                                         (GO G191)))
                                      (SEQ
                                       (LETT |p| (|SPADfirst| |ps|)
                                        |PSETCAT-;rewriteIdealWithHeadRemainder;LSL;25|)
                                       (LETT |ps| (CDR |ps|)
                                        |PSETCAT-;rewriteIdealWithHeadRemainder;LSL;25|)
                                       (LETT |p|
                                        (QCAR
                                         (SPADCALL |p| |cs|
                                          (|getShellEntry| $ 78)))
                                        |PSETCAT-;rewriteIdealWithHeadRemainder;LSL;25|)
                                       (EXIT
                                        (COND
                                          ((NULL
                                            (SPADCALL |p|
                                             (|getShellEntry| $ 43)))
                                           (COND
                                             ((SPADCALL |p|
                                               (|getShellEntry| $ 24))
                                              (SEQ
                                               (LETT |ps| NIL
                                                |PSETCAT-;rewriteIdealWithHeadRemainder;LSL;25|)
                                               (EXIT
                                                (LETT |rs|
                                                 (LIST
                                                  (|spadConstant| $ 75))
                                                 |PSETCAT-;rewriteIdealWithHeadRemainder;LSL;25|))))
                                             ('T
                                              (SEQ
                                               (SPADCALL |p|
                                                (|getShellEntry| $ 85))
                                               (EXIT
                                                (LETT |rs|
                                                 (CONS |p| |rs|)
                                                 |PSETCAT-;rewriteIdealWithHeadRemainder;LSL;25|)))))))))
                                      NIL (GO G190) G191 (EXIT NIL))
                                 (EXIT (SPADCALL |rs|
                                        (|getShellEntry| $ 86)))))))))))))) 

(DEFUN |PSETCAT-;rewriteIdealWithRemainder;LSL;26| (|ps| |cs| $)
  (PROG (|p| |rs|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |cs| (|getShellEntry| $ 82)) |ps|)
             ((SPADCALL |cs| (|getShellEntry| $ 83))
              (LIST (|spadConstant| $ 84)))
             ('T
              (SEQ (LETT |ps|
                         (SPADCALL (ELT $ 43) |ps|
                             (|getShellEntry| $ 26))
                         |PSETCAT-;rewriteIdealWithRemainder;LSL;26|)
                   (EXIT (COND
                           ((NULL |ps|) |ps|)
                           ((SPADCALL (ELT $ 24) |ps|
                                (|getShellEntry| $ 44))
                            (LIST (|spadConstant| $ 75)))
                           ('T
                            (SEQ (LETT |rs| NIL
                                       |PSETCAT-;rewriteIdealWithRemainder;LSL;26|)
                                 (SEQ G190
                                      (COND
                                        ((NULL
                                          (SPADCALL (NULL |ps|)
                                           (|getShellEntry| $ 29)))
                                         (GO G191)))
                                      (SEQ
                                       (LETT |p| (|SPADfirst| |ps|)
                                        |PSETCAT-;rewriteIdealWithRemainder;LSL;26|)
                                       (LETT |ps| (CDR |ps|)
                                        |PSETCAT-;rewriteIdealWithRemainder;LSL;26|)
                                       (LETT |p|
                                        (QVELT
                                         (SPADCALL |p| |cs|
                                          (|getShellEntry| $ 88))
                                         1)
                                        |PSETCAT-;rewriteIdealWithRemainder;LSL;26|)
                                       (EXIT
                                        (COND
                                          ((NULL
                                            (SPADCALL |p|
                                             (|getShellEntry| $ 43)))
                                           (COND
                                             ((SPADCALL |p|
                                               (|getShellEntry| $ 24))
                                              (SEQ
                                               (LETT |ps| NIL
                                                |PSETCAT-;rewriteIdealWithRemainder;LSL;26|)
                                               (EXIT
                                                (LETT |rs|
                                                 (LIST
                                                  (|spadConstant| $ 75))
                                                 |PSETCAT-;rewriteIdealWithRemainder;LSL;26|))))
                                             ('T
                                              (LETT |rs|
                                               (CONS
                                                (SPADCALL |p|
                                                 (|getShellEntry| $ 89))
                                                |rs|)
                                               |PSETCAT-;rewriteIdealWithRemainder;LSL;26|)))))))
                                      NIL (GO G190) G191 (EXIT NIL))
                                 (EXIT (SPADCALL |rs|
                                        (|getShellEntry| $ 86)))))))))))))) 

(DEFUN |PolynomialSetCategory&| (|#1| |#2| |#3| |#4| |#5|)
  (PROG (|dv$1| |dv$2| |dv$3| |dv$4| |dv$5| |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT |dv$1| (|devaluate| |#1|)
              . #0=(|PolynomialSetCategory&|))
        (LETT |dv$2| (|devaluate| |#2|) . #0#)
        (LETT |dv$3| (|devaluate| |#3|) . #0#)
        (LETT |dv$4| (|devaluate| |#4|) . #0#)
        (LETT |dv$5| (|devaluate| |#5|) . #0#)
        (LETT |dv$|
              (LIST '|PolynomialSetCategory&| |dv$1| |dv$2| |dv$3|
                    |dv$4| |dv$5|) . #0#)
        (LETT $ (|newShell| 91) . #0#)
        (|setShellEntry| $ 0 |dv$|)
        (|setShellEntry| $ 3
            (LETT |pv$|
                  (|buildPredVector| 0 0
                      (LIST (|HasCategory| |#2| '(|IntegralDomain|)))) . #0#))
        (|stuffDomainSlots| $)
        (|setShellEntry| $ 6 |#1|)
        (|setShellEntry| $ 7 |#2|)
        (|setShellEntry| $ 8 |#3|)
        (|setShellEntry| $ 9 |#4|)
        (|setShellEntry| $ 10 |#5|)
        (COND
          ((|testBitVector| |pv$| 1)
           (PROGN
             (|setShellEntry| $ 49
                 (CONS (|dispatchFunction|
                           |PSETCAT-;roughUnitIdeal?;SB;16|)
                       $))
             (|setShellEntry| $ 53
                 (CONS (|dispatchFunction| |PSETCAT-;roughBase?;SB;18|)
                       $))
             (|setShellEntry| $ 55
                 (CONS (|dispatchFunction|
                           |PSETCAT-;roughSubIdeal?;2SB;19|)
                       $))
             (|setShellEntry| $ 58
                 (CONS (|dispatchFunction|
                           |PSETCAT-;roughEqualIdeals?;2SB;20|)
                       $)))))
        (COND
          ((|HasCategory| |#2| '(|GcdDomain|))
           (COND
             ((|HasCategory| |#4| '(|ConvertibleTo| (|Symbol|)))
              (PROGN
                (|setShellEntry| $ 73
                    (CONS (|dispatchFunction|
                              |PSETCAT-;headRemainder;PSR;22|)
                          $))
                (|setShellEntry| $ 81
                    (CONS (|dispatchFunction|
                              |PSETCAT-;remainder;PSR;24|)
                          $))
                (|setShellEntry| $ 87
                    (CONS (|dispatchFunction|
                              |PSETCAT-;rewriteIdealWithHeadRemainder;LSL;25|)
                          $))
                (|setShellEntry| $ 90
                    (CONS (|dispatchFunction|
                              |PSETCAT-;rewriteIdealWithRemainder;LSL;26|)
                          $)))))))
        $)))) 

(MAKEPROP '|PolynomialSetCategory&| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|local| |#3|) (|local| |#4|) (|local| |#5|) (|List| 10)
             (0 . |members|) (|List| 9) (5 . |variables|) (|Boolean|)
             (10 . <) (|List| $) (16 . |concat|)
             (21 . |removeDuplicates|) (|Mapping| 15 9 9) (26 . |sort|)
             (32 . |mvar|) |PSETCAT-;variables;SL;4| (37 . |ground?|)
             (|Mapping| 15 10) (42 . |remove|)
             |PSETCAT-;mainVariables;SL;5| (48 . =) (54 . |not|)
             |PSETCAT-;mainVariable?;VarSetSB;6| (59 . |construct|)
             |PSETCAT-;collectUnder;SVarSetS;7|
             |PSETCAT-;collectUpper;SVarSetS;8|
             |PSETCAT-;collect;SVarSetS;9|
             (|Record| (|:| |under| $) (|:| |floor| $) (|:| |upper| $))
             |PSETCAT-;sort;SVarSetR;10| (|Set| 10) (64 . |brace|)
             (69 . =) |PSETCAT-;=;2SB;11| (75 . |degree|) (80 . <)
             (86 . |zero?|) (91 . |any?|) (|Mapping| 15 10 10)
             (97 . |sort|) |PSETCAT-;triangular?;SB;14|
             |PSETCAT-;trivialIdeal?;SB;15| (103 . |roughUnitIdeal?|)
             (108 . |sup|) (114 . +) (120 . =) (126 . |roughBase?|)
             (131 . |rewriteIdealWithRemainder|)
             (137 . |roughSubIdeal?|) (143 . =)
             (149 . |roughSubIdeal?|) (155 . |roughEqualIdeals?|)
             (161 . |quo|) (|Union| $ '"failed") (167 . |exquo|)
             (173 . |One|) (177 . |reductum|) (182 . |subtractIfCan|)
             (188 . |leadingCoefficient|) (193 . |gcd|) (199 . *)
             (205 . |monomial|) (211 . *) (217 . -) (223 . *)
             (|Record| (|:| |num| 10) (|:| |den| 7))
             (229 . |headRemainder|) (235 . |gcd|) (241 . |One|)
             (245 . =) (251 . |exactQuotient!|) (257 . |headRemainder|)
             (263 . +)
             (|Record| (|:| |rnum| 7) (|:| |polnum| 10) (|:| |den| 7))
             (269 . |remainder|) (275 . |trivialIdeal?|)
             (280 . |roughUnitIdeal?|) (285 . |Zero|)
             (289 . |primitivePart!|) (294 . |removeDuplicates|)
             (299 . |rewriteIdealWithHeadRemainder|)
             (305 . |remainder|) (311 . |unitCanonical|)
             (316 . |rewriteIdealWithRemainder|))
          '#(|variables| 322 |trivialIdeal?| 327 |triangular?| 332
             |sort| 337 |roughUnitIdeal?| 343 |roughSubIdeal?| 348
             |roughEqualIdeals?| 354 |roughBase?| 360
             |rewriteIdealWithRemainder| 365
             |rewriteIdealWithHeadRemainder| 371 |remainder| 377
             |mainVariables| 383 |mainVariable?| 388 |headRemainder|
             394 |collectUpper| 400 |collectUnder| 406 |collect| 412 =
             418)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 90
                                '(1 6 11 0 12 1 10 13 0 14 2 9 15 0 0
                                  16 1 13 0 17 18 1 13 0 0 19 2 13 0 20
                                  0 21 1 10 9 0 22 1 10 15 0 24 2 11 0
                                  25 0 26 2 9 15 0 0 28 1 15 0 0 29 1 6
                                  0 11 31 1 37 0 11 38 2 37 15 0 0 39 1
                                  10 8 0 41 2 8 15 0 0 42 1 10 15 0 43
                                  2 11 15 25 0 44 2 11 0 45 0 46 1 0 15
                                  0 49 2 8 0 0 0 50 2 8 0 0 0 51 2 8 15
                                  0 0 52 1 0 15 0 53 2 6 11 11 0 54 2 0
                                  15 0 0 55 2 6 15 0 0 56 2 6 15 0 0 57
                                  2 0 15 0 0 58 2 7 0 0 0 59 2 7 60 0 0
                                  61 0 7 0 62 1 10 0 0 63 2 8 60 0 0 64
                                  1 10 7 0 65 2 7 0 0 0 66 2 10 0 7 0
                                  67 2 10 0 7 8 68 2 10 0 0 0 69 2 10 0
                                  0 0 70 2 7 0 0 0 71 2 0 72 10 0 73 2
                                  10 7 7 0 74 0 10 0 75 2 7 15 0 0 76 2
                                  10 0 0 7 77 2 6 72 10 0 78 2 10 0 0 0
                                  79 2 0 80 10 0 81 1 6 15 0 82 1 6 15
                                  0 83 0 10 0 84 1 10 0 0 85 1 11 0 0
                                  86 2 0 11 11 0 87 2 6 80 10 0 88 1 10
                                  0 0 89 2 0 11 11 0 90 1 0 13 0 23 1 0
                                  15 0 48 1 0 15 0 47 2 0 35 0 9 36 1 0
                                  15 0 49 2 0 15 0 0 55 2 0 15 0 0 58 1
                                  0 15 0 53 2 0 11 11 0 90 2 0 11 11 0
                                  87 2 0 80 10 0 81 1 0 13 0 27 2 0 15
                                  9 0 30 2 0 72 10 0 73 2 0 0 0 9 33 2
                                  0 0 0 9 32 2 0 0 0 9 34 2 0 15 0 0
                                  40)))))
          '|lookupComplete|))