
(SDEFUN |NUMERIC;complexNumericIfCan;PU;1|
        ((|p| (|Polynomial| (|Complex| S)))
         (% (|Union| (|Complex| (|Float|)) "failed")))
        (SPROG ((|p'| (|Union| (|Complex| S) "failed")))
               (SEQ (LETT |p'| (SPADCALL |p| (QREFELT % 9)))
                    (EXIT
                     (COND ((QEQCAR |p'| 1) (CONS 1 "failed"))
                           ('T
                            (CONS 0 (SPADCALL (QCDR |p'|) (QREFELT % 12))))))))) 

(SDEFUN |NUMERIC;complexNumericIfCan;PPiU;2|
        ((|p| (|Polynomial| (|Complex| S))) (|n| (|PositiveInteger|))
         (% (|Union| (|Complex| (|Float|)) "failed")))
        (SPROG ((|p'| (|Union| (|Complex| S) "failed")))
               (SEQ (LETT |p'| (SPADCALL |p| (QREFELT % 9)))
                    (EXIT
                     (COND ((QEQCAR |p'| 1) (CONS 1 "failed"))
                           ('T
                            (CONS 0
                                  (SPADCALL (QCDR |p'|) |n|
                                            (QREFELT % 16))))))))) 

(SDEFUN |NUMERIC;numericIfCan;PU;3|
        ((|p| (|Polynomial| S)) (% (|Union| (|Float|) "failed")))
        (SPROG ((|p'| (|Union| S "failed")))
               (SEQ (LETT |p'| (SPADCALL |p| (QREFELT % 20)))
                    (EXIT
                     (COND ((QEQCAR |p'| 1) (CONS 1 "failed"))
                           ('T
                            (CONS 0 (SPADCALL (QCDR |p'|) (QREFELT % 22))))))))) 

(SDEFUN |NUMERIC;complexNumericIfCan;PU;4|
        ((|p| (|Polynomial| S)) (% (|Union| (|Complex| (|Float|)) "failed")))
        (SPROG ((|p'| (|Union| S "failed")))
               (SEQ (LETT |p'| (SPADCALL |p| (QREFELT % 20)))
                    (EXIT
                     (COND ((QEQCAR |p'| 1) (CONS 1 "failed"))
                           ('T
                            (CONS 0 (SPADCALL (QCDR |p'|) (QREFELT % 25))))))))) 

(SDEFUN |NUMERIC;complexNumericIfCan;PPiU;5|
        ((|p| (|Polynomial| S)) (|n| (|PositiveInteger|))
         (% (|Union| (|Complex| (|Float|)) "failed")))
        (SPROG ((|p'| (|Union| S "failed")))
               (SEQ (LETT |p'| (SPADCALL |p| (QREFELT % 20)))
                    (EXIT
                     (COND ((QEQCAR |p'| 1) (CONS 1 "failed"))
                           ('T
                            (CONS 0
                                  (SPADCALL (QCDR |p'|) |n|
                                            (QREFELT % 27))))))))) 

(SDEFUN |NUMERIC;numericIfCan;PPiU;6|
        ((|p| (|Polynomial| S)) (|n| (|PositiveInteger|))
         (% (|Union| (|Float|) "failed")))
        (SPROG
         ((|ans| (|Union| (|Float|) "failed")) (|old| (|PositiveInteger|)))
         (SEQ (LETT |old| (SPADCALL |n| (QREFELT % 29)))
              (LETT |ans| (SPADCALL |p| (QREFELT % 24)))
              (SPADCALL |old| (QREFELT % 29)) (EXIT |ans|)))) 

(SDEFUN |NUMERIC;numericIfCan;FU;7|
        ((|f| (|Fraction| (|Polynomial| S))) (% (|Union| (|Float|) "failed")))
        (SPROG ((|den| #1=(|Union| (|Float|) "failed")) (|num| #1#))
               (SEQ
                (LETT |num|
                      (SPADCALL (SPADCALL |f| (QREFELT % 32)) (QREFELT % 24)))
                (EXIT
                 (COND ((QEQCAR |num| 1) (CONS 1 "failed"))
                       (#2='T
                        (SEQ
                         (LETT |den|
                               (SPADCALL (SPADCALL |f| (QREFELT % 33))
                                         (QREFELT % 24)))
                         (EXIT
                          (COND ((QEQCAR |den| 1) (CONS 1 "failed"))
                                (#2#
                                 (CONS 0
                                       (SPADCALL (QCDR |num|) (QCDR |den|)
                                                 (QREFELT % 34))))))))))))) 

(SDEFUN |NUMERIC;complexNumericIfCan;FU;8|
        ((|f| (|Fraction| (|Polynomial| S)))
         (% (|Union| (|Complex| (|Float|)) "failed")))
        (SPROG
         ((|den| #1=(|Union| (|Complex| (|Float|)) "failed")) (|num| #1#))
         (SEQ
          (LETT |num| (SPADCALL (SPADCALL |f| (QREFELT % 32)) (QREFELT % 26)))
          (EXIT
           (COND ((QEQCAR |num| 1) (CONS 1 "failed"))
                 (#2='T
                  (SEQ
                   (LETT |den|
                         (SPADCALL (SPADCALL |f| (QREFELT % 33))
                                   (QREFELT % 26)))
                   (EXIT
                    (COND ((QEQCAR |den| 1) (CONS 1 "failed"))
                          (#2#
                           (CONS 0
                                 (SPADCALL (QCDR |num|) (QCDR |den|)
                                           (QREFELT % 36))))))))))))) 

(SDEFUN |NUMERIC;complexNumericIfCan;FPiU;9|
        ((|f| (|Fraction| (|Polynomial| S))) (|n| (|PositiveInteger|))
         (% (|Union| (|Complex| (|Float|)) "failed")))
        (SPROG
         ((|den| #1=(|Union| (|Complex| (|Float|)) "failed")) (|num| #1#))
         (SEQ
          (LETT |num|
                (SPADCALL (SPADCALL |f| (QREFELT % 32)) |n| (QREFELT % 28)))
          (EXIT
           (COND ((QEQCAR |num| 1) (CONS 1 "failed"))
                 (#2='T
                  (SEQ
                   (LETT |den|
                         (SPADCALL (SPADCALL |f| (QREFELT % 33)) |n|
                                   (QREFELT % 28)))
                   (EXIT
                    (COND ((QEQCAR |den| 1) (CONS 1 "failed"))
                          (#2#
                           (CONS 0
                                 (SPADCALL (QCDR |num|) (QCDR |den|)
                                           (QREFELT % 36))))))))))))) 

(SDEFUN |NUMERIC;numericIfCan;FPiU;10|
        ((|f| (|Fraction| (|Polynomial| S))) (|n| (|PositiveInteger|))
         (% (|Union| (|Float|) "failed")))
        (SPROG
         ((|ans| (|Union| (|Float|) "failed")) (|old| (|PositiveInteger|)))
         (SEQ (LETT |old| (SPADCALL |n| (QREFELT % 29)))
              (LETT |ans| (SPADCALL |f| (QREFELT % 35)))
              (SPADCALL |old| (QREFELT % 29)) (EXIT |ans|)))) 

(SDEFUN |NUMERIC;complexNumericIfCan;FU;11|
        ((|f| (|Fraction| (|Polynomial| (|Complex| S))))
         (% (|Union| (|Complex| (|Float|)) "failed")))
        (SPROG
         ((|den| #1=(|Union| (|Complex| (|Float|)) "failed")) (|num| #1#))
         (SEQ
          (LETT |num| (SPADCALL (SPADCALL |f| (QREFELT % 41)) (QREFELT % 14)))
          (EXIT
           (COND ((QEQCAR |num| 1) (CONS 1 "failed"))
                 (#2='T
                  (SEQ
                   (LETT |den|
                         (SPADCALL (SPADCALL |f| (QREFELT % 42))
                                   (QREFELT % 14)))
                   (EXIT
                    (COND ((QEQCAR |den| 1) (CONS 1 "failed"))
                          (#2#
                           (CONS 0
                                 (SPADCALL (QCDR |num|) (QCDR |den|)
                                           (QREFELT % 36))))))))))))) 

(SDEFUN |NUMERIC;complexNumericIfCan;FPiU;12|
        ((|f| (|Fraction| (|Polynomial| (|Complex| S))))
         (|n| (|PositiveInteger|))
         (% (|Union| (|Complex| (|Float|)) "failed")))
        (SPROG
         ((|den| #1=(|Union| (|Complex| (|Float|)) "failed")) (|num| #1#))
         (SEQ
          (LETT |num|
                (SPADCALL (SPADCALL |f| (QREFELT % 41)) |n| (QREFELT % 17)))
          (EXIT
           (COND ((QEQCAR |num| 1) (CONS 1 "failed"))
                 (#2='T
                  (SEQ
                   (LETT |den|
                         (SPADCALL (SPADCALL |f| (QREFELT % 42)) |n|
                                   (QREFELT % 17)))
                   (EXIT
                    (COND ((QEQCAR |den| 1) (CONS 1 "failed"))
                          (#2#
                           (CONS 0
                                 (SPADCALL (QCDR |num|) (QCDR |den|)
                                           (QREFELT % 36))))))))))))) 

(SDEFUN |NUMERIC;numericIfCan;EU;13|
        ((|x| (|Expression| S)) (% (|Union| (|Float|) "failed")))
        (|trappedSpadEvalUnion|
         (SPADCALL (SPADCALL (ELT % 45) |x| (QREFELT % 50)) (QREFELT % 51)))) 

(SDEFUN |NUMERIC;complexNumericIfCan;EU;14|
        ((|x| (|Expression| S)) (% (|Union| (|Complex| (|Float|)) "failed")))
        (SPADCALL (SPADCALL (ELT % 53) |x| (QREFELT % 57)) (QREFELT % 58))) 

(SDEFUN |NUMERIC;numericIfCan;EPiU;15|
        ((|x| (|Expression| S)) (|n| (|PositiveInteger|))
         (% (|Union| (|Float|) "failed")))
        (SPROG ((|old| (|PositiveInteger|)))
               (SEQ (LETT |old| (SPADCALL (QREFELT % 60)))
                    (EXIT
                     (|finally|
                      (SEQ (SPADCALL |n| (QREFELT % 29))
                           (EXIT (SPADCALL |x| (QREFELT % 52))))
                      (SPADCALL |old| (QREFELT % 61))))))) 

(SDEFUN |NUMERIC;complexNumericIfCan;EPiU;16|
        ((|x| (|Expression| S)) (|n| (|PositiveInteger|))
         (% (|Union| (|Complex| (|Float|)) "failed")))
        (SPROG
         ((|ans| (|Union| (|Complex| (|Float|)) "failed"))
          (|x'| (|Expression| (|Complex| S))) (|old| (|PositiveInteger|)))
         (SEQ (LETT |old| (SPADCALL |n| (QREFELT % 29)))
              (LETT |x'| (SPADCALL (ELT % 53) |x| (QREFELT % 57)))
              (LETT |ans| (SPADCALL |x'| (QREFELT % 58)))
              (SPADCALL |old| (QREFELT % 29)) (EXIT |ans|)))) 

(SDEFUN |NUMERIC;complexNumericIfCan;EU;17|
        ((|x| (|Expression| (|Complex| S)))
         (% (|Union| (|Complex| (|Float|)) "failed")))
        (SPADCALL (SPADCALL (ELT % 64) |x| (QREFELT % 68)) (QREFELT % 69))) 

(SDEFUN |NUMERIC;complexNumericIfCan;EPiU;18|
        ((|x| (|Expression| (|Complex| S))) (|n| (|PositiveInteger|))
         (% (|Union| (|Complex| (|Float|)) "failed")))
        (SPROG
         ((|ans| (|Union| (|Complex| (|Float|)) "failed"))
          (|x'| (|Expression| (|Complex| (|Float|))))
          (|old| (|PositiveInteger|)))
         (SEQ (LETT |old| (SPADCALL |n| (QREFELT % 29)))
              (LETT |x'| (SPADCALL (ELT % 64) |x| (QREFELT % 68)))
              (LETT |ans| (SPADCALL |x'| (QREFELT % 69)))
              (SPADCALL |old| (QREFELT % 29)) (EXIT |ans|)))) 

(SDEFUN |NUMERIC;convert| ((|x| (|Complex| S)) (% (|Complex| (|Float|))))
        (SPADCALL (ELT % 45) |x| (QREFELT % 72))) 

(SDEFUN |NUMERIC;complexNumericIfCan;EU;20|
        ((|x| (|Expression| (|Complex| S)))
         (% (|Union| (|Complex| (|Float|)) "failed")))
        (SPADCALL
         (SPADCALL (CONS (|function| |NUMERIC;convert|) %) |x| (QREFELT % 68))
         (QREFELT % 69))) 

(SDEFUN |NUMERIC;complexNumericIfCan;EPiU;21|
        ((|x| (|Expression| (|Complex| S))) (|n| (|PositiveInteger|))
         (% (|Union| (|Complex| (|Float|)) "failed")))
        (SPROG
         ((|ans| (|Union| (|Complex| (|Float|)) "failed"))
          (|x'| (|Expression| (|Complex| (|Float|))))
          (|old| (|PositiveInteger|)))
         (SEQ (LETT |old| (SPADCALL |n| (QREFELT % 29)))
              (LETT |x'|
                    (SPADCALL (CONS (|function| |NUMERIC;convert|) %) |x|
                              (QREFELT % 68)))
              (LETT |ans| (SPADCALL |x'| (QREFELT % 69)))
              (SPADCALL |old| (QREFELT % 29)) (EXIT |ans|)))) 

(SDEFUN |NUMERIC;numeric;SF;22| ((|s| (S)) (% (|Float|)))
        (SPADCALL |s| (QREFELT % 45))) 

(SDEFUN |NUMERIC;complexNumeric;SC;23| ((|s| (S)) (% (|Complex| (|Float|))))
        (SPADCALL |s| (QREFELT % 73))) 

(SDEFUN |NUMERIC;complexNumeric;SPiC;24|
        ((|s| (S)) (|n| (|PositiveInteger|)) (% (|Complex| (|Float|))))
        (SPROG ((|ans| (|Complex| (|Float|))) (|old| (|PositiveInteger|)))
               (SEQ (LETT |old| (SPADCALL |n| (QREFELT % 29)))
                    (LETT |ans| (SPADCALL |s| (QREFELT % 25)))
                    (SPADCALL |old| (QREFELT % 29)) (EXIT |ans|)))) 

(SDEFUN |NUMERIC;complexNumeric;SC;25| ((|s| (S)) (% (|Complex| (|Float|))))
        (SPADCALL (SPADCALL |s| (QREFELT % 45)) (QREFELT % 74))) 

(SDEFUN |NUMERIC;complexNumeric;SPiC;26|
        ((|s| (S)) (|n| (|PositiveInteger|)) (% (|Complex| (|Float|))))
        (SPADCALL (SPADCALL |s| |n| (QREFELT % 75)) (QREFELT % 74))) 

(SDEFUN |NUMERIC;complexNumeric;PC;27|
        ((|p| (|Polynomial| (|Complex| S))) (% (|Complex| (|Float|))))
        (SPROG ((|p'| (|Union| (|Complex| S) "failed")))
               (SEQ (LETT |p'| (SPADCALL |p| (QREFELT % 9)))
                    (EXIT
                     (COND
                      ((QEQCAR |p'| 1)
                       (|error|
                        "Cannot compute the numerical value of a non-constant polynomial"))
                      ('T (SPADCALL (QCDR |p'|) (QREFELT % 12)))))))) 

(SDEFUN |NUMERIC;complexNumeric;PPiC;28|
        ((|p| (|Polynomial| (|Complex| S))) (|n| (|PositiveInteger|))
         (% (|Complex| (|Float|))))
        (SPROG ((|p'| (|Union| (|Complex| S) "failed")))
               (SEQ (LETT |p'| (SPADCALL |p| (QREFELT % 9)))
                    (EXIT
                     (COND
                      ((QEQCAR |p'| 1)
                       (|error|
                        "Cannot compute the numerical value of a non-constant polynomial"))
                      ('T (SPADCALL (QCDR |p'|) |n| (QREFELT % 16)))))))) 

(SDEFUN |NUMERIC;complexNumeric;CC;29|
        ((|s| (|Complex| S)) (% (|Complex| (|Float|))))
        (SPADCALL |s| (QREFELT % 64))) 

(SDEFUN |NUMERIC;complexNumeric;CPiC;30|
        ((|s| (|Complex| S)) (|n| (|PositiveInteger|))
         (% (|Complex| (|Float|))))
        (SPROG ((|ans| (|Complex| (|Float|))) (|old| (|PositiveInteger|)))
               (SEQ (LETT |old| (SPADCALL |n| (QREFELT % 29)))
                    (LETT |ans| (SPADCALL |s| (QREFELT % 12)))
                    (SPADCALL |old| (QREFELT % 29)) (EXIT |ans|)))) 

(SDEFUN |NUMERIC;complexNumeric;CC;31|
        ((|s| (|Complex| S)) (% (|Complex| (|Float|))))
        (SPADCALL |s| (QREFELT % 64))) 

(SDEFUN |NUMERIC;complexNumeric;CPiC;32|
        ((|s| (|Complex| S)) (|n| (|PositiveInteger|))
         (% (|Complex| (|Float|))))
        (SPROG ((|ans| (|Complex| (|Float|))) (|old| (|PositiveInteger|)))
               (SEQ (LETT |old| (SPADCALL |n| (QREFELT % 29)))
                    (LETT |ans| (SPADCALL |s| (QREFELT % 12)))
                    (SPADCALL |old| (QREFELT % 29)) (EXIT |ans|)))) 

(SDEFUN |NUMERIC;complexNumeric;CC;33|
        ((|s| (|Complex| S)) (% (|Complex| (|Float|))))
        (SPROG ((|s'| (|Union| S "failed")))
               (SEQ (LETT |s'| (SPADCALL |s| (QREFELT % 78)))
                    (EXIT
                     (COND
                      ((QEQCAR |s'| 1)
                       (|error|
                        "Cannot compute the numerical value of a non-constant object"))
                      ('T (SPADCALL (QCDR |s'|) (QREFELT % 25)))))))) 

(SDEFUN |NUMERIC;complexNumeric;CPiC;34|
        ((|s| (|Complex| S)) (|n| (|PositiveInteger|))
         (% (|Complex| (|Float|))))
        (SPROG
         ((|ans| (|Complex| (|Float|))) (|old| (|PositiveInteger|))
          (|s'| (|Union| S "failed")))
         (SEQ (LETT |s'| (SPADCALL |s| (QREFELT % 78)))
              (EXIT
               (COND
                ((QEQCAR |s'| 1)
                 (|error|
                  "Cannot compute the numerical value of a non-constant object"))
                ('T
                 (SEQ (LETT |old| (SPADCALL |n| (QREFELT % 29)))
                      (LETT |ans| (SPADCALL (QCDR |s'|) (QREFELT % 25)))
                      (SPADCALL |old| (QREFELT % 29)) (EXIT |ans|)))))))) 

(SDEFUN |NUMERIC;numeric;SPiF;35|
        ((|s| (S)) (|n| (|PositiveInteger|)) (% (|Float|)))
        (SPROG ((|ans| (|Float|)) (|old| (|PositiveInteger|)))
               (SEQ (LETT |old| (SPADCALL |n| (QREFELT % 29)))
                    (LETT |ans| (SPADCALL |s| (QREFELT % 22)))
                    (SPADCALL |old| (QREFELT % 29)) (EXIT |ans|)))) 

(SDEFUN |NUMERIC;numeric;PF;36| ((|p| (|Polynomial| S)) (% (|Float|)))
        (SPROG ((|p'| (|Union| S "failed")))
               (SEQ (LETT |p'| (SPADCALL |p| (QREFELT % 20)))
                    (EXIT
                     (COND
                      ((QEQCAR |p'| 1)
                       (|error|
                        "Can only compute the numerical value of a constant, real-valued polynomial"))
                      ('T (SPADCALL (QCDR |p'|) (QREFELT % 22)))))))) 

(SDEFUN |NUMERIC;complexNumeric;PC;37|
        ((|p| (|Polynomial| S)) (% (|Complex| (|Float|))))
        (SPROG ((|p'| (|Union| S "failed")))
               (SEQ (LETT |p'| (SPADCALL |p| (QREFELT % 20)))
                    (EXIT
                     (COND
                      ((QEQCAR |p'| 1)
                       (|error|
                        "Cannot compute the numerical value of a non-constant polynomial"))
                      ('T (SPADCALL (QCDR |p'|) (QREFELT % 25)))))))) 

(SDEFUN |NUMERIC;complexNumeric;PPiC;38|
        ((|p| (|Polynomial| S)) (|n| (|PositiveInteger|))
         (% (|Complex| (|Float|))))
        (SPROG ((|p'| (|Union| S "failed")))
               (SEQ (LETT |p'| (SPADCALL |p| (QREFELT % 20)))
                    (EXIT
                     (COND
                      ((QEQCAR |p'| 1)
                       (|error|
                        "Cannot compute the numerical value of a non-constant polynomial"))
                      ('T (SPADCALL (QCDR |p'|) |n| (QREFELT % 27)))))))) 

(SDEFUN |NUMERIC;numeric;PPiF;39|
        ((|p| (|Polynomial| S)) (|n| (|PositiveInteger|)) (% (|Float|)))
        (SPROG ((|ans| (|Float|)) (|old| (|PositiveInteger|)))
               (SEQ (LETT |old| (SPADCALL |n| (QREFELT % 29)))
                    (LETT |ans| (SPADCALL |p| (QREFELT % 79)))
                    (SPADCALL |old| (QREFELT % 29)) (EXIT |ans|)))) 

(SDEFUN |NUMERIC;numeric;FF;40|
        ((|f| (|Fraction| (|Polynomial| S))) (% (|Float|)))
        (SPADCALL (SPADCALL (SPADCALL |f| (QREFELT % 32)) (QREFELT % 79))
                  (SPADCALL (SPADCALL |f| (QREFELT % 33)) (QREFELT % 79))
                  (QREFELT % 34))) 

(SDEFUN |NUMERIC;complexNumeric;FC;41|
        ((|f| (|Fraction| (|Polynomial| S))) (% (|Complex| (|Float|))))
        (SPADCALL (SPADCALL (SPADCALL |f| (QREFELT % 32)) (QREFELT % 80))
                  (SPADCALL (SPADCALL |f| (QREFELT % 33)) (QREFELT % 80))
                  (QREFELT % 36))) 

(SDEFUN |NUMERIC;complexNumeric;FPiC;42|
        ((|f| (|Fraction| (|Polynomial| S))) (|n| (|PositiveInteger|))
         (% (|Complex| (|Float|))))
        (SPADCALL (SPADCALL (SPADCALL |f| (QREFELT % 32)) |n| (QREFELT % 81))
                  (SPADCALL (SPADCALL |f| (QREFELT % 33)) |n| (QREFELT % 81))
                  (QREFELT % 36))) 

(SDEFUN |NUMERIC;numeric;FPiF;43|
        ((|f| (|Fraction| (|Polynomial| S))) (|n| (|PositiveInteger|))
         (% (|Float|)))
        (SPROG ((|ans| (|Float|)) (|old| (|PositiveInteger|)))
               (SEQ (LETT |old| (SPADCALL |n| (QREFELT % 29)))
                    (LETT |ans| (SPADCALL |f| (QREFELT % 83)))
                    (SPADCALL |old| (QREFELT % 29)) (EXIT |ans|)))) 

(SDEFUN |NUMERIC;complexNumeric;FC;44|
        ((|f| (|Fraction| (|Polynomial| (|Complex| S))))
         (% (|Complex| (|Float|))))
        (SPADCALL (SPADCALL (SPADCALL |f| (QREFELT % 41)) (QREFELT % 76))
                  (SPADCALL (SPADCALL |f| (QREFELT % 42)) (QREFELT % 76))
                  (QREFELT % 36))) 

(SDEFUN |NUMERIC;complexNumeric;FPiC;45|
        ((|f| (|Fraction| (|Polynomial| (|Complex| S))))
         (|n| (|PositiveInteger|)) (% (|Complex| (|Float|))))
        (SPADCALL (SPADCALL (SPADCALL |f| (QREFELT % 41)) |n| (QREFELT % 77))
                  (SPADCALL (SPADCALL |f| (QREFELT % 42)) |n| (QREFELT % 77))
                  (QREFELT % 36))) 

(SDEFUN |NUMERIC;numeric;EF;46| ((|x| (|Expression| S)) (% (|Float|)))
        (SPROG ((|x'| (|Union| (|Float|) "failed")))
               (SEQ
                (LETT |x'|
                      (SPADCALL (SPADCALL (ELT % 45) |x| (QREFELT % 50))
                                (QREFELT % 51)))
                (EXIT
                 (COND
                  ((QEQCAR |x'| 1)
                   (|error|
                    "Can only compute the numerical value of a constant, real-valued Expression"))
                  ('T (QCDR |x'|))))))) 

(SDEFUN |NUMERIC;complexNumeric;EC;47|
        ((|x| (|Expression| S)) (% (|Complex| (|Float|))))
        (SPROG ((|x'| (|Union| (|Complex| (|Float|)) "failed")))
               (SEQ
                (LETT |x'|
                      (SPADCALL (SPADCALL (ELT % 25) |x| (QREFELT % 92))
                                (QREFELT % 69)))
                (EXIT
                 (COND
                  ((QEQCAR |x'| 1)
                   (|error|
                    "Cannot compute the numerical value of a non-constant expression"))
                  ('T (QCDR |x'|))))))) 

(SDEFUN |NUMERIC;numeric;EPiF;48|
        ((|x| (|Expression| S)) (|n| (|PositiveInteger|)) (% (|Float|)))
        (SPROG
         ((|ans| (|Union| (|Float|) "failed")) (|x'| (|Expression| (|Float|)))
          (|old| (|PositiveInteger|)))
         (SEQ (LETT |old| (SPADCALL |n| (QREFELT % 29)))
              (LETT |x'| (SPADCALL (ELT % 45) |x| (QREFELT % 50)))
              (LETT |ans| (SPADCALL |x'| (QREFELT % 51)))
              (SPADCALL |old| (QREFELT % 29))
              (EXIT
               (COND
                ((QEQCAR |ans| 1)
                 (|error|
                  "Can only compute the numerical value of a constant, real-valued Expression"))
                ('T (QCDR |ans|))))))) 

(SDEFUN |NUMERIC;complexNumeric;EPiC;49|
        ((|x| (|Expression| S)) (|n| (|PositiveInteger|))
         (% (|Complex| (|Float|))))
        (SPROG
         ((|ans| (|Union| (|Complex| (|Float|)) "failed"))
          (|x'| (|Expression| (|Complex| (|Float|))))
          (|old| (|PositiveInteger|)))
         (SEQ (LETT |old| (SPADCALL |n| (QREFELT % 29)))
              (LETT |x'| (SPADCALL (ELT % 25) |x| (QREFELT % 92)))
              (LETT |ans| (SPADCALL |x'| (QREFELT % 69)))
              (SPADCALL |old| (QREFELT % 29))
              (EXIT
               (COND
                ((QEQCAR |ans| 1)
                 (|error|
                  "Cannot compute the numerical value of a non-constant expression"))
                ('T (QCDR |ans|))))))) 

(SDEFUN |NUMERIC;complexNumeric;EC;50|
        ((|x| (|Expression| (|Complex| S))) (% (|Complex| (|Float|))))
        (SPROG ((|x'| (|Union| (|Complex| (|Float|)) "failed")))
               (SEQ
                (LETT |x'|
                      (SPADCALL (SPADCALL (ELT % 12) |x| (QREFELT % 68))
                                (QREFELT % 69)))
                (EXIT
                 (COND
                  ((QEQCAR |x'| 1)
                   (|error|
                    "Cannot compute the numerical value of a non-constant expression"))
                  ('T (QCDR |x'|))))))) 

(SDEFUN |NUMERIC;complexNumeric;EPiC;51|
        ((|x| (|Expression| (|Complex| S))) (|n| (|PositiveInteger|))
         (% (|Complex| (|Float|))))
        (SPROG
         ((|ans| (|Union| (|Complex| (|Float|)) "failed"))
          (|x'| (|Expression| (|Complex| (|Float|))))
          (|old| (|PositiveInteger|)))
         (SEQ (LETT |old| (SPADCALL |n| (QREFELT % 29)))
              (LETT |x'| (SPADCALL (ELT % 12) |x| (QREFELT % 68)))
              (LETT |ans| (SPADCALL |x'| (QREFELT % 69)))
              (SPADCALL |old| (QREFELT % 29))
              (EXIT
               (COND
                ((QEQCAR |ans| 1)
                 (|error|
                  "Cannot compute the numerical value of a non-constant expression"))
                ('T (QCDR |ans|))))))) 

(DECLAIM (NOTINLINE |Numeric;|)) 

(DEFUN |Numeric| (#1=#:G254)
  (SPROG NIL
         (PROG (#2=#:G255)
           (RETURN
            (COND
             ((LETT #2#
                    (|lassocShiftWithFunction| (LIST (|devaluate| #1#))
                                               (HGET |$ConstructorCache|
                                                     '|Numeric|)
                                               '|domainEqualList|))
              (|CDRwithIncrement| #2#))
             ('T
              (UNWIND-PROTECT (PROG1 (|Numeric;| #1#) (LETT #2# T))
                (COND ((NOT #2#) (HREM |$ConstructorCache| '|Numeric|)))))))))) 

(DEFUN |Numeric;| (|#1|)
  (SPROG ((|pv$| NIL) (#1=#:G253 NIL) (% NIL) (|dv$| NIL) (DV$1 NIL))
         (PROGN
          (LETT DV$1 (|devaluate| |#1|))
          (LETT |dv$| (LIST '|Numeric| DV$1))
          (LETT % (GETREFV 98))
          (QSETREFV % 0 |dv$|)
          (QSETREFV % 3
                    (LETT |pv$|
                          (|buildPredVector| 0 0
                                             (LIST
                                              (LETT #1#
                                                    (|HasCategory| |#1|
                                                                   '(|IntegralDomain|)))
                                              (AND #1#
                                                   (|HasCategory| |#1|
                                                                  '(|OrderedSet|)))
                                              (|HasCategory| |#1| '(|Ring|))
                                              (|HasCategory| |#1|
                                                             '(|CommutativeRing|))))))
          (|haddProp| |$ConstructorCache| '|Numeric| (LIST DV$1) (CONS 1 %))
          (|stuffDomainSlots| %)
          (QSETREFV % 6 |#1|)
          (SETF |pv$| (QREFELT % 3))
          (COND
           ((|testBitVector| |pv$| 4)
            (PROGN
             (QSETREFV % 14
                       (CONS
                        (|dispatchFunction| |NUMERIC;complexNumericIfCan;PU;1|)
                        %))
             (QSETREFV % 17
                       (CONS
                        (|dispatchFunction|
                         |NUMERIC;complexNumericIfCan;PPiU;2|)
                        %)))))
          (COND
           ((|testBitVector| |pv$| 3)
            (PROGN
             (QSETREFV % 24
                       (CONS (|dispatchFunction| |NUMERIC;numericIfCan;PU;3|)
                             %))
             (QSETREFV % 26
                       (CONS
                        (|dispatchFunction| |NUMERIC;complexNumericIfCan;PU;4|)
                        %))
             (QSETREFV % 28
                       (CONS
                        (|dispatchFunction|
                         |NUMERIC;complexNumericIfCan;PPiU;5|)
                        %))
             (QSETREFV % 30
                       (CONS (|dispatchFunction| |NUMERIC;numericIfCan;PPiU;6|)
                             %)))))
          (COND
           ((|testBitVector| |pv$| 1)
            (PROGN
             (QSETREFV % 35
                       (CONS (|dispatchFunction| |NUMERIC;numericIfCan;FU;7|)
                             %))
             (QSETREFV % 37
                       (CONS
                        (|dispatchFunction| |NUMERIC;complexNumericIfCan;FU;8|)
                        %))
             (QSETREFV % 38
                       (CONS
                        (|dispatchFunction|
                         |NUMERIC;complexNumericIfCan;FPiU;9|)
                        %))
             (QSETREFV % 39
                       (CONS
                        (|dispatchFunction| |NUMERIC;numericIfCan;FPiU;10|) %))
             (QSETREFV % 43
                       (CONS
                        (|dispatchFunction|
                         |NUMERIC;complexNumericIfCan;FU;11|)
                        %))
             (QSETREFV % 44
                       (CONS
                        (|dispatchFunction|
                         |NUMERIC;complexNumericIfCan;FPiU;12|)
                        %))
             (COND
              ((|HasCategory| |#1| '(|OrderedSet|))
               (PROGN
                (QSETREFV % 52
                          (CONS
                           (|dispatchFunction| |NUMERIC;numericIfCan;EU;13|)
                           %))
                (QSETREFV % 59
                          (CONS
                           (|dispatchFunction|
                            |NUMERIC;complexNumericIfCan;EU;14|)
                           %))
                (QSETREFV % 62
                          (CONS
                           (|dispatchFunction| |NUMERIC;numericIfCan;EPiU;15|)
                           %))
                (QSETREFV % 63
                          (CONS
                           (|dispatchFunction|
                            |NUMERIC;complexNumericIfCan;EPiU;16|)
                           %))
                (COND
                 ((|HasCategory| |#1| '(|RealConstant|))
                  (PROGN
                   (QSETREFV % 58
                             (CONS
                              (|dispatchFunction|
                               |NUMERIC;complexNumericIfCan;EU;17|)
                              %))
                   (QSETREFV % 70
                             (CONS
                              (|dispatchFunction|
                               |NUMERIC;complexNumericIfCan;EPiU;18|)
                              %))))
                 ('T
                  (PROGN
                   (QSETREFV % 58
                             (CONS
                              (|dispatchFunction|
                               |NUMERIC;complexNumericIfCan;EU;20|)
                              %))
                   (QSETREFV % 70
                             (CONS
                              (|dispatchFunction|
                               |NUMERIC;complexNumericIfCan;EPiU;21|)
                              %)))))))))))
          (COND
           ((|HasCategory| |#1| '(|ConvertibleTo| (|Complex| (|Float|))))
            (PROGN
             (QSETREFV % 25
                       (CONS
                        (|dispatchFunction| |NUMERIC;complexNumeric;SC;23|) %))
             (QSETREFV % 27
                       (CONS
                        (|dispatchFunction| |NUMERIC;complexNumeric;SPiC;24|)
                        %))))
           ('T
            (PROGN
             (QSETREFV % 25
                       (CONS
                        (|dispatchFunction| |NUMERIC;complexNumeric;SC;25|) %))
             (QSETREFV % 27
                       (CONS
                        (|dispatchFunction| |NUMERIC;complexNumeric;SPiC;26|)
                        %)))))
          (COND
           ((|testBitVector| |pv$| 4)
            (PROGN
             (QSETREFV % 76
                       (CONS
                        (|dispatchFunction| |NUMERIC;complexNumeric;PC;27|) %))
             (QSETREFV % 77
                       (CONS
                        (|dispatchFunction| |NUMERIC;complexNumeric;PPiC;28|)
                        %))
             (COND
              ((|HasCategory| |#1| '(|RealConstant|))
               (PROGN
                (QSETREFV % 12
                          (CONS
                           (|dispatchFunction| |NUMERIC;complexNumeric;CC;29|)
                           %))
                (QSETREFV % 16
                          (CONS
                           (|dispatchFunction|
                            |NUMERIC;complexNumeric;CPiC;30|)
                           %))))
              ((|HasCategory| (|Complex| |#1|)
                              '(|ConvertibleTo| (|Complex| (|Float|))))
               (PROGN
                (QSETREFV % 12
                          (CONS
                           (|dispatchFunction| |NUMERIC;complexNumeric;CC;31|)
                           %))
                (QSETREFV % 16
                          (CONS
                           (|dispatchFunction|
                            |NUMERIC;complexNumeric;CPiC;32|)
                           %))))
              ('T
               (PROGN
                (QSETREFV % 12
                          (CONS
                           (|dispatchFunction| |NUMERIC;complexNumeric;CC;33|)
                           %))
                (QSETREFV % 16
                          (CONS
                           (|dispatchFunction|
                            |NUMERIC;complexNumeric;CPiC;34|)
                           %))))))))
          (COND
           ((|testBitVector| |pv$| 3)
            (PROGN
             (QSETREFV % 79
                       (CONS (|dispatchFunction| |NUMERIC;numeric;PF;36|) %))
             (QSETREFV % 80
                       (CONS
                        (|dispatchFunction| |NUMERIC;complexNumeric;PC;37|) %))
             (QSETREFV % 81
                       (CONS
                        (|dispatchFunction| |NUMERIC;complexNumeric;PPiC;38|)
                        %))
             (QSETREFV % 82
                       (CONS (|dispatchFunction| |NUMERIC;numeric;PPiF;39|)
                             %)))))
          (COND
           ((|testBitVector| |pv$| 1)
            (PROGN
             (QSETREFV % 83
                       (CONS (|dispatchFunction| |NUMERIC;numeric;FF;40|) %))
             (QSETREFV % 84
                       (CONS
                        (|dispatchFunction| |NUMERIC;complexNumeric;FC;41|) %))
             (QSETREFV % 85
                       (CONS
                        (|dispatchFunction| |NUMERIC;complexNumeric;FPiC;42|)
                        %))
             (QSETREFV % 86
                       (CONS (|dispatchFunction| |NUMERIC;numeric;FPiF;43|) %))
             (QSETREFV % 87
                       (CONS
                        (|dispatchFunction| |NUMERIC;complexNumeric;FC;44|) %))
             (QSETREFV % 88
                       (CONS
                        (|dispatchFunction| |NUMERIC;complexNumeric;FPiC;45|)
                        %))
             (COND
              ((|HasCategory| |#1| '(|OrderedSet|))
               (PROGN
                (QSETREFV % 89
                          (CONS (|dispatchFunction| |NUMERIC;numeric;EF;46|)
                                %))
                (QSETREFV % 93
                          (CONS
                           (|dispatchFunction| |NUMERIC;complexNumeric;EC;47|)
                           %))
                (QSETREFV % 94
                          (CONS (|dispatchFunction| |NUMERIC;numeric;EPiF;48|)
                                %))
                (QSETREFV % 95
                          (CONS
                           (|dispatchFunction|
                            |NUMERIC;complexNumeric;EPiC;49|)
                           %))
                (QSETREFV % 96
                          (CONS
                           (|dispatchFunction| |NUMERIC;complexNumeric;EC;50|)
                           %))
                (QSETREFV % 97
                          (CONS
                           (|dispatchFunction|
                            |NUMERIC;complexNumeric;EPiC;51|)
                           %))))))))
          %))) 

(MAKEPROP '|Numeric| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|Union| 11 '#1="failed")
              (|Polynomial| 11) (0 . |retractIfCan|) (|Complex| 21)
              (|Complex| 6) (5 . |complexNumeric|) (|Union| 10 '#2="failed")
              (10 . |complexNumericIfCan|) (|PositiveInteger|)
              (15 . |complexNumeric|) (21 . |complexNumericIfCan|)
              (|Union| 6 '#1#) (|Polynomial| 6) (27 . |retractIfCan|) (|Float|)
              |NUMERIC;numeric;SF;22| (|Union| 21 '#3="failed")
              (32 . |numericIfCan|) (37 . |complexNumeric|)
              (42 . |complexNumericIfCan|) (47 . |complexNumeric|)
              (53 . |complexNumericIfCan|) (59 . |digits|)
              (64 . |numericIfCan|) (|Fraction| 19) (70 . |numer|)
              (75 . |denom|) (80 . /) (86 . |numericIfCan|) (91 . /)
              (97 . |complexNumericIfCan|) (102 . |complexNumericIfCan|)
              (108 . |numericIfCan|) (|Fraction| 8) (114 . |numer|)
              (119 . |denom|) (124 . |complexNumericIfCan|)
              (129 . |complexNumericIfCan|) (135 . |convert|) (|Expression| 21)
              (|Mapping| 21 6) (|Expression| 6) (|ExpressionFunctions2| 6 21)
              (140 . |map|) (146 . |retractIfCan|) (151 . |numericIfCan|)
              (156 . |coerce|) (|Expression| 11) (|Mapping| 11 6)
              (|ExpressionFunctions2| 6 11) (161 . |map|)
              (167 . |complexNumericIfCan|) (172 . |complexNumericIfCan|)
              (177 . |bits|) (181 . |bits|) (186 . |numericIfCan|)
              (192 . |complexNumericIfCan|) (198 . |convert|) (|Expression| 10)
              (|Mapping| 10 11) (|ExpressionFunctions2| 11 10) (203 . |map|)
              (209 . |retractIfCan|) (214 . |complexNumericIfCan|)
              (|ComplexFunctions2| 6 21) (220 . |map|) (226 . |convert|)
              (231 . |coerce|) |NUMERIC;numeric;SPiF;35|
              (236 . |complexNumeric|) (241 . |complexNumeric|)
              (247 . |retractIfCan|) (252 . |numeric|) (257 . |complexNumeric|)
              (262 . |complexNumeric|) (268 . |numeric|) (274 . |numeric|)
              (279 . |complexNumeric|) (284 . |complexNumeric|)
              (290 . |numeric|) (296 . |complexNumeric|)
              (301 . |complexNumeric|) (307 . |numeric|) (|Mapping| 10 6)
              (|ExpressionFunctions2| 6 10) (312 . |map|)
              (318 . |complexNumeric|) (323 . |numeric|)
              (329 . |complexNumeric|) (335 . |complexNumeric|)
              (340 . |complexNumeric|))
           '#(|numericIfCan| 346 |numeric| 379 |complexNumericIfCan| 423
              |complexNumeric| 489)
           'NIL
           (CONS (|makeByteWordVec2| 1 '(0))
                 (CONS '#(NIL)
                       (CONS
                        '#((|Join|
                            (|mkCategory|
                             (LIST '((|numeric| ((|Float|) |#1|)) T)
                                   '((|numeric|
                                      ((|Float|) |#1| (|PositiveInteger|)))
                                     T)
                                   '((|complexNumeric|
                                      ((|Complex| (|Float|)) |#1|))
                                     T)
                                   '((|complexNumeric|
                                      ((|Complex| (|Float|)) |#1|
                                       (|PositiveInteger|)))
                                     T)
                                   '((|complexNumeric|
                                      ((|Complex| (|Float|)) (|Complex| |#1|)))
                                     (|has| 6 (|CommutativeRing|)))
                                   '((|complexNumeric|
                                      ((|Complex| (|Float|)) (|Complex| |#1|)
                                       (|PositiveInteger|)))
                                     (|has| 6 (|CommutativeRing|)))
                                   '((|complexNumeric|
                                      ((|Complex| (|Float|))
                                       (|Polynomial| (|Complex| |#1|))))
                                     (|has| 6 (|CommutativeRing|)))
                                   '((|complexNumeric|
                                      ((|Complex| (|Float|))
                                       (|Polynomial| (|Complex| |#1|))
                                       (|PositiveInteger|)))
                                     (|has| 6 (|CommutativeRing|)))
                                   '((|numeric|
                                      ((|Float|) (|Polynomial| |#1|)))
                                     (|has| 6 (|Ring|)))
                                   '((|numeric|
                                      ((|Float|) (|Polynomial| |#1|)
                                       (|PositiveInteger|)))
                                     (|has| 6 (|Ring|)))
                                   '((|complexNumeric|
                                      ((|Complex| (|Float|))
                                       (|Polynomial| |#1|)))
                                     (|has| 6 (|Ring|)))
                                   '((|complexNumeric|
                                      ((|Complex| (|Float|))
                                       (|Polynomial| |#1|)
                                       (|PositiveInteger|)))
                                     (|has| 6 (|Ring|)))
                                   '((|numeric|
                                      ((|Float|)
                                       (|Fraction| (|Polynomial| |#1|))))
                                     (|has| 6 (|IntegralDomain|)))
                                   '((|numeric|
                                      ((|Float|)
                                       (|Fraction| (|Polynomial| |#1|))
                                       (|PositiveInteger|)))
                                     (|has| 6 (|IntegralDomain|)))
                                   '((|complexNumeric|
                                      ((|Complex| (|Float|))
                                       (|Fraction| (|Polynomial| |#1|))))
                                     (|has| 6 (|IntegralDomain|)))
                                   '((|complexNumeric|
                                      ((|Complex| (|Float|))
                                       (|Fraction| (|Polynomial| |#1|))
                                       (|PositiveInteger|)))
                                     (|has| 6 (|IntegralDomain|)))
                                   '((|complexNumeric|
                                      ((|Complex| (|Float|))
                                       (|Fraction|
                                        (|Polynomial| (|Complex| |#1|)))))
                                     (|has| 6 (|IntegralDomain|)))
                                   '((|complexNumeric|
                                      ((|Complex| (|Float|))
                                       (|Fraction|
                                        (|Polynomial| (|Complex| |#1|)))
                                       (|PositiveInteger|)))
                                     (|has| 6 (|IntegralDomain|)))
                                   '((|numeric|
                                      ((|Float|) (|Expression| |#1|)))
                                     (AND (|has| 6 (|OrderedSet|))
                                          (|has| 6 (|IntegralDomain|))))
                                   '((|numeric|
                                      ((|Float|) (|Expression| |#1|)
                                       (|PositiveInteger|)))
                                     (AND (|has| 6 (|OrderedSet|))
                                          (|has| 6 (|IntegralDomain|))))
                                   '((|complexNumeric|
                                      ((|Complex| (|Float|))
                                       (|Expression| |#1|)))
                                     (AND (|has| 6 (|OrderedSet|))
                                          (|has| 6 (|IntegralDomain|))))
                                   '((|complexNumeric|
                                      ((|Complex| (|Float|))
                                       (|Expression| |#1|)
                                       (|PositiveInteger|)))
                                     (AND (|has| 6 (|OrderedSet|))
                                          (|has| 6 (|IntegralDomain|))))
                                   '((|complexNumeric|
                                      ((|Complex| (|Float|))
                                       (|Expression| (|Complex| |#1|))))
                                     (AND (|has| 6 (|OrderedSet|))
                                          (|has| 6 (|IntegralDomain|))))
                                   '((|complexNumeric|
                                      ((|Complex| (|Float|))
                                       (|Expression| (|Complex| |#1|))
                                       (|PositiveInteger|)))
                                     (AND (|has| 6 (|OrderedSet|))
                                          (|has| 6 (|IntegralDomain|))))
                                   '((|complexNumericIfCan|
                                      ((|Union| (|Complex| (|Float|)) #2#)
                                       (|Polynomial| (|Complex| |#1|))))
                                     (|has| 6 (|CommutativeRing|)))
                                   '((|complexNumericIfCan|
                                      ((|Union| (|Complex| (|Float|)) "failed")
                                       (|Polynomial| (|Complex| |#1|))
                                       (|PositiveInteger|)))
                                     (|has| 6 (|CommutativeRing|)))
                                   '((|numericIfCan|
                                      ((|Union| (|Float|) #3#)
                                       (|Polynomial| |#1|)))
                                     (|has| 6 (|Ring|)))
                                   '((|numericIfCan|
                                      ((|Union| (|Float|) "failed")
                                       (|Polynomial| |#1|)
                                       (|PositiveInteger|)))
                                     (|has| 6 (|Ring|)))
                                   '((|complexNumericIfCan|
                                      ((|Union| (|Complex| (|Float|)) "failed")
                                       (|Polynomial| |#1|)))
                                     (|has| 6 (|Ring|)))
                                   '((|complexNumericIfCan|
                                      ((|Union| (|Complex| (|Float|)) "failed")
                                       (|Polynomial| |#1|)
                                       (|PositiveInteger|)))
                                     (|has| 6 (|Ring|)))
                                   '((|numericIfCan|
                                      ((|Union| (|Float|) "failed")
                                       (|Fraction| (|Polynomial| |#1|))))
                                     (|has| 6 (|IntegralDomain|)))
                                   '((|numericIfCan|
                                      ((|Union| (|Float|) "failed")
                                       (|Fraction| (|Polynomial| |#1|))
                                       (|PositiveInteger|)))
                                     (|has| 6 (|IntegralDomain|)))
                                   '((|complexNumericIfCan|
                                      ((|Union| (|Complex| (|Float|)) "failed")
                                       (|Fraction| (|Polynomial| |#1|))))
                                     (|has| 6 (|IntegralDomain|)))
                                   '((|complexNumericIfCan|
                                      ((|Union| (|Complex| (|Float|)) "failed")
                                       (|Fraction| (|Polynomial| |#1|))
                                       (|PositiveInteger|)))
                                     (|has| 6 (|IntegralDomain|)))
                                   '((|complexNumericIfCan|
                                      ((|Union| (|Complex| (|Float|)) "failed")
                                       (|Fraction|
                                        (|Polynomial| (|Complex| |#1|)))))
                                     (|has| 6 (|IntegralDomain|)))
                                   '((|complexNumericIfCan|
                                      ((|Union| (|Complex| (|Float|)) "failed")
                                       (|Fraction|
                                        (|Polynomial| (|Complex| |#1|)))
                                       (|PositiveInteger|)))
                                     (|has| 6 (|IntegralDomain|)))
                                   '((|numericIfCan|
                                      ((|Union| (|Float|) "failed")
                                       (|Expression| |#1|)))
                                     (AND (|has| 6 (|OrderedSet|))
                                          (|has| 6 (|IntegralDomain|))))
                                   '((|numericIfCan|
                                      ((|Union| (|Float|) "failed")
                                       (|Expression| |#1|)
                                       (|PositiveInteger|)))
                                     (AND (|has| 6 (|OrderedSet|))
                                          (|has| 6 (|IntegralDomain|))))
                                   '((|complexNumericIfCan|
                                      ((|Union| (|Complex| (|Float|)) "failed")
                                       (|Expression| |#1|)))
                                     (AND (|has| 6 (|OrderedSet|))
                                          (|has| 6 (|IntegralDomain|))))
                                   '((|complexNumericIfCan|
                                      ((|Union| (|Complex| (|Float|)) "failed")
                                       (|Expression| |#1|)
                                       (|PositiveInteger|)))
                                     (AND (|has| 6 (|OrderedSet|))
                                          (|has| 6 (|IntegralDomain|))))
                                   '((|complexNumericIfCan|
                                      ((|Union| (|Complex| (|Float|)) "failed")
                                       (|Expression| (|Complex| |#1|))))
                                     (AND (|has| 6 (|OrderedSet|))
                                          (|has| 6 (|IntegralDomain|))))
                                   '((|complexNumericIfCan|
                                      ((|Union| (|Complex| (|Float|)) "failed")
                                       (|Expression| (|Complex| |#1|))
                                       (|PositiveInteger|)))
                                     (AND (|has| 6 (|OrderedSet|))
                                          (|has| 6 (|IntegralDomain|)))))
                             (LIST) NIL NIL)))
                        (|makeByteWordVec2| 97
                                            '(1 8 7 0 9 1 0 10 11 12 1 0 13 8
                                              14 2 0 10 11 15 16 2 0 13 8 15 17
                                              1 19 18 0 20 1 0 23 19 24 1 0 10
                                              6 25 1 0 13 19 26 2 0 10 6 15 27
                                              2 0 13 19 15 28 1 21 15 15 29 2 0
                                              23 19 15 30 1 31 19 0 32 1 31 19
                                              0 33 2 21 0 0 0 34 1 0 23 31 35 2
                                              10 0 0 0 36 1 0 13 31 37 2 0 13
                                              31 15 38 2 0 23 31 15 39 1 40 8 0
                                              41 1 40 8 0 42 1 0 13 40 43 2 0
                                              13 40 15 44 1 6 21 0 45 2 49 46
                                              47 48 50 1 46 23 0 51 1 0 23 48
                                              52 1 11 0 6 53 2 56 54 55 48 57 1
                                              0 13 54 58 1 0 13 48 59 0 21 15
                                              60 1 21 15 15 61 2 0 23 48 15 62
                                              2 0 13 48 15 63 1 11 10 0 64 2 67
                                              65 66 54 68 1 65 13 0 69 2 0 13
                                              54 15 70 2 71 10 47 11 72 1 6 10
                                              0 73 1 10 0 21 74 1 0 10 8 76 2 0
                                              10 8 15 77 1 11 18 0 78 1 0 21 19
                                              79 1 0 10 19 80 2 0 10 19 15 81 2
                                              0 21 19 15 82 1 0 21 31 83 1 0 10
                                              31 84 2 0 10 31 15 85 2 0 21 31
                                              15 86 1 0 10 40 87 2 0 10 40 15
                                              88 1 0 21 48 89 2 91 65 90 48 92
                                              1 0 10 48 93 2 0 21 48 15 94 2 0
                                              10 48 15 95 1 0 10 54 96 2 0 10
                                              54 15 97 2 2 23 48 15 62 1 2 23
                                              48 52 2 1 23 31 15 39 1 1 23 31
                                              35 1 3 23 19 24 2 3 23 19 15 30 1
                                              0 21 6 22 2 0 21 6 15 75 2 2 21
                                              48 15 94 1 2 21 48 89 2 1 21 31
                                              15 86 1 1 21 31 83 1 3 21 19 79 2
                                              3 21 19 15 82 1 2 13 54 58 2 2 13
                                              54 15 70 2 2 13 48 15 63 1 2 13
                                              48 59 1 4 13 8 14 2 4 13 8 15 17
                                              1 1 13 40 43 2 1 13 40 15 44 2 1
                                              13 31 15 38 1 1 13 31 37 2 3 13
                                              19 15 28 1 3 13 19 26 2 0 10 6 15
                                              27 1 0 10 6 25 2 2 10 54 15 97 2
                                              2 10 48 15 95 1 2 10 54 96 1 2 10
                                              48 93 2 4 10 8 15 77 2 4 10 11 15
                                              16 1 4 10 8 76 1 4 10 11 12 1 1
                                              10 40 87 2 1 10 40 15 88 2 1 10
                                              31 15 85 1 1 10 31 84 1 3 10 19
                                              80 2 3 10 19 15 81)))))
           '|lookupComplete|)) 
