
(/VERSIONCHECK 2) 

(DEFUN |RSETGCD;startTableGcd!;3SV;1| (|ok| |ko| |domainName| $)
  (SEQ (SPADCALL (QREFELT $ 15)) (SPADCALL |ok| |ko| (QREFELT $ 17))
       (SPADCALL |domainName| (QREFELT $ 18))
       (EXIT (SPADCALL (QREFELT $ 19))))) 

(DEFUN |RSETGCD;stopTableGcd!;V;2| ($)
  (SEQ (COND ((SPADCALL (QREFELT $ 22)) (SPADCALL (QREFELT $ 23))))
       (EXIT (SPADCALL (QREFELT $ 24))))) 

(DEFUN |RSETGCD;startTableInvSet!;3SV;3| (|ok| |ko| |domainName| $)
  (SEQ (SPADCALL (QREFELT $ 28)) (SPADCALL |ok| |ko| (QREFELT $ 29))
       (SPADCALL |domainName| (QREFELT $ 30))
       (EXIT (SPADCALL (QREFELT $ 19))))) 

(DEFUN |RSETGCD;stopTableInvSet!;V;4| ($)
  (SEQ (COND ((SPADCALL (QREFELT $ 32)) (SPADCALL (QREFELT $ 33))))
       (EXIT (SPADCALL (QREFELT $ 34))))) 

(DEFUN |RSETGCD;toseInvertible?;PTSB;5| (|p| |ts| $)
  (PROG (|q| |v| |toCheck| |bwt| #0=#:G1904 #1=#:G1886 #2=#:G1893 |tsv|
             |tsv-| |lgwt| |gwt| #3=#:G1905 |g| #4=#:G1903 #5=#:G1898)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |q|
                            (SPADCALL
                                (SPADCALL |p| |ts| (QREFELT $ 36))
                                (QREFELT $ 37))
                            . #6=(|RSETGCD;toseInvertible?;PTSB;5|))
                      (EXIT (COND
                              ((SPADCALL |q| (QREFELT $ 38)) 'NIL)
                              ((SPADCALL |q| |ts| (QREFELT $ 39)) 'T)
                              ('T
                               (SEQ (LETT |v|
                                     (SPADCALL |q| (QREFELT $ 40)) . #6#)
                                    (COND
                                      ((NULL
                                        (SPADCALL |v| |ts|
                                         (QREFELT $ 41)))
                                       (EXIT
                                        (SEQ
                                         (LETT |toCheck|
                                          (SPADCALL |p| |ts|
                                           (QREFELT $ 44)) . #6#)
                                         (SEQ
                                          (EXIT
                                           (SEQ (LETT |bwt| NIL . #6#)
                                            (LETT #0# |toCheck| . #6#)
                                            G190
                                            (COND
                                              ((OR (ATOM #0#)
                                                (PROGN
                                                  (LETT |bwt|
                                                   (CAR #0#) . #6#)
                                                  NIL))
                                               #7=(GO G191)))
                                            (SEQ
                                             (EXIT
                                              (COND
                                                ((|BooleanEquality|
                                                  (QCAR |bwt|) 'NIL)
                                                 (PROGN
                                                   (LETT #1#
                                                    (PROGN
                                                      (LETT #4#
                                                       'NIL . #6#)
                                                      (GO #4#)) . #6#)
                                                   (GO #1#))))))
                                            (LETT #0# (CDR #0#) . #6#)
                                            #8=(GO G190) G191
                                            (EXIT NIL)))
                                          #1# (EXIT #1#))
                                         (EXIT
                                          (PROGN
                                            (LETT #4# 'T . #6#)
                                            (GO #4#)))))))
                                    (LETT |tsv|
                                     (PROG2
                                      (LETT #2#
                                       (SPADCALL |ts| |v|
                                        (QREFELT $ 46)) . #6#)
                                      (QCDR #2#)
                                       (|check-union| (QEQCAR #2# 0)
                                        (QREFELT $ 9) #2#)) . #6#)
                                    (LETT |tsv-|
                                     (SPADCALL |ts| |v| (QREFELT $ 47)) . #6#)
                                    (LETT |lgwt|
                                     (SPADCALL |tsv| |q| |tsv-| 'NIL 'T
                                      (QREFELT $ 49)) . #6#)
                                    (SEQ (LETT |gwt| NIL . #6#)
                                     (LETT #3# |lgwt| . #6#) G190
                                     (COND
                                       ((OR (ATOM #3#)
                                         (PROGN
                                           (LETT |gwt| (CAR #3#) . #6#)
                                           NIL))
                                        #7#))
                                     (SEQ
                                      (EXIT
                                       (SEQ
                                        (LETT |g| (QCAR |gwt|) . #6#)
                                        (EXIT
                                         (COND
                                           ((NULL
                                             (SPADCALL |g|
                                              (QREFELT $ 50)))
                                            (COND
                                              ((SPADCALL
                                                (SPADCALL |g|
                                                 (QREFELT $ 40))
                                                |v| (QREFELT $ 51))
                                               (PROGN
                                                 (LETT #5#
                                                  (PROGN
                                                    (LETT #4#
                                                     'NIL . #6#)
                                                    (GO #4#)) . #6#)
                                                 (GO #5#)))))))))
                                      #5# (EXIT #5#))
                                     (LETT #3# (CDR #3#) . #6#) #8#
                                     G191 (EXIT NIL))
                                    (EXIT 'T)))))))
           #4# (EXIT #4#))))) 

(DEFUN |RSETGCD;toseInvertible?;PTSL;6| (|p| |ts| $)
  (PROG (|q| |v| |toCheck| #0=#:G1931 |newq| #1=#:G1930 #2=#:G1913
             |tsv| |tsv-| |tsv+| |lgwt| |gwt| #3=#:G1932 |g| |tsg| |h|
             |tsh| |inv| #4=#:G1933 |bwt| #5=#:G1934 |lbwt|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |q|
                            (SPADCALL
                                (SPADCALL |p| |ts| (QREFELT $ 36))
                                (QREFELT $ 37))
                            . #6=(|RSETGCD;toseInvertible?;PTSL;6|))
                      (EXIT (COND
                              ((SPADCALL |q| (QREFELT $ 38))
                               (LIST (CONS 'NIL |ts|)))
                              ((SPADCALL |q| |ts| (QREFELT $ 39))
                               (LIST (CONS 'T |ts|)))
                              ('T
                               (SEQ (LETT |v|
                                     (SPADCALL |q| (QREFELT $ 40)) . #6#)
                                    (COND
                                      ((NULL
                                        (SPADCALL |v| |ts|
                                         (QREFELT $ 41)))
                                       (EXIT
                                        (SEQ (LETT |lbwt| NIL . #6#)
                                         (LETT |toCheck|
                                          (SPADCALL
                                           (SPADCALL |q|
                                            (QREFELT $ 53))
                                           |ts| (QREFELT $ 44)) . #6#)
                                         (SEQ (LETT |bwt| NIL . #6#)
                                          (LETT #0# |toCheck| . #6#)
                                          G190
                                          (COND
                                            ((OR (ATOM #0#)
                                              (PROGN
                                                (LETT |bwt|
                                                 (CAR #0#) . #6#)
                                                NIL))
                                             #7=(GO G191)))
                                          (SEQ
                                           (EXIT
                                            (COND
                                              ((QCAR |bwt|)
                                               (LETT |lbwt|
                                                (CONS |bwt| |lbwt|) . #6#))
                                              ('T
                                               (SEQ
                                                (LETT |newq|
                                                 (SPADCALL |q|
                                                  (QCDR |bwt|)
                                                  (QREFELT $ 54)) . #6#)
                                                (EXIT
                                                 (COND
                                                   ((SPADCALL |newq|
                                                     (QREFELT $ 38))
                                                    (LETT |lbwt|
                                                     (CONS |bwt|
                                                      |lbwt|) . #6#))
                                                   ('T
                                                    (LETT |lbwt|
                                                     (SPADCALL
                                                      (SPADCALL |newq|
                                                       (QCDR |bwt|)
                                                       (QREFELT $ 44))
                                                      |lbwt|
                                                      (QREFELT $ 55)) . #6#)))))))))
                                          (LETT #0# (CDR #0#) . #6#)
                                          #8=(GO G190) G191 (EXIT NIL))
                                         (EXIT
                                          (PROGN
                                            (LETT #1# |lbwt| . #6#)
                                            (GO #1#)))))))
                                    (LETT |tsv|
                                     (PROG2
                                      (LETT #2#
                                       (SPADCALL |ts| |v|
                                        (QREFELT $ 46)) . #6#)
                                      (QCDR #2#)
                                       (|check-union| (QEQCAR #2# 0)
                                        (QREFELT $ 9) #2#)) . #6#)
                                    (LETT |tsv-|
                                     (SPADCALL |ts| |v| (QREFELT $ 47)) . #6#)
                                    (LETT |tsv+|
                                     (SPADCALL |ts| |v| (QREFELT $ 56)) . #6#)
                                    (LETT |lgwt|
                                     (SPADCALL |tsv| |q| |tsv-| 'NIL
                                      'NIL (QREFELT $ 49)) . #6#)
                                    (LETT |lbwt| NIL . #6#)
                                    (SEQ (LETT |gwt| NIL . #6#)
                                     (LETT #3# |lgwt| . #6#) G190
                                     (COND
                                       ((OR (ATOM #3#)
                                         (PROGN
                                           (LETT |gwt| (CAR #3#) . #6#)
                                           NIL))
                                        #7#))
                                     (SEQ (LETT |g| (QCAR |gwt|) . #6#)
                                      (LETT |ts| (QCDR |gwt|) . #6#)
                                      (COND
                                        ((OR
                                          (SPADCALL |g| (QREFELT $ 50))
                                          (SPADCALL
                                           (SPADCALL |g|
                                            (QREFELT $ 40))
                                           |v| (QREFELT $ 61)))
                                         (EXIT
                                          (SEQ
                                           (LETT |ts|
                                            (SPADCALL |tsv| |ts|
                                             (QREFELT $ 57)) . #6#)
                                           (LETT |ts|
                                            (SPADCALL
                                             (SPADCALL |tsv+|
                                              (QREFELT $ 59))
                                             |ts| (QREFELT $ 60)) . #6#)
                                           (EXIT
                                            (LETT |lbwt|
                                             (CONS (CONS 'T |ts|)
                                              |lbwt|) . #6#))))))
                                      (LETT |g|
                                       (SPADCALL |g| (QREFELT $ 62)) . #6#)
                                      (LETT |tsg|
                                       (SPADCALL |g| |ts|
                                        (QREFELT $ 57)) . #6#)
                                      (LETT |tsg|
                                       (SPADCALL
                                        (SPADCALL |tsv+|
                                         (QREFELT $ 59))
                                        |tsg| (QREFELT $ 60)) . #6#)
                                      (LETT |lbwt|
                                       (CONS (CONS 'NIL |tsg|) |lbwt|) . #6#)
                                      (LETT |h|
                                       (SPADCALL |tsv| |g|
                                        (QREFELT $ 63)) . #6#)
                                      (COND
                                        ((OR
                                          (SPADCALL |h| (QREFELT $ 50))
                                          (SPADCALL
                                           (SPADCALL |h|
                                            (QREFELT $ 40))
                                           |v| (QREFELT $ 61)))
                                         (EXIT "leave")))
                                      (LETT |h|
                                       (SPADCALL |h| (QREFELT $ 62)) . #6#)
                                      (LETT |tsh|
                                       (SPADCALL |h| |ts|
                                        (QREFELT $ 57)) . #6#)
                                      (LETT |tsh|
                                       (SPADCALL
                                        (SPADCALL |tsv+|
                                         (QREFELT $ 59))
                                        |tsh| (QREFELT $ 60)) . #6#)
                                      (LETT |inv|
                                       (SPADCALL |q| |tsh|
                                        (QREFELT $ 44)) . #6#)
                                      (EXIT
                                       (LETT |lbwt|
                                        (SPADCALL
                                         (PROGN
                                           (LETT #4# NIL . #6#)
                                           (SEQ (LETT |bwt| NIL . #6#)
                                            (LETT #5# |inv| . #6#) G190
                                            (COND
                                              ((OR (ATOM #5#)
                                                (PROGN
                                                  (LETT |bwt|
                                                   (CAR #5#) . #6#)
                                                  NIL))
                                               #7#))
                                            (SEQ
                                             (EXIT
                                              (COND
                                                ((QCAR |bwt|)
                                                 (LETT #4#
                                                  (CONS |bwt| #4#) . #6#)))))
                                            (LETT #5# (CDR #5#) . #6#)
                                            #8# G191
                                            (EXIT (NREVERSE0 #4#))))
                                         |lbwt| (QREFELT $ 55)) . #6#)))
                                     (LETT #3# (CDR #3#) . #6#) #8#
                                     G191 (EXIT NIL))
                                    (EXIT
                                     (SPADCALL
                                      (CONS
                                       #'|RSETGCD;toseInvertible?;PTSL;6!0|
                                       $)
                                      |lbwt| (QREFELT $ 66)))))))))
           #1# (EXIT #1#))))) 

(DEFUN |RSETGCD;toseInvertible?;PTSL;6!0| (|#1| |#2| $)
  (SPADCALL (QCAR |#1|) (QCAR |#2|) (QREFELT $ 64))) 

(DEFUN |RSETGCD;toseInvertibleSet;PTSL;7| (|p| |ts| $)
  (PROG (|k| |e| |q| |v| |toCheck| |bwt| #0=#:G1965 |newq| #1=#:G1964
             #2=#:G1949 |tsv| |tsv-| |tsv+| |lgwt| |gwt| #3=#:G1966 |g|
             |h| |tsh| |inv| |toSave|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |k| (CONS |p| |ts|)
                            . #4=(|RSETGCD;toseInvertibleSet;PTSL;7|))
                      (LETT |e| (SPADCALL |k| (QREFELT $ 68)) . #4#)
                      (EXIT (COND
                              ((QEQCAR |e| 0) (QCDR |e|))
                              ('T
                               (SEQ (LETT |q|
                                     (SPADCALL
                                      (SPADCALL |p| |ts|
                                       (QREFELT $ 36))
                                      (QREFELT $ 37)) . #4#)
                                    (EXIT
                                     (COND
                                       ((SPADCALL |q| (QREFELT $ 38))
                                        NIL)
                                       ((SPADCALL |q| |ts|
                                         (QREFELT $ 39))
                                        (LIST |ts|))
                                       ('T
                                        (SEQ
                                         (LETT |v|
                                          (SPADCALL |q| (QREFELT $ 40)) . #4#)
                                         (LETT |toSave| NIL . #4#)
                                         (COND
                                           ((NULL
                                             (SPADCALL |v| |ts|
                                              (QREFELT $ 41)))
                                            (EXIT
                                             (SEQ
                                              (LETT |toCheck|
                                               (SPADCALL
                                                (SPADCALL |q|
                                                 (QREFELT $ 53))
                                                |ts| (QREFELT $ 44)) . #4#)
                                              (SEQ
                                               (LETT |bwt| NIL . #4#)
                                               (LETT #0#
                                                |toCheck| . #4#)
                                               G190
                                               (COND
                                                 ((OR (ATOM #0#)
                                                   (PROGN
                                                     (LETT |bwt|
                                                      (CAR #0#) . #4#)
                                                     NIL))
                                                  #5=(GO G191)))
                                               (SEQ
                                                (EXIT
                                                 (COND
                                                   ((QCAR |bwt|)
                                                    (LETT |toSave|
                                                     (CONS (QCDR |bwt|)
                                                      |toSave|) . #4#))
                                                   ('T
                                                    (SEQ
                                                     (LETT |newq|
                                                      (SPADCALL |q|
                                                       (QCDR |bwt|)
                                                       (QREFELT $ 54)) . #4#)
                                                     (EXIT
                                                      (COND
                                                        ((SPADCALL
                                                          |newq|
                                                          (QREFELT $
                                                           38))
                                                         "leave")
                                                        ('T
                                                         (LETT |toSave|
                                                          (SPADCALL
                                                           (SPADCALL
                                                            |newq|
                                                            (QCDR
                                                             |bwt|)
                                                            (QREFELT $
                                                             70))
                                                           |toSave|
                                                           (QREFELT $
                                                            71)) . #4#)))))))))
                                               (LETT #0#
                                                (CDR #0#) . #4#)
                                               #6=(GO G190) G191
                                               (EXIT NIL))
                                              (LETT |toSave|
                                               (SPADCALL |toSave|
                                                (QREFELT $ 72)) . #4#)
                                              (EXIT
                                               (PROGN
                                                 (LETT #1#
                                                  (SPADCALL |toSave|
                                                   (QREFELT $ 74)) . #4#)
                                                 (GO #1#)))))))
                                         (LETT |tsv|
                                          (PROG2
                                           (LETT #2#
                                            (SPADCALL |ts| |v|
                                             (QREFELT $ 46)) . #4#)
                                           (QCDR #2#)
                                            (|check-union|
                                             (QEQCAR #2# 0)
                                             (QREFELT $ 9) #2#)) . #4#)
                                         (LETT |tsv-|
                                          (SPADCALL |ts| |v|
                                           (QREFELT $ 47)) . #4#)
                                         (LETT |tsv+|
                                          (SPADCALL |ts| |v|
                                           (QREFELT $ 56)) . #4#)
                                         (LETT |lgwt|
                                          (SPADCALL |tsv| |q| |tsv-|
                                           'NIL 'NIL (QREFELT $ 49)) . #4#)
                                         (SEQ (LETT |gwt| NIL . #4#)
                                          (LETT #3# |lgwt| . #4#) G190
                                          (COND
                                            ((OR (ATOM #3#)
                                              (PROGN
                                                (LETT |gwt|
                                                 (CAR #3#) . #4#)
                                                NIL))
                                             #5#))
                                          (SEQ
                                           (LETT |g|
                                            (QCAR |gwt|) . #4#)
                                           (LETT |ts|
                                            (QCDR |gwt|) . #4#)
                                           (COND
                                             ((OR
                                               (SPADCALL |g|
                                                (QREFELT $ 50))
                                               (SPADCALL
                                                (SPADCALL |g|
                                                 (QREFELT $ 40))
                                                |v| (QREFELT $ 61)))
                                              (EXIT
                                               (SEQ
                                                (LETT |ts|
                                                 (SPADCALL |tsv| |ts|
                                                  (QREFELT $ 57)) . #4#)
                                                (LETT |ts|
                                                 (SPADCALL
                                                  (SPADCALL |tsv+|
                                                   (QREFELT $ 59))
                                                  |ts| (QREFELT $ 60)) . #4#)
                                                (EXIT
                                                 (LETT |toSave|
                                                  (CONS |ts| |toSave|) . #4#))))))
                                           (LETT |g|
                                            (SPADCALL |g|
                                             (QREFELT $ 62)) . #4#)
                                           (LETT |h|
                                            (SPADCALL |tsv| |g|
                                             (QREFELT $ 63)) . #4#)
                                           (LETT |h|
                                            (SPADCALL |h|
                                             (QREFELT $ 62)) . #4#)
                                           (COND
                                             ((OR
                                               (SPADCALL |h|
                                                (QREFELT $ 50))
                                               (SPADCALL
                                                (SPADCALL |h|
                                                 (QREFELT $ 40))
                                                |v| (QREFELT $ 61)))
                                              (EXIT "leave")))
                                           (LETT |tsh|
                                            (SPADCALL |h| |ts|
                                             (QREFELT $ 57)) . #4#)
                                           (LETT |tsh|
                                            (SPADCALL
                                             (SPADCALL |tsv+|
                                              (QREFELT $ 59))
                                             |tsh| (QREFELT $ 60)) . #4#)
                                           (LETT |inv|
                                            (SPADCALL |q| |tsh|
                                             (QREFELT $ 70)) . #4#)
                                           (EXIT
                                            (LETT |toSave|
                                             (SPADCALL
                                              (SPADCALL |inv| |toSave|
                                               (QREFELT $ 71))
                                              (QREFELT $ 72)) . #4#)))
                                          (LETT #3# (CDR #3#) . #4#)
                                          #6# G191 (EXIT NIL))
                                         (LETT |toSave|
                                          (SPADCALL |toSave|
                                           (QREFELT $ 74)) . #4#)
                                         (SPADCALL |k| |toSave|
                                          (QREFELT $ 75))
                                         (EXIT |toSave|)))))))))))
           #1# (EXIT #1#))))) 

(DEFUN |RSETGCD;toseSquareFreePartwip| (|p| |ts| $)
  (PROG (|v| |q| |lgwt| |gwt| #0=#:G1975 |us| |g| |sfp| |lpwt|)
    (RETURN
      (SEQ (COND
             ((EQL (SPADCALL |p| (QREFELT $ 77)) 1)
              (LIST (CONS |p| |ts|)))
             ('T
              (SEQ (LETT |v| (SPADCALL |p| (QREFELT $ 40))
                         . #1=(|RSETGCD;toseSquareFreePartwip|))
                   (LETT |q|
                         (SPADCALL (SPADCALL |p| |v| (QREFELT $ 79))
                             (QREFELT $ 62)) . #1#)
                   (LETT |lgwt|
                         (SPADCALL |p| |q| |ts| 'T 'NIL (QREFELT $ 49)) . #1#)
                   (LETT |lpwt| NIL . #1#)
                   (SEQ (LETT |gwt| NIL . #1#) (LETT #0# |lgwt| . #1#)
                        G190
                        (COND
                          ((OR (ATOM #0#)
                               (PROGN
                                 (LETT |gwt| (CAR #0#) . #1#)
                                 NIL))
                           (GO G191)))
                        (SEQ (LETT |g| (QCAR |gwt|) . #1#)
                             (LETT |us| (QCDR |gwt|) . #1#)
                             (COND
                               ((OR (SPADCALL |g| (QREFELT $ 50))
                                    (SPADCALL
                                     (SPADCALL |g| (QREFELT $ 40)) |v|
                                     (QREFELT $ 61)))
                                (EXIT (LETT |lpwt|
                                       (CONS (CONS |p| |us|) |lpwt|) . #1#))))
                             (LETT |g|
                                   (SPADCALL |g| (QREFELT $ 62)) . #1#)
                             (LETT |sfp|
                                   (SPADCALL |p| |g| (QREFELT $ 63)) . #1#)
                             (LETT |sfp|
                                   (SPADCALL
                                    (SPADCALL |sfp| |us|
                                     (QREFELT $ 80))
                                    (QREFELT $ 62)) . #1#)
                             (EXIT (LETT |lpwt|
                                    (CONS (CONS |sfp| |us|) |lpwt|) . #1#)))
                        (LETT #0# (CDR #0#) . #1#) (GO G190) G191
                        (EXIT NIL))
                   (EXIT |lpwt|)))))))) 

(DEFUN |RSETGCD;toseSquareFreePartbase| (|p| |ts| $)
  (LIST (CONS |p| |ts|))) 

(DEFUN |RSETGCD;toseSquareFreePart;PTSL;10| (|p| |ts| $)
  (|RSETGCD;toseSquareFreePartwip| |p| |ts| $)) 

(DEFUN |RSETGCD;prepareSubResAlgo;2PTSL;11| (|p1| |p2| |ts| $)
  (PROG (|v| |lpwt| |lbwt| |bwt| #0=#:G1995 |p3| #1=#:G1982 |s| |newp2|
             |toSave| |toSee|)
    (RETURN
      (SEQ (LETT |toSee| (LIST (CONS (LIST |p1| |p2|) |ts|))
                 . #2=(|RSETGCD;prepareSubResAlgo;2PTSL;11|))
           (LETT |toSave| NIL . #2#)
           (LETT |v| (SPADCALL |p1| (QREFELT $ 40)) . #2#)
           (SEQ G190
                (COND
                  ((NULL (COND ((NULL |toSee|) 'NIL) ('T 'T)))
                   #3=(GO G191)))
                (SEQ (LETT |lpwt| (|SPADfirst| |toSee|) . #2#)
                     (LETT |toSee| (CDR |toSee|) . #2#)
                     (LETT |p1|
                           (SPADCALL (QCAR |lpwt|) 1 (QREFELT $ 83)) . #2#)
                     (LETT |p2|
                           (SPADCALL (QCAR |lpwt|) 2 (QREFELT $ 83)) . #2#)
                     (LETT |ts| (QCDR |lpwt|) . #2#)
                     (LETT |lbwt|
                           (SPADCALL (SPADCALL |p2| |v| (QREFELT $ 84))
                               |ts| (QREFELT $ 44)) . #2#)
                     (EXIT (SEQ (LETT |bwt| NIL . #2#)
                                (LETT #0# |lbwt| . #2#) G190
                                (COND
                                  ((OR (ATOM #0#)
                                    (PROGN
                                      (LETT |bwt| (CAR #0#) . #2#)
                                      NIL))
                                   #3#))
                                (SEQ (COND
                                       ((|BooleanEquality| (QCAR |bwt|)
                                         'T)
                                        (COND
                                          ((< 0
                                            (SPADCALL |p2| |v|
                                             (QREFELT $ 88)))
                                           (EXIT
                                            (SEQ
                                             (LETT |p3|
                                              (SPADCALL |p1|
                                               (SPADCALL |p2|
                                                (QREFELT $ 89))
                                               (QREFELT $ 90)) . #2#)
                                             (LETT |s|
                                              (SPADCALL
                                               (SPADCALL |p2|
                                                (QREFELT $ 53))
                                               (PROG1
                                                (LETT #1#
                                                 (-
                                                  (SPADCALL |p1|
                                                   (QREFELT $ 77))
                                                  (SPADCALL |p2|
                                                   (QREFELT $ 77))) . #2#)
                                                 (|check-subtype|
                                                  (>= #1# 0)
                                                  '(|NonNegativeInteger|)
                                                  #1#))
                                               (QREFELT $ 91)) . #2#)
                                             (EXIT
                                              (LETT |toSave|
                                               (CONS
                                                (CONS
                                                 (LIST |p2| |p3| |s|)
                                                 (QCDR |bwt|))
                                                |toSave|) . #2#))))))))
                                     (LETT |newp2|
                                      (SPADCALL
                                       (SPADCALL |p2| (QCDR |bwt|)
                                        (QREFELT $ 36))
                                       (QREFELT $ 37)) . #2#)
                                     (EXIT
                                      (COND
                                        ((|BooleanEquality|
                                          (QCAR |bwt|) 'T)
                                         (LETT |toSave|
                                          (CONS
                                           (CONS
                                            (LIST |p2|
                                             (|spadConstant| $ 87)
                                             (|spadConstant| $ 92))
                                            (QCDR |bwt|))
                                           |toSave|) . #2#))
                                        ((SPADCALL |newp2|
                                          (QREFELT $ 38))
                                         (LETT |toSave|
                                          (CONS
                                           (CONS
                                            (LIST |p1|
                                             (|spadConstant| $ 87)
                                             (|spadConstant| $ 92))
                                            (QCDR |bwt|))
                                           |toSave|) . #2#))
                                        ('T
                                         (LETT |toSee|
                                          (CONS
                                           (CONS (LIST |p1| |newp2|)
                                            (QCDR |bwt|))
                                           |toSee|) . #2#)))))
                                (LETT #0# (CDR #0#) . #2#) #4=(GO G190)
                                G191 (EXIT NIL))))
                NIL #4# G191 (EXIT NIL))
           (EXIT |toSave|))))) 

(DEFUN |RSETGCD;integralLastSubResultant;2PTSL;12| (|p1| |p2| |ts| $)
  (PROG (|lsr| |gi1i2| |ex|)
    (RETURN
      (SEQ (LETT |lsr| (SPADCALL |p1| |p2| (QREFELT $ 96))
                 . #0=(|RSETGCD;integralLastSubResultant;2PTSL;12|))
           (EXIT (COND
                   ((OR (SPADCALL |lsr| (QREFELT $ 50))
                        (SPADCALL (SPADCALL |lsr| (QREFELT $ 40))
                            (SPADCALL |p1| (QREFELT $ 40))
                            (QREFELT $ 61)))
                    (LIST (CONS |lsr| |ts|)))
                   ('T
                    (SEQ (LETT |gi1i2|
                               (SPADCALL (SPADCALL |p1| (QREFELT $ 53))
                                   (SPADCALL |p2| (QREFELT $ 53))
                                   (QREFELT $ 97)) . #0#)
                         (LETT |ex|
                               (SPADCALL
                                   (SPADCALL |gi1i2| |lsr|
                                    (QREFELT $ 98))
                                   (SPADCALL |lsr| (QREFELT $ 53))
                                   (QREFELT $ 100)) . #0#)
                         (EXIT (COND
                                 ((QEQCAR |ex| 1)
                                  (LIST (CONS |lsr| |ts|)))
                                 ('T (LIST (CONS (QCDR |ex|) |ts|))))))))))))) 

(DEFUN |RSETGCD;internalLastSubResultant;2PTS2BL;13|
       (|p1| |p2| |ts| |b1| |b2| $)
  (PROG (|k| |e| #0=#:G2021 |p3| #1=#:G2016 |s| |toSee| |toSave|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |k| (VECTOR |p1| |p2| |ts| |b2|)
                            . #2=(|RSETGCD;internalLastSubResultant;2PTS2BL;13|))
                      (LETT |e| (SPADCALL |k| (QREFELT $ 103)) . #2#)
                      (EXIT (COND
                              ((QEQCAR |e| 0) (QCDR |e|))
                              ((SPADCALL |ts| (QREFELT $ 104))
                               (SEQ (LETT |toSave|
                                     (SPADCALL |p1| |p2| |ts|
                                      (QREFELT $ 101)) . #2#)
                                    (SPADCALL |k| |toSave|
                                     (QREFELT $ 105))
                                    (EXIT
                                     (PROGN
                                       (LETT #0# |toSave| . #2#)
                                       (GO #0#)))))
                              ('T
                               (SEQ (COND
                                      (|b1|
                                       (SEQ
                                        (LETT |p3|
                                         (SPADCALL |p1|
                                          (SPADCALL |p2|
                                           (QREFELT $ 89))
                                          (QREFELT $ 90)) . #2#)
                                        (LETT |s|
                                         (SPADCALL
                                          (SPADCALL |p2|
                                           (QREFELT $ 53))
                                          (PROG1
                                           (LETT #1#
                                            (-
                                             (SPADCALL |p1|
                                              (QREFELT $ 77))
                                             (SPADCALL |p2|
                                              (QREFELT $ 77))) . #2#)
                                            (|check-subtype| (>= #1# 0)
                                             '(|NonNegativeInteger|)
                                             #1#))
                                          (QREFELT $ 91)) . #2#)
                                        (EXIT
                                         (LETT |toSee|
                                          (LIST
                                           (CONS (LIST |p2| |p3| |s|)
                                            |ts|)) . #2#))))
                                      ('T
                                       (LETT |toSee|
                                        (SPADCALL |p1| |p2| |ts|
                                         (QREFELT $ 95)) . #2#)))
                                    (LETT |toSave|
                                     (SPADCALL |toSee|
                                      (SPADCALL |p1| (QREFELT $ 40))
                                      |b2| (QREFELT $ 106)) . #2#)
                                    (SPADCALL |k| |toSave|
                                     (QREFELT $ 105))
                                    (EXIT |toSave|)))))))
           #0# (EXIT #0#))))) 

(DEFUN |RSETGCD;internalLastSubResultant;LVBL;14| (|llpwt| |v| |b2| $)
  (PROG (#0=#:G2041 |ts| |lbwt| |bwt| #1=#:G2042 #2=#:G2040 |toSee|
            #3=#:G2031 |delta| |p3| #4=#:G2043 |toReturn| |#G79| |#G80|
            |p1| |p2| |s| |lpwt| #5=#:G2044)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |toReturn| NIL
                            . #6=(|RSETGCD;internalLastSubResultant;LVBL;14|))
                      (SEQ G190
                           (COND
                             ((NULL (COND
                                      ((NULL |llpwt|) 'NIL)
                                      ('T 'T)))
                              #7=(GO G191)))
                           (SEQ (LETT |toSee| |llpwt| . #6#)
                                (LETT |llpwt| NIL . #6#)
                                (SEQ (LETT |lpwt| NIL . #6#)
                                     (LETT #0# |toSee| . #6#) G190
                                     (COND
                                       ((OR (ATOM #0#)
                                         (PROGN
                                           (LETT |lpwt|
                                            (CAR #0#) . #6#)
                                           NIL))
                                        #7#))
                                     (SEQ
                                      (LETT |p1|
                                       (SPADCALL (QCAR |lpwt|) 1
                                        (QREFELT $ 83)) . #6#)
                                      (LETT |p2|
                                       (SPADCALL (QCAR |lpwt|) 2
                                        (QREFELT $ 83)) . #6#)
                                      (LETT |s|
                                       (SPADCALL (QCAR |lpwt|) 3
                                        (QREFELT $ 83)) . #6#)
                                      (LETT |ts| (QCDR |lpwt|) . #6#)
                                      (LETT |lbwt|
                                       (SPADCALL
                                        (SPADCALL |p2| |v|
                                         (QREFELT $ 84))
                                        |ts| (QREFELT $ 44)) . #6#)
                                      (EXIT
                                       (SEQ (LETT |bwt| NIL . #6#)
                                        (LETT #1# |lbwt| . #6#) G190
                                        (COND
                                          ((OR (ATOM #1#)
                                            (PROGN
                                              (LETT |bwt|
                                               (CAR #1#) . #6#)
                                              NIL))
                                           #7#))
                                        (SEQ
                                         (EXIT
                                          (COND
                                            ((|BooleanEquality|
                                              (QCAR |bwt|) 'NIL)
                                             (SEQ
                                              (LETT |toReturn|
                                               (CONS
                                                (CONS |p1|
                                                 (QCDR |bwt|))
                                                |toReturn|) . #6#)
                                              (EXIT
                                               (COND
                                                 (|b2|
                                                  (COND
                                                    ((SPADCALL
                                                      (SPADCALL |p1|
                                                       |v|
                                                       (QREFELT $ 88))
                                                      (QREFELT $ 107))
                                                     (PROGN
                                                       (LETT #2#
                                                        |toReturn| . #6#)
                                                       (GO #2#)))))))))
                                            ('T
                                             (LETT |llpwt|
                                              (CONS
                                               (CONS
                                                (LIST |p1| |p2| |s|)
                                                (QCDR |bwt|))
                                               |llpwt|) . #6#)))))
                                        (LETT #1# (CDR #1#) . #6#)
                                        #8=(GO G190) G191 (EXIT NIL))))
                                     (LETT #0# (CDR #0#) . #6#) #8#
                                     G191 (EXIT NIL))
                                (EXIT (COND
                                        ((NULL |llpwt|) "leave")
                                        ('T
                                         (SEQ
                                          (LETT |toSee| |llpwt| . #6#)
                                          (LETT |llpwt| NIL . #6#)
                                          (LETT |lpwt|
                                           (|SPADfirst| |toSee|) . #6#)
                                          (LETT |toSee|
                                           (CDR |toSee|) . #6#)
                                          (LETT |p1|
                                           (SPADCALL (QCAR |lpwt|) 1
                                            (QREFELT $ 83)) . #6#)
                                          (LETT |p2|
                                           (SPADCALL (QCAR |lpwt|) 2
                                            (QREFELT $ 83)) . #6#)
                                          (LETT |s|
                                           (SPADCALL (QCAR |lpwt|) 3
                                            (QREFELT $ 83)) . #6#)
                                          (LETT |delta|
                                           (PROG1
                                            (LETT #3#
                                             (-
                                              (SPADCALL |p1|
                                               (QREFELT $ 77))
                                              (SPADCALL |p2| |v|
                                               (QREFELT $ 88))) . #6#)
                                             (|check-subtype|
                                              (>= #3# 0)
                                              '(|NonNegativeInteger|)
                                              #3#)) . #6#)
                                          (LETT |p3|
                                           (SPADCALL |p2|
                                            (SPADCALL |p2| |v|
                                             (QREFELT $ 84))
                                            |s| |delta|
                                            (QREFELT $ 108)) . #6#)
                                          (EXIT
                                           (COND
                                             ((ZEROP
                                               (SPADCALL |p3| |v|
                                                (QREFELT $ 88)))
                                              (SEQ
                                               (LETT |toReturn|
                                                (CONS
                                                 (CONS |p3|
                                                  (QCDR |lpwt|))
                                                 |toReturn|) . #6#)
                                               (EXIT
                                                (SEQ
                                                 (LETT |lpwt|
                                                  NIL . #6#)
                                                 (LETT #4#
                                                  |toSee| . #6#)
                                                 G190
                                                 (COND
                                                   ((OR (ATOM #4#)
                                                     (PROGN
                                                       (LETT |lpwt|
                                                        (CAR #4#) . #6#)
                                                       NIL))
                                                    #7#))
                                                 (SEQ
                                                  (EXIT
                                                   (LETT |toReturn|
                                                    (CONS
                                                     (CONS |p3|
                                                      (QCDR |lpwt|))
                                                     |toReturn|) . #6#)))
                                                 (LETT #4#
                                                  (CDR #4#) . #6#)
                                                 #8# G191 (EXIT NIL)))))
                                             ('T
                                              (SEQ
                                               (PROGN
                                                 (LETT |#G79|
                                                  |p3| . #6#)
                                                 (LETT |#G80|
                                                  (SPADCALL |p1| |p2|
                                                   |p3| |s|
                                                   (QREFELT $ 109)) . #6#)
                                                 (LETT |p1|
                                                  |#G79| . #6#)
                                                 (LETT |p2|
                                                  |#G80| . #6#))
                                               (LETT |s|
                                                (SPADCALL |p1| |v|
                                                 (QREFELT $ 84)) . #6#)
                                               (LETT |llpwt|
                                                (CONS
                                                 (CONS
                                                  (LIST |p1| |p2| |s|)
                                                  (QCDR |lpwt|))
                                                 |llpwt|) . #6#)
                                               (EXIT
                                                (SEQ
                                                 (LETT |lpwt|
                                                  NIL . #6#)
                                                 (LETT #5#
                                                  |toSee| . #6#)
                                                 G190
                                                 (COND
                                                   ((OR (ATOM #5#)
                                                     (PROGN
                                                       (LETT |lpwt|
                                                        (CAR #5#) . #6#)
                                                       NIL))
                                                    #7#))
                                                 (SEQ
                                                  (EXIT
                                                   (LETT |llpwt|
                                                    (CONS
                                                     (CONS
                                                      (LIST |p1| |p2|
                                                       |s|)
                                                      (QCDR |lpwt|))
                                                     |llpwt|) . #6#)))
                                                 (LETT #5#
                                                  (CDR #5#) . #6#)
                                                 #8# G191 (EXIT NIL))))))))))))
                           NIL #8# G191 (EXIT NIL))
                      (EXIT |toReturn|)))
           #2# (EXIT #2#))))) 

(DEFUN |RSETGCD;toseLastSubResultant;2PTSL;15| (|p1| |p2| |ts| $)
  (PROG (|#G86| |#G87|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |p1| (QREFELT $ 50))
              (|error| "in toseLastSubResultantElseSplit$TOSEGCD  : bad #1"))
             ((OR (SPADCALL |p2| (QREFELT $ 50))
                  (NULL (SPADCALL (SPADCALL |p2| (QREFELT $ 40))
                            (SPADCALL |p1| (QREFELT $ 40))
                            (QREFELT $ 51))))
              (|error| "in toseLastSubResultantElseSplit$TOSEGCD : bad #2"))
             ((OR (SPADCALL (SPADCALL |p1| (QREFELT $ 40)) |ts|
                      (QREFELT $ 41))
                  (NULL (SPADCALL |p1| |ts| (QREFELT $ 110))))
              (|error| "in toseLastSubResultantElseSplit$TOSEGCD : bad #1"))
             ((NULL (SPADCALL |p2| |ts| (QREFELT $ 110)))
              (|error| "in toseLastSubResultantElseSplit$TOSEGCD : bad #2"))
             ('T
              (SEQ (COND
                     ((SPADCALL |p1| |ts| (QREFELT $ 111))
                      (COND
                        ((SPADCALL |p2| |ts| (QREFELT $ 111))
                         (EXIT (SPADCALL |p1| |p2| |ts|
                                   (QREFELT $ 101)))))))
                   (COND
                     ((< (SPADCALL |p1| (QREFELT $ 77))
                         (SPADCALL |p2| (QREFELT $ 77)))
                      (SEQ (PROGN
                             (LETT |#G86| |p2|
                                   . #0=(|RSETGCD;toseLastSubResultant;2PTSL;15|))
                             (LETT |#G87| |p1| . #0#)
                             (LETT |p1| |#G86| . #0#)
                             (LETT |p2| |#G87| . #0#))
                           (EXIT (COND
                                   ((ODDP
                                     (SPADCALL |p1| (QREFELT $ 77)))
                                    (COND
                                      ((ODDP
                                        (SPADCALL |p2| (QREFELT $ 77)))
                                       (LETT |p2|
                                        (SPADCALL |p2| (QREFELT $ 89)) . #0#)))))))))
                   (EXIT (SPADCALL |p1| |p2| |ts| 'NIL 'NIL
                             (QREFELT $ 49)))))))))) 

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

(DEFUN |RegularTriangularSetGcdPackage;| (|#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=(|RegularTriangularSetGcdPackage|))
        (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 '|RegularTriangularSetGcdPackage| DV$1 DV$2 DV$3
                    DV$4 DV$5) . #0#)
        (LETT $ (GETREFV 113) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache|
            '|RegularTriangularSetGcdPackage|
            (LIST DV$1 DV$2 DV$3 DV$4 DV$5) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        (QSETREFV $ 8 |#3|)
        (QSETREFV $ 9 |#4|)
        (QSETREFV $ 10 |#5|)
        $)))) 

(MAKEPROP '|RegularTriangularSetGcdPackage| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|local| |#3|) (|local| |#4|) (|local| |#5|) (|Void|)
             (|Record| (|:| |arg1| 9) (|:| |arg2| 9) (|:| |arg3| 10)
                 (|:| |arg4| 21))
             (|Record| (|:| |val| 9) (|:| |tower| 10))
             (|TabulatedComputationPackage| 12 48) (0 . |initTable!|)
             (|String|) (4 . |printInfo!|) (10 . |startStats!|)
             (15 . |void|) |RSETGCD;startTableGcd!;3SV;1| (|Boolean|)
             (19 . |makingStats?|) (23 . |printStats!|)
             (27 . |clearTable!|) |RSETGCD;stopTableGcd!;V;2|
             (|Record| (|:| |arg1| 9) (|:| |arg3| 10))
             (|TabulatedComputationPackage| 26 69) (31 . |initTable!|)
             (35 . |printInfo!|) (41 . |startStats!|)
             |RSETGCD;startTableInvSet!;3SV;3| (46 . |makingStats?|)
             (50 . |printStats!|) (54 . |clearTable!|)
             |RSETGCD;stopTableInvSet!;V;4| (58 . |initiallyReduce|)
             (64 . |primitivePart|) (69 . |zero?|) (74 . |normalized?|)
             (80 . |mvar|) (85 . |algebraic?|)
             (|Record| (|:| |val| 21) (|:| |tower| 10)) (|List| 42)
             |RSETGCD;toseInvertible?;PTSL;6| (|Union| 9 '"failed")
             (91 . |select|) (97 . |collectUnder|) (|List| 13)
             |RSETGCD;internalLastSubResultant;2PTS2BL;13|
             (103 . |ground?|) (108 . =)
             |RSETGCD;toseInvertible?;PTSB;5| (114 . |init|)
             (119 . |removeZero|) (125 . |concat|)
             (131 . |collectUpper|) (137 . |internalAugment|)
             (|List| 9) (143 . |members|) (148 . |internalAugment|)
             (154 . <) (160 . |mainPrimitivePart|) (165 . |lazyPquo|)
             (171 . <) (|Mapping| 21 42 42) (177 . |sort|)
             (|Union| 69 '"failed") (183 . |extractIfCan|) (|List| 10)
             |RSETGCD;toseInvertibleSet;PTSL;7| (188 . |concat|)
             (194 . |removeDuplicates|)
             (|QuasiComponentPackage| 6 7 8 9 10)
             (199 . |algebraicSort|) (204 . |insert!|)
             (|NonNegativeInteger|) (210 . |mdeg|) (215 . |One|)
             (219 . D) (225 . |stronglyReduce|)
             |RSETGCD;toseSquareFreePart;PTSL;10| (|Integer|)
             (231 . |elt|) (237 . |leadingCoefficient|) (243 . |Zero|)
             (247 . |Zero|) (251 . |Zero|) (255 . |degree|) (261 . -)
             (266 . |prem|) (272 . **) (278 . |One|)
             (|Record| (|:| |val| 58) (|:| |tower| 10)) (|List| 93)
             |RSETGCD;prepareSubResAlgo;2PTSL;11|
             (282 . |lastSubResultant|) (288 . |gcd|) (294 . *)
             (|Union| $ '"failed") (300 . |exquo|)
             |RSETGCD;integralLastSubResultant;2PTSL;12|
             (|Union| 48 '"failed") (306 . |extractIfCan|)
             (311 . |empty?|) (316 . |insert!|)
             |RSETGCD;internalLastSubResultant;LVBL;14|
             (322 . |positive?|) (327 . |LazardQuotient2|)
             (335 . |nextsubResultant2|) (343 . |initiallyReduced?|)
             (349 . |purelyTranscendental?|)
             |RSETGCD;toseLastSubResultant;2PTSL;15|)
          '#(|toseSquareFreePart| 355 |toseLastSubResultant| 361
             |toseInvertibleSet| 368 |toseInvertible?| 374
             |stopTableInvSet!| 386 |stopTableGcd!| 390
             |startTableInvSet!| 394 |startTableGcd!| 401
             |prepareSubResAlgo| 408 |internalLastSubResultant| 415
             |integralLastSubResultant| 431)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 112
                                '(0 14 11 15 2 14 11 16 16 17 1 14 11
                                  16 18 0 11 0 19 0 14 21 22 0 14 11 23
                                  0 14 11 24 0 27 11 28 2 27 11 16 16
                                  29 1 27 11 16 30 0 27 21 32 0 27 11
                                  33 0 27 11 34 2 10 9 9 0 36 1 9 0 0
                                  37 1 9 21 0 38 2 10 21 9 0 39 1 9 8 0
                                  40 2 10 21 8 0 41 2 10 45 0 8 46 2 10
                                  0 0 8 47 1 9 21 0 50 2 8 21 0 0 51 1
                                  9 0 0 53 2 10 9 9 0 54 2 43 0 0 0 55
                                  2 10 0 0 8 56 2 10 0 9 0 57 1 10 58 0
                                  59 2 10 0 58 0 60 2 8 21 0 0 61 1 9 0
                                  0 62 2 9 0 0 0 63 2 21 21 0 0 64 2 43
                                  0 65 0 66 1 27 67 26 68 2 69 0 0 0 71
                                  1 69 0 0 72 1 73 69 69 74 2 27 11 26
                                  69 75 1 9 76 0 77 0 6 0 78 2 9 0 0 8
                                  79 2 10 9 9 0 80 2 58 9 0 82 83 2 9 0
                                  0 8 84 0 6 0 85 0 7 0 86 0 9 0 87 2 9
                                  76 0 8 88 1 9 0 0 89 2 9 0 0 0 90 2 9
                                  0 0 76 91 0 9 0 92 2 9 0 0 0 96 2 9 0
                                  0 0 97 2 9 0 0 0 98 2 9 99 0 0 100 1
                                  14 102 12 103 1 10 21 0 104 2 14 11
                                  12 48 105 1 82 21 0 107 4 9 0 0 0 0
                                  76 108 4 9 0 0 0 0 0 109 2 10 21 9 0
                                  110 2 10 21 9 0 111 2 0 48 9 10 81 3
                                  0 48 9 9 10 112 2 0 69 9 10 70 2 0 43
                                  9 10 44 2 0 21 9 10 52 0 0 11 35 0 0
                                  11 25 3 0 11 16 16 16 31 3 0 11 16 16
                                  16 20 3 0 94 9 9 10 95 5 0 48 9 9 10
                                  21 21 49 3 0 48 94 8 21 106 3 0 48 9
                                  9 10 101)))))
          '|lookupComplete|)) 
