
(/VERSIONCHECK 2) 

(DEFUN |NFINTBAS;frobMatrix| (|rb| |rbinv| |rbden| |p| $)
  (PROG (|n| |b| |v| |ii| #0=#:G1839 |i| #1=#:G1838 |jj| #2=#:G1841 |j|
             #3=#:G1840 |a| |mat| #4=#:G1834)
    (RETURN
      (SEQ (LETT |n| (SPADCALL (QREFELT $ 9))
                 . #5=(|NFINTBAS;frobMatrix|))
           (LETT |b| (SPADCALL (QREFELT $ 11)) . #5#)
           (LETT |v|
                 (SPADCALL |n| (|spadConstant| $ 13) (QREFELT $ 16)) . #5#)
           (SEQ (LETT |ii| (SPADCALL |rb| (QREFELT $ 20)) . #5#)
                (LETT #0# (SPADCALL |rb| (QREFELT $ 21)) . #5#)
                (LETT |i| (SPADCALL |v| (QREFELT $ 18)) . #5#)
                (LETT #1# (QVSIZE |v|) . #5#) G190
                (COND ((OR (> |i| #1#) (> |ii| #0#)) #6=(GO G191)))
                (SEQ (LETT |a| (|spadConstant| $ 13) . #5#)
                     (SEQ (LETT |jj|
                                (SPADCALL |rb| (QREFELT $ 22)) . #5#)
                          (LETT #2#
                                (SPADCALL |rb| (QREFELT $ 23)) . #5#)
                          (LETT |j|
                                (SPADCALL |b| (QREFELT $ 18)) . #5#)
                          (LETT #3# (QVSIZE |b|) . #5#) G190
                          (COND ((OR (> |j| #3#) (> |jj| #2#)) #6#))
                          (SEQ (EXIT (LETT |a|
                                      (SPADCALL |a|
                                       (SPADCALL
                                        (SPADCALL |rb| |ii| |jj|
                                         (QREFELT $ 24))
                                        (SPADCALL |b| |j|
                                         (QREFELT $ 25))
                                        (QREFELT $ 26))
                                       (QREFELT $ 27)) . #5#)))
                          (LETT |j|
                                (PROG1 (+ |j| 1)
                                  (LETT |jj| (+ |jj| 1) . #5#)) . #5#)
                          #7=(GO G190) G191 (EXIT NIL))
                     (EXIT (SPADCALL |v| |i|
                               (SPADCALL |a| |p| (QREFELT $ 28))
                               (QREFELT $ 29))))
                (LETT |i|
                      (PROG1 (+ |i| 1) (LETT |ii| (+ |ii| 1) . #5#)) . #5#)
                #7# G191 (EXIT NIL))
           (LETT |mat|
                 (SPADCALL (SPADCALL |v| (QREFELT $ 30))
                     (QREFELT $ 31)) . #5#)
           (EXIT (PROG2 (LETT #4#
                              (SPADCALL
                                  (SPADCALL
                                      (SPADCALL |rbinv| (QREFELT $ 31))
                                      |mat| (QREFELT $ 32))
                                  (EXPT |rbden| |p|) (QREFELT $ 34)) . #5#)
                        (QCDR #4#)
                   (|check-union| (QEQCAR #4# 0) (|Matrix| (|Integer|))
                       #4#))))))) 

(DEFUN |NFINTBAS;wildPrimes| (|factoredDisc| |n| $)
  (PROG (|f| #0=#:G1850 |ans|)
    (RETURN
      (SEQ (LETT |ans| NIL . #1=(|NFINTBAS;wildPrimes|))
           (SEQ (LETT |f| NIL . #1#)
                (LETT #0#
                      (SPADCALL |factoredDisc| (QREFELT $ 38)) . #1#)
                G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |f| (CAR #0#) . #1#) NIL))
                   (GO G191)))
                (SEQ (EXIT (COND
                             ((< 1 (QCDR |f|))
                              (COND
                                ((NULL (< |n| (QCAR |f|)))
                                 (LETT |ans|
                                       (CONS (QCAR |f|) |ans|) . #1#)))))))
                (LETT #0# (CDR #0#) . #1#) (GO G190) G191 (EXIT NIL))
           (EXIT |ans|))))) 

(DEFUN |NFINTBAS;tameProduct| (|factoredDisc| |n| $)
  (PROG (|f| #0=#:G1857 |ans|)
    (RETURN
      (SEQ (LETT |ans| 1 . #1=(|NFINTBAS;tameProduct|))
           (SEQ (LETT |f| NIL . #1#)
                (LETT #0#
                      (SPADCALL |factoredDisc| (QREFELT $ 38)) . #1#)
                G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |f| (CAR #0#) . #1#) NIL))
                   (GO G191)))
                (SEQ (EXIT (COND
                             ((< 1 (QCDR |f|))
                              (COND
                                ((< |n| (QCAR |f|))
                                 (LETT |ans|
                                       (* (QCAR |f|) |ans|) . #1#)))))))
                (LETT #0# (CDR #0#) . #1#) (GO G190) G191 (EXIT NIL))
           (EXIT |ans|))))) 

(DEFUN |NFINTBAS;integralBasis;R;4| ($)
  (PROG (|traceMat| |n| |disc0| |factoredDisc| |wilds| |sing|
            |matrixOut| |p| #0=#:G1869 |lb| |rb| |rbinv| |rbden| |disc|
            |mat| |runningRbden| |runningRb| |runningRbinv|)
    (RETURN
      (SEQ (LETT |traceMat| (SPADCALL (QREFELT $ 41))
                 . #1=(|NFINTBAS;integralBasis;R;4|))
           (LETT |n| (SPADCALL (QREFELT $ 9)) . #1#)
           (LETT |disc| (SPADCALL |traceMat| (QREFELT $ 42)) . #1#)
           (LETT |disc0| |disc| . #1#)
           (LETT |factoredDisc|
                 (SPADCALL |disc0| (QREFELT $ 44)) . #1#)
           (LETT |wilds|
                 (|NFINTBAS;wildPrimes| |factoredDisc| |n| $) . #1#)
           (LETT |sing|
                 (|NFINTBAS;tameProduct| |factoredDisc| |n| $) . #1#)
           (LETT |runningRb| (SPADCALL |n| 1 (QREFELT $ 45)) . #1#)
           (LETT |runningRbinv| (SPADCALL |n| 1 (QREFELT $ 45)) . #1#)
           (LETT |runningRbden| 1 . #1#)
           (COND
             ((EQL |sing| 1)
              (COND
                ((NULL |wilds|)
                 (EXIT (VECTOR |runningRb| |runningRbden|
                               |runningRbinv|))))))
           (LETT |matrixOut| (SPADCALL |n| 0 (QREFELT $ 45)) . #1#)
           (SEQ (LETT |p| NIL . #1#) (LETT #0# |wilds| . #1#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |p| (CAR #0#) . #1#) NIL))
                   (GO G191)))
                (SEQ (LETT |lb|
                           (|NFINTBAS;iWildLocalIntegralBasis|
                               |matrixOut| |disc| |p| $) . #1#)
                     (LETT |rb| (QVELT |lb| 0) . #1#)
                     (LETT |rbinv| (QVELT |lb| 2) . #1#)
                     (LETT |rbden| (QVELT |lb| 1) . #1#)
                     (LETT |disc| (QVELT |lb| 3) . #1#)
                     (EXIT (COND
                             ((SPADCALL 1 |rbden| (QREFELT $ 47))
                              (SEQ (LETT |mat|
                                    (SPADCALL
                                     (SPADCALL |rbden| |runningRb|
                                      (QREFELT $ 48))
                                     (SPADCALL |runningRbden| |rb|
                                      (QREFELT $ 48))
                                     (QREFELT $ 49)) . #1#)
                                   (LETT |runningRbden|
                                    (* |runningRbden| |rbden|) . #1#)
                                   (LETT |runningRb|
                                    (SPADCALL
                                     (SPADCALL |mat| |runningRbden|
                                      (QREFELT $ 51))
                                     (QREFELT $ 52)) . #1#)
                                   (EXIT
                                    (LETT |runningRbinv|
                                     (SPADCALL |runningRb|
                                      |runningRbden| (QREFELT $ 54)) . #1#)))))))
                (LETT #0# (CDR #0#) . #1#) (GO G190) G191 (EXIT NIL))
           (LETT |lb|
                 (|NFINTBAS;iTameLocalIntegralBasis| |traceMat| |disc|
                     |sing| $) . #1#)
           (LETT |rb| (QVELT |lb| 0) . #1#)
           (LETT |rbinv| (QVELT |lb| 2) . #1#)
           (LETT |rbden| (QVELT |lb| 1) . #1#)
           (LETT |disc| (QVELT |lb| 3) . #1#)
           (COND
             ((SPADCALL 1 |rbden| (QREFELT $ 47))
              (SEQ (LETT |mat|
                         (SPADCALL (SPADCALL |rbden| |runningRb|
                                    (QREFELT $ 48))
                                   (SPADCALL |runningRbden| |rb|
                                    (QREFELT $ 48))
                                   (QREFELT $ 49)) . #1#)
                   (LETT |runningRbden|
                         (* |runningRbden| |rbden|) . #1#)
                   (LETT |runningRb|
                         (SPADCALL
                             (SPADCALL |mat| |runningRbden|
                                 (QREFELT $ 51))
                             (QREFELT $ 52)) . #1#)
                   (EXIT (LETT |runningRbinv|
                               (SPADCALL |runningRb| |runningRbden|
                                   (QREFELT $ 54)) . #1#)))))
           (EXIT (VECTOR |runningRb| |runningRbden| |runningRbinv|)))))) 

(DEFUN |NFINTBAS;localIntegralBasis;IR;5| (|p| $)
  (PROG (|traceMat| |n| |disc| |lb|)
    (RETURN
      (SEQ (LETT |traceMat| (SPADCALL (QREFELT $ 41))
                 . #0=(|NFINTBAS;localIntegralBasis;IR;5|))
           (LETT |n| (SPADCALL (QREFELT $ 9)) . #0#)
           (LETT |disc| (SPADCALL |traceMat| (QREFELT $ 42)) . #0#)
           (EXIT (COND
                   ((QEQCAR (SPADCALL |disc| (* |p| |p|)
                                (QREFELT $ 57))
                            1)
                    (VECTOR (SPADCALL |n| 1 (QREFELT $ 45)) 1
                            (SPADCALL |n| 1 (QREFELT $ 45))))
                   ('T
                    (SEQ (LETT |lb|
                               (COND
                                 ((< (SPADCALL (QREFELT $ 9)) |p|)
                                  (|NFINTBAS;iTameLocalIntegralBasis|
                                      |traceMat| |disc| |p| $))
                                 ('T
                                  (|NFINTBAS;iWildLocalIntegralBasis|
                                      (SPADCALL |n| 0 (QREFELT $ 45))
                                      |disc| |p| $))) . #0#)
                         (EXIT (VECTOR (QVELT |lb| 0) (QVELT |lb| 1)
                                       (QVELT |lb| 2))))))))))) 

(DEFUN |NFINTBAS;iTameLocalIntegralBasis| (|traceMat| |disc| |sing| $)
  (PROG (|n| |disc0| |id| |idinv| |index| |g| |rb| |rbden| |rbinv|
             |indexChange| |oldIndex| #0=#:G1886 #1=#:G1880 |tfm|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |n| (SPADCALL (QREFELT $ 9))
                            . #2=(|NFINTBAS;iTameLocalIntegralBasis|))
                      (LETT |disc0| |disc| . #2#)
                      (LETT |rb| (SPADCALL |n| 1 (QREFELT $ 45)) . #2#)
                      (LETT |rbinv|
                            (SPADCALL |n| 1 (QREFELT $ 45)) . #2#)
                      (LETT |rbden| 1 . #2#) (LETT |index| 1 . #2#)
                      (LETT |oldIndex| 1 . #2#)
                      (LETT |tfm| |traceMat| . #2#)
                      (EXIT (SEQ G190 NIL
                                 (SEQ (LETT |idinv|
                                       (SPADCALL
                                        (SPADCALL
                                         (SPADCALL |tfm| |sing|
                                          (QREFELT $ 51))
                                         (QREFELT $ 52))
                                        (QREFELT $ 31)) . #2#)
                                      (LETT |id|
                                       (SPADCALL
                                        (SPADCALL |idinv| |sing|
                                         (QREFELT $ 59))
                                        (QREFELT $ 60)) . #2#)
                                      (LETT |idinv|
                                       (SPADCALL |id| |sing|
                                        (QREFELT $ 54)) . #2#)
                                      (LETT |rbinv|
                                       (SPADCALL
                                        (SPADCALL |id| |rb|
                                         (QREFELT $ 32))
                                        (SPADCALL |rbinv| |idinv|
                                         (QREFELT $ 32))
                                        (* |sing| |rbden|)
                                        (QREFELT $ 62)) . #2#)
                                      (LETT |index|
                                       (SPADCALL |rbinv|
                                        (QREFELT $ 63)) . #2#)
                                      (LETT |rb|
                                       (SPADCALL
                                        (SPADCALL |rbinv|
                                         (* |sing| |rbden|)
                                         (QREFELT $ 59))
                                        (QREFELT $ 60)) . #2#)
                                      (LETT |g|
                                       (SPADCALL |rb| |sing| |n|
                                        (QREFELT $ 64)) . #2#)
                                      (COND
                                        ((SPADCALL 1 |g|
                                          (QREFELT $ 47))
                                         (LETT |rb|
                                          (PROG2
                                           (LETT #1#
                                            (SPADCALL |rb| |g|
                                             (QREFELT $ 34)) . #2#)
                                           (QCDR #1#)
                                            (|check-union|
                                             (QEQCAR #1# 0)
                                             (|Matrix| (|Integer|))
                                             #1#)) . #2#)))
                                      (LETT |rbden|
                                       (* |rbden|
                                        (QUOTIENT2 |sing| |g|)) . #2#)
                                      (LETT |rbinv|
                                       (SPADCALL |rb| |rbden|
                                        (QREFELT $ 54)) . #2#)
                                      (LETT |disc|
                                       (QUOTIENT2 |disc0|
                                        (* |index| |index|)) . #2#)
                                      (LETT |indexChange|
                                       (QUOTIENT2 |index| |oldIndex|) . #2#)
                                      (LETT |oldIndex| |index| . #2#)
                                      (EXIT
                                       (COND
                                         ((EQL |indexChange| 1)
                                          (PROGN
                                            (LETT #0#
                                             (VECTOR |rb| |rbden|
                                              |rbinv| |disc|) . #2#)
                                            (GO #0#)))
                                         ('T
                                          (LETT |tfm|
                                           (PROG2
                                            (LETT #1#
                                             (SPADCALL
                                              (SPADCALL
                                               (SPADCALL |rb|
                                                |traceMat|
                                                (QREFELT $ 32))
                                               (SPADCALL |rb|
                                                (QREFELT $ 31))
                                               (QREFELT $ 32))
                                              (* |rbden| |rbden|)
                                              (QREFELT $ 34)) . #2#)
                                            (QCDR #1#)
                                             (|check-union|
                                              (QEQCAR #1# 0)
                                              (|Matrix| (|Integer|))
                                              #1#)) . #2#)))))
                                 NIL (GO G190) G191 (EXIT NIL)))))
           #0# (EXIT #0#))))) 

(DEFUN |NFINTBAS;iWildLocalIntegralBasis| (|matrixOut| |disc| |p| $)
  (PROG (|n| |disc0| |p2| #0=#:G1888 |lp| #1=#:G1922 |tfm| |id| |idinv|
             |index| |rb| |rbden| |rbinv| |indexChange| |oldIndex|
             #2=#:G1928 #3=#:G1924)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |n| (SPADCALL (QREFELT $ 9))
                            . #4=(|NFINTBAS;iWildLocalIntegralBasis|))
                      (LETT |disc0| |disc| . #4#)
                      (LETT |rb| (SPADCALL |n| 1 (QREFELT $ 45)) . #4#)
                      (LETT |rbinv|
                            (SPADCALL |n| 1 (QREFELT $ 45)) . #4#)
                      (LETT |rbden| 1 . #4#) (LETT |index| 1 . #4#)
                      (LETT |oldIndex| 1 . #4#)
                      (LETT |p2| (* |p| |p|) . #4#)
                      (LETT |lp|
                            (SPADCALL
                                (PROG1 (LETT #0# |p| . #4#)
                                  (|check-subtype| (>= #0# 0)
                                      '(|NonNegativeInteger|) #0#))
                                |n| (QREFELT $ 65)) . #4#)
                      (EXIT (SEQ G190 NIL
                                 (SEQ (LETT |tfm|
                                       (SPADCALL
                                        (|NFINTBAS;frobMatrix| |rb|
                                         |rbinv| |rbden|
                                         (PROG1 (LETT #1# |p| . #4#)
                                           (|check-subtype| (>= #1# 0)
                                            '(|NonNegativeInteger|)
                                            #1#))
                                         $)
                                        |lp| (QREFELT $ 66)) . #4#)
                                      (LETT |idinv|
                                       (SPADCALL
                                        (SPADCALL
                                         (SPADCALL |tfm| |p|
                                          (QREFELT $ 51))
                                         (QREFELT $ 52))
                                        (QREFELT $ 31)) . #4#)
                                      (LETT |id|
                                       (SPADCALL
                                        (SPADCALL |idinv| |p|
                                         (QREFELT $ 59))
                                        (QREFELT $ 60)) . #4#)
                                      (LETT |idinv|
                                       (SPADCALL |id| |p|
                                        (QREFELT $ 54)) . #4#)
                                      (LETT |rbinv|
                                       (SPADCALL
                                        (SPADCALL |id| |rb|
                                         (QREFELT $ 32))
                                        (SPADCALL |rbinv| |idinv|
                                         (QREFELT $ 32))
                                        (* |p| |rbden|) (QREFELT $ 62)) . #4#)
                                      (LETT |index|
                                       (SPADCALL |rbinv|
                                        (QREFELT $ 63)) . #4#)
                                      (LETT |rb|
                                       (SPADCALL
                                        (SPADCALL |rbinv|
                                         (* |p| |rbden|)
                                         (QREFELT $ 59))
                                        (QREFELT $ 60)) . #4#)
                                      (COND
                                        ((EQL
                                          (SPADCALL |rb| |matrixOut|
                                           |p| |n| (QREFELT $ 67))
                                          1)
                                         (LETT |rb| |matrixOut| . #4#))
                                        ('T
                                         (LETT |rbden|
                                          (* |p| |rbden|) . #4#)))
                                      (LETT |rbinv|
                                       (SPADCALL |rb| |rbden|
                                        (QREFELT $ 54)) . #4#)
                                      (LETT |indexChange|
                                       (QUOTIENT2 |index| |oldIndex|) . #4#)
                                      (LETT |oldIndex| |index| . #4#)
                                      (LETT |disc|
                                       (QUOTIENT2 |disc|
                                        (* |indexChange| |indexChange|)) . #4#)
                                      (EXIT
                                       (COND
                                         ((EQL |indexChange| 1)
                                          (PROGN
                                            (LETT #2#
                                             (VECTOR |rb| |rbden|
                                              |rbinv| |disc|) . #4#)
                                            (GO #2#)))
                                         ('T
                                          (SEQ
                                           (EXIT
                                            (COND
                                              ((NULL
                                                (EQL (GCD |p2| |disc|)
                                                 |p2|))
                                               (PROGN
                                                 (LETT #3#
                                                  (PROGN
                                                    (LETT #2#
                                                     (VECTOR |rb|
                                                      |rbden| |rbinv|
                                                      |disc|) . #4#)
                                                    (GO #2#)) . #4#)
                                                 (GO #3#)))))
                                           #3# (EXIT #3#))))))
                                 NIL (GO G190) G191 (EXIT NIL)))))
           #2# (EXIT #2#))))) 

(DEFUN |NFINTBAS;discriminant;I;8| ($)
  (PROG (|disc| |intBas| |rb| |rbden| |index| #0=#:G1931)
    (RETURN
      (SEQ (LETT |disc|
                 (SPADCALL (SPADCALL (QREFELT $ 41)) (QREFELT $ 42))
                 . #1=(|NFINTBAS;discriminant;I;8|))
           (LETT |intBas| (SPADCALL (QREFELT $ 56)) . #1#)
           (LETT |rb| (QVELT |intBas| 0) . #1#)
           (LETT |rbden| (QVELT |intBas| 1) . #1#)
           (LETT |index|
                 (PROG2 (LETT #0#
                              (SPADCALL
                                  (EXPT |rbden|
                                        (SPADCALL (QREFELT $ 9)))
                                  (SPADCALL |rb| (QREFELT $ 42))
                                  (QREFELT $ 57)) . #1#)
                        (QCDR #0#)
                   (|check-union| (QEQCAR #0# 0) (|Integer|) #0#)) . #1#)
           (EXIT (PROG2 (LETT #0#
                              (SPADCALL |disc| (* |index| |index|)
                                  (QREFELT $ 57)) . #1#)
                        (QCDR #0#)
                   (|check-union| (QEQCAR #0# 0) (|Integer|) #0#))))))) 

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

(DEFUN |NumberFieldIntegralBasis;| (|#1| |#2|)
  (PROG (DV$1 DV$2 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|)
              . #0=(|NumberFieldIntegralBasis|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT |dv$| (LIST '|NumberFieldIntegralBasis| DV$1 DV$2) . #0#)
        (LETT $ (GETREFV 69) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache| '|NumberFieldIntegralBasis|
            (LIST DV$1 DV$2) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        $)))) 

(MAKEPROP '|NumberFieldIntegralBasis| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|PositiveInteger|) (0 . |rank|) (|Vector| $)
             (4 . |basis|) (8 . |Zero|) (12 . |Zero|)
             (|NonNegativeInteger|) (|Vector| 7) (16 . |new|)
             (|Integer|) (22 . |minIndex|) (|Matrix| 17)
             (27 . |minRowIndex|) (32 . |maxRowIndex|)
             (37 . |minColIndex|) (42 . |maxColIndex|) (47 . |qelt|)
             (54 . |qelt|) (60 . *) (66 . +) (72 . **)
             (78 . |qsetelt!|) (85 . |coordinates|) (90 . |transpose|)
             (95 . *) (|Union| $ '"failed") (101 . |exquo|)
             (|Record| (|:| |factor| 17) (|:| |exponent| 17))
             (|List| 35) (|Factored| 17) (107 . |factors|)
             (112 . |One|) (116 . |One|) (120 . |traceMatrix|)
             (124 . |determinant|) (|IntegerFactorizationPackage| 17)
             (129 . |factor|) (134 . |scalarMatrix|) (|Boolean|)
             (140 . |sizeLess?|) (146 . *) (152 . |vertConcat|)
             (|ModularHermitianRowReduction| 17) (158 . |rowEchelon|)
             (164 . |squareTop|)
             (|TriangularMatrixOperations| 17 (|Vector| 17)
                 (|Vector| 17) 19)
             (169 . |UpTriBddDenomInv|)
             (|Record| (|:| |basis| 19) (|:| |basisDen| 17)
                 (|:| |basisInv| 19))
             |NFINTBAS;integralBasis;R;4| (175 . |exquo|)
             |NFINTBAS;localIntegralBasis;IR;5|
             (181 . |LowTriBddDenomInv|) (187 . |rowEchelon|)
             (|IntegralBasisTools| 17 6 7) (192 . |idealiser|)
             (199 . |diagonalProduct|) (204 . |matrixGcd|)
             (211 . |leastPower|) (217 . **) (223 . |divideIfCan!|)
             |NFINTBAS;discriminant;I;8|)
          '#(|localIntegralBasis| 231 |integralBasis| 236
             |discriminant| 240)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 68
                                '(0 7 8 9 0 7 10 11 0 6 0 12 0 7 0 13 2
                                  15 0 14 7 16 1 15 17 0 18 1 19 17 0
                                  20 1 19 17 0 21 1 19 17 0 22 1 19 17
                                  0 23 3 19 17 0 17 17 24 2 15 7 0 17
                                  25 2 7 0 17 0 26 2 7 0 0 0 27 2 7 0 0
                                  14 28 3 15 7 0 17 7 29 1 7 19 10 30 1
                                  19 0 0 31 2 19 0 0 0 32 2 19 33 0 17
                                  34 1 37 36 0 38 0 6 0 39 0 7 0 40 0 7
                                  19 41 1 19 17 0 42 1 43 37 17 44 2 19
                                  0 14 17 45 2 17 46 0 0 47 2 19 0 17 0
                                  48 2 19 0 0 0 49 2 50 19 19 17 51 1
                                  19 0 0 52 2 53 19 19 17 54 2 17 33 0
                                  0 57 2 53 19 19 17 59 1 19 0 0 60 3
                                  61 19 19 19 17 62 1 61 17 19 63 3 61
                                  17 19 17 14 64 2 61 14 14 14 65 2 19
                                  0 0 14 66 4 61 17 19 19 17 17 67 1 0
                                  55 17 58 0 0 55 56 0 0 17 68)))))
          '|lookupComplete|)) 
