
(/VERSIONCHECK 2) 

(DEFUN |SIGNEF;sign;FSOcU;1| (|f| |x| |a| $)
  (COND ((NULL (SPADCALL |f| (QREFELT $ 10))) (CONS 1 "failed"))
        ('T (|SIGNEF;insign| |f| |x| |a| 0 $)))) 

(DEFUN |SIGNEF;sign;FSFSU;2| (|f| |x| |a| |st| $)
  (COND ((NULL (SPADCALL |f| (QREFELT $ 10))) (CONS 1 "failed"))
        ('T (|SIGNEF;psign| |f| |x| |a| |st| 0 $)))) 

(DEFUN |SIGNEF;sign;FU;3| (|f| $)
  (PROG (#1=#:G730 |r| |f2| |mapfun| #2=#:G728 |ud| |un| |u|)
    (RETURN
     (SEQ
      (EXIT
       (COND ((NULL (SPADCALL |f| (QREFELT $ 10))) (CONS 1 "failed"))
             ('T
              (SEQ
               (LETT |u| (SPADCALL |f| (QREFELT $ 18))
                     . #3=(|SIGNEF;sign;FU;3|))
               (EXIT
                (COND ((QEQCAR |u| 0) (SPADCALL (QCDR |u|) (QREFELT $ 21)))
                      (#4='T
                       (SEQ
                        (EXIT
                         (SEQ
                          (SEQ
                           (LETT |un|
                                 (|SIGNEF;smpsign|
                                  (SPADCALL |f| (QREFELT $ 23)) $)
                                 . #3#)
                           (EXIT
                            (COND
                             ((QEQCAR |un| 0)
                              (SEQ
                               (LETT |ud|
                                     (|SIGNEF;smpsign|
                                      (SPADCALL |f| (QREFELT $ 24)) $)
                                     . #3#)
                               (EXIT
                                (COND
                                 ((QEQCAR |ud| 0)
                                  (PROGN
                                   (LETT #2#
                                         (CONS 0 (* (QCDR |un|) (QCDR |ud|)))
                                         . #3#)
                                   (GO #2#))))))))))
                          (COND
                           ((NULL (NULL (SPADCALL |f| (QREFELT $ 26))))
                            (EXIT (CONS 1 "failed"))))
                          (EXIT
                           (COND
                            ((SPADCALL (SPADCALL "rootOf" (QREFELT $ 27))
                                       (SPADCALL (ELT $ 29)
                                                 (SPADCALL |f| (QREFELT $ 31))
                                                 (QREFELT $ 34))
                                       (QREFELT $ 35))
                             (CONS 1 "failed"))
                            (#4#
                             (SEQ
                              (COND
                               ((|HasCategory| (QREFELT $ 6)
                                               (LIST '|ConvertibleTo|
                                                     '(|Float|)))
                                (SEQ
                                 (LETT |mapfun| (CONS #'|SIGNEF;sign;FU;3!0| $)
                                       . #3#)
                                 (LETT |f2|
                                       (SPADCALL |mapfun| |f| (QREFELT $ 43))
                                       . #3#)
                                 (LETT |r| (SPADCALL |f2| (QREFELT $ 45))
                                       . #3#)
                                 (COND
                                  ((QEQCAR |r| 1)
                                   (PROGN
                                    (LETT #1# (CONS 1 "failed") . #3#)
                                    (GO #1#))))
                                 (EXIT
                                  (COND
                                   ((SPADCALL (QCDR |r|) (QREFELT $ 46))
                                    (PROGN
                                     (LETT #1# (CONS 0 -1) . #3#)
                                     (GO #1#)))
                                   ((SPADCALL (QCDR |r|) (QREFELT $ 49))
                                    (PROGN
                                     (LETT #1# (CONS 0 1) . #3#)
                                     (GO #1#)))
                                   ((SPADCALL (QCDR |r|) (QREFELT $ 50))
                                    (PROGN
                                     (LETT #1# (CONS 0 0) . #3#)
                                     (GO #1#)))
                                   (#4# "failed"))))))
                              (EXIT (CONS 1 "failed"))))))))
                        #2# (EXIT #2#)))))))))
      #1# (EXIT #1#))))) 

(DEFUN |SIGNEF;sign;FU;3!0| (|z1| $)
  (SPADCALL (SPADCALL |z1| (QREFELT $ 37)) (QREFELT $ 39))) 

(DEFUN |SIGNEF;overRF| (|a| $)
  (PROG (|u| |n|)
    (RETURN
     (SEQ (LETT |n| (SPADCALL |a| (QREFELT $ 53)) . #1=(|SIGNEF;overRF|))
          (EXIT
           (COND
            ((EQL |n| 0)
             (SEQ
              (LETT |u| (SPADCALL (SPADCALL |a| (QREFELT $ 56)) (QREFELT $ 18))
                    . #1#)
              (EXIT
               (COND ((QEQCAR |u| 1) (CONS 1 "failed"))
                     (#2='T (CONS 0 (SPADCALL (QCDR |u|) (QREFELT $ 58))))))))
            (#2#
             (CONS 0
                   (SPADCALL |n| (SPADCALL (QREFELT $ 59))
                             (QREFELT $ 61)))))))))) 

(DEFUN |SIGNEF;ofesign| (|a| $)
  (PROG (#1=#:G744 |n|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (SEQ (LETT |n| (SPADCALL |a| (QREFELT $ 53)) . #2=(|SIGNEF;ofesign|))
             (EXIT
              (COND
               ((NULL (EQL |n| 0))
                (PROGN (LETT #1# (CONS 0 |n|) . #2#) (GO #1#))))))
        (EXIT (SPADCALL (SPADCALL |a| (QREFELT $ 56)) (QREFELT $ 51)))))
      #1# (EXIT #1#))))) 

(DEFUN |SIGNEF;insign| (|f| |x| |a| |m| $)
  (PROG (|ur| #1=#:G774 |ul| |s| |v| #2=#:G772 |n| |u| |eq| #3=#:G780 |ua|
         |uf|)
    (RETURN
     (SEQ
      (COND ((< 10 |m|) (CONS 1 "failed"))
            (#4='T
             (SEQ
              (EXIT
               (SEQ
                (SEQ
                 (LETT |uf| (SPADCALL |f| (QREFELT $ 18))
                       . #5=(|SIGNEF;insign|))
                 (EXIT
                  (COND
                   ((QEQCAR |uf| 0)
                    (SEQ (LETT |ua| (|SIGNEF;overRF| |a| $) . #5#)
                         (EXIT
                          (COND
                           ((QEQCAR |ua| 0)
                            (PROGN
                             (LETT #3#
                                   (SPADCALL (QCDR |uf|) |x| (QCDR |ua|)
                                             (QREFELT $ 62))
                                   . #5#)
                             (GO #3#))))))))))
                (LETT |eq|
                      (SPADCALL
                       (SPADCALL (SPADCALL |x| (QREFELT $ 63)) (QREFELT $ 64))
                       |a| (QREFELT $ 66))
                      . #5#)
                (LETT |u| (SPADCALL |f| |eq| (QREFELT $ 71)) . #5#)
                (EXIT
                 (COND ((QEQCAR |u| 2) (CONS 1 "failed"))
                       ((QEQCAR |u| 0)
                        (SEQ
                         (EXIT
                          (SEQ
                           (SEQ
                            (LETT |n| (SPADCALL (QCDR |u|) (QREFELT $ 53))
                                  . #5#)
                            (EXIT
                             (COND
                              ((NULL (EQL |n| 0))
                               (PROGN
                                (LETT #2# (CONS 0 |n|) . #5#)
                                (GO #2#))))))
                           (LETT |v| (SPADCALL (QCDR |u|) (QREFELT $ 56))
                                 . #5#)
                           (EXIT
                            (COND
                             ((SPADCALL |v| (|spadConstant| $ 55)
                                        (QREFELT $ 72))
                              (SEQ
                               (LETT |s|
                                     (|SIGNEF;insign|
                                      (SPADCALL |f| |x| (QREFELT $ 73)) |x| |a|
                                      (+ |m| 1) $)
                                     . #5#)
                               (EXIT
                                (COND ((QEQCAR |s| 1) (CONS 1 "failed"))
                                      (#4#
                                       (CONS 0
                                             (-
                                              (SPADCALL (QCDR |s|) |n|
                                                        (QREFELT $ 74)))))))))
                             (#4# (SPADCALL |v| (QREFELT $ 51)))))))
                         #2# (EXIT #2#)))
                       (#4#
                        (COND
                         ((OR (QEQCAR (QCAR (QCDR |u|)) 1)
                              (QEQCAR (QCDR (QCDR |u|)) 1))
                          (CONS 1 "failed"))
                         ('T
                          (SEQ
                           (LETT |ul|
                                 (|SIGNEF;ofesign|
                                  (PROG2
                                      (LETT #1# (QCAR (QCDR |u|)) . #5#)
                                      (QCDR #1#)
                                    (|check-union| (QEQCAR #1# 0)
                                                   (|OrderedCompletion|
                                                    (QREFELT $ 7))
                                                   #1#))
                                  $)
                                 . #5#)
                           (EXIT
                            (COND ((QEQCAR |ul| 1) (CONS 1 "failed"))
                                  (#4#
                                   (SEQ
                                    (LETT |ur|
                                          (|SIGNEF;ofesign|
                                           (PROG2
                                               (LETT #1# (QCDR (QCDR |u|))
                                                     . #5#)
                                               (QCDR #1#)
                                             (|check-union| (QEQCAR #1# 0)
                                                            (|OrderedCompletion|
                                                             (QREFELT $ 7))
                                                            #1#))
                                           $)
                                          . #5#)
                                    (EXIT
                                     (COND
                                      ((OR (QEQCAR |ur| 1)
                                           (NULL
                                            (EQL (QCDR |ul|) (QCDR |ur|))))
                                       (CONS 1 "failed"))
                                      ('T |ul|)))))))))))))))
              #3# (EXIT #3#)))))))) 

(DEFUN |SIGNEF;psign| (|f| |x| |a| |st| |m| $)
  (PROG (|s| |v| #1=#:G795 |n| |u| |eq| #2=#:G796 |ua| |uf|)
    (RETURN
     (SEQ
      (COND ((< 10 |m|) (CONS 1 "failed"))
            ((SPADCALL |f| (|spadConstant| $ 55) (QREFELT $ 72)) (CONS 0 0))
            (#3='T
             (SEQ
              (EXIT
               (SEQ
                (SEQ
                 (LETT |uf| (SPADCALL |f| (QREFELT $ 18))
                       . #4=(|SIGNEF;psign|))
                 (EXIT
                  (COND
                   ((QEQCAR |uf| 0)
                    (SEQ (LETT |ua| (SPADCALL |a| (QREFELT $ 18)) . #4#)
                         (EXIT
                          (COND
                           ((QEQCAR |ua| 0)
                            (PROGN
                             (LETT #2#
                                   (SPADCALL (QCDR |uf|) |x| (QCDR |ua|) |st|
                                             (QREFELT $ 75))
                                   . #4#)
                             (GO #2#))))))))))
                (LETT |eq|
                      (SPADCALL (SPADCALL |x| (QREFELT $ 63)) |a|
                                (QREFELT $ 77))
                      . #4#)
                (LETT |u| (SPADCALL |f| |eq| |st| (QREFELT $ 78)) . #4#)
                (EXIT
                 (COND ((QEQCAR |u| 1) (CONS 1 "failed"))
                       ((QEQCAR |u| 0)
                        (SEQ
                         (EXIT
                          (SEQ
                           (SEQ
                            (LETT |n| (SPADCALL (QCDR |u|) (QREFELT $ 53))
                                  . #4#)
                            (EXIT
                             (COND
                              ((NULL (EQL |n| 0))
                               (PROGN
                                (LETT #1# (CONS 0 |n|) . #4#)
                                (GO #1#))))))
                           (LETT |v| (SPADCALL (QCDR |u|) (QREFELT $ 56))
                                 . #4#)
                           (EXIT
                            (COND
                             ((SPADCALL |v| (|spadConstant| $ 55)
                                        (QREFELT $ 72))
                              (SEQ
                               (LETT |s|
                                     (|SIGNEF;psign|
                                      (SPADCALL |f| |x| (QREFELT $ 73)) |x| |a|
                                      |st| (+ |m| 1) $)
                                     . #4#)
                               (EXIT
                                (COND ((QEQCAR |s| 1) (CONS 1 "failed"))
                                      (#3#
                                       (CONS 0
                                             (* (SPADCALL |st| (QREFELT $ 80))
                                                (QCDR |s|))))))))
                             (#3# (SPADCALL |v| (QREFELT $ 51)))))))
                         #1# (EXIT #1#)))))))
              #2# (EXIT #2#)))))))) 

(DEFUN |SIGNEF;smpsign| (|p| $)
  (PROG (|ans| #1=#:G820 |u| #2=#:G821 |term| |s| |r|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |r| (SPADCALL |p| (QREFELT $ 83)) . #3=(|SIGNEF;smpsign|))
            (EXIT
             (COND ((QEQCAR |r| 0) (SPADCALL (QCDR |r|) (QREFELT $ 84)))
                   (#4='T
                    (SEQ
                     (LETT |u|
                           (SPADCALL
                            (SPADCALL
                             (SPADCALL
                              (LETT |s| (SPADCALL |p| (QREFELT $ 86)) . #3#)
                              (QREFELT $ 88))
                             (QREFELT $ 89))
                            (QREFELT $ 84))
                           . #3#)
                     (EXIT
                      (COND ((QEQCAR |u| 1) (CONS 1 "failed"))
                            (#4#
                             (SEQ (LETT |ans| (QCDR |u|) . #3#)
                                  (SEQ (LETT |term| NIL . #3#)
                                       (LETT #2# (SPADCALL |s| (QREFELT $ 93))
                                             . #3#)
                                       G190
                                       (COND
                                        ((OR (ATOM #2#)
                                             (PROGN
                                              (LETT |term| (CAR #2#) . #3#)
                                              NIL))
                                         (GO G191)))
                                       (SEQ
                                        (EXIT
                                         (COND
                                          ((ODDP (QVELT |term| 2))
                                           (SEQ
                                            (LETT |u|
                                                  (|SIGNEF;sqfrSign|
                                                   (QVELT |term| 1) $)
                                                  . #3#)
                                            (EXIT
                                             (COND
                                              ((QEQCAR |u| 1)
                                               (PROGN
                                                (LETT #1# (CONS 1 "failed")
                                                      . #3#)
                                                (GO #1#)))
                                              ('T
                                               (LETT |ans| (* |ans| (QCDR |u|))
                                                     . #3#)))))))))
                                       (LETT #2# (CDR #2#) . #3#) (GO G190)
                                       G191 (EXIT NIL))
                                  (EXIT (CONS 0 |ans|))))))))))))
      #1# (EXIT #1#))))) 

(DEFUN |SIGNEF;sqfrSign| (|p| $)
  (PROG (|u| |l|)
    (RETURN
     (SEQ
      (LETT |u|
            (|SIGNEF;termSign|
             (|SPADfirst|
              (LETT |l| (SPADCALL |p| (QREFELT $ 95))
                    . #1=(|SIGNEF;sqfrSign|)))
             $)
            . #1#)
      (EXIT
       (COND ((QEQCAR |u| 1) (CONS 1 "failed"))
             ('T (|SIGNEF;listSign| (CDR |l|) (QCDR |u|) $)))))))) 

(DEFUN |SIGNEF;listSign| (|l| |s| $)
  (PROG (#1=#:G833 |u| #2=#:G834 |term|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (SEQ (LETT |term| NIL . #3=(|SIGNEF;listSign|)) (LETT #2# |l| . #3#)
             G190
             (COND
              ((OR (ATOM #2#) (PROGN (LETT |term| (CAR #2#) . #3#) NIL))
               (GO G191)))
             (SEQ (LETT |u| (|SIGNEF;termSign| |term| $) . #3#)
                  (EXIT
                   (COND
                    ((OR (QEQCAR |u| 1) (NULL (EQL |s| (QCDR |u|))))
                     (PROGN (LETT #1# (CONS 1 "failed") . #3#) (GO #1#))))))
             (LETT #2# (CDR #2#) . #3#) (GO G190) G191 (EXIT NIL))
        (EXIT (CONS 0 |s|))))
      #1# (EXIT #1#))))) 

(DEFUN |SIGNEF;termSign| (|term| $)
  (PROG (#1=#:G842 #2=#:G845 #3=#:G840 |vs| #4=#:G846 |lv| |var| |us|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |us| (SPADCALL (SPADCALL |term| (QREFELT $ 96)) (QREFELT $ 84))
              . #5=(|SIGNEF;termSign|))
        (EXIT
         (COND ((QEQCAR |us| 1) (CONS 1 "failed"))
               ('T
                (SEQ
                 (SEQ
                  (EXIT
                   (SEQ (LETT |var| NIL . #5#)
                        (LETT #4#
                              (LETT |lv| (SPADCALL |term| (QREFELT $ 98))
                                    . #5#)
                              . #5#)
                        G190
                        (COND
                         ((OR (ATOM #4#)
                              (PROGN (LETT |var| (CAR #4#) . #5#) NIL))
                          (GO G191)))
                        (SEQ
                         (EXIT
                          (COND
                           ((ODDP (SPADCALL |term| |var| (QREFELT $ 101)))
                            (PROGN
                             (LETT #1#
                                   (SEQ
                                    (EXIT
                                     (SEQ
                                      (COND
                                       ((NULL (CDR |lv|))
                                        (SEQ
                                         (LETT |vs|
                                               (|SIGNEF;kerSign|
                                                (|SPADfirst| |lv|) $)
                                               . #5#)
                                         (EXIT
                                          (COND
                                           ((QEQCAR |vs| 0)
                                            (PROGN
                                             (LETT #3#
                                                   (PROGN
                                                    (LETT #2#
                                                          (CONS 0
                                                                (* (QCDR |us|)
                                                                   (QCDR
                                                                    |vs|)))
                                                          . #5#)
                                                    (GO #2#))
                                                   . #5#)
                                             (GO #3#))))))))
                                      (EXIT
                                       (PROGN
                                        (LETT #2# (CONS 1 "failed") . #5#)
                                        (GO #2#)))))
                                    #3# (EXIT #3#))
                                   . #5#)
                             (GO #1#))))))
                        (LETT #4# (CDR #4#) . #5#) (GO G190) G191 (EXIT NIL)))
                  #1# (EXIT #1#))
                 (EXIT (CONS 0 (QCDR |us|)))))))))
      #2# (EXIT #2#))))) 

(DEFUN |SIGNEF;kerSign| (|k| $)
  (PROG (|s| |arg| |op|)
    (RETURN
     (SEQ (LETT |op| (SPADCALL |k| (QREFELT $ 102)) . #1=(|SIGNEF;kerSign|))
          (COND
           ((OR (SPADCALL |op| '|pi| (QREFELT $ 103))
                (OR (SPADCALL |op| '|exp| (QREFELT $ 103))
                    (OR (SPADCALL |op| '|cosh| (QREFELT $ 103))
                        (SPADCALL |op| '|sech| (QREFELT $ 103)))))
            (EXIT (CONS 0 1))))
          (EXIT
           (COND
            ((NULL (LETT |arg| (SPADCALL |k| (QREFELT $ 105)) . #1#))
             (CONS 1 "failed"))
            (#2='T
             (SEQ
              (LETT |s| (SPADCALL (|SPADfirst| |arg|) (QREFELT $ 51)) . #1#)
              (EXIT
               (COND
                ((QEQCAR |s| 1)
                 (COND
                  ((SPADCALL |op| (SPADCALL "nthRoot" (QREFELT $ 27))
                             (QREFELT $ 103))
                   (COND
                    ((SPADCALL
                      (SPADCALL (SPADCALL |arg| (QREFELT $ 106))
                                (QREFELT $ 107))
                      (QREFELT $ 108))
                     (CONS 0 1))
                    (#2# (CONS 1 "failed"))))
                  (#2# (CONS 1 "failed"))))
                ((SPADCALL |op| (SPADCALL "log" (QREFELT $ 27))
                           (QREFELT $ 103))
                 (COND ((< (QCDR |s|) 0) (CONS 1 "failed"))
                       (#2#
                        (SPADCALL
                         (SPADCALL (|SPADfirst| |arg|) (|spadConstant| $ 48)
                                   (QREFELT $ 109))
                         (QREFELT $ 51)))))
                ((OR
                  (SPADCALL |op| (SPADCALL "tanh" (QREFELT $ 27))
                            (QREFELT $ 103))
                  (OR
                   (SPADCALL |op| (SPADCALL "sinh" (QREFELT $ 27))
                             (QREFELT $ 103))
                   (OR
                    (SPADCALL |op| (SPADCALL "csch" (QREFELT $ 27))
                              (QREFELT $ 103))
                    (SPADCALL |op| (SPADCALL "coth" (QREFELT $ 27))
                              (QREFELT $ 103)))))
                 |s|)
                ('T
                 (COND
                  ((SPADCALL |op| (SPADCALL "nthRoot" (QREFELT $ 27))
                             (QREFELT $ 103))
                   (COND
                    ((SPADCALL
                      (SPADCALL (SPADCALL |arg| (QREFELT $ 106))
                                (QREFELT $ 107))
                      (QREFELT $ 108))
                     (COND ((< (QCDR |s|) 0) (CONS 1 "failed")) (#2# |s|)))
                    (#2# |s|)))
                  (#2# (CONS 1 "failed")))))))))))))) 

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

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

(MAKEPROP '|ElementaryFunctionSign| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|) (|Boolean|)
              (|TrigonometricManipulations| 6 7) (0 . |real?|)
              (|Union| 60 '"failed") (|Symbol|) (|OrderedCompletion| 7)
              |SIGNEF;sign;FSOcU;1| (|String|) |SIGNEF;sign;FSFSU;2|
              (|Union| 19 '#1="failed") (5 . |retractIfCan|)
              (|Fraction| (|Polynomial| 6)) (|RationalFunctionSign| 6)
              (10 . |sign|) (|SparseMultivariatePolynomial| 6 (|Kernel| $))
              (15 . |numer|) (20 . |denom|) (|List| 12) (25 . |variables|)
              (30 . |coerce|) (|BasicOperator|) (35 . |name|) (|List| 28)
              (40 . |operators|) (|Mapping| 12 28) (|ListFunctions2| 28 12)
              (45 . |map|) (51 . |member?|) (|Float|) (57 . |convert|)
              (|Interval| 36) (62 . |interval|) (|Expression| 38)
              (|Mapping| 38 6) (|FunctionSpaceFunctions2| 6 7 38 40)
              (67 . |map|) (|Union| 38 '#1#) (73 . |retractIfCan|)
              (78 . |negative?|) (83 . |One|) (87 . |One|) (91 . |positive?|)
              (96 . |zero?|) |SIGNEF;sign;FU;3| (|SingleInteger|)
              (101 . |whatInfinity|) (106 . |Zero|) (110 . |Zero|)
              (114 . |retract|) (|OrderedCompletion| 19) (119 . |coerce|)
              (124 . |plusInfinity|) (|Integer|) (128 . *) (134 . |sign|)
              (141 . |coerce|) (146 . |coerce|) (|Equation| 13)
              (151 . |equation|) (|Union| 13 '"failed")
              (|Record| (|:| |leftHandLimit| 67) (|:| |rightHandLimit| 67))
              (|Union| 13 68 '"failed") (|PowerSeriesLimitPackage| 6 7)
              (157 . |limit|) (163 . =) (169 . |differentiate|) (175 . *)
              (181 . |sign|) (|Equation| 7) (189 . |equation|) (195 . |limit|)
              (|ToolsForSign| 6) (202 . |direction|) (|Union| 6 '#1#)
              (|SparseMultivariatePolynomial| 6 100) (207 . |retractIfCan|)
              (212 . |sign|) (|Factored| $) (217 . |squareFree|)
              (|Factored| 82) (222 . |unit|) (227 . |retract|)
              (|Union| '"nil" '"sqfr" '"irred" '"prime")
              (|Record| (|:| |flg| 90) (|:| |fctr| 82) (|:| |xpnt| 60))
              (|List| 91) (232 . |factorList|) (|List| $) (237 . |monomials|)
              (242 . |leadingCoefficient|) (|List| 100) (247 . |variables|)
              (|NonNegativeInteger|) (|Kernel| 7) (252 . |degree|)
              (258 . |operator|) (263 . |is?|) (|List| 7) (269 . |argument|)
              (274 . |second|) (279 . |retract|) (284 . |even?|) (289 . -))
           '#(|sign| 295) 'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 109
                                                 '(1 9 8 7 10 1 7 17 0 18 1 20
                                                   11 19 21 1 7 22 0 23 1 7 22
                                                   0 24 1 7 25 0 26 1 12 0 15
                                                   27 1 28 12 0 29 1 7 30 0 31
                                                   2 33 25 32 30 34 2 25 8 12 0
                                                   35 1 6 36 0 37 1 38 0 36 39
                                                   2 42 40 41 7 43 1 40 44 0 45
                                                   1 38 8 0 46 0 6 0 47 0 7 0
                                                   48 1 38 8 0 49 1 38 8 0 50 1
                                                   13 52 0 53 0 6 0 54 0 7 0 55
                                                   1 13 7 0 56 1 57 0 19 58 0
                                                   57 0 59 2 57 0 60 0 61 3 20
                                                   11 19 12 57 62 1 7 0 12 63 1
                                                   13 0 7 64 2 65 0 13 13 66 2
                                                   70 69 7 65 71 2 7 8 0 0 72 2
                                                   7 0 0 12 73 2 52 0 60 0 74 4
                                                   20 11 19 12 19 15 75 2 76 0
                                                   7 7 77 3 70 67 7 76 15 78 1
                                                   79 60 15 80 1 82 81 0 83 1
                                                   79 11 6 84 1 82 85 0 86 1 87
                                                   82 0 88 1 82 6 0 89 1 87 92
                                                   0 93 1 82 94 0 95 1 82 6 0
                                                   96 1 82 97 0 98 2 82 99 0
                                                   100 101 1 100 28 0 102 2 28
                                                   8 0 12 103 1 100 104 0 105 1
                                                   104 7 0 106 1 7 60 0 107 1
                                                   60 8 0 108 2 7 0 0 0 109 1 0
                                                   11 7 51 4 0 11 7 12 7 15 16
                                                   3 0 11 7 12 13 14)))))
           '|lookupComplete|)) 
