
(/VERSIONCHECK 2) 

(DEFUN |MODHP;SUPI_to_PA| (|poli| |p| $)
  (PROG (|nlc| |m| |pa| |n|)
    (RETURN
     (SEQ (LETT |n| (SPADCALL |poli| (QREFELT $ 8)) . #1=(|MODHP;SUPI_to_PA|))
          (LETT |pa| (GETREFV32 (+ |n| 1) 0) . #1#)
          (SEQ G190
               (COND
                ((NULL (COND ((SPADCALL |poli| (QREFELT $ 10)) 'NIL) ('T 'T)))
                 (GO G191)))
               (SEQ (LETT |m| (SPADCALL |poli| (QREFELT $ 8)) . #1#)
                    (LETT |nlc|
                          (SPADCALL (SPADCALL |poli| (QREFELT $ 12)) |p|
                                    (QREFELT $ 13))
                          . #1#)
                    (SETELT32 |pa| |m| |nlc|)
                    (EXIT
                     (LETT |poli| (SPADCALL |poli| (QREFELT $ 14)) . #1#)))
               NIL (GO G190) G191 (EXIT NIL))
          (EXIT |pa|))))) 

(DEFUN |MODHP;VSUPI_to_VPA;VIV;2| (|vps| |p| $)
  (PROG (|i| |vpa| |m|)
    (RETURN
     (SEQ (LETT |m| (QVSIZE |vps|) . #1=(|MODHP;VSUPI_to_VPA;VIV;2|))
          (LETT |vpa| (MAKEARR1 |m| (GETREFV32 0 0)) . #1#)
          (SEQ (LETT |i| 1 . #1#) G190 (COND ((QSGREATERP |i| |m|) (GO G191)))
               (SEQ
                (EXIT
                 (SPADCALL |vpa| |i|
                           (|MODHP;SUPI_to_PA|
                            (SPADCALL |vps| |i| (QREFELT $ 16)) |p| $)
                           (QREFELT $ 19))))
               (LETT |i| (QSADD1 |i|) . #1#) (GO G190) G191 (EXIT NIL))
          (EXIT |vpa|))))) 

(DEFUN |MODHP;SUPPI_to_PA| (|poli| |vars| |pts| |p| $)
  (PROG (|nlc| |m| |pa| |n|)
    (RETURN
     (SEQ
      (LETT |n| (SPADCALL |poli| (QREFELT $ 22)) . #1=(|MODHP;SUPPI_to_PA|))
      (LETT |pa| (GETREFV32 (+ |n| 1) 0) . #1#)
      (SEQ G190
           (COND
            ((NULL (COND ((SPADCALL |poli| (QREFELT $ 23)) 'NIL) ('T 'T)))
             (GO G191)))
           (SEQ (LETT |m| (SPADCALL |poli| (QREFELT $ 22)) . #1#)
                (LETT |nlc|
                      (SPADCALL (SPADCALL |poli| (QREFELT $ 25)) |vars| |pts|
                                |p| (QREFELT $ 29))
                      . #1#)
                (SETELT32 |pa| |m| |nlc|)
                (EXIT (LETT |poli| (SPADCALL |poli| (QREFELT $ 30)) . #1#)))
           NIL (GO G190) G191 (EXIT NIL))
      (EXIT |pa|))))) 

(DEFUN |MODHP;VSUPPI_to_VPA;VLLIV;4| (|vps| |vars| |pts| |p| $)
  (PROG (|i| |vpa| |m|)
    (RETURN
     (SEQ (LETT |m| (QVSIZE |vps|) . #1=(|MODHP;VSUPPI_to_VPA;VLLIV;4|))
          (LETT |vpa| (MAKEARR1 |m| (GETREFV32 0 0)) . #1#)
          (SEQ (LETT |i| 1 . #1#) G190 (COND ((QSGREATERP |i| |m|) (GO G191)))
               (SEQ
                (EXIT
                 (SPADCALL |vpa| |i|
                           (|MODHP;SUPPI_to_PA|
                            (SPADCALL |vps| |i| (QREFELT $ 32)) |vars| |pts|
                            |p| $)
                           (QREFELT $ 19))))
               (LETT |i| (QSADD1 |i|) . #1#) (GO G190) G191 (EXIT NIL))
          (EXIT |vpa|))))) 

(DEFUN |MODHP;LLFI_to_LPA;L2IU;5| (|llfi| |n| |prime| $)
  (PROG (|resl| |nlc| |dms| #1=#:G1870 |dm| |nm| #2=#:G1872 |j| #3=#:G1873 |el|
         |pa| |nn| #4=#:G1871 |lfi|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |resl| NIL . #5=(|MODHP;LLFI_to_LPA;L2IU;5|))
            (SEQ (LETT |lfi| NIL . #5#) (LETT #4# |llfi| . #5#) G190
                 (COND
                  ((OR (ATOM #4#) (PROGN (LETT |lfi| (CAR #4#) . #5#) NIL))
                   #6=(GO G191)))
                 (SEQ
                  (LETT |nn| (COND ((< 0 |n|) |n|) ('T (LENGTH |lfi|))) . #5#)
                  (LETT |pa| (GETREFV32 |nn| 0) . #5#)
                  (SEQ (LETT |el| NIL . #5#) (LETT #3# |lfi| . #5#)
                       (LETT |j| 0 . #5#) (LETT #2# (- |nn| 1) . #5#) G190
                       (COND
                        ((OR (QSGREATERP |j| #2#) (ATOM #3#)
                             (PROGN (LETT |el| (CAR #3#) . #5#) NIL))
                         #6#))
                       (SEQ
                        (LETT |nm|
                              (SPADCALL (SPADCALL |el| (QREFELT $ 36)) |prime|
                                        (QREFELT $ 13))
                              . #5#)
                        (LETT |dm|
                              (SPADCALL (SPADCALL |el| (QREFELT $ 37)) |prime|
                                        (QREFELT $ 13))
                              . #5#)
                        (EXIT
                         (COND
                          ((EQL |dm| 0)
                           (PROGN (LETT #1# (CONS 1 "failed") . #5#) (GO #1#)))
                          ('T
                           (SEQ (LETT |dms| |dm| . #5#)
                                (LETT |nlc|
                                      (QSMULMOD32 |nm|
                                                  (SPADCALL |dms| |prime|
                                                            (QREFELT $ 39))
                                                  |prime|)
                                      . #5#)
                                (EXIT (SETELT32 |pa| |j| |nlc|)))))))
                       (LETT |j|
                             (PROG1 (QSADD1 |j|) (LETT #3# (CDR #3#) . #5#))
                             . #5#)
                       #7=(GO G190) G191 (EXIT NIL))
                  (EXIT (LETT |resl| (CONS |pa| |resl|) . #5#)))
                 (LETT #4# (CDR #4#) . #5#) #7# G191 (EXIT NIL))
            (EXIT (CONS 0 (NREVERSE |resl|)))))
      #1# (EXIT #1#))))) 

(DEFUN |MODHP;LLFPI_to_LPA;LILLIU;6| (|llfi| |n| |vars| |pts| |prime| $)
  (PROG (|resl| |nlc| |dms| #1=#:G1883 |dm| |nm| #2=#:G1885 |j| #3=#:G1886 |el|
         |pa| #4=#:G1884 |lfi|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |resl| NIL . #5=(|MODHP;LLFPI_to_LPA;LILLIU;6|))
            (SEQ (LETT |lfi| NIL . #5#) (LETT #4# |llfi| . #5#) G190
                 (COND
                  ((OR (ATOM #4#) (PROGN (LETT |lfi| (CAR #4#) . #5#) NIL))
                   #6=(GO G191)))
                 (SEQ (LETT |pa| (GETREFV32 |n| 0) . #5#)
                      (SEQ (LETT |el| NIL . #5#) (LETT #3# |lfi| . #5#)
                           (LETT |j| 0 . #5#) (LETT #2# (- |n| 1) . #5#) G190
                           (COND
                            ((OR (QSGREATERP |j| #2#) (ATOM #3#)
                                 (PROGN (LETT |el| (CAR #3#) . #5#) NIL))
                             #6#))
                           (SEQ
                            (LETT |nm|
                                  (SPADCALL (SPADCALL |el| (QREFELT $ 44))
                                            |vars| |pts| |prime|
                                            (QREFELT $ 29))
                                  . #5#)
                            (LETT |dm|
                                  (SPADCALL (SPADCALL |el| (QREFELT $ 45))
                                            |vars| |pts| |prime|
                                            (QREFELT $ 29))
                                  . #5#)
                            (EXIT
                             (COND
                              ((EQL |dm| 0)
                               (PROGN
                                (LETT #1# (CONS 1 "failed") . #5#)
                                (GO #1#)))
                              ('T
                               (SEQ (LETT |dms| |dm| . #5#)
                                    (LETT |nlc|
                                          (QSMULMOD32 |nm|
                                                      (SPADCALL |dms| |prime|
                                                                (QREFELT $ 39))
                                                      |prime|)
                                          . #5#)
                                    (EXIT (SETELT32 |pa| |j| |nlc|)))))))
                           (LETT |j|
                                 (PROG1 (QSADD1 |j|)
                                   (LETT #3# (CDR #3#) . #5#))
                                 . #5#)
                           #7=(GO G190) G191 (EXIT NIL))
                      (EXIT (LETT |resl| (CONS |pa| |resl|) . #5#)))
                 (LETT #4# (CDR #4#) . #5#) #7# G191 (EXIT NIL))
            (EXIT (CONS 0 (NREVERSE |resl|)))))
      #1# (EXIT #1#))))) 

(DEFUN |MODHP;PPFtoPA| (|pfi| |sigma| |psi| $)
  (PROG (|nc| |nlcq| |m| |prime| |pa|)
    (RETURN
     (SEQ (LETT |pa| (GETREFV32 |sigma| 0) . #1=(|MODHP;PPFtoPA|))
          (LETT |prime| |psi| . #1#)
          (SEQ G190
               (COND
                ((NULL (COND ((SPADCALL |pfi| (QREFELT $ 10)) 'NIL) ('T 'T)))
                 (GO G191)))
               (SEQ (LETT |m| (SPADCALL |pfi| (QREFELT $ 8)) . #1#)
                    (COND
                     ((< |m| |sigma|)
                      (SEQ (LETT |nlcq| (SPADCALL |pfi| (QREFELT $ 12)) . #1#)
                           (LETT |nc| (SPADCALL |nlcq| |prime| (QREFELT $ 13))
                                 . #1#)
                           (EXIT (SETELT32 |pa| |m| |nc|)))))
                    (EXIT (LETT |pfi| (SPADCALL |pfi| (QREFELT $ 14)) . #1#)))
               NIL (GO G190) G191 (EXIT NIL))
          (EXIT (CONS 0 |pa|)))))) 

(DEFUN |MODHP;LPPFtoVPA| (|lpi| |sigma| |psi| $)
  (PROG (#1=#:G1902 |vpp| |i| #2=#:G1903 |p| |vpa| |m|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |m| (LENGTH |lpi|) . #3=(|MODHP;LPPFtoVPA|))
            (LETT |vpa| (MAKEARR1 |m| (GETREFV32 0 0)) . #3#)
            (SEQ (LETT |p| NIL . #3#) (LETT #2# |lpi| . #3#) (LETT |i| 1 . #3#)
                 G190
                 (COND
                  ((OR (QSGREATERP |i| |m|) (ATOM #2#)
                       (PROGN (LETT |p| (CAR #2#) . #3#) NIL))
                   (GO G191)))
                 (SEQ (LETT |vpp| (|MODHP;PPFtoPA| |p| |sigma| |psi| $) . #3#)
                      (EXIT
                       (COND
                        ((QEQCAR |vpp| 1)
                         (PROGN (LETT #1# (CONS 1 "failed") . #3#) (GO #1#)))
                        ('T
                         (SPADCALL |vpa| |i| (QCDR |vpp|) (QREFELT $ 19))))))
                 (LETT |i| (PROG1 (QSADD1 |i|) (LETT #2# (CDR #2#) . #3#))
                       . #3#)
                 (GO G190) G191 (EXIT NIL))
            (EXIT (CONS 0 |vpa|))))
      #1# (EXIT #1#))))) 

(DEFUN |MODHP;intpoly_to_PFI| (|p| $) (SPADCALL (ELT $ 48) |p| (QREFELT $ 52))) 

(DEFUN |MODHP;check_sol1a;VLM3IUv;10| (|nres| |gv0| |gen| |sigma| |qval| |p| $)
  (PROG (|i| |res| |gvp| |m|)
    (RETURN
     (SEQ (LETT |m| (QVSIZE |nres|) . #1=(|MODHP;check_sol1a;VLM3IUv;10|))
          (LETT |gvp| (SPADCALL |gv0| |p| |qval| |gen|) . #1#)
          (LETT |res| (GETREFV32 |sigma| 0) . #1#)
          (SEQ (LETT |i| 1 . #1#) G190 (COND ((QSGREATERP |i| |m|) (GO G191)))
               (SEQ
                (EXIT
                 (SPADCALL (SPADCALL |gvp| |i| (QREFELT $ 53))
                           (SPADCALL |nres| |i| (QREFELT $ 53)) |res|
                           (- |sigma| 1) |p| (QREFELT $ 57))))
               (LETT |i| (QSADD1 |i|) . #1#) (GO G190) G191 (EXIT NIL))
          (EXIT |res|))))) 

(DEFUN |MODHP;HP_solve_I;LLSNniMMU;11|
       (|list| |degs| |kind| |sigma| |gen| |check| $)
  (PROG (#1=#:G2018 |l| #2=#:G2022 |i| |mress| #3=#:G1997 |ii| #4=#:G1996
         |sol_ok| |sol_okp| |k| |s| |mm| |j| |resvi| |resv| #5=#:G1984 |ppr|
         |pp| |empty_offsets| |offsets| #6=#:G1973 |cp| |rv| #7=#:G1963
         |rstate| |oldciv| |oldva| |nsols| #8=#:G1960 |is_bad| |all_bad| |civ|
         |va| |bm| |rblr| |blr| |gv2| |gv0| |gv0p| |psi| |nprimes| |ok| |lp|
         |prime| |maxd| |vi| |pts| #9=#:G1936 #10=#:G2021 |pts0| |ve|
         #11=#:G2020 |d| #12=#:G2019 |degs_sum| |m|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |lp| NIL . #13=(|MODHP;HP_solve_I;LLSNniMMU;11|))
            (COND
             ((OR (EQUAL |kind| '|qdiffHP|) (EQUAL |kind| '|qshiftHP|))
              (EXIT (CONS 1 'T))))
            (LETT |m| (LENGTH |degs|) . #13#)
            (LETT |degs_sum|
                  (+ (SPADCALL (ELT $ 61) |degs| (QREFELT $ 63)) |m|) . #13#)
            (LETT |ve|
                  (SPADCALL
                   (PROGN
                    (LETT #12# NIL . #13#)
                    (SEQ (LETT |d| NIL . #13#) (LETT #11# |degs| . #13#) G190
                         (COND
                          ((OR (ATOM #11#)
                               (PROGN (LETT |d| (CAR #11#) . #13#) NIL))
                           #14=(GO G191)))
                         (SEQ (EXIT (LETT #12# (CONS |d| #12#) . #13#)))
                         (LETT #11# (CDR #11#) . #13#) #15=(GO G190) G191
                         (EXIT (NREVERSE0 #12#))))
                   (QREFELT $ 65))
                  . #13#)
            (LETT |pts|
                  (COND ((EQUAL |kind| '|diffHP|) (GETREFV32 0 0))
                        ('T
                         (SEQ
                          (EXIT
                           (COND
                            ((EQUAL |kind| '|shiftHP|)
                             (PROGN
                              (LETT #9#
                                    (SEQ
                                     (LETT |pts0| (GETREFV32 |sigma| 0) . #13#)
                                     (SEQ (LETT |i| 0 . #13#)
                                          (LETT #10# (- |sigma| 1) . #13#) G190
                                          (COND ((QSGREATERP |i| #10#) #14#))
                                          (SEQ
                                           (EXIT (SETELT32 |pts0| |i| |i|)))
                                          (LETT |i| (QSADD1 |i|) . #13#) #15#
                                          G191 (EXIT NIL))
                                     (EXIT |pts0|))
                                    . #13#)
                              (GO #9#)))))
                          #9# (EXIT #9#))))
                  . #13#)
            (LETT |vi| (MAKEARR1 |m| NIL) . #13#) (LETT |nsols| -1 . #13#)
            (LETT |maxd| -1 . #13#) (LETT |nprimes| 0 . #13#)
            (LETT |nsols| (+ |m| 1) . #13#) (LETT |empty_offsets| 'T . #13#)
            (SEQ G190 NIL
                 (SEQ (LETT |ok| 'NIL . #13#)
                      (SEQ (LETT |k| 1 . #13#) G190
                           (COND
                            ((OR (QSGREATERP |k| 100)
                                 (NULL (COND (|ok| 'NIL) ('T 'T))))
                             #14#))
                           (SEQ
                            (LETT |prime|
                                  (SPADCALL (+ (RANDOM 2000000) 2000000)
                                            (QREFELT $ 68))
                                  . #13#)
                            (EXIT
                             (COND
                              ((SPADCALL |prime| |lp| (QREFELT $ 69))
                               "iterate")
                              ('T
                               (SEQ (LETT |lp| (CONS |prime| |lp|) . #13#)
                                    (EXIT (LETT |ok| 'T . #13#)))))))
                           (LETT |k| (QSADD1 |k|) . #13#) #15# G191 (EXIT NIL))
                      (EXIT
                       (COND
                        (|ok|
                         (SEQ (LETT |nprimes| (+ |nprimes| 1) . #13#)
                              (LETT |psi| (SPADCALL |prime| (QREFELT $ 70))
                                    . #13#)
                              (LETT |gv0p|
                                    (SPADCALL |list| 0 |psi| (QREFELT $ 42))
                                    . #13#)
                              (EXIT
                               (COND ((QEQCAR |gv0p| 1) "iterate")
                                     ('T
                                      (SEQ (LETT |gv0| (QCDR |gv0p|) . #13#)
                                           (LETT |gv2|
                                                 (SPADCALL |gv0| |prime| 1
                                                           |gen|)
                                                 . #13#)
                                           (LETT |blr|
                                                 (SPADCALL |gv2| |ve| |sigma|
                                                           |pts| |prime| |kind|
                                                           (QREFELT $ 74))
                                                 . #13#)
                                           (EXIT
                                            (COND
                                             ((QEQCAR |blr| 1)
                                              (PROGN
                                               (LETT #1# (CONS 1 'NIL) . #13#)
                                               (GO #1#)))
                                             ('T
                                              (SEQ
                                               (LETT |rblr| (QCDR |blr|)
                                                     . #13#)
                                               (LETT |bm| (QVELT |rblr| 0)
                                                     . #13#)
                                               (LETT |va| (QVELT |rblr| 1)
                                                     . #13#)
                                               (LETT |civ| (QVELT |rblr| 2)
                                                     . #13#)
                                               (EXIT
                                                (COND
                                                 ((< |nsols| (QVSIZE |va|))
                                                  "iterate")
                                                 ('T
                                                  (SEQ
                                                   (LETT |is_bad| 'NIL . #13#)
                                                   (LETT |all_bad|
                                                         (< (QVSIZE |va|)
                                                            |nsols|)
                                                         . #13#)
                                                   (COND
                                                    ((EQL (QVSIZE |va|)
                                                          |nsols|)
                                                     (SEQ
                                                      (EXIT
                                                       (SEQ (LETT |i| 1 . #13#)
                                                            G190
                                                            (COND
                                                             ((QSGREATERP |i|
                                                                          |nsols|)
                                                              #14#))
                                                            (SEQ
                                                             (EXIT
                                                              (COND
                                                               ((<
                                                                 (SPADCALL |va|
                                                                           |i|
                                                                           (QREFELT
                                                                            $
                                                                            75))
                                                                 (SPADCALL
                                                                  |oldva| |i|
                                                                  (QREFELT $
                                                                           75)))
                                                                (SEQ
                                                                 (LETT
                                                                  |all_bad| 'T
                                                                  . #13#)
                                                                 (EXIT
                                                                  (PROGN
                                                                   (LETT #8#
                                                                         |$NoValue|
                                                                         . #13#)
                                                                   (GO #8#)))))
                                                               ((<
                                                                 (SPADCALL
                                                                  |oldva| |i|
                                                                  (QREFELT $
                                                                           75))
                                                                 (SPADCALL |va|
                                                                           |i|
                                                                           (QREFELT
                                                                            $
                                                                            75)))
                                                                (SEQ
                                                                 (LETT |is_bad|
                                                                       'T
                                                                       . #13#)
                                                                 (EXIT
                                                                  (PROGN
                                                                   (LETT #8#
                                                                         |$NoValue|
                                                                         . #13#)
                                                                   (GO #8#)))))
                                                               ((<
                                                                 (SPADCALL
                                                                  |civ| |i|
                                                                  (QREFELT $
                                                                           75))
                                                                 (SPADCALL
                                                                  |oldciv| |i|
                                                                  (QREFELT $
                                                                           75)))
                                                                (SEQ
                                                                 (LETT
                                                                  |all_bad| 'T
                                                                  . #13#)
                                                                 (EXIT
                                                                  (PROGN
                                                                   (LETT #8#
                                                                         |$NoValue|
                                                                         . #13#)
                                                                   (GO #8#)))))
                                                               ((<
                                                                 (SPADCALL
                                                                  |oldciv| |i|
                                                                  (QREFELT $
                                                                           75))
                                                                 (SPADCALL
                                                                  |civ| |i|
                                                                  (QREFELT $
                                                                           75)))
                                                                (SEQ
                                                                 (LETT |is_bad|
                                                                       'T
                                                                       . #13#)
                                                                 (EXIT
                                                                  (PROGN
                                                                   (LETT #8#
                                                                         |$NoValue|
                                                                         . #13#)
                                                                   (GO
                                                                    #8#))))))))
                                                            (LETT |i|
                                                                  (QSADD1 |i|)
                                                                  . #13#)
                                                            #15# G191
                                                            (EXIT NIL)))
                                                      #8# (EXIT #8#))))
                                                   (EXIT
                                                    (COND (|is_bad| "iterate")
                                                          ('T
                                                           (SEQ
                                                            (COND
                                                             (|all_bad|
                                                              (SEQ
                                                               (LETT |nsols|
                                                                     (QVSIZE
                                                                      |va|)
                                                                     . #13#)
                                                               (LETT |oldva|
                                                                     |va|
                                                                     . #13#)
                                                               (LETT |oldciv|
                                                                     |civ|
                                                                     . #13#)
                                                               (LETT |rstate|
                                                                     (SPADCALL
                                                                      (*
                                                                       |nsols|
                                                                       |degs_sum|)
                                                                      (QREFELT
                                                                       $ 77))
                                                                     . #13#)
                                                               (LETT |rv|
                                                                     (GETREFV32
                                                                      (SPADCALL
                                                                       (PROG1
                                                                           (LETT
                                                                            #7#
                                                                            |nsols|
                                                                            . #13#)
                                                                         (|check-subtype|
                                                                          (>
                                                                           #7#
                                                                           0)
                                                                          '(|PositiveInteger|)
                                                                          #7#))
                                                                       |degs_sum|
                                                                       (QREFELT
                                                                        $ 79))
                                                                      0)
                                                                     . #13#)
                                                               (EXIT
                                                                (LETT
                                                                 |empty_offsets|
                                                                 'T . #13#)))))
                                                            (LETT |k| 0 . #13#)
                                                            (COND
                                                             ((EQL
                                                               (SPADCALL
                                                                |nprimes| 100
                                                                (QREFELT $ 13))
                                                               0)
                                                              (SEQ
                                                               (SPADCALL
                                                                "number of primes"
                                                                (QREFELT $ 82))
                                                               (EXIT
                                                                (SPADCALL
                                                                 (SPADCALL
                                                                  |nprimes|
                                                                  (QREFELT $
                                                                           83))
                                                                 (QREFELT $
                                                                          82))))))
                                                            (SEQ
                                                             (LETT |i| 1
                                                                   . #13#)
                                                             G190
                                                             (COND
                                                              ((QSGREATERP |i|
                                                                           |nsols|)
                                                               #14#))
                                                             (SEQ
                                                              (EXIT
                                                               (SEQ
                                                                (LETT |j| 1
                                                                      . #13#)
                                                                G190
                                                                (COND
                                                                 ((QSGREATERP
                                                                   |j| |m|)
                                                                  #14#))
                                                                (SEQ
                                                                 (LETT |mm|
                                                                       (SPADCALL
                                                                        |ve|
                                                                        |j|
                                                                        (QREFELT
                                                                         $ 75))
                                                                       . #13#)
                                                                 (LETT |cp|
                                                                       (SPADCALL
                                                                        |bm|
                                                                        |i| |j|
                                                                        (QREFELT
                                                                         $ 85))
                                                                       . #13#)
                                                                 (EXIT
                                                                  (SEQ
                                                                   (LETT |l| 0
                                                                         . #13#)
                                                                   G190
                                                                   (COND
                                                                    ((QSGREATERP
                                                                      |l| |mm|)
                                                                     #14#))
                                                                   (SEQ
                                                                    (SETELT32
                                                                     |rv| |k|
                                                                     (ELT32
                                                                      |cp|
                                                                      |l|))
                                                                    (EXIT
                                                                     (LETT |k|
                                                                           (+
                                                                            |k|
                                                                            1)
                                                                           . #13#)))
                                                                   (LETT |l|
                                                                         (QSADD1
                                                                          |l|)
                                                                         . #13#)
                                                                   #15# G191
                                                                   (EXIT
                                                                    NIL))))
                                                                (LETT |j|
                                                                      (QSADD1
                                                                       |j|)
                                                                      . #13#)
                                                                #15# G191
                                                                (EXIT NIL))))
                                                             (LETT |i|
                                                                   (QSADD1 |i|)
                                                                   . #13#)
                                                             #15# G191
                                                             (EXIT NIL))
                                                            (SPADCALL |rv|
                                                                      |prime|
                                                                      |rstate|
                                                                      (QREFELT
                                                                       $ 86))
                                                            (COND
                                                             (|empty_offsets|
                                                              (SEQ
                                                               (LETT |offsets|
                                                                     (MAKEARR1
                                                                      (PROG1
                                                                          (LETT
                                                                           #6#
                                                                           |nsols|
                                                                           . #13#)
                                                                        (|check-subtype|
                                                                         (>=
                                                                          #6#
                                                                          0)
                                                                         '(|NonNegativeInteger|)
                                                                         #6#))
                                                                      0)
                                                                     . #13#)
                                                               (LETT |j| 0
                                                                     . #13#)
                                                               (SEQ
                                                                (LETT |i| 1
                                                                      . #13#)
                                                                G190
                                                                (COND
                                                                 ((QSGREATERP
                                                                   |i| |nsols|)
                                                                  #14#))
                                                                (SEQ
                                                                 (SPADCALL
                                                                  |offsets| |i|
                                                                  |j|
                                                                  (QREFELT $
                                                                           87))
                                                                 (EXIT
                                                                  (LETT |j|
                                                                        (+ |j|
                                                                           |degs_sum|)
                                                                        . #13#)))
                                                                (LETT |i|
                                                                      (QSADD1
                                                                       |i|)
                                                                      . #13#)
                                                                #15# G191
                                                                (EXIT NIL))
                                                               (EXIT
                                                                (LETT
                                                                 |empty_offsets|
                                                                 'NIL
                                                                 . #13#)))))
                                                            (LETT |pp|
                                                                  (SPADCALL
                                                                   |rstate|
                                                                   |offsets|
                                                                   (QREFELT $
                                                                            89))
                                                                  . #13#)
                                                            (EXIT
                                                             (COND
                                                              ((QEQCAR |pp| 1)
                                                               "iterate")
                                                              ('T
                                                               (SEQ
                                                                (LETT |ppr|
                                                                      (QCDR
                                                                       |pp|)
                                                                      . #13#)
                                                                (LETT |k| 0
                                                                      . #13#)
                                                                (LETT |resv|
                                                                      (MAKEARR1
                                                                       (PROG1
                                                                           (LETT
                                                                            #5#
                                                                            |nsols|
                                                                            . #13#)
                                                                         (|check-subtype|
                                                                          (>=
                                                                           #5#
                                                                           0)
                                                                          '(|NonNegativeInteger|)
                                                                          #5#))
                                                                       (MAKE-ARRAY
                                                                        0))
                                                                      . #13#)
                                                                (LETT |ii| 1
                                                                      . #13#)
                                                                (LETT |sol_ok|
                                                                      'T
                                                                      . #13#)
                                                                (SEQ
                                                                 (EXIT
                                                                  (SEQ
                                                                   (LETT |i| 1
                                                                         . #13#)
                                                                   G190
                                                                   (COND
                                                                    ((QSGREATERP
                                                                      |i|
                                                                      |nsols|)
                                                                     #14#))
                                                                   (SEQ
                                                                    (LETT
                                                                     |resvi|
                                                                     (MAKEARR1
                                                                      |m|
                                                                      (|spadConstant|
                                                                       $ 90))
                                                                     . #13#)
                                                                    (SEQ
                                                                     (LETT |j|
                                                                           1
                                                                           . #13#)
                                                                     G190
                                                                     (COND
                                                                      ((QSGREATERP
                                                                        |j|
                                                                        |m|)
                                                                       #14#))
                                                                     (SEQ
                                                                      (LETT
                                                                       |mm|
                                                                       (SPADCALL
                                                                        |ve|
                                                                        |j|
                                                                        (QREFELT
                                                                         $ 75))
                                                                       . #13#)
                                                                      (LETT |s|
                                                                            (|spadConstant|
                                                                             $
                                                                             90)
                                                                            . #13#)
                                                                      (SEQ
                                                                       (LETT
                                                                        |l| 0
                                                                        . #13#)
                                                                       G190
                                                                       (COND
                                                                        ((QSGREATERP
                                                                          |l|
                                                                          |mm|)
                                                                         #14#))
                                                                       (SEQ
                                                                        (LETT
                                                                         |s|
                                                                         (SPADCALL
                                                                          |s|
                                                                          (SPADCALL
                                                                           (QAREF1
                                                                            |ppr|
                                                                            |k|)
                                                                           |l|
                                                                           (QREFELT
                                                                            $
                                                                            91))
                                                                          (QREFELT
                                                                           $
                                                                           92))
                                                                         . #13#)
                                                                        (EXIT
                                                                         (LETT
                                                                          |k|
                                                                          (+
                                                                           |k|
                                                                           1)
                                                                          . #13#)))
                                                                       (LETT
                                                                        |l|
                                                                        (QSADD1
                                                                         |l|)
                                                                        . #13#)
                                                                       #15#
                                                                       G191
                                                                       (EXIT
                                                                        NIL))
                                                                      (EXIT
                                                                       (SPADCALL
                                                                        |resvi|
                                                                        |j| |s|
                                                                        (QREFELT
                                                                         $
                                                                         93))))
                                                                     (LETT |j|
                                                                           (QSADD1
                                                                            |j|)
                                                                           . #13#)
                                                                     #15# G191
                                                                     (EXIT
                                                                      NIL))
                                                                    (LETT
                                                                     |sol_okp|
                                                                     (SPADCALL
                                                                      (SPADCALL
                                                                       |resvi|
                                                                       (QREFELT
                                                                        $ 95))
                                                                      |check|)
                                                                     . #13#)
                                                                    (EXIT
                                                                     (COND
                                                                      ((QEQCAR
                                                                        |sol_okp|
                                                                        1)
                                                                       "iterate")
                                                                      ((QEQCAR
                                                                        |sol_okp|
                                                                        2)
                                                                       (SEQ
                                                                        (LETT
                                                                         |sol_ok|
                                                                         'NIL
                                                                         . #13#)
                                                                        (EXIT
                                                                         (PROGN
                                                                          (LETT
                                                                           #4#
                                                                           |$NoValue|
                                                                           . #13#)
                                                                          (GO
                                                                           #4#)))))
                                                                      ('T
                                                                       (SEQ
                                                                        (SPADCALL
                                                                         |resv|
                                                                         |ii|
                                                                         |resvi|
                                                                         (QREFELT
                                                                          $
                                                                          97))
                                                                        (EXIT
                                                                         (LETT
                                                                          |ii|
                                                                          (+
                                                                           |ii|
                                                                           1)
                                                                          . #13#)))))))
                                                                   (LETT |i|
                                                                         (QSADD1
                                                                          |i|)
                                                                         . #13#)
                                                                   #15# G191
                                                                   (EXIT NIL)))
                                                                 #4#
                                                                 (EXIT #4#))
                                                                (EXIT
                                                                 (COND
                                                                  (|sol_ok|
                                                                   (SEQ
                                                                    (LETT
                                                                     |mress|
                                                                     (SPADCALL
                                                                      |m|
                                                                      (PROG1
                                                                          (LETT
                                                                           #3#
                                                                           (-
                                                                            |ii|
                                                                            1)
                                                                           . #13#)
                                                                        (|check-subtype|
                                                                         (>=
                                                                          #3#
                                                                          0)
                                                                         '(|NonNegativeInteger|)
                                                                         #3#))
                                                                      (|spadConstant|
                                                                       $ 90)
                                                                      (QREFELT
                                                                       $ 99))
                                                                     . #13#)
                                                                    (SEQ
                                                                     (LETT |i|
                                                                           1
                                                                           . #13#)
                                                                     (LETT #2#
                                                                           (-
                                                                            |ii|
                                                                            1)
                                                                           . #13#)
                                                                     G190
                                                                     (COND
                                                                      ((QSGREATERP
                                                                        |i|
                                                                        #2#)
                                                                       #14#))
                                                                     (SEQ
                                                                      (EXIT
                                                                       (SEQ
                                                                        (LETT
                                                                         |l| 1
                                                                         . #13#)
                                                                        G190
                                                                        (COND
                                                                         ((QSGREATERP
                                                                           |l|
                                                                           |m|)
                                                                          #14#))
                                                                        (SEQ
                                                                         (EXIT
                                                                          (SPADCALL
                                                                           |mress|
                                                                           |l|
                                                                           |i|
                                                                           (SPADCALL
                                                                            (SPADCALL
                                                                             |resv|
                                                                             |i|
                                                                             (QREFELT
                                                                              $
                                                                              100))
                                                                            |l|
                                                                            (QREFELT
                                                                             $
                                                                             16))
                                                                           (QREFELT
                                                                            $
                                                                            101))))
                                                                        (LETT
                                                                         |l|
                                                                         (QSADD1
                                                                          |l|)
                                                                         . #13#)
                                                                        #15#
                                                                        G191
                                                                        (EXIT
                                                                         NIL))))
                                                                     (LETT |i|
                                                                           (QSADD1
                                                                            |i|)
                                                                           . #13#)
                                                                     #15# G191
                                                                     (EXIT
                                                                      NIL))
                                                                    (EXIT
                                                                     (PROGN
                                                                      (LETT #1#
                                                                            (CONS
                                                                             0
                                                                             |mress|)
                                                                            . #13#)
                                                                      (GO
                                                                       #1#)))))))))))))))))))))))))))))
                        ('T (|error| "Run out of primes")))))
                 NIL #15# G191 (EXIT NIL))
            (EXIT (PROGN (LETT #1# (CONS 1 'T) . #13#) (GO #1#)))))
      #1# (EXIT #1#))))) 

(DEFUN |MODHP;get_variables2| (|llpi| $)
  (PROG (|res| #1=#:G2029 |p| #2=#:G2028 |lpi|)
    (RETURN
     (SEQ (LETT |res| NIL . #3=(|MODHP;get_variables2|))
          (SEQ (LETT |lpi| NIL . #3#) (LETT #2# |llpi| . #3#) G190
               (COND
                ((OR (ATOM #2#) (PROGN (LETT |lpi| (CAR #2#) . #3#) NIL))
                 #4=(GO G191)))
               (SEQ
                (EXIT
                 (SEQ (LETT |p| NIL . #3#) (LETT #1# |lpi| . #3#) G190
                      (COND
                       ((OR (ATOM #1#) (PROGN (LETT |p| (CAR #1#) . #3#) NIL))
                        #4#))
                      (SEQ
                       (LETT |res|
                             (SPADCALL |res|
                                       (SPADCALL (SPADCALL |p| (QREFELT $ 44))
                                                 (QREFELT $ 106))
                                       (QREFELT $ 107))
                             . #3#)
                       (EXIT
                        (LETT |res|
                              (SPADCALL |res|
                                        (SPADCALL (SPADCALL |p| (QREFELT $ 45))
                                                  (QREFELT $ 106))
                                        (QREFELT $ 107))
                              . #3#)))
                      (LETT #1# (CDR #1#) . #3#) #5=(GO G190) G191
                      (EXIT NIL))))
               (LETT #2# (CDR #2#) . #3#) #5# G191 (EXIT NIL))
          (EXIT |res|))))) 

(DEFUN |MODHP;unpack_poly| (|vars| |exps| |coeffs| |lo| |hi| $)
  (PROG (|res| #1=#:G2039 |i| |term| |term1| #2=#:G2033 |k| #3=#:G2042 |var|
         |j| #4=#:G2031 |jj| |i0| |nn| |nvars|)
    (RETURN
     (SEQ (LETT |res| (|spadConstant| $ 108) . #5=(|MODHP;unpack_poly|))
          (LETT |nvars| (LENGTH |vars|) . #5#) (LETT |nn| (+ |nvars| 1) . #5#)
          (LETT |vars| (REVERSE |vars|) . #5#) (LETT |j| -1 . #5#)
          (LETT |i| (* |lo| |nn|) . #5#)
          (SEQ (LETT |i0| |lo| . #5#) G190 (COND ((> |i0| |hi|) #6=(GO G191)))
               (SEQ (LETT |jj| (SPADCALL |exps| |i| (QREFELT $ 111)) . #5#)
                    (EXIT
                     (COND
                      ((< |jj| |j|)
                       (|error|
                        "Internal error: inconsistent exponent vector"))
                      ('T
                       (SEQ
                        (COND
                         ((< |j| |jj|)
                          (SEQ
                           (COND
                            ((NULL (< |j| 0))
                             (LETT |res|
                                   (SPADCALL |res|
                                             (SPADCALL |term|
                                                       (PROG1
                                                           (LETT #4# |j| . #5#)
                                                         (|check-subtype|
                                                          (>= #4# 0)
                                                          '(|NonNegativeInteger|)
                                                          #4#))
                                                       (QREFELT $ 112))
                                             (QREFELT $ 113))
                                   . #5#)))
                           (LETT |j| |jj| . #5#)
                           (EXIT (LETT |term| (|spadConstant| $ 114) . #5#)))))
                        (LETT |term1|
                              (SPADCALL (QAREF1 |coeffs| |i0|) (QREFELT $ 115))
                              . #5#)
                        (SEQ (LETT |var| NIL . #5#) (LETT #3# |vars| . #5#)
                             (LETT |k| 1 . #5#) G190
                             (COND
                              ((OR (QSGREATERP |k| |nvars|) (ATOM #3#)
                                   (PROGN (LETT |var| (CAR #3#) . #5#) NIL))
                               #6#))
                             (SEQ
                              (EXIT
                               (LETT |term1|
                                     (SPADCALL |term1|
                                               (SPADCALL (|spadConstant| $ 116)
                                                         |var|
                                                         (PROG1
                                                             (LETT #2#
                                                                   (SPADCALL
                                                                    |exps|
                                                                    (+ |i| |k|)
                                                                    (QREFELT $
                                                                             111))
                                                                   . #5#)
                                                           (|check-subtype|
                                                            (>= #2# 0)
                                                            '(|NonNegativeInteger|)
                                                            #2#))
                                                         (QREFELT $ 117))
                                               (QREFELT $ 118))
                                     . #5#)))
                             (LETT |k|
                                   (PROG1 (QSADD1 |k|)
                                     (LETT #3# (CDR #3#) . #5#))
                                   . #5#)
                             #7=(GO G190) G191 (EXIT NIL))
                        (LETT |term| (SPADCALL |term1| |term| (QREFELT $ 119))
                              . #5#)
                        (EXIT (LETT |i| (+ |i| |nn|) . #5#)))))))
               (LETT |i0| (+ |i0| 1) . #5#) #7# G191 (EXIT NIL))
          (COND
           ((NULL (< |j| 0))
            (LETT |res|
                  (SPADCALL |res|
                            (SPADCALL |term|
                                      (PROG1 (LETT #1# |j| . #5#)
                                        (|check-subtype| (>= #1# 0)
                                                         '(|NonNegativeInteger|)
                                                         #1#))
                                      (QREFELT $ 112))
                            (QREFELT $ 113))
                  . #5#)))
          (EXIT |res|))))) 

(DEFUN |MODHP;intpoly_to_PFPI| (|p| $)
  (SPADCALL (ELT $ 120) |p| (QREFELT $ 124))) 

(DEFUN |MODHP;PFPI_to_PFI| (|p| $)
  (PROG (|res| |iq| |q| |m|)
    (RETURN
     (SEQ (LETT |res| (|spadConstant| $ 66) . #1=(|MODHP;PFPI_to_PFI|))
          (SEQ G190
               (COND
                ((NULL (COND ((SPADCALL |p| (QREFELT $ 125)) 'NIL) ('T 'T)))
                 (GO G191)))
               (SEQ (LETT |m| (SPADCALL |p| (QREFELT $ 126)) . #1#)
                    (LETT |q| (SPADCALL |p| (QREFELT $ 127)) . #1#)
                    (LETT |p| (SPADCALL |p| (QREFELT $ 128)) . #1#)
                    (LETT |iq| (SPADCALL |q| (QREFELT $ 129)) . #1#)
                    (EXIT
                     (LETT |res|
                           (SPADCALL (SPADCALL |iq| |m| (QREFELT $ 130)) |res|
                                     (QREFELT $ 131))
                           . #1#)))
               NIL (GO G190) G191 (EXIT NIL))
          (EXIT |res|))))) 

(DEFUN |MODHP;PI_to_PPI| (|p| $)
  (PROG (|res| |mq| |q| |m|)
    (RETURN
     (SEQ (LETT |res| (|spadConstant| $ 108) . #1=(|MODHP;PI_to_PPI|))
          (SEQ G190
               (COND
                ((NULL (COND ((SPADCALL |p| (QREFELT $ 10)) 'NIL) ('T 'T)))
                 (GO G191)))
               (SEQ (LETT |m| (SPADCALL |p| (QREFELT $ 8)) . #1#)
                    (LETT |q| (SPADCALL |p| (QREFELT $ 12)) . #1#)
                    (LETT |p| (SPADCALL |p| (QREFELT $ 14)) . #1#)
                    (LETT |mq| (SPADCALL |q| (QREFELT $ 115)) . #1#)
                    (EXIT
                     (LETT |res|
                           (SPADCALL (SPADCALL |mq| |m| (QREFELT $ 112)) |res|
                                     (QREFELT $ 113))
                           . #1#)))
               NIL (GO G190) G191 (EXIT NIL))
          (EXIT |res|))))) 

(DEFUN |MODHP;LPI_to_LPPI| (|lp| $)
  (PROG (#1=#:G2058 |p| #2=#:G2057)
    (RETURN
     (SEQ
      (PROGN
       (LETT #2# NIL . #3=(|MODHP;LPI_to_LPPI|))
       (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 (|MODHP;PI_to_PPI| |p| $) #2#) . #3#)))
            (LETT #1# (CDR #1#) . #3#) (GO G190) G191
            (EXIT (NREVERSE0 #2#)))))))) 

(DEFUN |MODHP;trivial_poly_solve|
       (|list| |degs| |kind| |sigma| |gen| |check| $)
  (PROG (|j| |i| |res| |nc| |nr| |resi| #1=#:G2081 |pres| |nlist| #2=#:G2085
         |q| #3=#:G2084 #4=#:G2083 |li| #5=#:G2082)
    (RETURN
     (SEQ
      (EXIT
       (COND
        ((EQUAL |kind| '|qshiftHP|)
         (PROGN
          (LETT #1# (CONS 1 'T) . #6=(|MODHP;trivial_poly_solve|))
          (GO #1#)))
        (#7='T
         (SEQ (COND ((EQUAL |kind| '|qdiffHP|) (LETT |kind| '|diffHP| . #6#)))
              (LETT |nlist|
                    (PROGN
                     (LETT #5# NIL . #6#)
                     (SEQ (LETT |li| NIL . #6#) (LETT #4# |list| . #6#) G190
                          (COND
                           ((OR (ATOM #4#)
                                (PROGN (LETT |li| (CAR #4#) . #6#) NIL))
                            #8=(GO G191)))
                          (SEQ
                           (EXIT
                            (LETT #5#
                                  (CONS
                                   (PROGN
                                    (LETT #3# NIL . #6#)
                                    (SEQ (LETT |q| NIL . #6#)
                                         (LETT #2# |li| . #6#) G190
                                         (COND
                                          ((OR (ATOM #2#)
                                               (PROGN
                                                (LETT |q| (CAR #2#) . #6#)
                                                NIL))
                                           #8#))
                                         (SEQ
                                          (EXIT
                                           (LETT #3#
                                                 (CONS
                                                  (SPADCALL |q|
                                                            (QREFELT $ 129))
                                                  #3#)
                                                 . #6#)))
                                         (LETT #2# (CDR #2#) . #6#)
                                         #9=(GO G190) G191
                                         (EXIT (NREVERSE0 #3#))))
                                   #5#)
                                  . #6#)))
                          (LETT #4# (CDR #4#) . #6#) #9# G191
                          (EXIT (NREVERSE0 #5#))))
                    . #6#)
              (LETT |pres|
                    (SPADCALL |nlist| |degs| |kind| |sigma| |gen|
                              (CONS #'|MODHP;trivial_poly_solve!0|
                                    (VECTOR |check| $))
                              (QREFELT $ 105))
                    . #6#)
              (EXIT
               (COND
                ((QEQCAR |pres| 1)
                 (PROGN (LETT #1# (CONS 1 (QCDR |pres|)) . #6#) (GO #1#)))
                (#7#
                 (SEQ (LETT |resi| (QCDR |pres|) . #6#)
                      (LETT |nr| (QVSIZE |resi|) . #6#)
                      (LETT |nc| (SPADCALL |resi| (QREFELT $ 132)) . #6#)
                      (LETT |res|
                            (SPADCALL |nr| |nc| (|spadConstant| $ 108)
                                      (QREFELT $ 134))
                            . #6#)
                      (SEQ (LETT |i| 1 . #6#) G190
                           (COND ((QSGREATERP |i| |nr|) #8#))
                           (SEQ
                            (EXIT
                             (SEQ (LETT |j| 1 . #6#) G190
                                  (COND ((QSGREATERP |j| |nc|) #8#))
                                  (SEQ
                                   (EXIT
                                    (SPADCALL |res| |i| |j|
                                              (|MODHP;PI_to_PPI|
                                               (SPADCALL |resi| |i| |j|
                                                         (QREFELT $ 135))
                                               $)
                                              (QREFELT $ 136))))
                                  (LETT |j| (QSADD1 |j|) . #6#) #9# G191
                                  (EXIT NIL))))
                           (LETT |i| (QSADD1 |i|) . #6#) #9# G191 (EXIT NIL))
                      (EXIT (CONS 0 |res|))))))))))
      #1# (EXIT #1#))))) 

(DEFUN |MODHP;trivial_poly_solve!0| (|x| $$)
  (PROG ($ |check|)
    (LETT $ (QREFELT $$ 1) . #1=(|MODHP;trivial_poly_solve|))
    (LETT |check| (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (SPADCALL (|MODHP;LPI_to_LPPI| |x| $) |check|))))) 

(DEFUN |MODHP;get_variables;L2SL;19| (|list| |kind| |qvar| $)
  (PROG (|vars|)
    (RETURN
     (SEQ
      (LETT |vars| (|MODHP;get_variables2| |list| $)
            . #1=(|MODHP;get_variables;L2SL;19|))
      (COND
       ((OR (EQUAL |kind| '|qdiffHP|)
            (OR (EQUAL |kind| '|qshiftHP|) (EQUAL |kind| '|qmixed|)))
        (LETT |vars|
              (COND ((SPADCALL |qvar| |vars| (QREFELT $ 137)) |vars|)
                    ('T (CONS |qvar| |vars|)))
              . #1#)))
      (EXIT (REVERSE (SPADCALL |vars| (QREFELT $ 138)))))))) 

(DEFUN |MODHP;HP_solve_P;LL2SNniMMU;20|
       (|list| |degs| |kind| |qvar| |sigma| |gen| |check| $)
  (PROG (#1=#:G2151 |l| #2=#:G2157 |i| |mress| #3=#:G2137 |ii| #4=#:G2136 |ok|
         |sol_okp| |hi| |ohi| |kk| |lo| |j| |resvi| |resv| |nsols| |cc|
         |coeffs| |exps| |oc| |offsets| |ppr| |pp| |gv0| #5=#:G2156 |li|
         #6=#:G2155 |vars| |pts| #7=#:G2103 #8=#:G2154 |pts0| |ve| #9=#:G2153
         |d| #10=#:G2152 |m| |lp|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |lp| NIL . #11=(|MODHP;HP_solve_P;LL2SNniMMU;20|))
            (LETT |m| (LENGTH |degs|) . #11#)
            (LETT |ve|
                  (SPADCALL
                   (PROGN
                    (LETT #10# NIL . #11#)
                    (SEQ (LETT |d| NIL . #11#) (LETT #9# |degs| . #11#) G190
                         (COND
                          ((OR (ATOM #9#)
                               (PROGN (LETT |d| (CAR #9#) . #11#) NIL))
                           #12=(GO G191)))
                         (SEQ (EXIT (LETT #10# (CONS |d| #10#) . #11#)))
                         (LETT #9# (CDR #9#) . #11#) #13=(GO G190) G191
                         (EXIT (NREVERSE0 #10#))))
                   (QREFELT $ 65))
                  . #11#)
            (LETT |pts|
                  (SEQ
                   (EXIT
                    (COND
                     ((OR (EQUAL |kind| '|diffHP|) (EQUAL |kind| '|qdiffHP|))
                      (GETREFV32 0 0))
                     ((OR (EQUAL |kind| '|shiftHP|) (EQUAL |kind| '|qmixed|))
                      (SEQ (LETT |pts0| (GETREFV32 |sigma| 0) . #11#)
                           (SEQ (LETT |i| 0 . #11#)
                                (LETT #8# (- |sigma| 1) . #11#) G190
                                (COND ((QSGREATERP |i| #8#) #12#))
                                (SEQ (EXIT (SETELT32 |pts0| |i| |i|)))
                                (LETT |i| (QSADD1 |i|) . #11#) #13# G191
                                (EXIT NIL))
                           (EXIT |pts0|)))
                     ('T
                      (COND
                       ((EQUAL |kind| '|qshiftHP|)
                        (PROGN
                         (LETT #7# (GETREFV32 |sigma| 0) . #11#)
                         (GO #7#)))))))
                   #7# (EXIT #7#))
                  . #11#)
            (LETT |vars| (|MODHP;get_variables2| |list| $) . #11#)
            (COND
             ((OR (EQUAL |kind| '|qdiffHP|)
                  (OR (EQUAL |kind| '|qshiftHP|) (EQUAL |kind| '|qmixed|)))
              (LETT |vars|
                    (COND ((SPADCALL |qvar| |vars| (QREFELT $ 137)) |vars|)
                          (#14='T (CONS |qvar| |vars|)))
                    . #11#)))
            (EXIT
             (COND
              ((NULL |vars|)
               (|MODHP;trivial_poly_solve| |list| |degs| |kind| |sigma| |gen|
                |check| $))
              (#14#
               (SEQ
                (LETT |gv0|
                      (PROGN
                       (LETT #6# NIL . #11#)
                       (SEQ (LETT |li| NIL . #11#) (LETT #5# |list| . #11#)
                            G190
                            (COND
                             ((OR (ATOM #5#)
                                  (PROGN (LETT |li| (CAR #5#) . #11#) NIL))
                              #12#))
                            (SEQ
                             (EXIT
                              (LETT #6#
                                    (CONS (SPADCALL |li| (QREFELT $ 142)) #6#)
                                    . #11#)))
                            (LETT #5# (CDR #5#) . #11#) #13# G191
                            (EXIT (NREVERSE0 #6#))))
                      . #11#)
                (EXIT
                 (SEQ G190 NIL
                      (SEQ
                       (LETT |pp|
                             (SPADCALL |vars| |gv0| |ve| |sigma| |pts| |kind|
                                       |qvar| |gen| (QREFELT $ 146))
                             . #11#)
                       (EXIT
                        (COND
                         ((QEQCAR |pp| 1)
                          (PROGN (LETT #1# (CONS 1 'NIL) . #11#) (GO #1#)))
                         ('T
                          (SEQ (LETT |ppr| (QCDR |pp|) . #11#)
                               (LETT |offsets| (QVELT |ppr| 3) . #11#)
                               (LETT |oc| (QVSIZE |offsets|) . #11#)
                               (LETT |exps| (QVELT |ppr| 4) . #11#)
                               (LETT |coeffs| (QVELT |ppr| 5) . #11#)
                               (LETT |cc| (QVSIZE |coeffs|) . #11#)
                               (LETT |nsols| (QUOTIENT2 (QVSIZE |offsets|) |m|)
                                     . #11#)
                               (LETT |ok| 'T . #11#) (LETT |kk| 1 . #11#)
                               (LETT |ohi|
                                     (SPADCALL |offsets| 1 (QREFELT $ 75))
                                     . #11#)
                               (LETT |resv| (MAKEARR1 |nsols| (MAKE-ARRAY 0))
                                     . #11#)
                               (LETT |ii| 1 . #11#)
                               (SEQ
                                (EXIT
                                 (SEQ (LETT |i| 1 . #11#) G190
                                      (COND ((QSGREATERP |i| |nsols|) #12#))
                                      (SEQ
                                       (LETT |resvi|
                                             (MAKEARR1 |m|
                                                       (|spadConstant| $ 108))
                                             . #11#)
                                       (SEQ (LETT |j| 1 . #11#) G190
                                            (COND ((QSGREATERP |j| |m|) #12#))
                                            (SEQ (LETT |lo| |ohi| . #11#)
                                                 (LETT |ohi|
                                                       (SEQ
                                                        (LETT |kk| (+ |kk| 1)
                                                              . #11#)
                                                        (EXIT
                                                         (COND
                                                          ((< |oc| |kk|) |cc|)
                                                          ('T
                                                           (SPADCALL |offsets|
                                                                     |kk|
                                                                     (QREFELT $
                                                                              75))))))
                                                       . #11#)
                                                 (LETT |hi| (- |ohi| 1) . #11#)
                                                 (EXIT
                                                  (SPADCALL |resvi| |j|
                                                            (|MODHP;unpack_poly|
                                                             |vars| |exps|
                                                             |coeffs| |lo| |hi|
                                                             $)
                                                            (QREFELT $ 149))))
                                            (LETT |j| (QSADD1 |j|) . #11#) #13#
                                            G191 (EXIT NIL))
                                       (LETT |sol_okp|
                                             (SPADCALL
                                              (SPADCALL |resvi|
                                                        (QREFELT $ 151))
                                              |check|)
                                             . #11#)
                                       (EXIT
                                        (COND ((QEQCAR |sol_okp| 1) "iterate")
                                              ((QEQCAR |sol_okp| 2)
                                               (SEQ (LETT |ok| 'NIL . #11#)
                                                    (EXIT
                                                     (PROGN
                                                      (LETT #4# |$NoValue|
                                                            . #11#)
                                                      (GO #4#)))))
                                              ('T
                                               (SEQ
                                                (SPADCALL |resv| |ii| |resvi|
                                                          (QREFELT $ 153))
                                                (EXIT
                                                 (LETT |ii| (+ |ii| 1)
                                                       . #11#)))))))
                                      (LETT |i| (QSADD1 |i|) . #11#) #13# G191
                                      (EXIT NIL)))
                                #4# (EXIT #4#))
                               (EXIT
                                (COND
                                 (|ok|
                                  (SEQ
                                   (LETT |mress|
                                         (SPADCALL |m|
                                                   (PROG1
                                                       (LETT #3# (- |ii| 1)
                                                             . #11#)
                                                     (|check-subtype|
                                                      (>= #3# 0)
                                                      '(|NonNegativeInteger|)
                                                      #3#))
                                                   (|spadConstant| $ 108)
                                                   (QREFELT $ 134))
                                         . #11#)
                                   (SEQ (LETT |i| 1 . #11#)
                                        (LETT #2# (- |ii| 1) . #11#) G190
                                        (COND ((QSGREATERP |i| #2#) #12#))
                                        (SEQ
                                         (EXIT
                                          (SEQ (LETT |l| 1 . #11#) G190
                                               (COND
                                                ((QSGREATERP |l| |m|) #12#))
                                               (SEQ
                                                (EXIT
                                                 (SPADCALL |mress| |l| |i|
                                                           (SPADCALL
                                                            (SPADCALL |resv|
                                                                      |i|
                                                                      (QREFELT
                                                                       $ 154))
                                                            |l| (QREFELT $ 32))
                                                           (QREFELT $ 136))))
                                               (LETT |l| (QSADD1 |l|) . #11#)
                                               #13# G191 (EXIT NIL))))
                                        (LETT |i| (QSADD1 |i|) . #11#) #13#
                                        G191 (EXIT NIL))
                                   (EXIT
                                    (PROGN
                                     (LETT #1# (CONS 0 |mress|) . #11#)
                                     (GO #1#)))))
                                 ('T
                                  (SEQ
                                   (SPADCALL "check_sol_poly rejected solution"
                                             (QREFELT $ 82))
                                   (SPADCALL (SPADCALL |resvi| (QREFELT $ 155))
                                             (QREFELT $ 82))
                                   (EXIT (|error| "giving up")))))))))))
                      NIL #13# G191 (EXIT NIL)))))))))
      #1# (EXIT #1#))))) 

(DEFUN |MODHP;HP_solve_M;LLSINniMMU;21|
       (|list| |degs| |kind| |prime| |sigma| |gen| |check| $)
  (PROG (#1=#:G2188 |l| #2=#:G2194 |i| |mress| #3=#:G2183 |ii| |sol_okp| |s|
         |bmij| |mm| |j| |resvi| |resv| |nsols| |va| |bm| |rblr| |blr| |gv|
         |gv0| #4=#:G2193 |li| #5=#:G2192 |pts| #6=#:G2166 #7=#:G2191 |pts0|
         |ve| #8=#:G2190 |d| #9=#:G2189 |m| |lp|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |lp| NIL . #10=(|MODHP;HP_solve_M;LLSINniMMU;21|))
            (COND
             ((OR (EQUAL |kind| '|qdiffHP|) (EQUAL |kind| '|qshiftHP|))
              (EXIT (CONS 1 'T))))
            (LETT |m| (LENGTH |degs|) . #10#)
            (LETT |ve|
                  (SPADCALL
                   (PROGN
                    (LETT #9# NIL . #10#)
                    (SEQ (LETT |d| NIL . #10#) (LETT #8# |degs| . #10#) G190
                         (COND
                          ((OR (ATOM #8#)
                               (PROGN (LETT |d| (CAR #8#) . #10#) NIL))
                           #11=(GO G191)))
                         (SEQ (EXIT (LETT #9# (CONS |d| #9#) . #10#)))
                         (LETT #8# (CDR #8#) . #10#) #12=(GO G190) G191
                         (EXIT (NREVERSE0 #9#))))
                   (QREFELT $ 65))
                  . #10#)
            (LETT |pts|
                  (COND ((EQUAL |kind| '|diffHP|) (GETREFV32 0 0))
                        (#13='T
                         (SEQ
                          (EXIT
                           (COND
                            ((EQUAL |kind| '|shiftHP|)
                             (PROGN
                              (LETT #6#
                                    (SEQ
                                     (LETT |pts0| (GETREFV32 |sigma| 0) . #10#)
                                     (SEQ (LETT |i| 0 . #10#)
                                          (LETT #7# (- |sigma| 1) . #10#) G190
                                          (COND ((QSGREATERP |i| #7#) #11#))
                                          (SEQ
                                           (EXIT (SETELT32 |pts0| |i| |i|)))
                                          (LETT |i| (QSADD1 |i|) . #10#) #12#
                                          G191 (EXIT NIL))
                                     (EXIT |pts0|))
                                    . #10#)
                              (GO #6#)))))
                          #6# (EXIT #6#))))
                  . #10#)
            (LETT |gv0|
                  (PROGN
                   (LETT #5# NIL . #10#)
                   (SEQ (LETT |li| NIL . #10#) (LETT #4# |list| . #10#) G190
                        (COND
                         ((OR (ATOM #4#)
                              (PROGN (LETT |li| (CAR #4#) . #10#) NIL))
                          #11#))
                        (SEQ
                         (EXIT
                          (LETT #5# (CONS (SPADCALL |li| (QREFELT $ 159)) #5#)
                                . #10#)))
                        (LETT #4# (CDR #4#) . #10#) #12# G191
                        (EXIT (NREVERSE0 #5#))))
                  . #10#)
            (LETT |gv| (SPADCALL |gv0| |prime| 1 |gen|) . #10#)
            (LETT |blr|
                  (SPADCALL |gv| |ve| |sigma| |pts| |prime| |kind|
                            (QREFELT $ 74))
                  . #10#)
            (EXIT
             (COND
              ((QEQCAR |blr| 1)
               (PROGN (LETT #1# (CONS 1 'NIL) . #10#) (GO #1#)))
              (#13#
               (SEQ (LETT |rblr| (QCDR |blr|) . #10#)
                    (LETT |bm| (QVELT |rblr| 0) . #10#)
                    (LETT |va| (QVELT |rblr| 1) . #10#)
                    (LETT |nsols| (QVSIZE |va|) . #10#)
                    (LETT |resv| (MAKEARR1 |nsols| (MAKE-ARRAY 0)) . #10#)
                    (LETT |ii| 1 . #10#)
                    (SEQ (LETT |i| 1 . #10#) G190
                         (COND ((QSGREATERP |i| |nsols|) #11#))
                         (SEQ
                          (LETT |resvi| (MAKEARR1 |m| (|spadConstant| $ 90))
                                . #10#)
                          (SEQ (LETT |j| 1 . #10#) G190
                               (COND ((QSGREATERP |j| |m|) #11#))
                               (SEQ
                                (LETT |mm| (SPADCALL |ve| |j| (QREFELT $ 75))
                                      . #10#)
                                (LETT |bmij|
                                      (SPADCALL |bm| |i| |j| (QREFELT $ 85))
                                      . #10#)
                                (LETT |s| (|spadConstant| $ 90) . #10#)
                                (SEQ (LETT |l| 0 . #10#) G190
                                     (COND ((QSGREATERP |l| |mm|) #11#))
                                     (SEQ
                                      (EXIT
                                       (LETT |s|
                                             (SPADCALL |s|
                                                       (SPADCALL
                                                        (ELT32 |bmij| |l|) |l|
                                                        (QREFELT $ 91))
                                                       (QREFELT $ 92))
                                             . #10#)))
                                     (LETT |l| (QSADD1 |l|) . #10#) #12# G191
                                     (EXIT NIL))
                                (EXIT
                                 (SPADCALL |resvi| |j| |s| (QREFELT $ 93))))
                               (LETT |j| (QSADD1 |j|) . #10#) #12# G191
                               (EXIT NIL))
                          (LETT |sol_okp|
                                (SPADCALL (SPADCALL |resvi| (QREFELT $ 95))
                                          |check|)
                                . #10#)
                          (EXIT
                           (COND ((QEQCAR |sol_okp| 1) "iterate")
                                 ((QEQCAR |sol_okp| 2)
                                  (|error|
                                   "HPsolveM: check should never return nosolution for finite fields"))
                                 ('T
                                  (SEQ
                                   (SPADCALL |resv| |ii| |resvi|
                                             (QREFELT $ 97))
                                   (EXIT (LETT |ii| (+ |ii| 1) . #10#)))))))
                         (LETT |i| (QSADD1 |i|) . #10#) #12# G191 (EXIT NIL))
                    (LETT |mress|
                          (SPADCALL |m|
                                    (PROG1 (LETT #3# (- |ii| 1) . #10#)
                                      (|check-subtype| (>= #3# 0)
                                                       '(|NonNegativeInteger|)
                                                       #3#))
                                    (|spadConstant| $ 90) (QREFELT $ 99))
                          . #10#)
                    (SEQ (LETT |i| 1 . #10#) (LETT #2# (- |ii| 1) . #10#) G190
                         (COND ((QSGREATERP |i| #2#) #11#))
                         (SEQ
                          (EXIT
                           (SEQ (LETT |l| 1 . #10#) G190
                                (COND ((QSGREATERP |l| |m|) #11#))
                                (SEQ
                                 (EXIT
                                  (SPADCALL |mress| |l| |i|
                                            (SPADCALL
                                             (SPADCALL |resv| |i|
                                                       (QREFELT $ 100))
                                             |l| (QREFELT $ 16))
                                            (QREFELT $ 101))))
                                (LETT |l| (QSADD1 |l|) . #10#) #12# G191
                                (EXIT NIL))))
                         (LETT |i| (QSADD1 |i|) . #10#) #12# G191 (EXIT NIL))
                    (EXIT
                     (PROGN (LETT #1# (CONS 0 |mress|) . #10#) (GO #1#)))))))))
      #1# (EXIT #1#))))) 

(DEFUN |MODHP;HP_solve_A;LLSNniMMU;22|
       (|list| |degs| |kind| |sigma| |gen| |check| $)
  (CONS 1 'T)) 

(DEFUN |MODHP;HP_solve_PA;LL2SNniMMU;23|
       (|list| |degs| |kind| |qvar| |sigma| |gen| |check| $)
  (CONS 1 'T)) 

(DEFUN |ModularHermitePade| #1=()
  (PROG #1#
    (RETURN
     (PROG (#2=#:G2212)
       (RETURN
        (COND
         ((LETT #2# (HGET |$ConstructorCache| '|ModularHermitePade|)
                . #3=(|ModularHermitePade|))
          (|CDRwithIncrement| (CDAR #2#)))
         ('T
          (UNWIND-PROTECT
              (PROG1
                  (CDDAR
                   (HPUT |$ConstructorCache| '|ModularHermitePade|
                         (LIST (CONS NIL (CONS 1 (|ModularHermitePade;|))))))
                (LETT #2# T . #3#))
            (COND
             ((NOT #2#)
              (HREM |$ConstructorCache| '|ModularHermitePade|))))))))))) 

(DEFUN |ModularHermitePade;| ()
  (PROG (|dv$| $ |pv$|)
    (RETURN
     (PROGN
      (LETT |dv$| '(|ModularHermitePade|) . #1=(|ModularHermitePade|))
      (LETT $ (GETREFV 170) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
      (|haddProp| |$ConstructorCache| '|ModularHermitePade| NIL (CONS 1 $))
      (|stuffDomainSlots| $)
      (SETF |pv$| (QREFELT $ 3))
      $)))) 

(MAKEPROP '|ModularHermitePade| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|NonNegativeInteger|)
              (|SparseUnivariatePolynomial| 11) (0 . |degree|) (|Boolean|)
              (5 . |zero?|) (|Integer|) (10 . |leadingCoefficient|)
              (15 . |positiveRemainder|) (21 . |reductum|) (|Vector| 7)
              (26 . |elt|) (|U32Vector|) (|Vector| 17) (32 . |setelt|)
              |MODHP;VSUPI_to_VPA;VIV;2| (|SparseUnivariatePolynomial| 24)
              (39 . |degree|) (44 . |zero?|) (|Polynomial| 11)
              (49 . |leadingCoefficient|) (|List| 73) (|List| 11)
              (|InnerModularHermitePade|) (54 . |modpeval|) (62 . |reductum|)
              (|Vector| 21) (67 . |elt|) |MODHP;VSUPPI_to_VPA;VLLIV;4|
              (|Fraction| 11) (73 . |Zero|) (77 . |numer|) (82 . |denom|)
              (|SingleInteger|) (87 . |invmod|) (|Union| 58 '"failed")
              (|List| (|List| 34)) |MODHP;LLFI_to_LPA;L2IU;5| (|Fraction| 24)
              (93 . |numer|) (98 . |denom|) (|List| 140)
              |MODHP;LLFPI_to_LPA;LILLIU;6| (103 . |coerce|)
              (|SparseUnivariatePolynomial| 34) (|Mapping| 34 11)
              (|SparseUnivariatePolynomialFunctions2| 11 34) (108 . |map|)
              (114 . |elt|) (120 . |One|) (|Void|)
              (|U32VectorPolynomialOperations|) (124 . |truncated_mul_add|)
              (|List| 17) (|Mapping| 18 58 11 11)
              |MODHP;check_sol1a;VLM3IUv;10| (133 . +) (|Mapping| 11 11 11)
              (139 . |reduce|) (|Vector| 11) (145 . |vector|) (150 . |Zero|)
              (|IntegerPrimesPackage| 11) (154 . |nextPrime|) (159 . |member?|)
              (165 . |coerce|)
              (|Record| (|:| |basis| 84) (|:| |defects| 64) (|:| |cinds| 64))
              (|Union| 71 '"no_solution") (|Symbol|) (170 . |do_modular_solve|)
              (180 . |elt|) (|VectorIntegerReconstructor|) (186 . |empty|)
              (|PositiveInteger|) (191 . *) (|OutputForm|) (|PrintPackage|)
              (197 . |print|) (202 . |coerce|) (|TwoDimensionalArray| 17)
              (207 . |elt|) (214 . |chinese_update|) (221 . |setelt|)
              (|Union| (|PrimitiveArray| 11) '"failed") (228 . |reconstruct|)
              (234 . |Zero|) (238 . |monomial|) (244 . +) (250 . |setelt|)
              (|List| 7) (257 . |entries|) (|Vector| 15) (262 . |setelt|)
              (|Matrix| 7) (269 . |new|) (276 . |elt|) (282 . |setelt|)
              (|Union| 98 9) (|Union| '"good" '"reject" '"no_solution")
              (|Mapping| 103 94) |MODHP;HP_solve_I;LLSNniMMU;11|
              (290 . |variables|) (295 . |setUnion|) (301 . |Zero|)
              (305 . |One|) (|SortedExponentVector|) (309 . |elt|)
              (315 . |monomial|) (321 . +) (327 . |Zero|) (331 . |coerce|)
              (336 . |One|) (340 . |monomial|) (347 . *) (353 . +)
              (359 . |coerce|) (|SparseUnivariatePolynomial| 43)
              (|Mapping| 43 24) (|SparseUnivariatePolynomialFunctions2| 24 43)
              (364 . |map|) (370 . |zero?|) (375 . |degree|)
              (380 . |leadingCoefficient|) (385 . |reductum|) (390 . |retract|)
              (395 . |monomial|) (401 . +) (407 . |ncols|) (|Matrix| 21)
              (412 . |new|) (419 . |elt|) (426 . |setelt|) (434 . |member?|)
              (440 . |sort|) |MODHP;get_variables;L2SL;19| (|List| 43)
              (|PrimitiveArray| 43) (445 . |construct|)
              (|Record| (|:| |defects| 64) (|:| |cinds| 64) (|:| |rowlen| 11)
                        (|:| |offsetdata| 64) (|:| |expdata| 110)
                        (|:| |coeffdata| (|PrimitiveArray| 11)))
              (|Union| 143 '"no_solution") (|List| 141)
              (450 . |do_poly_integer|) (462 . |One|) (466 . |One|)
              (470 . |setelt|) (|List| 21) (477 . |entries|) (|Vector| 31)
              (482 . |setelt|) (489 . |elt|) (495 . |coerce|) (|Union| 133 9)
              (|Mapping| 103 150) |MODHP;HP_solve_P;LL2SNniMMU;20|
              (500 . |construct|) (|List| 27) |MODHP;HP_solve_M;LLSINniMMU;21|
              (|Union|
               (|Matrix| (|SparseUnivariatePolynomial| (|AlgebraicNumber|))) 9)
              (|List| (|List| (|AlgebraicNumber|)))
              (|Mapping| 103
                         (|List|
                          (|SparseUnivariatePolynomial| (|AlgebraicNumber|))))
              |MODHP;HP_solve_A;LLSNniMMU;22|
              (|Union|
               (|Matrix|
                (|SparseUnivariatePolynomial|
                 (|Polynomial| (|AlgebraicNumber|))))
               9)
              (|List| (|List| (|Fraction| (|Polynomial| (|AlgebraicNumber|)))))
              (|Mapping| 103
                         (|List|
                          (|SparseUnivariatePolynomial|
                           (|Polynomial| (|AlgebraicNumber|)))))
              |MODHP;HP_solve_PA;LL2SNniMMU;23|)
           '#(|get_variables| 505 |check_sol1a| 512 |VSUPPI_to_VPA| 522
              |VSUPI_to_VPA| 530 |LLFPI_to_LPA| 536 |LLFI_to_LPA| 545
              |HP_solve_PA| 552 |HP_solve_P| 563 |HP_solve_M| 574 |HP_solve_I|
              585 |HP_solve_A| 595)
           'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 169
                                                 '(1 7 6 0 8 1 7 9 0 10 1 7 11
                                                   0 12 2 11 0 0 0 13 1 7 0 0
                                                   14 2 15 7 0 11 16 3 18 17 0
                                                   11 17 19 1 21 6 0 22 1 21 9
                                                   0 23 1 21 24 0 25 4 28 11 24
                                                   26 27 11 29 1 21 0 0 30 2 31
                                                   21 0 11 32 0 34 0 35 1 34 11
                                                   0 36 1 34 11 0 37 2 38 0 0 0
                                                   39 1 43 24 0 44 1 43 24 0 45
                                                   1 34 0 11 48 2 51 49 50 7 52
                                                   2 18 17 0 11 53 0 49 0 54 5
                                                   56 55 17 17 17 11 11 57 2 11
                                                   0 0 0 61 2 27 11 62 0 63 1
                                                   64 0 27 65 0 49 0 66 1 67 11
                                                   11 68 2 27 9 11 0 69 1 38 0
                                                   11 70 6 28 72 18 64 6 17 11
                                                   73 74 2 64 11 0 11 75 1 76 0
                                                   11 77 2 6 0 78 0 79 1 81 55
                                                   80 82 1 11 80 0 83 3 84 17 0
                                                   11 11 85 3 76 55 17 11 0 86
                                                   3 64 11 0 11 11 87 2 76 88 0
                                                   64 89 0 7 0 90 2 7 0 11 6 91
                                                   2 7 0 0 0 92 3 15 7 0 11 7
                                                   93 1 15 94 0 95 3 96 15 0 11
                                                   15 97 3 98 0 6 6 7 99 2 96
                                                   15 0 11 100 4 98 7 0 11 11 7
                                                   101 1 24 26 0 106 2 26 0 0 0
                                                   107 0 21 0 108 0 21 0 109 2
                                                   110 11 0 11 111 2 21 0 24 6
                                                   112 2 21 0 0 0 113 0 24 0
                                                   114 1 24 0 11 115 0 24 0 116
                                                   3 24 0 0 73 6 117 2 24 0 0 0
                                                   118 2 24 0 0 0 119 1 43 0 24
                                                   120 2 123 121 122 21 124 1
                                                   121 9 0 125 1 121 6 0 126 1
                                                   121 43 0 127 1 121 0 0 128 1
                                                   43 34 0 129 2 49 0 34 6 130
                                                   2 49 0 0 0 131 1 98 6 0 132
                                                   3 133 0 6 6 21 134 3 98 7 0
                                                   11 11 135 4 133 21 0 11 11
                                                   21 136 2 26 9 73 0 137 1 26
                                                   0 0 138 1 141 0 140 142 8 28
                                                   144 26 145 64 6 17 73 73 59
                                                   146 0 121 0 147 0 43 0 148 3
                                                   31 21 0 11 21 149 1 31 150 0
                                                   151 3 152 31 0 11 31 153 2
                                                   152 31 0 11 154 1 31 80 0
                                                   155 1 17 0 27 159 3 0 26 46
                                                   73 73 139 6 0 17 18 58 59 11
                                                   11 11 60 4 0 18 31 26 27 11
                                                   33 2 0 18 15 11 20 5 0 40 46
                                                   11 26 27 11 47 3 0 40 41 11
                                                   11 42 7 0 166 167 27 73 73 6
                                                   59 168 169 7 0 156 46 27 73
                                                   73 6 59 157 158 7 0 102 160
                                                   27 73 11 6 59 104 161 6 0
                                                   102 41 27 73 6 59 104 105 6
                                                   0 162 163 27 73 6 59 164
                                                   165)))))
           '|lookupComplete|)) 

(MAKEPROP '|ModularHermitePade| 'NILADIC T) 
