
(/VERSIONCHECK 2) 

(DEFUN |IMODHP;eval1a| (|pol| |pt| |pss| $)
  (PROG (|res| |pk| |ptk| |ki| |j| |i| |t1| |n| |exps| |nexps| |coeffs|
         |ncoeffs| |nn| #1=#:G1843 |t0| |ns| |polu| #2=#:G1842 |polr| |p|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |p| (QVELT |pss| 5) . #3=(|IMODHP;eval1a|))
            (LETT |polr| |pol| . #3#)
            (EXIT
             (COND
              ((QEQCAR |polr| 0)
               (PROGN (LETT #2# (QCDR |polr|) . #3#) (GO #2#)))
              ('T
               (SEQ (LETT |polu| (QCDR (QCDR |polr|)) . #3#) (LETT |i| 0 . #3#)
                    (LETT |coeffs| (QVELT |pss| 11) . #3#)
                    (LETT |exps| (QVELT |pss| 12) . #3#)
                    (LETT |n| (QV32LEN |coeffs|) . #3#) (LETT |ns| |n| . #3#)
                    (SEQ (LETT |t0| NIL . #3#) (LETT #1# |polu| . #3#) G190
                         (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |t0| (CAR #1#) . #3#) NIL))
                           #4=(GO G191)))
                         (SEQ
                          (COND
                           ((NULL (< |i| |n|))
                            (SEQ
                             (LETT |nn| (SPADCALL 2 |n| (QREFELT $ 8)) . #3#)
                             (LETT |ncoeffs| (GETREFV32 |nn| 0) . #3#)
                             (SPADCALL |ncoeffs| |coeffs| |n| (QREFELT $ 13))
                             (LETT |coeffs| |ncoeffs| . #3#)
                             (QSETVELT |pss| 11 |coeffs|)
                             (LETT |nexps| (SPADCALL |nn| 0 (QREFELT $ 15))
                                   . #3#)
                             (SPADCALL |nexps| |exps| |n| (QREFELT $ 13))
                             (LETT |exps| |nexps| . #3#)
                             (QSETVELT |pss| 12 |exps|)
                             (EXIT (LETT |n| |nn| . #3#)))))
                          (LETT |t1| (QCDR |t0|) . #3#)
                          (SPADCALL |exps| |i| (QCAR |t0|) (QREFELT $ 16))
                          (COND
                           ((QEQCAR |t1| 0)
                            (SETELT32 |coeffs| |i| (QCDR |t1|)))
                           ('T (|error| "More than one variable in eval1a")))
                          (EXIT (LETT |i| (QSPLUS |i| 1) . #3#)))
                         (LETT #1# (CDR #1#) . #3#) #5=(GO G190) G191
                         (EXIT NIL))
                    (LETT |res| 0 . #3#) (LETT |ptk| 1 . #3#)
                    (LETT |pk| 0 . #3#)
                    (SEQ (LETT |j| (QSDIFFERENCE |i| 1) . #3#) G190
                         (COND ((< |j| 0) #4#))
                         (SEQ
                          (LETT |ki| (SPADCALL |exps| |j| (QREFELT $ 17))
                                . #3#)
                          (SEQ G190 (COND ((NULL (< |pk| |ki|)) #4#))
                               (SEQ
                                (LETT |ptk| (QSMULMOD32 |ptk| |pt| |p|) . #3#)
                                (EXIT (LETT |pk| (+ |pk| 1) . #3#)))
                               NIL #5# G191 (EXIT NIL))
                          (EXIT
                           (LETT |res|
                                 (QSMULADDMOD64-32 |ptk| (ELT32 |coeffs| |j|)
                                                   |res| |p|)
                                 . #3#)))
                         (LETT |j| (+ |j| -1) . #3#) #5# G191 (EXIT NIL))
                    (EXIT |res|)))))))
      #2# (EXIT #2#))))) 

(DEFUN |IMODHP;eval1s| (|gv0| |pt| |var| |pss| $)
  (PROG (|nlc| |dms| #1=#:G1855 |dm| |nm| |nlcq| #2=#:G1856 |j| |ress| |p| |n|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |n| (QVSIZE |gv0|) . #3=(|IMODHP;eval1s|))
            (LETT |p| (QVELT |pss| 5) . #3#)
            (LETT |ress| (GETREFV32 |n| 0) . #3#)
            (SEQ (LETT |j| 0 . #3#) (LETT #2# (- |n| 1) . #3#) G190
                 (COND ((QSGREATERP |j| #2#) (GO G191)))
                 (SEQ (LETT |nlcq| (QAREF1 |gv0| |j|) . #3#)
                      (LETT |nm|
                            (|IMODHP;eval1a| (SPADCALL |nlcq| (QREFELT $ 20))
                             |pt| |pss| $)
                            . #3#)
                      (LETT |dm|
                            (|IMODHP;eval1a| (SPADCALL |nlcq| (QREFELT $ 21))
                             |pt| |pss| $)
                            . #3#)
                      (EXIT
                       (COND
                        ((EQL |dm| 0)
                         (PROGN (LETT #1# (CONS 1 "failed") . #3#) (GO #1#)))
                        ('T
                         (SEQ (LETT |dms| |dm| . #3#)
                              (LETT |nlc|
                                    (QSMULMOD32 |nm|
                                                (SPADCALL |dms| |p|
                                                          (QREFELT $ 23))
                                                |p|)
                                    . #3#)
                              (EXIT (SETELT32 |ress| |j| |nlc|)))))))
                 (LETT |j| (QSADD1 |j|) . #3#) (GO G190) G191 (EXIT NIL))
            (EXIT (CONS 0 |ress|))))
      #1# (EXIT #1#))))) 

(DEFUN |IMODHP;modpreduction| (|x| |p| $)
  (PROG (|xr| |yu| |c1| |c0| |t1| #1=#:G1878 |t0| |xu| |vx|)
    (RETURN
     (SEQ (LETT |xr| |x| . #2=(|IMODHP;modpreduction|))
          (EXIT
           (COND
            ((QEQCAR |xr| 0)
             (SEQ (LETT |c0| (SPADCALL (QCDR |xr|) |p| (QREFELT $ 24)) . #2#)
                  (LETT |xr| (CONS 0 |c0|) . #2#) (EXIT (SETF |xr| |xr|))))
            (#3='T
             (SEQ (LETT |vx| (QCAR (QCDR |xr|)) . #2#)
                  (LETT |xu| (QCDR (QCDR |xr|)) . #2#) (LETT |yu| NIL . #2#)
                  (SEQ (LETT |t0| NIL . #2#) (LETT #1# |xu| . #2#) G190
                       (COND
                        ((OR (ATOM #1#)
                             (PROGN (LETT |t0| (CAR #1#) . #2#) NIL))
                         (GO G191)))
                       (SEQ (LETT |t1| (QCDR |t0|) . #2#)
                            (EXIT
                             (COND
                              ((QEQCAR |t1| 0)
                               (SEQ
                                (LETT |c0|
                                      (SPADCALL (QCDR |t1|) |p| (QREFELT $ 24))
                                      . #2#)
                                (EXIT
                                 (COND ((EQL |c0| 0) 0)
                                       ('T
                                        (SEQ (LETT |xr| (CONS 0 |c0|) . #2#)
                                             (EXIT
                                              (LETT |yu|
                                                    (CONS
                                                     (CONS (QCAR |t0|)
                                                           (SETF |xr| |xr|))
                                                     |yu|)
                                                    . #2#))))))))
                              ('T
                               (SEQ
                                (LETT |c1|
                                      (|IMODHP;modpreduction| (QCDR |t0|) |p|
                                       $)
                                      . #2#)
                                (EXIT
                                 (COND
                                  ((SPADCALL |c1| (|spadConstant| $ 25)
                                             (QREFELT $ 27))
                                   0)
                                  ('T
                                   (LETT |yu|
                                         (CONS (CONS (QCAR |t0|) |c1|) |yu|)
                                         . #2#)))))))))
                       (LETT #1# (CDR #1#) . #2#) (GO G190) G191 (EXIT NIL))
                  (LETT |xr|
                        (COND ((SPADCALL |yu| NIL (QREFELT $ 30)) (CONS 0 0))
                              (#3# (CONS 1 (CONS |vx| (REVERSE |yu|)))))
                        . #2#)
                  (EXIT (SETF |xr| |xr|)))))))))) 

(DEFUN |IMODHP;modpeval;PLL2I;4| (|x| |vars| |pts| |p| $)
  (PROG (|res| |c0| |kk| |ptk| |kk1| |t1| #1=#:G1898 |t0| |xu| |yu| |vxval|
         #2=#:G1897 |vx| |xr|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |xr| |x| . #3=(|IMODHP;modpeval;PLL2I;4|))
            (EXIT
             (COND
              ((QEQCAR |xr| 0)
               (PROGN
                (LETT #2# (SPADCALL (QCDR |xr|) |p| (QREFELT $ 24)) . #3#)
                (GO #2#)))
              ('T
               (SEQ (LETT |vx| (QCAR (QCDR |xr|)) . #3#)
                    (COND
                     ((NULL (EQUAL |vx| (|SPADfirst| |vars|)))
                      (EXIT
                       (PROGN
                        (LETT #2#
                              (SPADCALL |x| (CDR |vars|) (CDR |pts|) |p|
                                        (QREFELT $ 33))
                              . #3#)
                        (GO #2#)))))
                    (LETT |vxval| (|SPADfirst| |pts|) . #3#)
                    (LETT |vars| (CDR |vars|) . #3#)
                    (LETT |pts| (CDR |pts|) . #3#)
                    (LETT |xu| (QCDR (QCDR |xr|)) . #3#) (LETT |yu| NIL . #3#)
                    (LETT |ptk| 1 . #3#) (LETT |kk| 0 . #3#)
                    (LETT |res| 0 . #3#) (LETT |xu| (REVERSE |xu|) . #3#)
                    (SEQ (LETT |t0| NIL . #3#) (LETT #1# |xu| . #3#) G190
                         (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |t0| (CAR #1#) . #3#) NIL))
                           #4=(GO G191)))
                         (SEQ (LETT |t1| (QCDR |t0|) . #3#)
                              (LETT |kk1| (QCAR |t0|) . #3#)
                              (SEQ G190 (COND ((NULL (< |kk| |kk1|)) #4#))
                                   (SEQ
                                    (LETT |ptk| (QSMULMOD32 |vxval| |ptk| |p|)
                                          . #3#)
                                    (EXIT (LETT |kk| (+ |kk| 1) . #3#)))
                                   NIL #5=(GO G190) G191 (EXIT NIL))
                              (LETT |c0|
                                    (COND
                                     ((QEQCAR |t1| 0)
                                      (SPADCALL (QCDR |t1|) |p|
                                                (QREFELT $ 24)))
                                     ('T
                                      (SPADCALL (QCDR |t0|) |vars| |pts| |p|
                                                (QREFELT $ 33))))
                                    . #3#)
                              (EXIT
                               (LETT |res|
                                     (QSMULADDMOD64-32 |ptk| |c0| |res| |p|)
                                     . #3#)))
                         (LETT #1# (CDR #1#) . #3#) #5# G191 (EXIT NIL))
                    (EXIT |res|)))))))
      #2# (EXIT #2#))))) 

(DEFUN |IMODHP;eval2s| (|gv0| |pt| |var| |p| $)
  (PROG (#1=#:G1905 |dm| |nm| |dmp| |nmp| |nlcq| #2=#:G1906 |j| |pts| |vars|
         |ress| |n|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |n| (QVSIZE |gv0|) . #3=(|IMODHP;eval2s|))
            (LETT |ress| (MAKEARR1 |n| (|spadConstant| $ 34)) . #3#)
            (LETT |vars| (LIST |var|) . #3#) (LETT |pts| (LIST |pt|) . #3#)
            (SEQ (LETT |j| 0 . #3#) (LETT #2# (- |n| 1) . #3#) G190
                 (COND ((QSGREATERP |j| #2#) (GO G191)))
                 (SEQ (LETT |nlcq| (QAREF1 |gv0| |j|) . #3#)
                      (LETT |nmp|
                            (SPADCALL (SPADCALL |nlcq| (QREFELT $ 20)) |vars|
                                      |pts| (QREFELT $ 35))
                            . #3#)
                      (LETT |dmp|
                            (SPADCALL (SPADCALL |nlcq| (QREFELT $ 21)) |vars|
                                      |pts| (QREFELT $ 35))
                            . #3#)
                      (LETT |nm| (|IMODHP;modpreduction| |nmp| |p| $) . #3#)
                      (LETT |dm| (|IMODHP;modpreduction| |dmp| |p| $) . #3#)
                      (EXIT
                       (COND
                        ((SPADCALL |dm| (|spadConstant| $ 25) (QREFELT $ 27))
                         (PROGN (LETT #1# (CONS 1 "failed") . #3#) (GO #1#)))
                        ('T
                         (QSETAREF1 |ress| |j|
                                    (SPADCALL |nm| |dm| (QREFELT $ 36)))))))
                 (LETT |j| (QSADD1 |j|) . #3#) (GO G190) G191 (EXIT NIL))
            (EXIT (CONS 0 |ress|))))
      #1# (EXIT #1#))))) 

(DEFUN |IMODHP;eval3s| (|gv0| |p| $)
  (PROG (#1=#:G1910 |dm| |nm| |dmp| |nmp| |nlcq| #2=#:G1911 |j| |ress| |n|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |n| (QVSIZE |gv0|) . #3=(|IMODHP;eval3s|))
            (LETT |ress| (MAKEARR1 |n| (|spadConstant| $ 34)) . #3#)
            (SEQ (LETT |j| 0 . #3#) (LETT #2# (- |n| 1) . #3#) G190
                 (COND ((QSGREATERP |j| #2#) (GO G191)))
                 (SEQ (LETT |nlcq| (QAREF1 |gv0| |j|) . #3#)
                      (LETT |nmp| (SPADCALL |nlcq| (QREFELT $ 20)) . #3#)
                      (LETT |dmp| (SPADCALL |nlcq| (QREFELT $ 21)) . #3#)
                      (LETT |nm| (|IMODHP;modpreduction| |nmp| |p| $) . #3#)
                      (LETT |dm| (|IMODHP;modpreduction| |dmp| |p| $) . #3#)
                      (EXIT
                       (COND
                        ((SPADCALL |dm| (|spadConstant| $ 25) (QREFELT $ 27))
                         (PROGN (LETT #1# (CONS 1 "failed") . #3#) (GO #1#)))
                        ('T
                         (QSETAREF1 |ress| |j|
                                    (SPADCALL |nm| |dm| (QREFELT $ 36)))))))
                 (LETT |j| (QSADD1 |j|) . #3#) (GO G190) G191 (EXIT NIL))
            (EXIT (CONS 0 |ress|))))
      #1# (EXIT #1#))))) 

(DEFUN |IMODHP;do_modular_solve0| (|gv| |ve| |sigma| |pts| |prime| |kind| $)
  (COND
   ((OR (EQUAL |kind| '|diffHP|) (EQUAL |kind| '|qdiffHP|))
    (SPADCALL |gv| |ve| |sigma| |prime| (QREFELT $ 41)))
   ((OR (EQUAL |kind| '|shiftHP|)
        (OR (EQUAL |kind| '|qshiftHP|) (EQUAL |kind| '|qmixed|)))
    (SPADCALL |gv| |ve| |pts| |prime| (QREFELT $ 42)))
   ('T (|error| "kind must be diffHP, qdiffHP, shiftHP, qshiftHP or qmixed")))) 

(DEFUN |IMODHP;do_modular_solve;VVNniUvISU;8|
       (|gv| |ve| |sigma| |pts| |prime| |kind| $)
  (PROG (#1=#:G1938 |bm| |dbm| |ok| |i| |m| |va| |dva| |blr|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |blr|
              (|IMODHP;do_modular_solve0| |gv| |ve| |sigma| |pts| |prime|
               |kind| $)
              . #2=(|IMODHP;do_modular_solve;VVNniUvISU;8|))
        (LETT |dva| (SPADCALL |blr| 3 (QREFELT $ 44)) . #2#)
        (LETT |va| (SPADCALL |dva| (QREFELT $ 46)) . #2#) (LETT |ok| NIL . #2#)
        (LETT |m| (QVSIZE |va|) . #2#)
        (SEQ (LETT |i| 1 . #2#) G190 (COND ((QSGREATERP |i| |m|) (GO G191)))
             (SEQ
              (EXIT
               (LETT |ok|
                     (COND
                      ((OR |ok|
                           (NULL (< (SPADCALL |va| |i| (QREFELT $ 47)) 0)))
                       'T)
                      ('T 'NIL))
                     . #2#)))
             (LETT |i| (QSADD1 |i|) . #2#) (GO G190) G191 (EXIT NIL))
        (EXIT
         (COND
          (|ok|
           (SEQ (LETT |dbm| (SPADCALL |blr| 1 (QREFELT $ 44)) . #2#)
                (LETT |bm| (SPADCALL |dbm| (QREFELT $ 49)) . #2#)
                (EXIT
                 (PROGN
                  (LETT #1#
                        (CONS 0
                              (SPADCALL |bm| |ve| |va| |prime| (QREFELT $ 51)))
                        . #2#)
                  (GO #1#)))))
          ('T (PROGN (LETT #1# (CONS 1 "no_solution") . #2#) (GO #1#)))))))
      #1# (EXIT #1#))))) 

(DEFUN |IMODHP;compute_blocks| (|offsets| |rowlen| |nsols| $)
  (PROG (|i| |block_offsets|)
    (RETURN
     (SEQ
      (LETT |block_offsets| (MAKEARR1 |nsols| 0)
            . #1=(|IMODHP;compute_blocks|))
      (SEQ (LETT |i| 1 . #1#) G190 (COND ((QSGREATERP |i| |nsols|) (GO G191)))
           (SEQ
            (EXIT
             (SPADCALL |block_offsets| |i|
                       (SPADCALL |offsets| (+ (* (- |i| 1) |rowlen|) 1)
                                 (QREFELT $ 47))
                       (QREFELT $ 55))))
           (LETT |i| (QSADD1 |i|) . #1#) (GO G190) G191 (EXIT NIL))
      (EXIT |block_offsets|))))) 

(DEFUN |IMODHP;merge_exponents;IVSevVSevL;10|
       (|nvars| |offsets| |exps| |noffsets| |nexps| $)
  (PROG (|j0| |i0| |j| |i| |ci| #1=#:G1962 |j0i| |ji| |jl| |i0i| |ii| |il| |k|
         |lj| |li| #2=#:G1966 #3=#:G1968 |jj| #4=#:G1967 |kk| |nn| |oc| |m|
         |n|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |n| (QUOTIENT2 (SPADCALL |exps| (QREFELT $ 56)) |nvars|)
              . #5=(|IMODHP;merge_exponents;IVSevVSevL;10|))
        (LETT |m| (QUOTIENT2 (SPADCALL |nexps| (QREFELT $ 56)) |nvars|) . #5#)
        (LETT |oc| (QVSIZE |offsets|) . #5#) (LETT |i0| 0 . #5#)
        (LETT |j0| 0 . #5#) (LETT |ci| 0 . #5#) (LETT |i| 0 . #5#)
        (LETT |j| 0 . #5#) (LETT |li| 0 . #5#) (LETT |lj| 0 . #5#)
        (LETT |il| NIL . #5#) (LETT |jl| NIL . #5#) (LETT |kk| 1 . #5#)
        (LETT |nn| (- |nvars| 1) . #5#)
        (EXIT
         (SEQ G190 NIL
              (SEQ (LETT |i0i| 1 . #5#) (LETT |j0i| 1 . #5#)
                   (LETT |ii| |nvars| . #5#) (LETT |ji| |nvars| . #5#)
                   (COND
                    ((OR (EQL |i0| |li|) (EQL |j0| |lj|))
                     (EXIT
                      (SEQ (LETT |kk| (+ |kk| 1) . #5#)
                           (COND
                            ((< |i0| |li|)
                             (SEQ (LETT |jj| |i0| . #5#)
                                  (LETT #4# (- |li| 1) . #5#) G190
                                  (COND ((> |jj| #4#) #6=(GO G191)))
                                  (SEQ (LETT |jl| (CONS |ci| |jl|) . #5#)
                                       (EXIT (LETT |ci| (+ |ci| 1) . #5#)))
                                  (LETT |jj| (+ |jj| 1) . #5#) #7=(GO G190)
                                  G191 (EXIT NIL))))
                           (COND
                            ((< |j0| |lj|)
                             (SEQ (LETT |jj| |j0| . #5#)
                                  (LETT #3# (- |lj| 1) . #5#) G190
                                  (COND ((> |jj| #3#) #6#))
                                  (SEQ (LETT |il| (CONS |ci| |il|) . #5#)
                                       (EXIT (LETT |ci| (+ |ci| 1) . #5#)))
                                  (LETT |jj| (+ |jj| 1) . #5#) #7# G191
                                  (EXIT NIL))))
                           (EXIT
                            (COND
                             ((EQL |li| |n|)
                              (PROGN
                               (LETT #2# (LIST (NREVERSE |il|) (NREVERSE |jl|))
                                     . #5#)
                               (GO #2#)))
                             ('T
                              (SEQ (LETT |i0| |li| . #5#)
                                   (LETT |j0| |lj| . #5#)
                                   (LETT |i| (* |i0| |nvars|) . #5#)
                                   (LETT |j| (* |j0| |nvars|) . #5#)
                                   (EXIT
                                    (COND
                                     ((< |oc| |kk|)
                                      (SEQ (LETT |li| |n| . #5#)
                                           (EXIT (LETT |lj| |m| . #5#))))
                                     ('T
                                      (SEQ
                                       (LETT |li|
                                             (SPADCALL |offsets| |kk|
                                                       (QREFELT $ 47))
                                             . #5#)
                                       (EXIT
                                        (LETT |lj|
                                              (SPADCALL |noffsets| |kk|
                                                        (QREFELT $ 47))
                                              . #5#))))))))))))))
                   (SEQ
                    (EXIT
                     (SEQ (LETT |k| 0 . #5#) G190
                          (COND ((QSGREATERP |k| |nn|) #6#))
                          (SEQ
                           (EXIT
                            (COND
                             ((NULL
                               (EQL
                                (SPADCALL |exps| (+ |i| |k|) (QREFELT $ 17))
                                (SPADCALL |nexps| (+ |j| |k|) (QREFELT $ 17))))
                              (PROGN
                               (LETT #1#
                                     (COND
                                      ((<
                                        (SPADCALL |nexps| (+ |j| |k|)
                                                  (QREFELT $ 17))
                                        (SPADCALL |exps| (+ |i| |k|)
                                                  (QREFELT $ 17)))
                                       (SEQ (LETT |il| (CONS |ci| |il|) . #5#)
                                            (LETT |ii| 0 . #5#)
                                            (LETT |i0i| 0 . #5#)
                                            (EXIT
                                             (PROGN
                                              (LETT #1# |$NoValue| . #5#)
                                              (GO #1#)))))
                                      ('T
                                       (SEQ (LETT |jl| (CONS |ci| |jl|) . #5#)
                                            (LETT |ji| 0 . #5#)
                                            (LETT |j0i| 0 . #5#)
                                            (EXIT
                                             (PROGN
                                              (LETT #1# |$NoValue| . #5#)
                                              (GO #1#))))))
                                     . #5#)
                               (GO #1#))))))
                          (LETT |k| (QSADD1 |k|) . #5#) #7# G191 (EXIT NIL)))
                    #1# (EXIT #1#))
                   (LETT |ci| (+ |ci| 1) . #5#) (LETT |i| (+ |i| |ii|) . #5#)
                   (LETT |j| (+ |j| |ji|) . #5#)
                   (LETT |i0| (+ |i0| |i0i|) . #5#)
                   (EXIT (LETT |j0| (+ |j0| |j0i|) . #5#)))
              NIL #7# G191 (EXIT NIL)))))
      #2# (EXIT #2#))))) 

(DEFUN |IMODHP;merge2;I2LVSevVSevR;11|
       (|nvars| |odl| |ndl| |ov1| |exps1| |ov2| |exps2| $)
  (PROG (|i| |ci| |i0| |i00| |j0| |j| |k| |j00| |lj| |li| |kk| #1=#:G1990 |ci0|
         |nv1| |noffsets| |m| |nexps| #2=#:G1970 |nn1| |n1| |nn| |n0|)
    (RETURN
     (SEQ
      (LETT |n0| (SPADCALL |exps1| (QREFELT $ 56))
            . #3=(|IMODHP;merge2;I2LVSevVSevR;11|))
      (LETT |nn| (LENGTH |odl|) . #3#)
      (LETT |n1| (+ (QUOTIENT2 |n0| |nvars|) |nn|) . #3#)
      (LETT |nn1| (* |n1| |nvars|) . #3#)
      (LETT |nexps|
            (SPADCALL
             (PROG1 (LETT #2# |nn1| . #3#)
               (|check-subtype| (>= #2# 0) '(|NonNegativeInteger|) #2#))
             0 (QREFELT $ 15))
            . #3#)
      (LETT |m| (QVSIZE |ov2|) . #3#) (LETT |noffsets| (MAKEARR1 |m| 0) . #3#)
      (LETT |nv1| (- |nvars| 1) . #3#) (LETT |i0| 0 . #3#) (LETT |j0| 0 . #3#)
      (LETT |ci0| 0 . #3#) (LETT |i| 0 . #3#) (LETT |j| 0 . #3#)
      (LETT |ci| 0 . #3#)
      (LETT |j00| (COND ((NULL |ndl|) |n1|) ('T (|SPADfirst| |ndl|))) . #3#)
      (LETT |i00| (|SPADfirst| |odl|) . #3#)
      (LETT |li| (SPADCALL |ov1| 1 (QREFELT $ 47)) . #3#)
      (LETT |lj| (SPADCALL |ov2| 1 (QREFELT $ 47)) . #3#) (LETT |kk| 1 . #3#)
      (SEQ (LETT |ci0| 0 . #3#) (LETT #1# (- |n1| 1) . #3#) G190
           (COND ((QSGREATERP |ci0| #1#) #4=(GO G191)))
           (SEQ
            (SEQ G190
                 (COND
                  ((NULL (COND ((EQL |i0| |li|) (EQL |j0| |lj|)) ('T 'NIL)))
                   #4#))
                 (SEQ (SPADCALL |noffsets| |kk| |ci0| (QREFELT $ 55))
                      (LETT |kk| (+ |kk| 1) . #3#)
                      (EXIT
                       (COND
                        ((< |m| |kk|)
                         (SEQ (LETT |li| |n1| . #3#)
                              (EXIT (LETT |lj| |n1| . #3#))))
                        ('T
                         (SEQ
                          (LETT |li| (SPADCALL |ov1| |kk| (QREFELT $ 47))
                                . #3#)
                          (EXIT
                           (LETT |lj| (SPADCALL |ov2| |kk| (QREFELT $ 47))
                                 . #3#)))))))
                 NIL #5=(GO G190) G191 (EXIT NIL))
            (COND
             ((EQL |ci0| |j00|)
              (SEQ
               (SEQ (LETT |k| 0 . #3#) G190 (COND ((QSGREATERP |k| |nv1|) #4#))
                    (SEQ
                     (EXIT
                      (SPADCALL |nexps| (+ |ci| |k|)
                                (SPADCALL |exps1| (+ |i| |k|) (QREFELT $ 17))
                                (QREFELT $ 16))))
                    (LETT |k| (QSADD1 |k|) . #3#) #5# G191 (EXIT NIL))
               (LETT |ndl| (CDR |ndl|) . #3#)
               (EXIT
                (LETT |j00| (COND ((NULL |ndl|) |n1|) ('T (|SPADfirst| |ndl|)))
                      . #3#))))
             ('T
              (SEQ
               (SEQ (LETT |k| 0 . #3#) G190 (COND ((QSGREATERP |k| |nv1|) #4#))
                    (SEQ
                     (EXIT
                      (SPADCALL |nexps| (+ |ci| |k|)
                                (SPADCALL |exps2| (+ |j| |k|) (QREFELT $ 17))
                                (QREFELT $ 16))))
                    (LETT |k| (QSADD1 |k|) . #3#) #5# G191 (EXIT NIL))
               (LETT |j| (+ |j| |nvars|) . #3#)
               (EXIT (LETT |j0| (+ |j0| 1) . #3#)))))
            (COND
             ((EQL |ci0| |i00|)
              (SEQ (LETT |odl| (CDR |odl|) . #3#)
                   (EXIT
                    (LETT |i00|
                          (COND ((NULL |odl|) |n1|) ('T (|SPADfirst| |odl|)))
                          . #3#))))
             ('T
              (SEQ (LETT |i| (+ |i| |nvars|) . #3#)
                   (EXIT (LETT |i0| (+ |i0| 1) . #3#)))))
            (EXIT (LETT |ci| (+ |ci| |nvars|) . #3#)))
           (LETT |ci0| (QSADD1 |ci0|) . #3#) #5# G191 (EXIT NIL))
      (SEQ (LETT |i| |kk| . #3#) G190 (COND ((> |i| |m|) #4#))
           (SEQ (EXIT (SPADCALL |noffsets| |i| |n1| (QREFELT $ 55))))
           (LETT |i| (+ |i| 1) . #3#) #5# G191 (EXIT NIL))
      (EXIT (CONS |noffsets| |nexps|)))))) 

(DEFUN |IMODHP;check_defects| (|va| |civ| |pss| $)
  (PROG (#1=#:G2008 #2=#:G2004 |is_bad| |all_bad| |i| |ociv| |ova| |nsols|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |nsols| (QVELT |pss| 10) . #3=(|IMODHP;check_defects|))
            (LETT |is_bad| (< |nsols| (QVSIZE |va|)) . #3#)
            (LETT |all_bad| (< (QVSIZE |va|) |nsols|) . #3#)
            (COND
             ((EQL (QVSIZE |va|) |nsols|)
              (SEQ (LETT |ova| (QVELT |pss| 7) . #3#)
                   (LETT |ociv| (QVELT |pss| 8) . #3#)
                   (EXIT
                    (SEQ
                     (EXIT
                      (SEQ (LETT |i| 1 . #3#) G190
                           (COND ((QSGREATERP |i| |nsols|) (GO G191)))
                           (SEQ
                            (EXIT
                             (COND
                              ((< (SPADCALL |va| |i| (QREFELT $ 47))
                                  (SPADCALL |ova| |i| (QREFELT $ 47)))
                               (SEQ (LETT |all_bad| 'T . #3#)
                                    (EXIT
                                     (PROGN
                                      (LETT #2# |$NoValue| . #3#)
                                      (GO #2#)))))
                              ((< (SPADCALL |ova| |i| (QREFELT $ 47))
                                  (SPADCALL |va| |i| (QREFELT $ 47)))
                               (SEQ (LETT |is_bad| 'T . #3#)
                                    (EXIT
                                     (PROGN
                                      (LETT #2# |$NoValue| . #3#)
                                      (GO #2#)))))
                              ((< (SPADCALL |civ| |i| (QREFELT $ 47))
                                  (SPADCALL |ociv| |i| (QREFELT $ 47)))
                               (SEQ (LETT |all_bad| 'T . #3#)
                                    (EXIT
                                     (PROGN
                                      (LETT #2# |$NoValue| . #3#)
                                      (GO #2#)))))
                              ((< (SPADCALL |ociv| |i| (QREFELT $ 47))
                                  (SPADCALL |civ| |i| (QREFELT $ 47)))
                               (SEQ (LETT |is_bad| 'T . #3#)
                                    (EXIT
                                     (PROGN
                                      (LETT #2# |$NoValue| . #3#)
                                      (GO #2#))))))))
                           (LETT |i| (QSADD1 |i|) . #3#) (GO G190) G191
                           (EXIT NIL)))
                     #2# (EXIT #2#))))))
            (EXIT
             (COND
              (|is_bad| (PROGN (LETT #1# (CONS 1 "failed") . #3#) (GO #1#)))
              (|all_bad| (PROGN (LETT #1# (CONS 2 "all_bad") . #3#) (GO #1#)))
              ('T (PROGN (LETT #1# (CONS 0 "OK") . #3#) (GO #1#)))))))
      #1# (EXIT #1#))))) 

(DEFUN |IMODHP;eval_and_solve;ILPaRMU;13| (|pt| |vars| |gv0| |pss| |gen| $)
  (PROG (#1=#:G2045 |ngv0| |ngv0p| #2=#:G2046 |i| |nev| #3=#:G2029 |ncv|
         #4=#:G2028 |k| |cpl| |l| |cp| |mm| |k1| |j| |ov| |ev| #5=#:G2021 |cv|
         #6=#:G2020 |r_cnt| |m| |nsols| |civ| |va| |bm| |rblr| |blr| |ve|
         |ngv2| |ngv10| |ngv10p| |nvars| |p|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |p| (QVELT |pss| 5) . #7=(|IMODHP;eval_and_solve;ILPaRMU;13|))
        (LETT |nvars| (LENGTH |vars|) . #7#)
        (EXIT
         (COND
          ((EQL |nvars| 1)
           (SEQ
            (LETT |ngv10p|
                  (|IMODHP;eval1s| |gv0| |pt| (|SPADfirst| |vars|) |pss| $)
                  . #7#)
            (EXIT
             (COND
              ((QEQCAR |ngv10p| 1)
               (PROGN (LETT #1# (CONS 1 "failed") . #7#) (GO #1#)))
              (#8='T
               (SEQ (LETT |ngv10| (QCDR |ngv10p|) . #7#)
                    (LETT |ngv2| (SPADCALL |ngv10| |p| (QVELT |pss| 4) |gen|)
                          . #7#)
                    (LETT |ve| (QVELT |pss| 0) . #7#)
                    (LETT |blr|
                          (SPADCALL |ngv2| |ve| (QVELT |pss| 1) (QVELT |pss| 2)
                                    |p| (QVELT |pss| 6) (QREFELT $ 54))
                          . #7#)
                    (EXIT
                     (COND
                      ((QEQCAR |blr| 1)
                       (PROGN
                        (LETT #1# (CONS 2 "no_solution") . #7#)
                        (GO #1#)))
                      (#8#
                       (SEQ (LETT |rblr| (QCDR |blr|) . #7#)
                            (LETT |bm| (QVELT |rblr| 0) . #7#)
                            (LETT |va| (QVELT |rblr| 1) . #7#)
                            (LETT |civ| (QVELT |rblr| 2) . #7#)
                            (LETT |nsols| (QVSIZE |va|) . #7#)
                            (LETT |r_cnt| 0 . #7#)
                            (LETT |m| (QVSIZE |ve|) . #7#)
                            (SEQ (LETT |j| 1 . #7#) G190
                                 (COND ((QSGREATERP |j| |m|) #9=(GO G191)))
                                 (SEQ
                                  (EXIT
                                   (LETT |r_cnt|
                                         (+
                                          (+ |r_cnt|
                                             (SPADCALL |ve| |j|
                                                       (QREFELT $ 47)))
                                          1)
                                         . #7#)))
                                 (LETT |j| (QSADD1 |j|) . #7#) #10=(GO G190)
                                 G191 (EXIT NIL))
                            (LETT |r_cnt| (* |r_cnt| |nsols|) . #7#)
                            (LETT |cv|
                                  (GETREFV32
                                   (PROG1 (LETT #6# |r_cnt| . #7#)
                                     (|check-subtype| (>= #6# 0)
                                                      '(|NonNegativeInteger|)
                                                      #6#))
                                   0)
                                  . #7#)
                            (LETT |ev|
                                  (SPADCALL
                                   (PROG1 (LETT #5# |r_cnt| . #7#)
                                     (|check-subtype| (>= #5# 0)
                                                      '(|NonNegativeInteger|)
                                                      #5#))
                                   0 (QREFELT $ 15))
                                  . #7#)
                            (LETT |ov| (MAKEARR1 (* |nsols| |m|) 0) . #7#)
                            (LETT |k| 0 . #7#) (LETT |k1| 1 . #7#)
                            (SEQ (LETT |i| 1 . #7#) G190
                                 (COND ((QSGREATERP |i| |nsols|) #9#))
                                 (SEQ
                                  (EXIT
                                   (SEQ (LETT |j| 1 . #7#) G190
                                        (COND ((QSGREATERP |j| |m|) #9#))
                                        (SEQ
                                         (SPADCALL |ov| |k1| |k|
                                                   (QREFELT $ 55))
                                         (LETT |k1| (+ |k1| 1) . #7#)
                                         (LETT |mm|
                                               (SPADCALL |ve| |j|
                                                         (QREFELT $ 47))
                                               . #7#)
                                         (LETT |cp|
                                               (SPADCALL |bm| |i| |j|
                                                         (QREFELT $ 64))
                                               . #7#)
                                         (EXIT
                                          (SEQ (LETT |l| 0 . #7#) G190
                                               (COND
                                                ((QSGREATERP |l| |mm|) #9#))
                                               (SEQ
                                                (LETT |cpl| (ELT32 |cp| |l|)
                                                      . #7#)
                                                (EXIT
                                                 (COND
                                                  ((NULL (EQL |cpl| 0))
                                                   (SEQ
                                                    (SETELT32 |cv| |k| |cpl|)
                                                    (SPADCALL |ev| |k| |l|
                                                              (QREFELT $ 16))
                                                    (EXIT
                                                     (LETT |k| (+ |k| 1)
                                                           . #7#)))))))
                                               (LETT |l| (QSADD1 |l|) . #7#)
                                               #10# G191 (EXIT NIL))))
                                        (LETT |j| (QSADD1 |j|) . #7#) #10# G191
                                        (EXIT NIL))))
                                 (LETT |i| (QSADD1 |i|) . #7#) #10# G191
                                 (EXIT NIL))
                            (LETT |ncv|
                                  (GETREFV32
                                   (PROG1 (LETT #4# |k| . #7#)
                                     (|check-subtype| (>= #4# 0)
                                                      '(|NonNegativeInteger|)
                                                      #4#))
                                   0)
                                  . #7#)
                            (LETT |nev|
                                  (SPADCALL
                                   (PROG1 (LETT #3# |k| . #7#)
                                     (|check-subtype| (>= #3# 0)
                                                      '(|NonNegativeInteger|)
                                                      #3#))
                                   0 (QREFELT $ 15))
                                  . #7#)
                            (SEQ (LETT |i| 0 . #7#) (LETT #2# (- |k| 1) . #7#)
                                 G190 (COND ((QSGREATERP |i| #2#) #9#))
                                 (SEQ (SETELT32 |ncv| |i| (ELT32 |cv| |i|))
                                      (EXIT
                                       (SPADCALL |nev| |i|
                                                 (SPADCALL |ev| |i|
                                                           (QREFELT $ 17))
                                                 (QREFELT $ 16))))
                                 (LETT |i| (QSADD1 |i|) . #7#) #10# G191
                                 (EXIT NIL))
                            (EXIT
                             (PROGN
                              (LETT #1#
                                    (CONS 0
                                          (VECTOR |va| |civ| |m| |ov| |nev|
                                                  |ncv|))
                                    . #7#)
                              (GO #1#)))))))))))))
          (#8#
           (SEQ
            (LETT |ngv0p|
                  (|IMODHP;eval2s| |gv0| |pt| (|SPADfirst| |vars|) |p| $)
                  . #7#)
            (EXIT
             (COND
              ((QEQCAR |ngv0p| 1)
               (PROGN (LETT #1# (CONS 1 "failed") . #7#) (GO #1#)))
              (#8#
               (SEQ (LETT |ngv0| (QCDR |ngv0p|) . #7#)
                    (EXIT
                     (PROGN
                      (LETT #1#
                            (SPADCALL (CDR |vars|) |ngv0| |pss| |gen|
                                      (QREFELT $ 70))
                            . #7#)
                      (GO #1#)))))))))))))
      #1# (EXIT #1#))))) 

(DEFUN |IMODHP;do_poly_modular;LPaRMU;14| (|vars| |gv0| |pss| |gen| $)
  (PROG (#1=#:G2099 |rr| |pp| #2=#:G2102 |j| |hi| |lo| |invc| #3=#:G2082 |ok|
         |nofi| |ofi| |ofin| |cnum| |i| |n1| |block_offsets| |coeffs| |jl|
         |ndl| #4=#:G2101 |ncoeffs| |nn| |n0| |rstate| |ncc| |exps| |offsets|
         |oer| |odl| |dl| |good_cnt| |all_bad| |nsols| |bad_cnt| |chk_ress|
         |noffsets| |nexps| |civ| |va| |ppr| |pprp| |qn| #5=#:G2100 |k| |pts|
         |npt| |lpt| |pt| |nvars| |m| |p| |update_qval| |update_points|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |lpt| NIL . #6=(|IMODHP;do_poly_modular;LPaRMU;14|))
            (LETT |bad_cnt| 0 . #6#) (LETT |good_cnt| 0 . #6#)
            (LETT |exps| (SPADCALL (QREFELT $ 72)) . #6#)
            (LETT |offsets| (MAKE-ARRAY 0) . #6#) (LETT |all_bad| 'T . #6#)
            (LETT |update_points|
                  (COND
                   ((EQUAL (QVELT |pss| 6) '|qshiftHP|)
                    (EQUAL (QVELT |pss| 3) (|SPADfirst| |vars|)))
                   ('T 'NIL))
                  . #6#)
            (LETT |update_qval|
                  (COND
                   ((OR (EQUAL (QVELT |pss| 6) '|qshiftHP|)
                        (OR (EQUAL (QVELT |pss| 6) '|qdiffHP|)
                            (EQUAL (QVELT |pss| 6) '|qmixed|)))
                    (EQUAL (QVELT |pss| 3) (|SPADfirst| |vars|)))
                   ('T 'NIL))
                  . #6#)
            (LETT |p| (QVELT |pss| 5) . #6#) (LETT |m| (QVELT |pss| 9) . #6#)
            (LETT |nvars| (LENGTH |vars|) . #6#) (LETT |nsols| (+ |m| 1) . #6#)
            (EXIT
             (SEQ G190 NIL
                  (SEQ (LETT |ok| 'NIL . #6#)
                       (SEQ (LETT |k| 1 . #6#) G190
                            (COND
                             ((OR (QSGREATERP |k| 100)
                                  (NULL (COND (|ok| 'NIL) ('T 'T))))
                              #7=(GO G191)))
                            (SEQ (LETT |pt| (RANDOM |p|) . #6#)
                                 (EXIT
                                  (COND
                                   ((SPADCALL |pt| |lpt| (QREFELT $ 73))
                                    "iterate")
                                   ('T
                                    (SEQ (LETT |lpt| (CONS |pt| |lpt|) . #6#)
                                         (EXIT (LETT |ok| 'T . #6#)))))))
                            (LETT |k| (QSADD1 |k|) . #6#) #8=(GO G190) G191
                            (EXIT NIL))
                       (COND
                        ((EQL
                          (SPADCALL (LETT |npt| (LENGTH |lpt|) . #6#) 100
                                    (QREFELT $ 24))
                          0)
                         (SEQ
                          (SPADCALL "Number of evaluation points"
                                    (QREFELT $ 75))
                          (EXIT
                           (SPADCALL (SPADCALL |npt| (QREFELT $ 76))
                                     (QREFELT $ 75))))))
                       (EXIT
                        (COND
                         (|ok|
                          (SEQ
                           (COND
                            (|update_points|
                             (SEQ (LETT |pts| (QVELT |pss| 2) . #6#)
                                  (LETT |qn| 1 . #6#)
                                  (EXIT
                                   (SEQ (LETT |k| 0 . #6#)
                                        (LETT #5# (- (QVELT |pss| 1) 1) . #6#)
                                        G190 (COND ((QSGREATERP |k| #5#) #7#))
                                        (SEQ (SETELT32 |pts| |k| |qn|)
                                             (EXIT
                                              (LETT |qn|
                                                    (SPADCALL (* |pt| |qn|) |p|
                                                              (QREFELT $ 24))
                                                    . #6#)))
                                        (LETT |k| (QSADD1 |k|) . #6#) #8# G191
                                        (EXIT NIL))))))
                           (COND (|update_qval| (QSETVELT |pss| 4 |pt|)))
                           (LETT |pprp|
                                 (SPADCALL |pt| |vars| |gv0| |pss| |gen|
                                           (QREFELT $ 71))
                                 . #6#)
                           (EXIT
                            (COND
                             ((QEQCAR |pprp| 2)
                              (PROGN
                               (LETT #1# (CONS 2 "no_solution") . #6#)
                               (GO #1#)))
                             ((QEQCAR |pprp| 1)
                              (SEQ (LETT |bad_cnt| (+ |bad_cnt| 1) . #6#)
                                   (EXIT
                                    (COND
                                     ((< (+ |good_cnt| 2) |bad_cnt|)
                                      (PROGN
                                       (LETT #1# (CONS 1 "failed") . #6#)
                                       (GO #1#)))
                                     ('T "iterate")))))
                             ('T
                              (SEQ (LETT |ppr| (QCDR |pprp|) . #6#)
                                   (LETT |va| (QVELT |ppr| 0) . #6#)
                                   (LETT |civ| (QVELT |ppr| 1) . #6#)
                                   (LETT |nexps| (QVELT |ppr| 4) . #6#)
                                   (LETT |noffsets| (QVELT |ppr| 3) . #6#)
                                   (LETT |coeffs| (QVELT |ppr| 5) . #6#)
                                   (LETT |chk_ress|
                                         (|IMODHP;check_defects| |va| |civ|
                                          |pss| $)
                                         . #6#)
                                   (EXIT
                                    (COND
                                     ((QEQCAR |chk_ress| 1)
                                      (SEQ
                                       (LETT |bad_cnt| (+ |bad_cnt| 1) . #6#)
                                       (EXIT
                                        (COND
                                         ((< (+ |good_cnt| 2) |bad_cnt|)
                                          (PROGN
                                           (LETT #1# (CONS 1 "failed") . #6#)
                                           (GO #1#)))
                                         ('T "iterate")))))
                                     ('T
                                      (SEQ
                                       (COND
                                        ((QEQCAR |chk_ress| 2)
                                         (LETT |all_bad| 'T . #6#)))
                                       (COND
                                        (|all_bad|
                                         (SEQ
                                          (LETT |nsols| (QVSIZE |va|) . #6#)
                                          (QSETVELT |pss| 10 |nsols|)
                                          (QSETVELT |pss| 7 |va|)
                                          (QSETVELT |pss| 8 |civ|)
                                          (LETT |exps| |nexps| . #6#)
                                          (LETT |offsets| |noffsets| . #6#)
                                          (EXIT
                                           (LETT |rstate|
                                                 (SPADCALL (QV32LEN |coeffs|)
                                                           |p| (QREFELT $ 78))
                                                 . #6#)))))
                                       (LETT |all_bad| 'NIL . #6#)
                                       (LETT |good_cnt| (+ |good_cnt| 1) . #6#)
                                       (LETT |dl|
                                             (SPADCALL |nvars| |offsets| |exps|
                                                       |noffsets| |nexps|
                                                       (QREFELT $ 58))
                                             . #6#)
                                       (LETT |odl|
                                             (SPADCALL |dl| 1 (QREFELT $ 79))
                                             . #6#)
                                       (LETT |ndl|
                                             (SPADCALL |dl| 2 (QREFELT $ 79))
                                             . #6#)
                                       (COND
                                        ((NULL
                                          (SPADCALL |odl| NIL (QREFELT $ 80)))
                                         (SEQ
                                          (LETT |oer|
                                                (SPADCALL |nvars| |odl| |ndl|
                                                          |offsets| |exps|
                                                          |noffsets| |nexps|
                                                          (QREFELT $ 62))
                                                . #6#)
                                          (LETT |offsets| (QCAR |oer|) . #6#)
                                          (LETT |exps| (QCDR |oer|) . #6#)
                                          (LETT |ncc|
                                                (QUOTIENT2
                                                 (SPADCALL |exps|
                                                           (QREFELT $ 56))
                                                 |nvars|)
                                                . #6#)
                                          (EXIT
                                           (LETT |rstate|
                                                 (SPADCALL |ncc| |p|
                                                           (QREFELT $ 78))
                                                 . #6#)))))
                                       (COND
                                        ((NULL
                                          (SPADCALL |ndl| NIL (QREFELT $ 80)))
                                         (SEQ
                                          (LETT |n0| (QV32LEN |coeffs|) . #6#)
                                          (LETT |nn| (LENGTH |ndl|) . #6#)
                                          (LETT |n1| (+ |n0| |nn|) . #6#)
                                          (LETT |ncoeffs| (GETREFV32 |n1| 0)
                                                . #6#)
                                          (LETT |i| 0 . #6#)
                                          (LETT |jl| (|SPADfirst| |ndl|) . #6#)
                                          (SEQ (LETT |j| 0 . #6#)
                                               (LETT #4# (- |n1| 1) . #6#) G190
                                               (COND
                                                ((QSGREATERP |j| #4#) #7#))
                                               (SEQ
                                                (EXIT
                                                 (COND
                                                  ((EQL |j| |jl|)
                                                   (SEQ
                                                    (SETELT32 |ncoeffs| |j| 0)
                                                    (LETT |ndl| (CDR |ndl|)
                                                          . #6#)
                                                    (EXIT
                                                     (LETT |jl|
                                                           (COND
                                                            ((NULL |ndl|) |n1|)
                                                            ('T
                                                             (|SPADfirst|
                                                              |ndl|)))
                                                           . #6#))))
                                                  ('T
                                                   (SEQ
                                                    (SETELT32 |ncoeffs| |j|
                                                              (ELT32 |coeffs|
                                                                     |i|))
                                                    (EXIT
                                                     (LETT |i| (+ |i| 1)
                                                           . #6#)))))))
                                               (LETT |j| (QSADD1 |j|) . #6#)
                                               #8# G191 (EXIT NIL))
                                          (EXIT
                                           (LETT |coeffs| |ncoeffs| . #6#)))))
                                       (LETT |block_offsets|
                                             (|IMODHP;compute_blocks| |offsets|
                                              |m| |nsols| $)
                                             . #6#)
                                       (LETT |n1| (QV32LEN |coeffs|) . #6#)
                                       (LETT |ok| 'T . #6#)
                                       (SEQ
                                        (EXIT
                                         (SEQ (LETT |i| 1 . #6#) G190
                                              (COND
                                               ((QSGREATERP |i| |nsols|) #7#))
                                              (SEQ
                                               (LETT |cnum|
                                                     (SPADCALL |civ| |i|
                                                               (QREFELT $ 47))
                                                     . #6#)
                                               (LETT |ofin|
                                                     (+ (* |m| (- |i| 1))
                                                        |cnum|)
                                                     . #6#)
                                               (LETT |ofi|
                                                     (SPADCALL |offsets| |ofin|
                                                               (QREFELT $ 47))
                                                     . #6#)
                                               (LETT |nofi|
                                                     (COND
                                                      ((OR (< |i| |nsols|)
                                                           (< |cnum| |m|))
                                                       (SPADCALL |offsets|
                                                                 (+ |ofin| 1)
                                                                 (QREFELT $
                                                                          47)))
                                                      ('T |n1|))
                                                     . #6#)
                                               (LETT |nofi| (- |nofi| 1) . #6#)
                                               (EXIT
                                                (COND
                                                 ((< |nofi| |ofi|)
                                                  (SEQ
                                                   (SPADCALL
                                                    (SPADCALL |civ|
                                                              (QREFELT $ 81))
                                                    (QREFELT $ 75))
                                                   (SPADCALL
                                                    (SPADCALL |offsets|
                                                              (QREFELT $ 81))
                                                    (QREFELT $ 75))
                                                   (EXIT
                                                    (|error|
                                                     "Internal error: corrupted offsets 1"))))
                                                 ((EQL (ELT32 |coeffs| |nofi|)
                                                       0)
                                                  (SEQ (LETT |ok| 'NIL . #6#)
                                                       (EXIT
                                                        (PROGN
                                                         (LETT #3# |$NoValue|
                                                               . #6#)
                                                         (GO #3#)))))
                                                 ('T
                                                  (SEQ
                                                   (LETT |invc|
                                                         (SPADCALL
                                                          (ELT32 |coeffs|
                                                                 |nofi|)
                                                          |p| (QREFELT $ 82))
                                                         . #6#)
                                                   (LETT |lo|
                                                         (SPADCALL
                                                          |block_offsets| |i|
                                                          (QREFELT $ 47))
                                                         . #6#)
                                                   (LETT |hi|
                                                         (COND
                                                          ((< |i| |nsols|)
                                                           (SPADCALL
                                                            |block_offsets|
                                                            (+ |i| 1)
                                                            (QREFELT $ 47)))
                                                          ('T |n1|))
                                                         . #6#)
                                                   (EXIT
                                                    (SEQ (LETT |j| |lo| . #6#)
                                                         (LETT #2# (- |hi| 1)
                                                               . #6#)
                                                         G190
                                                         (COND
                                                          ((> |j| #2#) #7#))
                                                         (SEQ
                                                          (EXIT
                                                           (SETELT32 |coeffs|
                                                                     |j|
                                                                     (QSMULMOD32
                                                                      (ELT32
                                                                       |coeffs|
                                                                       |j|)
                                                                      |invc|
                                                                      |p|))))
                                                         (LETT |j| (+ |j| 1)
                                                               . #6#)
                                                         #8# G191
                                                         (EXIT NIL))))))))
                                              (LETT |i| (QSADD1 |i|) . #6#) #8#
                                              G191 (EXIT NIL)))
                                        #3# (EXIT #3#))
                                       (EXIT
                                        (COND
                                         (|ok|
                                          (SEQ
                                           (SPADCALL |coeffs| |pt| |rstate|
                                                     (QREFELT $ 83))
                                           (LETT |pp|
                                                 (SPADCALL |rstate| |nvars|
                                                           |block_offsets|
                                                           |offsets| |exps|
                                                           (QREFELT $ 86))
                                                 . #6#)
                                           (EXIT
                                            (COND ((QEQCAR |pp| 1) "iterate")
                                                  ('T
                                                   (SEQ
                                                    (LETT |rr| (QCDR |pp|)
                                                          . #6#)
                                                    (EXIT
                                                     (PROGN
                                                      (LETT #1#
                                                            (CONS 0
                                                                  (VECTOR |va|
                                                                          |civ|
                                                                          |m|
                                                                          (QVELT
                                                                           |rr|
                                                                           1)
                                                                          (QVELT
                                                                           |rr|
                                                                           2)
                                                                          (QVELT
                                                                           |rr|
                                                                           3)))
                                                            . #6#)
                                                      (GO #1#)))))))))
                                         ('T "iterate")))))))))))))
                         ('T (|error| "Run out of evaluation points")))))
                  NIL #8# G191 (EXIT NIL)))))
      #1# (EXIT #1#))))) 

(DEFUN |IMODHP;do_poly_integer0| (|vars| |gv0| |pss| |gen| $)
  (PROG (#1=#:G2146 |pp| #2=#:G2148 |j| |hi| |lo| |invc| #3=#:G2131 |ok| |nofi|
         |ofi| |ofin| |cnum| |i| |n1| |block_offsets| |coeffs| |jl| |ndl|
         #4=#:G2147 |ncoeffs| |nn| |n0| |rstate| |ncc| |exps| |offsets| |oer|
         |odl| |dl| |all_bad| |nsols| |chk_ress| |noffsets| |nexps| |civ| |va|
         |ppr| |pprp| |ngv0| |ngv0p| |lp| |p| |k| |nvars| |m|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |lp| NIL . #5=(|IMODHP;do_poly_integer0|))
            (LETT |exps| (SPADCALL (QREFELT $ 72)) . #5#)
            (LETT |offsets| (MAKE-ARRAY 0) . #5#) (LETT |all_bad| 'T . #5#)
            (LETT |p| 16 . #5#) (LETT |m| (QVELT |pss| 9) . #5#)
            (LETT |nvars| (LENGTH |vars|) . #5#) (LETT |nsols| (+ |m| 1) . #5#)
            (EXIT
             (SEQ G190 NIL
                  (SEQ (LETT |ok| 'NIL . #5#)
                       (SEQ (LETT |k| 1 . #5#) G190
                            (COND
                             ((OR (QSGREATERP |k| 100)
                                  (NULL (COND (|ok| 'NIL) ('T 'T))))
                              #6=(GO G191)))
                            (SEQ
                             (LETT |p|
                                   (SPADCALL (+ (RANDOM 200000) 200000)
                                             (QREFELT $ 88))
                                   . #5#)
                             (EXIT
                              (COND
                               ((SPADCALL |p| |lp| (QREFELT $ 73)) "iterate")
                               ('T
                                (SEQ (LETT |lp| (CONS |p| |lp|) . #5#)
                                     (EXIT (LETT |ok| 'T . #5#)))))))
                            (LETT |k| (QSADD1 |k|) . #5#) #7=(GO G190) G191
                            (EXIT NIL))
                       (EXIT
                        (COND
                         (|ok|
                          (SEQ (QSETVELT |pss| 5 |p|)
                               (LETT |ngv0p| (|IMODHP;eval3s| |gv0| |p| $)
                                     . #5#)
                               (EXIT
                                (COND ((QEQCAR |ngv0p| 1) "iterate")
                                      ('T
                                       (SEQ (LETT |ngv0| (QCDR |ngv0p|) . #5#)
                                            (LETT |pprp|
                                                  (SPADCALL |vars| |ngv0| |pss|
                                                            |gen|
                                                            (QREFELT $ 70))
                                                  . #5#)
                                            (EXIT
                                             (COND
                                              ((QEQCAR |pprp| 2)
                                               (PROGN
                                                (LETT #1#
                                                      (CONS 1 "no_solution")
                                                      . #5#)
                                                (GO #1#)))
                                              ((QEQCAR |pprp| 1) "iterate")
                                              ('T
                                               (SEQ
                                                (LETT |ppr| (QCDR |pprp|)
                                                      . #5#)
                                                (LETT |va| (QVELT |ppr| 0)
                                                      . #5#)
                                                (LETT |civ| (QVELT |ppr| 1)
                                                      . #5#)
                                                (LETT |nexps| (QVELT |ppr| 4)
                                                      . #5#)
                                                (LETT |noffsets|
                                                      (QVELT |ppr| 3) . #5#)
                                                (LETT |coeffs| (QVELT |ppr| 5)
                                                      . #5#)
                                                (LETT |chk_ress|
                                                      (|IMODHP;check_defects|
                                                       |va| |civ| |pss| $)
                                                      . #5#)
                                                (EXIT
                                                 (COND
                                                  ((QEQCAR |chk_ress| 1)
                                                   "iterate")
                                                  ('T
                                                   (SEQ
                                                    (COND
                                                     ((QEQCAR |chk_ress| 2)
                                                      (LETT |all_bad| 'T
                                                            . #5#)))
                                                    (COND
                                                     (|all_bad|
                                                      (SEQ
                                                       (LETT |nsols|
                                                             (QVSIZE |va|)
                                                             . #5#)
                                                       (QSETVELT |pss| 10
                                                                 |nsols|)
                                                       (QSETVELT |pss| 7 |va|)
                                                       (QSETVELT |pss| 8 |civ|)
                                                       (LETT |exps| |nexps|
                                                             . #5#)
                                                       (LETT |offsets|
                                                             |noffsets| . #5#)
                                                       (EXIT
                                                        (LETT |rstate|
                                                              (SPADCALL
                                                               (QV32LEN
                                                                |coeffs|)
                                                               (QREFELT $ 90))
                                                              . #5#)))))
                                                    (LETT |all_bad| 'NIL . #5#)
                                                    (LETT |dl|
                                                          (SPADCALL
                                                           (+ |nvars| 1)
                                                           |offsets| |exps|
                                                           |noffsets| |nexps|
                                                           (QREFELT $ 58))
                                                          . #5#)
                                                    (LETT |odl|
                                                          (SPADCALL |dl| 1
                                                                    (QREFELT $
                                                                             79))
                                                          . #5#)
                                                    (LETT |ndl|
                                                          (SPADCALL |dl| 2
                                                                    (QREFELT $
                                                                             79))
                                                          . #5#)
                                                    (COND
                                                     ((NULL
                                                       (SPADCALL |odl| NIL
                                                                 (QREFELT $
                                                                          80)))
                                                      (SEQ
                                                       (LETT |oer|
                                                             (SPADCALL
                                                              (+ |nvars| 1)
                                                              |odl| |ndl|
                                                              |offsets| |exps|
                                                              |noffsets|
                                                              |nexps|
                                                              (QREFELT $ 62))
                                                             . #5#)
                                                       (LETT |offsets|
                                                             (QCAR |oer|)
                                                             . #5#)
                                                       (LETT |exps|
                                                             (QCDR |oer|)
                                                             . #5#)
                                                       (LETT |ncc|
                                                             (QUOTIENT2
                                                              (SPADCALL |exps|
                                                                        (QREFELT
                                                                         $ 56))
                                                              (+ |nvars| 1))
                                                             . #5#)
                                                       (EXIT
                                                        (LETT |rstate|
                                                              (SPADCALL |ncc|
                                                                        (QREFELT
                                                                         $ 90))
                                                              . #5#)))))
                                                    (COND
                                                     ((NULL
                                                       (SPADCALL |ndl| NIL
                                                                 (QREFELT $
                                                                          80)))
                                                      (SEQ
                                                       (LETT |n0|
                                                             (QV32LEN |coeffs|)
                                                             . #5#)
                                                       (LETT |nn|
                                                             (LENGTH |ndl|)
                                                             . #5#)
                                                       (LETT |n1| (+ |n0| |nn|)
                                                             . #5#)
                                                       (LETT |ncoeffs|
                                                             (GETREFV32 |n1| 0)
                                                             . #5#)
                                                       (LETT |i| 0 . #5#)
                                                       (LETT |jl|
                                                             (|SPADfirst|
                                                              |ndl|)
                                                             . #5#)
                                                       (SEQ (LETT |j| 0 . #5#)
                                                            (LETT #4#
                                                                  (- |n1| 1)
                                                                  . #5#)
                                                            G190
                                                            (COND
                                                             ((QSGREATERP |j|
                                                                          #4#)
                                                              #6#))
                                                            (SEQ
                                                             (EXIT
                                                              (COND
                                                               ((EQL |j| |jl|)
                                                                (SEQ
                                                                 (SETELT32
                                                                  |ncoeffs| |j|
                                                                  0)
                                                                 (LETT |ndl|
                                                                       (CDR
                                                                        |ndl|)
                                                                       . #5#)
                                                                 (EXIT
                                                                  (LETT |jl|
                                                                        (COND
                                                                         ((NULL
                                                                           |ndl|)
                                                                          |n1|)
                                                                         ('T
                                                                          (|SPADfirst|
                                                                           |ndl|)))
                                                                        . #5#))))
                                                               ('T
                                                                (SEQ
                                                                 (SETELT32
                                                                  |ncoeffs| |j|
                                                                  (ELT32
                                                                   |coeffs|
                                                                   |i|))
                                                                 (EXIT
                                                                  (LETT |i|
                                                                        (+ |i|
                                                                           1)
                                                                        . #5#)))))))
                                                            (LETT |j|
                                                                  (QSADD1 |j|)
                                                                  . #5#)
                                                            #7# G191
                                                            (EXIT NIL))
                                                       (EXIT
                                                        (LETT |coeffs|
                                                              |ncoeffs|
                                                              . #5#)))))
                                                    (LETT |block_offsets|
                                                          (|IMODHP;compute_blocks|
                                                           |offsets| |m|
                                                           |nsols| $)
                                                          . #5#)
                                                    (LETT |n1|
                                                          (QV32LEN |coeffs|)
                                                          . #5#)
                                                    (LETT |ok| 'T . #5#)
                                                    (SEQ
                                                     (EXIT
                                                      (SEQ (LETT |i| 1 . #5#)
                                                           G190
                                                           (COND
                                                            ((QSGREATERP |i|
                                                                         |nsols|)
                                                             #6#))
                                                           (SEQ
                                                            (LETT |cnum|
                                                                  (SPADCALL
                                                                   |civ| |i|
                                                                   (QREFELT $
                                                                            47))
                                                                  . #5#)
                                                            (LETT |ofin|
                                                                  (+
                                                                   (* |m|
                                                                      (- |i|
                                                                         1))
                                                                   |cnum|)
                                                                  . #5#)
                                                            (LETT |ofi|
                                                                  (SPADCALL
                                                                   |offsets|
                                                                   |ofin|
                                                                   (QREFELT $
                                                                            47))
                                                                  . #5#)
                                                            (LETT |nofi|
                                                                  (COND
                                                                   ((OR
                                                                     (< |i|
                                                                        |nsols|)
                                                                     (< |cnum|
                                                                        |m|))
                                                                    (SPADCALL
                                                                     |offsets|
                                                                     (+ |ofin|
                                                                        1)
                                                                     (QREFELT $
                                                                              47)))
                                                                   ('T |n1|))
                                                                  . #5#)
                                                            (LETT |nofi|
                                                                  (- |nofi| 1)
                                                                  . #5#)
                                                            (EXIT
                                                             (COND
                                                              ((< |nofi| |ofi|)
                                                               (SEQ
                                                                (SPADCALL
                                                                 (SPADCALL
                                                                  |civ|
                                                                  (QREFELT $
                                                                           81))
                                                                 (QREFELT $
                                                                          75))
                                                                (SPADCALL
                                                                 (SPADCALL
                                                                  |offsets|
                                                                  (QREFELT $
                                                                           81))
                                                                 (QREFELT $
                                                                          75))
                                                                (EXIT
                                                                 (|error|
                                                                  "Internal error: corrupted offsets"))))
                                                              ((EQL
                                                                (ELT32 |coeffs|
                                                                       |nofi|)
                                                                0)
                                                               (SEQ
                                                                (LETT |ok| 'NIL
                                                                      . #5#)
                                                                (EXIT
                                                                 (PROGN
                                                                  (LETT #3#
                                                                        |$NoValue|
                                                                        . #5#)
                                                                  (GO #3#)))))
                                                              ('T
                                                               (SEQ
                                                                (LETT |invc|
                                                                      (SPADCALL
                                                                       (ELT32
                                                                        |coeffs|
                                                                        |nofi|)
                                                                       |p|
                                                                       (QREFELT
                                                                        $ 82))
                                                                      . #5#)
                                                                (LETT |lo|
                                                                      (SPADCALL
                                                                       |block_offsets|
                                                                       |i|
                                                                       (QREFELT
                                                                        $ 47))
                                                                      . #5#)
                                                                (LETT |hi|
                                                                      (COND
                                                                       ((< |i|
                                                                           |nsols|)
                                                                        (SPADCALL
                                                                         |block_offsets|
                                                                         (+ |i|
                                                                            1)
                                                                         (QREFELT
                                                                          $
                                                                          47)))
                                                                       ('T
                                                                        |n1|))
                                                                      . #5#)
                                                                (EXIT
                                                                 (SEQ
                                                                  (LETT |j|
                                                                        |lo|
                                                                        . #5#)
                                                                  (LETT #2#
                                                                        (- |hi|
                                                                           1)
                                                                        . #5#)
                                                                  G190
                                                                  (COND
                                                                   ((> |j| #2#)
                                                                    #6#))
                                                                  (SEQ
                                                                   (EXIT
                                                                    (SETELT32
                                                                     |coeffs|
                                                                     |j|
                                                                     (QSMULMOD32
                                                                      (ELT32
                                                                       |coeffs|
                                                                       |j|)
                                                                      |invc|
                                                                      |p|))))
                                                                  (LETT |j|
                                                                        (+ |j|
                                                                           1)
                                                                        . #5#)
                                                                  #7# G191
                                                                  (EXIT
                                                                   NIL))))))))
                                                           (LETT |i|
                                                                 (QSADD1 |i|)
                                                                 . #5#)
                                                           #7# G191
                                                           (EXIT NIL)))
                                                     #3# (EXIT #3#))
                                                    (EXIT
                                                     (COND
                                                      (|ok|
                                                       (SEQ
                                                        (SPADCALL |coeffs| |p|
                                                                  |rstate|
                                                                  (QREFELT $
                                                                           91))
                                                        (LETT |pp|
                                                              (SPADCALL
                                                               |rstate|
                                                               |block_offsets|
                                                               (QREFELT $ 93))
                                                              . #5#)
                                                        (EXIT
                                                         (COND
                                                          ((QEQCAR |pp| 1)
                                                           "iterate")
                                                          ('T
                                                           (PROGN
                                                            (LETT #1#
                                                                  (CONS 0
                                                                        (VECTOR
                                                                         |va|
                                                                         |civ|
                                                                         |m|
                                                                         |offsets|
                                                                         |exps|
                                                                         (QCDR
                                                                          |pp|)))
                                                                  . #5#)
                                                            (GO #1#)))))))
                                                      ('T
                                                       "iterate")))))))))))))))))
                         ('T (|error| "Run out of primes")))))
                  NIL #7# G191 (EXIT NIL)))))
      #1# (EXIT #1#))))) 

(DEFUN |IMODHP;do_poly_integer;LPaVNniUv2SMU;16|
       (|vars| |gv0| |ve| |sigma| |pts| |kind| |qvar| |gen| $)
  (PROG (#1=#:G2155 |pss|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |pss|
              (VECTOR |ve| |sigma| |pts| |qvar| 0 0 |kind| (MAKE-ARRAY 0)
                      (MAKE-ARRAY 0) (QVSIZE |ve|) (+ (QVSIZE |ve|) 1)
                      (GETREFV32 10 0) (SPADCALL 10 0 (QREFELT $ 15)))
              . #2=(|IMODHP;do_poly_integer;LPaVNniUv2SMU;16|))
        (EXIT
         (PROGN
          (LETT #1# (|IMODHP;do_poly_integer0| |vars| |gv0| |pss| |gen| $)
                . #2#)
          (GO #1#)))))
      #1# (EXIT #1#))))) 

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

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

(MAKEPROP '|InnerModularHermitePade| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|PositiveInteger|)
              (|NonNegativeInteger|) (0 . *) (|Void|) (|U32Vector|) (|Integer|)
              (|U32VectorPolynomialOperations|) (6 . |copy_first|)
              (|SortedExponentVector|) (13 . |new|) (19 . |setelt|)
              (26 . |elt|) (|Polynomial| 11) (|Fraction| 18) (32 . |numer|)
              (37 . |denom|) (|SingleInteger|) (42 . |invmod|)
              (48 . |positiveRemainder|) (54 . |Zero|) (|Boolean|) (58 . =)
              (|Record| (|:| |k| 7) (|:| |c| 18)) (|List| 28) (64 . =)
              (|List| 53) (|List| 11) |IMODHP;modpeval;PLL2I;4| (70 . |Zero|)
              (74 . |eval|) (81 . /) (|List| 43) (|Vector| 10) (|Vector| 11)
              (|NaiveBeckermannLabahnModular|) (87 . |naiveBeckermannLabahn|)
              (95 . |naiveBeckermannLabahnMultipoint|) (|Any|) (103 . |elt|)
              (|AnyFunctions1| 39) (109 . |retract|) (114 . |elt|)
              (|AnyFunctions1| 38) (120 . |retract|)
              (|Record| (|:| |basis| 63) (|:| |defects| 39) (|:| |cinds| 39))
              (125 . |reduceBasis|) (|Union| 50 '"no_solution") (|Symbol|)
              |IMODHP;do_modular_solve;VVNniUvISU;8| (133 . |setelt|)
              (140 . |#|) (|List| 32) |IMODHP;merge_exponents;IVSevVSevL;10|
              (145 . |One|) (149 . |One|)
              (|Record| (|:| |offsetdata| 39) (|:| |expdata| 14))
              |IMODHP;merge2;I2LVSevVSevR;11| (|TwoDimensionalArray| 10)
              (153 . |elt|)
              (|Record| (|:| |defects| 39) (|:| |cinds| 39) (|:| |rowlen| 11)
                        (|:| |offsetdata| 39) (|:| |expdata| 14)
                        (|:| |coeffdata| 10))
              (|Union| 65 '"failed" '"no_solution") (|PrimitiveArray| 19)
              (|Record| (|:| |degree_bounds| 39) (|:| |pss_sigma| 7)
                        (|:| |points| 10) (|:| |pss_qvar| 53)
                        (|:| |pss_qval| 11) (|:| |prime| 11)
                        (|:| |pss_kind| 53) (|:| |oldva| 39) (|:| |oldciv| 39)
                        (|:| |pss_m| 11) (|:| |sol_cnt| 11)
                        (|:| |eval1coeffbuf| 10) (|:| |eval1expbuf| 14))
              (|Mapping| 38 10 11 11) |IMODHP;do_poly_modular;LPaRMU;14|
              |IMODHP;eval_and_solve;ILPaRMU;13| (160 . |empty|)
              (164 . |member?|) (|OutputForm|) (170 . |print|) (175 . |coerce|)
              (|VectorModularReconstructor|) (180 . |empty|) (186 . |elt|)
              (192 . =) (198 . |coerce|) (203 . |invmod|)
              (209 . |chinese_update|)
              (|Record| (|:| |nvars| 11) (|:| |offsetdata| 39)
                        (|:| |expdata| 14) (|:| |coeffdata| 10))
              (|Union| 84 '"failed") (216 . |reconstruct|)
              (|IntegerPrimesPackage| 11) (225 . |nextPrime|)
              (|VectorIntegerReconstructor|) (230 . |empty|)
              (235 . |chinese_update|)
              (|Union| (|PrimitiveArray| 11) '"failed") (242 . |reconstruct|)
              (|Record| (|:| |defects| 39) (|:| |cinds| 39) (|:| |rowlen| 11)
                        (|:| |offsetdata| 39) (|:| |expdata| 14)
                        (|:| |coeffdata| (|PrimitiveArray| 11)))
              (|Union| 94 '"no_solution")
              |IMODHP;do_poly_integer;LPaVNniUv2SMU;16|)
           '#(|modpeval| 248 |merge_exponents| 256 |merge2| 265
              |eval_and_solve| 276 |do_poly_modular| 285 |do_poly_integer| 293
              |do_modular_solve| 305)
           'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 96
                                                 '(2 7 0 6 0 8 3 12 9 10 10 11
                                                   13 2 14 0 7 11 15 3 14 11 0
                                                   11 11 16 2 14 11 0 11 17 1
                                                   19 18 0 20 1 19 18 0 21 2 22
                                                   0 0 0 23 2 11 0 0 0 24 0 18
                                                   0 25 2 18 26 0 0 27 2 29 26
                                                   0 0 30 0 19 0 34 3 18 0 0 31
                                                   32 35 2 19 0 18 18 36 4 40
                                                   37 38 39 7 11 41 4 40 37 38
                                                   39 10 11 42 2 37 43 0 11 44
                                                   1 45 39 43 46 2 39 11 0 11
                                                   47 1 48 38 43 49 4 40 50 38
                                                   39 39 11 51 3 39 11 0 11 11
                                                   55 1 14 7 0 56 0 18 0 59 0
                                                   19 0 60 3 63 10 0 11 11 64 0
                                                   14 0 72 2 32 26 11 0 73 1 74
                                                   9 0 75 1 11 74 0 76 2 77 0
                                                   11 11 78 2 57 32 0 11 79 2
                                                   32 26 0 0 80 1 39 74 0 81 2
                                                   11 0 0 0 82 3 77 9 10 11 0
                                                   83 5 77 85 0 11 39 39 14 86
                                                   1 87 11 11 88 1 89 0 11 90 3
                                                   89 9 10 11 0 91 2 89 92 0 39
                                                   93 4 0 11 18 31 32 11 33 5 0
                                                   57 11 39 14 39 14 58 7 0 61
                                                   11 32 32 39 14 39 14 62 5 0
                                                   66 11 31 67 68 69 71 4 0 66
                                                   31 67 68 69 70 8 0 95 31 67
                                                   39 7 10 53 53 69 96 6 0 52
                                                   38 39 7 10 11 53 54)))))
           '|lookupComplete|)) 

(MAKEPROP '|InnerModularHermitePade| 'NILADIC T) 
