
(/VERSIONCHECK 2) 

(PUT '|SREGSET;rep| '|SPADreplace| '(XLAM (|s|) |s|)) 

(DEFUN |SREGSET;rep| (|s| $) |s|) 

(PUT '|SREGSET;per| '|SPADreplace| '(XLAM (|l|) |l|)) 

(DEFUN |SREGSET;per| (|l| $) |l|) 

(DEFUN |SREGSET;copy;2$;3| (|ts| $)
  (|SREGSET;per| (SPADCALL (|SREGSET;rep| |ts| $) (QREFELT $ 11)) $)) 

(DEFUN |SREGSET;empty;$;4| ($) (|SREGSET;per| NIL $)) 

(DEFUN |SREGSET;empty?;$B;5| (|ts| $) (NULL (|SREGSET;rep| |ts| $))) 

(DEFUN |SREGSET;parts;$L;6| (|ts| $) (|SREGSET;rep| |ts| $)) 

(DEFUN |SREGSET;members;$L;7| (|ts| $) (|SREGSET;rep| |ts| $)) 

(DEFUN |SREGSET;map;M2$;8| (|f| |ts| $)
  (SPADCALL (SPADCALL |f| (|SREGSET;rep| |ts| $) (QREFELT $ 19))
            (QREFELT $ 20))) 

(DEFUN |SREGSET;map!;M2$;9| (|f| |ts| $)
  (SPADCALL (SPADCALL |f| (|SREGSET;rep| |ts| $) (QREFELT $ 22))
            (QREFELT $ 20))) 

(DEFUN |SREGSET;member?;P$B;10| (|p| |ts| $)
  (SPADCALL |p| (|SREGSET;rep| |ts| $) (QREFELT $ 24))) 

(PUT '|SREGSET;roughUnitIdeal?;$B;11| '|SPADreplace| '(XLAM (|ts|) 'NIL)) 

(DEFUN |SREGSET;roughUnitIdeal?;$B;11| (|ts| $) 'NIL) 

(DEFUN |SREGSET;coerce;$Of;12| (|ts| $)
  (PROG (#1=#:G725 |p| #2=#:G724 |lp|)
    (RETURN
     (SEQ
      (LETT |lp| (REVERSE (|SREGSET;rep| |ts| $))
            . #3=(|SREGSET;coerce;$Of;12|))
      (EXIT
       (SPADCALL
        (PROGN
         (LETT #2# NIL . #3#)
         (SEQ (LETT |p| NIL . #3#) (LETT #1# |lp| . #3#) G190
              (COND
               ((OR (ATOM #1#) (PROGN (LETT |p| (CAR #1#) . #3#) NIL))
                (GO G191)))
              (SEQ
               (EXIT
                (LETT #2# (CONS (SPADCALL |p| (QREFELT $ 28)) #2#) . #3#)))
              (LETT #1# (CDR #1#) . #3#) (GO G190) G191
              (EXIT (NREVERSE0 #2#))))
        (QREFELT $ 30))))))) 

(DEFUN |SREGSET;mvar;$V;13| (|ts| $)
  (COND ((SPADCALL |ts| (QREFELT $ 15)) (|error| "mvar$SREGSET: #1 is empty"))
        ('T (SPADCALL (|SPADfirst| (|SREGSET;rep| |ts| $)) (QREFELT $ 32))))) 

(DEFUN |SREGSET;first;$U;14| (|ts| $)
  (COND ((SPADCALL |ts| (QREFELT $ 15)) (CONS 1 "failed"))
        ('T (CONS 0 (|SPADfirst| (|SREGSET;rep| |ts| $)))))) 

(DEFUN |SREGSET;last;$U;15| (|ts| $)
  (COND ((SPADCALL |ts| (QREFELT $ 15)) (CONS 1 "failed"))
        ('T (CONS 0 (SPADCALL (|SREGSET;rep| |ts| $) (QREFELT $ 36)))))) 

(DEFUN |SREGSET;rest;$U;16| (|ts| $)
  (COND ((SPADCALL |ts| (QREFELT $ 15)) (CONS 1 "failed"))
        ('T (CONS 0 (|SREGSET;per| (CDR (|SREGSET;rep| |ts| $)) $))))) 

(DEFUN |SREGSET;coerce;$L;17| (|ts| $) (|SREGSET;rep| |ts| $)) 

(DEFUN |SREGSET;collectUpper;$V$;18| (|ts| |v| $)
  (PROG (|lp| |newlp|)
    (RETURN
     (SEQ
      (COND ((SPADCALL |ts| (QREFELT $ 15)) |ts|)
            ('T
             (SEQ
              (LETT |lp| (|SREGSET;rep| |ts| $)
                    . #1=(|SREGSET;collectUpper;$V$;18|))
              (LETT |newlp| NIL . #1#)
              (SEQ G190
                   (COND
                    ((NULL
                      (COND ((NULL |lp|) 'NIL)
                            ('T
                             (SPADCALL |v|
                                       (SPADCALL (|SPADfirst| |lp|)
                                                 (QREFELT $ 32))
                                       (QREFELT $ 41)))))
                     (GO G191)))
                   (SEQ (LETT |newlp| (CONS (|SPADfirst| |lp|) |newlp|) . #1#)
                        (EXIT (LETT |lp| (CDR |lp|) . #1#)))
                   NIL (GO G190) G191 (EXIT NIL))
              (EXIT (|SREGSET;per| (REVERSE |newlp|) $))))))))) 

(DEFUN |SREGSET;collectUnder;$V$;19| (|ts| |v| $)
  (PROG (|lp|)
    (RETURN
     (SEQ
      (COND ((SPADCALL |ts| (QREFELT $ 15)) |ts|)
            ('T
             (SEQ
              (LETT |lp| (|SREGSET;rep| |ts| $)
                    . #1=(|SREGSET;collectUnder;$V$;19|))
              (SEQ G190
                   (COND
                    ((NULL
                      (COND
                       ((OR (NULL |lp|)
                            (SPADCALL
                             (SPADCALL (|SPADfirst| |lp|) (QREFELT $ 32)) |v|
                             (QREFELT $ 41)))
                        'NIL)
                       ('T 'T)))
                     (GO G191)))
                   (SEQ (EXIT (LETT |lp| (CDR |lp|) . #1#))) NIL (GO G190) G191
                   (EXIT NIL))
              (EXIT (|SREGSET;per| |lp| $))))))))) 

(DEFUN |SREGSET;construct;L$;20| (|lp| $)
  (PROG (|ts| |eif|)
    (RETURN
     (SEQ (LETT |ts| (|SREGSET;per| NIL $) . #1=(|SREGSET;construct;L$;20|))
          (EXIT
           (COND ((NULL |lp|) |ts|)
                 ('T
                  (SEQ
                   (LETT |lp| (SPADCALL (ELT $ 44) |lp| (QREFELT $ 46)) . #1#)
                   (SEQ G190
                        (COND
                         ((NULL (COND ((NULL |lp|) 'NIL) ('T 'T))) (GO G191)))
                        (SEQ
                         (LETT |eif|
                               (SPADCALL |ts| (|SPADfirst| |lp|)
                                         (QREFELT $ 47))
                               . #1#)
                         (EXIT
                          (COND
                           ((QEQCAR |eif| 0)
                            (SEQ (LETT |ts| (QCDR |eif|) . #1#)
                                 (EXIT (LETT |lp| (CDR |lp|) . #1#))))
                           ('T
                            (|error|
                             "in construct : List P -> %  from SREGSET : bad #1")))))
                        NIL (GO G190) G191 (EXIT NIL))
                   (EXIT |ts|))))))))) 

(DEFUN |SREGSET;extendIfCan;$PU;21| (|ts| |p| $)
  (PROG (|lts|)
    (RETURN
     (SEQ
      (COND ((SPADCALL |p| (QREFELT $ 48)) (CONS 1 "failed"))
            ((SPADCALL |ts| (QREFELT $ 15))
             (SEQ
              (LETT |p| (SPADCALL (SPADCALL |p| (QREFELT $ 49)) (QREFELT $ 50))
                    . #1=(|SREGSET;extendIfCan;$PU;21|))
              (EXIT (CONS 0 (|SREGSET;per| (LIST |p|) $)))))
            ((NULL
              (SPADCALL (SPADCALL |ts| (QREFELT $ 33))
                        (SPADCALL |p| (QREFELT $ 32)) (QREFELT $ 41)))
             (CONS 1 "failed"))
            ('T
             (COND
              ((SPADCALL (SPADCALL |p| (QREFELT $ 51)) |ts| (QREFELT $ 52))
               (SEQ (LETT |lts| (SPADCALL |p| |ts| (QREFELT $ 53)) . #1#)
                    (COND
                     ((NULL (EQL (SPADCALL |lts| (QREFELT $ 56)) 1))
                      (EXIT (CONS 1 "failed"))))
                    (EXIT (CONS 0 (SPADCALL |lts| (QREFELT $ 58))))))
              ('T (CONS 1 "failed"))))))))) 

(DEFUN |SREGSET;removeZero;P$P;22| (|p| |ts| $)
  (PROG (|q| #1=#:G796 #2=#:G787 |tsv-| |v|)
    (RETURN
     (SEQ
      (EXIT
       (COND
        ((OR (SPADCALL |p| (QREFELT $ 48)) (SPADCALL |ts| (QREFELT $ 15))) |p|)
        ('T
         (SEQ
          (LETT |v| (SPADCALL |p| (QREFELT $ 32))
                . #3=(|SREGSET;removeZero;P$P;22|))
          (LETT |tsv-| (SPADCALL |ts| |v| (QREFELT $ 43)) . #3#)
          (COND
           ((SPADCALL |v| |ts| (QREFELT $ 59))
            (SEQ
             (LETT |q|
                   (SPADCALL |p|
                             (PROG2
                                 (LETT #2# (SPADCALL |ts| |v| (QREFELT $ 60))
                                       . #3#)
                                 (QCDR #2#)
                               (|check-union| (QEQCAR #2# 0) (QREFELT $ 9)
                                              #2#))
                             (QREFELT $ 61))
                   . #3#)
             (EXIT
              (COND
               ((SPADCALL |q| (QREFELT $ 62))
                (PROGN (LETT #1# |q| . #3#) (GO #1#)))
               ((SPADCALL (SPADCALL |q| |tsv-| (QREFELT $ 63)) (QREFELT $ 62))
                (PROGN (LETT #1# (|spadConstant| $ 64) . #3#) (GO #1#))))))))
          (EXIT
           (COND ((SPADCALL |tsv-| (QREFELT $ 15)) |p|)
                 ('T
                  (SEQ (LETT |q| (|spadConstant| $ 64) . #3#)
                       (SEQ G190
                            (COND
                             ((NULL
                               (SPADCALL (SPADCALL |p| |v| (QREFELT $ 65))
                                         (QREFELT $ 67)))
                              (GO G191)))
                            (SEQ
                             (LETT |q|
                                   (SPADCALL
                                    (SPADCALL
                                     (SPADCALL (SPADCALL |p| (QREFELT $ 51))
                                               |tsv-| (QREFELT $ 63))
                                     (SPADCALL |p| (QREFELT $ 68))
                                     (QREFELT $ 69))
                                    |q| (QREFELT $ 70))
                                   . #3#)
                             (EXIT
                              (LETT |p| (SPADCALL |p| (QREFELT $ 71)) . #3#)))
                            NIL (GO G190) G191 (EXIT NIL))
                       (EXIT
                        (SPADCALL |q| (SPADCALL |p| |tsv-| (QREFELT $ 63))
                                  (QREFELT $ 70)))))))))))
      #1# (EXIT #1#))))) 

(DEFUN |SREGSET;internalAugment;P2$;23| (|p| |ts| $)
  (COND
   ((SPADCALL |p| (QREFELT $ 48))
    (|error| "in internalAugment$SREGSET: ground? #1"))
   ('T
    (SPADCALL (SPADCALL |p| |ts| 'NIL 'NIL 'NIL 'NIL 'NIL (QREFELT $ 72))
              (QREFELT $ 58))))) 

(DEFUN |SREGSET;internalAugment;L2$;24| (|lp| |ts| $)
  (COND ((NULL |lp|) |ts|)
        ('T
         (SPADCALL (CDR |lp|) (SPADCALL (|SPADfirst| |lp|) |ts| (QREFELT $ 73))
                   (QREFELT $ 74))))) 

(DEFUN |SREGSET;internalAugment;P$5BL;25|
       (|p| |ts| |rem?| |red?| |prim?| |sqfr?| |extend?| $)
  (PROG (#1=#:G819 |us| #2=#:G818 |lts| |sfp| #3=#:G817 |pwt| |lpwt| #4=#:G816
         |f| |lsfp| |tsv+| |tsv-| |v|)
    (RETURN
     (SEQ
      (LETT |v| (SPADCALL |p| (QREFELT $ 32))
            . #5=(|SREGSET;internalAugment;P$5BL;25|))
      (LETT |tsv-| (SPADCALL |ts| |v| (QREFELT $ 43)) . #5#)
      (LETT |tsv+| (SPADCALL |ts| |v| (QREFELT $ 42)) . #5#)
      (COND
       (|rem?|
        (LETT |p| (QVELT (SPADCALL |p| |tsv-| (QREFELT $ 76)) 1) . #5#)))
      (COND (|red?| (LETT |p| (SPADCALL |p| |tsv-| (QREFELT $ 63)) . #5#)))
      (COND (|prim?| (LETT |p| (SPADCALL |p| (QREFELT $ 77)) . #5#)))
      (COND
       (|sqfr?|
        (SEQ (LETT |lts| NIL . #5#)
             (LETT |lsfp| (SPADCALL |p| (QREFELT $ 79)) . #5#)
             (EXIT
              (SEQ (LETT |f| NIL . #5#) (LETT #4# |lsfp| . #5#) G190
                   (COND
                    ((OR (ATOM #4#) (PROGN (LETT |f| (CAR #4#) . #5#) NIL))
                     #6=(GO G191)))
                   (SEQ
                    (EXIT
                     (COND
                      ((OR (SPADCALL |f| (QREFELT $ 48))
                           (SPADCALL (SPADCALL |f| (QREFELT $ 32)) |v|
                                     (QREFELT $ 41)))
                       "leave")
                      ('T
                       (SEQ
                        (LETT |lpwt| (SPADCALL |f| |tsv-| (QREFELT $ 82))
                              . #5#)
                        (EXIT
                         (SEQ (LETT |pwt| NIL . #5#) (LETT #3# |lpwt| . #5#)
                              G190
                              (COND
                               ((OR (ATOM #3#)
                                    (PROGN (LETT |pwt| (CAR #3#) . #5#) NIL))
                                #6#))
                              (SEQ (LETT |sfp| (QCAR |pwt|) . #5#)
                                   (LETT |us| (QCDR |pwt|) . #5#)
                                   (EXIT
                                    (LETT |lts|
                                          (SPADCALL
                                           (|SREGSET;per|
                                            (CONS (QCAR |pwt|)
                                                  (|SREGSET;rep| (QCDR |pwt|)
                                                   $))
                                            $)
                                           |lts| (QREFELT $ 83))
                                          . #5#)))
                              (LETT #3# (CDR #3#) . #5#) #7=(GO G190) G191
                              (EXIT NIL))))))))
                   (LETT #4# (CDR #4#) . #5#) #7# G191 (EXIT NIL)))))
       (#8='T
        (LETT |lts|
              (LIST (|SREGSET;per| (CONS |p| (|SREGSET;rep| |tsv-| $)) $))
              . #5#)))
      (EXIT
       (COND
        (|extend?|
         (SPADCALL (SPADCALL |tsv+| (QREFELT $ 17)) |lts| (QREFELT $ 84)))
        (#8#
         (PROGN
          (LETT #2# NIL . #5#)
          (SEQ (LETT |us| NIL . #5#) (LETT #1# |lts| . #5#) G190
               (COND
                ((OR (ATOM #1#) (PROGN (LETT |us| (CAR #1#) . #5#) NIL)) #6#))
               (SEQ
                (EXIT
                 (LETT #2#
                       (CONS
                        (|SREGSET;per|
                         (SPADCALL (|SREGSET;rep| |tsv+| $)
                                   (|SREGSET;rep| |us| $) (QREFELT $ 85))
                         $)
                        #2#)
                       . #5#)))
               (LETT #1# (CDR #1#) . #5#) #7# G191
               (EXIT (NREVERSE0 #2#))))))))))) 

(DEFUN |SREGSET;augment;P$L;26| (|p| |ts| $)
  (COND
   ((SPADCALL |p| (QREFELT $ 48)) (|error| "in augment$SREGSET: ground? #1"))
   ((SPADCALL (SPADCALL |p| (QREFELT $ 32)) |ts| (QREFELT $ 59))
    (|error| "in augment$SREGSET: bad #1"))
   ('T (SPADCALL |p| |ts| 'T 'T 'T 'T 'T (QREFELT $ 72))))) 

(DEFUN |SREGSET;extend;P$L;27| (|p| |ts| $)
  (PROG (|lts| #1=#:G828 |us| |split| |v|)
    (RETURN
     (SEQ
      (COND
       ((SPADCALL |p| (QREFELT $ 48))
        (|error| "in extend$SREGSET: ground? #1"))
       ('T
        (SEQ
         (LETT |v| (SPADCALL |p| (QREFELT $ 32))
               . #2=(|SREGSET;extend;P$L;27|))
         (COND
          ((NULL
            (SPADCALL (SPADCALL |ts| (QREFELT $ 33))
                      (SPADCALL |p| (QREFELT $ 32)) (QREFELT $ 41)))
           (EXIT (|error| "in extend$SREGSET: bad #1"))))
         (LETT |split|
               (SPADCALL (SPADCALL |p| (QREFELT $ 51)) |ts| (QREFELT $ 86))
               . #2#)
         (LETT |lts| NIL . #2#)
         (SEQ (LETT |us| NIL . #2#) (LETT #1# |split| . #2#) G190
              (COND
               ((OR (ATOM #1#) (PROGN (LETT |us| (CAR #1#) . #2#) NIL))
                (GO G191)))
              (SEQ
               (EXIT
                (LETT |lts|
                      (SPADCALL (SPADCALL |p| |us| (QREFELT $ 53)) |lts|
                                (QREFELT $ 87))
                      . #2#)))
              (LETT #1# (CDR #1#) . #2#) (GO G190) G191 (EXIT NIL))
         (EXIT |lts|)))))))) 

(DEFUN |SREGSET;invertible?;P$B;28| (|p| |ts| $)
  (SPADCALL |p| |ts| (QREFELT $ 90))) 

(DEFUN |SREGSET;invertible?;P$L;29| (|p| |ts| $)
  (SPADCALL |p| |ts| (QREFELT $ 93))) 

(DEFUN |SREGSET;invertibleSet;P$L;30| (|p| |ts| $)
  (SPADCALL |p| |ts| (QREFELT $ 97))) 

(DEFUN |SREGSET;lastSubResultant;2P$L;31| (|p1| |p2| |ts| $)
  (SPADCALL |p1| |p2| |ts| (QREFELT $ 100))) 

(DEFUN |SREGSET;squareFreePart;P$L;32| (|p| |ts| $)
  (SPADCALL |p| |ts| (QREFELT $ 102))) 

(DEFUN |SREGSET;intersect;P$L;33| (|p| |ts| $)
  (SPADCALL (LIST |p|) (LIST |ts|) 'NIL 'NIL (QREFELT $ 104))) 

(DEFUN |SREGSET;intersect;L2L;34| (|lp| |lts| $)
  (SPADCALL |lp| |lts| 'NIL 'NIL (QREFELT $ 104))) 

(DEFUN |SREGSET;zeroSetSplit;LL;35| (|lp| $)
  (SPADCALL |lp| 'T 'NIL (QREFELT $ 107))) 

(DEFUN |SREGSET;zeroSetSplit;LBL;36| (|lp| |clos?| $)
  (SPADCALL |lp| |clos?| 'NIL (QREFELT $ 107))) 

(DEFUN |SREGSET;zeroSetSplit;L2BL;37| (|lp| |clos?| |info?| $)
  (SPADCALL |lp| 'T |clos?| |info?| 'T (QREFELT $ 110))) 

(DEFUN |SREGSET;zeroSetSplit;L4BL;38| (|lp| |hash?| |clos?| |info?| |prep?| $)
  (PROG (|lts| |dom3| |dom2| |dom1| |#G94| |#G93| |#G92| |#G91| |#G90| |#G89|
         |s3| |s2| |s1| |#G85| |#G84| |#G83| |#G82| |#G81| |#G80| |e|)
    (RETURN
     (SEQ
      (COND
       (|hash?|
        (SEQ
         (LETT |e| (MAKE-FULL-CVEC 0) . #1=(|SREGSET;zeroSetSplit;L4BL;38|))
         (COND
          (|info?|
           (PROGN
            (LETT |#G80| "w" . #1#)
            (LETT |#G81| "g" . #1#)
            (LETT |#G82| "i" . #1#)
            (LETT |s1| |#G80| . #1#)
            (LETT |s2| |#G81| . #1#)
            (LETT |s3| |#G82| . #1#)))
          (#2='T
           (PROGN
            (LETT |#G83| |e| . #1#)
            (LETT |#G84| |e| . #1#)
            (LETT |#G85| |e| . #1#)
            (LETT |s1| |#G83| . #1#)
            (LETT |s2| |#G84| . #1#)
            (LETT |s3| |#G85| . #1#))))
         (COND
          (|info?|
           (PROGN
            (LETT |#G89| "QCMPACK" . #1#)
            (LETT |#G90| "REGSETGCD: Gcd" . #1#)
            (LETT |#G91| "REGSETGCD: Inv Set" . #1#)
            (LETT |dom1| |#G89| . #1#)
            (LETT |dom2| |#G90| . #1#)
            (LETT |dom3| |#G91| . #1#)))
          (#2#
           (PROGN
            (LETT |#G92| |e| . #1#)
            (LETT |#G93| |e| . #1#)
            (LETT |#G94| |e| . #1#)
            (LETT |dom1| |#G92| . #1#)
            (LETT |dom2| |#G93| . #1#)
            (LETT |dom3| |#G94| . #1#))))
         (SPADCALL |s1| "W" |dom1| (QREFELT $ 114))
         (SPADCALL |s2| "G" |dom2| (QREFELT $ 115))
         (EXIT (SPADCALL |s3| "I" |dom3| (QREFELT $ 116))))))
      (LETT |lts| (SPADCALL |lp| |clos?| |info?| |prep?| (QREFELT $ 117))
            . #1#)
      (COND
       (|hash?|
        (SEQ (SPADCALL (QREFELT $ 118)) (SPADCALL (QREFELT $ 119))
             (EXIT (SPADCALL (QREFELT $ 120))))))
      (EXIT |lts|))))) 

(DEFUN |SREGSET;internalZeroSetSplit;L3BL;39| (|lp| |clos?| |info?| |prep?| $)
  (PROG (|lts| #1=#:G864 |p| |ts| |pp|)
    (RETURN
     (SEQ
      (COND
       (|prep?|
        (SEQ
         (LETT |pp| (SPADCALL |lp| |clos?| |info?| (QREFELT $ 122))
               . #2=(|SREGSET;internalZeroSetSplit;L3BL;39|))
         (LETT |lp| (QCAR |pp|) . #2#) (EXIT (LETT |lts| (QCDR |pp|) . #2#))))
       (#3='T
        (SEQ (LETT |ts| (SPADCALL NIL (QREFELT $ 20)) . #2#)
             (EXIT (LETT |lts| (LIST |ts|) . #2#)))))
      (LETT |lp| (SPADCALL (ELT $ 62) |lp| (QREFELT $ 124)) . #2#)
      (EXIT
       (COND ((SPADCALL (ELT $ 48) |lp| (QREFELT $ 125)) NIL)
             ((OR (NULL |lp|) (SPADCALL |lts| (QREFELT $ 126))) |lts|)
             ('T
              (SEQ (LETT |lp| (SPADCALL (ELT $ 44) |lp| (QREFELT $ 46)) . #2#)
                   (EXIT
                    (COND
                     (|clos?|
                      (SPADCALL |lp| |lts| |clos?| |info?| (QREFELT $ 104)))
                     (#3#
                      (SEQ
                       (SEQ (LETT |p| NIL . #2#) (LETT #1# |lp| . #2#) G190
                            (COND
                             ((OR (ATOM #1#)
                                  (PROGN (LETT |p| (CAR #1#) . #2#) NIL))
                              (GO G191)))
                            (SEQ
                             (EXIT
                              (LETT |lts|
                                    (SPADCALL (LIST |p|) |lts| |clos?| |info?|
                                              (QREFELT $ 104))
                                    . #2#)))
                            (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                            (EXIT NIL))
                       (EXIT |lts|))))))))))))) 

(DEFUN |SREGSET;largeSystem?| (|lp| $)
  (PROG (|lts|)
    (RETURN
     (SEQ
      (COND ((< 16 (LENGTH |lp|)) 'T) ((< (LENGTH |lp|) 13) 'NIL)
            ('T
             (SEQ (LETT |lts| NIL |SREGSET;largeSystem?|)
                  (EXIT
                   (< 3
                      (- (LENGTH |lp|)
                         (SPADCALL |lp| |lts| (QREFELT $ 127)))))))))))) 

(DEFUN |SREGSET;smallSystem?| (|lp| $) (< (LENGTH |lp|) 5)) 

(DEFUN |SREGSET;mediumSystem?| (|lp| $)
  (PROG (|lts|)
    (RETURN
     (SEQ (LETT |lts| NIL |SREGSET;mediumSystem?|)
          (EXIT
           (< (- (SPADCALL |lp| |lts| (QREFELT $ 127)) (LENGTH |lp|)) 2)))))) 

(DEFUN |SREGSET;lin?| (|p| $)
  (COND
   ((SPADCALL (SPADCALL |p| (QREFELT $ 51)) (QREFELT $ 48))
    (EQL (SPADCALL |p| (QREFELT $ 128)) 1))
   ('T 'NIL))) 

(DEFUN |SREGSET;preprocess;L2BR;44| (|lp| |clos?| |info?| $)
  (PROG (#1=#:G902 |lp2| |lts| #2=#:G915 |p| |lp3| #3=#:G914 |lp4| #4=#:G913
         #5=#:G912 #6=#:G911 #7=#:G910 #8=#:G909 #9=#:G908 #10=#:G907
         #11=#:G906 #12=#:G905 #13=#:G904 |lp1| #14=#:G903 |ts|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |ts| (SPADCALL NIL (QREFELT $ 20))
              . #15=(|SREGSET;preprocess;L2BR;44|))
        (LETT |lts| (LIST |ts|) . #15#)
        (EXIT
         (COND ((NULL |lp|) (CONS |lp| |lts|))
               (#16='T
                (SEQ (LETT |lp1| NIL . #15#) (LETT |lp2| NIL . #15#)
                     (SEQ (LETT |p| NIL . #15#) (LETT #14# |lp| . #15#) G190
                          (COND
                           ((OR (ATOM #14#)
                                (PROGN (LETT |p| (CAR #14#) . #15#) NIL))
                            #17=(GO G191)))
                          (SEQ
                           (EXIT
                            (COND
                             ((SPADCALL (SPADCALL |p| (QREFELT $ 71))
                                        (QREFELT $ 48))
                              (LETT |lp1| (CONS |p| |lp1|) . #15#))
                             ('T (LETT |lp2| (CONS |p| |lp2|) . #15#)))))
                          (LETT #14# (CDR #14#) . #15#) #18=(GO G190) G191
                          (EXIT NIL))
                     (LETT |lts|
                           (SPADCALL |lp1| (LIST |ts|) |clos?| |info?|
                                     (QREFELT $ 104))
                           . #15#)
                     (EXIT
                      (COND
                       ((SPADCALL |lp| (QREFELT $ 129))
                        (COND
                         ((|SREGSET;largeSystem?| |lp| $)
                          (PROGN
                           (LETT #1# (CONS |lp2| |lts|) . #15#)
                           (GO #1#)))
                         (#16#
                          (SEQ
                           (COND
                            ((< 7 (LENGTH |lp|))
                             (SEQ
                              (LETT |lp2| (SPADCALL |lp2| (QREFELT $ 130))
                                    . #15#)
                              (LETT |lp2|
                                    (SPADCALL (ELT $ 62) |lp2| (QREFELT $ 124))
                                    . #15#)
                              (EXIT
                               (COND
                                ((SPADCALL (ELT $ 48) |lp2| (QREFELT $ 125))
                                 (PROGN
                                  (LETT #1# (CONS |lp2| |lts|) . #15#)
                                  (GO #1#)))
                                (#16#
                                 (SEQ
                                  (LETT |lp3|
                                        (PROGN
                                         (LETT #13# NIL . #15#)
                                         (SEQ (LETT |p| NIL . #15#)
                                              (LETT #12# |lp2| . #15#) G190
                                              (COND
                                               ((OR (ATOM #12#)
                                                    (PROGN
                                                     (LETT |p| (CAR #12#)
                                                           . #15#)
                                                     NIL))
                                                #17#))
                                              (SEQ
                                               (EXIT
                                                (COND
                                                 ((|SREGSET;lin?| |p| $)
                                                  (LETT #13# (CONS |p| #13#)
                                                        . #15#)))))
                                              (LETT #12# (CDR #12#) . #15#)
                                              #18# G191
                                              (EXIT (NREVERSE0 #13#))))
                                        . #15#)
                                  (LETT |lp4|
                                        (PROGN
                                         (LETT #11# NIL . #15#)
                                         (SEQ (LETT |p| NIL . #15#)
                                              (LETT #10# |lp2| . #15#) G190
                                              (COND
                                               ((OR (ATOM #10#)
                                                    (PROGN
                                                     (LETT |p| (CAR #10#)
                                                           . #15#)
                                                     NIL))
                                                #17#))
                                              (SEQ
                                               (EXIT
                                                (COND
                                                 ((COND
                                                   ((|SREGSET;lin?| |p| $)
                                                    'NIL)
                                                   (#16# 'T))
                                                  (LETT #11# (CONS |p| #11#)
                                                        . #15#)))))
                                              (LETT #10# (CDR #10#) . #15#)
                                              #18# G191
                                              (EXIT (NREVERSE0 #11#))))
                                        . #15#)
                                  (COND
                                   (|clos?|
                                    (LETT |lts|
                                          (SPADCALL |lp4| |lts| |clos?| |info?|
                                                    (QREFELT $ 104))
                                          . #15#))
                                   (#16#
                                    (SEQ
                                     (LETT |lp4|
                                           (SPADCALL (ELT $ 44) |lp4|
                                                     (QREFELT $ 46))
                                           . #15#)
                                     (EXIT
                                      (SEQ (LETT |p| NIL . #15#)
                                           (LETT #9# |lp4| . #15#) G190
                                           (COND
                                            ((OR (ATOM #9#)
                                                 (PROGN
                                                  (LETT |p| (CAR #9#) . #15#)
                                                  NIL))
                                             #17#))
                                           (SEQ
                                            (EXIT
                                             (LETT |lts|
                                                   (SPADCALL (LIST |p|) |lts|
                                                             |clos?| |info?|
                                                             (QREFELT $ 104))
                                                   . #15#)))
                                           (LETT #9# (CDR #9#) . #15#) #18#
                                           G191 (EXIT NIL))))))
                                  (EXIT (LETT |lp2| |lp3| . #15#))))))))
                            (#16#
                             (SEQ
                              (LETT |lp2| (SPADCALL |lp2| (QREFELT $ 130))
                                    . #15#)
                              (LETT |lp2|
                                    (SPADCALL (ELT $ 62) |lp2| (QREFELT $ 124))
                                    . #15#)
                              (EXIT
                               (COND
                                ((SPADCALL (ELT $ 48) |lp2| (QREFELT $ 125))
                                 (PROGN
                                  (LETT #1# (CONS |lp2| |lts|) . #15#)
                                  (GO #1#))))))))
                           (COND
                            (|clos?|
                             (LETT |lts|
                                   (SPADCALL |lp2| |lts| |clos?| |info?|
                                             (QREFELT $ 104))
                                   . #15#))
                            (#16#
                             (SEQ
                              (LETT |lp2|
                                    (SPADCALL (ELT $ 44) |lp2| (QREFELT $ 46))
                                    . #15#)
                              (EXIT
                               (SEQ (LETT |p| NIL . #15#)
                                    (LETT #8# |lp2| . #15#) G190
                                    (COND
                                     ((OR (ATOM #8#)
                                          (PROGN
                                           (LETT |p| (CAR #8#) . #15#)
                                           NIL))
                                      #17#))
                                    (SEQ
                                     (EXIT
                                      (LETT |lts|
                                            (SPADCALL (LIST |p|) |lts| |clos?|
                                                      |info?| (QREFELT $ 104))
                                            . #15#)))
                                    (LETT #8# (CDR #8#) . #15#) #18# G191
                                    (EXIT NIL))))))
                           (LETT |lp2| NIL . #15#)
                           (EXIT
                            (PROGN
                             (LETT #1# (CONS |lp2| |lts|) . #15#)
                             (GO #1#)))))))
                       ((|SREGSET;smallSystem?| |lp| $) (CONS |lp2| |lts|))
                       ((|SREGSET;mediumSystem?| |lp| $)
                        (CONS (SPADCALL |lp2| (QREFELT $ 130)) |lts|))
                       (#16#
                        (SEQ
                         (LETT |lp3|
                               (PROGN
                                (LETT #7# NIL . #15#)
                                (SEQ (LETT |p| NIL . #15#)
                                     (LETT #6# |lp2| . #15#) G190
                                     (COND
                                      ((OR (ATOM #6#)
                                           (PROGN
                                            (LETT |p| (CAR #6#) . #15#)
                                            NIL))
                                       #17#))
                                     (SEQ
                                      (EXIT
                                       (COND
                                        ((|SREGSET;lin?| |p| $)
                                         (LETT #7# (CONS |p| #7#) . #15#)))))
                                     (LETT #6# (CDR #6#) . #15#) #18# G191
                                     (EXIT (NREVERSE0 #7#))))
                               . #15#)
                         (LETT |lp4|
                               (PROGN
                                (LETT #5# NIL . #15#)
                                (SEQ (LETT |p| NIL . #15#)
                                     (LETT #4# |lp2| . #15#) G190
                                     (COND
                                      ((OR (ATOM #4#)
                                           (PROGN
                                            (LETT |p| (CAR #4#) . #15#)
                                            NIL))
                                       #17#))
                                     (SEQ
                                      (EXIT
                                       (COND
                                        ((COND ((|SREGSET;lin?| |p| $) 'NIL)
                                               (#16# 'T))
                                         (LETT #5# (CONS |p| #5#) . #15#)))))
                                     (LETT #4# (CDR #4#) . #15#) #18# G191
                                     (EXIT (NREVERSE0 #5#))))
                               . #15#)
                         (COND
                          (|clos?|
                           (LETT |lts|
                                 (SPADCALL |lp4| |lts| |clos?| |info?|
                                           (QREFELT $ 104))
                                 . #15#))
                          (#16#
                           (SEQ
                            (LETT |lp4|
                                  (SPADCALL (ELT $ 44) |lp4| (QREFELT $ 46))
                                  . #15#)
                            (EXIT
                             (SEQ (LETT |p| NIL . #15#) (LETT #3# |lp4| . #15#)
                                  G190
                                  (COND
                                   ((OR (ATOM #3#)
                                        (PROGN
                                         (LETT |p| (CAR #3#) . #15#)
                                         NIL))
                                    #17#))
                                  (SEQ
                                   (EXIT
                                    (LETT |lts|
                                          (SPADCALL (LIST |p|) |lts| |clos?|
                                                    |info?| (QREFELT $ 104))
                                          . #15#)))
                                  (LETT #3# (CDR #3#) . #15#) #18# G191
                                  (EXIT NIL))))))
                         (COND
                          (|clos?|
                           (LETT |lts|
                                 (SPADCALL |lp3| |lts| |clos?| |info?|
                                           (QREFELT $ 104))
                                 . #15#))
                          (#16#
                           (SEQ
                            (LETT |lp3|
                                  (SPADCALL (ELT $ 44) |lp3| (QREFELT $ 46))
                                  . #15#)
                            (EXIT
                             (SEQ (LETT |p| NIL . #15#) (LETT #2# |lp3| . #15#)
                                  G190
                                  (COND
                                   ((OR (ATOM #2#)
                                        (PROGN
                                         (LETT |p| (CAR #2#) . #15#)
                                         NIL))
                                    #17#))
                                  (SEQ
                                   (EXIT
                                    (LETT |lts|
                                          (SPADCALL (LIST |p|) |lts| |clos?|
                                                    |info?| (QREFELT $ 104))
                                          . #15#)))
                                  (LETT #2# (CDR #2#) . #15#) #18# G191
                                  (EXIT NIL))))))
                         (LETT |lp2| NIL . #15#)
                         (EXIT
                          (PROGN
                           (LETT #1# (CONS |lp2| |lts|) . #15#)
                           (GO #1#)))))))))))))
      #1# (EXIT #1#))))) 

(DEFUN |SquareFreeRegularTriangularSet| (&REST #1=#:G935)
  (PROG ()
    (RETURN
     (PROG (#2=#:G936)
       (RETURN
        (COND
         ((LETT #2#
                (|lassocShiftWithFunction| (|devaluateList| #1#)
                                           (HGET |$ConstructorCache|
                                                 '|SquareFreeRegularTriangularSet|)
                                           '|domainEqualList|)
                . #3=(|SquareFreeRegularTriangularSet|))
          (|CDRwithIncrement| #2#))
         ('T
          (UNWIND-PROTECT
              (PROG1 (APPLY (|function| |SquareFreeRegularTriangularSet;|) #1#)
                (LETT #2# T . #3#))
            (COND
             ((NOT #2#)
              (HREM |$ConstructorCache|
                    '|SquareFreeRegularTriangularSet|))))))))))) 

(DEFUN |SquareFreeRegularTriangularSet;| (|#1| |#2| |#3| |#4|)
  (PROG (#1=#:G934 |pv$| #2=#:G933 $ |dv$| DV$4 DV$3 DV$2 DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #3=(|SquareFreeRegularTriangularSet|))
      (LETT DV$2 (|devaluate| |#2|) . #3#)
      (LETT DV$3 (|devaluate| |#3|) . #3#)
      (LETT DV$4 (|devaluate| |#4|) . #3#)
      (LETT |dv$| (LIST '|SquareFreeRegularTriangularSet| DV$1 DV$2 DV$3 DV$4)
            . #3#)
      (LETT $ (GETREFV 147) . #3#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3
                (LETT |pv$|
                      (|buildPredVector| 0 0
                                         (LIST
                                          (|HasCategory| |#4|
                                                         '(|ConvertibleTo|
                                                           (|InputForm|)))
                                          (LETT #2#
                                                (|HasCategory| |#4|
                                                               '(|SetCategory|))
                                                . #3#)
                                          (AND #2#
                                               (|HasCategory| |#4|
                                                              (LIST '|Evalable|
                                                                    (|devaluate|
                                                                     |#4|))))
                                          (|HasCategory| |#1|
                                                         '(|IntegralDomain|))
                                          (|HasCategory| |#3| '(|Finite|))))
                      . #3#))
      (|haddProp| |$ConstructorCache| '|SquareFreeRegularTriangularSet|
                  (LIST DV$1 DV$2 DV$3 DV$4) (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (QSETREFV $ 7 |#2|)
      (QSETREFV $ 8 |#3|)
      (QSETREFV $ 9 |#4|)
      (AND (|HasCategory| $ '(|shallowlyMutable|)) (|augmentPredVector| $ 32))
      (AND (LETT #1# (|HasCategory| $ '(|finiteAggregate|)) . #3#)
           (|augmentPredVector| $ 64))
      (AND #1# #2# (|augmentPredVector| $ 128))
      $)))) 

(MAKEPROP '|SquareFreeRegularTriangularSet| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
              (|local| |#3|) (|local| |#4|) (|List| 9) (0 . |copy|)
              |SREGSET;copy;2$;3| |SREGSET;empty;$;4| (|Boolean|)
              |SREGSET;empty?;$B;5| |SREGSET;parts;$L;6| |SREGSET;members;$L;7|
              (|Mapping| 9 9) (5 . |map|) |SREGSET;construct;L$;20|
              |SREGSET;map;M2$;8| (11 . |map!|) |SREGSET;map!;M2$;9|
              (17 . |member?|) |SREGSET;member?;P$B;10|
              |SREGSET;roughUnitIdeal?;$B;11| (|OutputForm|) (23 . |coerce|)
              (|List| $) (28 . |brace|) |SREGSET;coerce;$Of;12| (33 . |mvar|)
              |SREGSET;mvar;$V;13| (|Union| 9 '#1="failed")
              |SREGSET;first;$U;14| (38 . |last|) |SREGSET;last;$U;15|
              (|Union| $ '#1#) |SREGSET;rest;$U;16| |SREGSET;coerce;$L;17|
              (43 . <) |SREGSET;collectUpper;$V$;18|
              |SREGSET;collectUnder;$V$;19| (49 . |infRittWu?|)
              (|Mapping| 14 9 9) (55 . |sort|) |SREGSET;extendIfCan;$PU;21|
              (61 . |ground?|) (66 . |primitivePart|) (71 . |squareFreePart|)
              (76 . |init|) |SREGSET;invertible?;P$B;28|
              |SREGSET;augment;P$L;26| (|NonNegativeInteger|) (|List| $$)
              (81 . |#|) (86 . |One|) (90 . |first|) (95 . |algebraic?|)
              (101 . |select|) (107 . |lazyPrem|) (113 . |zero?|)
              |SREGSET;removeZero;P$P;22| (118 . |Zero|) (122 . |degree|)
              (|Integer|) (128 . |positive?|) (133 . |mainMonomial|) (138 . *)
              (144 . +) (150 . |tail|) |SREGSET;internalAugment;P$5BL;25|
              |SREGSET;internalAugment;P2$;23| |SREGSET;internalAugment;L2$;24|
              (|Record| (|:| |rnum| 6) (|:| |polnum| 9) (|:| |den| 6))
              (155 . |remainder|) (161 . |mainPrimitivePart|)
              (|PolynomialSetUtilitiesPackage| 6 7 8 9)
              (166 . |squareFreeFactors|)
              (|Record| (|:| |val| 9) (|:| |tower| $)) (|List| 80)
              |SREGSET;squareFreePart;P$L;32| (171 . |cons|) (177 . |extend|)
              (183 . |concat|) |SREGSET;invertibleSet;P$L;30| (189 . |concat|)
              |SREGSET;extend;P$L;27|
              (|SquareFreeRegularTriangularSetGcdPackage| 6 7 8 9 $$)
              (195 . |stoseInvertible?|)
              (|Record| (|:| |val| 14) (|:| |tower| $$)) (|List| 91)
              (201 . |stoseInvertible?sqfreg|)
              (|Record| (|:| |val| 14) (|:| |tower| $)) (|List| 94)
              |SREGSET;invertible?;P$L;29| (207 . |stoseInvertibleSetsqfreg|)
              (|Record| (|:| |val| 9) (|:| |tower| $$)) (|List| 98)
              (213 . |stoseLastSubResultant|)
              |SREGSET;lastSubResultant;2P$L;31| (220 . |stoseSquareFreePart|)
              (|SquareFreeRegularSetDecompositionPackage| 6 7 8 9 $$)
              (226 . |decompose|) |SREGSET;intersect;P$L;33|
              |SREGSET;intersect;L2L;34| |SREGSET;zeroSetSplit;L2BL;37|
              |SREGSET;zeroSetSplit;LL;35| |SREGSET;zeroSetSplit;LBL;36|
              |SREGSET;zeroSetSplit;L4BL;38| (|Void|) (|String|)
              (|SquareFreeQuasiComponentPackage| 6 7 8 9 $$)
              (234 . |startTable!|) (241 . |startTableGcd!|)
              (248 . |startTableInvSet!|)
              |SREGSET;internalZeroSetSplit;L3BL;39| (255 . |stopTable!|)
              (259 . |stopTableGcd!|) (263 . |stopTableInvSet!|)
              (|Record| (|:| |val| 10) (|:| |towers| 29))
              |SREGSET;preprocess;L2BR;44| (|Mapping| 14 9) (267 . |remove|)
              (273 . |any?|) (279 . |empty?|) (284 . |numberOfVariables|)
              (290 . |mdeg|) (295 . |probablyZeroDim?|) (300 . |crushedSet|)
              (|Mapping| 9 9 9) (|List| 133) (|Equation| 9) (|InputForm|)
              (|Record| (|:| |num| 9) (|:| |den| 6)) (|Union| 9 29)
              (|Union| 14 29) (|List| 8)
              (|Record| (|:| |close| $) (|:| |open| 10)) (|List| 139)
              (|Mapping| 14 9 10) (|Record| (|:| |close| 10) (|:| |open| 10))
              (|Record| (|:| |bas| $) (|:| |top| 10)) (|Union| 143 '#1#)
              (|Record| (|:| |under| $) (|:| |floor| $) (|:| |upper| $))
              (|SingleInteger|))
           '#(~= 305 |zeroSetSplitIntoTriangularSystems| 311 |zeroSetSplit| 316
              |variables| 343 |trivialIdeal?| 348 |triangular?| 353
              |stronglyReduced?| 358 |stronglyReduce| 369 |squareFreePart| 375
              |sort| 381 |size?| 387 |select| 393 |sample| 405
              |roughUnitIdeal?| 409 |roughSubIdeal?| 414 |roughEqualIdeals?|
              420 |roughBase?| 426 |rewriteSetWithReduction| 431
              |rewriteIdealWithRemainder| 439 |rewriteIdealWithHeadRemainder|
              445 |retractIfCan| 451 |retract| 456 |rest| 461 |removeZero| 466
              |removeDuplicates| 472 |remove| 477 |remainder| 489 |reduced?|
              495 |reduceByQuasiMonic| 502 |reduce| 508 |quasiComponent| 537
              |purelyTranscendental?| 542 |purelyAlgebraicLeadingMonomial?| 548
              |purelyAlgebraic?| 554 |preprocess| 565 |parts| 572 |normalized?|
              577 |mvar| 588 |more?| 593 |members| 599 |member?| 604 |map!| 610
              |map| 616 |mainVariables| 622 |mainVariable?| 627 |less?| 633
              |latex| 639 |lastSubResultantElseSplit| 644 |lastSubResultant|
              651 |last| 658 |invertibleSet| 663 |invertibleElseSplit?| 669
              |invertible?| 675 |intersect| 687 |internalZeroSetSplit| 711
              |internalAugment| 719 |initials| 742 |initiallyReduced?| 747
              |initiallyReduce| 758 |infRittWu?| 764 |iexactQuo| 770
              |headRemainder| 776 |headReduced?| 782 |headReduce| 793 |hash|
              799 |first| 804 |find| 809 |extendIfCan| 815 |extend| 821
              |every?| 851 |eval| 857 |eq?| 883 |empty?| 889 |empty| 894
              |degree| 898 |count| 903 |copy| 915 |convert| 920 |construct| 925
              |collectUpper| 930 |collectUnder| 936 |collectQuasiMonic| 942
              |collect| 947 |coerce| 953 |coHeight| 963 |basicSet| 968
              |autoReduced?| 981 |augment| 987 |any?| 1011 |algebraicVariables|
              1017 |algebraicCoefficients?| 1022 |algebraic?| 1028 = 1034 |#|
              1040)
           'NIL
           (CONS (|makeByteWordVec2| 3 '(0 0 0 0 0 0 0 0 3 0 0 0 0 0 0 3 1))
                 (CONS
                  '#(NIL |RegularTriangularSetCategory&|
                     |TriangularSetCategory&| |PolynomialSetCategory&|
                     |Collection&| |HomogeneousAggregate&| |SetCategory&|
                     |Aggregate&| |Evalable&| |BasicType&| NIL NIL NIL NIL NIL
                     |InnerEvalable&| NIL)
                  (CONS
                   '#((|SquareFreeRegularTriangularSetCategory| 6 7 8 9)
                      (|RegularTriangularSetCategory| 6 7 8 9)
                      (|TriangularSetCategory| 6 7 8 9)
                      (|PolynomialSetCategory| 6 7 8 9) (|Collection| 9)
                      (|HomogeneousAggregate| 9) (|SetCategory|) (|Aggregate|)
                      (|Evalable| 9) (|BasicType|) (|shallowlyMutable|)
                      (|finiteAggregate|) (|CoercibleTo| (|List| 9)) (|Type|)
                      (|CoercibleTo| 27) (|InnerEvalable| 9 9)
                      (|ConvertibleTo| 134))
                   (|makeByteWordVec2| 146
                                       '(1 10 0 0 11 2 10 0 18 0 19 2 10 0 18 0
                                         22 2 10 14 9 0 24 1 9 27 0 28 1 27 0
                                         29 30 1 9 8 0 32 1 10 9 0 36 2 8 14 0
                                         0 41 2 9 14 0 0 44 2 10 0 45 0 46 1 9
                                         14 0 48 1 9 0 0 49 1 9 0 0 50 1 9 0 0
                                         51 1 55 54 0 56 0 6 0 57 1 55 2 0 58 2
                                         0 14 8 0 59 2 0 34 0 8 60 2 9 0 0 0 61
                                         1 9 14 0 62 0 9 0 64 2 9 54 0 8 65 1
                                         66 14 0 67 1 9 0 0 68 2 9 0 0 0 69 2 9
                                         0 0 0 70 1 9 0 0 71 2 0 75 9 0 76 1 9
                                         0 0 77 1 78 10 9 79 2 55 0 2 0 83 2 0
                                         29 10 29 84 2 10 0 0 0 85 2 55 0 0 0
                                         87 2 89 14 9 2 90 2 89 92 9 2 93 2 89
                                         55 9 2 97 3 89 99 9 9 2 100 2 89 99 9
                                         2 102 4 103 55 10 55 14 14 104 3 113
                                         111 112 112 112 114 3 89 111 112 112
                                         112 115 3 89 111 112 112 112 116 0 113
                                         111 118 0 89 111 119 0 89 111 120 2 10
                                         0 123 0 124 2 10 14 123 0 125 1 55 14
                                         0 126 2 103 54 10 55 127 1 9 54 0 128
                                         1 78 14 10 129 1 78 10 10 130 2 0 14 0
                                         0 1 1 0 140 10 1 5 0 29 10 14 14 14 14
                                         110 3 0 29 10 14 14 107 2 0 29 10 14
                                         109 1 0 29 10 108 1 0 138 0 1 1 0 14 0
                                         1 1 4 14 0 1 1 0 14 0 1 2 0 14 9 0 1 2
                                         0 9 9 0 1 2 0 81 9 0 82 2 0 145 0 8 1
                                         2 0 14 0 54 1 2 7 0 123 0 1 2 0 34 0 8
                                         60 0 0 0 1 1 4 14 0 26 2 4 14 0 0 1 2
                                         4 14 0 0 1 1 4 14 0 1 4 0 10 10 0 131
                                         45 1 2 4 10 10 0 1 2 4 10 10 0 1 1 0
                                         38 10 1 1 0 0 10 1 1 0 38 0 39 2 0 9 9
                                         0 63 1 8 0 0 1 2 8 0 9 0 1 2 7 0 123 0
                                         1 2 4 75 9 0 76 3 0 14 9 0 45 1 2 0 9
                                         9 0 1 4 8 9 131 0 9 9 1 2 7 9 131 0 1
                                         3 7 9 131 0 9 1 4 0 9 9 0 131 45 1 1 0
                                         142 0 1 2 0 14 9 0 1 2 0 14 9 0 1 1 0
                                         14 0 1 2 0 14 9 0 1 3 0 121 10 14 14
                                         122 1 7 10 0 16 2 0 14 9 0 1 1 0 14 0
                                         1 1 0 8 0 33 2 0 14 0 54 1 1 7 10 0 17
                                         2 8 14 9 0 25 2 6 0 18 0 23 2 0 0 18 0
                                         21 1 0 138 0 1 2 0 14 8 0 1 2 0 14 0
                                         54 1 1 0 112 0 1 3 0 136 9 9 0 1 3 0
                                         81 9 9 0 101 1 0 34 0 37 2 0 29 9 0 86
                                         2 0 137 9 0 1 2 0 14 9 0 52 2 0 95 9 0
                                         96 2 0 29 9 29 1 2 0 29 10 0 1 2 0 29
                                         10 29 106 2 0 29 9 0 105 4 0 29 10 14
                                         14 14 117 7 0 29 9 0 14 14 14 14 14 72
                                         2 0 0 10 0 74 2 0 0 9 0 73 1 0 10 0 1
                                         1 0 14 0 1 2 0 14 9 0 1 2 0 9 9 0 1 2
                                         0 14 0 0 1 2 4 6 6 6 1 2 4 135 9 0 1 1
                                         0 14 0 1 2 0 14 9 0 1 2 0 9 9 0 1 1 0
                                         146 0 1 1 0 34 0 35 2 0 34 123 0 1 2 0
                                         38 0 9 47 2 0 29 10 29 84 2 0 29 9 29
                                         1 2 0 29 10 0 1 2 0 29 9 0 88 2 0 0 0
                                         9 1 2 7 14 123 0 1 2 3 0 0 132 1 3 3 0
                                         0 9 9 1 2 3 0 0 133 1 3 3 0 0 10 10 1
                                         2 0 14 0 0 1 1 0 14 0 15 0 0 0 13 1 0
                                         54 0 1 2 8 54 9 0 1 2 7 54 123 0 1 1 0
                                         0 0 12 1 1 134 0 1 1 0 0 10 20 2 0 0 0
                                         8 42 2 0 0 0 8 43 1 0 0 0 1 2 0 0 0 8
                                         1 1 0 10 0 40 1 0 27 0 31 1 5 54 0 1 2
                                         0 144 10 45 1 3 0 144 10 123 45 1 2 0
                                         14 0 141 1 2 0 29 10 29 1 2 0 29 9 29
                                         1 2 0 29 10 0 1 2 0 29 9 0 53 2 7 14
                                         123 0 1 1 0 138 0 1 2 0 14 9 0 1 2 0
                                         14 8 0 59 2 0 14 0 0 1 1 7 54 0 1)))))
           '|lookupComplete|)) 
