
(/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 (|u| |un| |ud| #0=#:G1882 |mapfun| |f2| |r| #1=#:G1884)
    (RETURN
      (SEQ (EXIT (COND
                   ((NULL (SPADCALL |f| (QREFELT $ 10)))
                    (CONS 1 "failed"))
                   ('T
                    (SEQ (LETT |u| (SPADCALL |f| (QREFELT $ 18))
                               . #2=(|SIGNEF;sign;FU;3|))
                         (EXIT (COND
                                 ((QEQCAR |u| 0)
                                  (SPADCALL (QCDR |u|) (QREFELT $ 21)))
                                 ('T
                                  (SEQ (EXIT
                                        (SEQ
                                         (SEQ
                                          (LETT |un|
                                           (|SIGNEF;smpsign|
                                            (SPADCALL |f|
                                             (QREFELT $ 23))
                                            $) . #2#)
                                          (EXIT
                                           (COND
                                             ((QEQCAR |un| 0)
                                              (SEQ
                                               (LETT |ud|
                                                (|SIGNEF;smpsign|
                                                 (SPADCALL |f|
                                                  (QREFELT $ 24))
                                                 $) . #2#)
                                               (EXIT
                                                (COND
                                                  ((QEQCAR |ud| 0)
                                                   (PROGN
                                                     (LETT #0#
                                                      (CONS 0
                                                       (* (QCDR |un|)
                                                        (QCDR |ud|))) . #2#)
                                                     (GO #0#))))))))))
                                         (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"))
                                            ('T
                                             (SEQ
                                              (COND
                                                ((|HasCategory|
                                                  (QREFELT $ 6)
                                                  (LIST
                                                   '|ConvertibleTo|
                                                   '(|Float|)))
                                                 (SEQ
                                                  (LETT |mapfun|
                                                   (CONS
                                                    #'|SIGNEF;sign;FU;3!0|
                                                    $) . #2#)
                                                  (LETT |f2|
                                                   (SPADCALL |mapfun|
                                                    |f| (QREFELT $ 43)) . #2#)
                                                  (LETT |r|
                                                   (SPADCALL |f2|
                                                    (QREFELT $ 45)) . #2#)
                                                  (COND
                                                    ((QEQCAR |r| 1)
                                                     (PROGN
                                                       (LETT #1#
                                                        (CONS 1
                                                         "failed") . #2#)
                                                       (GO #1#))))
                                                  (EXIT
                                                   (COND
                                                     ((SPADCALL
                                                       (QCDR |r|)
                                                       (QREFELT $ 46))
                                                      (PROGN
                                                        (LETT #1#
                                                         (CONS 0 -1) . #2#)
                                                        (GO #1#)))
                                                     ((SPADCALL
                                                       (QCDR |r|)
                                                       (QREFELT $ 49))
                                                      (PROGN
                                                        (LETT #1#
                                                         (CONS 0 1) . #2#)
                                                        (GO #1#)))
                                                     ((SPADCALL
                                                       (QCDR |r|)
                                                       (QREFELT $ 50))
                                                      (PROGN
                                                        (LETT #1#
                                                         (CONS 0 0) . #2#)
                                                        (GO #1#)))
                                                     ('T "failed"))))))
                                              (EXIT (CONS 1 "failed"))))))))
                                       #0# (EXIT #0#)))))))))
           #1# (EXIT #1#))))) 

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

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

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

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

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

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

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

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

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

(DEFUN |SIGNEF;kerSign| (|k| $)
  (PROG (|op| |arg| |s|)
    (RETURN
      (SEQ (LETT |op| (SPADCALL |k| (QREFELT $ 102))
                 . #0=(|SIGNEF;kerSign|))
           (COND
             ((OR (SPADCALL |op| (SPADCALL "pi" (QREFELT $ 27))
                      (QREFELT $ 103))
                  (OR (SPADCALL |op| (SPADCALL "exp" (QREFELT $ 27))
                          (QREFELT $ 103))
                      (OR (SPADCALL |op|
                              (SPADCALL "cosh" (QREFELT $ 27))
                              (QREFELT $ 103))
                          (SPADCALL |op|
                              (SPADCALL "sech" (QREFELT $ 27))
                              (QREFELT $ 103)))))
              (EXIT (CONS 0 1))))
           (EXIT (COND
                   ((NULL (LETT |arg|
                                (SPADCALL |k| (QREFELT $ 105)) . #0#))
                    (CONS 1 "failed"))
                   ('T
                    (SEQ (LETT |s|
                               (SPADCALL (|SPADfirst| |arg|)
                                   (QREFELT $ 51)) . #0#)
                         (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))
                                       ('T (CONS 1 "failed"))))
                                    ('T (CONS 1 "failed"))))
                                 ((SPADCALL |op|
                                      (SPADCALL "log" (QREFELT $ 27))
                                      (QREFELT $ 103))
                                  (COND
                                    ((< (QCDR |s|) 0)
                                     (CONS 1 "failed"))
                                    ('T
                                     (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"))
                                          ('T |s|)))
                                       ('T |s|)))
                                    ('T (CONS 1 "failed")))))))))))))) 

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

(DEFUN |ElementaryFunctionSign;| (|#1| |#2|)
  (PROG (DV$1 DV$2 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #0=(|ElementaryFunctionSign|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT |dv$| (LIST '|ElementaryFunctionSign| DV$1 DV$2) . #0#)
        (LETT $ (GETREFV 110) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|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 '"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 '"failed") (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 '"failed")
             (|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|)) 
